@noodleseed/one 0.133.0 → 0.135.0

package/node_modules/@noodle-borg/assistant-gateway/dist/assistant-guide.d.ts

@@ -0,0 +1,39 @@
+import type { ArtifactTool, RuntimeArtifact } from '@noodle-borg/compiler';
+import { type ToolAuthorizationCaller } from '@noodle-borg/protocol';
+import { type SurfaceCapabilityRef } from './artifact-projection.js';
+/** Model-context budget for the embedded assistant's compact product workflow projection. */
+export declare const ASSISTANT_GUIDE_MAX_BYTES: number;
+export type AssistantGuideUnavailableReason = 'package_unavailable' | 'no_complete_workflow' | 'context_too_large';
+export type AssistantGuideProjection = {
+    readonly status: 'ready';
+    readonly guide: {
+        readonly content: string;
+        readonly workflowIds: readonly string[];
+        readonly byteLength: number;
+    };
+} | {
+    readonly status: 'unavailable';
+    readonly reason: AssistantGuideUnavailableReason;
+};
+/**
+ * Select the exact deployment tools an embedded model may see for this turn.
+ *
+ * A mixed anonymous surface deliberately advertises only its declared tools so the existing elevation
+ * interceptor can turn an attempted gated call into a sign-in offer. The selector performs that projection
+ * itself: callers cannot opt into sign-in offers without supplying the surface capability boundary. Every
+ * other caller gets the normal authorization filter. App-only tools never enter model tools or guidance.
+ */
+export declare function selectAssistantModelTools(artifact: RuntimeArtifact, caller: (ToolAuthorizationCaller & {
+    readonly identityKind?: string;
+}) | undefined, options?: {
+    readonly anonymousSignInOfferSurface?: readonly SurfaceCapabilityRef[];
+}): readonly ArtifactTool[];
+/**
+ * Build bounded product guidance from structured App Package data, never from rendered host files.
+ * Workflows are atomic: if one step is unavailable to this model, the entire workflow is omitted.
+ */
+export declare function projectAssistantGuide(input: {
+    readonly appPackage: unknown;
+    readonly modelTools: readonly ArtifactTool[];
+}): AssistantGuideProjection;
+//# sourceMappingURL=assistant-guide.d.ts.map

package/node_modules/@noodle-borg/assistant-gateway/dist/assistant-interaction-state.d.ts

