@zhixuan92/multi-model-agent-core 5.0.3 → 5.2.0

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

@@ -1,55 +0,0 @@
-import { parseCriteria } from '../criteria-types.js';
-export const SPEC_AUDIT_PURPOSE_ORIENTATION = [
-    'Why this audit exists:',
-    'A spec is the prose that says what the system shall do. A finding here is a place where the prose, executed literally, would produce the wrong outcome or paralyze the executor. The completion test: would a downstream worker reading only this spec be able to build the right thing without coming back for clarification?',
-    '',
-    'For your output to clear that bar, every Finding must answer:',
-    '- Issue: the gap or contradiction in one paragraph, quoting the exact prose snippet.',
-    '- Suggestion: the missing sentence the spec needs in order to be executable.',
-    '',
-    'The completion test: would a downstream executor reading ONLY this spec be able to build the right thing without coming back for clarification? If a Finding does not change that answer from "no" to "yes" when applied, it is below the bar — omit it.',
-].join('\n');
-export const EVIDENCE_RULE_SPEC_AUDIT = [
-    'Evidence grounding (REQUIRED for every finding):',
-    '- Quote the exact `shall` / `must` / `should` clause that contains the gap (or the heading the gap sits under).',
-    '- For requirement conflicts: quote BOTH conflicting clauses.',
-    '- For assumption-exposure findings: quote the hidden assumption + name what would break if it does not hold.',
-    '- For acceptance-criteria-coverage findings: name the requirement that lacks a mapping AND state whether the spec calls out a reason it is non-testable.',
-    '- A "the spec seems to imply" claim without a quoted clause is NOT evidence — drop it.',
-    '- Severity binding: critical = literal execution silently ships wrong behavior; high = executor blocked; medium = clarification round forced; low = stylistic / metadata gap.',
-].join('\n');
-export const SCOPE_RULE_SPEC_AUDIT = [
-    'Scope:',
-    '- In scope: requirement testability, scope explicitness AND decomposability, acceptance-criteria coverage, non-functional capture, requirement conflicts, decision trace, hidden assumptions, unresolved authoring placeholders, and presence of architectural decomposition (components, data flow, error handling, testing strategy).',
-    '- Out of scope: implementation details (those belong in a plan, not a spec — flag scope leak into implementation as a SCOPE-EXPLICITNESS-AND-DECOMPOSABILITY finding, not a general comment), stylistic prose preferences, opinions on whether the spec is "good", lens-style audits (security or performance focus belongs in free-text prompt, not in spec subtype).',
-    '- IMPLICIT requirements embedded inside a clause ARE in scope. Example: "shall validate the token" implicitly requires "what counts as valid" — if that is undefined, flag it as REQUIREMENT-TESTABILITY (do not split into two findings).',
-].join('\n');
-export const ANNOTATOR_AWARENESS_SPEC_AUDIT = [
-    '(N/A — your output is consumed verbatim by the user; there is no downstream annotator dedup step on this subtype.)',
-].join('\n');
-const SPEC_AUDIT_FAILURE_MODES = [
-    '1. REQUIREMENT-TESTABILITY — Every "shall" / "must" / "should" requirement has a concrete, observable outcome that a test can assert. Vague verbs ("supports", "handles", "is reliable") without a measurable outcome flag as findings.',
-    '2. SCOPE-EXPLICITNESS-AND-DECOMPOSABILITY — In-scope and out-of-scope items are explicit AND the stated scope is sized for a single implementation plan. Two sub-checks: (a) EXPLICITNESS — implied scope (mentioned-once-then-dropped, or referenced without definition) is a finding; in-scope and out-of-scope lists should appear as a dedicated section, not be inferred from prose. (b) DECOMPOSABILITY — the spec describes ONE buildable feature, not multiple independent subsystems bundled together. Signals that decomposition is needed (severity HIGH): the spec mixes orthogonal subsystems (e.g. chat + file storage + billing); the spec has more than one top-level "Goal" or implies multiple independently releasable units; the architecture section names more than ~5 net-new modules across non-overlapping concerns. Suggested fix on a multi-subsystem spec: split into sub-project specs and brainstorm/plan each independently, citing the brainstorming-skill decomposition guidance.',
-    '3. ACCEPTANCE-CRITERIA-COVERAGE — Every requirement maps to at least one acceptance criterion (or the spec calls out it is non-acceptance-testable and says why). Missing mapping is a finding.',
-    '4. NON-FUNCTIONAL-CAPTURED — Non-functional constraints (latency, security, observability, accessibility, scale) are stated where load-bearing, not assumed silently. Silent assumption is a finding.',
-    '5. REQUIREMENT-CONFLICT — Two requirements that cannot simultaneously hold (e.g. "respond in <50ms" + "validate against the remote registry on every call") are surfaced.',
-    '6. DECISION-TRACE — Decisions that affect downstream implementation (algorithm choice, data shape, integration point) are stated with the reasoning, not just the outcome. Outcome-only is a finding.',
-    '7. ASSUMPTION-EXPOSURE — Hidden assumptions about caller behaviour, environment, or pre-existing state are made explicit so the executor can verify them.',
-    '8. PLACEHOLDER-SCAN — The spec contains no unresolved authoring placeholders that would block planning. Flag occurrences of `TBD`, `TODO`, `[fill in]`, `[to be decided]`, `???`, empty section bodies under a heading (a heading with no content beneath it before the next heading), bulleted lists ending in `…` or "more to come", and tables with empty cells in load-bearing columns. Severity binding: HIGH when the placeholder sits on a load-bearing section (a requirement, an architecture component, an acceptance criterion); MEDIUM elsewhere; LOW on metadata-only sections (author, revision history). Suggested fix: resolve the placeholder before moving to writing-plans, or mark the section explicitly as "out of scope for this iteration" with a forward reference. Evidence is the exact placeholder quote with its section heading.',
-    '9. DESIGN-DECOMPOSITION-PRESENT — A spec must give the planner enough architectural information to write tasks. The brainstorming skill mandates that the spec cover architecture, components, data flow, error handling, and testing. Flag the spec when any load-bearing dimension is missing: (a) no component decomposition (the spec states requirements but never names the modules / units / services that will implement them); (b) no data flow description (request shape, response shape, or how data moves between named components is silent); (c) no error-handling treatment for failure modes that the requirements themselves imply (e.g. a "shall validate the token" requirement with no statement of what happens on invalid token); (d) no testing strategy section (silent on unit / integration / contract / manual layer). Severity HIGH when the missing dimension is load-bearing for downstream planning (the planner would have to invent the architecture); MEDIUM when the dimension is partial (named but underspecified). For each finding, name the missing dimension and the section that should contain it. This perspective is the spec-side complement to plan-audit perspective 10 (SPEC-COVERAGE) — together they enforce that the spec gives the planner enough to build, and the plan in turn covers the spec.',
-].join('\n');
-export const SPEC_AUDIT_CRITERIA = parseCriteria(SPEC_AUDIT_FAILURE_MODES);
-export const SPEC_AUDIT_SEMANTICS = {
-    goalLine: 'Find ALL ways this spec, executed literally by a downstream worker, would produce the wrong outcome or paralyze the executor — viewed through this criterion.',
-    emptyOutcomeLine: 'If THIS criterion does not surface a real gap in the spec, respond with the literal text "No findings for this criterion." — that is a valid outcome on a clean spec.',
-    findingMeaningParagraph: 'A finding is a PLACE WHERE THE SPEC PROSE FAILS THE EXECUTABILITY TEST viewed through this criterion. Title = the failing prose snippet (or its anchor). Severity reflects whether the failure would silently ship wrong behavior, block the executor, force a clarification round, or just leave a stylistic gap.',
-    severityMeanings: {
-        critical: 'Blocks executability of the audited doc',
-        high: 'Significant ambiguity/gap; rework needed',
-        medium: 'Clarity gap; minor assumption needed',
-        low: 'Polish; no behavior change',
-    },
-    mustEmitAtLeastOne: false,
-    legalOutcomes: ['found', 'clean'],
-};
-//# sourceMappingURL=spec-audit-criteria.js.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"spec-audit-criteria.js","sourceRoot":"","sources":["../../../src/tools/audit/spec-audit-criteria.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAC;AAGrD,MAAM,CAAC,MAAM,8BAA8B,GAAG;IAC5C,wBAAwB;IACxB,gUAAgU;IAChU,EAAE;IACF,+DAA+D;IAC/D,sFAAsF;IACtF,8EAA8E;IAC9E,EAAE;IACF,0PAA0P;CAC3P,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;AAEb,MAAM,CAAC,MAAM,wBAAwB,GAAG;IACtC,kDAAkD;IAClD,iHAAiH;IACjH,8DAA8D;IAC9D,8GAA8G;IAC9G,0JAA0J;IAC1J,wFAAwF;IACxF,+KAA+K;CAChL,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;AAEb,MAAM,CAAC,MAAM,qBAAqB,GAAG;IACnC,QAAQ;IACR,yUAAyU;IACzU,wWAAwW;IACxW,4OAA4O;CAC7O,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;AAEb,MAAM,CAAC,MAAM,8BAA8B,GAAG;IAC5C,oHAAoH;CACrH,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;AAEb,MAAM,wBAAwB,GAAG;IAC/B,yOAAyO;IACzO,o9BAAo9B;IACp9B,iMAAiM;IACjM,uMAAuM;IACvM,2KAA2K;IAC3K,uMAAuM;IACvM,2JAA2J;IAC3J,g0BAAg0B;IACh0B,yxCAAyxC;CAC1xC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;AAEb,MAAM,CAAC,MAAM,mBAAmB,GAA8B,aAAa,CAAC,wBAAwB,CAAC,CAAC;AAEtG,MAAM,CAAC,MAAM,oBAAoB,GAAmB;IAClD,QAAQ,EAAE,+JAA+J;IACzK,gBAAgB,EAAE,uKAAuK;IACzL,uBAAuB,EAAE,oTAAoT;IAC7U,gBAAgB,EAAE;QAChB,QAAQ,EAAE,yCAAyC;QACnD,IAAI,EAAE,0CAA0C;QAChD,MAAM,EAAE,sCAAsC;QAC9C,GAAG,EAAE,4BAA4B;KAClC;IACD,kBAAkB,EAAE,KAAK;IACzB,aAAa,EAAE,CAAC,OAAO,EAAE,OAAO,CAAU;CAC3C,CAAC"}

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

