@noodleseed/one 0.177.0 → 0.179.0

package/node_modules/@noodle-borg/service/dist/conversation-history/operator.js

@@ -1,6 +1,8 @@
 import { createHmac } from 'node:crypto';
 import { canonicalJson } from '@noodle-borg/compiler';
-import { ConversationExportResponseSchema, ConversationForgetRequestSchema, ConversationForgetResponseSchema, ConversationIdSchema, ConversationListResponseSchema, ConversationShowResponseSchema, } from '@noodle-borg/wire-contracts';
+import { ConversationExportResponseSchema, ConversationForgetRequestSchema, ConversationForgetResponseSchema, ConversationIdSchema, ConversationListResponseSchema, ConversationReviewRequestSchema, ConversationReviewStatusSchema, ConversationShowResponseSchema, } from '@noodle-borg/wire-contracts';
+import { maskPaymentCards } from '../payment-card.js';
+import { CONVERSATION_DAY_MS, CONVERSATION_NOTE_LIMIT, } from './contracts.js';
 const runLocal = (operation) => operation();
 const MESSAGES = {
     conversation_invalid: 'Invalid conversation request.',
@@ -17,16 +19,22 @@ export class ConversationHistoryError extends Error {
 const PAGE = { list: { default: 50, maximum: 100 }, export: { default: 25, maximum: 25 } };
 /**
  * The staff projection of conversation history (ADR 0241). Callers authorize before and after, and every
- * read, export and forget returns identifier-only audit details; message text never reaches audit.
+ * read, review, note, export and forget returns identifier-only audit details; message and note text
+ * never reach audit.
  */
 export class ApplicationConversations {
     options;
     constructor(options) {
         this.options = options;
     }
+    /** Whether this installation serves a Preview environment; failure keeps production rules. */
+    async isPreview(scope) {
+        const tenant = { org: scope.org, app: scope.app, env: scope.env };
+        return (await this.options.preview?.(tenant).catch(() => false)) ?? false;
+    }
     async project(scope, action, input, local = runLocal) {
         const tenant = { org: scope.org, app: scope.app, env: scope.env };
-        const allowed = action === 'list' || action === 'export' ? ['limit', 'cursor', 'channel'] : [];
+        const allowed = action === 'list' || action === 'export' ? ['limit', 'cursor', 'channel', 'status'] : [];
         const parameters = new Map();
         for (const [key, value] of input.parameters) {
             if (!allowed.includes(key) || parameters.has(key))
@@ -37,36 +45,94 @@ export class ApplicationConversations {
             eventType,
             details,
         });
+        if (action === 'review') {
+            const id = ConversationIdSchema.safeParse(input.conversationId);
+            if (!id.success)
+                throw new ConversationHistoryError('conversation_not_found');
+            const parsed = ConversationReviewRequestSchema.safeParse(input.body);
+            if (!parsed.success || (parsed.data.note !== undefined && !input.actor))
+                throw invalid();
+            const { reviewStatus, note } = parsed.data;
+            const now = this.#now();
+            const notBefore = await this.#notBefore(tenant, now);
+            const conversation = await local(async () => {
+                const current = await this.options.store.read(tenant, id.data, now, notBefore);
+                if (!current)
+                    throw new ConversationHistoryError('conversation_not_found');
+                if (note !== undefined && current.notes.length >= CONVERSATION_NOTE_LIMIT)
+                    throw invalid();
+                if (reviewStatus !== undefined)
+                    await this.options.store.setReviewStatus(tenant, id.data, reviewStatus);
+                if (note !== undefined)
+                    await this.options.store.addNote(tenant, id.data, {
+                        author: String(input.actor),
+                        text: maskPaymentCards(note),
+                        at: now,
+                    });
+                return this.options.store.read(tenant, id.data, now, notBefore);
+            });
+            if (!conversation)
+                throw new ConversationHistoryError('conversation_not_found');
+            return {
+                response: ConversationShowResponseSchema.parse({
+                    ok: true,
+                    data: { conversation: shown(conversation, now - notBefore) },
+                }),
+                audits: [
+                    ...(reviewStatus === undefined
+                        ? []
+                        : [audit('conversation.reviewed', { conversationId: id.data, reviewStatus })]),
+                    ...(note === undefined ? [] : [audit('conversation.noted', { conversationId: id.data })]),
+                ],
+            };
+        }
         if (action === 'forget') {
             const parsed = ConversationForgetRequestSchema.safeParse(input.body);
             if (!parsed.success)
                 throw invalid();
             const request = parsed.data;
-            const forgotten = await local(() => 'conversationId' in request
-                ? this.options.store.forget(tenant, request.conversationId)
-                : this.options.store.forgetSubject(tenant, request.subject));
+            // A WhatsApp participant's working memory goes with their history (ADR 0241); a web session
+            // expires on its own, so a customer has none to erase.
+            const { forgotten, workingMemory } = await local(async () => {
+                if ('conversationId' in request)
+                    return {
+                        forgotten: await this.options.store.forget(tenant, request.conversationId),
+                        workingMemory: false,
+                    };
+                const erased = await this.options.store.forgetSubject(tenant, request.subject);
+                return {
+                    forgotten: erased,
+                    workingMemory: request.subject.kind === 'participant' &&
+                        (await input.forgetWorkingMemory?.(tenant, request.subject.ref, String(input.actor))) === true,
+                };
+            });
             return {
                 response: ConversationForgetResponseSchema.parse({ ok: true, data: { forgotten } }),
-                audit: audit('conversation.forgotten', {
-                    conversations: forgotten.conversations,
-                    items: forgotten.items,
-                    kind: 'conversationId' in request ? 'conversation' : request.subject.kind,
-                }),
+                audits: [
+                    audit('conversation.forgotten', {
+                        conversations: forgotten.conversations,
+                        items: forgotten.items,
+                        kind: 'conversationId' in request ? 'conversation' : request.subject.kind,
+                        workingMemory,
+                    }),
+                ],
             };
         }
         if (action === 'show') {
             const id = ConversationIdSchema.safeParse(input.conversationId);
             if (!id.success)
                 throw new ConversationHistoryError('conversation_not_found');
-            const conversation = await local(() => this.options.store.read(tenant, id.data, this.#now()));
+            const now = this.#now();
+            const notBefore = await this.#notBefore(tenant, now);
+            const conversation = await local(() => this.options.store.read(tenant, id.data, now, notBefore));
             if (!conversation)
                 throw new ConversationHistoryError('conversation_not_found');
             return {
                 response: ConversationShowResponseSchema.parse({
                     ok: true,
-                    data: { conversation: detail(conversation) },
+                    data: { conversation: shown(conversation, now - notBefore) },
                 }),
-                audit: audit('conversation.read', { conversationId: id.data }),
+                audits: [audit('conversation.read', { conversationId: id.data })],
             };
         }
         const page = await this.#page(scope, tenant, action, parameters, local);
@@ -77,13 +143,16 @@ export class ApplicationConversations {
                     data: {
                         conversations: page.summaries.map(summary),
                         ...(page.nextCursor ? { nextCursor: page.nextCursor } : {}),
+                        ...((await this.isPreview(scope)) ? { preview: { retentionDays: page.days } } : {}),
                     },
                 }),
+                audits: [],
             };
         const conversations = await local(async () => {
-            const now = this.#now();
-            const read = await Promise.all(page.summaries.map((row) => this.options.store.read(tenant, row.id, now)));
-            return read.filter((row) => row !== undefined).map(detail);
+            const read = await Promise.all(page.summaries.map((row) => this.options.store.read(tenant, row.id, page.now, page.notBefore)));
+            return read
+                .filter((row) => row !== undefined)
+                .map((row) => detail(row, page.now - page.notBefore));
         });
         return {
             response: ConversationExportResponseSchema.parse({
@@ -93,18 +162,20 @@ export class ApplicationConversations {
                     ...(page.nextCursor ? { nextCursor: page.nextCursor } : {}),
                 },
             }),
-            audit: audit('conversation.exported', { count: conversations.length }),
+            audits: [audit('conversation.exported', { count: conversations.length })],
         };
     }
     async #page(scope, tenant, purpose, parameters, local) {
         const bounds = PAGE[purpose];
         const limit = parameters.has('limit') ? Number(parameters.get('limit')) : bounds.default;
         const channel = parameters.get('channel');
+        const status = parameters.get('status');
         const cursor = parameters.get('cursor');
         if (!Number.isInteger(limit) ||
             limit < 1 ||
             limit > bounds.maximum ||
             (channel !== undefined && channel !== 'website' && channel !== 'whatsapp') ||
+            (status !== undefined && !ConversationReviewStatusSchema.safeParse(status).success) ||
             (cursor !== undefined && (!cursor || cursor.length > 2048)))
             throw invalid();
         const binding = this.#hash({
@@ -112,26 +183,46 @@ export class ApplicationConversations {
             scope,
             limit,
             channel: channel ?? null,
+            status: status ?? null,
         });
         const after = decodeConversationCursor(cursor, binding);
+        const now = this.#now();
+        const { notBefore, days } = await this.#window(tenant, now);
         const rows = await local(() => this.options.store.list(tenant, {
-            now: this.#now(),
+            now,
+            notBefore,
             limit: limit + 1,
             ...(after ? { after } : {}),
             ...(channel ? { channel: channel } : {}),
+            ...(status ? { reviewStatus: status } : {}),
         }));
         const summaries = rows.slice(0, limit);
         const last = summaries.at(-1);
         return {
+            now,
+            notBefore,
+            days,
             summaries,
-            nextCursor: rows.length > limit && last
-                ? Buffer.from(JSON.stringify({ binding, lastMessageAt: last.lastMessageAt, id: last.id })).toString('base64url')
-                : undefined,
+            nextCursor: rows.length > limit && last ? encodeConversationCursor(binding, last) : undefined,
         };
     }
     #now() {
         return this.options.now?.() ?? Date.now();
     }
