codex-toys 0.140.11 → 0.140.13

package/dist/internal/workbench/workbench-runtime.js

@@ -6,6 +6,7 @@ import { spawn } from "node:child_process";
 import { parse as parseToml } from "smol-toml";
 import { createWorkflowHost, resolveWorkflowTarget, runWorkflowScript, startWorkflowTurnWithRequest, waitWorkflowTurnWithRequest, } from "./workflow.js";
 import { parseJsonText } from "../bridge/json.js";
+export const defaultActionsRunnerImage = "ghcr.io/peezy-tech/codex-toys-actions:latest";
 export async function discoverWorkbenchRoot(start = process.cwd()) {
     let current = path.resolve(start);
     let firstDotCodexRoot;
@@ -86,7 +87,9 @@ export async function loadWorkbenchConfig(context) {
     const workbench = isRecord(parsed.workbench) ? parsed.workbench : undefined;
     const surfacesInput = Array.isArray(workbench?.surfaces) ? workbench.surfaces : [];
     const tasksInput = Array.isArray(workbench?.tasks) ? workbench.tasks : [];
-    const reactiveInput = Array.isArray(workbench?.reactive) ? workbench.reactive : [];
+    if (workbench?.reactive !== undefined) {
+        throw new Error("workbench.reactive has been removed; run explicit tasks or dispatch queues from systemd or Actions schedules");
+    }
     const tasks = tasksInput.map(parseTask);
     const ids = new Set();
     for (const task of tasks) {
@@ -99,11 +102,10 @@ export async function loadWorkbenchConfig(context) {
         name: stringValue(workbench?.name, path.basename(context.repoRoot)),
         surfaces: surfacesInput.map(parseSurface),
         tasks,
-        reactive: reactiveInput.map(parseReactiveRule),
         path: context.configPath,
     };
 }
-export async function collectWorkbenchDoctorInfo(context, options = {}) {
+export async function collectWorkbenchDoctorInfo(context) {
     let config;
     let configExists = true;
     try {
@@ -122,16 +124,12 @@ export async function collectWorkbenchDoctorInfo(context, options = {}) {
     }
     const runs = await readRuns(context);
     const latestRun = runs.sort((a, b) => b.startedAt.localeCompare(a.startedAt))[0];
-    const deferredRuns = await listDeferredRunIntents(context);
+    const dispatchRuns = await listDispatchRunIntents(context);
     const now = new Date();
-    const latestDeferredRun = deferredRuns
+    const latestDispatchRun = dispatchRuns
         .toSorted((a, b) => b.updatedAt.localeCompare(a.updatedAt))[0];
-    const deferredDueFlags = await Promise.all(deferredRuns.map(async (intent) => await isDeferredIntentDue(context, intent, now)));
+    const dispatchDueFlags = await Promise.all(dispatchRuns.map(async (intent) => await isDispatchIntentDue(context, intent, now)));
     const failingCount = countFailingTasks(config?.tasks ?? [], runs);
-    const includeRunner = options.includeRunner === true || options.runnerProbe !== undefined;
-    const runner = includeRunner
-        ? await collectWorkbenchRunnerInfo(context, config?.tasks ?? [], deferredRuns, options.runnerProbe ?? runSystemctlUser)
-        : undefined;
     return {
         mode: context.mode,
         requestedMode: context.requestedMode,
@@ -148,15 +146,13 @@ export async function collectWorkbenchDoctorInfo(context, options = {}) {
         globalMemorySummaryExists: await exists(path.join(context.globalCodexHome, "memories", "memory_summary.md")),
         workbenchMemorySummaryExists: await exists(path.join(context.workbenchCodexHome, "memories", "memory_summary.md")),
         taskCount: config?.tasks.length ?? 0,
-        dueCount: dueTasks(config?.tasks ?? [], runs, new Date()).length,
         failingCount,
-        deferredCount: deferredRuns.length,
-        deferredDueCount: deferredDueFlags.filter(Boolean).length,
-        deferredRunningCount: deferredRuns.filter((intent) => intent.status === "running").length,
-        deferredFailedCount: deferredRuns.filter((intent) => intent.status === "failed").length,
+        dispatchCount: dispatchRuns.length,
+        dispatchDueCount: dispatchDueFlags.filter(Boolean).length,
+        dispatchRunningCount: dispatchRuns.filter((intent) => intent.status === "running").length,
+        dispatchFailedCount: dispatchRuns.filter((intent) => intent.status === "failed").length,
         latestRun,
-        latestDeferredRun,
-        runner,
+        latestDispatchRun,
         surfaces: config?.surfaces ?? [],
         errors: workbenchDoctorErrors(context),
     };
@@ -173,23 +169,19 @@ export function formatWorkbenchDoctorInfo(info) {
         ["actions state", info.actionsStateRoot],
         ["global memories", `${info.globalMemoryRoot}${info.globalMemorySummaryExists ? " (summary)" : ""}`],
         ["workbench memories", `${info.workbenchMemoryRoot}${info.workbenchMemorySummaryExists ? " (summary)" : ""}`],
-        ["tasks", `${info.taskCount} configured, ${info.dueCount} due, ${info.failingCount} failing`],
+        ["tasks", `${info.taskCount} configured, ${info.failingCount} failing`],
         ["latest run", info.latestRun ? `${info.latestRun.status} ${info.latestRun.taskId} ${info.latestRun.finishedAt}` : "none"],
         [
-            "deferred runs",
-            `${info.deferredCount} total, ${info.deferredDueCount} due, ${info.deferredRunningCount} running, ${info.deferredFailedCount} failed`,
+            "dispatch runs",
+            `${info.dispatchCount} total, ${info.dispatchDueCount} due, ${info.dispatchRunningCount} running, ${info.dispatchFailedCount} failed`,
         ],
         [
-            "latest deferred",
-            info.latestDeferredRun
-                ? `${info.latestDeferredRun.status} ${info.latestDeferredRun.id} ${info.latestDeferredRun.updatedAt}`
+            "latest dispatch",
+            info.latestDispatchRun
+                ? `${info.latestDispatchRun.status} ${info.latestDispatchRun.id} ${info.latestDispatchRun.updatedAt}`
                 : "none",
         ],
-        ["runner", formatWorkbenchRunnerInfo(info.runner)],
     ];
-    if (info.runner?.warning) {
-        rows.push(["runner warning", info.runner.warning]);
-    }
     for (const error of info.errors) {
         rows.push(["error", error]);
     }
@@ -198,47 +190,21 @@ export function formatWorkbenchDoctorInfo(info) {
 export async function scaffoldActionsWorkbench(options = {}) {
     const workbenchRoot = path.resolve(options.workbenchRoot ?? await discoverWorkbenchRoot());
     const files = [];
+    const runnerImage = options.runnerImage === undefined ? defaultActionsRunnerImage : options.runnerImage;
     const write = async (relativePath, content) => {
         files.push(await writeScaffoldFile(workbenchRoot, relativePath, content, options.overwrite === true));
     };
     await write(".codex/workbench.toml", workbenchTomlTemplate(workbenchRoot));
     await write(".codex/config.toml", codexConfigTemplate());
     if (options.forgejo) {
-        await write(".forgejo/workflows/codex-toys-actions.yml", actionsWorkflowTemplate("forgejo"));
+        await write(".forgejo/workflows/codex-toys-actions.yml", actionsWorkflowTemplate("forgejo", runnerImage));
     }
     if (options.github || !options.forgejo) {
-        await write(".github/workflows/codex-toys-actions.yml", actionsWorkflowTemplate("github"));
+        await write(".github/workflows/codex-toys-actions.yml", actionsWorkflowTemplate("github", runnerImage));
     }
     files.push(await appendGitignoreEntries(workbenchRoot, actionsGitignoreEntries(), retiredActionsGitignoreEntries()));
     return { workbenchRoot, files };
 }
-export async function tickWorkbench(context, options) {
-    await ensureStateDirs(context);
-    const config = await loadWorkbenchConfig(context);
-    const previousRuns = await readRuns(context);
-    const previousIntents = await listDeferredRunIntents(context);
-    const now = new Date();
-    const due = dueTasks(config.tasks, previousRuns, now, previousIntents);
-    const runs = [];
-    for (const task of due) {
-        await createScheduledWorkbenchTaskIntent(context, task, now);
-    }
-    const executions = await runDueDeferredRuns(context, options);
-    for (const execution of executions.executions) {
-        const workbenchRun = record(execution.output).workbenchRun;
-        if (isWorkbenchRunRecord(workbenchRun)) {
-            runs.push(workbenchRun);
-        }
-    }
-    const allRuns = [...previousRuns, ...runs];
-    for (const rule of config.reactive.filter((item) => item.enabled)) {
-        const targets = config.tasks.filter((task) => rule.task === "*" ? true : task.id === rule.task);
-        if (targets.some((task) => consecutiveFailures(task.id, allRuns) >= rule.consecutiveFailuresGte)) {
-            runs.push(await runReactiveRule(context, rule));
-        }
-    }
-    return { mode: context.mode, due: due.map((task) => task.id), runs };
-}
 export async function runWorkbenchTaskById(context, taskId, options) {
     await ensureStateDirs(context);
     const config = await loadWorkbenchConfig(context);
@@ -269,15 +235,18 @@ export async function commitActionsWorkbenchState(context, options = {}) {
         await runGit(context.repoRoot, ["add", "-A", "-f", "--", sessionsPath]);
     }
     const staged = await runGit(context.repoRoot, ["diff", "--cached", "--name-only", "--", ...relativePaths]);
-    if (!staged.stdout.trim()) {
+    const stagedPaths = staged.stdout.trim().split(/\r?\n/).filter(Boolean);
+    if (stagedPaths.length === 0) {
         return { attempted: true, committed: false, paths: context.actionsCommitPaths };
     }
+    await runGit(context.repoRoot, ["config", "user.name", "codex-toys-actions"]);
+    await runGit(context.repoRoot, ["config", "user.email", "codex-toys-actions@users.noreply.github.com"]);
     const commit = await runGit(context.repoRoot, [
         "commit",
         "-m",
         options.message ?? "Update Codex workbench state",
         "--",
-        ...relativePaths,
+        ...stagedPaths,
     ]);
     return {
         attempted: true,
@@ -286,13 +255,13 @@ export async function commitActionsWorkbenchState(context, options = {}) {
         output: commit.stdout || commit.stderr,
     };
 }
-export async function createDeferredRunIntent(context, params) {
-    await ensureDeferredRunDirs(context);
-    const input = parseDeferredRunCreateParams(params);
+export async function createDispatchRunIntent(context, params) {
+    await ensureDispatchRunDirs(context);
+    const input = parseDispatchRunCreateParams(params);
     const now = new Date().toISOString();
     const runAt = input.runAt ?? now;
     const intent = compactUndefined({
-        id: input.id ?? deferredRunId(now),
+        id: input.id ?? dispatchRunId(now),
         status: "pending",
         mode: context.mode,
         runAt,
@@ -305,11 +274,11 @@ export async function createDeferredRunIntent(context, params) {
         dependsOn: input.dependsOn,
         attemptIds: [],
     });
-    await writeNewJsonFile(deferredIntentPath(context, intent.id), intent);
+    await writeNewJsonFile(dispatchIntentPath(context, intent.id), intent);
     return intent;
 }
-export async function listDeferredRunIntents(context, options = {}) {
-    const dir = deferredIntentDir(context);
+export async function listDispatchRunIntents(context, options = {}) {
+    const dir = dispatchIntentDir(context);
     try {
         const entries = await readdir(dir);
         const intents = [];
@@ -318,7 +287,7 @@ export async function listDeferredRunIntents(context, options = {}) {
                 continue;
             }
             try {
-                const intent = normalizeDeferredRunIntent(parseJsonText(await readFile(path.join(dir, entry), "utf8"), path.join(dir, entry)));
+                const intent = normalizeDispatchRunIntent(parseJsonText(await readFile(path.join(dir, entry), "utf8"), path.join(dir, entry)));
                 if (!options.status || intent.status === options.status) {
                     intents.push(intent);
                 }
@@ -332,11 +301,11 @@ export async function listDeferredRunIntents(context, options = {}) {
         return [];
     }
 }
-export async function readDeferredRun(context, intentId, options = {}) {
-    const intent = await readDeferredRunIntent(context, intentId);
-    const attempts = await readDeferredRunAttempts(context, intent.attemptIds);
+export async function readDispatchRun(context, intentId, options = {}) {
+    const intent = await readDispatchRunIntent(context, intentId);
+    const attempts = await readDispatchRunAttempts(context, intent.attemptIds);
     const outputs = options.includeOutput
-        ? await readDeferredRunAttemptOutputs(attempts)
+        ? await readDispatchRunAttemptOutputs(attempts)
         : undefined;
     return compactUndefined({ intent, attempts, outputs });
 }
@@ -344,12 +313,12 @@ export async function enqueuePromptQueueIntent(context, params) {
     const input = parsePromptQueueEnqueueParams(params);
     const after = input.afterIntentId
         ? {
-            kind: "deferred-run",
+            kind: "dispatch-run",
             intentId: input.afterIntentId,
             status: input.afterStatus,
         }
         : undefined;
-    return await createDeferredRunIntent(context, {
+    return await createDispatchRunIntent(context, {
         id: input.id,
         runAt: input.runAt,
         target: compactUndefined({
@@ -373,7 +342,7 @@ export async function enqueuePromptQueueIntent(context, params) {
     });
 }
 export async function listPromptQueueIntents(context, options = {}) {
-    const intents = await listDeferredRunIntents(context, {
+    const intents = await listDispatchRunIntents(context, {
         status: options.status,
     });
     return intents
@@ -393,10 +362,10 @@ function comparePromptQueueIntents(left, right) {
         left.id.localeCompare(right.id);
 }
 function dependsOnIntent(intent, dependencyId) {
-    return (intent.dependsOn ?? []).some((dependency) => dependency.kind === "deferred-run" && dependency.intentId === dependencyId);
+    return (intent.dependsOn ?? []).some((dependency) => dependency.kind === "dispatch-run" && dependency.intentId === dependencyId);
 }
 export async function collectPromptQueueRuns(context, options = {}) {
-    return await collectDeferredRuns(context, {
+    return await collectDispatchRuns(context, {
         cursor: options.cursor,
         defaultCursor: "prompt-queue",
         now: options.now,
@@ -404,7 +373,7 @@ export async function collectPromptQueueRuns(context, options = {}) {
     });
 }
 export async function runDuePromptQueueIntents(context, options) {
-    return await runDueDeferredRuns(context, {
+    return await runDueDispatchRuns(context, {
         ...options,
         filter: (intent) => isPromptQueueIntent(intent, options.queue),
     });
@@ -413,12 +382,12 @@ export async function enqueueLocalHandoffIntent(context, params) {
     const input = parseLocalHandoffEnqueueParams(params);
     const after = input.afterIntentId
         ? {
-            kind: "deferred-run",
+            kind: "dispatch-run",
             intentId: input.afterIntentId,
             status: input.afterStatus,
         }
         : undefined;
-    return await createDeferredRunIntent(context, {
+    return await createDispatchRunIntent(context, {
         id: input.id,
         runAt: input.runAt,
         target: compactUndefined({
@@ -442,7 +411,7 @@ export async function enqueueLocalHandoffIntent(context, params) {
     });
 }
 export async function listLocalHandoffIntents(context, options = {}) {
-    const intents = await listDeferredRunIntents(context, {
+    const intents = await listDispatchRunIntents(context, {
         status: options.status,
     });
     return intents
@@ -450,7 +419,7 @@ export async function listLocalHandoffIntents(context, options = {}) {
         .slice(0, clampLimit(options.limit, 500));
 }
 export async function collectLocalHandoffRuns(context, options = {}) {
-    return await collectDeferredRuns(context, {
+    return await collectDispatchRuns(context, {
         cursor: options.cursor,
         defaultCursor: "local-handoff",
         now: options.now,
@@ -459,7 +428,7 @@ export async function collectLocalHandoffRuns(context, options = {}) {
 }
 export async function drainLocalHandoffQueue(context, options) {
     const action = options.action ?? "run";
-    const result = await runDueDeferredRuns(context, {
+    const result = await runDueDispatchRuns(context, {
         ...options,
         includeLocalHandoffs: true,
         localHandoffMaterialize: action === "materialize"
@@ -478,22 +447,22 @@ export async function drainLocalHandoffQueue(context, options) {
         executions: result.executions,
     };
 }
-export async function collectDeferredRuns(context, options = {}) {
-    await ensureDeferredRunDirs(context);
-    const cursor = deferredCollectCursorName(options.cursor, options.defaultCursor);
-    const previousCursor = await readDeferredRunCollectCursor(context, cursor);
+export async function collectDispatchRuns(context, options = {}) {
+    await ensureDispatchRunDirs(context);
+    const cursor = dispatchCollectCursorName(options.cursor, options.defaultCursor);
+    const previousCursor = await readDispatchRunCollectCursor(context, cursor);
     const collectedAt = (options.now ?? new Date()).toISOString();
     const filteredIntents = [];
-    for (const intent of await listDeferredRunIntents(context)) {
+    for (const intent of await listDispatchRunIntents(context)) {
         if (!options.filter || await options.filter(intent)) {
             filteredIntents.push(intent);
         }
     }
     const terminalIntents = filteredIntents
-        .filter((intent) => isTerminalDeferredRunStatus(intent.status))
+        .filter((intent) => isTerminalDispatchRunStatus(intent.status))
         .toSorted((left, right) => left.updatedAt.localeCompare(right.updatedAt) || left.id.localeCompare(right.id))
-        .filter((intent) => isAfterDeferredRunCollectCursor(intent, previousCursor));
-    const intents = await Promise.all(terminalIntents.map(async (intent) => await readDeferredRun(context, intent.id, { includeOutput: true })));
+        .filter((intent) => isAfterDispatchRunCollectCursor(intent, previousCursor));
+    const intents = await Promise.all(terminalIntents.map(async (intent) => await readDispatchRun(context, intent.id, { includeOutput: true })));
     const last = terminalIntents.at(-1);
     const cursorState = compactUndefined({
         cursor,
@@ -501,7 +470,7 @@ export async function collectDeferredRuns(context, options = {}) {
         lastUpdatedAt: last?.updatedAt ?? previousCursor?.lastUpdatedAt,
         lastIntentId: last?.id ?? previousCursor?.lastIntentId,
     });
-    await writeJsonFileAtomic(deferredCollectCursorPath(context, cursor), cursorState);
+    await writeJsonFileAtomic(dispatchCollectCursorPath(context, cursor), cursorState);
     return compactUndefined({
         mode: context.mode,
         cursor,
@@ -511,10 +480,10 @@ export async function collectDeferredRuns(context, options = {}) {
         intents,
     });
 }
-export async function cancelDeferredRunIntent(context, intentId) {
-    const intent = await readDeferredRunIntent(context, intentId);
+export async function cancelDispatchRunIntent(context, intentId) {
+    const intent = await readDispatchRunIntent(context, intentId);
     if (intent.status !== "pending") {
-        throw new Error(`Only pending deferred runs can be canceled: ${intentId}`);
+        throw new Error(`Only pending dispatch runs can be canceled: ${intentId}`);
     }
     const now = new Date().toISOString();
     const canceled = {
@@ -523,19 +492,19 @@ export async function cancelDeferredRunIntent(context, intentId) {
         updatedAt: now,
         canceledAt: now,
     };
-    await writeJsonFileAtomic(deferredIntentPath(context, intentId), canceled);
+    await writeJsonFileAtomic(dispatchIntentPath(context, intentId), canceled);
     return canceled;
 }
-export async function retryDeferredRunIntent(context, intentId, params = {}, options = {}) {
-    await ensureDeferredRunDirs(context);
-    const originalIntent = await readDeferredRunIntent(context, intentId);
-    if (!isTerminalDeferredRunStatus(originalIntent.status)) {
-        throw new Error(`Only terminal deferred runs can be retried: ${intentId} is ${originalIntent.status}`);
+export async function retryDispatchRunIntent(context, intentId, params = {}, options = {}) {
+    await ensureDispatchRunDirs(context);
+    const originalIntent = await readDispatchRunIntent(context, intentId);
+    if (!isTerminalDispatchRunStatus(originalIntent.status)) {
+        throw new Error(`Only terminal dispatch runs can be retried: ${intentId} is ${originalIntent.status}`);
     }
-    const input = parseDeferredRunRetryParams(params);
+    const input = parseDispatchRunRetryParams(params);
     const now = (options.now ?? new Date()).toISOString();
-    const retrySource = retryDeferredRunSource(originalIntent, input.source);
-    let id = input.id ?? deferredRetryRunId(originalIntent.id, now);
+    const retrySource = retryDispatchRunSource(originalIntent, input.source);
+    let id = input.id ?? dispatchRetryRunId(originalIntent.id, now);
     for (let attempt = 0; attempt < 10; attempt += 1) {
         const intent = compactUndefined({
             id,
@@ -545,32 +514,32 @@ export async function retryDeferredRunIntent(context, intentId, params = {}, opt
             target: originalIntent.target,
             createdAt: now,
             updatedAt: now,
-            createdBy: input.createdBy ?? "workbench-deferred-retry",
-            reason: input.reason ?? `Retry deferred run ${originalIntent.id}`,
+            createdBy: input.createdBy ?? "workbench-dispatch-retry",
+            reason: input.reason ?? `Retry dispatch run ${originalIntent.id}`,
             source: retrySource,
             dependsOn: originalIntent.dependsOn,
             attemptIds: [],
         });
         try {
-            await writeNewJsonFile(deferredIntentPath(context, intent.id), intent);
+            await writeNewJsonFile(dispatchIntentPath(context, intent.id), intent);
             return { intent, originalIntent };
         }
         catch (error) {
             if (!isAlreadyExistsError(error)) {
                 throw error;
             }
-            id = deferredRetryRunId(originalIntent.id, now);
+            id = dispatchRetryRunId(originalIntent.id, now);
         }
     }
-    throw new Error(`Could not allocate retry deferred run id for ${intentId}`);
+    throw new Error(`Could not allocate retry dispatch run id for ${intentId}`);
 }
-export async function runDueDeferredRuns(context, options) {
+export async function runDueDispatchRuns(context, options) {
     await ensureStateDirs(context);
-    await ensureDeferredRunDirs(context);
+    await ensureDispatchRunDirs(context);
     const now = options.now ?? new Date();
     const due = [];
-    for (const intent of await listDeferredRunIntents(context)) {
-        if (await isDeferredIntentDue(context, intent, now) &&
+    for (const intent of await listDispatchRunIntents(context)) {
+        if (await isDispatchIntentDue(context, intent, now) &&
             (options.includeLocalHandoffs === true || !isLocalHandoffIntent(intent)) &&
             (!options.filter || await options.filter(intent))) {
             due.push(intent);
@@ -581,7 +550,7 @@ export async function runDueDeferredRuns(context, options) {
     }
     const executions = [];
     for (const intent of due) {
-        const claim = await claimDeferredRunIntent(context, intent, {
+        const claim = await claimDispatchRunIntent(context, intent, {
             now,
             leaseMs: options.leaseMs ?? 30 * 60 * 1000,
         });
@@ -589,9 +558,9 @@ export async function runDueDeferredRuns(context, options) {
             continue;
         }
         try {
-            const outputPath = path.join(deferredOutputDir(context), `${claim.attempt.id}.json`);
-            await writeJsonFileAtomic(deferredAttemptPath(context, claim.attempt.id), claim.attempt);
-            const result = await executeDeferredRunTarget(context, claim.intent, {
+            const outputPath = path.join(dispatchOutputDir(context), `${claim.attempt.id}.json`);
+            await writeJsonFileAtomic(dispatchAttemptPath(context, claim.attempt.id), claim.attempt);
+            const result = await executeDispatchRunTarget(context, claim.intent, {
                 callToybox: options.callToybox,
                 workflowCwd: options.workflowCwd,
                 localHandoffMaterialize: options.localHandoffMaterialize,
@@ -614,8 +583,8 @@ export async function runDueDeferredRuns(context, options) {
                 completedAt: result.status === "completed" ? finishedAt : undefined,
                 error: result.error,
             });
-            await writeJsonFileAtomic(deferredAttemptPath(context, attempt.id), attempt);
-            await writeJsonFileAtomic(deferredIntentPath(context, completedIntent.id), completedIntent);
+            await writeJsonFileAtomic(dispatchAttemptPath(context, attempt.id), attempt);
+            await writeJsonFileAtomic(dispatchIntentPath(context, completedIntent.id), completedIntent);
             executions.push({
                 intent: completedIntent,
                 attempt,
@@ -623,24 +592,24 @@ export async function runDueDeferredRuns(context, options) {
             });
         }
         finally {
-            await releaseDeferredRunClaim(context, claim.intent.id);
+            await releaseDispatchRunClaim(context, claim.intent.id);
         }
     }
     return { mode: context.mode, executions };
 }
-export async function pruneDeferredRunHistory(context, options) {
+export async function pruneDispatchRunHistory(context, options) {
     if (!Number.isInteger(options.olderThanDays) || options.olderThanDays <= 0) {
         throw new Error("olderThanDays must be a positive integer");
     }
     const now = options.now ?? new Date();
     const cutoff = new Date(now.getTime() - options.olderThanDays * 24 * 60 * 60 * 1000).toISOString();
-    const intents = await listDeferredRunIntents(context);
+    const intents = await listDispatchRunIntents(context);
     const pruned = [];
     for (const intent of intents) {
-        if (!isTerminalDeferredRunStatus(intent.status) || intent.updatedAt >= cutoff) {
+        if (!isTerminalDispatchRunStatus(intent.status) || intent.updatedAt >= cutoff) {
             continue;
         }
-        const attempts = await readDeferredRunAttempts(context, intent.attemptIds);
+        const attempts = await readDispatchRunAttempts(context, intent.attemptIds);
         const outputPaths = attempts.flatMap((attempt) => attempt.outputPath ? [attempt.outputPath] : []);
         pruned.push({
             id: intent.id,
@@ -652,14 +621,14 @@ export async function pruneDeferredRunHistory(context, options) {
         if (options.dryRun === true) {
             continue;
         }
-        await releaseDeferredRunClaim(context, intent.id);
+        await releaseDispatchRunClaim(context, intent.id);
         for (const outputPath of outputPaths) {
             await rm(outputPath, { force: true });
         }
         for (const attempt of attempts) {
-            await rm(deferredAttemptPath(context, attempt.id), { force: true });
+            await rm(dispatchAttemptPath(context, attempt.id), { force: true });
         }
-        await rm(deferredIntentPath(context, intent.id), { force: true });
+        await rm(dispatchIntentPath(context, intent.id), { force: true });
     }
     return {
         mode: context.mode,
@@ -673,13 +642,13 @@ export async function pruneDeferredRunHistory(context, options) {
 async function runWorkbenchTask(context, config, task, options) {
     const startedAt = new Date().toISOString();
     const runId = workbenchRunId(task.id, startedAt);
-    const outputPath = path.join(context.stateRoot, "outputs", `${runId}.json`);
+    const outputPath = workbenchTaskOutputPath(context, task, runId);
     try {
         let result;
         if (!task.enabled) {
             result = { skipped: "disabled" };
             const run = runRecord(context, runId, task.id, task.kind, startedAt, "skipped", outputPath);
-            await persistRun(context, run, result);
+            await persistRun(context, task, run, result);
             return run;
         }
         if (task.kind === "workflow") {
@@ -692,18 +661,23 @@ async function runWorkbenchTask(context, config, task, options) {
             result = await runSkill(task, context);
         }
         const run = runRecord(context, runId, task.id, task.kind, startedAt, "completed", outputPath);
-        await persistRun(context, run, result);
+        await persistRun(context, task, run, result);
         return run;
     }
     catch (error) {
         const run = runRecord(context, runId, task.id, task.kind, startedAt, "failed", outputPath, errorMessage(error));
-        await persistRun(context, run, { error: errorMessage(error) });
+        await persistRun(context, task, run, { error: errorMessage(error) });
         return run;
     }
 }
 function workbenchRunId(taskId, startedAt) {
     return `${startedAt.replace(/[:.]/g, "-")}-${randomUUID().slice(0, 8)}-${taskId}`;
 }
+function workbenchTaskOutputPath(context, task, runId) {
+    return task.history === "latest"
+        ? path.join(latestOutputDir(context), `${safeFileSegment(task.id)}.json`)
+        : path.join(context.stateRoot, "outputs", `${runId}.json`);
+}
 async function runWorkflowTask(context, config, task, runId, startedAt, options) {
     const target = await resolveWorkflowTarget(task.workflow, {
         cwd: context.repoRoot,
@@ -734,7 +708,7 @@ async function runWorkflowTask(context, config, task, runId, startedAt, options)
     });
     return scriptRun.result;
 }
-async function executeDeferredRunTarget(context, intent, options) {
+async function executeDispatchRunTarget(context, intent, options) {
     try {
         const target = intent.target;
         if (options.localHandoffMaterialize && isLocalHandoffIntent(intent)) {
@@ -762,10 +736,9 @@ async function executeDeferredRunTarget(context, intent, options) {
                 name: path.basename(context.repoRoot),
                 surfaces: [],
                 tasks: [],
-                reactive: [],
                 path: context.configPath,
             }));
-            const result = await runWorkflowDeferredTarget(context, config, { ...intent, target }, options);
+            const result = await runWorkflowDispatchTarget(context, config, { ...intent, target }, options);
             return { status: "completed", output: result };
         }
         if (target.kind === "turn") {
@@ -825,12 +798,12 @@ async function materializeLocalHandoffIntent(context, intent, options) {
         queue,
     };
 }
-async function runWorkflowDeferredTarget(context, config, intent, options) {
+async function runWorkflowDispatchTarget(context, config, intent, options) {
     const target = await resolveWorkflowTarget(intent.target.workflow, {
         cwd: context.repoRoot,
     });
     const startedAt = new Date().toISOString();
-    const event = deferredWorkflowEvent(config, intent, startedAt);
+    const event = dispatchWorkflowEvent(config, intent, startedAt);
     const prompt = intent.target.prompt ?? target.prompt;
     const cwd = intent.target.cwd ?? options.workflowCwd ?? target.cwd ?? context.repoRoot;
     const scriptRun = await runWorkflowScript({
@@ -876,46 +849,24 @@ function workbenchWorkflowEvent(config, task, runId, startedAt) {
         },
     };
 }
-function deferredWorkflowEvent(config, intent, startedAt) {
+function dispatchWorkflowEvent(config, intent, startedAt) {
     const event = intent.target.event ?? {};
     const payload = isRecord(event.payload) ? event.payload : {};
     return {
         ...event,
-        id: stringValue(event.id, `deferred:${config.name}:${intent.id}`),
+        id: stringValue(event.id, `dispatch:${config.name}:${intent.id}`),
         type: stringValue(event.type, intent.target.workflow),
         source: stringValue(event.source, config.name),
         occurredAt: stringValue(event.occurredAt, intent.runAt),
         receivedAt: stringValue(event.receivedAt, startedAt),
         payload: {
-            deferredRunId: intent.id,
+            dispatchRunId: intent.id,
             ...payload,
         },
     };
 }
 function exhaustiveTarget(value) {
-    throw new Error(`Unsupported deferred run target: ${JSON.stringify(value)}`);
-}
-async function runReactiveRule(context, rule) {
-    const startedAt = new Date().toISOString();
-    const runId = `${startedAt.replace(/[:.]/g, "-")}-${rule.id}`;
-    const outputPath = path.join(context.stateRoot, "outputs", `${runId}.json`);
-    try {
-        const result = await runSkill({
-            id: rule.id,
-            enabled: rule.enabled,
-            kind: "skill",
-            skill: rule.skill,
-            var: `repair failures for ${rule.task}`,
-        }, context);
-        const run = runRecord(context, runId, rule.id, "reactive", startedAt, "completed", outputPath);
-        await persistRun(context, run, result);
-        return run;
-    }
-    catch (error) {
-        const run = runRecord(context, runId, rule.id, "reactive", startedAt, "failed", outputPath, errorMessage(error));
-        await persistRun(context, run, { error: errorMessage(error) });
-        return run;
-    }
+    throw new Error(`Unsupported dispatch run target: ${JSON.stringify(value)}`);
 }
 async function runSkill(task, context) {
     const skillPath = path.join(context.runtimeCodexHome, "skills", task.skill, "SKILL.md");
@@ -971,18 +922,6 @@ async function runGit(cwd, args) {
     }
     return { stdout, stderr };
 }
-async function runSystemctlUser(args) {
-    const proc = spawn("systemctl", ["--user", ...args]);
-    const [stdout, stderr, exitCode] = await Promise.all([
-        collectText(proc.stdout),
-        collectText(proc.stderr),
-        exitCodeFor(proc),
-    ]);
-    if (exitCode !== 0) {
-        throw new Error(`systemctl --user ${args.join(" ")} failed (${exitCode}): ${stderr || stdout}`);
-    }
-    return stdout;
-}
 function collectText(stream) {
     return new Promise((resolve, reject) => {
         let output = "";
@@ -1004,16 +943,20 @@ function exitCodeFor(child) {
         child.once("exit", (code) => resolve(code));
     });
 }
-async function persistRun(context, run, output) {
+async function persistRun(context, task, run, output) {
     await ensureStateDirs(context);
     if (run.outputPath) {
         await writeFile(run.outputPath, `${JSON.stringify(output, null, 2)}\n`);
     }
-    await writeFile(path.join(context.stateRoot, "runs", `${run.id}.json`), `${JSON.stringify(run, null, 2)}\n`);
+    const runPath = task.history === "latest"
+        ? path.join(latestRunDir(context), `${safeFileSegment(task.id)}.json`)
+        : path.join(context.stateRoot, "runs", `${run.id}.json`);
+    await writeFile(runPath, `${JSON.stringify(run, null, 2)}\n`);
     await writeHealth(context, run);
 }
 async function writeHealth(context, run) {
-    const runs = [...await readRuns(context), run].sort((a, b) => a.startedAt.localeCompare(b.startedAt));
+    const runs = uniqueWorkbenchRuns([...await readRuns(context), run])
+        .sort((a, b) => a.startedAt.localeCompare(b.startedAt));
     const health = {
         updatedAt: new Date().toISOString(),
         latestRun: run,
@@ -1025,79 +968,58 @@ async function writeHealth(context, run) {
     await writeFile(path.join(context.stateRoot, "health", "summary.json"), `${JSON.stringify(health, null, 2)}\n`);
 }
 async function readRuns(context) {
-    const dir = path.join(context.stateRoot, "runs");
-    try {
-        const entries = await readdir(dir);
-        const runs = [];
-        for (const entry of entries) {
-            if (!entry.endsWith(".json")) {
-                continue;
-            }
-            try {
-                const runPath = path.join(dir, entry);
-                const parsed = parseJsonText(await readFile(runPath, "utf8"), runPath);
-                if (parsed && typeof parsed.taskId === "string") {
-                    runs.push(parsed);
+    const dirs = [path.join(context.stateRoot, "runs"), latestRunDir(context)];
+    const runs = [];
+    for (const dir of dirs) {
+        try {
+            const entries = await readdir(dir);
+            for (const entry of entries) {
+                if (!entry.endsWith(".json")) {
+                    continue;
+                }
+                try {
+                    const runPath = path.join(dir, entry);
+                    const parsed = parseJsonText(await readFile(runPath, "utf8"), runPath);
+                    if (isWorkbenchRunRecord(parsed)) {
+                        runs.push(parsed);
+                    }
                 }
+                catch { }
             }
-            catch { }
         }
-        return runs;
-    }
-    catch {
-        return [];
-    }
-}
-async function createScheduledWorkbenchTaskIntent(context, task, now) {
-    try {
-        return await createDeferredRunIntent(context, {
-            id: scheduledDeferredRunId(task.id, now),
-            runAt: now.toISOString(),
-            target: {
-                kind: "workbench-task",
-                taskId: task.id,
-            },
-            createdBy: "workbench-schedule",
-            reason: `Scheduled workbench task ${task.id}`,
-            source: {
-                kind: "workbench-task-schedule",
-                taskId: task.id,
-                schedule: task.schedule,
-                date: now.toISOString().slice(0, 10),
-            },
-        });
-    }
-    catch (error) {
-        if (isAlreadyExistsError(error)) {
-            return undefined;
+        catch {
+            continue;
         }
-        throw error;
     }
+    return uniqueWorkbenchRuns(runs);
+}
+function uniqueWorkbenchRuns(runs) {
+    return [...new Map(runs.map((run) => [run.id, run])).values()];
 }
-async function readDeferredRunIntent(context, intentId) {
-    const intentPath = deferredIntentPath(context, intentId);
+async function readDispatchRunIntent(context, intentId) {
+    const intentPath = dispatchIntentPath(context, intentId);
     try {
-        return normalizeDeferredRunIntent(parseJsonText(await readFile(intentPath, "utf8"), intentPath));
+        return normalizeDispatchRunIntent(parseJsonText(await readFile(intentPath, "utf8"), intentPath));
     }
     catch (error) {
         if (isNotFoundError(error)) {
-            throw new Error(`Unknown deferred run: ${intentId}`);
+            throw new Error(`Unknown dispatch run: ${intentId}`);
         }
         throw error;
     }
 }
-async function readDeferredRunAttempts(context, attemptIds) {
+async function readDispatchRunAttempts(context, attemptIds) {
     const attempts = [];
     for (const attemptId of attemptIds) {
-        const attemptPath = deferredAttemptPath(context, attemptId);
+        const attemptPath = dispatchAttemptPath(context, attemptId);
         try {
-            attempts.push(normalizeDeferredRunAttempt(parseJsonText(await readFile(attemptPath, "utf8"), attemptPath)));
+            attempts.push(normalizeDispatchRunAttempt(parseJsonText(await readFile(attemptPath, "utf8"), attemptPath)));
         }
         catch { }
     }
     return attempts.sort((left, right) => left.startedAt.localeCompare(right.startedAt));
 }
-async function readDeferredRunAttemptOutputs(attempts) {
+async function readDispatchRunAttemptOutputs(attempts) {
     const outputs = [];
     for (const attempt of attempts) {
         if (!attempt.outputPath) {
@@ -1120,10 +1042,10 @@ async function readDeferredRunAttemptOutputs(attempts) {
     }
     return outputs;
 }
-async function readDeferredRunCollectCursor(context, cursor) {
-    const file = deferredCollectCursorPath(context, cursor);
+async function readDispatchRunCollectCursor(context, cursor) {
+    const file = dispatchCollectCursorPath(context, cursor);
     try {
-        return normalizeDeferredRunCollectCursor(parseJsonText(await readFile(file, "utf8"), file), cursor);
+        return normalizeDispatchRunCollectCursor(parseJsonText(await readFile(file, "utf8"), file), cursor);
     }
     catch (error) {
         if (isNotFoundError(error)) {
@@ -1132,14 +1054,14 @@ async function readDeferredRunCollectCursor(context, cursor) {
         throw error;
     }
 }
-async function claimDeferredRunIntent(context, intent, options) {
-    const current = await readDeferredRunIntent(context, intent.id);
-    if (!await isDeferredIntentDue(context, current, options.now)) {
+async function claimDispatchRunIntent(context, intent, options) {
+    const current = await readDispatchRunIntent(context, intent.id);
+    if (!await isDispatchIntentDue(context, current, options.now)) {
         return undefined;
     }
-    const claimPath = deferredClaimPath(context, current.id);
+    const claimPath = dispatchClaimPath(context, current.id);
     const claimedAt = options.now.toISOString();
-    const attemptId = deferredAttemptId(current.id, claimedAt);
+    const attemptId = dispatchAttemptId(current.id, claimedAt);
     const leaseExpiresAt = new Date(options.now.getTime() + options.leaseMs).toISOString();
     const executorId = `${process.pid}:${randomUUID()}`;
     const claim = { intentId: current.id, attemptId, claimedAt, leaseExpiresAt, executorId };
@@ -1185,11 +1107,11 @@ async function claimDeferredRunIntent(context, intent, options) {
             executorId,
         },
     };
-    await writeJsonFileAtomic(deferredIntentPath(context, current.id), running);
+    await writeJsonFileAtomic(dispatchIntentPath(context, current.id), running);
     return { intent: running, attempt };
 }
-async function releaseDeferredRunClaim(context, intentId) {
-    await rm(deferredClaimPath(context, intentId), { force: true });
+async function releaseDispatchRunClaim(context, intentId) {
+    await rm(dispatchClaimPath(context, intentId), { force: true });
 }
 async function readClaimFile(file) {
     try {
@@ -1202,13 +1124,13 @@ async function readClaimFile(file) {
         return undefined;
     }
 }
-function parseDeferredRunCreateParams(value) {
+function parseDispatchRunCreateParams(value) {
     const input = record(value);
     const runAt = optionalString(input.runAt);
     if (runAt && Number.isNaN(Date.parse(runAt))) {
-        throw new Error(`Deferred run runAt must be an ISO-compatible date: ${runAt}`);
+        throw new Error(`Dispatch run runAt must be an ISO-compatible date: ${runAt}`);
     }
-    const target = parseDeferredRunTarget(input.target);
+    const target = parseDispatchRunTarget(input.target);
     const source = recordOrUndefined(input.source);
     return compactUndefined({
         id: optionalString(input.id),
@@ -1217,7 +1139,7 @@ function parseDeferredRunCreateParams(value) {
         createdBy: optionalString(input.createdBy),
         reason: optionalString(input.reason),
         source,
-        dependsOn: parseDeferredRunDependencies(input.dependsOn),
+        dependsOn: parseDispatchRunDependencies(input.dependsOn),
     });
 }
 function parsePromptQueueEnqueueParams(value) {
@@ -1226,7 +1148,7 @@ function parsePromptQueueEnqueueParams(value) {
     if (runAt && Number.isNaN(Date.parse(runAt))) {
         throw new Error(`Prompt queue runAt must be an ISO-compatible date: ${runAt}`);
     }
-    const afterStatus = deferredDependencyStatusValue(input.afterStatus, "prompt queue afterStatus");
+    const afterStatus = dispatchDependencyStatusValue(input.afterStatus, "prompt queue afterStatus");
     return compactUndefined({
         id: optionalString(input.id),
         runAt,
@@ -1257,7 +1179,7 @@ function parseLocalHandoffEnqueueParams(value) {
     if (runAt && Number.isNaN(Date.parse(runAt))) {
         throw new Error(`Local handoff runAt must be an ISO-compatible date: ${runAt}`);
     }
-    const afterStatus = deferredDependencyStatusValue(input.afterStatus, "local handoff afterStatus");
+    const afterStatus = dispatchDependencyStatusValue(input.afterStatus, "local handoff afterStatus");
     return compactUndefined({
         id: optionalString(input.id),
         runAt,
@@ -1286,30 +1208,30 @@ function parseLocalHandoffEnqueueParams(value) {
         source: recordOrUndefined(input.source),
     });
 }
-function parseDeferredRunDependencies(value) {
+function parseDispatchRunDependencies(value) {
     if (!Array.isArray(value)) {
         return undefined;
     }
-    const dependencies = value.map(parseDeferredRunDependency);
+    const dependencies = value.map(parseDispatchRunDependency);
     return dependencies.length > 0 ? dependencies : undefined;
 }
-function parseDeferredRunDependency(value) {
+function parseDispatchRunDependency(value) {
     const input = record(value);
-    const kind = requiredString(input.kind, "deferred run dependency kind");
-    if (kind !== "deferred-run") {
-        throw new Error(`Invalid deferred run dependency kind: ${kind}`);
+    const kind = requiredString(input.kind, "dispatch run dependency kind");
+    if (kind !== "dispatch-run") {
+        throw new Error(`Invalid dispatch run dependency kind: ${kind}`);
     }
     return compactUndefined({
-        kind: "deferred-run",
-        intentId: requiredString(input.intentId, "deferred run dependency intentId"),
-        status: deferredDependencyStatusValue(input.status, "deferred run dependency status"),
+        kind: "dispatch-run",
+        intentId: requiredString(input.intentId, "dispatch run dependency intentId"),
+        status: dispatchDependencyStatusValue(input.status, "dispatch run dependency status"),
     });
 }
-function parseDeferredRunRetryParams(value) {
+function parseDispatchRunRetryParams(value) {
     const input = record(value);
     const runAt = optionalString(input.runAt);
     if (runAt && Number.isNaN(Date.parse(runAt))) {
-        throw new Error(`Deferred run retry runAt must be an ISO-compatible date: ${runAt}`);
+        throw new Error(`Dispatch run retry runAt must be an ISO-compatible date: ${runAt}`);
     }
     return compactUndefined({
         id: optionalString(input.id),
@@ -1319,13 +1241,13 @@ function parseDeferredRunRetryParams(value) {
         source: recordOrUndefined(input.source),
     });
 }
-function retryDeferredRunSource(originalIntent, source) {
+function retryDispatchRunSource(originalIntent, source) {
     const originalSource = recordOrUndefined(originalIntent.source) ?? {};
     return compactUndefined({
         ...originalSource,
-        kind: optionalString(originalSource.kind) ?? "deferred-retry",
+        kind: optionalString(originalSource.kind) ?? "dispatch-retry",
         retry: compactUndefined({
-            kind: "deferred-retry",
+            kind: "dispatch-retry",
             originalIntentId: originalIntent.id,
             originalStatus: originalIntent.status,
             originalRunAt: originalIntent.runAt,
@@ -1396,30 +1318,30 @@ function isLocalHandoffIntent(intent, options = {}) {
     }
     return true;
 }
-function parseDeferredRunTarget(value) {
+function parseDispatchRunTarget(value) {
     const target = record(value);
-    const kind = requiredString(target.kind, "deferred run target kind");
+    const kind = requiredString(target.kind, "dispatch run target kind");
     if (kind === "workbench-task") {
         return {
             kind,
-            taskId: requiredString(target.taskId, "deferred run workbench-task taskId"),
+            taskId: requiredString(target.taskId, "dispatch run workbench-task taskId"),
         };
     }
     if (kind === "workflow") {
         return compactUndefined({
             kind,
-            workflow: requiredString(target.workflow, "deferred run workflow target workflow"),
+            workflow: requiredString(target.workflow, "dispatch run workflow target workflow"),
             event: recordOrUndefined(target.event),
             prompt: optionalString(target.prompt),
             cwd: optionalString(target.cwd),
             model: optionalString(target.model),
-            sandbox: sandboxValue(target.sandbox, "deferred run workflow target sandbox"),
-            approvalPolicy: approvalPolicyValue(target.approvalPolicy, "deferred run workflow target approvalPolicy"),
+            sandbox: sandboxValue(target.sandbox, "dispatch run workflow target sandbox"),
+            approvalPolicy: approvalPolicyValue(target.approvalPolicy, "dispatch run workflow target approvalPolicy"),
             permissions: optionalString(target.permissions),
         });
     }
     if (kind === "turn") {
-        const prompt = requiredString(target.prompt, "deferred run turn target prompt");
+        const prompt = requiredString(target.prompt, "dispatch run turn target prompt");
         return compactUndefined({
             kind,
             prompt,
@@ -1427,39 +1349,39 @@ function parseDeferredRunTarget(value) {
             cwd: optionalString(target.cwd),
             model: optionalString(target.model),
             serviceTier: optionalString(target.serviceTier),
-            effort: reasoningEffortValue(target.effort, "deferred run turn target effort"),
-            sandbox: sandboxValue(target.sandbox, "deferred run turn target sandbox"),
-            approvalPolicy: approvalPolicyValue(target.approvalPolicy, "deferred run turn target approvalPolicy"),
+            effort: reasoningEffortValue(target.effort, "dispatch run turn target effort"),
+            sandbox: sandboxValue(target.sandbox, "dispatch run turn target sandbox"),
+            approvalPolicy: approvalPolicyValue(target.approvalPolicy, "dispatch run turn target approvalPolicy"),
             permissions: optionalString(target.permissions),
             responsesapiClientMetadata: stringRecord(target.responsesapiClientMetadata),
             outputSchema: target.outputSchema,
         });
     }
-    throw new Error(`Invalid deferred run target kind: ${kind}`);
+    throw new Error(`Invalid dispatch run target kind: ${kind}`);
 }
-function normalizeDeferredRunIntent(value) {
+function normalizeDispatchRunIntent(value) {
     const input = record(value);
     return {
-        id: requiredString(input.id, "deferred run id"),
-        status: deferredRunStatus(input.status),
+        id: requiredString(input.id, "dispatch run id"),
+        status: dispatchRunStatus(input.status),
         mode: workbenchMode(input.mode),
-        runAt: requiredString(input.runAt, "deferred run runAt"),
-        target: parseDeferredRunTarget(input.target),
-        createdAt: requiredString(input.createdAt, "deferred run createdAt"),
-        updatedAt: requiredString(input.updatedAt, "deferred run updatedAt"),
+        runAt: requiredString(input.runAt, "dispatch run runAt"),
+        target: parseDispatchRunTarget(input.target),
+        createdAt: requiredString(input.createdAt, "dispatch run createdAt"),
+        updatedAt: requiredString(input.updatedAt, "dispatch run updatedAt"),
         createdBy: optionalString(input.createdBy),
         reason: optionalString(input.reason),
         source: recordOrUndefined(input.source),
-        dependsOn: parseDeferredRunDependencies(input.dependsOn),
+        dependsOn: parseDispatchRunDependencies(input.dependsOn),
         attemptIds: Array.isArray(input.attemptIds)
             ? input.attemptIds.filter((entry) => typeof entry === "string")
             : [],
         lease: isRecord(input.lease)
             ? {
-                attemptId: requiredString(input.lease.attemptId, "deferred run lease attemptId"),
-                claimedAt: requiredString(input.lease.claimedAt, "deferred run lease claimedAt"),
-                expiresAt: requiredString(input.lease.expiresAt, "deferred run lease expiresAt"),
-                executorId: requiredString(input.lease.executorId, "deferred run lease executorId"),
+                attemptId: requiredString(input.lease.attemptId, "dispatch run lease attemptId"),
+                claimedAt: requiredString(input.lease.claimedAt, "dispatch run lease claimedAt"),
+                expiresAt: requiredString(input.lease.expiresAt, "dispatch run lease expiresAt"),
+                executorId: requiredString(input.lease.executorId, "dispatch run lease executorId"),
             }
             : undefined,
         completedAt: optionalString(input.completedAt),
@@ -1467,101 +1389,58 @@ function normalizeDeferredRunIntent(value) {
         error: optionalString(input.error),
     };
 }
-function normalizeDeferredRunAttempt(value) {
+function normalizeDispatchRunAttempt(value) {
     const input = record(value);
     return {
-        id: requiredString(input.id, "deferred run attempt id"),
-        intentId: requiredString(input.intentId, "deferred run attempt intentId"),
-        status: deferredAttemptStatus(input.status),
+        id: requiredString(input.id, "dispatch run attempt id"),
+        intentId: requiredString(input.intentId, "dispatch run attempt intentId"),
+        status: dispatchAttemptStatus(input.status),
         mode: workbenchMode(input.mode),
-        startedAt: requiredString(input.startedAt, "deferred run attempt startedAt"),
+        startedAt: requiredString(input.startedAt, "dispatch run attempt startedAt"),
         finishedAt: optionalString(input.finishedAt),
-        executorId: requiredString(input.executorId, "deferred run attempt executorId"),
-        leaseExpiresAt: requiredString(input.leaseExpiresAt, "deferred run attempt leaseExpiresAt"),
+        executorId: requiredString(input.executorId, "dispatch run attempt executorId"),
+        leaseExpiresAt: requiredString(input.leaseExpiresAt, "dispatch run attempt leaseExpiresAt"),
         outputPath: optionalString(input.outputPath),
         error: optionalString(input.error),
     };
 }
-function normalizeDeferredRunCollectCursor(value, fallbackCursor) {
+function normalizeDispatchRunCollectCursor(value, fallbackCursor) {
     const input = record(value);
     return compactUndefined({
         cursor: optionalString(input.cursor) ?? fallbackCursor,
-        updatedAt: requiredString(input.updatedAt, "deferred run collect cursor updatedAt"),
+        updatedAt: requiredString(input.updatedAt, "dispatch run collect cursor updatedAt"),
         lastUpdatedAt: optionalString(input.lastUpdatedAt),
         lastIntentId: optionalString(input.lastIntentId),
     });
 }
-function dueTasks(tasks, runs, now, intents = []) {
-    return tasks.filter((task) => {
-        if (!task.enabled) {
-            return false;
-        }
-        if (!task.schedule) {
-            return false;
-        }
-        return isScheduleDue(task.schedule, now) &&
-            !hasRunForDate(task.id, runs, now) &&
-            !hasScheduledIntentForDate(task.id, intents, now);
-    });
-}
-function isScheduleDue(schedule, now) {
-    const parts = schedule.trim().split(/\s+/);
-    if (parts.length !== 5) {
-        throw new Error(`Invalid workbench task schedule: ${schedule}`);
-    }
-    const [minute, hour, dayOfMonth, month, dayOfWeek] = parts;
-    return cronPartMatches(minute, now.getUTCMinutes()) &&
-        cronPartMatches(hour, now.getUTCHours()) &&
-        cronPartMatches(dayOfMonth, now.getUTCDate()) &&
-        cronPartMatches(month, now.getUTCMonth() + 1) &&
-        cronPartMatches(dayOfWeek, now.getUTCDay());
-}
-function cronPartMatches(part, value) {
-    if (!part || part === "*") {
-        return true;
-    }
-    return part.split(",").some((item) => Number.parseInt(item, 10) === value);
-}
-function hasRunForDate(taskId, runs, now) {
-    const today = now.toISOString().slice(0, 10);
-    return runs.some((run) => run.taskId === taskId && run.startedAt.startsWith(today));
-}
-function hasScheduledIntentForDate(taskId, intents, now) {
-    const expected = scheduledDeferredRunId(taskId, now);
-    return intents.some((intent) => intent.id === expected ||
-        (intent.target.kind === "workbench-task" &&
-            intent.target.taskId === taskId &&
-            intent.source?.kind === "workbench-task-schedule" &&
-            intent.source.date === now.toISOString().slice(0, 10)));
-}
-async function isDeferredIntentDue(context, intent, now) {
+async function isDispatchIntentDue(context, intent, now) {
     if (intent.status === "pending") {
         return intent.runAt <= now.toISOString() &&
-            await areDeferredRunDependenciesSatisfied(context, intent.dependsOn);
+            await areDispatchRunDependenciesSatisfied(context, intent.dependsOn);
     }
     if (intent.status === "running" && intent.lease?.expiresAt) {
         return intent.lease.expiresAt <= now.toISOString();
     }
     return false;
 }
-async function areDeferredRunDependenciesSatisfied(context, dependencies) {
+async function areDispatchRunDependenciesSatisfied(context, dependencies) {
     if (!dependencies || dependencies.length === 0) {
         return true;
     }
     for (const dependency of dependencies) {
-        if (dependency.kind !== "deferred-run") {
+        if (dependency.kind !== "dispatch-run") {
             return false;
         }
         let intent;
         try {
-            intent = await readDeferredRunIntent(context, dependency.intentId);
+            intent = await readDispatchRunIntent(context, dependency.intentId);
         }
         catch {
             return false;
         }
         const status = dependency.status ?? "completed";
         if (status === "terminal") {
-            if (!isTerminalDeferredRunStatus(intent.status)) {
+            if (!isTerminalDispatchRunStatus(intent.status)) {
                 return false;
             }
             continue;
@@ -1572,10 +1451,10 @@ async function areDeferredRunDependenciesSatisfied(context, dependencies) {
     }
     return true;
 }
-function isTerminalDeferredRunStatus(status) {
+function isTerminalDispatchRunStatus(status) {
     return status === "completed" || status === "failed" || status === "canceled";
 }
-function isAfterDeferredRunCollectCursor(intent, cursor) {
+function isAfterDispatchRunCollectCursor(intent, cursor) {
     if (!cursor?.lastUpdatedAt) {
         return true;
     }
@@ -1603,182 +1482,6 @@ function workbenchDoctorErrors(context) {
     }
     return [];
 }
-async function collectWorkbenchRunnerInfo(context, tasks, deferredRuns, probe) {
-    const workbenchRoot = path.resolve(context.repoRoot);
-    const hasScheduledWork = tasks.some((task) => task.enabled && task.schedule);
-    const hasPendingDeferredWork = deferredRuns.some((intent) => intent.status === "pending" || intent.status === "running");
-    const hasRunnableWork = hasScheduledWork || hasPendingDeferredWork;
-    const base = {
-        kind: "systemd-user",
-        workbenchRoot,
-        candidates: [],
-    };
-    if (context.mode !== "local") {
-        return {
-            ...base,
-            status: "unsupported",
-            warning: hasRunnableWork
-                ? "Runner visibility currently checks local systemd user timers only."
-                : undefined,
-        };
-    }
-    if (os.platform() !== "linux") {
-        return {
-            ...base,
-            status: "unsupported",
-            warning: hasRunnableWork
-                ? "No local systemd user timer check is available on this platform."
-                : undefined,
-        };
-    }
-    try {
-        const timerRows = parseSystemdTimerRows(await probe(["list-timers", "--all", "--no-legend", "--no-pager"]));
-        const candidates = [];
-        for (const row of timerRows) {
-            const serviceShow = parseSystemdShow(await probe([
-                "show",
-                row.service,
-                "--property=ExecStart",
-                "--property=ActiveState",
-                "--property=UnitFileState",
-                "--no-pager",
-            ]));
-            const command = normalizeSystemdCommand(serviceShow.ExecStart);
-            if (!command.includes("codex-toys")) {
-                continue;
-            }
-            const runsWorkbenchTick = /\bworkbench\s+tick\b/.test(command);
-            const runsDeferredOnly = /\bworkbench\s+deferred\s+run-due\b/.test(command);
-            if (!runsWorkbenchTick && !runsDeferredOnly) {
-                continue;
-            }
-            const timerShow = parseSystemdShow(await probe([
-                "show",
-                row.timer,
-                "--property=ActiveState",
-                "--property=UnitFileState",
-                "--property=NextElapseUSecRealtime",
-                "--property=LastTriggerUSec",
-                "--no-pager",
-            ]));
-            const runnerWorkbenchRoot = extractWorkbenchRootFromCommand(command);
-            const matchesWorkbench = runnerWorkbenchRoot
-                ? path.resolve(runnerWorkbenchRoot) === workbenchRoot
-                : command.includes(workbenchRoot);
-            candidates.push(compactUndefined({
-                kind: "systemd-user",
-                timer: row.timer,
-                service: row.service,
-                command,
-                activeState: serviceShow.ActiveState,
-                unitFileState: serviceShow.UnitFileState,
-                timerActiveState: timerShow.ActiveState,
-                timerUnitFileState: timerShow.UnitFileState,
-                nextTrigger: timerShow.NextElapseUSecRealtime,
-                lastTrigger: timerShow.LastTriggerUSec,
-                workbenchRoot: runnerWorkbenchRoot,
-                runsWorkbenchTick,
-                runsDeferredOnly,
-                matchesWorkbench,
-            }));
-        }
-        const selected = candidates.find((candidate) => candidate.matchesWorkbench &&
-            candidate.runsWorkbenchTick &&
-            candidate.timerActiveState === "active") ?? candidates.find((candidate) => candidate.matchesWorkbench &&
-            candidate.timerActiveState === "active") ?? candidates.find((candidate) => candidate.matchesWorkbench &&
-            candidate.runsWorkbenchTick) ?? candidates.find((candidate) => candidate.matchesWorkbench);
-        if (!selected) {
-            return {
-                ...base,
-                status: "missing",
-                candidates,
-                warning: hasRunnableWork
-                    ? "No matching local runner was found; due work needs a manual tick or another scheduler."
-                    : undefined,
-            };
-        }
-        const status = selected.timerActiveState === "active" ? "active" : "inactive";
-        return {
-            ...base,
-            status,
-            selected,
-            candidates,
-            warning: selected.runsDeferredOnly
-                ? "The matching runner only runs deferred work; scheduled tasks need workbench tick."
-                : status === "inactive" && hasRunnableWork
-                    ? "The matching local runner is not active; due work needs a manual tick or another scheduler."
-                    : undefined,
-        };
-    }
-    catch (error) {
-        return {
-            ...base,
-            status: "unknown",
-            error: error instanceof Error ? error.message : String(error),
-            warning: hasRunnableWork
-                ? "Could not inspect local runner status; due work may need a manual tick or another scheduler."
-                : undefined,
-        };
-    }
-}
-function parseSystemdTimerRows(output) {
-    const rows = [];
-    for (const line of output.split(/\r?\n/)) {
-        const trimmed = line.trim();
-        if (!trimmed) {
-            continue;
-        }
-        const fields = trimmed.split(/\s+/);
-        const timerIndex = fields.findIndex((field) => field.endsWith(".timer"));
-        if (timerIndex < 0) {
-            continue;
-        }
-        const timer = fields[timerIndex];
-        const service = fields[timerIndex + 1];
-        if (!timer || !service?.endsWith(".service")) {
-            continue;
-        }
-        rows.push({ timer, service });
-    }
-    return rows;
-}
-function parseSystemdShow(output) {
-    const result = {};
-    for (const line of output.split(/\r?\n/)) {
-        const index = line.indexOf("=");
-        if (index <= 0) {
-            continue;
-        }
-        result[line.slice(0, index)] = line.slice(index + 1);
-    }
-    return result;
-}
-function normalizeSystemdCommand(value) {
-    return (value ?? "")
-        .replace(/\\x([0-9a-fA-F]{2})/g, (_match, hex) => String.fromCharCode(Number.parseInt(hex, 16)))
-        .replace(/\s+/g, " ")
-        .trim();
-}
-function extractWorkbenchRootFromCommand(command) {
-    const match = command.match(/--workbench-root(?:=|\s+)(?:"([^"]+)"|'([^']+)'|([^\s;]+))/);
-    return match?.[1] ?? match?.[2] ?? match?.[3];
-}
-function formatWorkbenchRunnerInfo(runner) {
-    if (!runner) {
-        return "not checked";
-    }
-    if (runner.selected) {
-        const command = runner.selected.runsWorkbenchTick ? "workbench tick" : "workbench deferred run-due";
-        return `${runner.status} ${runner.selected.timer} -> ${runner.selected.service} (${command})`;
-    }
-    if (runner.status === "unsupported") {
-        return "unsupported";
-    }
-    if (runner.status === "unknown") {
-        return `unknown${runner.error ? ` (${runner.error})` : ""}`;
-    }
-    return `${runner.status}${runner.candidates.length > 0 ? ` (${runner.candidates.length} codex-toys runner candidates)` : ""}`;
-}
 function consecutiveFailures(taskId, runs) {
     let count = 0;
     for (const run of runs.filter((item) => item.taskId === taskId).sort((a, b) => b.startedAt.localeCompare(a.startedAt))) {
@@ -1803,73 +1506,76 @@ function runRecord(context, id, taskId, kind, startedAt, status, outputPath, err
     };
 }
 async function ensureStateDirs(context) {
-    for (const name of ["state", "runs", "outputs", "health"]) {
+    for (const name of ["state", "runs", "outputs", "latest-runs", "latest-outputs", "health"]) {
         await mkdir(path.join(context.stateRoot, name), { recursive: true });
     }
 }
-async function ensureDeferredRunDirs(context) {
+async function ensureDispatchRunDirs(context) {
     for (const dir of [
-        deferredIntentDir(context),
-        deferredAttemptDir(context),
-        deferredOutputDir(context),
-        deferredClaimDir(context),
-        deferredCollectCursorDir(context),
+        dispatchIntentDir(context),
+        dispatchAttemptDir(context),
+        dispatchOutputDir(context),
+        dispatchClaimDir(context),
+        dispatchCollectCursorDir(context),
     ]) {
         await mkdir(dir, { recursive: true });
     }
 }
-function deferredRoot(context) {
-    return path.join(context.stateRoot, "deferred");
+function dispatchRoot(context) {
+    return path.join(context.stateRoot, "dispatch");
 }
-function deferredIntentDir(context) {
-    return path.join(deferredRoot(context), "intents");
+function dispatchIntentDir(context) {
+    return path.join(dispatchRoot(context), "intents");
 }
-function deferredAttemptDir(context) {
-    return path.join(deferredRoot(context), "attempts");
+function dispatchAttemptDir(context) {
+    return path.join(dispatchRoot(context), "attempts");
 }
-function deferredOutputDir(context) {
-    return path.join(deferredRoot(context), "outputs");
+function dispatchOutputDir(context) {
+    return path.join(dispatchRoot(context), "outputs");
 }
-function deferredClaimDir(context) {
-    return path.join(deferredRoot(context), "claims");
+function dispatchClaimDir(context) {
+    return path.join(dispatchRoot(context), "claims");
 }
-function deferredCollectCursorDir(context) {
-    return path.join(deferredRoot(context), "collect-cursors");
+function dispatchCollectCursorDir(context) {
+    return path.join(dispatchRoot(context), "collect-cursors");
 }
-function deferredIntentPath(context, intentId) {
-    return path.join(deferredIntentDir(context), `${safeFileSegment(intentId)}.json`);
+function dispatchIntentPath(context, intentId) {
+    return path.join(dispatchIntentDir(context), `${safeFileSegment(intentId)}.json`);
 }
-function deferredAttemptPath(context, attemptId) {
-    return path.join(deferredAttemptDir(context), `${safeFileSegment(attemptId)}.json`);
+function dispatchAttemptPath(context, attemptId) {
+    return path.join(dispatchAttemptDir(context), `${safeFileSegment(attemptId)}.json`);
 }
-function deferredClaimPath(context, intentId) {
-    return path.join(deferredClaimDir(context), `${safeFileSegment(intentId)}.json`);
+function dispatchClaimPath(context, intentId) {
+    return path.join(dispatchClaimDir(context), `${safeFileSegment(intentId)}.json`);
 }
-function deferredCollectCursorPath(context, cursor) {
-    return path.join(deferredCollectCursorDir(context), `${safeFileSegment(cursor)}.json`);
+function dispatchCollectCursorPath(context, cursor) {
+    return path.join(dispatchCollectCursorDir(context), `${safeFileSegment(cursor)}.json`);
 }
-function deferredCollectCursorName(value, defaultCursor = "default") {
+function dispatchCollectCursorName(value, defaultCursor = "default") {
     const cursor = value?.trim() || defaultCursor;
     if (!/^[A-Za-z0-9][A-Za-z0-9_.-]*$/.test(cursor)) {
-        throw new Error(`Invalid deferred collect cursor: ${cursor}`);
+        throw new Error(`Invalid dispatch collect cursor: ${cursor}`);
     }
     return cursor;
 }
-function deferredRunId(createdAt) {
-    return `deferred-${createdAt.replace(/[:.]/g, "-")}-${randomUUID().slice(0, 8)}`;
+function dispatchRunId(createdAt) {
+    return `dispatch-${createdAt.replace(/[:.]/g, "-")}-${randomUUID().slice(0, 8)}`;
 }
-function deferredRetryRunId(originalIntentId, createdAt) {
+function dispatchRetryRunId(originalIntentId, createdAt) {
     return `retry-${safeFileSegment(originalIntentId).slice(0, 40)}-${createdAt.replace(/[:.]/g, "-")}-${randomUUID().slice(0, 8)}`;
 }
-function deferredAttemptId(intentId, startedAt) {
+function dispatchAttemptId(intentId, startedAt) {
     return `${startedAt.replace(/[:.]/g, "-")}-${randomUUID().slice(0, 8)}-${safeFileSegment(intentId).slice(0, 48)}`;
 }
-function scheduledDeferredRunId(taskId, now) {
-    return `scheduled-${safeFileSegment(taskId)}-${now.toISOString().slice(0, 10)}`;
+function latestRunDir(context) {
+    return path.join(context.stateRoot, "latest-runs");
+}
+function latestOutputDir(context) {
+    return path.join(context.stateRoot, "latest-outputs");
 }
 function safeFileSegment(value) {
     const safe = value.toLowerCase().replace(/[^a-z0-9._-]+/g, "-").replace(/^-+|-+$/g, "");
-    return safe.slice(0, 120) || "deferred-run";
+    return safe.slice(0, 120) || "dispatch-run";
 }
 async function writeNewJsonFile(file, value) {
     await mkdir(path.dirname(file), { recursive: true });
@@ -1944,10 +1650,10 @@ function codexConfigTemplate() {
         "",
     ].join("\n");
 }
-function actionsWorkflowTemplate(provider) {
+function actionsWorkflowTemplate(provider, runnerImage) {
     const checkout = provider === "github" ? "actions/checkout@v4" : "actions/checkout@v4";
     const setupNode = provider === "github" ? "actions/setup-node@v4" : "actions/setup-node@v4";
-    return [
+    const lines = [
         "name: Codex Toys Actions",
         "",
         "on:",
@@ -1958,38 +1664,19 @@ function actionsWorkflowTemplate(provider) {
         "jobs:",
         "  workbench:",
         "    runs-on: ubuntu-latest",
-        "    permissions:",
-        "      contents: write",
-        "    steps:",
-        `      - uses: ${checkout}`,
-        `      - uses: ${setupNode}`,
-        "        with:",
-        "          node-version: 24",
-        "      - run: npm install -g vite-plus",
-        "      - run: vp dlx codex-toys actions prepare-auth",
-        "        env:",
-        "          CODEX_AUTH_JSON_B64: ${{ secrets.CODEX_AUTH_JSON_B64 }}",
-        "          CODEX_AUTH_JSON: ${{ secrets.CODEX_AUTH_JSON }}",
-        "          OPENAI_API_KEY: ${{ secrets.OPENAI_API_KEY }}",
-        "      - run: vp dlx codex-toys workbench tick --mode actions",
-        "      - if: always()",
-        "        run: vp dlx codex-toys actions cleanup",
-        "      - if: always()",
-        "        run: |",
-        "          git add -- .codex/memories .codex/workbench/actions",
-        "          if [ -d .codex/feed/actions ]; then",
-        "            git add -- .codex/feed/actions",
-        "          fi",
-        "          if [ -d .codex/sessions ]; then",
-        "            git add -A -f -- .codex/sessions",
-        "          fi",
-        "          git diff --cached --quiet && exit 0",
-        "          git config user.name codex-toys-actions",
-        "          git config user.email codex-toys-actions@users.noreply.github.com",
-        "          git commit -m \"Update Codex workbench state\"",
-        "          git push",
-        "",
-    ].join("\n");
+    ];
+    if (runnerImage) {
+        lines.push("    container:", `      image: ${runnerImage}`);
+    }
+    lines.push("    permissions:", "      contents: write", "    steps:", `      - uses: ${checkout}`);
+    if (runnerImage) {
+        lines.push("      - run: git config --global --add safe.directory \"${GITHUB_WORKSPACE:-$PWD}\"", "      - run: codex-toys actions prepare-auth");
+    }
+    else {
+        lines.push(`      - uses: ${setupNode}`, "        with:", "          node-version: 24", "      - run: npm install -g vite-plus", "      - run: vp dlx codex-toys actions prepare-auth");
+    }
+    lines.push("        env:", "          CODEX_AUTH_JSON_B64: ${{ secrets.CODEX_AUTH_JSON_B64 }}", "          CODEX_AUTH_JSON: ${{ secrets.CODEX_AUTH_JSON }}", "          OPENAI_API_KEY: ${{ secrets.OPENAI_API_KEY }}", `      - run: ${runnerImage ? "codex-toys" : "vp dlx codex-toys"} workbench dispatch run-due --mode actions`, "      - if: always()", `        run: ${runnerImage ? "codex-toys" : "vp dlx codex-toys"} actions cleanup`, "      - if: always()", "        run: |", "          git add -- .codex/memories .codex/workbench/actions", "          if [ -d .codex/feed/actions ]; then", "            git add -- .codex/feed/actions", "          fi", "          if [ -d .codex/sessions ]; then", "            git add -A -f -- .codex/sessions", "          fi", "          if git diff --cached --quiet; then", "            upstream=\"$(git rev-parse --abbrev-ref --symbolic-full-name @{u} 2>/dev/null || true)\"", "            if [ -z \"${upstream}\" ] || [ \"$(git rev-list --count \"${upstream}..HEAD\")\" = \"0\" ]; then", "              exit 0", "            fi", "          else", "            git config user.name codex-toys-actions", "            git config user.email codex-toys-actions@users.noreply.github.com", "            git commit -m \"Update Codex workbench state\"", "          fi", "          git push", "");
+    return lines.join("\n");
 }
 function actionsGitignoreEntries() {
     return [
@@ -2031,12 +1718,12 @@ function parseTask(input) {
     const id = requiredTaskId(input.id);
     const enabled = input.enabled === undefined ? true : booleanValue(input.enabled, `workbench task ${id} enabled`);
     const kind = requiredString(input.kind, `workbench task ${id} kind`);
-    const schedule = optionalString(input.schedule);
-    if (schedule) {
-        isScheduleDue(schedule, new Date());
+    if (input.schedule !== undefined) {
+        throw new Error(`workbench task ${id} schedule has been removed; run explicit codex-toys commands from systemd or Actions schedules`);
     }
+    const history = workbenchTaskHistoryValue(input.history, `workbench task ${id} history`);
     if (kind === "skill") {
-        return { id, enabled, kind, skill: requiredString(input.skill, `workbench task ${id} skill`), schedule, var: optionalString(input.var) };
+        return { id, enabled, kind, skill: requiredString(input.skill, `workbench task ${id} skill`), history, var: optionalString(input.var) };
     }
     if (kind === "workflow") {
         return {
@@ -2044,7 +1731,7 @@ function parseTask(input) {
             enabled,
             kind,
             workflow: requiredString(input.workflow, `workbench task ${id} workflow`),
-            schedule,
+            history,
             event: isRecord(input.event) ? input.event : undefined,
             prompt: optionalString(input.prompt),
             cwd: optionalString(input.cwd),
@@ -2054,28 +1741,10 @@ function parseTask(input) {
         if (!Array.isArray(input.command) || !input.command.every((item) => typeof item === "string")) {
             throw new Error(`workbench task ${id} command must be an array of strings`);
         }
-        return { id, enabled, kind, command: input.command, schedule };
+        return { id, enabled, kind, command: input.command, history };
     }
     throw new Error(`Invalid workbench task kind for ${id}: ${kind}`);
 }
-function parseReactiveRule(input) {
-    if (!isRecord(input)) {
-        throw new Error("workbench.reactive entries must be tables");
-    }
-    const id = requiredTaskId(input.id);
-    const kind = requiredString(input.kind, `workbench reactive ${id} kind`);
-    if (kind !== "skill") {
-        throw new Error(`Invalid workbench reactive kind for ${id}: ${kind}`);
-    }
-    return {
-        id,
-        enabled: input.enabled === undefined ? true : booleanValue(input.enabled, `workbench reactive ${id} enabled`),
-        task: requiredString(input.task, `workbench reactive ${id} task`),
-        consecutiveFailuresGte: positiveInteger(input.consecutive_failures_gte, `workbench reactive ${id} consecutive_failures_gte`),
-        kind,
-        skill: requiredString(input.skill, `workbench reactive ${id} skill`),
-    };
-}
 function requiredTaskId(value) {
     const id = requiredString(value, "workbench task id");
     if (!/^[A-Za-z0-9][A-Za-z0-9_.-]*$/.test(id)) {
@@ -2116,6 +1785,15 @@ function booleanValue(value, label) {
     }
     return value;
 }
+function workbenchTaskHistoryValue(value, label) {
+    if (value === undefined) {
+        return "full";
+    }
+    if (value === "full" || value === "latest") {
+        return value;
+    }
+    throw new Error(`${label} must be full or latest`);
+}
 function stringRecord(value) {
     if (!isRecord(value)) {
         return undefined;
@@ -2167,7 +1845,7 @@ function reasoningEffortValue(value, label) {
     }
     return undefined;
 }
-function deferredDependencyStatusValue(value, label) {
+function dispatchDependencyStatusValue(value, label) {
     if (value === "completed" ||
         value === "failed" ||
         value === "canceled" ||
@@ -2179,7 +1857,7 @@ function deferredDependencyStatusValue(value, label) {
     }
     return undefined;
 }
-function deferredRunStatus(value) {
+function dispatchRunStatus(value) {
     if (value === "pending" ||
         value === "running" ||
         value === "completed" ||
@@ -2187,13 +1865,13 @@ function deferredRunStatus(value) {
         value === "canceled") {
         return value;
     }
-    throw new Error(`Invalid deferred run status: ${String(value)}`);
+    throw new Error(`Invalid dispatch run status: ${String(value)}`);
 }
-function deferredAttemptStatus(value) {
+function dispatchAttemptStatus(value) {
     if (value === "running" || value === "completed" || value === "failed") {
         return value;
     }
-    throw new Error(`Invalid deferred run attempt status: ${String(value)}`);
+    throw new Error(`Invalid dispatch run attempt status: ${String(value)}`);
 }
 function workbenchMode(value) {
     if (value === "local" || value === "actions") {
@@ -2201,12 +1879,6 @@ function workbenchMode(value) {
     }
     throw new Error(`Invalid workbench mode: ${String(value)}`);
 }
-function positiveInteger(value, label) {
-    if (typeof value !== "number" || !Number.isInteger(value) || value <= 0) {
-        throw new Error(`${label} must be a positive integer`);
-    }
-    return value;
-}
 function isRecord(value) {
     return typeof value === "object" && value !== null && !Array.isArray(value);
 }