jsfe 1.26.0 → 1.27.1

package/README.md

@@ -366,8 +366,7 @@ deterministic reader cannot read, jsfe asks what the reply does with the step's
 `answers`, `abort`, `new_request` or `irrelevant`. ONE aiCallback call whose 4th argument is `task: 'rank_reply'` with both
 executors' instructions (`llm`, `systemOne`); the host replies `{ "option": … }`, plus `"fallback": true` when the
 option is `answers` only because nothing cleared the cut (System One). `jsfe/host` exports
-`buildReplyRank`, `decodeReplyRankLlm` and `decodeReplyRankSystemOne` (the highest option at or above 0.5, else
-`answers`). `answers` continues the flow, after extracting the step's `responseParameters` with a stage-2 request
+`buildReplyRank`, `decodeReplyRankLlm` and `decodeReplyRankSystemOne` (the highest option at or above its cut: 0.5, or `choice:no` 0.65, `new_request` 0.6, `irrelevant` 0.7; a cleared choice outranks `answers` and `new_request`, and `irrelevant` from 0.8; else `answers`). `answers` continues the flow, after extracting the step's `responseParameters` with a stage-2 request
 when it declares them. A confident `answers` (no `fallback`) is never lost: when the declaration is one parameter marked
 `verbatim: true` (an open string whose words are the value, such as a reason) and extraction finds nothing or fails,
 the field is the reply as said. Unmarked fields (a product, a city) always need a real extraction. After a
@@ -378,9 +377,11 @@ outcome `user_aborted`, no recovery stamp;
 `answers` a later ordinary DISPATCH in the same turn hands the host the turn without detection. A host that does not know the task answers the `llm`
 instructions with its text model.
 
+An input with `profile.whole_phrases` (default off; `choice`, or a `pattern` that reads words) keeps its word reader only for a reply wholly made of its phrase, arguments, courtesy, connecting words and its `template_words`; any other reply goes to this ranker.
+
 **Declared choices (`responseChoices`, jsfe 1.14):** a step may name a flow variable of type array holding
-`[{ key, label }]`; the ranker is then also offered `choice:<key>` for each (before the fixed three), and `answers`
-means a reply that picks none of them. A picked choice sets `responseVariable` to `{ key }` with no extraction;
+`[{ key, label, parameters? }]` (`parameters`: extracted on a pick, read as `{ key, arguments }`); the ranker is then also offered `choice:<key>` for each (before the fixed options), and `answers`
+means a reply that picks none of them. A picked choice sets `responseVariable` to `{ key }`, plus `arguments` when it declares `parameters` (the pick stands if extraction finds nothing or fails);
 `answers` sets `{ key: '' }` unless `responseParameters` are declared too. The request carries the options it offers
 (`request.options`); a host validates a reply against those, never a fixed list. The form readers use it: an unread
 answer with any words goes to the ranker with the question's choices (never an exact choice or the YES of a firm

package/dist/forms/address-flows.js

