@wardby/cli 0.5.3 → 0.7.0

package/dist/coding/protocol.d.ts

@@ -2,14 +2,32 @@ import { z } from "zod";
 export declare const CODING_PROTOCOL_VERSION: 1;
 /** The code host every coding run's repository and pull request live on (see pullRequestUrlSchema); the one place to change when another is added. */
 export declare const CODING_CODE_PROVIDER = "github";
+/** result.json and the agent output file: room for a full summary and test list, JSON-escaped. */
 export declare const MAX_CODING_ARTIFACT_BYTES: number;
+/** The worker input artifact (input.json): larger than results because it can carry Claude Code repo context. */
+export declare const MAX_CODING_INPUT_BYTES: number;
+/** Bounds on CodingTaskInput.claudeContext, enforced by the builder (src/coding/claude-context.ts) and this schema. */
+export declare const CLAUDE_CONTEXT_LIMITS: {
+    readonly maxFiles: 200;
+    readonly maxFileBytes: number;
+    readonly maxTotalBytes: number;
+};
 export declare const MAX_CODING_TASK_BYTES: number;
 /** Room reserved at the end of a composed task for lines the executor appends (e.g. the base commit). */
 export declare const CODING_TASK_TRAILER_RESERVE_BYTES = 256;
+/**
+ * A coding run's summary (the agent's final message, posted as the PR body):
+ * longer text is cut at a line boundary with SUMMARY_TRUNCATED_MARKER rather
+ * than failing the run.
+ */
 export declare const MAX_CODING_SUMMARY_BYTES: number;
+export declare const SUMMARY_TRUNCATED_MARKER = "\n\n[summary truncated]";
 export declare const MAX_CODING_TESTS = 64;
 export declare const MAX_CODING_TEST_COMMAND_BYTES: number;
 export declare const MAX_TAG_BYTES = 32;
+/** The workspace volume bounds every launcher enforces (docker-isolation.ts, kubernetes-isolation.ts). */
+export declare const MIN_CODING_DISK_MB = 64;
+export declare const MAX_CODING_DISK_MB = 32768;
 /**
  * Coding-run services (docs/coding-services.md): the catalog name and version
  * grammar, shared by the repository's .wardby/services.yaml, the catalog, and
@@ -32,9 +50,15 @@ export declare const MAX_CODING_OUTPUT_ISSUES = 8;
 export declare const SAFE_CODING_OUTPUT_ISSUE: RegExp;
 export declare const INVALID_SINGLE_LINE_CONTROL: RegExp;
 export declare function byteLength(value: string): number;
+/**
+ * `text` unchanged when `measure(text) <= max`; otherwise its longest prefix
+ * that fits with `marker` appended, cut back to the last line break when one
+ * is in the second half, and never inside a surrogate pair.
+ */
+export declare function truncateText(text: string, max: number, measure?: (value: string) => number, marker?: string): string;
 export declare function isReservedServiceEnvName(name: string): boolean;
 /** The variables one service hands the agent's shells: upper-case names wardby does not reserve. */
-export declare const CodingServiceTestEnvSchema: z.ZodEffects<z.ZodRecord<z.ZodString, z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>>, Record<string, string>, Record<string, string>>;
+export declare const CodingServiceTestEnvSchema: z.ZodRecord<z.ZodString, z.ZodString>;
 export declare function normalizeGitHubRepository(value: string): string;
 export declare function normalizeGitRef(value: string): string;
 /** Repository identity prefix for a git folder on the wardby host: `local:/abs/path`. */
@@ -48,8 +72,8 @@ export declare const MAX_LOCAL_REPOSITORY_BYTES = 4096;
  * (no trailing slash).
  */
 export declare function normalizeLocalRepository(value: string): string;
