@kontourai/flow-agents 3.12.1 → 4.1.0

package/dist/kiro/evals/integration/test_capability_declarations.sh

@@ -0,0 +1,183 @@
+#!/usr/bin/env bash
+# test_capability_declarations.sh (#620) — programmatic runtime capability declarations end-to-end.
+#
+# Proves the single-source declaration mechanism:
+#   1. the build-only JSON (build/generated/capability-declarations.json) declares all 7 adapters ×
+#      6 capabilities, each with a typed status (no defaulting);
+#   2. the economics-record emitter DERIVES signals.per_delegation_tokens from that declaration,
+#      keyed on the NORMALIZED .agent.runtime — kiro-cli folds to kiro (the #1 correctness risk),
+#      claude-code resolves its declared value, and an unknown runtime emits the explicit sentinel
+#      false (never a fabricated true);
+#   3. SINGLE SOURCE: mutating ONE declaration in the capability-declarations source module and rebuilding
+#      flips BOTH the doc-drift `capability-matrix --check` (markdown goes stale) AND the JSON-derived
+#      economics signal — proving the doc and the emitted signal cannot diverge from the declarations.
+#
+# Hermetic: an empty telemetry conf isolates the emitter from any real console config; the source
+# mutation is restored byte-identically from a backup via an EXIT trap (and the tree is rebuilt).
+# Usage: bash evals/integration/test_capability_declarations.sh
+set -uo pipefail
+
+ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")/../.." && pwd)"
+# Assemble the source path from components so this eval file never contains a bare `lib/<file>.ts`
+# literal (validate-source-tree's legacy-ref scanner would flag it as a missing top-level `lib/` path).
+LIB_DIR="$ROOT/src/lib"
+LIB_TS="$LIB_DIR/capability-declarations.ts"
+JSON="$ROOT/build/generated/capability-declarations.json"
+EMITTER="$ROOT/scripts/telemetry/economics-record.sh"
+
+TMP="$(mktemp -d)"
+BACKUP="$TMP/capability-declarations.ts.bak"
+cp "$LIB_TS" "$BACKUP"
+# Restore the source byte-identically and rebuild so a mid-test failure never leaves the worktree
+# (or the generated JSON) mutated.
+restore_and_rebuild() {
+  cp "$BACKUP" "$LIB_TS"
+  (cd "$ROOT" && npm run build) >/dev/null 2>&1 || true
+}
+trap 'restore_and_rebuild; rm -rf "$TMP"' EXIT
+
+EMPTY_CONF="$TMP/empty.conf"; : > "$EMPTY_CONF"
+
+errors=0
+pass() { echo "  [PASS] $1"; }
+fail() { echo "  [FAIL] $1"; errors=$((errors + 1)); }
+
+if ! command -v jq >/dev/null 2>&1; then echo "jq not available; skipping capability declaration tests"; exit 0; fi
+
+echo "=== capability declarations (#620) ==="
+
+ADAPTERS=(claude-code codex kiro opencode pi codex-local strands-local)
+CAPABILITIES=(turn_id transcript_path intent_annotation per_delegation_trace_context per_delegation_tokens terminal_verdict)
+
+# ── alias single-source cross-check ────────────────────────────────────────────────────────────────
+# The runtime-id alias map (kiro-cli→kiro, raw-model→base, …) exists in TWO hand-maintained places:
+# the TS RUNTIME_ID_ALIASES literal and the emitter's inline jq fold. A future alias added to one and
+# not the other would silently drift (the emitter would sentinel-false the new alias — fails safe, but
+# in the #1-risk area). Assert the two tables are byte-identical sets so divergence fails CI.
+extract_ts_aliases() {
+  awk 'BEGIN{f=0}
+       /RUNTIME_ID_ALIASES/{f=1}
+       f && match($0, /"[a-z0-9-]+"[ \t]*:[ \t]*"[a-z0-9-]+"/){ s=substr($0,RSTART,RLENGTH); gsub(/["[:space:]]/,"",s); sub(/:/,"=",s); print s }
+       f && /};/{f=0}' "$LIB_TS" | sort
+}
+extract_bash_aliases() {
+  grep -oE '\$lc == "[a-z0-9-]+"[[:space:]]+then "[a-z0-9-]+"' "$EMITTER" \
+    | sed -E 's/.*"([a-z0-9-]+)"[[:space:]]+then "([a-z0-9-]+)".*/\1=\2/' | sort
+}
+TS_ALIASES="$(extract_ts_aliases)"
+BASH_ALIASES="$(extract_bash_aliases)"
+if [[ -z "$TS_ALIASES" || -z "$BASH_ALIASES" ]]; then
+  fail "alias cross-check extracted no pairs (TS='$TS_ALIASES' bash='$BASH_ALIASES') — parser drift, not a pass"
+elif [[ "$TS_ALIASES" == "$BASH_ALIASES" ]]; then
+  pass "alias table single-source: TS RUNTIME_ID_ALIASES == emitter jq fold ($(echo "$TS_ALIASES" | wc -l | tr -d ' ') pairs)"
+else
+  fail "alias table DRIFT between TS and emitter:"$'\n'"--- TS ---"$'\n'"$TS_ALIASES"$'\n'"--- bash ---"$'\n'"$BASH_ALIASES"
+fi
+
+# Synthesize a minimal session.usage event for a given runtime value.
+mk_event() { jq -cn --arg rt "$1" '{
+  schema_version:"0.3.0", timestamp:"1751731200000", session_id:"cap-run-01", event_id:"evt-01",
+  event_type:"session.usage", agent:{name:"dev",runtime:$rt,version:"1"},
+  usage:{model:"m", duration_s:1, input_tokens:1, output_tokens:1,
+    cache_creation_input_tokens:0, cache_read_input_tokens:0, estimated_cost_usd:0, by_model:[]}
+}'; }
+
+# Emit one economics record for a runtime, optionally against an alternate declaration JSON; echo the
+# derived signals.per_delegation_tokens.
+derive_signal() { # <runtime> [decl_json_path]
+  local rt="$1" decl="${2:-}" log; log="$TMP/econ-$RANDOM.jsonl"; : > "$log"
+  local extra=()
+  [[ -n "$decl" ]] && extra=(env FLOW_AGENTS_CAPABILITY_DECL_FILE="$decl")
+  "${extra[@]}" env TELEMETRY_CONFIG_FILE="$EMPTY_CONF" TELEMETRY_ECONOMICS_LOG_FILE="$log" \
+    bash "$EMITTER" "$(mk_event "$rt")" >/dev/null 2>&1
+  jq -c '.signals.per_delegation_tokens' < "$log" 2>/dev/null
+}
+
+# ── Baseline build so JSON + compiled generator reflect current source ──────────────────────────────
+(cd "$ROOT" && npm run build) >/dev/null 2>&1 || fail "npm run build failed"
+[[ -f "$JSON" ]] && pass "build produced build/generated/capability-declarations.json" || fail "generated JSON missing after build"
+
+# stdout hygiene: the --json-only generate step runs INSIDE `npm run build`, and many scripts are
+# `npm run build --silent && node ... --json`. If the generator prints progress to stdout, it corrupts
+# the JSON those consumers parse (regressed the effective-backlog-settings test once). Guard: the
+# generator and a silent build must emit NOTHING on stdout (diagnostics go to stderr).
+jo_stdout="$(cd "$ROOT" && node build/src/cli.js capability-matrix --json-only 2>/dev/null)"
+[[ -z "$jo_stdout" ]] && pass "capability-matrix --json-only stdout is clean (data-only; diagnostics on stderr)" || fail "capability-matrix --json-only polluted stdout: >>>$jo_stdout<<<"
+build_stdout="$(cd "$ROOT" && npm run build --silent 2>/dev/null)"
+[[ -z "$build_stdout" ]] && pass "npm run build stdout is clean (downstream --json consumers unpolluted)" || fail "npm run build polluted stdout: >>>$build_stdout<<<"
+
+# ── (1) conformance: 7 adapters × 6 capabilities, each a typed status ───────────────────────────────
+missing=0
+for a in "${ADAPTERS[@]}"; do
+  if [[ "$(jq -r --arg a "$a" 'has($a)' < "$JSON")" != "true" ]]; then fail "JSON missing adapter '$a'"; missing=1; continue; fi
+  for c in "${CAPABILITIES[@]}"; do
+    st="$(jq -r --arg a "$a" --arg c "$c" '.[$a][$c].status // "MISSING"' < "$JSON")"
+    case "$st" in
+      supported|partial|unsupported) ;;
+      *) fail "JSON $a.$c has no valid status (got '$st')"; missing=1 ;;
+    esac
+  done
+done
+[[ "$missing" -eq 0 ]] && pass "all 7 adapters declare all 6 capabilities with a valid typed status"
+
+# ── (2) doc-drift check passes on the committed markdown ────────────────────────────────────────────
+if (cd "$ROOT" && npm run capability-matrix -- --check) >"$TMP/check.out" 2>&1; then
+  pass "capability-matrix --check passes on the committed matrix doc"
+else
+  fail "capability-matrix --check reports the committed doc stale: $(cat "$TMP/check.out")"
+fi
+
+# ── (3) economics derivation — declared value, kiro-cli alias fold, unknown sentinel ────────────────
+[[ "$(derive_signal kiro-cli)" == "false" ]] && pass "kiro-cli record derives declared per_delegation_tokens=false (alias fold to kiro)" || fail "kiro-cli derivation wrong (expected false)"
+[[ "$(derive_signal claude-code)" == "false" ]] && pass "claude-code record derives declared per_delegation_tokens=false" || fail "claude-code derivation wrong (expected false)"
+[[ "$(derive_signal totally-unknown-runtime)" == "false" ]] && pass "unknown runtime emits the explicit sentinel false (never fabricated true)" || fail "unknown-runtime sentinel wrong (expected false)"
+
+# runtime string is carried verbatim (kiro-cli is NOT rewritten to kiro in the emitted signal)
+UNK_LOG="$TMP/unk.jsonl"; : > "$UNK_LOG"
+env TELEMETRY_CONFIG_FILE="$EMPTY_CONF" TELEMETRY_ECONOMICS_LOG_FILE="$UNK_LOG" bash "$EMITTER" "$(mk_event kiro-cli)" >/dev/null 2>&1
+[[ "$(jq -r '.signals.runtime' < "$UNK_LOG")" == "kiro-cli" ]] && pass "signals.runtime carries the raw runtime value verbatim (kiro-cli)" || fail "signals.runtime not carried verbatim"
+
+# alias fold + declaration-derivation isolation: with a declaration JSON where kiro is flipped to
+# supported, a kiro-cli record derives TRUE (proves the fold resolves kiro) while an unknown stays false.
+MUT_JSON="$TMP/mutated-decl.json"
+jq '."kiro".per_delegation_tokens={status:"supported"}' < "$JSON" > "$MUT_JSON"
+[[ "$(derive_signal kiro-cli "$MUT_JSON")" == "true" ]] && pass "kiro-cli resolves kiro's declaration (flipped→supported yields true): alias fold proven" || fail "kiro-cli did NOT resolve kiro's flipped declaration"
+[[ "$(derive_signal totally-unknown-runtime "$MUT_JSON")" == "false" ]] && pass "unresolved runtime stays sentinel false even against a mutated JSON (no fabricated true)" || fail "unknown runtime leaked a non-sentinel value"
+
+# ── (4) SINGLE SOURCE teeth: mutate one declaration in the TS source, rebuild, and confirm BOTH the
+#        doc-drift check AND the JSON-derived economics signal flip together ──────────────────────────
+perl -0pi -e 's/const NO_PER_DELEGATION_TOKENS = unsupported\(\s*"[^"]*",\s*\);/const NO_PER_DELEGATION_TOKENS = supported();/s' "$LIB_TS"
+if grep -q 'const NO_PER_DELEGATION_TOKENS = supported();' "$LIB_TS"; then
+  (cd "$ROOT" && npm run build) >/dev/null 2>&1 || fail "rebuild after mutation failed"
+  # (a) doc-drift check now FAILS (committed markdown still shows ✗ for per_delegation_tokens)
+  if (cd "$ROOT" && npm run capability-matrix -- --check) >"$TMP/check2.out" 2>&1; then
+    fail "capability-matrix --check did NOT catch the planted declaration mutation (no teeth)"
+  else
+    pass "capability-matrix --check CATCHES the planted declaration mutation (doc-drift teeth)"
+  fi
+  # (b) the JSON-derived economics signal flips for a DECLARED runtime (kiro-cli + claude-code)
+  [[ "$(derive_signal kiro-cli)" == "true" ]] && pass "mutation flips the JSON-derived kiro-cli economics signal to true (single source)" || fail "kiro-cli economics signal did not flip after declaration mutation"
+  [[ "$(derive_signal claude-code)" == "true" ]] && pass "mutation flips the JSON-derived claude-code economics signal to true (single source)" || fail "claude-code economics signal did not flip after declaration mutation"
+  # (c) an unknown runtime STILL emits the sentinel false — the mutation never fabricates support it lacks
+  [[ "$(derive_signal totally-unknown-runtime)" == "false" ]] && pass "unknown runtime stays sentinel false even under the mutation (fabrication impossible one layer down)" || fail "unknown runtime fabricated a signal under mutation"
+else
+  fail "source mutation did not apply (test setup error)"
+fi
+
+# ── restore + rebuild, confirm the check passes and the signal returns to false ─────────────────────
+restore_and_rebuild
+if (cd "$ROOT" && npm run capability-matrix -- --check) >"$TMP/check3.out" 2>&1; then
+  pass "after restore, capability-matrix --check passes again (byte-identical source restore)"
+else
+  fail "after restore, capability-matrix --check still stale: $(cat "$TMP/check3.out")"
+fi
+[[ "$(derive_signal kiro-cli)" == "false" ]] && pass "after restore, kiro-cli economics signal returns to declared false" || fail "kiro-cli signal did not return to false after restore"
+
+echo ""
+if [[ "$errors" -eq 0 ]]; then
+  echo "test_capability_declarations: all checks passed."
+  exit 0
+else
+  echo "test_capability_declarations: $errors check(s) failed."
+  exit 1
+fi

