@owlmeans/llm-common 0.1.18-rc.12 → 0.1.18-rc.13

package/README.md

@@ -10,6 +10,8 @@ persistence/queue consumer need to name the same things.
 - The inheritable `ModelPolicy` and its JSON-safe `ModelConfigPatch` / `ModelConfigOverride`
 - `ExecutionState` / `TaskExecutionState` — what an execution looks like once its
   collaborators (models, file access, live handles) are stripped off
+- The inquiry contracts — one question put to a person mid-run, the answer that comes back,
+  and the pure helpers every layer reads an answer through
 - Spectator record contracts and the `NullCapture` diagnostic
 - No `@langchain/*` runtime dependency: safe to import from a browser bundle, a queue
   worker, or a package that must not pull an inference SDK
@@ -63,12 +65,13 @@ export interface MyExecutionState extends ExecutionState {
 
 | Export | Description |
 |--------|-------------|
-| `ModelProvider` | `OpenAI` · `Anthropic` · `Compatible` — each maps to an `LlmPlugin` type in `@owlmeans/llm`. |
+| `ModelProvider` | `OpenAI` · `Anthropic` · `Compatible` · `Delegated` — each maps to an `LlmPlugin` type in `@owlmeans/llm`. `Delegated` talks to no provider: the call is handed to a transport the application seated (`@owlmeans/llm-delegate`). |
 | `ExecutionLevel` | `Project` → `Task` → `Helper`; an execution is refined downward only. |
 | `ExecutionEffort` | `Economy` · `Standard` · `High` · `Max` — the one "how hard should this run" axis. |
 | `StructuredMode` | `Native` (provider JSON-schema mode) vs `Tool` (forced tool call). |
 | `SpectatorContentType` | `Text` · `Json` · `ToolCall`. |
 | `SPECTATOR_GENERAL` | Default entry kind for consumers that do not classify calls. |
+| `DEFAULT_INQUIRY_ANSWER_CHARS` (2000) · `DEFAULT_INQUIRY_OPTIONS` (12) · `INQUIRY_STATE_TEXT_CHARS` (200) · `CONFIRM_YES` / `CONFIRM_NO` | The one ceiling on a stored answer, the point past which a choice is not a question, what a pipeline state keeps of an answer's prose, and the two confirmation values. Never introduce a second copy of any of them. |
 
 ### Types
 
@@ -82,6 +85,9 @@ export interface MyExecutionState extends ExecutionState {
 | `TaskExecutionState` | Adds `phase` / `completed` / `cursor` / `data` for checkpoint & resume. |
 | `LlmPurpose` | `{ type?, dedication? }` — observability metadata carried on every call. |
 | `NullCapture`, `NullKind` | Full diagnostics of a call that returned nothing usable. |
+| `Inquiry`, `InquiryAnswer`, `InquiryOption`, `InquiryTransport`, `InquiryConfig` | One question put to a person while a run is in flight, and its answer. `ExecutionState.inquiry` carries the channel and the policy, so a resumed run asks the same way. |
+| `InquiryKind`, `InquiryPolicy` | `choice` / `text` / `confirm`; `ask` / `default` / `refuse` — no configuration means `default`, so a run nobody is watching never blocks on a question. |
+| `defaultAnswerFor`, `answeredWith`, `isDeclined`, `capAnswer`, `stateAnswerOf`, `renderInquiry` | The ONE reading of an answer every layer shares. `capAnswer` cuts prose only and reports the cut; a `value` is the decision itself and is never shortened. |
 | `SpectatorArgument`, `SpectatorEntry`, `SpectatorEntryLogged`, `SpectatorEntryMessage` | The record format an observability sink stores. |
 
 ## Related
@@ -96,7 +102,7 @@ This package ships embedded agent skills under `agent-meta/`. After installing y
 your project's skill store (`.agents/skills/`):
 
 ```sh
-npx @owlmeans/agent-skills@^0.1.18-rc.12
+npx @owlmeans/agent-skills@^0.1.18-rc.13
 ```
 
 The embedded files are version-matched to this package release. Do not edit them

package/agent-meta/manifest.json

@@ -1,8 +1,8 @@
 {
   "schemaVersion": 2,
   "package": "@owlmeans/llm-common",
-  "version": "0.1.18-rc.12",
-  "generatedAt": "2026-09-04T22:43:25.447Z",
+  "version": "0.1.18-rc.13",
+  "generatedAt": "2026-09-10T18:54:42.500Z",
   "canonicalRepo": "https://github.com/owlmeans/common",
   "entries": [
     {

package/agent-meta/skills/llm-common/SKILL.md

@@ -8,7 +8,7 @@ user-invocable: false
 # @owlmeans/llm-common
 
 **Layer:** Core
-**Install:** `"@owlmeans/llm-common": "^0.1.18-rc.12"` in `dependencies`
+**Install:** `"@owlmeans/llm-common": "^0.1.18-rc.13"` in `dependencies`
 
 The contracts half of the LLM stack. **No `@langchain/*` runtime dependency** — importable
 from a browser bundle, a queue worker, or any package that must not pull an inference SDK.
@@ -36,6 +36,10 @@ The dependency direction is one-way: a domain contracts package extends these;
 | `CacheTtl`, `CacheUsage` | `'5m' \| '1h'`; normalized prompt-cache accounting. |
 | `LlmFileProvider`, `FileProviderRef`, `resolveFileProvider` | The file contract prompt plugins work against — four members, every path relative to the host's project root. `FileProviderRef` accepts the provider or a thunk returning one; `resolveFileProvider` unwraps whichever form arrived, or `undefined`. |
 | `NullCapture`, `NullKind` | Full diagnostics of a call that returned nothing usable. |
+| `Inquiry`, `InquiryAnswer`, `InquiryOption`, `InquiryTransport`, `InquiryConfig` | One question put to a person mid-run, and the answer that comes back. |
+| `InquiryKind`, `InquiryPolicy` | `choice`/`text`/`confirm`; `ask`/`default`/`refuse`. |
+| `DEFAULT_INQUIRY_ANSWER_CHARS`, `DEFAULT_INQUIRY_OPTIONS`, `INQUIRY_STATE_TEXT_CHARS`, `CONFIRM_YES`, `CONFIRM_NO` | The one answer ceiling, the option ceiling, what a pipeline state may hold of an answer's prose, and the two confirmation values. |
+| `defaultAnswerFor`, `answeredWith`, `capAnswer`, `isDeclined`, `stateAnswerOf`, `renderInquiry` | The pure reading of an inquiry and its answer, shared by every layer. |
 | `SpectatorArgument`, `SpectatorEntry`, `SpectatorEntryLogged`, `SpectatorEntryMessage` | What an observability sink stores. |
 
 ## `LlmFileProvider` — what a host must supply
@@ -86,12 +90,35 @@ export interface MyTaskState
 `SpectatorEntry.kind` is an open `string` for the same reason: declare your own kind enum
 and narrow it on your own entry interface.
 
+## Inquiry — the contracts half
+
+`src/inquiry/` carries the human-in-the-loop primitive's serializable half: the question, the
+answer, the transport interface, and the pure helpers every layer reads an answer through.
+`ExecutionState.inquiry?: InquiryConfig` says how one run may put a question to a person, and it is
+STATE rather than a collaborator — a resumed run must ask through the same channel under the same
+policy, so it travels into every snapshot (it is deliberately absent from `@owlmeans/llm`'s
+`COLLABORATOR_KEYS`).
+
+`DEFAULT_INQUIRY_ANSWER_CHARS` is the ONE ceiling on a stored answer; every other layer references
+it rather than choosing its own, and `capAnswer` reports the cut (`truncated: true`) instead of
+truncating silently. It cuts the PROSE only: a `value` is the decision itself, so a shortened one
+matches no option and is passed through whole with `truncated` raised on it.
+`INQUIRY_STATE_TEXT_CHARS` is the much smaller amount a resumable pipeline
+state may hold of an answer's free text (`stateAnswerOf`, the other writer of `truncated`) — a
+state is keys and markers, not prose.
+The primitive end to end, including the runtime registry and the pipeline park: [[inquiry]].
+
 ## What must NOT go here
 
 Anything that cannot survive `JSON.stringify` or that needs an inference SDK: model
 instances, credentials, file handles, callbacks, `ModelConfig` (it carries `secret` /
 `headers` / `fallback` — that lives in `@owlmeans/llm`).
 
+## Tests
+
+`bun test ./tests` in the package. Contracts and enums are not tested (nothing to assert); the
+specs cover the pure helpers that carry a decision — `tests/inquiry.spec.ts`.
+
 ## Depends On
 
 Nothing at runtime. `@langchain/core` is a **dev** dependency, for the `UsageMetadata` type
@@ -100,3 +127,4 @@ on a spectator message only.
 ## Related
 
 - [[llm]] — the runtime that implements these contracts
+- [[inquiry]] — the human-in-the-loop primitive whose contracts live here

package/build/consts.d.ts

@@ -9,7 +9,21 @@ export declare enum ModelProvider {
     /** Anthropic messages API. */
     Anthropic = "anthropic",
     /** Any OpenAI-compatible endpoint — OpenRouter, HuggingFace router, Together, vLLM, … */
-    Compatible = "compatible"
+    Compatible = "compatible",
+    /**
+     * No endpoint at all: the call is handed to whoever holds the execution.
+     *
+     * A delegated model does not talk to a provider. It packages the call — the system prompt, the
+     * conversation, the tools or the schema — and hands it to a transport the application seated,
+     * which carries it to something outside this process entirely: a coding agent driving the
+     * application through a connector, a human, a test. The answer comes back the same way and is
+     * turned into a completion the rest of the stack cannot tell apart from a provider's.
+     *
+     * It exists so that "who performs this call" can be a property of the SESSION rather than of the
+     * code: the same pipeline, the same prompts and the same retry rules, billed to somebody else's
+     * model.
+     */
+    Delegated = "delegated"
 }
 /**
  * Refinement level of an execution. An execution is refined downward only:

package/build/consts.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"consts.d.ts","sourceRoot":"","sources":["../src/consts.ts"],"names":[],"mappings":"AACA;;;;GAIG;AACH,oBAAY,aAAa;IACvB,yFAAyF;IACzF,MAAM,WAAW;IACjB,8BAA8B;IAC9B,SAAS,cAAc;IACvB,yFAAyF;IACzF,UAAU,eAAe;CAC1B;AAED;;;GAGG;AACH,oBAAY,cAAc;IACxB,OAAO,YAAY;IACnB,IAAI,SAAS;IACb,MAAM,WAAW;CAClB;AAED;;;;GAIG;AACH,oBAAY,eAAe;IACzB,OAAO,YAAY;IACnB,QAAQ,aAAa;IACrB,IAAI,SAAS;IACb,GAAG,QAAQ;CACZ;AAED;;;;;;;;;GASG;AACH,oBAAY,cAAc;IACxB,MAAM,WAAW;IACjB,IAAI,SAAS;CACd;AAED,0DAA0D;AAC1D,oBAAY,oBAAoB;IAC9B,IAAI,SAAS;IACb,IAAI,SAAS;IACb,QAAQ,cAAc;CACvB;AAED,mFAAmF;AACnF,eAAO,MAAM,iBAAiB,YAAY,CAAA;AAE1C;;;;;;;;;;;;;;GAcG;AACH,oBAAY,WAAW;IACrB,IAAI,SAAS;IACb,MAAM,WAAW;IACjB,QAAQ,aAAa;IACrB,OAAO,YAAY;CACpB;AAED;;;;GAIG;AACH,eAAO,MAAM,kBAAkB,EAAE,SAAS,WAAW,EAK3C,CAAA;AAEV,+EAA+E;AAC/E,eAAO,MAAM,mBAAmB,MAAM,CAAA;AAEtC;;;;;GAKG;AACH,eAAO,MAAM,YAAY,YAAY,CAAA"}
+{"version":3,"file":"consts.d.ts","sourceRoot":"","sources":["../src/consts.ts"],"names":[],"mappings":"AACA;;;;GAIG;AACH,oBAAY,aAAa;IACvB,yFAAyF;IACzF,MAAM,WAAW;IACjB,8BAA8B;IAC9B,SAAS,cAAc;IACvB,yFAAyF;IACzF,UAAU,eAAe;IACzB;;;;;;;;;;;;OAYG;IACH,SAAS,cAAc;CACxB;AAED;;;GAGG;AACH,oBAAY,cAAc;IACxB,OAAO,YAAY;IACnB,IAAI,SAAS;IACb,MAAM,WAAW;CAClB;AAED;;;;GAIG;AACH,oBAAY,eAAe;IACzB,OAAO,YAAY;IACnB,QAAQ,aAAa;IACrB,IAAI,SAAS;IACb,GAAG,QAAQ;CACZ;AAED;;;;;;;;;GASG;AACH,oBAAY,cAAc;IACxB,MAAM,WAAW;IACjB,IAAI,SAAS;CACd;AAED,0DAA0D;AAC1D,oBAAY,oBAAoB;IAC9B,IAAI,SAAS;IACb,IAAI,SAAS;IACb,QAAQ,cAAc;CACvB;AAED,mFAAmF;AACnF,eAAO,MAAM,iBAAiB,YAAY,CAAA;AAE1C;;;;;;;;;;;;;;GAcG;AACH,oBAAY,WAAW;IACrB,IAAI,SAAS;IACb,MAAM,WAAW;IACjB,QAAQ,aAAa;IACrB,OAAO,YAAY;CACpB;AAED;;;;GAIG;AACH,eAAO,MAAM,kBAAkB,EAAE,SAAS,WAAW,EAK3C,CAAA;AAEV,+EAA+E;AAC/E,eAAO,MAAM,mBAAmB,MAAM,CAAA;AAEtC;;;;;GAKG;AACH,eAAO,MAAM,YAAY,YAAY,CAAA"}

package/build/consts.js

@@ -11,6 +11,20 @@ export var ModelProvider;
     ModelProvider["Anthropic"] = "anthropic";
     /** Any OpenAI-compatible endpoint — OpenRouter, HuggingFace router, Together, vLLM, … */
     ModelProvider["Compatible"] = "compatible";
+    /**
+     * No endpoint at all: the call is handed to whoever holds the execution.
+     *
+     * A delegated model does not talk to a provider. It packages the call — the system prompt, the
+     * conversation, the tools or the schema — and hands it to a transport the application seated,
+     * which carries it to something outside this process entirely: a coding agent driving the
+     * application through a connector, a human, a test. The answer comes back the same way and is
+     * turned into a completion the rest of the stack cannot tell apart from a provider's.
+     *
+     * It exists so that "who performs this call" can be a property of the SESSION rather than of the
+     * code: the same pipeline, the same prompts and the same retry rules, billed to somebody else's
+     * model.
+     */
+    ModelProvider["Delegated"] = "delegated";
 })(ModelProvider || (ModelProvider = {}));
 /**
  * Refinement level of an execution. An execution is refined downward only:

package/build/consts.js.map

@@ -1 +1 @@
-{"version":3,"file":"consts.js","sourceRoot":"","sources":["../src/consts.ts"],"names":[],"mappings":"AACA;;;;GAIG;AACH,MAAM,CAAN,IAAY,aAOX;AAPD,WAAY,aAAa;IACvB,yFAAyF;IACzF,kCAAiB,CAAA;IACjB,8BAA8B;IAC9B,wCAAuB,CAAA;IACvB,yFAAyF;IACzF,0CAAyB,CAAA;AAC3B,CAAC,EAPW,aAAa,KAAb,aAAa,QAOxB;AAED;;;GAGG;AACH,MAAM,CAAN,IAAY,cAIX;AAJD,WAAY,cAAc;IACxB,qCAAmB,CAAA;IACnB,+BAAa,CAAA;IACb,mCAAiB,CAAA;AACnB,CAAC,EAJW,cAAc,KAAd,cAAc,QAIzB;AAED;;;;GAIG;AACH,MAAM,CAAN,IAAY,eAKX;AALD,WAAY,eAAe;IACzB,sCAAmB,CAAA;IACnB,wCAAqB,CAAA;IACrB,gCAAa,CAAA;IACb,8BAAW,CAAA;AACb,CAAC,EALW,eAAe,KAAf,eAAe,QAK1B;AAED;;;;;;;;;GASG;AACH,MAAM,CAAN,IAAY,cAGX;AAHD,WAAY,cAAc;IACxB,mCAAiB,CAAA;IACjB,+BAAa,CAAA;AACf,CAAC,EAHW,cAAc,KAAd,cAAc,QAGzB;AAED,0DAA0D;AAC1D,MAAM,CAAN,IAAY,oBAIX;AAJD,WAAY,oBAAoB;IAC9B,qCAAa,CAAA;IACb,qCAAa,CAAA;IACb,8CAAsB,CAAA;AACxB,CAAC,EAJW,oBAAoB,KAApB,oBAAoB,QAI/B;AAED,mFAAmF;AACnF,MAAM,CAAC,MAAM,iBAAiB,GAAG,SAAS,CAAA;AAE1C;;;;;;;;;;;;;;GAcG;AACH,MAAM,CAAN,IAAY,WAKX;AALD,WAAY,WAAW;IACrB,4BAAa,CAAA;IACb,gCAAiB,CAAA;IACjB,oCAAqB,CAAA;IACrB,kCAAmB,CAAA;AACrB,CAAC,EALW,WAAW,KAAX,WAAW,QAKtB;AAED;;;;GAIG;AACH,MAAM,CAAC,MAAM,kBAAkB,GAA2B;IACxD,WAAW,CAAC,IAAI;IAChB,WAAW,CAAC,MAAM;IAClB,WAAW,CAAC,QAAQ;IACpB,WAAW,CAAC,OAAO;CACX,CAAA;AAEV,+EAA+E;AAC/E,MAAM,CAAC,MAAM,mBAAmB,GAAG,GAAG,CAAA;AAEtC;;;;;GAKG;AACH,MAAM,CAAC,MAAM,YAAY,GAAG,SAAS,CAAA"}
+{"version":3,"file":"consts.js","sourceRoot":"","sources":["../src/consts.ts"],"names":[],"mappings":"AACA;;;;GAIG;AACH,MAAM,CAAN,IAAY,aAqBX;AArBD,WAAY,aAAa;IACvB,yFAAyF;IACzF,kCAAiB,CAAA;IACjB,8BAA8B;IAC9B,wCAAuB,CAAA;IACvB,yFAAyF;IACzF,0CAAyB,CAAA;IACzB;;;;;;;;;;;;OAYG;IACH,wCAAuB,CAAA;AACzB,CAAC,EArBW,aAAa,KAAb,aAAa,QAqBxB;AAED;;;GAGG;AACH,MAAM,CAAN,IAAY,cAIX;AAJD,WAAY,cAAc;IACxB,qCAAmB,CAAA;IACnB,+BAAa,CAAA;IACb,mCAAiB,CAAA;AACnB,CAAC,EAJW,cAAc,KAAd,cAAc,QAIzB;AAED;;;;GAIG;AACH,MAAM,CAAN,IAAY,eAKX;AALD,WAAY,eAAe;IACzB,sCAAmB,CAAA;IACnB,wCAAqB,CAAA;IACrB,gCAAa,CAAA;IACb,8BAAW,CAAA;AACb,CAAC,EALW,eAAe,KAAf,eAAe,QAK1B;AAED;;;;;;;;;GASG;AACH,MAAM,CAAN,IAAY,cAGX;AAHD,WAAY,cAAc;IACxB,mCAAiB,CAAA;IACjB,+BAAa,CAAA;AACf,CAAC,EAHW,cAAc,KAAd,cAAc,QAGzB;AAED,0DAA0D;AAC1D,MAAM,CAAN,IAAY,oBAIX;AAJD,WAAY,oBAAoB;IAC9B,qCAAa,CAAA;IACb,qCAAa,CAAA;IACb,8CAAsB,CAAA;AACxB,CAAC,EAJW,oBAAoB,KAApB,oBAAoB,QAI/B;AAED,mFAAmF;AACnF,MAAM,CAAC,MAAM,iBAAiB,GAAG,SAAS,CAAA;AAE1C;;;;;;;;;;;;;;GAcG;AACH,MAAM,CAAN,IAAY,WAKX;AALD,WAAY,WAAW;IACrB,4BAAa,CAAA;IACb,gCAAiB,CAAA;IACjB,oCAAqB,CAAA;IACrB,kCAAmB,CAAA;AACrB,CAAC,EALW,WAAW,KAAX,WAAW,QAKtB;AAED;;;;GAIG;AACH,MAAM,CAAC,MAAM,kBAAkB,GAA2B;IACxD,WAAW,CAAC,IAAI;IAChB,WAAW,CAAC,MAAM;IAClB,WAAW,CAAC,QAAQ;IACpB,WAAW,CAAC,OAAO;CACX,CAAA;AAEV,+EAA+E;AAC/E,MAAM,CAAC,MAAM,mBAAmB,GAAG,GAAG,CAAA;AAEtC;;;;;GAKG;AACH,MAAM,CAAC,MAAM,YAAY,GAAG,SAAS,CAAA"}

package/build/delegate/index.d.ts

@@ -0,0 +1,2 @@
+export * from './types.js';
+//# sourceMappingURL=index.d.ts.map

package/build/delegate/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/delegate/index.ts"],"names":[],"mappings":"AAAA,cAAc,YAAY,CAAA"}

package/build/delegate/index.js

@@ -0,0 +1,2 @@
+export * from './types.js';
+//# sourceMappingURL=index.js.map

package/build/delegate/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/delegate/index.ts"],"names":[],"mappings":"AAAA,cAAc,YAAY,CAAA"}

package/build/delegate/types.d.ts

@@ -0,0 +1,108 @@
+/**
+ * The serializable form of one model call, for a performer outside this process.
+ *
+ * A delegated call cannot pass a `BaseChatModel` or a langchain message anywhere: the thing that
+ * answers it is a coding agent on somebody's laptop, a test double, or a person. So the call is
+ * reduced to what any of them can act on — a persona, a conversation, and the shape the answer
+ * must take — and everything provider-specific is left behind.
+ *
+ * There is no vocabulary here from whatever pipeline asked. A `role` and a `tier` travel because
+ * the performer has to choose a model; nothing else about the caller does.
+ */
+/** What the answer must be. */
+export declare enum DelegatedMode {
+    /** Prose or code. */
+    Text = "text",
+    /** Exactly one JSON object satisfying `outputSchema`. */
+    Json = "json",
+    /** A list of calls chosen from `tools`. */
+    Tools = "tools"
+}
+/** Who a message came from. Deliberately the four roles every chat API agrees on. */
+export declare enum DelegatedRole {
+    System = "system",
+    User = "user",
+    Assistant = "assistant",
+    Tool = "tool"
+}
+/** What shape an answer came back in. */
+export declare enum DelegatedResultKind {
+    Text = "text",
+    Json = "json",
+    ToolCalls = "tool-calls",
+    /** The performer could not answer. Treated as a malformed answer: asked again, with the reason. */
+    Error = "error"
+}
+export interface DelegatedToolCall {
+    id?: string;
+    name: string;
+    args: Record<string, unknown>;
+}
+export interface DelegatedMessage {
+    role: DelegatedRole;
+    content: string;
+    /** Assistant turns that called tools. */
+    toolCalls?: DelegatedToolCall[];
+    /** Tool turns answer one call, and name the tool they answer. */
+    toolCallId?: string;
+    name?: string;
+}
+export interface DelegatedTool {
+    name: string;
+    description?: string;
+    /** JSON Schema of the arguments. */
+    parameters: Record<string, unknown>;
+}
+export type DelegatedToolChoice = 'auto' | 'none' | {
+    name: string;
+};
+export interface DelegatedTask {
+    id: string;
+    /** Which transport is expected to answer it — the key the application seated it under. */
+    delegate: string;
+    /** The performer's role name, for its own logging. Never load-bearing. */
+    role?: string;
+    /** Which power class the performer should run this on. */
+    tier?: string;
+    /** 0-based. Above zero means a previous answer was refused; `feedback` says why. */
+    attempt: number;
+    mode: DelegatedMode;
+    system?: string;
+    messages: DelegatedMessage[];
+    tools?: DelegatedTool[];
+    toolChoice?: DelegatedToolChoice;
+    outputSchema?: Record<string, unknown>;
+    /** A soft cap, stated so a performer can size its own call. */
+    maxOutputChars?: number;
+    feedback?: string;
+    /** ISO. A performer past this may say so rather than answer. */
+    expiresAt?: string;
+}
+export interface DelegatedUsage {
+    inputTokens?: number;
+    outputTokens?: number;
+}
+export interface DelegatedResult {
+    taskId: string;
+    kind: DelegatedResultKind;
+    text?: string;
+    json?: unknown;
+    toolCalls?: DelegatedToolCall[];
+    error?: string;
+    /** What the performer spent. Recorded; it costs this deployment nothing. */
+    usage?: DelegatedUsage;
+    /** What the performer actually ran. Display only. */
+    model?: string;
+}
+/**
+ * How a delegated call reaches its performer.
+ *
+ * One method, because that is the whole seam: everything about routing, waiting, redelivery and
+ * giving up belongs to whoever implements it. A transport that cannot serve the call must THROW
+ * rather than answer with an error result — an error result is a bad answer, which is retried,
+ * while a transport that is gone is terminal.
+ */
+export interface DelegateTransport {
+    dispatch: (task: DelegatedTask, signal?: AbortSignal) => Promise<DelegatedResult>;
+}
+//# sourceMappingURL=types.d.ts.map

package/build/delegate/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/delegate/types.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,+BAA+B;AAC/B,oBAAY,aAAa;IACvB,qBAAqB;IACrB,IAAI,SAAS;IACb,yDAAyD;IACzD,IAAI,SAAS;IACb,2CAA2C;IAC3C,KAAK,UAAU;CAChB;AAED,qFAAqF;AACrF,oBAAY,aAAa;IACvB,MAAM,WAAW;IACjB,IAAI,SAAS;IACb,SAAS,cAAc;IACvB,IAAI,SAAS;CACd;AAED,yCAAyC;AACzC,oBAAY,mBAAmB;IAC7B,IAAI,SAAS;IACb,IAAI,SAAS;IACb,SAAS,eAAe;IACxB,mGAAmG;IACnG,KAAK,UAAU;CAChB;AAED,MAAM,WAAW,iBAAiB;IAChC,EAAE,CAAC,EAAE,MAAM,CAAA;IACX,IAAI,EAAE,MAAM,CAAA;IACZ,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;CAC9B;AAED,MAAM,WAAW,gBAAgB;IAC/B,IAAI,EAAE,aAAa,CAAA;IACnB,OAAO,EAAE,MAAM,CAAA;IACf,yCAAyC;IACzC,SAAS,CAAC,EAAE,iBAAiB,EAAE,CAAA;IAC/B,iEAAiE;IACjE,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,IAAI,CAAC,EAAE,MAAM,CAAA;CACd;AAED,MAAM,WAAW,aAAa;IAC5B,IAAI,EAAE,MAAM,CAAA;IACZ,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,oCAAoC;IACpC,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;CACpC;AAED,MAAM,MAAM,mBAAmB,GAAG,MAAM,GAAG,MAAM,GAAG;IAAE,IAAI,EAAE,MAAM,CAAA;CAAE,CAAA;AAEpE,MAAM,WAAW,aAAa;IAC5B,EAAE,EAAE,MAAM,CAAA;IACV,0FAA0F;IAC1F,QAAQ,EAAE,MAAM,CAAA;IAChB,0EAA0E;IAC1E,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,0DAA0D;IAC1D,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,oFAAoF;IACpF,OAAO,EAAE,MAAM,CAAA;IACf,IAAI,EAAE,aAAa,CAAA;IACnB,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,QAAQ,EAAE,gBAAgB,EAAE,CAAA;IAC5B,KAAK,CAAC,EAAE,aAAa,EAAE,CAAA;IACvB,UAAU,CAAC,EAAE,mBAAmB,CAAA;IAChC,YAAY,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;IACtC,+DAA+D;IAC/D,cAAc,CAAC,EAAE,MAAM,CAAA;IACvB,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,gEAAgE;IAChE,SAAS,CAAC,EAAE,MAAM,CAAA;CACnB;AAED,MAAM,WAAW,cAAc;IAC7B,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,YAAY,CAAC,EAAE,MAAM,CAAA;CACtB;AAED,MAAM,WAAW,eAAe;IAC9B,MAAM,EAAE,MAAM,CAAA;IACd,IAAI,EAAE,mBAAmB,CAAA;IACzB,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,IAAI,CAAC,EAAE,OAAO,CAAA;IACd,SAAS,CAAC,EAAE,iBAAiB,EAAE,CAAA;IAC/B,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,4EAA4E;IAC5E,KAAK,CAAC,EAAE,cAAc,CAAA;IACtB,qDAAqD;IACrD,KAAK,CAAC,EAAE,MAAM,CAAA;CACf;AAED;;;;;;;GAOG;AACH,MAAM,WAAW,iBAAiB;IAChC,QAAQ,EAAE,CAAC,IAAI,EAAE,aAAa,EAAE,MAAM,CAAC,EAAE,WAAW,KAAK,OAAO,CAAC,eAAe,CAAC,CAAA;CAClF"}

package/build/delegate/types.js

@@ -0,0 +1,39 @@
+/**
+ * The serializable form of one model call, for a performer outside this process.
+ *
+ * A delegated call cannot pass a `BaseChatModel` or a langchain message anywhere: the thing that
+ * answers it is a coding agent on somebody's laptop, a test double, or a person. So the call is
+ * reduced to what any of them can act on — a persona, a conversation, and the shape the answer
+ * must take — and everything provider-specific is left behind.
+ *
+ * There is no vocabulary here from whatever pipeline asked. A `role` and a `tier` travel because
+ * the performer has to choose a model; nothing else about the caller does.
+ */
+/** What the answer must be. */
+export var DelegatedMode;
+(function (DelegatedMode) {
+    /** Prose or code. */
+    DelegatedMode["Text"] = "text";
+    /** Exactly one JSON object satisfying `outputSchema`. */
+    DelegatedMode["Json"] = "json";
+    /** A list of calls chosen from `tools`. */
+    DelegatedMode["Tools"] = "tools";
+})(DelegatedMode || (DelegatedMode = {}));
+/** Who a message came from. Deliberately the four roles every chat API agrees on. */
+export var DelegatedRole;
+(function (DelegatedRole) {
+    DelegatedRole["System"] = "system";
+    DelegatedRole["User"] = "user";
+    DelegatedRole["Assistant"] = "assistant";
+    DelegatedRole["Tool"] = "tool";
+})(DelegatedRole || (DelegatedRole = {}));
+/** What shape an answer came back in. */
+export var DelegatedResultKind;
+(function (DelegatedResultKind) {
+    DelegatedResultKind["Text"] = "text";
+    DelegatedResultKind["Json"] = "json";
+    DelegatedResultKind["ToolCalls"] = "tool-calls";
+    /** The performer could not answer. Treated as a malformed answer: asked again, with the reason. */
+    DelegatedResultKind["Error"] = "error";
+})(DelegatedResultKind || (DelegatedResultKind = {}));
+//# sourceMappingURL=types.js.map

package/build/delegate/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../src/delegate/types.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,+BAA+B;AAC/B,MAAM,CAAN,IAAY,aAOX;AAPD,WAAY,aAAa;IACvB,qBAAqB;IACrB,8BAAa,CAAA;IACb,yDAAyD;IACzD,8BAAa,CAAA;IACb,2CAA2C;IAC3C,gCAAe,CAAA;AACjB,CAAC,EAPW,aAAa,KAAb,aAAa,QAOxB;AAED,qFAAqF;AACrF,MAAM,CAAN,IAAY,aAKX;AALD,WAAY,aAAa;IACvB,kCAAiB,CAAA;IACjB,8BAAa,CAAA;IACb,wCAAuB,CAAA;IACvB,8BAAa,CAAA;AACf,CAAC,EALW,aAAa,KAAb,aAAa,QAKxB;AAED,yCAAyC;AACzC,MAAM,CAAN,IAAY,mBAMX;AAND,WAAY,mBAAmB;IAC7B,oCAAa,CAAA;IACb,oCAAa,CAAA;IACb,+CAAwB,CAAA;IACxB,mGAAmG;IACnG,sCAAe,CAAA;AACjB,CAAC,EANW,mBAAmB,KAAnB,mBAAmB,QAM9B"}

package/build/index.d.ts

@@ -3,4 +3,6 @@ export type * from './types.js';
 export type * from './spectator/types.js';
 export type * from './files/types.js';
 export * from './files/utils.js';
+export * from './delegate/index.js';
+export * from './inquiry/index.js';
 //# sourceMappingURL=index.d.ts.map

package/build/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AACA,cAAc,aAAa,CAAA;AAC3B,mBAAmB,YAAY,CAAA;AAC/B,mBAAmB,sBAAsB,CAAA;AACzC,mBAAmB,kBAAkB,CAAA;AACrC,cAAc,kBAAkB,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AACA,cAAc,aAAa,CAAA;AAC3B,mBAAmB,YAAY,CAAA;AAC/B,mBAAmB,sBAAsB,CAAA;AACzC,mBAAmB,kBAAkB,CAAA;AACrC,cAAc,kBAAkB,CAAA;AAChC,cAAc,qBAAqB,CAAA;AACnC,cAAc,oBAAoB,CAAA"}

package/build/index.js

@@ -1,3 +1,5 @@
 export * from './consts.js';
 export * from './files/utils.js';
+export * from './delegate/index.js';
+export * from './inquiry/index.js';
 //# sourceMappingURL=index.js.map

package/build/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AACA,cAAc,aAAa,CAAA;AAI3B,cAAc,kBAAkB,CAAA"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AACA,cAAc,aAAa,CAAA;AAI3B,cAAc,kBAAkB,CAAA;AAChC,cAAc,qBAAqB,CAAA;AACnC,cAAc,oBAAoB,CAAA"}

package/build/inquiry/consts.d.ts

@@ -0,0 +1,48 @@
+/**
+ * What shape of answer a question expects. Deliberately three, because a question a person is
+ * asked mid-run is answered in seconds or not at all: pick one of these, say it in your own
+ * words, or say yes/no. Anything richer is a form, and a form belongs to an application screen.
+ */
+export declare enum InquiryKind {
+    Choice = "choice",
+    Text = "text",
+    Confirm = "confirm"
+}
+/**
+ * What a run is allowed to do when it needs a decision that is not its own.
+ *
+ * - `Ask` — put it to a person through the seated transport and wait.
+ * - `Default` — assume the question's own default (or record a decline) and carry on. The caller
+ *   is expected to RECORD the assumption; a run nobody is watching must never block.
+ * - `Refuse` — nobody may be asked at all; the attempt is an error.
+ */
+export declare enum InquiryPolicy {
+    Ask = "ask",
+    Default = "default",
+    Refuse = "refuse"
+}
+/**
+ * The ONE ceiling on a stored answer, in characters. An answer is a decision, not a document.
+ *
+ * Every layer that carries an answer references this constant rather than choosing its own:
+ * `viable-common`'s `CONNECT_INQUIRY_MAX_TEXT` (the wire copy) equals it, `capAnswer` enforces it,
+ * and the connector's answer schema caps `text` at it. Three ceilings for one value is how a
+ * user's answer gets accepted on the wire and silently halved further in.
+ */
+export declare const DEFAULT_INQUIRY_ANSWER_CHARS = 2000;
+/** How many options one question may offer. Beyond this it is not a question. */
+export declare const DEFAULT_INQUIRY_OPTIONS = 12;
+/**
+ * How much of an answer's free text a resumable pipeline STATE may hold.
+ *
+ * A pipeline state is keys, markers and paths — a couple of full-size answers would make it prose,
+ * which is the invariant the whole pipeline design rests on. The decision (`value`/`declined`)
+ * stays whole; the prose is cut here and belongs in whatever document the application keeps for
+ * it (`stateAnswerOf`).
+ */
+export declare const INQUIRY_STATE_TEXT_CHARS = 200;
+/** The answer value of a confirmed {@link InquiryKind.Confirm}. */
+export declare const CONFIRM_YES = "yes";
+/** The answer value of a refused {@link InquiryKind.Confirm}. */
+export declare const CONFIRM_NO = "no";
+//# sourceMappingURL=consts.d.ts.map

package/build/inquiry/consts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"consts.d.ts","sourceRoot":"","sources":["../../src/inquiry/consts.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,oBAAY,WAAW;IACrB,MAAM,WAAW;IACjB,IAAI,SAAS;IACb,OAAO,YAAY;CACpB;AAED;;;;;;;GAOG;AACH,oBAAY,aAAa;IACvB,GAAG,QAAQ;IACX,OAAO,YAAY;IACnB,MAAM,WAAW;CAClB;AAED;;;;;;;GAOG;AACH,eAAO,MAAM,4BAA4B,OAAQ,CAAA;AAEjD,iFAAiF;AACjF,eAAO,MAAM,uBAAuB,KAAK,CAAA;AAEzC;;;;;;;GAOG;AACH,eAAO,MAAM,wBAAwB,MAAM,CAAA;AAE3C,mEAAmE;AACnE,eAAO,MAAM,WAAW,QAAQ,CAAA;AAChC,iEAAiE;AACjE,eAAO,MAAM,UAAU,OAAO,CAAA"}

package/build/inquiry/consts.js

@@ -0,0 +1,50 @@
+/**
+ * What shape of answer a question expects. Deliberately three, because a question a person is
+ * asked mid-run is answered in seconds or not at all: pick one of these, say it in your own
+ * words, or say yes/no. Anything richer is a form, and a form belongs to an application screen.
+ */
+export var InquiryKind;
+(function (InquiryKind) {
+    InquiryKind["Choice"] = "choice";
+    InquiryKind["Text"] = "text";
+    InquiryKind["Confirm"] = "confirm";
+})(InquiryKind || (InquiryKind = {}));
+/**
+ * What a run is allowed to do when it needs a decision that is not its own.
+ *
+ * - `Ask` — put it to a person through the seated transport and wait.
+ * - `Default` — assume the question's own default (or record a decline) and carry on. The caller
+ *   is expected to RECORD the assumption; a run nobody is watching must never block.
+ * - `Refuse` — nobody may be asked at all; the attempt is an error.
+ */
+export var InquiryPolicy;
+(function (InquiryPolicy) {
+    InquiryPolicy["Ask"] = "ask";
+    InquiryPolicy["Default"] = "default";
+    InquiryPolicy["Refuse"] = "refuse";
+})(InquiryPolicy || (InquiryPolicy = {}));
+/**
+ * The ONE ceiling on a stored answer, in characters. An answer is a decision, not a document.
+ *
+ * Every layer that carries an answer references this constant rather than choosing its own:
+ * `viable-common`'s `CONNECT_INQUIRY_MAX_TEXT` (the wire copy) equals it, `capAnswer` enforces it,
+ * and the connector's answer schema caps `text` at it. Three ceilings for one value is how a
+ * user's answer gets accepted on the wire and silently halved further in.
+ */
+export const DEFAULT_INQUIRY_ANSWER_CHARS = 2_000;
+/** How many options one question may offer. Beyond this it is not a question. */
+export const DEFAULT_INQUIRY_OPTIONS = 12;
+/**
+ * How much of an answer's free text a resumable pipeline STATE may hold.
+ *
+ * A pipeline state is keys, markers and paths — a couple of full-size answers would make it prose,
+ * which is the invariant the whole pipeline design rests on. The decision (`value`/`declined`)
+ * stays whole; the prose is cut here and belongs in whatever document the application keeps for
+ * it (`stateAnswerOf`).
+ */
+export const INQUIRY_STATE_TEXT_CHARS = 200;
+/** The answer value of a confirmed {@link InquiryKind.Confirm}. */
+export const CONFIRM_YES = 'yes';
+/** The answer value of a refused {@link InquiryKind.Confirm}. */
+export const CONFIRM_NO = 'no';
+//# sourceMappingURL=consts.js.map

package/build/inquiry/consts.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"consts.js","sourceRoot":"","sources":["../../src/inquiry/consts.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,MAAM,CAAN,IAAY,WAIX;AAJD,WAAY,WAAW;IACrB,gCAAiB,CAAA;IACjB,4BAAa,CAAA;IACb,kCAAmB,CAAA;AACrB,CAAC,EAJW,WAAW,KAAX,WAAW,QAItB;AAED;;;;;;;GAOG;AACH,MAAM,CAAN,IAAY,aAIX;AAJD,WAAY,aAAa;IACvB,4BAAW,CAAA;IACX,oCAAmB,CAAA;IACnB,kCAAiB,CAAA;AACnB,CAAC,EAJW,aAAa,KAAb,aAAa,QAIxB;AAED;;;;;;;GAOG;AACH,MAAM,CAAC,MAAM,4BAA4B,GAAG,KAAK,CAAA;AAEjD,iFAAiF;AACjF,MAAM,CAAC,MAAM,uBAAuB,GAAG,EAAE,CAAA;AAEzC;;;;;;;GAOG;AACH,MAAM,CAAC,MAAM,wBAAwB,GAAG,GAAG,CAAA;AAE3C,mEAAmE;AACnE,MAAM,CAAC,MAAM,WAAW,GAAG,KAAK,CAAA;AAChC,iEAAiE;AACjE,MAAM,CAAC,MAAM,UAAU,GAAG,IAAI,CAAA"}

package/build/inquiry/index.d.ts

@@ -0,0 +1,4 @@
+export * from './consts.js';
+export type * from './types.js';
+export * from './utils.js';
+//# sourceMappingURL=index.d.ts.map

package/build/inquiry/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/inquiry/index.ts"],"names":[],"mappings":"AAAA,cAAc,aAAa,CAAA;AAC3B,mBAAmB,YAAY,CAAA;AAC/B,cAAc,YAAY,CAAA"}

package/build/inquiry/index.js

@@ -0,0 +1,3 @@
+export * from './consts.js';
+export * from './utils.js';
+//# sourceMappingURL=index.js.map

package/build/inquiry/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/inquiry/index.ts"],"names":[],"mappings":"AAAA,cAAc,aAAa,CAAA;AAE3B,cAAc,YAAY,CAAA"}

package/build/inquiry/types.d.ts

@@ -0,0 +1,72 @@
+import type { InquiryKind, InquiryPolicy } from './consts.js';
+/**
+ * One question put to a person while a run is in flight, and the answer that comes back.
+ *
+ * Everything here is serializable for the same reason a delegated task is: whoever answers is
+ * outside this process — a browser dialog, a coding agent driving the application through a
+ * connector, a test double — and the question may outlive the process that asked it, parked on a
+ * pipeline run row until somebody comes back to it.
+ */
+export interface InquiryOption {
+    value: string;
+    label: string;
+    description?: string;
+}
+export interface Inquiry {
+    /** Stable id, chosen by whoever asks. The ONLY thing that routes an answer back. */
+    id: string;
+    kind: InquiryKind;
+    /** One question, in plain words. */
+    question: string;
+    /** One or two sentences of background. Never the whole task. */
+    context?: string;
+    /** Required for {@link InquiryKind.Choice}; ignored otherwise. */
+    options?: InquiryOption[];
+    multiple?: boolean;
+    /** A `Choice` the answerer may answer in their own words instead. */
+    allowText?: boolean;
+    /** What to assume when nobody answers. {@link InquiryPolicy.Default} returns exactly this. */
+    default?: string | string[];
+    expiresAt?: string;
+}
+export interface InquiryAnswer {
+    inquiryId: string;
+    value?: string | string[];
+    text?: string;
+    /** Nobody could decide. A legitimate ANSWER, never a failure. */
+    declined?: boolean;
+    /**
+     * This answer is not exactly the one that was given. Never an answerer's own flag.
+     *
+     * Two writers, two ceilings: `capAnswer` cuts the text to `DEFAULT_INQUIRY_ANSWER_CHARS` (and
+     * raises this WITHOUT cutting when a `value` arrived over that ceiling, since a shortened
+     * identifier matches no option), while `stateAnswerOf` cuts the text again to the much smaller
+     * `INQUIRY_STATE_TEXT_CHARS` a pipeline state may hold. So a flag read back off a resumed run
+     * says the state's copy is short — not that the person hit the answer ceiling.
+     *
+     * It exists so no cut is silent: whoever records the answer can say that the rest of it was
+     * dropped, instead of the answerer discovering it in the work that followed.
+     */
+    truncated?: boolean;
+}
+/**
+ * How a question reaches a person.
+ *
+ * One method, like `DelegateTransport` beside it, and for the same reason: routing, waiting,
+ * redelivery and giving up all belong to whoever implements it. A transport that cannot serve the
+ * question must THROW rather than answer — a declined answer is a decision, while a channel that
+ * is not there is terminal, and the two must never look alike.
+ */
+export interface InquiryTransport {
+    ask: (inquiry: Inquiry, signal?: AbortSignal) => Promise<InquiryAnswer>;
+}
+/**
+ * How one run may put a question to a person. Carried on an execution's serializable state, so a
+ * resumed run keeps the channel and the policy it was started with.
+ */
+export interface InquiryConfig {
+    /** The key the application seated an {@link InquiryTransport} under. */
+    transport?: string;
+    policy: InquiryPolicy;
+}
+//# sourceMappingURL=types.d.ts.map

package/build/inquiry/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/inquiry/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,aAAa,EAAE,MAAM,aAAa,CAAA;AAE7D;;;;;;;GAOG;AAEH,MAAM,WAAW,aAAa;IAC5B,KAAK,EAAE,MAAM,CAAA;IACb,KAAK,EAAE,MAAM,CAAA;IACb,WAAW,CAAC,EAAE,MAAM,CAAA;CACrB;AAED,MAAM,WAAW,OAAO;IACtB,oFAAoF;IACpF,EAAE,EAAE,MAAM,CAAA;IACV,IAAI,EAAE,WAAW,CAAA;IACjB,oCAAoC;IACpC,QAAQ,EAAE,MAAM,CAAA;IAChB,gEAAgE;IAChE,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,kEAAkE;IAClE,OAAO,CAAC,EAAE,aAAa,EAAE,CAAA;IACzB,QAAQ,CAAC,EAAE,OAAO,CAAA;IAClB,qEAAqE;IACrE,SAAS,CAAC,EAAE,OAAO,CAAA;IACnB,8FAA8F;IAC9F,OAAO,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,CAAA;IAC3B,SAAS,CAAC,EAAE,MAAM,CAAA;CACnB;AAED,MAAM,WAAW,aAAa;IAC5B,SAAS,EAAE,MAAM,CAAA;IACjB,KAAK,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,CAAA;IACzB,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,iEAAiE;IACjE,QAAQ,CAAC,EAAE,OAAO,CAAA;IAClB;;;;;;;;;;;OAWG;IACH,SAAS,CAAC,EAAE,OAAO,CAAA;CACpB;AAED;;;;;;;GAOG;AACH,MAAM,WAAW,gBAAgB;IAC/B,GAAG,EAAE,CAAC,OAAO,EAAE,OAAO,EAAE,MAAM,CAAC,EAAE,WAAW,KAAK,OAAO,CAAC,aAAa,CAAC,CAAA;CACxE;AAED;;;GAGG;AACH,MAAM,WAAW,aAAa;IAC5B,wEAAwE;IACxE,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,MAAM,EAAE,aAAa,CAAA;CACtB"}

package/build/inquiry/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=types.js.map

package/build/inquiry/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../src/inquiry/types.ts"],"names":[],"mappings":""}

package/build/inquiry/utils.d.ts

@@ -0,0 +1,45 @@
+import type { Inquiry, InquiryAnswer } from './types.js';
+/**
+ * Pure helpers over an inquiry and its answer — no IO, no state, no clock.
+ *
+ * They are here rather than in the runtime because every layer needs the same reading of an
+ * answer: the execution service, the pipeline runner, the `ask_user` tool, the connector and the
+ * screen that finally shows it. A second reading of "was this answered" is a second contract.
+ */
+/**
+ * What to assume when nobody answers: the question's own default, or a decline.
+ *
+ * A decline is an ANSWER — the run carries on and records what it assumed — which is why this
+ * never throws and never returns null.
+ */
+export declare const defaultAnswerFor: (inquiry: Inquiry) => InquiryAnswer;
+/**
+ * The one thing an answer says, as a string — the first chosen value, else the free text, else
+ * `null` when it says nothing at all (a decline, or an empty answer).
+ */
+export declare const answeredWith: (answer: InquiryAnswer) => string | null;
+/** Nobody could decide. Distinct from an empty answer — see {@link answeredWith}. */
+export declare const isDeclined: (answer: InquiryAnswer) => boolean;
+/**
+ * Cut an answer's free TEXT to the ceiling and SAY SO.
+ *
+ * Only the prose is cut. A `value` IS the decision — for a choice it has to equal one of the
+ * question's own option values — so slicing one does not degrade an answer, it silently replaces
+ * it with an identifier nobody offered and nothing matches, which `answeredWith` then hands on as
+ * what the person chose. An over-long value is a defect upstream rather than a long answer (the
+ * connector's schema refuses one outright instead of shortening it), so it travels on whole and is
+ * REPORTED through `truncated` — the flag every consumer already reads as "this is not exactly
+ * what the person gave".
+ */
+export declare const capAnswer: (answer: InquiryAnswer, max?: number) => InquiryAnswer;
+/**
+ * The copy of an answer a resumable pipeline STATE keeps: the decision whole, the prose cut to
+ * {@link INQUIRY_STATE_TEXT_CHARS}.
+ *
+ * The full answer goes back to whoever asked; only this reduced one is persisted, so a run that
+ * asks several questions still holds a state made of keys rather than of paragraphs.
+ */
+export declare const stateAnswerOf: (answer: InquiryAnswer) => InquiryAnswer;
+/** One-line label of a question — for a note, a trace line or a run row. */
+export declare const renderInquiry: (inquiry: Inquiry) => string;
+//# sourceMappingURL=utils.d.ts.map