@sapiom/harness 0.1.5 → 0.2.0

package/dist/core/render-local-run.d.ts

@@ -0,0 +1,82 @@
+/**
+ * renderLocalRun — the pure mapper from an offline stub run's per-step traces
+ * ({@link LocalStepTrace}[], streamed as NDJSON by `POST /api/runs/local`) to
+ * the same {@link RunView} the canvas renders for prod runs. Its twin is
+ * {@link renderRunState} (prod / local-backend); both emit the identical
+ * cost-free {@link StepView} shape, so ONE inspector renders every run source.
+ *
+ * Pure and deterministic: no LLM, no I/O, no clock. Every field is derived from
+ * the traces (plus the caller-supplied execution id and terminal outcome), so
+ * the same function can map a partial trace mid-stream and the final trace at
+ * the end — only the input grows, never this mapping. It is a Stryker target;
+ * the tests are mutation-first.
+ *
+ * Honest absence, matching renderRunState and the SDK's "null is honest absence,
+ * never a fabricated value" contract:
+ *  - **No cost** — local runs are stubbed and free by construction; a StepView
+ *    from here never carries `costUsd` (so the inspector reads "local run ·
+ *    free", never "$0.00").
+ *  - **No latency** — a {@link LocalStepTrace} carries no timing (agent-core's
+ *    in-process dispatcher records none, and agent-core is consumed as-is), so
+ *    `latencyMs` is ABSENT rather than a fabricated `0`.
+ *  - **Output** is present only when the trace captured one (a step that threw,
+ *    or a `continue` with no value, carries none) — but ABSENCE is `undefined`
+ *    on the trace, and a genuine `null`/`false`/`0`/`""` output is a real value
+ *    that passes through.
+ *  - **Input** is always carried by a trace (every attempt ran on some input,
+ *    even `undefined`); it is surfaced whenever it isn't `undefined`.
+ *  - **Logs and errors** collapse to the same `logSlice`/`error` fields prod
+ *    uses, via the shared formatter.
+ *  - **Stub signal (WB15-2)** is RUN-LEVEL. A local run is stub-served by
+ *    construction, so the run carries `stubbed: true` (prod's renderRunState
+ *    never does) and the inspector marks each executed step with a "stubbed"
+ *    chip — agent-core records no per-CALL stub attribution, so that is the
+ *    honest granularity. The terminal summary's `unusedStubs` (a supplied key
+ *    that matched nothing) and `stubWarnings` (a wrong-shape value) pass through
+ *    only when NON-empty, so a clean run surfaces no notice at all.
+ */
+import type { LocalStepTrace, LocalRunOutcome } from "@sapiom/agent-core";
+import type { RunView, UnusedStubView } from "../shared/types.js";
+/**
+ * Options carrying the run-level facts a `LocalStepTrace[]` alone can't provide.
+ * Both are optional so the mapper can render a live, still-streaming trace (no
+ * terminal summary yet) exactly as it renders the final one.
+ */
+export interface RenderLocalRunOptions {
+    /**
+     * The execution id to stamp on the {@link RunView}. A local run has no
+     * server-issued id, so the caller (the SPA's run store) synthesizes and owns
+     * one; the mapper stays pure by taking it rather than minting time/randomness.
+     * Defaults to an empty string when the caller has none yet.
+     */
+    executionId?: string;
+    /**
+     * The run's terminal outcome from the NDJSON summary line, when it has
+     * arrived. Absent while the stream is still open — the mapper then reports the
+     * run as `running` (steps may still be coming). Passing it flips the run to
+     * its settled status.
+     */
+    outcome?: LocalRunOutcome;
+    /**
+     * Supplied stub keys that matched no capability call this run — from the
+     * terminal summary line. A no-op mock (typo'd path, wrong plural/singular)
+     * otherwise fails silently; surfacing it is the whole point of WB15-2. Only a
+     * NON-empty list reaches the {@link RunView} (honest absence), so pass it as-is
+     * from the summary and the mapper decides. Absent while the stream is open.
+     */
+    unusedStubs?: UnusedStubView[];
+    /**
+     * Warnings about stub values that matched a key but carried the wrong shape —
+     * from the terminal summary line. Same honest-absence handling as
+     * {@link RenderLocalRunOptions.unusedStubs}: an empty list is dropped.
+     */
+    stubWarnings?: string[];
+}
+/**
+ * Map an offline stub run's traces (plus the caller-owned execution id and, once
+ * known, terminal outcome) to the {@link RunView} the canvas renders. Order-
+ * preserving over `traces` (execution order); total — never throws, mirroring
+ * renderRunState — because the traces are already the decoded wire shape.
+ */
+export declare function renderLocalRun(traces: LocalStepTrace[], options?: RenderLocalRunOptions): RunView;
+//# sourceMappingURL=render-local-run.d.ts.map

