gsd-pi 2.76.0 → 2.77.0

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
@@ -225,6 +232,188 @@ export function checkAutoStartAfterDiscuss() {
     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/hook-emitter.js

@@ -0,0 +1,108 @@
+// GSD Extension — Layer 2 Event Emitter Bridge
+//
+// Holds a module-scoped reference to the ExtensionAPI so deeply-nested code
+// (auto-loop, git-service callers, verification, budget) can emit Layer 2
+// events without having to thread `pi` through every function signature.
+//
+// Set once from `registerGsdExtension`. All emitters are best-effort — a
+// missing `pi` (e.g. in standalone unit tests) silently becomes a no-op.
+let _pi;
+export function setHookEmitter(pi) {
+    _pi = pi;
+}
+export function clearHookEmitter() {
+    _pi = undefined;
+}
+// ─── Notification ──────────────────────────────────────────────────────────
+export async function emitNotification(kind, message, details) {
+    if (!_pi)
+        return;
+    await _pi.emitExtensionEvent({ type: "notification", kind, message, details });
+}
+// ─── Git Lifecycle ─────────────────────────────────────────────────────────
+export async function emitBeforeCommit(args) {
+    if (!_pi)
+        return undefined;
+    return (await _pi.emitExtensionEvent({
+        type: "before_commit",
+        ...args,
+    }));
+}
+export async function emitCommit(args) {
+    if (!_pi)
+        return;
+    await _pi.emitExtensionEvent({ type: "commit", ...args });
+}
+export async function emitBeforePush(args) {
+    if (!_pi)
+        return undefined;
+    return (await _pi.emitExtensionEvent({
+        type: "before_push",
+        ...args,
+    }));
+}
+export async function emitPush(args) {
+    if (!_pi)
+        return;
+    await _pi.emitExtensionEvent({ type: "push", ...args });
+}
+export async function emitBeforePr(args) {
+    if (!_pi)
+        return undefined;
+    return (await _pi.emitExtensionEvent({
+        type: "before_pr",
+        ...args,
+    }));
+}
+export async function emitPrOpened(args) {
+    if (!_pi)
+        return;
+    await _pi.emitExtensionEvent({ type: "pr_opened", ...args });
+}
+// ─── Verification ──────────────────────────────────────────────────────────
+export async function emitBeforeVerify(args) {
+    if (!_pi)
+        return undefined;
+    return (await _pi.emitExtensionEvent({
+        type: "before_verify",
+        ...args,
+    }));
+}
+export async function emitVerifyResult(args) {
+    if (!_pi)
+        return;
+    await _pi.emitExtensionEvent({ type: "verify_result", ...args });
+}
+// ─── Budget ────────────────────────────────────────────────────────────────
+export async function emitBudgetThreshold(args) {
+    if (!_pi)
+        return undefined;
+    return (await _pi.emitExtensionEvent({
+        type: "budget_threshold",
+        fraction: args.fraction,
+        spent: args.spent,
+        limit: args.limit,
+        currency: "USD",
+    }));
+}
+// ─── Orchestrator Boundaries ───────────────────────────────────────────────
+export async function emitMilestoneStart(args) {
+    if (!_pi)
+        return;
+    await _pi.emitExtensionEvent({ type: "milestone_start", ...args });
+}
+export async function emitMilestoneEnd(args) {
+    if (!_pi)
+        return;
+    await _pi.emitExtensionEvent({ type: "milestone_end", ...args });
+}
+export async function emitUnitStart(args) {
+    if (!_pi)
+        return;
+    await _pi.emitExtensionEvent({ type: "unit_start", ...args });
+}
+export async function emitUnitEnd(args) {
+    if (!_pi)
+        return;
+    await _pi.emitExtensionEvent({ type: "unit_end", ...args });
+}

package/dist/resources/extensions/gsd/init-wizard.js

@@ -8,7 +8,7 @@
 import { existsSync, mkdirSync, writeFileSync, readFileSync } from "node:fs";
 import { join } from "node:path";
 import { showNextAction } from "../shared/tui.js";
-import { nativeInit } from "./native-git-bridge.js";
+import { nativeInit, nativeAddAll, nativeCommit } from "./native-git-bridge.js";
 import { ensureGitignore, untrackRuntimeFiles } from "./gitignore.js";
 import { gsdRoot } from "./paths.js";
 import { assertSafeDirectory } from "./validate-directory.js";
@@ -40,6 +40,7 @@ export async function showProjectInit(ctx, pi, basePath, detection) {
         ctx.ui.notify(`Project detected:\n${detectionSummary.join("\n")}`, "info");
     }
     // ── Step 2: Git setup ──────────────────────────────────────────────────────
+    let didInitGit = false;
     if (!signals.isGitRepo) {
         const gitChoice = await showNextAction(ctx, {
             title: "GSD — Project Setup",
@@ -54,6 +55,7 @@ export async function showProjectInit(ctx, pi, basePath, detection) {
             return { completed: false, bootstrapped: false };
         if (gitChoice === "init_git") {
             nativeInit(basePath, prefs.mainBranch);
+            didInitGit = true;
         }
     }
     else {
@@ -244,6 +246,18 @@ export async function showProjectInit(ctx, pi, basePath, detection) {
     // Ensure .gitignore
     ensureGitignore(basePath);
     untrackRuntimeFiles(basePath);
+    // Create initial commit so git log and git worktree work immediately (#4530).
+    // Without this, the branch is "unborn" (zero commits) and downstream operations
+    // like `git log` and `git worktree add` fail.
+    if (didInitGit) {
+        try {
+            nativeAddAll(basePath);
+            nativeCommit(basePath, "chore: init project");
+        }
+        catch {
+            // Non-fatal — user can commit manually; don't block project init
+        }
+    }
     // Auto-generate codebase map for instant agent orientation
     try {
         const result = generateCodebaseMap(basePath);

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

@@ -12,6 +12,12 @@ import { getErrorMessage } from "./error-utils.js";
 export const PROVIDER_REGISTRY = [
     // LLM Providers
     { id: "anthropic", label: "Anthropic (Claude)", category: "llm", envVar: "ANTHROPIC_API_KEY", prefixes: ["sk-ant-"], hasOAuth: true, dashboardUrl: "console.anthropic.com" },
+    // Claude Code CLI: routes through the local `claude` binary — no API key,
+    // authentication is handled by the CLI's own OAuth flow.
+    // Referenced by doctor-providers.ts, auto-model-selection.ts, and others;
+    // must be in the canonical registry so all consumers see the same catalog.
+    // See: https://github.com/gsd-build/gsd-2/issues/4541
+    { id: "claude-code", label: "Claude Code CLI", category: "llm", hasOAuth: true },
     { id: "openai", label: "OpenAI", category: "llm", envVar: "OPENAI_API_KEY", prefixes: ["sk-"], dashboardUrl: "platform.openai.com/api-keys" },
     { id: "github-copilot", label: "GitHub Copilot", category: "llm", envVar: "GITHUB_TOKEN", hasOAuth: true },
     { id: "openai-codex", label: "ChatGPT Plus/Pro (Codex)", category: "llm", hasOAuth: true },
@@ -22,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" },
@@ -387,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/memory-backfill.js

@@ -0,0 +1,126 @@
+// GSD2 — Decisions -> memories backfill (ADR-013 step 5)
+//
+// Idempotent one-shot migration that copies every active decisions row into
+// the memories table with category="architecture" and a structured_fields
+// payload preserving the original gsd_save_decision schema (when_context,
+// scope, decision, choice, rationale, made_by, revisable, sourceDecisionId).
+//
+// The backfill exists so the cutover in ADR-013 step 6 can drop the
+// decisions table without losing schema fidelity. Idempotency is enforced
+// by tagging each backfilled memory with structured_fields.sourceDecisionId
+// and skipping any decision whose ID already appears in the memories table.
+//
+// Triggered opportunistically by buildBeforeAgentStartResult so the cost
+// only ever fires once per project. Costs O(N) inserts on first run where
+// N is the active-decisions count; subsequent runs are an O(N) lookup that
+// finds existing markers and exits.
+import { isDbAvailable, _getAdapter } from "./gsd-db.js";
+import { createMemory } from "./memory-store.js";
+import { logWarning } from "./workflow-logger.js";
+/**
+ * Backfill active decisions rows into the memories table.
+ *
+ * - Idempotent (per-row): every row written carries
+ *   `structured_fields.sourceDecisionId = "<decisionId>"`. Each candidate
+ *   decision is checked individually; only decisions whose id is already
+ *   present in the memory store are skipped. A user-authored memory with
+ *   their own `sourceDecisionId` does NOT abort the backfill.
+ * - Best-effort: never throws. Logs and returns 0 on failure so a broken
+ *   backfill cannot block agent startup.
+ * - Active-only: skips rows where `superseded_by IS NOT NULL`. Superseded
+ *   decisions are historical record; the memory store is for active
+ *   knowledge.
+ *
+ * Returns the number of memories written (0 when already backfilled or
+ * when the DB has no decisions). Callers can log the result or surface it
+ * to the user.
+ */
+export function backfillDecisionsToMemories() {
+    if (!isDbAvailable())
+        return 0;
+    const adapter = _getAdapter();
+    if (!adapter)
+        return 0;
+    try {
+        const decisions = adapter
+            .prepare("SELECT id, when_context, scope, decision, choice, rationale, made_by, revisable, superseded_by FROM decisions WHERE superseded_by IS NULL")
+            .all();
+        if (decisions.length === 0)
+            return 0;
+        // Per-row idempotency: each memory backfilled from a decision carries
+        // structured_fields.sourceDecisionId="<decisionId>". Skipping is decided
+        // per row by matching that exact id, NOT by a global sentinel — a global
+        // sentinel would silently abort the backfill if a user manually called
+        // capture_thought with their own structuredFields.sourceDecisionId.
+        const checkExisting = adapter.prepare("SELECT 1 FROM memories WHERE structured_fields LIKE :pattern LIMIT 1");
+        let written = 0;
+        for (const raw of decisions) {
+            const row = {
+                id: String(raw["id"] ?? ""),
+                when_context: String(raw["when_context"] ?? ""),
+                scope: String(raw["scope"] ?? ""),
+                decision: String(raw["decision"] ?? ""),
+                choice: String(raw["choice"] ?? ""),
+                rationale: String(raw["rationale"] ?? ""),
+                made_by: String(raw["made_by"] ?? "agent"),
+                revisable: String(raw["revisable"] ?? ""),
+                superseded_by: raw["superseded_by"] == null ? null : String(raw["superseded_by"]),
+            };
+            if (!row.id)
+                continue;
+            // Pattern is anchored to the JSON-stringified shape and the exact
+            // decision id to avoid prefix collisions (e.g. "D1" vs "D10").
+            if (checkExisting.get({ ":pattern": `%"sourceDecisionId":"${row.id}"%` }))
+                continue;
+            const content = synthesizeContent(row);
+            const id = createMemory({
+                category: "architecture",
+                content,
+                scope: row.scope || "project",
+                confidence: 0.85,
+                structuredFields: {
+                    sourceDecisionId: row.id,
+                    when_context: row.when_context,
+                    scope: row.scope,
+                    decision: row.decision,
+                    choice: row.choice,
+                    rationale: row.rationale,
+                    made_by: row.made_by,
+                    revisable: row.revisable,
+                },
+            });
+            if (id)
+                written += 1;
+        }
+        return written;
+    }
+    catch (e) {
+        logWarning("memory-backfill", `decisions->memories backfill failed: ${e.message}`);
+        return 0;
+    }
+}
+/**
+ * Combine the decision's structured fields into a 1-3 sentence content
+ * string suitable for keyword retrieval and human review.
+ *
+ * Format: "<decision> Chose: <choice>. Rationale: <rationale>."
+ * Truncates each field to keep the synthesized line under ~600 chars so
+ * memory_query rendering stays readable.
+ */
+function synthesizeContent(row) {
+    const trim = (value, max) => {
+        const cleaned = value.replace(/\s+/g, " ").trim();
+        return cleaned.length > max ? cleaned.slice(0, max - 1) + "\u2026" : cleaned;
+    };
+    const parts = [];
+    const decision = trim(row.decision, 240);
+    const choice = trim(row.choice, 200);
+    const rationale = trim(row.rationale, 200);
+    if (decision)
+        parts.push(decision);
+    if (choice)
+        parts.push(`Chose: ${choice}.`);
+    if (rationale)
+        parts.push(`Rationale: ${rationale}.`);
+    return parts.join(" ");
+}

package/dist/resources/extensions/gsd/memory-store.js

@@ -29,8 +29,22 @@ function rowToMemory(row) {
         hit_count: row['hit_count'],
         scope: row['scope'] ?? 'project',
         tags: parseTags(row['tags']),
+        structured_fields: parseStructuredFields(row['structured_fields']),
     };
 }
+function parseStructuredFields(raw) {
+    if (typeof raw !== 'string' || raw.length === 0)
+        return null;
+    try {
+        const parsed = JSON.parse(raw);
+        return parsed && typeof parsed === 'object' && !Array.isArray(parsed)
+            ? parsed
+            : null;
+    }
+    catch {
+        return null;
+    }
+}
 function parseTags(raw) {
     if (typeof raw !== 'string' || raw.length === 0)
         return [];
@@ -376,6 +390,7 @@ export function createMemory(fields) {
             updatedAt: now,
             scope: fields.scope ?? 'project',
             tags: fields.tags ?? [],
+            structuredFields: fields.structuredFields ?? null,
         });
         // Derive the real ID from the assigned seq (SELECT is still fine via adapter)
         const row = adapter.prepare('SELECT seq FROM memories WHERE id = :id').get({ ':id': placeholder });
@@ -553,6 +568,10 @@ export function applyMemoryActions(actions, unitType, unitId) {
                             source_unit_id: unitId,
                             scope: action.scope,
                             tags: action.tags,
+                            // ADR-013: forward structured payload through the action layer so
+                            // bulk applyMemoryActions callers (extraction, ingestion) don't
+                            // silently drop it.
+                            structuredFields: action.structuredFields ?? null,
                         });
                         break;
                     case 'UPDATE':

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 };
 }