akm-cli 0.9.0-rc.1 → 0.9.0-rc.13

package/dist/storage/repositories/salience-repository.js

@@ -0,0 +1,172 @@
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at https://mozilla.org/MPL/2.0/.
+/**
+ * Upsert salience scores for one asset into state.db.
+ *
+ * Idempotent: safe to call every run; updates the outcome / retrieval / rank
+ * columns on conflict.
+ *
+ * #644 — encoding provenance guard: the `encoding_salience` + `encoding_source`
+ * columns are NOT lowered from a real content-derived score to a type-weight
+ * stub. When the stored row is `encoding_source = 'content'` and the incoming
+ * vector is a `type-stub` fallback, the stored encoding score and its provenance
+ * are preserved (only the other sub-scores and `rank_score` advance). A `content`
+ * write always wins; a `type-stub` write only seeds a row that has no content
+ * score yet. This stops the improve loop's type-weight fallback re-asserting the
+ * stub over a distill-written score on every run.
+ *
+ * NOTE: when the guard preserves the stored encoding score, the incoming
+ * `vector.rankScore` (computed from the stub encoding) is still written. Callers
+ * that want the rank_score to reflect the preserved content score should pass the
+ * stored content score back in as `inputs.encodingSalience` to `computeSalience`
+ * — which the improve loop does. The guard here is the defensive backstop.
+ */
+export function upsertAssetSalience(db, ref, vector, now) {
+    const ts = now ?? Date.now();
+    db.prepare(`INSERT INTO asset_salience
+       (asset_ref, encoding_salience, outcome_salience, retrieval_salience, rank_score, consecutive_no_ops, updated_at, encoding_source)
+     VALUES (?, ?, ?, ?, ?, 0, ?, ?)
+     ON CONFLICT(asset_ref) DO UPDATE SET
+       -- #644: never lower a real content-derived score to a type-weight stub.
+       -- Keep the stored encoding score + provenance when the stored row is
+       -- 'content' and the incoming write is a 'type-stub' fallback.
+       encoding_salience  = CASE
+         WHEN asset_salience.encoding_source = 'content' AND excluded.encoding_source = 'type-stub'
+           THEN asset_salience.encoding_salience
+           ELSE excluded.encoding_salience
+       END,
+       encoding_source    = CASE
+         WHEN asset_salience.encoding_source = 'content' AND excluded.encoding_source = 'type-stub'
+           THEN asset_salience.encoding_source
+           ELSE excluded.encoding_source
+       END,
+       outcome_salience   = excluded.outcome_salience,
+       retrieval_salience = excluded.retrieval_salience,
+       rank_score         = excluded.rank_score,
+       updated_at         = excluded.updated_at`).run(ref, vector.encoding, vector.outcome, vector.retrieval, vector.rankScore, ts, vector.encodingSource ?? "type-stub");
+}
+/**
+ * Load the salience row for one asset, or undefined if not yet computed.
+ */
+export function getAssetSalience(db, ref) {
+    const row = db
+        .prepare(`SELECT asset_ref, encoding_salience, outcome_salience, retrieval_salience,
+              rank_score, consecutive_no_ops, updated_at, encoding_source
+       FROM asset_salience WHERE asset_ref = ?`)
+        .get(ref);
+    // Bun SQLite returns null (not undefined) when no row found.
+    return row == null ? undefined : row;
+}
+/**
+ * Load ALL rank scores from the asset_salience table (full-stash query).
+ *
+ * Used by the forgetting-safety report (plan §WS-1 step 7) to compute stash-wide
+ * rank positions rather than pool-relative positions. Returns an empty Map when the
+ * table is empty (first WS-1 run = no pre-existing rows).
+ *
+ * Order is unspecified; callers must sort before assigning 1-indexed positions.
+ */
+export function getAllRankScores(db) {
+    const rows = db.prepare("SELECT asset_ref, rank_score FROM asset_salience").all();
+    const result = new Map();
+    for (const row of rows) {
+        result.set(row.asset_ref, row.rank_score);
+    }
+    return result;
+}
+// ── Plasticity helpers ────────────────────────────────────────────────────────
+/**
+ * Increment `consecutive_no_ops` for an asset. Called after a no-op reflect/distill.
+ * Has NO effect on `rank_score` — the plasticity counter only dampens consolidation
+ * selection, not retrieval ranking. See plan §WS-1 step 8.
+ *
+ * Invariant: recordNoOp must never originate rank_score semantics. If the asset has
+ * no salience row yet (persistence's best-effort try/catch may have swallowed an
+ * error), we do nothing — a no-op counter is meaningless without a rank_score row,
+ * and a synthetic INSERT would fabricate a rank_score=0 entry that could produce
+ * false catastrophic-forgetting signals in buildRankChangeReport.
+ */
+export function recordNoOp(db, ref) {
+    db.prepare(`UPDATE asset_salience SET consecutive_no_ops = consecutive_no_ops + 1, updated_at = ? WHERE asset_ref = ?`).run(Date.now(), ref);
+    // If changes === 0 the asset has no salience row yet — leave the table unchanged.
+}
+/**
+ * Reset `consecutive_no_ops` to 0 when an asset produces an accepted change.
+ * Call after a successful proposal acceptance or detected mutation.
+ */
+export function resetConsecutiveNoOps(db, ref) {
+    db.prepare(`UPDATE asset_salience SET consecutive_no_ops = 0, updated_at = ? WHERE asset_ref = ?`).run(Date.now(), ref);
+}
+/**
+ * Return the `consecutive_no_ops` count for one asset. 0 when unknown.
+ */
+export function getConsecutiveNoOps(db, ref) {
+    const row = db.prepare(`SELECT consecutive_no_ops FROM asset_salience WHERE asset_ref = ?`).get(ref);
+    return row?.consecutive_no_ops ?? 0;
+}
+// ── New in #672 part 2 ────────────────────────────────────────────────────────
+/**
+ * Load the `retrieval_salience` column for the top `limit` assets ordered by
+ * `rank_score` descending.
+ *
+ * Absorbs the health read formerly inlined in `commands/health/metrics.ts`
+ * (`computeDegradationMetrics`'s corpus-diversity Gini calculation) — same
+ * query, now parameterised on `limit` instead of a hardcoded 100. This is new
+ * behavior (a named, parameterised repository entry point), not a verbatim
+ * move; callers that need fail-open behaviour on a missing table (pre-WS-1
+ * installs) must wrap the call in their own try/catch, matching the existing
+ * call site.
+ */
+export function getTopRetrievalSalience(db, limit) {
+    return db
+        .prepare(`SELECT retrieval_salience FROM asset_salience ORDER BY rank_score DESC LIMIT ?`)
+        .all(limit);
+}
+/** List every `asset_salience` ref with its current `missing_since` marker. */
+export function listAssetSalienceMissingState(db) {
+    return db.prepare(`SELECT asset_ref, missing_since FROM asset_salience`).all();
+}
+/**
+ * Stamp `missing_since = now` for the given refs, but ONLY where it is
+ * currently NULL — a ref already stamped keeps its original timestamp so the
+ * grace window measures from first sighting, not last. Refs with no row at
+ * all are silently skipped (0 rows affected). Returns the number of rows
+ * actually stamped.
+ */
+export function stampAssetSalienceMissing(db, refs, now) {
+    if (refs.length === 0)
+        return 0;
+    const stmt = db.prepare(`UPDATE asset_salience SET missing_since = ? WHERE asset_ref = ? AND missing_since IS NULL`);
+    let changed = 0;
+    for (const ref of refs)
+        changed += Number(stmt.run(now, ref).changes);
+    return changed;
+}
+/**
+ * Clear `missing_since` for refs that resolved again. Returns the number of
+ * rows actually cleared.
+ */
+export function clearAssetSalienceMissing(db, refs) {
+    if (refs.length === 0)
+        return 0;
+    const stmt = db.prepare(`UPDATE asset_salience SET missing_since = NULL WHERE asset_ref = ? AND missing_since IS NOT NULL`);
+    let changed = 0;
+    for (const ref of refs)
+        changed += Number(stmt.run(ref).changes);
+    return changed;
+}
+/**
+ * Delete `asset_salience` rows whose `missing_since` is older than
+ * `cutoffMs`. A single DELETE — SQLite runs it as one implicit transaction.
+ * Returns the number of rows deleted.
+ */
+export function deleteAssetSalienceMissingBefore(db, cutoffMs) {
+    return Number(db.prepare(`DELETE FROM asset_salience WHERE missing_since IS NOT NULL AND missing_since < ?`).run(cutoffMs)
+        .changes);
+}
+/** Count `asset_salience` rows currently marked missing (the live backlog size). */
+export function countAssetSalienceMissing(db) {
+    const row = db.prepare(`SELECT COUNT(*) AS n FROM asset_salience WHERE missing_since IS NOT NULL`).get();
+    return row.n;
+}