+    /**
+     * Oldest visible item time under the live window. Items the window hides are not deleted: they purge
+     * at their stamped expiry, so restoring a longer plan before then shows them again. That recovers
+     * nothing deleted, which is all the business history contract forbids.
+     */
+    async #notBefore(tenant, now) {
+        return (await this.#window(tenant, now)).notBefore;
+    }
+    async #window(tenant, now) {
+        const policy = await this.options.policy(tenant).catch(() => undefined);
+        if (!policy || !Number.isInteger(policy.maximumDays))
+            throw new ConversationHistoryError('conversation_unavailable');
+        return { days: conversationWindowDays(policy), notBefore: conversationReadBound(policy, now) };
+    }
     #hash(value) {
         return createHmac('sha256', this.options.identityKey)
             .update(canonicalJson(value))
@@ -149,11 +240,30 @@ function summary(row) {
         startedAt: new Date(row.startedAt).toISOString(),
         lastMessageAt: new Date(row.lastMessageAt).toISOString(),
         itemCount: row.itemCount,
+        reviewStatus: row.reviewStatus,
+    };
+}
+/**
+ * The last visible item's effective removal: its stored expiry, or sooner where the live window of
+ * `windowMs` hides it first.
+ */
+function removalAt(conversation, windowMs) {
+    return Math.max(...conversation.items.map((item) => Math.min(item.expiresAt, item.at + windowMs)));
+}
+function shown(conversation, windowMs) {
+    return {
+        ...detail(conversation, windowMs),
+        notes: conversation.notes.map((note) => ({
+            author: note.author,
+            text: note.text,
+            at: new Date(note.at).toISOString(),
+        })),
     };
 }
