@noodleseed/one 0.173.0 → 0.175.0

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

@@ -0,0 +1,183 @@
+import { CHANNEL_RETENTION_MS } from './channel-types.js';
+export class CollectionError extends Error {
+    code;
+    constructor(code) {
+        super(code);
+        this.code = code;
+        this.name = 'CollectionError';
+    }
+}
+const TERMINAL = new Set(['completed', 'cancelled', 'expired']);
+const iso = (now) => new Date(now).toISOString();
+export function openCollection(spec, input) {
+    const fields = {};
+    for (const field of spec.fields)
+        fields[field.key] = { status: 'missing', attempts: 0 };
+    return {
+        id: input.id,
+        bindingId: input.bindingId,
+        participantId: input.participantId,
+        interactionId: spec.interactionId,
+        action: spec.action,
+        phase: 'collecting',
+        fields,
+        values: {},
+        createdAt: iso(input.now),
+        updatedAt: iso(input.now),
+        expiresAt: iso(input.now + (input.retentionMs ?? CHANNEL_RETENTION_MS)),
+    };
+}
+/** Non-consent fields a capture turn may still fill or repair. */
+export function neededFields(spec, ledger) {
+    return spec.fields.filter((field) => field.control !== 'consent' && ledger.fields[field.key]?.status !== 'captured');
+}
+function complete(spec, ledger) {
+    return spec.fields.every((field) => field.control === 'consent' ||
+        field.optional === true ||
+        ledger.fields[field.key]?.status === 'captured');
+}
+/** A spec without a consent control needs no consent turn: fields complete straight to confirmation. */
+function consentRequired(spec) {
+    return spec.fields.some((field) => field.control === 'consent');
+}
+function requireOpen(ledger) {
+    if (TERMINAL.has(ledger.phase) || ledger.phase === 'executing')
+        throw new CollectionError('phase_invalid');
+}
+/** Recompute the phase after fields changed; a changed value always drops the pending proposal. */
+function settle(spec, ledger, now) {
+    const { proposal: _dropped, ...rest } = ledger;
+    const phase = !complete(spec, ledger)
+        ? 'collecting'
+        : ledger.consent?.given || !consentRequired(spec)
+            ? 'awaiting_confirmation'
+            : 'awaiting_consent';
+    return { ...rest, phase, updatedAt: iso(now) };
+}
+function close(ledger, phase, now) {
+    const { proposal: _continuation, ...rest } = ledger;
+    return { ...rest, phase, values: {}, updatedAt: iso(now) };
+}
+export function applyCapture(spec, ledger, outcome, now) {
+    requireOpen(ledger);
+    const fields = { ...ledger.fields };
+    const values = { ...ledger.values };
+    let touched = false;
+    for (const field of spec.fields) {
+        const result = outcome[field.key];
+        if (result === undefined || field.control === 'consent')
+            continue;
+        touched = true;
+        const attempts = (fields[field.key]?.attempts ?? 0) + 1;
+        if (result.status === 'captured') {
+            fields[field.key] = { status: 'captured', attempts };
+            values[field.key] = result.value;
+        }
+        else {
+            fields[field.key] = { status: result.status, reason: result.reason, attempts };
+            delete values[field.key];
+        }
+    }
+    // A turn that changes nothing keeps the pending proposal; only a new value invalidates it.
+    if (!touched)
+        return { ...ledger, updatedAt: iso(now) };
+    return settle(spec, { ...ledger, fields, values }, now);
+}
+/** The user said a stored value is wrong; keep it so a partial correction can be applied. */
+export function rejectField(spec, ledger, key, now) {
+    requireOpen(ledger);
+    const current = ledger.fields[key];
+    if (current === undefined)
+        throw new CollectionError('field_unknown');
+    return settle(spec, {
+        ...ledger,
+        fields: {
+            ...ledger.fields,
+            [key]: { status: 'rejected_by_user', reason: 'rejected', attempts: current.attempts },
+        },
+    }, now);
+}
+export function applyConsent(spec, ledger, decision, questionVersion, now) {
+    if (ledger.phase !== 'awaiting_consent')
+        throw new CollectionError('phase_invalid');
+    const consent = { given: decision === 'given', questionVersion, at: iso(now) };
+    if (decision === 'declined')
+        return close({ ...ledger, consent }, 'cancelled', now);
+    const fields = { ...ledger.fields };
+    const values = { ...ledger.values };
+    for (const field of spec.fields) {
+        if (field.control !== 'consent')
+            continue;
+        fields[field.key] = { status: 'captured', attempts: (fields[field.key]?.attempts ?? 0) + 1 };
+        values[field.key] = true;
+    }
+    return {
+        ...ledger,
+        consent,
+        fields,
+        values,
+        phase: 'awaiting_confirmation',
+        updatedAt: iso(now),
+    };
+}
+export function attachProposal(spec, ledger, proposal, now) {
+    if (ledger.phase !== 'awaiting_confirmation' ||
+        (consentRequired(spec) && ledger.consent?.given !== true))
+        throw new CollectionError('phase_invalid');
+    return {
+        ...ledger,
+        proposal: {
+            ...proposal,
+            createdAt: iso(now),
+            expiresAt: iso(now + spec.confirmationExpiryMs),
+        },
+        updatedAt: iso(now),
+    };
+}
+export function pendingProposal(ledger, now) {
+    const proposal = ledger.proposal;
+    if (proposal === undefined || Date.parse(proposal.expiresAt) <= now)
+        return undefined;
+    return proposal;
+}
+export function applyConfirmation(ledger, act, now) {
+    if (act === 'cancel')
+        return cancelCollection(ledger, now);
+    if (ledger.phase !== 'awaiting_confirmation')
+        throw new CollectionError('phase_invalid');
+    if (ledger.proposal === undefined)
+        throw new CollectionError('proposal_missing');
+    if (pendingProposal(ledger, now) === undefined)
+        throw new CollectionError('proposal_expired');
+    return { ...ledger, phase: 'executing', updatedAt: iso(now) };
+}
+export function completeCollection(ledger, now) {
+    if (ledger.phase !== 'executing')
+        throw new CollectionError('phase_invalid');
+    const done = close(ledger, 'completed', now);
+    return ledger.proposal === undefined ? done : { ...done, executedProposalId: ledger.proposal.id };
+}
+/** The participant asked to change something before saying what: the proposal and its acts lapse, every value stays. */
+export function withdrawProposal(ledger, now) {
+    requireOpen(ledger);
+    const { proposal: _withdrawn, ...rest } = ledger;
+    return { ...rest, updatedAt: iso(now) };
+}
+export function cancelCollection(ledger, now) {
+    if (TERMINAL.has(ledger.phase))
+        throw new CollectionError('phase_invalid');
+    return close(ledger, 'cancelled', now);
+}
+/** Returns the same ledger when nothing has expired, so callers can detect a change by identity. */
+export function expireCollection(ledger, now) {
+    if (TERMINAL.has(ledger.phase))
+        return ledger;
+    if (Date.parse(ledger.expiresAt) <= now)
+        return close(ledger, 'expired', now);
+    if (ledger.proposal !== undefined && pendingProposal(ledger, now) === undefined) {
+        const { proposal: _expired, ...rest } = ledger;
+        return { ...rest, updatedAt: iso(now) };
+    }
+    return ledger;
+}
+//# sourceMappingURL=collection-ledger.js.map

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