@@ -1,4 +0,0 @@
-import type { ReadOnlySubtypeSpec } from '../../lifecycle/read-only-subtype-spec.js';
-export type AuditSubtype = 'default' | 'plan' | 'spec' | 'skill';
-export declare const AUDIT_SUBTYPES: Record<AuditSubtype, ReadOnlySubtypeSpec>;
-//# sourceMappingURL=subtypes.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"subtypes.d.ts","sourceRoot":"","sources":["../../../src/tools/audit/subtypes.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,2CAA2C,CAAC;AAarF,MAAM,MAAM,YAAY,GAAG,SAAS,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO,CAAC;AAkCjE,eAAO,MAAM,cAAc,EAAE,MAAM,CAAC,YAAY,EAAE,mBAAmB,CAiCpE,CAAC"}

package/dist/tools/audit/subtypes.js

@@ -1,69 +0,0 @@
-import { AUDIT_PURPOSE_ORIENTATION, EVIDENCE_RULE_AUDIT, SCOPE_RULE_AUDIT, ANNOTATOR_AWARENESS_AUDIT, AUDIT_CRITERIA, } from './implementer-criteria.js';
-import { PLAN_AUDIT_PURPOSE_ORIENTATION, EVIDENCE_RULE_PLAN_AUDIT, SCOPE_RULE_PLAN_AUDIT, ANNOTATOR_AWARENESS_PLAN_AUDIT, PLAN_AUDIT_CRITERIA, } from './plan-audit-criteria.js';
-import { SPEC_AUDIT_CRITERIA, SPEC_AUDIT_PURPOSE_ORIENTATION, EVIDENCE_RULE_SPEC_AUDIT, SCOPE_RULE_SPEC_AUDIT, ANNOTATOR_AWARENESS_SPEC_AUDIT, SPEC_AUDIT_SEMANTICS } from './spec-audit-criteria.js';
-import { SKILL_AUDIT_CRITERIA, SKILL_AUDIT_PURPOSE_ORIENTATION, EVIDENCE_RULE_SKILL_AUDIT, SCOPE_RULE_SKILL_AUDIT, ANNOTATOR_AWARENESS_SKILL_AUDIT, SKILL_AUDIT_SEMANTICS } from './skill-audit-criteria.js';
-// Copied verbatim from ROUTE_SEMANTICS.audit in
-// packages/core/src/routing/read-route-criteria.ts (the legacy
-// private const there is removed in Task 8 once dispatch reads from here).
-const SEMANTICS_DEFAULT = {
-    goalLine: 'Find ALL issues of THIS specific kind in the artifact above.',
-    emptyOutcomeLine: 'If none exist, respond with the literal text "No findings for this criterion." — that is a fully valid outcome. Do NOT pad with low-signal observations to avoid returning empty.',
-    findingMeaningParagraph: 'A finding is an ISSUE in the artifact (a contradiction, missing recommendation, fix that violates a constraint, drift, structural inconsistency, etc.). Severity reflects how much the issue blocks the artifact\'s downstream use.',
-    severityMeanings: {
-        critical: 'a recommendation or claim that, if implemented as written, would fail or cause harm because the artifact is internally incoherent — e.g. a fix that depends on something the doc forbids.',
-        high: 'a substantive missing recommendation, an evidence chain that does not support a load-bearing conclusion, OR a fix that violates a stated principle/constraint of the doc.',
-        medium: 'argument-soundness gap, fix-actionability gap, drift between sections, structural inconsistency between similar items, scope-creep risk that needs a guardrail.',
-        low: 'stylistic / labeling / formatting issue; missing metadata; minor cross-reference fix.',
-    },
-    mustEmitAtLeastOne: false,
-    legalOutcomes: ['found', 'clean'],
-};
-// Copied verbatim from ROUTE_SEMANTICS.audit_plan.
-const SEMANTICS_PLAN = {
-    goalLine: 'Apply THIS verification perspective to every task in the plan above. Each finding is a plan-vs-codebase coherence issue grounded in real file:line evidence. Verify before flagging — use read_file / grep to inspect the source files the plan names.',
-    emptyOutcomeLine: 'If your perspective finds no plan-vs-codebase drift after grounding in the actual source files, respond with the literal text "No findings for this criterion." — that is the EXPECTED outcome on a clean plan. Do NOT pad with prose-quality observations (those belong in subtype=default, not here).',
-    findingMeaningParagraph: 'A finding is a CONCRETE PLAN-VS-CODEBASE DRIFT viewed through this perspective: the plan names a symbol / path / signature / import / test helper / verify command / cross-task dependency that the actual codebase does not match. Title = "<task ID>: <one-line drift>". Severity reflects whether the task can dispatch.',
-    severityMeanings: {
-        critical: 'plan would BLOCK dispatch — e.g. wrong method name (perspective 2), missing modify-target file (perspective 1), wrong signature (perspective 3), missing module export (perspective 4), out-of-order task dependency (perspective 7), wrong tooling (perspective 8). A literal worker freezes on this.',
-        high: 'load-bearing ambiguity — multiple matching symbols and the plan does not disambiguate, OR test harness missing in claimed shape, OR step depends on later step recoverably. Task may execute but produces an ambiguous artifact.',
-        medium: 'step ordering inferable but undeclared, cross-task dependency unstated, verify command vague but recoverable, missing parent dirs for create-targets. Fixable by reordering or adding a sentence; doesn\'t block dispatch.',
-        low: 'cosmetic — naming preference, missing metadata, minor cross-reference. Does not affect executability.',
-    },
-    mustEmitAtLeastOne: false,
-    legalOutcomes: ['found', 'clean'],
-};
-export const AUDIT_SUBTYPES = {
-    default: {
-        criteria: AUDIT_CRITERIA,
-        orientation: AUDIT_PURPOSE_ORIENTATION,
-        evidenceRule: EVIDENCE_RULE_AUDIT,
-        scopeRule: SCOPE_RULE_AUDIT,
-        annotatorAwareness: ANNOTATOR_AWARENESS_AUDIT,
-        semantics: SEMANTICS_DEFAULT,
-    },
-    plan: {
-        criteria: PLAN_AUDIT_CRITERIA,
-        orientation: PLAN_AUDIT_PURPOSE_ORIENTATION,
-        evidenceRule: EVIDENCE_RULE_PLAN_AUDIT,
-        scopeRule: SCOPE_RULE_PLAN_AUDIT,
-        annotatorAwareness: ANNOTATOR_AWARENESS_PLAN_AUDIT,
-        semantics: SEMANTICS_PLAN,
-    },
-    spec: {
-        criteria: SPEC_AUDIT_CRITERIA,
-        orientation: SPEC_AUDIT_PURPOSE_ORIENTATION,
-        evidenceRule: EVIDENCE_RULE_SPEC_AUDIT,
-        scopeRule: SCOPE_RULE_SPEC_AUDIT,
-        annotatorAwareness: ANNOTATOR_AWARENESS_SPEC_AUDIT,
-        semantics: SPEC_AUDIT_SEMANTICS,
-    },
-    skill: {
-        criteria: SKILL_AUDIT_CRITERIA,
-        orientation: SKILL_AUDIT_PURPOSE_ORIENTATION,
-        evidenceRule: EVIDENCE_RULE_SKILL_AUDIT,
-        scopeRule: SCOPE_RULE_SKILL_AUDIT,
-        annotatorAwareness: ANNOTATOR_AWARENESS_SKILL_AUDIT,
-        semantics: SKILL_AUDIT_SEMANTICS,
-    },
-};
-//# sourceMappingURL=subtypes.js.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"subtypes.js","sourceRoot":"","sources":["../../../src/tools/audit/subtypes.ts"],"names":[],"mappings":"AAIA,OAAO,EACL,yBAAyB,EAAE,mBAAmB,EAAE,gBAAgB,EAChE,yBAAyB,EAAE,cAAc,GAC1C,MAAM,2BAA2B,CAAC;AACnC,OAAO,EACL,8BAA8B,EAAE,wBAAwB,EAAE,qBAAqB,EAC/E,8BAA8B,EAAE,mBAAmB,GACpD,MAAM,0BAA0B,CAAC;AAClC,OAAO,EAAE,mBAAmB,EAAE,8BAA8B,EAAE,wBAAwB,EAAE,qBAAqB,EAAE,8BAA8B,EAAE,oBAAoB,EAAE,MAAM,0BAA0B,CAAC;AACtM,OAAO,EAAE,oBAAoB,EAAE,+BAA+B,EAAE,yBAAyB,EAAE,sBAAsB,EAAE,+BAA+B,EAAE,qBAAqB,EAAE,MAAM,2BAA2B,CAAC;AAI7M,gDAAgD;AAChD,+DAA+D;AAC/D,2EAA2E;AAC3E,MAAM,iBAAiB,GAAmB;IACxC,QAAQ,EAAE,8DAA8D;IACxE,gBAAgB,EAAE,mLAAmL;IACrM,uBAAuB,EAAE,qOAAqO;IAC9P,gBAAgB,EAAE;QAChB,QAAQ,EAAE,2LAA2L;QACrM,IAAI,EAAE,2KAA2K;QACjL,MAAM,EAAE,iKAAiK;QACzK,GAAG,EAAE,uFAAuF;KAC7F;IACD,kBAAkB,EAAE,KAAK;IACzB,aAAa,EAAE,CAAC,OAAO,EAAE,OAAO,CAAU;CAC3C,CAAC;AAEF,mDAAmD;AACnD,MAAM,cAAc,GAAmB;IACrC,QAAQ,EAAE,wPAAwP;IAClQ,gBAAgB,EAAE,ySAAyS;IAC3T,uBAAuB,EAAE,6TAA6T;IACtV,gBAAgB,EAAE;QAChB,QAAQ,EAAE,wSAAwS;QAClT,IAAI,EAAE,kOAAkO;QACxO,MAAM,EAAE,4NAA4N;QACpO,GAAG,EAAE,uGAAuG;KAC7G;IACD,kBAAkB,EAAE,KAAK;IACzB,aAAa,EAAE,CAAC,OAAO,EAAE,OAAO,CAAU;CAC3C,CAAC;AAEF,MAAM,CAAC,MAAM,cAAc,GAA8C;IACvE,OAAO,EAAE;QACP,QAAQ,EAAE,cAAc;QACxB,WAAW,EAAE,yBAAyB;QACtC,YAAY,EAAE,mBAAmB;QACjC,SAAS,EAAE,gBAAgB;QAC3B,kBAAkB,EAAE,yBAAyB;QAC7C,SAAS,EAAE,iBAAiB;KAC7B;IACD,IAAI,EAAE;QACJ,QAAQ,EAAE,mBAAmB;QAC7B,WAAW,EAAE,8BAA8B;QAC3C,YAAY,EAAE,wBAAwB;QACtC,SAAS,EAAE,qBAAqB;QAChC,kBAAkB,EAAE,8BAA8B;QAClD,SAAS,EAAE,cAAc;KAC1B;IACD,IAAI,EAAE;QACJ,QAAQ,EAAE,mBAAmB;QAC7B,WAAW,EAAE,8BAA8B;QAC3C,YAAY,EAAE,wBAAwB;QACtC,SAAS,EAAE,qBAAqB;QAChC,kBAAkB,EAAE,8BAA8B;QAClD,SAAS,EAAE,oBAAoB;KAChC;IACD,KAAK,EAAE;QACL,QAAQ,EAAE,oBAAoB;QAC9B,WAAW,EAAE,+BAA+B;QAC5C,YAAY,EAAE,yBAAyB;QACvC,SAAS,EAAE,sBAAsB;QACjC,kBAAkB,EAAE,+BAA+B;QACnD,SAAS,EAAE,qBAAqB;KACjC;CACF,CAAC"}

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

