@opengsd/gsd-pi 1.1.1-dev.a5a2de8 → 1.1.1-dev.b2556262

package/src/resources/extensions/gsd/prompts/plan-milestone.md

@@ -14,7 +14,7 @@ All relevant context is preloaded below. Start immediately without re-reading th
 
 ## Already Planned? Soft Brake
 
-If `{{outputPath}}` exists with at least one slice line (e.g. `- [ ] **S01:`) AND `gsd_query` reports slice rows for this milestone, a prior `gsd_plan_milestone` call already persisted the plan. Do **not** re-call it; its UPSERT could overwrite existing planning. Skip to the ready phrase.
+If `{{outputPath}}` exists with at least one slice line (e.g. `- [ ] **S01:`) AND `gsd_milestone_status` reports slice rows for this milestone, a prior `gsd_plan_milestone` call already persisted the plan. Do **not** re-call it; its UPSERT could overwrite existing planning. Skip to the ready phrase.
 
 If only the file or only DB rows exist, the prior write was incomplete; plan normally so the tool reconciles both.
 

package/src/resources/extensions/gsd/prompts/plan-slice.md

@@ -44,7 +44,7 @@ If slice research is inlined, trust its architectural findings, but verify every
 6. Include Threat Surface (Q3), Requirement Impact (Q4), proof level, observability, integration closure, Failure Modes (Q5), Load Profile (Q6), and Negative Tests (Q7) only where applicable.
 7. Right-size tasks. Simple slices can be one task; split only when context, ownership, or verification boundaries justify it.
 8. Task `verify` commands must be safe, simple commands. Do not use shell pipes, redirects, semicolons, backticks, command substitution, output trimming, or grep regex alternation with `|`. If multiple checks are needed, create a small test file and run it with `node --test` or a package test script, or use separate simple commands joined only with `&&`. For absence checks, verify a pattern does not exist with `! grep -q 'pattern' file` or `! rg -q 'pattern' file`; do not use `grep -c` or `rg -c` to assert zero matches because count commands exit 1 when they find zero matches, and the verification gate treats that as failure.
-9. Each task needs the exact `gsd_plan_slice.tasks[]` shape: `taskId`, `title`, `description`, `estimate`, `files`, `verify`, `inputs`, `expectedOutput`, and optional `observabilityImpact`. `description` should contain the Why / Do / Done-when narrative. `files`, `inputs`, and `expectedOutput` must be JSON arrays of strings, even when there is only one path (for example, `"inputs": ["src/index.ts"]`, never `"inputs": "src/index.ts"`). Use paths relative to `{{workingDirectory}}`; do not put absolute paths to the original checkout or any directory outside `{{workingDirectory}}` in `files`, `inputs`, `expectedOutput`, or verification commands. **`expectedOutput` must only list files the task actually creates or overwrites on disk.** Do NOT include files the task merely reads, verifies, or tests — those belong only in `inputs`. If a task is a pure verification or test task that produces no new files, `expectedOutput` may be `[]` or limited to test-result artifacts (e.g. a log or assertion output). A file that does not yet exist on disk and is needed as an `input` must be produced by an earlier task's `expectedOutput` — if no prior task creates it, add a task before this one that does.
+9. Each task needs the exact `gsd_plan_slice.tasks[]` shape: `taskId`, `title`, `description`, `estimate`, `files`, `verify`, `inputs`, `expectedOutput`, and optional `observabilityImpact`. `description` should contain the Why / Do / Done-when narrative. `files`, `inputs`, and `expectedOutput` must be JSON arrays of strings, even when there is only one path (for example, `"inputs": ["src/index.ts"]`, never `"inputs": "src/index.ts"`). Use paths relative to `{{workingDirectory}}`; do not put absolute paths to the original checkout or any directory outside `{{workingDirectory}}` in `files`, `inputs`, `expectedOutput`, or verification commands. **`expectedOutput` must only list files the task actually creates or overwrites on disk.** Do NOT include files the task merely reads, verifies, tests, or describes — those belong in `inputs`, `verify`, `description`, or slice success criteria. If a task is a pure verification or test task that produces no new files, `expectedOutput` must be `[]`; if it writes a test-result log or assertion output file, list only that concrete file path. A file that does not yet exist on disk and is needed as an `input` must be produced by an earlier task's `expectedOutput` — if no prior task creates it, add a task before this one that does.
 10. Persist with `gsd_plan_slice` using `milestoneId`, `sliceId`, `goal`, optional `successCriteria`/`proofLevel`/`integrationClosure`/`observabilityImpact`, and `tasks`. `gsd_plan_slice` handles task persistence transactionally and renders `{{outputPath}}` plus task plans; do not call `gsd_plan_task`. The DB-backed tool is the canonical write path. Do **not** rely on direct `PLAN.md` writes as the source of truth.
 11. Self-audit before finishing: goal/demo closure, requirement coverage, deliverable coverage audit (cross-check every file listed in CONTEXT.md `## Scope` / `### In Scope` against task `files` or `expectedOutput`), locked decisions, concrete paths, dependency order, wiring, scope size, proof truthfulness, feature completeness, and quality gates. Quality gates: non-trivial slices/tasks include specific Q3-Q7 coverage where applicable.
 12. If planning creates structural decisions, call `gsd_decision_save` for each; the tool persists the decision and regenerates `.gsd/DECISIONS.md`.

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

