@wardby/cli 0.1.0

package/dist/coding/observability.js

@@ -0,0 +1,77 @@
+import { logger } from "../core/logger.js";
+/** A small exporter-neutral aggregate that monitoring adapters can scrape or forward. */
+export class CodingMetrics {
+    stages = Object.fromEntries([
+        "queued",
+        "prepared",
+        "launched",
+        "running",
+        "budget_cutoff",
+        "stopping",
+        "collected",
+        "pull_request_opened",
+        "pull_request_updated",
+        "terminal",
+        "cleanup",
+    ].map((stage) => [stage, 0]));
+    terminalOutcomes = {};
+    activeJobs = 0;
+    cleanupFailures = 0;
+    budgetReservedUsd = 0;
+    budgetActualUsd = 0;
+    runtimeMsTotal = 0;
+    emit(event) {
+        this.stages[event.stage] += 1;
+        if (event.stage === "launched")
+            this.activeJobs += 1;
+        if (event.stage === "cleanup") {
+            this.activeJobs = Math.max(0, this.activeJobs - 1);
+            if (event.cleanupSucceeded === false)
+                this.cleanupFailures += 1;
+        }
+        if (event.stage === "terminal" && event.outcome) {
+            this.terminalOutcomes[event.outcome] = (this.terminalOutcomes[event.outcome] ?? 0) + 1;
+        }
+        if (event.budgetReservedUsd !== undefined)
+            this.budgetReservedUsd += event.budgetReservedUsd;
+        if (event.budgetActualUsd !== undefined)
+            this.budgetActualUsd += event.budgetActualUsd;
+        if (event.durationMs !== undefined)
+            this.runtimeMsTotal += event.durationMs;
+    }
+    snapshot() {
+        return {
+            stages: { ...this.stages },
+            terminalOutcomes: { ...this.terminalOutcomes },
+            activeJobs: this.activeJobs,
+            cleanupFailures: this.cleanupFailures,
+            budgetReservedUsd: this.budgetReservedUsd,
+            budgetActualUsd: this.budgetActualUsd,
+            runtimeMsTotal: this.runtimeMsTotal,
+        };
+    }
+}
+export class PinoCodingRunObserver {
+    metrics;
+    constructor(metrics = new CodingMetrics()) {
+        this.metrics = metrics;
+    }
+    emit(event) {
+        this.metrics.emit(event);
+        logger.info({ event: `coding.${event.stage}`, ...event }, "coding run lifecycle");
+    }
+    snapshot() {
+        return this.metrics.snapshot();
+    }
+}
+/** Default application observer. Production log infrastructure owns retention. */
+export const codingRunObserver = new PinoCodingRunObserver();
+export class InMemoryCodingRunObserver {
+    events = [];
+    metrics = new CodingMetrics();
+    emit(event) {
+        const copy = { ...event };
+        this.events.push(copy);
+        this.metrics.emit(copy);
+    }
+}

package/dist/coding/profile.d.ts

