codex-toys 0.135.0

package/dist/cli/workspace-autonomy.js

@@ -0,0 +1,771 @@
+import { mkdir, readdir, readFile, stat, writeFile } from "node:fs/promises";
+import { randomUUID } from "node:crypto";
+import os from "node:os";
+import path from "node:path";
+import { spawn } from "node:child_process";
+import { parse as parseToml } from "smol-toml";
+import { createTurnAutomationHost, resolveTurnAutomationTarget, runTurnAutomationScript, } from "./turn-automation.js";
+import { parseJsonText } from "./json.js";
+export async function discoverWorkspaceRoot(start = process.cwd()) {
+    let current = path.resolve(start);
+    let firstDotCodexRoot;
+    while (true) {
+        try {
+            const workspaceConfig = path.join(current, ".codex", "workspace.toml");
+            if ((await stat(workspaceConfig)).isFile()) {
+                return current;
+            }
+        }
+        catch { }
+        if (!firstDotCodexRoot) {
+            try {
+                const dotCodex = path.join(current, ".codex");
+                if ((await stat(dotCodex)).isDirectory()) {
+                    firstDotCodexRoot = current;
+                }
+            }
+            catch { }
+        }
+        const parent = path.dirname(current);
+        if (parent === current) {
+            return firstDotCodexRoot ?? path.resolve(start);
+        }
+        current = parent;
+    }
+}
+export function resolveWorkspaceMode(input, env = process.env) {
+    const requestedMode = input ?? parseMode(env.CODEX_WORKSPACE_MODE) ?? "auto";
+    if (requestedMode === "actions") {
+        return { requestedMode, mode: "actions" };
+    }
+    if (requestedMode === "local") {
+        return { requestedMode, mode: "local" };
+    }
+    return { requestedMode, mode: env.GITHUB_ACTIONS === "true" ? "actions" : "local" };
+}
+export function parseMode(value) {
+    if (value === undefined || value === "") {
+        return undefined;
+    }
+    if (value === "auto" || value === "local" || value === "actions") {
+        return value;
+    }
+    throw new Error(`Invalid workspace mode: ${value}`);
+}
+export async function createWorkspaceContext(options = {}) {
+    const env = options.env ?? process.env;
+    const repoRoot = path.resolve(options.workspaceRoot ?? await discoverWorkspaceRoot());
+    const resolved = resolveWorkspaceMode(options.mode, env);
+    const workspaceCodexHome = path.join(repoRoot, ".codex");
+    const globalCodexHome = env.CODEX_HOME ?? defaultCodexHome();
+    return {
+        mode: resolved.mode,
+        requestedMode: resolved.requestedMode,
+        repoRoot,
+        configPath: path.join(workspaceCodexHome, "workspace.toml"),
+        workspaceCodexHome,
+        runtimeCodexHome: resolved.mode === "actions" ? workspaceCodexHome : globalCodexHome,
+        stateRoot: path.join(workspaceCodexHome, "workspace", resolved.mode),
+        localStateRoot: path.join(workspaceCodexHome, "workspace", "local"),
+        actionsStateRoot: path.join(workspaceCodexHome, "workspace", "actions"),
+        globalCodexHome,
+        actionsCommitPaths: [
+            path.join(workspaceCodexHome, "memories"),
+            path.join(workspaceCodexHome, "workspace", "actions"),
+        ],
+    };
+}
+export async function loadWorkspaceConfig(context) {
+    const text = await readFile(context.configPath, "utf8");
+    const parsed = parseToml(text);
+    if (!isRecord(parsed)) {
+        throw new Error(`workspace.toml must contain a table: ${context.configPath}`);
+    }
+    const workspace = isRecord(parsed.workspace) ? parsed.workspace : undefined;
+    const surfacesInput = Array.isArray(workspace?.surfaces) ? workspace.surfaces : [];
+    const tasksInput = Array.isArray(workspace?.tasks) ? workspace.tasks : [];
+    const reactiveInput = Array.isArray(workspace?.reactive) ? workspace.reactive : [];
+    const tasks = tasksInput.map(parseTask);
+    const ids = new Set();
+    for (const task of tasks) {
+        if (ids.has(task.id)) {
+            throw new Error(`Duplicate workspace task id: ${task.id}`);
+        }
+        ids.add(task.id);
+    }
+    return {
+        name: stringValue(workspace?.name, path.basename(context.repoRoot)),
+        surfaces: surfacesInput.map(parseSurface),
+        tasks,
+        reactive: reactiveInput.map(parseReactiveRule),
+        path: context.configPath,
+    };
+}
+export async function collectWorkspaceDoctorInfo(context) {
+    let config;
+    let configExists = true;
+    try {
+        config = await loadWorkspaceConfig(context);
+    }
+    catch (error) {
+        try {
+            await stat(context.configPath);
+        }
+        catch {
+            configExists = false;
+        }
+        if (configExists) {
+            throw error;
+        }
+    }
+    const runs = await readRuns(context);
+    const latestRun = runs.sort((a, b) => b.startedAt.localeCompare(a.startedAt))[0];
+    const failingCount = countFailingTasks(config?.tasks ?? [], runs);
+    return {
+        mode: context.mode,
+        requestedMode: context.requestedMode,
+        repoRoot: context.repoRoot,
+        configPath: context.configPath,
+        configExists,
+        runtimeCodexHome: context.runtimeCodexHome,
+        workspaceCodexHome: context.workspaceCodexHome,
+        stateRoot: context.stateRoot,
+        localStateRoot: context.localStateRoot,
+        actionsStateRoot: context.actionsStateRoot,
+        globalMemoryRoot: path.join(context.globalCodexHome, "memories"),
+        workspaceMemoryRoot: path.join(context.workspaceCodexHome, "memories"),
+        globalMemorySummaryExists: await exists(path.join(context.globalCodexHome, "memories", "memory_summary.md")),
+        workspaceMemorySummaryExists: await exists(path.join(context.workspaceCodexHome, "memories", "memory_summary.md")),
+        taskCount: config?.tasks.length ?? 0,
+        dueCount: dueTasks(config?.tasks ?? [], runs, new Date()).length,
+        failingCount,
+        latestRun,
+        surfaces: config?.surfaces ?? [],
+        errors: workspaceDoctorErrors(context),
+    };
+}
+export function formatWorkspaceDoctorInfo(info) {
+    const rows = [
+        ["mode", info.requestedMode === info.mode ? info.mode : `${info.mode} (${info.requestedMode})`],
+        ["repo root", info.repoRoot],
+        ["config", `${info.configPath}${info.configExists ? "" : " (missing)"}`],
+        ["runtime CODEX_HOME", info.runtimeCodexHome],
+        ["workspace CODEX_HOME", info.workspaceCodexHome],
+        ["state root", info.stateRoot],
+        ["local state", info.localStateRoot],
+        ["actions state", info.actionsStateRoot],
+        ["global memories", `${info.globalMemoryRoot}${info.globalMemorySummaryExists ? " (summary)" : ""}`],
+        ["workspace memories", `${info.workspaceMemoryRoot}${info.workspaceMemorySummaryExists ? " (summary)" : ""}`],
+        ["tasks", `${info.taskCount} configured, ${info.dueCount} due, ${info.failingCount} failing`],
+        ["latest run", info.latestRun ? `${info.latestRun.status} ${info.latestRun.taskId} ${info.latestRun.finishedAt}` : "none"],
+    ];
+    for (const error of info.errors) {
+        rows.push(["error", error]);
+    }
+    return `${rows.map(([label, value]) => `${label.padEnd(19)} ${value}`).join("\n")}\n`;
+}
+export async function scaffoldActionsWorkspace(options = {}) {
+    const workspaceRoot = path.resolve(options.workspaceRoot ?? await discoverWorkspaceRoot());
+    const files = [];
+    const write = async (relativePath, content) => {
+        files.push(await writeScaffoldFile(workspaceRoot, relativePath, content, options.overwrite === true));
+    };
+    await write(".codex/workspace.toml", workspaceTomlTemplate(workspaceRoot));
+    await write(".codex/config.toml", codexConfigTemplate());
+    if (options.forgejo) {
+        await write(".forgejo/workflows/codex-toys-actions.yml", actionsWorkflowTemplate("forgejo"));
+    }
+    if (options.github || !options.forgejo) {
+        await write(".github/workflows/codex-toys-actions.yml", actionsWorkflowTemplate("github"));
+    }
+    files.push(await appendGitignoreEntries(workspaceRoot, actionsGitignoreEntries()));
+    return { workspaceRoot, files };
+}
+export async function tickWorkspace(context, options) {
+    await ensureStateDirs(context);
+    const config = await loadWorkspaceConfig(context);
+    const previousRuns = await readRuns(context);
+    const due = dueTasks(config.tasks, previousRuns, new Date());
+    const runs = [];
+    for (const task of due) {
+        runs.push(await runWorkspaceTask(context, config, task, options));
+    }
+    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 runWorkspaceTaskById(context, taskId, options) {
+    await ensureStateDirs(context);
+    const config = await loadWorkspaceConfig(context);
+    const task = config.tasks.find((item) => item.id === taskId);
+    if (!task) {
+        throw new Error(`Unknown workspace task: ${taskId}`);
+    }
+    return await runWorkspaceTask(context, config, task, options);
+}
+export async function commitActionsWorkspaceState(context, options = {}) {
+    const env = options.env ?? process.env;
+    if (context.mode !== "actions" || env.GITHUB_ACTIONS !== "true") {
+        return { attempted: false, committed: false, paths: context.actionsCommitPaths };
+    }
+    const relativePaths = context.actionsCommitPaths.map((item) => path.relative(context.repoRoot, item));
+    await runGit(context.repoRoot, ["add", "--", ...relativePaths]);
+    const staged = await runGit(context.repoRoot, ["diff", "--cached", "--name-only", "--", ...relativePaths]);
+    if (!staged.stdout.trim()) {
+        return { attempted: true, committed: false, paths: context.actionsCommitPaths };
+    }
+    const commit = await runGit(context.repoRoot, [
+        "commit",
+        "-m",
+        options.message ?? "Update Codex workspace state",
+        "--",
+        ...relativePaths,
+    ]);
+    return {
+        attempted: true,
+        committed: true,
+        paths: context.actionsCommitPaths,
+        output: commit.stdout || commit.stderr,
+    };
+}
+async function runWorkspaceTask(context, config, task, options) {
+    const startedAt = new Date().toISOString();
+    const runId = workspaceRunId(task.id, startedAt);
+    const outputPath = path.join(context.stateRoot, "outputs", `${runId}.json`);
+    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);
+            return run;
+        }
+        if (task.kind === "automation") {
+            result = await runAutomationTask(context, config, task, runId, startedAt, options);
+        }
+        else if (task.kind === "command") {
+            result = await runCommand(task.command, context);
+        }
+        else {
+            result = await runSkill(task, context);
+        }
+        const run = runRecord(context, runId, task.id, task.kind, startedAt, "completed", outputPath);
+        await persistRun(context, 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) });
+        return run;
+    }
+}
+function workspaceRunId(taskId, startedAt) {
+    return `${startedAt.replace(/[:.]/g, "-")}-${randomUUID().slice(0, 8)}-${taskId}`;
+}
+async function runAutomationTask(context, config, task, runId, startedAt, options) {
+    const target = await resolveTurnAutomationTarget(task.automation, {
+        cwd: context.repoRoot,
+    });
+    const event = workspaceAutomationEvent(config, task, runId, startedAt);
+    const prompt = task.prompt ?? target.prompt;
+    const cwd = task.cwd ?? options.automationCwd ?? target.cwd ?? context.repoRoot;
+    const scriptRun = await runTurnAutomationScript({
+        scriptPath: target.scriptPath,
+        automation: target.automation,
+        event,
+        prompt,
+        cwd,
+        timeoutMs: 90_000,
+        host: createTurnAutomationHost({
+            via: "workspace",
+            appRequest: async (method, params) => await options.callToybox("app.call", {
+                method,
+                params,
+            }),
+            workspaceRequest: options.callToybox,
+            defaults: {
+                prompt,
+                cwd,
+                skills: target.skills,
+            },
+        }),
+    });
+    return scriptRun.result;
+}
+function workspaceAutomationEvent(config, task, runId, startedAt) {
+    const event = task.event ?? {};
+    const payload = isRecord(event.payload) ? event.payload : {};
+    return {
+        ...event,
+        id: `workspace:${config.name}:${task.id}:${runId}`,
+        type: stringValue(event.type, task.automation),
+        source: stringValue(event.source, config.name),
+        occurredAt: startedAt,
+        receivedAt: startedAt,
+        payload: {
+            taskId: task.id,
+            ...payload,
+        },
+    };
+}
+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)) {
+        throw new Error(`Skill not found: ${skillPath}`);
+    }
+    return await runCommand([
+        process.env.CODEX_APP_SERVER_CODEX_COMMAND ?? "codex",
+        "exec",
+        "--cwd",
+        context.repoRoot,
+        `Use the ${task.skill} skill for this workspace task.${task.var ? `\n\nInput: ${task.var}` : ""}`,
+    ], context);
+}
+async function runCommand(command, context) {
+    if (command.length === 0) {
+        throw new Error("command task requires at least one command element");
+    }
+    const [cmd, ...args] = command;
+    if (!cmd) {
+        throw new Error("command task requires command executable");
+    }
+    const env = {
+        ...process.env,
+        CODEX_WORKSPACE_MODE: context.mode,
+        CODEX_HOME: context.runtimeCodexHome,
+    };
+    const proc = spawn(cmd, args, {
+        cwd: context.repoRoot,
+        env,
+    });
+    const [stdout, stderr, exitCode] = await Promise.all([
+        collectText(proc.stdout),
+        collectText(proc.stderr),
+        exitCodeFor(proc),
+    ]);
+    if (exitCode !== 0) {
+        throw new Error(`Command failed (${exitCode}): ${stderr || stdout}`);
+    }
+    return { exitCode, stdout, stderr };
+}
+async function runGit(cwd, args) {
+    const proc = spawn("git", args, {
+        cwd,
+    });
+    const [stdout, stderr, exitCode] = await Promise.all([
+        collectText(proc.stdout),
+        collectText(proc.stderr),
+        exitCodeFor(proc),
+    ]);
+    if (exitCode !== 0) {
+        throw new Error(`git ${args.join(" ")} failed (${exitCode}): ${stderr || stdout}`);
+    }
+    return { stdout, stderr };
+}
+function collectText(stream) {
+    return new Promise((resolve, reject) => {
+        let output = "";
+        if (!stream) {
+            resolve(output);
+            return;
+        }
+        stream.setEncoding("utf8");
+        stream.on("data", (chunk) => {
+            output += chunk;
+        });
+        stream.once("error", reject);
+        stream.once("end", () => resolve(output));
+    });
+}
+function exitCodeFor(child) {
+    return new Promise((resolve, reject) => {
+        child.once("error", reject);
+        child.once("exit", (code) => resolve(code));
+    });
+}
+async function persistRun(context, 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`);
+    await writeHealth(context, run);
+}
+async function writeHealth(context, run) {
+    const runs = [...await readRuns(context), run].sort((a, b) => a.startedAt.localeCompare(b.startedAt));
+    const health = {
+        updatedAt: new Date().toISOString(),
+        latestRun: run,
+        failingTasks: Object.fromEntries(Array.from(new Set(runs.map((item) => item.taskId))).flatMap((taskId) => {
+            const count = consecutiveFailures(taskId, runs);
+            return count > 0 ? [[taskId, count]] : [];
+        })),
+    };
+    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);
+                }
+            }
+            catch { }
+        }
+        return runs;
+    }
+    catch {
+        return [];
+    }
+}
+function dueTasks(tasks, runs, now) {
+    return tasks.filter((task) => {
+        if (!task.enabled) {
+            return false;
+        }
+        if (!task.schedule) {
+            return false;
+        }
+        return isScheduleDue(task.schedule, now) && !hasRunForDate(task.id, runs, now);
+    });
+}
+function isScheduleDue(schedule, now) {
+    const parts = schedule.trim().split(/\s+/);
+    if (parts.length !== 5) {
+        throw new Error(`Invalid workspace 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 countFailingTasks(tasks, runs) {
+    return tasks.filter((task) => consecutiveFailures(task.id, runs) > 0).length;
+}
+function workspaceDoctorErrors(context) {
+    if (context.mode === "actions" &&
+        path.resolve(context.runtimeCodexHome) !== path.resolve(context.workspaceCodexHome)) {
+        return [
+            `Actions mode must use repo .codex as CODEX_HOME; got ${context.runtimeCodexHome}`,
+        ];
+    }
+    return [];
+}
+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))) {
+        if (run.status !== "failed") {
+            break;
+        }
+        count += 1;
+    }
+    return count;
+}
+function runRecord(context, id, taskId, kind, startedAt, status, outputPath, error) {
+    return {
+        id,
+        taskId,
+        kind,
+        status,
+        startedAt,
+        finishedAt: new Date().toISOString(),
+        mode: context.mode,
+        ...(outputPath ? { outputPath } : {}),
+        ...(error ? { error } : {}),
+    };
+}
+async function ensureStateDirs(context) {
+    for (const name of ["state", "runs", "outputs", "health"]) {
+        await mkdir(path.join(context.stateRoot, name), { recursive: true });
+    }
+}
+async function writeScaffoldFile(workspaceRoot, relativePath, content, overwrite) {
+    const file = path.join(workspaceRoot, relativePath);
+    const normalizedContent = content.endsWith("\n") ? content : `${content}\n`;
+    if (await exists(file)) {
+        const current = await readFile(file, "utf8");
+        if (current === normalizedContent) {
+            return { path: file, action: "unchanged" };
+        }
+        if (!overwrite) {
+            return { path: file, action: "unchanged" };
+        }
+        await writeFile(file, normalizedContent);
+        return { path: file, action: "updated" };
+    }
+    await mkdir(path.dirname(file), { recursive: true });
+    await writeFile(file, normalizedContent);
+    return { path: file, action: "created" };
+}
+async function appendGitignoreEntries(workspaceRoot, entries) {
+    const file = path.join(workspaceRoot, ".gitignore");
+    let current = "";
+    try {
+        current = await readFile(file, "utf8");
+    }
+    catch (error) {
+        if (!isRecord(error) || error.code !== "ENOENT") {
+            throw error;
+        }
+    }
+    const lines = new Set(current.split(/\r?\n/).filter(Boolean));
+    const missing = entries.filter((entry) => !lines.has(entry));
+    if (missing.length === 0) {
+        return { path: file, action: current ? "unchanged" : "created" };
+    }
+    await mkdir(path.dirname(file), { recursive: true });
+    const prefix = current && !current.endsWith("\n") ? "\n" : "";
+    const separator = current && !current.endsWith("\n\n") ? "\n" : "";
+    await writeFile(file, `${current}${prefix}${separator}${missing.join("\n")}\n`);
+    return { path: file, action: current ? "updated" : "created" };
+}
+function workspaceTomlTemplate(workspaceRoot) {
+    const lines = [
+        "[workspace]",
+        `name = ${tomlString(path.basename(workspaceRoot))}`,
+        "",
+    ];
+    return lines.join("\n");
+}
+function codexConfigTemplate() {
+    return [
+        "# Codex configuration for repository-scoped Actions runs.",
+        "# Actions helpers set CODEX_HOME to this .codex directory at runtime.",
+        "",
+    ].join("\n");
+}
+function actionsWorkflowTemplate(provider) {
+    const checkout = provider === "github" ? "actions/checkout@v4" : "actions/checkout@v4";
+    const setupNode = provider === "github" ? "actions/setup-node@v4" : "actions/setup-node@v4";
+    return [
+        "name: Codex Toys Actions",
+        "",
+        "on:",
+        "  workflow_dispatch:",
+        "  schedule:",
+        "    - cron: '0 * * * *'",
+        "",
+        "jobs:",
+        "  workspace:",
+        "    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 workspace tick --mode actions",
+        "      - if: always()",
+        "        run: vp dlx codex-toys actions cleanup",
+        "      - if: always()",
+        "        run: |",
+        "          git add .codex/memories .codex/workspace/actions",
+        "          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 workspace state\"",
+        "          git push",
+        "",
+    ].join("\n");
+}
+function actionsGitignoreEntries() {
+    return [
+        ".codex/auth.json",
+        ".codex/install_id",
+        ".codex/install-id",
+        ".codex/installation_id",
+        ".codex/sessions/",
+        ".codex/shell_snapshots/",
+        ".codex/shell-snapshots/",
+        ".codex/tmp/",
+        ".codex/temp/",
+        ".codex/workspace/local/",
+        ".codex/**/*.sqlite",
+        ".codex/**/*.sqlite3",
+        ".codex/**/*.db",
+    ];
+}
+function parseSurface(input) {
+    if (!isRecord(input)) {
+        throw new Error("workspace.surfaces entries must be tables");
+    }
+    return {
+        key: requiredString(input.key, "workspace surface key"),
+        kind: stringValue(input.kind, "local"),
+        homeChannelId: optionalString(input.home_channel_id),
+        workspaceForumChannelId: optionalString(input.workspace_forum_channel_id),
+        taskThreadsChannelId: optionalString(input.task_threads_channel_id),
+    };
+}
+function parseTask(input) {
+    if (!isRecord(input)) {
+        throw new Error("workspace.tasks entries must be tables");
+    }
+    const id = requiredTaskId(input.id);
+    const enabled = input.enabled === undefined ? true : booleanValue(input.enabled, `workspace task ${id} enabled`);
+    const kind = requiredString(input.kind, `workspace task ${id} kind`);
+    const schedule = optionalString(input.schedule);
+    if (schedule) {
+        isScheduleDue(schedule, new Date());
+    }
+    if (kind === "skill") {
+        return { id, enabled, kind, skill: requiredString(input.skill, `workspace task ${id} skill`), schedule, var: optionalString(input.var) };
+    }
+    if (kind === "automation") {
+        return {
+            id,
+            enabled,
+            kind,
+            automation: requiredString(input.automation, `workspace task ${id} automation`),
+            schedule,
+            event: isRecord(input.event) ? input.event : undefined,
+            prompt: optionalString(input.prompt),
+            cwd: optionalString(input.cwd),
+        };
+    }
+    if (kind === "command") {
+        if (!Array.isArray(input.command) || !input.command.every((item) => typeof item === "string")) {
+            throw new Error(`workspace task ${id} command must be an array of strings`);
+        }
+        return { id, enabled, kind, command: input.command, schedule };
+    }
+    throw new Error(`Invalid workspace task kind for ${id}: ${kind}`);
+}
+function parseReactiveRule(input) {
+    if (!isRecord(input)) {
+        throw new Error("workspace.reactive entries must be tables");
+    }
+    const id = requiredTaskId(input.id);
+    const kind = requiredString(input.kind, `workspace reactive ${id} kind`);
+    if (kind !== "skill") {
+        throw new Error(`Invalid workspace reactive kind for ${id}: ${kind}`);
+    }
+    return {
+        id,
+        enabled: input.enabled === undefined ? true : booleanValue(input.enabled, `workspace reactive ${id} enabled`),
+        task: requiredString(input.task, `workspace reactive ${id} task`),
+        consecutiveFailuresGte: positiveInteger(input.consecutive_failures_gte, `workspace reactive ${id} consecutive_failures_gte`),
+        kind,
+        skill: requiredString(input.skill, `workspace reactive ${id} skill`),
+    };
+}
+function requiredTaskId(value) {
+    const id = requiredString(value, "workspace task id");
+    if (!/^[A-Za-z0-9][A-Za-z0-9_.-]*$/.test(id)) {
+        throw new Error(`Invalid workspace task id: ${id}`);
+    }
+    return id;
+}
+function requiredString(value, label) {
+    if (typeof value !== "string" || value.length === 0) {
+        throw new Error(`${label} must be a non-empty string`);
+    }
+    return value;
+}
+function optionalString(value) {
+    return typeof value === "string" && value.length > 0 ? value : undefined;
+}
+function record(value) {
+    return isRecord(value) ? value : {};
+}
+function compactUndefined(value) {
+    const result = {};
+    for (const [key, entry] of Object.entries(value)) {
+        if (entry !== undefined) {
+            result[key] = entry;
+        }
+    }
+    return result;
+}
+function stringValue(value, fallback) {
+    return typeof value === "string" && value.length > 0 ? value : fallback;
+}
+function booleanValue(value, label) {
+    if (typeof value !== "boolean") {
+        throw new Error(`${label} must be a boolean`);
+    }
+    return 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);
+}
+async function exists(file) {
+    try {
+        await stat(file);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function defaultCodexHome() {
+    return path.join(os.homedir(), ".codex");
+}
+function tomlString(value) {
+    return JSON.stringify(value);
+}
+function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+//# sourceMappingURL=workspace-autonomy.js.map