@workbench-ai/workbench 0.0.74 → 0.0.76

package/dist/fanout.js

@@ -34,7 +34,7 @@ export async function fanOutSkill(name, options) {
             "--global",
             "--yes",
         ];
-        const child = await runNode(args, scrubAgentRuntimeEnv(process.env), FANOUT_TIMEOUT_MS);
+        const child = await runNode(args, minimalChildEnv(process.env), FANOUT_TIMEOUT_MS);
         const { linkedAgents, additionalAgents } = parseFanOutAgents(`${child.stdout}\n${child.stderr}`);
         if (child.timedOut) {
             return {
@@ -143,29 +143,40 @@ function runNode(args, env, timeoutMs) {
         });
     });
 }
-function scrubAgentRuntimeEnv(env) {
-    const next = { ...env };
-    for (const key of [
-        "AI_AGENT",
-        "CODEX_SANDBOX",
-        "CODEX_CI",
-        "CODEX_THREAD_ID",
-        "CURSOR_TRACE_ID",
-        "CURSOR_AGENT",
-        "CURSOR_EXTENSION_HOST_ROLE",
-        "GEMINI_CLI",
-        "ANTIGRAVITY_AGENT",
-        "AUGMENT_AGENT",
-        "OPENCODE_CLIENT",
-        "CLAUDECODE",
-        "CLAUDE_CODE",
-        "CLAUDE_CODE_IS_COWORK",
-        "REPL_ID",
-        "COPILOT_MODEL",
-        "COPILOT_ALLOW_ALL",
-        "COPILOT_GITHUB_TOKEN",
-    ]) {
-        delete next[key];
+// The skills CLI changes behavior when it detects it is running inside an
+// agent (via @vercel/detect-agent reading agent-specific environment
+// variables). Fan-out must always run in machine mode, so the child gets a
+// minimal allowlisted environment instead of a hand-maintained blacklist of
+// every agent's marker variables.
+function minimalChildEnv(env) {
+    const allowed = [
+        "PATH",
+        "HOME",
+        "USER",
+        "SHELL",
+        "TMPDIR",
+        "TMP",
+        "TEMP",
+        "LANG",
+        "NODE_EXTRA_CA_CERTS",
+        "HTTP_PROXY",
+        "HTTPS_PROXY",
+        "NO_PROXY",
+        "http_proxy",
+        "https_proxy",
+        "no_proxy",
+        "SYSTEMROOT",
+        "SystemRoot",
+        "COMSPEC",
+        "APPDATA",
+        "LOCALAPPDATA",
+        "USERPROFILE",
+    ];
+    const next = {};
+    for (const key of Object.keys(env)) {
+        if (allowed.includes(key) || key.startsWith("XDG_") || key.startsWith("LC_")) {
+            next[key] = env[key];
+        }
     }
     return next;
 }

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAiEA,MAAM,WAAW,KAAK;IACpB,MAAM,EAAE,MAAM,CAAC,cAAc,CAAC;IAC9B,MAAM,EAAE,MAAM,CAAC,cAAc,CAAC;CAC/B;AAuTD,wBAAsB,MAAM,CAAC,IAAI,EAAE,SAAS,MAAM,EAAE,EAAE,EAAE,GAAE,KAGzD,GAAG,OAAO,CAAC,MAAM,CAAC,CAsMlB"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAgEA,MAAM,WAAW,KAAK;IACpB,MAAM,EAAE,MAAM,CAAC,cAAc,CAAC;IAC9B,MAAM,EAAE,MAAM,CAAC,cAAc,CAAC;CAC/B;AAuTD,wBAAsB,MAAM,CAAC,IAAI,EAAE,SAAS,MAAM,EAAE,EAAE,EAAE,GAAE,KAGzD,GAAG,OAAO,CAAC,MAAM,CAAC,CAoMlB"}

package/dist/index.js

@@ -4,7 +4,7 @@ import { createRequire } from "node:module";
 import os from "node:os";
 import path from "node:path";
 import { gzipSync } from "node:zlib";
-import { addWorkbenchRemote, addWorkbenchAgent, compareWorkbench, createWorkbenchInspectionSnapshot, createWorkbenchAdapterAuthBundle, createWorkbenchReadOnlyInspectionSnapshot, diffWorkbenchVersions, evalWorkbenchSkill, improveWorkbenchSkill, initWorkbenchSkill, listWorkbenchAgents, listWorkbenchVersions, localWorkbenchAdapterAuthStore, parseWorkbenchAdapterAuthTarget, prepareWorkbenchCloudEvalRequest, prepareWorkbenchCloudImproveRequest, publishWorkbenchVersion, removeWorkbenchAgent, showWorkbenchRef, switchWorkbenchVersion, syncWorkbenchRemote, workbenchJobEvidenceForSnapshot, workbenchSkillImproveCanUseQueuedAdapter, workbenchStatusSnapshot, WorkbenchCodedError, WorkbenchUserError, } from "@workbench-ai/workbench-core";
+import { addWorkbenchRemote, addWorkbenchAgent, compareWorkbench, createWorkbenchInspectionSnapshot, createWorkbenchAdapterAuthBundle, createWorkbenchReadOnlyInspectionSnapshot, diffWorkbenchVersions, evalWorkbenchSkill, improveWorkbenchSkill, initWorkbenchSkill, listWorkbenchAgents, listWorkbenchVersions, localWorkbenchAdapterAuthStore, parseWorkbenchAdapterAuthTarget, prepareWorkbenchCloudEvalRequest, prepareWorkbenchCloudImproveRequest, publishWorkbenchVersion, removeWorkbenchAgent, showWorkbenchRef, switchWorkbenchVersion, syncWorkbenchRemote, workbenchJobEvidenceForSnapshot, workbenchStatusSnapshot, WorkbenchCodedError, WorkbenchUserError, } from "@workbench-ai/workbench-core";
 import { normalizeWorkbenchSkillName } from "@workbench-ai/workbench-contract";
 import { emitError, emitResult } from "./output.js";
 import { fanOutSkill, manualFanOutCommand } from "./fanout.js";
@@ -375,12 +375,10 @@ export async function runCli(argv, io = {
             if (parsed.flags.cloud === true) {
                 return await handleCloudImprove(parsed, io);
             }
-            const improverAgent = await resolveLocalImproverAgent(parsed, core);
             const result = await improveWorkbenchSkill({
                 ...core,
                 skill: stringFlag(parsed, "skills"),
                 agent: stringFlag(parsed, "agents"),
-                ...(improverAgent ? { improverAgent } : {}),
                 budget: intFlag(parsed, "budget"),
                 samples: intFlag(parsed, "samples"),
             });
@@ -916,10 +914,7 @@ async function handleInstall(parsed, io) {
         next: next,
         ...(parsed.flags["dry-run"] === true ? { dryRun: true } : {}),
     }, parsed, io, () => [
-        parsed.flags["dry-run"] === true
-            ? `Would install ${result.directoryName} to ${result.destination}: filesCopied=${result.filesCopied}`
-            : `Installed ${result.directoryName}: ${result.result}`,
-        `  machine\t${result.previous}\t${result.destination}`,
+        formatInstallOutcome(result, parsed.flags["dry-run"] === true),
         formatFanOut(fanout),
         ...(next ? [`next: ${next}`] : []),
     ].join("\n"));
@@ -1015,6 +1010,21 @@ function installNextCommand(fanout) {
         ? fanout.command
         : null;
 }
+function formatInstallOutcome(result, dryRun) {
+    if (dryRun) {
+        return `Would install ${result.directoryName} to ${result.destination} (${formatFileCount(result.filesCopied)}).`;
+    }
+    if (result.result === "unchanged") {
+        return `Already installed ${result.directoryName} at ${result.destination} (unchanged).`;
+    }
+    const detail = result.previous === "overwritten"
+        ? `overwrote existing copy, ${formatFileCount(result.filesCopied)}`
+        : formatFileCount(result.filesCopied);
+    return `Installed ${result.directoryName} to ${result.destination} (${detail}).`;
+}
+function formatFileCount(count) {
+    return `${count} ${count === 1 ? "file" : "files"}`;
+}
 function fanOutToJson(fanout) {
     return {
         status: fanout.status,
@@ -1067,83 +1077,139 @@ function withTimeout(promise, timeoutMs) {
 async function startCloudExecution(command, parsed, io) {
     const root = dirFlag(parsed) ?? process.cwd();
     const showProgress = parsed.flags.json !== true;
-    const remote = await ensureCloudRemoteForExecution(root, parsed);
-    const source = parseWorkbenchInstallSource(remote.url);
-    if (!source) {
-        throw new WorkbenchCodedError("remote_invalid_url", `Workbench remote is not a Cloud skill URL: ${remote.url}`, {
-            remediation: "Run workbench publish to recreate the Workbench Cloud link.",
-            subject: { remote: remote.name, url: remote.url },
-            exitCode: 2,
-        });
-    }
-    const token = await workbenchCloudToken({ baseUrl: source.baseUrl });
-    if (!token) {
-        throw new WorkbenchCodedError("auth_required", `workbench ${command} --cloud requires Workbench Cloud auth.`, {
-            remediation: `Run workbench login --base-url ${source.baseUrl}.`,
-            exitCode: 1,
-        });
-    }
-    const core = { dir: root, authToken: token };
-    const request = command === "eval"
-        ? await prepareWorkbenchCloudEvalRequest({
-            ...core,
-            skill: stringFlag(parsed, "skills"),
-            agent: stringFlag(parsed, "agents"),
-            samples: intFlag(parsed, "samples"),
-        })
-        : await prepareWorkbenchCloudImproveRequest({
-            ...core,
-            skill: stringFlag(parsed, "skills"),
-            agent: stringFlag(parsed, "agents"),
-            samples: intFlag(parsed, "samples"),
-            budget: intFlag(parsed, "budget"),
-        });
-    const syncBefore = await syncWorkbenchRemote({ ...core, remote: remote.name });
-    const skillId = await resolveCloudSkillId(source);
-    const response = await apiRequest(`/api/workbench/skills/${encodeURIComponent(skillId)}${command === "improve" ? "/improve" : "/runs"}`, { method: "POST", body: cloudExecutionRequestBody(command, request) }, source.baseUrl);
-    const runs = response.runs ?? [];
-    if (runs.length === 0) {
-        throw new WorkbenchCodedError("cloud_run_missing", `Workbench Cloud did not return a run for ${command}.`, {
-            retryable: true,
-            remediation: "Run workbench log --runs.",
-            subject: { remote: remote.name, skillId },
-            exitCode: 1,
+    const interrupt = createCloudInterruptController(command, io, showProgress);
+    try {
+        writeCloudProgress(io, `workbench cloud: preparing hosted ${command}.`, showProgress);
+        const remote = await cloudPreScheduleStep(command, interrupt, ensureCloudRemoteForExecution(root, parsed));
+        const source = parseWorkbenchInstallSource(remote.url);
+        if (!source) {
+            throw new WorkbenchCodedError("remote_invalid_url", `Workbench remote is not a Cloud skill URL: ${remote.url}`, {
+                remediation: "Run workbench publish to recreate the Workbench Cloud link.",
+                subject: { remote: remote.name, url: remote.url },
+                exitCode: 2,
+            });
+        }
+        const token = await workbenchCloudToken({ baseUrl: source.baseUrl });
+        if (!token) {
+            throw new WorkbenchCodedError("auth_required", `workbench ${command} --cloud requires Workbench Cloud auth.`, {
+                remediation: `Run workbench login --base-url ${source.baseUrl}.`,
+                exitCode: 1,
+            });
+        }
+        const core = { dir: root, authToken: token };
+        writeCloudProgress(io, "workbench cloud: preparing current source.", showProgress);
+        const request = command === "eval"
+            ? await cloudPreScheduleStep(command, interrupt, prepareWorkbenchCloudEvalRequest({
+                ...core,
+                skill: stringFlag(parsed, "skills"),
+                agent: stringFlag(parsed, "agents"),
+                samples: intFlag(parsed, "samples"),
+            }))
+            : await cloudPreScheduleStep(command, interrupt, prepareWorkbenchCloudImproveRequest({
+                ...core,
+                skill: stringFlag(parsed, "skills"),
+                agent: stringFlag(parsed, "agents"),
+                samples: intFlag(parsed, "samples"),
+                budget: intFlag(parsed, "budget"),
+            }));
+        writeCloudProgress(io, "workbench cloud: syncing source to cloud.", showProgress);
+        const syncBefore = await cloudPreScheduleStep(command, interrupt, syncWorkbenchRemote({ ...core, remote: remote.name }));
+        writeCloudProgress(io, `workbench cloud: scheduling hosted ${command}.`, showProgress);
+        const skillId = await cloudPreScheduleStep(command, interrupt, resolveCloudSkillId(source));
+        const response = await cloudPreScheduleStep(command, interrupt, apiRequest(`/api/workbench/skills/${encodeURIComponent(skillId)}${command === "improve" ? "/improve" : "/runs"}`, { method: "POST", body: cloudExecutionRequestBody(command, request) }, source.baseUrl));
+        const runs = response.runs ?? [];
+        if (runs.length === 0) {
+            throw new WorkbenchCodedError("cloud_run_missing", `Workbench Cloud did not return a run for ${command}.`, {
+                retryable: true,
+                remediation: "Run workbench log --runs.",
+                subject: { remote: remote.name, skillId },
+                exitCode: 1,
+            });
+        }
+        const initialRunIds = runs.map((run) => run.id);
+        interrupt.setRunIds(initialRunIds);
+        const syncAfterSchedule = await syncWorkbenchRemote({ ...core, remote: remote.name });
+        writeCloudProgress(io, `workbench cloud: scheduled hosted ${command} on ${remote.url} (${formatCloudRunStatuses(runs)}).`, showProgress);
+        writeCloudProgress(io, `workbench cloud: waiting for terminal status; press Ctrl-C to detach and resume with workbench show ${displayRef(initialRunIds[0] ?? "run")}.`, showProgress);
+        const completed = await waitForCloudRuns({
+            command,
+            core,
+            interrupt,
+            io,
+            progress: showProgress,
+            remote,
+            runs,
+            source,
+            skillId,
+            initialSync: syncAfterSchedule,
         });
+        return {
+            core,
+            remote,
+            skillId,
+            initialRunIds,
+            runs: completed.runs,
+            ...(completed.detached ? { detached: true } : {}),
+            startVersionId: request.versionId,
+            source,
+            sync: {
+                before: { pushed: syncBefore.pushed, pulled: syncBefore.pulled, upToDate: syncBefore.upToDate },
+                after: { pushed: completed.sync.pushed, pulled: completed.sync.pulled, upToDate: completed.sync.upToDate },
+            },
+        };
     }
-    const initialRunIds = runs.map((run) => run.id);
-    writeCloudProgress(io, `workbench cloud: scheduled hosted ${command} on ${remote.url} (${formatCloudRunStatuses(runs)}).`, showProgress);
-    let initialSyncAfter = syncBefore;
-    try {
-        initialSyncAfter = await syncWorkbenchRemote({ ...core, remote: remote.name });
+    finally {
+        interrupt.dispose();
     }
-    catch (error) {
-        writeCloudProgress(io, `workbench cloud: sync while waiting failed; retrying (${oneLineExcerpt(errorMessage(error)) ?? "unknown error"}).`, showProgress);
-    }
-    writeCloudProgress(io, `workbench cloud: waiting for terminal status; press Ctrl-C to detach and resume with workbench show ${displayRef(initialRunIds[0] ?? "run")}.`, showProgress);
-    const completed = await waitForCloudRuns({
-        command,
-        core,
-        io,
-        progress: showProgress,
-        remote,
-        runs,
-        initialSync: initialSyncAfter,
+}
+function createCloudInterruptController(command, io, progress) {
+    let interrupted = false;
+    let runIds = [];
+    let resolveSignal = () => undefined;
+    const signal = new Promise((resolve) => {
+        resolveSignal = resolve;
     });
+    const onSigint = () => {
+        interrupted = true;
+        if (runIds.length > 0) {
+            writeCloudProgress(io, `workbench cloud: detaching from hosted ${command} (${runIds.map(displayRef).join(", ")}).`, progress);
+        }
+        resolveSignal();
+    };
+    process.once("SIGINT", onSigint);
     return {
-        core,
-        remote,
-        skillId,
-        initialRunIds,
-        runs: completed.runs,
-        ...(completed.detached ? { detached: true } : {}),
-        startVersionId: request.versionId,
-        source,
-        sync: {
-            before: { pushed: syncBefore.pushed, pulled: syncBefore.pulled, upToDate: syncBefore.upToDate },
-            after: { pushed: completed.sync.pushed, pulled: completed.sync.pulled, upToDate: completed.sync.upToDate },
+        signal,
+        get interrupted() {
+            return interrupted;
+        },
+        get runIds() {
+            return runIds;
+        },
+        setRunIds(nextRunIds) {
+            runIds = [...nextRunIds];
+        },
+        dispose() {
+            process.off("SIGINT", onSigint);
         },
     };
 }
+async function cloudPreScheduleStep(command, interrupt, step) {
+    if (interrupt.interrupted) {
+        throw cloudCanceledBeforeRunIdError(command);
+    }
+    return await Promise.race([
+        step,
+        interrupt.signal.then(() => {
+            throw cloudCanceledBeforeRunIdError(command);
+        }),
+    ]);
+}
+function cloudCanceledBeforeRunIdError(command) {
+    return new WorkbenchCodedError("cloud_canceled", `Hosted ${command} was canceled before Workbench Cloud returned a run id.`, {
+        remediation: `Run workbench ${command} --cloud.`,
+        exitCode: 130,
+    });
+}
 async function waitForCloudRuns(input) {
     const runIds = input.runs
         .map((run) => run.id)
@@ -1160,83 +1226,57 @@ async function waitForCloudRuns(input) {
     const pollIntervalMs = positiveIntEnv("WORKBENCH_CLOUD_RUN_POLL_INTERVAL_MS") ?? CLOUD_RUN_POLL_INTERVAL_MS;
     const deadline = Date.now() + timeoutMs;
     let runs = [...input.runs];
-    let interrupted = false;
     const startedAtMs = Date.now();
     let lastProgressAtMs = startedAtMs;
-    let lastSyncErrorMessage;
-    const onSigint = () => {
-        interrupted = true;
-        writeCloudProgress(input.io, `workbench cloud: detaching from hosted ${input.command} (${runIds.map(displayRef).join(", ")}).`, input.progress);
-    };
-    process.once("SIGINT", onSigint);
     const seenStatuses = new Map();
-    try {
-        while (true) {
-            const snapshot = await createWorkbenchReadOnlyInspectionSnapshot(input.core);
-            const snapshotRuns = runIds
-                .map((id) => snapshot.runs.find((entry) => entry.id === id))
-                .filter((run) => Boolean(run));
-            if (snapshotRuns.length > 0) {
-                runs = runIds.map((id) => snapshotRuns.find((entry) => entry.id === id) ?? runs.find((entry) => entry.id === id))
-                    .filter((run) => Boolean(run));
-            }
-            let wroteProgress = false;
-            const nowMs = Date.now();
-            for (const run of runs) {
-                const previous = seenStatuses.get(run.id);
-                if (previous !== run.status) {
-                    seenStatuses.set(run.id, run.status);
-                    writeCloudProgress(input.io, `workbench cloud: ${formatCloudRunState(run, startedAtMs, nowMs)}.`, input.progress);
-                    wroteProgress = input.progress || wroteProgress;
-                }
-            }
-            if (runs.length === runIds.length && runs.every(isTerminalRun)) {
-                return { runs, sync };
-            }
-            if (wroteProgress) {
-                lastProgressAtMs = nowMs;
-            }
-            else if (input.progress && nowMs - lastProgressAtMs >= 60_000) {
-                writeCloudProgress(input.io, `workbench cloud: still waiting (${formatCloudRunStates(runs, startedAtMs, nowMs)}).`);
-                lastProgressAtMs = nowMs;
-            }
-            if (interrupted) {
-                return { runs, sync, detached: true };
-            }
-            if (Date.now() >= deadline) {
-                throw new WorkbenchCodedError("cloud_run_pending", "Hosted Workbench run is still running.", {
-                    retryable: true,
-                    remediation: runIds[0] ? `Run workbench show ${runIds[0]}.` : "Run workbench log --runs.",
-                    subject: {
-                        runIds,
-                        statuses: Object.fromEntries(runs.map((run) => [run.id, run.status])),
-                    },
-                    exitCode: 1,
-                });
-            }
-            await sleep(pollIntervalMs);
-            if (interrupted) {
-                return { runs, sync, detached: true };
-            }
-            try {
-                sync = await syncWorkbenchRemote({ ...input.core, remote: input.remote.name });
-                if (lastSyncErrorMessage) {
-                    writeCloudProgress(input.io, "workbench cloud: sync while waiting recovered.", input.progress);
-                    lastSyncErrorMessage = undefined;
-                }
-            }
-            catch (error) {
-                const message = oneLineExcerpt(errorMessage(error)) ?? "unknown error";
-                if (message !== lastSyncErrorMessage) {
-                    writeCloudProgress(input.io, `workbench cloud: sync while waiting failed; retrying (${message}).`, input.progress);
-                    lastSyncErrorMessage = message;
-                }
+    while (true) {
+        runs = await fetchCloudRuns(input.source.baseUrl, input.skillId, runIds, runs);
+        let wroteProgress = false;
+        const nowMs = Date.now();
+        for (const run of runs) {
+            const previous = seenStatuses.get(run.id);
+            if (previous !== run.status) {
+                seenStatuses.set(run.id, run.status);
+                writeCloudProgress(input.io, `workbench cloud: ${formatCloudRunState(run, startedAtMs, nowMs)}.`, input.progress);
+                wroteProgress = input.progress || wroteProgress;
             }
         }
+        if (runs.length === runIds.length && runs.every(isTerminalRun)) {
+            sync = await syncWorkbenchRemote({ ...input.core, remote: input.remote.name });
+            return { runs, sync };
+        }
+        if (wroteProgress) {
+            lastProgressAtMs = nowMs;
+        }
+        else if (input.progress && nowMs - lastProgressAtMs >= 60_000) {
+            writeCloudProgress(input.io, `workbench cloud: still waiting (${formatCloudRunStates(runs, startedAtMs, nowMs)}).`);
+            lastProgressAtMs = nowMs;
+        }
+        if (input.interrupt.interrupted) {
+            return { runs, sync, detached: true };
+        }
+        if (Date.now() >= deadline) {
+            throw new WorkbenchCodedError("cloud_run_pending", "Hosted Workbench run is still running.", {
+                retryable: true,
+                remediation: runIds[0] ? `Run workbench show ${runIds[0]}.` : "Run workbench log --runs.",
+                subject: {
+                    runIds,
+                    statuses: Object.fromEntries(runs.map((run) => [run.id, run.status])),
+                },
+                exitCode: 1,
+            });
+        }
+        await Promise.race([sleep(pollIntervalMs), input.interrupt.signal]);
+        if (input.interrupt.interrupted) {
+            return { runs, sync, detached: true };
+        }
     }
-    finally {
-        process.off("SIGINT", onSigint);
-    }
+}
+async function fetchCloudRuns(baseUrl, skillId, runIds, fallback) {
+    const responses = await Promise.all(runIds.map((runId) => apiRequest(`/api/workbench/skills/${encodeURIComponent(skillId)}/runs/${encodeURIComponent(runId)}`, {}, baseUrl)));
+    return runIds
+        .map((runId, index) => responses[index]?.run ?? fallback.find((run) => run.id === runId))
+        .filter((run) => Boolean(run));
 }
 function isTerminalRun(run) {
     return run.status === "succeeded" || run.status === "failed" || run.status === "canceled";
@@ -1353,15 +1393,11 @@ async function resolveCloudSkillId(source) {
 function cloudExecutionRequestBody(command, request) {
     return {
         versionId: request.versionId,
-        evalHash: request.evalHash,
         skill: request.skill,
-        skillBundleHash: request.skillBundleHash,
         agent: request.agent,
-        agentHash: request.agentHash,
         samples: request.samples,
         ...(command === "improve" ? {
             budget: request.budget,
-            evidenceTraceIds: request.evidenceTraceIds,
         } : {}),
     };
 }
@@ -2701,10 +2737,10 @@ async function workbenchMachineStatus(auth) {
     };
 }
 function scoredRunValue(run) {
-    return run.status === "succeeded" && typeof run.score === "number" ? run.score : undefined;
+    return typeof run.score === "number" ? run.score : undefined;
 }
 function scoredJobValue(job) {
-    return job.status === "succeeded" && typeof job.score === "number" ? job.score : undefined;
+    return typeof job.score === "number" ? job.score : undefined;
 }
 function snapshotHasWorkflowCase(snapshot) {
     const currentVersion = snapshotVersionByRef(snapshot, snapshot.status.currentVersionId ?? snapshot.refs.current ?? "");
@@ -2760,6 +2796,15 @@ async function statusWithCausalNext(status, auth, core, machine) {
     if (unpublishedCloudRemote) {
         return { ...status, next: "workbench publish" };
     }
+    const currentVersionId = status.project.currentVersionId ?? snapshot?.status.currentVersionId ?? snapshot?.refs.current;
+    const stalePublishedCloudRemote = status.remotes.find((remote) => remote.kind === "workbench-cloud" &&
+        remote.publication.status === "published" &&
+        remote.sync.status === "up_to_date" &&
+        currentVersionId !== undefined &&
+        remote.publication.versionId !== currentVersionId);
+    if (canPublish && stalePublishedCloudRemote) {
+        return { ...status, next: "workbench publish" };
+    }
     const publishedCloudRemote = status.remotes.find((remote) => remote.kind === "workbench-cloud" &&
         remote.publication.status === "published" &&
         Boolean(remote.publication.installUrl));
@@ -2981,41 +3026,6 @@ function manifestOnly(value) {
     }
     return out;
 }
-async function resolveLocalImproverAgent(parsed, core) {
-    if (stringFlag(parsed, "agents")) {
-        return undefined;
-    }
-    const agents = await listWorkbenchAgents(core).catch(() => []);
-    const status = await workbenchStatusSnapshot(core).catch(() => undefined);
-    const defaultAgentName = status?.project.defaultAgent ?? agents[0]?.name;
-    const defaultAgent = agents.find((agent) => agent.name === defaultAgentName);
-    if (defaultAgent && workbenchSkillImproveCanUseQueuedAdapter(defaultAgent)) {
-        return undefined;
-    }
-    const connected = await localWorkbenchAdapterAuthStore(adapterAuthStoreRoot()).listStatus().catch(() => []);
-    const candidates = connected
-        .filter((entry) => entry.status === "connected" &&
-        (entry.adapterId === "claude" || entry.adapterId === "codex"))
-        .sort((left, right) => {
-        const adapterRank = (adapter) => adapter === "claude" ? 0 : adapter === "codex" ? 1 : 2;
-        return adapterRank(left.adapterId) - adapterRank(right.adapterId) ||
-            (Date.parse(right.updatedAt ?? "") || 0) - (Date.parse(left.updatedAt ?? "") || 0);
-    });
-    const selected = candidates[0];
-    if (!selected) {
-        throw new WorkbenchCodedError("auth_required", "workbench improve needs a connected improver.", {
-            remediation: "Run workbench login claude (or codex) to connect an improver.",
-            exitCode: 1,
-        });
-    }
-    return {
-        name: selected.adapterId,
-        adapter: selected.adapterId,
-        config: {
-            auth: selected.slot ? { [selected.slot]: selected.profile } : selected.profile,
-        },
-    };
-}
 function formatLogEntry(entry) {
     if (entry.kind === "version") {
         return `${entry.createdAt}\tversion\t${displayRef(entry.id)}\tfiles=${entry.fileCount}\t${entry.message}`;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@workbench-ai/workbench",
-  "version": "0.0.74",
+  "version": "0.0.76",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/workbench-ai/workbench.git",
@@ -22,10 +22,10 @@
   "dependencies": {
     "skills": "1.5.11",
     "yaml": "^2.8.2",
-    "@workbench-ai/workbench-built-in-adapters": "0.0.74",
-    "@workbench-ai/workbench-contract": "0.0.74",
-    "@workbench-ai/workbench-protocol": "0.0.74",
-    "@workbench-ai/workbench-core": "0.0.74"
+    "@workbench-ai/workbench-built-in-adapters": "0.0.76",
+    "@workbench-ai/workbench-core": "0.0.76",
+    "@workbench-ai/workbench-contract": "0.0.76",
+    "@workbench-ai/workbench-protocol": "0.0.76"
   },
   "devDependencies": {
     "@tailwindcss/postcss": "^4.2.2",
@@ -36,7 +36,7 @@
     "react-dom": "^19.2.0",
     "typescript": "^5.9.2",
     "vitest": "^3.2.4",
-    "@workbench-ai/workbench-ui": "0.0.74"
+    "@workbench-ai/workbench-ui": "0.0.76"
   },
   "scripts": {
     "build": "rm -rf dist && tsc -p tsconfig.json && chmod 755 dist/workbench.js && node ./scripts/build-dev-open-assets.mjs",