@opengsd/gsd-pi 1.3.0-dev.eed73bea → 1.4.0

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

@@ -1,11 +1,12 @@
 // Project/App: gsd-pi
 // File Purpose: State manifest snapshot and restore orchestration for GSD workflow data.
 import { _getAdapter, readTransaction, restoreManifest, } from "./gsd-db.js";
-import { atomicWriteSync } from "./atomic-write.js";
+import { atomicWriteAsync, atomicWriteSync } from "./atomic-write.js";
 import { getAllDecisionsFromMemories } from "./context-store.js";
 import { backfillDecisionsToMemories } from "./memory-backfill.js";
 import { invalidateAllCaches } from "./cache.js";
-import { readFileSync, existsSync, mkdirSync } from "node:fs";
+import { logWarning } from "./workflow-logger.js";
+import { readFileSync, existsSync } from "node:fs";
 import { isAbsolute, join, relative, resolve } from "node:path";
 // ─── helpers ─────────────────────────────────────────────────────────────
 function requireDb() {
@@ -257,22 +258,131 @@ export function snapshotState() {
         return result;
     });
 }
-// ─── restore ─────────────────────────────────────────────────────────────
-//
-// The actual restore() implementation lives in gsd-db.ts (single-writer
-// invariant). This module only orchestrates reading the manifest file
-// and handing it to the writer.
-// ─── writeManifest ───────────────────────────────────────────────────────
+const manifestWrites = new Map();
+let processTeardownFlushInstalled = false;
+let beforeExitFlushStarted = false;
+function manifestWriteKey(basePath) {
+    return resolve(basePath);
+}
+function manifestFilePath(basePath) {
+    return join(resolve(basePath), ".gsd", "state-manifest.json");
+}
+function describeError(err) {
+    return err instanceof Error ? err.message : String(err);
+}
+function logManifestWriteFailure(filePath, err) {
+    logWarning("manifest", `state manifest write failed: ${describeError(err)}`, { file: filePath });
+}
+async function drainManifestWrites(key, state) {
+    let lastWriteError = null;
+    try {
+        while (state.latestJson !== null && state.syncFlushJson === null) {
+            const json = state.latestJson;
+            state.latestJson = null;
+            state.inFlightJson = json;
+            try {
+                await atomicWriteAsync(state.filePath, json);
+                if (state.syncFlushJson !== null) {
+                    atomicWriteSync(state.filePath, state.syncFlushJson);
+                    break;
+                }
+                lastWriteError = null;
+            }
+            catch (err) {
+                lastWriteError = err;
+                logManifestWriteFailure(state.filePath, err);
+            }
+            finally {
+                state.inFlightJson = null;
+            }
+        }
+    }
+    finally {
+        state.active = null;
+        if (state.latestJson === null && state.inFlightJson === null) {
+            manifestWrites.delete(key);
+        }
+    }
+    if (lastWriteError !== null && state.syncFlushJson === null) {
+        throw lastWriteError;
+    }
+}
+function enqueueManifestWrite(basePath, json) {
+    const key = manifestWriteKey(basePath);
+    let state = manifestWrites.get(key);
+    if (!state) {
+        state = {
+            filePath: manifestFilePath(basePath),
+            latestJson: null,
+            inFlightJson: null,
+            syncFlushJson: null,
+            active: null,
+        };
+        manifestWrites.set(key, state);
+    }
+    state.latestJson = json;
+    if (!state.active) {
+        const active = drainManifestWrites(key, state);
+        void active.catch(() => { });
+        state.active = active;
+    }
+}
 /**
- * Write current DB state to .gsd/state-manifest.json via atomicWriteSync.
+ * Queue current DB state for an async atomic write to .gsd/state-manifest.json.
  * Uses JSON.stringify with 2-space indent for git three-way merge friendliness.
  */
 export function writeManifest(basePath) {
     const manifest = snapshotState();
     const json = JSON.stringify(manifest, null, 2);
-    const dir = join(basePath, ".gsd");
-    mkdirSync(dir, { recursive: true });
-    atomicWriteSync(join(dir, "state-manifest.json"), json);
+    enqueueManifestWrite(basePath, json);
+}
+async function flushManifestByKey(key) {
+    for (;;) {
+        const active = manifestWrites.get(key)?.active;
+        if (!active)
+            return;
+        await active;
+    }
+}
+/**
+ * Wait for any queued manifest write for this base path to become durable.
+ */
+export async function flushManifest(basePath) {
+    await flushManifestByKey(manifestWriteKey(basePath));
+}
+export async function flushAllManifests() {
+    await Promise.all(Array.from(manifestWrites.keys(), key => flushManifestByKey(key)));
+}
+function flushAllManifestsSync() {
+    for (const [key, state] of manifestWrites) {
+        const json = state.latestJson ?? state.inFlightJson;
+        if (json === null)
+            continue;
+        try {
+            atomicWriteSync(state.filePath, json);
+            state.latestJson = null;
+            state.inFlightJson = null;
+            state.syncFlushJson = json;
+            manifestWrites.delete(key);
+        }
+        catch (err) {
+            logManifestWriteFailure(state.filePath, err);
+        }
+    }
+}
+export function installManifestFlushOnProcessTeardown() {
+    if (processTeardownFlushInstalled)
+        return;
+    processTeardownFlushInstalled = true;
+    process.once("beforeExit", () => {
+        if (beforeExitFlushStarted)
+            return;
+        beforeExitFlushStarted = true;
+        void flushAllManifests();
+    });
+    process.once("exit", () => {
+        flushAllManifestsSync();
+    });
 }
 // ─── readManifest ────────────────────────────────────────────────────────
 /**
@@ -317,7 +427,10 @@ function restoreArtifactProjections(basePath, manifest) {
     if (manifest.artifacts === undefined)
         return;
     for (const artifact of manifest.artifacts) {
-        atomicWriteSync(artifactProjectionPath(basePath, artifact.path), artifact.full_content ?? "");
+        const content = artifact.full_content ?? "";
+        if (content === "")
+            continue;
+        atomicWriteSync(artifactProjectionPath(basePath, artifact.path), content);
     }
 }
 // ─── bootstrapFromManifest ──────────────────────────────────────────────

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

@@ -399,15 +399,13 @@ export async function renderStateProjection(basePath) {
         logWarning("projection", `renderStateProjection failed: ${err.message}`);
     }
 }
-// ─── renderAllProjections ───────────────────────────────────────────────
+// ─── renderMilestoneShellProjections ─────────────────────────────────────
 /**
- * Regenerate all projection files for a milestone from DB state.
- * All calls are wrapped in try/catch — projection failure is non-fatal per D-02.
+ * Regenerate milestone-level projections (roadmap, top-level views, STATE.md).
+ * Does not touch slice PLAN.md or task SUMMARY.md — those have authoritative
+ * renderers in plan-slice / complete-task.
  */
