@wardby/cli 0.5.3 → 0.6.0

package/dist/providers/chat/fake.js

@@ -0,0 +1,39 @@
+export class FakeChatProvider {
+    name = "slack";
+    posts = [];
+    updates = [];
+    channels = new Map();
+    queuedErrors = {
+        postMessage: [],
+        updateMessage: [],
+        channelInfo: [],
+        authTest: [],
+    };
+    nextTs = 1;
+    failNext(method, err) {
+        this.queuedErrors[method].push(err);
+    }
+    consumeFailure(method) {
+        const err = this.queuedErrors[method].shift();
+        if (err)
+            throw err;
+    }
+    async postMessage(channelId, msg, opts = {}) {
+        this.consumeFailure("postMessage");
+        const ts = `${this.nextTs++}.000`;
+        this.posts.push({ channelId, ts, msg, threadTs: opts.threadTs, broadcast: opts.broadcast });
+        return { ts };
+    }
+    async updateMessage(channelId, ts, msg) {
+        this.consumeFailure("updateMessage");
+        this.updates.push({ channelId, ts, msg });
+    }
+    async channelInfo(channel) {
+        this.consumeFailure("channelInfo");
+        return this.channels.get(channel) ?? null;
+    }
+    async authTest() {
+        this.consumeFailure("authTest");
+        return { team: "fake", botUserId: "UFAKE" };
+    }
+}

package/dist/providers/chat/index.d.ts

@@ -0,0 +1,4 @@
+import type { ChatProviderRegistry } from "./types.js";
+export * from "./types.js";
+/** One provider per configured chat service; empty when Slack is not configured. */
+export declare function buildChatProviders(env?: NodeJS.ProcessEnv, fetchImpl?: typeof fetch): ChatProviderRegistry;

package/dist/providers/chat/index.js

@@ -0,0 +1,8 @@
+import { loadSlackConfig } from "../../config/providers.js";
+import { SlackChatProvider } from "./slack.js";
+export * from "./types.js";
+/** One provider per configured chat service; empty when Slack is not configured. */
+export function buildChatProviders(env = process.env, fetchImpl) {
+    const slack = loadSlackConfig(env);
+    return slack ? { slack: new SlackChatProvider(slack, fetchImpl) } : {};
+}

package/dist/providers/chat/slack.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Slack Web API client for workflow notifications: chat.postMessage,
+ * chat.update, conversations.info, auth.test. Plain fetch (JSON bodies for
+ * writes, form-encoded for reads), bot token. Every failure becomes a ChatError with a normalized code the
+ * dispatcher acts on; Slack's own error string is kept for the operator.
+ */
+import type { SlackConfig } from "../../config/providers.js";
+import { type ChatMessage, type ChatProvider } from "./types.js";
+export declare class SlackChatProvider implements ChatProvider {
+    private readonly config;
+    private readonly fetchImpl;
+    readonly name: "slack";
+    constructor(config: SlackConfig, fetchImpl?: typeof fetch);
+    /**
+     * `form` for read methods (conversations.info, auth.test): Slack accepts JSON
+     * bodies only on write methods and answers a read method's JSON body with
+     * invalid_arguments.
+     */
+    private call;
+    private messageBody;
+    postMessage(channelId: string, msg: ChatMessage, opts?: {
+        threadTs?: string;
+        broadcast?: boolean;
+    }): Promise<{
+        ts: string;
+    }>;
+    updateMessage(channelId: string, ts: string, msg: ChatMessage): Promise<void>;
+    channelInfo(channel: string): Promise<{
+        id: string;
+        name: string;
+        isPrivate: boolean;
+    } | null>;
+    authTest(): Promise<{
+        team: string;
+        botUserId: string;
+    }>;
+}

package/dist/providers/chat/slack.js

