@loomcycle/client 0.34.0 → 1.1.1

package/README.md

@@ -12,6 +12,8 @@ TypeScript client for the [loomcycle](https://github.com/denn-gubsky/loomcycle)
 
 ### What's new since v0.8.18
 
+- **`interactiveSession` / `sendRunInput` / `streamRunByID` + the `interactive` flag** (v1.1.1, RFC AI) — the interactive agentic session, the adapter port of the Web UI's run terminal. Pass `interactive: true` to `runStreaming` / `continueSession` to start a **persistent** run that parks at end_turn (an `awaiting_input` frame) instead of ending; **`sendRunInput(runId, text)`** steers it (the response arrives on the same stream); **`streamRunByID(runId, {fromSeq})`** re-attaches by run_id (the operator's prior turns replay as `steer` events, `user_input.source === "replay"`, so a cold client — e.g. another device — reconstructs the whole conversation). The high-level **`client.interactiveSession({agent, segments})`** returns an `InteractiveSession` with `events()` / `send()` / `cancel()`; **`attachInteractiveSession(runId)`** resumes one. The `AgentEvent` union gains `awaiting_input` / `steer` / `context_compaction`.
+- **`volumeDef` / `listVolumes` / `listEphemeralVolumes`** (v0.35.0, RFC AH) — the dynamic filesystem-volume surface. `volumeDef` is the op-discriminated substrate tool (`create` / `get` / `list` / `delete` / `purge`); a Volume is **flat** (a pointer to mutable on-disk state, not a versioned def), so `delete` unmaps + leaves files while `purge` removes the row **and** the directory tree — there is no retire/promote/fork. Tenant-confined (`ScopeTenant`): the runtime derives the path inside an operator-blessed `dynamic_root`, so you pass `{name, mode}`, never a host path. `listVolumes()` / `listEphemeralVolumes()` return the tenant's persistent + live run-scoped volumes; host paths are redacted (`""`) for a non-operator caller.
 - **`ensureMcpServer` / `mcpServerDefVerify`** (v0.18.0) — typed ergonomics for the dynamic-MCP dedup flow. `ensureMcpServer({name, url, headers?, rediscover?})` registers a callback MCP server **idempotently**: it runs `create` (a no-op in loomcycle ≥ v0.18.0 when the active def already carries identical content) plus an optional `rediscover` (a no-op on unchanged tools), and returns `{defId, version, changed, discoveredToolCount?}` — so a consumer re-registering on every startup gets `changed: false` once its registration content is stable. Keep `${run.*}` / `${LOOMCYCLE_*}` header placeholders **literal** (don't bake a per-restart token) or the content varies each boot and dedup can't engage. `mcpServerDefVerify(name, sha)` is the typed `op: verify` wrapper (`matches: true` = no-op signal).
 - **`operatorTokenDef` / `whoami` + tenant-scoped reads** (v0.17.0, RFC L) — the OSS multi-tenant authorization surface. `operatorTokenDef` is the op-discriminated admin tool over the `OperatorTokenDef` substrate (create / rotate / retire per-principal bearer tokens); `whoami()` returns the authoritative `(tenant, subject, scopes, is_admin)` resolved from the calling bearer; `listUsers({ tenant })` / `listUserAgents(userId, { tenant })` accept a super-admin tenant-focus (ignored server-side for a tenant principal — its own tenant is forced).
 
@@ -104,8 +106,31 @@ All methods are async / return `Promise<T>` unless noted; streaming methods retu
 
 | Method | Returns | Notes |
 |---|---|---|
-| `runStreaming(opts: RunOptions)` | `AsyncIterable<AgentEvent>` | Server-streams provider events for a fresh run. |
+| `runStreaming(opts: RunOptions)` | `AsyncIterable<AgentEvent>` | Server-streams provider events for a fresh run. `interactive: true` parks at end_turn for steering (RFC AI). |
 | `continueSession(opts: ContinueOptions)` | `AsyncIterable<AgentEvent>` | Continues an existing session. |
+| `sendRunInput(runId, text)` | `{run_id, delivered}` | RFC AI — steer a live interactive run (`POST /v1/runs/{id}/input`). |
+| `streamRunByID(runId, {fromSeq})` | `AsyncIterable<AgentEvent>` | RFC AI — re-attach by run_id (`GET /v1/runs/{id}/stream`); replays operator turns as `steer` events. |
+| `interactiveSession(opts)` / `attachInteractiveSession(runId)` | `InteractiveSession` | RFC AI — high-level driver: `events()` / `send()` / `cancel()`. |
+
+### Interactive sessions (RFC AI)
+
+```ts
+const sess = client.interactiveSession({
+  agent: "assistant",
+  segments: [{ role: "user", content: [{ type: "trusted-text", text: "help me debug" }] }],
+});
+for await (const ev of sess.events()) {
+  if (ev.type === "text") process.stdout.write(ev.text ?? "");
+  if (ev.type === "awaiting_input") {
+    await sess.send(await prompt("you> ")); // steers; response arrives on this same loop
+  }
+  if (ev.type === "done") break;
+}
+// later, from anywhere (another process / device): resume the same run
+const resumed = client.attachInteractiveSession(sess.runId);
+```
+
+The low-level primitives (`runStreaming({interactive:true})` + `sendRunInput` + `streamRunByID`) are the escape hatch if you'd rather drive the stream yourself.
 
 ### Agent metadata
 
@@ -274,6 +299,32 @@ Operations on AgentDef: `create` / `fork` / `get` / `list` / `promote` / `retire
 
 Refusals throw `SubstrateToolRefusedError` (a scope deny / empty body / allowed-tools widening); transport failures throw the usual typed errors (`AuthError`, `UnavailableError`, etc.).
 
+### Dynamic filesystem volumes (v0.35.0 — RFC AH)
+
+Per-tenant, ro/rw filesystem roots an agent can be bound to. `volumeDef` provisions and manages them at runtime; the two list methods render the volume universe. Tenant-confined (`ScopeTenant`).
+
+| Method | Returns | Notes |
+|---|---|---|
+| `volumeDef(input)` | `Promise<SubstrateToolResponse>` | Op-discriminated (`create` / `get` / `list` / `delete` / `purge`). Mirrors `POST /v1/_volumedef`. |
+| `listVolumes()` | `Promise<PersistentVolumesResponse>` | Static (read-only floor) + the tenant's dynamic volumes. `GET /v1/_volumes`. |
+| `listEphemeralVolumes()` | `Promise<EphemeralVolumesResponse>` | Live, run-scoped volumes (auto-purged at run completion). `GET /v1/_volumes/ephemeral`. |
+
+A Volume is **flat** — a pointer to mutable on-disk state, not a versioned definition — so the op set is `create` / `get` / `list` / `delete` / `purge` (no retire/promote/fork). The runtime DERIVES the path inside an operator-blessed `dynamic_root` (`<root>/<tenant>/<name>`), so you pass `{name, mode}` and never a host path:
+
+```ts
+// Provision a writable per-tenant volume (the runtime mkdir's it).
+await client.volumeDef({ op: "create", name: "repo-a", mode: "rw" });
+
+// Unmap (keeps files) vs. destroy (RemoveAll's the tree).
+await client.volumeDef({ op: "delete", name: "repo-a" }); // non-destructive
+await client.volumeDef({ op: "purge",  name: "repo-a" }); // destructive
+
+const { entries } = await client.listVolumes();
+// entries[].path is "" (redacted) unless the caller is operator-equivalent.
+```
+
+Refusals throw `SubstrateToolRefusedError` (collision with a static volume name, no `dynamic_root` configured, cross-tenant); transport failures throw the usual typed errors.
+
 ### Channels + run-state stream (v0.9.x n8n Phase 0)
 
 Two substrate-side surfaces added in the n8n integration's Phase 0 wire-API work. Useful for any orchestrator (not just n8n) that needs to see channel state or subscribe to run-state transitions.

package/dist/cjs/client.js

@@ -28,6 +28,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.LoomcycleClient = void 0;
 const fetch_helpers_js_1 = require("./fetch-helpers.js");
 const stream_js_1 = require("./stream.js");
+const interactive_js_1 = require("./interactive.js");
 /** samplingToWire maps the camelCase SamplingOptions to the snake_case wire
  *  object, omitting unset fields so they inherit the agent's value. */
 function samplingToWire(s) {
@@ -107,6 +108,8 @@ function runBody(opts) {
         body.sampling = samplingToWire(opts.sampling);
     if (opts.compaction !== undefined)
         body.compaction = compactionToWire(opts.compaction);
+    if (opts.interactive !== undefined)
+        body.interactive = opts.interactive;
     return body;
 }
 class LoomcycleClient {
@@ -189,8 +192,65 @@ class LoomcycleClient {
             body.sampling = samplingToWire(opts.sampling);
         if (opts.compaction !== undefined)
             body.compaction = compactionToWire(opts.compaction);
+        if (opts.interactive !== undefined)
+            body.interactive = opts.interactive;
         yield* this.streamSSE(`/v1/sessions/${encodeURIComponent(opts.sessionId)}/messages`, body, opts.signal, opts.debug);
     }
+    /** Push an operator steering message into a LIVE interactive run (RFC AI).
+     *  Mirrors `POST /v1/runs/{run_id}/input`. The run must be in-flight —
+     *  parked at end_turn awaiting input, or mid-turn (the message is drained
+     *  at the next iteration boundary). Does NOT open a stream; the operator's
+     *  turn + the model's response arrive on the run's OWN event stream
+     *  (the open `runStreaming` iterator, or a `streamRunByID` re-attach).
+     *  Returns `{ run_id, delivered }`.
+     *
+     *  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);
+    }
+    /** 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
+     *  operator's own prior turns are replayed as `steer` events
+     *  (`user_input.source === "replay"`), so a cold client — e.g. resuming on
+     *  another device — reconstructs the whole conversation. A PARKED
+     *  interactive run keeps streaming until it ends or `signal` aborts; a
+     *  disconnect does NOT stop the run.
+     *
+     *  The first frame is an `agent` side-channel carrying the run's
+     *  agent_id / session_id (for `sendRunInput` / `cancelAgent`). */
+    async *streamRunByID(runId, opts) {
+        const q = opts?.fromSeq ? `?from_seq=${opts.fromSeq}` : "";
+        yield* this.streamSSEGet(`/v1/runs/${encodeURIComponent(runId)}/stream${q}`, opts?.signal);
+    }
+    /** Start a high-level INTERACTIVE session (RFC AI) — the ergonomic driver
+     *  for a persistent run you converse with turn by turn. Starts an
+     *  `interactive` run and returns an {@link InteractiveSession} whose
+     *  `events()` you iterate and whose `send()` / `cancel()` steer it. See
+     *  {@link InteractiveSession}. For the raw primitives, use
+     *  {@link LoomcycleClient.runStreaming} with `interactive: true` +
+     *  {@link LoomcycleClient.sendRunInput}. */
+    interactiveSession(opts) {
+        const source = this.runStreaming({ ...opts, interactive: true });
+        return new interactive_js_1.InteractiveSession(source, {
+            sendRunInput: (rid, t) => this.sendRunInput(rid, t),
+            cancelAgent: (aid) => this.cancelAgent(aid),
+        });
+    }
+    /** Re-attach to a detached interactive run by `run_id` as a high-level
+     *  {@link InteractiveSession} — e.g. resuming on another device. The run_id
+     *  is known up front, so `send()` works immediately. Replays the
+     *  conversation (incl. the operator's prior turns, RFC AI) then live-tails. */
+    attachInteractiveSession(runId, opts) {
+        const source = this.streamRunByID(runId, opts);
+        const session = new interactive_js_1.InteractiveSession(source, {
+            sendRunInput: (rid, t) => this.sendRunInput(rid, t),
+            cancelAgent: (aid) => this.cancelAgent(aid),
+        });
+        session.runId = runId;
+        return session;
+    }
     /**
      * Spawn N fresh runs concurrently in ONE call (RFC Y external fan-out) and
      * resolve once they ALL settle, returning the combined index-aligned
@@ -744,6 +804,48 @@ class LoomcycleClient {
     async operatorTokenDef(input, opts) {
         return (0, fetch_helpers_js_1.postJSON)(this.ctx, "/v1/_operatortokendef", input, opts);
     }
+    // ---- RFC AH (v0.35.0) dynamic filesystem volumes ----
+    /** Invoke the RFC AH VolumeDef substrate tool over HTTP. Provision +
+     *  manage CONFINED, per-tenant filesystem volumes at runtime.
+     *  Tenant-confined (ScopeTenant, not operator-admin-only): the runtime
+     *  stamps the caller's authoritative tenant and opaque-404s cross-tenant.
+     *
+     *  Op-discriminated input. A VolumeDef is FLAT (a pointer to mutable
+     *  on-disk state, not a versioned definition), so the op set is
+     *  `{op: "create" | "get" | "list" | "delete" | "purge", ...}` — NOT the
+     *  content-addressed retire/promote/fork of the other Def families:
+     *  - `create` — `{op, name, mode}`. The runtime DERIVES the path inside the
+     *    operator-blessed `dynamic_root` (`<root>/<tenant>/<name>`) and
+     *    `MkdirAll`s it; you never supply a host path.
+     *  - `delete` — non-destructive: drops the mapping, leaves files on disk.
+     *  - `purge`  — destructive: drops the mapping AND `RemoveAll`s the tree.
+     *
+     *  Raises {@link SubstrateToolRefusedError} on tool-level refusals
+     *  (collision with a static volume name, no `dynamic_root` configured,
+     *  cross-tenant); {@link InvalidArgumentError} on 400; {@link AuthError}
+     *  on 401. */
+    async volumeDef(input, opts) {
+        return (0, fetch_helpers_js_1.postJSON)(this.ctx, "/v1/_volumedef", input, opts);
+    }
+    /** List the PERSISTENT volume universe for the caller's tenant — every
+     *  static volume (the shared bind floor, `source: "static"`, read-only)
+     *  plus the tenant's own dynamic VolumeDefs (`source: "dynamic"`). Host
+     *  paths are redacted (`""`) for a non-operator (tenant) caller.
+     *
+     *  Wraps `GET /v1/_volumes` (RFC AH Phase 4). Bearer-authed; tenant-scoped
+     *  from the authoritative principal. */
+    async listVolumes(opts) {
+        return (0, fetch_helpers_js_1.jsonFetch)(this.ctx, "/v1/_volumes", opts);
+    }
+    /** List the LIVE ephemeral (run-scoped) volumes for the caller's tenant —
+     *  created mid-run, inherited by sub-agents, auto-purged when the run
+     *  completes. Host paths are redacted (`""`) for a non-operator caller.
+     *
+     *  Wraps `GET /v1/_volumes/ephemeral` (RFC AH Phase 4). Bearer-authed;
+     *  tenant-scoped from the authoritative principal. */
+    async listEphemeralVolumes(opts) {
+        return (0, fetch_helpers_js_1.jsonFetch)(this.ctx, "/v1/_volumes/ephemeral", opts);
+    }
     // ---- v0.10.3 Library v2 enumeration (read-only, merged yaml+substrate) ----
     /** List every agent the runtime knows about — yaml-static + dynamic
      *  AgentDefs merged into one envelope per name. Each entry carries
@@ -875,6 +977,29 @@ class LoomcycleClient {
      *  events AND a `{ type: "_meta", meta_subtype: "stream_close",
      *  meta_reason }` on EOF / abort / error. The default is silent
      *  (matches pre-v0.9.x behaviour). */
+    /** GET-based SSE stream (RFC AI re-attach). The interactive re-attach
+     *  endpoint is a GET with a query string, not a POST body, so it can't reuse
+     *  streamSSE; the parse + error handling are identical otherwise. No debug
+     *  shape — re-attach is a plain tail. */
+    async *streamSSEGet(path, signal) {
+        const headers = {
+            Accept: "text/event-stream, application/json",
+        };
+        if (this.ctx.authToken)
+            headers.Authorization = `Bearer ${this.ctx.authToken}`;
+        const resp = await this.ctx.fetchImpl(this.ctx.baseUrl + path, {
+            method: "GET",
+            headers,
+            signal,
+        });
+        if (!resp.ok) {
+            await (0, fetch_helpers_js_1.raiseFromResponse)(resp);
+        }
+        if (!resp.body) {
+            throw new Error("loomcycle: response has no body");
+        }
+        yield* (0, stream_js_1.parseSSE)(resp.body.getReader());
+    }
     async *streamSSE(path, body, signal, debug) {
         const headers = {
             "Content-Type": "application/json",

package/dist/cjs/index.js

@@ -53,6 +53,11 @@
  *     ensureMcpServer(opts): Promise<EnsureMcpServerResult>              // v0.18.0 — idempotent register-if-changed
  *     scheduleDef(input): Promise<SubstrateToolResponse>
  *
+ *     // Dynamic filesystem volumes (v0.35.0 — RFC AH; tenant-confined)
+ *     volumeDef(input): Promise<SubstrateToolResponse>            // create/get/list/delete/purge
+ *     listVolumes(): Promise<PersistentVolumesResponse>
+ *     listEphemeralVolumes(): Promise<EphemeralVolumesResponse>
+ *
  *     // Library v2 enumeration (v0.10.3 — yaml+substrate merged)
  *     listLibraryAgents(): Promise<LibraryListResponse<LibraryAgentDefinition>>
  *     listLibrarySkills(): Promise<LibraryListResponse<LibrarySkillDefinition>>
@@ -83,9 +88,11 @@
  * See `adapters/ts/README.md` for usage examples.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.UnavailableError = exports.SubstrateToolRefusedError = exports.SnapshotVersionError = exports.SnapshotTooLargeError = exports.SnapshotNotFoundError = exports.SessionNotFoundError = exports.SessionBusyError = exports.PerUserQuotaExhaustedError = exports.PauseNotConfiguredError = exports.NotPausedError = exports.LoomcycleError = exports.ChannelCursorRegressionError = exports.InvalidArgumentError = exports.NotFoundError = exports.HookNotFoundError = exports.BackpressureError = exports.AuthError = exports.AlreadyPausingError = exports.AgentNotFoundError = exports.AgentIDInUseError = exports.LoomcycleClient = void 0;
+exports.UnavailableError = exports.SubstrateToolRefusedError = exports.SnapshotVersionError = exports.SnapshotTooLargeError = exports.SnapshotNotFoundError = exports.SessionNotFoundError = exports.SessionBusyError = exports.PerUserQuotaExhaustedError = exports.PauseNotConfiguredError = exports.NotPausedError = exports.LoomcycleError = exports.ChannelCursorRegressionError = exports.InvalidArgumentError = exports.NotFoundError = exports.HookNotFoundError = exports.BackpressureError = exports.AuthError = exports.AlreadyPausingError = exports.AgentNotFoundError = exports.AgentIDInUseError = exports.InteractiveSession = exports.LoomcycleClient = void 0;
 var client_js_1 = require("./client.js");
 Object.defineProperty(exports, "LoomcycleClient", { enumerable: true, get: function () { return client_js_1.LoomcycleClient; } });
+var interactive_js_1 = require("./interactive.js");
+Object.defineProperty(exports, "InteractiveSession", { enumerable: true, get: function () { return interactive_js_1.InteractiveSession; } });
 var errors_js_1 = require("./errors.js");
 Object.defineProperty(exports, "AgentIDInUseError", { enumerable: true, get: function () { return errors_js_1.AgentIDInUseError; } });
 Object.defineProperty(exports, "AgentNotFoundError", { enumerable: true, get: function () { return errors_js_1.AgentNotFoundError; } });

package/dist/cjs/interactive.js

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InteractiveSession = void 0;
+/** A high-level driver for an interactive agentic session (RFC AI) — the
+ *  adapter port of the Web UI's run terminal. It wraps the underlying event
+ *  stream (a fresh `interactive` run, or a `streamRunByID` re-attach), taps
+ *  each frame to track the run's tracking IDs + parked state, and routes
+ *  operator input + cancel through the client.
+ *
+ *  Typical loop:
+ *  ```ts
+ *  const sess = client.interactiveSession({ agent: "chat", segments: [...] });
+ *  for await (const ev of sess.events()) {
+ *    if (ev.type === "text") process.stdout.write(ev.text ?? "");
+ *    if (ev.type === "awaiting_input") await sess.send(await prompt("you> "));
+ *  }
+ *  ```
+ *  `send()` does NOT open a new stream — the operator's turn and the model's
+ *  response arrive on the same `events()` iterator. */
+class InteractiveSession {
+    source;
+    ops;
+    /** The run's id, from the first `agent` frame (set up-front on re-attach). */
+    runId = "";
+    /** The run's agent_id (for cancel), from the first `agent` frame. */
+    agentId = "";
+    /** The run's session_id, from the `session` / `agent` frames. */
+    sessionId = "";
+    /** True after an `awaiting_input` frame; cleared on the next activity. */
+    awaitingInput = false;
+    constructor(source, ops) {
+        this.source = source;
+        this.ops = ops;
+    }
+    /** The merged event stream. Consume with `for await`. Each frame updates the
+     *  session's runId / agentId / sessionId / awaitingInput BEFORE it is
+     *  yielded, so a consumer that reacts to `awaiting_input` can immediately
+     *  `send()`. */
+    async *events() {
+        for await (const ev of this.source) {
+            if (ev.type === "agent") {
+                if (ev.run_id)
+                    this.runId = ev.run_id;
+                if (ev.agent_id)
+                    this.agentId = ev.agent_id;
+                if (ev.session_id)
+                    this.sessionId = ev.session_id;
+            }
+            else if (ev.type === "session" && ev.session_id) {
+                this.sessionId = ev.session_id;
+            }
+            this.awaitingInput = ev.type === "awaiting_input";
+            yield ev;
+        }
+    }
+    /** Steer the live run with an operator message. The response arrives on the
+     *  `events()` stream (NOT a new stream). Returns the server's `delivered`
+     *  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) {
+        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);
+        this.awaitingInput = false;
+        return delivered;
+    }
+    /** Cancel the run (and its sub-agents). No-op if the agent_id isn't known
+     *  yet (nothing to cancel). */
+    async cancel() {
+        if (this.agentId)
+            await this.ops.cancelAgent(this.agentId);
+    }
+}
+exports.InteractiveSession = InteractiveSession;

package/dist/client.d.ts

@@ -23,7 +23,8 @@
  * via fetch-helpers.ts:raiseFromResponse — see README.md for the
  * full mapping table.
  */
-import type { 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, ChannelSubscribeResult, CreateChannelOptions, ListChannelsResponse, PeekChannelOptions, PublishChannelOptions, SetMemoryEntryOptions, SetMemoryEntryResponse, SubscribeChannelOptions, UpdateChannelOptions, LibraryAgentDefinition, LibraryListResponse, LibraryMcpServerDefinition, LibrarySkillDefinition, ListUsersResponse, LLMChatOptions, LLMChatResponse, LLMChatStreamItem, LLMEmbeddingsOptions, LLMEmbeddingsResponse, MCPServerDefVerifyResult, MemoryEntriesResponse, MemoryEntryResponse, MemoryScopeIDsResponse, MemoryScopesResponse, PauseResult, RegisterHookOptions, RegisterHookResponse, ResolveInterruptOptions, ResumeResult, ResolverMatrix, CompactRunResult, RunBatchOptions, RunBatchResult, RunOptions, RunStateStreamItem, RuntimeStateResponse, SnapshotCreateResponse, SnapshotDescriptor, SnapshotEnvelope, SnapshotRestoreResponse, StreamUserRunStatesOptions, SubstrateToolInput, SubstrateToolResponse, TranscriptResponse, WhoamiResponse } from "./types.js";
+import { InteractiveSession } from "./interactive.js";
+import type { 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, ChannelSubscribeResult, CreateChannelOptions, ListChannelsResponse, PeekChannelOptions, PublishChannelOptions, SetMemoryEntryOptions, SetMemoryEntryResponse, SubscribeChannelOptions, UpdateChannelOptions, LibraryAgentDefinition, LibraryListResponse, LibraryMcpServerDefinition, LibrarySkillDefinition, ListUsersResponse, LLMChatOptions, LLMChatResponse, LLMChatStreamItem, LLMEmbeddingsOptions, LLMEmbeddingsResponse, MCPServerDefVerifyResult, MemoryEntriesResponse, MemoryEntryResponse, MemoryScopeIDsResponse, MemoryScopesResponse, PauseResult, PersistentVolumesResponse, EphemeralVolumesResponse, RegisterHookOptions, RegisterHookResponse, ResolveInterruptOptions, ResumeResult, ResolverMatrix, CompactRunResult, RunBatchOptions, RunBatchResult, RunOptions, RunStateStreamItem, RuntimeStateResponse, SnapshotCreateResponse, SnapshotDescriptor, SnapshotEnvelope, SnapshotRestoreResponse, StreamUserRunStatesOptions, SubstrateToolInput, SubstrateToolResponse, TranscriptResponse, WhoamiResponse } from "./types.js";
 export declare class LoomcycleClient {
     private ctx;
     constructor(opts?: ClientOptions);
@@ -67,6 +68,53 @@ export declare class LoomcycleClient {
      * `_meta` open/close events.
      */
     continueSession(opts: ContinueOptions): AsyncIterable<AgentEvent>;
+    /** Push an operator steering message into a LIVE interactive run (RFC AI).
+     *  Mirrors `POST /v1/runs/{run_id}/input`. The run must be in-flight —
+     *  parked at end_turn awaiting input, or mid-turn (the message is drained
+     *  at the next iteration boundary). Does NOT open a stream; the operator's
+     *  turn + the model's response arrive on the run's OWN event stream
+     *  (the open `runStreaming` iterator, or a `streamRunByID` re-attach).
+     *  Returns `{ run_id, delivered }`.
+     *
+     *  Raises {@link UnavailableError} (503, steering off / no run),
+     *  {@link AuthError} (401). A full steer queue surfaces as a 429. */
+    sendRunInput(runId: string, text: string, opts?: {
+        signal?: AbortSignal;
+    }): Promise<{
+        run_id: string;
+        delivered: boolean;
+    }>;
+    /** 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
+     *  operator's own prior turns are replayed as `steer` events
+     *  (`user_input.source === "replay"`), so a cold client — e.g. resuming on
+     *  another device — reconstructs the whole conversation. A PARKED
+     *  interactive run keeps streaming until it ends or `signal` aborts; a
+     *  disconnect does NOT stop the run.
+     *
+     *  The first frame is an `agent` side-channel carrying the run's
+     *  agent_id / session_id (for `sendRunInput` / `cancelAgent`). */
+    streamRunByID(runId: string, opts?: {
+        fromSeq?: number;
+        signal?: AbortSignal;
+    }): AsyncIterable<AgentEvent>;
+    /** Start a high-level INTERACTIVE session (RFC AI) — the ergonomic driver
+     *  for a persistent run you converse with turn by turn. Starts an
+     *  `interactive` run and returns an {@link InteractiveSession} whose
+     *  `events()` you iterate and whose `send()` / `cancel()` steer it. See
+     *  {@link InteractiveSession}. For the raw primitives, use
+     *  {@link LoomcycleClient.runStreaming} with `interactive: true` +
+     *  {@link LoomcycleClient.sendRunInput}. */
+    interactiveSession(opts: Omit<RunOptions, "interactive">): InteractiveSession;
+    /** Re-attach to a detached interactive run by `run_id` as a high-level
+     *  {@link InteractiveSession} — e.g. resuming on another device. The run_id
+     *  is known up front, so `send()` works immediately. Replays the
+     *  conversation (incl. the operator's prior turns, RFC AI) then live-tails. */
+    attachInteractiveSession(runId: string, opts?: {
+        fromSeq?: number;
+        signal?: AbortSignal;
+    }): InteractiveSession;
     /**
      * Spawn N fresh runs concurrently in ONE call (RFC Y external fan-out) and
      * resolve once they ALL settle, returning the combined index-aligned
@@ -486,6 +534,47 @@ export declare class LoomcycleClient {
     operatorTokenDef(input: SubstrateToolInput, opts?: {
         signal?: AbortSignal;
     }): Promise<SubstrateToolResponse>;
+    /** Invoke the RFC AH VolumeDef substrate tool over HTTP. Provision +
+     *  manage CONFINED, per-tenant filesystem volumes at runtime.
+     *  Tenant-confined (ScopeTenant, not operator-admin-only): the runtime
+     *  stamps the caller's authoritative tenant and opaque-404s cross-tenant.
+     *
+     *  Op-discriminated input. A VolumeDef is FLAT (a pointer to mutable
+     *  on-disk state, not a versioned definition), so the op set is
+     *  `{op: "create" | "get" | "list" | "delete" | "purge", ...}` — NOT the
+     *  content-addressed retire/promote/fork of the other Def families:
+     *  - `create` — `{op, name, mode}`. The runtime DERIVES the path inside the
+     *    operator-blessed `dynamic_root` (`<root>/<tenant>/<name>`) and
+     *    `MkdirAll`s it; you never supply a host path.
+     *  - `delete` — non-destructive: drops the mapping, leaves files on disk.
+     *  - `purge`  — destructive: drops the mapping AND `RemoveAll`s the tree.
+     *
+     *  Raises {@link SubstrateToolRefusedError} on tool-level refusals
+     *  (collision with a static volume name, no `dynamic_root` configured,
+     *  cross-tenant); {@link InvalidArgumentError} on 400; {@link AuthError}
+     *  on 401. */
+    volumeDef(input: SubstrateToolInput, opts?: {
+        signal?: AbortSignal;
+    }): Promise<SubstrateToolResponse>;
+    /** List the PERSISTENT volume universe for the caller's tenant — every
+     *  static volume (the shared bind floor, `source: "static"`, read-only)
+     *  plus the tenant's own dynamic VolumeDefs (`source: "dynamic"`). Host
+     *  paths are redacted (`""`) for a non-operator (tenant) caller.
+     *
+     *  Wraps `GET /v1/_volumes` (RFC AH Phase 4). Bearer-authed; tenant-scoped
+     *  from the authoritative principal. */
+    listVolumes(opts?: {
+        signal?: AbortSignal;
+    }): Promise<PersistentVolumesResponse>;
+    /** List the LIVE ephemeral (run-scoped) volumes for the caller's tenant —
+     *  created mid-run, inherited by sub-agents, auto-purged when the run
+     *  completes. Host paths are redacted (`""`) for a non-operator caller.
+     *
+     *  Wraps `GET /v1/_volumes/ephemeral` (RFC AH Phase 4). Bearer-authed;
+     *  tenant-scoped from the authoritative principal. */
+    listEphemeralVolumes(opts?: {
+        signal?: AbortSignal;
+    }): Promise<EphemeralVolumesResponse>;
     /** List every agent the runtime knows about — yaml-static + dynamic
      *  AgentDefs merged into one envelope per name. Each entry carries
      *  `source: "static-only" | "dynamic-only" | "both"` so callers can
@@ -583,6 +672,11 @@ export declare class LoomcycleClient {
      *  events AND a `{ type: "_meta", meta_subtype: "stream_close",
      *  meta_reason }` on EOF / abort / error. The default is silent
      *  (matches pre-v0.9.x behaviour). */
+    /** GET-based SSE stream (RFC AI re-attach). The interactive re-attach
+     *  endpoint is a GET with a query string, not a POST body, so it can't reuse
+     *  streamSSE; the parse + error handling are identical otherwise. No debug
+     *  shape — re-attach is a plain tail. */
+    private streamSSEGet;
     private streamSSE;
     /** List every operator-declared channel with aggregate stats
      *  (message_count, oldest_visible_at, newest_visible_at).

package/dist/client.js

@@ -25,6 +25,7 @@
  */
 import { authHeaders, deleteRequest, jsonFetch, patchJSON, postJSON, putJSON, raiseFromResponse, } from "./fetch-helpers.js";
 import { parseSSE } from "./stream.js";
+import { InteractiveSession } from "./interactive.js";
 /** samplingToWire maps the camelCase SamplingOptions to the snake_case wire
  *  object, omitting unset fields so they inherit the agent's value. */
 function samplingToWire(s) {
@@ -104,6 +105,8 @@ function runBody(opts) {
         body.sampling = samplingToWire(opts.sampling);
     if (opts.compaction !== undefined)
         body.compaction = compactionToWire(opts.compaction);
+    if (opts.interactive !== undefined)
+        body.interactive = opts.interactive;
     return body;
 }
 export class LoomcycleClient {
@@ -186,8 +189,65 @@ export class LoomcycleClient {
             body.sampling = samplingToWire(opts.sampling);
         if (opts.compaction !== undefined)
             body.compaction = compactionToWire(opts.compaction);
+        if (opts.interactive !== undefined)
+            body.interactive = opts.interactive;
         yield* this.streamSSE(`/v1/sessions/${encodeURIComponent(opts.sessionId)}/messages`, body, opts.signal, opts.debug);
     }
+    /** Push an operator steering message into a LIVE interactive run (RFC AI).
+     *  Mirrors `POST /v1/runs/{run_id}/input`. The run must be in-flight —
+     *  parked at end_turn awaiting input, or mid-turn (the message is drained
+     *  at the next iteration boundary). Does NOT open a stream; the operator's
+     *  turn + the model's response arrive on the run's OWN event stream
+     *  (the open `runStreaming` iterator, or a `streamRunByID` re-attach).
+     *  Returns `{ run_id, delivered }`.
+     *
+     *  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);
+    }
+    /** 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
+     *  operator's own prior turns are replayed as `steer` events
+     *  (`user_input.source === "replay"`), so a cold client — e.g. resuming on
+     *  another device — reconstructs the whole conversation. A PARKED
+     *  interactive run keeps streaming until it ends or `signal` aborts; a
+     *  disconnect does NOT stop the run.
+     *
+     *  The first frame is an `agent` side-channel carrying the run's
+     *  agent_id / session_id (for `sendRunInput` / `cancelAgent`). */
+    async *streamRunByID(runId, opts) {
+        const q = opts?.fromSeq ? `?from_seq=${opts.fromSeq}` : "";
+        yield* this.streamSSEGet(`/v1/runs/${encodeURIComponent(runId)}/stream${q}`, opts?.signal);
+    }
+    /** Start a high-level INTERACTIVE session (RFC AI) — the ergonomic driver
+     *  for a persistent run you converse with turn by turn. Starts an
+     *  `interactive` run and returns an {@link InteractiveSession} whose
+     *  `events()` you iterate and whose `send()` / `cancel()` steer it. See
+     *  {@link InteractiveSession}. For the raw primitives, use
+     *  {@link LoomcycleClient.runStreaming} with `interactive: true` +
+     *  {@link LoomcycleClient.sendRunInput}. */
+    interactiveSession(opts) {
+        const source = this.runStreaming({ ...opts, interactive: true });
+        return new InteractiveSession(source, {
+            sendRunInput: (rid, t) => this.sendRunInput(rid, t),
+            cancelAgent: (aid) => this.cancelAgent(aid),
+        });
+    }
+    /** Re-attach to a detached interactive run by `run_id` as a high-level
+     *  {@link InteractiveSession} — e.g. resuming on another device. The run_id
+     *  is known up front, so `send()` works immediately. Replays the
+     *  conversation (incl. the operator's prior turns, RFC AI) then live-tails. */
+    attachInteractiveSession(runId, opts) {
+        const source = this.streamRunByID(runId, opts);
+        const session = new InteractiveSession(source, {
+            sendRunInput: (rid, t) => this.sendRunInput(rid, t),
+            cancelAgent: (aid) => this.cancelAgent(aid),
+        });
+        session.runId = runId;
+        return session;
+    }
     /**
      * Spawn N fresh runs concurrently in ONE call (RFC Y external fan-out) and
      * resolve once they ALL settle, returning the combined index-aligned
@@ -741,6 +801,48 @@ export class LoomcycleClient {
     async operatorTokenDef(input, opts) {
         return postJSON(this.ctx, "/v1/_operatortokendef", input, opts);
     }
+    // ---- RFC AH (v0.35.0) dynamic filesystem volumes ----
+    /** Invoke the RFC AH VolumeDef substrate tool over HTTP. Provision +
+     *  manage CONFINED, per-tenant filesystem volumes at runtime.
+     *  Tenant-confined (ScopeTenant, not operator-admin-only): the runtime
+     *  stamps the caller's authoritative tenant and opaque-404s cross-tenant.
+     *
+     *  Op-discriminated input. A VolumeDef is FLAT (a pointer to mutable
+     *  on-disk state, not a versioned definition), so the op set is
+     *  `{op: "create" | "get" | "list" | "delete" | "purge", ...}` — NOT the
+     *  content-addressed retire/promote/fork of the other Def families:
+     *  - `create` — `{op, name, mode}`. The runtime DERIVES the path inside the
+     *    operator-blessed `dynamic_root` (`<root>/<tenant>/<name>`) and
+     *    `MkdirAll`s it; you never supply a host path.
+     *  - `delete` — non-destructive: drops the mapping, leaves files on disk.
+     *  - `purge`  — destructive: drops the mapping AND `RemoveAll`s the tree.
+     *
+     *  Raises {@link SubstrateToolRefusedError} on tool-level refusals
+     *  (collision with a static volume name, no `dynamic_root` configured,
+     *  cross-tenant); {@link InvalidArgumentError} on 400; {@link AuthError}
+     *  on 401. */
+    async volumeDef(input, opts) {
+        return postJSON(this.ctx, "/v1/_volumedef", input, opts);
+    }
+    /** List the PERSISTENT volume universe for the caller's tenant — every
+     *  static volume (the shared bind floor, `source: "static"`, read-only)
+     *  plus the tenant's own dynamic VolumeDefs (`source: "dynamic"`). Host
+     *  paths are redacted (`""`) for a non-operator (tenant) caller.
+     *
+     *  Wraps `GET /v1/_volumes` (RFC AH Phase 4). Bearer-authed; tenant-scoped
+     *  from the authoritative principal. */
+    async listVolumes(opts) {
+        return jsonFetch(this.ctx, "/v1/_volumes", opts);
+    }
+    /** List the LIVE ephemeral (run-scoped) volumes for the caller's tenant —
+     *  created mid-run, inherited by sub-agents, auto-purged when the run
+     *  completes. Host paths are redacted (`""`) for a non-operator caller.
+     *
+     *  Wraps `GET /v1/_volumes/ephemeral` (RFC AH Phase 4). Bearer-authed;
+     *  tenant-scoped from the authoritative principal. */
+    async listEphemeralVolumes(opts) {
+        return jsonFetch(this.ctx, "/v1/_volumes/ephemeral", opts);
+    }
     // ---- v0.10.3 Library v2 enumeration (read-only, merged yaml+substrate) ----
     /** List every agent the runtime knows about — yaml-static + dynamic
      *  AgentDefs merged into one envelope per name. Each entry carries
@@ -872,6 +974,29 @@ export class LoomcycleClient {
      *  events AND a `{ type: "_meta", meta_subtype: "stream_close",
      *  meta_reason }` on EOF / abort / error. The default is silent
      *  (matches pre-v0.9.x behaviour). */
+    /** GET-based SSE stream (RFC AI re-attach). The interactive re-attach
+     *  endpoint is a GET with a query string, not a POST body, so it can't reuse
+     *  streamSSE; the parse + error handling are identical otherwise. No debug
+     *  shape — re-attach is a plain tail. */
+    async *streamSSEGet(path, signal) {
+        const headers = {
+            Accept: "text/event-stream, application/json",
+        };
+        if (this.ctx.authToken)
+            headers.Authorization = `Bearer ${this.ctx.authToken}`;
+        const resp = await this.ctx.fetchImpl(this.ctx.baseUrl + path, {
+            method: "GET",
+            headers,
+            signal,
+        });
+        if (!resp.ok) {
+            await raiseFromResponse(resp);
+        }
+        if (!resp.body) {
+            throw new Error("loomcycle: response has no body");
+        }
+        yield* parseSSE(resp.body.getReader());
+    }
     async *streamSSE(path, body, signal, debug) {
         const headers = {
             "Content-Type": "application/json",

package/dist/index.d.ts

@@ -52,6 +52,11 @@
  *     ensureMcpServer(opts): Promise<EnsureMcpServerResult>              // v0.18.0 — idempotent register-if-changed
  *     scheduleDef(input): Promise<SubstrateToolResponse>
  *
+ *     // Dynamic filesystem volumes (v0.35.0 — RFC AH; tenant-confined)
+ *     volumeDef(input): Promise<SubstrateToolResponse>            // create/get/list/delete/purge
+ *     listVolumes(): Promise<PersistentVolumesResponse>
+ *     listEphemeralVolumes(): Promise<EphemeralVolumesResponse>
+ *
  *     // Library v2 enumeration (v0.10.3 — yaml+substrate merged)
  *     listLibraryAgents(): Promise<LibraryListResponse<LibraryAgentDefinition>>
  *     listLibrarySkills(): Promise<LibraryListResponse<LibrarySkillDefinition>>
@@ -82,5 +87,7 @@
  * See `adapters/ts/README.md` for usage examples.
  */
 export { LoomcycleClient } from "./client.js";
-export type { AgentEvent, ClientOptions, ContinueOptions, EventType, HostWidening, ParentContext, PromptContent, PromptSegment, RetryInfo, RunOptions, SamplingOptions, CompactionOptions, ToolUse, Usage, Agent, AgentStatus, AgentUsage, CancelAgentResult, ListAgentsResponse, RunBatchOptions, RunBatchResult, SpawnRunResult, CompactRunResult, TranscriptEvent, TranscriptResponse, HealthResponse, ListUsersResponse, UserSummary, WhoamiResponse, PauseResult, ResumeResult, RuntimeStateResponse, RuntimeStateStatus, ResolverMatrix, ResolverModelStatus, ResolverProviderAvailability, CreateSnapshotOptions, SnapshotCreateResponse, SnapshotDescriptor, SnapshotEnvelope, SnapshotListResponse, SnapshotRestoreResponse, MemoryEntriesResponse, MemoryEntry, MemoryEntryResponse, MemoryScopeIDsResponse, MemoryScopeIDSummary, MemoryScopeKind, MemoryScopesResponse, InterruptListResponse, InterruptRow, InterruptStatus, ResolveInterruptOptions, Hook, HookFailMode, HookPhase, HookToolCall, HookToolResult, ListHooksResponse, PostHookCall, PostHookResult, PreHookCall, PreHookResult, RegisterHookOptions, RegisterHookResponse, SubstrateToolInput, SubstrateToolResponse, SystemPromptPayload, UserInputPayload, ChannelDescriptor, ListChannelsResponse, RunStateEvent, RunStateStreamClose, RunStateStreamItem, RunStateStreamOpen, StreamUserRunStatesOptions, AckChannelOptions, ChannelAckResult, ChannelMessageItem, ChannelPeekResult, ChannelPublishResult, ChannelPurgeResult, ChannelScope, ChannelSubscribeResult, PeekChannelOptions, PublishChannelOptions, SubscribeChannelOptions, AwaitChannelsOptions, BroadcastChannelsOptions, ChannelAwaitEntry, ChannelAwaitMode, ChannelAwaitResult, ChannelBroadcastEntry, ChannelBroadcastResult, CreateChannelOptions, 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, } from "./types.js";
+export { InteractiveSession } from "./interactive.js";
+export type { InteractiveSessionOps } from "./interactive.js";
+export type { AgentEvent, ClientOptions, ContinueOptions, EventType, HostWidening, ParentContext, PromptContent, PromptSegment, RetryInfo, RunOptions, SamplingOptions, CompactionOptions, ToolUse, Usage, Agent, AgentStatus, AgentUsage, CancelAgentResult, ListAgentsResponse, RunBatchOptions, RunBatchResult, SpawnRunResult, CompactRunResult, TranscriptEvent, TranscriptResponse, HealthResponse, ListUsersResponse, UserSummary, WhoamiResponse, PauseResult, ResumeResult, RuntimeStateResponse, RuntimeStateStatus, ResolverMatrix, ResolverModelStatus, ResolverProviderAvailability, CreateSnapshotOptions, SnapshotCreateResponse, SnapshotDescriptor, SnapshotEnvelope, SnapshotListResponse, SnapshotRestoreResponse, MemoryEntriesResponse, MemoryEntry, MemoryEntryResponse, MemoryScopeIDsResponse, MemoryScopeIDSummary, MemoryScopeKind, MemoryScopesResponse, InterruptListResponse, InterruptRow, InterruptStatus, ResolveInterruptOptions, Hook, HookFailMode, HookPhase, HookToolCall, HookToolResult, ListHooksResponse, PostHookCall, PostHookResult, PreHookCall, PreHookResult, RegisterHookOptions, RegisterHookResponse, SubstrateToolInput, SubstrateToolResponse, VolumeMode, PersistentVolumeEntry, PersistentVolumesResponse, EphemeralVolumeEntry, EphemeralVolumesResponse, SystemPromptPayload, UserInputPayload, ChannelDescriptor, ListChannelsResponse, RunStateEvent, RunStateStreamClose, RunStateStreamItem, RunStateStreamOpen, StreamUserRunStatesOptions, AckChannelOptions, ChannelAckResult, ChannelMessageItem, ChannelPeekResult, ChannelPublishResult, ChannelPurgeResult, ChannelScope, ChannelSubscribeResult, PeekChannelOptions, PublishChannelOptions, SubscribeChannelOptions, AwaitChannelsOptions, BroadcastChannelsOptions, ChannelAwaitEntry, ChannelAwaitMode, ChannelAwaitResult, ChannelBroadcastEntry, ChannelBroadcastResult, CreateChannelOptions, 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, } 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/index.js

@@ -52,6 +52,11 @@
  *     ensureMcpServer(opts): Promise<EnsureMcpServerResult>              // v0.18.0 — idempotent register-if-changed
  *     scheduleDef(input): Promise<SubstrateToolResponse>
  *
+ *     // Dynamic filesystem volumes (v0.35.0 — RFC AH; tenant-confined)
+ *     volumeDef(input): Promise<SubstrateToolResponse>            // create/get/list/delete/purge
+ *     listVolumes(): Promise<PersistentVolumesResponse>
+ *     listEphemeralVolumes(): Promise<EphemeralVolumesResponse>
+ *
  *     // Library v2 enumeration (v0.10.3 — yaml+substrate merged)
  *     listLibraryAgents(): Promise<LibraryListResponse<LibraryAgentDefinition>>
  *     listLibrarySkills(): Promise<LibraryListResponse<LibrarySkillDefinition>>
@@ -82,4 +87,5 @@
  * See `adapters/ts/README.md` for usage examples.
  */
 export { LoomcycleClient } from "./client.js";
+export { InteractiveSession } from "./interactive.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

@@ -0,0 +1,53 @@
+import type { AgentEvent } 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<{
+        delivered: boolean;
+    }>;
+    cancelAgent: (agentId: string) => Promise<unknown>;
+}
+/** A high-level driver for an interactive agentic session (RFC AI) — the
+ *  adapter port of the Web UI's run terminal. It wraps the underlying event
+ *  stream (a fresh `interactive` run, or a `streamRunByID` re-attach), taps
+ *  each frame to track the run's tracking IDs + parked state, and routes
+ *  operator input + cancel through the client.
+ *
+ *  Typical loop:
+ *  ```ts
+ *  const sess = client.interactiveSession({ agent: "chat", segments: [...] });
+ *  for await (const ev of sess.events()) {
+ *    if (ev.type === "text") process.stdout.write(ev.text ?? "");
+ *    if (ev.type === "awaiting_input") await sess.send(await prompt("you> "));
+ *  }
+ *  ```
+ *  `send()` does NOT open a new stream — the operator's turn and the model's
+ *  response arrive on the same `events()` iterator. */
+export declare class InteractiveSession {
+    private readonly source;
+    private readonly ops;
+    /** The run's id, from the first `agent` frame (set up-front on re-attach). */
+    runId: string;
+    /** The run's agent_id (for cancel), from the first `agent` frame. */
+    agentId: string;
+    /** The run's session_id, from the `session` / `agent` frames. */
+    sessionId: string;
+    /** True after an `awaiting_input` frame; cleared on the next activity. */
+    awaitingInput: boolean;
+    constructor(source: AsyncIterable<AgentEvent>, ops: InteractiveSessionOps);
+    /** The merged event stream. Consume with `for await`. Each frame updates the
+     *  session's runId / agentId / sessionId / awaitingInput BEFORE it is
+     *  yielded, so a consumer that reacts to `awaiting_input` can immediately
+     *  `send()`. */
+    events(): AsyncIterable<AgentEvent>;
+    /** Steer the live run with an operator message. The response arrives on the
+     *  `events()` stream (NOT a new stream). Returns the server's `delivered`
+     *  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>;
+    /** 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

@@ -0,0 +1,72 @@
+/** A high-level driver for an interactive agentic session (RFC AI) — the
+ *  adapter port of the Web UI's run terminal. It wraps the underlying event
+ *  stream (a fresh `interactive` run, or a `streamRunByID` re-attach), taps
+ *  each frame to track the run's tracking IDs + parked state, and routes
+ *  operator input + cancel through the client.
+ *
+ *  Typical loop:
+ *  ```ts
+ *  const sess = client.interactiveSession({ agent: "chat", segments: [...] });
+ *  for await (const ev of sess.events()) {
+ *    if (ev.type === "text") process.stdout.write(ev.text ?? "");
+ *    if (ev.type === "awaiting_input") await sess.send(await prompt("you> "));
+ *  }
+ *  ```
+ *  `send()` does NOT open a new stream — the operator's turn and the model's
+ *  response arrive on the same `events()` iterator. */
+export class InteractiveSession {
+    source;
+    ops;
+    /** The run's id, from the first `agent` frame (set up-front on re-attach). */
+    runId = "";
+    /** The run's agent_id (for cancel), from the first `agent` frame. */
+    agentId = "";
+    /** The run's session_id, from the `session` / `agent` frames. */
+    sessionId = "";
+    /** True after an `awaiting_input` frame; cleared on the next activity. */
+    awaitingInput = false;
+    constructor(source, ops) {
+        this.source = source;
+        this.ops = ops;
+    }
+    /** The merged event stream. Consume with `for await`. Each frame updates the
+     *  session's runId / agentId / sessionId / awaitingInput BEFORE it is
+     *  yielded, so a consumer that reacts to `awaiting_input` can immediately
+     *  `send()`. */
+    async *events() {
+        for await (const ev of this.source) {
+            if (ev.type === "agent") {
+                if (ev.run_id)
+                    this.runId = ev.run_id;
+                if (ev.agent_id)
+                    this.agentId = ev.agent_id;
+                if (ev.session_id)
+                    this.sessionId = ev.session_id;
+            }
+            else if (ev.type === "session" && ev.session_id) {
+                this.sessionId = ev.session_id;
+            }
+            this.awaitingInput = ev.type === "awaiting_input";
+            yield ev;
+        }
+    }
+    /** Steer the live run with an operator message. The response arrives on the
+     *  `events()` stream (NOT a new stream). Returns the server's `delivered`
+     *  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) {
+        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);
+        this.awaitingInput = false;
+        return delivered;
+    }
+    /** Cancel the run (and its sub-agents). No-op if the agent_id isn't known
+     *  yet (nothing to cancel). */
+    async cancel() {
+        if (this.agentId)
+            await this.ops.cancelAgent(this.agentId);
+    }
+}

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" | "_meta";
+export type EventType = "started" | "text" | "tool_call" | "tool_result" | "usage" | "done" | "error" | "retry" | "host_widened" | "session" | "agent" | "awaiting_input" | "steer" | "context_compaction" | "_meta";
 export interface ToolUse {
     id: string;
     name: string;
@@ -70,6 +70,18 @@ export interface AgentEvent {
     /** Host-widening payload on `event: host_widened`. Nil on all other
      *  event types. */
     host_widening?: HostWidening;
+    /** Payload on `event: awaiting_input` (RFC AI) — a persistent interactive
+     *  run parked at end_turn. `since_turn` is the iteration it parked after. */
+    awaiting_input?: {
+        since_turn?: number;
+    };
+    /** Payload on `event: steer` (RFC AI) — the operator's drained turn. On a
+     *  re-attach replay, `source` is `"replay"`. Nil on all other event types. */
+    user_input?: {
+        text?: string;
+        source?: string;
+        seen_at?: string;
+    };
     agent_id?: string;
     run_id?: string;
     session_id?: string;
@@ -177,6 +189,13 @@ export interface RunOptions {
      *  Omitted = inherit entirely. Trigger compaction mid-run with
      *  {@link LoomcycleClient.compactRun}. */
     compaction?: CompactionOptions;
+    /** RFC AI — start a PERSISTENT interactive run that parks at end_turn
+     *  awaiting operator steering instead of terminating. The stream emits an
+     *  `awaiting_input` frame when it parks; drive it with
+     *  {@link LoomcycleClient.sendRunInput}, re-attach with
+     *  {@link LoomcycleClient.streamRunByID}, and `cancelAgent` to end it.
+     *  Higher-level: {@link LoomcycleClient.interactiveSession}. */
+    interactive?: boolean;
     /** Opt-in observability: when true, the iterator emits client-
      *  synthesized `{ type: "_meta", meta_subtype: "stream_open" | "stream_close" }`
      *  events around the real event stream. `meta_reason` carries the
@@ -279,6 +298,9 @@ export interface ContinueOptions {
     sampling?: SamplingOptions;
     /** Per-continuation context-compaction override — see {@link RunOptions.compaction}. */
     compaction?: CompactionOptions;
+    /** RFC AI — park this continuation at end_turn for operator steering. See
+     *  {@link RunOptions.interactive}. */
+    interactive?: boolean;
     /** Opt-in observability: see {@link RunOptions.debug}. Same shape. */
     debug?: boolean;
     signal?: AbortSignal;
@@ -725,7 +747,7 @@ export interface PostHookCall {
  *  the adapter doesn't re-validate. Use the optional `extra` index
  *  signature for forward-compat fields. */
 export type SubstrateToolInput = {
-    op: "create" | "fork" | "get" | "list" | "promote" | "retire" | "rediscover" | "verify";
+    op: "create" | "fork" | "get" | "list" | "promote" | "retire" | "rediscover" | "verify" | "delete" | "purge";
     name?: string;
     def_id?: string;
     parent_def_id?: string;
@@ -733,6 +755,7 @@ export type SubstrateToolInput = {
     description?: string;
     promote?: boolean;
     retired?: boolean;
+    mode?: VolumeMode;
     [extra: string]: unknown;
 };
 /** Response shape for {@link LoomcycleClient.agentDef} and
@@ -741,6 +764,42 @@ export type SubstrateToolInput = {
  *  `{name, versions: [...]}`, promote/retire return summary shapes.
  *  Callers narrow as needed. */
 export type SubstrateToolResponse = unknown;
+/** Volume access mode — read-only or read-write (RFC AH). */
+export type VolumeMode = "ro" | "rw";
+/** One row of {@link LoomcycleClient.listVolumes} (`GET /v1/_volumes`). */
+export interface PersistentVolumeEntry {
+    name: string;
+    /** "static" (operator yaml, read-only) or "dynamic" (a tenant VolumeDef). */
+    source: "static" | "dynamic";
+    /** Host path. Redacted to "" for a non-operator (tenant) caller — the
+     *  volume universe is visible to a tenant operator, the host location is
+     *  not. Operator-equivalent callers see the real path. */
+    path: string;
+    mode: VolumeMode;
+    /** True for the static volume flagged `default: true` (never for dynamic). */
+    default: boolean;
+    /** True for the static volume dynamic VolumeDefs are provisioned inside. */
+    dynamic_root: boolean;
+    /** Set for dynamic rows (the substrate stamps it); absent for static. */
+    created_at?: string;
+}
+export interface PersistentVolumesResponse {
+    entries: PersistentVolumeEntry[];
+}
+/** One row of {@link LoomcycleClient.listEphemeralVolumes}
+ *  (`GET /v1/_volumes/ephemeral`). */
+export interface EphemeralVolumeEntry {
+    name: string;
+    root_run_id: string;
+    /** Host path — redacted to "" for a non-operator caller (see
+     *  {@link PersistentVolumeEntry.path}). */
+    path: string;
+    mode: VolumeMode;
+    created_at: string;
+}
+export interface EphemeralVolumesResponse {
+    entries: EphemeralVolumeEntry[];
+}
 /** Response a Post webhook returns. When result is omitted the tool
  *  result passes through unchanged. */
 export interface PostHookResult {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@loomcycle/client",
-  "version": "0.34.0",
-  "description": "TypeScript client for the loomcycle sidecar (HTTP+SSE). 54 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).",
+  "version": "1.1.1",
+  "description": "TypeScript client for the loomcycle sidecar (HTTP+SSE). 61 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).",
   "license": "Apache-2.0",
   "type": "module",
   "repository": {