@opengsd/gsd-pi 1.8.1 → 1.9.0

package/src/resources/extensions/gsd/migrate/plan.ts

@@ -0,0 +1,101 @@
+// gsd-pi - /gsd migrate planning service.
+// File Purpose: Resolve, validate, parse, transform, preview, and guard a migration before UI confirmation.
+
+import { existsSync } from "node:fs";
+
+import {
+  assertMigrationHasSlices,
+  assertMigrationTargetAvailable,
+  resolveMigrationPaths,
+  type MigrationPaths,
+} from "./safety.js";
+import { parsePlanningDirectory } from "./parser.js";
+import { generatePreview } from "./preview.js";
+import { transformToGSD } from "./transformer.js";
+import { validatePlanningDirectory } from "./validator.js";
+import type { GSDProject, ValidationIssue, ValidationResult } from "./types.js";
+import type { MigrationPreview } from "./writer.js";
+
+export interface SplitValidationIssues {
+  warnings: ValidationIssue[];
+  fatals: ValidationIssue[];
+}
+
+interface MigrationPlanBase extends MigrationPaths {
+  warnings: ValidationIssue[];
+  fatals: ValidationIssue[];
+}
+
+export interface MissingMigrationSourceResult extends MigrationPaths {
+  status: "missing-source";
+}
+
+export interface InvalidMigrationPlanResult extends MigrationPlanBase {
+  status: "invalid";
+  validation: ValidationResult;
+}
+
+export interface BlockedMigrationPlanResult extends MigrationPlanBase {
+  status: "blocked";
+  validation: ValidationResult;
+  message: string;
+}
+
+export interface ReadyMigrationPlanResult extends MigrationPlanBase {
+  status: "ready";
+  validation: ValidationResult;
+  project: GSDProject;
+  preview: MigrationPreview;
+}
+
+export type MigrationPlanResult =
+  | MissingMigrationSourceResult
+  | InvalidMigrationPlanResult
+  | BlockedMigrationPlanResult
+  | ReadyMigrationPlanResult;
+
+export function splitValidationIssues(validation: ValidationResult): SplitValidationIssues {
+  return {
+    warnings: validation.issues.filter((issue) => issue.severity === "warning"),
+    fatals: validation.issues.filter((issue) => issue.severity === "fatal"),
+  };
+}
+
+export async function createMigrationPlan(args: string, cwd: string = process.cwd()): Promise<MigrationPlanResult> {
+  const paths = resolveMigrationPaths(args, cwd);
+  if (!existsSync(paths.sourcePath)) {
+    return { status: "missing-source", ...paths };
+  }
+
+  const validation = await validatePlanningDirectory(paths.sourcePath);
+  const issues = splitValidationIssues(validation);
+  if (!validation.valid) {
+    return { status: "invalid", ...paths, validation, ...issues };
+  }
+
+  const parsed = await parsePlanningDirectory(paths.sourcePath);
+  const project = transformToGSD(parsed);
+  const preview = generatePreview(project);
+
+  try {
+    assertMigrationHasSlices(preview);
+    await assertMigrationTargetAvailable(paths.targetRoot);
+  } catch (error) {
+    return {
+      status: "blocked",
+      ...paths,
+      validation,
+      ...issues,
+      message: error instanceof Error ? error.message : String(error),
+    };
+  }
+
+  return {
+    status: "ready",
+    ...paths,
+    validation,
+    ...issues,
+    project,
+    preview,
+  };
+}

package/src/resources/extensions/gsd/migrate/planning-writer.ts