@@ -0,0 +1,105 @@
+import { ChatError } from "./types.js";
+const CHANNEL_UNREACHABLE = new Set(["channel_not_found", "not_in_channel", "is_archived"]);
+const AUTH_FAILED = new Set([
+    "invalid_auth",
+    "not_authed",
+    "token_revoked",
+    "token_expired",
+    "account_inactive",
+    "missing_scope",
+]);
+const TIMEOUT_MS = 10_000;
+function classify(slackError) {
+    if (CHANNEL_UNREACHABLE.has(slackError))
+        return "channel_unreachable";
+    if (AUTH_FAILED.has(slackError))
+        return "auth_failed";
+    if (slackError === "message_not_found")
+        return "message_not_found";
+    if (slackError === "ratelimited")
+        return "rate_limited";
+    return "transient";
+}
+export class SlackChatProvider {
+    config;
+    fetchImpl;
+    name = "slack";
+    constructor(config, fetchImpl = fetch) {
+        this.config = config;
+        this.fetchImpl = fetchImpl;
+    }
+    /**
+     * `form` for read methods (conversations.info, auth.test): Slack accepts JSON
+     * bodies only on write methods and answers a read method's JSON body with
+     * invalid_arguments.
+     */
+    async call(method, body, encoding = "json") {
+        let res;
+        try {
+            res = await this.fetchImpl(`${this.config.apiBaseUrl}/${method}`, {
+                method: "POST",
+                headers: {
+                    authorization: `Bearer ${this.config.botToken}`,
+                    "content-type": encoding === "json" ? "application/json; charset=utf-8" : "application/x-www-form-urlencoded",
+                },
+                body: encoding === "json"
+                    ? JSON.stringify(body)
+                    : new URLSearchParams(Object.fromEntries(Object.entries(body).map(([k, v]) => [k, String(v)]))).toString(),
+                signal: AbortSignal.timeout(TIMEOUT_MS),
+            });
+        }
+        catch (err) {
+            throw new ChatError("transient", err instanceof Error ? err.message : String(err));
+        }
+        if (res.status === 429) {
+            const seconds = Number(res.headers.get("retry-after") ?? "1");
+            throw new ChatError("rate_limited", "ratelimited", (Number.isFinite(seconds) && seconds > 0 ? seconds : 1) * 1000);
+        }
+        if (!res.ok)
+            throw new ChatError("transient", `http_${res.status}`);
+        const json = (await res.json().catch(() => ({ ok: false, error: "invalid_json" })));
+        if (json.ok !== true) {
+            const slackError = typeof json.error === "string" ? json.error : "unknown_error";
+            throw new ChatError(classify(slackError), slackError);
+        }
+        return json;
+    }
+    messageBody(msg) {
+        return {
+            text: msg.text,
+            ...(msg.blocks ? { blocks: msg.blocks } : {}),
+            ...(this.config.customize && msg.username ? { username: msg.username } : {}),
+            ...(this.config.customize && msg.iconEmoji ? { icon_emoji: msg.iconEmoji } : {}),
+        };
+    }
+    async postMessage(channelId, msg, opts = {}) {
+        const json = await this.call("chat.postMessage", {
+            channel: channelId,
+            ...this.messageBody(msg),
+            ...(opts.threadTs ? { thread_ts: opts.threadTs } : {}),
+            ...(opts.threadTs && opts.broadcast ? { reply_broadcast: true } : {}),
+            unfurl_links: false,
+            unfurl_media: false,
+        });
+        return { ts: String(json.ts) };
+    }
+    async updateMessage(channelId, ts, msg) {
+        await this.call("chat.update", { channel: channelId, ts, ...this.messageBody(msg) });
+    }
+    async channelInfo(channel) {
+        try {
+            const json = await this.call("conversations.info", { channel }, "form");
+            const c = json.channel;
+            return { id: c.id, name: c.name, isPrivate: c.is_private === true };
+        }
+        catch (err) {
+            if (err instanceof ChatError && err.code === "channel_unreachable")
+                return null;
+            throw err;
+        }
+    }
+    async authTest() {
+        const json = await this.call("auth.test", {}, "form");
+        return { team: String(json.team), botUserId: String(json.user_id) };
+    }
+}

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

@@ -0,0 +1,42 @@
+/**
+ * Host-neutral chat surface for outbound workflow notifications. Slack is
+ * the first (and only) implementation (./slack.ts). wardby only ever posts
+ * or updates messages here — it never reads channel history or listens for
+ * events.
+ */
+export declare const CHAT_PROVIDERS: readonly ["slack"];
+export type ChatProviderName = (typeof CHAT_PROVIDERS)[number];
+export type ChatErrorCode = "rate_limited" | "channel_unreachable" | "auth_failed" | "message_not_found" | "transient";
+export declare class ChatError extends Error {
+    readonly code: ChatErrorCode;
+    readonly slackError: string;
+    readonly retryAfterMs?: number | undefined;
+    constructor(code: ChatErrorCode, slackError: string, retryAfterMs?: number | undefined);
+}
+export interface ChatMessage {
+    text: string;
+    blocks?: unknown[];
+    username?: string;
+    iconEmoji?: string;
+}
+export interface ChatProvider {
+    readonly name: ChatProviderName;
+    postMessage(channelId: string, msg: ChatMessage, opts?: {
+        threadTs?: string;
+        broadcast?: boolean;
+    }): Promise<{
+        ts: string;
+    }>;
+    updateMessage(channelId: string, ts: string, msg: ChatMessage): Promise<void>;
+    /** null when the bot cannot see the channel; throws ChatError("auth_failed") on missing scope. */
+    channelInfo(channel: string): Promise<{
+        id: string;
+        name: string;
+        isPrivate: boolean;
+    } | null>;
+    authTest(): Promise<{
+        team: string;
+        botUserId: string;
+    }>;
+}
+export type ChatProviderRegistry = Partial<Record<ChatProviderName, ChatProvider>>;

package/dist/providers/chat/types.js

@@ -0,0 +1,19 @@
+/**
+ * Host-neutral chat surface for outbound workflow notifications. Slack is
+ * the first (and only) implementation (./slack.ts). wardby only ever posts
+ * or updates messages here — it never reads channel history or listens for
+ * events.
+ */
+export const CHAT_PROVIDERS = ["slack"];
+export class ChatError extends Error {
+    code;
+    slackError;
+    retryAfterMs;
+    constructor(code, slackError, retryAfterMs) {
+        super(`chat_error:${code}:${slackError}`);
+        this.code = code;
+        this.slackError = slackError;
+        this.retryAfterMs = retryAfterMs;
+        this.name = "ChatError";
+    }
+}

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

