agentfootprint 10.3.0 → 10.4.0

package/dist/answer-account/templates.js

@@ -0,0 +1,320 @@
+"use strict";
+/**
+ * The answer account's words — ONE closed, versioned table.
+ *
+ * Every string a reader of the account sees comes from here: row headings,
+ * chips, the lines, the signals, the one-liner, and the small pieces a line is
+ * built from (the skill form, the distance, "it / both / all n"). The lens owns
+ * layout only; no app overrides the words in v1.
+ *
+ * Laws (each pinned by `test/answer-account/templates.test.ts`):
+ *  - never "a" / "an" before a placeholder — a lint over this table;
+ *  - plurals are explicit pairs, `{{count:n,'value','values'}}`; zero has its
+ *    own template, chosen by the reader;
+ *  - a sentence starts with fixed words or a `:code` tool id;
+ *  - changing a template's words bumps its `version` AND
+ *    `ANSWER_ACCOUNT_TEMPLATE_SET_VERSION`: a pinned digest of the table fails
+ *    on a word change without a bump.
+ *
+ * Placeholder grammar (filled by `render.ts` · `fillParts`, non-recursively over
+ * the VARS — a var's value is never re-read as a template):
+ *   `{{name}}`                  the var's value as plain text
+ *   `{{name:code}}`             a tool or skill id, verbatim
+ *   `{{name:quote}}`            words quoted from the record
+ *   `{{name:label}}`            a declared label (its own voucher)
+ *   `{{name:skill}}`            `part.skill.labelled` / `part.skill.bare`, from
+ *                               var `name` (the id) and var `nameLabel` (optional)
+ *   `{{name:distance}}`         `distance.*`, from var `name` (n) and
+ *                               var `nameWindowed` (1 = a window strategy ran)
+ *   `{{count:name,'one','many'}}`  "n one" / "n many"
+ *   `{{allOf:name}}`            `part.allOf.*` — it / both / all n
+ *
+ * `voucher` is the template's OWN claim-maker; a sentence's voucher is the
+ * weakest of it and every truth-deciding var (`render.ts` · `sentence`).
+ * `tool` means "the tool named by the `tool` var".
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ANSWER_ACCOUNT_TEMPLATES = exports.ANSWER_ACCOUNT_TEMPLATE_SET_VERSION = void 0;
+/** Bumped whenever any template's words change (a pinned digest enforces it). */
+exports.ANSWER_ACCOUNT_TEMPLATE_SET_VERSION = 11;
+const t = (text, voucher = 'library', version = 1) => Object.freeze({ version, text, voucher });
+/** The closed table. Ids are `row.part@version` in prose; the version lives on the entry. */
+exports.ANSWER_ACCOUNT_TEMPLATES = Object.freeze({
+    // ── row headings ─────────────────────────────────────────────────────
+    'row.asked': t('You asked'),
+    'row.understood': t('It understood'),
+    'row.checked': t('It checked'),
+    'row.notChecked': t('It did not check'),
+    'row.found': t('It found'),
+    'row.howSure': t('How sure'),
+    'row.wrong': t('Anything wrong'),
+    'row.more': t("…and {{count:n,'more tool call','more tool calls'}}."),
+    'items.more': t("…and {{count:n,'more item','more items'}}."),
+    // A declaration's items whose words the record keeps out (a redaction policy) — set 11.
+    'items.keptOut': t("Kept out of this record: {{count:n,'item','items'}}."),
+    // ── chips ────────────────────────────────────────────────────────────
+    'chip.saidBy': t('said by: {{who}}'),
+    'chip.who.person': t('you'),
+    'chip.who.library': t("the library's record"),
+    'chip.who.model': t('the model'),
+    'chip.who.app': t('the app (not recorded with the run)'),
+    'chip.declared': t('declared'),
+    'chip.notDeclared': t('no coverage declared'),
+    'chip.undeclaredEmpty': t('undeclared empty'),
+    'chip.decidedDelivered': t('decided = delivered'),
+    'chip.decidedNotDelivered': t('decided ≠ delivered'),
+    'chip.notRecorded': t('not recorded'),
+    'chip.beforePause': t('before a pause — not in this record'),
+    // A line about the part before a pause, read from the committed state this record holds.
+    'chip.beforePause.held': t('before the pause — read from the state this record holds'),
+    'chip.kind.existence': t('whether it exists'),
+    'chip.kind.scope': t('outside what it covers'),
+    'chip.signals': t("{{count:n,'signal','signals'}}"),
+    'chip.noneFound': t('none found'),
+    // ── pieces a line is built from ──────────────────────────────────────
+    'part.skill.labelled': t('{{label:label}} skill ({{id:code}})'),
+    'part.skill.bare': t('{{id:code}} skill'),
+    'part.allOf.one': t('it'),
+    'part.allOf.two': t('both'),
+    'part.allOf.many': t('all {{n}}'),
+    'part.clipped': t('… (the rest is in the record)'),
+    'distance.previous': t('(the previous one)'),
+    'distance.back': t('({{n}} answers back)'),
+    'distance.atLeast': t("(at least {{count:n,'answer','answers'}} back)"),
+    'unreadable.line': t('This line could not be written from the record.'),
+    // ── You asked ────────────────────────────────────────────────────────
+    asked: t('“{{question:quote}}”', 'person'),
+    'asked.rewritten': t('Your message, as the app passed it to the model: “{{question:quote}}”', 'app'),
+    'asked.raw.notRecorded': t('Your own words before that change are not in this record.'),
+    'asked.resumed': t('This answer continued after a pause. The message, as the run held it: “{{question:quote}}”'),
+    'asked.none': t('The question is not recorded.'),
+    'asked.keptOut': t('The question is kept out of this record.'),
+    // ── It understood ────────────────────────────────────────────────────
+    'understood.rule': t("The library's routing picked the {{skill:skill}} because one of the app's rules matched."),
+    'understood.rule.witness': t("The library's routing picked the {{skill:skill}} because one of the app's rules matched your words “{{witness:quote}}”."),
+    'understood.intent': t("The library's routing picked the {{skill:skill}}."),
+    'understood.scores.allOthers': t("The app's scoring put it first: {{top}} against {{next}} for every other skill.", 'app'),
+    'understood.scores': t("The app's scoring put it first: {{top}} against {{next}} for the next one, the {{nextSkill:skill}}.", 'app'),
+    'understood.continuity': t('It stayed with the {{skill:skill}} from the previous question.'),
+    'understood.decider': t('A separate routing model ({{model:code}}) picked the {{skill:skill}}.', 'model'),
+    'understood.decider.noModel': t('A separate routing model picked the {{skill:skill}}.', 'model'),
+    'understood.menu': t("No routing rule decided; the model was offered {{count:offered,'skill','skills'}} to choose from."),
+    'understood.menu.bare': t('No routing rule decided; the model was offered skills to choose from.'),
+    'understood.menu.picked': t('The model then opened the {{skill:skill}}.', 'model'),
+    'understood.none': t('No skill was chosen; the answer ran on the general instructions.'),
+    'understood.notConfigured': t('This app does not route questions to skills.'),
+    'understood.notRecorded': t('How the question was routed is not recorded.'),
+    'understood.resumed': t('The routing happened before the pause and is not in this record.'),
+    'understood.delivered': t('The skill was given to the model before it answered.'),
+    'understood.notDelivered': t('The {{skill:skill}} was not given to the model.'),
+    'understood.notDelivered.other': t('The {{skill:skill}} was not given to the model; it was given the {{other:skill}} instead.'),
+    'understood.delivery.unknown': t('Whether the skill was given to the model cannot be told from this record.'),
+    'understood.refused': t('A check named {{by:code}} refused to open the {{skill:skill}}.'),
+    'understood.refused.unnamed': t('A check refused to open the {{skill:skill}}.'),
+    'understood.refused.more': t("…and {{count:n,'more refusal','more refusals'}} of the same skill, not listed here."),
+    'understood.rejected': t('The skill graph refused to open the {{skill:skill}}.'),
+    'understood.confidence.none': t('How sure the routing was is not recorded.'),
+    'understood.app.notRecorded': t('Whether the app itself decided a skill for this question is not recorded.', 'app'),
+    // ── It checked ───────────────────────────────────────────────────────
+    'checked.declared': t('{{tool:code}} says it checked:', 'tool'),
+    'checked.item': t('{{short:label}}', 'tool'),
+    'checked.item.full': t('{{what}}', 'tool'),
+    'checked.silent': t('{{tool:code}} declared its limits but did not say what it checked.'),
+    'checked.undeclared': t('It ran {{tool:code}}. The tool did not say what it checked.'),
+    'checked.failed': t('It ran {{tool:code}}, and the tool reported an error.'),
+    'checked.refused': t('It asked to run {{tool:code}}, and a rule named {{by:code}} refused it.'),
+    'checked.refused.unnamed': t('It asked to run {{tool:code}}, and a rule refused it.'),
+    'checked.declined': t('It asked to run {{tool:code}}; a person was asked and declined.'),
+    'checked.notDispatched': t('It asked to run {{tool:code}}, but the call was not run.'),
+    'checked.unknown': t('It started {{tool:code}}; how the call ended is not recorded.'),
+    // A call answered BEFORE a pause, read from the committed state (`facts/pausedLeg.ts`): what
+    // came back is in history, what its tool declared is in `coverageDeclared` — never its events.
+    'checked.beforePause.declared': t('Before the pause, {{tool:code}} said it checked:', 'tool'),
+    'checked.beforePause.silent': t('Before the pause, {{tool:code}} declared its limits but did not say what it checked.'),
+    'checked.beforePause.undeclared': t('Before the pause, the model read what came back from {{tool:code}}; the tool did not say what it checked.'),
+    'beforePause.more': t("…and {{count:n,'more tool call','more tool calls'}} from before the pause."),
+    'beforePause.noResults': t("No tool result from before the pause is in this record's history."),
+    'beforePause.keptOut': t("This record keeps the run's history out, so what came back before the pause cannot be told."),
+    'checked.unnamed': t('A tool call ({{id:code}}) is in this record, but no event of it names its tool.'),
+    'checked.beforePause.none': t('Anything run before the pause is not in this record.'),
+    'checked.noCalls': t('It did not run any tools for this answer.'),
+    // ── It did not check ─────────────────────────────────────────────────
+    'notChecked.declared': t('{{tool:code}} says it did not check:', 'tool'),
+    'notChecked.item': t('{{short:label}}', 'tool'),
+    'notChecked.item.full': t('{{what}}', 'tool'),
+    'notChecked.silent': t('{{tool:code}} did not say what it left unchecked.'),
+    'notChecked.undeclared': t('{{tool:code}} did not say what it left unchecked.'),
+    'cannotCover.declared': t('{{tool:code}} says it can never check:', 'tool'),
+    'cannotCover.item': t('{{short:label}}', 'tool'),
+    'cannotCover.item.full': t('{{what}}', 'tool'),
+    'tryInstead.tool': t('{{tool:code}} suggested trying {{other:code}} instead.', 'tool'),
+    'notChecked.unnamed': t('What the call {{id:code}} left unchecked is not told here: no event of it names its tool.'),
+    'notChecked.notListed': t("None of the tool calls listed here ran; {{count:n,'call that ran is','calls that ran are'}} among the ones not listed."),
+    'notChecked.noCalls': t('Nothing to report: no tool ran.'),
+    'notChecked.noneRan': t('Nothing to report: none of the tool calls ran.'),
+    'notChecked.beforePause': t('What the tools run before the pause did not check is not in this record.'),
+    // ── It found ─────────────────────────────────────────────────────────
+    'found.absent': t('{{tool:code}} looked for {{lookedFor}} and found none.', 'tool'),
+    'found.bare': t('{{tool:code}} found nothing matching.', 'tool'),
+    'found.undeclaredEmpty': t('{{tool:code}} returned an empty result and did not declare what it searched.'),
+    'found.rows': t("{{tool:code}} returned {{count:n,'item','items'}}."),
+    // A described result (`describedResult()`): the counts are the library's, read
+    // from the envelope the record keeps; the source and the time are the tool's own words.
+    'found.described.facts': t("{{tool:code}} returned {{count:n,'fact','facts'}}."),
+    'found.described.series': t("{{tool:code}} returned {{count:n,'series','series'}}."),
+    'found.described.edges': t("{{tool:code}} returned {{count:n,'relationship','relationships'}}."),
+    'found.described.provenance': t('{{tool:code}} says the data came from {{source}}, as of {{measuredAt}}.', 'tool'),
+    'found.clarify': t('{{tool:code}} handed back a question instead of data.', 'tool'),
+    'found.result': t('{{tool:code}} returned a result.'),
+    'found.failed': t('{{tool:code}} returned an error, not a result.'),
+    'found.refused': t('{{tool:code}} did not run, so it found nothing.'),
+    'found.declined': t('{{tool:code}} did not run, so it found nothing.'),
+    'found.notDispatched': t('{{tool:code}} did not run, so it found nothing.'),
+    'found.unknown': t('What {{tool:code}} returned is not recorded.'),
+    'found.withheld': t('{{tool:code}} ran, but a rule named {{by:code}} withheld its result from the model.'),
+    'found.beforePause': t('What the tools found before the pause is not in this record.'),
+    'found.beforePause.absent': t('Before the pause, {{tool:code}} looked for {{lookedFor}} and found none.', 'tool'),
+    'found.beforePause.bare': t('Before the pause, {{tool:code}} found nothing matching.', 'tool'),
+    'found.beforePause.undeclaredEmpty': t('Before the pause, {{tool:code}} returned an empty result and did not declare what it searched.'),
+    'found.beforePause.rows': t("Before the pause, {{tool:code}} returned {{count:n,'item','items'}}."),
+    'found.beforePause.clarify': t('Before the pause, {{tool:code}} handed back a question instead of data.', 'tool'),
+    'found.beforePause.result': t('Before the pause, the model read what came back from {{tool:code}}.'),
+    'found.inView': t('The model could also see the result of {{tool:code}} from an earlier answer {{distance:distance}}.'),
+    'found.inView.undeclaredEmpty': t('The model could also see the result of {{tool:code}} from an earlier answer {{distance:distance}}: an empty result that did not declare what it searched.'),
+    'found.inView.absent': t('The model could also see the result of {{tool:code}} from an earlier answer {{distance:distance}}: it found nothing and declared what it searched.'),
+    'found.inView.more': t("…and {{count:n,'more earlier result','more earlier results'}} the model could also see."),
+    'found.unnamed': t('What the call {{id:code}} returned is not told here: no event of it names its tool.'),
+    'found.noCalls': t('No tool ran for this answer.'),
+    // ── How sure ─────────────────────────────────────────────────────────
+    // The answer's standing, rendered from the ONE fold (`core/agent/assessment/assess.ts` ·
+    // `assessAnswer`) over the run's committed record — never from how sure the model sounds.
+    'howSure.standing.none': t("How sure this answer is cannot be told: the run's committed state is not in this record.", 'library', 2),
+    // No `turn_end` and no pause: the run threw, a rule stopped it before it answered, or the
+    // recording ends early — the record cannot tell those apart, and there is no answer to rate.
+    'howSure.standing.noAnswer': t('How sure cannot be told: this record does not show the run giving an answer.'),
+    'howSure.standing.keptOut': t('How sure cannot be told: this record keeps out part of the state the standing rests on.'),
+    'howSure.standing.known': t("Known — the app's answer checks passed this exact answer."),
+    'howSure.standing.consistent': t("Consistent with the run's record — {{count:n,'check','checks'}} ran and none fired. This is not a verification."),
+    'howSure.standing.notSure': t("Not sure — the record holds {{count:n,'reason','reasons'}} this answer may not stand:"),
+    'howSure.standing.ask': t('Ask — the run stopped to ask a question before it could answer:'),
+    'howSure.standing.notAssessed': t("Not assessed — this record's committed state holds no verdict the standing can rest on."),
+    'howSure.check.toolCoverage': t("Tool coverage: {{ran}} of {{count:of,'call','calls'}} declared what they covered."),
+    'howSure.check.resultShape': t("What came back: {{ran}} of {{count:of,'result','results'}} could be read."),
+    'howSure.check.namesAndNumbers': t("Names and numbers: the answer's were looked up in what the tools returned."),
+    'howSure.check.answerChecks': t("The app's answer checks: they ran on this answer."),
+    // The inputs layer (honesty layer 2) — set 3.
+    'howSure.check.argumentRules': t("Argument rules: {{ran}} of {{count:of,'ruled argument','ruled arguments'}} had a verdict on the record."),
+    // The inputs layer's declared sources (honesty layer 2, step 5) — set 7.
+    'howSure.check.argumentSources': t("Argument sources: {{ran}} of {{count:of,'value','values'}} had a source verdict on the record."),
+    // The results layer (honesty layer 3, step 7b) — set 6.
+    'howSure.check.resultPeriod': t("Result periods: {{ran}} of {{count:of,'call','calls'}} had a period verdict on the record."),
+    'howSure.reason.asked': t('A question the run asked is still waiting for its answer.'),
+    // The inputs layer's own ask (honesty layer 2, step 4) — set 4.
+    'howSure.reason.argumentAsked': t('The run asked the person for values its calls need, before any of them ran; the answer has not come yet.'),
+    'howSure.reason.argumentAssumed': t("{{count:n,'value a call ran with was','values the calls ran with were'}} assumed: set by a tool's rule or a rewrite, not given in the conversation."),
+    // Set 7: a failed declared-source check fires this reason on ANY argument, so "ruled" went.
+    'howSure.reason.argumentUnverified': t("{{count:n,'value came','values came'}} from the model, with no source on the record: not the conversation, a result or the app.", 'library', 2),
+    'howSure.reason.argumentRead': t("{{count:n,'value a call ran with was','values the calls ran with were'}} read into the conversation: the quoted words are on the record, the value itself is not in them."),
+    'howSure.reason.valueContingent': t("{{count:n,'value was','values were'}} taken from a result the model itself had set aside."),
+    'howSure.reason.coverageGap': t("{{count:n,'call declared ground it did not check or can never cover','calls declared ground they did not check or can never cover'}}."),
+    'howSure.reason.declaredAbsent': t("{{count:n,'call','calls'}} declared that nothing matched."),
+    'howSure.reason.emptyUndeclared': t("{{count:n,'call returned nothing and did not say what it searched','calls returned nothing and did not say what they searched'}}."),
+    // The results layer's period verdicts (honesty layer 3, step 7b) — set 6.
+    'howSure.reason.periodNotHeld': t("{{count:n,'call asked about a period its store does not hold','calls asked about periods their stores do not hold'}}."),
+    'howSure.reason.periodPartlyHeld': t("{{count:n,'call asked about a period its store holds only part of','calls asked about periods their stores hold only part of'}}."),
+    'howSure.reason.periodUnknown': t("{{count:n,'call could not say whether its store holds the period it asked about','calls could not say whether their stores hold the periods they asked about'}}."),
+    'howSure.reason.periodUndeclared': t("{{count:n,'call did not say what period its read covered, though its tool declares a period argument','calls did not say what period their reads covered, though their tools declare a period argument'}}."),
+    // The time layer's result checks (step T8).
+    'howSure.reason.periodDiffersFromAsked': t("{{count:n,'call read a different stretch of time than the one asked about','calls read a different stretch of time than the one asked about'}}."),
+    'howSure.reason.periodBeyondRetention': t("{{count:n,'call asked about time older than its tool declares its source keeps','calls asked about time older than their tools declare their sources keep'}}."),
+    'howSure.reason.sourcesConflict': t("{{count:n,'conflict','conflicts'}} between results the model stood on."),
+    'howSure.reason.valueUnsupported': t('Names or numbers in the answer appear in no tool result.'),
+    'howSure.reason.valueSurvivedRevision': t('Names or numbers in the answer appear in no tool result, even after one revision.'),
+    'howSure.reason.derivedFromReading': t("A time in the answer is the library's own spelling of your words — an implied year, an offset or a converted form — not something you said or a tool returned."),
+    'howSure.reason.stoppedEarly': t('The run stopped before the model finished.'),
+    // The answer layer's witness (honesty layer 4) — set 5.
+    'howSure.reason.stepsUnfinished': t("The answer came before the active skill's declared steps finished."),
+    'howSure.reason.answerCheckFailed': t("The app's answer checks failed this answer."),
+    'howSure.reason.checkUnreachable': t("The app's answer checks could not reach a verdict on this answer."),
+    'howSure.expected.direct': t('Before calling {{tool:code}}, the model said it expected this call to answer the question directly, and rated how useful it expected the result to be: {{expect}}.', 'model'),
+    'howSure.expected.directNoRating': t('Before calling {{tool:code}}, the model said it expected this call to answer the question directly.', 'model'),
+    'howSure.expected.exploratory': t('Before calling {{tool:code}}, the model said this call was exploratory.', 'model'),
+    'howSure.expected.more': t("…and {{count:n,'more call','more calls'}} the model declared an expectation for, not listed here."),
+    'howSure.outcome.nothing': t('The call found nothing.', 'tool'),
+    'howSure.outcome.empty': t('The call returned an empty result.'),
+    'howSure.evidence.lookedUp': t("The library looked up {{count:lookedUp,'value','values'}} from the answer in what the tools returned and found {{allOf:lookedUp}}."),
+    'howSure.evidence.lookedUp.none': t("Every value in the answer also appears in your message, the conversation or the app's own instructions (recalled memory included), so none needed looking up."),
+    'howSure.evidence.unsplit': t("The library checked the answer's names and numbers: none was missing from what the tools returned, your message, the conversation or the app's own instructions (recalled memory included)."),
+    'howSure.evidence.flagged': t("The library could not find {{count:n,'value','values'}} from the answer in any tool result: {{values}}."),
+    'howSure.evidence.flagged.list': t("The library could not find {{count:n,'value','values'}} from the answer in any tool result:"),
+    'howSure.evidence.flagged.atLeast': t('The library could not find at least {{n}} values from the answer in any tool result:'),
+    'howSure.evidence.value': t('{{value:code}}'),
+    'howSure.evidence.revised': t('The answer was sent back once to be corrected before this check.'),
+    'howSure.evidence.empty': t('The answer contained no names or numbers for the library to check.'),
+    'howSure.evidence.truncated': t("The library's index of tool results was full, so this check is incomplete."),
+    'howSure.evidence.off': t("The library was not set to check the answer's names and numbers."),
+    'howSure.evidence.keptOut': t("The library checked the answer's names and numbers; what it could not find is kept out of this record."),
+    'howSure.evidence.notRecorded': t("Whether the answer's names and numbers were checked is not recorded."),
+    // ── Anything wrong: signals ──────────────────────────────────────────
+    'signal.decidedNotDelivered': t('The {{skill:skill}} was decided for this question but was not given to the model.'),
+    'signal.existenceNotChecked': t('{{tool:code}} says it did not check {{short:label}}.', 'tool'),
+    'signal.existenceNotChecked.full': t('{{tool:code}} says it did not check {{what}}.', 'tool'),
+    'signal.existenceCannotCover': t('{{tool:code}} says it can never check {{short:label}}.', 'tool'),
+    'signal.existenceCannotCover.full': t('{{tool:code}} says it can never check {{what}}.', 'tool'),
+    // The same, when the record keeps the item's words out (a redaction policy) — set 11.
+    'signal.existenceNotChecked.keptOut': t('{{tool:code}} says it did not check everywhere the thing could be; this record keeps out where.', 'tool'),
+    'signal.existenceCannotCover.keptOut': t('{{tool:code}} says it can never check everywhere the thing could be; this record keeps out where.', 'tool'),
+    'signal.undeclaredEmptyUsed': t("This answer's {{tool:code}} call returned an empty result that did not declare what it searched."),
+    'signal.undeclaredEmptyUsed.beforePause': t("Before the pause, this answer's {{tool:code}} call returned an empty result that did not declare what it searched."),
+    'signal.undeclaredEmptyInView': t('An empty result that did not declare what it searched, from {{tool:code}} in an earlier answer {{distance:distance}}, was in front of the model when it answered.'),
+    // ── Anything wrong: the checks that could not run ────────────────────
+    'unreachable.decided': t('It cannot be told whether the chosen skill was given to the model: the routing is not in this record.'),
+    'unreachable.delivery': t('It cannot be told whether the chosen skill was given to the model: what the model was given is not fully in this record.'),
+    'unreachable.existence': t('It cannot be told whether {{tool:code}} checked that the thing asked about exists: its not-checked items do not say what kind they are.'),
+    'unreachable.unnamed': t('It cannot be told what the call {{id:code}} found: no event of it names its tool.'),
+    'unreachable.unnamed.existence': t('It cannot be told whether the call {{id:code}} checked that the thing asked about exists: no event of it names its tool.'),
+    'unreachable.unnamed.both': t('It cannot be told what the call {{id:code}} found, nor whether it checked that the thing asked about exists: no event of it names its tool.'),
+    'unreachable.empty': t('It cannot be told whether the result of {{tool:code}} was empty: its shape is not declared.'),
+    // The shape IS declared (the app's `rowsAt`), so "not declared" would be false: the value the
+    // model read holds no list at that key, or the rows reached it as a ticket that counts none.
+    'unreachable.empty.noList': t('It cannot be told whether the result of {{tool:code}} was empty: what the model read holds no list at the key the app declared for its rows.'),
+    'unreachable.empty.uncountedTicket': t('It cannot be told whether the result of {{tool:code}} was empty: it reached the model as a ticket to the artifact store, and the ticket does not say how many rows it holds.'),
+    // The record keeps the result out (a redaction policy's placeholder stands where it was), so
+    // nothing about it — not even whether it was empty — can be read from this record.
+    'unreachable.inView.redacted': t("It cannot be told what {{count:n,'earlier result','earlier results'}} in front of the model held: this record keeps the run's history out."),
+    'unreachable.empty.redacted': t('It cannot be told whether the result of {{tool:code}} was empty: this record keeps what it returned out.'),
+    // ── Anything wrong: the row's own lines ──────────────────────────────
+    'wrong.errors': t("{{count:n,'tool call','tool calls'}} did not run cleanly: {{failed}} failed, {{refused}} refused by a rule, {{declined}} declined by a person, {{notDispatched}} not run."),
+    'wrong.withheld': t("{{count:n,'result was','results were'}} withheld from the model by a rule after the tool ran."),
+    'wrong.noErrors': t('No tool call failed or was refused.'),
+    'wrong.none': t("The {{count:reachable,'check','checks'}} this report could run found nothing."),
+    'wrong.unreachable': t('{{unreachable}} of the {{applicable}} checks could not be run on this record.'),
+    'wrong.unreachable.all': t('None of the checks this report looks for could be run on this record.'),
+    'wrong.more': t("…and {{count:n,'more line','more lines'}} from these checks, not listed here."),
+    'wrong.notApplicable': t('None of the checks this report looks for applies to this answer.'),
+    'wrong.beforePause': t('Anything before the pause is not in this record, so these checks cover only the part after it.'),
+    'wrong.beforePause.held': t("The part before the pause is read from the state this record holds. That part's events are not in this record, so how it was routed, what was in front of the model then, and whether a call then failed or was refused by a rule cannot be told here."),
+    // The same, when the routing verdict IS read from that state (or the app routes nothing): the
+    // routing is not named as lost.
+    'wrong.beforePause.held.events': t("The part before the pause is read from the state this record holds. That part's events are not in this record, so what was in front of the model then, and whether a call then failed or was refused by a rule, cannot be told here."),
+    'scope.noOwnEvents': t("None of this record's events belong to the run asked for, so nothing about that run can be told from it."),
+    'row.notInRecord': t('Not in this record: none of its events belong to the run asked for.'),
+    'scope.keptOut': t('This record keeps out values this report reads, so nothing about the answer can be told from it.'),
+    'row.keptOut': t('Not told: this record keeps out values this report reads.'),
+    'scope.unfiltered': t('Which run these events belong to is not recorded, so this report reads every event in the record.'),
+    // ── In one line ──────────────────────────────────────────────────────
+    'summary.signal': t('{{first}}'),
+    'summary.signals': t('{{first}} {{second}}'),
+    'summary.none': t('Nothing this report looks for turned up in the record.'),
+    'summary.none.partial': t('Nothing this report looks for turned up, but {{unreachable}} of the {{applicable}} checks could not be run on this record.'),
+    'summary.none.nothingRun': t('This report could not run any of its checks on this record.'),
+    'summary.none.notApplicable': t('None of the checks this report looks for applies to this answer.'),
+    'summary.resumed': t('This answer continued after a pause; what happened before the pause is not in this record.'),
+    'summary.resumed.tail': t('What happened before the pause is not in this record.'),
+    'summary.resumed.held': t("This answer continued after a pause; this record holds the state the run kept from before it, not that part's events."),
+    // What the RECORD shows, never what the run did: a missing `turn_end` can be a pause, a crash
+    // or a truncated recording, and the record cannot tell those apart.
+    'summary.unfinished': t('This record does not show the run finishing.'),
+    'summary.notAvailable': t("This answer's record is not available, so it cannot be explained."),
+});
+//# sourceMappingURL=templates.js.map

