@inflexa-ai/harness 0.17.0 → 0.18.0

package/dist/report-render/views/page-view.d.ts

@@ -0,0 +1,20 @@
+/**
+ * The page assembly.
+ *
+ * The skeleton inlines the style rules in the head, and it puts the two scripts at the end of the body.
+ * The theme registration runs before the chart bootstrap, thus each chart finds its theme. The
+ * navigation, the main content, and the reference frame arrive as already-escaped markup strings, thus
+ * `raw()` inserts them byte for byte.
+ */
+import type { ReferenceLedger } from "../references.js";
+/**
+ * Wrap the reference list in one fixed frame. An empty ledger gives an empty string, thus the page shows
+ * no empty reference frame.
+ */
+export declare function renderReferenceSection(ledger: ReferenceLedger): string;
+/**
+ * Assemble the page from the title, the navigation, the main content, and the reference frame. The title
+ * passes through the runtime as text, and the runtime escapes it. The reference frame is optional, thus
+ * an empty frame adds no markup.
+ */
+export declare function assemblePage(title: string, nav: string, content: string, references: string): string;

package/dist/report-render/views/page-view.js

@@ -0,0 +1,49 @@
+import { jsx as _jsx, jsxs as _jsxs } from "hono/jsx/jsx-runtime";
+/**
+ * The page assembly.
+ *
+ * The skeleton inlines the style rules in the head, and it puts the two scripts at the end of the body.
+ * The theme registration runs before the chart bootstrap, thus each chart finds its theme. The
+ * navigation, the main content, and the reference frame arrive as already-escaped markup strings, thus
+ * `raw()` inserts them byte for byte.
+ */
+import { raw } from "hono/html";
+import { CDN_HEAD, CHART_BOOTSTRAP, ECHARTS_THEME, ECHARTS_THEME_NAME, PAGE_CSS } from "../page.js";
+import { renderReferenceList } from "./references-view.js";
+import { scriptJson } from "../script-json.js";
+/**
+ * The theme object as script-safe JSON. `scriptJson` replaces every `<` with `\u003c`, thus a later edit
+ * that adds a `<` to the theme stays safe inside the script sink. The JSON parser reads `\u003c` as `<`, thus
+ * the theme value stays exact.
+ */
+const THEME_JSON = scriptJson(ECHARTS_THEME);
+/**
+ * The registration script for the ECharts theme. It runs before the chart bootstrap, thus each chart
+ * reads the registered theme by its name. The guard skips the call when the ECharts runtime did not load.
+ */
+const THEME_REGISTRATION = `(function () {
+  if (typeof echarts === "undefined") {
+    return;
+  }
+  echarts.registerTheme(${JSON.stringify(ECHARTS_THEME_NAME)}, ${THEME_JSON});
+})();`;
+/**
+ * Wrap the reference list in one fixed frame. An empty ledger gives an empty string, thus the page shows
+ * no empty reference frame.
+ */
+export function renderReferenceSection(ledger) {
+    const list = renderReferenceList(ledger);
+    if (list === "") {
+        return "";
+    }
+    return String(_jsxs("section", { class: "report-references-section mt-16 pt-8 border-t border-slate-200", children: [_jsx("h2", { class: "text-xl font-semibold tracking-tight text-slate-900 mb-4", children: "References" }), raw(list)] }));
+}
+/**
+ * Assemble the page from the title, the navigation, the main content, and the reference frame. The title
+ * passes through the runtime as text, and the runtime escapes it. The reference frame is optional, thus
+ * an empty frame adds no markup.
+ */
+export function assemblePage(title, nav, content, references) {
+    return ("<!doctype html>" +
+        String(_jsxs("html", { lang: "en", children: [_jsxs("head", { children: [_jsx("meta", { charset: "utf-8" }), _jsx("meta", { name: "viewport", content: "width=device-width, initial-scale=1" }), _jsx("title", { children: title }), raw(CDN_HEAD), _jsx("style", { children: raw(PAGE_CSS) })] }), _jsxs("body", { children: [raw(nav), _jsxs("main", { class: "report-main mx-auto max-w-4xl px-6 py-10", children: [_jsx("h1", { class: "report-title text-4xl font-bold tracking-tight text-slate-900 mb-8", children: title }), raw(content), references.length > 0 ? raw(references) : null] }), _jsx("script", { children: raw(THEME_REGISTRATION) }), _jsx("script", { children: raw(CHART_BOOTSTRAP) })] })] })));
+}

