gsd-pi 2.80.0 → 2.81.0

package/src/resources/extensions/gsd/tests/db-migration-steps.test.ts

@@ -0,0 +1,159 @@
+// Project/App: GSD-2
+// File Purpose: Tests for extracted GSD database migration DDL steps.
+
+import { describe, test } from "node:test";
+import assert from "node:assert/strict";
+import type { DbAdapter, DbStatement } from "../db-adapter.ts";
+import {
+  applyMigrationV2Artifacts,
+  applyMigrationV3Memories,
+  applyMigrationV4DecisionMadeBy,
+  applyMigrationV5HierarchyTables,
+  applyMigrationV8PlanningFields,
+  applyMigrationV11TaskPlanning,
+  applyMigrationV13HotPathIndexes,
+  applyMigrationV15AuditTables,
+  applyMigrationV17TaskEscalation,
+  applyMigrationV18MemorySources,
+  applyMigrationV19MemoryFts,
+  applyMigrationV20MemoryRelations,
+  applyMigrationV22QualityGateRepair,
+} from "../db-migration-steps.ts";
+
+class FakeStatement implements DbStatement {
+  private readonly rows: Record<string, unknown>[];
+
+  constructor(rows: Record<string, unknown>[] = []) {
+    this.rows = rows;
+  }
+
+  run(): unknown {
+    return undefined;
+  }
+
+  get(): Record<string, unknown> | undefined {
+    return undefined;
+  }
+
+  all(): Record<string, unknown>[] {
+    return this.rows;
+  }
+}
+
+class FakeAdapter implements DbAdapter {
+  readonly execCalls: string[] = [];
+  tableInfoRows: Record<string, unknown>[] = [];
+
+  exec(sql: string): void {
+    this.execCalls.push(sql);
+  }
+
+  prepare(): DbStatement {
+    return new FakeStatement(this.tableInfoRows);
+  }
+
+  close(): void {}
+}
+
+describe("db-migration-steps", () => {
+  test("early migrations create artifact, memory, hierarchy, and active decision structures", () => {
+    const db = new FakeAdapter();
+
+    applyMigrationV2Artifacts(db);
+    applyMigrationV3Memories(db);
+    applyMigrationV4DecisionMadeBy(db);
+    applyMigrationV5HierarchyTables(db);
+
+    assert.ok(db.execCalls.some((sql) => sql.includes("CREATE TABLE IF NOT EXISTS artifacts")));
+    assert.ok(db.execCalls.some((sql) => sql.includes("CREATE TABLE IF NOT EXISTS memories")));
+    assert.ok(db.execCalls.some((sql) => sql.includes("CREATE VIEW active_memories")));
+    assert.ok(db.execCalls.some((sql) => sql.includes("ALTER TABLE decisions ADD COLUMN made_by")));
+    assert.ok(db.execCalls.some((sql) => sql.includes("CREATE VIEW active_decisions")));
+    assert.ok(db.execCalls.some((sql) => sql.includes("CREATE TABLE IF NOT EXISTS milestones")));
+    assert.ok(db.execCalls.some((sql) => sql.includes("CREATE TABLE IF NOT EXISTS tasks")));
+    assert.ok(db.execCalls.some((sql) => sql.includes("CREATE TABLE IF NOT EXISTS verification_evidence")));
+  });
+
+  test("planning migration adds planning columns and support tables", () => {
+    const db = new FakeAdapter();
+
+    applyMigrationV8PlanningFields(db);
+
+    assert.ok(db.execCalls.some((sql) => sql.includes("ALTER TABLE milestones ADD COLUMN vision")));
+    assert.ok(db.execCalls.some((sql) => sql.includes("ALTER TABLE slices ADD COLUMN goal")));
+    assert.ok(db.execCalls.some((sql) => sql.includes("ALTER TABLE tasks ADD COLUMN description")));
+    assert.ok(db.execCalls.some((sql) => sql.includes("CREATE TABLE IF NOT EXISTS replan_history")));
+    assert.ok(db.execCalls.some((sql) => sql.includes("CREATE TABLE IF NOT EXISTS assessments")));
+    assert.ok(db.execCalls.some((sql) => sql.includes("CREATE INDEX IF NOT EXISTS idx_replan_history_milestone")));
+  });
+
+  test("mid migrations add task planning, hot-path indexes, and audit tables", () => {
+    const db = new FakeAdapter();
+    let dedupeCalls = 0;
+
+    applyMigrationV11TaskPlanning(db);
+    applyMigrationV13HotPathIndexes(db, () => {
+      dedupeCalls += 1;
+    });
+    applyMigrationV15AuditTables(db);
+
+    assert.equal(dedupeCalls, 1);
+    assert.ok(db.execCalls.some((sql) => sql.includes("ALTER TABLE tasks ADD COLUMN full_plan_md")));
+    assert.ok(db.execCalls.some((sql) => sql.includes("CREATE UNIQUE INDEX IF NOT EXISTS idx_replan_history_unique")));
+    assert.ok(db.execCalls.some((sql) => sql.includes("CREATE INDEX IF NOT EXISTS idx_tasks_active")));
+    assert.ok(db.execCalls.some((sql) => sql.includes("CREATE TABLE IF NOT EXISTS gate_runs")));
+    assert.ok(db.execCalls.some((sql) => sql.includes("CREATE TABLE IF NOT EXISTS audit_events")));
+  });
+
+  test("late DDL migrations add escalation and memory structures", () => {
+    const db = new FakeAdapter();
+
+    applyMigrationV17TaskEscalation(db);
+    applyMigrationV18MemorySources(db);
+    applyMigrationV20MemoryRelations(db);
+
+    assert.ok(db.execCalls.some((sql) => sql.includes("ALTER TABLE tasks ADD COLUMN escalation_pending")));
+    assert.ok(db.execCalls.some((sql) => sql.includes("CREATE INDEX IF NOT EXISTS idx_tasks_escalation_pending")));
+    assert.ok(db.execCalls.some((sql) => sql.includes("CREATE TABLE IF NOT EXISTS memory_sources")));
+    assert.ok(db.execCalls.some((sql) => sql.includes("CREATE INDEX IF NOT EXISTS idx_memory_sources_scope")));
+    assert.ok(db.execCalls.some((sql) => sql.includes("CREATE TABLE IF NOT EXISTS memory_relations")));
+    assert.ok(db.execCalls.some((sql) => sql.includes("CREATE INDEX IF NOT EXISTS idx_memory_relations_from")));
+  });
+
+  test("memory FTS migration delegates data-copy backfill to caller-owned write callback", () => {
+    const db = new FakeAdapter();
+    let backfillCalls = 0;
+    const warnings: string[] = [];
+
+    applyMigrationV19MemoryFts(db, {
+      tryCreateMemoriesFts: () => true,
+      isMemoriesFtsAvailable: () => true,
+      backfillMemoriesFts: () => {
+        backfillCalls += 1;
+      },
+      logWarning: (_scope, message) => warnings.push(message),
+    });
+
+    assert.equal(backfillCalls, 1);
+    assert.deepEqual(warnings, []);
+    assert.ok(db.execCalls.some((sql) => sql.includes("CREATE TABLE IF NOT EXISTS memory_embeddings")));
+  });
+
+  test("quality gate repair delegates row copy to caller-owned write callback", () => {
+    const db = new FakeAdapter();
+    db.tableInfoRows = [{ name: "task_id", notnull: 0 }];
+    let copyCalls = 0;
+
+    applyMigrationV22QualityGateRepair(db, {
+      copyQualityGateRowsToRepairedTable: () => {
+        copyCalls += 1;
+      },
+    });
+
+    assert.equal(copyCalls, 1);
+    assert.ok(db.execCalls.some((sql) => sql.includes("CREATE TABLE quality_gates_new")));
+    assert.ok(db.execCalls.some((sql) => sql.includes("ALTER TABLE quality_gates_new RENAME TO quality_gates")));
+    assert.ok(db.execCalls.some((sql) => sql.includes("ALTER TABLE quality_gates ADD COLUMN scope")));
+    assert.ok(db.execCalls.some((sql) => sql.includes("ALTER TABLE assessments ADD COLUMN scope")));
+  });
+});

