@noodleseed/one 0.173.0 → 0.175.0

package/node_modules/@noodle-borg/agent-kit/dist/generated/surface.js

@@ -176,6 +176,15 @@ export const COMPILE_ERROR_CODES = [
     'assistant_capability_unknown',
     'assistant_public_user_reference',
     'assistant_public_effect_unconfirmed',
+    'interaction_action_invalid',
+    'interaction_field_unknown',
+    'interaction_field_control_mismatch',
+    'interaction_field_missing',
+    'interaction_initial_value_unknown',
+    'interaction_consent_invalid',
+    'interaction_expiry_invalid',
+    'channel_dependency_missing',
+    'channel_requirement_unsupported',
     'customer_endpoint_action_unsupported',
     'customer_endpoint_surface_unsupported',
     'customer_endpoint_credential_source_unsupported',

package/node_modules/@noodle-borg/agent-kit/dist/skill-authoring-refs.js

@@ -274,7 +274,7 @@ export function renderAuthoringWorkflowReference() {
         'Omitting `source` makes Noodle authoritative for the collection. To project a read-only collection from an outside system, bind an HTTP connector in `server(..., { use: [...] })` and add `source: { connector: connector.ref(), scan: "scan_operation" }`. The compiler requires the exact normalized scan contract and the same record schema. Noodle ingests a one-way replica; create, update, and delete in the outside system remain ordinary application tools with their own confirmation and policy.',
         '',
         'For an explicitly authored native operation, bind `use: { records: noodlePlatform.records.v1 }` and call `connectors.records.submitRecord({ collection: "guest_requests", payload: input })` from an ordinary confirmed tool. Submission accepts only public fields and returns a receipt. `createRecord`, `getRecord`, `listRecords`, `updateRecord`, and `deleteRecord` require a verified platform caller with a live business grant; updates/deletes require the current revision. `updateRecord({ collection, id, expectedRevision, patch, unset: ["optional_field"] })` removes named optional editable fields; omitted keys stay unchanged, `null` is data, and overlap with `patch`, required fields or undeclared fields is rejected. Runtime identity supplies write idempotency and admission; never accept those controls as model arguments. An uninstalled collection is unavailable, including during local tool execution.',
-        'A collection declaration does not create a submit tool, grant access, select retention or residency, provision storage, or expose records to MCP or an embedded assistant. Operators activate the definition and configure lifecycle, access, and any external binding. A connector does not become a collection unless the app explicitly supplies the source contract, and an external collection never becomes a writable mirror.',
+        'A collection declaration does not create a submit tool, grant access, select retention or residency, provision storage, or expose records to MCP or an embedded assistant. Operators activate the definition and configure lifecycle, access, and any external binding. Native records retain legacy creation-time expiry until an Owner/Admin explicitly reviews and confirms preservation through Business settings or `noodle solutions records lifecycle`. Then expiry is null (until explicit erasure); activity history caps remain separate. Never change expiry in authored tools or infer an appointment was fulfilled from a saved request. A connector does not become a collection unless the app explicitly supplies the source contract, and an external collection never becomes a writable mirror.',
         '',
         '## Boundaries',
         '',

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

@@ -7,6 +7,7 @@ export function renderEmbeddedAssistantReference() {
         '',
         '## Contents',
         '',
+        '- Collect interactions',
         '- Architecture',
         '- Select the architecture before code',
         '- First-workflow default: continuous onboarding',
@@ -30,10 +31,21 @@ export function renderEmbeddedAssistantReference() {
         '',
         '## WhatsApp public alpha',
         '',
-        'Reuse the same server and public read-only capabilities with `publicMessaging({ channel: "whatsapp", capabilities: [product, siteIdentity] })` in `embeddedAssistant.access`. Import `publicMessaging` from `@noodleseed/one`. This projection is explicit: browser widgets, confirmed writes, customer identity and native forms are not supported in this first slice. A WhatsApp participant is anonymous; never infer a customer account from its phone number.',
+        'Reuse the same server and public read-only capabilities with `publicMessaging({ channel: "whatsapp", capabilities: [product, siteIdentity] })` in `embeddedAssistant.access`. Import `publicMessaging` from `@noodleseed/one`. This projection is explicit: knowledge, pure public reads, and a `collect` opener listed with its confirmed native-record action. The platform’s natural collection gathers the opener’s fields in conversation, asks the consent question, renders the review verbatim and confirms; a field marked `private: true` never reaches the conversation model or the transcript. Other writes, connector-backed lookups, customer identity and browser widgets without an interaction are not supported. A WhatsApp participant is anonymous; never infer a customer account from its phone number.',
         '',
         'Operator setup uses `noodle channels whatsapp configure`, managed secret references, `webhook configure`, `doctor`, and `enable`. Start paused. Only a service advertising `features.whatsapp: 1`, durable storage, a running worker, a verified cost bound and matching provider webhook can enable. Use `noodle channels whatsapp --help` for the complete operator command catalog. Keep real keys in `noodle secrets`, never in source, flags or messages. ChatGPT and Claude continue to use the same app MCP endpoint with their own host configuration.',
         '',
+        '## Collect interactions',
+        '',
+        'An opener `tool()` may declare `interaction: { kind: "collect", action, fields, review: "all", outcome }`: one definition of a form-like exchange that Noodle Seed presents with the controls each channel has. On the website the tool’s React `view` (or a standard form) collects the fields; on a messaging channel the platform renderer gathers the same fields in natural conversation, renders the review verbatim, and saves through the same confirmed `action`. The block carries meaning, never layout, ordering or screen language; `noodle validate` checks it against the action’s input schema.',
+        '',
+        '- `action` is a tool with `annotations.openAction({ confirm: true })` (never read-only) whose fulfilment saves one native record through `connectors.records`.',
+        '- `fields` name the action’s Zod input keys with one of seven controls: `text`, `textarea`, `email`, `phone`, `url`, `select` (a `z.enum` of strings) and `consent` (`z.literal(true)`, at most one; the runtime poses the consent question and never infers it).',
+        '- Nothing is private by default. `private: true` keeps that value out of the conversation model, transcript, logs and diagnostics. `optional: true` lets a person skip a field; an optional field the schema still requires must accept `""`.',
+        '- `initialValues: { workflow: { fromOutput: "workflow" } }` seeds action inputs from the opener’s `output`; every other required action input must be a field.',
+        '- `confirmationExpiry: { seconds }` may only shorten the channel’s default (ten minutes on WhatsApp), never lengthen it.',
+        '- On `publicMessaging`, list the opener and its action together. The compiler reports `channel_dependency_missing` for an opener selected alone and `channel_requirement_unsupported` for a widget, write or external connector call that has no collect interaction.',
+        '',
         '## Architecture',
         '',
         'The browser never receives a model key, assistant client secret, MCP token, or raw application session. The embedding SaaS authenticates its own user, its backend exchanges that verified identity through `@noodleseed/assistant/server`, and the browser receives only a short-lived assistant session.',

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

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

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

@@ -1,5 +1,6 @@
 import type { ChannelStore, ChannelTransaction } from './channel-store.js';
-import { type ChannelBinding, type ChannelConfigure, type ChannelEvent, type ChannelInbound, type ChannelLimitsInput } from './channel-types.js';
+import { type ChannelBinding, type ChannelConfigure, type ChannelEvent, type ChannelInbound, type ChannelLimitsInput, type ChannelReplyButton } from './channel-types.js';
+import { type ChannelTranscript } from './channel-work.js';
 import type { TenantRef } from './tenant-ref.js';
 export interface ChannelBlock {
     readonly participantId: string;
@@ -115,11 +116,12 @@ export declare class ChannelCoordinator {
     expireHistory(id: string, retentionMs: number): Promise<void>;
     claimTool(id: string, participantId: string, name: string): Promise<boolean>;
     event(id: string, eventId: string): Promise<ChannelEvent | undefined>;
-    fail(id: string, eventId: string, lease: string, code: string): Promise<void>;
+    /** Close a running turn without a reply: `failed` for an error, `cancelled` for input that is deliberately not answered. */
+    fail(id: string, eventId: string, lease: string, code: string, state?: 'failed' | 'cancelled'): Promise<void>;
     receive(id: string, messages: readonly ChannelInbound[], retentionMs?: number): Promise<Pick<ChannelEvent, "state" | "id" | "code" | "participantId">[]>;
     claim(id: string, retentionMs?: number): Promise<import("./channel-work.js").ChannelWork | undefined>;
     renew(id: string, eventId: string, lease: string): Promise<void>;
-    complete(id: string, eventId: string, lease: string, reply: string, retentionMs?: number, code?: string): Promise<void>;
+    complete(id: string, eventId: string, lease: string, reply: string, retentionMs?: number, code?: string, transcript?: ChannelTranscript, buttons?: readonly ChannelReplyButton[]): Promise<void>;
     assertSend(id: string, eventId: string, lease: string): Promise<void>;
     prepareSend(id: string): Promise<import("./channel-work.js").ChannelWork | undefined>;
     sent(id: string, eventId: string, lease: string, result: {

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

@@ -336,12 +336,13 @@ export class ChannelCoordinator {
             return channelValue(tx, id, eventId);
         });
     }
-    async fail(id, eventId, lease, code) {
+    /** Close a running turn without a reply: `failed` for an error, `cancelled` for input that is deliberately not answered. */
+    async fail(id, eventId, lease, code, state = 'failed') {
         await this.store.transaction([id], async (tx) => {
             const event = await channelValue(tx, id, eventId);
             if (!event || event.lease !== lease || event.state !== 'running')
                 return;
-            await writeChannelEvent(tx, id, { ...event, state: 'failed', code }, this.now());
+            await writeChannelEvent(tx, id, { ...event, state, code }, this.now());
         });
     }
     receive(id, messages, retentionMs = CHANNEL_RETENTION_MS) {
@@ -353,8 +354,8 @@ export class ChannelCoordinator {
     renew(id, eventId, lease) {
         return renewChannelTurn(this.store, id, eventId, lease, this.now());
     }
-    complete(id, eventId, lease, reply, retentionMs = CHANNEL_RETENTION_MS, code) {
-        return completeChannelTurn(this.store, id, eventId, lease, reply, this.now(), retentionMs, code);
+    complete(id, eventId, lease, reply, retentionMs = CHANNEL_RETENTION_MS, code, transcript, buttons) {
+        return completeChannelTurn(this.store, id, eventId, lease, reply, this.now(), retentionMs, code, transcript, buttons);
     }
     assertSend(id, eventId, lease) {
         return assertChannelSend(this.store, id, eventId, lease, this.now());

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

@@ -67,7 +67,10 @@ export async function receiveChannelMessages(store, id, messages, now, retention
             const sequence = ((await channelValue(tx, id, 'sequence')) ?? 0) + 1;
             await tx.put(id, channelRow('sequence', 'counter', sequence, now));
             const eventId = `e_${String(sequence).padStart(20, '0')}`;
-            const unsupported = message.text === undefined || message.text.length > binding.limits.textCharacters;
+            const text = message.text !== undefined && message.text.length <= binding.limits.textCharacters
+                ? message.text
+                : undefined;
+            const unsupported = text === undefined && message.button === undefined;
             let event = {
                 id: eventId,
                 participantId,
@@ -79,7 +82,8 @@ export async function receiveChannelMessages(store, id, messages, now, retention
                 attempts: 0,
                 state: code ? 'refused' : unsupported ? 'reply' : 'queued',
                 ...(code ? { code } : {}),
-                ...(!code && !unsupported ? { text: message.text } : {}),
+                ...(!code && text !== undefined ? { text } : {}),
+                ...(!code && message.button !== undefined ? { button: message.button } : {}),
                 ...(!code && unsupported
                     ? {
                         reply: `Please send a text message of up to ${binding.limits.textCharacters} characters. For help, contact ${binding.supportEmail}.`,

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

@@ -1,7 +1,7 @@
 /** Private channel journal. Each binding is a transaction/lease authority, not a browser session. */
 export interface ChannelRow {
     readonly id: string;
-    readonly kind: 'binding' | 'asset' | 'participant' | 'event' | 'counter' | 'spend' | 'block' | 'mutation';
+    readonly kind: 'binding' | 'asset' | 'participant' | 'event' | 'counter' | 'spend' | 'block' | 'mutation' | 'interaction';
     readonly state?: string;
     readonly updatedAt: number;
     readonly expiresAt?: number;

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

@@ -71,13 +71,24 @@ export interface ChannelParticipant {
     readonly cooldownUntil?: number;
 }
 export type ChannelEventState = 'queued' | 'running' | 'reply' | 'sending' | 'accepted' | 'delivered' | 'read' | 'refused' | 'expired' | 'failed' | 'cancelled' | 'unknown';
+/** A native reply button: an opaque server-bound id and the label the participant sees. */
+export interface ChannelReplyButton {
+    readonly id: string;
+    readonly title: string;
+}
 export interface ChannelEvent {
     readonly id: string;
     readonly participantId: string;
     readonly providerId: string;
     readonly providerMessageId?: string;
     readonly text?: string;
+    /** The button the participant tapped, in place of text. */
+    readonly button?: ChannelReplyButton;
     readonly reply?: string;
+    /** What history keeps of the reply when it must differ from the sent text; replaces `reply` once dispatched. */
+    readonly replyTranscript?: string;
+    /** Native reply buttons offered with the reply; content-free, dropped once dispatch is attempted. */
+    readonly buttons?: readonly ChannelReplyButton[];
     readonly eventAt: number;
     readonly receivedAt: number;
     readonly generation: number;
@@ -94,6 +105,7 @@ export interface ChannelInbound {
     readonly address: ChannelAddress;
     readonly eventAt: number;
     readonly text?: string;
+    readonly button?: ChannelReplyButton;
 }
 export declare class ChannelError extends Error {
     readonly code: string;

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

@@ -1,5 +1,5 @@
 import type { ChannelStore } from './channel-store.js';
-import { type ChannelBinding, type ChannelEvent, type ChannelParticipant } from './channel-types.js';
+import { type ChannelBinding, type ChannelEvent, type ChannelParticipant, type ChannelReplyButton } from './channel-types.js';
 export interface ChannelWork {
     readonly binding: ChannelBinding;
     readonly participant: ChannelParticipant;
@@ -7,7 +7,12 @@ export interface ChannelWork {
 }
 export declare function claimChannelTurn(store: ChannelStore, id: string, now: number, retentionMs?: number): Promise<ChannelWork | undefined>;
 export declare function renewChannelTurn(store: ChannelStore, id: string, eventId: string, lease: string, now: number): Promise<void>;
-export declare function completeChannelTurn(store: ChannelStore, id: string, eventId: string, lease: string, reply: string, now: number, retentionMs?: number, code?: string): Promise<void>;
+/** Text the transcript keeps instead of the raw message or the sent reply, e.g. with private values redacted. */
+export interface ChannelTranscript {
+    readonly user?: string;
+    readonly assistant?: string;
+}
+export declare function completeChannelTurn(store: ChannelStore, id: string, eventId: string, lease: string, reply: string, now: number, retentionMs?: number, code?: string, transcript?: ChannelTranscript, buttons?: readonly ChannelReplyButton[]): Promise<void>;
 export declare function prepareChannelSend(store: ChannelStore, id: string, now: number): Promise<ChannelWork | undefined>;
 export declare function updateChannelSend(store: ChannelStore, id: string, eventId: string, lease: string, result: {
     state: 'accepted' | 'unknown' | 'failed';

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

@@ -99,7 +99,7 @@ export async function renewChannelTurn(store, id, eventId, lease, now) {
         await writeChannelEvent(tx, id, { ...event, leaseUntil: Math.min(now + LEASE_MS, event.turnDeadline) }, now);
     });
 }
-export async function completeChannelTurn(store, id, eventId, lease, reply, now, retentionMs = CHANNEL_RETENTION_MS, code) {
+export async function completeChannelTurn(store, id, eventId, lease, reply, now, retentionMs = CHANNEL_RETENTION_MS, code, transcript = {}, buttons) {
     if (!reply.trim() || reply.length > 4096)
         throw new ChannelError('reply_invalid');
     await store.transaction([id], async (tx) => {
@@ -107,17 +107,23 @@ export async function completeChannelTurn(store, id, eventId, lease, reply, now,
         const participant = await channelValue(tx, id, event.participantId);
         if (!participant)
             throw new ChannelError('context_expired');
+        const userText = transcript.user ?? event.text ?? '';
         const history = [
             ...participant.history.filter((entry) => entry.at > now - retentionMs),
-            { role: 'user', content: event.text ?? '', at: event.receivedAt },
-            { role: 'assistant', content: reply, at: now },
+            { role: 'user', content: userText, at: event.receivedAt },
+            { role: 'assistant', content: transcript.assistant ?? reply, at: now },
         ].slice(-20);
         await tx.put(id, channelRow(participant.id, 'participant', { ...participant, history }, now, {
             expiresAt: participant.lastInboundAt + retentionMs,
         }));
         await writeChannelEvent(tx, id, {
             ...event,
+            ...(event.text === undefined ? {} : { text: userText }),
             reply,
+            ...(transcript.assistant !== undefined && transcript.assistant !== reply
+                ? { replyTranscript: transcript.assistant }
+                : {}),
+            ...(buttons !== undefined && buttons.length > 0 ? { buttons } : {}),
             state: 'reply',
             lease: undefined,
             leaseUntil: undefined,
@@ -160,8 +166,12 @@ export async function updateChannelSend(store, id, eventId, lease, result, now)
         const early = result.providerMessageId
             ? await channelValue(tx, id, `delivery:${channelDigest(result.providerMessageId)}`)
             : undefined;
+        // Once dispatch has been attempted the sent text and its buttons are never needed again: the
+        // row keeps only what the transcript keeps, so a redacted reply does not outlive its delivery.
+        const { replyTranscript: _kept, buttons: _offered, ...dispatched } = event;
         await writeChannelEvent(tx, id, {
-            ...event,
+            ...dispatched,
+            ...(event.replyTranscript === undefined ? {} : { reply: event.replyTranscript }),
             ...result,
             ...(early && early !== 'sent' ? { state: early } : {}),
             leaseUntil: undefined,

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

@@ -0,0 +1,104 @@
+import { validateJsonSchema } from '@noodle-borg/compiler';
+import { z } from 'zod';
+import { applyCapture, neededFields, } from './collection-ledger.js';
+import { boundedJsonCall } from './collection-model-call.js';
+import { normaliseTypedValue, redactSpans, scanTypedValues, } from './collection-parsers.js';
+const PARSED = new Set(['email', 'phone', 'url']);
+const extraction = z.record(z.string(), z.unknown());
+function isParsed(control) {
+    return PARSED.has(control);
+}
+/**
+ * Deterministic step: a parser assigns a value only when exactly one candidate meets exactly one
+ * needed field of that control; competing candidates mark the field ambiguous. Every candidate,
+ * assigned or not, is redacted from the text before a model sees it.
+ */
+function parseTurn(needed, utterance) {
+    const controls = [...new Set(needed.map((field) => field.control).filter(isParsed))];
+    const spans = scanTypedValues(utterance, controls);
+    const outcome = {};
+    const assigned = new Set();
+    for (const control of controls) {
+        const fields = needed.filter((field) => field.control === control);
+        const candidates = spans.filter((span) => span.control === control);
+        if (candidates.length === 0)
+            continue;
+        const [onlyField] = fields;
+        const [onlyCandidate] = candidates;
+        if (fields.length === 1 && candidates.length === 1 && onlyField && onlyCandidate) {
+            outcome[onlyField.key] = { status: 'captured', value: onlyCandidate.value };
+            assigned.add(onlyCandidate);
+            continue;
+        }
+        const reason = candidates.length > 1 ? 'multiple_candidates' : 'multiple_fields';
+        for (const field of fields)
+            outcome[field.key] = { status: 'ambiguous', reason };
+    }
+    const redacted = redactSpans(utterance, spans, (span) => assigned.has(span) ? `[${span.control} captured]` : `[${span.control} withheld]`);
+    return { outcome, redacted };
+}
+/** Control rules first, then the action's own property schema; a failure is a code, never a value. */
+function validateCandidate(field, raw) {
+    let value = raw;
+    if (isParsed(field.control)) {
+        value = typeof raw === 'string' ? normaliseTypedValue(field.control, raw) : undefined;
+        if (value === undefined)
+            return { status: 'invalid', reason: 'format' };
+    }
+    else if (field.control === 'select') {
+        const option = typeof raw === 'string'
+            ? field.options?.find((candidate) => candidate.toLowerCase() === raw.trim().toLowerCase())
+            : undefined;
+        if (option === undefined)
+            return { status: 'invalid', reason: 'option' };
+        value = option;
+    }
+    else if (typeof raw === 'string') {
+        value = raw.trim();
+    }
+    if (validateJsonSchema(field.schema, value).length > 0)
+        return { status: 'invalid', reason: 'schema' };
+    return { status: 'captured', value };
+}
+function extractionInstruction(needed, ledger) {
+    const fields = needed.map((field) => ({
+        key: field.key,
+        title: field.title,
+        control: field.control,
+        ...(field.options === undefined ? {} : { options: field.options }),
+        ...(ledger.fields[field.key]?.status === 'rejected_by_user' && field.key in ledger.values
+            ? {
+                current: ledger.values[field.key],
+                note: 'the user said this value is wrong; apply their correction to it',
+            }
+            : {}),
+    }));
+    return [
+        'Read the values the user states for these fields and reply with exactly one JSON object whose keys are the field keys.',
+        'Use null for any field the message does not state. Never guess, infer or invent a value.',
+        'Keep the user wording for text fields. For a select field return one of its options exactly, or null.',
+        'Bracketed placeholders such as [email captured] stand for values already taken; leave those fields null.',
+        `Fields: ${JSON.stringify(fields)}`,
+    ].join('\n');
+}
+/**
+ * One user turn while a collection is open: parsers first, then at most one bounded extraction call
+ * for whatever still needs a value. Values reach the caller only inside the returned ledger.
+ */
+export async function capture(spec, ledger, utterance, deps, now) {
+    const needed = neededFields(spec, ledger);
+    const { outcome, redacted } = parseTurn(needed, utterance);
+    const remaining = needed.filter((field) => outcome[field.key] === undefined);
+    const content = redacted.replace(/\[(?:email|phone|url) (?:captured|withheld)\]/g, '').trim();
+    if (remaining.length > 0 && /[\p{L}\p{N}]/u.test(content)) {
+        const extracted = await boundedJsonCall(deps, extractionInstruction(remaining, ledger), redacted, extraction);
+        for (const field of remaining) {
+            const raw = extracted?.[field.key];
+            if (raw === undefined || raw === null)
+                continue;
+            outcome[field.key] = validateCandidate(field, raw);
+        }
+    }
+    return applyCapture(spec, ledger, outcome, now);
+}
+//# sourceMappingURL=collection-capture.js.map

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

@@ -0,0 +1,93 @@
+import { z } from 'zod';
+import { boundedJsonCall } from './collection-model-call.js';
+import { scanTypedValues } from './collection-parsers.js';
+/** A judged consent counts only at or above this confidence; below it the runtime re-asks. */
+export const CONSENT_THRESHOLD = 0.85;
+/** A judged confirmation binds a real write, so it is stricter than consent. */
+export const CONFIRM_THRESHOLD = 0.95;
+export const CONFIRMATION_AFFIRMATIVES = [
+    'yes',
+    'y',
+    'ok',
+    'okay',
+    'confirm',
+    'confirmed',
+    'send',
+    'send it',
+    'go ahead',
+    'sure',
+    'yes please',
+    'do it',
+    'looks good',
+];
+export const CONFIRMATION_NEGATIVES = [
+    'no',
+    'cancel',
+    'stop',
+    'never mind',
+    'nevermind',
+    "don't",
+    'dont',
+    'forget it',
+];
+/** Words that turn a reply naming a field into an edit; shared with the runtime's reopen rule. */
+export const CORRECTION_CUES = /\b(change|changed|actually|instead|wrong|not|should be|make it|update|correct|rather|swap|replace|edit|fix)\b/;
+const judgment = z.object({ affirmative: z.boolean(), confidence: z.number().min(0).max(1) });
+const PARSED = ['email', 'phone', 'url'];
+/** Lowercase, collapse whitespace, straighten quotes and drop trailing punctuation. */
+export function normaliseReply(text) {
+    return text
+        .replace(/[‘’]/g, "'")
+        .toLowerCase()
+        .replace(/\s+/g, ' ')
+        .trim()
+        .replace(/[\s.!?,;:…]+$/u, '');
+}
+/**
+ * Judge whether a free reply answers the fixed question affirmatively. The two messages carry the
+ * question and the reply only, never a collected value or the review.
+ */
+async function judgeAffirmative(deps, question, reply) {
+    return boundedJsonCall(deps, [
+        `The assistant asked the user this yes-or-no question: ${JSON.stringify(question)}`,
+        'Judge whether the reply is an affirmative answer to exactly that question.',
+        'A reply that asks for a change, adds a condition, gives new information or answers something else is not affirmative.',
+        'Reply with exactly one JSON object shaped {"affirmative": true or false, "confidence": a number from 0 to 1}.',
+    ].join('\n'), reply, judgment);
+}
+export async function consentReply(text, spec, deps) {
+    const reply = normaliseReply(text);
+    if (reply === 'yes')
+        return 'given';
+    if (reply === 'no')
+        return 'declined';
+    const judged = await judgeAffirmative(deps, spec.consentQuestion, text);
+    if (judged === undefined || judged.confidence < CONSENT_THRESHOLD)
+        return 'unclear';
+    return judged.affirmative ? 'given' : 'declined';
+}
+/** A reply that offers a value or names a field with a correction cue is an edit, never a confirmation. */
+function carriesEdit(text, spec) {
+    const controls = PARSED.filter((control) => spec.fields.some((field) => field.control === control));
+    if (scanTypedValues(text, controls).length > 0)
+        return true;
+    const lower = text.toLowerCase();
+    const namesField = spec.fields.some((field) => field.control !== 'consent' &&
+        (lower.includes(field.title.toLowerCase()) ||
+            new RegExp(`\\b${field.key}\\b`, 'i').test(text)));
+    return namesField && CORRECTION_CUES.test(lower);
+}
+export async function confirmationReply(text, spec, deps) {
+    if (carriesEdit(text, spec))
+        return 'edit';
+    const reply = normaliseReply(text);
+    if (CONFIRMATION_AFFIRMATIVES.includes(reply))
+        return 'confirm';
+    if (CONFIRMATION_NEGATIVES.includes(reply))
+        return 'cancel';
+    const judged = await judgeAffirmative(deps, 'Shall I send it? Yes or no.', text);
+    if (judged === undefined || !judged.affirmative || judged.confidence < CONFIRM_THRESHOLD)
+        return 'unclear';
+    return 'confirm';
+}
+//# sourceMappingURL=collection-judgment.js.map

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

@@ -0,0 +1,105 @@
+import type { JsonSchema } from '@noodle-borg/compiler';
+/**
+ * Runtime-owned natural collection ledger (ADR 0240 decision 5). The ledger is the pre-proposal
+ * stage of the shared confirmation lifecycle: once fields are complete the proposal it stores is an
+ * opaque prepared-tool continuation, never a second confirmation engine.
+ */
+export type CollectionControl = 'text' | 'textarea' | 'email' | 'phone' | 'url' | 'select' | 'consent';
+export interface CollectionField {
+    readonly key: string;
+    readonly title: string;
+    readonly control: CollectionControl;
+    /** Never enters the conversation model, transcript, logs or diagnostics. */
+    readonly private?: true;
+    readonly optional?: true;
+    readonly options?: readonly string[];
+    /** The action input property this field fills; every candidate is validated against it. */
+    readonly schema: JsonSchema;
+}
+export interface CollectionSpec {
+    /** Opener tool name. */
+    readonly interactionId: string;
+    readonly action: string;
+    readonly fields: readonly CollectionField[];
+    readonly consentQuestion: string;
+    readonly successMessage: string;
+    readonly confirmationExpiryMs: number;
+}
+export type CollectionPhase = 'collecting' | 'awaiting_consent' | 'awaiting_confirmation' | 'executing' | 'completed' | 'cancelled' | 'expired';
+export type CollectionFieldStatus = 'missing' | 'captured' | 'invalid' | 'ambiguous' | 'rejected_by_user';
+export interface CollectionFieldState {
+    readonly status: CollectionFieldStatus;
+    /** Short structured code, never a value. */
+    readonly reason?: string;
+    readonly attempts: number;
+}
+export interface CollectionConsent {
+    readonly given: boolean;
+    readonly questionVersion: string;
+    readonly at: string;
+}
+export interface CollectionProposal {
+    readonly id: string;
+    /** Exact runtime-rendered review the confirmation binds to. */
+    readonly review: string;
+    /** Opaque prepared-tool continuation released to the runtime only after confirmation. */
+    readonly continuation: unknown;
+    readonly createdAt: string;
+    readonly expiresAt: string;
+}
+/** Sealed at rest: values include private fields, so this record never leaves custody unredacted. */
+export interface CollectionLedger {
+    readonly id: string;
+    readonly bindingId: string;
+    readonly participantId: string;
+    readonly interactionId: string;
+    readonly action: string;
+    readonly phase: CollectionPhase;
+    readonly fields: Readonly<Record<string, CollectionFieldState>>;
+    readonly values: Readonly<Record<string, unknown>>;
+    readonly consent?: CollectionConsent;
+    readonly proposal?: CollectionProposal;
+    /** The proposal that was executed, kept after completion so its native confirmation echoes the same receipt. */
+    readonly executedProposalId?: string;
+    readonly createdAt: string;
+    readonly updatedAt: string;
+    readonly expiresAt: string;
+}
+export type CaptureOutcome = Readonly<Record<string, {
+    readonly status: 'captured';
+    readonly value: unknown;
+} | {
+    readonly status: 'invalid' | 'ambiguous';
+    readonly reason: string;
+}>>;
+export declare class CollectionError extends Error {
+    readonly code: string;
+    constructor(code: string);
+}
+export declare function openCollection(spec: CollectionSpec, input: {
+    readonly id: string;
+    readonly bindingId: string;
+    readonly participantId: string;
+    readonly now: number;
+    readonly retentionMs?: number;
+}): CollectionLedger;
+/** Non-consent fields a capture turn may still fill or repair. */
+export declare function neededFields(spec: CollectionSpec, ledger: CollectionLedger): readonly CollectionField[];
+export declare function applyCapture(spec: CollectionSpec, ledger: CollectionLedger, outcome: CaptureOutcome, now: number): CollectionLedger;
+/** The user said a stored value is wrong; keep it so a partial correction can be applied. */
+export declare function rejectField(spec: CollectionSpec, ledger: CollectionLedger, key: string, now: number): CollectionLedger;
+export declare function applyConsent(spec: CollectionSpec, ledger: CollectionLedger, decision: 'given' | 'declined', questionVersion: string, now: number): CollectionLedger;
+export declare function attachProposal(spec: CollectionSpec, ledger: CollectionLedger, proposal: {
+    readonly id: string;
+    readonly review: string;
+    readonly continuation: unknown;
+}, now: number): CollectionLedger;
+export declare function pendingProposal(ledger: CollectionLedger, now: number): CollectionProposal | undefined;
+export declare function applyConfirmation(ledger: CollectionLedger, act: 'confirm' | 'cancel', now: number): CollectionLedger;
+export declare function completeCollection(ledger: CollectionLedger, now: number): CollectionLedger;
+/** The participant asked to change something before saying what: the proposal and its acts lapse, every value stays. */
+export declare function withdrawProposal(ledger: CollectionLedger, now: number): CollectionLedger;
+export declare function cancelCollection(ledger: CollectionLedger, now: number): CollectionLedger;
+/** Returns the same ledger when nothing has expired, so callers can detect a change by identity. */
+export declare function expireCollection(ledger: CollectionLedger, now: number): CollectionLedger;
+//# sourceMappingURL=collection-ledger.d.ts.map