gsd-pi 2.76.0 → 2.77.0-dev.538325aea

package/README.md

@@ -27,47 +27,49 @@ One command. Walk away. Come back to a built project with clean git history.
 
 ---
 
-## What's New in v2.75
+## What's New in v2.77
 
-### Knowledge Graph & Learning Extraction
+### Context Mode & Execution
 
-- **Knowledge graph system** — GSD now builds a structured knowledge graph from project artifacts. Learnings, decisions, and patterns are parsed into queryable graph nodes.
-- **`/gsd extract-learnings`** — new command extracts decisions, lessons, patterns, and surprises from completed phase artifacts into `LEARNINGS.md`, which feeds the knowledge graph automatically.
+- **Context Mode** — a dispatch behavior that builds task-ready context automatically: it pulls in the most relevant project artifacts, prior session state, milestone/slice signals, and execution metadata before the model runs. This reduces manual prompt assembly, improves continuity across turns, and helps tasks start with the right files and constraints from the first dispatch. Enabled by default for new projects (opt out with `enabled: false`).
+- **Sandboxed execution tools** — added `gsd_exec_search`, `gsd_resume`, and sandboxed tool-output execution paths for context-mode flows, so search/resume and follow-up execution can run with tighter boundaries and more predictable runtime behavior.
+- **Preflight hardening** — milestone completion now performs stricter clean-root preflight checks and can auto-stash when needed, reducing accidental dirty-tree transitions and helping completion flows fail fast with clearer remediation.
 
-### Unified Orchestration Kernel (UOK)
+### Memory Architecture (ADR-013)
 
-- **UOK is now the default** — the unified orchestration kernel replaces the legacy execution path. Plan-v2 compile gates, unified audit envelopes, turn-level git transaction modes, reactive/parallel scheduling via execution graph, and model policy filtering are all enforced by default. Legacy fallback remains as an emergency escape.
+- **Memories table is now authoritative** — all memory reads and writes now flow through the `memories` table as the single source of truth. By removing split legacy paths, memory state stays consistent across agents, tools, and UI surfaces, with fewer reconciliation edge cases and less sync drift.
+- **Structured memory fields** — `structured_fields` adds typed metadata (instead of only free-form text), so memories can carry machine-usable attributes for more accurate retrieval, stronger filtering, and more dependable downstream automation and tooling.
+- **Dual-write migration completed** — the staged migration that wrote to both old and new paths is now fully landed, including decisions backfill and parity wiring across agents, MCP tools, and extract-learnings flows. That gives a safer upgrade path while preserving historical data and reducing cutover risk.
 
-### Extension API
+### Skills, Tooling, and UX
 