package/dist/report-render/views/prose.d.ts

@@ -0,0 +1,28 @@
+/**
+ * The prose markup: the text block, the claim block, the section wrapper, and the page navigation.
+ *
+ * The runtime escapes every interpolated string, thus hostile prose reaches the page as text. A text
+ * block and a claim block split the prose on a blank line, and each part becomes one paragraph. A claim
+ * adds one marker for each binding, and the markers number through the shared ledger.
+ */
+import type { ClaimBlock, SectionBlock, TextBlock } from "../../contracts/report-blocks.js";
+import type { ReferenceLedger } from "../references.js";
+/** Render a text block as escaped paragraphs. */
+export declare function renderText(block: TextBlock): string;
+/**
+ * Render a claim block as escaped paragraphs plus evidence markers. The markers attach to the last
+ * paragraph, thus they sit at the end of the claim text. The ledger marks each binding, thus a shared
+ * reference keeps one number across the page.
+ */
+export declare function renderClaim(block: ClaimBlock, ledger: ReferenceLedger): string;
+/**
+ * Render a section wrapper around its rendered children. The heading level is `h2` at depth 0, `h3` at
+ * depth 1, and `h4` at depth 2 or deeper. The walk renders the children first, and it passes the markup
+ * as one already-escaped string, thus `raw()` inserts it byte for byte.
+ */
+export declare function renderSection(section: SectionBlock, depth: number, childrenHtml: string): string;
+/**
+ * Render the fixed left navigation. Each anchor targets one top-level section by its block id, with a
+ * numeric badge for its position. The brand row stays, and the mobile toggle and the icon slot drop out.
+ */
+export declare function renderNav(topSections: SectionBlock[]): string;

package/dist/report-render/views/prose.js

