@opengsd/gsd-pi 1.10.0 → 1.11.0

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

@@ -0,0 +1,459 @@
+// Project/App: gsd-pi
+// File Purpose: Executable contract for the additive v31 canonical database foundation.
+
+import assert from "node:assert/strict";
+import { spawnSync } from "node:child_process";
+import { copyFileSync, mkdtempSync, rmSync } from "node:fs";
+import { createRequire } from "node:module";
+import { tmpdir } from "node:os";
+import { dirname, join } from "node:path";
+import { afterEach, test } from "node:test";
+import { pathToFileURL } from "node:url";
+
+import {
+  SCHEMA_VERSION,
+  _getAdapter,
+  _setMigrationFaultForTest,
+  closeDatabase,
+  openDatabase,
+} from "../gsd-db.ts";
+
+const require = createRequire(import.meta.url);
+const tempDirs = new Set<string>();
+
+interface RawDb {
+  exec(sql: string): void;
+  prepare(sql: string): {
+    get(...args: unknown[]): Record<string, unknown> | undefined;
+    all(...args: unknown[]): Array<Record<string, unknown>>;
+  };
+  close(): void;
+}
+
+function openRawDatabase(path: string): RawDb {
+  const sqlite = require("node:sqlite") as { DatabaseSync: new (path: string) => RawDb };
+  return new sqlite.DatabaseSync(path);
+}
+
+function createDatabasePath(): string {
+  const dir = mkdtempSync(join(tmpdir(), "gsd-canonical-foundation-"));
+  tempDirs.add(dir);
+  return join(dir, "gsd.db");
+}
+
+function tableExists(db: RawDb, table: string): boolean {
+  return Boolean(
+    db.prepare("SELECT 1 AS present FROM sqlite_master WHERE type = 'table' AND name = ?").get(table),
+  );
+}
+
+function maxSchemaVersion(db: RawDb): number {
+  return Number(db.prepare("SELECT MAX(version) AS version FROM schema_version").get()?.version);
+}
+
+function rewindToV30(dbPath: string): void {
+  assert.equal(openDatabase(dbPath), true);
+  closeDatabase();
+
+  const raw = openRawDatabase(dbPath);
+  try {
+    raw.exec(`
+      DROP TABLE IF EXISTS workflow_outbox;
+      DROP TABLE IF EXISTS workflow_domain_events;
+      DROP TABLE IF EXISTS workflow_operations;
+      DROP TABLE IF EXISTS project_authority;
+      DELETE FROM schema_version;
+      INSERT INTO schema_version (version, applied_at) VALUES (30, '2026-07-12T00:00:00.000Z');
+      INSERT OR IGNORE INTO milestones (id, title, status, created_at)
+      VALUES ('M-LEGACY', 'Preserved legacy milestone', 'active', '2026-07-12T00:00:00.000Z');
+      INSERT OR IGNORE INTO audit_events
+        (event_id, trace_id, category, type, ts, payload_json)
+      VALUES
+        ('audit-legacy', 'trace-legacy', 'workflow', 'legacy', '2026-07-12T00:00:00.000Z', '{"kept":true}');
+    `);
+  } finally {
+    raw.close();
+  }
+}
+
+function inspectFromFreshProcess(dbPath: string): Record<string, unknown> {
+  const moduleHref = pathToFileURL(
+    join(process.cwd(), "src/resources/extensions/gsd/gsd-db.ts"),
+  ).href;
+  const script = [
+    `import { openDatabase, closeDatabase, _getAdapter } from ${JSON.stringify(moduleHref)};`,
+    "const path = process.argv[1];",
+    "if (!openDatabase(path)) throw new Error('database open failed');",
+    "const db = _getAdapter();",
+    "const version = db.prepare('SELECT MAX(version) AS value FROM schema_version').get().value;",
+    "const authority = db.prepare('SELECT project_id, revision, authority_epoch FROM project_authority').get();",
+    "const legacy = db.prepare(\"SELECT title FROM milestones WHERE id = 'M-LEGACY'\").get();",
+    "console.log(JSON.stringify({ version, authority, legacy }));",
+    "closeDatabase();",
+  ].join("\n");
+  const env = { ...process.env };
+  delete env.NODE_TEST_CONTEXT;
+  const child = spawnSync(
+    process.execPath,
+    [
+      "--import",
+      "./src/resources/extensions/gsd/tests/resolve-ts.mjs",
+      "--experimental-strip-types",
+      "--input-type=module",
+      "-e",
+      script,
+      dbPath,
+    ],
+    { cwd: process.cwd(), encoding: "utf8", env, timeout: 30_000 },
+  );
+  assert.equal(child.status, 0, child.stderr || child.stdout);
+  return JSON.parse(child.stdout) as Record<string, unknown>;
+}
+
+afterEach(() => {
+  _setMigrationFaultForTest(false);
+  closeDatabase();
+  for (const dir of tempDirs) rmSync(dir, { recursive: true, force: true });
+  tempDirs.clear();
+});
+
+test("fresh database creates the v31 authority root and linked operation journal", () => {
+  assert.equal(SCHEMA_VERSION, 31);
+  const dbPath = createDatabasePath();
+  assert.equal(openDatabase(dbPath), true);
+  const db = _getAdapter();
+  assert.ok(db);
+
+  const authority = db.prepare(`
+    SELECT singleton, project_id, project_root_realpath, revision, authority_epoch
+    FROM project_authority
+  `).get();
+  assert.deepEqual(
+    {
+      singleton: authority?.singleton,
+      projectIdLength: String(authority?.project_id ?? "").length,
+      root: authority?.project_root_realpath,
+      revision: authority?.revision,
+      epoch: authority?.authority_epoch,
+    },
+    { singleton: 1, projectIdLength: 32, root: "", revision: 0, epoch: 0 },
+  );
+
+  assert.throws(
+    () => db.exec("INSERT INTO project_authority (singleton, project_id) VALUES (2, 'second')"),
+    /CHECK constraint failed/i,
+  );
+  assert.throws(
+    () => db.exec("UPDATE project_authority SET revision = -1 WHERE singleton = 1"),
+    /CHECK constraint failed/i,
+  );
+  assert.throws(
+    () => db.exec("UPDATE project_authority SET authority_epoch = -1 WHERE singleton = 1"),
+    /CHECK constraint failed/i,
+  );
+
+  db.exec(`
+    INSERT INTO workflow_operations (
+      operation_id, project_id, operation_type, idempotency_key,
+      expected_revision, resulting_revision,
+      expected_authority_epoch, resulting_authority_epoch,
+      actor_type, actor_id, source_transport, request_hash, created_at
+    )
+    SELECT
+      'op-1', project_id, 'test.operation', 'idem-1',
+      0, 1, 0, 0, 'agent', 'test-agent', 'test', 'request-1', '2026-07-12T00:00:01.000Z'
+    FROM project_authority WHERE singleton = 1;
+
+    INSERT INTO workflow_domain_events (
+      event_id, operation_id, event_index, project_id, project_revision,
+      authority_epoch, event_type, entity_type, entity_id, payload_json, created_at
+    )
+    SELECT
+      'event-1', 'op-1', 0, project_id, 1,
+      0, 'test.started', 'project', project_id, '{"step":1}', '2026-07-12T00:00:02.000Z'
+    FROM project_authority WHERE singleton = 1;
+
+    INSERT INTO workflow_domain_events (
+      event_id, operation_id, event_index, project_id, project_revision,
+      authority_epoch, event_type, entity_type, entity_id, caused_by_event_id,
+      payload_json, created_at
+    )
+    SELECT
+      'event-2', 'op-1', 1, project_id, 1,
+      0, 'test.finished', 'project', project_id, 'event-1',
+      '{"step":2}', '2026-07-12T00:00:03.000Z'
+    FROM project_authority WHERE singleton = 1;
+
+    INSERT INTO workflow_outbox (event_id, destination, available_at)
+    VALUES ('event-2', 'projection', '2026-07-12T00:00:04.000Z');
+  `);
+
+  const chain = db.prepare(`
+    SELECT
+      p.revision AS authority_revision,
+      o.expected_revision,
+      o.resulting_revision,
+      COUNT(DISTINCT e.event_id) AS event_count,
+      COUNT(DISTINCT x.outbox_id) AS outbox_count
+    FROM project_authority p
+    JOIN workflow_operations o ON o.project_id = p.project_id
+    JOIN workflow_domain_events e ON e.operation_id = o.operation_id
+    LEFT JOIN workflow_outbox x ON x.event_id = e.event_id
+    GROUP BY p.revision, o.expected_revision, o.resulting_revision
+  `).get();
+  assert.deepEqual(chain, {
+    authority_revision: 0,
+    expected_revision: 0,
+    resulting_revision: 1,
+    event_count: 2,
+    outbox_count: 1,
+  });
+
+  assert.throws(
+    () => db.exec(`
+      INSERT INTO workflow_operations (
+        operation_id, project_id, operation_type, idempotency_key,
+        expected_revision, resulting_revision,
+        expected_authority_epoch, resulting_authority_epoch,
+        actor_type, source_transport, request_hash, created_at
+      )
+      SELECT 'op-duplicate', project_id, 'test.operation', 'idem-1', 1, 2, 0, 0,
+             'agent', 'test', 'request-2', '2026-07-12T00:00:05.000Z'
+      FROM project_authority WHERE singleton = 1
+    `),
+    /UNIQUE constraint failed/i,
+  );
+  assert.throws(
+    () => db.exec(`
+      INSERT INTO workflow_operations (
+        operation_id, project_id, operation_type, idempotency_key,
+        expected_revision, resulting_revision,
+        expected_authority_epoch, resulting_authority_epoch,
+        actor_type, source_transport, request_hash, created_at
+      )
+      SELECT 'op-same-revision', project_id, 'test.operation', 'idem-2', 0, 1, 0, 0,
+             'agent', 'test', 'request-2', '2026-07-12T00:00:05.000Z'
+      FROM project_authority WHERE singleton = 1
+    `),
+    /UNIQUE constraint failed/i,
+  );
+  assert.throws(
+    () => db.exec(`
+      INSERT INTO workflow_domain_events (
+        event_id, operation_id, event_index, project_id, project_revision,
+        authority_epoch, event_type, entity_type, entity_id, payload_json, created_at
+      )
+      SELECT 'event-duplicate-index', 'op-1', 1, project_id, 1, 0,
+             'test.duplicate', 'project', project_id, '{}', '2026-07-12T00:00:06.000Z'
+      FROM project_authority WHERE singleton = 1
+    `),
+    /UNIQUE constraint failed/i,
+  );
+  assert.throws(
+    () => db.exec(`
+      INSERT INTO workflow_domain_events (
+        event_id, operation_id, event_index, project_id, project_revision,
+        authority_epoch, event_type, entity_type, entity_id, payload_json, created_at
+      )
+      SELECT 'event-wrong-revision', 'op-1', 2, project_id, 2, 0,
+             'test.wrong-revision', 'project', project_id, '{}', '2026-07-12T00:00:06.000Z'
+      FROM project_authority WHERE singleton = 1
+    `),
+    /FOREIGN KEY constraint failed/i,
+  );
+  assert.throws(
+    () => db.exec(`
+      INSERT INTO workflow_outbox (event_id, destination, available_at)
+      VALUES ('missing-event', 'projection', '2026-07-12T00:00:07.000Z')
+    `),
+    /FOREIGN KEY constraint failed/i,
+  );
+  assert.throws(
+    () => db.exec(`
+      INSERT INTO workflow_outbox (event_id, destination, available_at)
+      VALUES ('event-2', 'projection', '2026-07-12T00:00:08.000Z')
+    `),
+    /UNIQUE constraint failed/i,
+  );
+});
+
+test("operations record the resulting authority epoch used by their events", () => {
+  const dbPath = createDatabasePath();
+  assert.equal(openDatabase(dbPath), true);
+  const db = _getAdapter();
+  assert.ok(db);
+
+  db.exec(`
+    INSERT INTO workflow_operations (
+      operation_id, project_id, operation_type, idempotency_key,
+      expected_revision, resulting_revision,
+      expected_authority_epoch, resulting_authority_epoch,
+      actor_type, source_transport, request_hash, created_at
+    )
+    SELECT 'op-cutover', project_id, 'authority.cutover', 'idem-cutover',
+           0, 1, 0, 1, 'agent', 'test', 'request-cutover', '2026-07-12T00:00:01.000Z'
+    FROM project_authority WHERE singleton = 1;
+
+    INSERT INTO workflow_domain_events (
+      event_id, operation_id, event_index, project_id, project_revision,
+      authority_epoch, event_type, entity_type, entity_id, payload_json, created_at
+    )
+    SELECT 'event-cutover', 'op-cutover', 0, project_id, 1, 1,
+           'authority.cutover', 'project', project_id, '{}', '2026-07-12T00:00:02.000Z'
+    FROM project_authority WHERE singleton = 1;
+
+    INSERT INTO workflow_operations (
+      operation_id, project_id, operation_type, idempotency_key,
+      expected_revision, resulting_revision,
+      expected_authority_epoch, resulting_authority_epoch,
+      actor_type, source_transport, request_hash, created_at
+    )
+    SELECT 'op-unchanged-epoch', project_id, 'test.operation', 'idem-unchanged-epoch',
+           1, 2, 1, 1, 'agent', 'test', 'request-unchanged', '2026-07-12T00:00:03.000Z'
+    FROM project_authority WHERE singleton = 1;
+  `);
+
+  assert.throws(
+    () => db.exec(`
+      INSERT INTO workflow_domain_events (
+        event_id, operation_id, event_index, project_id, project_revision,
+        authority_epoch, event_type, entity_type, entity_id, payload_json, created_at
+      )
+      SELECT 'event-stale-epoch', 'op-cutover', 1, project_id, 1, 0,
+             'authority.stale', 'project', project_id, '{}', '2026-07-12T00:00:04.000Z'
+      FROM project_authority WHERE singleton = 1
+    `),
+    /FOREIGN KEY constraint failed/i,
+  );
+  assert.throws(
+    () => db.exec(`
+      INSERT INTO workflow_operations (
+        operation_id, project_id, operation_type, idempotency_key,
+        expected_revision, resulting_revision,
+        expected_authority_epoch, resulting_authority_epoch,
+        actor_type, source_transport, request_hash, created_at
+      )
+      SELECT 'op-epoch-jump', project_id, 'authority.cutover', 'idem-epoch-jump',
+             2, 3, 1, 3, 'agent', 'test', 'request-jump', '2026-07-12T00:00:05.000Z'
+      FROM project_authority WHERE singleton = 1
+    `),
+    /CHECK constraint failed/i,
+  );
+});
+
+test("domain events reject updates and deletes", () => {
+  const dbPath = createDatabasePath();
+  assert.equal(openDatabase(dbPath), true);
+  const db = _getAdapter();
+  assert.ok(db);
+
+  db.exec(`
+    INSERT INTO workflow_operations (
+      operation_id, project_id, operation_type, idempotency_key,
+      expected_revision, resulting_revision,
+      expected_authority_epoch, resulting_authority_epoch,
+      actor_type, source_transport, request_hash, created_at
+    )
+    SELECT 'op-immutable', project_id, 'test.operation', 'idem-immutable',
+           0, 1, 0, 0, 'agent', 'test', 'request-immutable', '2026-07-12T00:00:01.000Z'
+    FROM project_authority WHERE singleton = 1;
+
+    INSERT INTO workflow_domain_events (
+      event_id, operation_id, event_index, project_id, project_revision,
+      authority_epoch, event_type, entity_type, entity_id, payload_json, created_at
+    )
+    SELECT 'event-immutable', 'op-immutable', 0, project_id, 1, 0,
+           'test.recorded', 'project', project_id, '{"original":true}', '2026-07-12T00:00:02.000Z'
+    FROM project_authority WHERE singleton = 1;
+  `);
+
+  assert.throws(
+    () => db.exec(`UPDATE workflow_domain_events SET payload_json = '{}' WHERE event_id = 'event-immutable'`),
+    /workflow domain events are immutable/i,
+  );
+  assert.throws(
+    () => db.exec(`DELETE FROM workflow_domain_events WHERE event_id = 'event-immutable'`),
+    /workflow domain events are immutable/i,
+  );
+});
+
+test("v30 upgrade preserves legacy rows and creates an independently healthy backup", () => {
+  const dbPath = createDatabasePath();
+  rewindToV30(dbPath);
+
+  assert.equal(openDatabase(dbPath), true);
+  closeDatabase();
+
+  let projectId = "";
+  const upgraded = openRawDatabase(dbPath);
+  try {
+    assert.equal(maxSchemaVersion(upgraded), 31);
+    assert.equal(tableExists(upgraded, "project_authority"), true);
+    assert.equal(upgraded.prepare("SELECT title FROM milestones WHERE id = 'M-LEGACY'").get()?.title, "Preserved legacy milestone");
+    assert.equal(upgraded.prepare("SELECT payload_json FROM audit_events WHERE event_id = 'audit-legacy'").get()?.payload_json, '{"kept":true}');
+    assert.equal(upgraded.prepare("PRAGMA quick_check").get()?.quick_check, "ok");
+    projectId = String(upgraded.prepare("SELECT project_id FROM project_authority").get()?.project_id);
+  } finally {
+    upgraded.close();
+  }
+
+  const backup = openRawDatabase(`${dbPath}.backup-v30`);
+  try {
+    assert.equal(maxSchemaVersion(backup), 30);
+    assert.equal(tableExists(backup, "project_authority"), false);
+    assert.equal(backup.prepare("SELECT title FROM milestones WHERE id = 'M-LEGACY'").get()?.title, "Preserved legacy milestone");
+    assert.equal(backup.prepare("PRAGMA quick_check").get()?.quick_check, "ok");
+  } finally {
+    backup.close();
+  }
+
+  const reopened = inspectFromFreshProcess(dbPath);
+  assert.deepEqual(reopened, {
+    version: 31,
+    authority: { project_id: projectId, revision: 0, authority_epoch: 0 },
+    legacy: { title: "Preserved legacy milestone" },
+  });
+
+  const restoredPath = join(dirname(dbPath), "restored.db");
+  copyFileSync(`${dbPath}.backup-v30`, restoredPath);
+  const restored = inspectFromFreshProcess(restoredPath);
+  assert.equal(restored.version, 31);
+  assert.deepEqual(restored.legacy, { title: "Preserved legacy milestone" });
+  assert.deepEqual(
+    Object.fromEntries(
+      Object.entries(restored.authority as Record<string, unknown>).filter(([key]) => key !== "project_id"),
+    ),
+    { revision: 0, authority_epoch: 0 },
+  );
+});
+
+test("faulted v30 migration leaves no v31 state and retries cleanly", () => {
+  const dbPath = createDatabasePath();
+  rewindToV30(dbPath);
+
+  _setMigrationFaultForTest(true);
+  assert.throws(() => openDatabase(dbPath), /migration fault injected/);
+  _setMigrationFaultForTest(false);
+
+  const rolledBack = openRawDatabase(dbPath);
+  try {
+    assert.equal(maxSchemaVersion(rolledBack), 30);
+    assert.equal(tableExists(rolledBack, "project_authority"), false);
+    assert.equal(tableExists(rolledBack, "workflow_operations"), false);
+    assert.equal(tableExists(rolledBack, "workflow_domain_events"), false);
+    assert.equal(tableExists(rolledBack, "workflow_outbox"), false);
+  } finally {
+    rolledBack.close();
+  }
+
+  assert.equal(openDatabase(dbPath), true);
+  closeDatabase();
+  const retried = openRawDatabase(dbPath);
+  try {
+    assert.equal(maxSchemaVersion(retried), 31);
+    assert.equal(retried.prepare("SELECT COUNT(*) AS count FROM project_authority").get()?.count, 1);
+    assert.equal(retried.prepare("SELECT COUNT(*) AS count FROM milestones WHERE id = 'M-LEGACY'").get()?.count, 1);
+  } finally {
+    retried.close();
+  }
+});

