@arnilo/prism 0.0.96 → 0.1.1

package/dist/contracts.js

@@ -1,6 +1,62 @@
+/**
+ * Thrown by a delegated-run host (e.g. the supervisor) when a nested run suspends on
+ * pending decisions inside a tool execution. Core converts it into a root suspension
+ * with attributed, root-visible approval ids; the dispatching wrapper attaches `toolCall`.
+ */
+export class AgentDelegationSuspendedError extends Error {
+    ref;
+    pendingDecisions;
+    path;
+    code = "ERR_PRISM_DELEGATION_SUSPENDED";
+    toolCall;
+    constructor(ref, pendingDecisions, 
+    /** Redacted delegation path (child ids) used when decisions carry no attribution. */
+    path) {
+        super("Delegated run suspended");
+        this.ref = ref;
+        this.pendingDecisions = pendingDecisions;
+        this.path = path;
+        this.name = "AgentDelegationSuspendedError";
+    }
+}
+/** Shared decision-contract violations. Unknown and foreign approval ids share one non-enumerating error. */
+export class AgentDecisionError extends Error {
+    code;
+    constructor(code, message, options) {
+        super(message, options);
+        this.code = code;
+        this.name = "AgentDecisionError";
+    }
+}
+export const DEFAULT_MAX_PENDING_DECISIONS = 32;
+export const HARD_MAX_PENDING_DECISIONS = 128;
+export const DEFAULT_MAX_STICKY_DECISIONS = 64;
+export const HARD_MAX_STICKY_DECISIONS = 256;
+export const MAX_DECISION_REASON_BYTES = 2 * 1024;
+export const HARD_MAX_DECISION_REASON_BYTES = 8 * 1024;
+export const MAX_ELICITATION_BYTES = 16 * 1024;
+export const HARD_MAX_ELICITATION_BYTES = 64 * 1024;
+export const MAX_ACTION_CONSTRAINTS = 32;
+export const HARD_MAX_ACTION_CONSTRAINTS = 64;
+/** Maximum delegation attribution depth for surfaced nested pending decisions. */
+export const MAX_ATTRIBUTION_DEPTH = 8;
+export const MAX_ACTION_CONSTRAINT_BYTES = 4 * 1024;
+export const HARD_MAX_ACTION_CONSTRAINT_BYTES = 16 * 1024;
 export class AgentRunStateError extends Error {
     code = "ERR_PRISM_AGENT_RUN_STATE";
-    constructor(message) { super(message); this.name = "AgentRunStateError"; }
+    constructor(message) {
+        super(message);
+        this.name = "AgentRunStateError";
+    }
+}
+/** Durable-loop contract violations: hook-less custom strategy on a durable run, invalid snapshot, or revision drift. */
+export class AgentLoopStateError extends Error {
+    code;
+    constructor(code, message, options) {
+        super(message, options);
+        this.code = code;
+        this.name = "AgentLoopStateError";
+    }
 }
 export class AgentRunError extends Error {
     result;
@@ -10,6 +66,14 @@ export class AgentRunError extends Error {
         this.result = result;
     }
 }
