ai-foreman 1.6.2 → 1.7.0

package/dist/tickets/queue.js

@@ -1,4 +1,5 @@
 import { resolveBlockers, computeDisplayStatus } from "./blockers.js";
+import { normalizeStackNodes } from "./delivery.js";
 function defaultNextAction(ticket, displayStatus, blockedBy) {
     if (displayStatus === "blocked")
         return `Resolve blockers: ${blockedBy.join(", ")}`;
@@ -11,7 +12,7 @@ export function buildNextQueue(ticketDefs, states, queueLimit) {
         .filter((t) => {
         const s = states.get(t.id);
         const status = s?.status ?? "planned";
-        return status !== "done" && status !== "canceled";
+        return status !== "done" && status !== "canceled" && status !== "obsolete";
     })
         .sort((a, b) => a.order - b.order);
     const window = remaining.slice(0, Math.min(queueLimit, remaining.length));
@@ -60,3 +61,51 @@ export function buildActiveStatusRows(queueRows, ticketDefs, states) {
         };
     });
 }
+/** Human-readable queue blocks keep a whole unfinished stack and its resume point visible. */
+export function formatStackAwareQueue(ticketDefs, states, delivery) {
+    if (!delivery?.stacks?.length)
+        return buildNextQueue(ticketDefs, states, Number.MAX_SAFE_INTEGER).map((row) => `${row.ticket} ${row.status} ${row.title}`);
+    const defs = new Map(ticketDefs.map((ticket) => [ticket.id, ticket]));
+    const unitById = new Map(delivery.units.map((unit) => [unit.id, unit]));
+    const stackedTickets = new Set();
+    const lines = [];
+    for (const stack of delivery.stacks) {
+        const nodes = normalizeStackNodes(stack, delivery.units, ticketDefs);
+        const ticketIds = stack.units.flatMap((id) => unitById.get(id)?.tickets ?? []);
+        ticketIds.forEach((id) => stackedTickets.add(id));
+        const completed = ticketIds.filter((id) => terminal(states.get(id)?.status));
+        if (completed.length === ticketIds.length && (stack.status ?? "planned") === "merged")
+            continue;
+        const next = ticketIds.find((id) => !terminal(states.get(id)?.status));
+        const blockers = next && defs.get(next) ? resolveBlockers(defs.get(next), states) : [];
+        const state = deriveStackState(stack, ticketIds, states, blockers);
+        lines.push(`=== STACK START: ${stack.name} (${stack.id}) ===`);
+        lines.push(`status=${state}; size=${ticketIds.length}; pr_depth=${nodes.length}; blockers=${blockers.join(",") || "none"}; completed_prefix=${completed.join(",") || "none"}; next=${next ?? "none"}`);
+        lines.push(`reviews=${stack.review_links?.join(",") || "none"}; remote_checked=${stack.remote_checked_at ?? "never"}${stack.remote_stale ? " (stale; run --refresh for a live check)" : ""}`);
+        for (const id of ticketIds)
+            lines.push(`${id} ${states.get(id)?.status ?? "planned"} ${defs.get(id)?.title ?? "unknown ticket"}`);
+        lines.push(`=== STACK END: ${stack.name} (${stack.id}) ===`);
+    }
+    for (const ticket of ticketDefs.sort((a, b) => a.order - b.order)) {
+        if (stackedTickets.has(ticket.id) || terminal(states.get(ticket.id)?.status))
+            continue;
+        const blockers = resolveBlockers(ticket, states);
+        lines.push(`${ticket.id} ${computeDisplayStatus(states.get(ticket.id)?.status ?? "planned", blockers)} ${ticket.title}`);
+    }
+    return lines;
+}
+function terminal(status) { return status === "done" || status === "canceled" || status === "obsolete"; }
+function deriveStackState(stack, tickets, states, blockers) {
+    if (stack.status === "merged")
+        return "merged";
+    if (stack.status === "awaiting_review")
+        return "awaiting_review";
+    if (blockers.length)
+        return "blocked";
+    const completed = tickets.filter((id) => terminal(states.get(id)?.status)).length;
+    if (completed === 0)
+        return stack.status ?? "planned";
+    if (completed < tickets.length)
+        return "partial";
+    return "awaiting_review";
+}

package/dist/tickets/stateDb.d.ts