@@ -0,0 +1,181 @@
+import type { InvocationContext } from '@noodle-borg/runtime';
+export declare const DEFAULT_MAX_PENDING_INTERACTIONS_PER_SESSION = 8;
+export declare const ASSISTANT_INTERACTION_OUTCOME_RETENTION_MS: number;
+/** Recovery grace for an in-flight action before its outcome becomes unknowable and payload is scrubbed. */
+export declare const ASSISTANT_INTERACTION_EXECUTING_GRACE_MS: number;
+export type AssistantInteractionKind = 'confirmation' | 'input';
+export type AssistantInteractionStatus = 'pending' | 'executing' | 'succeeded' | 'failed' | 'declined' | 'cancelled';
+export type AssistantInteractionPublicScalar = string | number | boolean | null;
+export interface AssistantInteractionPublicArray extends ReadonlyArray<AssistantInteractionPublicValue> {
+    readonly [index: number]: AssistantInteractionPublicValue;
+}
+export interface AssistantInteractionPublicObject {
+    readonly [key: string]: AssistantInteractionPublicValue;
+}
+export type AssistantInteractionPublicValue = AssistantInteractionPublicScalar | AssistantInteractionPublicArray | AssistantInteractionPublicObject;
+/** Compact replay-safe data only. Exact connector output and errors must never enter this shape. */
+export interface AssistantInteractionPublicOutcome {
+    readonly code: string;
+    readonly summary: string;
+    readonly details?: Readonly<Record<string, AssistantInteractionPublicScalar>>;
+    readonly result?: AssistantInteractionPublicValue;
+}
+export declare const ASSISTANT_INTERACTION_UNKNOWN_OUTCOME: AssistantInteractionPublicOutcome;
+interface AssistantInteractionCommon {
+    readonly id: string;
+    readonly sessionId: string;
+    readonly deploymentId: string;
+    /** Immutable proposal-time snapshot reused when the interaction resumes. */
+    readonly context?: InvocationContext;
+    /** Set when a terminal interaction's exact private payload has been removed. */
+    readonly payloadScrubbedAt?: string;
+    readonly createdAt: string;
+    readonly expiresAt: string;
+}
+interface AssistantConfirmationInteractionPayload {
+    readonly kind: 'confirmation';
+    readonly tool: string;
+    /** Exact validated arguments. Store-internal; renderers receive a separate review projection. */
+    readonly arguments: unknown;
+    /** Prepared post-elicitation execution state. Server-internal and absent on legacy proposals. */
+    readonly continuation?: unknown;
+    /** Complete, already-redacted review projection retained so a lost response can be replayed. */
+    readonly review?: unknown;
+}
+interface AssistantInputInteractionPayload {
+    readonly kind: 'input';
+    readonly tool: string;
+    readonly message: string;
+    readonly requestedSchema: Readonly<Record<string, unknown>>;
+    /** Exact runtime continuation. Store-internal and never part of the public interaction event. */
+    readonly continuation: unknown;
+}
+export interface AssistantPendingInteractionState {
+    readonly status: 'pending';
+}
+export interface AssistantExecutingInteractionState {
+    readonly status: 'executing';
+    readonly claimedAt: string;
+}
+export interface AssistantSucceededInteractionState {
+    readonly status: 'succeeded';
+    readonly claimedAt: string;
+    readonly completedAt: string;
+    readonly publicOutcome: AssistantInteractionPublicOutcome;
+}
+export interface AssistantFailedInteractionState {
+    readonly status: 'failed';
+    readonly claimedAt: string;
+    readonly completedAt: string;
+    readonly publicOutcome: AssistantInteractionPublicOutcome;
+}
+export interface AssistantDeclinedInteractionState {
+    readonly status: 'declined';
+    readonly completedAt: string;
+    readonly publicOutcome: AssistantInteractionPublicOutcome;
+}
+export interface AssistantCancelledInteractionState {
+    readonly status: 'cancelled';
+    readonly completedAt: string;
+    readonly publicOutcome: AssistantInteractionPublicOutcome;
+}
+export type AssistantInteractionState = AssistantPendingInteractionState | AssistantExecutingInteractionState | AssistantSucceededInteractionState | AssistantFailedInteractionState | AssistantDeclinedInteractionState | AssistantCancelledInteractionState;
+export type AssistantTerminalInteractionState = AssistantSucceededInteractionState | AssistantFailedInteractionState | AssistantDeclinedInteractionState | AssistantCancelledInteractionState;
+export type AssistantConfirmationInteractionRecord = AssistantInteractionCommon & AssistantConfirmationInteractionPayload & AssistantInteractionState;
+export type AssistantInputInteractionRecord = AssistantInteractionCommon & AssistantInputInteractionPayload & AssistantInteractionState;
+export type AssistantInteractionRecord = AssistantConfirmationInteractionRecord | AssistantInputInteractionRecord;
+export type AssistantPendingConfirmationInteractionRecord = AssistantInteractionCommon & AssistantConfirmationInteractionPayload & AssistantPendingInteractionState;
+export type AssistantPendingInputInteractionRecord = AssistantInteractionCommon & AssistantInputInteractionPayload & AssistantPendingInteractionState;
+export type AssistantPendingInteractionRecord = AssistantPendingConfirmationInteractionRecord | AssistantPendingInputInteractionRecord;
+interface AssistantInteractionCreateCommon {
+    readonly sessionId: string;
+    readonly deploymentId: string;
+    readonly context?: InvocationContext;
+    /** Omit only when the persistence adapter should stamp its own proposal time. */
+    readonly createdAt?: string;
+    readonly expiresAt: string;
+}
+export type AssistantConfirmationInteractionCreateInput = AssistantInteractionCreateCommon & Omit<AssistantConfirmationInteractionPayload, never>;
+export type AssistantInputInteractionCreateInput = AssistantInteractionCreateCommon & Omit<AssistantInputInteractionPayload, never>;
+export type AssistantInteractionCreateInput = AssistantConfirmationInteractionCreateInput | AssistantInputInteractionCreateInput;
+export interface AssistantInteractionScope {
+    readonly id: string;
+    readonly sessionId: string;
+    readonly deploymentId: string;
+    readonly now: Date;
+}
+export type AssistantInteractionClaimResult = {
+    readonly disposition: 'claimed';
+    readonly interaction: AssistantInteractionRecord & AssistantExecutingInteractionState;
+} | {
+    readonly disposition: 'replay';
+    readonly interaction: AssistantInteractionRecord;
+} | {
+    readonly disposition: 'unavailable';
+};
+export type AssistantInteractionCompletion = {
+    readonly status: 'succeeded' | 'failed';
+    readonly publicOutcome: AssistantInteractionPublicOutcome;
+} | {
+    readonly status: 'declined' | 'cancelled';
+    readonly publicOutcome?: AssistantInteractionPublicOutcome;
+};
+export type AssistantInteractionCompletionResult = {
+    readonly disposition: 'completed';
+    readonly interaction: AssistantInteractionRecord;
+} | {
+    readonly disposition: 'replay';
+    readonly interaction: AssistantInteractionRecord;
+} | {
+    readonly disposition: 'conflict';
+    readonly interaction: AssistantInteractionRecord;
+} | {
+    readonly disposition: 'unavailable';
+};
+export type AssistantInteractionTransitionNext = Omit<AssistantConfirmationInteractionCreateInput, 'sessionId' | 'deploymentId' | 'createdAt'> | Omit<AssistantInputInteractionCreateInput, 'sessionId' | 'deploymentId' | 'createdAt'>;
+/**
+ * Atomically records that an executing interaction handed control to one new pending interaction.
+ * The store owns the child identity and persists it in the parent's replay-safe public outcome.
+ */
+export interface AssistantInteractionTransitionInput extends AssistantInteractionScope {
+    readonly publicOutcome: AssistantInteractionPublicOutcome;
+    readonly next: AssistantInteractionTransitionNext;
+}
+export type AssistantInteractionTransitionResult = {
+    readonly disposition: 'transitioned';
+    readonly interaction: AssistantInteractionRecord & AssistantSucceededInteractionState;
+    readonly next: AssistantPendingInteractionRecord;
+} | {
+    readonly disposition: 'replay';
+    readonly interaction: AssistantInteractionRecord;
+} | {
+    readonly disposition: 'conflict';
+    readonly interaction: AssistantInteractionRecord;
+} | {
+    readonly disposition: 'unavailable';
+};
+export declare class AssistantInteractionCapacityError extends Error {
+    readonly code: "pending_interaction_limit";
+    constructor();
+}
+export declare function createPendingInteraction(id: string, input: AssistantConfirmationInteractionCreateInput): AssistantPendingConfirmationInteractionRecord;
+export declare function createPendingInteraction(id: string, input: AssistantInputInteractionCreateInput): AssistantPendingInputInteractionRecord;
+export declare function executingInteraction(interaction: AssistantInteractionRecord, claimedAt: Date): AssistantInteractionRecord & AssistantExecutingInteractionState;
+export declare function completedInteraction(interaction: AssistantInteractionRecord, completion: AssistantInteractionCompletion, completedAt: Date): AssistantInteractionRecord & AssistantTerminalInteractionState;
+export declare function transitionedInteractions(interaction: AssistantInteractionRecord, input: AssistantInteractionTransitionInput, nextId: string): {
+    readonly interaction: AssistantInteractionRecord & AssistantSucceededInteractionState;
+    readonly next: AssistantPendingInteractionRecord;
+};
+export declare function isTerminalInteraction(interaction: AssistantInteractionRecord): interaction is AssistantInteractionRecord & AssistantTerminalInteractionState;
+/**
+ * Pending proposals expire at their decision deadline. Executing/unknown work keeps a tombstone, and a
+ * terminal public outcome remains replayable for a bounded reconciliation window after completion.
+ */
+export declare function isPrunableInteraction(interaction: AssistantInteractionRecord, now: Date): boolean;
+export declare function shouldExpireStrandedExecutingInteraction(interaction: AssistantInteractionRecord, now: Date): interaction is AssistantInteractionRecord & AssistantExecutingInteractionState;
+/** Preserve a non-retryable unknown outcome without retaining its exact private payload. */
+export declare function expireStrandedExecutingInteraction(interaction: AssistantInteractionRecord & AssistantExecutingInteractionState, scrubbedAt: Date): AssistantInteractionRecord & AssistantFailedInteractionState;
+export declare function cloneInteraction<T extends AssistantInteractionRecord>(interaction: T): T;
+export declare function normalizePublicOutcome(input: AssistantInteractionPublicOutcome): AssistantInteractionPublicOutcome;
+export {};
+//# sourceMappingURL=assistant-interaction-state.d.ts.map

