@loomcycle/client 1.93.0 → 1.94.0

package/dist/cjs/client.js

@@ -1116,11 +1116,13 @@ class LoomcycleClient {
         });
     }
     // ---- Hook management (hooks-connector series, PR C) ----
-    /** Register a pre- or post-tool webhook. The callback_url must be
-     *  an http:// or https:// endpoint the CONSUMER runs — loomcycle
-     *  POSTs PreHookCall / PostHookCall payloads to it. This method
-     *  manages registration only; the receiver is the consumer's own
-     *  HTTP framework (Express, Next.js, etc.).
+    /** Register a pre- or post-tool hook. Its body is a webhook — the
+     *  callback_url must be an http:// or https:// endpoint the CONSUMER
+     *  runs; loomcycle POSTs PreHookCall / PostHookCall payloads to it —
+     *  or a code-js body (`code`), run in-process by loomcycle. Set
+     *  exactly one. This method manages registration only; a webhook's
+     *  receiver is the consumer's own HTTP framework (Express, Next.js,
+     *  etc.).
      *
      *  Re-registering the same (owner, name) replaces the prior entry
      *  with a fresh id (idempotent app-restart contract).
@@ -1132,8 +1134,11 @@ class LoomcycleClient {
             owner: opts.owner,
             name: opts.name,
             phase: opts.phase,
-            callback_url: opts.callbackUrl,
         };
+        if (opts.callbackUrl !== undefined)
+            body.callback_url = opts.callbackUrl;
+        if (opts.code !== undefined)
+            body.code = opts.code;
         if (opts.agents !== undefined)
             body.agents = opts.agents;
         if (opts.tools !== undefined)
@@ -1534,6 +1539,10 @@ class LoomcycleClient {
             body.mode = target.mode;
         if (target.breakpoints !== undefined)
             body.breakpoints = target.breakpoints;
+        if (target.review !== undefined)
+            body.review = target.review;
+        if (target.reviewTtlSeconds !== undefined)
+            body.review_ttl_seconds = target.reviewTtlSeconds;
         return (0, fetch_helpers_js_1.postJSON)(this.ctx, "/v1/_teamdef", body, opts);
     }
     /** Read the debug breakpoints armed on a live team walk
@@ -1554,10 +1563,11 @@ class LoomcycleClient {
      *  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.
+     *  Each entry is a starter state id — `"wave"` (or `"wave:before_dispatch"`)
+     *  pauses the state before it dispatches, and `"wave:review"` holds its member
+     *  runs for a verdict ({@link LoomcycleClient.reviewRun}). An arm takes effect
+     *  at the next point 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) {

package/dist/client.d.ts

@@ -696,11 +696,13 @@ export declare class LoomcycleClient {
         resolvedBy?: string;
         signal?: AbortSignal;
     }): Promise<unknown>;
-    /** Register a pre- or post-tool webhook. The callback_url must be
-     *  an http:// or https:// endpoint the CONSUMER runs — loomcycle
-     *  POSTs PreHookCall / PostHookCall payloads to it. This method
-     *  manages registration only; the receiver is the consumer's own
-     *  HTTP framework (Express, Next.js, etc.).
+    /** Register a pre- or post-tool hook. Its body is a webhook — the
+     *  callback_url must be an http:// or https:// endpoint the CONSUMER
+     *  runs; loomcycle POSTs PreHookCall / PostHookCall payloads to it —
+     *  or a code-js body (`code`), run in-process by loomcycle. Set
+     *  exactly one. This method manages registration only; a webhook's
+     *  receiver is the consumer's own HTTP framework (Express, Next.js,
+     *  etc.).
      *
      *  Re-registering the same (owner, name) replaces the prior entry
      *  with a fresh id (idempotent app-restart contract).
@@ -1061,10 +1063,11 @@ export declare class LoomcycleClient {
      *  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.
+     *  Each entry is a starter state id — `"wave"` (or `"wave:before_dispatch"`)
+     *  pauses the state before it dispatches, and `"wave:review"` holds its member
+     *  runs for a verdict ({@link LoomcycleClient.reviewRun}). An arm takes effect
+     *  at the next point 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?: {

package/dist/client.js

@@ -1113,11 +1113,13 @@ export class LoomcycleClient {
         });
     }
     // ---- Hook management (hooks-connector series, PR C) ----
-    /** Register a pre- or post-tool webhook. The callback_url must be
-     *  an http:// or https:// endpoint the CONSUMER runs — loomcycle
-     *  POSTs PreHookCall / PostHookCall payloads to it. This method
-     *  manages registration only; the receiver is the consumer's own
-     *  HTTP framework (Express, Next.js, etc.).
+    /** Register a pre- or post-tool hook. Its body is a webhook — the
+     *  callback_url must be an http:// or https:// endpoint the CONSUMER
+     *  runs; loomcycle POSTs PreHookCall / PostHookCall payloads to it —
+     *  or a code-js body (`code`), run in-process by loomcycle. Set
+     *  exactly one. This method manages registration only; a webhook's
+     *  receiver is the consumer's own HTTP framework (Express, Next.js,
+     *  etc.).
      *
      *  Re-registering the same (owner, name) replaces the prior entry
      *  with a fresh id (idempotent app-restart contract).
@@ -1129,8 +1131,11 @@ export class LoomcycleClient {
             owner: opts.owner,
             name: opts.name,
             phase: opts.phase,
-            callback_url: opts.callbackUrl,
         };
+        if (opts.callbackUrl !== undefined)
+            body.callback_url = opts.callbackUrl;
+        if (opts.code !== undefined)
+            body.code = opts.code;
         if (opts.agents !== undefined)
             body.agents = opts.agents;
         if (opts.tools !== undefined)
@@ -1531,6 +1536,10 @@ export class LoomcycleClient {
             body.mode = target.mode;
         if (target.breakpoints !== undefined)
             body.breakpoints = target.breakpoints;
+        if (target.review !== undefined)
+            body.review = target.review;
+        if (target.reviewTtlSeconds !== undefined)
+            body.review_ttl_seconds = target.reviewTtlSeconds;
         return postJSON(this.ctx, "/v1/_teamdef", body, opts);
     }
     /** Read the debug breakpoints armed on a live team walk
@@ -1551,10 +1560,11 @@ export class LoomcycleClient {
      *  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.
+     *  Each entry is a starter state id — `"wave"` (or `"wave:before_dispatch"`)
+     *  pauses the state before it dispatches, and `"wave:review"` holds its member
+     *  runs for a verdict ({@link LoomcycleClient.reviewRun}). An arm takes effect
+     *  at the next point 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) {

package/dist/types.d.ts

@@ -7,7 +7,7 @@
  * `client.ts` for the input shapes (RunOptions, CreateSnapshotOptions,
  * etc.) — those are translated to snake_case in the request body.
  */
