gsd-pi 2.78.0-dev.aeeb2ca00 → 2.78.1-dev.0fdacd524

package/README.md

@@ -471,6 +471,7 @@ On first run, GSD launches a branded setup wizard that walks you through LLM pro
 | `/gsd logs`             | Browse activity, debug, and metrics logs                                      |
 | `/gsd export --html`    | Generate HTML report for current or completed milestone                       |
 | `/worktree` (`/wt`)     | Git worktree lifecycle — create, switch, merge, remove                        |
+| `/gsd worktree` (`/gsd wt`) | TUI worktree management — list, merge, clean, remove with safety checks   |
 | `/voice`                | Toggle real-time speech-to-text (macOS, Linux)                                |
 | `/exit`                 | Graceful shutdown — saves session state before exiting                        |
 | `/kill`                 | Kill GSD process immediately                                                  |
@@ -625,19 +626,19 @@ Start GSD with `gsd --debug` to enable structured JSONL diagnostic logging. Debu
 
 ### Token Optimization
 
-GSD includes a coordinated token optimization system that reduces usage by 40-60% on cost-sensitive workloads. Set a single preference to coordinate model selection, phase skipping, and context compression:
+GSD includes a coordinated token optimization system that reduces usage by 40-60% on cost-sensitive workloads. Set a single preference to coordinate model tier selection, phase skipping, and context compression:
 
 ```yaml
 token_profile: budget # or balanced (default), quality
 ```
 
-| Profile    | Savings | What It Does                                                   |
-| ---------- | ------- | -------------------------------------------------------------- |
-| `budget`   | 40-60%  | Cheap models, skip research/reassess, minimal context inlining |
-| `balanced` | 10-20%  | Default models, skip slice research, standard context          |
-| `quality`  | 0%      | All phases, all context, full model power                      |
+| Profile    | Savings | What It Does                                                                     |
+| ---------- | ------- | -------------------------------------------------------------------------------- |
+| `budget`   | 40-60%  | Light/standard tier defaults, skip research/reassess, minimal context inlining   |
+| `balanced` | 10-20%  | Standard tier for core work, light tier for simple work, standard context        |
+| `quality`  | 0%      | Heavy tier for planning, standard tier for core work, full context               |
 
-**Complexity-based routing** automatically classifies tasks as simple/standard/complex and routes to appropriate models. Simple docs tasks get Haiku; complex architectural work gets Opus. The classification is heuristic (sub-millisecond, no LLM calls) and learns from outcomes via a persistent routing history.
+**Complexity-based routing** automatically classifies tasks as simple/standard/complex and routes to appropriate available models. Token profiles define provider-agnostic tier intentions, so simple docs tasks use a light-tier configured model and complex architectural work can use a heavy-tier configured model. The classification is heuristic (sub-millisecond, no LLM calls) and learns from outcomes via a persistent routing history.
 
 **Budget pressure** graduates model downgrading as you approach your budget ceiling — 50%, 75%, and 90% thresholds progressively shift work to cheaper tiers.
 

package/dist/bundled-resource-path.d.ts

