@wardby/cli 0.6.0 → 0.7.0

package/dist/providers/executor/in-process.d.ts

@@ -13,5 +13,13 @@ export declare class InProcessExecutor implements Executor {
     private readonly heartbeatIntervalMs;
     constructor(providers: NativeRunProviders, db?: RunnerDb, heartbeatIntervalMs?: number);
     start(runId: string): Promise<void>;
-    stop(_runId: string, _reason?: string): Promise<void>;
+    /**
+     * Records the run cancelled (only while it is still pending or running: the first terminal write
+     * wins) and settles it like any finished run (its review check, status comments, notifications).
+     * The engine itself is stopped cooperatively: executeRun's inline step runner reads the run's row
+     * before every step (stopAwareStep), so the process executing it, this one or another, stops it
+     * at the next step boundary, and a run that has not started yet never does. A step already in
+     * flight (one model turn or tool call) finishes first; its spend is still recorded.
+     */
+    stop(runId: string, reason?: string): Promise<void>;
 }

package/dist/providers/executor/in-process.js

@@ -5,7 +5,7 @@
  * heartbeat and recovers the run to `lost` rather than leaving it stuck
  * `running` forever.
  */
-import { executeRun } from "../../core/runner.js";
+import { executeRun, failNativeRun, nativeRunIntegrations, RunCancelledError, } from "../../core/runner.js";
 import { prisma as defaultDb } from "../../core/db.js";
 import { HEARTBEAT_INTERVAL_MS } from "../../core/timing.js";
 export class InProcessExecutor {
@@ -31,8 +31,18 @@ export class InProcessExecutor {
             clearInterval(timer);
         }
     }
-    async stop(_runId, _reason) {
-        // Native engine cancellation remains cooperative until Engine accepts an
-        // AbortSignal. The task state still records the caller's request.
+    /**
+     * Records the run cancelled (only while it is still pending or running: the first terminal write
+     * wins) and settles it like any finished run (its review check, status comments, notifications).
+     * The engine itself is stopped cooperatively: executeRun's inline step runner reads the run's row
+     * before every step (stopAwareStep), so the process executing it, this one or another, stops it
+     * at the next step boundary, and a run that has not started yet never does. A step already in
+     * flight (one model turn or tool call) finishes first; its spend is still recorded.
+     */
+    async stop(runId, reason) {
+        const run = await this.db.run.findUnique({ where: { id: runId }, select: { status: true } });
+        if (!run || (run.status !== "pending" && run.status !== "running"))
+            return;
+        await failNativeRun({ runId, db: this.db, providers: this.providers, ...nativeRunIntegrations(this.providers, this.db) }, new RunCancelledError(reason ?? "The run was cancelled."));
     }
 }

package/dist/providers/executor/linked-issue-reader.d.ts

@@ -0,0 +1,16 @@
+import type { IssueTrackerRegistry } from "../issue-tracker/types.js";
+import type { ReviewHostRegistry } from "../review-host/types.js";
+import type { LinkedIssueRef } from "./container.js";
+/**
+ * The executor's readLinkedIssue: a GitHub issue through the review host's
+ * issue read (the App's installation token for the run's repository), a Jira
+ * issue through the configured tracker. Null when the number is a pull
+ * request, the issue is missing, or no host or tracker is configured.
+ */
+export declare function linkedIssueReader(deps: {
+    hosts: ReviewHostRegistry;
+    issueTrackers: IssueTrackerRegistry;
+}): (ref: LinkedIssueRef) => Promise<{
+    title: string;
+    body: string;
+} | null>;

package/dist/providers/executor/linked-issue-reader.js

@@ -0,0 +1,30 @@
+/** A tracker read for a continuation's task must not hold up its launch. */
+const TRACKER_READ_TIMEOUT_MS = 10_000;
+/**
+ * The executor's readLinkedIssue: a GitHub issue through the review host's
+ * issue read (the App's installation token for the run's repository), a Jira
+ * issue through the configured tracker. Null when the number is a pull
+ * request, the issue is missing, or no host or tracker is configured.
+ */
+export function linkedIssueReader(deps) {
+    return async (ref) => {
+        if (ref.provider === "github") {
+            const host = deps.hosts.github;
+            if (!host?.readIssue)
+                return null;
+            // Title and body only: the task carries the ticket, not its discussion.
+            const result = await host.readIssue(ref.repository, ref.number, { comments: false });
+            return result.kind === "issue" ? { title: result.title, body: result.body } : null;
+        }
+        const tracker = deps.issueTrackers.jira;
+        if (!tracker)
+            return null;
+        const view = await tracker.getIssue(ref.key, {
+            maxComments: 0,
+            agentMarker: "",
+            timeoutMs: TRACKER_READ_TIMEOUT_MS,
+            retryOn429: false,
+        });
+        return { title: view.summary, body: view.description };
+    };
+}