@@ -1,4 +1,4 @@
-export type TicketStatus = "planned" | "next" | "in_progress" | "blocked" | "done" | "canceled";
+export type TicketStatus = "planned" | "next" | "in_progress" | "blocked" | "done" | "canceled" | "obsolete";
 export type ValidationResult = "passed" | "failed" | "not_run" | "not_applicable";
 export interface TicketState {
     ticket_id: string;
@@ -92,6 +92,7 @@ export interface OperationReceipt {
 export declare class StateDb {
     private db;
     constructor(dbPath: string);
+    private migrateObsoleteStatus;
     close(): void;
     getState(ticketId: string): TicketState | undefined;
     getAllStates(): Map<string, TicketState>;

package/dist/tickets/stateDb.js

@@ -25,7 +25,7 @@ CREATE TABLE IF NOT EXISTS ticket_state (
   validation_notes TEXT,
   updated_at TEXT NOT NULL,
   updated_by TEXT,
-  CHECK (status IN ('planned','next','in_progress','blocked','done','canceled')),
+  CHECK (status IN ('planned','next','in_progress','blocked','done','canceled','obsolete')),
   CHECK (validation_result IS NULL OR validation_result IN ('passed','failed','not_run','not_applicable'))
 );
 
@@ -120,6 +120,29 @@ export class StateDb {
         this.db = new Database(dbPath);
         this.db.pragma("journal_mode = WAL");
         this.db.exec(INIT_SQL);
+        this.migrateObsoleteStatus();
+    }
+    migrateObsoleteStatus() {
+        const row = this.db.prepare("SELECT sql FROM sqlite_master WHERE type='table' AND name='ticket_state'").get();
+        if (!row || row.sql.includes("'obsolete'"))
+            return;
+        this.db.pragma("foreign_keys = OFF");
+        this.db.exec(`
+      DROP INDEX IF EXISTS idx_ticket_state_status;
+      ALTER TABLE ticket_state RENAME TO ticket_state_legacy;
+      CREATE TABLE ticket_state (
+        ticket_id TEXT PRIMARY KEY,status TEXT NOT NULL DEFAULT 'planned',owner TEXT,current_step TEXT,next_action TEXT,
+        blocked_by_json TEXT NOT NULL DEFAULT '[]',blocker_type TEXT,blocker_notes TEXT,first_blocked_at TEXT,last_checked_at TEXT,
+        last_worked_at TEXT,completed_at TEXT,attempt_count INTEGER NOT NULL DEFAULT 0,last_error TEXT,evidence TEXT,
+        validation_result TEXT,validation_commands TEXT,validation_notes TEXT,updated_at TEXT NOT NULL,updated_by TEXT,
+        CHECK (status IN ('planned','next','in_progress','blocked','done','canceled','obsolete')),
+        CHECK (validation_result IS NULL OR validation_result IN ('passed','failed','not_run','not_applicable'))
+      );
+      INSERT INTO ticket_state SELECT * FROM ticket_state_legacy;
+      DROP TABLE ticket_state_legacy;
+      CREATE INDEX idx_ticket_state_status ON ticket_state(status);
+    `);
+        this.db.pragma("foreign_keys = ON");
     }
     close() {
         this.db.close();

package/dist/tickets/ticketSchema.d.ts

@@ -15,6 +15,11 @@ export interface TicketSourceRef {
     fingerprint?: string | null;
     note?: string | null;
 }
+export interface TicketPlanRef {
+    plan_id: string;
+    revision: number;
+    slice_ref: string;
+}
 export interface TicketDef {
     id: string;
     order: number;
@@ -34,6 +39,7 @@ export interface TicketDef {
     source_refs?: TicketSourceRef[];
     superseded_by?: string[];
     supersedes?: string[];
+    plan_ref?: TicketPlanRef;
 }
 export declare const TICKET_JSON_SCHEMA: {
     readonly type: "object";
@@ -169,6 +175,25 @@ export declare const TICKET_JSON_SCHEMA: {
             };
             readonly uniqueItems: true;
         };
+        readonly plan_ref: {
+            readonly type: "object";
+            readonly required: readonly ["plan_id", "revision", "slice_ref"];
+            readonly additionalProperties: false;
+            readonly properties: {
+                readonly plan_id: {
+                    readonly type: "string";
+                    readonly minLength: 1;
+                };
+                readonly revision: {
+                    readonly type: "integer";
+                    readonly minimum: 1;
+                };
+                readonly slice_ref: {
+                    readonly type: "string";
+                    readonly minLength: 1;
+                };
+            };
+        };
     };
 };
 export declare const TICKETS_FILE_SCHEMA: {
@@ -311,6 +336,25 @@ export declare const TICKETS_FILE_SCHEMA: {
                         };
                         readonly uniqueItems: true;
                     };
+                    readonly plan_ref: {
+                        readonly type: "object";
+                        readonly required: readonly ["plan_id", "revision", "slice_ref"];
+                        readonly additionalProperties: false;
+                        readonly properties: {
+                            readonly plan_id: {
+                                readonly type: "string";
+                                readonly minLength: 1;
+                            };
+                            readonly revision: {
+                                readonly type: "integer";
+                                readonly minimum: 1;
+                            };
+                            readonly slice_ref: {
+                                readonly type: "string";
+                                readonly minLength: 1;
+                            };
+                        };
+                    };
                 };
             };
         };

package/dist/tickets/ticketSchema.js

