agentfootprint 7.18.0 → 7.19.1

package/dist/types/core/agent/AgentBuilder.d.ts

@@ -384,6 +384,11 @@ export declare class AgentBuilder {
      * Register any `Injection`. Use this for power-user / custom flavors;
      * for built-in flavors use the typed sugar (`.skill`, `.steering`,
      * `.instruction`, `.fact`).
+     *
+     * An Injection carrying `inject.messages` is refused here — the named
+     * factories refuse the same thing at declaration, and this is the one
+     * funnel every flavor passes through, so a hand-built Injection cannot
+     * reach the run by going around them. See {@link messagesSlotRefusal}.
      */
     injection(injection: Injection): this;
     /**

package/dist/types/core/agent/AgentBuilder.d.ts.map

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

package/dist/types/core/agent/memoryRecallInjections.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"memoryRecallInjections.d.ts","sourceRoot":"","sources":["../../../../src/core/agent/memoryRecallInjections.ts"],"names":[],"mappings":"AAcA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,qCAAqC,CAAC;AAO3E,0FAA0F;AAC1F,wBAAgB,sBAAsB,CACpC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC/B,SAAS,EAAE,SAAS,MAAM,EAAE,GAC3B,eAAe,EAAE,CAyBnB;AAED;;;GAGG;AACH,wBAAgB,gBAAgB,CAC9B,gBAAgB,EAAE,SAAS,eAAe,EAAE,GAAG,SAAS,EACxD,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC/B,SAAS,EAAE,SAAS,MAAM,EAAE,GAC3B,SAAS,eAAe,EAAE,CAK5B"}
+{"version":3,"file":"memoryRecallInjections.d.ts","sourceRoot":"","sources":["../../../../src/core/agent/memoryRecallInjections.ts"],"names":[],"mappings":"AAsBA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,qCAAqC,CAAC;AAO3E,0FAA0F;AAC1F,wBAAgB,sBAAsB,CACpC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC/B,SAAS,EAAE,SAAS,MAAM,EAAE,GAC3B,eAAe,EAAE,CAyBnB;AAED;;;GAGG;AACH,wBAAgB,gBAAgB,CAC9B,gBAAgB,EAAE,SAAS,eAAe,EAAE,GAAG,SAAS,EACxD,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC/B,SAAS,EAAE,SAAS,MAAM,EAAE,GAC3B,SAAS,eAAe,EAAE,CAK5B"}

package/dist/types/core/agent/stages/toolCalls.d.ts

@@ -101,6 +101,27 @@ export interface ToolCallsHandlerDeps {
      * proposed. Empty / undefined → not walked, no ledger key, no events.
      */
     readonly toolMiddleware?: readonly ToolMiddleware[];
+    /**
+     * The durable-write barrier (`core/durabilityBarrier.ts`). Asked ONCE per
+     * iteration, before any of this iteration's tools are dispatched: if the last
+     * iteration's state is still being written to a session store, wait for it.
+     *
+     * This is what bounds side-effect replay. Without it, iteration N's tools run
+     * while iteration N-1's write is in flight, so a crash can re-issue more than
+     * one iteration's worth of tool calls on replay and "how much re-executes?"
+     * has no answer. With it the answer is exactly one: the current iteration.
+     *
+     * Returns `undefined` when nobody installed a barrier — the ordinary case —
+     * and the dispatch loop then does not await at all, so an agent without a
+     * durable session composer is byte-identical in behaviour AND in timing.
+     *
+     * NOT a general extension point: the only installer is
+     * `agentfootprint/hosting`'s session writer, through a module-private
+     * WeakMap that appears on no barrel. See `core/durabilityBarrier.ts`.
+     *
+     * @internal
+     */
+    readonly awaitDurable?: () => Promise<void> | undefined;
 }
 /**
  * Build the pausable tool-call handler for the agent's chart.

package/dist/types/core/agent/stages/toolCalls.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"toolCalls.d.ts","sourceRoot":"","sources":["../../../../../src/core/agent/stages/toolCalls.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AAEH,OAAO,KAAK,EAAE,eAAe,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAC/D,OAAO,KAAK,EAAc,iBAAiB,EAAE,MAAM,4BAA4B,CAAC;AAIhF,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,kCAAkC,CAAC;AACrE,OAAO,KAAK,EAAc,kBAAkB,EAAE,MAAM,4BAA4B,CAAC;AAGjF,OAAO,EAIL,KAAK,qBAAqB,EAG3B,MAAM,kBAAkB,CAAC;AAC1B,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,+BAA+B,CAAC;AACvE,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,gBAAgB,CAAC;AAE3C,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAC;AAG7D,OAAO,EAGL,KAAK,qBAAqB,EAC3B,MAAM,0BAA0B,CAAC;AAElC,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAE9C,MAAM,WAAW,oBAAoB;IACnC;;4DAEwD;IACxD,QAAQ,CAAC,cAAc,EAAE,WAAW,CAAC,MAAM,EAAE,IAAI,CAAC,CAAC;IACnD;;qDAEiD;IACjD,QAAQ,CAAC,oBAAoB,CAAC,EAAE,YAAY,CAAC;IAC7C;;;;;OAKG;IACH,QAAQ,CAAC,iBAAiB,CAAC,EAAE,iBAAiB,CAAC;IAC/C;;4DAEwD;IACxD,QAAQ,CAAC,iBAAiB,CAAC,EAAE,iBAAiB,CAAC;IAC/C;;kEAE8D;IAC9D,QAAQ,CAAC,kBAAkB,CAAC,EAAE,kBAAkB,CAAC;IACjD;;;8EAG0E;IAC1E,QAAQ,CAAC,iBAAiB,CAAC,EAAE,qBAAqB,CAAC;IACnD;;;;;;OAMG;IACH,QAAQ,CAAC,eAAe,CAAC,EAAE,CAAC,cAAc,CAAC,EAAE,MAAM,KAAK,SAAS,MAAM,EAAE,CAAC;IAC1E;;;;;;OAMG;IACH,QAAQ,CAAC,OAAO,CAAC,EAAE,qBAAqB,CAAC;IACzC;;;;;;;OAOG;IACH,QAAQ,CAAC,cAAc,CAAC,EAAE,SAAS,cAAc,EAAE,CAAC;CACrD;AAED;;GAEG;AACH,wBAAgB,qBAAqB,CACnC,IAAI,EAAE,oBAAoB,GACzB,eAAe,CAAC,UAAU,CAAC,UAAU,CAAC,CAAC,CA60BzC"}
+{"version":3,"file":"toolCalls.d.ts","sourceRoot":"","sources":["../../../../../src/core/agent/stages/toolCalls.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AAEH,OAAO,KAAK,EAAE,eAAe,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAC/D,OAAO,KAAK,EAAc,iBAAiB,EAAE,MAAM,4BAA4B,CAAC;AAIhF,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,kCAAkC,CAAC;AACrE,OAAO,KAAK,EAAc,kBAAkB,EAAE,MAAM,4BAA4B,CAAC;AAGjF,OAAO,EAIL,KAAK,qBAAqB,EAG3B,MAAM,kBAAkB,CAAC;AAC1B,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,+BAA+B,CAAC;AACvE,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,gBAAgB,CAAC;AAE3C,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAC;AAG7D,OAAO,EAGL,KAAK,qBAAqB,EAC3B,MAAM,0BAA0B,CAAC;AAElC,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAE9C,MAAM,WAAW,oBAAoB;IACnC;;4DAEwD;IACxD,QAAQ,CAAC,cAAc,EAAE,WAAW,CAAC,MAAM,EAAE,IAAI,CAAC,CAAC;IACnD;;qDAEiD;IACjD,QAAQ,CAAC,oBAAoB,CAAC,EAAE,YAAY,CAAC;IAC7C;;;;;OAKG;IACH,QAAQ,CAAC,iBAAiB,CAAC,EAAE,iBAAiB,CAAC;IAC/C;;4DAEwD;IACxD,QAAQ,CAAC,iBAAiB,CAAC,EAAE,iBAAiB,CAAC;IAC/C;;kEAE8D;IAC9D,QAAQ,CAAC,kBAAkB,CAAC,EAAE,kBAAkB,CAAC;IACjD;;;8EAG0E;IAC1E,QAAQ,CAAC,iBAAiB,CAAC,EAAE,qBAAqB,CAAC;IACnD;;;;;;OAMG;IACH,QAAQ,CAAC,eAAe,CAAC,EAAE,CAAC,cAAc,CAAC,EAAE,MAAM,KAAK,SAAS,MAAM,EAAE,CAAC;IAC1E;;;;;;OAMG;IACH,QAAQ,CAAC,OAAO,CAAC,EAAE,qBAAqB,CAAC;IACzC;;;;;;;OAOG;IACH,QAAQ,CAAC,cAAc,CAAC,EAAE,SAAS,cAAc,EAAE,CAAC;IAEpD;;;;;;;;;;;;;;;;;;;OAmBG;IACH,QAAQ,CAAC,YAAY,CAAC,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,GAAG,SAAS,CAAC;CACzD;AAED;;GAEG;AACH,wBAAgB,qBAAqB,CACnC,IAAI,EAAE,oBAAoB,GACzB,eAAe,CAAC,UAAU,CAAC,UAAU,CAAC,CAAC,CA01BzC"}

package/dist/types/core/durabilityBarrier.d.ts

@@ -0,0 +1,62 @@
+/**
+ * core/durabilityBarrier — the one seam a durable session composer may hold
+ * inside a run, and nothing else may.
+ *
+ * ── What it is ───────────────────────────────────────────────────────────────
+ * A run's tool dispatch asks, once per ReAct iteration, "is there a durable
+ * write still in flight from the LAST iteration?" and — only if there is —
+ * waits for it before executing this iteration's tools. That is the entire
+ * mechanism. It exists because the alternative is a bound nobody can state:
+ * without it, iteration N's tools can run while iteration N-1's write is still
+ * on the wire, so a crash replays MORE than one iteration of side effects and
+ * "how much can re-execute?" has no answer.
+ *
+ * ── Why it is a WeakMap and not an option ────────────────────────────────────
+ * This is deliberately **not** a public extension point. footprintjs's stage
+ * seams and phase chain are closed here, and a general "run something between
+ * my stages" hook would be a new one — it would let any consumer inject
+ * latency, ordering and failures into a traversal, and every later feature
+ * would have to reason about it. So the barrier is keyed off the runner
+ * instance in a module-private WeakMap that appears on no barrel and no
+ * subpath: `agentfootprint/hosting`'s session writer installs it, the tool
+ * dispatch reads it, and there is no third party. Nothing in the public API
+ * surface mentions it, which is the point.
+ *
+ * ── Why it costs nothing when nobody installed one ───────────────────────────
+ * {@link pendingDurableWrite} returns `undefined` — not a resolved promise —
+ * when no barrier is installed, so the dispatch loop does not `await`, does not
+ * schedule a microtask, and produces byte-identical timing to an agent that
+ * never heard of durability.
+ *
+ * Pattern: Instance-keyed private capability (a WeakMap "friend" channel).
+ * Role: core/ layer, internal. No events, no state, no scope.
+ *
+ * @internal
+ */
+/**
+ * What a barrier answers: the write still in flight, or `undefined` when there
+ * is nothing to wait for. Returning `undefined` is the fast path and the
+ * common case — a mode that persists at run end only never installs one at all.
+ *
+ * @internal
+ */
+export type DurabilityBarrier = () => Promise<void> | undefined;
+/**
+ * Install the barrier for one runner. Returns the uninstall function; the
+ * caller owns it, exactly as `attach()` and `on()` hand back their own.
+ *
+ * Last install wins. One runner has at most one barrier because one composer
+ * owns its durability — two would be two answers to "has the last write
+ * landed?", and a run cannot honour both.
+ *
+ * @internal
+ */
+export declare function installDurabilityBarrier(owner: object, barrier: DurabilityBarrier): () => void;
+/**
+ * The durable write still in flight for this runner, or `undefined` when there
+ * is no barrier installed or nothing outstanding.
+ *
+ * @internal
+ */
+export declare function pendingDurableWrite(owner: object): Promise<void> | undefined;
+//# sourceMappingURL=durabilityBarrier.d.ts.map