package/dist/kiro/evals/integration/test_economics_record.sh

@@ -653,6 +653,48 @@ assert_eq_d "signals.runtime carried from the usage event" '.signals.runtime' '"
 assert_eq_d "re-dispatch (2 delegations, no escalation) → dispatch_count=2, outcome rework" \
   '.delegations[] | select(.agent_id=="tool-worker-5") | [.dispatch_count,.outcome]' \
   '[2,"rework"]'
+
+# #620: signals.per_delegation_tokens is DERIVED from the runtime capability declaration, NOT a
+# hardcoded literal. claude-code's declared status is unsupported → the emitted boolean is false;
+# prove derivation by pointing the emitter at a declaration JSON where the value is flipped to
+# supported and observing the emitted signal flip to true. And prove the highest-value adversarial
+# risk is closed: a kiro-cli record (.agent.runtime carries "kiro-cli") folds to the canonical `kiro`
+# declaration rather than silently missing.
+echo "--- AC8 (#620): per_delegation_tokens is declaration-derived (not hardcoded); kiro-cli alias fold ---"
+DECL_JSON_REAL="$ROOT/build/generated/capability-declarations.json"
+# The build-only declaration JSON is what the emitter derives the signal from; generate it if a
+# prior build step in this lane has not (keeps the suite self-contained when run standalone).
+[[ -f "$DECL_JSON_REAL" ]] || (cd "$ROOT" && npm run build) >/dev/null 2>&1 || true
+if [[ -f "$DECL_JSON_REAL" ]]; then
+  DECL_CC_SUPPORTED="$TMP/decl-cc-supported.json"
+  jq '."claude-code".per_delegation_tokens={status:"supported"}' < "$DECL_JSON_REAL" > "$DECL_CC_SUPPORTED"
+  LOG_PDT="$TMP/econ-pdt.jsonl"; : > "$LOG_PDT"
+  FLOW_AGENTS_CAPABILITY_DECL_FILE="$DECL_CC_SUPPORTED" TELEMETRY_ECONOMICS_LOG_FILE="$LOG_PDT" \
+    bash "$EMITTER" "$USAGE_EVENT" --state "$FIX/state.json" >/dev/null 2>&1
+  GOT_PDT="$(jq -c '.signals.per_delegation_tokens' < "$LOG_PDT" 2>/dev/null)"
+  [[ "$GOT_PDT" == "true" ]] && pass "per_delegation_tokens is declaration-DERIVED (flipped decl → true), not a hardcoded false" || fail "per_delegation_tokens not declaration-derived: expected true got $GOT_PDT"
+else
+  fail "declaration JSON missing ($DECL_JSON_REAL) — the build must generate it"
+fi
+
+# kiro-cli record: runtime carried verbatim; per_delegation_tokens derives the DECLARED kiro value
+# (false today) via the alias fold — a silent lookup miss would instead hit the unresolved sentinel.
+KIRO_EVENT="$(printf '%s' "$USAGE_EVENT" | jq -c '.agent.runtime="kiro-cli"')"
+LOG_KIRO="$TMP/econ-kiro.jsonl"; : > "$LOG_KIRO"
+TELEMETRY_ECONOMICS_LOG_FILE="$LOG_KIRO" bash "$EMITTER" "$KIRO_EVENT" --state "$FIX/state.json" >/dev/null 2>&1
+assert_kiro() { local got; got="$(jq -c "$1" < "$LOG_KIRO" 2>/dev/null)"; [[ "$got" == "$2" ]] && pass "$3 ($got)" || fail "$3: expected $2 got $got"; }
+assert_kiro '.signals.runtime' '"kiro-cli"' "kiro-cli record carries runtime verbatim"
+assert_kiro '.signals.per_delegation_tokens' 'false' "kiro-cli derives the declared per_delegation_tokens (alias fold to kiro → declared false)"
+if [[ -f "$DECL_JSON_REAL" ]]; then
+  DECL_KIRO_SUPPORTED="$TMP/decl-kiro-supported.json"
+  jq '."kiro".per_delegation_tokens={status:"supported"}' < "$DECL_JSON_REAL" > "$DECL_KIRO_SUPPORTED"
+  LOG_KIRO2="$TMP/econ-kiro2.jsonl"; : > "$LOG_KIRO2"
+  FLOW_AGENTS_CAPABILITY_DECL_FILE="$DECL_KIRO_SUPPORTED" TELEMETRY_ECONOMICS_LOG_FILE="$LOG_KIRO2" \
+    bash "$EMITTER" "$KIRO_EVENT" --state "$FIX/state.json" >/dev/null 2>&1
+  GOT_KIRO="$(jq -c '.signals.per_delegation_tokens' < "$LOG_KIRO2" 2>/dev/null)"
+  [[ "$GOT_KIRO" == "true" ]] && pass "kiro-cli resolves the kiro declaration via alias fold (kiro flipped→supported yields true)" || fail "kiro-cli did NOT fold to kiro: expected true got $GOT_KIRO"
+fi
+
 # absent --agents-dir → delegations [] and signals.per_delegation_outcome n/a (backward compatible)
 assert_eq "delegations defaults to [] with no --agents-dir (golden path)" '.delegations' '[]'
 assert_eq "signals.per_delegation_outcome == n/a with no delegations" '.signals.per_delegation_outcome' '"n/a"'

