@noodleseed/one 0.170.0 → 0.171.0

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

@@ -0,0 +1,221 @@
+import { randomUUID } from 'node:crypto';
+import { channelBlocked, requireChannel } from './channel-coordinator.js';
+import { channelCounter } from './channel-inbox.js';
+import { CHANNEL_DAY_MS, CHANNEL_RETENTION_MS, ChannelError, channelDigest, channelRow, channelValue, writeChannelEvent, } from './channel-types.js';
+const LEASE_MS = 30_000;
+async function pendingEvents(tx, id) {
+    const events = [];
+    for (const state of ['queued', 'running', 'reply', 'sending'])
+        events.push(...(await tx.list(id, { kind: 'event', state, limit: 1000 })).map((row) => row.value));
+    return events.sort((a, b) => (a.id < b.id ? -1 : a.id > b.id ? 1 : 0));
+}
+async function disallowed(tx, binding, event, now) {
+    if (binding.state !== 'enabled' ||
+        binding.generation !== event.generation ||
+        binding.deploymentId !== event.deploymentId)
+        return 'authority_changed';
+    if (await channelBlocked(tx, binding.id, event.participantId, now))
+        return 'blocked';
+    return undefined;
+}
+async function reconcile(tx, binding, now) {
+    const pending = await pendingEvents(tx, binding.id);
+    const live = [];
+    for (const event of pending) {
+        const invalid = await disallowed(tx, binding, event, now);
+        let updated = event;
+        if (event.state === 'sending') {
+            if ((event.leaseUntil ?? 0) <= now)
+                updated = { ...event, state: 'unknown', code: 'send_lease_expired' };
+        }
+        else if (invalid)
+            updated = { ...event, state: 'cancelled', code: invalid };
+        else if (event.state === 'running' && (event.leaseUntil ?? 0) <= now)
+            updated = {
+                ...event,
+                state: event.attempts >= 3 || now - event.receivedAt > 300_000 ? 'failed' : 'queued',
+                code: 'worker_lease_expired',
+            };
+        else if ((event.state === 'queued' || event.state === 'reply') &&
+            now - event.receivedAt > 300_000)
+            updated = { ...event, state: 'expired', code: 'work_deadline' };
+        if (updated !== event)
+            await writeChannelEvent(tx, binding.id, updated, now);
+        if (['queued', 'running', 'reply', 'sending'].includes(updated.state))
+            live.push(updated);
+    }
+    return live;
+}
+export async function claimChannelTurn(store, id, now, retentionMs = CHANNEL_RETENTION_MS) {
+    return store.transaction([id], async (tx) => {
+        const binding = await requireChannel(tx, id);
+        const events = await reconcile(tx, binding, now);
+        if (binding.state !== 'enabled' ||
+            events.filter((event) => event.state === 'running').length >= binding.limits.concurrent)
+            return undefined;
+        const candidate = events.find((event, index) => event.state === 'queued' &&
+            !events.slice(0, index).some((older) => older.participantId === event.participantId));
+        if (!candidate)
+            return undefined;
+        const participant = await channelValue(tx, id, candidate.participantId);
+        if (!participant || participant.lastInboundAt < now - retentionMs) {
+            await writeChannelEvent(tx, id, { ...candidate, state: 'cancelled', code: 'context_expired' }, now);
+            return undefined;
+        }
+        const event = {
+            ...candidate,
+            state: 'running',
+            attempts: candidate.attempts + 1,
+            lease: randomUUID(),
+            leaseUntil: now + LEASE_MS,
+            turnDeadline: now + 60_000,
+        };
+        await writeChannelEvent(tx, id, event, now);
+        return {
+            binding,
+            event,
+            participant: {
+                ...participant,
+                history: participant.history.filter((entry) => entry.at > now - retentionMs).slice(-20),
+            },
+        };
+    });
+}
+async function leased(tx, id, eventId, lease, now) {
+    const event = await channelValue(tx, id, eventId);
+    if (!event ||
+        event.state !== 'running' ||
+        event.lease !== lease ||
+        (event.leaseUntil ?? 0) <= now ||
+        (event.turnDeadline ?? 0) <= now)
+        throw new ChannelError('lease_lost');
+    if (await disallowed(tx, await requireChannel(tx, id), event, now))
+        throw new ChannelError('authority_changed');
+    return event;
+}
+export async function renewChannelTurn(store, id, eventId, lease, now) {
+    await store.transaction([id], async (tx) => {
+        const event = await leased(tx, id, eventId, lease, now);
+        await writeChannelEvent(tx, id, { ...event, leaseUntil: Math.min(now + LEASE_MS, event.turnDeadline) }, now);
+    });
+}
+export async function completeChannelTurn(store, id, eventId, lease, reply, now, retentionMs = CHANNEL_RETENTION_MS, code) {
+    if (!reply.trim() || reply.length > 4096)
+        throw new ChannelError('reply_invalid');
+    await store.transaction([id], async (tx) => {
+        const event = await leased(tx, id, eventId, lease, now);
+        const participant = await channelValue(tx, id, event.participantId);
+        if (!participant)
+            throw new ChannelError('context_expired');
+        const history = [
+            ...participant.history.filter((entry) => entry.at > now - retentionMs),
+            { role: 'user', content: event.text ?? '', at: event.receivedAt },
+            { role: 'assistant', content: reply, at: now },
+        ].slice(-20);
+        await tx.put(id, channelRow(participant.id, 'participant', { ...participant, history }, now, {
+            expiresAt: participant.lastInboundAt + retentionMs,
+        }));
+        await writeChannelEvent(tx, id, {
+            ...event,
+            reply,
+            state: 'reply',
+            lease: undefined,
+            leaseUntil: undefined,
+            ...(code ? { code } : {}),
+        }, now);
+    });
+}
+export async function prepareChannelSend(store, id, now) {
+    return store.transaction([id], async (tx) => {
+        const binding = await requireChannel(tx, id);
+        const events = await reconcile(tx, binding, now);
+        if (binding.state !== 'enabled')
+            return undefined;
+        const candidate = events.find((event, index) => event.state === 'reply' &&
+            !events.slice(0, index).some((older) => older.participantId === event.participantId));
+        if (!candidate)
+            return undefined;
+        const participant = await channelValue(tx, id, candidate.participantId);
+        if (!participant || participant.lastInboundAt + CHANNEL_DAY_MS <= now) {
+            await writeChannelEvent(tx, id, { ...candidate, state: 'expired', code: 'reply_window_closed' }, now);
+            return undefined;
+        }
+        const event = {
+            ...candidate,
+            state: 'sending',
+            lease: randomUUID(),
+            leaseUntil: now + LEASE_MS,
+        };
+        await writeChannelEvent(tx, id, event, now);
+        return { binding, event, participant };
+    });
+}
+export async function updateChannelSend(store, id, eventId, lease, result, now) {
+    await store.transaction([id], async (tx) => {
+        const event = await channelValue(tx, id, eventId);
+        if (!event || event.lease !== lease || !['sending', 'unknown'].includes(event.state))
+            throw new ChannelError('lease_lost');
+        if (result.state === 'accepted' && !result.providerMessageId)
+            throw new ChannelError('provider_receipt_missing');
+        const early = result.providerMessageId
+            ? await channelValue(tx, id, `delivery:${channelDigest(result.providerMessageId)}`)
+            : undefined;
+        await writeChannelEvent(tx, id, {
+            ...event,
+            ...result,
+            ...(early && early !== 'sent' ? { state: early } : {}),
+            leaseUntil: undefined,
+        }, now);
+        if (result.providerMessageId)
+            await tx.put(id, channelRow(`receipt:${channelDigest(result.providerMessageId)}`, 'mutation', eventId, now, {
+                expiresAt: event.receivedAt + CHANNEL_RETENTION_MS,
+            }));
+    });
+}
+export async function recordChannelDelivery(store, id, providerMessageId, state, now) {
+    await store.transaction([id], async (tx) => {
+        await requireChannel(tx, id);
+        const eventId = await channelValue(tx, id, `receipt:${channelDigest(providerMessageId)}`);
+        if (!eventId) {
+            // A delivery callback can beat the response that supplies its message id. Bound this
+            // authenticated evidence separately, then join it when the acceptance receipt commits.
+            const key = `delivery:${channelDigest(providerMessageId)}`;
+            const prior = await channelValue(tx, id, key);
+            if (!prior) {
+                if ((await channelCounter(tx, id, 'delivery-ingress', now, CHANNEL_DAY_MS)) >= 10_000)
+                    throw new ChannelError('ingress_capacity');
+                await channelCounter(tx, id, 'delivery-ingress', now, CHANNEL_DAY_MS, 1);
+            }
+            const order = { sent: 0, failed: 1, delivered: 2, read: 3 };
+            if (!prior || order[state] > order[prior])
+                await tx.put(id, channelRow(key, 'mutation', state, now, { expiresAt: now + CHANNEL_RETENTION_MS }));
+            return;
+        }
+        const event = await channelValue(tx, id, eventId);
+        if (!event)
+            return;
+        const next = state === 'sent' ? 'accepted' : state;
+        const rank = { sending: 0, unknown: 0, accepted: 1, failed: 2, delivered: 3, read: 4 };
+        if (!(event.state in rank) || rank[next] <= rank[event.state])
+            return;
+        await writeChannelEvent(tx, id, { ...event, state: next }, now);
+    });
+}
+/** Last local fence before the adapter starts external IO; already dispatched work cannot be recalled. */
+export async function assertChannelSend(store, id, eventId, lease, now) {
+    await store.transaction([id], async (tx) => {
+        const event = await channelValue(tx, id, eventId);
+        const binding = await requireChannel(tx, id);
+        if (!event ||
+            event.state !== 'sending' ||
+            event.lease !== lease ||
+            (event.leaseUntil ?? 0) <= now)
+            throw new ChannelError('lease_lost');
+        if (await disallowed(tx, binding, event, now))
+            throw new ChannelError('authority_changed');
+        const participant = await channelValue(tx, id, event.participantId);
+        if (!participant || participant.lastInboundAt + CHANNEL_DAY_MS <= now)
+            throw new ChannelError('reply_window_closed');
+    });
+}
+//# sourceMappingURL=channel-work.js.map

