ai-foreman 1.7.5 → 1.7.6

package/dist/foreman.d.ts

@@ -27,7 +27,7 @@ export declare function looksLikeQuestion(text: string): boolean;
 export { MARKER_SPEC } from "./markers.js";
 export { QA_MARKER_SPEC } from "./markers.js";
 /** Instruction sent on the first turn of a batch. */
-export declare function buildPrimer(n: number, trackerPath?: string, ticketsEnabled?: boolean): string;
+export declare function buildPrimer(n: number, trackerPath?: string, ticketsEnabled?: boolean, preferredTicketId?: string): string;
 /** Instruction sent on turns 2–N. */
 export declare function buildNextStepInstruction(i: number, n: number): string;
 /** QA review turn: ask the builder to triple-check the ticket or step it just completed. */
@@ -35,7 +35,7 @@ export declare function buildQaInstruction(): string;
 /** Follow-up turn after qa_fail: have the builder implement the listed fixes. */
 export declare function buildQaFixInstruction(issues: string): string;
 /** Pre-flight planning turn: ask the builder to list its next N steps without implementing anything. */
-export declare function buildPlanningTurn(n: number, ticketsContent?: string): string;
+export declare function buildPlanningTurn(n: number, ticketsContent?: string, preferredTicketId?: string): string;
 /** Builds the permission callback: classify, log, allow or escalate. */
 export declare function createPermissionHandler(policy: PermissionPolicy, log: Log, opts?: {
     interactive?: boolean;
@@ -74,7 +74,7 @@ export declare class Foreman {
     private prepareBuilderBoundary;
     private doTurnWith;
     /** Send a planning turn and return the builder's response text. Does not count toward steps. */
-    runPreflight(n: number, ticketsContent?: string): Promise<string>;
+    runPreflight(n: number, ticketsContent?: string, preferredTicketId?: string): Promise<string>;
     /** Send user feedback on the plan; builder responds with a revised list. Does not count toward steps. */
     sendPreflightFeedback(feedback: string): Promise<void>;
     /** Send one custom instruction through the same needs_input loop as a batch turn. */
@@ -98,5 +98,5 @@ export declare class Foreman {
     builderAdapter(): BuilderAdapter;
     close(): Promise<void>;
     private ticketForQa;
-    runBatch(n: number, trackerPath?: string): Promise<BatchResult>;
+    runBatch(n: number, trackerPath?: string, onTicketStart?: (ticketId: string) => void | Promise<void>, preferredTicketId?: string): Promise<BatchResult>;
 }

package/dist/foreman.js

@@ -107,7 +107,7 @@ export function looksLikeQuestion(text) {
 export { MARKER_SPEC } from "./markers.js";
 export { QA_MARKER_SPEC } from "./markers.js";
 /** Instruction sent on the first turn of a batch. */
-export function buildPrimer(n, trackerPath, ticketsEnabled = false) {
+export function buildPrimer(n, trackerPath, ticketsEnabled = false, preferredTicketId) {
     let trackerRule;
     if (ticketsEnabled) {
         const progressDoc = trackerPath ?? "docs/ticket-progress.md";
@@ -122,12 +122,15 @@ export function buildPrimer(n, trackerPath, ticketsEnabled = false) {
     else {
         trackerRule = "";
     }
+    const preferredTicketRule = preferredTicketId
+        ? `\n- Resume and finish ticket ${preferredTicketId} first. Do not substitute a different queued ticket.`
+        : "";
     return `You are being run by an automated foreman. We will work through your next ${n} tickets or implementation steps, one per turn.
 
 Rules:
 - Do exactly ONE ticket or step this turn, then stop.
 - ${MARKER_SPEC}
-- If a tool action is denied by foreman policy, do not retry it; report it via the blocked marker.${trackerRule}
+- If a tool action is denied by foreman policy, do not retry it; report it via the blocked marker.${trackerRule}${preferredTicketRule}
 
 This is step 1 of ${n}. Implement the next ticket or step now.`;
 }
@@ -160,11 +163,14 @@ ${issues}
 Fix every one of them now. Then end with STEP_STATUS: done so foreman can re-run QA on the fixes. Triple-check that your fixes actually resolve the issues before emitting done.`;
 }
 /** Pre-flight planning turn: ask the builder to list its next N steps without implementing anything. */
-export function buildPlanningTurn(n, ticketsContent) {
+export function buildPlanningTurn(n, ticketsContent, preferredTicketId) {
     const header = ticketsContent
         ? `Here is the project's ticket list:\n\n${ticketsContent}\n\n`
         : "";
-    return `${header}Before we begin, list the next ${n} ticket(s) or step(s) you plan to implement, in order. Be specific — reference ticket IDs or titles where applicable. Do not implement anything yet; output the numbered list only. Do not emit a STEP_STATUS marker on this turn.`;
+    const preferred = preferredTicketId
+        ? ` The first item must be ticket ${preferredTicketId}; this is an interrupted ticket being resumed.`
+        : "";
+    return `${header}Before we begin, list the next ${n} ticket(s) or step(s) you plan to implement, in order.${preferred} Be specific — reference ticket IDs or titles where applicable. Do not implement anything yet; output the numbered list only. Do not emit a STEP_STATUS marker on this turn.`;
 }
 /** Builds the permission callback: classify, log, allow or escalate. */
 export function createPermissionHandler(policy, log, opts = {}) {
@@ -318,8 +324,8 @@ export class Foreman {
         return { result, status };
     }
     /** Send a planning turn and return the builder's response text. Does not count toward steps. */
-    async runPreflight(n, ticketsContent) {
-        const instruction = buildPlanningTurn(n, ticketsContent);
+    async runPreflight(n, ticketsContent, preferredTicketId) {
+        const instruction = buildPlanningTurn(n, ticketsContent, preferredTicketId);
         const result = await this.builder.sendTurn(instruction);
         this.log.write("preflight", {
             ticketsProvided: ticketsContent !== undefined,
@@ -346,10 +352,10 @@ export class Foreman {
      * Loops on qa_fail → fix → re-QA until qa_pass or the cycle cap is reached.
      * QA turns are free — they do not advance the step counter.
      */
-    async runQa(stepIndex) {
+    async runQa(stepIndex, ticketId) {
         if (this.projectDir && this.qaFactory) {
             const review = await runIsolatedQa({
-                ticket: this.ticketForQa(stepIndex),
+                ticket: this.ticketForQa(stepIndex, ticketId),
                 builderWorktree: this.projectDir,
                 builderSummary: `Builder completed step ${stepIndex}`,
                 qaStrategy: this.qaSessionStrategy,
@@ -439,10 +445,12 @@ export class Foreman {
     builderSessionId() { return this.builder.sessionId(); }
     builderAdapter() { return this.builder; }
     async close() { await this.builder.close(); }
-    ticketForQa(stepIndex) {
+    ticketForQa(stepIndex, ticketId) {
         if (this.projectDir && this.ticketsEnabled) {
             const config = loadTicketsConfig(this.projectDir);
-            const active = cmdImplementationQueue(this.projectDir).find((row) => row.status === "next" || row.status === "in_progress");
+            const active = ticketId
+                ? { ticket: ticketId }
+                : cmdImplementationQueue(this.projectDir).find((row) => row.status === "next" || row.status === "in_progress");
             const ticket = loadTickets(join(this.projectDir, config.paths.tickets)).find((candidate) => candidate.id === active?.ticket);
             if (ticket)
                 return ticket;
@@ -453,7 +461,7 @@ export class Foreman {
             acceptance: ["The requested implementation step is complete"], required_tests: ["Run the relevant project validation"], likely_files: [],
         };
     }
-    async runBatch(n, trackerPath) {
+    async runBatch(n, trackerPath, onTicketStart, preferredTicketId) {
         this.log.write("batch-start", { requested: n, agent: this.builder.agent });
         let completed = 0;
         let outcome = "all-done";
@@ -464,9 +472,22 @@ export class Foreman {
             if (this.ticketsEnabled && this.projectDir) {
                 try {
                     const queue = cmdImplementationQueue(this.projectDir);
-                    const next = queue.find((r) => r.status === "next");
+                    const next = i === 1 && preferredTicketId
+                        ? queue.find((row) => row.ticket === preferredTicketId)
+                        : queue.find((row) => row.status === "next");
+                    if (i === 1 && preferredTicketId && !next) {
+                        outcome = "needs-human";
+                        detail = `recovery ticket ${preferredTicketId} is no longer available in the implementation queue`;
+                        break;
+                    }
+                    if (i === 1 && preferredTicketId && next && next.status !== "next" && next.status !== "in_progress") {
+                        outcome = "needs-human";
+                        detail = `recovery ticket ${preferredTicketId} cannot resume while its status is ${next.status}`;
+                        break;
+                    }
                     if (next) {
                         pendingTicketId = next.ticket;
+                        await onTicketStart?.(next.ticket);
                         cmdUpdate(this.projectDir, next.ticket, {
                             status: "in_progress",
                             actor: "foreman",
@@ -481,7 +502,7 @@ export class Foreman {
                 }
             }
             const instruction = i === 1
-                ? buildPrimer(n, trackerPath, this.ticketsEnabled)
+                ? buildPrimer(n, trackerPath, this.ticketsEnabled, preferredTicketId)
                 : buildNextStepInstruction(i, n);
             if (i > 1)
                 await this.prepareBuilderBoundary();
@@ -506,7 +527,7 @@ export class Foreman {
                 let qaSummary;
                 let qaWaived = false;
                 if (this.qaEnabled) {
-                    const qa = await this.runQa(i);
+                    const qa = await this.runQa(i, status.ticket ?? pendingTicketId);
                     if (qa.outcome === "blocked") {
                         outcome = "blocked";
                         detail = qa.detail;

package/dist/qaReview.d.ts

@@ -45,6 +45,7 @@ export interface IsolatedQaResult {
     summary?: string;
 }
 export declare function runIsolatedQa(opts: IsolatedQaOptions): Promise<IsolatedQaResult>;
+export declare function buildQaReviewHandoff(ticket: TicketDef, builderSummary: string, diffDigest: string, validationChecklist: string[]): string;
 export declare function compactWithRetry(adapter: BuilderAdapter): Promise<{
     ok: boolean;
     error?: string;

package/dist/qaReview.js

@@ -1,6 +1,7 @@
 import { currentActivity, withActivityPhase } from "./activity.js";
 import { buildQaFixInstruction, buildQaInstruction, parseStepStatus } from "./foreman.js";
 import { createDisposableQaSnapshotAsync } from "./qaSnapshot.js";
+import { loadTicketSetupConfigWithDefaults } from "./tickets/setupConfig.js";
 export async function runIsolatedQa(opts) {
     const history = [];
     for (let cycle = 1; cycle <= opts.maxCycles; cycle++) {
@@ -51,12 +52,7 @@ async function oneReview(opts, cycle) {
                 opts.state.sessionId = undefined;
             }
         }
-        const handoff = [
-            buildQaInstruction(), "", "QA handoff:", `Ticket: ${opts.ticket.id} — ${opts.ticket.title}`,
-            `Acceptance: ${opts.ticket.acceptance.join("; ")}`, `Builder summary: ${opts.builderSummary}`,
-            `Changed files/diff digest: ${snapshot.manifest.diffDigest}`, `Required tests: ${opts.ticket.required_tests.join("; ")}`,
-            "Do not change source, configuration, documentation, tickets, or control files. Only ignored cache, coverage, and build output is allowed.",
-        ].join("\n");
+        const handoff = buildQaReviewHandoff(opts.ticket, opts.builderSummary, snapshot.manifest.diffDigest, loadTicketSetupConfigWithDefaults(opts.builderWorktree).build.validation_checklist);
         const turn = await qa.sendTurn(handoff);
         const status = parseStepStatus(turn.text);
         opts.state.reviews += 1;
@@ -89,6 +85,15 @@ async function oneReview(opts, cycle) {
         await withActivityPhase("cleaning up disposable QA snapshot", () => snapshot.remove());
     }
 }
+export function buildQaReviewHandoff(ticket, builderSummary, diffDigest, validationChecklist) {
+    return [
+        buildQaInstruction(), "", "QA handoff:", `Ticket: ${ticket.id} — ${ticket.title}`,
+        `Acceptance: ${ticket.acceptance.join("; ")}`, `Builder summary: ${builderSummary}`,
+        `Changed files/diff digest: ${diffDigest}`, `Required tests: ${ticket.required_tests.join("; ")}`,
+        `Project validation checklist: ${validationChecklist.join("; ")}`,
+        "Do not change source, configuration, documentation, tickets, or control files. Only ignored cache, coverage, and build output is allowed.",
+    ].join("\n");
+}
 export async function compactWithRetry(adapter) {
     if (!adapter.compact)
         return { ok: false, error: "native compaction unavailable" };

package/dist/tickets/details.d.ts

@@ -0,0 +1,17 @@
+import { type DeliveryStack, type DeliveryUnit } from "./delivery.js";
+import { type TicketEvent, type TicketState, type ValidationSnapshot } from "./stateDb.js";
+import type { TicketDef } from "./ticketSchema.js";
+export interface TicketDeliveryDetails {
+    units: DeliveryUnit[];
+    stacks: DeliveryStack[];
+}
+export interface TicketDetails {
+    definition: TicketDef & Record<string, unknown>;
+    state: TicketState;
+    effective_blockers: string[];
+    validation_history: ValidationSnapshot[];
+    events: TicketEvent[];
+    delivery: TicketDeliveryDetails;
+}
+export declare function getTicketDetails(projectDir: string, ticketId: string, now?: Date): TicketDetails;
+export declare function formatTicketDetails(details: TicketDetails): string[];

package/dist/tickets/details.js

@@ -0,0 +1,94 @@
+import { existsSync } from "node:fs";
+import { loadTicketsConfig, resolveTicketPaths } from "./config.js";
+import { loadDeliveryConfig } from "./delivery.js";
+import { resolveBlockers } from "./blockers.js";
+import { StateDb, pristineTicketState } from "./stateDb.js";
+import { loadTickets } from "./ticketLoader.js";
+export function getTicketDetails(projectDir, ticketId, 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 tickets = loadTickets(paths.tickets);
+    const definition = tickets.find((ticket) => ticket.id === ticketId);
+    if (!definition)
+        throw new Error(`Ticket ${ticketId} not found. Run \`rafi tickets queue\` to list tickets.`);
+    const db = new StateDb(paths.stateDb);
+    try {
+        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 },
+        };
+    }
+    finally {
+        db.close();
+    }
+}
+export function formatTicketDetails(details) {
+    const lines = [`${details.definition.id}: ${details.definition.title}`, "", "Canonical ticket"];
+    const preferred = [
+        "id", "order", "title", "area", "priority", "size", "risk", "summary", "depends_on",
+        "acceptance", "required_tests", "likely_files", "rollback", "notes", "external_refs",
+        "source_refs", "plan_ref", "supersedes", "superseded_by",
+    ];
+    const keys = [...preferred.filter((key) => key in details.definition), ...Object.keys(details.definition).filter((key) => !preferred.includes(key)).sort()];
+    for (const key of keys)
+        lines.push(...formatField(key, details.definition[key]));
+    lines.push("", "Active state");
+    for (const [key, value] of Object.entries(details.state))
+        lines.push(...formatField(key, parseJsonField(key, value)));
+    lines.push(...formatField("effective_blockers", details.effective_blockers));
+    lines.push("", "Active validation and evidence");
+    lines.push(...formatField("validation_result", details.state.validation_result));
+    lines.push(...formatField("validation_commands", details.state.validation_commands));
+    lines.push(...formatField("validation_notes", details.state.validation_notes));
+    lines.push(...formatField("evidence", details.state.evidence));
+    lines.push("", "Historical validation");
+    lines.push(...formatRecords(details.validation_history));
+    lines.push("", "Delivery");
+    lines.push(...formatField("units", details.delivery.units));
+    lines.push(...formatField("stacks", details.delivery.stacks));
+    lines.push("", "History");
+    lines.push(...formatRecords(details.events));
+    return lines;
+}
+function formatField(label, value) {
+    if (Array.isArray(value)) {
+        if (value.length === 0)
+            return [`${label}: (none)`];
+        if (value.every((item) => typeof item !== "object" || item === null)) {
+            return [`${label}:`, ...value.map((item) => `  - ${String(item)}`)];
+        }
+        return [`${label}:`, ...JSON.stringify(value, null, 2).split("\n").map((line) => `  ${line}`)];
+    }
+    if (value && typeof value === "object") {
+        return [`${label}:`, ...JSON.stringify(value, null, 2).split("\n").map((line) => `  ${line}`)];
+    }
+    const rendered = value === undefined || value === null || value === "" ? "(none)" : String(value);
+    if (!rendered.includes("\n"))
+        return [`${label}: ${rendered}`];
+    return [`${label}:`, ...rendered.split("\n").map((line) => `  ${line}`)];
+}
+function formatRecords(records) {
+    return records.length ? JSON.stringify(records, null, 2).split("\n").map((line) => `  ${line}`) : ["  (none)"];
+}
+function parseJsonField(key, value) {
+    if (key !== "blocked_by_json" || typeof value !== "string")
+        return value;
+    try {
+        return JSON.parse(value);
+    }
+    catch {
+        return value;
+    }
+}

package/dist/tickets/eligibility.d.ts

@@ -0,0 +1,28 @@
+import type { DeliveryConfig } from "./delivery.js";
+import type { TicketDef } from "./ticketSchema.js";
+import type { TicketState } from "./stateDb.js";
+export type TicketIneligibilityCode = "missing" | "terminal" | "outside-window" | "dependencies" | "explicit-blocker" | "delivery-constraint" | "active-lease" | "resumable-owner";
+export interface TicketEligibility {
+    ticket?: TicketDef;
+    eligible: boolean;
+    recommended: boolean;
+    blockers: Array<{
+        code: TicketIneligibilityCode;
+        detail: string;
+        tickets?: string[];
+    }>;
+    eligibleDependencies: TicketDef[];
+}
+export interface EligibilityContext {
+    tickets: TicketDef[];
+    states: Map<string, TicketState>;
+    implementationLimit: number;
+    delivery?: DeliveryConfig;
+    activeLease?: {
+        runId: string;
+    };
+    allowOwnedResume?: boolean;
+}
+export declare function evaluateTicketEligibility(context: EligibilityContext, ticketId: string): TicketEligibility;
+export declare function eligibleTickets(context: EligibilityContext): TicketDef[];
+export declare function implementationWindow(tickets: TicketDef[], states: Map<string, TicketState>, limit: number): TicketDef[];

package/dist/tickets/eligibility.js

@@ -0,0 +1,71 @@
+import { resolveBlockers } from "./blockers.js";
+export function evaluateTicketEligibility(context, ticketId) {
+    const ticket = context.tickets.find((candidate) => candidate.id === ticketId);
+    if (!ticket)
+        return { eligible: false, recommended: false, blockers: [{ code: "missing", detail: `ticket ${ticketId} does not exist` }], eligibleDependencies: [] };
+    const state = context.states.get(ticket.id);
+    const blockers = [];
+    if (["done", "canceled", "obsolete"].includes(state?.status ?? "planned"))
+        blockers.push({ code: "terminal", detail: `ticket is ${state?.status}` });
+    const window = implementationWindow(context.tickets, context.states, context.implementationLimit);
+    if (!window.some((candidate) => candidate.id === ticket.id))
+        blockers.push({ code: "outside-window", detail: `ticket is outside the ${context.implementationLimit}-ticket implementation window` });
+    const unfinishedDependencies = ticket.depends_on.filter((id) => context.states.get(id)?.status !== "done");
+    if (unfinishedDependencies.length)
+        blockers.push({ code: "dependencies", detail: `unfinished dependencies: ${unfinishedDependencies.join(", ")}`, tickets: unfinishedDependencies });
+    const explicit = resolveBlockers(ticket, context.states).filter((id) => !unfinishedDependencies.includes(id));
+    if (explicit.length)
+        blockers.push({ code: "explicit-blocker", detail: `explicit blockers: ${explicit.join(", ")}`, tickets: explicit });
+    const deliveryReason = deliveryConstraint(ticket.id, context.delivery, context.states);
+    if (deliveryReason)
+        blockers.push({ code: "delivery-constraint", detail: deliveryReason });
+    if (context.activeLease)
+        blockers.push({ code: "active-lease", detail: `project has an active workflow lease for run ${context.activeLease.runId}` });
+    if (!context.allowOwnedResume && (state?.status === "in_progress" || state?.owner))
+        blockers.push({ code: "resumable-owner", detail: `ticket has resumable ownership${state.owner ? ` by ${state.owner}` : ""}` });
+    const eligibleDependencies = unfinishedDependencies
+        .map((id) => context.tickets.find((candidate) => candidate.id === id))
+        .filter((candidate) => Boolean(candidate))
+        .filter((candidate) => evaluateTicketEligibility({ ...context, activeLease: undefined }, candidate.id).eligible)
+        .sort(ticketOrder);
+    const ranked = eligibleTickets({ ...context, activeLease: undefined });
+    return { ticket, eligible: blockers.length === 0, recommended: ranked[0]?.id === ticket.id, blockers, eligibleDependencies };
+}
+export function eligibleTickets(context) {
+    return implementationWindow(context.tickets, context.states, context.implementationLimit)
+        .filter((ticket) => {
+        const state = context.states.get(ticket.id);
+        if (["done", "canceled", "obsolete", "in_progress"].includes(state?.status ?? "planned") || state?.owner)
+            return false;
+        if (resolveBlockers(ticket, context.states).length)
+            return false;
+        return !deliveryConstraint(ticket.id, context.delivery, context.states);
+    })
+        .sort(ticketOrder);
+}
+export function implementationWindow(tickets, states, limit) {
+    return tickets.filter((ticket) => !["done", "canceled", "obsolete"].includes(states.get(ticket.id)?.status ?? "planned")).sort(ticketOrder).slice(0, limit);
+}
+function ticketOrder(a, b) {
+    return a.order - b.order || a.id.localeCompare(b.id);
+}
+function deliveryConstraint(ticketId, delivery, states) {
+    if (!delivery)
+        return undefined;
+    const unit = delivery.units.find((candidate) => candidate.tickets.includes(ticketId));
+    if (!unit)
+        return undefined;
+    const stack = delivery.stacks?.find((candidate) => candidate.units.includes(unit.id));
+    if (!stack)
+        return undefined;
+    const firstUnfinishedUnit = stack.units.find((unitId) => {
+        const candidate = delivery.units.find((item) => item.id === unitId);
+        return candidate?.tickets.some((id) => !["done", "canceled", "obsolete"].includes(states.get(id)?.status ?? "planned"));
+    });
+    if (firstUnfinishedUnit && firstUnfinishedUnit !== unit.id)
+        return `delivery stack ${stack.id} must continue with unit ${firstUnfinishedUnit}`;
+    const firstUnfinishedTicket = unit.tickets.find((id) => !["done", "canceled", "obsolete"].includes(states.get(id)?.status ?? "planned"));
+    if (firstUnfinishedTicket && firstUnfinishedTicket !== ticketId && unit.dependency_mode === "stack")
+        return `delivery unit ${unit.id} must continue with ${firstUnfinishedTicket}`;
+    return undefined;
+}

package/dist/tickets/reset.d.ts

@@ -0,0 +1,27 @@
+import { type TicketStatus } from "./stateDb.js";
+export type TicketResetScope = "all" | "completed-and-unfinished" | "unfinished";
+export interface TicketResetPreviewRow {
+    id: string;
+    title: string;
+    status: TicketStatus;
+    cleared: string[];
+}
+export interface TicketResetPreview {
+    scope: TicketResetScope | "single" | "run";
+    tickets: TicketResetPreviewRow[];
+    relatedRuns: Array<{
+        runId: string;
+        status: string;
+        tickets: string[];
+    }>;
+}
+export declare function previewTicketReset(projectDir: string, target: string | TicketResetScope | string[]): TicketResetPreview;
+export declare function resetTickets(projectDir: string, target: string | TicketResetScope | string[], actor?: string, now?: Date, hooks?: {
+    beforePublish?: () => void;
+    resetId?: string;
+}): {
+    resetId: string;
+    tickets: string[];
+};
+/** Finish or roll back a reset publication left incomplete by process interruption. */
+export declare function recoverTicketResetPublications(projectDir: string): string[];