gsd-pi 2.73.0-dev.e1c09f2 → 2.73.1-dev.06e4302

package/src/resources/extensions/gsd/tests/crash-handler-secondary.test.ts

@@ -0,0 +1,235 @@
+/**
+ * Regression tests for #3348 secondary issues — crash handler gaps surfaced after #3696
+ *
+ * 1. register-extension.ts: writeCrashLog writes to ~/.gsd/crash/ directory
+ * 2. register-extension.ts: _gsdRejectionGuard registered for unhandledRejection
+ * 3. register-extension.ts: _gsdEpipeGuard exits with code 1 for unrecoverable errors (no log-and-continue)
+ * 4. crash-recovery.ts: emitCrashRecoveredUnitEnd closes open unit-start journal entries
+ */
+
+import { describe, test } from 'node:test';
+import assert from 'node:assert/strict';
+import { existsSync, mkdirSync, readFileSync, readdirSync, rmSync } from 'node:fs';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+import { randomUUID } from 'node:crypto';
+import { fileURLToPath } from 'node:url';
+import { dirname } from 'node:path';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+function makeTmpBase(): string {
+  const base = join(tmpdir(), `gsd-test-${randomUUID()}`);
+  mkdirSync(join(base, '.gsd'), { recursive: true });
+  return base;
+}
+
+// ─── register-extension source assertions ────────────────────────────────────
+
+const registerExtSrc = readFileSync(
+  join(__dirname, '..', 'bootstrap', 'register-extension.ts'),
+  'utf-8',
+);
+
+describe('register-extension crash handler secondary fixes (#3348)', () => {
+  test('writeCrashLog is exported and writes a file to the crash directory', async () => {
+    // Dynamic import so GSD_HOME can be pointed at a temp dir without polluting ~/.gsd
+    const tmpHome = join(tmpdir(), `gsd-crash-test-${randomUUID()}`);
+    const origHome = process.env.GSD_HOME;
+    process.env.GSD_HOME = tmpHome;
+    try {
+      const { writeCrashLog } = await import('../bootstrap/crash-log.ts');
+      const err = new Error('test crash from secondary regression test');
+      writeCrashLog(err, 'uncaughtException');
+
+      const crashDir = join(tmpHome, 'crash');
+      assert.ok(existsSync(crashDir), 'crash directory should be created');
+
+      const logs = readdirSync(crashDir).filter((f) => f.endsWith('.log'));
+      assert.equal(logs.length, 1, 'exactly one crash log should be written');
+
+      const content = readFileSync(join(crashDir, logs[0]), 'utf-8');
+      assert.ok(content.includes('test crash from secondary regression test'), 'log should contain error message');
+      assert.ok(content.includes('uncaughtException'), 'log should identify the source');
+      assert.ok(content.includes('pid:'), 'log should include process pid');
+    } finally {
+      process.env.GSD_HOME = origHome;
+      rmSync(tmpHome, { recursive: true, force: true });
+    }
+  });
+
+  test('_gsdRejectionGuard is registered for unhandledRejection', () => {
+    assert.match(
+      registerExtSrc,
+      /_gsdRejectionGuard/,
+      '_gsdRejectionGuard handler should be defined',
+    );
+    assert.match(
+      registerExtSrc,
+      /unhandledRejection/,
+      'installEpipeGuard should register an unhandledRejection handler',
+    );
+  });
+
+  test('_gsdEpipeGuard calls process.exit(1) for unrecoverable errors, not log-and-continue', () => {
+    // The original #3696 fix replaced "throw err" with a log-and-continue.
+    // The secondary fix replaces that with writeCrashLog + process.exit(1).
+    assert.ok(
+      !registerExtSrc.includes('process.stderr.write(`[gsd] uncaught extension error (non-fatal)'),
+      '_gsdEpipeGuard should NOT log errors as non-fatal and continue',
+    );
+    assert.match(
+      registerExtSrc,
+      /process\.exit\(1\)/,
+      '_gsdEpipeGuard should call process.exit(1) for unrecoverable errors',
+    );
+  });
+
+  test('writeCrashLog never throws even when directory is unwritable', async () => {
+    const { writeCrashLog } = await import('../bootstrap/crash-log.ts');
+    const origHome = process.env.GSD_HOME;
+    // Point at a path that will fail to mkdir (e.g. a file that exists as non-dir)
+    const tmpFile = join(tmpdir(), `gsd-not-a-dir-${randomUUID()}`);
+    // Don't create it — mkdirSync with bad path should be caught internally
+    process.env.GSD_HOME = join(tmpFile, 'nested', 'deeply');
+    try {
+      // Should not throw
+      assert.doesNotThrow(() => {
+        writeCrashLog(new Error('should not throw'), 'test');
+      });
+    } finally {
+      process.env.GSD_HOME = origHome;
+    }
+  });
+});
+
+// ─── emitCrashRecoveredUnitEnd ────────────────────────────────────────────────
+
+describe('emitCrashRecoveredUnitEnd (#3348)', () => {
+  test('emits synthetic unit-end when unit-start has no matching unit-end', async () => {
+    const base = makeTmpBase();
+    try {
+      const { emitJournalEvent, queryJournal } = await import('../journal.ts');
+      const { emitCrashRecoveredUnitEnd } = await import('../crash-recovery.ts');
+
+      const flowId = randomUUID();
+      const unitStartSeq = 5;
+
+      // Emit a unit-start with no corresponding unit-end (simulating a crash)
+      emitJournalEvent(base, {
+        ts: new Date().toISOString(),
+        flowId,
+        seq: unitStartSeq,
+        eventType: 'unit-start',
+        data: { unitType: 'execute-task', unitId: 'M001/S01/T01' },
+      });
+
+      const lock = {
+        pid: 99999,
+        startedAt: new Date().toISOString(),
+        unitType: 'execute-task',
+        unitId: 'M001/S01/T01',
+        unitStartedAt: new Date().toISOString(),
+      };
+
+      emitCrashRecoveredUnitEnd(base, lock);
+
+      const events = queryJournal(base);
+      const ends = events.filter((e) => e.eventType === 'unit-end');
+      assert.equal(ends.length, 1, 'should emit exactly one unit-end');
+      assert.equal(ends[0].data?.unitId, 'M001/S01/T01');
+      assert.equal(ends[0].data?.status, 'crash-recovered');
+      assert.equal(ends[0].causedBy?.flowId, flowId);
+      assert.equal(ends[0].causedBy?.seq, unitStartSeq);
+      assert.ok(ends[0].seq > unitStartSeq, 'unit-end seq must be higher than unit-start seq');
+    } finally {
+      rmSync(base, { recursive: true, force: true });
+    }
+  });
+
+  test('is a no-op when unit-end was already emitted (e.g. hard timeout fired)', async () => {
+    const base = makeTmpBase();
+    try {
+      const { emitJournalEvent, queryJournal } = await import('../journal.ts');
+      const { emitCrashRecoveredUnitEnd } = await import('../crash-recovery.ts');
+
+      const flowId = randomUUID();
+      emitJournalEvent(base, {
+        ts: new Date().toISOString(),
+        flowId,
+        seq: 3,
+        eventType: 'unit-start',
+        data: { unitType: 'plan-slice', unitId: 'M001/S02' },
+      });
+      // Hard timeout already emitted a unit-end
+      emitJournalEvent(base, {
+        ts: new Date().toISOString(),
+        flowId,
+        seq: 4,
+        eventType: 'unit-end',
+        data: { unitType: 'plan-slice', unitId: 'M001/S02', status: 'cancelled' },
+        causedBy: { flowId, seq: 3 },
+      });
+
+      const lock = {
+        pid: 99999,
+        startedAt: new Date().toISOString(),
+        unitType: 'plan-slice',
+        unitId: 'M001/S02',
+        unitStartedAt: new Date().toISOString(),
+      };
+      emitCrashRecoveredUnitEnd(base, lock);
+
+      const ends = queryJournal(base).filter((e) => e.eventType === 'unit-end');
+      assert.equal(ends.length, 1, 'should not emit a duplicate unit-end');
+      assert.equal(ends[0].data?.status, 'cancelled', 'original unit-end should be preserved');
+    } finally {
+      rmSync(base, { recursive: true, force: true });
+    }
+  });
+
+  test('is a no-op for "starting" pseudo-units (bootstrap crash)', async () => {
+    const base = makeTmpBase();
+    try {
+      const { queryJournal } = await import('../journal.ts');
+      const { emitCrashRecoveredUnitEnd } = await import('../crash-recovery.ts');
+
+      const lock = {
+        pid: 99999,
+        startedAt: new Date().toISOString(),
+        unitType: 'starting',
+        unitId: 'bootstrap',
+        unitStartedAt: new Date().toISOString(),
+      };
+      emitCrashRecoveredUnitEnd(base, lock);
+
+      const events = queryJournal(base);
+      assert.equal(events.length, 0, 'should emit nothing for starting/bootstrap pseudo-units');
+    } finally {
+      rmSync(base, { recursive: true, force: true });
+    }
+  });
+
+  test('is a no-op when no unit-start exists in the journal', async () => {
+    const base = makeTmpBase();
+    try {
+      const { queryJournal } = await import('../journal.ts');
+      const { emitCrashRecoveredUnitEnd } = await import('../crash-recovery.ts');
+
+      const lock = {
+        pid: 99999,
+        startedAt: new Date().toISOString(),
+        unitType: 'execute-task',
+        unitId: 'M002/S01/T03',
+        unitStartedAt: new Date().toISOString(),
+      };
+      emitCrashRecoveredUnitEnd(base, lock);
+
+      const events = queryJournal(base);
+      assert.equal(events.length, 0, 'should emit nothing when there is no journal entry to close');
+    } finally {
+      rmSync(base, { recursive: true, force: true });
+    }
+  });
+});