@@ -51,6 +51,16 @@ export const TICKET_JSON_SCHEMA = {
         },
         superseded_by: { type: "array", items: { type: "string" }, uniqueItems: true },
         supersedes: { type: "array", items: { type: "string" }, uniqueItems: true },
+        plan_ref: {
+            type: "object",
+            required: ["plan_id", "revision", "slice_ref"],
+            additionalProperties: false,
+            properties: {
+                plan_id: { type: "string", minLength: 1 },
+                revision: { type: "integer", minimum: 1 },
+                slice_ref: { type: "string", minLength: 1 },
+            },
+        },
     },
 };
 export const TICKETS_FILE_SCHEMA = {

package/dist/tickets/validate.js

@@ -40,7 +40,7 @@ export function runAllValidation(config, projectDir, ticketDefs, states, db) {
     const queueRows = buildNextQueue(ticketDefs, states, config.implementationLimit);
     const remaining = ticketDefs.filter((t) => {
         const s = states.get(t.id);
-        return s?.status !== "done" && s?.status !== "canceled";
+        return s?.status !== "done" && s?.status !== "canceled" && s?.status !== "obsolete";
     });
     const expectedLen = Math.min(config.implementationLimit, remaining.length);
     if (queueRows.length !== expectedLen) {

package/dist/workflowDb.d.ts

@@ -0,0 +1,113 @@
+import type { OperationLifecycle, ResolvedAgentSettings, WorkflowIssue } from "rafi-spec";
+export declare const WORKFLOW_DB_FILE = ".rafi/recovery.sqlite3";
+export type WorkflowKind = "plan" | "ticket-plan" | "ticket-populate" | "uninstall" | "build" | "qa-remediation" | "recovery" | "legacy";
+export type WorkflowRunStatus = "running" | "paused" | "blocked" | "completed" | "failed" | "cancelled" | "superseded";
+export interface WorkflowRunSnapshot {
+    runId: string;
+    kind: WorkflowKind;
+    status: WorkflowRunStatus;
+    checkpoint: string;
+    originalWork: unknown;
+    remainingWork: unknown;
+    state: Record<string, unknown>;
+    leaseGeneration?: number;
+    legacy: boolean;
+    createdAt: string;
+    updatedAt: string;
+}
+export interface OperationRecord {
+    idempotencyKey: string;
+    runId: string;
+    kind: string;
+    status: OperationLifecycle;
+    intent: unknown;
+    result?: unknown;
+    externalId?: string;
+    error?: string;
+    createdAt: string;
+    updatedAt: string;
+}
+export interface ProjectLease {
+    owner: string;
+    generation: number;
+    pid: number;
+    host: string;
+    processStart: string;
+    heartbeatAt: string;
+    runId: string;
+}
+export interface PublicationTransaction {
+    transactionId: string;
+    runId: string;
+    status: "prepared" | "staged" | "tracker_committed" | "published" | "committed" | "rolled_back";
+    intent: unknown;
+    previousDigests: unknown;
+    createdAt: string;
+    updatedAt: string;
+}
+/** Authoritative persistence for every resumable workflow in a project. */
+export declare class WorkflowDb {
+    readonly projectDir: string;
+    readonly path: string;
+    private readonly db;
+    constructor(projectDir: string, path?: string);
+    close(): void;
+    createRun(input: {
+        runId?: string;
+        kind: WorkflowKind;
+        checkpoint?: string;
+        originalWork?: unknown;
+        remainingWork?: unknown;
+        state?: Record<string, unknown>;
+        legacy?: boolean;
+    }, now?: Date): WorkflowRunSnapshot;
+    getRun(runId: string): WorkflowRunSnapshot | undefined;
+    activeRuns(): WorkflowRunSnapshot[];
+    transition(runId: string, update: {
+        status?: WorkflowRunStatus;
+        checkpoint: string;
+        remainingWork?: unknown;
+        state?: Record<string, unknown>;
+        event?: string;
+        payload?: unknown;
+    }, now?: Date): WorkflowRunSnapshot;
+    events(runId: string): Array<{
+        sequence: number;
+        type: string;
+        checkpoint: string;
+        payload: unknown;
+        at: string;
+    }>;
+    recordSettings(runId: string, role: string, boundary: number, settings: ResolvedAgentSettings, now?: Date): void;
+    recordProjectSettingsRevision(revision: number, defaults: unknown, now?: Date): void;
+    recordTelemetry(runId: string, snapshot: unknown, now?: Date): void;
+    recordSession(runId: string, role: string, stream: string, sessionId: string | undefined, transition: string, settings: ResolvedAgentSettings, now?: Date): void;
+    recordIssue(runId: string, issue: WorkflowIssue): number;
+    issues(runId: string): WorkflowIssue[];
+    planOperation(input: {
+        runId: string;
+        idempotencyKey: string;
+        kind: string;
+        intent: unknown;
+    }, now?: Date): OperationRecord;
+    updateOperation(idempotencyKey: string, status: OperationLifecycle, details?: {
+        result?: unknown;
+        externalId?: string;
+        error?: string;
+    }, now?: Date): OperationRecord;
+    operation(idempotencyKey: string): OperationRecord | undefined;
+    operations(runId: string): OperationRecord[];
+    putEvidence(kind: "handoff" | "diff" | "test", value: string | Buffer, now?: Date): string;
+    getEvidence(digest: string): Buffer | undefined;
+    beginPublication(runId: string, intent: unknown, previousDigests: unknown, now?: Date): PublicationTransaction;
+    updatePublication(transactionId: string, status: PublicationTransaction["status"], now?: Date): PublicationTransaction;
+    publication(transactionId: string): PublicationTransaction | undefined;
+    incompletePublications(): PublicationTransaction[];
+    acquireLease(runId: string, owner?: string, now?: Date, staleMs?: number): ProjectLease;
+    heartbeatLease(lease: ProjectLease, now?: Date): ProjectLease;
+    releaseLease(lease: ProjectLease, now?: Date): void;
+    currentLease(): ProjectLease | undefined;
+    importLegacyOnce(now?: Date): number;
+    private insertEvent;
+    private migrate;
+}

package/dist/workflowDb.js

@@ -0,0 +1,261 @@
+import { createHash, randomUUID } from "node:crypto";
+import { appendFileSync, existsSync, mkdirSync, readFileSync, readdirSync, statSync } from "node:fs";
+import { hostname } from "node:os";
+import { dirname, join, resolve } from "node:path";
+import Database from "better-sqlite3";
+export const WORKFLOW_DB_FILE = ".rafi/recovery.sqlite3";
+/** Authoritative persistence for every resumable workflow in a project. */
+export class WorkflowDb {
+    projectDir;
+    path;
+    db;
+    constructor(projectDir, path = join(resolve(projectDir), WORKFLOW_DB_FILE)) {
+        this.projectDir = projectDir;
+        this.path = path;
+        mkdirSync(dirname(path), { recursive: true });
+        ensureRecoveryGitignore(resolve(projectDir));
+        this.db = new Database(path);
+        this.db.pragma("journal_mode = WAL");
+        this.db.pragma("synchronous = FULL");
+        this.db.pragma("foreign_keys = ON");
+        this.migrate();
+        this.importLegacyOnce();
+    }
+    close() { this.db.close(); }
+    createRun(input, now = new Date()) {
+        const at = now.toISOString();
+        const run = {
+            runId: input.runId ?? randomUUID(), kind: input.kind, status: "running", checkpoint: input.checkpoint ?? "created",
+            originalWork: input.originalWork ?? {}, remainingWork: input.remainingWork ?? input.originalWork ?? {}, state: input.state ?? {},
+            legacy: Boolean(input.legacy), createdAt: at, updatedAt: at,
+        };
+        this.db.transaction(() => {
+            this.db.prepare(`INSERT INTO workflow_runs(run_id,kind,status,checkpoint,original_work_json,remaining_work_json,state_json,legacy,created_at,updated_at)
+        VALUES(?,?,?,?,?,?,?,?,?,?)`).run(run.runId, run.kind, run.status, run.checkpoint, json(run.originalWork), json(run.remainingWork), json(run.state), run.legacy ? 1 : 0, at, at);
+            this.insertEvent(run.runId, "run_created", run.checkpoint, { kind: run.kind }, at);
+        })();
+        return run;
+    }
+    getRun(runId) {
+        const row = this.db.prepare("SELECT * FROM workflow_runs WHERE run_id=?").get(runId);
+        return row ? rowToRun(row) : undefined;
+    }
+    activeRuns() {
+        return this.db.prepare("SELECT * FROM workflow_runs WHERE status IN ('running','paused','blocked') ORDER BY created_at").all().map(rowToRun);
+    }
+    transition(runId, update, now = new Date()) {
+        const at = now.toISOString();
+        return this.db.transaction(() => {
+            const current = this.getRun(runId);
+            if (!current)
+                throw new Error(`workflow run not found: ${runId}`);
+            const next = { ...current, status: update.status ?? current.status, checkpoint: update.checkpoint, remainingWork: update.remainingWork ?? current.remainingWork, state: update.state ?? current.state, updatedAt: at };
+            this.db.prepare("UPDATE workflow_runs SET status=?,checkpoint=?,remaining_work_json=?,state_json=?,updated_at=? WHERE run_id=?")
+                .run(next.status, next.checkpoint, json(next.remainingWork), json(next.state), at, runId);
+            this.insertEvent(runId, update.event ?? "checkpoint", update.checkpoint, update.payload ?? {}, at);
+            return next;
+        })();
+    }
+    events(runId) {
+        const rows = this.db.prepare("SELECT sequence,event_type,checkpoint,payload_json,created_at FROM workflow_events WHERE run_id=? ORDER BY sequence").all(runId);
+        return rows.map((row) => ({ sequence: row.sequence, type: row.event_type, checkpoint: row.checkpoint, payload: parseJson(row.payload_json), at: row.created_at }));
+    }
+    recordSettings(runId, role, boundary, settings, now = new Date()) {
+        this.db.transaction(() => {
+            this.db.prepare("INSERT OR REPLACE INTO role_settings(run_id,role,boundary,revision,settings_json,created_at) VALUES(?,?,?,?,?,?)")
+                .run(runId, role, boundary, settings.settings_revision, json(settings), now.toISOString());
+            this.insertEvent(runId, "settings_boundary", `role:${role}:${boundary}`, { revision: settings.settings_revision }, now.toISOString());
+        })();
+    }
+    recordProjectSettingsRevision(revision, defaults, now = new Date()) {
+        this.db.prepare("INSERT OR REPLACE INTO project_settings_revisions(revision,defaults_json,created_at) VALUES(?,?,?)").run(revision, json(defaults), now.toISOString());
+    }
+    recordTelemetry(runId, snapshot, now = new Date()) {
+        this.db.prepare("INSERT INTO workflow_telemetry(run_id,snapshot_json,created_at) VALUES(?,?,?)").run(runId, json(snapshot), now.toISOString());
+    }
+    recordSession(runId, role, stream, sessionId, transition, settings, now = new Date()) {
+        this.db.prepare(`INSERT INTO provider_sessions(run_id,role,stream,provider,model,session_id,transition,settings_revision,created_at)
+      VALUES(?,?,?,?,?,?,?,?,?)`).run(runId, role, stream, settings.make, settings.model, sessionId ?? null, transition, settings.settings_revision, now.toISOString());
+    }
+    recordIssue(runId, issue) {
+        const result = this.db.prepare("INSERT INTO workflow_issues(run_id,code,issue_json,created_at) VALUES(?,?,?,?)").run(runId, issue.code, json(issue), issue.occurred_at);
+        this.insertEvent(runId, "issue", issue.phase, { issueId: Number(result.lastInsertRowid), code: issue.code }, issue.occurred_at);
+        return Number(result.lastInsertRowid);
+    }
+    issues(runId) {
+        return this.db.prepare("SELECT issue_json FROM workflow_issues WHERE run_id=? ORDER BY issue_id").all(runId).map((row) => parseJson(row.issue_json));
+    }
+    planOperation(input, now = new Date()) {
+        const at = now.toISOString();
+        this.db.prepare(`INSERT INTO operation_journal(idempotency_key,run_id,kind,status,intent_json,created_at,updated_at)
+      VALUES(?,?,?,'planned',?,?,?) ON CONFLICT(idempotency_key) DO NOTHING`).run(input.idempotencyKey, input.runId, input.kind, json(input.intent), at, at);
+        return this.operation(input.idempotencyKey);
+    }
+    updateOperation(idempotencyKey, status, details = {}, now = new Date()) {
+        if (!this.operation(idempotencyKey))
+            throw new Error(`operation not found: ${idempotencyKey}`);
+        this.db.prepare("UPDATE operation_journal SET status=?,result_json=?,external_id=?,error=?,updated_at=? WHERE idempotency_key=?")
+            .run(status, details.result === undefined ? null : json(details.result), details.externalId ?? null, details.error ?? null, now.toISOString(), idempotencyKey);
+        return this.operation(idempotencyKey);
+    }
+    operation(idempotencyKey) {
+        const row = this.db.prepare("SELECT * FROM operation_journal WHERE idempotency_key=?").get(idempotencyKey);
+        return row ? operationFromRow(row) : undefined;
+    }
+    operations(runId) {
+        return this.db.prepare("SELECT * FROM operation_journal WHERE run_id=? ORDER BY created_at,idempotency_key").all(runId).map(operationFromRow);
+    }
+    putEvidence(kind, value, now = new Date()) {
+        const bytes = Buffer.isBuffer(value) ? value : Buffer.from(sanitizeText(value));
+        const digest = createHash("sha256").update(bytes).digest("hex");
+        this.db.prepare("INSERT OR IGNORE INTO content_refs(digest,kind,content,created_at) VALUES(?,?,?,?)").run(digest, kind, bytes, now.toISOString());
+        return digest;
+    }
+    getEvidence(digest) {
+        const row = this.db.prepare("SELECT content FROM content_refs WHERE digest=?").get(digest);
+        return row?.content;
+    }
+    beginPublication(runId, intent, previousDigests, now = new Date()) {
+        const transactionId = randomUUID();
+        const at = now.toISOString();
+        this.db.prepare("INSERT INTO publication_transactions(transaction_id,run_id,status,intent_json,previous_digests_json,created_at,updated_at) VALUES(?,?,'prepared',?,?,?,?)")
+            .run(transactionId, runId, json(intent), json(previousDigests), at, at);
+        this.insertEvent(runId, "publication_prepared", "publication", { transactionId }, at);
+        return { transactionId, runId, status: "prepared", intent, previousDigests, createdAt: at, updatedAt: at };
+    }
+    updatePublication(transactionId, status, now = new Date()) {
+        const current = this.publication(transactionId);
+        if (!current)
+            throw new Error(`publication transaction not found: ${transactionId}`);
+        this.db.prepare("UPDATE publication_transactions SET status=?,updated_at=? WHERE transaction_id=?").run(status, now.toISOString(), transactionId);
+        this.insertEvent(current.runId, `publication_${status}`, "publication", { transactionId }, now.toISOString());
+        return { ...current, status, updatedAt: now.toISOString() };
+    }
+    publication(transactionId) {
+        const row = this.db.prepare("SELECT * FROM publication_transactions WHERE transaction_id=?").get(transactionId);
+        return row ? { transactionId: row.transaction_id, runId: row.run_id, status: row.status, intent: parseJson(row.intent_json), previousDigests: parseJson(row.previous_digests_json), createdAt: row.created_at, updatedAt: row.updated_at } : undefined;
+    }
+    incompletePublications() {
+        const rows = this.db.prepare("SELECT transaction_id FROM publication_transactions WHERE status NOT IN ('committed','rolled_back') ORDER BY created_at").all();
+        return rows.map((row) => this.publication(row.transaction_id));
+    }
+    acquireLease(runId, owner = `${hostname()}:${process.pid}:${randomUUID()}`, now = new Date(), staleMs = 45_000) {
+        const at = now.toISOString();
+        const host = hostname();
+        const pid = process.pid;
+        const processStart = processStartIdentity();
+        return this.db.transaction(() => {
+            const current = this.currentLease();
+            if (current && leaseVerifiedLive(current, now, staleMs))
+                throw new Error(`project workflow lease is held by ${current.owner} for run ${current.runId}`);
+            const generation = (current?.generation ?? 0) + 1;
+            this.db.prepare(`INSERT INTO project_lease(singleton,owner,generation,pid,host,process_start,heartbeat_at,run_id)
+        VALUES(1,?,?,?,?,?,?,?) ON CONFLICT(singleton) DO UPDATE SET owner=excluded.owner,generation=excluded.generation,pid=excluded.pid,host=excluded.host,process_start=excluded.process_start,heartbeat_at=excluded.heartbeat_at,run_id=excluded.run_id`)
+                .run(owner, generation, pid, host, processStart, at, runId);
+            this.db.prepare("UPDATE workflow_runs SET lease_generation=? WHERE run_id=?").run(generation, runId);
+            this.insertEvent(runId, current ? "lease_takeover" : "lease_acquired", "lease", { owner, generation, previous: current?.owner }, at);
+            return { owner, generation, pid, host, processStart, heartbeatAt: at, runId };
+        })();
+    }
+    heartbeatLease(lease, now = new Date()) {
+        const at = now.toISOString();
+        const result = this.db.prepare("UPDATE project_lease SET heartbeat_at=? WHERE singleton=1 AND owner=? AND generation=?").run(at, lease.owner, lease.generation);
+        if (result.changes !== 1)
+            throw new Error("workflow lease ownership changed");
+        return { ...lease, heartbeatAt: at };
+    }
+    releaseLease(lease, now = new Date()) {
+        this.db.transaction(() => {
+            const result = this.db.prepare("DELETE FROM project_lease WHERE singleton=1 AND owner=? AND generation=?").run(lease.owner, lease.generation);
+            if (result.changes === 1)
+                this.insertEvent(lease.runId, "lease_released", "lease", { generation: lease.generation }, now.toISOString());
+        })();
+    }
+    currentLease() {
+        const row = this.db.prepare("SELECT * FROM project_lease WHERE singleton=1").get();
+        return row ? { owner: row.owner, generation: row.generation, pid: row.pid, host: row.host, processStart: row.process_start, heartbeatAt: row.heartbeat_at, runId: row.run_id } : undefined;
+    }
+    importLegacyOnce(now = new Date()) {
+        const sources = [join(this.projectDir, ".foreman", "runs"), join(this.projectDir, ".rafi", "interviews"), join(this.projectDir, ".tickets", "delivery-sessions")];
+        let count = 0;
+        for (const directory of sources) {
+            if (!existsSync(directory) || !statSync(directory).isDirectory())
+                continue;
+            for (const name of readdirSync(directory).filter((entry) => entry.endsWith(".json"))) {
+                const path = join(directory, name);
+                const digest = createHash("sha256").update(readFileSync(path)).digest("hex");
+                if (this.db.prepare("SELECT 1 FROM legacy_imports WHERE source_path=? AND digest=?").get(path, digest))
+                    continue;
+                let parsed;
+                try {
+                    parsed = JSON.parse(readFileSync(path, "utf8"));
+                }
+                catch {
+                    parsed = { unreadable: true };
+                }
+                const runId = `legacy_${digest.slice(0, 24)}`;
+                if (!this.getRun(runId)) {
+                    this.createRun({ runId, kind: "legacy", checkpoint: "legacy-imported", originalWork: { source: path }, remainingWork: {}, state: { source: path, record: parsed }, legacy: true }, now);
+                    this.transition(runId, { status: "superseded", checkpoint: "legacy-imported", remainingWork: {}, event: "legacy_record_preserved" }, now);
+                }
+                this.db.prepare("INSERT INTO legacy_imports(source_path,digest,run_id,imported_at) VALUES(?,?,?,?)").run(path, digest, runId, now.toISOString());
+                count += 1;
+            }
+        }
+        return count;
+    }
+    insertEvent(runId, type, checkpoint, payload, at) {
+        this.db.prepare("INSERT INTO workflow_events(run_id,event_type,checkpoint,payload_json,created_at) VALUES(?,?,?,?,?)").run(runId, type, checkpoint, json(payload), at);
+    }
+    migrate() {
+        this.db.exec(`
+      CREATE TABLE IF NOT EXISTS workflow_runs(run_id TEXT PRIMARY KEY,kind TEXT NOT NULL,status TEXT NOT NULL,checkpoint TEXT NOT NULL,original_work_json TEXT NOT NULL,remaining_work_json TEXT NOT NULL,state_json TEXT NOT NULL,lease_generation INTEGER,legacy INTEGER NOT NULL DEFAULT 0,created_at TEXT NOT NULL,updated_at TEXT NOT NULL);
+      CREATE TABLE IF NOT EXISTS workflow_events(sequence INTEGER PRIMARY KEY AUTOINCREMENT,run_id TEXT NOT NULL REFERENCES workflow_runs(run_id),event_type TEXT NOT NULL,checkpoint TEXT NOT NULL,payload_json TEXT NOT NULL,created_at TEXT NOT NULL);
+      CREATE TABLE IF NOT EXISTS role_settings(run_id TEXT NOT NULL REFERENCES workflow_runs(run_id),role TEXT NOT NULL,boundary INTEGER NOT NULL,revision INTEGER NOT NULL,settings_json TEXT NOT NULL,created_at TEXT NOT NULL,PRIMARY KEY(run_id,role,boundary));
+      CREATE TABLE IF NOT EXISTS project_settings_revisions(revision INTEGER PRIMARY KEY,defaults_json TEXT NOT NULL,created_at TEXT NOT NULL);
+      CREATE TABLE IF NOT EXISTS workflow_telemetry(id INTEGER PRIMARY KEY AUTOINCREMENT,run_id TEXT NOT NULL REFERENCES workflow_runs(run_id),snapshot_json TEXT NOT NULL,created_at TEXT NOT NULL);
+      CREATE TABLE IF NOT EXISTS provider_sessions(id INTEGER PRIMARY KEY AUTOINCREMENT,run_id TEXT NOT NULL REFERENCES workflow_runs(run_id),role TEXT NOT NULL,stream TEXT NOT NULL,provider TEXT NOT NULL,model TEXT NOT NULL,session_id TEXT,transition TEXT NOT NULL,settings_revision INTEGER NOT NULL,created_at TEXT NOT NULL);
+      CREATE TABLE IF NOT EXISTS workflow_issues(issue_id INTEGER PRIMARY KEY AUTOINCREMENT,run_id TEXT NOT NULL REFERENCES workflow_runs(run_id),code TEXT NOT NULL,issue_json TEXT NOT NULL,created_at TEXT NOT NULL);
+      CREATE TABLE IF NOT EXISTS operation_journal(idempotency_key TEXT PRIMARY KEY,run_id TEXT NOT NULL REFERENCES workflow_runs(run_id),kind TEXT NOT NULL,status TEXT NOT NULL,intent_json TEXT NOT NULL,result_json TEXT,external_id TEXT,error TEXT,created_at TEXT NOT NULL,updated_at TEXT NOT NULL);
+      CREATE TABLE IF NOT EXISTS content_refs(digest TEXT PRIMARY KEY,kind TEXT NOT NULL,content BLOB NOT NULL,created_at TEXT NOT NULL);
+      CREATE TABLE IF NOT EXISTS project_lease(singleton INTEGER PRIMARY KEY CHECK(singleton=1),owner TEXT NOT NULL,generation INTEGER NOT NULL,pid INTEGER NOT NULL,host TEXT NOT NULL,process_start TEXT NOT NULL,heartbeat_at TEXT NOT NULL,run_id TEXT NOT NULL);
+      CREATE TABLE IF NOT EXISTS legacy_imports(source_path TEXT NOT NULL,digest TEXT NOT NULL,run_id TEXT NOT NULL,imported_at TEXT NOT NULL,PRIMARY KEY(source_path,digest));
+      CREATE TABLE IF NOT EXISTS publication_transactions(transaction_id TEXT PRIMARY KEY,run_id TEXT NOT NULL,status TEXT NOT NULL,intent_json TEXT NOT NULL,previous_digests_json TEXT NOT NULL,created_at TEXT NOT NULL,updated_at TEXT NOT NULL);
+      CREATE INDEX IF NOT EXISTS workflow_events_run ON workflow_events(run_id,sequence);
+      CREATE INDEX IF NOT EXISTS operations_run ON operation_journal(run_id,status);
+    `);
+    }
+}
+function rowToRun(row) { return { runId: row.run_id, kind: row.kind, status: row.status, checkpoint: row.checkpoint, originalWork: parseJson(row.original_work_json), remainingWork: parseJson(row.remaining_work_json), state: parseJson(row.state_json), ...(row.lease_generation === null ? {} : { leaseGeneration: row.lease_generation }), legacy: Boolean(row.legacy), createdAt: row.created_at, updatedAt: row.updated_at }; }
+function operationFromRow(row) { return { idempotencyKey: row.idempotency_key, runId: row.run_id, kind: row.kind, status: row.status, intent: parseJson(row.intent_json), ...(row.result_json ? { result: parseJson(row.result_json) } : {}), ...(row.external_id ? { externalId: row.external_id } : {}), ...(row.error ? { error: row.error } : {}), createdAt: row.created_at, updatedAt: row.updated_at }; }
+function json(value) { return JSON.stringify(value ?? null); }
+function parseJson(value) { return JSON.parse(value); }
+function sanitizeText(value) { return value.replace(/\b(sk-[A-Za-z0-9_-]{12,}|(?:api[_-]?key|token|password)\s*[:=]\s*\S+)/gi, "[REDACTED]"); }
+function processStartIdentity(pid = process.pid) { try {
+    return readFileSync(`/proc/${pid}/stat`, "utf8").split(" ")[21] ?? "unavailable";
+}
+catch {
+    return "unavailable";
+} }
+function leaseVerifiedLive(lease, now, staleMs) {
+    if (now.getTime() - new Date(lease.heartbeatAt).getTime() > staleMs)
+        return false;
+    if (lease.host !== hostname())
+        return true;
+    try {
+        process.kill(lease.pid, 0);
+        return processStartIdentity(lease.pid) === lease.processStart;
+    }
+    catch {
+        return false;
+    }
+}
+function ensureRecoveryGitignore(projectDir) {
+    const localExclude = join(projectDir, ".git", "info", "exclude");
+    const path = existsSync(localExclude) ? localExclude : join(projectDir, ".gitignore");
+    const entries = [WORKFLOW_DB_FILE, `${WORKFLOW_DB_FILE}-wal`, `${WORKFLOW_DB_FILE}-shm`];
+    const existing = existsSync(path) ? readFileSync(path, "utf8") : "";
+    const missing = entries.filter((entry) => !existing.split(/\r?\n/).includes(entry));
+    if (missing.length)
+        appendFileSync(path, `${existing && !existing.endsWith("\n") ? "\n" : ""}${missing.join("\n")}\n`, "utf8");
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ai-foreman",
-  "version": "1.6.2",
+  "version": "1.7.0",
   "description": "An orchestrator that keeps Codex CLI / Claude Code builders moving through their step list unattended. Part of Rafi.",
   "license": "Apache-2.0",
   "type": "module",
@@ -41,6 +41,18 @@
       "types": "./dist/buildRuns.d.ts",
       "default": "./dist/buildRuns.js"
     },
+    "./workflow-db.js": {
+      "types": "./dist/workflowDb.d.ts",
+      "default": "./dist/workflowDb.js"
+    },
+    "./session-lifecycle.js": {
+      "types": "./dist/sessionLifecycle.d.ts",
+      "default": "./dist/sessionLifecycle.js"
+    },
+    "./operation-recovery.js": {
+      "types": "./dist/operationRecovery.d.ts",
+      "default": "./dist/operationRecovery.js"
+    },
     "./ticket-planning.js": {
       "types": "./dist/ticketPlanning.d.ts",
       "default": "./dist/ticketPlanning.js"
@@ -81,6 +93,7 @@
     "dev": "tsx src/index.ts",
     "test": "tsx --test test/*.test.ts",
     "typecheck": "tsc --noEmit",
+    "test:live-providers": "RAFI_LIVE_PROVIDER_SESSIONS=1 tsx --test test/providerSmoke.test.ts",
     "prepublishOnly": "pnpm build && pnpm test && pnpm typecheck"
   },
   "keywords": [
@@ -101,8 +114,8 @@
     "@anthropic-ai/claude-agent-sdk": "^0.3.148"
   },
   "dependencies": {
-    "special-agents": "0.7.0",
-    "rafi-spec": "0.7.0",
+    "special-agents": "0.8.0",
+    "rafi-spec": "0.8.0",
     "@clack/prompts": "^1.4.0",
     "ajv": "^8.20.0",
     "ajv-formats": "^3.0.1",