@zhixuan92/multi-model-agent-core 4.0.6 → 4.2.0

package/dist/review/templates/annotator-debug.js

@@ -1,15 +1,19 @@
 export const annotatorDebugTemplate = {
     role: 'debugging hypothesis',
-    onBriefCheck: 'Each finding should be a hypothesis, root-cause claim, or evidence (reproducer, error pattern, code path).',
+    onBriefCheck: 'Each finding should be a hypothesis with a complete trace from symptom to cause, not a point observation at the symptom. AND: the cited cause must come UPSTREAM of the cited symptom in the call/data flow — a finding that names a symptom location as the cause is misdirection (SYMPTOM-NOT-CAUSE failure mode). Findings consistent with the debug failure-mode taxonomy (symptom-not-cause, scapegoat file, incomplete trace, untested hypothesis, parallel causes, pre-existing-vs-new entanglement, wrong fix scope, missing reproduction, confidence overstatement) and backed by file:line citations at each step are valid even when the chain has marked gaps — partial-evidence hypotheses with explicit "the gap is here, verify by X" notes are FULLY VALID, do NOT downgrade them as "speculation".',
     evidenceRule: [
-        '- Debug findings are hypotheses with reasoning chains.',
-        '- Evidence: reproducer + traced code path (file:line) + observed output.',
-        '- Hypothesis-level findings with PARTIAL evidence are valid — that is debugging.',
-        '- Severity reflects evidence strength: confirmed root cause = high; plausible = medium; ruled out = low or drop.',
+        '- Debug findings are hypotheses with REASONING CHAINS, not point observations.',
+        '- Each finding must have at least three citations: SYMPTOM (where the failure surfaces) → INTERMEDIATE STATE (the wrong value, the unexpected branch) → CAUSE (the file:line that, if changed, would prevent the failure).',
+        '- Evidence forms accepted: reproducer commands, captured logs / stack traces, observed values, code-path traces with file:line per step.',
+        '- A finding with NO falsifier (no way to verify the proposed fix worked) is a guess, not a finding.',
+        '- Cross-file tracing (symptom in one file, cause in another reachable via call/data flow) is REQUIRED and FULLY VALID — not "speculation about untouched files".',
+        '- Severity reflects evidence strength AND impact: confirmed root cause that ships a wrong fix = critical; confirmed root cause with full chain = high; plausible candidate with most of the chain = medium; partial trace / multiple plausible explanations = low.',
     ].join('\n'),
     scopeRule: [
-        '- Cross-file tracing is in scope and required to follow the failure path.',
-        '- Out of scope: applied fixes (the worker should propose, not apply); unrelated code-review remarks.',
+        '- Cross-file tracing is in scope and REQUIRED to follow the failure path. Cross-file findings are not out-of-scope just because the named files do not include the cause file.',
+        '- Reproduction discovery is in scope: if no reproduction was provided, the worker should infer one and state it explicitly.',
+        '- Pre-existing-vs-new separation is in scope: multiple bugs in one failure should be separated, with the answered one as the primary finding and others noted separately.',
+        '- Out of scope: applied fixes (the worker should propose, not apply); unrelated code-review remarks; broadening into general code review of files not on the failure path.',
     ].join('\n'),
 };
 //# sourceMappingURL=annotator-debug.js.map

package/dist/review/templates/annotator-debug.js.map

@@ -1 +1 @@
-{"version":3,"file":"annotator-debug.js","sourceRoot":"","sources":["../../../src/review/templates/annotator-debug.ts"],"names":[],"mappings":"AAEA,MAAM,CAAC,MAAM,sBAAsB,GAAsB;IACvD,IAAI,EAAE,sBAAsB;IAC5B,YAAY,EAAE,4GAA4G;IAC1H,YAAY,EAAE;QACZ,wDAAwD;QACxD,0EAA0E;QAC1E,kFAAkF;QAClF,kHAAkH;KACnH,CAAC,IAAI,CAAC,IAAI,CAAC;IACZ,SAAS,EAAE;QACT,2EAA2E;QAC3E,sGAAsG;KACvG,CAAC,IAAI,CAAC,IAAI,CAAC;CACb,CAAC"}
+{"version":3,"file":"annotator-debug.js","sourceRoot":"","sources":["../../../src/review/templates/annotator-debug.ts"],"names":[],"mappings":"AAEA,MAAM,CAAC,MAAM,sBAAsB,GAAsB;IACvD,IAAI,EAAE,sBAAsB;IAC5B,YAAY,EAAE,qxBAAqxB;IACnyB,YAAY,EAAE;QACZ,gFAAgF;QAChF,4NAA4N;QAC5N,0IAA0I;QAC1I,qGAAqG;QACrG,kKAAkK;QAClK,oQAAoQ;KACrQ,CAAC,IAAI,CAAC,IAAI,CAAC;IACZ,SAAS,EAAE;QACT,gLAAgL;QAChL,6HAA6H;QAC7H,2KAA2K;QAC3K,4KAA4K;KAC7K,CAAC,IAAI,CAAC,IAAI,CAAC;CACb,CAAC"}