package/dist/types/core/durabilityBarrier.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"durabilityBarrier.d.ts","sourceRoot":"","sources":["../../../src/core/durabilityBarrier.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AAEH;;;;;;GAMG;AACH,MAAM,MAAM,iBAAiB,GAAG,MAAM,OAAO,CAAC,IAAI,CAAC,GAAG,SAAS,CAAC;AAIhE;;;;;;;;;GASG;AACH,wBAAgB,wBAAwB,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,iBAAiB,GAAG,MAAM,IAAI,CAK9F;AAED;;;;;GAKG;AACH,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,GAAG,SAAS,CAE5E"}

package/dist/types/core/slots/buildMessagesSlot.d.ts

@@ -8,8 +8,22 @@
  *          messages accumulated over iterations.
  * Emits:   None directly; ContextRecorder sees the writes.
  *
- * Minimal scope for Phase 3e: pass-through of an input message history
- * array. Full MessageStrategy (windowing, summarizing) arrives in Phase 5.
+ * ── What this slot is, and is not ───────────────────────────────────
+ * It is the OBSERVABILITY PROJECTION of the conversation: one
+ * InjectionRecord per message, with the source, reason, role and
+ * recency a consumer needs to see what the turn was made of. It is not
+ * the wire. The request's message list comes from `scope.history`
+ * directly (`stages/callLLM.ts`), because the projection flattens away
+ * the LLM-protocol shape a provider needs — an assistant turn's
+ * `toolCalls[]`, a tool turn's `toolCallId`.
+ *
+ * Windowing and summarizing are not pending here either: they arrived in
+ * 7.16–7.17 as the window-strategy family, and they govern the window by
+ * editing `scope.history` at the loop-head window stage (`stages/window.ts`)
+ * — BEFORE this slot runs, so the projection and the wire describe the same
+ * past. Content declared for this slot is refused at the declaration site
+ * (`lib/injection-engine/messagesSlotRefusal.ts`) precisely because this
+ * slot cannot deliver it.
  */
 import type { FlowChart } from 'footprintjs';
 import type { ContextRole } from '../../events/types.js';

