gsd-pi 2.77.0-dev.eaa4973bc → 2.78.0-dev.aeeb2ca00

package/dist/resources/extensions/gsd/uok/parity-report.js

@@ -0,0 +1,58 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { gsdRoot } from "../paths.js";
+function parityLogPath(basePath) {
+    return join(gsdRoot(basePath), "runtime", "uok-parity.jsonl");
+}
+function reportPath(basePath) {
+    return join(gsdRoot(basePath), "runtime", "uok-parity-report.json");
+}
+function increment(bucket, key) {
+    const normalized = key && key.trim().length > 0 ? key : "unknown";
+    bucket[normalized] = (bucket[normalized] ?? 0) + 1;
+}
+export function parseParityEvents(raw) {
+    return raw
+        .split("\n")
+        .filter(Boolean)
+        .map((line) => {
+        try {
+            return JSON.parse(line);
+        }
+        catch {
+            return { status: "error", error: "invalid parity json line" };
+        }
+    });
+}
+export function buildParityReport(events, sourcePath) {
+    const paths = {};
+    const statuses = {};
+    const criticalMismatches = [];
+    let fallbackInvocations = 0;
+    for (const event of events) {
+        increment(paths, event.path);
+        increment(statuses, event.status);
+        if (event.path === "legacy-fallback")
+            fallbackInvocations += 1;
+        if (event.status === "error") {
+            criticalMismatches.push(event.error ?? "parity event reported error");
+        }
+    }
+    return {
+        generatedAt: new Date().toISOString(),
+        sourcePath,
+        totalEvents: events.length,
+        paths,
+        statuses,
+        criticalMismatches,
+        fallbackInvocations,
+    };
+}
+export function writeParityReport(basePath) {
+    const sourcePath = parityLogPath(basePath);
+    const raw = existsSync(sourcePath) ? readFileSync(sourcePath, "utf-8") : "";
+    const report = buildParityReport(parseParityEvents(raw), sourcePath);
+    mkdirSync(join(gsdRoot(basePath), "runtime"), { recursive: true });
+    writeFileSync(reportPath(basePath), JSON.stringify(report, null, 2) + "\n", "utf-8");
+    return report;
+}

package/dist/resources/extensions/gsd/uok/plan-v2.js

@@ -3,12 +3,15 @@ import { join } from "node:path";
 import { gsdRoot, resolveMilestoneFile, resolveSliceFile } from "../paths.js";
 import { isDbAvailable, getMilestoneSlices, getSliceTasks } from "../gsd-db.js";
 const PLAN_V2_CLARIFY_ROUND_LIMIT = 3;
