agentic-dev 0.2.17 → 0.2.19

package/dist/bin/agentic-dev.js

@@ -1,13 +1,14 @@
 #!/usr/bin/env node
+import { spawnSync } from "node:child_process";
 import fs from "node:fs";
 import path from "node:path";
 import process from "node:process";
-import * as readline from "node:readline";
 import { createInterface } from "node:readline/promises";
 import { DEFAULT_TEMPLATE_OWNER, ensureTargetDir, fetchTemplateRepos, finalizeRepositoryGit, installTemplateRepo, parseArgs, resolveGitHubOrchestration, resolveTemplateRepo, usage, } from "../lib/scaffold.js";
 const DEFAULT_TARGET_DIR = ".";
 const DEFAULT_AI_PROVIDERS = ["codex", "claude"];
-const DEFAULT_PROVIDER_PROFILES = ["codex-subscription", "claude-subscription"];
+const DEFAULT_PROVIDER_PROFILES = ["codex-cli", "claude-cli"];
+const DASHBOARD_TABS = ["Overview", "Agents", "Tasks", "Activity"];
 const GITHUB_AUTH_CHOICES = [
     {
         label: "gh-session",
@@ -43,12 +44,11 @@ const AI_PROVIDER_CHOICES = [
     },
 ];
 const PROVIDER_PROFILE_CHOICES = [
-    { label: "codex-subscription", value: "codex-subscription", description: "Codex subscription/runtime access" },
-    { label: "codex-api", value: "codex-api", description: "Codex API access" },
-    { label: "claude-subscription", value: "claude-subscription", description: "Claude subscription/runtime access" },
-    { label: "claude-api", value: "claude-api", description: "Claude API access" },
-    { label: "openai-api", value: "openai-api", description: "OpenAI API access" },
-    { label: "ollama-self-hosted", value: "ollama-self-hosted", description: "Local Ollama runtime" },
+    { label: "codex-cli", value: "codex-cli", description: "Run tasks through the local Codex CLI session." },
+    { label: "openai-api", value: "openai-api", description: "Call the OpenAI Responses API directly for coding tasks." },
+    { label: "claude-cli", value: "claude-cli", description: "Run tasks through the local Claude Code CLI session." },
+    { label: "anthropic-api", value: "anthropic-api", description: "Call the Anthropic Messages API directly for Claude tasks." },
+    { label: "ollama-self-hosted", value: "ollama-self-hosted", description: "Use the local Ollama server/runtime." },
 ];
 const GITHUB_PROJECT_MODE_CHOICES = [
     {
@@ -74,13 +74,6 @@ const CONFIRM_CHOICES = [
         description: "Stop without writing files",
     },
 ];
-function clearMenu(lines) {
-    if (lines <= 0) {
-        return;
-    }
-    readline.moveCursor(process.stdout, 0, -lines);
-    readline.clearScreenDown(process.stdout);
-}
 function inferProjectName(targetDir) {
     const normalized = targetDir.trim() || DEFAULT_TARGET_DIR;
     const resolved = path.resolve(process.cwd(), normalized);
@@ -101,8 +94,42 @@ function uniqueStrings(values) {
 function normalizeProviders(providers) {
     return providers.length > 0 ? uniqueStrings(providers) : [...DEFAULT_AI_PROVIDERS];
 }
+function normalizeProviderProfile(value) {
+    const normalized = value.trim().toLowerCase();
+    switch (normalized) {
+        case "codex-subscription":
+        case "codex-cli":
+            return "codex-cli";
+        case "codex-api":
+        case "openai-api":
+            return "openai-api";
+        case "claude-subscription":
+        case "claude-cli":
+            return "claude-cli";
+        case "claude-api":
+        case "anthropic-api":
+            return "anthropic-api";
+        case "ollama-self-hosted":
+            return "ollama-self-hosted";
+        default:
+            return "";
+    }
+}
 function normalizeProviderProfiles(providerProfiles) {
-    return providerProfiles.length > 0 ? uniqueStrings(providerProfiles) : [...DEFAULT_PROVIDER_PROFILES];
+    const normalized = providerProfiles
+        .map((profile) => normalizeProviderProfile(profile))
+        .filter(Boolean);
+    return normalized.length > 0 ? uniqueStrings(normalized) : [...DEFAULT_PROVIDER_PROFILES];
+}
+function normalizeGithubAuthMode(value) {
+    const normalized = value.trim().toLowerCase();
+    if (normalized === "public" || normalized === "gh-session") {
+        return "gh";
+    }
+    if (normalized === "gh" || normalized === "env" || normalized === "pat") {
+        return normalized;
+    }
+    return "gh";
 }
 function hydrateOptions(options) {
     const state = {
@@ -131,16 +158,6 @@ function hydrateOptions(options) {
     }
     return state;
 }
-function normalizeGithubAuthMode(value) {
-    const normalized = value.trim().toLowerCase();
-    if (normalized === "public" || normalized === "gh-session") {
-        return "gh";
-    }
-    if (normalized === "gh" || normalized === "env" || normalized === "pat") {
-        return normalized;
-    }
-    return "gh";
-}
 function applyRuntimeGitHubAuth(state) {
     if (state.githubAuthMode === "pat" && state.githubPat) {
         process.env.AGENTIC_GITHUB_TOKEN = state.githubPat;
@@ -179,21 +196,21 @@ function buildSteps(state, repos) {
             key: "projectName",
             type: "text",
             label: "Project name",
-            description: "Written into scaffold metadata and Claude workspace nickname.",
+            description: "Written into scaffold metadata and workspace labels.",
             placeholder: inferProjectName(state.targetDir),
         },
         {
             key: "githubRepositoryInput",
             type: "text",
             label: "GitHub repository",
-            description: "Use owner/name, a GitHub URL, or just a repo name to create/use the repository.",
+            description: "Use owner/name, a GitHub URL, or just a repo name to create or reuse the repository.",
             placeholder: state.projectName,
         },
         {
             key: "githubAuthMode",
             type: "single",
             label: "GitHub credential source",
-            description: "Choose which GitHub credentials this run should use for repo/project orchestration. say828 template-* selection is always available.",
+            description: "Choose which credentials this run should use for repo/project orchestration. say828 template-* selection is always available.",
             choices: GITHUB_AUTH_CHOICES,
         },
     ];
@@ -210,7 +227,7 @@ function buildSteps(state, repos) {
         key: "githubProjectMode",
         type: "single",
         label: "GitHub project mode",
-        description: "Choose whether the orchestration must reuse an existing GitHub Project or create one if needed.",
+        description: "Choose whether orchestration must reuse an existing GitHub Project or create one if needed.",
         choices: GITHUB_PROJECT_MODE_CHOICES,
     }, {
         key: "githubProjectTitle",
@@ -227,14 +244,14 @@ function buildSteps(state, repos) {
     }, {
         key: "providerProfiles",
         type: "multi",
-        label: "AI runtime profiles",
-        description: "Use Space to toggle provider/runtime profiles.",
+        label: "AI execution adapters",
+        description: "Toggle the runtime adapters this repo may use during orchestration.",
         choices: PROVIDER_PROFILE_CHOICES,
     }, {
         key: "aiProviders",
         type: "multi",
         label: "Workspace agent surfaces",
-        description: "Use Space to toggle Codex/Claude workspace assets.",
+        description: "Toggle Codex, Claude, and Ollama metadata in the generated repo.",
         choices: AI_PROVIDER_CHOICES,
     });
     if (!state.force && directoryHasUserFiles(state.targetDir)) {
@@ -261,7 +278,7 @@ function buildSteps(state, repos) {
         key: "confirm",
         type: "confirm",
         label: "Review and run",
-        description: "Confirm every choice before the CLI starts cloning or installing.",
+        description: "All selections are collected first. Commands run only after final confirmation.",
         choices: CONFIRM_CHOICES,
     });
     return steps;
@@ -284,29 +301,67 @@ function stepValue(state, step) {
     }
     return state[step.key];
 }
-function renderHeader(step, index, total) {
-    return [`Agentic Dev Setup ${index + 1}/${total}`, step.label, step.description, ""];
+function renderHeader(title, subtitle, modeHint) {
+    return [
+        title,
+        subtitle,
+        "",
+        modeHint,
+        "",
+    ];
+}
+function executionPreview(state, selectedRepo) {
+    const lines = [
+        `Project directory: ${path.resolve(process.cwd(), state.targetDir)}`,
+        `Project name: ${state.projectName}`,
+        `GitHub repository: ${state.githubRepositoryInput}`,
+        `GitHub project mode: ${state.githubProjectMode}`,
+        `GitHub project title: ${state.githubProjectTitle}`,
+        `GitHub credential source: ${state.githubAuthMode}`,
+        `Template repo: ${selectedRepo?.name || state.template}`,
+        `Workspace surfaces: ${state.aiProviders.join(", ")}`,
+        `Execution adapters: ${state.providerProfiles.join(", ")}`,
+        `Allow non-empty directory: ${state.force ? "yes" : "no"}`,
+    ];
+    if (state.githubAuthMode === "pat") {
+        lines.push(`GitHub PAT supplied: ${state.githubPat ? "yes" : "no"}`);
+    }
+    lines.push("");
+    lines.push("Planned execution:");
+    lines.push(`  1. Ensure GitHub repo ${state.githubRepositoryInput}`);
+    lines.push(`  2. Ensure GitHub Project ${state.githubProjectTitle}`);
+    lines.push(`  3. Clone ${selectedRepo?.name || state.template}`);
+    lines.push("  4. Install shared sub-agent assets and orchestration workflow");
+    lines.push("  5. Copy .env.example to .env if needed");
+    lines.push("  6. Run pnpm install");
+    lines.push("  7. If the selected template has a default frontend target, install Playwright Chromium");
+    lines.push("  8. If the selected template has a default frontend target and bootstrap is not skipped, run frontend parity bootstrap");
+    return lines;
 }
 function renderTextStep(step, state, buffers, index, total) {
-    const lines = renderHeader(step, index, total);
     if (!buffers.has(step.key)) {
         buffers.set(step.key, String(stepValue(state, step) || ""));
     }
     const rawValue = buffers.get(step.key) || "";
     const displayValue = step.type === "password" ? "*".repeat(rawValue.length) : rawValue || step.placeholder || "";
-    lines.push(`Value: ${displayValue}`);
-    lines.push("");
-    lines.push("Controls: type text, Backspace to edit, Enter or → to continue, ← to go back.");
-    process.stdout.write(`${lines.join("\n")}\n`);
-    return lines.length;
+    return [
+        ...renderHeader(`Agentic Dev Init ${index + 1}/${total}`, step.label, step.description),
+        `Value: ${displayValue}`,
+        "",
+        "Controls",
+        "  ← previous screen",
+        "  → or Enter next screen",
+        "  Backspace edit",
+        "  Ctrl+C cancel",
+    ];
 }
 function renderSingleChoiceStep(step, state, cursors, index, total) {
-    const lines = renderHeader(step, index, total);
     if (!cursors.has(step.key)) {
         const currentValue = stepValue(state, step);
         const currentIndex = Math.max(0, step.choices.findIndex((choice) => choice.value === currentValue));
         cursors.set(step.key, currentIndex >= 0 ? currentIndex : 0);
     }
+    const lines = renderHeader(`Agentic Dev Init ${index + 1}/${total}`, step.label, step.description);
     const cursor = cursors.get(step.key) || 0;
     step.choices.forEach((choice, choiceIndex) => {
         const pointer = choiceIndex === cursor ? ">" : " ";
@@ -314,15 +369,18 @@ function renderSingleChoiceStep(step, state, cursors, index, total) {
         lines.push(`${pointer} ${choice.label}${suffix}`);
     });
     lines.push("");
-    lines.push("Controls: ↑/↓ to choose, Enter or → to continue, ← to go back.");
-    process.stdout.write(`${lines.join("\n")}\n`);
-    return lines.length;
+    lines.push("Controls");
+    lines.push("  ↑/↓ choose");
+    lines.push("  ← previous screen");
+    lines.push("  → or Enter next screen");
+    lines.push("  Ctrl+C cancel");
+    return lines;
 }
 function renderMultiChoiceStep(step, state, cursors, index, total) {
-    const lines = renderHeader(step, index, total);
     if (!cursors.has(step.key)) {
         cursors.set(step.key, 0);
     }
+    const lines = renderHeader(`Agentic Dev Init ${index + 1}/${total}`, step.label, step.description);
     const selected = new Set(uniqueStrings(stepValue(state, step) || []));
     const cursor = cursors.get(step.key) || 0;
     step.choices.forEach((choice, choiceIndex) => {
@@ -332,39 +390,16 @@ function renderMultiChoiceStep(step, state, cursors, index, total) {
         lines.push(`${pointer} ${checked} ${choice.label}${suffix}`);
     });
     lines.push("");
-    lines.push("Controls: ↑/↓ to move, Space to toggle, Enter or → to continue, ← to go back.");
-    process.stdout.write(`${lines.join("\n")}\n`);
-    return lines.length;
-}
-function executionPreview(state, selectedRepo) {
-    const lines = [
-        `Project directory: ${path.resolve(process.cwd(), state.targetDir)}`,
-        `Project name: ${state.projectName}`,
-        `GitHub repository: ${state.githubRepositoryInput}`,
-        `GitHub project mode: ${state.githubProjectMode}`,
-        `GitHub project title: ${state.githubProjectTitle}`,
-        `GitHub credential source: ${state.githubAuthMode}`,
-        `Template repo: ${selectedRepo?.name || state.template}`,
-        `AI providers: ${state.aiProviders.join(", ")}`,
-        `Provider profiles: ${state.providerProfiles.join(", ")}`,
-        `Allow non-empty directory: ${state.force ? "yes" : "no"}`,
-    ];
-    if (state.githubAuthMode === "pat") {
-        lines.push(`GitHub PAT supplied: ${state.githubPat ? "yes" : "no"}`);
-    }
-    lines.push("Run plan:");
-    lines.push(`  1. Ensure GitHub repo ${state.githubRepositoryInput}`);
-    lines.push(`  2. Ensure GitHub Project ${state.githubProjectTitle}`);
-    lines.push(`  3. Clone ${selectedRepo?.name || state.template}`);
-    lines.push("  4. Install shared sub-agent assets and orchestration workflow");
-    lines.push("  5. Copy .env.example to .env if needed");
-    lines.push("  6. Run pnpm install");
-    lines.push("  7. If the selected template has a default frontend target, install Playwright Chromium");
-    lines.push("  8. If the selected template has a default frontend target and bootstrap is not skipped, run frontend parity bootstrap");
+    lines.push("Controls");
+    lines.push("  ↑/↓ choose");
+    lines.push("  Space toggle");
+    lines.push("  ← previous screen");
+    lines.push("  → or Enter next screen");
+    lines.push("  Ctrl+C cancel");
     return lines;
 }
 function renderConfirmStep(step, state, repos, cursors, index, total) {
-    const lines = renderHeader(step, index, total);
+    const lines = renderHeader(`Agentic Dev Init ${index + 1}/${total}`, step.label, step.description);
     const selectedRepo = resolveTemplateRepo(state.template, repos);
     executionPreview(state, selectedRepo).forEach((line) => lines.push(line));
     lines.push("");
@@ -378,48 +413,73 @@ function renderConfirmStep(step, state, repos, cursors, index, total) {
         lines.push(`${pointer} ${choice.label}${suffix}`);
     });
     lines.push("");
-    lines.push("Controls: ↑/↓ to choose, Enter or → to confirm, ← to go back.");
-    process.stdout.write(`${lines.join("\n")}\n`);
-    return lines.length;
+    lines.push("Controls");
+    lines.push("  ↑/↓ choose");
+    lines.push("  ← previous screen");
+    lines.push("  → or Enter confirm");
+    lines.push("  Ctrl+C cancel");
+    return lines;
+}
+function truncateLine(line, width) {
+    if (width <= 0) {
+        return "";
+    }
+    if (line.length <= width) {
+        return line;
+    }
+    if (width <= 1) {
+        return line.slice(0, width);
+    }
+    return `${line.slice(0, width - 1)}…`;
 }
-async function runInteractiveSession(render, onInput) {
+function renderFullScreen(lines) {
+    const width = process.stdout.columns || 120;
+    const height = process.stdout.rows || 40;
+    const clipped = lines.map((line) => truncateLine(line, width)).slice(0, height);
+    while (clipped.length < height) {
+        clipped.push("");
+    }
+    process.stdout.write("\u001b[H\u001b[2J");
+    process.stdout.write(clipped.join("\n"));
+}
+async function runFullScreenSession(render, onInput) {
     const stdin = process.stdin;
     const stdout = process.stdout;
     const previousRawMode = typeof stdin.setRawMode === "function" ? stdin.isRaw : undefined;
+    const rerender = () => {
+        renderFullScreen(render());
+    };
+    stdout.write("\u001b[?1049h\u001b[?25l");
     if (typeof stdin.setRawMode === "function") {
         stdin.setRawMode(true);
     }
     stdin.resume();
     stdin.setEncoding("utf8");
     return new Promise((resolve, reject) => {
-        let renderedLines = render();
         const cleanup = () => {
             stdin.removeListener("data", handleData);
+            stdout.removeListener("resize", rerender);
             if (typeof stdin.setRawMode === "function") {
                 stdin.setRawMode(Boolean(previousRawMode));
             }
-            stdout.write("\n");
-        };
-        const rerender = () => {
-            clearMenu(renderedLines);
-            renderedLines = render();
+            stdout.write("\u001b[?25h\u001b[?1049l");
         };
         const handleData = (chunk) => {
             try {
                 const result = onInput(chunk, rerender);
                 if (result !== undefined) {
-                    clearMenu(renderedLines);
                     cleanup();
                     resolve(result);
                 }
             }
             catch (error) {
-                clearMenu(renderedLines);
                 cleanup();
                 reject(error);
             }
         };
+        stdout.on("resize", rerender);
         stdin.on("data", handleData);
+        rerender();
     });
 }
 function validateStepValue(step, state, value) {
@@ -464,7 +524,7 @@ function validateStepValue(step, state, value) {
     if (step.key === "providerProfiles") {
         const profiles = normalizeProviderProfiles(Array.isArray(value) ? value : []);
         if (profiles.length === 0) {
-            throw new Error("Select at least one provider profile.");
+            throw new Error("Select at least one execution adapter.");
         }
         return profiles;
     }
@@ -489,13 +549,12 @@ async function runWizard(initialState, repos) {
     const buffers = new Map();
     const cursors = new Map();
     let stepIndex = 0;
-    return runInteractiveSession(() => {
+    return runFullScreenSession(() => {
         const steps = buildSteps(state, repos);
         if (stepIndex >= steps.length) {
             stepIndex = steps.length - 1;
         }
         const step = steps[stepIndex];
-        process.stdout.write("\n");
         if (step.type === "text" || step.type === "password") {
             return renderTextStep(step, state, buffers, stepIndex, steps.length);
         }
@@ -684,7 +743,7 @@ async function promptLinearly(initialState, repos) {
         const projectTitleAnswer = await rl.question(`GitHub project title [${state.githubProjectTitle || `${state.projectName} Delivery`}]: `);
         state.githubProjectTitle = projectTitleAnswer.trim() || state.githubProjectTitle || `${state.projectName} Delivery`;
         state.template = await promptForChoice(rl, `Template repo from ${state.owner}`, buildTemplateChoices(repos));
-        state.providerProfiles = await promptForMultiChoice(rl, "AI runtime profiles", PROVIDER_PROFILE_CHOICES, state.providerProfiles);
+        state.providerProfiles = await promptForMultiChoice(rl, "AI execution adapters", PROVIDER_PROFILE_CHOICES, state.providerProfiles);
         state.aiProviders = await promptForMultiChoice(rl, "AI providers", AI_PROVIDER_CHOICES, state.aiProviders);
         if (!state.force && directoryHasUserFiles(state.targetDir)) {
             state.force = await promptForChoice(rl, "Target directory is not empty", [
@@ -758,6 +817,356 @@ function validateNonInteractiveState(state) {
     }
     return state;
 }
+function readJson(filePath) {
+    if (!fs.existsSync(filePath)) {
+        return null;
+    }
+    try {
+        return JSON.parse(fs.readFileSync(filePath, "utf-8"));
+    }
+    catch {
+        return null;
+    }
+}
+function readTaskList(snapshotRoot) {
+    const taskIndex = readJson(path.join(snapshotRoot, ".agentic-dev/generated/task-index.json"));
+    const indexed = Array.isArray(taskIndex?.tasks) ? taskIndex?.tasks : null;
+    if (indexed) {
+        return indexed.map((task) => ({
+            id: String(task.id || ""),
+            title: String(task.title || ""),
+            status: String(task.status || "open"),
+            source: String(task.source || ""),
+            issue_number: task.issue_number ?? null,
+            issue_url: task.issue_url ?? null,
+        }));
+    }
+    const taskIr = readJson(path.join(snapshotRoot, ".agentic-dev/generated/task-ir.json"));
+    const irTasks = Array.isArray(taskIr?.tasks) ? taskIr?.tasks : [];
+    return irTasks.map((task) => ({
+        id: String(task.id || ""),
+        title: String(task.title || ""),
+        status: String(task.status || "open"),
+        source: String(task.source || ""),
+        issue_number: null,
+        issue_url: null,
+    }));
+}
+function loadDashboardSnapshot(cwd) {
+    const setup = readJson(path.join(cwd, ".agentic-dev/setup.json"));
+    const orchestration = readJson(path.join(cwd, ".agentic-dev/orchestration.json"));
+    const queue = readJson(path.join(cwd, ".agentic-dev/generated/agent-queue.json"));
+    const dispatch = readJson(path.join(cwd, ".agentic-dev/generated/dispatch-plan.json"));
+    const journal = readJson(path.join(cwd, ".agentic-dev/generated/execution-journal.json"));
+    const closed = readJson(path.join(cwd, ".agentic-dev/generated/closed-tasks.json"));
+    const tasks = readTaskList(cwd);
+    const agents = Array.isArray(orchestration?.specialized_agents) ? orchestration?.specialized_agents : [];
+    const recentExecutions = Array.isArray(journal?.executions) ? journal?.executions : [];
+    return {
+        installed: Boolean(setup && orchestration),
+        cwd,
+        projectName: String(setup?.project_name || orchestration?.project_name || path.basename(cwd)),
+        templateRepo: String(setup?.template_repo || ""),
+        repositorySlug: String(orchestration?.github?.repository
+            ? (orchestration?.github).repository.slug || ""
+            : ""),
+        projectTitle: String(orchestration?.github?.project
+            ? (orchestration?.github).project.title || ""
+            : ""),
+        agentSurfaces: Array.isArray(setup?.ai_providers) ? setup?.ai_providers : [],
+        providers: Array.isArray(orchestration?.providers) ? orchestration?.providers : [],
+        agents: agents.map((agent) => ({
+            id: String(agent.id || ""),
+            description: String(agent.description || ""),
+        })),
+        tasks,
+        queueCount: Array.isArray(queue?.queue) ? queue.queue.length : 0,
+        dispatchCount: Array.isArray(dispatch?.dispatch) ? dispatch.dispatch.length : 0,
+        executionCount: recentExecutions.length,
+        closedCount: Array.isArray(closed?.closed) ? closed.closed.length : 0,
+        recentExecutions: recentExecutions
+            .map((item) => ({
+            task_id: String(item.task_id || ""),
+            title: String(item.title || ""),
+            provider: String(item.provider || ""),
+            adapter: String(item.adapter || ""),
+            execution_state: String(item.execution_state || ""),
+            started_at: item.started_at || "",
+            completed_at: item.completed_at || "",
+            issue_number: item.issue_number ?? null,
+            stdout: String(item.stdout || ""),
+            stderr: String(item.stderr || ""),
+        }))
+            .reverse(),
+    };
+}
+function selectedTab(tabIndex) {
+    return DASHBOARD_TABS[Math.max(0, Math.min(DASHBOARD_TABS.length - 1, tabIndex))];
+}
+function renderDashboardTabs(tabIndex) {
+    return DASHBOARD_TABS.map((tab, index) => (index === tabIndex ? `[${tab}]` : ` ${tab} `)).join("  ");
+}
+function dashboardList(state) {
+    const tab = selectedTab(state.tabIndex);
+    if (tab === "Agents") {
+        return state.snapshot.agents.map((agent) => `${agent.id} - ${agent.description}`);
+    }
+    if (tab === "Tasks") {
+        return state.snapshot.tasks.map((task) => {
+            const issue = task.issue_number ? ` #${task.issue_number}` : "";
+            return `${task.status.toUpperCase()} ${task.id}${issue} - ${task.title}`;
+        });
+    }
+    if (tab === "Activity") {
+        return state.snapshot.recentExecutions.map((execution) => {
+            return `${execution.execution_state.toUpperCase()} ${execution.task_id} via ${execution.adapter || execution.provider}`;
+        });
+    }
+    return [];
+}
+function clampDashboardCursor(state) {
+    const items = dashboardList(state);
+    if (items.length === 0) {
+        state.listCursor = 0;
+        return;
+    }
+    state.listCursor = Math.max(0, Math.min(state.listCursor, items.length - 1));
+}
+function renderOverview(snapshot) {
+    const openTasks = snapshot.tasks.filter((task) => task.status !== "closed").length;
+    const closedTasks = snapshot.tasks.filter((task) => task.status === "closed").length;
+    return [
+        `Project: ${snapshot.projectName}`,
+        `Template: ${snapshot.templateRepo || "(not recorded)"}`,
+        `Repository: ${snapshot.repositorySlug || "(not bound)"}`,
+        `GitHub Project: ${snapshot.projectTitle || "(not bound)"}`,
+        `Workspace surfaces: ${snapshot.agentSurfaces.join(", ") || "(none)"}`,
+        `Execution adapters: ${snapshot.providers.join(", ") || "(none)"}`,
+        "",
+        `Tasks: ${snapshot.tasks.length} total | ${openTasks} open | ${closedTasks} closed`,
+        `Queue: ${snapshot.queueCount} planned agent items`,
+        `Dispatch: ${snapshot.dispatchCount} dispatch items`,
+        `Executions: ${snapshot.executionCount} records`,
+        `Closed by close pass: ${snapshot.closedCount}`,
+    ];
+}
+function renderAgents(state) {
+    const items = dashboardList(state);
+    if (items.length === 0) {
+        return ["No specialized agents recorded in .agentic-dev/orchestration.json."];
+    }
+    return items.map((item, index) => `${index === state.listCursor ? ">" : " "} ${item}`);
+}
+function renderTasks(state) {
+    if (state.snapshot.tasks.length === 0) {
+        return ["No task IR or task index found yet."];
+    }
+    const selected = state.snapshot.tasks[state.listCursor];
+    const lines = state.snapshot.tasks.slice(0, 12).map((task, index) => `${index === state.listCursor ? ">" : " "} ${task.status.toUpperCase()} ${task.id} - ${task.title}`);
+    if (selected) {
+        lines.push("");
+        lines.push(`Selected source: ${selected.source || "(unknown)"}`);
+        lines.push(`Selected issue: ${selected.issue_number ? `#${selected.issue_number}` : "(not mirrored yet)"}`);
+    }
+    return lines;
+}
+function renderActivity(state) {
+    if (state.snapshot.recentExecutions.length === 0) {
+        return ["No execution journal found yet."];
+    }
+    const selected = state.snapshot.recentExecutions[state.listCursor];
+    const lines = state.snapshot.recentExecutions
+        .slice(0, 12)
+        .map((execution, index) => `${index === state.listCursor ? ">" : " "} ${execution.execution_state.toUpperCase()} ${execution.task_id} via ${execution.adapter || execution.provider}`);
+    if (selected) {
+        lines.push("");
+        lines.push(`Task: ${selected.title}`);
+        lines.push(`Started: ${selected.started_at || "(unknown)"}`);
+        lines.push(`Completed: ${selected.completed_at || "(unknown)"}`);
+        if (selected.stderr) {
+            lines.push(`stderr: ${selected.stderr}`);
+        }
+        else if (selected.stdout) {
+            lines.push(`stdout: ${selected.stdout.split(/\r?\n/)[0] || "(empty)"}`);
+        }
+    }
+    return lines;
+}
+function renderDashboard(state) {
+    const snapshot = state.snapshot;
+    const lines = renderHeader("Agentic Dev Dashboard", snapshot.installed
+        ? "Installed orchestration repo detected."
+        : "No .agentic-dev install found in the current working directory.", `cwd: ${snapshot.cwd}`);
+    lines.push(renderDashboardTabs(state.tabIndex));
+    lines.push("");
+    if (!snapshot.installed) {
+        lines.push("This command is the management TUI.");
+        lines.push("Initialize a repo first with:");
+        lines.push("  agentic-dev init");
+        lines.push("");
+        lines.push("Controls");
+        lines.push("  q quit");
+        lines.push("  r refresh");
+        return lines;
+    }
+    const tab = selectedTab(state.tabIndex);
+    if (tab === "Overview") {
+        lines.push(...renderOverview(snapshot));
+    }
+    else if (tab === "Agents") {
+        lines.push(...renderAgents(state));
+    }
+    else if (tab === "Tasks") {
+        lines.push(...renderTasks(state));
+    }
+    else {
+        lines.push(...renderActivity(state));
+    }
+    lines.push("");
+    lines.push(`Status: ${state.statusMessage}`);
+    lines.push("");
+    lines.push("Controls");
+    lines.push("  ←/→ switch tabs");
+    lines.push("  ↑/↓ move selection");
+    lines.push("  r refresh");
+    lines.push("  i build IR");
+    lines.push("  t sync GitHub tasks");
+    lines.push("  p plan queue");
+    lines.push("  d build dispatch");
+    lines.push("  e execute dispatch");
+    lines.push("  c close completed tasks");
+    lines.push("  q quit");
+    return lines;
+}
+function runDashboardAction(cwd, key) {
+    const scriptMap = {
+        i: ".agentic-dev/runtime/sdd_to_ir.ts",
+        t: ".agentic-dev/runtime/sync_project_tasks.ts",
+        p: ".agentic-dev/runtime/run_multi_agent_queue.ts",
+        d: ".agentic-dev/runtime/dispatch_agents.ts",
+        e: ".agentic-dev/runtime/dispatch_execute.ts",
+        c: ".agentic-dev/runtime/close_completed_tasks.ts",
+    };
+    const script = scriptMap[key];
+    if (!script) {
+        return "No action.";
+    }
+    if (!fs.existsSync(path.join(cwd, script))) {
+        throw new Error(`Missing runtime script: ${script}`);
+    }
+    const result = spawnSync("npx", ["--yes", "tsx", script], {
+        cwd,
+        encoding: "utf-8",
+        maxBuffer: 1024 * 1024 * 20,
+    });
+    if (result.status !== 0) {
+        throw new Error((result.stderr || result.stdout || `Failed to run ${script}`).trim());
+    }
+    return (result.stdout || `${script} ok`).trim().split(/\r?\n/).join(" | ");
+}
+async function runDashboard() {
+    if (!process.stdin.isTTY || !process.stdout.isTTY) {
+        throw new Error("Dashboard mode requires a TTY. Use `agentic-dev init` for non-interactive setup.");
+    }
+    const state = {
+        tabIndex: 0,
+        listCursor: 0,
+        snapshot: loadDashboardSnapshot(process.cwd()),
+        statusMessage: "Ready.",
+    };
+    clampDashboardCursor(state);
+    await runFullScreenSession(() => renderDashboard(state), (chunk, rerender) => {
+        if (chunk === "\u0003" || chunk.toLowerCase() === "q") {
+            return true;
+        }
+        if (chunk === "\u001b[C") {
+            state.tabIndex = (state.tabIndex + 1) % DASHBOARD_TABS.length;
+            clampDashboardCursor(state);
+            rerender();
+            return undefined;
+        }
+        if (chunk === "\u001b[D") {
+            state.tabIndex = (state.tabIndex - 1 + DASHBOARD_TABS.length) % DASHBOARD_TABS.length;
+            clampDashboardCursor(state);
+            rerender();
+            return undefined;
+        }
+        if (chunk === "\u001b[A") {
+            state.listCursor = Math.max(0, state.listCursor - 1);
+            rerender();
+            return undefined;
+        }
+        if (chunk === "\u001b[B") {
+            state.listCursor += 1;
+            clampDashboardCursor(state);
+            rerender();
+            return undefined;
+        }
+        const lower = chunk.toLowerCase();
+        if (lower === "r") {
+            state.snapshot = loadDashboardSnapshot(process.cwd());
+            clampDashboardCursor(state);
+            state.statusMessage = "Refreshed snapshot.";
+            rerender();
+            return undefined;
+        }
+        if ("itpdec".includes(lower)) {
+            if (!state.snapshot.installed) {
+                state.statusMessage = "Initialize the repo first with `agentic-dev init`.";
+                rerender();
+                return undefined;
+            }
+            try {
+                const actionOutput = runDashboardAction(process.cwd(), lower);
+                state.snapshot = loadDashboardSnapshot(process.cwd());
+                clampDashboardCursor(state);
+                state.statusMessage = actionOutput || "Action completed.";
+            }
+            catch (error) {
+                state.statusMessage = error instanceof Error ? error.message : String(error);
+            }
+            rerender();
+            return undefined;
+        }
+        return undefined;
+    });
+}
+async function runInitCommand(options) {
+    const state = hydrateOptions(options);
+    applyRuntimeGitHubAuth(state);
+    const repos = await fetchTemplateRepos({ owner: state.owner });
+    if (repos.length === 0) {
+        throw new Error(`No public template-* repos found for ${state.owner}.`);
+    }
+    const resolvedState = options.yes
+        ? validateNonInteractiveState(sanitizeStateForInstall(state))
+        : process.stdin.isTTY && process.stdout.isTTY
+            ? await runWizard(state, repos)
+            : await promptLinearly(state, repos);
+    applyRuntimeGitHubAuth(resolvedState);
+    const orchestration = await resolveGitHubOrchestration(resolvedState);
+    const selectedRepo = resolveTemplateRepo(resolvedState.template, repos);
+    if (!selectedRepo) {
+        throw new Error(`Template repo not found: ${resolvedState.template}`);
+    }
+    const destinationRoot = ensureTargetDir(resolvedState.targetDir, {
+        force: resolvedState.force,
+    });
+    const result = installTemplateRepo({
+        destinationRoot: path.resolve(destinationRoot),
+        templateRepo: selectedRepo,
+        setupSelections: {
+            ...resolvedState,
+            ...orchestration,
+        },
+        skipBootstrap: resolvedState.skipBootstrap,
+    });
+    finalizeRepositoryGit(path.resolve(destinationRoot), {
+        ...resolvedState,
+        ...orchestration,
+    });
+    printSuccess(result);
+}
 async function main() {
     let options;
     try {
@@ -774,10 +1183,11 @@ async function main() {
         console.log(usage());
         return;
     }
-    if (options.command !== "init") {
+    let command = options.command;
+    if (!["dashboard", "init"].includes(command)) {
         if (!options.targetDir) {
             options.targetDir = options.command;
-            options.command = "init";
+            command = "init";
         }
         else {
             console.error(`Unsupported command: ${options.command}`);
@@ -788,40 +1198,11 @@ async function main() {
         }
     }
     try {
-        const state = hydrateOptions(options);
-        applyRuntimeGitHubAuth(state);
-        const repos = await fetchTemplateRepos({ owner: state.owner });
-        if (repos.length === 0) {
-            throw new Error(`No public template-* repos found for ${state.owner}.`);
-        }
-        const resolvedState = options.yes
-            ? validateNonInteractiveState(sanitizeStateForInstall(state))
-            : process.stdin.isTTY && process.stdout.isTTY
-                ? await runWizard(state, repos)
-                : await promptLinearly(state, repos);
-        applyRuntimeGitHubAuth(resolvedState);
-        const orchestration = await resolveGitHubOrchestration(resolvedState);
-        const selectedRepo = resolveTemplateRepo(resolvedState.template, repos);
-        if (!selectedRepo) {
-            throw new Error(`Template repo not found: ${resolvedState.template}`);
-        }
-        const destinationRoot = ensureTargetDir(resolvedState.targetDir, {
-            force: resolvedState.force,
-        });
-        const result = installTemplateRepo({
-            destinationRoot: path.resolve(destinationRoot),
-            templateRepo: selectedRepo,
-            setupSelections: {
-                ...resolvedState,
-                ...orchestration,
-            },
-            skipBootstrap: resolvedState.skipBootstrap,
-        });
-        finalizeRepositoryGit(path.resolve(destinationRoot), {
-            ...resolvedState,
-            ...orchestration,
-        });
-        printSuccess(result);
+        if (command === "dashboard") {
+            await runDashboard();
+            return;
+        }
+        await runInitCommand(options);
     }
     catch (error) {
         console.error(error instanceof Error ? error.message : String(error));