@open-everywhere/core 0.1.0

package/dist/agent/routines/outcome-fold.js

@@ -0,0 +1,244 @@
+// FOLDING A RUN OUTCOME BACK ONTO THE ROUTINE — the one place that reads the routine,
+// settles the outcome, persists the fold, and writes the forensic rows. Extracted in
+// OPE-146 because there are now TWO ingresses for the same fact and they must not drift:
+//
+//   1. hooks/routine-outcome.ts — the fire's own TURN ended (eve turn.completed/turn.failed).
+//      Carries a session id, so it writes the `routine.fire` join row. It was `session.completed`/
+//      `session.failed` until OPE-611, which measured that eve emits `session.completed` for no
+//      session on this build. That hook latches per fire, so one fire reaches this function once
+//      however many turns it runs for.
+//   2. schedules/dispatch.ts — the fire's DELIVERY was REJECTED. No session ever started,
+//      so there is no session id and no `routine.fire` row (the dispatcher writes
+//      `routine.fire_lost` instead, which is the same fact told from the only end that
+//      knows it).
+//
+// THE DEFECT THIS CLOSES (audit §S3). Before OPE-146 the delivery-failure path was a bare
+// `.catch(log)` — later a `.catch(auditRoutineFireLost)`. Either way NO session started, so
+// the outcome hook never ran, so `consecutiveFailures` stayed 0 FOREVER. The three-strike
+// self-disable therefore only ever counted eve session crashes: a routine on an archived
+// channel, or one the bot was kicked from, retried on every tick indefinitely, consuming a
+// per-tick concurrency slot and leaving nothing but a log line. A rejected delivery is a
+// FAILED RUN by any reading — this makes the counter see it.
+//
+// It is also what makes `docs/capabilities/proactivity-and-routines.md`'s "removing it from
+// the surface ends it" TRUE, by the only mechanism the deployment actually has. There is no
+// membership enumerator anywhere in the tree (the never-wired `gcOrphaned` that used to sit
+// in lifecycle.ts asserted one and was deleted in the same ticket) — but a surface the agent
+// has been removed from rejects the delivery, and three rejections now disable the routine.
+//
+// Everything here is best-effort by CONTRACT for the audit legs (fire-audit.ts swallows its
+// own failures) but NOT for the store: a store error propagates so the caller can log it
+// with its own context, exactly as the hook did before the extraction.
+import { applyOutcome, settleOutcome } from "./lifecycle.js";
+import { boundExhaustedPatch } from "./bound.js";
+import { auditRoutineDisabled, auditRoutineFire, auditRoutineStalled } from "./fire-audit.js";
+import { announceBoundExhausted, announceSelfDisable } from "./disable-notice.js";
+import { stallFoldPatch } from "./stall.js";
+import { getRoutine, updateRoutine } from "./store.js";
+/**
+ * Fold one run's outcome onto its routine and persist it, writing the forensic rows.
+ *
+ * `sessionId` present ⇒ a real session ran ⇒ the `routine.fire` join row is written (it is
+ * the ONLY row that can carry both the routine id and the session id, which is what makes
+ * `GET /control/v1/session/:id/transcript` reachable from a routine id). Absent ⇒ no join
+ * row: there is genuinely no session, and the caller has already recorded the loss.
+ *
+ * `routine.disabled` is written on the TRANSITION only, from whichever ingress caused it —
+ * so a self-disable driven by repeated DELIVERY failures is as visible as one driven by
+ * repeated session failures.
+ */
+export async function foldRoutineOutcome(opts) {
+    const { marker, sessionOutcome } = opts;
+    const at = opts.at ?? new Date();
+    const routine = await getRoutine(marker.org, marker.surfaceKey, marker.id);
+    if (!routine)
+        return { folded: false }; // cancelled meanwhile
+    // A run can have recorded its OWN verdict mid-turn, and a clean session end must keep it rather
+    // than claim "ok": a watch that saw no change recorded `skipped` (record_watch_state), and since
+    // OPE-177 a turn whose work did not work recorded `failed` + a reason (report_run_failed). The
+    // dispatcher clears BOTH fields at fire, so anything present here was written during THIS run.
+    const settled = settleOutcome(sessionOutcome, routine.lastOutcome);
+    const updated = applyOutcome(routine, settled, at);
+    await updateRoutine(marker.org, marker.surfaceKey, marker.id, {
+        lastRunAt: updated.lastRunAt,
+        lastOutcome: updated.lastOutcome,
+        // Cleared by applyOutcome on any non-`failed` settlement — patched explicitly so the store
+        // actually drops it, rather than leaving a previous run's reason on the row.
+        lastFailureReason: updated.lastFailureReason,
+        consecutiveFailures: updated.consecutiveFailures,
+        // OPE-506: the streak's own start instant — cleared alongside consecutiveFailures on any
+        // non-failed settlement (applyOutcome), carried forward on every failure in between. Without
+        // patching it explicitly here it is computed and then silently discarded, and every fold after
+        // the first reads it back as absent — which applyOutcome's own back-compat fallback then reads
+        // as an ALREADY-SPANNED legacy streak, disabling on the bare 3-strike count regardless of how
+        // close together the failures actually were. Measured: this exact defect shipped in the first
+        // draft of this ticket and was caught by routine-reliability-test.ts §3 going red.
+        firstFailureAt: updated.firstFailureAt,
+        status: updated.status,
+        disabledReason: updated.disabledReason,
+        nextRunAt: updated.nextRunAt,
+        // THE STALL ARITHMETIC (OPE-253) — folded in the SAME write as the outcome, because it is the same
+        // question about the same fire ("what happened on this run?") and two writes could disagree.
+        //
+        // It rides HERE rather than in applyOutcome because a stall is NOT an outcome: the fire settles
+        // `ok` (a soft-blocked tool is a recoverable tool-error the model works around), and threading it
+        // through the outcome would either make a blocked fire read as failed — three-strike-disabling a
+        // job whose only problem is an unanswered card — or need a fourth RunOutcome that nothing else
+        // means. `{}` for a routine that never stalled, so its patch is byte-identical to before.
+        //
+        // OPE-625: a LATE fold skips it entirely — see the `late` option's own note. This fire's stall
+        // was counted by its first fold, and `lastStallAt` is still on the row because only the next
+        // fire clears it.
+        ...(opts.late === true ? {} : stallFoldPatch(routine)),
+    });
+    // The DECLARED reason (OPE-177), for the forensic rows below. Read off the settled routine so it
+    // is present exactly when the run actually settled as failed. It goes on the audit rows and
+    // NOWHERE else: `disabledReason` stays host-composed because announceSelfDisable posts it into
+    // the room past the silent-routine delivery gate (routines/disable-notice.ts), and model text has
+    // no business riding that path.
+    const declared = updated.lastFailureReason;
+    // Written AFTER the store update so the rows' counters match what a reader will then see
+    // on the row itself. fire-audit.ts swallows its own failures: an audit hiccup must never
+    // undo the fold above.
+    if (opts.sessionId !== undefined) {
+        await auditRoutineFire(routine, opts.sessionId, settled, {
+            consecutiveFailures: updated.consecutiveFailures,
+            ...(updated.disabledReason ? { disabledReason: updated.disabledReason } : {}),
+            // Positive-only (OPE-147): absent means "the clock", which is what every row before this
+            // ticket meant, so no reader has to be taught a new default.
+            ...(opts.manual === true ? { manual: true } : {}),
+            // OPE-177: absent means "nobody declared anything" — either the run was fine, or it failed at
+            // the session level, which is a different (and already legible) story. Present means the turn
+            // itself said the work did not happen, in its own words. This is the field that answers "why
+            // is this thing about to disable itself" from the fire rows, one run at a time.
+            ...(declared !== undefined ? { declaredFailure: declared } : {}),
+            // OPE-625: positive-only, like `manual`. Absent means "this fire's own settlement", which is
+            // what every row before this ticket meant. Present means a SECOND row for a fire whose first
+            // row already exists — so a reader counting fires subtracts it, and a reader asking "why did
+            // this routine disable after a clean run?" reads it as the answer.
+            ...(opts.late === true ? { late: true } : {}),
+        });
+    }
+    // OPE-506: a `once` routine goes terminal on EVERY outcome now (applyOutcome), not only on
+    // failure — a successful one-shot completing on schedule is not a self-disable, and must not
+    // post the 🛑 "disabled after N consecutive failures" notice or write a routine.disabled row
+    // that would misreport a clean run as a breakage. `settled === "failed"` is what a genuine
+    // self-disable (the recurring three-strike, or a once's first failure) always is, and what an
+    // ordinary once completion never is — so it is the second half of the transition test, not a
+    // narrowing of it: every pre-existing disable this fold could produce already satisfied it.
+    const disabled = updated.status === "disabled" && routine.status !== "disabled" && settled === "failed";
+    if (disabled) {
+        await auditRoutineDisabled(routine, updated.disabledReason ?? "auto-disabled", updated.consecutiveFailures, opts.sessionId, 
+        // OPE-177: the LAST run's declared reason on the row that says it stopped. `reason` above only
+        // ever says "it hit the threshold"; this is the nearest thing to a diagnosis the mechanism can
+        // honestly produce, and it is the field an operator reads before deciding to `enable_routine`.
+        declared !== undefined ? { declaredFailure: declared } : {});
+        // ANNOUNCE IT (OPE-149, visibility leg 3). The audit row above is durable but PASSIVE — it only
+        // answers a question someone thought to ask. A routine stopping itself is a state change with
+        // lasting consequence taken with no human present, and for a SILENT routine it is unobservable
+        // from the room by construction (its healthy state is also "you hear nothing").
+        //
+        // It lives HERE rather than in the session-end hook (where OPE-149 first put it) because the
+        // fold has two ingresses. The delivery-rejected path never starts a session, so a hook-side
+        // announcement could not reach the case that needs it MOST: three rejected deliveries is
+        // precisely the archived-channel / kicked-bot story, where nobody has seen anything at all.
+        // Fail-soft inside, and after the row: a surface that can't be posted into never costs us the
+        // fold or the row. See routines/disable-notice.ts.
+        await announceSelfDisable(routine, updated.disabledReason ?? "auto-disabled", updated.consecutiveFailures);
+    }
+    return { folded: true, outcome: settled, consecutiveFailures: updated.consecutiveFailures, disabled };
+}
+/**
+ * RETIRE A ROUTINE THAT HIT ITS CEILING (OPE-248) — the SECOND reason a routine stops itself, and
+ * the reason it lives in this file rather than beside the pure verdict in routines/bound.ts.
+ *
+ * Stopping a routine is three acts that must always happen together: persist the terminal status,
+ * write the `routine.disabled` forensic row, and POST the host-composed notice. `foldRoutineOutcome`
+ * above already does exactly those three for the three-strike case, and the one thing worse than
+ * having no ceiling would be having one whose stop drifts out of step with the other stop — a
+ * ceiling that disabled the row but never announced it would be strictly WORSE than no ceiling at
+ * all, because the routine would go quiet with nothing anywhere to read.
+ *
+ * ORDER MATCHES THE FOLD, for the same reasons: the store write first (so the row is terminal even
+ * if everything after it fails — an exhausted routine must not fire again under any circumstances),
+ * then the audit row (fire-audit.ts swallows its own failures), then the notice (fail-soft inside
+ * disable-notice.ts).
+ *
+ * `consecutiveFailures` rides the audit row unchanged and is USUALLY 0 — which is the point of this
+ * row existing at all: `routine.disabled` carrying a `boundDimension` and zero failures is a routine
+ * that was working the whole time and simply never finished, and that is a different incident from
+ * one that broke three times.
+ */
+export async function retireExhaustedRoutine(opts) {
+    const { routine, verdict } = opts;
+    const patch = boundExhaustedPatch(verdict);
+    const updated = await updateRoutine(routine.org, routine.surfaceKey, routine.id, patch);
+    if (!updated)
+        return false; // cancelled between the read and here — nothing to retire
+    await auditRoutineDisabled(routine, patch.disabledReason ?? "stopped at its ceiling", routine.consecutiveFailures, undefined, {
+        // The DIMENSION, not just the sentence: "ran out of tries", "ran out of time" and "was never
+        // allowed to work" lead an operator to three different next moves (raise the cap / re-arm as-is /
+        // answer the checkpoint card FIRST), and a reader of the audit trail should not have to parse
+        // prose to tell them apart.
+        boundDimension: verdict.dimension,
+        fireCount: routine.fireCount ?? 0,
+        ...(routine.bound?.maxFires !== undefined ? { maxFires: routine.bound.maxFires } : {}),
+        ...(routine.bound?.until !== undefined ? { boundUntil: routine.bound.until } : {}),
+        // OPE-253: present exactly when there is a stall run to report, so an operator reading a
+        // `boundDimension: "stalled"` row gets the count that produced it without a second lookup — and a
+        // FIRES/DEADLINE row that ALSO carries a non-zero count is the tell that the ceiling was partly
+        // burned by fires that could not act.
+        ...(routine.stalledFires ? { stalledFires: routine.stalledFires } : {}),
+        ...(routine.lastStallAt !== undefined ? { lastStallAt: routine.lastStallAt } : {}),
+    });
+    return announceBoundExhausted(routine, verdict);
+}
+/**
+ * RECORD THAT THIS FIRE WAS BLOCKED (OPE-253) — called from spend/checkpoint.ts's block path when the
+ * refused session turns out to be a routine fire. Returns whether this call was the one that recorded
+ * the stall (false = already recorded for this fire, or the routine is gone).
+ *
+ * IT RECORDS A FACT AND DOES NO ARITHMETIC. `lastStallAt` is the per-fire fact; the COUNT is applied
+ * by {@link foldRoutineOutcome} at session end via routines/stall.ts stallFoldPatch. That is the exact
+ * split OPE-177 uses (`report_run_failed` records `lastFailureReason` mid-turn, `applyOutcome` counts
+ * it into `consecutiveFailures`), and it buys three things a counter-here design would not:
+ *
+ *   • PER-FIRE IDEMPOTENCE for free. A blocked tool throws a RECOVERABLE error, so the model takes
+ *     another step and may reach for a second consequential tool in the same fire — three refusals is
+ *     still ONE stalled fire. The dispatcher clears `lastStallAt` at fire, so "already set" is a
+ *     reliable "this fire is already counted", and the early return below is what keeps the audit row
+ *     one-per-fire without a throttle.
+ *   • the RUN can be broken by a fire that got its hands, which is what makes the counter consecutive.
+ *     Only the fold knows a fire ended without stalling.
+ *   • no double-count across a durable-replay of the same tool step.
+ *
+ * FAIL-SOFT BY CONTRACT, and it must be: this runs INSIDE a guard whose whole job is to throw a
+ * recoverable tool-error, on a path the guard already documents as fail-OPEN. A store hiccup while
+ * recording the stall must never change whether the tool was blocked, nor replace the guard's error
+ * with a store error the model would read as something else entirely. Every failure logs and returns
+ * false; the checkpoint's own `checkpoint.trip` row is unaffected.
+ */
+export async function recordCheckpointStall(opts) {
+    const { marker, tool, reason } = opts;
+    try {
+        const routine = await getRoutine(marker.org, marker.surfaceKey, marker.id);
+        if (!routine)
+            return false; // cancelled between the fire and the refusal
+        if (routine.lastStallAt !== undefined)
+            return false; // this fire is already recorded — see above
+        const at = (opts.at ?? new Date()).toISOString();
+        const updated = await updateRoutine(marker.org, marker.surfaceKey, marker.id, { lastStallAt: at });
+        if (!updated)
+            return false;
+        // AFTER the row, so the count on the row and the count on the row's row agree for a reader. The
+        // fold has not run yet, so the run this fire EXTENDS is the stored count plus this one — stated
+        // that way rather than reported as the stored value, which would be off by one for every reader.
+        await auditRoutineStalled(routine, { tool, reason, stalledFires: (routine.stalledFires ?? 0) + 1 });
+        return true;
+    }
+    catch (err) {
+        console.log(`[open-everywhere:routines] stall record skipped for ${marker.id}: ${String(err)}`);
+        return false;
+    }
+}
+//# sourceMappingURL=outcome-fold.js.map