package/src/resources/extensions/gsd/tests/db-milestone-artifact-rows.test.ts

@@ -0,0 +1,53 @@
+// Project/App: GSD-2
+// File Purpose: Tests for milestone and artifact database row mappers.
+
+import { describe, test } from "node:test";
+import assert from "node:assert/strict";
+import { rowToArtifact, rowToMilestone } from "../db-milestone-artifact-rows.ts";
+
+describe("db-milestone-artifact-rows", () => {
+  test("rowToMilestone maps JSON planning fields and defaults optional strings", () => {
+    const milestone = rowToMilestone({
+      id: "M001",
+      title: "Refactor DB",
+      status: "active",
+      depends_on: '["M000"]',
+      created_at: "2026-05-04T00:00:00.000Z",
+      success_criteria: '["tests pass"]',
+      key_risks: '[{"risk":"drift","whyItMatters":"behavior"}]',
+      proof_strategy: '[{"riskOrUnknown":"queries","retireIn":"tests","whatWillBeProven":"same rows"}]',
+      definition_of_done: '["committed"]',
+    });
+
+    assert.deepEqual(milestone.depends_on, ["M000"]);
+    assert.deepEqual(milestone.success_criteria, ["tests pass"]);
+    assert.deepEqual(milestone.key_risks, [{ risk: "drift", whyItMatters: "behavior" }]);
+    assert.deepEqual(milestone.proof_strategy, [
+      { riskOrUnknown: "queries", retireIn: "tests", whatWillBeProven: "same rows" },
+    ]);
+    assert.deepEqual(milestone.definition_of_done, ["committed"]);
+    assert.equal(milestone.completed_at, null);
+    assert.equal(milestone.vision, "");
+    assert.equal(milestone.sequence, 0);
+  });
+
+  test("rowToArtifact maps nullable ownership columns", () => {
+    const artifact = rowToArtifact({
+      path: "docs/report.md",
+      artifact_type: "report",
+      milestone_id: "M001",
+      full_content: "content",
+      imported_at: "2026-05-04T00:00:00.000Z",
+    });
+
+    assert.deepEqual(artifact, {
+      path: "docs/report.md",
+      artifact_type: "report",
+      milestone_id: "M001",
+      slice_id: null,
+      task_id: null,
+      full_content: "content",
+      imported_at: "2026-05-04T00:00:00.000Z",
+    });
+  });
+});

