lsd-pi 1.1.2 → 1.1.3

package/README.md

@@ -242,7 +242,8 @@ A few quality-of-life touches in the TUI:
 
 - the footer can show a live cache timer for the current prompt-cache window
 - `/hotkeys` gives you a full shortcut reference on demand
-- `/settings` now includes toggles for Codex rotate, the cache timer, and RTK shell-command compression
+- `/settings` now includes toggles for Codex rotate, the cache timer, RTK shell-command compression, and a configurable **Main accent** preset
+- changing the main accent also updates accent-driven UI elements and the text input border across thinking levels
 
 Some workflow/automation commands still use the legacy namespace:
 

package/dist/bedrock-auth.d.ts

@@ -0,0 +1,25 @@
+import type { AuthStorage } from '@gsd/pi-coding-agent';
+export declare const BEDROCK_PROVIDER_ID = "amazon-bedrock";
+export type BedrockCredentialInput = {
+    authType: 'sso';
+    profile: string;
+    region: string;
+} | {
+    authType: 'access-key';
+    accessKeyId: string;
+    secretAccessKey: string;
+    region: string;
+};
+export type BedrockStoredCredential = ({
+    version: 1;
+} & Extract<BedrockCredentialInput, {
+    authType: 'sso';
+}>) | ({
+    version: 1;
+} & Extract<BedrockCredentialInput, {
+    authType: 'access-key';
+}>);
+export declare function encodeBedrockCredential(credential: BedrockCredentialInput): string;
+export declare function decodeBedrockCredential(value: string): BedrockStoredCredential | null;
+export declare function applyBedrockCredentialToEnv(credential: BedrockStoredCredential): void;
+export declare function saveBedrockCredential(authStorage: AuthStorage, credential: BedrockCredentialInput): void;

package/dist/bedrock-auth.js

@@ -0,0 +1,59 @@
+export const BEDROCK_PROVIDER_ID = 'amazon-bedrock';
+export function encodeBedrockCredential(credential) {
+    return JSON.stringify({ version: 1, ...credential });
+}
+export function decodeBedrockCredential(value) {
+    try {
+        const parsed = JSON.parse(value);
+        if (parsed.version !== 1 || typeof parsed.region !== 'string' || !parsed.region.trim()) {
+            return null;
+        }
+        if (parsed.authType === 'sso' && typeof parsed.profile === 'string' && parsed.profile.trim()) {
+            return {
+                version: 1,
+                authType: 'sso',
+                profile: parsed.profile.trim(),
+                region: parsed.region.trim(),
+            };
+        }
+        if (parsed.authType === 'access-key' &&
+            typeof parsed.accessKeyId === 'string' &&
+            typeof parsed.secretAccessKey === 'string' &&
+            parsed.accessKeyId.trim() &&
+            parsed.secretAccessKey.trim()) {
+            return {
+                version: 1,
+                authType: 'access-key',
+                accessKeyId: parsed.accessKeyId.trim(),
+                secretAccessKey: parsed.secretAccessKey.trim(),
+                region: parsed.region.trim(),
+            };
+        }
+    }
+    catch {
+        // Ignore malformed or legacy plain-text values.
+    }
+    return null;
+}
+function clearBedrockEnv() {
+    delete process.env.AWS_PROFILE;
+    delete process.env.AWS_ACCESS_KEY_ID;
+    delete process.env.AWS_SECRET_ACCESS_KEY;
+}
+export function applyBedrockCredentialToEnv(credential) {
+    clearBedrockEnv();
+    process.env.AWS_REGION = credential.region;
+    process.env.AWS_DEFAULT_REGION = credential.region;
+    if (credential.authType === 'sso') {
+        process.env.AWS_PROFILE = credential.profile;
+        return;
+    }
+    process.env.AWS_ACCESS_KEY_ID = credential.accessKeyId;
+    process.env.AWS_SECRET_ACCESS_KEY = credential.secretAccessKey;
+}
+export function saveBedrockCredential(authStorage, credential) {
+    const encoded = encodeBedrockCredential(credential);
+    authStorage.remove(BEDROCK_PROVIDER_ID);
+    authStorage.set(BEDROCK_PROVIDER_ID, { type: 'api_key', key: encoded });
+    applyBedrockCredentialToEnv({ version: 1, ...credential });
+}

package/dist/headless.js