-- **GSD Extension API** — third-party extensions can now be loaded from `.gsd/extensions/`, with a formal API surface for hooking into the GSD lifecycle (#3338).
+- **Skill coverage expanded** — 9 gap-closing skills landed and 6 planning/design skills were surfaced, improving end-to-end workflow coverage and making specialized guidance easier to discover at the point of use.
+- **Hook stack upgrades** — Layer 0 shell hooks and additional Layer 2 events were added to widen extension integration points: hooks can act earlier in command execution, and lifecycle consumers now receive richer event signals for orchestration, policy checks, and observability.
+- **TUI polish** — skill invocations now render in a dedicated chat-frame style for clearer scanability, and active-row overflow handling was fixed to prevent terminal layout breakage during long outputs.
 
-### v1 Command Parity
+### Reliability & Safety
 
-- **12 missing commands added** — GSD v2 now covers all v1 commands, closing the migration gap.
+- **Worktree and dispatch resilience** — crash-recovery dispatch is more robust, path derivation is safer, and worktree context fallback is improved, reducing stuck states and misrouted artifact operations after interruptions.
+- **DB/schema guardrails** — migration/index ordering and schema version stamping were tightened so upgrades apply deterministically and avoid index/version drift across mixed or legacy states.
+- **Security and validation fixes** — multiple hardening fixes landed across redaction paths, file/path checks, and pre-execution validation, closing false-positive/false-negative gaps while improving safety boundaries.
 
-### TUI Improvements
-
-- **Chat frame redesign** — compaction notices, tool execution cards, and the chat frame now share a unified styling with timestamps and model headers.
-- **Inline tool calls** — assistant tool calls render inline with text instead of grouped at the end.
-- **Compaction and success fixes** — tool cards no longer stick after compaction; success notifications are properly promoted.
-
-### Auto-Mode & Reliability
-
-- **Session timeout recovery** — auto-resume timer handles session creation timeouts; timeout counter resets on resume.
-- **Compaction checkpoint fix** — all session phases are checkpointed during compaction, not just the executing phase.
-- **MCP worktree routing** — tool writes are routed to the active worktree when a milestone has one; worktree paths are accepted in the project root guard.
-- **Single-writer DB invariant** — the engine database now enforces a single-writer invariant, preventing corruption from concurrent access.
-
-### Providers & CI
+See the full [Changelog](./CHANGELOG.md) for details on every release.
 
-- **Alibaba DashScope** — added as a standalone provider (#3891).
-- **Persistent language preference** — `/gsd language` sets a persistent language preference.
-- **Flat-rate provider detection** — extended to custom and externalCli providers.
-- **Thinking level as effort** — Claude Code now passes thinking level as an effort parameter.
-- **Hardened release pipeline** — workspace versions synced in release commits, package-lock.json regenerated during bumps, incremental build cache issues resolved.
+<details>
+<summary>v2.75 highlights</summary>
+
+- **Knowledge graph system** — structured knowledge graph built from project artifacts
+- **`/gsd extract-learnings`** — extracts decisions, lessons, patterns, and surprises into `LEARNINGS.md`
+- **Unified Orchestration Kernel (UOK)** — now the default execution path with plan-v2 compile gates and reactive/parallel scheduling
+- **GSD Extension API** — third-party extensions loadable from `.gsd/extensions/` (#3338)
+- **v1 command parity** — 12 missing commands added, closing the migration gap
+- **Chat frame redesign** — unified styling for compaction notices, tool cards, and chat frame with timestamps and model headers
+- **Single-writer DB invariant** — engine database enforces single-writer to prevent corruption
+- **MCP worktree routing** — tool writes routed to active worktree; worktree paths accepted in project root guard
+- **Alibaba DashScope** — added as a standalone provider (#3891)
+- **Persistent language preference** — `/gsd language`
 
-See the full [Changelog](./CHANGELOG.md) for details on every release.
+</details>
 
 <details>
 <summary>v2.74 highlights</summary>

package/dist/claude-cli-check.js

@@ -12,12 +12,41 @@ import { execFileSync } from 'node:child_process';
  * `src/resources/extensions/gsd/pre-execution-checks.ts`.
  */
 export const CLAUDE_COMMAND = process.platform === 'win32' ? 'claude.cmd' : 'claude';
+/**
+ * Ordered list of binary names to probe for the Claude Code CLI.
+ *
+ * Windows installs vary: npm-global installs produce a `claude.cmd` shim,
+ * direct binary installs produce `claude.exe`, and Git Bash wrappers may
+ * expose a bare `claude` shim. Try all three so no valid install is missed.
+ */
+const CLAUDE_COMMAND_CANDIDATES = process.platform === 'win32' ? [CLAUDE_COMMAND, 'claude.exe', 'claude'] : [CLAUDE_COMMAND];
+/**
+ * Try to run `args` against each candidate binary.
+ * Returns the output buffer on first success, throws the last error if all fail.
+ */
+function execClaudeCheck(args) {
+    let lastError;
+    for (const command of CLAUDE_COMMAND_CANDIDATES) {
+        try {
+            return execFileSync(command, args, { timeout: 5_000, stdio: 'pipe' });
+        }
+        catch (error) {
+            lastError = error;
+            const code = error?.code;
+            // EINVAL can surface on Windows Git Bash for .cmd spawn failures.
+            if (code === 'ENOENT' || code === 'EINVAL')
+                continue;
+            throw error;
+        }
+    }
+    throw lastError ?? new Error(`Claude CLI not found (tried: ${CLAUDE_COMMAND_CANDIDATES.join(', ')})`);
+}
 /**
  * Check if the `claude` binary is installed (regardless of auth state).
  */
 export function isClaudeBinaryInstalled() {
     try {
-        execFileSync(CLAUDE_COMMAND, ['--version'], { timeout: 5_000, stdio: 'pipe' });
+        execClaudeCheck(['--version']);
         return true;
     }
     catch {
@@ -29,13 +58,13 @@ export function isClaudeBinaryInstalled() {
  */
 export function isClaudeCliReady() {
     try {
-        execFileSync(CLAUDE_COMMAND, ['--version'], { timeout: 5_000, stdio: 'pipe' });
+        execClaudeCheck(['--version']);
     }
     catch {
         return false;
     }
     try {
-        const output = execFileSync(CLAUDE_COMMAND, ['auth', 'status'], { timeout: 5_000, stdio: 'pipe' })
+        const output = execClaudeCheck(['auth', 'status'])
             .toString()
             .toLowerCase();
         return !(/not logged in|no credentials|unauthenticated|not authenticated/i.test(output));

package/dist/cli.js

@@ -1,4 +1,6 @@
-import { AuthStorage, DefaultResourceLoader, ModelRegistry, runPackageCommand, SettingsManager, SessionManager, createAgentSession, InteractiveMode, runPrintMode, runRpcMode, } from '@gsd/pi-coding-agent';
+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 { readFileSync } from 'node:fs';
 import { join } from 'node:path';
 import { agentDir, sessionsDir, authFilePath } from './app-paths.js';
@@ -233,18 +235,8 @@ 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);
-}
+// Package management subcommands (install, remove, list) were handled here
+// via pi-coding-agent prior to 0.67.2. That API was removed upstream.
 // `gsd config` — replay the setup wizard and exit
 if (cliFlags.messages[0] === 'config') {
     const authStorage = AuthStorage.create(authFilePath);
@@ -425,7 +417,7 @@ if (cliFlags.listModels !== undefined) {
     let filtered = models;
     if (searchPattern) {
         const q = searchPattern.toLowerCase();
-        filtered = models.filter((m) => `${m.provider} ${m.id} ${m.name}`.toLowerCase().includes(q));
+        filtered = models.filter((model) => `${model.provider} ${model.id} ${model.name}`.toLowerCase().includes(q));
     }
     // Sort by name descending (newest first), then provider, then id
     filtered.sort((a, b) => {
@@ -438,13 +430,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((m) => [
-        m.provider,
-        m.id,
-        m.name,
-        fmt(m.contextWindow),
-        fmt(m.maxTokens),
-        m.reasoning ? 'yes' : 'no',
+    const rows = filtered.map((model) => [
+        model.provider,
+        model.id,
+        model.name,
+        fmt(model.contextWindow),
+        fmt(model.maxTokens),
+        model.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)));

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/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/pi-coding-agent';
+import { RpcClient } from '@gsd/agent-modes';
 interface ExtensionUIRequest {
     type: 'extension_ui_request';
     id: string;

package/dist/headless.js

@@ -14,7 +14,8 @@
 import { existsSync, mkdirSync, writeFileSync } from 'node:fs';
 import { join } from 'node:path';
 import { resolve } from 'node:path';
-import { RpcClient, SessionManager } from '@gsd/pi-coding-agent';
+import { RpcClient } from '@gsd/agent-modes';
+import { 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';
@@ -648,10 +649,8 @@ 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');
@@ -743,7 +742,6 @@ 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

@@ -110,7 +110,6 @@ 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

package/dist/mcp-server.d.ts

@@ -1,6 +1,11 @@
 /**
  * Minimal tool interface matching GSD's AgentTool shape.
  * Avoids a direct dependency on @gsd/pi-agent-core from this compiled module.
+ *
+ * `details` and `isError` are optional fields that runtime tool implementations
+ * may populate. The MCP transport drops non-standard fields, so the wrapper at
+ * the call site mirrors `details` into `structuredContent` and forwards
+ * `isError` directly. See #4472.
  */
 export interface McpToolDef {
     name: string;
@@ -13,6 +18,8 @@ export interface McpToolDef {
             data?: string;
             mimeType?: string;
         }>;
+        details?: Record<string, unknown>;
+        isError?: boolean;
     }>;
 }
 /**

package/dist/mcp-server.js

@@ -1,3 +1,21 @@
+/**
+ * Strict plain-object guard. True only for object literals and
+ * `Object.create(null)` — not for `Date`, `URL`, `Map`, `Set`, class instances,
+ * or arrays. Used to gate `structuredContent` forwarding so the MCP transport
+ * receives only true JSON objects (the protocol contract). See #4477 review.
+ *
+ * Mirrored in `packages/mcp-server/src/workflow-tools.ts` for the
+ * `adaptExecutorResult` adapter on the workflow path. Keep both copies in
+ * sync if the contract definition needs to evolve.
+ */
+function isPlainObject(value) {
+    if (value === null || typeof value !== 'object')
+        return false;
+    if (Array.isArray(value))
+        return false;
+    const proto = Object.getPrototypeOf(value);
+    return proto === null || proto === Object.prototype;
+}
 // MCP SDK subpath imports use wildcard exports (./*) in @modelcontextprotocol/sdk's
 // package.json export map. The wildcard maps "./foo" → "./dist/cjs/foo" (no .js
 // suffix), so bare subpath specifiers like `${MCP_PKG}/server/stdio` resolve to
@@ -83,7 +101,23 @@ export async function startMcpServer(options) {
                 // by stringifying into a text block so clients see the payload.
                 return { type: 'text', text: JSON.stringify(block) };
             });
-            return { content };
+            // Forward a tool's runtime `details` field to MCP's `structuredContent`
+            // channel. The protocol drops non-standard fields on the wire, so tools
+            // that populate `details` for client-side renderers (e.g. save_gate_result)
+            // would otherwise arrive empty on the other side. See #4472.
+            //
+            // Use a strict plain-object guard (prototype-chain check) rather than just
+            // `typeof === 'object' && !Array.isArray()` — Date, URL, Map, Set, and
+            // class instances would otherwise pass through and end up as
+            // `structuredContent`, violating the protocol's JSON-object contract.
+            // The mirror discipline applies in `workflow-tools.ts adaptExecutorResult`.
+            const base = { content };
+            if (isPlainObject(result.details)) {
+                base.structuredContent = result.details;
+            }
+            if (result.isError === true)
+                base.isError = true;
+            return base;
         }
         catch (err) {
             // AbortError from a cancelled tool surfaces as a normal error — MCP

package/dist/onboarding.js

@@ -60,6 +60,8 @@ const OTHER_PROVIDERS = [
     { value: 'xai', label: 'xAI (Grok)', hint: 'console.x.ai' },
     { value: 'openrouter', label: 'OpenRouter', hint: '200+ models — openrouter.ai/keys' },
     { value: 'mistral', label: 'Mistral', hint: 'console.mistral.ai/api-keys' },
+    { value: 'minimax', label: 'MiniMax', hint: 'platform.minimax.io (Anthropic-compatible recommended)' },
+    { value: 'minimax-cn', label: 'MiniMax CN', hint: 'api.minimaxi.com (Anthropic-compatible)' },
     { value: 'ollama-cloud', label: 'Ollama Cloud' },
     { value: 'custom-openai', label: 'Custom (OpenAI-compatible)', hint: 'Ollama, LM Studio, vLLM, proxies — see docs/providers.md' },
 ];
@@ -131,6 +133,36 @@ function persistDefaultProvider(providerId) {
         // Non-fatal: startup fallback logic will still run.
     }
 }
+/**
+ * Persist the selected default model to settings.json.
+ */
+function persistDefaultModel(modelId) {
+    const settingsPath = join(agentDir, 'settings.json');
+    try {
+        const raw = existsSync(settingsPath) ? JSON.parse(readFileSync(settingsPath, 'utf-8')) : {};
+        raw.defaultModel = modelId;
+        mkdirSync(dirname(settingsPath), { recursive: true });
+        writeFileSync(settingsPath, JSON.stringify(raw, null, 2), 'utf-8');
+    }
+    catch {
+        // Non-fatal: startup fallback logic will still run.
+    }
+}
+function detectNativeProviderFromBaseUrl(baseUrl) {
+    try {
+        const hostname = new URL(baseUrl).hostname.toLowerCase();
+        if (hostname === 'api.minimax.io' || hostname.endsWith('.minimax.io')) {
+            return 'minimax';
+        }
+        if (hostname === 'api.minimaxi.com' || hostname.endsWith('.minimaxi.com')) {
+            return 'minimax-cn';
+        }
+    }
+    catch {
+        // ignore parse failures; handled by prior validation
+    }
+    return null;
+}
 /** Sentinel returned by runStep when the user cancels — tells the caller
  *  to abort the entire wizard. */
 const STEP_CANCELLED = Symbol('step-cancelled');
@@ -558,9 +590,22 @@ async function runCustomOpenAIFlow(p, pc, authStorage) {
     if (p.isCancel(modelId) || !modelId)
         return false;
     const trimmedModelId = modelId.trim();
+    const nativeProvider = detectNativeProviderFromBaseUrl(trimmedUrl);
+    if (nativeProvider) {
+        const envVar = nativeProvider === 'minimax' ? 'MINIMAX_API_KEY' : 'MINIMAX_CN_API_KEY';
+        authStorage.set(nativeProvider, { type: 'api_key', key: trimmedKey });
+        persistDefaultProvider(nativeProvider);
+        persistDefaultModel(trimmedModelId);
+        process.env[envVar] = trimmedKey;
+        p.log.success(`${pc.green('MiniMax')} detected — configured as native provider (${pc.cyan(nativeProvider)})`);
+        p.log.info(`Model: ${pc.cyan(trimmedModelId)}`);
+        p.log.info(pc.dim('Using Anthropic-compatible MiniMax integration for full model metadata and clean thinking output.'));
+        return true;
+    }
     // Save API key to auth storage
     authStorage.set('custom-openai', { type: 'api_key', key: trimmedKey });
     persistDefaultProvider('custom-openai');
+    persistDefaultModel(trimmedModelId);
     // Write or merge into models.json
     const modelsJsonPath = join(agentDir, 'models.json');
     let config = { providers: {} };
@@ -704,10 +749,11 @@ export async function runToolKeysStep(p, pc, authStorage) {
 }
 // ─── Remote Questions Step ────────────────────────────────────────────────────
 export async function runRemoteQuestionsStep(p, pc, authStorage) {
-    // 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);
+    // 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;
+    };
     const hasDiscord = hasValidKey('discord_bot');
     const hasSlack = hasValidKey('slack_bot');
     const hasTelegram = hasValidKey('telegram_bot');
@@ -905,7 +951,6 @@ 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, "getCredentialsForProvider">;
+    authStorage: Pick<AuthStorage, "get">;
     isClaudeCodeReady: boolean;
     defaultProvider: string | undefined;
     env?: NodeJS.ProcessEnv;
 };
-export declare function hasDirectAnthropicApiKey(authStorage: Pick<AuthStorage, "getCredentialsForProvider">, env?: NodeJS.ProcessEnv): boolean;
+export declare function hasDirectAnthropicApiKey(authStorage: Pick<AuthStorage, "get">, env?: NodeJS.ProcessEnv): boolean;
 export declare function shouldMigrateAnthropicToClaudeCode({ authStorage, isClaudeCodeReady, defaultProvider, env, }: AnthropicMigrationDeps): boolean;
 export {};

package/dist/provider-migrations.js

@@ -2,7 +2,8 @@ export function hasDirectAnthropicApiKey(authStorage, env = process.env) {
     if ((env.ANTHROPIC_API_KEY ?? "").trim()) {
         return true;
     }
-    return authStorage.getCredentialsForProvider("anthropic").some((credential) => credential?.type === "api_key" && typeof credential?.key === "string" && credential.key.trim().length > 0);
+    const credential = authStorage.get("anthropic");
+    return 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 = content;
+    let next;
     if (fmMatch) {
         let frontmatter = fmMatch[1];
         const regex = /remote_questions:[\s\S]*?(?=\n[a-zA-Z_]|\n---|$)/;

package/dist/resource-loader.d.ts

@@ -21,6 +21,6 @@ export declare function getNewerManagedResourceVersion(agentDir: string, current
  *
  * Inspectable: `ls ~/.gsd/agent/extensions/`
  */
-export declare function initResources(agentDir: string): void;
+export declare function initResources(agentDir: string, skillsDir?: string): void;
 export declare function hasStaleCompiledExtensionSiblings(extensionsDir: string, sourceDir?: string): boolean;
 export declare function buildResourceLoader(agentDir: string): DefaultResourceLoader;

package/dist/resource-loader.js

@@ -506,7 +506,7 @@ function pruneRemovedBundledExtensions(manifest, agentDir) {
  *
  * Inspectable: `ls ~/.gsd/agent/extensions/`
  */
-export function initResources(agentDir) {
+export function initResources(agentDir, skillsDir = join(homedir(), '.agents', 'skills')) {
     mkdirSync(agentDir, { recursive: true });
     const currentVersion = getBundledGsdVersion();
     const manifest = readManagedResourceManifest(agentDir);
@@ -538,13 +538,7 @@ export function initResources(agentDir) {
     // Sync bundled resources — overwrite so updates land on next launch.
     syncResourceDir(bundledExtensionsDir, join(agentDir, 'extensions'));
     syncResourceDir(join(resourcesDir, 'agents'), join(agentDir, 'agents'));
-    // Skills are no longer force-synced here. Users install skills via the
-    // skills.sh CLI (`npx skills add <repo>`) into ~/.agents/skills/ which
-    // is the industry-standard Agent Skills ecosystem directory.
-    //
-    // Migration from the legacy ~/.gsd/agent/skills/ directory is handled
-    // above the manifest check so it runs on every launch (including retries
-    // after partial copy failures).
+    syncResourceDir(join(resourcesDir, 'skills'), skillsDir);
     // Sync GSD-WORKFLOW.md to agentDir as a fallback for when GSD_WORKFLOW_PATH
     // env var is not set (e.g. fork/dev builds, alternative entry points).
     const workflowSrc = join(resourcesDir, 'GSD-WORKFLOW.md');

package/dist/resources/agents/researcher.md

@@ -1,7 +1,7 @@
 ---
 name: researcher
 description: Web researcher that finds and synthesizes current information using Brave Search
-tools: search-the-web, bash
+tools: search-the-web, bash, capture_thought, memory_query, gsd_graph
 ---
 
 You are a web researcher. You find current, accurate information using web search and synthesize it into a clear, well-structured report.

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, sanitizeCommand, DEFAULT_MAX_BYTES, DEFAULT_MAX_LINES, } from "@gsd/pi-coding-agent";
+import { getShellConfig, DEFAULT_MAX_BYTES, DEFAULT_MAX_LINES, sanitizeCommand, } from "@gsd/pi-coding-agent";
 import { Type } from "@sinclair/typebox";
 import { spawn, spawnSync } from "node:child_process";
 import { createWriteStream } from "node:fs";

package/dist/resources/extensions/aws-auth/index.js

@@ -133,6 +133,7 @@ export default function (pi) {
         const refreshed = await runRefresh(refreshCommand, (m, level) => ctx.ui.notify(m, level));
         if (!refreshed)
             return;
-        pi.retryLastTurn();
+        // retryLastTurn removed in pi 0.67.2 — notify user to retry manually
+        ctx.ui.notify("AWS credentials refreshed. Please resend your message to retry.", "info");
     });
 }

package/dist/resources/extensions/bg-shell/bg-shell-lifecycle.js

@@ -3,7 +3,7 @@
  * context injection, process discovery, footer widget, and periodic maintenance.
  */
 import { truncateToWidth, visibleWidth, } from "@gsd/pi-tui";
-import { processes, pendingAlerts, pushAlert, cleanupAll, cleanupSessionProcesses, persistManifest, loadManifest, pruneDeadProcesses, } from "./process-manager.js";
+import { processes, pendingAlerts, pushAlert, cleanupAll, persistManifest, loadManifest, pruneDeadProcesses, } from "./process-manager.js";
 import { formatUptime, getBgShellLiveCwd, resolveBgShellPersistenceCwd } from "./utilities.js";
 import { formatTokenCount } from "../shared/format-utils.js";
 export function registerBgShellLifecycle(pi, state) {
@@ -66,14 +66,11 @@ export function registerBgShellLifecycle(pi, state) {
         buildProcessStateAlert("Session tree was navigated.");
     });
     // Session switch resets the agent's context.
-    pi.on("session_switch", async (event, ctx) => {
+    pi.on("session_start", async (_event, ctx) => {
         state.latestCtx = ctx;
-        if (event.reason === "new" && event.previousSessionFile) {
-            await cleanupSessionProcesses(event.previousSessionFile);
-            syncLatestCtxCwd();
-            if (state.latestCtx)
-                persistManifest(state.latestCtx.cwd);
-        }
+        syncLatestCtxCwd();
+        if (state.latestCtx)
+            persistManifest(state.latestCtx.cwd);
         buildProcessStateAlert("Session was switched.");
     });
     // ── Context Injection: Proactive Alerts ────────────────────────────
@@ -341,7 +338,7 @@ export function registerBgShellLifecycle(pi, state) {
     pi.on("turn_end", refreshHandler);
     pi.on("agent_end", refreshHandler);
     pi.on("session_start", refreshHandler);
-    pi.on("session_switch", refreshHandler);
+    pi.on("session_before_switch", refreshHandler);
     pi.on("tool_execution_end", async (_event, ctx) => {
         state.latestCtx = ctx;
         refreshWidget();

package/dist/resources/extensions/bg-shell/process-manager.js

@@ -6,7 +6,8 @@ import { spawn, spawnSync } from "node:child_process";
 import { randomUUID } from "node:crypto";
 import { writeFileSync, readFileSync, existsSync, mkdirSync } from "node:fs";
 import { join } from "node:path";
-import { getShellConfig, sanitizeCommand } from "@gsd/pi-coding-agent";
+import { getShellConfig } from "@gsd/pi-coding-agent";
+import { sanitizeCommand } from "@gsd/pi-coding-agent";
 import { rewriteCommandWithRtk } from "../shared/rtk.js";
 import { MAX_BUFFER_LINES, MAX_EVENTS, DEAD_PROCESS_TTL, } from "./types.js";
 import { restoreWindowsVTInput, formatUptime } from "./utilities.js";

package/dist/resources/extensions/browser-tools/index.js

@@ -1,4 +1,3 @@
-/** browser-tools — pi extension: full browser interaction via Playwright. */
 import { importExtensionModule } from "@gsd/pi-coding-agent";
 let registrationPromise = null;
 async function registerBrowserTools(pi) {

package/dist/resources/extensions/claude-code-cli/index.js

@@ -16,9 +16,9 @@ import { streamViaClaudeCode } from "./stream-adapter.js";
 export default function claudeCodeCli(pi) {
     pi.registerProvider("claude-code", {
         authMode: "externalCli",
+        isReady: isClaudeCodeReady,
         api: "anthropic-messages",
         baseUrl: "local://claude-code",
-        isReady: isClaudeCodeReady,
         streamSimple: streamViaClaudeCode,
         models: CLAUDE_CODE_MODELS,
     });