-export declare const CodingBaseRefSchema: z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>;
-export declare const CodingTaskOverrideSchema: z.ZodEffects<z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>, string, string>;
+export declare const CodingBaseRefSchema: z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>;
+export declare const CodingTaskOverrideSchema: z.ZodString;
 /**
  * A section rendered to fit whatever room the task leaves (the knowledge note:
  * src/knowledge/note.ts). Declared structurally so this module, which coding
@@ -80,171 +104,108 @@ export declare function composeCodingTask(instructions: string | null | undefine
  * re-validates whatever survives.
  */
 export declare function normalizeCodingTag(value: unknown): string | null | undefined;
+/**
+ * The tag schemas' type. Zod 4 types a transform's output key as required, but
+ * an absent tag still parses to an absent key (as under Zod 3), so the type
+ * keeps the key optional. Types only: the emitted protocol.js is unchanged.
+ */
+type OptionalTagSchema = z.ZodOptional<z.ZodType<string | undefined, string | null | undefined>>;
 /** Upper bound on CodingAgentProfile.maxTurns (Claude Code runs). */
 export declare const MAX_CODING_TURNS = 1000;
 /** The Claude Code worker's turn limit when the agent sets none; the run's budget and timeout are the real limits. */
 export declare const DEFAULT_CLAUDE_MAX_TURNS = 200;
+/**
+ * The most output tokens per model reply on a Claude Code run when the agent sets
+ * none (CodingAgentProfile.maxOutputTokens); thinking counts toward it. The coding
+ * proxy reserves maxOutputTokens x the model's output price per request against
+ * the run budget, so higher values need a larger budget.
+ */
+export declare const DEFAULT_CLAUDE_MAX_OUTPUT_TOKENS = 32000;
+/** Bounds on CodingAgentProfile.maxOutputTokens (Claude Code runs). */
+export declare const MIN_CLAUDE_MAX_OUTPUT_TOKENS = 1024;
+export declare const MAX_CLAUDE_MAX_OUTPUT_TOKENS = 128000;
 /** Longest line a debug-traced worker writes to its log (src/coding-worker/debug-trace.ts). */
 export declare const MAX_DEBUG_TRACE_LINE_BYTES: number;