package/dist/agent/routines/outcome-fold.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"outcome-fold.js","sourceRoot":"","sources":["../../../agent/routines/outcome-fold.ts"],"names":[],"mappings":"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"}

package/dist/agent/routines/partition.d.ts

@@ -0,0 +1,5 @@
+import type { Partition } from "../memory/partition.js";
+import type { Routine } from "./routine.js";
+/** The partition a routine belongs to and fires back into. */
+export declare function routinePartition(r: Pick<Routine, "org" | "surfaceKey">): Partition;
+//# sourceMappingURL=partition.d.ts.map

package/dist/agent/routines/partition.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"partition.d.ts","sourceRoot":"","sources":["../../../agent/routines/partition.ts"],"names":[],"mappings":"AAUA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,wBAAwB,CAAC;AACxD,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AAE5C,8DAA8D;AAC9D,wBAAgB,gBAAgB,CAAC,CAAC,EAAE,IAAI,CAAC,OAAO,EAAE,KAAK,GAAG,YAAY,CAAC,GAAG,SAAS,CAYlF"}

package/dist/agent/routines/partition.js

@@ -0,0 +1,24 @@
+// A routine's PARTITION, derived without a session. One shape, one place.
+//
+// A routine fires with no live context to bind from — the dispatcher (clock leg) and the fan-out
+// (event leg) both need "which partition is this row's?" before any session exists — so the split
+// is done off the stored `surfaceKey` exactly the way `memory/partition.ts` resolvePartition does
+// it off a binding. This used to be a private copy inside schedules/dispatch.ts, with a second
+// partial copy (`routineAuditScope`) in routines/fire-audit.ts; the read-grant check (event-authz.ts)
+// would have made it a third, which is the point at which a duplicated identity derivation stops
+// being harmless.
+/** The partition a routine belongs to and fires back into. */
+export function routinePartition(r) {
+    const [platform = "", workspace = "", ...rest] = r.surfaceKey.split("/");
+    const workspaceKey = `${platform}/${workspace}`;
+    return {
+        org: r.org,
+        platform,
+        workspace,
+        surface: rest.join("/"),
+        workspaceKey,
+        surfaceKey: r.surfaceKey,
+        key: r.surfaceKey,
+    };
+}
+//# sourceMappingURL=partition.js.map