package/dist/core/render-local-run.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"render-local-run.d.ts","sourceRoot":"","sources":["../../src/core/render-local-run.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AACH,OAAO,KAAK,EAAE,cAAc,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAC;AAE1E,OAAO,KAAK,EACV,OAAO,EAIP,cAAc,EACf,MAAM,oBAAoB,CAAC;AAQ5B;;;;GAIG;AACH,MAAM,WAAW,qBAAqB;IACpC;;;;;OAKG;IACH,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB;;;;;OAKG;IACH,OAAO,CAAC,EAAE,eAAe,CAAC;IAC1B;;;;;;OAMG;IACH,WAAW,CAAC,EAAE,cAAc,EAAE,CAAC;IAC/B;;;;OAIG;IACH,YAAY,CAAC,EAAE,MAAM,EAAE,CAAC;CACzB;AAoED;;;;;GAKG;AACH,wBAAgB,cAAc,CAC5B,MAAM,EAAE,cAAc,EAAE,EACxB,OAAO,GAAE,qBAA0B,GAClC,OAAO,CAsBT"}

package/dist/core/render-local-run.js

@@ -0,0 +1,105 @@
+// Reuse prod's exact log-buffer formatter so a step's `logSlice` is byte-
+// identical whether it came from a prod projection or a local trace — the
+// inspector can never disagree with itself about how a log renders. Imported
+// from the dependency-free module (NOT render-run-state) so this mapper carries
+// no `@sapiom/agent-core`/`node:fs` runtime dep into the browser bundle.
+import { toLogSlice } from "./render-log-slice.js";
+/**
+ * Fold a single step-attempt's status into a {@link StepStatus}. A local trace's
+ * status vocabulary is exactly `succeeded | threw` (see agent-core's
+ * LocalStubDispatcher). `succeeded` → `passed`; `threw` → `failed` (it did not
+ * pass — mirrors renderRunState's fold of `threw`). Anything unrecognized is
+ * `pending` (defensive; the union shouldn't produce it), NEVER silently
+ * `passed`.
+ */
+function toStepStatus(raw) {
+    if (raw === "succeeded")
+        return "passed";
+    if (raw === "threw")
+        return "failed";
+    return "pending";
+}
+/**
+ * Fold the run's terminal outcome into the four states the UI draws. A local run
+ * that `paused` is not yet done (the auto-resume loop or a human must advance
+ * it), so it reads as `running`, not a terminal state. An absent outcome (stream
+ * still open) is also `running`. `completed`/`failed` map straight through;
+ * there is no local "cancelled" outcome.
+ */
+function toRunStatus(outcome) {
+    if (outcome === "completed")
+        return "completed";
+    if (outcome === "failed")
+        return "failed";
+    // "paused", "running", or absent (still streaming) — not terminal.
+    return "running";
+}
+/**
+ * Map one trace line to its {@link StepView}. Optional fields are assigned only
+ * when they carry a real value, so honest absence survives into the JSON the
+ * inspector reads (a missing field renders nothing rather than a fabricated
+ * zero/empty payload).
+ */
+function toStepView(trace) {
+    const view = {
+        // Local traces have no OTel span id; the (step, attempt) pair is the stable,
+        // collision-free key across a run's attempts of the same step.
+        id: `${trace.step}-${trace.attempt}`,
+        name: trace.step,
+        status: toStepStatus(trace.status),
+    };
+    // No costUsd, no latencyMs — a local run is free and untimed (see the file
+    // header). Their honest absence is the whole point of the local target.
+    if (trace.input !== undefined)
+        view.input = trace.input;
+    if (trace.output !== undefined)
+        view.output = trace.output;
+    if (trace.error?.message)
+        view.error = trace.error.message;
+    const logSlice = toLogSlice(trace.logs);
+    if (logSlice !== undefined)
+        view.logSlice = logSlice;
+    // Per-step capability calls from the stub client. Honest absence: only a
+    // non-empty list reaches the view (an empty list means no calls were made —
+    // but absence on the trace means the sink was never wired, so we leave it
+    // absent too). The StubCallRecord shape maps directly onto StepCall.
+    if (trace.calls && trace.calls.length > 0) {
+        view.calls = trace.calls.map((c) => ({
+            capability: c.capability,
+            stubUsed: c.stubUsed,
+            args: c.args,
+            result: c.result,
+        }));
+    }
+    return view;
+}
+/**
+ * Map an offline stub run's traces (plus the caller-owned execution id and, once
+ * known, terminal outcome) to the {@link RunView} the canvas renders. Order-
+ * preserving over `traces` (execution order); total — never throws, mirroring
+ * renderRunState — because the traces are already the decoded wire shape.
+ */
+export function renderLocalRun(traces, options = {}) {
+    const view = {
+        executionId: options.executionId ?? "",
+        status: toRunStatus(options.outcome),
+        steps: traces.map(toStepView),
+        // A local run is stub-served by construction (every ctx.sapiom.* call
+        // resolves from a stub, never the network) — so the run itself is `stubbed`,
+        // and the inspector marks each executed step with the chip. This is the
+        // honest per-run truth: agent-core records no per-CALL stub attribution, so
+        // there is nothing finer to claim. renderRunState (prod) never sets this.
+        stubbed: true,
+    };
+    // Honest absence: only a NON-empty signal reaches the view, so the read-only
+    // notice renders nothing when the run had no stub-hygiene problems. A supplied
+    // empty array is indistinguishable from "no problems" and must not surface.
+    if (options.unusedStubs && options.unusedStubs.length > 0) {
+        view.unusedStubs = options.unusedStubs;
+    }
+    if (options.stubWarnings && options.stubWarnings.length > 0) {
+        view.stubWarnings = options.stubWarnings;
+    }
+    return view;
+}
+//# sourceMappingURL=render-local-run.js.map