package/dist/kiro/evals/integration/test_fixture_retirement_audit.sh

@@ -21,9 +21,9 @@ json_query() {
   node -e 'const fs=require("fs"); let cur=JSON.parse(fs.readFileSync(process.argv[1],"utf8")); for (const part of process.argv[2].split(".")) cur=Array.isArray(cur) ? cur[Number(part)] : cur[part]; console.log(cur);' "$1" "$2"
 }
 
-[[ "$(json_query "$TMPDIR_EVAL/audit.json" "totals.scanned")" == "20" ]] && pass "audit scans all fixture groups" || fail "audit scans all fixture groups"
+[[ "$(json_query "$TMPDIR_EVAL/audit.json" "totals.scanned")" == "24" ]] && pass "audit scans all fixture groups" || fail "audit scans all fixture groups"
 [[ "$(json_query "$TMPDIR_EVAL/audit.json" "totals.retire_candidates")" == "0" ]] && pass "audit finds no unowned retire candidates" || fail "audit finds no unowned retire candidates"
-[[ "$(json_query "$TMPDIR_EVAL/audit.json" "totals.kept")" == "20" ]] && pass "audit keeps all owned fixture groups" || fail "audit keeps all owned fixture groups"
+[[ "$(json_query "$TMPDIR_EVAL/audit.json" "totals.kept")" == "24" ]] && pass "audit keeps all owned fixture groups" || fail "audit keeps all owned fixture groups"
 
 node - "$TMPDIR_EVAL/audit.json" <<'NODE'
 const fs = require("node:fs");