@@ -0,0 +1,75 @@
+import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "hono/jsx/jsx-runtime";
+/**
+ * The prose markup: the text block, the claim block, the section wrapper, and the page navigation.
+ *
+ * The runtime escapes every interpolated string, thus hostile prose reaches the page as text. A text
+ * block and a claim block split the prose on a blank line, and each part becomes one paragraph. A claim
+ * adds one marker for each binding, and the markers number through the shared ledger.
+ */
+import { raw } from "hono/html";
+import { Marker } from "./references-view.js";
+/** The paragraph class of a text block and a claim block. */
+const PARAGRAPH_CLASS = "report-paragraph mb-4 leading-relaxed text-slate-600";
+/**
+ * Split prose into paragraphs on a blank line. A run of blank lines makes one split. An empty part drops
+ * out, thus a leading or a trailing blank line adds no empty paragraph.
+ */
+function splitParagraphs(prose) {
+    const parts = prose.split(/\n[ \t]*\n/);
+    const paragraphs = [];
+    for (const part of parts) {
+        const trimmed = part.trim();
+        if (trimmed.length > 0) {
+            paragraphs.push(trimmed);
+        }
+    }
+    return paragraphs;
+}
+/** Render a text block as escaped paragraphs. */
+export function renderText(block) {
+    const paragraphs = splitParagraphs(block.content.prose);
+    return String(_jsx(_Fragment, { children: paragraphs.map((paragraph) => (_jsx("p", { class: PARAGRAPH_CLASS, children: paragraph }))) }));
+}
+/**
+ * Render a claim block as escaped paragraphs plus evidence markers. The markers attach to the last
+ * paragraph, thus they sit at the end of the claim text. The ledger marks each binding, thus a shared
+ * reference keeps one number across the page.
+ */
+export function renderClaim(block, ledger) {
+    const markerNumbers = block.bindings.map((reference) => ledger.mark(reference));
+    const markers = markerNumbers.map((n) => _jsx(Marker, { n: n }));
+    const paragraphs = splitParagraphs(block.content.prose);
+    if (paragraphs.length === 0) {
+        return String(_jsx("p", { class: PARAGRAPH_CLASS, children: markers }));
+    }
+    const last = paragraphs.length - 1;
+    return String(_jsx(_Fragment, { children: paragraphs.map((paragraph, index) => (_jsxs("p", { class: PARAGRAPH_CLASS, children: [paragraph, index === last ? markers : null] }))) }));
+}
+/** The heading class of a section, by heading level. */
+function headingClass(level) {
+    switch (level) {
+        case 2:
+            return "text-3xl font-semibold tracking-tight text-slate-900 mb-4";
+        case 3:
+            return "text-2xl font-semibold tracking-tight text-slate-900 mb-3";
+        default:
+            return "text-xl font-semibold tracking-tight text-slate-900 mb-2";
+    }
+}
+/**
+ * Render a section wrapper around its rendered children. The heading level is `h2` at depth 0, `h3` at
+ * depth 1, and `h4` at depth 2 or deeper. The walk renders the children first, and it passes the markup
+ * as one already-escaped string, thus `raw()` inserts it byte for byte.
+ */
+export function renderSection(section, depth, childrenHtml) {
+    const level = Math.min(depth + 2, 4);
+    const Heading = `h${level}`;
+    return String(_jsxs("section", { id: section.id, class: "report-section mb-10", children: [_jsx(Heading, { class: headingClass(level), children: section.title }), raw(childrenHtml)] }));
+}
+/**
+ * Render the fixed left navigation. Each anchor targets one top-level section by its block id, with a
+ * numeric badge for its position. The brand row stays, and the mobile toggle and the icon slot drop out.
+ */
+export function renderNav(topSections) {
+    return String(_jsxs("aside", { id: "report-sidebar", class: "fixed top-0 left-0 z-40 h-screen w-60 flex flex-col border-r border-slate-200 bg-white/95 backdrop-blur", "aria-label": "Report navigation", children: [_jsx("div", { class: "flex items-center gap-2 px-5 py-5 border-b border-slate-200", children: _jsx("span", { class: "font-mono text-sm font-semibold tracking-wider text-primary-500", children: "inflexa" }) }), _jsx("nav", { class: "flex-1 overflow-y-auto py-3", "aria-label": "Report sections", children: topSections.map((section, index) => (_jsxs("a", { href: `#${section.id}`, "data-sidebar-link": "", class: "sidebar-link flex items-center gap-3 px-5 py-2 text-sm text-slate-500 hover:text-slate-900 hover:bg-slate-50 transition-colors", children: [_jsx("span", { class: "font-mono text-[10px] font-semibold tracking-wider text-slate-300 shrink-0 w-4 text-right", children: index + 1 }), _jsx("span", { class: "truncate", children: section.title })] }))) })] }));
+}

package/dist/report-render/views/references-view.d.ts

@@ -0,0 +1,20 @@
+/**
+ * The reference markup: the evidence marker and the ordered reference list.
+ *
+ * The runtime escapes each child and each attribute value, thus a hostile path, a hostile id, or a
+ * hostile operation reaches the page as text. The list keeps the first-appearance order of the ledger,
+ * thus the ordinal of each item matches its marker.
+ */
+import type { ReferenceLedger } from "../references.js";
+/**
+ * One evidence marker as a superscript that links to the list entry. The number comes from the ledger as
+ * an integer.
+ */
+export declare function Marker({ n }: {
+    n: number;
+}): import("hono/jsx/jsx-dev-runtime").JSX.Element;
+/**
+ * The ordered reference list for the end of the page. An empty ledger gives an empty string, thus the
+ * page shows no empty list.
+ */
+export declare function renderReferenceList(ledger: ReferenceLedger): string;