package/node_modules/@noodle-borg/assistant-gateway/dist/messaging-tool-dispatch.d.ts

@@ -0,0 +1,15 @@
+import { type RuntimeArtifact } from '@noodle-borg/compiler';
+import { type ExecuteDeps, type InvocationContext } from '@noodle-borg/runtime';
+import type { AssistantToolDispatch } from './assistant-interactive.js';
+import { type MessagingTurnContext } from './assistant-turn-context.js';
+/** Read-only transport adapter over the same authorized runtime; native interactions are a later slice. */
+export declare function dispatchMessagingReadTool(input: {
+    readonly artifact: RuntimeArtifact;
+    readonly tool: RuntimeArtifact['tools'][number];
+    readonly arguments: unknown;
+    readonly executeDeps: ExecuteDeps;
+    readonly context: InvocationContext;
+    readonly session: MessagingTurnContext;
+    readonly claimTool: (name: string) => Promise<boolean>;
+}): Promise<AssistantToolDispatch>;
+//# sourceMappingURL=messaging-tool-dispatch.d.ts.map

package/node_modules/@noodle-borg/assistant-gateway/dist/messaging-tool-dispatch.js

@@ -0,0 +1,34 @@
+import { requiresToolConfirmation } from '@noodle-borg/compiler';
+import { evaluateToolAuthorization } from '@noodle-borg/protocol';
+import { executeToolInteractive, } from '@noodle-borg/runtime';
+import { assistantModelToolOncePerSession } from './assistant-guide.js';
+import { assistantSafeOutput } from './assistant-presentation.js';
+import { withAssistantTurnExecutionAuthority, } from './assistant-turn-context.js';
+/** Read-only transport adapter over the same authorized runtime; native interactions are a later slice. */
+export async function dispatchMessagingReadTool(input) {
+    const denied = (code) => ({
+        kind: 'event',
+        event: 'error',
+        data: { code, retryable: false },
+    });
+    if (input.tool.annotations?.readOnlyHint !== true ||
+        requiresToolConfirmation(input.tool.annotations) ||
+        input.tool._meta?.ui)
+        return denied('messaging_action_unsupported');
+    if (!evaluateToolAuthorization(input.tool.authorization, input.session.caller).allow)
+        return denied('tool_forbidden');
+    if (assistantModelToolOncePerSession(input.tool) && !(await input.claimTool(input.tool.name)))
+        return denied('invalid_model_tool_call');
+    const result = await executeToolInteractive(input.artifact, input.tool.name, input.arguments, {
+        ...withAssistantTurnExecutionAuthority(input.executeDeps, input.artifact, input.session),
+        caller: input.session.caller,
+        context: input.context,
+    });
+    if (result.status !== 'completed')
+        return denied(result.status === 'failed' ? result.error.code : 'messaging_action_unsupported');
+    return {
+        kind: 'tool_result',
+        output: assistantSafeOutput(input.tool.outputSchema, result.output),
+    };
+}
+//# sourceMappingURL=messaging-tool-dispatch.js.map

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

