gsd-pi 2.80.0-dev.fbe7c8c6f → 2.81.0

package/README.md

@@ -27,75 +27,49 @@ One command. Walk away. Come back to a built project with clean git history.
 
 ---
 
-## What's New in v2.79
+## What's New in v2.80
 
-### DB-Authoritative Runtime State
+### DB-Authoritative Context
 
-- **Auto-mode coordination tables (#5247)** — workers, leases, dispatches, and a command queue are now first-class DB rows, replacing ad-hoc files for cross-process auto coordination.
-- **`auto.lock` + `paused-session.json` → DB (#5250)** — phase C pt 2 of the runtime-state migration. The on-disk lockfile and paused-session JSON are gone; lock acquisition, stale-lock detection, and pause state all live in `gsd.db`.
-- **Stuck-state migration (#5249)** — `copyPlanningArtifacts` / `reconcile` deleted; auto-mode writers canonicalize through the DB instead of mirroring artifacts to disk.
-- **`gsd headless recover`** — non-TTY DB recovery command for unattended environments where the interactive recover flow can't run.
-- **Doctor surfaces DB locks** — `gsd doctor` reports DB-backed stale locks and flags exhausted `run-uat` retry counters so wedged runs are visible without log archaeology.
+- **UOK contracts are DB-authoritative** — runtime contract state now flows through the database instead of file-first projections.
+- **Auto-run context mode fully wired** — context-mode execution is connected end-to-end for auto runs.
+- **Planned slice recovery** — planned slices recover correctly after artifact writes.
 
-### Workspace & Worktree Isolation
+### Auto, Deep Mode & Gates
 
-- **`GsdWorkspace` + `MilestoneScope` handle types** — workspace identity is now an explicit handle threaded through writers, metrics, and the DB connection instead of a module singleton.
-- **Symlink-safe canonicalization** — `deriveState` read root and cache key are canonicalized; path normalization unified on `realpathSync.native`; `gsdRootCache` keys normalized and decoupled from per-turn cache clears; `git-root` anchor guarded against `~/.gsd` resolution.
-- **Worktree-scoped DB + metrics** — `gsd-db` connections and metrics ledgers are scoped by workspace identity, so concurrent milestones in separate worktrees can't cross-contaminate state.
-- **Worktree cwd anchoring** — subagent dispatch anchors to the canonical worktree path, `mergeAndExit` anchors cwd at project root (closes [#5079](https://github.com/gsd-build/GSD-2/issues/5079)), MCP cwd is hardened against drift, and dispatch stops on cwd anchor failures.
-- **Slice isolation through resolver (#5246)** — slice merge isolation routed through the worktree resolver; `originalBase` checks use `isSamePath` instead of string equality; `auto-worktree` validates `milestoneId` match in `ByScope` wrappers.
-- **Worktree CLI commands** — `gsd worktree {list, merge, clean, remove}` exposed in the TUI dispatcher.
+- **Deep queued milestones continue** — deep project milestones can resume through queued work instead of stalling.
+- **Deep project registration** — deep project milestones are registered as part of the workflow.
+- **Depth-verification gate fixes** — gate workflow regressions were closed, including case-insensitive plan-slice artifact resolution.
+- **Task commits bound to milestone completion** — automated task commits now respect the milestone completion guard.
 
-### Deep Planning Mode (Phase 11)
+### MCP, Post-Exec & Cross-Platform
 
-- **`/gsd new-project --deep`** — opt-in deep mode for new projects, with `research-decision` and `research-project` dispatch units, deep-mode artifact validators, and gated approval flows that pause the milestone instead of aborting on grounding/discovery questions.
-- **EVAL-REVIEW system** — `/gsd eval-review` command, frontmatter schema, pre-ship soft warning when EVAL-REVIEW status is incomplete, and registration in the catalog + ops dispatcher.
-- **Project-shape-aware discuss depth** — discuss-phase questioning depth scales via the project-shape classifier; tiny apps cap research and auto-skip stale research blockers; deep research is opt-in and blocked while a marker is in flight.
-- **Approval-gate hardening** — deep approval gates verified, opening interview question protected from approval abort, plain-text setup approvals gated, deep setup state guarded against phantom transitions.
+- **Post-exec import hardening** — explicit extension fallbacks, dotted module stems, React Router `+types`, and `+types` guards are handled more carefully.
+- **MCP write gating** — `gsd_exec` writes are gated, with Windows path-separator test coverage tightened.
+- **Project saves stay successful** — saving a project no longer fails just because registration fails.
+- **Home-directory fallback** — `currentDirectoryRoot` uses `homedir()` fallback behavior for better cross-platform consistency.
 
-### Auto Pipeline & Dispatch
+### Reliability & Review Hardening
 
-- **Delegation-policy verdicts** — dispatch actions are annotated with a per-tool background-safety policy verdict; the policy itself is codified instead of inferred per call.
-- **Reactive-execute default** — auto-dispatch defaults to reactive-execute when ≥3 ready tasks are queued, replacing the always-sequential fallback.
-- **Proactive rate limiting (#2996)** — `min_request_interval_ms` preference paces auto-mode requests; the interval is stamped at dispatch.
-- **Manifest-driven skill surfacing** — `auto-prompts` surfaces manifest skills via recommendations + auto-match; planning-dispatch mode added to the unit manifest for slice plan/complete; runtime tools-policy enforced for planning units (#4934).
-- **Subagent telemetry** — dispatch telemetry, stronger prompt guidelines, and model-override threading (`??` consistently used for `modelOverride`).
+- **Auto orchestration seams and contracts** — orchestration boundaries were made more explicit and review feedback was folded in.
+- **Cancellation context preserved** — auto-mode pauses keep cancellation context instead of dropping it.
+- **Recovery stop lifecycle** — recovery stop now emits the expected lifecycle event.
+- **Trace and cleanup fixes** — trace correlation, cleanup-on-throw, audit context reset, and `onTurnResult` phase-result guards were tightened.
 
-### MCP, Models & Cross-Platform
+See the full [Changelog](./CHANGELOG.md) for the complete v2.80 entry and prior releases.
 
-- **Global MCP config** — `mcp-client` reads `~/.gsd/mcp.json` for user-level MCP server config.
-- **`ask_user_questions` over MCP** — host elicitation tried before remote channel; multi-select array shape preserved; explicit cancellation handled; remote answers normalized into `structuredContent`.
-- **Model routing overhaul** — cross-provider tier resolution, provider-agnostic profile-tier defaults, disabled-provider routing denylist, resolved tier model IDs normalized, and `findModelForTier` with behavioral tests.
-- **Ollama** — configurable probe/request timeouts via env vars (clamped); cloud / long-variant context windows reported correctly.
-- **Windows fixes** — home directory resolved correctly (#5015), `Path` env lookup repaired, Windows-safe env CLI shims, DEP0190 avoided in Claude CLI binary probes, tool-bootstrap skipped when tools are on PATH.
-- **Anthropic prompt-cache preserved (#5019)** — `pi-coding-agent` and `gsd` no longer thrash the cache on dispatch.
-
-### Git, GitHub Sync & Reliability
-
-- **Integration-branch self-merge guard (#5024)** — milestone refuses to self-merge when the integration branch equals the milestone branch; self-merge ref guard normalized.
-- **Slice-cadence safety** — integration branch used for slice cadence, dirty worktree state preserved on merge, checked-out slice worktrees advance safely, slice PRs deferred until completion, slice-PR sync stays retryable on failure.
-- **Milestone-ID reservation** — DB rows included in reservation; ghost IDs reused in `nextMilestoneId` to close gaps; `ensurePreconditions` guarded against phantom IDs (#4996); orphan milestone-dir doctor check (#4996); milestone-dir creation deferred until first artifact write.
-- **Auto-commit hygiene** — task commits scoped to reported files, generated commit subjects sanitized, user hooks run on automated commits, milestone-tagged commits bound when `.gsd/` is gitignored (#5033), startup blocked on `git index.lock`.
-- **GitHub sync** — issues no longer closed before delivery, failed task closure / slice PR sync stay retryable, config cache scoped by project, safe git environment used.
-
-### Safety, Recovery & Hardening
-
-- **Policy-block pause through dispatch errors** — pause state is preserved when dispatch errors out mid-policy-block.
-- **Skip-validation persistence** — skip-validation state persists and gate rows are cleared on recover.
-- **Cancelled-gate hard block** — redirected to `ask_user_questions`; false plain-text claim dropped from the message.
-- **Write-gate basePath required** — `process.cwd()` defaults removed; basePath threaded through pre-existing tests.
-- **Atomic metrics writes** — parallel-mode `metrics.json` writes merge atomically; ledger cache invalidated after prune; `saveLedger` aborts when lock not acquired; stale-lock detection adds PID stamp + async yield.
-- **Auto-worktree teardown** — `activeWorkspace` guaranteed cleared on teardown failure; teardown try/finally broadened to cover `chdir`; cleanup steps mirrored on the abort path; warning emitted on resume when persisted worktree is missing.
-- **Empty-turn nudge** — no longer auto-replies to user questions; deferred on mid-line approval prompts.
-- **Refuses project writes from `$HOME`** — and surfaces real SQL errors from `capture_thought` instead of swallowing them.
-
-### VS Code & TUI
+<details>
+<summary>v2.79 highlights</summary>
 
-- **Checkpoint tree view** — registered in the VS Code extension; checkpoint file existence restored; RPC file-mutation events tracked; agent diff scoped to tracked files.
-- **TUI image paste** — pasted images preserved on regular submit.
-- **Bundled `/gsd` slash command protected** — core handler refuses to overwrite the bundled command.
+- **DB-backed runtime coordination** — workers, leases, dispatches, command queue, locks, paused-session state, and stuck-state recovery moved into `gsd.db`
+- **Workspace/worktree isolation** — `GsdWorkspace` and `MilestoneScope` handles, symlink-safe canonicalization, worktree-scoped DB/metrics, cwd anchoring, and `gsd worktree {list, merge, clean, remove}`
+- **Deep planning mode** — `/gsd new-project --deep`, research dispatch units, EVAL-REVIEW, project-shape-aware questioning, and approval-gate hardening
+- **Auto pipeline upgrades** — delegation-policy verdicts, reactive-execute default, proactive rate limiting, manifest-driven skill surfacing, and subagent telemetry
+- **MCP/model/cross-platform fixes** — global MCP config, `ask_user_questions` over MCP, provider-agnostic model routing, Ollama timeouts, Windows fixes, and Anthropic prompt-cache preservation
+- **Git and recovery reliability** — self-merge guards, safer slice cadence, milestone-ID reservation, auto-commit hygiene, retryable GitHub sync, atomic metrics writes, and stronger teardown handling
+- **VS Code and TUI polish** — checkpoint tree view, image paste preservation, and bundled `/gsd` slash command protection
 
-See the full [Changelog](./CHANGELOG.md) for the complete v2.79 entry and prior releases.
+</details>
 
 <details>
 <summary>v2.78 highlights</summary>
@@ -259,6 +233,7 @@ Full documentation is in the [`docs/`](./docs/) directory:
 
 - **[Architecture](./docs/dev/architecture.md)** — system design and dispatch pipeline
 - **[CI/CD Pipeline](./docs/dev/ci-cd-pipeline.md)** — three-stage promotion pipeline (Dev → Test → Prod)
+- **[E2E Testing](./tests/e2e/README.md)** — real-process CLI/runtime coverage and CI runner expectations
 - **[Pipeline Simplification (ADR-003)](./docs/dev/ADR-003-pipeline-simplification.md)** — merged research into planning, mechanical completion
 - **[VS Code Extension](./vscode-extension/README.md)** — chat participant, sidebar dashboard, RPC integration
 
@@ -361,7 +336,7 @@ The database is authoritative for milestones, slices, tasks, requirements, decis
 
 2. **Context pre-loading** — The dispatch prompt includes inlined task plans, slice plans, prior task summaries, dependency summaries, roadmap excerpts, and decisions register. The LLM starts with everything it needs instead of spending tool calls reading files.
 
-3. **Context Mode** — Context Mode is enabled by default and gives every auto-mode unit guidance for preserving context. Agents are steered toward `gsd_exec` for noisy scans, builds, tests, and diagnostics; full stdout/stderr is saved under `.gsd/exec/` while only a short digest enters the conversation. `gsd_exec_search` lets agents reuse prior runs instead of repeating expensive checks, and `gsd_resume` reads `.gsd/last-snapshot.md` after compaction or resume. Opt out with `context_mode.enabled: false`; tune sandbox timeout/output caps with `context_mode.exec_timeout_ms`, `context_mode.exec_stdout_cap_bytes`, and `context_mode.exec_digest_chars`.
+3. **Context Mode** — Context Mode is enabled by default and gives eligible auto-mode units guidance for preserving context. Agents are steered toward `gsd_exec` for noisy scans, builds, tests, and diagnostics; capped stdout/stderr and metadata are saved under `.gsd/exec/` while only a short digest enters the conversation. `gsd_exec_search` lets agents reuse prior runs instead of repeating expensive checks, and `gsd_resume` reads a prior compaction snapshot from `.gsd/last-snapshot.md` when one exists. Opt out with `context_mode.enabled: false` to disable Context Mode guidance, snapshot injection, `gsd_exec`, `gsd_exec_search`, and `gsd_resume`; tune sandbox timeout/output caps and environment forwarding with `context_mode.exec_timeout_ms`, `context_mode.exec_stdout_cap_bytes`, `context_mode.exec_digest_chars`, and `context_mode.exec_env_allowlist`.
 
 4. **Git isolation** — When `git.isolation` is set to `worktree` or `branch`, each milestone runs on its own `milestone/<MID>` branch (in a worktree or in-place). All slice work commits sequentially — no branch switching, no merge conflicts. When the milestone completes, it's squash-merged to main as one clean commit. The default is `none` (work on the current branch), configurable via preferences. If `worktree` is configured in a repo with no committed `HEAD`, GSD temporarily behaves as `none` until the first commit exists because git worktrees need a committed start point.
 
@@ -659,10 +634,11 @@ auto_report: true
 | `unique_milestone_ids`            | Uses unique milestone names to avoid clashes when working in teams of people                          |
 | `git.isolation`                   | `none` (default), `worktree`, or `branch` — enable worktree or branch isolation for milestone work. `worktree` requires a committed `HEAD`; zero-commit repos temporarily run as `none`    |
 | `git.manage_gitignore`            | Set `false` to prevent GSD from modifying `.gitignore`                                                |
-| `context_mode.enabled`            | Context Mode is default-on; set `false` to disable `gsd_exec`, exec history guidance, and resume snapshots |
+| `context_mode.enabled`            | Context Mode is default-on; set `false` to disable prompt guidance, snapshot injection, `gsd_exec`, `gsd_exec_search`, and `gsd_resume` |
 | `context_mode.exec_timeout_ms`    | Timeout for sandboxed `gsd_exec` runs (default: 30000)                                                |
 | `context_mode.exec_stdout_cap_bytes` | Persisted stdout cap for `gsd_exec` output (default: 1048576)                                      |
 | `context_mode.exec_digest_chars`  | Trailing stdout characters returned to the agent context (default: 300)                              |
+| `context_mode.exec_env_allowlist` | Environment variables forwarded to sandboxed `gsd_exec` runs in addition to `PATH` and `HOME`        |
 | `verification_commands`           | Array of shell commands to run after task execution (e.g., `["npm run lint", "npm run test"]`)        |
 | `verification_auto_fix`           | Auto-retry on verification failures (default: true)                                                   |
 | `verification_max_retries`        | Max retries for verification failures (default: 2)                                                    |

package/dist/claude-cli-check.d.ts

@@ -1,3 +1,16 @@
+/**
+ * Spawn the Claude CLI without triggering Node's DEP0190.
+ *
+ * Passing `args` together with `shell: true` is deprecated in Node 22+
+ * because the args are concatenated into the command string without
+ * escaping. On Windows we still need a shell to resolve `.cmd` shims, so
+ * we invoke `cmd /c <command> <args...>` explicitly. On POSIX we don't
+ * need a shell at all.
+ */
+export declare function buildClaudeSpawnInvocation(command: string, args: string[], platform?: NodeJS.Platform): {
+    command: string;
+    args: string[];
+};
 /**
  * Platform-correct binary name for the Claude Code CLI.
  *
@@ -7,7 +20,24 @@
  * authenticated. Mirrors the `NPM_COMMAND` pattern in
  * `src/resources/extensions/gsd/pre-execution-checks.ts`.
  */
+export declare function getClaudeCommand(platform?: NodeJS.Platform): string;
 export declare const CLAUDE_COMMAND: string;
+/**
+ * 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.
+ */
+export declare function getClaudeCommandCandidates(platform?: NodeJS.Platform): string[];
+/**
+ * Decide auth state from `claude auth status` output.
+ *
+ * Newer Claude CLI builds emit JSON with a `loggedIn` boolean. Older builds
+ * emit free-form text. Prefer the structured signal; fall back to a text
+ * heuristic. The text heuristic only covers English phrasing.
+ */
+export declare function parseAuthStatus(output: string): boolean | null;
 /**
  * Check if the `claude` binary is installed (regardless of auth state).
  */

package/dist/claude-cli-check.js

@@ -14,11 +14,15 @@ import { execFileSync } from 'node:child_process';
  * we invoke `cmd /c <command> <args...>` explicitly. On POSIX we don't
  * need a shell at all.
  */
-function spawnClaude(command, args, opts) {
-    if (process.platform === 'win32') {
-        return execFileSync('cmd', ['/c', command, ...args], opts);
+export function buildClaudeSpawnInvocation(command, args, platform = process.platform) {
+    if (platform === 'win32') {
+        return { command: 'cmd', args: ['/c', command, ...args] };
     }
-    return execFileSync(command, args, opts);
+    return { command, args };
+}
+function spawnClaude(command, args, opts) {
+    const invocation = buildClaudeSpawnInvocation(command, args);
+    return execFileSync(invocation.command, invocation.args, opts);
 }
 /**
  * Platform-correct binary name for the Claude Code CLI.
@@ -29,7 +33,10 @@ function spawnClaude(command, args, opts) {
  * authenticated. Mirrors the `NPM_COMMAND` pattern in
  * `src/resources/extensions/gsd/pre-execution-checks.ts`.
  */
-export const CLAUDE_COMMAND = process.platform === 'win32' ? 'claude.cmd' : 'claude';
+export function getClaudeCommand(platform = process.platform) {
+    return platform === 'win32' ? 'claude.cmd' : 'claude';
+}
+export const CLAUDE_COMMAND = getClaudeCommand();
 /**
  * Ordered list of binary names to probe for the Claude Code CLI.
  *
@@ -37,7 +44,11 @@ export const CLAUDE_COMMAND = process.platform === 'win32' ? 'claude.cmd' : 'cla
  * 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];
+export function getClaudeCommandCandidates(platform = process.platform) {
+    const command = getClaudeCommand(platform);
+    return platform === 'win32' ? [command, 'claude.exe', 'claude'] : [command];
+}
+const CLAUDE_COMMAND_CANDIDATES = getClaudeCommandCandidates();
 const VERSION_TIMEOUT_MS = 5_000;
 // Auth probe needs more headroom on Windows because the spawn goes through
 // cmd.exe → claude.cmd → node → Claude CLI.
@@ -80,7 +91,7 @@ function findWorkingCommand() {
  * emit free-form text. Prefer the structured signal; fall back to a text
  * heuristic. The text heuristic only covers English phrasing.
  */
-function parseAuthStatus(output) {
+export function parseAuthStatus(output) {
     const trimmed = output.trim();
     if (!trimmed)
         return null;

package/dist/cli.js

@@ -760,25 +760,6 @@ if (!process.stdin.isTTY || !process.stdout.isTTY) {
             : 'stdout is';
     printNonTtyErrorAndExit(missing, true);
 }
-// Welcome screen — shown on every fresh interactive session before TUI takes over.
-// Skip when the first-run banner was already printed in loader.ts (prevents double banner).
-if (!process.env.GSD_FIRST_RUN_BANNER) {
-    const { printWelcomeScreen } = await import('./welcome-screen.js');
-    let remoteChannel;
-    try {
-        const { resolveRemoteConfig } = await import('./resources/extensions/remote-questions/config.js');
-        const rc = resolveRemoteConfig();
-        if (rc)
-            remoteChannel = rc.channel;
-    }
-    catch { /* non-fatal */ }
-    printWelcomeScreen({
-        version: process.env.GSD_VERSION || '0.0.0',
-        modelName: settingsManager.getDefaultModel() || undefined,
-        provider: settingsManager.getDefaultProvider() || undefined,
-        remoteChannel,
-    });
-}
 const interactiveMode = new InteractiveMode(session);
 markStartup('InteractiveMode');
 printStartupTimings();

package/dist/headless-query.d.ts

@@ -36,6 +36,13 @@ export declare function shouldUseAgentExtensionsDir(opts: {
     agentDir: string;
     useAgentDir: boolean;
 };
+declare function loadExtensionModules(): Promise<{
+    openProjectDbIfPresent: (basePath: string) => Promise<void>;
+    deriveState: (basePath: string) => Promise<GSDState>;
+    resolveDispatch: (opts: any) => Promise<any>;
+    readAllSessionStatuses: (basePath: string) => any[];
+    loadEffectiveGSDPreferences: () => any;
+}>;
 export interface QuerySnapshot {
     state: GSDState;
     next: {
@@ -59,4 +66,7 @@ export interface QueryResult {
     exitCode: number;
     data?: QuerySnapshot;
 }
+type HeadlessQueryModules = Awaited<ReturnType<typeof loadExtensionModules>>;
+export declare function runHeadlessQuery(basePath: string, modules: HeadlessQueryModules, writeOutput?: (text: string) => void): Promise<QueryResult>;
 export declare function handleQuery(basePath: string): Promise<QueryResult>;
+export {};

package/dist/headless-query.js

@@ -77,9 +77,8 @@ async function loadExtensionModules() {
         loadEffectiveGSDPreferences: prefsModule.loadEffectiveGSDPreferences,
     };
 }
-// ─── Implementation ─────────────────────────────────────────────────────────
-export async function handleQuery(basePath) {
-    const { openProjectDbIfPresent, deriveState, resolveDispatch, readAllSessionStatuses, loadEffectiveGSDPreferences, } = await loadExtensionModules();
+export async function runHeadlessQuery(basePath, modules, writeOutput = (text) => process.stdout.write(text)) {
+    const { openProjectDbIfPresent, deriveState, resolveDispatch, readAllSessionStatuses, loadEffectiveGSDPreferences, } = modules;
     await openProjectDbIfPresent(basePath);
     const state = await deriveState(basePath);
     // Derive next dispatch action
@@ -120,6 +119,9 @@ export async function handleQuery(basePath) {
         next,
         cost: { workers, total: workers.reduce((sum, w) => sum + w.cost, 0) },
     };
-    process.stdout.write(JSON.stringify(snapshot) + '\n');
+    writeOutput(JSON.stringify(snapshot) + '\n');
     return { exitCode: 0, data: snapshot };
 }
+export async function handleQuery(basePath) {
+    return runHeadlessQuery(basePath, await loadExtensionModules());
+}

package/dist/loader-entrypoint.d.ts

@@ -0,0 +1,8 @@
+export interface LoaderEntrypointOptions {
+    gsdRoot: string;
+    invokedBinPath: string | undefined;
+    env?: NodeJS.ProcessEnv;
+    existsSync?: (path: string) => boolean;
+}
+export declare function resolveLoaderCliEntrypoint({ gsdRoot, invokedBinPath, env, existsSync, }: LoaderEntrypointOptions): string | undefined;
+export declare function applyLoaderCliEntrypointEnv(env: NodeJS.ProcessEnv, options: LoaderEntrypointOptions): string | undefined;

package/dist/loader-entrypoint.js

@@ -0,0 +1,27 @@
+// GSD-2 - Loader child-process entrypoint resolution helpers.
+import { existsSync as defaultExistsSync } from "node:fs";
+import { join, resolve } from "node:path";
+export function resolveLoaderCliEntrypoint({ gsdRoot, invokedBinPath, env = process.env, existsSync = defaultExistsSync, }) {
+    const sourceLoaderPath = join(gsdRoot, "src", "loader.ts");
+    const devCliPath = env.GSD_DEV_CLI_PATH?.trim() || join(gsdRoot, "scripts", "dev-cli.js");
+    const explicitCliPath = env.GSD_CLI_PATH?.trim() || env.GSD_BIN_PATH?.trim();
+    const isSourceLoader = Boolean(invokedBinPath && resolve(invokedBinPath) === sourceLoaderPath);
+    const rawGsdBinPath = explicitCliPath || (isSourceLoader && existsSync(devCliPath) ? devCliPath : invokedBinPath);
+    return rawGsdBinPath ? resolve(rawGsdBinPath) : undefined;
+}
+export function applyLoaderCliEntrypointEnv(env, options) {
+    const resolvedGsdBinPath = resolveLoaderCliEntrypoint({ ...options, env });
+    if (resolvedGsdBinPath) {
+        env.GSD_BIN_PATH = resolvedGsdBinPath;
+        if (!env.GSD_CLI_PATH) {
+            env.GSD_CLI_PATH = resolvedGsdBinPath;
+        }
+    }
+    else {
+        delete env.GSD_BIN_PATH;
+        if (!env.GSD_CLI_PATH) {
+            delete env.GSD_CLI_PATH;
+        }
+    }
+    return resolvedGsdBinPath;
+}

package/dist/loader.js

@@ -63,6 +63,7 @@ import { serializeBundledExtensionPaths } from './bundled-extension-paths.js';
 import { resolveBundledResourcesDirFromPackageRoot } from './bundled-resource-path.js';
 import { discoverExtensionEntryPaths } from './extension-discovery.js';
 import { loadRegistry, readManifestFromEntryPath, isExtensionEnabled } from './extension-registry.js';
+import { applyLoaderCliEntrypointEnv } from './loader-entrypoint.js';
 import { renderLogo } from './logo.js';
 // pkg/ is a shim directory: contains gsd's piConfig (package.json) and pi's
 // theme assets (dist/modes/interactive/theme/) without a src/ directory.
@@ -117,17 +118,7 @@ process.env.GSD_VERSION = gsdVersion;
 // subagent/parallel workers to spawn gsd instead of pi when dispatching
 // workflow tasks. In source-dev mode this must remain scripts/dev-cli.js, not
 // src/loader.ts, because child processes need the --import resolve-ts wrapper.
-const invokedBinPath = process.argv[1];
-const sourceLoaderPath = join(gsdRoot, 'src', 'loader.ts');
-const devCliPath = process.env.GSD_DEV_CLI_PATH?.trim() || join(gsdRoot, 'scripts', 'dev-cli.js');
-const explicitCliPath = process.env.GSD_CLI_PATH?.trim() || process.env.GSD_BIN_PATH?.trim();
-const isSourceLoader = invokedBinPath && resolve(invokedBinPath) === sourceLoaderPath;
-const rawGsdBinPath = explicitCliPath || (isSourceLoader && existsSync(devCliPath) ? devCliPath : invokedBinPath);
-const resolvedGsdBinPath = rawGsdBinPath ? resolve(rawGsdBinPath) : undefined;
-process.env.GSD_BIN_PATH = resolvedGsdBinPath;
-if (!process.env.GSD_CLI_PATH) {
-    process.env.GSD_CLI_PATH = resolvedGsdBinPath;
-}
+applyLoaderCliEntrypointEnv(process.env, { gsdRoot, invokedBinPath: process.argv[1] });
 // GSD_WORKFLOW_PATH — absolute path to bundled GSD-WORKFLOW.md, used by patched gsd extension
 // when dispatching workflow prompts. Prefers dist/resources/ (stable, set at build time)
 // over src/resources/ (live working tree) — see resource-loader.ts for rationale.

package/dist/mcp-server.d.ts

@@ -22,6 +22,7 @@ export interface McpToolDef {
         isError?: boolean;
     }>;
 }
+export declare function mcpSdkSpecifier(subpath: 'server/index' | 'server/stdio' | 'types'): string;
 /**
  * Starts a native MCP (Model Context Protocol) server over stdin/stdout.
  *

package/dist/mcp-server.js

@@ -29,6 +29,9 @@ function isPlainObject(value) {
 // built via a template string so TypeScript's NodeNext resolver treats them as
 // `any` and skips static checking.
 const MCP_PKG = '@modelcontextprotocol/sdk';
+export function mcpSdkSpecifier(subpath) {
+    return `${MCP_PKG}/${subpath}.js`;
+}
 /**
  * Starts a native MCP (Model Context Protocol) server over stdin/stdout.
  *
@@ -45,9 +48,9 @@ const MCP_PKG = '@modelcontextprotocol/sdk';
  */
 export async function startMcpServer(options) {
     const { tools, version = '0.0.0' } = options;
-    const serverMod = await import(`${MCP_PKG}/server/index.js`);
-    const stdioMod = await import(`${MCP_PKG}/server/stdio.js`);
-    const typesMod = await import(`${MCP_PKG}/types.js`);
+    const serverMod = await import(mcpSdkSpecifier('server/index'));
+    const stdioMod = await import(mcpSdkSpecifier('server/stdio'));
+    const typesMod = await import(mcpSdkSpecifier('types'));
     const Server = serverMod.Server;
     const StdioServerTransport = stdioMod.StdioServerTransport;
     const { ListToolsRequestSchema, CallToolRequestSchema } = typesMod;

package/dist/resources/.managed-resources-content-hash

@@ -1 +1 @@
-4b5e4f1bfb55a0a1
+195cc0a83851a027

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

@@ -23,11 +23,15 @@ import { execFileSync } from "node:child_process";
  * we invoke `cmd /c <command> <args...>` explicitly. On POSIX we don't
  * need a shell at all.
  */
-function spawnClaude(command, args, opts) {
-    if (process.platform === "win32") {
-        return execFileSync("cmd", ["/c", command, ...args], opts);
+export function buildClaudeSpawnInvocation(command, args, platform = process.platform) {
+    if (platform === "win32") {
+        return { command: "cmd", args: ["/c", command, ...args] };
     }
-    return execFileSync(command, args, opts);
+    return { command, args };
+}
+function spawnClaude(command, args, opts) {
+    const invocation = buildClaudeSpawnInvocation(command, args);
+    return execFileSync(invocation.command, invocation.args, opts);
 }
 /**
  * Candidate executable names for the Claude Code CLI.
@@ -35,14 +39,21 @@ function spawnClaude(command, args, opts) {
  * Keep the explicit win32 ternary selector for regression coverage (Issue #4424):
  * Node's execFileSync must target `claude.cmd` directly on Windows.
  */
-const CLAUDE_COMMAND = process.platform === "win32" ? "claude.cmd" : "claude";
+export function getClaudeCommand(platform = process.platform) {
+    return platform === "win32" ? "claude.cmd" : "claude";
+}
+const CLAUDE_COMMAND = getClaudeCommand();
 /**
  * Windows installs vary: some environments expose `claude.cmd` (npm shim),
  * `claude.exe` (direct binary install), or a bare `claude` shim on PATH
  * (for example Git Bash wrappers). Try all three to avoid false "not
  * installed" results in readiness checks.
  */
-const CLAUDE_COMMAND_CANDIDATES = process.platform === "win32" ? [CLAUDE_COMMAND, "claude.exe", "claude"] : [CLAUDE_COMMAND];
+export function getClaudeCommandCandidates(platform = process.platform) {
+    const command = getClaudeCommand(platform);
+    return platform === "win32" ? [command, "claude.exe", "claude"] : [command];
+}
+const CLAUDE_COMMAND_CANDIDATES = getClaudeCommandCandidates();
 // Keep the version probe snappy — `claude --version` is a quick path.
 const VERSION_TIMEOUT_MS = 5_000;
 // Auth status can be much slower on Windows because the spawn goes through
@@ -90,7 +101,7 @@ function findWorkingCommand() {
  * back to a text heuristic. Note: the text heuristic only covers English
  * phrasing — the JSON path is the durable signal.
  */
-function parseAuthStatus(output) {
+export function parseAuthStatus(output) {
     const trimmed = output.trim();
     if (!trimmed)
         return null;

package/dist/resources/extensions/claude-code-cli/stream-adapter.js

@@ -1,3 +1,4 @@
+// GSD2 - Claude Code CLI provider stream adapter
 /**
  * Stream adapter: bridges the Claude Agent SDK into GSD's streamSimple contract.
  *
@@ -16,6 +17,10 @@ import { dirname, join } from "node:path";
 import { PartialMessageBuilder, ZERO_USAGE, mapUsage } from "./partial-builder.js";
 import { buildWorkflowMcpServers } from "../gsd/workflow-mcp.js";
 import { showInterviewRound } from "../shared/tui.js";
+/** Resolve the workspace root for local Claude Code process execution. */
+export function resolveClaudeCodeCwd(options) {
+    return options?.cwd && options.cwd.trim().length > 0 ? options.cwd : process.cwd();
+}
 /** Label used for the free-text fallback option in single-choice elicitation questions. */
 const OTHER_OPTION_LABEL = "None of the above";
 /** Regex pattern that identifies field names and descriptions that should be treated as sensitive/secure inputs. */
@@ -261,6 +266,26 @@ function makeErrorMessage(model, errorMsg) {
         timestamp: Date.now(),
     };
 }
+export function isClaudeCodeAbortErrorMessage(message) {
+    if (!message)
+        return false;
+    return /\b(?:claude code process aborted by user|request aborted by user|process aborted by user)\b/i.test(message);
+}
+function isBareClaudeCodeAbortErrorMessage(message) {
+    if (!message)
+        return false;
+    const normalized = message.trim().replace(/\s+/g, " ").toLowerCase();
+    return normalized === "claude code process aborted by user"
+        || normalized === "request aborted by user"
+        || normalized === "process aborted by user";
+}
+export function resolveClaudeCodeAbortedMessageText(errorMsg, lastTextContent) {
+    const trimmedError = errorMsg.trim();
+    if (trimmedError && !isBareClaudeCodeAbortErrorMessage(trimmedError)) {
+        return trimmedError;
+    }
+    return lastTextContent;
+}
 /**
  * Generator exhaustion without a terminal result means the SDK stream was
  * interrupted mid-turn. Surface it as an error so downstream recovery logic
@@ -1031,8 +1056,9 @@ function mapThinkingLevelToAnthropicEffort(level, modelId) {
  * behaviour pass `permissionMode: "bypassPermissions"` explicitly.
  */
 export function buildSdkOptions(modelId, prompt, overrides, extraOptions = {}) {
-    const { reasoning, ...sdkExtraOptions } = extraOptions;
-    const mcpServers = buildWorkflowMcpServers();
+    const { reasoning, cwd, ...sdkExtraOptions } = extraOptions;
+    const sdkCwd = typeof cwd === "string" && cwd.trim().length > 0 ? cwd : process.cwd();
+    const mcpServers = buildWorkflowMcpServers(sdkCwd);
     const permissionMode = overrides?.permissionMode ?? "bypassPermissions";
     // Globally unblock the tools GSD expects Claude Code to run. When the
     // workflow MCP server is available, prefer its `ask_user_questions` tool over
@@ -1070,7 +1096,7 @@ export function buildSdkOptions(modelId, prompt, overrides, extraOptions = {}) {
         model: modelId,
         includePartialMessages: true,
         persistSession: true,
-        cwd: process.cwd(),
+        cwd: sdkCwd,
         permissionMode,
         allowDangerouslySkipPermissions: permissionMode === "bypassPermissions",
         settingSources: ["project"],
@@ -1332,12 +1358,14 @@ async function pumpSdkMessages(model, context, options, stream) {
         const queryPrompt = buildSdkQueryPrompt(context, prompt);
         const permissionMode = await resolveClaudePermissionMode();
         const uiContext = options?.extensionUIContext;
+        const cwd = resolveClaudeCodeCwd(options);
         const canUseToolHandler = createClaudeCodeCanUseToolHandler(uiContext);
         // When no UI is available (headless / auto-mode), auto-approve all
         // tool requests. This replaces the old bypassPermissions workaround.
         const canUseToolFallback = canUseToolHandler
             ?? (async (_toolName, _input, opts) => ({ behavior: "allow", toolUseID: opts.toolUseID }));
         const sdkOpts = buildSdkOptions(modelId, prompt, { permissionMode }, {
+            cwd,
             reasoning: options?.reasoning,
             canUseTool: canUseToolFallback,
             ...(uiContext
@@ -1512,6 +1540,15 @@ async function pumpSdkMessages(model, context, options, stream) {
     }
     catch (err) {
         const errorMsg = err instanceof Error ? err.message : String(err);
+        if (options?.signal?.aborted || isClaudeCodeAbortErrorMessage(errorMsg)) {
+            const abortedText = resolveClaudeCodeAbortedMessageText(errorMsg, lastTextContent);
+            stream.push({
+                type: "error",
+                reason: "aborted",
+                error: makeAbortedMessage(modelId, abortedText),
+            });
+            return;
+        }
         stream.push({
             type: "error",
             reason: "error",

package/dist/resources/extensions/github-sync/sync.js

@@ -79,6 +79,9 @@ export async function runGitHubSync(basePath, unitType, unitId) {
         debugLog("github-sync", { error: String(err) });
     }
 }
+export function shouldCreateSlicePrForSyncEvent(unitType, config) {
+    return unitType === "complete-slice" && config.slice_prs !== false;
+}
 // ─── Per-Event Sync Functions ───────────────────────────────────────────────
 async function syncMilestonePlan(basePath, mapping, config, mid) {
     // Skip if already synced
@@ -307,7 +310,7 @@ async function syncSliceComplete(basePath, mapping, config, mid, sid) {
     }
     if (!sliceRecord || sliceRecord.state === "closed")
         return;
-    if (!sliceRecord.prNumber && config.slice_prs !== false) {
+    if (!sliceRecord.prNumber && shouldCreateSlicePrForSyncEvent("complete-slice", config)) {
         await ensureSlicePullRequest(basePath, mapping, mid, sid);
         sliceRecord = getSliceRecord(mapping, mid, sid);
         if (!sliceRecord || !sliceRecord.prNumber)

package/dist/resources/extensions/gsd/auto/contracts.js

@@ -1 +1,3 @@
+// Project/App: GSD-2
+// File Purpose: Auto Orchestration module interfaces and ADR-015 invariant adapter contracts.
 export {};