package/node_modules/@noodle-borg/assistant-gateway/dist/assistant-interactive.d.ts

@@ -0,0 +1,99 @@
+import { type RuntimeArtifact } from '@noodle-borg/compiler';
+import type { AuditSink } from '@noodle-borg/module';
+import type { CallerIdentity, ConfirmationPreparationResult, ExecuteDeps, InteractiveExecutionResult, InvocationContext, PreparedToolContinuation, ToolContinuation, ToolPreparationContinuation } from '@noodle-borg/runtime';
+import { type AssistantInteractionRecord, type AssistantInteractionTransitionNext, type AssistantPendingConfirmationInteractionRecord, type AssistantPendingInputInteractionRecord } from './assistant-interaction-state.js';
+import type { AssistantSessionRecord, AssistantStore } from './assistant-store.js';
+/**
+ * Single-use confirmation lifetime, owned by the admission envelope rather than restated here. The
+ * value is unchanged; what changes is that lowering `confirmationTtlMs` now does something, where
+ * before the envelope documented a bound this constant silently outranked.
+ */
+export declare const ASSISTANT_INTERACTION_TTL_MS: number;
+type InputRequired = Extract<InteractiveExecutionResult, {
+    readonly status: 'input_required';
+}> | Extract<ConfirmationPreparationResult, {
+    readonly status: 'input_required';
+}>;
+export type AssistantToolDispatch = {
+    readonly kind: 'event';
+    readonly event: 'tool_proposed' | 'input_requested' | 'error';
+    readonly data: Readonly<Record<string, unknown>>;
+} | {
+    readonly kind: 'tool_result';
+    readonly output: unknown;
+};
+/** Apply the same confirmation and suspend/resume policy to one model-proposed tool call. */
+export declare function dispatchAssistantTool(input: {
+    readonly artifact: RuntimeArtifact;
+    readonly tool: RuntimeArtifact['tools'][number];
+    readonly arguments: unknown;
+    readonly executeDeps: ExecuteDeps;
+    readonly caller: CallerIdentity;
+    readonly context: InvocationContext;
+    readonly session: AssistantSessionRecord;
+    readonly store: AssistantStore;
+    readonly audit: AuditSink;
+    readonly now: () => Date;
+    readonly onToolStarted?: () => void;
+}): Promise<AssistantToolDispatch>;
+/** Persist a complete, reviewable proposal and its server-only prepared execution state. */
+export declare function createAssistantConfirmationInteraction(input: {
+    readonly store: AssistantStore;
+    readonly audit: AuditSink;
+    readonly session: AssistantSessionRecord;
+    readonly context: InvocationContext;
+    readonly tool: string;
+    readonly arguments: unknown;
+    readonly review: unknown;
+    readonly continuation: PreparedToolContinuation;
+    readonly now: Date;
+}): Promise<AssistantPendingConfirmationInteractionRecord>;
+export declare function assistantConfirmationTransition(input: {
+    readonly context: InvocationContext;
+    readonly tool: string;
+    readonly arguments: unknown;
+    readonly review: unknown;
+    readonly continuation: PreparedToolContinuation;
+    readonly now: Date;
+}): Extract<AssistantInteractionTransitionNext, {
+    readonly kind: 'confirmation';
+}>;
+export declare function assistantConfirmationProposalData(interaction: AssistantPendingConfirmationInteractionRecord): Readonly<Record<string, unknown>>;
+/** Persist an opaque input interaction and audit only scalar metadata about the suspension. */
+export declare function createAssistantInputInteraction(input: {
+    readonly store: AssistantStore;
+    readonly audit: AuditSink;
+    readonly session: AssistantSessionRecord;
+    readonly context: InvocationContext;
+    readonly required: InputRequired;
+    readonly now: Date;
+}): Promise<AssistantPendingInputInteractionRecord>;
+export declare function assistantInputTransition(input: {
+    readonly context: InvocationContext;
+    readonly required: InputRequired;
+    readonly now: Date;
+}): Extract<AssistantInteractionTransitionNext, {
+    readonly kind: 'input';
+}>;
+/** Emit one tenant-scoped, scalar-only interaction audit record. */
+export declare function auditAssistantInteraction(input: {
+    readonly audit: AuditSink;
+    readonly session: AssistantSessionRecord;
+    readonly interaction: AssistantInteractionRecord;
+    readonly eventType: 'assistant.interaction.proposed' | 'assistant.interaction.resolved' | 'assistant.interaction.execution';
+    readonly decision: 'allow' | 'deny';
+    readonly httpStatus: number;
+    readonly status: string;
+    readonly action?: 'accept' | 'decline' | 'cancel';
+    readonly reasonCode?: string;
+}): Promise<void>;
+export declare function assistantInteractionTool(interaction: AssistantInteractionRecord): string | undefined;
+/** The store is the only trust boundary allowed to deserialize this runtime continuation. */
+export declare function assistantToolContinuation(interaction: Extract<AssistantInteractionRecord, {
+    readonly kind: 'input';
+}>): ToolContinuation | ToolPreparationContinuation;
+export declare function assistantPreparedToolContinuation(interaction: Extract<AssistantInteractionRecord, {
+    readonly kind: 'confirmation';
+}>): PreparedToolContinuation | undefined;
+export {};
+//# sourceMappingURL=assistant-interactive.d.ts.map