-const EXECUTION_ENTRY_PHASES = new Set([
+export const EXECUTION_ENTRY_PHASES = new Set([
     "executing",
     "summarizing",
     "validating-milestone",
     "completing-milestone",
 ]);
+export function isExecutionEntryPhase(phase) {
+    return EXECUTION_ENTRY_PHASES.has(phase);
+}
 function graphOutputPath(basePath) {
     return join(gsdRoot(basePath), "runtime", "uok-plan-v2-graph.json");
 }
@@ -39,6 +42,12 @@ function hasMilestoneFileContent(basePath, milestoneId, suffix) {
     }
     return false;
 }
+export function hasFinalizedMilestoneContext(basePath, milestoneId) {
+    return hasMilestoneFileContent(basePath, milestoneId, "CONTEXT");
+}
+export function isMissingFinalizedContextResult(result) {
+    return !result.ok && result.finalizedContextIncluded === false;
+}
 function countSliceResearchArtifacts(basePath, milestoneId, slices) {
     let count = 0;
     for (const slice of slices) {
@@ -48,9 +57,6 @@ function countSliceResearchArtifacts(basePath, milestoneId, slices) {
     }
     return count;
 }
-function isExecutionEntryPhase(phase) {
-    return EXECUTION_ENTRY_PHASES.has(phase);
-}
 export function compileUnitGraphFromState(basePath, state) {
     const mid = state.activeMilestone?.id;
     if (!mid)

package/dist/resources/extensions/gsd/uok/writer.js

@@ -0,0 +1,82 @@
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { randomUUID } from "node:crypto";
+import { atomicWriteSync } from "../atomic-write.js";
+import { gsdRoot } from "../paths.js";
+const activeTokens = new Map();
+function tokenKey(basePath, turnId) {
+    return `${basePath}:${turnId}`;
+}
+function sequencePath(basePath) {
+    return join(gsdRoot(basePath), "runtime", "uok-writer-sequence.json");
+}
+function readSequenceState(basePath) {
+    const path = sequencePath(basePath);
+    if (!existsSync(path)) {
+        return { lastSequence: 0, updatedAt: new Date(0).toISOString() };
+    }
+    try {
+        const parsed = JSON.parse(readFileSync(path, "utf-8"));
+        return {
+            lastSequence: Number.isInteger(parsed.lastSequence) ? Number(parsed.lastSequence) : 0,
+            updatedAt: typeof parsed.updatedAt === "string" ? parsed.updatedAt : new Date(0).toISOString(),
+        };
+    }
+    catch {
+        return { lastSequence: 0, updatedAt: new Date(0).toISOString() };
+    }
+}
+function writeSequenceState(basePath, state) {
+    atomicWriteSync(sequencePath(basePath), JSON.stringify(state, null, 2) + "\n", "utf-8");
+}
+export function acquireWriterToken(args) {
+    const key = tokenKey(args.basePath, args.turnId);
+    const existing = activeTokens.get(key);
+    if (existing) {
+        throw new Error(`Writer token already active for turn ${args.turnId}`);
+    }
+    const token = {
+        tokenId: randomUUID(),
+        traceId: args.traceId,
+        turnId: args.turnId,
+        acquiredAt: new Date().toISOString(),
+        owner: args.owner ?? "uok",
+    };
+    activeTokens.set(key, token);
+    return token;
+}
+export function releaseWriterToken(basePath, token) {
+    const key = tokenKey(basePath, token.turnId);
+    const current = activeTokens.get(key);
+    if (current?.tokenId === token.tokenId) {
+        activeTokens.delete(key);
+    }
+}
+export function hasActiveWriterToken(basePath, turnId) {
+    return activeTokens.has(tokenKey(basePath, turnId));
+}
+export function nextWriteRecord(args) {
+    if (!hasActiveWriterToken(args.basePath, args.token.turnId)) {
+        throw new Error(`Writer token is not active for turn ${args.token.turnId}`);
+    }
+    const state = readSequenceState(args.basePath);
+    const sequence = state.lastSequence + 1;
+    const updatedAt = new Date().toISOString();
+    writeSequenceState(args.basePath, { lastSequence: sequence, updatedAt });
+    return {
+        writerToken: args.token,
+        sequence: {
+            traceId: args.token.traceId,
+            turnId: args.token.turnId,
+            sequence,
+        },
+        category: args.category,
+        operation: args.operation,
+        path: args.path,
+        ts: updatedAt,
+        metadata: args.metadata,
+    };
+}
+export function resetWriterTokensForTests() {
+    activeTokens.clear();
+}

package/dist/resources/extensions/gsd/workflow-mcp.js

@@ -15,6 +15,7 @@ const MCP_WORKFLOW_TOOL_SURFACE = new Set([
     "gsd_journal_query",
     "gsd_milestone_complete",
     "gsd_milestone_generate_id",
+    "gsd_milestone_reopen",
     "gsd_checkpoint_db",
     "gsd_milestone_status",
     "gsd_milestone_validate",
@@ -23,6 +24,9 @@ const MCP_WORKFLOW_TOOL_SURFACE = new Set([
     "gsd_plan_slice",
     "gsd_replan_slice",
     "gsd_reassess_roadmap",
+    "gsd_reopen_milestone",
+    "gsd_reopen_slice",
+    "gsd_reopen_task",
     "gsd_requirement_save",
     "gsd_requirement_update",
     "gsd_roadmap_reassess",
@@ -32,9 +36,11 @@ const MCP_WORKFLOW_TOOL_SURFACE = new Set([
     "gsd_skip_slice",
     "gsd_slice_replan",
     "gsd_slice_complete",
+    "gsd_slice_reopen",
     "gsd_summary_save",
     "gsd_task_plan",
     "gsd_task_complete",
+    "gsd_task_reopen",
     "gsd_update_requirement",
     "gsd_validate_milestone",
 ]);

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

@@ -19,7 +19,8 @@ import { execFileSync } from "node:child_process";
 import { join, resolve, sep } from "node:path";
 import { GSDError, GSD_PARSE_ERROR, GSD_STALE_STATE, GSD_LOCK_HELD, GSD_GIT_ERROR, GSD_MERGE_CONFLICT } from "./errors.js";
 import { logWarning } from "./workflow-logger.js";
-import { nativeBranchDelete, nativeBranchExists, nativeBranchForceReset, nativeCommit, nativeDetectMainBranch, nativeDiffContent, nativeDiffNameStatus, nativeDiffNumstat, nativeGetCurrentBranch, nativeLogOneline, nativeMergeSquash, nativeWorktreeAdd, nativeWorktreeList, nativeWorktreePrune, nativeWorktreeRemove, } from "./native-git-bridge.js";
+import { nativeBranchDelete, nativeBranchExists, nativeBranchForceReset, nativeCommit, nativeDetectMainBranch, nativeDiffContent, nativeDiffNameStatus, nativeDiffNumstat, nativeGetCurrentBranch, nativeIsAncestor, nativeLogOneline, nativeMergeSquash, nativeWorktreeAdd, nativeWorktreeList, nativeWorktreePrune, nativeWorktreeRemove, } from "./native-git-bridge.js";
+import { emitCanonicalRootRedirect } from "./worktree-telemetry.js";
 // ─── Path Helpers ──────────────────────────────────────────────────────────
 function normalizePathForComparison(path) {
     const normalized = path
@@ -84,6 +85,56 @@ export function isInsideWorktreesDir(basePath, targetPath) {
     // not merely be a prefix match (e.g. ".gsd/worktrees-extra" must not match).
     return resolved === wtDir || resolved.startsWith(wtDir + sep);
 }
+/**
+ * Return the canonical path from which a milestone's artifacts should be read.
+ *
+ * If a live git worktree exists for this milestone at `.gsd/worktrees/<MID>/`
+ * (directory present AND a `.git` file indicating a registered worktree),
+ * returns that worktree path. Otherwise returns `basePath` unchanged.
+ *
+ * Readers that cross the session/worktree boundary (validators, the bootstrap
+ * audit, cross-session state queries) should route through this helper so they
+ * don't silently read stale project-root state while live work sits in the
+ * worktree. Writers and tools whose contract is "operate on the path I was
+ * given" should NOT use this helper — they preserve the legacy behavior.
+ *
+ * A stale worktree directory (no `.git` file) is treated as absent. The
+ * createWorktree() path already cleans these up, but readers must not trust
+ * them in the window before cleanup runs.
+ *
+ * Fixes #4761. Used by the #4762 audit for the pre-completion orphan case.
+ */
+export function resolveCanonicalMilestoneRoot(basePath, milestoneId) {
+    if (!milestoneId || /[\/\\]|\.\./.test(milestoneId))
+        return basePath;
+    const wtPath = worktreePath(basePath, milestoneId);
+    if (!existsSync(wtPath))
+        return basePath;
+    // A registered git worktree has a .git *file* (not directory) containing
+    // "gitdir: <path>". A standalone .git directory indicates a copied repo
+    // or nested standalone repo — not a worktree registered with this project —
+    // and must not be treated as the canonical root.
+    const gitPath = join(wtPath, ".git");
+    if (!existsSync(gitPath))
+        return basePath;
+    try {
+        const stat = lstatSync(gitPath);
+        if (!stat.isFile())
+            return basePath;
+    }
+    catch {
+        return basePath;
+    }
+    // #4764 — record the redirect so we can measure how often the #4761 fix
+    // would have mattered. Best-effort; emit is silent on any failure.
+    try {
+        emitCanonicalRootRedirect(basePath, milestoneId, wtPath);
+    }
+    catch (err) {
+        logWarning("worktree", `canonical-root-redirect telemetry failed: ${err instanceof Error ? err.message : String(err)}`);
+    }
+    return wtPath;
+}
 // ─── Core Operations ───────────────────────────────────────────────────────
 /**
  * Create a new git worktree under .gsd/worktrees/<name>/ with branch worktree/<name>.
@@ -120,6 +171,13 @@ export function createWorktree(basePath, name, opts = {}) {
     // Use the explicit start point (e.g. integration branch) if provided,
     // otherwise fall back to the repo's detected main branch.
     const startPoint = opts.startPoint ?? nativeDetectMainBranch(basePath);
+    // Reject early if startPoint resolves to an empty/invalid ref. On an
+    // unborn branch (zero-commit repo) nativeDetectMainBranch returns "",
+    // which would flow into `git worktree add ... ""` and crash with
+    // `fatal: not a valid object name`. (Issue #4980 HIGH-9)
+    if (!startPoint || startPoint.length === 0) {
+        throw new GSDError(GSD_GIT_ERROR, "Repository has no commits yet (unborn branch). Make an initial commit before creating worktrees.");
+    }
     // Check if the branch already exists (leftover from a previous worktree)
     const branchAlreadyExists = nativeBranchExists(basePath, branch);
     if (branchAlreadyExists) {
@@ -137,6 +195,18 @@ export function createWorktree(basePath, name, opts = {}) {
             nativeWorktreeAdd(basePath, wtPath, branch);
         }
         else {
+            // Ancestry guard: refuse to force-reset a branch that has commits not
+            // reachable from startPoint. A crash-then-resume cycle that didn't
+            // write the resume file would silently orphan prior-session commits
+            // (recoverable from reflog for 90d, then gone — branch is also
+            // deleted at teardown). (Issue #4980 HIGH-3)
+            const branchIsAncestor = nativeIsAncestor(basePath, branch, startPoint);
+            if (!branchIsAncestor) {
+                throw new GSDError(GSD_GIT_ERROR, `Branch "${branch}" already exists with commits not reachable from "${startPoint}". ` +
+                    `Refusing to force-reset — would orphan prior work. ` +
+                    `If you intend to keep those commits, retry with reuseExistingBranch=true. ` +
+                    `If you intend to discard, run \`git branch -D ${branch}\` manually first.`);
+            }
             // Reset the stale branch to the start point, then attach worktree to it
             nativeBranchForceReset(basePath, branch, startPoint);
             nativeWorktreeAdd(basePath, wtPath, branch);
@@ -368,15 +438,22 @@ export function removeWorktree(basePath, name, opts = {}) {
             // Lines starting with '+' indicate uncommitted submodule changes
             hasSubmoduleChanges = submoduleStatus.split("\n").some((line) => line.startsWith("+") || line.startsWith("-"));
             if (hasSubmoduleChanges) {
-                // Stash submodule changes so they are not lost during force removal.
-                // The stash is created in the worktree before it's torn down.
+                // Save submodule changes to a labeled rescue branch instead of the
+                // shared stash list. Stash is per-repo (not per-worktree), so an
+                // entry created here would appear in the user's main-tree stash
+                // list and reference paths that disappear after worktree removal.
+                // A branch persists in the shared .git refs after worktree removal
+                // and is discoverable via `git branch --list 'gsd/submodule-rescue/*'`.
+                // (Issue #4980 HIGH-11)
+                const rescueBranch = `gsd/submodule-rescue/${name}-${Date.now()}`;
                 try {
-                    execFileSync("git", ["stash", "push", "-m", "gsd: auto-stash submodule changes before worktree teardown"], { cwd: resolvedWtPath, stdio: ["ignore", "pipe", "pipe"], encoding: "utf-8" });
-                    logWarning("reconcile", `Stashed uncommitted submodule changes before worktree teardown`, { worktree: name, path: resolvedWtPath });
+                    execFileSync("git", ["add", "-A"], { cwd: resolvedWtPath, stdio: ["ignore", "pipe", "pipe"], encoding: "utf-8" });
+                    execFileSync("git", ["commit", "-m", `gsd: rescue submodule changes from worktree ${name}`, "--allow-empty"], { cwd: resolvedWtPath, stdio: ["ignore", "pipe", "pipe"], encoding: "utf-8" });
+                    execFileSync("git", ["branch", rescueBranch, "HEAD"], { cwd: resolvedWtPath, stdio: ["ignore", "pipe", "pipe"], encoding: "utf-8" });
+                    logWarning("reconcile", `Saved uncommitted submodule changes to rescue branch ${rescueBranch}`, { worktree: name, path: resolvedWtPath, rescueBranch });
                 }
-                catch {
-                    // Stash failed — warn the user that submodule changes may be lost
-                    logWarning("reconcile", `Submodule changes detected — stash failed, changes may be lost during force removal`, { worktree: name, path: resolvedWtPath });
+                catch (err) {
+                    logWarning("reconcile", `Submodule rescue branch creation failed — changes may be lost during force removal: ${err instanceof Error ? err.message : String(err)}`, { worktree: name, path: resolvedWtPath });
                 }
             }
         }

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

@@ -17,6 +17,9 @@ import { randomUUID } from "node:crypto";
 import { join } from "node:path";
 import { debugLog } from "./debug-logger.js";
 import { emitJournalEvent } from "./journal.js";
+import { emitWorktreeCreated, emitWorktreeMerged } from "./worktree-telemetry.js";
+import { getCollapseCadence, getMilestoneResquash, resquashMilestoneOnMain } from "./slice-cadence.js";
+import { loadEffectiveGSDPreferences } from "./preferences.js";
 // ─── Path Helpers ──────────────────────────────────────────────────────────
 /**
  * Worktree marker segment — present in any path produced by worktreePath().
@@ -194,6 +197,20 @@ export class WorktreeResolver {
                 eventType: "worktree-enter",
                 data: { milestoneId, wtPath, created: !existingPath },
             });
+            // #4764 — record creation/enter as a lifecycle event so the telemetry
+            // aggregator can pair it with the eventual worktree-merged event.
+            try {
+                emitWorktreeCreated(this.s.originalBasePath || this.s.basePath, milestoneId, {
+                    reason: existingPath ? "enter-milestone" : "create-milestone",
+                });
+            }
+            catch (telemetryErr) {
+                debugLog("WorktreeResolver", {
+                    action: "enterMilestone",
+                    phase: "telemetry-emit",
+                    error: telemetryErr instanceof Error ? telemetryErr.message : String(telemetryErr),
+                });
+            }
             ctx.notify(`Entered worktree for ${milestoneId} at ${wtPath}`, "info");
         }
         catch (err) {
@@ -289,6 +306,9 @@ export class WorktreeResolver {
      */
     mergeAndExit(milestoneId, ctx) {
         this.validateMilestoneId(milestoneId);
+        // #4764 — telemetry: record start timestamp so we can emit merge duration.
+        const mergeStartedAt = new Date().toISOString();
+        const mergeStartMs = Date.now();
         // If worktree creation failed earlier, skip merge — work is on current branch (#2483)
         if (this.s.isolationDegraded) {
             debugLog("WorktreeResolver", {
@@ -328,14 +348,68 @@ export class WorktreeResolver {
             });
             return;
         }
+        let actuallyMerged = false;
         if (mode === "worktree" || inWorktree) {
-            this._mergeWorktreeMode(milestoneId, ctx);
+            actuallyMerged = this._mergeWorktreeMode(milestoneId, ctx);
         }
         else if (mode === "branch") {
-            this._mergeBranchMode(milestoneId, ctx);
+            actuallyMerged = this._mergeBranchMode(milestoneId, ctx);
+        }
+        // The remainder of this function emits telemetry and runs re-squash.
+        // Both are gated on actuallyMerged — if the _merge* helper took a
+        // no-merge path (missing originalBase, no roadmap, wrong branch) the
+        // milestone branch was intentionally left unmerged and we must not
+        // emit a worktree-merged event or collapse commits on main.
+        if (!actuallyMerged) {
+            // Always clear the start-SHA tracker to avoid leaking across sessions.
+            this.s.milestoneStartShas.delete(milestoneId);
+            return;
+        }
+        // #4765 — when collapse_cadence=slice AND milestone_resquash=true, the
+        // N per-slice commits on main should be collapsed into one milestone
+        // commit. Done AFTER the primary merge-and-teardown so the branch and
+        // worktree are already cleaned up; we operate on main directly.
+        try {
+            const startSha = this.s.milestoneStartShas.get(milestoneId);
+            if (startSha) {
+                const prefs = loadEffectiveGSDPreferences(this.s.originalBasePath || this.s.basePath)?.preferences;
+                if (getCollapseCadence(prefs) === "slice" && getMilestoneResquash(prefs)) {
+                    const result = resquashMilestoneOnMain(this.s.originalBasePath || this.s.basePath, milestoneId, startSha);
+                    if (result.resquashed) {
+                        ctx.notify(`slice-cadence: re-squashed slice commits for ${milestoneId} into a single milestone commit.`, "info");
+                    }
+                }
+                this.s.milestoneStartShas.delete(milestoneId);
+            }
+        }
+        catch (err) {
+            debugLog("WorktreeResolver", {
+                action: "mergeAndExit",
+                milestoneId,
+                phase: "resquash",
+                error: err instanceof Error ? err.message : String(err),
+            });
+        }
+        // #4764 — record merge completion. Only reaches here when an actual
+        // merge ran; failure paths throw out of _merge* before this point and
+        // no-merge paths returned above.
+        try {
+            emitWorktreeMerged(this.s.originalBasePath || this.s.basePath, milestoneId, {
+                reason: "milestone-complete",
+                startedAt: mergeStartedAt,
+                durationMs: Date.now() - mergeStartMs,
+            });
+        }
+        catch (telemetryErr) {
+            debugLog("WorktreeResolver", {
+                action: "mergeAndExit",
+                phase: "telemetry-emit",
+                error: telemetryErr instanceof Error ? telemetryErr.message : String(telemetryErr),
+            });
         }
     }
-    /** Worktree-mode merge: read roadmap, merge, teardown, reset paths. */
+    /** Worktree-mode merge: read roadmap, merge, teardown, reset paths.
+     *  Returns true when a squash-merge actually ran (false on skip paths). */
     _mergeWorktreeMode(milestoneId, ctx) {
         const originalBase = this.s.originalBasePath;
         if (!originalBase) {
@@ -346,8 +420,9 @@ export class WorktreeResolver {
                 skipped: true,
                 reason: "missing-original-base",
             });
-            return;
+            return false;
         }
+        let merged = false;
         try {
             const { synced } = this.deps.syncWorktreeStateBack(originalBase, this.s.basePath, milestoneId);
             if (synced.length > 0) {
@@ -378,6 +453,7 @@ export class WorktreeResolver {
             if (roadmapPath) {
                 const roadmapContent = this.deps.readFileSync(roadmapPath, "utf-8");
                 const mergeResult = this.deps.mergeMilestoneToMain(originalBase, milestoneId, roadmapContent);
+                merged = true;
                 // #2945 Bug 3: mergeMilestoneToMain performs best-effort worktree
                 // cleanup internally (step 12), but it can silently fail on Windows
                 // or when the worktree directory is locked. Perform a secondary
@@ -470,8 +546,10 @@ export class WorktreeResolver {
             result: "done",
             basePath: this.s.basePath,
         });
+        return merged;
     }
-    /** Branch-mode merge: check current branch, merge if on milestone branch. */
+    /** Branch-mode merge: check current branch, merge if on milestone branch.
+     *  Returns true when a merge actually ran (false on skip paths). */
     _mergeBranchMode(milestoneId, ctx) {
         try {
             const currentBranch = this.deps.getCurrentBranch(this.s.basePath);
@@ -486,7 +564,7 @@ export class WorktreeResolver {
                     currentBranch,
                     milestoneBranch,
                 });
-                return;
+                return false;
             }
             const roadmapPath = this.deps.resolveMilestoneFile(this.s.basePath, milestoneId, "ROADMAP");
             if (!roadmapPath) {
@@ -497,7 +575,7 @@ export class WorktreeResolver {
                     skipped: true,
                     reason: "no-roadmap",
                 });
-                return;
+                return false;
             }
             const roadmapContent = this.deps.readFileSync(roadmapPath, "utf-8");
             const mergeResult = this.deps.mergeMilestoneToMain(this.s.basePath, milestoneId, roadmapContent);
@@ -516,6 +594,7 @@ export class WorktreeResolver {
                 mode: "branch",
                 result: "success",
             });
+            return true;
         }
         catch (err) {
             const msg = err instanceof Error ? err.message : String(err);