-export type EventType = "started" | "text" | "tool_call" | "tool_result" | "usage" | "done" | "error" | "retry" | "host_widened" | "session" | "agent" | "awaiting_input" | "awaiting_review" | "steer" | "context_compaction" | "capability_inert" | "limit" | "override" | "context_recap" | "context_state" | "context_distill_declined" | "context_exhausted" | "thinking" | "turn_cancelled" | "provider_fallback" | "fallback_suppressed" | "model_downgraded" | "cache_invalidated" | "reasoning_invalidated" | "channel_publish" | "channel_delivery" | "interruption_pending" | "spawn_child_started" | "spawn_child_result" | "prompt_snapshot" | "_meta";
+export type EventType = "started" | "text" | "tool_call" | "tool_result" | "usage" | "done" | "error" | "retry" | "host_widened" | "session" | "agent" | "awaiting_input" | "awaiting_review" | "steer" | "context_compaction" | "capability_inert" | "hook_decision" | "limit" | "override" | "context_recap" | "context_state" | "context_distill_declined" | "context_exhausted" | "thinking" | "turn_cancelled" | "provider_fallback" | "fallback_suppressed" | "model_downgraded" | "cache_invalidated" | "reasoning_invalidated" | "channel_publish" | "channel_delivery" | "interruption_pending" | "spawn_child_started" | "spawn_child_result" | "prompt_snapshot" | "_meta";
 export interface ToolUse {
     id: string;
     name: string;
@@ -253,6 +253,29 @@ export interface ErrorInfo {
      *  instructions. */
     retry_after_ms?: number;
 }
+/** What one hook did to one call, or to the run (the `hook_decision`
+ *  payload). */
+export interface HookDecisionInfo {
+    /** `"<owner>/<name>"`. */
+    hook: string;
+    phase: HookPhase;
+    /** The call a tool hook decided on; absent for agent_start / agent_stop. */
+    tool_use_id?: string;
+    tool_name?: string;
+    /** `block` and `hold` are agent_stop's: the model was sent back with
+     *  `reason`, or the answer is held for a verdict. */
+    decision: "deny" | "rewrite_input" | "rewrite_output" | "context" | "block" | "hold" | "unavailable";
+    /** For `unavailable`: `open` (the call went ahead) or `closed` (refused). */
+    fail_mode?: "open" | "closed";
+    /** A deny's or block's text, a hold's reason, or the error that made the
+     *  hook unavailable. */
+    reason?: string;
+    /** For `rewrite_input`: the input the tool actually ran with. */
+    updated_input?: unknown;
+    /** For `context`: what was appended to the tool result (or, for
+     *  agent_start, to the prompt). */
+    additional_context?: string;
+}
 /** The payload on a `capability_inert` event: one tool the agent holds and
  *  cannot use, because the capability gate that tool reads grants nothing.
  *
@@ -452,11 +475,14 @@ export interface AgentEvent {
         since_turn?: number;
     };
     /** Payload on `event: awaiting_review` — the run is held for a verdict.
-     *  `round` is 1 on the first answer and counts up with each revision. */
+     *  `round` is 1 on the first answer and counts up with each revision.
+     *  `held_by` names the agent_stop hook that held it; absent when review
+     *  arming did (and only that kind is released by disarming review). */
     awaiting_review?: {
         since_turn?: number;
         round?: number;
         expires_at?: string;
+        held_by?: string;
     };
     /** 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. */
@@ -470,6 +496,8 @@ export interface AgentEvent {
     limit?: LimitInfo;
     /** Set on `capability_inert` events: a tool the agent holds and cannot use. */
     capability_inert?: CapabilityInertInfo;
+    /** Payload on `event: hook_decision`. */
+    hook_decision?: HookDecisionInfo;
     /** Set on `event: override` frames — what the operator changed, and from
      *  what to what. */
     override?: OverrideInfo;
@@ -1763,7 +1791,9 @@ export interface ResolveInterruptOptions {
      *  the waiting Question tool proceeds. */
     disposition?: "answer" | "declined";
 }
-export type HookPhase = "pre" | "post";
+/** `post_failure` runs only when the tool failed, before the post chain, with
+ *  the failure's classification in the payload. */
+export type HookPhase = "pre" | "post" | "post_failure" | "agent_start" | "agent_stop";
 export type HookFailMode = "open" | "closed";
 /** Hook is the full descriptor returned by listHooks. The id +
  *  registered_at are loomcycle-assigned; the rest mirrors what was
@@ -1780,6 +1810,8 @@ export interface Hook {
     fail_mode: HookFailMode;
     timeout_ms: number;
     registered_at: string;
+    /** The code-js body, when the hook has one instead of a callback_url. */
+    code?: string;
 }
 /** RegisterHookOptions uses camelCase (JS norm for method parameters)
  *  and is translated to snake_case in the request body — same split as
@@ -1796,12 +1828,18 @@ export interface RegisterHookOptions {
     /** Tool name globs (same syntax). Empty matches every tool. */
     tools?: string[];
     /** http:// or https:// URL loomcycle POSTs PreHookCall /
-     *  PostHookCall payloads to. */
-    callbackUrl: string;
+     *  PostHookCall payloads to. Set this or `code`. */
+    callbackUrl?: string;
+    /** A code-js body in place of a webhook: JavaScript defining a
+     *  top-level `hook(ev)` that returns the decision. Its only tool is
+     *  `Interruption` (ask, notify). Needs code hooks enabled on the
+     *  server. Set this or `callbackUrl`. */
+    code?: string;
     /** "open" (default) — webhook errors pass through. "closed" — webhook
      *  errors fail the tool call with IsError=true. */
     failMode?: HookFailMode;
-    /** Per-call timeout. 0 / omitted = registry default (5 s). */
+    /** Per-call timeout. 0 / omitted = registry default (5 s; 50 ms for a
+     *  code body, where it bounds each run of the code, capped at 1 s). */
     timeoutMs?: number;
 }
 export interface RegisterHookResponse {
@@ -2017,14 +2055,25 @@ export interface TeamRunTarget {
      *  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"`.
+     *  `"<state>"` or `"<state>:before_dispatch"`: the walk pauses before the
+     *  state dispatches its wave, with every prompt composed and nothing run.
      *
      *  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. */
+     *  go wrong, and want to stop before the next one.
+     *
+     *  `"<state>:review"` arms review instead — see {@link TeamRunTarget.review}. */
     breakpoints?: string[];
+    /** Starter state ids whose member runs are held for an operator's verdict
+     *  when they finish: approve with {@link LoomcycleClient.reviewRun}, reject
+     *  with feedback the member revises from, or reject. A rejected member
+     *  reaches the sink as status `"rejected"` and does not count toward the
+     *  wave's `wait`. Also armable live as the breakpoint `"<state>:review"`. */
+    review?: string[];
+    /** With `review`: end a member hold nobody rules on within this many
+     *  seconds as rejected. Omit for no deadline. */
+    reviewTtlSeconds?: number;
 }
 /** What {@link LoomcycleClient.runTeam} returns for `mode: "detach"` — the
  *  handle, immediately, with the walk still running behind it.

package/package.json

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