@gobing-ai/spur 0.4.4 → 0.4.6

package/plugins/sp/scripts/persist-out-check.ts

@@ -1,7 +1,6 @@
 #!/usr/bin/env bun
 /**
  * persist-out-check — WT-4 pre-removal assertion for E71 persist-out (task 1067 R1, 1148 R1).
- *
  * Before `git worktree remove`, verify the worktree's OWNED durable evidence would not be abandoned:
  * every `.spur/run/` and `.spur/memory/evidence/` file starting with a forwarded `<wbs>-`/`<runId>-`
  * prefix must exist in the invoking tree with identical bytes. Unowned evidence is counted
@@ -17,6 +16,9 @@ const EVIDENCE_DIR = join('.spur', 'memory', 'evidence');
 const RUN_DIR = join('.spur', 'run');
 const NAMED_CAP = 32;
 const PREFIX_CAP = 64;
+/** The durable-verdict family persist-out itself transfers (1026/1043) — the one artifact class whose
+ *  silent abandonment WT-4 exists to prevent, even when the driver forwarded no matching prefix. */
+const DURABLE_FAMILY_RE = /^\d{4}-(?:verdict|feature-verification)\.json$/;
 
 /** Task files own their `<wbs>-*` evidence: leading digits before `_` in the basename. */
 export function wbsOfTaskFile(path: string): string | null {
@@ -27,6 +29,8 @@ export function wbsOfTaskFile(path: string): string | null {
 export interface ListObligationsResult {
     files: string[];
     unowned: number;
+    /** Every file seen in both planes (recursive) — lets callers audit outside the forwarded prefixes. */
+    planeFiles: string[];
 }
 
 /** Recursively list files under `dir`, relative to `root`. */
@@ -58,8 +62,9 @@ function collectOwned(rels: string[], prefixes: string[], counts: Map<string, nu
 }
 
 /**
- * Evidence the worktree owns: `.spur/memory/evidence/` (recursive) and `.spur/run/` (flat) files
- * whose basename starts with a forwarded `<wbs>-`/`<runId>-` prefix. Evidence matching no prefix is
+ * Evidence the worktree owns: `.spur/memory/evidence/` (recursive) and `.spur/run/` (recursive — the
+ * driver keeps run scratch under `.spur/run/<run-id>/`, which a flat scan silently missed) files whose
+ * basename starts with a forwarded `<wbs>-`/`<runId>-` prefix. Evidence matching no prefix is
  * counted as `unowned` (1148 R1). Null when no prefix is forwarded or a prefix cap is exceeded.
  */
 export function listObligations(wtRoot: string, wbsList: string[], runIds: string[]): ListObligationsResult | null {
@@ -69,19 +74,14 @@ export function listObligations(wtRoot: string, wbsList: string[], runIds: strin
     const evDir = join(wtRoot, EVIDENCE_DIR);
     const runDir = join(wtRoot, RUN_DIR);
     const evFiles = walkFiles(evDir, wtRoot);
-    const runFiles = existsSync(runDir)
-        ? readdirSync(runDir, { withFileTypes: true })
-              .filter((e) => e.isFile())
-              .map((e) => join(RUN_DIR, e.name))
-              .sort()
-        : [];
+    const runFiles = walkFiles(runDir, wtRoot);
 
     const files: string[] = [];
     const counts = new Map<string, number>();
     if (!collectOwned(evFiles, prefixes, counts, files)) return null;
     if (!collectOwned(runFiles, prefixes, counts, files)) return null;
     const unowned = evFiles.length - files.filter((f) => f.startsWith(EVIDENCE_DIR)).length;
-    return { files: [...new Set(files)].sort(), unowned };
+    return { files: [...new Set(files)].sort(), unowned, planeFiles: [...evFiles, ...runFiles] };
 }
 
 /** Classify obligations against the invoking tree: missing, divergent (byte-differs), or ok. */
@@ -164,14 +164,12 @@ export function main(argv: string[], invokeRoot = defaultInvokeRoot(process.cwd(
     }
     if (wbsList.length === 0 && runIds.length === 0) {
         process.stderr.write(
-            `${persistOutCheckUsage()}\npersist-out-check: at least one --task-file or --run-id prefix required\n`,
+            `${persistOutCheckUsage()}\npersist-out-check: at least one --task-file or --run-id required\n`,
         );
         return 2;
     }
     if (!wtRoot || !existsSync(wtRoot) || !statSync(wtRoot).isDirectory()) {
-        process.stderr.write(
-            `${persistOutCheckUsage()}\npersist-out-check: --from must be an existing worktree directory\n`,
-        );
+        process.stderr.write(`${persistOutCheckUsage()}\npersist-out-check: --from must be an existing directory\n`);
         return 2;
     }
     const foreignDivergent = new Set<string>();
@@ -182,27 +180,26 @@ export function main(argv: string[], invokeRoot = defaultInvokeRoot(process.cwd(
         join(wtRoot, '.spur', 'run', 'persist-out.json'),
     ].filter(Boolean);
     for (const cand of candidates) {
-        if (existsSync(cand)) {
-            try {
-                const parsed = JSON.parse(readFileSync(cand, 'utf8'));
-                if (Array.isArray(parsed.evidenceSkipped)) {
-                    for (const item of parsed.evidenceSkipped) {
-                        if (item.reason === 'foreign-divergent' && typeof item.name === 'string') {
-                            foreignDivergent.add(item.name);
-                            foreignDivergent.add(join(EVIDENCE_DIR, item.name));
-                        }
+        if (!existsSync(cand)) continue;
+        try {
+            const parsed = JSON.parse(readFileSync(cand, 'utf8'));
+            if (Array.isArray(parsed.evidenceSkipped)) {
+                for (const item of parsed.evidenceSkipped) {
+                    if (item.reason === 'foreign-divergent' && typeof item.name === 'string') {
+                        foreignDivergent.add(item.name);
+                        foreignDivergent.add(join(EVIDENCE_DIR, item.name));
                     }
                 }
-                if (Array.isArray(parsed.skipped)) {
-                    for (const item of parsed.skipped) {
-                        if (typeof item.id === 'string' && typeof item.reason === 'string') {
-                            skips.push({ id: item.id, reason: item.reason });
-                        }
+            }
+            if (Array.isArray(parsed.skipped)) {
+                for (const item of parsed.skipped) {
+                    if (typeof item.id === 'string' && typeof item.reason === 'string') {
+                        skips.push({ id: item.id, reason: item.reason });
                     }
                 }
-                break;
-            } catch {}
-        }
+            }
+            break;
+        } catch {}
     }
     const obligations = listObligations(wtRoot, wbsList, runIds);
     if (obligations === null) {
@@ -211,11 +208,21 @@ export function main(argv: string[], invokeRoot = defaultInvokeRoot(process.cwd(
         );
         return 1;
     }
-    const { files, unowned } = obligations;
+    const { files, unowned, planeFiles } = obligations;
+    // Session-incident class (runall-1208-1209-bdcd): the driver forwarded only the batch run id, no
+    // prefix matched, and the check passed at 0 obligations while the worktree held its verdicts. Family
+    // files outside the prefixes (not foreign-divergent) block teardown; non-family scratch never does.
+    const unforwarded = planeFiles
+        .filter((rel) => DURABLE_FAMILY_RE.test(basename(rel)))
+        .filter((rel) => !files.includes(rel) && !foreignDivergent.has(rel) && !foreignDivergent.has(basename(rel)));
+    const unforwardedFindings = unforwarded.map(
+        (f) => `UNFORWARDED ${f} — durable verdict/receipt outside the forwarded prefixes`,
+    );
     const { missing, divergent, ok } = compareTrees(wtRoot, invokeRoot, files, foreignDivergent);
     const findings = [
         ...missing.map((f) => `MISSING ${f}`),
         ...divergent.map((f) => `DIVERGENT ${f} — reconcile by hand (persist-out never overwrites)`),
+        ...unforwardedFindings,
     ];
     for (const line of findings.slice(0, NAMED_CAP)) process.stdout.write(`${line}\n`);
     if (findings.length > NAMED_CAP) process.stdout.write(`… +${findings.length - NAMED_CAP} more\n`);
@@ -230,7 +237,9 @@ export function main(argv: string[], invokeRoot = defaultInvokeRoot(process.cwd(
         return 0;
     }
     process.stderr.write(
-        `persist-out-check: BLOCKED ${missing.length} missing, ${divergent.length} divergent — run inline-run-setup --persist-out --from <worktree> before worktree removal\n`,
+        `persist-out-check: BLOCKED ${missing.length} missing, ${divergent.length} divergent` +
+            `${unforwarded.length > 0 ? `, ${unforwarded.length} unforwarded durable verdict/receipt` : ''}` +
+            ' — run inline-run-setup --persist-out --from <worktree> (--task-file <wbs>_<slug>.md) before worktree removal\n',
     );
     return 1;
 }

package/plugins/sp/scripts/residual-scan.mjs

@@ -33,14 +33,6 @@ function hasClaimMarker(evidence) {
 function hasCitationForm(evidence) {
   return CITATION_FORMS.some((re) => re.test(evidence));
 }
-var CONFIDENCE_LEVELS = ["HIGH", "MEDIUM", "LOW"];
-function extractAnswerConfidence(text) {
-  const matches = [...text.matchAll(/^\s*Confidence:\s*(\S+)\s*$/gim)];
-  if (matches.length !== 1)
-    return;
-  const value = (matches[0]?.[1] ?? "").toUpperCase();
-  return CONFIDENCE_LEVELS.includes(value) ? value : undefined;
-}
 var MARKER_PATTERN = /TODO|FIXME|XXX|HACK/;
 var PRIORITY_PATTERN = /^P[1-4]/;
 var RANGE_PRIORITY = /^P[1-4]\s*[\u2013\u2014-]\s*P?[1-4]/;
@@ -212,13 +204,6 @@ function blockingReviewFindings(taskContent, deferrals) {
 }
 function reviewContractViolations(taskContent) {
   const violations = [];
-  const body = reviewBody(taskContent);
-  if (body !== null && extractAnswerConfidence(body.replace(/\*\*/g, "")) === undefined) {
-    violations.push({
-      location: "task-file:Review",
-      text: "Review report carries no single valid `**Confidence:** HIGH | MEDIUM | LOW` line — " + "state the level the report can defend (HIGH: every requirement row MET, every finding " + "dispositioned, evidence cited; MEDIUM/LOW: name the gap)."
-    });
-  }
   for (const row of parseReviewFindings(taskContent)) {
     if (hasClaimMarker(row.text) && !hasCitationForm(row.text)) {
       violations.push({
@@ -229,32 +214,8 @@ function reviewContractViolations(taskContent) {
   }
   return violations;
 }
-function reviewConfidenceViolation(reviewAnswer, ackLowConfidence) {
-  if (ackLowConfidence === "true")
-    return null;
-  const level = extractAnswerConfidence(reviewAnswer.replace(/\*\*/g, ""));
-  if (level === "HIGH" || level === "MEDIUM")
-    return null;
-  return {
-    location: "review-answer:Confidence",
-    text: level === undefined ? "The review answer carries no valid `**Confidence:** HIGH | MEDIUM | LOW` line — a " + "PASS must be graded, or the operator must set ackLowConfidence" : `The review answer graded its PASS ${level} — HIGH/MEDIUM cross unadorned, ` + "LOW/absent needs the operator’s ackLowConfidence"
-  };
-}
-function reviewGradingInput(root, reviewAnswer, ackLowConfidence, fs) {
-  if (reviewAnswer === undefined)
-    return;
-  const path = join(root, reviewAnswer);
-  let isFile = false;
-  try {
-    isFile = fs.statSync(path).isFile();
-  } catch {
-    isFile = false;
-  }
-  return { answer: isFile ? fs.readFileSync(path, "utf8") : "", ackLowConfidence };
-}
-function buildReviewGateArtifact(wbs, taskContent, deferrals, review) {
-  const confidence = review === undefined ? null : reviewConfidenceViolation(review.answer, review.ackLowConfidence);
-  const contractViolations = [...reviewContractViolations(taskContent), ...confidence === null ? [] : [confidence]];
+function buildReviewGateArtifact(wbs, taskContent, deferrals) {
+  const contractViolations = reviewContractViolations(taskContent);
   const items = [
     ...blockingReviewFindings(taskContent, deferrals),
     ...contractViolations.map((v) => ({
@@ -390,7 +351,6 @@ function parseScanArgs(argv, cwd, defaultTmpDir) {
   let spurBin;
   let root = cwd;
   let tmpDir = defaultTmpDir;
-  let reviewAnswer;
   for (let i = 0;i < argv.length; i++) {
     const a = argv[i];
     if (a === undefined)
@@ -401,8 +361,6 @@ function parseScanArgs(argv, cwd, defaultTmpDir) {
       root = argv[++i] ?? root;
     else if (a === "--tmp-dir")
       tmpDir = argv[++i] ?? tmpDir;
-    else if (a === "--review-answer")
-      reviewAnswer = argv[++i];
     else if (a === "--help" || a === "-h")
       return null;
     else if (mode === "")
@@ -410,7 +368,7 @@ function parseScanArgs(argv, cwd, defaultTmpDir) {
     else if (wbs === "")
       wbs = a;
   }
-  return mode === "" || wbs === "" ? null : { mode, wbs, spurBin, root, tmpDir, reviewAnswer };
+  return mode === "" || wbs === "" ? null : { mode, wbs, spurBin, root, tmpDir };
 }
 
 // plugins/sp/lib/spur-bin.ts
@@ -420,7 +378,7 @@ function spurCommand(spurBin) {
 }
 
 // plugins/sp/scripts/residual-scan.ts
-var RESIDUAL_SCAN_USAGE = "usage: residual-scan.ts <scan|fold|settle|report|review-gate> <wbs> [--spur-bin <bin>] [--root <dir>] [--tmp-dir <dir>] [--review-answer <path>]";
+var RESIDUAL_SCAN_USAGE = "usage: residual-scan.ts <scan|fold|settle|report|review-gate> <wbs> [--spur-bin <bin>] [--root <dir>] [--tmp-dir <dir>]";
 function run(cmd, args, cwd) {
   const result = spawnSync(cmd, args, { cwd, encoding: "utf8" });
   if (result.error !== undefined)
@@ -515,8 +473,7 @@ function reviewGateMode(opts, env, io) {
   const runDir = join2(opts.root, ".spur", "run");
   fs.mkdirSync(runDir, { recursive: true });
   const { content } = loadTask(env, opts.spurBin, opts.wbs, opts.root);
-  const grading = reviewGradingInput(opts.root, opts.reviewAnswer, env.ackLowConfidence, fs);
-  const gate = buildReviewGateArtifact(opts.wbs, content, readDeferrals(runDir, opts.wbs), grading);
+  const gate = buildReviewGateArtifact(opts.wbs, content, readDeferrals(runDir, opts.wbs));
   fs.writeFileSync(join2(runDir, `${opts.wbs}-residuals.json`), `${JSON.stringify(gate.artifact, null, 2)}
 `);
   io.out(gate.note);
@@ -671,9 +628,7 @@ export {
   parseScanArgs,
   recordedVerdictPath,
   renderReport,
-  reviewConfidenceViolation,
   reviewContractViolations,
-  reviewGradingInput,
   scanResiduals2 as scanResiduals,
   verdictDisagreementNote
 };

package/plugins/sp/scripts/residual-scan.ts

@@ -10,7 +10,7 @@ import { spurCommand } from '../lib/spur-bin';
 
 export * from '../lib/residual-scan.generated.mjs';
 export const RESIDUAL_SCAN_USAGE =
-    'usage: residual-scan.ts <scan|fold|settle|report|review-gate> <wbs> [--spur-bin <bin>] [--root <dir>] [--tmp-dir <dir>] [--review-answer <path>]';
+    'usage: residual-scan.ts <scan|fold|settle|report|review-gate> <wbs> [--spur-bin <bin>] [--root <dir>] [--tmp-dir <dir>]';
 export type ScanEnv = { spurBin?: string } & Record<string, string | undefined>;
 export type ScanIo = { out: (line: string) => void; err: (line: string) => void };
 export type ScanOptions = { cwd?: string; io?: ScanIo };
@@ -106,16 +106,14 @@ function scanMode(opts: ParsedArgs, env: ScanEnv, io: ScanIo): number {
 /**
  * Task 1122 R2: the review-time gate — the record sweep's review-finding slice
  * (core.buildReviewGateArtifact) at the review PASS edges; writes the same `<wbs>-residuals.json`
- * the test-fix hop reads. Exit 1 on an open P1-P3 finding, or on a review answer graded LOW or left
- * ungraded without `env.ackLowConfidence` (task 1204, graded via `core.reviewGradingInput` — it
- * cannot sit inline in the edge because ADR-115 caps a guard at 5 logical commands).
+ * the test-fix hop reads. Exit 1 on an open P1-P3 finding. The answer-grade rule (1204) was
+ * retired with the asserted confidence machinery (F511); findings stay the gate.
  */
 function reviewGateMode(opts: ParsedArgs, env: ScanEnv, io: ScanIo): number {
     const runDir = join(opts.root, '.spur', 'run');
     fs.mkdirSync(runDir, { recursive: true });
     const { content } = loadTask(env, opts.spurBin, opts.wbs, opts.root);
-    const grading = core.reviewGradingInput(opts.root, opts.reviewAnswer, env.ackLowConfidence, fs);
-    const gate = core.buildReviewGateArtifact(opts.wbs, content, readDeferrals(runDir, opts.wbs), grading);
+    const gate = core.buildReviewGateArtifact(opts.wbs, content, readDeferrals(runDir, opts.wbs));
     fs.writeFileSync(join(runDir, `${opts.wbs}-residuals.json`), `${JSON.stringify(gate.artifact, null, 2)}\n`);
     io.out(gate.note);
     return gate.artifact.counts.blocking > 0 ? 1 : 0;

package/plugins/sp/skills/code-verification/SKILL.md

@@ -341,7 +341,6 @@ Verdict: PASS    (or PARTIAL / FAIL)
 
 ```markdown
 Verdict: PASS
-Confidence: HIGH
 
 ### Per-Requirement Traceability
 | Req | Status | Evidence |
@@ -360,7 +359,7 @@ Confidence: HIGH
 ```
 
 The per-requirement traceability table MUST use `| Req | Status | Evidence |` (exactly this header, no `R#`/`R`/`Requirement` variant — `Status` in column 2 — and no extra columns between Req and Status). The Acceptance Criteria table MUST use `| AC | Status | Evidence Type | Evidence |`.
-The answer MUST carry exactly one `Confidence: HIGH|MEDIUM|LOW` line (task 1068): the verifier's stated confidence in the verdict — HIGH = fresh executable evidence + re-read anchors this run; MEDIUM = partial reliance on prior evidence, external/delegated outcomes, or an unstable tree; LOW = key evidence not re-executed. A missing or out-of-vocabulary line fails lint (`confidence-missing` / `confidence-value`) and blocks derivation; the value lands in the verdict artifact's `confidence` field and the recorded `## Testing` section.
+The answer carries no `Confidence:` line (F511, task 1207): model-asserted confidence is not verification — a verifier that can write a PASS can write `HIGH`. What the old level compressed now lives in the evidence cells themselves: cite fresh executable evidence and name residual gaps explicitly. Legacy answers that still carry a confidence line parse (the value is ignored); no lint code reads it and the artifact and recorded `## Testing` section carry no confidence value.
 The answer MUST cite a source for external API/library claims in Requirement/AC evidence cells: a cell asserting a scoped-package (`@scope/name`), `node_modules/`, semver-version (`x.y.z`), or backticked function-call (`` `name(args)` ``) claim is rejected with `evidence-citation` unless the SAME cell carries a citation — a repo `path:line(-end)` (backticked or bare), the external named-origin form (@origin `path` line N), or a URL. Cross-cell references ("receipt above") do not count; marker-free receipts ("bun test 398 pass / 0 fail") need no citation.
 **MUST NOT:** place a `Severity` column between `Req` and `Status`. The parser tolerates variants
 as defense-in-depth; this contract is canonical.

package/plugins/sp/skills/code-verification/references/verdict-schema.md

@@ -35,42 +35,21 @@ interface VerifyVerdict {
     status: 'pass' | 'fail' | 'warn';
     evidence: string;
   }>;
-  /** Verifier confidence (task 1068 R3). REQUIRED for PASS — the done gate denies
-   *  a confidence-less PASS. Accepted case-insensitively, normalized to uppercase. */
-  confidence?: 'HIGH' | 'MEDIUM' | 'LOW';
+  // F511 (task 1207): no asserted `confidence` field. Legacy artifacts that still carry one
+  // parse with the value ignored — unknown legacy keys are tolerated on read.
 }
 ```
 
-## Confidence level (task 1068 R3)
+## No asserted confidence (F511, task 1207)
 
-A PASS verdict must state the verifier's confidence: `"confidence": "HIGH" | "MEDIUM" | "LOW"`.
-The value is case-insensitive on read (normalized to uppercase), but a present value outside the
-enum invalidates the artifact, and a PASS with the field absent is denied at the `* → done`
-transition with a remediation naming the field (`--force-done` remains the documented escape).
-The verify answer's `Confidence:` lint rule (producer side) already guarantees the field for
-pipeline-produced artifacts; this closes the hand-authored / pre-1068 artifact hole.
-
-### Coherence: the level must be earned (task 1133)
-
-Presence and vocabulary are not enough — the level has to match the rows in the same answer, so the
-lint rejects a level that contradicts its own evidence. Two rejection classes, both addressed to the
-`Confidence:` line and both capped by the shared `ANSWER_LINT_MAX_FINDINGS` budget:
-
-- `confidence-unwarranted` — `HIGH` while any requirement row normalizes to `PARTIAL`/`UNMET`, any
-  acceptance-criteria row does not normalize to `MET`, or any `MET` row's evidence is hedged.
-  A `HIGH` claim says the evidence needs no re-check; a non-MET or hedged row says the opposite.
-- `confidence-understated` — `LOW` while at least one requirement row exists and every requirement
-  and acceptance-criteria row normalizes to `MET`. The evidence already did the work, so `LOW`
-  misreports the state as unproven.
-
-`MEDIUM` carries no coherence rule in either direction: it is the level a verifier uses for a caveat
-with no row to point at, and closing it would force either an overclaimed `HIGH` or an unusable
-`LOW`. The level is normalized to uppercase before the decision, so `high` is judged as `HIGH`.
-
-Set the level from the rows, not the mood: all rows `MET` with fresh evidence is `HIGH`; a
-`PARTIAL`/`UNMET` row or a hedge means `MEDIUM`, not `HIGH`. An unwarranted level does not merely
-warn — the lint rejects the answer and no verdict artifact is written, so the level is worth
-choosing deliberately before the verdict line is finalized.
+Verdict artifacts carry no `confidence` field and verify answers no `Confidence:` line. The
+1068/1133 machinery that required, linted and coherence-checked a model-asserted
+`HIGH | MEDIUM | LOW` was retired: a verifier that can write a PASS can write `HIGH`, so the grade
+verifies nothing. What the level compressed belongs in the evidence cells — cite fresh executable
+evidence and name residual gaps explicitly. The done gate no longer denies a confidence-less PASS:
+it checks the proof digests, which are the part a hand-edited artifact cannot fake. The DERIVED
+confidence family is a different thing and stays: feature-verification receipts (ADR-131, 1196),
+the decision subsystem threshold, history-anatomy reading.
 
 ## Compatibility alias: `scenario` row key
 
@@ -124,9 +103,11 @@ is part of the contract so weak proof is visible to the pipeline and to reviewer
 - `n/a`: explicitly justified non-applicability.
 
 Every CORE behavior-bearing AC requires executable evidence: at least one `test` or `command` row.
-`spur task verdict` treats AC rows as core and behavior-bearing by default; add `[advisory]`,
-`[non-core]`, `[non-behavior]`, or `[docs-only]` in the AC id only when that weaker rule is
-intentional. A MET behavior AC with only `static-ref`, `manual-review`, or `llm-judge` evidence is
+`spur task verdict` treats AC rows as core and behavior-bearing by default. Only the task author
+can exempt an AC: the `[advisory]`, `[non-core]`, `[non-behavior]` or `[docs-only]` tag must be on
+the AC item in the task file's `## Acceptance Criteria`. The verifier must not add these tags to
+answer rows; a tag that appears only in the answer is ignored and flagged by an advisory
+`ac-exemption-not-in-task` check. A MET behavior AC with only `static-ref`, `manual-review`, or `llm-judge` evidence is
 downgraded to `PARTIAL` and emits an `evidence-rule-failed` check. CLI-surface changes should also
 emit a `cli-golden-path-present` check backed by a golden-path `--json` command invocation.
 

package/plugins/sp/skills/spur-cli/references/tasks/verbs.md

@@ -377,8 +377,10 @@ rows), there is no checklist label: cite each row by its exact scenario title
 matches nothing and the verdict is rejected.
 
 **Evidence rule (behavior-bearing AC):** an AC row with `status: MET` on a behavior-bearing id
-(no `[advisory]`/`[non-core]`/`[non-behavior]`/`[docs-only]` marker) MUST carry `test` or
-`command` evidence; any other evidence type downgrades the row to `PARTIAL` and caps the verdict.
+(no `[advisory]`/`[non-core]`/`[non-behavior]`/`[docs-only]` marker **on the AC item in the task
+file**) MUST carry `test` or `command` evidence; any other evidence type downgrades the row to
+`PARTIAL` and caps the verdict. Tags written only in the answer are ignored and reported by the
+advisory `ac-exemption-not-in-task` check.
 
 **Worked example** — a minimal PASS-producing answer file:
 

package/plugins/sp/skills/spur-dev/references/ac-style-guide.md

@@ -219,7 +219,9 @@ clean at authoring time.
 ### Which tags exempt a row from executable evidence
 
 A `MET` row is silently demoted to `PARTIAL` unless it carries `test` or `command` evidence — the
-executable-evidence rule. Five tags opt a row out, because not every scenario is behavioral:
+executable-evidence rule. Five tags opt a row out, because not every scenario is behavioral. The
+tag counts only when the task author writes it on the AC item in the task file; `spur task verdict`
+ignores (and flags) a tag that appears only in the verify answer:
 
 `[doc-only]` · `[docs-only]` · `[non-behavior]` · `[advisory]` · `[non-core]`
 

package/plugins/sp/skills/spur-dev/references/done-housekeeping.md

@@ -139,8 +139,9 @@ silently incomplete (H6 shipped at 23/48 that way, with one verdict carrying an
    parses zero AC rows while lint still reports PASS.
 3. A behavioral AC marked `MET` with a non-executable evidence type (`static-ref`,
    `manual-review`, `llm-judge`) is **downgraded to PARTIAL** by `task verdict`, making the whole
-   verdict PARTIAL. Use `test`/`command` (grep-based verification counts as `command`), or tag the
-   AC id `[non-behavior]`/`[advisory]` when executable evidence genuinely doesn't apply.
+   verdict PARTIAL. Use `test`/`command` (grep-based verification counts as `command`). Only the
+   task author can exempt an AC, by tagging the AC item in the task file `[non-behavior]`/`[advisory]`;
+   the same tag added in the verify answer alone is ignored.
 
 **Invariant:** a force-done task has a non-empty `done_reason` naming the timeout, a verdict
 artifact whose AC rows cover every declared scenario, and a green lint/test run recorded in

package/plugins/sp/skills/spur-dev/references/execution-workflow.md

@@ -171,17 +171,13 @@ Two branches reach the bounded repair hop, not one (session finding after 1088):
   an on-graph, bounded path to remediation instead of dead-ending the run, and the fix re-enters
   quality → review → verify on a freshly captured proof digest.
 
-The completion gate also reads the verifier's confidence (session finding after 1088): the verify
-answer's `Confidence: HIGH|MEDIUM|LOW` line reaches the verdict artifact, and both `verify → record`
-and `record → done` refuse a `LOW` (or absent) level unless the run was launched with
-`--vars '{"ackLowConfidence":"true"}'`. A PASS the verifier would not stand behind is an operator
-risk decision, so it takes an operator acknowledgement — not a silent certification.
-The CLI-layer done gate (`done-transition-guard`, task 1068 R3) separately requires the artifact to *state* a
-level at all: a PASS artifact whose `confidence` is missing is denied there too, and a present but
-out-of-vocabulary value fails the read closed (`invalid confidence field`), so a hand-driven
-`task update <wbs> done` — which is how this pipeline itself reaches `done` (`--no-lifecycle`) —
-cannot certify a verdict that carries no confidence. `LOW` is accepted at that gate; the
-acknowledgement rule above stays the pipeline's.
+The completion gate reads deterministic evidence only (F511, task 1207): both `verify → record` and
+`record → done` check the proof digests in `.spur/run/<wbs>-verdict.json` — verdict PASS, matching
+run/definition digests, review stage completed. No confidence is read, stated or acknowledged; the
+asserted `Confidence:` line and the `ackLowConfidence` operator var were retired because a model
+that can write a PASS can write `HIGH` — the grade verified nothing. What protects a hand-driven
+`task update <wbs> done` is unchanged: the digests must match the run's captured proof, and the
+review stage must actually be completed in the artifact.
 
 Agentic steps use the pure slash inputs declared by each YAML `agent.run` action (ADR-043). The
 workflow engine dispatches them; the interactive driver invokes their backing skills in-session.

package/plugins/sp/skills/spur-dev/references/inline-pipeline-driver.md

@@ -844,9 +844,10 @@ leave no `.spur/run/<wbs>-check-receipt.json`. The deciding artifacts are then
 1. **Drive the pipeline** for anything that must be certified: only a digest-bound full receipt
    satisfies a review/verify/record boundary (`sp-spur-check`), and the `test` hop owns the capture.
 2. **When a host-driven pass is unavoidable, say so in the verdict** — name the status file and gate
-   log as the evidence and grade confidence `MEDIUM`. A `HIGH` claim needs re-runnable evidence from a
-   checked path (the `sp-code-verification` ladder); claiming a receipt that was never written is the
-   failure mode this note exists to prevent (observed across four A91 tasks, 2026-10-12).
+   log as the evidence, and mark the reliance explicitly in the evidence cell (a host-driven gate is
+   not re-runnable proof from a checked path; the `sp-code-verification` ladder is). Claiming a
+   receipt that was never written is the failure mode this note exists to prevent (observed across
+   four A91 tasks, 2026-10-12).
 
 **A mismatch names the drifted paths (R5).** At gate entry the pipeline snapshots the non-corpus tree
 state (`git status --porcelain=v1 -uall` plus `git diff --name-only HEAD`, excluding
@@ -977,14 +978,14 @@ Each item below cost a driver cycle to discover. They are contracts, not tips.
   `.spur/run/<wbs>-diffstat.json` and never on command output. Never the bare unguarded
   source-repo path form — the script-contract check forbids it on a shipped surface because it
   shadows the installed twin in a consumer.
-- **The verify answer grammar is exact.** One `Verdict:` line, one `Confidence:` line, then
+- **The verify answer grammar is exact.** One `Verdict:` line, then
   `### Per-Requirement Traceability` (`| Req | Status | Evidence |`) and
   `### Acceptance Criteria Verification` (`| AC | Status | Evidence Type | Evidence |`). Requirement
   statuses are `MET | PARTIAL | UNMET`; AC statuses add `N/A`; every AC row id must match a declared
   scenario title verbatim, including its `(req: ...)` suffix. A `MET` row whose evidence hedges
   (`likely`, `probably`, `seems`, `appears`, `possibly`, `presumably`) is rejected as
-  `evidence-hedged`, and a level the rows do not earn is rejected as `confidence-unwarranted` or
-  `confidence-understated`. `spur task verdict` lints before writing, so a rejected answer leaves no
+  `evidence-hedged`. No `Confidence:` line exists (F511, task 1207) — legacy answers that carry one
+  parse with the value ignored. `spur task verdict` lints before writing, so a rejected answer leaves no
   artifact and exits non-zero.
 - **Harness tooling refuses direct task-file writes.** Resolve a merge conflict in a task file by
   choosing a git side, then applying the corpus delta through `spur task update` (for example