gsd-pi 2.73.0-dev.27730dc → 2.73.0-dev.e1c09f2

package/src/resources/extensions/gsd/bootstrap/register-extension.ts

@@ -11,9 +11,6 @@ import { registerJournalTools } from "./journal-tools.js";
 import { registerQueryTools } from "./query-tools.js";
 import { registerHooks } from "./register-hooks.js";
 import { registerShortcuts } from "./register-shortcuts.js";
-import { writeCrashLog } from "./crash-log.js";
-
-export { writeCrashLog } from "./crash-log.js";
 
 export function handleRecoverableExtensionProcessError(err: Error): boolean {
   if ((err as NodeJS.ErrnoException).code === "EPIPE") {
@@ -36,25 +33,16 @@ export function handleRecoverableExtensionProcessError(err: Error): boolean {
 function installEpipeGuard(): void {
   if (!process.listeners("uncaughtException").some((listener) => listener.name === "_gsdEpipeGuard")) {
     const _gsdEpipeGuard = (err: Error): void => {
-      if (handleRecoverableExtensionProcessError(err)) return;
-      // Write crash log and exit cleanly for unrecoverable errors.
-      // Logging and continuing was the original double-fault fix (#3163), but
-      // continuing in an indeterminate state is worse than a clean exit (#3348).
-      writeCrashLog(err, "uncaughtException");
-      process.exit(1);
+      if (handleRecoverableExtensionProcessError(err)) {
+        return;
+      }
+      // Log unhandled errors instead of re-throwing — throwing inside an
+      // uncaughtException handler is a fatal double-fault in Node.js (#3163).
+      process.stderr.write(`[gsd] uncaught extension error (non-fatal): ${err.message}\n`);
+      if (err.stack) process.stderr.write(`${err.stack}\n`);
     };
     process.on("uncaughtException", _gsdEpipeGuard);
   }
-
-  if (!process.listeners("unhandledRejection").some((listener) => listener.name === "_gsdRejectionGuard")) {
-    const _gsdRejectionGuard = (reason: unknown, _promise: Promise<unknown>): void => {
-      const err = reason instanceof Error ? reason : new Error(String(reason));
-      if (handleRecoverableExtensionProcessError(err)) return;
-      writeCrashLog(err, "unhandledRejection");
-      process.exit(1);
-    };
-    process.on("unhandledRejection", _gsdRejectionGuard);
-  }
 }
 
 export function registerGsdExtension(pi: ExtensionAPI): void {

package/src/resources/extensions/gsd/crash-recovery.ts

@@ -15,7 +15,6 @@ import { join } from "node:path";
 import { gsdRoot } from "./paths.js";
 import { atomicWriteSync } from "./atomic-write.js";
 import { effectiveLockFile } from "./session-lock.js";
-import { emitJournalEvent, queryJournal } from "./journal.js";
 
 export interface LockData {
   pid: number;
@@ -119,61 +118,3 @@ export function formatCrashInfo(lock: LockData): string {
 
   return lines.join("\n");
 }
-
-/**
- * Emit a synthetic unit-end event for a unit that crashed without emitting its own.
- *
- * Queries the journal to find the most recent unit-start for the crashed unit.
- * If a matching unit-end already exists (e.g. the hard timeout fired), this is a
- * no-op. Called during crash recovery, before clearing the stale lock.
- *
- * Addresses the gap reported in #3348 where `unit-start` was emitted but no
- * `unit-end` followed — side effects landed but the worker died before closeout.
- */
-export function emitCrashRecoveredUnitEnd(basePath: string, lock: LockData): void {
-  // Skip bootstrap / starting pseudo-units — they have no meaningful unit-start event.
-  if (!lock.unitType || !lock.unitId || lock.unitType === "starting") return;
-
-  try {
-    const all = queryJournal(basePath);
-
-    // Find the most recent unit-start for this unitId
-    const starts = all.filter(
-      (e) => e.eventType === "unit-start" && e.data?.unitId === lock.unitId,
-    );
-    if (starts.length === 0) return;
-
-    const lastStart = starts[starts.length - 1];
-
-    // Check if a unit-end was already emitted (e.g. hard timeout fired after the crash)
-    const alreadyClosed = all.some(
-      (e) =>
-        e.eventType === "unit-end" &&
-        e.data?.unitId === lock.unitId &&
-        e.causedBy?.flowId === lastStart.flowId &&
-        e.causedBy?.seq === lastStart.seq,
-    );
-    if (alreadyClosed) return;
-
-    // Find the highest seq in this flow for monotonic ordering
-    const maxSeq = all
-      .filter((e) => e.flowId === lastStart.flowId)
-      .reduce((max, e) => Math.max(max, e.seq), lastStart.seq);
-
-    emitJournalEvent(basePath, {
-      ts: new Date().toISOString(),
-      flowId: lastStart.flowId,
-      seq: maxSeq + 1,
-      eventType: "unit-end",
-      data: {
-        unitType: lock.unitType,
-        unitId: lock.unitId,
-        status: "crash-recovered",
-        artifactVerified: false,
-      },
-      causedBy: { flowId: lastStart.flowId, seq: lastStart.seq },
-    });
-  } catch {
-    // Never throw from crash recovery path — journal failure must not block recovery
-  }
-}

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

@@ -1564,23 +1564,6 @@ export interface TaskRow {
   sequence: number;
 }
 
-function parseTaskArrayColumn(raw: unknown): string[] {
-  if (typeof raw !== "string" || raw.trim() === "") return [];
-
-  try {
-    const parsed = JSON.parse(raw);
-    if (Array.isArray(parsed)) return parsed.map((value) => String(value));
-    if (parsed === null || parsed === undefined || parsed === "") return [];
-    return [String(parsed)];
-  } catch {
-    // Older/corrupt rows may contain comma-separated strings instead of JSON.
-    return raw
-      .split(",")
-      .map((value) => value.trim())
-      .filter(Boolean);
-  }
-}
-
 function rowToTask(row: Record<string, unknown>): TaskRow {
   const parseTaskArray = (value: unknown): string[] => {
     if (Array.isArray(value)) {
@@ -1620,8 +1603,8 @@ function rowToTask(row: Record<string, unknown>): TaskRow {
     blocker_discovered: (row["blocker_discovered"] as number) === 1,
     deviations: row["deviations"] as string,
     known_issues: row["known_issues"] as string,
-    key_files: parseTaskArrayColumn(row["key_files"]),
-    key_decisions: parseTaskArrayColumn(row["key_decisions"]),
+    key_files: JSON.parse((row["key_files"] as string) || "[]"),
+    key_decisions: JSON.parse((row["key_decisions"] as string) || "[]"),
     full_summary_md: row["full_summary_md"] as string,
     description: (row["description"] as string) ?? "",
     estimate: (row["estimate"] as string) ?? "",
@@ -2217,39 +2200,6 @@ export function deleteSlice(milestoneId: string, sliceId: string): void {
   });
 }
 
-export function deleteMilestone(milestoneId: string): void {
-  if (!currentDb) throw new GSDError(GSD_STALE_STATE, "gsd-db: No database open");
-  transaction(() => {
-    currentDb!.prepare(
-      `DELETE FROM verification_evidence WHERE milestone_id = :mid`,
-    ).run({ ":mid": milestoneId });
-    currentDb!.prepare(
-      `DELETE FROM quality_gates WHERE milestone_id = :mid`,
-    ).run({ ":mid": milestoneId });
-    currentDb!.prepare(
-      `DELETE FROM tasks WHERE milestone_id = :mid`,
-    ).run({ ":mid": milestoneId });
-    currentDb!.prepare(
-      `DELETE FROM slice_dependencies WHERE milestone_id = :mid`,
-    ).run({ ":mid": milestoneId });
-    currentDb!.prepare(
-      `DELETE FROM slices WHERE milestone_id = :mid`,
-    ).run({ ":mid": milestoneId });
-    currentDb!.prepare(
-      `DELETE FROM replan_history WHERE milestone_id = :mid`,
-    ).run({ ":mid": milestoneId });
-    currentDb!.prepare(
-      `DELETE FROM assessments WHERE milestone_id = :mid`,
-    ).run({ ":mid": milestoneId });
-    currentDb!.prepare(
-      `DELETE FROM artifacts WHERE milestone_id = :mid`,
-    ).run({ ":mid": milestoneId });
-    currentDb!.prepare(
-      `DELETE FROM milestones WHERE id = :mid`,
-    ).run({ ":mid": milestoneId });
-  });
-}
-
 export function updateSliceFields(milestoneId: string, sliceId: string, fields: {
   title?: string;
   risk?: string;

package/src/resources/extensions/gsd/milestone-actions.ts

@@ -20,8 +20,7 @@ import {
 } from "./paths.js";
 import { invalidateAllCaches } from "./cache.js";
 import { loadQueueOrder, saveQueueOrder } from "./queue-order.js";
-import { deleteMilestone, getMilestone, isDbAvailable, updateMilestoneStatus } from "./gsd-db.js";
-import { removeWorktree } from "./worktree-manager.js";
+import { getMilestone, isDbAvailable, updateMilestoneStatus } from "./gsd-db.js";
 import { logWarning } from "./workflow-logger.js";
 
 // ─── Park ──────────────────────────────────────────────────────────────────
@@ -111,15 +110,6 @@ export function discardMilestone(basePath: string, milestoneId: string): boolean
   const mDir = resolveMilestonePath(basePath, milestoneId);
   if (!mDir || !existsSync(mDir)) return false;
 
-  try {
-    removeWorktree(basePath, milestoneId, {
-      branch: `milestone/${milestoneId}`,
-      deleteBranch: true,
-    });
-  } catch (err) {
-    logWarning("engine", `discardMilestone worktree cleanup failed for ${milestoneId}: ${(err as Error).message}`);
-  }
-
   rmSync(mDir, { recursive: true, force: true });
 
   // Prune from queue order if present
@@ -128,14 +118,6 @@ export function discardMilestone(basePath: string, milestoneId: string): boolean
     saveQueueOrder(basePath, order.filter(id => id !== milestoneId));
   }
 
-  if (isDbAvailable()) {
-    try {
-      deleteMilestone(milestoneId);
-    } catch (err) {
-      logWarning("engine", `discardMilestone DB cleanup failed for ${milestoneId}: ${(err as Error).message}`);
-    }
-  }
-
   invalidateAllCaches();
   return true;
 }

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

@@ -15,14 +15,10 @@ import {
   getRequirementById,
   getActiveDecisions,
   getActiveRequirements,
+  getTask,
   transaction,
   _getAdapter,
   _resetProvider,
-  insertMilestone,
-  insertSlice,
-  insertTask,
-  getTask,
-  getSliceTasks,
 } from '../gsd-db.ts';
 
 // ═══════════════════════════════════════════════════════════════════════════
@@ -464,60 +460,6 @@ 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/park-milestone.test.ts

@@ -3,22 +3,10 @@ import assert from 'node:assert/strict';
 import { mkdtempSync, mkdirSync, rmSync, writeFileSync, existsSync, readFileSync } from 'node:fs';
 import { join } from 'node:path';
 import { tmpdir } from 'node:os';
-import { execSync } from 'node:child_process';
 
 import { deriveState, invalidateStateCache, getActiveMilestoneId } from '../state.ts';
 import { clearPathCache } from '../paths.ts';
 import { parkMilestone, unparkMilestone, discardMilestone, isParked, getParkedReason } from '../milestone-actions.ts';
-import {
-  closeDatabase,
-  getMilestone,
-  getMilestoneSlices,
-  getSliceTasks,
-  insertMilestone,
-  insertSlice,
-  insertTask,
-  openDatabase,
-} from "../gsd-db.ts";
-import { createWorktree } from "../worktree-manager.ts";
 
 
 
@@ -72,29 +60,9 @@ function createMilestone(base: string, mid: string, opts?: { withRoadmap?: boole
 }
 
 function cleanup(base: string): void {
-  try {
-    closeDatabase();
-  } catch {
-    // ignore
-  }
   rmSync(base, { recursive: true, force: true });
 }
 
-function run(cmd: string, cwd: string): string {
-  return execSync(cmd, { cwd, stdio: ["ignore", "pipe", "pipe"], encoding: "utf-8" }).trim();
-}
-
-function initGitRepo(base: string): void {
-  writeFileSync(join(base, "README.md"), "# test\n", "utf-8");
-  writeFileSync(join(base, ".gsd", "STATE.md"), "# State\n", "utf-8");
-  run("git init", base);
-  run("git config user.email test@test.com", base);
-  run("git config user.name Test", base);
-  run("git add .", base);
-  run('git commit -m "init"', base);
-  run("git branch -M main", base);
-}
-
 function clearCaches(): void {
   clearPathCache();
   invalidateStateCache();
@@ -326,38 +294,6 @@ test('discardMilestone updates queue order', () => {
     }
 });
 
-test('discardMilestone removes DB rows, worktree, and milestone branch', () => {
-    const base = createFixtureBase();
-    try {
-      createMilestone(base, 'M001', { withRoadmap: true });
-      initGitRepo(base);
-      clearCaches();
-
-      assert.ok(openDatabase(join(base, '.gsd', 'gsd.db')), 'database opens');
-      insertMilestone({ id: 'M001', title: 'Discard me', status: 'active' });
-      insertSlice({ milestoneId: 'M001', id: 'S01', title: 'Only slice', status: 'pending' });
-      insertTask({ milestoneId: 'M001', sliceId: 'S01', id: 'T01', title: 'Only task', status: 'pending' });
-
-      const wt = createWorktree(base, 'M001', { branch: 'milestone/M001' });
-      assert.ok(existsSync(wt.path), 'worktree exists before discard');
-      assert.ok(run('git branch', base).includes('milestone/M001'), 'milestone branch exists before discard');
-      assert.ok(getMilestone('M001'), 'milestone exists in DB before discard');
-      assert.equal(getMilestoneSlices('M001').length, 1, 'slice exists in DB before discard');
-      assert.equal(getSliceTasks('M001', 'S01').length, 1, 'task exists in DB before discard');
-
-      const success = discardMilestone(base, 'M001');
-      assert.ok(success, 'discardMilestone returns true');
-
-      assert.equal(getMilestone('M001'), null, 'milestone row removed from DB');
-      assert.equal(getMilestoneSlices('M001').length, 0, 'slice rows removed from DB');
-      assert.equal(getSliceTasks('M001', 'S01').length, 0, 'task rows removed from DB');
-      assert.ok(!existsSync(wt.path), 'worktree removed after discard');
-      assert.ok(!run('git branch', base).includes('milestone/M001'), 'milestone branch removed after discard');
-    } finally {
-      cleanup(base);
-    }
-});
-
   // ─── Test 12: All milestones parked → no active milestone ─────────────
 test('All milestones parked → no active', async () => {
     const base = createFixtureBase();

package/dist/resources/extensions/gsd/bootstrap/crash-log.js

@@ -1,31 +0,0 @@
-/**
- * crash-log.ts — Write crash diagnostics to ~/.gsd/crash/<timestamp>.log
- *
- * Zero cross-dependencies: only uses Node.js built-ins so it can be imported
- * safely from uncaughtException / unhandledRejection handlers and from tests
- * without pulling in the full extension dependency tree.
- */
-import { appendFileSync, mkdirSync } from "node:fs";
-import { homedir } from "node:os";
-import { join } from "node:path";
-/**
- * Write a crash log to ~/.gsd/crash/<timestamp>.log (or $GSD_HOME/crash/).
- * Never throws — must be safe to call from any error handler.
- */
-export function writeCrashLog(err, source) {
-    try {
-        const crashDir = join(process.env.GSD_HOME ?? join(homedir(), ".gsd"), "crash");
-        mkdirSync(crashDir, { recursive: true });
-        const ts = new Date().toISOString().replace(/[:.]/g, "-");
-        const logPath = join(crashDir, `${ts}.log`);
-        const lines = [
-            `[gsd] ${source}: ${err.message}`,
-            `timestamp: ${new Date().toISOString()}`,
-            `pid: ${process.pid}`,
-            err.stack ?? "(no stack trace available)",
-            "",
-        ];
-        appendFileSync(logPath, lines.join("\n"));
-    }
-    catch { /* never throw from crash handler */ }
-}

package/src/resources/extensions/gsd/bootstrap/crash-log.ts

@@ -1,32 +0,0 @@
-/**
- * crash-log.ts — Write crash diagnostics to ~/.gsd/crash/<timestamp>.log
- *
- * Zero cross-dependencies: only uses Node.js built-ins so it can be imported
- * safely from uncaughtException / unhandledRejection handlers and from tests
- * without pulling in the full extension dependency tree.
- */
-
-import { appendFileSync, mkdirSync } from "node:fs";
-import { homedir } from "node:os";
-import { join } from "node:path";
-
-/**
- * Write a crash log to ~/.gsd/crash/<timestamp>.log (or $GSD_HOME/crash/).
- * Never throws — must be safe to call from any error handler.
- */
-export function writeCrashLog(err: Error, source: string): void {
-  try {
-    const crashDir = join(process.env.GSD_HOME ?? join(homedir(), ".gsd"), "crash");
-    mkdirSync(crashDir, { recursive: true });
-    const ts = new Date().toISOString().replace(/[:.]/g, "-");
-    const logPath = join(crashDir, `${ts}.log`);
-    const lines = [
-      `[gsd] ${source}: ${err.message}`,
-      `timestamp: ${new Date().toISOString()}`,
-      `pid: ${process.pid}`,
-      err.stack ?? "(no stack trace available)",
-      "",
-    ];
-    appendFileSync(logPath, lines.join("\n"));
-  } catch { /* never throw from crash handler */ }
-}