@opengsd/gsd-pi 1.2.0 → 1.3.0-dev.65546769

package/dist/resources/extensions/gsd/db/queries.js

@@ -0,0 +1,482 @@
+// Project/App: gsd-pi
+// File Purpose: Query Module — the read-only seam of the DB layer.
+// SELECT-only wrappers, read through the shared engine handle (getDbOrNull()).
+// Contains NO write SQL (asserted by tests/single-writer-invariant.test.ts).
+// Read-only callers (forensics, dashboard, doctor) depend on this seam, not on
+// the single-writer surface.
+import { getDbOrNull } from "./engine.js";
+import { isClosedStatus } from "../status-guards.js";
+import { getGateIdsForTurn } from "../gate-registry.js";
+import { emptyTaskStatusCounts, rowToActiveTaskSummary, rowToIdStatusSummary, rowToTaskStatusCounts, rowsToStringColumn, } from "../db-lightweight-query-rows.js";
+import { rowToActiveDecision, rowToActiveRequirement, rowToDecision, rowToRequirement, rowsToRequirementCounts, } from "../db-decision-requirement-rows.js";
+import { rowToGate } from "../db-gate-rows.js";
+import { rowToArtifact, rowToMilestone } from "../db-milestone-artifact-rows.js";
+import { rowToSlice, rowToTask } from "../db-task-slice-rows.js";
+function parseStringArrayColumn(raw) {
+    if (Array.isArray(raw))
+        return raw.filter((entry) => typeof entry === "string");
+    if (typeof raw !== "string")
+        return [];
+    const trimmed = raw.trim();
+    if (!trimmed)
+        return [];
+    try {
+        const parsed = JSON.parse(trimmed);
+        if (Array.isArray(parsed))
+            return parsed.filter((entry) => typeof entry === "string");
+        if (typeof parsed === "string")
+            return [parsed];
+    }
+    catch {
+        return trimmed.split(",");
+    }
+    return [];
+}
+function normalizeRepoPath(file) {
+    return file.trim().replace(/\\/g, "/").replace(/^\.\/+/, "");
+}
+export function getDecisionById(id) {
+    if (!getDbOrNull())
+        return null;
+    const row = getDbOrNull().prepare("SELECT * FROM decisions WHERE id = ?").get(id);
+    if (!row)
+        return null;
+    return rowToDecision(row);
+}
+export function getActiveDecisions() {
+    if (!getDbOrNull())
+        return [];
+    const rows = getDbOrNull().prepare("SELECT * FROM active_decisions").all();
+    return rows.map(rowToActiveDecision);
+}
+export function getRequirementById(id) {
+    if (!getDbOrNull())
+        return null;
+    const row = getDbOrNull().prepare("SELECT * FROM requirements WHERE id = ?").get(id);
+    if (!row)
+        return null;
+    return rowToRequirement(row);
+}
+export function getActiveRequirements() {
+    if (!getDbOrNull())
+        return [];
+    const rows = getDbOrNull().prepare("SELECT * FROM active_requirements").all();
+    return rows.map(rowToActiveRequirement);
+}
+export function getRequirementCounts() {
+    if (!getDbOrNull()) {
+        return { active: 0, validated: 0, deferred: 0, outOfScope: 0, blocked: 0, total: 0 };
+    }
+    const rows = getDbOrNull()
+        .prepare("SELECT lower(status) as status, COUNT(*) as count FROM requirements GROUP BY lower(status)")
+        .all();
+    return rowsToRequirementCounts(rows);
+}
+/**
+ * ADR-017 raw primitive: returns slice IDs in a milestone whose is_sketch flag
+ * is still 1. The stale-sketch-flag drift handler at
+ * `state-reconciliation/drift/sketch-flag.ts` composes this with PLAN.md
+ * existence checks to detect drift, then writes via `setSliceSketchFlag`.
+ */
+export function getSketchedSliceIds(milestoneId) {
+    if (!getDbOrNull())
+        return [];
+    const rows = getDbOrNull().prepare(`SELECT id FROM slices WHERE milestone_id = :mid AND is_sketch = 1`).all({ ":mid": milestoneId });
+    return rows.map((r) => r.id);
+}
+export function getSlice(milestoneId, sliceId) {
+    if (!getDbOrNull())
+        return null;
+    const row = getDbOrNull().prepare("SELECT * FROM slices WHERE milestone_id = :mid AND id = :sid").get({ ":mid": milestoneId, ":sid": sliceId });
+    if (!row)
+        return null;
+    return rowToSlice(row);
+}
+export function getTask(milestoneId, sliceId, taskId) {
+    if (!getDbOrNull())
+        return null;
+    const row = getDbOrNull().prepare("SELECT * FROM tasks WHERE milestone_id = :mid AND slice_id = :sid AND id = :tid").get({ ":mid": milestoneId, ":sid": sliceId, ":tid": taskId });
+    if (!row)
+        return null;
+    return rowToTask(row);
+}
+export function getSliceTasks(milestoneId, sliceId) {
+    if (!getDbOrNull())
+        return [];
+    const rows = getDbOrNull().prepare("SELECT * FROM tasks WHERE milestone_id = :mid AND slice_id = :sid ORDER BY sequence, id").all({ ":mid": milestoneId, ":sid": sliceId });
+    return rows.map(rowToTask);
+}
+export function getCompletedMilestoneTaskFileHints(milestoneId) {
+    if (!getDbOrNull())
+        return [];
+    const rows = getDbOrNull().prepare(`SELECT files, key_files
+     FROM tasks
+     WHERE milestone_id = :mid AND status IN ('complete', 'done')`).all({ ":mid": milestoneId });
+    const hints = new Set();
+    for (const row of rows) {
+        for (const raw of [row["files"], row["key_files"]]) {
+            for (const file of parseStringArrayColumn(raw)) {
+                const normalized = normalizeRepoPath(file);
+                if (normalized)
+                    hints.add(normalized);
+            }
+        }
+    }
+    return [...hints];
+}
+/** Find the most recent resolved-but-unapplied escalation override in a slice. */
+export function findUnappliedEscalationOverride(milestoneId, sliceId) {
+    if (!getDbOrNull())
+        return null;
+    // Filter BOTH flags: escalation_pending=0 AND escalation_awaiting_review=0
+    // ensures we only claim overrides the user has explicitly resolved.
+    // Without the awaiting_review filter, continueWithDefault=true artifacts
+    // (not yet responded to) would be prematurely claimed, causing the override
+    // to be lost when the user later resolves (#ADR-011 Phase 2 peer-review Bug 2).
+    const row = getDbOrNull().prepare(`SELECT id, escalation_artifact_path AS path
+       FROM tasks
+      WHERE milestone_id = :mid AND slice_id = :sid
+        AND escalation_artifact_path IS NOT NULL
+        AND escalation_override_applied_at IS NULL
+        AND escalation_pending = 0
+        AND escalation_awaiting_review = 0
+      ORDER BY sequence DESC, id DESC
+      LIMIT 1`).get({ ":mid": milestoneId, ":sid": sliceId });
+    if (!row || !row.path)
+        return null;
+    return { taskId: row.id, artifactPath: row.path };
+}
+/** List tasks with active escalation artifacts across a milestone (for /gsd escalate list). */
+export function listEscalationArtifacts(milestoneId, includeResolved = false) {
+    if (!getDbOrNull())
+        return [];
+    const filter = includeResolved
+        ? "escalation_artifact_path IS NOT NULL"
+        : "(escalation_pending = 1 OR escalation_awaiting_review = 1) AND escalation_artifact_path IS NOT NULL";
+    const rows = getDbOrNull().prepare(`SELECT * FROM tasks WHERE milestone_id = :mid AND ${filter} ORDER BY slice_id, sequence, id`).all({ ":mid": milestoneId });
+    return rows.map(rowToTask);
+}
+export function getVerificationEvidence(milestoneId, sliceId, taskId) {
+    if (!getDbOrNull())
+        return [];
+    const rows = getDbOrNull().prepare("SELECT * FROM verification_evidence WHERE milestone_id = :mid AND slice_id = :sid AND task_id = :tid ORDER BY id").all({ ":mid": milestoneId, ":sid": sliceId, ":tid": taskId });
+    return rows;
+}
+export function getAllMilestones() {
+    if (!getDbOrNull())
+        return [];
+    const rows = getDbOrNull().prepare("SELECT * FROM milestones ORDER BY CASE WHEN sequence > 0 THEN 0 ELSE 1 END, sequence, id").all();
+    return rows.map(rowToMilestone);
+}
+export function getMilestone(id) {
+    if (!getDbOrNull())
+        return null;
+    const row = getDbOrNull().prepare("SELECT * FROM milestones WHERE id = :id").get({ ":id": id });
+    if (!row)
+        return null;
+    return rowToMilestone(row);
+}
+export function getActiveMilestoneFromDb() {
+    if (!getDbOrNull())
+        return null;
+    const row = getDbOrNull().prepare("SELECT * FROM milestones WHERE status NOT IN ('complete', 'done', 'skipped', 'closed', 'parked') ORDER BY id LIMIT 1").get();
+    if (!row)
+        return null;
+    return rowToMilestone(row);
+}
+export function getActiveSliceFromDb(milestoneId) {
+    if (!getDbOrNull())
+        return null;
+    // Single query: find the first non-complete slice whose dependencies are all satisfied.
+    // Uses json_each() to expand the JSON depends array and checks each dep is complete.
+    const row = getDbOrNull().prepare(`SELECT s.* FROM slices s
+     WHERE s.milestone_id = :mid
+       AND s.status NOT IN ('complete', 'done', 'skipped')
+       AND NOT EXISTS (
+         SELECT 1 FROM json_each(s.depends) AS dep
+         WHERE dep.value NOT IN (
+           SELECT id FROM slices WHERE milestone_id = :mid AND status IN ('complete', 'done', 'skipped')
+         )
+       )
+     ORDER BY s.sequence, s.id
+     LIMIT 1`).get({ ":mid": milestoneId });
+    if (!row)
+        return null;
+    return rowToSlice(row);
+}
+export function getActiveTaskFromDb(milestoneId, sliceId) {
+    if (!getDbOrNull())
+        return null;
+    const row = getDbOrNull().prepare("SELECT * FROM tasks WHERE milestone_id = :mid AND slice_id = :sid AND status NOT IN ('complete', 'done') ORDER BY sequence, id LIMIT 1").get({ ":mid": milestoneId, ":sid": sliceId });
+    if (!row)
+        return null;
+    return rowToTask(row);
+}
+export function getMilestoneSlices(milestoneId) {
+    if (!getDbOrNull())
+        return [];
+    const rows = getDbOrNull().prepare("SELECT * FROM slices WHERE milestone_id = :mid ORDER BY sequence, id").all({ ":mid": milestoneId });
+    return rows.map(rowToSlice);
+}
+export function getParallelMonitorSliceProgress(milestoneId) {
+    const db = getDbOrNull();
+    if (!db)
+        return [];
+    const rows = db.prepare(`SELECT
+       s.id AS id,
+       s.status AS status,
+       COUNT(t.id) AS total,
+       COALESCE(SUM(CASE WHEN t.status='complete' THEN 1 ELSE 0 END), 0) AS done
+     FROM slices s
+     LEFT JOIN tasks t ON s.milestone_id=t.milestone_id AND s.id=t.slice_id
+     WHERE s.milestone_id=:mid
+     GROUP BY s.id
+     ORDER BY s.id`).all({ ":mid": milestoneId });
+    return rows.map((row) => ({
+        id: String(row["id"] ?? ""),
+        status: String(row["status"] ?? ""),
+        total: Number(row["total"] ?? 0),
+        done: Number(row["done"] ?? 0),
+    }));
+}
+export function getParallelMonitorRecentCompletions(milestoneId, limit = 5) {
+    const db = getDbOrNull();
+    if (!db)
+        return [];
+    const numericLimit = Number.isFinite(limit) ? Math.floor(limit) : 5;
+    const safeLimit = Math.max(1, Math.min(50, numericLimit));
+    const rows = db.prepare(`SELECT id, slice_id, one_liner
+     FROM tasks
+     WHERE milestone_id=:mid
+       AND status='complete'
+       AND completed_at IS NOT NULL
+     ORDER BY completed_at DESC
+     LIMIT ${safeLimit}`).all({ ":mid": milestoneId });
+    return rows.map((row) => ({
+        taskId: String(row["id"] ?? ""),
+        sliceId: String(row["slice_id"] ?? ""),
+        oneLiner: String(row["one_liner"] ?? ""),
+    }));
+}
+/**
+ * Load slices for many milestones in a single query. Returns a Map keyed by
+ * milestone_id, preserving `ORDER BY sequence, id` within each bucket.
+ */
+export function getSlicesByMilestoneIds(milestoneIds) {
+    const db = getDbOrNull();
+    if (!db || milestoneIds.length === 0)
+        return new Map();
+    const idList = [...milestoneIds];
+    const placeholders = idList.map((_, i) => `:mid${i}`).join(",");
+    const params = {};
+    idList.forEach((id, i) => {
+        params[`:mid${i}`] = id;
+    });
+    const rows = db
+        .prepare(`SELECT * FROM slices WHERE milestone_id IN (${placeholders}) ORDER BY milestone_id, sequence, id`)
+        .all(params);
+    const byMilestone = new Map();
+    for (const row of rows) {
+        const slice = rowToSlice(row);
+        const bucket = byMilestone.get(slice.milestone_id);
+        if (bucket) {
+            bucket.push(slice);
+        }
+        else {
+            byMilestone.set(slice.milestone_id, [slice]);
+        }
+    }
+    return byMilestone;
+}
+/**
+ * Consolidated DB read for dispatch/gate/completion decisions (ADR-017).
+ * `done` uses the canonical closed-status predicate (`isClosedStatus`) — the
+ * same vocabulary the SQL terminal-status fragment derives from. Decision
+ * paths must consume this instead of parsing `.gsd/*.md` projections.
+ * Rows keep `getMilestoneSlices` ordering (sequence, then id).
+ */
+export function getMilestoneSliceSummaries(milestoneId) {
+    return getMilestoneSlices(milestoneId).map((s) => ({
+        id: s.id,
+        title: s.title,
+        done: isClosedStatus(s.status),
+        depends: s.depends ?? [],
+    }));
+}
+/**
+ * Ids of slices closed per the canonical status vocabulary (ADR-017), in
+ * milestone order. Thin wrapper over `getMilestoneSliceSummaries` for the
+ * common "which slices are done?" decision-path read.
+ */
+export function getClosedSliceIds(milestoneId) {
+    return getMilestoneSliceSummaries(milestoneId)
+        .filter((s) => s.done)
+        .map((s) => s.id);
+}
+export function getArtifact(path) {
+    if (!getDbOrNull())
+        return null;
+    const row = getDbOrNull().prepare("SELECT * FROM artifacts WHERE path = :path").get({ ":path": path });
+    if (!row)
+        return null;
+    return rowToArtifact(row);
+}
+/** Milestone-level artifacts (CONTEXT, RESEARCH, VALIDATION, etc.) from the artifacts table. */
+export function getMilestoneScopedArtifacts(milestoneId) {
+    if (!getDbOrNull())
+        return [];
+    const rows = getDbOrNull().prepare("SELECT * FROM artifacts WHERE milestone_id = :mid AND slice_id IS NULL AND task_id IS NULL ORDER BY path").all({ ":mid": milestoneId });
+    return rows.map(rowToArtifact);
+}
+/** Slice-level artifacts (CONTEXT, RESEARCH, CONTINUE, etc.) from the artifacts table. */
+export function getSliceScopedArtifacts(milestoneId, sliceId) {
+    if (!getDbOrNull())
+        return [];
+    const rows = getDbOrNull().prepare("SELECT * FROM artifacts WHERE milestone_id = :mid AND slice_id = :sid AND task_id IS NULL ORDER BY path").all({ ":mid": milestoneId, ":sid": sliceId });
+    return rows.map(rowToArtifact);
+}
+/** Fast milestone status check — avoids deserializing JSON planning fields. */
+export function getActiveMilestoneIdFromDb() {
+    if (!getDbOrNull())
+        return null;
+    const row = getDbOrNull().prepare("SELECT id, status FROM milestones WHERE status NOT IN ('complete', 'done', 'skipped', 'closed', 'parked') ORDER BY id LIMIT 1").get();
+    if (!row)
+        return null;
+    return rowToIdStatusSummary(row);
+}
+/** Fast slice status check — avoids deserializing JSON depends/planning fields. */
+export function getSliceStatusSummary(milestoneId) {
+    if (!getDbOrNull())
+        return [];
+    return getDbOrNull().prepare("SELECT id, status FROM slices WHERE milestone_id = :mid ORDER BY sequence, id").all({ ":mid": milestoneId }).map(rowToIdStatusSummary);
+}
+/** Fast task status check — avoids deserializing JSON arrays and large text fields. */
+export function getActiveTaskIdFromDb(milestoneId, sliceId) {
+    if (!getDbOrNull())
+        return null;
+    const row = getDbOrNull().prepare("SELECT id, status, title FROM tasks WHERE milestone_id = :mid AND slice_id = :sid AND status NOT IN ('complete', 'done') ORDER BY sequence, id LIMIT 1").get({ ":mid": milestoneId, ":sid": sliceId });
+    if (!row)
+        return null;
+    return rowToActiveTaskSummary(row);
+}
+/** Count tasks by status for a slice — useful for progress reporting without full row load. */
+export function getSliceTaskCounts(milestoneId, sliceId) {
+    if (!getDbOrNull())
+        return emptyTaskStatusCounts();
+    const row = getDbOrNull().prepare(`SELECT
+       COUNT(*) as total,
+       SUM(CASE WHEN status IN ('complete', 'done') THEN 1 ELSE 0 END) as done,
+       SUM(CASE WHEN status NOT IN ('complete', 'done') THEN 1 ELSE 0 END) as pending
+     FROM tasks WHERE milestone_id = :mid AND slice_id = :sid`).get({ ":mid": milestoneId, ":sid": sliceId });
+    return rowToTaskStatusCounts(row);
+}
+/** Get all slices that depend on a given slice. */
+export function getDependentSlices(milestoneId, sliceId) {
+    if (!getDbOrNull())
+        return [];
+    const rows = getDbOrNull().prepare("SELECT slice_id FROM slice_dependencies WHERE milestone_id = :mid AND depends_on_slice_id = :sid").all({ ":mid": milestoneId, ":sid": sliceId });
+    return rowsToStringColumn(rows, "slice_id");
+}
+export function getReplanHistory(milestoneId, sliceId) {
+    if (!getDbOrNull())
+        return [];
+    if (sliceId) {
+        return getDbOrNull().prepare(`SELECT * FROM replan_history WHERE milestone_id = :mid AND slice_id = :sid ORDER BY created_at DESC`).all({ ":mid": milestoneId, ":sid": sliceId });
+    }
+    return getDbOrNull().prepare(`SELECT * FROM replan_history WHERE milestone_id = :mid ORDER BY created_at DESC`).all({ ":mid": milestoneId });
+}
+export function getAssessment(path) {
+    if (!getDbOrNull())
+        return null;
+    const row = getDbOrNull().prepare(`SELECT * FROM assessments WHERE path = :path`).get({ ":path": path });
+    return row ?? null;
+}
+export function getLatestAssessmentByScope(milestoneId, scope) {
+    if (!getDbOrNull())
+        return null;
+    const row = getDbOrNull().prepare(`SELECT * FROM assessments
+      WHERE milestone_id = :mid AND scope = :scope
+      ORDER BY created_at DESC
+      LIMIT 1`).get({ ":mid": milestoneId, ":scope": scope });
+    return row ?? null;
+}
+export function getPendingGates(milestoneId, sliceId, scope) {
+    if (!getDbOrNull())
+        return [];
+    const sql = scope
+        ? `SELECT * FROM quality_gates WHERE milestone_id = :mid AND slice_id = :sid AND scope = :scope AND status = 'pending'`
+        : `SELECT * FROM quality_gates WHERE milestone_id = :mid AND slice_id = :sid AND status = 'pending'`;
+    const params = { ":mid": milestoneId, ":sid": sliceId };
+    if (scope)
+        params[":scope"] = scope;
+    return getDbOrNull().prepare(sql).all(params).map(rowToGate);
+}
+export function getGateResults(milestoneId, sliceId, scope) {
+    if (!getDbOrNull())
+        return [];
+    const sql = scope
+        ? `SELECT * FROM quality_gates WHERE milestone_id = :mid AND slice_id = :sid AND scope = :scope`
+        : `SELECT * FROM quality_gates WHERE milestone_id = :mid AND slice_id = :sid`;
+    const params = { ":mid": milestoneId, ":sid": sliceId };
+    if (scope)
+        params[":scope"] = scope;
+    return getDbOrNull().prepare(sql).all(params).map(rowToGate);
+}
+export function getPendingSliceGateCount(milestoneId, sliceId) {
+    if (!getDbOrNull())
+        return 0;
+    const row = getDbOrNull().prepare(`SELECT COUNT(*) as cnt FROM quality_gates
+     WHERE milestone_id = :mid AND slice_id = :sid AND scope = 'slice' AND status = 'pending'`).get({ ":mid": milestoneId, ":sid": sliceId });
+    return row ? row["cnt"] : 0;
+}
+/**
+ * Return pending gate rows owned by a specific workflow turn.
+ *
+ * Unlike `getPendingGates(..., scope)`, this filters by the registry's
+ * `ownerTurn` metadata so callers can distinguish Q3/Q4 (owned by
+ * gate-evaluate) from Q8 (owned by complete-slice) even though both are
+ * scope:"slice". Pass `taskId` to narrow task-scoped results to one task.
+ */
+export function getPendingGatesForTurn(milestoneId, sliceId, turn, taskId) {
+    if (!getDbOrNull())
+        return [];
+    const ids = getGateIdsForTurn(turn);
+    if (ids.size === 0)
+        return [];
+    const idList = [...ids];
+    const placeholders = idList.map((_, i) => `:gid${i}`).join(",");
+    const params = {
+        ":mid": milestoneId,
+        ":sid": sliceId,
+    };
+    idList.forEach((id, i) => {
+        params[`:gid${i}`] = id;
+    });
+    let sql = `SELECT * FROM quality_gates
+     WHERE milestone_id = :mid AND slice_id = :sid
+       AND status = 'pending'
+       AND gate_id IN (${placeholders})`;
+    if (taskId !== undefined) {
+        sql += ` AND task_id = :tid`;
+        params[":tid"] = taskId;
+    }
+    return getDbOrNull().prepare(sql).all(params).map(rowToGate);
+}
+/**
+ * Count pending gates for a turn. Convenience wrapper used by state
+ * derivation to decide whether a phase transition should pause.
+ */
+export function getPendingGateCountForTurn(milestoneId, sliceId, turn) {
+    return getPendingGatesForTurn(milestoneId, sliceId, turn).length;
+}
+export function getMilestoneCommitAttributionShas(milestoneId) {
+    if (!getDbOrNull())
+        return [];
+    const rows = getDbOrNull().prepare(`SELECT commit_sha
+     FROM milestone_commit_attributions
+     WHERE milestone_id = :mid
+     ORDER BY created_at, commit_sha`).all({ ":mid": milestoneId });
+    return rows
+        .map((row) => typeof row["commit_sha"] === "string" ? row["commit_sha"] : "")
+        .filter(Boolean);
+}

