@loomcycle/client 1.72.0 → 1.78.0

package/README.md

@@ -335,7 +335,7 @@ Two substrate-side surfaces added in the n8n integration's Phase 0 wire-API work
 | Method | Returns | Notes |
 |---|---|---|
 | `listChannels()` | `Promise<ListChannelsResponse>` | Operator-declared channels + aggregate stats (`message_count`, `oldest_visible_at`, `newest_visible_at`). Mirrors `GET /v1/_channels`. |
-| `streamUserRunStates(userId, opts?)` | `AsyncIterable<RunStateStreamItem>` | SSE stream of run state transitions for one user. Yields one `{ kind: "open", ... }` frame then one `{ kind: "event", payload: RunStateEvent }` per matching transition until close. |
+| `streamUserRunStates(userId, opts?)` | `AsyncIterable<RunStateStreamItem>` | SSE stream of run state transitions for one user. Yields one `{ kind: "open", ... }` frame then one `{ kind: "event", payload: RunStateEvent }` per matching transition until close. `opts.walkId` (v1.78.0) narrows it server-side to one team walk's agents. |
 
 **Streaming run-state events** — for orchestration UIs that want to react when an agent run completes / fails / cancels:
 
@@ -537,6 +537,31 @@ for await (const item of client.streamUserRunStates(userId, {
 
 `streamUserRunStates` holds ONE connection per user regardless of how many concurrent runs that user has. Server-enforced 30-minute timeout; reconnect on close.
 
+### `walkId` — watching ONE team walk's agents (v1.78.0)
+
+A detached team walk returns a `run_id`, and that id **is** the walk id every run it spawns carries in `parent_context.walk_id`. Pass it back as `walkId` and the server filters the stream to that workflow — no second identifier, nothing to map:
+
+```ts
+const { run_id } = await client.runTeam({ team: "triage", detach: true });
+
+for await (const item of client.streamUserRunStates(userId, { walkId: run_id })) {
+  if (item.kind === "open") {
+    // The server echoes the filter it applied. Check it: a filter that matched
+    // nothing and a filter the server did not understand are both a quiet
+    // stream, and only this tells them apart.
+    if (item.payload.filter_walk_id !== run_id) throw new Error("walk filter not applied");
+    continue;
+  }
+  if (item.kind !== "event") continue;
+  const pc = item.payload.parent_context;
+  // wave_id groups one fan-out; wave_index is the position inside it, so a
+  // live view can place an agent WITHIN the walk, not merely inside it.
+  render(item.payload.agent, item.payload.status, pc?.wave_id, pc?.wave_index);
+}
+```
+
+Unlike `parentAgentId`, which the adapter applies after parsing each frame, `walkId` is applied by the server — it reduces what crosses the wire, not just what your callback sees.
+
 ### `debug: true` — synthetic open/close frames
 
 All three streaming methods (`runStreaming`, `continueSession`, `streamUserRunStates`) accept `debug?: boolean`. Default off; behaviour is exactly the pre-v0.9.x shape.

package/dist/cjs/client.js

@@ -1240,17 +1240,46 @@ class LoomcycleClient {
     async forkTeam(name, overlay, opts) {
         return (0, fetch_helpers_js_1.postJSON)(this.ctx, "/v1/_teamdef", { op: "fork", name, overlay }, opts);
     }
+    /** List every version of ONE team, newest first (op=list) — the lineage
+     *  behind {@link LoomcycleClient.listTeams}' roll-up. Tenant-scoped
+     *  server-side; a name with no versions returns an empty list rather than
+     *  raising. */
+    async listTeamVersions(name, opts) {
+        return (0, fetch_helpers_js_1.postJSON)(this.ctx, "/v1/_teamdef", { op: "list", name }, opts);
+    }
+    /** Point the team's active pointer at one version (op=promote) — what a new
+     *  run of the team by NAME will execute.
+     *
+     *  `forkTeam` defaults to promote:false, so authoring a version and putting
+     *  it in force are deliberately two steps: an edited graph can be reviewed,
+     *  diagrammed, even run by `defId`, before it becomes what the name means. */
+    async promoteTeam(defId, opts) {
+        return (0, fetch_helpers_js_1.postJSON)(this.ctx, "/v1/_teamdef", { op: "promote", def_id: defId }, opts);
+    }
+    /** Soft-retire one version, or un-retire it (op=retire, `retired` required).
+     *
+     *  Retiring is REVERSIBLE and version-scoped: the row stays, its history stays
+     *  readable, and passing `false` brings it back. Removing a team is
+     *  {@link LoomcycleClient.deleteTeam}, which is neither. */
+    async retireTeam(defId, retired, opts) {
+        return (0, fetch_helpers_js_1.postJSON)(this.ctx, "/v1/_teamdef", { op: "retire", def_id: defId, retired }, opts);
+    }
+    /** Compare a locally computed content hash against the deployed active
+     *  version (op=verify) — the drift check for a team kept in source control
+     *  and pushed to several deployments.
+     *
+     *  Never raises for an absent team: a name with no active version answers
+     *  `{deployed: false, matches: false}`, which a caller distinguishes from a
+     *  deployed version whose hash differs. */
+    async verifyTeam(name, contentSha256, opts) {
+        return (0, fetch_helpers_js_1.postJSON)(this.ctx, "/v1/_teamdef", { op: "verify", name, content_sha256: contentSha256 }, opts);
+    }
     /** Hard-remove a whole team by name — all versions + the active pointer
      *  (op=delete), scoped to the caller's tenant. Teams are runtime-only, so
      *  this is how an operator clears an obsolete/test team. */
     async deleteTeam(name, opts) {
         return (0, fetch_helpers_js_1.postJSON)(this.ctx, "/v1/_teamdef", { op: "delete", name }, opts);
     }
-    /** Execute a team (op=run) — walk its state graph, spawning each state's agent
-     *  until a terminal state, returning the per-state trace. Target the active
-     *  version by `name` OR a specific version by `defId`. `input` is the initial
-     *  task handed to the entry state's agent. The walk runs under the same
-     *  admission a normal run gets (token budget / operator-key / depth). */
     async runTeam(target, opts) {
         const body = { op: "run" };
         if (target.name !== undefined)
@@ -1263,8 +1292,39 @@ class LoomcycleClient {
             body.board_chunk_id = target.boardChunkId;
         if (target.boardScope !== undefined)
             body.board_scope = target.boardScope;
+        if (target.mode !== undefined)
+            body.mode = target.mode;
+        if (target.breakpoints !== undefined)
+            body.breakpoints = target.breakpoints;
         return (0, fetch_helpers_js_1.postJSON)(this.ctx, "/v1/_teamdef", body, opts);
     }
+    /** Read the debug breakpoints armed on a live team walk
+     *  (`GET /v1/runs/{run_id}/breakpoints`).
+     *
+     *  404 when no walk is in flight under that run on this replica — loudly,
+     *  because an arming that appeared to succeed and then never paused anything
+     *  is the worst possible outcome for a debugger. Surface it rather than
+     *  treating it as "nothing armed". */
+    async getRunBreakpoints(runId, opts) {
+        return (0, fetch_helpers_js_1.jsonFetch)(this.ctx, `/v1/runs/${encodeURIComponent(runId)}/breakpoints`, opts);
+    }
+    /** Replace the debug breakpoints armed on a live team walk
+     *  (`PUT /v1/runs/{run_id}/breakpoints`).
+     *
+     *  The WHOLE desired set, not a delta: you hold the configuration and push
+     *  it, so two operators cannot interleave a read-modify-write. `[]` is the
+     *  off switch. A malformed entry is refused whole and leaves the previous
+     *  arming exactly as it was.
+     *
+     *  Each entry is a starter state id — `"review"` arms both phases,
+     *  `"review:before_dispatch"` or `"review:after_collection"` arms one. An arm
+     *  takes effect at the next pause the walk reaches; disarming RELEASES
+     *  whatever is still pending rather than stranding it.
+     *
+     *  A pause is read and answered through the run's interrupts. */
+    async setRunBreakpoints(runId, breakpoints, opts) {
+        return (0, fetch_helpers_js_1.putJSON)(this.ctx, `/v1/runs/${encodeURIComponent(runId)}/breakpoints`, { breakpoints }, opts);
+    }
     /** Invoke the RFC AL Path VFS tool over HTTP (`POST /v1/_path`). A
      *  Unix-like filesystem over your Memory entries, Volume mounts, and
      *  Documents — address them by human-readable paths (e.g. /docs/launch).
@@ -1772,6 +1832,8 @@ class LoomcycleClient {
             body.publisher = opts.publisher;
         if (opts.period !== undefined)
             body.period = opts.period;
+        if (opts.hold !== undefined)
+            body.hold = opts.hold;
         return (0, fetch_helpers_js_1.postJSON)(this.ctx, "/v1/_channels", body, {
             signal: opts.signal,
         });
@@ -1789,6 +1851,8 @@ class LoomcycleClient {
             body.max_messages = opts.max_messages;
         if (opts.semantic !== undefined)
             body.semantic = opts.semantic;
+        if (opts.hold !== undefined)
+            body.hold = opts.hold;
         return (0, fetch_helpers_js_1.patchJSON)(this.ctx, `/v1/_channels/${encodeURIComponent(name)}`, body, { signal: opts.signal });
     }
     /** Delete a runtime-substrate channel + cascade its persisted
@@ -1807,6 +1871,21 @@ class LoomcycleClient {
     async purgeChannel(name, opts) {
         return (0, fetch_helpers_js_1.postJSON)(this.ctx, `/v1/_channels/${encodeURIComponent(name)}/purge`, {}, { signal: opts?.signal });
     }
+    /** Hand the oldest `count` (default 1) messages held on a `hold:`
+     *  channel to its subscribers. Allowed on yaml-declared channels —
+     *  releasing moves messages, it does not mutate the definition.
+     *  Releasing a channel with nothing held reports zero rather than
+     *  failing. */
+    async releaseChannel(name, opts) {
+        const body = {};
+        if (opts?.count !== undefined)
+            body.count = opts.count;
+        if (opts?.scope !== undefined)
+            body.scope = opts.scope;
+        if (opts?.scope_id !== undefined)
+            body.scope_id = opts.scope_id;
+        return (0, fetch_helpers_js_1.postJSON)(this.ctx, `/v1/_channels/${encodeURIComponent(name)}/release`, body, { signal: opts?.signal });
+    }
     // ---- v0.11.5 Memory entry admin CRUD ----
     /** Idempotently upsert one memory entry by full (scope, scope_id,
      *  key) identifier. PUT semantics — re-writes overwrite the value.
@@ -1839,6 +1918,18 @@ class LoomcycleClient {
      *  Errors during the stream throw — they do NOT surface as items.
      *  Pass an AbortSignal to terminate cleanly from the consumer side.
      *
+     *  v1.78.0 — `walkId` is a SERVER-side filter: only the runs one team
+     *  walk spawned. A walk's own run_id IS its walk id, so a caller that
+     *  started a team with `detach: true` passes back the handle it already
+     *  holds and gets a live view of that workflow's agents:
+     *
+     *  ```ts
+     *  const { run_id } = await client.runTeam({ team: "triage", detach: true });
+     *  for await (const item of client.streamUserRunStates(userId, { walkId: run_id })) {
+     *    if (item.kind === "event") place(item.payload.parent_context?.wave_index);
+     *  }
+     *  ```
+     *
      *  v0.9.x options:
      *  - `parentAgentId` — client-side filter: only `kind: "event"`
      *    items whose payload's `parent_agent_id` matches are yielded.
@@ -1857,6 +1948,9 @@ class LoomcycleClient {
         if (opts?.agent) {
             params.set("agent", opts.agent);
         }
+        if (opts?.walkId) {
+            params.set("walk_id", opts.walkId);
+        }
         const qs = params.toString();
         const path = `/v1/users/${encodeURIComponent(userId)}/agents/stream` +
             (qs ? `?${qs}` : "");

package/dist/cjs/index.js

@@ -84,6 +84,9 @@
  *     forkTeam(name, overlay): Promise<CreatedTeam>
  *     deleteTeam(name): Promise<{name, deleted}>
  *     runTeam({name|defId, input}): Promise<TeamRunResult>
+ *     runTeam({..., mode:"detach"}): Promise<TeamRunDetached>     // the handle, now — the walk runs on
+ *     getRunBreakpoints(runId): Promise<TeamBreakpoints>          // debug a walk that is already running
+ *     setRunBreakpoints(runId, breakpoints): Promise<TeamBreakpoints>
  *
  *     // Path VFS + chunked-graph Documents on the wire (v1.4.0 — RFC AL / RFC AK)
  *     path(input): Promise<PathToolResponse>                      // resolve/ls/stat/mkdir/mv/rm

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, ChannelSubscribeResult, CreateChannelOptions, ListChannelsResponse, PeekChannelOptions, PublishChannelOptions, 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, TeamDefDetail, 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, 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);
@@ -870,6 +870,40 @@ export declare class LoomcycleClient {
     forkTeam(name: string, overlay: Record<string, unknown>, opts?: {
         signal?: AbortSignal;
     }): Promise<CreatedTeam>;
+    /** List every version of ONE team, newest first (op=list) — the lineage
+     *  behind {@link LoomcycleClient.listTeams}' roll-up. Tenant-scoped
+     *  server-side; a name with no versions returns an empty list rather than
+     *  raising. */
+    listTeamVersions(name: string, opts?: {
+        signal?: AbortSignal;
+    }): Promise<TeamVersionList>;
+    /** Point the team's active pointer at one version (op=promote) — what a new
+     *  run of the team by NAME will execute.
+     *
+     *  `forkTeam` defaults to promote:false, so authoring a version and putting
+     *  it in force are deliberately two steps: an edited graph can be reviewed,
+     *  diagrammed, even run by `defId`, before it becomes what the name means. */
+    promoteTeam(defId: string, opts?: {
+        signal?: AbortSignal;
+    }): Promise<PromotedTeam>;
+    /** Soft-retire one version, or un-retire it (op=retire, `retired` required).
+     *
+     *  Retiring is REVERSIBLE and version-scoped: the row stays, its history stays
+     *  readable, and passing `false` brings it back. Removing a team is
+     *  {@link LoomcycleClient.deleteTeam}, which is neither. */
+    retireTeam(defId: string, retired: boolean, opts?: {
+        signal?: AbortSignal;
+    }): Promise<RetiredTeam>;
+    /** Compare a locally computed content hash against the deployed active
+     *  version (op=verify) — the drift check for a team kept in source control
+     *  and pushed to several deployments.
+     *
+     *  Never raises for an absent team: a name with no active version answers
+     *  `{deployed: false, matches: false}`, which a caller distinguishes from a
+     *  deployed version whose hash differs. */
+    verifyTeam(name: string, contentSha256: string, opts?: {
+        signal?: AbortSignal;
+    }): Promise<TeamVerification>;
     /** Hard-remove a whole team by name — all versions + the active pointer
      *  (op=delete), scoped to the caller's tenant. Teams are runtime-only, so
      *  this is how an operator clears an obsolete/test team. */
@@ -884,21 +918,43 @@ export declare class LoomcycleClient {
      *  version by `name` OR a specific version by `defId`. `input` is the initial
      *  task handed to the entry state's agent. The walk runs under the same
      *  admission a normal run gets (token budget / operator-key / depth). */
-    runTeam(target: {
-        name?: string;
-        defId?: string;
-        input?: string;
-        /** Bind the walk to a Document chunk task board (RFC BT P4): each state
-         *  transition persists `chunk.status` = the current team state, and every
-         *  handler run this walk spawns carries the task key on its
-         *  `parent_context` (so a board client can pin the live agent to the
-         *  card). Omit for an ephemeral run. */
-        boardChunkId?: string;
-        /** The Document scope of `boardChunkId` (agent | user, default user). */
-        boardScope?: "agent" | "user";
+    runTeam(target: TeamRunTarget & {
+        mode: "detach";
+    }, opts?: {
+        signal?: AbortSignal;
+    }): Promise<TeamRunDetached>;
+    runTeam(target: TeamRunTarget & {
+        mode?: undefined;
     }, opts?: {
         signal?: AbortSignal;
     }): Promise<TeamRunResult>;
+    /** Read the debug breakpoints armed on a live team walk
+     *  (`GET /v1/runs/{run_id}/breakpoints`).
+     *
+     *  404 when no walk is in flight under that run on this replica — loudly,
+     *  because an arming that appeared to succeed and then never paused anything
+     *  is the worst possible outcome for a debugger. Surface it rather than
+     *  treating it as "nothing armed". */
+    getRunBreakpoints(runId: string, opts?: {
+        signal?: AbortSignal;
+    }): Promise<TeamBreakpoints>;
+    /** Replace the debug breakpoints armed on a live team walk
+     *  (`PUT /v1/runs/{run_id}/breakpoints`).
+     *
+     *  The WHOLE desired set, not a delta: you hold the configuration and push
+     *  it, so two operators cannot interleave a read-modify-write. `[]` is the
+     *  off switch. A malformed entry is refused whole and leaves the previous
+     *  arming exactly as it was.
+     *
+     *  Each entry is a starter state id — `"review"` arms both phases,
+     *  `"review:before_dispatch"` or `"review:after_collection"` arms one. An arm
+     *  takes effect at the next pause the walk reaches; disarming RELEASES
+     *  whatever is still pending rather than stranding it.
+     *
+     *  A pause is read and answered through the run's interrupts. */
+    setRunBreakpoints(runId: string, breakpoints: string[], opts?: {
+        signal?: AbortSignal;
+    }): Promise<TeamBreakpoints>;
     /** Invoke the RFC AL Path VFS tool over HTTP (`POST /v1/_path`). A
      *  Unix-like filesystem over your Memory entries, Volume mounts, and
      *  Documents — address them by human-readable paths (e.g. /docs/launch).
@@ -1185,6 +1241,12 @@ export declare class LoomcycleClient {
     purgeChannel(name: string, opts?: {
         signal?: AbortSignal;
     }): Promise<ChannelPurgeResult>;
+    /** Hand the oldest `count` (default 1) messages held on a `hold:`
+     *  channel to its subscribers. Allowed on yaml-declared channels —
+     *  releasing moves messages, it does not mutate the definition.
+     *  Releasing a channel with nothing held reports zero rather than
+     *  failing. */
+    releaseChannel(name: string, opts?: ReleaseChannelOptions): Promise<ChannelReleaseResult>;
     /** Idempotently upsert one memory entry by full (scope, scope_id,
      *  key) identifier. PUT semantics — re-writes overwrite the value.
      *  Optional embed flag triggers a synchronous embed via the
@@ -1208,6 +1270,18 @@ export declare class LoomcycleClient {
      *  Errors during the stream throw — they do NOT surface as items.
      *  Pass an AbortSignal to terminate cleanly from the consumer side.
      *
+     *  v1.78.0 — `walkId` is a SERVER-side filter: only the runs one team
+     *  walk spawned. A walk's own run_id IS its walk id, so a caller that
+     *  started a team with `detach: true` passes back the handle it already
+     *  holds and gets a live view of that workflow's agents:
+     *
+     *  ```ts
+     *  const { run_id } = await client.runTeam({ team: "triage", detach: true });
+     *  for await (const item of client.streamUserRunStates(userId, { walkId: run_id })) {
+     *    if (item.kind === "event") place(item.payload.parent_context?.wave_index);
+     *  }
+     *  ```
+     *
      *  v0.9.x options:
      *  - `parentAgentId` — client-side filter: only `kind: "event"`
      *    items whose payload's `parent_agent_id` matches are yielded.

package/dist/client.js

@@ -1237,17 +1237,46 @@ export class LoomcycleClient {
     async forkTeam(name, overlay, opts) {
         return postJSON(this.ctx, "/v1/_teamdef", { op: "fork", name, overlay }, opts);
     }
+    /** List every version of ONE team, newest first (op=list) — the lineage
+     *  behind {@link LoomcycleClient.listTeams}' roll-up. Tenant-scoped
+     *  server-side; a name with no versions returns an empty list rather than
+     *  raising. */
+    async listTeamVersions(name, opts) {
+        return postJSON(this.ctx, "/v1/_teamdef", { op: "list", name }, opts);
+    }
+    /** Point the team's active pointer at one version (op=promote) — what a new
+     *  run of the team by NAME will execute.
+     *
+     *  `forkTeam` defaults to promote:false, so authoring a version and putting
+     *  it in force are deliberately two steps: an edited graph can be reviewed,
+     *  diagrammed, even run by `defId`, before it becomes what the name means. */
+    async promoteTeam(defId, opts) {
+        return postJSON(this.ctx, "/v1/_teamdef", { op: "promote", def_id: defId }, opts);
+    }
+    /** Soft-retire one version, or un-retire it (op=retire, `retired` required).
+     *
+     *  Retiring is REVERSIBLE and version-scoped: the row stays, its history stays
+     *  readable, and passing `false` brings it back. Removing a team is
+     *  {@link LoomcycleClient.deleteTeam}, which is neither. */
+    async retireTeam(defId, retired, opts) {
+        return postJSON(this.ctx, "/v1/_teamdef", { op: "retire", def_id: defId, retired }, opts);
+    }
+    /** Compare a locally computed content hash against the deployed active
+     *  version (op=verify) — the drift check for a team kept in source control
+     *  and pushed to several deployments.
+     *
+     *  Never raises for an absent team: a name with no active version answers
+     *  `{deployed: false, matches: false}`, which a caller distinguishes from a
+     *  deployed version whose hash differs. */
+    async verifyTeam(name, contentSha256, opts) {
+        return postJSON(this.ctx, "/v1/_teamdef", { op: "verify", name, content_sha256: contentSha256 }, opts);
+    }
     /** Hard-remove a whole team by name — all versions + the active pointer
      *  (op=delete), scoped to the caller's tenant. Teams are runtime-only, so
      *  this is how an operator clears an obsolete/test team. */
     async deleteTeam(name, opts) {
         return postJSON(this.ctx, "/v1/_teamdef", { op: "delete", name }, opts);
     }
-    /** Execute a team (op=run) — walk its state graph, spawning each state's agent
-     *  until a terminal state, returning the per-state trace. Target the active
-     *  version by `name` OR a specific version by `defId`. `input` is the initial
-     *  task handed to the entry state's agent. The walk runs under the same
-     *  admission a normal run gets (token budget / operator-key / depth). */
     async runTeam(target, opts) {
         const body = { op: "run" };
         if (target.name !== undefined)
@@ -1260,8 +1289,39 @@ export class LoomcycleClient {
             body.board_chunk_id = target.boardChunkId;
         if (target.boardScope !== undefined)
             body.board_scope = target.boardScope;
+        if (target.mode !== undefined)
+            body.mode = target.mode;
+        if (target.breakpoints !== undefined)
+            body.breakpoints = target.breakpoints;
         return postJSON(this.ctx, "/v1/_teamdef", body, opts);
     }
+    /** Read the debug breakpoints armed on a live team walk
+     *  (`GET /v1/runs/{run_id}/breakpoints`).
+     *
+     *  404 when no walk is in flight under that run on this replica — loudly,
+     *  because an arming that appeared to succeed and then never paused anything
+     *  is the worst possible outcome for a debugger. Surface it rather than
+     *  treating it as "nothing armed". */
+    async getRunBreakpoints(runId, opts) {
+        return jsonFetch(this.ctx, `/v1/runs/${encodeURIComponent(runId)}/breakpoints`, opts);
+    }
+    /** Replace the debug breakpoints armed on a live team walk
+     *  (`PUT /v1/runs/{run_id}/breakpoints`).
+     *
+     *  The WHOLE desired set, not a delta: you hold the configuration and push
+     *  it, so two operators cannot interleave a read-modify-write. `[]` is the
+     *  off switch. A malformed entry is refused whole and leaves the previous
+     *  arming exactly as it was.
+     *
+     *  Each entry is a starter state id — `"review"` arms both phases,
+     *  `"review:before_dispatch"` or `"review:after_collection"` arms one. An arm
+     *  takes effect at the next pause the walk reaches; disarming RELEASES
+     *  whatever is still pending rather than stranding it.
+     *
+     *  A pause is read and answered through the run's interrupts. */
+    async setRunBreakpoints(runId, breakpoints, opts) {
+        return putJSON(this.ctx, `/v1/runs/${encodeURIComponent(runId)}/breakpoints`, { breakpoints }, opts);
+    }
     /** Invoke the RFC AL Path VFS tool over HTTP (`POST /v1/_path`). A
      *  Unix-like filesystem over your Memory entries, Volume mounts, and
      *  Documents — address them by human-readable paths (e.g. /docs/launch).
@@ -1769,6 +1829,8 @@ export class LoomcycleClient {
             body.publisher = opts.publisher;
         if (opts.period !== undefined)
             body.period = opts.period;
+        if (opts.hold !== undefined)
+            body.hold = opts.hold;
         return postJSON(this.ctx, "/v1/_channels", body, {
             signal: opts.signal,
         });
@@ -1786,6 +1848,8 @@ export class LoomcycleClient {
             body.max_messages = opts.max_messages;
         if (opts.semantic !== undefined)
             body.semantic = opts.semantic;
+        if (opts.hold !== undefined)
+            body.hold = opts.hold;
         return patchJSON(this.ctx, `/v1/_channels/${encodeURIComponent(name)}`, body, { signal: opts.signal });
     }
     /** Delete a runtime-substrate channel + cascade its persisted
@@ -1804,6 +1868,21 @@ export class LoomcycleClient {
     async purgeChannel(name, opts) {
         return postJSON(this.ctx, `/v1/_channels/${encodeURIComponent(name)}/purge`, {}, { signal: opts?.signal });
     }
+    /** Hand the oldest `count` (default 1) messages held on a `hold:`
+     *  channel to its subscribers. Allowed on yaml-declared channels —
+     *  releasing moves messages, it does not mutate the definition.
+     *  Releasing a channel with nothing held reports zero rather than
+     *  failing. */
+    async releaseChannel(name, opts) {
+        const body = {};
+        if (opts?.count !== undefined)
+            body.count = opts.count;
+        if (opts?.scope !== undefined)
+            body.scope = opts.scope;
+        if (opts?.scope_id !== undefined)
+            body.scope_id = opts.scope_id;
+        return postJSON(this.ctx, `/v1/_channels/${encodeURIComponent(name)}/release`, body, { signal: opts?.signal });
+    }
     // ---- v0.11.5 Memory entry admin CRUD ----
     /** Idempotently upsert one memory entry by full (scope, scope_id,
      *  key) identifier. PUT semantics — re-writes overwrite the value.
@@ -1836,6 +1915,18 @@ export class LoomcycleClient {
      *  Errors during the stream throw — they do NOT surface as items.
      *  Pass an AbortSignal to terminate cleanly from the consumer side.
      *
+     *  v1.78.0 — `walkId` is a SERVER-side filter: only the runs one team
+     *  walk spawned. A walk's own run_id IS its walk id, so a caller that
+     *  started a team with `detach: true` passes back the handle it already
+     *  holds and gets a live view of that workflow's agents:
+     *
+     *  ```ts
+     *  const { run_id } = await client.runTeam({ team: "triage", detach: true });
+     *  for await (const item of client.streamUserRunStates(userId, { walkId: run_id })) {
+     *    if (item.kind === "event") place(item.payload.parent_context?.wave_index);
+     *  }
+     *  ```
+     *
      *  v0.9.x options:
      *  - `parentAgentId` — client-side filter: only `kind: "event"`
      *    items whose payload's `parent_agent_id` matches are yielded.
@@ -1854,6 +1945,9 @@ export class LoomcycleClient {
         if (opts?.agent) {
             params.set("agent", opts.agent);
         }
+        if (opts?.walkId) {
+            params.set("walk_id", opts.walkId);
+        }
         const qs = params.toString();
         const path = `/v1/users/${encodeURIComponent(userId)}/agents/stream` +
             (qs ? `?${qs}` : "");

package/dist/index.d.ts

@@ -83,6 +83,9 @@
  *     forkTeam(name, overlay): Promise<CreatedTeam>
  *     deleteTeam(name): Promise<{name, deleted}>
  *     runTeam({name|defId, input}): Promise<TeamRunResult>
+ *     runTeam({..., mode:"detach"}): Promise<TeamRunDetached>     // the handle, now — the walk runs on
+ *     getRunBreakpoints(runId): Promise<TeamBreakpoints>          // debug a walk that is already running
+ *     setRunBreakpoints(runId, breakpoints): Promise<TeamBreakpoints>
  *
  *     // Path VFS + chunked-graph Documents on the wire (v1.4.0 — RFC AL / RFC AK)
  *     path(input): Promise<PathToolResponse>                      // resolve/ls/stat/mkdir/mv/rm
@@ -125,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, TeamDefDetail, TeamRunResult, 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, 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, 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, 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 { 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

@@ -83,6 +83,9 @@
  *     forkTeam(name, overlay): Promise<CreatedTeam>
  *     deleteTeam(name): Promise<{name, deleted}>
  *     runTeam({name|defId, input}): Promise<TeamRunResult>
+ *     runTeam({..., mode:"detach"}): Promise<TeamRunDetached>     // the handle, now — the walk runs on
+ *     getRunBreakpoints(runId): Promise<TeamBreakpoints>          // debug a walk that is already running
+ *     setRunBreakpoints(runId, breakpoints): Promise<TeamBreakpoints>
  *
  *     // Path VFS + chunked-graph Documents on the wire (v1.4.0 — RFC AL / RFC AK)
  *     path(input): Promise<PathToolResponse>                      // resolve/ls/stat/mkdir/mv/rm

package/dist/types.d.ts

@@ -295,6 +295,22 @@ export interface ParentContext {
     board_scope?: string;
     board_chunk_id?: string;
     board_document_id?: string;
+    /** Team-walk correlation (loomcycle v1.78.0). A run spawned by a team walk
+     *  carries the walk's own run_id here, plus which WAVE of that walk it
+     *  belongs to and its index within the wave.
+     *
+     *  `walk_id` is what {@link StreamUserRunStatesOptions.walkId} filters on
+     *  server-side; `wave_id` + `wave_index` are what let a live view place an
+     *  agent within the walk rather than merely inside it — a fan-out of N
+     *  agents shares one `wave_id` and differs only by `wave_index`.
+     *
+     *  Absent on any run no team walk spawned. */
+    walk_id?: string;
+    wave_id?: string;
+    /** Position within the wave, 0-based. Sent even when 0 (unlike the string
+     *  fields, which are omitted when empty), so an index of 0 is a real first
+     *  position and not an absent one. */
+    wave_index?: number;
 }
 export interface ContinueOptions {
     /** Required — the session to continue. */
@@ -1210,6 +1226,57 @@ export interface TeamDefDetail {
     content_sha256?: string;
     definition: unknown;
 }
+/** One team version's record in {@link TeamVersionList} (op=list). Same shape
+ *  as {@link TeamDefDetail} plus the lineage + authorship fields the version
+ *  history needs — who wrote it, when, and which version it forked from. */
+export interface TeamVersion {
+    def_id: string;
+    name: string;
+    version: number;
+    parent_def_id?: string;
+    description?: string;
+    created_at?: string;
+    created_by_agent_id?: string;
+    retired?: boolean;
+    bootstrapped_from_static?: boolean;
+    content_sha256?: string;
+    definition?: unknown;
+}
+/** Result of {@link LoomcycleClient.listTeamVersions} (op=list) — every version
+ *  of ONE team, newest first. Tenant-scoped server-side. */
+export interface TeamVersionList {
+    name: string;
+    versions: TeamVersion[];
+}
+/** Result of {@link LoomcycleClient.promoteTeam} (op=promote) — the version the
+ *  active pointer now names. */
+export interface PromotedTeam {
+    def_id: string;
+    name: string;
+    promoted: boolean;
+}
+/** Result of {@link LoomcycleClient.retireTeam} (op=retire) — the version's new
+ *  retired state. Retiring is reversible (pass `false` to un-retire); it is
+ *  {@link LoomcycleClient.deleteTeam} that removes anything. */
+export interface RetiredTeam {
+    def_id: string;
+    retired: boolean;
+}
+/** Result of {@link LoomcycleClient.verifyTeam} (op=verify) — whether a locally
+ *  computed content hash matches the deployed active version.
+ *
+ *  `deployed: false` means the name has no active version in this tenant at all
+ *  (`matches` is then false and the current_* fields are empty) — distinct from
+ *  a deployed version whose hash differs, which is a DRIFT rather than an
+ *  absence. */
+export interface TeamVerification {
+    name: string;
+    matches: boolean;
+    deployed: boolean;
+    current_sha256: string;
+    current_def_id: string;
+    version: number;
+}
 /** Result of {@link LoomcycleClient.runTeam} (op=run) — the walk trace. `status`
  *  is `"completed"` (a terminal state was reached) or `"iteration_cap"` (a
  *  state's cycle cap tripped; `capped_state` + `iteration_count` describe it).
@@ -1219,6 +1286,13 @@ export interface TeamRunResult {
     name: string;
     def_id: string;
     status: string;
+    /** The walk's own run id. A team walk IS a run — it opens a `runs` row filed
+     *  under `team:<name>` — which is what makes it addressable while it runs:
+     *  {@link LoomcycleClient.setRunBreakpoints} arms it, `GET /v1/runs/{id}/
+     *  interrupts` carries a pause, and cancel stops it. Returned on the
+     *  synchronous path too, so a caller holding a second connection can debug a
+     *  walk it is waiting on. */
+    run_id?: string;
     final_state?: string;
     final_output?: string;
     capped_state?: string;
@@ -1227,6 +1301,58 @@ export interface TeamRunResult {
     steps: Array<Record<string, unknown>>;
     [extra: string]: unknown;
 }
+/** What team {@link LoomcycleClient.runTeam} walks, and how. */
+export interface TeamRunTarget {
+    name?: string;
+    defId?: string;
+    /** The initial task handed to the entry state's agent. */
+    input?: string;
+    /** Bind the walk to a Document chunk task board: each state transition
+     *  persists `chunk.status` = the current team state, and every handler run
+     *  the walk spawns carries the task key on its `parent_context`. */
+    boardChunkId?: string;
+    /** The Document scope of `boardChunkId` (agent | user, default user). */
+    boardScope?: "agent" | "user";
+    /** "detach" returns the run id immediately and leaves the walk running
+     *  behind it. Omit to wait for the walk and get its trace — which still
+     *  returns `run_id`, so a second connection can debug a walk you await. */
+    mode?: "detach";
+    /** Starter state ids to pause at, armed before the walk starts. Each is
+     *  `"<state>"` (both phases) or `"<state>:before_dispatch"` /
+     *  `"<state>:after_collection"`.
+     *
+     *  A walk can also be armed AFTER it starts — see
+     *  {@link LoomcycleClient.setRunBreakpoints} — which is the case this
+     *  argument cannot serve: you start a run expecting it to work, watch a wave
+     *  go wrong, and want to stop before the next one. */
+    breakpoints?: string[];
+}
+/** What {@link LoomcycleClient.runTeam} returns for `mode: "detach"` — the
+ *  handle, immediately, with the walk still running behind it.
+ *
+ *  Detaching exists because op=run is otherwise SYNCHRONOUS: the caller learns
+ *  nothing until the walk is over, so there is no moment at which it can arm a
+ *  breakpoint, read a pause, or watch progress. There are no `steps` yet —
+ *  poll the run, or read its events, for those. */
+export interface TeamRunDetached {
+    name: string;
+    def_id: string;
+    /** Address every other run surface with this. */
+    run_id: string;
+    /** Always "running" — the walk has been started, not awaited. */
+    status: string;
+    [extra: string]: unknown;
+}
+/** The armed debug breakpoints of a live team walk, as
+ *  {@link LoomcycleClient.getRunBreakpoints} / {@link LoomcycleClient.setRunBreakpoints}
+ *  report them. */
+export interface TeamBreakpoints {
+    run_id: string;
+    /** Canonical: always phase-qualified (`"<state>:before_dispatch"`) and
+     *  sorted, so what you read back is what the walk will actually do rather
+     *  than an echo of the shorthand you sent. */
+    armed: string[];
+}
 /** Input for {@link LoomcycleClient.path} — the RFC AL Unix-like VFS tool
  *  (POST /v1/_path). Op-discriminated; the server resolves scope + tenant
  *  from the authenticated principal, never the wire. Address Memory entries,
@@ -1243,6 +1369,12 @@ export type PathToolInput = {
     recursive?: boolean;
     /** ls: only entries of this kind (document/volume_mount/memory_entry/directory). */
     kind_filter?: string;
+    /** ls: maximum entries to return (default 500, max 5000). A truncated listing
+     *  reports `truncated: true` and a `next_cursor`; pass that back as `cursor`. */
+    limit?: number;
+    /** ls: continue a truncated listing with the previous response's `next_cursor`.
+     *  Opaque — its encoding is not part of the contract, so do not construct one. */
+    cursor?: string;
     /** rm: also delete the backing resource (NOT supported in v1). */
     resource_too?: boolean;
     [extra: string]: unknown;
@@ -1299,6 +1431,10 @@ export type DocumentToolInput = {
     under_path?: string;
     /** query_chunks: raw read-only SELECT (escape hatch; validator-gated). */
     sql?: string;
+    /** Row/response bound. On `documents_summary` it defaults to 500 (max 5000) and
+     *  the response reports `truncated: true` when it clips — an `under_path` over a
+     *  subject-homed fact store is as wide as the tenant's entity count, so page the
+     *  directory with `path op=ls` and pass each page's ids as `document_ids`. */
     limit?: number;
     /** define/list_types: the type name. */
     name?: string;
@@ -1337,6 +1473,13 @@ export type DocumentToolInput = {
      *  sync reconciles — so a reading or coverage surface wants this on, and a
      *  federation one does not. */
     claims_only?: boolean;
+    /** list_facts: the facts about ONE SUBJECT — the subject's entity chunk id (a
+     *  subject document's `root_chunk_id`, from get_document). Returns the facts filed
+     *  under it AND the facts filed elsewhere that reference it: filing is
+     *  single-parent, so a fact about two things lives in one of their documents and
+     *  only points at the other, and a document filter would lose it from the second
+     *  subject entirely. */
+    about?: string;
     /** remember: a statement to store as a fact that cites ITSELF — the text becomes both
      *  the claim and its source span, so write what you want recorded rather than an
      *  instruction about it. Additive only; it is never a way to delete. */
@@ -1366,12 +1509,21 @@ export type DocumentToolResponse = unknown;
  *  Loosely typed (the in-process tool owns the full schema); use the `[extra]`
  *  index signature for forward-compat fields. */
 export type HistoryToolInput = {
-    op: "list" | "get" | "search" | "rename" | "annotate" | "pin" | "archive" | "recap" | "resume";
+    op: "list" | "get" | "search" | "rename" | "annotate" | "pin" | "archive" | "recap" | "resume" | "related" | "window";
     /** Whose chats: self = this caller's agent; user = this end-user's; tenant =
      *  this tenant's; global = all tenants (admin only). Default self. */
     scope?: "self" | "user" | "tenant" | "global";
-    /** get/rename/annotate/pin/archive/recap/resume: the chat (session) id. */
+    /** get/rename/annotate/pin/archive/recap/resume/window: the chat (session) id.
+     *  For `window`, the session a recalled fact reported as its source. */
     session_id?: string;
+    /** window: the fact's source span — the verbatim text it was distilled from,
+     *  which recall returns as `source`. It anchors the window to the turn the fact
+     *  came from, rather than the start of the chat. */
+    quote?: string;
+    /** window: how many turns either side of the match to return (default 2, max
+     *  10). A distilled fact loses what its turn's neighbours carry — a bare date, a
+     *  pronoun — which is what these recover. */
+    context?: number;
     /** list/search: filter by derived chat status (running/completed/failed/cancelled). */
     status?: string;
     /** list/search: RFC3339 lower bound on last activity. */
@@ -1463,6 +1615,8 @@ export interface ChannelDescriptor {
     period?: string;
     default_ttl?: number;
     max_messages?: number;
+    /** Breakpoint: publishes are stored but never delivered until released. */
+    hold?: boolean;
     message_count: number;
     /** RFC3339 — empty when count == 0. */
     oldest_visible_at?: string;
@@ -1652,6 +1806,9 @@ export interface CreateChannelOptions {
     publisher?: string;
     /** Free-form retention hint; not enforced by the substrate. */
     period?: string;
+    /** Breakpoint: publishes are stored but never delivered until
+     *  {@link LoomcycleClient.releaseChannel} hands them over. */
+    hold?: boolean;
     signal?: AbortSignal;
 }
 /** Options for {@link LoomcycleClient.updateChannel}. Nil fields
@@ -1662,8 +1819,29 @@ export interface UpdateChannelOptions {
     max_messages?: number;
     /** "queue" | "topic" */
     semantic?: string;
+    /** Turn the breakpoint on or off. Messages already held stay held
+     *  until released — turning it off does not flush the queue. */
+    hold?: boolean;
+    signal?: AbortSignal;
+}
+/** Options for {@link LoomcycleClient.releaseChannel}. */
+export interface ReleaseChannelOptions {
+    /** How many held messages to hand over, oldest first. Default 1. */
+    count?: number;
+    /** "global" (default) | "user" | "tenant". */
+    scope?: string;
+    /** Required when scope is "user". */
+    scope_id?: string;
     signal?: AbortSignal;
 }
+/** Result of {@link LoomcycleClient.releaseChannel}. `released` is the
+ *  ids handed over, in delivery order; `still_held` is what is left. */
+export interface ChannelReleaseResult {
+    channel: string;
+    released: string[];
+    released_count: number;
+    still_held: number;
+}
 /** Options for {@link LoomcycleClient.setMemoryEntry}. `value` is
  *  opaque JSON. Setting `embed: true` triggers a synchronous embed
  *  via the operator-configured embedder; the returned `embedded`
@@ -1716,6 +1894,13 @@ export interface RunStateStreamOpen {
     user_id: string;
     filter_status: string[] | null;
     filter_agent: string;
+    /** v1.78.0 — the walk filter the server actually applied, echoed back.
+     *
+     *  Worth reading rather than assuming: a filter that matched nothing and a
+     *  filter the server never understood look identical from the outside — both
+     *  are a stream that stays quiet. Comparing this to what you sent tells the
+     *  two apart before you wait on an empty stream. Empty when unfiltered. */
+    filter_walk_id?: string;
     keepalive_interval: number;
 }
 /** Yielded by {@link LoomcycleClient.streamUserRunStates}.
@@ -1741,12 +1926,28 @@ export interface StreamUserRunStatesOptions {
     statuses?: string[];
     /** Filter to one agent name. Empty means any. */
     agent?: string;
+    /** v1.78.0 — SERVER-side filter: only the runs one team walk spawned,
+     *  matched against each event's `parent_context.walk_id`.
+     *
+     *  A team walk's own run_id IS its walk id, so a caller that started a team
+     *  with `detach: true` passes back exactly the handle it already holds —
+     *  there is no second identifier and nothing to map. That is what makes a
+     *  live view of one running workflow's agents a filter rather than a
+     *  feature.
+     *
+     *  Unlike {@link StreamUserRunStatesOptions.parentAgentId}, this is applied
+     *  by the server, so it reduces what crosses the wire and not just what your
+     *  callback sees. The server echoes it back on the open frame as
+     *  {@link RunStateStreamOpen.filter_walk_id}. */
+    walkId?: string;
     /** v0.9.x — client-side filter on the run's parent_agent_id.
      *  Useful for "show me only the sub-runs spawned by agent X."
      *  The filter is applied AFTER the SSE frame is parsed, so this
      *  shrinks what your callback sees but doesn't reduce server-side
-     *  load. Server-side filtering is a separate (future) request.
-     *  Pass the empty string to opt out (default). */
+     *  load. Pass the empty string to opt out (default).
+     *
+     *  For the one case that HAS a server-side filter, prefer it: see
+     *  {@link StreamUserRunStatesOptions.walkId}. */
     parentAgentId?: string;
     /** v0.9.x — opt-in observability: when true, the iterator yields a
      *  client-synthesized `{ kind: "close", payload: { reason } }` item

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@loomcycle/client",
-  "version": "1.72.0",
-  "description": "TypeScript client for the loomcycle sidecar (HTTP+SSE). 67 methods covering run streaming, agent metadata, pause/resume/state, resolver re-probe (resolveProbe \u2014 issue #88 operator escape hatch), operator-token admin (operatorTokenDef \u2014 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 \u2014 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 \u2014 direct provider routing without agent overhead; primary target is n8n's LoomCycleChatModel AI Agent sub-node and any LangChain-compatible consumer). v0.10.1 \u2014 dual ESM + CommonJS distribution (additive \u2014 ESM consumers unchanged; CJS consumers like n8n's community-node loader now work). v0.19.0 \u2014 typed inline code-js agent ingestion (AgentDefOverlay.code_body + ensureCodeAgent \u2014 register a deterministic code agent through the substrate with no host filesystem bind; RFC J). v0.20.0 \u2014 ensureMcpServer surfaces discoveredToolCount straight from create (loomcycle now auto-discovers MCP tools at ingestion); rediscover is now an explicit force-refresh. v0.21.0 \u2014 run/continue accept optional non-secret `metadata` (repo name, review policy, \u2026) passed to the agent, symmetric with the WebHook/Schedule trigger paths. v0.22.0 \u2014 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 \u2014 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 \u2014 purgeChannel clears a channel's buffered messages without deleting its definition (allowed on yaml-declared channels too, unlike deleteChannel \u2014 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 \u2014 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 \u2014 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 \u2014 the manual-management Web UI console + Context op=time + max_fires self-retiring schedules \u2014 is server-side / in-band, no client-surface change). v0.29.1 \u2014 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 \u2014 gRPC + TS client parity for the RFC Y external fan-out and the compaction surface: spawnRunBatch() (POST /v1/runs:batch \u2014 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 \u2014 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 \u2014 server-side.) v0.34.0 \u2014 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 \u2014 RFC AH dynamic filesystem volumes: volumeDef() (POST /v1/_volumedef \u2014 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] \u2014 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 \u2014 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 \u2014 steer a live run) + streamRunByID(runId, {fromSeq}) (GET /v1/runs/{id}/stream \u2014 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 \u2014 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 \u2014 RFC AL Path VFS + RFC AK Document on the wire: path(input) (POST /v1/_path \u2014 a Unix-like filesystem over Memory/Volumes/Documents; resolve/ls/stat/mkdir/mv/rm) + document(input) (POST /v1/_document \u2014 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 \u2014 narrow as needed). v1.7.0 \u2014 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 \u2014 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 \u2014 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 \u2014 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 \u2014 existing path() / document() callers are unchanged. v1.16.0 \u2014 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> \u2014 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 \u2014 RFC BL P5 subject erasure: erasureReport(subject, {tenant}) (GET /v1/_erasure \u2014 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 \u2014 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 \u2014 the returned object is the only durable record of what was not reached; persist it. New ErasureReport / ErasureResult / ErasureTier / ErasureResidue types. v1.47.0 \u2014 RFC BV memory-view SDK: memorySearch() (POST /v1/_memory/search \u2014 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 \u2014 existing callers unchanged. v1.61.0 \u2014 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.",
+  "version": "1.78.0",
+  "description": "TypeScript client for the loomcycle sidecar (HTTP+SSE). 71 methods covering run streaming, agent metadata, pause/resume/state, resolver re-probe (resolveProbe \u2014 issue #88 operator escape hatch), operator-token admin (operatorTokenDef \u2014 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 \u2014 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 \u2014 direct provider routing without agent overhead; primary target is n8n's LoomCycleChatModel AI Agent sub-node and any LangChain-compatible consumer). v0.10.1 \u2014 dual ESM + CommonJS distribution (additive \u2014 ESM consumers unchanged; CJS consumers like n8n's community-node loader now work). v0.19.0 \u2014 typed inline code-js agent ingestion (AgentDefOverlay.code_body + ensureCodeAgent \u2014 register a deterministic code agent through the substrate with no host filesystem bind; RFC J). v0.20.0 \u2014 ensureMcpServer surfaces discoveredToolCount straight from create (loomcycle now auto-discovers MCP tools at ingestion); rediscover is now an explicit force-refresh. v0.21.0 \u2014 run/continue accept optional non-secret `metadata` (repo name, review policy, \u2026) passed to the agent, symmetric with the WebHook/Schedule trigger paths. v0.22.0 \u2014 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 \u2014 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 \u2014 purgeChannel clears a channel's buffered messages without deleting its definition (allowed on yaml-declared channels too, unlike deleteChannel \u2014 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 \u2014 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 \u2014 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 \u2014 the manual-management Web UI console + Context op=time + max_fires self-retiring schedules \u2014 is server-side / in-band, no client-surface change). v0.29.1 \u2014 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 \u2014 gRPC + TS client parity for the RFC Y external fan-out and the compaction surface: spawnRunBatch() (POST /v1/runs:batch \u2014 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 \u2014 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 \u2014 server-side.) v0.34.0 \u2014 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 \u2014 RFC AH dynamic filesystem volumes: volumeDef() (POST /v1/_volumedef \u2014 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] \u2014 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 \u2014 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 \u2014 steer a live run) + streamRunByID(runId, {fromSeq}) (GET /v1/runs/{id}/stream \u2014 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 \u2014 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 \u2014 RFC AL Path VFS + RFC AK Document on the wire: path(input) (POST /v1/_path \u2014 a Unix-like filesystem over Memory/Volumes/Documents; resolve/ls/stat/mkdir/mv/rm) + document(input) (POST /v1/_document \u2014 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 \u2014 narrow as needed). v1.7.0 \u2014 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 \u2014 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 \u2014 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 \u2014 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 \u2014 existing path() / document() callers are unchanged. v1.16.0 \u2014 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> \u2014 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 \u2014 RFC BL P5 subject erasure: erasureReport(subject, {tenant}) (GET /v1/_erasure \u2014 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 \u2014 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 \u2014 the returned object is the only durable record of what was not reached; persist it. New ErasureReport / ErasureResult / ErasureTier / ErasureResidue types. v1.47.0 \u2014 RFC BV memory-view SDK: memorySearch() (POST /v1/_memory/search \u2014 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 \u2014 existing callers unchanged. v1.61.0 \u2014 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 \u2014 the TeamDef version lifecycle: listTeamVersions(name) (op=list \u2014 every version of one team, newest first), promoteTeam(defId) (op=promote \u2014 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 \u2014 reversible and version-scoped, unlike deleteTeam) and verifyTeam(name, contentSha256) (op=verify \u2014 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",
   "repository": {