package/src/resources/extensions/gsd/tests/db-open-state.test.ts

@@ -0,0 +1,56 @@
+// Project/App: GSD-2
+// File Purpose: Tests for database open attempt and error state tracking.
+
+import { describe, test } from "node:test";
+import assert from "node:assert/strict";
+import { createDbOpenState } from "../db-open-state.ts";
+
+describe("db-open-state", () => {
+  test("starts with no attempt or error", () => {
+    const state = createDbOpenState();
+
+    assert.deepEqual(state.snapshot(), {
+      attempted: false,
+      lastError: null,
+      lastPhase: null,
+    });
+  });
+
+  test("tracks attempts and open errors", () => {
+    const state = createDbOpenState();
+    const error = new Error("cannot open");
+
+    state.markAttempted();
+    state.recordError("open", error);
+
+    assert.equal(state.snapshot().attempted, true);
+    assert.equal(state.snapshot().lastError, error);
+    assert.equal(state.snapshot().lastPhase, "open");
+  });
+
+  test("normalizes non-Error values and clears errors without clearing attempts", () => {
+    const state = createDbOpenState();
+
+    state.markAttempted();
+    state.recordError("initSchema", "schema failed");
+    state.clearError();
+
+    assert.equal(state.snapshot().attempted, true);
+    assert.equal(state.snapshot().lastError, null);
+    assert.equal(state.snapshot().lastPhase, null);
+  });
+
+  test("reset clears attempt and error state", () => {
+    const state = createDbOpenState();
+
+    state.markAttempted();
+    state.recordError("vacuum-recovery", "vacuum failed");
+    state.reset();
+
+    assert.deepEqual(state.snapshot(), {
+      attempted: false,
+      lastError: null,
+      lastPhase: null,
+    });
+  });
+});