@@ -186,17 +186,14 @@ export async function writePlanningDirectory(
       });
 
       if (tasks.length === 0) {
-        // Empty phase — write a single placeholder plan so the dir isn't empty.
-        const planPath = join(phaseDir, `${pad(phaseNum)}-01-PLAN.md`);
-        await saveFile(
-          planPath,
-          formatPlanningPlan(phaseNum, 1, slice.title || slice.id, []),
-        );
-        paths.push(planPath);
-        projectionWrites.push({
-          relPath: toPlanningRel(planPath),
-          entities: [`${milestone.id}/${slice.id}`],
-        });
+        // Sketch / undecomposed slice — zero tasks. Do NOT emit an ingestible
+        // *-PLAN.md here: the reverse transform maps one GSDTask per plan file
+        // (transformer.ts mapSlice), so a placeholder would materialize a
+        // phantom "Plan NN" task and flip the slice from "needs planning" to
+        // "has a planned task", causing auto-mode to skip planning (issue #1285).
+        // The phase dir is already created (mkdirSync above) and the slice is
+        // listed in ROADMAP.md, so it round-trips with tasks = [] — the correct
+        // sketch-slice shape.
       } else {
         for (let ti = 0; ti < tasks.length; ti++) {
           const task = tasks[ti]!;
@@ -223,19 +220,14 @@ export async function writePlanningDirectory(
     }
   }
 
-  // If no slices produced any phases, write a single empty phase so ROADMAP.md
-  // isn't blank and the layout is still discoverable.
+  // If no slices produced any phases, emit a single empty phase dir + ROADMAP
+  // entry so the layout stays discoverable. Do NOT write a placeholder
+  // *-PLAN.md — an ingestible plan file would round-trip into a phantom task
+  // (see the tasks.length === 0 branch above, issue #1285).
   if (roadmapEntries.length === 0) {
     const phaseDirName = `${pad(1)}-milestone`;
     const phaseDir = join(root, "phases", phaseDirName);
     mkdirSync(phaseDir, { recursive: true });
-    const planPath = join(phaseDir, `${pad(1)}-01-PLAN.md`);
-    await saveFile(planPath, formatPlanningPlan(1, 1, milestones[0]!.title || milestones[0]!.id, []));
-    paths.push(planPath);
-    projectionWrites.push({
-      relPath: toPlanningRel(planPath),
-      entities: [milestones[0]!.id],
-    });
     roadmapEntries.push({ number: 1, title: milestones[0]!.title || milestones[0]!.id, done: false });
   }
 

package/src/resources/extensions/gsd/migrate/presentation.ts

@@ -0,0 +1,83 @@
+// 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";
+import type { MigrationPreview } from "./writer.js";
+
+export interface ReviewPromptInput {
+  sourcePath: string;
+  gsdPath: string;
+  preview: MigrationPreview;
+  templatePath?: string;
+}
+
+function formatRequirements(preview: MigrationPreview): string | null {
+  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: MigrationPreview): string | null {
+  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: MigrationPreview, targetRoot: string): string[] {
+  const lines: string[] = [
+    `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: MigrationPreview): string {
+  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(): string {
+  const promptsDir = join(dirname(fileURLToPath(import.meta.url)), "..", "prompts");
+  return join(promptsDir, "review-migration.md");
+}
+
+export function buildReviewPrompt(input: ReviewPromptInput): string {
+  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/src/resources/extensions/gsd/parallel-eligibility.ts

@@ -8,7 +8,7 @@
 import { deriveState } from "./state.js";
 import { resolveMilestoneFile, resolveSliceFile } from "./paths.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";
 import type { MilestoneRegistryEntry } from "./types.js";
 
@@ -40,10 +40,11 @@ async function collectTouchedFiles(
   const files = new Set<string>();
 
   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/src/resources/extensions/gsd/parallel-monitor-overlay.ts

@@ -72,6 +72,7 @@ interface WorkerView {
   totalSlices: number;
   doneSlices: number;
   slices: SliceProgress[];
+  completions: string[];
   errors: string[];
 }
 
@@ -143,14 +144,21 @@ function discoverWorkers(basePath: string): string[] {
   return [...mids].sort();
 }
 
-function querySliceProgress(basePath: string, mid: string, workRoot: string = worktreePathFor(basePath, mid)): SliceProgress[] {
+// 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: string,
+  mid: string,
+  workRoot: string = worktreePathFor(basePath, mid),
+): { slices: SliceProgress[]; completions: string[] } {
   const dbPath = resolveGsdPathContract(workRoot, basePath).projectDb;
-  if (!existsSync(dbPath)) return [];
+  if (!existsSync(dbPath)) return { slices: [], completions: [] };
 
   const db = openWorkflowDatabaseIsolated(dbPath);
-  if (!db) return [];
+  if (!db) return { slices: [], completions: [] };
   try {
-    const rows = db.prepare(
+    const sliceRows = db.prepare(
       `SELECT
          s.id AS id,
          s.status AS status,
@@ -162,14 +170,32 @@ function querySliceProgress(basePath: string, mid: string, workRoot: string = wo
        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 { db.close(); } catch { /* ignore */ }
   }
@@ -276,36 +302,6 @@ function extractCostFromNdjson(basePath: string, mid: string): number {
   }
 }
 
-function queryRecentCompletions(basePath: string, mid: string): string[] {
-  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: string): WorkerView[] {
   const mids = discoverWorkers(basePath);
   const parallelDir = join(basePath, ".gsd", "parallel");
@@ -317,7 +313,7 @@ function collectWorkerData(basePath: string): WorkerView[] {
     const workRoot = worktreePathFor(basePath, mid);
     const status = readJsonSafe<StatusJson>(join(parallelDir, `${mid}.status.json`));
     const lock = readJsonSafe<AutoLock>(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;
@@ -378,6 +374,7 @@ function collectWorkerData(basePath: string): WorkerView[] {
       totalSlices: slices.length,
       doneSlices,
       slices,
+      completions,
       errors,
     });
   }
@@ -443,10 +440,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/src/resources/extensions/gsd/paths.ts

@@ -618,17 +618,20 @@ function legacyMilestonesHasSubdirs(basePath: string): boolean {
  * 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: string): boolean {
   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; } catch { return false; }
     });
   } catch {

package/src/resources/extensions/gsd/phase-anchor.ts

@@ -19,13 +19,17 @@ export interface PhaseAnchor {
 }
 
 function anchorsDir(basePath: string, milestoneId: string): string {
-  return join(gsdRoot(basePath), "milestones", milestoneId, "anchors");
+  return join(gsdRoot(basePath), "runtime", "anchors", milestoneId);
 }
 
 function anchorPath(basePath: string, milestoneId: string, phase: string): string {
   return join(anchorsDir(basePath, milestoneId), `${phase}.json`);
 }
 
+function legacyAnchorPath(basePath: string, milestoneId: string, phase: string): string {
+  return join(gsdRoot(basePath), "milestones", milestoneId, "anchors", `${phase}.json`);
+}
+
 export function writePhaseAnchor(basePath: string, milestoneId: string, anchor: PhaseAnchor): void {
   const dir = anchorsDir(basePath, milestoneId);
   if (!existsSync(dir)) {
@@ -35,7 +39,9 @@ export function writePhaseAnchor(basePath: string, milestoneId: string, anchor:
 }
 
 export function readPhaseAnchor(basePath: string, milestoneId: string, phase: string): PhaseAnchor | null {
-  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 {
     return JSON.parse(readFileSync(path, "utf-8")) as PhaseAnchor;

package/src/resources/extensions/gsd/post-execution-checks.ts

@@ -318,12 +318,12 @@ export function checkImportResolution(
     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;
       }

package/src/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/src/resources/extensions/gsd/safety/evidence-collector.ts

@@ -232,7 +232,7 @@ export function recordToolCall(toolCallId: string, toolName: string, input: Reco
       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(),
@@ -254,6 +254,33 @@ export function recordToolCall(toolCallId: string, toolName: string, input: Reco
   }
 }
 
+function pickString(input: Record<string, unknown>, ...keys: string[]): string {
+  for (const key of keys) {
+    const value = input[key];
+    if (typeof value === "string" && value.trim().length > 0) return value.trim();
+  }
+  return "";
+}
+
+function canonicalExecutionToolLabel(toolName: string): string {
+  const normalized = toolName.trim().toLowerCase();
+  const mcpMatch = normalized.match(/^mcp__.+__(gsd_(?:uat_)?exec(?:_search)?)$/);
+  return mcpMatch?.[1] ?? normalized;
+}
+
+function formatExecutionEvidenceCommand(toolName: string, input: Record<string, unknown>): string {
+  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/src/resources/extensions/gsd/safety/evidence-cross-ref.ts

@@ -161,9 +161,18 @@ function findMatches(
 ): BashEvidence[] {
   const normalized = claimedCommand.trim();
 
-  // Exact matches first
-  const exact = bashCalls.filter(b => b.command.trim() === normalized);
-  if (exact.length > 0) return exact;
+  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, ...scriptWrapped];
 
   // Substring match: claimed is contained in actual or actual in claimed.
   // A claimed verification command typically appears verbatim inside a
@@ -171,7 +180,7 @@ function findMatches(
   // 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 &&
+    (b) => b.command.trim().length > 0 &&
       (b.command.includes(normalized) || normalized.includes(b.command)),
   );
   if (substring.length > 0) return substring;
@@ -199,6 +208,23 @@ function findMatches(
 
 function latestMatch(matches: readonly BashEvidence[]): BashEvidence {
   return matches.reduce((latest, match) => (
-    match.timestamp > latest.timestamp ? match : latest
+    match.timestamp >= latest.timestamp ? match : latest
   ));
 }
+
+/** True when `actual` is the same command with only shell wrapper noise. */
+function isWrapperEquivalentCommand(actual: string, claimed: string): boolean {
+  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: string): boolean {
+  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/src/resources/extensions/gsd/state-reconciliation/drift/external-markdown-edit.ts

@@ -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";
@@ -59,10 +60,11 @@ function detectExternalMarkdownEdit(
 }
 
 /**
- * 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: ExternalMarkdownEditDrift,
@@ -72,13 +74,28 @@ async function repairExternalMarkdownEdit(
     // 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) {
     logWarning(