gsd-pi 2.77.0-dev.538325aea → 2.77.0-dev.c9c8932c6

package/dist/cli.js

@@ -1,6 +1,4 @@
-import { AuthStorage, DefaultResourceLoader, ModelRegistry, SettingsManager, SessionManager, } from '@gsd/pi-coding-agent';
-import { runInteractiveMode as InteractiveMode, runPrintMode, runRpcMode, } from '@gsd/agent-modes';
-import { createAgentSession } from '@gsd/agent-core';
+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';
@@ -76,6 +74,18 @@ function printExtensionErrors(errors) {
         process.stderr.write(`[gsd] ${prefix}: ${err.error}\n`);
     }
 }
+/**
+ * Print extension load warnings (non-fatal, e.g. missing declared deps from
+ * the topological sort). Complements printExtensionErrors — fatal errors go
+ * there, advisory warnings go here.
+ */
+function printExtensionWarnings(warnings) {
+    if (!warnings)
+        return;
+    for (const w of warnings) {
+        process.stderr.write(`[gsd] Extension warning: ${w.message}\n`);
+    }
+}
 /**
  * Re-apply the validated model to the session when `createAgentSession()`
  * reports that it had to use a fallback. Prevents silently overriding the
@@ -235,8 +245,18 @@ const hasSubcommand = cliFlags.messages.length > 0;
 if (!process.stdin.isTTY && !isPrintMode && !hasSubcommand && !cliFlags.listModels && !cliFlags.web) {
     printNonTtyErrorAndExit(undefined, false);
 }
-// Package management subcommands (install, remove, list) were handled here
-// via pi-coding-agent prior to 0.67.2. That API was removed upstream.
+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 = AuthStorage.create(authFilePath);
@@ -417,7 +437,7 @@ if (cliFlags.listModels !== undefined) {
     let filtered = models;
     if (searchPattern) {
         const q = searchPattern.toLowerCase();
-        filtered = models.filter((model) => `${model.provider} ${model.id} ${model.name}`.toLowerCase().includes(q));
+        filtered = models.filter((m) => `${m.provider} ${m.id} ${m.name}`.toLowerCase().includes(q));
     }
     // Sort by name descending (newest first), then provider, then id
     filtered.sort((a, b) => {
@@ -430,13 +450,13 @@ if (cliFlags.listModels !== undefined) {
         return a.id.localeCompare(b.id);
     });
     const fmt = (n) => n >= 1_000_000 ? `${n / 1_000_000}M` : n >= 1_000 ? `${n / 1_000}K` : `${n}`;
-    const rows = filtered.map((model) => [
-        model.provider,
-        model.id,
-        model.name,
-        fmt(model.contextWindow),
-        fmt(model.maxTokens),
-        model.reasoning ? 'yes' : 'no',
+    const rows = filtered.map((m) => [
+        m.provider,
+        m.id,
+        m.name,
+        fmt(m.contextWindow),
+        fmt(m.maxTokens),
+        m.reasoning ? 'yes' : 'no',
     ]);
     const hdrs = ['provider', 'model', 'name', 'context', 'max-out', 'thinking'];
     const widths = hdrs.map((h, i) => Math.max(h.length, ...rows.map((r) => r[i].length)));
@@ -499,6 +519,7 @@ if (isPrintMode) {
     validateConfiguredModel(modelRegistry, settingsManager);
     await reapplyValidatedModelOnFallback(session, modelRegistry, settingsManager, modelFallbackMessage);
     printExtensionErrors(extensionsResult.errors);
+    printExtensionWarnings(extensionsResult.warnings);
     // Apply --model override if specified
     if (cliFlags.model) {
         const available = modelRegistry.getAvailable();
@@ -636,6 +657,7 @@ markStartup('createAgentSession');
 validateConfiguredModel(modelRegistry, settingsManager);
 await reapplyValidatedModelOnFallback(session, modelRegistry, settingsManager, interactiveFallbackMsg);
 printExtensionErrors(extensionsResult.errors);
+printExtensionWarnings(extensionsResult.warnings);
 // Restore scoped models from settings on startup.
 // The upstream InteractiveMode reads enabledModels from settings when /scoped-models is opened,
 // but doesn't apply them to the session at startup — so Ctrl+P cycles all models instead of

package/dist/extension-discovery.d.ts

@@ -16,3 +16,9 @@ export declare function resolveExtensionEntries(dir: string): string[];
  *   pi.extensions, then index.ts/index.js fallback).
  */
 export declare function discoverExtensionEntryPaths(extensionsDir: string): string[];
