muonroi-cli 1.8.4 → 1.9.0

package/dist/src/gsd/state-document.js

@@ -0,0 +1,163 @@
+/**
+ * state-document.ts — Native replacement for gsd-core/bin/lib/state-document.cjs
+ *
+ * STATE.md Document Module — pure transforms for STATE.md text.
+ * This module does not read the filesystem and does not own persistence or locking.
+ */
+function escapeRegex(str) {
+    return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function isTableSeparatorRow(firstCell) {
+    return /^[\s\-:]+$/.test(firstCell.trim());
+}
+function tableRowPattern(escapedFieldName) {
+    return new RegExp(`^(\\|[ \\t]*)(${escapedFieldName})([ \\t]*\\|[ \\t]*)([^|\\n]*?)([ \\t]*\\|[ \\t]*)$`, "im");
+}
+/**
+ * Extract a field value from STATE.md content.
+ * Supports bold inline (**FieldName:** value), plain line-start (FieldName: value),
+ * and pipe-table (| FieldName | value |) formats.
+ */
+export function stateExtractField(content, fieldName) {
+    const escaped = escapeRegex(fieldName);
+    // Bold inline: **FieldName:** value
+    const boldPattern = new RegExp(`\\*\\*${escaped}:\\*\\*[ \\t]*(.+)`, "i");
+    const boldMatch = content.match(boldPattern);
+    if (boldMatch)
+        return boldMatch[1].trim();
+    // Plain line-start: FieldName: value
+    const plainPattern = new RegExp(`^${escaped}:[ \\t]*(.+)`, "im");
+    const plainMatch = content.match(plainPattern);
+    if (plainMatch)
+        return plainMatch[1].trim();
+    // Pipe-table: | FieldName | value |
+    const tableMatch = content.match(tableRowPattern(escaped));
+    if (tableMatch && !isTableSeparatorRow(tableMatch[2]))
+        return tableMatch[4].trim();
+    return null;
+}
+/**
+ * Replace a field value in STATE.md content.
+ * Returns null if the field is not found in any known format.
+ */
+export function stateReplaceField(content, fieldName, newValue) {
+    const escaped = escapeRegex(fieldName);
+    // Bold inline: **FieldName:** value
+    const boldPattern = new RegExp(`(\\*\\*${escaped}:\\*\\*\\s*)(.*)`, "i");
+    if (boldPattern.test(content)) {
+        return content.replace(boldPattern, (_match, prefix) => `${prefix}${newValue}`);
+    }
+    // Plain line-start: FieldName: value
+    const plainPattern = new RegExp(`(^${escaped}:\\s*)(.*)`, "im");
+    if (plainPattern.test(content)) {
+        return content.replace(plainPattern, (_match, prefix) => `${prefix}${newValue}`);
+    }
+    // Pipe-table: | FieldName | value |
+    const tblPat = tableRowPattern(escaped);
+    const tblMatch = content.match(tblPat);
+    if (tblMatch && !isTableSeparatorRow(tblMatch[2])) {
+        return content.replace(tblPat, (_m, leadPipe, fieldCell, midPipe, _oldVal, trailPipe) => `${leadPipe}${fieldCell}${midPipe}${newValue}${trailPipe}`);
+    }
+    return null;
+}
+/**
+ * Replace a field with a primary name, falling back to an alternate field name.
+ */
+export function stateReplaceFieldWithFallback(content, primary, fallback, value) {
+    const result = stateReplaceField(content, primary, value);
+    if (result)
+        return result;
+    if (fallback) {
+        const fbResult = stateReplaceField(content, fallback, value);
+        if (fbResult)
+            return fbResult;
+    }
+    return content;
+}
+/** Normalize a status string to a canonical value. */
+export function normalizeStateStatus(status, pausedAt) {
+    const statusLower = (status || "").toLowerCase();
+    if (statusLower.includes("paused") || statusLower.includes("stopped") || pausedAt) {
+        return "paused";
+    }
+    if (statusLower.includes("executing") || statusLower.includes("in progress")) {
+        return "executing";
+    }
+    if (statusLower.includes("planning") || statusLower.includes("ready to plan")) {
+        return "planning";
+    }
+    if (statusLower.includes("discussing"))
+        return "discussing";
+    if (statusLower.includes("verif"))
+        return "verifying";
+    if (statusLower.includes("complete") || statusLower.includes("done"))
+        return "completed";
+    if (statusLower.includes("ready to execute"))
+        return "executing";
+    return status || "unknown";
+}
+/** Compute progress percentage from plan and phase counts. */
+export function computeProgressPercent(completedPlans, totalPlans, completedPhases, totalPhases) {
+    const hasPlanData = totalPlans !== null && totalPlans > 0 && completedPlans !== null;
+    const hasPhaseData = totalPhases !== null && totalPhases > 0 && completedPhases !== null;
+    if (!hasPlanData && !hasPhaseData)
+        return null;
+    const planFraction = hasPlanData ? (completedPlans ?? 0) / (totalPlans ?? 1) : 1;
+    const phaseFraction = hasPhaseData ? (completedPhases ?? 0) / (totalPhases ?? 1) : 1;
+    return Math.min(100, Math.round(Math.min(planFraction, phaseFraction) * 100));
+}
+/**
+ * KNOWN_TEMPLATE_DEFAULTS — per-field table of handler-written values.
+ * A value in this list is safe to overwrite on the next handler call.
+ */
+export const KNOWN_TEMPLATE_DEFAULTS = {
+    "Resume File": ["None"],
+    Status: [
+        "Ready to execute",
+        "Phase complete — ready for verification",
+        "Ready to plan",
+        "Defining requirements",
+        "Planning complete",
+        "Executing",
+        "In progress",
+        "Planning",
+        "Verifying",
+        "Completed",
+        "Done",
+        "Active",
+        "Paused",
+        "unknown",
+    ],
+    "Last Activity": [],
+    "Last activity": [],
+};
+/**
+ * Regex patterns matching handler-generated Status values with variable components.
+ */
+export const KNOWN_STATUS_PATTERNS = [
+    /^Executing Phase\s+\d+/i,
+    /^Planning Phase\s+\d+/i,
+    /^Phase\s+\d+\s+complete/i,
+    /^Verifying Phase\s+\d+/i,
+    /^Phase complete/i,
+    /^Complete\s*[✓✔✅☑]?\s*$/i,
+];
+/** Check if a value is a known template default (handler may overwrite it). */
+export function isStateTemplateDefault(field, value) {
+    if (value === null || value === undefined)
+        return true;
+    const v = (typeof value === "string" ? value : `${value}`).trim();
+    if (v === "")
+        return true;
+    const defaults = KNOWN_TEMPLATE_DEFAULTS[field];
+    const matched = defaults ? defaults.some((d) => d.toLowerCase() === v.toLowerCase()) : false;
+    if (matched)
+        return true;
+    const fieldLower = field.toLowerCase();
+    if (fieldLower === "status" && KNOWN_STATUS_PATTERNS.some((p) => p.test(v)))
+        return true;
+    if (fieldLower === "last activity" && /^\d{4}-\d{2}-\d{2}$/.test(v))
+        return true;
+    return false;
+}
+//# sourceMappingURL=state-document.js.map

package/dist/src/gsd/verdict-schema.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Model-first verdict protocol for the GSD plan-council.
+ *
+ * The verdict decision is owned by the model and emitted as structured JSON.
+ * Our code only parses + validates. When parse fails the caller degrades
+ * conservatively (force another revision cycle) — we never derive the verdict
+ * from prose via regex.
+ *
+ * Extraction strategy (in priority order):
+ *   1. Last fenced block labeled ```council-verdict``` (preferred shape).
+ *   2. Last fenced block labeled ```json``` that validates.
+ *   3. Last fenced block (any / no label) that validates.
+ *   4. Last brace-balanced {...} substring that validates.
+ *   5. null — caller decides conservative fallback.
+ *
+ * "Last wins" because the model is instructed to emit reasoning first and a
+ * final verdict block last; earlier JSON (e.g. quoting plan acceptance
+ * criteria) must not collide.
+ */
+import { z } from "zod";
+export declare const PlanCouncilVerdictSchema: z.ZodObject<{
+    verdict: z.ZodEnum<{
+        block: "block";
+        approve: "approve";
+        revise: "revise";
+    }>;
+    concerns: z.ZodCatch<z.ZodArray<z.ZodString>>;
+    evidence: z.ZodDefault<z.ZodCatch<z.ZodArray<z.ZodString>>>;
+    rationale: z.ZodOptional<z.ZodCatch<z.ZodString>>;
+}, z.core.$strip>;
+export type PlanCouncilVerdict = z.infer<typeof PlanCouncilVerdictSchema>;
+/**
+ * Extract a model-first structured verdict from raw model output.
+ * Returns null when no valid verdict block is found — caller MUST treat null
+ * as "parse failed" (conservative revise), never as "approve".
+ */
+export declare function extractStructuredVerdict(raw: string): PlanCouncilVerdict | null;
+/** Render the output-contract suffix appended to every council prompt. */
+export declare const VERDICT_OUTPUT_CONTRACT: string;

package/dist/src/gsd/verdict-schema.js

@@ -0,0 +1,144 @@
+/**
+ * Model-first verdict protocol for the GSD plan-council.
+ *
+ * The verdict decision is owned by the model and emitted as structured JSON.
+ * Our code only parses + validates. When parse fails the caller degrades
+ * conservatively (force another revision cycle) — we never derive the verdict
+ * from prose via regex.
+ *
+ * Extraction strategy (in priority order):
+ *   1. Last fenced block labeled ```council-verdict``` (preferred shape).
+ *   2. Last fenced block labeled ```json``` that validates.
+ *   3. Last fenced block (any / no label) that validates.
+ *   4. Last brace-balanced {...} substring that validates.
+ *   5. null — caller decides conservative fallback.
+ *
+ * "Last wins" because the model is instructed to emit reasoning first and a
+ * final verdict block last; earlier JSON (e.g. quoting plan acceptance
+ * criteria) must not collide.
+ */
+import { z } from "zod";
+export const PlanCouncilVerdictSchema = z.object({
+    verdict: z.enum(["approve", "revise", "block"]),
+    concerns: z.array(z.string()).catch([]),
+    evidence: z.array(z.string()).catch([]).default([]),
+    rationale: z.string().catch("").optional(),
+});
+/** Validate + coerce a candidate JSON object to the verdict shape, or null. */
+function validate(candidate) {
+    if (candidate === null || typeof candidate !== "object")
+        return null;
+    const parsed = PlanCouncilVerdictSchema.safeParse(candidate);
+    return parsed.success ? parsed.data : null;
+}
+const FENCE_RE = /```([a-zA-Z0-9_+-]+)?\s*\n([\s\S]*?)\n?```/g;
+/** All fenced blocks in document order, with their (lower-cased) label. */
+function findFencedBlocks(raw) {
+    const out = [];
+    for (const m of raw.matchAll(FENCE_RE)) {
+        const label = (m[1] ?? "").toLowerCase();
+        const body = m[2] ?? "";
+        out.push({ label, body });
+    }
+    return out;
+}
+/** Top-level {...} substrings via brace-balanced scan, in document order. */
+function findBareObjects(raw) {
+    const out = [];
+    let i = 0;
+    while (i < raw.length) {
+        if (raw[i] !== "{") {
+            i += 1;
+            continue;
+        }
+        let depth = 0;
+        let inStr = false;
+        let esc = false;
+        let j = i;
+        for (; j < raw.length; j += 1) {
+            const ch = raw[j];
+            if (inStr) {
+                if (esc)
+                    esc = false;
+                else if (ch === "\\")
+                    esc = true;
+                else if (ch === '"')
+                    inStr = false;
+            }
+            else if (ch === '"') {
+                inStr = true;
+            }
+            else if (ch === "{") {
+                depth += 1;
+            }
+            else if (ch === "}") {
+                depth -= 1;
+                if (depth === 0) {
+                    out.push(raw.slice(i, j + 1));
+                    break;
+                }
+            }
+        }
+        i = j >= raw.length ? j : j + 1;
+    }
+    return out;
+}
+function tryJson(s) {
+    const trimmed = s.trim();
+    if (!trimmed)
+        return null;
+    try {
+        return validate(JSON.parse(trimmed));
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Extract a model-first structured verdict from raw model output.
+ * Returns null when no valid verdict block is found — caller MUST treat null
+ * as "parse failed" (conservative revise), never as "approve".
+ */
+export function extractStructuredVerdict(raw) {
+    if (!raw || !raw.trim())
+        return null;
+    // 1-3. Fenced blocks, preferring labeled council-verdict → json → bare, then
+    //      taking the LAST valid one in each priority bucket.
+    const fenced = findFencedBlocks(raw);
+    const buckets = { verdict: [], json: [], bare: [] };
+    for (const f of fenced) {
+        if (f.label === "council-verdict")
+            buckets.verdict.push(f);
+        else if (f.label === "json")
+            buckets.json.push(f);
+        else
+            buckets.bare.push(f);
+    }
+    for (const bucket of [buckets.verdict, buckets.json, buckets.bare]) {
+        for (let i = bucket.length - 1; i >= 0; i -= 1) {
+            const parsed = tryJson(bucket[i].body);
+            if (parsed)
+                return parsed;
+        }
+    }
+    // 4. Bare {...} substrings, right-to-left.
+    const bare = findBareObjects(raw);
+    for (let i = bare.length - 1; i >= 0; i -= 1) {
+        const parsed = tryJson(bare[i]);
+        if (parsed)
+            return parsed;
+    }
+    return null;
+}
+/** Render the output-contract suffix appended to every council prompt. */
+export const VERDICT_OUTPUT_CONTRACT = [
+    "",
+    "Emit your final decision as a fenced block in EXACTLY this shape — no prose inside the fence, no fields beyond these four:",
+    "```council-verdict",
+    '{"verdict":"approve|revise|block","concerns":["..."],"evidence":["..."],"rationale":"one short sentence"}',
+    "```",
+    '- "approve" = plan is correct, safe, and ready to execute.',
+    '- "revise" = plan has gaps — list each gap as a concern; execution stays gated.',
+    '- "block" = plan is fundamentally flawed — list each blocker as a concern.',
+].join("\n");
+//# sourceMappingURL=verdict-schema.js.map

package/dist/src/gsd/verify-context.d.ts

@@ -0,0 +1,22 @@
+import { type CouncilContextBundle } from "./council-context.js";
+export interface VerifyContextBundle {
+    base: CouncilContextBundle;
+    /** Implementation diff (caller supplies; empty when unavailable). */
+    diff: string;
+    diffChars: number;
+    /** Deterministic-floor evidence (test/lint/self-verify output). */
+    evidence: string;
+    /** The plan-verify verdict recorded before execution — sanity anchor. */
+    planVerdict: "pass" | "revise" | "block" | null;
+}
+/**
+ * Build the context a verify-council needs: the full plan bundle (acceptance
+ * criteria are the verify contract) PLUS the implementation diff and the
+ * deterministic-floor evidence. Reads are tolerant — missing inputs degrade to
+ * empty strings, never throw.
+ */
+export declare function buildVerifyContextBundle(cwd: string, opts: {
+    depth: string;
+    evidence?: string;
+    diff?: string;
+}): VerifyContextBundle;

package/dist/src/gsd/verify-context.js

@@ -0,0 +1,27 @@
+import { buildCouncilContextBundle } from "./council-context.js";
+import { readPlanVerifyVerdict } from "./workflow-engine.js";
+const DIFF_CAP = 8000;
+const EVIDENCE_CAP = 4000;
+function cap(text, max) {
+    const t = (text ?? "").trim();
+    return t.length <= max ? t : `${t.slice(0, max)}…[truncated]`;
+}
+/**
+ * Build the context a verify-council needs: the full plan bundle (acceptance
+ * criteria are the verify contract) PLUS the implementation diff and the
+ * deterministic-floor evidence. Reads are tolerant — missing inputs degrade to
+ * empty strings, never throw.
+ */
+export function buildVerifyContextBundle(cwd, opts) {
+    const base = buildCouncilContextBundle(cwd, { depth: opts.depth });
+    const diff = cap(opts.diff ?? "", DIFF_CAP);
+    const evidence = cap(opts.evidence ?? "", EVIDENCE_CAP);
+    return {
+        base,
+        diff,
+        diffChars: diff.length,
+        evidence,
+        planVerdict: readPlanVerifyVerdict(cwd),
+    };
+}
+//# sourceMappingURL=verify-context.js.map

package/dist/src/gsd/verify-council-prompts.d.ts

@@ -0,0 +1,19 @@
+import type { VerifyContextBundle } from "./verify-context.js";
+import { type VerifyGateDimensionId } from "./verify-gate-vocabulary.js";
+export type VerifyPerspectiveId = "acceptance" | "correctness" | "regression" | "security";
+export interface VerifyPerspective {
+    id: VerifyPerspectiveId;
+    role: string;
+    mandate: string;
+    /**
+     * The shared verify-gate axis this perspective primarily owns. Ties the
+     * headless perspective set to the same criteria the interactive verify debate
+     * uses; the full set must cover every VERIFY_GATE_DIMENSION (parity-tested).
+     */
+    dimension: VerifyGateDimensionId;
+}
+export declare const VERIFY_PERSPECTIVES: VerifyPerspective[];
+/** standard = acceptance + correctness; heavy = all four; quick = none (deterministic floor only). */
+export declare function verifyPerspectivesForDepth(depth: string): VerifyPerspective[];
+export declare function buildVerifyPerspectivePrompt(p: VerifyPerspective, bundle: VerifyContextBundle): string;
+export declare function buildVerifyDebateTopic(bundle: VerifyContextBundle): string;

package/dist/src/gsd/verify-council-prompts.js

@@ -0,0 +1,85 @@
+import { renderCouncilContextBlock } from "./council-context.js";
+import { VERDICT_OUTPUT_CONTRACT } from "./verdict-schema.js";
+import { renderVerifyGateAxes } from "./verify-gate-vocabulary.js";
+export const VERIFY_PERSPECTIVES = [
+    {
+        id: "acceptance",
+        role: "acceptance auditor",
+        mandate: "For EACH acceptance criterion, cite the diff line or evidence that satisfies it. Any criterion without concrete evidence is a concern.",
+        dimension: "acceptance",
+    },
+    {
+        id: "correctness",
+        role: "adversarial correctness reviewer",
+        mandate: "Try to REFUTE that the implementation works. Construct a concrete failing input or state. Default to a concern when uncertain.",
+        dimension: "correctness",
+    },
+    {
+        id: "regression",
+        role: "regression reviewer",
+        mandate: "Identify behavior OUTSIDE the task scope that the diff may have broken (removed guards, changed signatures, side effects).",
+        dimension: "regression",
+    },
+    {
+        id: "security",
+        role: "security reviewer",
+        mandate: "Path traversal, secret handling, permission changes, dangerous shell patterns introduced by the diff.",
+        dimension: "safety",
+    },
+];
+/** standard = acceptance + correctness; heavy = all four; quick = none (deterministic floor only). */
+export function verifyPerspectivesForDepth(depth) {
+    if (depth === "quick")
+        return [];
+    if (depth === "standard")
+        return VERIFY_PERSPECTIVES.filter((p) => p.id === "acceptance" || p.id === "correctness");
+    return VERIFY_PERSPECTIVES;
+}
+function renderBundle(bundle) {
+    return [
+        renderCouncilContextBlock(bundle.base),
+        "",
+        "### Deterministic-floor evidence (tests/lint/self-verify)",
+        "",
+        bundle.evidence || "(no evidence supplied)",
+        "",
+        "### Implementation diff under review",
+        "",
+        "```diff",
+        bundle.diff || "(no diff supplied)",
+        "```",
+    ].join("\n");
+}
+export function buildVerifyPerspectivePrompt(p, bundle) {
+    return [
+        `You are the ${p.role} on a verify council judging whether an implementation meets its plan.`,
+        `Mandate: ${p.mandate}`,
+        "",
+        "The deterministic test floor has already PASSED. Your job is intent-vs-reality: does the code",
+        "actually achieve the plan's goal and acceptance criteria? Tests passing is necessary, not sufficient.",
+        "",
+        // Shared gate axes (single source with the interactive verify debate) so both
+        // verify-gate paths judge the implementation against identical criteria.
+        renderVerifyGateAxes(),
+        "",
+        renderBundle(bundle),
+        "",
+        VERDICT_OUTPUT_CONTRACT,
+    ].join("\n");
+}
+export function buildVerifyDebateTopic(bundle) {
+    return [
+        "Debate whether the implementation below satisfies the plan's goal and acceptance criteria.",
+        "The deterministic test floor already passed — focus on goal-achievement, missed acceptance criteria,",
+        "and regressions. Converge on a single merged verdict.",
+        "",
+        // Shared gate axes (single source with the headless perspective review) so
+        // both verify-gate paths judge the implementation against identical criteria.
+        renderVerifyGateAxes(),
+        "",
+        renderBundle(bundle),
+        "",
+        VERDICT_OUTPUT_CONTRACT,
+    ].join("\n");
+}
+//# sourceMappingURL=verify-council-prompts.js.map

package/dist/src/gsd/verify-council.d.ts

@@ -0,0 +1,25 @@
+import { type VerifyPerspective } from "./verify-council-prompts.js";
+export type VerifyVerdict = "pass" | "revise" | "block";
+export interface VerifyCouncilResult {
+    skipped: boolean;
+    verdict: VerifyVerdict;
+    concerns: string[];
+    verifyCouncilPath?: string;
+    leaderModelId?: string;
+    verdictSource: "structured" | "heuristic-fallback" | "parse-failed";
+}
+export interface VerifyCouncilOpts {
+    cwd: string;
+    sessionModelId: string;
+    depth: string;
+    evidence?: string;
+    diff?: string;
+    runPerspectiveFn?: (prompt: string, p: VerifyPerspective) => Promise<string>;
+    runDebate?: (topic: string) => Promise<string>;
+}
+/**
+ * Independent council adjudication of an implementation against its plan.
+ * Runs ONLY after the deterministic test floor passes (caller's contract).
+ * Never silently approves: a missing structured verdict forces "revise".
+ */
+export declare function runVerifyCouncil(opts: VerifyCouncilOpts): Promise<VerifyCouncilResult>;

package/dist/src/gsd/verify-council.js

@@ -0,0 +1,119 @@
+import { writeFileSync } from "node:fs";
+import { resolvePlanCouncilLeader } from "../council/leader.js";
+import { planningArtifact } from "./paths.js";
+import { extractStructuredVerdict } from "./verdict-schema.js";
+import { buildVerifyContextBundle } from "./verify-context.js";
+import { buildVerifyDebateTopic, buildVerifyPerspectivePrompt, verifyPerspectivesForDepth, } from "./verify-council-prompts.js";
+/** approve → pass; else the worst verdict wins (block > revise). */
+function mergeVerdict(verdicts) {
+    if (verdicts.some((v) => v === "block"))
+        return "block";
+    if (verdicts.some((v) => v === "revise"))
+        return "revise";
+    return "pass";
+}
+function writeArtifact(cwd, verdict, concerns, leaderModelId, source) {
+    const path = planningArtifact(cwd, "VERIFY-COUNCIL.md");
+    const content = [
+        "# VERIFY-COUNCIL",
+        "",
+        `verdict: ${verdict}`,
+        `leader: \`${leaderModelId}\``,
+        `verdictSource: ${source}`,
+        "",
+        "## Concerns",
+        concerns.length ? concerns.map((c) => `- ${c}`).join("\n") : "- (none)",
+    ].join("\n");
+    writeFileSync(path, content, "utf8");
+    return path;
+}
+/**
+ * Independent council adjudication of an implementation against its plan.
+ * Runs ONLY after the deterministic test floor passes (caller's contract).
+ * Never silently approves: a missing structured verdict forces "revise".
+ */
+export async function runVerifyCouncil(opts) {
+    const perspectives = verifyPerspectivesForDepth(opts.depth);
+    if (perspectives.length === 0) {
+        return { skipped: true, verdict: "pass", concerns: [], verdictSource: "structured" };
+    }
+    const bundle = buildVerifyContextBundle(opts.cwd, { depth: opts.depth, evidence: opts.evidence, diff: opts.diff });
+    const leader = await resolvePlanCouncilLeader(opts.sessionModelId);
+    // ---- Debate path (production: runCouncilV2 synthesis) ----
+    if (opts.runDebate) {
+        let synthesis = "";
+        try {
+            synthesis = await opts.runDebate(buildVerifyDebateTopic(bundle));
+        }
+        catch (err) {
+            console.error(`[gsd] verify-council debate failed: ${err.message}`);
+        }
+        const parsed = extractStructuredVerdict(synthesis);
+        if (!parsed) {
+            const concerns = ["Verify council leader emitted no structured verdict — forcing revision."];
+            const path = writeArtifact(opts.cwd, "revise", concerns, leader.modelId, "parse-failed");
+            return {
+                skipped: false,
+                verdict: "revise",
+                concerns,
+                verifyCouncilPath: path,
+                leaderModelId: leader.modelId,
+                verdictSource: "parse-failed",
+            };
+        }
+        const verdict = mergeVerdict([parsed.verdict]);
+        const concerns = parsed.concerns.map(String);
+        const path = writeArtifact(opts.cwd, verdict, concerns, leader.modelId, "structured");
+        return {
+            skipped: false,
+            verdict,
+            concerns,
+            verifyCouncilPath: path,
+            leaderModelId: leader.modelId,
+            verdictSource: "structured",
+        };
+    }
+    // ---- Perspective path (parallel sub-agents; tests use this) ----
+    if (!opts.runPerspectiveFn) {
+        // No runner at all — cannot adjudicate; conservatively pass (deterministic floor already gated).
+        return { skipped: true, verdict: "pass", concerns: [], verdictSource: "structured" };
+    }
+    const runFn = opts.runPerspectiveFn;
+    const results = await Promise.all(perspectives.map(async (p) => {
+        try {
+            const raw = await runFn(buildVerifyPerspectivePrompt(p, bundle), p);
+            const parsed = extractStructuredVerdict(raw);
+            if (!parsed) {
+                console.error(`[gsd] verify-council perspective ${p.id} emitted no structured verdict — forcing revise`);
+                return {
+                    verdict: "revise",
+                    concerns: [`${p.id}: no structured verdict (parse failed)`],
+                    parseFailed: true,
+                };
+            }
+            return { verdict: parsed.verdict, concerns: parsed.concerns.map(String), parseFailed: false };
+        }
+        catch (err) {
+            console.error(`[gsd] verify-council perspective ${p.id} failed: ${err.message}`);
+            return {
+                verdict: "revise",
+                concerns: [`${p.id}: perspective error — ${err.message}`],
+                parseFailed: true,
+            };
+        }
+    }));
+    const verdict = mergeVerdict(results.map((r) => r.verdict));
+    const concerns = results.flatMap((r) => r.concerns);
+    const anyParseFailed = results.some((r) => r.parseFailed);
+    const source = anyParseFailed ? "parse-failed" : "structured";
+    const path = writeArtifact(opts.cwd, verdict, concerns, leader.modelId, source);
+    return {
+        skipped: false,
+        verdict,
+        concerns,
+        verifyCouncilPath: path,
+        leaderModelId: leader.modelId,
+        verdictSource: source,
+    };
+}
+//# sourceMappingURL=verify-council.js.map

package/dist/src/gsd/verify-gate-vocabulary.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Single source of truth for the GSD verify-gate's EVALUATION AXES — the twin of
+ * plan-gate-vocabulary.ts for the verify council. Same drift risk: the interactive
+ * verify debate (`buildVerifyDebateTopic`) and the headless perspective review
+ * (`buildVerifyPerspectivePrompt` over `VERIFY_PERSPECTIVES`) must judge an
+ * implementation against IDENTICAL criteria or the two verify gates diverge.
+ *
+ * Council decision 2026-07-11 (PR 2): apply the plan-gate consolidation to the
+ * verify twin — one criteria source both paths derive from, parity-locked.
+ */
+export type VerifyGateDimensionId = "acceptance" | "correctness" | "regression" | "safety";
+export interface VerifyGateDimension {
+    id: VerifyGateDimensionId;
+    label: string;
+    probe: string;
+}
+/**
+ * The canonical axes every implementation is judged against once the
+ * deterministic test floor has passed — intent-vs-reality, not "tests are green".
+ */
+export declare const VERIFY_GATE_DIMENSIONS: readonly VerifyGateDimension[];
+/** Fast lookup by id. */
+export declare const VERIFY_GATE_DIMENSION_BY_ID: Readonly<Record<VerifyGateDimensionId, VerifyGateDimension>>;
+/** Bullet list of axes, shared by both verify-gate prompt paths. */
+export declare function renderVerifyGateAxes(): string;