package/dist/report-render/views/references-view.js

@@ -0,0 +1,64 @@
+import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "hono/jsx/jsx-runtime";
+/**
+ * One evidence marker as a superscript that links to the list entry. The number comes from the ledger as
+ * an integer.
+ */
+export function Marker({ n }) {
+    return (_jsx("sup", { class: "report-marker font-mono text-[10px] text-primary-500", children: _jsx("a", { href: `#ref-${n}`, children: n }) }));
+}
+/** The kind label of one reference entry. */
+function RefKind({ children }) {
+    return _jsx("span", { class: "report-ref-kind font-mono text-[11px] uppercase tracking-wider text-slate-400", children: children });
+}
+/** A path in a monospace code span. */
+function PathCode({ children }) {
+    return _jsx("code", { class: "font-mono text-primary-700", children: children });
+}
+/** A plain detail such as a locator or an external id. */
+function Detail({ children }) {
+    return _jsx("span", { class: "text-slate-500", children: children });
+}
+/**
+ * Describe a locator as plain text: the column and the one row selector. The refine of the schema admits
+ * exactly one of `row` or `rowFilter`, thus the two branches cover a valid locator.
+ */
+function describeLocator(locator) {
+    if (locator.row !== undefined) {
+        return `column ${locator.column}, row ${locator.row}`;
+    }
+    const filter = locator.rowFilter;
+    if (filter !== undefined) {
+        return `column ${locator.column}, row where ${filter.column} ${filter.op} ${String(filter.value)}`;
+    }
+    return `column ${locator.column}`;
+}
+/**
+ * The inner markup of one list entry. An artifact entry names its path, and it adds the locator when the
+ * reference pins one cell. A citation entry names its identifier space and its id. A derivation entry
+ * names its operation and its two inputs, each by path and locator.
+ */
+function ReferenceEntry({ reference }) {
+    switch (reference.kind) {
+        case "artifact-value":
+            return (_jsxs(_Fragment, { children: [_jsx(RefKind, { children: "Artifact value" }), " ", _jsx(PathCode, { children: reference.path }), " ", _jsx(Detail, { children: describeLocator(reference.locator) })] }));
+        case "artifact-table":
+            return (_jsxs(_Fragment, { children: [_jsx(RefKind, { children: "Artifact table" }), " ", _jsx(PathCode, { children: reference.path })] }));
+        case "artifact-file":
+            return (_jsxs(_Fragment, { children: [_jsx(RefKind, { children: "Artifact file" }), " ", _jsx(PathCode, { children: reference.path })] }));
+        case "citation":
+            return (_jsxs(_Fragment, { children: [_jsx(RefKind, { children: "Citation" }), " ", _jsx(Detail, { children: `${reference.idKind}:${reference.id}` })] }));
+        case "derivation":
+            return (_jsxs(_Fragment, { children: [_jsx(RefKind, { children: `Derivation (${reference.op})` }), " ", reference.inputs.map((input, index) => (_jsxs(_Fragment, { children: [index > 0 ? " and " : "", _jsx(PathCode, { children: input.path }), " ", _jsx(Detail, { children: describeLocator(input.locator) })] })))] }));
+    }
+}
+/**
+ * The ordered reference list for the end of the page. An empty ledger gives an empty string, thus the
+ * page shows no empty list.
+ */
+export function renderReferenceList(ledger) {
+    const entries = ledger.entries();
+    if (entries.length === 0) {
+        return "";
+    }
+    return String(_jsx("ol", { class: "report-references list-decimal pl-6", children: entries.map((reference, index) => (_jsx("li", { id: `ref-${index + 1}`, class: "report-ref-item mb-2 text-sm text-slate-600", children: _jsx(ReferenceEntry, { reference: reference }) }))) }));
+}

package/dist/report-render/views/values.d.ts