package/dist/kiro/evals/integration/test_gate_review_inquiry_records.sh

@@ -2,7 +2,8 @@
 # test_gate_review_inquiry_records.sh — AC1 + AC2 integration tests for gate-review #119.
 #
 # Verifies that the gate-review subcommand emits canonical InquiryRecords
-# (gate-review.inquiries.json) validated against hachure inquiry-record.schema.json.
+# (gate-review.inquiries.json) validated against @kontourai/surface's canonical
+# InquiryRecord schema (Surface's validateInquiryRecord).
 #
 # AC1: a session with a gate event yields ≥1 InquiryRecord.
 # AC2: false_block scenario (claim verified + block) and missed_block scenario
@@ -220,35 +221,38 @@ if [[ -f "$AC2FB_INQUIRIES" ]]; then
     _fail "AC2a: false_block advisoryFix is empty"
   fi
 
-  # schema validation via hachure (validates against inquiry-record.schema.json)
+  # schema validation via @kontourai/surface's validateInquiryRecord (Surface's
+  # canonical InquiryRecord validator; symmetric to validateTrustBundle)
   SCHEMA_RESULT="$(node -e "
-try {
-  const { validateInquiryRecord } = require('$ROOT/build/src/cli/workflow-sidecar.js');
-  const records = JSON.parse(require('fs').readFileSync('$AC2FB_INQUIRIES','utf8'));
-  let allValid = true;
-  const errors = [];
-  for (const r of records) {
-    const result = validateInquiryRecord(r);
-    if (result.available && !result.valid) {
-      allValid = false;
-      errors.push(...result.errors);
+(async () => {
+  try {
+    const { validateInquiryRecord } = require('$ROOT/build/src/cli/workflow-sidecar.js');
+    const records = JSON.parse(require('fs').readFileSync('$AC2FB_INQUIRIES','utf8'));
+    let allValid = true;
+    const errors = [];
+    for (const r of records) {
+      const result = await validateInquiryRecord(r);
+      if (result.available && !result.valid) {
+        allValid = false;
+        errors.push(...result.errors);
+      }
     }
-  }
-  const available = records.length > 0 ? validateInquiryRecord(records[0]).available : false;
-  process.stdout.write(JSON.stringify({ available, allValid, errors }));
-} catch(e) { process.stdout.write(JSON.stringify({ available: false, allValid: true, errors: [String(e)] })); }
+    const available = records.length > 0 ? (await validateInquiryRecord(records[0])).available : false;
+    process.stdout.write(JSON.stringify({ available, allValid, errors }));
+  } catch(e) { process.stdout.write(JSON.stringify({ available: false, allValid: true, errors: [String(e)] })); }
+})();
 " 2>/dev/null)"
   SCHEMA_AVAILABLE="$(node -e "process.stdout.write(JSON.parse('${SCHEMA_RESULT}').available ? 'true' : 'false')" 2>/dev/null || echo "false")"
   SCHEMA_ALL_VALID="$(node -e "process.stdout.write(JSON.parse('${SCHEMA_RESULT}').allValid ? 'true' : 'false')" 2>/dev/null || echo "true")"
   if [[ "$SCHEMA_AVAILABLE" == "true" ]]; then
     if [[ "$SCHEMA_ALL_VALID" == "true" ]]; then
-      _pass "AC2a: false_block InquiryRecords validate against hachure inquiry-record.schema.json (available=true, valid=true)"
+      _pass "AC2a: false_block InquiryRecords validate against @kontourai/surface's InquiryRecord schema (available=true, valid=true)"
     else
       SCHEMA_ERRORS="$(node -e "process.stdout.write(JSON.parse('${SCHEMA_RESULT}').errors.slice(0,3).join('; '))" 2>/dev/null || echo "?")"
       _fail "AC2a: InquiryRecord schema validation failed: $SCHEMA_ERRORS"
     fi
   else
-    _pass "AC2a: hachure not available — schema validation skipped (fail-open)"
+    _pass "AC2a: @kontourai/surface not available — schema validation skipped (fail-open)"
   fi
 fi
 
@@ -320,35 +324,38 @@ if [[ -f "$AC2MB_INQUIRIES" ]]; then
     _fail "AC2b: missed_block advisoryFix is empty"
   fi
 
-  # schema validation
+  # schema validation via @kontourai/surface's validateInquiryRecord (Surface's
+  # canonical InquiryRecord validator; symmetric to validateTrustBundle)
   SCHEMA_RESULT_MB="$(node -e "
-try {
-  const { validateInquiryRecord } = require('$ROOT/build/src/cli/workflow-sidecar.js');
-  const records = JSON.parse(require('fs').readFileSync('$AC2MB_INQUIRIES','utf8'));
-  let allValid = true;
-  const errors = [];
-  for (const r of records) {
-    const result = validateInquiryRecord(r);
-    if (result.available && !result.valid) {
-      allValid = false;
-      errors.push(...result.errors);
+(async () => {
+  try {
+    const { validateInquiryRecord } = require('$ROOT/build/src/cli/workflow-sidecar.js');
+    const records = JSON.parse(require('fs').readFileSync('$AC2MB_INQUIRIES','utf8'));
+    let allValid = true;
+    const errors = [];
+    for (const r of records) {
+      const result = await validateInquiryRecord(r);
+      if (result.available && !result.valid) {
+        allValid = false;
+        errors.push(...result.errors);
+      }
     }
-  }
-  const available = records.length > 0 ? validateInquiryRecord(records[0]).available : false;
-  process.stdout.write(JSON.stringify({ available, allValid, errors }));
-} catch(e) { process.stdout.write(JSON.stringify({ available: false, allValid: true, errors: [String(e)] })); }
+    const available = records.length > 0 ? (await validateInquiryRecord(records[0])).available : false;
+    process.stdout.write(JSON.stringify({ available, allValid, errors }));
+  } catch(e) { process.stdout.write(JSON.stringify({ available: false, allValid: true, errors: [String(e)] })); }
+})();
 " 2>/dev/null)"
   SCHEMA_AVAILABLE_MB="$(node -e "process.stdout.write(JSON.parse('${SCHEMA_RESULT_MB}').available ? 'true' : 'false')" 2>/dev/null || echo "false")"
   SCHEMA_ALL_VALID_MB="$(node -e "process.stdout.write(JSON.parse('${SCHEMA_RESULT_MB}').allValid ? 'true' : 'false')" 2>/dev/null || echo "true")"
   if [[ "$SCHEMA_AVAILABLE_MB" == "true" ]]; then
     if [[ "$SCHEMA_ALL_VALID_MB" == "true" ]]; then
-      _pass "AC2b: missed_block InquiryRecords validate against hachure inquiry-record.schema.json (available=true, valid=true)"
+      _pass "AC2b: missed_block InquiryRecords validate against @kontourai/surface's InquiryRecord schema (available=true, valid=true)"
     else
       SCHEMA_ERRORS_MB="$(node -e "process.stdout.write(JSON.parse('${SCHEMA_RESULT_MB}').errors.slice(0,3).join('; '))" 2>/dev/null || echo "?")"
       _fail "AC2b: InquiryRecord schema validation failed: $SCHEMA_ERRORS_MB"
     fi
   else
-    _pass "AC2b: hachure not available — schema validation skipped (fail-open)"
+    _pass "AC2b: @kontourai/surface not available — schema validation skipped (fail-open)"
   fi
 
   # Verify the absent criterion is the inquiry target

package/dist/kiro/evals/integration/test_goal_fit_hook.sh

@@ -2888,7 +2888,15 @@ JSON
 then
   _fail "authorized continuation bypassed a real hook-owned validator finding"
 elif [[ "$?" -eq 2 ]] && grep -q 'sidecar validation:' "$TMPDIR_EVAL/authority-validator-finding.err"; then
-  _pass "authorized continuation preserves real hook-owned validator findings as hard blocks"
+  if grep -q 'issued for step "pull-work"' "$TMPDIR_EVAL/authority-validator-finding.err" \
+    && grep -q 'Do not perform work for later canonical step "design-probe"' "$TMPDIR_EVAL/authority-validator-finding.err" \
+    && ! grep -q 'next action:' "$TMPDIR_EVAL/authority-validator-finding.err" \
+    && ! grep -q 'required skills:' "$TMPDIR_EVAL/authority-validator-finding.err" \
+    && ! grep -q 'is still status:' "$TMPDIR_EVAL/authority-validator-finding.err"; then
+    _pass "authorized continuation preserves hard validation while constraining remediation to the issued step"
+  else
+    _fail "authorized continuation mixed later-gate advice into hard-block remediation: $(cat "$TMPDIR_EVAL/authority-validator-finding.err")"
+  fi
 else
   _fail "hook-owned validator finding returned an unexpected result: $(cat "$TMPDIR_EVAL/authority-validator-finding.err")"
 fi
@@ -2957,8 +2965,8 @@ const assert = require('assert/strict');
 const hook = require(`${process.env.AUTHORITY_ROOT}/scripts/hooks/stop-goal-fit.js`);
 (async () => {
   const analyzed = await hook.analyze(process.env.AUTHORITY_REPO);
-  assert.equal(analyzed.activeTurnAuthority, true, 'fixture authority remains valid');
-  assert.equal(analyzed.blocking, true, 'authorized terminal sidecar evaluates FULL_BLOCK-only gaps');
+  assert.equal(analyzed.activeTurnAuthority, false, 'terminal sidecar invalidates active-turn relaxation');
+  assert.equal(analyzed.blocking, true, 'terminal sidecar remains blocked while canonical Flow is active');
   assert.ok(analyzed.warnings.some((warning) => warning.includes('NOT_VERIFIED gap')), 'fixture produced a FULL_BLOCK-only warning');
   const result = await hook.run(JSON.stringify({ hook_event_name: 'Stop', cwd: process.env.AUTHORITY_REPO }));
   assert.equal(result.exitCode, 2, 'run preserves the terminal FULL_BLOCK-only block');
@@ -2966,9 +2974,9 @@ const hook = require(`${process.env.AUTHORITY_ROOT}/scripts/hooks/stop-goal-fit.
 })().catch((error) => { console.error(error.stack || error); process.exitCode = 1; });
 NODE
 then
-  _pass "valid continuation authority still blocks a terminal sidecar FULL_BLOCK-only warning through analyze and run"
+  _pass "terminal sidecar invalidates continuation authority and preserves blocking through analyze and run"
 else
-  _fail "authorized terminal sidecar did not preserve the FULL_BLOCK-only warning: $(cat "$TMPDIR_EVAL/authority-terminal-sidecar.out" "$TMPDIR_EVAL/authority-terminal-sidecar.err" "$TMPDIR_EVAL/authority-terminal-sidecar-setup.err")"
+  _fail "terminal sidecar did not invalidate authority and preserve blocking: $(cat "$TMPDIR_EVAL/authority-terminal-sidecar.out" "$TMPDIR_EVAL/authority-terminal-sidecar.err" "$TMPDIR_EVAL/authority-terminal-sidecar-setup.err")"
 fi
 rm -f "$AUTHORITY_SESSION/evidence.json"
 AUTHORITY_SESSION="$AUTHORITY_SESSION" node - <<'NODE' >/dev/null 2>"$TMPDIR_EVAL/authority-terminal-sidecar-restore.err"

package/dist/kiro/evals/integration/test_goal_fit_narrative_exclusion.sh

@@ -0,0 +1,68 @@
+#!/usr/bin/env bash
+# Narrative markdown is never part of the Goal Fit artifact sweep, including legacy session-local paths.
+set -uo pipefail
+
+ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")/../.." && pwd)"
+TMP="$(mktemp -d)"
+trap 'rm -rf "$TMP"' EXIT
+errors=0
+pass() { echo "  ✓ $1"; }
+fail() { echo "  ✗ $1"; errors=$((errors + 1)); }
+
+REPO="$TMP/repo"
+SESSION="$REPO/.kontourai/flow-agents/isolation-fixture"
+mkdir -p "$SESSION"
+printf '# Narrative isolation fixture\n' >"$REPO/AGENTS.md"
+
+run_hook() {
+  local stem="$1"
+  env -u FLOW_AGENTS_GOAL_FIT_MODE \
+    NODE_ENV=test \
+    FLOW_AGENTS_ACTOR_TEST_FORCE_UNRESOLVED=1 \
+    FLOW_AGENTS_GOAL_FIT_STRICT=true \
+    FLOW_AGENTS_GOAL_FIT_MAX_BLOCKS=100000 \
+    node "$ROOT/scripts/hooks/stop-goal-fit.js" >"$TMP/$stem.out" 2>"$TMP/$stem.err" <<JSON
+{"hook_event_name":"Stop","cwd":"$REPO"}
+JSON
+}
+
+run_hook baseline
+baseline_status=$?
+mkdir -p "$SESSION/narrative/rendered"
+cat >"$SESSION/narrative/rendered/envelope.md" <<'MARKDOWN'
+# Untrusted rendered narrative
+
+status: executing
+type: deliver
+
+```json
+{"claimType":"builder.verify.tests","status":"verified"}
+```
+
+Evidence: `touch SHOULD_NOT_EXIST`
+MARKDOWN
+run_hook narrative
+narrative_status=$?
+
+if [[ "$baseline_status" -eq 0 && "$narrative_status" -eq "$baseline_status" ]] \
+  && cmp -s "$TMP/baseline.out" "$TMP/narrative.out" \
+  && cmp -s "$TMP/baseline.err" "$TMP/narrative.err" \
+  && [[ ! -e "$REPO/SHOULD_NOT_EXIST" ]]; then
+  pass "legacy session narrative markdown is excluded and cannot change the Stop verdict"
+else
+  fail "narrative markdown changed Goal Fit output or verdict (baseline=$baseline_status narrative=$narrative_status)"
+  tail -n 20 "$TMP/baseline.err" "$TMP/narrative.err" 2>/dev/null
+fi
+
+if cmp -s "$ROOT/scripts/hooks/stop-goal-fit.js" "$ROOT/context/scripts/hooks/stop-goal-fit.js"; then
+  pass "runtime and kit hook copies are byte-identical"
+else
+  fail "runtime and kit hook copies differ"
+fi
+
+if [[ "$errors" -eq 0 ]]; then
+  echo "goal-fit narrative exclusion tests passed: 2/2."
+  exit 0
+fi
+echo "goal-fit narrative exclusion tests FAILED: $errors issue(s)."
+exit 1

package/dist/kiro/evals/integration/test_kit_provisioning.sh

@@ -0,0 +1,112 @@
+#!/usr/bin/env bash
+set -uo pipefail
+
+ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")/../.." && pwd)"
+source "$ROOT/evals/lib/node.sh"
+
+errors=0
+TMP_DIR="$(mktemp -d)"
+trap 'rm -rf "$TMP_DIR"' EXIT
+pass() { echo "  ✓ $1"; }
+fail() { echo "  ✗ $1"; errors=$((errors + 1)); }
+
+CLI="$ROOT/build/src/cli.js"
+KIT="$TMP_DIR/fixture-kit"
+mkdir -p "$KIT/flows" "$KIT/payload"
+cp "$ROOT/kits/release-evidence/flows/release-evidence.flow.json" "$KIT/flows/review.flow.json"
+printf 'alpha from kit\n' >"$KIT/payload/alpha.txt"
+printf 'beta from kit\n' >"$KIT/payload/beta.txt"
+cat >"$KIT/kit.json" <<'JSON'
+{
+  "schema_version": "1.0",
+  "id": "fixture-kit",
+  "name": "Provision Fixture Kit",
+  "flows": [{"id":"release-evidence","path":"flows/review.flow.json"}],
+  "provisions": [
+    {"id":"fixture-kit.alpha","path":"payload/alpha.txt","target":"docs/alpha.txt"},
+    {"id":"fixture-kit.beta","path":"payload/beta.txt","target":"config/beta.txt","description":"fixture"}
+  ]
+}
+JSON
+
+echo "=== Kit provisioning integration ==="
+npm run build --silent >/dev/null || { fail "build failed"; exit 1; }
+
+if node "$CLI" kit validate "$KIT" >"$TMP_DIR/validate.out" 2>&1; then
+  pass "kit validate accepts declared provisions"
+else
+  fail "kit validate rejected valid provisions"; sed -n '1,80p' "$TMP_DIR/validate.out"
+fi
+
+TARGET="$TMP_DIR/consumer"
+mkdir -p "$TARGET"
+if node "$CLI" kit provision "$KIT" --target "$TARGET" >"$TMP_DIR/provision.out" 2>&1 \
+  && cmp -s "$KIT/payload/alpha.txt" "$TARGET/docs/alpha.txt" \
+  && cmp -s "$KIT/payload/beta.txt" "$TARGET/config/beta.txt" \
+  && node -e 'const m=require(process.argv[1]); if(m.schema_version!=="1.0"||m.kit_id!=="fixture-kit"||m.files.length!==2)process.exit(1)' "$TARGET/.kontourai/flow-agents/provisions/fixture-kit.json"; then
+  pass "provision copies exact content and writes the two-entry manifest"
+else
+  fail "positive provision failed"; sed -n '1,100p' "$TMP_DIR/provision.out"
+fi
+
+printf 'consumer-owned alpha\n' >"$TARGET/docs/alpha.txt"
+printf 'changed source beta\n' >"$KIT/payload/beta.txt"
+if node "$CLI" kit provision "$KIT" --target "$TARGET" >"$TMP_DIR/conflict.out" 2>&1; then
+  fail "create-only conflict unexpectedly succeeded"
+elif [[ "$(cat "$TARGET/docs/alpha.txt")" == "consumer-owned alpha" ]] \
+  && [[ "$(cat "$TARGET/config/beta.txt")" == "beta from kit" ]] \
+  && rg -q 'docs/alpha.txt' "$TMP_DIR/conflict.out" \
+  && rg -q 'config/beta.txt' "$TMP_DIR/conflict.out"; then
+  pass "conflict is nonzero, names all conflicts, and overwrites nothing"
+else
+  fail "conflict handling was not atomic or diagnostic"; sed -n '1,100p' "$TMP_DIR/conflict.out"
+fi
+
+if node "$CLI" kit provision "$KIT" --target "$TARGET" --force >"$TMP_DIR/force.out" 2>&1 \
+  && cmp -s "$KIT/payload/alpha.txt" "$TARGET/docs/alpha.txt" \
+  && cmp -s "$KIT/payload/beta.txt" "$TARGET/config/beta.txt"; then
+  pass "--force overwrites declared destinations"
+else
+  fail "--force did not overwrite"; sed -n '1,100p' "$TMP_DIR/force.out"
+fi
+
+DRY="$TMP_DIR/dry-consumer"
+mkdir -p "$DRY"
+if node "$CLI" kit provision "$KIT" --target "$DRY" --dry-run >"$TMP_DIR/dry.out" 2>&1 \
+  && [[ ! -e "$DRY/docs/alpha.txt" && ! -e "$DRY/.kontourai" ]] \
+  && rg -q 'would provision' "$TMP_DIR/dry.out"; then
+  pass "--dry-run prints the plan and writes nothing"
+else
+  fail "--dry-run wrote state or omitted its plan"; sed -n '1,100p' "$TMP_DIR/dry.out"
+fi
+
+INVALID="$TMP_DIR/invalid-kit"
+cp -R "$KIT" "$INVALID"
+node -e 'const fs=require("fs"),p=process.argv[1],m=JSON.parse(fs.readFileSync(p));m.provisions[0].target="../escape.txt";m.provisions[1].target="/absolute.txt";fs.writeFileSync(p,JSON.stringify(m,null,2))' "$INVALID/kit.json"
+if node "$CLI" kit validate "$INVALID" >"$TMP_DIR/invalid-validate.out" 2>&1; then
+  fail "kit validate accepted traversal and absolute targets"
+elif node "$CLI" kit provision "$INVALID" --target "$DRY" >"$TMP_DIR/invalid-provision.out" 2>&1; then
+  fail "kit provision accepted an invalid kit"
+elif rg -q 'traversal' "$TMP_DIR/invalid-validate.out" && rg -q 'must be relative' "$TMP_DIR/invalid-validate.out"; then
+  pass "validation and provisioning refuse traversal and absolute targets"
+else
+  fail "unsafe target diagnostics were incomplete"; sed -n '1,100p' "$TMP_DIR/invalid-validate.out"
+fi
+
+HOME_FIXTURE="$TMP_DIR/kit-home"
+mkdir -p "$HOME_FIXTURE"
+if node "$CLI" kit install "$KIT" --dest "$HOME_FIXTURE" >"$TMP_DIR/install.out" 2>&1 \
+  && node "$CLI" kit activate --dest "$HOME_FIXTURE" --source-root "$ROOT" >"$TMP_DIR/activate.out" 2>&1 \
+  && node -e 'const r=JSON.parse(require("fs").readFileSync(process.argv[1],"utf8"));if(!r.skipped_assets.some(x=>x.asset_class==="provisions"&&/not activated/.test(x.reason)))process.exit(1)' "$TMP_DIR/activate.out"; then
+  pass "codex-local activation explicitly skips provisions"
+else
+  fail "activation did not report provisions as skipped"; sed -n '1,120p' "$TMP_DIR/activate.out"
+fi
+
+echo ""
+if [[ "$errors" -eq 0 ]]; then
+  echo "Kit provisioning integration passed."
+  exit 0
+fi
+echo "Kit provisioning integration failed with $errors error(s)."
+exit 1