package/dist/agent/routines/partition.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"partition.js","sourceRoot":"","sources":["../../../agent/routines/partition.ts"],"names":[],"mappings":"AAAA,0EAA0E;AAC1E,EAAE;AACF,iGAAiG;AACjG,kGAAkG;AAClG,kGAAkG;AAClG,+FAA+F;AAC/F,sGAAsG;AACtG,iGAAiG;AACjG,kBAAkB;AAKlB,8DAA8D;AAC9D,MAAM,UAAU,gBAAgB,CAAC,CAAsC;IACrE,MAAM,CAAC,QAAQ,GAAG,EAAE,EAAE,SAAS,GAAG,EAAE,EAAE,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,UAAU,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;IACzE,MAAM,YAAY,GAAG,GAAG,QAAQ,IAAI,SAAS,EAAE,CAAC;IAChD,OAAO;QACL,GAAG,EAAE,CAAC,CAAC,GAAG;QACV,QAAQ;QACR,SAAS;QACT,OAAO,EAAE,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC;QACvB,YAAY;QACZ,UAAU,EAAE,CAAC,CAAC,UAAU;QACxB,GAAG,EAAE,CAAC,CAAC,UAAU;KAClB,CAAC;AACJ,CAAC"}

package/dist/agent/routines/permission-card-wait.d.ts

