@sapiom/harness 0.1.5 → 0.1.6

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/run-local-bootstrap.d.ts

@@ -0,0 +1,93 @@
+/**
+ * run-local bootstrap — the child-process entrypoint behind
+ * `POST /api/runs/local`.
+ *
+ * It runs an agent entirely in-process against stub capabilities
+ * (`runLocalFromDir` from @sapiom/agent-core) and writes the result as an
+ * NDJSON stream to stdout: one line per {@link LocalStepTrace}, then a single
+ * terminal summary line `{ outcome, output, error, unusedStubs, stubWarnings }`.
+ * Fully offline and zero-cost — run-local resolves every `ctx.sapiom.*` call
+ * from stubs and never touches the network.
+ *
+ * Why a separate child process (not an in-process import):
+ *  1. `runLocalFromDir` esbuild-bundles and dynamically `import()`s a workflow
+ *     project the harness doesn't control, so a stray top-level side effect,
+ *     infinite loop, or crash in someone else's step body is bounded to this
+ *     one child instead of taking the long-lived harness server down.
+ *  2. It sidesteps a Vite/Vitest limitation: the dynamic `import(\`file://…\`)`
+ *     inside the loader gets intercepted by the SSR dynamic-import-vars
+ *     transform when pulled into a Vitest module graph, and mishandles the
+ *     tmpdir `file://` URL on darwin. A plain child `node` process never goes
+ *     through that transform. (Mirrors the reasoning in canvas-manifest-check.)
+ *
+ * Contract with the route ({@link createActionsRouter}):
+ *  - Request arrives as one JSON object on **stdin**: `{ sourceDir, input?,
+ *    stubs?, maxAttemptsPerStep? }`.
+ *  - Output is line-oriented JSON on **stdout** — the route forwards each line
+ *    through unchanged, so the shapes here ARE the wire shapes the SPA parses.
+ *  - Diagnostics go to **stderr**; the route keeps a bounded tail for failures.
+ *  - Exit 0 once the terminal line is written (even for a failed run — a failed
+ *    *run* is a successful *invocation*); exit 1 only when no run happened
+ *    (bad request, load error) after writing a terminal `error` line.
+ */
+import { type LocalRunOutcome, type StubFile } from "@sapiom/agent-core";
+/** The request shape the route writes to this child's stdin. */
+export interface RunLocalRequest {
+    /** Absolute path to the agent project directory (contains `index.ts`). */
+    sourceDir: string;
+    /** The workflow's entry-step input (optional; agent-core defaults it). */
+    input?: unknown;
+    /** Explicit stub overrides. When omitted the project's committed
+     *  `.sapiom-dev/stubs.json` is used (agent-core's own precedence). */
+    stubs?: StubFile;
+    /** Per-step attempt cap (optional; agent-core defaults it). */
+    maxAttemptsPerStep?: number;
+}
+/**
+ * The terminal NDJSON line, written after every per-step trace line. Carries
+ * the run-level outcome and the two stub-hygiene signals the inspector surfaces
+ * (WB15-2): `unusedStubs` (supplied keys that matched no capability call) and
+ * `stubWarnings` (keys that matched but carried the wrong shape).
+ *
+ * `kind: "summary"` discriminates it from a step-trace line so a consumer never
+ * has to guess which line is terminal.
+ */
+export interface RunLocalSummaryLine {
+    kind: "summary";
+    outcome: LocalRunOutcome;
+    output?: unknown;
+    error?: unknown;
+    unusedStubs: Array<{
+        step: string;
+        key: string;
+    }>;
+    stubWarnings: string[];
+}
+/**
+ * The terminal line written when the run could not be *invoked* at all — a
+ * malformed request, an unreadable stub file, a project that fails to load.
+ * `outcome` is always `"failed"`; the child then exits non-zero. Distinct from
+ * a `summary` line, which represents a run that actually executed (even if that
+ * run's own outcome was `failed`).
+ */
+export interface RunLocalErrorLine {
+    kind: "error";
+    outcome: "failed";
+    error: string;
+}
+/**
+ * Parse the stdin payload into a {@link RunLocalRequest}. Throws a plain Error
+ * with a caller-safe message (no key material, no provider names) on anything
+ * that isn't a JSON object carrying a non-empty string `sourceDir`.
+ */
+export declare function parseRunLocalRequest(raw: string): RunLocalRequest;
+/**
+ * Run the request and emit its NDJSON stream to `out`. Returns the process exit
+ * code: 0 when a run executed (any outcome), 1 when the run could not be
+ * invoked (a terminal `error` line is emitted first). Never throws — every
+ * failure becomes an in-band terminal line, because a half-written stream with
+ * a thrown stack on stderr is far harder for the route to reason about than a
+ * clean terminal line plus an exit code.
+ */
+export declare function runBootstrap(request: RunLocalRequest, out: NodeJS.WritableStream): Promise<number>;
+//# sourceMappingURL=run-local-bootstrap.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"run-local-bootstrap.d.ts","sourceRoot":"","sources":["../../src/core/run-local-bootstrap.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,OAAO,EAGL,KAAK,eAAe,EACpB,KAAK,QAAQ,EACd,MAAM,oBAAoB,CAAC;AAE5B,gEAAgE;AAChE,MAAM,WAAW,eAAe;IAC9B,0EAA0E;IAC1E,SAAS,EAAE,MAAM,CAAC;IAClB,0EAA0E;IAC1E,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB;0EACsE;IACtE,KAAK,CAAC,EAAE,QAAQ,CAAC;IACjB,+DAA+D;IAC/D,kBAAkB,CAAC,EAAE,MAAM,CAAC;CAC7B;AAED;;;;;;;;GAQG;AACH,MAAM,WAAW,mBAAmB;IAClC,IAAI,EAAE,SAAS,CAAC;IAChB,OAAO,EAAE,eAAe,CAAC;IACzB,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,WAAW,EAAE,KAAK,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,GAAG,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IAClD,YAAY,EAAE,MAAM,EAAE,CAAC;CACxB;AAED;;;;;;GAMG;AACH,MAAM,WAAW,iBAAiB;IAChC,IAAI,EAAE,OAAO,CAAC;IACd,OAAO,EAAE,QAAQ,CAAC;IAClB,KAAK,EAAE,MAAM,CAAC;CACf;AAWD;;;;GAIG;AACH,wBAAgB,oBAAoB,CAAC,GAAG,EAAE,MAAM,GAAG,eAAe,CAwBjE;AAYD;;;;;;;GAOG;AACH,wBAAsB,YAAY,CAChC,OAAO,EAAE,eAAe,EACxB,GAAG,EAAE,MAAM,CAAC,cAAc,GACzB,OAAO,CAAC,MAAM,CAAC,CAkCjB"}