package/node_modules/@noodle-borg/assistant-gateway/dist/assistant-interactive.js

@@ -1,4 +1,4 @@
-import { ADMISSION_DEFAULTS } from '@noodle-borg/admission-limits';
+import { ADMISSION_DEFAULTS } from '@noodle-borg/admission-limits/portable';
 import { requiresToolConfirmation } from '@noodle-borg/compiler';
 import { evaluateToolAuthorization } from '@noodle-borg/protocol';
 import { executeToolInteractive, prepareToolForConfirmation } from '@noodle-borg/runtime';

package/node_modules/@noodle-borg/assistant-gateway/dist/assistant-presentation.d.ts

@@ -0,0 +1,35 @@
+import { type ConfirmationReview } from '@noodle-borg/runtime';
+type JsonSchema = Readonly<Record<string, unknown>>;
+type AssistantPresentationScalar = string | number | boolean | null;
+interface AssistantPresentationArray extends ReadonlyArray<AssistantPresentationValue> {
+}
+interface AssistantPresentationObject {
+    readonly [key: string]: AssistantPresentationValue;
+}
+export type AssistantPresentationValue = AssistantPresentationScalar | AssistantPresentationArray | AssistantPresentationObject;
+type ArgumentReview = {
+    readonly ok: true;
+    readonly value: unknown;
+    readonly reviewSchema: JsonSchema;
+} | {
+    readonly ok: false;
+    readonly code: 'arguments_not_presentable';
+};
+/** Derive a client-visible review while retaining the exact validated arguments only in the store. */
+export declare function assistantArgumentReview(schema: JsonSchema, value: unknown): ArgumentReview;
+/** Present the original tool input plus every elicited value that will affect prepared execution. */
+export declare function assistantPreparedArgumentReview(schema: JsonSchema, review: ConfirmationReview): ArgumentReview;
+/** Attach portable display metadata to the already-persisted review JSON without changing execution input. */
+export declare function assistantConfirmationReview(input: {
+    readonly title?: string;
+    readonly description: string;
+    readonly review: Extract<ArgumentReview, {
+        readonly ok: true;
+    }>;
+}): Readonly<Record<string, unknown>>;
+/** Decode enriched and legacy persisted reviews into the additive public proposal shape. */
+export declare function assistantConfirmationProposal(review: unknown): Readonly<Record<string, unknown>>;
+/** Redact and bound execution output before SSE, history, audit, or model narration. */
+export declare function assistantSafeOutput(schema: JsonSchema | undefined, value: unknown): AssistantPresentationValue;
+export {};
+//# sourceMappingURL=assistant-presentation.d.ts.map