package/dist/answer-account/templates.js.map

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

package/dist/answer-account/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../src/answer-account/types.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;GAaG"}

package/dist/answer-account/view.js

@@ -0,0 +1,242 @@
+"use strict";
+/**
+ * `recordingView` — ONE indexed pass over a recording, filtered to THIS run.
+ *
+ * Every reader of the account asks the view, never the raw `events` array, so
+ * "which event is where" has one owner (and `failureCauses`, when it ships,
+ * reuses it).
+ *
+ * Whose events: the rule `bridge/eventMeta.ts` · `eventBelongsToRun` owns (an
+ * event that names a run belongs to that run; one that names none, to runs of
+ * its session). The run is identified by the agentfootprint run id — NOT
+ * `snapshot.runId`, which is footprintjs's executor id and a different id space
+ * (filtering on it would drop every event). In order:
+ *   1. `options.runId` — the stored artifact's `meta.origin.runId`;
+ *   2. else the one run id on the recording's `agent.run_configured` events;
+ *   3. with more than one (a shared-agent recording made before runs kept their
+ *      own events): the run that owns `turn_end` — never simply the first;
+ *   4. with none of these, NOTHING is filtered and `scope` says `'unfiltered'`.
+ *
+ * Tolerance: an event that is not an object with a string `type` and an object
+ * `payload` is passed over and counted in `unread`. Indices are the RECORDING's
+ * indices, so a pointer lands on the event the reader can open.
+ *
+ * A REDACTED recording (a run under an agent's `redact`) holds a placeholder
+ * where the policy selected a value: `[REDACTED]` for a payload field (or for a
+ * whole payload, under `emitPatterns`), and `REDACTED` for a state key. Its
+ * snapshot says it was served under a policy (`redaction/marker.ts`); in such
+ * a record — and ONLY there; a tool can return the string `'REDACTED'` too —
+ * a placeholder is NO value: a field or key that holds one reads as absent,
+ * never as a result to judge or a pause to report — and it is NAMED
+ * (`ViewEvent.redacted`, `RecordingView.stateKeptOut`), so a fact that would
+ * otherwise say "not recorded" can say "kept out" (`keptOut`,
+ * `RecordingView.isStateKeptOut`). An event whose whole payload is kept out
+ * is still an event of the run: its type and meta are read, its payload is
+ * empty.
+ *
+ * THE GUARD. A reader that touches a kept-out field without asking about it
+ * would state a fact about a placeholder ("no tool ran" from a kept-out
+ * `toolCallId`). So the view watches: every kept-out field or state key a
+ * reader TOUCHES (reads, or tests with `in`) is noted, and so is every one it
+ * ASKS about; `keptOutRead()` lists the touched ones never asked about, and
+ * the account refuses to tell over them (`account.ts` · `notToldAccount`).
+ * An unredacted recording is read through no guard at all.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.recordingView = exports.isKeptOut = exports.num = exports.str = exports.isRecord = exports.keptOut = void 0;
+const eventMeta_js_1 = require("../bridge/eventMeta.js");
+const marker_js_1 = require("../redaction/marker.js");
+/**
+ * Whether the record keeps `field` of `event`'s payload out (see
+ * `ViewEvent.redacted`) — and a reader that asks has handled it, so touching
+ * the field afterwards is not a read of a placeholder (the view's guard).
+ */
+function keptOut(event, field) {
+    const redacted = event?.redacted;
+    if (event === undefined || redacted === undefined)
+        return false;
+    noteName(ASKED, event, field);
+    return redacted === 'whole' || redacted.includes(field);
+}
+exports.keptOut = keptOut;
+/** Per event (or per state): the kept-out names a reader touched, and the ones it asked about. */
+const TOUCHED = new WeakMap();
+const ASKED = new WeakMap();
+function noteName(map, owner, name) {
+    const names = map.get(owner) ?? new Set();
+    names.add(name);
+    map.set(owner, names);
+}
+/** `record` behind a guard that notes, on `owner`, every kept-out name a reader touches. */
+function guarded(owner, record, isKept) {
+    const touch = (key) => {
+        if (typeof key === 'string' && isKept(key))
+            noteName(TOUCHED, owner, key);
+    };
+    return new Proxy(record, {
+        get: (target, key, receiver) => (touch(key), Reflect.get(target, key, receiver)),
+        has: (target, key) => (touch(key), Reflect.has(target, key)),
+    });
+}
+/** The kept-out names `owner`'s readers touched and never asked about. */
+function unasked(owner) {
+    const asked = ASKED.get(owner);
+    return [...(TOUCHED.get(owner) ?? [])].filter((name) => asked?.has(name) !== true);
+}
+/** An event as readers see it: a payload that keeps something out is read through the guard. */
+function asViewEvent(event) {
+    const redacted = event.redacted;
+    if (redacted === undefined)
+        return event;
+    const isKept = redacted === 'whole' ? () => true : (name) => redacted.includes(name);
+    const view = { ...event };
+    view.payload = guarded(view, event.payload, isKept);
+    return view;
+}
+const PREFIX = 'agentfootprint.';
+const isRecord = (value) => typeof value === 'object' && value !== null && !Array.isArray(value);
+exports.isRecord = isRecord;
+const str = (value) => typeof value === 'string' ? value : undefined;
+exports.str = str;
+const num = (value) => typeof value === 'number' && Number.isFinite(value) ? value : undefined;
+exports.num = num;
+/**
+ * Whether `value` is a redaction placeholder — a value the record keeps out.
+ * Asked only of a record SERVED under a policy (`redaction/marker.ts` ·
+ * `servedUnderPolicy`): anywhere else the same string is a value a tool or a
+ * person really produced.
+ */
+exports.isKeptOut = marker_js_1.isPlaceholder;
+/** The names of `record`'s fields that hold a redaction placeholder. */
+function placeholderFields(record) {
+    return Object.keys(record).filter((key) => (0, exports.isKeptOut)(record[key]));
+}
+/** `record` without the fields that hold a redaction placeholder — the SAME
+ *  object when none does, so an unredacted recording is read as it always was. */
+function withoutPlaceholders(record) {
+    const masked = placeholderFields(record);
+    if (masked.length === 0)
+        return record;
+    return Object.fromEntries(Object.entries(record).filter(([key]) => !masked.includes(key)));
+}
+/**
+ * The run's events, narrowed. `served` — the record was served under a policy
+ * (its snapshot carries the marker) — is the only case a placeholder is read
+ * as kept out; otherwise every payload is read exactly as before.
+ */
+function narrow(events, served) {
+    const raw = [];
+    let unread = 0;
+    if (!Array.isArray(events))
+        return { raw, unread };
+    events.forEach((event, index) => {
+        if (!(0, exports.isRecord)(event) || typeof event.type !== 'string') {
+            unread += 1;
+            return;
+        }
+        const meta = (0, exports.isRecord)(event.meta) ? event.meta : {};
+        if ((0, exports.isRecord)(event.payload)) {
+            const redacted = served ? placeholderFields(event.payload) : [];
+            raw.push({
+                index,
+                type: event.type,
+                payload: redacted.length > 0 ? withoutPlaceholders(event.payload) : event.payload,
+                meta,
+                ...(redacted.length > 0 && { redacted }),
+            });
+        }
+        else if (served && (0, exports.isKeptOut)(event.payload)) {
+            // The whole payload is kept out (`emitPatterns`): still an event of the run.
+            raw.push({ index, type: event.type, payload: {}, meta, redacted: 'whole' });
+        }
+        else {
+            unread += 1;
+        }
+    });
+    return { raw, unread };
+}
+const CONFIGURED = `${PREFIX}agent.run_configured`;
+const TURN_END = `${PREFIX}agent.turn_end`;
+/** Pick the run id by the documented order; `undefined` = none is known. */
+function chooseRunId(raw, given) {
+    if (given !== undefined && given.length > 0)
+        return given;
+    const configured = [
+        ...new Set(raw
+            .filter((e) => e.type === CONFIGURED)
+            .map((e) => (0, exports.str)(e.meta.runId))
+            .filter((id) => id !== undefined)),
+    ];
+    if (configured.length === 1)
+        return configured[0];
+    if (configured.length === 0)
+        return undefined;
+    const owner = (0, exports.str)(raw.find((e) => e.type === TURN_END)?.meta.runId);
+    return owner !== undefined && configured.includes(owner) ? owner : undefined;
+}
+function recordingView(recording, options = {}) {
+    const snapshot = (0, exports.isRecord)(recording.snapshot) ? recording.snapshot : undefined;
+    // A placeholder is KEPT OUT only in a record a policy covered — the snapshot says so.
+    const served = (0, marker_js_1.servedUnderPolicy)(snapshot);
+    const { raw, unread } = narrow(recording.events, served);
+    const runId = chooseRunId(raw, options.runId);
+    const sessionId = runId === undefined
+        ? undefined
+        : (0, exports.str)(raw.find((e) => e.type === CONFIGURED && e.meta.runId === runId)?.meta.sessionId);
+    const narrowed = runId === undefined
+        ? raw
+        : raw.filter((e) => (0, eventMeta_js_1.eventBelongsToRun)({
+            ...((0, exports.str)(e.meta.runId) !== undefined && { runId: (0, exports.str)(e.meta.runId) }),
+            ...((0, exports.str)(e.meta.sessionId) !== undefined && { sessionId: (0, exports.str)(e.meta.sessionId) }),
+        }, { runId, ...(sessionId !== undefined && { sessionId }) }));
+    const own = narrowed.map(asViewEvent);
+    const byType = new Map();
+    for (const event of own) {
+        const list = byType.get(event.type) ?? [];
+        list.push(event);
+        byType.set(event.type, list);
+    }
+    const full = (type) => (type.startsWith(PREFIX) ? type : `${PREFIX}${type}`);
+    const ofType = (type) => byType.get(full(type)) ?? [];
+    const recorded = snapshot && (0, exports.isRecord)(snapshot.sharedState) ? snapshot.sharedState : undefined;
+    const stateKeptOut = recorded !== undefined && served ? placeholderFields(recorded) : [];
+    // The state's guard is noted on this object (`TOUCHED` / `ASKED`), as an event's is on the event.
+    const stateOwner = {};
+    const stripped = recorded !== undefined && stateKeptOut.length > 0 ? withoutPlaceholders(recorded) : recorded;
+    const state = stripped !== undefined && stateKeptOut.length > 0
+        ? guarded(stateOwner, stripped, (key) => stateKeptOut.includes(key))
+        : stripped;
+    const initial = snapshot && (0, exports.isRecord)(snapshot.initialState) ? snapshot.initialState : undefined;
+    const pausedWith = initial !== undefined && Array.isArray(initial.history) ? initial : undefined;
+    return {
+        events: own,
+        ...(runId !== undefined && { runId }),
+        ...(sessionId !== undefined && { sessionId }),
+        scope: runId === undefined ? 'unfiltered' : 'own-run',
+        foreign: raw.length - own.length,
+        unread,
+        servedUnderPolicy: served,
+        ...(state !== undefined && { state }),
+        stateKeptOut,
+        isStateKeptOut: (key) => {
+            noteName(ASKED, stateOwner, key);
+            return stateKeptOut.includes(key);
+        },
+        ...(recorded !== undefined && { stateAsRecorded: recorded }),
+        ...(pausedWith !== undefined && { pausedWith }),
+        ofType,
+        keptOutRead: () => [
+            ...new Set([
+                ...own.flatMap((e) => unasked(e).map((name) => `${e.type} · ${name}`)),
+                ...unasked(stateOwner).map((key) => `state · ${key}`),
+            ]),
+        ].sort(),
+        first: (type) => ofType(type)[0],
+        last: (type) => {
+            const list = ofType(type);
+            return list[list.length - 1];
+        },
+    };
+}
+exports.recordingView = recordingView;
+//# sourceMappingURL=view.js.map