gsd-pi 2.78.1-dev.84a383f51 → 2.78.1

package/README.md

@@ -625,19 +625,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 tier 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 selection, phase skipping, and context compression:
 
 ```yaml
 token_profile: budget # or balanced (default), quality
 ```
 
-| 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               |
+| 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                      |
 
-**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.
+**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.
 
 **Budget pressure** graduates model downgrading as you approach your budget ceiling — 50%, 75%, and 90% thresholds progressively shift work to cheaper tiers.
 

package/dist/cli.js

@@ -1,3 +1,4 @@
+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';
@@ -8,7 +9,6 @@ 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,11 +17,8 @@ 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 { applyRtkProcessEnv, GSD_RTK_DISABLED_ENV, isTruthy } from './rtk-shared.js';
-let piCodingAgentModulePromise;
-function loadPiCodingAgentModule() {
-    return (piCodingAgentModulePromise ??= import('@gsd/pi-coding-agent'));
-}
+import { bootstrapRtk, GSD_RTK_DISABLED_ENV } from './rtk.js';
+import { loadEffectiveGSDPreferences } from './resources/extensions/gsd/preferences.js';
 // ---------------------------------------------------------------------------
 // V8 compile cache — Node 22+ can cache compiled bytecode across runs,
 // eliminating repeated parse/compile overhead for unchanged modules.
@@ -132,53 +129,27 @@ 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 (!rtkDisabled) {
-        const { loadEffectiveGSDPreferences } = await import('./resources/extensions/gsd/preferences.js');
+    if (!process.env[GSD_RTK_DISABLED_ENV]) {
         const prefs = loadEffectiveGSDPreferences();
         const rtkEnabled = prefs?.preferences.experimental?.rtk === true;
         if (!rtkEnabled) {
             process.env[GSD_RTK_DISABLED_ENV] = '1';
-            rtkDisabled = true;
         }
     }
-    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();
-    }
+    const 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() {
-    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])) {
+    return (rtkBootstrapPromise ??= doRtkBootstrap());
+}
+// `gsd update` — update to the latest version via npm
+if (cliFlags.messages[0] === 'update') {
     const { runUpdate } = await import('./update-cmd.js');
     await runUpdate();
     process.exit(0);
@@ -275,25 +246,20 @@ const hasSubcommand = cliFlags.messages.length > 0;
 if (!process.stdin.isTTY && !isPrintMode && !hasSubcommand && !cliFlags.listModels && !cliFlags.web) {
     printNonTtyErrorAndExit(undefined, false);
 }
-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);
-    }
+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);
 }
 // `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);
@@ -325,7 +291,6 @@ 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);
@@ -415,35 +380,6 @@ 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.
@@ -495,7 +431,11 @@ if (cliFlags.listModels !== undefined) {
         additionalExtensionPaths: cliFlags.extensions.length > 0 ? cliFlags.extensions : undefined,
     });
     await listModelsLoader.reload();
