gsd-pi 2.13.0 → 2.14.0

package/README.md

@@ -38,7 +38,7 @@ GSD v2 solves all of these because it's not a prompt framework anymore — it's
 | Context management   | Hope the LLM doesn't fill up | Fresh session per task, programmatic                    |
 | Auto mode            | LLM self-loop                | State machine reading `.gsd/` files                     |
 | Crash recovery       | None                         | Lock files + session forensics                          |
-| Git strategy         | LLM writes git commands      | Programmatic branch-per-slice, squash merge             |
+| Git strategy         | LLM writes git commands      | Worktree isolation, sequential commits, squash merge    |
 | Cost tracking        | None                         | Per-unit token/cost ledger with dashboard               |
 | Stuck detection      | None                         | Retry once, then stop with diagnostics                  |
 | Timeout supervision  | None                         | Soft/idle/hard timeouts with recovery steering          |
@@ -111,7 +111,7 @@ Auto mode is a state machine driven by files on disk. It reads `.gsd/STATE.md`,
 
 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. **Git branch-per-slice** — Each slice gets its own branch (`gsd/M001/S01`). Tasks commit atomically on the branch. When the slice completes, it's squash-merged to main (or whichever branch you started from) as one clean commit.
+3. **Git worktree isolation** — Each milestone runs in its own git worktree with a `milestone/<MID>` branch. 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.
 
 4. **Crash recovery** — A lock file tracks the current unit. If the session dies, the next `/gsd auto` reads the surviving session file, synthesizes a recovery briefing from every tool call that made it to disk, and resumes with full context.
 