@@ -184,7 +184,8 @@ async function runHeadlessOnce(options, restartCount) {
     // per-unit timeout via auto-supervisor. Disable the overall timeout unless the
     // user explicitly set --timeout.
     const isAutoMode = options.command === 'auto';
-    const isMultiTurnCommand = options.command === 'auto' || options.command === 'next';
+    let isMultiTurnCommand = options.command === 'auto' || options.command === 'next';
+    let isSingleTurnContextRun = false;
     if (isAutoMode && options.timeout === 300_000) {
         options.timeout = 0;
     }
@@ -213,6 +214,10 @@ async function runHeadlessOnce(options, restartCount) {
     if (options.context || options.contextText) {
         try {
             contextContent = await loadContext(options);
+            isSingleTurnContextRun = !!(options.bare && contextContent);
+            if (isSingleTurnContextRun) {
+                isMultiTurnCommand = false;
+            }
         }
         catch (err) {
             process.stderr.write(`[headless] Error loading context: ${err instanceof Error ? err.message : String(err)}\n`);
@@ -591,8 +596,8 @@ async function runHeadlessOnce(options, restartCount) {
                 return;
             }
         }
-        // Quick commands: resolve on first agent_end
-        if (eventObj.type === 'agent_end' && isQuickCommand(options.command) && !completed) {
+        // Quick commands and bare+context runs: resolve on first agent_end
+        if (eventObj.type === 'agent_end' && (isQuickCommand(options.command) || isSingleTurnContextRun) && !completed) {
             completed = true;
             resolveCompletion();
             return;

package/dist/loader.js

@@ -142,6 +142,7 @@ const discoveredExtensionPaths = discoverExtensionEntryPaths(bundledExtDir)
     return isExtensionEnabled(registry, manifest.id, manifest.defaultEnabled ?? true);
 });
 process.env.LSD_BUNDLED_EXTENSION_PATHS = serializeBundledExtensionPaths(discoveredExtensionPaths);
+process.env.GSD_BUNDLED_EXTENSION_PATHS = process.env.LSD_BUNDLED_EXTENSION_PATHS;
 // Respect HTTP_PROXY / HTTPS_PROXY / NO_PROXY env vars for all outbound requests.
 // pi-coding-agent's cli.ts sets this, but GSD bypasses that entry point — so we
 // must set it here before any SDK clients are created.

package/dist/onboarding-llm.d.ts

@@ -0,0 +1,37 @@
+import type { AuthStorage } from '@gsd/pi-coding-agent';
+export { BEDROCK_PROVIDER_ID } from './bedrock-auth.js';
+export type LlmProviderOption = {
+    value: string;
+    label: string;
+    hint?: string;
+};
+export declare const LLM_PROVIDER_IDS: string[];
+export declare const BUDGET_MODEL_OPTIONS: {
+    value: string;
+    label: string;
+    hint: string;
+}[];
+export declare function getOtherLlmProviders(): ({
+    readonly value: "google";
+    readonly label: "Google (Gemini)";
+} | {
+    readonly value: "groq";
+    readonly label: "Groq";
+} | {
+    readonly value: "xai";
+    readonly label: "xAI (Grok)";
+} | {
+    readonly value: "openrouter";
+    readonly label: "OpenRouter";
+} | {
+    readonly value: "mistral";
+    readonly label: "Mistral";
+} | {
+    readonly value: "ollama-cloud";
+    readonly label: "Ollama Cloud";
+} | {
+    readonly value: "custom-openai";
+    readonly label: "Custom (OpenAI-compatible)";
+})[];
+export declare function getLlmProviderOptions(method: 'browser' | 'api-key'): LlmProviderOption[];
+export declare function shouldRunOnboarding(authStorage: AuthStorage, settingsDefaultProvider?: string): boolean;

package/dist/onboarding-llm.js

@@ -0,0 +1,64 @@
+import { BEDROCK_PROVIDER_ID } from './bedrock-auth.js';
+export { BEDROCK_PROVIDER_ID } from './bedrock-auth.js';
+export const LLM_PROVIDER_IDS = [
+    'anthropic',
+    'anthropic-vertex',
+    'openai',
+    'github-copilot',
+    'openai-codex',
+    'google-gemini-cli',
+    'google-antigravity',
+    'google',
+    'groq',
+    'xai',
+    'openrouter',
+    'mistral',
+    'ollama-cloud',
+    'custom-openai',
+    BEDROCK_PROVIDER_ID,
+];
+const OTHER_PROVIDERS = [
+    { value: 'google', label: 'Google (Gemini)' },
+    { value: 'groq', label: 'Groq' },
+    { value: 'xai', label: 'xAI (Grok)' },
+    { value: 'openrouter', label: 'OpenRouter' },
+    { value: 'mistral', label: 'Mistral' },
+    { value: 'ollama-cloud', label: 'Ollama Cloud' },
+    { value: 'custom-openai', label: 'Custom (OpenAI-compatible)' },
+];
+export const BUDGET_MODEL_OPTIONS = [
+    { value: 'anthropic/claude-haiku-4-5', label: 'Claude Haiku 4.5', hint: 'recommended for scout/subagents' },
+    { value: 'google/gemini-2.5-flash', label: 'Gemini 2.5 Flash', hint: 'fast and cheap' },
+    { value: 'google/gemini-3-flash-preview', label: 'Gemini 3 Flash Preview', hint: 'newer flash option' },
+    { value: 'openai/gpt-4.1-mini', label: 'GPT-4.1 mini', hint: 'small general-purpose option' },
+    { value: 'openai/gpt-5.4-mini', label: 'GPT-5.4 mini', hint: 'fast and cheap — OpenAI' },
+];
+export function getOtherLlmProviders() {
+    return [...OTHER_PROVIDERS];
+}
+export function getLlmProviderOptions(method) {
+    if (method === 'browser') {
+        return [
+            { value: 'anthropic', label: 'Anthropic (Claude)', hint: 'recommended' },
+            { value: 'github-copilot', label: 'GitHub Copilot' },
+            { value: 'openai-codex', label: 'ChatGPT Plus/Pro (Codex)' },
+            { value: BEDROCK_PROVIDER_ID, label: 'AWS SSO Login', hint: 'Amazon Bedrock via aws sso login' },
+            { value: 'google-gemini-cli', label: 'Google Gemini CLI' },
+            { value: 'google-antigravity', label: 'Antigravity (Gemini 3, Claude, GPT-OSS)' },
+        ];
+    }
+    return [
+        { value: 'anthropic', label: 'Anthropic (Claude)' },
+        { value: 'openai', label: 'OpenAI' },
+        { value: BEDROCK_PROVIDER_ID, label: 'Amazon Bedrock', hint: 'AWS access key + region' },
+        ...OTHER_PROVIDERS.map(op => ({ value: op.value, label: op.label })),
+    ];
+}
+export function shouldRunOnboarding(authStorage, settingsDefaultProvider) {
+    if (!process.stdin.isTTY)
+        return false;
+    if (settingsDefaultProvider)
+        return false;
+    const hasLlmAuth = LLM_PROVIDER_IDS.some(id => authStorage.hasAuth(id));
+    return !hasLlmAuth;
+}

package/dist/onboarding.d.ts

@@ -10,20 +10,8 @@
  * All steps are skippable. All errors are recoverable. Never crashes boot.
  */
 import type { AuthStorage, SettingsManager } from '@gsd/pi-coding-agent';
-/**
- * Determine if the onboarding wizard should run.
- *
- * Returns true when:
- * - No LLM provider auth is available
- * - We're on a TTY (interactive terminal)
- *
- * Returns false (skip wizard) when:
- * - Any LLM provider is already available via auth.json, env vars, runtime overrides, or fallback auth
- * - A default provider is already configured in settings (covers extension-based providers
- *   that may not require credentials in auth.json)
- * - Not a TTY (piped input, subagent, CI)
- */
-export declare function shouldRunOnboarding(authStorage: AuthStorage, settingsDefaultProvider?: string): boolean;
+export { BEDROCK_PROVIDER_ID, saveBedrockCredential } from './bedrock-auth.js';
+export { BUDGET_MODEL_OPTIONS, getLlmProviderOptions, LLM_PROVIDER_IDS, shouldRunOnboarding } from './onboarding-llm.js';
 /**
  * Run the unified onboarding wizard.
  *

package/dist/onboarding.js

@@ -9,9 +9,13 @@
  *
  * All steps are skippable. All errors are recoverable. Never crashes boot.
  */
-import { execFile } from 'node:child_process';
+import { execFile, spawnSync } from 'node:child_process';
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
 import { dirname, join } from 'node:path';
+import { BEDROCK_PROVIDER_ID, saveBedrockCredential } from './bedrock-auth.js';
+export { BEDROCK_PROVIDER_ID, saveBedrockCredential } from './bedrock-auth.js';
+import { BUDGET_MODEL_OPTIONS, getLlmProviderOptions, getOtherLlmProviders, LLM_PROVIDER_IDS } from './onboarding-llm.js';
+export { BUDGET_MODEL_OPTIONS, getLlmProviderOptions, LLM_PROVIDER_IDS, shouldRunOnboarding } from './onboarding-llm.js';
 import { renderLogo } from './logo.js';
 import { agentDir } from './app-paths.js';
 import { accentAnsi } from './cli-theme.js';
@@ -37,37 +41,11 @@ const TOOL_KEYS = [
         hint: 'voice transcription — free at console.groq.com',
     },
 ];
-/** Known LLM provider IDs that, if authed, mean the user doesn't need onboarding */
-const LLM_PROVIDER_IDS = [
-    'anthropic',
-    'anthropic-vertex',
-    'openai',
-    'github-copilot',
-    'openai-codex',
-    'google-gemini-cli',
-    'google-antigravity',
-    'google',
-    'groq',
-    'xai',
-    'openrouter',
-    'mistral',
-    'ollama-cloud',
-    'custom-openai',
-];
 /** API key prefix validation — loose checks to catch obvious mistakes */
 const API_KEY_PREFIXES = {
     anthropic: ['sk-ant-'],
     openai: ['sk-'],
 };
-const OTHER_PROVIDERS = [
-    { value: 'google', label: 'Google (Gemini)' },
-    { value: 'groq', label: 'Groq' },
-    { value: 'xai', label: 'xAI (Grok)' },
-    { value: 'openrouter', label: 'OpenRouter' },
-    { value: 'mistral', label: 'Mistral' },
-    { value: 'ollama-cloud', label: 'Ollama Cloud' },
-    { value: 'custom-openai', label: 'Custom (OpenAI-compatible)' },
-];
 const CLASSIFIER_MODEL_OPTIONS = [
     { value: 'anthropic/claude-haiku-4-5', label: 'Claude Haiku 4.5', hint: 'fast default' },
     { value: 'anthropic/claude-sonnet-4-5', label: 'Claude Sonnet 4.5', hint: 'stronger reasoning' },
@@ -76,12 +54,6 @@ const CLASSIFIER_MODEL_OPTIONS = [
     { value: 'google/gemini-3-flash-preview', label: 'Gemini 3 Flash Preview', hint: 'newer flash option' },
     { value: 'google/gemini-3.1-pro-preview', label: 'Gemini 3.1 Pro Preview', hint: 'newer pro option' },
 ];
-const BUDGET_MODEL_OPTIONS = [
-    { value: 'anthropic/claude-haiku-4-5', label: 'Claude Haiku 4.5', hint: 'recommended for scout/subagents' },
-    { value: 'google/gemini-2.5-flash', label: 'Gemini 2.5 Flash', hint: 'fast and cheap' },
-    { value: 'google/gemini-3-flash-preview', label: 'Gemini 3 Flash Preview', hint: 'newer flash option' },
-    { value: 'openai/gpt-4.1-mini', label: 'GPT-4.1 mini', hint: 'small general-purpose option' },
-];
 // ─── Dynamic imports ──────────────────────────────────────────────────────────
 /**
  * Dynamically import @clack/prompts and picocolors.
@@ -122,29 +94,47 @@ function openBrowser(url) {
 function isCancelError(p, err) {
     return p.isCancel(err);
 }
-// ─── Public API ───────────────────────────────────────────────────────────────
-/**
- * Determine if the onboarding wizard should run.
- *
- * Returns true when:
- * - No LLM provider auth is available
- * - We're on a TTY (interactive terminal)
- *
- * Returns false (skip wizard) when:
- * - Any LLM provider is already available via auth.json, env vars, runtime overrides, or fallback auth
- * - A default provider is already configured in settings (covers extension-based providers
- *   that may not require credentials in auth.json)
- * - Not a TTY (piped input, subagent, CI)
- */
-export function shouldRunOnboarding(authStorage, settingsDefaultProvider) {
-    if (!process.stdin.isTTY)
-        return false;
-    if (settingsDefaultProvider)
-        return false;
-    // Check if any LLM provider has credentials
-    const hasLlmAuth = LLM_PROVIDER_IDS.some(id => authStorage.hasAuth(id));
-    return !hasLlmAuth;
+function getAwsCliInstallInstructions() {
+    if (process.platform === 'darwin') {
+        return 'Install the AWS CLI with `brew install awscli` or from https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html';
+    }
+    if (process.platform === 'win32') {
+        return 'Install the AWS CLI MSI from https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html';
+    }
+    return 'Install the AWS CLI from https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html';
+}
+function ensureAwsCliInstalled() {
+    const result = spawnSync('aws', ['--version'], { encoding: 'utf-8' });
+    if (result.error && 'code' in result.error && result.error.code === 'ENOENT') {
+        return `AWS CLI not found. ${getAwsCliInstallInstructions()}`;
+    }
+    return null;
+}
+function saveAwsAuthRefreshCommand(profile) {
+    const settingsPath = join(agentDir, 'settings.json');
+    let settings = {};
+    if (existsSync(settingsPath)) {
+        try {
+            settings = JSON.parse(readFileSync(settingsPath, 'utf-8'));
+        }
+        catch {
+            settings = {};
+        }
+    }
+    settings.awsAuthRefresh = `aws sso login --profile ${profile}`;
+    mkdirSync(dirname(settingsPath), { recursive: true });
+    writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + '\n', 'utf-8');
 }
+function validateAwsRegion(region) {
+    const trimmed = region?.trim();
+    if (!trimmed)
+        return 'AWS region is required';
+    if (!/^[a-z]{2}(?:-gov)?-[a-z0-9-]+-\d+$/.test(trimmed)) {
+        return 'Use a valid AWS region like us-east-1';
+    }
+    return undefined;
+}
+// ─── Public API ───────────────────────────────────────────────────────────────
 /**
  * Run the unified onboarding wizard.
  *
@@ -171,7 +161,7 @@ export async function runOnboarding(authStorage, settingsManager) {
     }
     // ── Intro ─────────────────────────────────────────────────────────────────
     process.stderr.write(renderLogo(accentAnsi));
-    p.intro(pc.bold('Welcome to LSD — let\'s get you set up'));
+    p.intro(accentAnsi(pc.bold('Welcome to LSD')) + pc.bold(' — let\'s get you set up'));
     // ── LLM Provider Selection ────────────────────────────────────────────────
     let llmConfigured = false;
     try {
@@ -314,8 +304,8 @@ export async function runOnboarding(authStorage, settingsManager) {
     else {
         summaryLines.push(`${pc.green('✓')} Language servers: ${lspInstalled.join(', ')} (${lspInstalled.length} installed)`);
     }
-    p.note(summaryLines.join('\n'), 'Setup complete');
-    p.outro(pc.dim('Launching LSD...'));
+    p.note(summaryLines.join('\n'), accentAnsi('Setup complete'));
+    p.outro(accentAnsi('Launching LSD...'));
 }
 async function runClassifierModelStep(p, pc, settingsManager) {
     const existing = settingsManager.getClassifierModel();
@@ -467,35 +457,32 @@ async function runLlmStep(p, pc, authStorage) {
     if (method === 'browser') {
         const provider = await p.select({
             message: 'Choose provider',
-            options: [
-                { value: 'anthropic', label: 'Anthropic (Claude)', hint: 'recommended' },
-                { value: 'github-copilot', label: 'GitHub Copilot' },
-                { value: 'openai-codex', label: 'ChatGPT Plus/Pro (Codex)' },
-                { value: 'google-gemini-cli', label: 'Google Gemini CLI' },
-                { value: 'google-antigravity', label: 'Antigravity (Gemini 3, Claude, GPT-OSS)' },
-            ],
+            options: getLlmProviderOptions('browser'),
         });
         if (p.isCancel(provider))
             return false;
+        if (provider === BEDROCK_PROVIDER_ID) {
+            return await runBedrockSsoFlow(p, pc, authStorage);
+        }
         return await runOAuthFlow(p, pc, authStorage, provider, oauthMap);
     }
     if (method === 'api-key') {
         const provider = await p.select({
             message: 'Choose provider',
-            options: [
-                { value: 'anthropic', label: 'Anthropic (Claude)' },
-                { value: 'openai', label: 'OpenAI' },
-                ...OTHER_PROVIDERS.map(op => ({ value: op.value, label: op.label })),
-            ],
+            options: getLlmProviderOptions('api-key'),
         });
         if (p.isCancel(provider))
             return false;
         if (provider === 'custom-openai') {
             return await runCustomOpenAIFlow(p, pc, authStorage);
         }
+        if (provider === BEDROCK_PROVIDER_ID) {
+            return await runBedrockApiKeyFlow(p, pc, authStorage);
+        }
+        const otherProviders = getOtherLlmProviders();
         const label = provider === 'anthropic' ? 'Anthropic'
             : provider === 'openai' ? 'OpenAI'
-                : OTHER_PROVIDERS.find(op => op.value === provider)?.label ?? String(provider);
+                : otherProviders.find(op => op.value === provider)?.label ?? String(provider);
         return await runApiKeyFlow(p, pc, authStorage, provider, label);
     }
     return false;
@@ -563,6 +550,94 @@ async function runOAuthFlow(p, pc, authStorage, providerId, oauthMap) {
     }
 }
 // ─── API Key Flow ─────────────────────────────────────────────────────────────
+async function runBedrockSsoFlow(p, pc, authStorage) {
+    const missingAwsCli = ensureAwsCliInstalled();
+    if (missingAwsCli) {
+        p.log.warn(missingAwsCli);
+        return false;
+    }
+    const profile = await p.text({
+        message: 'AWS profile for SSO login:',
+        placeholder: 'default',
+        initialValue: 'default',
+        validate: (value) => value?.trim() ? undefined : 'AWS profile is required',
+    });
+    if (p.isCancel(profile) || !profile)
+        return false;
+    const trimmedProfile = String(profile).trim();
+    const region = await p.text({
+        message: 'AWS region for Bedrock:',
+        placeholder: 'us-east-1',
+        initialValue: process.env.AWS_REGION ?? process.env.AWS_DEFAULT_REGION ?? 'us-east-1',
+        validate: validateAwsRegion,
+    });
+    if (p.isCancel(region) || !region)
+        return false;
+    const trimmedRegion = String(region).trim();
+    const s = p.spinner();
+    s.start(`Running aws sso login for profile ${trimmedProfile}...`);
+    try {
+        await new Promise((resolve, reject) => {
+            execFile('aws', ['sso', 'login', '--profile', trimmedProfile], { timeout: 120_000 }, (error, stdout, stderr) => {
+                if (error) {
+                    reject(new Error((stderr || stdout || error.message).trim() || error.message));
+                    return;
+                }
+                resolve();
+            });
+        });
+        saveBedrockCredential(authStorage, {
+            authType: 'sso',
+            profile: trimmedProfile,
+            region: trimmedRegion,
+        });
+        saveAwsAuthRefreshCommand(trimmedProfile);
+        s.stop('AWS SSO login complete');
+        p.log.success(`Bedrock configured with ${pc.green(`profile ${trimmedProfile}`)} in ${pc.green(trimmedRegion)}`);
+        return true;
+    }
+    catch (err) {
+        s.stop('AWS SSO login failed');
+        const message = err instanceof Error ? err.message : String(err);
+        p.log.warn(message);
+        p.log.info(getAwsCliInstallInstructions());
+        return false;
+    }
+}
+async function runBedrockApiKeyFlow(p, pc, authStorage) {
+    const accessKeyId = await p.text({
+        message: 'AWS Access Key ID:',
+        placeholder: 'AKIA...',
+        validate: (value) => value?.trim() ? undefined : 'AWS Access Key ID is required',
+    });
+    if (p.isCancel(accessKeyId) || !accessKeyId)
+        return false;
+    const secretAccessKey = await p.password({
+        message: 'AWS Secret Access Key:',
+        mask: '●',
+    });
+    if (p.isCancel(secretAccessKey) || !secretAccessKey)
+        return false;
+    const trimmedSecret = String(secretAccessKey).trim();
+    if (!trimmedSecret)
+        return false;
+    const region = await p.text({
+        message: 'AWS region for Bedrock:',
+        placeholder: 'us-east-1',
+        initialValue: process.env.AWS_REGION ?? process.env.AWS_DEFAULT_REGION ?? 'us-east-1',
+        validate: validateAwsRegion,
+    });
+    if (p.isCancel(region) || !region)
+        return false;
+    saveBedrockCredential(authStorage, {
+        authType: 'access-key',
+        accessKeyId: String(accessKeyId).trim(),
+        secretAccessKey: trimmedSecret,
+        region: String(region).trim(),
+    });
+    p.log.success(`Bedrock credentials saved for ${pc.green('Amazon Bedrock')}`);
+    return true;
+}
 async function runApiKeyFlow(p, pc, authStorage, providerId, providerLabel) {
     const key = await p.password({
         message: `Paste your ${providerLabel} API key:`,

package/dist/pi-migration.js

@@ -20,6 +20,7 @@ const LLM_PROVIDER_IDS = [
     'xai',
     'openrouter',
     'mistral',
+    'amazon-bedrock',
 ];
 /**
  * Migrate provider credentials from Pi's auth.json into GSD's AuthStorage.

package/dist/resources/extensions/memory/auto-extract.js

@@ -13,6 +13,11 @@ import { randomUUID } from 'node:crypto';
 import { getAgentDir } from '@gsd/pi-coding-agent';
 import { getMemoryDir } from './memory-paths.js';
 import { scanMemoryFiles, formatMemoryManifest } from './memory-scan.js';
+import { normalizeSubagentModel } from '../subagent/model-resolution.js';
+const AUTO_EXTRACT_ANSI_PATTERN = /\u001B\[[0-?]*[ -/]*[@-~]/g;
+export function stripAnsiForAutoExtractLog(text) {
+    return text.replace(AUTO_EXTRACT_ANSI_PATTERN, '');
+}
 /**
  * Build a plain-text transcript from session entries, keeping only
  * human-readable message content (no tool_use / tool_result blocks).
@@ -112,7 +117,7 @@ export function readBudgetMemoryModel() {
         const raw = readFileSync(settingsPath, 'utf-8');
         const parsed = JSON.parse(raw);
         return typeof parsed.budgetSubagentModel === 'string'
-            ? parsed.budgetSubagentModel.trim() || undefined
+            ? normalizeSubagentModel(parsed.budgetSubagentModel)
             : undefined;
     }
     catch {
@@ -177,7 +182,7 @@ export function extractMemories(ctx, cwd) {
     const helperScript = `
 const { spawn } = require('node:child_process');
 const { appendFileSync, writeFileSync, readFileSync, readdirSync, statSync, existsSync } = require('node:fs');
-const { join } = require('node:path');
+const { join, delimiter } = require('node:path');
 
 const [cliPath, cwd, tmpPromptPath, auditPath, logPath, memoryDir, instruction, model, userMessageCount, transcriptLength] = process.argv.slice(1);
 const startedAt = new Date().toISOString();
@@ -186,6 +191,11 @@ let sawSessionEnded = false;
 let sessionEndTimer = null;
 let hardTimeout = null;
 let pendingLogText = '';
+const ANSI_PATTERN = /\u001B\[[0-?]*[ -/]*[@-~]/g;
+
+function stripAnsi(text) {
+  return String(text).replace(ANSI_PATTERN, '');
+}
 
 function flushLogText(text, force = false) {
   pendingLogText += text;
@@ -194,7 +204,7 @@ function flushLogText(text, force = false) {
 
   const kept = [];
   for (const rawLine of parts) {
-    const line = rawLine.trim();
+    const line = stripAnsi(rawLine).trim();
     if (!line) continue;
     if (/^\[phase\]\s+cache-timer\s*$/.test(line)) continue;
     kept.push(rawLine);
@@ -278,6 +288,14 @@ writeFileSync(logPath, '', 'utf-8');
 writeAudit('running', ['startedAt: ' + startedAt]);
 
 const childArgs = [cliPath, 'headless'];
+const bundledPaths = Array.from(
+  new Set(
+    [process.env.GSD_BUNDLED_EXTENSION_PATHS, process.env.LSD_BUNDLED_EXTENSION_PATHS]
+      .filter(Boolean)
+      .flatMap((value) => String(value).split(delimiter).map((entry) => entry.trim()).filter(Boolean)),
+  ),
+);
+for (const extensionPath of bundledPaths) childArgs.push('--extension', extensionPath);
 if (model) childArgs.push('--model', model);
 childArgs.push('--bare', '--context', tmpPromptPath, '--context-text', instruction);