package/dist/review/templates/annotator-investigate.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"annotator-investigate.d.ts","sourceRoot":"","sources":["../../../src/review/templates/annotator-investigate.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,uBAAuB,CAAC;AAE/D,eAAO,MAAM,4BAA4B,EAAE,iBAY1C,CAAC"}
+{"version":3,"file":"annotator-investigate.d.ts","sourceRoot":"","sources":["../../../src/review/templates/annotator-investigate.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,uBAAuB,CAAC;AAE/D,eAAO,MAAM,4BAA4B,EAAE,iBAe1C,CAAC"}

package/dist/review/templates/annotator-investigate.js

@@ -1,14 +1,17 @@
 export const annotatorInvestigateTemplate = {
     role: 'codebase investigation',
-    onBriefCheck: 'Each finding should be relevant to the question.',
+    onBriefCheck: 'Each finding should be relevant to the question (not an adjacent question — QUESTION SHIFT failure mode). AND: each load-bearing claim must have a file:line citation OR an explicit "searched X in Y, not found" negative. Findings consistent with the investigate failure-mode taxonomy (wrong file, stale quote, hallucinated citation, confidence overstatement, citation gap, question shift, synthesis without grounding, assumed-current-state) should be filed as the appropriate verdict — do NOT downgrade negative findings for lacking a code quote, and do NOT downgrade inference-with-citations as "speculation" if the cited links are real.',
     evidenceRule: [
-        '- Present-thing citations: real `file:line` from files actually read, with a quote or summary.',
+        '- Present-thing citations: real `file:line` from files actually read THIS SESSION, with a quote or summary. Citations from training-data memory are hallucinations — flag any cited line that does not currently contain the cited content.',
         '- Absent-thing citations: explicit "searched <pattern> in <path>, no matches" — negative findings are legitimate answers and must NOT be downgraded for lacking a code quote.',
-        '- Synthesis findings: cite each link in the reasoning chain by file:line.',
+        '- Synthesis findings: cite each link in the reasoning chain by file:line. A synthesis with even one un-cited link is a hand-wave; downgrade confidence or drop the un-cited link.',
+        '- Inference-with-citations ("I infer X from Y:42, Z:18") is FULLY VALID and should not be downgraded as "speculation" when the cited links are real. The distinction: inference-with-citations names what is inferred and what is cited; speculation makes a claim without naming the gap.',
     ].join('\n'),
     scopeRule: [
         '- Wherever the question leads is in scope; the question may not name files.',
+        '- Negative answers ("X is not used", "Y does not exist") ARE in scope when backed by an explicit search; they are not "unable to find" excuses.',
         '- Drift into unrelated code-review remarks is out of scope.',
+        '- Fix proposals / suggestions / improvements are out of scope (this is a read-only Q&A).',
     ].join('\n'),
 };
 //# sourceMappingURL=annotator-investigate.js.map

package/dist/review/templates/annotator-investigate.js.map

@@ -1 +1 @@
-{"version":3,"file":"annotator-investigate.js","sourceRoot":"","sources":["../../../src/review/templates/annotator-investigate.ts"],"names":[],"mappings":"AAEA,MAAM,CAAC,MAAM,4BAA4B,GAAsB;IAC7D,IAAI,EAAE,wBAAwB;IAC9B,YAAY,EAAE,kDAAkD;IAChE,YAAY,EAAE;QACZ,gGAAgG;QAChG,+KAA+K;QAC/K,2EAA2E;KAC5E,CAAC,IAAI,CAAC,IAAI,CAAC;IACZ,SAAS,EAAE;QACT,6EAA6E;QAC7E,6DAA6D;KAC9D,CAAC,IAAI,CAAC,IAAI,CAAC;CACb,CAAC"}
+{"version":3,"file":"annotator-investigate.js","sourceRoot":"","sources":["../../../src/review/templates/annotator-investigate.ts"],"names":[],"mappings":"AAEA,MAAM,CAAC,MAAM,4BAA4B,GAAsB;IAC7D,IAAI,EAAE,wBAAwB;IAC9B,YAAY,EAAE,+nBAA+nB;IAC7oB,YAAY,EAAE;QACZ,6OAA6O;QAC7O,+KAA+K;QAC/K,mLAAmL;QACnL,4RAA4R;KAC7R,CAAC,IAAI,CAAC,IAAI,CAAC;IACZ,SAAS,EAAE;QACT,6EAA6E;QAC7E,iJAAiJ;QACjJ,6DAA6D;QAC7D,0FAA0F;KAC3F,CAAC,IAAI,CAAC,IAAI,CAAC;CACb,CAAC"}

package/dist/review/templates/annotator-review.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"annotator-review.d.ts","sourceRoot":"","sources":["../../../src/review/templates/annotator-review.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,uBAAuB,CAAC;AAE/D,eAAO,MAAM,uBAAuB,EAAE,iBAarC,CAAC"}
+{"version":3,"file":"annotator-review.d.ts","sourceRoot":"","sources":["../../../src/review/templates/annotator-review.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,uBAAuB,CAAC;AAE/D,eAAO,MAAM,uBAAuB,EAAE,iBAoBrC,CAAC"}

package/dist/review/templates/annotator-review.js

@@ -1,15 +1,22 @@
 export const annotatorReviewTemplate = {
     role: 'code review',
-    onBriefCheck: 'For each finding, ask: is this within the requested focus area? A security review should produce security findings, not formatting nits.',
+    onBriefCheck: 'For each finding, ask: is this within the requested focus area (or universally applicable: security, correctness, performance apply to every code change)? AND: is this finding consistent with the code-review failure-mode taxonomy (test gap, cross-file ripple, pre-existing-bug-vs-new-regression, missing edge case, race, resource leak, backward-compat break, security regression, performance regression, implicit-contract assumption)? Findings that match the taxonomy and are backed by call-site references or sibling-test-file references are valid even when the cited code is not in the named files — do NOT downgrade them as "speculation about untouched files".',
     evidenceRule: [
-        '- Code-review findings must cite `file:line` from the named files.',
-        '- Evidence must include a verbatim code quote, not paraphrase.',
-        '- Findings without a quotable code excerpt are speculation; downgrade or drop.',
+        '- Code-review findings come in three valid shapes:',
+        '  1. In-file quote: a verbatim code excerpt from the named files at `file:line`.',
+        '  2. Cross-file ripple: a quote in the named file at `fileA:lineA` PLUS a call-site reference at `fileB:lineB` reachable via grep on the changed symbol. Both lines must be cited.',
+        '  3. Test-gap reference: a quote of the changed line in the named file PLUS the natural-sibling test file path (e.g. `tests/foo.test.ts` for `src/foo.ts`). If no test file exists, that itself is the finding.',
+        '- Implicit-contract findings are valid when they cite the changed line AND name the contract source (docstring, type, README) that does not state the assumption.',
+        '- Findings without one of these forms are speculation; downgrade or drop.',
+        '- Reasoning-based findings backed by call-site references (e.g. "this signature change breaks src/handlers/auth.ts:42") are FULLY VALID and the highest-value kind of code-review finding. Do NOT downgrade them as "speculation about untouched files."',
     ].join('\n'),
     scopeRule: [
-        '- Only the named files are in scope. Behavior of direct callers/callees may be referenced when visible in the named files.',
-        '- Speculation about untouched files is out of scope.',
+        '- Named files are in scope. Behavior of direct callers/callees may be referenced when visible in the named files.',
+        '- Cross-file ripples on changed public symbols ARE in scope when backed by a grep-able symbol reference. Do not penalize as out-of-scope.',
+        '- Test-gap findings citing a sibling test file ARE in scope. Do not penalize as out-of-scope.',
+        '- Speculation about unrelated untouched files is out of scope.',
         '- Doc/spec issues belong in an audit, not a review — flag as off-brief.',
+        '- Pre-existing bugs (the diff did not introduce them) belong in a separate "Pre-existing — out of scope" section, not in the merge-blocking findings.',
     ].join('\n'),
 };
 //# sourceMappingURL=annotator-review.js.map

package/dist/review/templates/annotator-review.js.map

@@ -1 +1 @@
-{"version":3,"file":"annotator-review.js","sourceRoot":"","sources":["../../../src/review/templates/annotator-review.ts"],"names":[],"mappings":"AAEA,MAAM,CAAC,MAAM,uBAAuB,GAAsB;IACxD,IAAI,EAAE,aAAa;IACnB,YAAY,EAAE,0IAA0I;IACxJ,YAAY,EAAE;QACZ,oEAAoE;QACpE,gEAAgE;QAChE,gFAAgF;KACjF,CAAC,IAAI,CAAC,IAAI,CAAC;IACZ,SAAS,EAAE;QACT,4HAA4H;QAC5H,sDAAsD;QACtD,yEAAyE;KAC1E,CAAC,IAAI,CAAC,IAAI,CAAC;CACb,CAAC"}
+{"version":3,"file":"annotator-review.js","sourceRoot":"","sources":["../../../src/review/templates/annotator-review.ts"],"names":[],"mappings":"AAEA,MAAM,CAAC,MAAM,uBAAuB,GAAsB;IACxD,IAAI,EAAE,aAAa;IACnB,YAAY,EAAE,ypBAAypB;IACvqB,YAAY,EAAE;QACZ,oDAAoD;QACpD,kFAAkF;QAClF,oLAAoL;QACpL,iNAAiN;QACjN,mKAAmK;QACnK,2EAA2E;QAC3E,0PAA0P;KAC3P,CAAC,IAAI,CAAC,IAAI,CAAC;IACZ,SAAS,EAAE;QACT,mHAAmH;QACnH,2IAA2I;QAC3I,+FAA+F;QAC/F,gEAAgE;QAChE,yEAAyE;QACzE,uJAAuJ;KACxJ,CAAC,IAAI,CAAC,IAAI,CAAC;CACb,CAAC"}

package/dist/review/templates/annotator-shared.d.ts

@@ -1,5 +1,12 @@
 export interface AnnotatorPromptContext {
-    workerOutput: string;
+    /** N parallel sub-worker narratives, one per criterion the dispatcher
+     *  fanned out. The empty-result narrative ("No findings for this
+     *  criterion.") is filtered out by the engine before this context is
+     *  built — entries here are non-empty narratives that need merging. */
+    workerOutputs: Array<{
+        criterion: string;
+        narrative: string;
+    }>;
     brief: string;
 }
 export interface AnnotatorTemplate {

package/dist/review/templates/annotator-shared.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"annotator-shared.d.ts","sourceRoot":"","sources":["../../../src/review/templates/annotator-shared.ts"],"names":[],"mappings":"AAGA,MAAM,WAAW,sBAAsB;IACrC,YAAY,EAAE,MAAM,CAAC;IACrB,KAAK,EAAE,MAAM,CAAC;CACf;AAED,MAAM,WAAW,iBAAiB;IAChC,IAAI,EAAE,MAAM,CAAC;IACb,YAAY,EAAE,MAAM,CAAC;IACrB;yDACqD;IACrD,YAAY,EAAE,MAAM,CAAC;IACrB;uCACmC;IACnC,SAAS,EAAE,MAAM,CAAC;CACnB;AAED,wBAAgB,oBAAoB,CAAC,QAAQ,EAAE,iBAAiB,GAAG,MAAM,CA+CxE"}
+{"version":3,"file":"annotator-shared.d.ts","sourceRoot":"","sources":["../../../src/review/templates/annotator-shared.ts"],"names":[],"mappings":"AAGA,MAAM,WAAW,sBAAsB;IACrC;;;2EAGuE;IACvE,aAAa,EAAE,KAAK,CAAC;QAAE,SAAS,EAAE,MAAM,CAAC;QAAC,SAAS,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IAC/D,KAAK,EAAE,MAAM,CAAC;CACf;AAED,MAAM,WAAW,iBAAiB;IAChC,IAAI,EAAE,MAAM,CAAC;IACb,YAAY,EAAE,MAAM,CAAC;IACrB;yDACqD;IACrD,YAAY,EAAE,MAAM,CAAC;IACrB;uCACmC;IACnC,SAAS,EAAE,MAAM,CAAC;CACnB;AAED,wBAAgB,oBAAoB,CAAC,QAAQ,EAAE,iBAAiB,GAAG,MAAM,CA+CxE"}

package/dist/review/templates/annotator-shared.js.map

@@ -1 +1 @@
-{"version":3,"file":"annotator-shared.js","sourceRoot":"","sources":["../../../src/review/templates/annotator-shared.ts"],"names":[],"mappings":"AAAA,uEAAuE;AACvE,iDAAiD;AAkBjD,MAAM,UAAU,oBAAoB,CAAC,QAA2B;IAC9D,OAAO,MAAM,CAAC,GAAG,CAAA;;;;;;;CAOlB,GAAG,WAAW,GAAG;;;;;;;;;;;CAWjB,GAAG,KAAK,GAAG;;;GAGT,GAAG,MAAM,GAAG;GACZ,GAAG,YAAY,GAAG;;GAElB,GAAG,SAAS,GAAG;GACf,GAAG,YAAY,GAAG;;GAElB,GAAG,cAAc,GAAG;GACpB,GAAG,uBAAuB,GAAG;;GAE7B,GAAG,YAAY,GAAG;;;;;;;CAOpB,GAAG,QAAQ,CAAC,YAAY,GAAG;;;;CAI3B,GAAG,QAAQ,CAAC,SAAS,GAAG;;wCAEe,GAAG,MAAM,GAAG;mDACD,GAAG,SAAS,GAAG;CACjE,CAAC,IAAI,EAAE,CAAC;AACT,CAAC"}
+{"version":3,"file":"annotator-shared.js","sourceRoot":"","sources":["../../../src/review/templates/annotator-shared.ts"],"names":[],"mappings":"AAAA,uEAAuE;AACvE,iDAAiD;AAsBjD,MAAM,UAAU,oBAAoB,CAAC,QAA2B;IAC9D,OAAO,MAAM,CAAC,GAAG,CAAA;;;;;;;CAOlB,GAAG,WAAW,GAAG;;;;;;;;;;;CAWjB,GAAG,KAAK,GAAG;;;GAGT,GAAG,MAAM,GAAG;GACZ,GAAG,YAAY,GAAG;;GAElB,GAAG,SAAS,GAAG;GACf,GAAG,YAAY,GAAG;;GAElB,GAAG,cAAc,GAAG;GACpB,GAAG,uBAAuB,GAAG;;GAE7B,GAAG,YAAY,GAAG;;;;;;;CAOpB,GAAG,QAAQ,CAAC,YAAY,GAAG;;;;CAI3B,GAAG,QAAQ,CAAC,SAAS,GAAG;;wCAEe,GAAG,MAAM,GAAG;mDACD,GAAG,SAAS,GAAG;CACjE,CAAC,IAAI,EAAE,CAAC;AACT,CAAC"}

package/dist/review/templates/annotator-verify.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"annotator-verify.d.ts","sourceRoot":"","sources":["../../../src/review/templates/annotator-verify.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,uBAAuB,CAAC;AAE/D,eAAO,MAAM,uBAAuB,EAAE,iBAarC,CAAC"}
+{"version":3,"file":"annotator-verify.d.ts","sourceRoot":"","sources":["../../../src/review/templates/annotator-verify.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,uBAAuB,CAAC;AAE/D,eAAO,MAAM,uBAAuB,EAAE,iBAmBrC,CAAC"}

package/dist/review/templates/annotator-verify.js

@@ -1,15 +1,21 @@
 export const annotatorVerifyTemplate = {
     role: 'verification report',
-    onBriefCheck: 'Each finding should map to one checklist item with evidence the criterion was met or unmet.',
+    onBriefCheck: 'Each finding should map 1:1 to a checklist item with evidence in one of three valid shapes (EXECUTION command+output, FILE-LEVEL file:line+quote, or NEGATIVE "cannot verify"). AND: a PASS that rests on a prose claim from the work product alone — without execution output or file:line citation — is a rubber stamp; downgrade to FAIL with NEGATIVE evidence. Findings consistent with the verify failure-mode taxonomy (claim-without-evidence, stale evidence, implicit-criterion gap, partial coverage, conflated criteria, wrong-artifact evidence, assumed-PASS-on-untested) should be filed as the appropriate verdict — do NOT silently exclude implicit sub-criteria from PASS verdicts.',
     evidenceRule: [
         '- Each Finding must map 1:1 to a checklist item.',
-        '- Evidence is execution output (test/build/command output) OR a code reference (`file:line`).',
-        '- A claimed PASS without evidence is speculation; downgrade or drop.',
-        '- Severity binding: PASS = low; FAIL = medium or high based on impact.',
+        '- Evidence is one of three valid shapes:',
+        '  1. EXECUTION: a command + its observed output (test name + pass/fail line, build output, lint result), with the relevant output line quoted.',
+        '  2. FILE-LEVEL: `file:line` citation showing the implementation that satisfies (or fails) the criterion, with the relevant code excerpt quoted.',
+        '  3. NEGATIVE: an explicit "cannot verify from this artifact" plus what would be needed to verify (a test run, a different file, a runtime check).',
+        '- A claimed PASS without one of the three shapes is a rubber stamp; downgrade to FAIL with NEGATIVE evidence.',
+        '- A "the work product says it is done" claim is NOT valid evidence — only execution output or file:line citations count for PASS.',
+        '- Severity binding: PASS = low; FAIL = medium or high based on impact; FAIL on a release-blocking criterion = critical.',
+        '- FAIL with NEGATIVE evidence ("cannot verify") is FULLY VALID and the correct verdict when the artifact is insufficient. Do NOT downgrade NEGATIVE-evidence FAILs to "cannot determine" or assumed-PASS.',
     ].join('\n'),
     scopeRule: [
         '- Only checklist items are in scope. Findings not tied to a checklist item are off-brief.',
-        '- All checklist items should be covered (one Finding per item, in order).',
+        '- All checklist items should be covered (one Finding per item, in order, no skips).',
+        '- IMPLICIT criteria embedded in a checklist item (e.g. "fix the bug" implies "regression test added") ARE in scope. A PASS verdict that silently excludes an implicit sub-criterion is a partial-coverage failure.',
     ].join('\n'),
 };
 //# sourceMappingURL=annotator-verify.js.map

package/dist/review/templates/annotator-verify.js.map

@@ -1 +1 @@
-{"version":3,"file":"annotator-verify.js","sourceRoot":"","sources":["../../../src/review/templates/annotator-verify.ts"],"names":[],"mappings":"AAEA,MAAM,CAAC,MAAM,uBAAuB,GAAsB;IACxD,IAAI,EAAE,qBAAqB;IAC3B,YAAY,EAAE,6FAA6F;IAC3G,YAAY,EAAE;QACZ,kDAAkD;QAClD,+FAA+F;QAC/F,sEAAsE;QACtE,wEAAwE;KACzE,CAAC,IAAI,CAAC,IAAI,CAAC;IACZ,SAAS,EAAE;QACT,2FAA2F;QAC3F,2EAA2E;KAC5E,CAAC,IAAI,CAAC,IAAI,CAAC;CACb,CAAC"}
+{"version":3,"file":"annotator-verify.js","sourceRoot":"","sources":["../../../src/review/templates/annotator-verify.ts"],"names":[],"mappings":"AAEA,MAAM,CAAC,MAAM,uBAAuB,GAAsB;IACxD,IAAI,EAAE,qBAAqB;IAC3B,YAAY,EAAE,wqBAAwqB;IACtrB,YAAY,EAAE;QACZ,kDAAkD;QAClD,0CAA0C;QAC1C,gJAAgJ;QAChJ,kJAAkJ;QAClJ,oJAAoJ;QACpJ,+GAA+G;QAC/G,mIAAmI;QACnI,yHAAyH;QACzH,2MAA2M;KAC5M,CAAC,IAAI,CAAC,IAAI,CAAC;IACZ,SAAS,EAAE;QACT,2FAA2F;QAC3F,qFAAqF;QACrF,oNAAoN;KACrN,CAAC,IAAI,CAAC,IAAI,CAAC;CACb,CAAC"}

package/dist/tools/audit/implementer-criteria.d.ts

@@ -1,17 +1,73 @@
 /**
  * Audit-specific implementer criteria.
  *
- * Audit examines a prose artifact (spec, design doc, API contract,
- * config, plan). The "thing being examined" is text — not source code —
- * so evidence and scope rules differ from review/debug:
+ * AUDIT'S PURPOSE — read this before adding categories.
+ * Most audit targets are spec / plan / design / recommendation files that
+ * will subsequently be EXECUTED BY A LOW-JUDGMENT WORKER (a sub-agent that
+ * follows the spec literally, with little ability to disambiguate or
+ * choose between alternatives). The audit's success criterion is:
+ *
+ *   "After audit + fixes, can a literal-following worker execute this
+ *    artifact without failing, picking wrong, or getting stuck?"
+ *
+ * That criterion is what makes a finding load-bearing. Stylistic nits
+ * don't block execution; ambiguity, contradictions, missing verification,
+ * unspecified branches, out-of-order steps, and overloaded terms do.
+ *
+ * EVIDENCE & SCOPE for prose artifacts.
+ * Audit examines a prose artifact (spec, design doc, plan, recommendation
+ * doc, API contract, config, brief). The "thing being examined" is text —
+ * not source code — so evidence and scope rules differ from review/debug:
  *
  *  - Evidence is a doc quote, OR a precise reference to a section/item
  *    that *should* address the issue but doesn't (absence-finding), OR
- *    a doc-claim + contradicting source (wrong-claim finding).
+ *    a doc-claim + contradicting source (wrong-claim finding), OR
+ *    two sections of the doc that contradict each other (internal-
+ *    coherence finding).
  *  - Scope is the document and what it directly references; cross-section
  *    reasoning IS the value of an audit.
+ *
+ * The failure-mode rubric below tells the worker WHAT KINDS of issues to
+ * look for in a prose artifact. Without it, workers calibrated on code
+ * audits collapse to surface-level proofreading on documents.
+ */
+/**
+ * The orientation block. Goes at the TOP of every audit prompt.
+ *
+ * This is the load-bearing addition. Without an explicit purpose statement,
+ * workers default to "find issues in this doc" — which produces stylistic
+ * proofreading. With this orientation, they look for issues that would
+ * BLOCK EXECUTION by a literal-following worker, which is what the caller
+ * actually needs.
  */
+export declare const AUDIT_PURPOSE_ORIENTATION: string;
 export declare const EVIDENCE_RULE_AUDIT: string;
 export declare const SCOPE_RULE_AUDIT: string;
+/**
+ * The failure-mode rubric for prose-document audits.
+ *
+ * This is the load-bearing addition. Without an explicit taxonomy, workers
+ * calibrated on source-code rubrics (off-by-one, type mismatches, dead code)
+ * have nothing to look for in a spec/plan/recommendation doc and emit only
+ * surface nits. The 11 categories below cover what actually goes wrong in
+ * non-trivial prose artifacts and are independent of the audit-type label.
+ */
+export declare const DOC_AUDIT_FAILURE_MODES: string;
+/**
+ * Counter-balance to the SEVERITY_LADDER's anti-inflation hint.
+ *
+ * The shared severity ladder ends with "Workers commonly inflate — resist
+ * the urge." That bias is correct for code reviews, where over-flagging
+ * stylistic preferences is the common failure. For prose-document audits
+ * the opposite is true: workers UNDER-find because they have nothing to
+ * pattern-match against in their training. This block tells the worker
+ * the doc-audit failure mode is silence, not noise.
+ */
+export declare const THOROUGHNESS_REMINDER_AUDIT: string;
 export declare const ANNOTATOR_AWARENESS_AUDIT: string;
+import { type CriterionEntry } from '../criteria-types.js';
+/** Structured per-criterion array for parallel-criteria fan-out. Derived
+ *  from DOC_AUDIT_FAILURE_MODES so the prose in the cached prefix and the
+ *  per-sub-worker assignment stay in lockstep. */
+export declare const AUDIT_CRITERIA: readonly CriterionEntry[];
 //# sourceMappingURL=implementer-criteria.d.ts.map

package/dist/tools/audit/implementer-criteria.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"implementer-criteria.d.ts","sourceRoot":"","sources":["../../../src/tools/audit/implementer-criteria.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,eAAO,MAAM,mBAAmB,QAMpB,CAAC;AAEb,eAAO,MAAM,gBAAgB,QAMjB,CAAC;AAEb,eAAO,MAAM,yBAAyB,QAO1B,CAAC"}
+{"version":3,"file":"implementer-criteria.d.ts","sourceRoot":"","sources":["../../../src/tools/audit/implementer-criteria.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AAEH;;;;;;;;GAQG;AACH,eAAO,MAAM,yBAAyB,QAmB1B,CAAC;AAEb,eAAO,MAAM,mBAAmB,QAOpB,CAAC;AAEb,eAAO,MAAM,gBAAgB,QAMjB,CAAC;AAEb;;;;;;;;GAQG;AACH,eAAO,MAAM,uBAAuB,QAoBxB,CAAC;AAEb;;;;;;;;;GASG;AACH,eAAO,MAAM,2BAA2B,QAW5B,CAAC;AAEb,eAAO,MAAM,yBAAyB,QAO1B,CAAC;AAEb,OAAO,EAAiB,KAAK,cAAc,EAAE,MAAM,sBAAsB,CAAC;AAE1E;;kDAEkD;AAClD,eAAO,MAAM,cAAc,EAAE,SAAS,cAAc,EAA2C,CAAC"}

package/dist/tools/audit/implementer-criteria.js

@@ -1,36 +1,143 @@
 /**
  * Audit-specific implementer criteria.
  *
- * Audit examines a prose artifact (spec, design doc, API contract,
- * config, plan). The "thing being examined" is text — not source code —
- * so evidence and scope rules differ from review/debug:
+ * AUDIT'S PURPOSE — read this before adding categories.
+ * Most audit targets are spec / plan / design / recommendation files that
+ * will subsequently be EXECUTED BY A LOW-JUDGMENT WORKER (a sub-agent that
+ * follows the spec literally, with little ability to disambiguate or
+ * choose between alternatives). The audit's success criterion is:
+ *
+ *   "After audit + fixes, can a literal-following worker execute this
+ *    artifact without failing, picking wrong, or getting stuck?"
+ *
+ * That criterion is what makes a finding load-bearing. Stylistic nits
+ * don't block execution; ambiguity, contradictions, missing verification,
+ * unspecified branches, out-of-order steps, and overloaded terms do.
+ *
+ * EVIDENCE & SCOPE for prose artifacts.
+ * Audit examines a prose artifact (spec, design doc, plan, recommendation
+ * doc, API contract, config, brief). The "thing being examined" is text —
+ * not source code — so evidence and scope rules differ from review/debug:
  *
  *  - Evidence is a doc quote, OR a precise reference to a section/item
  *    that *should* address the issue but doesn't (absence-finding), OR
- *    a doc-claim + contradicting source (wrong-claim finding).
+ *    a doc-claim + contradicting source (wrong-claim finding), OR
+ *    two sections of the doc that contradict each other (internal-
+ *    coherence finding).
  *  - Scope is the document and what it directly references; cross-section
  *    reasoning IS the value of an audit.
+ *
+ * The failure-mode rubric below tells the worker WHAT KINDS of issues to
+ * look for in a prose artifact. Without it, workers calibrated on code
+ * audits collapse to surface-level proofreading on documents.
  */
+/**
+ * The orientation block. Goes at the TOP of every audit prompt.
+ *
+ * This is the load-bearing addition. Without an explicit purpose statement,
+ * workers default to "find issues in this doc" — which produces stylistic
+ * proofreading. With this orientation, they look for issues that would
+ * BLOCK EXECUTION by a literal-following worker, which is what the caller
+ * actually needs.
+ */
+export const AUDIT_PURPOSE_ORIENTATION = [
+    'Why this audit exists:',
+    'The artifact you are auditing is most likely a spec, plan, design doc, or recommendation doc that will subsequently be EXECUTED BY A LOW-JUDGMENT WORKER — a sub-agent that follows instructions literally, has limited ability to disambiguate, and cannot recover from contradictions.',
+    '',
+    'Your job is to find anywhere a literal-following worker would:',
+    '- get stuck on ambiguity (e.g. "implement the function" with no signature, location, or contract)',
+    '- pick wrong on an unspecified branch (e.g. "if X then Y" with no "otherwise")',
+    '- implement contradictions (section A says use X, section B says use Y, both apparently authoritative)',
+    '- skip a requirement that is implicit or buried (the worker only does what is explicitly stated)',
+    '- be unable to verify completion (no acceptance criteria, no done condition, no test command)',
+    '- misinterpret an overloaded term (the same word means two different things in two sections)',
+    '- execute steps out of order (step 3 needs the output of step 5)',
+    '- act on an unbounded scope ("fix the bug" with no scope boundary)',
+    '- need context that is referenced but not provided (a helper, a flag, a file the spec assumes the worker knows)',
+    '- produce data of an unspecified shape (return value, file format, error envelope)',
+    '',
+    'A finding that points at any of these failure-mode triggers is high-value EVEN IF the prose reads cleanly. Conversely, a stylistic nit that does not block execution is low-priority no matter how clean the wording.',
+    '',
+    'When you have completed this audit and its fixes have been applied, the test is: would a worker that reads only this artifact, follows it literally, and asks no clarifying questions, produce the right outcome? If yes, the audit succeeded.',
+].join('\n');
 export const EVIDENCE_RULE_AUDIT = [
     'Evidence grounding (REQUIRED for every finding):',
     '- For issues IN the doc: quote the exact passage that demonstrates the issue.',
-    '- For ABSENCES (the doc is silent on something it should specify): name the section that should address it. Example: "Section 3.2 enumerates failure modes but does not specify queue-overflow behavior."',
+    '- For ABSENCES (the doc is silent on something it should specify): name the section that should address it. Example: "Section 3.2 enumerates failure modes but does not specify queue-overflow behavior." This is an absence-finding and is fully valid evidence.',
     '- For WRONG-CLAIM findings: quote the doc\'s claim AND the source that contradicts it (the actual code, the referenced spec, etc.).',
-    '- A finding without one of these three forms of evidence is speculation. Note "investigation needed" in your summary instead.',
+    '- For INTERNAL-COHERENCE findings (two parts of the doc conflict, a recommendation contradicts a stated constraint, a fix relies on something the doc forbids): quote both passages OR quote one and name the section ID of the other.',
+    '- A finding without one of these four forms of evidence is speculation. Note "investigation needed" in your summary instead.',
 ].join('\n');
 export const SCOPE_RULE_AUDIT = [
     'Scope:',
     '- The document itself plus any artifact the document directly references (cited code, linked spec, embedded config).',
-    '- Cross-section reasoning within the document IS in scope and often the highest-value kind of finding.',
+    '- Cross-section reasoning within the document IS in scope and is often the highest-value kind of finding.',
     '- Do NOT enumerate the repository or glob across all source files. If verifying a referenced file or symbol, read or grep for that specific name only — the goal is to evaluate the document, not catalog the codebase.',
     '- Out of scope: speculation about content the document does not reference; coding-style nits on inline code examples (those belong in a code review, not an audit).',
 ].join('\n');
+/**
+ * The failure-mode rubric for prose-document audits.
+ *
+ * This is the load-bearing addition. Without an explicit taxonomy, workers
+ * calibrated on source-code rubrics (off-by-one, type mismatches, dead code)
+ * have nothing to look for in a spec/plan/recommendation doc and emit only
+ * surface nits. The 11 categories below cover what actually goes wrong in
+ * non-trivial prose artifacts and are independent of the audit-type label.
+ */
+export const DOC_AUDIT_FAILURE_MODES = [
+    'Look for these kinds of issues — applicable to ALL prose-document audits regardless of auditType. The auditType (default / security / performance) tells you which lens to weight, but every doc audit should sweep the full taxonomy:',
+    '',
+    '1. RECOMMENDATION-COHERENCE — does the proposed fix actually solve the stated problem given the doc\'s own stated constraints? A fix that requires X when the doc forbids X is logically incomplete. **Always check fixes against any explicit principles, constraints, invariants, or "what we won\'t do" sections in the doc itself.** Example: a doc that lists "no persistence" as a principle cannot have a fix that disambiguates "id existed before" from "id never existed" without persistence — that fix is unimplementable.',
+    '2. INTERNAL CONTRADICTION — does section A say something incompatible with section B? Does a methodology disclaimer ("these numbers are approximations") undercut a load-bearing claim built on those same numbers? Does a "do not auto-X" rule sit next to an "auto-X above threshold" recommendation?',
+    '3. CROSS-ITEM DUPLICATION — are two items addressing the same root cause without acknowledging each other? Should they be merged or cross-referenced? Look across the WHOLE doc for items that target the same underlying problem from different angles.',
+    '4. INDEPENDENCE-CLAIMED-WITHOUT-EVIDENCE — is X asserted as independent of Y when the evidence shows correlation, co-occurrence, or shared mechanism?',
+    '5. ARGUMENT SOUNDNESS — does the evidence chain support the conclusion? Does a headline ("95% wasted") rest on data the doc itself flags as unreliable? Does a severity rating match the evidence depth?',
+    '6. COMPLETENESS AGAINST CONSTRAINTS — does any constraint stated elsewhere render a recommendation infeasible? Is a fix step that depends on persistence proposed in a doc that forbids persistence? **If the doc has a principles, invariants, or constraints section, walk every recommendation through every constraint and flag mismatches.**',
+    '7. FIX ACTIONABILITY — is the proposed fix complete enough to implement, or does it stop at "fix it" / vague verbs? Does it leave open which subsystem owns the change? Are step-by-step actions or only goals?',
+    '8. DRIFT / STALENESS — does any claim in one section contradict more recently revised material in the same doc? **Specifically: count items the doc claims to discuss (e.g. "across all three sessions", "the four highest-impact items", "we have N tools") and verify the count against the actual list elsewhere.** If the count is wrong, that\'s drift. Other drift signals: version labels, renamed sections, references to removed items.',
+    '9. SCOPE-CREEP / FRAMING — do recommendations exceed what the evidence supports? Does the framing (table title, bucket label, headline) misrepresent what the row contents actually say?',
+    '10. STRUCTURAL CONSISTENCY — do similar items in a list/table follow the same shape? If one row has a Verification subsection and the others don\'t, that\'s structural inconsistency. If items are numbered "1, 1b, 2, 3" the duplicate "1" is a structural break. If a column is labeled "Fix direction" but one row\'s cell holds verification criteria, that\'s a column-content mismatch.',
+    '11. METADATA COMPLETENESS — for living/revised documents: is there a "last updated" / "as of" / version stamp? When findings claim "still unfixed in version X", is there a date timeline that supports the claim?',
+    '',
+    'Severity calibration for doc audits:',
+    '- critical: a recommendation that, if implemented, would fail or cause harm because the doc is internally incoherent (e.g. a fix that depends on something the doc forbids). Or: a contradiction that would silently lead to wrong implementation if a reader followed both passages.',
+    '- high: a substantive missing recommendation, an incorrect claim of independence between two issues, an evidence chain that does not support a load-bearing conclusion, OR a fix that violates a stated principle/constraint of the doc itself.',
+    '- medium: argument soundness gap, fix actionability gap, drift between sections (item-count mismatch), structural inconsistency between similar items, scope-creep risk that needs a guardrail.',
+    '- low: stylistic, labeling, or formatting issues; missing metadata; minor cross-reference fixes.',
+].join('\n');
+/**
+ * Counter-balance to the SEVERITY_LADDER's anti-inflation hint.
+ *
+ * The shared severity ladder ends with "Workers commonly inflate — resist
+ * the urge." That bias is correct for code reviews, where over-flagging
+ * stylistic preferences is the common failure. For prose-document audits
+ * the opposite is true: workers UNDER-find because they have nothing to
+ * pattern-match against in their training. This block tells the worker
+ * the doc-audit failure mode is silence, not noise.
+ */
+export const THOROUGHNESS_REMINDER_AUDIT = [
+    'Thoroughness expectation for prose-document audits:',
+    '- For non-trivial documents (>500 words), zero or 1-2 findings is unusual and usually indicates the rubric was applied too narrowly. Sweep the full failure-mode taxonomy above before declaring "no findings."',
+    '- The SEVERITY_LADDER warns against inflation. That warning is calibrated for code reviews — for prose audits the typical failure mode is the opposite (under-finding because the worker only looked for surface nits). Apply the failure-mode taxonomy thoroughly first; THEN calibrate severity downward where the impact is small.',
+    '- Do not invent findings to hit a quota. But if you have applied all 11 failure modes and still have only stylistic nits, double-check categories 1, 2, 5, 6, and 8 (recommendation-coherence, internal contradiction, argument soundness, completeness against constraints, drift) — these are the ones workers most often miss on first pass.',
+    '',
+    'Principle-mapping pass (REQUIRED when the doc has a principles / constraints / "what we won\'t do" section):',
+    '- Make ONE explicit pass walking each recommendation against each principle/constraint listed in the doc.',
+    '- For each (recommendation, constraint) pair, ask: does this recommendation, as written, require something the constraint forbids? Or rely on something the constraint says is unavailable?',
+    '- Worked example (illustrative — DO NOT match this verbatim against the doc you are auditing). Suppose a doc states Principle X: "Operations must be deterministic — no random sources." Suppose recommendation R proposes: "On request collision, generate a fresh tiebreaker using the system entropy pool." Chain: the tiebreaker uses entropy; entropy is non-deterministic; Principle X forbids non-determinism; therefore R is unimplementable as written without breaking Principle X. → File this as a HIGH-severity recommendation-coherence finding. The general pattern: a fix that REQUIRES something a constraint FORBIDS, or RELIES ON something a constraint says is UNAVAILABLE, is a load-bearing finding regardless of how clean the fix\'s prose reads.',
+    '- Most workers miss findings of this shape on first pass because the chain spans two non-adjacent sections. The principle-mapping pass forces you to make the chain.',
+].join('\n');
 export const ANNOTATOR_AWARENESS_AUDIT = [
     'After your output, an annotator validates each finding against this audit-specific rubric:',
-    '- Is the finding about the document (contradiction / absence / ambiguity / wrong claim / scope gap)?',
-    '- Is the evidence either a doc quote OR a precise reference for absence-findings OR a doc-claim + contradicting source?',
-    '- Is the severity calibrated to actual downstream-execution impact?',
+    '- Is the finding about the document (contradiction / absence / ambiguity / wrong claim / scope gap / recommendation-coherence / argument-soundness)?',
+    '- Is the evidence one of the four valid shapes: doc quote, absence-reference, claim+contradiction, OR internal-coherence cross-section reference?',
+    '- Is the severity calibrated to actual downstream-execution impact (does following the recommendation as written produce a wrong outcome)?',
     '- Is the finding within the document\'s scope, or is it speculation about untouched material?',
-    'Self-check before emitting. Findings that fail any check are downgraded or dropped.',
+    'Self-check before emitting. Findings that fail any check are downgraded or dropped — but logical-coherence and argument-soundness findings backed by section references are FULLY VALID, do NOT downgrade them as "speculation."',
 ].join('\n');
+import { parseCriteria } from '../criteria-types.js';
+/** Structured per-criterion array for parallel-criteria fan-out. Derived
+ *  from DOC_AUDIT_FAILURE_MODES so the prose in the cached prefix and the
+ *  per-sub-worker assignment stay in lockstep. */
+export const AUDIT_CRITERIA = parseCriteria(DOC_AUDIT_FAILURE_MODES);
 //# sourceMappingURL=implementer-criteria.js.map

package/dist/tools/audit/implementer-criteria.js.map

@@ -1 +1 @@
-{"version":3,"file":"implementer-criteria.js","sourceRoot":"","sources":["../../../src/tools/audit/implementer-criteria.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,MAAM,CAAC,MAAM,mBAAmB,GAAG;IACjC,kDAAkD;IAClD,+EAA+E;IAC/E,2MAA2M;IAC3M,qIAAqI;IACrI,+HAA+H;CAChI,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;AAEb,MAAM,CAAC,MAAM,gBAAgB,GAAG;IAC9B,QAAQ;IACR,sHAAsH;IACtH,wGAAwG;IACxG,yNAAyN;IACzN,qKAAqK;CACtK,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;AAEb,MAAM,CAAC,MAAM,yBAAyB,GAAG;IACvC,4FAA4F;IAC5F,sGAAsG;IACtG,yHAAyH;IACzH,qEAAqE;IACrE,+FAA+F;IAC/F,qFAAqF;CACtF,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC"}
+{"version":3,"file":"implementer-criteria.js","sourceRoot":"","sources":["../../../src/tools/audit/implementer-criteria.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AAEH;;;;;;;;GAQG;AACH,MAAM,CAAC,MAAM,yBAAyB,GAAG;IACvC,wBAAwB;IACxB,0RAA0R;IAC1R,EAAE;IACF,gEAAgE;IAChE,mGAAmG;IACnG,gFAAgF;IAChF,wGAAwG;IACxG,kGAAkG;IAClG,+FAA+F;IAC/F,8FAA8F;IAC9F,kEAAkE;IAClE,oEAAoE;IACpE,iHAAiH;IACjH,oFAAoF;IACpF,EAAE;IACF,uNAAuN;IACvN,EAAE;IACF,gPAAgP;CACjP,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;AAEb,MAAM,CAAC,MAAM,mBAAmB,GAAG;IACjC,kDAAkD;IAClD,+EAA+E;IAC/E,mQAAmQ;IACnQ,qIAAqI;IACrI,wOAAwO;IACxO,8HAA8H;CAC/H,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;AAEb,MAAM,CAAC,MAAM,gBAAgB,GAAG;IAC9B,QAAQ;IACR,sHAAsH;IACtH,2GAA2G;IAC3G,yNAAyN;IACzN,qKAAqK;CACtK,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;AAEb;;;;;;;;GAQG;AACH,MAAM,CAAC,MAAM,uBAAuB,GAAG;IACrC,wOAAwO;IACxO,EAAE;IACF,wgBAAwgB;IACxgB,ySAAyS;IACzS,0PAA0P;IAC1P,uJAAuJ;IACvJ,0MAA0M;IAC1M,mVAAmV;IACnV,iNAAiN;IACjN,kbAAkb;IAClb,0LAA0L;IAC1L,gYAAgY;IAChY,oNAAoN;IACpN,EAAE;IACF,sCAAsC;IACtC,uRAAuR;IACvR,iPAAiP;IACjP,iMAAiM;IACjM,kGAAkG;CACnG,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;AAEb;;;;;;;;;GASG;AACH,MAAM,CAAC,MAAM,2BAA2B,GAAG;IACzC,qDAAqD;IACrD,iNAAiN;IACjN,uUAAuU;IACvU,iVAAiV;IACjV,EAAE;IACF,8GAA8G;IAC9G,2GAA2G;IAC3G,6LAA6L;IAC7L,4uBAA4uB;IAC5uB,sKAAsK;CACvK,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;AAEb,MAAM,CAAC,MAAM,yBAAyB,GAAG;IACvC,4FAA4F;IAC5F,sJAAsJ;IACtJ,mJAAmJ;IACnJ,4IAA4I;IAC5I,+FAA+F;IAC/F,kOAAkO;CACnO,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;AAEb,OAAO,EAAE,aAAa,EAAuB,MAAM,sBAAsB,CAAC;AAE1E;;kDAEkD;AAClD,MAAM,CAAC,MAAM,cAAc,GAA8B,aAAa,CAAC,uBAAuB,CAAC,CAAC"}

package/dist/tools/audit/schema.d.ts

@@ -1,18 +1,11 @@
 import { z } from 'zod';
 export declare const inputSchema: z.ZodObject<{
     document: z.ZodOptional<z.ZodString>;
-    auditType: z.ZodUnion<readonly [z.ZodEnum<{
+    auditType: z.ZodDefault<z.ZodEnum<{
+        default: "default";
         security: "security";
         performance: "performance";
-        style: "style";
-        correctness: "correctness";
-        general: "general";
-    }>, z.ZodArray<z.ZodEnum<{
-        security: "security";
-        performance: "performance";
-        style: "style";
-        correctness: "correctness";
-    }>>]>;
+    }>>;
     filePaths: z.ZodOptional<z.ZodArray<z.ZodString>>;
     contextBlockIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
 }, z.core.$strip>;

package/dist/tools/audit/schema.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../../src/tools/audit/schema.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAMxB,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;iBAUtB,CAAC;AAEH,MAAM,MAAM,KAAK,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,WAAW,CAAC,CAAC;AAEhD,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAA8B,CAAC;AAExD,MAAM,MAAM,MAAM,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,YAAY,CAAC,CAAC"}
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../../src/tools/audit/schema.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAMxB,eAAO,MAAM,WAAW;;;;;;;;;iBAStB,CAAC;AAEH,MAAM,MAAM,KAAK,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,WAAW,CAAC,CAAC;AAEhD,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAA8B,CAAC;AAExD,MAAM,MAAM,MAAM,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,YAAY,CAAC,CAAC"}

package/dist/tools/audit/schema.js

@@ -6,10 +6,9 @@ import { buildOutputEnvelopeSchema } from '../shared-output.js';
 // cross-package coupling.
 export const inputSchema = z.object({
     document: z.string().optional().describe('Inline document content to audit'),
-    auditType: z.union([
-        z.enum(['security', 'performance', 'correctness', 'style', 'general']),
-        z.array(z.enum(['security', 'performance', 'correctness', 'style'])).min(1),
-    ]).describe('Audit focus.'),
+    auditType: z.enum(['default', 'security', 'performance'])
+        .default('default')
+        .describe('Audit focus. `default` is the comprehensive sweep — recommended for specs, plans, designs, recommendation docs, post-mortems. Use `security` or `performance` only when you specifically want to narrow the lens to that single dimension (threat models, scaling designs).'),
     filePaths: z.array(z.string()).optional()
         .describe('Files the sub-agent should focus on. Multiple files are processed in parallel.'),
     contextBlockIds: z.array(z.string()).optional()

package/dist/tools/audit/schema.js.map

@@ -1 +1 @@
-{"version":3,"file":"schema.js","sourceRoot":"","sources":["../../../src/tools/audit/schema.ts"],"names":[],"mappings":"AAAA,0CAA0C;AAC1C,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EAAE,yBAAyB,EAAE,MAAM,qBAAqB,CAAC;AAEhE,uFAAuF;AACvF,2EAA2E;AAC3E,0BAA0B;AAC1B,MAAM,CAAC,MAAM,WAAW,GAAG,CAAC,CAAC,MAAM,CAAC;IAClC,QAAQ,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE,CAAC,QAAQ,CAAC,kCAAkC,CAAC;IAC5E,SAAS,EAAE,CAAC,CAAC,KAAK,CAAC;QACjB,CAAC,CAAC,IAAI,CAAC,CAAC,UAAU,EAAE,aAAa,EAAE,aAAa,EAAE,OAAO,EAAE,SAAS,CAAC,CAAC;QACtE,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,UAAU,EAAE,aAAa,EAAE,aAAa,EAAE,OAAO,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC;KAC5E,CAAC,CAAC,QAAQ,CAAC,cAAc,CAAC;IAC3B,SAAS,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,MAAM,EAAE,CAAC,CAAC,QAAQ,EAAE;SACtC,QAAQ,CAAC,gFAAgF,CAAC;IAC7F,eAAe,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,MAAM,EAAE,CAAC,CAAC,QAAQ,EAAE;SAC5C,QAAQ,CAAC,mHAAmH,CAAC;CACjI,CAAC,CAAC;AAIH,MAAM,CAAC,MAAM,YAAY,GAAG,yBAAyB,EAAE,CAAC"}
+{"version":3,"file":"schema.js","sourceRoot":"","sources":["../../../src/tools/audit/schema.ts"],"names":[],"mappings":"AAAA,0CAA0C;AAC1C,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EAAE,yBAAyB,EAAE,MAAM,qBAAqB,CAAC;AAEhE,uFAAuF;AACvF,2EAA2E;AAC3E,0BAA0B;AAC1B,MAAM,CAAC,MAAM,WAAW,GAAG,CAAC,CAAC,MAAM,CAAC;IAClC,QAAQ,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE,CAAC,QAAQ,CAAC,kCAAkC,CAAC;IAC5E,SAAS,EAAE,CAAC,CAAC,IAAI,CAAC,CAAC,SAAS,EAAE,UAAU,EAAE,aAAa,CAAC,CAAC;SACtD,OAAO,CAAC,SAAS,CAAC;SAClB,QAAQ,CAAC,6QAA6Q,CAAC;IAC1R,SAAS,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,MAAM,EAAE,CAAC,CAAC,QAAQ,EAAE;SACtC,QAAQ,CAAC,gFAAgF,CAAC;IAC7F,eAAe,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,MAAM,EAAE,CAAC,CAAC,QAAQ,EAAE;SAC5C,QAAQ,CAAC,mHAAmH,CAAC;CACjI,CAAC,CAAC;AAIH,MAAM,CAAC,MAAM,YAAY,GAAG,yBAAyB,EAAE,CAAC"}

package/dist/tools/audit/tool-config.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"tool-config.d.ts","sourceRoot":"","sources":["../../../src/tools/audit/tool-config.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,mBAAmB,EAAE,MAAM,6CAA6C,CAAC;AAClF,OAAO,EAAe,KAAK,KAAK,EAAE,MAAM,aAAa,CAAC;AAEtD,OAAO,EAAqB,KAAK,WAAW,EAAE,MAAM,qDAAqD,CAAC;AAE1G,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,sCAAsC,CAAC;AAUvE,wBAAgB,aAAa,CAAC,QAAQ,EAAE,mBAAmB,GAAG,IAAI,CAYjE;AAID,MAAM,WAAW,cAAc;IAC7B,aAAa,EAAE,MAAM,CAAC;IACtB,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,EAAE,CAAC;IACpB,gBAAgB,EAAE,OAAO,CAAC;IAC1B,eAAe,CAAC,EAAE,MAAM,EAAE,CAAC;IAC3B,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AAkCD,wBAAgB,cAAc,CAAC,KAAK,EAAE,KAAK,GAAG,cAAc,EAAE,CA0B7D;AAgED,eAAO,MAAM,UAAU,EAAE,UAAU,CAAC,KAAK,EAAE,cAAc,EAAE,WAAW,CAyBrE,CAAC"}
+{"version":3,"file":"tool-config.d.ts","sourceRoot":"","sources":["../../../src/tools/audit/tool-config.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,mBAAmB,EAAE,MAAM,6CAA6C,CAAC;AAClF,OAAO,EAAe,KAAK,KAAK,EAAE,MAAM,aAAa,CAAC;AAEtD,OAAO,EAAqB,KAAK,WAAW,EAAE,MAAM,qDAAqD,CAAC;AAE1G,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,sCAAsC,CAAC;AAavE,wBAAgB,aAAa,CAAC,QAAQ,EAAE,mBAAmB,GAAG,IAAI,CAYjE;AAID,MAAM,WAAW,cAAc;IAC7B,aAAa,EAAE,MAAM,CAAC;IACtB,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,EAAE,CAAC;IACpB,gBAAgB,EAAE,OAAO,CAAC;IAC1B,eAAe,CAAC,EAAE,MAAM,EAAE,CAAC;IAC3B,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AA6CD,wBAAgB,cAAc,CAAC,KAAK,EAAE,KAAK,GAAG,cAAc,EAAE,CA0B7D;AAgFD,eAAO,MAAM,UAAU,EAAE,UAAU,CAAC,KAAK,EAAE,cAAc,EAAE,WAAW,CAqCrE,CAAC"}