package/node_modules/@noodle-borg/assistant-gateway/dist/assistant-sensitive-values.d.ts

@@ -0,0 +1,3 @@
+/** Catch common credential shapes even when a connector returns them under an innocuous key. */
+export declare function isCredentialShapedAssistantText(value: string): boolean;
+//# sourceMappingURL=assistant-sensitive-values.d.ts.map

package/node_modules/@noodle-borg/assistant-gateway/dist/assistant-store.d.ts

@@ -0,0 +1,226 @@
+import type { ArtifactServer } from '@noodle-borg/compiler';
+import type { CallerIdentity } from '@noodle-borg/runtime';
+import type { AssistantContextPreferences } from './assistant-context.js';
+import type { AssistantCustomerRouting } from './assistant-customer-routing.js';
+import { type AssistantInteractionClaimResult, type AssistantInteractionCompletionResult, type AssistantInteractionCreateInput, type AssistantInteractionRecord, type AssistantInteractionScope, type AssistantInteractionTransitionInput, type AssistantInteractionTransitionResult, type AssistantPendingConfirmationInteractionRecord, type AssistantPendingInputInteractionRecord } from './assistant-interaction-state.js';
+import type { TenantRef } from './tenant-ref.js';
+export { ASSISTANT_INTERACTION_EXECUTING_GRACE_MS, ASSISTANT_INTERACTION_OUTCOME_RETENTION_MS, type AssistantConfirmationInteractionRecord, AssistantInteractionCapacityError, type AssistantInteractionClaimResult, type AssistantInteractionCompletion, type AssistantInteractionCompletionResult, type AssistantInteractionCreateInput, type AssistantInteractionKind, type AssistantInteractionPublicArray, type AssistantInteractionPublicObject, type AssistantInteractionPublicOutcome, type AssistantInteractionPublicValue, type AssistantInteractionRecord, type AssistantInteractionScope, type AssistantInteractionStatus, type AssistantInteractionTransitionInput, type AssistantInteractionTransitionNext, type AssistantInteractionTransitionResult, type AssistantPendingConfirmationInteractionRecord, type AssistantPendingInputInteractionRecord, DEFAULT_MAX_PENDING_INTERACTIONS_PER_SESSION, } from './assistant-interaction-state.js';
+export declare const ASSISTANT_SESSION_IDLE_MS: number;
+/**
+ * The only `server.assistant` fields that may reach a browser.
+ *
+ * It lives here, beside the record it types, so the allowlist and the shape it produces cannot drift
+ * apart: the projection in `packages/service` iterates this same list. A denylist here would be a type
+ * that lies — it once admitted `sessionClaims` key names, and would now admit the public surface's
+ * capability allowlist — so growth in the manifest must not be able to grow the browser payload.
+ */
+export declare const ASSISTANT_BROWSER_UI_FIELDS: readonly ["layout", "behavior", "labels", "presentation", "suggestedPrompts", "privacyUrl", "termsUrl", "locale", "direction"];
+export interface AssistantClientRecord {
+    readonly id: string;
+    readonly name: string;
+    readonly tenant: TenantRef;
+    readonly deploymentId: string;
+    readonly allowedOrigins: readonly string[];
+    readonly secretHash: string;
+    readonly createdAt: string;
+    readonly revokedAt?: string;
+}
+export interface AssistantSessionRecord {
+    readonly id: string;
+    readonly tokenHash: string;
+    readonly clientId: string;
+    readonly tenant: TenantRef;
+    readonly deploymentId: string;
+    readonly origin: string;
+    readonly caller: CallerIdentity;
+    /** Canonical customer endpoint routes; private session authority, never caller or response data. */
+    readonly customerRouting?: AssistantCustomerRouting;
+    readonly context?: Readonly<Record<string, string | number | boolean | null>>;
+    readonly preferences?: AssistantContextPreferences;
+    readonly configuration?: {
+        readonly branding?: ArtifactServer['branding'];
+        readonly assistant?: Pick<NonNullable<ArtifactServer['assistant']>, (typeof ASSISTANT_BROWSER_UI_FIELDS)[number]>;
+    };
+    /**
+     * The public surface this session was minted from, when it was minted anonymously from a page rather
+     * than exchanged through a customer backend. It is the key admission spends against, so it stays on
+     * the record for the session's whole life — including after a mixed surface elevates the caller, whose
+     * turns still belong to the surface that admitted them.
+     */
+    readonly publicEmbedId?: string;
+    /**
+     * The intercepted tool a successful elevation may re-attempt as the session's first elevated
+     * turn. Armed only in the same statement that elevates; consumed (or mooted by the visitor's
+     * first typed turn) exactly once via {@link AssistantStore.consumePendingResume}.
+     */
+    readonly pendingResume?: AssistantPendingResume;
+    readonly createdAt: string;
+    readonly expiresAt: string;
+    readonly absoluteExpiresAt: string;
+    readonly history: AssistantHistoryMessage[];
+    /**
+     * Model turns already spent. Durable and separate from `history`, which truncates to the last twelve
+     * messages: history is a prompt-window trim, never a bound.
+     */
+    readonly turnCount: number;
+}
+/** The intercepted call a spent sign-in ticket left pending, resumable at most once. */
+export interface AssistantPendingResume {
+    readonly tool: string;
+    readonly requestedAt: string;
+}
+/** One consumed turn slot, or the refusal that the session has spent its allowance. */
+export interface AssistantTurnConsumption {
+    readonly allowed: boolean;
+    readonly turnCount: number;
+}
+export interface AssistantHistoryMessage {
+    readonly role: 'user' | 'assistant';
+    readonly content: string;
+}
+export type AssistantSessionElevation = {
+    readonly ok: true;
+    readonly session: AssistantSessionRecord;
+    /** The replacement token. The value it replaces is dead the moment this returns. */
+    readonly token: string;
+} | {
+    readonly ok: false;
+    readonly reason: 'unknown_session' | 'already_elevated';
+};
+export interface AssistantStore {
+    createClient(input: {
+        readonly name: string;
+        readonly tenant: TenantRef;
+        readonly deploymentId: string;
+        readonly allowedOrigins: readonly string[];
+        readonly now: Date;
+    }): Promise<{
+        readonly client: AssistantClientRecord;
+        readonly secret: string;
+    }>;
+    listClients(tenant: TenantRef): Promise<readonly AssistantClientRecord[]>;
+    rotateClient(id: string, now: Date): Promise<{
+        readonly client: AssistantClientRecord;
+        readonly secret: string;
+    } | undefined>;
+    revokeClient(id: string, now: Date): Promise<boolean>;
+    authenticateClient(id: string, secret: string): Promise<AssistantClientRecord | undefined>;
+    createSession(input: Omit<AssistantSessionRecord, 'id' | 'tokenHash' | 'history' | 'turnCount'>): Promise<{
+        readonly session: AssistantSessionRecord;
+        readonly token: string;
+    }>;
+    /**
+     * Spend one turn if the session has one left, atomically. This is one seam rather than a
+     * read-then-write in the route because two turns arriving together at the last slot is precisely the
+     * race a read-then-write loses. A refused turn does not advance the count.
+     */
+    consumeTurn(id: string, limit: number): Promise<AssistantTurnConsumption>;
+    /**
+     * Bind an already-open conversation to a signed-in caller (ADR 0201, 5.6b).
+     *
+     * One seam, and one row: the session is **mutated in place** rather than replaced, so the visitor
+     * keeps the conversation they were having. The old token dies with the same statement that installs
+     * the new one, which is why this is not a read-then-write — an elevation that left the anonymous
+     * token briefly alive would be a window in which both identities could act.
+     *
+     * `publicEmbedId` is deliberately retained: admission keeps charging the surface that admitted the
+     * visitor, exactly as 5.4 designed when it chose to key sessions on the embed rather than on being
+     * anonymous. Refuses when the session is already non-anonymous, which is what makes a second
+     * elevation impossible without a separate check to forget.
+     */
+    elevateSession(input: {
+        readonly sessionId: string;
+        readonly caller: AssistantSessionRecord['caller'];
+        /** The elevating client: becomes the session's delegated-credential issuer basis (ADR 0152). */
+        readonly clientId: string;
+        /** Allowlist-validated by the route: becomes the session's CORS pin, where the conversation continues. */
+        readonly origin: string;
+        /** Backend-verified customer routes; absent means unchanged, never cleared. */
+        readonly customerRouting?: AssistantSessionRecord['customerRouting'];
+        /** Arms the one-shot resume of the intercepted tool, in the same statement that elevates. */
+        readonly pendingResume?: AssistantPendingResume;
+        readonly now: Date;
+    }): Promise<AssistantSessionElevation>;
+    /**
+     * Clear and return the pending resume exactly once, atomically — the turn route calls this both
+     * to run the resume and to moot it when the visitor types first, and two requests racing the
+     * same arm must not both see it.
+     */
+    consumePendingResume(sessionId: string): Promise<AssistantPendingResume | undefined>;
+    getSession(token: string, now: Date): Promise<AssistantSessionRecord | undefined>;
+    appendHistory(id: string, messages: readonly AssistantHistoryMessage[]): Promise<void>;
+    createInteraction(input: Extract<AssistantInteractionCreateInput, {
+        readonly kind: 'confirmation';
+    }>): Promise<AssistantPendingConfirmationInteractionRecord>;
+    createInteraction(input: Extract<AssistantInteractionCreateInput, {
+        readonly kind: 'input';
+    }>): Promise<AssistantPendingInputInteractionRecord>;
+    claimInteraction(input: AssistantInteractionScope): Promise<AssistantInteractionClaimResult>;
+    completeInteraction(input: AssistantInteractionScope & {
+        readonly completion: import('./assistant-interaction-state.js').AssistantInteractionCompletion;
+    }): Promise<AssistantInteractionCompletionResult>;
+    transitionInteraction(input: AssistantInteractionTransitionInput): Promise<AssistantInteractionTransitionResult>;
+    getInteraction(input: AssistantInteractionScope): Promise<AssistantInteractionRecord | undefined>;
+    /** @deprecated Temporary compatibility for the accept-only route while it moves to claim/complete. */
+    consumeInteraction(id: string, sessionId: string, deploymentId: string, now: Date): Promise<(import('./assistant-interaction-state.js').AssistantConfirmationInteractionRecord & {
+        readonly status: 'executing';
+    }) | undefined>;
+    consumeConsoleApprovalNonce(nonce: string, subject: string, expiresAt: Date, now: Date): Promise<boolean>;
+}
+export declare class InMemoryAssistantStore implements AssistantStore {
+    #private;
+    constructor(options?: {
+        readonly maxPendingInteractionsPerSession?: number;
+    });
+    createClient(input: {
+        readonly name: string;
+        readonly tenant: TenantRef;
+        readonly deploymentId: string;
+        readonly allowedOrigins: readonly string[];
+        readonly now: Date;
+    }): Promise<{
+        readonly client: AssistantClientRecord;
+        readonly secret: string;
+    }>;
+    listClients(tenant: TenantRef): Promise<readonly AssistantClientRecord[]>;
+    rotateClient(id: string, now: Date): Promise<{
+        readonly client: AssistantClientRecord;
+        readonly secret: string;
+    } | undefined>;
+    revokeClient(id: string, now: Date): Promise<boolean>;
+    authenticateClient(id: string, secret: string): Promise<AssistantClientRecord | undefined>;
+    createSession(input: Omit<AssistantSessionRecord, 'id' | 'tokenHash' | 'history' | 'turnCount'>): Promise<{
+        readonly session: AssistantSessionRecord;
+        readonly token: string;
+    }>;
+    elevateSession(input: {
+        readonly sessionId: string;
+        readonly caller: AssistantSessionRecord['caller'];
+        readonly clientId: string;
+        readonly origin: string;
+        readonly customerRouting?: AssistantSessionRecord['customerRouting'];
+        readonly pendingResume?: AssistantPendingResume;
+        readonly now: Date;
+    }): Promise<AssistantSessionElevation>;
+    consumePendingResume(sessionId: string): Promise<AssistantPendingResume | undefined>;
+    consumeTurn(id: string, limit: number): Promise<AssistantTurnConsumption>;
+    getSession(token: string, now: Date): Promise<AssistantSessionRecord | undefined>;
+    appendHistory(id: string, messages: readonly AssistantHistoryMessage[]): Promise<void>;
+    createInteraction(input: Extract<AssistantInteractionCreateInput, {
+        readonly kind: 'confirmation';
+    }>): Promise<AssistantPendingConfirmationInteractionRecord>;
+    createInteraction(input: Extract<AssistantInteractionCreateInput, {
+        readonly kind: 'input';
+    }>): Promise<AssistantPendingInputInteractionRecord>;
+    claimInteraction(input: AssistantInteractionScope): Promise<AssistantInteractionClaimResult>;
+    completeInteraction(input: AssistantInteractionScope & {
+        readonly completion: import('./assistant-interaction-state.js').AssistantInteractionCompletion;
+    }): Promise<AssistantInteractionCompletionResult>;
+    transitionInteraction(input: AssistantInteractionTransitionInput): Promise<AssistantInteractionTransitionResult>;
+    getInteraction(input: AssistantInteractionScope): Promise<AssistantInteractionRecord | undefined>;
+    consumeInteraction(id: string, sessionId: string, deploymentId: string, now: Date): Promise<(import('./assistant-interaction-state.js').AssistantConfirmationInteractionRecord & {
+        readonly status: 'executing';
+    }) | undefined>;
+    consumeConsoleApprovalNonce(nonce: string, subject: string, expiresAt: Date, now: Date): Promise<boolean>;
+}
+//# sourceMappingURL=assistant-store.d.ts.map

package/node_modules/@noodle-borg/assistant-gateway/dist/assistant-store.js

@@ -1,5 +1,5 @@
 import { createHash, randomBytes, randomUUID, timingSafeEqual } from 'node:crypto';
-import { ADMISSION_DEFAULTS } from '@noodle-borg/admission-limits';
+import { ADMISSION_DEFAULTS } from '@noodle-borg/admission-limits/portable';
 import { AssistantInteractionCapacityError, cloneInteraction, completedInteraction, createPendingInteraction, DEFAULT_MAX_PENDING_INTERACTIONS_PER_SESSION, executingInteraction, expireStrandedExecutingInteraction, isPrunableInteraction, isTerminalInteraction, shouldExpireStrandedExecutingInteraction, transitionedInteractions, } from './assistant-interaction-state.js';
 export { ASSISTANT_INTERACTION_EXECUTING_GRACE_MS, ASSISTANT_INTERACTION_OUTCOME_RETENTION_MS, AssistantInteractionCapacityError, DEFAULT_MAX_PENDING_INTERACTIONS_PER_SESSION, } from './assistant-interaction-state.js';
 export const ASSISTANT_SESSION_IDLE_MS = 30 * 60 * 1000;