@loomcycle/client 1.129.0 → 1.133.0

package/README.md

@@ -152,6 +152,29 @@ The low-level primitives (`runStreaming({interactive:true})` + `sendRunInput` +
 | `getConfig(opts?)` | `Promise<ConfigResponse>` | v1.38.0 — instance configuration: build identity, the feature matrix, and the live provider/model/search cascade with `active`/`selected`. `view` names the disclosure level (`public` / `authenticated` / `admin`). Also readable with **no bearer** against a deployment running `LOOMCYCLE_PUBLIC_CONFIG=1`, which serves the narrower `public` view — the landing-page case. |
 | `listUsers()` | `Promise<ListUsersResponse>` | Admin: known users with running-count summary. |
 
+### Ontology subjects
+
+| Method | Returns | Notes |
+|---|---|---|
+| `mergeSubjects(duplicate, survivor, { tenant? })` | `Promise<MergeSubjectsResult>` | Fold one tenant ontology subject into another, each a document id or natural key (`POST /v1/_ontology/subjects/merge`): facts move, statements are copied onto the survivor (originals expired as merged), the duplicate stays retired with `fields.merged_into`, and a user the duplicate is bound to is bound to the survivor. Refusals throw with `code`: `same_subject`, `not_a_subject`, `subject_not_in_scope`, `already_merged`, `principal_conflict`, `forbidden`. |
+| `bindSubjectPrincipal(subject, principal, { tenant? })` | `Promise<BindSubjectPrincipalResult>` | Bind a subject to the user it stands for, or clear it with `principal: ""` (`POST /v1/_ontology/subjects/principal`). The user must be registered in the tenant (any status). Erasing that user then lists the subject in the erasure report's `bound_subjects`, unbinds it and keeps it. Refusals throw with `code`: `subject_not_found`, `not_a_subject`, `binding_conflict`, `principal_not_found`, `forbidden`, `invalid_request`, `unavailable`. |
+
+Both need a tenant operator or admin token; `tenant` is an admin's focus.
+
+### Statement review
+
+| Method | Returns | Notes |
+|---|---|---|
+| `listReviewQueue({ filter?, summarize?, limit?, after?, order?, scope?, scopeId?, tenant? })` | `Promise<ReviewQueueResult>` | The scope's proposed relations, narrowed by `filter` (`method` prefix, `kind(s)`, `actor`, `from_/to_document_id`, `from_/to_under_path`, `min_confidence`, `created_before/after`, `has_judge_verdict`, `judge_verdict`), newest first; `summarize: true` returns counts by kind × method × from-path prefix × judge verdict instead (`GET /v1/_statements/review`). |
+| `ruleStatements(action, { ids } \| { filter }, { reason?, dryRun?, expectCount?, max?, scope?, scopeId?, tenant? })` | `Promise<RuleStatementsResult>` | Accept or reject up to 1000 statements at once (`POST /v1/_statements/rule`). A dry run unless `dryRun: false`; the real call needs `expectCount` = the dry run's `matched` (`queue_changed` otherwise). `reason` is required to reject. Each statement records `ruled_by: bulk:<ruling_id>`. |
+| `revertRuling(rulingId, { scope?, scopeId?, tenant? })` | `Promise<RevertRulingResult>` | Undo a bulk ruling, or a review policy's, where nothing changed the statements since (`POST /v1/_statements/revert`); changed ones are listed and left. Returns `revert_id`. |
+| `listRulings({ limit?, after?, scope?, scopeId?, tenant? })` | `Promise<ListRulingsResult>` | The scope's bulk rulings and reverts, newest first (`GET /v1/_statements/rulings`; limit 20 by default, at most 100): action, who, reason, counts, the selector (filter, or an ids count — never the ids), and `reverted` / `reverted_by`. An operator sees all, a member its own. |
+| `applyReviewPolicy({ filter?, dryRun?, expectCount?, max?, scope?, scopeId?, tenant? })` | `Promise<ApplyReviewPolicyResult>` | Run the tenant's review policy (the ontology's Review section) over the proposals already in the queue (`POST /v1/_statements/apply_policy`). A dry run unless `dryRun: false` (`matched`, `accept` / `reject` / `judge` / `human`, per-rule `rules`, `sample`); the real call needs `expectCount` = the dry run's `matched` and rules at most `max` (1000) accepts and rejects as one ruling, each recording `ruled_by: policy:<rule>@<ontology version>`. An admin or a tenant operator only (`forbidden` for a member). |
+
+The filter also takes the exact selectors `method_exact`, `kind_exact`, `from_path_prefix` and `from_unfiled`, and each summary group carries the `filter` that selects exactly it. Every method takes `scopeId` with `scope: "user"`: an admin or a tenant operator may name another subject of its tenant, a member only itself.
+
+An admin, a tenant operator, or a member holding the access-control action `review` on the statements' from-documents may rule; what the caller may not rule on is skipped and counted. Pass `created_before` / `created_after` as text (RFC 3339, or unix nanoseconds as a decimal string): a nanosecond `created_at` does not fit a JS number. Refusals throw with `code`: `invalid_request`, `forbidden`, `queue_changed`, `ruling_not_found`, `unavailable`.
+
 ### Pause / Resume / State (v0.8.17 / v0.8.18)
 
 | Method | Returns | Notes |

package/dist/cjs/client.js

@@ -685,6 +685,204 @@ class LoomcycleClient {
             : "";
         return (0, fetch_helpers_js_1.postJSON)(this.ctx, `/v1/_erasure${q}`, body, opts);
     }