@@ -0,0 +1,150 @@
+/**
+ * The deployed function's wall ceiling, in seconds (measured on ship #148, config-read, three
+ * sources agreeing: the platform default under fluid compute, with no app pin). Everything below is
+ * arithmetic off this number, and it is stated here rather than in the setting so the code that
+ * enforces the bound and the doc that explains it cannot drift apart.
+ */
+export declare const FUNCTION_WALL_CEILING_SECONDS = 300;
+/**
+ * The FALLBACK for what the turn has already spent by the time a gated tool call reaches its
+ * refusal — the wake, the model's first passes, and whatever tools ran before this one.
+ *
+ * 🔴 IT IS THE "OTHERWISE" ARM, NOT THE ONLY ARM (OPE-1347). The bound is
+ * `min(configured, ceiling − elapsed − reserve)`, and `elapsed` is READ from the turn's own
+ * `startedAt` through {@link turnElapsedSeconds}. This number is what stands in when there is no
+ * turn to read: a schedule, an eval, a CLI, a unit test. It is deliberately generous — assuming a
+ * turn is further along than it is shortens the wait, which costs a run its window; assuming it is
+ * younger than it is lets the wall clock kill the turn mid-report, which costs the run its report.
+ */
+export declare const ASSUMED_TURN_ELAPSED_SECONDS = 120;
+/**
+ * What must still fit AFTER the wait: telling the model, its next passes, and posting the run's
+ * report to the routine's surface. A wait that consumed the whole remainder would turn a refusal
+ * the model could report into a turn that is killed mid-sentence.
+ */
+export declare const TURN_TAIL_RESERVE_SECONDS = 60;
+/** The clamp on the FALLBACK arm: 300 − 120 − 60. Also the recommended armed value, because it is
+ *  what a turn that reached its refusal at the assumed elapsed can still afford. It is NOT a floor
+ *  on {@link routineCardWaitCeilingSeconds}, which goes to 0 and below on a longer turn — that is
+ *  the clamp OPE-1347 exists for. */
+export declare const ROUTINE_CARD_WAIT_CEILING_SECONDS: number;
+/**
+ * The wait this turn may still afford, in seconds: `300 − elapsed − 60`.
+ *
+ * 🔴 IT CAN BE ZERO OR NEGATIVE, AND THAT IS THE POINT (OPE-1347). A turn that reached its refusal
+ * 250 seconds in has 300 − 250 − 60 = −10 seconds of room. Before the elapsed read that same turn
+ * was handed the flat 120-second budget and was killed by the wall clock mid-report — the refusal
+ * never reached the model and the routine's room learned nothing. A non-positive ceiling now
+ * disarms the wait instead: the refusal is immediate and the card still decides every future fire.
+ * {@link routineCardWaitBudgetMs} is where that clamp is applied.
+ *
+ * An unreadable elapsed (no turn context, or a clock that moved backwards) falls back to
+ * {@link ASSUMED_TURN_ELAPSED_SECONDS}, which reproduces the pre-OPE-1347 number exactly.
+ */
+export declare function routineCardWaitCeilingSeconds(elapsedSeconds?: number | undefined): number;
+/**
+ * What the wait concluded.
+ *
+ * `stale` and `gone` are kept apart from `deadline` on purpose: all three refuse the run, and they
+ * refuse it for three different reasons that a human debugging a routine needs told apart. Saying
+ * "nobody was around" about a card a person actually clicked is the overclaim this split prevents.
+ */
+export type RoutineCardWaitOutcome = 
+/** The setting ships 0 — no wait ran at all, and the refusal is byte-identical to PR 1's. */
+"disarmed"
+/** A person approved inside the window AND the standing grant row is really written. */
+ | "approved"
+/** A person declined inside the window. The run refuses.
+ *
+ *  🔴 IT SAYS NOTHING ABOUT DURABILITY. `routinePermission.declined` writes the "stop asking" row
+ *  only when its own click-time re-check passes, and that write is best-effort — so whether the
+ *  decline is remembered is a property of the CARD, decided after this outcome is read, and the
+ *  run must not report it. Reading it here would also race the click exactly as `stale` does. */
+ | "declined"
+/** A person approved, and no standing permission was written behind the click before the budget
+ *  ran out. Reported only at the DEADLINE, never on the first unarmed probe — see the loop. */
+ | "stale"
+/** The card is no longer answerable (expired, or the row is gone). */
+ | "gone"
+/**
+ * The budget ran out and the LAST probe of the window could not read the card at all.
+ *
+ * 🔴 IT EXISTS BECAUSE `deadline` WOULD BE A LIE HERE. The loop swallows every probe rejection so a
+ * store blip cannot auto-decline a run early — which means a store that is down for the whole
+ * window reaches the same end state as a card nobody touched. Reporting that as "nobody was
+ * present to action it" states as fact something the code never observed: the owner may have
+ * clicked, and this run simply could not see it. So the two are separated at the one place that
+ * can tell them apart, and this arm says what actually happened.
+ */
+ | "unreadable"
+/** The budget ran out with the card still pending. The row is untouched and stays clickable. */
+ | "deadline";
+/** One read of the card's world: what its row says, and whether the grant really exists. */
+export interface RoutineCardProbe {
+    readonly status: "pending" | "approved" | "rejected" | "expired" | "gone";
+    /** Is the standing grant row actually written? Read only when it could be — see the header. */
+    readonly armed: boolean;
+}
+/**
+ * The injected seam. Production passes the real store probe, a real `setTimeout` sleep and
+ * `Date.now`; a test passes a scripted probe, a sleep that resolves immediately and a clock it
+ * advances itself — which is how the deadline legs run in milliseconds and prove the arithmetic
+ * rather than the machine's timer.
+ */
+export interface RoutineCardWaitDeps {
+    readonly probe: () => Promise<RoutineCardProbe>;
+    readonly sleep: (ms: number) => Promise<void>;
+    readonly nowMs: () => number;
+    /** Defaults to {@link ROUTINE_CARD_POLL_INTERVAL_MS}. */
+    readonly pollIntervalMs?: number;
+}
+/** The configured wait, in seconds, before the ceiling clamp. */
+export declare function routineCardWaitSeconds(): number;
+/**
+ * The budget this run may actually spend, in milliseconds — `min(configured, ceiling)`, and 0 for
+ * anything non-positive or unreadable. 0 means NO WAIT: the caller refuses immediately, exactly as
+ * it did before this file existed.
+ *
+ * The clamp is not defensive decoration. The setting's validator refuses a value above 300, but it
+ * admits every value up to it — an operator who authors 200 gets what the turn can still afford,
+ * not a turn killed mid-report. And since OPE-1347 the ceiling is derived from the turn's OWN
+ * elapsed time rather than an assumed 120 seconds, so a long turn is clamped harder (down to no
+ * wait at all) and a young one is allowed the whole configured window.
+ */
+export declare function routineCardWaitBudgetMs(configuredSeconds?: number, ceilingSeconds?: number): number;
+/**
+ * Poll the card until it is answered or the budget is spent.
+ *
+ * ORDER IS LOAD-BEARING: probe, then test the deadline, then sleep. A click that landed between the
+ * card's post and the first tick is therefore seen without waiting for one, and the last sleep is
+ * always followed by one final probe rather than an immediate give-up.
+ *
+ * A probe that THROWS is swallowed and the loop continues. A store blip must not read as "nobody
+ * answered" — the budget still bounds the whole thing, so the cost of a broken store is the full
+ * wait and then an honest deadline, never an early wrong answer.
+ */
+export declare function waitForRoutineCardDecision(budgetMs: number, deps: RoutineCardWaitDeps): Promise<RoutineCardWaitOutcome>;
+/**
+ * The clause the refusal appends for a wait that did not end in an approval. Every arm names what
+ * really happened, and every arm states only what a row actually said.
+ *
+ * 🔴 EVERY ARM IS SELF-CONTAINED, AND THAT IS LOAD-BEARING. The caller composes this with the
+ * PRE-WAIT card-state clause ("a card is now waiting" / "a card is already waiting"), which
+ * describes the card at wait START. Only {@link routineCardKeepsStateClause} says when that is still
+ * true at wait END — everywhere else the pre-wait sentence is DROPPED, because "nobody has decided
+ * it yet" followed by "a person declined it" is one paragraph contradicting itself. So each arm here
+ * has to introduce the card itself rather than lean on a sentence that may not be there.
+ *
+ * `approved` returns "" — that run does not refuse, so it has no refusal to append to.
+ */
+export declare function routineCardWaitRefusalClause(outcome: RoutineCardWaitOutcome, waitedSeconds: number): string;
+/**
+ * May the caller keep its PRE-WAIT card-state clause alongside {@link routineCardWaitRefusalClause}?
+ *
+ * Only at the deadline. There the card really is untouched — still pending, still where the earlier
+ * sentence said it was — so "a card is waiting in the routine's own room" is as true at wait end as
+ * it was at wait start, and the two sentences read as one paragraph. Every other outcome moved the
+ * card out from under that sentence.
+ */
+export declare function routineCardKeepsStateClause(outcome: RoutineCardWaitOutcome): boolean;
+//# sourceMappingURL=permission-card-wait.d.ts.map