@@ -0,0 +1,42 @@
+/**
+ * The value markup: the metric card, the data table, the figure, and the inline citation.
+ *
+ * The caller resolves each value, and it narrows the value to the shape that the block needs. The runtime
+ * escapes every interpolated string, thus a hostile label, a hostile cell, a hostile caption, or a
+ * hostile source reaches the page as text.
+ */
+import type { CitationBlock, FigureBlock, MetricBlock, TableBlock } from "../../contracts/report-blocks.js";
+import type { ReferenceLedger } from "../references.js";
+import type { RenderValue } from "../types.js";
+/** The scalar value that a metric renders from. */
+type ScalarValue = Extract<RenderValue, {
+    type: "scalar";
+}>;
+/** The table value that a table renders from. */
+type TableValue = Extract<RenderValue, {
+    type: "table";
+}>;
+/** The figure value that a figure renders from. */
+type FigureValue = Extract<RenderValue, {
+    type: "figure";
+}>;
+/** Render a metric block as a stat card with the label and the scalar value. */
+export declare function renderMetric(block: MetricBlock, value: ScalarValue): string;
+/**
+ * Render a table block. The header holds one cell for each column, and the body holds one row for each
+ * resolved row. A zero-row table renders the header alone. The title and the caption render only when the
+ * block carries one. An absent cell renders as an empty cell, thus a ragged row keeps its shape.
+ */
+export declare function renderTable(block: TableBlock, value: TableValue): string;
+/**
+ * Render a figure block. The source rides the `src` attribute, and the caption renders below the image.
+ * The caption also fills the `alt` attribute, thus the escape keeps a hostile source and a hostile caption
+ * inside their slots.
+ */
+export declare function renderFigure(block: FigureBlock, value: FigureValue): string;
+/**
+ * Render a citation block as a short line. The binding joins the ledger like a claim binding, thus one
+ * shared source keeps one number. The optional note renders after the marker.
+ */
+export declare function renderCitation(block: CitationBlock, ledger: ReferenceLedger): string;
+export {};

package/dist/report-render/views/values.js

@@ -0,0 +1,43 @@
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "hono/jsx/jsx-runtime";
+import { Marker } from "./references-view.js";
+/** Render a metric block as a stat card with the label and the scalar value. */
+export function renderMetric(block, value) {
+    return String(_jsxs("div", { class: "corner-accents border border-slate-200 bg-white p-6", children: [_jsx("div", { class: "font-mono text-3xl font-bold", style: "color: #576dea;", children: value.value }), _jsx("div", { class: "font-mono text-xs font-medium text-slate-500 mt-2 uppercase tracking-wider", children: block.label })] }));
+}
+/**
+ * The column order of a table. The value columns win when they are present. The keys of the first row
+ * give the order otherwise, in first-appearance order.
+ */
+function tableColumns(value) {
+    if (value.columns !== undefined) {
+        return value.columns;
+    }
+    const first = value.rows[0];
+    return first !== undefined ? Object.keys(first) : [];
+}
+/**
+ * Render a table block. The header holds one cell for each column, and the body holds one row for each
+ * resolved row. A zero-row table renders the header alone. The title and the caption render only when the
+ * block carries one. An absent cell renders as an empty cell, thus a ragged row keeps its shape.
+ */
+export function renderTable(block, value) {
+    const columns = tableColumns(value);
+    return String(_jsxs("div", { class: "report-table mb-8", children: [block.title !== undefined ? (_jsx("div", { class: "font-mono text-xs font-semibold uppercase tracking-widest text-primary-500 mb-3", children: block.title })) : null, _jsx("div", { class: "corner-accents border border-slate-200 bg-white overflow-hidden", children: _jsx("div", { class: "overflow-x-auto", children: _jsxs("table", { class: "w-full text-sm", children: [_jsx("thead", { children: _jsx("tr", { class: "border-b border-slate-200 bg-slate-50", children: columns.map((column) => (_jsx("th", { class: "px-4 py-3 text-left font-mono text-[11px] font-semibold text-slate-500 uppercase tracking-wider", children: column }))) }) }), _jsx("tbody", { children: value.rows.map((row) => (_jsx("tr", { class: "report-row border-b border-slate-100 last:border-b-0", children: columns.map((column) => (_jsx("td", { class: "px-4 py-2.5 text-slate-700", children: row[column] }))) }))) })] }) }) }), block.caption !== undefined ? _jsx("p", { class: "text-sm text-slate-400 mt-2", children: block.caption }) : null] }));
+}
+/**
+ * Render a figure block. The source rides the `src` attribute, and the caption renders below the image.
+ * The caption also fills the `alt` attribute, thus the escape keeps a hostile source and a hostile caption
+ * inside their slots.
+ */
+export function renderFigure(block, value) {
+    const caption = block.caption;
+    return String(_jsxs("figure", { class: "report-figure mb-8", children: [_jsx("img", { src: value.src, alt: caption !== undefined ? caption : "", class: "max-w-full h-auto border border-slate-200" }), caption !== undefined ? _jsx("figcaption", { class: "text-sm text-slate-400 mt-2", children: caption }) : null] }));
+}
+/**
+ * Render a citation block as a short line. The binding joins the ledger like a claim binding, thus one
+ * shared source keeps one number. The optional note renders after the marker.
+ */
+export function renderCitation(block, ledger) {
+    const n = ledger.mark(block.binding);
+    return String(_jsxs("p", { class: "report-citation text-sm text-slate-500", children: [_jsx(Marker, { n: n }), block.note !== undefined ? (_jsxs(_Fragment, { children: [" ", _jsx("span", { class: "text-slate-600", children: block.note })] })) : null] }));
+}