package/dist/storage/repositories/task-history-repository.js

@@ -1,6 +1,110 @@
 // This Source Code Form is subject to the terms of the Mozilla Public
 // License, v. 2.0. If a copy of the MPL was not distributed with this
 // file, You can obtain one at https://mozilla.org/MPL/2.0/.
+function metadataError(message) {
+    throw new Error(`invalid task_history metadata_json: ${message}`);
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function validateDetail(value) {
+    if (value === undefined || value === null)
+        return;
+    if (!isRecord(value))
+        metadataError("detail must be an object or null");
+    const allowed = new Set(["runId", "reason", "error", "exitCode"]);
+    const unknown = Object.keys(value).filter((key) => !allowed.has(key));
+    if (unknown.length > 0)
+        metadataError(`unknown detail fields: ${unknown.sort().join(", ")}`);
+    for (const field of ["runId", "reason", "error"]) {
+        if (value[field] !== undefined && typeof value[field] !== "string")
+            metadataError(`detail.${field} must be a string`);
+    }
+    if (value.exitCode !== undefined && value.exitCode !== null && typeof value.exitCode !== "number") {
+        metadataError("detail.exitCode must be a number or null");
+    }
+}
+/** Decode supported historical and current task-history metadata. */
+export function decodeTaskHistoryMetadata(input) {
+    let parsed = input;
+    if (typeof input === "string") {
+        try {
+            parsed = JSON.parse(input);
+        }
+        catch {
+            metadataError("not valid JSON");
+        }
+    }
+    if (!isRecord(parsed))
+        metadataError("root must be an object");
+    if (parsed.metadataVersion === undefined || parsed.metadataVersion === 1) {
+        const allowed = new Set(["metadataVersion", "durationMs", "detail", "profile"]);
+        const unknown = Object.keys(parsed).filter((key) => !allowed.has(key));
+        if (unknown.length > 0)
+            metadataError(`unknown v1 fields: ${unknown.sort().join(", ")}`);
+        if (parsed.durationMs !== undefined && typeof parsed.durationMs !== "number") {
+            metadataError("durationMs must be a number");
+        }
+        if (parsed.profile !== undefined && typeof parsed.profile !== "string") {
+            metadataError("profile must be a string");
+        }
+        validateDetail(parsed.detail);
+        return {
+            metadataVersion: 1,
+            durationMs: parsed.durationMs ?? 0,
+            detail: parsed.detail ?? null,
+            ...(parsed.profile !== undefined ? { legacyProfile: parsed.profile } : {}),
+        };
+    }
+    if (parsed.metadataVersion === 2) {
+        const allowed = new Set(["metadataVersion", "durationMs", "detail", "engine"]);
+        const unknown = Object.keys(parsed).filter((key) => !allowed.has(key));
+        if (unknown.length > 0)
+            metadataError(`unknown v2 fields: ${unknown.sort().join(", ")}`);
+        if (typeof parsed.durationMs !== "number")
+            metadataError("durationMs must be a number");
+        if (!("detail" in parsed))
+            metadataError("detail is required in v2");
+        if (parsed.engine !== undefined && parsed.engine !== null && typeof parsed.engine !== "string") {
+            metadataError("engine must be a string or null");
+        }
+        validateDetail(parsed.detail);
+        return {
+            metadataVersion: 2,
+            durationMs: parsed.durationMs,
+            detail: parsed.detail ?? null,
+            ...(parsed.engine !== undefined ? { engine: parsed.engine } : {}),
+        };
+    }
+    metadataError(`unsupported metadataVersion: ${String(parsed.metadataVersion)}`);
+}
+/**
+ * Atomically reserve one task-attempt identity.
+ *
+ * The existing unique `(task_id, started_at)` index arbitrates concurrent
+ * processes: exactly one caller receives `true` for a candidate timestamp.
+ * Callers can advance by one millisecond and retry without a schema change.
+ */
+export function reserveTaskHistoryAttempt(db, row) {
+    const result = db
+        .prepare(`INSERT OR IGNORE INTO task_history
+         (task_id, status, started_at, completed_at, failed_at, log_path,
+          target_kind, target_ref, metadata_json)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`)
+        .run(row.task_id, row.status, row.started_at, row.completed_at ?? null, row.failed_at ?? null, row.log_path ?? null, row.target_kind ?? null, row.target_ref ?? null, row.metadata_json);
+    return Number(result.changes) === 1;
+}
+/** Finalize a row previously created by {@link reserveTaskHistoryAttempt}. */
+export function finalizeTaskHistoryAttempt(db, row) {
+    const result = db
+        .prepare(`UPDATE task_history
+       SET status = ?, completed_at = ?, failed_at = ?, log_path = ?,
+           target_kind = ?, target_ref = ?, metadata_json = ?
+       WHERE task_id = ? AND started_at = ?
+         AND status = 'active' AND completed_at IS NULL`)
+        .run(row.status, row.completed_at ?? null, row.failed_at ?? null, row.log_path ?? null, row.target_kind ?? null, row.target_ref ?? null, row.metadata_json, row.task_id, row.started_at);
+    return Number(result.changes) === 1;
+}
 /**
  * Upsert a task history row.
  */
@@ -24,7 +128,7 @@ export function getTaskHistory(db, taskId) {
     return db
         .prepare(`SELECT id, task_id, status, started_at, completed_at, failed_at, log_path,
               target_kind, target_ref, metadata_json
-       FROM task_history WHERE task_id = ? ORDER BY started_at DESC LIMIT 1`)
+       FROM task_history WHERE task_id = ? ORDER BY started_at DESC, id DESC LIMIT 1`)
         .get(taskId);
 }
 /**
@@ -34,7 +138,7 @@ export function getTaskHistoryRuns(db, taskId, limit = 50) {
     return db
         .prepare(`SELECT id, task_id, status, started_at, completed_at, failed_at, log_path,
               target_kind, target_ref, metadata_json
-       FROM task_history WHERE task_id = ? ORDER BY started_at DESC LIMIT ?`)
+       FROM task_history WHERE task_id = ? ORDER BY started_at DESC, id DESC LIMIT ?`)
         .all(taskId, limit);
 }
 /**
@@ -64,10 +168,13 @@ export function queryTaskHistory(db, options = {}) {
         params.push(options.targetRef);
     }
     const where = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
+    const limit = options.limit !== undefined ? "LIMIT ?" : "";
+    if (options.limit !== undefined)
+        params.push(options.limit);
     return db
         .prepare(`SELECT task_id, status, started_at, completed_at, failed_at, log_path,
               target_kind, target_ref, metadata_json
-       FROM task_history ${where} ORDER BY started_at DESC`)
+       FROM task_history ${where} ORDER BY started_at DESC, id DESC ${limit}`)
         .all(...params);
 }
 /**

package/dist/storage/repositories/workflow-runs-repository.js

@@ -1,13 +1,15 @@
 // This Source Code Form is subject to the terms of the Mozilla Public
 // License, v. 2.0. If a copy of the MPL was not distributed with this
 // file, You can obtain one at https://mozilla.org/MPL/2.0/.
-import { closeWorkflowDatabase, openWorkflowDatabase } from "../../workflows/db.js";
+import { openStateDatabase, withImmediateTransaction } from "../../core/state-db.js";
 import { resolveStorageLocations } from "../locations.js";
 /**
  * Repository owning every raw SQL statement against `workflow_runs` and
  * `workflow_run_steps`. It is DB-location-agnostic: the lifecycle helper
- * {@link withWorkflowRunsRepo} binds it to {@link StorageLocations.workflowDb}
- * so a future storage move (#489) changes only `locations.ts`.
+ * {@link withWorkflowRunsRepo} binds it to {@link StorageLocations.stateDb}
+ * (the three-DB cutover folded workflow.db into state.db; the tables exist via
+ * state migration `020-three-db-cutover`) so a future storage move (#489)
+ * changes only `locations.ts`.
  *
  * ## Connection-lifetime contract (WS5)
  *
@@ -28,19 +30,28 @@ export class WorkflowRunsRepository {
     transaction(fn) {
         return this.db.transaction(fn)();
     }
+    immediateTransaction(fn) {
+        return withImmediateTransaction(this.db, () => fn(this.db));
+    }
     // ── reads (fully materialised) ─────────────────────────────────────────────
-    findActiveRunForScope(workflowRef, scopeKey) {
+    findActiveRunForScope(workflowRefs, scopeKey) {
+        const refs = typeof workflowRefs === "string" ? [workflowRefs] : [...workflowRefs];
+        if (refs.length === 0)
+            return undefined;
         return this.db
-            .prepare("SELECT id, current_step_id FROM workflow_runs WHERE workflow_ref = ? AND scope_key = ? AND status = 'active' ORDER BY updated_at DESC LIMIT 1")
-            .get(workflowRef, scopeKey);
+            .prepare(`SELECT id, current_step_id FROM workflow_runs WHERE workflow_ref IN (${refs.map(() => "?").join(", ")}) AND scope_key = ? AND status = 'active' ORDER BY updated_at DESC, created_at DESC LIMIT 1`)
+            .get(...refs, scopeKey);
     }
     getRunById(runId) {
         return this.db.prepare("SELECT * FROM workflow_runs WHERE id = ?").get(runId);
     }
-    getActiveRunRowForScope(workflowRef, scopeKey) {
+    getActiveRunRowForScope(workflowRefs, scopeKey) {
+        const refs = typeof workflowRefs === "string" ? [workflowRefs] : [...workflowRefs];
+        if (refs.length === 0)
+            return undefined;
         return this.db
-            .prepare("SELECT * FROM workflow_runs WHERE workflow_ref = ? AND scope_key = ? AND status = 'active' ORDER BY updated_at DESC LIMIT 1")
-            .get(workflowRef, scopeKey);
+            .prepare(`SELECT * FROM workflow_runs WHERE workflow_ref IN (${refs.map(() => "?").join(", ")}) AND scope_key = ? AND status = 'active' ORDER BY updated_at DESC, created_at DESC LIMIT 1`)
+            .get(...refs, scopeKey);
     }
     hasRun(runId) {
         const row = this.db.prepare("SELECT 1 FROM workflow_runs WHERE id = ? LIMIT 1").get(runId);
@@ -55,6 +66,10 @@ export class WorkflowRunsRepository {
             filters.push("workflow_ref = ?");
             params.push(filter.workflowRef);
         }
+        else if (filter.workflowRefs && filter.workflowRefs.length > 0) {
+            filters.push(`workflow_ref IN (${filter.workflowRefs.map(() => "?").join(", ")})`);
+            params.push(...filter.workflowRefs);
+        }
         if (filter.activeOnly) {
             // `activeOnly` means EXACTLY status='active' — a run currently
             // executable. A `blocked` run is NOT active (it is parked awaiting a
@@ -111,7 +126,9 @@ export class WorkflowRunsRepository {
             .run(runId, currentStepId);
     }
     markRunActive(runId, updatedAt) {
-        this.db.prepare("UPDATE workflow_runs SET status = 'active', updated_at = ? WHERE id = ?").run(updatedAt, runId);
+        this.db
+            .prepare("UPDATE workflow_runs SET status = 'active', updated_at = ?, engine_lease_holder = NULL, engine_lease_until = NULL WHERE id = ?")
+            .run(updatedAt, runId);
     }
     updateStepCompletion(input) {
         this.db
@@ -127,6 +144,14 @@ export class WorkflowRunsRepository {
            WHERE id = ?`)
             .run(input.status, input.currentStepId, input.updatedAt, input.completedAt, input.checkinArmedAt, input.runId);
     }
+    markRunAbandoned(runId, updatedAt) {
+        const result = this.db
+            .prepare(`UPDATE workflow_runs
+           SET status = 'failed', updated_at = ?, completed_at = ?, checkin_armed_at = ?
+           WHERE id = ? AND status IN ('active', 'blocked')`)
+            .run(updatedAt, updatedAt, updatedAt, runId);
+        return Number(result.changes) === 1;
+    }
     rearmCheckin(runId, checkinArmedAt) {
         this.db.prepare("UPDATE workflow_runs SET checkin_armed_at = ? WHERE id = ?").run(checkinArmedAt, runId);
     }
@@ -137,10 +162,10 @@ export class WorkflowRunsRepository {
      * `insertRun`, so a run row never exists without its frozen plan. Read back
      * via {@link getRunById} (`plan_json` / `plan_hash` on the row).
      */
