muonroi-cli 1.8.5 → 1.9.0

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

@@ -1,6 +1,7 @@
 import { existsSync, readFileSync, writeFileSync } from "node:fs";
 import { resolvePlanCouncilLeader } from "../council/leader.js";
 import { buildCouncilContextBundle } from "./council-context.js";
+import { getPlanReviewDebateRetries } from "./flags.js";
 import { buildGsdPerspectiveTaskRequest } from "./model-tier.js";
 import { planningArtifact } from "./paths.js";
 import { buildDebateTopic, buildPerspectivePrompt, perspectivesForDepth, } from "./plan-council-prompts.js";
@@ -137,81 +138,112 @@ export async function runPlanCouncil(opts) {
         const leader = await resolvePlanCouncilLeader(sessionModelId);
         const bundle = buildCouncilContextBundle(cwd, { depth, revisionCycle });
         const topic = buildDebateTopic(planBody, bundle);
+        // The council debate returns an EMPTY synthesis on any of its fail-open
+        // paths (provider unreachable, sub-phase catch, user/watchdog abort) — a
+        // silent null we must NOT collapse into a permanent forced-`revise`. Retry
+        // the debate on empty (covers transient aborts), then fall back to the
+        // perspective path so an autonomous /ideal run never bricks with 0 code.
+        const maxRetries = getPlanReviewDebateRetries();
         let synthesis = "";
-        try {
-            synthesis = await opts.runDebate(topic);
+        let lastDebateError;
+        for (let attempt = 0; attempt <= maxRetries; attempt += 1) {
+            try {
+                synthesis = (await opts.runDebate(topic)) ?? "";
+            }
+            catch (err) {
+                lastDebateError = err.message;
+                console.error(`[gsd] plan-review debate threw (attempt ${attempt + 1}/${maxRetries + 1}): ${lastDebateError}`);
+                synthesis = "";
+            }
+            if (synthesis.trim())
+                break;
+            if (attempt < maxRetries) {
+                console.error(`[gsd] plan-review debate returned empty synthesis ` +
+                    `(attempt ${attempt + 1}/${maxRetries + 1}) — provider unreachable / aborted / ` +
+                    `sub-phase fail-open; retrying`);
+            }
         }
-        catch (err) {
-            console.error(`[gsd] plan review debate failed: ${err.message}`);
+        // Persistent empty synthesis after retries — this is a DEBATE FAILURE, not
+        // a plan defect. Do NOT write a misleading "leader did not emit a verdict"
+        // forced-revise (which would brick the run). Log the real reason
+        // (No-Silent-Catch) and fall through to the perspective path below, which
+        // produces a genuine verdict from parallel sub-agent reviewers (heuristic
+        // last resort) so the loop can proceed.
+        if (!synthesis.trim()) {
+            console.error(`[gsd] plan-review debate produced no synthesis after ${maxRetries + 1} attempt(s)` +
+                `${lastDebateError ? ` (last error: ${lastDebateError})` : ""} — ` +
+                `falling back to perspective review`);
+        }
+        else {
+            const parsed = extractStructuredVerdict(synthesis);
+            const parseFailed = parsed === null;
+            // Model-first: if we could not extract structured verdict, DO NOT regex
+            // the prose. Force a conservative revise so the loop iterates and the
+            // leader gets another chance to emit valid JSON (the prior-concerns
+            // directive re-states the contract).
+            // Map "approve" → "pass" so the merged verdict matches the union the rest
+            // of the pipeline expects (applyVerdict keys the gate on `=== "pass"`).
+            const rawVerdict = parseFailed ? "revise" : parsed.verdict;
+            const verdict = rawVerdict === "approve" ? "pass" : rawVerdict;
+            const source = parseFailed ? "parse-failed" : "structured";
+            const concerns = parsed?.concerns.map(String) ?? [
+                "Council leader did not emit a structured verdict block — forcing revision.",
+            ];
+            const evidence = parsed?.evidence.map(String) ?? [];
+            const rationale = parsed?.rationale ?? "";
+            const planReviewPath = planningArtifact(cwd, "PLAN-REVIEW.md");
+            const planVerifyPath = planningArtifact(cwd, "PLAN-VERIFY.md");
+            const reviewContent = [
+                "# PLAN-REVIEW",
+                "",
+                `Leader: \`${leader.modelId}\``,
+                `Revision cycle: ${revisionCycle}`,
+                `Verdict source: ${source}${parseFailed ? " (parse failed — forced revise)" : ""}`,
+                "",
+                "## Council Debate Synthesis",
+                "",
+                synthesis.trim() || "No synthesis generated.",
+                rationale ? `\n**Rationale:** ${rationale}` : "",
+                "",
+                "## Merged Concerns",
+                "",
+                concerns.length ? concerns.map((c) => `- ${c}`).join("\n") : "- (none)",
+            ].join("\n");
+            const verifyContent = [
+                "# PLAN-VERIFY",
+                "",
+                `verdict: ${verdict}`,
+                `revisionRequired: ${verdict === "revise" || verdict === "block" ? "yes" : "no"}`,
+                `verdictSource: ${source}`,
+                `verdictParseFailed: ${parseFailed ? "yes" : "no"}`,
+                "",
+                "## Summary",
+                verdict === "pass"
+                    ? "Council leader approved via structured verdict."
+                    : parseFailed
+                        ? "Structured verdict missing — forced revision so the leader re-emits valid JSON."
+                        : `Council requested ${verdict}.`,
+                "",
+                "## Concerns",
+                concerns.length ? concerns.map((c) => `- ${c}`).join("\n") : "- (none)",
+            ].join("\n");
+            writeFileSync(planReviewPath, reviewContent, "utf8");
+            writeFileSync(planVerifyPath, verifyContent, "utf8");
+            applyVerdict(cwd, verdict);
+            return {
+                skipped: false,
+                perspectives: [],
+                planReviewPath,
+                planVerifyPath,
+                verdict,
+                leaderModelId: leader.modelId,
+                revisionRequired: verdict === "revise" || verdict === "block",
+                contextBundleChars: bundle.totalChars,
+                hadPriorConcerns: bundle.hadPriorConcerns,
+                verdictSource: source,
+                verdictParseFailed: parseFailed,
+            };
         }
-        const parsed = extractStructuredVerdict(synthesis);
-        const parseFailed = parsed === null;
-        // Model-first: if we could not extract structured verdict, DO NOT regex
-        // the prose. Force a conservative revise so the loop iterates and the
-        // leader gets another chance to emit valid JSON (the prior-concerns
-        // directive re-states the contract).
-        // Map "approve" → "pass" so the merged verdict matches the union the rest
-        // of the pipeline expects (applyVerdict keys the gate on `=== "pass"`).
-        const rawVerdict = parseFailed ? "revise" : parsed.verdict;
-        const verdict = rawVerdict === "approve" ? "pass" : rawVerdict;
-        const source = parseFailed ? "parse-failed" : "structured";
-        const concerns = parsed?.concerns.map(String) ?? [
-            "Council leader did not emit a structured verdict block — forcing revision.",
-        ];
-        const evidence = parsed?.evidence.map(String) ?? [];
-        const rationale = parsed?.rationale ?? "";
-        const planReviewPath = planningArtifact(cwd, "PLAN-REVIEW.md");
-        const planVerifyPath = planningArtifact(cwd, "PLAN-VERIFY.md");
-        const reviewContent = [
-            "# PLAN-REVIEW",
-            "",
-            `Leader: \`${leader.modelId}\``,
-            `Revision cycle: ${revisionCycle}`,
-            `Verdict source: ${source}${parseFailed ? " (parse failed — forced revise)" : ""}`,
-            "",
-            "## Council Debate Synthesis",
-            "",
-            synthesis.trim() || "No synthesis generated.",
-            rationale ? `\n**Rationale:** ${rationale}` : "",
-            "",
-            "## Merged Concerns",
-            "",
-            concerns.length ? concerns.map((c) => `- ${c}`).join("\n") : "- (none)",
-        ].join("\n");
-        const verifyContent = [
-            "# PLAN-VERIFY",
-            "",
-            `verdict: ${verdict}`,
-            `revisionRequired: ${verdict === "revise" || verdict === "block" ? "yes" : "no"}`,
-            `verdictSource: ${source}`,
-            `verdictParseFailed: ${parseFailed ? "yes" : "no"}`,
-            "",
-            "## Summary",
-            verdict === "pass"
-                ? "Council leader approved via structured verdict."
-                : parseFailed
-                    ? "Structured verdict missing — forced revision so the leader re-emits valid JSON."
-                    : `Council requested ${verdict}.`,
-            "",
-            "## Concerns",
-            concerns.length ? concerns.map((c) => `- ${c}`).join("\n") : "- (none)",
-        ].join("\n");
-        writeFileSync(planReviewPath, reviewContent, "utf8");
-        writeFileSync(planVerifyPath, verifyContent, "utf8");
-        applyVerdict(cwd, verdict);
-        return {
-            skipped: false,
-            perspectives: [],
-            planReviewPath,
-            planVerifyPath,
-            verdict,
-            leaderModelId: leader.modelId,
-            revisionRequired: verdict === "revise" || verdict === "block",
-            contextBundleChars: bundle.totalChars,
-            hadPriorConcerns: bundle.hadPriorConcerns,
-            verdictSource: source,
-            verdictParseFailed: parseFailed,
-        };
     }
     // ---------- Perspective path (parallel sub-agents) ----------
     const leader = await resolvePlanCouncilLeader(sessionModelId);

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

@@ -20,8 +20,8 @@
 import { z } from "zod";
 export declare const PlanCouncilVerdictSchema: z.ZodObject<{
     verdict: z.ZodEnum<{
-        approve: "approve";
         block: "block";
+        approve: "approve";
         revise: "revise";
     }>;
     concerns: z.ZodCatch<z.ZodArray<z.ZodString>>;

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 {