package/src/resources/extensions/gsd/tests/db-provider.test.ts

@@ -0,0 +1,105 @@
+// Project/App: GSD-2
+// File Purpose: Tests for SQLite provider loading and fallback behavior.
+
+import { describe, test } from "node:test";
+import assert from "node:assert/strict";
+import { createSqliteProviderLoader, type SqliteProviderDeps } from "../db-provider.ts";
+
+class FakeNodeDatabase {
+  readonly path: string;
+
+  constructor(path: string) {
+    this.path = path;
+  }
+}
+
+class FakeBetterDatabase {
+  readonly path: string;
+
+  constructor(path: string) {
+    this.path = path;
+  }
+}
+
+function createDeps(overrides: Partial<SqliteProviderDeps> = {}): SqliteProviderDeps & { stderr: string[] } {
+  const stderr: string[] = [];
+  return {
+    requireModule(id: string): unknown {
+      if (id === "node:sqlite") return { DatabaseSync: FakeNodeDatabase };
+      throw new Error(`unexpected module: ${id}`);
+    },
+    suppressSqliteWarning(): void {},
+    nodeVersion: "22.0.0",
+    writeStderr(message: string): void {
+      stderr.push(message);
+    },
+    stderr,
+    ...overrides,
+  };
+}
+
+describe("db-provider", () => {
+  test("loads node:sqlite first and opens raw databases with it", () => {
+    const loader = createSqliteProviderLoader(createDeps());
+
+    const rawDb = loader.openRaw("/tmp/gsd-node.db");
+
+    assert.equal(loader.getProviderName(), "node:sqlite");
+    assert.ok(rawDb instanceof FakeNodeDatabase);
+    assert.equal((rawDb as FakeNodeDatabase).path, "/tmp/gsd-node.db");
+  });
+
+  test("falls back to better-sqlite3 when node:sqlite is unavailable", () => {
+    const loader = createSqliteProviderLoader(createDeps({
+      requireModule(id: string): unknown {
+        if (id === "node:sqlite") throw new Error("node sqlite unavailable");
+        if (id === "better-sqlite3") return FakeBetterDatabase;
+        throw new Error(`unexpected module: ${id}`);
+      },
+    }));
+
+    const rawDb = loader.openRaw("/tmp/gsd-better.db");
+
+    assert.equal(loader.getProviderName(), "better-sqlite3");
+    assert.ok(rawDb instanceof FakeBetterDatabase);
+    assert.equal((rawDb as FakeBetterDatabase).path, "/tmp/gsd-better.db");
+  });
+
+  test("reports provider unavailability with a Node version hint below Node 22", () => {
+    const deps = createDeps({
+      requireModule(): unknown {
+        throw new Error("unavailable");
+      },
+      nodeVersion: "20.11.1",
+    });
+    const loader = createSqliteProviderLoader(deps);
+
+    assert.equal(loader.openRaw("/tmp/gsd-none.db"), null);
+
+    assert.equal(loader.getProviderName(), null);
+    assert.equal(deps.stderr.length, 1);
+    assert.match(deps.stderr[0], /No SQLite provider available/);
+    assert.match(deps.stderr[0], /Node >= 22\.0\.0/);
+  });
+
+  test("opens better-sqlite3 fallback without committing it until requested", () => {
+    const loader = createSqliteProviderLoader(createDeps({
+      requireModule(id: string): unknown {
+        if (id === "node:sqlite") return { DatabaseSync: FakeNodeDatabase };
+        if (id === "better-sqlite3") return { default: FakeBetterDatabase };
+        throw new Error(`unexpected module: ${id}`);
+      },
+    }));
+
+    loader.load();
+    const fallback = loader.tryOpenBetterSqliteFallback("/tmp/gsd-fallback.db");
+
+    assert.equal(loader.getProviderName(), "node:sqlite");
+    assert.ok(fallback);
+    assert.ok(fallback.rawDb instanceof FakeBetterDatabase);
+    assert.equal((fallback.rawDb as FakeBetterDatabase).path, "/tmp/gsd-fallback.db");
+
+    loader.commitFallback(fallback);
+    assert.equal(loader.getProviderName(), "better-sqlite3");
+  });
+});