package/dist/runtime/boot.d.ts

@@ -11,9 +11,9 @@
  *      to a no-op so a library host never acquires process-wide telemetry (or a
  *      console banner) it did not ask for. An embedder that wants harness OTel
  *      passes `initOtel` / `shutdownOtel` here.
- *   2. `validateAgentSkills(skillsDir, SANDBOX_AGENT_META)` — pure fs stat, zero
- *      external deps. A `meta.skills` typo or a `skillsDir` / image drift dies in
- *      milliseconds, before any Postgres or DBOS cost is paid (agent-skill-assignment).
+ *   2. `validateAgentSkills(skillsDir, ...)` — pure fs stat, zero external deps.
+ *      A `meta.skills` typo or a `skillsDir` / image drift dies in milliseconds,
+ *      before any Postgres or DBOS cost is paid (agent-skill-assignment).
  *   3. `initCortexState(pool)` — app tables must exist before launch; recovery
  *      queries them on the first step.
  *   4. `assertConnectionBudget(...)` — needs the live pool; gates launch so a

package/dist/runtime/boot.js

@@ -11,9 +11,9 @@
  *      to a no-op so a library host never acquires process-wide telemetry (or a
  *      console banner) it did not ask for. An embedder that wants harness OTel
  *      passes `initOtel` / `shutdownOtel` here.
- *   2. `validateAgentSkills(skillsDir, SANDBOX_AGENT_META)` — pure fs stat, zero
- *      external deps. A `meta.skills` typo or a `skillsDir` / image drift dies in
- *      milliseconds, before any Postgres or DBOS cost is paid (agent-skill-assignment).
+ *   2. `validateAgentSkills(skillsDir, ...)` — pure fs stat, zero external deps.
+ *      A `meta.skills` typo or a `skillsDir` / image drift dies in milliseconds,
+ *      before any Postgres or DBOS cost is paid (agent-skill-assignment).
  *   3. `initCortexState(pool)` — app tables must exist before launch; recovery
  *      queries them on the first step.
  *   4. `assertConnectionBudget(...)` — needs the live pool; gates launch so a
@@ -38,6 +38,7 @@
  */
 import { unwrapOrThrow } from "../lib/result.js";
 import { SANDBOX_AGENT_META } from "../agents/sandbox/index.js";
+import { REPORT_BUILDER_AGENT_ID, REPORT_BUILDER_SKILLS } from "../agents/report-builder.js";
 import { validateAgentSkills } from "../agents/sandbox/validate-skills.js";
 import { initCortexState } from "../state/init.js";
 import { backfillConversationDisplayEnvelopes } from "../memory/conversation-display-backfill.js";