@@ -1,7 +0,0 @@
-import { ToolSurfaceRegistry } from '../../tool-surface/tool-surface-registry.js';
-import { type Input } from './schema.js';
-import { type AuditBrief } from './brief-slot.js';
-import type { ToolConfig } from '../../lifecycle/tool-config-types.js';
-export declare function registerAudit(registry: ToolSurfaceRegistry): void;
-export declare const toolConfig: ToolConfig<Input, AuditBrief, unknown>;
-//# sourceMappingURL=tool-config.d.ts.map

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

@@ -1 +0,0 @@
-{"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;AACtD,OAAO,EAAkB,KAAK,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAGlE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,sCAAsC,CAAC;AAIvE,wBAAgB,aAAa,CAAC,QAAQ,EAAE,mBAAmB,GAAG,IAAI,CAYjE;AAED,eAAO,MAAM,UAAU,EAAE,UAAU,CAAC,KAAK,EAAE,UAAU,EAAE,OAAO,CAuC7D,CAAC"}

package/dist/tools/audit/tool-config.js

@@ -1,60 +0,0 @@
-import { inputSchema } from './schema.js';
-import { auditBriefSlot } from './brief-slot.js';
-import { noStructuredReportSchema } from '../../reporting/report-parser-slots/no-structured-report.js';
-import { makeFindingsHeadlineTemplate } from '../../reporting/findings-headline.js';
-import { DEFAULT_TASK_TIMEOUT_MS } from '../../config/schema.js';
-export function registerAudit(registry) {
-    registry.register({
-        routeName: 'audit',
-        httpMethod: 'POST',
-        httpPath: '/audit',
-        surface: 'tool',
-        schema: inputSchema,
-        toolCategory: 'read_only',
-        agentTypeDefault: 'complex',
-        agentTypeOverridable: false,
-        responseShapeName: 'BatchResponse',
-    });
-}
-export const toolConfig = {
-    name: 'audit',
-    category: 'read_only',
-    dispatchMode: 'parallel',
-    dispatchModeOverridable: false,
-    agentType: 'complex',
-    briefSlot: auditBriefSlot,
-    buildTaskSpec: (brief, ctx) => {
-        // The read-route dispatcher builds the worker prefix from this pure
-        // target + FINDING_FORMAT_SHARED + the audit RouteSemantics (subtypes.ts);
-        // `prompt` carries the same pure target (TaskSpec.prompt is required and
-        // feeds telemetry, but is not the read-route worker input).
-        const targetParts = [`Audit for ${brief.subtypeText} issues.`];
-        if (brief.document)
-            targetParts.push(`Document:\n\n${brief.document}`);
-        if (brief.filePaths.length > 0) {
-            targetParts.push(`Target files:\n${brief.filePaths.map(p => `- ${p}`).join('\n')}`);
-        }
-        const target = targetParts.join('\n\n');
-        return {
-            prompt: target,
-            readTarget: target,
-            agentType: 'complex',
-            reviewPolicy: 'none',
-            briefQualityPolicy: 'off',
-            done: brief.done,
-            tools: ctx.config.defaults?.tools ?? 'full',
-            timeoutMs: ctx.config.defaults?.timeoutMs ?? DEFAULT_TASK_TIMEOUT_MS,
-            sandboxPolicy: ctx.config.defaults?.sandboxPolicy ?? 'cwd-only',
-            cwd: ctx.projectContext?.cwd ?? ctx.cwd,
-            contextBlockIds: brief.contextBlockIds,
-            filePaths: brief.filePaths.length > 0 ? brief.filePaths : undefined,
-            mainModel: ctx.mainModel,
-            // v4.4.x: plumb subtype to the dispatcher. The parallel-criteria
-            // router reads `task.subtype` and looks it up in AUDIT_SUBTYPES.
-            subtype: brief.subtype,
-        };
-    },
-    reportSchema: noStructuredReportSchema,
-    headlineTemplate: makeFindingsHeadlineTemplate('audit', 'high'),
-};
-//# sourceMappingURL=tool-config.js.map

