@loomcycle/client 1.111.0 → 1.113.0

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, DecideRequest, DecideResponse, DecisionModelsResponse, CredentialScope, DirectoryInspection, DirectoryTenant, DirectoryUser, ErasureReport, ErasureResult, Agent, AgentEvent, AgentStatus, CancelAgentResult, ClientOptions, ContinueOptions, RunOverrideOptions, EffectiveConfigResponse, RetuneRunResponse, RunConfigResponse, RunPromptResponse, CreateSnapshotOptions, EnsureCodeAgentOptions, EnsureCodeAgentResult, EnsureMcpServerOptions, EnsureMcpServerResult, HealthResponse, InterruptListResponse, InterruptStatus, WalkRunsPage, AckChannelOptions, AwaitChannelsOptions, BroadcastChannelsOptions, ChannelAckResult, ChannelAwaitResult, ChannelBroadcastResult, ChannelDescriptor, ChannelPeekResult, ListTeamChannelsOptions, PeekTeamChannelOptions, ReleaseTeamChannelOptions, TeamChannelPeekResult, TeamChannelReleaseResult, TeamChannelsResult, 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, ResolveInterruptOptions, ResumeResult, ResolverMatrix, CompactRunResult, ReplaySessionResult, CancelTurnResult, ReviewRunResult, RunBatchOptions, RunBatchResult, RunOptions, ConfiguredRun, ConfiguredRunPatch, RunStateStreamItem, RuntimeStateResponse, SnapshotCreateResponse, SnapshotDescriptor, SnapshotEnvelope, SnapshotRestoreResponse, StreamUserRunStatesOptions, SubstrateToolInput, SubstrateToolResponse, CreatedTeam, ListTeamsResponse, PromotedTeam, RetiredTeam, TeamBreakpoints, TeamDefDetail, TeamRunDetached, TeamRunTarget, TeamVerification, TeamDraft, TeamDraftVerification, TeamVersionList, TeamDiagram, TeamRunResult, PathToolInput, PathToolResponse, DocumentToolInput, DocumentToolResponse, HistoryToolInput, HistoryToolResponse, TranscriptResponse, WhoamiResponse, UsageDimension, UsageReportResponse, TokenLimit, TokenLimitsResponse, ConfigResponse, SetTokenLimitRequest } from "./types.js";
+import type { ChangeFeedFrame, StreamChangesOptions, CredentialListResponse, CredentialMeta, DecideRequest, DecideResponse, DecisionModelsResponse, CredentialScope, DirectoryInspection, DirectoryTenant, DirectoryUser, ErasureReport, ErasureResult, Agent, AgentEvent, AgentList, CancelAgentResult, ClientOptions, ContinueOptions, RunOverrideOptions, EffectiveConfigResponse, AgentOverridableResponse, RetuneRunResponse, RunConfigResponse, RunPromptResponse, CreateSnapshotOptions, EnsureCodeAgentOptions, EnsureCodeAgentResult, EnsureHookDefOptions, EnsureHookDefResult, HookDefInput, HookDefOverlay, HookDefRowResponse, CreateDefOptions, ForkDefOptions, HookDefForkOverlay, ScheduleDefInput, ScheduleDefOverlay, ScheduleDefRowResponse, WebhookDefInput, WebhookDefOverlay, WebhookDefRowResponse, EnsureMcpServerOptions, EnsureMcpServerResult, HealthResponse, InterruptListResponse, InterruptStatus, ListUserAgentsOptions, WalkRunsPage, AckChannelOptions, AwaitChannelsOptions, BroadcastChannelsOptions, ChannelAckResult, ChannelAwaitResult, ChannelBroadcastResult, ChannelDescriptor, ChannelPeekResult, ListTeamChannelsOptions, PeekTeamChannelOptions, ReleaseTeamChannelOptions, TeamChannelPeekResult, TeamChannelReleaseResult, TeamChannelsResult, 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, RetentionOverride, PersistentVolumesResponse, EphemeralVolumesResponse, ResolveInterruptOptions, ResumeResult, ResolverMatrix, CompactRunResult, RunTreeDeletion, ReplaySessionResult, CancelTurnResult, ReviewRunResult, RunBatchOptions, RunBatchResult, RunOptions, ConfiguredRun, ConfiguredRunPatch, RunStateStreamItem, RuntimeStateResponse, SnapshotCreateResponse, SnapshotDescriptor, SnapshotEnvelope, SnapshotRestoreResponse, StreamUserRunStatesOptions, SubstrateToolInput, SubstrateToolResponse, CreatedTeam, CreateTeamOptions, DefNamesResponse, ForkTeamOptions, ModelAliasesResponse, OperatorTokenDefNamesResponse, ProviderModelsResponse, RoutingResponse, ScheduleListResponse, SchedulePauseResult, ScheduleRunNowResult, ScheduleStateView, ListTeamsResponse, PromotedTeam, RetiredTeam, TeamBreakpoints, TeamDefDetail, TeamRunDetached, TeamRunTarget, TeamVerification, TeamDraft, TeamDraftVerification, TeamVersionList, TeamDiagram, TeamRunResult, PathToolInput, PathToolResponse, DocumentToolInput, DocumentToolResponse, HistoryToolInput, HistoryToolResponse, EvaluationSubmitInput, EvaluationGetInput, EvaluationListForRunInput, EvaluationListForDefInput, EvaluationAggregateInput, EvaluationInput, EvaluationSubmitResult, EvaluationRecord, EvaluationListForRunResult, EvaluationListForDefResult, EvaluationAggregate, TranscriptResponse, WhoamiResponse, UsageDimension, UsageReportResponse, TokenLimit, TokenLimitsResponse, ConfigResponse, SetTokenLimitRequest } from "./types.js";
 export declare class LoomcycleClient {
     private ctx;
     constructor(opts?: ClientOptions);
@@ -183,6 +183,24 @@ export declare class LoomcycleClient {
     getEffectiveConfig(runId: string, opts?: {
         signal?: AbortSignal;
     }): Promise<EffectiveConfigResponse>;
+    /** Which per-run overrides a run of `name` may set, for this caller — what a
+     *  run form needs before it sends anything. Mirrors
+     *  `GET /v1/_agentdef/{name}/overridable`.
+     *
+     *  Folds the agent's `allow_overrides` with the caller's token overrides
+     *  policy, through the same checks the run path refuses with; a refused field
+     *  names which (`reason`). Overridable fields carry what the run path then
+     *  accepts: `narrow_only`, `max`, and `values` for a closed set.
+     *
+     *  `substrate:tenant` (a non-isolated member too). A token limited to certain
+     *  agents may ask about those agents only. Raises {@link AgentNotFoundError}
+     *  (404) for an unknown or another tenant's agent, and a 403
+     *  `agent_not_allowed` for an agent outside the token's allowlist. */
+    getAgentOverridable(name: string, opts?: {
+        /** Admin-only tenant focus (?tenant=); ignored for a tenant principal. */
+        tenant?: string;
+        signal?: AbortSignal;
+    }): Promise<AgentOverridableResponse>;
     /** Re-attach to a run's event stream by `run_id` (RFC AI), replaying from
      *  `fromSeq` (default 0) then live-tailing — the gRPC-free twin of the Web
      *  UI's resume-in-terminal. Mirrors `GET /v1/runs/{run_id}/stream`. The
@@ -312,6 +330,36 @@ export declare class LoomcycleClient {
         reason?: string;
         signal?: AbortSignal;
     }): Promise<CompactRunResult>;
+    /** Permanently delete a run and every run it spawned, with what is stored
+     *  about them: transcripts, their sessions when no other run is left in
+     *  them, interrupts, evaluations of them, queued memory rows and indexed
+     *  turns. The usage ledger (tokens, cost) is kept. Mirrors
+     *  `DELETE /v1/runs/{run_id}/tree`.
+     *
+     *  Needs the `runs:delete` scope (an admin and a tenant operator have it;
+     *  any other token only if it was granted at mint) — a token without it
+     *  raises `LoomcycleError` with status 403. A run that does not exist, was
+     *  already deleted, or is not yours to read resolves with `deleted_runs: 0`
+     *  rather than raising, so repeating the call is safe. A tree holding a run
+     *  that is still running, awaiting input or paused deletes nothing and
+     *  raises `LoomcycleError` with `code: "run_tree_live"` (status 409): cancel
+     *  it first. `not_reached` names where a copy may remain that this call
+     *  cannot remove. To discard a configured run that never started, use
+     *  {@link LoomcycleClient.deleteConfiguredRun}. */
+    deleteRunTree(runId: string, opts?: {
+        signal?: AbortSignal;
+    }): Promise<RunTreeDeletion>;
+    /** Permanently delete every run of a session, each with the runs it
+     *  spawned — {@link LoomcycleClient.deleteRunTree} for all of them at once.
+     *  `cascade: "children"` is required and is the only mode: there is no
+     *  delete that leaves sub-agent runs behind. Mirrors
+     *  `DELETE /v1/sessions/{session_id}?cascade=children`. Same scope, same
+     *  zero-count answer for a session you cannot read, same `run_tree_live`
+     *  refusal. */
+    deleteSession(sessionId: string, opts: {
+        cascade: "children";
+        signal?: AbortSignal;
+    }): Promise<RunTreeDeletion>;
     /**
      * Replay a session's transcript into a NEW session bound to a (possibly
      * different) target agent, so that agent continues from the same context
@@ -383,22 +431,21 @@ export declare class LoomcycleClient {
         reason?: string;
         signal?: AbortSignal;
     }): Promise<CancelAgentResult>;
-    /** List a user's recent agent runs, optionally filtered by status. With no
-     *  `status` only running runs are returned; `"all"` returns every status.
+    /** List a user's recent agent runs (at most 100), optionally filtered by
+     *  status. With no `status` only running runs are returned; `"all"` returns
+     *  every status; several statuses list a run in any of them.
+     *
+     *  `awaitedState` lists only running runs blocked on one of the named waits
+     *  (`"review"`, `"input"`, …). The state is derived per run, so the server
+     *  reads at most 1,000 running runs; the returned array carries
+     *  `truncated: true` when it stopped with some unread.
      *
      *  v0.9.x — `parentAgentId` narrows the result CLIENT-SIDE to runs
      *  whose `parent_agent_id` matches. The server still returns the
      *  full set (server-side `?parent_agent_id=` filter is a future
      *  request); the adapter trims before returning. Useful for the
      *  n8n trigger pattern "show me all sub-runs spawned by parent X." */
-    listUserAgents(userId: string, opts?: {
-        status?: AgentStatus | "all";
-        parentAgentId?: string;
-        /** Super-admin tenant-focus (?tenant=, RFC L v0.17.0). Ignored
-         *  server-side for a tenant principal — its own tenant is forced. */
-        tenant?: string;
-        signal?: AbortSignal;
-    }): Promise<Agent[]>;
+    listUserAgents(userId: string, opts?: ListUserAgentsOptions): Promise<AgentList>;
     /** One page of a team walk's runs — the walk's own run (its run id IS the
      *  walk id) and every member it spawned, oldest first. The walk's own row
      *  carries its `result` (with the `terminal` it reached); member rows do
@@ -478,6 +525,38 @@ export declare class LoomcycleClient {
         tenant?: string;
         signal?: AbortSignal;
     }): Promise<void>;
+    /** The timed no-trace overrides in force: agents whose runs are being
+     *  stored although they normally store none. An admin sees every tenant's
+     *  (or one with `tenant`); a tenant operator sees its own. Mirrors
+     *  `GET /v1/_retention/overrides`. */
+    listRetentionOverrides(opts?: {
+        /** Admin-only tenant focus; ignored for a tenant operator. */
+        tenant?: string;
+        signal?: AbortSignal;
+    }): Promise<{
+        overrides: RetentionOverride[];
+    }>;
+    /** Store the runs of one no-trace agent until `until`, to debug it. At
+     *  most 24 hours ahead; setting one replaces the last. It lifts a mode
+     *  that came from the agent's definition or the run request, never one a
+     *  token requires. Audited. `tenant` is admin-only: a tenant operator's
+     *  override is always for its own tenant. Mirrors
+     *  `PUT /v1/_retention/overrides`. */
+    setRetentionOverride(body: {
+        agent: string;
+        until: string | Date;
+        tenant?: string;
+    }, opts?: {
+        signal?: AbortSignal;
+    }): Promise<RetentionOverride>;
+    /** End an agent's no-trace override before it runs out. Clearing one that
+     *  is not there is not an error. Mirrors
+     *  `DELETE /v1/_retention/overrides`. */
+    clearRetentionOverride(agent: string, opts?: {
+        /** Admin-only target tenant; ignored for a tenant operator. */
+        tenant?: string;
+        signal?: AbortSignal;
+    }): Promise<void>;
     /** Ask a decision model typed questions (`choice` / `noul` / `score`) about
      *  `state` and get each answer with its probabilities. A decision model does
      *  not write: there is no reply to parse and the call costs a few output
@@ -544,9 +623,47 @@ export declare class LoomcycleClient {
      *  scopes are DERIVED server-side from the member's access_mode (never sent),
      *  and the plaintext `token` is returned exactly ONCE — store it now, it is
      *  never retrievable again. 404 for an unknown/cross-tenant subject; 409 for
-     *  a disabled user. */
+     *  a disabled user.
+     *
+     *  `ttlSeconds` gives the token a fixed lifetime: it stops authenticating
+     *  when that runs out, and the answer carries `expires_at`. It cannot run
+     *  past the end of the token making the call. `name` labels it (stored as
+     *  `u-<name>`).
+     *  `maxActive` keeps at most that many of the user's tokens alive — the
+     *  oldest beyond it are retired at once and listed in `retired`.
+     *
+     *  `agents` limits the token to starting those agents as top-level runs, and
+     *  to the run endpoints: it is refused everywhere else (403
+     *  `restricted_token`), and refused any other agent (403
+     *  `agent_not_allowed`). An agent that a listed one spawns is not limited.
+     *  An empty list is refused; omit the option for no limit.
+     *
+     *  `overrides` locks the per-run settings for runs the token starts, and
+     *  for retunes it makes: `"none"` locks them all (model, provider, tier,
+     *  effort, sampling, limits, output format and the rest), a list names the
+     *  ones it may still set. A request that sets a locked one is refused with
+     *  403 `override_not_allowed`.
+     *
+     *  `rate` bounds how often the token may start runs: `perMinute` runs a
+     *  minute, with `burst` allowed at once from idle (default: `perMinute`).
+     *  A start past the rate is refused with 429 `rate_limited` and a
+     *  `Retry-After` header.
+     *
+     *  With none of the options the request has no body, as before. */
     mintUserToken(subject: string, opts?: {
         signal?: AbortSignal;
+        ttlSeconds?: number;
+        name?: string;
+        maxActive?: number;
+        agents?: string[];
+        overrides?: "none" | string[];
+        rate?: {
+            perMinute: number;
+            burst?: number;
+        };
+        /** `"none"`: every run the token starts is a no-trace run, whatever
+         *  the request or the agent says. */
+        retention?: "none";
     }): Promise<MintedUserToken>;
     /** List the caller's own user's delegated tokens — METADATA ONLY (never the
      *  plaintext or hash). `active` applies the auth-layer validity rule so a
@@ -606,6 +723,38 @@ export declare class LoomcycleClient {
     resolveProbe(opts?: {
         signal?: AbortSignal;
     }): Promise<ResolverMatrix>;
+    /** The configured model aliases — the operator's top-level `models:` map,
+     *  alias name → `{provider, model, kind?}` (`GET /v1/_models`). Non-secret and
+     *  global (the same set for every tenant); tenant-readable. Store an alias on
+     *  an agent or fork rather than the concrete model it names, and the agent
+     *  follows when the operator retargets the alias. */
+    listModels(opts?: {
+        signal?: AbortSignal;
+    }): Promise<ModelAliasesResponse>;
+    /** For each user tier × tier, the ordered provider/model cascade a run
+     *  resolves to now, top first, with live availability and the candidate
+     *  `selected` (`GET /v1/_routing`). Tenant-readable. A non-admin caller gets
+     *  `admin: false`, no raw `last_error`, and — when the operator-key gate
+     *  restricts it — only the providers it can key itself
+     *  (`operator_key_restricted: true`). */
+    getRouting(opts?: {
+        signal?: AbortSignal;
+    }): Promise<RoutingResponse>;
+    /** List the models a provider serves right now, by a live round-trip to it
+     *  (`GET /v1/_providers/{id}/models`) rather than the cached probe matrix.
+     *
+     *  **Requires an admin token.** A `substrate:tenant` token is refused with a
+     *  {@link LoomcycleError} whose `status` is 403 ("insufficient scope"); a
+     *  model picker built on a tenant token should fall back to
+     *  {@link LoomcycleClient.listModels} plus free-text model entry.
+     *
+     *  Errors carry the server's code on `e.code`: 404 `provider_unknown` (no such
+     *  driver), 503 `provider_unavailable` (known, but not configured — e.g. no
+     *  key), 502 `provider_list_failed` (the round-trip failed; bounded at 10 s
+     *  server-side). */
+    listProviderModels(providerId: string, opts?: {
+        signal?: AbortSignal;
+    }): Promise<ProviderModelsResponse>;
     /** Capture running-state into a per-section-semver JSON envelope.
      *  Raises SnapshotTooLargeError on 413 when the envelope exceeds
      *  LOOMCYCLE_SNAPSHOT_MAX_BYTES (default 512 MiB). */
@@ -896,10 +1045,29 @@ export declare class LoomcycleClient {
      *  Raises {@link SubstrateToolRefusedError} on tool-level refusals
      *  (static-name collision, missing required credential, invalid
      *  cron, etc.); {@link InvalidArgumentError} on 400 (malformed
-     *  JSON); {@link AuthError} on 401. */
-    scheduleDef(input: SubstrateToolInput, opts?: {
+     *  JSON); {@link AuthError} on 401.
+     *
+     *  Annotate the input as {@link ScheduleDefInput} to have the overlay and
+     *  each op's fields checked (including `add_hook` / `remove_hook`, which the
+     *  loose {@link SubstrateToolInput} does not list); a loose input is sent
+     *  as it is. For create / fork, {@link LoomcycleClient.createScheduleDef} /
+     *  {@link LoomcycleClient.forkScheduleDef} check a bare literal too. */
+    scheduleDef(input: ScheduleDefInput | SubstrateToolInput, opts?: {
         signal?: AbortSignal;
     }): Promise<SubstrateToolResponse>;
+    /** `scheduleDef({op: "create"})` with the overlay typed and no loose
+     *  fallback. {@link ScheduleDefOverlay} stays OPEN (the server drops keys it
+     *  does not know), so a misspelt key still compiles here; what fails is a
+     *  wrong type or value on a key it declares (`concurrency_policy: "skip"`,
+     *  an `on_complete` entry missing its `tool`). New versions are promoted
+     *  unless `promote: false`. */
+    createScheduleDef(name: string, overlay: ScheduleDefOverlay, opts?: CreateDefOptions): Promise<ScheduleDefRowResponse>;
+    /** `scheduleDef({op: "fork"})`, typed like
+     *  {@link LoomcycleClient.createScheduleDef}. A field the overlay leaves out
+     *  keeps the parent's; the credential maps merge key by key. Forks the
+     *  active version of `name` (or its yaml template) unless `parentDefId` is
+     *  given; promoted unless `promote: false`. */
+    forkScheduleDef(name: string, overlay: ScheduleDefOverlay, opts?: ForkDefOptions): Promise<ScheduleDefRowResponse>;
     /** Invoke the v1.x RFC G A2AServerCardDef substrate tool over HTTP.
      *  Author + fork + retire A2A server-card definitions at runtime.
      *  Mirror of {@link LoomcycleClient.scheduleDef} for A2A server cards.
@@ -941,10 +1109,29 @@ export declare class LoomcycleClient {
      *
      *  Raises {@link SubstrateToolRefusedError} on tool-level refusals;
      *  {@link InvalidArgumentError} on 400 (malformed JSON);
-     *  {@link AuthError} on 401. */
-    webhookDef(input: SubstrateToolInput, opts?: {
+     *  {@link AuthError} on 401.
+     *
+     *  Annotate the input as {@link WebhookDefInput} to have the overlay and
+     *  each op's fields checked; a loose input is sent as it is. For create /
+     *  fork, {@link LoomcycleClient.createWebhookDef} /
+     *  {@link LoomcycleClient.forkWebhookDef} check a bare literal too. */
+    webhookDef(input: WebhookDefInput | SubstrateToolInput, opts?: {
         signal?: AbortSignal;
     }): Promise<SubstrateToolResponse>;
+    /** `webhookDef({op: "create"})` with the overlay typed and no loose
+     *  fallback. {@link WebhookDefOverlay} stays OPEN for now (the server drops
+     *  keys it does not know), so a misspelt key still compiles here; what
+     *  fails is a wrong type or value on a key it declares (`delivery: "run"`,
+     *  `auth.kind: "basic"`, a misspelt key inside `rate_limit`). Promoted
+     *  unless `promote: false`. */
+    createWebhookDef(name: string, overlay: WebhookDefOverlay, opts?: CreateDefOptions): Promise<WebhookDefRowResponse>;
+    /** `webhookDef({op: "fork"})`, typed like
+     *  {@link LoomcycleClient.createWebhookDef}. A field the overlay leaves out
+     *  keeps the parent's; naming exactly one of `agent` / `channel` / `team`
+     *  clears the other two. Forks the active version of `name` (or its yaml
+     *  template) unless `parentDefId` is given; promoted unless
+     *  `promote: false`. */
+    forkWebhookDef(name: string, overlay: WebhookDefOverlay, opts?: ForkDefOptions): Promise<WebhookDefRowResponse>;
     /** Invoke the RFC I MR-3a MemoryBackendDef substrate tool over HTTP.
      *  Author + fork + retire named memory backend definitions at runtime.
      *  Mirror of {@link LoomcycleClient.webhookDef} for memory backends.
@@ -973,10 +1160,51 @@ export declare class LoomcycleClient {
      *  matches, its body (code-js or a webhook URL), fail mode and timeout.
      *  Tenant-confined like agentDef. A HookDef fires on nothing by itself; an
      *  agent definition, a team definition or a run names it. Mirrors
-     *  POST /v1/_hookdef. */
-    hookDef(input: SubstrateToolInput, opts?: {
+     *  POST /v1/_hookdef.
+     *
+     *  Annotate the input as {@link HookDefInput} to have the overlay checked
+     *  against the definition the server decodes STRICTLY — an unknown overlay
+     *  key is then a compile error instead of a refusal. A loose
+     *  {@link SubstrateToolInput} is sent as it is — including a bare literal
+     *  with a misspelt key, which falls through to that loose shape. To have a
+     *  bare literal checked, use {@link LoomcycleClient.createHookDef} /
+     *  {@link LoomcycleClient.forkHookDef}. */
+    hookDef(input: HookDefInput | SubstrateToolInput, opts?: {
         signal?: AbortSignal;
     }): Promise<SubstrateToolResponse>;
+    /** `hookDef({op: "create"})` with no loose fallback: `overlay` is the
+     *  CLOSED {@link HookDefOverlay}, so any key the server would refuse is a
+     *  compile error, even in a bare literal. Every create mints a new version
+     *  (use {@link LoomcycleClient.ensureHookDef} to register only on change);
+     *  promoted unless `promote: false`. */
+    createHookDef(name: string, overlay: HookDefOverlay, opts?: CreateDefOptions): Promise<HookDefRowResponse>;
+    /** `hookDef({op: "fork"})`, closed like
+     *  {@link LoomcycleClient.createHookDef}. Each top-level field given replaces
+     *  the parent's; `null` clears one. Forks the active version of `name` in
+     *  your tenant unless `parentDefId` is given. NOT promoted unless
+     *  `promote: true` — authoring and putting in force are two steps. */
+    forkHookDef(name: string, overlay: HookDefForkOverlay, opts?: ForkDefOptions): Promise<HookDefRowResponse>;
+    /** Register a HookDef idempotently — the register-on-every-boot
+     *  convenience, sibling of {@link LoomcycleClient.ensureMcpServer}.
+     *
+     *  Unlike MCPServerDef and AgentDef, a HookDef `create` is NOT
+     *  content-addressed: every create mints a new version. And the hash
+     *  `verify` compares is computed over the server's own JSON encoding of the
+     *  definition, which this client cannot reproduce byte for byte. So instead
+     *  this reads the active version (`verify` for its def_id — it answers
+     *  `deployed: false` rather than raising — then `get`) and compares its
+     *  stored definition with `overlay`, both normalized the way the server
+     *  normalizes (`fail_mode` defaults to `"open"`, an empty `match.tools`,
+     *  description, header map or timeout is dropped). Equal → no write,
+     *  `changed: false`. Otherwise `create` with the default promote, which
+     *  makes the new version active.
+     *
+     *  The normalization only collapses what the server collapses, so a real
+     *  change is never skipped; should the server come to normalize something
+     *  more, the cost is a redundant version, not a lost one. The rationale
+     *  in {@link EnsureHookDefOptions.description} is not part of the
+     *  definition and does not count as a change. */
+    ensureHookDef(name: string, overlay: HookDefOverlay, opts?: EnsureHookDefOptions): Promise<EnsureHookDefResult>;
     /** OperatorTokenDef substrate ops (create/rotate/retire/get/list) —
      *  RFC L OSS multi-tenant authorization. Operator-admin only. The
      *  token plaintext is returned ONCE in the create/rotate response.
@@ -1006,6 +1234,101 @@ export declare class LoomcycleClient {
     volumeDef(input: SubstrateToolInput, opts?: {
         signal?: AbortSignal;
     }): Promise<SubstrateToolResponse>;
+    private listDefNames;
+    /** Every AgentDef name (`GET /v1/_agentdef/names`). */
+    listAgentDefNames(opts?: {
+        tenant?: string;
+        signal?: AbortSignal;
+    }): Promise<DefNamesResponse>;
+    /** Every SkillDef name (`GET /v1/_skilldef/names`). */
+    listSkillDefNames(opts?: {
+        tenant?: string;
+        signal?: AbortSignal;
+    }): Promise<DefNamesResponse>;
+    /** Every HookDef name (`GET /v1/_hookdef/names`). */
+    listHookDefNames(opts?: {
+        tenant?: string;
+        signal?: AbortSignal;
+    }): Promise<DefNamesResponse>;
+    /** Every MCPServerDef name (`GET /v1/_mcpserverdef/names`). */
+    listMcpServerDefNames(opts?: {
+        tenant?: string;
+        signal?: AbortSignal;
+    }): Promise<DefNamesResponse>;
+    /** Every ScheduleDef name (`GET /v1/_scheduledef/names`). Substrate only —
+     *  {@link LoomcycleClient.listAllSchedules} merges in the static yaml ones. */
+    listScheduleDefNames(opts?: {
+        tenant?: string;
+        signal?: AbortSignal;
+    }): Promise<DefNamesResponse>;
+    /** Every A2AServerCardDef name (`GET /v1/_a2aservercarddef/names`). */
+    listA2AServerCardDefNames(opts?: {
+        tenant?: string;
+        signal?: AbortSignal;
+    }): Promise<DefNamesResponse>;
+    /** Every A2AAgentDef name (`GET /v1/_a2aagentdef/names`). */
+    listA2AAgentDefNames(opts?: {
+        tenant?: string;
+        signal?: AbortSignal;
+    }): Promise<DefNamesResponse>;
+    /** Every WebhookDef name (`GET /v1/_webhookdef/names`). */
+    listWebhookDefNames(opts?: {
+        tenant?: string;
+        signal?: AbortSignal;
+    }): Promise<DefNamesResponse>;
+    /** Every MemoryBackendDef name (`GET /v1/_memorybackenddef/names`). */
+    listMemoryBackendDefNames(opts?: {
+        tenant?: string;
+        signal?: AbortSignal;
+    }): Promise<DefNamesResponse>;
+    /** Every DocumentSourceDef name (`GET /v1/_documentsourcedef/names`). */
+    listDocumentSourceDefNames(opts?: {
+        tenant?: string;
+        signal?: AbortSignal;
+    }): Promise<DefNamesResponse>;
+    /** Every OperatorTokenDef name (`GET /v1/_operatortokendef/names`), with its
+     *  subject and token counts — never a token. **Admin token only**: token
+     *  minting stays operator-only, so a `substrate:tenant` token is refused
+     *  with 403. */
+    listOperatorTokenDefNames(opts?: {
+        tenant?: string;
+        signal?: AbortSignal;
+    }): Promise<OperatorTokenDefNamesResponse>;
+    /** Every schedule: static yaml `scheduled_runs` and ScheduleDefs, merged by
+     *  name (`GET /v1/_schedules/list-all`), sorted by name. A tenant token sees
+     *  only its own tenant's ScheduleDefs — static schedules are operator
+     *  automation and appear only for an admin, who may focus one tenant with
+     *  `tenant`. */
+    listAllSchedules(opts?: {
+        tenant?: string;
+        signal?: AbortSignal;
+    }): Promise<ScheduleListResponse>;
+    /** One schedule's runtime state (`GET /v1/_schedules/{def_id}/state`): last
+     *  and next fire, pause, the last slot claim, the catch-up backlog and the
+     *  runs it has in flight. 404 when the def has no state row (never promoted,
+     *  retired, or not yours). */
+    getScheduleState(defId: string, opts?: {
+        signal?: AbortSignal;
+    }): Promise<ScheduleStateView>;
+    /** Fire a schedule now (`POST /v1/_schedules/{def_id}/run-now`). The run
+     *  starts on the scheduler's next tick, not during this call, and the regular
+     *  cadence continues after it. A run already in flight is handled by the
+     *  schedule's `concurrency_policy`. 404 for an unknown def. */
+    runScheduleNow(defId: string, opts?: {
+        signal?: AbortSignal;
+    }): Promise<ScheduleRunNowResult>;
+    /** Pause a schedule indefinitely (`POST /v1/_schedules/{def_id}/pause`) until
+     *  {@link LoomcycleClient.resumeSchedule}. Takes no duration: the server sets
+     *  `paused_until` about 100 years ahead. Distinct from
+     *  {@link LoomcycleClient.pauseRuntime}, which stops the whole runtime. */
+    pauseSchedule(defId: string, opts?: {
+        signal?: AbortSignal;
+    }): Promise<SchedulePauseResult>;
+    /** Clear a schedule's pause (`POST /v1/_schedules/{def_id}/resume`), so the
+     *  scheduler considers it due again; `next_run_at` is left as it was. */
+    resumeSchedule(defId: string, opts?: {
+        signal?: AbortSignal;
+    }): Promise<SchedulePauseResult>;
     /** List every team the caller may see (GET /v1/_teamdef/names), each with its
      *  version roll-up. Tenant-scoped server-side. `names` is `null` when empty. */
     listTeams(opts?: {
@@ -1025,16 +1348,22 @@ export declare class LoomcycleClient {
     }): Promise<TeamDefDetail>;
     /** Author a new TeamDef (op=create). `overlay` is the workflow graph
      *  (`{entry, states, transitions, max_iterations?, colors?}`), validated
-     *  server-side — an invalid graph raises {@link SubstrateToolRefusedError}. */
-    createTeam(name: string, overlay: Record<string, unknown>, opts?: {
-        signal?: AbortSignal;
-    }): Promise<CreatedTeam>;
+     *  server-side — an invalid graph raises {@link SubstrateToolRefusedError}.
+     *
+     *  `opts.promote` and `opts.description` ride beside `signal`, as on
+     *  {@link LoomcycleClient.forkTeam}; each is sent only when set. Omitted,
+     *  the server promotes a create (unlike a fork); `promote: false` authors the
+     *  version without putting it in force. */
+    createTeam(name: string, overlay: Record<string, unknown>, opts?: CreateTeamOptions): Promise<CreatedTeam>;
     /** Save an edited graph as a NEW version of an existing team (op=fork). With
-     *  no parent the server forks the name's active def; `overlay` (a full graph)
-     *  replaces it. Validated server-side ({@link SubstrateToolRefusedError}). */
-    forkTeam(name: string, overlay: Record<string, unknown>, opts?: {
-        signal?: AbortSignal;
-    }): Promise<CreatedTeam>;
+     *  no `parentDefId` the server forks the name's active def; `overlay` (a full
+     *  graph) replaces it. Validated server-side ({@link SubstrateToolRefusedError}).
+     *
+     *  The fork's own fields ride in `opts` beside `signal` — the pattern
+     *  {@link LoomcycleClient.setRunBreakpoints} uses — so existing two- and
+     *  three-argument calls are unchanged. `promote: true` puts the new version
+     *  in force in the same call; omitted, it is authored but not active. */
+    forkTeam(name: string, overlay: Record<string, unknown>, opts?: ForkTeamOptions): 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
@@ -1101,6 +1430,9 @@ export declare class LoomcycleClient {
     }, opts?: {
         signal?: AbortSignal;
     }): Promise<TeamRunResult>;
+    runTeam(target: TeamRunTarget, opts?: {
+        signal?: AbortSignal;
+    }): Promise<TeamRunResult | TeamRunDetached>;
     /** Read the debug breakpoints armed on a live team walk
      *  (`GET /v1/runs/{run_id}/breakpoints`), and the review deadline its
      *  member holds get (`review_ttl_seconds`, 0 = none).
@@ -1235,6 +1567,69 @@ export declare class LoomcycleClient {
     history(input: HistoryToolInput, opts?: {
         signal?: AbortSignal;
     }): Promise<HistoryToolResponse>;
+    /** Invoke the Evaluation tool outside a run (`POST /v1/_evaluation`):
+     *  record scores against runs and read them back. Op-discriminated
+     *  (`submit` / `get` / `list_for_run` / `list_for_def` / `aggregate`); the
+     *  return type follows the op. The `*Evaluation*` methods below are the same
+     *  call with positional arguments.
+     *
+     *  What a token may do: `substrate:tenant` every op, inside its own tenant;
+     *  admin every op, in every tenant; any other token (an isolated
+     *  `substrate:user`, a tenant member) `submit_self` only, which a call from
+     *  outside a run cannot use — it is not the run's agent — so each op is
+     *  refused. A token without `runs:read` gets a 403.
+     *
+     *  Another tenant's evaluation or run reads exactly like one that does not
+     *  exist. Raises {@link SubstrateToolRefusedError} on a tool refusal (an
+     *  unknown id, an op the token may not use); {@link InvalidArgumentError}
+     *  on 400; {@link AuthError} on 401. */
+    evaluation(input: EvaluationSubmitInput, opts?: {
+        signal?: AbortSignal;
+    }): Promise<EvaluationSubmitResult>;
+    evaluation(input: EvaluationGetInput, opts?: {
+        signal?: AbortSignal;
+    }): Promise<EvaluationRecord>;
+    evaluation(input: EvaluationListForRunInput, opts?: {
+        signal?: AbortSignal;
+    }): Promise<EvaluationListForRunResult>;
+    evaluation(input: EvaluationListForDefInput, opts?: {
+        signal?: AbortSignal;
+    }): Promise<EvaluationListForDefResult>;
+    evaluation(input: EvaluationAggregateInput, opts?: {
+        signal?: AbortSignal;
+    }): Promise<EvaluationAggregate>;
+    evaluation(input: EvaluationInput, opts?: {
+        signal?: AbortSignal;
+    }): Promise<EvaluationSubmitResult | EvaluationRecord | EvaluationListForRunResult | EvaluationListForDefResult | EvaluationAggregate>;
+    /** Record a score against a run — `evaluation({op:"submit"})`. Scores are
+     *  additive: a second submit records another evaluation. */
+    submitEvaluation(runId: string, score: number, opts?: {
+        dimensions?: Record<string, number>;
+        judgement?: unknown;
+        rationale?: string;
+        signal?: AbortSignal;
+    }): Promise<EvaluationSubmitResult>;
+    /** One evaluation by id — `evaluation({op:"get"})`. */
+    getEvaluation(evalId: string, opts?: {
+        signal?: AbortSignal;
+    }): Promise<EvaluationRecord>;
+    /** Every evaluation of one run — `evaluation({op:"list_for_run"})`. */
+    listEvaluationsForRun(runId: string, opts?: {
+        limit?: number;
+        signal?: AbortSignal;
+    }): Promise<EvaluationListForRunResult>;
+    /** Every evaluation of one definition version, in your tenant —
+     *  `evaluation({op:"list_for_def"})`. */
+    listEvaluationsForDef(defId: string, opts?: {
+        limit?: number;
+        signal?: AbortSignal;
+    }): Promise<EvaluationListForDefResult>;
+    /** A definition's scores rolled up — `evaluation({op:"aggregate"})`.
+     *  `includeLineage` adds the ancestors' evaluations along parent_def_id. */
+    aggregateEvaluations(defId: string, opts?: {
+        includeLineage?: boolean;
+        signal?: AbortSignal;
+    }): Promise<EvaluationAggregate>;
     /** List the PERSISTENT volume universe for the caller's tenant — every
      *  static volume (the shared bind floor, `source: "static"`, read-only)
      *  plus the tenant's own dynamic VolumeDefs (`source: "dynamic"`). Host
@@ -1493,11 +1888,11 @@ export declare class LoomcycleClient {
      *
      *  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
+     *  started a team with `mode: "detach"` 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 });
+     *  const { run_id } = await client.runTeam({ name: "triage", mode: "detach" });
      *  for await (const item of client.streamUserRunStates(userId, { walkId: run_id })) {
      *    if (item.kind === "event") place(item.payload.parent_context?.wave_index);
      *  }
@@ -1514,6 +1909,43 @@ export declare class LoomcycleClient {
      *    "stream re-opened / closed" log entries without inferring
      *    from timing. Default false. */
     streamUserRunStates(userId: string, opts?: StreamUserRunStatesOptions): AsyncIterable<RunStateStreamItem>;
+    /** Tail the caller's tenant's MEMORY change feed (RFC CD Part C) — one
+     *  value-free coordinate per `memory.set` / `memory.delete` /
+     *  `memory.scope_deleted`. Mirrors `GET /v1/_memory/changes?since=<seq>`.
+     *
+     *  The first item is always `{ kind: "feed", payload: ChangeFeedStatus }`,
+     *  then one `{ kind: "change", payload: MemoryChange }` per change, oldest
+     *  first. Pull the current value through the data API; the feed never
+     *  carries it.
+     *
+     *  - The feed is EMPTY unless the server runs with
+     *    `LOOMCYCLE_MEMORY_CHANGES_ENABLED`. The stream still opens and idles,
+     *    so read `payload.enabled` on the feed frame instead of waiting.
+     *  - Scope is the caller's OWN tenant; there is no cross-tenant feed.
+     *  - Needs `substrate:tenant` (or admin). A tenant MEMBER's token is refused
+     *    — the feed exposes the tenant's write pattern, which is operator
+     *    observability, not member data.
+     *  - To resume after a disconnect, persist the last `payload.seq` you
+     *    processed and pass it back as `since`. A cursor older than the
+     *    server's change retention resumes past the pruned gap without saying
+     *    so.
+     *  - A `{ kind: "error", payload: ChangeFeedError }` item means the server
+     *    could not read its change log. It is NOT fatal and iteration
+     *    continues: the server retries with backoff without advancing its
+     *    cursor, so changes resume after recovery with no gap. One item per
+     *    failure streak.
+     *  - The stream has no end of its own: iteration ends when the server
+     *    closes it (shutdown — reconnect with `since`) or throws an
+     *    `AbortError` when `signal` aborts. */
+    streamMemoryChanges(opts?: StreamChangesOptions): AsyncIterable<ChangeFeedFrame>;
+    /** Tail the caller's tenant's DOCUMENT change feed (RFC CD Part C) — one
+     *  coordinate per `document.chunk.updated` / `document.chunk.deleted`,
+     *  naming the `chunk_id`. Mirrors `GET /v1/_document/changes?since=<seq>`.
+     *  Same frames, scope, auth and resume contract as
+     *  {@link LoomcycleClient.streamMemoryChanges}; a reader wanting both
+     *  families opens both. */
+    streamDocumentChanges(opts?: StreamChangesOptions): AsyncIterable<ChangeFeedFrame>;
+    private streamChangeFeed;
     /** List credential METADATA for a scope (RFC AR) — never a secret value.
      *  `user` = your own subject's tokens (per-user, e.g. a personal Telegram bot
      *  token); `tenant` = shared across the tenant (operator authority). RFC CN: a
@@ -1524,11 +1956,43 @@ export declare class LoomcycleClient {
     }): Promise<CredentialListResponse>;
     /** Store or rotate a credential (RFC AR). The plaintext `value` is write-only:
      *  the server encrypts it, masks it from the transcript, and never returns it.
-     *  Returns the stored row's metadata. Mirrors `POST /v1/_credentialdef {op:create}`. */
+     *  Returns the stored row's metadata. Mirrors `POST /v1/_credentialdef {op:create}`.
+     *
+     *  `allowed_urls` restricts where the value may be sent: https URLs, each
+     *  covering itself and everything under it. `[]` stores a value that is
+     *  sent nowhere. Leave it out for no restriction, or, when the credential
+     *  already exists, to keep the list it has. A restricted credential is used
+     *  only where the destination is known and covered (an MCP server's or a
+     *  hook's header, a remote peer's key, a git source), never as a provider
+     *  key.
+     *
+     *  `username` is the user name sent with the value where a destination
+     *  takes one (HTTP basic auth for a git source). Leave it out to keep the
+     *  stored one; `""` removes it.
+     *
+     *  `expires_at` is an RFC3339 timestamp (`"2026-12-31T00:00:00Z"`) stored
+     *  with the credential and reported back in its metadata; any other format
+     *  is refused. `backend` is where the value is kept: `"inline"` (encrypted
+     *  in loomcycle's own store, the default) is the only one accepted. */
     createCredential(input: {
         scope: CredentialScope;
         name: string;
         value: string;
+        allowed_urls?: string[];
+        username?: string;
+        expires_at?: string;
+        backend?: "inline";
+    }, opts?: {
+        signal?: AbortSignal;
+    }): Promise<CredentialMeta>;
+    /** Read ONE credential's metadata (RFC AR) — never its value. Answers
+     *  whether a name is stored, and its `allowed_urls` / `username` /
+     *  `expires_at`, without listing the whole scope. An absent name raises
+     *  {@link SubstrateToolRefusedError}. Mirrors
+     *  `POST /v1/_credentialdef {op:get}`. */
+    getCredential(input: {
+        scope: CredentialScope;
+        name: string;
     }, opts?: {
         signal?: AbortSignal;
     }): Promise<CredentialMeta>;