package/src/resources/extensions/gsd/tests/db-engine-migrate-guards.test.ts

@@ -101,9 +101,9 @@ describe('db-engine migrate guards', () => {
       assert.ok(openDatabase(dbPath), 'fresh open should succeed');
       closeDatabase();
 
-      // Rewind the DB to v(SCHEMA_VERSION-1): stamp the prior version and drop
-      // the objects the last migration adds, so the re-run has real work to redo.
-      const startVersion = SCHEMA_VERSION - 2;
+      // Rewind to v28 and remove a v29 column so the multi-step migration has
+      // real work to redo even as later schema versions are added.
+      const startVersion = 28;
       const raw = openRawSqliteForTest(dbPath);
       raw.exec('DELETE FROM schema_version');
       raw.exec(`INSERT INTO schema_version (version, applied_at) VALUES (${startVersion}, '2026-01-01T00:00:00Z')`);

package/src/resources/extensions/gsd/tests/doctor-scope-db-unavailable.test.ts

@@ -206,6 +206,38 @@ test("checkEngineHealth ignores stale suffixed flat-phase duplicate when bare mi
   );
 });
 
+test("checkEngineHealth reads task checkboxes from the canonical milestone worktree", async (t) => {
+  const base = mkdtempSync(join(tmpdir(), "gsd-doctor-checkbox-worktree-"));
+  t.after(() => rmSync(base, { recursive: true, force: true }));
+
+  const gsdDir = join(base, ".gsd");
+  mkdirSync(gsdDir, { recursive: true });
+
+  openDatabase(join(gsdDir, "gsd.db"));
+  insertMilestone({ id: "M003", title: "Milestone", status: "active" });
+  insertSlice({ id: "S01", milestoneId: "M003", title: "Slice", status: "pending", risk: "low", depends: [], sequence: 1 });
+  insertTask({ id: "T03", milestoneId: "M003", sliceId: "S01", title: "Task", status: "complete", sequence: 1 });
+
+  const plan = await renderPlanFromDb(base, "M003", "S01");
+  const checkedPlan = readFileSync(plan.planPath, "utf-8");
+  writeFileSync(plan.planPath, checkedPlan.replace("- [x] **T03**:", "- [ ] **T03**:"), "utf-8");
+
+  const worktree = join(base, ".gsd-worktrees", "M003");
+  const worktreePlan = join(worktree, ".gsd", "phases", "03-milestone", "03-01-PLAN.md");
+  mkdirSync(join(worktree, ".gsd", "phases", "03-milestone"), { recursive: true });
+  writeFileSync(join(worktree, ".git"), `gitdir: ${join(base, ".git", "worktrees", "M003")}\n`);
+  writeFileSync(worktreePlan, checkedPlan, "utf-8");
+
+  const issues: any[] = [];
+  await checkEngineHealth(base, issues, []);
+
+  assert.deepEqual(
+    issues.filter((issue) => issue.code === "checkbox_db_status_divergence").map((issue) => issue.unitId),
+    [],
+    "the stale project-root PLAN must not compete with the live milestone worktree projection",
+  );
+});
+
 test("checkEngineHealth reads task checkboxes from the <tasks> block, not a stray line above it", async (t) => {
   const base = mkdtempSync(join(tmpdir(), "gsd-doctor-task-section-"));
   t.after(() => rmSync(base, { recursive: true, force: true }));
@@ -375,6 +407,38 @@ test("checkEngineHealth reports artifact rows whose files are missing on disk",
   assert.equal(missing.fixable, false);
 });
 
+test("checkEngineHealth resolves artifact rows through the canonical milestone worktree", async (t) => {
+  const base = mkdtempSync(join(tmpdir(), "gsd-doctor-artifact-worktree-"));
+  t.after(() => rmSync(base, { recursive: true, force: true }));
+
+  const gsdDir = join(base, ".gsd");
+  const artifactPath = "phases/03-milestone/03-01-PLAN.md";
+  const worktree = join(base, ".gsd-worktrees", "M003");
+  mkdirSync(gsdDir, { recursive: true });
+  mkdirSync(join(worktree, ".gsd", "phases", "03-milestone"), { recursive: true });
+  writeFileSync(join(worktree, ".git"), `gitdir: ${join(base, ".git", "worktrees", "M003")}\n`);
+  writeFileSync(join(worktree, ".gsd", artifactPath), "# Plan\n", "utf-8");
+
+  openDatabase(join(gsdDir, "gsd.db"));
+  insertArtifact({
+    path: artifactPath,
+    artifact_type: "PLAN",
+    milestone_id: "M003",
+    slice_id: "S01",
+    task_id: null,
+    full_content: "# Plan\n",
+  });
+
+  const issues: any[] = [];
+  await checkEngineHealth(base, issues, []);
+
+  assert.equal(
+    issues.some((issue) => issue.code === "artifact_file_missing" && issue.file === artifactPath),
+    false,
+    "worktree-local artifact rows must not be reported missing from the project root",
+  );
+});
+
 test("checkEngineHealth resolves escaped .gsd artifact rows against the project .gsd directory", async (t) => {
   const base = mkdtempSync(join(tmpdir(), "gsd-doctor-escaped-artifact-"));
   t.after(() => rmSync(base, { recursive: true, force: true }));

package/src/resources/extensions/gsd/tests/model-cost-table.test.ts

@@ -74,7 +74,8 @@ test("#2885: cost table includes openai-codex provider models", () => {
   const ids = BUNDLED_COST_TABLE.map(e => e.id);
   const codexModels = [
     "gpt-5.1", "gpt-5.1-codex-max", "gpt-5.1-codex-mini",
-    "gpt-5.2", "gpt-5.2-codex", "gpt-5.3-codex", "gpt-5.3-codex-spark", "gpt-5.4", "gpt-5.4-mini", "gpt-5.5", "gpt-5.6",
+    "gpt-5.2", "gpt-5.2-codex", "gpt-5.3-codex", "gpt-5.3-codex-spark", "gpt-5.4", "gpt-5.4-mini", "gpt-5.5",
+    "gpt-5.6-sol", "gpt-5.6-terra", "gpt-5.6-luna",
   ];
   for (const model of codexModels) {
     assert.ok(ids.includes(model), `cost table should include openai-codex model "${model}"`);
@@ -110,10 +111,24 @@ test("gpt-5.5 uses official OpenAI list pricing", () => {
   assert.equal(entry.updatedAt, "2026-04-23");
 });
 
-test("gpt-5.6 mirrors gpt-5.5 pricing until official pricing is published", () => {
-  const entry = lookupModelCost("gpt-5.6");
-  assert.ok(entry, "lookupModelCost should find gpt-5.6");
-  assert.equal(entry.inputPer1k, 0.005);
-  assert.equal(entry.outputPer1k, 0.03);
-  assert.equal(entry.updatedAt, "2026-07-08");
+test("gpt-5.6 bare alias is not treated as a real cost-table model", () => {
+  assert.equal(lookupModelCost("gpt-5.6"), undefined);
+});
+
+test("gpt-5.6 variants use published pricing", () => {
+  const sol = lookupModelCost("openai-codex/gpt-5.6-sol");
+  assert.ok(sol, "lookupModelCost should find gpt-5.6-sol");
+  assert.equal(sol.inputPer1k, 0.005);
+  assert.equal(sol.outputPer1k, 0.03);
+  assert.deepEqual(sol.tiers?.[0], { inputTokensAbove: 272000, inputPer1k: 0.01, outputPer1k: 0.045 });
+
+  const terra = lookupModelCost("gpt-5.6-terra");
+  assert.ok(terra, "lookupModelCost should find gpt-5.6-terra");
+  assert.equal(terra.inputPer1k, 0.0025);
+  assert.equal(terra.outputPer1k, 0.015);
+
+  const luna = lookupModelCost("gpt-5.6-luna");
+  assert.ok(luna, "lookupModelCost should find gpt-5.6-luna");
+  assert.equal(luna.inputPer1k, 0.001);
+  assert.equal(luna.outputPer1k, 0.006);
 });

package/src/resources/extensions/gsd/tests/model-isolation.test.ts

@@ -10,6 +10,7 @@ import assert from "node:assert/strict";
 import { mkdirSync, writeFileSync, rmSync, existsSync, readFileSync } from "node:fs";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
+import { isCustomProvider } from "../preferences-models.ts";
 
 // ─── Test helpers ─────────────────────────────────────────────────────────────
 
@@ -303,3 +304,57 @@ describe("custom provider session model overrides PREFERENCES.md (#4122)", () =>
   });
 });
 
+describe("custom provider detection (#801)", () => {
+  let originalGsdHome: string | undefined;
+  let tmpGsdHome: string;
+
+  beforeEach(() => {
+    originalGsdHome = process.env.GSD_HOME;
+    tmpGsdHome = makeTmpDir("gsd-home");
+    process.env.GSD_HOME = tmpGsdHome;
+  });
+
+  afterEach(() => {
+    if (originalGsdHome === undefined) {
+      delete process.env.GSD_HOME;
+    } else {
+      process.env.GSD_HOME = originalGsdHome;
+    }
+    try { rmSync(tmpGsdHome, { recursive: true, force: true }); } catch {}
+  });
+
+  it("detects extension-registered providers that are not declared in models.json", () => {
+    const registry = {
+      getAllWithDiscovered: () => [
+        { provider: "pi-llama-cpp" },
+      ],
+    };
+
+    assert.equal(isCustomProvider("pi-llama-cpp", registry), true,
+      "runtime providers outside the built-in catalog should count as custom");
+  });
+
+  it("does not treat built-in providers as custom just because they are in the registry", () => {
+    const registry = {
+      getAll: () => [
+        { provider: "claude-code" },
+      ],
+    };
+
+    assert.equal(isCustomProvider("claude-code", registry), false,
+      "built-in providers must still defer to PREFERENCES.md");
+  });
+
+  it("does not treat bundled external-CLI providers as custom", () => {
+    // claude-code/cursor-agent/google-gemini-cli/google-antigravity register at
+    // runtime (so they are absent from the generated @gsd/pi-ai catalog), but
+    // they are first-party built-ins that PREFERENCES.md can route to. They must
+    // never be classified as custom, otherwise auto-mode silently ignores
+    // PREFERENCES.md for the default provider.
+    for (const provider of ["cursor-agent", "google-gemini-cli", "google-antigravity"]) {
+      const registry = { getAll: () => [{ provider }] };
+      assert.equal(isCustomProvider(provider, registry), false,
+        `${provider} is a built-in CLI provider and must defer to PREFERENCES.md`);
+    }
+  });
+});

package/src/resources/extensions/gsd/tests/model-router.test.ts

@@ -900,7 +900,7 @@ test("#2885: openai-codex standard-tier models are recognized", () => {
 
 test("#2885: openai-codex heavy-tier models are recognized", () => {
   const config = { ...defaultRoutingConfig(), enabled: true };
-  const heavyModels = ["gpt-5", "gpt-5-pro", "gpt-5.1", "gpt-5.2", "gpt-5.2-codex", "gpt-5.3-codex", "gpt-5.4", "gpt-5.5", "gpt-5.6", "o4-mini", "o4-mini-deep-research"];
+  const heavyModels = ["gpt-5", "gpt-5-pro", "gpt-5.1", "gpt-5.2", "gpt-5.2-codex", "gpt-5.3-codex", "gpt-5.4", "gpt-5.5", "gpt-5.6-sol", "gpt-5.6-terra", "gpt-5.6-luna", "o4-mini", "o4-mini-deep-research"];
   for (const model of heavyModels) {
     const result = resolveModelForComplexity(
       makeClassification("heavy"),