ai-foreman 1.7.28 → 2.0.0

package/dist/supervisor.js

@@ -1,9 +1,40 @@
 import { processStartIdentity } from "./processIdentity.js";
+import { stopCause } from "rafi-spec";
 import { WorkflowDb } from "./workflowDb.js";
+/**
+ * Retry only the short synchronous persistence operation. The caller owns
+ * the retry budget and remains responsible for deciding whether ownership is
+ * safe after the budget is exhausted.
+ */
+export async function persistWithBoundedRetry(persist, sleep, attempts = 3) {
+    let error;
+    let completedAttempts = 0;
+    for (let attempt = 1; attempt <= Math.max(1, attempts); attempt++) {
+        completedAttempts = attempt;
+        try {
+            persist();
+            return { ok: true, attempts: attempt };
+        }
+        catch (failure) {
+            error = failure;
+            if (attempt < attempts && retryablePersistenceError(failure))
+                await sleep(100 * attempt);
+            else
+                break;
+        }
+    }
+    return { ok: false, attempts: completedAttempts, error };
+}
+function retryablePersistenceError(error) {
+    const code = typeof error === "object" && error !== null && "code" in error ? String(error.code) : "";
+    const message = error instanceof Error ? error.message : String(error);
+    return code === "SQLITE_BUSY" || code === "SQLITE_LOCKED" || /database is (?:busy|locked)/i.test(message);
+}
 /** Durable worker restart loop. The supervisor never owns the project's mutation lease. */
 export class DurableSupervisor {
     options;
     stopRequested = false;
+    requestedStopCause;
     active;
     sleep;
     now;
@@ -12,8 +43,12 @@ export class DurableSupervisor {
         this.sleep = options.sleep ?? ((milliseconds) => new Promise((resolve) => setTimeout(resolve, milliseconds)));
         this.now = options.now ?? (() => new Date());
     }
-    requestStop() {
+    requestStop(cause = "unknown") {
         this.stopRequested = true;
+        const source = cause === "user-sigint" || cause === "parent-sigterm" ? "signal" : cause === "heartbeat-timeout" ? "heartbeat" : cause === "heartbeat-persistence-failure" ? "persistence" : cause === "human-decision" ? "human-decision" : "host";
+        const actor = cause === "user-sigint" ? "user" : cause === "parent-sigterm" ? "parent" : cause === "heartbeat-persistence-failure" ? "database" : cause === "unknown" ? "unknown" : "supervisor";
+        this.requestedStopCause = stopCause({ cause, source, actor, runId: this.options.runId, checkpoint: this.options.checkpoint(), at: this.now().toISOString(), requested: true });
+        this.options.onStopRequested?.(this.requestedStopCause);
         void this.active?.stop();
     }
     async run() {
@@ -64,24 +99,35 @@ export class DurableSupervisor {
             db.putSupervisorState(this.options.runId, state);
         });
         let lastCheckpoint = this.options.checkpoint();
-        const heartbeat = setInterval(() => {
-            state = { ...state, heartbeatAt: this.now().toISOString() };
+        let heartbeatInFlight = false;
+        const persistHeartbeat = async () => {
+            if (heartbeatInFlight || this.stopRequested)
+                return;
+            heartbeatInFlight = true;
             try {
-                saveState();
+                state = { ...state, heartbeatAt: this.now().toISOString() };
+                const persisted = await persistWithBoundedRetry(saveState, this.sleep);
+                if (persisted.ok)
+                    return;
+                this.requestStop("heartbeat-persistence-failure");
+                // Ownership failure remains fail-closed; the explicit cause is
+                // delivered to the worker-exit evidence by supervisedStart.
             }
-            catch {
-                this.requestStop();
+            finally {
+                heartbeatInFlight = false;
             }
-        }, 10_000);
+        };
+        let heartbeatTask;
+        const heartbeat = setInterval(() => { heartbeatTask = persistHeartbeat(); }, this.options.heartbeatIntervalMs ?? 10_000);
         heartbeat.unref();
         try {
             while (!this.stopRequested) {
                 const pending = db.pendingHumanDecisions(this.options.runId);
                 if (pending.some(decision => !this.options.policy.continueIndependentTickets || !decision.interruptionId.startsWith("ticket:"))) {
-                    state = { ...state, status: "waiting_for_human", workerPid: undefined, heartbeatAt: this.now().toISOString() };
+                    state = { ...state, status: "waiting_for_human", workerPid: undefined, heartbeatAt: this.now().toISOString(), stopCause: stopCause({ cause: "human-decision", source: "human-decision", actor: "supervisor", runId: this.options.runId, supervisorGeneration: state.generation, workerGeneration: state.workerGeneration, checkpoint: "waiting-for-human", at: this.now().toISOString(), requested: true }) };
                     saveState();
                     if (db.getRun(this.options.runId)?.status === "running")
-                        db.transitionSupervisor(this.options.runId, state.workerGeneration, { status: "paused", checkpoint: "waiting-for-human", event: "worker_waiting_for_human" });
+                        db.transitionSupervisor(this.options.runId, state.workerGeneration, { status: "paused", checkpoint: "waiting-for-human", event: "worker_waiting_for_human", payload: { cause: state.stopCause } });
                     return { kind: "waiting_for_human" };
                 }
                 const checkpoint = this.options.checkpoint();
@@ -92,22 +138,27 @@ export class DurableSupervisor {
                 this.active = await this.options.spawnWorker(state.workerGeneration);
                 state = { ...state, workerPid: this.active.pid };
                 saveState();
+                const workerPid = state.workerPid;
                 const outcome = await this.active.result;
                 this.active = undefined;
                 state = { ...state, workerPid: undefined, heartbeatAt: this.now().toISOString() };
+                const cause = this.requestedStopCause
+                    ? stopCause({ ...this.requestedStopCause, supervisorGeneration: state.generation, workerGeneration: state.workerGeneration, pid: workerPid, processStart: workerPid ? processStartIdentity(workerPid) : undefined, checkpoint: this.options.checkpoint(), at: this.now().toISOString() })
+                    : stopCause({ cause: "worker-exit", source: "worker", actor: "worker", runId: this.options.runId, supervisorGeneration: state.generation, workerGeneration: state.workerGeneration, pid: workerPid, checkpoint: this.options.checkpoint(), at: this.now().toISOString(), requested: false, detail: outcome.kind === "failed" ? outcome.detail : `worker outcome: ${outcome.kind}` });
+                state = { ...state, stopCause: cause };
                 if (outcome.kind !== "crashed") {
                     if (outcome.kind === "failed" && db.getRun(this.options.runId)?.status === "running") {
                         const eligibility = db.preparationEligibility(this.options.runId);
                         db.transitionSupervisor(this.options.runId, state.workerGeneration, {
                             status: eligibility.eligible ? "failed" : "paused",
                             checkpoint: eligibility.eligible ? "worker-failed" : "worker-reconciliation-required",
-                            event: "worker_exit_recorded", payload: { detail: outcome.detail, reasons: eligibility.reasons },
+                            event: "worker_exit_recorded", payload: { detail: outcome.detail, reasons: eligibility.reasons, cause },
                         });
                     }
                     else if (db.getRun(this.options.runId)?.status === "running")
                         db.transitionSupervisor(this.options.runId, state.workerGeneration, {
                             status: "paused", checkpoint: outcome.kind === "waiting_for_human" && db.pendingHumanDecisions(this.options.runId).length ? "waiting-for-human" : "worker-exited-before-checkpoint",
-                            event: "worker_exit_recorded", payload: { outcome: outcome.kind },
+                            event: "worker_exit_recorded", payload: { outcome: outcome.kind, cause },
                         });
                     const status = outcome.kind === "completed" ? "stopped" : outcome.kind === "waiting_for_human" ? "waiting_for_human" : outcome.kind === "failed" ? "failed" : "stopped";
                     state = { ...state, status };
@@ -118,7 +169,10 @@ export class DurableSupervisor {
                 if (!eligibility.eligible) {
                     state = { ...state, status: "waiting_for_human" };
                     saveState();
-                    db.transitionSupervisor(this.options.runId, state.workerGeneration, { status: "paused", checkpoint: "worker-reconciliation-required", event: "worker_restart_withheld", payload: { reasons: eligibility.reasons } });
+                    const cause = stopCause({ ...state.stopCause, cause: "worker-reconciliation-required", source: "reconciliation", actor: "supervisor", checkpoint: "worker-reconciliation-required", at: this.now().toISOString(), requested: false, detail: eligibility.reasons.join("; ") });
+                    state = { ...state, stopCause: cause };
+                    saveState();
+                    db.transitionSupervisor(this.options.runId, state.workerGeneration, { status: "paused", checkpoint: "worker-reconciliation-required", event: "worker_restart_withheld", payload: { reasons: eligibility.reasons, cause } });
                     return { kind: "waiting_for_human" };
                 }
                 const checkpointLimit = this.options.policy.limits.workerRestartsPerCheckpoint;
@@ -128,7 +182,7 @@ export class DurableSupervisor {
                     saveState();
                     if (db.getRun(this.options.runId)?.status === "running")
                         db.transitionSupervisor(this.options.runId, state.workerGeneration, {
-                            status: "failed", checkpoint: "worker-restart-budget-exhausted", event: "worker_restart_budget_exhausted", payload: { checkpoint, detail: outcome.detail },
+                            status: "failed", checkpoint: "worker-restart-budget-exhausted", event: "worker_restart_budget_exhausted", payload: { checkpoint, detail: outcome.detail, cause: state.stopCause },
                         });
                     return { kind: "failed", detail: `worker restart budget exhausted at ${checkpoint}: ${outcome.detail}` };
                 }
@@ -136,26 +190,29 @@ export class DurableSupervisor {
                 saveState();
                 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 };
+            state = { ...state, status: "stopped", stopRequestedAt: this.now().toISOString(), workerPid: undefined, stopCause: state.stopCause ?? this.requestedStopCause ?? stopCause({ cause: "unknown", source: "host", actor: "unknown", runId: this.options.runId, supervisorGeneration: state.generation, workerGeneration: state.workerGeneration, checkpoint: "worker-stopped", at: this.now().toISOString(), requested: true, detail: "Supervisor stopped without a more specific durable cause" }) };
             if (db.getRun(this.options.runId)?.status === "running")
-                db.transitionSupervisor(this.options.runId, state.workerGeneration, { status: "paused", checkpoint: "worker-stopped", event: "supervisor_stop_recorded" });
+                db.transitionSupervisor(this.options.runId, state.workerGeneration, { status: "paused", checkpoint: "worker-stopped", event: "supervisor_stop_recorded", payload: { cause: state.stopCause } });
             saveState();
             return { kind: "stopped" };
         }
         catch (error) {
-            state = { ...state, status: "failed", workerPid: undefined, heartbeatAt: this.now().toISOString() };
+            state = { ...state, status: "failed", workerPid: undefined, heartbeatAt: this.now().toISOString(), stopCause: stopCause({ cause: "launch-failure", source: "launch", actor: "supervisor", runId: this.options.runId, supervisorGeneration: state.generation, workerGeneration: state.workerGeneration, checkpoint: "worker-launch-failed", at: this.now().toISOString(), requested: false, detail: String(error) }) };
             saveState();
             if (db.getRun(this.options.runId)?.status === "running") {
                 const eligibility = db.preparationEligibility(this.options.runId);
+                const cause = stopCause({ cause: "launch-failure", source: "launch", actor: "supervisor", runId: this.options.runId, supervisorGeneration: state.generation, workerGeneration: state.workerGeneration, checkpoint: eligibility.eligible ? "worker-launch-failed" : "worker-reconciliation-required", at: new Date().toISOString(), requested: false, detail: String(error) });
                 db.transitionSupervisor(this.options.runId, state.workerGeneration, { status: eligibility.eligible ? "failed" : "paused",
                     checkpoint: eligibility.eligible ? "worker-launch-failed" : "worker-reconciliation-required", event: "worker_launch_failed",
-                    payload: { detail: String(error), reasons: eligibility.reasons },
+                    payload: { detail: String(error), reasons: eligibility.reasons, cause },
                 });
             }
             throw error;
         }
         finally {
             clearInterval(heartbeat);
+            if (heartbeatTask)
+                await heartbeatTask;
             try {
                 if (ownedAdmission && db.buildAdmission()?.token === ownedAdmission.token)
                     db.releaseBuildAdmission(ownedAdmission);

package/dist/ticketPlanning.d.ts

@@ -2,7 +2,6 @@ import type { TicketDef } from "./tickets/ticketSchema.js";
 import { type TicketStatus } from "./tickets/stateDb.js";
 import { type DeliveryConfig } from "./tickets/delivery.js";
 import { type TicketBuildSetupConfig } from "./tickets/setupConfig.js";
-import { z } from "zod";
 export declare const PROPOSAL_START = "RAFI_PROPOSAL_START";
 export declare const PROPOSAL_END = "RAFI_PROPOSAL_END";
 export interface TicketEdit {
@@ -69,378 +68,7 @@ export interface TicketPlanningContext {
 export interface TicketPlanValidationContext {
     futureWorkIds?: Iterable<number>;
 }
-export declare const ticketPlanProposalV1Schema: z.ZodObject<{
-    version: z.ZodLiteral<1>;
-    title: z.ZodString;
-    markdown: z.ZodString;
-    additions: z.ZodArray<z.ZodObject<{
-        qa_preparation: z.ZodOptional<z.ZodObject<{
-            version: z.ZodLiteral<1>;
-            decisionId: z.ZodString;
-            level: z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<2>, z.ZodLiteral<3>, z.ZodLiteral<4>, z.ZodLiteral<5>]>;
-            rationale: z.ZodString;
-            riskFactors: z.ZodArray<z.ZodObject<{
-                category: z.ZodEnum<{
-                    interaction: "interaction";
-                    compatibility: "compatibility";
-                    "state-transition": "state-transition";
-                    "external-dependency": "external-dependency";
-                    authorization: "authorization";
-                    security: "security";
-                    "data-integrity": "data-integrity";
-                    migration: "migration";
-                    concurrency: "concurrency";
-                    recovery: "recovery";
-                    deployment: "deployment";
-                    "architecture-uncertainty": "architecture-uncertainty";
-                }>;
-                rationale: z.ZodString;
-                references: z.ZodArray<z.ZodString>;
-            }, z.core.$strict>>;
-            lowRisk: z.ZodOptional<z.ZodObject<{
-                narrowBehavior: z.ZodString;
-                understoodDependencies: z.ZodString;
-                adequateVerification: z.ZodString;
-            }, z.core.$strict>>;
-            policyVersion: z.ZodLiteral<"qa-preparation-v1">;
-            plannerOperationId: z.ZodString;
-            plannerIdentity: z.ZodString;
-            timestamp: z.ZodString;
-            minimumLevel: z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<2>, z.ZodLiteral<3>, z.ZodLiteral<4>, z.ZodLiteral<5>]>;
-            minimumReasons: z.ZodArray<z.ZodString>;
-            predecessorDecisionId: z.ZodOptional<z.ZodString>;
-        }, z.core.$strict>>;
-        id: z.ZodString;
-        order: z.ZodNumber;
-        documentation: z.ZodOptional<z.ZodObject<{
-            required: z.ZodBoolean;
-            targets: z.ZodArray<z.ZodString>;
-            criteria: z.ZodArray<z.ZodString>;
-        }, z.core.$strict>>;
-        title: z.ZodString;
-        area: z.ZodString;
-        priority: z.ZodEnum<{
-            P0: "P0";
-            P1: "P1";
-            P2: "P2";
-            P3: "P3";
-        }>;
-        size: z.ZodEnum<{
-            XS: "XS";
-            S: "S";
-            M: "M";
-            L: "L";
-            XL: "XL";
-        }>;
-        risk: z.ZodEnum<{
-            Low: "Low";
-            Medium: "Medium";
-            High: "High";
-        }>;
-        depends_on: z.ZodArray<z.ZodString>;
-        summary: z.ZodString;
-        acceptance: z.ZodArray<z.ZodString>;
-        required_tests: z.ZodArray<z.ZodString>;
-        likely_files: z.ZodArray<z.ZodString>;
-        rollback: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-        notes: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-        external_refs: z.ZodOptional<z.ZodArray<z.ZodObject<{
-            provider: z.ZodString;
-            id: z.ZodString;
-            key: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-            url: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-        }, z.core.$strict>>>;
-        source_refs: z.ZodOptional<z.ZodArray<z.ZodObject<{
-            source: z.ZodString;
-            item: z.ZodString;
-            source_id: z.ZodOptional<z.ZodString>;
-            url: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-            fingerprint: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-            note: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-        }, z.core.$strict>>>;
-        superseded_by: z.ZodOptional<z.ZodArray<z.ZodString>>;
-        supersedes: z.ZodOptional<z.ZodArray<z.ZodString>>;
-        plan_ref: z.ZodOptional<z.ZodObject<{
-            plan_id: z.ZodString;
-            revision: z.ZodNumber;
-            slice_ref: z.ZodString;
-        }, z.core.$strict>>;
-    }, z.core.$strict>>;
-    edits: z.ZodArray<z.ZodObject<{
-        id: z.ZodString;
-        patch: z.ZodObject<{
-            qa_preparation: z.ZodOptional<z.ZodOptional<z.ZodObject<{
-                version: z.ZodLiteral<1>;
-                decisionId: z.ZodString;
-                level: z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<2>, z.ZodLiteral<3>, z.ZodLiteral<4>, z.ZodLiteral<5>]>;
-                rationale: z.ZodString;
-                riskFactors: z.ZodArray<z.ZodObject<{
-                    category: z.ZodEnum<{
-                        interaction: "interaction";
-                        compatibility: "compatibility";
-                        "state-transition": "state-transition";
-                        "external-dependency": "external-dependency";
-                        authorization: "authorization";
-                        security: "security";
-                        "data-integrity": "data-integrity";
-                        migration: "migration";
-                        concurrency: "concurrency";
-                        recovery: "recovery";
-                        deployment: "deployment";
-                        "architecture-uncertainty": "architecture-uncertainty";
-                    }>;
-                    rationale: z.ZodString;
-                    references: z.ZodArray<z.ZodString>;
-                }, z.core.$strict>>;
-                lowRisk: z.ZodOptional<z.ZodObject<{
-                    narrowBehavior: z.ZodString;
-                    understoodDependencies: z.ZodString;
-                    adequateVerification: z.ZodString;
-                }, z.core.$strict>>;
-                policyVersion: z.ZodLiteral<"qa-preparation-v1">;
-                plannerOperationId: z.ZodString;
-                plannerIdentity: z.ZodString;
-                timestamp: z.ZodString;
-                minimumLevel: z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<2>, z.ZodLiteral<3>, z.ZodLiteral<4>, z.ZodLiteral<5>]>;
-                minimumReasons: z.ZodArray<z.ZodString>;
-                predecessorDecisionId: z.ZodOptional<z.ZodString>;
-            }, z.core.$strict>>>;
-            id: z.ZodOptional<z.ZodString>;
-            order: z.ZodOptional<z.ZodNumber>;
-            documentation: z.ZodOptional<z.ZodOptional<z.ZodObject<{
-                required: z.ZodBoolean;
-                targets: z.ZodArray<z.ZodString>;
-                criteria: z.ZodArray<z.ZodString>;
-            }, z.core.$strict>>>;
-            title: z.ZodOptional<z.ZodString>;
-            area: z.ZodOptional<z.ZodString>;
-            priority: z.ZodOptional<z.ZodEnum<{
-                P0: "P0";
-                P1: "P1";
-                P2: "P2";
-                P3: "P3";
-            }>>;
-            size: z.ZodOptional<z.ZodEnum<{
-                XS: "XS";
-                S: "S";
-                M: "M";
-                L: "L";
-                XL: "XL";
-            }>>;
-            risk: z.ZodOptional<z.ZodEnum<{
-                Low: "Low";
-                Medium: "Medium";
-                High: "High";
-            }>>;
-            depends_on: z.ZodOptional<z.ZodArray<z.ZodString>>;
-            summary: z.ZodOptional<z.ZodString>;
-            acceptance: z.ZodOptional<z.ZodArray<z.ZodString>>;
-            required_tests: z.ZodOptional<z.ZodArray<z.ZodString>>;
-            likely_files: z.ZodOptional<z.ZodArray<z.ZodString>>;
-            rollback: z.ZodOptional<z.ZodOptional<z.ZodNullable<z.ZodString>>>;
-            notes: z.ZodOptional<z.ZodOptional<z.ZodNullable<z.ZodString>>>;
-            external_refs: z.ZodOptional<z.ZodOptional<z.ZodArray<z.ZodObject<{
-                provider: z.ZodString;
-                id: z.ZodString;
-                key: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-                url: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-            }, z.core.$strict>>>>;
-            source_refs: z.ZodOptional<z.ZodOptional<z.ZodArray<z.ZodObject<{
-                source: z.ZodString;
-                item: z.ZodString;
-                source_id: z.ZodOptional<z.ZodString>;
-                url: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-                fingerprint: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-                note: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-            }, z.core.$strict>>>>;
-            superseded_by: z.ZodOptional<z.ZodOptional<z.ZodArray<z.ZodString>>>;
-            supersedes: z.ZodOptional<z.ZodOptional<z.ZodArray<z.ZodString>>>;
-            plan_ref: z.ZodOptional<z.ZodOptional<z.ZodObject<{
-                plan_id: z.ZodString;
-                revision: z.ZodNumber;
-                slice_ref: z.ZodString;
-            }, z.core.$strict>>>;
-        }, z.core.$strict>;
-    }, z.core.$strict>>;
-    supersessions: z.ZodArray<z.ZodObject<{
-        replaced: z.ZodArray<z.ZodString>;
-        replacements: z.ZodArray<z.ZodString>;
-        reason: z.ZodString;
-    }, z.core.$strict>>;
-    state_changes: z.ZodArray<z.ZodObject<{
-        id: z.ZodString;
-        status: z.ZodEnum<{
-            blocked: "blocked";
-            in_progress: "in_progress";
-            done: "done";
-            planned: "planned";
-            next: "next";
-            canceled: "canceled";
-            obsolete: "obsolete";
-        }>;
-        reason: z.ZodString;
-    }, z.core.$strict>>;
-    source_reconciliation: z.ZodArray<z.ZodObject<{
-        source: z.ZodString;
-        item: z.ZodString;
-        disposition: z.ZodEnum<{
-            split: "split";
-            deferred: "deferred";
-            combined: "combined";
-            mapped: "mapped";
-            excluded: "excluded";
-        }>;
-        ticket_ids: z.ZodArray<z.ZodString>;
-        reason: z.ZodOptional<z.ZodString>;
-    }, z.core.$strict>>;
-    delivery: z.ZodOptional<z.ZodNullable<z.ZodObject<{
-        version: z.ZodLiteral<1>;
-        plan: z.ZodOptional<z.ZodObject<{
-            plan_id: z.ZodString;
-            revision: z.ZodNumber;
-        }, z.core.$strict>>;
-        units: z.ZodArray<z.ZodObject<{
-            id: z.ZodString;
-            tickets: z.ZodArray<z.ZodString>;
-            branch_mode: z.ZodEnum<{
-                current: "current";
-                "per-ticket": "per-ticket";
-                shared: "shared";
-            }>;
-            completion: z.ZodOptional<z.ZodEnum<{
-                none: "none";
-                pr: "pr";
-                "auto-merge": "auto-merge";
-                "direct-merge": "direct-merge";
-            }>>;
-            provider: z.ZodOptional<z.ZodEnum<{
-                auto: "auto";
-                local: "local";
-                github: "github";
-                gitlab: "gitlab";
-            }>>;
-            pr_ready: z.ZodOptional<z.ZodBoolean>;
-            merge_method: z.ZodOptional<z.ZodEnum<{
-                squash: "squash";
-                merge: "merge";
-                rebase: "rebase";
-            }>>;
-            cleanup: z.ZodOptional<z.ZodBoolean>;
-            depends_on: z.ZodOptional<z.ZodArray<z.ZodString>>;
-            dependency_mode: z.ZodOptional<z.ZodEnum<{
-                combine: "combine";
-                wait: "wait";
-                stack: "stack";
-            }>>;
-        }, z.core.$strict>>;
-        stacks: z.ZodOptional<z.ZodArray<z.ZodObject<{
-            id: z.ZodString;
-            name: z.ZodString;
-            units: z.ZodArray<z.ZodString>;
-            status: z.ZodOptional<z.ZodEnum<{
-                partial: "partial";
-                blocked: "blocked";
-                in_progress: "in_progress";
-                planned: "planned";
-                merged: "merged";
-                awaiting_review: "awaiting_review";
-            }>>;
-            completed_prefix: z.ZodOptional<z.ZodArray<z.ZodString>>;
-            next_ticket: z.ZodOptional<z.ZodString>;
-            review_links: z.ZodOptional<z.ZodArray<z.ZodString>>;
-            remote_checked_at: z.ZodOptional<z.ZodString>;
-            remote_stale: z.ZodOptional<z.ZodBoolean>;
-            published_branches: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
-        }, z.core.$strict>>>;
-    }, z.core.$strict>>>;
-    build_defaults: z.ZodOptional<z.ZodNullable<z.ZodObject<{
-        branch_strategy: z.ZodOptional<z.ZodOptional<z.ZodEnum<{
-            current: "current";
-            batch: "batch";
-            "branch-per-ticket": "branch-per-ticket";
-        }>>>;
-        completion: z.ZodOptional<z.ZodOptional<z.ZodEnum<{
-            none: "none";
-            pr: "pr";
-            "auto-merge": "auto-merge";
-            "direct-merge": "direct-merge";
-        }>>>;
-        provider: z.ZodOptional<z.ZodOptional<z.ZodEnum<{
-            auto: "auto";
-            local: "local";
-            github: "github";
-            gitlab: "gitlab";
-        }>>>;
-        pr_ready: z.ZodOptional<z.ZodOptional<z.ZodBoolean>>;
-        merge_method: z.ZodOptional<z.ZodOptional<z.ZodEnum<{
-            squash: "squash";
-            merge: "merge";
-            rebase: "rebase";
-        }>>>;
-        cleanup: z.ZodOptional<z.ZodOptional<z.ZodBoolean>>;
-        auto_merge_wait: z.ZodOptional<z.ZodOptional<z.ZodBoolean>>;
-        auto_merge_timeout_minutes: z.ZodOptional<z.ZodOptional<z.ZodNullable<z.ZodNumber>>>;
-        base_branch: z.ZodOptional<z.ZodOptional<z.ZodString>>;
-        branch_prefix: z.ZodOptional<z.ZodOptional<z.ZodString>>;
-        branch_policy: z.ZodOptional<z.ZodOptional<z.ZodObject<{
-            mode: z.ZodEnum<{
-                size: "size";
-                global: "global";
-            }>;
-            global_strategy: z.ZodEnum<{
-                current: "current";
-                batch: "batch";
-                "branch-per-ticket": "branch-per-ticket";
-            }>;
-            by_size: z.ZodObject<{
-                XS: z.ZodEnum<{
-                    "per-ticket": "per-ticket";
-                    shared: "shared";
-                }>;
-                S: z.ZodEnum<{
-                    "per-ticket": "per-ticket";
-                    shared: "shared";
-                }>;
-                M: z.ZodEnum<{
-                    "per-ticket": "per-ticket";
-                    shared: "shared";
-                }>;
-                L: z.ZodEnum<{
-                    "per-ticket": "per-ticket";
-                    shared: "shared";
-                }>;
-                XL: z.ZodEnum<{
-                    "per-ticket": "per-ticket";
-                    shared: "shared";
-                }>;
-            }, z.core.$strict>;
-        }, z.core.$strict>>>;
-        review: z.ZodOptional<z.ZodOptional<z.ZodObject<{
-            title_style: z.ZodEnum<{
-                none: "none";
-                custom: "custom";
-                "ticket-title": "ticket-title";
-                conventional: "conventional";
-            }>;
-            title_template: z.ZodNullable<z.ZodString>;
-            description_sections: z.ZodArray<z.ZodString>;
-        }, z.core.$strict>>>;
-        validation_checklist: z.ZodOptional<z.ZodOptional<z.ZodArray<z.ZodString>>>;
-    }, z.core.$strict>>>;
-    future_work: z.ZodArray<z.ZodObject<{
-        id: z.ZodNumber;
-        disposition: z.ZodEnum<{
-            rejected: "rejected";
-            accepted: "accepted";
-            merged: "merged";
-            queued: "queued";
-        }>;
-    }, z.core.$strict>>;
-    next: z.ZodObject<{
-        ticket_ids: z.ZodArray<z.ZodString>;
-        replace_existing: z.ZodBoolean;
-    }, z.core.$strict>;
-}, z.core.$strict>;
+export { ticketPlanProposalV1Schema } from "rafi-spec";
 export declare function readTicketPlanningContext(projectDir: string): TicketPlanningContext;
 export declare function ticketPlanningFingerprint(projectDir: string): PlanningFingerprint[];
 export declare function planningFingerprintChanges(projectDir: string, expected: PlanningFingerprint[]): string[];

package/dist/ticketPlanning.js

@@ -10,34 +10,10 @@ import { renderAndWrite } from "./tickets/renderMarkdown.js";
 import { runAllValidation } from "./tickets/validate.js";
 import { normalizeDeliveryConfig, validateDeliveryConfig } from "./tickets/delivery.js";
 import { loadTicketSetupConfig, mergeTicketSetup, saveTicketSetupConfig } from "./tickets/setupConfig.js";
-import { z } from "zod";
-import { documentationPolicyV1ZodSchema as documentationPolicyZodSchema, qaPreparationDepthDecisionZodSchema, zodIssues } from "rafi-spec";
+import { ticketPlanProposalV1Schema, zodIssues } from "rafi-spec";
 export const PROPOSAL_START = "RAFI_PROPOSAL_START";
 export const PROPOSAL_END = "RAFI_PROPOSAL_END";
-const providerText = (max = 20_000) => z.string().trim().min(1).max(max);
-const identifier = z.string().regex(/^[A-Za-z][A-Za-z0-9-_]{0,127}$/);
-const ticketSourceRef = z.strictObject({ source: providerText(500), item: providerText(2_000), source_id: identifier.optional(), url: z.string().url().nullable().optional(), fingerprint: z.string().regex(/^[a-f0-9]{64}$/).nullable().optional(), note: providerText(2_000).nullable().optional() });
-const ticketDefinitionProposal = z.strictObject({
-    qa_preparation: qaPreparationDepthDecisionZodSchema.optional(), id: identifier, order: z.number().int().min(0),
-    documentation: documentationPolicyZodSchema.optional(),
-    title: providerText(500), area: providerText(500), priority: z.enum(["P0", "P1", "P2", "P3"]), size: z.enum(["XS", "S", "M", "L", "XL"]), risk: z.enum(["Low", "Medium", "High"]),
-    depends_on: z.array(identifier).max(200), summary: providerText(), acceptance: z.array(providerText()).min(1).max(200), required_tests: z.array(providerText()).min(1).max(200), likely_files: z.array(providerText(1_000)).max(200),
-    rollback: z.string().max(20_000).nullable().optional(), notes: z.string().max(20_000).nullable().optional(),
-    external_refs: z.array(z.strictObject({ provider: providerText(100), id: providerText(500), key: providerText(500).nullable().optional(), url: z.string().url().nullable().optional() })).max(100).optional(),
-    source_refs: z.array(ticketSourceRef).max(100).optional(), superseded_by: z.array(identifier).max(200).optional(), supersedes: z.array(identifier).max(200).optional(),
-    plan_ref: z.strictObject({ plan_id: identifier, revision: z.number().int().min(1), slice_ref: identifier }).optional(),
-});
-const deliveryConfigProposal = z.strictObject({
-    version: z.literal(1), plan: z.strictObject({ plan_id: identifier, revision: z.number().int().min(1) }).optional(),
-    units: z.array(z.strictObject({ id: identifier, tickets: z.array(identifier).min(1).max(200), branch_mode: z.enum(["current", "per-ticket", "shared"]), completion: z.enum(["pr", "auto-merge", "direct-merge", "none"]).optional(), provider: z.enum(["auto", "github", "gitlab", "local"]).optional(), pr_ready: z.boolean().optional(), merge_method: z.enum(["squash", "merge", "rebase"]).optional(), cleanup: z.boolean().optional(), depends_on: z.array(identifier).max(200).optional(), dependency_mode: z.enum(["combine", "wait", "stack"]).optional() })).max(200),
-    stacks: z.array(z.strictObject({ id: identifier, name: providerText(500), units: z.array(identifier).min(1).max(5), status: z.enum(["planned", "in_progress", "partial", "blocked", "awaiting_review", "merged"]).optional(), completed_prefix: z.array(identifier).max(5).optional(), next_ticket: identifier.optional(), review_links: z.array(z.string().url()).max(20).optional(), remote_checked_at: z.string().datetime().optional(), remote_stale: z.boolean().optional(), published_branches: z.record(identifier, providerText(500)).optional() })).max(200).optional(),
-});
-const buildDefaultsProposal = z.strictObject({
-    branch_strategy: z.enum(["current", "batch", "branch-per-ticket"]).optional(), completion: z.enum(["pr", "auto-merge", "direct-merge", "none"]).optional(), provider: z.enum(["auto", "github", "gitlab", "local"]).optional(), pr_ready: z.boolean().optional(), merge_method: z.enum(["squash", "merge", "rebase"]).optional(), cleanup: z.boolean().optional(), auto_merge_wait: z.boolean().optional(), auto_merge_timeout_minutes: z.number().int().min(0).nullable().optional(), base_branch: providerText(500).optional(), branch_prefix: providerText(500).optional(), branch_policy: z.strictObject({ mode: z.enum(["global", "size"]), global_strategy: z.enum(["current", "batch", "branch-per-ticket"]), by_size: z.strictObject({ XS: z.enum(["shared", "per-ticket"]), S: z.enum(["shared", "per-ticket"]), M: z.enum(["shared", "per-ticket"]), L: z.enum(["shared", "per-ticket"]), XL: z.enum(["shared", "per-ticket"]) }) }).optional(), review: z.strictObject({ title_style: z.enum(["ticket-title", "conventional", "none", "custom"]), title_template: z.string().max(500).nullable(), description_sections: z.array(providerText(500)).max(50) }).optional(), validation_checklist: z.array(providerText(500)).max(100).optional(),
-});
-export const ticketPlanProposalV1Schema = z.strictObject({
-    version: z.literal(1), title: providerText(500), markdown: providerText(100_000), additions: z.array(ticketDefinitionProposal).max(200), edits: z.array(z.strictObject({ id: identifier, patch: ticketDefinitionProposal.partial() })).max(200), supersessions: z.array(z.strictObject({ replaced: z.array(identifier).min(1).max(200), replacements: z.array(identifier).min(1).max(200), reason: providerText() })).max(200), state_changes: z.array(z.strictObject({ id: identifier, status: z.enum(["planned", "next", "in_progress", "blocked", "done", "canceled", "obsolete"]), reason: providerText() })).max(200), source_reconciliation: z.array(z.strictObject({ source: providerText(500), item: providerText(2_000), disposition: z.enum(["mapped", "split", "combined", "deferred", "excluded"]), ticket_ids: z.array(identifier).max(200), reason: providerText().optional() })).max(500), delivery: deliveryConfigProposal.nullable().optional(), build_defaults: buildDefaultsProposal.partial().nullable().optional(), future_work: z.array(z.strictObject({ id: z.number().int().min(0), disposition: z.enum(["accepted", "rejected", "merged", "queued"]) })).max(500), next: z.strictObject({ ticket_ids: z.array(identifier).max(200), replace_existing: z.boolean() }),
-});
+export { ticketPlanProposalV1Schema } from "rafi-spec";
 const TICKET_STATUSES = new Set([
     "planned", "next", "in_progress", "blocked", "done", "canceled", "obsolete",
 ]);

package/dist/ticketPopulation.d.ts

@@ -32,8 +32,6 @@ export interface TicketPopulationProposalV1 {
     tickets: TicketSliceProposal[];
     retirements: string[];
 }
-export declare const TICKET_POPULATION_PROPOSAL_START = "RAFI_TICKET_POPULATION_PROPOSAL_START";
-export declare const TICKET_POPULATION_PROPOSAL_END = "RAFI_TICKET_POPULATION_PROPOSAL_END";
 export interface PopulationRiskWaiver {
     ticketId: string;
     reason: string;
@@ -57,7 +55,6 @@ export declare class TicketPopulationValidationError extends Error {
 }
 /** Reject a correction that attempts to turn a risk-note repair into a new plan. */
 export declare function assertRiskPlanOnlyCorrection(previous: TicketPopulationProposalV1, corrected: TicketPopulationProposalV1, permittedSliceRefs: string[]): void;
-export declare function extractTicketPopulationProposal(output: string): TicketPopulationProposalV1;
 export declare function validateTicketPopulationProposal(proposal: TicketPopulationProposalV1, plan: StructuredPlanV1, existing: TicketDef[], options?: {
     branchStrategy?: PopulationBranchStrategy;
 }): string[];