@sireai/optimus 0.1.18 → 0.1.21

package/dist/cli/optimus.js

@@ -12,10 +12,8 @@ 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 { resolveCodexAuthMode, resolveConfiguredCodexProvider } 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";
@@ -33,8 +31,8 @@ import { FeishuClient } from "../integrations/feishu/feishu-client.js";
 import { FeishuUserService } from "../integrations/feishu/feishu-user-service.js";
 import { createFeedbackReport } from "./feedback.js";
 import { DEFAULT_FEEDBACK_RECIPIENT_EMAIL, FeishuFeedbackDeliveryService, persistFeedbackDeliveryResult, resolveDefaultFeedbackRecipientFallbackOpenId } from "./feedback-delivery.js";
-import { resolveDefaultConfigPath, resolveDefaultEnvPath, resolveOptimusHomeDir } from "../config/optimus-paths.js";
-import { checkForSelfUpdate, installSelfUpdate, recordSkippedSelfUpdate, readSelfUpdateState, shouldPromptForCachedStartupUpdate } from "./self-update.js";
+import { resolveDefaultConfigPath, resolveDefaultEnvPath } from "../config/optimus-paths.js";
+import { checkForSelfUpdate, installSelfUpdate, recordSkippedSelfUpdate, shouldPromptForCachedStartupUpdate } 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);
@@ -42,16 +40,28 @@ const PACKAGE_NAME = "@sireai/optimus";
 const JIRA_CLI_ENTRY = join(CLI_ROOT_DIR, "dist", "integrations", "jira", "jira-cli.js");
 const SENTRY_CLI_ENTRY = join(CLI_ROOT_DIR, "dist", "integrations", "sentry", "sentry-cli.js");
 const RELEASE_NOTES_URL = "https://github.com/SireAI/optimus/releases/latest";
+const DOCTOR_ANSI = {
+    reset: "\u001B[0m",
+    green: "\u001B[32m",
+    yellow: "\u001B[33m",
+    red: "\u001B[31m",
+    gray: "\u001B[90m"
+};
 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}`);
+    if (result.repository) {
+        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}`);
+    }
+    else {
+        lines.push("Repository: not configured");
+    }
     lines.push(`Delivery: ${result.deliveryChannels.join(", ")}`);
     lines.push(`Jira: ${result.jiraEnabled ? "enabled" : "disabled"}`);
     lines.push(`Sentry: ${result.sentryEnabled ? "enabled" : "disabled"}`);
@@ -67,7 +77,7 @@ function renderSetupResult(result) {
     lines.push("Next");
     lines.push("- optimus start");
     lines.push("- optimus submit --title \"Login crash\" --description \"Crash on startup\"");
-    lines.push("- optimus doctor --quick");
+    lines.push("- optimus doctor");
     lines.push("");
     lines.push(renderQuickDoctorReport(result.doctorQuick));
     return lines.join("\n");
@@ -112,28 +122,96 @@ function renderQuickDoctorReport(report) {
 }
 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"}`
-            + ` channel=${doctor.selfUpdate.cachedState?.channel ?? "latest"}`
-            + ` mode=${doctor.selfUpdate.config.mode}`
-            + ` source=${doctor.selfUpdate.cachedState?.installSource ?? "unknown"}`
-            + ` status=${doctor.selfUpdate.cachedState?.lastCheckStatus ?? "never_checked"}`);
-    }
-    lines.push(`Runtime Root: ${doctor.runtimeRootDir}`);
+    lines.push("Optimus Doctor");
+    lines.push("");
+    lines.push(`Overall: ${doctor.overall}`);
+    lines.push("");
+    lines.push(...renderDoctorSection("Repository", doctor.repository, doctor.repository.using ? [`Using: ${doctor.repository.using}`] : []));
+    lines.push("");
+    lines.push(...renderDoctorSection("Codex", doctor.codex, renderDoctorSubstatusLines(doctor.codex)));
+    lines.push("");
+    lines.push(...renderDoctorSection("Delivery", doctor.delivery));
+    lines.push("");
+    lines.push("Integrations:");
+    for (const integration of doctor.integrations) {
+        lines.push(`  ${formatDoctorStatusHeading(integration.name, integration.status)}`);
+        if (integration.reason) {
+            lines.push(`  Reason: ${integration.reason}`);
+        }
+        if (integration.fix) {
+            lines.push(`  Fix: ${integration.fix}`);
+        }
+    }
+    if (doctor.nextActions.length > 0) {
+        lines.push("");
+        lines.push("Next actions:");
+        doctor.nextActions.forEach((action, index) => {
+            lines.push(`${index + 1}. ${action}`);
+        });
+    }
     return lines.join("\n");
 }