package/src/resources/extensions/gsd/tests/db-runtime-kv-schema.test.ts

@@ -0,0 +1,37 @@
+// Project/App: GSD-2
+// File Purpose: Tests for runtime_kv schema helper.
+
+import { describe, test } from "node:test";
+import assert from "node:assert/strict";
+import { createRuntimeKvTableV25 } from "../db-runtime-kv-schema.ts";
+import type { DbAdapter, DbStatement } from "../db-adapter.ts";
+
+class FakeAdapter implements DbAdapter {
+  readonly execCalls: string[] = [];
+
+  exec(sql: string): void {
+    this.execCalls.push(sql);
+  }
+
+  prepare(): DbStatement {
+    throw new Error("prepare is not used by runtime_kv schema tests");
+  }
+
+  close(): void {}
+}
+
+describe("db-runtime-kv-schema", () => {
+  test("creates the runtime_kv table with soft-state scope key columns", () => {
+    const db = new FakeAdapter();
+
+    createRuntimeKvTableV25(db);
+
+    assert.equal(db.execCalls.length, 1);
+    assert.match(db.execCalls[0], /CREATE TABLE IF NOT EXISTS runtime_kv/);
+    assert.match(db.execCalls[0], /scope TEXT NOT NULL/);
+    assert.match(db.execCalls[0], /scope_id TEXT NOT NULL DEFAULT ''/);
+    assert.match(db.execCalls[0], /key TEXT NOT NULL/);
+    assert.match(db.execCalls[0], /value_json TEXT NOT NULL/);
+    assert.match(db.execCalls[0], /PRIMARY KEY \(scope, scope_id, key\)/);
+  });
+});

package/src/resources/extensions/gsd/tests/db-schema-metadata.test.ts

