gsd-pi 2.33.1-dev.ee47f1b → 2.34.0-dev.bbb5216

package/dist/resources/extensions/gsd/undo.js

@@ -7,54 +7,52 @@ import { deriveState } from "./state.js";
 import { invalidateAllCaches } from "./cache.js";
 import { gsdRoot, resolveTasksDir, resolveSlicePath, buildTaskFileName } from "./paths.js";
 import { sendDesktopNotification } from "./notifications.js";
-import { parseUnitId } from "./unit-id.js";
 /**
- * Undo the last completed unit: revert git commits, remove from completed-units,
+ * Undo the last completed unit: revert git commits,
  * delete summary artifacts, and uncheck the task in PLAN.
+ * deriveState() handles re-derivation after revert.
  */
 export async function handleUndo(args, ctx, _pi, basePath) {
     const force = args.includes("--force");
-    // 1. Load completed-units.json
-    const completedKeysFile = join(gsdRoot(basePath), "completed-units.json");
-    if (!existsSync(completedKeysFile)) {
-        ctx.ui.notify("Nothing to undo — no completed units found.", "info");
+    // Find the last GSD-related commit from git activity logs
+    const activityDir = join(gsdRoot(basePath), "activity");
+    if (!existsSync(activityDir)) {
+        ctx.ui.notify("Nothing to undo — no activity logs found.", "info");
         return;
     }
-    let keys;
-    try {
-        keys = JSON.parse(readFileSync(completedKeysFile, "utf-8"));
-    }
-    catch {
-        ctx.ui.notify("Nothing to undo — completed-units.json is corrupt.", "warning");
+    // Parse activity logs to find the most recent unit
+    const files = readdirSync(activityDir)
+        .filter(f => f.endsWith(".jsonl"))
+        .sort()
+        .reverse();
+    if (files.length === 0) {
+        ctx.ui.notify("Nothing to undo — no activity logs found.", "info");
         return;
     }
-    if (keys.length === 0) {
-        ctx.ui.notify("Nothing to undo — no completed units.", "info");
+    // Extract unit type and ID from the most recent activity log filename
+    // Format: <seq>-<unitType>-<unitId>.jsonl
+    const match = files[0].match(/^\d+-(.+?)-(.+)\.jsonl$/);
+    if (!match) {
+        ctx.ui.notify("Nothing to undo — could not parse latest activity log.", "warning");
         return;
     }
-    // Get the last completed unit
-    const lastKey = keys[keys.length - 1];
-    const sepIdx = lastKey.indexOf("/");
-    const unitType = sepIdx >= 0 ? lastKey.slice(0, sepIdx) : lastKey;
-    const unitId = sepIdx >= 0 ? lastKey.slice(sepIdx + 1) : lastKey;
+    const unitType = match[1];
+    const unitId = match[2].replace(/-/g, "/");
     if (!force) {
         ctx.ui.notify(`Will undo: ${unitType} (${unitId})\n` +
             `This will:\n` +
-            `  - Remove from completed-units.json\n` +
             `  - Delete summary artifacts\n` +
             `  - Uncheck task in PLAN (if execute-task)\n` +
             `  - Attempt to revert associated git commits\n\n` +
             `Run /gsd undo --force to confirm.`, "warning");
         return;
     }
-    // 2. Remove from completed-units.json
-    keys = keys.filter(k => k !== lastKey);
-    writeFileSync(completedKeysFile, JSON.stringify(keys), "utf-8");
-    // 3. Delete summary artifact
-    const { milestone: mid, slice: sid, task: tid } = parseUnitId(unitId);
+    // 1. Delete summary artifact
+    const parts = unitId.split("/");
     let summaryRemoved = false;
-    if (mid && sid && tid) {
+    if (parts.length === 3) {
         // Task-level: M001/S01/T01
+        const [mid, sid, tid] = parts;
         const tasksDir = resolveTasksDir(basePath, mid, sid);
         if (tasksDir) {
             const summaryFile = join(tasksDir, buildTaskFileName(tid, "SUMMARY"));
@@ -64,11 +62,11 @@ export async function handleUndo(args, ctx, _pi, basePath) {
             }
         }
     }
-    else if (mid && sid) {
+    else if (parts.length === 2) {
         // Slice-level: M001/S01
+        const [mid, sid] = parts;
         const slicePath = resolveSlicePath(basePath, mid, sid);
         if (slicePath) {
-            // Try common summary filenames
             for (const suffix of ["SUMMARY", "COMPLETE"]) {
                 const candidates = findFileWithPrefix(slicePath, sid, suffix);
                 for (const f of candidates) {
@@ -78,43 +76,40 @@ export async function handleUndo(args, ctx, _pi, basePath) {
             }
         }
     }
-    // 4. Uncheck task in PLAN if execute-task
+    // 2. Uncheck task in PLAN if execute-task
     let planUpdated = false;
-    if (unitType === "execute-task" && mid && sid && tid) {
+    if (unitType === "execute-task" && parts.length === 3) {
+        const [mid, sid, tid] = parts;
         planUpdated = uncheckTaskInPlan(basePath, mid, sid, tid);
     }
-    // 5. Try to revert git commits from activity log
+    // 3. Try to revert git commits from activity log
     let commitsReverted = 0;
-    const activityDir = join(gsdRoot(basePath), "activity");
     try {
-        if (existsSync(activityDir)) {
-            const commits = findCommitsForUnit(activityDir, unitType, unitId);
-            if (commits.length > 0) {
-                for (const sha of commits.reverse()) {
+        const commits = findCommitsForUnit(activityDir, unitType, unitId);
+        if (commits.length > 0) {
+            for (const sha of commits.reverse()) {
+                try {
+                    nativeRevertCommit(basePath, sha);
+                    commitsReverted++;
+                }
+                catch {
+                    // Revert conflict or already reverted — skip
                     try {
-                        nativeRevertCommit(basePath, sha);
-                        commitsReverted++;
-                    }
-                    catch {
-                        // Revert conflict or already reverted — skip
-                        try {
-                            nativeRevertAbort(basePath);
-                        }
-                        catch { /* no-op */ }
-                        break;
+                        nativeRevertAbort(basePath);
                     }
+                    catch { /* no-op */ }
+                    break;
                 }
             }
         }
     }
     finally {
-        // 6. Re-derive state — always invalidate caches even if git operations fail
+        // 4. Re-derive state — always invalidate caches even if git operations fail
         invalidateAllCaches();
         await deriveState(basePath);
     }
     // Build result message
     const results = [`Undone: ${unitType} (${unitId})`];
-    results.push(`  - Removed from completed-units.json`);
     if (summaryRemoved)
         results.push(`  - Deleted summary artifact`);
     if (planUpdated)

package/dist/resources/extensions/gsd/unit-runtime.js

@@ -1,25 +1,18 @@
-import { existsSync, readdirSync, readFileSync, unlinkSync } from "node:fs";
+import { existsSync, mkdirSync, readdirSync, readFileSync, writeFileSync, unlinkSync } from "node:fs";
 import { join } from "node:path";
 import { gsdRoot, relSliceFile, relTaskFile, resolveSliceFile, resolveTaskFile, } from "./paths.js";
 import { loadFile, parseTaskPlanMustHaves, countMustHavesMentionedInSummary } from "./files.js";
-import { loadJsonFileOrNull, saveJsonFile } from "./json-persistence.js";
-import { parseUnitId } from "./unit-id.js";
-function isAutoUnitRuntimeRecord(data) {
-    return (typeof data === "object" &&
-        data !== null &&
-        data.version === 1 &&
-        typeof data.unitType === "string" &&
-        typeof data.unitId === "string");
-}
 function runtimeDir(basePath) {
     return join(gsdRoot(basePath), "runtime", "units");
 }
 function runtimePath(basePath, unitType, unitId) {
-    const sanitizedUnitType = unitType.replace(/[^a-zA-Z0-9._-]+/g, "-");
-    const sanitizedUnitId = unitId.replace(/[^a-zA-Z0-9._-]+/g, "-");
+    const sanitizedUnitType = unitType.replace(/[\/]/g, "-");
+    const sanitizedUnitId = unitId.replace(/[\/]/g, "-");
     return join(runtimeDir(basePath), `${sanitizedUnitType}-${sanitizedUnitId}.json`);
 }
 export function writeUnitRuntimeRecord(basePath, unitType, unitId, startedAt, updates = {}) {
+    const dir = runtimeDir(basePath);
+    mkdirSync(dir, { recursive: true });
     const path = runtimePath(basePath, unitType, unitId);
     const prev = readUnitRuntimeRecord(basePath, unitType, unitId);
     const next = {
@@ -39,11 +32,19 @@ export function writeUnitRuntimeRecord(basePath, unitType, unitId, startedAt, up
         recoveryAttempts: updates.recoveryAttempts ?? prev?.recoveryAttempts ?? 0,
         lastRecoveryReason: updates.lastRecoveryReason ?? prev?.lastRecoveryReason,
     };
-    saveJsonFile(path, next);
+    writeFileSync(path, JSON.stringify(next, null, 2) + "\n", "utf-8");
     return next;
 }
 export function readUnitRuntimeRecord(basePath, unitType, unitId) {
-    return loadJsonFileOrNull(runtimePath(basePath, unitType, unitId), isAutoUnitRuntimeRecord);
+    const path = runtimePath(basePath, unitType, unitId);
+    if (!existsSync(path))
+        return null;
+    try {
+        return JSON.parse(readFileSync(path, "utf-8"));
+    }
+    catch {
+        return null;
+    }
 }
 export function clearUnitRuntimeRecord(basePath, unitType, unitId) {
     const path = runtimePath(basePath, unitType, unitId);
@@ -74,7 +75,7 @@ export function listUnitRuntimeRecords(basePath) {
     return results;
 }
 export async function inspectExecuteTaskDurability(basePath, unitId) {
-    const { milestone: mid, slice: sid, task: tid } = parseUnitId(unitId);
+    const [mid, sid, tid] = unitId.split("/");
     if (!mid || !sid || !tid)
         return null;
     const planAbs = resolveSliceFile(basePath, mid, sid, "PLAN");

package/dist/resources/extensions/gsd/verification-evidence.js

@@ -31,7 +31,6 @@ export function writeVerificationJSON(result, tasksDir, taskId, unitId, retryAtt
             exitCode: check.exitCode,
             durationMs: check.durationMs,
             verdict: check.exitCode === 0 ? "pass" : "fail",
-            blocking: check.blocking,
         })),
         ...(retryAttempt !== undefined ? { retryAttempt } : {}),
         ...(maxRetries !== undefined ? { maxRetries } : {}),

package/dist/resources/extensions/gsd/verification-gate.js

@@ -28,12 +28,11 @@ const PACKAGE_SCRIPT_KEYS = ["typecheck", "lint", "test"];
  *   4. None found
  */
 export function discoverCommands(options) {
-    // 1. Preference commands (still sanitize — may contain prose from misconfiguration)
+    // 1. Preference commands
     if (options.preferenceCommands && options.preferenceCommands.length > 0) {
         const filtered = options.preferenceCommands
             .map(c => c.trim())
-            .filter(Boolean)
-            .filter(c => isLikelyCommand(c));
+            .filter(Boolean);
         if (filtered.length > 0) {
             return { commands: filtered, source: "preference" };
         }
@@ -89,9 +88,7 @@ const MAX_FAILURE_CONTEXT_CHARS = 10_000;
  * Returns an empty string when all checks pass or the checks array is empty.
  */
 export function formatFailureContext(result) {
-    // Only include blocking failures in retry context — non-blocking (advisory) failures
-    // should not be injected into retry prompts to avoid noise pollution.
-    const failures = result.checks.filter((c) => c.exitCode !== 0 && c.blocking);
+    const failures = result.checks.filter((c) => c.exitCode !== 0);
     if (failures.length === 0)
         return "";
     const blocks = [];
@@ -187,19 +184,13 @@ function sanitizeCommand(cmd) {
         return null;
     return cmd;
 }
-/** Error codes from spawnSync that indicate infrastructure/OS-level failures
- *  rather than the command itself failing. These are transient — the agent
- *  cannot fix them, so they should not trigger auto-fix retries. */
-const INFRA_ERROR_CODES = new Set(["ETIMEDOUT", "ENOENT", "ENOMEM", "EMFILE", "ENFILE", "EAGAIN"]);
 /**
  * Run the verification gate: discover commands, execute each via spawnSync,
  * and return a structured result.
  *
  * - All commands run sequentially regardless of individual pass/fail.
- * - `passed` is true when every blocking command exits 0 (or no commands are discovered).
+ * - `passed` is true when every command exits 0 (or no commands are discovered).
  * - stdout/stderr per command are truncated to 10 KB.
- * - Spawn/infra errors (ETIMEDOUT, ENOENT, etc.) are tagged with `infraError: true`
- *   so the retry logic can distinguish "the OS couldn't run this" from "the tests failed".
  */
 export function runVerificationGate(options) {
     const timestamp = Date.now();
@@ -216,9 +207,6 @@ export function runVerificationGate(options) {
             timestamp,
         };
     }
-    // Commands from preference and task-plan sources are blocking;
-    // package-json discovered commands are advisory (non-blocking).
-    const blocking = source === "preference" || source === "task-plan";
     const checks = [];
     for (const command of commands) {
         const start = Date.now();
@@ -233,22 +221,9 @@ export function runVerificationGate(options) {
         let exitCode;
         let stderr;
         if (result.error) {
-            // Spawn infrastructure failure — OS-level, not a test failure.
-            // Tag with infraError so the retry logic can skip auto-fix attempts.
-            const errCode = result.error.code;
-            const isInfra = !!errCode && INFRA_ERROR_CODES.has(errCode);
+            // Command not found or spawn failure
             exitCode = 127;
             stderr = truncate((result.stderr || "") + "\n" + result.error.message, MAX_OUTPUT_BYTES);
-            checks.push({
-                command,
-                exitCode,
-                stdout: truncate(result.stdout, MAX_OUTPUT_BYTES),
-                stderr,
-                durationMs,
-                blocking,
-                ...(isInfra ? { infraError: true } : {}),
-            });
-            continue;
         }
         else {
             // status is null when killed by signal — treat as failure
@@ -261,14 +236,10 @@ export function runVerificationGate(options) {
             stdout: truncate(result.stdout, MAX_OUTPUT_BYTES),
             stderr,
             durationMs,
-            blocking,
         });
     }
-    // Gate passes if all blocking checks pass (non-blocking failures are advisory)
-    const blockingChecks = checks.filter(c => c.blocking);
-    const passed = blockingChecks.length === 0 || blockingChecks.every(c => c.exitCode === 0);
     return {
-        passed,
+        passed: checks.every(c => c.exitCode === 0),
         checks,
         discoverySource: source,
         timestamp,

package/dist/resources/extensions/gsd/worktree-command.js

@@ -19,34 +19,21 @@ import { inferCommitType } from "./git-service.js";
 import { existsSync, realpathSync, readdirSync, rmSync, unlinkSync } from "node:fs";
 import { nativeMergeAbort } from "./native-git-bridge.js";
 import { join, sep } from "node:path";
-import { getErrorMessage } from "./error-utils.js";
 /**
  * Tracks the original project root so we can switch back.
  * Set when we first chdir into a worktree, cleared on return.
  */
 let originalCwd = null;
-function ensureWorktreeStateInitialized() {
-    if (originalCwd)
-        return;
-    const cwd = process.cwd();
-    const marker = `${sep}.gsd${sep}worktrees${sep}`;
-    const markerIdx = cwd.indexOf(marker);
-    if (markerIdx !== -1) {
-        originalCwd = cwd.slice(0, markerIdx);
-    }
-}
 /** Get the original project root if currently in a worktree, or null. */
 export function getWorktreeOriginalCwd() {
-    ensureWorktreeStateInitialized();
     return originalCwd;
 }
 /** Get the name of the active worktree, or null if not in one. */
 export function getActiveWorktreeName() {
-    ensureWorktreeStateInitialized();
     if (!originalCwd)
         return null;
     const cwd = process.cwd();
-    const wtDir = join(gsdRoot(originalCwd), "worktrees");
+    const wtDir = join(originalCwd, ".gsd", "worktrees");
     if (!cwd.startsWith(wtDir))
         return null;
     const rel = cwd.slice(wtDir.length + 1);
@@ -94,8 +81,7 @@ function worktreeCompletions(prefix) {
     }
     return [];
 }
-export async function handleWorktreeCommand(args, ctx, pi, alias) {
-    ensureWorktreeStateInitialized();
+async function worktreeHandler(args, ctx, pi, alias) {
     const trimmed = (typeof args === "string" ? args : "").trim();
     const basePath = process.cwd();
     if (trimmed === "") {
@@ -199,11 +185,21 @@ export async function handleWorktreeCommand(args, ctx, pi, alias) {
         await handleCreate(basePath, nameOnly, ctx);
     }
 }
+export async function handleWorktreeCommand(args, ctx, pi, alias) {
+    await worktreeHandler(args, ctx, pi, alias);
+}
 export function registerWorktreeCommand(pi) {
     // Restore worktree state after /reload.
     // The module-level originalCwd resets to null when extensions are re-loaded,
     // but process.cwd() is still inside the worktree. Detect this and recover.
-    ensureWorktreeStateInitialized();
+    if (!originalCwd) {
+        const cwd = process.cwd();
+        const marker = `${sep}.gsd${sep}worktrees${sep}`;
+        const markerIdx = cwd.indexOf(marker);
+        if (markerIdx !== -1) {
+            originalCwd = cwd.slice(0, markerIdx);
+        }
+    }
     pi.registerCommand("worktree", {
         description: "Git worktrees (also /wt): /worktree <name> | list | merge | remove",
         getArgumentCompletions: worktreeCompletions,
@@ -317,7 +313,7 @@ async function handleCreate(basePath, name, ctx) {
         ].filter(Boolean).join("\n"), "info");
     }
     catch (error) {
-        const msg = getErrorMessage(error);
+        const msg = error instanceof Error ? error.message : String(error);
         ctx.ui.notify(`Failed to create worktree: ${msg}`, "error");
     }
 }
@@ -351,7 +347,7 @@ async function handleSwitch(basePath, name, ctx) {
         ].filter(Boolean).join("\n"), "info");
     }
     catch (error) {
-        const msg = getErrorMessage(error);
+        const msg = error instanceof Error ? error.message : String(error);
         ctx.ui.notify(`Failed to switch to worktree: ${msg}`, "error");
     }
 }
@@ -442,7 +438,7 @@ async function handleList(basePath, ctx) {
         ctx.ui.notify(lines.join("\n"), "info");
     }
     catch (error) {
-        const msg = getErrorMessage(error);
+        const msg = error instanceof Error ? error.message : String(error);
         ctx.ui.notify(`Failed to list worktrees: ${msg}`, "error");
     }
 }
@@ -533,6 +529,16 @@ async function handleMerge(basePath, name, ctx, pi, targetBranch) {
         // Try a direct squash-merge first. Only fall back to LLM on conflict.
         const commitType = inferCommitType(name);
         const commitMessage = `${commitType}(${name}): merge worktree ${name}`;
+        // Reconcile worktree DB into main DB before squash merge
+        const wtDbPath = join(worktreePath(basePath, name), ".gsd", "gsd.db");
+        const mainDbPath = join(basePath, ".gsd", "gsd.db");
+        if (existsSync(wtDbPath) && existsSync(mainDbPath)) {
+            try {
+                const { reconcileWorktreeDb } = await import("./gsd-db.js");
+                reconcileWorktreeDb(mainDbPath, wtDbPath);
+            }
+            catch { /* non-fatal */ }
+        }
         try {
             mergeWorktreeToMain(basePath, name, commitMessage);
             ctx.ui.notify([
@@ -544,7 +550,7 @@ async function handleMerge(basePath, name, ctx, pi, targetBranch) {
             return;
         }
         catch (mergeErr) {
-            const mergeMsg = getErrorMessage(mergeErr);
+            const mergeMsg = mergeErr instanceof Error ? mergeErr.message : String(mergeErr);
             const isConflict = /conflict/i.test(mergeMsg);
             if (isConflict) {
                 // Abort the failed merge so the working tree is clean for LLM retry
@@ -588,7 +594,7 @@ async function handleMerge(basePath, name, ctx, pi, targetBranch) {
         ctx.ui.notify(`${CLR.ok("✓")} Merge helper started for ${CLR.name(name)} ${CLR.muted(`(${codeChanges} code + ${gsdChanges} GSD artifact change${totalChanges === 1 ? "" : "s"})`)}`, "info");
     }
     catch (error) {
-        const msg = getErrorMessage(error);
+        const msg = error instanceof Error ? error.message : String(error);
         ctx.ui.notify(`Failed to start merge: ${msg}`, "error");
     }
 }
@@ -622,7 +628,7 @@ async function handleRemove(basePath, name, ctx) {
         ctx.ui.notify(`${CLR.ok("✓")} Worktree ${CLR.name(name)} removed ${CLR.muted("(branch deleted)")}.`, "info");
     }
     catch (error) {
-        const msg = getErrorMessage(error);
+        const msg = error instanceof Error ? error.message : String(error);
         ctx.ui.notify(`Failed to remove worktree: ${msg}`, "error");
     }
 }
@@ -670,7 +676,7 @@ async function handleRemoveAll(basePath, ctx) {
         ctx.ui.notify(lines.join("\n"), failed.length > 0 ? "warning" : "info");
     }
     catch (error) {
-        const msg = getErrorMessage(error);
+        const msg = error instanceof Error ? error.message : String(error);
         ctx.ui.notify(`Failed to remove worktrees: ${msg}`, "error");
     }
 }

package/dist/resources/extensions/gsd/worktree-manager.js

@@ -16,7 +16,6 @@
  */
 import { existsSync, mkdirSync, readFileSync, realpathSync } from "node:fs";
 import { join, resolve, sep } from "node:path";
-import { gsdRoot } from "./paths.js";
 import { GSDError, GSD_PARSE_ERROR, GSD_STALE_STATE, GSD_LOCK_HELD, GSD_GIT_ERROR, GSD_MERGE_CONFLICT } from "./errors.js";
 import { nativeBranchDelete, nativeBranchExists, nativeBranchForceReset, nativeCommit, nativeDetectMainBranch, nativeDiffContent, nativeDiffNameStatus, nativeDiffNumstat, nativeGetCurrentBranch, nativeLogOneline, nativeMergeSquash, nativeWorktreeAdd, nativeWorktreeList, nativeWorktreePrune, nativeWorktreeRemove, } from "./native-git-bridge.js";
 // ─── Path Helpers ──────────────────────────────────────────────────────────
@@ -56,7 +55,7 @@ export function resolveGitDir(basePath) {
     return join(basePath, ".git");
 }
 export function worktreesDir(basePath) {
-    return join(gsdRoot(basePath), "worktrees");
+    return join(basePath, ".gsd", "worktrees");
 }
 export function worktreePath(basePath, name) {
     return join(worktreesDir(basePath), name);
@@ -133,7 +132,7 @@ export function listWorktrees(basePath) {
     const seenRoots = new Set();
     const worktreeRoots = baseVariants
         .map(baseVariant => {
-        const path = join(gsdRoot(baseVariant), "worktrees");
+        const path = join(baseVariant, ".gsd", "worktrees");
         return {
             normalized: normalizePathForComparison(path),
         };