package/src/resources/extensions/gsd/tests/derive-state-crossval.test.ts

@@ -351,8 +351,9 @@ skills_used: []
       const dbState = await deriveStateFromDb(base);
 
       assertStatesEqual(dbState, fileState, 'E-blocked');
-      assert.deepStrictEqual(dbState.phase, 'blocked', 'E-blocked: phase is blocked');
-      assert.ok(dbState.blockers.length > 0, 'E-blocked: has blockers');
+      // With partial-dep fallback, circular deps no longer block — fallback picks first eligible slice
+      assert.deepStrictEqual(dbState.phase, 'planning', 'E-blocked: phase is planning (fallback picks a slice)');
+      assert.ok(dbState.activeSlice !== null, 'E-blocked: activeSlice is set via fallback');
 
       closeDatabase();
     } finally {

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

@@ -616,9 +616,10 @@ describe('derive-state-db', async () => {
       invalidateStateCache();
       const dbState = await deriveStateFromDb(base);
 
-      assert.deepStrictEqual(dbState.phase, 'blocked', 'blocked-db: phase is blocked');
+      // With partial-dep fallback, circular deps no longer block — fallback picks first eligible slice
+      assert.deepStrictEqual(dbState.phase, 'planning', 'blocked-db: phase is planning (fallback picks a slice)');
       assert.deepStrictEqual(dbState.phase, fileState.phase, 'blocked-db: phase matches filesystem');
-      assert.ok(dbState.blockers.length > 0, 'blocked-db: has blockers');
+      assert.ok(dbState.activeSlice !== null, 'blocked-db: activeSlice is set via fallback');
 
       closeDatabase();
     } finally {

package/src/resources/extensions/gsd/tests/derive-state-helpers.test.ts

@@ -307,27 +307,87 @@ describe('derive-state-helpers', () => {
     }
   });
 
-  // ─── buildCompletenessSet: SUMMARY-on-disk marks complete ───────────
-  test('buildCompletenessSet: milestone with SUMMARY on disk treated as complete', async () => {
+  // ─── buildCompletenessSet: DB status is authoritative ──────────────
+  test('buildCompletenessSet: DB status=complete marks milestone complete', async () => {
     const base = createFixtureBase();
     try {
-      // M001 has summary on disk but DB status is still 'active'
       writeFile(base, 'milestones/M001/M001-ROADMAP.md', ROADMAP_CONTENT);
       writeFile(base, 'milestones/M001/M001-SUMMARY.md', '# M001 Summary\n\nDone.');
-      // M002 is the real active milestone
       writeFile(base, 'milestones/M002/M002-CONTEXT.md', '# M002\n\nActive.');
 
       openDatabase(':memory:');
-      insertMilestone({ id: 'M001', title: 'First', status: 'active' });
+      insertMilestone({ id: 'M001', title: 'First', status: 'complete' });
       insertMilestone({ id: 'M002', title: 'Second', status: 'active' });
 
       invalidateStateCache();
       const state = await deriveStateFromDb(base);
 
-      // M001 should be complete (summary on disk), M002 should be active
       const m1 = state.registry.find(e => e.id === 'M001');
-      assert.equal(m1?.status, 'complete', 'summary-disk: M001 marked complete via disk SUMMARY');
-      assert.equal(state.activeMilestone?.id, 'M002', 'summary-disk: M002 is active');
+      assert.equal(m1?.status, 'complete', 'DB status=complete → registry entry complete');
+      assert.equal(state.activeMilestone?.id, 'M002', 'M002 is the active milestone');
+    } finally {
+      closeDatabase();
+      cleanup(base);
+    }
+  });
+
+  // ─── Regression #4179: orphan SUMMARY must NOT flip DB-active milestone ───
+  // A crashed complete-milestone turn (or stale/manual SUMMARY.md) can leave
+  // a milestone SUMMARY on disk while the DB row still reads 'active'. The
+  // read-side of state derivation must NOT treat the orphan SUMMARY as a
+  // completion signal, or the auto-loop advances and merges work that was
+  // never actually finished (same failure class as #4175, read-side twin).
+  test('buildCompletenessSet (#4179): orphan SUMMARY on disk does not mark DB-active milestone complete', async () => {
+    const base = createFixtureBase();
+    try {
+      writeFile(base, 'milestones/M001/M001-ROADMAP.md', ROADMAP_CONTENT);
+      writeFile(base, 'milestones/M001/M001-SUMMARY.md', '# M001 Orphan Summary\n\nLeft over from crashed turn.');
+
+      openDatabase(':memory:');
+      insertMilestone({ id: 'M001', title: 'First', status: 'active' });
+      // Slice still in-flight — auto should resume, not merge.
+      insertSlice({ id: 'S01', milestoneId: 'M001', title: 'First', status: 'active', risk: 'low', depends: [] });
+      insertSlice({ id: 'S02', milestoneId: 'M001', title: 'Second', status: 'pending', risk: 'low', depends: ['S01'] });
+      insertTask({ id: 'T01', sliceId: 'S01', milestoneId: 'M001', title: 'In-flight', status: 'pending' });
+
+      invalidateStateCache();
+      const state = await deriveStateFromDb(base);
+
+      const m1 = state.registry.find(e => e.id === 'M001');
+      assert.notEqual(m1?.status, 'complete', 'orphan SUMMARY must not mark milestone complete');
+      assert.equal(m1?.status, 'active', 'M001 remains active — DB is authoritative');
+      assert.equal(state.activeMilestone?.id, 'M001', 'M001 is still the active milestone');
+      assert.notEqual(state.phase, 'completing-milestone', 'must not short-circuit into completion');
+    } finally {
+      closeDatabase();
+      cleanup(base);
+    }
+  });
+
+  // Regression #4179 (companion): DB-active milestone with all slices done +
+  // validation terminal + orphan SUMMARY must still flow through completing-milestone
+  // (re-runs complete-milestone), not be reported as already-complete.
+  test('buildRegistryAndFindActive (#4179): orphan SUMMARY with validation-terminal falls through to completing-milestone', async () => {
+    const base = createFixtureBase();
+    try {
+      writeFile(base, 'milestones/M001/M001-ROADMAP.md', ROADMAP_CONTENT);
+      writeFile(base, 'milestones/M001/slices/S01/S01-PLAN.md', PLAN_CONTENT);
+      writeFile(base, 'milestones/M001/slices/S02/S02-PLAN.md', PLAN_CONTENT);
+      writeFile(base, 'milestones/M001/M001-VALIDATION.md', '---\nverdict: passed\n---\n# Validation\nAll good.');
+      writeFile(base, 'milestones/M001/M001-SUMMARY.md', '# M001 Orphan Summary\n\nLeft over.');
+
+      openDatabase(':memory:');
+      insertMilestone({ id: 'M001', title: 'First', status: 'active' });
+      insertSlice({ id: 'S01', milestoneId: 'M001', title: 'First', status: 'complete', risk: 'low', depends: [] });
+      insertSlice({ id: 'S02', milestoneId: 'M001', title: 'Second', status: 'complete', risk: 'low', depends: ['S01'] });
+
+      invalidateStateCache();
+      const state = await deriveStateFromDb(base);
+
+      const m1 = state.registry.find(e => e.id === 'M001');
+      assert.equal(m1?.status, 'active', 'M001 stays active despite orphan SUMMARY + validation-terminal');
+      assert.equal(state.activeMilestone?.id, 'M001', 'M001 is still the active milestone');
+      assert.equal(state.phase, 'completing-milestone', 'phase flows through completing-milestone (re-run)');
     } finally {
       closeDatabase();
       cleanup(base);

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

@@ -446,9 +446,9 @@ Continue from step 2.
 
       const state2 = await deriveState(base2);
 
-      assert.deepStrictEqual(state2.phase, 'blocked', 'blocked-B: phase is blocked');
-      assert.deepStrictEqual(state2.activeSlice, null, 'blocked-B: activeSlice is null');
-      assert.ok(state2.blockers.length > 0, 'blocked-B: blockers array is non-empty');
+      // With partial-dep fallback, S01 is picked despite unmet dep on S99
+      assert.deepStrictEqual(state2.phase, 'planning', 'blocked-B: phase is planning (fallback picks S01)');
+      assert.deepStrictEqual(state2.activeSlice?.id, 'S01', 'blocked-B: activeSlice is S01 via fallback');
     } finally {
       cleanup(base2);
     }

package/src/resources/extensions/gsd/tests/flat-rate-routing-guard.test.ts

@@ -6,7 +6,7 @@
 
 import { describe, test } from "node:test";
 import assert from "node:assert/strict";
-import { isFlatRateProvider, resolvePreferredModelConfig } from "../auto-model-selection.ts";
+import { buildFlatRateContext, isFlatRateProvider, resolvePreferredModelConfig } from "../auto-model-selection.ts";
 
 describe("flat-rate provider routing guard (#3453)", () => {
 
@@ -48,3 +48,139 @@ describe("flat-rate provider routing guard (#3453)", () => {
     assert.equal(result, undefined, "Should not create routing config for copilot");
   });
 });
+
+describe("flat-rate provider extensibility (any/all/custom)", () => {
+  test("regression: built-in providers still flat-rate with no context", () => {
+    assert.equal(isFlatRateProvider("github-copilot"), true);
+    assert.equal(isFlatRateProvider("copilot"), true);
+    assert.equal(isFlatRateProvider("claude-code"), true);
+  });
+
+  test("regression: non-flat-rate API providers return false with no context", () => {
+    assert.equal(isFlatRateProvider("anthropic"), false);
+    assert.equal(isFlatRateProvider("openai"), false);
+    assert.equal(isFlatRateProvider("google-vertex"), false);
+  });
+
+  test("auto-detection: externalCli auth mode marks provider flat-rate", () => {
+    // Any provider registered with authMode: "externalCli" is a local
+    // CLI wrapper around the user's subscription — every request costs
+    // the same regardless of model, so dynamic routing provides no benefit.
+    assert.equal(
+      isFlatRateProvider("my-private-cli", { authMode: "externalCli" }),
+      true,
+    );
+  });
+
+  test("auto-detection: non-externalCli auth modes do not mark provider flat-rate", () => {
+    assert.equal(
+      isFlatRateProvider("my-http-proxy", { authMode: "apiKey" }),
+      false,
+    );
+    assert.equal(
+      isFlatRateProvider("my-http-proxy", { authMode: "oauth" }),
+      false,
+    );
+    assert.equal(
+      isFlatRateProvider("my-http-proxy", { authMode: "none" }),
+      false,
+    );
+  });
+
+  test("user preference: custom provider listed in userFlatRate is flat-rate", () => {
+    assert.equal(
+      isFlatRateProvider("my-ollama-proxy", { userFlatRate: ["my-ollama-proxy"] }),
+      true,
+    );
+  });
+
+  test("user preference: case-insensitive match against userFlatRate list", () => {
+    assert.equal(
+      isFlatRateProvider("My-Proxy", { userFlatRate: ["my-proxy"] }),
+      true,
+    );
+    assert.equal(
+      isFlatRateProvider("my-proxy", { userFlatRate: ["MY-PROXY"] }),
+      true,
+    );
+  });
+
+  test("user preference: provider not in userFlatRate list is not flat-rate", () => {
+    assert.equal(
+      isFlatRateProvider("other-proxy", { userFlatRate: ["my-proxy"] }),
+      false,
+    );
+  });
+
+  test("combined signals: built-in list wins even when context is empty", () => {
+    assert.equal(
+      isFlatRateProvider("claude-code", { authMode: "apiKey", userFlatRate: [] }),
+      true,
+    );
+  });
+
+  test("combined signals: externalCli auto-detection wins alongside userFlatRate miss", () => {
+    assert.equal(
+      isFlatRateProvider("my-cli", {
+        authMode: "externalCli",
+        userFlatRate: ["a-different-cli"],
+      }),
+      true,
+    );
+  });
+});
+
+describe("buildFlatRateContext()", () => {
+  test("builds a context from ctx.modelRegistry.getProviderAuthMode + prefs", () => {
+    const ctx = {
+      modelRegistry: {
+        getProviderAuthMode: (p: string) =>
+          p === "my-cli" ? "externalCli" : "apiKey",
+      },
+    };
+    const prefs = { flat_rate_providers: ["my-proxy"] };
+
+    const ctxForCli = buildFlatRateContext("my-cli", ctx, prefs);
+    assert.equal(ctxForCli.authMode, "externalCli");
+    assert.deepEqual(ctxForCli.userFlatRate, ["my-proxy"]);
+    assert.equal(isFlatRateProvider("my-cli", ctxForCli), true);
+
+    const ctxForProxy = buildFlatRateContext("my-proxy", ctx, prefs);
+    assert.equal(ctxForProxy.authMode, "apiKey");
+    assert.equal(isFlatRateProvider("my-proxy", ctxForProxy), true);
+
+    const ctxForOther = buildFlatRateContext("anthropic", ctx, prefs);
+    assert.equal(ctxForOther.authMode, "apiKey");
+    assert.equal(isFlatRateProvider("anthropic", ctxForOther), false);
+  });
+
+  test("survives missing ctx and missing prefs", () => {
+    const empty = buildFlatRateContext("anything");
+    assert.equal(empty.authMode, undefined);
+    assert.equal(empty.userFlatRate, undefined);
+    assert.equal(isFlatRateProvider("anything", empty), false);
+  });
+
+  test("survives a registry lookup that throws", () => {
+    const ctx = {
+      modelRegistry: {
+        getProviderAuthMode: () => {
+          throw new Error("registry boom");
+        },
+      },
+    };
+    const result = buildFlatRateContext("anything", ctx);
+    // Error must be swallowed — authMode left undefined, function returns.
+    assert.equal(result.authMode, undefined);
+  });
+
+  test("registry returning a non-canonical auth mode is ignored", () => {
+    const ctx = {
+      modelRegistry: {
+        getProviderAuthMode: () => "weird-mode",
+      },
+    };
+    const result = buildFlatRateContext("anything", ctx);
+    assert.equal(result.authMode, undefined);
+  });
+});

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

@@ -15,10 +15,14 @@ import {
   getRequirementById,
   getActiveDecisions,
   getActiveRequirements,
-  getTask,
   transaction,
   _getAdapter,
   _resetProvider,
+  insertMilestone,
+  insertSlice,
+  insertTask,
+  getTask,
+  getSliceTasks,
 } from '../gsd-db.ts';
 
 // ═══════════════════════════════════════════════════════════════════════════
@@ -460,6 +464,60 @@ describe('gsd-db', () => {
     assert.ok(!wasDbOpenAttempted(), 'wasDbOpenAttempted should reset after closeDatabase');
   });
 
+  test('gsd-db: rowToTask tolerates corrupt comma-separated task arrays', () => {
+    openDatabase(':memory:');
+    insertMilestone({ id: 'M001', status: 'active' });
+    insertSlice({ milestoneId: 'M001', id: 'S01', status: 'active' });
+    insertTask({
+      milestoneId: 'M001',
+      sliceId: 'S01',
+      id: 'T01',
+      title: 'Recover corrupt arrays',
+      planning: {
+        description: 'desc',
+        estimate: 'small',
+        files: ['src/original.ts'],
+        verify: 'npm test',
+        inputs: ['docs/original.md'],
+        expectedOutput: ['dist/original.md'],
+        observabilityImpact: '',
+      },
+    });
+
+    const adapter = _getAdapter()!;
+    adapter.prepare(
+      `UPDATE tasks
+         SET files = ?, inputs = ?, expected_output = ?, key_files = ?, key_decisions = ?
+       WHERE milestone_id = ? AND slice_id = ? AND id = ?`,
+    ).run(
+      'src-erf/Models/foo.cs, src-erf/Models/bar.cs',
+      'docs/input-a.md, docs/input-b.md',
+      'dist/out-a.md, dist/out-b.md',
+      'src/resources/extensions/gsd/gsd-db.ts, src/resources/extensions/gsd/state.ts',
+      '"decision-1"',
+      'M001',
+      'S01',
+      'T01',
+    );
+
+    const task = getTask('M001', 'S01', 'T01');
+    assert.ok(task, 'getTask should still return the corrupt row');
+    assert.deepStrictEqual(task!.files, ['src-erf/Models/foo.cs', 'src-erf/Models/bar.cs']);
+    assert.deepStrictEqual(task!.inputs, ['docs/input-a.md', 'docs/input-b.md']);
+    assert.deepStrictEqual(task!.expected_output, ['dist/out-a.md', 'dist/out-b.md']);
+    assert.deepStrictEqual(
+      task!.key_files,
+      ['src/resources/extensions/gsd/gsd-db.ts', 'src/resources/extensions/gsd/state.ts'],
+    );
+    assert.deepStrictEqual(task!.key_decisions, ['decision-1']);
+
+    const sliceTasks = getSliceTasks('M001', 'S01');
+    assert.equal(sliceTasks.length, 1, 'getSliceTasks should also survive corrupt rows');
+    assert.deepStrictEqual(sliceTasks[0]!.files, task!.files);
+
+    closeDatabase();
+  });
+
   // ─── Final Report ──────────────────────────────────────────────────────────
 
 });

package/src/resources/extensions/gsd/tests/integration/state-machine-edge-cases.test.ts

@@ -691,7 +691,7 @@ describe("transition boundary failures", () => {
     );
   });
 
-  test("blocked state: all slices have unmet deps → blocked phase", async () => {
+  test("blocked state: all slices have unmet deps → fallback picks slice", async () => {
     base = makeTempDir();
     const mDir = join(base, ".gsd", "milestones", "M001");
     mkdirSync(join(mDir, "slices", "S01", "tasks"), { recursive: true });
@@ -736,7 +736,9 @@ describe("transition boundary failures", () => {
 
     invalidateAllCaches();
     const state = await deriveStateFromDb(base);
-    assert.equal(state.phase, "blocked", "circular deps should produce blocked phase");
+    // With partial-dep fallback, circular deps no longer block — fallback picks first eligible slice
+    assert.equal(state.phase, "planning", "circular deps: fallback picks a slice instead of blocking");
+    assert.ok(state.activeSlice !== null, "activeSlice set via fallback");
   });
 });