@@ -0,0 +1,38 @@
+import { requestModelCompletion } from './model-request.js';
+export const COLLECTION_MODEL_TIMEOUT_MS = 30_000;
+const MAX_RESPONSE_BYTES = 1 << 16;
+const MAX_COMPLETION_TOKENS = 512;
+/**
+ * One tool-free JSON-mode request with exactly two messages: the task and the user's text. Transport
+ * and admission errors propagate to the caller; output that fails the schema reads as `undefined`.
+ */
+export async function boundedJsonCall(deps, system, user, schema) {
+    const signal = AbortSignal.any([deps.signal, AbortSignal.timeout(COLLECTION_MODEL_TIMEOUT_MS)].filter((candidate) => candidate !== undefined));
+    const completion = await requestModelCompletion({
+        binding: deps.binding,
+        messages: [
+            { role: 'system', content: system },
+            { role: 'user', content: user },
+        ],
+        tools: [],
+        toolChoice: 'none',
+        jsonOutput: true,
+        fetcher: deps.fetcher,
+        maxResponseBytes: MAX_RESPONSE_BYTES,
+        maxCompletionTokens: MAX_COMPLETION_TOKENS,
+        signal,
+    });
+    const content = completion.choices[0]?.message.content;
+    if (typeof content !== 'string')
+        return undefined;
+    let parsed;
+    try {
+        parsed = JSON.parse(content);
+    }
+    catch {
+        return undefined;
+    }
+    const result = schema.safeParse(parsed);
+    return result.success ? result.data : undefined;
+}
+//# sourceMappingURL=collection-model-call.js.map

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