package/dist/tools/audit/tool-config.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"tool-config.js","sourceRoot":"","sources":["../../../src/tools/audit/tool-config.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,WAAW,EAAc,MAAM,aAAa,CAAC;AACtD,OAAO,EAAE,cAAc,EAAmB,MAAM,iBAAiB,CAAC;AAClE,OAAO,EAAE,wBAAwB,EAAE,MAAM,6DAA6D,CAAC;AACvG,OAAO,EAAE,4BAA4B,EAAE,MAAM,sCAAsC,CAAC;AAGpF,OAAO,EAAE,uBAAuB,EAAE,MAAM,wBAAwB,CAAC;AAEjE,MAAM,UAAU,aAAa,CAAC,QAA6B;IACzD,QAAQ,CAAC,QAAQ,CAAC;QAChB,SAAS,EAAE,OAAO;QAClB,UAAU,EAAE,MAAM;QAClB,QAAQ,EAAE,QAAQ;QAClB,OAAO,EAAE,MAAM;QACf,MAAM,EAAE,WAAW;QACnB,YAAY,EAAE,WAAW;QACzB,gBAAgB,EAAE,SAAS;QAC3B,oBAAoB,EAAE,KAAK;QAC3B,iBAAiB,EAAE,eAAe;KACnC,CAAC,CAAC;AACL,CAAC;AAED,MAAM,CAAC,MAAM,UAAU,GAA2C;IAChE,IAAI,EAAE,OAAO;IACb,QAAQ,EAAE,WAAW;IACrB,YAAY,EAAE,UAAU;IACxB,uBAAuB,EAAE,KAAK;IAC9B,SAAS,EAAE,SAAS;IACpB,SAAS,EAAE,cAAc;IACzB,aAAa,EAAE,CAAC,KAAK,EAAE,GAAG,EAAE,EAAE;QAC5B,oEAAoE;QACpE,2EAA2E;QAC3E,yEAAyE;QACzE,4DAA4D;QAC5D,MAAM,WAAW,GAAa,CAAC,aAAa,KAAK,CAAC,WAAW,UAAU,CAAC,CAAC;QACzE,IAAI,KAAK,CAAC,QAAQ;YAAE,WAAW,CAAC,IAAI,CAAC,gBAAgB,KAAK,CAAC,QAAQ,EAAE,CAAC,CAAC;QACvE,IAAI,KAAK,CAAC,SAAS,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;YAC/B,WAAW,CAAC,IAAI,CAAC,kBAAkB,KAAK,CAAC,SAAS,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;QACtF,CAAC;QACD,MAAM,MAAM,GAAG,WAAW,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;QACxC,OAAO;YACL,MAAM,EAAE,MAAM;YACd,UAAU,EAAE,MAAM;YAClB,SAAS,EAAE,SAAS;YACpB,YAAY,EAAE,MAAM;YACpB,kBAAkB,EAAE,KAAK;YACzB,IAAI,EAAE,KAAK,CAAC,IAAI;YAChB,KAAK,EAAE,GAAG,CAAC,MAAM,CAAC,QAAQ,EAAE,KAAK,IAAI,MAAM;YAC3C,SAAS,EAAE,GAAG,CAAC,MAAM,CAAC,QAAQ,EAAE,SAAS,IAAI,uBAAuB;YACpE,aAAa,EAAE,GAAG,CAAC,MAAM,CAAC,QAAQ,EAAE,aAAa,IAAI,UAAU;YAC/D,GAAG,EAAE,GAAG,CAAC,cAAc,EAAE,GAAG,IAAI,GAAG,CAAC,GAAG;YACvC,eAAe,EAAE,KAAK,CAAC,eAAe;YACtC,SAAS,EAAE,KAAK,CAAC,SAAS,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,SAAS,CAAC,CAAC,CAAC,SAAS;YACnE,SAAS,EAAE,GAAG,CAAC,SAAS;YACxB,iEAAiE;YACjE,iEAAiE;YACjE,OAAO,EAAE,KAAK,CAAC,OAAO;SACX,CAAC;IAChB,CAAC;IACD,YAAY,EAAE,wBAAwB;IACtC,gBAAgB,EAAE,4BAA4B,CAAC,OAAO,EAAE,MAAM,CAAC;CAChE,CAAC"}