package/dist/core/render-local-run.js.map

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

package/dist/core/render-log-slice.d.ts

@@ -0,0 +1,30 @@
+/**
+ * render-log-slice — the shared, dependency-free formatter for a step's executor
+ * log buffer. Both run mappers use it so a step's `logSlice` is byte-identical
+ * whether it came from a prod {@link import("./render-run-state.js").renderRunState}
+ * projection or a local {@link import("./render-local-run.js").renderLocalRun}
+ * trace — the inspector can never disagree with itself about how a log renders.
+ *
+ * Kept in its OWN module (rather than in render-run-state.ts) precisely because
+ * it has NO `@sapiom/agent-core` dependency: render-run-state pulls in agent-core
+ * runtime helpers (e.g. `isExecutionTerminal`) that reach for `node:fs`, which
+ * must never enter the browser bundle. The local-run mapper is imported by the
+ * SPA, so it depends on THIS pure module instead — no Node built-ins ride along.
+ *
+ * Pure and deterministic: no I/O, no clock. Safe in both Node and the browser.
+ */
+/**
+ * Cap on the characters of a step's executor log buffer surfaced in `logSlice`.
+ * The TAIL is kept (most recent lines) because failures surface at the end of a
+ * log. This is a payload guard on the poll/stream response; the debug-macro
+ * context extractor does the final, smaller trim for prompt injection.
+ */
+export declare const LOG_SLICE_MAX = 4000;
+/** One executor log entry → a compact line. Accepts the `{ ts, level, msg }`
+ *  wire shape (or `message`), a bare string, or anything else (stringified).
+ *  A local trace's `{ level, msg }` entry is a subset of this same shape. */
+export declare function formatLogEntry(entry: unknown): string;
+/** Format the executor log buffer into a trimmed, tail-preserving slice, or
+ *  `undefined` when there are no usable logs. */
+export declare function toLogSlice(logs: unknown): string | undefined;
+//# sourceMappingURL=render-log-slice.d.ts.map

