@opengsd/gsd-pi 1.1.1-dev.9f86580 → 1.1.1-dev.b2556262

package/src/resources/extensions/gsd/tests/schema-v21-sequence.test.ts

@@ -24,6 +24,7 @@ import {
   openDatabase,
   closeDatabase,
   _getAdapter,
+  SCHEMA_VERSION,
 } from '../gsd-db.ts';
 
 const _require = createRequire(import.meta.url);
@@ -403,9 +404,10 @@ test('schema v21 migration: upgrading from v20 lands on current SCHEMA_VERSION',
     // The DB must reach the current SCHEMA_VERSION.  If the v21 block was
     // skipped (as it would be when SCHEMA_VERSION was still 20), this
     // assertion catches it.
-    assert.ok(
-      maxVersion >= 21,
-      `DB upgraded from v20 must reach at least schema version 21; got ${maxVersion}`,
+    assert.equal(
+      maxVersion,
+      SCHEMA_VERSION,
+      `DB upgraded from v20 must reach schema version ${SCHEMA_VERSION}; got ${maxVersion}`,
     );
   } finally {
     cleanup(base);

package/src/resources/extensions/gsd/tests/schema-v27-v28-sequence.test.ts

@@ -1,16 +1,17 @@
-// gsd-pi / V27 + V28 schema migration regression tests
+// gsd-pi / V27 + V28 + V29 schema migration regression tests
 //
 // Same bug class as #4591 (schema-v21-sequence): a migration block can be
 // added but the SCHEMA_VERSION constant left unchanged, causing fresh-install
-// + upgrade paths to silently skip the column add. This file pins both V27
-// (artifacts.content_hash) and V28 (memories.last_hit_at) at the schema and
-// write-path level on fresh-install DBs.
+// + upgrade paths to silently skip the column add. This file pins V27
+// (artifacts.content_hash), V28 (memories.last_hit_at), and V29
+// (target_repositories) at the schema/write-path level.
 
 import test from "node:test";
 import assert from "node:assert/strict";
 import * as fs from "node:fs";
 import * as path from "node:path";
 import * as os from "node:os";
+import { createRequire } from "node:module";
 
 import {
   openDatabase,
@@ -22,8 +23,10 @@ import {
   SCHEMA_VERSION,
 } from "../gsd-db.ts";
 
+const _require = createRequire(import.meta.url);
+
 function makeTmp(): string {
-  return fs.mkdtempSync(path.join(os.tmpdir(), "gsd-v27v28-"));
+  return fs.mkdtempSync(path.join(os.tmpdir(), "gsd-v27v29-"));
 }
 
 function cleanup(base: string): void {
@@ -31,10 +34,114 @@ function cleanup(base: string): void {
   try { fs.rmSync(base, { recursive: true, force: true }); } catch { /* noop */ }
 }
 
-test("SCHEMA_VERSION constant is at least 28 (V28 migration committed)", () => {
+function columnNames(table: string): Set<string> {
+  const db = _getAdapter()!;
+  const cols = db.prepare(`PRAGMA table_info(${table})`).all() as Array<Record<string, unknown>>;
+  return new Set(cols.map((c) => c["name"] as string));
+}
+
+function createV28Db(dbPath: string): void {
+  const sqlite = _require("node:sqlite") as {
+    DatabaseSync: new (p: string) => {
+      exec(sql: string): void;
+      close(): void;
+    };
+  };
+  const db = new sqlite.DatabaseSync(dbPath);
+  db.exec("PRAGMA journal_mode=WAL");
+  db.exec(`
+    CREATE TABLE schema_version (
+      version INTEGER NOT NULL,
+      applied_at TEXT NOT NULL
+    );
+    INSERT INTO schema_version (version, applied_at) VALUES (28, '2026-01-01T00:00:00.000Z');
+
+    CREATE TABLE milestones (
+      id TEXT PRIMARY KEY,
+      title TEXT NOT NULL DEFAULT '',
+      status TEXT NOT NULL DEFAULT 'active',
+      depends_on TEXT NOT NULL DEFAULT '[]',
+      created_at TEXT NOT NULL DEFAULT '',
+      completed_at TEXT DEFAULT NULL,
+      vision TEXT NOT NULL DEFAULT '',
+      success_criteria TEXT NOT NULL DEFAULT '[]',
+      key_risks TEXT NOT NULL DEFAULT '[]',
+      proof_strategy TEXT NOT NULL DEFAULT '[]',
+      verification_contract TEXT NOT NULL DEFAULT '',
+      verification_integration TEXT NOT NULL DEFAULT '',
+      verification_operational TEXT NOT NULL DEFAULT '',
+      verification_uat TEXT NOT NULL DEFAULT '',
+      definition_of_done TEXT NOT NULL DEFAULT '[]',
+      requirement_coverage TEXT NOT NULL DEFAULT '',
+      boundary_map_markdown TEXT NOT NULL DEFAULT '',
+      sequence INTEGER DEFAULT 0
+    );
+    CREATE TABLE slices (
+      milestone_id TEXT NOT NULL,
+      id TEXT NOT NULL,
+      title TEXT NOT NULL DEFAULT '',
+      status TEXT NOT NULL DEFAULT 'pending',
+      risk TEXT NOT NULL DEFAULT 'medium',
+      depends TEXT NOT NULL DEFAULT '[]',
+      demo TEXT NOT NULL DEFAULT '',
+      created_at TEXT NOT NULL DEFAULT '',
+      completed_at TEXT DEFAULT NULL,
+      full_summary_md TEXT NOT NULL DEFAULT '',
+      full_uat_md TEXT NOT NULL DEFAULT '',
+      goal TEXT NOT NULL DEFAULT '',
+      success_criteria TEXT NOT NULL DEFAULT '',
+      proof_level TEXT NOT NULL DEFAULT '',
+      integration_closure TEXT NOT NULL DEFAULT '',
+      observability_impact TEXT NOT NULL DEFAULT '',
+      sequence INTEGER DEFAULT 0,
+      replan_triggered_at TEXT DEFAULT NULL,
+      is_sketch INTEGER NOT NULL DEFAULT 0,
+      sketch_scope TEXT NOT NULL DEFAULT '',
+      PRIMARY KEY (milestone_id, id),
+      FOREIGN KEY (milestone_id) REFERENCES milestones(id)
+    );
+    CREATE TABLE tasks (
+      milestone_id TEXT NOT NULL,
+      slice_id TEXT NOT NULL,
+      id TEXT NOT NULL,
+      title TEXT NOT NULL DEFAULT '',
+      status TEXT NOT NULL DEFAULT 'pending',
+      one_liner TEXT NOT NULL DEFAULT '',
+      narrative TEXT NOT NULL DEFAULT '',
+      verification_result TEXT NOT NULL DEFAULT '',
+      duration TEXT NOT NULL DEFAULT '',
+      completed_at TEXT DEFAULT NULL,
+      blocker_discovered INTEGER DEFAULT 0,
+      blocker_source TEXT NOT NULL DEFAULT '',
+      escalation_pending INTEGER NOT NULL DEFAULT 0,
+      escalation_awaiting_review INTEGER NOT NULL DEFAULT 0,
+      escalation_artifact_path TEXT DEFAULT NULL,
+      escalation_override_applied_at TEXT DEFAULT NULL,
+      deviations TEXT NOT NULL DEFAULT '',
+      known_issues TEXT NOT NULL DEFAULT '',
+      key_files TEXT NOT NULL DEFAULT '[]',
+      key_decisions TEXT NOT NULL DEFAULT '[]',
+      full_summary_md TEXT NOT NULL DEFAULT '',
+      description TEXT NOT NULL DEFAULT '',
+      estimate TEXT NOT NULL DEFAULT '',
+      files TEXT NOT NULL DEFAULT '[]',
+      verify TEXT NOT NULL DEFAULT '',
+      inputs TEXT NOT NULL DEFAULT '[]',
+      expected_output TEXT NOT NULL DEFAULT '[]',
+      observability_impact TEXT NOT NULL DEFAULT '',
+      full_plan_md TEXT NOT NULL DEFAULT '',
+      sequence INTEGER DEFAULT 0,
+      PRIMARY KEY (milestone_id, slice_id, id),
+      FOREIGN KEY (milestone_id, slice_id) REFERENCES slices(milestone_id, id)
+    );
+  `);
+  db.close();
+}
+
+test("SCHEMA_VERSION constant is at least 29 (V29 migration committed)", () => {
   assert.ok(
-    SCHEMA_VERSION >= 28,
-    `SCHEMA_VERSION must be ≥ 28 after V28 migration; got ${SCHEMA_VERSION}`,
+    SCHEMA_VERSION >= 29,
+    `SCHEMA_VERSION must be ≥ 29 after V29 migration; got ${SCHEMA_VERSION}`,
   );
 });
 
@@ -43,11 +150,8 @@ test("fresh-install DB has artifacts.content_hash column (V27)", () => {
   const dbPath = path.join(base, "gsd.db");
   try {
     openDatabase(dbPath);
-    const db = _getAdapter()!;
-    const cols = db.prepare("PRAGMA table_info(artifacts)").all() as Array<Record<string, unknown>>;
-    const colNames = new Set(cols.map((c) => c["name"] as string));
     assert.ok(
-      colNames.has("content_hash"),
+      columnNames("artifacts").has("content_hash"),
       "V27 must add content_hash column to artifacts on fresh install",
     );
   } finally {
@@ -60,11 +164,8 @@ test("fresh-install DB has memories.last_hit_at column (V28)", () => {
   const dbPath = path.join(base, "gsd.db");
   try {
     openDatabase(dbPath);
-    const db = _getAdapter()!;
-    const cols = db.prepare("PRAGMA table_info(memories)").all() as Array<Record<string, unknown>>;
-    const colNames = new Set(cols.map((c) => c["name"] as string));
     assert.ok(
-      colNames.has("last_hit_at"),
+      columnNames("memories").has("last_hit_at"),
       "V28 must add last_hit_at column to memories on fresh install",
     );
   } finally {
@@ -72,15 +173,58 @@ test("fresh-install DB has memories.last_hit_at column (V28)", () => {
   }
 });
 
-test("fresh-install DB stamps SCHEMA_VERSION (≥28) in schema_version table", () => {
+test("fresh-install DB has target_repositories columns (V29)", () => {
   const base = makeTmp();
   const dbPath = path.join(base, "gsd.db");
   try {
     openDatabase(dbPath);
+    assert.ok(
+      columnNames("slices").has("target_repositories"),
+      "V29 must add target_repositories column to slices on fresh install",
+    );
+    assert.ok(
+      columnNames("tasks").has("target_repositories"),
+      "V29 must add target_repositories column to tasks on fresh install",
+    );
+  } finally {
+    cleanup(base);
+  }
+});
+
+test("fresh-install DB stamps current SCHEMA_VERSION in schema_version table", () => {
+  const base = makeTmp();
+  const dbPath = path.join(base, "gsd.db");
+  try {
+    openDatabase(dbPath);
+    const db = _getAdapter()!;
+    const row = db.prepare("SELECT MAX(version) as v FROM schema_version").get() as Record<string, unknown> | undefined;
+    const max = (row?.["v"] as number) ?? 0;
+    assert.equal(max, SCHEMA_VERSION, `fresh install must record schema_version ${SCHEMA_VERSION}; got ${max}`);
+  } finally {
+    cleanup(base);
+  }
+});
+
+test("upgrading from V28 adds target_repositories and stamps V29", () => {
+  const base = makeTmp();
+  const dbPath = path.join(base, "gsd.db");
+  createV28Db(dbPath);
+
+  try {
+    openDatabase(dbPath);
+    assert.ok(
+      columnNames("slices").has("target_repositories"),
+      "V29 migration must add target_repositories column to existing slices table",
+    );
+    assert.ok(
+      columnNames("tasks").has("target_repositories"),
+      "V29 migration must add target_repositories column to existing tasks table",
+    );
+
     const db = _getAdapter()!;
     const row = db.prepare("SELECT MAX(version) as v FROM schema_version").get() as Record<string, unknown> | undefined;
     const max = (row?.["v"] as number) ?? 0;
-    assert.ok(max >= 28, `fresh install must record schema_version ≥ 28; got ${max}`);
+    assert.equal(max, SCHEMA_VERSION, `V28 DB must upgrade to schema_version ${SCHEMA_VERSION}; got ${max}`);
   } finally {
     cleanup(base);
   }

package/src/resources/extensions/gsd/tests/skipped-validation-db-atomicity.test.ts

@@ -7,6 +7,8 @@ import { tmpdir } from "node:os";
 import { DISPATCH_RULES } from "../auto-dispatch.ts";
 import {
   closeDatabase,
+  getArtifact,
+  getAssessment,
   getLatestAssessmentByScope,
   insertMilestone,
   insertSlice,
@@ -46,6 +48,12 @@ test("skipped validation dispatch persists the validation file and DB assessment
 
     assert.deepEqual(action, { action: "skip" });
     assert.equal(existsSync(join(milestoneDir, "M001-VALIDATION.md")), true);
+    assert.equal(existsSync(join(sliceDir, "S01-ASSESSMENT.md")), true);
+    const artifactPath = "milestones/M001/slices/S01/S01-ASSESSMENT.md";
+    const assessmentPath = `.gsd/${artifactPath}`;
+    assert.equal(getArtifact(artifactPath)?.artifact_type, "ASSESSMENT");
+    assert.equal(getAssessment(assessmentPath)?.scope, "run-uat");
+    assert.equal(getAssessment(assessmentPath)?.status, "pass");
     assert.equal(
       getLatestAssessmentByScope("M001", "milestone-validation")?.status,
       "pass",

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

@@ -0,0 +1,275 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { mkdirSync, mkdtempSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+import {
+  SourceObservationStore,
+  injectSourceContextBlockIntoPayload,
+  observeSourcePath,
+  planDeclaredSourceEntries,
+} from "../source-observations.js";
+import { AutoSession } from "../auto/session.js";
+import { truncateContextResultMessages, truncateResponsesInputResultItems } from "../context-masker.js";
+import type { TaskRow } from "../db-task-slice-rows.js";
+
+function makeTask(overrides: Partial<TaskRow> = {}): TaskRow {
+  return {
+    milestone_id: "M001",
+    slice_id: "S01",
+    id: "T01",
+    title: "Task",
+    status: "pending",
+    one_liner: "",
+    narrative: "",
+    verification_result: "",
+    duration: "",
+    completed_at: null,
+    blocker_discovered: false,
+    deviations: "",
+    known_issues: "",
+    key_files: [],
+    key_decisions: [],
+    full_summary_md: "",
+    description: "",
+    estimate: "",
+    files: [],
+    verify: "",
+    inputs: [],
+    expected_output: [],
+    observability_impact: "",
+    full_plan_md: "",
+    sequence: 1,
+    blocker_source: "",
+    escalation_pending: 0,
+    escalation_awaiting_review: 0,
+    escalation_artifact_path: null,
+    escalation_override_applied_at: null,
+    ...overrides,
+  };
+}
+
+function tempProject(): string {
+  return mkdtempSync(join(tmpdir(), "gsd-source-observations-"));
+}
+
+function beginStore(basePath: string): SourceObservationStore {
+  const store = new SourceObservationStore();
+  store.beginUnit({ unitType: "execute-task", unitId: "M001/S01/T01", startedAt: 123, basePath });
+  return store;
+}
+
+test("plan-declared source entries use task.files and concrete task.inputs, not expectedOutput", () => {
+  const task = makeTask({
+    files: ["src/app.ts"],
+    inputs: ["Current enum shape", "`src/input.ts` - existing input"],
+    expected_output: ["src/generated.ts"],
+  });
+
+  assert.deepEqual(planDeclaredSourceEntries(task), [
+    { path: "src/app.ts", field: "files" },
+    { path: "src/input.ts", field: "inputs" },
+  ]);
+});
+
+test("preloaded plan observations render whole files and unavailable statuses", () => {
+  const basePath = tempProject();
+  mkdirSync(join(basePath, "src"), { recursive: true });
+  writeFileSync(join(basePath, "src", "app.ts"), "export const value = 1;\n");
+  mkdirSync(join(basePath, "src", "directory"), { recursive: true });
+  writeFileSync(join(basePath, "image.png"), Buffer.from([0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a]));
+
+  const store = beginStore(basePath);
+  store.observePlanTask(makeTask({
+    files: [
+      "src/app.ts",
+      "src/missing.ts",
+      "src/*.ts",
+      "src/directory/",
+      "image.png",
+    ],
+  }));
+
+  const block = store.renderActiveBlock();
+  assert.ok(block);
+  assert.match(block, /## Source Context Block/);
+  assert.match(block, /#### src\/app\.ts/);
+  assert.match(block, /export const value = 1;/);
+  assert.match(block, /src\/missing\.ts: missing/);
+  assert.match(block, /src\/\*\.ts: glob/);
+  assert.match(block, /src\/directory: directory/);
+  assert.match(block, /image\.png: binary\/image/);
+});
+
+test("narrow reads of under-threshold files auto-upgrade to whole-file observations", () => {
+  const basePath = tempProject();
+  mkdirSync(join(basePath, "src"), { recursive: true });
+  writeFileSync(join(basePath, "src", "app.ts"), ["line one", "line two", "line three"].join("\n"));
+
+  const store = beginStore(basePath);
+  store.observeRead({ path: "src/app.ts", offset: 2, limit: 1 });
+
+  const block = store.renderActiveBlock();
+  assert.ok(block);
+  assert.match(block, /line one/);
+  assert.match(block, /line two/);
+  assert.match(block, /line three/);
+});
+
+test("successful file mutations refresh active whole-file observations", () => {
+  const basePath = tempProject();
+  writeFileSync(join(basePath, "app.ts"), "export const value = 'before';\n");
+
+  const store = beginStore(basePath);
+  store.observeRead({ path: "app.ts" });
+
+  assert.match(store.renderActiveBlock() ?? "", /before/);
+
+  writeFileSync(join(basePath, "app.ts"), "export const value = 'after';\n");
+  store.observeMutation({ path: "app.ts" });
+
+  const block = store.renderActiveBlock() ?? "";
+  assert.match(block, /after/);
+  assert.doesNotMatch(block, /before/);
+});
+
+test("successful writes promote missing plan observations to whole files", () => {
+  const basePath = tempProject();
+  const store = beginStore(basePath);
+  store.observePlanTask(makeTask({ files: ["generated.ts"] }));
+
+  assert.match(store.renderActiveBlock() ?? "", /generated\.ts: missing/);
+
+  writeFileSync(join(basePath, "generated.ts"), "export const generated = true;\n");
+  store.observeMutation({ path: "generated.ts" });
+
+  const block = store.renderActiveBlock() ?? "";
+  assert.match(block, /#### generated\.ts/);
+  assert.match(block, /export const generated = true;/);
+  assert.doesNotMatch(block, /generated\.ts: missing/);
+});
+
+test("over-threshold files are explicit unavailable observations", () => {
+  const basePath = tempProject();
+  writeFileSync(join(basePath, "large.txt"), "a".repeat(51 * 1024));
+
+  const observation = observeSourcePath(basePath, "large.txt", "plan");
+
+  assert.equal(observation.status, "over-threshold");
+  assert.match(observation.reason ?? "", /exceeds/);
+});
+
+test("outside-root paths are unavailable and never inlined", () => {
+  const root = tempProject();
+  const basePath = join(root, "project");
+  const outsidePath = join(root, "outside");
+  mkdirSync(basePath, { recursive: true });
+  mkdirSync(outsidePath, { recursive: true });
+  writeFileSync(join(outsidePath, "secret.txt"), "do not inline me\n");
+
+  const absoluteObservation = observeSourcePath(basePath, join(outsidePath, "secret.txt"), "read");
+  const relativeObservation = observeSourcePath(basePath, "../outside/secret.txt", "read");
+
+  assert.equal(absoluteObservation.status, "unresolved selector");
+  assert.equal(relativeObservation.status, "unresolved selector");
+  assert.match(absoluteObservation.reason ?? "", /outside active Unit root/);
+  assert.match(relativeObservation.reason ?? "", /outside active Unit root/);
+  assert.equal(absoluteObservation.text, undefined);
+  assert.equal(relativeObservation.text, undefined);
+});
+
+test("source observations only render for execute-task units", () => {
+  const basePath = tempProject();
+  writeFileSync(join(basePath, "plan.md"), "planning context\n");
+
+  const store = new SourceObservationStore();
+  store.beginUnit({ unitType: "plan-slice", unitId: "M001/S01", startedAt: 123, basePath });
+  store.observeRead({ path: "plan.md" });
+
+  assert.equal(store.renderActiveBlock(), null);
+});
+
+test("source context block injection survives tool-result truncation for messages payloads", () => {
+  const payload = {
+    messages: truncateContextResultMessages([
+      { role: "toolResult", content: [{ type: "text", text: "x".repeat(200) }], toolCallId: "read-1", toolName: "read", isError: false },
+    ] as any, 10),
+  };
+
+  const injected = injectSourceContextBlockIntoPayload(payload, "## Source Context Block\n\nfull source text");
+
+  assert.match((injected.messages as any[])[0].content[0].text, /truncated/);
+  assert.equal((injected.messages as any[])[1].content[0].text, "## Source Context Block\n\nfull source text");
+});
+
+test("source context block injection supports Responses input payloads", () => {
+  const payload = {
+    input: truncateResponsesInputResultItems([
+      { type: "function_call_output", call_id: "read-1", output: "x".repeat(200) },
+    ] as any, 10),
+  };
+
+  const injected = injectSourceContextBlockIntoPayload(payload, "## Source Context Block\n\nfull source text");
+
+  assert.match((injected.input as any[])[0].output, /truncated/);
+  assert.equal((injected.input as any[])[1].content[0].text, "## Source Context Block\n\nfull source text");
+});
+
+test("unit-close degradation removes active whole-file source text", () => {
+  const basePath = tempProject();
+  writeFileSync(join(basePath, "app.ts"), "export const value = 1;");
+  const store = beginStore(basePath);
+  store.observeRead({ path: "app.ts" });
+
+  assert.match(store.renderActiveBlock() ?? "", /export const value = 1/);
+
+  store.degradeUnit({ unitType: "execute-task", unitId: "M001/S01/T01", startedAt: 123 });
+
+  assert.equal(store.renderActiveBlock(), null);
+});
+
+test("AutoSession current-unit clear removes active source observations", () => {
+  const basePath = tempProject();
+  writeFileSync(join(basePath, "app.ts"), "export const value = 1;");
+  const session = new AutoSession();
+  session.basePath = basePath;
+  session.setCurrentUnit({
+    type: "execute-task",
+    id: "M001/S01/T01",
+    startedAt: 123,
+    workspaceRoot: basePath,
+  });
+  session.sourceObservations.observeRead({ path: "app.ts" });
+
+  assert.match(session.sourceObservations.renderActiveBlock() ?? "", /export const value = 1/);
+
+  session.clearCurrentUnit();
+
+  assert.equal(session.sourceObservations.renderActiveBlock(), null);
+});
+
+test("AutoSession clears source observations when switching to non-execute units", () => {
+  const basePath = tempProject();
+  writeFileSync(join(basePath, "app.ts"), "export const value = 1;");
+  const session = new AutoSession();
+  session.basePath = basePath;
+  session.setCurrentUnit({
+    type: "execute-task",
+    id: "M001/S01/T01",
+    startedAt: 123,
+    workspaceRoot: basePath,
+  });
+  session.sourceObservations.observeRead({ path: "app.ts" });
+
+  assert.match(session.sourceObservations.renderActiveBlock() ?? "", /export const value = 1/);
+
+  session.setCurrentUnit({
+    type: "plan-slice",
+    id: "M001/S01",
+    startedAt: 124,
+    workspaceRoot: basePath,
+  });
+
+  assert.equal(session.sourceObservations.renderActiveBlock(), null);
+});

package/src/resources/extensions/gsd/tests/stale-queued-milestone.test.ts

@@ -100,6 +100,7 @@ describe("stale queued milestone selection (#3470)", () => {
     const state = await deriveStateFromDb(base);
 
     assert.equal(state.activeMilestone?.id, "M068", "Queued milestone with draft should become active");
+    assert.equal(state.phase, "needs-discussion", "Queued milestone with draft should resume discussion");
   });
 
   test("queued milestone WITH slices can still be selected as active", async () => {
@@ -144,4 +145,46 @@ describe("stale queued milestone selection (#3470)", () => {
       assert.equal(entry!.status, "pending", `${id} should be pending, not active`);
     }
   });
+
+  test("queued milestone with stale CONTEXT-DRAFT does not block real active milestone", async () => {
+    base = createFixtureBase();
+    openDatabase(":memory:");
+
+    // M068: queued, no slices, has a CONTEXT-DRAFT (abandoned discussion)
+    insertMilestone({ id: "M068", title: "Abandoned Draft", status: "queued" });
+    writeFile(base, "milestones/M068/M068-CONTEXT-DRAFT.md", "# M068: Abandoned Draft\n\nDraft left over from an abandoned session.");
+
+    // M070: real active milestone with execution artifacts
+    insertMilestone({ id: "M070", title: "Real Active", status: "active" });
+    insertSlice({ id: "S01", milestoneId: "M070", title: "Slice One", status: "active", risk: "low", depends: [] });
+    insertTask({ id: "T01", sliceId: "S01", milestoneId: "M070", title: "Task One", status: "pending" });
+
+    writeFile(base, "milestones/M070/M070-CONTEXT.md", "# M070: Real Active\n\nThis is the real milestone.");
+    writeFile(base, "milestones/M070/M070-ROADMAP.md", "# M070: Real Active\n\n## Slices\n\n- [ ] **S01: Slice One**");
+    writeFile(base, "milestones/M070/slices/S01/S01-PLAN.md", "# S01: Slice One\n\n## Tasks\n\n- [ ] **T01: Task One**");
+
+    invalidateStateCache();
+    const state = await deriveStateFromDb(base);
+
+    assert.equal(state.activeMilestone?.id, "M070", "Stale draft on M068 must not block real active M070");
+
+    const m068Entry = state.registry.find((e: any) => e.id === "M068");
+    assert.ok(m068Entry, "M068 should still appear in registry");
+    assert.equal(m068Entry!.status, "pending", "M068 with stale draft should be pending, not active");
+  });
+
+  test("queued milestone with CONTEXT-DRAFT becomes active with needs-discussion phase when nothing else is active", async () => {
+    base = createFixtureBase();
+    openDatabase(":memory:");
+
+    // M068: queued, no slices, has a CONTEXT-DRAFT — should resume discussion
+    insertMilestone({ id: "M068", title: "Draft Only", status: "queued" });
+    writeFile(base, "milestones/M068/M068-CONTEXT-DRAFT.md", "# M068: Draft Only\n\nPartial context from first question round.");
+
+    invalidateStateCache();
+    const state = await deriveStateFromDb(base);
+
+    assert.equal(state.activeMilestone?.id, "M068", "Queued milestone with draft should become active when nothing else is");
+    assert.equal(state.phase, "needs-discussion", "Should resume discussion for queued milestone with draft");
+  });
 });