agentfootprint 10.3.0 → 10.4.0

package/dist/esm/answer-account/templates.d.ts

@@ -0,0 +1,282 @@
+/**
+ * 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".
+ */
+export type TemplateVoucher = 'person' | 'library' | 'tool' | 'model' | 'app';
+export interface AccountTemplate {
+    readonly version: number;
+    readonly text: string;
+    readonly voucher: TemplateVoucher;
+}
+/** Bumped whenever any template's words change (a pinned digest enforces it). */
+export declare const ANSWER_ACCOUNT_TEMPLATE_SET_VERSION = 11;
+/** The closed table. Ids are `row.part@version` in prose; the version lives on the entry. */
+export declare const ANSWER_ACCOUNT_TEMPLATES: Readonly<{
+    'row.asked': AccountTemplate;
+    'row.understood': AccountTemplate;
+    'row.checked': AccountTemplate;
+    'row.notChecked': AccountTemplate;
+    'row.found': AccountTemplate;
+    'row.howSure': AccountTemplate;
+    'row.wrong': AccountTemplate;
+    'row.more': AccountTemplate;
+    'items.more': AccountTemplate;
+    'items.keptOut': AccountTemplate;
+    'chip.saidBy': AccountTemplate;
+    'chip.who.person': AccountTemplate;
+    'chip.who.library': AccountTemplate;
+    'chip.who.model': AccountTemplate;
+    'chip.who.app': AccountTemplate;
+    'chip.declared': AccountTemplate;
+    'chip.notDeclared': AccountTemplate;
+    'chip.undeclaredEmpty': AccountTemplate;
+    'chip.decidedDelivered': AccountTemplate;
+    'chip.decidedNotDelivered': AccountTemplate;
+    'chip.notRecorded': AccountTemplate;
+    'chip.beforePause': AccountTemplate;
+    'chip.beforePause.held': AccountTemplate;
+    'chip.kind.existence': AccountTemplate;
+    'chip.kind.scope': AccountTemplate;
+    'chip.signals': AccountTemplate;
+    'chip.noneFound': AccountTemplate;
+    'part.skill.labelled': AccountTemplate;
+    'part.skill.bare': AccountTemplate;
+    'part.allOf.one': AccountTemplate;
+    'part.allOf.two': AccountTemplate;
+    'part.allOf.many': AccountTemplate;
+    'part.clipped': AccountTemplate;
+    'distance.previous': AccountTemplate;
+    'distance.back': AccountTemplate;
+    'distance.atLeast': AccountTemplate;
+    'unreadable.line': AccountTemplate;
+    asked: AccountTemplate;
+    'asked.rewritten': AccountTemplate;
+    'asked.raw.notRecorded': AccountTemplate;
+    'asked.resumed': AccountTemplate;
+    'asked.none': AccountTemplate;
+    'asked.keptOut': AccountTemplate;
+    'understood.rule': AccountTemplate;
+    'understood.rule.witness': AccountTemplate;
+    'understood.intent': AccountTemplate;
+    'understood.scores.allOthers': AccountTemplate;
+    'understood.scores': AccountTemplate;
+    'understood.continuity': AccountTemplate;
+    'understood.decider': AccountTemplate;
+    'understood.decider.noModel': AccountTemplate;
+    'understood.menu': AccountTemplate;
+    'understood.menu.bare': AccountTemplate;
+    'understood.menu.picked': AccountTemplate;
+    'understood.none': AccountTemplate;
+    'understood.notConfigured': AccountTemplate;
+    'understood.notRecorded': AccountTemplate;
+    'understood.resumed': AccountTemplate;
+    'understood.delivered': AccountTemplate;
+    'understood.notDelivered': AccountTemplate;
+    'understood.notDelivered.other': AccountTemplate;
+    'understood.delivery.unknown': AccountTemplate;
+    'understood.refused': AccountTemplate;
+    'understood.refused.unnamed': AccountTemplate;
+    'understood.refused.more': AccountTemplate;
+    'understood.rejected': AccountTemplate;
+    'understood.confidence.none': AccountTemplate;
+    'understood.app.notRecorded': AccountTemplate;
+    'checked.declared': AccountTemplate;
+    'checked.item': AccountTemplate;
+    'checked.item.full': AccountTemplate;
+    'checked.silent': AccountTemplate;
+    'checked.undeclared': AccountTemplate;
+    'checked.failed': AccountTemplate;
+    'checked.refused': AccountTemplate;
+    'checked.refused.unnamed': AccountTemplate;
+    'checked.declined': AccountTemplate;
+    'checked.notDispatched': AccountTemplate;
+    'checked.unknown': AccountTemplate;
+    'checked.beforePause.declared': AccountTemplate;
+    'checked.beforePause.silent': AccountTemplate;
+    'checked.beforePause.undeclared': AccountTemplate;
+    'beforePause.more': AccountTemplate;
+    'beforePause.noResults': AccountTemplate;
+    'beforePause.keptOut': AccountTemplate;
+    'checked.unnamed': AccountTemplate;
+    'checked.beforePause.none': AccountTemplate;
+    'checked.noCalls': AccountTemplate;
+    'notChecked.declared': AccountTemplate;
+    'notChecked.item': AccountTemplate;
+    'notChecked.item.full': AccountTemplate;
+    'notChecked.silent': AccountTemplate;
+    'notChecked.undeclared': AccountTemplate;
+    'cannotCover.declared': AccountTemplate;
+    'cannotCover.item': AccountTemplate;
+    'cannotCover.item.full': AccountTemplate;
+    'tryInstead.tool': AccountTemplate;
+    'notChecked.unnamed': AccountTemplate;
+    'notChecked.notListed': AccountTemplate;
+    'notChecked.noCalls': AccountTemplate;
+    'notChecked.noneRan': AccountTemplate;
+    'notChecked.beforePause': AccountTemplate;
+    'found.absent': AccountTemplate;
+    'found.bare': AccountTemplate;
+    'found.undeclaredEmpty': AccountTemplate;
+    'found.rows': AccountTemplate;
+    'found.described.facts': AccountTemplate;
+    'found.described.series': AccountTemplate;
+    'found.described.edges': AccountTemplate;
+    'found.described.provenance': AccountTemplate;
+    'found.clarify': AccountTemplate;
+    'found.result': AccountTemplate;
+    'found.failed': AccountTemplate;
+    'found.refused': AccountTemplate;
+    'found.declined': AccountTemplate;
+    'found.notDispatched': AccountTemplate;
+    'found.unknown': AccountTemplate;
+    'found.withheld': AccountTemplate;
+    'found.beforePause': AccountTemplate;
+    'found.beforePause.absent': AccountTemplate;
+    'found.beforePause.bare': AccountTemplate;
+    'found.beforePause.undeclaredEmpty': AccountTemplate;
+    'found.beforePause.rows': AccountTemplate;
+    'found.beforePause.clarify': AccountTemplate;
+    'found.beforePause.result': AccountTemplate;
+    'found.inView': AccountTemplate;
+    'found.inView.undeclaredEmpty': AccountTemplate;
+    'found.inView.absent': AccountTemplate;
+    'found.inView.more': AccountTemplate;
+    'found.unnamed': AccountTemplate;
+    'found.noCalls': AccountTemplate;
+    'howSure.standing.none': AccountTemplate;
+    'howSure.standing.noAnswer': AccountTemplate;
+    'howSure.standing.keptOut': AccountTemplate;
+    'howSure.standing.known': AccountTemplate;
+    'howSure.standing.consistent': AccountTemplate;
+    'howSure.standing.notSure': AccountTemplate;
+    'howSure.standing.ask': AccountTemplate;
+    'howSure.standing.notAssessed': AccountTemplate;
+    'howSure.check.toolCoverage': AccountTemplate;
+    'howSure.check.resultShape': AccountTemplate;
+    'howSure.check.namesAndNumbers': AccountTemplate;
+    'howSure.check.answerChecks': AccountTemplate;
+    'howSure.check.argumentRules': AccountTemplate;
+    'howSure.check.argumentSources': AccountTemplate;
+    'howSure.check.resultPeriod': AccountTemplate;
+    'howSure.reason.asked': AccountTemplate;
+    'howSure.reason.argumentAsked': AccountTemplate;
+    'howSure.reason.argumentAssumed': AccountTemplate;
+    'howSure.reason.argumentUnverified': AccountTemplate;
+    'howSure.reason.argumentRead': AccountTemplate;
+    'howSure.reason.valueContingent': AccountTemplate;
+    'howSure.reason.coverageGap': AccountTemplate;
+    'howSure.reason.declaredAbsent': AccountTemplate;
+    'howSure.reason.emptyUndeclared': AccountTemplate;
+    'howSure.reason.periodNotHeld': AccountTemplate;
+    'howSure.reason.periodPartlyHeld': AccountTemplate;
+    'howSure.reason.periodUnknown': AccountTemplate;
+    'howSure.reason.periodUndeclared': AccountTemplate;
+    'howSure.reason.periodDiffersFromAsked': AccountTemplate;
+    'howSure.reason.periodBeyondRetention': AccountTemplate;
+    'howSure.reason.sourcesConflict': AccountTemplate;
+    'howSure.reason.valueUnsupported': AccountTemplate;
+    'howSure.reason.valueSurvivedRevision': AccountTemplate;
+    'howSure.reason.derivedFromReading': AccountTemplate;
+    'howSure.reason.stoppedEarly': AccountTemplate;
+    'howSure.reason.stepsUnfinished': AccountTemplate;
+    'howSure.reason.answerCheckFailed': AccountTemplate;
+    'howSure.reason.checkUnreachable': AccountTemplate;
+    'howSure.expected.direct': AccountTemplate;
+    'howSure.expected.directNoRating': AccountTemplate;
+    'howSure.expected.exploratory': AccountTemplate;
+    'howSure.expected.more': AccountTemplate;
+    'howSure.outcome.nothing': AccountTemplate;
+    'howSure.outcome.empty': AccountTemplate;
+    'howSure.evidence.lookedUp': AccountTemplate;
+    'howSure.evidence.lookedUp.none': AccountTemplate;
+    'howSure.evidence.unsplit': AccountTemplate;
+    'howSure.evidence.flagged': AccountTemplate;
+    'howSure.evidence.flagged.list': AccountTemplate;
+    'howSure.evidence.flagged.atLeast': AccountTemplate;
+    'howSure.evidence.value': AccountTemplate;
+    'howSure.evidence.revised': AccountTemplate;
+    'howSure.evidence.empty': AccountTemplate;
+    'howSure.evidence.truncated': AccountTemplate;
+    'howSure.evidence.off': AccountTemplate;
+    'howSure.evidence.keptOut': AccountTemplate;
+    'howSure.evidence.notRecorded': AccountTemplate;
+    'signal.decidedNotDelivered': AccountTemplate;
+    'signal.existenceNotChecked': AccountTemplate;
+    'signal.existenceNotChecked.full': AccountTemplate;
+    'signal.existenceCannotCover': AccountTemplate;
+    'signal.existenceCannotCover.full': AccountTemplate;
+    'signal.existenceNotChecked.keptOut': AccountTemplate;
+    'signal.existenceCannotCover.keptOut': AccountTemplate;
+    'signal.undeclaredEmptyUsed': AccountTemplate;
+    'signal.undeclaredEmptyUsed.beforePause': AccountTemplate;
+    'signal.undeclaredEmptyInView': AccountTemplate;
+    'unreachable.decided': AccountTemplate;
+    'unreachable.delivery': AccountTemplate;
+    'unreachable.existence': AccountTemplate;
+    'unreachable.unnamed': AccountTemplate;
+    'unreachable.unnamed.existence': AccountTemplate;
+    'unreachable.unnamed.both': AccountTemplate;
+    'unreachable.empty': AccountTemplate;
+    'unreachable.empty.noList': AccountTemplate;
+    'unreachable.empty.uncountedTicket': AccountTemplate;
+    'unreachable.inView.redacted': AccountTemplate;
+    'unreachable.empty.redacted': AccountTemplate;
+    'wrong.errors': AccountTemplate;
+    'wrong.withheld': AccountTemplate;
+    'wrong.noErrors': AccountTemplate;
+    'wrong.none': AccountTemplate;
+    'wrong.unreachable': AccountTemplate;
+    'wrong.unreachable.all': AccountTemplate;
+    'wrong.more': AccountTemplate;
+    'wrong.notApplicable': AccountTemplate;
+    'wrong.beforePause': AccountTemplate;
+    'wrong.beforePause.held': AccountTemplate;
+    'wrong.beforePause.held.events': AccountTemplate;
+    'scope.noOwnEvents': AccountTemplate;
+    'row.notInRecord': AccountTemplate;
+    'scope.keptOut': AccountTemplate;
+    'row.keptOut': AccountTemplate;
+    'scope.unfiltered': AccountTemplate;
+    'summary.signal': AccountTemplate;
+    'summary.signals': AccountTemplate;
+    'summary.none': AccountTemplate;
+    'summary.none.partial': AccountTemplate;
+    'summary.none.nothingRun': AccountTemplate;
+    'summary.none.notApplicable': AccountTemplate;
+    'summary.resumed': AccountTemplate;
+    'summary.resumed.tail': AccountTemplate;
+    'summary.resumed.held': AccountTemplate;
+    'summary.unfinished': AccountTemplate;
+    'summary.notAvailable': AccountTemplate;
+}>;
+export type TemplateId = keyof typeof ANSWER_ACCOUNT_TEMPLATES;

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

@@ -0,0 +1,317 @@
+/**
+ * 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".
+ */
+/** Bumped whenever any template's words change (a pinned digest enforces it). */
+export const 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. */
+export const 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