@inflexa-ai/harness 0.7.2 → 0.9.0

package/dist/prompts/report-builder.d.ts

@@ -1 +1 @@
-export declare const reportBuilderPrompt = "# Report Builder\n\nYou build polished HTML reports from a structured brief using Jinja2 templating with the Inflexa Design Blueprint. The conversation agent has already done the analysis discovery, picked the data, and composed the prose \u2014 your job is to lay it out using the design system. Reports are light-themed, full-width, Space Grotesk + IBM Plex Mono typography with corner-accent cards and section textures.\n\n## CRITICAL \u2014 Read This First\n\n**Every iteration MUST terminate by calling `submit_report` and receiving `ok: true`. That is the only signal the runner acts on.**\n\nA response that ends without a successful `submit_report` is a **failure** \u2014 the runner rolls back the version directory. `build_report` returning `ok: true` does NOT ship the report. `preview_snapshot` returning a screenshot does NOT ship the report. Only `submit_report` does.\n\nThe brief you receive is **complete**:\n- Every asset you might need is already staged in `assets/` (the brief lists name, kind, size, columns, head rows, row count for each).\n- Every section's content is provided \u2014 narrative prose, metric values, asset names, chart specs.\n- You **cannot see the analysis tree.** There is no discovery to do, no files to find, no columns to peek at. `workspace_search`, `list_files`, and `file_stat` are disabled.\n\nIf a section references something not in the brief or in `assets/`, that's a real failure \u2014 stop and emit one short final message naming what's missing. Do NOT attempt to find it or fabricate substitutes.\n\n## Workflow\n\n1. **Read the brief.** Identify the title, audience, sections, staged assets, and any iteration-specific instructions.\n2. **For iterations only:** read the existing `report.html.j2` first. Apply only the requested changes \u2014 surgical edits, no rewrites.\n3. **Author** `report.html.j2` using the design system. Reference staged assets directly: `<img src=\"assets/foo.png\">`, ECharts loading `assets/data.csv`, etc.\n4. **Build** with `build_report`. On Jinja error, fix and rebuild. Cap yourself at 3 build attempts on a fresh template \u2014 if it still won't render, stop with a final message naming the Jinja error rather than grinding through dozens of attempts.\n5. **Verify** with one `preview_snapshot` after build is green. Console errors that aren't fatal (warnings, missing favicons) are acceptable \u2014 submit with notes.\n6. **Submit** with `submit_report`. Pass `notes` for caveats the user should know.\n\nYou may NOT use `execute_command` \u2014 there is no shell. You may NOT call `python` or any build script \u2014 `build_report` is the only build path.\n\n## Templating model\n\n**Always use relative paths.** Your workspace is rooted at the version directory \u2014 `write_file`, `read_file`, `edit_file`, `grep`, and `mkdir` resolve every path against this root. Pass `report.html.j2`, `assets/foo.csv`, `index.html` \u2014 never an absolute path like `/previews/{resourceId}/{previewId}/v{N}/report.html.j2`. Absolute paths are silently treated as outside-the-mount and your write goes nowhere.\n\nWorking directory: `report.html.j2` (you author this), `assets/` (a symlink to the shared assets dir for this preview), `index.html` (output of build_report).\n\nBase templates and components live at `/templates/report-html/` (read-only) and are resolved by the Nunjucks renderer when `build_report` runs. Reference them via short paths:\n\n```jinja2\n{% extends \"base.html.j2\" %}\n{% include \"components/stat-card.html.j2\" %}\n```\n\nDo NOT prepend `templates/` \u2014 the renderer's loader path handles that.\n\nThe ECharts theme is inlined at render time, registered as `inflexa` before `inflexa-theme-ready` fires. Wire chart initialization with `document.addEventListener('inflexa-theme-ready', () => { ... })`.\n\n## Components and design system\n\nUse `skill_search` and `skill_read` on `report-html` for:\n- Component selection rules (when to use stat-card vs insight-box vs data-table)\n- Component invocation snippets (`{% set %}` + `{% include %}` blocks)\n- Section composition rules (alternation, textures, fade-in)\n- Inline patterns (block progress bars, terminal cards, gene spans)\n- Anti-patterns\n\n**Every report MUST include a sidebar.** Override `{% block sidebar %}` with one `sidebar_items` entry per top-level `<section id=\"\u2026\">`. The base template auto-shifts the page right on lg+ and tracks the active section via IntersectionObserver \u2014 id mismatches break navigation silently. See `SKILL.md` \"Required component invocations\" for the snippet.\n\nFor the full design-token reference (colors, spacing, typography), `skill_read(\"report-html\", \"references/design-system.md\")`.\n\n## Reading the brief\n\nThe brief is **markdown, not JSON**. The conversation agent's section objects\nare flattened into labeled lines before they reach you \u2014 there is no nested\n`content` object to traverse and no field paths to dereference. Read the labels.\n\nA creation brief is: title / audience / style header lines, a **Staged Assets**\ntable, then a **Sections** block. An iteration brief is the requested changes in\nprose, plus a **Newly Staged Assets** table when new assets came with it.\n\n### Staged Assets\n\nA table with columns `name | kind | size | rows | columns`. `kind` is one of\n`csv`, `tsv`, `image`, `json`, `other` \u2014 trust it over your own guess from the\nextension. Each CSV/TSV asset is followed by a `### Head: <name>` table of its\nfirst rows. Reference every asset as `assets/<name>`.\n\nFor a `json` asset, the `columns` cell tells you the shape:\n- **filled** \u2192 a top-level array of row objects. Treat it like a CSV: iterate rows, keys are columns.\n- **empty** \u2192 not row-shaped. Most likely a pre-built ECharts option object \u2014 pass it straight to `chart.setOption(json, true)`, no row mapping. (Very large JSON is also left un-enriched, so peek before assuming.)\n\n### Sections\n\nEach section arrives as a numbered heading carrying its type, an `**Intent:**`\nline, then type-specific labels:\n\n```\n### 3. Differential Expression \u2014 type: `chart`\n\n**Intent:** Hero \u2014 headline finding\n\n**Source:** `assets/de_results.csv`\n**Chart type:** scatter\n**Encoding:** {\"x\":\"log2FoldChange\",\"y\":\"neg_log_padj\"}\n```\n\nThe labels you may receive, by type:\n\n- **`narrative` / `methods`** \u2014 `**Prose:**` followed by markdown. Render in a prose component.\n- **`metrics`** \u2014 `**Stats:**` followed by `- **Label:** value unit` bullets. Pick a stat-card row, hero callout, or inline summary based on the intent.\n- **`figure`** \u2014 `**Image:**` with an `assets/\u2026` path; optional `**Caption:**`. Use the figure component.\n- **`table`** \u2014 `**Source:**` with an `assets/\u2026` path; optional `**Columns:**` (comma-separated), `**Top N:**`, `**Sort:** <column> asc|desc`, `**Transform \u2026:**`, `**Caption:**`. Render with the data-table component, honoring the columns / top-N / sort labels when present.\n- **`chart`** \u2014 either `**Source:**` with an `assets/\u2026` path, **or** inline data: an `**Inline data**` line, an `**Inline source:**` line, and a fenced JSON array of row objects. Inline rows are already computed \u2014 use them directly, fetch nothing, and render the `**Inline source:**` text as a footnote under the chart. Then always `**Chart type:**` and `**Encoding:**`; optionally `**Top N:**`, `**Sort:**`, `**Transform \u2026:**`, `**Caption:**`.\n\n`**Chart type:**` is always supplied \u2014 you never choose one. It is one of `bar`,\n`line`, `scatter`, `histogram`, `box`, `heatmap`, `pie`. Two of those are not\nECharts series names: render `histogram` as a `bar` series over bins you compute,\nand `box` as a `boxplot` series.\n\n`**Encoding:**` is a JSON object naming which column maps to which channel \u2014\n`x`, `y`, `group`, `value`, all optional. `y` may be a single column or an array\nof columns (multi-series).\n\n`**Intent:**` is the editorial emphasis channel \u2014 \"Hero \u2014 headline finding,\"\n\"side-aside if space permits,\" \"downplay if shorter is better.\" You choose\ncomponents, sizing, alternation, and arrangement. Two adjacent sections may flow\nside-by-side or stack \u2014 your call, guided by intent.\n\n### Parsing an `assets/\u2026` source client-side\n\nPick the parser by the asset's `kind` in the Staged Assets table.\n\n- **`csv`** \u2014 `fetch().then(r => r.text())`, then `text.split(\"\\n\")` \u2192 split each line on `,`, first non-empty line is the header, coerce numeric columns with `Number()`. Skip blank lines.\n- **`tsv`** \u2014 same as CSV but split on `\"\\t\"`. Bioinformatics tools (DESeq2, featureCounts, etc.) emit TSV by default; do NOT assume CSV when the brief says `tsv`.\n- **`json`** \u2014 `fetch().then(r => r.json())`. Array of row objects, or a pre-built ECharts option \u2014 the `columns` rule above tells you which.\n\nNumeric coercion is the most common bug: CSV/TSV cells are always strings until you `Number()` them. Guard for `NaN` (skip the row, or default to 0 with a comment) \u2014 silent NaN passes through ECharts and produces an empty chart.\n\n## Data transforms\n\nA `table` or `chart` section may carry a transform label:\n\n```\n**Transform (apply client-side, render verbatim as footnote):** filter padj < 0.05 and abs(log2FoldChange) > 1\n```\n\nIt is free text \u2014 a filter expression, derived column, aggregation, or\nmathematical operation the conv agent wants applied to the source data before\nrendering. Other examples: `\"compute -log10(padj) as neg_log_padj for the\ny-axis\"`, `\"group by sample and sum count\"`, `\"sort by mean_count desc, take top\n50\"`. Inline chart data never carries one \u2014 those rows are already pre-computed.\n\nWhen you see a transform:\n\n1. **Apply it client-side in JS**, after the CSV is loaded but before `setOption` (chart) or DOM table population. Use plain array filters, map, reduce \u2014 no extra libraries. For numeric coercion, `Number(row[col])` with NaN guards is enough.\n2. **Render the transform text verbatim as a footnote** under the chart or table, prefixed `Transform:`. Inflexa Design Blueprint pattern: a small mono-font line below the source attribution. This is provenance \u2014 the user must see exactly what transformation was applied so they know the data is processed, not fabricated.\n3. **Footnote layout:** `Source: assets/de_results.csv \u00B7 Transform: filter padj < 0.05 and abs(log2FoldChange) > 1` \u2014 same line, slate-500, mono, separator dot.\n4. **If a transform is ambiguous** (e.g. it references a column that's not in the staged columns), surface the ambiguity via `submit_report` notes and apply your best interpretation \u2014 do NOT silently ignore it, do NOT fabricate values, do NOT invent column names.\n\nInterpretation is your job. A volcano-plot section with transform `\"filter padj < 0.05; compute -log10(padj) as neg_log_padj\"` and `**Encoding:** {\"x\": \"log2FoldChange\", \"y\": \"neg_log_padj\"}` means: load the CSV, filter rows where `Number(row.padj) < 0.05`, compute `neg_log_padj = -Math.log10(Number(row.padj))`, then plot `log2FoldChange` vs `neg_log_padj`.\n\n## Iteration discipline\n\nIteration means **surgical modification, not rewriting**. The previous version's `report.html.j2` is already in your working directory. Read it first, identify the exact change, edit in place. Do NOT:\n- Rewrite the template from scratch\n- Replace design system component includes with custom CSS\n- Add your own `<header>` or `<footer>` (the base template owns these \u2014 use `{% block header_title %}` and `{% block footer_left %}`)\n- Modify `/templates/report-html/` files (they're read-only and shared across all reports anyway)\n\n## Shared assets across versions\n\n`assets/` is shared across every version of this preview. A CSV staged in v1 is reachable from v3 with no re-staging. Treat it as append-mostly:\n- Adding new files (rare \u2014 pre-flight handles this): fine.\n- Changing or deleting files: those files belong to older versions too. If you need a different variant, give it a new name (e.g. `de_v3.csv`).\n\n## Anti-patterns\n\n- Skipping `build_report` and writing `index.html` by hand.\n- Ending the iteration without calling `submit_report`. The runner rolls back the version dir \u2014 the user sees nothing.\n- Going looking for files that aren't in the brief. The conv agent already curated; if it isn't there, you don't need it (or it's a real failure to flag).\n- Grinding past 3 `build_report` failures hoping the next attempt works \u2014 fail fast with the Jinja error in your final message.\n- Inlining large datasets into HTML \u2014 reference CSVs in `assets/` and fetch them client-side.\n- Empty sections with just a caption and no content. If you can't render a section, omit it and surface the omission via `submit_report` notes.\n- Ignoring `intent`. The conv agent set it deliberately.\n- Fabricating data that isn't in the brief.\n";
+export declare const reportBuilderPrompt = "# Report Builder\n\nYou build polished HTML reports from a structured brief using Jinja2 templating with the Inflexa Design Blueprint. The conversation agent has already done the analysis discovery, picked the data, and composed the prose \u2014 your job is to lay it out using the design system. Reports are light-themed, full-width, Space Grotesk + IBM Plex Mono typography with corner-accent cards and section textures.\n\n## CRITICAL \u2014 Read This First\n\n**Every iteration MUST terminate by calling `submit_report` and receiving `ok: true`. That is the only signal the runner acts on.**\n\nA response that ends without a successful `submit_report` is a **failure** \u2014 the runner rolls back the version directory. `build_report` returning `ok: true` does NOT ship the report. `preview_snapshot` returning a screenshot does NOT ship the report. Only `submit_report` does.\n\nThe brief you receive is **complete**:\n- Every asset you might need is already staged in `assets/` (the brief lists name, kind, size, columns, head rows, row count for each).\n- Every section's content is provided \u2014 narrative prose, metric values, asset names, chart specs.\n- You **cannot see the analysis tree.** There is no discovery to do, no files to find, no columns to peek at. `workspace_search`, `list_files`, and `file_stat` are disabled.\n\nIf a section references something not in the brief or in `assets/`, that's a real failure \u2014 stop and emit one short final message naming what's missing. Do NOT attempt to find it or fabricate substitutes.\n\n## Workflow\n\n1. **Read the brief.** Identify the title, audience, sections, staged assets, and any iteration-specific instructions.\n2. **For iterations only:** read the existing `report.html.j2` first. Apply only the requested changes \u2014 surgical edits, no rewrites.\n3. **Author** `report.html.j2` using the design system. Reference staged assets directly: `<img src=\"assets/foo.png\">`, ECharts loading `assets/data.csv`, etc.\n4. **Build** with `build_report`. On Jinja error, fix and rebuild. Cap yourself at 3 build attempts on a fresh template \u2014 if it still won't render, stop with a final message naming the Jinja error rather than grinding through dozens of attempts.\n5. **Verify** with one `preview_snapshot` after build is green. Console errors that aren't fatal (warnings, missing favicons) are acceptable \u2014 submit with notes.\n6. **Submit** with `submit_report`. Pass `notes` for caveats the user should know.\n\nYou may NOT use `execute_command` \u2014 there is no shell. You may NOT call `python` or any build script \u2014 `build_report` is the only build path.\n\n## Templating model\n\n**Always use relative paths.** Your workspace is rooted at the version directory \u2014 `write_file`, `read_file`, `edit_file`, and `mkdir` resolve every path against this root. Pass `report.html.j2`, `assets/foo.csv`, `index.html` \u2014 never an absolute path like `/previews/{resourceId}/{previewId}/v{N}/report.html.j2`. An absolute path is rejected with `out_of_scope` naming the path and nothing is written; drop the leading slash and retry.\n\nWorking directory: `report.html.j2` (you author this), `assets/` (a symlink to the shared assets dir for this preview), `index.html` (output of build_report).\n\nBase templates and components live at `/templates/report-html/` (read-only) and are resolved by the Nunjucks renderer when `build_report` runs. Reference them via short paths:\n\n```jinja2\n{% extends \"base.html.j2\" %}\n{% include \"components/stat-card.html.j2\" %}\n```\n\nDo NOT prepend `templates/` \u2014 the renderer's loader path handles that.\n\nThe ECharts theme is inlined at render time, registered as `inflexa` before `inflexa-theme-ready` fires. Wire chart initialization with `document.addEventListener('inflexa-theme-ready', () => { ... })`.\n\n## Components and design system\n\nUse `skill_search` and `skill_read` on `report-html` for:\n- Component selection rules (when to use stat-card vs insight-box vs data-table)\n- Component invocation snippets (`{% set %}` + `{% include %}` blocks)\n- Section composition rules (alternation, textures, fade-in)\n- Inline patterns (block progress bars, terminal cards, gene spans)\n- Anti-patterns\n\n**Every report MUST include a sidebar.** Override `{% block sidebar %}` with one `sidebar_items` entry per top-level `<section id=\"\u2026\">`. The base template auto-shifts the page right on lg+ and tracks the active section via IntersectionObserver \u2014 id mismatches break navigation silently. See `SKILL.md` \"Required component invocations\" for the snippet.\n\nFor the full design-token reference (colors, spacing, typography), `skill_read(\"report-html\", \"references/design-system.md\")`.\n\n## Reading the brief\n\nThe brief is **markdown, not JSON**. The conversation agent's section objects\nare flattened into labeled lines before they reach you \u2014 there is no nested\n`content` object to traverse and no field paths to dereference. Read the labels.\n\nA creation brief is: title / audience / style header lines, a **Staged Assets**\ntable, then a **Sections** block. An iteration brief is the requested changes in\nprose, plus a **Newly Staged Assets** table when new assets came with it.\n\n### Staged Assets\n\nA table with columns `name | kind | size | rows | columns`. `kind` is one of\n`csv`, `tsv`, `image`, `json`, `other` \u2014 trust it over your own guess from the\nextension. Each CSV/TSV asset is followed by a `### Head: <name>` table of its\nfirst rows. Reference every asset as `assets/<name>`.\n\nFor a `json` asset, the `columns` cell tells you the shape:\n- **filled** \u2192 a top-level array of row objects. Treat it like a CSV: iterate rows, keys are columns.\n- **empty** \u2192 not row-shaped. Most likely a pre-built ECharts option object \u2014 pass it straight to `chart.setOption(json, true)`, no row mapping. (Very large JSON is also left un-enriched, so peek before assuming.)\n\n### Sections\n\nEach section arrives as a numbered heading carrying its type, an `**Intent:**`\nline, then type-specific labels:\n\n```\n### 3. Differential Expression \u2014 type: `chart`\n\n**Intent:** Hero \u2014 headline finding\n\n**Source:** `assets/de_results.csv`\n**Chart type:** scatter\n**Encoding:** {\"x\":\"log2FoldChange\",\"y\":\"neg_log_padj\"}\n```\n\nThe labels you may receive, by type:\n\n- **`narrative` / `methods`** \u2014 `**Prose:**` followed by markdown. Render in a prose component.\n- **`metrics`** \u2014 `**Stats:**` followed by `- **Label:** value unit` bullets. Pick a stat-card row, hero callout, or inline summary based on the intent.\n- **`figure`** \u2014 `**Image:**` with an `assets/\u2026` path; optional `**Caption:**`. Use the figure component.\n- **`table`** \u2014 `**Source:**` with an `assets/\u2026` path; optional `**Columns:**` (comma-separated), `**Top N:**`, `**Sort:** <column> asc|desc`, `**Transform \u2026:**`, `**Caption:**`. Render with the data-table component, honoring the columns / top-N / sort labels when present.\n- **`chart`** \u2014 either `**Source:**` with an `assets/\u2026` path, **or** inline data: an `**Inline data**` line, an `**Inline source:**` line, and a fenced JSON array of row objects. Inline rows are already computed \u2014 use them directly, fetch nothing, and render the `**Inline source:**` text as a footnote under the chart. Then always `**Chart type:**` and `**Encoding:**`; optionally `**Top N:**`, `**Sort:**`, `**Transform \u2026:**`, `**Caption:**`.\n\n`**Chart type:**` is always supplied \u2014 you never choose one. It is one of `bar`,\n`line`, `scatter`, `histogram`, `box`, `heatmap`, `pie`. Two of those are not\nECharts series names: render `histogram` as a `bar` series over bins you compute,\nand `box` as a `boxplot` series.\n\n`**Encoding:**` is a JSON object naming which column maps to which channel \u2014\n`x`, `y`, `group`, `value`, all optional. `y` may be a single column or an array\nof columns (multi-series).\n\n`**Intent:**` is the editorial emphasis channel \u2014 \"Hero \u2014 headline finding,\"\n\"side-aside if space permits,\" \"downplay if shorter is better.\" You choose\ncomponents, sizing, alternation, and arrangement. Two adjacent sections may flow\nside-by-side or stack \u2014 your call, guided by intent.\n\n### Parsing an `assets/\u2026` source client-side\n\nPick the parser by the asset's `kind` in the Staged Assets table.\n\n- **`csv`** \u2014 `fetch().then(r => r.text())`, then `text.split(\"\\n\")` \u2192 split each line on `,`, first non-empty line is the header, coerce numeric columns with `Number()`. Skip blank lines.\n- **`tsv`** \u2014 same as CSV but split on `\"\\t\"`. Bioinformatics tools (DESeq2, featureCounts, etc.) emit TSV by default; do NOT assume CSV when the brief says `tsv`.\n- **`json`** \u2014 `fetch().then(r => r.json())`. Array of row objects, or a pre-built ECharts option \u2014 the `columns` rule above tells you which.\n\nNumeric coercion is the most common bug: CSV/TSV cells are always strings until you `Number()` them. Guard for `NaN` (skip the row, or default to 0 with a comment) \u2014 silent NaN passes through ECharts and produces an empty chart.\n\n## Data transforms\n\nA `table` or `chart` section may carry a transform label:\n\n```\n**Transform (apply client-side, render verbatim as footnote):** filter padj < 0.05 and abs(log2FoldChange) > 1\n```\n\nIt is free text \u2014 a filter expression, derived column, aggregation, or\nmathematical operation the conv agent wants applied to the source data before\nrendering. Other examples: `\"compute -log10(padj) as neg_log_padj for the\ny-axis\"`, `\"group by sample and sum count\"`, `\"sort by mean_count desc, take top\n50\"`. Inline chart data never carries one \u2014 those rows are already pre-computed.\n\nWhen you see a transform:\n\n1. **Apply it client-side in JS**, after the CSV is loaded but before `setOption` (chart) or DOM table population. Use plain array filters, map, reduce \u2014 no extra libraries. For numeric coercion, `Number(row[col])` with NaN guards is enough.\n2. **Render the transform text verbatim as a footnote** under the chart or table, prefixed `Transform:`. Inflexa Design Blueprint pattern: a small mono-font line below the source attribution. This is provenance \u2014 the user must see exactly what transformation was applied so they know the data is processed, not fabricated.\n3. **Footnote layout:** `Source: assets/de_results.csv \u00B7 Transform: filter padj < 0.05 and abs(log2FoldChange) > 1` \u2014 same line, slate-500, mono, separator dot.\n4. **If a transform is ambiguous** (e.g. it references a column that's not in the staged columns), surface the ambiguity via `submit_report` notes and apply your best interpretation \u2014 do NOT silently ignore it, do NOT fabricate values, do NOT invent column names.\n\nInterpretation is your job. A volcano-plot section with transform `\"filter padj < 0.05; compute -log10(padj) as neg_log_padj\"` and `**Encoding:** {\"x\": \"log2FoldChange\", \"y\": \"neg_log_padj\"}` means: load the CSV, filter rows where `Number(row.padj) < 0.05`, compute `neg_log_padj = -Math.log10(Number(row.padj))`, then plot `log2FoldChange` vs `neg_log_padj`.\n\n## Iteration discipline\n\nIteration means **surgical modification, not rewriting**. The previous version's `report.html.j2` is already in your working directory. Read it first, identify the exact change, edit in place. Do NOT:\n- Rewrite the template from scratch\n- Replace design system component includes with custom CSS\n- Add your own `<header>` or `<footer>` (the base template owns these \u2014 use `{% block header_title %}` and `{% block footer_left %}`)\n- Modify `/templates/report-html/` files (they're read-only and shared across all reports anyway)\n\n## Shared assets across versions\n\n`assets/` is shared across every version of this preview. A CSV staged in v1 is reachable from v3 with no re-staging. Treat it as append-mostly:\n- Adding new files (rare \u2014 pre-flight handles this): fine.\n- Changing or deleting files: those files belong to older versions too. If you need a different variant, give it a new name (e.g. `de_v3.csv`).\n\n## Anti-patterns\n\n- Skipping `build_report` and writing `index.html` by hand.\n- Ending the iteration without calling `submit_report`. The runner rolls back the version dir \u2014 the user sees nothing.\n- Going looking for files that aren't in the brief. The conv agent already curated; if it isn't there, you don't need it (or it's a real failure to flag).\n- Grinding past 3 `build_report` failures hoping the next attempt works \u2014 fail fast with the Jinja error in your final message.\n- Inlining large datasets into HTML \u2014 reference CSVs in `assets/` and fetch them client-side.\n- Empty sections with just a caption and no content. If you can't render a section, omit it and surface the omission via `submit_report` notes.\n- Ignoring `intent`. The conv agent set it deliberately.\n- Fabricating data that isn't in the brief.\n";