@@ -0,0 +1,22 @@
+/**
+ * Deterministic readers for typed collection controls (ADR 0240 decision 5). A correctly typed value
+ * is read here and never reaches a model; the same rules validate whatever a model does return.
+ */
+export type ParsedControl = 'email' | 'phone' | 'url';
+export interface ParsedSpan {
+    readonly control: ParsedControl;
+    /** Normalised value: lowercase domain or host, `+` and digits for phones, https for bare hosts. */
+    readonly value: string;
+    readonly start: number;
+    readonly end: number;
+}
+/** Validate and normalise one whole value with the control's rules; `undefined` means not that type. */
+export declare function normaliseTypedValue(control: ParsedControl, raw: string): string | undefined;
+/**
+ * Every candidate of the requested controls, in text order. Emails claim their span before URLs and
+ * URLs before phones, so digits inside an address are never read as a number.
+ */
+export declare function scanTypedValues(text: string, controls: readonly ParsedControl[]): readonly ParsedSpan[];
+/** Replace each span with the caller's placeholder; used before any utterance reaches a model. */
+export declare function redactSpans(text: string, spans: readonly ParsedSpan[], placeholder: (span: ParsedSpan) => string): string;
+//# sourceMappingURL=collection-parsers.d.ts.map

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

@@ -0,0 +1,109 @@
+const EMAIL = /[A-Za-z0-9._%+-]+@[A-Za-z0-9](?:[A-Za-z0-9-]*[A-Za-z0-9])?(?:\.[A-Za-z0-9](?:[A-Za-z0-9-]*[A-Za-z0-9])?)+/g;
+const ABSOLUTE_URL = /https?:\/\/[^\s<>"'`]+/gi;
+const BARE_HOST = /(?<![\w@./-])(?:[A-Za-z0-9-]+\.)+[A-Za-z]{2,}(?:\/[^\s<>"'`]*)?/g;
+/** Plain digit runs with the separators people type; at least seven digits (dates match: accepted). */
+const PHONE = /\+?\(?\d[\d\s().-]{5,}\d/g;
+const URL_TRAILING = /[.,;:!?)\]]+$/;
+const HOST = /^(?:[A-Za-z0-9-]+\.)+[A-Za-z]{2,}(?::\d{2,5})?$/;
+/** Bare tokens ending in a file extension are attachments people mention, not websites. */
+const FILE_EXTENSIONS = new Set([
+    'pdf',
+    'doc',
+    'docx',
+    'xls',
+    'xlsx',
+    'ppt',
+    'pptx',
+    'csv',
+    'txt',
+    'png',
+    'jpg',
+    'jpeg',
+    'gif',
+    'zip',
+    'mp3',
+    'mp4',
+]);
+const SCAN_ORDER = ['email', 'url', 'phone'];
+function normaliseEmail(raw) {
+    const match = raw.match(EMAIL);
+    if (match?.length !== 1 || match[0] !== raw)
+        return undefined;
+    const at = raw.lastIndexOf('@');
+    return `${raw.slice(0, at)}@${raw.slice(at + 1).toLowerCase()}`;
+}
+function normalisePhone(raw) {
+    if (!/^\+?[\d\s().-]+$/.test(raw))
+        return undefined;
+    const digits = raw.replace(/\D/g, '');
+    if (digits.length < 7 || digits.length > 15)
+        return undefined;
+    return `${raw.startsWith('+') ? '+' : ''}${digits}`;
+}
+function normaliseUrl(raw) {
+    const trimmed = raw.replace(URL_TRAILING, '');
+    const absolute = /^https?:\/\//i.test(trimmed);
+    const candidate = absolute ? trimmed : `https://${trimmed}`;
+    const parts = /^(https?):\/\/([^/?#\s]+)(.*)$/i.exec(candidate);
+    const scheme = parts?.[1];
+    const rawHost = parts?.[2];
+    if (scheme === undefined || rawHost === undefined || !HOST.test(rawHost))
+        return undefined;
+    const host = rawHost.toLowerCase();
+    if (!absolute && FILE_EXTENSIONS.has(host.slice(host.lastIndexOf('.') + 1)))
+        return undefined;
+    return `${scheme.toLowerCase()}://${host}${parts?.[3] ?? ''}`;
+}
+/** Validate and normalise one whole value with the control's rules; `undefined` means not that type. */
+export function normaliseTypedValue(control, raw) {
+    const value = raw.trim();
+    if (value.length === 0 || value.length > 2048)
+        return undefined;
+    if (control === 'email')
+        return normaliseEmail(value);
+    if (control === 'phone')
+        return normalisePhone(value);
+    return normaliseUrl(value);
+}
+function matches(text, control) {
+    const patterns = control === 'email' ? [EMAIL] : control === 'url' ? [ABSOLUTE_URL, BARE_HOST] : [PHONE];
+    const found = [];
+    for (const pattern of patterns) {
+        for (const match of text.matchAll(pattern)) {
+            const raw = control === 'url' ? match[0].replace(URL_TRAILING, '') : match[0];
+            if (raw.length > 0)
+                found.push({ start: match.index, end: match.index + raw.length });
+        }
+    }
+    return found.sort((a, b) => a.start - b.start);
+}
+/**
+ * Every candidate of the requested controls, in text order. Emails claim their span before URLs and
+ * URLs before phones, so digits inside an address are never read as a number.
+ */
+export function scanTypedValues(text, controls) {
+    const spans = [];
+    for (const control of SCAN_ORDER) {
+        if (!controls.includes(control))
+            continue;
+        for (const { start, end } of matches(text, control)) {
+            if (spans.some((span) => start < span.end && end > span.start))
+                continue;
+            const value = normaliseTypedValue(control, text.slice(start, end));
+            if (value !== undefined)
+                spans.push({ control, value, start, end });
+        }
+    }
+    return spans.sort((a, b) => a.start - b.start);
+}
+/** Replace each span with the caller's placeholder; used before any utterance reaches a model. */
+export function redactSpans(text, spans, placeholder) {
+    let out = '';
+    let cursor = 0;
+    for (const span of [...spans].sort((a, b) => a.start - b.start)) {
+        out += text.slice(cursor, span.start) + placeholder(span);
+        cursor = span.end;
+    }
+    return out + text.slice(cursor);
+}
+//# sourceMappingURL=collection-parsers.js.map

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

@@ -0,0 +1,21 @@
+import type { CollectionConsent, CollectionFieldStatus, CollectionLedger, CollectionPhase, CollectionSpec } from './collection-ledger.js';
+/** What the conversation model may see: statuses, reason codes and non-private values only. */
+export interface CollectionModelView {
+    readonly phase: CollectionPhase;
+    readonly consent?: 'given' | 'declined';
+    readonly fields: readonly {
+        readonly key: string;
+        readonly title: string;
+        readonly status: CollectionFieldStatus;
+        readonly reason?: string;
+    }[];
+    readonly values: Readonly<Record<string, unknown>>;
+    readonly pendingProposal: boolean;
+}
+/**
+ * The exact review the confirmation binds to: one `Title: value` line per non-consent field in spec
+ * order, then the contact permission line. The caller renders this string; a model never restates it.
+ */
+export declare function renderReview(spec: CollectionSpec, values: Readonly<Record<string, unknown>>, consent: CollectionConsent | undefined): string;
+export declare function ledgerForModel(spec: CollectionSpec, ledger: CollectionLedger, now: number): CollectionModelView;
+//# sourceMappingURL=collection-review.d.ts.map

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

@@ -0,0 +1,44 @@
+import { pendingProposal } from './collection-ledger.js';
+function formatValue(value) {
+    if (value === undefined || value === null || value === '')
+        return 'none';
+    return typeof value === 'string' ? value : JSON.stringify(value);
+}
+/**
+ * The exact review the confirmation binds to: one `Title: value` line per non-consent field in spec
+ * order, then the contact permission line. The caller renders this string; a model never restates it.
+ */
+export function renderReview(spec, values, consent) {
+    const lines = spec.fields
+        .filter((field) => field.control !== 'consent')
+        .map((field) => `${field.title}: ${formatValue(values[field.key])}`);
+    if (spec.fields.some((field) => field.control === 'consent'))
+        lines.push(`Contact permission: ${consent?.given === true ? 'yes' : 'no'}`);
+    return lines.join('\n');
+}
+export function ledgerForModel(spec, ledger, now) {
+    const values = {};
+    const fields = spec.fields
+        .filter((field) => field.control !== 'consent')
+        .map((field) => {
+        const state = ledger.fields[field.key] ?? { status: 'missing', attempts: 0 };
+        if (state.status === 'captured' && field.private !== true && field.key in ledger.values)
+            values[field.key] = ledger.values[field.key];
+        return {
+            key: field.key,
+            title: field.title,
+            status: state.status,
+            ...(state.reason === undefined ? {} : { reason: state.reason }),
+        };
+    });
+    return {
+        phase: ledger.phase,
+        ...(ledger.consent === undefined
+            ? {}
+            : { consent: ledger.consent.given ? 'given' : 'declined' }),
+        fields,
+        values,
+        pendingProposal: pendingProposal(ledger, now) !== undefined,
+    };
+}
+//# sourceMappingURL=collection-review.js.map

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

@@ -0,0 +1,18 @@
+import { type RuntimeArtifact } from '@noodle-borg/compiler';
+import { type CollectionLedger, type CollectionSpec } from './collection-ledger.js';
+/** Platform default confirmation expiry for the WhatsApp profile (ADR 0240 decision 9). */
+export declare const WHATSAPP_CONFIRMATION_EXPIRY_MS = 600000;
+/**
+ * Derive the runtime collection spec from an opener's compiled `collect` interaction and its action's
+ * input schema (ADR 0240 decision 5). Field titles, options and validation come from the action
+ * schema, so the review and every candidate check use the same contract the action itself enforces;
+ * the consent question is fixed runtime wording, never authored prose.
+ */
+export declare function collectionSpecFor(artifact: RuntimeArtifact, opener: string, profileExpiryMs: number): CollectionSpec | undefined;
+/**
+ * Seed a freshly opened ledger from the opener's output through the interaction's `initialValues`.
+ * A seeded value that is a declared field is captured only if the action schema accepts it; a seeded
+ * input that is not a field rides along in the ledger values so the prepared action still receives it.
+ */
+export declare function seedCollection(artifact: RuntimeArtifact, spec: CollectionSpec, ledger: CollectionLedger, output: unknown, now: number): CollectionLedger;
+//# sourceMappingURL=collection-spec.d.ts.map

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

@@ -0,0 +1,86 @@
+import { validateJsonSchema } from '@noodle-borg/compiler';
+import { applyCapture, } from './collection-ledger.js';
+/** Platform default confirmation expiry for the WhatsApp profile (ADR 0240 decision 9). */
+export const WHATSAPP_CONFIRMATION_EXPIRY_MS = 600_000;
+/**
+ * Derive the runtime collection spec from an opener's compiled `collect` interaction and its action's
+ * input schema (ADR 0240 decision 5). Field titles, options and validation come from the action
+ * schema, so the review and every candidate check use the same contract the action itself enforces;
+ * the consent question is fixed runtime wording, never authored prose.
+ */
+export function collectionSpecFor(artifact, opener, profileExpiryMs) {
+    const interaction = artifact.toolInteractions?.[opener];
+    const action = artifact.tools.find((tool) => tool.name === interaction?.action);
+    if (interaction === undefined || action === undefined)
+        return undefined;
+    const properties = objectProperties(action.inputSchema);
+    const fields = [];
+    for (const field of interaction.fields) {
+        const schema = properties[field.key];
+        if (schema === undefined)
+            return undefined;
+        const options = Array.isArray(schema.enum)
+            ? schema.enum.filter((option) => typeof option === 'string')
+            : undefined;
+        fields.push({
+            key: field.key,
+            title: typeof schema.title === 'string' && schema.title ? schema.title : humanise(field.key),
+            control: field.control,
+            ...(field.private === true ? { private: true } : {}),
+            ...(field.optional === true ? { optional: true } : {}),
+            ...(field.control === 'select' && options !== undefined ? { options } : {}),
+            schema,
+        });
+    }
+    const brand = artifact.server.branding?.name ?? artifact.server.title;
+    const authored = interaction.confirmationExpirySeconds;
+    return {
+        interactionId: opener,
+        action: action.name,
+        fields,
+        consentQuestion: `Do you agree to ${brand} contacting you about this request? Yes or no.`,
+        successMessage: interaction.outcome.success,
+        confirmationExpiryMs: authored === undefined ? profileExpiryMs : Math.min(profileExpiryMs, authored * 1000),
+    };
+}
+/**
+ * Seed a freshly opened ledger from the opener's output through the interaction's `initialValues`.
+ * A seeded value that is a declared field is captured only if the action schema accepts it; a seeded
+ * input that is not a field rides along in the ledger values so the prepared action still receives it.
+ */
+export function seedCollection(artifact, spec, ledger, output, now) {
+    const sources = artifact.toolInteractions?.[spec.interactionId]?.initialValues ?? {};
+    const record = typeof output === 'object' && output !== null && !Array.isArray(output)
+        ? output
+        : {};
+    const outcome = {};
+    const extra = {};
+    for (const [target, source] of Object.entries(sources)) {
+        const value = record[source.fromOutput];
+        if (value === undefined || value === null)
+            continue;
+        const field = spec.fields.find((candidate) => candidate.key === target);
+        if (field === undefined)
+            extra[target] = value;
+        else
+            outcome[target] =
+                validateJsonSchema(field.schema, value).length === 0
+                    ? { status: 'captured', value }
+                    : { status: 'invalid', reason: 'schema' };
+    }
+    const seeded = applyCapture(spec, { ...ledger, values: { ...extra, ...ledger.values } }, outcome, now);
+    return seeded;
+}
+function humanise(key) {
+    const words = key.replace(/([a-z0-9])([A-Z])/g, '$1 $2').replace(/[_-]+/g, ' ');
+    return words.charAt(0).toUpperCase() + words.slice(1).toLowerCase();
+}
+function objectProperties(schema) {
+    const properties = schema?.properties;
+    if (typeof properties !== 'object' || properties === null || Array.isArray(properties))
+        return {};
+    return Object.fromEntries(Object.entries(properties).flatMap(([key, value]) => typeof value === 'object' && value !== null && !Array.isArray(value)
+        ? [[key, value]]
+        : []));
+}
+//# sourceMappingURL=collection-spec.js.map

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

@@ -0,0 +1,11 @@
+import type { ChannelTransaction } from './channel-store.js';
+import type { CollectionLedger } from './collection-ledger.js';
+/**
+ * One sealed `interaction` row per participant inside the binding scope: the fixed id is what makes
+ * "at most one open collection" true, and the row carries only the phase and expiry in the clear.
+ */
+export declare function collectionRowId(participantId: string): string;
+export declare function loadCollection(tx: ChannelTransaction, bindingId: string, participantId: string): Promise<CollectionLedger | undefined>;
+export declare function saveCollection(tx: ChannelTransaction, ledger: CollectionLedger): Promise<void>;
+export declare function deleteCollection(tx: ChannelTransaction, bindingId: string, participantId: string): Promise<void>;
+//# sourceMappingURL=collection-store.d.ts.map

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

@@ -0,0 +1,18 @@
+import { channelRow, channelValue } from './channel-types.js';
+/**
+ * One sealed `interaction` row per participant inside the binding scope: the fixed id is what makes
+ * "at most one open collection" true, and the row carries only the phase and expiry in the clear.
+ */
+export function collectionRowId(participantId) {
+    return `interaction:${participantId}`;
+}
+export async function loadCollection(tx, bindingId, participantId) {
+    return channelValue(tx, bindingId, collectionRowId(participantId));
+}
+export async function saveCollection(tx, ledger) {
+    await tx.put(ledger.bindingId, channelRow(collectionRowId(ledger.participantId), 'interaction', ledger, Date.parse(ledger.updatedAt), { state: ledger.phase, expiresAt: Date.parse(ledger.expiresAt) }));
+}
+export async function deleteCollection(tx, bindingId, participantId) {
+    await tx.remove(bindingId, collectionRowId(participantId));
+}
+//# sourceMappingURL=collection-store.js.map

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

@@ -2,7 +2,25 @@ 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. */
+import { type CollectionLedger } from './collection-ledger.js';
+/**
+ * How a messaging turn opens natural collection when the model calls a `collect` opener (ADR 0240).
+ * The transport owns the participant's ledger custody; the dispatcher only opens and seeds.
+ */
+export interface MessagingCollectionPort {
+    /** The participant's open ledger, if any: an opener never opens a second one. */
+    readonly open: CollectionLedger | undefined;
+    readonly now: number;
+    readonly retentionMs: number;
+    readonly confirmationExpiryMs: number;
+    save(ledger: CollectionLedger): Promise<void>;
+}
+/**
+ * Read-only transport adapter over the same authorized runtime. A `collect` opener is the one
+ * exception: it runs as a read, then opens the participant's collection and tells the model which
+ * fields are needed; its confirmed action is never callable here and executes only through the
+ * confirmed proposal path.
+ */
 export declare function dispatchMessagingReadTool(input: {
     readonly artifact: RuntimeArtifact;
     readonly tool: RuntimeArtifact['tools'][number];
@@ -11,5 +29,6 @@ export declare function dispatchMessagingReadTool(input: {
     readonly context: InvocationContext;
     readonly session: MessagingTurnContext;
     readonly claimTool: (name: string) => Promise<boolean>;
+    readonly collection?: MessagingCollectionPort;
 }): Promise<AssistantToolDispatch>;
 //# sourceMappingURL=messaging-tool-dispatch.d.ts.map

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

@@ -1,24 +1,42 @@
+import { randomUUID } from 'node:crypto';
 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. */
+import { openCollection } from './collection-ledger.js';
+import { ledgerForModel } from './collection-review.js';
+import { collectionSpecFor, seedCollection } from './collection-spec.js';
+const COLLECTION_GUIDANCE = 'The platform is collecting these fields in this conversation: ask naturally for the ones still missing, in any order and without counters. It validates values, asks for consent, shows the review and confirms. Never mention a form, never ask for or repeat private values, and never claim anything was sent.';
+/**
+ * Read-only transport adapter over the same authorized runtime. A `collect` opener is the one
+ * exception: it runs as a read, then opens the participant's collection and tells the model which
+ * fields are needed; its confirmed action is never callable here and executes only through the
+ * confirmed proposal path.
+ */
 export async function dispatchMessagingReadTool(input) {
     const denied = (code) => ({
         kind: 'event',
         event: 'error',
         data: { code, retryable: false },
     });
+    const collection = input.artifact.toolInteractions?.[input.tool.name] === undefined ? undefined : input.collection;
     if (input.tool.annotations?.readOnlyHint !== true ||
         requiresToolConfirmation(input.tool.annotations) ||
-        input.tool._meta?.ui)
+        (input.tool._meta?.ui && collection === undefined))
         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 spec = collection === undefined
+        ? undefined
+        : collectionSpecFor(input.artifact, input.tool.name, collection.confirmationExpiryMs);
+    if (collection !== undefined && spec === undefined)
+        return denied('messaging_action_unsupported');
+    if (collection?.open !== undefined && spec !== undefined)
+        return collectionResult(spec, collection.open, collection.now, 'already_open');
     const result = await executeToolInteractive(input.artifact, input.tool.name, input.arguments, {
         ...withAssistantTurnExecutionAuthority(input.executeDeps, input.artifact, input.session),
         caller: input.session.caller,
@@ -26,9 +44,27 @@ export async function dispatchMessagingReadTool(input) {
     });
     if (result.status !== 'completed')
         return denied(result.status === 'failed' ? result.error.code : 'messaging_action_unsupported');
+    if (collection !== undefined && spec !== undefined) {
+        const ledger = seedCollection(input.artifact, spec, openCollection(spec, {
+            id: randomUUID(),
+            bindingId: input.session.bindingId,
+            participantId: input.session.participantId,
+            now: collection.now,
+            retentionMs: collection.retentionMs,
+        }), result.output, collection.now);
+        await collection.save(ledger);
+        return collectionResult(spec, ledger, collection.now, 'opened');
+    }
     return {
         kind: 'tool_result',
         output: assistantSafeOutput(input.tool.outputSchema, result.output),
     };
 }
+/** The model sees the ledger view, never the opener's own output, which may carry website copy. */
+function collectionResult(spec, ledger, now, collection) {
+    return {
+        kind: 'tool_result',
+        output: { collection, ...ledgerForModel(spec, ledger, now), guidance: COLLECTION_GUIDANCE },
+    };
+}
 //# sourceMappingURL=messaging-tool-dispatch.js.map