gsd-pi 2.3.11 → 2.5.0

package/README.md

@@ -200,7 +200,7 @@ Both terminals read and write the same `.gsd/` files on disk. Your decisions in
 
 ### First launch
 
-On first run, GSD launches a branded setup wizard that walks you through LLM provider selection (OAuth or API key), then optional tool API keys (Brave Search, Context7, Jina, Slack, Discord). Every step is skippable — press Enter to skip any. Run `gsd config` anytime to re-run the wizard.
+On first run, GSD launches a branded setup wizard that walks you through LLM provider selection (OAuth or API key), then optional tool API keys (Brave Search, Context7, Jina, Slack, Discord). Every step is skippable — press Enter to skip any. If you have an existing Pi installation, your provider credentials (LLM and tool keys) are imported automatically. Run `gsd config` anytime to re-run the wizard.
 
 ### Commands
 
@@ -252,17 +252,18 @@ Branch-per-slice with squash merge. Fully automated.
 
 ```
 main:
-  feat(M001/S03): auth and session management
+  docs(M001/S04): workflow documentation and examples
+  fix(M001/S03): bug fixes and doc corrections
   feat(M001/S02): API endpoints and middleware
   feat(M001/S01): data model and type system
 
-gsd/M001/S01 (preserved):
+gsd/M001/S01 (deleted after merge):
   feat(S01/T03): file writer with round-trip fidelity
   feat(S01/T02): markdown parser for plan files
   feat(S01/T01): core types and interfaces
 ```
 
-One commit per slice on main. Per-task history preserved on branches. Git bisect works. Individual slices are revertable.
+One commit per slice on main. Squash commits are the permanent record — branches are deleted after merge. Git bisect works. Individual slices are revertable.
 
 ### Verification
 

package/dist/cli.js

