@noodleseed/one 0.151.0 → 0.152.0

package/node_modules/@noodle-borg/agent-kit/dist/skill-embedded-assistant-renderer-ref.js

@@ -0,0 +1,109 @@
+/** Framework-neutral browser-client and linked-App renderer guidance. */
+export function renderEmbeddedAssistantRendererReference() {
+    return [
+        '### Framework-neutral DOM client',
+        '',
+        'Use the same DOM-free client directly without a component wrapper, and import the isolated App-view entry only when rendering linked Apps. The client keeps the session token in memory, and the element owns only App presentation:',
+        '',
+        '```html',
+        '<div id="assistant-app-views"></div>',
+        '```',
+        '',
+        '```ts',
+        'import { createAssistantClient } from "@noodleseed/assistant/client";',
+        'import "@noodleseed/assistant/app-view";',
+        'import {',
+        '  type AssistantViewAvailableDetail,',
+        '  type NoodleAppViewElement,',
+        '} from "@noodleseed/assistant/app-view";',
+        '',
+        'const assistant = createAssistantClient({',
+        '  sessionEndpoint: "/api/assistant/session",',
+        '  clientContext: () => ({',
+        '    locale: navigator.language,',
+        '    timeZone: Intl.DateTimeFormat().resolvedOptions().timeZone,',
+        '  }),',
+        '});',
+        '',
+        'const appViews = document.querySelector("#assistant-app-views");',
+        'if (!appViews) throw new Error("Missing App views host");',
+        'const mountedViews = new Map<string, NoodleAppViewElement>();',
+        'const readResolvedTheme = (): "light" | "dark" =>',
+        '  document.documentElement.classList.contains("dark") ? "dark" : "light";',
+        'let resolvedTheme: "light" | "dark" = readResolvedTheme();',
+        'const syncResolvedTheme = () => {',
+        '  resolvedTheme = readResolvedTheme();',
+        '  for (const mountedView of mountedViews.values()) mountedView.theme = resolvedTheme;',
+        '};',
+        'new MutationObserver(syncResolvedTheme).observe(document.documentElement, {',
+        '  attributes: true,',
+        '  attributeFilter: ["class"],',
+        '});',
+        'const appViewFor = (view: AssistantViewAvailableDetail) => {',
+        '  const key = `${view.id}:${view.resourceUri}`;',
+        '  let appView = mountedViews.get(key);',
+        '  if (!appView) {',
+        '    appView = document.createElement("noodle-app-view") as NoodleAppViewElement;',
+        '    appView.client = assistant;',
+        '    mountedViews.set(key, appView);',
+        '    appViews.append(appView);',
+        '  }',
+        '  appView.theme = resolvedTheme;',
+        '  return appView;',
+        '};',
+        '',
+        'assistant.updateModelContext({',
+        "  content: [{ type: 'text', text: 'The time-off form is mounted.' }],",
+        "  structuredContent: { widget: { name: 'time-off', lifecycle: 'mounted' } },",
+        '});',
+        '',
+        'assistant.subscribeChat((state) => {',
+        '  renderUIMessageState(state, {',
+        '    respond: (id, response) => assistant.respond(id, response),',
+        '  });',
+        '  const activeViewKeys = new Set<string>();',
+        '  for (const message of state.messages) {',
+        '    for (const part of message.parts) {',
+        "      if (part.type === 'data-view') {",
+        '        const key = `${part.data.id}:${part.data.resourceUri}`;',
+        '        activeViewKeys.add(key);',
+        '        appViewFor(part.data).view = part.data;',
+        '      }',
+        '    }',
+        '  }',
+        '  for (const [key, mountedView] of mountedViews) {',
+        '    if (!activeViewKeys.has(key)) {',
+        '      mountedView.remove();',
+        '      mountedViews.delete(key);',
+        '    }',
+        '  }',
+        '});',
+        '```',
+        '',
+        '`subscribeChat` immediately emits a detached `{ messages, status, error? }` snapshot and then emits as `UIMessage.parts` change. Text uses `text`; Noodle confirmations, input requests, sign-in requests, tool results, and linked views use `data-confirmation`, `data-input-request`, `data-sign-in`, `data-tool-result`, and `data-view`. `renderUIMessageState` is application code: it must show a complete schema-aware review or requested form and require an explicit user gesture before calling the supplied `respond`. Never call `respond` while scanning a transcript snapshot. Interaction data moves through pending/submitting/accepted/declined/cancelled. Use raw `subscribe(...)` only for transport/session lifecycle events that are not transcript content.',
+        '',
+        'For a chat-first custom host, raw `tool_started` carries the direct invocation call `id` and technical `tool` name before execution. Map known tools through a finite application-owned label table and use a neutral fallback such as "Working"; never mechanically expose an internal identifier as customer copy. Reserve one stable region with `role="status"` and `aria-live="polite"` for thinking, the mapped activity label, and the linked-view skeleton. `view_available` makes the view ready; raw `error` or chat `error` replaces it with `role="alert"`. Mark decorative skeleton shapes `aria-hidden="true"` and disable shimmer/transitions under `@media (prefers-reduced-motion: reduce)`.',
+        '',
+        '```ts',
+        'const activityByTool: Readonly<Record<string, string>> = {',
+        '  list_open_items: "Loading open items",',
+        '};',
+        'const viewSlots = new Map([["ui://workspace/current", "current-workspace"]]);',
+        '',
+        'assistant.subscribe((event) => {',
+        '  if (event.event === "tool_started") {',
+        '    showActivity(event.data.id, activityByTool[event.data.tool] ?? "Working");',
+        '  }',
+        '  if (event.event === "view_available") {',
+        '    const key = viewSlots.get(event.data.resourceUri) ?? `${event.data.id}:${event.data.resourceUri}`;',
+        '    showReadyView(key, event.data);',
+        '  }',
+        '  if (event.event === "error") showActivityError(event.data.code);',
+        '});',
+        '```',
+        '',
+        '`data-view` means a completed tool has a linked MCP App view. Pass that typed part and the existing client to `<noodle-app-view>` in another component framework or plain DOM, or to its `NoodleAppView` React adapter. It retains one bridge for client + `view.id` + `view.resourceUri` and requests standard App teardown on semantic replacement, disconnect, or App request. That pair is transport identity: different call ids are distinct invocations and must not be deduplicated generically. If the product intentionally owns one current panel for a known resource, declare an application-owned slot map and replace only that slot. Deliberately map the bounded result to an application-trusted native component only when replacing the linked App UI.',
+        '',
+    ];
+}
+//# sourceMappingURL=skill-embedded-assistant-renderer-ref.js.map

