gsd-pi 2.73.0 → 2.73.1-dev.6ddfa43

package/dist/cli.js

@@ -6,7 +6,6 @@ import { initResources, buildResourceLoader, getNewerManagedResourceVersion } fr
 import { ensureManagedTools } from './tool-bootstrap.js';
 import { loadStoredEnvKeys } from './wizard.js';
 import { migratePiCredentials, getPiDefaultModelAndProvider } from './pi-migration.js';
-import { shouldMigrateAnthropicToClaudeCode } from './provider-migrations.js';
 import { shouldRunOnboarding, runOnboarding } from './onboarding.js';
 import chalk from 'chalk';
 import { checkForUpdates } from './update-check.js';
@@ -455,29 +454,6 @@ if (isPrintMode) {
         isClaudeCodeReady: () => modelRegistry.isProviderRequestReady('claude-code'),
     });
     markStartup('createAgentSession');
-    // Migrate anthropic OAuth users to claude-code provider when CLI is available (#3772).
-    // Anthropic blocks third-party apps from using subscription quotas — routing through
-    // the local claude CLI binary is TOS-compliant.
-    if (shouldMigrateAnthropicToClaudeCode({
-        authStorage,
-        isClaudeCodeReady: modelRegistry.isProviderRequestReady('claude-code'),
-        defaultProvider: settingsManager.getDefaultProvider(),
-    })) {
-        const currentModelId = settingsManager.getDefaultModel();
-        if (currentModelId) {
-            const ccModel = modelRegistry.find('claude-code', currentModelId);
-            if (ccModel) {
-                try {
-                    await session.setModel(ccModel);
-                    // Only persist after successful session switch to avoid desync
-                    settingsManager.setDefaultModelAndProvider('claude-code', currentModelId);
-                }
-                catch {
-                    // claude-code provider not ready — leave both session and settings unchanged
-                }
-            }
-        }
-    }
     // Validate configured model AFTER extensions have registered their models (#2626).
     // Before this, extension-provided models (e.g. claude-code/*) were not yet in the
     // registry, causing the user's valid choice to be silently overwritten.
@@ -647,29 +623,6 @@ const { session, extensionsResult, modelFallbackMessage: interactiveFallbackMsg
     isClaudeCodeReady: () => modelRegistry.isProviderRequestReady('claude-code'),
 });
 markStartup('createAgentSession');
-// Migrate anthropic OAuth users to claude-code provider when CLI is available (#3772).
-// Anthropic blocks third-party apps from using subscription quotas — routing through
-// the local claude CLI binary is TOS-compliant.
-if (shouldMigrateAnthropicToClaudeCode({
-    authStorage,
-    isClaudeCodeReady: modelRegistry.isProviderRequestReady('claude-code'),
-    defaultProvider: settingsManager.getDefaultProvider(),
-})) {
-    const currentModelId = settingsManager.getDefaultModel();
-    if (currentModelId) {
-        const ccModel = modelRegistry.find('claude-code', currentModelId);
-        if (ccModel) {
-            try {
-                await session.setModel(ccModel);
-                // Only persist after successful session switch to avoid desync
-                settingsManager.setDefaultModelAndProvider('claude-code', currentModelId);
-            }
-            catch {
-                // claude-code provider not ready — leave both session and settings unchanged
-            }
-        }
-    }
-}
 // Validate configured model AFTER extensions have registered their models (#2626).
 // Before this, extension-provided models (e.g. claude-code/*) were not yet in the
 // registry, causing the user's valid choice to be silently overwritten.

package/dist/help-text.js

