gsd-pi 2.76.0-dev.fe143342a → 2.77.0-dev.538325aea

package/dist/resources/extensions/gsd/dispatch-guard.js

@@ -2,10 +2,26 @@
 import { resolveMilestoneFile } from "./paths.js";
 import { findMilestoneIds } from "./guided-flow.js";
 import { parseUnitId } from "./unit-id.js";
-import { isDbAvailable, getMilestoneSlices } from "./gsd-db.js";
+import { isDbAvailable, getMilestoneSlices, getMilestone } from "./gsd-db.js";
 import { parseRoadmap } from "./parsers-legacy.js";
 import { isClosedStatus } from "./status-guards.js";
 import { readFileSync } from "node:fs";
+/**
+ * Detect failure-path milestone SUMMARY content (#4663 sibling to #4658).
+ * A failure SUMMARY must not let the dispatch guard treat an active
+ * milestone as complete. The markers mirror those produced by
+ * writeBlockerPlaceholder and the "verification FAILED" retry path.
+ *
+ * This is intentionally a minimal local detector so this fix does not
+ * depend on PR #4660's `classifyMilestoneSummaryContent`. It can migrate
+ * to the shared classifier once that lands.
+ */
+function isFailureMilestoneSummary(content) {
+    return (/(?:^|\n)\s*#\s*BLOCKER\b/i.test(content) ||
+        /auto-mode recovery failed/i.test(content) ||
+        /verification\s+failed/i.test(content) ||
+        /\bnot complete\b/i.test(content));
+}
 const SLICE_DISPATCH_TYPES = new Set([
     "research-slice",
     "plan-slice",
@@ -39,8 +55,33 @@ export function getPriorSliceCompletionBlocker(base, _mainBranch, unitType, unit
     for (const mid of milestoneIds) {
         if (resolveMilestoneFile(base, mid, "PARKED"))
             continue;
-        if (resolveMilestoneFile(base, mid, "SUMMARY"))
-            continue;
+        // DB/SUMMARY completion check (#4663 sibling to #4658).
+        // Prior behavior treated any SUMMARY file on disk as proof of milestone
+        // completion, which is wrong when the SUMMARY is a failure-path report
+        // (verification FAILED, blocker placeholder, etc.). Resolve as follows:
+        //   1. When DB is available and status is closed → skip (authoritative).
+        //   2. When SUMMARY exists but looks like a failure/blocker report →
+        //      do not short-circuit; fall through to the slice-level check so
+        //      the guard can still block dependents of an active milestone.
+        //   3. Otherwise (SUMMARY without failure markers) → skip. Preserves
+        //      the #1716 contract where a completed milestone with unchecked
+        //      remediation slices is still treated as done.
+        const summaryPath = resolveMilestoneFile(base, mid, "SUMMARY");
+        if (isDbAvailable()) {
+            const milestoneRow = getMilestone(mid);
+            if (milestoneRow && isClosedStatus(milestoneRow.status))
+                continue;
+        }
+        if (summaryPath) {
+            let summaryContent = null;
+            try {
+                summaryContent = readFileSync(summaryPath, "utf-8");
+            }
+            catch { /* ignore */ }
+            if (!summaryContent || !isFailureMilestoneSummary(summaryContent)) {
+                continue;
+            }
+        }
         let slices = null;
         if (isDbAvailable()) {
             const rows = getMilestoneSlices(mid);

package/dist/resources/extensions/gsd/gitignore.js

@@ -45,6 +45,7 @@ const BASELINE_PATTERNS = [
     // ── GSD state directory (symlink to external storage) ──
     ".gsd",
     ".gsd-id",
+    ".mcp.json",
     ".bg-shell/",
     // ── OS junk ──
     ".DS_Store",

package/dist/resources/extensions/gsd/gsd-db.js

@@ -135,7 +135,7 @@ function openRawDb(path) {
     const Database = providerModule;
     return new Database(path);
 }
-const SCHEMA_VERSION = 21;
+const SCHEMA_VERSION = 22;
 function indexExists(db, name) {
     return !!db.prepare("SELECT 1 as present FROM sqlite_master WHERE type = 'index' AND name = ?").get(name);
 }
@@ -491,17 +491,6 @@ function initSchema(db, fileBacked) {
       )
     `);
         db.exec("CREATE INDEX IF NOT EXISTS idx_memories_active ON memories(superseded_by)");
-        // Existing DBs may arrive here before migrateSchema() has added columns
-        // that fresh installs already have. Add only columns needed by bootstrap
-        // indexes so old DBs can open far enough for the normal migration chain.
-        ensureBootstrapIndexColumns(db);
-        if (columnExists(db, "memories", "scope")) {
-            db.exec("CREATE INDEX IF NOT EXISTS idx_memories_scope ON memories(scope)");
-        }
-        db.exec("CREATE INDEX IF NOT EXISTS idx_memory_sources_kind ON memory_sources(kind)");
-        db.exec("CREATE INDEX IF NOT EXISTS idx_memory_sources_scope ON memory_sources(scope)");
-        db.exec("CREATE INDEX IF NOT EXISTS idx_memory_relations_from ON memory_relations(from_id)");
-        db.exec("CREATE INDEX IF NOT EXISTS idx_memory_relations_to ON memory_relations(to_id)");
         db.exec("CREATE INDEX IF NOT EXISTS idx_replan_history_milestone ON replan_history(milestone_id, created_at)");
         // v13 indexes — hot-path dispatch queries
         db.exec("CREATE INDEX IF NOT EXISTS idx_tasks_active ON tasks(milestone_id, slice_id, status)");
@@ -517,14 +506,21 @@ function initSchema(db, fileBacked) {
         db.exec("CREATE INDEX IF NOT EXISTS idx_turn_git_tx_turn ON turn_git_transactions(trace_id, turn_id)");
         db.exec("CREATE INDEX IF NOT EXISTS idx_audit_events_trace ON audit_events(trace_id, ts)");
         db.exec("CREATE INDEX IF NOT EXISTS idx_audit_events_turn ON audit_events(trace_id, turn_id, ts)");
-        // ADR-011 Phase 2 — also created by the v17 migration; fresh installs
-        // skip migrations so the index must be created here too.
-        db.exec("CREATE INDEX IF NOT EXISTS idx_tasks_escalation_pending ON tasks(milestone_id, slice_id, escalation_pending)");
         db.exec(`CREATE VIEW IF NOT EXISTS active_decisions AS SELECT * FROM decisions WHERE superseded_by IS NULL`);
         db.exec(`CREATE VIEW IF NOT EXISTS active_requirements AS SELECT * FROM requirements WHERE superseded_by IS NULL`);
         db.exec(`CREATE VIEW IF NOT EXISTS active_memories AS SELECT * FROM memories WHERE superseded_by IS NULL`);
         const existing = db.prepare("SELECT count(*) as cnt FROM schema_version").get();
         if (existing && existing["cnt"] === 0) {
+            // Fresh install — all tables are created above with the full current schema,
+            // so it is safe to create all migration-specific indexes here.  For existing
+            // databases these indexes are created inside the individual migration guards
+            // in migrateSchema() after the corresponding columns have been added.
+            db.exec("CREATE INDEX IF NOT EXISTS idx_tasks_escalation_pending ON tasks(milestone_id, slice_id, escalation_pending)");
+            db.exec("CREATE INDEX IF NOT EXISTS idx_memories_scope ON memories(scope)");
+            db.exec("CREATE INDEX IF NOT EXISTS idx_memory_sources_kind ON memory_sources(kind)");
+            db.exec("CREATE INDEX IF NOT EXISTS idx_memory_sources_scope ON memory_sources(scope)");
+            db.exec("CREATE INDEX IF NOT EXISTS idx_memory_relations_from ON memory_relations(from_id)");
+            db.exec("CREATE INDEX IF NOT EXISTS idx_memory_relations_to ON memory_relations(to_id)");
             db.prepare("INSERT INTO schema_version (version, applied_at) VALUES (:version, :applied_at)").run({
                 ":version": SCHEMA_VERSION,
                 ":applied_at": new Date().toISOString(),
@@ -596,13 +592,6 @@ function ensureColumn(db, table, column, ddl) {
     if (!columnExists(db, table, column))
         db.exec(ddl);
 }
-function ensureBootstrapIndexColumns(db) {
-    ensureColumn(db, "memories", "scope", `ALTER TABLE memories ADD COLUMN scope TEXT NOT NULL DEFAULT 'project'`);
-    ensureColumn(db, "memories", "tags", `ALTER TABLE memories ADD COLUMN tags TEXT NOT NULL DEFAULT '[]'`);
-    ensureColumn(db, "memory_sources", "scope", `ALTER TABLE memory_sources ADD COLUMN scope TEXT NOT NULL DEFAULT 'project'`);
-    ensureColumn(db, "memory_sources", "tags", `ALTER TABLE memory_sources ADD COLUMN tags TEXT NOT NULL DEFAULT '[]'`);
-    ensureColumn(db, "tasks", "escalation_pending", `ALTER TABLE tasks ADD COLUMN escalation_pending INTEGER NOT NULL DEFAULT 0`);
-}
 function migrateSchema(db) {
     const row = db.prepare("SELECT MAX(version) as v FROM schema_version").get();
     const currentVersion = row ? row["v"] : 0;
@@ -856,19 +845,24 @@ function migrateSchema(db) {
             });
         }
         if (currentVersion < 12) {
+            // NOTE: The original DDL used COALESCE(task_id, '') in the PRIMARY KEY
+            // expression, which is invalid SQLite syntax and causes startup errors on
+            // DBs that migrate through v12. The corrected DDL uses
+            // task_id TEXT NOT NULL DEFAULT '' with a plain column list PK. DBs that
+            // were created with the broken DDL are repaired by the v22 migration below.
             db.exec(`
         CREATE TABLE IF NOT EXISTS quality_gates (
           milestone_id TEXT NOT NULL,
           slice_id TEXT NOT NULL,
           gate_id TEXT NOT NULL,
           scope TEXT NOT NULL DEFAULT 'slice',
-          task_id TEXT DEFAULT NULL,
+          task_id TEXT NOT NULL DEFAULT '',
           status TEXT NOT NULL DEFAULT 'pending',
           verdict TEXT NOT NULL DEFAULT '',
           rationale TEXT NOT NULL DEFAULT '',
           findings TEXT NOT NULL DEFAULT '',
           evaluated_at TEXT DEFAULT NULL,
-          PRIMARY KEY (milestone_id, slice_id, gate_id, COALESCE(task_id, '')),
+          PRIMARY KEY (milestone_id, slice_id, gate_id, task_id),
           FOREIGN KEY (milestone_id, slice_id) REFERENCES slices(milestone_id, id)
         )
       `);
@@ -1020,6 +1014,10 @@ function migrateSchema(db) {
           tags TEXT NOT NULL DEFAULT '[]'
         )
       `);
+            // If memory_sources already existed before v18 (created by an earlier
+            // version of initSchema that lacked scope/tags), add the missing columns.
+            ensureColumn(db, "memory_sources", "scope", `ALTER TABLE memory_sources ADD COLUMN scope TEXT NOT NULL DEFAULT 'project'`);
+            ensureColumn(db, "memory_sources", "tags", `ALTER TABLE memory_sources ADD COLUMN tags TEXT NOT NULL DEFAULT '[]'`);
             db.exec("CREATE INDEX IF NOT EXISTS idx_memories_scope ON memories(scope)");
             db.exec("CREATE INDEX IF NOT EXISTS idx_memory_sources_kind ON memory_sources(kind)");
             db.exec("CREATE INDEX IF NOT EXISTS idx_memory_sources_scope ON memory_sources(scope)");
@@ -1087,6 +1085,51 @@ function migrateSchema(db) {
                 ":applied_at": new Date().toISOString(),
             });
         }
+        if (currentVersion < 22) {
+            // v22: Repair quality_gates tables that were created by the broken v12
+            // migration (which used COALESCE(task_id, '') as a PK expression — invalid
+            // SQLite DDL). Those DBs have task_id nullable (dflt_value NULL, notnull 0).
+            // Rebuild the table with the correct schema, migrating existing rows via
+            // COALESCE so no data is lost.
+            const qgInfo = db.prepare("PRAGMA table_info(quality_gates)").all();
+            const taskIdCol = qgInfo.find((r) => r["name"] === "task_id");
+            const needsRepair = taskIdCol && (taskIdCol["notnull"] === 0 || taskIdCol["notnull"] === "0");
+            if (needsRepair) {
+                db.exec(`
+          CREATE TABLE quality_gates_new (
+            milestone_id TEXT NOT NULL,
+            slice_id TEXT NOT NULL,
+            gate_id TEXT NOT NULL,
+            scope TEXT NOT NULL DEFAULT 'slice',
+            task_id TEXT NOT NULL DEFAULT '',
+            status TEXT NOT NULL DEFAULT 'pending',
+            verdict TEXT NOT NULL DEFAULT '',
+            rationale TEXT NOT NULL DEFAULT '',
+            findings TEXT NOT NULL DEFAULT '',
+            evaluated_at TEXT DEFAULT NULL,
+            PRIMARY KEY (milestone_id, slice_id, gate_id, task_id),
+            FOREIGN KEY (milestone_id, slice_id) REFERENCES slices(milestone_id, id)
+          )
+        `);
+                db.exec(`
+          INSERT OR IGNORE INTO quality_gates_new
+            (milestone_id, slice_id, gate_id, scope, task_id, status, verdict, rationale, findings, evaluated_at)
+          SELECT milestone_id, slice_id, gate_id, scope, COALESCE(task_id, ''), status, verdict, rationale, findings, evaluated_at
+          FROM quality_gates
+        `);
+                db.exec("DROP TABLE quality_gates");
+                db.exec("ALTER TABLE quality_gates_new RENAME TO quality_gates");
+                db.exec("CREATE INDEX IF NOT EXISTS idx_quality_gates_pending ON quality_gates(milestone_id, slice_id, status)");
+            }
+            // Ensure scope column exists on quality_gates and assessments (guard
+            // against DBs that somehow lack it after a partial migration).
+            ensureColumn(db, "quality_gates", "scope", "ALTER TABLE quality_gates ADD COLUMN scope TEXT NOT NULL DEFAULT 'slice'");
+            ensureColumn(db, "assessments", "scope", "ALTER TABLE assessments ADD COLUMN scope TEXT NOT NULL DEFAULT ''");
+            db.prepare("INSERT INTO schema_version (version, applied_at) VALUES (:version, :applied_at)").run({
+                ":version": 22,
+                ":applied_at": new Date().toISOString(),
+            });
+        }
         db.exec("COMMIT");
     }
     catch (err) {
@@ -2353,7 +2396,10 @@ export function reconcileWorktreeDb(mainDbPath, worktreeDbPath) {
           SELECT path, artifact_type, milestone_id, slice_id, task_id, full_content, imported_at
           FROM wt.artifacts
         `).run());
-                // Merge milestones — worktree may have updated status/planning fields
+                // Merge milestones — worktree may have updated status/planning fields.
+                // Never downgrade status: complete > active > pre-planning (#4372).
+                // A stale worktree may carry an older 'active' status for a milestone
+                // that the main DB has already marked 'complete'; preserve the higher status.
                 merged.milestones = countChanges(adapter.prepare(`
           INSERT OR REPLACE INTO milestones (
             id, title, status, depends_on, created_at, completed_at,
@@ -2361,11 +2407,25 @@ export function reconcileWorktreeDb(mainDbPath, worktreeDbPath) {
             verification_contract, verification_integration, verification_operational, verification_uat,
             definition_of_done, requirement_coverage, boundary_map_markdown
           )
-          SELECT id, title, status, depends_on, created_at, completed_at,
-                 vision, success_criteria, key_risks, proof_strategy,
-                 verification_contract, verification_integration, verification_operational, verification_uat,
-                 definition_of_done, requirement_coverage, boundary_map_markdown
-          FROM wt.milestones
+          SELECT w.id, w.title,
+                 CASE
+                   WHEN m.status IN ('complete', 'done') AND w.status NOT IN ('complete', 'done')
+                   THEN m.status ELSE w.status
+                 END,
+                 w.depends_on,
+                 CASE
+                   WHEN m.status IN ('complete', 'done') AND w.status NOT IN ('complete', 'done')
+                   THEN m.created_at ELSE w.created_at
+                 END,
+                 CASE
+                   WHEN m.status IN ('complete', 'done') AND w.status NOT IN ('complete', 'done')
+                   THEN m.completed_at ELSE w.completed_at
+                 END,
+                 w.vision, w.success_criteria, w.key_risks, w.proof_strategy,
+                 w.verification_contract, w.verification_integration, w.verification_operational, w.verification_uat,
+                 w.definition_of_done, w.requirement_coverage, w.boundary_map_markdown
+          FROM wt.milestones w
+          LEFT JOIN milestones m ON m.id = w.id
         `).run());
                 // Merge slices — preserve worktree progress but never downgrade completed status (#2558).
                 // ADR-011 Phase 1: carry is_sketch + sketch_scope so reconcile doesn't

package/dist/resources/extensions/gsd/guided-flow.js

@@ -69,7 +69,7 @@ function runPlanV2Gate(ctx, basePath, state) {
     const compiled = ensurePlanV2Graph(basePath, state);
     if (!compiled.ok) {
         const reason = compiled.reason ?? "plan-v2 compilation failed";
-        ctx.ui.notify(`Plan gate failed-closed: ${reason}. Complete plan/discuss artifacts before execution.`, "error");
+        ctx.ui.notify(`Plan gate failed-closed: ${reason}. Complete plan/discuss artifacts before execution.\n\nIf this keeps happening, try: /gsd doctor heal`, "error");
         return false;
     }
     return true;
@@ -79,6 +79,13 @@ function runPlanV2Gate(ctx, basePath, state) {
 function buildDocsCommitInstruction(_message) {
     return "Do not commit planning artifacts — .gsd/ is managed externally.";
 }
+// #4573: cap for how many times we nudge the LLM after a premature ready
+// phrase before giving up and asking the user to re-run /gsd.
+const MAX_READY_REJECTS = 2;
+// #4573: matches the canonical ready phrase the discuss prompt asks the LLM
+// to emit. Accepts any M-prefixed milestone ID (three digits + optional
+// suffix) with optional trailing punctuation.
+const READY_PHRASE_RE = /\bMilestone\s+M\d{3}[A-Z0-9-]*\s+ready\.?/i;
 const pendingAutoStartMap = new Map();
 /**
  * Backward-compat bridge: returns a mutable reference to the entry matching
@@ -221,10 +228,192 @@ export function checkAutoStartAfterDiscuss() {
         }
     }
     pendingAutoStartMap.delete(basePath);
-    ctx.ui.notify(`Milestone ${milestoneId} ready.`, "success");
+    ctx.ui.notify(`Milestone ${milestoneId} ready.`, "info");
     startAutoDetached(ctx, pi, basePath, false, { step });
     return true;
 }
+/**
+ * Extract the concatenated text content from an assistant message, whether it
+ * stores content as a string or as an array of text blocks.
+ */
+function extractAssistantText(msg) {
+    if (!msg)
+        return "";
+    const content = msg.content;
+    if (typeof content === "string")
+        return content;
+    if (!Array.isArray(content))
+        return "";
+    const parts = [];
+    for (const block of content) {
+        if (!block || typeof block !== "object")
+            continue;
+        if (block.type === "text" && typeof block.text === "string")
+            parts.push(block.text);
+    }
+    return parts.join("\n");
+}
+/**
+ * Return true if the assistant message contains any tool-use block.
+ */
+function hasToolUse(msg) {
+    if (!msg)
+        return false;
+    const content = msg.content;
+    if (!Array.isArray(content))
+        return false;
+    return content.some((b) => b && typeof b === "object" && (b.type === "tool_use" || b.type === "tool-use"));
+}
+/**
+ * #4573 — Detect and recover from the "ready phrase without files" failure mode.
+ *
+ * When the LLM emits "Milestone {{id}} ready." but has not written CONTEXT.md
+ * or ROADMAP.md, `checkAutoStartAfterDiscuss()` silently returns false and the
+ * next /gsd invocation loops into the "All milestones complete" warning.
+ *
+ * This function, called from `handleAgentEnd` after `checkAutoStartAfterDiscuss`
+ * returns false, pattern-matches the ready phrase on the last assistant message.
+ * If it fired AND neither CONTEXT.md nor ROADMAP.md exists, it:
+ *   1. Notifies the user that the signal was rejected.
+ *   2. Injects a system message via `pi.sendMessage(..., {triggerTurn:true})`
+ *      telling the LLM the signal was premature and to emit the writes now.
+ *   3. Caps at `MAX_READY_REJECTS` per-entry; beyond that, gives up and asks
+ *      the user to re-run /gsd.
+ *
+ * Returns true when a nudge (or give-up) was emitted, signaling the caller to
+ * skip `resolveAgentEnd`.
+ */
+export function maybeHandleReadyPhraseWithoutFiles(event) {
+    const entry = _getPendingAutoStart();
+    if (!entry)
+        return false;
+    const { ctx, pi, basePath, milestoneId } = entry;
+    // Gate: last assistant message must contain the ready phrase
+    const lastMsg = event.messages[event.messages.length - 1];
+    const text = extractAssistantText(lastMsg);
+    if (!READY_PHRASE_RE.test(text))
+        return false;
+    // Gate: artifacts must still be missing — if they exist, the happy path
+    // already fired and we have nothing to do.
+    const contextFile = resolveMilestoneFile(basePath, milestoneId, "CONTEXT");
+    const roadmapFile = resolveMilestoneFile(basePath, milestoneId, "ROADMAP");
+    if (contextFile || roadmapFile)
+        return false;
+    entry.readyRejectCount = (entry.readyRejectCount ?? 0) + 1;
+    if (entry.readyRejectCount > MAX_READY_REJECTS) {
+        // Give up: clear state and tell the user to re-run /gsd. Avoids an
+        // infinite nudge loop when the LLM never produces the writes.
+        pendingAutoStartMap.delete(basePath);
+        ctx.ui.notify(`Milestone ${milestoneId}: LLM signaled "ready" ${entry.readyRejectCount} times without writing files. ` +
+            `Stopping auto-nudge. Run /gsd to try again.`, "error");
+        return true;
+    }
+    ctx.ui.notify(`Milestone ${milestoneId}: "ready" signal rejected — CONTEXT.md and ROADMAP.md are missing. Asking the LLM to complete the writes.`, "warning");
+    const nudge = `You emitted "Milestone ${milestoneId} ready." but neither ` +
+        `.gsd/milestones/${milestoneId}/${milestoneId}-CONTEXT.md nor ` +
+        `.gsd/milestones/${milestoneId}/${milestoneId}-ROADMAP.md exists on disk. ` +
+        `The ready phrase is a POST-WRITE signal and has been rejected. ` +
+        `In this turn: (1) write PROJECT.md, REQUIREMENTS.md, and the milestone ` +
+        `CONTEXT.md, (2) call gsd_plan_milestone, then (3) emit the ready phrase. ` +
+        `Do not describe these steps — execute them as tool calls. ` +
+        `This is retry ${entry.readyRejectCount}/${MAX_READY_REJECTS}; further ` +
+        `premature signals will clear the session.`;
+    try {
+        pi.sendMessage({ customType: "gsd-ready-no-files", content: nudge, display: false }, { triggerTurn: true });
+    }
+    catch (e) {
+        logWarning("guided", `ready-phrase nudge sendMessage failed: ${e.message}`);
+        return false;
+    }
+    return true;
+}
+/**
+ * #4573 — Detect and recover from the "announces tool, never calls it" stall.
+ *
+ * The LLM emits text like "I'll now write the CONTEXT.md file" but the turn
+ * ends with zero tool-use blocks. The harness has no post-turn tool-call
+ * validation, so the unit promise resolves and the user sees a stalled state.
+ *
+ * This function, called from `handleAgentEnd`, inspects the last assistant
+ * message. If ALL of the following are true, it injects a recovery message:
+ *   - Text-only (no tool-use blocks)
+ *   - Contains a commit-intent phrase ("I'll write", "I'll call", etc.)
+ *   - Auto-mode is active OR a discussion autostart is pending
+ *   - `emptyTurnRetryCount` is under the cap
+ *
+ * Per-handler state is held on the `PendingAutoStartEntry` when present, and
+ * on a module-level map otherwise. The counter resets on any successful
+ * tool-use turn via `resetEmptyTurnCounter`.
+ */
+const emptyTurnCounterByBase = new Map();
+const MAX_EMPTY_TURN_RETRIES = 2;
+// Phrases that indicate the LLM is about to do something but has not yet.
+// Kept tight to avoid flagging legitimate narration like "I'll wait for your answer."
+const COMMIT_INTENT_RE = /\b(?:I['’]ll|I will|Next,? I['’]ll|Now I['’]ll|Let me|I['’]m going to|I am going to)\s+(?:now\s+)?(?:write|create|call|invoke|update|add|make|run|execute|generate|produce|emit|compose|implement|save|apply|commit)\b/i;
+/**
+ * Reset the empty-turn counter for a basePath after a successful tool-use turn.
+ * Called from handleAgentEnd when the last message contains tool_use blocks.
+ */
+export function resetEmptyTurnCounter(basePath) {
+    if (basePath)
+        emptyTurnCounterByBase.delete(basePath);
+    else
+        emptyTurnCounterByBase.clear();
+}
+export function maybeHandleEmptyIntentTurn(event, isAuto) {
+    // Gate: only fire when there is system-driven work in flight. Interactive
+    // /gsd discuss (user-driven) produces legitimate text-only turns.
+    if (!isAuto && pendingAutoStartMap.size === 0)
+        return false;
+    const lastMsg = event.messages[event.messages.length - 1];
+    if (!lastMsg)
+        return false;
+    if (hasToolUse(lastMsg))
+        return false;
+    const text = extractAssistantText(lastMsg).trim();
+    if (!text)
+        return false;
+    // Skip if the LLM is emitting the ready phrase — that is the ready-no-files
+    // path, handled by maybeHandleReadyPhraseWithoutFiles.
+    if (READY_PHRASE_RE.test(text))
+        return false;
+    // Skip if the LLM is clearly handing back to the user. Keep the heuristic
+    // tight: a trailing question mark on the last non-empty line is the common
+    // signal for "I asked the user a question and stopped."
+    const lines = text.split(/\r?\n/).map((l) => l.trim()).filter(Boolean);
+    const lastLine = lines[lines.length - 1] ?? "";
+    if (lastLine.endsWith("?"))
+        return false;
+    // Must contain a commit-intent phrase — this is the stall we care about.
+    if (!COMMIT_INTENT_RE.test(text))
+        return false;
+    // Resolve the target basePath + pi for injection. Prefer the pending
+    // autostart entry (discuss flow); otherwise we cannot inject.
+    const entry = _getPendingAutoStart();
+    if (!entry)
+        return false;
+    const { ctx, pi, basePath } = entry;
+    const count = (emptyTurnCounterByBase.get(basePath) ?? 0) + 1;
+    emptyTurnCounterByBase.set(basePath, count);
+    if (count > MAX_EMPTY_TURN_RETRIES) {
+        ctx.ui.notify(`Empty-turn recovery: LLM announced intent ${count} times without calling any tool. ` +
+            `Stopping auto-nudge.`, "error");
+        return false; // let the normal flow resolve/pause the unit
+    }
+    ctx.ui.notify(`Empty-turn detected: LLM announced intent but called no tool. Prompting it to execute.`, "info");
+    const nudge = `Your last turn announced an action (e.g. "I'll write…" or "Let me call…") ` +
+        `but contained no tool call. The system records zero tool-use blocks for ` +
+        `that turn. Execute the announced action NOW as a tool call in this turn. ` +
+        `Do not describe it again. Retry ${count}/${MAX_EMPTY_TURN_RETRIES}.`;
+    try {
+        pi.sendMessage({ customType: "gsd-empty-turn-recovery", content: nudge, display: false }, { triggerTurn: true });
+    }
+    catch (e) {
+        logWarning("guided", `empty-turn nudge sendMessage failed: ${e.message}`);
+        return false;
+    }
+    return true;
+}
 /**
  * Extract milestone IDs from PROJECT.md milestone sequence table.
  * Looks for rows like "| M001 | Name | Status |" and extracts the ID column.

package/dist/resources/extensions/gsd/health-widget.js

@@ -91,6 +91,7 @@ export function initHealthWidget(ctx) {
         let data = initialData;
         let cachedLines;
         let refreshInFlight = false;
+        let isDisposed = false;
         const refresh = async () => {
             if (refreshInFlight)
                 return;
@@ -98,7 +99,8 @@ export function initHealthWidget(ctx) {
             try {
                 data = loadHealthWidgetData(basePath);
                 cachedLines = undefined;
-                _tui.requestRender();
+                if (!isDisposed)
+                    _tui.requestRender();
             }
             catch { /* non-fatal */ }
             finally {
@@ -122,6 +124,7 @@ export function initHealthWidget(ctx) {
             },
             invalidate() { cachedLines = undefined; cachedWidth = undefined; },
             dispose() {
+                isDisposed = true;
                 clearInterval(refreshTimer);
             },
         };

package/dist/resources/extensions/gsd/key-manager.js

@@ -28,6 +28,8 @@ export const PROVIDER_REGISTRY = [
     { id: "xai", label: "xAI (Grok)", category: "llm", envVar: "XAI_API_KEY", dashboardUrl: "console.x.ai" },
     { id: "openrouter", label: "OpenRouter", category: "llm", envVar: "OPENROUTER_API_KEY", dashboardUrl: "openrouter.ai/keys" },
     { id: "mistral", label: "Mistral", category: "llm", envVar: "MISTRAL_API_KEY", dashboardUrl: "console.mistral.ai" },
+    { id: "minimax", label: "MiniMax", category: "llm", envVar: "MINIMAX_API_KEY", dashboardUrl: "platform.minimax.io" },
+    { id: "minimax-cn", label: "MiniMax CN", category: "llm", envVar: "MINIMAX_CN_API_KEY", dashboardUrl: "platform.minimax.io" },
     { id: "ollama-cloud", label: "Ollama Cloud", category: "llm", envVar: "OLLAMA_API_KEY" },
     { id: "custom-openai", label: "Custom (OpenAI-compat)", category: "llm", envVar: "CUSTOM_OPENAI_API_KEY" },
     { id: "cerebras", label: "Cerebras", category: "llm", envVar: "CEREBRAS_API_KEY" },
@@ -393,6 +395,26 @@ const TEST_ENDPOINTS = {
         url: "https://api.mistral.ai/v1/models",
         headers: (key) => ({ Authorization: `Bearer ${key}` }),
     },
+    minimax: {
+        url: "https://api.minimax.io/anthropic/v1/messages",
+        method: "POST",
+        headers: (key) => ({
+            "x-api-key": key,
+            "anthropic-version": "2023-06-01",
+            "content-type": "application/json",
+        }),
+        body: JSON.stringify({ model: "MiniMax-M2.7", max_tokens: 1, messages: [{ role: "user", content: "hi" }] }),
+    },
+    "minimax-cn": {
+        url: "https://api.minimaxi.com/anthropic/v1/messages",
+        method: "POST",
+        headers: (key) => ({
+            "x-api-key": key,
+            "anthropic-version": "2023-06-01",
+            "content-type": "application/json",
+        }),
+        body: JSON.stringify({ model: "MiniMax-M2.7", max_tokens: 1, messages: [{ role: "user", content: "hi" }] }),
+    },
     openrouter: {
         url: "https://openrouter.ai/api/v1/models",
         headers: (key) => ({ Authorization: `Bearer ${key}` }),

package/dist/resources/extensions/gsd/model-router.js

@@ -440,6 +440,20 @@ function getModelCost(modelId) {
 function bareModelId(modelId) {
     return modelId.includes("/") ? modelId.split("/").pop() : modelId;
 }
+// ─── Provider-specific Tool Limits ─────────────────────────────────────────
+/**
+ * Groq enforces a hard limit of 128 tools per request.
+ * Requests exceeding this limit receive a 400 error:
+ * "maximum number of items is 128"
+ * @see https://console.groq.com/docs/tool-use
+ */
+export const GROQ_MAX_TOOLS = 128;
+/**
+ * Provider IDs that map to the Groq API backend.
+ * Used to detect Groq at the GSD routing layer where only the provider string
+ * is available (the pi-ai openai-completions adapter is shared across providers).
+ */
+const GROQ_PROVIDER_IDS = new Set(["groq"]);
 // ─── Tool Compatibility Filter (ADR-005 Phase 3) ───────────────────────────
 /**
  * Check if a tool is compatible with a provider's capabilities.
@@ -461,8 +475,14 @@ export function isToolCompatibleWithProvider(toolName, providerCaps) {
 /**
  * Filter a list of tool names to only those compatible with a provider.
  * Used by the routing pipeline to adjust tool sets when switching providers.
+ *
+ * @param toolNames - The full list of active tool names to filter.
+ * @param providerApi - The pi-ai API string (e.g. "openai-completions").
+ * @param provider - Optional provider ID (e.g. "groq"). Used to apply
+ *   provider-specific limits that can't be expressed as API-level capabilities
+ *   (e.g. Groq's 128-tool hard limit on the shared openai-completions adapter).
  */
-export function filterToolsForProvider(toolNames, providerApi) {
+export function filterToolsForProvider(toolNames, providerApi, provider) {
     const providerCaps = getProviderCapabilities(providerApi);
     // Provider doesn't support tool calling at all
     if (!providerCaps.toolCalling) {
@@ -478,6 +498,14 @@ export function filterToolsForProvider(toolNames, providerApi) {
             filtered.push(name);
         }
     }
+    // Groq enforces a hard limit of 128 tools per request (#4376).
+    // Trim the compatible list to GROQ_MAX_TOOLS and move the excess to filtered.
+    if (provider && GROQ_PROVIDER_IDS.has(provider) && compatible.length > GROQ_MAX_TOOLS) {
+        const trimmed = compatible.splice(GROQ_MAX_TOOLS);
+        filtered.push(...trimmed);
+        console.warn(`[gsd] Groq tool limit: ${compatible.length + trimmed.length} tools active but Groq allows at most ${GROQ_MAX_TOOLS}. ` +
+            `Trimming to the first ${GROQ_MAX_TOOLS} tools. Removed: ${trimmed.join(", ")}`);
+    }
     return { compatible, filtered };
 }
 /**
@@ -486,8 +514,13 @@ export function filterToolsForProvider(toolNames, providerApi) {
  *
  * This is a hard filter only — it removes tools that would fail at the
  * provider level. It does NOT remove tools based on soft heuristics.
+ *
+ * @param activeToolNames - The full list of currently active tool names.
+ * @param selectedModelApi - The pi-ai API string for the selected model.
+ * @param provider - Optional provider ID (e.g. "groq") for provider-specific
+ *   limits beyond what the API-level capability profile expresses.
  */
-export function adjustToolSet(activeToolNames, selectedModelApi) {
-    const { compatible, filtered } = filterToolsForProvider(activeToolNames, selectedModelApi);
+export function adjustToolSet(activeToolNames, selectedModelApi, provider) {
+    const { compatible, filtered } = filterToolsForProvider(activeToolNames, selectedModelApi, provider);
     return { toolNames: compatible, removedTools: filtered };
 }