gsd-pi 2.76.0 → 2.77.0-dev.1d17f366c

package/dist/resources/extensions/gsd/uok/writer.js

@@ -0,0 +1,82 @@
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { randomUUID } from "node:crypto";
+import { atomicWriteSync } from "../atomic-write.js";
+import { gsdRoot } from "../paths.js";
+const activeTokens = new Map();
+function tokenKey(basePath, turnId) {
+    return `${basePath}:${turnId}`;
+}
+function sequencePath(basePath) {
+    return join(gsdRoot(basePath), "runtime", "uok-writer-sequence.json");
+}
+function readSequenceState(basePath) {
+    const path = sequencePath(basePath);
+    if (!existsSync(path)) {
+        return { lastSequence: 0, updatedAt: new Date(0).toISOString() };
+    }
+    try {
+        const parsed = JSON.parse(readFileSync(path, "utf-8"));
+        return {
+            lastSequence: Number.isInteger(parsed.lastSequence) ? Number(parsed.lastSequence) : 0,
+            updatedAt: typeof parsed.updatedAt === "string" ? parsed.updatedAt : new Date(0).toISOString(),
+        };
+    }
+    catch {
+        return { lastSequence: 0, updatedAt: new Date(0).toISOString() };
+    }
+}
+function writeSequenceState(basePath, state) {
+    atomicWriteSync(sequencePath(basePath), JSON.stringify(state, null, 2) + "\n", "utf-8");
+}
+export function acquireWriterToken(args) {
+    const key = tokenKey(args.basePath, args.turnId);
+    const existing = activeTokens.get(key);
+    if (existing) {
+        throw new Error(`Writer token already active for turn ${args.turnId}`);
+    }
+    const token = {
+        tokenId: randomUUID(),
+        traceId: args.traceId,
+        turnId: args.turnId,
+        acquiredAt: new Date().toISOString(),
+        owner: args.owner ?? "uok",
+    };
+    activeTokens.set(key, token);
+    return token;
+}
+export function releaseWriterToken(basePath, token) {
+    const key = tokenKey(basePath, token.turnId);
+    const current = activeTokens.get(key);
+    if (current?.tokenId === token.tokenId) {
+        activeTokens.delete(key);
+    }
+}
+export function hasActiveWriterToken(basePath, turnId) {
+    return activeTokens.has(tokenKey(basePath, turnId));
+}
+export function nextWriteRecord(args) {
+    if (!hasActiveWriterToken(args.basePath, args.token.turnId)) {
+        throw new Error(`Writer token is not active for turn ${args.token.turnId}`);
+    }
+    const state = readSequenceState(args.basePath);
+    const sequence = state.lastSequence + 1;
+    const updatedAt = new Date().toISOString();
+    writeSequenceState(args.basePath, { lastSequence: sequence, updatedAt });
+    return {
+        writerToken: args.token,
+        sequence: {
+            traceId: args.token.traceId,
+            turnId: args.token.turnId,
+            sequence,
+        },
+        category: args.category,
+        operation: args.operation,
+        path: args.path,
+        ts: updatedAt,
+        metadata: args.metadata,
+    };
+}
+export function resetWriterTokensForTests() {
+    activeTokens.clear();
+}

package/dist/resources/extensions/gsd/workflow-logger.js

@@ -15,8 +15,9 @@
 // a process. The auto-loop must call _resetLogs() (or drainAndSummarize()) at
 // the start of each unit to prevent log bleed between units running in the same
 // Node process.
-import { appendFileSync, readFileSync, existsSync, mkdirSync } from "node:fs";
+import { appendFileSync, closeSync, existsSync, mkdirSync, openSync, readFileSync, } from "node:fs";
 import { join } from "node:path";
+import { withFileLockSync } from "./file-lock.js";
 import { appendNotification } from "./notification-store.js";
 import { buildAuditEnvelope, emitUokAuditEvent } from "./uok/audit.js";
 import { isUnifiedAuditEnabled } from "./uok/audit-toggle.js";