package/dist/agent/routines/permission-card-wait.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"permission-card-wait.d.ts","sourceRoot":"","sources":["../../../agent/routines/permission-card-wait.ts"],"names":[],"mappings":"AAsCA;;;;;GAKG;AACH,eAAO,MAAM,6BAA6B,MAAM,CAAC;AAEjD;;;;;;;;;;GAUG;AACH,eAAO,MAAM,4BAA4B,MAAM,CAAC;AAEhD;;;;GAIG;AACH,eAAO,MAAM,yBAAyB,KAAK,CAAC;AAE5C;;;qCAGqC;AACrC,eAAO,MAAM,iCAAiC,QAA2F,CAAC;AAE1I;;;;;;;;;;;;GAYG;AACH,wBAAgB,6BAA6B,CAAC,cAAc,GAAE,MAAM,GAAG,SAAgC,GAAG,MAAM,CAG/G;AASD;;;;;;GAMG;AACH,MAAM,MAAM,sBAAsB;AAChC,6FAA6F;AAC3F,UAAU;AACZ,wFAAwF;GACtF,UAAU;AACZ;;;;;iGAKiG;GAC/F,UAAU;AACZ;+FAC+F;GAC7F,OAAO;AACT,sEAAsE;GACpE,MAAM;AACR;;;;;;;;;GASG;GACD,YAAY;AACd,gGAAgG;GAC9F,UAAU,CAAC;AAEf,4FAA4F;AAC5F,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,CAAC,MAAM,EAAE,SAAS,GAAG,UAAU,GAAG,UAAU,GAAG,SAAS,GAAG,MAAM,CAAC;IAC1E,+FAA+F;IAC/F,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAC;CACzB;AAED;;;;;GAKG;AACH,MAAM,WAAW,mBAAmB;IAClC,QAAQ,CAAC,KAAK,EAAE,MAAM,OAAO,CAAC,gBAAgB,CAAC,CAAC;IAChD,QAAQ,CAAC,KAAK,EAAE,CAAC,EAAE,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IAC9C,QAAQ,CAAC,KAAK,EAAE,MAAM,MAAM,CAAC;IAC7B,yDAAyD;IACzD,QAAQ,CAAC,cAAc,CAAC,EAAE,MAAM,CAAC;CAClC;AAED,iEAAiE;AACjE,wBAAgB,sBAAsB,IAAI,MAAM,CAE/C;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,uBAAuB,CACrC,iBAAiB,GAAE,MAAiC,EACpD,cAAc,GAAE,MAAwC,GACvD,MAAM,CAIR;AAED;;;;;;;;;;GAUG;AACH,wBAAsB,0BAA0B,CAAC,QAAQ,EAAE,MAAM,EAAE,IAAI,EAAE,mBAAmB,GAAG,OAAO,CAAC,sBAAsB,CAAC,CA0C7H;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,4BAA4B,CAAC,OAAO,EAAE,sBAAsB,EAAE,aAAa,EAAE,MAAM,GAAG,MAAM,CAmB3G;AAED;;;;;;;GAOG;AACH,wBAAgB,2BAA2B,CAAC,OAAO,EAAE,sBAAsB,GAAG,OAAO,CAEpF"}