@wardby/cli 0.7.0 → 0.9.0

package/dist/sandbox/host-functions.js

@@ -95,7 +95,11 @@ export function createPrivilegedHost(options) {
         },
         async __bridge_fetch(argsJson) {
             const [url, init = {}, secretNames] = args(argsJson);
-            const policy = { ...sandboxFetchPolicy(allowedFetchHosts ?? []), signal };
+            const policy = {
+                ...sandboxFetchPolicy(allowedFetchHosts ?? []),
+                signal,
+                ...(options.fetchTimeoutMs !== undefined ? { timeoutMs: options.fetchTimeoutMs } : {}),
+            };
             if (secretNames === undefined || (Array.isArray(secretNames) && secretNames.length === 0)) {
                 return fetchImpl(url, init, policy);
             }
@@ -177,13 +181,14 @@ export function createPrivilegedHost(options) {
 /** Registers the whole sandbox API: the local bridges directly, the privileged ones through `privileged`. */
 export function installSandboxApi(context, runtime, options) {
     const { privileged, signal } = options;
+    const sleepLimitMs = options.wallTimeLimitMs ?? WALL_TIME_LIMIT_MS;
     const register = (name, fn) => registerJsonAsyncFunction(context, runtime, name, fn, signal);
     const parserPool = options.parserPool ?? (sharedParserPool ??= createParserWorkerPool());
     for (const name of PRIVILEGED_BRIDGE_NAMES)
         register(name, (argsJson) => privileged[name](argsJson));
     register("__bridge_sleep", async (argsJson) => {
         const [ms] = args(argsJson);
-        if (!Number.isFinite(ms) || ms < 0 || ms > WALL_TIME_LIMIT_MS)
+        if (!Number.isFinite(ms) || ms < 0 || ms > sleepLimitMs)
             throw new Error("sleep_limit");
         await sleep(ms, undefined, { signal });
         return null;

package/dist/sandbox/limits.d.ts

@@ -15,7 +15,10 @@ export declare const MAX_INTERRUPT_CHECKS = 20000000;
  * awaiting a host async call (e.g. a slow `fetch`) — this does.
  */
 export declare const WALL_TIME_LIMIT_MS = 10000;
-/** Timeout for the sandbox's `fetch` host bridge, independent of the wall-time cap. */
+/**
+ * safeFetch's timeout when its caller gives none. A sandboxed tool's fetches get
+ * fetchTimeoutFor(the tool's limit) instead (tool-timeout.ts), just past its wall time.
+ */
 export declare const FETCH_TIMEOUT_MS = 8000;
 /** QuickJS interpreter stack size cap (bytes). */
 export declare const MAX_STACK_SIZE_BYTES: number;

package/dist/sandbox/limits.js

@@ -15,7 +15,10 @@ export const MAX_INTERRUPT_CHECKS = 20_000_000;
  * awaiting a host async call (e.g. a slow `fetch`) — this does.
  */
 export const WALL_TIME_LIMIT_MS = 10_000;
-/** Timeout for the sandbox's `fetch` host bridge, independent of the wall-time cap. */
+/**
+ * safeFetch's timeout when its caller gives none. A sandboxed tool's fetches get
+ * fetchTimeoutFor(the tool's limit) instead (tool-timeout.ts), just past its wall time.
+ */
 export const FETCH_TIMEOUT_MS = 8_000;
 /** QuickJS interpreter stack size cap (bytes). */
 export const MAX_STACK_SIZE_BYTES = 1024 * 1024; // 1 MiB

package/dist/sandbox/run-in-sandbox.d.ts

@@ -27,6 +27,8 @@ export interface SandboxInvocation {
     toolName: string;
     /** Overrides the default limits (limits.ts) — mainly for fast, deterministic tests. */
     limits?: Partial<SandboxLimits>;
+    /** The tool's time limit (effectiveToolTimeoutMs); its fetches time out just before it. Overrides limits.wallTimeLimitMs. */
+    timeoutMs?: number;
     /** Omitted for a dry run (no real agent) — secrets.get always resolves undefined. */
     secrets?: SecretsAccessor;
     /** Overrides the default shared logger — mainly for tests that need to capture forwarded console output. */
@@ -42,12 +44,16 @@ export interface ToolCodeInvocation {
     code: string;
     params: unknown;
     limits?: Partial<SandboxLimits>;
+    /** Stops the call early (its run was stopped): it fails as `cancelled`, and its host calls are aborted. */
+    signal?: AbortSignal;
     /** Built once per invocation, with that invocation's abort signal (fetch needs it). */
     privileged: (signal: AbortSignal) => PrivilegedHost;
     parserPool?: ParserWorkerPool;
 }
 /** Evaluates one tool body in a fresh QuickJS context against the given privileged host. */
 export declare function runToolCode(invocation: ToolCodeInvocation): Promise<SandboxResult>;
+/** The sandbox limits for a tool whose time limit is `timeoutMs` (absent: the defaults). */
+export declare function toolLimits(timeoutMs: number | undefined, base?: Partial<SandboxLimits>): Partial<SandboxLimits>;
 /** The in-process privileged host for a sandbox invocation. */
 export declare function privilegedHostFor(invocation: SandboxInvocation, signal: AbortSignal): PrivilegedHost;
 export declare function runInSandbox(invocation: SandboxInvocation): Promise<SandboxResult>;

package/dist/sandbox/run-in-sandbox.js

@@ -9,7 +9,8 @@
  */
 import { createPrivilegedHost, installSandboxApi } from "./host-functions.js";
 import { SANDBOX_PRELUDE } from "./prelude.js";
-import { evalToJson, NON_SERIALIZABLE_MARKER } from "./eval-core.js";
+import { DEFAULT_SANDBOX_LIMITS, evalToJson, NON_SERIALIZABLE_MARKER, } from "./eval-core.js";
+import { fetchTimeoutFor, TOOL_RUN_STOPPED_MESSAGE, toolTimeoutMessage } from "./tool-timeout.js";
 import { boundedJson, boundedString } from "./bounded-json.js";
 import { BRIDGE_INPUT_BYTES } from "./limits.js";
 /** Evaluates one tool body in a fresh QuickJS context against the given privileged host. */
@@ -39,14 +40,24 @@ export async function runToolCode(invocation) {
     throw new Error("${NON_SERIALIZABLE_MARKER}" + (__serializeErr && __serializeErr.message));
   }
 })()`;
+    const wallTimeLimitMs = invocation.limits?.wallTimeLimitMs ?? DEFAULT_SANDBOX_LIMITS.wallTimeLimitMs;
     return evalToJson(code, invocation.limits, (context, runtime, signal) => {
         installSandboxApi(context, runtime, {
             privileged: invocation.privileged(signal),
             signal,
             parserPool: invocation.parserPool,
+            wallTimeLimitMs,
         });
+    }, {
+        signal: invocation.signal,
+        aborted: () => ({ ok: false, errorKind: "cancelled", errorMessage: TOOL_RUN_STOPPED_MESSAGE }),
+        timeoutMessage: toolTimeoutMessage,
     });
 }
+/** The sandbox limits for a tool whose time limit is `timeoutMs` (absent: the defaults). */
+export function toolLimits(timeoutMs, base) {
+    return timeoutMs === undefined ? { ...base } : { ...base, wallTimeLimitMs: timeoutMs };
+}
 /** The in-process privileged host for a sandbox invocation. */
 export function privilegedHostFor(invocation, signal) {
     return createPrivilegedHost({
@@ -59,13 +70,14 @@ export function privilegedHostFor(invocation, signal) {
         allowedFetchHosts: invocation.allowedFetchHosts,
         fetchImpl: invocation.fetchImpl,
         signal,
+        fetchTimeoutMs: fetchTimeoutFor(invocation.timeoutMs ?? invocation.limits?.wallTimeLimitMs ?? DEFAULT_SANDBOX_LIMITS.wallTimeLimitMs),
     });
 }
 export async function runInSandbox(invocation) {
     return runToolCode({
         code: invocation.code,
         params: invocation.params,
-        limits: invocation.limits,
+        limits: toolLimits(invocation.timeoutMs, invocation.limits),
         privileged: (signal) => privilegedHostFor(invocation, signal),
     });
 }

package/dist/sandbox/safe-fetch.d.ts

@@ -11,6 +11,8 @@ export declare function pinnedLookup(destination: Destination): LookupFunction;
 export declare function requestPinned(destination: Destination, init: SafeFetchInit, signal: AbortSignal): Promise<IncomingMessage>;
 export interface SafeFetchOptions extends FetchPolicyOptions {
     signal?: AbortSignal;
+    /** This fetch's own timeout; FETCH_TIMEOUT_MS when absent. */
+    timeoutMs?: number;
     connect?: typeof requestPinned;
     /** False: a 3xx is returned to the caller as-is (brokered requests re-check every hop themselves). */
     followRedirects?: boolean;

package/dist/sandbox/safe-fetch.js

@@ -39,7 +39,7 @@ async function untilAbort(promise, signal) {
 }
 export async function safeFetch(input, init = {}, options = {}) {
     const abort = new AbortController();
-    const timer = setTimeout(() => abort.abort(new Error("fetch_timeout")), FETCH_TIMEOUT_MS);
+    const timer = setTimeout(() => abort.abort(new Error("fetch_timeout")), options.timeoutMs ?? FETCH_TIMEOUT_MS);
     const signal = options.signal ? AbortSignal.any([options.signal, abort.signal]) : abort.signal;
     let url = input;
     let method = init.method ?? "GET";

package/dist/sandbox/secret-broker.d.ts

@@ -26,6 +26,7 @@ export declare function consoleRedactionValues(entry: {
     value: string;
     broker: SecretBrokerConfig | null;
 }): string[];
+export declare function encodedForms(value: string): string[];
 export declare function scrubBrokeredResponse<T extends {
     headers: Record<string, string>;
     bodyBase64: string;

package/dist/sandbox/secret-broker.js

@@ -121,7 +121,7 @@ export function consoleRedactionValues(entry) {
         return [entry.value];
     }
 }
-function encodedForms(value) {
+export function encodedForms(value) {
     const buf = Buffer.from(value, "utf8");
     // Query placement goes through URLSearchParams, which encodes ~ ! ' ( ) differently and space as "+",
     // so both percent-encodings are scrubbed, each also in lowercase-hex form (a response may echo either).

package/dist/sandbox/tool-timeout.d.ts

@@ -0,0 +1,32 @@
+/**
+ * A sandboxed tool's time limit. A tool may ask for its own `timeoutMs`; the operator's
+ * WARDBY_TOOL_MAX_TIMEOUT_MS (config/tool-timeout.ts) caps it. Without one a tool keeps the
+ * default wall-time cap (limits.ts). Pure and worker-safe: no configuration is read here.
+ */
+/** A tool that sets no `timeoutMs`. */
+export declare const DEFAULT_TOOL_TIMEOUT_MS = 10000;
+/** The shortest `timeoutMs` a tool may ask for. */
+export declare const MIN_TOOL_TIMEOUT_MS = 1000;
+/** WARDBY_TOOL_MAX_TIMEOUT_MS when unset: five minutes. */
+export declare const DEFAULT_TOOL_MAX_TIMEOUT_MS = 300000;
+/**
+ * How far past the tool's limit each fetch's own timeout lies. The wall time ends the call (and
+ * aborts its fetches) first, so a slow request fails with the wall-time error that names the
+ * limit, not a fetch error.
+ */
+export declare const FETCH_TIMEOUT_MARGIN_MS = 1000;
+/** The fetch timeout for a tool limit of `wallTimeLimitMs`. */
+export declare function fetchTimeoutFor(wallTimeLimitMs: number): number;
+/**
+ * The limit a run uses for a tool: its own `timeoutMs` (or the default when it has none), never
+ * above the current ceiling, so lowering the ceiling also covers tools that already exist.
+ */
+export declare function effectiveToolTimeoutMs(timeoutMs: number | null | undefined, ceilingMs: number): number;
+/** Why `timeoutMs` can't be stored on a tool under `ceilingMs`, or undefined when it can. */
+export declare function toolTimeoutProblem(timeoutMs: unknown, ceilingMs: number): string | undefined;
+/** The model-facing text for a tool that ran out of time. */
+export declare function toolTimeoutMessage(limitMs: number): string;
+/** The model-facing text for a tool call cut off at its run's deadline. */
+export declare const TOOL_RUN_DEADLINE_MESSAGE = "Stopped at the run's deadline while this tool call was still running.";
+/** The model-facing text for a tool call aborted because its run was stopped. */
+export declare const TOOL_RUN_STOPPED_MESSAGE = "The run was stopped while this tool call was running.";

package/dist/sandbox/tool-timeout.js

@@ -0,0 +1,52 @@
+/**
+ * A sandboxed tool's time limit. A tool may ask for its own `timeoutMs`; the operator's
+ * WARDBY_TOOL_MAX_TIMEOUT_MS (config/tool-timeout.ts) caps it. Without one a tool keeps the
+ * default wall-time cap (limits.ts). Pure and worker-safe: no configuration is read here.
+ */
+import { WALL_TIME_LIMIT_MS } from "./limits.js";
+/** A tool that sets no `timeoutMs`. */
+export const DEFAULT_TOOL_TIMEOUT_MS = WALL_TIME_LIMIT_MS;
+/** The shortest `timeoutMs` a tool may ask for. */
+export const MIN_TOOL_TIMEOUT_MS = 1_000;
+/** WARDBY_TOOL_MAX_TIMEOUT_MS when unset: five minutes. */
+export const DEFAULT_TOOL_MAX_TIMEOUT_MS = 300_000;
+/**
+ * How far past the tool's limit each fetch's own timeout lies. The wall time ends the call (and
+ * aborts its fetches) first, so a slow request fails with the wall-time error that names the
+ * limit, not a fetch error.
+ */
+export const FETCH_TIMEOUT_MARGIN_MS = 1_000;
+/** The fetch timeout for a tool limit of `wallTimeLimitMs`. */
+export function fetchTimeoutFor(wallTimeLimitMs) {
+    return wallTimeLimitMs + FETCH_TIMEOUT_MARGIN_MS;
+}
+/**
+ * The limit a run uses for a tool: its own `timeoutMs` (or the default when it has none), never
+ * above the current ceiling, so lowering the ceiling also covers tools that already exist.
+ */
+export function effectiveToolTimeoutMs(timeoutMs, ceilingMs) {
+    if (timeoutMs === null || timeoutMs === undefined)
+        return DEFAULT_TOOL_TIMEOUT_MS;
+    return Math.min(timeoutMs, ceilingMs);
+}
+/** Why `timeoutMs` can't be stored on a tool under `ceilingMs`, or undefined when it can. */
+export function toolTimeoutProblem(timeoutMs, ceilingMs) {
+    if (typeof timeoutMs !== "number" || !Number.isSafeInteger(timeoutMs)) {
+        return "timeoutMs must be a whole number of milliseconds.";
+    }
+    if (timeoutMs < MIN_TOOL_TIMEOUT_MS)
+        return `timeoutMs must be at least ${MIN_TOOL_TIMEOUT_MS} ms.`;
+    if (timeoutMs > ceilingMs) {
+        return `timeoutMs ${timeoutMs} is above this server's ceiling of ${ceilingMs} ms (WARDBY_TOOL_MAX_TIMEOUT_MS).`;
+    }
+    return undefined;
+}
+/** The model-facing text for a tool that ran out of time. */
+export function toolTimeoutMessage(limitMs) {
+    return (`Exceeded the ${limitMs}ms wall-time limit. A tool that needs longer can set timeoutMs ` +
+        "(create_tool or update_tool), up to the server's WARDBY_TOOL_MAX_TIMEOUT_MS.");
+}
+/** The model-facing text for a tool call cut off at its run's deadline. */
+export const TOOL_RUN_DEADLINE_MESSAGE = "Stopped at the run's deadline while this tool call was still running.";
+/** The model-facing text for a tool call aborted because its run was stopped. */
+export const TOOL_RUN_STOPPED_MESSAGE = "The run was stopped while this tool call was running.";

package/dist/sandbox/user-tool.d.ts

@@ -10,5 +10,12 @@ import type { SandboxLimits } from "./eval-core.js";
 export interface UserToolDefinition {
     code: string;
     paramsZod: string;
+    /** The time limit this run gives the tool (effectiveToolTimeoutMs); absent = the default. */
+    timeoutMs?: number;
 }
-export declare function runUserToolCall(tool: UserToolDefinition, argsJson: string, privileged: (signal: AbortSignal) => PrivilegedHost, limits?: Partial<SandboxLimits>): Promise<string>;
+export interface UserToolCallOptions {
+    limits?: Partial<SandboxLimits>;
+    /** Aborts the call when its run is stopped. */
+    signal?: AbortSignal;
+}
+export declare function runUserToolCall(tool: UserToolDefinition, argsJson: string, privileged: (signal: AbortSignal) => PrivilegedHost, options?: UserToolCallOptions): Promise<string>;

package/dist/sandbox/user-tool.js

@@ -5,9 +5,9 @@
  * JSON error result. Worker-safe: it touches no database or provider, only the
  * privileged host it is given, so the native sandbox worker runs it as is.
  */
-import { runToolCode } from "./run-in-sandbox.js";
+import { runToolCode, toolLimits } from "./run-in-sandbox.js";
 import { validateParams } from "./zod-params.js";
-export async function runUserToolCall(tool, argsJson, privileged, limits) {
+export async function runUserToolCall(tool, argsJson, privileged, options = {}) {
     let parsedArgs;
     try {
         // Some providers stream no JSON delta at all for a zero-parameter
@@ -24,7 +24,13 @@ export async function runUserToolCall(tool, argsJson, privileged, limits) {
     if (!validation.ok) {
         return JSON.stringify({ error: "validation_failed", message: validation.errorMessage });
     }
-    const result = await runToolCode({ code: tool.code, params: validation.value, limits, privileged });
+    const result = await runToolCode({
+        code: tool.code,
+        params: validation.value,
+        limits: toolLimits(tool.timeoutMs, options.limits),
+        signal: options.signal,
+        privileged,
+    });
     if (!result.ok) {
         return JSON.stringify({ error: result.errorKind, message: result.errorMessage });
     }

package/dist/serve.js

@@ -1,21 +1,3 @@
-/**
- * `wardby serve`: the complete wardby process. Runs the MCP server, the
- * scheduler, and the reconciler together on ONE provider set and ONE
- * executor, which is what a single-container deployment (Cloud Run, a lone
- * VM) needs - `wardby mcp` alone never fires a schedule.
- *
- * Why one executor: DbosExecutor is a per-process singleton and refuses to
- * launch twice under different ids (providers/executor/dbos.ts), and its
- * recovery decisions key on that id. Building providers once and sharing
- * them is the whole trick; it also gives scheduled native runs the same
- * `providers.executor` wiring MCP-triggered runs get, so sub-agent dispatch
- * from a scheduled run works (it does not from `wardby scheduler`).
- *
- * Why the scheduler and reconciler can run in every replica: the scheduler
- * elects one ticker via a Postgres lease and enforces at-most-once with row
- * locks regardless (core/scheduler.ts); the reconciler is deliberately not
- * lease-gated and is safe under concurrency (core/reconciler.ts).
- */
 import { loadCodingConcurrencyConfig, loadMcpConfig } from "./config/providers.js";
 import { drainCodingQueue } from "./core/coding-queue.js";
 import { prisma } from "./core/db.js";
@@ -28,6 +10,8 @@ import { markRunFailedFromExecutorError } from "./core/dispatch.js";
 import { startScheduler } from "./core/scheduler.js";
 import { drainDeferredRuns } from "./providers/executor/deferred.js";
 import { resolveDeferredCodingRun } from "./core/deferred-coding.js";
+import { RunStepSweeper } from "./core/run-steps/sweep.js";
+import { parseRunStepsListen, startRunStepIngress } from "./core/run-steps/ingress.js";
 import { buildMcpProviders, startMcp } from "./mcp/index.js";
 const serveLog = logger.child({ module: "serve" });
 export async function startServe(options = {}) {
@@ -39,6 +23,8 @@ export async function startServe(options = {}) {
     // Parsed before anything starts, so a malformed CODING_MAX_CONCURRENT or
     // CODING_QUEUE_TIMEOUT_SEC fails fast instead of after HTTP is listening.
     const concurrency = loadCodingConcurrencyConfig();
+    // Run steps from the coding proxy (POST /internal/run-steps); parsed early so a bad value stops start-up.
+    const runStepsListen = parseRunStepsListen(process.env.WARDBY_RUN_STEPS_LISTEN);
     const providers = options.providers ?? buildMcpProviders().providers;
     const power = providers.power ?? DISABLED_POWER;
     if (power.enabled) {
@@ -48,6 +34,21 @@ export async function startServe(options = {}) {
         }, (err) => serveLog.warn({ err }, "low_power_access_check_failed"));
     }
     const mcp = await startMcp({ providers, schedulerAttached: true });
+    // Its own port (not the MCP listener's): only the coding proxy reaches it.
+    let runStepIngress;
+    if (runStepsListen && providers.runSteps) {
+        try {
+            runStepIngress = await startRunStepIngress(runStepsListen, { db: prisma, sink: providers.runSteps });
+        }
+        catch (err) {
+            await mcp.close();
+            throw err;
+        }
+        serveLog.info({ host: runStepsListen.host, port: runStepsListen.port }, "run steps listener started");
+    }
+    else if (runStepsListen) {
+        serveLog.warn("WARDBY_RUN_STEPS_LISTEN is set but this server has no run-steps writer; not listening");
+    }
     const reviewHosts = providers.reviewHosts;
     const reconciler = startReconciler({
         executor: providers.executor,
@@ -67,6 +68,8 @@ export async function startServe(options = {}) {
     });
     const notifications = await startNotifications({ db: prisma, chat: providers.chat ?? {} });
     const selfDefects = { db: prisma, issueTrackers: providers.issueTrackers };
+    // Expired run steps (RUN_STEP_RETENTION_DAYS), from the scheduler leader only.
+    const runStepSweeper = new RunStepSweeper(prisma);
     const scheduler = startScheduler({
         executor: providers.executor,
         scope: options.scope,
@@ -82,6 +85,7 @@ export async function startServe(options = {}) {
             });
             // Scale idle coding-proxy/native-gateway Deployments to zero (no-op unless WARDBY_LOW_POWER=1).
             await power.sleepIfIdle().catch((err) => serveLog.warn({ err }, "power_sleep_failed"));
+            await runStepSweeper.maybeSweep();
         },
     });
     return {
@@ -92,6 +96,10 @@ export async function startServe(options = {}) {
             scheduler.stop();
             reconciler.stop();
             notifications.stop();
+            // Before mcp.close(), which flushes the run-steps writer: no batch arrives after the flush.
+            const ingress = runStepIngress;
+            if (ingress)
+                await new Promise((resolve) => ingress.close(() => resolve()));
             await mcp.close();
         },
     };

package/dist/viewer/api-schema.d.ts

@@ -320,6 +320,21 @@ export declare const GraphSnapshotSchema: z.ZodObject<{
         }, z.core.$strip>>;
     }, z.core.$strip>;
 }, z.core.$strip>;
+/**
+ * One recorded run step (docs/viewer-api.md): a tool call or what the model said, one line. Stored
+ * already redacted (src/core/run-steps/writer.ts); a step's call id and detail text are never sent.
+ */
+export declare const RunStepSchema: z.ZodObject<{
+    seq: z.ZodNumber;
+    at: z.ZodString;
+    kind: z.ZodEnum<{
+        tool: "tool";
+        said: "said";
+    }>;
+    tool: z.ZodNullable<z.ZodString>;
+    summary: z.ZodString;
+    status: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
 export declare const RunDetailSchema: z.ZodObject<{
     id: z.ZodString;
     parentRunId: z.ZodNullable<z.ZodString>;
@@ -429,6 +444,19 @@ export declare const RunDetailSchema: z.ZodObject<{
     error: z.ZodNullable<z.ZodString>;
     finalText: z.ZodNullable<z.ZodString>;
     childRunIds: z.ZodArray<z.ZodString>;
+    steps: z.ZodArray<z.ZodObject<{
+        seq: z.ZodNumber;
+        at: z.ZodString;
+        kind: z.ZodEnum<{
+            tool: "tool";
+            said: "said";
+        }>;
+        tool: z.ZodNullable<z.ZodString>;
+        summary: z.ZodString;
+        status: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>>;
+    stepsOmitted: z.ZodNumber;
+    stepsDropped: z.ZodNumber;
     coding: z.ZodNullable<z.ZodObject<{
         provider: z.ZodString;
         repository: z.ZodString;
@@ -484,6 +512,18 @@ export declare const ViewerEventSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
         issue_status: "issue_status";
         host_check: "host_check";
     }>;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"step">;
+    runId: z.ZodString;
+    seq: z.ZodNumber;
+    stepKind: z.ZodEnum<{
+        tool: "tool";
+        said: "said";
+    }>;
+    tool: z.ZodNullable<z.ZodString>;
+    summary: z.ZodString;
+    status: z.ZodNullable<z.ZodString>;
+    at: z.ZodString;
 }, z.core.$strip>], "kind">;
 export type RunTriggerInfo = z.infer<typeof RunTriggerSchema>;
 export type Outcome = z.infer<typeof OutcomeSchema>;
@@ -491,6 +531,7 @@ export type ServiceStatus = z.infer<typeof ServiceStatusSchema>;
 export type GraphRun = z.infer<typeof GraphRunSchema>;
 export type GraphSnapshot = z.infer<typeof GraphSnapshotSchema>;
 export type RunDetail = z.infer<typeof RunDetailSchema>;
+export type RunStepView = z.infer<typeof RunStepSchema>;
 export type ViewerEvent = z.infer<typeof ViewerEventSchema>;
 /** How this deployment runs coding jobs, for the desktop viewer's Infrastructure view (GET /admin/api/infra). */
 export declare const InfraInfoSchema: z.ZodObject<{
@@ -758,6 +799,19 @@ export declare const VIEWER_SCHEMAS: {
         error: z.ZodNullable<z.ZodString>;
         finalText: z.ZodNullable<z.ZodString>;
         childRunIds: z.ZodArray<z.ZodString>;
+        steps: z.ZodArray<z.ZodObject<{
+            seq: z.ZodNumber;
+            at: z.ZodString;
+            kind: z.ZodEnum<{
+                tool: "tool";
+                said: "said";
+            }>;
+            tool: z.ZodNullable<z.ZodString>;
+            summary: z.ZodString;
+            status: z.ZodNullable<z.ZodString>;
+        }, z.core.$strip>>;
+        stepsOmitted: z.ZodNumber;
+        stepsDropped: z.ZodNumber;
         coding: z.ZodNullable<z.ZodObject<{
             provider: z.ZodString;
             repository: z.ZodString;
@@ -813,6 +867,18 @@ export declare const VIEWER_SCHEMAS: {
             issue_status: "issue_status";
             host_check: "host_check";
         }>;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"step">;
+        runId: z.ZodString;
+        seq: z.ZodNumber;
+        stepKind: z.ZodEnum<{
+            tool: "tool";
+            said: "said";
+        }>;
+        tool: z.ZodNullable<z.ZodString>;
+        summary: z.ZodString;
+        status: z.ZodNullable<z.ZodString>;
+        at: z.ZodString;
     }, z.core.$strip>], "kind">;
     readonly "infra-info": z.ZodObject<{
         launcher: z.ZodEnum<{

package/dist/viewer/api-schema.js

@@ -123,10 +123,30 @@ export const GraphSnapshotSchema = z.object({
     runs: z.array(GraphRunSchema),
     spend: z.object({ todayUsd: z.number(), groups: z.array(BudgetGroupSpendSchema) }),
 });
+/**
+ * One recorded run step (docs/viewer-api.md): a tool call or what the model said, one line. Stored
+ * already redacted (src/core/run-steps/writer.ts); a step's call id and detail text are never sent.
+ */
+export const RunStepSchema = z.object({
+    seq: z.number().int(),
+    at: z.string(),
+    kind: z.enum(["tool", "said"]),
+    /** The tool's display name (`Bash`, `Edit`, `mcp:<tool>`); null for said. */
+    tool: z.string().nullable(),
+    summary: z.string(),
+    /** `ok`, `error` or `exit N` once the result is back; null until then and for said. */
+    status: z.string().nullable(),
+});
 export const RunDetailSchema = GraphRunSchema.extend({
     error: z.string().nullable(),
     finalText: z.string().nullable(),
     childRunIds: z.array(z.string()),
+    /** The run's newest steps (at most 200), oldest first; see `stepsOmitted` for earlier ones. */
+    steps: z.array(RunStepSchema),
+    /** Earlier recorded steps not included in `steps`. */
+    stepsOmitted: z.number().int(),
+    /** Steps past the per-run limit, never recorded. */
+    stepsDropped: z.number().int(),
     coding: z
         .object({
         provider: z.string(),
@@ -170,6 +190,17 @@ export const ViewerEventSchema = z.discriminatedUnion("kind", [
         /** Which table changed (the viewer NOTIFY trigger names them). */
         source: z.enum(["pull_request", "host_status", "issue_status", "host_check"]),
     }),
+    /** A run recorded a step, or a step's status arrived (the RunStep NOTIFY trigger). */
+    z.object({
+        kind: z.literal("step"),
+        runId: z.string(),
+        seq: RunStepSchema.shape.seq,
+        stepKind: RunStepSchema.shape.kind,
+        tool: RunStepSchema.shape.tool,
+        summary: RunStepSchema.shape.summary,
+        status: RunStepSchema.shape.status,
+        at: RunStepSchema.shape.at,
+    }),
 ]);
 /** How this deployment runs coding jobs, for the desktop viewer's Infrastructure view (GET /admin/api/infra). */
 export const InfraInfoSchema = z.object({

package/dist/viewer/graph.js

@@ -1,4 +1,5 @@
 import { periodStart } from "../core/budget-groups.js";
+import { codeProviderOf } from "../coding/code-host.js";
 import { publicCodingRunResult } from "../coding/protocol.js";
 const DEFAULT_SINCE_MS = 60 * 60 * 1000;
 const RELATIVE_SINCE_MS = {
@@ -102,7 +103,7 @@ function outcomesFor(row, pullRequests, sites) {
         !pullRequests.some((pr) => pr.url === result.pullRequestUrl)) {
         outcomes.push({
             kind: "pull_request",
-            provider: "github",
+            provider: codeProviderOf(result.repository),
             repository: result.repository,
             number: result.pullRequestNumber,
             url: result.pullRequestUrl,

package/dist/viewer/openapi.js

@@ -59,7 +59,7 @@ export const VIEWER_ROUTES = [
         path: "/admin/api/runs/{id}",
         operationId: "getRun",
         summary: "Run detail",
-        description: "Full detail for one run, including final text.",
+        description: "Full detail for one run, including final text and its newest steps.",
         parameters: [{ name: "id", in: "path", required: true, description: "Run id.", schema: { type: "string" } }],
         responses: {
             "200": { description: "The run.", content: { "application/json": { schema: ref("run-detail") } } },
@@ -85,6 +85,7 @@ export const VIEWER_ROUTES = [
             "- `retry: 3000`: suggested client reconnect delay in milliseconds.",
             '- `event: hello`: sent first. Data is `{"connected": <bool>}`, whether the server\'s live-event connection is up.',
             "- `event: run`, `event: service`, `event: outcome`: a run, coding-run service, or outcome changed. Each carries an `id:` line. Payloads match the `viewer-event` schema (see `x-event-schema`).",
+            "- `event: step`: a run recorded a step, or a step's status arrived. Carries an `id:` line. Data: the step's `seq`, `stepKind` (`tool` or `said`), `tool`, `summary` (redacted when it was recorded), `status` and `at`, never tool output.",
             '- `event: status`: the server\'s live-event connection changed. Data is `{"connected": <bool>}`.',
             "- `event: resync`: the live-event connection is up (again). Events may have been missed: refetch the graph.",
             `- \`: ping\`: comment sent every ${SSE_HEARTBEAT_MS / 1000} seconds to keep the connection open.`,

package/dist/viewer/run-detail.d.ts

@@ -2,4 +2,6 @@
 import type { PrismaClient } from "#prisma";
 import type { RunDetail } from "./api-schema.js";
 import { type IssueSites } from "./graph.js";
+/** The most steps a run detail carries: the newest, oldest first. */
+export declare const RUN_DETAIL_STEPS = 200;
 export declare function loadRunDetail(db: PrismaClient, runId: string, issueSites?: IssueSites): Promise<RunDetail | null>;

package/dist/viewer/run-detail.js

@@ -11,16 +11,19 @@ function serviceDetails(snapshot) {
         envNames: isRecord(s.testEnv) ? Object.keys(s.testEnv).sort() : [],
     }));
 }
+/** The most steps a run detail carries: the newest, oldest first. */
+export const RUN_DETAIL_STEPS = 200;
 export async function loadRunDetail(db, runId, issueSites = {}) {
     const [graphRun] = await loadGraphRuns(db, [runId], issueSites);
     if (!graphRun)
         return null;
-    const [row, children] = await Promise.all([
+    const [row, children, newest, stepCount] = await Promise.all([
         db.run.findUniqueOrThrow({
             where: { id: runId },
             select: {
                 error: true,
                 finalText: true,
+                stepsDropped: true,
                 codingRun: {
                     select: {
                         provider: true,
@@ -39,13 +42,35 @@ export async function loadRunDetail(db, runId, issueSites = {}) {
             select: { id: true },
             orderBy: [{ startedAt: "asc" }, { id: "asc" }],
         }),
+        // Stored already redacted; the call id and the detail text are never selected.
+        db.runStep.findMany({
+            where: { runId },
+            orderBy: { seq: "desc" },
+            take: RUN_DETAIL_STEPS,
+            select: { seq: true, at: true, kind: true, tool: true, summary: true, status: true },
+        }),
+        db.runStep.count({ where: { runId } }),
     ]);
+    const steps = newest
+        .reverse()
+        .filter((s) => s.kind === "tool" || s.kind === "said")
+        .map((s) => ({
+        seq: s.seq,
+        at: s.at.toISOString(),
+        kind: s.kind,
+        tool: s.tool,
+        summary: s.summary,
+        status: s.status,
+    }));
     const coding = row.codingRun;
     return {
         ...graphRun,
         error: row.error,
         finalText: row.finalText,
         childRunIds: children.map((c) => c.id),
+        steps,
+        stepsOmitted: Math.max(0, stepCount - newest.length),
+        stepsDropped: row.stepsDropped,
         coding: coding
             ? {
                 provider: coding.provider,