+/**
+ * Merge bundled and installed extension entry paths.
+ * Installed extensions with the same manifest ID as a bundled extension take precedence (D-14).
+ * Loader stays dumb — receives a pre-merged path list (D-15).
+ */
+export declare function mergeExtensionEntryPaths(bundledPaths: string[], installedExtDir: string): string[];

package/dist/extension-discovery.js

@@ -1,5 +1,6 @@
 import { existsSync, readFileSync, readdirSync } from 'node:fs';
 import { join, resolve } from 'node:path';
+import { readManifest, readManifestFromEntryPath } from './extension-registry.js';
 function isExtensionFile(name) {
     return name.endsWith('.ts') || name.endsWith('.js');
 }
@@ -69,3 +70,39 @@ export function discoverExtensionEntryPaths(extensionsDir) {
     }
     return discovered;
 }
+/**
+ * Merge bundled and installed extension entry paths.
+ * Installed extensions with the same manifest ID as a bundled extension take precedence (D-14).
+ * Loader stays dumb — receives a pre-merged path list (D-15).
+ */
+export function mergeExtensionEntryPaths(bundledPaths, installedExtDir) {
+    if (!existsSync(installedExtDir))
+        return bundledPaths;
+    // Build map: manifest ID → entry paths for installed extensions
+    const installedById = new Map();
+    for (const entry of readdirSync(installedExtDir, { withFileTypes: true })) {
+        if (!entry.isDirectory())
+            continue;
+        const dir = join(installedExtDir, entry.name);
+        const manifest = readManifest(dir);
+        const entries = resolveExtensionEntries(dir);
+        if (manifest && entries.length > 0) {
+            installedById.set(manifest.id, entries);
+        }
+    }
+    if (installedById.size === 0)
+        return bundledPaths;
+    // Filter bundled paths: skip any whose manifest id is shadowed by installed
+    const merged = [];
+    for (const entryPath of bundledPaths) {
+        const manifest = readManifestFromEntryPath(entryPath);
+        if (manifest && installedById.has(manifest.id))
+            continue; // shadowed by installed
+        merged.push(entryPath);
+    }
+    // Append all installed entries
+    for (const entries of installedById.values()) {
+        merged.push(...entries);
+    }
+    return merged;
+}

package/dist/extension-registry.d.ts

