muonroi-cli 1.8.4 → 1.9.0

package/dist/src/gsd/verify-gate-vocabulary.js

@@ -0,0 +1,46 @@
+/**
+ * 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.
+ */
+/**
+ * The canonical axes every implementation is judged against once the
+ * deterministic test floor has passed — intent-vs-reality, not "tests are green".
+ */
+export const VERIFY_GATE_DIMENSIONS = [
+    {
+        id: "acceptance",
+        label: "Acceptance met",
+        probe: "Every acceptance criterion is satisfied by a cited diff line or concrete evidence.",
+    },
+    {
+        id: "correctness",
+        label: "Actually correct",
+        probe: "No concrete failing input or state refutes that the implementation works.",
+    },
+    {
+        id: "regression",
+        label: "No regression",
+        probe: "No behavior outside the task scope was broken — no removed guards, changed signatures, or side effects.",
+    },
+    {
+        id: "safety",
+        label: "Safe",
+        probe: "The diff introduces no path traversal, secret leak, permission change, or dangerous shell pattern.",
+    },
+];
+/** Fast lookup by id. */
+export const VERIFY_GATE_DIMENSION_BY_ID = Object.fromEntries(VERIFY_GATE_DIMENSIONS.map((d) => [d.id, d]));
+/** Bullet list of axes, shared by both verify-gate prompt paths. */
+export function renderVerifyGateAxes() {
+    return [
+        "The implementation is judged against these axes (the test floor already passed):",
+        ...VERIFY_GATE_DIMENSIONS.map((d) => `- ${d.label}: ${d.probe}`),
+    ].join("\n");
+}
+//# sourceMappingURL=verify-gate-vocabulary.js.map

package/dist/src/gsd/workflow-engine.d.ts

@@ -0,0 +1,60 @@
+import type { GsdPhase } from "./types.js";
+export interface WorkflowState {
+    phase: GsdPhase | null;
+    depth: string | null;
+    planVerified: boolean;
+    raw: string;
+}
+export interface WorkflowProgress {
+    milestone_version?: string;
+    milestone_name?: string;
+    phases?: unknown[];
+    phase_count?: number;
+    completed_count?: number;
+    state_exists?: boolean;
+    project_exists?: boolean;
+}
+export type WorkflowKind = "task" | "product";
+export declare function readExtensionField(cwd: string, fieldName: string): string | null;
+export declare function readWorkflowKind(cwd: string): WorkflowKind | null;
+export declare function readVerifyOutcome(cwd: string): "pass" | "fail" | null;
+export declare function canShip(cwd: string, depth: string): {
+    allowed: boolean;
+    reason?: string;
+};
+export interface GsdStatusPayload {
+    state: WorkflowState;
+    progress: WorkflowProgress & {
+        phases_remaining?: number | null;
+    };
+    gates: {
+        canExecute: {
+            allowed: boolean;
+            reason?: string;
+        };
+        canShip: {
+            allowed: boolean;
+            reason?: string;
+        };
+        planVerifyVerdict: ReturnType<typeof readPlanVerifyVerdict>;
+    };
+    artifacts: {
+        planExists: boolean;
+        planVerifyExists: boolean;
+        verifyExists: boolean;
+        shipExists: boolean;
+        phaseDir: string | null;
+    };
+}
+export declare function buildGsdStatusPayload(cwd: string, depth: string): GsdStatusPayload;
+export declare function readState(cwd: string): WorkflowState;
+export declare function setStateField(cwd: string, field: string, value: string): WorkflowState;
+export declare function currentPhase(cwd: string): GsdPhase | null;
+export declare function advancePhase(cwd: string, phase: GsdPhase): WorkflowState;
+export declare function readProgress(cwd: string): WorkflowProgress;
+export declare function readPlanVerifyVerdict(cwd: string): "pass" | "revise" | "block" | null;
+export declare function canExecute(cwd: string, depth: string): {
+    allowed: boolean;
+    reason?: string;
+};
+export declare function syncWorkflowContext(cwd: string, sessionModelId: string, depth: string): WorkflowState;