-export declare const CodingTaskInputSchema: z.ZodEffects<z.ZodObject<{
+/** A traced run's total trace output when the agent sets no cap (CodingAgentProfile.debugTraceMaxMb), in MiB. */
+export declare const DEFAULT_DEBUG_TRACE_MAX_MB = 2;
+/** Upper bound on CodingAgentProfile.debugTraceMaxMb. */
+export declare const MAX_DEBUG_TRACE_MAX_MB = 64;
+/**
+ * A repo-relative POSIX path with no empty, ".", or ".." segment, no backslash, no control
+ * character, and nothing under .git.
+ */
+export declare function isSafeContextPath(path: string): boolean;
+/**
+ * Whether a Claude Code context file may be shipped to (and written by) the worker: a safe path
+ * that is CLAUDE.md, .claude/CLAUDE.md, AGENTS.md, a .claude/skills/<name>/SKILL.md, or any other
+ * Markdown file outside every .claude directory that is not a CLAUDE.local.md. This keeps
+ * repository settings, hooks, MCP configuration, agents, commands, and personal memory out of
+ * Claude Code's native loading. Not part of the input schema: a refused file is dropped, and never
+ * fails the run.
+ */
+export declare function isAllowedContextPath(path: string): boolean;
+export declare const ClaudeContextFileSchema: z.ZodObject<{
+    path: z.ZodString;
+    content: z.ZodString;
+}, z.core.$strict>;
+export type ClaudeContextFile = z.infer<typeof ClaudeContextFileSchema>;
+export declare const CodingTaskInputSchema: z.ZodObject<{
     schemaVersion: z.ZodLiteral<1>;
-    runId: z.ZodEffects<z.ZodEffects<z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>, string, string>, string, string>;
-    repository: z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>;
-    baseRef: z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>;
-    headRef: z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>;
-    task: z.ZodEffects<z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>, string, string>;
-    model: z.ZodEffects<z.ZodEffects<z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>, string, string>, string, string>;
+    runId: z.ZodString;
+    repository: z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>;
+    baseRef: z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>;
+    headRef: z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>;
+    task: z.ZodString;
+    model: z.ZodString;
     budgetUsd: z.ZodNumber;
     deadlineAt: z.ZodString;
-    /**
-     * Revision-in-place: set when this run pushes a new commit onto the
-     * branch/PR the named run
-     * (the thread's ROOT CodingRun, always -- never a chain) originally
-     * opened, instead of opening a fresh branch of its own. Resolved and
-     * verified server-side (dispatch.ts) against the database; this schema
-     * only enforces that headRef is internally consistent with it.
-     */
     continuationOf: z.ZodOptional<z.ZodObject<{
-        runId: z.ZodEffects<z.ZodEffects<z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>, string, string>, string, string>;
-    }, "strict", z.ZodTypeAny, {
-        runId: string;
-    }, {
-        runId: string;
-    }>>;
-    /**
-     * Admin-requested debug trace (CodingAgentProfile.debugTraceUntil): the
-     * worker writes its full stream trace to its own log. Absent means off;
-     * the control plane writes the key only when true, so an input for an
-     * untraced run is unchanged for workers that predate it.
-     */
+        runId: z.ZodString;
+    }, z.core.$strict>>;
     debugTrace: z.ZodOptional<z.ZodBoolean>;
-    /**
-     * Claude Code turn limit (CodingAgentProfile.maxTurns, fixed on the run at
-     * dispatch). Absent means the worker default; written only when the agent
-     * sets one, so other runs' input is unchanged for workers that predate it.
-     */
+    dependencyCache: z.ZodOptional<z.ZodLiteral<true>>;
+    sessionResume: z.ZodOptional<z.ZodLiteral<true>>;
+    diskMb: z.ZodOptional<z.ZodNumber>;
+    debugTraceMaxMb: z.ZodOptional<z.ZodNumber>;
     maxTurns: z.ZodOptional<z.ZodNumber>;
-    /**
-     * Coding-run services started next to this run (docs/coding-services.md):
-     * each one's catalog name and version, and the variables the agent's shells
-     * receive. Absent means none; the control plane writes the key only when a
-     * run has services, so every other input is unchanged for workers that
-     * predate it.
-     */
+    maxOutputTokens: z.ZodOptional<z.ZodNumber>;
     services: z.ZodOptional<z.ZodArray<z.ZodObject<{
         name: z.ZodString;
         version: z.ZodString;
-        testEnv: z.ZodEffects<z.ZodRecord<z.ZodString, z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>>, Record<string, string>, Record<string, string>>;
-    }, "strict", z.ZodTypeAny, {
-        name: string;
-        version: string;
-        testEnv: Record<string, string>;
-    }, {
-        name: string;
-        version: string;
-        testEnv: Record<string, string>;
-    }>, "many">>;
-}, "strict", z.ZodTypeAny, {
-    repository: string;
-    schemaVersion: 1;
-    runId: string;
-    baseRef: string;
-    headRef: string;
-    task: string;
-    model: string;
-    budgetUsd: number;
-    deadlineAt: string;
-    continuationOf?: {
-        runId: string;
-    } | undefined;
-    debugTrace?: boolean | undefined;
-    maxTurns?: number | undefined;
-    services?: {
-        name: string;
-        version: string;
-        testEnv: Record<string, string>;
-    }[] | undefined;
-}, {
-    repository: string;
-    schemaVersion: 1;
-    runId: string;
-    baseRef: string;
-    headRef: string;
-    task: string;
-    model: string;
-    budgetUsd: number;
-    deadlineAt: string;
-    continuationOf?: {
-        runId: string;
-    } | undefined;
-    debugTrace?: boolean | undefined;
-    maxTurns?: number | undefined;
-    services?: {
-        name: string;
-        version: string;
-        testEnv: Record<string, string>;
-    }[] | undefined;
-}>, {
-    repository: string;
-    schemaVersion: 1;
-    runId: string;
-    baseRef: string;
-    headRef: string;
-    task: string;
-    model: string;
-    budgetUsd: number;
-    deadlineAt: string;
-    continuationOf?: {
-        runId: string;
-    } | undefined;
-    debugTrace?: boolean | undefined;
-    maxTurns?: number | undefined;
-    services?: {
-        name: string;
-        version: string;
-        testEnv: Record<string, string>;
-    }[] | undefined;
-}, {
-    repository: string;
-    schemaVersion: 1;
-    runId: string;
-    baseRef: string;
-    headRef: string;
-    task: string;
-    model: string;
-    budgetUsd: number;
-    deadlineAt: string;
-    continuationOf?: {
-        runId: string;
-    } | undefined;
-    debugTrace?: boolean | undefined;
-    maxTurns?: number | undefined;
-    services?: {
-        name: string;
-        version: string;
-        testEnv: Record<string, string>;
-    }[] | undefined;
-}>;
-export declare const CodingAgentOutputSchema: z.ZodEffects<z.ZodObject<{
+        testEnv: z.ZodRecord<z.ZodString, z.ZodString>;
+    }, z.core.$strict>>>;
+    repoSkills: z.ZodOptional<z.ZodBoolean>;
+    claudeBareMode: z.ZodOptional<z.ZodBoolean>;
+    claudeContext: z.ZodOptional<z.ZodObject<{
+        files: z.ZodArray<z.ZodObject<{
+            path: z.ZodString;
+            content: z.ZodString;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+/** What the model returns. Strict: it can never carry a worker-written field such as dependencyCache. */
+export declare const CodingAgentOutputSchema: z.ZodPipe<z.ZodObject<{
     schemaVersion: z.ZodLiteral<1>;
-    runId: z.ZodEffects<z.ZodEffects<z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>, string, string>, string, string>;
-    outcome: z.ZodEnum<["changes_ready", "no_changes", "budget_exhausted"]>;
-    summary: z.ZodEffects<z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>, string, string>;
+    runId: z.ZodString;
+    outcome: z.ZodEnum<{
+        changes_ready: "changes_ready";
+        no_changes: "no_changes";
+        budget_exhausted: "budget_exhausted";
+    }>;
+    summary: z.ZodPreprocess<z.ZodString, unknown>;
     tests: z.ZodArray<z.ZodObject<{
-        command: z.ZodEffects<z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>, string, string>;
-        outcome: z.ZodEnum<["passed", "failed", "skipped"]>;
-    }, "strict", z.ZodTypeAny, {
-        command: string;
-        outcome: "passed" | "failed" | "skipped";
-    }, {
-        command: string;
-        outcome: "passed" | "failed" | "skipped";
-    }>, "many">;
-    tag: z.ZodEffects<z.ZodEffects<z.ZodOptional<z.ZodNullable<z.ZodString>>, string | undefined, string | null | undefined>, string | undefined, unknown>;
-}, "strict", z.ZodTypeAny, {
-    outcome: "changes_ready" | "no_changes" | "budget_exhausted";
+        command: z.ZodString;
+        outcome: z.ZodEnum<{
+            passed: "passed";
+            failed: "failed";
+            skipped: "skipped";
+        }>;
+    }, z.core.$strict>>;
+    tag: OptionalTagSchema;
+}, z.core.$strict>, z.ZodTransform<{
     schemaVersion: 1;
     runId: string;
+    outcome: "changes_ready" | "no_changes" | "budget_exhausted";
     summary: string;
     tests: {
         command: string;
@@ -252,160 +213,217 @@ export declare const CodingAgentOutputSchema: z.ZodEffects<z.ZodObject<{
     }[];
     tag?: string | undefined;
 }, {
-    outcome: "changes_ready" | "no_changes" | "budget_exhausted";
     schemaVersion: 1;
     runId: string;
+    outcome: "changes_ready" | "no_changes" | "budget_exhausted";
     summary: string;
     tests: {
         command: string;
         outcome: "passed" | "failed" | "skipped";
     }[];
-    tag?: unknown;
-}>, {
     tag?: string | undefined;
+}>>;
+/**
+ * The run's dependency cache (src/coding-worker/dependency-cache.mjs), as the worker reports it in
+ * result.json and the control plane stores it (CodingRun.dependencyCacheResult, get_run). Worker-
+ * written, never model-written: the model's output schema above refuses the key. Only stable codes,
+ * repository folder names and bounded numbers; never npm output.
+ */
+export declare const MAX_DEPENDENCY_CACHE_PROJECTS = 4;
+export declare const DEPENDENCY_CACHE_OUTCOMES: readonly ["hit", "nearest", "cold", "skipped", "refused"];
+export declare const DEPENDENCY_CACHE_REBUILD_OUTCOMES: readonly ["ok", "failed", "timeout", "skipped", "unsealed"];
+/** "." or up to three folder segments: the proxy's project-path rule (dependency-cache/key.ts). */
+export declare const DEPENDENCY_CACHE_PATH: RegExp;
+declare const dependencyCacheProjectSchema: z.ZodObject<{
+    path: z.ZodString;
+    result: z.ZodEnum<{
+        skipped: "skipped";
+        hit: "hit";
+        nearest: "nearest";
+        cold: "cold";
+        refused: "refused";
+    }>;
+    key: z.ZodOptional<z.ZodString>;
+    sizeBytes: z.ZodOptional<z.ZodNumber>;
+    restoreMs: z.ZodOptional<z.ZodNumber>;
+    installMs: z.ZodOptional<z.ZodNumber>;
+    reason: z.ZodOptional<z.ZodString>;
+    rebuild: z.ZodOptional<z.ZodEnum<{
+        failed: "failed";
+        skipped: "skipped";
+        ok: "ok";
+        timeout: "timeout";
+        unsealed: "unsealed";
+    }>>;
+}, z.core.$strict>;
+export declare const DependencyCacheReportSchema: z.ZodObject<{
+    projects: z.ZodArray<z.ZodObject<{
+        path: z.ZodString;
+        result: z.ZodEnum<{
+            skipped: "skipped";
+            hit: "hit";
+            nearest: "nearest";
+            cold: "cold";
+            refused: "refused";
+        }>;
+        key: z.ZodOptional<z.ZodString>;
+        sizeBytes: z.ZodOptional<z.ZodNumber>;
+        restoreMs: z.ZodOptional<z.ZodNumber>;
+        installMs: z.ZodOptional<z.ZodNumber>;
+        reason: z.ZodOptional<z.ZodString>;
+        rebuild: z.ZodOptional<z.ZodEnum<{
+            failed: "failed";
+            skipped: "skipped";
+            ok: "ok";
+            timeout: "timeout";
+            unsealed: "unsealed";
+        }>>;
+    }, z.core.$strict>>;
+    omitted: z.ZodOptional<z.ZodNumber>;
+    reason: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export type DependencyCacheProject = z.infer<typeof dependencyCacheProjectSchema>;
+export type DependencyCacheReport = z.infer<typeof DependencyCacheReportSchema>;
+/**
+ * Bounds whatever the module (or a tool runner over its socket) returned into a report: projects
+ * that don't fit the schema are dropped and counted in `omitted`; past the cap, installed and
+ * refused projects are kept ahead of skipped ones, in their original order. A value that isn't a
+ * report at all becomes `{ projects: [], reason: "report_invalid" }`. Never throws.
+ */
+export declare function sanitizeDependencyCacheReport(value: unknown): DependencyCacheReport;
+/** Folders the dependency cache installed (hit, nearest or cold), "." for the repository root. */
+export declare function installedDependencyFolders(report: DependencyCacheReport | undefined): string[];
+/** Folders whose node_modules came from a cached snapshot (hit or nearest): the PR body's line. */
+export declare function restoredDependencyFolders(report: DependencyCacheReport | undefined): string[];
+/** The one line both workers add to the agent's prompt when dependencies were installed; else undefined. */
+export declare function dependencyCacheTaskNote(report: DependencyCacheReport | undefined): string | undefined;
+/**
+ * What a worker writes to result.json and the control plane reads back: the model's output plus
+ * worker-written fields. `dependencyCache` is written only on a run whose input asked for it, so an
+ * older control plane never sees the key; a malformed one is bounded (sanitizeDependencyCacheReport)
+ * rather than failing the run.
+ */
+export declare const CodingWorkerOutputSchema: z.ZodPipe<z.ZodObject<{
+    dependencyCache: z.ZodPipe<z.ZodOptional<z.ZodUnknown>, z.ZodTransform<{
+        projects: {
+            path: string;
+            result: "skipped" | "hit" | "nearest" | "cold" | "refused";
+            key?: string | undefined;
+            sizeBytes?: number | undefined;
+            restoreMs?: number | undefined;
+            installMs?: number | undefined;
+            reason?: string | undefined;
+            rebuild?: "failed" | "skipped" | "ok" | "timeout" | "unsealed" | undefined;
+        }[];
+        omitted?: number | undefined;
+        reason?: string | undefined;
+    } | undefined, unknown>>;
+    schemaVersion: z.ZodLiteral<1>;
+    runId: z.ZodString;
+    outcome: z.ZodEnum<{
+        changes_ready: "changes_ready";
+        no_changes: "no_changes";
+        budget_exhausted: "budget_exhausted";
+    }>;
+    summary: z.ZodPreprocess<z.ZodString, unknown>;
+    tests: z.ZodArray<z.ZodObject<{
+        command: z.ZodString;
+        outcome: z.ZodEnum<{
+            passed: "passed";
+            failed: "failed";
+            skipped: "skipped";
+        }>;
+    }, z.core.$strict>>;
+    tag: OptionalTagSchema;
+}, z.core.$strict>, z.ZodTransform<{
+    dependencyCache?: {
+        projects: {
+            path: string;
+            result: "skipped" | "hit" | "nearest" | "cold" | "refused";
+            key?: string | undefined;
+            sizeBytes?: number | undefined;
+            restoreMs?: number | undefined;
+            installMs?: number | undefined;
+            reason?: string | undefined;
+            rebuild?: "failed" | "skipped" | "ok" | "timeout" | "unsealed" | undefined;
+        }[];
+        omitted?: number | undefined;
+        reason?: string | undefined;
+    } | undefined;
+    schemaVersion: 1;
+    runId: string;
+    outcome: "changes_ready" | "no_changes" | "budget_exhausted";
     summary: string;
     tests: {
         command: string;
         outcome: "passed" | "failed" | "skipped";
     }[];
-    outcome: "changes_ready" | "no_changes" | "budget_exhausted";
-    schemaVersion: 1;
-    runId: string;
+    tag?: string | undefined;
 }, {
-    outcome: "changes_ready" | "no_changes" | "budget_exhausted";
+    dependencyCache: {
+        projects: {
+            path: string;
+            result: "skipped" | "hit" | "nearest" | "cold" | "refused";
+            key?: string | undefined;
+            sizeBytes?: number | undefined;
+            restoreMs?: number | undefined;
+            installMs?: number | undefined;
+            reason?: string | undefined;
+            rebuild?: "failed" | "skipped" | "ok" | "timeout" | "unsealed" | undefined;
+        }[];
+        omitted?: number | undefined;
+        reason?: string | undefined;
+    } | undefined;
     schemaVersion: 1;
     runId: string;
+    outcome: "changes_ready" | "no_changes" | "budget_exhausted";
     summary: string;
     tests: {
         command: string;
         outcome: "passed" | "failed" | "skipped";
     }[];
-    tag?: unknown;
-}>;
-export declare const CodingRunResultSchema: z.ZodEffects<z.ZodEffects<z.ZodObject<{
+    tag?: string | undefined;
+}>>;
+export declare const CodingRunResultSchema: z.ZodPipe<z.ZodObject<{
     schemaVersion: z.ZodLiteral<1>;
-    outcome: z.ZodEnum<["pull_request_opened", "pull_request_updated", "branch_pushed", "no_changes", "budget_exhausted"]>;
-    repository: z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>;
-    baseRef: z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>;
-    headRef: z.ZodOptional<z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>>;
-    commitSha: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
-    pullRequestUrl: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
+    outcome: z.ZodEnum<{
+        no_changes: "no_changes";
+        budget_exhausted: "budget_exhausted";
+        pull_request_opened: "pull_request_opened";
+        pull_request_updated: "pull_request_updated";
+        branch_pushed: "branch_pushed";
+    }>;
+    repository: z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>;
+    baseRef: z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>;
+    headRef: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>>;
+    commitSha: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>>;
+    pullRequestUrl: z.ZodOptional<z.ZodString>;
     pullRequestNumber: z.ZodOptional<z.ZodNumber>;
-    summary: z.ZodEffects<z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>, string, string>;
+    summary: z.ZodPreprocess<z.ZodString, unknown>;
     tests: z.ZodArray<z.ZodObject<{
-        command: z.ZodEffects<z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>, string, string>;
-        outcome: z.ZodEnum<["passed", "failed", "skipped"]>;
-    }, "strict", z.ZodTypeAny, {
-        command: string;
-        outcome: "passed" | "failed" | "skipped";
-    }, {
-        command: string;
-        outcome: "passed" | "failed" | "skipped";
-    }>, "many">;
+        command: z.ZodString;
+        outcome: z.ZodEnum<{
+            passed: "passed";
+            failed: "failed";
+            skipped: "skipped";
+        }>;
+    }, z.core.$strict>>;
     usage: z.ZodObject<{
         tokensIn: z.ZodNumber;
         tokensOut: z.ZodNumber;
         costUsd: z.ZodNumber;
-    }, "strict", z.ZodTypeAny, {
-        tokensIn: number;
-        tokensOut: number;
-        costUsd: number;
-    }, {
-        tokensIn: number;
-        tokensOut: number;
-        costUsd: number;
-    }>;
-    tag: z.ZodEffects<z.ZodOptional<z.ZodNullable<z.ZodString>>, string | undefined, string | null | undefined>;
-}, "strict", z.ZodTypeAny, {
-    repository: string;
-    outcome: "no_changes" | "budget_exhausted" | "pull_request_opened" | "pull_request_updated" | "branch_pushed";
-    schemaVersion: 1;
-    baseRef: string;
-    summary: string;
-    tests: {
-        command: string;
-        outcome: "passed" | "failed" | "skipped";
-    }[];
-    usage: {
-        tokensIn: number;
-        tokensOut: number;
-        costUsd: number;
-    };
-    headRef?: string | undefined;
+    }, z.core.$strict>;
+    tag: OptionalTagSchema;
+}, z.core.$strict>, z.ZodTransform<{
     tag?: string | undefined;
-    commitSha?: string | undefined;
-    pullRequestUrl?: string | undefined;
-    pullRequestNumber?: number | undefined;
-}, {
-    repository: string;
-    outcome: "no_changes" | "budget_exhausted" | "pull_request_opened" | "pull_request_updated" | "branch_pushed";
-    schemaVersion: 1;
-    baseRef: string;
     summary: string;
     tests: {
         command: string;
         outcome: "passed" | "failed" | "skipped";
     }[];
-    usage: {
-        tokensIn: number;
-        tokensOut: number;
-        costUsd: number;
-    };
-    headRef?: string | undefined;
-    tag?: string | null | undefined;
-    commitSha?: string | undefined;
-    pullRequestUrl?: string | undefined;
-    pullRequestNumber?: number | undefined;
-}>, {
-    repository: string;
-    outcome: "no_changes" | "budget_exhausted" | "pull_request_opened" | "pull_request_updated" | "branch_pushed";
     schemaVersion: 1;
-    baseRef: string;
-    summary: string;
-    tests: {
-        command: string;
-        outcome: "passed" | "failed" | "skipped";
-    }[];
-    usage: {
-        tokensIn: number;
-        tokensOut: number;
-        costUsd: number;
-    };
-    headRef?: string | undefined;
-    tag?: string | undefined;
-    commitSha?: string | undefined;
-    pullRequestUrl?: string | undefined;
-    pullRequestNumber?: number | undefined;
-}, {
-    repository: string;
     outcome: "no_changes" | "budget_exhausted" | "pull_request_opened" | "pull_request_updated" | "branch_pushed";
-    schemaVersion: 1;
-    baseRef: string;
-    summary: string;
-    tests: {
-        command: string;
-        outcome: "passed" | "failed" | "skipped";
-    }[];
-    usage: {
-        tokensIn: number;
-        tokensOut: number;
-        costUsd: number;
-    };
-    headRef?: string | undefined;
-    tag?: string | null | undefined;
-    commitSha?: string | undefined;
-    pullRequestUrl?: string | undefined;
-    pullRequestNumber?: number | undefined;
-}>, {
-    tag?: string | undefined;
-    summary: string;
-    tests: {
-        command: string;
-        outcome: "passed" | "failed" | "skipped";
-    }[];
     repository: string;
-    outcome: "no_changes" | "budget_exhausted" | "pull_request_opened" | "pull_request_updated" | "branch_pushed";
-    schemaVersion: 1;
     baseRef: string;
     usage: {
         tokensIn: number;
@@ -417,9 +435,9 @@ export declare const CodingRunResultSchema: z.ZodEffects<z.ZodEffects<z.ZodObjec
     pullRequestUrl?: string | undefined;
     pullRequestNumber?: number | undefined;
 }, {
-    repository: string;
-    outcome: "no_changes" | "budget_exhausted" | "pull_request_opened" | "pull_request_updated" | "branch_pushed";
     schemaVersion: 1;
+    outcome: "no_changes" | "budget_exhausted" | "pull_request_opened" | "pull_request_updated" | "branch_pushed";
+    repository: string;
     baseRef: string;
     summary: string;
     tests: {
@@ -432,13 +450,14 @@ export declare const CodingRunResultSchema: z.ZodEffects<z.ZodEffects<z.ZodObjec
         costUsd: number;
     };
     headRef?: string | undefined;
-    tag?: string | null | undefined;
     commitSha?: string | undefined;
     pullRequestUrl?: string | undefined;
     pullRequestNumber?: number | undefined;
-}>;
+    tag?: string | undefined;
+}>>;
 export type CodingTaskInput = z.infer<typeof CodingTaskInputSchema>;
 export type CodingAgentOutput = z.infer<typeof CodingAgentOutputSchema>;
+export type CodingWorkerOutput = z.infer<typeof CodingWorkerOutputSchema>;
 export type CodingRunResult = z.infer<typeof CodingRunResultSchema>;
 /** Parses stored worker output into the only coding result shape callers may receive. */
 export declare function publicCodingRunResult(value: unknown): CodingRunResult | undefined;
@@ -479,4 +498,7 @@ export declare function redactTokenShapedValues(value: string): string;
 export declare function redactAndTruncate(value: string, limit: number): string;
 export declare function parseCodingTaskInputJson(text: string): CodingTaskInput;
 export declare function parseCodingAgentOutputJson(text: string): CodingAgentOutput;
+/** The control plane's read of a worker's result.json (see CodingWorkerOutputSchema). */
+export declare function parseCodingWorkerOutputJson(text: string): CodingWorkerOutput;
 export declare function parseCodingRunResultJson(text: string): CodingRunResult;
+export {};