+function renderDoctorSection(title, section, extraLines = []) {
+    const lines = [formatDoctorStatusHeading(title, section.status)];
+    if (section.reason) {
+        lines.push(`Reason: ${section.reason}`);
+    }
+    if (section.fix) {
+        lines.push(`Fix: ${section.fix}`);
+    }
+    lines.push(...extraLines);
+    return lines;
+}
+function renderDoctorSubstatusLines(section) {
+    const lines = [];
+    lines.push(...renderDoctorSubstatus("Auth", section.auth));
+    lines.push(...renderDoctorSubstatus("Connectivity", section.connectivity));
+    return lines;
+}
+function renderDoctorSubstatus(label, section) {
+    const lines = [`${label}: ${formatDoctorStatusMarker(section.status)}`];
+    if (section.reason) {
+        lines.push(`  Reason: ${section.reason}`);
+    }
+    if (section.fix) {
+        lines.push(`  Fix: ${section.fix}`);
+    }
+    return lines;
+}
+function formatDoctorStatusHeading(title, status) {
+    return `${formatDoctorStatusMarker(status)} ${title}`;
+}
+function formatDoctorStatusMarker(status) {
+    const marker = resolveDoctorStatusMarker(status);
+    if (!output.isTTY) {
+        return marker;
+    }
+    return `${resolveDoctorStatusColor(status)}${marker}${DOCTOR_ANSI.reset}`;
+}
+function resolveDoctorStatusMarker(status) {
+    switch (status) {
+        case "ok":
+            return "[✓]";
+        case "warning":
+            return "[!]";
+        case "not_ok":
+            return "[x]";
+        case "disabled":
+            return "[-]";
+    }
+}
+function resolveDoctorStatusColor(status) {
+    switch (status) {
+        case "ok":
+            return DOCTOR_ANSI.green;
+        case "warning":
+            return DOCTOR_ANSI.yellow;
+        case "not_ok":
+            return DOCTOR_ANSI.red;
+        case "disabled":
+            return DOCTOR_ANSI.gray;
+    }
+}
 const SETUP_CODEX_AUTH_MODE_OPTIONS = [
     { index: "1", mode: "model_provider", label: "Model provider" },
     { index: "2", mode: "openai_api_key", label: "OpenAI API key" },
@@ -148,25 +226,19 @@ function renderCliHelp() {
         "",
         "First time here:",
         "  1. optimus setup",
-        "  2. optimus start",
-        "  3. optimus submit --title \"Login crash\" --description \"Crash on startup\"",
+        "  2. optimus doctor",
+        "  3. optimus start",
         "",
-        "Everyday commands:",
-        "  setup                First-time setup or update config",
-        "  start                Start the resident runtime",
+        "Common commands:",
         "  submit               Submit a problem for Optimus to handle",
-        "  task-status          Check what is running now",
-        "  task-result          Read the latest result for a task",
-        "  doctor --quick       Quick readiness check",
+        "  jira-submit-issue    Submit a Jira issue into Optimus",
+        "  sentry-submit-event  Submit a Sentry event into Optimus",
+        "  repo list            Show registered repositories",
         "  version              Show the installed package version",
         "",
         "Need more?",
         "  optimus help advanced        Show integration, retry, and developer commands",
-        "  optimus help <command>       Show details for one command",
-        "",
-        "Notes:",
-        `  - Optimus stores config and runtime data under ${resolveOptimusHomeDir()}.`,
-        "  - Jira and Sentry are optional integrations. You can enable them later in `optimus setup`."
+        "  optimus help <command>       Show details for one command"
     ].join("\n");
 }
 function renderAdvancedCliHelp() {
@@ -186,9 +258,8 @@ function renderAdvancedCliHelp() {
         "  task-status          Show task execution status",
         "  task-result          Show persisted result, delivery, and publication data",
         "  task-events          Show task timeline",
-        "  repo add|remove|update|list|doctor",
-        "  doctor               Show runtime, skills, and environment diagnostics",
-        "  health-check         Validate Codex/provider readiness",
+        "  repo add|remove|update|list",
+        "  doctor               Check repository, Codex, delivery, and integrations in one place",
         "  upgrade              Check for or install a latest/snapshot Optimus update",
         "  version              Show the installed package version",
         "",
@@ -328,7 +399,6 @@ function renderCommandHelp(command) {
             "  optimus repo remove <path|alias>",
             "  optimus repo update <path|alias> [options]",
             "  optimus repo list",
-            "  optimus repo doctor",
             "",
             "Common options:",
             "  --alias <name>               Repository alias",
@@ -346,9 +416,7 @@ function renderCommandHelp(command) {
             "  optimus doctor [options]",
             "",
             "Optional:",
-            "  --quick                      Run compact readiness check",
-            "  --json                       Print JSON when used with --quick",
-            "  --format text                Print text report"
+            "  --json                       Print JSON output for automation"
         ].join("\n"),
         advanced: renderAdvancedCliHelp(),
         "notify-test": [
@@ -408,7 +476,8 @@ function renderCommandHelp(command) {
             "  --branch <name>              Override target branch",
             "  --task-type <type>           Task type, default bugfix",
             "  --allow-duplicate            Allow duplicate submission",
-            "  --comment-limit <n>          Comment lines fetched from Jira, default 3",
+            "  --with-comments              Include recent Jira comments in submit context",
+            "  --comment-limit <n>          Comment lines fetched from Jira when --with-comments is set, default 3",
             "  --dry-run                    Preview without creating a task",
             "",
             "Example:",
@@ -425,6 +494,7 @@ function renderCommandHelp(command) {
             "  --repo <alias>               Target registered repository alias",
             "  --projects-filter <csv>      Restrict Jira projects",
             "  --limit <n>                  Max issues to submit, default 50",
+            "  --with-comments              Include recent Jira comments in submit context",
             "  --allow-duplicate            Allow duplicate submission",
             "  --dry-run                    Preview without creating tasks"
         ].join("\n"),
@@ -940,7 +1010,7 @@ async function buildFeishuDoctorStatus(config) {
                 : "Real @mentions require Feishu app availability.",
             ...(mentionReady
                 ? {}
-                : { recommendation: "Rerun `optimus doctor --quick` after restoring Feishu app availability." })
+                : { recommendation: "Rerun `optimus doctor` after restoring Feishu app availability." })
         }
     };
 }
@@ -1065,16 +1135,16 @@ async function promptSetupAnswers(defaults) {
     try {
         console.log("Optimus setup");
         console.log("This usually takes about 2 minutes.");
-        console.log("Required: repository + Codex auth. Optional: Feishu webhook, Jira, Sentry.");
+        console.log("Required: Codex auth. Optional: repository, Feishu webhook, Jira, Sentry.");
         console.log("You can rerun `optimus setup` later to change anything.");
         if (await pathExists(configPath)) {
             console.log(`Existing config found at ${configPath}. Press Enter to keep current values.`);
         }
-        printSetupSection("Repository", "Point Optimus at the main local repository it should work in.");
-        printSetupHint("Repository path: the local code directory Optimus will read and edit.");
-        const repoPath = (await ask(renderSetupPrompt("Required", "Repository path", defaults.repoPath))).trim() || defaults.repoPath;
-        printSetupHint("Repository alias: the short name used later in commands like --repo ohos-pre.");
-        const repoAlias = (await ask(renderSetupPrompt("Required", "Repository alias", defaults.repoAlias))).trim() || defaults.repoAlias;
+        printSetupSection("Repository", "Optional. Point Optimus at the main local repository it should work in, or leave both fields empty and add one later.");
+        printSetupHint("Repository path: the local code directory Optimus will read and edit. Leave empty if you only want to finish setup first.");
+        const repoPath = (await ask(renderSetupPrompt("Optional", "Repository path", defaults.repoPath))).trim() || defaults.repoPath;
+        printSetupHint("Repository alias: the short name used later in commands like --repo ohos-pre. Leave empty if no repository should be registered now.");
+        const repoAlias = (await ask(renderSetupPrompt("Optional", "Repository alias", defaults.repoAlias))).trim() || defaults.repoAlias;
         printSetupSection("Codex", "Choose one model authentication mode. This is required before tasks can run.");
         printSetupHint("Codex auth mode: choose how Optimus reaches the model you want to use.");
         const codexAuthMode = await askSetupCodexAuthMode({ ask, defaultMode: defaults.codexAuthMode });
@@ -1103,8 +1173,6 @@ async function promptSetupAnswers(defaults) {
         printSetupSection("Feishu", "Built-in Feishu app delivery is already available. Add a webhook only if group notifications should go to a chat first. Type \"\" to clear an existing optional value.");
         printSetupHint("Feishu webhook: optional; leave empty to use direct Feishu app delivery only.");
         const feishuWebhook = resolveOptionalTextAnswer(await ask(renderSetupPrompt("Optional", "Feishu webhook", defaults.feishuWebhook ? "configured" : "")), defaults.feishuWebhook ?? undefined);
-        printSetupHint("Feishu secret: optional; only needed when the webhook itself requires signature verification.");
-        const feishuSecret = resolveOptionalTextAnswer(await ask(renderSetupPrompt("Optional", "Feishu secret", defaults.feishuSecret ? "configured" : "")), defaults.feishuSecret ?? undefined);
         printSetupSection("Jira", "Optional. Turn this on only if you want this machine to read Jira issues or write Jira comments.");
         printSetupHint("If disabled, Optimus still works; Jira commands just stay unavailable on this machine.");
         const enableJiraInput = (await ask(renderSetupPrompt("Optional integration", "Enable Jira integration", defaults.enableJira ? "Y/n" : "y/N"))).trim().toLowerCase();
@@ -1145,7 +1213,6 @@ async function promptSetupAnswers(defaults) {
             ...(codexProviderBaseUrl ? { codexProviderBaseUrl } : {}),
             ...(codexProviderApiKeyEnvName ? { codexProviderApiKeyEnvName } : {}),
             ...(feishuWebhook !== undefined ? { feishuWebhook } : {}),
-            ...(feishuSecret !== undefined ? { feishuSecret } : {}),
             enableJira,
             ...(jiraBaseUrl ? { jiraBaseUrl } : {}),
             ...(jiraPersonalToken ? { jiraPersonalToken } : {}),
@@ -1196,7 +1263,6 @@ async function resolveDefaultSetupAnswers() {
         ...(provider?.baseUrl ? { codexProviderBaseUrl: provider.baseUrl } : {}),
         ...(provider?.apiKeyEnvName ? { codexProviderApiKeyEnvName: provider.apiKeyEnvName } : {}),
         ...(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.personalToken ? { jiraPersonalToken: config.jira.personalToken } : {}),
@@ -1248,11 +1314,10 @@ async function askSetupCodexAuthMode(input) {
     }
 }
 function validateSetupAnswers(answers) {
-    if (!answers.repoPath.trim()) {
-        return "setup requires a repository path.";
-    }
-    if (!answers.repoAlias.trim()) {
-        return "setup requires a repository alias.";
+    const repoPath = answers.repoPath.trim();
+    const repoAlias = answers.repoAlias.trim();
+    if ((repoPath && !repoAlias) || (!repoPath && repoAlias)) {
+        return "setup repository registration requires both repository path and repository alias, or neither.";
     }
     if (answers.codexAuthMode === "model_provider" && !answers.codexProviderId?.trim()) {
         return "setup requires provider id when Codex auth mode is model_provider.";
@@ -1384,16 +1449,15 @@ function buildSetupConfig(answers, rawConfig) {
     config.delivery.channels = ["console", "feishu"];
     config.delivery.feishu = {
         ...config.delivery.feishu,
-        ...(typeof answers.feishuWebhook === "string" ? { webhook: answers.feishuWebhook } : {}),
-        ...(typeof answers.feishuSecret === "string" ? { secret: answers.feishuSecret } : {})
+        ...(typeof rawConfig?.delivery?.feishu?.secret === "string" && rawConfig.delivery.feishu.secret.trim()
+            ? { secret: rawConfig.delivery.feishu.secret.trim() }
+            : {}),
+        ...(typeof answers.feishuWebhook === "string" ? { webhook: answers.feishuWebhook } : {})
     };
     if (answers.feishuWebhook === null) {
         delete config.delivery.feishu.webhook;
         delete config.delivery.feishu.webhooks;
     }
-    if (answers.feishuSecret === null) {
-        delete config.delivery.feishu.secret;
-    }
     config.jira.enabled = answers.enableJira;
     if (answers.enableJira) {
         config.jira.baseUrl = answers.jiraBaseUrl ?? config.jira.baseUrl;
@@ -1551,12 +1615,12 @@ async function runQuickDoctor(configPath = resolveDefaultConfigPath()) {
     await store.init();
     const registeredRepositories = await store.listRepositoryRoots();
     if (registeredRepositories.length === 0) {
-        blocking.push({
+        warnings.push({
             code: "repository_missing",
             message: "No repository is registered.",
-            fix: "Rerun `optimus setup` and provide a repository path and alias."
+            fix: "Register one with `optimus repo add <path> --alias <name>` or rerun `optimus setup`."
         });
-        next.add("optimus setup");
+        next.add("optimus repo add <path> --alias <name>");
     }
     for (const repository of registeredRepositories) {
         const inspection = await inspectRepositoryRoot(repository.path);
@@ -1587,7 +1651,7 @@ async function runQuickDoctor(configPath = resolveDefaultConfigPath()) {
             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`."
+                fix: "Run `git config user.name \"Your Name\"` in the repository, then rerun `optimus doctor`."
             });
             next.add("git config user.name \"Your Name\"");
         }
@@ -1595,7 +1659,7 @@ async function runQuickDoctor(configPath = resolveDefaultConfigPath()) {
             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`."
+                fix: "Run `git config user.email \"you@example.com\"` in the repository, then rerun `optimus doctor`."
             });
             next.add("git config user.email \"you@example.com\"");
         }
@@ -1640,6 +1704,196 @@ async function runQuickDoctor(configPath = resolveDefaultConfigPath()) {
         next: [...next]
     };
 }
+function summarizeIssue(issue, fallback) {
+    if (!issue?.message) {
+        return fallback;
+    }
+    return issue.message.replace(/\.$/u, "");
+}
+function doctorNextActions(quick, healthCheck, delivery) {
+    const actions = new Set();
+    for (const step of quick.next) {
+        actions.add(step);
+    }
+    if (!healthCheck.ok) {
+        const fixHint = healthCheck.diagnostics.auth?.fixHint?.trim();
+        if (fixHint) {
+            actions.add(fixHint);
+        }
+        else {
+            actions.add("Rerun `optimus setup`.");
+        }
+    }
+    if (delivery.status === "not_ok" && delivery.fix) {
+        actions.add(delivery.fix);
+    }
+    if (actions.size === 0) {
+        actions.add("Run `optimus start`.");
+        actions.add("Submit a task with `optimus submit --title \"...\" --description \"...\"`.");
+    }
+    return [...actions].slice(0, 3);
+}
+async function runDoctor(configPath = resolveDefaultConfigPath()) {
+    const quick = await runQuickDoctor(configPath);
+    const configIssue = quick.blocking.find((issue) => issue.code === "config_missing" || issue.code === "config_parse_failed" || issue.code === "config_load_failed");
+    if (configIssue) {
+        const repoIssue = quick.blocking.find((issue) => issue.code.startsWith("repository_") || issue.code.startsWith("git_user_"));
+        const codexIssue = quick.blocking.find((issue) => issue.code.startsWith("codex_"));
+        return {
+            overall: "not_ready",
+            repository: {
+                status: repoIssue ? "not_ok" : "warning",
+                ...(repoIssue ? { reason: summarizeIssue(repoIssue, "Repository setup is incomplete.") } : { reason: "Repository checks could not complete yet." }),
+                ...(repoIssue?.fix ? { fix: repoIssue.fix } : {})
+            },
+            codex: {
+                status: codexIssue ? "not_ok" : "warning",
+                ...(codexIssue ? { reason: summarizeIssue(codexIssue, "Codex setup is incomplete.") } : { reason: "Codex checks could not complete yet." }),
+                ...(codexIssue?.fix ? { fix: codexIssue.fix } : {}),
+                auth: {
+                    status: codexIssue ? "not_ok" : "warning",
+                    ...(codexIssue ? { reason: summarizeIssue(codexIssue, "Codex authentication is not ready.") } : { reason: "Authentication checks could not complete yet." }),
+                    ...(codexIssue?.fix ? { fix: codexIssue.fix } : {})
+                },
+                connectivity: {
+                    status: "disabled",
+                    reason: "Connectivity check is deferred until authentication is ready."
+                }
+            },
+            delivery: {
+                status: "warning",
+                reason: "Delivery checks are deferred until setup is complete."
+            },
+            integrations: [
+                {
+                    name: "Jira",
+                    status: "disabled"
+                },
+                {
+                    name: "Sentry",
+                    status: "disabled"
+                }
+            ],
+            nextActions: quick.next.slice(0, 3)
+        };
+    }
+    const config = await loadConfig(configPath);
+    const codexRunner = new CodexRunner(config);
+    const feishuStatus = await buildFeishuDoctorStatus(config);
+    const healthCheck = await codexRunner.runHealthCheck();
+    const repositoryIssue = quick.blocking.find((issue) => issue.code.startsWith("repository_") || issue.code.startsWith("git_user_"))
+        ?? quick.warnings.find((issue) => issue.code.startsWith("repository_") || issue.code.startsWith("git_user_"));
+    const repositoryStatus = repositoryIssue
+        ? quick.blocking.includes(repositoryIssue)
+            ? "not_ok"
+            : "warning"
+        : "ok";
+    const repository = repositoryIssue
+        ? {
+            status: repositoryStatus,
+            reason: summarizeIssue(repositoryIssue, "Repository is not ready."),
+            ...(repositoryIssue.fix ? { fix: repositoryIssue.fix } : {}),
+            ...(quick.repositories[0]?.alias ?? quick.repositories[0]?.path ? { using: quick.repositories[0]?.alias ?? quick.repositories[0]?.path } : {})
+        }
+        : {
+            status: "ok",
+            ...(quick.repositories[0]?.alias ?? quick.repositories[0]?.path ? { using: quick.repositories[0]?.alias ?? quick.repositories[0]?.path } : {})
+        };
+    const authDiagnostics = healthCheck.diagnostics.auth;
+    const codexIssue = quick.blocking.find((issue) => issue.code.startsWith("codex_"));
+    const codexAuth = authDiagnostics?.authenticated
+        ? { status: "ok" }
+        : {
+            status: "not_ok",
+            reason: summarizeIssue(codexIssue, healthCheck.diagnostics.failureCategory === "auth_missing"
+                ? "authentication is not usable."
+                : "Codex authentication is not ready."),
+            fix: authDiagnostics?.fixHint?.trim() || "Rerun `optimus setup`."
+        };
+    const codexConnectivity = !authDiagnostics?.authenticated
+        ? {
+            status: "disabled",
+            reason: "Connectivity check is deferred until authentication is ready."
+        }
+        : healthCheck.ok
+            ? { status: "ok" }
+            : {
+                status: "not_ok",
+                reason: healthCheck.diagnostics.failureCategory === "provider_error"
+                    ? "model provider is unreachable."
+                    : healthCheck.diagnostics.failureCategory === "network_error"
+                        ? "network connectivity to Codex is unavailable."
+                        : "Codex request could not complete.",
+                fix: authDiagnostics.fixHint?.trim() || "Retry `optimus doctor` after fixing the Codex connection."
+            };
+    const codex = healthCheck.ok
+        ? {
+            status: "ok",
+            auth: codexAuth,
+            connectivity: codexConnectivity
+        }
+        : {
+            status: "not_ok",
+            reason: summarizeIssue(codexIssue, !authDiagnostics?.authenticated
+                ? "authentication is not usable."
+                : healthCheck.diagnostics.failureCategory === "provider_error"
+                    ? "model provider is unreachable."
+                    : "Codex is not ready."),
+            fix: authDiagnostics?.fixHint?.trim() || "Rerun `optimus setup`.",
+            auth: codexAuth,
+            connectivity: codexConnectivity
+        };
+    const feishuIssue = quick.blocking.find((issue) => issue.code.startsWith("feishu_"))
+        ?? quick.warnings.find((issue) => issue.code.startsWith("feishu_"));
+    const delivery = !config.delivery.enabled
+        ? {
+            status: "warning",
+            reason: "task delivery is disabled.",
+            fix: "Enable delivery in config if this machine should send notifications."
+        }
+        : feishuIssue
+            ? {
+                status: "not_ok",
+                reason: summarizeIssue(feishuIssue, "Feishu delivery is not usable."),
+                ...(feishuIssue.fix ? { fix: feishuIssue.fix } : {})
+            }
+            : feishuStatus.auth.configured
+                ? {
+                    status: "ok"
+                }
+                : {
+                    status: "warning",
+                    reason: "Feishu app delivery is unavailable.",
+                    fix: "Rerun `optimus setup` and verify Feishu configuration."
+                };
+    const jiraIssues = config.jira.enabled ? resolveJiraQuickDoctorIssues(config.jira) : [];
+    const sentryIssues = config.sentry.enabled ? resolveSentryQuickDoctorIssues(config.sentry) : [];
+    const integrations = [
+        config.jira.enabled
+            ? jiraIssues.length > 0
+                ? { name: "Jira", status: "not_ok", reason: summarizeIssue(jiraIssues[0], "Jira is not ready."), ...(jiraIssues[0]?.fix ? { fix: jiraIssues[0].fix } : {}) }
+                : { name: "Jira", status: "ok" }
+            : { name: "Jira", status: "disabled" },
+        config.sentry.enabled
+            ? sentryIssues.length > 0
+                ? { name: "Sentry", status: "not_ok", reason: summarizeIssue(sentryIssues[0], "Sentry is not ready."), ...(sentryIssues[0]?.fix ? { fix: sentryIssues[0].fix } : {}) }
+                : { name: "Sentry", status: "ok" }
+            : { name: "Sentry", status: "disabled" }
+    ];
+    const overall = repository.status === "not_ok" || codex.status === "not_ok"
+        ? "not_ready"
+        : delivery.status === "warning" || integrations.some((integration) => integration.status === "not_ok")
+            ? "warning"
+            : "ready";
+    return {
+        overall,
+        repository,
+        codex,
+        delivery,
+        integrations,
+        nextActions: doctorNextActions(quick, healthCheck, delivery)
+    };
+}
 async function runSetup(args) {
     const configPath = resolveDefaultConfigPath();
     const envPath = resolveDefaultEnvPath();
@@ -1653,27 +1907,34 @@ async function runSetup(args) {
     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 preflightConfig = configExists ? await loadConfig(configPath) : buildDefaultConfig();
     const preflightStore = new SQLiteTaskStore(preflightConfig.storage.rootDir);
     await preflightStore.init();
     const existingRepositories = await preflightStore.listRepositoryRoots();
-    const aliasConflict = existingRepositories.find((repository) => repository.alias === answers.repoAlias && repository.path !== normalizedRepoPath);
-    if (aliasConflict) {
-        throw new Error(`Repository alias already exists for another path: ${answers.repoAlias} -> ${aliasConflict.path}. `
-            + "Use `optimus repo update` or `optimus repo remove` before re-running setup.");
-    }
-    const existingRepository = existingRepositories.find((repository) => repository.path === normalizedRepoPath);
-    const resolvedExecutionMode = existingRepository?.executionMode ?? describeRepositoryExecutionPlan({ executionMode: "copy" }, inspection).resolvedDefaultMode;
-    const previewExecutionPlan = describeRepositoryExecutionPlan({ executionMode: resolvedExecutionMode }, inspection);
-    const reviewSystem = await detectRepositoryReviewSystem(normalizedRepoPath, inspection);
+    const hasRepositorySelection = answers.repoPath.trim().length > 0 && answers.repoAlias.trim().length > 0;
+    let normalizedRepoPath;
+    let resolvedExecutionMode;
+    let previewExecutionPlan;
+    let reviewSystem;
+    if (hasRepositorySelection) {
+        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 aliasConflict = existingRepositories.find((repository) => repository.alias === answers.repoAlias && repository.path !== normalizedRepoPath);
+        if (aliasConflict) {
+            throw new Error(`Repository alias already exists for another path: ${answers.repoAlias} -> ${aliasConflict.path}. `
+                + "Use `optimus repo update` or `optimus repo remove` before re-running setup.");
+        }
+        const existingRepository = existingRepositories.find((repository) => repository.path === normalizedRepoPath);
+        resolvedExecutionMode = existingRepository?.executionMode ?? describeRepositoryExecutionPlan({ executionMode: "copy" }, inspection).resolvedDefaultMode;
+        previewExecutionPlan = describeRepositoryExecutionPlan({ executionMode: resolvedExecutionMode }, inspection);
+        reviewSystem = await detectRepositoryReviewSystem(normalizedRepoPath, inspection);
+    }
     const rawConfig = configExists ? await readRawProjectConfig(configPath) : undefined;
     await mkdir(dirname(configPath), { recursive: true });
-    await writeFile(configPath, `${buildSetupConfig({ ...answers, repoPath: normalizedRepoPath }, rawConfig)}\n`, "utf8");
+    await writeFile(configPath, `${buildSetupConfig({ ...answers, ...(normalizedRepoPath ? { repoPath: normalizedRepoPath } : {}) }, rawConfig)}\n`, "utf8");
     const codexAuthEnvName = resolveSetupCodexApiKeyEnvName(answers);
     if (answers.codexApiKey && codexAuthEnvName) {
         await mkdir(dirname(envPath), { recursive: true });
@@ -1682,11 +1943,13 @@ async function runSetup(args) {
     const config = await loadConfig(configPath);
     const store = new SQLiteTaskStore(config.storage.rootDir);
     await store.init();
-    await store.addRepositoryRoot({
-        path: normalizedRepoPath,
-        alias: answers.repoAlias,
-        executionMode: resolvedExecutionMode
-    });
+    if (normalizedRepoPath && resolvedExecutionMode) {
+        await store.addRepositoryRoot({
+            path: normalizedRepoPath,
+            alias: answers.repoAlias,
+            executionMode: resolvedExecutionMode
+        });
+    }
     const doctorQuick = await runQuickDoctor(configPath);
     const codexAuth = new CodexAuthResolver(config).resolve().diagnostics;
     return {
@@ -1694,13 +1957,15 @@ async function runSetup(args) {
         configPath,
         envPath,
         configStatus: configExists ? "overwritten" : "created",
-        repository: {
-            path: normalizedRepoPath,
-            alias: answers.repoAlias,
-            workspaceKind: previewExecutionPlan.workspaceKind,
-            executionMode: resolvedExecutionMode,
-            reviewSystem
-        },
+        ...(normalizedRepoPath && previewExecutionPlan && resolvedExecutionMode && reviewSystem ? {
+            repository: {
+                path: normalizedRepoPath,
+                alias: answers.repoAlias,
+                workspaceKind: previewExecutionPlan.workspaceKind,
+                executionMode: resolvedExecutionMode,
+                reviewSystem
+            }
+        } : {}),
         deliveryChannels: config.delivery.channels,
         jiraEnabled: config.jira.enabled,
         sentryEnabled: config.sentry.enabled,
@@ -1934,7 +2199,7 @@ async function main() {
         if (command === "repo") {
             const repoSubcommand = commandArgs.find((token) => !token.startsWith("--"))?.trim();
             console.log(renderCommandHelp("repo") ?? renderCliHelp());
-            process.exitCode = repoSubcommand && !["add", "remove", "update", "list", "doctor"].includes(repoSubcommand) ? 1 : 0;
+            process.exitCode = repoSubcommand && !["add", "remove", "update", "list"].includes(repoSubcommand) ? 1 : 0;
             return;
         }
         console.log(renderCommandHelp(command) ?? renderCliHelp());
@@ -2018,15 +2283,15 @@ async function main() {
         return;
     }
     const parsedCommandArgs = parseArgs(commandArgs);
-    if (command === "doctor" && parsedCommandArgs.quick === "true") {
-        const result = await runQuickDoctor();
+    if (command === "doctor") {
+        const result = await runDoctor();
         if (parsedCommandArgs.json === "true") {
             console.log(JSON.stringify(result, null, 2));
         }
         else {
-            console.log(renderQuickDoctorReport(result));
+            console.log(renderDoctorTextReport(result));
         }
-        process.exitCode = result.summary === "blocked" ? 1 : 0;
+        process.exitCode = result.overall === "not_ready" ? 1 : 0;
         return;
     }
     let config;
@@ -2380,7 +2645,9 @@ async function main() {
             artifacts,
             deliveryBundle: existingBundle
         });
-        const deliveryService = new TaskDeliveryService();
+        const deliveryService = new TaskDeliveryService({
+            jiraBaseUrl: config.jira.baseUrl
+        });
         const analysisDocService = new FeishuAnalysisDocService({ config, refStore: store });
         const publicationService = new TaskPublicationService(logger);
         const deliveryDispatcher = new TaskDeliveryDispatcher(config);
@@ -2628,22 +2895,6 @@ async function main() {
             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;
@@ -2992,163 +3243,6 @@ async function main() {
             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(config);
-        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;
 }