package/dist/providers/executor/routing.d.ts

@@ -37,6 +37,8 @@ export declare class RoutingExecutor implements Executor {
      * backend name.
      */
     recover(handle: PersistedExecutionHandle): Promise<ExecutionRecoveryResult>;
+    /** Only coding runs wait in the coding queue, so only the coding executor is asked. */
+    cleanupQueueTimeout(runId: string): Promise<void>;
     /** Each distinct executor once, in a fixed order: native, coding, sandbox. */
     private distinct;
     /** Lifecycle fans out to every distinct executor; each hook is optional on the seam. */

package/dist/providers/executor/routing.js

@@ -63,6 +63,10 @@ export class RoutingExecutor {
         }
         return executor.recover(handle);
     }
+    /** Only coding runs wait in the coding queue, so only the coding executor is asked. */
+    async cleanupQueueTimeout(runId) {
+        await this.coding.cleanupQueueTimeout?.(runId);
+    }
     /** Each distinct executor once, in a fixed order: native, coding, sandbox. */
     distinct() {
         return [this.native, this.coding, this.sandbox].filter((executor, index, all) => executor !== undefined && all.indexOf(executor) === index);

package/dist/providers/executor/types.d.ts

@@ -35,6 +35,14 @@ export interface Executor {
      * terminal Run persistence completed. Recovery must never relaunch a job.
      */
     recover?: (handle: PersistedExecutionHandle) => Promise<ExecutionRecoveryResult>;
+    /**
+     * Called by drainCodingQueue for each queued coding run it failed with coding_queue_timeout, after
+     * that write: releases what an earlier attempt of the run left (a launch the backend refused for
+     * capacity), such as a continuation's in-progress host signal and its input artifact. Best effort;
+     * a throw is logged by the caller. Optional: an executor that never leaves a queued run anything
+     * to release omits it.
+     */
+    cleanupQueueTimeout?: (runId: string) => Promise<void>;
     /**
      * Optional one-time startup. A durable backend connects and re-drives the
      * workflows it owned before the last restart. Composition roots call it
@@ -97,5 +105,10 @@ export interface Executor {
      * in). MCP refuses to set an agent to sandbox mode where it cannot (docs/native-sandbox.md).
      */
     supportsNativeSandbox?(): boolean;
+    /**
+     * true: this executor cannot resolve coding inputs; dispatch records the coding run unresolved
+     * and the process that starts it resolves them (resolveDeferredCodingRun).
+     */
+    defersCodingResolution?: boolean;
 }
 import type { CodingProvider } from "../../coding/provider.js";

package/dist/providers/index.d.ts

@@ -34,7 +34,8 @@ export interface ProviderRegistry {
     llm: LlmProvider;
     secrets: SecretCipher;
     auth: AuthProvider;
-    storage: BlobStore;
+    /** Absent unless BLOB_STORE is configured. */
+    storage?: BlobStore;
     executor: Executor;
     datastore: Datastore;
     memory: AgentMemoryStore;

package/dist/providers/issue-tracker/types.d.ts

@@ -264,6 +264,23 @@ export interface IssueEvent {
 }
 /** Shared by the ingress and the tools: a Jira issue key, e.g. PROJ-123. */
 export declare const ISSUE_KEY: RegExp;
+/** A GitHub issue's recorded key (githubIssueKey): "<owner>/<repo>#<number>", the repository normalised to lowercase. */
+export declare const GITHUB_ISSUE_KEY: RegExp;
+/** The product name of each system an issue can be recorded from (CodingRun / IssuePullRequest issueProvider). */
+export declare const ISSUE_SOURCE_NAMES: Readonly<Record<string, string>>;
+/**
+ * A recorded issue (CodingRun / IssuePullRequest issueProvider + issueKey) as
+ * people see it: the key re-validated for its provider, the system's name and
+ * the issue's page. A GitHub issue's page comes from its key; a tracker
+ * issue's from `trackerUrl` (the tracker's issueUrl), dropped when it throws
+ * or is not https. Undefined for an unknown provider or a malformed key.
+ */
+export declare function issueReference(provider: string, key: string, trackerUrl?: (key: string) => string | undefined): {
+    key: string;
+    url?: string;
+    trackerName: string;
+} | undefined;
 /** A Jira project key. */
 export declare const PROJECT_KEY: RegExp;
+/** An issue key's project: a Jira key's project key ("PROJ-123" → "PROJ"); a GitHub issue key's repository ("owner/repo#5" → "owner/repo"). */
 export declare const projectOf: (issueKey: string) => string;

package/dist/providers/issue-tracker/types.js

@@ -11,6 +11,44 @@ export class IssueTrackerError extends Error {
 }
 /** Shared by the ingress and the tools: a Jira issue key, e.g. PROJ-123. */
 export const ISSUE_KEY = /^[A-Z][A-Z0-9_]{0,254}-[1-9]\d{0,9}$/;
+/** A GitHub issue's recorded key (githubIssueKey): "<owner>/<repo>#<number>", the repository normalised to lowercase. */
+export const GITHUB_ISSUE_KEY = /^[a-z0-9](?:[a-z0-9-]{0,37}[a-z0-9])?\/[a-z0-9._-]{1,100}#[1-9]\d{0,9}$/;
+/** The product name of each system an issue can be recorded from (CodingRun / IssuePullRequest issueProvider). */
+export const ISSUE_SOURCE_NAMES = { ...ISSUE_TRACKER_NAMES, github: "GitHub" };
+/**
+ * A recorded issue (CodingRun / IssuePullRequest issueProvider + issueKey) as
+ * people see it: the key re-validated for its provider, the system's name and
+ * the issue's page. A GitHub issue's page comes from its key; a tracker
+ * issue's from `trackerUrl` (the tracker's issueUrl), dropped when it throws
+ * or is not https. Undefined for an unknown provider or a malformed key.
+ */
+export function issueReference(provider, key, trackerUrl) {
+    let url;
+    if (provider === "github") {
+        if (!GITHUB_ISSUE_KEY.test(key))
+            return undefined;
+        const hash = key.lastIndexOf("#");
+        url = `https://github.com/${key.slice(0, hash)}/issues/${key.slice(hash + 1)}`;
+    }
+    else if (provider === "jira") {
+        if (!ISSUE_KEY.test(key))
+            return undefined;
+        try {
+            url = trackerUrl?.(key);
+        }
+        catch {
+            url = undefined;
+        }
+    }
+    else {
+        return undefined;
+    }
+    return { key, ...(url?.startsWith("https://") ? { url } : {}), trackerName: ISSUE_SOURCE_NAMES[provider] };
+}
 /** A Jira project key. */
 export const PROJECT_KEY = /^[A-Z][A-Z0-9_]{0,254}$/;
-export const projectOf = (issueKey) => issueKey.slice(0, issueKey.lastIndexOf("-"));
+/** An issue key's project: a Jira key's project key ("PROJ-123" → "PROJ"); a GitHub issue key's repository ("owner/repo#5" → "owner/repo"). */
+export const projectOf = (issueKey) => {
+    const hash = issueKey.lastIndexOf("#");
+    return issueKey.slice(0, hash >= 0 ? hash : issueKey.lastIndexOf("-"));
+};

package/dist/providers/jobs/claude-tool-setup.d.ts

@@ -19,5 +19,9 @@ export interface ClaudeToolSetup {
         content: string;
         mode: number;
     }[];
+    /** Present only when the run's dependency cache is on, so older tool runners see an unchanged setup. */
+    dependencyCache?: true;
+    /** With dependencyCache only: the workspace volume size (limits.diskMb) the cache must stay inside. */
+    diskMb?: number;
 }
 export declare function claudeToolSetup(spec: JobSpec, capability: string): string;

package/dist/providers/jobs/claude-tool-setup.js

@@ -2,8 +2,10 @@
  * What Claude Code's tool runner (the credential-free container that runs commands in the
  * repository) needs from the trusted launcher: the package-registry settings every Codex shell
  * gets, built from the run's registry-only token (deriveRegistryToken, never the capability), and
