@loomcycle/client 1.82.0 → 1.84.0

package/dist/cjs/client.js

@@ -68,6 +68,37 @@ function compactionToWire(c) {
         w.model = c.model;
     return w;
 }
+/** contextToWire maps the camelCase ContextOptions to the snake_case `context`
+ *  block the server decodes.
+ *
+ *  Note `autorecapAtPct` -> `autorecap_at_pct`: the wire key has no underscore
+ *  after "auto", unlike compaction's `autocompact_at_pct`. The two blocks are
+ *  spelled differently on the wire and a shared helper would have to special-
+ *  case one of them, so they stay separate functions. */
+function contextToWire(c) {
+    const w = {};
+    if (c.mode !== undefined)
+        w.mode = c.mode;
+    if (c.keepLastN !== undefined)
+        w.keep_last_n = c.keepLastN;
+    if (c.reasoning !== undefined)
+        w.reasoning = c.reasoning;
+    if (c.recapMaxChars !== undefined)
+        w.recap_max_chars = c.recapMaxChars;
+    if (c.autorecapAtPct !== undefined)
+        w.autorecap_at_pct = c.autorecapAtPct;
+    if (c.stateSchema !== undefined)
+        w.state_schema = c.stateSchema;
+    if (c.onInvalidPatch !== undefined)
+        w.on_invalid_patch = c.onInvalidPatch;
+    if (c.maxPatchRetries !== undefined)
+        w.max_patch_retries = c.maxPatchRetries;
+    if (c.recall !== undefined)
+        w.recall = c.recall;
+    if (c.harvestToMemory !== undefined)
+        w.harvest_to_memory = c.harvestToMemory;
+    return w;
+}
 /** runBody builds the snake_case /v1/runs request body from RunOptions,
  *  omitting unset fields (preserves the server's nil semantics — notably
  *  `allowedHosts: null` is treated as "omit", not deny-all). Shared by
@@ -109,6 +140,8 @@ function runBody(opts) {
         body.sampling = samplingToWire(opts.sampling);
     if (opts.compaction !== undefined)
         body.compaction = compactionToWire(opts.compaction);
+    if (opts.context !== undefined)
+        body.context = contextToWire(opts.context);
     if (opts.maxContextTokens !== undefined)
         body.max_context_tokens = opts.maxContextTokens;
     if (opts.interactive !== undefined)
@@ -123,6 +156,12 @@ function runBody(opts) {
  *  to the TYPE but to only one of those lists is invisible on the wire from one
  *  of them, silently. That is the shape of the bug RFC DA shipped.
  */