@@ -64,7 +64,7 @@ Then:
 2. {{skillActivation}} Record the installed skills you expect executors to use in each task plan's `skills_used` frontmatter.
 3. Define slice-level verification: the objective stopping condition. Plan real test files with real assertions; for simple slices, executable commands are fine.
 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"`).
+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.
 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.
 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`.

package/src/resources/extensions/gsd/prompts/run-uat.md

@@ -27,7 +27,7 @@ You are the UAT runner. Execute every check defined in `{{uatPath}}` as deeply a
 ### Automation rules by mode
 
 - `artifact-driven` — verify with shell commands, scripts, file reads, and artifact structure checks.
-- `browser-executable` — use gsd-browser tools to navigate to the target URL and verify expected behavior. Prefer `mcp__gsd-browser__browser_*` tools when namespaced, or direct `browser_*` tools when surfaced without a namespace. Capture screenshots as evidence. Record pass/fail with specific assertions.
+- `browser-executable` — use browser tools to navigate to the target URL and verify expected behavior. Prefer direct `browser_*` tools when available. Capture screenshots as evidence. Record pass/fail with specific assertions.
 - `runtime-executable` — execute the specified command or script. Capture stdout/stderr as evidence. Record pass/fail based on exit code and output.
 - `live-runtime` — exercise the real runtime path. Start or connect to the app/service if needed, use browser/runtime/network checks, and verify observable behavior.
 - `mixed` — run all automatable artifact-driven and live-runtime checks. Separate any remaining human-only checks explicitly.
@@ -48,7 +48,7 @@ Choose the lightest tool that proves the check honestly:
 - Run `node` / other script invocations
 - Read files and verify their contents
 - Check that expected artifacts exist and have correct structure
-- For live/runtime/UI checks, exercise the real flow with gsd-browser when applicable and inspect runtime/network/console state
+- For live/runtime/UI checks, exercise the real flow with browser tools when applicable and inspect runtime/network/console state
 - When a check cannot be honestly automated, gather the best objective evidence you can and mark it `NEEDS-HUMAN`
 
 For each check, record:

package/src/resources/extensions/gsd/prompts/system.md

@@ -118,7 +118,7 @@ Templates are in `{{templatesDir}}`.
 
 **Secrets:** Use `secure_env_collect`. Never ask the user to edit `.env` files or paste secrets.
 
-**Browser verification:** Verify frontend work against a running app with gsd-browser by default. Use `browser_find`/`browser_snapshot_refs` for discovery, refs/selectors -> `browser_batch` for actions, `browser_assert` for verification, and `browser_diff` -> console/network logs -> full inspection as last resort. If tools are MCP-namespaced, prefer `mcp__gsd-browser__browser_*`. Retry only with a new hypothesis.
+**Browser verification:** Verify frontend work against a running app with browser tools by default. Use `browser_find`/`browser_snapshot_refs` for discovery, refs/selectors -> `browser_batch` for actions, `browser_assert` for verification, and `browser_diff` -> console/network logs -> full inspection as last resort. If browser tools are MCP-namespaced, use that host-provided browser surface. Retry only with a new hypothesis.
 
 **Database:** Never query `.gsd/gsd.db` directly via `sqlite3`, `better-sqlite3`, or `node -e require('better-sqlite3')`; the engine owns a single-writer WAL connection. Use `gsd_milestone_status`, `gsd_journal_query`, or other `gsd_*` tools.
 

package/src/resources/extensions/gsd/roadmap-slices.ts

@@ -193,7 +193,12 @@ export function parseRoadmapSlices(content: string): RoadmapSliceEntry[] {
         ? expandDependencies(depsMatch[1]!.split(",").map(s => s.trim()))
         : [];
 
-      currentSlice = { id, title, risk, depends, done, demo: "" };
+      // ADR-011: the renderer writes a `[sketch]` badge for sketch slices.
+      // Parse it back so the is_sketch flag survives a markdown → DB re-import
+      // (e.g. /gsd recover); otherwise the flag was silently lost.
+      const isSketch = /\[sketch\]/i.test(rest);
+
+      currentSlice = { id, title, risk, depends, done, demo: "", isSketch };
       continue;
     }
 

package/src/resources/extensions/gsd/safety/content-validator.ts

@@ -11,7 +11,7 @@ import { logWarning } from "../workflow-logger.js";
 // ─── Types ──────────────────────────────────────────────────────────────────
 
 export interface ContentViolation {
-  severity: "warning";
+  severity: "error" | "warning";
   reason: string;
 }
 
@@ -46,6 +46,9 @@ export function validateContent(
 
 type ContentValidatorFn = (content: string) => ContentViolation[];
 
+const TASK_MARKER_RE = /^\s*(?:-\s+\[[ xX]\]\s+\*\*T\d+:|#{2,4}\s+T\d+\b)/gm;
+const SLICE_MARKER_RE = /^\s*(?:-\s+\[[ xX]\]\s+\*\*S\d+:|#{2,4}\s+S\d+\b)/gm;
+
 const VALIDATORS: Record<string, ContentValidatorFn> = {
   "plan-slice": validatePlanSlice,
   "plan-milestone": validatePlanMilestone,
@@ -55,10 +58,10 @@ function validatePlanSlice(content: string): ContentViolation[] {
   const violations: ContentViolation[] = [];
 
   // Must have at least 1 task entry — single-task slices are valid (#3649)
-  const taskCount = (content.match(/- \[[ x]\] \*\*T\d+/g) || []).length;
+  const taskCount = (content.match(TASK_MARKER_RE) || []).length;
   if (taskCount < 1) {
     violations.push({
-      severity: "warning",
+      severity: "error",
       reason: `Slice plan has ${taskCount} task(s) — expected at least 1`,
     });
   }
@@ -86,10 +89,10 @@ function validatePlanMilestone(content: string): ContentViolation[] {
   const violations: ContentViolation[] = [];
 
   // Must have at least 1 slice entry
-  const sliceCount = (content.match(/##\s+S\d+/g) || []).length;
+  const sliceCount = (content.match(SLICE_MARKER_RE) || []).length;
   if (sliceCount < 1) {
     violations.push({
-      severity: "warning",
+      severity: "error",
       reason: `Milestone roadmap has ${sliceCount} slice(s) — expected at least 1`,
     });
   }

package/src/resources/extensions/gsd/skill-manifest.ts

@@ -117,6 +117,18 @@ const UNIT_TYPE_SKILL_MANIFEST: Record<string, string[]> = {
     "review",
     "accessibility",
   ],
+  // Slice closeout — the "closer" role: verify assembled task work, write the
+  // downstream-ready summary + UAT, optionally drive reviewer/security/tester
+  // subagents. Predictable skill set, mirrors `complete-milestone`.
+  "complete-slice": [
+    "verify-before-complete",
+    "test",
+    "review",
+    "security-review",
+    "write-docs",
+    "observability",
+    "handoff",
+  ],
   // `execute-task` intentionally omitted — implementation hot path covers a
   // wide surface of technologies; wildcard fallback preserves today's
   // behavior until per-task skill hints can be derived from task-plan

package/src/resources/extensions/gsd/source-observations.ts

@@ -0,0 +1,402 @@
+// Project/App: gsd-pi
+// File Purpose: Active-unit source observations for provider payload context.
+
+import { existsSync, readFileSync, statSync } from "node:fs";
+import { isAbsolute, relative, resolve, sep } from "node:path";
+
+import type { TaskRow } from "./db-task-slice-rows.js";
+import { extractPlanningPathReference, normalizeFilePath } from "./pre-execution-checks.js";
+
+export const WHOLE_FILE_OBSERVATION_MAX_BYTES = 50 * 1024;
+export const WHOLE_FILE_OBSERVATION_MAX_LINES = 2000;
+
+export type SourceObservationStatus =
+  | "whole"
+  | "missing"
+  | "binary/image"
+  | "over-threshold"
+  | "glob"
+  | "directory"
+  | "unresolved selector";
+
+export interface SourceObservationUnit {
+  unitType: string;
+  unitId: string;
+  startedAt: number;
+  basePath: string;
+}
+
+export type SourceObservationSource = "plan" | "read" | "mutation";
+
+export interface SourceObservation {
+  path: string;
+  absolutePath: string | null;
+  status: SourceObservationStatus;
+  source: SourceObservationSource;
+  text?: string;
+  bytes?: number;
+  lines?: number;
+  reason?: string;
+}
+
+interface ActiveSourceObservationSet {
+  unit: SourceObservationUnit;
+  observations: Map<string, SourceObservation>;
+}
+
+const SOURCE_CONTEXT_TITLE = "## Source Context Block";
+const SOURCE_OBSERVATION_UNIT_TYPE = "execute-task";
+
+export function supportsSourceObservationsForUnit(unitType: string): boolean {
+  return unitType === SOURCE_OBSERVATION_UNIT_TYPE;
+}
+
+export class SourceObservationStore {
+  private active: ActiveSourceObservationSet | null = null;
+
+  beginUnit(unit: SourceObservationUnit): void {
+    if (!supportsSourceObservationsForUnit(unit.unitType)) {
+      this.clear();
+      return;
+    }
+    if (this.matches(unit)) return;
+    this.active = { unit: { ...unit }, observations: new Map() };
+  }
+
+  clear(): void {
+    this.active = null;
+  }
+
+  degradeUnit(unit: Pick<SourceObservationUnit, "unitType" | "unitId" | "startedAt">): void {
+    if (!this.active) return;
+    const current = this.active.unit;
+    if (
+      current.unitType === unit.unitType &&
+      current.unitId === unit.unitId &&
+      current.startedAt === unit.startedAt
+    ) {
+      this.active = null;
+    }
+  }
+
+  observePlanTask(task: TaskRow): void {
+    if (!this.active) return;
+    for (const entry of planDeclaredSourceEntries(task)) {
+      this.observePath(entry.path, "plan");
+    }
+  }
+
+  observeRead(input: { path?: unknown; file_path?: unknown; [key: string]: unknown }): void {
+    if (!this.active) return;
+    const rawPath = readPathFromInput(input);
+    if (!rawPath.trim()) return;
+    this.observePath(rawPath, "read");
+  }
+
+  observeMutation(input: { path?: unknown; file_path?: unknown; [key: string]: unknown }): void {
+    if (!this.active) return;
+    const rawPath = readPathFromInput(input);
+    if (!rawPath.trim()) return;
+    this.observePath(rawPath, "mutation", { replaceExisting: true });
+  }
+
+  renderActiveBlock(): string | null {
+    if (!this.active || this.active.observations.size === 0) return null;
+    if (!supportsSourceObservationsForUnit(this.active.unit.unitType)) return null;
+    const observations = [...this.active.observations.values()]
+      .sort((a, b) => a.path.localeCompare(b.path));
+    const lines = [
+      SOURCE_CONTEXT_TITLE,
+      `Active Unit: ${this.active.unit.unitType} ${this.active.unit.unitId}`,
+      "",
+      "The files below are protected active-Unit source context. " +
+        "Use this block instead of rereading small files just to recover line windows.",
+    ];
+
+    const wholeFiles = observations.filter((observation) => observation.status === "whole");
+    const unavailable = observations.filter((observation) => observation.status !== "whole");
+
+    if (wholeFiles.length > 0) {
+      lines.push("", "### Whole-File Observations");
+      for (const observation of wholeFiles) {
+        lines.push(
+          "",
+          `#### ${observation.path}`,
+          `Status: whole-file (${observation.lines ?? 0} lines, ${formatSize(observation.bytes ?? 0)})`,
+          fencedSource(observation.text ?? ""),
+        );
+      }
+    }
+
+    if (unavailable.length > 0) {
+      lines.push("", "### Unavailable Source Observations");
+      for (const observation of unavailable) {
+        const detail = observation.reason ? ` - ${observation.reason}` : "";
+        lines.push(`- ${observation.path}: ${observation.status}${detail}`);
+      }
+    }
+
+    return lines.join("\n");
+  }
+
+  private matches(unit: SourceObservationUnit): boolean {
+    if (!this.active) return false;
+    const current = this.active.unit;
+    return current.unitType === unit.unitType &&
+      current.unitId === unit.unitId &&
+      current.startedAt === unit.startedAt &&
+      current.basePath === unit.basePath;
+  }
+
+  private observePath(
+    rawPath: string,
+    source: SourceObservationSource,
+    options: { replaceExisting?: boolean } = {},
+  ): void {
+    if (!this.active) return;
+    const observation = observeSourcePath(this.active.unit.basePath, rawPath, source);
+    const key = observation.absolutePath ?? `${observation.status}:${observation.path}`;
+    const existing = this.active.observations.get(key);
+    if (options.replaceExisting || !existing || observation.status === "whole" || existing.status !== "whole") {
+      this.active.observations.set(key, observation);
+    }
+  }
+}
+
+export function planDeclaredSourceEntries(
+  task: TaskRow,
+): Array<{ path: string; field: "files" | "inputs" }> {
+  const entries: Array<{ path: string; field: "files" | "inputs" }> = [];
+  for (const file of task.files) {
+    const path = extractPlanningPathReference(file) ?? file.trim();
+    if (path) entries.push({ path, field: "files" });
+  }
+  for (const input of task.inputs) {
+    const path = extractPlanningPathReference(input);
+    if (path) entries.push({ path, field: "inputs" });
+  }
+  return entries;
+}
+
+export function observeSourcePath(
+  basePath: string,
+  rawPath: string,
+  source: SourceObservationSource,
+): SourceObservation {
+  const normalizedRaw = normalizeFilePath(rawPath.trim());
+  const displayPath = normalizedRaw || rawPath.trim();
+  if (!normalizedRaw) {
+    return unavailable(displayPath || "<empty>", null, "unresolved selector", source);
+  }
+  if (containsGlobPattern(normalizedRaw)) {
+    return unavailable(displayPath, null, "glob", source, "glob selectors are not whole files");
+  }
+  if (rawPath.trim().endsWith("/")) {
+    return unavailable(displayPath, null, "directory", source, "directory selectors are not whole files");
+  }
+
+  const rootPath = resolve(basePath);
+  const absolutePath = isAbsolute(normalizedRaw) ? resolve(normalizedRaw) : resolve(rootPath, normalizedRaw);
+  const path = formatObservationPath(rootPath, absolutePath, displayPath);
+
+  if (!isPathInsideRoot(rootPath, absolutePath)) {
+    return unavailable(displayPath, absolutePath, "unresolved selector", source, "path is outside active Unit root");
+  }
+
+  if (!existsSync(absolutePath)) {
+    return unavailable(path, absolutePath, "missing", source, "file does not exist in the active Unit root");
+  }
+
+  let stat;
+  try {
+    stat = statSync(absolutePath);
+  } catch {
+    return unavailable(path, absolutePath, "missing", source, "file could not be inspected");
+  }
+
+  if (stat.isDirectory()) {
+    return unavailable(path, absolutePath, "directory", source, "directory selectors are not whole files");
+  }
+  if (!stat.isFile()) {
+    return unavailable(path, absolutePath, "unresolved selector", source, "path is not a regular file");
+  }
+  if (stat.size > WHOLE_FILE_OBSERVATION_MAX_BYTES) {
+    return unavailable(
+      path,
+      absolutePath,
+      "over-threshold",
+      source,
+      `${formatSize(stat.size)} exceeds ${formatSize(WHOLE_FILE_OBSERVATION_MAX_BYTES)}`,
+    );
+  }
+
+  let buffer: Buffer;
+  try {
+    buffer = readFileSync(absolutePath);
+  } catch {
+    return unavailable(path, absolutePath, "missing", source, "file could not be read");
+  }
+
+  if (isBinaryOrImage(buffer)) {
+    return unavailable(path, absolutePath, "binary/image", source, "binary or image files are not inlined as source text");
+  }
+
+  const text = buffer.toString("utf8");
+  const lines = countLines(text);
+  if (lines > WHOLE_FILE_OBSERVATION_MAX_LINES) {
+    return unavailable(
+      path,
+      absolutePath,
+      "over-threshold",
+      source,
+      `${lines} lines exceeds ${WHOLE_FILE_OBSERVATION_MAX_LINES}`,
+    );
+  }
+
+  return {
+    path,
+    absolutePath,
+    status: "whole",
+    source,
+    text,
+    bytes: buffer.byteLength,
+    lines,
+  };
+}
+
+export function injectSourceContextBlockIntoPayload(
+  payload: Record<string, unknown>,
+  block: string,
+): Record<string, unknown> {
+  const messages = payload.messages;
+  if (Array.isArray(messages)) {
+    return {
+      ...payload,
+      messages: [
+        ...withoutExistingSourceContextMessages(messages),
+        { role: "user", content: [{ type: "text", text: block }] },
+      ],
+    };
+  }
+
+  const input = payload.input;
+  if (Array.isArray(input)) {
+    return {
+      ...payload,
+      input: [
+        ...withoutExistingSourceContextItems(input),
+        { role: "user", content: [{ type: "input_text", text: block }] },
+      ],
+    };
+  }
+
+  return payload;
+}
+
+function unavailable(
+  path: string,
+  absolutePath: string | null,
+  status: Exclude<SourceObservationStatus, "whole">,
+  source: SourceObservationSource,
+  reason?: string,
+): SourceObservation {
+  return { path, absolutePath, status, source, reason };
+}
+
+function formatObservationPath(basePath: string, absolutePath: string, fallback: string): string {
+  const rel = relative(basePath, absolutePath);
+  if (rel && !rel.startsWith("..") && !isAbsolute(rel)) {
+    return rel.split(sep).join("/");
+  }
+  return fallback;
+}
+
+function isPathInsideRoot(rootPath: string, absolutePath: string): boolean {
+  const rel = relative(rootPath, absolutePath);
+  return rel === "" || (!rel.startsWith("..") && !isAbsolute(rel));
+}
+
+function containsGlobPattern(candidate: string): boolean {
+  return ["*", "?", "[", "]", "{", "}"].some((char) => candidate.includes(char));
+}
+
+function readPathFromInput(input: { path?: unknown; file_path?: unknown }): string {
+  if (typeof input.path === "string") return input.path;
+  if (typeof input.file_path === "string") return input.file_path;
+  return "";
+}
+
+function formatSize(bytes: number): string {
+  if (bytes < 1024) return `${bytes}B`;
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)}KB`;
+  return `${(bytes / (1024 * 1024)).toFixed(1)}MB`;
+}
+
+function isBinaryOrImage(buffer: Buffer): boolean {
+  if (buffer.includes(0)) return true;
+  if (startsWith(buffer, [0xff, 0xd8, 0xff])) return true;
+  if (startsWith(buffer, [0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a])) return true;
+  if (startsWithAscii(buffer, "GIF")) return true;
+  if (
+    startsWithAscii(buffer, "RIFF") &&
+    buffer.length >= 12 &&
+    buffer.subarray(8, 12).toString("ascii") === "WEBP"
+  ) return true;
+  return false;
+}
+
+function startsWith(buffer: Buffer, signature: readonly number[]): boolean {
+  if (buffer.length < signature.length) return false;
+  return signature.every((byte, index) => buffer[index] === byte);
+}
+
+function startsWithAscii(buffer: Buffer, text: string): boolean {
+  return buffer.length >= text.length && buffer.subarray(0, text.length).toString("ascii") === text;
+}
+
+function countLines(text: string): number {
+  if (text.length === 0) return 0;
+  return text.endsWith("\n") ? text.split("\n").length - 1 : text.split("\n").length;
+}
+
+function fencedSource(text: string): string {
+  const longest = longestBacktickRun(text);
+  const fence = longest >= 3 ? "`".repeat(longest + 1) : "```";
+  return `${fence}\n${text}\n${fence}`;
+}
+
+function longestBacktickRun(text: string): number {
+  let longest = 0;
+  let current = 0;
+  for (const char of text) {
+    if (char === "`") {
+      current += 1;
+      longest = Math.max(longest, current);
+    } else {
+      current = 0;
+    }
+  }
+  return longest;
+}
+
+function firstText(content: unknown): string | null {
+  if (typeof content === "string") return content;
+  if (!Array.isArray(content)) return null;
+  const block = content.find((entry) =>
+    entry && typeof entry === "object" && "text" in entry,
+  ) as { text?: unknown } | undefined;
+  return typeof block?.text === "string" ? block.text : null;
+}
+
+function isSourceContextMessage(message: unknown): boolean {
+  if (!message || typeof message !== "object") return false;
+  return firstText((message as { content?: unknown }).content)?.startsWith(SOURCE_CONTEXT_TITLE) === true;
+}
+
+function withoutExistingSourceContextMessages(messages: unknown[]): unknown[] {
+  return messages.filter((message) => !isSourceContextMessage(message));
+}
+
+function withoutExistingSourceContextItems(items: unknown[]): unknown[] {
+  return items.filter((item) => !isSourceContextMessage(item));
+}