+    /**
+     * Fold one subject of the tenant ontology (`duplicate`) into another
+     * (`survivor`), each named by its document id or natural key
+     * (`person:ada-lovelace`). Mirrors POST /v1/_ontology/subjects/merge.
+     *
+     * In one transaction the duplicate's facts move under the survivor, every
+     * statement about the duplicate is copied onto the survivor (the original
+     * expired as merged, never deleted), and the duplicate stays as a retired
+     * document recording where it went (`fields.merged_into`, status `merged`).
+     * A `merged` event then goes to the tenant's memory/subjects channel, unless
+     * the caller's access-control rules hide part of the tenant's documents —
+     * `not_announced` then says why. A user the duplicate is bound to is bound to
+     * the survivor instead; a survivor bound to a different user refuses the
+     * merge (`principal_conflict`).
+     *
+     * For an admin or a tenant operator only. `tenant` is honored only for an
+     * admin token. A refusal throws with the server's code: `same_subject`,
+     * `not_a_subject`, `subject_not_in_scope`, `already_merged`,
+     * `principal_conflict`, `forbidden`.
+     */
+    async mergeSubjects(duplicate, survivor, opts) {
+        const q = opts?.tenant !== undefined
+            ? `?tenant=${encodeURIComponent(opts.tenant)}`
+            : "";
+        return (0, fetch_helpers_js_1.postJSON)(this.ctx, `/v1/_ontology/subjects/merge${q}`, { duplicate, survivor }, opts);
+    }
+    /**
+     * Bind a subject of the tenant ontology to the user it stands for, or clear
+     * the binding with `principal: ""`. `subject` is the subject's document id,
+     * root chunk id or natural key; `principal` a user's subject id, registered
+     * in the tenant (any status). Mirrors POST /v1/_ontology/subjects/principal.
+     *
+     * Erasing that user then finds the subject: the erasure reports it, clears
+     * the binding and announces `erased`; the subject itself is never deleted.
+     * One user per subject (clear before rebinding) and one subject per user.
+     *
+     * For an admin or a tenant operator only. `tenant` is honored only for an
+     * admin token. A refusal throws with the server's code: `subject_not_found`,
+     * `not_a_subject`, `binding_conflict` (naming the subject that holds the
+     * binding), `principal_not_found`, `forbidden`, `invalid_request`,
+     * `unavailable`.
+     */
+    async bindSubjectPrincipal(subject, principal, opts) {
+        const q = opts?.tenant !== undefined
+            ? `?tenant=${encodeURIComponent(opts.tenant)}`
+            : "";
+        return (0, fetch_helpers_js_1.postJSON)(this.ctx, `/v1/_ontology/subjects/principal${q}`, { subject, principal }, opts);
+    }
+    /**
+     * The statement review queue: a scope's proposed relations (or another
+     * `filter.status`), narrowed by `filter`, newest first, or with
+     * `summarize: true` their counts by kind, method, from-path prefix and
+     * judge verdict. Rows the caller may not read are left out. Mirrors
+     * GET /v1/_statements/review. `scope` is `tenant` (default) or `user`;
+     * `tenant` is honored only for an admin token. With `scope: "user"`,
+     * `scopeId` names whose user documents: an admin or a tenant operator may
+     * name another subject of its tenant, a member only itself. Each summary
+     * group carries `filter`, which selects exactly that group.
+     */
+    async listReviewQueue(opts) {
+        const params = new URLSearchParams();
+        for (const [k, v] of Object.entries(opts?.filter ?? {})) {
+            if (v === undefined)
+                continue;
+            if (Array.isArray(v))
+                params.set(k, v.join(","));
+            else
+                params.set(k, String(v));
+        }
+        if (opts?.summarize)
+            params.set("summarize", "true");
+        if (opts?.limit !== undefined)
+            params.set("limit", String(opts.limit));
+        if (opts?.after)
+            params.set("after", opts.after);
+        if (opts?.order)
+            params.set("order", opts.order);
+        if (opts?.scope)
+            params.set("scope", opts.scope);
+        if (opts?.scopeId)
+            params.set("scope_id", opts.scopeId);
+        if (opts?.tenant !== undefined)
+            params.set("tenant", opts.tenant);
+        const q = params.toString() ? `?${params.toString()}` : "";
+        return (0, fetch_helpers_js_1.jsonFetch)(this.ctx, `/v1/_statements/review${q}`, opts);
+    }
+    /**
+     * Accept or reject proposed statements in bulk, named by `ids` or by the
+     * queue's `filter`, at most 1000 per call (`max`). A DRY RUN unless
+     * `dryRun: false`: it returns `matched`, a sample of 20 and the kind/method
+     * breakdown. To rule, call again with `dryRun: false` and `expectCount` set
+     * to the dry run's `matched`; a queue that changed in between is refused
+     * (`queue_changed`) and nothing is ruled. `reason` is required to reject.
+     * Each statement is ruled as `accept_statement` / `reject_statement` would,
+     * with a result per statement, and records `ruled_by: bulk:<ruling_id>`.
+     * Mirrors POST /v1/_statements/rule.
+     *
+     * For an admin or a tenant operator (write on each from-document), or a
+     * member holding the access-control action `review` on the from-document's
+     * path; what the caller may not rule on is skipped and counted. A refusal
+     * throws with the server's code: `invalid_request`, `forbidden`,
+     * `queue_changed`, `unavailable`.
+     */
+    async ruleStatements(action, select, opts) {
+        const body = { action, ...select };
+        if (opts?.reason !== undefined)
+            body.reason = opts.reason;
+        if (opts?.dryRun !== undefined)
+            body.dry_run = opts.dryRun;
+        if (opts?.expectCount !== undefined)
+            body.expect_count = opts.expectCount;
+        if (opts?.max !== undefined)
+            body.max = opts.max;
+        if (opts?.scope !== undefined)
+            body.scope = opts.scope;
+        if (opts?.scopeId !== undefined)
+            body.scope_id = opts.scopeId;
+        if (opts?.tenant !== undefined)
+            body.tenant = opts.tenant;
+        return (0, fetch_helpers_js_1.postJSON)(this.ctx, "/v1/_statements/rule", body, opts);
+    }
+    /**
+     * Undo a bulk ruling: each statement it ruled goes back to its status
+     * before, if nothing changed it since (no new evidence, no maintenance, no
+     * later ruling); a rejected one is no longer refused when proposed again.
+     * Changed ones are listed and left. Same authority as
+     * {@link ruleStatements}. Mirrors POST /v1/_statements/revert; an unknown
+     * ruling throws `ruling_not_found`.
+     */
+    async revertRuling(rulingId, opts) {
+        const body = { ruling_id: rulingId };
+        if (opts?.scope !== undefined)
+            body.scope = opts.scope;
+        if (opts?.scopeId !== undefined)
+            body.scope_id = opts.scopeId;
+        if (opts?.tenant !== undefined)
+            body.tenant = opts.tenant;
+        return (0, fetch_helpers_js_1.postJSON)(this.ctx, "/v1/_statements/revert", body, opts);
+    }
+    /**
+     * The scope's bulk rulings and their reverts, newest first (`limit`
+     * default 20, at most 100; `after` = the previous page's `next_cursor`),
+     * so an undo can be found after the ruling's own answer is gone. An
+     * operator sees every ruling, a member only its own; each names what it
+     * selected as the filter or a count of ids, never the ids. Mirrors
+     * GET /v1/_statements/rulings.
+     */
+    async listRulings(opts) {
+        const params = new URLSearchParams();
+        if (opts?.limit !== undefined)
+            params.set("limit", String(opts.limit));
+        if (opts?.after)
+            params.set("after", opts.after);
+        if (opts?.scope)
+            params.set("scope", opts.scope);
+        if (opts?.scopeId)
+            params.set("scope_id", opts.scopeId);
+        if (opts?.tenant !== undefined)
+            params.set("tenant", opts.tenant);
+        const q = params.toString() ? `?${params.toString()}` : "";
+        return (0, fetch_helpers_js_1.jsonFetch)(this.ctx, `/v1/_statements/rulings${q}`, opts);
+    }
+    /**
+     * Run the tenant's review policy (the ontology's Review section, or the
+     * policy `@auto_assert` implies) over the proposals already in the queue,
+     * narrowed by `filter` (its status, if any, must be `proposed`). A DRY RUN
+     * unless `dryRun: false`: it returns `matched`, what the policy would
+     * accept, reject, route to the judge or leave for a person, the count per
+     * rule and a sample. To apply, call again with `dryRun: false` and
+     * `expectCount` set to the dry run's `matched`: at most `max` (default and
+     * ceiling 1000) accepts and rejects are ruled as one ruling —
+     * {@link revertRuling} undoes it — each statement recording
+     * `ruled_by: policy:<rule>@<ontology version>`; the rest are `deferred`.
+     * Mirrors POST /v1/_statements/apply_policy.
+     *
+     * For an admin or a tenant operator only: a member is refused
+     * (`forbidden`) even holding `review`. A refusal throws with the server's
+     * code: `invalid_request` (no policy in force, or the Review section has
+     * issues), `forbidden`, `queue_changed`, `unavailable`.
+     */
+    async applyReviewPolicy(opts) {
+        const body = {};
+        if (opts?.filter !== undefined)
+            body.filter = opts.filter;
+        if (opts?.dryRun !== undefined)
+            body.dry_run = opts.dryRun;
+        if (opts?.expectCount !== undefined)
+            body.expect_count = opts.expectCount;
+        if (opts?.max !== undefined)
+            body.max = opts.max;
+        if (opts?.scope !== undefined)
+            body.scope = opts.scope;
+        if (opts?.scopeId !== undefined)
+            body.scope_id = opts.scopeId;
+        if (opts?.tenant !== undefined)
+            body.tenant = opts.tenant;
+        return (0, fetch_helpers_js_1.postJSON)(this.ctx, "/v1/_statements/apply_policy", body, opts);
+    }
     async compactRun(runId, opts) {
         const body = {};
         if (opts?.reason !== undefined)

package/dist/client.d.ts

@@ -26,7 +26,7 @@
 import { InteractiveSession } from "./interactive.js";
 import { LoomcycleOAuth } from "./oauth.js";
 import { ClientToolHost, type ConnectClientToolsOptions } from "./client-tools.js";
-import type { ChangeFeedFrame, StreamChangesOptions, CredentialListResponse, CredentialMeta, CryptoKeyEncoding, CryptoKeyExport, CryptoKeyExternal, CryptoKeyType, CryptoRequest, CryptoResultByOp, DecideRequest, DecideResponse, DecisionModelsResponse, CredentialScope, DirectoryInspection, DirectoryTenant, DirectoryUser, ErasureReport, ErasureResult, Agent, AgentEvent, AgentList, CancelAgentResult, ClientOptions, ContinueOptions, RunOverrideOptions, EffectiveConfigResponse, RunFileInput, RunInboxDownload, 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, UserIdentitiesResponse, AuthGateListResponse, CreateInviteBody, CreatedInvite, AuthInviteListResponse, CreatedPasswordReset, GateIdentitiesResponse, GateTenantStatus, 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, UsageBucket, UsageReportResponse, TokenLimit, TokenLimitsResponse, ConfigResponse, SetTokenLimitRequest, AclBinding, AclBindingListResponse, AclCatalog, AclDefInput, AclDefListResponse, AclDefNamesResponse, AclDefRow, AclRule, AclValidateResult, AuthzDecision, AuthzEvaluationRequest, AuthzEvaluationsRequest, AuthzEvaluationsResponse, AuthzExplainResponse, AuthzSimulateRequest, AuthzSimulateResponse, CreateAclBindingBody, CreateGroupBody, GroupDetail, GroupEffective, GroupListResponse, GroupMemberChange, GroupMemberKind, GroupRow, AppClientConfig, AppClientEntry, ClientDefInput, ClientDefListResponse, ClientDefNamesResponse, ClientDefRecord, ClientDefRetireResult, ClientDefVerifyResult, DeviceLoginOptions, DeviceLoginResult } from "./types.js";
+import type { ChangeFeedFrame, StreamChangesOptions, CredentialListResponse, CredentialMeta, CryptoKeyEncoding, CryptoKeyExport, CryptoKeyExternal, CryptoKeyType, CryptoRequest, CryptoResultByOp, DecideRequest, DecideResponse, DecisionModelsResponse, CredentialScope, DirectoryInspection, DirectoryTenant, DirectoryUser, ErasureReport, ErasureResult, MergeSubjectsResult, ReviewQueueFilter, ReviewQueueResult, RuleStatementsResult, RevertRulingResult, ListRulingsResult, ApplyReviewPolicyResult, BindSubjectPrincipalResult, Agent, AgentEvent, AgentList, CancelAgentResult, ClientOptions, ContinueOptions, RunOverrideOptions, EffectiveConfigResponse, RunFileInput, RunInboxDownload, 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, UserIdentitiesResponse, AuthGateListResponse, CreateInviteBody, CreatedInvite, AuthInviteListResponse, CreatedPasswordReset, GateIdentitiesResponse, GateTenantStatus, 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, UsageBucket, UsageReportResponse, TokenLimit, TokenLimitsResponse, ConfigResponse, SetTokenLimitRequest, AclBinding, AclBindingListResponse, AclCatalog, AclDefInput, AclDefListResponse, AclDefNamesResponse, AclDefRow, AclRule, AclValidateResult, AuthzDecision, AuthzEvaluationRequest, AuthzEvaluationsRequest, AuthzEvaluationsResponse, AuthzExplainResponse, AuthzSimulateRequest, AuthzSimulateResponse, CreateAclBindingBody, CreateGroupBody, GroupDetail, GroupEffective, GroupListResponse, GroupMemberChange, GroupMemberKind, GroupRow, AppClientConfig, AppClientEntry, ClientDefInput, ClientDefListResponse, ClientDefNamesResponse, ClientDefRecord, ClientDefRetireResult, ClientDefVerifyResult, DeviceLoginOptions, DeviceLoginResult } from "./types.js";
 export declare class LoomcycleClient {
     private ctx;
     private readonly tokenProvider?;
@@ -362,6 +362,161 @@ export declare class LoomcycleClient {
         tenant?: string;
         signal?: AbortSignal;
     }): Promise<ErasureResult>;
+    /**
+     * Fold one subject of the tenant ontology (`duplicate`) into another
+     * (`survivor`), each named by its document id or natural key
+     * (`person:ada-lovelace`). Mirrors POST /v1/_ontology/subjects/merge.
+     *
+     * In one transaction the duplicate's facts move under the survivor, every
+     * statement about the duplicate is copied onto the survivor (the original
+     * expired as merged, never deleted), and the duplicate stays as a retired
+     * document recording where it went (`fields.merged_into`, status `merged`).
+     * A `merged` event then goes to the tenant's memory/subjects channel, unless
+     * the caller's access-control rules hide part of the tenant's documents —
+     * `not_announced` then says why. A user the duplicate is bound to is bound to
+     * the survivor instead; a survivor bound to a different user refuses the
+     * merge (`principal_conflict`).
+     *
+     * For an admin or a tenant operator only. `tenant` is honored only for an
+     * admin token. A refusal throws with the server's code: `same_subject`,
+     * `not_a_subject`, `subject_not_in_scope`, `already_merged`,
+     * `principal_conflict`, `forbidden`.
+     */
+    mergeSubjects(duplicate: string, survivor: string, opts?: {
+        tenant?: string;
+        signal?: AbortSignal;
+    }): Promise<MergeSubjectsResult>;
+    /**
+     * Bind a subject of the tenant ontology to the user it stands for, or clear
+     * the binding with `principal: ""`. `subject` is the subject's document id,
+     * root chunk id or natural key; `principal` a user's subject id, registered
+     * in the tenant (any status). Mirrors POST /v1/_ontology/subjects/principal.
+     *
+     * Erasing that user then finds the subject: the erasure reports it, clears
+     * the binding and announces `erased`; the subject itself is never deleted.
+     * One user per subject (clear before rebinding) and one subject per user.
+     *
+     * For an admin or a tenant operator only. `tenant` is honored only for an
+     * admin token. A refusal throws with the server's code: `subject_not_found`,
+     * `not_a_subject`, `binding_conflict` (naming the subject that holds the
+     * binding), `principal_not_found`, `forbidden`, `invalid_request`,
+     * `unavailable`.
+     */
+    bindSubjectPrincipal(subject: string, principal: string, opts?: {
+        tenant?: string;
+        signal?: AbortSignal;
+    }): Promise<BindSubjectPrincipalResult>;
+    /**
+     * The statement review queue: a scope's proposed relations (or another
+     * `filter.status`), narrowed by `filter`, newest first, or with
+     * `summarize: true` their counts by kind, method, from-path prefix and
+     * judge verdict. Rows the caller may not read are left out. Mirrors
+     * GET /v1/_statements/review. `scope` is `tenant` (default) or `user`;
+     * `tenant` is honored only for an admin token. With `scope: "user"`,
+     * `scopeId` names whose user documents: an admin or a tenant operator may
+     * name another subject of its tenant, a member only itself. Each summary
+     * group carries `filter`, which selects exactly that group.
+     */
+    listReviewQueue(opts?: {
+        filter?: ReviewQueueFilter;
+        summarize?: boolean;
+        limit?: number;
+        after?: string;
+        order?: "created" | "verified";
+        scope?: "tenant" | "user";
+        scopeId?: string;
+        tenant?: string;
+        signal?: AbortSignal;
+    }): Promise<ReviewQueueResult>;
+    /**
+     * Accept or reject proposed statements in bulk, named by `ids` or by the
+     * queue's `filter`, at most 1000 per call (`max`). A DRY RUN unless
+     * `dryRun: false`: it returns `matched`, a sample of 20 and the kind/method
+     * breakdown. To rule, call again with `dryRun: false` and `expectCount` set
+     * to the dry run's `matched`; a queue that changed in between is refused
+     * (`queue_changed`) and nothing is ruled. `reason` is required to reject.
+     * Each statement is ruled as `accept_statement` / `reject_statement` would,
+     * with a result per statement, and records `ruled_by: bulk:<ruling_id>`.
+     * Mirrors POST /v1/_statements/rule.
+     *
+     * For an admin or a tenant operator (write on each from-document), or a
+     * member holding the access-control action `review` on the from-document's
+     * path; what the caller may not rule on is skipped and counted. A refusal
+     * throws with the server's code: `invalid_request`, `forbidden`,
+     * `queue_changed`, `unavailable`.
+     */
+    ruleStatements(action: "accept" | "reject", select: {
+        ids: string[];
+    } | {
+        filter: ReviewQueueFilter;
+    }, opts?: {
+        reason?: string;
+        dryRun?: boolean;
+        expectCount?: number;
+        max?: number;
+        scope?: "tenant" | "user";
+        scopeId?: string;
+        tenant?: string;
+        signal?: AbortSignal;
+    }): Promise<RuleStatementsResult>;
+    /**
+     * Undo a bulk ruling: each statement it ruled goes back to its status
+     * before, if nothing changed it since (no new evidence, no maintenance, no
+     * later ruling); a rejected one is no longer refused when proposed again.
+     * Changed ones are listed and left. Same authority as
+     * {@link ruleStatements}. Mirrors POST /v1/_statements/revert; an unknown
+     * ruling throws `ruling_not_found`.
+     */
+    revertRuling(rulingId: string, opts?: {
+        scope?: "tenant" | "user";
+        scopeId?: string;
+        tenant?: string;
+        signal?: AbortSignal;
+    }): Promise<RevertRulingResult>;
+    /**
+     * The scope's bulk rulings and their reverts, newest first (`limit`
+     * default 20, at most 100; `after` = the previous page's `next_cursor`),
+     * so an undo can be found after the ruling's own answer is gone. An
+     * operator sees every ruling, a member only its own; each names what it
+     * selected as the filter or a count of ids, never the ids. Mirrors
+     * GET /v1/_statements/rulings.
+     */
+    listRulings(opts?: {
+        limit?: number;
+        after?: string;
+        scope?: "tenant" | "user";
+        scopeId?: string;
+        tenant?: string;
+        signal?: AbortSignal;
+    }): Promise<ListRulingsResult>;
+    /**
+     * Run the tenant's review policy (the ontology's Review section, or the
+     * policy `@auto_assert` implies) over the proposals already in the queue,
+     * narrowed by `filter` (its status, if any, must be `proposed`). A DRY RUN
+     * unless `dryRun: false`: it returns `matched`, what the policy would
+     * accept, reject, route to the judge or leave for a person, the count per
+     * rule and a sample. To apply, call again with `dryRun: false` and
+     * `expectCount` set to the dry run's `matched`: at most `max` (default and
+     * ceiling 1000) accepts and rejects are ruled as one ruling —
+     * {@link revertRuling} undoes it — each statement recording
+     * `ruled_by: policy:<rule>@<ontology version>`; the rest are `deferred`.
+     * Mirrors POST /v1/_statements/apply_policy.
+     *
+     * For an admin or a tenant operator only: a member is refused
+     * (`forbidden`) even holding `review`. A refusal throws with the server's
+     * code: `invalid_request` (no policy in force, or the Review section has
+     * issues), `forbidden`, `queue_changed`, `unavailable`.
+     */
+    applyReviewPolicy(opts?: {
+        filter?: ReviewQueueFilter;
+        dryRun?: boolean;
+        expectCount?: number;
+        max?: number;
+        scope?: "tenant" | "user";
+        scopeId?: string;
+        tenant?: string;
+        signal?: AbortSignal;
+    }): Promise<ApplyReviewPolicyResult>;
     compactRun(runId: string, opts?: {
         reason?: string;
         signal?: AbortSignal;

package/dist/client.js

@@ -682,6 +682,204 @@ export class LoomcycleClient {
             : "";
         return postJSON(this.ctx, `/v1/_erasure${q}`, body, opts);
     }
+    /**
+     * Fold one subject of the tenant ontology (`duplicate`) into another
+     * (`survivor`), each named by its document id or natural key
+     * (`person:ada-lovelace`). Mirrors POST /v1/_ontology/subjects/merge.
+     *
+     * In one transaction the duplicate's facts move under the survivor, every
+     * statement about the duplicate is copied onto the survivor (the original
+     * expired as merged, never deleted), and the duplicate stays as a retired
+     * document recording where it went (`fields.merged_into`, status `merged`).
+     * A `merged` event then goes to the tenant's memory/subjects channel, unless
+     * the caller's access-control rules hide part of the tenant's documents —
+     * `not_announced` then says why. A user the duplicate is bound to is bound to
+     * the survivor instead; a survivor bound to a different user refuses the
+     * merge (`principal_conflict`).
+     *
+     * For an admin or a tenant operator only. `tenant` is honored only for an
+     * admin token. A refusal throws with the server's code: `same_subject`,
+     * `not_a_subject`, `subject_not_in_scope`, `already_merged`,
+     * `principal_conflict`, `forbidden`.
+     */
+    async mergeSubjects(duplicate, survivor, opts) {
+        const q = opts?.tenant !== undefined
+            ? `?tenant=${encodeURIComponent(opts.tenant)}`
+            : "";
+        return postJSON(this.ctx, `/v1/_ontology/subjects/merge${q}`, { duplicate, survivor }, opts);
+    }
+    /**
+     * Bind a subject of the tenant ontology to the user it stands for, or clear
+     * the binding with `principal: ""`. `subject` is the subject's document id,
+     * root chunk id or natural key; `principal` a user's subject id, registered
+     * in the tenant (any status). Mirrors POST /v1/_ontology/subjects/principal.
+     *
+     * Erasing that user then finds the subject: the erasure reports it, clears
+     * the binding and announces `erased`; the subject itself is never deleted.
+     * One user per subject (clear before rebinding) and one subject per user.
+     *
+     * For an admin or a tenant operator only. `tenant` is honored only for an
+     * admin token. A refusal throws with the server's code: `subject_not_found`,
+     * `not_a_subject`, `binding_conflict` (naming the subject that holds the
+     * binding), `principal_not_found`, `forbidden`, `invalid_request`,
+     * `unavailable`.
+     */
+    async bindSubjectPrincipal(subject, principal, opts) {
+        const q = opts?.tenant !== undefined
+            ? `?tenant=${encodeURIComponent(opts.tenant)}`
+            : "";
+        return postJSON(this.ctx, `/v1/_ontology/subjects/principal${q}`, { subject, principal }, opts);
+    }
+    /**
+     * The statement review queue: a scope's proposed relations (or another
+     * `filter.status`), narrowed by `filter`, newest first, or with
+     * `summarize: true` their counts by kind, method, from-path prefix and
+     * judge verdict. Rows the caller may not read are left out. Mirrors
+     * GET /v1/_statements/review. `scope` is `tenant` (default) or `user`;
+     * `tenant` is honored only for an admin token. With `scope: "user"`,
+     * `scopeId` names whose user documents: an admin or a tenant operator may
+     * name another subject of its tenant, a member only itself. Each summary
+     * group carries `filter`, which selects exactly that group.
+     */
+    async listReviewQueue(opts) {
+        const params = new URLSearchParams();
+        for (const [k, v] of Object.entries(opts?.filter ?? {})) {
+            if (v === undefined)
+                continue;
+            if (Array.isArray(v))
+                params.set(k, v.join(","));
+            else
+                params.set(k, String(v));
+        }
+        if (opts?.summarize)
+            params.set("summarize", "true");
+        if (opts?.limit !== undefined)
+            params.set("limit", String(opts.limit));
+        if (opts?.after)
+            params.set("after", opts.after);
+        if (opts?.order)
+            params.set("order", opts.order);
+        if (opts?.scope)
+            params.set("scope", opts.scope);
+        if (opts?.scopeId)
+            params.set("scope_id", opts.scopeId);
+        if (opts?.tenant !== undefined)
+            params.set("tenant", opts.tenant);
+        const q = params.toString() ? `?${params.toString()}` : "";
+        return jsonFetch(this.ctx, `/v1/_statements/review${q}`, opts);
+    }
+    /**
+     * Accept or reject proposed statements in bulk, named by `ids` or by the
+     * queue's `filter`, at most 1000 per call (`max`). A DRY RUN unless
+     * `dryRun: false`: it returns `matched`, a sample of 20 and the kind/method
+     * breakdown. To rule, call again with `dryRun: false` and `expectCount` set
+     * to the dry run's `matched`; a queue that changed in between is refused
+     * (`queue_changed`) and nothing is ruled. `reason` is required to reject.
+     * Each statement is ruled as `accept_statement` / `reject_statement` would,
+     * with a result per statement, and records `ruled_by: bulk:<ruling_id>`.
+     * Mirrors POST /v1/_statements/rule.
+     *
+     * For an admin or a tenant operator (write on each from-document), or a
+     * member holding the access-control action `review` on the from-document's
+     * path; what the caller may not rule on is skipped and counted. A refusal
+     * throws with the server's code: `invalid_request`, `forbidden`,
+     * `queue_changed`, `unavailable`.
+     */
+    async ruleStatements(action, select, opts) {
+        const body = { action, ...select };
+        if (opts?.reason !== undefined)
+            body.reason = opts.reason;
+        if (opts?.dryRun !== undefined)
+            body.dry_run = opts.dryRun;
+        if (opts?.expectCount !== undefined)
+            body.expect_count = opts.expectCount;
+        if (opts?.max !== undefined)
+            body.max = opts.max;
+        if (opts?.scope !== undefined)
+            body.scope = opts.scope;
+        if (opts?.scopeId !== undefined)
+            body.scope_id = opts.scopeId;
+        if (opts?.tenant !== undefined)
+            body.tenant = opts.tenant;
+        return postJSON(this.ctx, "/v1/_statements/rule", body, opts);
+    }
+    /**
+     * Undo a bulk ruling: each statement it ruled goes back to its status
+     * before, if nothing changed it since (no new evidence, no maintenance, no
+     * later ruling); a rejected one is no longer refused when proposed again.
+     * Changed ones are listed and left. Same authority as
+     * {@link ruleStatements}. Mirrors POST /v1/_statements/revert; an unknown
+     * ruling throws `ruling_not_found`.
+     */
+    async revertRuling(rulingId, opts) {
+        const body = { ruling_id: rulingId };
+        if (opts?.scope !== undefined)
+            body.scope = opts.scope;
+        if (opts?.scopeId !== undefined)
+            body.scope_id = opts.scopeId;
+        if (opts?.tenant !== undefined)
+            body.tenant = opts.tenant;
+        return postJSON(this.ctx, "/v1/_statements/revert", body, opts);
+    }
+    /**
+     * The scope's bulk rulings and their reverts, newest first (`limit`
+     * default 20, at most 100; `after` = the previous page's `next_cursor`),
+     * so an undo can be found after the ruling's own answer is gone. An
+     * operator sees every ruling, a member only its own; each names what it
+     * selected as the filter or a count of ids, never the ids. Mirrors
+     * GET /v1/_statements/rulings.
+     */
+    async listRulings(opts) {
+        const params = new URLSearchParams();
+        if (opts?.limit !== undefined)
+            params.set("limit", String(opts.limit));
+        if (opts?.after)
+            params.set("after", opts.after);
+        if (opts?.scope)
+            params.set("scope", opts.scope);
+        if (opts?.scopeId)
+            params.set("scope_id", opts.scopeId);
+        if (opts?.tenant !== undefined)
+            params.set("tenant", opts.tenant);
+        const q = params.toString() ? `?${params.toString()}` : "";
+        return jsonFetch(this.ctx, `/v1/_statements/rulings${q}`, opts);
+    }
+    /**
+     * Run the tenant's review policy (the ontology's Review section, or the
+     * policy `@auto_assert` implies) over the proposals already in the queue,
+     * narrowed by `filter` (its status, if any, must be `proposed`). A DRY RUN
+     * unless `dryRun: false`: it returns `matched`, what the policy would
+     * accept, reject, route to the judge or leave for a person, the count per
+     * rule and a sample. To apply, call again with `dryRun: false` and
+     * `expectCount` set to the dry run's `matched`: at most `max` (default and
+     * ceiling 1000) accepts and rejects are ruled as one ruling —
+     * {@link revertRuling} undoes it — each statement recording
+     * `ruled_by: policy:<rule>@<ontology version>`; the rest are `deferred`.
+     * Mirrors POST /v1/_statements/apply_policy.
+     *
+     * For an admin or a tenant operator only: a member is refused
+     * (`forbidden`) even holding `review`. A refusal throws with the server's
+     * code: `invalid_request` (no policy in force, or the Review section has
+     * issues), `forbidden`, `queue_changed`, `unavailable`.
+     */
+    async applyReviewPolicy(opts) {
+        const body = {};
+        if (opts?.filter !== undefined)
+            body.filter = opts.filter;
+        if (opts?.dryRun !== undefined)
+            body.dry_run = opts.dryRun;
+        if (opts?.expectCount !== undefined)
+            body.expect_count = opts.expectCount;
+        if (opts?.max !== undefined)
+            body.max = opts.max;
+        if (opts?.scope !== undefined)
+            body.scope = opts.scope;
+        if (opts?.scopeId !== undefined)
+            body.scope_id = opts.scopeId;
+        if (opts?.tenant !== undefined)
+            body.tenant = opts.tenant;
+        return postJSON(this.ctx, "/v1/_statements/apply_policy", body, opts);
+    }
     async compactRun(runId, opts) {
         const body = {};
         if (opts?.reason !== undefined)

package/dist/index.d.ts

@@ -216,5 +216,5 @@ export { ClientToolHost, clientToolsURL, CLIENT_TOOL_SUBPROTOCOL } from "./clien
 export type { ClientToolSchema, ClientToolInvocation, ConnectClientToolsOptions, WebSocketLike, WebSocketCtor, } from "./client-tools.js";
 export { LoomcycleOAuth, OAuthTokenProvider, parseAuthorizeResponse, pkceChallenge } from "./oauth.js";
 export type { LoomcycleOAuthOptions, OAuthTokenProviderOptions } from "./oauth.js";
-export type { AgentEvent, ClientOptions, ContinueOptions, EventType, HostWidening, ImageMediaType, ParentContext, PromptContent, PromptSegment, RetryInfo, RunOptions, RunOverrideOptions, SamplingOptions, CompactionOptions, ContextOptions, ToolUse, Usage, CallTiming, Agent, AgentStatus, AwaitedState, AgentUsage, RunResult, RunSpec, RunSpecTeam, ConfiguredRun, ConfiguredRunPatch, ToolChoiceOptions, OutputFormatOptions, CancelAgentResult, ListAgentsResponse, ListUserAgentsOptions, AgentList, WalkRunsPage, RunBatchOptions, RunBatchResult, SpawnRunResult, CompactRunResult, RunTreeDeletion, RunTreeNotReached, DirectoryBudget, DirectoryInspection, DirectoryTenant, DirectoryUser, ErasureAccess, ErasureReport, ErasureResidue, ErasureResult, ErasureTier, ErasureTokenRef, CancelTurnResult, ReviewRunResult, ReplaySessionResult, TranscriptEvent, TranscriptResponse, HealthResponse, ListUsersResponse, UserSummary, UserStatus, UserRecord, CreateUserBody, UpdateUserBody, MintedUserToken, TokenRestrictions, UserTokenMeta, ListUserTokensResponse, UserIdentity, UserIdentitiesResponse, AuthGateKind, AuthGate, AuthGateKey, AuthGateRemoval, AuthGateProbe, AuthGateListResponse, CreateInviteBody, CreatedInvite, AuthInviteState, AuthInvite, AuthInviteListResponse, CreatedPasswordReset, GateIdentity, GateIdentitiesResponse, GateTenantStatus, RunnableAgent, RunnableAgentsResponse, WhoamiResponse, WhoamiEffective, WhoamiAuth, PauseResult, RetentionOverride, ResumeResult, RuntimeStateResponse, RuntimeStateStatus, ResolverMatrix, ResolverModelStatus, ResolverProviderAvailability, CreateSnapshotOptions, SnapshotCreateResponse, SnapshotDescriptor, SnapshotEnvelope, SnapshotListResponse, SnapshotRestoreResponse, MemoryEntriesResponse, MemoryEntry, MemoryEntryResponse, MemoryScopeIDsResponse, MemoryScopeIDSummary, MemoryScopeKind, MemoryScopesResponse, MemorySearchDocumentFilter, MemorySearchInput, MemorySource, MemoryWhen, MemoryTimeFilter, MemorySearchEntry, MemorySearchResponse, MemoryEmbedModelStats, MemoryEmbedStatsResponse, MemoryReembedConfigured, MemoryReembedResponse, MemoryBackfillResponse, MemoryPurgeResponse, InterruptListResponse, InterruptRow, InterruptStatus, ResolveInterruptOptions, ChannelHookCall, ChannelHookResult, HookFailMode, HookPhase, HookToolCall, HookToolResult, PostHookCall, PostHookResult, PreHookCall, PreHookResult, SubstrateToolInput, SubstrateToolResponse, TeamNameSummary, ListTeamsResponse, TeamDiagram, CreatedTeam, PromotedTeam, RetiredTeam, TeamDefDetail, TeamVerification, TeamDraft, TeamDraftVerification, TeamIssue, TeamIssueKind, TeamVersion, TeamVersionList, TeamBreakpoints, TeamRunDetached, TeamRunResult, TeamRunTarget, CreateTeamOptions, ForkTeamOptions, DefNameSummary, DefNamesResponse, OperatorTokenDefNameSummary, OperatorTokenDefNamesResponse, ScheduleListEntry, ScheduleListResponse, ScheduleActiveRun, ScheduleStateView, ScheduleRunNowResult, SchedulePauseResult, ModelAlias, ModelAliasesResponse, RoutingResponse, RoutingUserTier, RoutingTier, RoutingCandidate, RoutingThroughput, RoutingProvider, SearchRoutingProvider, RoutingEmbedder, RoutingDecision, RoutingDecisionModel, ProviderModelsResponse, TeamRunStep, TeamDecisionHandler, TeamDecisionQuestion, TeamDecisionAnswer, PathToolInput, PathToolResponse, DocumentToolInput, DocumentEdgeEvidence, DocumentToolResponse, DocumentSearchFilter, DocumentSearchHit, DocumentSearchResult, DocumentRelatedResult, HistoryToolInput, HistoryToolResponse, EvaluationEmitterRole, EvaluationSubmitInput, EvaluationGetInput, EvaluationListForRunInput, EvaluationListForDefInput, EvaluationAggregateInput, EvaluationInput, EvaluationSubmitResult, EvaluationRecord, EvaluationListForRunResult, EvaluationListForDefResult, EvaluationScoreStats, EvaluationAggregate, VolumeMode, PersistentVolumeEntry, PersistentVolumesResponse, EphemeralVolumeEntry, EphemeralVolumesResponse, SystemPromptPayload, UserInputPayload, ChannelDescriptor, ListChannelsResponse, RunStateEvent, RunStateStreamClose, RunStateStreamItem, RunStateStreamOpen, StreamUserRunStatesOptions, ChangeFeedError, ChangeFeedFrame, ChangeFeedStatus, EmbedderHealth, MemoryChange, MemoryChangeScope, MemoryChangeType, StreamChangesOptions, AckChannelOptions, ChannelAckResult, ChannelMessageItem, ChannelPeekResult, ListTeamChannelsOptions, PeekTeamChannelOptions, ReleaseTeamChannelOptions, TeamChannelReleaseResult, TeamChannelDeclaredIn, TeamChannelDescriptor, TeamChannelPeekResult, TeamChannelsResult, 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, AgentRouting, AgentChannelACL, AgentInterruptionACL, AgentDecision, MemoryRerank, AgentSampling, AgentCompaction, AgentTranscription, AgentSpeech, AgentContext, TierCandidate, CoreBlock, HookEvent, InlineWebhook, HookEntry, EventHooks, ToolEntry, ToolHooksByTool, EnsureCodeAgentOptions, EnsureCodeAgentResult, CreateDefOptions, ForkDefOptions, EnsureHookDefOptions, EnsureHookDefResult, HookDefBody, HookDefForkOverlay, HookDefInput, HookDefMatch, HookDefOverlay, HookDefRowResponse, HookDefVerifyResult, ScheduleDefInput, ScheduleDefOverlay, ScheduleDefRowResponse, ScheduledRunHook, ScheduledRunPromptContent, ScheduledRunPromptSegment, WebhookDefAuth, WebhookDefFilter, WebhookDefInput, WebhookDefOverlay, WebhookDefRateLimit, WebhookDefRowResponse, WebhookDefDeliveries, WebhookDefSyncResponse, LibraryAgentDefinition, LibraryEntry, LibraryListResponse, LibraryMcpServerDefinition, LibrarySkillDefinition, LLMChatContent, LLMChatMessage, LLMChatOptions, LLMChatResponse, LLMChatStreamDelta, LLMChatStreamItem, LLMChatToolCall, LLMChatUsage, LLMTool, LLMEmbeddingItem, LLMEmbeddingsOptions, LLMEmbeddingsResponse, LLMEmbeddingsUsage, UsageDimension, UsageBucket, UsageAggregate, UsageReportResponse, CapabilityInertInfo, LimitInfo, FileCapturedInfo, TranscriptionInfo, AdmissionInfo, ErrorInfo, CallFormat, CallRef, HookDecisionInfo, TeamDecisionInfo, OverrideInfo, FallbackInfo, InterruptionEventInfo, SpawnChildInfo, TurnCancelledInfo, ChannelEventInfo, ContextCompactionInfo, ContextRecapInfo, ContextStateInfo, ContextExhaustedInfo, ContextTierVerdict, ContextDistillDeclinedInfo, EffectiveConfigResponse, RunFileInput, RunFileImportSource, RunFileImportHeading, RunInboxDownload, EffectiveConfigSource, EffectiveValue, InertContextSetting, AgentOverridableResponse, OverridableField, OverrideLockReason, RetuneRunResponse, RunConfigRecord, SubagentHoldInfo, RunConfigResponse, RunPromptResponse, RunPromptSnapshot, PromptBlock, TokenLimit, TokenLimitsResponse, ConfigResponse, ConfigProvider, ConfigModel, ConfigSearch, ConfigInstance, SetTokenLimitRequest, CredentialScope, CredentialMeta, CredentialListResponse, CryptoKeyVersion, CryptoKeyExport, CryptoKeyType, CryptoKeyEncoding, CryptoKeyBackend, CryptoKeyExternal, CryptoOp, CryptoRequestBase, CryptoKeyRef, CryptoEncryptRequest, CryptoDecryptRequest, CryptoRewrapRequest, CryptoMacRequest, CryptoVerifyMacRequest, CryptoSignRequest, CryptoVerifyRequest, CryptoPublicKeyRequest, CryptoTotpRequest, CryptoHashRequest, CryptoRandomRequest, CryptoHashPasswordRequest, CryptoVerifyPasswordRequest, CryptoRequest, CryptoEncryptResult, CryptoDecryptResult, CryptoRewrapResult, CryptoMacResult, CryptoVerifyResult, CryptoSignResult, CryptoPublicJWK, CryptoPublicKeyResult, CryptoTotpResult, CryptoHashResult, CryptoRandomResult, CryptoHashPasswordResult, CryptoVerifyPasswordResult, CryptoResultByOp, CryptoResult, DecideRequest, DecideResponse, DecisionQuestion, DecisionChoiceQuestion, DecisionNoulQuestion, DecisionScoreQuestion, DecisionAnswer, DecisionChoiceAnswer, DecisionNoulAnswer, DecisionScoreAnswer, DecisionModel, DecisionModelsResponse, AclMode, AclSource, AclEffect, AclSubjectKind, AclCondition, AclRule, AclList, AclDefRow, AclDefListResponse, AclDefNamesResponse, AclValidateResult, AclCatalogType, AclCatalog, AclDefOp, AclDefInput, GroupRow, GroupMemberKind, GroupMember, GroupListResponse, GroupDetail, GroupEffective, CreateGroupBody, GroupMemberChange, AclBinding, AclBindingListResponse, CreateAclBindingBody, AuthzReason, AuthzDecision, AuthzRequestContext, AuthzEvaluationRequest, AuthzEvaluationsSemantic, AuthzEvaluationsRequest, AuthzEvaluationsResponse, AuthzTrace, AuthzAppliedBinding, AuthzExplainResponse, AuthzDraftBinding, AuthzSimulateRequest, AuthzSimulateResult, AuthzSimulateResponse, OAuthServerMetadata, OAuthTokenResponse, OAuthTokenSet, BeginAuthorizeOptions, AuthorizeRequest, AuthorizeResponseParams, CompleteAuthorizeOptions, RefreshTokenOptions, RevokeTokenOptions, TokenProvider, AppClientRefresh, AppClientConfig, ClientDefInput, ClientDefRecord, ConfigAppClient, AppClientEntry, ClientDefListResponse, ClientDefVerifyResult, ClientDefRetireResult, ClientDefNameSummary, ClientDefNamesResponse, DeviceLoginPrompt, DeviceLoginOptions, DeviceLoginResult, } from "./types.js";
+export type { AgentEvent, ClientOptions, ContinueOptions, EventType, HostWidening, ImageMediaType, ParentContext, PromptContent, PromptSegment, RetryInfo, RunOptions, RunOverrideOptions, SamplingOptions, CompactionOptions, ContextOptions, ToolUse, Usage, CallTiming, Agent, AgentStatus, AwaitedState, AgentUsage, RunResult, RunSpec, RunSpecTeam, ConfiguredRun, ConfiguredRunPatch, ToolChoiceOptions, OutputFormatOptions, CancelAgentResult, ListAgentsResponse, ListUserAgentsOptions, AgentList, WalkRunsPage, RunBatchOptions, RunBatchResult, SpawnRunResult, CompactRunResult, RunTreeDeletion, RunTreeNotReached, DirectoryBudget, DirectoryInspection, DirectoryTenant, DirectoryUser, ErasureAccess, ErasureReport, ErasureResidue, ErasureResult, ErasureTier, MergeSubjectsResult, SubjectRef, BindSubjectPrincipalResult, ReviewQueueFilter, ReviewQueueGroup, ReviewQueueResult, RuleStatementsResult, RevertRulingResult, RulingBreakdown, RulingItem, RulingSelector, RulingRecord, ListRulingsResult, PolicyRuleCount, ApplyReviewPolicyResult, ErasureBoundSubject, ErasureTokenRef, CancelTurnResult, ReviewRunResult, ReplaySessionResult, TranscriptEvent, TranscriptResponse, HealthResponse, ListUsersResponse, UserSummary, UserStatus, UserRecord, CreateUserBody, UpdateUserBody, MintedUserToken, TokenRestrictions, UserTokenMeta, ListUserTokensResponse, UserIdentity, UserIdentitiesResponse, AuthGateKind, AuthGate, AuthGateKey, AuthGateRemoval, AuthGateProbe, AuthGateListResponse, CreateInviteBody, CreatedInvite, AuthInviteState, AuthInvite, AuthInviteListResponse, CreatedPasswordReset, GateIdentity, GateIdentitiesResponse, GateTenantStatus, RunnableAgent, RunnableAgentsResponse, WhoamiResponse, WhoamiEffective, WhoamiAuth, PauseResult, RetentionOverride, ResumeResult, RuntimeStateResponse, RuntimeStateStatus, ResolverMatrix, ResolverModelStatus, ResolverProviderAvailability, CreateSnapshotOptions, SnapshotCreateResponse, SnapshotDescriptor, SnapshotEnvelope, SnapshotListResponse, SnapshotRestoreResponse, MemoryEntriesResponse, MemoryEntry, MemoryEntryResponse, MemoryScopeIDsResponse, MemoryScopeIDSummary, MemoryScopeKind, MemoryScopesResponse, MemorySearchDocumentFilter, MemorySearchInput, MemorySource, MemoryWhen, MemoryTimeFilter, MemorySearchEntry, MemorySearchResponse, MemoryEmbedModelStats, MemoryEmbedStatsResponse, MemoryReembedConfigured, MemoryReembedResponse, MemoryBackfillResponse, MemoryPurgeResponse, InterruptListResponse, InterruptRow, InterruptStatus, ResolveInterruptOptions, ChannelHookCall, ChannelHookResult, HookFailMode, HookPhase, HookToolCall, HookToolResult, PostHookCall, PostHookResult, PreHookCall, PreHookResult, SubstrateToolInput, SubstrateToolResponse, TeamNameSummary, ListTeamsResponse, TeamDiagram, CreatedTeam, PromotedTeam, RetiredTeam, TeamDefDetail, TeamVerification, TeamDraft, TeamDraftVerification, TeamIssue, TeamIssueKind, TeamVersion, TeamVersionList, TeamBreakpoints, TeamRunDetached, TeamRunResult, TeamRunTarget, CreateTeamOptions, ForkTeamOptions, DefNameSummary, DefNamesResponse, OperatorTokenDefNameSummary, OperatorTokenDefNamesResponse, ScheduleListEntry, ScheduleListResponse, ScheduleActiveRun, ScheduleStateView, ScheduleRunNowResult, SchedulePauseResult, ModelAlias, ModelAliasesResponse, RoutingResponse, RoutingUserTier, RoutingTier, RoutingCandidate, RoutingThroughput, RoutingProvider, SearchRoutingProvider, RoutingEmbedder, RoutingDecision, RoutingDecisionModel, ProviderModelsResponse, TeamRunStep, TeamDecisionHandler, TeamDecisionQuestion, TeamDecisionAnswer, PathToolInput, PathToolResponse, DocumentToolInput, DocumentEdgeEvidence, DocumentToolResponse, DocumentSearchFilter, DocumentSearchHit, DocumentSearchResult, DocumentRelatedResult, HistoryToolInput, HistoryToolResponse, EvaluationEmitterRole, EvaluationSubmitInput, EvaluationGetInput, EvaluationListForRunInput, EvaluationListForDefInput, EvaluationAggregateInput, EvaluationInput, EvaluationSubmitResult, EvaluationRecord, EvaluationListForRunResult, EvaluationListForDefResult, EvaluationScoreStats, EvaluationAggregate, VolumeMode, PersistentVolumeEntry, PersistentVolumesResponse, EphemeralVolumeEntry, EphemeralVolumesResponse, SystemPromptPayload, UserInputPayload, ChannelDescriptor, ListChannelsResponse, RunStateEvent, RunStateStreamClose, RunStateStreamItem, RunStateStreamOpen, StreamUserRunStatesOptions, ChangeFeedError, ChangeFeedFrame, ChangeFeedStatus, EmbedderHealth, MemoryChange, MemoryChangeScope, MemoryChangeType, StreamChangesOptions, AckChannelOptions, ChannelAckResult, ChannelMessageItem, ChannelPeekResult, ListTeamChannelsOptions, PeekTeamChannelOptions, ReleaseTeamChannelOptions, TeamChannelReleaseResult, TeamChannelDeclaredIn, TeamChannelDescriptor, TeamChannelPeekResult, TeamChannelsResult, 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, AgentRouting, AgentChannelACL, AgentInterruptionACL, AgentDecision, MemoryRerank, AgentSampling, AgentCompaction, AgentTranscription, AgentSpeech, AgentContext, TierCandidate, CoreBlock, HookEvent, InlineWebhook, HookEntry, EventHooks, ToolEntry, ToolHooksByTool, EnsureCodeAgentOptions, EnsureCodeAgentResult, CreateDefOptions, ForkDefOptions, EnsureHookDefOptions, EnsureHookDefResult, HookDefBody, HookDefForkOverlay, HookDefInput, HookDefMatch, HookDefOverlay, HookDefRowResponse, HookDefVerifyResult, ScheduleDefInput, ScheduleDefOverlay, ScheduleDefRowResponse, ScheduledRunHook, ScheduledRunPromptContent, ScheduledRunPromptSegment, WebhookDefAuth, WebhookDefFilter, WebhookDefInput, WebhookDefOverlay, WebhookDefRateLimit, WebhookDefRowResponse, WebhookDefDeliveries, WebhookDefSyncResponse, LibraryAgentDefinition, LibraryEntry, LibraryListResponse, LibraryMcpServerDefinition, LibrarySkillDefinition, LLMChatContent, LLMChatMessage, LLMChatOptions, LLMChatResponse, LLMChatStreamDelta, LLMChatStreamItem, LLMChatToolCall, LLMChatUsage, LLMTool, LLMEmbeddingItem, LLMEmbeddingsOptions, LLMEmbeddingsResponse, LLMEmbeddingsUsage, UsageDimension, UsageBucket, UsageAggregate, UsageReportResponse, CapabilityInertInfo, LimitInfo, FileCapturedInfo, TranscriptionInfo, AdmissionInfo, ErrorInfo, CallFormat, CallRef, HookDecisionInfo, TeamDecisionInfo, OverrideInfo, FallbackInfo, InterruptionEventInfo, SpawnChildInfo, TurnCancelledInfo, ChannelEventInfo, ContextCompactionInfo, ContextRecapInfo, ContextStateInfo, ContextExhaustedInfo, ContextTierVerdict, ContextDistillDeclinedInfo, EffectiveConfigResponse, RunFileInput, RunFileImportSource, RunFileImportHeading, RunInboxDownload, EffectiveConfigSource, EffectiveValue, InertContextSetting, AgentOverridableResponse, OverridableField, OverrideLockReason, RetuneRunResponse, RunConfigRecord, SubagentHoldInfo, RunConfigResponse, RunPromptResponse, RunPromptSnapshot, PromptBlock, TokenLimit, TokenLimitsResponse, ConfigResponse, ConfigProvider, ConfigModel, ConfigSearch, ConfigInstance, SetTokenLimitRequest, CredentialScope, CredentialMeta, CredentialListResponse, CryptoKeyVersion, CryptoKeyExport, CryptoKeyType, CryptoKeyEncoding, CryptoKeyBackend, CryptoKeyExternal, CryptoOp, CryptoRequestBase, CryptoKeyRef, CryptoEncryptRequest, CryptoDecryptRequest, CryptoRewrapRequest, CryptoMacRequest, CryptoVerifyMacRequest, CryptoSignRequest, CryptoVerifyRequest, CryptoPublicKeyRequest, CryptoTotpRequest, CryptoHashRequest, CryptoRandomRequest, CryptoHashPasswordRequest, CryptoVerifyPasswordRequest, CryptoRequest, CryptoEncryptResult, CryptoDecryptResult, CryptoRewrapResult, CryptoMacResult, CryptoVerifyResult, CryptoSignResult, CryptoPublicJWK, CryptoPublicKeyResult, CryptoTotpResult, CryptoHashResult, CryptoRandomResult, CryptoHashPasswordResult, CryptoVerifyPasswordResult, CryptoResultByOp, CryptoResult, DecideRequest, DecideResponse, DecisionQuestion, DecisionChoiceQuestion, DecisionNoulQuestion, DecisionScoreQuestion, DecisionAnswer, DecisionChoiceAnswer, DecisionNoulAnswer, DecisionScoreAnswer, DecisionModel, DecisionModelsResponse, AclMode, AclSource, AclEffect, AclSubjectKind, AclCondition, AclRule, AclList, AclDefRow, AclDefListResponse, AclDefNamesResponse, AclValidateResult, AclCatalogType, AclCatalog, AclDefOp, AclDefInput, GroupRow, GroupMemberKind, GroupMember, GroupListResponse, GroupDetail, GroupEffective, CreateGroupBody, GroupMemberChange, AclBinding, AclBindingListResponse, CreateAclBindingBody, AuthzReason, AuthzDecision, AuthzRequestContext, AuthzEvaluationRequest, AuthzEvaluationsSemantic, AuthzEvaluationsRequest, AuthzEvaluationsResponse, AuthzTrace, AuthzAppliedBinding, AuthzExplainResponse, AuthzDraftBinding, AuthzSimulateRequest, AuthzSimulateResult, AuthzSimulateResponse, OAuthServerMetadata, OAuthTokenResponse, OAuthTokenSet, BeginAuthorizeOptions, AuthorizeRequest, AuthorizeResponseParams, CompleteAuthorizeOptions, RefreshTokenOptions, RevokeTokenOptions, TokenProvider, AppClientRefresh, AppClientConfig, ClientDefInput, ClientDefRecord, ConfigAppClient, AppClientEntry, ClientDefListResponse, ClientDefVerifyResult, ClientDefRetireResult, ClientDefNameSummary, ClientDefNamesResponse, DeviceLoginPrompt, DeviceLoginOptions, DeviceLoginResult, } from "./types.js";
 export { AclDeniedError, AgentIDInUseError, AgentNotFoundError, AlreadyPausingError, AuthError, BackpressureError, DeviceLoginError, NotFoundError, InsufficientScopeError, InvalidArgumentError, ChannelCursorRegressionError, LoomcycleError, NotPausedError, OAuthError, PauseNotConfiguredError, PerUserQuotaExhaustedError, PromptTooLargeError, RateLimitedError, RequestTooLargeError, SessionBusyError, SessionNotFoundError, SnapshotNotFoundError, SnapshotTooLargeError, SnapshotVersionError, SubstrateToolRefusedError, TokenLimitExceededError, UnavailableError, } from "./errors.js";

package/dist/types.d.ts

@@ -1991,10 +1991,23 @@ export interface ErasureReport {
     tier2_uncovered: ErasureTier;
     tier3_residue: ErasureResidue;
     access: ErasureAccess;
+    /** The tenant ontology subjects bound to this principal, which an erasure
+     *  unbinds and keeps. Absent from a server that predates subject bindings. */
+    bound_subjects?: ErasureBoundSubject[];
+    /** How many more are bound that the caller's access-control rules hide from
+     *  reading: counted, never named. Absent when none. */
+    bound_subjects_withheld?: number;
     notes: string[];
     /** Planes that could not be READ. Non-empty means every count is a lower bound. */
     errors?: string[];
 }
+/** A tenant ontology subject bound to an erased principal. */
+export interface ErasureBoundSubject {
+    document_id: string;
+    natural_key: string;
+    /** The document's first Path-tree name; absent when it has none. */
+    path?: string;
+}
 /** Result of {@link LoomcycleClient.erasureExecute} (RFC BL P5). */
 export interface ErasureResult {
     tenant: string;
@@ -2006,9 +2019,268 @@ export interface ErasureResult {
     residue: ErasureResidue;
     /** The groups, lists and member tokens removed (or, in a dry run, that would be). */
     access: ErasureAccess;
+    /** The subjects unbound (or, in a dry run, that would be), as in
+     *  {@link ErasureReport.bound_subjects}. */
+    bound_subjects?: ErasureBoundSubject[];
+    bound_subjects_withheld?: number;
+    /** Why `erased` was not announced for the unbound subjects; absent when it
+     *  was, or when there were none. */
+    not_announced?: string;
     errors?: string[];
     notes: string[];
 }
+/** One subject of the tenant ontology: its document, the document's root chunk
+ *  (the subject node) and its natural key. */
+export interface SubjectRef {
+    document_id: string;
+    root_chunk_id: string;
+    natural_key: string;
+}
+/** Result of {@link LoomcycleClient.mergeSubjects}. */
+export interface MergeSubjectsResult {
+    tenant: string;
+    duplicate: SubjectRef;
+    survivor: SubjectRef;
+    /** Chunks moved from the duplicate's document under the survivor. */
+    facts_moved: number;
+    /** Statements copied onto the survivor, each original expired as merged. */
+    statements_repointed: number;
+    /** Statements only expired: they would join the survivor to itself, or the
+     *  survivor already holds them. */
+    statements_retired: number;
+    /** Statements left on the duplicate (an end the caller may not link, or a
+     *  matching statement on the survivor that was retired). */
+    statements_left: number;
+    /** Why the merge was not announced on memory/subjects; absent when it was. */
+    not_announced?: string;
+}
+/** Result of {@link LoomcycleClient.bindSubjectPrincipal}. */
+export interface BindSubjectPrincipalResult {
+    tenant: string;
+    document_id: string;
+    root_chunk_id: string;
+    natural_key: string;
+    /** The subject document's first Path-tree name; absent when it has none. */
+    path?: string;
+    /** The binding after the call; "" when it was cleared. */
+    principal: string;
+    /** The binding before the call; absent when there was none. */
+    previous?: string;
+    /** False when the binding was already as asked. */
+    changed: boolean;
+}
+/** Narrows the statement review queue and selects what a bulk ruling rules
+ *  ({@link LoomcycleClient.listReviewQueue}, {@link LoomcycleClient.ruleStatements}).
+ *  Every field is optional; they combine with AND. A filter never shows more
+ *  than the caller may read. */
+export interface ReviewQueueFilter {
+    /** Statement status; default `proposed`. */
+    status?: string;
+    kind?: string;
+    kinds?: string[];
+    /** Exact, case-sensitive prefix of the method (`rule:`, `rule:citation`). */
+    method?: string;
+    /** The writer recorded on the statement: the agent for a run's write, else the user. */
+    actor?: string;
+    /** Either end in this document / under this Path. */
+    document_id?: string;
+    under_path?: string;
+    from_document_id?: string;
+    to_document_id?: string;
+    from_under_path?: string;
+    to_under_path?: string;
+    /** The writer's own confidence is at least this (0..1). */
+    min_confidence?: number;
+    /** Bounds on created_at: an RFC 3339 timestamp, or unix nanoseconds as a
+     *  decimal string (a statement's `created_at` exceeds a JS number's exact
+     *  range, so pass it as text). */
+    created_before?: string;
+    created_after?: string;
+    /** A judge's verdict is recorded (`attributes.judge`), or not / is exactly this. */
+    has_judge_verdict?: boolean;
+    judge_verdict?: string;
+    /** The method / the kind exactly as stored: no prefix match, no widening
+     *  to a kind's declared sub-kinds. */
+    method_exact?: string;
+    kind_exact?: string;
+    /** The from-document's path prefix exactly as the summary computes it
+     *  (first two segments of its first Path name in sort order). */
+    from_path_prefix?: string;
+    /** The from-document is filed under no Path name (the summary's "" prefix). */
+    from_unfiled?: boolean;
+    /** `judge`: the proposals the review policy left for the judge agent. */
+    review_route?: "judge";
+    /** A judge's acceptances in this audit state (attributes.judge.audited);
+     *  pair it with `status` (asserted for pending or confirmed, rejected for
+     *  overturned). */
+    judge_audit?: "pending" | "confirmed" | "overturned";
+}
+/** One row of the review queue's summary. */
+export interface ReviewQueueGroup {
+    kind: string;
+    method: string;
+    /** The from-document's Path name, first two segments; "" when filed nowhere. */
+    from_path_prefix: string;
+    /** `attributes.judge.verdict`; "" when none. */
+    judge_verdict: string;
+    count: number;
+    /** The filter that selects exactly this group: pass it to
+     *  {@link LoomcycleClient.ruleStatements} or `listReviewQueue` as it is. */
+    filter?: ReviewQueueFilter;
+}
+/** Result of {@link LoomcycleClient.listReviewQueue}. `statements` are as
+ *  `list_statements` renders them (envelope, both ends' titles and documents,
+ *  up to three evidence rows); with `summarize` it is empty and `summary` /
+ *  `total` carry the counts. */
+export interface ReviewQueueResult {
+    tenant: string;
+    scope: string;
+    statements: Array<Record<string, unknown>>;
+    truncated?: boolean;
+    next_cursor?: string;
+    summary?: ReviewQueueGroup[];
+    total?: number;
+}
+/** Counts of what a ruling rules, by kind and method. */
+export interface RulingBreakdown {
+    kind: string;
+    method: string;
+    count: number;
+}
+/** One statement's outcome in a ruling or a revert: the status it was ruled
+ *  (or reverted) to, or the refusal's code (`not_found`, `not_a_proposal`,
+ *  `statement_changed`, `failed`, `changed`) and message. */
+export interface RulingItem {
+    id: string;
+    status?: string;
+    error?: string;
+    message?: string;
+}
+/** Result of {@link LoomcycleClient.ruleStatements}. `matched` is what
+ *  `expect_count` must repeat; `skipped` counts statements the caller may not
+ *  rule on, never named. A dry run carries `sample` and `breakdown`; a real
+ *  call `ruling_id`, `ruled`, `failed` and `items`. */
+export interface RuleStatementsResult {
+    tenant: string;
+    scope: string;
+    action: "accept" | "reject";
+    dry_run: boolean;
+    ruling_id?: string;
+    matched: number;
+    selected: number;
+    skipped: number;
+    to_rule: number;
+    ruled: number;
+    failed: number;
+    sample?: Array<Record<string, unknown>>;
+    breakdown: RulingBreakdown[];
+    items?: RulingItem[];
+}
+/** Result of {@link LoomcycleClient.revertRuling}. */
+export interface RevertRulingResult {
+    tenant: string;
+    scope: string;
+    ruling_id: string;
+    action: string;
+    reverted: number;
+    /** Left because something changed them since the ruling (each in `items`
+     *  with error `changed`). */
+    changed: number;
+    skipped: number;
+    items: RulingItem[];
+    /** The revert's own record in {@link LoomcycleClient.listRulings}. */
+    revert_id?: string;
+}
+/** What a ruling selected: the queue filter, or how many ids it named
+ *  (never the ids); on a revert, the ruling it undid. */
+export interface RulingSelector {
+    filter?: ReviewQueueFilter;
+    ids_count?: number;
+    max?: number;
+    reverts?: string;
+    /** Set on a review policy's ruling: the ontology version it was read at,
+     *  its source (`review` / `auto_assert`; absent for a ruling made as a
+     *  run's proposals were filed) and that run. */
+    policy?: {
+        version: number;
+        source?: string;
+        run_id?: string;
+    };
+    /** Set on a judge run's ruling (action `judge`): that run and its agent. */
+    judge?: {
+        run_id: string;
+        agent?: string;
+    };
+}
+/** One bulk ruling (`accept` / `reject`) or one revert of one (`revert`:
+ *  `ruled` counts what it reverted, `failed` what had changed since). */
+export interface RulingRecord {
+    id: string;
+    action: string;
+    ruled_by: string;
+    /** The subject that made the call. */
+    actor?: string;
+    reason?: string;
+    selector: RulingSelector;
+    matched: number;
+    ruled: number;
+    failed: number;
+    skipped: number;
+    /** Unix nanoseconds; beyond a JS number's exact range, so compare loosely. */
+    created_at: number;
+    reverted: boolean;
+    reverted_at?: number;
+    /** The id of the (latest) revert, itself a record of the listing. */
+    reverted_by?: string;
+}
+/** Result of {@link LoomcycleClient.listRulings}: newest first. An operator
+ *  sees every ruling of the scope; a member only its own. */
+export interface ListRulingsResult {
+    tenant: string;
+    scope: string;
+    rulings: RulingRecord[];
+    next_cursor?: string;
+}
+/** How many proposals one rule of the review policy decided; rule 0 is none
+ *  matched (and corrections, which the policy never rules): they wait for a
+ *  person. */
+export interface PolicyRuleCount {
+    rule: number;
+    action: "accept" | "reject" | "judge" | "human";
+    text?: string;
+    count: number;
+}
+/** Result of {@link LoomcycleClient.applyReviewPolicy}. `source` is where the
+ *  policy comes from (`review`: the ontology's Review section; `auto_assert`:
+ *  the one `@auto_assert` implies) and `version` the ontology version it was
+ *  read at. `matched` is what `expect_count` must repeat; `skipped` counts
+ *  proposals the caller may not rule on. `to_rule` is the accepts and rejects
+ *  this call rules, `deferred` those left for the next call; `marked` the
+ *  proposals whose judge routing it changed. A dry run carries `sample` (each
+ *  with `review_rule` and `review_action`); a real call `ruling_id`, `ruled`,
+ *  `failed` and `items`. */
+export interface ApplyReviewPolicyResult {
+    tenant: string;
+    scope: string;
+    dry_run: boolean;
+    source: "review" | "auto_assert";
+    version: number;
+    ruling_id?: string;
+    matched: number;
+    skipped: number;
+    accept: number;
+    reject: number;
+    judge: number;
+    human: number;
+    to_rule: number;
+    deferred: number;
+    ruled: number;
+    failed: number;
+    marked: number;
+    rules: PolicyRuleCount[];
+    sample?: Array<Record<string, unknown>>;
+    items?: RulingItem[];
+}
 export interface CompactRunResult {
     run_id: string;
     compacted: boolean;
@@ -3495,7 +3767,7 @@ export type DocumentEdgeEvidence = {
     char_end?: number;
 };
 export type DocumentToolInput = {
-    op: "create_document" | "get_document" | "documents_summary" | "query_documents" | "delete_document" | "set_path" | "create_chunk" | "upsert_chunk" | "get_chunk" | "update_chunk" | "delete_chunk" | "supersede_chunk" | "graph_recall" | "move_chunk" | "reorder_chunk" | "link_chunks" | "unlink_chunks" | "get_edges" | "get_edge" | "propose_statement" | "accept_statement" | "reject_statement" | "list_statements" | "maintain_statement" | "resolve_anchor" | "lease" | "release" | "describe_ontology" | "extract_citations" | "classify" | "accept_classification" | "query_chunks" | "add_tags" | "remove_tags" | "list_tags" | "define_type" | "list_types" | "set_asset" | "get_asset" | "export_md" | "import_md" | "backlinks" | "related" | "unlinked_mentions" | "history" | "get_version" | "diff" | "export_canvas" | "import_canvas" | "list_facts" | "judge_fact" | "verbatim_answer" | "verification_stats" | "remember" | "propose_entity" | "propose_subject" | "search" | "set_remote" | "sync" | "diff_remote";
+    op: "create_document" | "get_document" | "documents_summary" | "query_documents" | "delete_document" | "set_path" | "create_chunk" | "upsert_chunk" | "get_chunk" | "update_chunk" | "delete_chunk" | "supersede_chunk" | "graph_recall" | "move_chunk" | "reorder_chunk" | "link_chunks" | "unlink_chunks" | "get_edges" | "get_edge" | "propose_statement" | "accept_statement" | "reject_statement" | "list_statements" | "judge_statements" | "maintain_statement" | "resolve_anchor" | "lease" | "release" | "describe_ontology" | "extract_citations" | "classify" | "accept_classification" | "query_chunks" | "add_tags" | "remove_tags" | "list_tags" | "define_type" | "list_types" | "set_asset" | "get_asset" | "export_md" | "import_md" | "backlinks" | "related" | "unlinked_mentions" | "history" | "get_version" | "diff" | "export_canvas" | "import_canvas" | "list_facts" | "judge_fact" | "verbatim_answer" | "verification_stats" | "remember" | "propose_entity" | "propose_subject" | "search" | "set_remote" | "sync" | "diff_remote";
     scope?: "agent" | "user" | "tenant";
     /** Document id (get/delete_document) or chunk id (get/update/delete/move_chunk). */
     id?: string;
@@ -3682,8 +3954,17 @@ export type DocumentToolInput = {
     /** lease: how long to hold it, in milliseconds (default 60000, max one hour). */
     ttl_ms?: number;
     /** classify: "propose" (default) applies an unambiguous rule match and files the
-     *  rest for review; "report" writes nothing. */
-    write?: "propose" | "report";
+     *  rest for review; "report" writes nothing. judge_statements: "rule"
+     *  (default) or "recommend". */
+    write?: "propose" | "report" | "rule" | "recommend";
+    /** judge_statements (a judge agent's run only): the verdicts to record. */
+    judgements?: Array<{
+        id: string;
+        verdict: "accept" | "reject" | "unsure";
+        confidence: number;
+        rationale: string;
+        verdict_run_id?: string;
+    }>;
     /** export_md: embed round-trippable chunk metadata + edges as HTML comments
      *  (default true server-side). false = clean human-facing Markdown. */
     include_metadata?: boolean;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@loomcycle/client",
-  "version": "1.129.0",
+  "version": "1.133.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",