@@ -0,0 +1,88 @@
+import { z } from "zod";
+export declare const MIN_CODING_TIMEOUT_SEC = 60;
+export declare const MAX_CODING_TIMEOUT_SEC = 7200;
+export declare const MAX_ALLOWED_EGRESS_HOSTS = 64;
+export declare const MAX_PROTECTED_PATHS = 128;
+export declare const DEFAULT_PROTECTED_PATHS: readonly [".github/workflows/**", ".github/CODEOWNERS", "CODEOWNERS", "docs/CODEOWNERS"];
+export declare const CodingProfileSchema: z.ZodObject<{
+    provider: z.ZodDefault<z.ZodEnum<["codex", "claude-code"]>>;
+    repository: z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>;
+    baseRef: z.ZodDefault<z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>>;
+    defaultTask: z.ZodDefault<z.ZodNullable<z.ZodEffects<z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>, string, string>>>;
+    allowWebhookTaskOverride: z.ZodDefault<z.ZodBoolean>;
+    timeoutSec: z.ZodDefault<z.ZodNumber>;
+    allowedEgress: z.ZodDefault<z.ZodEffects<z.ZodArray<z.ZodEffects<z.ZodEffects<z.ZodEffects<z.ZodEffects<z.ZodEffects<z.ZodEffects<z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>, string, string>, string, string>, string, string>, string, string>, string, string>, string, string>, "many">, string[], string[]>>;
+    protectedPaths: z.ZodDefault<z.ZodEffects<z.ZodArray<z.ZodEffects<z.ZodEffects<z.ZodEffects<z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>, string, string>, string, string>, string, string>, "many">, string[], string[]>>;
+    toolchain: z.ZodDefault<z.ZodEnum<["node", "node-python"]>>;
+    toolchainVersion: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    workerImageRef: z.ZodDefault<z.ZodNullable<z.ZodEffects<z.ZodString, string, string>>>;
+    workspaceDiskMb: z.ZodDefault<z.ZodNullable<z.ZodNumber>>;
+}, "strict", z.ZodTypeAny, {
+    repository: string;
+    baseRef: string;
+    provider: "codex" | "claude-code";
+    defaultTask: string | null;
+    allowWebhookTaskOverride: boolean;
+    timeoutSec: number;
+    allowedEgress: string[];
+    protectedPaths: string[];
+    toolchain: "node-python" | "node";
+    toolchainVersion: string | null;
+    workerImageRef: string | null;
+    workspaceDiskMb: number | null;
+}, {
+    repository: string;
+    baseRef?: string | undefined;
+    provider?: "codex" | "claude-code" | undefined;
+    defaultTask?: string | null | undefined;
+    allowWebhookTaskOverride?: boolean | undefined;
+    timeoutSec?: number | undefined;
+    allowedEgress?: string[] | undefined;
+    protectedPaths?: string[] | undefined;
+    toolchain?: "node-python" | "node" | undefined;
+    toolchainVersion?: string | null | undefined;
+    workerImageRef?: string | null | undefined;
+    workspaceDiskMb?: number | null | undefined;
+}>;
+export declare const CodingProfilePatchSchema: z.ZodObject<{
+    provider: z.ZodOptional<z.ZodEnum<["codex", "claude-code"]>>;
+    repository: z.ZodOptional<z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>>;
+    baseRef: z.ZodOptional<z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>>;
+    defaultTask: z.ZodOptional<z.ZodNullable<z.ZodEffects<z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>, string, string>>>;
+    allowWebhookTaskOverride: z.ZodOptional<z.ZodBoolean>;
+    timeoutSec: z.ZodOptional<z.ZodNumber>;
+    allowedEgress: z.ZodOptional<z.ZodEffects<z.ZodArray<z.ZodEffects<z.ZodEffects<z.ZodEffects<z.ZodEffects<z.ZodEffects<z.ZodEffects<z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>, string, string>, string, string>, string, string>, string, string>, string, string>, string, string>, "many">, string[], string[]>>;
+    protectedPaths: z.ZodOptional<z.ZodEffects<z.ZodArray<z.ZodEffects<z.ZodEffects<z.ZodEffects<z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>, string, string>, string, string>, string, string>, "many">, string[], string[]>>;
+    toolchain: z.ZodOptional<z.ZodEnum<["node", "node-python"]>>;
+    toolchainVersion: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    workerImageRef: z.ZodOptional<z.ZodNullable<z.ZodEffects<z.ZodString, string, string>>>;
+    workspaceDiskMb: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+}, "strict", z.ZodTypeAny, {
+    repository?: string | undefined;
+    baseRef?: string | undefined;
+    provider?: "codex" | "claude-code" | undefined;
+    defaultTask?: string | null | undefined;
+    allowWebhookTaskOverride?: boolean | undefined;
+    timeoutSec?: number | undefined;
+    allowedEgress?: string[] | undefined;
+    protectedPaths?: string[] | undefined;
+    toolchain?: "node-python" | "node" | undefined;
+    toolchainVersion?: string | null | undefined;
+    workerImageRef?: string | null | undefined;
+    workspaceDiskMb?: number | null | undefined;
+}, {
+    repository?: string | undefined;
+    baseRef?: string | undefined;
+    provider?: "codex" | "claude-code" | undefined;
+    defaultTask?: string | null | undefined;
+    allowWebhookTaskOverride?: boolean | undefined;
+    timeoutSec?: number | undefined;
+    allowedEgress?: string[] | undefined;
+    protectedPaths?: string[] | undefined;
+    toolchain?: "node-python" | "node" | undefined;
+    toolchainVersion?: string | null | undefined;
+    workerImageRef?: string | null | undefined;
+    workspaceDiskMb?: number | null | undefined;
+}>;
+export type CodingProfile = z.infer<typeof CodingProfileSchema>;
+export type CodingProfilePatch = z.infer<typeof CodingProfilePatchSchema>;

package/dist/coding/profile.js

