Compare commits

...
Author SHA1 Message Date
BaaRai 8c9c1fc0ab feat(findings): optional counterevidence and confidence_rationale
Add two optional free-text fields to findings so a reporter can record
what was tested and did not work (counterevidence) and why the
conclusion holds (confidence_rationale).

- db: idempotent ADD COLUMN IF NOT EXISTS, TEXT NOT NULL DEFAULT '',
  no CHECK; RecordFindingInput, the INSERT, the shared select list and
  all three scan sites carry them.
- agent: report_finding accepts both as optional strings; the worker
  and pentest prompts say to fill them when confidence is not high.
- server: FindingDTO (list and detail) carries both, omitted when empty;
  existing databases get the two schema properties added to the stored
  report_finding row once, without overwriting user edits.
- web: the finding detail page shows each section only when non-empty.

Both fields stay optional: a missing field never refuses a finding.
2026-11-11 23:43:12 +01:00
BaaRai a1f3256cf6 Merge pull request #190 from BaaRai/feat/agentic-guards
Agentic guards: goal_met/prove_goal, hint origin, built-in rules for planner Bash (#124 F5, F6, F11)
2026-11-11 22:53:54 +01:00
BaaRai 4bcb6d7250 Add agentic guards for goals, hint origin and planner Bash (F5, F6, F11)
Audit findings F5, F6 and F11 for issue #124.

F5, goal guards:
- goal_met refuses while any goal node of the task is open, and when the
  goals cannot be read. A task without goal nodes keeps the old behavior.
- prove_goal accepts a fact as evidence only when its confidence is
  "observed"; otherwise it refuses and the goal stays open. Findings are
  still accepted.

F6, hint origin:
- add_hint stores the calling ToolSet's worker as the hint origin instead
  of "human", and passes it to the planner trigger (TriggerEvent.HintOrigin).
- renderTriggers names the writer: the human via the main agent, a
  cross-task orchestration, or an agent, with a neutral fallback.

F11, built-in rules for the planner and the main agent:
- Interceptor.MatchBuiltin evaluates the enabled "[built-in]" deny rules on
  the intercept-enabled tools.
- The target-only guard applies them before the target gate, whether the
  gate is on or off. User rules and the judge stay out of it.
- SetRulesForTest is a test seam for the store-less guard tests; Log is a
  no-op without a store.
2026-11-11 22:39:13 +01:00
BaaRai 2945f58b01 Merge pull request #189 from BaaRai/feat/agentic-prompt-hardening
agent: code-owned prompt-injection tails and planner goal anchor (#124, part 1)
2026-11-11 22:11:40 +01:00
21 changed files with 731 additions and 48 deletions
+177
View File
@@ -0,0 +1,177 @@
package agent
import (
"context"
"encoding/json"
"strconv"
"strings"
"testing"
"github.com/Autumn-27/artex/db"
actool "github.com/Autumn-27/norma/tool"
)
// guardTaskStore creates a throwaway task (PG) and returns its exploration store.
// It has no goal node until the test adds one.
func guardTaskStore(t *testing.T) *db.ExplorationStore {
t.Helper()
d := testDB(t)
t.Cleanup(func() { _ = d.Close() })
task, err := d.CreateTaskWithOptions("agentic guards", "exercise the goal and hint guards", db.TaskCreateOptions{})
if err != nil {
t.Fatal(err)
}
t.Cleanup(func() { _ = d.DeleteTask(task.ID) })
return d.Exploration(task.ExplorationID)
}
func callGuardTool(t *testing.T, tool actool.CoreTool, input string) actool.Result {
t.Helper()
res, err := tool.Call(context.Background(), json.RawMessage(input), nil)
if err != nil {
t.Fatalf("%s: transport error: %v", tool.Name(), err)
}
return res
}
func addGuardNode(t *testing.T, s *db.ExplorationStore, kind string, payload map[string]any, state string) int64 {
t.Helper()
id, err := s.AddNode(kind, payload, 0, state, "worker-1", nil)
if err != nil {
t.Fatal(err)
}
return id
}
func nodeState(t *testing.T, s *db.ExplorationStore, id int64) string {
t.Helper()
n, err := s.GetNode(id)
if err != nil || n == nil {
t.Fatalf("node %d: %v", id, err)
}
return n.State
}
// goal_met refuses while a goal node is open, and ends the task once every goal
// is met (#124, F5).
func TestGoalMetRefusesWhileGoalsOpen(t *testing.T) {
s := guardTaskStore(t)
open := addGuardNode(t, s, db.KindGoal, map[string]any{"text": "read the admin panel"}, "open")
addGuardNode(t, s, db.KindGoal, map[string]any{"text": "list the users"}, "met")
tsx := NewToolSet(s, "planner")
res := callGuardTool(t, tsx.goalMet(), `{"reason":"the data says we are done"}`)
if !res.IsError || !strings.Contains(res.Flatten(), "1 of 2 goals") || !strings.Contains(res.Flatten(), "prove_goal") {
t.Fatalf("open goal: want a refusal naming the open goals and prove_goal, got IsError=%v %q", res.IsError, res.Flatten())
}
if tsx.GoalMet {
t.Fatal("goal_met set GoalMet while a goal is open")
}
if err := s.SetNodeState(open, "met"); err != nil {
t.Fatal(err)
}
res = callGuardTool(t, tsx.goalMet(), `{"reason":"both goals proven"}`)
if res.IsError || !tsx.GoalMet || tsx.Reason != "both goals proven" {
t.Fatalf("all goals met: IsError=%v GoalMet=%v reason=%q %q", res.IsError, tsx.GoalMet, tsx.Reason, res.Flatten())
}
}
// A task without goal nodes keeps the old goal_met behavior.
func TestGoalMetWithoutGoalNodes(t *testing.T) {
tsx := NewToolSet(guardTaskStore(t), "planner")
res := callGuardTool(t, tsx.goalMet(), `{"reason":"task goal reached"}`)
if res.IsError || !tsx.GoalMet {
t.Fatalf("no goal node: IsError=%v GoalMet=%v %q", res.IsError, tsx.GoalMet, res.Flatten())
}
}
// prove_goal accepts a fact only when its confidence is observed; a finding is
// still accepted (#124, F5).
func TestProveGoalRequiresObservedFact(t *testing.T) {
s := guardTaskStore(t)
goalA := addGuardNode(t, s, db.KindGoal, map[string]any{"text": "get admin"}, "open")
goalB := addGuardNode(t, s, db.KindGoal, map[string]any{"text": "dump the users"}, "open")
inferred := addGuardNode(t, s, db.KindFact, map[string]any{"summary": "admin is probably reachable", "confidence": "inferred"}, "confirmed")
unlabeled := addGuardNode(t, s, db.KindFact, map[string]any{"summary": "admin reachable"}, "confirmed")
observed := addGuardNode(t, s, db.KindFact, map[string]any{"summary": "logged in as admin", "confidence": " Observed "}, "confirmed")
finding := addGuardNode(t, s, db.KindFinding, map[string]any{"summary": "user table dumped"}, "confirmed")
tsx := NewToolSet(s, "planner")
prove := func(goal, ev int64) actool.Result {
return callGuardTool(t, tsx.proveGoal(), `{"goal_id":`+strconv.FormatInt(goal, 10)+`,"evidence_id":`+strconv.FormatInt(ev, 10)+`,"reason":"x"}`)
}
for name, ev := range map[string]int64{"inferred": inferred, "unlabeled": unlabeled} {
res := prove(goalA, ev)
if !res.IsError || !strings.Contains(res.Flatten(), "observed") || !strings.Contains(res.Flatten(), "stays open") {
t.Fatalf("%s fact: want a refusal, got IsError=%v %q", name, res.IsError, res.Flatten())
}
if st := nodeState(t, s, goalA); st != "open" {
t.Fatalf("%s fact: goal state %q, want open", name, st)
}
}
if tsx.GoalMet {
t.Fatal("a refused proof set GoalMet")
}
if res := prove(goalA, observed); res.IsError || nodeState(t, s, goalA) != "met" {
t.Fatalf("observed fact: IsError=%v state=%q %q", res.IsError, nodeState(t, s, goalA), res.Flatten())
}
if tsx.GoalMet {
t.Fatal("GoalMet set while goal B is open")
}
if res := prove(goalB, finding); res.IsError || nodeState(t, s, goalB) != "met" || !tsx.GoalMet {
t.Fatalf("finding: IsError=%v state=%q GoalMet=%v %q", res.IsError, nodeState(t, s, goalB), tsx.GoalMet, res.Flatten())
}
}
// add_hint stores the calling ToolSet as the hint's origin and passes it to the
// trigger (#124, F6): an orchestrator hint is not labelled human, and the main
// agent (worker "human") still is.
func TestAddHintRecordsOrigin(t *testing.T) {
s := guardTaskStore(t)
for _, origin := range []string{"orchestrator", "human"} {
tsx := NewToolSet(s, origin)
var gotOrigin string
var gotTexts []string
tsx.SetNotifyHint(func(o string, texts []string) { gotOrigin, gotTexts = o, texts })
res := callGuardTool(t, tsx.AddHintTool(), `{"text":"focus on the export endpoint"}`)
out := res.Flatten()
if res.IsError || !strings.HasPrefix(out, "hint added: ") {
t.Fatalf("%s: add_hint failed: %q", origin, out)
}
id, err := strconv.ParseInt(strings.TrimPrefix(out, "hint added: "), 10, 64)
if err != nil {
t.Fatalf("%s: hint id in %q: %v", origin, out, err)
}
n, err := s.GetNode(id)
if err != nil || n == nil || n.Kind != db.KindHint || n.Origin != origin {
t.Fatalf("%s: hint node %+v err=%v, want origin %q", origin, n, err, origin)
}
if gotOrigin != origin || len(gotTexts) != 1 || gotTexts[0] != "focus on the export endpoint" {
t.Fatalf("%s: trigger got origin=%q texts=%v", origin, gotOrigin, gotTexts)
}
}
}
// renderTriggers names the writer of a hint from its origin; only the main agent
// is "the human" (#124, F6). The hint case never reads the store.
func TestRenderTriggersHintOrigin(t *testing.T) {
ts := &db.ExplorationStore{}
for origin, want := range map[string]string{
"human": "- The human (via the main agent) added a strategic hint: h1",
"orchestrator": "- A cross-task orchestration added a strategic hint: h1",
"worker-3": "- An agent (worker-3) added a strategic hint: h1",
"": "- A source that was not recorded added a strategic hint: h1",
} {
got := renderTriggers(ts, []TriggerEvent{{Kind: "hint", Hints: []string{"h1"}, HintOrigin: origin}})
if !strings.Contains(got, want) || strings.Contains(got, "The human (main agent)") {
t.Errorf("origin %q: got %q, want %q", origin, got, want)
}
}
got := renderTriggers(ts, []TriggerEvent{{Kind: "hint", Hints: []string{"h1", "h2"}, HintOrigin: "orchestrator"}})
if !strings.Contains(got, "- A cross-task orchestration added 2 strategic hints: h1; h2") {
t.Errorf("batch: got %q", got)
}
}
+70
View File
@@ -0,0 +1,70 @@
package agent
import (
"encoding/json"
"slices"
"strings"
"testing"
"github.com/Autumn-27/artex/db"
)
// Pure: report_finding advertises counterevidence / confidence_rationale as
// optional string properties.
func TestReportFindingSchemaReasoningFieldsOptional(t *testing.T) {
schema := NewToolSet(nil, "").addFinding().InputSchema()
props, _ := schema["properties"].(map[string]any)
required, _ := schema["required"].([]string)
if !slices.Contains(required, "vulnclass") {
t.Fatalf("unexpected required list shape: %#v", schema["required"])
}
for _, name := range []string{"counterevidence", "confidence_rationale"} {
p, ok := props[name].(map[string]any)
if !ok {
t.Fatalf("report_finding schema missing %s", name)
}
if p["type"] != "string" {
t.Fatalf("%s type = %v, want string", name, p["type"])
}
if desc, _ := p["description"].(string); !strings.HasPrefix(desc, "optional") {
t.Fatalf("%s description should say optional: %q", name, desc)
}
if slices.Contains(required, name) {
t.Fatalf("%s must not be required: %v", name, required)
}
}
}
// PG: the tool passes both fields into storage, and omitting them never blocks
// a finding.
func TestReportFindingStoresReasoningFields(t *testing.T) {
d := testDB(t)
defer d.Close()
task, err := d.CreateTask("reasoning fields", "fixture", nil, 0, 0)
if err != nil {
t.Fatal(err)
}
defer d.DeleteTask(task.ID)
ts := NewToolSet(nil, "")
ts.ts, ts.taskID = d.Exploration(task.ExplorationID), task.ID
for _, tc := range []struct{ extra, counter, rationale string }{
{`,"counterevidence":"WAF blocked 4 of 5 encodings","confidence_rationale":"the 5th returned the other tenant's row"`, "WAF blocked 4 of 5 encodings", "the 5th returned the other tenant's row"},
{"", "", ""},
} {
res, err := ts.addFinding().Call(t.Context(), json.RawMessage(`{"vulnclass":"SQLI","severity":"high","summary":"reasoning fixture","evidence":"output"`+tc.extra+`}`), nil)
if err != nil || !strings.HasPrefix(res.Flatten(), "finding recorded: ") {
t.Fatalf("report_finding rejected: %v %s", err, res.Flatten())
}
var out db.RecordedFinding
if err := json.Unmarshal([]byte(strings.SplitN(res.Flatten(), "\n", 2)[1]), &out); err != nil {
t.Fatal(err)
}
f, err := d.GetFinding(out.FindingID)
if err != nil || f == nil {
t.Fatalf("GetFinding: %v %v", f, err)
}
if f.Counterevidence != tc.counter || f.ConfidenceRationale != tc.rationale {
t.Fatalf("stored (%q, %q), want (%q, %q)", f.Counterevidence, f.ConfidenceRationale, tc.counter, tc.rationale)
}
}
}
+2 -2
View File
@@ -111,7 +111,7 @@ func mainAgentSystem(goal, dataDir, workDir string) string {
// text / result) so the main-agent session shows its work — exactly like the
// worker/planner sessions — not just the final answer. hooks (the task's
// target-only Guard) sees every tool call; may be nil.
func (m *MainAgent) Chat(ctx context.Context, taskID int64, mainSeg int, as *db.AssetStore, ts *db.ExplorationStore, goal, message string, hooks harness.HookRunner, emit func(db.Activity), notify, resume func(), notifyGoal, notifyHint func([]string)) (string, error) {
func (m *MainAgent) Chat(ctx context.Context, taskID int64, mainSeg int, as *db.AssetStore, ts *db.ExplorationStore, goal, message string, hooks harness.HookRunner, emit func(db.Activity), notify, resume func(), notifyGoal func([]string), notifyHint func(string, []string)) (string, error) {
tsx := NewToolSet(ts, "human")
tsx.SetFindingRecorder(m.findingRecorder)
if as != nil {
@@ -122,7 +122,7 @@ func (m *MainAgent) Chat(ctx context.Context, taskID int64, mainSeg int, as *db.
tsx.SetNotify(notify) // generic wake-up (write ops without a dedicated callback go through it, debounced)
tsx.SetResumeTask(resume) // set_goals adds a goal → pull a completed/paused task back to running
tsx.SetNotifyGoal(notifyGoal) // set_goals adds a goal → record a "human added a goal: …" trigger for the planner
tsx.SetNotifyHint(notifyHint) // add_hint adds hints → record a "human added N strategic hints: …" trigger for the planner
tsx.SetNotifyHint(notifyHint) // add_hint adds hints → record a "human added N strategic hints: …" trigger for the planner (origin "human")
tsx.steerWork = m.steerWork // enable steer_work tool (nil = unavailable)
// domain tools + basic default toolset (Read/Write/Edit/MultiEdit/LS/Glob/Grep/Bash)
// when the asset coverage feature is off, drop add_task_scope/list_untested_assets (not in the prompt).
+24 -2
View File
@@ -195,6 +195,9 @@ func plannerGoalAnchor(goal, constraints string) string {
// "cancelled" — the human deleted intent IntentID (Detail = the deletion reason).
// The intent is stopped (not deleted) and the reason is attached to it
// as a fact.
// "hint" — one add_hint call added one OR MORE hints (Hints = the hint texts;
// HintOrigin = who wrote them: "human" via the main agent,
// "orchestrator" for cross-task orchestration, otherwise an agent name).
type TriggerEvent struct {
Kind string
IntentID int64
@@ -204,6 +207,25 @@ type TriggerEvent struct {
OldGoal string // Kind=="goal_edited" only: the goal text before the edit
NewGoal string // Kind=="goal_edited" only: the goal text after the edit
Hints []string // Kind=="hint" only: the hint texts added by this add_hint call (one or more)
// HintOrigin is the writer of the hints (Kind=="hint" only): the origin stored
// on the hint nodes. Empty when unknown.
HintOrigin string
}
// hintAuthor names the writer of a hint for the planner, from its stored origin.
// Only the main-agent chat writes as "human"; the other writers are named as
// what they are, so an agent-written hint is not read as an operator instruction.
func hintAuthor(origin string) string {
switch origin {
case "human":
return "The human (via the main agent)"
case "orchestrator":
return "A cross-task orchestration"
case "":
return "A source that was not recorded"
default:
return "An agent (" + origin + ")"
}
}
// renderTriggers spells out the change(s) that fired this round: for a finished
@@ -226,9 +248,9 @@ func renderTriggers(ts *db.ExplorationStore, evs []TriggerEvent) string {
}
case "hint":
if len(ev.Hints) == 1 {
b.WriteString(fmt.Sprintf("\n- The human (main agent) added a strategic hint: %s — already attached to the exploration graph; please adjust/add exploration directions accordingly (if no corresponding intent exists yet).", ev.Hints[0]))
b.WriteString(fmt.Sprintf("\n- %s added a strategic hint: %s — already attached to the exploration graph; please adjust/add exploration directions accordingly (if no corresponding intent exists yet).", hintAuthor(ev.HintOrigin), ev.Hints[0]))
} else {
b.WriteString(fmt.Sprintf("\n- The human (main agent) added %d strategic hints: %s — all are attached to the exploration graph; please adjust/add exploration directions accordingly, one by one.", len(ev.Hints), strings.Join(ev.Hints, "; ")))
b.WriteString(fmt.Sprintf("\n- %s added %d strategic hints: %s — all are attached to the exploration graph; please adjust/add exploration directions accordingly, one by one.", hintAuthor(ev.HintOrigin), len(ev.Hints), strings.Join(ev.Hints, "; ")))
}
case "goal_deleted":
b.WriteString(fmt.Sprintf("\n- The human deleted this goal: %s — the goal has been removed; re-judge the remaining goals/directions accordingly (no need to dispatch intents for it anymore).", ev.Detail))
+1 -1
View File
@@ -56,7 +56,7 @@ const pentestDefaultTmpl = `You are the "solo pentest agent" of an authorized pe
- Land every result **immediately**; don't save it for the end (if the session's step budget runs out, everything unrecorded is lost; only what's recorded counts — what lives in your head doesn't). These records are also your long-term memory against compaction.
- **Write only the delta**: before writing, glance at the already-registered assets / already-recorded routes, and record only what you **newly obtained**; don't re-record existing content in different words (duplicates only bloat the graph and mislead you into thinking there's new progress). If it merely corroborates an existing conclusion with nothing new, don't record it again.
- **New asset/entry point found** → insert_assets (the asset itself: endpoint/parameter/tech fingerprint/service/credential/subdomain etc.; structured attributes go on the asset's props). Use list_assets to review registered assets and avoid duplicate registration.
- **Confirmed vulnerability** → report_finding (with a reproducible PoC). **Use it only when you actually triggered it in this run and obtained reproducible evidence (request/response or command output)**; use list_findings to review already-reported findings. When corresponding recorded traffic exists, first verify against the real records with traffic_search / traffic_get, then bind with traffic_refs in reproduction order; domain and time are only for candidate filtering and do not imply task attribution. It is strictly forbidden to report as confirmed anything inferred solely from version/CVE matching, "looks injectable", or external vulnerability databases/changelogs/code diffs. **Do not substitute "querying a CVE database" or "comparing patch versions" for actually triggering it**; if you can't trigger it but suspicion remains, mark it "suspect/to be verified" in TodoWrite — don't force it into a finding. Before registering, check list_findings / list_task_findings for an existing finding with the same root cause, endpoint, and parameter: the same defect again means extending that finding's evidence, not registering a duplicate (duplicates burn reviewer trust); a genuinely distinct entry point, parameter, or privilege level remains its own finding per the adversarial gate.
- **Confirmed vulnerability** → report_finding (with a reproducible PoC). **Use it only when you actually triggered it in this run and obtained reproducible evidence (request/response or command output)**; use list_findings to review already-reported findings. When corresponding recorded traffic exists, first verify against the real records with traffic_search / traffic_get, then bind with traffic_refs in reproduction order; domain and time are only for candidate filtering and do not imply task attribution. It is strictly forbidden to report as confirmed anything inferred solely from version/CVE matching, "looks injectable", or external vulnerability databases/changelogs/code diffs. **Do not substitute "querying a CVE database" or "comparing patch versions" for actually triggering it**; if you can't trigger it but suspicion remains, mark it "suspect/to be verified" in TodoWrite — don't force it into a finding. Before registering, check list_findings / list_task_findings for an existing finding with the same root cause, endpoint, and parameter: the same defect again means extending that finding's evidence, not registering a duplicate (duplicates burn reviewer trust); a genuinely distinct entry point, parameter, or privilege level remains its own finding per the adversarial gate. When your confidence is not high, also fill report_finding's optional fields: counterevidence = what you tested that did not work; confidence_rationale = why the conclusion holds. Both are optional and never block reporting.
Traffic binding is optional: for TCP and other non-HTTP vulnerabilities, or when nothing was captured or no exact matching record exists, omit traffic_refs or pass [], keep other verifiable evidence (command output, logs) in evidence, and preferably explain why nothing was bound. Don't guess IDs, and don't re-probe just to pad the packet count.
+52 -17
View File
@@ -187,13 +187,14 @@ type ToolSet struct {
// agent; nil for the goals decomposer (round-0 has no running planner to inform)
// and workers → those fall back to the bare notify.
notifyGoal func(texts []string)
// notifyHint, if set, wakes the planner AND records ONE "human added N strategic
// notifyHint, if set, wakes the planner AND records ONE "<origin> added N strategic
// hints: …" trigger for a whole add_hint call (batch-aware — one call, one
// trigger) so the next round is told the round was fired by a new hint and spells
// the hint out, instead of the planner having to spot it folded into the graph
// overview. Wired for the main agent + cross-task orchestration; nil elsewhere →
// falls back to the bare notify.
notifyHint func(texts []string)
// overview. origin is the ToolSet's worker (human, orchestrator, or an agent name).
// Wired for the main agent + cross-task orchestration; nil elsewhere → falls back
// to the bare notify.
notifyHint func(origin string, texts []string)
}
// SetNotifyGoal wires the goal-add trigger callback (see ToolSet.notifyGoal). Set only
@@ -203,7 +204,7 @@ func (t *ToolSet) SetNotifyGoal(fn func([]string)) { t.notifyGoal = fn }
// SetNotifyHint wires the hint-add trigger callback (see ToolSet.notifyHint). Set by
// the main-agent chat and cross-task orchestration, so a runtime-added hint fires a
// planner round announced by name instead of a bare wake.
func (t *ToolSet) SetNotifyHint(fn func([]string)) { t.notifyHint = fn }
func (t *ToolSet) SetNotifyHint(fn func(string, []string)) { t.notifyHint = fn }
// SetResumeTask wires the task-revive callback (see ToolSet.resumeTask). Set only by
// the main-agent chat, so runtime-added goals can pull a finished task back to running.
@@ -1288,7 +1289,7 @@ func (t *ToolSet) listGoals() actool.CoreTool {
}
func (t *ToolSet) proveGoal() actool.CoreTool {
return t.writeExpTool("prove_goal", "Call when you judge that a finding/fact proves a goal met: links the evidence node to the goal node and marks the goal met.",
return t.writeExpTool("prove_goal", "Call when you judge that a finding/fact proves a goal met: links the evidence node to the goal node and marks the goal met. A fact counts as evidence only when its confidence is observed; an inferred fact is refused and the goal stays open.",
obj(map[string]any{
"goal_id": idp("goal node id"),
"evidence_id": idp("id of the finding/fact node that proves it"),
@@ -1313,6 +1314,20 @@ func (t *ToolSet) proveGoal() actool.CoreTool {
if err != nil || evidenceNode == nil || (evidenceNode.Kind != db.KindFact && evidenceNode.Kind != db.KindFinding) {
return actool.Errorf("evidence_id must be a fact/finding node of this task or a directly related task"), nil
}
// A fact proves a goal only when it was seen directly (#124, F5): an inferred
// conclusion, or one without a confidence, is refused and the goal stays open.
// The confidence is declared by the agent that recorded the fact.
if evidenceNode.Kind == db.KindFact {
var fp map[string]any
_ = json.Unmarshal(evidenceNode.Payload, &fp)
confidence, _ := fp["confidence"].(string)
if strings.ToLower(strings.TrimSpace(confidence)) != "observed" {
if confidence == "" {
confidence = "none"
}
return actool.Errorf(fmt.Sprintf("prove_goal refused: fact %d has confidence %q, and a fact proves a goal only when its confidence is \"observed\" (seen directly in tool output). Goal %d stays open: prove it with a finding or with an observed fact.", ev, confidence, goal)), nil
}
}
_ = t.ts.Link(ev, db.RelProves, goal)
_ = t.ts.SetNodeState(goal, "met")
// Each time a goal is marked met, check whether [all goals] of this task are
@@ -1337,11 +1352,26 @@ func (t *ToolSet) proveGoal() actool.CoreTool {
}
func (t *ToolSet) goalMet() actool.CoreTool {
return writeTool("goal_met", "[End the entire task immediately] — call only when you are sure [all of the task's goals are truly met and it is complete overall] (note: the task as a [whole]; having met just one goal / one flag / one finding [does not count] — in that case mark that goal with prove_goal). ⚠️ It is NOT for \"ending this planning round\": if there is no new intent to dispatch this round, or you're waiting on worker output, [just end the round — do NOT call this tool] (0 intents is a perfectly normal outcome). Prefer prove_goal to prove goals one by one; goal_met is only a means to skip per-goal proofs and complete the task globally.",
return t.writeExpTool("goal_met", "[End the entire task immediately] — call only when you are sure [all of the task's goals are truly met and it is complete overall] (note: the task as a [whole]; having met just one goal / one flag / one finding [does not count] — in that case mark that goal with prove_goal). ⚠️ It is NOT for \"ending this planning round\": if there is no new intent to dispatch this round, or you're waiting on worker output, [just end the round — do NOT call this tool] (0 intents is a perfectly normal outcome). Prefer prove_goal to prove goals one by one; goal_met is only a means to skip per-goal proofs and complete the task globally.",
obj(map[string]any{"reason": str("grounds for completion (must be evidence that the goals are truly met, not a round-ending reason like 'no new directions this round')")}, "reason"),
func(_ context.Context, in json.RawMessage) (actool.Result, error) {
var a struct{ Reason string }
_ = json.Unmarshal(in, &a)
// goal_met ends the task only when no goal node is open (#124, F5). A task
// without goal nodes keeps the old behavior.
goals, err := t.ts.ListByKind(db.KindGoal, 1000)
if err != nil {
return actool.Errorf("goal_met refused: the goals of this task could not be read (" + err.Error() + "); the task stays open"), nil
}
open := 0
for _, g := range goals {
if g.State != "met" {
open++
}
}
if open > 0 {
return actool.Errorf(fmt.Sprintf("goal_met refused: %d of %d goals of this task are still open; the task stays open. Prove each one with prove_goal(goal_id, evidence_id, reason): the task completes automatically when its last goal is marked met.", open, len(goals))), nil
}
t.GoalMet = true
t.Reason = a.Reason
return actool.Text("acknowledged: goal marked met"), nil
@@ -1358,9 +1388,13 @@ func (t *ToolSet) addFinding() actool.CoreTool {
"evidence_hint_id": idp("optional: the hint node ID in this task corresponding to this finding; automatically carries its structured traffic_refs; cannot reference an inherited hint or another finding's hint"),
"traffic_refs": map[string]any{"type": "array", "description": "optional; for HTTP/HTTPS findings, first search and verify entry by entry that the requests/responses actually support the finding's conclusion, then fill in real IDs in reproduction order. For TCP and other non-HTTP findings, or when nothing was captured or no exact record is found, omit or pass [] — it does not block reporting; explain why in evidence and provide other verifiable evidence. Don't guess IDs, infer association by domain/time, or re-probe just to pad the packet count. Roles: baseline = normal control / proof = vulnerability proof / verification = supplementary verification / supporting = auxiliary evidence.",
"items": obj(map[string]any{"traffic_id": str("a real traffic ID returned by traffic_search"), "role": map[string]any{"type": "string", "enum": []string{"baseline", "proof", "verification", "supporting"}}, "note": str("how this traffic supports the finding's conclusion")}, "traffic_id")},
"counterevidence": str("optional: what you tested that did not work (variants, paths, or bypasses that were blocked or came back negative). Fill it when your confidence is not high; omitting it never blocks reporting."),
"confidence_rationale": str("optional: why the conclusion holds (which observation rules out the benign explanation). Fill it when your confidence is not high; omitting it never blocks reporting."),
}, "vulnclass", "severity", "summary"), func(ctx context.Context, in json.RawMessage) (actool.Result, error) {
var a struct {
VulnClass, Name, Severity, Summary, Evidence string
Counterevidence string `json:"counterevidence"`
ConfidenceRationale string `json:"confidence_rationale"`
IntentID json.RawMessage `json:"intent_id"`
AssetIDs []json.RawMessage `json:"asset_ids"`
TrafficRefs []db.TrafficRef `json:"traffic_refs"`
@@ -1388,7 +1422,7 @@ func (t *ToolSet) addFinding() actool.CoreTool {
if err != nil {
return actool.Errorf(err.Error()), nil
}
input := db.RecordFindingInput{TaskID: t.taskID, ExplorationID: t.ts.ID(), IntentID: pid(a.IntentID), VulnClass: a.VulnClass, Name: a.Name, Severity: a.Severity, Summary: a.Summary, Evidence: a.Evidence, Worker: t.worker, AssetIDs: pidList(a.AssetIDs)}
input := db.RecordFindingInput{TaskID: t.taskID, ExplorationID: t.ts.ID(), IntentID: pid(a.IntentID), VulnClass: a.VulnClass, Name: a.Name, Severity: a.Severity, Summary: a.Summary, Evidence: a.Evidence, Worker: t.worker, AssetIDs: pidList(a.AssetIDs), Counterevidence: a.Counterevidence, ConfidenceRationale: a.ConfidenceRationale}
var recorded *db.RecordedFinding
if t.findingRecorder != nil {
recorded, err = t.findingRecorder.Record(ctx, input, refs)
@@ -1547,8 +1581,9 @@ type hintItem struct {
TrafficRefs []db.TrafficRef `json:"traffic_refs"`
}
// addOneHint attaches a hint node (active/human) to the exploration graph, optionally
// anchored to assets; returns the id.
// addOneHint attaches a hint node (active) to the exploration graph, optionally
// anchored to assets; returns the id. Its origin is t.worker, the agent that wrote
// it: "human" for the main-agent chat, "orchestrator" for cross-task orchestration.
func (t *ToolSet) addOneHint(it hintItem) (int64, error) {
if len(it.TrafficRefs) > 0 && !findingTrafficBindingEnabled() {
return 0, fmt.Errorf("automatic agent traffic binding is off; the hint carrying traffic_refs was not saved — enable it in system settings, or hand over text only")
@@ -1573,7 +1608,7 @@ func (t *ToolSet) addOneHint(it hintItem) (int64, error) {
// Waking the planner is not done here per item — addHint fires it once after the
// whole batch is written (carrying the hint texts), so one add_hint with multiple
// hints doesn't spam the planner's trigger lines one by one.
return t.ts.AddNode(db.KindHint, payload, 0, "active", "human", anchors)
return t.ts.AddNode(db.KindHint, payload, 0, "active", t.worker, anchors)
}
type goalItem struct {
@@ -1763,7 +1798,7 @@ func (t *ToolSet) setConstraints() actool.CoreTool {
}
func (t *ToolSet) addHint() actool.CoreTool {
return t.writeExpTool("add_hint", "Attach a strategic hint from the human/main agent to the exploration graph; the planner reads it the next time it generates intents.\n"+
return t.writeExpTool("add_hint", "Attach a strategic hint to the exploration graph; the planner reads it the next time it generates intents. The hint is stored with the calling agent as its origin (human for the main-agent chat, orchestrator for cross-task orchestration, otherwise the agent's name).\n"+
"★Batch preferred: put multiple hints in the hints array in a single submission (saves round trips vs. one call per item). Returns an ids array, same length and order as hints (failed items get id=0, details in errors). For a single hint, omit hints and pass the top-level text.",
obj(map[string]any{
"hints": map[string]any{"type": "array", "description": "[Prefer this] array of hints to add, processed in order. Each element has the same fields as the top-level ones below (text/asset_ids/traffic_refs). The returned ids match this array in length and order.", "items": obj(map[string]any{"text": str("hint content"), "asset_ids": map[string]any{"type": "array", "items": map[string]any{"type": "integer"}}, "traffic_refs": HintTrafficSchema()})},
@@ -1797,13 +1832,13 @@ func (t *ToolSet) addHint() actool.CoreTool {
}
if len(addedTexts) > 0 {
// Wake the planner (once for the whole batch). Prefer notifyHint: one
// add_hint records a single "human added N strategic hints: …" trigger, so
// the planner knows "this round was fired by a new hint" and sees its
// content; when the callback isn't wired, fall back to plain notify (bare
// wake; the hint is still folded into the graph for it to read).
// add_hint records a single "<origin> added N strategic hints: …" trigger,
// so the planner knows "this round was fired by a new hint", who wrote it,
// and sees its content; when the callback isn't wired, fall back to plain
// notify (bare wake; the hint is still folded into the graph for it to read).
switch {
case t.notifyHint != nil:
t.notifyHint(addedTexts)
t.notifyHint(t.worker, addedTexts)
case t.notify != nil:
t.notify()
}
+1 -1
View File
@@ -249,7 +249,7 @@ const workerDefaultTmpl = `You are an "executor" (work agent) of a network-secur
**Write back as you discover** (only what's written into the graph counts; what's in your head/text doesn't; write every result immediately — don't save it for the end and lose it when the step budget runs out). Three kinds of write-back, don't cross the graphs:
- **New asset/resource → insert_assets (asset graph)**: subdomains / services / endpoints / fingerprints / credentials and any asset [itself]. **Only assets are registered here; exploration conclusions/judgments don't go here — use record_fact.**
- **Exploration conclusion/fact → record_fact (exploration graph, pass intent_id)**: use it for all of those. **Consolidate multiple observations into [ONE] fact** (summary = one summarizing sentence + detail = the expansion of the summary, based on the real execution process) — not one fact per attribute; one intent usually produces only one fact, and splitting finely bloats the graph endlessly — **write one fact by default, merging everything mergeable into detail**; only use the facts array to split when there are genuinely [mutually independent, unmergeable] conclusions — that's a rare exception, not the norm. **Write only the delta**: record only what is [newly obtained] this time; don't re-record existing facts in different words (if it merely corroborates an existing one with nothing new, don't record it). **Write only what you actually saw**: give evidence (one line: the command + the most proving one or two output lines — brief; details in detail), and mark confidence (observed = seen directly / inferred = inferred from phenomena).
- **Confirmed vulnerability → report_finding (exploration graph, with PoC, pass intent_id)**: **use it only when you actually triggered it this time and obtained reproducible evidence (request/response or command output)**. It is strictly forbidden to treat "version/fingerprint matching a CVE", "the parameter looks injectable", or "inference from external vulnerability databases/changelogs/code diffs" as confirmed, and don't substitute querying a CVE database or comparing patch versions for actually triggering it. Can't trigger it but suspicion remains → record an inferred fact with record_fact (the suspicion point + why it couldn't be triggered) for the planner; don't force it into a finding. Before registering, check list_findings / list_task_findings for an existing finding with the same root cause, endpoint, and parameter: the same defect again means extending that finding's evidence, not registering a duplicate (duplicates burn reviewer trust); a genuinely distinct entry point, parameter, or privilege level remains its own finding per the adversarial gate.
- **Confirmed vulnerability → report_finding (exploration graph, with PoC, pass intent_id)**: **use it only when you actually triggered it this time and obtained reproducible evidence (request/response or command output)**. It is strictly forbidden to treat "version/fingerprint matching a CVE", "the parameter looks injectable", or "inference from external vulnerability databases/changelogs/code diffs" as confirmed, and don't substitute querying a CVE database or comparing patch versions for actually triggering it. Can't trigger it but suspicion remains → record an inferred fact with record_fact (the suspicion point + why it couldn't be triggered) for the planner; don't force it into a finding. Before registering, check list_findings / list_task_findings for an existing finding with the same root cause, endpoint, and parameter: the same defect again means extending that finding's evidence, not registering a duplicate (duplicates burn reviewer trust); a genuinely distinct entry point, parameter, or privilege level remains its own finding per the adversarial gate. When your confidence is not high, also fill report_finding's optional fields: counterevidence = what you tested that did not work; confidence_rationale = why the conclusion holds. Both are optional and never block reporting.
**Budget discipline (the deadline contract)**: your run has a step budget and a wall-clock budget. Before starting any command or probe, check it can finish well within what remains; never start work whose timeout can outlive the remaining budget — prefer the smaller variant that lands. When the budget is nearly spent or the wrap-up signal arrives, stop opening new work and land everything already collected (facts first, then findings): a result that exists only in your head is lost.
+67
View File
@@ -0,0 +1,67 @@
package db
import (
"strconv"
"testing"
)
// counterevidence / confidence_rationale are optional: they round-trip through
// RecordFinding and every read path, and default to "" when not given.
func TestFindingReasoningFieldsRoundTrip(t *testing.T) {
d, err := Open(testDSN(t))
if err != nil {
t.Skipf("postgres unavailable (%v) — skipping", err)
}
defer d.Close()
tk, err := d.CreateTask("finding reasoning fields", "goal", nil, 0, 0)
if err != nil {
t.Fatal(err)
}
defer d.DeleteTask(tk.ID)
es := d.Exploration(tk.ExplorationID)
with, err := es.RecordFinding(t.Context(), RecordFindingInput{TaskID: tk.ID, VulnClass: "IDOR", Severity: "medium", Summary: "with reasoning", Worker: "test",
Counterevidence: "UUID guessing returned 404", ConfidenceRationale: "two accounts, same response body"})
if err != nil {
t.Fatal(err)
}
without, err := es.RecordFinding(t.Context(), RecordFindingInput{TaskID: tk.ID, VulnClass: "IDOR", Severity: "low", Summary: "without reasoning", Worker: "test"})
if err != nil {
t.Fatal(err)
}
want := map[int64][2]string{
with.FindingID: {"UUID guessing returned 404", "two accounts, same response body"},
without.FindingID: {"", ""},
}
check := func(src string, f *DBFinding) {
t.Helper()
w, ok := want[f.ID]
if !ok {
return
}
if f.Counterevidence != w[0] || f.ConfidenceRationale != w[1] {
t.Fatalf("%s finding %d: got (%q, %q), want (%q, %q)", src, f.ID, f.Counterevidence, f.ConfidenceRationale, w[0], w[1])
}
}
for id := range want {
f, err := d.GetFinding(id)
if err != nil || f == nil {
t.Fatalf("GetFinding(%d): %v %v", id, f, err)
}
check("GetFinding", f)
}
filter := FindingFilter{TaskID: strconv.FormatInt(tk.ID, 10)}
page, total, err := d.ListFindingsPage(filter, 1, 50)
if err != nil || total != 2 {
t.Fatalf("ListFindingsPage: total=%d err=%v", total, err)
}
for _, f := range page {
check("ListFindingsPage", f)
}
exported, err := d.ListFindingsForExport(filter, nil)
if err != nil || len(exported) != 2 {
t.Fatalf("ListFindingsForExport: n=%d err=%v", len(exported), err)
}
for _, f := range exported {
check("ListFindingsForExport", f)
}
}
+3 -2
View File
@@ -328,6 +328,7 @@ func (d *DB) EditFindingTraffic(ctx context.Context, findingID, bindingID, versi
type RecordFindingInput struct {
TaskID, ExplorationID, IntentID int64
VulnClass, Name, Severity, Summary, Evidence, Worker string
Counterevidence, ConfidenceRationale string // optional; "" = not given
AssetIDs []int64
}
@@ -384,8 +385,8 @@ VALUES($1,'finding',$2,9,'confirmed',$3) RETURNING id`, in.ExplorationID, string
assets = []int64{}
}
raw, _ := json.Marshal(assets)
if err := tx.QueryRow(`INSERT INTO findings(task_id,node_id,vulnclass,name,severity,summary,evidence,worker,asset_ids)
VALUES(NULLIF($1,0),$2,$3,$4,$5,$6,$7,$8,$9) RETURNING id`, in.TaskID, out.NodeID, in.VulnClass, in.Name, in.Severity, in.Summary, in.Evidence, in.Worker, string(raw)).Scan(&out.FindingID); err != nil {
if err := tx.QueryRow(`INSERT INTO findings(task_id,node_id,vulnclass,name,severity,summary,evidence,worker,asset_ids,counterevidence,confidence_rationale)
VALUES(NULLIF($1,0),$2,$3,$4,$5,$6,$7,$8,$9,$10,$11) RETURNING id`, in.TaskID, out.NodeID, in.VulnClass, in.Name, in.Severity, in.Summary, in.Evidence, in.Worker, string(raw), in.Counterevidence, in.ConfidenceRationale).Scan(&out.FindingID); err != nil {
return nil, err
}
// Register a push event in the **same transaction**: committing guarantees
+7 -3
View File
@@ -37,6 +37,9 @@ type DBFinding struct {
Report string // detailed report (Markdown); only populated by GetFinding, not by list queries
CreatedAt time.Time
TaskDescription string // populated via LEFT JOIN on tasks
Counterevidence string // what was tested and did not work; optional, "" = not given
ConfidenceRationale string // why the conclusion holds; optional, "" = not given
}
// Finding triage states (findings.status).
@@ -109,6 +112,7 @@ const findingSelectCols = `f.id, f.task_id, f.node_id, f.vulnclass, COALESCE(f.n
f.evidence, f.worker, f.asset_ids, COALESCE(f.status, 'pending'), f.created_at,
COALESCE(t.description, '') AS task_description, f.evidence_version, f.report_evidence_version,
f.poe_level, COALESCE(f.verification_status, 'unverified'), COALESCE(f.verification_note, ''),
f.counterevidence, f.confidence_rationale,
(SELECT count(*) FROM finding_traffic_bindings b WHERE b.finding_id=f.id)`
// scanFindings materializes rows selected via findingSelectCols.
@@ -122,7 +126,7 @@ func scanFindings(rows interface {
f := &DBFinding{}
var aidsJSON string
if err := rows.Scan(&f.ID, &f.TaskID, &f.NodeID, &f.VulnClass, &f.Name, &f.Severity,
&f.Summary, &f.Evidence, &f.Worker, &aidsJSON, &f.Status, &f.CreatedAt, &f.TaskDescription, &f.EvidenceVersion, &f.ReportEvidenceVersion, &f.PoELevel, &f.VerificationStatus, &f.VerificationNote, &f.TrafficCount); err != nil {
&f.Summary, &f.Evidence, &f.Worker, &aidsJSON, &f.Status, &f.CreatedAt, &f.TaskDescription, &f.EvidenceVersion, &f.ReportEvidenceVersion, &f.PoELevel, &f.VerificationStatus, &f.VerificationNote, &f.Counterevidence, &f.ConfidenceRationale, &f.TrafficCount); err != nil {
return nil, err
}
_ = json.Unmarshal([]byte(aidsJSON), &f.AssetIDs)
@@ -525,7 +529,7 @@ func (d *DB) ListFindingsForExport(f FindingFilter, ids []int64) ([]*DBFinding,
var aidsJSON string
if err := rows.Scan(&f.ID, &f.TaskID, &f.NodeID, &f.VulnClass, &f.Name, &f.Severity,
&f.Summary, &f.Evidence, &f.Worker, &aidsJSON, &f.Status, &f.CreatedAt,
&f.TaskDescription, &f.EvidenceVersion, &f.ReportEvidenceVersion, &f.PoELevel, &f.VerificationStatus, &f.VerificationNote, &f.TrafficCount, &f.Report); err != nil {
&f.TaskDescription, &f.EvidenceVersion, &f.ReportEvidenceVersion, &f.PoELevel, &f.VerificationStatus, &f.VerificationNote, &f.Counterevidence, &f.ConfidenceRationale, &f.TrafficCount, &f.Report); err != nil {
return nil, err
}
_ = json.Unmarshal([]byte(aidsJSON), &f.AssetIDs)
@@ -655,7 +659,7 @@ func (d *DB) GetFinding(id int64) (*DBFinding, error) {
WHERE f.id = $1`, id).Scan(
&f.ID, &f.TaskID, &f.NodeID, &f.VulnClass, &f.Name, &f.Severity,
&f.Summary, &f.Evidence, &f.Worker, &aidsJSON, &f.Status, &f.CreatedAt,
&f.TaskDescription, &f.EvidenceVersion, &f.ReportEvidenceVersion, &f.PoELevel, &f.VerificationStatus, &f.VerificationNote, &f.TrafficCount, &f.Report)
&f.TaskDescription, &f.EvidenceVersion, &f.ReportEvidenceVersion, &f.PoELevel, &f.VerificationStatus, &f.VerificationNote, &f.Counterevidence, &f.ConfidenceRationale, &f.TrafficCount, &f.Report)
if err == sql.ErrNoRows {
return nil, nil
}
+4
View File
@@ -1247,6 +1247,10 @@ ALTER TABLE findings ADD COLUMN IF NOT EXISTS report_evidence_version BIGINT NOT
ALTER TABLE findings ADD COLUMN IF NOT EXISTS poe_level SMALLINT NOT NULL DEFAULT 0;
ALTER TABLE findings ADD COLUMN IF NOT EXISTS verification_status TEXT NOT NULL DEFAULT 'unverified';
ALTER TABLE findings ADD COLUMN IF NOT EXISTS verification_note TEXT NOT NULL DEFAULT '';
-- Reporter-supplied reasoning, both optional (empty = not given): counterevidence is what was
-- tested and did not work; confidence_rationale is why the conclusion holds.
ALTER TABLE findings ADD COLUMN IF NOT EXISTS counterevidence TEXT NOT NULL DEFAULT '';
ALTER TABLE findings ADD COLUMN IF NOT EXISTS confidence_rationale TEXT NOT NULL DEFAULT '';
CREATE TABLE IF NOT EXISTS traffic_evidence_snapshots (
id TEXT PRIMARY KEY,
+21 -9
View File
@@ -38,7 +38,7 @@ type Guard struct {
attrib map[string]int // failure attribution counts (Observer / G5)
reg *hook.Registry
interceptor *intercept.Interceptor // optional; nil disables user-configured rules
targetOnly bool // planner / main agent: target gate only, no rules, no judge, no audit ring
targetOnly bool // planner / main agent: built-in deny rules and target gate only, no user rules, no judge, no audit ring
gate targetGate // the target gate; nil without an interceptor
}
@@ -50,9 +50,10 @@ func New() *Guard { return newGuard(nil) }
func NewWithInterceptor(ic *intercept.Interceptor) *Guard { return newGuard(ic) }
// NewTargetOnly creates the Guard for the planner and the main agent. Their tool
// calls pass through the target gate only: the intercept rules and the fallback
// judge are not extended to them, and their calls are not written to the audit
// ring (which keeps the worker history of the task's main Guard).
// calls pass through the built-in deny rules and the target gate only: the user
// intercept rules and the fallback judge are not extended to them, and their
// calls that pass are not written to the audit ring (which keeps the worker
// history of the task's main Guard).
func NewTargetOnly(ic *intercept.Interceptor) *Guard {
g := &Guard{attrib: map[string]int{}, interceptor: ic, targetOnly: true}
g.setGate(ic)
@@ -131,12 +132,23 @@ func (g *Guard) gateScope(ctx context.Context) (intercept.TargetScope, bool) {
// then the target gate. Both rules and the fallback judge receive the complete
// tool input.
//
// The rules and the judge apply to the enabled tools of a full guard. The
// target gate applies to every tool call of a session whose gate is on: a deny
// blocks first, before any target request exists; an allow by a rule or by the
// judge does not satisfy the gate; an ask and an unpinned target share one
// approval request.
// The rules and the judge apply to the enabled tools of a full guard. A
// target-only guard applies the built-in deny rules alone, whether its gate is
// on or off. The target gate applies to every tool call of a session whose gate
// is on: a deny blocks first, before any target request exists; an allow by a
// rule or by the judge does not satisfy the gate; an ask and an unpinned target
// share one approval request.
func (g *Guard) applyIntercept(ctx context.Context, ev hook.Event) hook.Result {
if g.targetOnly && g.interceptor != nil {
// The planner and the main agent run Bash too (#124, F11): the built-in
// deny rules apply to them, before the target gate. User rules and the
// judge stay with the full guard.
if dec, ok := g.interceptor.MatchBuiltin(ev.ToolName, ev.Input); ok {
ctx = intercept.WithCall(ctx, ev.ToolName, ev.Input)
g.interceptor.Log(ctx, intercept.ConvIDFromContext(ctx), dec, ev.ToolName, ev.Input, "denied")
return g.block(ev.ToolName, systemBlockMessage(dec.Message), "")
}
}
scope, gated := g.gateScope(ctx)
rules := !g.targetOnly && g.interceptor != nil && g.interceptor.IsToolEnabled(ev.ToolName)
if !rules && !gated {
+66 -5
View File
@@ -3,8 +3,11 @@ package guard
import (
"context"
"encoding/json"
"strings"
"testing"
"time"
"github.com/Autumn-27/artex/db"
"github.com/Autumn-27/artex/intercept"
"github.com/Autumn-27/norma/hook"
)
@@ -37,11 +40,14 @@ func TestPreToolUsePassthrough(t *testing.T) {
}
}
// The target-only guard (planner, main agent) runs the target gate and nothing
// else: no intercept rule, no fallback judge, no audit-ring entry. Here the gate
// is off (no scope, or a scope without the flag). Its interceptor has no database
// behind it, so any read or write through it would panic — passing proves that
// with the gate off every call is allowed without touching the store.
// The target-only guard (planner, main agent) runs the built-in deny rules and
// the target gate: no user intercept rule, no fallback judge, no audit-ring entry
// for a call that passes (in production the built-in rules come from the store,
// see TestTargetOnlyGuardAppliesBuiltinDenyRules). Here the gate is off (no
// scope, or a scope without the flag). Its interceptor has no database behind it
// and no loaded rules, so it matches no built-in rule, and any read or write
// through it would panic — passing proves that with the gate off every call is
// allowed without touching the store.
func TestTargetOnlyGuardSkipsRules(t *testing.T) {
calls := []struct {
tool string
@@ -89,4 +95,59 @@ func TestTargetOnlyGuardSkipsRules(t *testing.T) {
}
}
// The target-only guard applies the built-in deny rules (#124, F11), and no user
// rule. The rules are injected into a store-less interceptor through the
// SetRulesForTest seam, so nothing is read from or logged to a database.
func TestTargetOnlyGuardAppliesBuiltinDenyRules(t *testing.T) {
newIC := func() *intercept.Interceptor {
ic := intercept.New(nil)
ic.SetRulesForTest([]db.InterceptRule{
{ID: 1, Name: "[built-in] Destructive system commands", Enabled: true, Priority: 100,
MatchTarget: "tool_input", MatchType: "regex", Action: "deny",
Pattern: `(?i)\b(rm\s+-rf\s+/|mkfs|dd\s+if=|:\(\)\s*\{|shutdown|reboot|>\s*/dev/sd)`,
Message: "Destructive command rejected"},
{ID: 2, Name: "No whoami", Enabled: true, Priority: 50,
MatchTarget: "tool_input", MatchType: "string", Action: "deny",
Pattern: "whoami", Message: "user rule: whoami is forbidden"},
})
return ic
}
const platform = "[ARTEX platform control, not target defense]"
g := NewTargetOnly(newIC())
gate := &fakeGate{t: t}
g.gate = gate
for name, ctx := range map[string]context.Context{
"gate off": context.Background(),
"gate on": gateOn(context.Background(), "7", time.Minute),
} {
if block, msg := pre(g, ctx, "Bash", `{"command":"rm -rf /"}`); !block ||
!strings.HasPrefix(msg, platform) || !strings.Contains(msg, "Destructive command rejected") {
t.Errorf("%s: rm -rf / block=%v msg=%q, want a built-in deny", name, block, msg)
}
if block, msg := pre(g, ctx, "Bash", `{"command":"ls -la"}`); block {
t.Errorf("%s: a benign command was blocked: %s", name, msg)
}
if block, msg := pre(g, ctx, "Bash", `{"command":"whoami"}`); block {
t.Errorf("%s: a user rule was applied to the target-only guard: %s", name, msg)
}
// A tool outside the rule system is not matched, even when its text names a
// destructive command (a hint or an intent that describes one).
if block, msg := pre(g, ctx, "add_hint", `{"text":"the reset endpoint runs rm -rf / on the target"}`); block {
t.Errorf("%s: a tool outside the rule system was blocked: %s", name, msg)
}
}
// The built-in deny is decided before the gate: only the two passing Bash calls
// and add_hint of the gated round reached it.
if gate.checks != 3 || len(gate.asked) != 0 {
t.Errorf("gate checks=%d requests=%d, want 3 and 0", gate.checks, len(gate.asked))
}
// The full guard (workers) still applies the user rule.
full := NewWithInterceptor(newIC())
if block, msg := pre(full, context.Background(), "Bash", `{"command":"whoami"}`); !block || !strings.Contains(msg, "user rule: whoami is forbidden") {
t.Errorf("full guard: whoami block=%v msg=%q, want the user rule", block, msg)
}
}
var _ = hook.PreToolUse
+71
View File
@@ -615,6 +615,74 @@ func (i *Interceptor) Match(toolName string, input []byte) (Decision, bool) {
return Decision{}, false
}
// builtinRulePrefix marks the rules seeded by the platform (db.seedDefaultInterceptRules
// and its v2/v3 migrations).
const builtinRulePrefix = "[built-in]"
// MatchBuiltin is Match restricted to the built-in deny rules: the enabled rules
// whose name starts with "[built-in]" and whose action is deny, on the tools that
// enter the rule system. It returns the first match in priority order. User rules,
// allow and ask rules, and the judge are not consulted. The planner and the main
// agent use it (#124, F11). An interceptor without a database and without loaded
// rules matches nothing.
func (i *Interceptor) MatchBuiltin(toolName string, input []byte) (Decision, bool) {
i.mu.RLock()
loaded := i.cached != nil
i.mu.RUnlock()
if !loaded && i.db == nil {
return Decision{}, false
}
if !i.IsToolEnabled(toolName) {
return Decision{}, false
}
rules, err := i.rules()
if err != nil {
return Decision{}, false
}
for _, r := range rules {
if r.Action != "deny" || !strings.HasPrefix(r.Name, builtinRulePrefix) || !ruleMatches(r, toolName, input) {
continue
}
msg := r.Message
if msg == "" {
msg = defaultMessage(r.Action, r.Name)
}
configJSON, _ := json.Marshal(r.InterceptRule)
return Decision{
RuleName: r.Name, ConfigDigest: digestInput(configJSON),
Action: r.Action,
Message: msg,
RuleID: r.ID,
}, true
}
return Decision{}, false
}
// SetRulesForTest installs rules (in priority order) as the loaded rule set, with
// the default intercept-enabled tools, on an interceptor that may have no
// database. It is a test seam for the guard package, which cannot reach the
// unexported cache; production code loads the rules from the database.
func (i *Interceptor) SetRulesForTest(rules []db.InterceptRule) {
out := []compiledRule{}
for _, r := range rules {
if !r.Enabled {
continue
}
cr := compiledRule{InterceptRule: r}
if r.MatchType == "regex" {
cr.re = regexp.MustCompile(r.Pattern)
}
out = append(out, cr)
}
tools := make(map[string]bool, len(defaultEnabledTools))
for _, n := range defaultEnabledTools {
tools[n] = true
}
i.mu.Lock()
i.cached, i.enabledTools = out, tools
i.mu.Unlock()
}
func ruleMatches(r compiledRule, toolName string, input []byte) bool {
var subject string
switch r.MatchTarget {
@@ -649,6 +717,9 @@ func defaultMessage(action, name string) string {
// error is swallowed so logging never changes the tool call's outcome. The pending list
// (status='pending') is unaffected, so it still shows only asks awaiting a decision.
func (i *Interceptor) Log(ctx context.Context, convID int64, dec Decision, toolName string, input []byte, status string) {
if i.db == nil {
return // no store to record into (SetRulesForTest)
}
taskID, agentName := taskInfoFromCtx(ctx)
audit := auditFor(ctx, dec, input, status)
id, err := i.db.CreateDecidedIntercept(dec.RuleID, convID, taskID, agentName, toolName, input, status, dec.Message, audit)
+3
View File
@@ -317,6 +317,8 @@ type FindingDTO struct {
PoELevel int `json:"poe_level"`
VerificationStatus string `json:"verification_status"`
VerificationNote string `json:"verification_note"`
Counterevidence string `json:"counterevidence,omitempty"` // what was tested and did not work; optional
ConfidenceRationale string `json:"confidence_rationale,omitempty"` // why the conclusion holds; optional
ID string `json:"id"`
FindingID string `json:"finding_id,omitempty"` // standalone findings-table id — the handle for status updates
@@ -458,6 +460,7 @@ func findingFromDB(f *db.DBFinding, assets map[int64]*db.Asset) FindingDTO {
TrafficCount: f.TrafficCount, EvidenceVersion: f.EvidenceVersion, ReportEvidenceVersion: f.ReportEvidenceVersion,
ReportStale: f.Report != "" && f.EvidenceVersion != f.ReportEvidenceVersion, TrafficBindings: f.TrafficBindings,
PoELevel: f.PoELevel, VerificationStatus: f.VerificationStatus, VerificationNote: f.VerificationNote,
Counterevidence: f.Counterevidence, ConfidenceRationale: f.ConfidenceRationale,
VulnClass: f.VulnClass,
Name: f.Name,
Severity: f.Severity,
+94
View File
@@ -0,0 +1,94 @@
package server
import (
"context"
"encoding/json"
"fmt"
"strings"
"testing"
"github.com/Autumn-27/artex/db"
)
// Pure: FindingDTO carries both reasoning fields and omits them when empty.
func TestFindingDTOReasoningFields(t *testing.T) {
d := findingFromDB(&db.DBFinding{ID: 1, Counterevidence: "blocked by WAF", ConfidenceRationale: "row of tenant B returned"}, nil)
if d.Counterevidence != "blocked by WAF" || d.ConfidenceRationale != "row of tenant B returned" {
t.Fatalf("DTO lost reasoning fields: %+v", d)
}
raw, _ := json.Marshal(d)
if !strings.Contains(string(raw), `"counterevidence":"blocked by WAF"`) || !strings.Contains(string(raw), `"confidence_rationale":"row of tenant B returned"`) {
t.Fatalf("JSON missing reasoning fields: %s", raw)
}
raw, _ = json.Marshal(findingFromDB(&db.DBFinding{ID: 2}, nil))
if strings.Contains(string(raw), "counterevidence") || strings.Contains(string(raw), "confidence_rationale") {
t.Fatalf("empty reasoning fields should be omitted: %s", raw)
}
}
// PG: the detail endpoint returns the stored fields, and the report_finding
// schema upgrade adds both properties to an existing (customized) row without
// overwriting it.
func TestFindingReasoningDetailAndSchemaUpgrade(t *testing.T) {
s, f, req := trafficEvidenceServer(t)
pg := s.m.pg
var taskID int64
if err := pg.QueryRow(`SELECT task_id FROM findings WHERE id=$1`, f.FindingID).Scan(&taskID); err != nil {
t.Fatal(err)
}
var expID int64
if err := pg.QueryRow(`SELECT exploration_id FROM tasks WHERE id=$1`, taskID).Scan(&expID); err != nil {
t.Fatal(err)
}
rec, err := pg.Exploration(expID).RecordFinding(context.Background(), db.RecordFindingInput{TaskID: taskID, VulnClass: "TEST", Severity: "low", Summary: "reasoning detail", Worker: "test",
Counterevidence: "admin path returned 403", ConfidenceRationale: "user path returned the admin record"})
if err != nil {
t.Fatal(err)
}
w := req("GET", fmt.Sprintf("/api/exploration/findings/%d", rec.FindingID), "")
if w.Code != 200 {
t.Fatalf("detail status %d: %s", w.Code, w.Body)
}
var got FindingDTO
if err := json.Unmarshal(w.Body.Bytes(), &got); err != nil {
t.Fatal(err)
}
if got.Counterevidence != "admin path returned 403" || got.ConfidenceRationale != "user path returned the admin record" {
t.Fatalf("detail DTO lost reasoning fields: %+v", got)
}
old, err := pg.GetTool("report_finding")
if err != nil || old == nil {
t.Fatal("missing report_finding", err)
}
t.Cleanup(func() {
bindings, _ := json.Marshal(old.Agents)
pg.UpdateTool(old.Key, old.Description, old.Schema, bindings, old.Enabled)
})
custom := json.RawMessage(`{"type":"object","properties":{"evidence":{"type":"string","description":"user evidence instructions"}},"required":["evidence"]}`)
if err := pg.UpdateTool("report_finding", "user description", custom, json.RawMessage(`["worker"]`), false); err != nil {
t.Fatal(err)
}
for range 2 { // idempotent
s.seedFindingEvidenceSchema()
}
tool, err := pg.GetTool("report_finding")
if err != nil || tool == nil {
t.Fatal(err)
}
var schema struct {
Properties map[string]map[string]any `json:"properties"`
Required []string `json:"required"`
}
if err := json.Unmarshal(tool.Schema, &schema); err != nil {
t.Fatal(err)
}
for _, name := range []string{"counterevidence", "confidence_rationale"} {
if schema.Properties[name]["type"] != "string" {
t.Fatalf("upgrade did not add %s: %s", name, tool.Schema)
}
}
if tool.Enabled || tool.Description != "user description" || len(schema.Required) != 1 || schema.Required[0] != "evidence" || schema.Properties["evidence"]["description"] != "user evidence instructions" {
t.Fatalf("custom configuration overwritten: %+v %s", tool, tool.Schema)
}
}
+38
View File
@@ -13,6 +13,7 @@ import (
"strings"
"unicode/utf8"
"github.com/Autumn-27/artex/agent"
"github.com/Autumn-27/artex/db"
"github.com/Autumn-27/artex/evidence"
)
@@ -242,3 +243,40 @@ WHERE key=$1 AND system AND NOT(COALESCE(schema->'properties','{}'::jsonb) ? $2)
}
}
}
// seedFindingEvidenceSchema adds the optional counterevidence /
// confidence_rationale properties to the report_finding schema of existing
// databases (SeedTool is first-insert only, so without this the model would never
// see them). Idempotent: a property is added only when the stored schema lacks it,
// and user edits are preserved.
func (s *Server) seedFindingEvidenceSchema() {
for _, seed := range agent.BuiltinToolSeeds() {
if seed.Key != "report_finding" {
continue
}
raw, err := json.Marshal(seed.Schema)
if err != nil {
log.Printf("[evidence] report_finding schema: %v", err)
return
}
var obj map[string]json.RawMessage
if err := json.Unmarshal(raw, &obj); err != nil {
return
}
var properties map[string]json.RawMessage
if err := json.Unmarshal(obj["properties"], &properties); err != nil {
return
}
for _, name := range []string{"counterevidence", "confidence_rationale"} {
if len(properties[name]) == 0 {
continue
}
_, err := s.m.pg.Exec(`UPDATE tools SET schema=jsonb_set(schema,ARRAY['properties',$2::text],$3::jsonb,true),updated_at=now()
WHERE key=$1 AND system AND NOT(COALESCE(schema->'properties','{}'::jsonb) ? $2)`, "report_finding", name, string(properties[name]))
if err != nil {
log.Printf("[evidence] upgrade report_finding.%s: %v", name, err)
}
}
return
}
}
+6 -5
View File
@@ -1888,16 +1888,17 @@ func (t *Task) NotifyGoal(texts []string) {
}
// NotifyHint records that one OR MORE hints were added in a single add_hint call —
// by the human via the main agent, or by cross-task orchestration — then wakes the
// planner, so the next round is told "the human added N strategy hints: ..." and looks at them
// directly instead of having to spot the new hint folded into the graph overview.
// by the human via the main agent (origin "human"), or by cross-task orchestration
// (origin "orchestrator") — then wakes the planner, so the next round is told who
// added N strategy hints and looks at them directly instead of having to spot the
// new hint folded into the graph overview.
// One call → one trigger event (a batched add_hint counts as one, not one per hint).
func (t *Task) NotifyHint(texts []string) {
func (t *Task) NotifyHint(origin string, texts []string) {
if len(texts) == 0 {
return
}
t.trigMu.Lock()
t.pendingTriggers = append(t.pendingTriggers, agent.TriggerEvent{Kind: "hint", Hints: texts})
t.pendingTriggers = append(t.pendingTriggers, agent.TriggerEvent{Kind: "hint", Hints: texts, HintOrigin: origin})
t.trigMu.Unlock()
t.Notify()
}
+2 -1
View File
@@ -170,7 +170,7 @@ func (s *Server) delegateToTask(ctx context.Context, in json.RawMessage, pick fu
tsx.SetAssetStore(s.m.Assets(), s.m.Assets().Companies())
}
tsx.SetNotify(t.Notify) // generic wake-up (write ops without a dedicated callback go through it; no-op for read tools)
tsx.SetNotifyHint(t.NotifyHint) // add_hint → records a "human added N strategic hints: ..." entry and wakes the planner
tsx.SetNotifyHint(t.NotifyHint) // add_hint → records an "orchestrator added N strategic hints: ..." entry and wakes the planner
return pick(tsx).Call(ctx, inner, nil)
}
@@ -570,6 +570,7 @@ func (s *Server) seedOrchestrationTools() {
s.seedFindingTrafficTools() // adds optional evidence params and read-only evidence tools, preserving user config
s.seedFindingWorkflowTools()
s.seedFindingVerificationSchema() // S1: poe_level / evidence_quotes on update_finding_report, added once per DB
s.seedFindingEvidenceSchema() // optional counterevidence / confidence_rationale on report_finding, added once per DB
// Note: pentest's default tool bindings need no migration — BuiltinToolSeeds already seeds
// list_assets/insert_assets/report_finding/list_findings/list_companies together with
// pentest at fresh initialization (no old DBs exist in this project, so no migration).
@@ -189,6 +189,26 @@ function FindingDetailInner() {
)}
</CardContent>
</Card>
{finding.counterevidence?.trim() && (
<Card>
<CardHeader>
<CardTitle className="text-sm">Counterevidence</CardTitle>
</CardHeader>
<CardContent>
<p className="text-sm leading-relaxed whitespace-pre-wrap">{finding.counterevidence}</p>
</CardContent>
</Card>
)}
{finding.confidence_rationale?.trim() && (
<Card>
<CardHeader>
<CardTitle className="text-sm">Confidence rationale</CardTitle>
</CardHeader>
<CardContent>
<p className="text-sm leading-relaxed whitespace-pre-wrap">{finding.confidence_rationale}</p>
</CardContent>
</Card>
)}
<FindingTrafficPanel
key={id}
findingId={id}
+2
View File
@@ -500,6 +500,8 @@ export interface Finding {
poe_level?: number; // proof-of-exploitation level (3 or 4 when verified); 0 = none declared
verification_status?: VerificationStatus; // automated verification outcome (S1)
verification_note?: string; // why the status was reached; empty when verified
counterevidence?: string; // what was tested and did not work; optional, omitted when empty
confidence_rationale?: string; // why the conclusion holds; optional, omitted when empty
id: string;
finding_id?: string; // row id in the standalone findings table, the handle for status updates (may be missing for old in-task nodes)
vulnclass: string;