package/dist/core/render-log-slice.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"render-log-slice.d.ts","sourceRoot":"","sources":["../../src/core/render-log-slice.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH;;;;;GAKG;AACH,eAAO,MAAM,aAAa,OAAO,CAAC;AAElC;;6EAE6E;AAC7E,wBAAgB,cAAc,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,CAgBrD;AAED;iDACiD;AACjD,wBAAgB,UAAU,CAAC,IAAI,EAAE,OAAO,GAAG,MAAM,GAAG,SAAS,CAO5D"}

package/dist/core/render-log-slice.js

@@ -0,0 +1,49 @@
+/**
+ * render-log-slice — the shared, dependency-free formatter for a step's executor
+ * log buffer. Both run mappers use it so a step's `logSlice` is byte-identical
+ * whether it came from a prod {@link import("./render-run-state.js").renderRunState}
+ * projection or a local {@link import("./render-local-run.js").renderLocalRun}
+ * trace — the inspector can never disagree with itself about how a log renders.
+ *
+ * Kept in its OWN module (rather than in render-run-state.ts) precisely because
+ * it has NO `@sapiom/agent-core` dependency: render-run-state pulls in agent-core
+ * runtime helpers (e.g. `isExecutionTerminal`) that reach for `node:fs`, which
+ * must never enter the browser bundle. The local-run mapper is imported by the
+ * SPA, so it depends on THIS pure module instead — no Node built-ins ride along.
+ *
+ * Pure and deterministic: no I/O, no clock. Safe in both Node and the browser.
+ */
+/**
+ * Cap on the characters of a step's executor log buffer surfaced in `logSlice`.
+ * The TAIL is kept (most recent lines) because failures surface at the end of a
+ * log. This is a payload guard on the poll/stream response; the debug-macro
+ * context extractor does the final, smaller trim for prompt injection.
+ */
+export const LOG_SLICE_MAX = 4000;
+/** One executor log entry → a compact line. Accepts the `{ ts, level, msg }`
+ *  wire shape (or `message`), a bare string, or anything else (stringified).
+ *  A local trace's `{ level, msg }` entry is a subset of this same shape. */
+export function formatLogEntry(entry) {
+    if (typeof entry === "string")
+        return entry;
+    if (entry !== null && typeof entry === "object") {
+        const e = entry;
+        const parts = [e.ts, e.level, e.msg ?? e.message].filter((p) => typeof p === "string" || typeof p === "number");
+        if (parts.length > 0)
+            return parts.map(String).join(" ");
+    }
+    return String(entry);
+}
+/** Format the executor log buffer into a trimmed, tail-preserving slice, or
+ *  `undefined` when there are no usable logs. */
+export function toLogSlice(logs) {
+    if (!Array.isArray(logs) || logs.length === 0)
+        return undefined;
+    const text = logs.map(formatLogEntry).join("\n").trim();
+    if (text === "")
+        return undefined;
+    return text.length > LOG_SLICE_MAX
+        ? text.slice(text.length - LOG_SLICE_MAX)
+        : text;
+}
+//# sourceMappingURL=render-log-slice.js.map

package/dist/core/render-log-slice.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"render-log-slice.js","sourceRoot":"","sources":["../../src/core/render-log-slice.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH;;;;;GAKG;AACH,MAAM,CAAC,MAAM,aAAa,GAAG,IAAI,CAAC;AAElC;;6EAE6E;AAC7E,MAAM,UAAU,cAAc,CAAC,KAAc;IAC3C,IAAI,OAAO,KAAK,KAAK,QAAQ;QAAE,OAAO,KAAK,CAAC;IAC5C,IAAI,KAAK,KAAK,IAAI,IAAI,OAAO,KAAK,KAAK,QAAQ,EAAE,CAAC;QAChD,MAAM,CAAC,GAAG,KAKT,CAAC;QACF,MAAM,KAAK,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,KAAK,EAAE,CAAC,CAAC,GAAG,IAAI,CAAC,CAAC,OAAO,CAAC,CAAC,MAAM,CACtD,CAAC,CAAC,EAAwB,EAAE,CAC1B,OAAO,CAAC,KAAK,QAAQ,IAAI,OAAO,CAAC,KAAK,QAAQ,CACjD,CAAC;QACF,IAAI,KAAK,CAAC,MAAM,GAAG,CAAC;YAAE,OAAO,KAAK,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;IAC3D,CAAC;IACD,OAAO,MAAM,CAAC,KAAK,CAAC,CAAC;AACvB,CAAC;AAED;iDACiD;AACjD,MAAM,UAAU,UAAU,CAAC,IAAa;IACtC,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC,IAAI,IAAI,CAAC,MAAM,KAAK,CAAC;QAAE,OAAO,SAAS,CAAC;IAChE,MAAM,IAAI,GAAG,IAAI,CAAC,GAAG,CAAC,cAAc,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,IAAI,EAAE,CAAC;IACxD,IAAI,IAAI,KAAK,EAAE;QAAE,OAAO,SAAS,CAAC;IAClC,OAAO,IAAI,CAAC,MAAM,GAAG,aAAa;QAChC,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,MAAM,GAAG,aAAa,CAAC;QACzC,CAAC,CAAC,IAAI,CAAC;AACX,CAAC"}