@@ -1,3 +1,10 @@
+export type FileExists = (path: string) => boolean;
+export declare function resolvePackageRoot(importUrl: string): string;
+export declare function hasCompleteBundledResources(resourcesDir: string, fileExists?: FileExists): boolean;
+export declare function resolveBundledResourcesDirFromPackageRoot(packageRoot: string, fileExists?: FileExists): string;
+export declare function resolveBundledResourcesDir(importUrl: string, fileExists?: FileExists): string;
+export declare function resolveBundledResource(importUrl: string, ...segments: string[]): string;
+export declare function resolveBundledGsdExtensionModule(importUrl: string, moduleFile: string, fileExists?: FileExists): string;
 /**
  * Resolve bundled raw resource files from the package root.
  *

package/dist/bundled-resource-path.js

@@ -1,5 +1,38 @@
+import { existsSync } from "node:fs";
 import { dirname, join, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
+export function resolvePackageRoot(importUrl) {
+    const moduleDir = dirname(fileURLToPath(importUrl));
+    return resolve(moduleDir, "..");
+}
+export function hasCompleteBundledResources(resourcesDir, fileExists = existsSync) {
+    return fileExists(join(resourcesDir, "agents")) &&
+        fileExists(join(resourcesDir, "extensions"));
+}
+export function resolveBundledResourcesDirFromPackageRoot(packageRoot, fileExists = existsSync) {
+    const distResources = join(packageRoot, "dist", "resources");
+    const srcResources = join(packageRoot, "src", "resources");
+    return hasCompleteBundledResources(distResources, fileExists)
+        ? distResources
+        : srcResources;
+}
+export function resolveBundledResourcesDir(importUrl, fileExists = existsSync) {
+    return resolveBundledResourcesDirFromPackageRoot(resolvePackageRoot(importUrl), fileExists);
+}
+export function resolveBundledResource(importUrl, ...segments) {
+    return join(resolveBundledResourcesDir(importUrl), ...segments);
+}
+export function resolveBundledGsdExtensionModule(importUrl, moduleFile, fileExists = existsSync) {
+    const packageRoot = resolvePackageRoot(importUrl);
+    const distResources = join(packageRoot, "dist", "resources");
+    const jsFile = moduleFile.replace(/\.ts$/, ".js");
+    const distModule = join(distResources, "extensions", "gsd", jsFile);
+    if (hasCompleteBundledResources(distResources, fileExists) && fileExists(distModule)) {
+        return distModule;
+    }
+    const tsFile = moduleFile.replace(/\.js$/, ".ts");
+    return join(packageRoot, "src", "resources", "extensions", "gsd", tsFile);
+}
 /**
  * Resolve bundled raw resource files from the package root.
  *
@@ -8,7 +41,6 @@ import { fileURLToPath } from "node:url";
  * `src/resources/**`, not next to the compiled entry point.
  */
 export function resolveBundledSourceResource(importUrl, ...segments) {
-    const moduleDir = dirname(fileURLToPath(importUrl));
-    const packageRoot = resolve(moduleDir, "..");
+    const packageRoot = resolvePackageRoot(importUrl);
     return join(packageRoot, "src", "resources", ...segments);
 }

package/dist/claude-cli-check.js

@@ -1,7 +1,25 @@
 // GSD2 — Claude CLI binary detection for onboarding
 // Lightweight check used at onboarding time (before extensions load).
 // The full readiness check with caching lives in the claude-code-cli extension.
+//
+// Set GSD_CLAUDE_DEBUG=1 to log probe output to stderr. Useful when
+// diagnosing platform-specific detection failures (Issue #4997).
 import { execFileSync } from 'node:child_process';
+/**
+ * Spawn the Claude CLI without triggering Node's DEP0190.
+ *
+ * Passing `args` together with `shell: true` is deprecated in Node 22+
+ * because the args are concatenated into the command string without
+ * escaping. On Windows we still need a shell to resolve `.cmd` shims, so
+ * we invoke `cmd /c <command> <args...>` explicitly. On POSIX we don't
+ * need a shell at all.
+ */
+function spawnClaude(command, args, opts) {
+    if (process.platform === 'win32') {
+        return execFileSync('cmd', ['/c', command, ...args], opts);
+    }
+    return execFileSync(command, args, opts);
+}
 /**
  * Platform-correct binary name for the Claude Code CLI.
  *
@@ -20,38 +38,40 @@ export const CLAUDE_COMMAND = process.platform === 'win32' ? 'claude.cmd' : 'cla
  * expose a bare `claude` shim. Try all three so no valid install is missed.
  */
 const CLAUDE_COMMAND_CANDIDATES = process.platform === 'win32' ? [CLAUDE_COMMAND, 'claude.exe', 'claude'] : [CLAUDE_COMMAND];
-// Codes treated as "this candidate didn't run — try the next one" rather than
-// fatal failures. ETIMEDOUT/EAGAIN cover slow-spawn cases on Windows where
-// cmd.exe wrapping plus the Claude CLI startup path together exceed the
-// per-attempt timeout (Issue #4997 regression on Windows + Node 25).
-const SOFT_FAIL_CODES = new Set(['ENOENT', 'EINVAL', 'ETIMEDOUT', 'EAGAIN']);
 const VERSION_TIMEOUT_MS = 5_000;
 // Auth probe needs more headroom on Windows because the spawn goes through
 // cmd.exe → claude.cmd → node → Claude CLI.
 const AUTH_TIMEOUT_MS = 15_000;
