@sireai/optimus 0.1.1

package/dist/cli/optimus.js

@@ -0,0 +1,2951 @@
+#!/usr/bin/env node
+import { buildDefaultConfig, loadConfig } from "../config/load-config.js";
+import { access, mkdir, readdir, readFile, stat, writeFile } from "node:fs/promises";
+import { basename, dirname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { execFile, spawn } from "node:child_process";
+import { createInterface } from "node:readline/promises";
+import { promisify } from "node:util";
+import { stdin as input, stdout as output } from "node:process";
+import { CodexRunner } from "../problem-solving-core/codex/codex-runner.js";
+import { CodexAuthResolver } from "../problem-solving-core/codex/codex-auth-resolver.js";
+import { SkillSyncService } from "../problem-solving-core/codex/skill-sync-service.js";
+import { RepoMemoryService } from "../problem-solving-core/codex/repo-memory-service.js";
+import { resolvePrimaryCodexApiKeyEnvName, resolveRequiredCodexEnvVars } from "../problem-solving-core/codex/codex-required-env.js";
+import { resolveCodexAuthMode, resolveConfiguredCodexModelProvider, resolveConfiguredCodexProvider, resolveEffectiveCodexModel } from "../problem-solving-core/codex/codex-provider-profile.js";
+import { classifyCodexFailureCategory } from "../problem-solving-core/codex/codex-failure-classifier.js";
+import { CodexPreflight } from "../problem-solving-core/codex/codex-preflight.js";
+import { createManualEventContent, createManualProblemEvent } from "../task-environment/intake/manual-problem-intake.js";
+import { OptimusLogger } from "../task-environment/observability/logger.js";
+import { TaskOrchestrator } from "../task-environment/orchestration/task-orchestrator.js";
+import { TriageRunner } from "../task-environment/orchestration/triage-runner.js";
+import { OptimusRuntime } from "../task-environment/runtime/optimus-runtime.js";
+import { SQLiteTaskStore } from "../task-environment/storage/sqlite-task-store.js";
+import { SQLiteEventStore } from "../task-environment/storage/sqlite-event-store.js";
+import { FeishuNotifier } from "../task-environment/delivery/feishu-notifier.js";
+import { TaskDeliveryDispatcher } from "../task-environment/delivery/task-delivery-dispatcher.js";
+import { TaskDeliveryService } from "../task-environment/delivery/task-delivery-service.js";
+import { FeishuAnalysisDocService } from "../task-environment/delivery/feishu-analysis-doc-service.js";
+import { TaskPublicationService } from "../task-environment/delivery/task-publication-service.js";
+import { resolveDefaultConfigPath, resolveDefaultEnvPath, resolveOptimusHomeDir } from "../config/optimus-paths.js";
+import { checkForSelfUpdate, installSelfUpdate, readSelfUpdateState } from "./self-update.js";
+const CLI_ROOT_DIR = resolve(dirname(fileURLToPath(import.meta.url)), "..", "..");
+const PACKAGE_JSON_PATH = join(CLI_ROOT_DIR, "package.json");
+const execFileAsync = promisify(execFile);
+const PACKAGE_NAME = "@sireai/optimus";
+function renderSetupResult(result) {
+    const lines = [];
+    lines.push("Setup Complete");
+    lines.push(`Config: ${result.configPath}`);
+    lines.push(`Env: ${result.envPath}`);
+    lines.push(`Status: ${result.configStatus}`);
+    lines.push(`Repository: ${result.repository.alias} (${result.repository.path})`);
+    lines.push(`Workspace: ${result.repository.workspaceKind}`);
+    lines.push(`Review: ${result.repository.reviewSystem}`);
+    lines.push(`Mode: ${result.repository.executionMode}`);
+    lines.push(`Delivery: ${result.deliveryChannels.join(", ")}`);
+    lines.push(`Jira: ${result.jiraEnabled ? "enabled" : "disabled"}`);
+    const providerLabel = result.codexAuth.provider ? ` | Provider: ${result.codexAuth.provider.displayName} (${result.codexAuth.provider.id})` : "";
+    if (result.codexAuth.mode === "codex_cli_login") {
+        lines.push(`Codex Auth: codex_cli_login selected${providerLabel}`);
+    }
+    else {
+        const envLabel = result.codexAuth.envName ?? "unknown";
+        lines.push(`Codex Auth: ${result.codexAuth.mode} | ${result.codexAuth.configured ? `${envLabel} configured` : `${envLabel} missing`}${providerLabel}`);
+    }
+    lines.push("");
+    lines.push(renderQuickDoctorReport(result.doctorQuick));
+    return lines.join("\n");
+}
+function renderQuickDoctorReport(report) {
+    const lines = [];
+    lines.push("Doctor Quick");
+    lines.push(`Summary: ${report.summary}`);
+    const configurationStatus = report.summary === "blocked" ? "incomplete" : "completed";
+    lines.push(`Configuration: ${configurationStatus}`);
+    if (report.blocking.length > 0) {
+        lines.push("");
+        lines.push("Blocking");
+        for (const issue of report.blocking) {
+            lines.push(`- ${issue.message}`);
+            if (issue.fix) {
+                lines.push(`  Fix: ${issue.fix}`);
+            }
+        }
+    }
+    if (report.warnings.length > 0) {
+        lines.push("");
+        lines.push("Warnings");
+        for (const issue of report.warnings) {
+            lines.push(`- ${issue.message}`);
+            if (issue.impact) {
+                lines.push(`  Impact: ${issue.impact}`);
+            }
+            if (issue.fix) {
+                lines.push(`  Fix: ${issue.fix}`);
+            }
+        }
+    }
+    if (report.next.length > 0) {
+        lines.push("");
+        lines.push("Next");
+        for (const step of report.next) {
+            lines.push(`- ${step}`);
+        }
+    }
+    return lines.join("\n");
+}
+function renderDoctorTextReport(doctor) {
+    const lines = [];
+    lines.push("Doctor");
+    lines.push(`Runtime: tasks=${doctor.runtime.totalTasks} active=${doctor.runtime.activeRuns} stalled=${doctor.runtime.stalledRuns}`);
+    lines.push(`Repositories: registered=${doctor.registeredRepositories.length}`);
+    lines.push(`Codex: model=${doctor.codex.model ?? "unknown"} auth=${doctor.codex.authMode ?? "unknown"}`);
+    if (doctor.codex.provider) {
+        const provider = typeof doctor.codex.provider === "string"
+            ? doctor.codex.provider
+            : `${doctor.codex.provider.displayName ?? doctor.codex.provider.id ?? "unknown"}`;
+        lines.push(`Provider: ${provider}`);
+    }
+    lines.push(`Triage: ${doctor.triage.status?.ok === false ? "not_ready" : "ready_or_unknown"}`);
+    if (doctor.selfUpdate) {
+        lines.push(`Self Update: current=${doctor.selfUpdate.currentVersion}`
+            + ` latest=${doctor.selfUpdate.cachedState?.latestVersion ?? "unknown"}`
+            + ` mode=${doctor.selfUpdate.config.mode}`
+            + ` source=${doctor.selfUpdate.cachedState?.installSource ?? "unknown"}`
+            + ` status=${doctor.selfUpdate.cachedState?.lastCheckStatus ?? "never_checked"}`);
+    }
+    lines.push(`Runtime Root: ${doctor.runtimeRootDir}`);
+    return lines.join("\n");
+}
+const SETUP_CODEX_AUTH_MODE_OPTIONS = [
+    { index: "1", mode: "model_provider", label: "Model provider" },
+    { index: "2", mode: "openai_api_key", label: "OpenAI API key" },
+    { index: "3", mode: "codex_cli_login", label: "Reuse local Codex CLI login" }
+];
+function renderCliHelp() {
+    return [
+        "Optimus CLI",
+        "",
+        "Usage:",
+        "  optimus <command> [options]",
+        "",
+        "First-time setup:",
+        "  optimus setup",
+        "  optimus doctor --quick",
+        "  optimus submit --title \"Login crash\" --description \"Crash on startup\"",
+        "",
+        "Core commands:",
+        "  start                 Start the resident runtime",
+        "  submit                Submit a manual task",
+        "  upgrade               Check for or install the latest Optimus version",
+        "  retry-task            Requeue an existing task",
+        "  cancel-task           Cancel a queued or running task",
+        "  triage-only           Run resident triage without enqueuing a task",
+        "",
+        "Repository commands:",
+        "  repo add|remove|update|list|doctor",
+        "",
+        "Inspection commands:",
+        "  health-check          Validate Codex/provider readiness",
+        "  doctor                Show runtime, skills, and environment diagnostics",
+        "  task-status           Show task execution status",
+        "  task-result           Show persisted result, delivery, and publication data",
+        "  delivery-status       Show focused delivery/publication state",
+        "  task-events           Show task timeline",
+        "  db-inspect            Show raw persisted task data",
+        "",
+        "Delivery commands:",
+        "  notify-test           Send or preview a Feishu test notification",
+        "  delivery-retry        Replay notification delivery from persisted bundle data",
+        "  postrun-retry         Rebuild postrun artifacts and optionally replay publication",
+        "",
+        "Integration commands:",
+        "  intake-status|intake-run|intake-disable|intake-enable|intake-reset-checkpoint",
+        "  jira-search|jira-get-issue|jira-search-assigned-open|jira-submit-issue|jira-submit-assigned-open|jira-poll-once|jira-poll-daemon",
+        "",
+        "Global options:",
+        "  -h, --help            Show this help",
+        "  -v, --version         Show the installed package version",
+        "",
+        "Notes:",
+        "  - `optimus` with no command prints help instead of starting runtime.",
+        `  - Run \`optimus setup\` once; Optimus stores config and runtime data under ${resolveOptimusHomeDir()}.`
+    ].join("\n");
+}
+async function readPackageVersion() {
+    const raw = await readFile(PACKAGE_JSON_PATH, "utf8");
+    const parsed = JSON.parse(raw);
+    return parsed.version?.trim() || "0.0.0";
+}
+async function rerunCurrentCommand() {
+    const scriptPath = process.argv[1];
+    if (!scriptPath) {
+        throw new Error("Unable to resolve current Optimus entry script.");
+    }
+    return new Promise((resolve, reject) => {
+        const child = spawn(process.execPath, [scriptPath, ...process.argv.slice(2)], {
+            stdio: "inherit",
+            env: process.env
+        });
+        child.on("error", reject);
+        child.on("close", (code) => resolve(code ?? 1));
+    });
+}
+async function maybeHandleStartupSelfUpdate(input) {
+    const check = await checkForSelfUpdate({
+        command: input.command,
+        config: input.config,
+        currentVersion: input.currentVersion,
+        packageName: PACKAGE_NAME,
+        packageRoot: CLI_ROOT_DIR
+    });
+    if (!check.checked) {
+        if (check.reason === "cached" && check.updateAvailable && check.latestVersion) {
+            console.log(`[optimus] update available ${check.currentVersion} -> ${check.latestVersion}. Run \`optimus upgrade\`.`);
+        }
+        return { handled: false };
+    }
+    if (check.reason === "check_failed") {
+        await input.logger.warn("self_update.check_failed", {
+            command: input.command,
+            reason: check.state.lastError ?? "unknown"
+        });
+        return { handled: false };
+    }
+    await input.logger.info(check.updateAvailable ? "self_update.available" : "self_update.current", {
+        command: input.command,
+        currentVersion: check.currentVersion,
+        latestVersion: check.latestVersion ?? null,
+        installSource: check.installSource
+    });
+    if (!check.updateAvailable || !check.latestVersion) {
+        return { handled: false };
+    }
+    if ((input.config.selfUpdate ?? buildDefaultConfig().selfUpdate).mode !== "auto" || input.command !== "start") {
+        console.log(`[optimus] update available ${check.currentVersion} -> ${check.latestVersion}. Run \`optimus upgrade\`.`);
+        return { handled: false };
+    }
+    console.log(`[optimus] upgrading ${check.currentVersion} -> ${check.latestVersion} before start...`);
+    await input.logger.info("self_update.install_started", {
+        command: input.command,
+        currentVersion: check.currentVersion,
+        latestVersion: check.latestVersion
+    });
+    const install = await installSelfUpdate({
+        currentVersion: check.currentVersion,
+        packageName: PACKAGE_NAME,
+        packageRoot: CLI_ROOT_DIR,
+        targetVersion: check.latestVersion
+    });
+    if (!install.success) {
+        await input.logger.error("self_update.install_failed", {
+            command: input.command,
+            currentVersion: check.currentVersion,
+            latestVersion: check.latestVersion,
+            reason: install.state.lastError ?? install.reason ?? "unknown"
+        });
+        console.log(`[optimus] upgrade failed, continuing with ${check.currentVersion}.`);
+        return { handled: false };
+    }
+    await input.logger.info("self_update.install_succeeded", {
+        command: input.command,
+        currentVersion: check.currentVersion,
+        latestVersion: check.latestVersion
+    });
+    console.log(`[optimus] upgrade succeeded, restarting ${input.command}...`);
+    return {
+        handled: true,
+        exitCode: await rerunCurrentCommand()
+    };
+}
+async function pathExists(path) {
+    try {
+        await access(path);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function buildPublicationReviewSummary(attempts) {
+    const latestReviewSubmit = [...attempts].reverse().find((attempt) => attempt.mode === "review_submit") ?? null;
+    if (!latestReviewSubmit) {
+        return { latestReviewSubmit: null };
+    }
+    return {
+        latestReviewSubmit: {
+            mode: latestReviewSubmit.mode,
+            status: latestReviewSubmit.status,
+            summary: latestReviewSubmit.summary,
+            ...(latestReviewSubmit.reviewUrl ? { reviewUrl: latestReviewSubmit.reviewUrl } : {}),
+            reviewUrls: latestReviewSubmit.reviewUrls ?? (latestReviewSubmit.reviewUrl ? [latestReviewSubmit.reviewUrl] : []),
+            ...(latestReviewSubmit.topic ? { topic: latestReviewSubmit.topic } : {}),
+            ...(latestReviewSubmit.topicUrl ? { topicUrl: latestReviewSubmit.topicUrl } : {}),
+            changeIds: latestReviewSubmit.changeIds ?? (latestReviewSubmit.changeId ? [latestReviewSubmit.changeId] : []),
+            ...(latestReviewSubmit.artifactPath ? { artifactPath: latestReviewSubmit.artifactPath } : {}),
+            createdAt: latestReviewSubmit.createdAt
+        }
+    };
+}
+function buildFeishuEnvStatus() {
+    return {
+        webhook: Boolean(process.env.OPTIMUS_FEISHU_WEBHOOK?.trim()),
+        webhooks: Boolean(process.env.OPTIMUS_FEISHU_WEBHOOKS?.trim()),
+        secret: Boolean(process.env.OPTIMUS_FEISHU_SECRET?.trim())
+    };
+}
+async function buildFeishuDoctorStatus() {
+    const env = buildFeishuEnvStatus();
+    const authCommand = "feishu auth login";
+    const resolverCommand = "feishu user resolve <xiaomi_email>";
+    try {
+        const versionResult = await execFileAsync("feishu", ["--version"], { encoding: "utf8" });
+        const version = typeof versionResult.stdout === "string" ? versionResult.stdout.trim() : String(versionResult.stdout).trim();
+        try {
+            const authResult = await execFileAsync("feishu", ["auth", "status"], { encoding: "utf8" });
+            const authText = `${typeof authResult.stdout === "string" ? authResult.stdout : String(authResult.stdout)}\n${typeof authResult.stderr === "string" ? authResult.stderr : String(authResult.stderr)}`.trim();
+            return {
+                env,
+                cli: {
+                    installed: true,
+                    authenticated: true,
+                    authCommand,
+                    ...(version ? { version } : {}),
+                    detail: authText || "Feishu CLI authenticated."
+                },
+                mentions: {
+                    requiresOpenId: true,
+                    resolverCommand,
+                    ready: true,
+                    detail: "Real @mentions require open_id resolution. Auth is ready; if resolve still fails, check Feishu app scope contact:user.id:readonly.",
+                    recommendation: "If @mentions still degrade to text, verify the Feishu app has contact:user.id:readonly."
+                }
+            };
+        }
+        catch (error) {
+            const detail = extractCommandFailureDetail(error) || "Feishu CLI is installed but not authenticated.";
+            return {
+                env,
+                cli: {
+                    installed: true,
+                    authenticated: false,
+                    authCommand,
+                    ...(version ? { version } : {}),
+                    detail,
+                    recommendation: "Run 'feishu auth login' to refresh Feishu authorization for doc upload and user identity resolution."
+                },
+                mentions: {
+                    requiresOpenId: true,
+                    resolverCommand,
+                    ready: false,
+                    detail: "Real @mentions require open_id resolution, but Feishu CLI auth is not ready.",
+                    recommendation: "Run 'feishu auth login' before relying on Feishu user resolution or real @mentions."
+                }
+            };
+        }
+    }
+    catch (error) {
+        const detail = extractCommandFailureDetail(error) || "Feishu CLI is not installed.";
+        return {
+            env,
+            cli: {
+                installed: false,
+                authenticated: false,
+                authCommand,
+                detail,
+                recommendation: "Install Feishu CLI first, then run 'feishu auth login' if you need Feishu delivery, docs, or real @mentions."
+            },
+            mentions: {
+                requiresOpenId: true,
+                resolverCommand,
+                ready: false,
+                detail: "Real @mentions require Feishu CLI user resolution support.",
+                recommendation: "Install Feishu CLI and authenticate before relying on Feishu open_id resolution."
+            }
+        };
+    }
+}
+function extractCommandFailureDetail(error) {
+    if (!(error instanceof Error)) {
+        return typeof error === "string" ? error : undefined;
+    }
+    const detail = [error.message, error.stderr, error.stdout]
+        .filter((value) => typeof value === "string" && value.trim().length > 0)
+        .join("\n")
+        .trim();
+    return detail || undefined;
+}
+async function promptSetupAnswers(defaults) {
+    const configPath = resolveDefaultConfigPath();
+    const scriptedAnswers = input.isTTY ? undefined : await readScriptedPromptAnswers();
+    const rl = scriptedAnswers ? undefined : createInterface({ input, output });
+    let scriptedIndex = 0;
+    const ask = async (prompt) => {
+        if (scriptedAnswers) {
+            output.write(prompt);
+            const answer = scriptedAnswers[scriptedIndex] ?? "";
+            scriptedIndex += 1;
+            return answer;
+        }
+        return rl.question(prompt);
+    };
+    try {
+        if (await pathExists(configPath)) {
+            console.log(`Existing config found at ${configPath}. Press Enter to keep current values.`);
+        }
+        const repoPath = (await ask(`Repository path [${defaults.repoPath}]: `)).trim() || defaults.repoPath;
+        const repoAlias = (await ask(`Repository alias [${defaults.repoAlias}]: `)).trim() || defaults.repoAlias;
+        const codexAuthMode = await askSetupCodexAuthMode({ ask, defaultMode: defaults.codexAuthMode });
+        let codexApiKey;
+        let codexProviderId;
+        let codexProviderDisplayName;
+        let codexProviderBaseUrl;
+        let codexProviderApiKeyEnvName;
+        if (codexAuthMode === "openai_api_key") {
+            codexApiKey = (await ask("OpenAI API key for OPENAI_API_KEY (leave blank to keep existing): ")).trim() || undefined;
+        }
+        else if (codexAuthMode === "model_provider") {
+            codexProviderId = (await ask(`Provider id [${defaults.codexProviderId ?? ""}]: `)).trim() || defaults.codexProviderId;
+            codexProviderDisplayName = (await ask(`Provider display name [${defaults.codexProviderDisplayName ?? ""}]: `)).trim() || defaults.codexProviderDisplayName;
+            codexProviderBaseUrl = (await ask(`Provider base URL [${defaults.codexProviderBaseUrl ?? ""}]: `)).trim() || defaults.codexProviderBaseUrl;
+            codexProviderApiKeyEnvName = (await ask(`Provider API key env name [${defaults.codexProviderApiKeyEnvName ?? ""}]: `)).trim() || defaults.codexProviderApiKeyEnvName;
+            const providerKeyLabel = codexProviderApiKeyEnvName || defaults.codexProviderApiKeyEnvName || "the configured provider env";
+            codexApiKey = (await ask(`Provider API key value for ${providerKeyLabel} (leave blank to keep existing): `)).trim() || undefined;
+        }
+        const enableFeishuInput = (await ask(`Enable Feishu delivery? [${defaults.enableFeishu ? "Y/n" : "y/N"}] `)).trim().toLowerCase();
+        const enableFeishu = enableFeishuInput.length === 0
+            ? defaults.enableFeishu
+            : ["y", "yes"].includes(enableFeishuInput);
+        const feishuWebhook = enableFeishu
+            ? (await ask(`Feishu webhook [${defaults.feishuWebhook ? "configured" : ""}]: `)).trim() || defaults.feishuWebhook
+            : undefined;
+        const feishuSecret = enableFeishu
+            ? (await ask(`Feishu secret (optional) [${defaults.feishuSecret ? "configured" : ""}]: `)).trim() || defaults.feishuSecret
+            : undefined;
+        const enableJiraInput = (await ask(`Enable Jira integration? [${defaults.enableJira ? "Y/n" : "y/N"}] `)).trim().toLowerCase();
+        const enableJira = enableJiraInput.length === 0
+            ? defaults.enableJira
+            : ["y", "yes"].includes(enableJiraInput);
+        const jiraBaseUrl = enableJira
+            ? (await ask(`Jira base URL [${defaults.jiraBaseUrl ?? ""}]: `)).trim() || defaults.jiraBaseUrl
+            : undefined;
+        const jiraToken = enableJira
+            ? (await ask(`Jira token [${defaults.jiraToken ? "configured" : ""}]: `)).trim() || defaults.jiraToken
+            : undefined;
+        return {
+            repoPath,
+            repoAlias,
+            codexAuthMode,
+            ...(codexApiKey ? { codexApiKey } : {}),
+            ...(codexProviderId ? { codexProviderId } : {}),
+            ...(codexProviderDisplayName ? { codexProviderDisplayName } : {}),
+            ...(codexProviderBaseUrl ? { codexProviderBaseUrl } : {}),
+            ...(codexProviderApiKeyEnvName ? { codexProviderApiKeyEnvName } : {}),
+            enableFeishu,
+            ...(feishuWebhook ? { feishuWebhook } : {}),
+            ...(feishuSecret ? { feishuSecret } : {}),
+            enableJira,
+            ...(jiraBaseUrl ? { jiraBaseUrl } : {}),
+            ...(jiraToken ? { jiraToken } : {})
+        };
+    }
+    finally {
+        rl?.close();
+    }
+}
+async function readScriptedPromptAnswers() {
+    const chunks = [];
+    for await (const chunk of input) {
+        chunks.push(typeof chunk === "string" ? chunk : chunk.toString("utf8"));
+    }
+    return chunks.join("").split(/\r?\n/);
+}
+async function resolveDefaultSetupAnswers() {
+    const defaults = buildDefaultConfig();
+    const configPath = resolveDefaultConfigPath();
+    if (!await pathExists(configPath)) {
+        return {
+            repoPath: "",
+            repoAlias: "",
+            codexAuthMode: defaults.codex.auth.mode,
+            enableFeishu: false,
+            enableJira: false
+        };
+    }
+    const config = await loadConfig(configPath);
+    const store = new SQLiteTaskStore(config.storage.rootDir);
+    await store.init();
+    const repositories = await store.listRepositoryRoots();
+    const primaryRepository = repositories[0];
+    const provider = config.codex.provider;
+    return {
+        repoPath: primaryRepository?.path ?? "",
+        repoAlias: primaryRepository?.alias ?? "",
+        codexAuthMode: config.codex.auth.mode,
+        ...(provider?.id ? { codexProviderId: provider.id } : {}),
+        ...(provider?.displayName ? { codexProviderDisplayName: provider.displayName } : {}),
+        ...(provider?.baseUrl ? { codexProviderBaseUrl: provider.baseUrl } : {}),
+        ...(provider?.apiKeyEnvName ? { codexProviderApiKeyEnvName: provider.apiKeyEnvName } : {}),
+        enableFeishu: config.delivery.channels.includes("feishu"),
+        ...(config.delivery.feishu.webhook ? { feishuWebhook: config.delivery.feishu.webhook } : {}),
+        ...(config.delivery.feishu.secret ? { feishuSecret: config.delivery.feishu.secret } : {}),
+        enableJira: config.jira.enabled,
+        ...(config.jira.baseUrl ? { jiraBaseUrl: config.jira.baseUrl } : {}),
+        ...(config.jira.bearerToken ? { jiraToken: config.jira.bearerToken } : {})
+    };
+}
+function normalizeSetupCodexAuthMode(value) {
+    const normalized = value?.trim();
+    if (normalized === "1") {
+        return "model_provider";
+    }
+    if (normalized === "2") {
+        return "openai_api_key";
+    }
+    if (normalized === "3") {
+        return "codex_cli_login";
+    }
+    if (normalized === "openai_api_key" || normalized === "codex_cli_login" || normalized === "model_provider") {
+        return normalized;
+    }
+    return undefined;
+}
+function renderSetupCodexAuthModePrompt(defaultMode) {
+    const defaultIndex = SETUP_CODEX_AUTH_MODE_OPTIONS.find((option) => option.mode === defaultMode)?.index ?? "1";
+    const lines = ["Codex auth mode:"];
+    for (const option of SETUP_CODEX_AUTH_MODE_OPTIONS) {
+        const defaultSuffix = option.index === defaultIndex ? " (default)" : "";
+        lines.push(`${option.index}. ${option.label} [${option.mode}]${defaultSuffix}`);
+    }
+    lines.push(`Choose [${defaultIndex}]: `);
+    return `${lines.join("\n")}\n`;
+}
+async function askSetupCodexAuthMode(input) {
+    while (true) {
+        const answer = (await input.ask(renderSetupCodexAuthModePrompt(input.defaultMode))).trim();
+        if (answer.length === 0) {
+            return input.defaultMode;
+        }
+        const normalized = normalizeSetupCodexAuthMode(answer);
+        if (normalized) {
+            return normalized;
+        }
+        console.log("Invalid selection. Choose 1, 2, or 3.");
+    }
+}
+function validateSetupAnswers(answers) {
+    if (!answers.repoPath.trim()) {
+        return "setup requires a repository path.";
+    }
+    if (!answers.repoAlias.trim()) {
+        return "setup requires a repository alias.";
+    }
+    if (answers.codexAuthMode === "model_provider" && !answers.codexProviderId?.trim()) {
+        return "setup requires provider id when Codex auth mode is model_provider.";
+    }
+    if (answers.codexAuthMode === "model_provider" && !answers.codexProviderDisplayName?.trim()) {
+        return "setup requires provider display name when Codex auth mode is model_provider.";
+    }
+    if (answers.codexAuthMode === "model_provider" && !answers.codexProviderBaseUrl?.trim()) {
+        return "setup requires provider base URL when Codex auth mode is model_provider.";
+    }
+    if (answers.codexAuthMode === "model_provider" && !answers.codexProviderApiKeyEnvName?.trim()) {
+        return "setup requires provider API key env name when Codex auth mode is model_provider.";
+    }
+    if (answers.enableFeishu && !answers.feishuWebhook?.trim()) {
+        return "setup requires a Feishu webhook when Feishu delivery is enabled.";
+    }
+    if (answers.enableJira && !answers.jiraBaseUrl?.trim()) {
+        return "setup requires a Jira base URL when Jira integration is enabled.";
+    }
+    if (answers.enableJira && !answers.jiraToken?.trim()) {
+        return "setup requires a Jira token when Jira integration is enabled.";
+    }
+    return undefined;
+}
+async function detectRepositoryReviewSystem(repositoryPath, inspection) {
+    if (!inspection.rootIsGit) {
+        return "manual";
+    }
+    const remoteNamesOutput = await execFileAsync("git", ["-C", repositoryPath, "remote"], { encoding: "utf8" })
+        .then((result) => typeof result.stdout === "string" ? result.stdout : String(result.stdout))
+        .catch(() => "");
+    const remoteNames = remoteNamesOutput
+        .split(/\r?\n/)
+        .map((value) => value.trim())
+        .filter(Boolean);
+    const primaryRemote = remoteNames.includes("origin") ? "origin" : remoteNames[0];
+    if (!primaryRemote) {
+        return "manual";
+    }
+    const remoteUrl = await execFileAsync("git", ["-C", repositoryPath, "remote", "get-url", primaryRemote], { encoding: "utf8" })
+        .then((result) => (typeof result.stdout === "string" ? result.stdout : String(result.stdout)).trim())
+        .catch(() => "");
+    if (!remoteUrl) {
+        return "manual";
+    }
+    if (/github\.com[:/]/i.test(remoteUrl)) {
+        return "github_pr";
+    }
+    if (/gerrit/i.test(remoteUrl)) {
+        return "gerrit_change";
+    }
+    return "manual";
+}
+function resolveSetupCodexApiKeyEnvName(answers) {
+    if (answers.codexAuthMode === "openai_api_key") {
+        return "OPENAI_API_KEY";
+    }
+    if (answers.codexAuthMode === "model_provider") {
+        return answers.codexProviderApiKeyEnvName?.trim() || undefined;
+    }
+    return undefined;
+}
+function buildSetupConfig(answers) {
+    const config = buildDefaultConfig();
+    config.codex.auth.mode = answers.codexAuthMode;
+    if (answers.codexAuthMode === "model_provider") {
+        config.codex.provider = {
+            id: answers.codexProviderId.trim(),
+            displayName: answers.codexProviderDisplayName.trim(),
+            baseUrl: answers.codexProviderBaseUrl.trim(),
+            apiKeyEnvName: answers.codexProviderApiKeyEnvName.trim(),
+            wireApi: "responses"
+        };
+    }
+    else {
+        delete config.codex.provider;
+    }
+    config.delivery.channels = answers.enableFeishu ? ["console", "feishu"] : ["console"];
+    config.delivery.feishu = {
+        ...config.delivery.feishu,
+        ...(answers.enableFeishu && answers.feishuWebhook ? { webhook: answers.feishuWebhook } : {}),
+        ...(answers.enableFeishu && answers.feishuSecret ? { secret: answers.feishuSecret } : {})
+    };
+    config.jira.enabled = answers.enableJira;
+    if (answers.enableJira) {
+        config.jira.baseUrl = answers.jiraBaseUrl ?? config.jira.baseUrl;
+        config.jira.authType = "bearer";
+        if (answers.jiraToken) {
+            config.jira.bearerToken = answers.jiraToken;
+        }
+        config.jira.httpHeaders = {};
+    }
+    return JSON.stringify(config, null, 2);
+}
+async function upsertDotEnvValue(path, key, value) {
+    let lines = [];
+    try {
+        lines = (await readFile(path, "utf8")).split(/\r?\n/);
+    }
+    catch {
+        lines = [];
+    }
+    let replaced = false;
+    const nextLines = lines.map((line) => {
+        if (!line.match(new RegExp(`^\\s*${key}=`))) {
+            return line;
+        }
+        replaced = true;
+        return `${key}=${value}`;
+    });
+    if (!replaced) {
+        if (nextLines.length > 0 && nextLines.at(-1)?.trim() !== "") {
+            nextLines.push("");
+        }
+        nextLines.push(`${key}=${value}`);
+    }
+    await writeFile(path, `${nextLines.join("\n").replace(/\n*$/, "\n")}`, "utf8");
+}
+async function readRawProjectConfig(configPath) {
+    try {
+        const raw = await readFile(configPath, "utf8");
+        return JSON.parse(raw);
+    }
+    catch {
+        return undefined;
+    }
+}
+async function readGitIdentity(repositoryPath) {
+    const userName = await execFileAsync("git", ["-C", repositoryPath, "config", "--get", "user.name"], { encoding: "utf8" })
+        .then((result) => (typeof result.stdout === "string" ? result.stdout : String(result.stdout)).trim() || undefined)
+        .catch(() => undefined);
+    const userEmail = await execFileAsync("git", ["-C", repositoryPath, "config", "--get", "user.email"], { encoding: "utf8" })
+        .then((result) => (typeof result.stdout === "string" ? result.stdout : String(result.stdout)).trim() || undefined)
+        .catch(() => undefined);
+    return {
+        ...(userName ? { userName } : {}),
+        ...(userEmail ? { userEmail } : {})
+    };
+}
+async function runQuickDoctor(configPath = resolveDefaultConfigPath()) {
+    const blocking = [];
+    const warnings = [];
+    const repositories = [];
+    const next = new Set();
+    if (!await pathExists(configPath)) {
+        return {
+            summary: "blocked",
+            configPath,
+            blocking: [{
+                    code: "config_missing",
+                    message: "Config file not found.",
+                    fix: "Run `optimus setup` first."
+                }],
+            warnings: [],
+            repositories: [],
+            next: ["optimus setup"]
+        };
+    }
+    const rawConfig = await readRawProjectConfig(configPath);
+    if (!rawConfig) {
+        return {
+            summary: "blocked",
+            configPath,
+            blocking: [{
+                    code: "config_parse_failed",
+                    message: "Config file exists but could not be parsed.",
+                    fix: "Fix `optimus.config.json` or rerun `optimus setup --force`."
+                }],
+            warnings: [],
+            repositories: [],
+            next: ["optimus setup --force"]
+        };
+    }
+    let config;
+    try {
+        config = await loadConfig(configPath);
+    }
+    catch (error) {
+        return {
+            summary: "blocked",
+            configPath,
+            blocking: [{
+                    code: "config_load_failed",
+                    message: error instanceof Error ? error.message : "Failed to load config.",
+                    fix: "Fix `optimus.config.json` or rerun `optimus setup --force`."
+                }],
+            warnings: [],
+            repositories: [],
+            next: ["optimus setup --force"]
+        };
+    }
+    const codexAuth = new CodexAuthResolver(config).resolve().diagnostics;
+    if (!codexAuth.authenticated) {
+        blocking.push({
+            code: "codex_auth_missing",
+            message: `Codex authentication is missing. Required credential: ${codexAuth.apiKeyEnvName ?? "runtime login"}.`,
+            fix: codexAuth.apiKeyEnvName
+                ? `Provide ${codexAuth.apiKeyEnvName} in .env.local, or rerun \`optimus setup\` and enter the Codex API key.`
+                : "Rerun `optimus setup` and select a supported Codex auth mode."
+        });
+        next.add("optimus setup");
+    }
+    if (codexAuth.mode === "codex_cli_login") {
+        warnings.push({
+            code: "codex_cli_login_runtime_validation",
+            message: "Codex auth mode is codex_cli_login.",
+            impact: "Quick doctor cannot statically verify local Codex CLI login; the first runtime turn will validate it."
+        });
+    }
+    if (!config.codex.model?.trim()) {
+        blocking.push({
+            code: "codex_model_missing",
+            message: "Codex model default is missing from project config.",
+            fix: "Rerun `optimus setup --force` to restore project defaults."
+        });
+        next.add("optimus setup --force");
+    }
+    if (resolveCodexAuthMode(config) === "model_provider" && !resolveConfiguredCodexProvider(config)) {
+        blocking.push({
+            code: "codex_provider_missing",
+            message: "Codex model provider metadata is missing or invalid.",
+            fix: "Rerun `optimus setup --force` and provide provider id, display name, base URL, and API key env name."
+        });
+        next.add("optimus setup --force");
+    }
+    const store = new SQLiteTaskStore(config.storage.rootDir);
+    await store.init();
+    const registeredRepositories = await store.listRepositoryRoots();
+    if (registeredRepositories.length === 0) {
+        blocking.push({
+            code: "repository_missing",
+            message: "No repository is registered.",
+            fix: "Rerun `optimus setup` and provide a repository path and alias."
+        });
+        next.add("optimus setup");
+    }
+    for (const repository of registeredRepositories) {
+        const inspection = await inspectRepositoryRoot(repository.path);
+        const executionPlan = describeRepositoryExecutionPlan(repository, inspection);
+        const reviewSystem = await detectRepositoryReviewSystem(repository.path, inspection);
+        repositories.push({
+            path: repository.path,
+            ...(repository.alias ? { alias: repository.alias } : {}),
+            ok: inspection.ok,
+            workspaceKind: executionPlan.workspaceKind,
+            reviewSystem,
+            executionMode: repository.executionMode,
+            ...(inspection.reason ? { reason: inspection.reason } : {})
+        });
+        if (!inspection.ok) {
+            blocking.push({
+                code: "repository_invalid",
+                message: `Repository path is not usable: ${repository.path}`,
+                fix: "Rerun `optimus setup` with a valid repository path."
+            });
+            next.add("optimus setup");
+        }
+    }
+    const firstRepository = registeredRepositories[0];
+    if (firstRepository) {
+        const gitIdentity = await readGitIdentity(firstRepository.path);
+        if (!gitIdentity.userName) {
+            blocking.push({
+                code: "git_user_name_missing",
+                message: "Git user.name is missing for the configured repository.",
+                fix: "Run `git config user.name \"Your Name\"` in the repository, then rerun `optimus doctor --quick`."
+            });
+            next.add("git config user.name \"Your Name\"");
+        }
+        if (!gitIdentity.userEmail) {
+            blocking.push({
+                code: "git_user_email_missing",
+                message: "Git user.email is missing for the configured repository.",
+                fix: "Run `git config user.email \"you@example.com\"` in the repository, then rerun `optimus doctor --quick`."
+            });
+            next.add("git config user.email \"you@example.com\"");
+        }
+    }
+    const feishuEnabled = config.delivery.channels.includes("feishu");
+    const configuredFeishuTargets = [
+        config.delivery.feishu.webhook?.trim(),
+        ...(config.delivery.feishu.webhooks ?? []).map((value) => value.trim())
+    ].filter((value) => Boolean(value));
+    if (feishuEnabled && configuredFeishuTargets.length === 0) {
+        blocking.push({
+            code: "feishu_webhook_missing",
+            message: "Feishu delivery is enabled, but no webhook is configured.",
+            fix: "Rerun `optimus setup` and provide a Feishu webhook."
+        });
+        next.add("optimus setup");
+    }
+    if (!feishuEnabled) {
+        warnings.push({
+            code: "feishu_disabled",
+            message: "Feishu delivery is disabled.",
+            impact: "Notifications will stay console-only."
+        });
+    }
+    if (config.jira.enabled) {
+        if (!config.jira.baseUrl?.trim() || /jira\.example\.com/i.test(config.jira.baseUrl)) {
+            blocking.push({
+                code: "jira_base_url_missing",
+                message: "Jira integration is enabled, but Jira base URL is missing or still using the placeholder value.",
+                fix: "Rerun `optimus setup` and provide a real Jira base URL."
+            });
+            next.add("optimus setup");
+        }
+        if (!config.jira.bearerToken?.trim()) {
+            blocking.push({
+                code: "jira_token_missing",
+                message: "Jira integration is enabled, but Jira token is missing.",
+                fix: "Rerun `optimus setup` and provide a Jira token."
+            });
+            next.add("optimus setup");
+        }
+    }
+    else {
+        warnings.push({
+            code: "jira_disabled",
+            message: "Jira integration is disabled.",
+            impact: "Jira submission commands will not be ready until setup is rerun with Jira enabled."
+        });
+    }
+    return {
+        summary: blocking.length > 0 ? "blocked" : warnings.length > 0 ? "degraded" : "ready",
+        configPath,
+        blocking,
+        warnings,
+        repositories,
+        next: [...next]
+    };
+}
+async function runSetup(args) {
+    const configPath = resolveDefaultConfigPath();
+    const envPath = resolveDefaultEnvPath();
+    const configExists = await pathExists(configPath);
+    const defaults = await resolveDefaultSetupAnswers();
+    if (args["non-interactive"] === "true") {
+        throw new Error("setup no longer supports --non-interactive. Run `optimus setup` interactively.");
+    }
+    const answers = await promptSetupAnswers(defaults);
+    const validationError = validateSetupAnswers(answers);
+    if (validationError) {
+        throw new Error(validationError);
+    }
+    const normalizedRepoPath = resolve(answers.repoPath);
+    const inspection = await inspectRepositoryRoot(normalizedRepoPath);
+    if (!inspection.ok) {
+        throw new Error(`Repository path is not usable: ${normalizedRepoPath} (${inspection.reason ?? "unknown"})`);
+    }
+    const previewExecutionPlan = describeRepositoryExecutionPlan({ executionMode: "copy" }, inspection);
+    const reviewSystem = await detectRepositoryReviewSystem(normalizedRepoPath, inspection);
+    await mkdir(dirname(configPath), { recursive: true });
+    await writeFile(configPath, `${buildSetupConfig({ ...answers, repoPath: normalizedRepoPath })}\n`, "utf8");
+    const codexAuthEnvName = resolveSetupCodexApiKeyEnvName(answers);
+    if (answers.codexApiKey && codexAuthEnvName) {
+        await mkdir(dirname(envPath), { recursive: true });
+        await upsertDotEnvValue(envPath, codexAuthEnvName, answers.codexApiKey);
+    }
+    const config = await loadConfig(configPath);
+    const store = new SQLiteTaskStore(config.storage.rootDir);
+    await store.init();
+    const existingRepositories = await store.listRepositoryRoots();
+    for (const repository of existingRepositories) {
+        await store.removeRepositoryRoot(repository.path);
+    }
+    await store.addRepositoryRoot({
+        path: normalizedRepoPath,
+        alias: answers.repoAlias,
+        executionMode: previewExecutionPlan.resolvedDefaultMode
+    });
+    const doctorQuick = await runQuickDoctor(configPath);
+    const codexAuth = new CodexAuthResolver(config).resolve().diagnostics;
+    return {
+        ok: true,
+        configPath,
+        envPath,
+        configStatus: configExists ? "overwritten" : "created",
+        repository: {
+            path: normalizedRepoPath,
+            alias: answers.repoAlias,
+            workspaceKind: previewExecutionPlan.workspaceKind,
+            executionMode: previewExecutionPlan.resolvedDefaultMode,
+            reviewSystem
+        },
+        deliveryChannels: config.delivery.channels,
+        jiraEnabled: config.jira.enabled,
+        codexAuth: {
+            mode: codexAuth.mode,
+            ...(codexAuth.apiKeyEnvName ? { envName: codexAuth.apiKeyEnvName } : {}),
+            configured: codexAuth.authenticated,
+            ...(codexAuth.providerId ? {
+                provider: {
+                    id: codexAuth.providerId,
+                    displayName: codexAuth.providerDisplayName ?? codexAuth.providerId
+                }
+            } : {})
+        },
+        doctorQuick
+    };
+}
+function inferArtifactDir(artifacts, bundle) {
+    const candidates = [
+        bundle?.artifacts.resultMd,
+        bundle?.artifacts.patchDiff,
+        ...artifacts.map((artifact) => artifact.path)
+    ].filter((value) => typeof value === "string" && value.trim().length > 0);
+    const artifactPath = candidates.find((candidate) => candidate.includes(`${join(".optimus", "artifacts")}${candidate.includes("\\") ? "\\" : "/"}`))
+        ?? candidates[0];
+    if (!artifactPath) {
+        return undefined;
+    }
+    return dirname(artifactPath);
+}
+function inferTaskRootDir(artifactDir) {
+    if (!artifactDir) {
+        return undefined;
+    }
+    return resolve(artifactDir, "..", "..");
+}
+async function buildReplayExecutionContext(input) {
+    const artifactDir = inferArtifactDir(input.artifacts, input.deliveryBundle);
+    const taskRootDir = inferTaskRootDir(artifactDir);
+    const sourceDir = input.deliveryBundle?.publication?.git?.repoDir?.trim()
+        || input.latestRun?.addresses?.visibleRepoDir?.trim()
+        || input.latestRun?.addresses?.workspaceDir?.trim();
+    const workspaceDir = input.latestRun?.addresses?.workspaceDir?.trim()
+        || sourceDir;
+    const mode = input.latestRun?.addresses?.resolvedExecutionMode
+        ?? input.latestRun?.addresses?.configuredExecutionMode
+        ?? (input.latestRun?.addresses?.visibleRepoDir ? "inplace" : "copy");
+    if (!artifactDir || !taskRootDir || !workspaceDir || !sourceDir) {
+        return undefined;
+    }
+    const repoSelector = input.taskRepo?.trim();
+    const repoMemory = repoSelector
+        ? await new RepoMemoryService(input.config).load(input.taskType, repoSelector)
+        : undefined;
+    return {
+        taskRootDir,
+        addresses: {
+            mode,
+            workspaceDir,
+            sourceDir,
+            artifactDir,
+            repoRef: repoSelector || sourceDir
+        },
+        sandboxMode: input.latestRun?.sandboxMode ?? input.config.codex.sandboxMode,
+        approvalPolicy: input.latestRun?.approvalPolicy ?? input.config.codex.approvalPolicy,
+        ...(input.latestRun?.addresses?.configuredExecutionMode ? { configuredExecutionMode: input.latestRun.addresses.configuredExecutionMode } : {}),
+        ...(repoMemory ? { repoMemory } : {})
+    };
+}
+function mergeReplayBundle(rebuilt, existing) {
+    if (!existing) {
+        return rebuilt;
+    }
+    const effectivePublication = !rebuilt.publication
+        || (rebuilt.publication.action !== "ready_for_publish" && existing.publication?.action === "ready_for_publish")
+        ? existing.publication
+        : rebuilt.publication;
+    return {
+        ...rebuilt,
+        summary: {
+            ...existing.summary,
+            ...rebuilt.summary,
+            ...(rebuilt.summary.analysisDocUrl ? {} : existing.summary.analysisDocUrl ? { analysisDocUrl: existing.summary.analysisDocUrl } : {}),
+            ...(rebuilt.summary.repo ? {} : existing.summary.repo ? { repo: existing.summary.repo } : {}),
+            ...(rebuilt.summary.sourceRef ? {} : existing.summary.sourceRef ? { sourceRef: existing.summary.sourceRef } : {}),
+            ...(rebuilt.summary.sourceUrl ? {} : existing.summary.sourceUrl ? { sourceUrl: existing.summary.sourceUrl } : {}),
+            ...(rebuilt.summary.qAssignee ? {} : existing.summary.qAssignee ? { qAssignee: existing.summary.qAssignee } : {})
+        },
+        ...(effectivePublication ? { publication: effectivePublication } : {})
+    };
+}
+function buildDeliveryAttemptSummary(attempts) {
+    const grouped = new Map();
+    for (const attempt of attempts) {
+        const current = grouped.get(attempt.channel) ?? [];
+        current.push(attempt);
+        grouped.set(attempt.channel, current);
+    }
+    const channels = Array.from(grouped.entries()).map(([channel, channelAttempts]) => {
+        const latest = channelAttempts.at(-1);
+        const failedAttempts = channelAttempts.filter((attempt) => attempt.status === "failed").length;
+        const dispatchedAttempts = channelAttempts.filter((attempt) => attempt.status === "dispatched").length;
+        const skippedAttempts = channelAttempts.filter((attempt) => attempt.status === "skipped").length;
+        const firstFailedIndex = channelAttempts.findIndex((attempt) => attempt.status === "failed");
+        const recoveredAfterFailure = firstFailedIndex >= 0 && channelAttempts.slice(firstFailedIndex + 1).some((attempt) => attempt.status === "dispatched");
+        return {
+            channel,
+            latestStatus: latest.status,
+            latestSummary: latest.summary,
+            latestCreatedAt: latest.createdAt,
+            ...(latest.deliveredAt ? { deliveredAt: latest.deliveredAt } : {}),
+            ...(latest.error ? { error: latest.error } : {}),
+            totalAttempts: channelAttempts.length,
+            failedAttempts,
+            dispatchedAttempts,
+            skippedAttempts,
+            backgroundRecovered: recoveredAfterFailure
+        };
+    });
+    return { channels };
+}
+const TASK_EVENT_EXPLANATIONS = {
+    "execution.started": "任务已进入 Codex 执行阶段，正在等待首个运行信号。",
+    "stream.turn.started": "Codex turn 已启动，runner 已收到流式起始事件。",
+    "turn.started": "Codex turn 已启动，任务进入稳定执行态。",
+    "stream.item.completed": "Codex 流式返回了一个完成项，说明 provider 仍在持续输出。",
+    "command_execution": "Agent 完成了一次命令执行。",
+    "file_change": "Agent 产生了文件变更。",
+    "agent_message": "Agent 产出了最终消息或阶段性结论。",
+    "runtime.stall_warning": "任务已长时间没有新事件，runtime 将其标记为疑似卡住。",
+    "runtime.timeout.startup": "任务在启动阶段迟迟没有首个有效进展，触发 startup timeout。",
+    "runtime.timeout.idle": "任务长时间没有任何新事件，触发 idle timeout。",
+    "runtime.timeout.hard": "任务总执行时长超过硬上限，触发 hard timeout。",
+    "execution.completed": "任务执行已结束并完成收口。",
+    "execution.failed": "任务执行已失败并完成收口。",
+    "execution.canceled": "任务执行已取消并完成收口。",
+    "task.needs_human": "任务需要人工补充信息或接手处理。",
+    "task.delivery_bundle.warning": "交付产物存在需要关注的告警，通常表示结果文档缺少关键标准字段。",
+};
+const DOCTOR_IMPORTANT_EVENT_TYPES = [
+    "runtime.started",
+    "runtime.stopped",
+    "runtime.health",
+    "runtime.recovery.requeued",
+    "event.received",
+    "triage.accepted",
+    "triage.rejected",
+    "triage.failed",
+    "task.received",
+    "task.dispatched",
+    "task.execution.started",
+    "task.completed",
+    "task.failed",
+    "task.canceled",
+    "task.timed_out",
+    "task.fallback",
+    "task.needs_human",
+    "task.retry_enqueued",
+    "task.cancel_requested",
+    "task.delivery_bundle.warning",
+    "execution.failed",
+    "execution.canceled",
+    "execution.completed",
+    "optimus.runner.turn_completed",
+    "optimus.runner.turn_failed",
+    "optimus.runner.result_parsed",
+];
+function parseArgs(argv) {
+    const parsed = {};
+    for (let index = 0; index < argv.length; index += 1) {
+        const token = argv[index];
+        if (!token) {
+            continue;
+        }
+        if (!token.startsWith("--")) {
+            continue;
+        }
+        const key = token.slice(2);
+        const value = argv[index + 1];
+        if (!value || value.startsWith("--")) {
+            parsed[key] = "true";
+            continue;
+        }
+        parsed[key] = value;
+        index += 1;
+    }
+    return parsed;
+}
+async function main() {
+    const argv = process.argv.slice(2);
+    const [firstArg, ...rest] = argv;
+    const helpCommands = new Set(["help", "-h", "--help"]);
+    const versionCommands = new Set(["version", "-v", "--version"]);
+    const command = !firstArg
+        ? "help"
+        : helpCommands.has(firstArg)
+            ? "help"
+            : versionCommands.has(firstArg)
+                ? "version"
+                : firstArg;
+    const commandArgs = rest;
+    if (command === "help") {
+        console.log(renderCliHelp());
+        return;
+    }
+    if (command === "version") {
+        console.log(await readPackageVersion());
+        return;
+    }
+    if (command === "upgrade") {
+        const args = parseArgs(commandArgs);
+        const currentVersion = await readPackageVersion();
+        const config = await loadConfig().catch(() => buildDefaultConfig());
+        if (args.check === "true") {
+            const result = await checkForSelfUpdate({
+                command: "start",
+                config,
+                currentVersion,
+                packageName: PACKAGE_NAME,
+                packageRoot: CLI_ROOT_DIR,
+                force: true
+            });
+            console.log(JSON.stringify({
+                currentVersion: result.currentVersion,
+                latestVersion: result.latestVersion ?? null,
+                updateAvailable: result.updateAvailable,
+                installSource: result.installSource,
+                checked: result.checked,
+                reason: result.reason ?? null
+            }, null, 2));
+            process.exitCode = result.reason === "check_failed" ? 1 : 0;
+            return;
+        }
+        const result = await installSelfUpdate({
+            currentVersion,
+            packageName: PACKAGE_NAME,
+            packageRoot: CLI_ROOT_DIR,
+            force: args.force === "true"
+        });
+        if (result.reason === "already_latest") {
+            console.log(`Optimus is already up to date (${currentVersion}).`);
+            return;
+        }
+        if (!result.success) {
+            console.error(result.state.lastError ?? "Optimus upgrade failed.");
+            process.exitCode = 1;
+            return;
+        }
+        console.log(`Optimus upgraded successfully: ${currentVersion} -> ${result.latestVersion ?? currentVersion}`);
+        return;
+    }
+    if (command === "setup") {
+        const args = parseArgs(commandArgs);
+        const result = await runSetup(args);
+        if (args.json === "true") {
+            console.log(JSON.stringify(result, null, 2));
+        }
+        else {
+            console.log(renderSetupResult(result));
+        }
+        process.exitCode = result.doctorQuick.summary === "blocked" ? 1 : 0;
+        return;
+    }
+    const parsedCommandArgs = parseArgs(commandArgs);
+    if (command === "doctor" && parsedCommandArgs.quick === "true") {
+        const result = await runQuickDoctor();
+        if (parsedCommandArgs.json === "true") {
+            console.log(JSON.stringify(result, null, 2));
+        }
+        else {
+            console.log(renderQuickDoctorReport(result));
+        }
+        process.exitCode = result.summary === "blocked" ? 1 : 0;
+        return;
+    }
+    let config;
+    try {
+        config = await loadConfig();
+    }
+    catch (error) {
+        if (error?.code === "ENOENT") {
+            console.error(`Config file not found at ${resolveDefaultConfigPath()}. Run \`optimus setup\` first.`);
+            process.exitCode = 1;
+            return;
+        }
+        throw error;
+    }
+    const store = new SQLiteTaskStore(config.storage.rootDir);
+    const codexRunner = new CodexRunner(config);
+    const skillSyncService = new SkillSyncService(config);
+    const logger = new OptimusLogger(config);
+    const eventStore = new SQLiteEventStore(config.storage.rootDir);
+    const taskOrchestrator = new TaskOrchestrator(store, codexRunner, config);
+    const runtime = new OptimusRuntime(store, taskOrchestrator, config);
+    const currentVersion = await readPackageVersion();
+    if (command === "start" || command === "submit") {
+        const selfUpdateOutcome = await maybeHandleStartupSelfUpdate({
+            command,
+            config,
+            logger,
+            currentVersion
+        });
+        if (selfUpdateOutcome.handled) {
+            process.exitCode = selfUpdateOutcome.exitCode ?? 0;
+            return;
+        }
+    }
+    if (command === "start") {
+        let shuttingDown = false;
+        const shutdown = () => {
+            if (shuttingDown) {
+                return;
+            }
+            shuttingDown = true;
+            runtime.stop();
+        };
+        process.on("SIGINT", shutdown);
+        process.on("SIGTERM", shutdown);
+        try {
+            await runtime.start();
+        }
+        finally {
+            process.off("SIGINT", shutdown);
+            process.off("SIGTERM", shutdown);
+            shutdown();
+        }
+        return;
+    }
+    if (command === "submit") {
+        const args = parseArgs(commandArgs);
+        const title = args.title?.trim();
+        const description = (args.desc ?? args.description)?.trim();
+        if (!title || !description) {
+            console.error("submit requires both --title and --description");
+            process.exitCode = 1;
+            return;
+        }
+        await store.init();
+        const repositorySelection = await resolveSubmissionRepositorySelector(args, store, config);
+        if (!repositorySelection.ok) {
+            console.error(repositorySelection.reason);
+            process.exitCode = 1;
+            return;
+        }
+        const event = createManualProblemEvent({
+            ...args,
+            ...(repositorySelection.repoSelector ? { repo: repositorySelection.repoSelector } : {}),
+            ...(args["allow-duplicate"] === "true" ? { "allow-duplicate": "true" } : {})
+        });
+        const inboxPath = await runtime.writeManualSubmission(event);
+        console.log(`[optimus] wrote submission ${inboxPath}`);
+        return;
+    }
+    if (command === "retry-task") {
+        const args = parseArgs(commandArgs);
+        const taskId = args["task-id"];
+        if (!taskId) {
+            console.error("Missing required --task-id for retry-task");
+            process.exitCode = 1;
+            return;
+        }
+        const inboxPath = await runtime.writeManualSubmission({
+            type: "task.retry_requested",
+            content: createManualEventContent({
+                title: `Retry ${taskId}`,
+                description: args.reason ?? "Manual retry requested from CLI.",
+                sourceRef: taskId
+            })
+        });
+        console.log(`[optimus] wrote retry request ${inboxPath}`);
+        return;
+    }
+    if (command === "notify-test") {
+        const args = parseArgs(commandArgs);
+        const title = args.title?.trim() || "Optimus Feishu webhook smoke test";
+        const taskId = args["task-id"]?.trim() || "task-feishu-smoke";
+        const taskType = args["task-type"]?.trim() || "bugfix";
+        const outcome = args.outcome?.trim() || "analysis_only";
+        const repo = args.repo?.trim() || "optimus";
+        const decision = args.decision?.trim() || "Manual webhook smoke test.";
+        const validation = args.validation?.trim() || "Triggered from local CLI.";
+        const nextAction = args["next-action"]?.trim() || "If this arrives, webhook delivery is working.";
+        const bundle = {
+            taskId,
+            runId: "run-feishu-smoke",
+            taskType,
+            outcome: outcome,
+            createdAt: new Date().toISOString(),
+            summary: {
+                title,
+                repo,
+                decision,
+                validation,
+                nextAction
+            },
+            artifacts: {
+                extras: []
+            }
+        };
+        const reviewUrls = args["review-url"]
+            ? args["review-url"].split(",").map((item) => item.trim()).filter(Boolean)
+            : [];
+        const changeIds = args["change-id"]
+            ? args["change-id"].split(",").map((item) => item.trim()).filter(Boolean)
+            : [];
+        const publicationAttempts = args["review-url"] || args["change-id"]
+            ? [{
+                    taskId,
+                    runId: "run-feishu-smoke",
+                    mode: "review_submit",
+                    status: "submitted",
+                    summary: args["review-summary"]?.trim() || "Review submission completed for 1/1 target(s).",
+                    createdAt: new Date().toISOString(),
+                    ...(reviewUrls.length > 0 ? { reviewUrl: reviewUrls[0], reviewUrls } : {}),
+                    ...(changeIds.length > 0 ? { changeId: changeIds[0], changeIds } : {})
+                }]
+            : [];
+        const reviewAwareNotifier = new FeishuNotifier({ config, publicationAttempts, format: config.delivery.feishu.format });
+        const message = reviewAwareNotifier.previewMessage(bundle);
+        const envStatus = buildFeishuEnvStatus();
+        if (args["print-env-status"] === "true") {
+            console.log(JSON.stringify({ envStatus }, null, 2));
+            process.exitCode = envStatus.webhook || envStatus.webhooks ? 0 : 1;
+            return;
+        }
+        if (args["print-message"] === "true") {
+            console.log(message);
+            process.exitCode = 0;
+            return;
+        }
+        const attempts = await reviewAwareNotifier.dispatch(bundle);
+        console.log(JSON.stringify({ envStatus, message, attempts }, null, 2));
+        process.exitCode = attempts.every((attempt) => attempt.status === "dispatched") ? 0 : 1;
+        return;
+    }
+    if (command === "delivery-retry") {
+        const args = parseArgs(commandArgs);
+        await store.init();
+        const taskId = args["task-id"]?.trim();
+        if (!taskId) {
+            console.error("Missing required --task-id for delivery-retry");
+            process.exitCode = 1;
+            return;
+        }
+        const channel = args.channel?.trim() || "feishu";
+        if (channel !== "feishu") {
+            console.error(`Unsupported delivery channel for retry: ${channel}`);
+            process.exitCode = 1;
+            return;
+        }
+        const bundle = await store.getLatestTaskDeliveryBundle(taskId);
+        if (!bundle) {
+            console.error(`Delivery bundle not found for task: ${taskId}`);
+            process.exitCode = 1;
+            return;
+        }
+        const publicationAttempts = await store.listTaskPublicationAttempts(taskId);
+        const notifier = new FeishuNotifier({ config, publicationAttempts, format: config.delivery.feishu.format });
+        const message = notifier.previewMessage(bundle);
+        const envStatus = buildFeishuEnvStatus();
+        if (args["print-env-status"] === "true") {
+            console.log(JSON.stringify({ taskId, channel, envStatus }, null, 2));
+            process.exitCode = envStatus.webhook || envStatus.webhooks ? 0 : 1;
+            return;
+        }
+        if (args["print-message"] === "true") {
+            console.log(message);
+            process.exitCode = 0;
+            return;
+        }
+        const attempts = await notifier.dispatch(bundle);
+        await store.appendTaskDeliveryAttempts(attempts);
+        console.log(JSON.stringify({ taskId, channel, envStatus, message, attempts }, null, 2));
+        process.exitCode = attempts.every((attempt) => attempt.status === "dispatched") ? 0 : 1;
+        return;
+    }
+    if (command === "postrun-retry") {
+        const args = parseArgs(commandArgs);
+        await store.init();
+        const taskId = args["task-id"]?.trim();
+        if (!taskId) {
+            console.error("Missing required --task-id for postrun-retry");
+            process.exitCode = 1;
+            return;
+        }
+        const task = await store.getTask(taskId);
+        if (!task) {
+            console.error(`Task not found: ${taskId}`);
+            process.exitCode = 1;
+            return;
+        }
+        const taskPackage = await store.getTaskPackage(task.taskPackageId);
+        if (!taskPackage) {
+            console.error(`Task package not found for task: ${taskId}`);
+            process.exitCode = 1;
+            return;
+        }
+        const artifacts = await store.listTaskArtifacts(taskId);
+        if (artifacts.length === 0) {
+            console.error(`No persisted artifacts found for task: ${taskId}`);
+            process.exitCode = 1;
+            return;
+        }
+        const existingBundle = await store.getLatestTaskDeliveryBundle(taskId);
+        const latestRun = (await store.listTaskRuns()).filter((run) => run.taskId === taskId).at(-1) ?? null;
+        const replayContext = await buildReplayExecutionContext({
+            config,
+            taskType: task.taskType,
+            taskRepo: taskPackage.repo,
+            latestRun,
+            artifacts,
+            deliveryBundle: existingBundle
+        });
+        const deliveryService = new TaskDeliveryService();
+        const analysisDocService = new FeishuAnalysisDocService({ refStore: store });
+        const publicationService = new TaskPublicationService(logger);
+        const deliveryDispatcher = new TaskDeliveryDispatcher(config);
+        let deliveryBundle = mergeReplayBundle(await deliveryService.buildBundle({
+            task,
+            taskPackage: {
+                title: taskPackage.title,
+                ...(taskPackage.sourceRef ? { sourceRef: taskPackage.sourceRef } : {}),
+                ...(taskPackage.input.metadata ? { metadata: taskPackage.input.metadata } : {})
+            },
+            ...(replayContext ? { context: replayContext } : {}),
+            ...(latestRun ? { latestRun } : {}),
+            artifacts
+        }), existingBundle);
+        let analysisDoc = {
+            status: "skipped",
+            reason: "feishu_delivery_disabled"
+        };
+        if (config.delivery.enabled && config.delivery.channels.includes("feishu")) {
+            const published = await analysisDocService.publishIfNeeded(deliveryBundle);
+            deliveryBundle = published.bundle;
+            analysisDoc = {
+                status: published.status,
+                ...(published.reason ? { reason: published.reason } : {}),
+                ...(published.url ? { url: published.url } : {})
+            };
+        }
+        await store.appendTaskDeliveryBundle(deliveryBundle);
+        const replayPublication = args["replay-publication"] === "true";
+        let publicationAttempts = await store.listTaskPublicationAttempts(taskId);
+        let publicationArtifacts = [];
+        if (replayPublication) {
+            const publicationResult = await publicationService.publish({
+                bundle: deliveryBundle,
+                ...(replayContext ? { context: replayContext } : {}),
+                dryRun: config.publication.dryRun,
+                reviewMode: config.publication.reviewMode
+            });
+            publicationAttempts = publicationResult.attempts;
+            publicationArtifacts = publicationResult.artifacts;
+            if (publicationResult.artifacts.length > 0) {
+                await store.appendArtifacts(taskId, publicationResult.artifacts);
+            }
+            await store.appendTaskPublicationAttempts(publicationResult.attempts);
+        }
+        const deliveryDispatch = await deliveryDispatcher.dispatch({
+            bundle: deliveryBundle,
+            ...(publicationAttempts.length > 0 ? { publicationAttempts } : {})
+        });
+        await store.appendTaskDeliveryAttempts(deliveryDispatch.attempts);
+        const publicationFailed = replayPublication && publicationAttempts.some((attempt) => attempt.status === "failed");
+        const deliveryFailed = deliveryDispatch.attempts.some((attempt) => attempt.status === "failed");
+        console.log(JSON.stringify({
+            taskId,
+            replayedFromArtifacts: true,
+            replayPublication,
+            publicationDryRun: replayPublication ? config.publication.dryRun : undefined,
+            bundle: deliveryBundle,
+            analysisDoc,
+            publication: {
+                attempts: publicationAttempts,
+                artifacts: publicationArtifacts
+            },
+            delivery: {
+                attempts: deliveryDispatch.attempts
+            }
+        }, null, 2));
+        process.exitCode = publicationFailed || deliveryFailed ? 1 : 0;
+        return;
+    }
+    if (command === "cancel-task") {
+        const args = parseArgs(commandArgs);
+        const taskId = args["task-id"];
+        if (!taskId) {
+            console.error("Missing required --task-id for cancel-task");
+            process.exitCode = 1;
+            return;
+        }
+        const content = createManualEventContent({
+            title: `Cancel ${taskId}`,
+            description: args.reason ?? "Manual cancel requested from CLI.",
+            sourceRef: taskId
+        });
+        if (args["keep-artifacts"] === "true" || args.force === "true") {
+            content.metadata = {
+                ...(content.metadata ?? {}),
+                ...(args["keep-artifacts"] === "true" ? { keepArtifacts: true } : {}),
+                ...(args.force === "true" ? { forceCancel: true } : {})
+            };
+        }
+        const inboxPath = await runtime.writeManualSubmission({
+            type: "task.cancel_requested",
+            content
+        });
+        console.log(`[optimus] wrote cancel request ${inboxPath}`);
+        return;
+    }
+    if (command === "intake-run") {
+        const args = parseArgs(commandArgs);
+        const pollerId = args["poller-id"]?.trim();
+        if (!pollerId) {
+            console.error("Missing required --poller-id for intake-run");
+            process.exitCode = 1;
+            return;
+        }
+        await eventStore.init();
+        await runtime.runPollerOnce(pollerId);
+        const state = (await eventStore.listPollerStates()).find((candidate) => candidate.pollerId === pollerId) ?? null;
+        console.log(JSON.stringify({ pollerId, state }, null, 2));
+        return;
+    }
+    if (command === "intake-disable") {
+        const args = parseArgs(commandArgs);
+        const pollerId = args["poller-id"]?.trim();
+        if (!pollerId) {
+            console.error("Missing required --poller-id for intake-disable");
+            process.exitCode = 1;
+            return;
+        }
+        await eventStore.init();
+        await eventStore.updatePollerEnabled(pollerId, false);
+        const state = (await eventStore.listPollerStates()).find((candidate) => candidate.pollerId === pollerId) ?? null;
+        console.log(JSON.stringify({ pollerId, disabled: true, state }, null, 2));
+        return;
+    }
+    if (command === "intake-enable") {
+        const args = parseArgs(commandArgs);
+        const pollerId = args["poller-id"]?.trim();
+        if (!pollerId) {
+            console.error("Missing required --poller-id for intake-enable");
+            process.exitCode = 1;
+            return;
+        }
+        await eventStore.init();
+        await eventStore.updatePollerEnabled(pollerId, true);
+        const state = (await eventStore.listPollerStates()).find((candidate) => candidate.pollerId === pollerId) ?? null;
+        console.log(JSON.stringify({ pollerId, enabled: true, state }, null, 2));
+        return;
+    }
+    if (command === "intake-reset-checkpoint") {
+        const args = parseArgs(commandArgs);
+        const pollerId = args["poller-id"]?.trim();
+        if (!pollerId) {
+            console.error("Missing required --poller-id for intake-reset-checkpoint");
+            process.exitCode = 1;
+            return;
+        }
+        await eventStore.init();
+        await eventStore.resetPollerCheckpoint(pollerId);
+        const state = (await eventStore.listPollerStates()).find((candidate) => candidate.pollerId === pollerId) ?? null;
+        console.log(JSON.stringify({ pollerId, checkpointReset: true, state }, null, 2));
+        return;
+    }
+    if (command === "repo") {
+        const [repoSubcommand = "list", ...repoRest] = commandArgs;
+        const args = parseArgs(repoRest);
+        await store.init();
+        if (repoSubcommand === "add") {
+            const repoPathArg = repoRest.find((token) => !token.startsWith("--")) ?? args.path;
+            const repoPath = repoPathArg?.trim();
+            if (!repoPath) {
+                console.error("repo add requires a repository path");
+                process.exitCode = 1;
+                return;
+            }
+            const normalizedPath = resolve(repoPath);
+            const validation = await inspectRepositoryRoot(normalizedPath);
+            if (!validation.ok) {
+                console.error(JSON.stringify({ ok: false, path: normalizedPath, reason: validation.reason }, null, 2));
+                process.exitCode = 1;
+                return;
+            }
+            const requestedMode = args.mode?.trim();
+            if (requestedMode && requestedMode !== "copy" && requestedMode !== "inplace") {
+                console.error("repo add --mode must be either copy or inplace");
+                process.exitCode = 1;
+                return;
+            }
+            const repositoryInput = {
+                path: normalizedPath
+            };
+            if (args.alias?.trim()) {
+                repositoryInput.alias = args.alias.trim();
+            }
+            if (requestedMode === "copy" || requestedMode === "inplace") {
+                repositoryInput.executionMode = requestedMode;
+            }
+            const saved = await store.addRepositoryRoot(repositoryInput);
+            console.log(JSON.stringify({ ok: true, repository: saved }, null, 2));
+            return;
+        }
+        if (repoSubcommand === "remove") {
+            const repoTarget = (repoRest.find((token) => !token.startsWith("--")) ?? args.path ?? args.alias)?.trim();
+            if (!repoTarget) {
+                console.error("repo remove requires a repository path or alias");
+                process.exitCode = 1;
+                return;
+            }
+            const removed = await store.removeRepositoryRoot(repoTarget);
+            if (!removed) {
+                console.error(`Repository root not found: ${repoTarget}`);
+                process.exitCode = 1;
+                return;
+            }
+            console.log(JSON.stringify({ ok: true, removed }, null, 2));
+            return;
+        }
+        if (repoSubcommand === "update") {
+            const repoTarget = (repoRest.find((token) => !token.startsWith("--")) ?? args.path ?? args.alias)?.trim();
+            if (!repoTarget) {
+                console.error("repo update requires a repository path or alias");
+                process.exitCode = 1;
+                return;
+            }
+            const requestedMode = args.mode?.trim();
+            if (requestedMode && requestedMode !== "copy" && requestedMode !== "inplace") {
+                console.error("repo update --mode must be either copy or inplace");
+                process.exitCode = 1;
+                return;
+            }
+            const requestedAlias = args.alias !== undefined ? args.alias.trim() : undefined;
+            if (requestedAlias === undefined && requestedMode === undefined) {
+                console.error("repo update requires at least one of --mode or --alias");
+                process.exitCode = 1;
+                return;
+            }
+            const updated = await store.updateRepositoryRoot(repoTarget, {
+                ...(requestedAlias !== undefined ? { alias: requestedAlias } : {}),
+                ...(requestedMode === "copy" || requestedMode === "inplace" ? { executionMode: requestedMode } : {})
+            });
+            if (!updated) {
+                console.error(`Repository root not found: ${repoTarget}`);
+                process.exitCode = 1;
+                return;
+            }
+            console.log(JSON.stringify({ ok: true, repository: updated }, null, 2));
+            return;
+        }
+        if (repoSubcommand === "list") {
+            const repositories = await store.listRepositoryRoots();
+            console.log(JSON.stringify({ repositories }, null, 2));
+            return;
+        }
+        if (repoSubcommand === "doctor") {
+            const repositories = await store.listRepositoryRoots();
+            const inspected = await Promise.all(repositories.map(async (repository) => {
+                const inspection = await inspectRepositoryRoot(repository.path);
+                const executionPlan = describeRepositoryExecutionPlan(repository, inspection);
+                return {
+                    ...repository,
+                    inspection,
+                    executionPlan,
+                    resolvedDefaultMode: executionPlan.resolvedDefaultMode
+                };
+            }));
+            console.log(JSON.stringify({ repositories: inspected }, null, 2));
+            process.exitCode = inspected.every((repository) => repository.inspection.ok) ? 0 : 1;
+            return;
+        }
+        console.error(`Unknown repo command: ${repoSubcommand}`);
+        process.exitCode = 1;
+        return;
+    }
+    if (command === "list") {
+        await store.init();
+        const tasks = await store.listTasks();
+        console.log(JSON.stringify(tasks, null, 2));
+        return;
+    }
+    if (command === "intake-status") {
+        await eventStore.init();
+        const pollerStates = await eventStore.listPollerStates();
+        const sourceRecords = await eventStore.listSourceRecords();
+        console.log(JSON.stringify({
+            configuredSources: (config.intake.pollingSources ?? []).map((source) => ({
+                id: source.id,
+                type: source.type,
+                enabled: source.enabled,
+                eventType: source.eventType ?? "problem.discovered",
+                pollingIntervalMs: source.intervalMs ?? config.intake.pollingIntervalMs
+            })),
+            pollerStates,
+            sourceRecordCount: sourceRecords.length,
+            recentSourceRecords: sourceRecords.slice(-20)
+        }, null, 2));
+        return;
+    }
+    if (command === "task-status") {
+        const args = parseArgs(commandArgs);
+        await store.init();
+        const tasks = await store.listTasks();
+        const runs = await store.listTaskRuns();
+        const requestedTaskId = args["task-id"]?.trim();
+        const requestedStatus = args.status?.trim();
+        const activeOnly = args["active-only"] === "true";
+        const limit = Number.parseInt(args.limit ?? "20", 10);
+        const normalizedLimit = Number.isFinite(limit) && limit > 0 ? limit : 20;
+        const taskProgressView = tasks
+            .filter((task) => !requestedTaskId || task.taskId === requestedTaskId)
+            .filter((task) => !requestedStatus || task.status === requestedStatus)
+            .filter((task) => !activeOnly || Boolean(task.activeRunId))
+            .slice(-normalizedLimit)
+            .map((task) => {
+            const taskRuns = runs.filter((run) => run.taskId === task.taskId);
+            const activeRun = runs.find((run) => run.runId === task.activeRunId) ?? taskRuns.slice(-1)[0];
+            const timing = activeRun ? buildRunTimingSnapshot(activeRun, config) : { elapsedMs: 0, idleMs: 0, timeoutKind: null };
+            return {
+                taskId: task.taskId,
+                taskPackageId: task.taskPackageId,
+                title: task.title,
+                status: task.status,
+                phase: activeRun?.status ?? null,
+                health: activeRun?.health ?? null,
+                progressMessage: activeRun?.lastEventType ?? null,
+                progressExplanation: activeRun?.lastEventType ? explainTaskEvent(activeRun.lastEventType) : null,
+                failureCategory: activeRun?.failureCategory ?? null,
+                failureSummary: activeRun?.summary ?? null,
+                lastAgentMessagePreview: activeRun?.lastAgentMessagePreview ?? null,
+                sdkThreadId: activeRun?.sdkThreadId ?? null,
+                workspaceSkillMountDir: activeRun?.workspaceSkillMountDir ?? null,
+                mountedSkills: (activeRun?.mountedSkills ?? []).map((skill) => ({
+                    id: skill.id,
+                    level: skill.level,
+                    version: skill.version,
+                    taskTypes: skill.taskTypes,
+                    targetDir: skill.targetDir
+                })),
+                cancelRequestedAt: activeRun?.cancelRequestedAt ?? null,
+                lastUpdatedAt: task.updatedAt,
+                elapsedMs: activeRun ? timing.elapsedMs : null,
+                idleMs: activeRun ? timing.idleMs : null,
+                timeoutKind: activeRun ? timing.timeoutKind : null,
+                nextAction: buildTaskNextAction(task.status, activeRun?.failureCategory),
+                runs: taskRuns.slice(-3).map((run) => {
+                    const timing = buildRunTimingSnapshot(run, config);
+                    return {
+                        runId: run.runId,
+                        status: run.status,
+                        taskStatus: run.taskStatus ?? null,
+                        health: run.health ?? null,
+                        failureCategory: run.failureCategory ?? null,
+                        summary: run.summary ?? null,
+                        startedAt: run.startedAt,
+                        endedAt: run.endedAt ?? null,
+                        lastEventType: run.lastEventType ?? null,
+                        lastEventExplanation: run.lastEventType ? explainTaskEvent(run.lastEventType) : null,
+                        lastAgentMessagePreview: run.lastAgentMessagePreview ?? null,
+                        workspaceSkillMountDir: run.workspaceSkillMountDir ?? null,
+                        mountedSkills: (run.mountedSkills ?? []).map((skill) => ({
+                            id: skill.id,
+                            level: skill.level,
+                            version: skill.version,
+                            taskTypes: skill.taskTypes,
+                            targetDir: skill.targetDir
+                        })),
+                        progressCounter: run.progressCounter ?? 0,
+                        commandCount: run.commandCount ?? 0,
+                        fileChangeCount: run.fileChangeCount ?? 0,
+                        cancelRequestedAt: run.cancelRequestedAt ?? null,
+                        elapsedMs: timing.elapsedMs,
+                        idleMs: timing.idleMs,
+                        timeoutKind: timing.timeoutKind
+                    };
+                })
+            };
+        });
+        console.log(JSON.stringify({
+            filters: {
+                taskId: requestedTaskId ?? null,
+                status: requestedStatus ?? null,
+                activeOnly,
+                limit: normalizedLimit
+            },
+            tasks: taskProgressView
+        }, null, 2));
+        return;
+    }
+    if (command === "task-result") {
+        const args = parseArgs(commandArgs);
+        await store.init();
+        const requestedTaskId = args["task-id"]?.trim();
+        if (!requestedTaskId) {
+            console.error("Missing required --task-id for task-result");
+            process.exitCode = 1;
+            return;
+        }
+        const task = await store.getTask(requestedTaskId);
+        if (!task) {
+            console.error(`Task not found: ${requestedTaskId}`);
+            process.exitCode = 1;
+            return;
+        }
+        const taskPackage = await store.getTaskPackage(task.taskPackageId);
+        const runs = (await store.listTaskRuns()).filter((run) => run.taskId === requestedTaskId);
+        const latestRun = runs.at(-1) ?? null;
+        const results = await store.listTaskArtifacts(requestedTaskId);
+        const deliveryBundle = await store.getLatestTaskDeliveryBundle(requestedTaskId);
+        const deliveryAttempts = await store.listTaskDeliveryAttempts(requestedTaskId);
+        const publicationAttempts = await store.listTaskPublicationAttempts(requestedTaskId);
+        if (args.format === "text" || args.print === "true") {
+            console.log(renderTaskResultReport({
+                task,
+                taskPackage,
+                latestRun,
+                resultFiles: results,
+                deliveryBundle,
+                deliveryAttempts,
+                publicationAttempts
+            }));
+            return;
+        }
+        const diagnosis = buildTaskDeliveryDiagnosis({
+            task,
+            latestRun,
+            deliveryBundle,
+            deliveryAttempts,
+            publicationAttempts
+        });
+        console.log(JSON.stringify({
+            task,
+            taskPackage,
+            latestRun,
+            resultFiles: results,
+            deliveryBundle,
+            deliveryAttempts,
+            deliverySummary: buildDeliveryAttemptSummary(deliveryAttempts),
+            diagnosis,
+            publicationAttempts,
+            publicationReview: buildPublicationReviewSummary(publicationAttempts)
+        }, null, 2));
+        return;
+    }
+    if (command === "delivery-status") {
+        const args = parseArgs(commandArgs);
+        await store.init();
+        const requestedTaskId = args["task-id"]?.trim();
+        if (!requestedTaskId) {
+            console.error("Missing required --task-id for delivery-status");
+            process.exitCode = 1;
+            return;
+        }
+        const task = await store.getTask(requestedTaskId);
+        if (!task) {
+            console.error(`Task not found: ${requestedTaskId}`);
+            process.exitCode = 1;
+            return;
+        }
+        const taskPackage = await store.getTaskPackage(task.taskPackageId);
+        const deliveryBundle = await store.getLatestTaskDeliveryBundle(requestedTaskId);
+        const deliveryAttempts = await store.listTaskDeliveryAttempts(requestedTaskId);
+        const publicationAttempts = await store.listTaskPublicationAttempts(requestedTaskId);
+        const runs = (await store.listTaskRuns()).filter((run) => run.taskId === requestedTaskId);
+        const latestRun = runs.at(-1) ?? null;
+        const deliverySummary = buildDeliveryAttemptSummary(deliveryAttempts);
+        const publicationReview = buildPublicationReviewSummary(publicationAttempts);
+        const diagnosis = buildTaskDeliveryDiagnosis({
+            task,
+            latestRun,
+            deliveryBundle,
+            deliveryAttempts,
+            publicationAttempts
+        });
+        if (args.format === "text" || args.print === "true") {
+            console.log(renderDeliveryStatusReport({
+                task,
+                taskPackage,
+                latestRun,
+                deliveryBundle,
+                deliveryAttempts,
+                publicationAttempts
+            }));
+            return;
+        }
+        console.log(JSON.stringify({
+            task,
+            taskPackage,
+            deliveryBundle,
+            deliveryAttempts,
+            deliverySummary,
+            diagnosis,
+            publicationAttempts,
+            publicationReview
+        }, null, 2));
+        return;
+    }
+    if (command === "task-events") {
+        const args = parseArgs(commandArgs);
+        await store.init();
+        const tasks = await store.listTasks();
+        const taskId = args["task-id"]?.trim();
+        const runId = args["run-id"]?.trim();
+        const limit = Number.parseInt(args.limit ?? "50", 10);
+        const normalizedLimit = Number.isFinite(limit) && limit > 0 ? limit : 50;
+        let scopedTaskId = taskId;
+        if (!scopedTaskId && runId) {
+            const runs = await store.listTaskRuns();
+            scopedTaskId = runs.find((candidate) => candidate.runId === runId)?.taskId;
+        }
+        const recentEvents = await store.listRecentTaskEvents(normalizedLimit * 3);
+        const filteredEvents = recentEvents
+            .filter((event) => !scopedTaskId || event.taskId === scopedTaskId)
+            .filter((event) => !runId || event.runId === runId)
+            .slice(0, normalizedLimit)
+            .reverse()
+            .map((event) => ({
+            taskId: event.taskId,
+            runId: event.runId ?? null,
+            type: event.type,
+            detail: event.detail,
+            explanation: explainTaskEvent(event.type),
+            createdAt: event.createdAt,
+            sourceEventId: event.sourceEventId ?? null
+        }));
+        const task = scopedTaskId ? tasks.find((candidate) => candidate.taskId === scopedTaskId) ?? null : null;
+        console.log(JSON.stringify({
+            filters: {
+                taskId: scopedTaskId ?? null,
+                runId: runId ?? null,
+                limit: normalizedLimit
+            },
+            task,
+            events: filteredEvents
+        }, null, 2));
+        return;
+    }
+    if (command === "db-inspect") {
+        const args = parseArgs(commandArgs);
+        await store.init();
+        const tasks = await store.listTasks();
+        const taskPackages = await store.listTaskPackages();
+        const runs = await store.listTaskRuns();
+        const requestedTaskId = args["task-id"]?.trim();
+        const taskMatches = requestedTaskId ? tasks.filter((task) => task.taskId === requestedTaskId) : tasks.slice(-20);
+        const taskIds = new Set(taskMatches.map((task) => task.taskId));
+        const taskPackageIds = new Set(taskMatches.map((task) => task.taskPackageId));
+        const runMatches = runs.filter((run) => taskIds.has(run.taskId)).slice(-50);
+        const taskPackageMatches = taskPackages.filter((taskPackage) => taskPackageIds.has(taskPackage.taskPackageId));
+        console.log(JSON.stringify({
+            databasePath: join(config.storage.rootDir, "optimus.db"),
+            taskCount: tasks.length,
+            taskPackageCount: taskPackages.length,
+            runCount: runs.length,
+            tasks: taskMatches,
+            taskPackages: taskPackageMatches,
+            runs: runMatches,
+            deliveryBundles: requestedTaskId ? [await store.getLatestTaskDeliveryBundle(requestedTaskId)].filter(Boolean) : [],
+            deliveryAttempts: requestedTaskId ? await store.listTaskDeliveryAttempts(requestedTaskId) : [],
+            deliverySummary: requestedTaskId ? buildDeliveryAttemptSummary(await store.listTaskDeliveryAttempts(requestedTaskId)) : { channels: [] },
+            publicationAttempts: requestedTaskId ? await store.listTaskPublicationAttempts(requestedTaskId) : [],
+            publicationReview: requestedTaskId ? buildPublicationReviewSummary(await store.listTaskPublicationAttempts(requestedTaskId)) : { latestReviewSubmit: null }
+        }, null, 2));
+        return;
+    }
+    if (command === "triage-only") {
+        const args = parseArgs(commandArgs);
+        const title = args.title?.trim();
+        const description = (args.desc ?? args.description)?.trim();
+        if (!title || !description) {
+            console.error("triage-only requires both --title and --description");
+            process.exitCode = 1;
+            return;
+        }
+        const triageRunner = new TriageRunner(config);
+        try {
+            await triageRunner.initialize();
+            await logger.writeTriageStatusSnapshot(triageRunner.getStatusSnapshot());
+            const decision = await triageRunner.triage({
+                eventId: `triage-only-${Date.now()}`,
+                type: "task.submitted_manually",
+                content: createManualEventContent(args),
+                createdAt: new Date().toISOString()
+            });
+            console.log(JSON.stringify(decision, null, 2));
+            process.exitCode = decision.decision === "accepted" ? 0 : 2;
+            return;
+        }
+        catch (error) {
+            const failureCategory = error && typeof error === "object" && "failureCategory" in error
+                ? error.failureCategory ?? "unknown"
+                : error instanceof Error
+                    ? classifyCodexFailureCategory(error.message)
+                    : "unknown";
+            await logger.writeTriageStatusSnapshot({
+                ok: false,
+                startedAt: new Date().toISOString(),
+                failureCategory,
+                reason: error instanceof Error ? error.message : "Unknown triage failure"
+            });
+            console.error(JSON.stringify({
+                ok: false,
+                summary: error instanceof Error ? error.message : "Unknown triage failure",
+                failureCategory
+            }, null, 2));
+            process.exitCode = 1;
+            return;
+        }
+    }
+    if (command === "health-check") {
+        const result = await codexRunner.runHealthCheck();
+        await logger.writeHealthCheckSnapshot(result);
+        await logger.info("optimus.health_check", {
+            ok: result.ok,
+            model: result.diagnostics.model,
+            provider: result.diagnostics.provider,
+            failureCategory: result.diagnostics.failureCategory,
+            connectivityChecks: result.diagnostics.connectivityChecks?.map((check) => `${check.name}:${check.ok ? "ok" : "failed"}${check.host ? `@${check.host}` : ""}`),
+            timeoutMs: result.diagnostics.timeoutMs,
+            codexHomeDir: result.diagnostics.codexHomeDir,
+            approvalPolicy: result.diagnostics.approvalPolicy,
+            sandboxMode: result.diagnostics.sandboxMode
+        });
+        console.log(JSON.stringify(result, null, 2));
+        process.exitCode = result.ok ? 0 : 1;
+        return;
+    }
+    if (command === "doctor") {
+        const healthCheck = await logger.readHealthCheckSnapshot();
+        const triageStatus = await logger.readTriageStatusSnapshot();
+        const skillSyncStatus = await logger.readSkillSyncSnapshot();
+        const evolutionStatus = await logger.readEvolutionSnapshot();
+        const repoMemoryStatus = await logger.readRepoMemorySnapshot();
+        const feishuStatus = await buildFeishuDoctorStatus();
+        const preflight = await new CodexPreflight(config).run();
+        const skillSummary = await inspectBuiltinSkills(config, skillSyncService);
+        const repoMemorySummary = await new RepoMemoryService(config).readDoctorSummary();
+        await store.init();
+        const tasks = await store.listTasks();
+        const runs = await store.listTaskRuns();
+        const recentImportantEvents = await store.listRecentTaskEvents(15, [...DOCTOR_IMPORTANT_EVENT_TYPES]);
+        const taskSummary = tasks.reduce((accumulator, task) => {
+            accumulator[task.status] = (accumulator[task.status] ?? 0) + 1;
+            return accumulator;
+        }, {});
+        const activeRuns = runs.filter((run) => !run.endedAt);
+        const registeredRepositories = await store.listRepositoryRoots();
+        const configuredRuntimeRepositories = await inspectConfiguredRuntimeRepositories(config);
+        const repositoryDiagnostics = buildRepositoryDiagnostics(registeredRepositories, configuredRuntimeRepositories);
+        const doctor = {
+            runtimeRootDir: config.storage.rootDir,
+            codexHomeDir: config.codex.homeDir,
+            cliInboxDir: config.intake.cliInboxDir,
+            healthLogDir: join(config.storage.rootDir, "logs"),
+            codexHomeReady: await pathExists(config.codex.homeDir),
+            inboxReady: await pathExists(config.intake.cliInboxDir),
+            taskHarnessRootReady: await pathExists(config.runtime.taskHarnessRootDir),
+            runtimeLogFiles: await safeList(join(config.storage.rootDir, "logs")),
+            registeredRepositories,
+            configuredRuntimeRepositories,
+            repositoryDiagnostics,
+            runtime: {
+                totalTasks: tasks.length,
+                totalRuns: runs.length,
+                activeRuns: activeRuns.length,
+                stalledRuns: activeRuns.filter((run) => run.health === "suspected_stall").length,
+                taskSummary,
+                recentTasks: tasks.slice(-5).map((task) => ({
+                    taskId: task.taskId,
+                    taskPackageId: task.taskPackageId,
+                    sourceEventId: task.sourceEventId ?? null,
+                    status: task.status,
+                    activeRunId: task.activeRunId ?? null,
+                    updatedAt: task.updatedAt
+                })),
+                activeRunDetails: activeRuns.map((run) => {
+                    const timing = buildRunTimingSnapshot(run, config);
+                    return {
+                        runId: run.runId,
+                        taskId: run.taskId,
+                        taskPackageId: run.taskPackageId,
+                        status: run.status,
+                        taskStatus: run.taskStatus,
+                        health: run.health ?? null,
+                        startedAt: run.startedAt,
+                        lastEventAt: run.lastEventAt ?? null,
+                        lastEventType: run.lastEventType ?? null,
+                        progressCounter: run.progressCounter ?? 0,
+                        commandCount: run.commandCount ?? 0,
+                        fileChangeCount: run.fileChangeCount ?? 0,
+                        sdkThreadId: run.sdkThreadId ?? null,
+                        addresses: {
+                            workspaceDir: run.addresses?.workspaceDir ?? null,
+                            visibleRepoDir: run.addresses?.visibleRepoDir ?? null,
+                            configuredExecutionMode: run.addresses?.configuredExecutionMode ?? null,
+                            resolvedExecutionMode: run.addresses?.resolvedExecutionMode ?? null
+                        },
+                        elapsedMs: timing.elapsedMs,
+                        idleMs: timing.idleMs,
+                        timeoutKind: timing.timeoutKind,
+                        failureCategoryLabel: describeFailureCategory(run.failureCategory),
+                        lastEventExplanation: run.lastEventType ? explainTaskEvent(run.lastEventType) : null
+                    };
+                }),
+                recentFailureBreakdown: buildRecentFailureBreakdown(runs),
+                deliveryWarningSummary: buildDeliveryWarningSummary(recentImportantEvents),
+                deliveryHealthSummary: await buildDeliveryHealthSummary(store, tasks, runs),
+                recentImportantEvents: recentImportantEvents.map((event) => ({
+                    taskId: event.taskId,
+                    runId: event.runId ?? null,
+                    type: event.type,
+                    detail: event.detail,
+                    explanation: explainTaskEvent(event.type),
+                    createdAt: event.createdAt,
+                    sourceEventId: event.sourceEventId ?? null
+                })),
+                recentFailureSummary: buildRecentFailureSummary(runs, recentImportantEvents)
+            },
+            triage: {
+                status: triageStatus ?? null
+            },
+            codex: {
+                model: resolveEffectiveCodexModel(config) ?? null,
+                authMode: resolveCodexAuthMode(config),
+                provider: resolveConfiguredCodexProvider(config)
+                    ? {
+                        id: resolveConfiguredCodexProvider(config).providerId,
+                        displayName: resolveConfiguredCodexProvider(config).displayName
+                    }
+                    : resolveConfiguredCodexModelProvider(config) ?? null,
+                apiKeyEnvName: resolvePrimaryCodexApiKeyEnvName(config) ?? null,
+                requiredEnvVars: resolveRequiredCodexEnvVars(config),
+                baseUrl: resolveConfiguredCodexProvider(config)?.baseUrl ?? config.codex.baseUrl ?? null,
+                sandboxMode: config.codex.sandboxMode,
+                networkAccessEnabled: config.runtime.networkAccessEnabled
+            },
+            skills: {
+                ...skillSummary,
+                recentSync: skillSyncStatus ?? null,
+                recentEvolution: evolutionStatus ?? null
+            },
+            repoMemory: {
+                rootDir: config.memory.rootDir,
+                rootReady: await pathExists(config.memory.rootDir),
+                totalCount: repoMemorySummary.length,
+                entries: repoMemorySummary,
+                recentUpdate: repoMemoryStatus ?? null
+            },
+            feishu: feishuStatus,
+            currentPreflight: preflight,
+            recentHealthCheck: healthCheck ?? null,
+            selfUpdate: {
+                currentVersion,
+                config: config.selfUpdate ?? buildDefaultConfig().selfUpdate,
+                cachedState: await readSelfUpdateState() ?? null
+            }
+        };
+        if (parsedCommandArgs.format === "text") {
+            console.log(renderDoctorTextReport(doctor));
+            process.exitCode = 0;
+            return;
+        }
+        console.log(JSON.stringify(doctor, null, 2));
+        process.exitCode = 0;
+        return;
+    }
+    console.error(`Unknown command: ${command}`);
+    process.exitCode = 1;
+}
+async function inspectBuiltinSkills(config, skillSyncService) {
+    const installedSkills = await skillSyncService.readInstalledSkills();
+    const sharedSkills = installedSkills
+        .filter((skill) => skill.level === "shared")
+        .map((skill) => ({ id: skill.id, version: skill.version, sourceKind: "embedded" }))
+        .sort((left, right) => left.id.localeCompare(right.id));
+    const embeddedTaskLevelSkills = installedSkills
+        .filter((skill) => skill.level === "task" && skill.sourceKind === "embedded")
+        .map((skill) => ({ id: skill.id, version: skill.version, taskTypes: skill.taskTypes, sourceKind: "embedded" }))
+        .sort((left, right) => left.id.localeCompare(right.id));
+    const evolutionTaskLevelSkills = installedSkills
+        .filter((skill) => skill.level === "task" && skill.sourceKind === "evolution")
+        .map((skill) => ({ id: skill.id, version: skill.version, taskTypes: skill.taskTypes, sourceKind: "evolution" }))
+        .sort((left, right) => left.id.localeCompare(right.id));
+    return {
+        embeddedRootDir: config.skills.embeddedRootDir,
+        evolutionRootDir: config.skills.evolutionRootDir,
+        storeDir: config.skills.storeDir,
+        embeddedRootReady: await pathExists(config.skills.embeddedRootDir),
+        evolutionRootReady: await pathExists(config.skills.evolutionRootDir),
+        storeReady: await pathExists(config.skills.storeDir),
+        sharedEnabled: config.skills.sharedEnabled,
+        taskLevelEnabled: config.skills.taskLevelEnabled,
+        disabledSkills: config.skills.disabledSkills,
+        installedCount: installedSkills.length,
+        sharedCount: sharedSkills.length,
+        embeddedTaskLevelCount: embeddedTaskLevelSkills.length,
+        evolutionTaskLevelCount: evolutionTaskLevelSkills.length,
+        taskLevelCount: embeddedTaskLevelSkills.length + evolutionTaskLevelSkills.length,
+        sharedSkills,
+        embeddedTaskLevelSkills,
+        evolutionTaskLevelSkills
+    };
+}
+async function resolveSubmissionRepositorySelector(args, store, config) {
+    const candidates = await listCliRepositoryCandidates(store, config);
+    const requestedRepo = args.repo?.trim();
+    if (requestedRepo) {
+        const matched = candidates.find((candidate) => matchesRepositorySelector(candidate, requestedRepo));
+        if (!matched) {
+            return {
+                ok: false,
+                reason: `submit received --repo ${requestedRepo}, but it did not match any registered repository. Run 'optimus repo list' or 'optimus repo add <path> --alias <name>' first.`
+            };
+        }
+        return { ok: true, repoSelector: requestedRepo };
+    }
+    if (candidates.length === 1) {
+        const onlyCandidate = candidates[0];
+        if (!onlyCandidate) {
+            return { ok: false, reason: "Repository discovery failed while selecting the only configured repository." };
+        }
+        return { ok: true, repoSelector: buildPreferredRepositorySelector(onlyCandidate) };
+    }
+    if (candidates.length === 0) {
+        return {
+            ok: false,
+            reason: "submit requires --repo because no executable repository is configured. Register one with 'optimus repo add <path> --alias <name>' or set runtime.repoRoots first."
+        };
+    }
+    return {
+        ok: false,
+        reason: "submit requires --repo because multiple repositories are configured. Choose one from 'optimus repo list'."
+    };
+}
+async function listCliRepositoryCandidates(store, config) {
+    const registered = await store.listRepositoryRoots();
+    const configured = await inspectConfiguredRuntimeRepositories(config);
+    const deduped = new Map();
+    for (const repository of registered) {
+        const inspection = await inspectRepositoryRoot(repository.path);
+        if (!inspection.ok || !repository.enabled) {
+            continue;
+        }
+        deduped.set(resolve(repository.path), {
+            path: resolve(repository.path),
+            ...(repository.alias ? { alias: repository.alias } : {}),
+            source: "registered"
+        });
+    }
+    for (const repository of configured) {
+        if (!repository.inspection.ok) {
+            continue;
+        }
+        deduped.set(resolve(repository.path), {
+            path: resolve(repository.path),
+            ...(repository.alias ? { alias: repository.alias } : {}),
+            source: "configured"
+        });
+    }
+    return [...deduped.values()];
+}
+async function inspectConfiguredRuntimeRepositories(config) {
+    return Promise.all(config.runtime.repoRoots.map(async (repositoryPath) => {
+        const normalizedPath = resolve(repositoryPath);
+        return {
+            path: normalizedPath,
+            alias: basename(normalizedPath),
+            source: "runtime.repoRoots",
+            executionMode: "copy",
+            inspection: await inspectRepositoryRoot(normalizedPath)
+        };
+    }));
+}
+function buildPreferredRepositorySelector(repository) {
+    return repository.alias ?? (basename(repository.path) || repository.path);
+}
+function matchesRepositorySelector(repository, selector) {
+    const normalizedSelector = resolve(selector);
+    if (repository.path === normalizedSelector) {
+        return true;
+    }
+    if (repository.alias === selector) {
+        return true;
+    }
+    return basename(repository.path) === selector;
+}
+function buildRepositoryDiagnostics(registeredRepositories, configuredRuntimeRepositories) {
+    const executablePaths = new Set();
+    for (const repository of registeredRepositories) {
+        if (repository.enabled) {
+            executablePaths.add(resolve(repository.path));
+        }
+    }
+    for (const repository of configuredRuntimeRepositories) {
+        if (repository.inspection.ok) {
+            executablePaths.add(resolve(repository.path));
+        }
+    }
+    if (executablePaths.size === 0) {
+        return {
+            ok: false,
+            totalExecutableRepositories: 0,
+            recommendation: "No executable repository is configured. Register one with 'optimus repo add <path> --alias <name>' or set runtime.repoRoots before submitting bugfix tasks."
+        };
+    }
+    return {
+        ok: true,
+        totalExecutableRepositories: executablePaths.size,
+        recommendation: null
+    };
+}
+function describeRepositoryExecutionPlan(repository, inspection) {
+    const resolvedDefaultMode = repository.executionMode === "inplace"
+        ? "inplace"
+        : inspection.rootIsGit
+            ? "copy"
+            : "inplace";
+    if (inspection.repoManaged) {
+        return {
+            workspaceKind: "repo_managed",
+            resolvedDefaultMode,
+            precheckStrategy: "repo_forall_status",
+            cleanupStrategy: "repo_forall_reset_clean",
+            recommendation: resolvedDefaultMode === "inplace"
+                ? "Runtime will execute in place and use repo forall for precheck and cleanup."
+                : "Runtime will default to copy mode. Switch to --mode inplace only if the repo workspace must stay in place."
+        };
+    }
+    if (inspection.rootIsGit) {
+        return {
+            workspaceKind: "git_root",
+            resolvedDefaultMode,
+            precheckStrategy: resolvedDefaultMode === "copy" ? "none" : "git_status",
+            cleanupStrategy: resolvedDefaultMode === "copy" ? "none" : "git_reset_clean",
+            recommendation: resolvedDefaultMode === "copy"
+                ? "Runtime will create a task-scoped git worktree by default."
+                : "Runtime will execute in place and use git status/reset/clean on the repository."
+        };
+    }
+    return {
+        workspaceKind: "plain_directory",
+        resolvedDefaultMode,
+        precheckStrategy: "git_status",
+        cleanupStrategy: "git_reset_clean",
+        recommendation: "Runtime will execute in place. If nested git repositories exist, each one must be clean and will be reset after the task."
+    };
+}
+async function inspectRepositoryRoot(path) {
+    try {
+        const metadata = await stat(path);
+        if (!metadata.isDirectory()) {
+            return { ok: false, reason: "path_is_not_directory", rootIsGit: false, repoManaged: false };
+        }
+    }
+    catch {
+        return { ok: false, reason: "path_not_found", rootIsGit: false, repoManaged: false };
+    }
+    const rootIsGit = await pathExists(join(path, ".git"));
+    const repoManaged = await pathExists(join(path, ".repo"));
+    if (rootIsGit) {
+        return { ok: true, rootIsGit: true, repoManaged };
+    }
+    return {
+        ok: true,
+        rootIsGit: false,
+        repoManaged,
+        reason: repoManaged ? "repo_workspace_detected" : "git_metadata_not_found"
+    };
+}
+async function safeList(path) {
+    try {
+        return await readdir(path);
+    }
+    catch {
+        return [];
+    }
+}
+function explainTaskEvent(eventType) {
+    return TASK_EVENT_EXPLANATIONS[eventType] ?? (eventType.startsWith("stream.")
+        ? "Codex runner 收到了新的流式事件，说明任务仍在持续推进。"
+        : null);
+}
+function buildRunTimingSnapshot(run, config) {
+    const now = Date.now();
+    const startedAt = Date.parse(run.startedAt);
+    const lastSignalAt = Date.parse(run.lastEventAt ?? run.startedAt);
+    const endedAt = run.endedAt ? Date.parse(run.endedAt) : now;
+    const elapsedMs = Number.isNaN(startedAt) || Number.isNaN(endedAt) ? 0 : Math.max(0, endedAt - startedAt);
+    const idleMs = Number.isNaN(lastSignalAt) ? 0 : Math.max(0, now - lastSignalAt);
+    const waitingForFirstSignal = run.status === "leased" || run.status === "bootstrapping" || run.status === "sdk_starting";
+    const timeoutKind = run.endedAt ? null : resolveTimeoutKind(run, config, waitingForFirstSignal, elapsedMs, idleMs);
+    return { elapsedMs, idleMs, timeoutKind };
+}
+function resolveTimeoutKind(run, config, waitingForFirstSignal, elapsedMs, idleMs) {
+    if (run.status === "timed_out") {
+        if (run.lastEventType === "runtime.timeout.startup") {
+            return "startup_timeout";
+        }
+        if (run.lastEventType === "runtime.timeout.idle") {
+            return "idle_timeout";
+        }
+        if (run.lastEventType === "runtime.timeout.hard") {
+            return "hard_timeout";
+        }
+    }
+    if (run.health === "suspected_stall") {
+        return "stall_timeout";
+    }
+    if (elapsedMs >= config.runtime.runTimeoutMs) {
+        return "hard_timeout";
+    }
+    if (waitingForFirstSignal && elapsedMs >= config.runtime.startupTimeoutMs) {
+        return "startup_timeout";
+    }
+    if (!waitingForFirstSignal && idleMs >= config.runtime.idleTimeoutMs) {
+        return "idle_timeout";
+    }
+    if (!waitingForFirstSignal && idleMs >= config.runtime.stallWarningMs) {
+        return "stall_timeout";
+    }
+    return null;
+}
+function renderTaskResultReport(input) {
+    const lines = [];
+    const task = input.task;
+    const taskPackage = input.taskPackage;
+    const latestRun = input.latestRun;
+    lines.push(`Task ${task.taskId}`);
+    lines.push(`Title: ${task.title}`);
+    lines.push(`Status: ${task.status}`);
+    if (taskPackage) {
+        lines.push(`Task Type: ${taskPackage.taskType}`);
+    }
+    if (latestRun) {
+        lines.push(`Run: ${latestRun.runId}`);
+        lines.push(`Run Status: ${latestRun.status}`);
+        if (latestRun.health) {
+            lines.push(`Health: ${latestRun.health}`);
+        }
+        if (latestRun.failureCategory) {
+            lines.push(`Failure Category: ${latestRun.failureCategory}`);
+        }
+        if (latestRun.startedAt) {
+            lines.push(`Started At: ${latestRun.startedAt}`);
+        }
+        if (latestRun.endedAt) {
+            lines.push(`Ended At: ${latestRun.endedAt}`);
+        }
+    }
+    lines.push("");
+    lines.push("Summary");
+    lines.push(latestRun?.summary?.trim() || "No run summary recorded.");
+    const diagnosis = buildTaskDeliveryDiagnosis({
+        task: input.task,
+        latestRun,
+        deliveryBundle: input.deliveryBundle,
+        deliveryAttempts: input.deliveryAttempts,
+        publicationAttempts: input.publicationAttempts
+    });
+    lines.push("");
+    lines.push("Diagnosis");
+    lines.push(`Primary Failure Domain: ${diagnosis.primaryFailureDomain}`);
+    lines.push(`Execution: ${diagnosis.execution.state}${diagnosis.execution.detail ? ` | ${diagnosis.execution.detail}` : ""}`);
+    lines.push(`Publication: ${diagnosis.publication.state}${diagnosis.publication.detail ? ` | ${diagnosis.publication.detail}` : ""}`);
+    lines.push(`Notification: ${diagnosis.notification.state}${diagnosis.notification.detail ? ` | ${diagnosis.notification.detail}` : ""}`);
+    lines.push(`Recommended Action: ${diagnosis.recommendedAction}`);
+    if (input.deliveryBundle) {
+        lines.push("");
+        lines.push("Delivery");
+        lines.push(`Outcome: ${input.deliveryBundle.outcome}`);
+        lines.push(`Decision: ${input.deliveryBundle.summary.decision}`);
+        if (input.deliveryBundle.warnings?.length) {
+            lines.push(`Warnings: ${input.deliveryBundle.warnings.join(", ")}`);
+        }
+        if (input.deliveryBundle.publication) {
+            lines.push(`Publication: ${input.deliveryBundle.publication.action}${input.deliveryBundle.publication.reason ? ` (${input.deliveryBundle.publication.reason})` : ""}`);
+            if (input.deliveryBundle.publication.git?.branch) {
+                lines.push(`Branch: ${input.deliveryBundle.publication.git.branch}`);
+            }
+            if (input.deliveryBundle.publication.git?.upstreamRemote && input.deliveryBundle.publication.git?.upstreamBranch) {
+                lines.push(`Upstream: ${input.deliveryBundle.publication.git.upstreamRemote}/${input.deliveryBundle.publication.git.upstreamBranch}`);
+            }
+            if (input.deliveryBundle.publication.git?.manifestRevision) {
+                lines.push(`Manifest Revision: ${input.deliveryBundle.publication.git.manifestRevision}`);
+            }
+            if (input.deliveryBundle.publication.git?.targetBranch) {
+                lines.push(`Publication Target: ${input.deliveryBundle.publication.git.targetBranch} (${input.deliveryBundle.publication.git.targetSource ?? "unknown"})`);
+            }
+            if (input.deliveryBundle.publication.git?.reviewSystem) {
+                lines.push(`Review System: ${input.deliveryBundle.publication.git.reviewSystem.type} (${input.deliveryBundle.publication.git.reviewSystem.strategy})${input.deliveryBundle.publication.git.reviewSystem.remoteName ? ` | ${input.deliveryBundle.publication.git.reviewSystem.remoteName}` : ""}${input.deliveryBundle.publication.git.reviewSystem.repository ? ` | ${input.deliveryBundle.publication.git.reviewSystem.repository}` : ""}`);
+            }
+            if (input.deliveryBundle.publication.git?.repoProjects?.length) {
+                lines.push("Publication Projects:");
+                for (const project of input.deliveryBundle.publication.git.repoProjects) {
+                    const target = project.targetBranch ? `${project.targetBranch} (${project.targetSource ?? "unknown"})` : "n/a";
+                    const upstream = project.upstreamRemote && project.upstreamBranch ? ` | ${project.upstreamRemote}/${project.upstreamBranch}` : "";
+                    const review = project.reviewSystem ? ` | ${project.reviewSystem.type}/${project.reviewSystem.strategy}` : "";
+                    lines.push(`- ${project.projectPath}: ${target}${upstream}${review}`);
+                }
+            }
+            if (input.deliveryBundle.publication.git?.unresolvedPaths?.length) {
+                lines.push(`Unresolved Paths: ${input.deliveryBundle.publication.git.unresolvedPaths.join(", ")}`);
+            }
+        }
+    }
+    const deliverySummary = buildDeliveryAttemptSummary(input.deliveryAttempts);
+    if (deliverySummary.channels.length > 0) {
+        lines.push("");
+        lines.push("Delivery Attempts");
+        for (const channel of deliverySummary.channels) {
+            lines.push(`- ${channel.channel}: ${channel.latestStatus} | attempts=${channel.totalAttempts} | failed=${channel.failedAttempts} | dispatched=${channel.dispatchedAttempts} | skipped=${channel.skippedAttempts}`);
+            lines.push(`  Latest: ${channel.latestSummary}`);
+            if (channel.backgroundRecovered) {
+                lines.push("  Recovery: background retry eventually delivered after an earlier failure.");
+            }
+            if (channel.error) {
+                lines.push(`  Error: ${channel.error}`);
+            }
+        }
+    }
+    if (input.publicationAttempts.length > 0) {
+        lines.push("");
+        lines.push("Publication Attempts");
+        for (const attempt of input.publicationAttempts) {
+            const reviewRefs = [
+                ...(attempt.topicUrl ? [`Topic=${attempt.topicUrl}`] : []),
+                ...(attempt.reviewUrls ?? []),
+                ...((attempt.reviewUrls?.length ?? 0) === 0 && attempt.reviewUrl ? [attempt.reviewUrl] : []),
+                ...((attempt.changeIds ?? []).map((value) => `Change-Id=${value}`)),
+                ...((attempt.changeIds?.length ?? 0) === 0 && attempt.changeId ? [`Change-Id=${attempt.changeId}`] : [])
+            ];
+            lines.push(`- ${attempt.mode}: ${attempt.status} | ${attempt.summary}${reviewRefs.length > 0 ? ` | ${reviewRefs.join(" | ")}` : ""}${attempt.artifactPath ? ` | ${attempt.artifactPath}` : ""}`);
+        }
+    }
+    const publicationReview = buildPublicationReviewSummary(input.publicationAttempts);
+    if (publicationReview.latestReviewSubmit) {
+        lines.push("");
+        lines.push("Publication Review");
+        lines.push(`Status: ${publicationReview.latestReviewSubmit.status}`);
+        lines.push(`Summary: ${publicationReview.latestReviewSubmit.summary}`);
+        if (publicationReview.latestReviewSubmit.reviewUrl) {
+            lines.push(`Review URL: ${publicationReview.latestReviewSubmit.reviewUrl}`);
+        }
+        if (publicationReview.latestReviewSubmit.topicUrl) {
+            lines.push(`Topic URL: ${publicationReview.latestReviewSubmit.topicUrl}`);
+        }
+        if (publicationReview.latestReviewSubmit.reviewUrls.length > 0) {
+            lines.push(`Review URLs: ${publicationReview.latestReviewSubmit.reviewUrls.join(", ")}`);
+        }
+        if (publicationReview.latestReviewSubmit.changeIds.length > 0) {
+            lines.push(`Change-Ids: ${publicationReview.latestReviewSubmit.changeIds.join(", ")}`);
+        }
+    }
+    if (input.resultFiles.length > 0) {
+        lines.push("");
+        lines.push("Result File");
+        for (const resultFile of input.resultFiles) {
+            lines.push(`- ${resultFile.path}${resultFile.createdAt ? ` @ ${resultFile.createdAt}` : ""}`);
+        }
+    }
+    return lines.join("\n");
+}
+function renderDeliveryStatusReport(input) {
+    const lines = [];
+    const deliverySummary = buildDeliveryAttemptSummary(input.deliveryAttempts);
+    const publicationReview = buildPublicationReviewSummary(input.publicationAttempts);
+    const diagnosis = buildTaskDeliveryDiagnosis({
+        task: input.task,
+        latestRun: input.latestRun,
+        deliveryBundle: input.deliveryBundle,
+        deliveryAttempts: input.deliveryAttempts,
+        publicationAttempts: input.publicationAttempts
+    });
+    lines.push(`Task ${input.task.taskId}`);
+    lines.push(`Status: ${input.task.status}`);
+    if (input.taskPackage) {
+        lines.push(`Task Type: ${input.taskPackage.taskType}`);
+    }
+    lines.push("");
+    lines.push("Delivery Status");
+    if (input.deliveryBundle) {
+        lines.push(`Outcome: ${input.deliveryBundle.outcome}`);
+        lines.push(`Decision: ${input.deliveryBundle.summary.decision}`);
+        lines.push(`Created At: ${input.deliveryBundle.createdAt}`);
+        if (input.deliveryBundle.warnings?.length) {
+            lines.push(`Warnings: ${input.deliveryBundle.warnings.join(", ")}`);
+        }
+    }
+    else {
+        lines.push("Outcome: not_generated");
+        lines.push("Decision: No delivery bundle recorded.");
+    }
+    lines.push("");
+    lines.push("Diagnosis");
+    lines.push(`Primary Failure Domain: ${diagnosis.primaryFailureDomain}`);
+    lines.push(`Execution: ${diagnosis.execution.state}${diagnosis.execution.detail ? ` | ${diagnosis.execution.detail}` : ""}`);
+    lines.push(`Publication: ${diagnosis.publication.state}${diagnosis.publication.detail ? ` | ${diagnosis.publication.detail}` : ""}`);
+    lines.push(`Notification: ${diagnosis.notification.state}${diagnosis.notification.detail ? ` | ${diagnosis.notification.detail}` : ""}`);
+    lines.push(`Recommended Action: ${diagnosis.recommendedAction}`);
+    if (deliverySummary.channels.length > 0) {
+        for (const channel of deliverySummary.channels) {
+            lines.push(`- ${channel.channel}: ${channel.latestStatus} | attempts=${channel.totalAttempts} | failed=${channel.failedAttempts} | dispatched=${channel.dispatchedAttempts} | skipped=${channel.skippedAttempts}`);
+            lines.push(`  Latest: ${channel.latestSummary}`);
+            lines.push(`  Created At: ${channel.latestCreatedAt}`);
+            if (channel.deliveredAt) {
+                lines.push(`  Delivered At: ${channel.deliveredAt}`);
+            }
+            if (channel.backgroundRecovered) {
+                lines.push("  Recovery: background retry eventually delivered after an earlier failure.");
+            }
+            if (channel.error) {
+                lines.push(`  Error: ${channel.error}`);
+            }
+        }
+    }
+    else {
+        lines.push("No delivery attempts recorded.");
+    }
+    if (publicationReview.latestReviewSubmit) {
+        lines.push("");
+        lines.push("Publication Review");
+        lines.push(`Status: ${publicationReview.latestReviewSubmit.status}`);
+        lines.push(`Summary: ${publicationReview.latestReviewSubmit.summary}`);
+        if (publicationReview.latestReviewSubmit.reviewUrl) {
+            lines.push(`Review URL: ${publicationReview.latestReviewSubmit.reviewUrl}`);
+        }
+        if (publicationReview.latestReviewSubmit.topicUrl) {
+            lines.push(`Topic URL: ${publicationReview.latestReviewSubmit.topicUrl}`);
+        }
+        if (publicationReview.latestReviewSubmit.reviewUrls.length > 0) {
+            lines.push(`Review URLs: ${publicationReview.latestReviewSubmit.reviewUrls.join(", ")}`);
+        }
+        if (publicationReview.latestReviewSubmit.changeIds.length > 0) {
+            lines.push(`Change-Ids: ${publicationReview.latestReviewSubmit.changeIds.join(", ")}`);
+        }
+    }
+    return lines.join("\n");
+}
+function buildTaskDeliveryDiagnosis(input) {
+    const latestRun = input.latestRun;
+    const latestPublicationAttempt = input.publicationAttempts.at(-1) ?? null;
+    const latestReviewSubmit = [...input.publicationAttempts].reverse().find((attempt) => attempt.mode === "review_submit") ?? null;
+    const deliverySummary = buildDeliveryAttemptSummary(input.deliveryAttempts);
+    let executionState = "queued";
+    let executionDetail = null;
+    if (input.task.status === "failed" || latestRun?.taskStatus === "failed") {
+        executionState = "failed";
+        executionDetail = normalizeFailureSummaryReason(latestRun?.summary ?? "Task execution failed.");
+    }
+    else if (input.task.status === "needs_human" || latestRun?.taskStatus === "needs_human") {
+        executionState = "needs_human";
+        executionDetail = normalizeFailureSummaryReason(latestRun?.summary ?? "Task requires human input.");
+    }
+    else if (input.task.status === "canceled" || latestRun?.taskStatus === "canceled") {
+        executionState = "canceled";
+        executionDetail = normalizeFailureSummaryReason(latestRun?.summary ?? "Task execution was canceled.");
+    }
+    else if (input.task.status === "completed" || latestRun?.taskStatus === "completed") {
+        executionState = "completed";
+        executionDetail = latestRun?.summary ? normalizeFailureSummaryReason(latestRun.summary) : null;
+    }
+    else if (latestRun) {
+        executionState = "in_progress";
+        executionDetail = latestRun.lastEventType ? explainTaskEvent(latestRun.lastEventType) : null;
+    }
+    let publicationState = "not_attempted";
+    let publicationDetail = null;
+    let publicationMode = latestReviewSubmit?.mode ?? latestPublicationAttempt?.mode ?? null;
+    let publicationStatus = latestReviewSubmit?.status ?? latestPublicationAttempt?.status ?? null;
+    if (latestReviewSubmit) {
+        publicationState = latestReviewSubmit.status;
+        publicationDetail = normalizeFailureSummaryReason(latestReviewSubmit.error ?? latestReviewSubmit.summary);
+    }
+    else if (latestPublicationAttempt) {
+        publicationState = latestPublicationAttempt.status;
+        publicationDetail = normalizeFailureSummaryReason(latestPublicationAttempt.error ?? latestPublicationAttempt.summary);
+    }
+    else if (!input.deliveryBundle?.publication) {
+        publicationState = "not_attempted";
+        publicationDetail = null;
+    }
+    else if (input.deliveryBundle.publication.action === "published") {
+        publicationState = "published";
+        publicationDetail = input.deliveryBundle.publication.git?.targetBranch ?? input.deliveryBundle.publication.git?.upstreamBranch ?? null;
+    }
+    else if (input.deliveryBundle.publication.action === "ready_for_publish") {
+        publicationState = "ready";
+        publicationDetail = input.deliveryBundle.publication.git?.targetBranch ?? input.deliveryBundle.publication.git?.upstreamBranch ?? null;
+    }
+    else if (input.deliveryBundle.publication.applicable === false) {
+        publicationState = "not_applicable";
+        publicationDetail = input.deliveryBundle.publication.reason ? normalizeFailureSummaryReason(input.deliveryBundle.publication.reason) : null;
+    }
+    else {
+        publicationState = "blocked";
+        publicationDetail = input.deliveryBundle.publication.reason ? normalizeFailureSummaryReason(input.deliveryBundle.publication.reason) : null;
+    }
+    const notificationChannels = deliverySummary.channels.map((channel) => ({
+        channel: channel.channel,
+        state: channel.latestStatus,
+        backgroundRecovered: channel.backgroundRecovered
+    }));
+    let notificationState = "not_attempted";
+    let notificationDetail = null;
+    const notificationRelevantChannels = deliverySummary.channels.filter((channel) => channel.channel !== "console");
+    const failedChannel = notificationRelevantChannels.find((channel) => channel.latestStatus === "failed");
+    if (failedChannel) {
+        notificationState = "failed";
+        notificationDetail = normalizeFailureSummaryReason(failedChannel.error ?? failedChannel.latestSummary);
+    }
+    else if (notificationRelevantChannels.some((channel) => channel.latestStatus === "dispatched")) {
+        notificationState = notificationRelevantChannels.some((channel) => channel.backgroundRecovered) ? "delivered_with_recovery" : "delivered";
+        notificationDetail = normalizeFailureSummaryReason(notificationRelevantChannels.find((channel) => channel.latestStatus === "dispatched")?.latestSummary ?? "Notification delivered.");
+    }
+    else if (notificationRelevantChannels.length > 0 && notificationRelevantChannels.every((channel) => channel.latestStatus === "skipped")) {
+        notificationState = "skipped";
+        notificationDetail = normalizeFailureSummaryReason(notificationRelevantChannels.map((channel) => channel.latestSummary).join(" | "));
+    }
+    else if (notificationRelevantChannels.length === 0 && deliverySummary.channels.some((channel) => channel.channel === "console" && channel.latestStatus === "dispatched")) {
+        notificationState = "not_attempted";
+        notificationDetail = null;
+    }
+    let primaryFailureDomain = "none";
+    if (["failed", "needs_human", "canceled"].includes(executionState)) {
+        primaryFailureDomain = "execution";
+    }
+    else if (["failed", "partial"].includes(publicationState)) {
+        primaryFailureDomain = "publication";
+    }
+    else if (notificationState === "failed") {
+        primaryFailureDomain = "notification";
+    }
+    let recommendedAction = "none";
+    if (primaryFailureDomain === "execution") {
+        recommendedAction = buildTaskNextAction(input.task.status, latestRun?.failureCategory);
+    }
+    else if (primaryFailureDomain === "publication") {
+        recommendedAction = "inspect_publication_failure";
+    }
+    else if (primaryFailureDomain === "notification") {
+        recommendedAction = "retry_delivery_notification";
+    }
+    else if (publicationState === "ready" || publicationState === "planned") {
+        recommendedAction = "review_publication_status";
+    }
+    return {
+        primaryFailureDomain,
+        execution: {
+            state: executionState,
+            detail: executionDetail,
+            failureCategory: latestRun?.failureCategory ?? null
+        },
+        publication: {
+            state: publicationState,
+            detail: publicationDetail,
+            latestMode: publicationMode,
+            latestStatus: publicationStatus
+        },
+        notification: {
+            state: notificationState,
+            detail: notificationDetail,
+            channels: notificationChannels
+        },
+        recommendedAction
+    };
+}
+function buildTaskNextAction(status, failureCategory) {
+    if (status === "needs_human") {
+        return "await_human_input";
+    }
+    if (status === "completed") {
+        return "consume_artifacts";
+    }
+    if (status === "canceled") {
+        return "review_cancel_reason";
+    }
+    if (status === "failed") {
+        if (failureCategory === "auth_missing" || failureCategory === "config_error") {
+            return "fix_configuration";
+        }
+        if (failureCategory === "network_error" || failureCategory === "provider_error" || failureCategory === "timeout") {
+            return "retry_after_environment_check";
+        }
+        if (failureCategory === "schema_error" || failureCategory === "parse_error") {
+            return "inspect_runner_output";
+        }
+        return "inspect_failure_and_retry";
+    }
+    return "wait_for_runtime";
+}
+function describeFailureCategory(failureCategory) {
+    if (!failureCategory) {
+        return null;
+    }
+    const labels = {
+        timeout: "Timed out while waiting for Codex or provider progress.",
+        process_exit: "Codex process exited unexpectedly.",
+        parse_error: "Runner could not parse the Codex reply.",
+        schema_error: "Codex reply shape did not match the result contract.",
+        config_error: "Codex configuration is invalid or incomplete.",
+        network_error: "Network path to Codex control plane or provider failed.",
+        provider_error: "Provider returned an upstream service error.",
+        environment_error: "Runtime environment or workspace setup failed.",
+        input_missing: "Task input is missing critical information.",
+        auth_missing: "Authentication inputs are missing or invalid.",
+        unknown: "Failure category was not classified."
+    };
+    return labels[failureCategory] ?? "Failure category is not yet documented.";
+}
+function buildRecentFailureBreakdown(runs) {
+    const counts = runs
+        .filter((run) => run.taskStatus === "failed")
+        .reduce((accumulator, run) => {
+        const key = run.failureCategory ?? "unknown";
+        accumulator.set(key, (accumulator.get(key) ?? 0) + 1);
+        return accumulator;
+    }, new Map());
+    return [...counts.entries()]
+        .sort((left, right) => right[1] - left[1])
+        .map(([failureCategory, count]) => ({
+        failureCategory,
+        count,
+        label: describeFailureCategory(failureCategory) ?? "Unknown failure"
+    }));
+}
+function buildDeliveryWarningSummary(recentEvents) {
+    const warningEvents = recentEvents.filter((event) => event.type === "task.delivery_bundle.warning");
+    const warningsByType = warningEvents.reduce((accumulator, event) => {
+        accumulator[event.detail] = (accumulator[event.detail] ?? 0) + 1;
+        return accumulator;
+    }, {});
+    return {
+        totalWarnings: warningEvents.length,
+        latestWarning: warningEvents[0]?.detail ?? null,
+        warningsByType
+    };
+}
+function buildRecentFailureSummary(runs, recentEvents) {
+    const recentTerminalRuns = [...runs]
+        .filter((run) => Boolean(run.endedAt) || run.taskStatus === "needs_human" || run.taskStatus === "failed")
+        .sort((left, right) => (right.endedAt ?? right.startedAt).localeCompare(left.endedAt ?? left.startedAt))
+        .slice(0, 50);
+    const failedByCategory = recentTerminalRuns
+        .filter((run) => run.taskStatus === "failed")
+        .reduce((accumulator, run) => {
+        const key = run.failureCategory ?? "unknown";
+        accumulator[key] = (accumulator[key] ?? 0) + 1;
+        return accumulator;
+    }, {});
+    const needsHumanByReason = recentTerminalRuns
+        .filter((run) => run.taskStatus === "needs_human")
+        .reduce((accumulator, run) => {
+        const key = normalizeFailureSummaryReason(run.summary ?? "needs_human");
+        accumulator[key] = (accumulator[key] ?? 0) + 1;
+        return accumulator;
+    }, {});
+    const eventBackfilledReasons = new Set(Object.keys(needsHumanByReason));
+    for (const event of recentEvents) {
+        if (event.type !== "task.needs_human") {
+            continue;
+        }
+        const key = normalizeFailureSummaryReason(event.detail);
+        if (eventBackfilledReasons.has(key)) {
+            continue;
+        }
+        needsHumanByReason[key] = (needsHumanByReason[key] ?? 0) + 1;
+        eventBackfilledReasons.add(key);
+    }
+    return {
+        sampleSize: recentTerminalRuns.length,
+        failedByCategory,
+        needsHumanByReason
+    };
+}
+async function buildDeliveryHealthSummary(store, tasks, runs) {
+    const recentTasks = [...tasks]
+        .sort((left, right) => right.updatedAt.localeCompare(left.updatedAt))
+        .slice(0, 20);
+    const primaryFailureDomain = {};
+    let publicationFailures = 0;
+    let notificationFailures = 0;
+    let notificationRecovered = 0;
+    for (const task of recentTasks) {
+        const latestRun = [...runs].filter((run) => run.taskId === task.taskId).at(-1) ?? null;
+        const deliveryBundle = await store.getLatestTaskDeliveryBundle(task.taskId);
+        const deliveryAttempts = await store.listTaskDeliveryAttempts(task.taskId);
+        const publicationAttempts = await store.listTaskPublicationAttempts(task.taskId);
+        const diagnosis = buildTaskDeliveryDiagnosis({
+            task,
+            latestRun,
+            deliveryBundle,
+            deliveryAttempts,
+            publicationAttempts
+        });
+        primaryFailureDomain[diagnosis.primaryFailureDomain] = (primaryFailureDomain[diagnosis.primaryFailureDomain] ?? 0) + 1;
+        if (diagnosis.publication.state === "failed" || diagnosis.publication.state === "partial") {
+            publicationFailures += 1;
+        }
+        if (diagnosis.notification.state === "failed") {
+            notificationFailures += 1;
+        }
+        if (diagnosis.notification.state === "delivered_with_recovery") {
+            notificationRecovered += 1;
+        }
+    }
+    return {
+        sampleSize: recentTasks.length,
+        primaryFailureDomain,
+        publicationFailures,
+        notificationFailures,
+        notificationRecovered
+    };
+}
+function normalizeFailureSummaryReason(reason) {
+    const normalized = reason.replace(/\s+/g, " ").trim();
+    return normalized.length > 120 ? `${normalized.slice(0, 117)}...` : normalized;
+}
+void main().catch((error) => {
+    const message = error instanceof Error ? error.message : String(error);
+    console.error(message);
+    process.exitCode = 1;
+});
+//# sourceMappingURL=optimus.js.map