package/dist/src/gsd/workflow-engine.js

@@ -0,0 +1,207 @@
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { ensurePlanningWorkspace } from "./config-bridge.js";
+import { dispatchInitProgress, dispatchStateJson, dispatchStateUpdate, invalidateGsdCache } from "./gsd-dispatch.js";
+import { loadStateDocument } from "./gsd-runtime.js";
+import { latestPhaseDir, planningArtifact } from "./paths.js";
+function readStateFile(cwd) {
+    const path = planningArtifact(cwd, "STATE.md");
+    if (!existsSync(path))
+        return "";
+    return readFileSync(path, "utf8");
+}
+function writeStateFile(cwd, content) {
+    writeFileSync(planningArtifact(cwd, "STATE.md"), content, "utf8");
+}
+function mapPhaseField(value) {
+    if (!value)
+        return null;
+    const normalized = value.trim().toLowerCase();
+    const allowed = ["discuss", "plan", "execute", "verify", "review", "debug"];
+    const exact = allowed.find((p) => p === normalized);
+    if (exact)
+        return exact;
+    // gsd-core prose uses "discuss of 0 (task)" — take task-level token before " of ".
+    const taskToken = normalized.split(/\s+of\s+/)[0]?.trim();
+    return taskToken ? (allowed.find((p) => p === taskToken) ?? null) : null;
+}
+/** Muonroi task fields live in the extension table; prose Phase: lines are gsd milestone position. */
+function extractExtensionTableField(raw, fieldName) {
+    const escaped = fieldName.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    const row = raw.match(new RegExp(`^\\|\\s*${escaped}\\s*\\|\\s*([^|\\n]+?)\\s*\\|`, "im"));
+    return row?.[1]?.trim() ?? null;
+}
+function replaceExtensionTableField(raw, fieldName, value) {
+    const escaped = fieldName.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    const pattern = new RegExp(`(^\\|\\s*${escaped}\\s*\\|\\s*)([^|\\n]*?)(\\s*\\|)`, "im");
+    if (!pattern.test(raw))
+        return null;
+    return raw.replace(pattern, `$1${value}$3`);
+}
+function appendExtensionTableField(raw, fieldName, value) {
+    return `${raw.trimEnd()}\n| ${fieldName} | ${value} |\n`;
+}
+export function readExtensionField(cwd, fieldName) {
+    const raw = readStateFile(cwd);
+    if (!raw)
+        return null;
+    return extractExtensionTableField(raw, fieldName);
+}
+export function readWorkflowKind(cwd) {
+    const kind = readExtensionField(cwd, "Workflow Kind")?.toLowerCase();
+    if (kind === "product")
+        return "product";
+    if (kind === "task")
+        return "task";
+    return kind ? kind : "task";
+}
+export function readVerifyOutcome(cwd) {
+    const path = planningArtifact(cwd, "VERIFY.md");
+    if (!existsSync(path))
+        return null;
+    const content = readFileSync(path, "utf8");
+    if (/verdict:\s*fail/i.test(content) || /status:\s*fail/i.test(content))
+        return "fail";
+    if (content.trim().length > 0)
+        return "pass";
+    return null;
+}
+export function canShip(cwd, depth) {
+    const state = readState(cwd);
+    if (state.phase !== "verify" && state.phase !== "review") {
+        return { allowed: false, reason: `phase is "${state.phase ?? "none"}" — call gsd_verify before gsd_ship` };
+    }
+    const verify = readVerifyOutcome(cwd);
+    if (verify === "fail") {
+        return { allowed: false, reason: "VERIFY.md indicates failure" };
+    }
+    if (depth !== "quick" && readPlanVerifyVerdict(cwd) !== "pass") {
+        return { allowed: false, reason: "plan-verify must pass before ship at standard/heavy depth" };
+    }
+    return { allowed: true };
+}
+export function buildGsdStatusPayload(cwd, depth) {
+    const state = readState(cwd);
+    const progressRaw = readProgress(cwd);
+    const phaseCount = progressRaw.phase_count;
+    const completedCount = progressRaw.completed_count;
+    const phasesRemaining = typeof phaseCount === "number" && typeof completedCount === "number"
+        ? Math.max(0, phaseCount - completedCount)
+        : null;
+    return {
+        state,
+        progress: { ...progressRaw, phases_remaining: phasesRemaining },
+        gates: {
+            canExecute: canExecute(cwd, depth),
+            canShip: canShip(cwd, depth),
+            planVerifyVerdict: readPlanVerifyVerdict(cwd),
+        },
+        artifacts: {
+            planExists: existsSync(planningArtifact(cwd, "PLAN.md")),
+            planVerifyExists: existsSync(planningArtifact(cwd, "PLAN-VERIFY.md")),
+            verifyExists: existsSync(planningArtifact(cwd, "VERIFY.md")),
+            shipExists: existsSync(planningArtifact(cwd, "SHIP.md")),
+            phaseDir: latestPhaseDir(cwd),
+        },
+    };
+}
+export function readState(cwd) {
+    const raw = readStateFile(cwd);
+    if (!raw) {
+        return { phase: null, depth: null, planVerified: false, raw: "" };
+    }
+    const doc = loadStateDocument();
+    const phaseRaw = extractExtensionTableField(raw, "Phase") ?? doc.stateExtractField(raw, "Phase");
+    const depth = extractExtensionTableField(raw, "Depth") ?? doc.stateExtractField(raw, "Depth");
+    const verifiedRaw = extractExtensionTableField(raw, "Plan Verified") ?? doc.stateExtractField(raw, "Plan Verified");
+    const phase = mapPhaseField(phaseRaw);
+    const planVerified = verifiedRaw?.toLowerCase() === "yes" || verifiedRaw?.toLowerCase() === "pass";
+    return { phase, depth, planVerified, raw };
+}
+export function setStateField(cwd, field, value) {
+    // gsd-core state-transition for milestone fields only — task Phase/Depth/Plan Verified use extension table.
+    const gsdCanonical = new Set(["Status", "status", "current_phase", "Current Phase"]);
+    if (gsdCanonical.has(field) && existsSync(planningArtifact(cwd, "STATE.md"))) {
+        const gsd = dispatchStateUpdate(cwd, field, value);
+        if (gsd.ok && gsd.data?.updated) {
+            return readState(cwd);
+        }
+    }
+    const raw = readStateFile(cwd);
+    const doc = loadStateDocument();
+    const base = raw || "# STATE\n\n| Field | Value |\n| --- | --- |\n";
+    const extensionFields = new Set([
+        "Phase",
+        "Depth",
+        "Plan Verified",
+        "Workflow Kind",
+        "Ideal Run",
+        "Milestone Phase Dir",
+    ]);
+    let next = null;
+    if (extensionFields.has(field)) {
+        next = replaceExtensionTableField(base, field, value);
+        if (!next)
+            next = appendExtensionTableField(base, field, value);
+    }
+    else {
+        next = doc.stateReplaceField(base, field, value);
+    }
+    if (!next) {
+        console.error(`[gsd] setStateField could not update ${field} in STATE.md`);
+        return readState(cwd);
+    }
+    writeStateFile(cwd, next);
+    // STATE.md just changed on disk → drop cached subprocess reads so the next
+    // dispatch / readState-with-progress sees the new mtime bucket.
+    invalidateGsdCache(cwd);
+    return readState(cwd);
+}
+export function currentPhase(cwd) {
+    return readState(cwd).phase;
+}
+export function advancePhase(cwd, phase) {
+    return setStateField(cwd, "Phase", phase);
+}
+export function readProgress(cwd) {
+    const result = dispatchInitProgress(cwd);
+    if (result.ok && result.data) {
+        return result.data;
+    }
+    const stateJson = dispatchStateJson(cwd);
+    return {
+        state_exists: existsSync(planningArtifact(cwd, "STATE.md")),
+        ...(stateJson.ok && stateJson.data ? { state_frontmatter: stateJson.data } : {}),
+    };
+}
+export function readPlanVerifyVerdict(cwd) {
+    const path = planningArtifact(cwd, "PLAN-VERIFY.md");
+    if (!existsSync(path))
+        return null;
+    const content = readFileSync(path, "utf8");
+    const match = content.match(/verdict:\s*(pass|revise|block)/i);
+    return match ? match[1].toLowerCase() : null;
+}
+export function canExecute(cwd, depth) {
+    if (depth === "quick")
+        return { allowed: true };
+    const verdict = readPlanVerifyVerdict(cwd);
+    if (verdict !== "pass") {
+        return {
+            allowed: false,
+            reason: verdict
+                ? `plan-verify verdict is "${verdict}" — call gsd_plan_review before gsd_execute`
+                : "plan-verify pending — call gsd_plan_review before gsd_execute",
+        };
+    }
+    const state = readState(cwd);
+    if (state.phase && state.phase !== "execute" && depth !== "quick") {
+        return { allowed: false, reason: `STATE.md phase is "${state.phase}" — advance to execute after plan-verify pass` };
+    }
+    return { allowed: true };
+}
+export function syncWorkflowContext(cwd, sessionModelId, depth) {
+    ensurePlanningWorkspace(cwd, sessionModelId);
+    setStateField(cwd, "Depth", depth);
+    return readState(cwd);
+}
+//# sourceMappingURL=workflow-engine.js.map

