@opengsd/gsd-pi 1.8.1 → 1.9.0

package/dist/resources/extensions/gsd/migrate/presentation.js

@@ -0,0 +1,64 @@
+// gsd-pi - /gsd migrate presentation helpers.
+// File Purpose: Pure formatting for migration previews and post-write review prompts.
+import { existsSync, readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { gsdRoot } from "../paths.js";
+function formatRequirements(preview) {
+    if (preview.requirements.total === 0)
+        return null;
+    return `Requirements: ${preview.requirements.total} (${preview.requirements.validated} validated, ${preview.requirements.active} active, ${preview.requirements.deferred} deferred, ${preview.requirements.outOfScope} out of scope)`;
+}
+function formatLegacyInputs(preview) {
+    if (!preview.migrationInputs)
+        return null;
+    return `Legacy inputs: ${preview.migrationInputs.milestonePhaseDirs} milestone phase dir(s), ${preview.migrationInputs.decisions} decision file(s), ${preview.migrationInputs.seeds} seed file(s)`;
+}
+export function buildMigrationPreviewSummary(preview, targetRoot) {
+    const lines = [
+        `Decisions: ${preview.decisions.total}`,
+        `Milestones: ${preview.milestoneCount}`,
+        `Slices: ${preview.totalSlices} (${preview.doneSlices} done — ${preview.sliceCompletionPct}%)`,
+        `Tasks: ${preview.totalTasks} (${preview.doneTasks} done — ${preview.taskCompletionPct}%)`,
+    ];
+    const requirements = formatRequirements(preview);
+    if (requirements)
+        lines.push(requirements);
+    const legacyInputs = formatLegacyInputs(preview);
+    if (legacyInputs)
+        lines.push(legacyInputs);
+    const targetGsdPath = gsdRoot(targetRoot);
+    if (existsSync(targetGsdPath)) {
+        lines.push("");
+        lines.push(`⚠ A .gsd directory already exists at ${targetGsdPath}.`);
+        lines.push("It will be backed up, deleted, and rewritten fresh before DB import.");
+    }
+    return lines;
+}
+export function formatMigrationPreviewStats(preview) {
+    const lines = [
+        `- Decisions: ${preview.decisions.total}`,
+        `- Milestones: ${preview.milestoneCount}`,
+        `- Slices: ${preview.totalSlices} (${preview.doneSlices} done — ${preview.sliceCompletionPct}%)`,
+        `- Tasks: ${preview.totalTasks} (${preview.doneTasks} done — ${preview.taskCompletionPct}%)`,
+    ];
+    const requirements = formatRequirements(preview);
+    if (requirements)
+        lines.push(`- ${requirements}`);
+    const legacyInputs = formatLegacyInputs(preview);
+    if (legacyInputs)
+        lines.push(`- ${legacyInputs}`);
+    return lines.join("\n");
+}
+function defaultReviewTemplatePath() {
+    const promptsDir = join(dirname(fileURLToPath(import.meta.url)), "..", "prompts");
+    return join(promptsDir, "review-migration.md");
+}
+export function buildReviewPrompt(input) {
+    const templatePath = input.templatePath ?? defaultReviewTemplatePath();
+    let content = readFileSync(templatePath, "utf-8");
+    content = content.replaceAll("{{sourcePath}}", input.sourcePath);
+    content = content.replaceAll("{{gsdPath}}", input.gsdPath);
+    content = content.replaceAll("{{previewStats}}", formatMigrationPreviewStats(input.preview));
+    return content.trim();
+}

package/dist/resources/extensions/gsd/parallel-eligibility.js

@@ -6,7 +6,7 @@
  */
 import { deriveState } from "./state.js";
 import { findMilestoneIds } from "./guided-flow.js";
-import { isDbAvailable, getMilestoneSlices, getSliceTasks } from "./gsd-db.js";
+import { isDbAvailable, getMilestoneSlices, getTasksBySliceIds } from "./gsd-db.js";
 import { openExistingWorkflowDatabase } from "./db-workspace.js";
 // ─── File Collection ─────────────────────────────────────────────────────────
 /**
@@ -16,10 +16,11 @@ import { openExistingWorkflowDatabase } from "./db-workspace.js";
 async function collectTouchedFiles(basePath, milestoneId) {
     const files = new Set();
     if (isDbAvailable()) {
-        // DB path: query slices and their tasks for file lists
+        // DB path: query slices and their tasks for file lists (one batched task
+        // query instead of one per slice; file order is irrelevant here — Set dedup)
         const slices = getMilestoneSlices(milestoneId);
-        for (const slice of slices) {
-            const tasks = getSliceTasks(milestoneId, slice.id);
+        const tasksBySlice = getTasksBySliceIds(slices.map((slice) => ({ milestoneId, sliceId: slice.id })));
+        for (const tasks of tasksBySlice.values()) {
             for (const task of tasks) {
                 if (Array.isArray(task.files)) {
                     for (const f of task.files) {

package/dist/resources/extensions/gsd/parallel-monitor-overlay.js

@@ -75,15 +75,18 @@ function discoverWorkers(basePath) {
     }
     return [...mids].sort();
 }
-function querySliceProgress(basePath, mid, workRoot = worktreePathFor(basePath, mid)) {
+// Slice progress + recent completions share one DB connection per worker per
+// tick. Opening the isolated worker DB twice per refresh (once for each) was
+// pure churn on the 5s interval.
+function queryWorkerProgress(basePath, mid, workRoot = worktreePathFor(basePath, mid)) {
     const dbPath = resolveGsdPathContract(workRoot, basePath).projectDb;
     if (!existsSync(dbPath))
-        return [];
+        return { slices: [], completions: [] };
     const db = openWorkflowDatabaseIsolated(dbPath);
     if (!db)
-        return [];
+        return { slices: [], completions: [] };
     try {
-        const rows = db.prepare(`SELECT
+        const sliceRows = db.prepare(`SELECT
          s.id AS id,
          s.status AS status,
          COUNT(t.id) AS total,
@@ -93,15 +96,29 @@ function querySliceProgress(basePath, mid, workRoot = worktreePathFor(basePath,
        WHERE s.milestone_id=:mid
        GROUP BY s.id
        ORDER BY s.id`).all({ ":mid": mid });
-        return rows.map((row) => ({
+        const slices = sliceRows.map((row) => ({
             id: String(row["id"] ?? ""),
             status: String(row["status"] ?? ""),
             total: Number(row["total"] ?? 0),
             done: Number(row["done"] ?? 0),
         }));
+        const completionRows = db.prepare(`SELECT id, slice_id, one_liner
+       FROM tasks
+       WHERE milestone_id=:mid
+         AND status='complete'
+         AND completed_at IS NOT NULL
+       ORDER BY completed_at DESC
+       LIMIT 5`).all({ ":mid": mid });
+        const completions = completionRows.map((row) => {
+            const taskId = String(row["id"] ?? "");
+            const sliceId = String(row["slice_id"] ?? "");
+            const oneLiner = String(row["one_liner"] ?? "");
+            return `✓ ${mid}/${sliceId}/${taskId}${oneLiner ? ": " + oneLiner : ""}`;
+        });
+        return { slices, completions };
     }
     catch {
-        return [];
+        return { slices: [], completions: [] };
     }
     finally {
         try {
@@ -200,39 +217,6 @@ function extractCostFromNdjson(basePath, mid) {
         return ndjsonCostCache.get(stdoutPath)?.total ?? 0;
     }
 }
-function queryRecentCompletions(basePath, mid) {
-    const workRoot = worktreePathFor(basePath, mid);
-    const dbPath = resolveGsdPathContract(workRoot, basePath).projectDb;
-    if (!existsSync(dbPath))
-        return [];
-    const db = openWorkflowDatabaseIsolated(dbPath);
-    if (!db)
-        return [];
-    try {
-        const rows = db.prepare(`SELECT id, slice_id, one_liner
-       FROM tasks
-       WHERE milestone_id=:mid
-         AND status='complete'
-         AND completed_at IS NOT NULL
-       ORDER BY completed_at DESC
-       LIMIT 5`).all({ ":mid": mid });
-        return rows.map((row) => {
-            const taskId = String(row["id"] ?? "");
-            const sliceId = String(row["slice_id"] ?? "");
-            const oneLiner = String(row["one_liner"] ?? "");
-            return `✓ ${mid}/${sliceId}/${taskId}${oneLiner ? ": " + oneLiner : ""}`;
-        });
-    }
-    catch {
-        return [];
-    }
-    finally {
-        try {
-            db.close();
-        }
-        catch { /* ignore */ }
-    }
-}
 function collectWorkerData(basePath) {
     const mids = discoverWorkers(basePath);
     const parallelDir = join(basePath, ".gsd", "parallel");
@@ -243,7 +227,7 @@ function collectWorkerData(basePath) {
         const workRoot = worktreePathFor(basePath, mid);
         const status = readJsonSafe(join(parallelDir, `${mid}.status.json`));
         const lock = readJsonSafe(join(workRoot, ".gsd", "auto.lock"));
-        const slices = querySliceProgress(basePath, mid, workRoot);
+        const { slices, completions } = queryWorkerProgress(basePath, mid, workRoot);
         const pid = lock?.pid || status?.pid || 0;
         const alive = pid ? isPidAlive(pid) : false;
         // Heartbeat: prefer status.json if PID matches, else use file mtime
@@ -303,6 +287,7 @@ function collectWorkerData(basePath) {
             totalSlices: slices.length,
             doneSlices,
             slices,
+            completions,
             errors,
         });
     }
