mirror of
https://github.com/BaaRai/ARTEX.git
synced 2026-11-19 14:40:53 +08:00
Compare commits
4
Commits
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
8c9c1fc0ab | ||
|
|
a1f3256cf6 | ||
|
|
4bcb6d7250 | ||
|
|
2945f58b01 |
@@ -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)
|
||||
}
|
||||
}
|
||||
@@ -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
@@ -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
@@ -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))
|
||||
|
||||
@@ -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
@@ -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
@@ -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.
|
||||
|
||||
@@ -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)
|
||||
}
|
||||
}
|
||||
@@ -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
@@ -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
|
||||
}
|
||||
|
||||
@@ -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
@@ -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
@@ -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
|
||||
|
||||
@@ -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)
|
||||
|
||||
@@ -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,
|
||||
|
||||
@@ -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)
|
||||
}
|
||||
}
|
||||
@@ -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
@@ -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()
|
||||
}
|
||||
|
||||
@@ -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}
|
||||
|
||||
@@ -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;
|
||||
|
||||
Reference in New Issue
Block a user