gsd-pi 2.76.0 → 2.77.0-dev.538325aea

package/dist/resources/extensions/claude-code-cli/partial-builder.js

@@ -4,7 +4,103 @@
  * Translates the Claude Agent SDK's `BetaRawMessageStreamEvent` sequence
  * into GSD's `AssistantMessageEvent` deltas for incremental TUI rendering.
  */
-import { hasXmlParameterTags, repairToolJson } from "@gsd/pi-ai";
+// ---------------------------------------------------------------------------
+// XML parameter tag utilities (inline replacements for removed pi-ai symbols)
+// ---------------------------------------------------------------------------
+/**
+ * Detects XML parameter tags (inline <parameter name="...">...</parameter> form)
+ * or XML wrapper (<parameters>...</parameters>) in streaming tool call JSON.
+ * Replaces removed pi-ai utility (removed in pi 0.67.2).
+ * T-10-05: regex only detects tag presence; does not evaluate content.
+ */
+function hasXmlParameterTags(s) {
+    return /<parameter[s\s>]/i.test(s);
+}
+/**
+ * Repairs malformed LLM-generated tool JSON using three strategies:
+ *
+ * 1. XML parameter extraction: When inline <parameter name="key">value</parameter>
+ *    tags appear inside a JSON string value, extract each as a top-level key and
+ *    clean the containing string value by truncating at the closing tag boundary.
+ *
+ * 2. YAML bullet repair: When bare "- item" patterns appear as JSON values (not
+ *    quoted), convert each bullet sequence into a JSON array.
+ *
+ * 3. XML wrapper extraction: Extract content from <parameters>...</parameters> wrapper.
+ *
+ * Replaces removed pi-ai utility (removed in pi 0.67.2).
+ * T-10-05: extracts text content only, no evaluation.
+ */
+function repairToolJson(s) {
+    // Strategy 1: XML parameter tags inside JSON string values (#3751)
+    // The raw JSON string may have escaped quotes: <parameter name=\"key\">val</parameter>
+    // or unescaped: <parameter name="key">val</parameter>
+    // We match both forms.
+    if (/<parameter\s+name=/i.test(s)) {
+        try {
+            // Match <parameter name="key"> or <parameter name=\"key\"> in raw JSON text
+            const paramPattern = /<parameter\s+name=(?:\\"|")([^"\\]+)(?:\\"|")>([\s\S]*?)<\/parameter>/gi;
+            const extracted = {};
+            let match;
+            while ((match = paramPattern.exec(s)) !== null) {
+                const key = match[1];
+                // rawVal may contain JSON-escaped characters; unescape for parsing
+                const rawVal = match[2].trim().replace(/\\"/g, '"').replace(/\\n/g, "\n");
+                // Attempt to parse value as JSON; fall back to string
+                try {
+                    extracted[key] = JSON.parse(rawVal);
+                }
+                catch {
+                    extracted[key] = rawVal;
+                }
+            }
+            if (Object.keys(extracted).length > 0) {
+                // Remove the XML parameter block and preceding closing tag from the raw string.
+                // The block looks like: </tagName>\n<parameter ...>...</parameter>...\n (with escaped chars)
+                // We remove from the first </...> closing tag through the last </parameter> tag.
+                const cleaned = s
+                    .replace(/<\/[^>]+>(?:\\n|\n)*(?:<parameter[\s\S]*?<\/parameter>(?:\\n|\n)*)+/gi, "")
+                    .trim();
+                // Parse cleaned base JSON and merge extracted params
+                const base = JSON.parse(cleaned);
+                return JSON.stringify({ ...base, ...extracted });
+            }
+        }
+        catch {
+            // Fall through to next strategy
+        }
+    }
+    // Strategy 2: YAML bullet lists as unquoted JSON values (#2660)
+    // Pattern: "key": - item1, "key2": - item2
+    if (/:\s*-\s+/.test(s)) {
+        try {
+            // Replace bare YAML bullet sequences with JSON arrays.
+            // Match: "key": - val1, - val2, "nextKey" or end
+            // We need to handle: "key": - item, "nextKey" where - item is the unquoted value
+            const repaired = s.replace(
+            // Match a quoted key followed by colon, then one or more "- item" bullets
+            // terminated by either a comma+quote (next key) or closing brace
+            /"([^"]+)":\s*((?:-\s+[^,\n\-"{}[\]]+(?:,\s*(?![-"\s*{]))?)+)/g, (fullMatch, key, bulletBlock) => {
+                // Extract individual bullet items
+                const items = bulletBlock
+                    .split(/,?\s*-\s+/)
+                    .map((item) => item.trim().replace(/,\s*$/, "").trim())
+                    .filter((item) => item.length > 0);
+                if (items.length === 0)
+                    return fullMatch;
+                return `"${key}": ${JSON.stringify(items)}`;
+            });
+            const parsed = JSON.parse(repaired);
+            return JSON.stringify(parsed);
+        }
+        catch {
+            // Fall through to next strategy
+        }
+    }
+    // Strategy 3: XML wrapper extraction (<parameters>...</parameters>)
+    const m = /<parameters[^>]*>([\s\S]*?)<\/parameters>/i.exec(s);
+    return m ? m[1].trim() : s;
+}
 // ---------------------------------------------------------------------------
 // MCP tool name parsing
 // ---------------------------------------------------------------------------
@@ -62,17 +158,16 @@ export function mapContentBlock(block) {
         case "tool_use":
             return toolCallFromBlock(block.id, block.name, block.input);
         case "server_tool_use":
+            // ServerToolUseContent removed from pi-ai in pi 0.67.2 — represent as text
             return {
-                type: "serverToolUse",
-                id: block.id,
-                name: block.name,
-                input: block.input,
+                type: "text",
+                text: `[server tool use: ${block.name ?? "unknown"}]`,
             };
         case "web_search_tool_result":
+            // WebSearchResultContent removed from pi-ai in pi 0.67.2 — represent as text
             return {
-                type: "webSearchResult",
-                toolUseId: block.tool_use_id,
-                content: block.content,
+                type: "text",
+                text: `[web search result]`,
             };
         default: {
             const unknown = block;
@@ -185,15 +280,7 @@ export class PartialMessageBuilder {
                     this.partial.content.push(toolCallFromBlock(block.id, block.name, {}));
                     return { type: "toolcall_start", contentIndex, partial: this.partial };
                 }
-                if (block.type === "server_tool_use") {
-                    this.partial.content.push({
-                        type: "serverToolUse",
-                        id: block.id,
-                        name: block.name,
-                        input: block.input,
-                    });
-                    return { type: "server_tool_use", contentIndex, partial: this.partial };
-                }
+                // server_tool_use removed from pi-ai content types in pi 0.67.2 — skip
                 return null;
             }
             // ---- Block delta ----
@@ -251,6 +338,8 @@ export class PartialMessageBuilder {
                             // malformation explicitly so downstream consumers can
                             // distinguish this from a healthy tool completion (#2574).
                             block.arguments = { _raw: jsonStr };
+                            // malformedArguments removed from the toolcall_end type in pi 0.67.2;
+                            // cast to any to preserve the runtime signal for downstream consumers (#2574)
                             return { type: "toolcall_end", contentIndex, toolCall: block, partial: this.partial, malformedArguments: true };
                         }
                     }

package/dist/resources/extensions/claude-code-cli/readiness.js

@@ -10,15 +10,38 @@
  */
 import { execFileSync } from "node:child_process";
 /**
- * Platform-correct binary name for the Claude Code CLI.
+ * Candidate executable names for the Claude Code CLI.
  *
- * On Windows, npm-global binaries are installed as `.cmd` shims and
- * `execFileSync` does not auto-resolve the extension — calling bare
- * `claude` would fail with ENOENT even when the CLI is installed and
- * authenticated. Mirrors the `NPM_COMMAND` pattern in
- * `src/resources/extensions/gsd/pre-execution-checks.ts`.
+ * Keep the explicit win32 ternary selector for regression coverage (Issue #4424):
+ * Node's execFileSync must target `claude.cmd` directly on Windows.
  */
 const CLAUDE_COMMAND = process.platform === "win32" ? "claude.cmd" : "claude";
+/**
+ * Windows installs vary: some environments expose `claude.cmd` (npm shim),
+ * `claude.exe` (direct binary install), or a bare `claude` shim on PATH
+ * (for example Git Bash wrappers). Try all three to avoid false "not
+ * installed" results in readiness checks.
+ */
+const CLAUDE_COMMAND_CANDIDATES = process.platform === "win32" ? [CLAUDE_COMMAND, "claude.exe", "claude"] : [CLAUDE_COMMAND];
+function execClaude(args) {
+    let lastError;
+    for (const command of CLAUDE_COMMAND_CANDIDATES) {
+        try {
+            return execFileSync(command, args, { timeout: 5_000, stdio: "pipe" });
+        }
+        catch (error) {
+            lastError = error;
+            const code = error?.code;
+            // Windows Git Bash can surface `.cmd` spawn failures as EINVAL instead
+            // of ENOENT. Treat both as "try next candidate".
+            if (code === "ENOENT" || code === "EINVAL") {
+                continue;
+            }
+            throw error;
+        }
+    }
+    throw lastError ?? new Error(`Claude CLI executable not found (tried: ${CLAUDE_COMMAND_CANDIDATES.join(", ")})`);
+}
 let cachedBinaryPresent = null;
 let cachedAuthed = null;
 let lastCheckMs = 0;
@@ -32,7 +55,7 @@ function refreshCache() {
     lastCheckMs = now;
     // Check binary presence
     try {
-        execFileSync(CLAUDE_COMMAND, ["--version"], { timeout: 5_000, stdio: "pipe" });
+        execClaude(["--version"]);
         cachedBinaryPresent = true;
     }
     catch {
@@ -42,7 +65,7 @@ function refreshCache() {
     }
     // Check auth status — exit code 0 with non-error output means authenticated
     try {
-        const output = execFileSync(CLAUDE_COMMAND, ["auth", "status"], { timeout: 5_000, stdio: "pipe" })
+        const output = execClaude(["auth", "status"])
             .toString()
             .toLowerCase();
         // The CLI outputs "not logged in", "no credentials", or similar when unauthenticated

package/dist/resources/extensions/claude-code-cli/stream-adapter.js

@@ -365,8 +365,9 @@ async function promptElicitationWithDialogs(request, questions, ui, signal) {
     for (const question of questions) {
         const title = buildElicitationPromptTitle(request, question);
         if (question.allowMultiple) {
+            // allowMultiple removed from ExtensionUIDialogOptions in pi 0.67.2;
+            // fall back to single-select (result is wrapped in array below)
             const selected = await ui.select(title, question.options.map((option) => option.label), {
-                allowMultiple: true,
                 signal,
             });
             if (Array.isArray(selected)) {
@@ -484,25 +485,33 @@ export function makeAbortedMessage(model, lastTextContent) {
 /**
  * Resolve the Claude Code permission mode for the current run.
  *
- * GSD subagents run underneath a host Claude Code session the user has
- * already consented to, and their work (edits, shell inspection, MCP calls)
- * spans the full workflow toolset. Defaulting the inner SDK to
- * `bypassPermissions` avoids per-tool approval prompts that offer no
- * meaningful safety beyond what the host session and the subagent prompts
- * already enforce. `GSD_CLAUDE_CODE_PERMISSION_MODE` lets security-conscious
- * users opt into a stricter mode (`acceptEdits`, `default`, `plan`).
+ * Defaults to `acceptEdits`, which auto-approves file reads/edits but
+ * surfaces a permission dialog for dangerous operations (e.g. general Bash,
+ * Agent, WebFetch). This prevents tools outside the allowlist from being
+ * silently denied — the SDK emits an `extension_ui_request` event so the
+ * user sees a prompt instead of a silent refusal that Claude Code mistakes
+ * for user rejection (#4383).
+ *
+ * Set `GSD_CLAUDE_CODE_PERMISSION_MODE` to `bypassPermissions` to restore
+ * the old always-approve behaviour, or to `default` / `plan` for stricter
+ * modes.
  *
- * Tradeoff: bypass means a prompt-injection payload read from an untrusted
- * file could trigger tool calls without a second gate. Accepted for GSD
- * because the workflow is explicit user intent and the alternative
- * (#4099) is continuous approval fatigue that blocks real work.
+ * When `GSD_HEADLESS=1` is set (auto-mode / non-interactive runs), the
+ * default flips to `bypassPermissions` because there is no UI to approve
+ * permission dialogs — `acceptEdits` would hang verification commands like
+ * `npx tsc --noEmit` or `npx vitest run` indefinitely (#4657). Explicit
+ * overrides still win, so users can opt back into `acceptEdits` in headless.
  */
 export async function resolveClaudePermissionMode(env = process.env) {
     const override = env.GSD_CLAUDE_CODE_PERMISSION_MODE?.trim();
     if (override === "bypassPermissions" || override === "acceptEdits" || override === "default" || override === "plan") {
         return override;
     }
-    return "bypassPermissions";
+    if (env.GSD_HEADLESS === "1") {
+        console.warn("[claude-code-cli] Headless mode detected (GSD_HEADLESS=1): defaulting permissionMode to 'bypassPermissions' so verification Bash commands can run. Set GSD_CLAUDE_CODE_PERMISSION_MODE=acceptEdits to opt out.");
+        return "bypassPermissions";
+    }
+    return "acceptEdits";
 }
 // NOTE: These helpers intentionally mirror @gsd/pi-ai anthropic-shared
 // behavior so this extension remains typecheck-stable even when the published
@@ -554,7 +563,7 @@ function mapThinkingLevelToAnthropicEffort(level, modelId) {
 export function buildSdkOptions(modelId, prompt, overrides, extraOptions = {}) {
     const { reasoning, ...sdkExtraOptions } = extraOptions;
     const mcpServers = buildWorkflowMcpServers();
-    const permissionMode = overrides?.permissionMode ?? "bypassPermissions";
+    const permissionMode = overrides?.permissionMode ?? "acceptEdits";
     const disallowedTools = ["AskUserQuestion"];
     // Pre-authorize the safe built-ins and every registered workflow MCP
     // server's tools. `acceptEdits` mode (the interactive default) only
@@ -637,6 +646,68 @@ function normalizeToolResultContent(content) {
     }
     return blocks.length > 0 ? blocks : [{ type: "text", text: "" }];
 }
+/**
+ * Extract a `details` payload from an MCP tool-result block.
+ *
+ * MCP's `CallToolResult` carries structured data in `structuredContent` — the
+ * protocol's supported channel for non-text payloads. Claude Code's synthetic
+ * user message may surface that field in one of two shapes depending on SDK
+ * version: as a sibling on the `mcp_tool_result` block itself, or as a
+ * dedicated content sub-block with `type: "structuredContent"`. Snake-case
+ * (`structured_content`) is accepted defensively in case a transport hop
+ * rewrites casing. All other shapes fall back to an empty object so callers
+ * can rely on `details` being present.
+ */
+function extractStructuredDetailsFromBlock(block) {
+    const sibling = block.structuredContent ?? block.structured_content;
+    if (sibling && typeof sibling === "object" && !Array.isArray(sibling)) {
+        return sibling;
+    }
+    if (Array.isArray(block.content)) {
+        for (const item of block.content) {
+            if (!item || typeof item !== "object")
+                continue;
+            const sub = item;
+            if (sub.type !== "structuredContent" && sub.type !== "structured_content")
+                continue;
+            const payload = sub.structuredContent ?? sub.structured_content ?? sub.data ?? sub.value;
+            if (payload && typeof payload === "object" && !Array.isArray(payload)) {
+                return payload;
+            }
+        }
+    }
+    // Return undefined (not {}) when no structured payload is present, matching
+    // the pre-#4477 contract where `details` was nullable. An empty-object
+    // sentinel is truthy and breaks downstream consumers that gate on
+    // `if (details)`. `undefined` matches the type of the field these results
+    // flow into (`Record<string, unknown> | undefined`).
+    return undefined;
+}
+/**
+ * True for items that are MCP `structuredContent` pseudo-blocks living inside
+ * a tool-result `content[]` array. These blocks carry the structured payload
+ * (extracted separately by `extractStructuredDetailsFromBlock`) and must NOT
+ * leak into the visible content rendered to the user — otherwise the renderer
+ * stringifies the JSON pseudo-block and shows it next to the actual tool
+ * output. See PR #4477 review (CodeRabbit, post-fix-round).
+ */
+function isStructuredContentPseudoBlock(item) {
+    if (!item || typeof item !== "object")
+        return false;
+    const type = item.type;
+    return type === "structuredContent" || type === "structured_content";
+}
+/**
+ * Strip `structuredContent` pseudo-blocks from a tool-result content array
+ * before normalization. The structured payload is extracted via the sibling
+ * `structuredContent` field (or a dedicated extractor pass on the raw block);
+ * the visible content path must not include the pseudo-block itself.
+ */
+function stripStructuredContentPseudoBlocks(content) {
+    if (!Array.isArray(content))
+        return content;
+    return content.filter((item) => !isStructuredContentPseudoBlock(item));
+}
 /** Extract tool result payloads from an SDK synthetic user message, keyed by tool-use ID. */
 export function extractToolResultsFromSdkUserMessage(message) {
     const extracted = [];
@@ -657,8 +728,8 @@ export function extractToolResultsFromSdkUserMessage(message) {
         extracted.push({
             toolUseId,
             result: {
-                content: normalizeToolResultContent(block.content),
-                details: {},
+                content: normalizeToolResultContent(stripStructuredContentPseudoBlocks(block.content)),
+                details: extractStructuredDetailsFromBlock(block),
                 isError: block.is_error === true,
             },
         });
@@ -672,8 +743,8 @@ export function extractToolResultsFromSdkUserMessage(message) {
                 extracted.push({
                     toolUseId,
                     result: {
-                        content: normalizeToolResultContent(toolResult.content),
-                        details: {},
+                        content: normalizeToolResultContent(stripStructuredContentPseudoBlocks(toolResult.content)),
+                        details: extractStructuredDetailsFromBlock(toolResult),
                         isError: toolResult.is_error === true,
                     },
                 });
@@ -685,7 +756,8 @@ export function extractToolResultsFromSdkUserMessage(message) {
 /** Attach external tool results from the SDK synthetic user message to their corresponding tool-call blocks by ID. */
 function attachExternalResultsToToolBlocks(toolBlocks, toolResultsById) {
     for (const block of toolBlocks) {
-        if (block.type !== "toolCall" && block.type !== "serverToolUse")
+        // serverToolUse removed from AssistantMessage content in pi 0.67.2
+        if (block.type !== "toolCall")
             continue;
         const externalResult = toolResultsById.get(block.id);
         if (!externalResult)
@@ -838,8 +910,9 @@ async function pumpSdkMessages(model, context, options, stream) {
                             else if (block.type === "thinking" && block.thinking) {
                                 lastThinkingContent = block.thinking;
                             }
-                            else if (block.type === "toolCall" || block.type === "serverToolUse") {
+                            else if (block.type === "toolCall") {
                                 // Collect tool blocks for externalToolExecution rendering
+                                // (serverToolUse removed from pi-ai content types in pi 0.67.2)
                                 intermediateToolBlocks.push(block);
                             }
                         }
@@ -871,13 +944,7 @@ async function pumpSdkMessages(model, context, options, stream) {
                                     partial: builder.message,
                                 });
                             }
-                            else if (block.type === "serverToolUse") {
-                                stream.push({
-                                    type: "server_tool_use",
-                                    contentIndex,
-                                    partial: builder.message,
-                                });
-                            }
+                            // serverToolUse/server_tool_use removed from pi-ai in pi 0.67.2
                         }
                     }
                     builder = null;

package/dist/resources/extensions/gsd/auto/loop.js

@@ -30,6 +30,13 @@ function stuckStatePath(basePath) {
 function loadStuckState(basePath) {
     try {
         const data = JSON.parse(readFileSync(stuckStatePath(basePath), "utf-8"));
+        // Only load state written by a DIFFERENT process (real session restart).
+        // If the PID matches the current process, this state was written by an earlier
+        // autoLoop call in the same process (e.g., a test that completed before this
+        // one), not by a crashed session — skip it to prevent test state pollution.
+        if (data.pid === process.pid) {
+            return { recentUnits: [], stuckRecoveryAttempts: 0 };
+        }
         return {
             recentUnits: Array.isArray(data.recentUnits) ? data.recentUnits : [],
             stuckRecoveryAttempts: typeof data.stuckRecoveryAttempts === "number" ? data.stuckRecoveryAttempts : 0,
@@ -45,6 +52,7 @@ function saveStuckState(basePath, state) {
         const filePath = stuckStatePath(basePath);
         mkdirSync(join(gsdRoot(basePath), "runtime"), { recursive: true });
         writeFileSync(filePath, JSON.stringify({
+            pid: process.pid,
             recentUnits: state.recentUnits.slice(-20), // keep last 20 entries
             stuckRecoveryAttempts: state.stuckRecoveryAttempts,
             updatedAt: new Date().toISOString(),
@@ -497,6 +505,7 @@ export async function autoLoop(ctx, pi, s, deps, options) {
             consecutiveCooldowns = 0;
             recentErrorMessages.length = 0;
             deps.emitJournalEvent({ ts: new Date().toISOString(), flowId, seq: nextSeq(), eventType: "iteration-end", data: { iteration } });
+            saveStuckState(s.basePath, loopState); // persist across session restarts (#4382)
             debugLog("autoLoop", { phase: "iteration-complete", iteration });
             finishTurn("completed");
         }