ai-foreman 1.7.11 → 1.7.13

package/dist/recoveryPolicy.js

@@ -0,0 +1,251 @@
+import { createHash, randomUUID } from "node:crypto";
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { parse as parseYaml } from "yaml";
+const RULES = ["qa.nonconvergence", "runtime.transient", "plan.material_change"];
+const PROFILE_LIMITS = {
+    supervised: {
+        limits: { builderQaFixesPerTicket: 2, transientPreDispatchRetries: 0, protocolCorrections: 1, reconciledOperationRetries: 0, workerRestartsPerCheckpoint: 0, workerRestartsPerRun: 0 },
+        providerFallback: "never", planChanges: "review-all",
+    },
+    balanced: {
+        limits: { builderQaFixesPerTicket: 3, transientPreDispatchRetries: 3, protocolCorrections: 2, reconciledOperationRetries: 2, workerRestartsPerCheckpoint: 3, workerRestartsPerRun: 10 },
+        providerFallback: "safe-boundaries", planChanges: "review-material",
+    },
+    unattended: {
+        limits: { builderQaFixesPerTicket: 5, transientPreDispatchRetries: 5, protocolCorrections: 3, reconciledOperationRetries: 4, workerRestartsPerCheckpoint: 5, workerRestartsPerRun: 10 },
+        providerFallback: "safe-boundaries", planChanges: "auto-bounded",
+    },
+};
+export const DEFAULT_AUTONOMY_CONFIG = {
+    profile: "balanced",
+    continue_independent_tickets: true,
+    rules: {
+        "qa.nonconvergence": { action: "retry_builder", max_attempts: 3 },
+        "runtime.transient": { action: "retry", max_attempts: 3 },
+        "plan.material_change": { action: "human_required" },
+    },
+    supervisor: { enabled: true, max_worker_restarts_per_checkpoint: 3, max_worker_restarts_per_run: 10 },
+};
+export function loadProjectAutonomyConfig(projectDir) {
+    const path = join(projectDir, "rafi-config.yaml");
+    if (!existsSync(path))
+        return undefined;
+    const raw = parseYaml(readFileSync(path, "utf8"));
+    return raw?.autonomy === undefined ? undefined : validateAutonomyConfig(raw.autonomy);
+}
+/** QA precedence: CLI -> frozen run -> canonical project config -> legacy foreman.yaml. */
+export function resolveQaEnablement(input) {
+    if (input.cli !== undefined)
+        return { enabled: input.cli, source: "cli" };
+    if (input.frozen !== undefined)
+        return { enabled: input.frozen, source: "frozen" };
+    const path = join(input.projectDir, "rafi-config.yaml");
+    if (existsSync(path)) {
+        const raw = parseYaml(readFileSync(path, "utf8"));
+        if (raw?.autonomy !== undefined)
+            return { enabled: raw.harness?.qa !== false, source: "project" };
+    }
+    if (input.legacyForeman !== undefined)
+        return { enabled: input.legacyForeman, source: "legacy-foreman", deprecationWarning: "foreman.yaml qa.enabled is deprecated; set harness.qa and autonomy in rafi-config.yaml" };
+    return { enabled: true, source: "default" };
+}
+export function validateAutonomyConfig(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        throw new Error("autonomy must be an object");
+    const input = value;
+    rejectUnknown(input, ["profile", "continue_independent_tickets", "rules", "supervisor"], "autonomy");
+    if (!["supervised", "balanced", "unattended"].includes(input.profile))
+        throw new Error("autonomy.profile must be supervised, balanced, or unattended");
+    if (typeof input.continue_independent_tickets !== "boolean")
+        throw new Error("autonomy.continue_independent_tickets must be a boolean");
+    if (!input.supervisor || typeof input.supervisor !== "object" || Array.isArray(input.supervisor))
+        throw new Error("autonomy.supervisor must be an object");
+    const supervisor = input.supervisor;
+    rejectUnknown(supervisor, ["enabled", "max_worker_restarts_per_checkpoint", "max_worker_restarts_per_run"], "autonomy.supervisor");
+    if (typeof supervisor.enabled !== "boolean")
+        throw new Error("autonomy.supervisor.enabled must be a boolean");
+    positiveInteger(supervisor.max_worker_restarts_per_checkpoint, "autonomy.supervisor.max_worker_restarts_per_checkpoint", true);
+    positiveInteger(supervisor.max_worker_restarts_per_run, "autonomy.supervisor.max_worker_restarts_per_run", true);
+    const overrides = {};
+    if (input.rules !== undefined) {
+        if (!input.rules || typeof input.rules !== "object" || Array.isArray(input.rules))
+            throw new Error("autonomy.rules must be an object");
+        const rawRules = input.rules;
+        rejectUnknown(rawRules, [...RULES], "autonomy.rules");
+        for (const [id, raw] of Object.entries(rawRules)) {
+            if (!raw || typeof raw !== "object" || Array.isArray(raw))
+                throw new Error(`autonomy.rules.${id} must be an object`);
+            const rule = raw;
+            rejectUnknown(rule, ["action", "max_attempts"], `autonomy.rules.${id}`);
+            const allowed = id === "qa.nonconvergence" ? ["retry_builder", "human_required"] : id === "runtime.transient" ? ["retry", "human_required"] : ["human_required"];
+            if (!allowed.includes(String(rule.action)))
+                throw new Error(`autonomy.rules.${id}.action is unsafe or unsupported`);
+            if (rule.max_attempts !== undefined)
+                positiveInteger(rule.max_attempts, `autonomy.rules.${id}.max_attempts`, true);
+            overrides[id] = { action: rule.action, ...(rule.max_attempts === undefined ? {} : { max_attempts: Number(rule.max_attempts) }) };
+        }
+    }
+    return {
+        profile: input.profile,
+        continue_independent_tickets: input.continue_independent_tickets,
+        rules: overrides,
+        supervisor: { enabled: supervisor.enabled, max_worker_restarts_per_checkpoint: Number(supervisor.max_worker_restarts_per_checkpoint), max_worker_restarts_per_run: Number(supervisor.max_worker_restarts_per_run) },
+    };
+}
+export function resolveAutonomyPolicy(config, profileOverride, now = new Date()) {
+    const profile = profileOverride ?? config?.profile ?? "balanced";
+    const defaults = PROFILE_LIMITS[profile];
+    const supervisor = config?.supervisor ?? DEFAULT_AUTONOMY_CONFIG.supervisor;
+    const defaultRules = {
+        "qa.nonconvergence": { action: profile === "supervised" ? "human_required" : "retry_builder", max_attempts: defaults.limits.builderQaFixesPerTicket },
+        "runtime.transient": { action: defaults.limits.transientPreDispatchRetries ? "retry" : "human_required", max_attempts: defaults.limits.transientPreDispatchRetries },
+        "plan.material_change": { action: profile === "unattended" ? "retry" : "human_required", max_attempts: profile === "unattended" ? 1 : 0 },
+    };
+    const policyWithoutDigest = {
+        version: 1, profile,
+        continueIndependentTickets: config?.continue_independent_tickets ?? profile !== "supervised",
+        limits: {
+            ...defaults.limits,
+            workerRestartsPerCheckpoint: supervisor.max_worker_restarts_per_checkpoint,
+            workerRestartsPerRun: supervisor.max_worker_restarts_per_run,
+        },
+        providerFallback: defaults.providerFallback,
+        planChanges: defaults.planChanges,
+        rules: Object.fromEntries(RULES.map((id) => [id, { ...defaultRules[id], ...(config?.rules?.[id] ?? {}) }])),
+        supervisorEnabled: supervisor.enabled,
+        resolvedAt: now.toISOString(),
+    };
+    return { ...policyWithoutDigest, digest: digestPolicy(policyWithoutDigest) };
+}
+export function mapWorkflowIssueDomain(code) {
+    if (code.startsWith("qa_"))
+        return "qa";
+    if (code.startsWith("role_") || code === "unstructured_agent_question")
+        return "agent-protocol";
+    if (code.includes("runtime") || code === "session_unavailable")
+        return "runtime";
+    if (code.startsWith("session_") || code === "recovery_failure")
+        return "continuity";
+    if (code.startsWith("ticket_") || code === "tracker_update_failure")
+        return "tracker/dependency";
+    if (code.startsWith("plan_") || code === "slice_mapping_failure" || code === "retirement_authorization_failure")
+        return "gate/plan";
+    if (code.startsWith("delivery_") || code.startsWith("remote_action_"))
+        return "delivery";
+    if (code === "builder_tool_policy_failure")
+        return "permissions";
+    if (code === "terminal_incompatibility" || code === "depth_exceeded")
+        return "process";
+    return "unknown";
+}
+const HARD_BOUNDARY_CODES = new Set([
+    "qa_waiver", "builder_tool_policy_failure", "remote_action_denied", "remote_action_uncertain",
+    "ticket_corruption", "ticket_validation_failure", "plan_pair_mismatch", "slice_mapping_failure",
+    "retirement_authorization_failure", "workspace_integrity_drift", "semantic_scope_ambiguity",
+    "invalid_dependency_semantics", "unknown",
+]);
+export function evaluateRecovery(policy, interruption, attemptsUsed) {
+    if (interruption.domain === "unknown" || HARD_BOUNDARY_CODES.has(interruption.code))
+        return disposition("human_required", "pause", "hard safety boundary requires human review", 0, attemptsUsed);
+    if (interruption.code === "user_cancelled")
+        return disposition("terminal", "stop", "the user cancelled the run", 0, attemptsUsed);
+    if (interruption.dispatchState === "unknown")
+        return disposition("human_required", "pause", "dispatch could not be reconciled; replay may duplicate a mutation", 0, attemptsUsed);
+    if (interruption.domain === "qa" && interruption.code === "qa_nonconvergence") {
+        const rule = policy.rules["qa.nonconvergence"];
+        const max = rule.max_attempts ?? policy.limits.builderQaFixesPerTicket;
+        if (rule.action === "retry_builder" && attemptsUsed < max)
+            return { ...disposition("configured_decision", "retry_builder", "frozen qa.nonconvergence rule permits another Builder fix", max, attemptsUsed), rule: "qa.nonconvergence" };
+        return { ...disposition("human_required", "pause", "Builder QA fix budget exhausted", max, attemptsUsed), rule: "qa.nonconvergence" };
+    }
+    if (interruption.domain === "runtime" && ["network", "timeout", "rate-limit", "readiness", "builder_runtime_failure", "qa_runtime_failure"].includes(interruption.code)) {
+        const rule = policy.rules["runtime.transient"];
+        const max = rule.max_attempts ?? policy.limits.transientPreDispatchRetries;
+        if (rule.action === "retry" && attemptsUsed < max && (interruption.dispatchState === "not_dispatched" || interruption.dispatchState === "idempotent"))
+            return { ...disposition("auto_retry", "retry", "transient operation is safe to replay", max, attemptsUsed), rule: "runtime.transient" };
+        return { ...disposition("human_required", "pause", "transient retry is unsafe or exhausted", max, attemptsUsed), rule: "runtime.transient" };
+    }
+    if (interruption.domain === "agent-protocol" || interruption.domain === "continuity") {
+        const max = policy.limits.protocolCorrections;
+        return attemptsUsed < max ? disposition("auto_retry", "correct_protocol", "bounded protocol/continuity correction", max, attemptsUsed) : disposition("human_required", "pause", "protocol correction budget exhausted", max, attemptsUsed);
+    }
+    if (interruption.operation && interruption.dispatchState === "dispatched") {
+        const max = policy.limits.reconciledOperationRetries;
+        return attemptsUsed < max ? disposition("reconcile_then_retry", "reconcile", "external mutation must be reconciled before replay", max, attemptsUsed) : disposition("human_required", "pause", "reconciled operation retry budget exhausted", max, attemptsUsed);
+    }
+    return disposition("human_required", "pause", "no safe automatic disposition is registered", 0, attemptsUsed);
+}
+export function qaDecisionChoices() {
+    return [
+        { id: "retry_builder_once", label: "Retry Builder once" },
+        { id: "planner_remediation", label: "Ask Planner for read-only remediation" },
+        { id: "waive_qa", label: "Waive QA", requiresConfirmation: true },
+        { id: "pause", label: "Pause" },
+    ];
+}
+export class RecoveryDispatcher {
+    db;
+    policy;
+    constructor(db, policy) {
+        this.db = db;
+        this.policy = policy;
+    }
+    async dispatch(input) {
+        const interruption = this.db.recordInterruption(input.interruption);
+        let effective = interruption;
+        if (effective.dispatchState === "unknown" && input.reconcile) {
+            const result = await input.reconcile();
+            effective = { ...effective, dispatchState: result === "absent" ? "not_dispatched" : result === "confirmed" ? "dispatched" : "unknown" };
+        }
+        const operationKey = effective.operation?.idempotencyKey ?? `${effective.domain}:${effective.code}`;
+        const attempts = this.db.recoveryAttemptCount(effective.runId, effective.ticket, effective.phase, effective.cause, operationKey);
+        const disposition = evaluateRecovery(this.policy, effective, attempts);
+        if (disposition.kind === "human_required") {
+            const decision = this.db.ensureHumanDecision({
+                decisionKey: `${effective.id}:${operationKey}`, runId: effective.runId, interruptionId: effective.id,
+                prompt: effective.domain === "qa" ? "QA recovery needs a decision" : disposition.reason,
+                choices: effective.domain === "qa" ? qaDecisionChoices() : [{ id: "retry_once", label: "Retry once" }, { id: "pause", label: "Pause" }], evidence: effective.evidence,
+            });
+            return { disposition, decision };
+        }
+        if (disposition.kind === "terminal")
+            return { disposition };
+        const runId = effective.runId;
+        const receipt = this.db.recordRecoveryAttempt({
+            attemptId: randomUUID(), runId, ticket: effective.ticket, phase: effective.phase, cause: effective.cause,
+            operationKey, attempt: attempts + 1, disposition: disposition.kind, action: disposition.action,
+            outcome: "intended", intendedAt: new Date().toISOString(),
+        });
+        this.db.updateRecoveryAttempt(receipt.attemptId, "started");
+        try {
+            const result = await input.execute(disposition);
+            this.db.updateRecoveryAttempt(receipt.attemptId, result.ok ? "succeeded" : "failed", result.detail);
+        }
+        catch (error) {
+            this.db.updateRecoveryAttempt(receipt.attemptId, "failed", error instanceof Error ? error.message : String(error));
+            throw error;
+        }
+        return { disposition, attemptId: receipt.attemptId };
+    }
+}
+function disposition(kind, action, reason, maxAttempts, attemptsUsed) {
+    return { kind, action, reason, maxAttempts, attemptsUsed };
+}
+function positiveInteger(value, path, allowZero = false) {
+    if (!Number.isInteger(value) || Number(value) < (allowZero ? 0 : 1))
+        throw new Error(`${path} must be ${allowZero ? "a non-negative" : "a positive"} integer`);
+}
+function rejectUnknown(value, allowed, path) {
+    for (const key of Object.keys(value))
+        if (!allowed.includes(key))
+            throw new Error(`${path}: unknown setting ${key}`);
+}
+function stable(value) {
+    if (Array.isArray(value))
+        return `[${value.map(stable).join(",")}]`;
+    if (value && typeof value === "object")
+        return `{${Object.entries(value).sort(([a], [b]) => a.localeCompare(b)).map(([key, entry]) => `${JSON.stringify(key)}:${stable(entry)}`).join(",")}}`;
+    return JSON.stringify(value ?? null);
+}
+function digestPolicy(value) { return createHash("sha256").update(stable(value)).digest("hex"); }