@@ -268,7 +268,7 @@ gsd/M001/S01 (deleted after merge):
   feat(S01/T01): core types and interfaces
 ```
 
-One commit per slice on main (or whichever branch you started from). Squash commits are the permanent record — branches are deleted after merge. Git bisect works. Individual slices are revertable.
+One squash commit per milestone on main (or whichever branch you started from). The worktree is torn down after merge. Git bisect works. Individual milestones are revertable.
 
 ### Verification
 

package/dist/cli.js

@@ -91,6 +91,7 @@ const isPrintMode = cliFlags.print || cliFlags.mode !== undefined;
 // `gsd config` — replay the setup wizard and exit
 if (cliFlags.messages[0] === 'config') {
     const authStorage = AuthStorage.create(authFilePath);
+    loadStoredEnvKeys(authStorage);
     await runOnboarding(authStorage);
     process.exit(0);
 }

package/dist/loader.js

@@ -1,7 +1,50 @@
 #!/usr/bin/env node
+// GSD Startup Loader
+// Copyright (c) 2026 Jeremy McSpadden <jeremy@fluxlabs.net>
 import { fileURLToPath } from 'url';
 import { dirname, resolve, join, delimiter } from 'path';
 import { existsSync, readFileSync, readdirSync, mkdirSync, symlinkSync } 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.
+const gsdRoot = resolve(dirname(fileURLToPath(import.meta.url)), '..');
+const args = process.argv.slice(2);
+const firstArg = args[0];
+if (firstArg === '--version' || firstArg === '-v') {
+    try {
+        const pkg = JSON.parse(readFileSync(join(gsdRoot, 'package.json'), 'utf-8'));
+        process.stdout.write((pkg.version || '0.0.0') + '\n');
+    }
+    catch {
+        process.stdout.write('0.0.0\n');
+    }
+    process.exit(0);
+}
+if (firstArg === '--help' || firstArg === '-h') {
+    let version = '0.0.0';
+    try {
+        const pkg = JSON.parse(readFileSync(join(gsdRoot, 'package.json'), 'utf-8'));
+        version = pkg.version || version;
+    }
+    catch { /* ignore */ }
+    process.stdout.write(`GSD v${version} — Get Shit Done\n\n`);
+    process.stdout.write('Usage: gsd [options] [message...]\n\n');
+    process.stdout.write('Options:\n');
+    process.stdout.write('  --mode <text|json|rpc>   Output mode (default: interactive)\n');
+    process.stdout.write('  --print, -p              Single-shot print mode\n');
+    process.stdout.write('  --continue, -c           Resume the most recent session\n');
+    process.stdout.write('  --model <id>             Override model (e.g. claude-opus-4-6)\n');
+    process.stdout.write('  --no-session             Disable session persistence\n');
+    process.stdout.write('  --extension <path>       Load additional extension\n');
+    process.stdout.write('  --tools <a,b,c>          Restrict available tools\n');
+    process.stdout.write('  --list-models [search]   List available models and exit\n');
+    process.stdout.write('  --version, -v            Print version and exit\n');
+    process.stdout.write('  --help, -h               Print this help and exit\n');
+    process.stdout.write('\nSubcommands:\n');
+    process.stdout.write('  config                   Re-run the setup wizard\n');
+    process.stdout.write('  update                   Update GSD to the latest version\n');
+    process.exit(0);
+}
 import { agentDir, appRoot } from './app-paths.js';
 import { serializeBundledExtensionPaths } from './bundled-extension-paths.js';
 import { renderLogo } from './logo.js';
@@ -40,7 +83,6 @@ process.env.GSD_CODING_AGENT_DIR = agentDir;
 // Without this, extensions (e.g. browser-tools) can't resolve dependencies like
 // `playwright` because jiti resolves modules from pi-coding-agent's location, not gsd's.
 // Prepending gsd's node_modules to NODE_PATH fixes this for all extensions.
-const gsdRoot = resolve(dirname(fileURLToPath(import.meta.url)), '..');
 const gsdNodeModules = join(gsdRoot, 'node_modules');
 process.env.NODE_PATH = [gsdNodeModules, process.env.NODE_PATH]
     .filter(Boolean)
@@ -64,9 +106,8 @@ process.env.GSD_BIN_PATH = 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.
-const loaderPackageRoot = resolve(dirname(fileURLToPath(import.meta.url)), '..');
-const distRes = join(loaderPackageRoot, 'dist', 'resources');
-const srcRes = join(loaderPackageRoot, 'src', 'resources');
+const distRes = join(gsdRoot, 'dist', 'resources');
+const srcRes = join(gsdRoot, 'src', 'resources');
 const resourcesDir = existsSync(distRes) ? distRes : srcRes;
 process.env.GSD_WORKFLOW_PATH = join(resourcesDir, 'GSD-WORKFLOW.md');
 // GSD_BUNDLED_EXTENSION_PATHS — dynamically discovered bundled extension entry points.
@@ -105,8 +146,11 @@ process.env.GSD_BUNDLED_EXTENSION_PATHS = serializeBundledExtensionPaths(discove
 // Respect HTTP_PROXY / HTTPS_PROXY / NO_PROXY env vars for all outbound requests.
 // pi-coding-agent's cli.ts sets this, but GSD bypasses that entry point — so we
 // must set it here before any SDK clients are created.
-import { EnvHttpProxyAgent, setGlobalDispatcher } from 'undici';
-setGlobalDispatcher(new EnvHttpProxyAgent());
+// Lazy-load undici (~200ms) only when proxy env vars are actually set.
+if (process.env.HTTP_PROXY || process.env.HTTPS_PROXY || process.env.http_proxy || process.env.https_proxy) {
+    const { EnvHttpProxyAgent, setGlobalDispatcher } = await import('undici');
+    setGlobalDispatcher(new EnvHttpProxyAgent());
+}
 // Ensure workspace packages are linked before importing cli.js (which imports @gsd/*).
 // npm postinstall handles this normally, but npx --ignore-scripts skips postinstall.
 const gsdScopeDir = join(gsdNodeModules, '@gsd');

package/dist/resource-loader.d.ts

@@ -5,14 +5,15 @@ export declare function getNewerManagedResourceVersion(agentDir: string, current
 /**
  * Syncs all bundled resources to agentDir (~/.gsd/agent/) on every launch.
  *
- * - extensions/ → ~/.gsd/agent/extensions/   (always overwrite — ensures updates ship on next launch)
- * - agents/     → ~/.gsd/agent/agents/        (always overwrite)
- * - skills/     → ~/.gsd/agent/skills/        (always overwrite)
+ * - extensions/ → ~/.gsd/agent/extensions/   (overwrite when version changes)
+ * - agents/     → ~/.gsd/agent/agents/        (overwrite when version changes)
+ * - skills/     → ~/.gsd/agent/skills/        (overwrite when version changes)
  * - GSD-WORKFLOW.md is read directly from bundled path via GSD_WORKFLOW_PATH env var
  *
- * Always-overwrite ensures `npm update -g @glittercowboy/gsd` takes effect immediately.
- * User customizations should go in ~/.gsd/agent/extensions/ subdirs with unique names,
- * not by editing the gsd-managed files.
+ * Skips the copy when the managed-resources.json version matches the current
+ * GSD version, avoiding ~128ms of synchronous cpSync on every startup.
+ * After `npm update -g @glittercowboy/gsd`, versions will differ and the
+ * copy runs once to land the new resources.
  *
  * Inspectable: `ls ~/.gsd/agent/extensions/`
  */

package/dist/resource-loader.js

@@ -107,20 +107,27 @@ export function getNewerManagedResourceVersion(agentDir, currentVersion) {
 /**
  * Syncs all bundled resources to agentDir (~/.gsd/agent/) on every launch.
  *
- * - extensions/ → ~/.gsd/agent/extensions/   (always overwrite — ensures updates ship on next launch)
- * - agents/     → ~/.gsd/agent/agents/        (always overwrite)
- * - skills/     → ~/.gsd/agent/skills/        (always overwrite)
+ * - extensions/ → ~/.gsd/agent/extensions/   (overwrite when version changes)
+ * - agents/     → ~/.gsd/agent/agents/        (overwrite when version changes)
+ * - skills/     → ~/.gsd/agent/skills/        (overwrite when version changes)
  * - GSD-WORKFLOW.md is read directly from bundled path via GSD_WORKFLOW_PATH env var
  *
- * Always-overwrite ensures `npm update -g @glittercowboy/gsd` takes effect immediately.
- * User customizations should go in ~/.gsd/agent/extensions/ subdirs with unique names,
- * not by editing the gsd-managed files.
+ * Skips the copy when the managed-resources.json version matches the current
+ * GSD version, avoiding ~128ms of synchronous cpSync on every startup.
+ * After `npm update -g @glittercowboy/gsd`, versions will differ and the
+ * copy runs once to land the new resources.
  *
  * Inspectable: `ls ~/.gsd/agent/extensions/`
  */
 export function initResources(agentDir) {
     mkdirSync(agentDir, { recursive: true });
-    // Sync extensions — always overwrite so updates land on next launch
+    // Skip resource sync when versions match — saves ~128ms of cpSync per launch
+    const currentVersion = getBundledGsdVersion();
+    const managedVersion = readManagedResourceVersion(agentDir);
+    if (managedVersion && managedVersion === currentVersion) {
+        return;
+    }
+    // Sync extensions — overwrite so updates land on next launch
     const destExtensions = join(agentDir, 'extensions');
     cpSync(bundledExtensionsDir, destExtensions, { recursive: true, force: true });
     // Sync agents
@@ -129,7 +136,7 @@ export function initResources(agentDir) {
     if (existsSync(srcAgents)) {
         cpSync(srcAgents, destAgents, { recursive: true, force: true });
     }
-    // Sync skills — always overwrite so updates land on next launch
+    // Sync skills — overwrite so updates land on next launch
     const destSkills = join(agentDir, 'skills');
     const srcSkills = join(resourcesDir, 'skills');
     if (existsSync(srcSkills)) {

package/dist/resources/extensions/gsd/auto-worktree.ts

@@ -8,26 +8,15 @@
 
 import { existsSync, readFileSync, realpathSync, utimesSync } from "node:fs";
 import { join, resolve } from "node:path";
-import { execSync } from "node:child_process";
+import { execSync, execFileSync } from "node:child_process";
 import {
   createWorktree,
   removeWorktree,
   worktreePath,
 } from "./worktree-manager.js";
-import {
-  detectWorktreeName,
-  getSliceBranchName,
-} from "./worktree.js";
 import {
   MergeConflictError,
-  inferCommitType,
 } from "./git-service.js";
-import type { MergeSliceResult } from "./git-service.js";
-import { recoverCheckout, withMergeHeal } from "./git-self-heal.js";
-import {
-  nativeBranchExists,
-  nativeCommitCountBetween,
-} from "./native-git-bridge.js";
 import { parseRoadmap } from "./files.js";
 import { loadEffectiveGSDPreferences } from "./preferences.js";
 
@@ -36,46 +25,6 @@ import { loadEffectiveGSDPreferences } from "./preferences.js";
 /** Original project root before chdir into auto-worktree. */
 let originalBase: string | null = null;
 
-// ─── Isolation Resolver ────────────────────────────────────────────────────
-
-/**
- * Determine whether auto-mode should use worktree isolation.
- *
- * Resolution order:
- *  1. Explicit git.isolation preference -> return (isolation === "worktree")
- *  2. Legacy detection: if gsd branches exist -> return false (branch mode)
- *  3. Default: return true (worktree mode for new projects)
- */
-export function shouldUseWorktreeIsolation(basePath: string, overridePrefs?: { isolation?: string }): boolean {
-  const prefs = overridePrefs ?? loadEffectiveGSDPreferences()?.preferences?.git;
-  if (prefs?.isolation) {
-    return prefs.isolation === "worktree";
-  }
-
-  // Legacy detection: check for existing gsd/*/* branches (branch-per-slice pattern)
-  try {
-    const output = execSync("git branch --list 'gsd/*/*'", {
-      cwd: basePath,
-      stdio: ["ignore", "pipe", "pipe"],
-      encoding: "utf-8",
-    }).trim();
-    if (output) return false; // Legacy branch-per-slice project
-  } catch {
-    // If git command fails, default to worktree
-  }
-
-  return true; // New project default
-}
-
-/**
- * Resolve the merge_to_main preference value.
- * Returns "milestone" (default) or "slice".
- */
-export function getMergeToMainMode(): "milestone" | "slice" {
-  const prefs = loadEffectiveGSDPreferences()?.preferences?.git;
-  return prefs?.merge_to_main ?? "milestone";
-}
-
 // ─── Git Helpers (local, mirrors worktree-command.ts pattern) ──────────────
 
 function resolveGitHeadPath(dir: string): string | null {
@@ -236,117 +185,6 @@ export function getAutoWorktreeOriginalBase(): string | null {
   return originalBase;
 }
 
-// ─── Merge Slice -> Milestone ───────────────────────────────────────────────
-
-/**
- * Merge a completed slice branch into the milestone branch via `--no-ff`.
- *
- * Worktree-mode merge: `.gsd/` is local to the worktree (not tracked in
- * git), so there are zero `.gsd/` conflict resolution concerns. No runtime
- * exclusion untracking, no `--theirs` checkout, no snapshot creation.
- *
- * On conflict: throws MergeConflictError with conflicted file list.
- * On success: deletes the slice branch and returns MergeSliceResult.
- */
-export function mergeSliceToMilestone(
-  basePath: string,
-  milestoneId: string,
-  sliceId: string,
-  sliceTitle: string,
-): MergeSliceResult {
-  if (!isInAutoWorktree(basePath)) {
-    throw new Error("mergeSliceToMilestone called outside auto-worktree");
-  }
-
-  const cwd = process.cwd();
-  const milestoneBranch = autoWorktreeBranch(milestoneId);
-  const worktreeName = detectWorktreeName(cwd);
-  const sliceBranch = getSliceBranchName(milestoneId, sliceId, worktreeName);
-
-  // Verify slice branch exists
-  if (!nativeBranchExists(cwd, sliceBranch)) {
-    throw new Error(`Slice branch "${sliceBranch}" does not exist`);
-  }
-
-  // Verify slice has commits ahead of milestone branch
-  const commitCount = nativeCommitCountBetween(cwd, milestoneBranch, sliceBranch);
-  if (commitCount === 0) {
-    throw new Error(
-      `Slice branch "${sliceBranch}" has no commits ahead of "${milestoneBranch}"`,
-    );
-  }
-
-  // Checkout milestone branch (with self-healing reset)
-  recoverCheckout(cwd, milestoneBranch);
-
-  // Build rich commit message (replicates GitServiceImpl.buildRichCommitMessage format)
-  const commitType = inferCommitType(sliceTitle);
-  const subject = `${commitType}(${milestoneId}/${sliceId}): ${sliceTitle}`;
-
-  let message = subject;
-  try {
-    const logOutput = execSync(
-      `git log --oneline --format=%s ${milestoneBranch}..${sliceBranch}`,
-      { cwd, stdio: ["ignore", "pipe", "pipe"], encoding: "utf-8" },
-    ).trim();
-
-    if (logOutput) {
-      const subjects = logOutput.split("\n").filter(Boolean);
-      const MAX_ENTRIES = 20;
-      const truncated = subjects.length > MAX_ENTRIES;
-      const displayed = truncated ? subjects.slice(0, MAX_ENTRIES) : subjects;
-      const taskLines = displayed.map(s => `- ${s}`).join("\n");
-      const truncationLine = truncated
-        ? `\n- ... and ${subjects.length - MAX_ENTRIES} more`
-        : "";
-      message = `${subject}\n\nTasks:\n${taskLines}${truncationLine}\n\nBranch: ${sliceBranch}`;
-    }
-  } catch {
-    // Fall back to subject-only message
-  }
-
-  // Merge --no-ff (with self-healing retry for transient failures)
-  try {
-    withMergeHeal(cwd, () => {
-      execSync(`git merge --no-ff -m "${message.replace(/"/g, '\\"')}" ${sliceBranch}`, {
-        cwd,
-        stdio: ["ignore", "pipe", "pipe"],
-        encoding: "utf-8",
-      });
-    });
-  } catch (err) {
-    if (err instanceof MergeConflictError) {
-      // Re-throw with correct branch context
-      throw new MergeConflictError(
-        err.conflictedFiles,
-        err.strategy,
-        sliceBranch,
-        milestoneBranch,
-      );
-    }
-    throw err;
-  }
-
-  // Delete slice branch
-  let deletedBranch = false;
-  try {
-    execSync(`git branch -d ${sliceBranch}`, {
-      cwd,
-      stdio: ["ignore", "pipe", "pipe"],
-      encoding: "utf-8",
-    });
-    deletedBranch = true;
-  } catch {
-    // Branch deletion is best-effort
-  }
-
-  return {
-    branch: sliceBranch,
-    mergedCommitMessage: message,
-    deletedBranch,
-  };
-}
-
 // ─── Merge Milestone -> Main ───────────────────────────────────────────────
 
 /**
@@ -361,7 +199,8 @@ function autoCommitDirtyState(cwd: string): boolean {
       encoding: "utf-8",
     }).trim();
     if (!status) return false;
-    execSync('git add -A && git commit -m "chore: auto-commit before milestone merge"', {
+    execFileSync("git", ["add", "-A"], { cwd, stdio: "pipe" });
+    execFileSync("git", ["commit", "-m", "chore: auto-commit before milestone merge"], {
       cwd,
       stdio: ["ignore", "pipe", "pipe"],
       encoding: "utf-8",
@@ -413,8 +252,12 @@ export function mergeMilestoneToMain(
   const prefs = loadEffectiveGSDPreferences()?.preferences?.git ?? {};
   const mainBranch = prefs.main_branch || "main";
 
-  // 5. Checkout main (with self-healing reset)
-  recoverCheckout(originalBasePath_, mainBranch);
+  // 5. Checkout main
+  execSync(`git checkout ${mainBranch}`, {
+    cwd: originalBasePath_,
+    stdio: ["ignore", "pipe", "pipe"],
+    encoding: "utf-8",
+  });
 
   // 6. Build rich commit message
   const milestoneTitle = roadmap.title.replace(/^M\d+:\s*/, "").trim() || milestoneId;
