@wardby/cli 0.2.1 → 0.4.0

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

@@ -13,12 +13,22 @@
  * blinds the pre-flight refuse and mid-stream cutoff, and is not allowed.
  */
 import type { ProviderRegistry } from "../index.js";
+import type { LlmEffort } from "../llm/types.js";
 /** The subset of Agent fields the engine needs — not the Prisma type, to keep this seam Prisma-agnostic. */
 export interface EngineAgent {
     systemPrompt: string;
     model: string;
     budgetUsd: number;
     maxTurns: number;
+    /** Reasoning effort sent on every model call; absent = provider default. */
+    effort?: LlmEffort;
+    /**
+     * Background for this run that nobody vetted (e.g. the title and
+     * description of the GitHub issue a mention was made on). Delivered in the
+     * first user message inside untrusted_context tags, never in the system
+     * prompt. Absent = the first user message is just "Begin.".
+     */
+    untrustedContext?: string;
 }
 export interface LoadedTool {
     name: string;
@@ -40,6 +50,19 @@ export interface LoadedTool {
 export type StepRunner = <T>(name: string, fn: () => Promise<T>) => Promise<T>;
 /** The no-checkpoint default: run the step body directly. */
 export declare const runStepInline: StepRunner;
+/**
+ * Live progress after a completed model turn: absolute cumulative totals,
+ * never deltas, so re-delivering one (a DBOS replay re-runs the loop over
+ * recorded steps) rewrites the same values instead of double counting.
+ */
+export interface EngineProgress {
+    turns: number;
+    usage: {
+        tokensIn: number;
+        tokensOut: number;
+        costUsd: number;
+    };
+}
 export interface EngineRunContext {
     agent: EngineAgent;
     tools: LoadedTool[];
@@ -47,6 +70,8 @@ export interface EngineRunContext {
     /** Host bridge: validates params (Zod-in-sandbox) then runs the tool body in the WASM sandbox. Never throws — a tool/validation failure is a JSON error result string, fed back to the model as the tool's result. */
     runSandboxTool(name: string, argsJson: string): Promise<string>;
     onText?: (delta: string) => void;
+    /** Called after each model turn that completed without error; the engine awaits it. */
+    onProgress?: (progress: EngineProgress) => Promise<void>;
     /** See StepRunner. Optional; the in-process executor leaves it unset. */
     step?: StepRunner;
 }
@@ -59,6 +84,10 @@ export interface EngineResult {
         tokensIn: number;
         tokensOut: number;
         costUsd: number;
+        /** Subset of tokensIn served from a prompt cache. */
+        cachedInputTokens?: number;
+        /** Tokens billed for writing prompt-cache entries (not part of tokensIn). */
+        cacheWriteTokens?: number;
     };
     error?: string;
 }

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

@@ -1,6 +1,6 @@
 import type { PrismaClient } from "#prisma";
-import type { ProviderRegistry } from "../index.js";
+import type { NativeRunProviders } from "../../core/runner.js";
 import { type ProviderConfig } from "../../config/providers.js";
 import type { Executor } from "./types.js";
 /** Select the Executor adapter from EXECUTOR. Constructing never connects; call `launch?.()` for that. */
-export declare function buildExecutor(config: Pick<ProviderConfig, "executor">, providers: Pick<ProviderRegistry, "llm" | "engine" | "datastore" | "secrets" | "memory">, db?: PrismaClient, env?: NodeJS.ProcessEnv): Executor;
+export declare function buildExecutor(config: Pick<ProviderConfig, "executor">, providers: NativeRunProviders, db?: PrismaClient, env?: NodeJS.ProcessEnv): Executor;

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

@@ -2,6 +2,7 @@ import type { PrismaClient } from "#prisma";
 import { type ProviderConfig } from "../../config/providers.js";
 import type { KubernetesApi } from "../jobs/kubernetes-api.js";
 import type { Executor } from "./types.js";
+import { type RepoAccessGate } from "../../core/repo-access.js";
 export interface ConfiguredExecutorOptions {
     native: Executor;
     db: PrismaClient;
@@ -9,6 +10,8 @@ export interface ConfiguredExecutorOptions {
     providerConfig?: ProviderConfig;
     /** Tests only: replaces the kubeconfig-backed client when JOB_LAUNCHER=kubernetes. */
     kubernetesApi?: KubernetesApi;
+    /** Repository authorization for coding runs; built from the configured review hosts when absent. */
+    repoAccess?: RepoAccessGate;
 }
 /** Builds container execution only when Docker or Kubernetes is explicitly selected. */
 export declare function buildConfiguredExecutor(options: ConfiguredExecutorOptions): Executor;

package/dist/providers/executor/composition.js

@@ -1,7 +1,9 @@
 import { tmpdir } from "node:os";
 import { resolve } from "node:path";
 import { loadCodingConcurrencyConfig, loadContainerExecutorConfig, loadGitHubVcsConfig, loadKubernetesJobConfig, loadProviderConfig, } from "../../config/providers.js";
+import { summarizeRegistryFetches } from "../../coding/registry/report.js";
 import { drainCodingQueue } from "../../core/coding-queue.js";
+import { prismaServiceStateReporter } from "../../core/coding-service-status.js";
 import { logger } from "../../core/logger.js";
 import { EnvironmentCredentialResolver } from "../coding-proxy/environment-credentials.js";
 import { CodingProxy } from "../coding-proxy/proxy.js";
@@ -15,6 +17,9 @@ import { KubernetesJobLauncher } from "../jobs/kubernetes.js";
 import { buildVcsProvider } from "../vcs/index.js";
 import { ContainerExecutor, PrismaContainerExecutionStore, RunCapabilityVault } from "./container.js";
 import { PrismaExecutionKindResolver, RoutingExecutor } from "./routing.js";
+import { createRepoAccessGate } from "../../core/repo-access.js";
+import { buildIssueTrackers } from "../issue-tracker/index.js";
+import { buildReviewHosts } from "../review-host/index.js";
 const compositionLog = logger.child({ module: "executor-composition" });
 /** Builds container execution only when Docker or Kubernetes is explicitly selected. */
 export function buildConfiguredExecutor(options) {
@@ -38,11 +43,21 @@ export function buildConfiguredExecutor(options) {
         ledger: new PrismaProxyLedger(options.db),
         credentials: new EnvironmentCredentialResolver(env),
     });
+    const onServiceState = prismaServiceStateReporter(options.db);
     let jobs;
     if (providerConfig.jobs === "kubernetes") {
         if (!isRegistryDigest(config.workerImage)) {
             throw new Error("CODING_WORKER_IMAGE must be a registry digest (repo@sha256:...) when JOB_LAUNCHER=kubernetes.");
         }
+        for (const image of [config.claudeWorkerImage, config.claudeToolRunnerImage]) {
+            if (image !== undefined && !isRegistryDigest(image)) {
+                throw new Error("CODING_CLAUDE_WORKER_IMAGE and CODING_CLAUDE_TOOL_RUNNER_IMAGE must be registry digests (repo@sha256:...) when JOB_LAUNCHER=kubernetes.");
+            }
+        }
+        const claudePython = config.claudeToolRunnerImages["node-python"]?.["3.12"];
+        if (claudePython !== undefined && !isRegistryDigest(claudePython)) {
+            throw new Error("CODING_CLAUDE_TOOL_RUNNER_IMAGE_NODE_PYTHON_3_12 must be a registry digest (repo@sha256:...) when JOB_LAUNCHER=kubernetes.");
+        }
         const kubernetes = loadKubernetesJobConfig(env);
         // The preflight only runs on the first launch; a configuration that cannot work should
         // fail the process at start-up, not the first coding run an hour later.
@@ -53,11 +68,13 @@ export function buildConfiguredExecutor(options) {
         const api = options.kubernetesApi ?? new ClientNodeKubernetesApi({ context: kubernetes.context });
         const workerImage = config.workerImage;
         jobs = new KubernetesJobLauncher({
+            onServiceState,
             api,
             config: kubernetes,
             workspaceRoot,
             resolveCapability: (runId) => capabilities.get(runId),
             readyTimeoutMs: kubernetes.readyTimeoutMs,
+            enforcementExecTimeoutMs: kubernetes.enforcementExecTimeoutMs,
             preflight: async () => {
                 const { proxyIp } = await runKubernetesPreflight({
                     api,
@@ -74,6 +91,7 @@ export function buildConfiguredExecutor(options) {
     else {
         const stateRoot = resolve(config.stateRoot ?? resolve(tmpdir(), "wardby-docker-jobs"));
         jobs = new DockerJobLauncher({
+            onServiceState,
             stateRoot,
             workspaceRoot,
             proxyContainer: proxyContainer,
@@ -87,12 +105,13 @@ export function buildConfiguredExecutor(options) {
             },
         });
     }
+    const issueTrackers = buildIssueTrackers(env);
     const concurrency = loadCodingConcurrencyConfig(env);
     // The release hook needs the composed RoutingExecutor, which only exists
     // after the ContainerExecutor it wraps is built. The closure reads
     // `composed` only when a run finishes, which is after this function returns.
     const coding = new ContainerExecutor({
-        store: new PrismaContainerExecutionStore(options.db, { maxConcurrent: concurrency.maxConcurrent }),
+        store: new PrismaContainerExecutionStore(options.db, { maxConcurrent: concurrency.maxConcurrent, issueTrackers }),
         jobs,
         vcs,
         sessions,
@@ -101,17 +120,25 @@ export function buildConfiguredExecutor(options) {
         workerImage: config.workerImage,
         claudeWorkerImage: config.claudeWorkerImage,
         claudeToolRunnerImage: config.claudeToolRunnerImage,
+        claudeToolRunnerImages: config.claudeToolRunnerImages,
         additionalWorkerImages: config.additionalWorkerImages,
         credentialRef: config.credentialRef,
         anthropicCredentialRef: config.anthropicCredentialRef,
         limits: { cpus: config.cpus, memoryMb: config.memoryMb, pids: config.pids, diskMb: config.diskMb },
         maxDiskMb: config.maxDiskMb,
+        repoAccess: options.repoAccess ?? createRepoAccessGate({ db: options.db, hosts: buildReviewHosts(env) }),
+        issueUrl: (provider, key) => (provider === "jira" ? issueTrackers.jira?.issueUrl(key) : undefined),
+        registryReport: async (runId) => {
+            const rows = await options.db.registryFetch.findMany({ where: { runId }, orderBy: { createdAt: "asc" } });
+            return summarizeRegistryFetches(rows);
+        },
         onSlotReleased: () => {
             void drainCodingQueue({
                 db: options.db,
                 executor: composed,
                 maxConcurrent: concurrency.maxConcurrent,
                 queueTimeoutSec: concurrency.queueTimeoutSec,
+                selfDefects: { db: options.db, issueTrackers },
             }).catch((err) => {
                 // Never throws: the next scheduler tick drains again.
                 compositionLog.warn({ err }, "coding queue drain after a released slot failed");

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

@@ -1,10 +1,19 @@
 import type { PrismaClient } from "#prisma";
+import { type CodingProvider } from "../../coding/provider.js";
+import type { IssueTrackerRegistry } from "../issue-tracker/types.js";
+import { type RepoAccessGate } from "../../core/repo-access.js";
 import { type CodingRunObserver } from "../../coding/observability.js";
 import { type CodingRunResult } from "../../coding/protocol.js";
-import type { ProxyProtocol } from "../coding-proxy/types.js";
+import type { ProxyModelTerms, ProxyProtocol } from "../coding-proxy/types.js";
 import type { JobHandle, JobResourceLimits, WorkspaceJobLauncher } from "../jobs/types.js";
 import type { VcsProvider } from "../vcs/types.js";
 import type { CodingImageSelector, ExecutionRecoveryResult, Executor, PersistedExecutionHandle } from "./types.js";
+/**
+ * Claude Code's commands run in its tool runner, which never reports back through the agent, so the
+ * host rewrites registry-proxy download URLs in collected lockfiles itself (the Codex driver does it
+ * in the worker). Best effort and symlink-safe (lockfiles.ts); a Codex workspace is left alone.
+ */
+export declare function normalizeCollectedLockfiles(provider: string, workspacePath: string): Promise<string[]>;
 export interface ContainerRunSnapshot {
     runId: string;
     status: string;
@@ -19,11 +28,18 @@ export interface ContainerRunSnapshot {
     provider: string;
     model: string;
     timeoutSec: number;
-    allowedEgress: unknown;
     protectedPaths: unknown;
+    /** Stored per-agent collection paths; see src/coding/collect-exclude.ts. */
+    collectExclude: unknown;
     /** Revision-in-place: set when this run continues another run's branch/PR. See preflight(). */
     rootCodingRunId: string | null;
+    /** The issue that triggered this run (CodingRun.issueProvider/issueKey); null when none. */
+    issueProvider?: string | null;
+    issueKey?: string | null;
     budgetUsd: number;
+    /** The agent's own per-run budget; `budgetUsd` is less when its budget group had less left. */
+    agentBudgetUsd?: number;
+    budgetGroupName?: string | null;
     tokensIn: number;
     tokensOut: number;
     costUsd: number;
@@ -32,7 +48,22 @@ export interface ContainerRunSnapshot {
     proxySessionId: string | null;
     result: unknown;
     workerImage: string | null;
+    /** Claude's tool-runner image, resolved at dispatch (CodingRun.toolImage); null on older rows and Codex runs. */
+    toolImage?: string | null;
     workspaceDiskMb: number | null;
+    /** Admin-requested debug trace, fixed at dispatch (CodingRun.debugTrace). */
+    debugTrace?: boolean;
+    /** Coding-run services resolved at dispatch (CodingRun.services); parsed with parseStoredServices. */
+    services?: unknown;
+    /** The terminal failure category, once the run has one (CodingRun.failureCategory). */
+    failureCategory?: string | null;
+    /** The agent's CURRENT coding-profile repository (null if the profile is gone); may differ from `repository`. */
+    profileRepository: string | null;
+    /** How the profile's repository was authorized (CodingAgentProfile.repositoryAuthorizedVia). */
+    repositoryAuthorizedVia: string | null;
+    /** The run's catalog entry recorded at dispatch (Run.pricingSnapshot); null on runs from before the catalog. */
+    pricingVersion: string | null;
+    pricingSnapshot: unknown;
 }
 /**
  * claimed: this caller owns provisioning. unavailable: someone else does, or
@@ -47,7 +78,7 @@ export interface ContainerExecutionStore {
     persistHandle(runId: string, claimId: string, handle: JobHandle): Promise<void>;
     heartbeat(runId: string): Promise<void>;
     complete(runId: string, status: "succeeded" | "budget_exhausted", result: CodingRunResult): Promise<void>;
-    terminate(runId: string, status: "failed" | "refused" | "lost" | "cancelled", error: string, audit?: CodingFailureAudit): Promise<void>;
+    terminate(runId: string, status: "failed" | "refused" | "lost" | "budget_exhausted" | "cancelled", error: string, audit?: CodingFailureAudit): Promise<void>;
 }
 export interface CodingFailureAudit {
     failureCategory: string;
@@ -58,13 +89,19 @@ export declare class PrismaContainerExecutionStore implements ContainerExecution
     private readonly options;
     constructor(db: PrismaClient, options?: {
         maxConcurrent?: number;
+        /** Configured issue trackers: a coding run this store ends failed/lost/budget_exhausted files a self-defect. */
+        issueTrackers?: IssueTrackerRegistry;
     });
+    /** Best effort (bounded, never throws): only called by the write that made the row terminal, so it files once. */
+    private selfDefect;
+    /** An empty registry (no Jira site configured) means no self-defect queries at all. */
+    private get hasTrackers();
     load(runId: string): Promise<ContainerRunSnapshot | null>;
     claimProvisioning(runId: string, claimId: string): Promise<ProvisioningClaim>;
     persistHandle(runId: string, claimId: string, handle: JobHandle): Promise<void>;
     heartbeat(runId: string): Promise<void>;
     complete(runId: string, status: "succeeded" | "budget_exhausted", result: CodingRunResult): Promise<void>;
-    terminate(runId: string, status: "failed" | "refused" | "lost" | "cancelled", error: string, audit?: CodingFailureAudit): Promise<void>;
+    terminate(runId: string, status: "failed" | "refused" | "lost" | "budget_exhausted" | "cancelled", error: string, audit?: CodingFailureAudit): Promise<void>;
 }
 export interface CodingSessionController {
     createSession(input: {
@@ -74,11 +111,17 @@ export interface CodingSessionController {
         allowedModels: string[];
         deadlineAt: Date;
         budgetUsd: number;
+        /** The run's catalog entry; the proxy prices and shapes the run's requests from it. */
+        terms?: ProxyModelTerms;
     }): Promise<{
         id: string;
         capability: string;
     }>;
     cancelSession(sessionId: string): Promise<void>;
+    /** Whether the proxy refused a request of this session for budget. */
+    budgetExhausted?(sessionId: string): Promise<boolean>;
+    /** The code of the first model-provider failure the proxy relayed for this session, if any. */
+    upstreamFailure?(sessionId: string): Promise<string | null>;
 }
 /** Plain capabilities live only for the short provisioning window. */
 export declare class RunCapabilityVault {
@@ -100,6 +143,12 @@ export interface ContainerExecutorOptions {
     credentialRef: string;
     claudeWorkerImage?: string;
     claudeToolRunnerImage?: string;
+    /**
+     * Claude tool-runner images for toolchains beyond the "node" baseline (claudeToolRunnerImage),
+     * keyed by toolchain, then version -- the same shape as additionalWorkerImages. Claude's agent
+     * image is the same for every toolchain; only the tool runner, which runs the commands, differs.
+     */
+    claudeToolRunnerImages?: Record<string, Record<string, string>>;
     anthropicCredentialRef?: string;
     limits: JobResourceLimits;
     /** Operator ceiling (MiB) on CodingRun.workspaceDiskMb; see coding_workspace_disk_exceeds_limit in jobSpec. */
@@ -117,6 +166,35 @@ export interface ContainerExecutorOptions {
      * than on the next scheduler tick. Never called for a run that was queued.
      */
     onSlotReleased?: () => void;
+    /**
+     * Loads this run's RegistryFetch ledger (composition.ts wires the Prisma
+     * query) so finalizeChanges can surface installed/refused packages in the
+     * PR body. Optional so tests and non-registry deployments can omit it;
+     * a rejection is swallowed and treated as "nothing to report" since a
+     * reporting failure must never fail the run itself.
+     */
+    registryReport?: (runId: string) => Promise<RegistryReport>;
+    /** Browse URL for an issue of a tracker provider (composition wires the issue-tracker registry); undefined when unconfigured. */
+    issueUrl?: (provider: string, key: string) => string | undefined;
+    /**
+     * Repository authorization: every run is checked, before its workspace is
+     * prepared, against the agent owner's current GitHub access (or a recorded
+     * admin/grandfathered approval of this exact repository).
+     */
+    repoAccess: RepoAccessGate;
+}
+/** A run's deduplicated served packages and refusals (see summarizeRegistryFetches). */
+export interface RegistryReport {
+    packages: Array<{
+        ecosystem: string;
+        name: string;
+        version: string;
+    }>;
+    packageRefusals: Array<{
+        ecosystem: string;
+        name: string;
+        reason: string;
+    }>;
 }
 export declare class ContainerExecutor implements Executor {
     private readonly options;
@@ -155,10 +233,44 @@ export declare class ContainerExecutor implements Executor {
      * that is otherwise healthy.
      */
     private whileHeartbeating;
+    /**
+     * The run may use its repository only if the agent's current owner still
+     * has write on it, or the profile's approval (admin or grandfathered)
+     * covers exactly this repository. A profile changed since dispatch no
+     * longer covers the run's repository, so that falls back to the owner's
+     * access. Throws RepoAccessError (refused before anything is cloned).
+     */
+    private authorizeRepository;
+    /** The originating issue for the PR title/body: control-plane data from the CodingRun row, key re-validated. */
+    private issueFor;
+    /** The run's stored model terms; a run from before the catalog resolves them from the current catalog. */
+    private modelTerms;
     private preflight;
     private finishTerminal;
+    /** The package report is informational: any failure loading it (a
+     *  rejection, a synchronous throw, or a malformed result) yields no
+     *  package section rather than failing finalization. */
+    private loadRegistryReport;
     private resultFor;
     resolveCodingWorkerImage(selector: CodingImageSelector): string;
+    /** Claude's tool-runner image for the agent's toolchain, at dispatch (Executor.resolveCodingToolImage); null for Codex. */
+    resolveCodingToolImage(selector: CodingImageSelector): string | null;
+    /** The tool runner is what runs a Claude agent's commands, so it is what the toolchain selects. */
+    private claudeToolImage;
+    /** Coding-run services: the repository's declaration at its base ref (Executor.readCodingServiceDeclaration). */
+    readCodingServiceDeclaration(input: {
+        repository: string;
+        baseRef: string;
+    }): Promise<string | null>;
+    /** One repository file at the run's base ref (Executor.readCodingRepositoryFile). */
+    readCodingRepositoryFile(input: {
+        repository: string;
+        baseRef: string;
+        path: string;
+        maxBytes: number;
+    }): Promise<string | null>;
+    /** The job launcher decides (Kubernetes and Docker start services for both providers). */
+    supportsCodingServices(provider: CodingProvider): boolean;
     private requireCurrent;
     private jobSpec;
     private credentialRef;
@@ -167,6 +279,24 @@ export declare class ContainerExecutor implements Executor {
     private preflightForCleanup;
     private abandon;
     private cleanupTerminal;
+    /** Whether the proxy refused this run's session for budget. Never throws. */
+    private outOfBudget;
+    /** The model-provider failure the proxy relayed for this run's session, classified. Never throws. */
+    private providerFailure;
+    /**
+     * A failure the model provider's refusal caused. The persisted error names
+     * the class only; the raw upstream code (a fixed identifier, never a message)
+     * goes to one operator line an alert can key on, and the failure itself is
+     * still logged under its diagnostic id.
+     */
+    private providerFailureOf;
+    /** The host-safe sentence for a run that ran out of budget. */
+    private budgetSentence;
+    /**
+     * A failure the proxy's budget refusal caused. The failure itself is still
+     * logged under its diagnostic id, so the operator keeps the real reason.
+     */
+    private budgetFailure;
     private emit;
     private terminal;
     /**