package/dist/types/core/slots/buildMessagesSlot.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"buildMessagesSlot.d.ts","sourceRoot":"","sources":["../../../../src/core/slots/buildMessagesSlot.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAGH,OAAO,KAAK,EAAE,SAAS,EAAc,MAAM,aAAa,CAAC;AAEzD,OAAO,KAAK,EAAkB,WAAW,EAAE,MAAM,uBAAuB,CAAC;AAMzE;;;;GAIG;AACH,MAAM,WAAW,YAAY;IAC3B,QAAQ,CAAC,IAAI,EAAE,WAAW,CAAC;IAC3B,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;CAC5B;AAED,MAAM,WAAW,kBAAkB;IACjC,0CAA0C;IAC1C,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;CAC7B;AAMD;;;;;;;;GAQG;AACH,wBAAgB,iBAAiB,CAAC,MAAM,GAAE,kBAAuB,GAAG,SAAS,CAoF5E"}
+{"version":3,"file":"buildMessagesSlot.d.ts","sourceRoot":"","sources":["../../../../src/core/slots/buildMessagesSlot.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AAGH,OAAO,KAAK,EAAE,SAAS,EAAc,MAAM,aAAa,CAAC;AAEzD,OAAO,KAAK,EAAkB,WAAW,EAAE,MAAM,uBAAuB,CAAC;AAMzE;;;;GAIG;AACH,MAAM,WAAW,YAAY;IAC3B,QAAQ,CAAC,IAAI,EAAE,WAAW,CAAC;IAC3B,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;CAC5B;AAED,MAAM,WAAW,kBAAkB;IACjC,0CAA0C;IAC1C,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;CAC7B;AAMD;;;;;;;;GAQG;AACH,wBAAgB,iBAAiB,CAAC,MAAM,GAAE,kBAAuB,GAAG,SAAS,CAyF5E"}

package/dist/types/hosting/durability.d.ts

@@ -0,0 +1,93 @@
+/**
+ * hosting/durability — how often a run's progress becomes crash-survivable.
+ *
+ * A standing agent that only writes at the end of a turn is one restart away
+ * from losing everything the turn had done: the tool calls it made, the results
+ * it read, the iterations it spent. This is the dial that decides how much of
+ * that survives, and what it costs.
+ *
+ * ── Where a mid-run write can honestly come from ─────────────────────────────
+ * From the COMMIT boundary, and nowhere else. footprintjs commits a stage's
+ * writes after the stage function returns, and committed state is
+ * immutable-after-swap — so `ScopeRecorder.onCommit` is the one moment where
+ * "what the run has agreed on so far" is a real, complete, consistent thing.
+ * Reading the agent's live state at any other moment would be reading a stage's
+ * work in progress.
+ *
+ * There is no mid-run engine checkpoint to store: footprintjs builds a
+ * `FlowchartCheckpoint` only at a pause (`getCheckpoint()` is documented as "the
+ * most recent PAUSED execution"). So what a mid-run write can carry is a
+ * CONVERSATION — the same `AgentRunCheckpoint` every finished turn stores — and
+ * that is exactly enough, because that is what the next turn resumes from.
+ *
+ * ── Why it writes on SOME commits and not all of them ────────────────────────
+ * A two-iteration turn commits about forty times. Exactly two of those commits
+ * change the conversation: `Initialize` (the user's message lands) and
+ * `ToolCalls` (an iteration's assistant turn and its tool results land). Every
+ * other commit would store bytes identical to the last write. So the trigger is
+ * "this commit wrote `history`", which is not an optimisation but the honest
+ * reading of the question: the conversation moved iff `history` moved.
+ *
+ * ── What a commit boundary actually guarantees, and what it does not ─────────
+ * It guarantees the whole stage. The agent dispatches ALL of one iteration's
+ * tool calls inside one stage body, so a crash part-way through that body stores
+ * nothing from it and a replay re-runs that iteration's tools. That is the
+ * shipped idempotency requirement, unchanged — mutating tools must be
+ * idempotent, keyed on stable call content rather than `ctx.toolCallId`. What
+ * `'sync'` adds is a BOUND on it: iteration N's tools do not start until
+ * iteration N-1's write has landed, so the replay is the current iteration and
+ * never an earlier one.
+ *
+ * Pattern: an observer (`CombinedRecorder`) for the snapshot, a serialiser for
+ * the writes, and — for `'sync'` only — a barrier the tool dispatch waits on.
+ * Role: internal to `standingAgent`. Deliberately not exported: it is how the
+ * composer keeps its promise, not a second way to write to a store.
+ */
+import type { CombinedRecorder } from 'footprintjs';
+import type { AgentRunCheckpoint } from '../core/runCheckpoint.js';
+import type { DurabilityMode } from './types.js';
+/** What the writer needs from the composer around it. */
+export interface DurableWriterOptions {
+    /** `'async'` or `'sync'`. `'exit'` never builds a writer at all. */
+    readonly mode: Exclude<DurabilityMode, 'exit'>;
+    /**
+     * The session this run belongs to, asked at every commit. `undefined` means
+     * "nothing to write to" — an anonymous request, or no run of ours in flight —
+     * and the commit is ignored.
+     */
+    readonly session: () => string | undefined;
+    /** The run id to stamp on the conversation, for correlating back to the run. */
+    readonly runId: () => string | undefined;
+    /** Where the conversation goes. */
+    readonly write: (sessionId: string, conversation: AgentRunCheckpoint) => Promise<void>;
+}
+/** The composer's handle on its own durability. */
+export interface DurableWriter {
+    /** Attach this to the agent to start observing commits. */
+    readonly recorder: CombinedRecorder;
+    /** Install the tool-dispatch barrier. Returns the uninstall function. */
+    install(agent: object): () => void;
+    /**
+     * Everything outstanding has landed.
+     *
+     * The composer awaits this before writing a run's FINAL envelope, and that
+     * ordering is load-bearing rather than tidy: an `'async'` conversation write
+     * still in flight would otherwise land AFTER the terminal envelope and
+     * overwrite it — turning a stored pause back into a plain conversation and
+     * losing the question a person was asked.
+     *
+     * **Rejects when the newest write did not land.** Fail-closed on purpose: a
+     * store that refused the run's progress has not made it durable, and both
+     * things waiting on this — the next tool call under `'sync'`, and the reply —
+     * would otherwise proceed on a promise nobody kept.
+     */
+    settle(): Promise<void>;
+}
+/**
+ * Build the writer.
+ *
+ * Under `'sync'` it also answers the tool-dispatch barrier, which is what turns
+ * "we write often" into a bound on how much can re-run.
+ */
+export declare function durableWriter(options: DurableWriterOptions): DurableWriter;
+//# sourceMappingURL=durability.d.ts.map

package/dist/types/hosting/durability.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"durability.d.ts","sourceRoot":"","sources":["../../../src/hosting/durability.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4CG;AAEH,OAAO,KAAK,EAAE,gBAAgB,EAAe,MAAM,aAAa,CAAC;AAIjE,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,0BAA0B,CAAC;AACnE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AAEjD,yDAAyD;AACzD,MAAM,WAAW,oBAAoB;IACnC,oEAAoE;IACpE,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAC,cAAc,EAAE,MAAM,CAAC,CAAC;IAC/C;;;;OAIG;IACH,QAAQ,CAAC,OAAO,EAAE,MAAM,MAAM,GAAG,SAAS,CAAC;IAC3C,gFAAgF;IAChF,QAAQ,CAAC,KAAK,EAAE,MAAM,MAAM,GAAG,SAAS,CAAC;IACzC,mCAAmC;IACnC,QAAQ,CAAC,KAAK,EAAE,CAAC,SAAS,EAAE,MAAM,EAAE,YAAY,EAAE,kBAAkB,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;CACxF;AAED,mDAAmD;AACnD,MAAM,WAAW,aAAa;IAC5B,2DAA2D;IAC3D,QAAQ,CAAC,QAAQ,EAAE,gBAAgB,CAAC;IACpC,yEAAyE;IACzE,OAAO,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,IAAI,CAAC;IACnC;;;;;;;;;;;;;OAaG;IACH,MAAM,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CACzB;AAED;;;;;GAKG;AACH,wBAAgB,aAAa,CAAC,OAAO,EAAE,oBAAoB,GAAG,aAAa,CAgI1E"}

package/dist/types/hosting/envelope.d.ts

@@ -1,17 +1,27 @@
 /**
- * hosting/envelope — pack a conversation for storage, and refuse to unpack one
- * you cannot read.
- *
- * Two functions and one rule: **an unknown format is refused by name, never
- * guessed at.** A store outlives the code that wrote to it. Somebody will
- * deploy a newer runtime, it will write a newer format, and an older instance
- * still running will read it. The only honest thing that older instance can do
- * is say which format it found, which ones it knows, and stop — because
- * "restore what I can and hope" means an agent answering from a conversation
- * that is missing whatever the older reader did not understand.
+ * hosting/envelope — pack a session for storage, and refuse to unpack one you
+ * cannot read.
+ *
+ * One rule, and everything here is a consequence of it: **an envelope this
+ * runtime cannot read is refused BY NAME, never guessed at.** A store outlives
+ * the code that wrote to it. Somebody will deploy a newer runtime, it will write
+ * a newer format, and an older instance still running will read it. The only
+ * honest thing that older instance can do is say which format it found, which
+ * ones it knows, and stop — because "restore what I can and hope" means an agent
+ * answering from a session that is missing whatever the older reader did not
+ * understand.
+ *
+ * ── Two formats, two readers, and why they refuse each other ─────────────────
+ * `readEnvelope` unpacks a CONVERSATION; `readPausedRun` unpacks a PAUSED RUN.
+ * Each refuses the other's format by name and points at its sibling. That looks
+ * fussy until you notice the alternative: one reader that quietly returned the
+ * conversation inside a paused run would hand back a session that LOOKS finished
+ * while a person is still waiting on a question nobody mentioned. That is a
+ * half-restore wearing a happy path, which is the exact failure the format field
+ * exists to prevent.
  */
 import { type AgentRunCheckpoint } from '../core/runCheckpoint.js';
-import type { CheckpointEnvelope } from './types.js';
+import type { CheckpointEnvelope, ConversationEnvelope, PausedRun, PausedRunEnvelope } from './types.js';
 /**
  * Pack a conversation checkpoint for storage.
  *
@@ -19,7 +29,28 @@ import type { CheckpointEnvelope } from './types.js';
  *   const conversation = agent.checkpoint();
  *   if (conversation) await sessions.persist(sessionId, toEnvelope(conversation));
  */
-export declare function toEnvelope(checkpoint: AgentRunCheckpoint): CheckpointEnvelope;
+export declare function toEnvelope(checkpoint: AgentRunCheckpoint): ConversationEnvelope;
+/**
+ * Pack a paused run for storage — the engine checkpoint, the conversation as of
+ * the pause, and the question it is waiting on.
+ *
+ * Store it anywhere that speaks JSON. Note what JSON does and does not preserve
+ * here: `agent.resume()` reads `checkpoint.sharedState`, which round-trips
+ * unchanged; the engine's diagnostic halves lose their explicitly-`undefined`
+ * properties, because that is what `JSON.stringify` does to them. See
+ * {@link PausedRun}.
+ *
+ * @example
+ *   const outcome = await agent.run({ message });
+ *   if (isPaused(outcome)) {
+ *     await sessions.persist(sessionId, toPausedEnvelope({
+ *       checkpoint: outcome.checkpoint,
+ *       conversation: agent.checkpoint()!,
+ *       pending: { pauseData: outcome.pauseData },
+ *     }));
+ *   }
+ */
+export declare function toPausedEnvelope(paused: PausedRun): PausedRunEnvelope;
 /**
  * Unpack a stored envelope back into a conversation checkpoint.
  *
@@ -27,8 +58,38 @@ export declare function toEnvelope(checkpoint: AgentRunCheckpoint): CheckpointEn
  * else wrote, in a format this runtime may not know, and typing the parameter
  * as the happy shape would be assuming the very thing that needs checking.
  *
- * @throws TypeError naming the format when it is one this runtime cannot read,
- *   and naming the missing field when the conversation inside is malformed.
+ * @throws TypeError naming the format when it is one this runtime cannot read;
+ *   naming the missing field when the conversation inside is malformed; and
+ *   pointing at {@link readPausedRun} when the envelope holds a paused run,
+ *   which is a session with a question outstanding rather than a conversation.
  */
 export declare function readEnvelope(envelope: unknown): AgentRunCheckpoint;
+/**
+ * Unpack a stored envelope back into a paused run.
+ *
+ * @throws TypeError naming the format when it is one this runtime cannot read;
+ *   pointing at {@link readEnvelope} when the envelope holds a plain
+ *   conversation; and naming the missing field when the paused run inside is
+ *   malformed.
+ */
+export declare function readPausedRun(envelope: unknown): PausedRun;
+/**
+ * Check that an envelope is one this runtime can read, and hand it back
+ * unchanged — without committing to which half you wanted.
+ *
+ * This is what a STORE wants. A store's job is to notice that the bytes it is
+ * about to hand over are unreadable, so the refusal names the store that
+ * produced them rather than whoever read them next; it has no business caring
+ * whether the session inside is mid-conversation or mid-question.
+ *
+ * @throws TypeError naming the format when this runtime cannot read it, or the
+ *   missing field when the payload is malformed.
+ *
+ * @example
+ *   async hydrate(sessionId) {
+ *     const stored = await myStore.get(sessionId);
+ *     return stored === undefined ? undefined : checkEnvelope(stored);
+ *   }
+ */
+export declare function checkEnvelope(envelope: unknown): CheckpointEnvelope;
 //# sourceMappingURL=envelope.d.ts.map

package/dist/types/hosting/envelope.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"envelope.d.ts","sourceRoot":"","sources":["../../../src/hosting/envelope.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,EAAsB,KAAK,kBAAkB,EAAE,MAAM,0BAA0B,CAAC;AACvF,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,YAAY,CAAC;AAKrD;;;;;;GAMG;AACH,wBAAgB,UAAU,CAAC,UAAU,EAAE,kBAAkB,GAAG,kBAAkB,CAE7E;AAED;;;;;;;;;GASG;AACH,wBAAgB,YAAY,CAAC,QAAQ,EAAE,OAAO,GAAG,kBAAkB,CAkBlE"}
+{"version":3,"file":"envelope.d.ts","sourceRoot":"","sources":["../../../src/hosting/envelope.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAEH,OAAO,EAAsB,KAAK,kBAAkB,EAAE,MAAM,0BAA0B,CAAC;AACvF,OAAO,KAAK,EACV,kBAAkB,EAClB,oBAAoB,EACpB,SAAS,EACT,iBAAiB,EAClB,MAAM,YAAY,CAAC;AAKpB;;;;;;GAMG;AACH,wBAAgB,UAAU,CAAC,UAAU,EAAE,kBAAkB,GAAG,oBAAoB,CAE/E;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,SAAS,GAAG,iBAAiB,CAErE;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,YAAY,CAAC,QAAQ,EAAE,OAAO,GAAG,kBAAkB,CAUlE;AAED;;;;;;;GAOG;AACH,wBAAgB,aAAa,CAAC,QAAQ,EAAE,OAAO,GAAG,SAAS,CAQ1D;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,aAAa,CAAC,QAAQ,EAAE,OAAO,GAAG,kBAAkB,CAOnE"}

package/dist/types/hosting/errors.d.ts

@@ -3,17 +3,21 @@
  * same words.
  *
  * A refusal that varies by adapter is a refusal nobody can write a test or a
- * runbook against. These three carry a stable `code`, name WHO refused, and say
+ * runbook against. These five carry a stable `code`, name WHO refused, and say
  * what the caller should do instead. Adapters map the codes onto whatever their
  * transport uses to say "no" — that mapping is the adapter's business and lives
  * in the adapter, never here.
  *
- * `requireCapability` is the fourth refusal and the only one that is a
+ * Note what is NOT here: a run that paused. That is unfinished work rather than
+ * a refusal, and it leaves through `reply.awaiting(...)` — its own terminal —
+ * not through an error dressed up as one.
+ *
+ * `requireCapability` is the last refusal and the only one that is a
  * programming mistake rather than a runtime condition, so it throws a plain
  * `Error`: nothing branches on "I forgot to feature-detect", it just needs to
  * say so loudly and name the adapter it is talking about.
  */
-import type { AgentHost, HostCapability } from './types.js';
+import type { AgentHost, HostCapability, PendingAsk } from './types.js';
 /**
  * Thrown when a request arrives at a host that is shutting down or shut down.
  *
@@ -44,22 +48,67 @@ export declare class ConcurrentRunError extends Error {
     constructor(sessionId: string, activeRunId?: string);
 }
 /**
- * Raised when a run paused to ask a person something and the reply cannot carry
- * a pause.
+ * Raised when a run paused to ask a person something and there is **nowhere to
+ * keep it**.
  *
  * **The run did not fail.** A pause is unfinished work: the agent stopped to ask
- * and is waiting for an answer. What cannot happen here is storing it — the
- * `'conversation-v1'` envelope holds a conversation, and a paused run is a
- * conversation plus an engine checkpoint. So nothing is written, and the
- * session keeps exactly the conversation it had before this request.
+ * and is waiting for an answer. Since 7.19 a paused run is stored as
+ * `'flowchart-v1'` and continued by a later request carrying a decision — so the
+ * one case left where a pause genuinely cannot be carried is a request with no
+ * session id. There is no session to store it under, and therefore no later
+ * request that could ever answer it.
+ *
+ * The other half of the old meaning — "the reply cannot carry a pause" — is
+ * gone: {@link HostReply.awaiting} carries it now. An adapter that has not
+ * implemented that terminal still gets its pause STORED (the store is not the
+ * transport's business) and this refusal on the wire, naming the session it can
+ * be answered on.
  */
 export declare class PauseNotCarriedError extends Error {
     readonly code: "ERR_PAUSE_NOT_CARRIED";
     /** The tool that asked, when the run recorded which one it was. */
     readonly toolName?: string;
-    /** The session whose stored conversation was left untouched. */
+    /** The session the paused run was stored under, when there was one. */
     readonly sessionId?: string;
-    constructor(toolName?: string, sessionId?: string);
+    /** Whether the paused run was stored. `false` means it is gone. */
+    readonly stored: boolean;
+    constructor(toolName?: string, sessionId?: string, stored?: boolean);
+}
+/**
+ * Thrown when a new message arrives for a session whose run is waiting on a
+ * person's decision.
+ *
+ * The message is NOT run and the pause is NOT discarded — those are the two ways
+ * this could have gone wrong. Answering the message would step over an
+ * outstanding consent gate; dropping the paused run to make room for the message
+ * would throw away work a person was asked about. So the request is refused, the
+ * pending question is named, and the session sits exactly where it was.
+ *
+ * Answer it by sending the same session a request carrying
+ * {@link HostRequest.decision}.
+ */
+export declare class AwaitingDecisionError extends Error {
+    readonly code: "ERR_AWAITING_DECISION";
+    /** The session that is waiting. */
+    readonly sessionId: string;
+    /** What it is waiting on — the same payload `reply.awaiting()` delivered. */
+    readonly pending: PendingAsk;
+    constructor(sessionId: string, pending: PendingAsk);
+}
+/**
+ * Thrown when a request carries a decision for a session that is not waiting on
+ * one.
+ *
+ * Usually a duplicate delivery: the run was already continued, or already
+ * answered, and the same decision arrived twice. Running it as an ordinary
+ * message would put a raw approval into the conversation as if the user had
+ * typed it, so it is refused by name instead.
+ */
+export declare class NoPendingAskError extends Error {
+    readonly code: "ERR_NO_PENDING_ASK";
+    /** The session the decision was addressed to. */
+    readonly sessionId: string;
+    constructor(sessionId: string);
 }
 /**
  * Assert that a host can do something, and throw a corrective error naming the

package/dist/types/hosting/errors.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../../src/hosting/errors.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AAE5D;;;;;GAKG;AACH,qBAAa,eAAgB,SAAQ,KAAK;IACxC,QAAQ,CAAC,IAAI,oBAA8B;IAC3C,6BAA6B;IAC7B,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;gBAEd,QAAQ,EAAE,MAAM;CAS7B;AAED;;;;;;;;GAQG;AACH,qBAAa,kBAAmB,SAAQ,KAAK;IAC3C,QAAQ,CAAC,IAAI,uBAAiC;IAC9C,gDAAgD;IAChD,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,mEAAmE;IACnE,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAC;gBAElB,SAAS,EAAE,MAAM,EAAE,WAAW,CAAC,EAAE,MAAM;CAapD;AAED;;;;;;;;;GASG;AACH,qBAAa,oBAAqB,SAAQ,KAAK;IAC7C,QAAQ,CAAC,IAAI,0BAAoC;IACjD,mEAAmE;IACnE,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAC3B,gEAAgE;IAChE,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;gBAEhB,QAAQ,CAAC,EAAE,MAAM,EAAE,SAAS,CAAC,EAAE,MAAM;CAiBlD;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,SAAS,EAAE,UAAU,EAAE,cAAc,GAAG,IAAI,CASnF"}
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../../src/hosting/errors.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,cAAc,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAExE;;;;;GAKG;AACH,qBAAa,eAAgB,SAAQ,KAAK;IACxC,QAAQ,CAAC,IAAI,oBAA8B;IAC3C,6BAA6B;IAC7B,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;gBAEd,QAAQ,EAAE,MAAM;CAS7B;AAED;;;;;;;;GAQG;AACH,qBAAa,kBAAmB,SAAQ,KAAK;IAC3C,QAAQ,CAAC,IAAI,uBAAiC;IAC9C,gDAAgD;IAChD,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,mEAAmE;IACnE,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAC;gBAElB,SAAS,EAAE,MAAM,EAAE,WAAW,CAAC,EAAE,MAAM;CAapD;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,qBAAa,oBAAqB,SAAQ,KAAK;IAC7C,QAAQ,CAAC,IAAI,0BAAoC;IACjD,mEAAmE;IACnE,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAC3B,uEAAuE;IACvE,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;IAC5B,mEAAmE;IACnE,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAC;gBAEb,QAAQ,CAAC,EAAE,MAAM,EAAE,SAAS,CAAC,EAAE,MAAM,EAAE,MAAM,UAAQ;CAsBlE;AAED;;;;;;;;;;;;GAYG;AACH,qBAAa,qBAAsB,SAAQ,KAAK;IAC9C,QAAQ,CAAC,IAAI,0BAAoC;IACjD,mCAAmC;IACnC,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,6EAA6E;IAC7E,QAAQ,CAAC,OAAO,EAAE,UAAU,CAAC;gBAEjB,SAAS,EAAE,MAAM,EAAE,OAAO,EAAE,UAAU;CAgBnD;AAED;;;;;;;;GAQG;AACH,qBAAa,iBAAkB,SAAQ,KAAK;IAC1C,QAAQ,CAAC,IAAI,uBAAiC;IAC9C,iDAAiD;IACjD,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;gBAEf,SAAS,EAAE,MAAM;CAW9B;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,SAAS,EAAE,UAAU,EAAE,cAAc,GAAG,IAAI,CASnF"}

package/dist/types/hosting/httpHost.d.ts

@@ -28,7 +28,7 @@
  * Pattern: Template method via configuration (Strategy on the wire format).
  * Everything HTTP lives here and in the wires; `types.ts` knows none of it.
  */
-import type { AgentHost, HostCapability, HostHandle, HostHandler } from './types.js';
+import type { AgentHost, HostCapability, HostHandle, HostHandler, PendingAsk } from './types.js';
 /** Everything a {@link HttpWire} may read when pulling a request apart. */
 export interface HttpRequestFacts {
     /** The parsed JSON body, or `{}` for an empty one. */
@@ -57,6 +57,12 @@ export interface HttpWire {
     readRequest(facts: HttpRequestFacts): {
         readonly input: string;
         readonly sessionId?: string;
+        /**
+         * A person's answer to an outstanding question, when this request carries
+         * one. Its presence is what makes a request a RESUME rather than a new
+         * message, so a wire that never returns it can only ever start new turns.
+         */
+        readonly decision?: unknown;
     };
     /** Body for a health probe. `uptimeMs` is how long this host has been serving. */
     health(uptimeMs: number): unknown;
@@ -66,6 +72,16 @@ export interface HttpWire {
     failure(message: string, code?: string): unknown;
     /** Body for one streamed piece, when the caller asked for Server-Sent Events. */
     chunk(text: string): unknown;
+    /**
+     * Body for a reply that is WAITING on a person — the run paused, it is stored,
+     * and a later request carrying a decision continues it.
+     *
+     * Optional so a wire written before this terminal existed keeps compiling and
+     * keeps working. A host whose wire has no `awaiting` cannot describe the
+     * question, so it reports the named refusal instead — the run is still stored
+     * either way.
+     */
+    awaiting?(pending: PendingAsk): unknown;
 }
 /** Options for {@link httpHost}. */
 export interface HttpHostOptions {

package/dist/types/hosting/httpHost.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"httpHost.d.ts","sourceRoot":"","sources":["../../../src/hosting/httpHost.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AAMH,OAAO,KAAK,EAAE,SAAS,EAAE,cAAc,EAAE,UAAU,EAAE,WAAW,EAAa,MAAM,YAAY,CAAC;AAEhG,2EAA2E;AAC3E,MAAM,WAAW,gBAAgB;IAC/B,sDAAsD;IACtD,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;IACjD,oFAAoF;IACpF,QAAQ,CAAC,OAAO,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;IACnD,wCAAwC;IACxC,QAAQ,CAAC,KAAK,EAAE,eAAe,CAAC;CACjC;AAED;;;;;;;GAOG;AACH,MAAM,WAAW,QAAQ;IACvB;;;;;;OAMG;IACH,WAAW,CAAC,KAAK,EAAE,gBAAgB,GAAG;QAAE,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;IAC9F,kFAAkF;IAClF,MAAM,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC;IAClC,uCAAuC;IACvC,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC;IAChC,0FAA0F;IAC1F,OAAO,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC;IACjD,iFAAiF;IACjF,KAAK,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC;CAC9B;AAED,oCAAoC;AACpC,MAAM,WAAW,eAAe;IAC9B;;;OAGG;IACH,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,yCAAyC;IACzC,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAC;IACxB;;;;;OAKG;IACH,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,uEAAuE;IACvE,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,oEAAoE;IACpE,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IACvB,8CAA8C;IAC9C,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAC3B,6EAA6E;IAC7E,QAAQ,CAAC,YAAY,CAAC,EAAE,SAAS,cAAc,EAAE,CAAC;CACnD;AAED,2DAA2D;AAC3D,MAAM,WAAW,cAAe,SAAQ,UAAU;IAChD,qEAAqE;IACrE,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB,yEAAyE;IACzE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;CACvB;AAED,oDAAoD;AACpD,MAAM,WAAW,QAAS,SAAQ,SAAS;IACzC,KAAK,CAAC,OAAO,EAAE,WAAW,GAAG,OAAO,CAAC,cAAc,CAAC,CAAC;CACtD;AAmBD;;;;;;GAMG;AACH,wBAAgB,QAAQ,CAAC,OAAO,EAAE,eAAe,GAAG,QAAQ,CAsE3D;AA+HD;;;;;;GAMG;AACH,wBAAgB,WAAW,CACzB,KAAK,EAAE,gBAAgB,EACvB,IAAI,EAAE,MAAM,EACZ,GAAG,SAAS,EAAE,MAAM,EAAE,GACrB,MAAM,GAAG,SAAS,CAMpB"}
+{"version":3,"file":"httpHost.d.ts","sourceRoot":"","sources":["../../../src/hosting/httpHost.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AAMH,OAAO,KAAK,EACV,SAAS,EACT,cAAc,EACd,UAAU,EACV,WAAW,EAEX,UAAU,EACX,MAAM,YAAY,CAAC;AAEpB,2EAA2E;AAC3E,MAAM,WAAW,gBAAgB;IAC/B,sDAAsD;IACtD,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;IACjD,oFAAoF;IACpF,QAAQ,CAAC,OAAO,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;IACnD,wCAAwC;IACxC,QAAQ,CAAC,KAAK,EAAE,eAAe,CAAC;CACjC;AAED;;;;;;;GAOG;AACH,MAAM,WAAW,QAAQ;IACvB;;;;;;OAMG;IACH,WAAW,CAAC,KAAK,EAAE,gBAAgB,GAAG;QACpC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;QACvB,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;QAC5B;;;;WAIG;QACH,QAAQ,CAAC,QAAQ,CAAC,EAAE,OAAO,CAAC;KAC7B,CAAC;IACF,kFAAkF;IAClF,MAAM,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC;IAClC,uCAAuC;IACvC,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC;IAChC,0FAA0F;IAC1F,OAAO,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC;IACjD,iFAAiF;IACjF,KAAK,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC;IAC7B;;;;;;;;OAQG;IACH,QAAQ,CAAC,CAAC,OAAO,EAAE,UAAU,GAAG,OAAO,CAAC;CACzC;AAED,oCAAoC;AACpC,MAAM,WAAW,eAAe;IAC9B;;;OAGG;IACH,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,yCAAyC;IACzC,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAC;IACxB;;;;;OAKG;IACH,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,uEAAuE;IACvE,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,oEAAoE;IACpE,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IACvB,8CAA8C;IAC9C,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAC3B,6EAA6E;IAC7E,QAAQ,CAAC,YAAY,CAAC,EAAE,SAAS,cAAc,EAAE,CAAC;CACnD;AAED,2DAA2D;AAC3D,MAAM,WAAW,cAAe,SAAQ,UAAU;IAChD,qEAAqE;IACrE,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB,yEAAyE;IACzE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;CACvB;AAED,oDAAoD;AACpD,MAAM,WAAW,QAAS,SAAQ,SAAS;IACzC,KAAK,CAAC,OAAO,EAAE,WAAW,GAAG,OAAO,CAAC,cAAc,CAAC,CAAC;CACtD;AA8BD;;;;;;GAMG;AACH,wBAAgB,QAAQ,CAAC,OAAO,EAAE,eAAe,GAAG,QAAQ,CAsE3D;AAyJD;;;;;;GAMG;AACH,wBAAgB,WAAW,CACzB,KAAK,EAAE,gBAAgB,EACvB,IAAI,EAAE,MAAM,EACZ,GAAG,SAAS,EAAE,MAAM,EAAE,GACrB,MAAM,GAAG,SAAS,CAMpB"}

package/dist/types/hosting/index.d.ts

@@ -33,9 +33,12 @@
  *     another. Two paths and five body shapes are all a second HTTP adapter
  *     re-decides.
  *   • `memorySessions()` — conversations in a Map, for tests and local dev.
- *   • `standingAgent({ agent, sessions, host })` — the composer.
+ *   • `standingAgent({ agent, sessions, host, durability? })` — the composer.
  *   • `toEnvelope` / `readEnvelope` — pack a conversation, and refuse by name to
  *     unpack a format this runtime does not know.
+ *   • `toPausedEnvelope` / `readPausedRun` — the same for a run that stopped to
+ *     ask a person something (`'flowchart-v1'`). `checkEnvelope` validates
+ *     either without committing to which half you wanted — what a STORE wants.
  *   • `requireCapability` — feature-detection with teeth.
  *
  * @example  An agent that stays up and remembers
@@ -54,8 +57,8 @@ export type { NodeHost, NodeHostHandle, NodeHostOptions } from './nodeHost.js';
 export { httpHost, headerValue } from './httpHost.js';
 export type { HttpHost, HttpHostHandle, HttpHostOptions, HttpRequestFacts, HttpWire, } from './httpHost.js';
 export { memorySessions } from './memorySessions.js';
-export { toEnvelope, readEnvelope } from './envelope.js';
+export { toEnvelope, toPausedEnvelope, readEnvelope, readPausedRun, checkEnvelope, } from './envelope.js';
 export { standingAgent } from './standingAgent.js';
-export { requireCapability, HostClosedError, ConcurrentRunError, PauseNotCarriedError, } from './errors.js';
-export type { AgentHost, CheckpointEnvelope, ConcurrentInvokePolicy, HostCapability, HostHandle, HostHandler, HostReply, HostRequest, SessionLifecycle, StandingAgentOptions, WakeReason, } from './types.js';
+export { requireCapability, HostClosedError, ConcurrentRunError, PauseNotCarriedError, AwaitingDecisionError, NoPendingAskError, } from './errors.js';
+export type { AgentHost, CheckpointEnvelope, ConcurrentInvokePolicy, ConversationEnvelope, DurabilityMode, HostCapability, HostHandle, HostHandler, HostReply, HostRequest, PausedRun, PausedRunEnvelope, PendingAsk, SessionLifecycle, StandingAgentOptions, WakeReason, } from './types.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/types/hosting/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/hosting/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkDG;AAEH,OAAO,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AACnD,YAAY,EAAE,QAAQ,EAAE,cAAc,EAAE,eAAe,EAAE,MAAM,eAAe,CAAC;AAE/E,OAAO,EAAE,QAAQ,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AACtD,YAAY,EACV,QAAQ,EACR,cAAc,EACd,eAAe,EACf,gBAAgB,EAChB,QAAQ,GACT,MAAM,eAAe,CAAC;AAEvB,OAAO,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AACrD,OAAO,EAAE,UAAU,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC;AACzD,OAAO,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AAEnD,OAAO,EACL,iBAAiB,EACjB,eAAe,EACf,kBAAkB,EAClB,oBAAoB,GACrB,MAAM,aAAa,CAAC;AAErB,YAAY,EACV,SAAS,EACT,kBAAkB,EAClB,sBAAsB,EACtB,cAAc,EACd,UAAU,EACV,WAAW,EACX,SAAS,EACT,WAAW,EACX,gBAAgB,EAChB,oBAAoB,EACpB,UAAU,GACX,MAAM,YAAY,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/hosting/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqDG;AAEH,OAAO,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AACnD,YAAY,EAAE,QAAQ,EAAE,cAAc,EAAE,eAAe,EAAE,MAAM,eAAe,CAAC;AAE/E,OAAO,EAAE,QAAQ,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AACtD,YAAY,EACV,QAAQ,EACR,cAAc,EACd,eAAe,EACf,gBAAgB,EAChB,QAAQ,GACT,MAAM,eAAe,CAAC;AAEvB,OAAO,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AACrD,OAAO,EACL,UAAU,EACV,gBAAgB,EAChB,YAAY,EACZ,aAAa,EACb,aAAa,GACd,MAAM,eAAe,CAAC;AACvB,OAAO,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AAEnD,OAAO,EACL,iBAAiB,EACjB,eAAe,EACf,kBAAkB,EAClB,oBAAoB,EACpB,qBAAqB,EACrB,iBAAiB,GAClB,MAAM,aAAa,CAAC;AAErB,YAAY,EACV,SAAS,EACT,kBAAkB,EAClB,sBAAsB,EACtB,oBAAoB,EACpB,cAAc,EACd,cAAc,EACd,UAAU,EACV,WAAW,EACX,SAAS,EACT,WAAW,EACX,SAAS,EACT,iBAAiB,EACjB,UAAU,EACV,gBAAgB,EAChB,oBAAoB,EACpB,UAAU,GACX,MAAM,YAAY,CAAC"}

package/dist/types/hosting/nodeHost.d.ts

@@ -7,8 +7,10 @@
  *     reply.complete(await answer(request.input));
  *   });
  *
- * Two routes: `POST /invoke` takes `{ input, sessionId? }` and answers
- * `{ output }`; `GET /health` answers `{ status: 'ok' }`. Both paths are
+ * Two routes: `POST /invoke` takes `{ input, sessionId?, decision? }` and
+ * answers `{ output }` — or `{ awaiting }` with a **202** when the run stopped
+ * to ask a person something, which a later `POST` carrying `decision` continues;
+ * `GET /health` answers `{ status: 'ok' }`. Both paths are
  * options, because the paths are the part most likely to be dictated to you by
  * whatever is in front of the process — a load balancer, a container contract,
  * a colleague's convention. A path is a deployment detail, so it is a knob

package/dist/types/hosting/nodeHost.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"nodeHost.d.ts","sourceRoot":"","sources":["../../../src/hosting/nodeHost.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AAEH,OAAO,EAAY,KAAK,QAAQ,EAAE,KAAK,cAAc,EAAE,KAAK,QAAQ,EAAE,MAAM,eAAe,CAAC;AAE5F,oCAAoC;AACpC,MAAM,WAAW,eAAe;IAC9B,oEAAoE;IACpE,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IACvB,8CAA8C;IAC9C,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAC3B,sDAAsD;IACtD,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC;IAC7B,6DAA6D;IAC7D,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC;CAC9B;AAED;;;;GAIG;AACH,MAAM,MAAM,cAAc,GAAG,cAAc,CAAC;AAE5C,qDAAqD;AACrD,MAAM,MAAM,QAAQ,GAAG,QAAQ,CAAC;AAIhC;;;;;;;GAOG;AACH,eAAO,MAAM,QAAQ,EAAE,QAatB,CAAC;AAEF;;;;;;;;;;;GAWG;AACH,wBAAgB,QAAQ,CAAC,OAAO,GAAE,eAAoB,GAAG,QAAQ,CAWhE"}
+{"version":3,"file":"nodeHost.d.ts","sourceRoot":"","sources":["../../../src/hosting/nodeHost.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AAEH,OAAO,EAAY,KAAK,QAAQ,EAAE,KAAK,cAAc,EAAE,KAAK,QAAQ,EAAE,MAAM,eAAe,CAAC;AAE5F,oCAAoC;AACpC,MAAM,WAAW,eAAe;IAC9B,oEAAoE;IACpE,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IACvB,8CAA8C;IAC9C,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAC3B,sDAAsD;IACtD,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC;IAC7B,6DAA6D;IAC7D,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC;CAC9B;AAED;;;;GAIG;AACH,MAAM,MAAM,cAAc,GAAG,cAAc,CAAC;AAE5C,qDAAqD;AACrD,MAAM,MAAM,QAAQ,GAAG,QAAQ,CAAC;AAIhC;;;;;;;GAOG;AACH,eAAO,MAAM,QAAQ,EAAE,QAsBtB,CAAC;AAEF;;;;;;;;;;;GAWG;AACH,wBAAgB,QAAQ,CAAC,OAAO,GAAE,eAAoB,GAAG,QAAQ,CAWhE"}