+// The parameter is RunOverrideOptions itself, not a structural copy of its
+// fields. It WAS such a copy — a second enumeration of the same list sitting in
+// the signature of the function whose whole job is to be the single one — and
+// adding a field to the shared interface then failed to compile here, which is
+// the good outcome only because someone was looking. Typing it as the interface
+// makes the list unduplicated rather than merely checked.
 function applyOverridesToWire(body, opts) {
     if (opts.model !== undefined)
         body.model = opts.model;
@@ -148,6 +187,10 @@ function applyOverridesToWire(body, opts) {
         body.memory_index_max_bytes = opts.memoryIndexMaxBytes;
     if (opts.injectToolGuide !== undefined)
         body.inject_tool_guide = opts.injectToolGuide;
+    if (opts.interactive !== undefined)
+        body.interactive = opts.interactive;
+    if (opts.interruption !== undefined)
+        body.interruption = opts.interruption;
 }
 class LoomcycleClient {
     ctx;
@@ -229,6 +272,8 @@ class LoomcycleClient {
             body.sampling = samplingToWire(opts.sampling);
         if (opts.compaction !== undefined)
             body.compaction = compactionToWire(opts.compaction);
+        if (opts.context !== undefined)
+            body.context = contextToWire(opts.context);
         if (opts.maxContextTokens !== undefined)
             body.max_context_tokens = opts.maxContextTokens;
         if (opts.interactive !== undefined)
@@ -247,7 +292,69 @@ class LoomcycleClient {
      *  Raises {@link UnavailableError} (503, steering off / no run),
      *  {@link AuthError} (401). A full steer queue surfaces as a 429. */
     async sendRunInput(runId, text, opts) {
-        return (0, fetch_helpers_js_1.postJSON)(this.ctx, `/v1/runs/${encodeURIComponent(runId)}/input`, { text }, opts);
+        const body = { text };
+        if (opts?.overrides) {
+            // The wire nests these under `overrides` on THIS endpoint (unlike the flat
+            // fields on /v1/runs), because the request's other job is sending a turn
+            // and the group needs a name.
+            const o = {};
+            applyOverridesToWire(o, opts.overrides);
+            if (Object.keys(o).length > 0)
+                body.overrides = o;
+        }
+        return (0, fetch_helpers_js_1.postJSON)(this.ctx, `/v1/runs/${encodeURIComponent(runId)}/input`, body, opts);
+    }
+    /** Change a run's settings WITHOUT sending it a turn. Mirrors
+     *  `POST /v1/runs/{run_id}/retune`.
+     *
+     *  Use this to retune a PARKED chat — switch it to a different model, raise
+     *  its iteration bound — when you do not also want a message in the
+     *  transcript. `sendRunInput(runId, text, { overrides })` is the other half:
+     *  retune and speak in one atomic call.
+     *
+     *  The overrides select WITHIN what the agent's definition already allows and
+     *  cannot widen it; an override the definition forbids is REFUSED here rather
+     *  than silently dropped, so a rejected retune is visible at the call.
+     *
+     *  Raises {@link NotFoundError} (404, no in-flight run — which is also what a
+     *  run belonging to another tenant returns, deliberately), and 422 when no
+     *  override is supplied at all. */
+    async retuneRun(runId, overrides, opts) {
+        const body = {};
+        applyOverridesToWire(body, overrides);
+        return (0, fetch_helpers_js_1.postJSON)(this.ctx, `/v1/runs/${encodeURIComponent(runId)}/retune`, body, opts);
+    }
+    /** Read a run's own stored overrides. Mirrors `GET /v1/runs/{run_id}/config`.
+     *
+     *  This is what the RUN overrides, not what it will effectively use: a field
+     *  absent from `config` means "this run does not override it", and the
+     *  definition, the tier or a driver still decides. {@link getEffectiveConfig}
+     *  is the resolved view.
+     *
+     *  A run that was never retuned answers with an empty `config` — "this run
+     *  overrides nothing" is an answer, not a 404.
+     *
+     *  Raises {@link NotFoundError} (404), which is also what a run belonging to
+     *  another tenant returns — deliberately, so the gate is not an existence
+     *  oracle for run ids that are not secrets. */
+    async getRunConfig(runId, opts) {
+        return (0, fetch_helpers_js_1.jsonFetch)(this.ctx, `/v1/runs/${encodeURIComponent(runId)}/config`, opts);
+    }
+    /** Read what a run will ACTUALLY use, field by field, with the layer that
+     *  decided each. Mirrors `GET /v1/runs/{run_id}/effective-config`.
+     *
+     *  Nothing else assembles this: a definition is a sparse overlay, the tier and
+     *  driver defaults are published nowhere else, and a field no layer set
+     *  resolves later somewhere the caller cannot see. The `source` on each field
+     *  is the point — `max_iterations: 16` cannot tell a deliberate setting from a
+     *  default nobody chose, and those call for opposite actions.
+     *
+     *  Keys are wire names (`max_tokens`, not `maxTokens`), so the result joins
+     *  directly against a definition from the library endpoints.
+     *
+     *  Raises {@link NotFoundError} (404) for an unknown or cross-tenant run. */
+    async getEffectiveConfig(runId, opts) {
+        return (0, fetch_helpers_js_1.jsonFetch)(this.ctx, `/v1/runs/${encodeURIComponent(runId)}/effective-config`, opts);
     }
     /** Re-attach to a run's event stream by `run_id` (RFC AI), replaying from
      *  `fromSeq` (default 0) then live-tailing — the gRPC-free twin of the Web
@@ -274,7 +381,8 @@ class LoomcycleClient {
     interactiveSession(opts) {
         const source = this.runStreaming({ ...opts, interactive: true });
         return new interactive_js_1.InteractiveSession(source, {
-            sendRunInput: (rid, t) => this.sendRunInput(rid, t),
+            sendRunInput: (rid, t, o) => this.sendRunInput(rid, t, o),
+            retuneRun: (rid, ov) => this.retuneRun(rid, ov),
             cancelAgent: (aid) => this.cancelAgent(aid),
         });
     }
@@ -285,7 +393,8 @@ class LoomcycleClient {
     attachInteractiveSession(runId, opts) {
         const source = this.streamRunByID(runId, opts);
         const session = new interactive_js_1.InteractiveSession(source, {
-            sendRunInput: (rid, t) => this.sendRunInput(rid, t),
+            sendRunInput: (rid, t, o) => this.sendRunInput(rid, t, o),
+            retuneRun: (rid, ov) => this.retuneRun(rid, ov),
             cancelAgent: (aid) => this.cancelAgent(aid),
         });
         session.runId = runId;

package/dist/cjs/interactive.js

@@ -58,14 +58,30 @@ class InteractiveSession {
      *  flag. Throws if the run_id isn't known yet — for a fresh session, consume
      *  `events()` until the `agent` frame (or the first `awaiting_input`) first;
      *  a re-attached session has the run_id up front. */
-    async send(text) {
+    async send(text, opts) {
         if (!this.runId) {
             throw new Error("loomcycle: run_id not known yet — consume events() until the `agent` frame before send()");
         }
-        const { delivered } = await this.ops.sendRunInput(this.runId, text);
+        const { delivered } = await this.ops.sendRunInput(this.runId, text, opts);
         this.awaitingInput = false;
         return delivered;
     }
+    /** Change this run's settings WITHOUT sending it a turn — switch a parked
+     *  chat to another model, raise its iteration bound.
+     *
+     *  `send(text, { overrides })` is the other half: retune and speak in one
+     *  atomic call. Use THIS one when a message in the transcript would be an
+     *  artefact of changing a setting rather than something the operator said.
+     *
+     *  Does not clear `awaitingInput`: a parked run is still parked after a
+     *  retune, because nothing was delivered for it to answer. */
+    async retune(overrides) {
+        if (!this.runId) {
+            throw new Error("loomcycle: run_id not known yet — consume events() until the `agent` frame before retune()");
+        }
+        const { retuned } = await this.ops.retuneRun(this.runId, overrides);
+        return retuned;
+    }
     /** Cancel the run (and its sub-agents). No-op if the agent_id isn't known
      *  yet (nothing to cancel). */
     async cancel() {

package/dist/client.d.ts

@@ -25,7 +25,7 @@
  */
 import { InteractiveSession } from "./interactive.js";
 import { ClientToolHost, type ConnectClientToolsOptions } from "./client-tools.js";
-import type { CredentialListResponse, CredentialMeta, CredentialScope, DirectoryInspection, DirectoryTenant, DirectoryUser, ErasureReport, ErasureResult, Agent, AgentEvent, AgentStatus, CancelAgentResult, ClientOptions, ContinueOptions, CreateSnapshotOptions, EnsureCodeAgentOptions, EnsureCodeAgentResult, EnsureMcpServerOptions, EnsureMcpServerResult, HealthResponse, Hook, InterruptListResponse, InterruptStatus, AckChannelOptions, AwaitChannelsOptions, BroadcastChannelsOptions, ChannelAckResult, ChannelAwaitResult, ChannelBroadcastResult, ChannelDescriptor, ChannelPeekResult, ChannelPublishResult, ChannelPurgeResult, ChannelReleaseResult, ChannelSubscribeResult, CreateChannelOptions, ListChannelsResponse, PeekChannelOptions, PublishChannelOptions, ReleaseChannelOptions, SetMemoryEntryOptions, SetMemoryEntryResponse, SubscribeChannelOptions, UpdateChannelOptions, LibraryAgentDefinition, LibraryListResponse, LibraryMcpServerDefinition, LibrarySkillDefinition, ListUsersResponse, UserRecord, CreateUserBody, UpdateUserBody, MintedUserToken, ListUserTokensResponse, RunnableAgentsResponse, LLMChatOptions, LLMChatResponse, LLMChatStreamItem, LLMEmbeddingsOptions, LLMEmbeddingsResponse, MCPServerDefVerifyResult, MemoryEmbedStatsResponse, MemoryEntriesResponse, MemoryEntryResponse, MemoryBackfillResponse, MemoryPurgeResponse, MemoryReembedResponse, MemoryScopeIDsResponse, MemoryScopesResponse, MemorySearchInput, MemorySearchResponse, PauseResult, PersistentVolumesResponse, EphemeralVolumesResponse, RegisterHookOptions, RegisterHookResponse, ResolveInterruptOptions, ResumeResult, ResolverMatrix, CompactRunResult, ReplaySessionResult, CancelTurnResult, RunBatchOptions, RunBatchResult, RunOptions, RunStateStreamItem, RuntimeStateResponse, SnapshotCreateResponse, SnapshotDescriptor, SnapshotEnvelope, SnapshotRestoreResponse, StreamUserRunStatesOptions, SubstrateToolInput, SubstrateToolResponse, CreatedTeam, ListTeamsResponse, PromotedTeam, RetiredTeam, TeamBreakpoints, TeamDefDetail, TeamRunDetached, TeamRunTarget, TeamVerification, TeamVersionList, TeamDiagram, TeamRunResult, PathToolInput, PathToolResponse, DocumentToolInput, DocumentToolResponse, HistoryToolInput, HistoryToolResponse, TranscriptResponse, WhoamiResponse, UsageDimension, UsageReportResponse, TokenLimit, TokenLimitsResponse, ConfigResponse, SetTokenLimitRequest } from "./types.js";
+import type { CredentialListResponse, CredentialMeta, CredentialScope, DirectoryInspection, DirectoryTenant, DirectoryUser, ErasureReport, ErasureResult, Agent, AgentEvent, AgentStatus, CancelAgentResult, ClientOptions, ContinueOptions, RunOverrideOptions, EffectiveConfigResponse, RetuneRunResponse, RunConfigResponse, CreateSnapshotOptions, EnsureCodeAgentOptions, EnsureCodeAgentResult, EnsureMcpServerOptions, EnsureMcpServerResult, HealthResponse, Hook, InterruptListResponse, InterruptStatus, AckChannelOptions, AwaitChannelsOptions, BroadcastChannelsOptions, ChannelAckResult, ChannelAwaitResult, ChannelBroadcastResult, ChannelDescriptor, ChannelPeekResult, ChannelPublishResult, ChannelPurgeResult, ChannelReleaseResult, ChannelSubscribeResult, CreateChannelOptions, ListChannelsResponse, PeekChannelOptions, PublishChannelOptions, ReleaseChannelOptions, SetMemoryEntryOptions, SetMemoryEntryResponse, SubscribeChannelOptions, UpdateChannelOptions, LibraryAgentDefinition, LibraryListResponse, LibraryMcpServerDefinition, LibrarySkillDefinition, ListUsersResponse, UserRecord, CreateUserBody, UpdateUserBody, MintedUserToken, ListUserTokensResponse, RunnableAgentsResponse, LLMChatOptions, LLMChatResponse, LLMChatStreamItem, LLMEmbeddingsOptions, LLMEmbeddingsResponse, MCPServerDefVerifyResult, MemoryEmbedStatsResponse, MemoryEntriesResponse, MemoryEntryResponse, MemoryBackfillResponse, MemoryPurgeResponse, MemoryReembedResponse, MemoryScopeIDsResponse, MemoryScopesResponse, MemorySearchInput, MemorySearchResponse, PauseResult, PersistentVolumesResponse, EphemeralVolumesResponse, RegisterHookOptions, RegisterHookResponse, ResolveInterruptOptions, ResumeResult, ResolverMatrix, CompactRunResult, ReplaySessionResult, CancelTurnResult, RunBatchOptions, RunBatchResult, RunOptions, RunStateStreamItem, RuntimeStateResponse, SnapshotCreateResponse, SnapshotDescriptor, SnapshotEnvelope, SnapshotRestoreResponse, StreamUserRunStatesOptions, SubstrateToolInput, SubstrateToolResponse, CreatedTeam, ListTeamsResponse, PromotedTeam, RetiredTeam, TeamBreakpoints, TeamDefDetail, TeamRunDetached, TeamRunTarget, TeamVerification, TeamVersionList, TeamDiagram, TeamRunResult, PathToolInput, PathToolResponse, DocumentToolInput, DocumentToolResponse, HistoryToolInput, HistoryToolResponse, TranscriptResponse, WhoamiResponse, UsageDimension, UsageReportResponse, TokenLimit, TokenLimitsResponse, ConfigResponse, SetTokenLimitRequest } from "./types.js";
 export declare class LoomcycleClient {
     private ctx;
     constructor(opts?: ClientOptions);
@@ -81,10 +81,61 @@ export declare class LoomcycleClient {
      *  {@link AuthError} (401). A full steer queue surfaces as a 429. */
     sendRunInput(runId: string, text: string, opts?: {
         signal?: AbortSignal;
+        overrides?: RunOverrideOptions;
     }): Promise<{
         run_id: string;
         delivered: boolean;
     }>;
+    /** Change a run's settings WITHOUT sending it a turn. Mirrors
+     *  `POST /v1/runs/{run_id}/retune`.
+     *
+     *  Use this to retune a PARKED chat — switch it to a different model, raise
+     *  its iteration bound — when you do not also want a message in the
+     *  transcript. `sendRunInput(runId, text, { overrides })` is the other half:
+     *  retune and speak in one atomic call.
+     *
+     *  The overrides select WITHIN what the agent's definition already allows and
+     *  cannot widen it; an override the definition forbids is REFUSED here rather
+     *  than silently dropped, so a rejected retune is visible at the call.
+     *
+     *  Raises {@link NotFoundError} (404, no in-flight run — which is also what a
+     *  run belonging to another tenant returns, deliberately), and 422 when no
+     *  override is supplied at all. */
+    retuneRun(runId: string, overrides: RunOverrideOptions, opts?: {
+        signal?: AbortSignal;
+    }): Promise<RetuneRunResponse>;
+    /** Read a run's own stored overrides. Mirrors `GET /v1/runs/{run_id}/config`.
+     *
+     *  This is what the RUN overrides, not what it will effectively use: a field
+     *  absent from `config` means "this run does not override it", and the
+     *  definition, the tier or a driver still decides. {@link getEffectiveConfig}
+     *  is the resolved view.
+     *
+     *  A run that was never retuned answers with an empty `config` — "this run
+     *  overrides nothing" is an answer, not a 404.
+     *
+     *  Raises {@link NotFoundError} (404), which is also what a run belonging to
+     *  another tenant returns — deliberately, so the gate is not an existence
+     *  oracle for run ids that are not secrets. */
+    getRunConfig(runId: string, opts?: {
+        signal?: AbortSignal;
+    }): Promise<RunConfigResponse>;
+    /** Read what a run will ACTUALLY use, field by field, with the layer that
+     *  decided each. Mirrors `GET /v1/runs/{run_id}/effective-config`.
+     *
+     *  Nothing else assembles this: a definition is a sparse overlay, the tier and
+     *  driver defaults are published nowhere else, and a field no layer set
+     *  resolves later somewhere the caller cannot see. The `source` on each field
+     *  is the point — `max_iterations: 16` cannot tell a deliberate setting from a
+     *  default nobody chose, and those call for opposite actions.
+     *
+     *  Keys are wire names (`max_tokens`, not `maxTokens`), so the result joins
+     *  directly against a definition from the library endpoints.
+     *
+     *  Raises {@link NotFoundError} (404) for an unknown or cross-tenant run. */
+    getEffectiveConfig(runId: string, opts?: {
+        signal?: AbortSignal;
+    }): Promise<EffectiveConfigResponse>;
     /** Re-attach to a run's event stream by `run_id` (RFC AI), replaying from
      *  `fromSeq` (default 0) then live-tailing — the gRPC-free twin of the Web
      *  UI's resume-in-terminal. Mirrors `GET /v1/runs/{run_id}/stream`. The

package/dist/client.js

@@ -65,6 +65,37 @@ function compactionToWire(c) {
         w.model = c.model;
     return w;
 }
+/** contextToWire maps the camelCase ContextOptions to the snake_case `context`
+ *  block the server decodes.
+ *
+ *  Note `autorecapAtPct` -> `autorecap_at_pct`: the wire key has no underscore
+ *  after "auto", unlike compaction's `autocompact_at_pct`. The two blocks are
+ *  spelled differently on the wire and a shared helper would have to special-
+ *  case one of them, so they stay separate functions. */
+function contextToWire(c) {
+    const w = {};
+    if (c.mode !== undefined)
+        w.mode = c.mode;
+    if (c.keepLastN !== undefined)
+        w.keep_last_n = c.keepLastN;
+    if (c.reasoning !== undefined)
+        w.reasoning = c.reasoning;
+    if (c.recapMaxChars !== undefined)
+        w.recap_max_chars = c.recapMaxChars;
+    if (c.autorecapAtPct !== undefined)
+        w.autorecap_at_pct = c.autorecapAtPct;
+    if (c.stateSchema !== undefined)
+        w.state_schema = c.stateSchema;
+    if (c.onInvalidPatch !== undefined)
+        w.on_invalid_patch = c.onInvalidPatch;
+    if (c.maxPatchRetries !== undefined)
+        w.max_patch_retries = c.maxPatchRetries;
+    if (c.recall !== undefined)
+        w.recall = c.recall;
+    if (c.harvestToMemory !== undefined)
+        w.harvest_to_memory = c.harvestToMemory;
+    return w;
+}
 /** runBody builds the snake_case /v1/runs request body from RunOptions,
  *  omitting unset fields (preserves the server's nil semantics — notably
  *  `allowedHosts: null` is treated as "omit", not deny-all). Shared by
@@ -106,6 +137,8 @@ function runBody(opts) {
         body.sampling = samplingToWire(opts.sampling);
     if (opts.compaction !== undefined)
         body.compaction = compactionToWire(opts.compaction);
+    if (opts.context !== undefined)
+        body.context = contextToWire(opts.context);
     if (opts.maxContextTokens !== undefined)
         body.max_context_tokens = opts.maxContextTokens;
     if (opts.interactive !== undefined)
@@ -120,6 +153,12 @@ function runBody(opts) {
  *  to the TYPE but to only one of those lists is invisible on the wire from one
  *  of them, silently. That is the shape of the bug RFC DA shipped.
  */
+// The parameter is RunOverrideOptions itself, not a structural copy of its
+// fields. It WAS such a copy — a second enumeration of the same list sitting in
+// the signature of the function whose whole job is to be the single one — and
+// adding a field to the shared interface then failed to compile here, which is
+// the good outcome only because someone was looking. Typing it as the interface
+// makes the list unduplicated rather than merely checked.
 function applyOverridesToWire(body, opts) {
     if (opts.model !== undefined)
         body.model = opts.model;
@@ -145,6 +184,10 @@ function applyOverridesToWire(body, opts) {
         body.memory_index_max_bytes = opts.memoryIndexMaxBytes;
     if (opts.injectToolGuide !== undefined)
         body.inject_tool_guide = opts.injectToolGuide;
+    if (opts.interactive !== undefined)
+        body.interactive = opts.interactive;
+    if (opts.interruption !== undefined)
+        body.interruption = opts.interruption;
 }
 export class LoomcycleClient {
     ctx;
@@ -226,6 +269,8 @@ export class LoomcycleClient {
             body.sampling = samplingToWire(opts.sampling);
         if (opts.compaction !== undefined)
             body.compaction = compactionToWire(opts.compaction);
+        if (opts.context !== undefined)
+            body.context = contextToWire(opts.context);
         if (opts.maxContextTokens !== undefined)
             body.max_context_tokens = opts.maxContextTokens;
         if (opts.interactive !== undefined)
@@ -244,7 +289,69 @@ export class LoomcycleClient {
      *  Raises {@link UnavailableError} (503, steering off / no run),
      *  {@link AuthError} (401). A full steer queue surfaces as a 429. */
     async sendRunInput(runId, text, opts) {
-        return postJSON(this.ctx, `/v1/runs/${encodeURIComponent(runId)}/input`, { text }, opts);
+        const body = { text };
+        if (opts?.overrides) {
+            // The wire nests these under `overrides` on THIS endpoint (unlike the flat
+            // fields on /v1/runs), because the request's other job is sending a turn
+            // and the group needs a name.
+            const o = {};
+            applyOverridesToWire(o, opts.overrides);
+            if (Object.keys(o).length > 0)
+                body.overrides = o;
+        }
+        return postJSON(this.ctx, `/v1/runs/${encodeURIComponent(runId)}/input`, body, opts);
+    }
+    /** Change a run's settings WITHOUT sending it a turn. Mirrors
+     *  `POST /v1/runs/{run_id}/retune`.
+     *
+     *  Use this to retune a PARKED chat — switch it to a different model, raise
+     *  its iteration bound — when you do not also want a message in the
+     *  transcript. `sendRunInput(runId, text, { overrides })` is the other half:
+     *  retune and speak in one atomic call.
+     *
+     *  The overrides select WITHIN what the agent's definition already allows and
+     *  cannot widen it; an override the definition forbids is REFUSED here rather
+     *  than silently dropped, so a rejected retune is visible at the call.
+     *
+     *  Raises {@link NotFoundError} (404, no in-flight run — which is also what a
+     *  run belonging to another tenant returns, deliberately), and 422 when no
+     *  override is supplied at all. */
+    async retuneRun(runId, overrides, opts) {
+        const body = {};
+        applyOverridesToWire(body, overrides);
+        return postJSON(this.ctx, `/v1/runs/${encodeURIComponent(runId)}/retune`, body, opts);
+    }
+    /** Read a run's own stored overrides. Mirrors `GET /v1/runs/{run_id}/config`.
+     *
+     *  This is what the RUN overrides, not what it will effectively use: a field
+     *  absent from `config` means "this run does not override it", and the
+     *  definition, the tier or a driver still decides. {@link getEffectiveConfig}
+     *  is the resolved view.
+     *
+     *  A run that was never retuned answers with an empty `config` — "this run
+     *  overrides nothing" is an answer, not a 404.
+     *
+     *  Raises {@link NotFoundError} (404), which is also what a run belonging to
+     *  another tenant returns — deliberately, so the gate is not an existence
+     *  oracle for run ids that are not secrets. */
+    async getRunConfig(runId, opts) {
+        return jsonFetch(this.ctx, `/v1/runs/${encodeURIComponent(runId)}/config`, opts);
+    }
+    /** Read what a run will ACTUALLY use, field by field, with the layer that
+     *  decided each. Mirrors `GET /v1/runs/{run_id}/effective-config`.
+     *
+     *  Nothing else assembles this: a definition is a sparse overlay, the tier and
+     *  driver defaults are published nowhere else, and a field no layer set
+     *  resolves later somewhere the caller cannot see. The `source` on each field
+     *  is the point — `max_iterations: 16` cannot tell a deliberate setting from a
+     *  default nobody chose, and those call for opposite actions.
+     *
+     *  Keys are wire names (`max_tokens`, not `maxTokens`), so the result joins
+     *  directly against a definition from the library endpoints.
+     *
+     *  Raises {@link NotFoundError} (404) for an unknown or cross-tenant run. */
+    async getEffectiveConfig(runId, opts) {
+        return jsonFetch(this.ctx, `/v1/runs/${encodeURIComponent(runId)}/effective-config`, opts);
     }
     /** Re-attach to a run's event stream by `run_id` (RFC AI), replaying from
      *  `fromSeq` (default 0) then live-tailing — the gRPC-free twin of the Web
@@ -271,7 +378,8 @@ export class LoomcycleClient {
     interactiveSession(opts) {
         const source = this.runStreaming({ ...opts, interactive: true });
         return new InteractiveSession(source, {
-            sendRunInput: (rid, t) => this.sendRunInput(rid, t),
+            sendRunInput: (rid, t, o) => this.sendRunInput(rid, t, o),
+            retuneRun: (rid, ov) => this.retuneRun(rid, ov),
             cancelAgent: (aid) => this.cancelAgent(aid),
         });
     }
@@ -282,7 +390,8 @@ export class LoomcycleClient {
     attachInteractiveSession(runId, opts) {
         const source = this.streamRunByID(runId, opts);
         const session = new InteractiveSession(source, {
-            sendRunInput: (rid, t) => this.sendRunInput(rid, t),
+            sendRunInput: (rid, t, o) => this.sendRunInput(rid, t, o),
+            retuneRun: (rid, ov) => this.retuneRun(rid, ov),
             cancelAgent: (aid) => this.cancelAgent(aid),
         });
         session.runId = runId;

package/dist/index.d.ts

@@ -128,5 +128,5 @@ export { InteractiveSession } from "./interactive.js";
 export type { InteractiveSessionOps } from "./interactive.js";
 export { ClientToolHost, clientToolsURL, CLIENT_TOOL_SUBPROTOCOL } from "./client-tools.js";
 export type { ClientToolSchema, ClientToolInvocation, ConnectClientToolsOptions, WebSocketLike, WebSocketCtor, } from "./client-tools.js";
-export type { AgentEvent, ClientOptions, ContinueOptions, EventType, HostWidening, ImageMediaType, ParentContext, PromptContent, PromptSegment, RetryInfo, RunOptions, SamplingOptions, CompactionOptions, ToolUse, Usage, Agent, AgentStatus, AgentUsage, CancelAgentResult, ListAgentsResponse, RunBatchOptions, RunBatchResult, SpawnRunResult, CompactRunResult, DirectoryBudget, DirectoryInspection, DirectoryTenant, DirectoryUser, ErasureReport, ErasureResidue, ErasureResult, ErasureTier, CancelTurnResult, TranscriptEvent, TranscriptResponse, HealthResponse, ListUsersResponse, UserSummary, UserRecord, CreateUserBody, UpdateUserBody, MintedUserToken, UserTokenMeta, ListUserTokensResponse, RunnableAgent, RunnableAgentsResponse, WhoamiResponse, PauseResult, ResumeResult, RuntimeStateResponse, RuntimeStateStatus, ResolverMatrix, ResolverModelStatus, ResolverProviderAvailability, CreateSnapshotOptions, SnapshotCreateResponse, SnapshotDescriptor, SnapshotEnvelope, SnapshotListResponse, SnapshotRestoreResponse, MemoryEntriesResponse, MemoryEntry, MemoryEntryResponse, MemoryScopeIDsResponse, MemoryScopeIDSummary, MemoryScopeKind, MemoryScopesResponse, MemorySearchInput, MemorySource, MemoryWhen, MemoryTimeFilter, MemorySearchEntry, MemorySearchResponse, MemoryEmbedModelStats, MemoryEmbedStatsResponse, MemoryReembedConfigured, MemoryReembedResponse, MemoryBackfillResponse, MemoryPurgeResponse, InterruptListResponse, InterruptRow, InterruptStatus, ResolveInterruptOptions, Hook, HookFailMode, HookPhase, HookToolCall, HookToolResult, ListHooksResponse, PostHookCall, PostHookResult, PreHookCall, PreHookResult, RegisterHookOptions, RegisterHookResponse, SubstrateToolInput, SubstrateToolResponse, TeamNameSummary, ListTeamsResponse, TeamDiagram, CreatedTeam, PromotedTeam, RetiredTeam, TeamDefDetail, TeamVerification, TeamVersion, TeamVersionList, TeamBreakpoints, TeamRunDetached, TeamRunResult, TeamRunTarget, PathToolInput, PathToolResponse, DocumentToolInput, DocumentToolResponse, HistoryToolInput, HistoryToolResponse, VolumeMode, PersistentVolumeEntry, PersistentVolumesResponse, EphemeralVolumeEntry, EphemeralVolumesResponse, SystemPromptPayload, UserInputPayload, ChannelDescriptor, ListChannelsResponse, RunStateEvent, RunStateStreamClose, RunStateStreamItem, RunStateStreamOpen, StreamUserRunStatesOptions, AckChannelOptions, ChannelAckResult, ChannelMessageItem, ChannelPeekResult, ChannelPublishResult, ChannelPurgeResult, ChannelReleaseResult, ChannelScope, ChannelSubscribeResult, PeekChannelOptions, PublishChannelOptions, SubscribeChannelOptions, AwaitChannelsOptions, BroadcastChannelsOptions, ChannelAwaitEntry, ChannelAwaitMode, ChannelAwaitResult, ChannelBroadcastEntry, ChannelBroadcastResult, CreateChannelOptions, ReleaseChannelOptions, UpdateChannelOptions, SetMemoryEntryOptions, SetMemoryEntryResponse, AgentDefRowResponse, AgentDefVerifyResult, SkillDefVerifyResult, EnsureMcpServerOptions, EnsureMcpServerResult, MCPServerDefRowResponse, MCPServerDefVerifyResult, AgentDefOverlay, EnsureCodeAgentOptions, EnsureCodeAgentResult, LibraryAgentDefinition, LibraryEntry, LibraryListResponse, LibraryMcpServerDefinition, LibrarySkillDefinition, LLMChatContent, LLMChatMessage, LLMChatOptions, LLMChatResponse, LLMChatStreamDelta, LLMChatStreamItem, LLMChatToolCall, LLMChatUsage, LLMTool, LLMEmbeddingItem, LLMEmbeddingsOptions, LLMEmbeddingsResponse, LLMEmbeddingsUsage, UsageDimension, UsageAggregate, UsageReportResponse, LimitInfo, TokenLimit, TokenLimitsResponse, ConfigResponse, ConfigProvider, ConfigModel, ConfigSearch, ConfigInstance, SetTokenLimitRequest, CredentialScope, CredentialMeta, CredentialListResponse, } from "./types.js";
+export type { AgentEvent, ClientOptions, ContinueOptions, EventType, HostWidening, ImageMediaType, ParentContext, PromptContent, PromptSegment, RetryInfo, RunOptions, SamplingOptions, CompactionOptions, ContextOptions, ToolUse, Usage, Agent, AgentStatus, AgentUsage, CancelAgentResult, ListAgentsResponse, RunBatchOptions, RunBatchResult, SpawnRunResult, CompactRunResult, DirectoryBudget, DirectoryInspection, DirectoryTenant, DirectoryUser, ErasureReport, ErasureResidue, ErasureResult, ErasureTier, CancelTurnResult, TranscriptEvent, TranscriptResponse, HealthResponse, ListUsersResponse, UserSummary, UserRecord, CreateUserBody, UpdateUserBody, MintedUserToken, UserTokenMeta, ListUserTokensResponse, RunnableAgent, RunnableAgentsResponse, WhoamiResponse, PauseResult, ResumeResult, RuntimeStateResponse, RuntimeStateStatus, ResolverMatrix, ResolverModelStatus, ResolverProviderAvailability, CreateSnapshotOptions, SnapshotCreateResponse, SnapshotDescriptor, SnapshotEnvelope, SnapshotListResponse, SnapshotRestoreResponse, MemoryEntriesResponse, MemoryEntry, MemoryEntryResponse, MemoryScopeIDsResponse, MemoryScopeIDSummary, MemoryScopeKind, MemoryScopesResponse, MemorySearchInput, MemorySource, MemoryWhen, MemoryTimeFilter, MemorySearchEntry, MemorySearchResponse, MemoryEmbedModelStats, MemoryEmbedStatsResponse, MemoryReembedConfigured, MemoryReembedResponse, MemoryBackfillResponse, MemoryPurgeResponse, InterruptListResponse, InterruptRow, InterruptStatus, ResolveInterruptOptions, Hook, HookFailMode, HookPhase, HookToolCall, HookToolResult, ListHooksResponse, PostHookCall, PostHookResult, PreHookCall, PreHookResult, RegisterHookOptions, RegisterHookResponse, SubstrateToolInput, SubstrateToolResponse, TeamNameSummary, ListTeamsResponse, TeamDiagram, CreatedTeam, PromotedTeam, RetiredTeam, TeamDefDetail, TeamVerification, TeamVersion, TeamVersionList, TeamBreakpoints, TeamRunDetached, TeamRunResult, TeamRunTarget, PathToolInput, PathToolResponse, DocumentToolInput, DocumentToolResponse, HistoryToolInput, HistoryToolResponse, VolumeMode, PersistentVolumeEntry, PersistentVolumesResponse, EphemeralVolumeEntry, EphemeralVolumesResponse, SystemPromptPayload, UserInputPayload, ChannelDescriptor, ListChannelsResponse, RunStateEvent, RunStateStreamClose, RunStateStreamItem, RunStateStreamOpen, StreamUserRunStatesOptions, AckChannelOptions, ChannelAckResult, ChannelMessageItem, ChannelPeekResult, ChannelPublishResult, ChannelPurgeResult, ChannelReleaseResult, ChannelScope, ChannelSubscribeResult, PeekChannelOptions, PublishChannelOptions, SubscribeChannelOptions, AwaitChannelsOptions, BroadcastChannelsOptions, ChannelAwaitEntry, ChannelAwaitMode, ChannelAwaitResult, ChannelBroadcastEntry, ChannelBroadcastResult, CreateChannelOptions, ReleaseChannelOptions, UpdateChannelOptions, SetMemoryEntryOptions, SetMemoryEntryResponse, AgentDefRowResponse, AgentDefVerifyResult, SkillDefVerifyResult, EnsureMcpServerOptions, EnsureMcpServerResult, MCPServerDefRowResponse, MCPServerDefVerifyResult, AgentDefOverlay, EnsureCodeAgentOptions, EnsureCodeAgentResult, LibraryAgentDefinition, LibraryEntry, LibraryListResponse, LibraryMcpServerDefinition, LibrarySkillDefinition, LLMChatContent, LLMChatMessage, LLMChatOptions, LLMChatResponse, LLMChatStreamDelta, LLMChatStreamItem, LLMChatToolCall, LLMChatUsage, LLMTool, LLMEmbeddingItem, LLMEmbeddingsOptions, LLMEmbeddingsResponse, LLMEmbeddingsUsage, UsageDimension, UsageAggregate, UsageReportResponse, CapabilityInertInfo, LimitInfo, EffectiveConfigResponse, EffectiveConfigSource, EffectiveValue, RetuneRunResponse, RunConfigRecord, RunConfigResponse, TokenLimit, TokenLimitsResponse, ConfigResponse, ConfigProvider, ConfigModel, ConfigSearch, ConfigInstance, SetTokenLimitRequest, CredentialScope, CredentialMeta, CredentialListResponse, } from "./types.js";
 export { AgentIDInUseError, AgentNotFoundError, AlreadyPausingError, AuthError, BackpressureError, HookNotFoundError, NotFoundError, InvalidArgumentError, ChannelCursorRegressionError, LoomcycleError, NotPausedError, PauseNotConfiguredError, PerUserQuotaExhaustedError, SessionBusyError, SessionNotFoundError, SnapshotNotFoundError, SnapshotTooLargeError, SnapshotVersionError, SubstrateToolRefusedError, UnavailableError, } from "./errors.js";

package/dist/interactive.d.ts

@@ -1,11 +1,16 @@
-import type { AgentEvent } from "./types.js";
+import type { AgentEvent, RunOverrideOptions } from "./types.js";
 /** The client-side operations an {@link InteractiveSession} routes through.
  *  Supplied by LoomcycleClient.interactiveSession / attachInteractiveSession —
  *  the session itself holds no transport logic. */
 export interface InteractiveSessionOps {
-    sendRunInput: (runId: string, text: string) => Promise<{
+    sendRunInput: (runId: string, text: string, opts?: {
+        overrides?: RunOverrideOptions;
+    }) => Promise<{
         delivered: boolean;
     }>;
+    retuneRun: (runId: string, overrides: RunOverrideOptions) => Promise<{
+        retuned: boolean;
+    }>;
     cancelAgent: (agentId: string) => Promise<unknown>;
 }
 /** A high-level driver for an interactive agentic session (RFC AI) — the
@@ -46,7 +51,19 @@ export declare class InteractiveSession {
      *  flag. Throws if the run_id isn't known yet — for a fresh session, consume
      *  `events()` until the `agent` frame (or the first `awaiting_input`) first;
      *  a re-attached session has the run_id up front. */
-    send(text: string): Promise<boolean>;
+    send(text: string, opts?: {
+        overrides?: RunOverrideOptions;
+    }): Promise<boolean>;
+    /** Change this run's settings WITHOUT sending it a turn — switch a parked
+     *  chat to another model, raise its iteration bound.
+     *
+     *  `send(text, { overrides })` is the other half: retune and speak in one
+     *  atomic call. Use THIS one when a message in the transcript would be an
+     *  artefact of changing a setting rather than something the operator said.
+     *
+     *  Does not clear `awaitingInput`: a parked run is still parked after a
+     *  retune, because nothing was delivered for it to answer. */
+    retune(overrides: RunOverrideOptions): Promise<boolean>;
     /** Cancel the run (and its sub-agents). No-op if the agent_id isn't known
      *  yet (nothing to cancel). */
     cancel(): Promise<void>;

package/dist/interactive.js

@@ -55,14 +55,30 @@ export class InteractiveSession {
      *  flag. Throws if the run_id isn't known yet — for a fresh session, consume
      *  `events()` until the `agent` frame (or the first `awaiting_input`) first;
      *  a re-attached session has the run_id up front. */
-    async send(text) {
+    async send(text, opts) {
         if (!this.runId) {
             throw new Error("loomcycle: run_id not known yet — consume events() until the `agent` frame before send()");
         }
-        const { delivered } = await this.ops.sendRunInput(this.runId, text);
+        const { delivered } = await this.ops.sendRunInput(this.runId, text, opts);
         this.awaitingInput = false;
         return delivered;
     }
+    /** Change this run's settings WITHOUT sending it a turn — switch a parked
+     *  chat to another model, raise its iteration bound.
+     *
+     *  `send(text, { overrides })` is the other half: retune and speak in one
+     *  atomic call. Use THIS one when a message in the transcript would be an
+     *  artefact of changing a setting rather than something the operator said.
+     *
+     *  Does not clear `awaitingInput`: a parked run is still parked after a
+     *  retune, because nothing was delivered for it to answer. */
+    async retune(overrides) {
+        if (!this.runId) {
+            throw new Error("loomcycle: run_id not known yet — consume events() until the `agent` frame before retune()");
+        }
+        const { retuned } = await this.ops.retuneRun(this.runId, overrides);
+        return retuned;
+    }
     /** Cancel the run (and its sub-agents). No-op if the agent_id isn't known
      *  yet (nothing to cancel). */
     async cancel() {

package/dist/types.d.ts

@@ -7,7 +7,7 @@
  * `client.ts` for the input shapes (RunOptions, CreateSnapshotOptions,
  * etc.) — those are translated to snake_case in the request body.
  */
-export type EventType = "started" | "text" | "tool_call" | "tool_result" | "usage" | "done" | "error" | "retry" | "host_widened" | "session" | "agent" | "awaiting_input" | "steer" | "context_compaction" | "limit" | "override" | "_meta";
+export type EventType = "started" | "text" | "tool_call" | "tool_result" | "usage" | "done" | "error" | "retry" | "host_widened" | "session" | "agent" | "awaiting_input" | "steer" | "context_compaction" | "capability_inert" | "limit" | "override" | "_meta";
 export interface ToolUse {
     id: string;
     name: string;
@@ -60,13 +60,116 @@ export interface HostWidening {
  *  scope stands against its ceiling — so a UI can render "tenant acme at 1.2M /
  *  1M tokens this month" without a follow-up fetch. Wire-stable; mirrors
  *  providers.LimitInfo. */
+/** A run's own stored overrides — what the RUN set, not what it will
+ *  effectively use. Mirrors the `config` object on `GET /v1/runs/{id}/config`
+ *  and on the `retuneRun` reply.
+ *
+ *  A field absent here means "this run does not override it", which is a
+ *  different and more useful answer at this layer than a resolved value would
+ *  be: it says the definition, the tier or a driver still decides. Use
+ *  {@link LoomcycleClient.getEffectiveConfig} for the resolved view. */
+export interface RunConfigRecord {
+    sampling?: Record<string, unknown>;
+    compaction?: Record<string, unknown>;
+    context?: Record<string, unknown>;
+    max_context_tokens?: number;
+    run_timeout_seconds?: number;
+    routing?: {
+        provider?: string;
+        model?: string;
+        tier?: string;
+        effort?: string;
+    };
+    resources?: {
+        max_tokens?: number;
+        max_iterations?: number;
+        unbounded_iterations?: boolean;
+        max_concurrent_children?: number;
+    };
+    tuning?: {
+        retry_attempts?: number;
+        memory_inject_max_tokens?: number;
+        memory_index_max_bytes?: number;
+        inject_tool_guide?: boolean;
+    };
+    interactive?: boolean;
+    interruption?: {
+        enabled?: boolean;
+        kinds?: string[];
+        max_pending?: number;
+    };
+    hosts?: Record<string, unknown>;
+}
+/** Which layer decided an effective value.
+ *
+ *  This is the half that makes the report worth fetching. `max_iterations: 16`
+ *  cannot distinguish a deliberate setting from a default nobody chose, and
+ *  those call for opposite actions — so every field carries where it came from.
+ *
+ *  - `run`        — a per-run override set it
+ *  - `definition` — the agent definition set it
+ *  - `user_tier`  — operator tier policy (e.g. retry_attempts)
+ *  - `operator`   — operator env / global configuration
+ *  - `resolved`   — decided at runtime: the tier cascade, the driver, the model.
+ *                   A `resolved` field with a null value means the runtime
+ *                   settles it somewhere this report cannot see, which is a
+ *                   more honest answer than omitting the field.
+ *  - `default`    — a fixed constant in the runtime */
+export type EffectiveConfigSource = "run" | "definition" | "user_tier" | "operator" | "resolved" | "default";
+/** One field's effective value plus the layer that decided it. */
+export interface EffectiveValue {
+    value: unknown;
+    source: EffectiveConfigSource;
+}
+/** The reply from `GET /v1/runs/{run_id}/config` — what the RUN overrides. */
+export interface RunConfigResponse {
+    run_id: string;
+    agent: string;
+    /** The model the run last resolved to, as recorded on the run row. */
+    model: string;
+    config: RunConfigRecord;
+}
+/** The reply from `GET /v1/runs/{run_id}/effective-config` — for every
+ *  overridable field, the value this run will actually use and which layer
+ *  decided it.
+ *
+ *  Keyed by the wire name the rest of the API uses (`max_tokens`, not
+ *  `maxTokens`), so it joins directly against a definition from
+ *  `/v1/_library/agents`. */
+export interface EffectiveConfigResponse {
+    run_id: string;
+    agent: string;
+    fields: Record<string, EffectiveValue>;
+}
+/** The reply from `retuneRun` — the run's MERGED configuration, not an echo of
+ *  the request.
+ *
+ *  A caller cannot recompute it: the merge is not a field-wise union. Naming a
+ *  `model` clears the `provider` so a previous choice cannot contradict the new
+ *  pin, and naming a `tier` clears the `model`. */
+export interface RetuneRunResponse {
+    run_id: string;
+    retuned: boolean;
+    config: RunConfigRecord;
+}
 /** OverrideInfo accompanies an `event: override` frame (RFC DC per-run
  *  overrides): a run's own configuration changed mid-run because an operator
  *  retuned it.
  *
- *  It names what MOVED rather than what the settings now are, because "the
- *  configuration changed" answers nothing for someone trying to explain why the
- *  answers got different after turn 12.
+ *  TWO EVENTS CARRY THIS TYPE, and a consumer needs to tell them apart because
+ *  one retune can produce both. The server emits one when the operator acts,
+ *  listing in `fields` the keys the REQUEST set and carrying NO from/to pair —
+ *  nothing has been re-resolved yet, so there is no honest "to" to report. The
+ *  runtime emits one when the run ADOPTS a routing change, and that one always
+ *  carries both halves of the pair.
+ *
+ *  So: a pair present means "the run is now using this"; a pair absent means
+ *  "an operator asked for these fields". Filter on `from_model === undefined`
+ *  for the second kind.
+ *
+ *  `fields` used to be documented as the request's keys unconditionally while
+ *  the only site filling it in was the runtime's, which cannot see a request —
+ *  so a branch written for "max_tokens changed" could never run.
  *
  *  Carries only operator-chosen configuration whose effects are already visible
  *  — a model name, a budget. No credential, no operator host. */
@@ -102,6 +205,21 @@ export interface ErrorInfo {
      *  instructions. */
     retry_after_ms?: number;
 }
+/** The payload on a `capability_inert` event: one tool the agent holds and
+ *  cannot use, because the capability gate that tool reads grants nothing.
+ *
+ *  Server-generated, emitted ONCE at run start — the condition is a property of
+ *  the definition, not of any one call. It carries the FIX as well as the fact:
+ *  the governing yaml key is not guessable from the tool name, which is most of
+ *  why this failure was hard to act on. */
+export interface CapabilityInertInfo {
+    /** The granted tool, as named in the agent's `tools` list. */
+    tool: string;
+    /** The yaml key that governs it, e.g. `agent_def_scopes`. */
+    gate: string;
+    /** A line naming the tool, the gate, and what to set. */
+    message?: string;
+}
 export interface LimitInfo {
     /** Which axis tripped: "operator" | "tenant" | "user". */
     scope: string;
@@ -150,6 +268,8 @@ export interface AgentEvent {
     /** Payload on `event: limit` (RFC AW) — a per-scope token-budget crossing.
      *  Nil on all other event types. */
     limit?: LimitInfo;
+    /** Set on `capability_inert` events: a tool the agent holds and cannot use. */
+    capability_inert?: CapabilityInertInfo;
     /** Set on `event: override` frames — what the operator changed, and from
      *  what to what. */
     override?: OverrideInfo;
@@ -188,7 +308,14 @@ export interface PromptSegment {
 }
 /** The per-run overrides (RFC DC) — a run's own answer to how it should run,
  *  instead of its agent definition's. Persisted with the run, so they survive a
- *  pause; a parked run can also be retuned via `sendRunInput`.
+ *  pause. A parked run is retuned with `retuneRun()` — or with
+ *  `sendRunInput(id, text, { overrides })` when you also want to say something.
+ *
+ *  This line used to say "can also be retuned via `sendRunInput`", which was
+ *  true of the WIRE and not of the method: the adapter sent a bare `{text}`, so
+ *  the sentence described a capability no caller could reach through it. A
+ *  comment that names the transport instead of the API is how a gap reads as
+ *  closed.
  *
  *  Declared ONCE and extended by both {@link RunOptions} and
  *  {@link ContinueOptions}, because the serializer that writes them is shared
@@ -233,6 +360,24 @@ export interface RunOverrideOptions {
     memoryIndexMaxBytes?: number;
     /** Whether to inject the generated tool guide into the prompt. */
     injectToolGuide?: boolean;
+    /** Park this run at its turn boundaries instead of finishing, so an operator
+     *  can steer it — settable while the run is ALREADY GOING, which is the point:
+     *  nobody knows at start that they will need to correct it.
+     *
+     *  `false` releases a run that was started interactive. Omit to keep whatever
+     *  the run has; a retune of anything else must not disturb this. */
+    interactive?: boolean;
+    /** Let this run's agent ASK a human a question, overriding what its
+     *  definition allows.
+     *
+     *  Overridable because an interruption touches no data and no host — it blocks
+     *  and waits for a person — so the exposure is liveness, bounded by the run's
+     *  timeout and the interruption's own. */
+    interruption?: {
+        enabled?: boolean;
+        kinds?: string[];
+        max_pending?: number;
+    };
 }
 export interface RunOptions extends RunOverrideOptions {
     agent: string;
@@ -320,6 +465,14 @@ export interface RunOptions extends RunOverrideOptions {
      *  Omitted = inherit entirely. Trigger compaction mid-run with
      *  {@link LoomcycleClient.compactRun}. */
     compaction?: CompactionOptions;
+    /** Per-run context-DISTILLATION override, merged PER FIELD over the agent's
+     *  own `context` block (this wins; unset fields inherit).
+     *
+     *  Start-only — see {@link ContextOptions}. This is what varies the
+     *  distillation strategy for a run without forking the agent, and outside
+     *  `mode: "append"` it, not {@link RunOptions.compaction}, is the block the
+     *  runtime reads. */
+    context?: ContextOptions;
     /** Per-run context-WINDOW override in tokens (RFC CJ). Wins over the agent's
      *  own `max_context_tokens` when > 0; omitted = inherit it (which itself
      *  defers to the provider/driver default). Distinct from a model's output
@@ -374,6 +527,76 @@ export interface CompactionOptions {
      *  provider. Omitted = the run's model. */
     model?: string;
 }
+/** Per-run context-distillation override. Mirrors the server's `context`
+ *  block — every field optional; an unset field inherits the agent's value,
+ *  merged per field.
+ *
+ *  DISTINCT from {@link CompactionOptions}, and the two are not
+ *  interchangeable: `compaction` is the append-mode summariser, while this
+ *  chooses HOW history is distilled at all. Outside `mode: "append"` the
+ *  compaction knobs are never consulted — so setting `autocompactAtPct` on a
+ *  recap or stateful run does nothing. The server reports settings in that
+ *  state under `inert` on GET /v1/runs/{id}/effective-config.
+ *
+ *  START-ONLY. These are accepted when a run BEGINS, not by retune: `mode` is
+ *  latched before the loop starts (the stateful branch is taken or not, and
+ *  the tool catalogue is already resolved), so a retune could apply the
+ *  thresholds and silently ignore the mode. */
+export interface ContextOptions {
+    /** How history is distilled.
+     *  - `append`   — keep everything; the compaction knobs apply here and
+     *                 ONLY here.
+     *  - `recap`    — fold the evicted span into a running progress note.
+     *  - `stateful` — a different loop: the model emits a patch + action each
+     *                 step and carries state rather than transcript.
+     *  - `auto`     — resolved at run start from the provider: a local backend
+     *                 or an interactive run takes `recap`, a frontier API takes
+     *                 `stateful`. */
+    mode?: "append" | "recap" | "stateful" | "auto";
+    /** Keep the last N messages verbatim (default 6; 0 = distil all).
+     *
+     *  ⚠️ This is a FLOOR on what can be distilled: a conversation of N+1
+     *  messages or fewer has nothing left after the pinned first turn, so it
+     *  never distils however full the window is. A chat of few enormous turns
+     *  is exactly that shape. The run reports it as a `context_distill_declined`
+     *  event with reason `split_declined`, carrying both numbers. */
+    keepLastN?: number;
+    /** What happens to the evicted span in recap mode.
+     *  - `recap` (default) — summarise it into a running note.
+     *  - `drop`            — discard it with no note.
+     *  - `keep`            — distil nothing (reported as a decline, so the
+     *                        run says why the window is not being reclaimed). */
+    reasoning?: "recap" | "drop" | "keep";
+    /** Character budget for the running recap note (default 512).
+     *
+     *  ⚠️ The summariser's token budget is derived from this
+     *  (`recapMaxChars/4 + 64`), so the default allows ~192 tokens. A model that
+     *  spends its budget on reasoning can return nothing at all, which the run
+     *  reports as a `context_distill_declined` event with reason
+     *  `empty_summary`. Raise this, or pick an effort that stops the model
+     *  thinking. */
+    recapMaxChars?: number;
+    /** Auto-distil when used/window ≥ N% (50..95; default 80). This is the live
+     *  threshold in recap mode — NOT `compaction.autocompactAtPct`. */
+    autorecapAtPct?: number;
+    /** JSON Schema the stateful mode validates every state patch against.
+     *  Stateful mode only. */
+    stateSchema?: Record<string, unknown>;
+    /** What a stateful run does with a patch that fails the schema
+     *  (`retry` default, or `fail`). */
+    onInvalidPatch?: "retry" | "fail";
+    /** How many times a rejected patch may be retried (default 2). */
+    maxPatchRetries?: number;
+    /** Grant the Recall tool so the agent can fetch back detail the
+     *  distillation dropped. */
+    recall?: boolean;
+    /** Bank each evicted span for the memory consolidator.
+     *
+     *  This is the flag the recap and stateful paths actually read —
+     *  `compaction.memoryFlush` installs the banking callback but nothing
+     *  outside append mode calls it. */
+    harvestToMemory?: boolean;
+}
 /** Opaque caller-tracking lineage (v0.12.x) attached to a run and
  *  propagated to all its sub-agents. The runtime stores and echoes
  *  these fields verbatim and never interprets them. All fields
@@ -457,6 +680,9 @@ export interface ContinueOptions extends RunOverrideOptions {
     sampling?: SamplingOptions;
     /** Per-continuation context-compaction override — see {@link RunOptions.compaction}. */
     compaction?: CompactionOptions;
+    /** Per-continuation context-distillation override — see
+     *  {@link RunOptions.context}. */
+    context?: ContextOptions;
     /** Per-continuation context-WINDOW override in tokens — see
      *  {@link RunOptions.maxContextTokens}. */
     maxContextTokens?: number;
@@ -2244,6 +2470,25 @@ export interface AgentDefOverlay {
     tools?: string[];
     skills?: string[];
     memory_scopes?: string[];
+    /** RFC DF: recall attaches the conversation TURN each fact was distilled from,
+     *  for this agent, WITHOUT the model asking for it. Operator-set on purpose — a
+     *  tool parameter is a decision the model makes, and measured across three local
+     *  models they do not make it. Also gated by `history_scope`: this decides whether
+     *  turns are OFFERED, history_scope whether they may be READ. */
+    recall_include_turns?: boolean;
+    /** Also run the QUESTION-anchored trace search on every `recall` and return those
+     *  turns as their own block, beside the facts.
+     *
+     *  Distinct from `recall_include_turns`, which attaches the turn each recalled FACT
+     *  was distilled from: fact-anchored retrieval can only reach turns some fact was
+     *  already extracted from, and the turns that answer the rest are the ones the
+     *  extractor passed over. Measured on one corpus the two routes differ by 24 points.
+     *
+     *  Operator-set, with deliberately NO tool parameter: told to pass the sibling's
+     *  parameter on every call, one model passed it on 51 of 128. Also gated by
+     *  `history_scope`, and needs the trace index enabled AND backfilled — an empty
+     *  index yields zero turns silently. */
+    recall_attach_traces?: boolean;
     memory_quota_bytes?: number;
     memory_backend?: string;
     retry_attempts?: number;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@loomcycle/client",
-  "version": "1.82.0",
+  "version": "1.84.0",
   "description": "TypeScript client for the loomcycle sidecar (HTTP+SSE). 71 methods covering run streaming, agent metadata, pause/resume/state, resolver re-probe (resolveProbe — issue #88 operator escape hatch), operator-token admin (operatorTokenDef — RFC L OSS multi-tenant auth) + whoami (RFC L authoritative principal, v0.17.0) + tenant-scoped listUsers / listUserAgents, dynamic MCP registration (mcpServerDef + v0.18.0 typed mcpServerDefVerify + ensureMcpServer idempotent register-if-changed), snapshot lifecycle, memory admin (incl. v0.9.0 Vector Memory embed_stats + reembed AND v0.11.5 setMemoryEntry + deleteMemoryEntry), interruption resolve, hook management, v0.8.22 substrate admin (agentDef + skillDef), v0.9.x n8n Phase 0 (listChannels + streamUserRunStates), v0.9.x Channel CRUD (publishChannel + subscribeChannel + peekChannel + ackChannel), v0.11.5 Channel admin CRUD (createChannel + updateChannel + deleteChannel — runtime substrate; yaml channels refuse mutation with HTTP 409), v0.9.x content_sha256 verify, v0.9.1 transcript first-cycle, v0.9.x dynamic MCP server registration (mcpServerDef + MCPServerDefVerifyResult), v0.10.3 Library v2 enumeration (listLibraryAgents + listLibrarySkills + listLibraryMcpServers), and v0.11.0 LLM Gateway (llmChat + llmStream — direct provider routing without agent overhead; primary target is n8n's LoomCycleChatModel AI Agent sub-node and any LangChain-compatible consumer). v0.10.1 — dual ESM + CommonJS distribution (additive — ESM consumers unchanged; CJS consumers like n8n's community-node loader now work). v0.19.0 — typed inline code-js agent ingestion (AgentDefOverlay.code_body + ensureCodeAgent — register a deterministic code agent through the substrate with no host filesystem bind; RFC J). v0.20.0 — ensureMcpServer surfaces discoveredToolCount straight from create (loomcycle now auto-discovers MCP tools at ingestion); rediscover is now an explicit force-refresh. v0.21.0 — run/continue accept optional non-secret `metadata` (repo name, review policy, …) passed to the agent, symmetric with the WebHook/Schedule trigger paths. v0.22.0 — version-aligned lockstep release; no client-surface change (RFC N tenant isolation of the agent/skill/MCP/Schedule/Webhook definition plane + real op-schemas on the builtin MCP meta-tools are both server-side). v0.23.0 — version-aligned lockstep release; no client-surface change (RFCs O/P/R MCP-server hardening + thin client and the RFC Q DeepSeek tool-content fix are all server-side / MCP-transport-side). v0.24.0 — purgeChannel clears a channel's buffered messages without deleting its definition (allowed on yaml-declared channels too, unlike deleteChannel — F20); AgentDefOverlay gains channels / evaluation_scopes / interruption so a COMPLETE interactive/multi-agent agent round-trips over the substrate (F14). (Consolidates the interim 0.24/0.25 package bumps, which were never tag-published, back into lockstep with the loomcycle v0.24.0 tag.) v0.25.0 — adds the RFC S channel fan-in/fan-out client twins: awaitChannels() (wait for any/all/at_least N messages across channels, or a timeout — non-committing) + broadcastChannels() (publish one payload to N channels in one atomic-pre-flight call), the client-facing counterparts of the in-band Channel.await / Channel.broadcast tool ops (the rest of v0.25.0 — the manual-management Web UI console + Context op=time + max_fires self-retiring schedules — is server-side / in-band, no client-surface change). v0.29.1 — Usage gains optional `max_context_tokens` (the serving model's context-window ceiling, stamped by the loop from Provider.Capabilities() on each usage event) so a consumer can render a 'context used / max' gauge without a hard-coded per-model table; additive + optional, no behavior change. (Lockstep catch-up: the field landed in loomcycle v0.29.0 but the adapter publish skipped on a version mismatch; v0.29.1 realigns the package version with the release tag so it publishes.) v0.33.0 — gRPC + TS client parity for the RFC Y external fan-out and the compaction surface: spawnRunBatch() (POST /v1/runs:batch — spawn up to 32 fresh runs concurrently in one call, combined index-aligned envelope, per-child failures in-envelope) + compactRun(runId) (POST /v1/runs/{run_id}/compact — summarize a parked run's context); plus per-run sampling + compaction overrides now accepted on runStreaming / continueSession (an explicit temperature 0 is preserved as deterministic, not dropped as falsy). (The gRPC half adds the matching SpawnRunBatch / CompactRun RPCs + the sampling/compaction fields on RunRequest/ContinueRequest — server-side.) v0.34.0 — version-aligned lockstep release; no client-surface change (context-transform plugins / RFC Z Phase 1a are server-side config; the exp7 hardening pass is server-side; the R2 cross-provider thinking-model downgrade surfaces a new `model_downgraded` SSE event the generic stream passes through unchanged). v0.35.0 — RFC AH dynamic filesystem volumes: volumeDef() (POST /v1/_volumedef — op-discriminated create/get/list/delete/purge; a Volume is flat, so delete unmaps + purge RemoveAll's, no retire/promote/fork) + listVolumes() / listEphemeralVolumes() (GET /v1/_volumes[/ephemeral] — tenant-scoped; host paths redacted for non-operator callers). Tenant-confined; the runtime derives the path inside an operator-blessed dynamic_root, so callers pass name + mode, never a host path. v1.1.1 — RFC AI interactive agentic sessions: an `interactive: true` flag on runStreaming/continueSession (a run that parks at end_turn for steering) + sendRunInput(runId, text) (POST /v1/runs/{id}/input — steer a live run) + streamRunByID(runId, {fromSeq}) (GET /v1/runs/{id}/stream — re-attach by run_id; the operator's prior turns replay as `steer` events so a cold client reconstructs the whole conversation) + a high-level InteractiveSession driver (client.interactiveSession / attachInteractiveSession — events()/send()/cancel(), the adapter port of the Web UI run terminal). The AgentEvent union gains awaiting_input/steer/context_compaction frames. Version-aligned with the loomcycle v1.1.x line so the v1.1.1 tag publishes it (also carrying the previously-unpublished v0.35.0 volume surface). v1.4.0 — RFC AL Path VFS + RFC AK Document on the wire: path(input) (POST /v1/_path — a Unix-like filesystem over Memory/Volumes/Documents; resolve/ls/stat/mkdir/mv/rm) + document(input) (POST /v1/_document — chunked-graph documents; 13 ops, needs SQL Memory on the sidecar). Scope (agent/user/tenant) + tenant are resolved server-side from the authenticated principal, never the wire; an off-run scope:'user' op keys on the principal subject so it interoperates with that user's agent runs. New PathToolInput / DocumentToolInput types; responses are op-varying (unknown — narrow as needed). v1.7.0 — RFC AT image/vision input: the PromptContent union gains an `image` variant ({ type:'image'; media_type: ImageMediaType; data: base64-no-prefix }) accepted in a user segment by runStreaming / continueSession (segments pass through unchanged — no method change). The model must be vision-capable or the run errors before the call. New ImageMediaType type (image/png|jpeg|gif|webp). v1.12.1 — Path/Document browse-by-subject + the full Document op set (RFC AS/AK): path(input, opts) / document(input, opts) accept optional scopeId / tenant browse overrides sent as ?scope_id= / ?tenant= query params (server reads them from the URL, re-checks authorization; omit both to browse your own subject — byte-identical to the pre-RFC-AS request), and DocumentToolInput.op now covers all 16 backend ops (adds set_path, export_md, import_md) with the matching include_metadata / markdown fields. Additive — existing path() / document() callers are unchanged. v1.16.0 — RFC BC client-executed tools (local tool host): connectClientTools({tools,onInvoke}) opens a persistent WebSocket to /v1/client-tools, registers tools this client runs on the user's machine (browser DOM / files / shell), and answers the invoke frames loomcycle routes when an agent of your principal calls a client:<tool> — returning your reply as an ordinary tool result. Returns a ClientToolHost driver (.close() to stop; auto-reconnect); dependency-free (global WebSocket in browsers / Node 22+, or an injected WebSocketImpl like the ws package on older Node); the bearer rides the Sec-WebSocket-Protocol subprotocol (browsers can't set an Authorization header on a WebSocket). The runtime's first WebSocket surface. v1.45.0 — RFC BL P5 subject erasure: erasureReport(subject, {tenant}) (GET /v1/_erasure — what this deployment holds about one subject, in three tiers: deletable with existing primitives, subject-keyed but not deletable, and facts ABOUT the subject in scopes they do not own) + erasureExecute(subject, {dryRun, confirm, tenant}) (POST /v1/_erasure — removes tiers 1 and 2). DEFAULTS TO A DRY RUN: dryRun defaults true and a live run also requires confirm === subject. The tier-3 residue is traceable only through the subject's chats, which a live run deletes, so a report afterwards shows rows: 0 while those facts remain — the returned object is the only durable record of what was not reached; persist it. New ErasureReport / ErasureResult / ErasureTier / ErasureResidue types. v1.47.0 — RFC BV memory-view SDK: memorySearch() (POST /v1/_memory/search — off-run unified semantic search spanning k/v entries AND document-chunk bodies in one ranked list, each hit tagged kind memory|document with chunk_id on document hits) + memoryEmbedStats(scope) + reembedMemory(scope, scopeId, {dryRun,limit}) (the Vector Memory embed-admin reads the memory-view console needs; dry_run defaults true). Fact reads (list_facts + get_chunk's entity block) ride the existing document() passthrough. Additive — existing callers unchanged. v1.61.0 — RFC CJ per-run context-window override: runStreaming / continueSession accept an optional maxContextTokens (integer tokens) that wins over the agent's own max_context_tokens; omitted inherits it (which defers to the provider/driver default). Distinct from a model's output cap; primarily for local inference (Ollama num_ctx). Serialized as the snake_case max_context_tokens field on POST /v1/runs + the continuation body; additive, existing callers unchanged. v1.72.1 — the TeamDef version lifecycle: listTeamVersions(name) (op=list — every version of one team, newest first), promoteTeam(defId) (op=promote — point the active pointer, which is what a run BY NAME executes; forkTeam defaults to promote:false, so authoring and putting in force stay two steps), retireTeam(defId, retired) (op=retire — reversible and version-scoped, unlike deleteTeam) and verifyTeam(name, contentSha256) (op=verify — the drift check for a workflow kept in source control and pushed to several deployments; an absent team answers deployed:false rather than raising). The ops existed on the substrate and over HTTP; a client that could author a team could not put one in force.",
   "license": "Apache-2.0",
   "type": "module",