package/dist/core/render-run-state.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"render-run-state.d.ts","sourceRoot":"","sources":["../../src/core/render-run-state.ts"],"names":[],"mappings":"AAiBA,OAAO,KAAK,EAEV,mBAAmB,EAEpB,MAAM,oBAAoB,CAAC;AAE5B,OAAO,KAAK,EAAE,OAAO,EAAwB,MAAM,oBAAoB,CAAC;AAoHxE;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,OAAO,EAAE,mBAAmB,GAAG,OAAO,CAMpE"}
+{"version":3,"file":"render-run-state.d.ts","sourceRoot":"","sources":["../../src/core/render-run-state.ts"],"names":[],"mappings":"AAgBA,OAAO,KAAK,EACV,mBAAmB,EAEpB,MAAM,oBAAoB,CAAC;AAE5B,OAAO,KAAK,EAAE,OAAO,EAAwB,MAAM,oBAAoB,CAAC;AA0FxE;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,OAAO,EAAE,mBAAmB,GAAG,OAAO,CAMpE"}

package/dist/core/render-run-state.js

@@ -4,24 +4,21 @@
  *
  * Pure and deterministic: no LLM, no I/O, no clock. Every field is derived from
  * the decoded projection, so the same function drives the polling path today and
- * a future WebSocket push (only the data source swaps, never this mapping). Cost
- * and latency are read straight from the projection and rendered statically — the
+ * a future WebSocket push (only the data source swaps, never this mapping).
+ * Latency is read straight from the projection and rendered statically — the
  * LLM is only ever invoked later by an explicit debug-macro press, never to
  * compute what's shown here.
  *
- * Honest absence is preserved end to end: a step with no cost on this read gets
- * no `costUsd` (not `0`), a still-running step gets no `latencyMs`, and a step
- * with no logs gets no `logSlice` — matching the SDK's "null cost is honest
- * absence, never a fabricated $0" contract.
+ * Honest absence is preserved end to end: a still-running step gets no
+ * `latencyMs`, and a step with no logs gets no `logSlice`. The inspector
+ * surfaces logs, latency, and pass/fail only — no cost.
  */
 import { isExecutionTerminal } from "@sapiom/agent-core";
-/**
- * Cap on the characters of a step's executor log buffer surfaced in `logSlice`.
- * The TAIL is kept (most recent lines) because failures surface at the end of a
- * log. This is a payload guard on the poll response; the debug-macro context
- * extractor does the final, smaller trim for prompt injection.
- */
-const LOG_SLICE_MAX = 4000;
+// The log-buffer formatter lives in its own dependency-free module so the
+// local-run mapper (imported by the browser SPA) can share the SAME formatter
+// WITHOUT dragging this file's `@sapiom/agent-core` runtime import — and its
+// `node:fs` reach — into the web bundle.
+import { toLogSlice } from "./render-log-slice.js";
 /**
  * Fold the run's lifecycle status into the four states the UI distinguishes.
  * Reuses `isExecutionTerminal` (agent-core's single source of truth for "won't
@@ -57,14 +54,6 @@ function toStepStatus(raw) {
         return "running";
     return "pending";
 }
-/** Captured USD as a number; `undefined` on honest absence (null cost) or an
- *  unparseable amount — never a fabricated `0`. */
-function toCostUsd(cost) {
-    if (!cost)
-        return undefined;
-    const n = Number(cost.capturedUsd);
-    return Number.isFinite(n) ? n : undefined;
-}
 /** `finishedAt − startedAt` in ms; `undefined` while still running (no finish)
  *  or when either timestamp is unparseable. A negative delta (clock skew) is
  *  dropped rather than shown as a misleading negative latency. */
