mirror of
https://github.com/BaaRai/ARTEX.git
synced 2026-11-18 14:10:54 +08:00
fix: repair record_fact input contracts and asset aliases
This commit is contained in:
@@ -0,0 +1,41 @@
|
||||
package agent
|
||||
|
||||
import (
|
||||
"encoding/json"
|
||||
"fmt"
|
||||
"slices"
|
||||
)
|
||||
|
||||
// factAssetAnchors accepts the historical asset_ids spelling and its explicit
|
||||
// tested_asset_ids alias. Never union conflicting lists: that could attribute
|
||||
// a conclusion to assets the caller did not actually check.
|
||||
func (it factItem) factAssetAnchors() ([]int64, error) {
|
||||
assets, err := parseFactAssetIDs("asset_ids", it.AssetIDs)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
tested, err := parseFactAssetIDs("tested_asset_ids", it.TestedAssetIDs)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
if it.AssetIDs != nil && it.TestedAssetIDs != nil && !slices.Equal(assets, tested) {
|
||||
return nil, fmt.Errorf("asset_ids and tested_asset_ids must contain the same asset IDs when both are provided; use one field or correct the conflicting lists")
|
||||
}
|
||||
if it.TestedAssetIDs != nil {
|
||||
return tested, nil
|
||||
}
|
||||
return assets, nil
|
||||
}
|
||||
|
||||
func parseFactAssetIDs(field string, raw []json.RawMessage) ([]int64, error) {
|
||||
ids := make([]int64, 0, len(raw))
|
||||
for i, value := range raw {
|
||||
id := pid(value)
|
||||
if id <= 0 {
|
||||
return nil, fmt.Errorf("%s[%d] must be a positive integer asset ID", field, i)
|
||||
}
|
||||
ids = append(ids, id)
|
||||
}
|
||||
slices.Sort(ids)
|
||||
return slices.Compact(ids), nil
|
||||
}
|
||||
@@ -0,0 +1,130 @@
|
||||
package agent
|
||||
|
||||
import (
|
||||
"encoding/json"
|
||||
"fmt"
|
||||
"slices"
|
||||
"strconv"
|
||||
"strings"
|
||||
"testing"
|
||||
|
||||
"github.com/Autumn-27/artex/db"
|
||||
)
|
||||
|
||||
func TestRecordFactAssetAliases(t *testing.T) {
|
||||
d := testDB(t)
|
||||
defer d.Close()
|
||||
task, err := d.CreateTask("fact asset alias", "test", nil, 0, 0)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
defer d.DeleteTask(task.ID)
|
||||
assets := d.Assets()
|
||||
first, err := assets.UpsertRootDomain(db.UpsertRootDomainReq{Domain: "fact-alias-one.example", TaskID: task.ID})
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
second, err := assets.UpsertRootDomain(db.UpsertRootDomainReq{Domain: "fact-alias-two.example", TaskID: task.ID})
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
defer assets.DeleteByIDs([]int64{first, second})
|
||||
store := d.Exploration(task.ExplorationID)
|
||||
tools := NewToolSet(store, "worker")
|
||||
check := func(t *testing.T, id int64, want []int64) {
|
||||
t.Helper()
|
||||
rows, err := d.Query("SELECT asset_id FROM exploration_anchors WHERE node_id=$1 ORDER BY asset_id", id)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
defer rows.Close()
|
||||
var got []int64
|
||||
for rows.Next() {
|
||||
var asset int64
|
||||
if err := rows.Scan(&asset); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
got = append(got, asset)
|
||||
}
|
||||
if err := rows.Err(); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
slices.Sort(want)
|
||||
if !slices.Equal(got, want) {
|
||||
t.Fatalf("anchors = %v, want %v", got, want)
|
||||
}
|
||||
}
|
||||
for _, tc := range []struct{ name, fields string }{
|
||||
{"canonical", fmt.Sprintf(`"asset_ids":[%d,%d,%d]`, first, second, first)},
|
||||
{"alias", fmt.Sprintf(`"tested_asset_ids":[%d,%d]`, first, second)},
|
||||
{"equal sets", fmt.Sprintf(`"asset_ids":[%d,%d],"tested_asset_ids":[%d,%d,%d]`, first, second, second, first, first)},
|
||||
{"numeric strings", fmt.Sprintf(`"tested_asset_ids":["%d","%d"]`, first, second)},
|
||||
} {
|
||||
t.Run(tc.name, func(t *testing.T) {
|
||||
out := callGuardTool(t, tools.recordFact(), fmt.Sprintf(`{"summary":%q,%s}`, tc.name, tc.fields))
|
||||
if out.IsError {
|
||||
t.Fatal(out.Flatten())
|
||||
}
|
||||
id, err := strconv.ParseInt(strings.TrimPrefix(out.Flatten(), "fact recorded: "), 10, 64)
|
||||
if err != nil {
|
||||
t.Fatal(out.Flatten(), err)
|
||||
}
|
||||
check(t, id, []int64{first, second})
|
||||
})
|
||||
}
|
||||
before := tools.Writes().Facts
|
||||
for _, fields := range []string{
|
||||
fmt.Sprintf(`"asset_ids":[%d],"tested_asset_ids":[%d]`, first, second),
|
||||
fmt.Sprintf(`"asset_ids":[],"tested_asset_ids":[%d]`, first),
|
||||
fmt.Sprintf(`"tested_asset_ids":[%d,0]`, first),
|
||||
fmt.Sprintf(`"asset_ids":[%d,-1]`, first),
|
||||
`"tested_asset_ids":[null]`,
|
||||
`"tested_asset_ids":[1.5]`,
|
||||
`"tested_asset_ids":["invalid"]`,
|
||||
} {
|
||||
out := callGuardTool(t, tools.recordFact(), `{"summary":"invalid assets",`+fields+`}`)
|
||||
if !out.IsError || !strings.Contains(out.Flatten(), "asset_ids") {
|
||||
t.Fatalf("accepted %s: %q", fields, out.Flatten())
|
||||
}
|
||||
}
|
||||
if tools.Writes().Facts != before {
|
||||
t.Fatal("invalid asset lists wrote facts")
|
||||
}
|
||||
|
||||
out := callGuardTool(t, tools.recordFact(), fmt.Sprintf(`{"tested_asset_ids":[%d],"facts":[{"summary":"batch alias","tested_asset_ids":[%d]},{"summary":"batch conflict","asset_ids":[%d],"tested_asset_ids":[%d]},{"summary":"no inherited assets"}]}`, second, first, first, second))
|
||||
var batch struct {
|
||||
IDs []int64 `json:"ids"`
|
||||
Errors map[string]string `json:"errors"`
|
||||
}
|
||||
if err := json.Unmarshal([]byte(out.Flatten()), &batch); err != nil {
|
||||
t.Fatal(out.Flatten(), err)
|
||||
}
|
||||
if len(batch.IDs) != 3 || batch.IDs[0] <= 0 || batch.IDs[1] != 0 || batch.IDs[2] <= 0 || !strings.Contains(batch.Errors["1"], "same asset IDs") {
|
||||
t.Fatalf("batch: %s", out.Flatten())
|
||||
}
|
||||
check(t, batch.IDs[0], []int64{first})
|
||||
check(t, batch.IDs[2], nil)
|
||||
|
||||
before = tools.Writes().Facts
|
||||
malformed := callGuardTool(t, tools.recordFact(), fmt.Sprintf(`{"facts":[{"summary":"must not be saved"},{"summary":"bad list","tested_asset_ids":%d}]}`, first))
|
||||
if !malformed.IsError || tools.Writes().Facts != before {
|
||||
t.Fatal("malformed list caused a partial write", malformed.Flatten())
|
||||
}
|
||||
}
|
||||
|
||||
func TestRecordFactAssetAliasSchema(t *testing.T) {
|
||||
schema := NewToolSet(nil, "").recordFact().InputSchema()
|
||||
props := schema["properties"].(map[string]any)
|
||||
for _, name := range []string{"asset_ids", "tested_asset_ids"} {
|
||||
if props[name] == nil {
|
||||
t.Fatalf("single schema missing %s", name)
|
||||
}
|
||||
}
|
||||
item := props["facts"].(map[string]any)["items"].(map[string]any)
|
||||
itemProps, _ := item["properties"].(map[string]any)
|
||||
for _, name := range []string{"summary", "asset_ids", "tested_asset_ids"} {
|
||||
if itemProps[name] == nil {
|
||||
t.Fatalf("batch schema missing %s", name)
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,67 @@
|
||||
package agent
|
||||
|
||||
import "encoding/json"
|
||||
|
||||
func factItemSchema() map[string]any {
|
||||
schema := obj(map[string]any{
|
||||
"summary": str("Required on every fact: a non-empty one-sentence summary of this conclusion. Batch items do not inherit summary from the top level."),
|
||||
"intent_id": idp("The intent that produced this fact; only this field inherits from the top level in a batch."),
|
||||
"detail": str("Details of this fact, including all related observations."),
|
||||
"evidence": str("One line of key evidence: the command and the most proving output lines. Put longer output in detail."),
|
||||
"confidence": str("observed (seen directly in output) | inferred (inferred from phenomena). Label negative conclusions honestly."),
|
||||
"source": map[string]any{"type": "string", "enum": factSources, "description": "where the content came from: target_response | tool_output | third_party_intel | operator_input | inference (default when omitted)"},
|
||||
"asset_ids": map[string]any{"type": "array", "items": map[string]any{"type": "integer", "minimum": 1}, "description": "Asset IDs explicitly involved in this fact. Use asset_ids as the canonical field; tested_asset_ids is accepted as an alias. If both are provided, they must name the same set. Do not infer IDs from the intent."},
|
||||
"tested_asset_ids": map[string]any{"type": "array", "items": map[string]any{"type": "integer", "minimum": 1}, "description": "Compatibility alias for asset_ids, not an additional list. When both are provided their sets must match. Only include assets actually involved in this conclusion."},
|
||||
}, "summary")
|
||||
schema["properties"].(map[string]any)["summary"].(map[string]any)["minLength"] = 1
|
||||
return schema
|
||||
}
|
||||
|
||||
func recordFactSchema() map[string]any {
|
||||
props := factItemSchema()["properties"].(map[string]any)
|
||||
props["facts"] = map[string]any{
|
||||
"type": "array", "minItems": 1, "items": factItemSchema(),
|
||||
"description": "A non-empty batch of complete facts. Every item needs its own summary. Only intent_id inherits from the top level. Returned ids match item order; retry only failed indices.",
|
||||
}
|
||||
schema := obj(props)
|
||||
schema["anyOf"] = []any{
|
||||
map[string]any{"required": []string{"summary"}},
|
||||
map[string]any{"required": []string{"facts"}},
|
||||
}
|
||||
return schema
|
||||
}
|
||||
|
||||
// RepairRecordFactSchema restores the single/batch input contract in stored or
|
||||
// cached schemas without changing operator descriptions, defaults or extra fields.
|
||||
func RepairRecordFactSchema(stored map[string]any) map[string]any {
|
||||
raw, _ := json.Marshal(stored)
|
||||
var out map[string]any
|
||||
_ = json.Unmarshal(raw, &out)
|
||||
if out == nil {
|
||||
out = map[string]any{}
|
||||
}
|
||||
mergeFactContract(out, recordFactSchema())
|
||||
// A batch requires summaries on its items, never a redundant top-level one.
|
||||
delete(out, "required")
|
||||
return out
|
||||
}
|
||||
|
||||
func mergeFactContract(dst, src map[string]any) {
|
||||
for key, value := range src {
|
||||
if key == "description" || key == "default" {
|
||||
if _, ok := dst[key]; ok {
|
||||
continue
|
||||
}
|
||||
}
|
||||
if child, ok := value.(map[string]any); ok {
|
||||
target, _ := dst[key].(map[string]any)
|
||||
if target == nil {
|
||||
target = map[string]any{}
|
||||
dst[key] = target
|
||||
}
|
||||
mergeFactContract(target, child)
|
||||
} else {
|
||||
dst[key] = value
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,100 @@
|
||||
package agent
|
||||
|
||||
import (
|
||||
"encoding/json"
|
||||
"strings"
|
||||
"testing"
|
||||
|
||||
actool "github.com/Autumn-27/norma/tool"
|
||||
)
|
||||
|
||||
func TestRecordFactSummaryContract(t *testing.T) {
|
||||
tools := NewToolSet(guardTaskStore(t), "worker")
|
||||
tool := tools.recordFact()
|
||||
for _, input := range []string{
|
||||
`{}`, `null`, `[]`,
|
||||
`{"summary":""}`, `{"summary":" "}`,
|
||||
`{"summary":"must not substitute","facts":[]}`,
|
||||
`{"summary":"must not substitute","facts":null}`,
|
||||
`{"summary":"must not inherit","facts":[{"detail":"missing summary"}]}`,
|
||||
`{"facts":[{"summary":"must not save"},{"summary":42}]}`,
|
||||
} {
|
||||
out := callGuardTool(t, tool, input)
|
||||
if !out.IsError {
|
||||
t.Errorf("accepted %s: %s", input, out.Flatten())
|
||||
}
|
||||
}
|
||||
if tools.Writes().Facts != 0 {
|
||||
t.Fatal("invalid inputs wrote facts")
|
||||
}
|
||||
single := callGuardTool(t, tool, `{"summary":"valid single"}`)
|
||||
if single.IsError {
|
||||
t.Fatal(single.Flatten())
|
||||
}
|
||||
batch := callGuardTool(t, tool, `{"facts":[{"summary":"valid batch"},{"detail":"missing summary"}]}`)
|
||||
var result struct {
|
||||
IDs []int64 `json:"ids"`
|
||||
Errors map[string]string `json:"errors"`
|
||||
Retry string `json:"retry_instruction"`
|
||||
}
|
||||
if err := json.Unmarshal([]byte(batch.Flatten()), &result); err != nil {
|
||||
t.Fatal(batch.Flatten(), err)
|
||||
}
|
||||
if !batch.IsError || len(result.IDs) != 2 || result.IDs[0] <= 0 || result.IDs[1] != 0 ||
|
||||
!strings.Contains(result.Errors["1"], "summary") || result.Retry == "" || tools.Writes().Facts != 2 {
|
||||
t.Fatalf("partial failure is not actionable: %s", batch.Flatten())
|
||||
}
|
||||
}
|
||||
|
||||
func TestRecordFactStoredContractRepair(t *testing.T) {
|
||||
old := map[string]any{
|
||||
"type": "object", "required": []any{"summary"},
|
||||
"properties": map[string]any{
|
||||
"summary": map[string]any{"type": "string", "description": "operator summary"},
|
||||
"confidence": map[string]any{"type": "string", "default": "inferred"},
|
||||
"custom_field": map[string]any{"type": "string"},
|
||||
"facts": map[string]any{"type": "array", "items": map[string]any{"type": "object"}},
|
||||
},
|
||||
}
|
||||
base := NewToolSet(nil, "").recordFact()
|
||||
repaired := DecorateTool(base, "operator tool", old)
|
||||
schema := repaired.InputSchema()
|
||||
if _, required := schema["required"]; required {
|
||||
t.Fatal("batch still requires a top-level summary")
|
||||
}
|
||||
if len(schema["anyOf"].([]any)) != 2 {
|
||||
t.Fatal("single/batch alternatives missing")
|
||||
}
|
||||
props := schema["properties"].(map[string]any)
|
||||
item := props["facts"].(map[string]any)["items"].(map[string]any)
|
||||
required := item["required"].([]string)
|
||||
if len(required) != 1 || required[0] != "summary" || props["facts"].(map[string]any)["minItems"] != 1 {
|
||||
t.Fatal("batch must require a nonempty list with a summary per item")
|
||||
}
|
||||
if props["summary"].(map[string]any)["minLength"] != 1 ||
|
||||
item["properties"].(map[string]any)["summary"].(map[string]any)["minLength"] != 1 {
|
||||
t.Fatal("empty summaries permitted by schema")
|
||||
}
|
||||
if repaired.Description() != "operator tool" ||
|
||||
props["summary"].(map[string]any)["description"] != "operator summary" ||
|
||||
props["confidence"].(map[string]any)["default"] != "inferred" || props["custom_field"] == nil {
|
||||
t.Fatal("operator annotations lost")
|
||||
}
|
||||
if _, ok := old["properties"].(map[string]any)["tested_asset_ids"]; ok {
|
||||
t.Fatal("shared old schema mutated")
|
||||
}
|
||||
first, _ := json.Marshal(schema)
|
||||
second, _ := json.Marshal(DecorateTool(base, "", schema).InputSchema())
|
||||
if string(first) != string(second) {
|
||||
t.Fatal("repair is not idempotent")
|
||||
}
|
||||
var roundTrip map[string]any
|
||||
if err := json.Unmarshal(first, &roundTrip); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
for _, input := range []string{`{"summary":"single"}`, `{"facts":[{"summary":"batch"}]}`} {
|
||||
if err := actool.ValidateInput(roundTrip, json.RawMessage(input)); err != nil {
|
||||
t.Fatalf("SDK rejects valid %s after catalog round trip: %v", input, err)
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -162,6 +162,9 @@ func DecorateTool(t actool.CoreTool, desc string, schema map[string]any) actool.
|
||||
if len(schema) == 0 {
|
||||
schema = t.InputSchema()
|
||||
}
|
||||
if t.Name() == "record_fact" {
|
||||
schema = RepairRecordFactSchema(schema)
|
||||
}
|
||||
return &overriddenTool{CoreTool: t, desc: desc, schema: schema}
|
||||
}
|
||||
|
||||
|
||||
+30
-22
@@ -1491,13 +1491,14 @@ func (t *ToolSet) addFinding() actool.CoreTool {
|
||||
// must NOT be stuffed into the asset graph via upsert_asset.
|
||||
// factItem is one fact of a record_fact batch/single call.
|
||||
type factItem struct {
|
||||
Summary string `json:"summary"`
|
||||
Detail string `json:"detail"`
|
||||
Evidence string `json:"evidence"` // one line of key evidence (command + key output lines) supporting the conclusion, for later verification
|
||||
Confidence string `json:"confidence"` // observed (seen directly) | inferred (inferred from phenomena)
|
||||
Source string `json:"source"` // where the content came from, one of factSources; empty = inference
|
||||
IntentID json.RawMessage `json:"intent_id"`
|
||||
AssetIDs []json.RawMessage `json:"asset_ids"`
|
||||
Summary string `json:"summary"`
|
||||
Detail string `json:"detail"`
|
||||
Evidence string `json:"evidence"` // one line of key evidence (command + key output lines) supporting the conclusion, for later verification
|
||||
Confidence string `json:"confidence"` // observed (seen directly) | inferred (inferred from phenomena)
|
||||
Source string `json:"source"` // where the content came from, one of factSources; empty = inference
|
||||
IntentID json.RawMessage `json:"intent_id"`
|
||||
AssetIDs []json.RawMessage `json:"asset_ids"`
|
||||
TestedAssetIDs []json.RawMessage `json:"tested_asset_ids"`
|
||||
}
|
||||
|
||||
// Fact sources (#124, F4): where a fact's content came from, as declared by the
|
||||
@@ -1533,12 +1534,16 @@ func normalizeFactSource(s string) (string, error) {
|
||||
// intent_id).
|
||||
func (t *ToolSet) recordOneFact(it factItem, defaultIntent int64) (int64, error) {
|
||||
if strings.TrimSpace(it.Summary) == "" {
|
||||
return 0, fmt.Errorf("summary must not be empty")
|
||||
return 0, fmt.Errorf("summary must not be empty: every fact, including each batch item, requires its own one-sentence summary")
|
||||
}
|
||||
source, err := normalizeFactSource(it.Source)
|
||||
if err != nil {
|
||||
return 0, err
|
||||
}
|
||||
anchors, err := it.factAssetAnchors()
|
||||
if err != nil {
|
||||
return 0, err
|
||||
}
|
||||
payload := map[string]any{"summary": it.Summary, "source": source}
|
||||
if it.Detail != "" {
|
||||
payload["detail"] = it.Detail
|
||||
@@ -1560,7 +1565,7 @@ func (t *ToolSet) recordOneFact(it factItem, defaultIntent int64) (int64, error)
|
||||
}
|
||||
}
|
||||
// a fact is its OWN node kind (distinct from a vuln finding).
|
||||
id, err := t.ts.AddNode(db.KindFact, payload, 5, "confirmed", t.worker, pidList(it.AssetIDs))
|
||||
id, err := t.ts.AddNode(db.KindFact, payload, 5, "confirmed", t.worker, anchors)
|
||||
if err != nil {
|
||||
return 0, err
|
||||
}
|
||||
@@ -1580,23 +1585,23 @@ func (t *ToolSet) recordFact() actool.CoreTool {
|
||||
" · confidence = observed (seen directly in output) | inferred (inferred from phenomena).\n"+
|
||||
" · source = where the content came from: target_response (content the target itself returned: page bodies, headers, error messages, banners, even when a tool fetched it) | tool_output (a tool's own result about the target: port states, scanner verdicts, status codes, timings) | third_party_intel (OSINT, CVE databases, public reports) | operator_input (given by the human operator) | inference (your own reasoning; the default when omitted). Any other value is refused.\n"+
|
||||
" · **Negative conclusions** (not injectable / port closed / no entry found, etc.) state only \"observation + tentative reading\" — state what you actually saw; whether to abandon the direction is for the planner to decide globally; always provide evidence, mark inferred when the means weren't exhausted or the evidence is weak (including probed only once, looks-like), and mark observed only when truly exhausted and directly seen.",
|
||||
obj(map[string]any{
|
||||
"facts": map[string]any{"type": "array", "description": "[use when there are several distinct conclusions] array of facts; element fields same as the top-level fields below (summary/detail/evidence/confidence/source/intent_id/asset_ids); omitting intent_id falls back to the top-level intent_id. The returned ids match this array in length and order.", "items": map[string]any{"type": "object"}},
|
||||
"summary": str("a [one-sentence summary] of this exploration's conclusion (a condensation of detail)"),
|
||||
"intent_id": idp("the id of the intent that produced this fact (the intent you claimed; the default for each item in batch mode)"),
|
||||
"detail": str("details related to this fact: write all of this exploration's observations here"),
|
||||
"evidence": str("[one line] of key evidence: the command + the one or two most proving output lines. Keep it brief; don't paste large output blocks (details go in detail)."),
|
||||
"confidence": str("observed (seen directly in output) | inferred (inferred from phenomena). Always label negative conclusions honestly."),
|
||||
"source": map[string]any{"type": "string", "enum": factSources, "description": "where the content came from: target_response | tool_output | third_party_intel | operator_input | inference (default when omitted)"},
|
||||
"asset_ids": map[string]any{"type": "array", "items": map[string]any{"type": "integer"}, "description": "related asset ids (optional, 0/1/many): which assets this fact involves"},
|
||||
}),
|
||||
recordFactSchema(),
|
||||
func(_ context.Context, in json.RawMessage) (actool.Result, error) {
|
||||
var a struct {
|
||||
Facts []factItem `json:"facts"`
|
||||
factItem // single mode + batch default intent_id
|
||||
}
|
||||
_ = json.Unmarshal(in, &a)
|
||||
batch := len(a.Facts) > 0
|
||||
if err := json.Unmarshal(in, &a); err != nil {
|
||||
return actool.Errorf("invalid record_fact input: " + err.Error() + "; no facts were written"), nil
|
||||
}
|
||||
var fields map[string]json.RawMessage
|
||||
if err := json.Unmarshal(in, &fields); err != nil || fields == nil {
|
||||
return actool.Errorf("record_fact input must be an object; no facts were written"), nil
|
||||
}
|
||||
_, batch := fields["facts"]
|
||||
if batch && len(a.Facts) == 0 {
|
||||
return actool.Errorf("facts must be a non-empty array of complete facts, each with its own summary; for a single fact omit facts and provide summary. No facts were written"), nil
|
||||
}
|
||||
items := a.Facts
|
||||
if !batch {
|
||||
items = []factItem{a.factItem}
|
||||
@@ -1623,8 +1628,11 @@ func (t *ToolSet) recordFact() actool.CoreTool {
|
||||
out := map[string]any{"ids": ids}
|
||||
if len(errs) > 0 {
|
||||
out["errors"] = errs
|
||||
out["retry_instruction"] = "Retry only failed indices with complete facts, including summary. Successful indices were already saved; do not retry them."
|
||||
}
|
||||
return jsonResult(out)
|
||||
result, err := jsonResult(out)
|
||||
result.IsError = len(errs) > 0
|
||||
return result, err
|
||||
})
|
||||
}
|
||||
|
||||
|
||||
@@ -0,0 +1,38 @@
|
||||
package server
|
||||
|
||||
import (
|
||||
"encoding/json"
|
||||
"log"
|
||||
|
||||
"github.com/Autumn-27/artex/agent"
|
||||
)
|
||||
|
||||
// SeedTool only inserts new rows. Repair existing built-ins too, while keeping
|
||||
// descriptions, bindings, enabled/deferred flags and parameter annotations.
|
||||
func (s *Server) seedFactInputSchema() {
|
||||
row, err := s.m.pg.GetTool("record_fact")
|
||||
if err != nil {
|
||||
log.Printf("[facts] read record_fact schema: %v", err)
|
||||
return
|
||||
}
|
||||
if row == nil || !row.System || row.Kind != "builtin" {
|
||||
return
|
||||
}
|
||||
var schema map[string]any
|
||||
if err := json.Unmarshal(row.Schema, &schema); err != nil {
|
||||
log.Printf("[facts] decode record_fact schema: %v", err)
|
||||
return
|
||||
}
|
||||
raw, err := json.Marshal(agent.RepairRecordFactSchema(schema))
|
||||
if err != nil {
|
||||
log.Printf("[facts] encode record_fact schema: %v", err)
|
||||
return
|
||||
}
|
||||
// Compare-and-swap preserves concurrent operator edits; JSONB equality
|
||||
// avoids changing updated_at again on every startup.
|
||||
if _, err := s.m.pg.Exec(`UPDATE tools SET schema=$2::jsonb, updated_at=now()
|
||||
WHERE key='record_fact' AND system AND kind='builtin'
|
||||
AND schema=$1::jsonb AND schema IS DISTINCT FROM $2::jsonb`, string(row.Schema), string(raw)); err != nil {
|
||||
log.Printf("[facts] repair record_fact schema: %v", err)
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,99 @@
|
||||
package server
|
||||
|
||||
import (
|
||||
"context"
|
||||
"encoding/json"
|
||||
"testing"
|
||||
"time"
|
||||
|
||||
"github.com/Autumn-27/artex/agent"
|
||||
actool "github.com/Autumn-27/norma/tool"
|
||||
)
|
||||
|
||||
func TestRecordFactInputSchemaUpgrade(t *testing.T) {
|
||||
skipWithoutDSN(t)
|
||||
m, err := NewManager(t.TempDir(), "")
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
t.Cleanup(func() { m.Close() })
|
||||
ctx, cancel := context.WithCancel(context.Background())
|
||||
cancel()
|
||||
s := New(ctx, m, t.TempDir(), t.TempDir(), t.TempDir())
|
||||
t.Cleanup(func() { agent.SetToolResolve(nil) })
|
||||
pg := m.pg
|
||||
old, err := pg.GetTool("record_fact")
|
||||
if err != nil || old == nil {
|
||||
t.Fatal("missing record_fact", err)
|
||||
}
|
||||
bindings, _ := json.Marshal(old.Agents)
|
||||
t.Cleanup(func() { pg.UpdateTool(old.Key, old.Description, old.Schema, bindings, old.Enabled) })
|
||||
legacy := map[string]any{
|
||||
"type": "object", "required": []string{"summary"},
|
||||
"properties": map[string]any{
|
||||
"summary": map[string]any{"type": "string", "description": "operator summary"},
|
||||
"confidence": map[string]any{"type": "string", "default": "inferred"},
|
||||
"custom": map[string]any{"type": "string"},
|
||||
"facts": map[string]any{"type": "array", "items": map[string]any{"type": "object"}},
|
||||
},
|
||||
}
|
||||
raw, _ := json.Marshal(legacy)
|
||||
if err := pg.UpdateTool("record_fact", "operator tool", raw, bindings, old.Enabled); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
check := func(schema map[string]any) {
|
||||
t.Helper()
|
||||
if _, ok := schema["required"]; ok {
|
||||
t.Fatal("top-level summary still required for batches")
|
||||
}
|
||||
props := schema["properties"].(map[string]any)
|
||||
items := props["facts"].(map[string]any)["items"].(map[string]any)
|
||||
itemProps := items["properties"].(map[string]any)
|
||||
if props["tested_asset_ids"] == nil || itemProps["tested_asset_ids"] == nil || itemProps["summary"] == nil {
|
||||
t.Fatal("repaired schema missing alias or batch summary")
|
||||
}
|
||||
if props["summary"].(map[string]any)["description"] != "operator summary" ||
|
||||
props["confidence"].(map[string]any)["default"] != "inferred" || props["custom"] == nil {
|
||||
t.Fatal("operator annotations lost")
|
||||
}
|
||||
if err := actool.ValidateInput(schema, json.RawMessage(`{"facts":[{"summary":"complete batch item"}]}`)); err != nil {
|
||||
t.Fatal("valid batch rejected", err)
|
||||
}
|
||||
}
|
||||
// Runtime repair protects cached or edited rows even before startup migration.
|
||||
tools := agent.ToolResolve()(context.Background(), "worker", agent.NewToolSet(nil, "").WorkerTools())
|
||||
found := false
|
||||
for _, tool := range tools {
|
||||
if tool.Name() == "record_fact" {
|
||||
check(tool.InputSchema())
|
||||
found = true
|
||||
}
|
||||
}
|
||||
if !found {
|
||||
t.Fatal("record_fact not resolved")
|
||||
}
|
||||
s.seedFactInputSchema()
|
||||
repaired, err := pg.GetTool("record_fact")
|
||||
if err != nil || repaired == nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
var schema map[string]any
|
||||
if err := json.Unmarshal(repaired.Schema, &schema); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
check(schema)
|
||||
if repaired.Description != "operator tool" || repaired.Enabled != old.Enabled {
|
||||
t.Fatal("operator tool settings changed")
|
||||
}
|
||||
var before, after time.Time
|
||||
if err := pg.QueryRow("SELECT updated_at FROM tools WHERE key='record_fact'").Scan(&before); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
s.seedFactInputSchema()
|
||||
if err := pg.QueryRow("SELECT updated_at FROM tools WHERE key='record_fact'").Scan(&after); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if !before.Equal(after) {
|
||||
t.Fatal("second migration changed the row")
|
||||
}
|
||||
}
|
||||
@@ -47,8 +47,8 @@ func TestRecordFactSourceSchemaUpgrade(t *testing.T) {
|
||||
if err := pg.UpdateTool("record_fact", "operator description", custom, bindings, true); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if src := resolvedRecordFactProps(t)["source"]; src != nil {
|
||||
t.Fatalf("precondition: stored schema should not expose source yet: %v", src)
|
||||
if src := resolvedRecordFactProps(t)["source"]; src == nil {
|
||||
t.Fatal("runtime contract repair must expose source even before startup migration")
|
||||
}
|
||||
|
||||
snapshot := func() (string, string, time.Time) {
|
||||
|
||||
@@ -571,6 +571,7 @@ func (s *Server) seedOrchestrationTools() {
|
||||
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
|
||||
s.seedFactInputSchema() // restore record_fact single/batch contracts
|
||||
s.seedFactSourceSchema() // source enum on record_fact, added once per DB
|
||||
s.seedTaskScopeDescription() // add_task_scope: "coverage scope, not enforced" replaces the authorization-boundary text
|
||||
// Note: pentest's default tool bindings need no migration — BuiltinToolSeeds already seeds
|
||||
|
||||
Reference in New Issue
Block a user