-export async function renderAllProjections(basePath, milestoneId) {
-    // Delegate to the authoritative roadmap renderer — the reduced
-    // renderRoadmapProjection omits sections like ## Boundary Map and would
-    // clobber the output written by plan-milestone / reassess-roadmap.
+export async function renderMilestoneShellProjections(basePath, milestoneId) {
     try {
         await renderRoadmapFromDb(basePath, milestoneId);
     }
@@ -426,6 +424,20 @@ export async function renderAllProjections(basePath, milestoneId) {
     catch (err) {
         logWarning("projection", `renderTopLevelQueueFromDb failed: ${err.message}`);
     }
+    try {
+        await renderStateProjection(basePath);
+    }
+    catch (err) {
+        logWarning("projection", `renderStateProjection failed: ${err.message}`);
+    }
+}
+// ─── renderAllProjections ───────────────────────────────────────────────
+/**
+ * Regenerate all projection files for a milestone from DB state.
+ * All calls are wrapped in try/catch — projection failure is non-fatal per D-02.
+ */
+export async function renderAllProjections(basePath, milestoneId) {
+    await renderMilestoneShellProjections(basePath, milestoneId);
     // Query all slices for this milestone
     const sliceRows = getMilestoneSlices(milestoneId);
     for (const slice of sliceRows) {
@@ -445,13 +457,6 @@ export async function renderAllProjections(basePath, milestoneId) {
             }
         }
     }
-    // Render STATE.md
-    try {
-        await renderStateProjection(basePath);
-    }
-    catch (err) {
-        logWarning("projection", `renderStateProjection failed: ${err.message}`);
-    }
 }
 // ─── regenerateIfMissing ────────────────────────────────────────────────
 /**

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

@@ -17,12 +17,12 @@
  *   3. merge()   — LLM-guided reconciliation of .gsd/ artifacts back to main
  *   4. remove()  — git worktree remove + branch cleanup
  */
-import { existsSync, lstatSync, mkdirSync, readdirSync, readFileSync, realpathSync, rmSync, statSync } from "node:fs";
+import { existsSync, lstatSync, mkdirSync, readdirSync, readFileSync, realpathSync, rmSync, statSync, unlinkSync } from "node:fs";
 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 { nativeBranchList, nativeBranchDelete, nativeBranchExists, nativeBranchForceReset, nativeCommit, nativeDetectMainBranch, nativeDiffContent, nativeDiffNameStatus, nativeDiffNumstat, nativeGetCurrentBranch, nativeIsAncestor, nativeLogOneline, nativeMergeSquash, nativeWorktreeAdd, nativeWorktreeList, nativeWorktreePrune, nativeWorktreeRemove, } from "./native-git-bridge.js";
+import { nativeBranchList, nativeBranchDelete, nativeBranchExists, nativeBranchForceReset, nativeCommit, nativeDetectMainBranch, nativeDiffContent, nativeDiffNameStatus, nativeDiffNumstat, nativeGetCurrentBranch, nativeIsAncestor, nativeLogOneline, nativeMergeAbort, nativeMergeSquash, nativeWorktreeAdd, nativeWorktreeList, nativeWorktreePrune, nativeWorktreeRemove, } from "./native-git-bridge.js";
 import { emitCanonicalRootRedirect } from "./worktree-telemetry.js";
 import { isGsdWorktreePath, normalizeWorktreePathForCompare, resolveWorktreeProjectRoot, } from "./worktree-root.js";
 import { MILESTONE_ID_RE } from "./milestone-ids.js";
@@ -37,6 +37,36 @@ function deleteBranchIfPresent(basePath, branch, warningPrefix) {
         logWarning("worktree", `${warningPrefix}: ${e.message}`);
     }
 }