@@ -1,4 +1,4 @@
-import { type ModelCompletion, type ModelToolCall } from './model-stream.js';
+import { type ModelCompletion, type ModelToolCall, type ModelUsage } from './model-stream.js';
 export type AssistantModelSource = 'operator' | 'noodle-managed';
 export type AssistantModelTransport = 'chat-completions' | 'responses';
 export interface AssistantModelRequestPolicy {
@@ -16,7 +16,24 @@ export interface AssistantModelRequestPolicy {
     /** Trusted operator-selected OpenAI-compatible request extensions. */
     readonly extraBody?: Readonly<Record<string, unknown>>;
 }
+export interface AssistantInferenceCostBound {
+    readonly version: string;
+    readonly validUntil: string;
+    readonly maxInputTokens: number;
+    /** Includes every billed output token, including hidden reasoning. */
+    readonly maxBilledOutputTokens: number;
+    readonly inputMicroUsdPerMillionTokens: number;
+    readonly outputMicroUsdPerMillionTokens: number;
+}
 interface ResolvedAssistantModelBase {
+    /** Deployment/provider-owned verified bound for this exact resolved model, never tenant-supplied. */
+    readonly inferenceCost?: AssistantInferenceCostBound;
+    readonly inferenceGuard?: {
+        reserve(): Promise<{
+            settle(usage: ModelUsage): Promise<void>;
+            cancelBeforeDispatch?(): Promise<void>;
+        }>;
+    };
     readonly source: AssistantModelSource;
     readonly transport?: AssistantModelTransport;
     readonly baseUrl: string;
@@ -64,6 +81,7 @@ export type ResolvedAssistantModel = ResolvedAssistantModelBase & ({
 });
 export interface ManagedAssistantModelResolver {
     resolve(input: {
+        readonly channel?: 'whatsapp';
         readonly tenant: {
             readonly org: string;
             readonly app: string;

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

@@ -1,6 +1,6 @@
 import { AssistantModelError, managedSponsorshipExhausted, managedSponsorshipUnavailable, modelFetchError, modelHttpError, modelRequestError, modelResponseError, } from './model-error.js';
 import { readResponsesCompletion, responsesInput, responsesTools } from './model-responses.js';
-import { readModelCompletion } from './model-stream.js';
+import { readModelCompletion, } from './model-stream.js';
 export async function requestModelCompletion(input) {
     const { binding } = input;
     const transport = binding.transport ?? 'chat-completions';
@@ -36,10 +36,21 @@ export async function requestModelCompletion(input) {
     if (maxRequestBytes !== undefined && requestBytes > maxRequestBytes) {
         throw modelRequestError('model request too large');
     }
-    await admitSponsorship(binding);
-    const bearerToken = binding.apiKey ?? (await binding.bearerToken());
-    if (!/^[^\s]{1,8192}$/.test(bearerToken)) {
-        throw modelRequestError('invalid model bearer token');
+    input.signal?.throwIfAborted();
+    const reservation = await binding.inferenceGuard?.reserve();
+    let bearerToken;
+    try {
+        // Channel work can recover as a new paid attempt; each request consumes funding authority.
+        await admitSponsorship(binding.inferenceGuard ? { ...binding } : binding);
+        input.signal?.throwIfAborted();
+        bearerToken = binding.apiKey ?? (await binding.bearerToken());
+        if (!/^[^\s]{1,8192}$/.test(bearerToken))
+            throw modelRequestError('invalid model bearer token');
+        input.signal?.throwIfAborted();
+    }
+    catch (error) {
+        await reservation?.cancelBeforeDispatch?.();
+        throw error;
     }
     const timeoutSignal = AbortSignal.timeout(binding.requestPolicy?.timeoutMs ?? 30_000);
     let response;
@@ -58,7 +69,12 @@ export async function requestModelCompletion(input) {
     if (!response.ok)
         throw modelHttpError(response.status);
     try {
-        return await (transport === 'responses' ? readResponsesCompletion : readModelCompletion)(response, input.onContent ?? (() => undefined), input.maxResponseBytes);
+        const completion = await (transport === 'responses'
+            ? readResponsesCompletion
+            : readModelCompletion)(response, input.onContent ?? (() => undefined), input.maxResponseBytes);
+        if (completion.usage)
+            await reservation?.settle(completion.usage);
+        return completion;
     }
     catch (error) {
         if (error instanceof AssistantModelError)

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

@@ -17,7 +17,13 @@ export * from './assistant-sensitive-values.js';
 export * from './assistant-store.js';
 export * from './assistant-transcript.js';
 export * from './assistant-transcript-events.js';
+export * from './assistant-turn-context.js';
 export * from './assistant-view-availability.js';
+export * from './channel-coordinator.js';
+export * from './channel-provider-blocks.js';
+export * from './channel-store.js';
+export * from './channel-types.js';
+export * from './channel-work.js';
 export * from './continuity-bounds.js';
 export * from './continuity-store.js';
 export * from './elevation.js';
@@ -30,6 +36,7 @@ export * from './in-memory-continuity-store.js';
 export * from './in-memory-elevation-store.js';
 export * from './in-memory-embed-store.js';
 export * from './managed-spend.js';
+export * from './messaging-tool-dispatch.js';
 export * from './public-configuration.js';
 export * from './public-session.js';
 export * from './public-surface.js';

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

@@ -17,7 +17,13 @@ export * from './assistant-sensitive-values.js';
 export * from './assistant-store.js';
 export * from './assistant-transcript.js';
 export * from './assistant-transcript-events.js';
+export * from './assistant-turn-context.js';
 export * from './assistant-view-availability.js';
+export * from './channel-coordinator.js';
+export * from './channel-provider-blocks.js';
+export * from './channel-store.js';
+export * from './channel-types.js';
+export * from './channel-work.js';
 export * from './continuity-bounds.js';
 export * from './continuity-store.js';
 export * from './elevation.js';
@@ -30,6 +36,7 @@ export * from './in-memory-continuity-store.js';
 export * from './in-memory-elevation-store.js';
 export * from './in-memory-embed-store.js';
 export * from './managed-spend.js';
+export * from './messaging-tool-dispatch.js';
 export * from './public-configuration.js';
 export * from './public-session.js';
 export * from './public-surface.js';

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

@@ -0,0 +1,83 @@
+import { assistantAppearanceOverrideSchema } from './assistant-appearance.js';
+function toRecord(row) {
+    const parsed = row.override_json === null
+        ? undefined
+        : assistantAppearanceOverrideSchema.parse(row.override_json);
+    return {
+        tenant: { org: row.org_slug, app: row.app_slug, env: row.environment },
+        ...(parsed === undefined ? {} : { override: parsed }),
+        revision: Number(row.revision),
+        updatedAt: row.updated_at,
+        updatedBy: row.updated_by,
+    };
+}
+/** Durable tenant/environment appearance overrides with atomic optimistic revisions. */
+export class PostgresAssistantAppearanceSettingsStore {
+    #pool;
+    constructor(pool) {
+        this.#pool = pool;
+    }
+    async ensureSchema() {
+        await this.#pool.query(`
+      CREATE TABLE IF NOT EXISTS assistant_appearance_settings (
+        org_slug text NOT NULL,
+        app_slug text NOT NULL,
+        environment text NOT NULL,
+        override_json jsonb,
+        revision bigint NOT NULL,
+        updated_at timestamptz NOT NULL,
+        updated_by text NOT NULL,
+        PRIMARY KEY (org_slug, app_slug, environment),
+        CONSTRAINT assistant_appearance_revision_positive CHECK (revision > 0)
+      )
+    `);
+    }
+    async get(tenant) {
+        const result = await this.#pool.query(`SELECT * FROM assistant_appearance_settings
+       WHERE org_slug = $1 AND app_slug = $2 AND environment = $3`, [tenant.org, tenant.app, tenant.env]);
+        const row = result.rows[0];
+        return row === undefined ? undefined : toRecord(row);
+    }
+    async replace(input) {
+        if (input.expectedRevision === 0) {
+            const inserted = await this.#pool.query(`INSERT INTO assistant_appearance_settings
+           (org_slug, app_slug, environment, override_json, revision, updated_at, updated_by)
+         VALUES ($1, $2, $3, $4::jsonb, 1, $5, $6)
+         ON CONFLICT DO NOTHING
+         RETURNING *`, [
+                input.tenant.org,
+                input.tenant.app,
+                input.tenant.env,
+                input.override === undefined ? null : JSON.stringify(input.override),
+                input.updatedAt,
+                input.updatedBy,
+            ]);
+            const row = inserted.rows[0];
+            if (row !== undefined)
+                return { ok: true, record: toRecord(row) };
+        }
+        else {
+            const updated = await this.#pool.query(`UPDATE assistant_appearance_settings
+         SET override_json = $4::jsonb,
+             revision = revision + 1,
+             updated_at = $5,
+             updated_by = $6
+         WHERE org_slug = $1 AND app_slug = $2 AND environment = $3 AND revision = $7
+         RETURNING *`, [
+                input.tenant.org,
+                input.tenant.app,
+                input.tenant.env,
+                input.override === undefined ? null : JSON.stringify(input.override),
+                input.updatedAt,
+                input.updatedBy,
+                input.expectedRevision,
+            ]);
+            const row = updated.rows[0];
+            if (row !== undefined)
+                return { ok: true, record: toRecord(row) };
+        }
+        const current = await this.get(input.tenant);
+        return { ok: false, currentRevision: current?.revision ?? 0 };
+    }
+}
+//# sourceMappingURL=postgres-assistant-appearance-store.js.map

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

@@ -0,0 +1,151 @@
+import { createHash, randomBytes } from 'node:crypto';
+import { insertAuditEvent } from '@noodle-borg/module-audit';
+import { adoptCallerState } from '@noodle-borg/runtime/postgres';
+import { elevationDigest } from './elevation-store.js';
+import { sessionFromRow } from './postgres-assistant.js';
+/** Hosted atomic implementation. In-memory stores remain local/test-only and use the portable fallback. */
+export class PostgresAssistantElevationCoordinator {
+    #pool;
+    #now;
+    constructor(pool, options = {}) {
+        this.#pool = pool;
+        this.#now = options.now ?? (() => new Date());
+    }
+    async complete(request) {
+        const now = this.#now();
+        const client = await this.#pool.connect();
+        try {
+            await client.query('BEGIN');
+            const ticket = await this.#ticket(client, request.continuation);
+            if (!ticket || ticket.claimed_at !== null) {
+                return rollback(client, { ok: false, status: 403, code: 'elevation_ticket_invalid' });
+            }
+            if (ticket.org_slug !== request.tenant.org ||
+                ticket.app_slug !== request.tenant.app ||
+                ticket.environment !== request.tenant.env) {
+                return rollback(client, { ok: false, status: 403, code: 'elevation_tenant_mismatch' });
+            }
+            if (ticket.expires_at.getTime() <= now.getTime()) {
+                return rollback(client, { ok: false, status: 403, code: 'elevation_ticket_expired' });
+            }
+            const current = await client.query(`SELECT * FROM assistant_sessions WHERE id = $1 FOR UPDATE`, [ticket.session_id]);
+            const session = current.rows[0];
+            if (!session ||
+                session.expires_at.getTime() <= now.getTime() ||
+                session.absolute_expires_at.getTime() <= now.getTime()) {
+                return consumeAndCommitRefusal(client, ticket.id, now, {
+                    ok: false,
+                    status: 409,
+                    code: 'elevation_session_unavailable',
+                });
+            }
+            if (session.caller.identityKind !== 'anonymous') {
+                return consumeAndCommitRefusal(client, ticket.id, now, {
+                    ok: false,
+                    status: 409,
+                    code: 'elevation_already_signed_in',
+                });
+            }
+            const handles = claimableHandles(ticket.claimable_state_handles);
+            const adopted = await adoptCallerState(client, {
+                deploymentId: session.deployment_id,
+                handles,
+                sourceCallerSubject: session.caller.subject,
+                targetCallerSubject: request.caller.subject,
+                redirectExpiresAt: session.absolute_expires_at,
+                now,
+            });
+            if (!adopted.ok) {
+                return consumeAndCommitRefusal(client, ticket.id, now, {
+                    ok: false,
+                    status: 409,
+                    code: 'elevation_state_conflict',
+                });
+            }
+            const pending = await client.query(`SELECT 1 FROM assistant_pending_tool_calls
+         WHERE session_id = $1 AND deployment_id = $2 AND status = 'pending' AND expires_at > $3
+         LIMIT 1`, [session.id, session.deployment_id, now]);
+            const resumeArmed = request.resume === true && (pending.rowCount ?? 0) === 0;
+            const token = `nss_${randomBytes(24).toString('base64url')}`;
+            const updated = await client.query(`UPDATE assistant_sessions
+         SET token_hash = $2, caller = $3::jsonb, client_id = $4, origin = $5,
+             customer_routing = COALESCE($6::jsonb, customer_routing),
+             pending_resume = $7::jsonb, latest_suggestions = NULL,
+             bound_surface = COALESCE($8, bound_surface)
+         WHERE id = $1 AND caller->>'identityKind' = 'anonymous'
+         RETURNING *`, [
+                session.id,
+                createHash('sha256').update(token).digest('hex'),
+                JSON.stringify(request.caller),
+                request.clientId,
+                request.origin,
+                request.customerRouting ? JSON.stringify(request.customerRouting) : null,
+                resumeArmed
+                    ? JSON.stringify({ tool: ticket.tool, requestedAt: now.toISOString() })
+                    : null,
+                request.boundSurface ?? null,
+            ]);
+            const elevated = updated.rows[0];
+            if (!elevated) {
+                return rollback(client, {
+                    ok: false,
+                    status: 409,
+                    code: 'elevation_already_signed_in',
+                });
+            }
+            await client.query(`UPDATE assistant_elevations SET claimed_at = $2 WHERE id = $1 AND claimed_at IS NULL`, [ticket.id, now]);
+            if (handles.length > 0) {
+                await insertAuditEvent(client, {
+                    eventType: 'assistant.state.claimed',
+                    org: request.tenant.org,
+                    app: request.tenant.app,
+                    env: request.tenant.env,
+                    deploymentId: session.deployment_id,
+                    actorSubject: request.caller.subject,
+                    decision: 'allow',
+                    details: {
+                        sessionId: session.id,
+                        ticketId: ticket.id,
+                        handleCount: adopted.adoptedHandles.length,
+                        recordCount: adopted.adoptedRecords,
+                    },
+                }, { now: () => now });
+            }
+            await client.query('COMMIT');
+            return {
+                ok: true,
+                session: sessionFromRow(elevated),
+                token,
+                tool: ticket.tool,
+                resumeArmed,
+            };
+        }
+        catch (error) {
+            await client.query('ROLLBACK');
+            throw error;
+        }
+        finally {
+            client.release();
+        }
+    }
+    async #ticket(client, continuation) {
+        const result = await client.query(`SELECT * FROM assistant_elevations WHERE continuation_hash = $1 FOR UPDATE`, [elevationDigest(continuation)]);
+        return result.rows[0];
+    }
+}
+function claimableHandles(value) {
+    if (!Array.isArray(value))
+        return [];
+    return [...new Set(value.filter((entry) => typeof entry === 'string'))].sort();
+}
+async function rollback(client, result) {
+    await client.query('ROLLBACK');
+    return result;
+}
+/** A valid ticket is single-use even when the authenticated transition is refused deterministically. */
+async function consumeAndCommitRefusal(client, ticketId, now, result) {
+    await client.query(`UPDATE assistant_elevations SET claimed_at = $2 WHERE id = $1 AND claimed_at IS NULL`, [ticketId, now]);
+    await client.query('COMMIT');
+    return result;
+}
+//# sourceMappingURL=postgres-assistant-elevation.js.map