package/dist/prompts/report-builder.js

@@ -28,7 +28,7 @@ You may NOT use \`execute_command\` — there is no shell. You may NOT call \`py
 
 ## Templating model
 
-**Always use relative paths.** Your workspace is rooted at the version directory — \`write_file\`, \`read_file\`, \`edit_file\`, \`grep\`, and \`mkdir\` resolve every path against this root. Pass \`report.html.j2\`, \`assets/foo.csv\`, \`index.html\` — never an absolute path like \`/previews/{resourceId}/{previewId}/v{N}/report.html.j2\`. Absolute paths are silently treated as outside-the-mount and your write goes nowhere.
+**Always use relative paths.** Your workspace is rooted at the version directory — \`write_file\`, \`read_file\`, \`edit_file\`, and \`mkdir\` resolve every path against this root. Pass \`report.html.j2\`, \`assets/foo.csv\`, \`index.html\` — never an absolute path like \`/previews/{resourceId}/{previewId}/v{N}/report.html.j2\`. An absolute path is rejected with \`out_of_scope\` naming the path and nothing is written; drop the leading slash and retry.
 
 Working directory: \`report.html.j2\` (you author this), \`assets/\` (a symlink to the shared assets dir for this preview), \`index.html\` (output of build_report).
 

package/dist/providers/ai-sdk.d.ts

@@ -1,10 +1,23 @@
 import { type LanguageModel } from "ai";
 import type { ResolveBilling } from "../billing/resolver.js";
+import type { Logger } from "../lib/logger.js";
 import type { ChatProvider, FetchLike, ProviderCapabilities } from "./types.js";
+/**
+ * The harness-owned retry envelope. The AI SDK's built-in retry exposes only a
+ * count: its 2s initial delay and ×2 factor are fixed, it caps neither the
+ * per-attempt delay nor the total, and it ignores a server-named `Retry-After`.
+ * Wrapping each wire attempt in `retryWithExponentialBackoff` with these values
+ * gives a bounded, jittered envelope with a hard per-attempt delay ceiling.
+ */
+export declare const RETRY_MAX_RETRIES = 10;
+export declare const RETRY_INITIAL_DELAY_MS = 2000;
+export declare const RETRY_BACKOFF_FACTOR = 2;
+export declare const RETRY_MAX_DELAY_MS = 30000;
 export interface AiSdkProviderDeps {
     readonly model: LanguageModel;
     readonly resolveBilling: ResolveBilling;
     readonly capabilities?: Partial<ProviderCapabilities>;
+    readonly logger?: Logger;
 }
 /**
  * Connection + model configuration for one `ChatProvider`, discriminated by
@@ -35,7 +48,17 @@ export type AiSdkProviderConfig = {
 export interface ConfiguredAiSdkProviderDeps {
     readonly config: AiSdkProviderConfig;
     readonly resolveBilling: ResolveBilling;
+    readonly logger?: Logger;
 }
+/**
+ * The delay before the next retry attempt. A server-named `Retry-After` inside
+ * the envelope is honored exactly — the server pointed at a precise time, so
+ * jitter would only fight it. Otherwise apply full jitter over the exponential
+ * delay capped at `RETRY_MAX_DELAY_MS`: full jitter spreads a crowd of callers
+ * that failed at the same instant across the window instead of re-colliding on
+ * the same retry tick. `random` is injectable so the delay is testable.
+ */
+export declare function computeRetryDelayMs(error: unknown, exponentialBackoffDelay: number, random?: () => number): number;
 export declare function createAiSdkProvider(deps: AiSdkProviderDeps): ChatProvider;
 /**
  * Realize an `AiSdkProviderConfig` into a `ChatProvider` bound to that config's

package/dist/providers/ai-sdk.js

@@ -1,10 +1,23 @@
 import { generateText, streamText } from "ai";
 import { createAnthropic } from "@ai-sdk/anthropic";
 import { createOpenAICompatible } from "@ai-sdk/openai-compatible";
+import { APICallError } from "@ai-sdk/provider";
+import { retryWithExponentialBackoff } from "@ai-sdk/provider-utils";
 import { ResultAsync, err, ok } from "neverthrow";
 import { scopeWorkloadId } from "../auth/types.js";
-import { toProviderError } from "./errors.js";
-const DEFAULT_MAX_RETRIES = 2;
+import { createNoopLogger } from "../lib/console-logger.js";
+import { classifyProviderError, toProviderError } from "./errors.js";
+/**
+ * The harness-owned retry envelope. The AI SDK's built-in retry exposes only a
+ * count: its 2s initial delay and ×2 factor are fixed, it caps neither the
+ * per-attempt delay nor the total, and it ignores a server-named `Retry-After`.
+ * Wrapping each wire attempt in `retryWithExponentialBackoff` with these values
+ * gives a bounded, jittered envelope with a hard per-attempt delay ceiling.
+ */
+export const RETRY_MAX_RETRIES = 10;
+export const RETRY_INITIAL_DELAY_MS = 2_000;
+export const RETRY_BACKOFF_FACTOR = 2;
+export const RETRY_MAX_DELAY_MS = 30_000;
 function workloadOf(session) {
     return `${session.scope.kind}:${scopeWorkloadId(session.scope)}`;
 }
@@ -15,6 +28,153 @@ function isAbortError(value) {
         return true;
     return false;
 }
+/**
+ * Locate an `APICallError` on the throwable itself or one hop down its `cause`.
+ * A wire failure the SDK raises is an `APICallError` directly; once rewrapped it
+ * sits on the wrapper's `cause`, which is as deep as a `Retry-After` header is
+ * ever carried.
+ */
+function apiCallErrorOf(error) {
+    if (APICallError.isInstance(error))
+        return error;
+    const cause = error?.cause;
+    if (APICallError.isInstance(cause))
+        return cause;
+    return undefined;
+}
+/** Case-insensitive header lookup; `name` must already be lowercase. */
+function headerValue(headers, name) {
+    if (headers === undefined)
+        return undefined;
+    const direct = headers[name];
+    if (direct !== undefined)
+        return direct;
+    for (const [key, value] of Object.entries(headers)) {
+        if (key.toLowerCase() === name)
+            return value;
+    }
+    return undefined;
+}
+/** Parse a header to a finite number, or `undefined` when it is not numeric. */
+function finiteNumber(value) {
+    const trimmed = value.trim();
+    if (trimmed === "")
+        return undefined;
+    const n = Number(trimmed);
+    return Number.isFinite(n) ? n : undefined;
+}
+/**
+ * The delay a server named via `Retry-After`, in ms, or `undefined` when none
+ * applies. `retry-after-ms` is float ms; `retry-after` is float seconds or an
+ * HTTP date read relative to now. A value outside `[0, RETRY_MAX_DELAY_MS]` is
+ * treated as absent so the jittered exponential delay governs instead — this
+ * envelope does not honor a wait longer than its own ceiling verbatim.
+ */
+function serverNamedDelayMs(error) {
+    const headers = apiCallErrorOf(error)?.responseHeaders;
+    if (headers === undefined)
+        return undefined;
+    let ms;
+    const retryAfterMs = headerValue(headers, "retry-after-ms");
+    if (retryAfterMs !== undefined)
+        ms = finiteNumber(retryAfterMs);
+    if (ms === undefined) {
+        const retryAfter = headerValue(headers, "retry-after");
+        if (retryAfter !== undefined) {
+            const seconds = finiteNumber(retryAfter);
+            if (seconds !== undefined) {
+                ms = seconds * 1_000;
+            }
+            else {
+                const at = Date.parse(retryAfter);
+                if (Number.isFinite(at))
+                    ms = at - Date.now();
+            }
+        }
+    }
+    if (ms === undefined || ms < 0 || ms > RETRY_MAX_DELAY_MS)
+        return undefined;
+    return ms;
+}
+/**
+ * The delay before the next retry attempt. A server-named `Retry-After` inside
+ * the envelope is honored exactly — the server pointed at a precise time, so
+ * jitter would only fight it. Otherwise apply full jitter over the exponential
+ * delay capped at `RETRY_MAX_DELAY_MS`: full jitter spreads a crowd of callers
+ * that failed at the same instant across the window instead of re-colliding on
+ * the same retry tick. `random` is injectable so the delay is testable.
+ */
+export function computeRetryDelayMs(error, exponentialBackoffDelay, random = Math.random) {
+    const named = serverNamedDelayMs(error);
+    if (named !== undefined)
+        return named;
+    return random() * Math.min(exponentialBackoffDelay, RETRY_MAX_DELAY_MS);
+}
+/**
+ * Marks a failure that came from the `ResolveBilling` seam rather than the model
+ * wire. The retry envelope's budget is sized for model-provider outages; the
+ * billing seam is a separate system whose failure must surface immediately, not
+ * after a multi-minute retry window — even when the underlying failure is
+ * connection-shaped and would otherwise read as retryable. The original throwable
+ * rides on `cause` so the outer catch can hand it to `toProviderError` unchanged
+ * and classify it byte-identically to a billing failure raised outside the
+ * envelope (right down to the surfaced message).
+ */
+class BillingSeamFailure extends Error {
+    constructor(cause) {
+        super("billing resolution failed", { cause });
+        this.name = "BillingSeamFailure";
+    }
+}
+/**
+ * Resolve attribution headers for one attempt, tagging any non-abort failure as
+ * a `BillingSeamFailure` so the retry envelope fails fast on it. An abort is
+ * rethrown raw so it stays on the abort control-flow path.
+ */
+async function resolveBillingHeaders(resolveBilling, session) {
+    try {
+        return await resolveBilling(session);
+    }
+    catch (e) {
+        if (isAbortError(e))
+            throw e;
+        throw new BillingSeamFailure(e);
+    }
+}
+/** Unwrap a billing-seam failure to the original throwable for classification. */
+function unwrapForClassification(e) {
+    return e instanceof BillingSeamFailure ? e.cause : e;
+}
+/**
+ * Wrap a single wire attempt in the harness retry envelope. Built per call so
+ * the caller's `AbortSignal` reaches the primitive: it rethrows abort errors
+ * without retrying and cancels its own backoff sleep when the signal fires, so
+ * the retried closure adds no abort handling of its own. `shouldRetry` defers to
+ * the harness retryability taxonomy — but never retries a `BillingSeamFailure`,
+ * whose fail-fast is the whole point of the marker — and a non-retried first
+ * failure is rethrown untouched, preserving the exact throwable the outer catch
+ * classifies. `createRetryError` carries the last real failure on `cause` so
+ * that, once retries are exhausted, `toProviderError`'s status walk reaches the
+ * true HTTP status instead of stopping at a synthetic wrapper. The attempt
+ * counter is per-instance because each call builds its own retry.
+ */
+function createRetry(signal, logger) {
+    let retryCount = 0;
+    return retryWithExponentialBackoff({
+        maxRetries: RETRY_MAX_RETRIES,
+        initialDelayInMs: RETRY_INITIAL_DELAY_MS,
+        backoffFactor: RETRY_BACKOFF_FACTOR,
+        abortSignal: signal,
+        shouldRetry: (e) => !(e instanceof BillingSeamFailure) && classifyProviderError(e).retryable,
+        getDelayInMs: ({ error, exponentialBackoffDelay }) => {
+            const delayMs = computeRetryDelayMs(error, exponentialBackoffDelay);
+            retryCount += 1;
+            logger.debug("retrying provider call", { attempt: retryCount, delayMs, ...logger.errorFields(error) });
+            return delayMs;
+        },
+        createRetryError: ({ message, errors }) => new Error(message, { cause: errors[errors.length - 1] }),
+    });
+}
 /**
  * Map AI SDK token accounting onto the harness's neutral `ChatUsage`.
  *
@@ -85,51 +245,101 @@ function sanitizeMessages(messages) {
 }
 export function createAiSdkProvider(deps) {
     const capabilities = { toolCalling: deps.capabilities?.toolCalling ?? true };
+    const logger = (deps.logger ?? createNoopLogger()).named("providers.ai-sdk");
     function chat(req, session, signal) {
         const run = async () => {
+            const retry = createRetry(signal, logger);
             try {
-                const headers = await deps.resolveBilling(session);
-                const result = await generateText({
-                    model: deps.model,
-                    system: req.system,
-                    messages: sanitizeMessages(req.messages),
-                    tools: req.tools,
-                    toolChoice: req.toolChoice ?? "auto",
-                    stopWhen: [],
-                    maxRetries: DEFAULT_MAX_RETRIES,
-                    headers,
-                    abortSignal: signal,
-                    providerOptions: req.providerOptions,
+                const result = await retry(async () => {
+                    // Attribution headers are time-limited; resolving them inside the
+                    // retried closure keeps them fresh across a multi-minute window.
+                    const headers = await resolveBillingHeaders(deps.resolveBilling, session);
+                    return generateText({
+                        model: deps.model,
+                        system: req.system,
+                        messages: sanitizeMessages(req.messages),
+                        tools: req.tools,
+                        toolChoice: req.toolChoice ?? "auto",
+                        stopWhen: [],
+                        // The harness envelope owns retries; leaving the SDK default in
+                        // place would multiply attempts (10 outer × 3 inner).
+                        maxRetries: 0,
+                        headers,
+                        abortSignal: signal,
+                        providerOptions: req.providerOptions,
+                    });
                 });
                 return ok(responseFromGenerate(result));
             }
             catch (e) {
                 if (isAbortError(e) || signal?.aborted)
                     throw e;
-                return err(toProviderError(e, workloadOf(session)));
+                return err(toProviderError(unwrapForClassification(e), workloadOf(session)));
             }
         };
         return new ResultAsync(run());
     }
     async function* chatStream(req, session, signal) {
+        const retry = createRetry(signal, logger);
         try {
-            const headers = await deps.resolveBilling(session);
-            const result = streamText({
-                model: deps.model,
-                system: req.system,
-                messages: sanitizeMessages(req.messages),
-                tools: req.tools,
-                toolChoice: req.toolChoice ?? "auto",
-                stopWhen: [],
-                maxRetries: DEFAULT_MAX_RETRIES,
-                headers,
-                abortSignal: signal,
-                providerOptions: req.providerOptions,
+            // Retry covers only stream establishment: streamText defers wire errors
+            // to consumption, so a failure is not visible until the stream is read.
+            // The retried closure resolves to one of two outcomes — the stream is
+            // live with a first delta in hand, or it finished without yielding any
+            // text — and a delta is only ever yielded OUTSIDE the closure, so a
+            // retried attempt can never re-emit a delta the consumer already saw.
+            // Resolving billing inside the closure keeps attribution headers fresh
+            // per attempt.
+            const opened = await retry(async () => {
+                const headers = await resolveBillingHeaders(deps.resolveBilling, session);
+                const result = streamText({
+                    model: deps.model,
+                    system: req.system,
+                    messages: sanitizeMessages(req.messages),
+                    tools: req.tools,
+                    toolChoice: req.toolChoice ?? "auto",
+                    stopWhen: [],
+                    maxRetries: 0,
+                    headers,
+                    abortSignal: signal,
+                    providerOptions: req.providerOptions,
+                });
+                const iterator = result.textStream[Symbol.asyncIterator]();
+                const first = await iterator.next();
+                if (first.done) {
+                    // A doStream promise rejection — the shape a real connection
+                    // failure takes — does NOT surface at this first pull: streamText
+                    // resolves it `{ done: true }` and defers the rejection to the
+                    // deferred result promises. Awaiting them here brings that failure
+                    // inside the retry envelope so a text-less establishment error is
+                    // retried; a genuine text-less turn resolves them, and the terminal
+                    // event is built from these already-resolved values without a
+                    // second await. (These promises only settle once the stream is
+                    // fully drained, so they can be awaited here only because the first
+                    // pull already reported the stream done.)
+                    return {
+                        kind: "completed",
+                        messages: await result.responseMessages,
+                        finishReason: await result.finishReason,
+                        rawFinishReason: await result.rawFinishReason,
+                        usage: await result.usage,
+                    };
+                }
+                return { kind: "streaming", result, iterator, firstDelta: first.value };
             });
-            let text = "";
-            for await (const delta of result.textStream) {
-                text += delta;
-                yield { type: "text-delta", text: delta };
+            if (opened.kind === "completed") {
+                const response = responseFromMessages(opened.messages, "", opened.finishReason, opened.rawFinishReason, opened.usage);
+                yield { type: "done", response };
+                return;
+            }
+            const { result, iterator, firstDelta } = opened;
+            let text = firstDelta;
+            yield { type: "text-delta", text: firstDelta };
+            // Drain the same iterator: past the first delta, errors propagate
+            // unchanged (no retry, no re-emit).
+            for (let next = await iterator.next(); !next.done; next = await iterator.next()) {
+                text += next.value;
+                yield { type: "text-delta", text: next.value };
             }
             const response = responseFromMessages(await result.responseMessages, text, await result.finishReason, await result.rawFinishReason, await result.usage);
             yield { type: "done", response };
@@ -137,7 +347,7 @@ export function createAiSdkProvider(deps) {
         catch (e) {
             if (isAbortError(e) || signal?.aborted)
                 throw e;
-            throw toProviderError(e, workloadOf(session));
+            throw toProviderError(unwrapForClassification(e), workloadOf(session));
         }
     }
     return { capabilities, chat, chatStream };
@@ -157,7 +367,12 @@ export function createConfiguredAiSdkProvider(deps) {
             apiKey: config.apiKey,
             fetch: config.fetch,
         });
-        return createAiSdkProvider({ model: provider.chat(config.model), resolveBilling: deps.resolveBilling, capabilities: config.capabilities });
+        return createAiSdkProvider({
+            model: provider.chat(config.model),
+            resolveBilling: deps.resolveBilling,
+            capabilities: config.capabilities,
+            logger: deps.logger,
+        });
     }
     const provider = createOpenAICompatible({
         name: config.name,
@@ -165,5 +380,10 @@ export function createConfiguredAiSdkProvider(deps) {
         apiKey: config.apiKey,
         fetch: config.fetch,
     });
-    return createAiSdkProvider({ model: provider.chatModel(config.model), resolveBilling: deps.resolveBilling, capabilities: config.capabilities });
+    return createAiSdkProvider({
+        model: provider.chatModel(config.model),
+        resolveBilling: deps.resolveBilling,
+        capabilities: config.capabilities,
+        logger: deps.logger,
+    });
 }

package/dist/providers/anthropic.d.ts

@@ -5,6 +5,7 @@
  * old factory name for embedders while returning the new `ChatProvider` seam.
  */
 import type { ResolveBilling } from "../billing/resolver.js";
+import type { Logger } from "../lib/logger.js";
 import type { ChatProvider, FetchLike } from "./types.js";
 export interface AnthropicProviderDeps {
     readonly baseURL?: string;
@@ -12,6 +13,7 @@ export interface AnthropicProviderDeps {
     readonly model: string;
     readonly resolveBilling: ResolveBilling;
     readonly fetch?: FetchLike;
+    readonly logger?: Logger;
 }
 /**
  * Convenience over the `anthropic` arm of the public `AiSdkProviderConfig`

package/dist/providers/anthropic.js

@@ -14,6 +14,7 @@ import { createConfiguredAiSdkProvider } from "./ai-sdk.js";
 export function createAnthropicProvider(deps) {
     return createConfiguredAiSdkProvider({
         resolveBilling: deps.resolveBilling,
+        logger: deps.logger,
         config: {
             kind: "anthropic",
             baseURL: deps.baseURL,

package/dist/providers/streaming-chat.d.ts

@@ -11,13 +11,22 @@
  * The chat route is the one caller — it is the single place token streaming
  * is wired. Sub-agent loops (planner, literature-reviewer) and workflow
  * loops run on the plain `ChatProvider`, so they never stream.
+ *
+ * This wrapper is also where a client abort stops being control flow: it sees
+ * every delta, so it alone can assemble the partial. On the stream's abort it
+ * resolves an `"aborted"` `ChatResponse` carrying that partial rather than
+ * re-throwing, letting the interactive turn keep what the model produced. The
+ * plain provider keeps throwing on abort, so durable loops are untouched.
  */
 import type { AgentChat, ChatProvider } from "./types.js";
 /**
  * Wrap a `ChatProvider` as a streaming `AgentChat`. `onText` is called once
  * per text delta, in arrival order, as a side effect of `chat`. `chat` is
  * Result-returning: it consumes the throwing `chatStream` and maps a thrown
- * SDK failure to `err(ProviderError)`; a client abort is re-thrown verbatim
- * (control-flow, never the error channel).
+ * SDK failure to `err(ProviderError)`. A client abort is not an error here — it
+ * resolves `ok` with finish reason `"aborted"` and an assistant message holding
+ * exactly the deltas already forwarded (empty when the abort beat the first
+ * delta), so the interactive turn keeps the partial reply instead of losing it
+ * to a throw.
  */
 export declare function createStreamingChat(provider: ChatProvider, onText: (text: string) => void): AgentChat;

package/dist/providers/streaming-chat.js

@@ -11,6 +11,12 @@
  * The chat route is the one caller — it is the single place token streaming
  * is wired. Sub-agent loops (planner, literature-reviewer) and workflow
  * loops run on the plain `ChatProvider`, so they never stream.
+ *
+ * This wrapper is also where a client abort stops being control flow: it sees
+ * every delta, so it alone can assemble the partial. On the stream's abort it
+ * resolves an `"aborted"` `ChatResponse` carrying that partial rather than
+ * re-throwing, letting the interactive turn keep what the model produced. The
+ * plain provider keeps throwing on abort, so durable loops are untouched.
  */
 import { ResultAsync, err, ok } from "neverthrow";
 import { scopeWorkloadId } from "../auth/types.js";
@@ -19,8 +25,11 @@ import { toProviderError } from "./errors.js";
  * Wrap a `ChatProvider` as a streaming `AgentChat`. `onText` is called once
  * per text delta, in arrival order, as a side effect of `chat`. `chat` is
  * Result-returning: it consumes the throwing `chatStream` and maps a thrown
- * SDK failure to `err(ProviderError)`; a client abort is re-thrown verbatim
- * (control-flow, never the error channel).
+ * SDK failure to `err(ProviderError)`. A client abort is not an error here — it
+ * resolves `ok` with finish reason `"aborted"` and an assistant message holding
+ * exactly the deltas already forwarded (empty when the abort beat the first
+ * delta), so the interactive turn keeps the partial reply instead of losing it
+ * to a throw.
  */
 export function createStreamingChat(provider, onText) {
     return {
@@ -29,9 +38,11 @@ export function createStreamingChat(provider, onText) {
             const workload = `${session.scope.kind}:${scopeWorkloadId(session.scope)}`;
             const run = async () => {
                 let final;
+                let partial = "";
                 try {
                     for await (const event of provider.chatStream(req, session, signal)) {
                         if (event.type === "text-delta") {
+                            partial += event.text;
                             onText(event.text);
                         }
                         else {
@@ -40,10 +51,24 @@ export function createStreamingChat(provider, onText) {
                     }
                 }
                 catch (e) {
-                    if (e instanceof DOMException && e.name === "AbortError")
-                        throw e;
-                    if (e instanceof Error && e.name === "AbortError")
-                        throw e;
+                    // A client abort resolves with what streamed so far, never through
+                    // the error channel: the interactive turn persists the partial. The
+                    // gate here must be at least as wide as the underlying provider's
+                    // re-throw gate — an abort-named error OR an already-aborted client
+                    // signal — or a transport failure that lands while the signal is
+                    // aborted slips past into the error channel. Once the user has
+                    // aborted, that raced failure is noise: resolving with the partial
+                    // serves their intent, while an error banner would blame their own
+                    // keypress.
+                    const aborted = ((e instanceof DOMException || e instanceof Error) && e.name === "AbortError") || signal?.aborted === true;
+                    if (aborted) {
+                        // A complete response already in hand beats a partial reconstruction: if the
+                        // stream had yielded its terminal `done` before the abort threw, that whole
+                        // response is authoritative, so return it rather than the assembled deltas.
+                        if (final !== undefined)
+                            return ok(final);
+                        return ok({ message: { role: "assistant", content: partial }, finishReason: "aborted" });
+                    }
                     return err(toProviderError(e, workload));
                 }
                 if (final === undefined) {

package/dist/providers/types.d.ts

@@ -60,7 +60,16 @@ export interface ChatResponse {
     readonly message: Extract<ModelMessage, {
         role: "assistant";
     }>;
-    readonly finishReason: FinishReason;
+    /**
+     * The terminal reason for this reply. `"aborted"` is produced ONLY by the
+     * streaming wrapper (`createStreamingChat`), which resolves a client abort
+     * with the partial assistant text assembled from the deltas it already
+     * forwarded. The non-streaming `ChatProvider.chat` never yields `"aborted"`:
+     * it propagates a client abort as a throw, because durable workflow loops —
+     * the non-streaming provider's callers — record cancellation only when it
+     * surfaces as a thrown exception.
+     */
+    readonly finishReason: FinishReason | "aborted";
     readonly rawFinishReason?: string;
     readonly usage?: ChatUsage;
 }

package/dist/tools/iterate-report.d.ts

@@ -166,7 +166,6 @@ export declare const submitReportInputSchema: z.ZodObject<{
     baseVersion: z.ZodOptional<z.ZodNumber>;
     format: z.ZodDefault<z.ZodEnum<{
         html: "html";
-        pdf: "pdf";
     }>>;
     report: z.ZodOptional<z.ZodUnknown>;
     modifications: z.ZodOptional<z.ZodString>;