@@ -426,32 +269,35 @@ export function mergeMilestoneToMain(
   }
   const commitMessage = subject + body;
 
-  // 7. Squash merge (with self-healing retry for transient failures)
+  // 7. Squash merge
   try {
-    withMergeHeal(originalBasePath_, () => {
-      execSync(`git merge --squash ${milestoneBranch}`, {
+    execSync(`git merge --squash ${milestoneBranch}`, {
+      cwd: originalBasePath_,
+      stdio: ["ignore", "pipe", "pipe"],
+      encoding: "utf-8",
+    });
+  } catch (mergeErr) {
+    // Check for real conflicts
+    try {
+      const conflictOutput = execSync("git diff --name-only --diff-filter=U", {
         cwd: originalBasePath_,
-        stdio: ["ignore", "pipe", "pipe"],
         encoding: "utf-8",
-      });
-    });
-  } catch (err) {
-    if (err instanceof MergeConflictError) {
-      // Re-throw with correct branch context
-      throw new MergeConflictError(
-        err.conflictedFiles,
-        err.strategy,
-        milestoneBranch,
-        mainBranch,
-      );
+        stdio: ["pipe", "pipe", "pipe"],
+      }).trim();
+      if (conflictOutput) {
+        const conflictedFiles = conflictOutput.split("\n").filter(Boolean);
+        throw new MergeConflictError(conflictedFiles, "squash", milestoneBranch, mainBranch);
+      }
+    } catch (diffErr) {
+      if (diffErr instanceof MergeConflictError) throw diffErr;
     }
-    // Possibly "already up to date" -- fall through to commit which will handle nothing-to-commit
+    // No conflicts detected — possibly "already up to date", fall through to commit
   }
 
   // 8. Commit (handle nothing-to-commit gracefully)
   let nothingToCommit = false;
   try {
-    execSync(`git commit -m ${JSON.stringify(commitMessage)}`, {
+    execFileSync("git", ["commit", "-m", commitMessage], {
       cwd: originalBasePath_,
       stdio: ["ignore", "pipe", "pipe"],
       encoding: "utf-8",