@@ -231,8 +232,15 @@ function _push(severity, component, message, context) {
         try {
             const auditDir = join(_auditBasePath, ".gsd");
             mkdirSync(auditDir, { recursive: true });
+            const auditPath = join(auditDir, "audit-log.jsonl");
             const sanitized = _sanitizeForAudit(entry);
-            appendFileSync(join(auditDir, "audit-log.jsonl"), JSON.stringify(sanitized) + "\n", "utf-8");
+            // Ensure file exists so proper-lockfile can acquire a lock against it.
+            if (!existsSync(auditPath))
+                closeSync(openSync(auditPath, "a"));
+            // onLocked: "skip" — never block error logging on lock contention.
+            withFileLockSync(auditPath, () => {
+                appendFileSync(auditPath, JSON.stringify(sanitized) + "\n", "utf-8");
+            }, { onLocked: "skip" });
         }
         catch (auditErr) {
             // Best-effort — never let audit write failures bubble up

package/dist/resources/extensions/gsd/workflow-mcp.js

@@ -5,6 +5,9 @@ import { fileURLToPath, pathToFileURL } from "node:url";
 const MCP_WORKFLOW_TOOL_SURFACE = new Set([
     "ask_user_questions",
     "gsd_decision_save",
+    "gsd_exec",
+    "gsd_exec_search",
+    "gsd_resume",
     "gsd_complete_milestone",
     "gsd_complete_task",
     "gsd_complete_slice",

package/dist/resources/extensions/gsd/workflow-templates/spike.md

@@ -66,5 +66,11 @@ Use for: technology evaluation, architecture decisions, "should we X?" questions
    - Recommendation with rationale
    - Next steps if the recommendation is accepted
 4. **Present** the recommendation to the user for discussion
+5. **Offer wrap-up:** If the findings are reusable on future work, offer to run
+   the `spike-wrap-up` skill to package them as a project-local skill at
+   `.claude/skills/<name>/SKILL.md`. That skill will auto-load on future
+   similar tasks via `skill-discovery.ts`. If the recommendation is
+   decision-only (no reusable guidance), suggest appending a one-liner to
+   `.gsd/DECISIONS.md` instead.
 
 </process>

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

@@ -479,6 +479,7 @@ const SKIP_PATHS = [
     ".gsd/worktrees/",
     ".gsd/runtime/",
     ".gsd/activity/",
+    ".gsd/audit/",
     ".gsd/forensics/",
     ".gsd/parallel/",
     ".gsd/journal/",

package/dist/resources/extensions/gsd/worktree-resolver.js

@@ -16,8 +16,30 @@ import { existsSync, unlinkSync } from "node:fs";
 import { randomUUID } from "node:crypto";
 import { join } from "node:path";
 import { debugLog } from "./debug-logger.js";
-import { MergeConflictError } from "./git-service.js";
 import { emitJournalEvent } from "./journal.js";
+// ─── Path Helpers ──────────────────────────────────────────────────────────
+/**
+ * Worktree marker segment — present in any path produced by worktreePath().
+ * Used to strip the worktree suffix and recover the project root (#3729).
+ */
+const WORKTREE_MARKER = "/.gsd/worktrees/";
+/**
+ * Resolve the project root from session path state.
+ *
+ * Prefers `originalBasePath` (always the project root when set), but falls
+ * back to `basePath` when `originalBasePath` is falsy (e.g. fresh AutoSession
+ * with default empty string). If `basePath` itself is inside a worktree
+ * directory (contains `/.gsd/worktrees/`), strip that suffix to recover the
+ * actual project root — preventing double-nested worktree paths (#3729).
+ */
+export function resolveProjectRoot(originalBasePath, basePath) {
+    let resolved = originalBasePath || basePath;
+    const markerIdx = resolved.indexOf(WORKTREE_MARKER);
+    if (markerIdx !== -1) {
+        resolved = resolved.slice(0, markerIdx);
+    }
+    return resolved;
+}
 // ─── WorktreeResolver ──────────────────────────────────────────────────────
 export class WorktreeResolver {
     s;
@@ -33,11 +55,11 @@ export class WorktreeResolver {
     }
     /** Original project root — always the non-worktree path. */
     get projectRoot() {
-        return this.s.originalBasePath || this.s.basePath;
+        return resolveProjectRoot(this.s.originalBasePath, this.s.basePath);
     }
     /** Path for auto.lock file — same as the old lockBase(). */
     get lockPath() {
-        return this.s.originalBasePath || this.s.basePath;
+        return resolveProjectRoot(this.s.originalBasePath, this.s.basePath);
     }
     // ── Private Helpers ────────────────────────────────────────────────────
     rebuildGitService() {
@@ -99,7 +121,10 @@ export class WorktreeResolver {
             });
             return;
         }
-        const basePath = this.s.originalBasePath || this.s.basePath;
+        // Resolve the project root for worktree operations via shared helper.
+        // Handles the case where originalBasePath is falsy and basePath is itself
+        // a worktree path — prevents double-nested worktree paths (#3729).
+        const basePath = resolveProjectRoot(this.s.originalBasePath, this.s.basePath);
         debugLog("WorktreeResolver", {
             action: "enterMilestone",
             milestoneId,
@@ -429,11 +454,13 @@ export class WorktreeResolver {
                     /* best-effort */
                 }
             }
-            // Re-throw MergeConflictError so the auto loop can detect real code
-            // conflicts and stop instead of retrying forever (#2330).
-            if (err instanceof MergeConflictError) {
-                throw err;
-            }
+            // Restore state before re-throwing so callers always get a consistent
+            // session (#4380).
+            this.restoreToProjectRoot();
+            // Re-throw: MergeConflictError stops the auto loop (#2330); non-conflict
+            // errors (permission denied, filesystem failures) must also propagate so
+            // broken states are diagnosable (#4380).
+            throw err;
         }
         // Always restore basePath and rebuild — whether merge succeeded or failed
         this.restoreToProjectRoot();
@@ -500,6 +527,8 @@ export class WorktreeResolver {
                 error: msg,
             });
             ctx.notify(`Milestone merge failed (branch mode): ${msg}`, "warning");
+            // Re-throw all errors so callers can apply their own recovery logic (#4380).
+            throw err;
         }
     }
     // ── Merge and Enter Next ───────────────────────────────────────────────
@@ -516,7 +545,18 @@ export class WorktreeResolver {
             currentMilestoneId,
             nextMilestoneId,
         });
-        this.mergeAndExit(currentMilestoneId, ctx);
+        try {
+            this.mergeAndExit(currentMilestoneId, ctx);
+        }
+        catch (err) {
+            // mergeAndExit emits a warning and restores state when it fails during
+            // merge/cleanup. But if it throws before recovery runs (e.g., in
+            // validateMilestoneId or emitJournalEvent), basePath won't be restored
+            // to projectRoot — re-throw so we don't enter the next milestone with
+            // the current one unmerged.
+            if (this.s.basePath !== this.projectRoot)
+                throw err;
+        }
         this.enterMilestone(nextMilestoneId, ctx);
     }
 }

