toolroll 0.9.51 → 0.9.53

package/dist/exhaustion.js

@@ -1,152 +1,26 @@
 /**
- * The terminal exhaustion taxonomy (fallback chains, R1/C5/C8 of the
- * approved design). A finished attempt is classified into ONE of these,
- * where the evidence still exists — the provider adapter's structural
- * record plus the gateway's authoritative CLI version and auth mode —
- * NEVER in disposal, by which time the structural signal is gone.
+ * How a finished attempt ended, classified where the evidence still exists
+ * (the provider adapter's structural terminal record), never in disposal.
+ * The one class that changes what happens next is `auth-expired`: a sign-in
+ * or API key that no longer works pauses dispatch for that provider until
+ * someone signs in, instead of burning attempts. Everything else is the
+ * ordinary failure road.
  *
- * The whole feature is FAIL CLOSED by construction: a recognizer's
- * eligible-signal set is EMPTY until a versioned fixture, captured from a
- * GENUINELY EXHAUSTED subscription, proves the exact bytes. A build with
- * no fixture for a (provider, version) can therefore NEVER return an
- * eligible class — so it can never authorize a paid fallback. A
- * successful run cannot establish the exhausted shape; only real
- * exhaustion can, and the plane cannot manufacture it.
- *
- * Precedence (C5), applied by the classifier:
- * - A present STRUCTURAL FAILURE terminal blocks success ingestion even
- *   on exit 0 (that is the parser's job; this module reads the record).
- * - Only an ALLOWLISTED, version+auth-specific pattern yields an ELIGIBLE
- *   class. Exit code, bare rate-limit prose, timeout, notFound, stderr,
- *   and zero tokens NEVER independently establish exhaustion.
- * - Everything unmatched is `unknown` — the ordinary failure road.
- * - A sign-in that no longer works (`auth-expired`) is recognized FIRST,
- *   for every provider and version: an expired or revoked login is not a
- *   property of a CLI version, and retrying it only burns attempts. It is
- *   never fallback-eligible — a lapsed login must not reach a paid key.
- */
-/** The two classes that may authorize a fallback advance. */
-export const FALLBACK_ELIGIBLE = new Set([
-    "usage-exhausted",
-    "credits-depleted",
-]);
-export function isFallbackEligible(cls) {
-    return FALLBACK_ELIGIBLE.has(cls);
-}
-/**
- * The registry. EVERY entry ships empty (fail closed). A real fixture,
- * once captured from a genuinely exhausted subscription and reviewed,
- * adds the exact patterns under that provider+version — and ONLY then can
- * that (provider, version) ever return an eligible class.
- *
- * The outer key is the provider; the inner key is the exact CLI version
- * string the gateway proved at spawn (never a range — a version this
- * build has no fixture for is unrecognized, so fail closed).
- */
-const RECOGNIZERS = {
-    claude: {},
-    codex: {},
-    openrouter: {},
-    gemini: {},
-};
-/**
- * The recognizer lookup. Reads ONLY the module-level RECOGNIZERS registry —
- * there is NO mutation surface, so no build (production or otherwise) can
- * install a recognizer at runtime; a real fixture arrives as a source edit,
- * reviewed in a text diff (Codex E2/E3 review, finding 1). The suite proves
- * the eligible path by MOCKING this module, never by a shipped seam.
- * Object.hasOwn keeps the lookup TOTAL for adversarial version strings
- * (foundation review, finding 3): "__proto__" / "constructor" / "toString"
- * resolve to "no recognizer", never an inherited property.
- */
-function recognizersFromRegistry(provider, version) {
-    if (!Object.hasOwn(RECOGNIZERS[provider], version))
-        return undefined;
-    return RECOGNIZERS[provider][version];
-}
-/** Whether THIS build carries a fixture-backed recognizer for a
- * (provider, version). The C8 gate consults this at every authority
- * point — not only at classification — so a downgrade to an unfixtured
- * build severs any in-flight fallback authority. */
-export function hasRecognizer(provider, version) {
-    if (version === null)
-        return false;
-    const perVersion = recognizersFromRegistry(provider, version);
-    if (perVersion === undefined)
-        return false;
-    return perVersion.eligibleUsage.length > 0 || perVersion.eligibleCredits.length > 0;
-}
-/**
- * The EXACT C8 capability check (Codex E2/E3 review, finding 8): whether
- * this build can recognize the specific eligible class an AUTH MODE would
- * produce — a subscription's `usage-exhausted` needs a nonempty
- * eligibleUsage set; an api-key account's `credits-depleted` needs a
- * nonempty eligibleCredits set. `hasRecognizer` (any-eligible) is too coarse
- * at the authority point: a version fixtured for usage only must NOT
- * authorize a credits-depleted advance.
- */
-export function recognizesEligible(provider, version, authMode) {
-    if (version === null)
-        return false;
-    const perVersion = recognizersFromRegistry(provider, version);
-    if (perVersion === undefined)
-        return false;
-    return authMode === "subscription" ? perVersion.eligibleUsage.length > 0 : perVersion.eligibleCredits.length > 0;
-}
-/** The eligible class an auth mode can legitimately carry — the C8
- * consistency invariant: `usage-exhausted` iff subscription,
- * `credits-depleted` iff api-key. A stamp that violates this pairing is a
- * bad/overwritten record and must never advance. */
-export function classMatchesAuthMode(cls, authMode) {
-    if (cls === "usage-exhausted")
-        return authMode === "subscription";
-    if (cls === "credits-depleted")
-        return authMode === "api-key";
-    return false;
-}
-/**
- * Classify a finished attempt. Fail closed: no recognizer for this exact
- * (provider, version) => never an eligible class. `authMode` decides which
- * eligible class a match yields — a subscription that hits its cap is
- * `usage-exhausted`; an api-key account out of credits is
- * `credits-depleted`. A structural failure with no eligible/transient
- * match is `not-exhausted`; no structural failure and no match is
- * `unknown`.
+ * `usage-exhausted`, `credits-depleted` and `transient-throttle` are only
+ * ever read from older runs' records (they were stamped by a removed
+ * feature); this build never produces them.
  */