+function debugLog(...parts) {
+    if (process.env.GSD_CLAUDE_DEBUG) {
+        process.stderr.write(`[claude-cli-check] ${parts.map(p => (typeof p === 'string' ? p : JSON.stringify(p))).join(' ')}\n`);
+    }
+}
 /**
- * Try to run `args` against each candidate binary.
- * Returns the output buffer on first success, throws the last error if all fail.
+ * Find the first candidate that responds to `--version`. Returns the
+ * candidate name on success, null if none worked.
+ *
+ * On Windows with `shell: true`, a missing candidate surfaces as a
+ * non-zero exit from cmd.exe rather than ENOENT — so we cannot rely on
+ * the error code to decide "try next". Treat any failure as "try next"
+ * for the version probe.
  */
-function execClaudeCheck(args, timeoutMs) {
-    let lastError;
+function findWorkingCommand() {
     for (const command of CLAUDE_COMMAND_CANDIDATES) {
         try {
-            return execFileSync(command, args, {
-                timeout: timeoutMs,
+            spawnClaude(command, ['--version'], {
+                timeout: VERSION_TIMEOUT_MS,
                 stdio: 'pipe',
-                shell: process.platform === 'win32',
             });
+            debugLog('version probe ok via', command);
+            return command;
         }
         catch (error) {
-            lastError = error;
-            const code = error?.code;
-            if (code && SOFT_FAIL_CODES.has(code))
-                continue;
-            throw error;
+            debugLog('version probe failed for', command, 'code=', error?.code);
+            continue;
         }
     }
-    throw lastError ?? new Error(`Claude CLI not found (tried: ${CLAUDE_COMMAND_CANDIDATES.join(', ')})`);
+    return null;
 }
 /**
  * Decide auth state from `claude auth status` output.
@@ -62,6 +82,8 @@ function execClaudeCheck(args, timeoutMs) {
  */
 function parseAuthStatus(output) {
     const trimmed = output.trim();
+    if (!trimmed)
+        return null;
     if (trimmed.startsWith('{')) {
         try {
             const parsed = JSON.parse(trimmed);
@@ -77,35 +99,52 @@ function parseAuthStatus(output) {
     if (/not logged in|no credentials|unauthenticated|not authenticated/.test(lower)) {
         return false;
     }
-    return true;
+    if (/logged in|authenticated|signed in|email|subscription/.test(lower)) {
+        return true;
+    }
+    return null;
+}
+function probeAuth(command) {
+    // Try --json first (newer CLIs).
+    try {
+        const out = spawnClaude(command, ['auth', 'status', '--json'], {
+            timeout: AUTH_TIMEOUT_MS,
+            stdio: 'pipe',
+        }).toString();
+        debugLog('auth status --json output:', out.slice(0, 200));
+        const parsed = parseAuthStatus(out);
+        if (parsed !== null)
+            return parsed;
+    }
+    catch (error) {
+        debugLog('auth status --json threw:', error.message?.slice(0, 200));
+    }
+    // Fallback: plain `auth status` (older CLIs that don't accept --json).
+    try {
+        const out = spawnClaude(command, ['auth', 'status'], {
+            timeout: AUTH_TIMEOUT_MS,
+            stdio: 'pipe',
+        }).toString();
+        debugLog('auth status output:', out.slice(0, 200));
+        return parseAuthStatus(out);
+    }
+    catch (error) {
+        debugLog('auth status threw:', error.message?.slice(0, 200));
+        return null;
+    }
 }
 /**
  * Check if the `claude` binary is installed (regardless of auth state).
  */
 export function isClaudeBinaryInstalled() {
-    try {
-        execClaudeCheck(['--version'], VERSION_TIMEOUT_MS);
-        return true;
-    }
-    catch {
-        return false;
-    }
+    return findWorkingCommand() !== null;
 }
 /**
  * Check if the `claude` CLI is installed AND authenticated.
  */
 export function isClaudeCliReady() {
-    try {
-        execClaudeCheck(['--version'], VERSION_TIMEOUT_MS);
-    }
-    catch {
+    const command = findWorkingCommand();
+    if (!command)
         return false;
-    }
-    try {
-        const output = execClaudeCheck(['auth', 'status', '--json'], AUTH_TIMEOUT_MS).toString();
-        return parseAuthStatus(output);
-    }
-    catch {
-        return false;
-    }
+    return probeAuth(command) === true;
 }

package/dist/cli-policy.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Subcommands that must bypass the managed-resource-mismatch gate.
+ *
+ * When the synced resource manifest claims a newer gsd version than the
+ * running binary, exitIfManagedResourcesAreNewer() blocks every command
+ * with a "Version mismatch detected" diagnostic. The `update` subcommand
+ * MUST bypass that gate so the user can recover by upgrading the binary —
+ * otherwise they're stuck in a broken state with no escape hatch.
+ *
+ * Any new bypassed subcommand goes here. cli.ts dispatches on this
+ * predicate before calling exitIfManagedResourcesAreNewer().
+ */
+export declare function shouldBypassManagedResourceMismatchGate(firstMessage: string | undefined): boolean;

package/dist/cli-policy.js

@@ -0,0 +1,17 @@
+// Policy helpers for cli.ts — extracted as pure functions so they can be
+// unit-tested without executing cli.ts's top-level script body.
+/**
+ * Subcommands that must bypass the managed-resource-mismatch gate.
+ *
+ * When the synced resource manifest claims a newer gsd version than the
+ * running binary, exitIfManagedResourcesAreNewer() blocks every command
+ * with a "Version mismatch detected" diagnostic. The `update` subcommand
+ * MUST bypass that gate so the user can recover by upgrading the binary —
+ * otherwise they're stuck in a broken state with no escape hatch.
+ *
+ * Any new bypassed subcommand goes here. cli.ts dispatches on this
+ * predicate before calling exitIfManagedResourcesAreNewer().
+ */
+export function shouldBypassManagedResourceMismatchGate(firstMessage) {
+    return firstMessage === 'update';
+}

package/dist/cli.js

@@ -1,4 +1,3 @@
-import { AuthStorage, DefaultResourceLoader, ModelRegistry, runPackageCommand, SettingsManager, SessionManager, createAgentSession, InteractiveMode, runPrintMode, runRpcMode, } from '@gsd/pi-coding-agent';
 import { readFileSync } from 'node:fs';
 import { join } from 'node:path';
 import { agentDir, sessionsDir, authFilePath } from './app-paths.js';
@@ -9,6 +8,7 @@ import { migratePiCredentials } from './pi-migration.js';
 import { shouldRunOnboarding, runOnboarding } from './onboarding.js';
 import chalk from 'chalk';
 import { checkForUpdates } from './update-check.js';
+import { shouldBypassManagedResourceMismatchGate } from './cli-policy.js';
 import { printHelp, printSubcommandHelp } from './help-text.js';
 import { applySecurityOverrides } from './security-overrides.js';
 import { validateConfiguredModel } from './startup-model-validation.js';
@@ -17,8 +17,11 @@ import { buildHeadlessAutoArgs, parseCliArgs, runWebCliBranch, migrateLegacyFlat
 import { stopWebMode } from './web-mode.js';
 import { getProjectSessionsDir } from './project-sessions.js';
 import { markStartup, printStartupTimings } from './startup-timings.js';
-import { bootstrapRtk, GSD_RTK_DISABLED_ENV } from './rtk.js';
-import { loadEffectiveGSDPreferences } from './resources/extensions/gsd/preferences.js';
+import { applyRtkProcessEnv, GSD_RTK_DISABLED_ENV, isTruthy } from './rtk-shared.js';
+let piCodingAgentModulePromise;
+function loadPiCodingAgentModule() {
+    return (piCodingAgentModulePromise ??= import('@gsd/pi-coding-agent'));
+}
 // ---------------------------------------------------------------------------
 // V8 compile cache — Node 22+ can cache compiled bytecode across runs,
 // eliminating repeated parse/compile overhead for unchanged modules.
@@ -129,27 +132,53 @@ if (process.argv.includes('--help') || process.argv.includes('-h')) {
 // so concurrent callers await the same initialization.
 let rtkBootstrapPromise;
 async function doRtkBootstrap() {
+    let rtkStatus;
+    let rtkDisabled = isTruthy(process.env[GSD_RTK_DISABLED_ENV]);
     // RTK is opt-in via experimental.rtk preference. Default: disabled.
     // Honor GSD_RTK_DISABLED if already explicitly set in the environment
     // (env var takes precedence over preferences for manual override).
-    if (!process.env[GSD_RTK_DISABLED_ENV]) {
+    if (!rtkDisabled) {
+        const { loadEffectiveGSDPreferences } = await import('./resources/extensions/gsd/preferences.js');
         const prefs = loadEffectiveGSDPreferences();
         const rtkEnabled = prefs?.preferences.experimental?.rtk === true;
         if (!rtkEnabled) {
             process.env[GSD_RTK_DISABLED_ENV] = '1';
+            rtkDisabled = true;
         }
     }
-    const rtkStatus = await bootstrapRtk();
+    markStartup('rtkPreferenceCheck');
+    if (rtkDisabled) {
+        applyRtkProcessEnv(process.env);
+        rtkStatus = {
+            enabled: false,
+            supported: true,
+            available: false,
+            source: 'disabled',
+            reason: `${GSD_RTK_DISABLED_ENV} is set`,
+        };
+    }
+    else {
+        const { bootstrapRtk } = await import('./rtk.js');
+        rtkStatus = await bootstrapRtk();
+    }
     markStartup('bootstrapRtk');
     if (!rtkStatus.available && rtkStatus.supported && rtkStatus.enabled && rtkStatus.reason) {
         process.stderr.write(`[gsd] Warning: RTK unavailable — continuing without shell-command compression (${rtkStatus.reason}).\n`);
     }
 }
 function ensureRtkBootstrap() {
-    return (rtkBootstrapPromise ??= doRtkBootstrap());
-}
-// `gsd update` — update to the latest version via npm
-if (cliFlags.messages[0] === 'update') {
+    if (!rtkBootstrapPromise) {
+        markStartup('preRtkBootstrap');
+        rtkBootstrapPromise = doRtkBootstrap();
+    }
+    return rtkBootstrapPromise;
+}
+// `gsd update` — update to the latest version via npm.
+// MUST run before exitIfManagedResourcesAreNewer(): when the bundled resource
+// manifest is from a newer version than the running binary, every other
+// command is blocked — only `update` should bypass the gate so the user can
+// actually upgrade out of the broken state. See shouldBypassManagedResourceMismatchGate.
+if (shouldBypassManagedResourceMismatchGate(cliFlags.messages[0])) {
     const { runUpdate } = await import('./update-cmd.js');
     await runUpdate();
     process.exit(0);
@@ -246,20 +275,25 @@ const hasSubcommand = cliFlags.messages.length > 0;
 if (!process.stdin.isTTY && !isPrintMode && !hasSubcommand && !cliFlags.listModels && !cliFlags.web) {
     printNonTtyErrorAndExit(undefined, false);
 }
-const packageCommand = await runPackageCommand({
-    appName: 'gsd',
-    args: process.argv.slice(2),
-    cwd: process.cwd(),
-    agentDir,
-    stdout: process.stdout,
-    stderr: process.stderr,
-    allowedCommands: new Set(['install', 'remove', 'list']),
-});
-if (packageCommand.handled) {
-    process.exit(packageCommand.exitCode);
+const packageCommandNames = new Set(['install', 'remove', 'list']);
+if (packageCommandNames.has(cliFlags.messages[0])) {
+    const { runPackageCommand } = await loadPiCodingAgentModule();
+    const packageCommand = await runPackageCommand({
+        appName: 'gsd',
+        args: process.argv.slice(2),
+        cwd: process.cwd(),
+        agentDir,
+        stdout: process.stdout,
+        stderr: process.stderr,
+        allowedCommands: packageCommandNames,
+    });
+    if (packageCommand.handled) {
+        process.exit(packageCommand.exitCode);
+    }
 }
 // `gsd config` — replay the setup wizard and exit
 if (cliFlags.messages[0] === 'config') {
+    const { AuthStorage } = await loadPiCodingAgentModule();
     const authStorage = AuthStorage.create(authFilePath);
     loadStoredEnvKeys(authStorage);
     await runOnboarding(authStorage);
@@ -291,6 +325,7 @@ if (cliFlags.web || (cliFlags.messages[0] === 'web' && cliFlags.messages[1] !==
 }
 // `gsd sessions` — list past sessions and pick one to resume
 if (cliFlags.messages[0] === 'sessions') {
+    const { SessionManager } = await loadPiCodingAgentModule();
     const cwd = process.cwd();
     const safePath = `--${cwd.replace(/^[/\\]/, '').replace(/[/\\:]/g, '-')}--`;
     const projectSessionsDir = join(sessionsDir, safePath);
@@ -380,6 +415,35 @@ function flushPendingProviderRegistrations(resourceLoader, modelRegistry) {
 if (cliFlags.messages[0] === 'auto') {
     await runHeadlessFromAuto(buildHeadlessAutoArgs(cliFlags));
 }
+// ---------------------------------------------------------------------------
+// Worktree subcommand — `gsd worktree <list|merge|clean|remove>`
+// ---------------------------------------------------------------------------
+if (!isPrintMode &&
+    cliFlags.listModels === undefined &&
+    (cliFlags.messages[0] === 'worktree' || cliFlags.messages[0] === 'wt')) {
+    const { handleList, handleMerge, handleClean, handleRemove } = await import('./worktree-cli.js');
+    const sub = cliFlags.messages[1];
+    const subArgs = cliFlags.messages.slice(2);
+    if (!sub || sub === 'list') {
+        await handleList(process.cwd());
+    }
+    else if (sub === 'merge') {
+        await handleMerge(process.cwd(), subArgs);
+    }
+    else if (sub === 'clean') {
+        await handleClean(process.cwd());
+    }
+    else if (sub === 'remove' || sub === 'rm') {
+        await handleRemove(process.cwd(), subArgs);
+    }
+    else {
+        process.stderr.write(`Unknown worktree command: ${sub}\n`);
+        process.stderr.write('Commands: list, merge [name], clean, remove <name>\n');
+    }
+    process.exit(0);
+}
+const { AuthStorage, DefaultResourceLoader, ModelRegistry, SettingsManager, SessionManager, createAgentSession, InteractiveMode, runPrintMode, runRpcMode, } = await loadPiCodingAgentModule();
+markStartup('loadPiCodingAgent');
 // Pi's tool bootstrap can mis-detect already-installed fd/rg on some systems
 // because spawnSync(..., ["--version"]) returns EPERM despite a zero exit code.
 // Provision local managed binaries first so Pi sees them without probing PATH.
@@ -431,11 +495,7 @@ if (cliFlags.listModels !== undefined) {
         additionalExtensionPaths: cliFlags.extensions.length > 0 ? cliFlags.extensions : undefined,
     });
     await listModelsLoader.reload();
-    const listModelsExtensions = listModelsLoader.getExtensions();
-    for (const { name, config } of listModelsExtensions.runtime.pendingProviderRegistrations) {
-        modelRegistry.registerProvider(name, config);
-    }
-    listModelsExtensions.runtime.pendingProviderRegistrations = [];
+    flushPendingProviderRegistrations(listModelsLoader, modelRegistry);
     const models = modelRegistry.getAvailable();
     if (models.length === 0) {
         console.log('No models available. Set API keys in environment variables.');
@@ -483,6 +543,7 @@ if (!settingsManager.getQuietStartup()) {
 if (!settingsManager.getCollapseChangelog()) {
     settingsManager.setCollapseChangelog(true);
 }
+markStartup('startupSettings');
 // ---------------------------------------------------------------------------
 // Print / subagent mode — single-shot execution, no TTY required
 // ---------------------------------------------------------------------------
@@ -515,7 +576,7 @@ if (isPrintMode) {
     flushPendingProviderRegistrations(resourceLoader, modelRegistry);
     migrateAnthropicDefaultToClaudeCode({
         authStorage,
-        isClaudeCodeReady: modelRegistry.isProviderRequestReady('claude-code'),
+        isClaudeCodeReady: () => modelRegistry.isProviderRequestReady('claude-code'),
         settingsManager,
         modelRegistry,
     });
@@ -577,31 +638,6 @@ if (isPrintMode) {
     process.exit(0);
 }
 // ---------------------------------------------------------------------------
-// Worktree subcommand — `gsd worktree <list|merge|clean|remove>`
-// ---------------------------------------------------------------------------
-if (cliFlags.messages[0] === 'worktree' || cliFlags.messages[0] === 'wt') {
-    const { handleList, handleMerge, handleClean, handleRemove } = await import('./worktree-cli.js');
-    const sub = cliFlags.messages[1];
-    const subArgs = cliFlags.messages.slice(2);
-    if (!sub || sub === 'list') {
-        await handleList(process.cwd());
-    }
-    else if (sub === 'merge') {
-        await handleMerge(process.cwd(), subArgs);
-    }
-    else if (sub === 'clean') {
-        await handleClean(process.cwd());
-    }
-    else if (sub === 'remove' || sub === 'rm') {
-        await handleRemove(process.cwd(), subArgs);
-    }
-    else {
-        process.stderr.write(`Unknown worktree command: ${sub}\n`);
-        process.stderr.write('Commands: list, merge [name], clean, remove <name>\n');
-    }
-    process.exit(0);
-}
-// ---------------------------------------------------------------------------
 // Worktree flag (-w) — create/resume a worktree for the interactive session
 // ---------------------------------------------------------------------------
 if (cliFlags.worktree) {
@@ -613,11 +649,12 @@ if (cliFlags.worktree) {
 // ---------------------------------------------------------------------------
 if (!cliFlags.worktree && !isPrintMode) {
     try {
-        const { handleStatusBanner } = await import('./worktree-cli.js');
-        await handleStatusBanner(process.cwd());
+        const { showWorktreeStatusBanner } = await import('./worktree-status-banner.js');
+        showWorktreeStatusBanner(process.cwd());
     }
     catch { /* non-fatal */ }
 }
+markStartup('worktreeStatusBanner');
 // ---------------------------------------------------------------------------
 // Auto-redirect: `gsd auto` with piped stdout → headless mode (#2732)
 // When stdout is not a TTY (e.g. `gsd auto | cat`, `gsd auto > file`),
@@ -651,7 +688,9 @@ markStartup('initResources');
 // Overlap resource loading with session manager setup — both are independent.
 // resourceLoader.reload() is the most expensive step (jiti compilation), so
 // starting it early shaves ~50-200ms off interactive startup.
-const resourceLoader = buildResourceLoader(agentDir);
+const resourceLoader = await buildResourceLoader(agentDir, {
+    additionalExtensionPaths: cliFlags.extensions.length > 0 ? cliFlags.extensions : undefined,
+});
 const resourceLoadPromise = resourceLoader.reload();
 // While resources load, let session manager finish any async I/O it needs.
 // Then await the resource promise before creating the agent session.
@@ -660,10 +699,11 @@ markStartup('resourceLoader.reload');
 flushPendingProviderRegistrations(resourceLoader, modelRegistry);
 migrateAnthropicDefaultToClaudeCode({
     authStorage,
-    isClaudeCodeReady: modelRegistry.isProviderRequestReady('claude-code'),
+    isClaudeCodeReady: () => modelRegistry.isProviderRequestReady('claude-code'),
     settingsManager,
     modelRegistry,
 });
+markStartup('providerMigrations');
 const { session, extensionsResult, modelFallbackMessage: interactiveFallbackMsg } = await createAgentSession({
     authStorage,
     modelRegistry,

package/dist/headless-query.d.ts

@@ -14,6 +14,28 @@
  * bypassing the extension loader's jiti setup (#1137).
  */
 import type { GSDState } from './resources/extensions/gsd/types.js';
+/**
+ * Resolve the GSD extensions root for headless-query. Prefers the synced
+ * agent directory (so headless-query loads the same extension copy as
+ * interactive/auto modes — #3471) and falls back to the bundled source
+ * resource for source-tree dev workflows.
+ *
+ * Pure on the given inputs (env + fs probe + bundled resolver) so the
+ * #3471 contract can be exercised in tests without spawning a subprocess.
+ */
+export declare function resolveGsdAgentExtensionsDir(env?: NodeJS.ProcessEnv): string;
+/**
+ * Decide whether headless-query should load extensions from the agent
+ * sync directory (#3471) or fall back to bundled source. Returns the
+ * agent dir alongside the decision so a caller can use it directly.
+ */
+export declare function shouldUseAgentExtensionsDir(opts: {
+    env?: NodeJS.ProcessEnv;
+    fileExists?: (path: string) => boolean;
+}): {
+    agentDir: string;
+    useAgentDir: boolean;
+};
 export interface QuerySnapshot {
     state: GSDState;
     next: {

package/dist/headless-query.js

@@ -17,17 +17,52 @@ import { createJiti } from '@mariozechner/jiti';
 import { fileURLToPath } from 'node:url';
 import { join } from 'node:path';
 import { homedir } from 'node:os';
-import { resolveBundledSourceResource } from './bundled-resource-path.js';
+import { resolveBundledGsdExtensionModule } from './bundled-resource-path.js';
 const jiti = createJiti(fileURLToPath(import.meta.url), { interopDefault: true, debug: false });
-// Resolve extensions from the synced agent directory so headless-query
-// loads the same extension copy as interactive/auto modes (#3471).
-// Falls back to bundled source for source-tree dev workflows.
-const agentExtensionsDir = join(process.env.GSD_AGENT_DIR || join(homedir(), '.gsd', 'agent'), 'extensions', 'gsd');
 const { existsSync } = await import('node:fs');
-const useAgentDir = existsSync(join(agentExtensionsDir, 'state.ts'));
+/**
+ * Resolve the GSD extensions root for headless-query. Prefers the synced
+ * agent directory (so headless-query loads the same extension copy as
+ * interactive/auto modes — #3471) and falls back to the bundled source
+ * resource for source-tree dev workflows.
+ *
+ * Pure on the given inputs (env + fs probe + bundled resolver) so the
+ * #3471 contract can be exercised in tests without spawning a subprocess.
+ */
+export function resolveGsdAgentExtensionsDir(env = process.env) {
+    const agentRoot = env.GSD_AGENT_DIR || join(env.GSD_HOME || join(homedir(), '.gsd'), 'agent');
+    return join(agentRoot, 'extensions', 'gsd');
+}
+/**
+ * Decide whether headless-query should load extensions from the agent
+ * sync directory (#3471) or fall back to bundled source. Returns the
+ * agent dir alongside the decision so a caller can use it directly.
+ */
+export function shouldUseAgentExtensionsDir(opts) {
+    const env = opts.env ?? process.env;
+    const fileExists = opts.fileExists ?? existsSync;
+    const agentDir = resolveGsdAgentExtensionsDir(env);
+    return {
+        agentDir,
+        useAgentDir: fileExists(join(agentDir, 'state.ts')) || fileExists(join(agentDir, 'state.js')),
+    };
+}
+const agentExtensionsDir = resolveGsdAgentExtensionsDir();
+const { useAgentDir } = shouldUseAgentExtensionsDir({ env: process.env });
 const gsdExtensionPath = (...segments) => useAgentDir
-    ? join(agentExtensionsDir, ...segments)
-    : resolveBundledSourceResource(import.meta.url, 'extensions', 'gsd', ...segments);
+    ? resolveAgentExtensionModule(agentExtensionsDir, segments)
+    : resolveBundledGsdExtensionModule(import.meta.url, segments.join('/'));
+function resolveAgentExtensionModule(agentDir, segments) {
+    const requested = join(agentDir, ...segments);
+    if (existsSync(requested))
+        return requested;
+    if (segments.length === 1 && segments[0].endsWith('.ts')) {
+        const jsPath = join(agentDir, segments[0].replace(/\.ts$/, '.js'));
+        if (existsSync(jsPath))
+            return jsPath;
+    }
+    return requested;
+}
 async function loadExtensionModules() {
     const stateModule = await jiti.import(gsdExtensionPath('state.ts'), {});
     const dispatchModule = await jiti.import(gsdExtensionPath('auto-dispatch.ts'), {});