@intentius/chant 0.57.0 → 0.59.0

package/dist/op/op-verb-class.d.ts

@@ -8,7 +8,7 @@
  * just the pre-built composites — so classification walks `OpConfig`'s
  * steps rather than trusting a self-reported tag.
  *
- * There is no existing per-Op verb-class field (`searchAttributes` is a free
+ * There is no existing per-Op verb-class field (`labels` is a free
  * `Record<string,string>` an author may or may not set — `ApplyOp` tags
  * `{ Apply: "true" }` but nothing requires it, and it carries no verb-class
  * semantics on its own) and no existing "which activity names are
@@ -37,6 +37,14 @@ export type OpVerbClass = "read-only" | "mutating" | "destructive";
  * read-only nor the destructive set is `mutating` by default (fail-closed).
  */
 export declare function classifyOpVerbClass(config: Pick<OpConfig, "phases" | "onFailure">): OpVerbClass;
-/** Does this Op have its own approval gate anywhere in its phases (main or `onFailure`)? Thin re-export of `findGate` under the name this module's callers reach for. */
+/**
+ * Does this Op have its own approval gate anywhere in its phases (main or
+ * `onFailure`), including one nested inside an effect step?
+ *
+ * A declaration-time question, not a run-time one: a gate is a fact the
+ * executor decides against the ledger when it reaches one (#2119,
+ * `./gate.ts`), so this says "this op can stop for a human", never "this op
+ * will stop". `OPS014`'s dispatch refusals are the caller that needs it.
+ */
 export declare function isGated(config: Pick<OpConfig, "phases" | "onFailure">): boolean;
 //# sourceMappingURL=op-verb-class.d.ts.map

package/dist/op/op-verb-class.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"op-verb-class.d.ts","sourceRoot":"","sources":["../../src/op/op-verb-class.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AAGH,OAAO,KAAK,EAA4B,QAAQ,EAAkB,MAAM,SAAS,CAAC;AAElF,MAAM,MAAM,WAAW,GAAG,WAAW,GAAG,UAAU,GAAG,aAAa,CAAC;AA0CnE;;;;;;;GAOG;AACH,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,IAAI,CAAC,QAAQ,EAAE,QAAQ,GAAG,WAAW,CAAC,GAAG,WAAW,CA2B/F;AAED,yKAAyK;AACzK,wBAAgB,OAAO,CAAC,MAAM,EAAE,IAAI,CAAC,QAAQ,EAAE,QAAQ,GAAG,WAAW,CAAC,GAAG,OAAO,CAE/E"}
+{"version":3,"file":"op-verb-class.d.ts","sourceRoot":"","sources":["../../src/op/op-verb-class.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AAEH,OAAO,KAAK,EAAsC,QAAQ,EAAkB,MAAM,SAAS,CAAC;AAE5F,MAAM,MAAM,WAAW,GAAG,WAAW,GAAG,UAAU,GAAG,aAAa,CAAC;AA0CnE;;;;;;;GAOG;AACH,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,IAAI,CAAC,QAAQ,EAAE,QAAQ,GAAG,WAAW,CAAC,GAAG,WAAW,CA2B/F;AAED;;;;;;;;GAQG;AACH,wBAAgB,OAAO,CAAC,MAAM,EAAE,IAAI,CAAC,QAAQ,EAAE,QAAQ,GAAG,WAAW,CAAC,GAAG,OAAO,CAS/E"}

package/dist/op/operator.d.ts

@@ -1,13 +1,13 @@
 /**
- * `chant operator` (#1485, epic #1487) — native durable ticks without
- * Temporal. A deliberately small daemon: a timer, a lease
+ * `chant operator` (#1485, epic #1487) — durable ticks with no service behind
+ * them. A deliberately small daemon: a timer, a lease
  * (../lifecycle/lease.ts), and the existing local executor
  * (./local-executor.ts) in a loop. No new service, no new state store — the
  * lease lives on a git ref, tick state lives on the `chant/lifecycle`
  * orphan branch via the same `convergeTick` activity `chant run <op>`
  * already calls for a single one-shot tick.
  *
- * One round: discover every `ConvergeOp` (searchAttributes `Converge:
+ * One round: discover every `ConvergeOp` (label `Converge:
  * "true"`, optionally filtered to one env), and for each one, try to
  * acquire (or renew) its lease. Win it — run one tick via `runOpLocally` on
  * the Op's own Observe → Converge phases, the identical path `chant run
@@ -38,9 +38,18 @@
 import type { ActivityFn, ActivityProfile } from "./activity-registry.js";
 import { type DiscoveredOp } from "./discover.js";
 import { type OpRunResult } from "./local-executor.js";
-/** Poll interval between rounds — the operator's own cadence, distinct from a `ConvergeOp`'s Temporal `schedule` cron (that field drives the durable path's `TemporalSchedule`, not anything the local executor can read back at discovery time; see this module's doc). Chosen short enough to converge promptly, long enough not to hammer `chant lifecycle plan --live` every few seconds. */
+import type { ChangeSubscription } from "../lexicon.js";
+/**
+ * Poll interval between rounds — the operator's own cadence, and the fallback
+ * for an Op that declares none. Since #2120 an Op can carry its own
+ * `schedule.cron` (`./composites/converge-op.ts`), which this loop honours per
+ * Op: the round still wakes every `intervalMs`, but an Op with a cron is
+ * ticked only on the minutes that cron fires. Chosen short enough to converge
+ * promptly, long enough not to hammer `chant lifecycle plan --live` every few
+ * seconds — and short enough that a per-minute cron is not missed.
+ */
 export declare const DEFAULT_OPERATOR_INTERVAL_MS = 60000;
-/** Discover every `ConvergeOp` in the project (`searchAttributes.Converge === "true"`), optionally filtered to one environment. Ops that don't declare an `Env` search attribute are excluded from an `--env`-filtered discovery (there's nothing to match), but included when no `env` filter is given. */
+/** Discover every `ConvergeOp` in the project (`labels.Converge === "true"`), optionally filtered to one environment. Ops that don't declare an `Env` label are excluded from an `--env`-filtered discovery (there's nothing to match), but included when no `env` filter is given. */
 export declare function discoverConvergeOps(opts?: {
     cwd?: string;
     env?: string;
@@ -59,6 +68,13 @@ export type OperatorTickEvent = {
     op: string;
     env: string;
     heldBy?: string;
+}
+/** The Op declares its own `schedule.cron` (#2120) and this round did not land on a firing minute — the lease was never touched. An Op without a cron is never reported this way: it ticks every round, on `--interval`. */
+ | {
+    kind: "skipped-not-due";
+    op: string;
+    env: string;
+    cron: string;
 } | {
     kind: "tick-failed";
     op: string;
@@ -101,6 +117,16 @@ export interface OperatorRoundOptions {
     profiles: Record<string, ActivityProfile>;
     now?: () => Date;
     signal?: AbortSignal;
+    /**
+     * When each Op with its own `schedule.cron` was last considered (#2120) —
+     * the state a round needs to answer "has a firing minute passed since I
+     * last looked at this Op?". `runOperatorForever` owns one map across
+     * rounds; a bare `runOperatorRound` with none given falls back to "is this
+     * minute a firing minute", which is what a single round can know on its
+     * own. Every considered Op's entry is updated, ticked or not, so a late
+     * round makes up exactly one tick rather than a backlog.
+     */
+    scheduleState?: Map<string, Date>;
 }
 /**
  * Run exactly one round: for every discovered ConvergeOp (filtered per
@@ -109,11 +135,67 @@ export interface OperatorRoundOptions {
  * assert on it directly without depending on log output.
  */
 export declare function runOperatorRound(opts: OperatorRoundOptions): Promise<OperatorTickEvent[]>;
+/**
+ * One lexicon's change-signal seam, already bound to an environment (#1981).
+ *
+ * The loop never sees a `LexiconPlugin`: core's operator does not import
+ * plugins, and binding happens where plugins are already loaded
+ * (`collectChangeSubscribers` in `../cli/plugins.ts`), the same extract-then-
+ * thread shape `collectBuildRootContributors` uses for build roots.
+ */
+export interface ChangeSubscriber {
+    /** Which lexicon supplies the signal. Log lines only; never a fact. */
+    lexicon: string;
+    subscribe(ctx: {
+        onChange: () => void;
+        onError: (message: string) => void;
+        signal: AbortSignal;
+    }): Promise<ChangeSubscription>;
+}
+/**
+ * What the loop's change-signal machinery reports, alongside the per-op tick
+ * events. Separate from {@link OperatorTickEvent} on purpose: none of this is
+ * about an Op, and none of it is an observation.
+ */
+export type OperatorSignalEvent = 
+/** A lexicon's subscription is live and the loop may now wake early. */
+{
+    kind: "subscribed";
+    lexicon: string;
+}
+/** Establishing it failed. The loop keeps its timer and retries next round. */
+ | {
+    kind: "subscribe-failed";
+    lexicon: string;
+    error: string;
+}
+/** A live subscription died. Reported once; the next round re-subscribes. */
+ | {
+    kind: "subscription-lost";
+    lexicon: string;
+    error: string;
+}
+/** A signal shortened the sleep. The round that follows is an ordinary round. */
+ | {
+    kind: "woken";
+    afterMs: number;
+};
+/** Render one signal event as `chant operator`'s log line shape. */
+export declare function formatSignalLine(event: OperatorSignalEvent): string;
 export interface OperatorLoopOptions extends OperatorRoundOptions {
     /** @default DEFAULT_OPERATOR_INTERVAL_MS */
     intervalMs?: number;
     /** Called after every round completes — the CLI's one-line-per-tick log lives here, not inside the loop itself, so a test can drive rounds without capturing stdout. */
     onRound?: (events: OperatorTickEvent[]) => void;
+    /**
+     * Change-signal seams to keep subscribed for the life of the loop (#1981).
+     * Omitted, or empty, and the loop is exactly what it was: a timer.
+     */
+    subscribers?: readonly ChangeSubscriber[];
+    /** @default DEFAULT_SIGNAL_FLOOR_MS. The shortest gap a signal may force between two rounds. */
+    signalFloorMs?: number;
+    /** Called for every subscription and wake event. The CLI logs one line each. */
+    onSignalEvent?: (event: OperatorSignalEvent) => void;
 }
 /**
  * Run rounds forever, sleeping `intervalMs` between them, until
@@ -121,6 +203,12 @@ export interface OperatorLoopOptions extends OperatorRoundOptions {
  * (issue: "if it dies, nothing breaks and nothing is lost") — this function
  * is exactly `while (!aborted) { round(); sleep(); }`, nothing durable lives
  * in its own memory that a restart would need to recover.
+ *
+ * With `subscribers` (#1981) the sleep gains a second wake source, and only a
+ * wake source. A signal aborts the current sleep; the round that follows is
+ * the same round the timer would have run, deriving everything from a fresh
+ * observation. Nothing a subscription reports reaches a tick, because the
+ * seam has nowhere to put it: `onChange` takes no arguments.
  */
 export declare function runOperatorForever(opts: OperatorLoopOptions): Promise<void>;
 /** Render one round's events as `chant operator`'s log line shape — one line per ticked/skipped/failed op, reusing each ticked op's own `convergeTick` log line (`OpRunResult`'s outcome attribute doesn't carry it, so this reads the tick's step record's `Remediated`... actually the human-readable summary comes from the ledger, not the run result — see `../cli/handlers/operator.ts` for where `chant operator status` reads it back). This formats what's available from the round itself: which op, which env, and whether it ticked, skipped, or failed. */

package/dist/op/operator.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"operator.d.ts","sourceRoot":"","sources":["../../src/op/operator.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AACH,OAAO,KAAK,EAAE,UAAU,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;AACvE,OAAO,EAAe,KAAK,YAAY,EAAE,MAAM,YAAY,CAAC;AAC5D,OAAO,EAAyD,KAAK,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAI3G,iYAAiY;AACjY,eAAO,MAAM,4BAA4B,QAAS,CAAC;AAWnD,4SAA4S;AAC5S,wBAAsB,mBAAmB,CACvC,IAAI,CAAC,EAAE;IAAE,GAAG,CAAC,EAAE,MAAM,CAAC;IAAC,GAAG,CAAC,EAAE,MAAM,CAAA;CAAE,GACpC,OAAO,CAAC;IAAE,GAAG,EAAE,YAAY,EAAE,CAAC;IAAC,MAAM,EAAE,MAAM,EAAE,CAAA;CAAE,CAAC,CAKpD;AAED,oIAAoI;AACpI,MAAM,MAAM,iBAAiB,GACzB;IAAE,IAAI,EAAE,QAAQ,CAAC;IAAC,EAAE,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,WAAW,CAAA;CAAE,GAChE;IAAE,IAAI,EAAE,oBAAoB,CAAC;IAAC,EAAE,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,CAAC;IAAC,MAAM,CAAC,EAAE,MAAM,CAAA;CAAE,GACxE;IAAE,IAAI,EAAE,aAAa,CAAC;IAAC,EAAE,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE;AACjE,qaAAqa;GACna;IAAE,IAAI,EAAE,QAAQ,CAAC;IAAC,EAAE,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,CAAA;CAAE;AAC7C;;;;;;;;;;GAUG;GACD;IAAE,IAAI,EAAE,aAAa,CAAC;IAAC,EAAE,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,CAAC;AAEpE,MAAM,WAAW,oBAAoB;IACnC,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,sGAAsG;IACtG,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,oCAAoC;IACpC,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,yVAAyV;IACzV,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,wKAAwK;IACxK,UAAU,EAAE,GAAG,CAAC,MAAM,EAAE,UAAU,CAAC,CAAC;IACpC,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,eAAe,CAAC,CAAC;IAC1C,GAAG,CAAC,EAAE,MAAM,IAAI,CAAC;IACjB,MAAM,CAAC,EAAE,WAAW,CAAC;CACtB;AAED;;;;;GAKG;AACH,wBAAsB,gBAAgB,CAAC,IAAI,EAAE,oBAAoB,GAAG,OAAO,CAAC,iBAAiB,EAAE,CAAC,CAkD/F;AAkBD,MAAM,WAAW,mBAAoB,SAAQ,oBAAoB;IAC/D,4CAA4C;IAC5C,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,wKAAwK;IACxK,OAAO,CAAC,EAAE,CAAC,MAAM,EAAE,iBAAiB,EAAE,KAAK,IAAI,CAAC;CACjD;AAED;;;;;;GAMG;AACH,wBAAsB,kBAAkB,CAAC,IAAI,EAAE,mBAAmB,GAAG,OAAO,CAAC,IAAI,CAAC,CAQjF;AAED,wiBAAwiB;AACxiB,wBAAgB,eAAe,CAAC,KAAK,EAAE,iBAAiB,GAAG,MAAM,CAahE"}
+{"version":3,"file":"operator.d.ts","sourceRoot":"","sources":["../../src/op/operator.ts"],"names":[],"mappings":"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"}

package/dist/op/receipt-store.d.ts

@@ -77,7 +77,7 @@ export interface ReceiptReadArgs extends ReceiptCheckInput {
 export interface ReceiptReadResult {
     /** The receipt's live stored value, or null when absent. */
     current: string | null;
-    /** The resolved expectation the workflow compares and later writes. */
+    /** The resolved expectation the effect step compares and later writes. */
     expectation: string;
     /** Convenience: `current === expectation`. */
     applied: boolean;

package/dist/op/receipt-store.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"receipt-store.d.ts","sourceRoot":"","sources":["../../src/op/receipt-store.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"receipt-store.d.ts","sourceRoot":"","sources":["../../src/op/receipt-store.ts"],"names":[],"mappings":"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"}

package/dist/op/resource.d.ts

@@ -1,7 +1,21 @@
 /**
  * The Declarable resource backing an Op definition.
- * entityType: "Temporal::Op", lexicon: "temporal"
+ * entityType: "Chant::Op", lexicon: "chant"
  * Discovered automatically alongside infra files — no pipeline changes needed.
+ *
+ * An Op is chant's own verb, not a runtime's (#2118, epic #2114): the model,
+ * the executor and the ledger all live in core, and a lexicon that hosts runs
+ * is one runtime among several. The entity type says so.
  */
+export declare const OP_ENTITY_TYPE = "Chant::Op";
 export declare const OpResource: new (props: Record<string, unknown>, attributes?: Record<string, unknown>) => import("../index.js").Declarable & Record<string, string>;
+/**
+ * Is this entity an Op declaration?
+ *
+ * Duck-typed on `entityType` rather than `instanceof OpResource` for the same
+ * reason `../build.ts`'s dependency inference is: an entity can be built
+ * against a different copy of core (a linked lexicon, a child project) and
+ * still be the same declaration.
+ */
+export declare function isOpEntity(entity: unknown): boolean;
 //# sourceMappingURL=resource.d.ts.map

package/dist/op/resource.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"resource.d.ts","sourceRoot":"","sources":["../../src/op/resource.ts"],"names":[],"mappings":"AAEA;;;;GAIG;AACH,eAAO,MAAM,UAAU,gIAAiD,CAAC"}
+{"version":3,"file":"resource.d.ts","sourceRoot":"","sources":["../../src/op/resource.ts"],"names":[],"mappings":"AAEA;;;;;;;;GAQG;AACH,eAAO,MAAM,cAAc,cAAc,CAAC;AAE1C,eAAO,MAAM,UAAU,gIAA8C,CAAC;AAEtE;;;;;;;GAOG;AACH,wBAAgB,UAAU,CAAC,MAAM,EAAE,OAAO,GAAG,OAAO,CAEnD"}

package/dist/op/runtime.d.ts

@@ -0,0 +1,200 @@
+/**
+ * The op-runtime seam (#2121, epic #2114).
+ *
+ * An Op is a convergent verb; *where* it runs is a separate question from
+ * *what* it does. This module states that question once, as a provider
+ * contract, so `chant run` has one dispatch path instead of a branch per
+ * runtime. Core ships the `local` provider (./runtimes/local.ts) and never
+ * imports a hosting lexicon; a lexicon that hosts runs implements
+ * {@link OpRuntimeProvider} and hangs it off `LexiconPlugin.opRuntime`, where
+ * `chant run <op> --on <lexicon>` finds it.
+ *
+ * The record shapes below are the run ledger's (#2118): what a run wrote to
+ * `<env>/runs__<op>.jsonl` is what a provider's `status` and `log` read back,
+ * so a run's outcome survives the process that produced it. A provider with no
+ * ledger behind it (a hosting lexicon reporting a live run) fills the same
+ * shape from whatever it does know.
+ */
+import type { OpConfig } from "./types.js";
+import type { StepRecord, OpRunResult } from "./local-executor.js";
+import type { GateResolutionRecord } from "../lifecycle/gate-ledger.js";
+import type { RunComponentsOptions, RunComponentsResult } from "../components/cli-support.js";
+/**
+ * How a run ended, or that it has not. `gated` is the state a run reaches when
+ * a gate has no recorded resolution — a fact, not a wait (#2119).
+ *
+ * This is the coarse state a *runtime* reports. The ledger records the
+ * executor's own three-state outcome instead ({@link OpRunRecord.status}),
+ * which has no `running` or `cancelled`: a record is only written once a run
+ * has settled.
+ */
+export type OpRunState = "running" | "completed" | "failed" | "gated" | "cancelled";
+/** Map a settled run's ledger status onto the coarser runtime state. */
+export declare function runStateOf(status: OpRunRecord["status"]): OpRunState;
+/** One step's outcome as the run ledger keeps it — `StepRecord` minus the fields only a live renderer needs. */
+export interface OpRunStepRecord {
+    /** The activity function name, or `gate:<signal>` for a gate step. */
+    fn: string;
+    status: StepRecord["status"];
+    durationMs: number;
+    /** The step's `outcomeAttribute` capture, when it declared one. */
+    outcome?: {
+        name: string;
+        value: unknown;
+    };
+    /** Who cleared this gate step and when (#2119), for a gate the run passed. */
+    approval?: {
+        gate: string;
+        resolvedBy: string;
+        timestamp: string;
+        url?: string;
+    };
+    /** The failure message, for `status: "fail"`. */
+    error?: string;
+}
+/** One phase's steps and the verdict they add up to. */
+export interface OpRunPhaseRecord {
+    name: string;
+    /** `fail` if any step failed, `skipped` if every step was skipped, else `ok`. */
+    status: "ok" | "fail" | "skipped";
+    steps: OpRunStepRecord[];
+}
+/**
+ * A run's current state, as every runtime reports it.
+ *
+ * `records` and `result` are populated by a runtime that has the executor's
+ * own step records to hand (the local one does, for a run it just executed in
+ * this process); a runtime answering from the ledger alone omits them rather
+ * than inventing them.
+ */
+export interface OpRunStatus {
+    op: string;
+    runId: string;
+    state: OpRunState;
+    /** ISO-8601 instant the run started. */
+    startedAt: string;
+    /** ISO-8601 instant the run settled; absent while it is still running. */
+    endedAt?: string;
+    /** Per-step records, when the runtime has them. */
+    records?: StepRecord[];
+    /** The executor's own result, when the runtime is executing in this process. */
+    result?: OpRunResult;
+    /** The gate this run is waiting on, when `state` is `gated`. */
+    gate?: {
+        name: string;
+        since: string;
+    };
+    /** Free-text detail for a failed run. */
+    error?: string;
+}
+/**
+ * One immutable, settled Op run — the run ledger's line
+ * (`../lifecycle/run-ledger.ts`), and what `chant run log <op>` prints a row
+ * per.
+ *
+ * This is where a run's outcome lives now that `OpConfig` no longer carries
+ * `searchAttributes` for the generated workflow to upsert (#2118). `labels` is
+ * copied off the declaration so a reader can filter runs the way it filters
+ * declarations; `outcomes` is every `outcomeAttribute` the run captured, later
+ * steps winning over earlier ones for a repeated name, exactly as an upsert
+ * would have.
+ */
+export interface OpRunRecord {
+    /** Schema version, so an incompatible future shape is detected before being misread. */
+    version: 1;
+    /** Stable run id — the same string a pending gate fact records for this run. */
+    id: string;
+    /** The Op's name (`OpConfig.name`). */
+    op: string;
+    /** The Op's `labels.Env`, or `local` when it declares none. */
+    env: string;
+    /** ISO-8601 instant the run started. */
+    started: string;
+    /** ISO-8601 instant the run settled. */
+    ended: string;
+    /**
+     * The executor's three-state outcome. `gated` is neither success nor
+     * failure: the run reached a gate nobody has approved, recorded the fact,
+     * and stopped (#2119).
+     */
+    status: "ok" | "fail" | "gated";
+    /** The Op's own `labels`, copied at run time. */
+    labels: Record<string, string>;
+    /** Every `outcomeAttribute` the run captured, name → value. */
+    outcomes: Record<string, unknown>;
+    /** Per-phase, per-step status, in execution order. */
+    phases: OpRunPhaseRecord[];
+    /** The gate the run stopped on, for `status: "gated"`. */
+    gate?: {
+        name: string;
+        since: string;
+    };
+}
+/** An {@link OpRunRecord} before the ledger stamps its version and mints an id. */
+export type OpRunRecordInput = Omit<OpRunRecord, "version" | "id"> & {
+    id?: string;
+};
+/** A started run. `result()` settles with the run's final status. */
+export interface OpRunHandle {
+    op: string;
+    runId: string;
+    result(): Promise<OpRunStatus>;
+}
+/** What a caller hands a runtime when it starts a run. */
+export interface OpRunStartOptions {
+    /** Build-time parameter bindings, when the caller resolved any. */
+    params?: Record<string, unknown>;
+    /** Target environment (`--env`). */
+    env?: string;
+    /**
+     * `-p, --profile <name>` (#2124, restored in #2192) — the named connection
+     * profile this runtime should target. Only a runtime that has profiles
+     * reads it; the local one ignores it, and a runtime that reads it decides
+     * for itself what an unknown name means (fountain refuses it rather than
+     * falling back to its default).
+     */
+    profile?: string;
+    /** Called once per settled step, so `--progress-json` can stream. */
+    progress?: (record: StepRecord) => void;
+    /** Aborts in-flight work (Ctrl-C). */
+    signal?: AbortSignal;
+}
+/**
+ * The contract a runtime implements to host Op runs.
+ *
+ * `chant run` resolves exactly one provider per invocation — the named
+ * lexicon's for `--on <name>`, the built-in `local` one otherwise — and every
+ * subcommand calls it. A provider that cannot do something (cancel a
+ * foreground run, host components) says so by throwing a message the CLI
+ * prints verbatim, or by omitting the optional member.
+ */
+export interface OpRuntimeProvider {
+    /** How the CLI names this runtime in messages, and what `--on` matches. */
+    readonly name: string;
+    /** Start a run. Rejects with an actionable Error when it cannot. */
+    start(op: OpConfig, opts: OpRunStartOptions): Promise<OpRunHandle>;
+    /** The latest run's state, or `undefined` when this runtime has none recorded. */
+    status(op: string): Promise<OpRunStatus | undefined>;
+    /** Run history, newest first. Empty when nothing is recorded. */
+    log(op: string, opts?: {
+        limit?: number;
+    }): Promise<OpRunRecord[]>;
+    /** Latest state for each of `ops`, keyed by op name. */
+    list(ops: OpConfig[]): Promise<Map<string, OpRunStatus | undefined>>;
+    /** Cancel the active run. `force` is the CLI's confirmation, already checked. */
+    cancel(op: string, opts: {
+        force: boolean;
+    }): Promise<void>;
+    /**
+     * Wake a run whose gate has just been resolved. The ledger write is the
+     * fact and `chant approve` owns it; this is the runtime's chance to act on
+     * it. Omit when a run re-reads the ledger on its own.
+     */
+    resolveGate?(op: string, gate: string, resolution: GateResolutionRecord): Promise<void>;
+    /**
+     * Host `chant run --components`. Optional: a runtime without it refuses the
+     * flag with one line naming itself.
+     */
+    runComponents?(projectPath: string, selector: string, options: RunComponentsOptions): Promise<RunComponentsResult>;
+}
+//# sourceMappingURL=runtime.d.ts.map

package/dist/op/runtime.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runtime.d.ts","sourceRoot":"","sources":["../../src/op/runtime.ts"],"names":[],"mappings":"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"}

package/dist/op/runtimes/local.d.ts

@@ -0,0 +1,29 @@
+/**
+ * The built-in `local` op runtime (#2121, epic #2114).
+ *
+ * Wraps `runOpLocally` (../local-executor.ts) in the {@link OpRuntimeProvider}
+ * contract so `chant run <op>` has one dispatch path whether the run is hosted
+ * here or by a lexicon's `opRuntime`. Behaviour is the executor's, unchanged:
+ * activities and profiles come from the project's configured lexicons, a gate
+ * is decided against the gate ledger and ends the run `gated` (#2119), and
+ * Ctrl-C aborts through the caller's `AbortSignal`.
+ *
+ * Status, log and list read the run ledger (#2118): every run this provider
+ * starts appends one `OpRunRecord` to `<env>/runs__<op>.jsonl` on the
+ * lifecycle branch, so an answer here outlives the process that produced it
+ * and a run started by cron, CI or another machine is visible too. The
+ * in-memory history stays as the fallback for the case the ledger cannot cover
+ * — a project that is not a checkout, or a run whose append failed — so a
+ * `chant run` followed by `chant run status` in the same process still
+ * answers.
+ */
+import { type OpRuntimeProvider } from "../runtime.js";
+/**
+ * Build the local provider. `projectPath` is where `chant.config.ts` is read
+ * from to decide which cloud appliers to load — the same best-effort read the
+ * CLI did inline before the seam existed.
+ */
+export declare function createLocalOpRuntime(opts?: {
+    projectPath?: string;
+}): OpRuntimeProvider;
+//# sourceMappingURL=local.d.ts.map

package/dist/op/runtimes/local.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"local.d.ts","sourceRoot":"","sources":["../../../src/op/runtimes/local.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AASH,OAAO,EAML,KAAK,iBAAiB,EACvB,MAAM,YAAY,CAAC;AAwCpB;;;;GAIG;AACH,wBAAgB,oBAAoB,CAAC,IAAI,GAAE;IAAE,WAAW,CAAC,EAAE,MAAM,CAAA;CAAO,GAAG,iBAAiB,CAoI3F"}

package/dist/op/step-output-ref.d.ts

@@ -5,14 +5,16 @@
  * An Op's steps run in a fixed sequence chant already knows: phases in
  * order, and (within a non-parallel phase) steps in order. Today the only
  * way a value escapes a step is `outcomeAttribute`, which stringifies it
- * into a Temporal search attribute — a UI filter, not something a later
- * step can consume. `StepOutputRef` is the mechanism that lets a later
+ * into a named run outcome — something to read a run back by, not something a
+ * later step can consume. `StepOutputRef` is the mechanism that lets a later
  * step's `args` hold a *reference* to an earlier step's declared return
  * value instead.
  *
  * Deliberately a reference, not an expression: `diff.out.driftedStacks` is
- * a value placeholder the build resolves and the serializer compiles into a
- * real local variable in the generated workflow — never `diff.out.count >
+ * a value placeholder that stays inert in the Op's data until the executor
+ * substitutes the producing step's recorded result for it, just before the
+ * consuming activity is called (`../op/local-executor.ts`'s
+ * `resolveStepOutputRefs` over `resultsById`) — never `diff.out.count >
  * 0` or a `.map()` over a reference. That property (an Op is data you can
  * read and know what it does, not a program) is exactly what makes it safe
  * to add this without Ops becoming programs; see the issue's "line not to
@@ -42,10 +44,10 @@
  * Cross-contract type compatibility (chant #1950 pre-merge review, finding
  * 3): `validateStepOutputRefs` checks the producer side (a registered
  * contract with a `returns` schema, and — when `path` is set — that the path
- * resolves on it) and, separately, `validateActivitySteps`/TMP012 checks a
+ * resolves on it) and, separately, `validateActivitySteps`/OPS012 checks a
  * step's `args` against its own contract's `args` schema — but a
  * {@link StepOutputRef} sitting in `args` is a placeholder object at build
- * time, not the value it resolves to, so TMP012 skips it (see
+ * time, not the value it resolves to, so OPS012 skips it (see
  * `activity-contract.ts`'s `isStepOutputRefValue` guard) rather than
  * false-positive on it. Nothing before this compared the *consumer's*
  * declared type at that position against the *producer's* declared type at
@@ -89,8 +91,8 @@ declare const STEP_OUTPUT_REF_BRAND: unique symbol;
  * A typed reference to a prior step's declared return value. Inert by
  * construction — it carries a producer step id and an optional dot-path
  * into that producer's return schema, resolved by `chant build`
- * (`validateStepOutputRefs`) and compiled by the temporal serializer into a
- * local variable holding the awaited activity result.
+ * (`validateStepOutputRefs`) and compiled by a hosting lexicon's serializer
+ * into a local variable holding the awaited activity result.
  */
 export interface StepOutputRef {
     readonly [STEP_OUTPUT_REF_BRAND]: true;
@@ -151,11 +153,11 @@ export declare function collectStepOutputRefs(value: unknown): StepOutputRef[];
  * validateStepOutputRefs}'s checks that don't depend on a contract map, kept
  * as its own export so a caller with no contracts on hand (or that wants to
  * defend against exactly this class of bug regardless of what contracts are
- * registered) can still refuse a scope-invalid reference. The temporal
- * lexicon's serializer (`serializeOps`) is exactly this caller: TMP013 (which
- * calls the fuller {@link validateStepOutputRefs}) protects `chant build`,
- * but `serializeOps` is a public export a caller can invoke directly,
- * bypassing that lint pass — this is its own defense-in-depth.
+ * registered) can still refuse a scope-invalid reference. A hosting lexicon's
+ * own Op serializer is exactly this caller: OPS013 (which calls the fuller
+ * {@link validateStepOutputRefs}) protects `chant build`, but a serializer is
+ * a public export a caller can invoke directly, bypassing that lint pass —
+ * this is its own defense-in-depth.
  *
  * Flags:
  *  - a reference authored inside `onFailure`, or inside an `EffectStep`'s

package/dist/op/step-output-ref.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"step-output-ref.d.ts","sourceRoot":"","sources":["../../src/op/step-output-ref.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmFG;AAGH,OAAO,KAAK,EAAE,YAAY,EAAE,QAAQ,EAAmB,MAAM,SAAS,CAAC;AACvE,OAAO,EAAqD,KAAK,gBAAgB,EAAE,KAAK,qBAAqB,EAAE,MAAM,qBAAqB,CAAC;AAE3I,QAAA,MAAM,qBAAqB,eAAuC,CAAC;AAEnE;;;;;;GAMG;AACH,MAAM,WAAW,aAAa;IAC5B,QAAQ,CAAC,CAAC,qBAAqB,CAAC,EAAE,IAAI,CAAC;IACvC,QAAQ,CAAC,IAAI,EAAE,iBAAiB,CAAC;IACjC,+CAA+C;IAC/C,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB;;;;OAIG;IACH,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;CACxB;AAED;;;;;;;;GAQG;AACH,MAAM,MAAM,YAAY,CAAC,CAAC,IAAI;KAAG,CAAC,IAAI,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,GAAG,aAAa;CAAE,CAAC;AAEvE,8FAA8F;AAC9F,wBAAgB,eAAe,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,aAAa,CAEtE;AAqBD;;;;;;;;;;;GAWG;AACH,wBAAgB,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC,YAAY,EAAE,IAAI,CAAC,EAAE,IAAI,CAAC,EAAE,MAAM,GAAG,aAAa,CAQhG;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,YAAY,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC,CAU1E;AAED,8GAA8G;AAC9G,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,OAAO,GAAG,aAAa,EAAE,CAKrE;AAmED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,0BAA0B,CACxC,MAAM,EAAE,IAAI,CAAC,QAAQ,EAAE,MAAM,GAAG,QAAQ,GAAG,WAAW,CAAC,GACtD,qBAAqB,EAAE,CAqEzB;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,sBAAsB,CACpC,MAAM,EAAE,IAAI,CAAC,QAAQ,EAAE,MAAM,GAAG,QAAQ,GAAG,WAAW,CAAC,EACvD,SAAS,EAAE,WAAW,CAAC,MAAM,EAAE,gBAAgB,CAAC,GAC/C,qBAAqB,EAAE,CA4EzB"}
+{"version":3,"file":"step-output-ref.d.ts","sourceRoot":"","sources":["../../src/op/step-output-ref.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqFG;AAGH,OAAO,KAAK,EAAE,YAAY,EAAE,QAAQ,EAAmB,MAAM,SAAS,CAAC;AACvE,OAAO,EAAqD,KAAK,gBAAgB,EAAE,KAAK,qBAAqB,EAAE,MAAM,qBAAqB,CAAC;AAE3I,QAAA,MAAM,qBAAqB,eAAuC,CAAC;AAEnE;;;;;;GAMG;AACH,MAAM,WAAW,aAAa;IAC5B,QAAQ,CAAC,CAAC,qBAAqB,CAAC,EAAE,IAAI,CAAC;IACvC,QAAQ,CAAC,IAAI,EAAE,iBAAiB,CAAC;IACjC,+CAA+C;IAC/C,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB;;;;OAIG;IACH,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;CACxB;AAED;;;;;;;;GAQG;AACH,MAAM,MAAM,YAAY,CAAC,CAAC,IAAI;KAAG,CAAC,IAAI,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,GAAG,aAAa;CAAE,CAAC;AAEvE,8FAA8F;AAC9F,wBAAgB,eAAe,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,aAAa,CAEtE;AAqBD;;;;;;;;;;;GAWG;AACH,wBAAgB,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC,YAAY,EAAE,IAAI,CAAC,EAAE,IAAI,CAAC,EAAE,MAAM,GAAG,aAAa,CAQhG;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,YAAY,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC,CAU1E;AAED,8GAA8G;AAC9G,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,OAAO,GAAG,aAAa,EAAE,CAKrE;AAmED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,0BAA0B,CACxC,MAAM,EAAE,IAAI,CAAC,QAAQ,EAAE,MAAM,GAAG,QAAQ,GAAG,WAAW,CAAC,GACtD,qBAAqB,EAAE,CAqEzB;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,sBAAsB,CACpC,MAAM,EAAE,IAAI,CAAC,QAAQ,EAAE,MAAM,GAAG,QAAQ,GAAG,WAAW,CAAC,EACvD,SAAS,EAAE,WAAW,CAAC,MAAM,EAAE,gBAAgB,CAAC,GAC/C,qBAAqB,EAAE,CA4EzB"}