package/dist/resources/extensions/mcp-client/auth.js

@@ -10,7 +10,16 @@
 // ─── Env resolution ───────────────────────────────────────────────────────────
 /** Resolve `${VAR}` references in a string against `process.env`. */
 function resolveEnvValue(value) {
-    return value.replace(/\$\{([^}]+)\}/g, (_match, varName) => process.env[varName] ?? "");
+    return value.replace(/\$\{([^}]+)\}/g, (_match, varName) => {
+        const resolved = process.env[varName];
+        if (resolved === undefined || resolved === "") {
+            // eslint-disable-next-line no-console
+            console.warn(`[mcp-client auth] Environment variable "${varName}" referenced in MCP server config is unset. ` +
+                `Requests will go out with a malformed header and the remote server will likely reject them with 401.`);
+            return "";
+        }
+        return resolved;
+    });
 }
 function resolveHeaders(raw) {
     const resolved = {};

package/dist/resources/extensions/mcp-client/index.js

@@ -21,8 +21,38 @@ import { join } from "node:path";
 import { buildHttpTransportOpts } from "./auth.js";
 // ─── Connection Manager ───────────────────────────────────────────────────────
 const connections = new Map();
+const pendingConnections = new Map();
 let configCache = null;
 const toolCache = new Map();
+const trustedStdioServers = new Set();
+const CHILD_ENV_ALLOWLIST = new Set([
+    "PATH",
+    "Path",
+    "HOME",
+    "USER",
+    "USERNAME",
+    "USERPROFILE",
+    "SHELL",
+    "TMPDIR",
+    "TEMP",
+    "TMP",
+    "SystemRoot",
+    "WINDIR",
+    "APPDATA",
+    "LOCALAPPDATA",
+    "XDG_CONFIG_HOME",
+    "XDG_CACHE_HOME",
+]);
+function stdioTrustKey(config) {
+    return JSON.stringify({
+        name: config.name,
+        sourcePath: config.sourcePath,
+        command: config.command,
+        args: config.args ?? [],
+        cwd: config.cwd,
+        env: config.env ?? {},
+    });
+}
 function readConfigs() {
     if (configCache)
         return configCache;
@@ -57,6 +87,7 @@ function readConfigs() {
                 servers.push({
                     name,
                     transport,
+                    sourcePath: configPath,
                     ...(hasCommand && {
                         command: config.command,
                         args: Array.isArray(config.args) ? config.args : undefined,
@@ -78,6 +109,42 @@ function readConfigs() {
     configCache = servers;
     return servers;
 }
+export function _buildMcpChildEnvForTest(configEnv) {
+    const childEnv = {};
+    for (const key of CHILD_ENV_ALLOWLIST) {
+        const value = process.env[key];
+        if (typeof value === "string")
+            childEnv[key] = value;
+    }
+    return {
+        ...childEnv,
+        ...(configEnv ? resolveEnv(configEnv) : {}),
+    };
+}
+export function _buildMcpTrustConfirmOptionsForTest(signal) {
+    return signal ? { timeout: 120_000, signal } : { timeout: 120_000 };
+}
+async function assertTrustedStdioServer(config, ctx, signal) {
+    if (config.transport !== "stdio")
+        return undefined;
+    const trustKey = stdioTrustKey(config);
+    if (trustedStdioServers.has(trustKey))
+        return undefined;
+    if (!ctx?.hasUI) {
+        throw new Error(`MCP server "${config.name}" is a project-local stdio command from ${config.sourcePath}. ` +
+            "Run this from an interactive GSD session and approve the server before use.");
+    }
+    const commandLine = [config.command, ...(config.args ?? [])].filter(Boolean).join(" ");
+    const envKeys = Object.keys(config.env ?? {});
+    const envSummary = envKeys.length > 0
+        ? `\n\nConfigured environment keys: ${envKeys.join(", ")}`
+        : "\n\nNo explicit environment keys configured.";
+    const approved = await ctx.ui.confirm(`Trust MCP server "${config.name}"?`, `Project config ${config.sourcePath} wants to start:\n\n${commandLine}${envSummary}\n\nOnly approve MCP servers you trust.`, _buildMcpTrustConfirmOptionsForTest(signal));
+    if (!approved) {
+        throw new Error(`MCP server "${config.name}" was not approved by the user.`);
+    }
+    return trustKey;
+}
 function getServerConfig(name) {
     const trimmed = name.trim();
     return readConfigs().find((s) => s.name === trimmed ||
@@ -96,7 +163,7 @@ function resolveEnv(env) {
     }
     return resolved;
 }
-async function getOrConnect(name, signal) {
+async function getOrConnect(name, signal, ctx) {
     const config = getServerConfig(name);
     if (!config)
         throw new Error(`Unknown MCP server: "${name}". Use mcp_servers to list available servers.`);
@@ -105,13 +172,28 @@ async function getOrConnect(name, signal) {
     const existing = connections.get(config.name);
     if (existing)
         return existing.client;
+    const pending = pendingConnections.get(config.name);
+    if (pending)
+        return pending;
+    const connectionPromise = connectServer(config, signal, ctx);
+    pendingConnections.set(config.name, connectionPromise);
+    try {
+        return await connectionPromise;
+    }
+    finally {
+        pendingConnections.delete(config.name);
+    }
+}
+async function connectServer(config, signal, ctx) {
     const client = new Client({ name: "gsd", version: "1.0.0" });
     let transport;
+    let approvedTrustKey;
     if (config.transport === "stdio" && config.command) {
+        approvedTrustKey = await assertTrustedStdioServer(config, ctx, signal);
         transport = new StdioClientTransport({
             command: config.command,
             args: config.args,
-            env: config.env ? { ...process.env, ...resolveEnv(config.env) } : undefined,
+            env: _buildMcpChildEnvForTest(config.env),
             cwd: config.cwd,
             stderr: "pipe",
         });
@@ -127,9 +209,28 @@ async function getOrConnect(name, signal) {
     else {
         throw new Error(`Server "${config.name}" has unsupported transport: ${config.transport}`);
     }
-    await client.connect(transport, { signal, timeout: 30000 });
-    connections.set(config.name, { client, transport });
-    return client;
+    try {
+        await client.connect(transport, { signal, timeout: 30000 });
+        if (approvedTrustKey)
+            trustedStdioServers.add(approvedTrustKey);
+        connections.set(config.name, { client, transport });
+        return client;
+    }
+    catch (err) {
+        try {
+            await transport.close();
+        }
+        catch {
+            // Best-effort cleanup after a failed or aborted connection attempt.
+        }
+        try {
+            await client.close();
+        }
+        catch {
+            // Best-effort cleanup after a failed or aborted connection attempt.
+        }
+        throw err;
+    }
 }
 async function closeAll() {
     const closing = Array.from(connections.entries()).map(async ([name, conn]) => {
@@ -139,9 +240,17 @@ async function closeAll() {
         catch {
             // Best-effort cleanup
         }
+        try {
+            await conn.transport.close();
+        }
+        catch {
+            // Best-effort cleanup
+        }
         connections.delete(name);
     });
     await Promise.allSettled(closing);
+    pendingConnections.clear();
+    trustedStdioServers.clear();
     toolCache.clear();
 }
 // ─── Formatters ───────────────────────────────────────────────────────────────
@@ -249,7 +358,7 @@ export default function (pi) {
                 description: "MCP server name (from mcp_servers output), e.g. 'railway', 'twitter-mcp', 'linear'",
             }),
         }),
-        async execute(_id, params, signal) {
+        async execute(_id, params, signal, _onUpdate, ctx) {
             try {
                 // Return cached tools if available
                 const cached = toolCache.get(params.server);
@@ -265,7 +374,7 @@ export default function (pi) {
                         details: { server: params.server, toolCount: cached.length, cached: true },
                     };
                 }
-                const client = await getOrConnect(params.server, signal);
+                const client = await getOrConnect(params.server, signal, ctx);
                 const result = await client.listTools(undefined, { signal, timeout: 30000 });
                 const tools = (result.tools ?? []).map((t) => ({
                     name: t.name,
@@ -326,9 +435,9 @@ export default function (pi) {
                 description: "Tool arguments as key-value pairs matching the tool's input schema",
             })),
         }),
-        async execute(_id, params, signal) {
+        async execute(_id, params, signal, _onUpdate, ctx) {
             try {
-                const client = await getOrConnect(params.server, signal);
+                const client = await getOrConnect(params.server, signal, ctx);
                 const result = await client.callTool({ name: params.tool, arguments: params.args ?? {} }, undefined, { signal, timeout: 60000 });
                 // Serialize result content to text
                 const contentItems = result.content;

package/dist/resources/extensions/search-the-web/command-search-provider.js

@@ -7,7 +7,7 @@
  *
  * All provider logic lives in provider.ts (S01) — this is pure UI wiring.
  */
-import { isAnthropicApi } from '@gsd/pi-ai';
+import { supportsNativeWebSearch } from './native-search.js';
 import { getTavilyApiKey, getBraveApiKey, getOllamaApiKey, getSearchProviderPreference, setSearchProviderPreference, resolveSearchProvider, } from './provider.js';
 const VALID_PREFERENCES = ['tavily', 'brave', 'ollama', 'auto'];
 function keyStatus(provider) {
@@ -72,9 +72,10 @@ export function registerSearchProviderCommand(pi) {
             }
             setSearchProviderPreference(chosen);
             const effective = resolveSearchProvider();
-            // Gate on api (#4478 / ADR-012): covers claude-code, anthropic-vertex, and
-            // other Anthropic-fronting transports — not just the plain `anthropic` provider.
-            const isAnthropic = isAnthropicApi(ctx.model);
+            // Gate on api shape + provider allowlist: the info note must match the
+            // actual runtime behavior in native-search.ts. Claude served via copilot
+            // / minimax / kimi is anthropic-shaped but does NOT run native search.
+            const isAnthropic = supportsNativeWebSearch(ctx.model);
             const nativeNote = isAnthropic ? '\nNote: Native Anthropic web search is also active (automatic, no API key needed).' : '';
             ctx.ui.notify(`Search provider set to ${chosen}. Effective provider: ${effective ?? 'none (no API keys)'}${nativeNote}`, 'info');
         },

package/dist/resources/extensions/search-the-web/native-search.js

@@ -12,6 +12,38 @@ export const BRAVE_TOOL_NAMES = ["search-the-web", "search_and_read"];
 export const CUSTOM_SEARCH_TOOL_NAMES = ["search-the-web", "search_and_read", "google_search"];
 /** Thinking block types that require signature validation by the API */
 const THINKING_TYPES = new Set(["thinking", "redacted_thinking"]);
+/**
+ * Providers whose Anthropic-Messages endpoint is known to accept the native
+ * `web_search_20250305` server tool. Anthropic-shaped transports NOT in this
+ * set (github-copilot, minimax, kimi-coding, opencode, vercel-ai-gateway,
+ * etc.) route Claude or Claude-compatible models through the Messages API
+ * but do NOT expose the server-side search tool — injecting it yields a
+ * 400 "unsupported_value" from their endpoints (regression from #4492).
+ *
+ * Keep this allowlist tight — err on the side of custom/Brave search rather
+ * than a runtime 400. Add a provider here only after confirming its endpoint
+ * accepts the tool type.
+ */
+const NATIVE_WEB_SEARCH_PROVIDERS = new Set([
+    "anthropic",
+    "claude-code",
+    "anthropic-vertex",
+    "vercel-ai-gateway",
+]);
+/**
+ * True when the model is an Anthropic-shaped transport AND the provider is
+ * known to accept the native `web_search_20250305` tool. Gate both on api
+ * shape (#4478 / ADR-012) and on provider identity (#444 regression guard
+ * and #4492 scope correction) — provider-level discrimination is legitimate
+ * per ADR-012 for credential/behavior differences that api shape can't
+ * express.
+ */
+export function supportsNativeWebSearch(model) {
+    if (!isAnthropicApi(model))
+        return false;
+    const provider = model?.provider;
+    return typeof provider === "string" && NATIVE_WEB_SEARCH_PROVIDERS.has(provider);
+}
 /**
  * Maximum number of native web searches allowed per session (agent unit).
  * The Anthropic API's `max_uses` is per-request — it resets on each API call.
@@ -76,10 +108,11 @@ export function registerNativeSearchHooks(pi) {
     pi.on("model_select", async (event, ctx) => {
         modelSelectFired = true;
         const wasAnthropic = isAnthropicProvider;
-        // Gate on `api` not `provider` (#4478 / ADR-012): covers claude-code OAuth,
-        // anthropic-vertex, and Vercel-gateway-hosted Anthropic — all serve the
-        // Messages API and accept the native web_search tool.
-        isAnthropicProvider = isAnthropicApi(event.model);
+        // Gate on api shape AND provider allowlist: direct Anthropic, claude-code
+        // OAuth, and anthropic-vertex accept `web_search_20250305`; copilot /
+        // minimax / kimi / opencode route Claude-compat models through the same
+        // wire protocol but reject the server-side tool (#4492 regression).
+        isAnthropicProvider = supportsNativeWebSearch(event.model);
         const hasBrave = !!process.env.BRAVE_API_KEY;
         // When Anthropic (and not preferring Brave): disable custom search tools —
         // native web_search is server-side and more reliable.
@@ -120,20 +153,19 @@ export function registerNativeSearchHooks(pi) {
         // modelsAreEqual suppresses model_select AND the SDK doesn't pass model.
         const eventModel = event.model;
         let isAnthropic;
-        if (eventModel?.api) {
-            // Preferred path: gate on wire protocol (#4478 / ADR-012).
-            isAnthropic = isAnthropicApi(eventModel);
-        }
-        else if (eventModel?.provider) {
-            // Fallback for event shapes that carry provider but not api — only plain
-            // `anthropic` maps unambiguously without the api field. Other Anthropic
-            // transports will arrive via the modelSelectFired or model-name branch.
-            isAnthropic = eventModel.provider === "anthropic";
+        if (eventModel?.api || eventModel?.provider) {
+            // Preferred path: gate on api shape + provider allowlist. Both fields
+            // are authoritative when present — do NOT fall back to the model-name
+            // heuristic, which would misclassify copilot-served Claude as Anthropic
+            // (#444 regression) or minimax-served Claude-compat as Anthropic (#4492).
+            isAnthropic = supportsNativeWebSearch(eventModel);
         }
         else if (modelSelectFired) {
             isAnthropic = isAnthropicProvider;
         }
         else {
+            // Last resort: session-restore paths where the SDK doesn't pass model.
+            // The model-name prefix is best-effort and assumes direct Anthropic.
             const modelName = typeof payload.model === "string" ? payload.model : "";
             isAnthropic = modelName.startsWith("claude-");
         }

package/dist/resources/extensions/shared/cmux-events.js

@@ -0,0 +1,12 @@
+// GSD-2 — Shared cmux event channel contracts
+// Copyright (c) 2026 Jeremy McSpadden <jeremy@fluxlabs.net>
+/**
+ * Neutral event channel module for gsd<->cmux IPC.
+ * Both gsd and cmux import from here — neither imports the other directly.
+ * Per ADR-006 Phase 0: event-based decoupling.
+ */
+export const CMUX_CHANNELS = {
+    SIDEBAR: "cmux:sidebar",
+    LOG: "cmux:log",
+    LIFECYCLE: "cmux:lifecycle",
+};

package/dist/resources/extensions/shared/rtk-session-stats.js

@@ -1,7 +1,6 @@
 import { spawnSync } from "node:child_process";
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
-import { gsdRoot } from "../gsd/paths.js";
 import { formatTokenCount } from "./format-utils.js";
 import { buildRtkEnv, isRtkEnabled, resolveRtkBinaryPath } from "./rtk.js";
 const SESSION_BASELINES_FILE = "rtk-session-baselines.json";
@@ -10,7 +9,7 @@ const CURRENT_SUMMARY_TIMEOUT_MS = 5_000;
 const MAX_BASELINE_SESSIONS = 200;
 let cachedSummary = null;
 function getRuntimeDir(basePath) {
-    return join(gsdRoot(basePath), "runtime");
+    return join(basePath, ".gsd", "runtime");
 }
 function getBaselinesPath(basePath) {
     return join(getRuntimeDir(basePath), SESSION_BASELINES_FILE);