+function cleanupFailedSquashMergeState(basePath) {
+    try {
+        nativeMergeAbort(basePath);
+    }
+    catch (e) {
+        // Squash conflicts may not create MERGE_HEAD; this is expected.
+        logWarning("worktree", `merge abort skipped: ${e.message}`);
+    }
+    try {
+        execFileSync("git", ["reset", "--merge"], {
+            cwd: basePath,
+            stdio: ["ignore", "pipe", "pipe"],
+            encoding: "utf-8",
+        });
+    }
+    catch (e) {
+        logWarning("worktree", `failed squash merge reset failed: ${e.message}`);
+    }
+    const gitDir = resolveGitDir(basePath);
+    for (const marker of ["SQUASH_MSG", "MERGE_MSG", "MERGE_MODE", "MERGE_HEAD", "AUTO_MERGE"]) {
+        try {
+            const markerPath = join(gitDir, marker);
+            if (existsSync(markerPath))
+                unlinkSync(markerPath);
+        }
+        catch (e) {
+            logWarning("worktree", `failed squash merge marker cleanup failed (${marker}): ${e.message}`);
+        }
+    }
+}
 // ─── Path Helpers ──────────────────────────────────────────────────────────
 function normalizePathForComparison(path) {
     const normalized = path
@@ -903,6 +933,18 @@ export function mergeWorktreeToMain(basePath, name, commitMessage, branchOverrid
     }
     const result = nativeMergeSquash(basePath, branch);
     if (!result.success) {
+        const dirtyWorkingTree = result.conflicts.includes("__dirty_working_tree__");
+        if (!dirtyWorkingTree) {
+            cleanupFailedSquashMergeState(basePath);
+        }
+        if (!dirtyWorkingTree && branch.startsWith("milestone/")) {
+            try {
+                removeWorktree(basePath, name, { branch, deleteBranch: true, force: true });
+            }
+            catch (e) {
+                logWarning("worktree", `failed milestone branch cleanup after squash merge failure: ${e.message}`);
+            }
+        }
         throw new GSDError(GSD_MERGE_CONFLICT, `Merge conflicts detected in: ${result.conflicts.join(", ")}`);
     }
     nativeCommit(basePath, commitMessage);