@@ -0,0 +1,137 @@
+import { isIP } from "node:net";
+import { z } from "zod";
+import { isImmutableDockerImage } from "../providers/jobs/docker-isolation.js";
+import { MAX_CODING_TASK_BYTES, normalizeGitHubRepository, normalizeGitRef } from "./protocol.js";
+import { CODING_PROVIDERS } from "./provider.js";
+export const MIN_CODING_TIMEOUT_SEC = 60;
+export const MAX_CODING_TIMEOUT_SEC = 7200;
+export const MAX_ALLOWED_EGRESS_HOSTS = 64;
+export const MAX_PROTECTED_PATHS = 128;
+export const DEFAULT_PROTECTED_PATHS = [
+    ".github/workflows/**",
+    ".github/CODEOWNERS",
+    "CODEOWNERS",
+    "docs/CODEOWNERS",
+];
+const MAX_HOST_BYTES = 253;
+const MAX_PROTECTED_PATH_BYTES = 512;
+const INVALID_MULTILINE_CONTROL = /[\u0000\u000B\u000C\u000E-\u001F\u007F]/;
+const INVALID_SINGLE_LINE_CONTROL = /[\u0000-\u001F\u007F]/;
+function byteLength(value) {
+    return Buffer.byteLength(value, "utf8");
+}
+const repositorySchema = z
+    .string()
+    .refine((value) => {
+    try {
+        normalizeGitHubRepository(value);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}, "must be a canonical name or uncredentialed github.com repository")
+    .transform(normalizeGitHubRepository);
+const baseRefSchema = z
+    .string()
+    .refine((value) => {
+    try {
+        normalizeGitRef(value);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}, "must be a safe branch ref")
+    .transform(normalizeGitRef);
+const defaultTaskSchema = z
+    .string()
+    .refine((value) => byteLength(value) <= MAX_CODING_TASK_BYTES, `must be at most ${MAX_CODING_TASK_BYTES} UTF-8 bytes`)
+    .refine((value) => !INVALID_MULTILINE_CONTROL.test(value), "must not contain control characters")
+    .refine((value) => value.trim().length > 0, "must not be blank")
+    .nullable();
+const egressHostSchema = z
+    .string()
+    .transform((value) => value.trim().toLowerCase())
+    .refine((value) => value.length > 0 && byteLength(value) <= MAX_HOST_BYTES, "must be a bounded hostname")
+    .refine((value) => !INVALID_SINGLE_LINE_CONTROL.test(value), "must not contain control characters")
+    .refine((value) => isIP(value) === 0, "IP addresses and CIDRs are not allowed")
+    .refine((value) => !/^\d+(?:\.\d+){3}$/.test(value), "IP-like hostnames are not allowed")
+    .refine((value) => !value.includes("://") &&
+    !value.includes("/") &&
+    !value.includes("@") &&
+    !value.includes(":") &&
+    !value.includes("*"), "must be an exact hostname")
+    .refine((value) => value !== "localhost" && value.includes("."), "must be a fully qualified hostname")
+    .refine((value) => value.split(".").every((label) => /^[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?$/.test(label)), "must be a valid ASCII hostname");
+const protectedPathSchema = z
+    .string()
+    .transform((value) => value.trim())
+    .refine((value) => value.length > 0 && byteLength(value) <= MAX_PROTECTED_PATH_BYTES, "must be a bounded path")
+    .refine((value) => !INVALID_SINGLE_LINE_CONTROL.test(value), "must not contain control characters")
+    .refine((value) => !value.startsWith("/") && !value.startsWith("./") && !value.includes("\\"), "must be a repository-relative POSIX path")
+    .refine((value) => !value.split("/").some((part) => part === "" || part === "." || part === ".."), "must not contain empty or traversal components");
+const KNOWN_TOOLCHAINS = ["node", "node-python"];
+const toolchainSchema = z.enum(KNOWN_TOOLCHAINS);
+const toolchainVersionSchema = z.string().trim().min(1).max(32).nullable();
+const workerImageRefSchema = z
+    .string()
+    .trim()
+    .min(1)
+    .max(512)
+    .refine(isImmutableDockerImage, "must be an immutable repository digest")
+    .nullable();
+const workspaceDiskMbSchema = z.number().int().min(64).max(32_768).nullable();
+const codingProfileFields = {
+    provider: z.enum(CODING_PROVIDERS),
+    repository: repositorySchema,
+    baseRef: baseRefSchema,
+    defaultTask: defaultTaskSchema,
+    allowWebhookTaskOverride: z.boolean(),
+    timeoutSec: z.number().int().min(MIN_CODING_TIMEOUT_SEC).max(MAX_CODING_TIMEOUT_SEC),
+    toolchain: toolchainSchema,
+    toolchainVersion: toolchainVersionSchema,
+    workerImageRef: workerImageRefSchema,
+    workspaceDiskMb: workspaceDiskMbSchema,
+    allowedEgress: z
+        .array(egressHostSchema)
+        .max(MAX_ALLOWED_EGRESS_HOSTS)
+        .transform((hosts) => [...new Set(hosts)]),
+    protectedPaths: z
+        .array(protectedPathSchema)
+        .min(1)
+        .max(MAX_PROTECTED_PATHS)
+        .transform((paths) => [...new Set(paths)]),
+};
+export const CodingProfileSchema = z
+    .object({
+    provider: codingProfileFields.provider.default("codex"),
+    repository: codingProfileFields.repository,
+    baseRef: codingProfileFields.baseRef.default("main"),
+    defaultTask: codingProfileFields.defaultTask.default(null),
+    allowWebhookTaskOverride: codingProfileFields.allowWebhookTaskOverride.default(false),
+    timeoutSec: codingProfileFields.timeoutSec.default(1800),
+    allowedEgress: codingProfileFields.allowedEgress.default([]),
+    protectedPaths: codingProfileFields.protectedPaths.default([...DEFAULT_PROTECTED_PATHS]),
+    toolchain: codingProfileFields.toolchain.default("node"),
+    toolchainVersion: codingProfileFields.toolchainVersion.default(null),
+    workerImageRef: codingProfileFields.workerImageRef.default(null),
+    workspaceDiskMb: codingProfileFields.workspaceDiskMb.default(null),
+})
+    .strict();
+export const CodingProfilePatchSchema = z
+    .object({
+    provider: codingProfileFields.provider.optional(),
+    repository: codingProfileFields.repository.optional(),
+    baseRef: codingProfileFields.baseRef.optional(),
+    defaultTask: codingProfileFields.defaultTask.optional(),
+    allowWebhookTaskOverride: codingProfileFields.allowWebhookTaskOverride.optional(),
+    timeoutSec: codingProfileFields.timeoutSec.optional(),
+    allowedEgress: codingProfileFields.allowedEgress.optional(),
+    protectedPaths: codingProfileFields.protectedPaths.optional(),
+    toolchain: codingProfileFields.toolchain.optional(),
+    toolchainVersion: codingProfileFields.toolchainVersion.optional(),
+    workerImageRef: codingProfileFields.workerImageRef.optional(),
+    workspaceDiskMb: codingProfileFields.workspaceDiskMb.optional(),
+})
+    .strict();

package/dist/coding/protocol.d.ts

@@ -0,0 +1,345 @@
+import { z } from "zod";
+export declare const CODING_PROTOCOL_VERSION: 1;
+export declare const MAX_CODING_ARTIFACT_BYTES: number;
+export declare const MAX_CODING_TASK_BYTES: number;
+export declare const MAX_CODING_SUMMARY_BYTES: number;
+export declare const MAX_CODING_TESTS = 64;
+export declare const MAX_CODING_TEST_COMMAND_BYTES: number;
+export declare const MAX_TAG_BYTES = 32;
+export declare function normalizeGitHubRepository(value: string): string;
+export declare function normalizeGitRef(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 CodingTaskInputSchema: z.ZodEffects<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>;
+    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;
+    }>>;
+}, "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;
+}, {
+    repository: string;
+    schemaVersion: 1;
+    runId: string;
+    baseRef: string;
+    headRef: string;
+    task: string;
+    model: string;
+    budgetUsd: number;
+    deadlineAt: string;
+    continuationOf?: {
+        runId: string;
+    } | undefined;
+}>, {
+    repository: string;
+    schemaVersion: 1;
+    runId: string;
+    baseRef: string;
+    headRef: string;
+    task: string;
+    model: string;
+    budgetUsd: number;
+    deadlineAt: string;
+    continuationOf?: {
+        runId: string;
+    } | undefined;
+}, {
+    repository: string;
+    schemaVersion: 1;
+    runId: string;
+    baseRef: string;
+    headRef: string;
+    task: string;
+    model: string;
+    budgetUsd: number;
+    deadlineAt: string;
+    continuationOf?: {
+        runId: string;
+    } | undefined;
+}>;
+export declare const CodingAgentOutputSchema: z.ZodEffects<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>;
+    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.ZodOptional<z.ZodNullable<z.ZodString>>, string | undefined, string | null | undefined>;
+}, "strict", z.ZodTypeAny, {
+    outcome: "changes_ready" | "no_changes" | "budget_exhausted";
+    schemaVersion: 1;
+    runId: string;
+    summary: string;
+    tests: {
+        command: string;
+        outcome: "passed" | "failed" | "skipped";
+    }[];
+    tag?: string | undefined;
+}, {
+    outcome: "changes_ready" | "no_changes" | "budget_exhausted";
+    schemaVersion: 1;
+    runId: string;
+    summary: string;
+    tests: {
+        command: string;
+        outcome: "passed" | "failed" | "skipped";
+    }[];
+    tag?: string | null | undefined;
+}>, {
+    tag?: string | undefined;
+    summary: string;
+    tests: {
+        command: string;
+        outcome: "passed" | "failed" | "skipped";
+    }[];
+    outcome: "changes_ready" | "no_changes" | "budget_exhausted";
+    schemaVersion: 1;
+    runId: string;
+}, {
+    outcome: "changes_ready" | "no_changes" | "budget_exhausted";
+    schemaVersion: 1;
+    runId: string;
+    summary: string;
+    tests: {
+        command: string;
+        outcome: "passed" | "failed" | "skipped";
+    }[];
+    tag?: string | null | undefined;
+}>;
+export declare const CodingRunResultSchema: z.ZodEffects<z.ZodEffects<z.ZodObject<{
+    schemaVersion: z.ZodLiteral<1>;
+    outcome: z.ZodEnum<["pull_request_opened", "pull_request_updated", "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>>;
+    pullRequestNumber: z.ZodOptional<z.ZodNumber>;
+    summary: z.ZodEffects<z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>, string, string>;
+    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">;
+    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";
+    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";
+    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";
+    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";
+    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";
+    schemaVersion: 1;
+    baseRef: string;
+    usage: {
+        tokensIn: number;
+        tokensOut: number;
+        costUsd: number;
+    };
+    headRef?: string | undefined;
+    commitSha?: string | undefined;
+    pullRequestUrl?: string | undefined;
+    pullRequestNumber?: number | undefined;
+}, {
+    repository: string;
+    outcome: "no_changes" | "budget_exhausted" | "pull_request_opened" | "pull_request_updated";
+    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;
+}>;
+export type CodingTaskInput = z.infer<typeof CodingTaskInputSchema>;
+export type CodingAgentOutput = z.infer<typeof CodingAgentOutputSchema>;
+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;
+/**
+ * The longest span any pattern that needs a trailing anchor can match — URL
+ * userinfo (1 061 chars) and a PEM block (6 262). `redactAndTruncate` relies on
+ * it: see there. Exported with the patterns themselves so the invariant is
+ * TESTED, not merely documented — raising a bound below without raising this
+ * fails `protocol.test.ts`'s max-span test rather than silently breaking the
+ * window argument.
+ */
+export declare const MAX_REDACTED_SPAN: number;
+/**
+ * The patterns that cannot match at all without their trailing anchor (`@`,
+ * `-----END …`), which is exactly the property that makes them, and only them,
+ * sensitive to the truncation window.
+ */
+export declare const TRAILING_ANCHORED_PATTERNS: {
+    urlCredentials: RegExp;
+    pemPrivateKey: RegExp;
+};
+export declare function redactTokenShapedValues(value: string): string;
+/**
+ * Redact, then truncate to `limit` — for callers that keep only a prefix of a
+ * potentially huge string (git output is capped at 2 MiB, an error message is
+ * unbounded). Redacting first is the security-critical half: truncating first
+ * could cut a credential in two and log the front of it.
+ *
+ * Scanning megabytes to keep 8 KiB is wasted event-loop time, so redaction runs
+ * over `limit + MAX_REDACTED_SPAN` characters instead of the whole string. That
+ * is safe because a credential with any character inside `limit` lies entirely
+ * within that window: the two patterns that need a trailing anchor to match at
+ * all (URL userinfo, PEM) are bounded well under `MAX_REDACTED_SPAN`, and every
+ * open-ended pattern still matches — and so still redacts — the part of the
+ * secret that falls inside the window. Whatever lies beyond the window is
+ * dropped, not logged.
+ */
+export declare function redactAndTruncate(value: string, limit: number): string;
+export declare function parseCodingTaskInputJson(text: string): CodingTaskInput;
+export declare function parseCodingAgentOutputJson(text: string): CodingAgentOutput;
+export declare function parseCodingRunResultJson(text: string): CodingRunResult;