package/dist/tools/criteria-types.d.ts

@@ -1,27 +0,0 @@
-/**
- * Structured criterion shape used by all five read-only routes for
- * parallel-criteria fan-out. Each entry in the route's *_CRITERIA constant
- * becomes one sub-worker; the per-criterion description is the variable
- * suffix in the sub-worker's user message (the cached prefix carries
- * everything else).
- */
-export interface CriterionEntry {
-    /** "1", "2", ..., matches the position in the existing *_FAILURE_MODES list. */
-    id: string;
-    /** Short label, e.g. "RECOMMENDATION-COHERENCE". */
-    title: string;
-    /** Verbatim prose from the existing failure-mode description, sans the
-     *  leading "N. TITLE — " prefix. */
-    description: string;
-}
-/**
- * Parses a `*_FAILURE_MODES` joined string back into structured criterion
- * entries. Each route's implementer-criteria.ts already authors its
- * taxonomy as a numbered list (`'1. TITLE — description...'`); this lets
- * the parallel-criteria dispatcher iterate without duplicating the prose.
- *
- * Expected line shape per criterion: `^N. TITLE — description$`
- * (em-dash with surrounding spaces; title may contain hyphens or slashes).
- */
-export declare function parseCriteria(failureModesText: string): CriterionEntry[];
-//# sourceMappingURL=criteria-types.d.ts.map

package/dist/tools/criteria-types.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"criteria-types.d.ts","sourceRoot":"","sources":["../../src/tools/criteria-types.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,MAAM,WAAW,cAAc;IAC7B,gFAAgF;IAChF,EAAE,EAAE,MAAM,CAAC;IACX,oDAAoD;IACpD,KAAK,EAAE,MAAM,CAAC;IACd;wCACoC;IACpC,WAAW,EAAE,MAAM,CAAC;CACrB;AAED;;;;;;;;GAQG;AACH,wBAAgB,aAAa,CAAC,gBAAgB,EAAE,MAAM,GAAG,cAAc,EAAE,CAaxE"}

package/dist/tools/criteria-types.js

@@ -1,25 +0,0 @@
-/**
- * Parses a `*_FAILURE_MODES` joined string back into structured criterion
- * entries. Each route's implementer-criteria.ts already authors its
- * taxonomy as a numbered list (`'1. TITLE — description...'`); this lets
- * the parallel-criteria dispatcher iterate without duplicating the prose.
- *
- * Expected line shape per criterion: `^N. TITLE — description$`
- * (em-dash with surrounding spaces; title may contain hyphens or slashes).
- */
-export function parseCriteria(failureModesText) {
-    const out = [];
-    const lines = failureModesText.split('\n');
-    // Regex: leading digits + dot + space, capture title up to ' — ' separator,
-    // then capture rest of line as description.
-    const re = /^(\d+)\.\s+([^—]+?)\s+—\s+(.+)$/;
-    for (const line of lines) {
-        const m = re.exec(line);
-        if (!m)
-            continue;
-        const [, id, title, description] = m;
-        out.push({ id, title: title.trim(), description: description.trim() });
-    }
-    return out;
-}
-//# sourceMappingURL=criteria-types.js.map

package/dist/tools/criteria-types.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"criteria-types.js","sourceRoot":"","sources":["../../src/tools/criteria-types.ts"],"names":[],"mappings":"AAiBA;;;;;;;;GAQG;AACH,MAAM,UAAU,aAAa,CAAC,gBAAwB;IACpD,MAAM,GAAG,GAAqB,EAAE,CAAC;IACjC,MAAM,KAAK,GAAG,gBAAgB,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;IAC3C,4EAA4E;IAC5E,4CAA4C;IAC5C,MAAM,EAAE,GAAG,iCAAiC,CAAC;IAC7C,KAAK,MAAM,IAAI,IAAI,KAAK,EAAE,CAAC;QACzB,MAAM,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QACxB,IAAI,CAAC,CAAC;YAAE,SAAS;QACjB,MAAM,CAAC,EAAE,EAAE,EAAE,KAAK,EAAE,WAAW,CAAC,GAAG,CAAC,CAAC;QACrC,GAAG,CAAC,IAAI,CAAC,EAAE,EAAE,EAAE,KAAK,EAAE,KAAK,CAAC,IAAI,EAAE,EAAE,WAAW,EAAE,WAAW,CAAC,IAAI,EAAE,EAAE,CAAC,CAAC;IACzE,CAAC;IACD,OAAO,GAAG,CAAC;AACb,CAAC"}

package/dist/tools/debug/brief-slot.d.ts

@@ -1,15 +0,0 @@
-export interface ToolDebugBrief {
-    problem: string;
-    context?: string;
-    hypothesis?: string;
-    filePaths?: string[];
-    contextBlockIds?: string[];
-}
-export declare function debugBriefSlot(input: {
-    problem: string;
-    context?: string;
-    hypothesis?: string;
-    filePaths?: string[];
-    contextBlockIds?: string[];
-}): ToolDebugBrief[];
-//# sourceMappingURL=brief-slot.d.ts.map

package/dist/tools/debug/brief-slot.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"brief-slot.d.ts","sourceRoot":"","sources":["../../../src/tools/debug/brief-slot.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,cAAc;IAC7B,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,SAAS,CAAC,EAAE,MAAM,EAAE,CAAC;IACrB,eAAe,CAAC,EAAE,MAAM,EAAE,CAAC;CAC5B;AAED,wBAAgB,cAAc,CAAC,KAAK,EAAE;IACpC,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,SAAS,CAAC,EAAE,MAAM,EAAE,CAAC;IACrB,eAAe,CAAC,EAAE,MAAM,EAAE,CAAC;CAC5B,GAAG,cAAc,EAAE,CAQnB"}

package/dist/tools/debug/brief-slot.js

@@ -1,10 +0,0 @@
-export function debugBriefSlot(input) {
-    return [{
-            problem: input.problem,
-            context: input.context,
-            hypothesis: input.hypothesis,
-            filePaths: input.filePaths,
-            contextBlockIds: input.contextBlockIds,
-        }];
-}
-//# sourceMappingURL=brief-slot.js.map