@@ -355,10 +340,10 @@ export class ParallelMonitorOverlay {
         if (this.disposed)
             return;
         this.workers = collectWorkerData(this.basePath);
-        // Collect completion events
+        // Collect completion events (already read during collectWorkerData's single
+        // DB open per worker — no second connection here).
         for (const wk of this.workers) {
-            const completions = queryRecentCompletions(this.basePath, wk.mid);
-            for (const evt of completions) {
+            for (const evt of wk.completions) {
                 if (!this.events.includes(evt))
                     this.events.push(evt);
             }

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

@@ -585,19 +585,22 @@ function legacyMilestonesHasSubdirs(basePath) {
  * See the matching TODO in markdown-renderer.ts detectStaleRenders, which
  * disabled stale-render detection for the same reason.
  */
+const LEGACY_MILESTONE_RUNTIME_DIRS = new Set(["anchors"]);
 export function dirIsContentBearingLegacyMilestone(dir) {
     try {
         const entries = readdirSync(dir, { withFileTypes: true });
         // 1. Any non-META regular file → real legacy content.
         if (entries.some(e => e.isFile() && !e.name.endsWith("-META.json")))
             return true;
-        // 2. A non-empty subdirectory → real legacy content (e.g. slices/ with slice dirs).
+        // 2. A non-empty non-runtime subdirectory → real legacy content (e.g. slices/ with slice dirs).
         //    An *empty* subdir is treated as scaffolding (e.g. git-service.ts may create
         //    an empty slices/ alongside the integration META file) and must NOT flip the
         //    layout — that is the Bugbot finding this guard addresses.
         return entries.some(e => {
             if (!e.isDirectory())
                 return false;
+            if (LEGACY_MILESTONE_RUNTIME_DIRS.has(e.name))
+                return false;
             try {
                 return readdirSync(join(dir, e.name)).length > 0;
             }

package/dist/resources/extensions/gsd/phase-anchor.js

@@ -7,11 +7,14 @@ import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { gsdRoot } from "./paths.js";
 function anchorsDir(basePath, milestoneId) {
-    return join(gsdRoot(basePath), "milestones", milestoneId, "anchors");
+    return join(gsdRoot(basePath), "runtime", "anchors", milestoneId);
 }
 function anchorPath(basePath, milestoneId, phase) {
     return join(anchorsDir(basePath, milestoneId), `${phase}.json`);
 }
+function legacyAnchorPath(basePath, milestoneId, phase) {
+    return join(gsdRoot(basePath), "milestones", milestoneId, "anchors", `${phase}.json`);
+}
 export function writePhaseAnchor(basePath, milestoneId, anchor) {
     const dir = anchorsDir(basePath, milestoneId);
     if (!existsSync(dir)) {
@@ -20,7 +23,9 @@ export function writePhaseAnchor(basePath, milestoneId, anchor) {
     writeFileSync(anchorPath(basePath, milestoneId, anchor.phase), JSON.stringify(anchor, null, 2), "utf-8");
 }
 export function readPhaseAnchor(basePath, milestoneId, phase) {
-    const path = anchorPath(basePath, milestoneId, phase);
+    const path = existsSync(anchorPath(basePath, milestoneId, phase))
+        ? anchorPath(basePath, milestoneId, phase)
+        : legacyAnchorPath(basePath, milestoneId, phase);
     if (!existsSync(path))
         return null;
     try {

package/dist/resources/extensions/gsd/post-execution-checks.js

@@ -242,11 +242,11 @@ export function checkImportResolution(taskRow, _priorTasks, basePath) {
         }
         const imports = extractRelativeImports(source);
         for (const { importPath, lineNum } of imports) {
-            // Framework-generated type modules may not exist on disk during post-exec
-            // checks (typically generated during framework builds/typegen). Don't
-            // block task completion on these imports.
+            // Framework/codegen-generated modules may not exist on disk during
+            // post-exec checks. Don't block task completion on these imports.
             if (/^\.{1,2}\/\+types\//.test(importPath) ||
-                /^(?:\.{1,2}\/)+(?:[^/]+\/)*\$types(?:$|\/)/.test(importPath)) {
+                /^(?:\.{1,2}\/)+(?:[^/]+\/)*\$types(?:$|\/)/.test(importPath) ||
+                /^(?:\.{1,2}\/)+(?:[^/]+\/)*_generated(?:$|\/)/.test(importPath)) {
                 continue;
             }
             const resolution = resolveImportPath(importPath, file, basePath);

package/dist/resources/extensions/gsd/prompts/refine-slice.md

@@ -66,12 +66,12 @@ Then:
    **Web apps:** when inlined Web App UAT guidance is present, follow it for Playwright scaffolding and browser-capable verification commands.
 4. For non-trivial slices, plan observability / proof level / integration closure, threat surface, and requirement impact. Omit entirely for simple slices.
 5. Decompose the slice into tasks that fit one context window each. Every task passed to `gsd_plan_slice` must use the exact keys `taskId`, `title`, `description`, `estimate`, `files`, `verify`, `inputs`, `expectedOutput`, and optional `observabilityImpact`. Put Why / Do / Done-when detail in `description`. `files`, `inputs`, and `expectedOutput` must be JSON arrays of strings, even for one path (for example, `"expectedOutput": ["src/index.ts"]`, never `"expectedOutput": "src/index.ts"`). `expectedOutput` is path-only: list only files the task creates or overwrites, and use `[]` for pure verification tasks. Never list GSD planning artifacts — anything under `.gsd/`, `.planning/`, or `.audits/`, or artifact names like `M001-CONTEXT.md` / `S01-PLAN.md` — in `inputs`, `files`, or `expectedOutput`: their content is preloaded as context, and they are written by workflow tools, not by tasks.
-6. **Persist planning state through `gsd_plan_slice`.** Call it with the full payload. The tool writes to the DB and renders `{{outputPath}}` and `{{slicePath}}/tasks/T##-PLAN.md` automatically. Do NOT rely on direct `PLAN.md` writes.
+6. **Persist planning state through `gsd_plan_slice`.** Call it with the full payload. The tool writes to the DB and renders `{{outputPath}}` with embedded task planning automatically. Do NOT rely on direct `PLAN.md` writes.
 7. **Self-audit the plan.** If every task were completed exactly as written, the slice goal/demo should be true. Every must-have maps to a task. Inputs and Expected Output are backtick-wrapped file paths.
 8. If refinement produced structural decisions that diverge from the sketch, call `gsd_decision_save` for each; the tool persists the decision and regenerates `.gsd/DECISIONS.md`.
 9. {{commitInstruction}}
 
-The slice directory and tasks/ subdirectory already exist. Do NOT mkdir.
+The slice plan path already exists. Do NOT mkdir.
 
 **Autonomous execution:** Do not call `ask_user_questions` or `secure_env_collect`. Document assumptions in the plan.
 

package/dist/resources/extensions/gsd/safety/evidence-collector.js

@@ -173,7 +173,7 @@ export function recordToolCall(toolCallId, toolName, input) {
             toolCallId,
             // gsd_exec / gsd_uat_exec carry the script body in `script` (or `code`);
             // bash-style tools use `command`/`cmd`; gsd_exec_search uses `query`.
-            command: String(input.command ?? input.script ?? input.cmd ?? input.code ?? input.query ?? ""),
+            command: formatExecutionEvidenceCommand(toolName, input),
             exitCode: -1,
             outputSnippet: "",
             timestamp: Date.now(),
@@ -196,6 +196,31 @@ export function recordToolCall(toolCallId, toolName, input) {
         });
     }
 }
+function pickString(input, ...keys) {
+    for (const key of keys) {
+        const value = input[key];
+        if (typeof value === "string" && value.trim().length > 0)
+            return value.trim();
+    }
+    return "";
+}
+function canonicalExecutionToolLabel(toolName) {
+    const normalized = toolName.trim().toLowerCase();
+    const mcpMatch = normalized.match(/^mcp__.+__(gsd_(?:uat_)?exec(?:_search)?)$/);
+    return mcpMatch?.[1] ?? normalized;
+}
+function formatExecutionEvidenceCommand(toolName, input) {
+    const body = pickString(input, "command", "script", "cmd", "code", "query");
+    const tool = canonicalExecutionToolLabel(toolName);
+    const purpose = pickString(input, "purpose");
+    const runtime = pickString(input, "runtime").toLowerCase();
+    const label = purpose && (tool === "gsd_exec" || tool === "gsd_uat_exec")
+        ? `${tool}${runtime ? ` ${runtime}` : ""}: ${purpose}`
+        : "";
+    if (label && body)
+        return `${label}\n${body}`;
+    return body || label;
+}
 /**
  * Record a tool execution result. Matches the entry by toolCallId (assigned
  * at dispatch time) and fills in exit code + output. Prior versions matched

package/dist/resources/extensions/gsd/safety/evidence-cross-ref.js

@@ -118,16 +118,25 @@ function latestClaimBatch(claimedEvidence) {
  */
 function findMatches(claimedCommand, bashCalls) {
     const normalized = claimedCommand.trim();
-    // Exact matches first
-    const exact = bashCalls.filter(b => b.command.trim() === normalized);
+    const exact = bashCalls.filter((b) => b.command.trim() === normalized);
+    // When an exact run exists, also consider wrapper-equivalent reruns (e.g.
+    // `cd ... && <command>`) so a newer pass is not shadowed by a stale exact
+    // failure. Do not merge arbitrary containing scripts: their exit code may
+    // belong to later work, not to the claimed verification command.
+    const scriptWrapped = bashCalls.filter((b) => {
+        const command = b.command.trim();
+        if (command.length === 0 || command === normalized)
+            return false;
+        return isWrapperEquivalentCommand(command, normalized);
+    });
     if (exact.length > 0)
-        return exact;
+        return [...exact, ...scriptWrapped];
     // Substring match: claimed is contained in actual or actual in claimed.
     // A claimed verification command typically appears verbatim inside a
     // larger gsd_exec script body (cd prefix, multi-line scripts), so
     // script-containing-claim is the common direction. Blank-command entries
     // must be excluded — `"x".includes("")` is true, so they'd match anything.
-    const substring = bashCalls.filter(b => b.command.trim().length > 0 &&
+    const substring = bashCalls.filter((b) => b.command.trim().length > 0 &&
         (b.command.includes(normalized) || normalized.includes(b.command)));
     if (substring.length > 0)
         return substring;
@@ -150,5 +159,21 @@ function findMatches(claimedCommand, bashCalls) {
         .map((match) => match.call);
 }
 function latestMatch(matches) {
-    return matches.reduce((latest, match) => (match.timestamp > latest.timestamp ? match : latest));
+    return matches.reduce((latest, match) => (match.timestamp >= latest.timestamp ? match : latest));
+}
+/** True when `actual` is the same command with only shell wrapper noise. */
+function isWrapperEquivalentCommand(actual, claimed) {
+    const claimIndex = actual.lastIndexOf(claimed);
+    if (claimIndex < 0)
+        return false;
+    const prefix = actual.slice(0, claimIndex).trim();
+    if (prefix.length > 0 && !/^cd\s+.+\s+&&$/.test(prefix))
+        return false;
+    const suffix = actual.slice(claimIndex + claimed.length).trim();
+    return suffix.length === 0 || isBenignWrapperSuffix(suffix);
+}
+function isBenignWrapperSuffix(suffix) {
+    if (/^;\s*echo\s+["']?[A-Z_]*EXIT=\$\?["']?$/.test(suffix))
+        return true;
+    return /^(?:(?:\d?>>?|&>)\s*\S+|\d?>&\d)(?:\s+(?:(?:\d?>>?|&>)\s*\S+|\d?>&\d))*$/.test(suffix);
 }

package/dist/resources/extensions/gsd/state-reconciliation/drift/external-markdown-edit.js

@@ -3,9 +3,10 @@
 //
 // gsd-pi's DB is canonical, but .gsd/*.md is the inter-tool contract. When
 // gsd-core edits a projection file, this handler detects the sha drift vs the
-// recorded baseline in .gsd/.compat.json and re-imports the affected entities
-// into the DB. The next renderAllFromDb pass re-projects; the write-time
-// invalidation hook then refreshes the marker entry, closing the loop.
+// recorded baseline in .gsd/.compat.json and re-imports from markdown with
+// status authority scoped to the affected milestone ids. The next
+// renderAllFromDb pass re-projects; the write-time invalidation hook then
+// refreshes the marker entry, closing the loop.
 import { existsSync, readFileSync } from "node:fs";
 import { join } from "node:path";
 import { computeProjectionSha, readCompatMarker, writeCompatMarker, } from "../../compat/compat-marker.js";
@@ -43,23 +44,36 @@ function detectExternalMarkdownEdit(_state, ctx) {
     return records;
 }
 /**
- * Idempotent repair: re-import hierarchy for the affected entities from
- * markdown into the DB, then update the marker entry so the next detect pass
- * sees the file as expected. migrateHierarchyToDb is itself idempotent
- * (upsert), so re-running this repair after a successful one is a no-op.
+ * Idempotent repair: re-import the hierarchy from markdown while allowing
+ * markdown status authority only for milestones named by the drifted file's
+ * marker entities, then update the marker entry so the next detect pass sees
+ * the file as expected. migrateHierarchyToDb is itself idempotent (upsert), so
+ * re-running this repair after a successful one is a no-op.
  */
 async function repairExternalMarkdownEdit(record, ctx) {
     try {
         // Dynamic imports break a module-init cycle: this handler ← registry ←
         // state.ts ← guided-flow.ts ← md-importer.ts ← (this handler's old static
         // import). Deferring to repair time keeps module load cycle-free.
-        const { migrateHierarchyToDb } = await import("../../md-importer.js");
+        const { migrateHierarchyToDb, milestoneIdsFromEntities } = await import("../../md-importer.js");
         const { invalidateStateCache } = await import("../../state.js");
-        // Scoped re-import. migrateHierarchyToDb walks the whole tree but is a
-        // cheap upsert; per-entity scoping would require decomposing it, which is
-        // out of scope for v1. The cost is bounded by tree size and runs at most
-        // once per reconcile pass (MAX_PASSES=2).
-        migrateHierarchyToDb(ctx.basePath);
+        // #027: migrateHierarchyToDb walks the whole tree (a cheap upsert), so
+        // without scoping every projection rides along with markdown *status*
+        // authority. That lets an unrelated file that is stale from gsd-pi's own
+        // miss silently revert a reopened slice/milestone. Scope status authority to
+        // exactly the milestone(s) this drifted file projects.
+        //
+        // Step 1: the marker's `entities` are DB ids (`M001`, `M001/S01`,
+        // `M001/S01/T01`), so the milestone id is always the first `/`-segment —
+        // layout-independent (legacy `milestones/<MID>/…` and flat `phases/NN-slug/…`
+        // both resolve the same way), no projectionPath parsing needed. An empty set
+        // (no resolvable entities) preserves DB status everywhere: fail toward
+        // protecting the DB, not toward markdown authority.
+        const statusAuthoritativeMilestones = milestoneIdsFromEntities(record.entities);
+        if (statusAuthoritativeMilestones.size === 0) {
+            logWarning("reconcile", `external-markdown-edit: no milestone scope resolved for ${record.projectionPath}; preserving DB status for all milestones`);
+        }
+        migrateHierarchyToDb(ctx.basePath, { statusAuthoritativeMilestones });
         invalidateStateCache();
     }
     catch (err) {

package/dist/resources/extensions/gsd/state-reconciliation/drift/external-planning-edit.js

@@ -3,7 +3,8 @@
 // Parallel to external-markdown-edit.ts. Detects sha drift between the compat
 // marker's planning.projections/passthrough and current .planning/ files.
 //
-// Modeled files (projections): re-imported via parsePlanningDirectory → DB.
+// Modeled files (projections): re-imported via parsePlanningDirectory → DB,
+// with markdown status authority scoped to their marker entity milestone ids.
 // Passthrough files (un-modeled docs): sha refreshed, content untouched.
 import { existsSync, readFileSync } from "node:fs";
 import { join } from "node:path";
@@ -115,12 +116,21 @@ async function repairExternalPlanningEdit(record, ctx) {
         const { parsePlanningDirectory } = await import("../../migrate/parser.js");
         const { transformToGSD } = await import("../../migrate/transformer.js");
         const { writeGSDDirectory } = await import("../../migrate/writer.js");
-        const { migrateHierarchyToDb } = await import("../../md-importer.js");
+        const { migrateHierarchyToDb, milestoneIdsFromEntities } = await import("../../md-importer.js");
         const { invalidateStateCache } = await import("../../state.js");
         const parsed = await parsePlanningDirectory(join(ctx.basePath, ".planning"));
         const gsdProject = transformToGSD(parsed);
         await writeGSDDirectory(gsdProject, ctx.basePath);
-        migrateHierarchyToDb(ctx.basePath);
+        // #027: scope status authority to the milestone(s) this drifted .planning/
+        // file projects (first `/`-segment of its DB entity ids), so a stale
+        // checkbox in an unrelated projection can't revert a reopened slice/milestone
+        // in the DB. Unseeded files carry no entities → empty set → preserve DB
+        // status everywhere (fail toward the DB, log the breadcrumb).
+        const statusAuthoritativeMilestones = milestoneIdsFromEntities(record.entities);
+        if (statusAuthoritativeMilestones.size === 0) {
+            logWarning("reconcile", `external-planning-edit: no milestone scope resolved for ${record.projectionPath}; preserving DB status for all milestones`);
+        }
+        migrateHierarchyToDb(ctx.basePath, { statusAuthoritativeMilestones });
         invalidateStateCache();
     }
     catch (err) {

package/dist/resources/extensions/gsd/stop-notice.js

@@ -50,8 +50,22 @@ export function isTerminalNotice(message) {
 export function isNonBlockingPauseNotice(message) {
     return message.includes("idempotent advance: unit already active");
 }
+/**
+ * A picker / next-action menu that could not render in a non-interactive
+ * (headless / RPC) session. Both wordings originate from the menu-unavailable
+ * helpers (`notifyCommandMenuUnavailable` and `notifyPickerCommandNeedsInteractiveMenu`
+ * in next-action-ui.ts / command-feedback.ts). Headless `auto`/`next` cannot
+ * answer such a menu, so the run has dead-ended and needs operator intervention.
+ * Classify it as blocked so the headless host exits 10 instead of idling
+ * forever waiting for a completion signal that never comes. (#1294)
+ */
+export function isInteractiveMenuUnavailableNotice(message) {
+    return (message.includes("menu could not be shown in this session") ||
+        message.includes("did not start:"));
+}
 export function isBlockedNoticeMessage(message) {
     return (message.includes("blocked:") ||
         (isPauseNotice(message) && !isNonBlockingPauseNotice(message)) ||
-        isManualResolutionNotice(message));
+        isManualResolutionNotice(message) ||
+        isInteractiveMenuUnavailableNotice(message));
 }

package/dist/resources/extensions/gsd/sync-lock.js

@@ -6,8 +6,9 @@ import { closeSync, existsSync, mkdirSync, openSync, readFileSync, statSync, unl
 import { dirname, join } from "node:path";
 const STALE_THRESHOLD_MS = 60_000; // 60 seconds
 const DEFAULT_TIMEOUT_MS = 0; // fail fast; sync waits block the JS event loop
-function lockFilePath(basePath) {
-    return join(basePath, ".gsd", "sync.lock");
+const DEFAULT_LOCK_NAME = "sync.lock";
+function lockFilePath(basePath, lockName = DEFAULT_LOCK_NAME) {
+    return join(basePath, ".gsd", lockName);
 }
 /** True if the given PID is alive in the current process namespace. */
 function isPidAlive(pid) {
@@ -71,8 +72,8 @@ function tryCreateLockFile(lp, payload) {
  * I/O, and UI work on Node's single JS thread. The timeout argument remains
  * accepted for compatibility but is intentionally not used for sync waiting.
  */
-export function acquireSyncLock(basePath, _timeoutMs = DEFAULT_TIMEOUT_MS) {
-    const lp = lockFilePath(basePath);
+export function acquireSyncLock(basePath, _timeoutMs = DEFAULT_TIMEOUT_MS, lockName = DEFAULT_LOCK_NAME) {
+    const lp = lockFilePath(basePath, lockName);
     const lockData = JSON.stringify({ pid: process.pid, acquired_at: new Date().toISOString() }, null, 2);
     while (true) {
         // First try the fast path: atomic create. No check-then-write race.
@@ -82,7 +83,12 @@ export function acquireSyncLock(basePath, _timeoutMs = DEFAULT_TIMEOUT_MS) {
             }
         }
         catch {
-            /* unexpected — fall through to retry */
+            // tryCreateLockFile only throws for non-EEXIST errors — a persistently
+            // uncreatable lock path (dangling-symlink parent, ENOTDIR, read-only FS).
+            // Retrying would spin the loop forever with no progress condition,
+            // blocking the JS event loop. Fail open like a contended lock so callers
+            // proceed (racy but functional) instead of hanging.
+            return { acquired: false };
         }
         // File exists. Decide whether to steal (stale + owner dead) or skip.
         let canSteal = false;
@@ -125,8 +131,8 @@ export function acquireSyncLock(basePath, _timeoutMs = DEFAULT_TIMEOUT_MS) {
 /**
  * Release the advisory sync lock. No-op if lock file does not exist.
  */
-export function releaseSyncLock(basePath) {
-    const lp = lockFilePath(basePath);
+export function releaseSyncLock(basePath, lockName = DEFAULT_LOCK_NAME) {
+    const lp = lockFilePath(basePath, lockName);
     try {
         if (existsSync(lp)) {
             unlinkSync(lp);