-    flushPendingProviderRegistrations(listModelsLoader, modelRegistry);
+    const listModelsExtensions = listModelsLoader.getExtensions();
+    for (const { name, config } of listModelsExtensions.runtime.pendingProviderRegistrations) {
+        modelRegistry.registerProvider(name, config);
+    }
+    listModelsExtensions.runtime.pendingProviderRegistrations = [];
     const models = modelRegistry.getAvailable();
     if (models.length === 0) {
         console.log('No models available. Set API keys in environment variables.');
@@ -543,7 +483,6 @@ if (!settingsManager.getQuietStartup()) {
 if (!settingsManager.getCollapseChangelog()) {
     settingsManager.setCollapseChangelog(true);
 }
-markStartup('startupSettings');
 // ---------------------------------------------------------------------------
 // Print / subagent mode — single-shot execution, no TTY required
 // ---------------------------------------------------------------------------
@@ -576,7 +515,7 @@ if (isPrintMode) {
     flushPendingProviderRegistrations(resourceLoader, modelRegistry);
     migrateAnthropicDefaultToClaudeCode({
         authStorage,
-        isClaudeCodeReady: () => modelRegistry.isProviderRequestReady('claude-code'),
+        isClaudeCodeReady: modelRegistry.isProviderRequestReady('claude-code'),
         settingsManager,
         modelRegistry,
     });
@@ -638,6 +577,31 @@ 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) {
@@ -649,12 +613,11 @@ if (cliFlags.worktree) {
 // ---------------------------------------------------------------------------
 if (!cliFlags.worktree && !isPrintMode) {
     try {
-        const { showWorktreeStatusBanner } = await import('./worktree-status-banner.js');
-        showWorktreeStatusBanner(process.cwd());
+        const { handleStatusBanner } = await import('./worktree-cli.js');
+        await handleStatusBanner(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`),
@@ -688,9 +651,7 @@ 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 = await buildResourceLoader(agentDir, {
-    additionalExtensionPaths: cliFlags.extensions.length > 0 ? cliFlags.extensions : undefined,
-});
+const resourceLoader = buildResourceLoader(agentDir);
 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.
@@ -699,11 +660,10 @@ 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,28 +14,6 @@
  * 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

@@ -19,31 +19,11 @@ import { join } from 'node:path';
 import { homedir } from 'node:os';
 import { resolveBundledSourceResource } 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');
-/**
- * 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) {
-    return join(env.GSD_AGENT_DIR || join(homedir(), '.gsd', 'agent'), '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')) };
-}
-const agentExtensionsDir = resolveGsdAgentExtensionsDir();
 const useAgentDir = existsSync(join(agentExtensionsDir, 'state.ts'));
 const gsdExtensionPath = (...segments) => useAgentDir
     ? join(agentExtensionsDir, ...segments)

package/dist/headless.d.ts

@@ -32,16 +32,6 @@ 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,21 +21,6 @@ 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.
@@ -201,7 +186,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 = isMultiTurnHeadlessCommand(options.command);
+    const isMultiTurnCommand = options.command === 'auto' || options.command === 'next' || options.command === 'discuss' || options.command === 'plan';
     if (isAutoMode && options.timeout === 300_000) {
         options.timeout = 0;
     }

package/dist/loader.js

@@ -1,5 +1,6 @@
 #!/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';
@@ -31,14 +32,14 @@ if (firstArg === '--help' || firstArg === '-h') {
 // package.json (already parsed above) and verifies git is available.
 // ---------------------------------------------------------------------------
 {
-    const { MIN_NODE_MAJOR, checkNodeVersion, requireGit } = await import('./runtime-checks.js');
+    const MIN_NODE_MAJOR = 22;
     const red = '\x1b[31m';
     const bold = '\x1b[1m';
     const dim = '\x1b[2m';
     const reset = '\x1b[0m';
     // -- Node version --
-    const nodeCheck = checkNodeVersion(process.versions.node, MIN_NODE_MAJOR);
-    if (!nodeCheck.ok) {
+    const nodeMajor = parseInt(process.versions.node.split('.')[0], 10);
+    if (nodeMajor < MIN_NODE_MAJOR) {
         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` +
@@ -48,9 +49,11 @@ if (firstArg === '--help' || firstArg === '-h') {
         process.exit(1);
     }
     // -- git --
-    const { execFileSync } = await import('child_process');
-    const gitOk = requireGit((cmd, args) => execFileSync(cmd, args, { stdio: 'ignore' }));
-    if (!gitOk) {
+    try {
+        const { execFileSync } = await import('child_process');
+        execFileSync('git', ['--version'], { stdio: 'ignore' });
+    }
+    catch {
         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`);
@@ -58,7 +61,7 @@ if (firstArg === '--help' || firstArg === '-h') {
     }
 }
 import { agentDir, appRoot } from './app-paths.js';
-import { applyRtkProcessEnv } from './rtk-shared.js';
+import { applyRtkProcessEnv } from './rtk.js';
 import { serializeBundledExtensionPaths } from './bundled-extension-paths.js';
 import { discoverExtensionEntryPaths } from './extension-discovery.js';
 import { loadRegistry, readManifestFromEntryPath, isExtensionEnabled } from './extension-registry.js';

package/dist/onboarding.d.ts

@@ -24,16 +24,6 @@ interface RunOnboardingOptions {
     /** Show logo + intro banner. Disable when onboarding is launched inside an active TUI session. */
     showIntro?: boolean;
 }
-export declare const OTHER_PROVIDERS: ({
-    value: string;
-    label: string;
-    hint: string;
-} | {
-    value: string;
-    label: string;
-    hint?: undefined;
-})[];
-export declare function detectNativeProviderFromBaseUrl(baseUrl: string): 'minimax' | 'minimax-cn' | null;
 /**
  * Determine if the onboarding wizard should run.
  *

package/dist/onboarding.js

@@ -54,7 +54,7 @@ const API_KEY_PREFIXES = {
     anthropic: ['sk-ant-'],
     openai: ['sk-'],
 };
-export const OTHER_PROVIDERS = [
+const OTHER_PROVIDERS = [
     { value: 'google', label: 'Google (Gemini)', hint: 'aistudio.google.com/app/apikey' },
     { value: 'groq', label: 'Groq', hint: 'console.groq.com/keys' },
     { value: 'xai', label: 'xAI (Grok)', hint: 'console.x.ai' },
@@ -148,7 +148,7 @@ function persistDefaultModel(modelId) {
         // Non-fatal: startup fallback logic will still run.
     }
 }
-export function detectNativeProviderFromBaseUrl(baseUrl) {
+function detectNativeProviderFromBaseUrl(baseUrl) {
     try {
         const hostname = new URL(baseUrl).hostname.toLowerCase();
         if (hostname === 'api.minimax.io' || hostname.endsWith('.minimax.io')) {

package/dist/provider-migrations.d.ts

@@ -1,7 +1,7 @@
 import type { AuthStorage } from "@gsd/pi-coding-agent";
 type AnthropicMigrationDeps = {
     authStorage: Pick<AuthStorage, "getCredentialsForProvider">;
-    isClaudeCodeReady: boolean | (() => boolean);
+    isClaudeCodeReady: boolean;
     defaultProvider: string | undefined;
     env?: NodeJS.ProcessEnv;
 };
@@ -11,7 +11,7 @@ type MigrationModel = {
 };
 type AnthropicDefaultMigrationDeps = {
     authStorage: Pick<AuthStorage, "getCredentialsForProvider">;
-    isClaudeCodeReady: boolean | (() => boolean);
+    isClaudeCodeReady: boolean;
     settingsManager: {
         getDefaultProvider(): string | undefined;
         getDefaultModel(): string | undefined;

package/dist/provider-migrations.js

@@ -5,13 +5,10 @@ export function hasDirectAnthropicApiKey(authStorage, env = process.env) {
     return authStorage.getCredentialsForProvider("anthropic").some((credential) => credential?.type === "api_key" && typeof credential?.key === "string" && credential.key.trim().length > 0);
 }
 export function shouldMigrateAnthropicToClaudeCode({ authStorage, isClaudeCodeReady, defaultProvider, env = process.env, }) {
-    if (defaultProvider !== "anthropic") {
+    if (!isClaudeCodeReady || defaultProvider !== "anthropic") {
         return false;
     }
-    if (hasDirectAnthropicApiKey(authStorage, env)) {
-        return false;
-    }
-    return typeof isClaudeCodeReady === "function" ? isClaudeCodeReady() : isClaudeCodeReady;
+    return !hasDirectAnthropicApiKey(authStorage, env);
 }
 export function migrateAnthropicDefaultToClaudeCode({ authStorage, isClaudeCodeReady, settingsManager, modelRegistry, env = process.env, }) {
     const defaultProvider = settingsManager.getDefaultProvider();

package/dist/resource-loader.d.ts

@@ -1,4 +1,4 @@
-import type { DefaultResourceLoader as DefaultResourceLoaderType } from '@gsd/pi-coding-agent';
+import { DefaultResourceLoader } from '@gsd/pi-coding-agent';
 export { discoverExtensionEntryPaths } from './extension-discovery.js';
 export declare function getExtensionKey(entryPath: string, extensionsDir: string): string;
 export declare function readManagedResourceVersion(agentDir: string): string | null;
@@ -63,7 +63,4 @@ export declare function mergedFingerprint(hoisted: string, internal: string): st
  */
 export declare function initResources(agentDir: string, skillsDir?: string): void;
 export declare function hasStaleCompiledExtensionSiblings(extensionsDir: string, sourceDir?: string): boolean;
-interface BuildResourceLoaderOptions {
-    additionalExtensionPaths?: string[];
-}
-export declare function buildResourceLoader(agentDir: string, options?: BuildResourceLoaderOptions): Promise<DefaultResourceLoaderType>;
+export declare function buildResourceLoader(agentDir: string): DefaultResourceLoader;

package/dist/resource-loader.js

@@ -1,3 +1,4 @@
+import { DefaultResourceLoader, sortExtensionPaths } from '@gsd/pi-coding-agent';
 import { createHash } from 'node:crypto';
 import { homedir } from 'node:os';
 import { chmodSync, copyFileSync, cpSync, existsSync, lstatSync, mkdirSync, openSync, closeSync, readFileSync, readlinkSync, readdirSync, rmSync, statSync, symlinkSync, unlinkSync, writeFileSync } from 'node:fs';
@@ -6,10 +7,6 @@ import { fileURLToPath } from 'node:url';
 import { compareSemver } from './update-check.js';
 import { discoverExtensionEntryPaths } from './extension-discovery.js';
 import { loadRegistry, readManifestFromEntryPath, isExtensionEnabled, ensureRegistryEntries } from './extension-registry.js';
-let piCodingAgentModulePromise;
-function loadPiCodingAgentModule() {
-    return (piCodingAgentModulePromise ??= import('@gsd/pi-coding-agent'));
-}
 // Resolve resources directory — prefer dist/resources/ (stable, set at build time)
 // over src/resources/ (live working tree, changes with git branch).
 //
@@ -29,7 +26,6 @@ const resourcesDir = (existsSync(distResources) && existsSync(join(distResources
     : srcResources;
 const bundledExtensionsDir = join(resourcesDir, 'extensions');
 const resourceVersionManifestName = 'managed-resources.json';
-const resourceFingerprintFileName = '.managed-resources-content-hash';
 export { discoverExtensionEntryPaths } from './extension-discovery.js';
 export function getExtensionKey(entryPath, extensionsDir) {
     const relPath = relative(extensionsDir, entryPath);
@@ -81,7 +77,7 @@ function writeManagedResourceManifest(agentDir) {
     const manifest = {
         gsdVersion: getBundledGsdVersion(),
         syncedAt: Date.now(),
-        contentHash: getCurrentResourceFingerprint(),
+        contentHash: computeResourceFingerprint(),
         installedExtensionRootFiles,
         installedExtensionDirs,
     };
@@ -129,24 +125,10 @@ export function computeResourceFingerprint(rootDir = resourcesDir) {
     entries.sort();
     return createHash('sha256').update(entries.join('\n')).digest('hex').slice(0, 16);
 }
-function getCurrentResourceFingerprint() {
-    try {
-        const precomputed = readFileSync(join(resourcesDir, resourceFingerprintFileName), 'utf-8').trim();
-        if (/^[a-f0-9]{16}$/i.test(precomputed)) {
-            return precomputed;
-        }
-    }
-    catch {
-        // Source-tree and partial-build workflows may not have a precomputed hash.
-    }
-    return computeResourceFingerprint();
-}
 function collectFileEntries(dir, root, out) {
     if (!existsSync(dir))
         return;
     for (const entry of readdirSync(dir, { withFileTypes: true })) {
-        if (entry.name === resourceFingerprintFileName)
-            continue;
         const fullPath = join(dir, entry.name);
         if (entry.isDirectory()) {
             collectFileEntries(fullPath, root, out);
@@ -566,7 +548,7 @@ export function initResources(agentDir, skillsDir = join(homedir(), '.agents', '
     // hotfixes within a release). The content hash catches those at ~1ms cost.
     if (manifest && manifest.gsdVersion === currentVersion) {
         // Version matches — check content fingerprint for same-version staleness.
-        const currentHash = getCurrentResourceFingerprint();
+        const currentHash = computeResourceFingerprint();
         const hasStaleExtensionFiles = hasStaleCompiledExtensionSiblings(extensionsDir, bundledExtensionsDir);
         if (manifest.contentHash && manifest.contentHash === currentHash && !hasStaleExtensionFiles) {
             return;
@@ -754,8 +736,7 @@ function getBundledExtensionKeys() {
     }
     return _bundledExtensionKeys;
 }
-export async function buildResourceLoader(agentDir, options = {}) {
-    const { DefaultResourceLoader, sortExtensionPaths } = await loadPiCodingAgentModule();
+export function buildResourceLoader(agentDir) {
     const registry = loadRegistry();
     const piAgentDir = join(homedir(), '.pi', 'agent');
     const piExtensionsDir = join(piAgentDir, 'extensions');
@@ -768,13 +749,9 @@ export async function buildResourceLoader(agentDir, options = {}) {
             return true;
         return isExtensionEnabled(registry, manifest.id);
     });
-    const additionalExtensionPaths = [
-        ...piExtensionPaths,
-        ...(options.additionalExtensionPaths ?? []),
-    ];
     return new DefaultResourceLoader({
         agentDir,
-        additionalExtensionPaths,
+        additionalExtensionPaths: piExtensionPaths,
         bundledExtensionKeys: bundledKeys,
         extensionPathsTransform: (paths) => {
             // 1. Filter community extensions through the GSD registry