package/dist/tools/debug/brief-slot.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"brief-slot.js","sourceRoot":"","sources":["../../../src/tools/debug/brief-slot.ts"],"names":[],"mappings":"AAQA,MAAM,UAAU,cAAc,CAAC,KAM9B;IACC,OAAO,CAAC;YACN,OAAO,EAAE,KAAK,CAAC,OAAO;YACtB,OAAO,EAAE,KAAK,CAAC,OAAO;YACtB,UAAU,EAAE,KAAK,CAAC,UAAU;YAC5B,SAAS,EAAE,KAAK,CAAC,SAAS;YAC1B,eAAe,EAAE,KAAK,CAAC,eAAe;SACvC,CAAC,CAAC;AACL,CAAC"}

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

@@ -1,45 +0,0 @@
-/**
- * Debug-specific implementer criteria.
- *
- * DEBUG'S PURPOSE — read this before adding categories.
- * mma-debug is hypothesis-driven root-cause investigation. The output is
- * a fix specification, not a hint. The success criterion is:
- *
- *   "Could a maintainer who reads ONLY your debug report apply the fix,
- *    reproduce the original failure, verify the fix, and re-merge —
- *    without redoing the investigation?"
- *
- * That criterion is what makes a finding load-bearing. A correctly-
- * identified line that is just a SYMPTOM (the real cause is upstream)
- * is the debug-equivalent of an unimplementable fix — it sends the
- * maintainer down the wrong path. A hypothesis with no falsifier is a
- * guess dressed up as a finding.
- *
- * Debug is hypothesis-driven; cross-file tracing is required, not
- * forbidden. Findings are evidence chains, not point observations.
- */
-/**
- * The orientation block. Goes at the TOP of every debug prompt.
- *
- * Without an explicit purpose statement, workers default to "find a
- * suspicious line" — which often points at the symptom, not the cause.
- * With this orientation, they trace from the failure point upstream
- * until they hit something that, if changed, would prevent the failure.
- */
-export declare const DEBUG_PURPOSE_ORIENTATION: string;
-export declare const EVIDENCE_RULE_DEBUG: string;
-export declare const SCOPE_RULE_DEBUG: string;
-/**
- * The failure-mode taxonomy for debug investigations.
- *
- * Without this block, workers default to "find a suspicious line" —
- * which catches surface symptoms but misses the chain upstream that
- * actually caused the failure. The 9 categories below are the patterns
- * a careful debugger would consciously check for.
- */
-export declare const DEBUG_FAILURE_MODES: string;
-export declare const ANNOTATOR_AWARENESS_DEBUG: string;
-import { type CriterionEntry } from '../criteria-types.js';
-/** Structured per-criterion array for parallel-criteria fan-out. */
-export declare const DEBUG_CRITERIA: readonly CriterionEntry[];
-//# sourceMappingURL=implementer-criteria.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"implementer-criteria.d.ts","sourceRoot":"","sources":["../../../src/tools/debug/implementer-criteria.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAEH;;;;;;;GAOG;AACH,eAAO,MAAM,yBAAyB,QAe1B,CAAC;AAEb,eAAO,MAAM,mBAAmB,QAQpB,CAAC;AAEb,eAAO,MAAM,gBAAgB,QAMjB,CAAC;AAEb;;;;;;;GAOG;AACH,eAAO,MAAM,mBAAmB,QAcpB,CAAC;AAEb,eAAO,MAAM,yBAAyB,QAS1B,CAAC;AAEb,OAAO,EAAiB,KAAK,cAAc,EAAE,MAAM,sBAAsB,CAAC;AAE1E,oEAAoE;AACpE,eAAO,MAAM,cAAc,EAAE,SAAS,cAAc,EAAuC,CAAC"}

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