package/dist/roles.js

@@ -18,6 +18,7 @@ export const AGENT_ROLE_REGISTRY = [
     { id: "qa", label: "QA (separate review session)", consumers: ["run-wide independent review"], configurable: true, manifest: "qa", commands: ["rafi start", "rafi build:resume"] },
     { id: "ticket-maker", label: "Ticket maker", consumers: ["ticket population"], configurable: true, manifest: "ticket-maker", commands: ["rafi tickets populate"] },
     { id: "uninstaller", label: "Uninstaller", consumers: ["non-empty uninstall instructions only"], configurable: true, manifest: "uninstaller", commands: ["rafi uninstall"] },
+    { id: "manager", label: "Manager (read-only diagnostics)", consumers: ["build diagnostics"], configurable: true, manifest: "manager", commands: ["rafi manager", "ai-foreman manager"] },
 ];
 function libraryGetter(role) {
     const a = getAgent(role);

package/dist/supervisor.d.ts

@@ -0,0 +1,40 @@
+import type { ResolvedAutonomyPolicy, SupervisorState } from "rafi-spec";
+export type WorkerOutcome = {
+    kind: "completed";
+} | {
+    kind: "waiting_for_human";
+} | {
+    kind: "stopped";
+} | {
+    kind: "failed";
+    detail: string;
+} | {
+    kind: "crashed";
+    detail: string;
+};
+export interface SupervisorWorkerHandle {
+    pid?: number;
+    result: Promise<WorkerOutcome>;
+    stop: () => Promise<void> | void;
+}
+export interface DurableSupervisorOptions {
+    projectDir: string;
+    runId: string;
+    policy: ResolvedAutonomyPolicy;
+    spawnWorker: (generation: number) => Promise<SupervisorWorkerHandle> | SupervisorWorkerHandle;
+    checkpoint: () => string;
+    sleep?: (milliseconds: number) => Promise<void>;
+    now?: () => Date;
+}
+/** Durable worker restart loop. The supervisor never owns the project's mutation lease. */
+export declare class DurableSupervisor {
+    private readonly options;
+    private stopRequested;
+    private active?;
+    private readonly sleep;
+    private readonly now;
+    constructor(options: DurableSupervisorOptions);
+    requestStop(): void;
+    run(): Promise<WorkerOutcome>;
+}
+export declare function initialSupervisorState(): SupervisorState;

package/dist/supervisor.js

@@ -0,0 +1,102 @@
+import { WorkflowDb } from "./workflowDb.js";
+/** Durable worker restart loop. The supervisor never owns the project's mutation lease. */
+export class DurableSupervisor {
+    options;
+    stopRequested = false;
+    active;
+    sleep;
+    now;
+    constructor(options) {
+        this.options = options;
+        this.sleep = options.sleep ?? ((milliseconds) => new Promise((resolve) => setTimeout(resolve, milliseconds)));
+        this.now = options.now ?? (() => new Date());
+    }
+    requestStop() {
+        this.stopRequested = true;
+        void this.active?.stop();
+    }
+    async run() {
+        const db = new WorkflowDb(this.options.projectDir);
+        let state = db.supervisorState(this.options.runId) ?? initialSupervisorState();
+        if (!this.options.policy.supervisorEnabled) {
+            state = { ...state, status: "disabled" };
+            db.putSupervisorState(this.options.runId, state);
+            db.close();
+            return { kind: "stopped" };
+        }
+        if (state.status === "running" && state.pid && state.pid !== process.pid && processLooksLive(state.pid, state.heartbeatAt)) {
+            db.close();
+            throw new Error(`supervisor already active for run ${this.options.runId} (pid ${state.pid})`);
+        }
+        state = { ...state, status: "running", pid: process.pid, generation: state.generation + 1, heartbeatAt: this.now().toISOString() };
+        db.putSupervisorState(this.options.runId, state);
+        let lastCheckpoint = this.options.checkpoint();
+        const heartbeat = setInterval(() => {
+            state = { ...state, heartbeatAt: this.now().toISOString() };
+            try {
+                db.putSupervisorState(this.options.runId, state);
+            }
+            catch { /* next durable boundary reports failure */ }
+        }, 10_000);
+        heartbeat.unref();
+        try {
+            while (!this.stopRequested) {
+                const pending = db.pendingHumanDecisions(this.options.runId);
+                if (pending.length) {
+                    state = { ...state, status: "waiting_for_human", workerPid: undefined, heartbeatAt: this.now().toISOString() };
+                    db.putSupervisorState(this.options.runId, state);
+                    return { kind: "waiting_for_human" };
+                }
+                const checkpoint = this.options.checkpoint();
+                if (checkpoint !== lastCheckpoint) {
+                    lastCheckpoint = checkpoint;
+                    state = { ...state, checkpointRestarts: 0 };
+                }
+                state = { ...state, status: "running", workerGeneration: state.workerGeneration + 1, heartbeatAt: this.now().toISOString() };
+                this.active = await this.options.spawnWorker(state.workerGeneration);
+                state = { ...state, workerPid: this.active.pid };
+                db.putSupervisorState(this.options.runId, state);
+                const outcome = await this.active.result;
+                this.active = undefined;
+                state = { ...state, workerPid: undefined, heartbeatAt: this.now().toISOString() };
+                if (outcome.kind !== "crashed") {
+                    const status = outcome.kind === "completed" ? "stopped" : outcome.kind === "waiting_for_human" ? "waiting_for_human" : outcome.kind === "failed" ? "failed" : "stopped";
+                    state = { ...state, status };
+                    db.putSupervisorState(this.options.runId, state);
+                    return outcome;
+                }
+                const checkpointLimit = this.options.policy.limits.workerRestartsPerCheckpoint;
+                const runLimit = this.options.policy.limits.workerRestartsPerRun;
+                if (state.checkpointRestarts >= checkpointLimit || state.runRestarts >= runLimit) {
+                    state = { ...state, status: "failed" };
+                    db.putSupervisorState(this.options.runId, state);
+                    return { kind: "failed", detail: `worker restart budget exhausted at ${checkpoint}: ${outcome.detail}` };
+                }
+                state = { ...state, checkpointRestarts: state.checkpointRestarts + 1, runRestarts: state.runRestarts + 1 };
+                db.putSupervisorState(this.options.runId, state);
+                await this.sleep(Math.min(10_000, 250 * (2 ** Math.min(5, state.checkpointRestarts - 1))));
+            }
+            state = { ...state, status: "stopped", stopRequestedAt: this.now().toISOString(), workerPid: undefined };
+            db.putSupervisorState(this.options.runId, state);
+            return { kind: "stopped" };
+        }
+        finally {
+            clearInterval(heartbeat);
+            db.close();
+        }
+    }
+}
+export function initialSupervisorState() {
+    return { status: "starting", generation: 0, workerGeneration: 0, checkpointRestarts: 0, runRestarts: 0 };
+}
+function processLooksLive(pid, heartbeatAt) {
+    if (!heartbeatAt || Date.now() - new Date(heartbeatAt).getTime() > 45_000)
+        return false;
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}

package/dist/ticketHistoryReader.d.ts

@@ -0,0 +1,19 @@
+import type { TicketEvent, TicketState } from "./tickets/stateDb.js";
+/** Read-only ticket history access. Unlike StateDb, construction never creates or migrates a database. */
+export declare class TicketHistoryReader {
+    readonly path?: string;
+    private readonly db?;
+    constructor(projectDir: string);
+    available(): boolean;
+    close(): void;
+    states(ticketIds: readonly string[]): TicketState[];
+    events(ticketIds: readonly string[], limit?: number): TicketEvent[];
+    operationReceipts(runIds: readonly string[], limit?: number): Array<{
+        operationId: string;
+        operationType: string;
+        ticketId?: string;
+        runId: string;
+        completedAt: string;
+        payload: unknown;
+    }>;
+}

package/dist/ticketHistoryReader.js

@@ -0,0 +1,58 @@
+import { existsSync } from "node:fs";
+import { resolve } from "node:path";
+import Database from "better-sqlite3";
+import { isTicketsInitialized, loadTicketsConfig, resolveTicketPaths } from "./tickets/config.js";
+/** Read-only ticket history access. Unlike StateDb, construction never creates or migrates a database. */
+export class TicketHistoryReader {
+    path;
+    db;
+    constructor(projectDir) {
+        const root = resolve(projectDir);
+        if (!isTicketsInitialized(root))
+            return;
+        try {
+            const path = resolveTicketPaths(loadTicketsConfig(root), root).stateDb;
+            this.path = path;
+            if (!existsSync(path))
+                return;
+            this.db = new Database(path, { readonly: true, fileMustExist: true });
+            this.db.pragma("query_only = ON");
+        }
+        catch { /* unavailable or legacy ticket setup */ }
+    }
+    available() { return Boolean(this.db); }
+    close() { this.db?.close(); }
+    states(ticketIds) {
+        if (!this.db || !ticketIds.length)
+            return [];
+        try {
+            const ids = [...new Set(ticketIds)].slice(0, 500);
+            return this.db.prepare(`SELECT * FROM ticket_state WHERE ticket_id IN (${ids.map(() => "?").join(",")}) ORDER BY ticket_id`).all(...ids);
+        }
+        catch {
+            return [];
+        }
+    }
+    events(ticketIds, limit = 500) {
+        if (!this.db || !ticketIds.length)
+            return [];
+        try {
+            const ids = [...new Set(ticketIds)].slice(0, 500);
+            return this.db.prepare(`SELECT * FROM ticket_events WHERE ticket_id IN (${ids.map(() => "?").join(",")}) ORDER BY timestamp DESC,id DESC LIMIT ?`).all(...ids, Math.max(1, Math.min(2_000, limit)));
+        }
+        catch {
+            return [];
+        }
+    }
+    operationReceipts(runIds, limit = 500) {
+        if (!this.db || !runIds.length)
+            return [];
+        try {
+            const ids = [...new Set(runIds)].slice(0, 100);
+            return this.db.prepare(`SELECT * FROM operation_receipts WHERE run_id IN (${ids.map(() => "?").join(",")}) ORDER BY completed_at DESC,operation_id LIMIT ?`).all(...ids, Math.max(1, Math.min(2_000, limit))).map(row => ({ operationId: String(row.operation_id), operationType: String(row.operation_type), ...(row.ticket_id ? { ticketId: String(row.ticket_id) } : {}), runId: String(row.run_id), completedAt: String(row.completed_at), payload: JSON.parse(String(row.payload_json)) }));
+        }
+        catch {
+            return [];
+        }
+    }
+}

package/dist/tickets/details.d.ts

@@ -13,5 +13,13 @@ export interface TicketDetails {
     events: TicketEvent[];
     delivery: TicketDeliveryDetails;
 }
+export interface AllTicketDetails {
+    version: 1;
+    generated_at: string;
+    ticket_count: number;
+    tickets: TicketDetails[];
+}
 export declare function getTicketDetails(projectDir: string, ticketId: string, now?: Date): TicketDetails;
+export declare function getAllTicketDetails(projectDir: string, now?: Date): AllTicketDetails;
 export declare function formatTicketDetails(details: TicketDetails): string[];
+export declare function formatAllTicketDetails(details: AllTicketDetails): string[];

package/dist/tickets/details.js

@@ -18,22 +18,60 @@ export function getTicketDetails(projectDir, ticketId, now = new Date()) {
         const states = db.getAllStates();
         const state = states.get(ticketId) ?? pristineTicketState(ticketId, now.toISOString());
         const delivery = loadDeliveryConfig(projectDir);
-        const units = delivery?.units.filter((unit) => unit.tickets.includes(ticketId)) ?? [];
-        const unitIds = new Set(units.map((unit) => unit.id));
-        const stacks = delivery?.stacks?.filter((stack) => stack.units.some((unit) => unitIds.has(unit))) ?? [];
-        return {
-            definition,
-            state,
-            effective_blockers: resolveBlockers(definition, states),
-            validation_history: db.getValidationSnapshots(ticketId),
-            events: db.getTicketEvents(ticketId),
-            delivery: { units, stacks },
-        };
+        return assembleTicketDetails(definition, state, states, db.getValidationSnapshots(ticketId), db.getTicketEvents(ticketId), delivery);
     }
     finally {
         db.close();
     }
 }
