codex-toys 0.140.12 → 0.140.13

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

@@ -87,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) {
@@ -100,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 {
@@ -129,10 +130,6 @@ export async function collectWorkbenchDoctorInfo(context, options = {}) {
         .toSorted((a, b) => b.updatedAt.localeCompare(a.updatedAt))[0];
     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 ?? [], dispatchRuns, options.runnerProbe ?? runSystemctlUser)
-        : undefined;
     return {
         mode: context.mode,
         requestedMode: context.requestedMode,
@@ -149,7 +146,6 @@ 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,
         dispatchCount: dispatchRuns.length,
         dispatchDueCount: dispatchDueFlags.filter(Boolean).length,
@@ -157,7 +153,6 @@ export async function collectWorkbenchDoctorInfo(context, options = {}) {
         dispatchFailedCount: dispatchRuns.filter((intent) => intent.status === "failed").length,
         latestRun,
         latestDispatchRun,
-        runner,
         surfaces: config?.surfaces ?? [],
         errors: workbenchDoctorErrors(context),
     };
@@ -174,7 +169,7 @@ 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"],
         [
             "dispatch runs",
@@ -186,11 +181,7 @@ export function formatWorkbenchDoctorInfo(info) {
                 ? `${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]);
     }
@@ -214,33 +205,6 @@ export async function scaffoldActionsWorkbench(options = {}) {
     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 listDispatchRunIntents(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 runDueDispatchRuns(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);
@@ -678,13 +642,13 @@ export async function pruneDispatchRunHistory(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") {
@@ -697,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,
@@ -767,7 +736,6 @@ async function executeDispatchRunTarget(context, intent, options) {
                 name: path.basename(context.repoRoot),
                 surfaces: [],
                 tasks: [],
-                reactive: [],
                 path: context.configPath,
             }));
             const result = await runWorkflowDispatchTarget(context, config, { ...intent, target }, options);
@@ -900,28 +868,6 @@ function dispatchWorkflowEvent(config, intent, startedAt) {
 function exhaustiveTarget(value) {
     throw new Error(`Unsupported dispatch 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;
-    }
-}
 async function runSkill(task, context) {
     const skillPath = path.join(context.runtimeCodexHome, "skills", task.skill, "SKILL.md");
     if (!await exists(skillPath)) {
@@ -976,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 = "";
@@ -1009,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,
@@ -1030,54 +968,33 @@ 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 createDispatchRunIntent(context, {
-            id: scheduledDispatchRunId(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 readDispatchRunIntent(context, intentId) {
     const intentPath = dispatchIntentPath(context, intentId);
@@ -1496,49 +1413,6 @@ function normalizeDispatchRunCollectCursor(value, fallbackCursor) {
         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 = scheduledDispatchRunId(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 isDispatchIntentDue(context, intent, now) {
     if (intent.status === "pending") {
         return intent.runAt <= now.toISOString() &&
@@ -1608,182 +1482,6 @@ function workbenchDoctorErrors(context) {
     }
     return [];
 }
-async function collectWorkbenchRunnerInfo(context, tasks, dispatchRuns, probe) {
-    const workbenchRoot = path.resolve(context.repoRoot);
-    const hasScheduledWork = tasks.some((task) => task.enabled && task.schedule);
-    const hasPendingDispatchWork = dispatchRuns.some((intent) => intent.status === "pending" || intent.status === "running");
-    const hasRunnableWork = hasScheduledWork || hasPendingDispatchWork;
-    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 runsDispatchOnly = /\bworkbench\s+dispatch\s+run-due\b/.test(command);
-            if (!runsWorkbenchTick && !runsDispatchOnly) {
-                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,
-                runsDispatchOnly,
-                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.runsDispatchOnly
-                ? "The matching runner only runs dispatch 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 dispatch 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))) {
@@ -1808,7 +1506,7 @@ 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 });
     }
 }
@@ -1869,8 +1567,11 @@ function dispatchRetryRunId(originalIntentId, createdAt) {
 function dispatchAttemptId(intentId, startedAt) {
     return `${startedAt.replace(/[:.]/g, "-")}-${randomUUID().slice(0, 8)}-${safeFileSegment(intentId).slice(0, 48)}`;
 }
-function scheduledDispatchRunId(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, "");
@@ -1974,7 +1675,7 @@ function actionsWorkflowTemplate(provider, runnerImage) {
     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 tick --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", "");
+    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() {
@@ -2017,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 {
@@ -2030,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),
@@ -2040,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)) {
@@ -2102,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;
@@ -2187,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);
 }