@@ -0,0 +1,115 @@
+// Project/App: GSD-2
+// File Purpose: Tests for SQLite schema metadata helpers.
+
+import { describe, test } from "node:test";
+import assert from "node:assert/strict";
+import { columnExists, ensureColumn, getCurrentSchemaVersion, indexExists, recordSchemaVersion } from "../db-schema-metadata.ts";
+import type { DbAdapter, DbStatement } from "../db-adapter.ts";
+
+class FakeStatement implements DbStatement {
+  private readonly getResult: Record<string, unknown> | undefined;
+  private readonly allResult: Record<string, unknown>[];
+  private readonly onRun: ((params: unknown[]) => void) | undefined;
+
+  constructor(
+    getResult: Record<string, unknown> | undefined,
+    allResult: Record<string, unknown>[],
+    onRun?: (params: unknown[]) => void,
+  ) {
+    this.getResult = getResult;
+    this.allResult = allResult;
+    this.onRun = onRun;
+  }
+
+  run(...params: unknown[]): unknown {
+    this.onRun?.(params);
+    return undefined;
+  }
+
+  get(): Record<string, unknown> | undefined {
+    return this.getResult;
+  }
+
+  all(): Record<string, unknown>[] {
+    return this.allResult;
+  }
+}
+
+class FakeAdapter implements DbAdapter {
+  readonly execCalls: string[] = [];
+  readonly runCalls: unknown[][] = [];
+  readonly preparedSql: string[] = [];
+  indexNames = new Set<string>();
+  tableColumns = new Map<string, string[]>();
+  currentVersion: number | undefined = undefined;
+
+  exec(sql: string): void {
+    this.execCalls.push(sql);
+  }
+
+  prepare(sql: string): DbStatement {
+    this.preparedSql.push(sql);
+    if (sql.includes("sqlite_master")) {
+      return new FakeStatement(this.indexNames.size > 0 ? { present: 1 } : undefined, []);
+    }
+    if (sql.includes("SELECT MAX(version)")) {
+      return new FakeStatement(this.currentVersion === undefined ? undefined : { v: this.currentVersion }, []);
+    }
+    if (sql.includes("INSERT INTO schema_version")) {
+      return new FakeStatement(undefined, [], (params) => {
+        this.runCalls.push(params);
+      });
+    }
+    const tableMatch = /^PRAGMA table_info\(([^)]+)\)$/.exec(sql);
+    if (tableMatch) {
+      const columns = this.tableColumns.get(tableMatch[1]) ?? [];
+      return new FakeStatement(undefined, columns.map((name) => ({ name })));
+    }
+    return new FakeStatement(undefined, []);
+  }
+
+  close(): void {}
+}
+
+describe("db-schema-metadata", () => {
+  test("indexExists returns true when sqlite_master has a row", () => {
+    const db = new FakeAdapter();
+    db.indexNames.add("idx_present");
+
+    assert.equal(indexExists(db, "idx_present"), true);
+  });
+
+  test("columnExists reads table_info rows", () => {
+    const db = new FakeAdapter();
+    db.tableColumns.set("tasks", ["id", "status"]);
+
+    assert.equal(columnExists(db, "tasks", "status"), true);
+    assert.equal(columnExists(db, "tasks", "missing"), false);
+  });
+
+  test("ensureColumn executes ddl only when the column is missing", () => {
+    const db = new FakeAdapter();
+    db.tableColumns.set("tasks", ["id"]);
+
+    ensureColumn(db, "tasks", "status", "ALTER TABLE tasks ADD COLUMN status TEXT");
+    ensureColumn(db, "tasks", "id", "ALTER TABLE tasks ADD COLUMN id TEXT");
+
+    assert.deepEqual(db.execCalls, ["ALTER TABLE tasks ADD COLUMN status TEXT"]);
+  });
+
+  test("getCurrentSchemaVersion returns zero when no version row exists", () => {
+    const db = new FakeAdapter();
+
+    assert.equal(getCurrentSchemaVersion(db), 0);
+  });
+
+  test("records schema version rows with timestamps", () => {
+    const db = new FakeAdapter();
+
+    recordSchemaVersion(db, 26);
+
+    assert.equal(db.runCalls.length, 1);
+    assert.equal((db.runCalls[0][0] as Record<string, unknown>)[":version"], 26);
+    assert.equal(typeof (db.runCalls[0][0] as Record<string, unknown>)[":applied_at"], "string");
+  });
+});

package/src/resources/extensions/gsd/tests/db-task-slice-rows.test.ts