-    setRunPlan(runId, planJson, planHash) {
+    setRunPlan(runId, planJson, planHash, planIrVersion = 3) {
         this.db
-            .prepare("UPDATE workflow_runs SET plan_json = ?, plan_hash = ? WHERE id = ?")
-            .run(planJson, planHash, runId);
+            .prepare("UPDATE workflow_runs SET plan_json = ?, plan_hash = ?, plan_ir_version = ? WHERE id = ?")
+            .run(planJson, planHash, planIrVersion, runId);
     }
     // ── engine run lease (migration 006 columns, R2 enforcement) ──────────────
     //
@@ -159,7 +184,8 @@ export class WorkflowRunsRepository {
         const result = this.db
             .prepare(`UPDATE workflow_runs
            SET engine_lease_holder = ?, engine_lease_until = ?
-           WHERE id = ? AND (engine_lease_holder IS NULL OR engine_lease_until IS NULL OR engine_lease_until < ?)`)
+           WHERE id = ? AND status = 'active'
+             AND (engine_lease_holder IS NULL OR engine_lease_until IS NULL OR engine_lease_until < ?)`)
             .run(holder, until, runId, now);
         return Number(result.changes) > 0;
     }
@@ -170,18 +196,18 @@ export class WorkflowRunsRepository {
      */
     renewEngineLease(runId, holder, until) {
         const result = this.db
-            .prepare("UPDATE workflow_runs SET engine_lease_until = ? WHERE id = ? AND engine_lease_holder = ?")
+            .prepare("UPDATE workflow_runs SET engine_lease_until = ? WHERE id = ? AND engine_lease_holder = ? AND status = 'active'")
             .run(until, runId, holder);
         return Number(result.changes) > 0;
     }
     /**
-     * Clear the lease — only while `holder` still owns it, so a crashed-then-
-     * recovered invocation can never release a lease another engine has since
-     * claimed. Releasing an already-lost lease is a harmless no-op.
+     * Clear the lease only while `holder` still owns a non-failed run. Failed
+     * runs retain the final holder/expiry for forensics until explicit resume.
+     * Releasing an already-lost lease is a harmless no-op.
      */
     releaseEngineLease(runId, holder) {
         this.db
-            .prepare("UPDATE workflow_runs SET engine_lease_holder = NULL, engine_lease_until = NULL WHERE id = ? AND engine_lease_holder = ?")
+            .prepare("UPDATE workflow_runs SET engine_lease_holder = NULL, engine_lease_until = NULL WHERE id = ? AND engine_lease_holder = ? AND status <> 'failed'")
             .run(runId, holder);
     }
     // ── unit rows (migration 004) ──────────────────────────────────────────────
@@ -238,15 +264,16 @@ export class WorkflowRunsRepository {
     insertUnit(input) {
         this.db
             .prepare(`INSERT INTO workflow_run_units (
-          run_id, unit_id, step_id, node_id, parent_unit_id, phase, runner, model,
+          run_id, unit_id, step_id, node_id, parent_unit_id, phase, runner, engine, model,
           status, input_hash, worktree_path, started_at, claim_holder, claim_expires_at
-        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, 'running', ?, ?, ?, ?, ?)
+        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, 'running', ?, ?, ?, ?, ?)
         ON CONFLICT(run_id, unit_id) DO UPDATE SET
           step_id          = excluded.step_id,
           node_id          = excluded.node_id,
           parent_unit_id   = excluded.parent_unit_id,
-          phase            = excluded.phase,
-          runner           = excluded.runner,
+           phase            = excluded.phase,
+           runner           = excluded.runner,
+           engine           = excluded.engine,
           model            = excluded.model,
           status           = excluded.status,
           input_hash       = excluded.input_hash,
@@ -261,7 +288,7 @@ export class WorkflowRunsRepository {
           finished_at      = NULL,
           last_checkin_at  = NULL,
           attempts         = workflow_run_units.attempts + 1`)
-            .run(input.runId, input.unitId, input.stepId, input.nodeId, input.parentUnitId, input.phase, input.runner, input.model, input.inputHash, input.worktreePath ?? null, input.startedAt, input.claimHolder ?? null, input.claimExpiresAt ?? null);
+            .run(input.runId, input.unitId, input.stepId, input.nodeId, input.parentUnitId, input.phase, input.runner, input.engine ?? null, input.model, input.inputHash, input.worktreePath ?? null, input.startedAt, input.claimHolder ?? null, input.claimExpiresAt ?? null);
     }
     /**
      * Stamp a `--status running` claim + heartbeat on a unit row (migration 009,
@@ -273,11 +300,13 @@ export class WorkflowRunsRepository {
      * marker set by {@link insertUnit}).
      */
     updateUnitClaim(runId, unitId, holder, expiresAt, lastCheckinAt) {
-        this.db
+        const result = this.db
             .prepare(`UPDATE workflow_run_units
            SET status = 'running', last_checkin_at = ?, claim_holder = ?, claim_expires_at = ?
-           WHERE run_id = ? AND unit_id = ?`)
-            .run(lastCheckinAt, holder, expiresAt, runId, unitId);
+           WHERE run_id = ? AND unit_id = ?
+             AND EXISTS (SELECT 1 FROM workflow_runs WHERE id = ? AND status = 'active')`)
+            .run(lastCheckinAt, holder, expiresAt, runId, unitId, runId);
+        return Number(result.changes) === 1;
     }
     /**
      * Record a unit's terminal state (completed / failed / skipped).
@@ -310,20 +339,24 @@ export class WorkflowRunsRepository {
     }
 }
 /**
- * Open the workflow database (bound to {@link StorageLocations.workflowDb}),
- * run `fn` against a {@link WorkflowRunsRepository}, and close the connection
- * exactly once when `fn` settles.
+ * Open state.db (bound to {@link StorageLocations.stateDb}, the post-cutover
+ * home of the `workflow_runs` / `workflow_run_steps` / `workflow_run_units`
+ * tables), run `fn` against a {@link WorkflowRunsRepository}, and close the
+ * connection exactly once when `fn` settles.
  *
- * Generalises the former `withWorkflowDb` loan pattern in runs.ts. Repository
- * read methods fully materialise their results, so closing here never truncates
- * lazy iteration (WS5 connection-lifetime rule).
+ * Fresh-connection-per-call, mirroring the former workflow.db loan pattern:
+ * `openStateDatabase` acquires its own maintenance activity + asserts the
+ * current ledger, and the repository owns all table-scoped SQL, so the merge
+ * into state.db is a zero-SQL-rewrite repoint. Repository read methods fully
+ * materialise their results, so closing here never truncates lazy iteration
+ * (WS5 connection-lifetime rule).
  */
 export async function withWorkflowRunsRepo(fn) {
-    const db = openWorkflowDatabase(resolveStorageLocations().workflowDb);
+    const db = openStateDatabase(resolveStorageLocations().stateDb);
     try {
         return await Promise.resolve(fn(new WorkflowRunsRepository(db)));
     }
     finally {
-        closeWorkflowDatabase(db);
+        db.close();
     }
 }