@@ -48,10 +49,20 @@ import { markDraining } from "./lifecycle.js";
 import { runShutdownSequence } from "./shutdown.js";
 const noop = () => { };
 const noopAsync = () => Promise.resolve();
+/**
+ * Every agent whose declared packs must resolve before the first run. The
+ * report-builder is not in the sandbox catalog — it is not plannable — but it
+ * declares a pack all the same, and a missing one there surfaces as a failed
+ * render partway through a report rather than at boot.
+ */
+const SKILL_DECLARING_AGENTS = {
+    ...SANDBOX_AGENT_META,
+    [REPORT_BUILDER_AGENT_ID]: { id: REPORT_BUILDER_AGENT_ID, skills: REPORT_BUILDER_SKILLS },
+};
 export async function bootHarness(deps) {
     const { core, pool, skillsDir, logger } = deps;
     (deps.initTelemetry ?? noop)();
-    validateAgentSkills(skillsDir, SANDBOX_AGENT_META);
+    validateAgentSkills(skillsDir, SKILL_DECLARING_AGENTS);
     await initCortexState(pool);
     await assertConnectionBudget({ pool, logger, config: deps.connectionBudget });
     const runtime = assembleCoreRuntime(core);

package/dist/runtime/dbos.d.ts

@@ -38,7 +38,8 @@ export interface DbosConfig {
      */
     readonly logLevel?: string;
 }
-interface State {
+/** DBOS lifecycle facts a host's readiness probe reports on. */
+export interface DbosState {
     launched: boolean;
     recoveryStarted: boolean;
 }
@@ -85,9 +86,8 @@ export declare function sweepEphemeralWorkflows({ pool, logger: injectedLogger,
     executorId: string;
 }): Promise<void>;
 /** Snapshot of DBOS lifecycle state — read by the readiness probe. */
-export declare function dbosState(): State;
+export declare function dbosState(): DbosState;
 /** Test hook: force-reset state without calling DBOS. Test-only. */
 export declare function __resetDbosStateForTest(): void;
 /** Test hook: mark launched without calling DBOS. Test-only. */
-export declare function __setDbosStateForTest(next: Partial<State>): void;
-export {};
+export declare function __setDbosStateForTest(next: Partial<DbosState>): void;

package/dist/state/artifacts.d.ts

@@ -57,6 +57,22 @@ export interface StepArtifactRef {
  * slice of it — and so the same call replays to the same rows.
  */
 export declare function queryStepArtifactPaths(pool: Querier, resourceId: string, runId: string, stepId: string, limit: number): Promise<StepArtifactRef[]>;
+/** One registered artifact of an analysis, as a reader of the full artifact set names it. */
+export interface AnalysisArtifactRef {
+    /** Workspace-root-relative path (`runs/{runId}/{stepId}/output/de.csv`). */
+    path: string;
+    hash: string;
+    fileType: string | null;
+}
+/**
+ * Every artifact of one analysis, ordered by path so the same call gives the same rows.
+ *
+ * The query applies no filter. An input row is a member, the same as a step output. A row that carries
+ * `unrecoverable_at` is a member too, because the artifact existed at the moment of this read. If the
+ * query drops such a row, a later refusal says that the artifact never existed, and that reason is
+ * false.
+ */
+export declare function queryAnalysisArtifacts(pool: Querier, analysisId: string): Promise<AnalysisArtifactRef[]>;
 /** Count step-output artifacts produced by a run — for the run-completed card. */
 export declare function countArtifactsForRun(pool: Querier, analysisId: string, runId: string): Promise<number>;
 export declare function updateArtifactId(pool: Querier, resourceId: string, path: string, artifactId: string, fileType?: string | null): Promise<void>;

package/dist/state/artifacts.js

@@ -148,6 +148,24 @@ export async function queryStepArtifactPaths(pool, resourceId, runId, stepId, li
     });
     return result.rows.map((r) => ({ path: r.path, fileType: r.file_type ?? null }));
 }
+/**
+ * Every artifact of one analysis, ordered by path so the same call gives the same rows.
+ *
+ * The query applies no filter. An input row is a member, the same as a step output. A row that carries
+ * `unrecoverable_at` is a member too, because the artifact existed at the moment of this read. If the
+ * query drops such a row, a later refusal says that the artifact never existed, and that reason is
+ * false.
+ */
+export async function queryAnalysisArtifacts(pool, analysisId) {
+    const result = await pool.query({
+        text: `SELECT path, hash, file_type
+          FROM cortex_artifacts
+          WHERE analysis_id = $1
+          ORDER BY path`,
+        values: [analysisId],
+    });
+    return result.rows.map((r) => ({ path: r.path, hash: r.hash, fileType: r.file_type ?? null }));
+}
 /** Count step-output artifacts produced by a run — for the run-completed card. */
 export async function countArtifactsForRun(pool, analysisId, runId) {
     const result = await pool.query({

package/dist/state/init.js

@@ -130,6 +130,37 @@ CREATE TABLE IF NOT EXISTS cortex_plans (
 CREATE INDEX IF NOT EXISTS idx_cortex_plans_analysis
   ON cortex_plans(analysis_id, created_at DESC);
 
+-- Report versions — one immutable row for each recorded report version. A row
+-- holds the block document, the pinned snapshot, and the anchor. A thread holds
+-- at most one version. The named unique constraint on thread_id enforces the
+-- rule, because the report policy binds one version to each report session. The
+-- row outlives its thread. Thus the table has no foreign key to
+-- cortex_analysis_threads, and the row carries the anchor columns (thread_id,
+-- parent_thread_id, parent_seq) directly. A purge of the analysis removes the row
+-- through the analysis_id cascade. The table is append-only, and a correction is
+-- a new version, never an update to a recorded row.
+CREATE TABLE IF NOT EXISTS cortex_report_versions (
+  version_id        TEXT PRIMARY KEY,
+  analysis_id       TEXT NOT NULL
+                      REFERENCES cortex_analysis_state(analysis_id)
+                      ON DELETE CASCADE,
+  thread_id         TEXT NOT NULL,
+  -- Nullable pair: a root conversation anchor can be absent. A version with no
+  -- parent thread carries no parent_seq either.
+  parent_thread_id  TEXT,
+  parent_seq        BIGINT,
+  parent_version_id TEXT
+                      REFERENCES cortex_report_versions(version_id)
+                      ON DELETE SET NULL,
+  document          JSONB NOT NULL,
+  snapshot          JSONB NOT NULL,
+  created_at        TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+  CONSTRAINT cortex_report_versions_one_per_thread UNIQUE (thread_id)
+);
+
+CREATE INDEX IF NOT EXISTS idx_cortex_report_versions_analysis
+  ON cortex_report_versions(analysis_id);
+
 -- Target assessments — organization-scoped, snapshot-style target dossiers.
 -- Independent of analyses, projects, runs, and chat threads. The full
 -- dossier is persisted as JSONB on the row, no separate artifacts table.

package/dist/state/purge-analysis.js

@@ -80,6 +80,7 @@ const ANALYSIS_KEYED_DELETES = [
     { op: "purgeAnalysis.asks", sql: "DELETE FROM cortex_asks WHERE analysis_id = $1" },
     { op: "purgeAnalysis.askGrants", sql: "DELETE FROM cortex_ask_grants WHERE analysis_id = $1" },
     { op: "purgeAnalysis.plans", sql: "DELETE FROM cortex_plans WHERE analysis_id = $1" },
+    { op: "purgeAnalysis.reportVersions", sql: "DELETE FROM cortex_report_versions WHERE analysis_id = $1" },
     { op: "purgeAnalysis.analysisState", sql: "DELETE FROM cortex_analysis_state WHERE analysis_id = $1" },
 ];
 /**