package/dist/resources/extensions/gsd/db/sql-constants.js

@@ -0,0 +1,11 @@
+// Project/App: gsd-pi
+// File Purpose: Shared SQL literal fragments for the single-writer layer.
+// Kept out of the barrel surface (imported as values, not re-exported) so it
+// stays an implementation detail of the writers.
+import { RAW_CLOSED_STATUSES } from "../status-guards.js";
+/** Status values that mean a unit is closed; used in ON CONFLICT guards to
+ *  prevent an upsert from reopening a completed slice/task. Derived from the
+ *  single source `RAW_CLOSED_STATUSES` (ADR-030) so the SQL fragment cannot
+ *  drift from `isClosedStatus()`. Renders as `'complete', 'done', 'skipped',
+ *  'closed'`. */
+export const TERMINAL_STATUS_SQL = RAW_CLOSED_STATUSES.map((s) => `'${s}'`).join(", ");

package/dist/resources/extensions/gsd/db/unit-dispatches.js

@@ -387,10 +387,31 @@ export function getRecentUnitKeysForWorker(workerId, limit = 20) {
     // Reverse so callers consume oldest-first (sliding-window semantics).
     return rows.reverse().map((r) => ({ key: r.unit_id }));
 }
-export function getRecentUnitKeysForProjectRoot(projectRootRealpath, limit = 20) {
+export function getRecentUnitKeysForProjectRoot(projectRootRealpath, limit = 20, traceId) {
     if (!isDbAvailable())
         return [];
     const db = _getAdapter();
+    // When a trace_id is provided, scope the window to the current session so
+    // stale finalize-retry entries from PREVIOUS sessions don't fire detectStuck
+    // Rule 1 on the first iteration of a new session — killing auto-mode before
+    // any new dispatch runs. Without this, a project that had two consecutive
+    // finalize-retry failures in a prior session is permanently stuck: every
+    // fresh session loads those stale errors and immediately declares stuck.
+    if (traceId) {
+        const rows = db.prepare(`SELECT ud.unit_type, ud.unit_id
+       FROM unit_dispatches ud
+       INNER JOIN workers w ON w.worker_id = ud.worker_id
+       WHERE w.project_root_realpath = :project_root_realpath
+         AND w.status != 'crashed'
+         AND ud.trace_id = :trace_id
+       ORDER BY ud.started_at DESC, ud.id DESC
+       LIMIT :limit`).all({
+            ":project_root_realpath": projectRootRealpath,
+            ":trace_id": traceId,
+            ":limit": limit,
+        });
+        return rows.reverse().map((r) => ({ key: `${r.unit_type}/${r.unit_id}` }));
+    }
     const rows = db.prepare(`SELECT ud.unit_type, ud.unit_id
      FROM unit_dispatches ud
      INNER JOIN workers w ON w.worker_id = ud.worker_id