@@ -148,7 +148,7 @@ export function printHelp(version) {
     process.stdout.write('  --print, -p              Single-shot print mode\n');
     process.stdout.write('  --continue, -c           Resume the most recent session\n');
     process.stdout.write('  --worktree, -w [name]    Start in an isolated worktree (auto-named if omitted)\n');
-    process.stdout.write('  --model <id>             Override model (e.g. claude-opus-4-6)\n');
+    process.stdout.write('  --model <id>             Override model (e.g. provider/model-id)\n');
     process.stdout.write('  --no-session             Disable session persistence\n');
     process.stdout.write('  --extension <path>       Load additional extension\n');
     process.stdout.write('  --tools <a,b,c>          Restrict available tools\n');

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

@@ -6,7 +6,7 @@
  * AssistantMessageEvents for TUI rendering, then strips tool-call blocks from
  * the final AssistantMessage so GSD's agent loop doesn't try to dispatch them.
  */
-import { EventStream } from "@gsd/pi-ai";
+import { EventStream, mapThinkingLevelToEffort, supportsAdaptiveThinking } from "@gsd/pi-ai";
 import { execSync } from "node:child_process";
 import { PartialMessageBuilder, ZERO_USAGE, mapUsage } from "./partial-builder.js";
 import { buildWorkflowMcpServers } from "../gsd/workflow-mcp.js";
@@ -437,6 +437,7 @@ export async function resolveClaudePermissionMode(env = process.env) {
  * behaviour pass `permissionMode: "bypassPermissions"` explicitly.
  */
 export function buildSdkOptions(modelId, prompt, overrides, extraOptions = {}) {
+    const { reasoning, ...sdkExtraOptions } = extraOptions;
     const mcpServers = buildWorkflowMcpServers();
     const permissionMode = overrides?.permissionMode ?? "bypassPermissions";
     const disallowedTools = ["AskUserQuestion"];
@@ -455,6 +456,9 @@ export function buildSdkOptions(modelId, prompt, overrides, extraOptions = {}) {
         "Bash(pwd)",
         ...(mcpServers ? Object.keys(mcpServers).map((serverName) => `mcp__${serverName}__*`) : []),
     ];
+    const effort = reasoning && supportsAdaptiveThinking(modelId)
+        ? mapThinkingLevelToEffort(reasoning, modelId)
+        : undefined;
     return {
         pathToClaudeCodeExecutable: getClaudePath(),
         model: modelId,
@@ -469,7 +473,8 @@ export function buildSdkOptions(modelId, prompt, overrides, extraOptions = {}) {
         ...(allowedTools.length > 0 ? { allowedTools } : {}),
         ...(mcpServers ? { mcpServers } : {}),
         betas: modelId.includes("sonnet") ? ["context-1m-2025-08-07"] : [],
-        ...extraOptions,
+        ...(effort ? { effort } : {}),
+        ...sdkExtraOptions,
     };
 }
 function normalizeToolResultContent(content) {
@@ -620,9 +625,10 @@ async function pumpSdkMessages(model, context, options, stream) {
         const permissionMode = await resolveClaudePermissionMode();
         const sdkOpts = buildSdkOptions(modelId, prompt, { permissionMode }, typeof options?.extensionUIContext === "object"
             ? {
+                reasoning: options?.reasoning,
                 onElicitation: createClaudeCodeElicitationHandler(options?.extensionUIContext),
             }
-            : {});
+            : { reasoning: options?.reasoning });
         const queryResult = sdk.query({
             prompt,
             options: {

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

@@ -18,6 +18,7 @@ import { logWarning, logError } from "./workflow-logger.js";
 import { join } from "node:path";
 import { hasImplementationArtifacts } from "./auto-recovery.js";
 import { buildDiscussMilestonePrompt, buildResearchMilestonePrompt, buildPlanMilestonePrompt, buildResearchSlicePrompt, buildPlanSlicePrompt, buildExecuteTaskPrompt, buildCompleteSlicePrompt, buildCompleteMilestonePrompt, buildValidateMilestonePrompt, buildReplanSlicePrompt, buildRunUatPrompt, buildReassessRoadmapPrompt, buildRewriteDocsPrompt, buildReactiveExecutePrompt, buildGateEvaluatePrompt, buildParallelResearchSlicesPrompt, checkNeedsReassessment, checkNeedsRunUat, } from "./auto-prompts.js";
+import { resolveModelWithFallbacksForUnit } from "./preferences-models.js";
 function missingSliceStop(mid, phase) {
     return {
         action: "stop",
@@ -330,7 +331,7 @@ export const DISPATCH_RULES = [
                 action: "dispatch",
                 unitType: "research-slice",
                 unitId: `${mid}/parallel-research`,
-                prompt: await buildParallelResearchSlicesPrompt(mid, midTitle, researchReadySlices, basePath),
+                prompt: await buildParallelResearchSlicesPrompt(mid, midTitle, researchReadySlices, basePath, resolveModelWithFallbacksForUnit("subagent")?.primary),
             };
         },
     },
@@ -401,7 +402,7 @@ export const DISPATCH_RULES = [
                 action: "dispatch",
                 unitType: "gate-evaluate",
                 unitId: `${mid}/${sid}/gates+${pending.map(g => g.gate_id).join(",")}`,
-                prompt: await buildGateEvaluatePrompt(mid, midTitle, sid, sTitle, basePath),
+                prompt: await buildGateEvaluatePrompt(mid, midTitle, sid, sTitle, basePath, resolveModelWithFallbacksForUnit("subagent")?.primary),
             };
         },
     },
@@ -436,6 +437,7 @@ export const DISPATCH_RULES = [
             const sid = state.activeSlice.id;
             const sTitle = state.activeSlice.title;
             const maxParallel = reactiveConfig.max_parallel ?? 2;
+            const subagentModel = reactiveConfig.subagent_model ?? resolveModelWithFallbacksForUnit("subagent")?.primary;
             // Dry-run mode: max_parallel=1 means graph is derived and logged but
             // execution remains sequential
             if (maxParallel <= 1)
@@ -478,7 +480,7 @@ export const DISPATCH_RULES = [
                     action: "dispatch",
                     unitType: "reactive-execute",
                     unitId: `${mid}/${sid}/reactive+${batchSuffix}`,
-                    prompt: await buildReactiveExecutePrompt(mid, midTitle, sid, sTitle, selected, basePath),
+                    prompt: await buildReactiveExecutePrompt(mid, midTitle, sid, sTitle, selected, basePath, subagentModel),
                 };
             }
             catch (err) {

package/dist/resources/extensions/gsd/auto-model-selection.js

@@ -9,10 +9,8 @@ import { resolveModelForComplexity, escalateTier, getEligibleModels, loadCapabil
 import { getLedger, getProjectTotals } from "./metrics.js";
 import { unitPhaseLabel } from "./auto-dashboard.js";
 import { getSessionModelOverride } from "./session-model-override.js";
-export function resolvePreferredModelConfig(unitType, autoModeStartModel, 
-/** When false, only return explicit per-phase model configs — do not
- *  synthesize a routing ceiling from dynamic_routing.tier_models (#3962). */
-isAutoMode = true) {
+import { logWarning } from "./workflow-logger.js";
+export function resolvePreferredModelConfig(unitType, autoModeStartModel, isAutoMode = true) {
     const explicitConfig = resolveModelWithFallbacksForUnit(unitType);
     if (explicitConfig)
         return explicitConfig;
@@ -24,7 +22,7 @@ isAutoMode = true) {
     if (!routingConfig.enabled || !routingConfig.tier_models)
         return undefined;
     // Don't synthesize a routing config for flat-rate providers (#3453).
-    if (autoModeStartModel && isFlatRateProvider(autoModeStartModel.provider))
+    if (autoModeStartModel && isFlatRateProvider(autoModeStartModel.provider, autoModeStartModel.flatRateCtx))
         return undefined;
     const ceilingModel = routingConfig.tier_models.heavy
         ?? (autoModeStartModel ? `${autoModeStartModel.provider}/${autoModeStartModel.id}` : undefined);
@@ -51,6 +49,17 @@ sessionModelOverride) {
     const effectiveSessionModelOverride = sessionModelOverride === undefined
         ? getSessionModelOverride(ctx.sessionManager.getSessionId())
         : (sessionModelOverride ?? undefined);
+    // Enrich the start model with a flat-rate context up front so routing
+    // synthesis and the dispatch-time guard see the same signals (built-in
+    // list + user `flat_rate_providers` preference + externalCli auto-
+    // detection).  The dispatch-time primary-model check below builds its
+    // own per-provider context when it has a resolved primary model.
+    if (autoModeStartModel) {
+        autoModeStartModel = {
+            ...autoModeStartModel,
+            flatRateCtx: buildFlatRateContext(autoModeStartModel.provider, ctx, prefs),
+        };
+    }
     const modelConfig = effectiveSessionModelOverride
         ? undefined
         : resolvePreferredModelConfig(unitType, autoModeStartModel, isAutoMode);
@@ -76,12 +85,13 @@ sessionModelOverride) {
         if (routingConfig.enabled) {
             const primaryModel = resolveModelId(modelConfig.primary, availableModels, ctx.model?.provider);
             if (primaryModel) {
-                if (isFlatRateProvider(primaryModel.provider)) {
+                const primaryFlatRateCtx = buildFlatRateContext(primaryModel.provider, ctx, prefs);
+                if (isFlatRateProvider(primaryModel.provider, primaryFlatRateCtx)) {
                     routingConfig.enabled = false;
                 }
             }
-            else if ((autoModeStartModel && isFlatRateProvider(autoModeStartModel.provider))
-                || (ctx.model?.provider && isFlatRateProvider(ctx.model.provider))) {
+            else if ((autoModeStartModel && isFlatRateProvider(autoModeStartModel.provider, autoModeStartModel.flatRateCtx))
+                || (ctx.model?.provider && isFlatRateProvider(ctx.model.provider, buildFlatRateContext(ctx.model.provider, ctx, prefs)))) {
                 // Primary model unresolvable but provider signals indicate flat-rate —
                 // disable routing to prevent quality degradation.
                 routingConfig.enabled = false;
@@ -331,7 +341,40 @@ export function resolveModelId(modelId, availableModels, currentProvider) {
  * Uses case-insensitive matching with alias support to prevent fail-open on
  * provider naming variations (e.g. "copilot" vs "github-copilot").
  */
-const FLAT_RATE_PROVIDERS = new Set(["github-copilot", "copilot", "claude-code"]);
-export function isFlatRateProvider(provider) {
-    return FLAT_RATE_PROVIDERS.has(provider.toLowerCase());
+const BUILTIN_FLAT_RATE = new Set(["github-copilot", "copilot", "claude-code"]);
+export function isFlatRateProvider(provider, opts) {
+    const p = provider.toLowerCase();
+    if (BUILTIN_FLAT_RATE.has(p))
+        return true;
+    if (opts?.userFlatRate?.some(id => id.toLowerCase() === p))
+        return true;
+    if (opts?.authMode === "externalCli")
+        return true;
+    return false;
+}
+/**
+ * Build a FlatRateContext for a given provider from live runtime state.
+ * Safe to call when ctx or prefs are undefined — missing pieces are
+ * treated as "no signal".
+ */
+export function buildFlatRateContext(provider, ctx, prefs) {
+    let authMode;
+    const getAuthMode = ctx?.modelRegistry?.getProviderAuthMode;
+    if (typeof getAuthMode === "function") {
+        try {
+            const mode = getAuthMode(provider);
+            if (mode === "apiKey" || mode === "oauth" || mode === "externalCli" || mode === "none") {
+                authMode = mode;
+            }
+        }
+        catch (err) {
+            // Registry lookup failure must never break flat-rate detection —
+            // fall through with authMode undefined and surface the cause.
+            logWarning("dispatch", `flat-rate auth-mode lookup failed for ${provider}: ${err instanceof Error ? err.message : String(err)}`);
+        }
+    }
+    return {
+        authMode,
+        userFlatRate: prefs?.flat_rate_providers,
+    };
 }

package/dist/resources/extensions/gsd/auto-prompts.js

@@ -1712,7 +1712,7 @@ export async function buildReassessRoadmapPrompt(mid, midTitle, completedSliceId
     });
 }
 // ─── Reactive Execute Prompt ──────────────────────────────────────────────
-export async function buildReactiveExecutePrompt(mid, midTitle, sid, sTitle, readyTaskIds, base) {
+export async function buildReactiveExecutePrompt(mid, midTitle, sid, sTitle, readyTaskIds, base, subagentModel) {
     const { loadSliceTaskIO, deriveTaskGraph, graphMetrics } = await import("./reactive-graph.js");
     // Build graph for context
     const taskIO = await loadSliceTaskIO(base, mid, sid);
@@ -1744,10 +1744,11 @@ export async function buildReactiveExecutePrompt(mid, midTitle, sid, sTitle, rea
         const depPaths = await getDependencyTaskSummaryPaths(mid, sid, tid, node?.dependsOn ?? [], base);
         // Build a full execute-task prompt with dependency-based carry-forward
         const taskPrompt = await buildExecuteTaskPrompt(mid, sid, sTitle, tid, tTitle, base, { carryForwardPaths: depPaths });
+        const modelSuffix = subagentModel ? ` with model: "${subagentModel}"` : "";
         subagentSections.push([
             `### ${tid}: ${tTitle}`,
             "",
-            "Use this as the prompt for a `subagent` call:",
+            `Use this as the prompt for a \`subagent\` call${modelSuffix}:`,
             "",
             "```",
             taskPrompt,
@@ -1806,15 +1807,16 @@ function renderGatesToCloseBlock(gates, opts) {
     }
     return lines.join("\n").trimEnd();
 }
-export async function buildParallelResearchSlicesPrompt(mid, midTitle, slices, basePath) {
+export async function buildParallelResearchSlicesPrompt(mid, midTitle, slices, basePath, subagentModel) {
     // Build individual research-slice prompts for each slice
     const subagentSections = [];
+    const modelSuffix = subagentModel ? ` with model: "${subagentModel}"` : "";
     for (const slice of slices) {
         const slicePrompt = await buildResearchSlicePrompt(mid, midTitle, slice.id, slice.title, basePath);
         subagentSections.push([
             `### ${slice.id}: ${slice.title}`,
             "",
-            "Use this as the prompt for a `subagent` call (agent: `gsd-executor` or the default agent):",
+            `Use this as the prompt for a \`subagent\` call${modelSuffix} (agent: \`gsd-executor\` or the default agent):`,
             "",
             "```",
             slicePrompt,
@@ -1829,7 +1831,7 @@ export async function buildParallelResearchSlicesPrompt(mid, midTitle, slices, b
         subagentPrompts: subagentSections.join("\n\n---\n\n"),
     });
 }
-export async function buildGateEvaluatePrompt(mid, midTitle, sid, sTitle, base) {
+export async function buildGateEvaluatePrompt(mid, midTitle, sid, sTitle, base, subagentModel) {
     // Pull only the gates this turn actually owns (Q3/Q4). Filter via the
     // registry so that scope:"slice" gates owned by other turns (Q8) can't
     // leak into this prompt and can't block dispatch via silent skip.
@@ -1873,10 +1875,11 @@ export async function buildGateEvaluatePrompt(mid, midTitle, sid, sTitle, base)
             "- `rationale`: one-sentence justification",
             "- `findings`: detailed markdown findings (or empty if omitted)",
         ].join("\n");
+        const modelSuffix = subagentModel ? ` with model: "${subagentModel}"` : "";
         subagentSections.push([
             `### ${def.id}: ${def.question}`,
             "",
-            "Use this as the prompt for a `subagent` call:",
+            `Use this as the prompt for a \`subagent\` call${modelSuffix}:`,
             "",
             "```",
             subPrompt,

package/dist/resources/extensions/gsd/auto-start.js

@@ -38,7 +38,7 @@ import { existsSync, mkdirSync, readdirSync, rmSync, statSync, unlinkSync, } fro
 import { join } from "node:path";
 import { sep as pathSep } from "node:path";
 import { resolveProjectRootDbPath } from "./bootstrap/dynamic-tools.js";
-import { resolveDefaultSessionModel, resolveDynamicRoutingConfig } from "./preferences-models.js";
+import { isCustomProvider, resolveDefaultSessionModel, resolveDynamicRoutingConfig, } from "./preferences-models.js";
 import { getSessionModelOverride } from "./session-model-override.js";
 /**
  * Bootstrap a fresh auto-mode session. Handles everything from git init
@@ -195,8 +195,18 @@ export async function bootstrapAutoSession(s, ctx, pi, base, verboseMode, reques
     //
     // This preserves #3517 defaults while honoring explicit runtime model
     // selection for subsequent /gsd runs in the same session.
+    //
+    // Exception (#4122): when the session provider is a custom provider declared
+    // in ~/.gsd/agent/models.json (Ollama, vLLM, OpenAI-compatible proxy, etc.),
+    // PREFERENCES.md is skipped entirely. PREFERENCES.md cannot reference custom
+    // providers, so honoring it would silently reroute auto-mode to a built-in
+    // provider the user is not logged into and surface as "Not logged in · Please
+    // run /login" before pausing and resetting to claude-code/claude-sonnet-4-6.
     const manualSessionOverride = getSessionModelOverride(ctx.sessionManager.getSessionId());
-    const preferredModel = resolveDefaultSessionModel(ctx.model?.provider);
+    const sessionProviderIsCustom = isCustomProvider(ctx.model?.provider);
+    const preferredModel = sessionProviderIsCustom
+        ? null
+        : resolveDefaultSessionModel(ctx.model?.provider);
     // Validate the preferred model against the live registry + provider auth so
     // an unconfigured PREFERENCES.md entry (no API key / OAuth) can't become the
     // start-model snapshot. Without this, every subsequent unit would try to
@@ -636,12 +646,16 @@ export async function bootstrapAutoSession(s, ctx, pi, base, verboseMode, reques
         const startModelLabel = s.autoModeStartModel
             ? `${s.autoModeStartModel.provider}/${s.autoModeStartModel.id}`
             : ctx.model ? `${ctx.model.provider}/${ctx.model.id}` : "default";
-        // Flat-rate providers (e.g. GitHub Copilot, claude-code) suppress routing
-        // at dispatch time (#3453) — reflect that in the banner.
-        const { isFlatRateProvider } = await import("./auto-model-selection.js");
+        // Flat-rate providers (e.g. GitHub Copilot, claude-code, user-declared
+        // subscription proxies, externalCli CLIs) suppress routing at dispatch
+        // time (#3453) — reflect that in the banner.  Thread the same
+        // FlatRateContext used by selectAndApplyModel so user-declared
+        // flat-rate providers and externalCli auto-detection are respected.
+        const { isFlatRateProvider, buildFlatRateContext } = await import("./auto-model-selection.js");
+        const bannerPrefs = loadEffectiveGSDPreferences()?.preferences;
         const effectiveProvider = s.autoModeStartModel?.provider ?? ctx.model?.provider;
         const effectivelyEnabled = routingConfig.enabled
-            && !(effectiveProvider && isFlatRateProvider(effectiveProvider));
+            && !(effectiveProvider && isFlatRateProvider(effectiveProvider, buildFlatRateContext(effectiveProvider, ctx, bannerPrefs)));
         // The actual ceiling may come from tier_models.heavy, not the start model.
         const effectiveCeiling = (routingConfig.enabled && routingConfig.tier_models?.heavy)
             ? routingConfig.tier_models.heavy

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

@@ -19,7 +19,7 @@ import { gsdRoot, resolveMilestoneFile, resolveMilestonePath, resolveDir, milest
 import { invalidateAllCaches } from "./cache.js";
 import { clearActivityLogState } from "./activity-log.js";
 import { synthesizeCrashRecovery, getDeepDiagnostic, readActiveMilestoneId, } from "./session-forensics.js";
-import { writeLock, clearLock, readCrashLock, isLockProcessAlive, formatCrashInfo, } from "./crash-recovery.js";
+import { writeLock, clearLock, readCrashLock, isLockProcessAlive, formatCrashInfo, emitCrashRecoveredUnitEnd, } from "./crash-recovery.js";
 import { acquireSessionLock, getSessionLockStatus, releaseSessionLock, updateSessionLock, } from "./session-lock.js";
 import { resolveAutoSupervisorConfig, loadEffectiveGSDPreferences, getIsolationMode, } from "./preferences.js";
 import { sendDesktopNotification } from "./notifications.js";
@@ -1014,6 +1014,10 @@ export async function startAuto(ctx, pi, base, verboseMode, options) {
         s.stepMode = requestedStepMode;
     }
     if (freshStartAssessment.lock) {
+        // Emit a synthetic unit-end for any unit-start that has no closing event.
+        // This closes the journal gap reported in #3348 where the worker wrote side
+        // effects (SUMMARY.md, DB updates) but died before emitting unit-end.
+        emitCrashRecoveredUnitEnd(base, freshStartAssessment.lock);
         clearLock(base);
     }
     if (!s.paused) {

package/dist/resources/extensions/gsd/bootstrap/crash-log.js

@@ -0,0 +1,31 @@
+/**
+ * crash-log.ts — Write crash diagnostics to ~/.gsd/crash/<timestamp>.log
+ *
+ * Zero cross-dependencies: only uses Node.js built-ins so it can be imported
+ * safely from uncaughtException / unhandledRejection handlers and from tests
+ * without pulling in the full extension dependency tree.
+ */
+import { appendFileSync, mkdirSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+/**
+ * Write a crash log to ~/.gsd/crash/<timestamp>.log (or $GSD_HOME/crash/).
+ * Never throws — must be safe to call from any error handler.
+ */
+export function writeCrashLog(err, source) {
+    try {
+        const crashDir = join(process.env.GSD_HOME ?? join(homedir(), ".gsd"), "crash");
+        mkdirSync(crashDir, { recursive: true });
+        const ts = new Date().toISOString().replace(/[:.]/g, "-");
+        const logPath = join(crashDir, `${ts}.log`);
+        const lines = [
+            `[gsd] ${source}: ${err.message}`,
+            `timestamp: ${new Date().toISOString()}`,
+            `pid: ${process.pid}`,
+            err.stack ?? "(no stack trace available)",
+            "",
+        ];
+        appendFileSync(logPath, lines.join("\n"));
+    }
+    catch { /* never throw from crash handler */ }
+}

package/dist/resources/extensions/gsd/bootstrap/register-extension.js

@@ -8,6 +8,8 @@ import { registerJournalTools } from "./journal-tools.js";
 import { registerQueryTools } from "./query-tools.js";
 import { registerHooks } from "./register-hooks.js";
 import { registerShortcuts } from "./register-shortcuts.js";
+import { writeCrashLog } from "./crash-log.js";
+export { writeCrashLog } from "./crash-log.js";
 export function handleRecoverableExtensionProcessError(err) {
     if (err.code === "EPIPE") {
         process.exit(0);
@@ -28,17 +30,26 @@ export function handleRecoverableExtensionProcessError(err) {
 function installEpipeGuard() {
     if (!process.listeners("uncaughtException").some((listener) => listener.name === "_gsdEpipeGuard")) {
         const _gsdEpipeGuard = (err) => {
-            if (handleRecoverableExtensionProcessError(err)) {
+            if (handleRecoverableExtensionProcessError(err))
                 return;
-            }
-            // Log unhandled errors instead of re-throwing — throwing inside an
-            // uncaughtException handler is a fatal double-fault in Node.js (#3163).
-            process.stderr.write(`[gsd] uncaught extension error (non-fatal): ${err.message}\n`);
-            if (err.stack)
-                process.stderr.write(`${err.stack}\n`);
+            // Write crash log and exit cleanly for unrecoverable errors.
+            // Logging and continuing was the original double-fault fix (#3163), but
+            // continuing in an indeterminate state is worse than a clean exit (#3348).
+            writeCrashLog(err, "uncaughtException");
+            process.exit(1);
         };
         process.on("uncaughtException", _gsdEpipeGuard);
     }
+    if (!process.listeners("unhandledRejection").some((listener) => listener.name === "_gsdRejectionGuard")) {
+        const _gsdRejectionGuard = (reason, _promise) => {
+            const err = reason instanceof Error ? reason : new Error(String(reason));
+            if (handleRecoverableExtensionProcessError(err))
+                return;
+            writeCrashLog(err, "unhandledRejection");
+            process.exit(1);
+        };
+        process.on("unhandledRejection", _gsdRejectionGuard);
+    }
 }
 export function registerGsdExtension(pi) {
     registerGSDCommand(pi);

package/dist/resources/extensions/gsd/bootstrap/system-context.js

@@ -6,6 +6,7 @@ import { debugTime } from "../debug-logger.js";
 import { loadPrompt, getTemplatesDir } from "../prompt-loader.js";
 import { readForensicsMarker } from "../forensics.js";
 import { resolveAllSkillReferences, renderPreferencesForSystemPrompt, loadEffectiveGSDPreferences } from "../preferences.js";
+import { resolveModelWithFallbacksForUnit } from "../preferences-models.js";
 import { resolveSkillReference } from "../preferences-skills.js";
 import { resolveGsdRootFile, resolveSliceFile, resolveSlicePath, resolveTaskFile, resolveTaskFiles, resolveTasksDir, relSliceFile, relSlicePath, relTaskFile } from "../paths.js";
 import { ensureCodebaseMapFresh, readCodebaseMap } from "../codebase-generator.js";
@@ -147,7 +148,11 @@ export async function buildBeforeAgentStartResult(event, ctx) {
     // Re-inject forensics context on follow-up turns (#2941)
     const forensicsInjection = !injection ? buildForensicsContextInjection(process.cwd(), event.prompt) : null;
     const worktreeBlock = buildWorktreeContextBlock();
-    const fullSystem = `${event.systemPrompt}\n\n[SYSTEM CONTEXT — GSD]\n\n${systemContent}${preferenceBlock}${knowledgeBlock}${codebaseBlock}${memoryBlock}${newSkillsBlock}${worktreeBlock}`;
+    const subagentModelConfig = resolveModelWithFallbacksForUnit("subagent");
+    const subagentModelBlock = subagentModelConfig
+        ? `\n\n## Subagent Model\n\nWhen spawning subagents via the \`subagent\` tool, always pass \`model: "${subagentModelConfig.primary}"\` in the tool call parameters. Never omit this — always specify it explicitly.`
+        : "";
+    const fullSystem = `${event.systemPrompt}\n\n[SYSTEM CONTEXT — GSD]\n\n${systemContent}${preferenceBlock}${knowledgeBlock}${codebaseBlock}${memoryBlock}${newSkillsBlock}${worktreeBlock}${subagentModelBlock}`;
     stopContextTimer({
         systemPromptSize: fullSystem.length,
         injectionSize: injection?.length ?? forensicsInjection?.length ?? 0,

package/dist/resources/extensions/gsd/crash-recovery.js

@@ -14,6 +14,7 @@ import { join } from "node:path";
 import { gsdRoot } from "./paths.js";
 import { atomicWriteSync } from "./atomic-write.js";
 import { effectiveLockFile } from "./session-lock.js";
+import { emitJournalEvent, queryJournal } from "./journal.js";
 function lockPath(basePath) {
     return join(gsdRoot(basePath), effectiveLockFile());
 }
@@ -110,3 +111,53 @@ export function formatCrashInfo(lock) {
     }
     return lines.join("\n");
 }
+/**
+ * Emit a synthetic unit-end event for a unit that crashed without emitting its own.
+ *
+ * Queries the journal to find the most recent unit-start for the crashed unit.
+ * If a matching unit-end already exists (e.g. the hard timeout fired), this is a
+ * no-op. Called during crash recovery, before clearing the stale lock.
+ *
+ * Addresses the gap reported in #3348 where `unit-start` was emitted but no
+ * `unit-end` followed — side effects landed but the worker died before closeout.
+ */
+export function emitCrashRecoveredUnitEnd(basePath, lock) {
+    // Skip bootstrap / starting pseudo-units — they have no meaningful unit-start event.
+    if (!lock.unitType || !lock.unitId || lock.unitType === "starting")
+        return;
+    try {
+        const all = queryJournal(basePath);
+        // Find the most recent unit-start for this unitId
+        const starts = all.filter((e) => e.eventType === "unit-start" && e.data?.unitId === lock.unitId);
+        if (starts.length === 0)
+            return;
+        const lastStart = starts[starts.length - 1];
+        // Check if a unit-end was already emitted (e.g. hard timeout fired after the crash)
+        const alreadyClosed = all.some((e) => e.eventType === "unit-end" &&
+            e.data?.unitId === lock.unitId &&
+            e.causedBy?.flowId === lastStart.flowId &&
+            e.causedBy?.seq === lastStart.seq);
+        if (alreadyClosed)
+            return;
+        // Find the highest seq in this flow for monotonic ordering
+        const maxSeq = all
+            .filter((e) => e.flowId === lastStart.flowId)
+            .reduce((max, e) => Math.max(max, e.seq), lastStart.seq);
+        emitJournalEvent(basePath, {
+            ts: new Date().toISOString(),
+            flowId: lastStart.flowId,
+            seq: maxSeq + 1,
+            eventType: "unit-end",
+            data: {
+                unitType: lock.unitType,
+                unitId: lock.unitId,
+                status: "crash-recovered",
+                artifactVerified: false,
+            },
+            causedBy: { flowId: lastStart.flowId, seq: lastStart.seq },
+        });
+    }
+    catch {
+        // Never throw from crash recovery path — journal failure must not block recovery
+    }
+}

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

@@ -1352,6 +1352,25 @@ export function setSliceSummaryMd(milestoneId, sliceId, summaryMd, uatMd) {
         throw new GSDError(GSD_STALE_STATE, "gsd-db: No database open");
     currentDb.prepare(`UPDATE slices SET full_summary_md = :summary_md, full_uat_md = :uat_md WHERE milestone_id = :mid AND id = :sid`).run({ ":mid": milestoneId, ":sid": sliceId, ":summary_md": summaryMd, ":uat_md": uatMd });
 }
+function parseTaskArrayColumn(raw) {
+    if (typeof raw !== "string" || raw.trim() === "")
+        return [];
+    try {
+        const parsed = JSON.parse(raw);
+        if (Array.isArray(parsed))
+            return parsed.map((value) => String(value));
+        if (parsed === null || parsed === undefined || parsed === "")
+            return [];
+        return [String(parsed)];
+    }
+    catch {
+        // Older/corrupt rows may contain comma-separated strings instead of JSON.
+        return raw
+            .split(",")
+            .map((value) => value.trim())
+            .filter(Boolean);
+    }
+}
 function rowToTask(row) {
     const parseTaskArray = (value) => {
         if (Array.isArray(value)) {
@@ -1390,8 +1409,8 @@ function rowToTask(row) {
         blocker_discovered: row["blocker_discovered"] === 1,
         deviations: row["deviations"],
         known_issues: row["known_issues"],
-        key_files: JSON.parse(row["key_files"] || "[]"),
-        key_decisions: JSON.parse(row["key_decisions"] || "[]"),
+        key_files: parseTaskArrayColumn(row["key_files"]),
+        key_decisions: parseTaskArrayColumn(row["key_decisions"]),
         full_summary_md: row["full_summary_md"],
         description: row["description"] ?? "",
         estimate: row["estimate"] ?? "",
@@ -1855,6 +1874,21 @@ export function deleteSlice(milestoneId, sliceId) {
         currentDb.prepare(`DELETE FROM slices WHERE milestone_id = :mid AND id = :sid`).run({ ":mid": milestoneId, ":sid": sliceId });
     });
 }
+export function deleteMilestone(milestoneId) {
+    if (!currentDb)
+        throw new GSDError(GSD_STALE_STATE, "gsd-db: No database open");
+    transaction(() => {
+        currentDb.prepare(`DELETE FROM verification_evidence WHERE milestone_id = :mid`).run({ ":mid": milestoneId });
+        currentDb.prepare(`DELETE FROM quality_gates WHERE milestone_id = :mid`).run({ ":mid": milestoneId });
+        currentDb.prepare(`DELETE FROM tasks WHERE milestone_id = :mid`).run({ ":mid": milestoneId });
+        currentDb.prepare(`DELETE FROM slice_dependencies WHERE milestone_id = :mid`).run({ ":mid": milestoneId });
+        currentDb.prepare(`DELETE FROM slices WHERE milestone_id = :mid`).run({ ":mid": milestoneId });
+        currentDb.prepare(`DELETE FROM replan_history WHERE milestone_id = :mid`).run({ ":mid": milestoneId });
+        currentDb.prepare(`DELETE FROM assessments WHERE milestone_id = :mid`).run({ ":mid": milestoneId });
+        currentDb.prepare(`DELETE FROM artifacts WHERE milestone_id = :mid`).run({ ":mid": milestoneId });
+        currentDb.prepare(`DELETE FROM milestones WHERE id = :mid`).run({ ":mid": milestoneId });
+    });
+}
 export function updateSliceFields(milestoneId, sliceId, fields) {
     if (!currentDb)
         throw new GSDError(GSD_STALE_STATE, "gsd-db: No database open");