@wardby/cli 0.8.0 → 0.9.0

package/dist/providers/coding-proxy/proxy.d.ts

@@ -1,6 +1,9 @@
 import type { ModelPricing } from "../llm/pricing-core.js";
 import { capabilityHash } from "./capability-hash.js";
 import type { McpToolPin } from "../../core/mcp-tools.js";
+import { type StepCaptureOptions, type StreamStepExtractor } from "../../core/run-steps/extract.js";
+import { type RunStepsLevel } from "../../core/run-steps/config.js";
+import type { RunStepSubmitter } from "../../core/run-steps/types.js";
 import type { CredentialResolver, ProxyAuditSink, ProxyLedger, ProxyModelTerms, ProxyProtocol, ProxyRefusalRecord } from "./types.js";
 export declare const PROXY_MAX_BODY_BYTES: number;
 export declare const PROXY_MAX_OUTPUT_TOKENS = 1000000;
@@ -49,6 +52,8 @@ export interface CreateCodingProxySession {
     mcpTools?: McpToolPin[];
     /** SHA-256 (base64url) of the run's MCP token; the control plane mints and delivers the token itself. */
     mcpTokenHash?: string;
+    /** The run's level (Run.runStepsLevel), fixed at dispatch; absent counts as summary. */
+    runStepsLevel?: RunStepsLevel;
 }
 export interface CreatedCodingProxySession {
     id: string;
@@ -75,6 +80,19 @@ export interface CodingProxyOptions {
      * dependency cache's seal, ModelRequestSeal). Awaited; a failure is ignored, never the request's.
      */
     onModelRequest?: (runId: string) => Promise<void>;
+    /**
+     * Where coding runs' steps go (RunStepForwarder, to the control plane's run-steps listener);
+     * absent, no step is extracted. Steps are read from frames after they are relayed and handed over
+     * unmasked (the control plane redacts them by exact value before writing). Extraction never fails,
+     * delays or alters a relay, and nothing of it is logged or written to the proxy's database.
+     * Tool-result output (its end) is sent only for a session at detail under a detail ceiling; at off
+     * nothing is read.
+     */
+    steps?: RunStepSubmitter;
+    /** The proxy's own WARDBY_RUN_STEPS: a session captures detail only when this is detail too. Default summary. */
+    runStepsCeiling?: RunStepsLevel;
+    /** Tests only: replaces the stream step extractor. */
+    createStepExtractor?: (protocol: ProxyProtocol, options?: StepCaptureOptions) => StreamStepExtractor;
 }
 export { capabilityHash };
 export declare class CodingProxy {
@@ -88,6 +106,11 @@ export declare class CodingProxy {
     private readonly priceVersion;
     private readonly activeRequests;
     private readonly onModelRequest?;
+    private readonly steps?;
+    private readonly createStepExtractor?;
+    private readonly runStepsCeiling;
+    /** Results already handed over, per session: each request resends the history. */
+    private readonly seenResults;
     constructor(options: CodingProxyOptions);
     createSession(input: CreateCodingProxySession): Promise<CreatedCodingProxySession>;
     cancelSession(sessionId: string): Promise<void>;
@@ -106,6 +129,9 @@ export declare class CodingProxy {
     private complete;
     private forwardJson;
     private forwardStream;
+    /** Queues a step batch for the control plane. Best effort: any failure drops the steps, never the request. */
+    private submitSteps;
+    private newStepExtractor;
     /** Best effort: the executor reads it to name the failure; it must never break the relay. */
     private recordUpstreamFailure;
     private markUncertain;

package/dist/providers/coding-proxy/proxy.js

@@ -8,6 +8,10 @@ import { AnthropicSseUsageTracker, actualCostUsd, fingerprintRequest, parseAnthr
 import { conversationKey, estimateHold } from "./hold.js";
 import { estimateInterrupted, previousInput } from "./interrupted.js";
 import { createPinnedProxyFetch } from "./secure-fetch.js";
+import { resultsFromRequest, stepsFromJson, streamStepExtractor, } from "../../core/run-steps/extract.js";
+import { RUN_STEPS_LEVELS } from "../../core/run-steps/config.js";
+import { SeenIds } from "../../core/run-steps/seen.js";
+import { CLAUDE_RESULT_TOOL } from "../../core/run-steps/summarize.js";
 export const PROXY_MAX_BODY_BYTES = 8 * 1024 * 1024;
 export const PROXY_MAX_OUTPUT_TOKENS = 1_000_000;
 export const PROXY_DEFAULT_MAX_OUTPUT_TOKENS = 4_096;
@@ -32,7 +36,7 @@ const REQUEST_KEY_PATTERN = /^[\x21-\x7e]{1,200}$/;
 export const OPTIONAL_ANTHROPIC_BETAS = ["per-turn-control-2026-07-01"];
 const APPROVED_ANTHROPIC_BETAS = new Set([...CLAUDE_CODE_ANTHROPIC_BETAS, ...OPTIONAL_ANTHROPIC_BETAS]);
 const WARDBY_COMMAND_TOOL = "mcp__wardby_tools__run_command";
-const STRUCTURED_OUTPUT_TOOL = "StructuredOutput";
+const STRUCTURED_OUTPUT_TOOL = CLAUDE_RESULT_TOOL;
 const MAX_COMMAND_BYTES = 16 * 1024;
 const MAX_TOOL_TEXT_BYTES = 256 * 1024;
 /**
@@ -50,6 +54,13 @@ export class CodingProxyError extends Error {
         this.code = code;
     }
 }
+/** What this session's replies and requests are read for. */
+function stepCapture(session, ceiling) {
+    const level = session.runStepsLevel ?? "summary";
+    if (level === "off" || ceiling === "off")
+        return "none";
+    return level === "detail" && ceiling === "detail" ? "detail" : "summary";
+}
 export { capabilityHash };
 // OpenAI Responses allowlist. Everything a request may carry is listed here;
 // anything else is refused before a credential is resolved. It mirrors what the
@@ -915,9 +926,17 @@ export class CodingProxy {
     priceVersion;
     activeRequests = new Map();
     onModelRequest;
+    steps;
+    createStepExtractor;
+    runStepsCeiling;
+    /** Results already handed over, per session: each request resends the history. */
+    seenResults = new SeenIds();
     constructor(options) {
         this.ledger = options.ledger;
         this.onModelRequest = options.onModelRequest;
+        this.steps = options.steps;
+        this.createStepExtractor = options.createStepExtractor;
+        this.runStepsCeiling = options.runStepsCeiling ?? "summary";
         this.credentials = options.credentials;
         this.upstreamUrls = {
             "openai-responses": options.upstreamUrl ?? "https://api.openai.com/v1/responses",
@@ -973,6 +992,9 @@ export class CodingProxy {
         if (mcp && (!input.mcpTools || input.mcpTools.length === 0 || !input.mcpTokenHash)) {
             throw new Error("invalid_proxy_mcp_tools");
         }
+        if (input.runStepsLevel !== undefined && !RUN_STEPS_LEVELS.includes(input.runStepsLevel)) {
+            throw new Error("invalid_proxy_run_steps_level");
+        }
         const capability = `rrp_${randomBytes(32).toString("base64url")}`;
         const id = randomUUID();
         const registryTokenHash = capabilityHash(deriveRegistryToken(capability));
@@ -988,6 +1010,7 @@ export class CodingProxy {
             registryTokenHash,
             terms: input.terms,
             ...(mcp ? { mcpTools: input.mcpTools, mcpTokenHash: input.mcpTokenHash } : {}),
+            ...(input.runStepsLevel ? { runStepsLevel: input.runStepsLevel } : {}),
         });
         this.audit({ type: "session.created", runId: input.runId });
         return {
@@ -1001,6 +1024,7 @@ export class CodingProxy {
         };
     }
     async cancelSession(sessionId) {
+        this.seenResults.forget(sessionId);
         await this.ledger.cancelSession(sessionId);
         for (const controller of this.activeRequests.get(sessionId) ?? [])
             controller.abort();
@@ -1100,6 +1124,8 @@ export class CodingProxy {
             now: this.now(),
         });
         if (reservation.outcome === "inactive") {
+            // The session has ended (cancelled, expired or closed): another replica may have ended it.
+            this.seenResults.forget(session.id);
             this.audit({ type: "request.rejected", runId: session.runId, reason: reservation.reason });
             throw new CodingProxyError(403, `session_${reservation.reason}`);
         }
@@ -1129,6 +1155,14 @@ export class CodingProxy {
             model: request.model,
             ...holdAudit,
         });
+        // Run steps: the results this (validated) request carries for the previous turn, once per call id.
+        const capture = stepCapture(session, this.runStepsCeiling);
+        if (capture !== "none") {
+            this.submitSteps(input.bearer, session.runId, () => ({
+                steps: [],
+                results: this.seenResults.fresh(session.id, resultsFromRequest(session.protocol, parsed.body, { detail: capture === "detail" })),
+            }));
+        }
         let key;
         try {
             key = await this.credentials.resolve(session.credentialRef);
@@ -1148,6 +1182,7 @@ export class CodingProxy {
         }
         const remainingMs = session.deadlineAt.getTime() - this.now().getTime();
         if (remainingMs <= 0) {
+            this.seenResults.forget(session.id);
             await this.ledger.release(request.id, 403);
             throw new CodingProxyError(403, "session_expired");
         }
@@ -1221,9 +1256,9 @@ export class CodingProxy {
         }
         try {
             if (parsed.stream)
-                await this.forwardStream(session, request, upstream, sink, progress);
+                await this.forwardStream(session, request, upstream, sink, progress, input.bearer);
             else
-                await this.forwardJson(session, request, upstream, sink);
+                await this.forwardJson(session, request, upstream, sink, input.bearer);
         }
         catch (error) {
             await this.markUncertain(session, request, upstream.status, failureReason(error), responseHeadersOf(upstream), progress);
@@ -1293,7 +1328,7 @@ export class CodingProxy {
             throw new CodingProxyError(502, "reservation_invariant_violated");
         }
     }
-    async forwardJson(session, request, upstream, sink) {
+    async forwardJson(session, request, upstream, sink, capability) {
         const declaredLength = Number(upstream.headers.get("content-length"));
         if (Number.isFinite(declaredLength) && declaredLength > MAX_UPSTREAM_JSON_BYTES) {
             throw new Error("upstream_response_too_large");
@@ -1313,8 +1348,15 @@ export class CodingProxy {
         sink.start(upstream.status, { "content-type": "application/json", "cache-control": "no-store" });
         await safeWrite(sink, bytes, { value: true });
         sink.end();
+        const capture = stepCapture(session, this.runStepsCeiling);
+        if (capture !== "none") {
+            this.submitSteps(capability, session.runId, () => ({
+                steps: stepsFromJson(session.protocol, value, { detail: capture === "detail" }),
+                results: [],
+            }));
+        }
     }
-    async forwardStream(session, request, upstream, sink, progress) {
+    async forwardStream(session, request, upstream, sink, progress, capability) {
         if (!upstream.body)
             throw new Error("missing_upstream_body");
         sink.start(upstream.status, { "content-type": "text/event-stream", "cache-control": "no-store" });
@@ -1325,49 +1367,98 @@ export class CodingProxy {
         let completed = false;
         let failedWithoutUsage = false;
         const anthropicUsage = session.protocol === "anthropic-messages" ? (progress.anthropic = new AnthropicSseUsageTracker()) : undefined;
+        // Run steps: each frame is read after it was relayed. An extractor that throws is dropped, never the relay.
+        let steps = this.newStepExtractor(session);
+        const observe = (frame) => {
+            if (!steps)
+                return;
+            try {
+                steps.consume(frame);
+            }
+            catch {
+                steps = undefined;
+            }
+        };
         const body = upstream.body;
-        for await (const chunk of body) {
-            receivedBytes += chunk.byteLength;
-            if (receivedBytes > MAX_UPSTREAM_JSON_BYTES)
-                throw new Error("upstream_response_too_large");
-            buffer = (buffer + decoder.decode(chunk, { stream: true })).replaceAll("\r\n", "\n");
-            for (;;) {
-                const boundary = buffer.indexOf("\n\n");
-                if (boundary < 0)
-                    break;
-                const frame = buffer.slice(0, boundary);
-                buffer = buffer.slice(boundary + 2);
-                const terminal = anthropicUsage ? anthropicUsage.consume(frame) : terminalUsageFromSseFrame(frame);
-                if (!terminal.terminal) {
-                    progress.relayedOutputBytes += relayedTextBytes(frame, session.protocol);
-                    await safeWrite(sink, Buffer.from(`${frame}\n\n`), connected);
-                    continue;
-                }
-                if (!terminal.usage) {
-                    if (!terminal.failure)
-                        throw new Error("terminal_usage_missing");
-                    // The upstream failed the response and reported no usage. Pass its failure on so the
-                    // client sees the real error instead of a cut connection; the reservation stays held.
-                    await this.recordUpstreamFailure(session, terminal.failure);
-                    if (!completed) {
-                        await this.markUncertain(session, request, upstream.status, `upstream_failed:${terminal.failure}`, responseHeadersOf(upstream), progress);
+        try {
+            for await (const chunk of body) {
+                receivedBytes += chunk.byteLength;
+                if (receivedBytes > MAX_UPSTREAM_JSON_BYTES)
+                    throw new Error("upstream_response_too_large");
+                buffer = (buffer + decoder.decode(chunk, { stream: true })).replaceAll("\r\n", "\n");
+                for (;;) {
+                    const boundary = buffer.indexOf("\n\n");
+                    if (boundary < 0)
+                        break;
+                    const frame = buffer.slice(0, boundary);
+                    buffer = buffer.slice(boundary + 2);
+                    const terminal = anthropicUsage ? anthropicUsage.consume(frame) : terminalUsageFromSseFrame(frame);
+                    if (!terminal.terminal) {
+                        progress.relayedOutputBytes += relayedTextBytes(frame, session.protocol);
+                        await safeWrite(sink, Buffer.from(`${frame}\n\n`), connected);
+                        observe(frame);
+                        continue;
                     }
-                    failedWithoutUsage = true;
+                    if (!terminal.usage) {
+                        if (!terminal.failure)
+                            throw new Error("terminal_usage_missing");
+                        // The upstream failed the response and reported no usage. Pass its failure on so the
+                        // client sees the real error instead of a cut connection; the reservation stays held.
+                        await this.recordUpstreamFailure(session, terminal.failure);
+                        if (!completed) {
+                            await this.markUncertain(session, request, upstream.status, `upstream_failed:${terminal.failure}`, responseHeadersOf(upstream), progress);
+                        }
+                        failedWithoutUsage = true;
+                        await safeWrite(sink, Buffer.from(`${frame}\n\n`), connected);
+                        observe(frame);
+                        continue;
+                    }
+                    await this.complete(session, request, terminal.usage, upstream.status);
+                    completed = true;
                     await safeWrite(sink, Buffer.from(`${frame}\n\n`), connected);
-                    continue;
+                    observe(frame);
                 }
-                await this.complete(session, request, terminal.usage, upstream.status);
-                completed = true;
-                await safeWrite(sink, Buffer.from(`${frame}\n\n`), connected);
             }
+            buffer = (buffer + decoder.decode()).replaceAll("\r\n", "\n");
+            if (!completed && !failedWithoutUsage)
+                throw new Error("terminal_usage_missing");
+            if (buffer)
+                await safeWrite(sink, Buffer.from(buffer), connected);
+            if (connected.value)
+                sink.end();
+        }
+        finally {
+            // The reply's steps, also when the stream broke (then its open text is marked cut).
+            const extractor = steps;
+            if (extractor)
+                this.submitSteps(capability, session.runId, () => ({ steps: extractor.finish(), results: [] }));
+        }
+    }
+    /** Queues a step batch for the control plane. Best effort: any failure drops the steps, never the request. */
+    submitSteps(capability, runId, build) {
+        if (!this.steps)
+            return;
+        try {
+            const batch = build();
+            if (batch.steps.length > 0 || batch.results.length > 0)
+                this.steps.submit(capability, runId, batch);
+        }
+        catch {
+            // Dropped: steps are never a reason to fail a model request.
+        }
+    }
+    newStepExtractor(session) {
+        if (!this.steps)
+            return undefined;
+        const capture = stepCapture(session, this.runStepsCeiling);
+        if (capture === "none")
+            return undefined;
+        try {
+            return (this.createStepExtractor ?? streamStepExtractor)(session.protocol, { detail: capture === "detail" });
+        }
+        catch {
+            return undefined;
         }
-        buffer = (buffer + decoder.decode()).replaceAll("\r\n", "\n");
-        if (!completed && !failedWithoutUsage)
-            throw new Error("terminal_usage_missing");
-        if (buffer)
-            await safeWrite(sink, Buffer.from(buffer), connected);
-        if (connected.value)
-            sink.end();
     }
     /** Best effort: the executor reads it to name the failure; it must never break the relay. */
     async recordUpstreamFailure(session, code) {

package/dist/providers/coding-proxy/run-step-forwarder.d.ts

@@ -0,0 +1,42 @@
+import { type RunStepBatch, type RunStepSubmitter } from "../../core/run-steps/types.js";
+export declare const MAX_FORWARD_QUEUE = 256;
+/** A queue holds at most this many bytes of (estimated) serialized submissions. */
+export declare const MAX_FORWARD_QUEUE_BYTES: number;
+export interface RunStepForwarderOptions {
+    /** WARDBY_RUN_STEPS_URL, without a trailing slash. */
+    url: string;
+    fetchImpl?: typeof fetch;
+    maxQueue?: number;
+    maxQueueBytes?: number;
+    timeoutMs?: number;
+    /** How long flush() and close() wait for the queue to settle before giving up. */
+    flushTimeoutMs?: number;
+    log?: {
+        info(fields: Record<string, unknown>, message: string): void;
+    };
+}
+export declare class RunStepForwarder implements RunStepSubmitter {
+    private readonly options;
+    private queue;
+    private queueBytes;
+    private draining;
+    private scheduled;
+    private closed;
+    private inflight;
+    private dropped;
+    private readonly loggedReasons;
+    constructor(options: RunStepForwarderOptions);
+    submit(capability: string, runId: string, batch: RunStepBatch): void;
+    /** Resolves once everything submitted so far was posted or dropped, or after a bound. Never rejects. */
+    flush(): Promise<void>;
+    /** Stops accepting, waits at most the flush bound, then drops what is left and aborts the in-flight POST. */
+    close(): Promise<void>;
+    private kick;
+    private drain;
+    /**
+     * The capability goes in the Authorization header only. The response body is never read, and a
+     * failure is logged by a fixed reason: an error's or a response's text never reaches a log line.
+     */
+    private post;
+    private drop;
+}

package/dist/providers/coding-proxy/run-step-forwarder.js

@@ -0,0 +1,206 @@
+/**
+ * Hands coding runs' steps from the proxy to the control plane's run-steps listener
+ * (`POST <WARDBY_RUN_STEPS_URL>/internal/run-steps`, `Authorization: Bearer <the run capability>`).
+ * The proxy forwards raw step text over the authenticated in-cluster listener; the control plane
+ * redacts by exact value before anything is stored. Because the body is raw, this class never logs,
+ * echoes, or puts into an error any part of the body, the step text, or the capability: log lines
+ * carry a fixed reason and a count only.
+ *
+ * A bounded in-memory queue, drained one POST at a time off the relay path: a full queue or a slow
+ * or failing control plane drops steps and never delays a model request.
+ */
+import { logger } from "../../core/logger.js";
+import { MAX_RESULTS_PER_POST, MAX_RUN_STEPS_POST_BYTES, MAX_STEPS_PER_POST, RUN_STEPS_INGRESS_PATH, } from "../../core/run-steps/types.js";
+const forwarderLog = logger.child({ module: "coding-proxy" });
+export const MAX_FORWARD_QUEUE = 256;
+/** A queue holds at most this many bytes of (estimated) serialized submissions. */
+export const MAX_FORWARD_QUEUE_BYTES = 8 * 1024 * 1024;
+/** Margin over the listener's 15 s request limit (its write can take lock wait 5 s + transaction 10 s). */
+const DEFAULT_TIMEOUT_MS = 20_000;
+const DEFAULT_FLUSH_TIMEOUT_MS = 5_000;
+/** The envelope around the arrays, with slack for the runId. */
+const ENVELOPE_SLACK_BYTES = 1024;
+/** A cheap upper-ish bound on a batch's serialized size, with no stringify on the caller's stack. */
+function estimate(batch) {
+    let bytes = ENVELOPE_SLACK_BYTES;
+    for (const step of batch.steps) {
+        bytes += step.text.length * 3 + step.callId.length * 3 + 256;
+        if (step.kind === "tool")
+            bytes += (step.input?.length ?? 0) * 3;
+    }
+    for (const result of batch.results)
+        bytes += 128 + (result.output?.length ?? 0) * 3;
+    return bytes;
+}
+/** Splits by count and by serialized UTF-8 size, so no body passes MAX_RUN_STEPS_POST_BYTES. */
+function split(batch, runId) {
+    const parts = [];
+    const base = ENVELOPE_SLACK_BYTES + Buffer.byteLength(runId);
+    let steps = [];
+    let size = base;
+    for (const step of batch.steps) {
+        const bytes = Buffer.byteLength(JSON.stringify(step)) + 1;
+        if (steps.length > 0 && (steps.length >= MAX_STEPS_PER_POST || size + bytes > MAX_RUN_STEPS_POST_BYTES)) {
+            parts.push({ steps, results: [] });
+            steps = [];
+            size = base;
+        }
+        steps.push(step);
+        size += bytes;
+    }
+    if (steps.length > 0)
+        parts.push({ steps, results: [] });
+    let results = [];
+    let resultBytes = base;
+    for (const result of batch.results) {
+        const bytes = Buffer.byteLength(JSON.stringify(result)) + 1;
+        if (results.length > 0 &&
+            (results.length >= MAX_RESULTS_PER_POST || resultBytes + bytes > MAX_RUN_STEPS_POST_BYTES)) {
+            parts.push({ steps: [], results });
+            results = [];
+            resultBytes = base;
+        }
+        results.push(result);
+        resultBytes += bytes;
+    }
+    if (results.length > 0)
+        parts.push({ steps: [], results });
+    return parts;
+}
+export class RunStepForwarder {
+    options;
+    queue = [];
+    queueBytes = 0;
+    draining;
+    scheduled = false;
+    closed = false;
+    inflight;
+    dropped = 0;
+    loggedReasons = new Set();
+    constructor(options) {
+        this.options = options;
+    }
+    submit(capability, runId, batch) {
+        try {
+            if (this.closed)
+                return this.drop("closed");
+            const size = estimate(batch);
+            if (this.queue.length >= (this.options.maxQueue ?? MAX_FORWARD_QUEUE) ||
+                this.queueBytes + size > (this.options.maxQueueBytes ?? MAX_FORWARD_QUEUE_BYTES)) {
+                return this.drop("queue_full");
+            }
+            this.queue.push({ capability, runId, batch, estimate: size });
+            this.queueBytes += size;
+            this.kick();
+        }
+        catch {
+            this.drop("submit_failed");
+        }
+    }
+    /** Resolves once everything submitted so far was posted or dropped, or after a bound. Never rejects. */
+    async flush() {
+        let timer;
+        const bound = new Promise((resolve) => {
+            timer = setTimeout(resolve, this.options.flushTimeoutMs ?? DEFAULT_FLUSH_TIMEOUT_MS);
+            timer.unref();
+        });
+        const settled = (async () => {
+            while (this.draining || this.scheduled)
+                await (this.draining ?? new Promise((r) => setImmediate(r)));
+        })().catch(() => undefined);
+        await Promise.race([settled, bound]);
+        clearTimeout(timer);
+    }
+    /** Stops accepting, waits at most the flush bound, then drops what is left and aborts the in-flight POST. */
+    async close() {
+        this.closed = true;
+        await this.flush();
+        const left = this.queue.length;
+        this.queue = [];
+        this.queueBytes = 0;
+        for (let n = 0; n < left; n += 1)
+            this.drop("closed");
+        this.inflight?.abort();
+    }
+    kick() {
+        if (this.draining || this.scheduled || this.queue.length === 0)
+            return;
+        this.scheduled = true;
+        // Off the caller's stack: the first serialization must not run on the relay path.
+        setImmediate(() => {
+            this.scheduled = false;
+            if (this.draining || this.queue.length === 0)
+                return;
+            this.draining = this.drain().finally(() => {
+                this.draining = undefined;
+                this.kick();
+            });
+        });
+    }
+    async drain() {
+        for (let next = this.queue.shift(); next; next = this.queue.shift()) {
+            this.queueBytes -= next.estimate;
+            if (this.closed) {
+                this.drop("closed");
+                continue;
+            }
+            let bodies;
+            try {
+                bodies = split(next.batch, next.runId).map((part) => JSON.stringify({ runId: next.runId, ...part }));
+            }
+            catch {
+                this.drop("serialize_failed");
+                continue;
+            }
+            for (const body of bodies) {
+                if (this.closed)
+                    this.drop("closed");
+                else
+                    await this.post(next.capability, body);
+            }
+        }
+    }
+    /**
+     * The capability goes in the Authorization header only. The response body is never read, and a
+     * failure is logged by a fixed reason: an error's or a response's text never reaches a log line.
+     */
+    async post(capability, body) {
+        const controller = new AbortController();
+        this.inflight = controller;
+        const timer = setTimeout(() => controller.abort(), this.options.timeoutMs ?? DEFAULT_TIMEOUT_MS);
+        timer.unref();
+        try {
+            const response = await (this.options.fetchImpl ?? fetch)(`${this.options.url}${RUN_STEPS_INGRESS_PATH}`, {
+                method: "POST",
+                headers: { authorization: `Bearer ${capability}`, "content-type": "application/json" },
+                body,
+                redirect: "error",
+                signal: controller.signal,
+            });
+            await response.body?.cancel().catch(() => undefined);
+            if (!response.ok)
+                this.drop(`http_${response.status}`);
+        }
+        catch {
+            this.drop(this.closed ? "closed" : controller.signal.aborted ? "timeout" : "unreachable");
+        }
+        finally {
+            clearTimeout(timer);
+            if (this.inflight === controller)
+                this.inflight = undefined;
+        }
+    }
+    drop(reason) {
+        this.dropped += 1;
+        const first = !this.loggedReasons.has(reason);
+        this.loggedReasons.add(reason);
+        if (first || this.dropped % 100 === 0) {
+            try {
+                (this.options.log ?? forwarderLog).info({ event: "run_steps.forward_dropped", reason, droppedParts: this.dropped }, "coding proxy: run steps not delivered to the control plane");
+            }
+            catch {
+                // logging must never break the relay
+            }
+        }
+    }
+}

package/dist/providers/coding-proxy/runtime.d.ts

@@ -20,6 +20,13 @@ export declare function createRegistryUpstream(pinned: typeof globalThis.fetch):
  * without credentials, query or fragment stops start-up (the value is not echoed).
  */
 export declare function loadMcpGatewayUrl(env: NodeJS.ProcessEnv): string | undefined;
+/**
+ * WARDBY_RUN_STEPS_URL: the control plane's run-steps listener (WARDBY_RUN_STEPS_LISTEN on the
+ * server), which the proxy posts coding runs' steps to. Unset or empty: coding runs record no steps.
+ * Anything but an http(s) origin without credentials, path, query or fragment stops start-up (the
+ * value is not echoed, so a credential in it never reaches a log).
+ */
+export declare function loadRunStepsUrl(env: NodeJS.ProcessEnv): string | undefined;
 export interface CodingProxyRuntimeOptions {
     db: PrismaClient;
     /** The package registry's own client, so its traffic (many concurrent