- * the run's service test variables. Delivered as CLAUDE_TOOL_SETUP_ENV: a Kubernetes Secret key, or
- * `docker create --env NAME` with the value in the CLI's own environment.
+ * the run's service test variables, and whether the run's dependency cache is on. Delivered as the
+ * WARDBY_TOOL_SETUP environment variable (CLAUDE_TOOL_SETUP_ENV, docker-isolation.ts; a test keeps it
+ * equal to the tool runner's TOOL_SETUP_ENV): a Kubernetes Secret key, or `docker create --env NAME`
+ * with the value in the CLI's own environment.
  */
 import { serviceEnvironment } from "../../coding-worker/driver.js";
 import { registryWorkerSetup } from "../../coding/registry/worker-config.js";
@@ -35,6 +37,7 @@ export function claudeToolSetup(spec, capability) {
         // Same precedence as the Codex driver: the registry's own settings win over a service's.
         env: { ...serviceEnvironment(spec.services), ...registry.env },
         files: registry.files,
+        ...(spec.dependencyCache ? { dependencyCache: true, diskMb: spec.limits.diskMb } : {}),
     };
     const raw = JSON.stringify(setup);
     const limits = CLAUDE_TOOL_SETUP_LIMITS;

package/dist/providers/jobs/docker-isolation.d.ts

@@ -25,6 +25,14 @@ export declare const CLAUDE_TOOL_SETUP_ENV = "WARDBY_TOOL_SETUP";
 export declare const CODING_PROXY_DENY_PORT = 8788;
 export declare const DOCKER_ISOLATION_ERROR = "docker_isolation_unsupported";
 export declare const WORKER_STOP_GRACE_SECONDS = 10;
+/** The Claude worker's SDK config dir (claude-coding-worker/driver.ts CLAUDE_CONFIG_DIR). */
+export declare const CLAUDE_CONFIG_PATH = "/tmp/claude-config";
+/**
+ * Its own memory-backed scratch on a session-resume run: room for a session file up to the largest the
+ * control plane reads (coding/protocol.ts MAX_RAW_TRANSCRIPT_BYTES, 64 MiB) plus the SDK's small config
+ * files. Past it the SDK's writes there fail with ENOSPC, as /tmp's would; /tmp itself keeps its room.
+ */
+export declare const CLAUDE_CONFIG_SCRATCH_MIB = 80;
 export declare const WORKER_PATHS: {
     readonly workspace: "/workspace";
     readonly git: "/workspace/.git";

package/dist/providers/jobs/docker-isolation.js

@@ -28,6 +28,14 @@ export const CLAUDE_TOOL_SETUP_ENV = "WARDBY_TOOL_SETUP";
 export const CODING_PROXY_DENY_PORT = 8788;
 export const DOCKER_ISOLATION_ERROR = "docker_isolation_unsupported";
 export const WORKER_STOP_GRACE_SECONDS = 10;
+/** The Claude worker's SDK config dir (claude-coding-worker/driver.ts CLAUDE_CONFIG_DIR). */
+export const CLAUDE_CONFIG_PATH = "/tmp/claude-config";
+/**
+ * Its own memory-backed scratch on a session-resume run: room for a session file up to the largest the
+ * control plane reads (coding/protocol.ts MAX_RAW_TRANSCRIPT_BYTES, 64 MiB) plus the SDK's small config
+ * files. Past it the SDK's writes there fail with ENOSPC, as /tmp's would; /tmp itself keeps its room.
+ */
+export const CLAUDE_CONFIG_SCRATCH_MIB = 80;
 export const WORKER_PATHS = {
     workspace: "/workspace",
     git: "/workspace/.git",
@@ -90,6 +98,9 @@ function validateSpec(spec) {
     else if (spec.toolImage !== undefined) {
         throw isolationError();
     }
+    if (spec.sessionResume !== undefined && (spec.sessionResume !== true || spec.provider !== "claude-code")) {
+        throw isolationError();
+    }
     if (spec.services !== undefined) {
         // docker-services.ts re-validates every entry against the catalog schema. Both providers' shells
         // share the network keeper's namespace: Codex's worker, and Claude Code's tool runner.
@@ -432,6 +443,12 @@ export function buildClaudeAgentCreateArgs(spec, proxyPort = CODING_PROXY_PORT)
         `/tmp:rw,noexec,nosuid,nodev,size=${scratchMb}m,mode=1777`,
         "--tmpfs",
         `/home/wardby:rw,noexec,nosuid,nodev,size=${scratchMb}m,uid=${CODING_WORKER_UID},gid=${CODING_WORKER_GID},mode=0700`,
+        ...(spec.sessionResume
+            ? [
+                "--tmpfs",
+                `${CLAUDE_CONFIG_PATH}:rw,noexec,nosuid,nodev,size=${CLAUDE_CONFIG_SCRATCH_MIB}m,uid=${CODING_WORKER_UID},gid=${CODING_WORKER_GID},mode=0700`,
+            ]
+            : []),
         "--mount",
         `type=volume,src=${names.storageVolume},dst=${WORKER_PATHS.input},volume-subpath=input,volume-nocopy,readonly`,
         "--mount",

package/dist/providers/jobs/docker.d.ts

@@ -164,6 +164,7 @@ export declare class DockerJobLauncher implements WorkspaceJobLauncher {
     private removeNetworkIfAttested;
     private removeVolumeIfAttested;
     private seedRun;
+    readTranscript(handle: JobHandle, maxBytes: number): Promise<string | undefined>;
     private readResultArtifact;
     private readWorkerFailureDiagnostic;
     private keeperName;

package/dist/providers/jobs/docker.js

@@ -7,7 +7,7 @@ import { dirname, isAbsolute, join, resolve, sep } from "node:path";
 import { logger } from "../../core/logger.js";
 import { ensurePrivateDirectory } from "../../core/private-directory.js";
 import { readBoundedRegularFile } from "../../coding-worker/artifact.js";
-import { parseCodingAgentOutputJson, redactAndTruncate, MAX_CODING_ARTIFACT_BYTES, MAX_CODING_INPUT_BYTES, MAX_CODING_OUTPUT_ISSUES, SAFE_CODING_OUTPUT_ISSUE, } from "../../coding/protocol.js";
+import { parseCodingWorkerOutputJson, redactAndTruncate, MAX_CODING_ARTIFACT_BYTES, MAX_CODING_INPUT_BYTES, MAX_CODING_OUTPUT_ISSUES, SAFE_CODING_OUTPUT_ISSUE, } from "../../coding/protocol.js";
 import { assertDockerHostSupportsIsolation, assertClaudeAgentContainerInspection, assertClaudeToolRunnerContainerInspection, assertIsolationNetworkInspection, assertKeeperContainerInspection, assertNetworkKeeperContainerInspection, assertProxyContainerInspection, assertStorageVolumeInspection, assertWorkerContainerInspection, buildDockerIsolationPlan, CLAUDE_TOOL_SETUP_ENV, dockerSupportsServicesFor, } from "./docker-isolation.js";
 import { serviceUnreadyError } from "../../coding/services/wording.js";
 import { assertServiceContainerInspection, buildDockerServicePlan, dockerServiceContainerNames, } from "./docker-services.js";
@@ -1067,13 +1067,38 @@ export class DockerJobLauncher {
         await this.transfer.seedDirectory(resolve(runRoot, "git"), keeper, "/run/wardby/storage/git");
         await this.transfer.seedInput(record.spec.inputArtifact, keeper);
     }
+    async readTranscript(handle, maxBytes) {
+        await this.ready;
+        const record = await this.findRecord(handle);
+        if (!record)
+            return undefined;
+        const staging = await mkdtemp(join(this.stateRoot, ".wardby-transcript-"));
+        const target = join(staging, "session.jsonl");
+        try {
+            try {
+                await this.run([
+                    "container",
+                    "cp",
+                    `${this.keeperName(record)}:/run/wardby/storage/output/session.jsonl`,
+                    target,
+                ]);
+            }
+            catch {
+                return undefined;
+            }
+            return await readBoundedRegularFile(target, maxBytes, "transcript_too_large");
+        }
+        finally {
+            await rm(staging, { recursive: true, force: true });
+        }
+    }
     async readResultArtifact(record) {
         const staging = await mkdtemp(join(this.stateRoot, ".wardby-result-"));
         const target = join(staging, "result.json");
         try {
             await this.run(["container", "cp", `${this.keeperName(record)}:/run/wardby/storage/output/result.json`, target]);
             const raw = await readBoundedRegularFile(target, MAX_CODING_ARTIFACT_BYTES, "docker_result_artifact_invalid");
-            const output = parseCodingAgentOutputJson(raw);
+            const output = parseCodingWorkerOutputJson(raw);
             if (output.runId !== record.runId)
                 throw new Error("docker_result_run_mismatch");
             return JSON.stringify(output);

package/dist/providers/jobs/fake-kubernetes-api.d.ts

@@ -31,6 +31,8 @@ export declare class FakeKubernetesApi implements KubernetesApi {
     onExec: (call: FakeExecCall) => Promise<number>;
     /** The admission chain a dry-run create runs through. Default: echo the pod back unchanged. */
     onDryRunCreatePod: (namespace: string, body: V1Pod) => Promise<V1Pod>;
+    /** Runs at the start of every pod create; tests throw KubernetesQuotaExceededError (or anything) from it. */
+    onCreatePod: (namespace: string, body: V1Pod) => Promise<void>;
     readonly deploymentPatches: Array<{
         name: string;
         replicas?: number;

package/dist/providers/jobs/fake-kubernetes-api.js

@@ -13,6 +13,8 @@ export class FakeKubernetesApi {
     };
     /** The admission chain a dry-run create runs through. Default: echo the pod back unchanged. */
     onDryRunCreatePod = async (_namespace, body) => body;
+    /** Runs at the start of every pod create; tests throw KubernetesQuotaExceededError (or anything) from it. */
+    onCreatePod = async () => { };
     deploymentPatches = [];
     /** Deployment names whose patch throws KubernetesForbiddenError. */
     forbidden = new Set();
@@ -83,6 +85,7 @@ export class FakeKubernetesApi {
         this.delete("secret", namespace, name);
     }
     async createPod(namespace, body) {
+        await this.onCreatePod(namespace, body);
         return this.create("pod", namespace, body);
     }
     /**

package/dist/providers/jobs/kubernetes-api.d.ts

@@ -12,6 +12,14 @@ export declare class KubernetesNotFoundError extends Error {
 export declare class KubernetesForbiddenError extends Error {
     constructor(message?: string, options?: ErrorOptions);
 }
+/** A create the namespace ResourceQuota refused (HTTP 403 "exceeded quota"). */
+export declare class KubernetesQuotaExceededError extends Error {
+    /** The refusing quota's name as the API server worded it; unvalidated, and nothing else of the refusal is kept. */
+    readonly quotaName?: string;
+    constructor(message?: string, options?: ErrorOptions & {
+        quotaName?: string;
+    });
+}
 /** Stale resourceVersion on replace. */
 export declare class KubernetesConflictError extends Error {
     constructor(message?: string);

package/dist/providers/jobs/kubernetes-api.js

@@ -11,6 +11,16 @@ export class KubernetesForbiddenError extends Error {
         this.name = "KubernetesForbiddenError";
     }
 }
+/** A create the namespace ResourceQuota refused (HTTP 403 "exceeded quota"). */
+export class KubernetesQuotaExceededError extends Error {
+    /** The refusing quota's name as the API server worded it; unvalidated, and nothing else of the refusal is kept. */
+    quotaName;
+    constructor(message, options) {
+        super(message, options);
+        this.name = "KubernetesQuotaExceededError";
+        this.quotaName = options?.quotaName;
+    }
+}
 /** Stale resourceVersion on replace. */
 export class KubernetesConflictError extends Error {
     constructor(message) {

package/dist/providers/jobs/kubernetes-client.js

@@ -5,7 +5,7 @@
  */
 import { ApiException, AppsV1Api, AuthorizationV1Api, CoreV1Api, Exec, KubeConfig, NetworkingV1Api, PatchStrategy, setHeaderOptions, VersionApi, } from "@kubernetes/client-node";
 import { Writable } from "node:stream";
-import { KubernetesAlreadyExistsError, KubernetesConflictError, KubernetesForbiddenError, KubernetesNotFoundError, } from "./kubernetes-api.js";
+import { KubernetesAlreadyExistsError, KubernetesConflictError, KubernetesForbiddenError, KubernetesNotFoundError, KubernetesQuotaExceededError, } from "./kubernetes-api.js";
 function statusCode(error) {
     return error instanceof ApiException ? error.code : undefined;
 }
@@ -44,6 +44,11 @@ async function deleteIgnoringMissing(remove) {
         throw error;
     }
 }
+/** The error's message plus its body as text, for matching only; never copied into a thrown message. */
+function bodyText(error) {
+    const { body, message } = error;
+    return `${message}\n${typeof body === "string" ? body : JSON.stringify(body ?? "")}`;
+}
 async function create(what, write) {
     try {
         return await write();
@@ -54,6 +59,10 @@ async function create(what, write) {
             throw new KubernetesAlreadyExistsError(what);
         if (code === 404)
             throw new KubernetesNotFoundError(what);
+        if (code === 403 && /exceeded quota/i.test(bodyText(error))) {
+            const quotaName = /exceeded quota: ([^\s,"\\]+)/i.exec(bodyText(error))?.[1];
+            throw new KubernetesQuotaExceededError(`exceeded quota: ${what}`, { cause: error, quotaName });
+        }
         throw error;
     }
 }

package/dist/providers/jobs/kubernetes-isolation.d.ts

@@ -1,6 +1,7 @@
 import type { V1Container, V1NetworkPolicy, V1Pod, V1Secret } from "@kubernetes/client-node";
 import { type ResolvedCodingService } from "../../coding/services/catalog.js";
 import type { JobSpec } from "./types.js";
+import { CLAUDE_CONFIG_PATH, CLAUDE_CONFIG_SCRATCH_MIB } from "./docker-isolation.js";
 import { type KubernetesPlatform } from "./kubernetes-platform.js";
 export declare const KUBERNETES_ISOLATION_ERROR = "kubernetes_isolation_unsupported";
 /** Extra seconds past timeoutSec before Kubernetes kills the pod (keeper included). */
@@ -51,6 +52,7 @@ export declare const ENFORCEMENT_PROBE_PROXY_UNREACHABLE = 4;
  * blocking the path — the port is reachable-but-unserved and witnesses nothing.
  */
 export declare const ENFORCEMENT_PROBE_DENY_REFUSED = 5;
+export { CLAUDE_CONFIG_PATH, CLAUDE_CONFIG_SCRATCH_MIB };
 export interface KubernetesRunNames {
     token: string;
     runSha: string;

package/dist/providers/jobs/kubernetes-isolation.js

@@ -7,7 +7,7 @@
 import { createHash } from "node:crypto";
 import { isIP } from "node:net";
 import { StoredCodingServicesSchema } from "../../coding/services/catalog.js";
-import { CLAUDE_TOOL_SETUP_ENV, CODING_PROXY_ALIAS, CODING_PROXY_DENY_PORT, CODING_PROXY_PORT, CODING_WORKER_GID, CODING_WORKER_UID, WORKER_STOP_GRACE_SECONDS, claudeToolLimits, isRepositoryDigest, } from "./docker-isolation.js";
+import { CLAUDE_CONFIG_PATH, CLAUDE_CONFIG_SCRATCH_MIB, CLAUDE_TOOL_SETUP_ENV, CODING_PROXY_ALIAS, CODING_PROXY_DENY_PORT, CODING_PROXY_PORT, CODING_WORKER_GID, CODING_WORKER_UID, WORKER_STOP_GRACE_SECONDS, claudeToolLimits, isRepositoryDigest, } from "./docker-isolation.js";
 import { GVISOR_RUNTIME_CLASS, KubernetesPlatformError, STORAGE_INIT_EPHEMERAL_MIB, TOOL_RUNNER_EPHEMERAL_MIB, WORKER_EPHEMERAL_MIB, conformResources, describeMib, normalizePlatformMetadata, platformProfile, podEphemeralStorageMib, } from "./kubernetes-platform.js";
 export const KUBERNETES_ISOLATION_ERROR = "kubernetes_isolation_unsupported";
 /** Extra seconds past timeoutSec before Kubernetes kills the pod (keeper included). */
@@ -97,6 +97,9 @@ const STORAGE_DIRECTORIES = ["workspace", "input", "output"];
  * sandbox (GKE Autopilot annotates it `share: pod`), so the agent's relay can connect.
  */
 const TOOL_SOCKET_VOLUME = "tool-socket";
+/** Session resume only: the Claude worker's SDK config dir (docker-isolation.ts CLAUDE_CONFIG_SCRATCH_MIB). */
+const CLAUDE_CONFIG_VOLUME = "claude-config";
+export { CLAUDE_CONFIG_PATH, CLAUDE_CONFIG_SCRATCH_MIB };
 const TOOL_SOCKET_VOLUME_MIB = 1;
 /**
  * `reason` is a short, fixed code naming which check failed (never a value from the spec itself,
@@ -166,6 +169,9 @@ export function validateKubernetesSpec(spec) {
     else if (spec.toolImage !== undefined) {
         throw isolationError("tool-image-set");
     }
+    if (spec.sessionResume !== undefined && (spec.sessionResume !== true || spec.provider !== "claude-code")) {
+        throw isolationError("session-resume-not-claude");
+    }
     if (!isRegistryDigest(spec.image))
         throw isolationError("image-not-registry-digest");
     if (spec.services !== undefined) {
@@ -322,6 +328,8 @@ export function buildRunPod(spec, options) {
                 { name: TOOL_SOCKET_VOLUME, mountPath: "/run/wardby/tool" },
                 { name: "tmp", mountPath: "/tmp" },
                 { name: "home", mountPath: "/home/wardby" },
+                // Session resume: the SDK's config dir, where the session file grows, off /tmp's budget.
+                ...(spec.sessionResume ? [{ name: CLAUDE_CONFIG_VOLUME, mountPath: CLAUDE_CONFIG_PATH }] : []),
             ]
             : [
                 { name: "storage", mountPath: "/workspace", subPath: "workspace" },
@@ -414,6 +422,14 @@ export function buildRunPod(spec, options) {
                         { name: TOOL_SOCKET_VOLUME, emptyDir: { medium: "Memory", sizeLimit: `${TOOL_SOCKET_VOLUME_MIB}Mi` } },
                         { name: "tool-tmp", emptyDir: { medium: "Memory", sizeLimit: `${toolScratchMb}Mi` } },
                         { name: "tool-home", emptyDir: { medium: "Memory", sizeLimit: `${toolScratchMb}Mi` } },
+                        ...(spec.sessionResume
+                            ? [
+                                {
+                                    name: CLAUDE_CONFIG_VOLUME,
+                                    emptyDir: { medium: "Memory", sizeLimit: `${CLAUDE_CONFIG_SCRATCH_MIB}Mi` },
+                                },
+                            ]
+                            : []),
                     ]
                     : []),
                 ...serviceVolumes(services),

package/dist/providers/jobs/kubernetes.d.ts

@@ -4,7 +4,7 @@ import { type Power } from "../../core/power.js";
 import { type KubernetesApi } from "./kubernetes-api.js";
 import { type ServiceStateReporter } from "./service-state.js";
 import type { CodingProvider } from "../../coding/provider.js";
-import type { JobHandle, JobResult, JobSpec, JobStatus, WorkspaceJobLauncher } from "./types.js";
+import { type JobHandle, type JobResult, type JobSpec, type JobStatus, type WorkspaceJobLauncher } from "./types.js";
 export interface KubernetesClusterInfo {
     /** The proxy Service's ClusterIP: the enforcement witness's address (8787 reachable, 8788 not). */
     proxyIp: string;
@@ -165,6 +165,10 @@ export declare class KubernetesJobLauncher implements WorkspaceJobLauncher {
      * must not open the gate at the initial proof either.
      */
     private waitForPolicyEnforcement;
+    /** True when `found` is a requeued record for this spec, which launch() replaces with a fresh one. */
+    private isRequeued;
+    /** Tells the operator once that a quota refused a pod while no quota is configured for the pre-launch check. */
+    private hintQuotaUnconfigured;
     private existingLaunch;
     private provision;
     private createIfMissing;
@@ -178,6 +182,7 @@ export declare class KubernetesJobLauncher implements WorkspaceJobLauncher {
     private refresh;
     /** Reads only a fixed diagnostic code from a failed worker's bounded log tail; never keeps anything else. */
     private readWorkerDiagnostic;
+    readTranscript(handle: JobHandle, maxBytes: number): Promise<string | undefined>;
     private readResultArtifact;
     /**
      * Streams the keeper's workspace through the strict extractor into `staging`.