ai-foreman 1.6.2 → 1.7.1

package/dist/tickets/queue.d.ts

@@ -1,5 +1,6 @@
 import type { TicketDef } from "./ticketSchema.js";
 import type { TicketState } from "./stateDb.js";
+import type { DeliveryConfig } from "./delivery.js";
 export interface QueueRow {
     rank: number;
     ticket: string;
@@ -34,3 +35,5 @@ export interface ActiveStatusRow {
 }
 export declare function buildNextQueue(ticketDefs: TicketDef[], states: Map<string, TicketState>, queueLimit: number): QueueRow[];
 export declare function buildActiveStatusRows(queueRows: QueueRow[], ticketDefs: TicketDef[], states: Map<string, TicketState>): ActiveStatusRow[];
+/** Human-readable queue blocks keep a whole unfinished stack and its resume point visible. */
+export declare function formatStackAwareQueue(ticketDefs: TicketDef[], states: Map<string, TicketState>, delivery?: DeliveryConfig): string[];

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/setupConfig.js

@@ -3,6 +3,7 @@ import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { parse, stringify } from "yaml";
 import { loadDefaults } from "special-agents";
+import { appendLegacyTicketSources, loadSourceRegistry } from "../sources/sourceRegistry.js";
 export const RAFI_CONFIG_FILE = "rafi-config.yaml";
 const AGENT_NAMES = ["builder", "qa", "planner", "ticket-maker", "uninstaller"];
 const SKILL_NAMES = [
@@ -48,7 +49,10 @@ export function loadTicketSetupConfig(projectDir) {
     const raw = loadRafiConfigObject(projectDir);
     if (!raw || raw.tickets === undefined)
         return undefined;
-    return normalizeTicketsSetupConfig(raw.tickets, `${RAFI_CONFIG_FILE}.tickets`);
+    const setup = normalizeTicketsSetupConfig(raw.tickets, `${RAFI_CONFIG_FILE}.tickets`);
+    if (setup.sources.length === 0)
+        setup.sources = legacySourcesFromRegistry(loadSourceRegistry(projectDir).registry.entries);
+    return setup;
 }
 export function loadTicketSetupConfigWithDefaults(projectDir) {
     return loadTicketSetupConfig(projectDir) ?? cloneTicketSetup(DEFAULT_TICKET_SETUP);
@@ -59,7 +63,17 @@ export function hasTicketSetupConfig(projectDir) {
 }
 export function saveTicketSetupConfig(projectDir, setup, opts = {}) {
     const config = loadRafiConfigObject(projectDir) ?? minimalRafiConfig(projectDir, opts);
-    config.tickets = denormalizeTicketsSetupConfig(normalizeTicketsSetupConfig(setup, "tickets"));
+    const normalized = normalizeTicketsSetupConfig(setup, "tickets");
+    const ticketConfig = denormalizeTicketsSetupConfig(normalized);
+    delete ticketConfig.sources;
+    config.tickets = ticketConfig;
+    config.sources = appendLegacyTicketSources(loadSourceRegistry(projectDir).registry, normalized.sources);
+    const planning = config.planning && typeof config.planning === "object" && !Array.isArray(config.planning) ? config.planning : undefined;
+    if (planning) {
+        delete planning.sources;
+        if (Object.keys(planning).length === 0)
+            delete config.planning;
+    }
     mkdirSync(projectDir, { recursive: true });
     writeFileSync(join(projectDir, RAFI_CONFIG_FILE), stringify(config, { lineWidth: 100 }), "utf8");
 }
@@ -424,3 +438,17 @@ function cloneTicketSetup(setup) {
 function unique(values) {
     return [...new Set(values)];
 }
+function legacySourcesFromRegistry(entries) {
+    const out = [];
+    for (const entry of entries.filter((item) => item.active)) {
+        if (entry.type === "local" && entry.locator.path)
+            out.push({ type: "local", paths: [entry.locator.path] });
+        else if (entry.type === "url" && entry.locator.url)
+            out.push({ type: "url", url: entry.locator.url });
+        else if (entry.type === "linear")
+            out.push({ type: "linear", api_key_env: entry.locator.api_key_env ?? "LINEAR_API_KEY", team_key: entry.locator.team_key, filter: entry.locator.filter });
+        else if (entry.type === "jira" && entry.locator.site && entry.locator.jql)
+            out.push({ type: "jira", site: entry.locator.site, email_env: entry.locator.email_env ?? "JIRA_EMAIL", token_env: entry.locator.token_env ?? "JIRA_API_TOKEN", jql: entry.locator.jql });
+    }
+    return dedupeTicketSources(out);
+}

package/dist/tickets/sourceFetch.js

@@ -23,7 +23,7 @@ export async function fetchAndSnapshotUrl(projectDir, input, limits = {}) {
             response = await fetch(current, {
                 redirect: "manual",
                 signal: controller.signal,
-                headers: { Accept: "text/html,text/plain,text/markdown,application/pdf;q=0.9" },
+                headers: { Accept: "text/html,text/plain,text/markdown,application/json,application/yaml,text/yaml,application/pdf;q=0.9" },
             });
         }
         finally {
@@ -154,6 +154,11 @@ function detectContentType(header, bytes, url) {
         return "html";
     if (["text/markdown", "text/x-markdown"].includes(mime) || /\.md(?:own)?$/i.test(new URL(url).pathname))
         return "markdown";
+    if (["application/json", "application/yaml", "application/x-yaml", "text/yaml", "text/x-yaml"].includes(mime) || /\.(?:json|ya?ml)$/i.test(new URL(url).pathname)) {
+        if (bytes.subarray(0, Math.min(bytes.length, 1024)).includes(0))
+            throw new Error("binary URL content is not supported");
+        return "text";
+    }
     if (!mime || mime.startsWith("text/") || mime === "application/octet-stream") {
         if (bytes.subarray(0, Math.min(bytes.length, 1024)).includes(0))
             throw new Error("binary URL content is not supported");

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

@@ -11,10 +11,16 @@ export interface TicketExternalRef {
 export interface TicketSourceRef {
     source: string;
     item: string;
+    source_id?: string;
     url?: string | null;
     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 +40,7 @@ export interface TicketDef {
     source_refs?: TicketSourceRef[];
     superseded_by?: string[];
     supersedes?: string[];
+    plan_ref?: TicketPlanRef;
 }
 export declare const TICKET_JSON_SCHEMA: {
     readonly type: "object";
@@ -143,6 +150,10 @@ export declare const TICKET_JSON_SCHEMA: {
                         readonly type: "string";
                         readonly minLength: 1;
                     };
+                    readonly source_id: {
+                        readonly type: "string";
+                        readonly pattern: "^src_[A-Za-z0-9_-]+$";
+                    };
                     readonly url: {
                         readonly type: readonly ["string", "null"];
                     };
@@ -169,6 +180,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: {
@@ -285,6 +315,10 @@ export declare const TICKETS_FILE_SCHEMA: {
                                     readonly type: "string";
                                     readonly minLength: 1;
                                 };
+                                readonly source_id: {
+                                    readonly type: "string";
+                                    readonly pattern: "^src_[A-Za-z0-9_-]+$";
+                                };
                                 readonly url: {
                                     readonly type: readonly ["string", "null"];
                                 };
@@ -311,6 +345,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

@@ -43,6 +43,7 @@ export const TICKET_JSON_SCHEMA = {
                 properties: {
                     source: { type: "string", minLength: 1 },
                     item: { type: "string", minLength: 1 },
+                    source_id: { type: "string", pattern: "^src_[A-Za-z0-9_-]+$" },
                     url: { type: ["string", "null"] },
                     fingerprint: { type: ["string", "null"] },
                     note: { type: ["string", "null"] },
@@ -51,6 +52,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;
+}