@@ -1,97 +0,0 @@
-/**
- * Debug-specific implementer criteria.
- *
- * DEBUG'S PURPOSE — read this before adding categories.
- * mma-debug is hypothesis-driven root-cause investigation. The output is
- * a fix specification, not a hint. The success criterion is:
- *
- *   "Could a maintainer who reads ONLY your debug report apply the fix,
- *    reproduce the original failure, verify the fix, and re-merge —
- *    without redoing the investigation?"
- *
- * That criterion is what makes a finding load-bearing. A correctly-
- * identified line that is just a SYMPTOM (the real cause is upstream)
- * is the debug-equivalent of an unimplementable fix — it sends the
- * maintainer down the wrong path. A hypothesis with no falsifier is a
- * guess dressed up as a finding.
- *
- * Debug is hypothesis-driven; cross-file tracing is required, not
- * forbidden. Findings are evidence chains, not point observations.
- */
-/**
- * The orientation block. Goes at the TOP of every debug prompt.
- *
- * Without an explicit purpose statement, workers default to "find a
- * suspicious line" — which often points at the symptom, not the cause.
- * With this orientation, they trace from the failure point upstream
- * until they hit something that, if changed, would prevent the failure.
- */
-export const DEBUG_PURPOSE_ORIENTATION = [
-    'Why this debug investigation exists:',
-    'mma-debug produces a fix specification a maintainer can apply WITHOUT redoing the investigation. Your output replaces the maintainer\'s own root-cause work — not augments it.',
-    '',
-    'For your output to clear that bar, every finding must answer:',
-    '- Reproduction: how does the maintainer trigger the failure (command, input, state)?',
-    '- Symptom: where does the failure surface (file:line of the error, the failing assertion, the wrong output)?',
-    '- Cause: where is the actual defect (file:line that, if changed, would prevent the failure)?',
-    '- Trace: the evidence chain that links symptom to cause — each step a file:line citation or an observed value.',
-    '- Fix: the specific change to make at the cause (PROPOSE only — read-only contract; the caller applies).',
-    '- Falsifier: how the maintainer can verify the fix works (the assertion that should now pass, the wrong output that should now be right).',
-    '',
-    'A finding missing the trace from symptom to cause is a guess. A finding that names a symptom location as the cause is misdirection. Both are worse than no finding because they send the maintainer down the wrong path.',
-    '',
-    'The completion test: would a maintainer who reads only your report and the source code reproduce the failure, find the cited cause, apply the proposed fix, and confirm the falsifier — all without doing the investigation a second time?',
-].join('\n');
-export const EVIDENCE_RULE_DEBUG = [
-    'Evidence grounding (REQUIRED for every finding):',
-    '- Each finding is a hypothesis with a supporting evidence chain. Cite `file:line` at every step of the chain.',
-    '- The chain has at least three points: SYMPTOM (where the failure surfaces) → INTERMEDIATE STATE (the wrong value, the unexpected branch, the missing call) → CAUSE (the file:line that, if changed, would prevent the failure).',
-    '- Evidence forms accepted: reproducer commands, captured logs / stack traces, observed values, and code-path traces with file:line per step.',
-    '- Hypothesis-level findings with PARTIAL evidence are valid — that is how root-causing works. Show the reasoning chain. State which step is firm and which is conjecture.',
-    '- A hypothesis with NO falsifier (no way to check if the proposed cause is right) is a guess, not a finding. Always state how the maintainer can verify the fix.',
-    '- Severity reflects evidence strength AND impact: confirmed root cause that ships a wrong fix = `critical`; confirmed root cause = `high`; plausible candidate with most of the chain = `medium`; partial trace / multiple plausible explanations = `low` (or note in summary).',
-].join('\n');
-export const SCOPE_RULE_DEBUG = [
-    'Scope:',
-    '- Follow the failure path wherever it leads. Cross-file tracing is required.',
-    '- Reproduction discovery IS in scope: if the caller did not provide reproduction steps, infer them from test files, error messages, or recent commits and state your inferred reproduction explicitly.',
-    '- Pre-existing-vs-new separation: if multiple bugs are entangled in the same failure, separate them. Identify which is the one the caller asked about; note the others under "Other defects observed (out of scope for this investigation)".',
-    '- Out of scope: applying fixes (debug is read-only — propose, do not apply); rewriting code; auditing unrelated subsystems; broadening into general code review.',
-].join('\n');
-/**
- * The failure-mode taxonomy for debug investigations.
- *
- * Without this block, workers default to "find a suspicious line" —
- * which catches surface symptoms but misses the chain upstream that
- * actually caused the failure. The 9 categories below are the patterns
- * a careful debugger would consciously check for.
- */
-export const DEBUG_FAILURE_MODES = [
-    'Five parallel angles for finding the root cause. EACH angle is a distinct perspective; from your assigned angle, propose one or more candidate root-cause hypotheses (or contributing factors). Severity = strength of the evidence chain from THIS angle.',
-    '',
-    '1. SYMPTOM-LOCATION ANGLE — start from where the failure surfaces (the throwing line, the failing assertion, the visible bad output). Trace UPSTREAM through the call/data path until you find a state that, if changed, prevents the failure. Each step must be a file:line citation or an observed value. Your candidate cause is the upstream state-change site you identify.',
-    '2. RECENT-CHANGE ANGLE — read git log / recent diffs on the involved files. Which lines changed in the last N commits? Which changes plausibly altered the behavior under question? Your candidate cause is a specific recent change that could have introduced the bug; cite the commit + the line.',
-    '3. TEST-FAILURE ANGLE — read the failing test (or the test that would fail). What assertion fires, with what expected vs actual? Read the implementation it exercises and identify where the contract is broken. Your candidate cause is "the implementation does X but the test contract requires Y at <file:line>".',
-    '4. REPRODUCTION ANGLE — what minimum input / state / config triggers the failure? If no reproduction exists in the bug report, infer one from the code: which entry point + arguments would land in the failing path? Your candidate cause is "the failure requires <state>; the bug is the code path that handles that state at <file:line>".',
-    '5. CONCURRENCY / CONFIGURATION ANGLE — does the failure depend on timing, ordering, async-ness, env vars, feature flags, or runtime config? Look for shared state, locks, awaits between check-and-act, conditional code gated on env. Your candidate cause is the race / config dependency, or "no concurrency/config dependency suspected" with reasoning.',
-    '',
-    'Severity calibration for each candidate root cause:',
-    '- critical: confirmed root cause + reproducible evidence + concrete fix is implied. The maintainer can act now without re-investigation.',
-    '- high: strong root-cause hypothesis with traced upstream evidence (file:line citations along the call/data path), single chain, no inferred steps.',
-    '- medium: likely candidate cause with most of the chain; 1-2 inferred steps; mark gaps explicitly with "verify by reading <file>" or "verify by running <cmd>".',
-    '- low: possible contributing factor or partial trace; weak evidence but worth surfacing for the maintainer to consider against other angles\' candidates.',
-].join('\n');
-export const ANNOTATOR_AWARENESS_DEBUG = [
-    'After your output, an annotator validates each finding against this debug rubric:',
-    '- Is each finding a hypothesis with a complete trace from symptom to cause (not a point observation at the symptom)?',
-    '- Does the cited cause come UPSTREAM of the cited symptom in the call/data flow?',
-    '- Is there a reproduction step the maintainer can use to trigger the failure?',
-    '- Is there a falsifier the maintainer can use to verify the fix?',
-    '- Did you propose fixes WITHOUT applying them (read-only contract)?',
-    '- Is severity calibrated to evidence strength (gaps in chain = lower severity, not the same severity with hand-waving)?',
-    'Self-check before emitting. Findings that fail any check are downgraded or dropped — but partial-evidence hypotheses with explicit "the gap is here, verify by X" notes are FULLY VALID, do NOT downgrade them as "speculation". Debug is speculation narrowed by evidence; hand-waving is the failure mode, not careful gap-marking.',
-].join('\n');
-import { parseCriteria } from '../criteria-types.js';
-/** Structured per-criterion array for parallel-criteria fan-out. */
-export const DEBUG_CRITERIA = parseCriteria(DEBUG_FAILURE_MODES);
-//# sourceMappingURL=implementer-criteria.js.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"implementer-criteria.js","sourceRoot":"","sources":["../../../src/tools/debug/implementer-criteria.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAEH;;;;;;;GAOG;AACH,MAAM,CAAC,MAAM,yBAAyB,GAAG;IACvC,sCAAsC;IACtC,gLAAgL;IAChL,EAAE;IACF,+DAA+D;IAC/D,sFAAsF;IACtF,8GAA8G;IAC9G,8FAA8F;IAC9F,gHAAgH;IAChH,0GAA0G;IAC1G,2IAA2I;IAC3I,EAAE;IACF,0NAA0N;IAC1N,EAAE;IACF,4OAA4O;CAC7O,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;AAEb,MAAM,CAAC,MAAM,mBAAmB,GAAG;IACjC,kDAAkD;IAClD,+GAA+G;IAC/G,kOAAkO;IAClO,8IAA8I;IAC9I,2KAA2K;IAC3K,kKAAkK;IAClK,iRAAiR;CAClR,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;AAEb,MAAM,CAAC,MAAM,gBAAgB,GAAG;IAC9B,QAAQ;IACR,8EAA8E;IAC9E,wMAAwM;IACxM,8OAA8O;IAC9O,kKAAkK;CACnK,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;AAEb;;;;;;;GAOG;AACH,MAAM,CAAC,MAAM,mBAAmB,GAAG;IACjC,4PAA4P;IAC5P,EAAE;IACF,kXAAkX;IAClX,sSAAsS;IACtS,uTAAuT;IACvT,gVAAgV;IAChV,8VAA8V;IAC9V,EAAE;IACF,qDAAqD;IACrD,0IAA0I;IAC1I,qJAAqJ;IACrJ,iKAAiK;IACjK,2JAA2J;CAC5J,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;AAEb,MAAM,CAAC,MAAM,yBAAyB,GAAG;IACvC,mFAAmF;IACnF,sHAAsH;IACtH,kFAAkF;IAClF,+EAA+E;IAC/E,kEAAkE;IAClE,qEAAqE;IACrE,yHAAyH;IACzH,uUAAuU;CACxU,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;AAEb,OAAO,EAAE,aAAa,EAAuB,MAAM,sBAAsB,CAAC;AAE1E,oEAAoE;AACpE,MAAM,CAAC,MAAM,cAAc,GAA8B,aAAa,CAAC,mBAAmB,CAAC,CAAC"}

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