@@ -0,0 +1,128 @@
+// Project/App: GSD-2
+// File Purpose: Tests for task and slice database row mappers.
+
+import { describe, test } from "node:test";
+import assert from "node:assert/strict";
+import { parseTaskArrayColumn, rowToSlice, rowToTask } from "../db-task-slice-rows.ts";
+
+describe("db-task-slice-rows", () => {
+  test("parseTaskArrayColumn handles JSON arrays, scalar JSON, raw arrays, and legacy CSV", () => {
+    assert.deepEqual(parseTaskArrayColumn('["a.ts","b.ts"]'), ["a.ts", "b.ts"]);
+    assert.deepEqual(parseTaskArrayColumn('"single.ts"'), ["single.ts"]);
+    assert.deepEqual(parseTaskArrayColumn(["a.ts", 42, "b.ts"]), ["a.ts", "b.ts"]);
+    assert.deepEqual(parseTaskArrayColumn(" a.ts, b.ts ,, "), ["a.ts", "b.ts"]);
+    assert.deepEqual(parseTaskArrayColumn(""), []);
+    assert.deepEqual(parseTaskArrayColumn(null), []);
+  });
+
+  test("rowToSlice maps optional DB columns to stable defaults", () => {
+    const slice = rowToSlice({
+      milestone_id: "M001",
+      id: "S01",
+      title: "Build the thing",
+      status: "active",
+      risk: "medium",
+      depends: '["S00"]',
+      created_at: "2026-05-04T00:00:00.000Z",
+    });
+
+    assert.deepEqual(slice, {
+      milestone_id: "M001",
+      id: "S01",
+      title: "Build the thing",
+      status: "active",
+      risk: "medium",
+      depends: ["S00"],
+      demo: "",
+      created_at: "2026-05-04T00:00:00.000Z",
+      completed_at: null,
+      full_summary_md: "",
+      full_uat_md: "",
+      goal: "",
+      success_criteria: "",
+      proof_level: "",
+      integration_closure: "",
+      observability_impact: "",
+      sequence: 0,
+      replan_triggered_at: null,
+      is_sketch: 0,
+      sketch_scope: "",
+    });
+  });
+
+  test("rowToTask maps planning and escalation columns", () => {
+    const task = rowToTask({
+      milestone_id: "M001",
+      slice_id: "S01",
+      id: "T01",
+      title: "Extract row mapper",
+      status: "done",
+      one_liner: "Mapper extraction",
+      narrative: "Moved row shaping",
+      verification_result: "passed",
+      duration: "5m",
+      completed_at: "2026-05-04T00:00:00.000Z",
+      blocker_discovered: 1,
+      deviations: "",
+      known_issues: "",
+      key_files: "a.ts,b.ts",
+      key_decisions: '["D001"]',
+      full_summary_md: "summary",
+      description: "description",
+      estimate: "small",
+      files: '["src/a.ts"]',
+      verify: "npm test",
+      inputs: '"input.md"',
+      expected_output: "result.md,report.md",
+      observability_impact: "none",
+      full_plan_md: "plan",
+      sequence: 3,
+      blocker_source: "test",
+      escalation_pending: 1,
+      escalation_awaiting_review: 0,
+      escalation_artifact_path: "/tmp/escalation.md",
+      escalation_override_applied_at: "2026-05-04T00:01:00.000Z",
+    });
+
+    assert.equal(task.blocker_discovered, true);
+    assert.deepEqual(task.key_files, ["a.ts", "b.ts"]);
+    assert.deepEqual(task.key_decisions, ["D001"]);
+    assert.deepEqual(task.files, ["src/a.ts"]);
+    assert.deepEqual(task.inputs, ["input.md"]);
+    assert.deepEqual(task.expected_output, ["result.md", "report.md"]);
+    assert.equal(task.sequence, 3);
+    assert.equal(task.escalation_pending, 1);
+    assert.equal(task.escalation_artifact_path, "/tmp/escalation.md");
+  });
+
+  test("rowToTask defaults optional planning and escalation fields", () => {
+    const task = rowToTask({
+      milestone_id: "M001",
+      slice_id: "S01",
+      id: "T01",
+      title: "Pending",
+      status: "pending",
+      one_liner: "",
+      narrative: "",
+      verification_result: "",
+      duration: "",
+      blocker_discovered: 0,
+      deviations: "",
+      known_issues: "",
+      key_files: "",
+      key_decisions: "",
+      full_summary_md: "",
+    });
+
+    assert.equal(task.completed_at, null);
+    assert.deepEqual(task.files, []);
+    assert.deepEqual(task.inputs, []);
+    assert.deepEqual(task.expected_output, []);
+    assert.equal(task.sequence, 0);
+    assert.equal(task.blocker_source, "");
+    assert.equal(task.escalation_pending, 0);
+    assert.equal(task.escalation_awaiting_review, 0);
+    assert.equal(task.escalation_artifact_path, null);
+    assert.equal(task.escalation_override_applied_at, null);
+  });
+});