+/** Mid-run steer queue: default pending message count (fail closed at this cap). */
+export const DEFAULT_MAX_PENDING_STEERS = 8;
+/** Absolute pending steer count ceiling if hosts later expose overrides. */
+export const HARD_MAX_PENDING_STEERS = 32;
+/** Mid-run steer queue: default total UTF-8 byte budget across pending messages. */
+export const DEFAULT_MAX_PENDING_STEER_BYTES = 64 * 1024;
+/** Absolute pending steer byte ceiling if hosts later expose overrides. */
+export const HARD_MAX_PENDING_STEER_BYTES = 256 * 1024;
 export const SESSION_ENTRY_KINDS = [
     "message",
     "event",
@@ -25,6 +89,75 @@ export const SESSION_ENTRY_SCHEMA_VERSION = 1;
 export function isSessionEntryKind(value) {
     return typeof value === "string" && SESSION_ENTRY_KIND_SET.has(value);
 }
+/** Host-written `SessionRecord.metadata` / session metadata key for workspace filtering. */
+export const SESSION_SEARCH_WORKSPACE_METADATA_KEY = "workspaceRoot";
+export const DEFAULT_SESSION_SEARCH_LIMIT = 20;
+export const HARD_MAX_SESSION_SEARCH_LIMIT = 100;
+export const DEFAULT_MAX_SESSION_SEARCH_QUERY_BYTES = 4 * 1024;
+export const HARD_MAX_SESSION_SEARCH_QUERY_BYTES = 16 * 1024;
+export const DEFAULT_MAX_SESSION_SEARCH_SNIPPET_BYTES = 512;
+export const HARD_MAX_SESSION_SEARCH_SNIPPET_BYTES = 4 * 1024;
+export const DEFAULT_MAX_SESSION_SEARCH_CURSOR_BYTES = 1 * 1024;
+export const HARD_MAX_SESSION_SEARCH_CURSOR_BYTES = 4 * 1024;
+export const DEFAULT_MAX_SESSION_SEARCH_LINEAR_SESSIONS = 1_000;
+export const HARD_MAX_SESSION_SEARCH_LINEAR_SESSIONS = 5_000;
+export const DEFAULT_MAX_SESSION_SEARCH_LINEAR_ENTRIES = 10_000;
+export const HARD_MAX_SESSION_SEARCH_LINEAR_ENTRIES = 50_000;
+export const DEFAULT_MAX_SESSION_SEARCH_LINEAR_BYTES = 8 * 1024 * 1024;
+export const HARD_MAX_SESSION_SEARCH_LINEAR_BYTES = 64 * 1024 * 1024;
+export const DEFAULT_MAX_SESSION_SEARCH_FTS_CANDIDATES = 1_000;
+export const HARD_MAX_SESSION_SEARCH_FTS_CANDIDATES = 5_000;
+/**
+ * O(1) validation before any scan/query. Applies default page limit; rejects NaN,
+ * non-positive limits, oversize query/cursor/filter strings, and invalid order.
+ */
+export function resolveSessionSearchQuery(query) {
+    const limit = query.limit === undefined ? DEFAULT_SESSION_SEARCH_LIMIT : query.limit;
+    if (!Number.isSafeInteger(limit) || limit < 1 || limit > HARD_MAX_SESSION_SEARCH_LIMIT) {
+        throw new TypeError(`SessionSearchQuery.limit must be a safe integer from 1 to ${HARD_MAX_SESSION_SEARCH_LIMIT}`);
+    }
+    const order = query.order ?? "desc";
+    if (order !== "asc" && order !== "desc") {
+        throw new TypeError('SessionSearchQuery.order must be "asc" or "desc"');
+    }
+    assertSearchStringBytes(query.query, "query", HARD_MAX_SESSION_SEARCH_QUERY_BYTES);
+    assertSearchStringBytes(query.cursor, "cursor", HARD_MAX_SESSION_SEARCH_CURSOR_BYTES);
+    assertSearchStringBytes(query.workspaceRoot, "workspaceRoot", HARD_MAX_SESSION_SEARCH_QUERY_BYTES);
+    assertSearchStringBytes(query.provider, "provider", HARD_MAX_SESSION_SEARCH_QUERY_BYTES);
+    assertSearchStringBytes(query.model, "model", HARD_MAX_SESSION_SEARCH_QUERY_BYTES);
+    assertSearchStringBytes(query.label, "label", HARD_MAX_SESSION_SEARCH_QUERY_BYTES);
+    assertSearchStringBytes(query.summary, "summary", HARD_MAX_SESSION_SEARCH_QUERY_BYTES);
+    assertSearchStringBytes(query.tenantId, "tenantId", HARD_MAX_SESSION_SEARCH_QUERY_BYTES);
+    assertSearchStringBytes(query.accountId, "accountId", HARD_MAX_SESSION_SEARCH_QUERY_BYTES);
+    assertSearchStringBytes(query.userId, "userId", HARD_MAX_SESSION_SEARCH_QUERY_BYTES);
+    assertSearchStringBytes(query.fromUpdatedAt, "fromUpdatedAt", HARD_MAX_SESSION_SEARCH_QUERY_BYTES);
+    assertSearchStringBytes(query.toUpdatedAt, "toUpdatedAt", HARD_MAX_SESSION_SEARCH_QUERY_BYTES);
+    return { ...query, limit, order };
+}
+function assertSearchStringBytes(value, name, hardMax) {
+    if (value === undefined)
+        return;
+    if (typeof value !== "string") {
+        throw new TypeError(`SessionSearchQuery.${name} must be a string`);
+    }
+    // ponytail: UTF-8 byte length via TextEncoder; upgrade only if a non-Unicode host appears.
+    const bytes = new TextEncoder().encode(value).byteLength;
+    if (bytes > hardMax) {
+        throw new TypeError(`SessionSearchQuery.${name} exceeds ${hardMax} bytes`);
+    }
+}
+export const SESSION_SEARCH_UNSUPPORTED_CODE = "session_search_unsupported";
+/** Thrown when a store opts out of `searchSessions` (memory `unsupported`, JSONL). */
+export class SessionSearchUnsupportedError extends Error {
+    code = SESSION_SEARCH_UNSUPPORTED_CODE;
+    constructor(message = "session search is unsupported by this store") {
+        super(message);
+        this.name = "SessionSearchUnsupportedError";
+    }
+}
+export function isSessionSearchUnsupported(error) {
+    return error instanceof Error && error.code === SESSION_SEARCH_UNSUPPORTED_CODE;
+}
 /** Stable error code carried by `SessionAppendConflictError`. */
 export const SESSION_APPEND_CONFLICT_CODE = "session_append_conflict";
 /**
@@ -51,4 +184,12 @@ export class SessionAppendConflictError extends Error {
 export function isSessionAppendConflict(error) {
     return error instanceof Error && error.code === SESSION_APPEND_CONFLICT_CODE;
 }
+const SESSION_METADATA_KEY_PATTERN = /^[A-Za-z0-9_][A-Za-z0-9_.-]{0,127}$/;
+/** Validate a top-level `SessionRecord.metadata` key used by `SessionQuery.metadataKey` filters. */
+export function assertSessionMetadataKey(key) {
+    if (typeof key !== "string" || !SESSION_METADATA_KEY_PATTERN.test(key)) {
+        throw new RangeError("metadataKey must match /^[A-Za-z0-9_][A-Za-z0-9_.-]{0,127}$/");
+    }
+    return key;
+}
 //# sourceMappingURL=contracts.js.map

package/dist/contribution-parsing.js

@@ -50,7 +50,11 @@ function parseFrontBlock(lines) {
             out.set(key, items);
         }
         else if (value.startsWith("[") && value.endsWith("]")) {
-            out.set(key, value.slice(1, -1).split(",").map((s) => s.trim()).filter((s) => s.length > 0));
+            out.set(key, value
+                .slice(1, -1)
+                .split(",")
+                .map((s) => s.trim())
+                .filter((s) => s.length > 0));
         }
         else {
             out.set(key, value);
@@ -63,7 +67,7 @@ function parseFrontBlock(lines) {
 // plain string split instead of `node:path`. Expects `.../<name>/SKILL.md`.
 function parentDirName(path) {
     const parts = path.split(/[/\\]+/).filter(Boolean);
-    return parts.length >= 2 ? parts[parts.length - 2] : parts[parts.length - 1] ?? "";
+    return parts.length >= 2 ? parts[parts.length - 2] : (parts[parts.length - 1] ?? "");
 }
 const NAME_RE = /^[A-Za-z0-9 _-]+$/;
 /** Parse a `SKILL.md` into a {@link Skill}. Frontmatter keys map to `name`

package/dist/contributions.d.ts

@@ -4,6 +4,8 @@ import { type ProviderRegistry } from "./providers.js";
 import { type DuplicateRegistrationOptions } from "./registry-options.js";
 export interface ContributionRegistry<T> {
     register(key: string, contribution: T): void;
+    /** Remove a contribution; returns false when the key was not registered. */
+    unregister(key: string): boolean;
     get(key: string): T | undefined;
     resolve(key: string): T;
     list(): readonly T[];

package/dist/contributions.js

@@ -9,6 +9,9 @@ export function createContributionRegistry(options = {}) {
             assertCanRegister(byKey, key, label, key, options.duplicate);
             byKey.set(key, contribution);
         },
+        unregister(key) {
+            return byKey.delete(key);
+        },
         get(key) {
             return byKey.get(key);
         },

package/dist/conversations.d.ts

@@ -0,0 +1,50 @@
+import type { OwnershipScope, SessionRecord } from "./contracts.js";
+/** Conversation thread lifecycle state. Archive is soft; deletion goes through persistence lifecycle. */
+export type ConversationThreadState = "active" | "archived";
+/** Well-known `SessionRecord.metadata` key marking conversation threads. */
+export declare const CONVERSATION_METADATA_KEY = "prismConversation";
+export declare const DEFAULT_MAX_CONVERSATION_CURSOR_BYTES: number;
+export declare const HARD_MAX_CONVERSATION_CURSOR_BYTES: number;
+export interface ConversationBranchRef {
+    readonly leafId: string;
+    readonly createdAt: string;
+}
+/**
+ * Durable user-scoped conversation thread. A thread is an ownership-scoped session
+ * branch plus metadata; content lives in session entries and the redacted event ledger.
+ */
+export interface ConversationThread extends OwnershipScope {
+    readonly id: string;
+    readonly title?: string;
+    readonly state: ConversationThreadState;
+    readonly createdAt: string;
+    readonly updatedAt: string;
+    /** Branch leaves recorded by the conversation service; the entry tree remains the content source of truth. */
+    readonly branches: readonly ConversationBranchRef[];
+    /** Host-supplied create metadata; never credentials or raw transcripts. */
+    readonly metadata?: Readonly<Record<string, unknown>>;
+}
+/** Opaque thread-bound replay cursor; prevents replaying a cursor minted for another thread. */
+export interface ConversationReplayCursor {
+    readonly v: 1;
+    readonly threadId: string;
+    /** Opaque store keyset cursor; undefined means the start of the thread. */
+    readonly cursor?: string;
+}
+export declare class ConversationError extends Error {
+    readonly reason: string;
+    readonly code = "ERR_PRISM_CONVERSATION";
+    constructor(message: string, reason: string);
+}
+export declare function encodeConversationReplayCursor(cursor: ConversationReplayCursor): string;
+export declare function decodeConversationReplayCursor(encoded: string, expectedThreadId: string, maxBytes?: number): ConversationReplayCursor;
+/** Project a persisted session record into a conversation thread. Undefined for non-conversation sessions. */
+export declare function conversationThreadFromRecord(record: SessionRecord): ConversationThread | undefined;
+/** Serialize conversation marker metadata for `SessionRecord.metadata`. */
+export declare function conversationMarkerMetadata(marker: {
+    readonly title?: string;
+    readonly state: ConversationThreadState;
+    readonly branches?: readonly ConversationBranchRef[];
+    readonly requestId?: string;
+    readonly metadata?: Readonly<Record<string, unknown>>;
+}): Readonly<Record<string, unknown>>;

package/dist/conversations.js

@@ -0,0 +1,98 @@
+/** Well-known `SessionRecord.metadata` key marking conversation threads. */
+export const CONVERSATION_METADATA_KEY = "prismConversation";
+export const DEFAULT_MAX_CONVERSATION_CURSOR_BYTES = 4 * 1024;
+export const HARD_MAX_CONVERSATION_CURSOR_BYTES = 16 * 1024;
+export class ConversationError extends Error {
+    reason;
+    code = "ERR_PRISM_CONVERSATION";
+    constructor(message, reason) {
+        super(message);
+        this.reason = reason;
+        this.name = "ConversationError";
+    }
+}
+export function encodeConversationReplayCursor(cursor) {
+    return Buffer.from(JSON.stringify(cursor), "utf8").toString("base64url");
+}
+export function decodeConversationReplayCursor(encoded, expectedThreadId, maxBytes = DEFAULT_MAX_CONVERSATION_CURSOR_BYTES) {
+    if (typeof encoded !== "string" || encoded.length === 0) {
+        throw new ConversationError("Replay cursor is required", "invalid_cursor");
+    }
+    if (Buffer.byteLength(encoded, "utf8") > maxBytes) {
+        throw new ConversationError("Replay cursor exceeds byte limit", "cursor_too_large");
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(Buffer.from(encoded, "base64url").toString("utf8"));
+    }
+    catch {
+        throw new ConversationError("Replay cursor is invalid", "invalid_cursor");
+    }
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+        throw new ConversationError("Replay cursor is invalid", "invalid_cursor");
+    }
+    const cursor = parsed;
+    if (cursor.v !== 1 || typeof cursor.threadId !== "string" || cursor.threadId.length === 0) {
+        throw new ConversationError("Replay cursor is invalid", "invalid_cursor");
+    }
+    if (cursor.threadId !== expectedThreadId) {
+        throw new ConversationError("Replay cursor belongs to another thread", "cursor_thread_mismatch");
+    }
+    if (cursor.cursor !== undefined && (typeof cursor.cursor !== "string" || cursor.cursor.length === 0)) {
+        throw new ConversationError("Replay cursor is invalid", "invalid_cursor");
+    }
+    return {
+        v: 1,
+        threadId: cursor.threadId,
+        ...(cursor.cursor === undefined ? {} : { cursor: cursor.cursor }),
+    };
+}
+/** Project a persisted session record into a conversation thread. Undefined for non-conversation sessions. */
+export function conversationThreadFromRecord(record) {
+    const marker = record.metadata?.[CONVERSATION_METADATA_KEY];
+    if (!marker || typeof marker !== "object" || Array.isArray(marker))
+        return undefined;
+    const value = marker;
+    const branches = [];
+    if (Array.isArray(value.branches)) {
+        for (const item of value.branches) {
+            if (item &&
+                typeof item === "object" &&
+                typeof item.leafId === "string" &&
+                typeof item.createdAt === "string") {
+                branches.push({
+                    leafId: item.leafId,
+                    createdAt: item.createdAt,
+                });
+            }
+        }
+    }
+    const metadata = value.metadata && typeof value.metadata === "object" && !Array.isArray(value.metadata)
+        ? value.metadata
+        : undefined;
+    return {
+        id: record.id,
+        ...(record.tenantId !== undefined ? { tenantId: record.tenantId } : {}),
+        ...(record.accountId !== undefined ? { accountId: record.accountId } : {}),
+        ...(record.userId !== undefined ? { userId: record.userId } : {}),
+        ...(typeof value.title === "string" && value.title.length > 0 ? { title: value.title } : {}),
+        state: value.state === "archived" ? "archived" : "active",
+        createdAt: record.createdAt,
+        updatedAt: record.updatedAt,
+        branches: Object.freeze(branches),
+        ...(metadata === undefined ? {} : { metadata }),
+    };
+}
+/** Serialize conversation marker metadata for `SessionRecord.metadata`. */
+export function conversationMarkerMetadata(marker) {
+    return {
+        [CONVERSATION_METADATA_KEY]: {
+            ...(marker.title === undefined ? {} : { title: marker.title }),
+            state: marker.state,
+            ...(marker.branches === undefined || marker.branches.length === 0 ? {} : { branches: marker.branches }),
+            ...(marker.requestId === undefined ? {} : { requestId: marker.requestId }),
+            ...(marker.metadata === undefined ? {} : { metadata: marker.metadata }),
+        },
+    };
+}
+//# sourceMappingURL=conversations.js.map

package/dist/credentials.d.ts

@@ -1,4 +1,4 @@
-import type { Credential, CredentialResolver, CredentialRequest, CredentialResolverSource, OAuthCredentialStore, OAuthCredentials, OAuthProvider } from "./contracts.js";
+import type { Credential, CredentialRequest, CredentialResolver, CredentialResolverSource, OAuthCredentialStore, OAuthCredentials, OAuthProvider } from "./contracts.js";
 export type CredentialValueSource = string | (() => string | undefined | Promise<string | undefined>) | CredentialResolver;
 export interface CredentialRecord {
     readonly name: string;
@@ -10,7 +10,13 @@ export interface MemoryCredentialStore extends CredentialResolver {
     delete(request: Pick<CredentialRequest, "name" | "provider">): boolean;
     clear(): void;
 }
-export declare function createMemoryCredentialStore(initial?: readonly CredentialRecord[]): MemoryCredentialStore;
+export interface MemoryCredentialStoreOptions {
+    /** When true (default, backward compatible), a provider-scoped request falls back to a
+     *  providerless record of the same name — that record is then served to EVERY provider.
+     *  Set false for exact-match-only resolution (strict provider scoping). */
+    readonly allowProviderFallback?: boolean;
+}
+export declare function createMemoryCredentialStore(initial?: readonly CredentialRecord[], options?: MemoryCredentialStoreOptions): MemoryCredentialStore;
 export declare function createChainedCredentialResolver(resolvers: readonly CredentialResolver[]): CredentialResolver;
 export declare function createExplicitCredentialResolver(sources: readonly CredentialResolverSource[]): CredentialResolver;
 export declare function createEnvCredentialResolver(env: Readonly<Record<string, string | undefined>>, map: Readonly<Record<string, string>>): CredentialResolver;
@@ -19,4 +25,18 @@ export declare function refreshOAuthCredential(options: {
     readonly credentials: OAuthCredentials;
     readonly store?: OAuthCredentialStore;
 }): Promise<OAuthCredentials>;
+/** A credential store that can also remove entries (revocation fails closed on the delete). */
+export interface RevocableOAuthCredentialStore extends OAuthCredentialStore {
+    delete(provider: string, accountId?: string): Promise<boolean> | boolean;
+}
+/**
+ * Revokes an OAuth credential: best-effort upstream revocation, then a mandatory local
+ * store delete so subsequent connector calls fail closed. The local delete is the trust
+ * boundary — an upstream revoke failure never leaves a stored token usable.
+ */
+export declare function revokeOAuthCredential(options: {
+    readonly provider: OAuthProvider;
+    readonly credentials: OAuthCredentials;
+    readonly store?: RevocableOAuthCredentialStore;
+}): Promise<void>;
 export declare function resolveCredentialValue(source: CredentialValueSource | undefined, request: CredentialRequest): Promise<string | undefined>;

package/dist/credentials.js

@@ -1,5 +1,6 @@
-export function createMemoryCredentialStore(initial = []) {
+export function createMemoryCredentialStore(initial = [], options = {}) {
     const records = new Map();
+    const allowProviderFallback = options.allowProviderFallback ?? true;
     const key = (name, provider) => `${provider ?? ""}\u0000${name}`;
     const store = {
         set(record) {
@@ -12,7 +13,10 @@ export function createMemoryCredentialStore(initial = []) {
             records.clear();
         },
         resolve(request) {
-            return records.get(key(request.name, request.provider)) ?? records.get(key(request.name));
+            const exact = records.get(key(request.name, request.provider));
+            if (exact !== undefined || !allowProviderFallback || request.provider === undefined)
+                return exact;
+            return records.get(key(request.name));
         },
     };
     for (const record of initial)
@@ -37,7 +41,9 @@ export function createExplicitCredentialResolver(sources) {
 export function createEnvCredentialResolver(env, map) {
     return {
         resolve(request) {
-            const envName = map[credentialMapKey(request.name, request.provider)] ?? (request.provider ? map[request.provider] : undefined) ?? map[request.name];
+            const envName = map[credentialMapKey(request.name, request.provider)] ??
+                (request.provider ? map[request.provider] : undefined) ??
+                map[request.name];
             const value = envName ? env[envName] : undefined;
             return value ? { type: "api_key", value, metadata: { source: "env", envName } } : undefined;
         },
@@ -48,6 +54,15 @@ export async function refreshOAuthCredential(options) {
     await options.store?.set(options.provider.id, refreshed);
     return refreshed;
 }
+/**
+ * Revokes an OAuth credential: best-effort upstream revocation, then a mandatory local
+ * store delete so subsequent connector calls fail closed. The local delete is the trust
+ * boundary — an upstream revoke failure never leaves a stored token usable.
+ */
+export async function revokeOAuthCredential(options) {
+    await options.provider.revoke?.(options.credentials);
+    await options.store?.delete(options.provider.id, options.credentials.accountId);
+}
 function credentialMapKey(name, provider) {
     return provider ? `${provider}:${name}` : name;
 }

package/dist/devices.d.ts

@@ -0,0 +1,94 @@
+/**
+ * Device adapter contract (realtime voice / desktop OS control) — 0.0.14.
+ *
+ * Contracts + deny-by-default policy ONLY. No vendor voice or desktop-control
+ * implementation ships in 0.0.14 (demand-gated to 0.1.x). This module composes
+ * over the existing `PermissionPolicy` / `RunLimits` / redactor seams; it adds
+ * no second approval runtime and no device framework. Hosts implement
+ * `DeviceAdapter`, resolve a policy, and admit sessions through the fail-closed
+ * gate below. Conformance fixtures (denial/approval/stream-bounds/redaction)
+ * live in `runDevicePolicyConformance` for future vendor adapters to run.
+ */
+import type { RunLimits } from "./contracts.js";
+import { type SecretRedactor } from "./redaction.js";
+/** Audio / screenshot / stream chunk: 1 MiB default / 8 MiB hard. */
+export declare const DEFAULT_DEVICE_MAX_CHUNK_BYTES: number;
+export declare const HARD_DEVICE_MAX_CHUNK_BYTES: number;
+/** Concurrent device sessions per identity: 1 default / 4 hard. */
+export declare const DEFAULT_DEVICE_MAX_CONCURRENT_SESSIONS = 1;
+export declare const HARD_DEVICE_MAX_CONCURRENT_SESSIONS = 4;
+export type DeviceKind = "voice" | "desktop-control";
+export type DevicePolicyErrorCode = "ERR_PRISM_DEVICE_INPUT" | "ERR_PRISM_DEVICE_DISABLED" | "ERR_PRISM_DEVICE_APPROVAL" | "ERR_PRISM_DEVICE_SESSIONS" | "ERR_PRISM_DEVICE_CHUNK" | "ERR_PRISM_DEVICE_RUN_LIMITS";
+export declare class DevicePolicyError extends Error {
+    readonly code: DevicePolicyErrorCode;
+    constructor(code: DevicePolicyErrorCode, message: string);
+}
+export interface DeviceStreamLimits {
+    readonly maxChunkBytes?: number;
+    readonly maxConcurrentSessions?: number;
+}
+/**
+ * Host-declared device adapter. `enabled` is deny-by-default: a device is
+ * admitted only when the host explicitly sets it `true` AND supplies a sandbox
+ * AND (when `requireApproval`) explicit per-side-effect approval.
+ */
+export interface DeviceAdapter {
+    readonly kind: DeviceKind;
+    readonly enabled: boolean;
+    readonly requireApproval: boolean;
+    readonly limits?: DeviceStreamLimits;
+    /** Host-owned sandbox identifier; admission fails closed without it. */
+    readonly sandbox?: string;
+    /** Host-owned network/egress policy identifier. */
+    readonly network?: string;
+}
+export interface ResolvedDevicePolicy {
+    readonly kind: DeviceKind;
+    readonly enabled: boolean;
+    readonly requireApproval: boolean;
+    readonly maxChunkBytes: number;
+    readonly maxConcurrentSessions: number;
+    readonly sandbox?: string;
+    readonly network?: string;
+    /** Shared run accounting the device session must consume. */
+    readonly runLimits?: RunLimits;
+}
+export interface DevicePolicyOptions {
+    readonly maxChunkBytes?: number;
+    readonly maxConcurrentSessions?: number;
+    readonly runLimits?: RunLimits;
+}
+export declare function resolveDevicePolicy(adapter: DeviceAdapter, options?: DevicePolicyOptions): ResolvedDevicePolicy;
+export interface DeviceAdmitRequest {
+    /** Explicit host approval for this device side effect. */
+    readonly approved: boolean;
+    /** Currently active device sessions for this identity. */
+    readonly activeSessions: number;
+}
+/**
+ * Fail-closed admission gate. Denies unless the device is explicitly enabled,
+ * sandboxed, approved (when required), under the concurrent-session budget, and
+ * bound to shared run accounting. Side effects never replay after reconnect:
+ * hosts must re-admit on every resume.
+ */
+export declare function assertDeviceAdmit(policy: ResolvedDevicePolicy, request: DeviceAdmitRequest): void;
+export interface DeviceChunkResult {
+    readonly accepted: boolean;
+    readonly bytes: number;
+    /** Present when the chunk exceeded the stream bound and was dropped. */
+    readonly marker?: "dropped_oversize";
+}
+/** Stream bound: oversize audio/screenshot/stream chunks are dropped with a marker, never forwarded. */
+export declare function acceptDeviceChunk(policy: ResolvedDevicePolicy, bytes: number): DeviceChunkResult;
+/** Telemetry must be metadata-safe: apply the host redactor before any emit/persist. */
+export declare function redactDeviceTelemetry<T>(redactor: SecretRedactor | undefined, telemetry: T): T;
+export interface DeviceConformanceResult {
+    readonly passed: readonly string[];
+}
+/**
+ * Conformance pair for future voice / desktop-control adapters. Runs the
+ * deny-by-default fixtures (denial, approval, stream bounds, session budget,
+ * run accounting, redaction) against a resolved policy and throws on any
+ * regression. Tested in 0.0.14 via fixtures only.
+ */
+export declare function runDevicePolicyConformance(adapter: DeviceAdapter, options?: DevicePolicyOptions): DeviceConformanceResult;