gsd-pi 2.78.0 → 2.78.1-dev.2d3fd6e71

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,8 @@ 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 { shouldRedirectAutoToHeadless } from './cli-auto-routing.js';
 import { printHelp, printSubcommandHelp } from './help-text.js';
 import { applySecurityOverrides } from './security-overrides.js';
 import { validateConfiguredModel } from './startup-model-validation.js';
@@ -17,8 +18,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 +133,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 +276,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 +326,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);
@@ -374,12 +410,41 @@ function flushPendingProviderRegistrations(resourceLoader, modelRegistry) {
     }
     runtime.pendingProviderRegistrations = [];
 }
-// `gsd auto [args...]` — shorthand for `gsd headless auto [args...]` (#2732)
-// Without this, `gsd auto` falls through to the interactive TUI which hangs
-// when stdin/stdout are piped (non-TTY environments).
-if (cliFlags.messages[0] === 'auto') {
+// `gsd auto [args...]` with piped stdin/stdout — shorthand for
+// `gsd headless auto [args...]` (#2732). Keep terminal TTY launches in the
+// interactive path so Warp/iTerm/Terminal retain foreground ownership.
+if (shouldRedirectAutoToHeadless(cliFlags.messages[0], process.stdin.isTTY, process.stdout.isTTY)) {
     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 +496,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 +544,7 @@ if (!settingsManager.getQuietStartup()) {
 if (!settingsManager.getCollapseChangelog()) {
     settingsManager.setCollapseChangelog(true);
 }
+markStartup('startupSettings');
 // ---------------------------------------------------------------------------
 // Print / subagent mode — single-shot execution, no TTY required
 // ---------------------------------------------------------------------------
@@ -515,7 +577,7 @@ if (isPrintMode) {
     flushPendingProviderRegistrations(resourceLoader, modelRegistry);
     migrateAnthropicDefaultToClaudeCode({
         authStorage,
-        isClaudeCodeReady: modelRegistry.isProviderRequestReady('claude-code'),
+        isClaudeCodeReady: () => modelRegistry.isProviderRequestReady('claude-code'),
         settingsManager,
         modelRegistry,
     });
@@ -577,31 +639,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,21 +650,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 */ }
 }
-// ---------------------------------------------------------------------------
-// Auto-redirect: `gsd auto` with piped stdout → headless mode (#2732)
-// When stdout is not a TTY (e.g. `gsd auto | cat`, `gsd auto > file`),
-// the TUI cannot render and the process hangs. Redirect to headless mode
-// which handles non-interactive output gracefully.
-// ---------------------------------------------------------------------------
-if (cliFlags.messages[0] === 'auto' && !process.stdout.isTTY) {
-    process.stderr.write('[gsd] stdout is not a terminal — running auto-mode in headless mode.\n');
-    await runHeadlessFromAuto(cliFlags.messages.slice(1));
-}
+markStartup('worktreeStatusBanner');
 // ---------------------------------------------------------------------------
 // Interactive mode — normal TTY session
 // ---------------------------------------------------------------------------
@@ -651,7 +679,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 +690,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'), {});

package/dist/headless-recover.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Headless Recover — `gsd headless recover`
+ *
+ * Non-interactive parallel of the `/gsd recover` slash command. Clears the
+ * milestones / slices / tasks tables and re-imports them from the on-disk
+ * markdown projections (ROADMAP.md, PLAN.md, SUMMARY.md, …) via
+ * migrateHierarchyToDb. Mutating: this is the one headless subcommand that
+ * writes to the DB. Required for CI / automation flows that need to
+ * reconcile DB state from markdown without launching an LLM session or a
+ * TTY-bound interactive runtime.
+ *
+ * Output: `gsd-recover: recovered <N>M/<N>S/<N>T hierarchy\n` to stderr on
+ * success — same marker emitted by handleRecover (commands-maintenance.ts)
+ * so callers can distinguish the success path from a silent no-op.
+ *
+ * Exit codes:
+ *   0 — recovery succeeded
+ *   1 — `.gsd/` missing, DB could not be opened, or migration threw
+ */
+export interface RecoverResult {
+    exitCode: number;
+}
+export declare function handleRecover(basePath: string): Promise<RecoverResult>;

package/dist/headless-recover.js

@@ -0,0 +1,93 @@
+// gsd-pi — Headless Recover entrypoint
+/**
+ * Headless Recover — `gsd headless recover`
+ *
+ * Non-interactive parallel of the `/gsd recover` slash command. Clears the
+ * milestones / slices / tasks tables and re-imports them from the on-disk
+ * markdown projections (ROADMAP.md, PLAN.md, SUMMARY.md, …) via
+ * migrateHierarchyToDb. Mutating: this is the one headless subcommand that
+ * writes to the DB. Required for CI / automation flows that need to
+ * reconcile DB state from markdown without launching an LLM session or a
+ * TTY-bound interactive runtime.
+ *
+ * Output: `gsd-recover: recovered <N>M/<N>S/<N>T hierarchy\n` to stderr on
+ * success — same marker emitted by handleRecover (commands-maintenance.ts)
+ * so callers can distinguish the success path from a silent no-op.
+ *
+ * Exit codes:
+ *   0 — recovery succeeded
+ *   1 — `.gsd/` missing, DB could not be opened, or migration threw
+ */
+import { createJiti } from '@mariozechner/jiti';
+import { fileURLToPath } from 'node:url';
+import { resolveGsdAgentExtensionsDir, shouldUseAgentExtensionsDir } from './headless-query.js';
+import { resolveBundledGsdExtensionModule } from './bundled-resource-path.js';
+import { join } from 'node:path';
+import { existsSync } from 'node:fs';
+const jiti = createJiti(fileURLToPath(import.meta.url), { interopDefault: true, debug: false });
+const agentExtensionsDir = resolveGsdAgentExtensionsDir();
+const { useAgentDir } = shouldUseAgentExtensionsDir({ env: process.env });
+const gsdExtensionPath = (...segments) => useAgentDir
+    ? 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 dbModule = await jiti.import(gsdExtensionPath('gsd-db.ts'), {});
+    const importerModule = await jiti.import(gsdExtensionPath('md-importer.ts'), {});
+    const dynamicToolsModule = await jiti.import(gsdExtensionPath('bootstrap/dynamic-tools.ts'), {});
+    return {
+        ensureDbOpen: dynamicToolsModule.ensureDbOpen,
+        isDbAvailable: dbModule.isDbAvailable,
+        clearEngineHierarchy: dbModule.clearEngineHierarchy,
+        transaction: dbModule.transaction,
+        migrateHierarchyToDb: importerModule.migrateHierarchyToDb,
+        invalidateStateCache: stateModule.invalidateStateCache,
+    };
+}
+export async function handleRecover(basePath) {
+    const gsdDir = join(basePath, '.gsd');
+    if (!existsSync(gsdDir)) {
+        process.stderr.write(`[headless] recover: no .gsd/ directory at ${basePath}\n`);
+        return { exitCode: 1 };
+    }
+    let modules;
+    try {
+        modules = await loadExtensionModules();
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        process.stderr.write(`[headless] recover: failed to load extension modules: ${msg}\n`);
+        return { exitCode: 1 };
+    }
+    const opened = await modules.ensureDbOpen(basePath);
+    if (!opened || !modules.isDbAvailable()) {
+        process.stderr.write(`[headless] recover: failed to open or create the GSD database at ${basePath}\n`);
+        return { exitCode: 1 };
+    }
+    let counts;
+    try {
+        counts = modules.transaction(() => {
+            modules.clearEngineHierarchy();
+            return modules.migrateHierarchyToDb(basePath);
+        });
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        process.stderr.write(`[headless] recover failed: ${msg}\n`);
+        return { exitCode: 1 };
+    }
+    modules.invalidateStateCache();
+    process.stderr.write(`gsd-recover: recovered ${counts.milestones}M/${counts.slices}S/${counts.tasks}T hierarchy\n`);
+    return { exitCode: 0 };
+}

package/dist/headless.d.ts

@@ -32,6 +32,16 @@ export interface HeadlessOptions {
     resumeSession?: string;
     bare?: boolean;
 }
+/**
+ * Commands classified as multi-turn in headless mode: they involve multiple
+ * question rounds, codebase scanning, and artifact writing before the workflow
+ * completes (#3547). Multi-turn commands suppress single-execution-complete
+ * exit and disable the default 5-minute timeout.
+ *
+ * Exported so the regression test can exercise the real classifier rather
+ * than grepping the source for identifier names.
+ */
+export declare function isMultiTurnHeadlessCommand(command: string): boolean;
 export interface ResumeSessionResult {
     session?: SessionInfo;
     error?: string;

package/dist/headless.js

@@ -21,6 +21,21 @@ import { isTerminalNotification, isBlockedNotification, isMilestoneReadyNotifica
 import { VALID_OUTPUT_FORMATS } from './headless-types.js';
 import { handleExtensionUIRequest, formatProgress, formatThinkingLine, formatTextStart, formatTextEnd, formatThinkingStart, formatThinkingEnd, startSupervisedStdinReader, } from './headless-ui.js';
 import { loadContext, bootstrapGsdProject, } from './headless-context.js';
+/**
+ * Commands classified as multi-turn in headless mode: they involve multiple
+ * question rounds, codebase scanning, and artifact writing before the workflow
+ * completes (#3547). Multi-turn commands suppress single-execution-complete
+ * exit and disable the default 5-minute timeout.
+ *
+ * Exported so the regression test can exercise the real classifier rather
+ * than grepping the source for identifier names.
+ */
+export function isMultiTurnHeadlessCommand(command) {
+    return (command === 'auto' ||
+        command === 'next' ||
+        command === 'discuss' ||
+        command === 'plan');
+}
 /**
  * Resolve a session prefix to a single session.
  * Exact id match is preferred over prefix match.
@@ -186,7 +201,7 @@ async function runHeadlessOnce(options, restartCount) {
     const isAutoMode = options.command === 'auto';
     // discuss and plan are multi-turn: they involve multiple question rounds,
     // codebase scanning, and artifact writing before the workflow completes (#3547).
-    const isMultiTurnCommand = options.command === 'auto' || options.command === 'next' || options.command === 'discuss' || options.command === 'plan';
+    const isMultiTurnCommand = isMultiTurnHeadlessCommand(options.command);
     if (isAutoMode && options.timeout === 300_000) {
         options.timeout = 0;
     }
@@ -250,6 +265,15 @@ async function runHeadlessOnce(options, restartCount) {
         const result = await handleQuery(process.cwd());
         return { exitCode: result.exitCode, interrupted: false };
     }
+    // Recover: rebuild DB hierarchy from on-disk markdown projections, no RPC
+    // child needed. This is the one mutating headless subcommand — required for
+    // CI / automation that needs to reconcile DB state from markdown without
+    // launching an interactive TTY-bound runtime.
+    if (options.command === 'recover') {
+        const { handleRecover } = await import('./headless-recover.js');
+        const result = await handleRecover(process.cwd());
+        process.exit(result.exitCode);
+    }
     // Doctor: read-only health check, no RPC child needed (#4904 live-regression).
     // The interactive `/gsd doctor` command lives in the GSD extension; this CLI
     // path lets non-interactive callers (CI, recovery scripts, the live-regression

package/dist/help-text.js

@@ -156,6 +156,7 @@ const SUBCOMMAND_HELP = {
         '  gsd headless --answers answers.json auto              With pre-supplied answers',
         '  gsd headless --events agent_end,extension_ui_request auto   Filtered event stream',
         '  gsd headless query                              Instant JSON state snapshot',
+        '  gsd headless recover                            Rebuild DB hierarchy from markdown (mutating)',
         '',
         'Exit codes: 0 = success, 1 = error/timeout, 10 = blocked, 11 = cancelled',
     ].join('\n'),

package/dist/loader.js

@@ -1,6 +1,5 @@
 #!/usr/bin/env node
 // GSD Startup Loader
-// Copyright (c) 2026 Jeremy McSpadden <jeremy@fluxlabs.net>
 import { fileURLToPath } from 'url';
 import { dirname, resolve, join, relative, delimiter } from 'path';
 import { existsSync, readFileSync, readdirSync, statSync, mkdirSync, symlinkSync, cpSync } from 'fs';
@@ -32,14 +31,14 @@ if (firstArg === '--help' || firstArg === '-h') {
 // package.json (already parsed above) and verifies git is available.
 // ---------------------------------------------------------------------------
 {
-    const MIN_NODE_MAJOR = 22;
+    const { MIN_NODE_MAJOR, checkNodeVersion, requireGit } = await import('./runtime-checks.js');
     const red = '\x1b[31m';
     const bold = '\x1b[1m';
     const dim = '\x1b[2m';
     const reset = '\x1b[0m';
     // -- Node version --
-    const nodeMajor = parseInt(process.versions.node.split('.')[0], 10);
-    if (nodeMajor < MIN_NODE_MAJOR) {
+    const nodeCheck = checkNodeVersion(process.versions.node, MIN_NODE_MAJOR);
+    if (!nodeCheck.ok) {
         process.stderr.write(`\n${red}${bold}Error:${reset} GSD requires Node.js >= ${MIN_NODE_MAJOR}.0.0\n` +
             `       You are running Node.js ${process.versions.node}\n\n` +
             `${dim}Install a supported version:${reset}\n` +
@@ -49,11 +48,9 @@ if (firstArg === '--help' || firstArg === '-h') {
         process.exit(1);
     }
     // -- git --
-    try {
-        const { execFileSync } = await import('child_process');
-        execFileSync('git', ['--version'], { stdio: 'ignore' });
-    }
-    catch {
+    const { execFileSync } = await import('child_process');
+    const gitOk = requireGit((cmd, args) => execFileSync(cmd, args, { stdio: 'ignore' }));
+    if (!gitOk) {
         process.stderr.write(`\n${red}${bold}Error:${reset} GSD requires git but it was not found on PATH.\n\n` +
             `${dim}Install git:${reset}\n` +
             `  https://git-scm.com/downloads\n\n`);
@@ -61,8 +58,9 @@ if (firstArg === '--help' || firstArg === '-h') {
     }
 }
 import { agentDir, appRoot } from './app-paths.js';
-import { applyRtkProcessEnv } from './rtk.js';
+import { applyRtkProcessEnv } from './rtk-shared.js';
 import { serializeBundledExtensionPaths } from './bundled-extension-paths.js';
+import { resolveBundledResourcesDirFromPackageRoot } from './bundled-resource-path.js';
 import { discoverExtensionEntryPaths } from './extension-discovery.js';
 import { loadRegistry, readManifestFromEntryPath, isExtensionEnabled } from './extension-registry.js';
 import { renderLogo } from './logo.js';
@@ -115,15 +113,25 @@ const { Module } = await import('module');
 Module._initPaths?.();
 // GSD_VERSION — expose package version so extensions can display it
 process.env.GSD_VERSION = gsdVersion;
-// GSD_BIN_PATH — absolute path to this loader (dist/loader.js), used by patched subagent
-// to spawn gsd instead of pi when dispatching workflow tasks
-process.env.GSD_BIN_PATH = process.argv[1];
+// GSD_BIN_PATH — absolute path to the CLI entrypoint, used by patched
+// subagent/parallel workers to spawn gsd instead of pi when dispatching
+// workflow tasks. In source-dev mode this must remain scripts/dev-cli.js, not
+// src/loader.ts, because child processes need the --import resolve-ts wrapper.
+const invokedBinPath = process.argv[1];
+const sourceLoaderPath = join(gsdRoot, 'src', 'loader.ts');
+const devCliPath = process.env.GSD_DEV_CLI_PATH?.trim() || join(gsdRoot, 'scripts', 'dev-cli.js');
+const explicitCliPath = process.env.GSD_CLI_PATH?.trim() || process.env.GSD_BIN_PATH?.trim();
+const isSourceLoader = invokedBinPath && resolve(invokedBinPath) === sourceLoaderPath;
+const rawGsdBinPath = explicitCliPath || (isSourceLoader && existsSync(devCliPath) ? devCliPath : invokedBinPath);
+const resolvedGsdBinPath = rawGsdBinPath ? resolve(rawGsdBinPath) : undefined;
+process.env.GSD_BIN_PATH = resolvedGsdBinPath;
+if (!process.env.GSD_CLI_PATH) {
+    process.env.GSD_CLI_PATH = resolvedGsdBinPath;
+}
 // GSD_WORKFLOW_PATH — absolute path to bundled GSD-WORKFLOW.md, used by patched gsd extension
 // when dispatching workflow prompts. Prefers dist/resources/ (stable, set at build time)
 // over src/resources/ (live working tree) — see resource-loader.ts for rationale.
-const distRes = join(gsdRoot, 'dist', 'resources');
-const srcRes = join(gsdRoot, 'src', 'resources');
-const resourcesDir = existsSync(distRes) ? distRes : srcRes;
+const resourcesDir = resolveBundledResourcesDirFromPackageRoot(gsdRoot);
 process.env.GSD_WORKFLOW_PATH = join(resourcesDir, 'GSD-WORKFLOW.md');
 // GSD_BUNDLED_EXTENSION_PATHS — dynamically discovered bundled extension entry points.
 // Uses the shared discoverExtensionEntryPaths() to scan the bundled resources