toolroll 0.9.51 → 0.9.53

package/dist/chat-actions.js

@@ -23,7 +23,7 @@ import { addCardToFlow, advanceFlows, cancelFlowCard, crossProjectProblem, decid
 import { chooseFlowCard, flowPersonOf } from "./flow-send.js";
 import { assignFlowCard, commentOnFlowCard, flowPeople, mentionsIn, watchFlowCard } from "./flow-people.js";
 import { addFlowTriggerTo, describeTrigger, readLinearKey, removeFlowTrigger, scheduleFromWords, takesDeliveries, triggerConfigOf, validateTriggerConfig } from "./flow-triggers.js";
-import { describeSchedule, parseSchedule } from "./routine.js";
+import { describeSchedule, parseSchedule } from "./flow-schedule.js";
 import { dirname } from "node:path";
 import { handleOf, parseSoul, SOUL_CHARS, TEAMMATE_TEMPLATES, teammateLabel } from "./teammates.js";
 import { createTeammateFrom, labelOf, nameOf, renamedSoul, saveSoul, setTeammateState } from "./teammate-admin.js";
@@ -825,8 +825,6 @@ export function prepareSharedAction(store, who, operation, input, root, now = ne
         const ref = store.lookupRef(task), row = store.getTask(task), family = store.taskFamilyOf(task, who.repos, false);
         if (!row || !family || family.problem || family.current.id !== task)
             throw Error("Choose the current task.");
-        if (store.openContestFor(ref.id) !== null)
-            throw Error("Wait for the agent comparison to finish.");
         const scope = store.getScope(task);
         state = {
             task,
@@ -847,19 +845,13 @@ export function prepareSharedAction(store, who, operation, input, root, now = ne
             if (!authority.ok)
                 throw Error(authority.problem);
             state["authMode"] = authority.authMode;
-            const race = store.activeTournamentTerms(ref.id);
-            state["race"] = race;
             terms.push(...describeScope(scope)
                 .filter((line) => !/^\s*(reference|approved)\s/.test(line))
                 .map((line) => line
                 .trimStart()
                 .replace(/^goal\s+/, "Work: ")
                 .replace(/^not this\s+/, "Excluded: ")
-                .replace(/^touches\s+/, "Allowed files: ")), ...(authority.chain ?? [
-                { profile: authority.profile, authMode: authority.authMode },
-            ]).map((entry, index) => `${index === 0 ? "Agent permissions and limits" : "Fallback " + index}\n${runtimeTerms(entry.profile)}\n${entry.authMode === "api-key" ? "Uses your API key; spend is charged to that account." : entry.authMode === "subscription" ? "Uses your subscription login." : ""}`));
-            if (race)
-                terms.push(`Agent comparison terms:\n${JSON.stringify(race, null, 2)}`);
+                .replace(/^touches\s+/, "Allowed files: ")), `Agent permissions and limits\n${runtimeTerms(authority.profile)}\n${authority.authMode === "api-key" ? "Uses your API key; spend is charged to that account." : authority.authMode === "subscription" ? "Uses your subscription login." : ""}`);
             const plan = store.latestPlanArtifact(ref.id), revision = ref.revisionBriefArtifact === null
                 ? null
                 : store.getArtifact(ref.revisionBriefArtifact);
@@ -1111,7 +1103,7 @@ export function executeSharedAction(store, who, id, payload, now, options) {
                         : { restore: Number(req["restore"]) }),
                 }, now);
             else if (payload.operation === "scope_approve") {
-                const scope = store.getScope(task), race = store.activeTournamentTerms(store.lookupRef(task).id);
+                const scope = store.getScope(task);
                 const result = approve(store, task, actor, now, scope.digest, options.review.password);
                 if (!result.ok) {
                     // v102: the project's approval rules speak for themselves.
@@ -1123,9 +1115,6 @@ export function executeSharedAction(store, who, id, payload, now, options) {
                         throw Error(result.message);
                     throw Error(`Approval refused: ${result.reason}.`);
                 }
-                if (race &&
-                    !store.approveTournamentTerms(race.id, actor, race.raceDigest, now))
-                    throw Error("The comparison terms changed. Nothing was approved.");
             }
             else if (payload.operation === "result_accept") {
                 // Accept and finish, as on the result page: whether a check only the person makes is accepted

package/dist/chat-controls.d.ts

@@ -42,10 +42,6 @@ export declare const CHAT_CONTROLS: {
         readonly label: "Open coding workspace";
         readonly href: "/code";
     };
-    readonly routines: {
-        readonly label: "Manage routines";
-        readonly href: "/routines";
-    };
     readonly flows: {
         readonly label: "Open flows";
         readonly href: "/flows";

package/dist/chat-controls.js

@@ -12,7 +12,6 @@ export const CHAT_CONTROLS = {
     publish: { label: "Review publication", target: "task" },
     projects: { label: "Manage projects", href: "/projects" },
     code: { label: "Open coding workspace", href: "/code" },
-    routines: { label: "Manage routines", href: "/routines" },
     flows: { label: "Open flows", href: "/flows" },
     recipes: { label: "Browse workflows", href: "/recipes" },
     workers: { label: "Manage workers", href: "/fleet" },

package/dist/chat-decide.js

@@ -104,11 +104,9 @@ export function planInChat(store, taskId, approver, now, root) {
     const family = store.taskFamilyOf(taskId, [ref.repo], false);
     if (family === null || family.problem !== null || family.current.id !== taskId)
         return { ok: false, why: "A newer version of this task is current." };
-    // What the mode's seal refuses anyway, said first: model- or coordinator-written terms, a race, an unreadable route.
+    // What the mode's seal refuses anyway, said first: model- or coordinator-written terms, an unreadable route.
     if (ref.coordinatorCid !== null || (scope.proposedVia ?? null) !== null)
         return { ok: false, why: "This plan was written for you, so you approve it in Toolroll." };
-    if (store.activeTournamentTerms(ref.id) !== null)
-        return { ok: false, why: "Agents compete on this task, so you approve it in Toolroll." };
     if (scope.profileState === "unresolved" || scope.routeEra == null || (scope.termsProblem ?? null) !== null)
         return { ok: false, why: "This plan can't say exactly which agents run, so you approve it in Toolroll." };
     const yours = mode.source === "setting" ? "your chat approval setting" : "your mode";

package/dist/chat-delivery.d.ts

@@ -1,5 +1,4 @@
 import { type WarmHooks } from "./chat-warmth.js";
-import { type DoorOptions } from "./mate-doors.js";
 import { ChatState, type ChatBinding, type ChatEvent, type ChatIdentity } from "./chat-delivery-state.js";
 import { type Store } from "./store.js";
 import type { SubscriptionMateRunner } from "./subscription-chat.js";
@@ -16,7 +15,6 @@ export type ChatDeliveryOptions = {
     current: () => boolean;
     origin: () => string | null;
     subscriptionRunner?: SubscriptionMateRunner;
-    held?: DoorOptions["held"];
     canNotify?: () => boolean;
     clock?: () => Date;
     partSize?: number;

package/dist/chat-delivery.js

@@ -547,7 +547,6 @@ export function applyChatAction(options, event, binding, repos) {
                 via: options.state.channel,
                 evidenceRoot: options.evidenceRoot,
                 confirm: phase === "yes",
-                ...(options.held ? { held: options.held } : {}),
                 deferSignal: (signal) => signals.push(signal),
             });
             if (!outcome.ok && outcome.reason === "needs-confirm") {

package/dist/chat-quiet.js

@@ -36,9 +36,9 @@ export function needsPerson(row) {
 export function isTaskFact(row) {
     return row.taskRef !== null && row.taskId !== null && row.project !== null;
 }
-/** The attempt a task's card follows: its newest builder attempt, outside any contest. */
+/** The attempt a task's card follows: its newest builder attempt. */
 function cardRun(store, taskRef) {
-    return store.runsFor(taskRef).find(run => run.role === "builder" && run.contestant === null) ?? null;
+    return store.runsFor(taskRef).find(run => run.role === "builder") ?? null;
 }
 /** Before any attempt starts, the card says where the task stands in the words of its last lifecycle fact. */
 const before = (headline) => ({ icon: headlineEmoji(headline), status: headline });

package/dist/chat-task-actions.d.ts

@@ -44,7 +44,7 @@ export declare function isChatTaskAction(value: unknown): value is keyof typeof
 export declare function chatTaskStamp(store: Store, who: VerifiedApprover, task: string): string | null;
 /** Only current, eligible controls can become cards; retain the exact run the reader saw. */
 export declare function chatTaskRun(store: Store, task: string, operation: "stop" | "resume", now: Date): number | null;
-export declare function applyChatTaskAction(store: Store, who: VerifiedApprover, payload: Record<string, unknown>, now: Date, web: boolean, controls?: Pick<StopRequest, "held" | "deferSignal"> & {
+export declare function applyChatTaskAction(store: Store, who: VerifiedApprover, payload: Record<string, unknown>, now: Date, web: boolean, controls?: Pick<StopRequest, "deferSignal"> & {
     via?: StopRequest["via"];
     evidenceRoot?: string;
 }): {

package/dist/chat-task-actions.js

@@ -46,8 +46,6 @@ export function applyChatTaskAction(store, who, payload, now, web, controls = {}
     if (stamp === null || stamp !== payload["stamp"])
         return { ok: false, message: "This task changed. Review it again before confirming." };
     const ref = store.lookupRef(task);
-    if (store.openContestFor(ref.id) !== null)
-        return { ok: false, message: "Wait for the agent comparison to finish." };
     if (operation === "stop" || operation === "resume") {
         if (store.isDemo())
             return { ok: false, message: "The demo authorizes nothing." };

package/dist/claim.d.ts

@@ -63,21 +63,6 @@ export type AcquireResult = {
     reason: "external";
     detail: "stale-mirror" | "external-closed" | "dispatch-revoked" | "plane-blocked";
 }
-/** An attended authorization holds this task for its named runner (v25).
- * Its OWN reason token — never the `reserved` tag, whose reservedFor field
- * is a documented public contract meaning task_ref.assigned_runner. */
- | {
-    ok: false;
-    reason: "attended-held";
-    runner: string;
-}
-/** The task's only authority is an attended authorization, and the
- * operator is not watching (or the one attempt is spent). Expiry never
- * converts attended work into unattended work. */
- | {
-    ok: false;
-    reason: "attended-only";
-}
 /** A mode-sealed approval whose signature no longer stands (v29): the
  * approval falls back to a person; nothing dispatches on a dead mode. */
  | {
@@ -209,26 +194,6 @@ export declare function acquireIfReady(store: Store, taskRef: number, runner: st
      * caller's survey is not trusted (Codex planning review, finding 2). */
     dispatchRole?: "builder" | "planner" | "scout";
 }): AcquireResult | NotReady;
-/**
- * The FALLBACK-ADMISSION claim (E3d, review finding 4): the one gate a
- * pending-admission chain cycle dispatches through. It enforces everything
- * `acquireIfReady` enforces — task state, holds, blockers, the approved
- * scope + live-mode belt, capability, capacity, and quota — with EXACTLY
- * ONE deliberate difference: a BACKOFF hold does not gate, because the
- * pending admission IS the system's answer to the predecessor's failure
- * (waiting out the exhausted entry's backoff to run a different credential
- * would be waiting for nothing). Quota is keyed by the PINNED entry's
- * provider, model, and auth mode — the credential that would actually
- * spend — so an exhausted fallback credential refuses here, before any
- * claim exists.
- */
-export declare function acquireFallback(store: Store, taskRef: number, runner: string, options: AcquireOptions & {
-    repo?: string;
-    provider: string;
-    model: string;
-    authMode: "subscription" | "api-key";
-    maxOpenDecisions?: number;
-}): AcquireResult | NotReady;
 /**
  * "I am still here." Extends the lease, and tells a superseded runner that it
  * has been superseded — which is the cheapest moment for it to find out, well
@@ -246,73 +211,67 @@ export declare function heartbeat(store: Store, leaseId: string, now: Date, ttlM
  */
 export declare function release(store: Store, leaseId: string, now: Date): FenceResult;
 /**
- * Release the lease and write the task's terminal state, as one step.
- *
- * Release-then-mark is a window: between the two, the freed task is back in
- * the ready set, and another pass can claim it before the terminal state
- * lands — two builders for one task, the second dispatched by our own
- * bookkeeping. Here the state is written inside the same transaction as the
- * fenced release, so a task is never simultaneously free and unfinished.
- *
- * A fenced or unknown lease writes nothing: a runner the world moved past
- * does not get to say how the task ended. A duplicate release reports
- * `duplicate` and also writes nothing — the first completion already said,
- * and a retry changing the answer would make "done" negotiable.
- */
-export declare function completeFenced(store: Store, leaseId: string, state: Extract<TaskState, "done" | "failed">, now: Date, mutation?: Mutation): CompleteResult;
-/**
- * Seal a park, fenced at the write (§7).
- *
- * The builder proved its lease after the agent ran; this transaction proves
- * it again *in the same statement that releases it*, because everything a
- * park creates — the decision, its hold, the outbox row — is only true if
- * this lease still spoke for the task at the moment of sealing. A superseded
- * lease creates none of it: no decision, no hold, no notification, and the
- * run is finalized as the fenced refusal it was. A crash anywhere inside
- * rolls all of it back together; there is no instant at which a decision
- * exists without its hold.
- *
- * `released_by = 'parked'` so a late retry from this lease is answered with
- * the fence, not "duplicate": a park hands the task to a person, and nothing
- * the runner says afterwards is that person's answer.
- */
-/**
- * Continuation admission (Phase 2E, A4 / v3 R7): the AUTHORIZATION is the
- * claimable unit — the finished parent task is never re-queued, its state,
- * strikes, holds, and dependents untouched. Every shared gate still runs
- * (acquireLocked: reservation, external mirror, the attended gates, the
- * lease CAS); the queued-state readiness gate alone is replaced by
- * construction. Liveness, the named runner, and the unspent attempt are
- * re-proved HERE at claim time and again at the final dispatch proof.
+ * How an attempt ended, one kind per ending, each with the facts its seal needs. `finalize` seals every one.
  */
-export declare function acquireContinuation(store: Store, authorization: import("./store.js").AttendedAuthorization, runner: string, options: AcquireOptions): AcquireResult | {
-    ok: false;
-    reason: "attended-only" | "contest-open" | "continuation-blocked";
-    message: string;
+export type Outcome = 
+/** The task's terminal state, written with the release (no run: the lease's own completion). */
+({
+    kind: "complete";
+} & CompleteSeal) | ({
+    kind: "park";
+} & ParkSeal) | ({
+    kind: "malformed";
+} & MalformedSeal) | ({
+    kind: "interrupted";
+} & InterruptedSeal) | ({
+    kind: "hand-back";
+} & HandBackSeal) | ({
+    kind: "failure";
+} & FailureSeal) | ({
+    kind: "plan";
+} & PlanSeal) | ({
+    kind: "revision";
+} & RevisionSeal) | ({
+    kind: "plan-failure";
+} & PlanFailureSeal) | ({
+    kind: "scout";
+} & ScoutSeal) | ({
+    kind: "scout-failure";
+} & ScoutFailureSeal);
+/** What sealing each kind answers. */
+export type Finalized = {
+    complete: CompleteResult;
+    park: ParkFinalize;
+    malformed: MalformedFinalize;
+    interrupted: InterruptSeal;
+    "hand-back": HandBackFinalize;
+    failure: FailureDisposition;
+    plan: PlanFinalize;
+    revision: RevisionFinalize;
+    "plan-failure": PlanFailureDisposition;
+    scout: ScoutFinalize;
+    "scout-failure": ScoutFailureDisposition;
 };
 /**
- * The HELD park (Phase 2E, v2 S1f): the decision is recorded, paged, and
- * causally linked to the session turn that produced it — and NOTHING else
- * ends. The lease stays; the run stays open; the process stays held. The
- * conversation continues when the answer is injected as the next turn.
- * The one-unresolved-per-run partial unique refuses a second open park.
+ * THE ONE WAY AN ATTEMPT ENDS: seal `outcome` for `leaseId` in one fenced transaction.
+ *
+ * Every ending passes the same fence, in the same order: the run is this lease's open attempt of the right role (a
+ * caller defect otherwise, thrown); a stop that applies to it wins — the attempt is sealed as interrupted instead
+ * (except the endings that ARE a stop or a service hand-back); then the claim is released by a compare-and-swap only the
+ * live, unsuperseded lease wins. A lease the world moved past writes nothing but its own run's fenced refusal (the
+ * stop and hand-back endings still end their run, touching no task state), and a retry of an ending the same lease
+ * already made answers as a duplicate where that ending allows it. Only then does the ending's own effect run —
+ * decision and hold, incident, strike and backoff, scope, report, revision, task state, the disowned mirror — inside
+ * the same transaction, so nothing of it exists without the release, and a crash rolls all of it back together.
  */
-export declare function finalizeParkHeld(store: Store, args: {
-    runId: number;
-    taskId: string;
-    decision: ParsedDecision;
-    artifactIds: readonly number[];
-    sessionTurn: number;
+export declare function finalize<O extends Outcome>(store: Store, leaseId: string, outcome: O): Finalized[O["kind"]];
+/** The task's terminal state, written with the release (no run: the lease's own completion). */
+export type CompleteSeal = {
+    state: Extract<TaskState, "done" | "failed">;
     now: Date;
-}): {
-    ok: true;
-    decisionId: number;
-} | {
-    ok: false;
-    reason: "decision-open" | "not-held";
+    mutation?: Mutation;
 };
-export declare function finalizeParkFenced(store: Store, args: {
-    leaseId: string;
+export type ParkSeal = {
     runId: number;
     taskId: string;
     decision: ParsedDecision;
@@ -321,28 +280,21 @@ export declare function finalizeParkFenced(store: Store, args: {
      * settled in this same fence, never earlier. */
     repairRunId?: number | null;
     now: Date;
-}): {
+};
+export type ParkFinalize = {
     ok: true;
     decisionId: number;
 } | {
     ok: false;
     reason: "fenced" | "unknown" | "stopped";
 };
-/**
- * Seal a park whose payload never became a decision (§6's bounded repair ran
- * out). Same fence, same atomicity, different record: an incident that stays
- * in every brief until a person resolves it, holding the task so the next
- * pass does not spend the same tokens hitting the same wall nightly. The
- * malformed payload is preserved as evidence — a person may still be able to
- * read what the agent meant.
- */
-export declare function finalizeMalformedFenced(store: Store, args: {
-    leaseId: string;
+export type MalformedSeal = {
     runId: number;
     taskId: string;
     problems: readonly Problem[];
     now: Date;
-}): {
+};
+export type MalformedFinalize = {
     ok: true;
     incidentId: number;
 } | {
@@ -387,48 +339,21 @@ export type InterruptSeal = {
     requeued: false;
     fenced: true;
 };
-/**
- * Seal an operator-stopped attempt (v52): ONE fenced transaction for the
- * claim's release as `interrupted`, the run's ending as `failed` /
- * `interrupted` (the same words dead-runner recovery writes, so the
- * recovered-draft road inherits the preserved work exactly as after a
- * crash), every open run the attempt owns, the task's return to the
- * queue under the stop's own hold, and the stop's settlement. Nothing
- * here is a failure: no strike, no backoff, no incident, no automatic
- * repair task, no notification page. A commit the attempt already made
- * is kept as a reviewable artifact — `committed` records that it exists.
- *
- * A lease the world moved past (reaped, recovered, superseded) still
- * ends the run as interrupted — that IS the honest ending — but touches
- * no task state: the task belongs to whoever holds it now.
- */
-export declare function finalizeInterruptedFenced(store: Store, args: {
-    leaseId: string;
+export type InterruptedSeal = {
     runId: number;
     taskId: string;
     stopRun: number;
     message?: string;
     committed?: boolean;
     now: Date;
-}): InterruptSeal;
-/**
- * Hand an attempt back because the SERVICE stopped (its builder is
- * stopping or restarting), not because anyone stopped the task: one fenced
- * transaction releases the claim as `interrupted`, ends the run (and every
- * open run it owns) as `failed` / `interrupted` — the words dead-runner
- * recovery writes, so the next attempt inherits the preserved work in the
- * same checkout exactly as after a crash — and returns the task to the
- * queue with no strike, no backoff and no hold, so the next builder pass
- * resumes it. A lease the world moved past still ends the run, touching no
- * task state.
- */
-export declare function finalizeHandBackFenced(store: Store, args: {
-    leaseId: string;
+};
+export type HandBackSeal = {
     runId: number;
     taskId: string;
     message: string;
     now: Date;
-}): {
+};
+export type HandBackFinalize = {
     ok: true;
     requeued: boolean;
     fenced: boolean;
@@ -449,30 +374,14 @@ export declare function interruptIfStopped(store: Store, args: {
     committed?: boolean;
     now: Date;
 }): InterruptSeal | null;
-/**
- * Seal a failed attempt: one fenced transaction for the release, the run,
- * the strike, the hold, and the page (§6, gnhf adopted rather than
- * reinvented).
- *
- * Strikes count only top-level builder attempts; built, no-change, and
- * parked reset them elsewhere; refusals, fenced attempts, and repair
- * children never reach this function. Under three strikes the task
- * requeues behind a doubling backoff hold the failure owns; at three it
- * stalls — an 'attempts-exhausted' incident, the task marked failed, held,
- * and paged once — because a fourth identical attempt at 3am is a token
- * bonfire, not persistence. A commit-stage failure takes neither road: the
- * worktree holds unpreserved work, ordinary re-pooling would refuse it as
- * dirty forever, so it is an immediate incident naming the checkout.
- */
-export declare function finalizeFailureFenced(store: Store, args: {
-    leaseId: string;
+export type FailureSeal = {
     runId: number;
     taskId: string;
     failureClass: FailureClass;
     message: string;
     worktree: string;
     now: Date;
-}): FailureDisposition;
+};
 /** The live claim on a task, if there is one. */
 export declare const MAX_PLAN_STRIKES = 3;
 export type PlanFinalize = {
@@ -492,16 +401,7 @@ export type PlanFinalize = {
     reason: "stale-source" | "source-invalid";
     detail: string;
 };
-/**
- * Seal a successful planning run: the proposed scope, the plan document
- * artifact, the drafted state, the run outcome, and the page to the
- * operator exist together or — if the lease was superseded — not at all.
- * The scope proposal is authority-bearing (it is what the approve card
- * will restate), which is why this is the park discipline, not the DONE
- * one (Codex planning review, question 2).
- */
-export declare function finalizePlanFenced(store: Store, args: {
-    leaseId: string;
+export type PlanSeal = {
     runId: number;
     taskId: string;
     plan: ParsedPlan;
@@ -529,7 +429,7 @@ export declare function finalizePlanFenced(store: Store, args: {
     /** Where the plan-contract ingestion record is written. */
     evidenceRoot?: string;
     now: Date;
-}): PlanFinalize;
+};
 export type RevisionFinalize = {
     ok: true;
     revisionId: number;
@@ -538,42 +438,7 @@ export type RevisionFinalize = {
     ok: false;
     reason: "fenced" | "unknown" | "stopped";
 };
-/**
- * Seal a running build's plan-revision proposal (adaptive execution plans).
- *
- * A builder that finds repository evidence invalidating a named dependency,
- * risk, or assumption in the plan it was given files ONE proposal and stops
- * without committing — the park discipline, applied to the road rather than
- * to a question. The ledger row, the hold when one is owed, the run's
- * outcome, and the page exist together or, if the lease was superseded,
- * not at all. Structurally `finalizePlanFenced`'s twin: the same
- * open-attempt assertion, the same fenced release, the same all-or-nothing
- * transaction.
- *
- * Two dispositions, decided by the caller's classification and recorded
- * here:
- *
- *   plan-only        the signed scope and publication authority are
- *                    byte-identical to what this build started under, so
- *                    nothing authority-bearing moved and the revision is
- *                    APPLIED. The claim releases plainly, the task returns
- *                    to the ready set, and the next attempt reads the new
- *                    plan — that is the "resume" the subject line promises.
- *
- *   authority-change something else moved the signed scope or the
- *                    publication authority WHILE this build ran. Whatever
- *                    the revision proposes, it is never auto-applied: the
- *                    row lands 'blocked', a `revision` hold keeps the task
- *                    out of every ready set until a person accepts or
- *                    rejects it, and the page names exactly which fields
- *                    changed.
- *
- * The lease is released either way — the attempt is over — and the run is
- * finished as `refused`, reusing the existing outcome vocabulary rather
- * than growing it: no work was committed, and nothing failed.
- */
-export declare function finalizeRevisionFenced(store: Store, args: {
-    leaseId: string;
+export type RevisionSeal = {
     runId: number;
     taskId: string;
     taskRef: number;
@@ -594,7 +459,7 @@ export declare function finalizeRevisionFenced(store: Store, args: {
         changedFields: readonly AuthorityChangeField[];
     };
     now: Date;
-}): RevisionFinalize;
+};
 export type PlanFailureDisposition = {
     ok: true;
     disposition: "malformed-incident";
@@ -616,44 +481,22 @@ export type PlanFailureDisposition = {
     ok: false;
     reason: "fenced" | "unknown" | "stopped";
 };
-/**
- * The planner's own fenced failure finalizer (Codex planning review,
- * finding 6): releases exactly the planner claim, finishes the run,
- * counts a SEPARATE planning strike — a planner that cannot finish must
- * never spend the builder's three attempts — and eventually leaves a
- * durable incident + hold + page. It never marks the task done, never
- * touches builder strikes, never commits, never publishes.
- *
- * A malformed payload goes straight to its incident with no strike: the
- * protocol failed, not the weather, and retrying the same session buys
- * nothing without the repair machinery (deliberately not wired for
- * planners in v1).
- */
-export declare function finalizePlanFailureFenced(store: Store, args: {
-    leaseId: string;
+export type PlanFailureSeal = {
     runId: number;
     taskId: string;
-    kind: "malformed" | "failure";
+    failure: "malformed" | "failure";
     /** Which payload was malformed (v4 review, finding 12): the mailbox is a `malformed-decision`. */
     malformed?: "decision" | "plan";
     message: string;
     now: Date;
-}): PlanFailureDisposition;
+};
 export type ScoutFinalize = {
     ok: true;
 } | {
     ok: false;
     reason: "fenced" | "unknown" | "stopped";
 };
-/**
- * Seal a successful scouting run (mate arc §10): the report artifact, the
- * run outcome, the task's terminal state, and the page to the operator
- * exist together or — if the lease was superseded — not at all. Nothing
- * here touches a branch, a publication, or a scope: the deliverable is
- * the artifact, and the task is done the moment it verifies.
- */
-export declare function finalizeScoutFenced(store: Store, args: {
-    leaseId: string;
+export type ScoutSeal = {
     runId: number;
     taskId: string;
     report: ParsedReport;
@@ -670,7 +513,7 @@ export declare function finalizeScoutFenced(store: Store, args: {
         redacted: boolean;
     };
     now: Date;
-}): ScoutFinalize;
+};
 export type ScoutFailureDisposition = {
     ok: true;
     disposition: "malformed-incident";
@@ -692,25 +535,17 @@ export type ScoutFailureDisposition = {
     ok: false;
     reason: "fenced" | "unknown" | "stopped";
 };
-/**
- * The scout's fenced failure finalizer: the BUILDER's discipline, not the
- * planner's — a scout task has no builder attempts, so its strikes are the
- * task's own (three stall it, `task requeue` clears them), and a malformed
- * report is a straight incident with no strike. Never a branch, never a
- * repair session, never a commit.
- */
-export declare function finalizeScoutFailureFenced(store: Store, args: {
-    leaseId: string;
+export type ScoutFailureSeal = {
     runId: number;
     taskId: string;
-    kind: "malformed" | "failure";
+    failure: "malformed" | "failure";
     /** Which payload was malformed (v4 review, finding 12): the park
      * mailbox is a `malformed-decision` incident, the handoff a
      * `malformed-report` one — the taxonomy says what actually broke. */
     malformed?: "decision" | "report";
     message: string;
     now: Date;
-}): ScoutFailureDisposition;
+};
 export declare function currentClaim(store: Store, taskRef: number, now: Date): Claim | null;
 /**
  * Release every lease that has run out.