package/dist/src/gsd/workflow-tools.d.ts

@@ -0,0 +1,13 @@
+import { type ToolSet } from "ai";
+import type { TaskRequest, ToolResult } from "../types/index.js";
+export declare const GSD_WORKFLOW_TOOL_NAMES: readonly ["gsd_status", "gsd_discuss", "gsd_plan", "gsd_plan_review", "gsd_execute", "gsd_verify", "gsd_ship"];
+export interface GsdWorkflowToolOpts {
+    cwd: string;
+    sessionModelId: string;
+    sessionId?: string;
+    depth?: string;
+    runTask?: (request: TaskRequest, abortSignal?: AbortSignal) => Promise<ToolResult>;
+    runDebate?: (topic: string) => Promise<string>;
+}
+export declare function shouldRegisterGsdTools(depth?: string): boolean;
+export declare function registerGsdWorkflowTools(tools: ToolSet, opts: GsdWorkflowToolOpts): ToolSet;

package/dist/src/gsd/workflow-tools.js

@@ -0,0 +1,277 @@
+import { execFileSync } from "node:child_process";
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { dynamicTool, jsonSchema } from "ai";
+import { ensurePlanningWorkspace } from "./config-bridge.js";
+import { isGsdNativeEnabled } from "./flags.js";
+import { getGsdLoopHost, loopHostContext, taskToRunPerspectiveFn } from "./loop-host.js";
+import { planningArtifact } from "./paths.js";
+import { runVerifyCouncil } from "./verify-council.js";
+import { advancePhase, buildGsdStatusPayload, canExecute, canShip, readState, setStateField, } from "./workflow-engine.js";
+export const GSD_WORKFLOW_TOOL_NAMES = [
+    "gsd_status",
+    "gsd_discuss",
+    "gsd_plan",
+    "gsd_plan_review",
+    "gsd_execute",
+    "gsd_verify",
+    "gsd_ship",
+];
+function json(data) {
+    return JSON.stringify(data, null, 2);
+}
+/**
+ * Adapts `taskToRunPerspectiveFn` (typed for plan-council `PlanPerspective`) to the verify
+ * council's `VerifyPerspective` shape. Safe: `resolveGsdPerspectiveAgent` only special-cases
+ * `id === "research"` (a plan-only id that never appears in `VerifyPerspectiveId`), so every
+ * verify perspective routes to the same "verify" subagent regardless of id — only the id
+ * value is threaded through for the task description string.
+ */
+function verifyRunPerspectiveFn(runTask, sessionModelId) {
+    const planFn = taskToRunPerspectiveFn(runTask, sessionModelId);
+    return (prompt, p) => planFn(prompt, p);
+}
+/** Best-effort implementation diff for the verify council. Empty on any failure — never throws. */
+function readImplementationDiff(cwd) {
+    try {
+        return execFileSync("git", ["diff", "HEAD"], { cwd, encoding: "utf8", maxBuffer: 16 * 1024 * 1024 });
+    }
+    catch (err) {
+        console.error(`[gsd] verify-council diff capture failed: ${err.message}`);
+        return "";
+    }
+}
+export function shouldRegisterGsdTools(depth) {
+    if (!isGsdNativeEnabled())
+        return false;
+    if (depth === "quick") {
+        return true;
+    }
+    return true;
+}
+export function registerGsdWorkflowTools(tools, opts) {
+    if (!isGsdNativeEnabled())
+        return tools;
+    const depth = opts.depth ?? "standard";
+    const { cwd, sessionModelId, sessionId, runTask } = opts;
+    tools.gsd_status = dynamicTool({
+        description: "Read native GSD workflow progress: STATE.md phase, depth, plan-verify status, and gsd-tools init.progress summary. Use to orient mid-task. Pure read — does not advance phase or write STATE.md.",
+        inputSchema: jsonSchema({ type: "object", properties: {}, additionalProperties: false }),
+        execute: async () => {
+            // Pure read: bootstrap .planning/ only if absent (idempotent — no write when it exists).
+            // Turn-start sync (message-processor) handles depth/STATE writes; gsd_status must NOT
+            // mutate STATE.md mtime, or the dispatch cache (keyed on STATE mtime) would thrash.
+            ensurePlanningWorkspace(cwd, sessionModelId);
+            return json(buildGsdStatusPayload(cwd, depth));
+        },
+    });
+    tools.gsd_discuss = dynamicTool({
+        description: "Enter GSD discuss phase — surface ambiguities before planning. Sets STATE.md phase to discuss.",
+        inputSchema: jsonSchema({
+            type: "object",
+            properties: {
+                notes: { type: "string", description: "Gray-area notes to append" },
+            },
+        }),
+        execute: async (input) => {
+            ensurePlanningWorkspace(cwd, sessionModelId);
+            const host = getGsdLoopHost();
+            host.ensureHost(cwd, sessionModelId);
+            advancePhase(cwd, "discuss");
+            await host.onDiscussComplete(loopHostContext(cwd, sessionModelId, depth, { phase: "discuss" }));
+            if (input.notes?.trim()) {
+                const ctxPath = planningArtifact(cwd, "CONTEXT.md");
+                const prior = existsSync(ctxPath) ? readFileSync(ctxPath, "utf8") : "# CONTEXT\n\n";
+                writeFileSync(ctxPath, `${prior}\n${input.notes.trim()}\n`, "utf8");
+            }
+            return json({ phase: "discuss", ok: true });
+        },
+    });
+    tools.gsd_plan = dynamicTool({
+        description: "Write PLAN.md for a multi-step task (leader-tier draft). Call before gsd_plan_review and gsd_execute.",
+        inputSchema: jsonSchema({
+            type: "object",
+            properties: {
+                body: { type: "string", description: "Full PLAN.md markdown body" },
+            },
+            required: ["body"],
+        }),
+        execute: async (input) => {
+            if (!input.body?.trim()) {
+                return json({ ok: false, error: "gsd_plan requires non-empty body" });
+            }
+            ensurePlanningWorkspace(cwd, sessionModelId);
+            writeFileSync(planningArtifact(cwd, "PLAN.md"), input.body.trim(), "utf8");
+            setStateField(cwd, "Plan Verified", "no");
+            advancePhase(cwd, "plan");
+            const host = getGsdLoopHost();
+            const ctx = loopHostContext(cwd, sessionModelId, depth, {
+                phase: "plan",
+                sessionId,
+                planBody: input.body.trim(),
+                planTitle: input.body
+                    .trim()
+                    .match(/^#\s+(.+)$/m)?.[1]
+                    ?.trim(),
+            });
+            await host.onPlanWritten(ctx);
+            return json({ ok: true, path: planningArtifact(cwd, "PLAN.md") });
+        },
+    });
+    if (depth !== "quick") {
+        tools.gsd_plan_review = dynamicTool({
+            description: "Run multi-perspective plan council (research + skeptic at standard; full council at heavy). Mandatory before gsd_execute at standard/heavy depth.",
+            inputSchema: jsonSchema({ type: "object", properties: {}, additionalProperties: false }),
+            execute: async () => {
+                const host = getGsdLoopHost();
+                const ctx = loopHostContext(cwd, sessionModelId, depth, {
+                    sessionId,
+                    runPerspectiveFn: runTask ? taskToRunPerspectiveFn(runTask, sessionModelId) : undefined,
+                    runDebate: opts.runDebate,
+                });
+                await host.firePoint("plan:post", ctx);
+                const reviewResult = await host.firePoint("plan-review:post", ctx);
+                const state = readState(cwd);
+                return json({
+                    planReview: reviewResult,
+                    planVerified: state.planVerified,
+                    phase: state.phase,
+                });
+            },
+        });
+    }
+    tools.gsd_execute = dynamicTool({
+        description: "Advance to execute phase after plan-verify pass. Does not run code itself — unlocks implement step in workflow state.",
+        inputSchema: jsonSchema({
+            type: "object",
+            properties: {
+                force: { type: "boolean", description: "Bypass plan-verify gate (yolo/debug only)" },
+            },
+        }),
+        execute: async (input) => {
+            const gate = canExecute(cwd, depth);
+            if (!gate.allowed && !input.force) {
+                return json({ blocked: true, reason: gate.reason });
+            }
+            const host = getGsdLoopHost();
+            const ctx = loopHostContext(cwd, sessionModelId, depth);
+            await host.onExecuteStart(ctx);
+            advancePhase(cwd, "execute");
+            return json({ blocked: false, phase: "execute" });
+        },
+    });
+    tools.gsd_verify = dynamicTool({
+        description: "Mark verify phase complete after tests/self-verify. Requires evidence when passed=true.",
+        inputSchema: jsonSchema({
+            type: "object",
+            properties: {
+                passed: { type: "boolean", description: "true when tests/self-verify passed" },
+                evidence: { type: "string", description: "Test/lint evidence summary (required when passed=true)" },
+            },
+            required: ["passed"],
+            additionalProperties: false,
+        }),
+        execute: async (input) => {
+            const passed = input.passed === true;
+            if (passed && !input.evidence?.trim()) {
+                return json({
+                    ok: false,
+                    error: "gsd_verify requires non-empty evidence when passed=true",
+                });
+            }
+            // Layer 2: council adjudication ONLY when the deterministic floor passed at non-quick
+            // depth. The council verdict OVERRIDES the model's self-reported `passed` — "tests green
+            // but doesn't meet the goal" is caught here. A `passed=false` floor never reaches the
+            // council (cheap: no LLM spend on an already-known failure).
+            let effectivePassed = passed;
+            let councilConcerns = [];
+            if (passed && depth !== "quick") {
+                try {
+                    const diff = readImplementationDiff(cwd);
+                    const council = await runVerifyCouncil({
+                        cwd,
+                        sessionModelId,
+                        depth,
+                        evidence: input.evidence?.trim(),
+                        diff,
+                        runPerspectiveFn: runTask ? verifyRunPerspectiveFn(runTask, sessionModelId) : undefined,
+                        runDebate: opts.runDebate,
+                    });
+                    if (!council.skipped && council.verdict !== "pass") {
+                        effectivePassed = false;
+                        councilConcerns = council.concerns;
+                    }
+                }
+                catch (err) {
+                    // Fail OPEN — a council wiring failure must not block a genuinely-passing verify;
+                    // honor the deterministic floor's verdict. Log per No-Silent-Catch.
+                    console.error(`[gsd] verify-council wiring failed, honoring deterministic floor: ${err.message}`);
+                }
+            }
+            const verdictLine = effectivePassed ? "verdict: pass" : "verdict: fail";
+            const concernBlock = councilConcerns.length
+                ? `\n\n## Council concerns\n${councilConcerns.map((c) => `- ${c}`).join("\n")}`
+                : "";
+            if (input.evidence?.trim() || councilConcerns.length) {
+                writeFileSync(planningArtifact(cwd, "VERIFY.md"), `${verdictLine}\n\n${input.evidence?.trim() ?? ""}${concernBlock}\n`, "utf8");
+            }
+            const host = getGsdLoopHost();
+            const ctx = loopHostContext(cwd, sessionModelId, depth, {
+                sessionId,
+                verifyPassed: effectivePassed,
+                verifyEvidence: {
+                    evidence: input.evidence?.trim(),
+                    evidenceChars: input.evidence?.length ?? 0,
+                    passed: effectivePassed,
+                },
+            });
+            const verifyResult = await host.onVerifyComplete(ctx);
+            return json({
+                ok: true,
+                phase: effectivePassed ? "review" : "debug",
+                passed: effectivePassed,
+                councilConcerns,
+                loop: verifyResult,
+            });
+        },
+    });
+    tools.gsd_ship = dynamicTool({
+        description: "Polish delivery after gsd_verify pass — writes .planning/SHIP.md. Call when task is ready to hand off.",
+        inputSchema: jsonSchema({
+            type: "object",
+            properties: {
+                notes: {
+                    type: "array",
+                    items: { type: "string" },
+                    description: "Optional delivery notes (agent-supplied, unverified)",
+                },
+                commitMessage: {
+                    type: "string",
+                    description: "Suggested commit message (stored in SHIP.md only, no git)",
+                },
+            },
+            additionalProperties: false,
+        }),
+        execute: async (input) => {
+            const gate = canShip(cwd, depth);
+            if (!gate.allowed) {
+                return json({ blocked: true, reason: gate.reason });
+            }
+            const host = getGsdLoopHost();
+            const ctx = loopHostContext(cwd, sessionModelId, depth, {
+                sessionId,
+                shipNotes: input.notes,
+                commitMessage: input.commitMessage,
+            });
+            const shipResult = await host.onShipComplete(ctx);
+            advancePhase(cwd, "review");
+            return json({
+                ok: true,
+                phase: "review",
+                shipMdPath: planningArtifact(cwd, "SHIP.md"),
+                loop: shipResult,
+            });
+        },
+    });
+    return tools;
+}
+//# sourceMappingURL=workflow-tools.js.map

package/dist/src/headless/council-answers.js

@@ -10,6 +10,10 @@ export function createCouncilAutoAnswerer(opts) {
         "pil-acceptance": [],
         "tool-loop-cap": [],
         "safety-override": [],
+        // ask_user: no file queue — fall through to defaultAnswerFor, which returns
+        // the agent's FIRST option (index 0) or "" for a free-text ask. Index 0 is
+        // NOT a CLI recommendation, just first-listed; headless has no human.
+        "ask-user": [],
     };
     const preflightApprove = opts.file?.preflightApprove ?? true;
     return {

package/dist/src/hooks/index.js

@@ -226,7 +226,7 @@ export async function executeEventHooks(input, cwd, _signal) {
                             .join(",");
                         if (pendingSha !== _lastRecallReminderSha) {
                             _lastRecallReminderSha = pendingSha;
-                            recallReminder = `⚠️ MANDATORY: ${pending.length} unrated EE recall(s) — call ee_feedback NOW before continuing.\n${formatPendingReminder(pending, { max: 5 })}`;
+                            recallReminder = `↳ ${pending.length} unrated EE recall(s) — rate the one(s) you acted on when convenient (does not block the task; queued if the brain is down).\n${formatPendingReminder(pending, { max: 5 })}`;
                         }
                     }
                     else {