@wardby/cli 0.5.3 → 0.7.0

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

@@ -1,5 +1,6 @@
 import { type CatalogEntry } from "../llm/catalog-types.js";
 import type { ModelPricing } from "../llm/pricing-core.js";
+import type { ProxyRefusalDetails } from "../../core/budget-events.js";
 export type ProxySessionStatus = "active" | "cancelled";
 export type ProxyRequestStatus = "reserved" | "completed" | "released" | "uncertain";
 export type ProxyProtocol = "openai-responses" | "anthropic-messages";
@@ -39,6 +40,8 @@ export interface ProxySession {
     registryTokenHash?: string | null;
     /** When the ledger first refused a request of this session for budget. */
     budgetExhaustedAt?: Date | null;
+    /** The numbers behind the first budget refusal, set with budgetExhaustedAt. */
+    budgetRefusal?: ProxyRefusalRecord | null;
     /** The code of the first upstream failure the proxy relayed for this session. */
     upstreamFailure?: string | null;
     /** The run's catalog entry, copied at session creation; null on sessions from before the catalog. */
@@ -56,6 +59,24 @@ export interface ProxyRequest {
     pricing: PricingSnapshot;
     usage?: ProxyUsage;
     upstreamStatus?: number;
+    /** An uncertain request settled at an estimate: actualCostUsd and usage are estimated, not reported. */
+    costEstimated?: boolean;
+    requestBytes?: number;
+    ceilingUsd?: number;
+    reservationBasis?: ReservationBasis;
+    conversationKey?: string | null;
+}
+export type ReservationBasis = "cached" | "full";
+/** The latest finished (completed or uncertain) request of a conversation, for the next request's hold. */
+export interface PreviousReply {
+    model: string;
+    status: "completed" | "uncertain";
+    costEstimated: boolean;
+    usage?: ProxyUsage;
+    /** UTF-8 bytes of the request body the proxy forwarded; null on rows from before cache-aware holds. */
+    requestBytes: number | null;
+    /** When the previous request was reserved: the prompt cache was last refreshed around then. */
+    startedAt: Date;
 }
 export interface CreateProxySessionInput {
     id: string;
@@ -78,7 +99,13 @@ export interface ReserveProxyRequestInput {
     reservationUsd: number;
     pricing: PricingSnapshot;
     now: Date;
+    requestBytes?: number;
+    ceilingUsd?: number;
+    reservationBasis?: ReservationBasis;
+    conversationKey?: string | null;
 }
+/** What the proxy knows about a refusal: the numbers only; names and the binding limit are the control plane's. */
+export type ProxyRefusalRecord = Omit<ProxyRefusalDetails, "agentBudgetUsd" | "groupName" | "leadAgentName">;
 export type ReserveProxyRequestResult = {
     outcome: "reserved";
     request: ProxyRequest;
@@ -87,6 +114,7 @@ export type ReserveProxyRequestResult = {
     request: ProxyRequest;
 } | {
     outcome: "budget_exhausted";
+    details: Omit<ProxyRefusalRecord, "source">;
 } | {
     outcome: "inactive";
     reason: "cancelled" | "expired";
@@ -97,10 +125,28 @@ export interface ProxyLedger {
     reserve(input: ReserveProxyRequestInput): Promise<ReserveProxyRequestResult>;
     complete(requestId: string, usage: ProxyUsage, actualCostUsd: number, upstreamStatus: number): Promise<ProxyRequest>;
     release(requestId: string, upstreamStatus: number): Promise<void>;
-    markUncertain(requestId: string, upstreamStatus?: number): Promise<void>;
+    /**
+     * Marks a reserved request uncertain. With an estimate it is also settled at that cost (and
+     * counts at it, not at its hold); without one it keeps its full hold.
+     */
+    markUncertain(requestId: string, upstreamStatus?: number, estimate?: {
+        usage: ProxyUsage;
+        costUsd: number;
+    }): Promise<void>;
+    /**
+     * What an interrupted reply's output can be estimated from: the median output tokens of the
+     * session's completed replies for this model. Its input comes from previousReply.
+     */
+    settlementHints(sessionId: string, model: string): Promise<{
+        medianOutputTokens?: number;
+    }>;
+    /** The latest completed or uncertain request of a conversation, or null when it has none. */
+    previousReply(sessionId: string, conversationKey: string): Promise<PreviousReply | null>;
     cancelSession(sessionId: string): Promise<void>;
     /** Whether a request of this session was ever refused for budget. */
     budgetExhausted(sessionId: string): Promise<boolean>;
+    /** The numbers behind the session's first budget refusal, if any. */
+    budgetRefusal(sessionId: string): Promise<ProxyRefusalRecord | null>;
     /** Records an upstream failure code on the session; only the first one is kept. */
     recordUpstreamFailure(sessionId: string, code: string): Promise<void>;
     /** The first upstream failure code relayed for this session, if any. */
@@ -115,7 +161,25 @@ export interface ProxyAuditEvent {
     status?: number;
     reason?: string;
     reservationUsd?: number;
+    /** For request.reserved and a budget refusal: the worst-case hold and how the hold was priced. */
+    ceilingUsd?: number;
+    reservationBasis?: ReservationBasis;
+    /** Why the hold fell back to the ceiling (basis "full"). */
+    holdFallback?: string;
+    /** Basis "cached": tokens priced at the cache-read rate, and at the input + cache-write rates. */
+    holdCachedTokens?: number;
+    holdUncachedTokens?: number;
+    /** For response.completed: how much the reply cost above its hold (reason "reservation_exceeded"). */
+    overshootUsd?: number;
+    /** For a budget refusal: the numbers behind it. */
+    budgetUsd?: number;
+    spentUsd?: number;
+    heldReservedUsd?: number;
+    heldUncertainUsd?: number;
+    turn?: number;
     costUsd?: number;
+    /** For request.uncertain: the estimated cost it was settled at, when one could be made. */
+    estimatedCostUsd?: number;
     inputTokens?: number;
     outputTokens?: number;
     cachedInputTokens?: number;

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

@@ -15,6 +15,11 @@ export interface DatastoreSetOptions {
      * for values that actually carry PII.
      */
     pii?: boolean;
+    /**
+     * Shared stores only: the agent doing the write, so the secret guard can
+     * check the value against that agent's attached secrets. Never persisted.
+     */
+    writerAgentId?: string;
 }
 export interface Datastore {
     get(agentId: string, key: string): Promise<DatastoreValue | undefined>;

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

@@ -48,6 +48,40 @@ export interface LoadedTool {
  * only on earlier step results and on `agent` fields fixed at run start.
  */
 export type StepRunner = <T>(name: string, fn: () => Promise<T>) => Promise<T>;
+/**
+ * Part of the StepRunner contract: a step runner may throw this when another
+ * execution of the same run recorded the step first, so this attempt no
+ * longer owns the run. The attempt must stop without writing the run (the
+ * winner does that); engines and the runner rethrow it untouched.
+ */
+export declare class RunOwnershipLostError extends Error {
+    readonly step: string;
+    /**
+     * Usage the losing step's body reported before its result was discarded
+     * (an LLM turn's token counts and cost), when the step runner saw it. Not
+     * recorded on any run: the winner's result replaces it. Logged only.
+     */
+    readonly discardedUsage?: Readonly<Record<string, number>>;
+    constructor(step: string, options?: {
+        cause?: unknown;
+        discardedUsage?: Readonly<Record<string, number>>;
+    });
+}
+/** Why a run ends lost when its replay meets a step its record does not have (StepReplayMismatchError). */
+export declare const STEPS_CHANGED_REASON = "Could not continue across versions: the run's steps changed in the new version.";
+/**
+ * Part of the StepRunner contract: a durable step runner may throw this when a
+ * replayed run reaches a step whose name differs from the one recorded at that
+ * position (the run was recorded by a release whose steps differ). The run
+ * cannot continue from its record; engines rethrow it untouched and the
+ * runner ends the run lost with STEPS_CHANGED_REASON.
+ */
+export declare class StepReplayMismatchError extends Error {
+    readonly step: string;
+    constructor(step: string, options?: {
+        cause?: unknown;
+    });
+}
 /** The no-checkpoint default: run the step body directly. */
 export declare const runStepInline: StepRunner;
 /**
@@ -67,8 +101,8 @@ export interface EngineRunContext {
     agent: EngineAgent;
     tools: LoadedTool[];
     providers: Pick<ProviderRegistry, "llm">;
-    /** 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>;
+    /** 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. `callId` is the model's id for this tool call; the same on a replay of the turn. */
+    runSandboxTool(name: string, argsJson: string, callId?: string): Promise<string>;
     /**
      * Consecutive tool calls of one model turn for which this returns true run
      * at the same time as each other (a lead's delegate_to_* calls, when the

package/dist/providers/engine/types.js

@@ -12,5 +12,44 @@
  * which engine is driving: an engine that calls a provider SDK directly
  * blinds the pre-flight refuse and mid-stream cutoff, and is not allowed.
  */
+/**
+ * Part of the StepRunner contract: a step runner may throw this when another
+ * execution of the same run recorded the step first, so this attempt no
+ * longer owns the run. The attempt must stop without writing the run (the
+ * winner does that); engines and the runner rethrow it untouched.
+ */
+export class RunOwnershipLostError extends Error {
+    step;
+    /**
+     * Usage the losing step's body reported before its result was discarded
+     * (an LLM turn's token counts and cost), when the step runner saw it. Not
+     * recorded on any run: the winner's result replaces it. Logged only.
+     */
+    discardedUsage;
+    constructor(step, options) {
+        super(`run_ownership_lost: another execution recorded step "${step}" first; this attempt stops.`, options?.cause === undefined ? undefined : { cause: options.cause });
+        this.name = "RunOwnershipLostError";
+        this.step = step;
+        if (options?.discardedUsage)
+            this.discardedUsage = options.discardedUsage;
+    }
+}
+/** Why a run ends lost when its replay meets a step its record does not have (StepReplayMismatchError). */
+export const STEPS_CHANGED_REASON = "Could not continue across versions: the run's steps changed in the new version.";
+/**
+ * Part of the StepRunner contract: a durable step runner may throw this when a
+ * replayed run reaches a step whose name differs from the one recorded at that
+ * position (the run was recorded by a release whose steps differ). The run
+ * cannot continue from its record; engines rethrow it untouched and the
+ * runner ends the run lost with STEPS_CHANGED_REASON.
+ */
+export class StepReplayMismatchError extends Error {
+    step;
+    constructor(step, options) {
+        super(`step_replay_mismatch: the recorded run has a different step where "${step}" was expected.`, options?.cause === undefined ? undefined : { cause: options.cause });
+        this.name = "StepReplayMismatchError";
+        this.step = step;
+    }
+}
 /** The no-checkpoint default: run the step body directly. */
 export const runStepInline = (_name, fn) => fn();

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

@@ -1,10 +1,30 @@
 import type { PrismaClient } from "#prisma";
 import { type ProviderConfig } from "../../config/providers.js";
+import { type Power } from "../../core/power.js";
+import { type ReReviewDeps } from "../../core/review-fix.js";
 import type { KubernetesApi } from "../jobs/kubernetes-api.js";
+import { loadAgentSecretValues } from "../../core/secret-guard.js";
 import type { Executor } from "./types.js";
 import { type RepoAccessGate } from "../../core/repo-access.js";
+/**
+ * The coding-run terminal hook: a review-fix round's coding run that made no change re-reviews
+ * the PR once (core/review-fix.ts), and the reviews of its pull request that waited for it (a
+ * draft's head it may have pushed before recording its result, core/host-events.ts) are
+ * released. Started in the background so the executor's terminal path (and the slot release
+ * after it) never waits on the host; idempotent (released rows are claimed), and never throws.
+ * Started outside the caller's async context: a delegated coding run finishes inside its lead's
+ * delegation step, and a review started from there would be refused by DBOS as a workflow
+ * started from inside a step. `deps` is read only when a run finishes, after composition returned.
+ */
+export declare function reReviewOnCodingRunTerminal(deps: () => ReReviewDeps): (runId: string) => void;
 export interface ConfiguredExecutorOptions {
     native: Executor;
+    /**
+     * Runs native agents whose run snapshot says `sandbox`. Composed whether or
+     * not a coding job launcher is configured. Absent: sandbox runs go to
+     * `native`, whose runner refuses them (RoutingExecutor).
+     */
+    nativeSandbox?: Executor;
     db: PrismaClient;
     env?: NodeJS.ProcessEnv;
     providerConfig?: ProviderConfig;
@@ -12,6 +32,16 @@ export interface ConfiguredExecutorOptions {
     kubernetesApi?: KubernetesApi;
     /** Repository authorization for coding runs; built from the configured review hosts when absent. */
     repoAccess?: RepoAccessGate;
+    /**
+     * Low-power mode, built once by the composition root and shared. Used only by the Kubernetes
+     * launcher (wakes the coding proxy before a run); absent: `DISABLED_POWER`.
+     */
+    power?: Power;
+    /** Decrypts agent secrets for transcript redaction (session resume). Absent: transcripts are never stored. */
+    secretCipher?: Parameters<typeof loadAgentSecretValues>[1];
 }
-/** Builds container execution only when Docker or Kubernetes is explicitly selected. */
+/**
+ * Builds container execution only when Docker or Kubernetes is explicitly
+ * selected, and native sandbox routing whenever a sandbox executor is given.
+ */
 export declare function buildConfiguredExecutor(options: ConfiguredExecutorOptions): Executor;

package/dist/providers/executor/composition.js

@@ -1,10 +1,16 @@
 import { tmpdir } from "node:os";
 import { resolve } from "node:path";
-import { loadCodingConcurrencyConfig, loadContainerExecutorConfig, loadGitHubVcsConfig, loadKubernetesJobConfig, loadProviderConfig, } from "../../config/providers.js";
+import { loadBlobStoreConfig, loadCodingConcurrencyConfig, loadContainerExecutorConfig, loadGitHubVcsConfig, loadKubernetesJobConfig, loadProviderConfig, } from "../../config/providers.js";
+import { summarizePackageAudit } from "../../coding/registry/audit-mode.js";
 import { summarizeRegistryFetches } from "../../coding/registry/report.js";
+import { linkedIssueReader } from "./linked-issue-reader.js";
 import { drainCodingQueue } from "../../core/coding-queue.js";
 import { prismaServiceStateReporter } from "../../core/coding-service-status.js";
 import { logger } from "../../core/logger.js";
+import { outsideRunContext } from "../../core/async-context.js";
+import { DISABLED_POWER } from "../../core/power.js";
+import { startDeferredForRequest } from "../../core/host-events.js";
+import { reReviewAfterNoChangeFix } from "../../core/review-fix.js";
 import { EnvironmentCredentialResolver } from "../coding-proxy/environment-credentials.js";
 import { CodingProxy } from "../coding-proxy/proxy.js";
 import { PrismaProxyLedger } from "../coding-proxy/prisma-ledger.js";
@@ -16,18 +22,50 @@ import { preflightCanaryImage, runKubernetesPreflight } from "../jobs/kubernetes
 import { CODING_WORKER_IMAGES_REQUIRED } from "../../coding/docker-preflight.js";
 import { KubernetesJobLauncher } from "../jobs/kubernetes.js";
 import { buildVcsProvider } from "../vcs/index.js";
+import { RunTranscriptRecorder, loadTranscriptMaxBytes, loadTranscriptRetentionDays, } from "../../coding/transcript/recorder.js";
+import { loadAgentSecretValues } from "../../core/secret-guard.js";
+import { createBlobStore } from "../storage/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. */
+/**
+ * The coding-run terminal hook: a review-fix round's coding run that made no change re-reviews
+ * the PR once (core/review-fix.ts), and the reviews of its pull request that waited for it (a
+ * draft's head it may have pushed before recording its result, core/host-events.ts) are
+ * released. Started in the background so the executor's terminal path (and the slot release
+ * after it) never waits on the host; idempotent (released rows are claimed), and never throws.
+ * Started outside the caller's async context: a delegated coding run finishes inside its lead's
+ * delegation step, and a review started from there would be refused by DBOS as a workflow
+ * started from inside a step. `deps` is read only when a run finishes, after composition returned.
+ */
+export function reReviewOnCodingRunTerminal(deps) {
+    return (runId) => outsideRunContext(() => {
+        void Promise.resolve()
+            .then(() => reReviewAfterNoChangeFix(runId, deps()))
+            .catch((err) => compositionLog.warn({ err, runId }, "no-change re-review hook failed"));
+        // Never throws (logs its own failures).
+        void Promise.resolve()
+            .then(() => startDeferredForRequest(deps(), runId))
+            .catch((err) => compositionLog.warn({ err, runId }, "could not release the reviews waiting for this run"));
+    });
+}
+/**
+ * Builds container execution only when Docker or Kubernetes is explicitly
+ * selected, and native sandbox routing whenever a sandbox executor is given.
+ */
 export function buildConfiguredExecutor(options) {
     const env = options.env ?? process.env;
     const providerConfig = options.providerConfig ?? loadProviderConfig(env);
-    if (providerConfig.jobs !== "docker" && providerConfig.jobs !== "kubernetes")
-        return options.native;
+    if (providerConfig.jobs !== "docker" && providerConfig.jobs !== "kubernetes") {
+        if (!options.nativeSandbox)
+            return options.native;
+        // No coding launcher: coding runs reach the native executor, whose runner fails them with
+        // the "needs a container executor" explanation, exactly as without this wrapper.
+        return new RoutingExecutor(new PrismaExecutionKindResolver(options.db), options.native, options.native, options.nativeSandbox);
+    }
     const github = loadGitHubVcsConfig(env);
     const config = loadContainerExecutorConfig(env);
     // Each provider's images are optional, but a coding launcher with neither can run nothing.
@@ -80,6 +118,7 @@ export function buildConfiguredExecutor(options) {
             resolveCapability: (runId) => capabilities.get(runId),
             readyTimeoutMs: kubernetes.readyTimeoutMs,
             enforcementExecTimeoutMs: kubernetes.enforcementExecTimeoutMs,
+            power: options.power ?? DISABLED_POWER,
             preflight: async () => {
                 const { proxyIp } = await runKubernetesPreflight({
                     api,
@@ -112,10 +151,27 @@ export function buildConfiguredExecutor(options) {
     }
     const issueTrackers = buildIssueTrackers(env);
     const concurrency = loadCodingConcurrencyConfig(env);
-    // The release hook needs the composed RoutingExecutor, which only exists
+    const reviewHosts = buildReviewHosts(env, options.db);
+    const repoAccess = options.repoAccess ?? createRepoAccessGate({ db: options.db, hosts: reviewHosts });
+    // The release and terminal hooks need 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 blobStoreConfig = loadBlobStoreConfig(env);
+    const cipher = options.secretCipher;
+    const transcripts = new RunTranscriptRecorder({
+        db: options.db,
+        blobs: blobStoreConfig && cipher ? createBlobStore(blobStoreConfig) : undefined,
+        secretValues: async (agentId) => {
+            if (!cipher)
+                throw new Error("transcript_secrets_unavailable");
+            const named = await loadAgentSecretValues(options.db, cipher, agentId);
+            return named.flatMap((entry) => entry.values);
+        },
+        retentionDays: loadTranscriptRetentionDays(env),
+        maxBytes: loadTranscriptMaxBytes(env),
+    });
     const coding = new ContainerExecutor({
+        transcripts,
         store: new PrismaContainerExecutionStore(options.db, { maxConcurrent: concurrency.maxConcurrent, issueTrackers }),
         jobs,
         vcs,
@@ -131,12 +187,29 @@ export function buildConfiguredExecutor(options) {
         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, options.db) }),
+        repoAccess,
+        readLinkedIssue: linkedIssueReader({ hosts: reviewHosts, issueTrackers }),
         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);
+            const coding = await options.db.codingRun.findUnique({ where: { runId }, select: { packageAuditMode: true } });
+            const packageAuditMode = coding?.packageAuditMode ?? null;
+            if (!packageAuditMode)
+                return summarizeRegistryFetches(rows);
+            const audits = await options.db.registryAuditRecord.findMany({ where: { runId }, orderBy: { createdAt: "asc" } });
+            return {
+                ...summarizeRegistryFetches(rows),
+                packageAuditMode,
+                packageAudit: summarizePackageAudit(audits).entries,
+            };
         },
+        onCodingRunTerminal: reReviewOnCodingRunTerminal(() => ({
+            db: options.db,
+            executor: composed,
+            hosts: reviewHosts,
+            repoAccess,
+            issueTrackers,
+        })),
         onSlotReleased: () => {
             void drainCodingQueue({
                 db: options.db,
@@ -150,6 +223,6 @@ export function buildConfiguredExecutor(options) {
             });
         },
     });
-    const composed = new RoutingExecutor(new PrismaExecutionKindResolver(options.db), options.native, coding);
+    const composed = new RoutingExecutor(new PrismaExecutionKindResolver(options.db), options.native, coding, options.nativeSandbox);
     return composed;
 }