@@ -11,13 +11,13 @@ const C = (id, summary, steps, extra = {}) => defineWorker({ id, name: id.split(
 const streetPattern = '\\b\\d{1,6}\\s+(?:[A-Za-z0-9.\\xC0-\\xFF-]+\\s+){1,8}(?:st(?:reet)?|ave(?:nue)?|blvd|boulevard|rd|road|ln|lane|dr(?:ive)?|way|ct|court|pl(?:ace)?|pkwy|parkway|cir(?:cle)?|ter(?:race)?)\\b';
 const address = defineForm({ id: 'collect-geocoded-address', name: 'CollectGeocodedAddress', version: '1.0.0', description: 'Collect a mailing address in any order, project geocoder evidence, and read the complete address back for confirmation.', contract: { summary: 'Collect and confirm a geocoded mailing address', result: { path: 'form result.resolved', type: 'object' } }, parameters: [P('given')], extraVars: { given: '', zip: '', street: '', unit: '', draft: null, address_result: null, exit_context: 'your address', exit_context_es: 'su dirección' },
     before: [S('address_given', 'given', "given || (cargo.forms[cargo.forms[form_instance].parent] || {}).context && (cargo.forms[cargo.forms[form_instance].parent].context.given || '') || ''"), S('address_draft', 'draft', E(addressDraft, "given || (cargo.forms[form_instance].seeds && cargo.forms[form_instance].seeds.given) || ''")), S('address_seed_zip', 'zip', "zip || draft.zip"), S('address_seed_street', 'street', "street || draft.street"), S('address_seed_unit', 'unit', "unit || draft.unit"), S('address_data', 'noop', "(cargo.forms[form_instance].data=Object.assign({need_city:false},cargo.forms[form_instance].data || {}), draft.street ? (cargo.addressDraft={said:draft.street}) : null, true)")],
-    inputs: [{ name: 'zip', field: 'zip', names: ['zip', 'zip code', 'postal code', 'código postal', 'codigo postal'], validator: 'address-zip-validate', prepare: 'address-zip-prompt', question_from: 'zip_question', question: 'What is the 5-digit zip code of your new address?', question_es: '¿Cuál es el código postal de 5 dígitos de su nueva dirección?' },
-        { name: 'city', label: 'city', label_es: 'ciudad', names: ['city', 'ciudad'], profile: { kind: 'choice', choices: [], accept_other: true }, choices_from: 'city_choices', when: { 'form.data.city_known': true }, depends_on: ['zip'], reset_on: ['zip'], prepare: 'address-city-prompt', question_from: 'city_question', question: 'Which city is it?', question_es: '¿Qué ciudad es?' },
-        { name: 'city_state', label: 'city and state', label_es: 'ciudad y estado', names: ['city', 'ciudad'], profile: { kind: 'text' }, when: { 'form.data.need_city': true }, depends_on: ['zip'], question: 'What city and state is that in?', question_es: '¿En qué ciudad y estado está?' },
-        { name: 'street', label: 'street address', label_es: 'dirección', names: ['street', 'calle'], profile: { kind: 'pattern', regex: streetPattern, accept_other: true }, depends_on: ['zip'], validator: 'address-street-validate', prepare: 'address-street-prompt', question_from: 'street_question', question: 'What is the street address?', question_es: '¿Cuál es la dirección?' },
-        { name: 'unit', reset_on: ['street'], label: 'apartment or unit', label_es: 'apartamento o unidad', names: ['apartment', 'apt', 'unit', 'apartamento', 'unidad', 'departamento'], profile: { kind: 'pattern', regex: '(?:\\bapt\\.?|\\bunit|#)\\s*([\\w-]+)', group: 1, accept_other: true }, question: 'Is there an apartment or unit number? Type the number, or NONE.', question_es: '¿Hay un número de apartamento o unidad? Escriba el número, o NINGUNO.' }],
+    inputs: [{ name: 'zip', field: 'zip', argument_description: '5-digit ZIP code', names: ['zip', 'zip code', 'postal code', 'código postal', 'codigo postal'], validator: 'address-zip-validate', prepare: 'address-zip-prompt', question_from: 'zip_question', question: 'What is the 5-digit zip code of your new address?', question_es: '¿Cuál es el código postal de 5 dígitos de su nueva dirección?' },
+        { name: 'city', argument_description: 'city name alone', label: 'city', label_es: 'ciudad', names: ['city', 'ciudad'], profile: { kind: 'choice', choices: [], accept_other: true }, choices_from: 'city_choices', when: { 'form.data.city_known': true }, depends_on: ['zip'], reset_on: ['zip'], prepare: 'address-city-prompt', question_from: 'city_question', question: 'Which city is it?', question_es: '¿Qué ciudad es?' },
+        { name: 'city_state', argument_description: 'city and state', label: 'city and state', label_es: 'ciudad y estado', names: ['city', 'ciudad'], profile: { kind: 'text' }, when: { 'form.data.need_city': true }, depends_on: ['zip'], question: 'What city and state is that in?', question_es: '¿En qué ciudad y estado está?' },
+        { name: 'street', argument_description: 'street number and street name, without the apartment', label: 'street address', label_es: 'dirección', names: ['street', 'calle'], profile: { kind: 'pattern', regex: streetPattern, accept_other: true }, depends_on: ['zip'], validator: 'address-street-validate', prepare: 'address-street-prompt', question_from: 'street_question', question: 'What is the street address?', question_es: '¿Cuál es la dirección?' },
+        { name: 'unit', argument_description: 'apartment or unit number alone, such as 4 or 12B', reset_on: ['street'], label: 'apartment or unit', label_es: 'apartamento o unidad', names: ['apartment', 'apt', 'unit', 'apartamento', 'unidad', 'departamento'], profile: { kind: 'pattern', regex: '(?:\\bapartment|\\bapartamento|\\bdepartamento|\\bapt\\.?|\\bunit|\\bunidad|#)\\s*([\\w-]+)', group: 1, accept_other: true }, question: 'Is there an apartment or unit number? Type the number, or NONE.', question_es: '¿Hay un número de apartamento o unidad? Escriba el número, o NINGUNO.' }],
     before_confirm: [S('address_resolved', 'address_result', E(resolvedAddress, 'cargo.forms[form_instance].values', 'cargo.forms[form_instance].data'))],
-    confirm: { named_fields: true, no_keys: ['2', 'not right', 'not correct', 'incorrect', 'wrong', 'no es correcto', 'no es correcta', 'incorrecta'], question: 'Your new address is {{address_result.line}}. Is that correct?', question_es: 'Su nueva dirección es {{address_result.line}}. ¿Es correcta?' },
+    confirm: { named_fields: true, reply_context: 'This is a mailing address read back for confirmation. A reply may correct one part or several at once: the street number, street name or street type, the apartment or unit, the city, or the ZIP code.', no_keys: ['2', 'not right', 'not correct', 'incorrect', 'wrong', 'no es correcto', 'no es correcta', 'incorrecta'], question: 'Your new address is {{address_result.line}}. Is that correct?', question_es: 'Su nueva dirección es {{address_result.line}}. ¿Es correcta?' },
     after: [S('address_result_store', 'noop', '(cargo.forms[form_instance].values.resolved = address_result, cargo.address = address_result, cargo.addressDraft = null, true)')], declined: [S('address_retry_noop', 'noop', 'true')] });
 const zip = C('address-zip-validate', 'Read city and state from geocoder evidence for the proposed ZIP; missing geocoder data requires an explicit city.', [
     S('address_zip_components', 'components', "'postal_code:'+value+'|country:US'"), { id: 'address_zip_tool', type: 'CALL-TOOL', tool: 'geocode-zip', variable: 'result', args: { components: '{{components}}', address: '' }, onFail: S('address_zip_failed', 'result', 'null') },

package/dist/forms/flows.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"flows.d.ts","sourceRoot":"","sources":["../../src/forms/flows.js"],"names":[],"mappings":"AAqIA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA8DC;AACD;;;GAGG;AACH;;;;;;EAGC;AA2fD,wHAAwH;AACxH,wEAaC;AACD,4FAA4F;AAC5F;;;EAYC;AACD,sGAAsG;AACtG;;;EAOC;AAjsBM,6CAAuG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA03B9G;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAOG"}
+{"version":3,"file":"flows.d.ts","sourceRoot":"","sources":["../../src/forms/flows.js"],"names":[],"mappings":"AAqIA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA8DC;AACD;;;GAGG;AACH;;;;;;EAGC;AA+fD,wHAAwH;AACxH,wEAaC;AACD,4FAA4F;AAC5F;;;EAYC;AACD,sGAAsG;AACtG;;;EAOC;AArsBM,6CAAuG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA83B9G;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAOG"}

package/dist/forms/flows.js

@@ -148,7 +148,7 @@ export function formFlow({ id, name, version, description, inputs, after = [], e
         // FLOW parameters are paths only: the question is built here, as a SAY-style template, then passed by name
         SET(`${id}_confirm_q`, 'form_confirm_q', textValue(confirm.question)),
         SET(`${id}_confirm_q_es`, 'form_confirm_q_es', textValue(confirm.question_es || confirm.question)),
-        FLOW(`${id}_confirm`, 'confirm-form', 'call', { form: '{{form_instance}}', question: '{{form_confirm_q}}', question_es: '{{form_confirm_q_es}}', phrases: '{{form_confirmation.phrases}}', words: '{{form_confirmation.words}}', clarifications: '{{form_confirmation.clarifications}}', no_keys: '{{form_confirmation.no_keys}}', interrupts: '{{form_confirmation.interrupts}}', invites: '{{form_confirmation.invites}}', named_fields: '{{form_confirmation.named_fields}}', exit_context: '{{exit_context}}', exit_context_es: '{{exit_context_es}}' }),
+        FLOW(`${id}_confirm`, 'confirm-form', 'call', { form: '{{form_instance}}', question: '{{form_confirm_q}}', question_es: '{{form_confirm_q_es}}', phrases: '{{form_confirmation.phrases}}', words: '{{form_confirmation.words}}', clarifications: '{{form_confirmation.clarifications}}', no_keys: '{{form_confirmation.no_keys}}', interrupts: '{{form_confirmation.interrupts}}', invites: '{{form_confirmation.invites}}', named_fields: '{{form_confirmation.named_fields}}', reply_context: '{{form_confirmation.reply_context}}', exit_context: '{{exit_context}}', exit_context_es: '{{exit_context_es}}' }),
         { id: `${id}_confirmed`, type: 'CASE', branches: {
                 [`condition: (cargo.formConfirm || {})[form_instance] === 'changed'`]: FLOW(`${id}_again`, id, 'replace', { parent_form: '{{parent_form}}', result_input: '{{result_input}}', form_instance: '{{form_instance}}' }),
                 // NO: the declined flow takes the form's place, so the action below never runs
@@ -312,7 +312,7 @@ const collectInput = {
         WHEN('ci_no_run', 'ci_no_flow', FLOW('ci_no_answer', '{{ci_no_flow}}', 'call', { form: '{{ci_no_owner}}' })),
         WHEN('ci_no_owner_resume', 'ci_no_flow && ci_no_up', FLOW('ci_no_resume_owner', 'resume-form', 'reboot', { form: '{{ci_no_owner}}' })),
         WHEN('ci_no_end', 'ci_no_flow', END('ci_no_done')),
-        SET('ci_build_chain', 'ci_chain', CHAIN_JS),
+        SET('ci_build_chain', 'ci_chain', `(${CHAIN_JS}).filter(function(i){return !(ci_spec.own_identifiers === true && i.form !== form && i.profile && i.profile.kind === 'identifier');})`),
         SET('ci_match', 'ci_m', "readFormAnswer(cargo.choiceText, ci_chain, Array.isArray(ci_spec.any_of) ? { form: form, names: ci_names } : { form: form, name: current }, cargo.choice, provides && Array.isArray(questions) ? questions : [])"),
         SIDE('ci_acceptance_trace', "(cargo.formAcceptance = formAcceptanceTrace(cargo.formAcceptance, ci_m), true)"),
         // The labels and validators ride on each reading, so the presets stay in this one flow.
@@ -424,7 +424,7 @@ const RANK_LABEL_JS = "function(c){var said=(Array.isArray(c.phrases) ? c.phrase
 // the pay confirmation): the ranker is offered every choice the reader would accept (owner 2026-10-28). A confirmation
 // input is answered only when asked, a current_only choice only at its own question (as the reader reads it), and a key
 // already offered is not offered twice. Each carries its input, so a pick is read as that input's answer.
-const otherChoicesJS = (asked, taken) => `(function(){var seen=(${taken}).map(function(c){return String(c.key);}).concat(['yes','no']);return (chain || []).filter(function(i){return i.form===form && i.name!==${asked} && !i.confirmation && i.profile && i.profile.kind==='choice' && Array.isArray(i.profile.choices);}).reduce(function(all,i){return all.concat(i.profile.choices.filter(function(c){var k=String(c.key);if(c.current_only===true||seen.indexOf(k)>=0)return false;seen.push(k);return true;}).map(function(c){return {key:String(c.key),label:(${RANK_LABEL_JS})(c),owner:{form:i.form,name:i.name}};}));},[]);})()`;
+const otherChoicesJS = (asked, taken, scope = `i.form===form && i.name!==${asked}`) => `(function(){var seen=(${taken}).map(function(c){return String(c.key);}).concat(['yes','no']);return (chain || []).filter(function(i){return ${scope} && !i.confirmation && i.profile && i.profile.kind==='choice' && Array.isArray(i.profile.choices);}).reduce(function(all,i){return all.concat(i.profile.choices.filter(function(c){var k=String(c.key);if(c.current_only===true||seen.indexOf(k)>=0)return false;seen.push(k);return true;}).map(function(c){return {key:String(c.key),label:(${RANK_LABEL_JS})(c),owner:{form:i.form,name:i.name}};}));},[]);})()`;
 const escapeRoutes = (id) => [WHEN(`${id}_agent`, "reply && reply.key === '__agent'", FLOW(`${id}_agent_flow`, 'live-agent-requested', 'reboot'))];
 const rankedDispatch = (id, reason) => ({ ...yieldDispatch(id, 'form', `'${reason}'`), onResponse: 'continue', responseContext: 'Current question: {{asked}}', responseChoices: 'ranked', responseVariable: 'reply' });
 const readFormReply = {
@@ -448,7 +448,8 @@ const readFormChoice = {
         rankedDispatch('choice_dispatch', 'input_not_matched'),
         ...escapeRoutes('choice_escape'),
         SET('choice_picked', 'picked', "(function(){var k=String(reply && reply.key || '');var c=(choices || []).filter(function(c){return String(c.key)===k;})[0] || others.filter(function(c){return c.key===k;})[0];return c ? String(c.key) : '';})()"),
-        SET('choice_owner', 'owner', "(others.filter(function(c){return c.key===picked && !(choices || []).some(function(own){return String(own.key)===picked;});})[0] || {}).owner || null"),
+        // A question over any_of asks one name and its choices belong to a member ('selection' asks, 'option' holds PAST DUE): the pick is read as the member's answer.
+        SET('choice_owner', 'owner', "(others.filter(function(c){return c.key===picked && !(choices || []).some(function(own){return String(own.key)===picked;});})[0] || {}).owner || (function(){var asked=(chain || []).filter(function(i){return i.form===form && i.name===input;})[0];if(asked || !picked)return null;var spec=((cargo.forms[form] || {}).specs || []).filter(function(i){return i.name===input;})[0];var names=((spec || {}).any_of || []).map(function(i){return i.name;});var member=(chain || []).filter(function(i){return i.form===form && names.indexOf(i.name)>=0 && i.profile && (i.profile.choices || []).some(function(c){return String(c.key)===picked;});})[0];return member ? {form:member.form,name:member.name} : null;})()"),
         WHEN('choice_none', '!picked', rankedMiss('choice_miss')),
         WHEN('choice_none_end', '!picked', END('choice_none_done')),
         SIDE('choice_take', "(cargo.choice=picked,cargo.choiceText=picked,true)"),
@@ -464,16 +465,21 @@ const readFormChoice = {
 // (ConfirmForm reads it); `abort` ends every flow; `new_request` goes to intent detection.
 const readConfirmReply = {
     id: 'read-confirm-reply', name: 'ReadConfirmReply', version: '1.3.0', scope: 'isolated', description: 'Rank an unreadable answer to a confirmation: it declines (NO), picks another of the form\'s choices (a correction, read as that input\'s answer), says a named field read back is wrong (confirm.named_fields: that input is asked again), asks for a person, or is asked again; a withdrawal or a new request leaves with saved form progress. Never confirms.',
-    parameters: [{ name: 'form', type: 'string' }, { name: 'question', type: 'string' }, { name: 'question_es', type: 'string' }, { name: 'named_fields', type: 'boolean' }],
-    variables: vars({ question: '', question_es: '', asked: '', ranked: [], reply: null, chain: null, others: [], fields: [], field: null, picked: null, reading: null, named_fields: false }),
-    steps: [SET('confirm_asked', 'asked', "language === 'es' && question_es ? question_es : question"),
+    parameters: [{ name: 'form', type: 'string' }, { name: 'question', type: 'string' }, { name: 'question_es', type: 'string' }, { name: 'named_fields', type: 'boolean' }, { name: 'reply_context', type: 'string' }],
+    variables: vars({ question: '', question_es: '', asked: '', ranked: [], reply: null, chain: null, others: [], fields: [], field: null, picked: null, reading: null, named_fields: false, prompt: null, field_arguments: [], corrections: [], reply_context: '' }),
+    steps: [
+        SET('confirm_asked', 'asked', "(language === 'es' && question_es ? question_es : question)+(reply_context ? ' '+reply_context : '')"),
         SET('confirm_chain', 'chain', 'formInputChain(cargo.forms, form, cargo)'),
-        SET('confirm_others', 'others', otherChoicesJS("''", '[]')),
+        // a proposal's confirmation belongs to its parent's input: a correction names another of that input's choices
+        SET('confirm_prompt', 'prompt', "cargo.forms[form] && cargo.forms[form].proposalPrompt ? {form:cargo.forms[form].parent,name:cargo.forms[form].proposalPrompt.input} : null"),
+        SET('confirm_others', 'others', otherChoicesJS("''", '[]', "(prompt ? i.form===prompt.form && i.name===prompt.name : i.form===form)")),
         // confirm.named_fields: a field read back may be corrected in the caller's own words ('es Long Beach' at an address
         // read back with the ZIP code's city): each named input of this form that holds a value is offered, and a pick asks
         // that input again, so the caller's value replaces the one read back
         SET('confirm_fields', 'fields', "named_fields === true || named_fields === 'true' ? (chain || []).filter(function(i){var v=cargo.forms[form] && cargo.forms[form].values;return i.form===form && !i.confirmation && Array.isArray(i.names) && i.names.length && v && v[i.name]!==undefined && v[i.name]!==null && v[i.name]!=='';}).map(function(i){var l=String(i.label || i.names[0]);return {key:'field:'+i.name,label:'says the '+l+' read back is wrong, or gives a different '+l,owner:{form:i.form,name:i.name}};}) : []"),
-        rankedChoices('confirm_ranked_choices', "[{key:'no',label:'no: declines or refuses what the question asks to confirm'}].concat(others.map(function(c){return {key:c.key,label:c.label};})).concat(fields.map(function(c){return {key:c.key,label:c.label};}))"),
+        // A correction may name several fields ('it is Long Beach, apartment 4'): any field's pick extracts every named field's new value.
+        SET('confirm_field_arguments', 'field_arguments', "fields.map(function(c){var i=(chain || []).filter(function(i){return i.form===c.owner.form && i.name===c.owner.name;})[0];var l=String(i.label || i.names[0]);return {name:c.owner.name,type:'string',description:'The correct '+(i.argument_description || l)+' the caller gives now. Leave it empty when they give none.'};})"),
+        rankedChoices('confirm_ranked_choices', "[{key:'no',label:'no: declines or refuses what the question asks to confirm'}].concat(others.map(function(c){return {key:c.key,label:c.label};})).concat(fields.map(function(c){return {key:c.key,label:c.label,parameters:field_arguments};}))"),
         rankedDispatch('confirm_dispatch', 'confirmation_not_matched'),
         ...escapeRoutes('confirm_escape'),
         // a correction picked by the ranker is read as its input's answer: the form changes and is confirmed again, never confirmed
@@ -481,8 +487,11 @@ const readConfirmReply = {
         SET('confirm_read', 'reading', "picked ? enrichFormMatches(readFormAnswer(picked.key, chain, picked.owner, picked.key, []), chain, form, [picked.owner.name], picked.owner.name) : null"),
         WHEN('confirm_change', 'reading && reading.hits.length', FLOW('confirm_change_accept', 'collect-input-accept', 'call', { hits: '{{reading.hits}}' })),
         SET('confirm_field', 'field', "fields.filter(function(c){return reply && c.key===reply.key;})[0] || null"),
-        WHEN('confirm_field_reset', 'field', SIDE('confirm_field_ask', '(resetFormInputs(cargo, field.owner.form, [field.owner.name]), true)')),
-        SIDE('confirm_ranked', "(cargo.confirmRanked=reading && reading.hits.length || field ? 'changed' : reply && reply.key==='no' ? 'no' : 'none',true)")]
+        SET('confirm_corrections', 'corrections', "field && reply.arguments ? fields.reduce(function(all,c){var said=String(reply.arguments[c.owner.name] || '').trim();return said ? all.concat(enrichFormMatches(readFormAnswer(said, chain, c.owner, said, []), chain, form, [c.owner.name], c.owner.name).hits) : all;},[]) : []"),
+        WHEN('confirm_correct', 'corrections.length', FLOW('confirm_correct_accept', 'collect-input-accept', 'call', { hits: '{{corrections}}' })),
+        WHEN('confirm_field_reset', 'field && !corrections.length', SIDE('confirm_field_ask', '(resetFormInputs(cargo, field.owner.form, [field.owner.name]), true)')),
+        SIDE('confirm_ranked', "(cargo.confirmRanked=reading && reading.hits.length || field ? 'changed' : reply && reply.key==='no' ? 'no' : 'none',true)")
+    ]
 };
 const collectContextualAnswer = formFlow({ id: 'collect-contextual-answer', name: 'CollectContextualAnswer', description: 'Collect one open-ended answer using contextual DISPATCH and preserve the caller wording.',
     parameters: [...['question', 'question_es', 'description', 'context', 'context_es'].map(name => ({ name, type: 'string' })), { name: 'choices', type: 'array' }, { name: 'digits', type: 'object' }],
@@ -573,7 +582,7 @@ const confirmForm = {
     id: 'confirm-form', name: 'ConfirmForm', version: '1.0.0', scope: 'isolated',
     description: "Worker: ask a form's confirmation (exact YES / NO; keys 1 and 2). A correction instead ('no, make it $40') is read against the form chain and stored, and the result is 'changed' so the form runs again; an answer with words it cannot read goes to the reply ranker (read-confirm-reply); an unclear one is asked again, and after two the give-up worker takes over. Result: cargo.formConfirm[form] = 'yes' | 'no' | 'changed'. Params: form, question(_es), exit_context(_es).",
     parameters: ['form', 'question', 'question_es', 'exit_context', 'exit_context_es', 'phrases', 'words', 'interrupts', 'no_keys', 'clarifications', 'invites'].map((n) => ({ name: n, type: ['phrases', 'words', 'interrupts', 'no_keys', 'clarifications', 'invites'].includes(n) ? 'array' : 'string', description: n })).concat([{ name: 'named_fields', type: 'boolean', description: "true: an answer that names one of the form's inputs (its names) without a value re-asks only that input" }]),
-    variables: vars({ named_fields: false, cf_must: false, cf_named: null, cf_presets: FIELD_PRESETS, cf_chain: [], cf_m: null, cf_current: null, cf_result: '', cf_prompt: '', cf_prompt_es: '', cf_words: 0, cf_tries: 0, phrases: null, words: [], clarifications: [], no_keys: ['2'], interrupts: [], invites: [], cf_choices: [], cf_event: '', cf_amount: false, cf_questions: [], cf_provides: null, cf_skip_gate: '' }),
+    variables: vars({ named_fields: false, reply_context: '', cf_must: false, cf_presets: FIELD_PRESETS, cf_chain: [], cf_m: null, cf_current: null, cf_result: '', cf_prompt: '', cf_prompt_es: '', cf_words: 0, cf_tries: 0, phrases: null, words: [], clarifications: [], no_keys: ['2'], interrupts: [], invites: [], cf_choices: [], cf_event: '', cf_amount: false, cf_questions: [], cf_provides: null, cf_skip_gate: '' }),
     steps: [
         SIDE('cf_reset', "(cargo.formConfirm = cargo.formConfirm || {}, cargo.formConfirm[form] = '', cargo.confirmRanked = '', true)"),
         SET('cf_choices', 'cf_choices', `[{key:'yes',phrases:['1'].concat(Array.isArray(phrases)?phrases:Array.isArray(words)?words:[]),exact:true},{key:'no',phrases:(Array.isArray(no_keys)?no_keys:['2']).concat(${JSON.stringify(ANSWER_WORDS.no)}),exact:true}].concat((Array.isArray(interrupts)?interrupts:[]).map(function(event){return {key:'event:'+event.key,phrases:event.phrases ?? event.words,exact:event.exact!==false};}))`),
@@ -591,14 +600,11 @@ const confirmForm = {
         SET('cf_question_catalog', 'cf_questions', 'cargo.forms[form].questions || []'),
         SET('cf_provider_catalog', 'cf_provides', 'cargo.forms[form].providers'),
         SET('cf_gate_policy', 'cf_skip_gate', "!cf_provides || !cf_provides.gate || [].concat(cf_provides.gate.verified || []).every(function(p){return !!formPath({cargo:cargo},p);}) ? 'true' : ''"),
-        SET('cf_current', 'cf_current', "cargo.forms[form].proposalPrompt ? {form:cargo.forms[form].parent,name:cargo.forms[form].proposalPrompt.input} : {form:form,name:'',invites:Array.isArray(invites)?invites:[]}"),
+        SET('cf_current', 'cf_current', "cargo.forms[form].proposalPrompt ? {form:cargo.forms[form].parent,name:cargo.forms[form].proposalPrompt.input} : {form:form,name:'',invites:Array.isArray(invites)?invites:[],whole_reply:named_fields === true || named_fields === 'true'}"),
         SET('cf_match', 'cf_m', "cargo.choice === 'yes' || cargo.choice === 'no' && pickChoice(cargo.choiceText, [{key:'no',phrases:Array.isArray(no_keys)?no_keys:['2'],exact:true}], false) === 'no' ? { hits: [], ambiguous: [], questions:[] } : readFormAnswer(cargo.choiceText, cf_chain, cf_current, '',cf_questions)"),
         SIDE('cf_acceptance_trace', "(cargo.formAcceptance = formAcceptanceTrace(cargo.formAcceptance, cf_m), true)"),
         SET('cf_enrich', 'cf_m', "(function(m){m.hits=m.hits.map(function(h){return Object.assign({},h,{silent:true});});return m;})(enrichFormMatches(cf_m, cf_chain, form))"),
         SET('cf_count_words', 'cf_words', "String(cargo.choiceText || '').split(/\\s+/).filter(function (w) { return /[a-záéíóúüñ]/i.test(w); }).length"),
-        // opt-in (confirm.named_fields): 'the city is wrong' / 'la ciudad no' names exactly one input and gives no value; that
-        // input alone is asked again instead of the answer being DISPATCHed
-        SET('cf_named_field', 'cf_named', "(named_fields === true || named_fields === 'true') && cargo.choice !== 'yes' && !cf_m.hits.length && !cf_m.ambiguous.length && !cf_m.questions.length ? (function (text, chain) { var plain = function (v) { return ' ' + String(v || '').toLowerCase().replace(/[^a-z0-9áéíóúüñ]+/g, ' ').trim() + ' '; }; var said = plain(text); var named = chain.filter(function (input) { return (input.names || []).some(function (name) { return said.indexOf(plain(name)) >= 0; }); }); return named.length === 1 ? { form: named[0].form, name: named[0].name } : null; })(cargo.choiceText, cf_chain) : null"),
         WHEN('cf_question_fields', 'cf_m.questions.length > 0 && cf_m.hits.length > 0', FLOW('cf_question_accept', 'collect-input-accept', 'call', { hits: '{{cf_m.hits}}' })),
         WHEN('cf_question_provide', 'cf_m.questions.length > 0', FLOW('cf_question_answer', 'provide-data', 'call', { form: '{{form}}', provides: '{{cf_provides}}', asked_keys: '{{cf_m.questions}}', no_menu: 'true', no_gate: '{{cf_skip_gate}}' })),
         SET('cf_must_complete', 'cf_must', "formMustComplete(cargo,form,'__confirm')"),
@@ -607,10 +613,9 @@ const confirmForm = {
                 "condition: cargo.choice === 'yes'": SET('cf_answered', 'cf_result', "'yes'"),
                 'condition: cf_m.ambiguous.length > 0': FLOW('cf_ambiguous', 'disambiguate-input', 'call', { readings: '{{cf_m.ambiguous}}', hits: '{{cf_m.hits}}', remaining: '{{cf_m.remaining}}' }),
                 'condition: cf_m.hits.length > 0': FLOW('cf_accept', 'collect-input-accept', 'call', { hits: '{{cf_m.hits}}' }),
-                'condition: cf_named': SET('cf_named_reset', 'cf_result', "(resetFormInputs(cargo, cf_named.form, [cf_named.name]), 'changed')"),
                 "condition: cargo.choice === 'no'": SET('cf_declined', 'cf_result', "'no'"),
                 "condition: Array.isArray(clarifications) && pickChoice(String(cargo.choiceText || '').replace(/[?¿]/g,''),[{key:'clarify',phrases:clarifications,exact:true}],false)==='clarify'": SET('cf_clarification', 'cf_result', "'clarification'"),
-                'condition: !cf_must && cf_words > 0': FLOW('cf_elsewhere', 'read-confirm-reply', 'call', { form: '{{form}}', question: '{{cf_prompt}}', question_es: '{{cf_prompt_es}}', named_fields: '{{named_fields}}' }),
+                'condition: !cf_must && cf_words > 0': FLOW('cf_elsewhere', 'read-confirm-reply', 'call', { form: '{{form}}', question: '{{cf_prompt}}', question_es: '{{cf_prompt_es}}', named_fields: '{{named_fields}}', reply_context: '{{reply_context}}' }),
                 default: SET('cf_unclear', 'cf_result', "'unclear'")
             } },
         // the ranker's reading of an unread answer: a decline is the NO; an answer that declines nothing is asked again

package/dist/forms/identity-flows.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"identity-flows.d.ts","sourceRoot":"","sources":["../../src/forms/identity-flows.js"],"names":[],"mappings":"AA+BA,+GAA+G;AAC/G,oFAOC;AAQD,wFAAwF;AACxF,iDAGC;AACD,6CAMC;AACD,qHAQC;AAMD,4EAKC;AA6FD,2DAOC;AACD,4DAOC;AACD,gHAAgH;AAChH,8DAGC;AA4ID,8EAGC;AA4BD,4FAA4F;AAC5F;;;;EAOC;AAWD,oGAOC;AAvPD,iCAAgC,wIAAwI,CAAC;AACzK,wCAAuC,CAAC,CAAC;AAmQzC,0BAAmJ"}
+{"version":3,"file":"identity-flows.d.ts","sourceRoot":"","sources":["../../src/forms/identity-flows.js"],"names":[],"mappings":"AA+BA,+GAA+G;AAC/G,oFAOC;AAQD,wFAAwF;AACxF,iDAGC;AACD,6CAMC;AACD,qHAQC;AAMD,4EAKC;AA6FD,2DAOC;AACD,4DAOC;AACD,gHAAgH;AAChH,8DAGC;AAoJD,8EAGC;AA4BD,4FAA4F;AAC5F;;;;EAOC;AAWD,oGAOC;AA/PD,iCAAgC,wIAAwI,CAAC;AACzK,wCAAuC,CAAC,CAAC;AA2QzC,0BAAmJ"}

package/dist/forms/identity-flows.js

@@ -19,9 +19,9 @@ const worker = (id, name, summary, extra) => defineWorker({ id, name, scope: 'sh
 const otpMenuMessages = [];
 const raw = { name: 'raw', label: 'answer', label_es: 'respuesta', profile: { kind: 'text' } };
 const SERVICE_RESULT = 'cargo.serviceAnswer';
-const service = defineForm({ id: 'collect-service-answer', name: 'CollectServiceAnswer', description: 'Collect one protocol answer against explicit profiles and the owning FORM ancestry; return its accepted readings and original text.', contract: { summary: 'Shared FORM adapter for field-specific protocol services', result: { path: SERVICE_RESULT, type: 'object' } }, parameters: [param('profiles', 'Declared alternative input profiles', 'array'), param('question', 'English prompt'), param('question_es', 'Spanish prompt'), param('keypad', 'Keypad completion metadata', 'object'), param('prefill', 'An activation answer to validate through the same profiles'), param('context', 'Exit context'), param('context_es', 'Spanish exit context'), param('stop_path', 'State path that completes this protocol without another answer')], extraVars: { profiles: [], question: '', question_es: '', keypad: null, prefill: '', context: 'your request', context_es: 'su solicitud', stop_path: '', service_initial: [], service_raw: '', service_chain: [], service_matches: null, service_prefilled: false }, stop: '{{stop_path}}', close_on_stop: true, inputs: [{ name: 'answer', any_of: [raw], question_from: 'question', answer_precheck: 'service-answer-raw' }],
+const service = defineForm({ id: 'collect-service-answer', name: 'CollectServiceAnswer', description: 'Collect one protocol answer against explicit profiles and the owning FORM ancestry; return its accepted readings and original text.', contract: { summary: 'Shared FORM adapter for field-specific protocol services', result: { path: SERVICE_RESULT, type: 'object' } }, parameters: [param('profiles', 'Declared alternative input profiles', 'array'), param('question', 'English prompt'), param('question_es', 'Spanish prompt'), param('keypad', 'Keypad completion metadata', 'object'), param('prefill', 'An activation answer to validate through the same profiles'), param('context', 'Exit context'), param('context_es', 'Spanish exit context'), param('stop_path', 'State path that completes this protocol without another answer'), param('own_identifiers', 'This question reads identifiers itself: an owner form\'s identifier input never takes the answer', 'boolean')], extraVars: { profiles: [], question: '', question_es: '', keypad: null, prefill: '', context: 'your request', context_es: 'su solicitud', stop_path: '', service_initial: [], service_raw: '', service_chain: [], service_matches: null, service_prefilled: false }, stop: '{{stop_path}}', close_on_stop: true, inputs: [{ name: 'answer', any_of: [raw], question_from: 'question', answer_precheck: 'service-answer-raw' }],
     before: [
-        effect('service_declaration', "(function () {var state=cargo.forms[form_instance];state.data={question:question,question_es:question_es};state.specs=[{name:'answer',any_of:Array.isArray(profiles) && profiles.length?profiles:[{name:'raw',label:'answer',label_es:'respuesta',profile:{kind:'text'}}],question_from:'question',digits:keypad,answer_precheck:'service-answer-raw',as_spoken:true}];return true;})()"),
+        effect('service_declaration', "(function () {var state=cargo.forms[form_instance];state.data={question:question,question_es:question_es};state.specs=[{name:'answer',any_of:Array.isArray(profiles) && profiles.length?profiles:[{name:'raw',label:'answer',label_es:'respuesta',profile:{kind:'text'}}],question_from:'question',digits:keypad,answer_precheck:'service-answer-raw',as_spoken:true,own_identifiers:own_identifiers===true||own_identifiers==='true'}];return true;})()"),
         set('service_chain', 'service_chain', 'formInputChain(cargo.forms,form_instance,cargo)'),
         set('service_prefill', 'service_matches', "prefill ? enrichFormMatches(matchInputs(prefill,service_chain,{form:form_instance,names:cargo.forms[form_instance].specs[0].any_of.map(function(f){return f.name;})},''),service_chain,form_instance,cargo.forms[form_instance].specs[0].any_of.map(function(f){return f.name;}),'answer') : {hits:[],ambiguous:[]}"),
         when('service_prefill_ambiguous', 'service_matches.ambiguous.length > 0', call('service_prefill_clarify', 'disambiguate-input', { readings: '{{service_matches.ambiguous}}', hits: '{{service_matches.hits}}' })),
@@ -224,7 +224,7 @@ const code = worker('get-and-validate-otp-code', 'GetAndValidateOtpCode', 'Colle
         set('otp_question', 'otp_question', expression(otpPrompt, 'cargo')), set('otp_question_es', 'otp_question_es', expression(otpPrompt, 'cargo', 'true')),
         // a contact question's unsaid intro (identity_contact_intro_unsaid) leads the first code question only
         effect('otp_intro_said', "(cargo.otpIntro='',cargo.otpIntro_es='',true)"),
-        call('otp_collect', 'collect-service-answer', { profiles: '{{otp_profiles}}', question: '{{otp_question}}', question_es: '{{otp_question_es}}', keypad: { min: 6, max: 6 }, parent_form: '{{cargo.authOptions.parent_form}}', stop_path: 'cargo.otpVerified', context: 'account verification', context_es: 'verificación de cuenta' }),
+        call('otp_collect', 'collect-service-answer', { profiles: '{{otp_profiles}}', own_identifiers: true, question: '{{otp_question}}', question_es: '{{otp_question_es}}', keypad: { min: 6, max: 6 }, parent_form: '{{cargo.authOptions.parent_form}}', stop_path: 'cargo.otpVerified', context: 'account verification', context_es: 'verificación de cuenta' }),
         when('otp_verified_by_join', 'cargo.otpVerified === true', end('otp_join_finished')),
         set('otp_answer', 'otp_code', "String(cargo.serviceAnswer.values.code || cargo.serviceAnswer.raw || '')"), set('otp_choice', 'user_choice', 'otp_code.trim().toLowerCase()'), set('otp_digits', 'normalized_otp_code', expression(otpDigits, 'otp_code')),
         call('otp_validate', 'validate-otp-code', undefined, 'replace')
@@ -262,7 +262,7 @@ const validateCode = worker('validate-otp-code', 'ValidateOtpCode', 'Validate a
         when('otp_tenant_code', 'cargo.authOptions && cargo.authOptions.code_validator && normalized_otp_code.length !== 6 && /[0-9]/.test(user_choice)', call('otp_tenant_code_call', '{{cargo.authOptions.code_validator}}', { answer: '{{user_choice}}' })),
         set('otp_other_given', 'other_account_given', "answer_key === 'another_account' ? (cargo.authOtherAccount=String(answer_value || ''),true) : false"),
         set('otp_other_requested', 'wants_other_account', 'other_account_given || !!(cargo.callerPreselected && normalized_otp_code.length !== 6 && (matchesChoice(user_choice,otp_phrases.other) || otp_phrases.other_alone.includes(user_choice.replace(/[.,!?¡¿]/g,\'\').trim())))'),
-        when('otp_tenant_answer', 'cargo.authOptions && cargo.authOptions.answer_handler && normalized_otp_code.length !== 6 && !wants_other_account', call('otp_tenant_answer_call', '{{cargo.authOptions.answer_handler}}', { answer: '{{user_choice}}' })),
+        when('otp_tenant_answer', 'cargo.authOptions && cargo.authOptions.answer_handler && normalized_otp_code.length !== 6 && !wants_other_account && answer_key !== \'code_notice\'', call('otp_tenant_answer_call', '{{cargo.authOptions.answer_handler}}', { answer: '{{user_choice}}' })),
         set('otp_where_early', 'otp_where', expression(otpWhere, 'cargo')), set('otp_where_early_es', 'otp_where_es', expression(otpWhere, 'cargo', 'true')),
         cases('otp_response', {
             'condition: normalized_otp_code.length === 6': { id: 'otp_check_tool', type: 'CALL-TOOL', tool: 'validate-otp', variable: 'otp_validation_result', args: { otp: '{{normalized_otp_code}}', container: '{{cargo}}' }, onFail: call('otp_check_failed', 'get-and-validate-otp-code', undefined, 'replace') },
@@ -278,7 +278,9 @@ const validateCode = worker('validate-otp-code', 'ValidateOtpCode', 'Validate a
             'condition: matchesChoice(user_choice,otp_phrases.cannot_find)': say('otp_cannot_find', '{{otp_where}}', '{{otp_where_es}}'),
             'condition: matchesChoice(user_choice,otp_phrases.another_way)': say('otp_no_other_way', '{{otp_where}} To reach a person, {{cargo.verb}} AGENT.', '{{otp_where_es}} Para hablar con una persona, {{cargo.verb_es}} AGENTE.'),
             'condition: matchesChoice(user_choice,otp_phrases.later)': say('otp_later', "No problem. Say TEXT and I'll continue with you by message so you can do this when you are free, or {{cargo.verb}} the code whenever you are ready.", 'No hay problema. Diga TEXTO y sigo con usted por mensaje para que lo haga cuando esté libre, o {{cargo.verb_es}} el código cuando pueda.'),
-            'condition: normalized_otp_code.length > 0 && Number(cargo.otpFormatMisses || 0)<2': say('otp_bad_format', "I was expecting a 6-digit code. Let's try again. You can also {{cargo.voice ? 'press * or ' : ''}}{{cargo.verb}} EXIT to cancel.", "Esperaba un código de 6 dígitos. Intentemos de nuevo. También puede {{cargo.voice ? 'presionar * o decir' : 'escribir'}} SALIR para cancelar."),
+            // code_validator said why this answer is not taken (answer_key 'code_notice'): the question is asked again; it counts as a format miss.
+            "condition: answer_key === 'code_notice'": effect('otp_tenant_notice_said', 'true'),
+            'condition: normalized_otp_code.length > 0 && Number(cargo.otpFormatMisses || 0)<2': say('otp_bad_format', "I was expecting a 6-digit code. Let's try again.", "Esperaba un código de 6 dígitos. Intentemos de nuevo."),
             'condition: normalized_otp_code.length > 0': effect('otp_format_cap_next', 'true'),
             ['condition: matchesChoice(user_choice,otp_phrases.noPhone) || ' + expression(otpPhoneUnavailable, 'user_choice')]: otpMenu('otp_no_phone', "No problem. Then the code can't reach you there. You can use the email on your account instead, or {{cargo.verb}} AGENT to reach a person.", 'No hay problema. Entonces el código no le puede llegar ahí. Puede usar el correo electrónico de su cuenta, o {{cargo.verb_es}} AGENTE para hablar con una persona.', false),
             default: set('otp_words_missing', 'no_code_given', 'true')
@@ -336,8 +338,8 @@ for (const flow of [auth, validateCode]) {
         flow.variables[name] = { type: 'string', value: '' };
     flow.steps.unshift(...otpMenuMessages.map(([name, value]) => set(name, name, value.includes('{{') ? value : JSON.stringify(value))));
 }
-const retryParams = [param('error_message', 'Failure sentence'), param('error_message_es', 'Spanish failure sentence'), param('retry_flow', 'Retry destination'), param('cancel_flow', 'Exit destination'), param('capture_patterns', 'Declared contact capture readers', 'array'), param('retry_call_type', 'reboot or replace'), param('allow_code_entry', 'Accept the active six-digit challenge', 'boolean'), param('question', 'Retry question'), param('question_es', 'Spanish retry question'), param('caller_outcome', 'Unresolved outcome'), param('caller_reason', 'Unresolved reason'), param('parent_form', 'Owning task FORM instance'), param('contact_options', 'Contact field protocol declaration', 'object')];
-const retry = worker('generic-retry-with-options', 'GenericRetryWithOptions', 'Collect a retry, alternate contact, code or exit through the shared FORM adapter.', { scope: 'isolated', parameters: retryParams, variables: vars({ error_message: '', error_message_es: '', retry_flow: 'authenticate-user', cancel_flow: 'contact-support', capture_patterns: [], retry_call_type: 'reboot', allow_code_entry: false, question: '', question_es: '', caller_outcome: '', caller_reason: '', parent_form: '', contact_options: null, user_choice: '', smart_capture_result: null, normalized_otp_code: '', retry_question: '', retry_question_es: '', retry_yes_words: ['phone', 'email', 'cell', 'mobile', 'teléfono', 'telefono', 'celular', 'móvil', 'movil', 'correo electrónico', 'correo', 'try again', 'try it again', 'retry', 'intentar', 'intentarlo', 'intentar de nuevo', 'intentar nuevamente', 'intentarlo de nuevo', 'intentarlo otra vez', 'de nuevo', 'nuevamente', 'otra vez', 'reintentar', 'volver a intentar', 'volver a intentarlo'], retry_otp_profiles: OTP_PROFILES, retry_profiles_base: [{ name: 'phone', label: 'phone number', label_es: 'número de teléfono', profile: { kind: 'phone' } }, { name: 'email_address', label: 'email address', label_es: 'correo electrónico', profile: { kind: 'email' } }], retry_profiles: [] }), contract: { role: 'collector', summary: 'Common bounded service retry menu' }, steps: [
+const retryParams = [param('retry_misses', 'Replies already asked again', 'number'), param('error_message', 'Failure sentence'), param('error_message_es', 'Spanish failure sentence'), param('retry_flow', 'Retry destination'), param('cancel_flow', 'Exit destination'), param('capture_patterns', 'Declared contact capture readers', 'array'), param('retry_call_type', 'reboot or replace'), param('allow_code_entry', 'Accept the active six-digit challenge', 'boolean'), param('question', 'Retry question'), param('question_es', 'Spanish retry question'), param('caller_outcome', 'Unresolved outcome'), param('caller_reason', 'Unresolved reason'), param('parent_form', 'Owning task FORM instance'), param('contact_options', 'Contact field protocol declaration', 'object')];
+const retry = worker('generic-retry-with-options', 'GenericRetryWithOptions', 'Collect a retry, alternate contact, code or exit through the shared FORM adapter.', { scope: 'isolated', parameters: retryParams, variables: vars({ error_message: '', error_message_es: '', retry_flow: 'authenticate-user', cancel_flow: 'contact-support', capture_patterns: [], retry_call_type: 'reboot', allow_code_entry: false, question: '', question_es: '', caller_outcome: '', caller_reason: '', parent_form: '', contact_options: null, retry_misses: 0, retry_known: false, retry_picked: '', retry_asked: '', retry_reply: null, retry_ranked: [{ key: 'yes', label: 'wants to try again' }, { key: 'exit', label: 'does not want to try again and stops here' }, { key: '__agent', label: 'speak with a person (a live agent)' }], user_choice: '', smart_capture_result: null, normalized_otp_code: '', retry_question: '', retry_question_es: '', retry_yes_words: ['phone', 'email', 'cell', 'mobile', 'teléfono', 'telefono', 'celular', 'móvil', 'movil', 'correo electrónico', 'correo', 'try again', 'try it again', 'retry', 'intentar', 'intentarlo', 'intentar de nuevo', 'intentar nuevamente', 'intentarlo de nuevo', 'intentarlo otra vez', 'de nuevo', 'nuevamente', 'otra vez', 'reintentar', 'volver a intentar', 'volver a intentarlo'], retry_otp_profiles: OTP_PROFILES, retry_profiles_base: [{ name: 'phone', label: 'phone number', label_es: 'número de teléfono', profile: { kind: 'phone' } }, { name: 'email_address', label: 'email address', label_es: 'correo electrónico', profile: { kind: 'email' } }], retry_profiles: [] }), contract: { role: 'collector', summary: 'Common bounded service retry menu' }, steps: [
         set('retry_parent', 'parent_form', "parent_form || cargo.authOptions && cargo.authOptions.parent_form || cargo.contactOptions && cargo.contactOptions.parent_form || ''"),
         // The menu answers what its capture declares: an account number in the tenant's pattern (get-cell-or-email's
         // account_pattern, carried in cargo.authCapture) is the menu's own answer, never the parent's, so it reaches the lookup.
@@ -353,7 +355,13 @@ const retry = worker('generic-retry-with-options', 'GenericRetryWithOptions', 'C
         set('retry_latest_answer', 'user_choice', 'String(cargo.serviceAnswer.raw || "").trim().replace(/[.,!?;:]+$/,"")'), set('retry_capture', 'smart_capture_result', 'capture_patterns && capture_patterns.length ? normalizeAndFindCapture(user_choice,capture_patterns) : null'),
         cases('retry_capture_route', { 'condition: smart_capture_result && retry_call_type === "replace"': toParent(call('retry_captured_replace', '{{retry_flow}}', { cell_number: '', email: '', '{{smart_capture_result.variable}}': '{{smart_capture_result.value}}', retry_flow: '{{retry_flow}}', cancel_flow: '{{cancel_flow}}', retrying: true, contact_options: null, parent_form: '{{parent_form}}' }, 'replace')), 'condition: smart_capture_result': call('retry_captured_reboot', '{{retry_flow}}', { '{{smart_capture_result.variable}}': '{{smart_capture_result.value}}', retry_flow: '{{retry_flow}}', cancel_flow: '{{cancel_flow}}', retrying: true, contact_options: null, parent_form: '{{parent_form}}' }, 'reboot'), default: effect('retry_no_capture', 'true') }),
         set('retry_typed_code', 'normalized_otp_code', "allow_code_entry && user_choice.replace(/\\D/g,'').length === 6 ? user_choice.replace(/\\D/g,'') : ''"), when('retry_validate_code', '!!normalized_otp_code', call('retry_code_validate', 'validate-otp-code')),
-        cases('retry_decision', { 'condition: normalized_otp_code && cargo.otpVerified === true': end('retry_verified'), "condition: (user_choice.trim() === '1' || isAnswer(user_choice,'yes',retry_yes_words)) && retry_call_type === 'replace'": toParent(call('retry_yes_replace', '{{retry_flow}}', { retrying: true, cell_number: '', email: '', contact_options: null, parent_form: '{{parent_form}}' }, 'replace')), "condition: user_choice.trim() === '1' || isAnswer(user_choice,'yes',retry_yes_words)": call('retry_yes_reboot', '{{retry_flow}}', { retrying: true, contact_options: null, parent_form: '{{parent_form}}' }, 'reboot'), "condition: user_choice.trim() === '9' || isAnswer(user_choice,'text')": call('retry_text', 'switch-to-text', undefined, 'reboot'), "condition: isAgentRequest(user_choice)": call('retry_agent', 'live-agent-requested', undefined, 'reboot'), "condition: !user_choice.trim() || /^\\d$/.test(user_choice.trim()) || isExitRequest(user_choice)": call('retry_cancel', '{{cancel_flow}}', undefined, 'reboot'), default: { id: 'retry_dispatch', type: 'DISPATCH', outcome: '{{caller_outcome}}', reason: '{{caller_reason}}' } })
+        // A reply no key or whole answer settles goes to the reply ranker: it may pick an option, and a reply that picks none is asked again (twice at most), so a stray word never leaves this menu.
+        set('retry_known', 'retry_known', "!!normalized_otp_code || (user_choice.trim() === '1' || isAnswer(user_choice,'yes',retry_yes_words)) || user_choice.trim() === '9' || isAnswer(user_choice,'text') || isAgentRequest(user_choice) || !user_choice.trim() || /^\\d$/.test(user_choice.trim()) || isExitRequest(user_choice)"),
+        set('retry_rank_asked', 'retry_asked', "language === 'es' ? retry_question_es : retry_question"),
+        when('retry_rank', '!retry_known', { id: 'retry_rank_dispatch', type: 'DISPATCH', outcome: '{{caller_outcome}}', reason: '{{caller_reason}}', onResponse: 'continue', responseContext: 'Current question: {{retry_asked}}', responseChoices: 'retry_ranked', responseVariable: 'retry_reply' }),
+        set('retry_picked', 'retry_picked', "retry_reply && retry_reply.key || ''"),
+        when('retry_again', "!retry_known && !retry_picked && retry_misses < 1", call('retry_ask_again', 'generic-retry-with-options', { error_message: "Sorry, I didn't catch that.", error_message_es: 'Disculpe, no le entendí.', retry_flow: '{{retry_flow}}', cancel_flow: '{{cancel_flow}}', capture_patterns: '{{capture_patterns}}', retry_call_type: '{{retry_call_type}}', allow_code_entry: '{{allow_code_entry}}', question: '{{question}}', question_es: '{{question_es}}', caller_outcome: '{{caller_outcome}}', caller_reason: '{{caller_reason}}', parent_form: '{{parent_form}}', contact_options: '{{contact_options}}', retry_misses: 1 }, 'replace')),
+        cases('retry_decision', { 'condition: normalized_otp_code && cargo.otpVerified === true': end('retry_verified'), "condition: (retry_picked === 'yes' || user_choice.trim() === '1' || isAnswer(user_choice,'yes',retry_yes_words)) && retry_call_type === 'replace'": toParent(call('retry_yes_replace', '{{retry_flow}}', { retrying: true, cell_number: '', email: '', contact_options: null, parent_form: '{{parent_form}}' }, 'replace')), "condition: user_choice.trim() === '1' || isAnswer(user_choice,'yes',retry_yes_words)": call('retry_yes_reboot', '{{retry_flow}}', { retrying: true, contact_options: null, parent_form: '{{parent_form}}' }, 'reboot'), "condition: user_choice.trim() === '9' || isAnswer(user_choice,'text')": call('retry_text', 'switch-to-text', undefined, 'reboot'), "condition: retry_picked === '__agent' || isAgentRequest(user_choice)": call('retry_agent', 'live-agent-requested', undefined, 'reboot'), "condition: retry_picked === 'exit' || !user_choice.trim() || /^\\d$/.test(user_choice.trim()) || isExitRequest(user_choice)": call('retry_cancel', '{{cancel_flow}}', undefined, 'reboot'), default: { id: 'retry_dispatch', type: 'DISPATCH', outcome: '{{caller_outcome}}', reason: '{{caller_reason}}' } })
     ] });
 const EMAIL_CHOICES = { ok: ['1', 'ok', 'okay', 'yes', 'send', 'send it', 'si', 'sí', 'enviar', 'envíalo', 'correcto'], another: ['otro correo', 'otro correo electrónico', 'otro correo electronico', 'otro email', 'otra dirección', 'otra direccion', 'a otro correo', 'another email', 'a different email', 'different email', 'other email', 'another address', 'a different address'] };
 export function emailReadback(address, voice, es = false) {

package/dist/helpers/answer.d.ts

@@ -42,6 +42,8 @@ export function numericAmountReading(input: any): {
     candidates: number;
 };
 export function withoutPromptEcho(answer: any, questions: any): any;
+/** Is this unclaimed text only courtesy, connecting words, the field's own template words and numbers (an argument, even one no input took)? */
+export function isReaderFiller(text: any, templateWords?: any[]): any;
 /**
  * ask-choice's matcher: the key of the choice the answer picks, '__agent', '__exit', or '' (no choice).
  * choices: [{ key, phrases, negative?, neutral?, exact? }]. A key (digit, * or #) and a YES word pick a choice only as the whole

package/dist/helpers/answer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"answer.d.ts","sourceRoot":"","sources":["../../src/helpers/answer.js"],"names":[],"mappings":"AAsNA;;;GAGG;AACH,wEAkBC;AAED,qHAAqH;AACrH,+CAGC;AAED;;;;GAIG;AACH,mDAIC;AAED,+HAA+H;AAC/H,oDAIC;AAcD,2GAA2G;AAC3G,uDAGC;AAOD;;;;;GAKG;AACH,+DAUC;AAKD;;;;GAIG;AACH,oDAEC;AAqBD;;;;;;GAMG;AACH,mDAAmF;AAEnF,kGAAkG;AAClG;;;EAoCC;AAqBD,oEAqBC;AAED;;;;;;;;;GASG;AACH,6EA4GC;;;;;;;;AAhfD,qCAKwE"}
+{"version":3,"file":"answer.d.ts","sourceRoot":"","sources":["../../src/helpers/answer.js"],"names":[],"mappings":"AAsNA;;;GAGG;AACH,wEAkBC;AAED,qHAAqH;AACrH,+CAGC;AAED;;;;GAIG;AACH,mDAIC;AAED,+HAA+H;AAC/H,oDAIC;AAcD,2GAA2G;AAC3G,uDAGC;AAOD;;;;;GAKG;AACH,+DAUC;AAKD;;;;GAIG;AACH,oDAEC;AAqBD;;;;;;GAMG;AACH,mDAAmF;AAEnF,kGAAkG;AAClG;;;EAoCC;AAqBD,oEAqBC;AASD,gJAAgJ;AAChJ,sEAGC;AAED;;;;;;;;;GASG;AACH,6EA4GC;;;;;;;;AA7fD,qCAKwE"}

package/dist/helpers/answer.js

@@ -433,6 +433,18 @@ export function withoutPromptEcho(answer, questions) {
     }
     return raw;
 }
+// What a phrase reader may leave unclaimed around its phrases and arguments (profile.whole_phrases): courtesy, an
+// acknowledgement and the connecting words of a template ("I want to pay 50 with my Visa", "quiero pagar 50 con mi Visa").
+const CONNECTORS = ['i', "i'd", 'want', 'to', 'would', 'like', 'need', 'can', 'could', 'you', 'quiero', 'quisiera', 'deseo', 'necesito', 'voy', 'puedo',
+    'a', 'al', 'an', 'the', 'el', 'la', 'los', 'las', 'lo', 'un', 'una', 'my', 'mi', 'mis', 'su', 'of', 'de', 'del', 'for', 'por', 'para', 'in', 'en',
+    'with', 'using', 'con', 'and', 'y', 'it', 'its', 'is', 'es', 'that', 'this', 'esa', 'ese', 'esta', 'just', 'solo', 'me', 'on', 'one', 'uno',
+    'actually', 'mean', 'realidad', 'mejor', 'quise', 'decir'];
+const READER_FILLER = new Set([...CONNECTORS, ...[...COURTESY, ...ACKNOWLEDGEMENTS.map(normalize).map((w) => w.split(' '))].flat()].map(normalize));
+/** Is this unclaimed text only courtesy, connecting words, the field's own template words and numbers (an argument, even one no input took)? */
+export function isReaderFiller(text, templateWords = []) {
+    const template = new Set(templateWords.map(normalize));
+    return normalize(String(text ?? '').replace(/[^\p{L}\p{N}'\s]/gu, ' ')).split(/\s+/).filter((word) => /\p{L}/u.test(word)).every((word) => READER_FILLER.has(word) || template.has(word));
+}
 /**
  * ask-choice's matcher: the key of the choice the answer picks, '__agent', '__exit', or '' (no choice).
  * choices: [{ key, phrases, negative?, neutral?, exact? }]. A key (digit, * or #) and a YES word pick a choice only as the whole

package/dist/helpers/match-inputs.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"match-inputs.d.ts","sourceRoot":"","sources":["../../src/helpers/match-inputs.js"],"names":[],"mappings":"AAiBA;;;;GAIG;AACH,sEAQC;AAuFD;;;GAGG;AACH,sFA8GC;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH;mHACmH;AACnH;;;;;;;;;;;;;;;;;;;;;EAeC;AACD;;;;;;;;;;;;;;;;;;;;;;EAoOC"}
+{"version":3,"file":"match-inputs.d.ts","sourceRoot":"","sources":["../../src/helpers/match-inputs.js"],"names":[],"mappings":"AAiBA;;;;GAIG;AACH,sEAQC;AAuFD;;;GAGG;AACH,sFA8GC;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH;mHACmH;AACnH;;;;;;;;;;;;;;;;;;;;;EAeC;AACD;;;;;;;;;;;;;;;;;;;;;;EA+PC"}

package/dist/helpers/match-inputs.js

@@ -9,7 +9,7 @@
  * the flows. Part of jsfe/helpers; imports only siblings.
  */
 import { matchesChoice } from './matches-choice.js';
-import { pickChoice, amountInAnswer, isAmountAnswer, ANSWER_WORDS, CONFIRM_WORDS } from './answer.js';
+import { pickChoice, amountInAnswer, isAmountAnswer, isReaderFiller, ANSWER_WORDS, CONFIRM_WORDS } from './answer.js';
 import { readEmail, readPhone, readInternationalPhone, readIdentifier } from './contact.js';
 import { readSpokenMoney } from './spoken-money.js';
 import { readMoneyAmount, isPartialMoneyAnswer } from './money.js';
@@ -155,7 +155,7 @@ export function readInputProfile(profile, answer, isCurrent = true) {
         let readings = pool.filter(c => pickChoice(raw, [c], false) === c.key || numericSpans(c).length).map(c => {
             const words = (c.phrases ?? c.words ?? []).filter(w => matchesChoice(raw, [w]));
             const spans = [...choiceSpans(raw, words), ...numericSpans(c)].filter((span, index, all) => all.findIndex(other => other[0] === span[0] && other[1] === span[1]) === index);
-            return { value: c.key, ...(isCurrent && (c.keys || []).length && !isAmountAnswer(raw) && pickChoice(raw, [{ key: c.key, phrases: c.keys, exact: true }], false) === c.key ? { keypad: true } : {}), spans: spans.length ? spans : [[0, raw.length]], option_label: c.label || (c.phrases ?? c.words ?? []).find(w => !/^\d+$/.test(w)) || c.key, option_label_es: c.label_es || c.label || (c.phrases ?? c.words ?? []).find(w => !/^\d+$/.test(w)) || c.key };
+            return { value: c.key, ...(spans.length ? {} : { unlocated: true }), ...(isCurrent && (c.keys || []).length && !isAmountAnswer(raw) && pickChoice(raw, [{ key: c.key, phrases: c.keys, exact: true }], false) === c.key ? { keypad: true } : {}), spans: spans.length ? spans : [[0, raw.length]], option_label: c.label || (c.phrases ?? c.words ?? []).find(w => !/^\d+$/.test(w)) || c.key, option_label_es: c.label_es || c.label || (c.phrases ?? c.words ?? []).find(w => !/^\d+$/.test(w)) || c.key };
         });
         // A more specific declared phrase can cover a shorter phrase of the same field's other option.
         readings = readings.filter(r => !readings.some(other => other !== r && r.spans.every(([a, b]) => other.spans.some(([c, d]) => c <= a && d >= b && (c < a || d > b)))));
@@ -450,6 +450,27 @@ export function matchInputs(answer, candidates, current, choiceKey) {
     }
     // Rule 4: a single digit the current question offers as a key is that key (the keypad reading wins its group below);
     // one it does not offer reaches the invited amount, whose own validation decides ("3 dollars?").
+    // profile.whole_phrases (a choice, or a pattern that reads words): a phrase picks only when the answer is accounted
+    // for: its phrases, the arguments read beside them (numbers, amounts, a card), courtesy or connecting words
+    // (isReaderFiller) and the field's own profile.template_words. A template such as "pay 50 with my Visa card" stays;
+    // any other word beside a phrase means the words do not decide: the reply ranker does. A reading from digits or a
+    // keypad key is an argument, read as before.
+    const wordChoice = (reading) => { const profile = fieldOf(reading).profile; return ['choice', 'pattern'].includes(profile.kind) && profile.whole_phrases === true && !reading.keypad && !/\d/.test(spanText(reading)); };
+    const wholeAnswer = (reading) => {
+        const choice = (fieldOf(reading).profile.choices || []).find((c) => c.key === reading.value);
+        return !!choice && (reading.value === 'yes' && reading.unlocated === true || pickChoice(raw, [{ ...choice, exact: true }], false) === reading.value);
+    };
+    const located = readings.filter((reading) => !reading.fallback && reading.unlocated !== true);
+    const leftover = unclaimedSpans(raw, located).map(([a, b]) => raw.slice(a, b)).join(' ');
+    readings = readings.filter((reading) => {
+        if (!wordChoice(reading) || wholeAnswer(reading) || reading.unlocated !== true && isReaderFiller(leftover, fieldOf(reading).profile.template_words || [])) {
+            return true;
+        }
+        else {
+            refused.push({ form: reading.form, name: reading.name, value: reading.value, rule: 'unaccounted_words', spans: reading.spans });
+            return false;
+        }
+    });
     const paired = (a, b) => a.confirm.indexOf(b.name) > -1 || b.confirm.indexOf(a.name) > -1;
     // Narrative ownership protects ancestor choices and same-form choices that reset
     // the requested field. Other sibling choices remain independent compound data. A current choice can carry narrative context too (e.g. a channel plus a
@@ -550,5 +571,12 @@ export function matchInputs(answer, candidates, current, choiceKey) {
     hits.push(...kept.map(({ rule, ...r }) => strip(r)));
     // Why each field was filled other than as the current answer, kept beside the hits so their shape never changes.
     const decisions = kept.filter((r) => r.rule).map((r) => ({ form: r.form, name: r.name, rule: r.rule }));
-    return { hits, ambiguous, ...(remaining.length ? { remaining } : {}), ...(stopped.length ? { refused: stopped } : {}), ...(decisions.length ? { decisions } : {}) };
+    // current.whole_reply (a read-back whose fields a caller may correct): a reply with words the readings do not account for
+    // ("It's Long Beach, apartment 4" read only as the apartment) is the reply ranker's, so none of it is lost.
+    if (current?.whole_reply === true && hits.length && !isReaderFiller(unclaimedSpans(raw, kept).map(([a, b]) => raw.slice(a, b)).join(' '))) {
+        return { hits: [], ambiguous, refused: [...stopped, ...hits.map((hit) => ({ form: hit.form, name: hit.name, value: hit.value, rule: 'unaccounted_words', spans: hit.spans }))], ...(decisions.length ? { decisions } : {}) };
+    }
+    else {
+        return { hits, ambiguous, ...(remaining.length ? { remaining } : {}), ...(stopped.length ? { refused: stopped } : {}), ...(decisions.length ? { decisions } : {}) };
+    }
 }

package/dist/host/reply-rank.d.ts

@@ -19,10 +19,16 @@ export declare const REPLY_OPTIONS: readonly ["answers", "abort", "new_request",
 /** The fixed options, or `choice:<key>` for a declared choice. */
 export type ReplyOption = typeof REPLY_OPTIONS[number] | `choice:${string}`;
 /** A choice the question offers: its key and the words that describe it to the ranker. */
+export interface ReplyChoiceParameter {
+    name: string;
+    type: string;
+    description: string;
+}
 export interface ReplyChoice {
     key: string;
     label: string;
     route?: 'new_request';
+    parameters?: ReplyChoiceParameter[];
 }
 export declare const CHOICE_PREFIX = "choice:";
 /** An open question's reply that clears no option is its answer (owner decision 2026-10-26). */

package/dist/host/reply-rank.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"reply-rank.d.ts","sourceRoot":"","sources":["../../src/host/reply-rank.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"reply-rank.d.ts","sourceRoot":"","sources":["../../src/host/reply-rank.ts"],"names":[],"mappings":"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"}

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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"}

package/dist/index.js

@@ -2970,7 +2970,7 @@ async function detectFlowInTwoStages(input, engine, flows) {
 }
 /**
  * The reply ranker (jsfe/host reply-rank): what the latest message does with the question a contextual DISPATCH
- * asked — `answers`, `abort` or `new_request`. ONE aiCallback call whose 4th argument carries both executors'
+ * asked — `answers`, `abort`, `new_request` or `irrelevant`. ONE aiCallback call whose 4th argument carries both executors'
  * instructions; the host answers with System One and covers it with a text model (its aiCallbackRank). A reply that
  * is not an offered option throws, and the pending step stays for the caller's error policy. `confident` is false only
  * when the host says `answers` is the default because no option cleared its cut (`fallback: true`); an answer
@@ -3002,7 +3002,9 @@ function readResponseChoices(value) {
         if (!key || keys.has(key))
             throw new Error('Contextual response choices need unique nonempty keys');
         keys.add(key);
-        return { key, label: String(choice?.label ?? '').trim() || key, ...(choice?.route === 'new_request' ? { route: 'new_request' } : {}) };
+        if (choice?.parameters !== undefined && (!Array.isArray(choice.parameters) || !choice.parameters.length || choice.parameters.some((p) => !String(p?.name ?? '').trim() || !String(p?.description ?? '').trim())))
+            throw new Error(`Contextual response choice '${key}': parameters need a name and a description`);
+        return { key, label: String(choice?.label ?? '').trim() || key, ...(choice?.route === 'new_request' ? { route: 'new_request' } : {}), ...(choice?.parameters ? { parameters: choice.parameters.map((p) => ({ name: String(p.name), type: String(p.type || 'string'), description: String(p.description) })) } : {}) };
     });
 }
 function verbatimReplyField(parameters) {
@@ -6026,8 +6028,22 @@ async function processActivity(input, userId, engine) {
             }
             ranked = option.startsWith(CHOICE_PREFIX) ? 'answers' : option;
             if (option.startsWith(CHOICE_PREFIX)) {
-                // A declared choice is the whole answer: no extraction.
-                frame.variables[declaration.variable] = { key: option.slice(CHOICE_PREFIX.length) };
+                // A declared choice is the whole answer, unless it declares arguments: they are extracted like a flow's, and the
+                // pick stands when extraction finds none or fails (the flow asks for what is missing).
+                let extractedArguments = null;
+                if (pickedChoice?.parameters?.length) {
+                    try {
+                        extractedArguments = await extractReplyParameters(String(sanitizedInput), engine, question, pickedChoice.parameters);
+                    }
+                    catch (error) {
+                        logger.warn(`Contextual DISPATCH in '${frame.flowName}': extracting the arguments of '${pickedChoice.key}' failed (${error?.message}); the pick stands`);
+                        extractedArguments = {};
+                    }
+                }
+                else {
+                    // no arguments declared
+                }
+                frame.variables[declaration.variable] = { key: option.slice(CHOICE_PREFIX.length), ...(extractedArguments ? { arguments: extractedArguments } : {}) };
                 logger.info(`Contextual DISPATCH in '${frame.flowName}': the reply picks '${option.slice(CHOICE_PREFIX.length)}'; the flow continues`);
                 return false;
             }

package/dist/runtime-identity.js

@@ -1 +1 @@
-export const JSFE_RUNTIME_FINGERPRINT = "sha256:923fce885d15f0d4f4aa03dd7e52de2a6b2296774e8054ace034b99632519fe5";
+export const JSFE_RUNTIME_FINGERPRINT = "sha256:5870c4d1f0ecdf914230c505ee5be4280005b23c0ab1ec1e5c5563438f0f7ef2";

package/docs/architecture-guide.md

@@ -237,6 +237,7 @@ flowchart TD
    K -->|answers / a choice| V
    K -->|abort| X[End flows: request cancelled]
    K -->|new_request| D[DISPATCH]
+   K -->|irrelevant| Q[Ask the question again; no flow moves]
    A -->|no| D
    D --> S1[Intent detection, stage 1: which primary flow, or None]
    S1 -->|a flow| S2[Stage 2: that flow's parameters]
@@ -273,6 +274,10 @@ does this reply do with the question the flow asked? The model picks from a clos
 | `new_request` | the caller clearly asks for something else | DISPATCH: the message goes to intent detection |
 | `irrelevant` | the reply means nothing here: a stray word, an unfinished sentence, speech to someone else | the question is asked again; no flow moves |
 
+**Options with arguments.** A declared choice may carry `parameters` (`{name,type,description}`): a pick then extracts them from the reply with the same stage as a flow's parameters, and the flow reads `{ key, arguments }`. The pick stands when extraction finds nothing or fails. The ranker is generic, so the flow supplies the context: a form's `confirm.reply_context` says what a reply may contain. The address read-back uses this: "It's Long Beach, apartment 4" changes the city and the apartment and reads the address back, with no further question.
+
+**Word readers and the ranker.** An input with `profile.whole_phrases` reads a choice from words only when the whole reply is accounted for: its phrase, another input's argument, courtesy, connecting words and the input's `template_words`. A reply with any other word goes to the ranker, so a word inside a sentence ("Quiero hacer una nueva compra" at a pay menu) never picks an option. Compound answers that carry arguments stay with the reader ("pay $50 with my Visa card"), because a picked option extracts no arguments. A proposal's confirmation offers the ranker its input's choices, so a correction ("yes, it was stolen") picks the changed candidate.
+
 Some options are **never offered**, so the ranker cannot pick them: a choice marked `exact` (anything that charges or
 cancels) and the YES of a firm confirmation. A ranker can understand "no thanks, maybe later" as NO; it can never
 produce a YES to a payment. Options that cost more when wrong need a higher score (a NO that would cancel what the
@@ -288,7 +293,7 @@ the task ("OK, let's pay now"), the primary flow starts again and resumes from i
 everything again.
 
 A flow can also ask a question whose answer is open ("Describe the problem") with a **contextual DISPATCH**
-(`onResponse: "continue"`): the ranker decides whether the reply answers, withdraws or changes the subject, and an
+(`onResponse: "continue"`): the ranker decides whether the reply answers, withdraws, changes the subject or means nothing here, and an
 answer's fields are extracted by the same parameter extraction intent detection uses.
 
 **DISPATCH is not giving up.** Sending a caller to a person (the `give-up` worker) happens only after real attempts at
@@ -297,6 +302,8 @@ transferred.
 
 ### Intent detection: two stages
 
+With `engine.intentDetection = 'two-stage'` (the default is one single call):
+
 1. **Which flow.** Only primary flows can start this way, and stage 1 reads only their `description`: what should
    start the flow and, in a `Not:` list, what belongs elsewhere. The answer is one flow or `None`.
 2. **Which arguments.** For the chosen flow only, stage 2 extracts its parameters: closed values (an enum such as

package/docs/copilot-reference.md

@@ -40,6 +40,9 @@ A versioned entry has `declarationVersion: 2` (new authoring) or `1` (earlier se
 | `parameters` | Entry arguments: what a caller passes, or what may be said up front that no input asks. On a version 2 form, input parameters are generated and may not be written. Declare meaning precisely; never infer consent from extraction. |
 | `parameterInstructions` | Cross-parameter extraction guidance for stage two; not stage-one intent selection. |
 | `variables` | Initial local variables, preferably `{ "name": {"type":"string","value":""} }`. Object/array defaults are cloned per activation. |
+| `interruptable` | When it and every flow on the stack are true, intent detection may interrupt. |
+| `loopBound` | A string naming the runtime limit that ends a loop this flow is on; the flow-trap check accepts the loop and a test must drive the limit. |
+| `replaceTarget` | `true`: a `FLOW.replace` with `toParent:true` may return to this flow's waiting frame and take its place. |
 | `functions` | Named ordinary JavaScript bodies, described below. |
 | `contract` | Business summary, role, requirements, tool references and result metadata; builders supply normal protocol details. |
 | `wraps` | Ordinary thin wrapper over an installed shared flow, by ID/name. The shared target becomes non-primary; omitted wrapper description, parameters, prompts and primary flag inherit from it (a primary wrapper needs no description of its own). |
@@ -104,12 +107,14 @@ Each step has `type`, a stable `id`, and the applicable fields below. CASE/SWITC
 | `CALL-TOOL` | Registered `tool`, `args`, result `variable`, and explicit `onFail`. |
 | `END` | End only this flow; resume its caller after the FLOW call. A root simply finishes. |
 | `RETURN` | End all stacks and return the evaluated `value` to the host. Empty string forwards this turn's original input to host AI/RAG. Queued SAY text is dropped unless `keepSay:true`. |
-| `DISPATCH` | End all stacks, drop undelivered SAY text, and reroute this turn's input through primary intent detection. A match starts in the same turn; otherwise the host handles it with its conversation context. |
+| `DISPATCH` | End all stacks, drop undelivered SAY text, and reroute this turn's input through primary intent detection. A match starts in the same turn; otherwise the host handles it with its conversation context. Optional `outcome`, `reason`, `recovery`. Contextual form: `onResponse:"continue"` with `responseContext`, `responseVariable` (a declared object), `responseParameters`, `responseChoices` (a declared array variable of `{key,label?,route?:"new_request",parameters?}`), `responseReasonFor` (a string; not with `responseChoices`) and `onNoIntent:"stay"`. |
 
 `FLOW.call` runs the child and returns to the next caller step. `FLOW.replace` replaces only the current frame; when the replacement ends, it returns to the original caller. A shared replace preserves existing variables; `initializeDefaults:true` fills declared target defaults only where a value is undefined. Versioned native builders set this explicitly. An isolated target always has its own declared context. `FLOW.reboot` clears all stacks and starts a new execution context with explicit parameters, preserving cargo. Queued SAY text normally travels with the reboot; `discardSay:true` drops it.
 
 A `FLOW.replace` with `toParent: true` whose target flow declares `replaceTarget: true` returns to that flow's waiting frame and takes its place, dropping what ran above it. With either missing, or no such frame, it is a local replace. The validator refuses a loop holding a `call` (`stack_growth`) and a loop of replaces with no question in reach (`spin`); a flow on a loop that a runtime limit ends declares `loopBound: "<the limit>"`, and a test drives the loop to that limit. Use `call` for a closed sub-task and `DISPATCH` for anything the caller asked for.
 
+A flow trap (a loop of flows with no question in reach, or a stack that grows with each answer) refuses the set. Trap edges include form input form, validator, prepare, refresh, after, answer_precheck, answer_validator, on_no, on_declined; proposal prepare and on_declined; gate, source and action flow; parameters validate_flow, code_validator, answer_handler, failed_flow, cell_validator, email_validator, switch_reset (calls), restart (replace), retry_flow with retry_returns:true (replace). Not traps: a flow replacing itself, reboot, DISPATCH, loopBound, any path through a JSFE worker.
+
 For validated native `FLOW.parameters` and `CALL-TOOL.args`, interpolation references must be dotted paths such as `{{request.account}}`, not arbitrary expressions. Compute expressions in a preceding SET or named worker. Provider `gateParameters` is an authoring convenience that lowers whole-expression templates to SET steps before the call.
 
 `digits` on SAY-GET has `min`, `max`, optional `autoSubmitChars`, `autoSubmitMs`, and host-supported completion hints. A one-key answer must be exactly that key, not digits found inside a sentence. Direct `asSpoken:true` (or a condition string) preserves the original voice answer instead of digit reduction/AI cleanup. Use it for meaning-sensitive answers such as amounts; do not disable normal number/email cleanup indiscriminately. `pii:true` (or a condition) marks sensitive input for engine/host logging safeguards. FORM field spelling is `as_spoken`, not `asSpoken`.
@@ -155,14 +160,14 @@ Use one of these input shapes:
 | Preset field | `name`, `field`; optional overrides. Presets: `phone`, `email`, `zip`, `account_number`, `ssn_last4`, `amount`, `street_address`, `city`, `state`, `card_number`, `card_expiration`, `card_cvv`, `card_zip`. `card_cvv` takes its card brand's length (`validate-card-cvv`: 4 digits for American Express, 3 for every other brand). |
 | Inline field | `name`, `profile`, questions and business validation. |
 | Child form | `name`, `form:"installed-child-id"`, optional `parameters`. JSFE links its schema; do not copy the derived `schema` into editable source. |
-| Alternative group | `name`, `any_of:[leaf-or-child declarations]`; optional `exclusive:true`. At least one applicable member satisfies the group; exclusive competing answers require clarification. |
+| Alternative group | `name`, `any_of:[leaf-or-child declarations]`; optional `exclusive:true`. At least one applicable member satisfies the group; exclusive competing answers require clarification. A ranked pick at the group's question is read as the answer of the member that offers that choice. |
 | Bound requirement | `name`, `bind:"cargo.someVerifiedValue"`; a nonempty, non-false bound value satisfies it. A bound requirement is not a general text collector. |
 
 Field options:
 
 | Fields | Meaning |
 | --- | --- |
-| `label`, `label_es`; `question`, `question_es`; `retry`, `retry_es` | Names, first prompt and explicit retry wording. Contextual question templates compile to workers automatically. |
+| `label`, `label_es`; `question`, `question_es`, `question_voice`, `question_voice_es`; `retry`, `retry_es` | Names, first prompt and explicit retry wording. Contextual question templates compile to workers automatically. |
 | `question_text`, `question_text_es`; `retry_text`, `retry_text_es` | Optional written-channel wording, used instead when the conversation is not a call (`cargo.voice` false). |
 | `description` | Public extraction guidance; `response.description`, when used, describes an open answer. |
 | `when` | Map paths to desired scalar values or arrays; siblings use field names, session paths use `cargo.*`, owner data uses `form.*`. Values prefixed `!` exclude that value. |
@@ -185,15 +190,15 @@ Profiles:
 
 | `profile.kind` | Options |
 | --- | --- |
-| `choice` | `choices:[{key,phrases,label?,label_es?,keys?,exact?,neutral?,negative?,current_only?}]`; optional `accept_other`, `numeric_values`, `narrative`. |
+| `choice` | `choices:[{key,phrases,label?,label_es?,keys?,exact?,neutral?,negative?,current_only?}]`; optional `accept_other`, `numeric_values`, `narrative`, `whole_phrases`, `template_words`. |
 | `digits` | `min`, `max`: one unambiguous digit run of that length. |
 | `identifier` | `pattern`: permitted account identifier shape. |
-| `pattern` | `regex`, optional `flags`, `group`; optional `accept_other` for the current field only. |
+| `pattern` | `regex`, optional `flags`, `group`; optional `accept_other` for the current field only, `whole_phrases`, `template_words`. |
 | `phone`, `email` | Typed readers; email `literal:true` preserves an explicit visible address token in surrounding prose. |
 | `amount` | `min`, `max`, optional `marked:true` or `marked:"out_of_order"`; optional `money:{currency:"USD",cardinals:true,intent:"payment"}`. |
 | `text` | Current-field text fallback; `narrative:true` retains a substantive answer alongside independent structured fields. |
 
-`phrases` is the authoring name for matching aliases; `description` explains their meaning. Do not duplicate `words` / `gloss` aliases in new source. Historical executable definitions remain readable with those old keys; new names take precedence.
+`phrases` is the authoring name for matching aliases; `description` explains their meaning to parameter extraction only. For the reply ranker a choice is its `label`, or else its key and first six phrases, so write a `label` when the phrases do not convey the option; there is no rank attribute. Do not duplicate `words` / `gloss` aliases in new source. Historical executable definitions remain readable with those old keys; new names take precedence.
 
 Matching depends on policy. With `exact:true`, a phrase must form the whole normalized answer, allowing the engine's bounded courtesy/affirmation wrappers; questions and additional substantive corrections do not consent. Thus exact `here` does not accept `pay here`. Without exact, ordinary positive named choices may match within an unnegated clause: do not assume whole-answer matching. Keypad aliases, YES and NO-type answers have stricter rules regardless. `keys` are current-field-only whole-answer keypad aliases; they must not steal a monetary answer or identify a different field. `neutral` is not consent. Use exact choices for sensitive finite decisions.
 
@@ -213,7 +218,6 @@ Declarations:
 | input `invites:[names]`, `form.confirm.invites` | The other inputs this question (or the read-back) also asks for ("NEW CARD, LINK, or a different amount" invites `amount`), in its form or an enclosing one; read as in order while it is asked. |
 | profile `out_of_order:{…}` | A narrower signature for out-of-order reading: the payment card takes a bare last four when asked, but out of order only a card word or "ending in 4242". |
 | input `choices_from` | The choice's values come from prepared data (the caller's saved cards), so its signature is those values. |
-| `form.compound:"worker"` | A parser that reads several of the form's fields from one answer (an address said in one breath). |
 
 Rules, in order:
 
@@ -258,6 +262,10 @@ An unreadable answer with any words goes to the reply ranker, offered the questi
 
 `must_complete:true` on a form (inherited by every field of it and of the forms nested in it) or on one field (`false` on a field opts out): an unreadable answer is never yielded to DISPATCH, however long, and neither is a confirmation miss or an unresolved ambiguity — the question is asked again, acknowledged. Use it where leaving would strand an effect in progress (a payment's card, its billing-ZIP correction). Exits stay explicit: the form's stop words, `max_attempts` with `on_exhausted`, and whatever the host intercepts before the engine. The form runaway guard counts passes without a caller answer only.
 
+`confirm.named_fields: true` lets a caller correct a read-back in their own words: each input of this form that declares `names` and holds a value is offered to the reply ranker, and a pick extracts the new value of every such input, so one reply can change several. `confirm.reply_context` tells the ranker and the extraction what a reply may contain (never spoken); an input's `argument_description` says what its value looks like ("apartment or unit number alone, such as 4 or 12B"). A reply the word readers only partly account for goes to the ranker, so none of it is lost.
+
+`whole_phrases: true` on a `choice`, or on a `pattern` that reads words: a word reading picks only when the whole reply is accounted for by its phrase, another input's argument (digits, an amount, a card), courtesy, connecting words and the input's `template_words` ("pay $50 with my Visa card"). Anything else goes to the reply ranker, which is offered every choice. Keypad keys and digit readings are arguments and read as before. Off by default.
+
 A choice marked `current_only` is read only at its own question: neither the word reader nor the reply ranker offers it while another question is asked (a route's `done` or `switch` is never picked for a NO or a sub account said at the amount question). Written cents (`72.45`, `$72.45`, `287,15`) are an amount by shape: out of order they fill an open amount, and beside another field's reading (`51:72.45` at a sub account question) they are that amount, never digits of a security code or ZIP code.
 
 Use `response:{description}` for open descriptions that need a model's interpretation. The prepared question and field description become the contextual DISPATCH question, and the reply ranker decides what the reply does: an answer is extracted and still passes deterministic validation (missing usable data yields with progress saved); a withdrawal leaves for the host; a new request routes through intent detection. No separate field classifier/model role is needed. Do not attempt exhaustive conversational inference with keyword lists. A field that asks why the caller does not want something (a cancellation's reason) adds `reason_for` (the words) or `reason_for_from` (a form data key) to its `response`, so the ranker is offered no withdrawal there ("I don't use it" is the reason); the flow must confirm the request before acting.
@@ -273,7 +281,7 @@ Ordinary DISPATCH is the default uncertainty escape. An explicit contextual DISP
 }
 ```
 
-Declare `response` as a local object variable. A single open string parameter whose words are the value (a reason, a description) may add `"verbatim":true`: a confident `answers` then keeps the reply as said when extraction finds nothing. Never mark a field that names something to look up (a product, a city). The reply ranker answers `answers`, `abort` or `new_request` (nothing clear is `answers`). `answers` retains the live continuation and runs the following recovery steps; an optional typed response writes a cloned normalized object before continuing. `new_request` routes the input through intent detection; `abort` ends every flow as a RETURN with the reply `cmd_request_aborted` and outcome `user_aborted` (no recovery stamp). Neither writes that response object. Typed contextual v1 permits primitive string/boolean/number/integer fields, not object/array/jsonSchema. Missing fields remain missing. Errors preserve the pending step and prior object. Context is supplied to that decision without overwriting saved conversation history. This is existing configured intent/extraction, not authorization and not a snapshot restore.
+Declare `response` as a local object variable. A single open string parameter whose words are the value (a reason, a description) may add `"verbatim":true`: a confident `answers` then keeps the reply as said when extraction finds nothing. Never mark a field that names something to look up (a product, a city). The reply ranker answers `answers`, `abort`, `new_request` or `irrelevant` (nothing clear is `answers`; `irrelevant` extracts nothing and the question is asked again). `responseChoices` names a flow variable holding `[{key,label,route?,parameters?}]`: the ranker is also offered `choice:<key>`. A pick sets the response variable to `{key}`, plus `arguments` when the choice declares `parameters:[{name,type,description}]`. `route:"new_request"` makes a pick leave like a new request. `onNoIntent:"stay"`: a `new_request` that intent detection routes to no flow is an answer to this question, and the flow continues. `answers` retains the live continuation and runs the following recovery steps; an optional typed response writes a cloned normalized object before continuing. `new_request` routes the input through intent detection; `abort` ends every flow as a RETURN with the reply `cmd_request_aborted` and outcome `user_aborted` (no recovery stamp). Neither writes that response object. Typed contextual v1 permits primitive string/boolean/number/integer fields, not object/array/jsonSchema. Missing fields remain missing. Errors preserve the pending step and prior object. Context is supplied to that decision without overwriting saved conversation history. This is existing configured intent/extraction, not authorization and not a snapshot restore.
 
 ## 7. Providers
 

package/docs/development-release.md

@@ -1,133 +1,10 @@
-## 1.10.9: written wording for a written channel
-
-An input may carry `question_text` / `retry_text` (and `_es`): the wording used when the conversation is not a call
-(`cargo.voice` false). Absent, `question` / `retry` are used on every channel, as before. The phone, ZIP, account number
-and card presets carry them, so a chat no longer reads "Por favor diga o ingrese el número de su tarjeta" (prod 2026-10-26,
-web D365 and WhatsApp).
-
-**A restated phone number is read.** `readPhone` (and so `readIdentifier`) reads the last complete North American number after a sentence break or an "area code" when the whole answer is not one number: "Area code 21. 213 555 0147." was read as a Mexican number and "Area code, 213 555. Area code 213-555-0147." as nothing (prod 2026-10-26). An answer with an international prefix is never split.
-
-## 1.10.8: "por favor" confirms
-
-"please" / "por favor" alone are a firm YES (`CONFIRM_WORDS`; owner rule 2026-10-26: prod 21:47, "por favor" to "presione 1 o
-diga SÍ" at a payment offer was not taken and the payment was lost). "No, por favor", "espere por favor" and "un enlace
-por favor" are still not a YES.
-
-## 1.10.7: a firm question's key in minimal context
-
-At a firm question (a yes choice that charges or cancels), its key confirms only alone or beside please/thanks or a CONFIRM
-word: "1", "uno", "1, por favor", "Sí, 1" (owner rule 2026-10-25). It no longer confirms beside a soft YES word or an
-acknowledgement ("1 está bien", "ok 1"), a key-naming word ("opción 1", "el número 1", which 1.10.5 had admitted) or other
-filler ("um, 1"). Firm YES words are unchanged ("Sí, está bien" still confirms).
-
-## 1.10.6: pointing at the offered thing
-
-At a soft question (a yes choice that does not charge or cancel), a word pointing at the offered thing may lead the YES:
-"ese está bien", "esa sí", "that one is fine" (prod 2026-10-25 17:46: "Ese está bien." to "¿Se lo envío a …?" was not a
-yes and the caller lost the flow). "ese mismo", "el mismo", "that's the one" are soft YES phrases. A pointing word alone is
-never a YES, and a firm question stays strict.
-
-## 1.10.5: a key named before it
-
-At a numbered choice, a word naming the key said right before it picks the key: "el número 4", "opción 2", "number 4", "the
-4" (`keyWithOnlyCourtesy`; prod 2026-10-25 18:25, "Número 4" and "El número 4" at a numbered product list were not
-understood, twice, and the caller lost the flow). A number anywhere else in a sentence is still not a key.
-
-## 1.10.4: forms that must complete
-
-`must_complete:true` on a form or a field (a field inherits it from any enclosing form; `false` on a field opts out): an
-unreadable answer, long or short, a confirmation miss and an unresolved ambiguity are asked again instead of yielding to
-DISPATCH (reference, "Retry, yield and recovery"). Prod 2026-10-25: "el número postal el código postal" at the billing-ZIP
-correction ended the payment. The form runaway guard now counts passes since the caller's last answer, so a caller who
-needs several tries is not mistaken for a loop.
-
-## 1.10.3: a field is ready before an unnamed answer fills it
-
-A bare number never fills, out of order, a field whose `depends_on` prerequisites are not filled yet (`formInputChain`
-marks each candidate `ready`; refusal rule `prerequisite_unmet`): an account number keyed in pieces is no longer taken for
-the payment's sub-account before the account is known. A named answer still waits as a pending value. The shared card
-expiration also reads a zero said between month and year ("020 28" as 02/28).
-
-## 1.10.2: "account number" at the contact question
-
-At the shared contact question (`get-cell-or-email`), a caller who names the account number without giving it yet ("número
-de cuenta", "account number"; only where the tenant takes account numbers) hears the question again, acknowledged ("Claro,
-su número de cuenta."), instead of the failure menu, so the number keyed next is read as the account number.
-
-## 1.10.1: refusals that stopped something
-
-`matchInputs` lists a refused reading only when it stopped something: one whose part of the answer a structured in-order
-reading (a key, the code, the amount asked) also claimed would have lost anyway, so "2" at a menu is its key, not a refused
-amount, and the host's `form_acceptance` counts real leaks. A free-text fallback does not count as a claim. The
-standard-functions test recognizes named function expressions and arrow functions a flow defines for itself.
-
-## 1.10.0: context-aware acceptance
-
-An answer given out of order fills another question's field only where it is relevant there (reference §5): a confirmation
-(`confirmation:"firm"` or `"soft"` on a choice keyed yes and no) is answered only when asked, firm by the confirm words and
-soft by the wider YES vocabulary; a bare number is an amount only at a question that is, invites (`invites`, also on a
-read-back's `confirm`) or is paired (`confirm_against`) with one; a number read out of order must be whole, never the
-fragment of a longer one; a profile may declare a narrower out-of-order signature (`out_of_order`); and one part of an
-answer never fills two fields. `matchInputs` lists `refused` readings and the `decisions` behind out-of-order fills, and
-the form workers append them to `cargo.formAcceptance` (`formAcceptanceTrace`, names and rules only) for the host to log.
-At the code question, "Otra", "Número de cuenta" and "Account number" mean ANOTHER ACCOUNT.
-
-## 1.9.4: card groups start like a card
-
-`accumulate_first` (a regular expression) limits accumulation to a first group that matches it; the `card_number` preset
-uses `^[2-6]` (every card network's first digit), so "1234" or "0729" said at the card question keeps its normal reading
-as an expiration date or a security code.
-
-## 1.9.3: a card number said in groups
-
-A digit input may opt in to `accumulate: true`: an answer that is only digits and short of the input's minimum is kept, and
-the next question is "Go on." / "Continúe."; the next digits are joined to it, and anything that is not digits drops the
-partial. The shared `card_number` preset opts in, so a card read in groups across turns is collected whole instead of each
-group being read as another field (an account number, an amount).
-
-## 1.9.2: address city list and part corrections
-
-The shared address form (`collect-geocoded-address`) asks the city when the ZIP code carries several place names (`geocode-zip` returns `localities`, Google's `postcode_localities`; at most 7): "Which city is it: Commerce, East Los Angeles, Los Angeles or Vernon?", by name or key. With one name it is not asked, and a caller who says the city is wrong is asked it plainly and any city is taken. At the read-back, naming one part without a value ("the city is wrong", "la ciudad no") asks only that part again, and a plain NO asks which part is wrong (zip code, city, street, apartment, or ALL to start over) instead of starting over. The part naming is an opt-in form confirmation setting, `confirm.named_fields: true`, read from each input's `names`; other forms keep their behavior. A host whose `geocode-zip` returns no `localities` keeps the one city it returns. A city read from the ZIP code alone is replaced by the city of an exact (rooftop) street match (90805: the ZIP lookup names Lakewood, its streets are Long Beach and Lakewood); a city the caller chose or gave is never replaced. With `named_fields`, a correction the word reader cannot read ("es Long Beach") goes to the reply ranker, which is offered each named part read back (`field:<input>`); a pick asks that part again, so the caller's value replaces the one read back.
-
-At the verification code question the reply ranker is offered `where`: a caller who asks where the code is ("¿dónde está?") hears where it went (by text to the cell ending with the last four digits, by email, or in this chat) and the code question again; nothing is sent again.
-
-The contact question's `intro` (why the account is needed) is not lost when the question is answered without being asked (the caller ID on file, a contact the caller gave): the first verification code question begins with it instead, once. A contact question that is asked says it, as before, and the code question does not repeat it.
-
-A form's or performer's `provides` catalog is validated like a provider's (`validateFlowContracts`: facts present, unique keys, a source path or worker for each fact, a gate for private facts, known gate and source workers), and every catalog's menu choices must name existing flows (a FLOW to an unknown name is skipped silently at run time). The check runs where flow sets are built and validated, never when an engine loads a set.
-
-## 1.9.1: stored sessions without definition copies
-
-`engine.storedSession(session)` returns the session as a host should store it: each open form instance's input specs, providers and questions that its loaded definition (or its parent's schema) reproduces exactly are replaced by a named source (`derived`), and continuation revision hashes are kept only for the definitions of open form instances, the only ones read back. Anything a flow built at run time is stored as it is. `updateActivity` restores a stored session from the loaded flows; a source that no longer exists is left absent and the continuation safety check retires it. The session passed in is never changed, and a session never stored this way continues as before. Measured on a production payment call: 182 KB to 110 KB, 245 revision hashes to 5.
-
-## 1.9.0: shared data
-
-A flow set may carry one reserved shared-data entry (`library:"data"`, version 2), read two ways. Expressions read it at run time as `$data.<name>` (`Object.values($data.services)`): one deep-frozen copy per engine, never saved in a session, and every `$data.<name>` an expression reads must exist when the engine is built. A declaration field that is not an expression (a choice's phrases or label) references it by path as `{"$data":"a.b.c"}`, which compiles to a copy. `$data` is a reserved evaluation namespace. Unknown paths and names, duplicate names and reference cycles fail at load. Version 1 is unchanged. JavaScript authoring of flows (the public Form/Provider/Performer/Worker builders and compileExpression) is deprecated: author JSON declarations; the builders leave the public API at 2.0.
-
-## 1.8.1: version 2 fixes found in the first tenant migration
-
-A generated parameter is also a variable of its flow, as an authored one always was, so a flow's expressions can read it by name (without it, removing an authored copy left `service is not defined`). Compiling already compiled version 2 flows again keeps working: a FLOW call may pass a compiled form target's protocol variables, and a shared-functions entry beside compiled flows is accepted.
-
-## 1.8.0: declaration version 2, shared functions, option clarification
-
-`declarationVersion: 2` makes parameters one contract: a primary form's input parameters (sub-forms as object parameters with every nested field) are generated, and writing one of those names in `parameters` is a compile error at any depth. `parameters` holds only entry arguments. An enum value's meaning is read from its choice's `description`, after the input's own `description` as the rule (`enumDescriptions`, and the parameter description `rule: key: meaning; …`); `extract:false` keeps a choice out of the enum and `internal:true` marks an input extraction never fills. A FLOW step may pass only arguments a version 2 target declares. Version 1 is unchanged.
-
-A flow set may carry one reserved shared-functions entry (`library:"functions"`, version 2); every version 2 flow sees those functions, and a redefinition or a name declared twice fails compilation. `functions` on an undeclared flow now fails compilation instead of being silently ignored. A primary `wraps` wrapper may omit its description (it inherits it). When a phrase is shared by two options of ONE input, the clarification names them ("Do you mean Gold Club or Member Benefits?" / "¿Se refiere a … o a …?"); a Spanish option label falls back to its first phrase rather than its key.
-
-## 1.7.9: simpler authoring and DISPATCH ownership of conversational interpretation
-
-The separate input-assessment classifier, model override and ASSESS-INPUT step are removed. Open-ended fields use existing contextual DISPATCH extraction and concise descriptions; an uncertain answer yields to the host with saved progress. Narrative correction phrases and broad payment refusal/tense rules are removed. Strict money reading, exact confirmation, proposal dependencies and action recovery guards remain.
-
-Requires matched shared and tenant definitions. Updated safety revisions retire incompatible saved continuations before consuming input and preserve unknown action holds. Old meaning/assessment declarations fail admission rather than silently bypassing validation. This is an intentional removal of the 1.7.8 assessment extension, not a drop-in runtime-only upgrade. Publish and activate the matched shared/tenant definitions together; the runtime alone is not sufficient.
-
-The Form, Provider, Performer and Worker authoring facades derive conventional metadata, parameter defaults, extraction descriptions and provider questions. Plain synchronous calculations/projections compile into ordinary guarded JSFE steps; compileExpression centralizes existing compound expression serialization. explainSession reads existing session snapshots and diffs without exposing collected values or introducing state. Runtime execution continues to consume JSON flow/tool sets, with the established shared-set composition.
-
 # Reproducible native JSFE development candidate
 
 The native form/performer implementation spans the engine, host and tenant flow generator. Testing an unversioned sibling symlink does not establish that a clean consumer installation will use the same engine.
 
 A local candidate is an unpublished prerelease. Freeze and test its source, run `npm run clean`, `npm run build` and `npm test`, then use `npm pack --ignore-scripts` to create an immutable artifact. Never replace a candidate tarball with different bytes under the same version. If runtime source changes afterward, create the next prerelease version.
 
-Both consumers pin the identical tarball under `vendor/jsfe/` using an exact `file:` dependency and lockfile integrity. Record the tarball SHA-256, package version, engine runtime fingerprint, source revisions and dirty source digest, and Node/npm versions. Verify each installed consumer's bytes with `flow-tests/lib/runtime-build.mjs`; matching package version labels alone are insufficient. Exercise a clean `npm ci` installation before accepting the candidate.
+Both consumers pin the identical tarball under `vendor/jsfe/` using an exact `file:` dependency and lockfile integrity. Record the tarball SHA-256, package version, engine runtime fingerprint, source revisions and dirty source digest, and Node/npm versions. Verify each installed consumer's bytes with `flow-tests-dev/lib/runtime-build.mjs`; matching package version labels alone are insufficient. Exercise a clean `npm ci` installation before accepting the candidate.
 
 Acceptance includes engine tests, host journal/save-boundary/invalidation tests, tenant `npm run test:accept`, real-engine production-response-shape journeys, the independent designer-skill example and bilingual live intent/parameter probes. Include late completion after newer saved work, versioned receipt acknowledgment races, expiry/reset recovery, strict projector failure, optional follow-up outcomes and explicit confirmation clarification. Exercise the actual storage adapter and conversation helpers with full session checkpoints and high-entropy history, checking exact decoded round trips, complete item bounds and removal of acknowledged checkpoint payloads. Customer/API effects in these checks use local stubs. Model credential access is a separately authorized test operation. Do not retain credentials in reports.
 
@@ -146,115 +23,3 @@ Native performer declarations from 1.7.1 include `contract.requires: ['guardedAc
 Session-only opt-out (1.7.1) requires `config.jsfe.actionPersistence:'session-only'`, no attached journal, and `durableActions` absent or false. The engine defaults to durable and missing storage still fails closed. Session-only retains confirmation, subject, revision, gate and session-owned attempted/completed/unknown guards, but cannot recover an effect after its updated conversation save is lost. It creates no durable receipts or journal traffic. Action-enabled conversations pin their mode before the first effect; changing the mode of an existing conversation or abandoning durable recovery metadata is rejected. Apply the new mode to fresh conversations and keep existing conversations on their original routing. See [session-only semantics](copilot-reference.md#action-persistence).
 
 Publishing the package, deploying the host or uploading tenant/system flow sets are separate release actions requiring the owner's authorization. A release should replace local tarball dependencies with the exact published package whose bytes were accepted, and deploy matched host/system/tenant contracts together. No deployment is implied by a passing local candidate.
-
-## 1.7.2 retry/yield/recovery acceptance
-
-Native contextual misses default to one localized re-ask then DISPATCH of the second current utterance. Validation attempts and declared exhaustion callbacks are independent. Dynamic question refresh, explicit localized retries, nested/out-of-order input, provider detours and recognized clarification questions require behavioral assertions. A required draft yields pending; a failed service stays unresolved; a completed optional follow-up stays completed; unknown effects remain held. The host must consume explicit recovery rather than infer restartability from `unresolved`. Unannotated legacy JSON retains its historical path.
-
-Acceptance must include real engine-produced states through the actual host outcome and consume-once guidance adapter, not only helper snapshots. Verify English/Spanish and voice/text, “imposible” never confirms, exact price-reference utterance handoff, same root/accepted values on resume, fresh consent after correction, validator-specific limits, completed receipts, unknown-action holds, matched dispatch suppression and next-turn clearing. Run full engine and tenant matrices and clean consumer installs; Shopify behavior is outside this release and its source/artifact bytes must remain unchanged.
-
-## 1.7.3 input-proposal confirmation
-
-The shared proposal contract is opt-in through input declarations or validator descriptors. It retains candidates before canonical acceptance, uses an owned exact-confirmation context and revalidates proof before commit. No host or website changes are part of this implementation. The contract is included in JSFE 1.7.3. Publishing and pinning the package do not activate regenerated flow definitions or deploy a host.
-
-`contract.requires:['jsfe:input-proposals:v1']` describes intrinsic runtime support, not host configuration. Current JSFE admits that version directly; unknown `jsfe:*` contracts fail closed. Static and linked child declarations derive the requirement and strict entry guard; dynamic proposal workers declare it explicitly. Older runtimes must reject the matched definitions before tenant behavior. Release/pin the accepted runtime before activating regenerated shared and tenant sets. Both consumers must pin the same exact published runtime before the matched shared and tenant flow definitions are activated.
-
-## 1.7.5 input ownership and intent corrections
-
-The local candidate corrects input ownership for incidental known-parent choices, keeps independent structured spans independent, and recognizes text-switch intent only as a complete command. English/Spanish courtesy and explicit continuation commands work; OTP delivery questions, quoted/code/struck-through commands, negation and extra-content sentences do not switch channels. Exact action consent, subject gates, money parsing, durable journal behavior and storage formats are unchanged. Provider terminal phrases retain priority when courtesy also makes them fit a shorter neutral action.
-
-Tenant integration resolves a valid canonical case before compatibility routing, builds CRM verification text from the same contact snapshot as payload flags, and handles account-menu bare NO through the existing provider action contract. Intent probes fail execution errors independently of expected intent, reject malformed/empty runs, and retain a bilingual synthetic corpus. The new corpus is not a reconstruction of the historical uncommitted production replay.
-
-Accept the same immutable tarball in isolated matched host/tenant installs. Run every engine suite and `npm run test:accept`, including the original journeys on both flow sets; `npm test` alone runs the curacao suites in legacy mode. Add host preprocessing end-reason checks to distinguish a closing question from a farewell, and exercise actual tool-call counts, payloads, reentry and fresh consent. Live model probes are separate from hermetic acceptance and retain execution failures as failures. Release authorization was granted after the local review. Publish the accepted runtime as 1.7.5, pin both consumers, deploy the dev host, then activate the matched shared and tenant definitions in the three dev configs. Production deployment remains a separate action.
-
-## 1.7.6 reviewed input recovery and data ownership
-
-The release preserves complete FORM voice answers before profile normalization, adds opt-in narrative evidence ownership and dependency-aware choice handling, and resumes a changed opted-in ancestor through its live owner. Contextual literal email reading remains opt-in. Absent/null named tool argument bags normalize without changing supplied object payloads or nullable roots.
-
-Contextual DISPATCH is opt-in through `onResponse:"continue"` and `responseContext`. A scoped ContinueCurrent decision runs authored bounded recovery without terminating the owner; a registered workflow replaces it once; None hands an unrelated request to the host. Detection precedes termination and outcome/recovery stamping. Model errors do not authorize a switch, reserved disposition names cannot collide with registry names, and ordinary DISPATCH is unchanged. Both the native and canonical legacy contact collectors opt in. Confirmation, action persistence and storage encoding contracts are unchanged.
-
-Reviewed acceptance: all 81 engine test files, 121 legacy and 121 native tenant suites; all 622 deterministic and 622 production-model primary journeys spanning 17 primaries and 166 applicable paths. Full-day replay retains 2,325 conversations and 8,543 original turns with no engine exceptions. Nine extraction deadlines and one empty Shopify cleanup response remain visible in model-health evidence; the extraction cases rechecked cleanly with production model redundancy. Shared Shopify's safe original-input fallback remains separately scoped. Unknown backend fixtures are diagnostic, never customer-success evidence.
-
-Owner authorized publication, exact consumer pins, dev host deployment and matched shared/native flow activation on all three dev configs with session-only action persistence. Production deployment/activation is not part of this release authorization. Publish/install the accepted package before activating its matched definitions.
-
-## 1.7.7 typed contextual responses and explicit registry composition
-
-Typed contextual DISPATCH binds canonical primitive fields only after ContinueCurrent, using the active question in both intent stages. Named/None handoffs do not commit old input. Routing/extraction failures preserve pending ownership; a second incompatible decision in one turn fails closed. The capability and its strict entry guard are explicit; existing ordinary DISPATCH remains unchanged.
-
-`jsfe/host` exports opt-in `composeRegistries` for independently compiled modules. It clones plain JSON declarations, deduplicates identical same-ID definitions, and rejects conflicts and case-insensitive ID/name aliases. Array and object property order remain execution data. Existing engine loaders do not compose implicitly.
-
-Reviewed Shopify acceptance covers 47 native definitions, three primary providers, 639 domain assertions, 88 production-model synthetic journeys (336 turns), both 127-suite tenant modes, and 83 SDK test files. Customer tools remain local stubs. The 12 retained nonprimary legacy definitions serve saved continuations only; native host admission rejects known fresh legacy references and incomplete native bundles.
-
-Owner authorized publication, exact consumer pins, dev host deployment, and matched shared/native Shopify activation for all three dev tenant configurations with explicit session-only action persistence. Production deployment/activation is outside this authorization. Match runtime, system, tenant and Shopify assets; do not enable native Shopify on the older production system registry.
-
-## 1.7.8 explicit intake meaning and continuation safety
-
-Optional declared field meanings use ASSESS-INPUT with a strict accept/retry/cancel/redirect result. This validation never grants action consent. Technical failure leaves input unaccepted and asks for a technical retry; late answers do not commit withdrawn work. Existing unmarked inputs do not invoke an assessment. The matched host qualifies GPT-6 Sol for this task, requires its schema-capable transport, and does not fall back to an unqualified model.
-
-Proposal dependency handling preserves a corrected candidate through its new explicit confirmation. Opted-in continuation safety revisions stop obsolete frames and yielded form continuations before consuming new input. An uncertain prior effect remains held for authoritative reconciliation; no automatic replay or expiry releases it. Session-only mode and its confirmation, subject and attempted/completed/unknown guards remain explicit. Storage encoding and durability defaults do not change.
-
-Payment interpretation rejects partial cents and card references as replacement amounts, distinguishes historical payment reports from new instructions, and keeps balance distinct from amount due. Identity recovery has bounded resend, lost-phone and disambiguation paths. Saved-card profiles deduplicate by stable identity and omit declined profiles.
-
-Reviewed acceptance: 89 SDK test files; 142 legacy and 142 native flow suites; 626 hermetic and 626 real-model primary executions across 17 primaries and 167 applicable paths. Targeted model probes: consent/intake 229/230, payments 16/16 per flow set, routing 132/132. The one consent deadline safely left input unaccepted with no case filed; its late verdict was retry, and bounded same-source rechecks passed in both flow sets. Original observations remain retained. Customer effects use local stubs; these results do not claim a literal replay of the October 21 production day.
-
-Owner authorized publication, exact pins in both consumers, dev host deployment and matching shared/ai-ar-ql activation in all three dev configs with session-only actions. Production deployment and activation are excluded. Shopify Policy remains unchanged with its later review recorded as a tenant TODO. Match runtime, host and regenerated definitions before activation; existing uncertain work must retain its hold.
-
-
-## 1.7.11 — self-contained JSON authoring
-
-Version-1 JSON flow declarations compile inside JSFE. Tenant JSON contains its forms, providers, performers, workers and ordinary named JavaScript functions; source snapshots remain detached from executable state. Named functions use explicit session arguments and normal JavaScript loops/callbacks. `phrases` and provider `description` are the authoring names; existing executable `words`/`gloss` inputs retain compatibility. Continuation safety revisions are generated internally from source declarations and preserve unknown action holds. The single authoring specification is `docs/copilot-reference.md`, also consumed by the Lambda CoPilot.
-
-Owner authorized publication, exact pins in both consumers, dev host deployment and matching shared/ai-ar-ql activation on all three dev configurations with session-only actions. Native Shopify remains composed and Shopify Policy remains unchanged. Production is outside this authorization. Full execution/model replay follows the matched dev activation; local focused results are not relabelled as full published-runtime acceptance.
-
-The 1.7.10 publication workflow was stopped before publication after the host-composition preflight rejected call-only declarative workers. Its tag is retained unchanged. The corrected 1.7.11 candidate includes actual registry-composition-to-engine execution coverage.
-
-## 1.7.12 — OTP recovery catalog correction
-
-Correct four OTP decision expressions to reference the renamed `otp_phrases` catalog. The incomplete rename in 1.7.11 prevented resend, lost-phone, later and some invalid-code recovery branches from executing correctly. Consent, authentication, action persistence and tool permissions are unchanged. A focused runtime regression executes the actual shared validator for English/Spanish lost-phone answers, resend, later and a short code, requiring no expression failures and no authentication. Tenant execution checks cover the affected account, identity, statement-delivery and proposal paths.
-
-This corrective release follows the same authorized dev-only rollout: exact consumer pins, matched shared and ai-ar-ql definitions in all three session-only dev configurations, and production unchanged. Broader execution and model results are retained separately and must be reported as observed.
-
-## 1.11.0 — the reply ranker replaces ContinueCurrent
-
-A contextual DISPATCH (`onResponse: "continue"`) now asks one question: what does the reply do with the step's question? The reply ranker (`jsfe/host` `buildReplyRank`, task `rank_reply`, 4th aiCallback argument with `llm` and `systemOne` instructions) answers `answers`, `abort` or `new_request`; nothing clear is `answers`. `answers` continues the flow, extracting declared `responseParameters` with a stage-2 request; `abort` is a RETURN: every flow ends and the reply is the new system message `cmd_request_aborted` ("The process has been cancelled at your request - how can I help you?"; es: "El proceso fue cancelado a petición suya - ¿cómo puedo ayudarle?"), outcome `user_aborted` (new: transaction failed, never a post-mortem), no recovery stamp; `new_request` ends them and routes the input through intent detection. Only a new request is routed: after `answers` a later ordinary DISPATCH in the same turn goes to the host unrouted, so an answer never restarts its own flow.
-
-Removed: the synthetic `ContinueCurrent` flow offered beside the primaries, its reserved name, and the per-turn routing cache shared between contextual and ordinary dispatch. Flow attributes and the `jsfe:contextual-responses:v1` protocol are unchanged. A host that does not know `rank_reply` answers its `llm` instructions with a text model. ReadFormResponse's question no longer sends uncertain replies to the host.
-
-## 1.11.1 — interruption uses the primary intent detection
-
-In a flow with `interruptable: true`, a reply is checked with the same intent detection as a new request (`detectFlowWithParameters`: two-stage when `engine.intentDetection = 'two-stage'`, so Jev with its LLM hedge): a detected primary interrupts on a new stack, started with the arguments stage 2 extracted. Removed: the separate `intent_analysis` call (`analyzeIntentStrength`).
-
-**EXIT is the whole answer.** Every EXIT in the authentication flows (the contact prompt, the verification code, the
-retry menus, the email prompt) now uses `isExitRequest`: the whole answer is exit, quit, abort, salir, cancel or cancelar
-(with "please" / "por favor"), or `*`. A sentence that contains one ("Cancelar el pedido" at the code prompt) is not an
-exit; at the code prompt it gets the "Let me explain" re-ask. Before, any answer containing the word (or, at the contact
-prompt, any answer of at most two words containing it) ended the authentication in contact-support.
-
-**A confident answer is never lost.** The host may add `fallback: true` to a `rank_reply` reply that is `answers` only
-because no option cleared the cut. Without it the answer is confident: when the step declares one parameter marked `verbatim: true` (new, an open
-string only; ReadFormResponse's answer is marked) and the stage-2 extraction finds nothing, or fails, the field is the
-reply as said. An unmarked field always needs a real extraction (prod
-2026-10-26: a cancellation reason ranked `answers`, extracted empty and went to the host,
-whose guru answered it). A `fallback` answer leaves extraction as the judge; ReadFormResponse then rejects the reading
-quietly and the form asks its question again, instead of handing the turn to the host.
-
-**"asesor" / "asesora" are AGENT words.**
-
-**A form gives up only for a new intent.** An answer a field's reader cannot read (three or more words, or any words at an
-amount) no longer goes straight to the host with a plain DISPATCH: the reply ranker decides (`read-form-choice` for a
-choice field, `read-form-reply` otherwise). `answers`: a choice takes the offered key the reply picks (stage-2 extraction
-of `key`, checked against the offered keys), else the question is asked again with "Sorry, I didn't catch that.",
-counted as an attempt, so `max_attempts` still bounds it; `abort` ends every flow; `new_request` goes to intent
-detection. A host fixture that answered such turns with intent detection only must now also answer `rank_reply`.
-
-**A press verb before a key picks it:** "ya oprimí el uno", "I already pressed one", "marqué el 2" (not after a negation).
-
-## 1.12.0 — a confirmation's unread answer goes to the reply ranker
-
-ConfirmForm no longer hands a long unread answer (three or more words, or any words when the form holds an amount) to the
-host with a plain DISPATCH. The new shared worker `read-confirm-reply` ranks it against the confirmation question:
-`answers` with the reply declining (stage-2 `key` = `no`) is the confirmation's NO, so the form's decline path runs;
-`answers` with nothing declined asks the confirmation again, counted as a miss (two misses still hand off, as before);
-`abort` ends every flow; `new_request` goes to intent detection. The ranker is offered NO only: a confirmation is accepted
-only by its exact YES, never by a ranked reading. Hosts that ship the shared workers in a system set must add
-`read-confirm-reply`; a host fixture that answered such turns with intent detection only must now also answer `rank_reply`.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jsfe",
-  "version": "1.26.0",
+  "version": "1.27.1",
   "description": "TypeScript workflow engine for conversational/automation apps: multi-flow orchestration, interrupt/resume, stack-based control, robust errors, and flexible tool/REST integration.",
   "license": "MIT",
   "author": "Ron Pinkas",