@@ -48,6 +48,25 @@ 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>>;
+    });
+}
 /** The no-checkpoint default: run the step body directly. */
 export declare const runStepInline: StepRunner;
 /**

package/dist/providers/engine/types.js

@@ -12,5 +12,27 @@
  * 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;
+    }
+}
 /** 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,25 @@
 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 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). Started in the background so the executor's terminal path
+ * (and the slot release after it) never waits on the host; idempotent, and never throws.
+ * `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 +27,14 @@ 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;
 }
-/** 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

@@ -5,6 +5,8 @@ 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 { DISABLED_POWER } from "../../core/power.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";
@@ -22,12 +24,33 @@ 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). Started in the background so the executor's terminal path
+ * (and the slot release after it) never waits on the host; idempotent, and never throws.
+ * `deps` is read only when a run finishes, after composition returned.
+ */
+export function reReviewOnCodingRunTerminal(deps) {
+    return (runId) => {
+        void Promise.resolve()
+            .then(() => reReviewAfterNoChangeFix(runId, deps()))
+            .catch((err) => compositionLog.warn({ err, runId }, "no-change re-review hook failed"));
+    };
+}
+/**
+ * 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 +103,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,7 +136,9 @@ 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 coding = new ContainerExecutor({
@@ -131,12 +157,19 @@ 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,
         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);
         },
+        onCodingRunTerminal: reReviewOnCodingRunTerminal(() => ({
+            db: options.db,
+            executor: composed,
+            hosts: reviewHosts,
+            repoAccess,
+            issueTrackers,
+        })),
         onSlotReleased: () => {
             void drainCodingQueue({
                 db: options.db,
@@ -150,6 +183,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;
 }

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

@@ -44,6 +44,8 @@ export interface ContainerRunSnapshot {
     /** The issue that triggered this run (CodingRun.issueProvider/issueKey); null when none. */
     issueProvider?: string | null;
     issueKey?: string | null;
+    /** Step in the delegating agent's declared merge order (CodingRun.mergeOrder); null = no order. */
+    mergeOrder?: number | null;
     budgetUsd: number;
     /** The agent's own per-run budget; `budgetUsd` is less when its budget group had less left. */
     agentBudgetUsd?: number;
@@ -63,6 +65,10 @@ export interface ContainerRunSnapshot {
     debugTrace?: boolean;
     /** Claude Code turn limit, fixed at dispatch (CodingRun.maxTurns); null = the worker default. */
     maxTurns?: number | null;
+    /** Load the repo's agent skills, fixed at dispatch (CodingRun.repoSkills); absent on older snapshots = true. */
+    repoSkills?: boolean;
+    /** Claude Code loading mode, fixed at dispatch (CodingRun.claudeBareMode); absent on older snapshots = true. */
+    claudeBareMode?: 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). */
@@ -195,6 +201,15 @@ export interface ContainerExecutorOptions {
      * than on the next scheduler tick. Never called for a run that was queued.
      */
     onSlotReleased?: () => void;
+    /**
+     * Called with the run id at the end of each terminal finish of a collected
+     * job (succeeded, no change, budget, or failed), after the terminal write
+     * and cleanup. It may run more than once for one run (a replayed or
+     * duplicate finish), so it must be idempotent; a rejection or throw is
+     * logged and never reaches the terminal path. composition.ts wires the
+     * review-fix re-review here, so this executor imports no review logic.
+     */
+    onCodingRunTerminal?: (runId: string) => Promise<void> | void;
     /**
      * Loads this run's RegistryFetch ledger (composition.ts wires the Prisma
      * query) so finalizeChanges can surface installed/refused packages in the
@@ -278,6 +293,8 @@ export declare class ContainerExecutor implements Executor {
     private modelTerms;
     private preflight;
     private finishTerminal;
+    /** Runs the onCodingRunTerminal hook; nothing it does, throws, or rejects reaches the caller. */
+    private notifyTerminal;
     /** 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. */
@@ -286,7 +303,11 @@ export declare class ContainerExecutor implements Executor {
     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. */
+    /**
+     * The tool runner is what runs a Claude agent's commands, so it is what the toolchain selects —
+     * unless the agent has a BYO workerImageRef, which replaces the tool runner directly (never the
+     * agent image; see resolveCodingWorkerImage).
+     */
     private claudeToolImage;
     /** Coding-run services: the repository's declaration at its base ref (Executor.readCodingServiceDeclaration). */
     readCodingServiceDeclaration(input: {
@@ -302,6 +323,8 @@ export declare class ContainerExecutor implements Executor {
     }): Promise<string | null>;
     /** The job launcher decides (Kubernetes and Docker start services for both providers). */
     supportsCodingServices(provider: CodingProvider): boolean;
+    /** Delegates to the job launcher's own warm-up (Executor.warmUp); a no-op for a launcher without one. */
+    warmUp(): Promise<void>;
     private requireCurrent;
     /**
      * False when the launcher reports this run's job would not fit the cluster right now; the run