@@ -1,60 +0,0 @@
-import { z } from 'zod';
-export declare const inputSchema: z.ZodObject<{
-    problem: z.ZodString;
-    context: z.ZodOptional<z.ZodString>;
-    hypothesis: z.ZodOptional<z.ZodString>;
-    subtype: z.ZodDefault<z.ZodEnum<{
-        default: "default";
-    }>>;
-    filePaths: z.ZodOptional<z.ZodArray<z.ZodString>>;
-    contextBlockIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
-}, z.core.$strip>;
-export type Input = z.infer<typeof inputSchema>;
-export declare const outputSchema: z.ZodObject<{
-    headline: z.ZodString;
-    results: z.ZodUnion<readonly [z.ZodArray<z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>, z.ZodObject<{
-        kind: z.ZodLiteral<"not_applicable">;
-        reason: z.ZodString;
-    }, z.core.$strip>]>;
-    batchTimings: z.ZodUnion<readonly [z.ZodObject<{}, z.core.$loose>, z.ZodObject<{
-        kind: z.ZodLiteral<"not_applicable">;
-        reason: z.ZodString;
-    }, z.core.$strip>]>;
-    costSummary: z.ZodUnion<readonly [z.ZodObject<{}, z.core.$loose>, z.ZodObject<{
-        kind: z.ZodLiteral<"not_applicable">;
-        reason: z.ZodString;
-    }, z.core.$strip>]>;
-    structuredReport: z.ZodUnion<readonly [z.ZodObject<{}, z.core.$loose>, z.ZodObject<{
-        kind: z.ZodLiteral<"not_applicable">;
-        reason: z.ZodString;
-    }, z.core.$strip>]>;
-    error: z.ZodUnion<readonly [z.ZodObject<{
-        code: z.ZodString;
-        message: z.ZodString;
-        details: z.ZodOptional<z.ZodUnknown>;
-    }, z.core.$strip>, z.ZodObject<{
-        kind: z.ZodLiteral<"not_applicable">;
-        reason: z.ZodString;
-    }, z.core.$strip>]>;
-    specReviewVerdict: z.ZodOptional<z.ZodEnum<{
-        error: "error";
-        approved: "approved";
-        concerns: "concerns";
-        changes_required: "changes_required";
-        annotated: "annotated";
-        skipped: "skipped";
-        not_applicable: "not_applicable";
-    }>>;
-    qualityReviewVerdict: z.ZodOptional<z.ZodEnum<{
-        error: "error";
-        approved: "approved";
-        concerns: "concerns";
-        changes_required: "changes_required";
-        annotated: "annotated";
-        skipped: "skipped";
-        not_applicable: "not_applicable";
-    }>>;
-    roundsUsed: z.ZodOptional<z.ZodNumber>;
-}, z.core.$loose>;
-export type Output = z.infer<typeof outputSchema>;
-//# sourceMappingURL=schema.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../../src/tools/debug/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"}

package/dist/tools/debug/schema.js

@@ -1,17 +0,0 @@
-// packages/core/src/tool-schemas/debug.ts
-import { z } from 'zod';
-import { buildOutputEnvelopeSchema } from '../shared-output.js';
-// Ported verbatim from packages/mcp/src/tools/debug-task.ts (debugTaskSchema).
-// The filePaths field has its description overridden in the original — reproduced here.
-// commonToolFields (filePaths + contextBlockIds) are inlined to avoid cross-package coupling.
-export const inputSchema = z.object({
-    problem: z.string().describe('What is broken'),
-    context: z.string().optional().describe('Background'),
-    hypothesis: z.string().optional().describe('Initial theory'),
-    subtype: z.enum(['default']).default('default').describe('Criteria-set selector. Only `default` is wired today; reserved for future per-failure-class subtypes.'),
-    filePaths: z.array(z.string()).optional().describe('Files the sub-agent should focus on. For debug_task, all provided files are investigated together in a single task.'),
-    contextBlockIds: z.array(z.string()).optional()
-        .describe('IDs from register_context_block to prepend to prompt. Use for delta audits, diff-scoped reviews, or shared specs.'),
-});
-export const outputSchema = buildOutputEnvelopeSchema();
-//# sourceMappingURL=schema.js.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"schema.js","sourceRoot":"","sources":["../../../src/tools/debug/schema.ts"],"names":[],"mappings":"AAAA,0CAA0C;AAC1C,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EAAE,yBAAyB,EAAE,MAAM,qBAAqB,CAAC;AAEhE,+EAA+E;AAC/E,wFAAwF;AACxF,8FAA8F;AAC9F,MAAM,CAAC,MAAM,WAAW,GAAG,CAAC,CAAC,MAAM,CAAC;IAClC,OAAO,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,CAAC,gBAAgB,CAAC;IAC9C,OAAO,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE,CAAC,QAAQ,CAAC,YAAY,CAAC;IACrD,UAAU,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE,CAAC,QAAQ,CAAC,gBAAgB,CAAC;IAC5D,OAAO,EAAE,CAAC,CAAC,IAAI,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC,QAAQ,CAAC,uGAAuG,CAAC;IACjK,SAAS,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,MAAM,EAAE,CAAC,CAAC,QAAQ,EAAE,CAAC,QAAQ,CAChD,qHAAqH,CACtH;IACD,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/debug/subtypes.d.ts

@@ -1,4 +0,0 @@
-import type { ReadOnlySubtypeSpec } from '../../lifecycle/read-only-subtype-spec.js';
-export type DebugSubtype = 'default';
-export declare const DEBUG_SUBTYPES: Record<DebugSubtype, ReadOnlySubtypeSpec>;
-//# sourceMappingURL=subtypes.d.ts.map

package/dist/tools/debug/subtypes.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"subtypes.d.ts","sourceRoot":"","sources":["../../../src/tools/debug/subtypes.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,2CAA2C,CAAC;AAOrF,MAAM,MAAM,YAAY,GAAG,SAAS,CAAC;AAiBrC,eAAO,MAAM,cAAc,EAAE,MAAM,CAAC,YAAY,EAAE,mBAAmB,CASpE,CAAC"}

package/dist/tools/debug/subtypes.js

@@ -1,26 +0,0 @@
-import { DEBUG_PURPOSE_ORIENTATION, EVIDENCE_RULE_DEBUG, SCOPE_RULE_DEBUG, ANNOTATOR_AWARENESS_DEBUG, DEBUG_CRITERIA, } from './implementer-criteria.js';
-// Copied verbatim from ROUTE_SEMANTICS.debug.
-const SEMANTICS_DEFAULT = {
-    goalLine: 'Apply THIS failure mode as the lens. Each finding is a root-cause hypothesis (or contributing factor), framed against this lens; severity = strength of the evidence chain.',
-    emptyOutcomeLine: 'If THIS lens reveals nothing in the failure under investigation, respond with "No findings for this criterion." — valid outcome.',
-    findingMeaningParagraph: 'A finding is a ROOT-CAUSE HYPOTHESIS (or contributing factor) for the failure under investigation, viewed through this criterion\'s lens. Title = the proposed cause. Severity reflects how strong the trace from symptom to cause is.',
-    severityMeanings: {
-        critical: 'Confirmed root cause',
-        high: 'Very likely root cause; one step unconfirmed',
-        medium: 'Plausible hypothesis',
-        low: 'Peripheral observation',
-    },
-    mustEmitAtLeastOne: true,
-    legalOutcomes: ['found', 'not_applicable'],
-};
-export const DEBUG_SUBTYPES = {
-    default: {
-        criteria: DEBUG_CRITERIA,
-        orientation: DEBUG_PURPOSE_ORIENTATION,
-        evidenceRule: EVIDENCE_RULE_DEBUG,
-        scopeRule: SCOPE_RULE_DEBUG,
-        annotatorAwareness: ANNOTATOR_AWARENESS_DEBUG,
-        semantics: SEMANTICS_DEFAULT,
-    },
-};
-//# sourceMappingURL=subtypes.js.map