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

package/dist/resources/extensions/gsd/memory-consolidation-scanner.js

@@ -94,27 +94,48 @@ function getActiveDecisions() {
         return [];
     }
 }
-/**
- * True when a memory row has a `structured_fields` JSON payload containing
- * the given `markerKey: "value"` pair. Matches the LIKE pattern used by
- * `backfillDecisionsToMemories` so the scanner is consistent with the
- * backfill's idempotency check.
- */
-function memoryHasSourceMarker(markerKey, value) {
+function emptyMemorySourceMarkers() {
+    return { decisionIds: new Set(), knowledgeIds: new Set() };
+}
+function getMemorySourceMarkers() {
+    const markers = emptyMemorySourceMarkers();
     if (!isDbAvailable())
-        return false;
+        return markers;
     const adapter = _getAdapter();
     if (!adapter)
-        return false;
+        return markers;
     try {
-        const pattern = `%"${markerKey}":"${value}"%`;
-        const row = adapter
-            .prepare("SELECT 1 FROM memories WHERE structured_fields LIKE :pattern LIMIT 1")
-            .get({ ":pattern": pattern });
-        return row !== undefined;
+        const rows = adapter
+            .prepare("SELECT structured_fields FROM memories WHERE structured_fields IS NOT NULL")
+            .all();
+        for (const row of rows) {
+            collectMemorySourceMarker(markers, row["structured_fields"]);
+        }
     }
     catch {
-        return false;
+        return markers;
+    }
+    return markers;
+}
+function collectMemorySourceMarker(markers, raw) {
+    if (typeof raw !== "string" || raw.length === 0)
+        return;
+    try {
+        const parsed = JSON.parse(raw);
+        if (!parsed || typeof parsed !== "object" || Array.isArray(parsed))
+            return;
+        const fields = parsed;
+        const decisionId = fields["sourceDecisionId"];
+        if (typeof decisionId === "string" && decisionId.length > 0) {
+            markers.decisionIds.add(decisionId);
+        }
+        const knowledgeId = fields["sourceKnowledgeId"];
+        if (typeof knowledgeId === "string" && knowledgeId.length > 0) {
+            markers.knowledgeIds.add(knowledgeId);
+        }
+    }
+    catch {
+        return;
     }
 }
 // ─── Public API ──────────────────────────────────────────────────────────────
@@ -127,10 +148,14 @@ const SAMPLE_LIMIT = 5;
 export function scanConsolidationGaps(basePath) {
     // ── Decisions ────────────────────────────────────────────────────────
     const decisions = getActiveDecisions();
+    const knowledgeRows = parseKnowledgeRows(knowledgeMdContent(basePath));
+    const memorySourceMarkers = decisions.length > 0 || knowledgeRows.length > 0
+        ? getMemorySourceMarkers()
+        : emptyMemorySourceMarkers();
     const decisionSamples = [];
     let decisionMigrated = 0;
     for (const decision of decisions) {
-        if (memoryHasSourceMarker("sourceDecisionId", decision.id)) {
+        if (memorySourceMarkers.decisionIds.has(decision.id)) {
             decisionMigrated += 1;
             continue;
         }
@@ -142,16 +167,14 @@ export function scanConsolidationGaps(basePath) {
         }
     }
     // ── KNOWLEDGE.md ─────────────────────────────────────────────────────
-    const knowledgeRows = parseKnowledgeRows(knowledgeMdContent(basePath));
     const knowledgeByTable = { rules: 0, patterns: 0, lessons: 0 };
     const knowledgeSamples = [];
     let knowledgeMigrated = 0;
     for (const row of knowledgeRows) {
         knowledgeByTable[row.table] += 1;
-        // Phase 6 will introduce a `sourceKnowledgeId` marker as part of the
-        // KNOWLEDGE.md backfill. Until that path ships, this check returns
-        // false for every row, which is the honest state of the consolidation.
-        if (memoryHasSourceMarker("sourceKnowledgeId", row.id)) {
+        // KNOWLEDGE.md backfill writes `sourceKnowledgeId`; rows without that
+        // marker are still reported as consolidation gaps.
+        if (memorySourceMarkers.knowledgeIds.has(row.id)) {
             knowledgeMigrated += 1;
             continue;
         }

package/dist/resources/extensions/gsd/milestone-implementation-evidence.js

@@ -10,6 +10,8 @@ import { logWarning } from "./workflow-logger.js";
 import { resolveTasksDir } from "./paths.js";
 /** Large enough for unbounded milestone-history git log scans in big repos. */
 const GIT_LOG_MAX_BUFFER = 16 * 1024 * 1024;
+const LOG_FIELD_SEPARATOR = "\x1f";
+const LOG_RECORD_SEPARATOR = "\x1e";
 /**
  * Check whether a milestone produced implementation artifacts (non-`.gsd/`
  * files) in git history. The primary signal is the branch diff against the
@@ -179,7 +181,7 @@ function getChangedFilesFromMilestoneTaggedCommits(basePath, milestoneId) {
     // Primary: path-scoped log against .gsd/milestones/<id>. Fast and unbounded
     // by depth when .gsd/ is tracked in git.
     const scoped = scanGsdTaggedCommits(basePath, milestoneId, [
-        "log", "--format=%H%x1f%B%x1e", "HEAD", "--", `.gsd/milestones/${milestoneId}`,
+        "log", "--full-diff", "--name-only", "--format=%x1e%H%x1f%B%x1f", "HEAD", "--", `.gsd/milestones/${milestoneId}`,
     ]);
     if (!scoped.ok)
         return scoped;
@@ -195,7 +197,7 @@ function getChangedFilesFromMilestoneTaggedCommits(basePath, milestoneId) {
     // reintroducing the rolling-depth failure class removed in #4699 where
     // milestone evidence aged out behind unrelated activity.
     const unscoped = scanGsdTaggedCommits(basePath, milestoneId, [
-        "log", "--format=%H%x1f%B%x1e", "HEAD",
+        "log", "--name-only", "--format=%x1e%H%x1f%B%x1f", "HEAD",
     ]);
     if (!unscoped.ok)
         return scoped.matched ? scoped : unscoped;
@@ -280,8 +282,7 @@ function backfillChangedFilesFromUntaggedMilestoneCommits(basePath, milestoneId)
                 continue;
             if (commitMessageHasGsdTrailer(record.message))
                 continue;
-            const commitFiles = getChangedFilesForCommit(basePath, record.hash);
-            const implementationFiles = commitFiles.map(normalizeRepoPath).filter(isImplementationPath);
+            const implementationFiles = record.files.map(normalizeRepoPath).filter(isImplementationPath);
             if (implementationFiles.length === 0)
                 continue;
             if (!implementationFiles.some((file) => hintSet.has(file)))
@@ -306,24 +307,28 @@ function backfillChangedFilesFromUntaggedMilestoneCommits(basePath, milestoneId)
     }
 }
 function getCommitRecords(basePath) {
-    const logOutput = execFileSync("git", ["log", "--format=%H%x1f%P%x1f%cI%x1f%B%x1e", "HEAD"], {
+    const logOutput = execFileSync("git", ["log", "--name-only", "--format=%x1e%H%x1f%P%x1f%cI%x1f%B%x1f", "HEAD"], {
         cwd: basePath,
         stdio: ["ignore", "pipe", "pipe"],
         encoding: "utf-8",
         maxBuffer: GIT_LOG_MAX_BUFFER,
     });
     return logOutput
-        .split("\x1e")
-        .map((record) => record.trim())
+        .split(LOG_RECORD_SEPARATOR)
         .filter(Boolean)
         .flatMap((record) => {
-        const parts = record.split("\x1f");
-        if (parts.length < 4)
+        const parts = record.split(LOG_FIELD_SEPARATOR);
+        if (parts.length < 5)
             return [];
-        const [hash, parents, committedAt, ...messageParts] = parts;
-        return [{ hash: hash.trim(), parents: parents.trim(), committedAt: committedAt.trim(), message: messageParts.join("\x1f") }];
+        const [hash, parents, committedAt] = parts;
+        const files = parseNameOnlyFiles(parts.at(-1) ?? "");
+        const message = parts.slice(3, -1).join(LOG_FIELD_SEPARATOR);
+        return [{ hash: hash.trim(), parents: parents.trim(), committedAt: committedAt.trim(), message, files }];
     });
 }
+function parseNameOnlyFiles(rawFiles) {
+    return rawFiles.split(/\r?\n/).map((file) => file.trim()).filter(Boolean);
+}
 function isFullCommitSha(value) {
     return /^[0-9a-f]{40}$/i.test(value);
 }
@@ -336,23 +341,24 @@ function scanGsdTaggedCommits(basePath, milestoneId, gitArgs) {
             maxBuffer: GIT_LOG_MAX_BUFFER,
         });
         const records = logOutput
-            .split("\x1e")
-            .map((record) => record.trim())
+            .split(LOG_RECORD_SEPARATOR)
             .filter(Boolean)
             .flatMap((record) => {
-            const sep = record.indexOf("\x1f");
-            if (sep === -1)
+            const parts = record.split(LOG_FIELD_SEPARATOR);
+            if (parts.length < 3)
+                return [];
+            const hash = parts[0].trim();
+            if (!hash)
                 return [];
-            const hash = record.slice(0, sep).trim();
-            const message = record.slice(sep + 1);
-            return [{ hash, message }];
+            const files = parseNameOnlyFiles(parts.at(-1) ?? "");
+            const message = parts.slice(1, -1).join(LOG_FIELD_SEPARATOR);
+            return [{ message, files }];
         });
         const files = new Set();
         let matched = false;
-        for (const { hash, message } of records) {
+        for (const { message, files: commitFiles } of records) {
             if (!commitMessageHasGsdTrailer(message))
                 continue;
-            const commitFiles = getChangedFilesForCommit(basePath, hash);
             if (!commitMatchesMilestone(basePath, message, milestoneId, commitFiles))
                 continue;
             matched = true;

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

@@ -8,8 +8,8 @@
  * Quick tasks live in `.gsd/quick/` and are tracked in STATE.md's
  * "Quick Tasks Completed" table.
  */
-import { existsSync, mkdirSync, readFileSync, readdirSync, realpathSync, rmSync, writeFileSync } from "node:fs";
-import { isAbsolute, join, relative } from "node:path";
+import { existsSync, lstatSync, mkdirSync, readFileSync, readdirSync, realpathSync, rmSync, writeFileSync } from "node:fs";
+import { isAbsolute, join, relative, resolve } from "node:path";
 import { QUICK_BRANCH_RE } from "./branch-patterns.js";
 import { loadPrompt } from "./prompt-loader.js";
 import { gsdRoot } from "./paths.js";
@@ -19,6 +19,7 @@ import { nativeBranchExists, nativeDetectMainBranch, nativeDiffNumstat } from ".
 import { nativeHasStagedChanges } from "./native-git-bridge.js";
 import { resolveUokFlags } from "./uok/flags.js";
 let pendingQuickReturn = null;
+const pendingQuickReturnMisses = new Map();
 // ─── Quick Task Helpers ───────────────────────────────────────────────────────
 /**
  * Generate a URL-friendly slug from a description.
@@ -169,11 +170,36 @@ export function buildQuickCommitInstruction(basePath, root) {
         "   - Quick tasks run outside the auto-mode lifecycle — there is no system auto-commit, so commit directly here.",
     ].join("\n");
 }
+function readHeadBranchName(basePath) {
+    try {
+        const gitPath = join(basePath, ".git");
+        if (!existsSync(gitPath))
+            return null;
+        let headPath;
+        if (lstatSync(gitPath).isDirectory()) {
+            headPath = join(gitPath, "HEAD");
+        }
+        else {
+            const gitFile = readFileSync(gitPath, "utf-8").trim();
+            if (!gitFile.startsWith("gitdir: "))
+                return null;
+            headPath = join(resolve(basePath, gitFile.slice("gitdir: ".length)), "HEAD");
+        }
+        const head = readFileSync(headPath, "utf-8").trim();
+        if (!head.startsWith("ref: refs/heads/"))
+            return null;
+        return head.slice("ref: refs/heads/".length);
+    }
+    catch {
+        return null;
+    }
+}
 function quickReturnStatePath(basePath) {
     return join(gsdRoot(basePath), "runtime", "quick-return.json");
 }
 function persistPendingReturn(state) {
     pendingQuickReturn = state;
+    pendingQuickReturnMisses.delete(state.basePath);
     mkdirSync(join(gsdRoot(state.basePath), "runtime"), { recursive: true });
     writeFileSync(quickReturnStatePath(state.basePath), JSON.stringify(state) + "\n", "utf-8");
 }
@@ -181,6 +207,13 @@ function readPendingReturn(basePath) {
     if (pendingQuickReturn && pendingQuickReturn.basePath === basePath) {
         return pendingQuickReturn;
     }
+    if (pendingQuickReturnMisses.has(basePath)) {
+        const statePath = quickReturnStatePath(basePath);
+        if (!existsSync(statePath) && readHeadBranchName(basePath) === pendingQuickReturnMisses.get(basePath)) {
+            return null;
+        }
+        pendingQuickReturnMisses.delete(basePath);
+    }
     try {
         const raw = readFileSync(quickReturnStatePath(basePath), "utf-8");
         const parsed = JSON.parse(raw);
@@ -191,6 +224,7 @@ function readPendingReturn(basePath) {
             && typeof parsed.slug === "string"
             && typeof parsed.description === "string") {
             pendingQuickReturn = parsed;
+            pendingQuickReturnMisses.delete(basePath);
             return pendingQuickReturn;
         }
     }
@@ -200,14 +234,23 @@ function readPendingReturn(basePath) {
     const inferred = inferQuickReturnFromBranch(basePath);
     if (inferred) {
         pendingQuickReturn = inferred;
+        pendingQuickReturnMisses.delete(basePath);
         return inferred;
     }
+    const branchAtMiss = readHeadBranchName(basePath);
+    if (branchAtMiss) {
+        pendingQuickReturnMisses.set(basePath, branchAtMiss);
+    }
     return null;
 }
 function clearPendingReturn(basePath) {
     if (pendingQuickReturn?.basePath === basePath) {
         pendingQuickReturn = null;
     }
+    const branchAtMiss = readHeadBranchName(basePath);
+    if (branchAtMiss) {
+        pendingQuickReturnMisses.set(basePath, branchAtMiss);
+    }
     rmSync(quickReturnStatePath(basePath), { force: true });
 }
 function hasStagedChanges(basePath) {

package/dist/resources/extensions/gsd/session-forensics.js

@@ -176,11 +176,21 @@ export function extractTrace(entries) {
     }
     // Flush any pending tool calls that never got results (crash mid-tool)
     for (const [, pending] of pendingTools) {
+        const missingResultError = `Tool call ${pending.name} started but no toolResult was recorded`;
         toolCalls.push({
             name: pending.name,
             input: redactInput(pending.name, pending.input),
-            isError: false,
+            result: "missing tool result (stream/tool-call abort before execution)",
+            isError: true,
         });
+        errors.push(missingResultError);
+        // Mark the matching commandsRun entry as failed so it is consistent with
+        // the isError: true on the tool call above (bash/bg_shell only).
+        if (pending.name === "bash" || pending.name === "bg_shell") {
+            const lastCmd = findLast(commandsRun, c => c.command === String(pending.input.command));
+            if (lastCmd)
+                lastCmd.failed = true;
+        }
     }
     return {
         toolCalls,

package/dist/resources/extensions/gsd/state-reconciliation/drift/stale-render.js

@@ -5,9 +5,12 @@
 // the detect+repair composition moves here. The previous repairStaleRenders
 // had zero callers in production code — wiring it through
 // reconcileBeforeDispatch closes that gap.
+import { existsSync } from "node:fs";
+import { join } from "node:path";
 import { detectStaleRenders, renderPlanCheckboxes, renderRoadmapFromDb, renderSliceSummary, renderTaskSummary, } from "../../markdown-renderer.js";
-import { getMilestone, getMilestoneSlices, getSlice, getSliceTasks, setSliceSummaryMd } from "../../gsd-db.js";
-import { resolveSliceFile } from "../../paths.js";
+import { getMilestone, getMilestoneSlices, getSlice, getSliceTasks, isDbAvailable, setSliceSummaryMd, } from "../../gsd-db.js";
+import { getWorkflowDatabasePath, openWorkflowDatabasePath, refreshWorkflowDatabaseFromDisk, } from "../../db-workspace.js";
+import { gsdRoot, resolveSliceFile } from "../../paths.js";
 import { logWarning } from "../../workflow-logger.js";
 // ─── Core (basePath-only — usable by both drift API and legacy wrapper) ──────
 function detectStaleRenderDriftFromBasePath(basePath) {
@@ -82,7 +85,42 @@ function resolveRoadmapMilestoneIdFromPath(normPath) {
     }
     return fileMatch?.[1] ?? milestoneMatch[1];
 }
+function expectedDbPathForStaleRenderRepair(basePath) {
+    return join(gsdRoot(basePath), "gsd.db");
+}
+function ensureDbForStaleRenderRepair(basePath) {
+    const dbPath = expectedDbPathForStaleRenderRepair(basePath);
+    if (isDbAvailable() && getWorkflowDatabasePath() === dbPath)
+        return true;
+    if (!existsSync(dbPath))
+        return false;
+    try {
+        return openWorkflowDatabasePath(dbPath);
+    }
+    catch (err) {
+        logWarning("reconcile", `stale-render repair could not reopen DB: ${err.message}`);
+        return false;
+    }
+}
+function retryDbForStaleRenderRepair(basePath) {
+    const dbPath = expectedDbPathForStaleRenderRepair(basePath);
+    if (!existsSync(dbPath))
+        return false;
+    try {
+        if (isDbAvailable() && getWorkflowDatabasePath() === dbPath && refreshWorkflowDatabaseFromDisk()) {
+            return true;
+        }
+        return openWorkflowDatabasePath(dbPath);
+    }
+    catch (err) {
+        logWarning("reconcile", `stale-render repair could not reopen DB: ${err.message}`);
+        return false;
+    }
+}
 async function repairStaleRenderFromBasePath(record, basePath) {
+    if (!ensureDbForStaleRenderRepair(basePath)) {
+        throw new Error(`stale-render drift: database unavailable for repair (${basePath})`);
+    }
     const normPath = record.renderPath.replace(/\\/g, "/");
     const reason = record.reason;
     if (reason.includes("in roadmap")) {
@@ -101,7 +139,18 @@ async function repairStaleRenderFromBasePath(record, basePath) {
         const sliceId = pathMatch[2] && pathMatch[3] && /^\d+$/.test(pathMatch[2])
             ? `S${String(parseInt(pathMatch[3], 10)).padStart(2, "0")}`
             : pathMatch[2];
-        const wrote = await renderPlanCheckboxes(basePath, milestoneId, sliceId, record.renderPath);
+        let wrote = false;
+        try {
+            wrote = await renderPlanCheckboxes(basePath, milestoneId, sliceId, record.renderPath);
+        }
+        catch (err) {
+            if (!retryDbForStaleRenderRepair(basePath))
+                throw err;
+            wrote = await renderPlanCheckboxes(basePath, milestoneId, sliceId, record.renderPath);
+        }
+        if (!wrote && retryDbForStaleRenderRepair(basePath)) {
+            wrote = await renderPlanCheckboxes(basePath, milestoneId, sliceId, record.renderPath);
+        }
         if (!wrote) {
             throw new Error(`stale-render drift: plan re-render wrote nothing for ${milestoneId}/${pathMatch[2]} ` +
                 `(${record.renderPath}); slice has no tasks or its path is unresolvable`);

package/dist/resources/extensions/gsd/tools/complete-slice.js

@@ -21,7 +21,7 @@ import { classifyUatContent, escalatesArtifactUatToBrowser } from "../uat-policy
 import { invalidateStateCache } from "../state.js";
 import { renderRoadmapFromDb, roadmapRenderMarksSliceDone } from "../markdown-renderer.js";
 import { isStaleWrite } from "../auto/turn-epoch.js";
-import { flushWorkflowProjections } from "../projection-flush.js";
+import { renderStateProjection, renderTopLevelQueueFromDb, renderTopLevelRoadmapFromDb } from "../workflow-projections.js";
 import { writeManifest } from "../workflow-manifest.js";
 import { appendEvent } from "../workflow-events.js";
 import { logWarning, logError } from "../workflow-logger.js";
@@ -457,11 +457,42 @@ export async function handleCompleteSlice(params, basePath) {
     // ── Post-mutation hook: projections, manifest, event log ───────────────
     // Separate try/catch per step so a projection failure doesn't prevent
     // the event log entry (critical for worktree reconciliation).
+    //
+    // If the primary summary/UAT/roadmap write block failed (projectionStale),
+    // retry the milestone-level roadmap here so ROADMAP.md is not left stale
+    // after a committed slice completion. This restores the recovery that the
+    // removed flushWorkflowProjections/renderAllProjections provided.
+    if (projectionStale) {
+        try {
+            await renderRoadmapFromDb(artifactBasePath, params.milestoneId);
+        }
+        catch (projErr) {
+            logWarning("tool", `complete-slice milestone roadmap retry warning for ${params.milestoneId}/${params.sliceId}: ${projErr.message}`);
+        }
+    }
+    try {
+        await renderRoadmapFromDb(artifactBasePath, params.milestoneId);
+    }
+    catch (projErr) {
+        logWarning("tool", `complete-slice milestone roadmap projection warning for ${params.milestoneId}/${params.sliceId}: ${projErr.message}`);
+    }
+    try {
+        renderTopLevelRoadmapFromDb(artifactBasePath);
+    }
+    catch (projErr) {
+        logWarning("tool", `complete-slice roadmap projection warning for ${params.milestoneId}/${params.sliceId}: ${projErr.message}`);
+    }
+    try {
+        renderTopLevelQueueFromDb(artifactBasePath);
+    }
+    catch (projErr) {
+        logWarning("tool", `complete-slice queue projection warning for ${params.milestoneId}/${params.sliceId}: ${projErr.message}`);
+    }
     try {
-        await flushWorkflowProjections(artifactBasePath, { milestoneId: params.milestoneId });
+        await renderStateProjection(artifactBasePath);
     }
     catch (projErr) {
-        logWarning("tool", `complete-slice projection warning for ${params.milestoneId}/${params.sliceId}: ${projErr.message}`);
+        logWarning("tool", `complete-slice state projection warning for ${params.milestoneId}/${params.sliceId}: ${projErr.message}`);
     }
     try {
         writeManifest(artifactBasePath);

package/dist/resources/extensions/gsd/tools/complete-task.js

@@ -5,22 +5,23 @@
  *
  * Validates inputs, writes task row and rendered SUMMARY.md to DB in a
  * transaction, then renders projections to disk and invalidates caches.
- * Projection write failures are reported as stale projections and do not roll
- * back committed DB state.
+ * If the critical task summary / plan projection write fails, the DB
+ * completion is compensated back to pending so DB state does not drift ahead
+ * of PLAN.md.
  */
-import { existsSync } from "node:fs";
+import { existsSync, unlinkSync } from "node:fs";
 import { join } from "node:path";
 import { isClosedStatus } from "../status-guards.js";
-import { transaction, insertMilestone, insertSlice, insertTask, insertVerificationEvidence, getMilestone, getSlice, getTask, updateTaskStatus, deleteVerificationEvidence, saveGateResult, getPendingGatesForTurn, } from "../gsd-db.js";
+import { transaction, insertMilestone, insertSlice, insertTask, insertVerificationEvidence, getMilestone, getSlice, getTask, updateTaskStatus, deleteVerificationEvidence, saveGateResult, getPendingGatesForTurn, isDbAvailable, } from "../gsd-db.js";
+import { getWorkflowDatabasePath, openWorkflowDatabasePath } from "../db-workspace.js";
 import { getGatesForTurn } from "../gate-registry.js";
 import { gsdProjectionRoot, clearPathCache, resolveMilestonePath, resolveSlicePath } from "../paths.js";
 import { resolveCanonicalMilestoneRoot } from "../worktree-manager.js";
 import { checkOwnership, taskUnitKey } from "../unit-ownership.js";
 import { saveFile, clearParseCache } from "../files.js";
 import { invalidateStateCache } from "../state.js";
-import { renderPlanCheckboxes } from "../markdown-renderer.js";
-import { renderSummaryContent } from "../workflow-projections.js";
-import { flushWorkflowProjections } from "../projection-flush.js";
+import { renderPlanCheckboxes, renderRoadmapFromDb } from "../markdown-renderer.js";
+import { renderStateProjection, renderSummaryContent, renderTopLevelQueueFromDb, renderTopLevelRoadmapFromDb, } from "../workflow-projections.js";
 import { writeManifest } from "../workflow-manifest.js";
 import { appendEvent } from "../workflow-events.js";
 import { logWarning, logError } from "../workflow-logger.js";
@@ -44,6 +45,39 @@ function taskSummaryPath(basePath, milestoneId, sliceId, taskId) {
     // Fallback: legacy hardcoded path (milestone/slice dir not on disk yet)
     return join(gsdProjectionRoot(basePath), "milestones", milestoneId, "slices", sliceId, "tasks", `${taskId}-SUMMARY.md`);
 }
+async function renderCompleteTaskProjections(basePath, milestoneId) {
+    try {
+        await renderRoadmapFromDb(basePath, milestoneId);
+    }
+    catch (err) {
+        logWarning("projection", `renderRoadmapFromDb failed for ${milestoneId}: ${err.message}`);
+    }
+    try {
+        renderTopLevelRoadmapFromDb(basePath);
+    }
+    catch (err) {
+        logWarning("projection", `renderTopLevelRoadmapFromDb failed: ${err.message}`);
+    }
+    try {
+        renderTopLevelQueueFromDb(basePath);
+    }
+    catch (err) {
+        logWarning("projection", `renderTopLevelQueueFromDb failed: ${err.message}`);
+    }
+    try {
+        await renderStateProjection(basePath);
+    }
+    catch (err) {
+        logWarning("projection", `renderStateProjection failed: ${err.message}`);
+    }
+}
+function ensureCompleteTaskDbOpen(dbPath) {
+    if (!dbPath || dbPath === ":memory:")
+        return isDbAvailable();
+    if (isDbAvailable() && getWorkflowDatabasePath() === dbPath)
+        return true;
+    return openWorkflowDatabasePath(dbPath);
+}
 async function repairMissingTaskSummaryProjection(artifactBasePath, taskRow) {
     const summaryPath = taskSummaryPath(artifactBasePath, taskRow.milestone_id, taskRow.slice_id, taskRow.id);
     const summaryMd = renderSummaryContent(taskRow, taskRow.slice_id, taskRow.milestone_id, []);
@@ -60,7 +94,7 @@ async function repairMissingTaskSummaryProjection(artifactBasePath, taskRow) {
     clearPathCache();
     clearParseCache();
     try {
-        await flushWorkflowProjections(artifactBasePath, { milestoneId: taskRow.milestone_id });
+        await renderCompleteTaskProjections(artifactBasePath, taskRow.milestone_id);
     }
     catch (projErr) {
         logWarning("tool", `complete-task repair projection warning: ${projErr.message}`);
@@ -181,6 +215,7 @@ export async function handleCompleteTask(params, basePath) {
     let guardError = null;
     let summaryMd = "";
     let repairTaskSummaryRow = null;
+    const rollbackDbPath = getWorkflowDatabasePath();
     // ── ADR-011 Phase 2: validate escalation payload BEFORE any side effects ─
     // Building the artifact runs the full shape validation (2-4 options, unique
     // ids, recommendation references a real id). If the payload is malformed
@@ -317,20 +352,48 @@ export async function handleCompleteTask(params, basePath) {
     if (guardError) {
         return { error: guardError };
     }
-    let projectionStale = false;
     // Resolve and write summary to disk
     const summaryPath = taskSummaryPath(artifactBasePath, params.milestoneId, params.sliceId, params.taskId);
     try {
         await saveFile(summaryPath, summaryMd);
         // Toggle or regenerate the plan projection from DB. Missing projection
         // files are rebuilt by the renderer instead of being skipped.
-        await renderPlanCheckboxes(artifactBasePath, params.milestoneId, params.sliceId);
+        if (!ensureCompleteTaskDbOpen(rollbackDbPath)) {
+            throw new Error(`database unavailable before plan projection render for ${params.milestoneId}/${params.sliceId}`);
+        }
+        const wrotePlan = await renderPlanCheckboxes(artifactBasePath, params.milestoneId, params.sliceId);
+        if (!wrotePlan) {
+            throw new Error(`plan projection write returned false for ${params.milestoneId}/${params.sliceId}`);
+        }
     }
     catch (renderErr) {
-        projectionStale = true;
-        logWarning("projection", `complete_task projection write failed for ${params.milestoneId}/${params.sliceId}/${params.taskId}; DB completion remains committed`, {
-            error: renderErr.message,
-        });
+        logWarning("projection", `complete_task projection write failed for ${params.milestoneId}/${params.sliceId}/${params.taskId}`, { error: renderErr.message });
+        let rollbackSucceeded = false;
+        try {
+            ensureCompleteTaskDbOpen(rollbackDbPath);
+            deleteVerificationEvidence(params.milestoneId, params.sliceId, params.taskId);
+            updateTaskStatus(params.milestoneId, params.sliceId, params.taskId, "pending");
+            invalidateStateCache();
+            rollbackSucceeded = true;
+        }
+        catch (rollbackErr) {
+            logWarning("projection", `complete_task rollback failed after projection write failure for ${params.milestoneId}/${params.sliceId}/${params.taskId}: ${rollbackErr.message}`);
+        }
+        try {
+            if (existsSync(summaryPath))
+                unlinkSync(summaryPath);
+        }
+        catch (summaryErr) {
+            logWarning("projection", `complete_task could not remove SUMMARY.md after projection write failure for ${params.milestoneId}/${params.sliceId}/${params.taskId}: ${summaryErr.message}`);
+        }
+        // Clear path/parse caches regardless of rollback outcome so stale
+        // entries from the failed write attempt don't leak into subsequent calls.
+        clearPathCache();
+        clearParseCache();
+        const returnMsg = rollbackSucceeded
+            ? `complete_task projection write failed for ${params.milestoneId}/${params.sliceId}/${params.taskId}; rolled completion back to pending`
+            : `complete_task projection write failed for ${params.milestoneId}/${params.sliceId}/${params.taskId}; rollback also failed — task may remain complete with stale plan`;
+        return { error: returnMsg };
     }
     // ── Close gates owned by execute-task (Q5/Q6/Q7) for this task ────────
     // Each gate id maps to a specific params field via taskGateFieldForId.
@@ -435,7 +498,7 @@ export async function handleCompleteTask(params, basePath) {
     // Separate try/catch per step so a projection failure doesn't prevent
     // the event log entry (critical for worktree reconciliation).
     try {
-        await flushWorkflowProjections(artifactBasePath, { milestoneId: params.milestoneId });
+        await renderCompleteTaskProjections(artifactBasePath, params.milestoneId);
     }
     catch (projErr) {
         logWarning("tool", `complete-task projection warning: ${projErr.message}`);
@@ -465,6 +528,5 @@ export async function handleCompleteTask(params, basePath) {
         milestoneId: params.milestoneId,
         summaryPath,
         ...(escalationMetadata ? { escalation: escalationMetadata } : {}),
-        ...(projectionStale ? { stale: true } : {}),
     };
 }

package/dist/resources/extensions/gsd/tools/exec-tool.js

@@ -144,7 +144,7 @@ export async function executeGsdExec(params, deps) {
     if (bashReferencesProjectRootOutsideWorktree(script, deps.baseDir)) {
         return paramError("script references the original project root while running inside a milestone worktree; use the active worktree path or relative paths");
     }
-    const opts = buildExecOptions(deps.baseDir, deps.preferences?.context_mode, { env: deps.env, now: deps.now, generateId: deps.generateId });
+    const opts = buildExecOptions(deps.baseDir, deps.preferences?.context_mode, { env: deps.env, now: deps.now, generateId: deps.generateId, signal: deps.signal });
     const run = deps.run ?? runExecSandbox;
     try {
         const result = await run({
@@ -235,6 +235,7 @@ function formatResult(result) {
             exit_code: result.exit_code,
             signal: result.signal,
             timed_out: result.timed_out,
+            aborted: result.aborted === true,
             force_resolved: result.force_resolved,
             duration_ms: result.duration_ms,
             stdout_bytes: result.stdout_bytes,
@@ -245,12 +246,16 @@ function formatResult(result) {
             stderr_path: result.stderr_path,
             meta_path: result.meta_path,
         },
-        isError: result.timed_out || result.signal !== null || result.exit_code !== 0,
+        isError: result.aborted === true || result.timed_out || result.signal !== null || result.exit_code !== 0,
     };
 }
 function formatExit(result) {
     // force_resolved means a non-closing (D-state) child was force-resolved past its
     // hard deadline rather than observed exiting; distinguish it from a clean timeout.
+    if (result.aborted && result.force_resolved)
+        return "aborted(force-killed)";
+    if (result.aborted)
+        return "aborted";
     if (result.force_resolved)
         return "timeout(force-killed)";
     if (result.timed_out)