package/node_modules/@noodle-borg/agent-kit/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@noodle-borg/agent-kit",
-  "version": "0.90.0",
+  "version": "0.91.0",
   "license": "Apache-2.0",
   "type": "module",
   "engines": {

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

@@ -0,0 +1,3 @@
+/** Positive allowlist of `server.assistant` fields that may reach the browser. */
+export declare const ASSISTANT_BROWSER_UI_FIELDS: readonly ["theme", "layout", "behavior", "labels", "presentation", "suggestedPrompts", "privacyUrl", "termsUrl", "locale", "direction", "webmcp"];
+//# sourceMappingURL=assistant-browser-fields.d.ts.map

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

@@ -0,0 +1,15 @@
+/** Positive allowlist of `server.assistant` fields that may reach the browser. */
+export const ASSISTANT_BROWSER_UI_FIELDS = [
+    'theme',
+    'layout',
+    'behavior',
+    'labels',
+    'presentation',
+    'suggestedPrompts',
+    'privacyUrl',
+    'termsUrl',
+    'locale',
+    'direction',
+    'webmcp',
+];
+//# sourceMappingURL=assistant-browser-fields.js.map

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

@@ -1,7 +1,7 @@
 import type { ArtifactServer } from '@noodle-borg/compiler';
 import { type AssistantAppearanceOverride } from './assistant-appearance.js';
 import type { AssistantAppearanceSettingsStore } from './assistant-appearance-store.js';
-import { ASSISTANT_BROWSER_UI_FIELDS } from './assistant-store.js';
+import { ASSISTANT_BROWSER_UI_FIELDS } from './assistant-browser-fields.js';
 import type { TenantRef } from './tenant-ref.js';
 /**
  * What the browser is allowed to see.

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

@@ -1,5 +1,5 @@
 import { resolveAssistantAppearanceConfiguration, } from './assistant-appearance.js';
-import { ASSISTANT_BROWSER_UI_FIELDS } from './assistant-store.js';
+import { ASSISTANT_BROWSER_UI_FIELDS } from './assistant-browser-fields.js';
 /**
  * What the browser is allowed to see.
  *

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

@@ -1,20 +1,14 @@
 import type { ArtifactServer } from '@noodle-borg/compiler';
 import type { CallerIdentity } from '@noodle-borg/runtime';
+import type { ASSISTANT_BROWSER_UI_FIELDS } from './assistant-browser-fields.js';
 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 AssistantInteractionClaimResult, type AssistantInteractionCompletionResult, type AssistantInteractionCreateInput, type AssistantInteractionRecord, type AssistantInteractionScope, type AssistantInteractionTransitionInput, type AssistantInteractionTransitionResult, type AssistantPendingConfirmationInteractionRecord, type AssistantPendingInputInteractionRecord, type AssistantPendingInteractionRecord } from './assistant-interaction-state.js';
+import type { AssistantRecoverableView } from './assistant-view-availability.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 { 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, type AssistantPendingInteractionRecord, 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 ["theme", "layout", "behavior", "labels", "presentation", "suggestedPrompts", "privacyUrl", "termsUrl", "locale", "direction", "webmcp"];
+export { ASSISTANT_BROWSER_UI_FIELDS } from './assistant-browser-fields.js';
 export interface AssistantClientRecord {
     readonly id: string;
     readonly name: string;
@@ -79,6 +73,8 @@ export interface AssistantSessionRecord {
     readonly initialSuggestions?: AssistantInitialSuggestionsState;
     /** Latest validated follow-up suggestions, replayed with the visible transcript. */
     readonly latestSuggestions?: AssistantSuggestedPrompts;
+    /** Latest renderer descriptor; HTML is re-resolved from the current surface artifact on recovery. */
+    readonly latestView?: AssistantRecoverableView;
 }
 export interface AssistantSuggestedPrompts {
     readonly phase: 'initial' | 'follow_up';
@@ -165,6 +161,7 @@ export interface AssistantStore {
     completeInitialSuggestions(id: string, prompts: readonly string[]): Promise<boolean>;
     failInitialSuggestions(id: string): Promise<boolean>;
     replaceLatestSuggestions(id: string, suggestions: AssistantSuggestedPrompts | undefined): Promise<boolean>;
+    replaceLatestView(id: string, view: AssistantRecoverableView | undefined): Promise<boolean>;
     /** Atomically reserve one once-per-session model tool use. */
     claimModelToolUse(id: string, tool: string): Promise<boolean>;
     /** Release a reservation only when execution failed before a usable result or interaction existed. */
@@ -221,6 +218,11 @@ export interface AssistantStore {
     }): Promise<AssistantInteractionCompletionResult>;
     transitionInteraction(input: AssistantInteractionTransitionInput): Promise<AssistantInteractionTransitionResult>;
     getInteraction(input: AssistantInteractionScope): Promise<AssistantInteractionRecord | undefined>;
+    findPendingInteraction(input: {
+        readonly sessionId: string;
+        readonly deploymentId: string;
+        readonly now: Date;
+    }): Promise<AssistantPendingInteractionRecord | 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';
@@ -269,6 +271,7 @@ export declare class InMemoryAssistantStore implements AssistantStore {
     completeInitialSuggestions(id: string, prompts: readonly string[]): Promise<boolean>;
     failInitialSuggestions(id: string): Promise<boolean>;
     replaceLatestSuggestions(id: string, suggestions: AssistantSuggestedPrompts | undefined): Promise<boolean>;
+    replaceLatestView(id: string, view: AssistantRecoverableView | undefined): Promise<boolean>;
     claimModelToolUse(id: string, tool: string): Promise<boolean>;
     releaseModelToolUse(id: string, tool: string): Promise<boolean>;
     getSession(token: string, now: Date): Promise<AssistantSessionRecord | undefined>;
@@ -285,6 +288,11 @@ export declare class InMemoryAssistantStore implements AssistantStore {
     }): Promise<AssistantInteractionCompletionResult>;
     transitionInteraction(input: AssistantInteractionTransitionInput): Promise<AssistantInteractionTransitionResult>;
     getInteraction(input: AssistantInteractionScope): Promise<AssistantInteractionRecord | undefined>;
+    findPendingInteraction(input: {
+        readonly sessionId: string;
+        readonly deploymentId: string;
+        readonly now: Date;
+    }): Promise<AssistantPendingInteractionRecord | undefined>;
     consumeInteraction(id: string, sessionId: string, deploymentId: string, now: Date): Promise<(import('./assistant-interaction-state.js').AssistantConfirmationInteractionRecord & {
         readonly status: 'executing';
     }) | undefined>;

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

@@ -3,29 +3,7 @@ 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;
-/**
- * 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 const ASSISTANT_BROWSER_UI_FIELDS = [
-    'theme',
-    'layout',
-    'behavior',
-    'labels',
-    'presentation',
-    'suggestedPrompts',
-    'privacyUrl',
-    'termsUrl',
-    'locale',
-    'direction',
-    // Not appearance: the browser must know whether this deployment opted into projecting its tools to
-    // a page agent (ADR 0220). It travels the allowlist like everything else the page may see.
-    'webmcp',
-];
+export { ASSISTANT_BROWSER_UI_FIELDS } from './assistant-browser-fields.js';
 /** Latest prompt messages retained for model continuity; turn admission is tracked separately. */
 export const ASSISTANT_HISTORY_MAX_MESSAGES = 40;
 export class InMemoryAssistantStore {
@@ -199,6 +177,19 @@ export class InMemoryAssistantStore {
         }
         return true;
     }
+    async replaceLatestView(id, view) {
+        const session = this.#sessions.get(id);
+        if (!session)
+            return false;
+        const next = {
+            ...session,
+            ...(view === undefined ? {} : { latestView: structuredClone(view) }),
+        };
+        if (view === undefined)
+            delete next.latestView;
+        this.#sessions.set(id, next);
+        return true;
+    }
     async claimModelToolUse(id, tool) {
         const session = this.#sessions.get(id);
         if (!session || session.modelToolUses.includes(tool))
@@ -319,6 +310,16 @@ export class InMemoryAssistantStore {
         const interaction = this.#scopedInteraction(input);
         return interaction ? cloneInteraction(interaction) : undefined;
     }
+    async findPendingInteraction(input) {
+        this.#pruneInteractions(input.now);
+        const interaction = [...this.#interactions.values()]
+            .filter((candidate) => candidate.sessionId === input.sessionId &&
+            candidate.deploymentId === input.deploymentId &&
+            candidate.status === 'pending' &&
+            Date.parse(candidate.expiresAt) > input.now.getTime())
+            .sort((left, right) => Date.parse(right.createdAt) - Date.parse(left.createdAt))[0];
+        return interaction ? cloneInteraction(interaction) : undefined;
+    }
     async consumeInteraction(id, sessionId, deploymentId, now) {
         const result = this.#claimInteraction({ id, sessionId, deploymentId, now }, 'confirmation');
         return result.disposition === 'claimed' && result.interaction.kind === 'confirmation'

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

@@ -0,0 +1,24 @@
+import type { AssistantTranscriptEntry } from './assistant-transcript.js';
+import type { AssistantViewAvailableData } from './assistant-view-availability.js';
+export interface AssistantTranscriptEvent {
+    readonly event: string;
+    readonly data: Readonly<Record<string, unknown>>;
+}
+export interface AssistantRecoveredInteraction {
+    readonly event: 'tool_proposed' | 'input_requested';
+    readonly data: Readonly<Record<string, unknown>>;
+}
+/**
+ * Project retained visual state through the ordinary assistant event protocol. The browser therefore
+ * has one parser and one rendering path for live and recovered turns; this function owns only ordering.
+ */
+export declare function assistantTranscriptEvents(input: {
+    readonly entries: readonly AssistantTranscriptEntry[];
+    readonly latestView?: AssistantViewAvailableData;
+    readonly pendingInteraction?: AssistantRecoveredInteraction;
+    readonly suggestions?: {
+        readonly phase: 'initial' | 'follow_up';
+        readonly prompts: readonly string[];
+    };
+}): readonly AssistantTranscriptEvent[];
+//# sourceMappingURL=assistant-transcript-events.d.ts.map

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

@@ -0,0 +1,39 @@
+/**
+ * Project retained visual state through the ordinary assistant event protocol. The browser therefore
+ * has one parser and one rendering path for live and recovered turns; this function owns only ordering.
+ */
+export function assistantTranscriptEvents(input) {
+    const events = [];
+    let open = false;
+    let awaitingAssistant = false;
+    for (const entry of input.entries) {
+        if (entry.role === 'user') {
+            if (open)
+                events.push({ event: 'message_completed', data: {} });
+            events.push({ event: 'message_started', data: { message: entry.text } });
+            open = true;
+            awaitingAssistant = true;
+            continue;
+        }
+        if (!open || !awaitingAssistant) {
+            if (open)
+                events.push({ event: 'message_completed', data: {} });
+            events.push({ event: 'resume_started', data: { tool: '' } });
+            open = true;
+        }
+        events.push({ event: 'content', data: { delta: entry.text } });
+        awaitingAssistant = false;
+    }
+    if (open)
+        events.push({ event: 'message_completed', data: {} });
+    if (input.latestView)
+        events.push({ event: 'view_available', data: { ...input.latestView } });
+    if (input.pendingInteraction)
+        events.push(input.pendingInteraction);
+    if (input.suggestions?.phase === 'follow_up') {
+        events.push({ event: 'suggested_prompts', data: { ...input.suggestions } });
+    }
+    events.push({ event: 'done', data: {} });
+    return events;
+}
+//# sourceMappingURL=assistant-transcript-events.js.map

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

@@ -1,4 +1,3 @@
-import type { AssistantHistoryMessage } from './assistant-store.js';
 /**
  * The bounded visible-transcript projection (ADR 0141/0201 amendments 2026-08-26): what a widget may
  * repaint after a full-page navigation — the sign-in redirect above all — from the session's own
@@ -14,5 +13,10 @@ export interface AssistantTranscriptEntry {
     readonly role: 'user' | 'assistant';
     readonly text: string;
 }
-export declare function visibleTranscript(history: readonly AssistantHistoryMessage[]): readonly AssistantTranscriptEntry[];
+export interface AssistantTranscriptHistoryEntry {
+    readonly role: 'user' | 'assistant';
+    readonly content: string;
+    readonly kind?: 'visible' | 'narration';
+}
+export declare function visibleTranscript(history: readonly AssistantTranscriptHistoryEntry[]): readonly AssistantTranscriptEntry[];
 //# sourceMappingURL=assistant-transcript.d.ts.map

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

@@ -1,3 +1,14 @@
+/**
+ * The bounded visible-transcript projection (ADR 0141/0201 amendments 2026-08-26): what a widget may
+ * repaint after a full-page navigation — the sign-in redirect above all — from the session's own
+ * short-lived history. Transport-free like every gateway decision; `packages/service` adapts.
+ *
+ * Only rows explicitly tagged `visible` project. Everything else fails closed out of the transcript:
+ * `narration` rows are model-facing scaffolding (resolution summaries carrying tool output,
+ * `[platform]` resume prompts the visitor never saw), and an untagged legacy row cannot prove which
+ * it was. This is a read-only projection over state that already exists and already expires with the
+ * session — it is not a durable transcript, and nothing here may extend a retention window.
+ */
 export function visibleTranscript(history) {
     return history
         .filter((entry) => entry.kind === 'visible')

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

@@ -14,6 +14,14 @@ export interface AssistantViewAvailableData {
     readonly allowedOpenDomains?: readonly string[];
     readonly replayed?: true;
 }
+/** Persisted renderer descriptor: bounded public data only, never HTML or a resource body. */
+export interface AssistantRecoverableView {
+    readonly id: string;
+    readonly tool: string;
+    readonly result: unknown;
+    readonly arguments?: unknown;
+}
+export declare function recoverableAssistantView(view: Pick<AssistantViewAvailableData, 'id' | 'tool' | 'result' | 'arguments'>): AssistantRecoverableView;
 /** A declared widget the completed tool could not surface — reported so the drop is never silent. */
 export interface AssistantViewUnresolved {
     readonly tool: string;

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

@@ -1,5 +1,13 @@
 import { injectWidgetBridge } from '@noodle-borg/protocol';
 const MCP_APP_MIME_TYPE = 'text/html;profile=mcp-app';
+export function recoverableAssistantView(view) {
+    return {
+        id: view.id,
+        tool: view.tool,
+        result: structuredClone(view.result),
+        ...(view.arguments === undefined ? {} : { arguments: structuredClone(view.arguments) }),
+    };
+}
 /**
  * Resolve a self-contained, statically compiled MCP App document for the embedded host. The linked
  * resource must be present in the same compiled artifact and carry the MCP App MIME type; arbitrary

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

@@ -19,6 +19,8 @@ export interface AssistantElevationRecord {
     readonly tenant: TenantRef;
     /** The capability the visitor was refused, carried so the audit says what they signed in for. */
     readonly tool: string;
+    /** Canonical server-side snapshot of handles eligible when this ticket was issued. */
+    readonly claimableStateHandles: readonly string[];
     readonly continuationHash: string;
     readonly createdAt: string;
     readonly expiresAt: string;
@@ -48,6 +50,7 @@ export interface AssistantElevationStore {
         readonly sessionId: string;
         readonly tenant: TenantRef;
         readonly tool: string;
+        readonly claimableStateHandles?: readonly string[];
         readonly now: Date;
     }): Promise<{
         readonly elevation: AssistantElevationRecord;

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

@@ -66,10 +66,16 @@ export type ElevationResult = {
     readonly token: string;
     /** What the visitor was refused before signing in, for the audit trail. */
     readonly tool: string;
+    /** Whether one-shot auto-resume was actually armed after pending-interaction suppression. */
+    readonly resumeArmed: boolean;
 } | {
     readonly ok: false;
     readonly status: 403 | 409;
-    readonly code: 'elevation_ticket_invalid' | 'elevation_ticket_expired' | 'elevation_tenant_mismatch' | 'elevation_session_unavailable' | 'elevation_already_signed_in';
+    readonly code: 'elevation_ticket_invalid' | 'elevation_ticket_expired' | 'elevation_tenant_mismatch' | 'elevation_session_unavailable' | 'elevation_already_signed_in' | 'elevation_state_conflict';
 };
+/** One commit boundary for ticket spend, state adoption, session rebind, and audit. */
+export interface AssistantElevationCoordinator {
+    complete(request: ElevationRequest): Promise<ElevationResult>;
+}
 export declare function completeElevation(request: ElevationRequest, ports: ElevationPorts): Promise<ElevationResult>;
 //# sourceMappingURL=elevation.d.ts.map

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

@@ -45,6 +45,7 @@ export async function completeElevation(request, ports) {
         session: elevated.session,
         token: elevated.token,
         tool: claimed.elevation.tool,
+        resumeArmed: request.resume === true,
     };
 }
 //# sourceMappingURL=elevation.js.map

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

@@ -7,6 +7,7 @@ export declare class InMemoryAssistantElevationStore implements AssistantElevati
         readonly sessionId: string;
         readonly tenant: TenantRef;
         readonly tool: string;
+        readonly claimableStateHandles?: readonly string[];
         readonly now: Date;
     }): Promise<{
         readonly elevation: AssistantElevationRecord;

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

@@ -15,6 +15,7 @@ export class InMemoryAssistantElevationStore {
             sessionId: input.sessionId,
             tenant: input.tenant,
             tool: input.tool,
+            claimableStateHandles: [...(input.claimableStateHandles ?? [])].sort(),
             continuationHash: elevationDigest(continuation),
             createdAt: input.now.toISOString(),
             expiresAt: new Date(input.now.getTime() + ASSISTANT_ELEVATION_TTL_MS).toISOString(),

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

@@ -55,6 +55,34 @@ export declare function managedSpendUnitWeight(rung: number): number;
  * stretches further.
  */
 export declare function managedSpendAllowanceForTurns(turnsPerDay: number): number;
+/**
+ * Output tokens a provider bills for one completion.
+ *
+ * Reasoning tokens are output. Every provider we serve bills "thinking" at the output rate, and the
+ * production surface measured them at 5.4x the visible completion — so counting `completionTokens`
+ * alone enforces a per-turn ceiling on roughly a sixth of what the turn costs, and reports the same
+ * shortfall to the drift check whose entire job is noticing a rung that does not bound what it
+ * claims. One definition, used by the enforcer and by the telemetry that audits the enforcer,
+ * because two definitions is how the blind spot got here.
+ *
+ * An absent count means the provider reported none, never "unknown": a model with no reasoning
+ * phase omits the field, and must read exactly as it did before.
+ */
+export declare function billedOutputTokens(usage: {
+    readonly completionTokens: number;
+    readonly reasoningTokens?: number;
+}): number;
+/**
+ * What remains of a turn's token budget after one completion.
+ *
+ * The fallback when a provider reports no usage at all is the whole request limit rather than zero:
+ * a step whose cost is unknown must be assumed to have spent everything it was allowed, or a
+ * provider that omits the block would make the turn unbounded.
+ */
+export declare function remainingTurnTokens(remaining: number, usage: {
+    readonly completionTokens: number;
+    readonly reasoningTokens?: number;
+} | undefined, requestLimit: number): number;
 /**
  * Is the ledger telling the truth?
  *
@@ -70,6 +98,7 @@ export declare function managedSpendDrift(observed: {
     readonly deliveredTurns: number;
     readonly promptTokens: number;
     readonly completionTokens: number;
+    readonly reasoningTokens?: number;
 }): {
     readonly observedPerTurn: number;
     readonly permittedPerTurn: number;

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

@@ -159,6 +159,32 @@ export function managedSpendAllowanceForTurns(turnsPerDay) {
         return 0;
     return Math.ceil(turnsPerDay) * managedSpendUnitWeight(0);
 }
+/**
+ * Output tokens a provider bills for one completion.
+ *
+ * Reasoning tokens are output. Every provider we serve bills "thinking" at the output rate, and the
+ * production surface measured them at 5.4x the visible completion — so counting `completionTokens`
+ * alone enforces a per-turn ceiling on roughly a sixth of what the turn costs, and reports the same
+ * shortfall to the drift check whose entire job is noticing a rung that does not bound what it
+ * claims. One definition, used by the enforcer and by the telemetry that audits the enforcer,
+ * because two definitions is how the blind spot got here.
+ *
+ * An absent count means the provider reported none, never "unknown": a model with no reasoning
+ * phase omits the field, and must read exactly as it did before.
+ */
+export function billedOutputTokens(usage) {
+    return usage.completionTokens + (usage.reasoningTokens ?? 0);
+}
+/**
+ * What remains of a turn's token budget after one completion.
+ *
+ * The fallback when a provider reports no usage at all is the whole request limit rather than zero:
+ * a step whose cost is unknown must be assumed to have spent everything it was allowed, or a
+ * provider that omits the block would make the turn unbounded.
+ */
+export function remainingTurnTokens(remaining, usage, requestLimit) {
+    return Math.max(0, remaining - (usage === undefined ? requestLimit : billedOutputTokens(usage)));
+}
 /**
  * Is the ledger telling the truth?
  *
@@ -175,7 +201,7 @@ export function managedSpendDrift(observed) {
     if (observed.deliveredTurns <= 0) {
         return { observedPerTurn: 0, permittedPerTurn, exceeded: false };
     }
-    const billable = observed.promptTokens + OUTPUT_WEIGHT * observed.completionTokens;
+    const billable = observed.promptTokens + OUTPUT_WEIGHT * billedOutputTokens(observed);
     const observedPerTurn = Math.round(billable / observed.deliveredTurns);
     return { observedPerTurn, permittedPerTurn, exceeded: observedPerTurn > permittedPerTurn };
 }

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

@@ -15,6 +15,7 @@ export * from './assistant-presentation.js';
 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-view-availability.js';
 export * from './elevation.js';
 export * from './elevation-store.js';

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

@@ -15,6 +15,7 @@ export * from './assistant-presentation.js';
 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-view-availability.js';
 export * from './elevation.js';
 export * from './elevation-store.js';

package/node_modules/@noodle-borg/assistant-gateway/package.json

@@ -39,6 +39,7 @@
     "@noodle-borg/compiler": "0.0.0",
     "@noodle-borg/connector-defs": "0.0.0",
     "@noodle-borg/module": "0.0.0",
+    "@noodle-borg/module-audit": "0.0.0",
     "@noodle-borg/protocol": "0.0.0",
     "@noodle-borg/runtime": "0.0.0",
     "@noodleseed/assistant": "1.31.0",

package/node_modules/@noodle-borg/authoring/dist/server.d.ts

@@ -19,6 +19,8 @@ export interface StateHandleOptions {
     readonly version: string;
     readonly scope?: StateHandleScope;
     readonly ttlSeconds?: number;
+    /** Move this caller-scoped, finite-lived state to the authenticated caller during ticket elevation. */
+    readonly claimOnAuthentication?: true;
 }
 export interface ServerOptions {
     readonly title: string;

package/node_modules/@noodle-borg/authoring/dist/server.js

@@ -231,6 +231,9 @@ class ServerBuilder {
                                 version: handle.version,
                                 ...(handle.scope !== undefined ? { scope: handle.scope } : {}),
                                 ...(handle.ttlSeconds !== undefined ? { ttlSeconds: handle.ttlSeconds } : {}),
+                                ...(handle.claimOnAuthentication === true
+                                    ? { claimOnAuthentication: true }
+                                    : {}),
                             },
                         ])),
                     },