package/src/resources/extensions/gsd/state-reconciliation/drift/completion.ts

@@ -9,6 +9,7 @@
 import { existsSync, statSync } from "node:fs";
 
 import {
+  getAllMilestones,
   getMilestone,
   getMilestoneSlices,
   getSliceTasks,
@@ -41,17 +42,30 @@ function summaryMtimeIso(path: string): string | null {
 }
 
 export function detectMissingCompletionTimestampDrift(
-  state: GSDState,
+  _state: GSDState,
   ctx: DriftContext,
 ): CompletionTimestampDrift[] {
   if (!isDbAvailable()) return [];
-  const mid = state.activeMilestone?.id;
-  if (!mid) return [];
-
-  const milestone = getMilestone(mid);
-  if (!milestone) return [];
 
+  // Scan every milestone, not just the active one. Markdown artifacts exist on
+  // disk for all milestones, so a user can manually complete a queued/parked
+  // milestone (edit the roadmap + drop a SUMMARY) and leave completed_at=null
+  // in the DB. Gating on the active milestone left that drift unrepaired until
+  // the milestone happened to become active.
   const drifts: CompletionTimestampDrift[] = [];
+  for (const { id: mid } of getAllMilestones()) {
+    collectMilestoneCompletionDrift(mid, ctx, drifts);
+  }
+  return drifts;
+}
+
+function collectMilestoneCompletionDrift(
+  mid: string,
+  ctx: DriftContext,
+  drifts: CompletionTimestampDrift[],
+): void {
+  const milestone = getMilestone(mid);
+  if (!milestone) return;
 
   // Milestone-level
   if (
@@ -105,8 +119,6 @@ export function detectMissingCompletionTimestampDrift(
       }
     }
   }
-
-  return drifts;
 }
 
 export function repairMissingCompletionTimestamp(