@@ -78,31 +67,6 @@ function toLatencyMs(startedAt, finishedAt) {
     const delta = end - start;
     return delta >= 0 ? delta : undefined;
 }
-/** One executor log entry → a compact line. Accepts the `{ ts, level, msg }`
- *  wire shape (or `message`), a bare string, or anything else (stringified). */
-function formatLogEntry(entry) {
-    if (typeof entry === "string")
-        return entry;
-    if (entry !== null && typeof entry === "object") {
-        const e = entry;
-        const parts = [e.ts, e.level, e.msg ?? e.message].filter((p) => typeof p === "string" || typeof p === "number");
-        if (parts.length > 0)
-            return parts.map(String).join(" ");
-    }
-    return String(entry);
-}
-/** Format the executor log buffer into a trimmed, tail-preserving slice, or
- *  `undefined` when there are no usable logs. */
-function toLogSlice(logs) {
-    if (!Array.isArray(logs) || logs.length === 0)
-        return undefined;
-    const text = logs.map(formatLogEntry).join("\n").trim();
-    if (text === "")
-        return undefined;
-    return text.length > LOG_SLICE_MAX
-        ? text.slice(text.length - LOG_SLICE_MAX)
-        : text;
-}
 /** Map one projection step to its render view. Optional fields are assigned only
  *  when present so absence stays absent (not `undefined`) in the JSON payload. */
 function toStepView(step) {
@@ -111,9 +75,6 @@ function toStepView(step) {
         name: step.stepName,
         status: toStepStatus(step.status),
     };
-    const costUsd = toCostUsd(step.cost);
-    if (costUsd !== undefined)
-        view.costUsd = costUsd;
     const latencyMs = toLatencyMs(step.startedAt, step.finishedAt);
     if (latencyMs !== undefined)
         view.latencyMs = latencyMs;
@@ -122,6 +83,26 @@ function toStepView(step) {
     const logSlice = toLogSlice(step.logs);
     if (logSlice !== undefined)
         view.logSlice = logSlice;
+    // Real per-step IO for the inspector's "Last run" block. The decoder
+    // collapses an absent input/output to `null` (its absence sentinel), so a
+    // `null` here means "the read carried nothing" — surfaced as ABSENT, never a
+    // fabricated payload. Any non-null value (including `0`, `false`, `""`) is a
+    // real payload and passes through. Capability, not model: these are the
+    // step's own values, with no provider/model surfaced.
+    if (step.input !== null)
+        view.input = step.input;
+    if (step.output !== null)
+        view.output = step.output;
+    // `step.events` are capability execution events forwarded by dispatched
+    // capabilities (e.g. tool_use / thinking / result events from a coding run).
+    // They do NOT represent dotted workflow capability calls (search.webSearch,
+    // memory.append, etc.) with args/results in the StepCall format, so we
+    // cannot map them to StepView.calls without fabricating structure that isn't
+    // there. `calls` is left absent for prod steps. The inspector's
+    // input/output/logs already carry the step-level evidence for prod runs;
+    // per-call detail is a fast-follow that requires a server-side addition to
+    // the projection shape (emitting dotted-capability call records alongside
+    // their args/results at the step level).
     return view;
 }
 /**

package/dist/core/render-run-state.js.map

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

package/dist/core/resume-brief.d.ts

@@ -0,0 +1,130 @@
+/**
+ * The "portable continue" brief: a bounded markdown reconstruction of a prior
+ * session, rendered from the SessionRecord our own events already produce (see
+ * core/session-record.ts).
+ *
+ * Why this exists rather than a vendor resume: `claude --resume` / `codex
+ * resume` only work when that agent, on this machine, still holds that
+ * conversation. H1 (SAP-2057) made us stop pretending otherwise; this is the
+ * other half — for every row where the agent does NOT hold it, start a fresh
+ * session seeded with what we recorded. Because the input is our normalized
+ * record and the output is plain text, the same code path serves claude-code
+ * (`--append-system-prompt`) and codex (`developer_instructions`), and would
+ * serve a harness with no prompt flag at all via post-ready injection.
+ *
+ * HONESTY IS THE PRODUCT HERE. A brief that reads like restored memory is
+ * worse than no brief: the agent will assert a file's contents or a command's
+ * outcome it never saw. So the header says outright that this is a
+ * reconstruction, `record.limitations` are spelled out, and every omission
+ * (dropped turns, clamped text, capped file lists) is stated in the text
+ * rather than silently applied.
+ *
+ * BUDGET. The brief is capped at `maxTokens` (default
+ * {@link RESUME_BRIEF_DEFAULT_MAX_TOKENS}), estimated at
+ * {@link CHARS_PER_TOKEN} characters per token — deliberately a crude
+ * estimator, since the consumer is a system prompt with room to spare, not a
+ * hard API limit, and a tokenizer dependency here would have to be right for
+ * two different vendors' tokenizers anyway. What gets squeezed, in order:
+ *
+ *   1. turns, oldest-first — the newest are the ones that explain what is in
+ *      flight right now, and an old turn is the most verbose thing here per
+ *      unit of usefulness;
+ *   2. the derived digests (files written, commands run). They go AFTER turns,
+ *      not before, because they are hard-capped ({@link MAX_FILES} /
+ *      {@link MAX_COMMANDS}) at a few hundred tokens for a whole session,
+ *      where each turn costs a comparable amount on its own — trading a
+ *      whole-session view for one more ancient turn is a bad deal. They can
+ *      also be recovered by looking at the repository, so this only bites
+ *      once every turn is already gone;
+ *   3. only then the rolling summary, tail-clamped. It is squeezed last
+ *      because it is the one section that is a lossy fold of turns already
+ *      dropped in step 1: cutting it loses history nothing else carries.
+ *
+ * The honesty header and the identity block are never dropped — a brief
+ * without them is a lie, not a shorter brief — so they act as a floor of
+ * roughly {@link RESUME_BRIEF_MIN_TOKENS} tokens that a smaller `maxTokens`
+ * cannot squeeze below.
+ */
+import type { SessionRecord, SessionRecordToolCall } from "../shared/types.js";
+/** Default token ceiling for a brief — see the module header on the estimate. */
+export declare const RESUME_BRIEF_DEFAULT_MAX_TOKENS = 6000;
+/** Turns considered before budgeting; the budget may keep fewer, never more. */
+export declare const RESUME_BRIEF_DEFAULT_MAX_TURNS = 12;
+/**
+ * Characters per token. Roughly right for English prose and code across both
+ * vendors' tokenizers, and biased the safe way: real text averages slightly
+ * more than 4 chars/token, so this over-counts and lands under the ceiling.
+ */
+export declare const CHARS_PER_TOKEN = 4;
+/**
+ * Floor the budget can never squeeze below — the honesty header plus the
+ * identity block. Approximate (it moves with the header's wording); it exists
+ * so callers can reason about "what does maxTokens: 200 even mean" rather than
+ * as an assertion about exact size.
+ */
+export declare const RESUME_BRIEF_MIN_TOKENS = 400;
+/** The workflow the prior session was bound to, resolved by the caller against
+ *  the live workflow registry (the record itself has no binding). */
+export interface ResumeBriefWorkflow {
+    name: string;
+    path: string;
+    definitionId: number | null;
+}
+export interface BuildResumeBriefOptions {
+    /** Display title of the prior session, when a history row knew one. */
+    title?: string | null;
+    /** Git branch the prior session was last on, when a history row knew one. */
+    gitBranch?: string | null;
+    /** The prior session's bound workflow. */
+    workflow?: ResumeBriefWorkflow | null;
+    /**
+     * The rolling summary (`<generated>/<sessionId>/summary.md`) when one was
+     * ever produced. Absent, the brief degrades to the last N turns — which is
+     * the normal case, since the summary is opt-in (see core/rolling-summary.ts).
+     */
+    summary?: string | null;
+    /** Token ceiling. Default {@link RESUME_BRIEF_DEFAULT_MAX_TOKENS}. */
+    maxTokens?: number;
+    /** Newest turns considered. Default {@link RESUME_BRIEF_DEFAULT_MAX_TURNS}. */
+    maxTurns?: number;
+}
+/** The crude char-count estimate the budget is enforced against. */
+export declare function estimateBriefTokens(text: string): number;
+/**
+ * The tool's target as a human would name it: the file it edited, the command
+ * it ran, or — failing both — a clamped slice of the raw input.
+ *
+ * `toolInput` is a string on the wire for both harnesses: claude-code's
+ * normalizer stores `JSON.stringify(tool_input)` and codex's tailer stores the
+ * function call's raw `arguments`, so a JSON parse covers both and a plain
+ * string (an untruncated free-text argument) falls through to the raw slice.
+ * Never throws on malformed input — a brief must render from whatever was
+ * recorded, including a payload the collector truncated mid-JSON.
+ */
+export declare function describeToolTarget(call: SessionRecordToolCall, cwd: string | null): string | null;
+interface DerivedDigests {
+    /** Files written, most-recently-touched first, with their touch counts. */
+    files: Array<{
+        display: string;
+        count: number;
+    }>;
+    /** Total distinct files, which may exceed `files.length` after the cap. */
+    totalFiles: number;
+    /** Distinct shell commands, most recent first. */
+    commands: string[];
+    totalCommands: number;
+}
+/**
+ * Files touched and commands run, derived from `tool.call` inputs. Exported
+ * for tests and because the same derivation is worth reusing anywhere that
+ * needs "what did this session actually do to the tree".
+ */
+export declare function deriveDigests(record: SessionRecord): DerivedDigests;
+/**
+ * Render a bounded brief for `record`. Pure and synchronous; the caller
+ * supplies the rolling summary and any registry-only context (title, branch,
+ * bound workflow) it can resolve.
+ */
+export declare function buildResumeBrief(record: SessionRecord, options?: BuildResumeBriefOptions): string;
+export {};
+//# sourceMappingURL=resume-brief.d.ts.map

package/dist/core/resume-brief.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resume-brief.d.ts","sourceRoot":"","sources":["../../src/core/resume-brief.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8CG;AAIH,OAAO,KAAK,EACV,aAAa,EAEb,qBAAqB,EAEtB,MAAM,oBAAoB,CAAC;AAE5B,iFAAiF;AACjF,eAAO,MAAM,+BAA+B,OAAQ,CAAC;AACrD,gFAAgF;AAChF,eAAO,MAAM,8BAA8B,KAAK,CAAC;AACjD;;;;GAIG;AACH,eAAO,MAAM,eAAe,IAAI,CAAC;AACjC;;;;;GAKG;AACH,eAAO,MAAM,uBAAuB,MAAM,CAAC;AAiB3C;qEACqE;AACrE,MAAM,WAAW,mBAAmB;IAClC,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,YAAY,EAAE,MAAM,GAAG,IAAI,CAAC;CAC7B;AAED,MAAM,WAAW,uBAAuB;IACtC,uEAAuE;IACvE,KAAK,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACtB,6EAA6E;IAC7E,SAAS,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC1B,0CAA0C;IAC1C,QAAQ,CAAC,EAAE,mBAAmB,GAAG,IAAI,CAAC;IACtC;;;;OAIG;IACH,OAAO,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACxB,sEAAsE;IACtE,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,+EAA+E;IAC/E,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAED,oEAAoE;AACpE,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAExD;AAUD;;;;;;;;;;GAUG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,qBAAqB,EAAE,GAAG,EAAE,MAAM,GAAG,IAAI,GAAG,MAAM,GAAG,IAAI,CAYjG;AAyDD,UAAU,cAAc;IACtB,2EAA2E;IAC3E,KAAK,EAAE,KAAK,CAAC;QAAE,OAAO,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IACjD,2EAA2E;IAC3E,UAAU,EAAE,MAAM,CAAC;IACnB,kDAAkD;IAClD,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,aAAa,EAAE,MAAM,CAAC;CACvB;AAED;;;;GAIG;AACH,wBAAgB,aAAa,CAAC,MAAM,EAAE,aAAa,GAAG,cAAc,CAoCnE;AA0ED;;;;GAIG;AACH,wBAAgB,gBAAgB,CAC9B,MAAM,EAAE,aAAa,EACrB,OAAO,GAAE,uBAA4B,GACpC,MAAM,CAyER"}