-function detail(conversation) {
+function detail(conversation, windowMs) {
     return {
         ...summary({ ...conversation, itemCount: conversation.items.length }),
+        expiresAt: new Date(removalAt(conversation, windowMs)).toISOString(),
         items: conversation.items.map((item) => item.kind === 'message'
             ? { kind: item.kind, role: item.role, text: item.text, at: new Date(item.at).toISOString() }
             : {
@@ -165,7 +275,20 @@ function detail(conversation) {
             }),
     };
 }
-function decodeConversationCursor(raw, binding) {
+/** Oldest visible item time under a policy's live window; Off hides every item. */
+export function conversationReadBound(policy, now) {
+    const days = conversationWindowDays(policy);
+    return days === 0 ? now + 1 : now - days * CONVERSATION_DAY_MS;
+}
+/** The live window in days: the chosen duration under the plan maximum; 0 hides everything. */
+function conversationWindowDays(policy) {
+    return Math.max(0, Math.min(policy.conversationDays ?? 0, policy.maximumDays));
+}
+/** An opaque keyset position bound to the purpose, scope and page shape that `binding` hashes. */
+export function encodeConversationCursor(binding, last) {
+    return Buffer.from(JSON.stringify({ binding, lastMessageAt: last.lastMessageAt, id: last.id })).toString('base64url');
+}
+export function decodeConversationCursor(raw, binding) {
     if (raw === undefined)
         return undefined;
     try {

package/node_modules/@noodle-borg/service/dist/conversation-history/preview.js

@@ -0,0 +1,43 @@
+import { ALL_CONVERSATION_SOURCES, } from './contracts.js';
+/**
+ * ADR 0241 decision 18: a Preview environment's conversations are kept this long, whatever the stored
+ * opt-in or recording switches, and never longer than the plan maximum.
+ */
+export const PREVIEW_CONVERSATION_DAYS = 3;
+/**
+ * A Preview environment is a deployed environment of an app whose production environment is another,
+ * designated one. An unknown environment, an app with no resolved production designation, or an
+ * unreadable registry keeps production semantics, so a live chat never loses its opt-in or reaches a
+ * Builder by default.
+ */
+export function previewEnvironments(registry) {
+    return async (tenant) => {
+        try {
+            const current = await registry.getEnvironment(tenant.org, tenant.app, tenant.env);
+            if (current === undefined || current.isProduction)
+                return false;
+            const environments = await registry.listEnvironments(tenant.org, tenant.app);
+            return environments.some((item) => item.isProduction && item.envName !== tenant.env);
+        }
+        catch {
+            return false;
+        }
+    };
+}
+/** A Preview tenant records every source for the fixed window; production policy is returned as is. */
+export function withPreviewConversations(policy, isPreview) {
+    return async (tenant) => {
+        const current = await policy(tenant);
+        if (current === undefined || !(await isPreview(tenant)))
+            return current;
+        return previewConversationPolicy(current.maximumDays);
+    };
+}
+function previewConversationPolicy(maximumDays) {
+    return {
+        maximumDays,
+        conversationDays: Math.max(0, Math.min(PREVIEW_CONVERSATION_DAYS, maximumDays)),
+        sources: { ...ALL_CONVERSATION_SOURCES },
+    };
+}
+//# sourceMappingURL=preview.js.map

package/node_modules/@noodle-borg/service/dist/routes/assistant-conversations.js

@@ -0,0 +1,52 @@
+import { readJsonBody, sendJson } from '@noodle-borg/transport-http';
+import { ConversationHistoryError } from '../conversation-history/operator.js';
+import { sendUnauthorized } from '../http-util.js';
+import { basicCredentials } from './assistant-route-http.js';
+/**
+ * Backend-only conversation routes for an embed client (ADR 0241 decision 12). They authenticate
+ * exactly like the session exchange and never read a tenant from the body; there is no browser CORS
+ * surface, because the client secret must never reach a browser.
+ */
+export async function handleAssistantConversations(req, res, action, deps) {
+    if (req.method !== 'POST') {
+        res.setHeader('allow', 'POST');
+        return sendJson(res, 405, { error: 'method not allowed' });
+    }
+    const credentials = basicCredentials(req);
+    if (!credentials)
+        return sendUnauthorized(res, 'invalid assistant client');
+    const client = await deps.store.authenticateClient(credentials.id, credentials.secret);
+    if (!client)
+        return sendUnauthorized(res, 'invalid assistant client');
+    res.setHeader('cache-control', 'private, no-store');
+    const body = await readJsonBody(req, deps.maxBody);
+    if (!body.ok)
+        return sendJson(res, body.status, { error: body.error });
+    try {
+        const conversations = deps.customerConversations;
+        if (!conversations)
+            throw new ConversationHistoryError('conversation_unavailable');
+        const owner = { id: client.id, tenant: client.tenant };
+        const result = action === 'list'
+            ? await conversations.list(owner, body.value)
+            : await conversations.forgetUser(owner, body.value);
+        await deps.audit.emit({
+            ...result.audit,
+            org: client.tenant.org,
+            app: client.tenant.app,
+            env: client.tenant.env,
+            decision: 'allow',
+            actorSubject: client.id,
+        });
+        sendJson(res, 200, result.response);
+    }
+    catch (error) {
+        if (!(error instanceof ConversationHistoryError))
+            throw error;
+        sendJson(res, error.code === 'conversation_unavailable' ? 503 : 400, {
+            code: error.code,
+            error: error.message,
+        });
+    }
+}
+//# sourceMappingURL=assistant-conversations.js.map

package/node_modules/@noodle-borg/service/dist/routes/assistant-dispatch.js

@@ -1,6 +1,7 @@
 import { handleAssistantAppRequest, handleAssistantPreflight, handleAssistantSession, handleAssistantTurn, handleConsoleApprovalNonce, } from './assistant.js';
 import { handleAssistantAppearance } from './assistant-appearance.js';
 import { handleAssistantClients } from './assistant-clients.js';
+import { handleAssistantConversations } from './assistant-conversations.js';
 import { handleAssistantDoctor } from './assistant-doctor.js';
 import { handleAssistantEmbedScript } from './assistant-embed-script.js';
 import { handleAssistantEmbeds } from './assistant-embeds.js';
@@ -60,6 +61,11 @@ export function dispatchAssistantRoutes(req, res, url, deps) {
     if (url.pathname === '/v1/assistant/sessions' && req.method === 'POST') {
         return run(req, res, deps, () => handleAssistantSession(req, res, deps));
     }
+    const conversationsMatch = /^\/v1\/assistant\/conversations\/(list|forget-user)$/.exec(url.pathname);
+    if (conversationsMatch?.[1] === 'list' || conversationsMatch?.[1] === 'forget-user') {
+        const action = conversationsMatch[1];
+        return run(req, res, deps, () => handleAssistantConversations(req, res, action, deps));
+    }
     if (url.pathname === '/v1/assistant/turns' && req.method === 'POST') {
         return run(req, res, deps, () => handleAssistantTurn(req, res, deps));
     }

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

@@ -3,6 +3,7 @@ import { anonymousBehavior } from '@noodle-borg/compiler';
 import { claimableStateHandleNames } from '@noodle-borg/runtime';
 import { sendJson } from '@noodle-borg/transport-http';
 import { assistantSessionResponseSchema } from '@noodle-borg/wire-contracts';
+import { sessionHistoryNotice, } from '../conversation-history/capture.js';
 function isMixed(surface) {
     return surface?.mode === 'mixed';
 }
@@ -147,6 +148,8 @@ export async function elevateAssistantSession(res, deps, input) {
         // The armed hint: the widget answers with one { resume: true } turn on the turns endpoint.
         ...(elevated.resumeArmed ? { resume: { tool: elevated.tool } } : {}),
         continuedAfterAuthentication: true,
+        // The caller is now verified, so the notice states the signed-in customers' window.
+        ...(await sessionHistoryNotice(deps.conversations, input.client.tenant, 'signed_in_customers', input.surfaceHistory)),
     };
     assistantSessionResponseSchema.parse(body);
     return sendJson(res, 200, body);

package/node_modules/@noodle-borg/service/dist/routes/assistant-interaction-stream.js

@@ -1,4 +1,5 @@
 import { assistantConfirmationProposal } from '@noodle-borg/assistant-gateway/portable';
+import { sessionSurfaceHistory } from '../conversation-history/capture.js';
 import { narrateInteractionResolution } from './assistant-agent.js';
 /** Stream the optional post-resolution narration without weakening the durable structured result. */
 export async function narrateResolvedInteraction(res, deps, target, session, tool, action, result, context, suggestions = false) {
@@ -10,7 +11,7 @@ export async function narrateResolvedInteraction(res, deps, target, session, too
                 { role: 'assistant', content: generated.narration, kind: 'visible' },
             ];
             await deps.store.appendHistory(session.id, rows);
-            await deps.conversations?.recordSessionTurn(session, rows);
+            await deps.conversations?.recordSessionTurn(session, rows, sessionSurfaceHistory(target.served.artifact.server.assistant, session));
         }
         if (generated.suggestions.length > 0) {
             await deps.store.replaceLatestSuggestions(session.id, {

package/node_modules/@noodle-borg/service/dist/routes/assistant-interactions.js

@@ -1,6 +1,7 @@
 import { AssistantInteractionCapacityError, assistantConfirmationReview, assistantConfirmationTransition, assistantInputTransition, assistantInteractionTool, assistantPreparedArgumentReview, assistantPreparedToolContinuation, assistantSafeOutput, assistantToolContinuation, assistantViewAvailableData, auditAssistantInteraction, boundedAssistantExecution, recoverableAssistantView, withAssistantSessionExecutionAuthority, } from '@noodle-borg/assistant-gateway/portable';
 import { executePreparedTool, executeToolInteractive, hasEphemeralEvidence, resumeTool, resumeToolPreparation, } from '@noodle-borg/runtime';
 import { readJsonBody, sendJson } from '@noodle-borg/transport-http';
+import { sessionSurfaceHistory } from '../conversation-history/capture.js';
 import { applyBrowserCors, authenticateSession, now, } from './assistant.js';
 import { replayOrConflict, writeUnknownOutcome } from './assistant-interaction-replay.js';
 import { parseInteractionResponse, validateInputContent } from './assistant-interaction-request.js';
@@ -340,11 +341,7 @@ async function finishExecution(res, deps, session, interaction, context, result,
             status: 'failed',
             reasonCode: code,
         });
-        await deps.conversations?.recordSessionOutcome(session, {
-            interactionId: interaction.id,
-            tool: toolName,
-            status: 'failed',
-        });
+        await deps.conversations?.recordSessionOutcome(session, { interactionId: interaction.id, tool: toolName, status: 'failed' }, sessionSurfaceHistory(target.served.artifact.server.assistant, session));
         writeInteractionSseHeaders(res, session.origin);
         writeInteractionResolved(res, interaction.id, 'accept');
         writeInteractionError(res, code, false);
@@ -375,11 +372,7 @@ async function finishExecution(res, deps, session, interaction, context, result,
             kind: 'narration',
         },
     ]);
-    await deps.conversations?.recordSessionOutcome(session, {
-        interactionId: interaction.id,
-        tool: toolName,
-        status: 'succeeded',
-    });
+    await deps.conversations?.recordSessionOutcome(session, { interactionId: interaction.id, tool: toolName, status: 'succeeded' }, sessionSurfaceHistory(target.served.artifact.server.assistant, session));
     writeInteractionSseHeaders(res, session.origin);
     writeInteractionResolved(res, interaction.id, 'accept');
     writeToolCompleted(res, interaction.id, toolName, safeOutput);
@@ -463,7 +456,9 @@ async function resolveStop(req, res, deps, session, interaction, action, suggest
         interactionId: interaction.id,
         tool: toolName,
         status: action === 'decline' ? 'declined' : 'cancelled',
-    });
+    }, 
+    // A vanished target leaves the surface unreadable, which records nothing (fail closed).
+    sessionSurfaceHistory(target?.served.artifact.server.assistant, session));
     writeInteractionSseHeaders(res, session.origin);
     writeInteractionResolved(res, interaction.id, action);
     if (target && context) {

package/node_modules/@noodle-borg/service/dist/routes/assistant-public-session.js

@@ -4,6 +4,7 @@ import { effectiveAssistantBrowserConfiguration, mintPublicSession, publicEmbedT
 import { assistantSessionUsageRequestEvent, captureAssistantUsage, captureRefusedAssistantSession, } from '@noodle-borg/observability';
 import { readJsonBody, sendJson } from '@noodle-borg/transport-http';
 import { assistantSessionResponseSchema } from '@noodle-borg/wire-contracts';
+import { sessionHistoryNotice, websiteSurfaceHistory, } from '../conversation-history/capture.js';
 import { applyBrowserCors, assistantSessionEndpoints, now } from './assistant-route-http.js';
 import { activeAssistantTarget } from './assistant-session-target.js';
 /**
@@ -35,6 +36,7 @@ export async function handlePublicAssistantSession(req, res, deps) {
     let configuration;
     let sponsoredBudget;
     let usageSession;
+    let surfaceHistory = { historyDisabled: true };
     const result = await mintPublicSession({ embedId, visitorId, origin, ...(addressBucket ? { addressBucket } : {}) }, deps.admissionEnvelope ?? ADMISSION_DEFAULTS, {
         embeds,
         counters,
@@ -59,6 +61,7 @@ export async function handlePublicAssistantSession(req, res, deps) {
                 !publicSurfaceOf(target.served.artifact.server.assistant)?.origins.includes(input.origin))
                 throw new Error('assistant surface changed mid-mint');
             const current = now(deps);
+            surfaceHistory = websiteSurfaceHistory(target.served.artifact.server.assistant, 'public');
             configuration = (await effectiveAssistantBrowserConfiguration(target.served.artifact.server, publicEmbedTenant(input.embed), deps.appearance, 'public', target.businessNotice)).effective;
             const created = await deps.store.createSession({
                 // A public surface has no client credential, so the embed id stands in as the minting
@@ -99,6 +102,9 @@ export async function handlePublicAssistantSession(req, res, deps) {
         expiresAt: result.expiresAt,
         endpoints: assistantSessionEndpoints(deps.serviceBase(req)),
         ...(configuration ? { configuration } : {}),
+        ...(usageSession
+            ? await sessionHistoryNotice(deps.conversations, usageSession.tenant, 'website_visitors', surfaceHistory)
+            : {}),
     };
     // Parse rather than trust: every published @noodleseed/assistant widget consumes this shape, and the
     // public mint must not be the path that quietly diverges from it (ADR 0151).

package/node_modules/@noodle-borg/service/dist/routes/assistant-route-http.js

@@ -60,4 +60,20 @@ export function assistantSessionEndpoints(base) {
         suggestions: `${base}/v1/assistant/suggestions`,
     };
 }
+/** HTTP Basic embed-client credentials for the backend-only assistant routes. */
+export function basicCredentials(req) {
+    const match = /^Basic\s+(.+)$/i.exec(req.headers.authorization ?? '');
+    if (!match?.[1])
+        return undefined;
+    try {
+        const decoded = Buffer.from(match[1], 'base64').toString('utf8');
+        const index = decoded.indexOf(':');
+        return index > 0
+            ? { id: decoded.slice(0, index), secret: decoded.slice(index + 1) }
+            : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
 //# sourceMappingURL=assistant-route-http.js.map

package/node_modules/@noodle-borg/service/dist/routes/assistant.js

@@ -8,11 +8,12 @@ import { mapExecutionError, mapResourceContents, mapResourcesList, mapToolOutput
 import { executeResource } from '@noodle-borg/runtime';
 import { readJsonBody, sendJson } from '@noodle-borg/transport-http';
 import { assistantMessageTurnRequestSchema, assistantResumeTurnRequestSchema, assistantSessionResponseSchema, } from '@noodle-borg/wire-contracts';
+import { sessionHistoryNotice, sessionSurfaceHistory, websiteSurfaceHistory, } from '../conversation-history/capture.js';
 import { sendForbidden, sendUnauthorized } from '../http-util.js';
 import { createAssistantTurnStats, runAgentTurn } from './assistant-agent.js';
 import { elevateAssistantSession } from './assistant-elevation.js';
 import { executeAssistantKnowledgeSearch, findAssistantKnowledgeComponent, resolveAssistantKnowledge, } from './assistant-knowledge.js';
-import { applyBrowserCors, assistantSessionEndpoints, authenticateSession, handleAssistantPreflight, now, } from './assistant-route-http.js';
+import { applyBrowserCors, assistantSessionEndpoints, authenticateSession, basicCredentials, handleAssistantPreflight, now, } from './assistant-route-http.js';
 import { activeAssistantTarget, sessionScopedTarget } from './assistant-session-target.js';
 import { authorizeControlPlane } from './control-plane.js';
 export { applyBrowserCors, authenticateSession, handleAssistantPreflight, now };
@@ -141,6 +142,7 @@ export async function handleAssistantSession(req, res, deps) {
             caller,
             configuration,
             endpoints: assistantSessionEndpoints(deps.serviceBase(req)),
+            surfaceHistory: websiteSurfaceHistory(assistant, surfaceBinding.kind),
         });
     }
     const session = await deps.store.createSession({
@@ -166,6 +168,7 @@ export async function handleAssistantSession(req, res, deps) {
         expiresAt: session.session.expiresAt,
         endpoints: assistantSessionEndpoints(deps.serviceBase(req)),
         ...(configuration ? { configuration } : {}),
+        ...(await sessionHistoryNotice(deps.conversations, client.tenant, 'signed_in_customers', websiteSurfaceHistory(assistant, surfaceBinding.kind))),
     };
     // Every published @noodleseed/assistant widget consumes this shape; parse (don't just test)
     // so a contract break fails loudly at mint time instead of stranding deployed widgets (ADR 0151).
@@ -344,7 +347,7 @@ export async function handleAssistantTurn(req, res, deps) {
         ];
         try {
             await deps.store.appendHistory(session.id, rows);
-            await deps.conversations?.recordSessionTurn(session, rows);
+            await deps.conversations?.recordSessionTurn(session, rows, sessionSurfaceHistory(target?.served.artifact.server.assistant, session));
         }
         catch {
             emit({ event: 'error', data: { code: 'conversation_state_failed', retryable: false } });
@@ -502,19 +505,4 @@ export async function handleAssistantAppRequest(req, res, deps) {
 function isRecord(value) {
     return typeof value === 'object' && value !== null && !Array.isArray(value);
 }
-function basicCredentials(req) {
-    const match = /^Basic\s+(.+)$/i.exec(req.headers.authorization ?? '');
-    if (!match?.[1])
-        return undefined;
-    try {
-        const decoded = Buffer.from(match[1], 'base64').toString('utf8');
-        const index = decoded.indexOf(':');
-        return index > 0
-            ? { id: decoded.slice(0, index), secret: decoded.slice(index + 1) }
-            : undefined;
-    }
-    catch {
-        return undefined;
-    }
-}
 //# sourceMappingURL=assistant.js.map

package/node_modules/@noodle-borg/service/dist/routes/business-information-activity.js

@@ -1,16 +1,17 @@
 import { readJsonBody, sendJson } from '@noodle-borg/transport-http';
-import { ActivityPolicyError, } from '../application-activity.js';
+import { ActivityPolicyError } from '../application-activity.js';
 import { businessGrantAllows } from '../business-information/model.js';
 import { requireIdentity, requireInstallationPermission, } from './business-information.js';
 export async function handleApplicationActivity(req, res, url, ref, deps) {
     const coordination = ref.action === 'coordination';
+    const history = ref.action === 'history';
     const suffix = url.pathname.split('/').at(-1);
     const action = coordination
         ? suffix === 'resolve'
             ? 'coordination-resolve'
             : 'coordination-list'
-        : suffix === 'settings'
-            ? req.method === 'PATCH'
+        : history
+            ? req.method === 'PUT'
                 ? 'save-settings'
                 : 'settings'
             : suffix === 'preview' || suffix === 'export'
@@ -20,8 +21,8 @@ export async function handleApplicationActivity(req, res, url, ref, deps) {
         ? suffix === 'resolve'
             ? ['POST']
             : ['GET']
-        : suffix === 'settings'
-            ? ['GET', 'PATCH']
+        : history
+            ? ['GET', 'PUT']
             : ['GET'];
     if (!allowed.includes(req.method ?? '')) {
         res.setHeader('allow', allowed.join(', '));