@@ -31,6 +31,9 @@ export interface ExtensionRegistryEntry {
     source: "bundled" | "user" | "project";
     disabledAt?: string;
     disabledReason?: string;
+    version?: string;
+    installedFrom?: string;
+    installType?: "npm" | "git" | "local";
 }
 export interface ExtensionRegistry {
     version: 1;

package/dist/extension-registry.js

@@ -150,7 +150,7 @@ export function ensureRegistryEntries(extensionsDir) {
         return;
     const registry = loadRegistry();
     let changed = false;
-    for (const [id, _manifest] of manifests) {
+    for (const [id, manifest] of manifests) {
         if (!registry.entries[id]) {
             registry.entries[id] = {
                 id,

package/dist/extension-sort.d.ts

@@ -0,0 +1,18 @@
+export interface SortWarning {
+    declaringId: string;
+    missingId: string;
+    message: string;
+}
+export interface SortResult {
+    sortedPaths: string[];
+    warnings: SortWarning[];
+}
+/**
+ * Sort extension entry paths in topological dependency-first order using Kahn's BFS algorithm.
+ *
+ * - Extensions without manifests are prepended in input order.
+ * - Missing dependencies produce a structured warning but do not block loading.
+ * - Cycles produce warnings; cycle participants are appended alphabetically.
+ * - Self-dependencies are silently ignored.
+ */
+export declare function sortExtensionPaths(paths: string[]): SortResult;

package/dist/extension-sort.js

@@ -0,0 +1,114 @@
+// GSD-2 — Extension Sort: Topological dependency ordering
+// Copyright (c) 2026 Jeremy McSpadden <jeremy@fluxlabs.net>
+import { readManifestFromEntryPath } from './extension-registry.js';
+/**
+ * Sort extension entry paths in topological dependency-first order using Kahn's BFS algorithm.
+ *
+ * - Extensions without manifests are prepended in input order.
+ * - Missing dependencies produce a structured warning but do not block loading.
+ * - Cycles produce warnings; cycle participants are appended alphabetically.
+ * - Self-dependencies are silently ignored.
+ */
+export function sortExtensionPaths(paths) {
+    const warnings = [];
+    const pathsWithoutId = [];
+    const idToPath = new Map();
+    // Step 1: Build ID map
+    for (const path of paths) {
+        const manifest = readManifestFromEntryPath(path);
+        if (!manifest) {
+            pathsWithoutId.push(path);
+        }
+        else {
+            idToPath.set(manifest.id, path);
+        }
+    }
+    // Step 2: Build graph — inDegree and dependents adjacency
+    const inDegree = new Map();
+    const dependents = new Map(); // dep → [ids that depend on dep]
+    for (const id of idToPath.keys()) {
+        if (!inDegree.has(id))
+            inDegree.set(id, 0);
+        if (!dependents.has(id))
+            dependents.set(id, []);
+    }
+    for (const [id, path] of idToPath) {
+        const manifest = readManifestFromEntryPath(path);
+        const rawDeps = manifest?.dependencies?.extensions ?? [];
+        const deps = Array.isArray(rawDeps) ? rawDeps : [];
+        for (const depId of deps) {
+            // Silently ignore self-deps
+            if (depId === id)
+                continue;
+            if (!idToPath.has(depId)) {
+                // Missing dependency — warn and skip edge
+                warnings.push({
+                    declaringId: id,
+                    missingId: depId,
+                    message: `Extension '${id}' declares dependency '${depId}' which is not installed — loading anyway`,
+                });
+                continue;
+            }
+            // Valid edge: id depends on depId → increment inDegree[id], add id to dependents[depId]
+            inDegree.set(id, (inDegree.get(id) ?? 0) + 1);
+            const depDependents = dependents.get(depId) ?? [];
+            depDependents.push(id);
+            dependents.set(depId, depDependents);
+        }
+    }
+    // Step 3: Kahn's algorithm — start with nodes that have inDegree 0
+    const sorted = [];
+    // Ready queue: IDs with inDegree 0, maintained in alphabetical order
+    const ready = [...idToPath.keys()]
+        .filter(id => inDegree.get(id) === 0)
+        .sort();
+    while (ready.length > 0) {
+        const id = ready.shift();
+        sorted.push(idToPath.get(id));
+        const deps = dependents.get(id) ?? [];
+        for (const depId of deps) {
+            const newDegree = (inDegree.get(depId) ?? 0) - 1;
+            inDegree.set(depId, newDegree);
+            if (newDegree === 0) {
+                // Insert into ready queue maintaining alphabetical order
+                const insertIdx = ready.findIndex(r => r > depId);
+                if (insertIdx === -1) {
+                    ready.push(depId);
+                }
+                else {
+                    ready.splice(insertIdx, 0, depId);
+                }
+            }
+        }
+    }
+    // Step 4: Cycle handling — any remaining IDs with inDegree > 0
+    const cycleIds = [...idToPath.keys()]
+        .filter(id => (inDegree.get(id) ?? 0) > 0)
+        .sort();
+    if (cycleIds.length > 0) {
+        const cycleSet = new Set(cycleIds);
+        for (const id of cycleIds) {
+            const path = idToPath.get(id);
+            const manifest = readManifestFromEntryPath(path);
+            const rawDeps = manifest?.dependencies?.extensions ?? [];
+            const deps = Array.isArray(rawDeps) ? rawDeps : [];
+            for (const depId of deps) {
+                if (depId === id)
+                    continue;
+                if (!cycleSet.has(depId))
+                    continue;
+                // Both id and depId are in cycle — emit warning
+                warnings.push({
+                    declaringId: id,
+                    missingId: depId,
+                    message: `Extension '${id}' and '${depId}' form a dependency cycle — loading both anyway (alphabetical order)`,
+                });
+            }
+            sorted.push(path);
+        }
+    }
+    return {
+        sortedPaths: [...pathsWithoutId, ...sorted],
+        warnings,
+    };
+}

package/dist/extension-validator.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Install-time validator for GSD extension packages. Called by the install command
+ * (Phase 8) before writing files. Not called on bundled extensions — they are
+ * discovered at load time, not installed.
+ */
+export interface ValidationError {
+    code: string;
+    message: string;
+    field?: string;
+}
+export interface ValidationWarning {
+    code: string;
+    message: string;
+}
+export interface ValidationResult {
+    valid: boolean;
+    errors: ValidationError[];
+    warnings: ValidationWarning[];
+}
+export interface ValidationOptions {
+    allowGsdNamespace?: boolean;
+    extensionId?: string;
+}
+/**
+ * Per D-03: Check that pkg.gsd.extension === true with STRICT equality (not truthiness).
+ * Packages without this marker are not recognized as GSD extensions.
+ */
+export declare function checkInstallDiscriminator(pkg: unknown): ValidationError | null;
+/**
+ * Per D-04/D-05: Check that the extension ID does not use the reserved gsd.* namespace,
+ * unless allowGsdNamespace is explicitly set to true.
+ * Per D-06: Only checks extension manifest ID — not pkg.name.
+ */
+export declare function checkNamespaceReservation(extensionId: string, opts: ValidationOptions): ValidationError | null;
+/**
+ * Per D-07/D-08/D-09/D-10: Scan both `dependencies` and `devDependencies` for @gsd/* packages.
+ * peerDependencies is the correct placement and is NOT flagged.
+ * Returns an error per violation naming the exact field and package.
+ */
+export declare function checkDependencyPlacement(pkg: unknown): ValidationError[];
+/**
+ * Run all validation checks for a GSD extension package.json.
+ * - If opts.extensionId is provided, runs namespace reservation check.
+ * - If opts.extensionId is not provided, skips namespace check and adds a warning.
+ * - valid is ALWAYS derived as errors.length === 0.
+ */
+export declare function validateExtensionPackage(pkg: unknown, opts?: ValidationOptions): ValidationResult;

package/dist/extension-validator.js

@@ -0,0 +1,127 @@
+// GSD-2 — Extension Package Format Validator
+// Copyright (c) 2026 Jeremy McSpadden <jeremy@fluxlabs.net>
+// ─── Individual Check Functions ───────────────────────────────────────────────
+/**
+ * Per D-03: Check that pkg.gsd.extension === true with STRICT equality (not truthiness).
+ * Packages without this marker are not recognized as GSD extensions.
+ */
+export function checkInstallDiscriminator(pkg) {
+    if (typeof pkg !== 'object' || pkg === null) {
+        return {
+            code: 'MISSING_GSD_MARKER',
+            message: 'package.json must declare "gsd": { "extension": true } to be recognized as a GSD extension.',
+            field: 'gsd.extension',
+        };
+    }
+    const obj = pkg;
+    const gsd = obj.gsd;
+    if (typeof gsd !== 'object' || gsd === null) {
+        return {
+            code: 'MISSING_GSD_MARKER',
+            message: 'package.json must declare "gsd": { "extension": true } to be recognized as a GSD extension.',
+            field: 'gsd.extension',
+        };
+    }
+    const gsdObj = gsd;
+    if (gsdObj.extension !== true) {
+        return {
+            code: 'MISSING_GSD_MARKER',
+            message: 'package.json must declare "gsd": { "extension": true } to be recognized as a GSD extension.',
+            field: 'gsd.extension',
+        };
+    }
+    return null;
+}
+/**
+ * Per D-04/D-05: Check that the extension ID does not use the reserved gsd.* namespace,
+ * unless allowGsdNamespace is explicitly set to true.
+ * Per D-06: Only checks extension manifest ID — not pkg.name.
+ */
+export function checkNamespaceReservation(extensionId, opts) {
+    if (opts.allowGsdNamespace === true) {
+        return null;
+    }
+    if (extensionId.startsWith('gsd.')) {
+        return {
+            code: 'RESERVED_NAMESPACE',
+            message: `Extension ID "${extensionId}" is reserved for GSD core extensions. Use a different namespace for community extensions (e.g., "my-tool" or "acme.my-tool"). To override: pass --allow-gsd-namespace (maintainers only).`,
+            field: 'extensionId',
+        };
+    }
+    return null;
+}
+/**
+ * Per D-07/D-08/D-09/D-10: Scan both `dependencies` and `devDependencies` for @gsd/* packages.
+ * peerDependencies is the correct placement and is NOT flagged.
+ * Returns an error per violation naming the exact field and package.
+ */
+export function checkDependencyPlacement(pkg) {
+    const errors = [];
+    if (typeof pkg !== 'object' || pkg === null) {
+        return errors;
+    }
+    const obj = pkg;
+    const fieldsToCheck = [
+        {
+            field: 'dependencies',
+            reason: 'Extensions must not bundle GSD host packages — the host provides them at runtime.',
+        },
+        {
+            field: 'devDependencies',
+            reason: 'GSD host packages are provided by the host at runtime; listing them in devDependencies misrepresents the runtime contract.',
+        },
+    ];
+    for (const { field, reason } of fieldsToCheck) {
+        const deps = obj[field];
+        if (typeof deps !== 'object' || deps === null)
+            continue;
+        const depsObj = deps;
+        for (const pkgName of Object.keys(depsObj)) {
+            if (pkgName.startsWith('@gsd/')) {
+                errors.push({
+                    code: 'WRONG_DEP_FIELD',
+                    message: `"${pkgName}" must not appear in "${field}". Move it to "peerDependencies". ${reason}`,
+                    field,
+                });
+            }
+        }
+    }
+    return errors;
+}
+// ─── Composite Validation ─────────────────────────────────────────────────────
+/**
+ * Run all validation checks for a GSD extension package.json.
+ * - If opts.extensionId is provided, runs namespace reservation check.
+ * - If opts.extensionId is not provided, skips namespace check and adds a warning.
+ * - valid is ALWAYS derived as errors.length === 0.
+ */
+export function validateExtensionPackage(pkg, opts = {}) {
+    const errors = [];
+    const warnings = [];
+    // Check 1: Install discriminator
+    const discriminatorError = checkInstallDiscriminator(pkg);
+    if (discriminatorError) {
+        errors.push(discriminatorError);
+    }
+    // Check 2: Namespace reservation (only if extensionId provided)
+    if (opts.extensionId !== undefined) {
+        const namespaceError = checkNamespaceReservation(opts.extensionId, opts);
+        if (namespaceError) {
+            errors.push(namespaceError);
+        }
+    }
+    else {
+        warnings.push({
+            code: 'NAMESPACE_CHECK_SKIPPED',
+            message: 'No extensionId provided — namespace reservation check was skipped.',
+        });
+    }
+    // Check 3: Dependency placement
+    const depErrors = checkDependencyPlacement(pkg);
+    errors.push(...depErrors);
+    return {
+        valid: errors.length === 0,
+        errors,
+        warnings,
+    };
+}

package/dist/headless-ui.d.ts

@@ -5,7 +5,7 @@
  * formats progress events for stderr output, and reads orchestrator
  * commands from stdin in supervised mode.
  */
-import { RpcClient } from '@gsd/agent-modes';
+import { RpcClient } from '@gsd/pi-coding-agent';
 interface ExtensionUIRequest {
     type: 'extension_ui_request';
     id: string;

package/dist/headless.js

@@ -14,8 +14,7 @@
 import { existsSync, mkdirSync, writeFileSync } from 'node:fs';
 import { join } from 'node:path';
 import { resolve } from 'node:path';
-import { RpcClient } from '@gsd/agent-modes';
-import { SessionManager } from '@gsd/pi-coding-agent';
+import { RpcClient, SessionManager } from '@gsd/pi-coding-agent';
 import { getProjectSessionsDir } from './project-sessions.js';
 import { loadAndValidateAnswerFile, AnswerInjector } from './headless-answers.js';
 import { isTerminalNotification, isBlockedNotification, isMilestoneReadyNotification, isQuickCommand, FIRE_AND_FORGET_METHODS, IDLE_TIMEOUT_MS, NEW_MILESTONE_IDLE_TIMEOUT_MS, isInteractiveHeadlessTool, shouldArmHeadlessIdleTimeout, EXIT_SUCCESS, EXIT_ERROR, EXIT_BLOCKED, EXIT_CANCELLED, mapStatusToExitCode, } from './headless-events.js';
@@ -649,8 +648,10 @@ async function runHeadlessOnce(options, restartCount) {
         process.exit(1);
     }
     // v2 protocol negotiation — attempt init for structured completion events
+    let v2Enabled = false;
     try {
         await client.init({ clientId: 'gsd-headless' });
+        v2Enabled = true;
     }
     catch {
         process.stderr.write('[headless] Warning: v2 init failed, falling back to v1 string-matching\n');
@@ -742,6 +743,7 @@ async function runHeadlessOnce(options, restartCount) {
         if (timeoutTimer)
             clearTimeout(timeoutTimer);
         completed = false;
+        milestoneReady = false;
         blocked = false;
         const autoCompletionPromise = new Promise((resolve) => {
             resolveCompletion = resolve;

package/dist/loader.js

@@ -3,7 +3,7 @@
 // Copyright (c) 2026 Jeremy McSpadden <jeremy@fluxlabs.net>
 import { fileURLToPath } from 'url';
 import { dirname, resolve, join, relative, delimiter } from 'path';
-import { existsSync, readFileSync, mkdirSync, symlinkSync, cpSync } from 'fs';
+import { existsSync, readFileSync, readdirSync, statSync, mkdirSync, symlinkSync, cpSync } from 'fs';
 // Fast-path: handle --version/-v and --help/-h before importing any heavy
 // dependencies. This avoids loading the entire pi-coding-agent barrel import
 // (~1s) just to print a version string.
@@ -110,6 +110,7 @@ process.env.NODE_PATH = [gsdNodeModules, process.env.NODE_PATH]
     .join(delimiter);
 // Force Node to re-evaluate module search paths with the updated NODE_PATH.
 // Must happen synchronously before cli.js imports → extension loading.
+// eslint-disable-next-line @typescript-eslint/no-require-imports
 const { Module } = await import('module');
 Module._initPaths?.();
 // GSD_VERSION — expose package version so extensions can display it
@@ -154,15 +155,42 @@ if (process.env.HTTP_PROXY || process.env.HTTPS_PROXY || process.env.http_proxy
 // On Windows without Developer Mode or admin rights, symlinkSync will throw even for
 // 'junction' type — so we fall back to cpSync (a full directory copy) which works
 // everywhere without elevated permissions.
-const gsdScopeDir = join(gsdNodeModules, '@gsd');
+// Discover linkable workspace packages by scanning packages/*/package.json for
+// `gsd.linkable === true`. This is the single source of truth — the same list
+// read by scripts/link-workspace-packages.cjs and scripts/validate-pack.js.
+// Adding a new linkable package requires only setting `gsd.linkable` in its
+// package.json; there is no enumeration to keep in sync here.
 const packagesDir = join(gsdRoot, 'packages');
-const wsPackages = ['native', 'pi-agent-core', 'pi-ai', 'pi-coding-agent', 'pi-tui'];
+const wsPackages = [];
+try {
+    if (existsSync(packagesDir)) {
+        for (const dir of readdirSync(packagesDir)) {
+            const pkgPath = join(packagesDir, dir);
+            if (!statSync(pkgPath).isDirectory())
+                continue;
+            const pkgJsonPath = join(pkgPath, 'package.json');
+            if (!existsSync(pkgJsonPath))
+                continue;
+            try {
+                const pkg = JSON.parse(readFileSync(pkgJsonPath, 'utf-8'));
+                const gsd = pkg.gsd;
+                if (!gsd || gsd.linkable !== true)
+                    continue;
+                if (gsd.scope && gsd.name)
+                    wsPackages.push({ dir, scope: gsd.scope, name: gsd.name });
+            }
+            catch { /* ignore malformed package.json */ }
+        }
+    }
+}
+catch { /* non-fatal — validation below catches missing critical packages */ }
 try {
-    if (!existsSync(gsdScopeDir))
-        mkdirSync(gsdScopeDir, { recursive: true });
     for (const pkg of wsPackages) {
-        const target = join(gsdScopeDir, pkg);
-        const source = join(packagesDir, pkg);
+        const scopeDir = join(gsdNodeModules, pkg.scope);
+        if (!existsSync(scopeDir))
+            mkdirSync(scopeDir, { recursive: true });
+        const target = join(scopeDir, pkg.name);
+        const source = join(packagesDir, pkg.dir);
         if (!existsSync(source) || existsSync(target))
             continue;
         try {
@@ -179,6 +207,7 @@ try {
     }
 }
 catch { /* non-fatal */ }
+const gsdScopeDir = join(gsdNodeModules, '@gsd');
 // Validate critical workspace packages are resolvable. If still missing after the
 // symlink+copy attempts, emit a clear diagnostic instead of a cryptic
 // ERR_MODULE_NOT_FOUND from deep inside cli.js.

package/dist/onboarding.js

@@ -749,11 +749,10 @@ export async function runToolKeysStep(p, pc, authStorage) {
 }
 // ─── Remote Questions Step ────────────────────────────────────────────────────
 export async function runRemoteQuestionsStep(p, pc, authStorage) {
-    // Check existing config — use authStorage.get() and validate the key
-    const hasValidKey = (provider) => {
-        const c = authStorage.get(provider);
-        return c?.type === 'api_key' && typeof c.key === 'string' && c.key.length > 0;
-    };
+    // Check existing config — use getCredentialsForProvider to skip empty-key entries
+    const hasValidKey = (provider) => authStorage
+        .getCredentialsForProvider(provider)
+        .some((c) => c.type === 'api_key' && typeof c.key === 'string' && c.key.length > 0);
     const hasDiscord = hasValidKey('discord_bot');
     const hasSlack = hasValidKey('slack_bot');
     const hasTelegram = hasValidKey('telegram_bot');
@@ -951,6 +950,7 @@ async function runDiscordChannelStep(p, pc, token) {
         if (p.isCancel(choice))
             return null;
         guildId = choice;
+        guildName = guilds.find(g => g.id === guildId)?.name ?? guildId;
     }
     // Fetch channels
     let channels;

package/dist/provider-migrations.d.ts

@@ -1,10 +1,10 @@
 import type { AuthStorage } from "@gsd/pi-coding-agent";
 type AnthropicMigrationDeps = {
-    authStorage: Pick<AuthStorage, "get">;
+    authStorage: Pick<AuthStorage, "getCredentialsForProvider">;
     isClaudeCodeReady: boolean;
     defaultProvider: string | undefined;
     env?: NodeJS.ProcessEnv;
 };
-export declare function hasDirectAnthropicApiKey(authStorage: Pick<AuthStorage, "get">, env?: NodeJS.ProcessEnv): boolean;
+export declare function hasDirectAnthropicApiKey(authStorage: Pick<AuthStorage, "getCredentialsForProvider">, env?: NodeJS.ProcessEnv): boolean;
 export declare function shouldMigrateAnthropicToClaudeCode({ authStorage, isClaudeCodeReady, defaultProvider, env, }: AnthropicMigrationDeps): boolean;
 export {};

package/dist/provider-migrations.js

@@ -2,8 +2,7 @@ export function hasDirectAnthropicApiKey(authStorage, env = process.env) {
     if ((env.ANTHROPIC_API_KEY ?? "").trim()) {
         return true;
     }
-    const credential = authStorage.get("anthropic");
-    return credential?.type === "api_key" && typeof credential?.key === "string" && credential.key.trim().length > 0;
+    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 (!isClaudeCodeReady || defaultProvider !== "anthropic") {

package/dist/remote-questions-config.js

@@ -26,7 +26,7 @@ export function saveRemoteQuestionsConfig(channel, channelId) {
     ].join("\n");
     const content = existsSync(prefsPath) ? readFileSync(prefsPath, "utf-8") : "";
     const fmMatch = content.match(/^---\n([\s\S]*?)\n---/);
-    let next;
+    let next = content;
     if (fmMatch) {
         let frontmatter = fmMatch[1];
         const regex = /remote_questions:[\s\S]*?(?=\n[a-zA-Z_]|\n---|$)/;

package/dist/resources/extensions/async-jobs/async-bash-tool.js

@@ -5,7 +5,7 @@
  * immediately. The LLM can continue working and check results later
  * with await_job.
  */
-import { getShellConfig, DEFAULT_MAX_BYTES, DEFAULT_MAX_LINES, sanitizeCommand, } from "@gsd/pi-coding-agent";
+import { getShellConfig, sanitizeCommand, DEFAULT_MAX_BYTES, DEFAULT_MAX_LINES, } from "@gsd/pi-coding-agent";
 import { Type } from "@sinclair/typebox";
 import { spawn, spawnSync } from "node:child_process";
 import { createWriteStream } from "node:fs";