@@ -2,9 +2,10 @@ import { AuthStorage, DefaultResourceLoader, ModelRegistry, SettingsManager, Ses
 import { existsSync, readdirSync, renameSync, readFileSync } from 'node:fs';
 import { join } from 'node:path';
 import { agentDir, sessionsDir, authFilePath } from './app-paths.js';
-import { initResources } from './resource-loader.js';
+import { initResources, buildResourceLoader } from './resource-loader.js';
 import { ensureManagedTools } from './tool-bootstrap.js';
 import { loadStoredEnvKeys } from './wizard.js';
+import { migratePiCredentials } from './pi-migration.js';
 import { shouldRunOnboarding, runOnboarding } from './onboarding.js';
 function parseCliArgs(argv) {
     const flags = { extensions: [], messages: [] };
@@ -74,6 +75,7 @@ if (cliFlags.messages[0] === 'config') {
 ensureManagedTools(join(agentDir, 'bin'));
 const authStorage = AuthStorage.create(authFilePath);
 loadStoredEnvKeys(authStorage);
+migratePiCredentials(authStorage);
 // Run onboarding wizard on first launch (no LLM provider configured)
 if (!isPrintMode && shouldRunOnboarding(authStorage)) {
     await runOnboarding(authStorage);
@@ -200,7 +202,7 @@ if (existsSync(sessionsDir)) {
 }
 const sessionManager = SessionManager.create(cwd, projectSessionsDir);
 initResources(agentDir);
-const resourceLoader = new DefaultResourceLoader({ agentDir });
+const resourceLoader = buildResourceLoader(agentDir);
 await resourceLoader.reload();
 const { session, extensionsResult } = await createAgentSession({
     authStorage,

package/dist/pi-migration.d.ts

@@ -0,0 +1,14 @@
+/**
+ * One-time migration of provider credentials from Pi (~/.pi/agent/auth.json)
+ * into GSD's auth storage. Runs when GSD has no LLM providers configured,
+ * so users with an existing Pi install skip re-authentication.
+ */
+import type { AuthStorage } from '@mariozechner/pi-coding-agent';
+/**
+ * Migrate provider credentials from Pi's auth.json into GSD's AuthStorage.
+ *
+ * Only runs when GSD has no LLM provider configured and Pi's auth.json exists.
+ * Copies any credentials GSD doesn't already have. Returns true if an LLM
+ * provider was migrated (so onboarding can be skipped).
+ */
+export declare function migratePiCredentials(authStorage: AuthStorage): boolean;

package/dist/pi-migration.js

@@ -0,0 +1,57 @@
+/**
+ * One-time migration of provider credentials from Pi (~/.pi/agent/auth.json)
+ * into GSD's auth storage. Runs when GSD has no LLM providers configured,
+ * so users with an existing Pi install skip re-authentication.
+ */
+import { existsSync, readFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+const PI_AUTH_PATH = join(homedir(), '.pi', 'agent', 'auth.json');
+const LLM_PROVIDER_IDS = [
+    'anthropic',
+    'openai',
+    'github-copilot',
+    'openai-codex',
+    'google-gemini-cli',
+    'google-antigravity',
+    'google',
+    'groq',
+    'xai',
+    'openrouter',
+    'mistral',
+];
+/**
+ * Migrate provider credentials from Pi's auth.json into GSD's AuthStorage.
+ *
+ * Only runs when GSD has no LLM provider configured and Pi's auth.json exists.
+ * Copies any credentials GSD doesn't already have. Returns true if an LLM
+ * provider was migrated (so onboarding can be skipped).
+ */
+export function migratePiCredentials(authStorage) {
+    try {
+        // Only migrate when GSD has no LLM providers
+        const existing = authStorage.list();
+        const hasLlm = existing.some(id => LLM_PROVIDER_IDS.includes(id));
+        if (hasLlm)
+            return false;
+        if (!existsSync(PI_AUTH_PATH))
+            return false;
+        const raw = readFileSync(PI_AUTH_PATH, 'utf-8');
+        const piData = JSON.parse(raw);
+        let migratedLlm = false;
+        for (const [providerId, credential] of Object.entries(piData)) {
+            if (authStorage.has(providerId))
+                continue;
+            authStorage.set(providerId, credential);
+            const isLlm = LLM_PROVIDER_IDS.includes(providerId);
+            if (isLlm)
+                migratedLlm = true;
+            process.stderr.write(`[gsd] Migrated ${isLlm ? 'LLM provider' : 'credential'}: ${providerId} (from Pi)\n`);
+        }
+        return migratedLlm;
+    }
+    catch {
+        // Non-fatal — don't block startup
+        return false;
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gsd-pi",
-  "version": "2.3.11",
+  "version": "2.5.0",
   "description": "GSD — Get Shit Done coding agent",
   "license": "MIT",
   "repository": {
@@ -35,7 +35,7 @@
   "scripts": {
     "build": "tsc && npm run copy-themes",
     "copy-themes": "node -e \"const{mkdirSync,cpSync}=require('fs');const{resolve}=require('path');const src=resolve(__dirname,'node_modules/@mariozechner/pi-coding-agent/dist/modes/interactive/theme');mkdirSync('pkg/dist/modes/interactive/theme',{recursive:true});cpSync(src,'pkg/dist/modes/interactive/theme',{recursive:true})\"",
-    "test": "node --import ./src/resources/extensions/gsd/tests/resolve-ts.mjs --experimental-strip-types --test 'src/resources/extensions/gsd/tests/*.test.ts' 'src/resources/extensions/gsd/tests/*.test.mjs' 'src/tests/*.test.ts'",
+    "test": "node --import ./src/resources/extensions/gsd/tests/resolve-ts.mjs --experimental-strip-types --test src/resources/extensions/gsd/tests/*.test.ts src/resources/extensions/gsd/tests/*.test.mjs src/tests/*.test.ts",
     "dev": "tsc --watch",
     "postinstall": "node scripts/postinstall.js",
     "pi:install-global": "node scripts/install-pi-global.js",

package/src/resources/GSD-WORKFLOW.md

@@ -548,7 +548,7 @@ If files disagree, **pause and surface to the user**:
 1. **Slice starts** → create branch `gsd/M001/S01` from main
 2. **Per-task commits** on the branch — atomic, descriptive, bisectable
 3. **Slice completes** → squash merge to main as one clean commit
-4. **Branch kept** — not deleted, available for per-task history
+4. **Branch deleted** — squash commit on main is the permanent record
 
 ### What Main Looks Like
 
@@ -566,21 +566,21 @@ One commit per slice. Individually revertable. Reads like a changelog.
 gsd/M001/S01:
   test(S01): round-trip tests passing
   feat(S01/T03): file writer with round-trip fidelity
-  checkpoint(S01/T03): pre-task
+  chore(S01/T03): auto-commit after task
   feat(S01/T02): markdown parser for plan files
-  checkpoint(S01/T02): pre-task
+  chore(S01/T02): auto-commit after task
   feat(S01/T01): core types and interfaces
-  checkpoint(S01/T01): pre-task
+  chore(S01/T01): auto-commit after task
 ```
 
 ### Commit Conventions
 
 | When | Format | Example |
 |------|--------|---------|
-| Before each task | `checkpoint(S01/T02): pre-task` | Safety net for `git reset` |
+| Auto-commit (dirty state) | `chore(S01/T02): auto-commit after task` | Automatic save of work in progress |
 | After task verified | `feat(S01/T02): <what was built>` | The real work |
 | Plan/docs committed | `docs(S01): add slice plan` | Bundled with first task |
-| Slice squash to main | `feat(M001/S01): <slice title>` | Clean one-liner on main |
+| Slice squash to main | `type(M001/S01): <slice title>` | Type inferred from title (`feat`, `fix`, `docs`, etc.) |
 
 Commit types: `feat`, `fix`, `test`, `refactor`, `docs`, `chore`
 
@@ -601,7 +601,7 @@ Tasks completed:
 
 | Problem | Fix |
 |---------|-----|
-| Bad task | `git reset --hard` to checkpoint on the branch |
+| Bad task | `git reset --hard HEAD~1` to previous commit on the branch |
 | Bad slice | `git revert <squash commit>` on main |
 | UAT failure after merge | Fix tasks on `gsd/M001/S01-fix` branch, squash as `fix(M001/S01): <fix>` |
 

package/src/resources/extensions/gsd/auto.ts

@@ -62,11 +62,12 @@ import {
   ensureSliceBranch,
   getCurrentBranch,
   getMainBranch,
-  getSliceBranchName,
   parseSliceBranch,
   switchToMain,
   mergeSliceToMain,
 } from "./worktree.ts";
+import { GitServiceImpl } from "./git-service.ts";
+import type { GitPreferences } from "./git-service.ts";
 import { truncateToWidth, visibleWidth } from "@mariozechner/pi-tui";
 import { makeUI, GLYPH, INDENT } from "../shared/ui.js";
 import { showNextAction } from "../shared/next-action-ui.js";
@@ -93,6 +94,18 @@ function persistCompletedKey(base: string, key: string): void {
   }
 }
 
+/** Remove a stale completed unit key from disk. */
+function removePersistedKey(base: string, key: string): void {
+  const file = completedKeysPath(base);
+  try {
+    if (existsSync(file)) {
+      let keys: string[] = JSON.parse(readFileSync(file, "utf-8"));
+      keys = keys.filter(k => k !== key);
+      writeFileSync(file, JSON.stringify(keys), "utf-8");
+    }
+  } catch { /* non-fatal */ }
+}
+
 /** Load all completed unit keys from disk into the in-memory set. */
 function loadPersistedKeys(base: string, target: Set<string>): void {
   const file = completedKeysPath(base);
@@ -112,6 +125,7 @@ let stepMode = false;
 let verbose = false;
 let cmdCtx: ExtensionCommandContext | null = null;
 let basePath = "";
+let gitService: GitServiceImpl | null = null;
 
 /** Track total dispatches per unit to detect stuck loops (catches A→B→A→B patterns) */
 const unitDispatchCount = new Map<string, number>();
@@ -376,6 +390,9 @@ export async function startAuto(
     } catch { /* nothing to commit */ }
   }
 
+  // Initialize GitServiceImpl — basePath is set and git repo confirmed
+  gitService = new GitServiceImpl(basePath, loadEffectiveGSDPreferences()?.preferences?.git ?? {});
+
   // Check for crash from previous session
   const crashLock = readCrashLock(base);
   if (crashLock) {
@@ -1190,15 +1207,27 @@ async function dispatchNextUnit(
   // Idempotency: skip units already completed in a prior session.
   const idempotencyKey = `${unitType}/${unitId}`;
   if (completedKeySet.has(idempotencyKey)) {
-    ctx.ui.notify(
-      `Skipping ${unitType} ${unitId} — already completed in a prior session. Advancing.`,
-      "info",
-    );
-    // Yield to the event loop before re-dispatching to avoid tight recursion
-    // when many units are already completed (e.g., after crash recovery).
-    await new Promise(r => setImmediate(r));
-    await dispatchNextUnit(ctx, pi);
-    return;
+    // Cross-validate: does the expected artifact actually exist?
+    const artifactExists = verifyExpectedArtifact(unitType, unitId, basePath);
+    if (artifactExists) {
+      ctx.ui.notify(
+        `Skipping ${unitType} ${unitId} — already completed in a prior session. Advancing.`,
+        "info",
+      );
+      // Yield to the event loop before re-dispatching to avoid tight recursion
+      // when many units are already completed (e.g., after crash recovery).
+      await new Promise(r => setImmediate(r));
+      await dispatchNextUnit(ctx, pi);
+      return;
+    } else {
+      // Stale completion record — artifact missing. Remove and re-run.
+      completedKeySet.delete(idempotencyKey);
+      removePersistedKey(basePath, idempotencyKey);
+      ctx.ui.notify(
+        `Re-running ${unitType} ${unitId} — marked complete but expected artifact missing.`,
+        "warning",
+      );
+    }
   }
 
   // Stuck detection — tracks total dispatches per unit (not just consecutive repeats).
@@ -1234,20 +1263,26 @@ async function dispatchNextUnit(
     snapshotUnitMetrics(ctx, currentUnit.type, currentUnit.id, currentUnit.startedAt, modelId);
     saveActivityLog(ctx, basePath, currentUnit.type, currentUnit.id);
 
-    // Persist completion to disk BEFORE updating memory — so a crash here is recoverable.
+    // Only mark the previous unit as completed if:
+    // 1. We're not about to re-dispatch the same unit (retry scenario)
+    // 2. The expected artifact actually exists on disk
     const closeoutKey = `${currentUnit.type}/${currentUnit.id}`;
-    persistCompletedKey(basePath, closeoutKey);
-    completedKeySet.add(closeoutKey);
-
-    completedUnits.push({
-      type: currentUnit.type,
-      id: currentUnit.id,
-      startedAt: currentUnit.startedAt,
-      finishedAt: Date.now(),
-    });
-    clearUnitRuntimeRecord(basePath, currentUnit.type, currentUnit.id);
-    unitDispatchCount.delete(`${currentUnit.type}/${currentUnit.id}`);
-    unitRecoveryCount.delete(`${currentUnit.type}/${currentUnit.id}`);
+    const incomingKey = `${unitType}/${unitId}`;
+    const artifactVerified = verifyExpectedArtifact(currentUnit.type, currentUnit.id, basePath);
+    if (closeoutKey !== incomingKey && artifactVerified) {
+      persistCompletedKey(basePath, closeoutKey);
+      completedKeySet.add(closeoutKey);
+
+      completedUnits.push({
+        type: currentUnit.type,
+        id: currentUnit.id,
+        startedAt: currentUnit.startedAt,
+        finishedAt: Date.now(),
+      });
+      clearUnitRuntimeRecord(basePath, currentUnit.type, currentUnit.id);
+      unitDispatchCount.delete(`${currentUnit.type}/${currentUnit.id}`);
+      unitRecoveryCount.delete(`${currentUnit.type}/${currentUnit.id}`);
+    }
   }
   currentUnit = { type: unitType, id: unitId, startedAt: Date.now() };
   writeUnitRuntimeRecord(basePath, unitType, unitId, currentUnit.startedAt, {
@@ -2587,6 +2622,15 @@ export function resolveExpectedArtifactPath(unitType: string, unitId: string, ba
       const dir = resolveSlicePath(base, mid, sid!);
       return dir ? join(dir, buildSliceFileName(sid!, "UAT-RESULT")) : null;
     }
+    case "execute-task": {
+      const tid = parts[2];
+      const dir = resolveSlicePath(base, mid, sid!);
+      return dir && tid ? join(dir, "tasks", buildTaskFileName(tid, "SUMMARY")) : null;
+    }
+    case "complete-slice": {
+      const dir = resolveSlicePath(base, mid, sid!);
+      return dir ? join(dir, buildSliceFileName(sid!, "SUMMARY")) : null;
+    }
     case "complete-milestone": {
       const dir = resolveMilestonePath(base, mid);
       return dir ? join(dir, buildMilestoneFileName(mid, "SUMMARY")) : null;
@@ -2596,6 +2640,17 @@ export function resolveExpectedArtifactPath(unitType: string, unitId: string, ba
   }
 }
 
+/**
+ * Check whether the expected artifact for a unit exists on disk.
+ * Returns true if the artifact file exists, or if the unit type has no
+ * single verifiable artifact (e.g., replan-slice).
+ */
+function verifyExpectedArtifact(unitType: string, unitId: string, base: string): boolean {
+  const absPath = resolveExpectedArtifactPath(unitType, unitId, base);
+  if (!absPath) return true;
+  return existsSync(absPath);
+}
+
 /**
  * Write a placeholder artifact so the pipeline can advance past a stuck unit.
  * Returns the relative path written, or null if the path couldn't be resolved.

package/src/resources/extensions/gsd/docs/preferences-reference.md

@@ -40,6 +40,14 @@ Full documentation for `~/.gsd/preferences.md` (global) and `.gsd/preferences.md
   - `idle_timeout_minutes`: minutes of inactivity before the supervisor intervenes (default: 10).
   - `hard_timeout_minutes`: minutes before the supervisor forces termination (default: 30).
 
+- `git`: configures GSD's git behavior. All fields are optional — omit any to use defaults. Keys:
+  - `auto_push`: boolean — automatically push commits to the remote after committing. Default: `false`.
+  - `push_branches`: boolean — push newly created slice branches to the remote. Default: `false`.
+  - `remote`: string — git remote name to push to. Default: `"origin"`.
+  - `snapshots`: boolean — create snapshot commits (WIP saves) during long-running tasks. Default: `false`.
+  - `pre_merge_check`: boolean or `"auto"` — run pre-merge checks before merging a slice branch. `true` always runs, `false` never runs, `"auto"` runs when CI is detected. Default: `false`.
+  - `commit_type`: string — override the conventional commit type prefix. Must be one of: `feat`, `fix`, `refactor`, `docs`, `test`, `chore`, `perf`, `ci`, `build`, `style`. Default: inferred from diff content.
+
 ---
 
 ## Best Practices
@@ -101,3 +109,22 @@ skill_rules:
       - find-skills
 ---
 ```
+
+---
+
+## Git Preferences Example
+
+```yaml
+---
+version: 1
+git:
+  auto_push: true
+  push_branches: true
+  remote: origin
+  snapshots: true
+  pre_merge_check: auto
+  commit_type: feat
+---
+```
+
+All git fields are optional. Omit any field to use the default behavior. Project-level preferences override global preferences on a per-field basis.