+export function getAllTicketDetails(projectDir, now = new Date()) {
+    const config = loadTicketsConfig(projectDir);
+    const paths = resolveTicketPaths(config, projectDir);
+    if (!existsSync(paths.tickets))
+        throw new Error("ticket tracker is not initialized; run `rafi tickets init`");
+    const definitions = loadTickets(paths.tickets)
+        .sort((left, right) => left.order - right.order || left.id.localeCompare(right.id));
+    const generatedAt = now.toISOString();
+    const db = new StateDb(paths.stateDb);
+    try {
+        const states = db.getAllStates();
+        const validations = groupByTicketId(db.getValidationSnapshots(), (snapshot) => snapshot.scope);
+        const events = groupByTicketId(db.getAllTicketEvents(), (event) => event.ticket_id);
+        const delivery = loadDeliveryConfig(projectDir);
+        const tickets = definitions.map((definition) => assembleTicketDetails(definition, states.get(definition.id) ?? pristineTicketState(definition.id, generatedAt), states, validations.get(definition.id) ?? [], events.get(definition.id) ?? [], delivery));
+        return { version: 1, generated_at: generatedAt, ticket_count: tickets.length, tickets };
+    }
+    finally {
+        db.close();
+    }
+}
+function assembleTicketDetails(definition, state, states, validationHistory, events, delivery) {
+    const units = delivery?.units.filter((unit) => unit.tickets.includes(definition.id)) ?? [];
+    const unitIds = new Set(units.map((unit) => unit.id));
+    const stacks = delivery?.stacks?.filter((stack) => stack.units.some((unit) => unitIds.has(unit))) ?? [];
+    return {
+        definition,
+        state,
+        effective_blockers: resolveBlockers(definition, states),
+        validation_history: validationHistory,
+        events,
+        delivery: { units, stacks },
+    };
+}
+function groupByTicketId(records, ticketId) {
+    const grouped = new Map();
+    for (const record of records) {
+        const id = ticketId(record);
+        if (id === null)
+            continue;
+        const group = grouped.get(id);
+        if (group)
+            group.push(record);
+        else
+            grouped.set(id, [record]);
+    }
+    return grouped;
+}
 export function formatTicketDetails(details) {
     const lines = [`${details.definition.id}: ${details.definition.title}`, "", "Canonical ticket"];
     const preferred = [
@@ -62,6 +100,16 @@ export function formatTicketDetails(details) {
     lines.push(...formatRecords(details.events));
     return lines;
 }
+export function formatAllTicketDetails(details) {
+    const lines = [`All tickets (${details.ticket_count})`, `Snapshot: ${details.generated_at}`];
+    details.tickets.forEach((ticket, index) => {
+        lines.push("");
+        if (index > 0)
+            lines.push("--------------------------------------------------------------------------------", "");
+        lines.push(...formatTicketDetails(ticket));
+    });
+    return lines;
+}
 function formatField(label, value) {
     if (Array.isArray(value)) {
         if (value.length === 0)

package/dist/tickets/output.d.ts

@@ -0,0 +1,5 @@
+export interface AppendTicketOutputResult {
+    disposition: "created" | "appended";
+    path: string;
+}
+export declare function appendTicketOutput(projectDir: string, outputFile: string, payload: string): AppendTicketOutputResult;