+/** Classify a finished attempt: a sign-in that no longer works first, for
+ * any provider or version; then a structural failure terminal is
+ * `not-exhausted`, and anything else `unknown`. */
 export function classifyTerminal(args) {
-    const { provider, version, authMode, terminal } = args;
-    // A sign-in that no longer works, before anything else and for any
-    // provider or version: no fixture is needed to know a login is gone.
+    const { terminal } = args;
     if (terminal !== null && terminal.failed === true && isAuthFailure(`${terminal.code ?? ""}\n${terminal.text ?? ""}`))
         return "auth-expired";
     if (typeof args.earlyExit === "string" && isAuthFailure(args.earlyExit))
         return "auth-expired";
-    if (terminal === null)
-        return "unknown";
-    // The classifier's contract permits failed:false, but a non-failure
-    // terminal is never exhaustion (Codex foundation review, finding 4):
-    // only a structural FAILURE terminal is even eligible for matching.
-    if (terminal.failed !== true)
+    if (terminal === null || terminal.failed !== true)
         return "unknown";
-    const perVersion = version === null ? undefined : recognizersFromRegistry(provider, version);
-    const haystack = `${terminal.code ?? ""}\n${terminal.text ?? ""}`;
-    if (perVersion !== undefined) {
-        // Transient throttle is checked FIRST so a throttle can never be read
-        // as exhaustion (Claude's "temporarily limiting requests — not your
-        // usage limit" family).
-        if (perVersion.transient.some(re => re.test(haystack)))
-            return "transient-throttle";
-        // Then the eligible sets, gated by auth mode.
-        if (authMode === "subscription" && perVersion.eligibleUsage.some(re => re.test(haystack))) {
-            return "usage-exhausted";
-        }
-        if (authMode === "api-key" && perVersion.eligibleCredits.some(re => re.test(haystack))) {
-            return "credits-depleted";
-        }
-    }
-    // A structural FAILURE terminal that matched nothing is a definite
-    // non-exhaustion terminal (a non-failure terminal already returned
-    // unknown above).
     return "not-exhausted";
 }
 /**

package/dist/export.js

@@ -34,7 +34,7 @@ const DERIVED_TABLE = /^(sqlite_|memory_search)/;
 /** Columns that hold a secret (or what stands in for one): never exported. */
 const SECRET_COLUMNS = new Set([
     "api_token.secret_hash", "lead_credential.secret_hash", "approver.credential_hash", "coordinator_credential.credential_hash", "runner.credential_hash", "invite.token_hash",
-    "flow_trigger.hook_hash", "held_session.cookie", "push_subscription.endpoint", "push_subscription.p256dh", "push_subscription.auth",
+    "flow_trigger.hook_hash", "push_subscription.endpoint", "push_subscription.p256dh", "push_subscription.auth",
     "chat_turn.credential_key", "mate_session.credential_key", "mate_turn.credential_key", "bridge_lease.push_url", "workflow_preview.token",
     "quota.credential_fp", "oauth_grant.renew_hash", "oauth_client.source_hash",
 ]);
@@ -54,10 +54,10 @@ export function categoryOf(table) {
     const rules = [
         [/^(action_ledger|ledger_seal|ledger_checkpoint|sync_ledger)$/, "ledger"],
         [/^teammate/, "teammates"],
-        [/^(flow|routine|workflow_)/, "flows"],
+        [/^(flow|workflow_)/, "flows"],
         [/^(chat_|mate_|team_|telegram_|slack_|discord_|teams_|notification|push_|bridge_lease)/, "chats"],
         [/^(approver|api_token|lead_credential|invite|sso_identity|coordinator_|oauth_)/, "people"],
-        [/^(run|artifact|claim|worktree$|execution_slot|contest|tournament_terms|fallback_cycle|fallback_transition|held_session|session_turn|attended_authorization|criterion_review|diff_comment|proof_|review_request|repair_chain|incident|publication$|merge_|side_spend|knowledge_snapshot|learning_snapshot|skill_snapshot)/, "runs"],
+        [/^(run|artifact|claim|worktree$|execution_slot|criterion_review|diff_comment|proof_|review_request|repair_chain|incident|publication$|merge_|side_spend|knowledge_snapshot|learning_snapshot|skill_snapshot)/, "runs"],
         [/^(task|hold$|plan_|scope_|tool_seal|decision|external_|skill_test)/, "tasks"],
         [/^(project|approval_policy|capability|verify_command|worktree_setup|backend_grant|intake_grant|publication_grant|operating_mode|knowledge_|learning_|memory_|skill_)/, "projects"],
         [/(_config|_default|_defaults)$|^(budget|model_|provider_|installation_fact|runtime_check|monitoring_status|integration_check|quota|mode_rail|schema_version)/, "settings"],
@@ -215,7 +215,7 @@ Everything this installation knew on ${now.toISOString().slice(0, 16).replace("T
 - \`ledger/\`: the action ledger (\`action_ledger\`), each entry's seal (\`ledger_seal\`) and the checkpoints (\`ledger_checkpoint\`).
 - \`evidence-packs/\`: one JSON file per task: who asked, the exact terms and who approved them, runs and cost, checks, completion and its ledger entries.
 - \`chats/\`: conversations with the lead and teammates, and Telegram, Slack, Discord and Teams messages and notifications.
-- \`flows/\`: flows, their cards, scripts and triggers, routines and saved recipes.
+- \`flows/\`: flows, their cards, scripts and triggers (schedules included) and saved recipes.
 - \`teammates/\`: teammates, their versions, memory, tools and turns.
 - \`people/\`: accounts, API token names and invitations (no passwords or tokens).
 - \`settings/\`: models, budgets, spend and permission defaults, provider readings; \`files.json\` holds the settings kept in files.

package/dist/flow-engine.js

@@ -1,6 +1,6 @@
 /**
  * The flow engine: moves cards through their flow's zones. Deterministic
- * and model-free — it runs in a worker's pass beside routines, files work
+ * and model-free — it runs in a worker's pass beside builds, files work
  * through the ordinary task door (so every approval and check a task needs
  * still applies), reads task state, posts messages through the outbox, and
  * waits for people. See flows.ts for what each zone does.

package/dist/flow-schedule.d.ts

@@ -0,0 +1,154 @@
+/**
+ * Schedules (v115: flow-owned; routines became scheduled flows).
+ *
+ * A schedule trigger fires on one of four readable cadences. Its two failure modes are subtle enough to deserve
+ * names: advancing one interval after downtime leaves the next firing in the past — a catch-up burst; advancing to
+ * `now + interval` drifts the cadence forever. The rule is ALIGNED advancement: the next occurrence strictly after
+ * now, anchored to the occurrence that just fired (for `every`) or to the clock itself (for calendar schedules).
+ * Missed slots while nothing was running fire ONCE — the overdue occurrence — and are never backfilled.
+ */
+import type { StandingOrder } from "./contracts/flow.js";
+import { type PhaseRoute } from "./phase-routing.js";
+import { type AcceptanceCriterion, type ExecutionProfile } from "./scope.js";
+import { type Store } from "./store.js";
+export type { StandingOrder };
+export type Schedule = {
+    kind: "every";
+    minutes: number;
+} | {
+    kind: "daily";
+    hhmm: string;
+    timezone?: string;
+}
+/** v96: Monday to Friday. */
+ | {
+    kind: "weekdays";
+    hhmm: string;
+    timezone?: string;
+} | {
+    kind: "weekly";
+    day: number;
+    hhmm: string;
+    timezone?: string;
+};
+export declare const WEEKDAYS: readonly ["Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"];
+export declare function validTimezone(value: string): boolean;
+/** Bounds a person would pick on purpose: 5 minutes to 7 days. */
+export declare const MIN_EVERY_MINUTES = 5;
+export declare const MAX_EVERY_MINUTES: number;
+/**
+ * Existing daily schedules remain UTC. Calendar schedules may name an IANA
+ * timezone, whose wall-clock time stays fixed across daylight saving changes.
+ * No cron expressions in v1 — a schedule the operator cannot read at a
+ * glance is a schedule they cannot honestly approve.
+ */
+export declare function parseSchedule(text: string): Schedule | null;
+export declare function scheduleText(schedule: Schedule): string;
+/** The schedule, in words an operator agrees to. */
+export declare function describeSchedule(schedule: Schedule): string;
+/**
+ * The first occurrence after approval: the schedule starts counting from the
+ * yes, because "approved at 14:07, every 60 minutes" firing instantly would
+ * spend before the approver's hand left the keyboard.
+ */
+export declare function firstFireAt(schedule: Schedule, now: Date): string;
+/**
+ * Aligned advancement: the smallest cadence occurrence STRICTLY after now.
+ * `anchor` is the occurrence that just fired (or was just skipped) — the
+ * cadence grid grows from it, so a pass that ran late does not tilt every
+ * later firing by its lateness.
+ */
+export declare function nextFireAt(schedule: Schedule, anchorIso: string, now: Date): string;
+/** The rolling window a standing order's cost ceiling counts over: seven days, and every surface says so. */
+export declare const BUDGET_WINDOW_MS: number;
+/** A firing's task id: the order's stem stamped with its slot (`nightly-deps-20261008-0700`). */
+export declare function instanceId(stem: string, slotIso: string): string;
+/**
+ * The exact standing order an approver agreed to, as 128 bits — byte for byte what a routine's digest was, so a
+ * routine's approval moved onto a scheduled flow (v115) still verifies: the project, the terms, the schedule, the
+ * ceiling, and the agents the approval froze. Editing any of them (or moving the flow) strands the approval.
+ */
+export declare function standingDigestOf(repo: string, schedule: string, order: StandingOrder, acceptance: readonly AcceptanceCriterion[], profile: ExecutionProfile, route: PhaseRoute): string;
+export type StandingApproval = {
+    live: true;
+    by: string | null;
+    profile: ExecutionProfile;
+    route: PhaseRoute;
+    acceptance: AcceptanceCriterion[];
+} | {
+    live: false;
+    problem: string | null;
+    acceptance: AcceptanceCriterion[] | null;
+};
+/**
+ * Whether a standing order's carried approval still stands, read whole before anything is written: the frozen agents
+ * read back, re-hash with the order's terms, this schedule and project to the digest the approver signed, state no
+ * problem, and build and repair on the approved profile's own agents. `problem` is null when there is no approval.
+ */
+export declare function standingApproval(order: StandingOrder, repo: string, schedule: string): StandingApproval;
+export type StandingFiring = {
+    made: "filed";
+    taskId: string;
+    approved: boolean;
+    note: string | null;
+} | {
+    made: "skipped";
+    note: string;
+};
+/** A firing that must not stand: thrown inside the transaction so nothing it wrote survives. */
+export declare class StandingOrderRefused extends Error {
+}
+/**
+ * File one firing of a standing order (v115, what firing a routine did), inside the caller's transaction. It skips,
+ * saying why, while the last task is unfinished or the rolling 7-day ceiling is reached (an unmeasured paid run fails
+ * closed). Otherwise it files the order's terms unchanged: approved by the carried approval when that still verifies
+ * — on exactly the agents it froze, sealed like any automatic approval under the project's rules — or else as an
+ * ordinary proposal that waits for the project's approval rules like any other.
+ */
+export declare function fileStandingOrder(store: Store, input: {
+    flowId: number;
+    repo: string;
+    trigger: number;
+    schedule: string;
+    order: StandingOrder;
+    title: string;
+    slot: string;
+}, now: Date): StandingFiring;
+/** A standing order in the words a person reads before turning its schedule on. */
+export declare function describeStandingOrder(order: StandingOrder, repo: string, schedule: string): string[];
+/** The terms a person sets a standing order up with (a template's, a recipe's): what each firing files. */
+export type StandingTerms = {
+    goal: string;
+    outOfScope: string | null;
+    touches: string[];
+    requirements: string[];
+    acceptance: readonly AcceptanceCriterion[];
+    budgetPerRunMicrousd: number | null;
+    costCeilingUsd: number | null;
+};
+/** Every problem with a standing order's terms and schedule at once, as `field: problem` lines (none when it can be set up). */
+export declare function standingTermsProblems(terms: StandingTerms, schedule: string): string[];
+export type ScheduledFlowMade = {
+    ok: true;
+    flow: number;
+    trigger: number;
+} | {
+    ok: false;
+    message: string;
+};
+/**
+ * A scheduled flow a person set up (a template or a recipe; v115, what filing a routine was): a Build step that follows
+ * the task each firing files, then Done, and a schedule trigger carrying the terms as its standing order — with no
+ * approval, so each firing waits for approval under the project's rules. The schedule starts PAUSED with no time:
+ * nothing repeats until a person turns it on, and it starts counting then. Its tasks are filed as `filedBy`'s (default
+ * `by`; null files them as automation's). Inside the caller's transaction, if any.
+ */
+export declare function createScheduledFlow(store: Store, input: {
+    repo: string;
+    name: string;
+    stem: string;
+    schedule: string;
+    terms: StandingTerms;
+    by: string;
+    filedBy?: string | null;
+}, now: Date): ScheduledFlowMade;