agent-control-plane 0.1.14 → 0.2.0

package/npm/bin/agent-control-plane.js

@@ -22,6 +22,7 @@ Commands:
   help                 Show this help
   version              Print package version
   setup                Guided setup flow for one repo profile
+  onboard              Alias for setup
   sync                 Publish the packaged runtime into ~/.agent-runtime
   install              Alias for sync
   init                 Scaffold and adopt a project profile
@@ -56,7 +57,7 @@ Options:
   --retained-repo-root <path>  Manual checkout root to keep linked in the profile
   --vscode-workspace-file <path>
                                Workspace file path ACP should generate/use
-  --coding-worker <backend>    One of: codex, claude, openclaw
+  --coding-worker <backend>    One of: codex, claude, openclaw, ollama, pi, opencode, kilo
   --force                      Overwrite an existing profile
   --skip-anchor-sync           Skip profile-adopt anchor repo sync
   --skip-workspace-sync        Skip profile-adopt workspace sync
@@ -74,6 +75,11 @@ Options:
   --no-start-runtime           Do not start the runtime after setup
   --install-launchd            Install macOS autostart after a successful runtime start
   --no-install-launchd         Do not install macOS autostart
+  --start-dashboard            Start the dashboard in background after setup
+  --no-start-dashboard         Do not start the dashboard
+  --dashboard-port <port>      Dashboard port (default: 8765)
+  --create-starter-issues      Create recurring issues so ACP starts working immediately
+  --no-create-starter-issues   Skip starter issue creation
   --yes                        Accept detected defaults without prompting
   --non-interactive            Same as --yes
   --help                       Show this help
@@ -393,6 +399,9 @@ function parseSetupArgs(args) {
     json: false,
     startRuntime: null,
     installLaunchd: null,
+    startDashboard: null,
+    dashboardPort: 8765,
+    createStarterIssues: null,
     interactive: process.stdin.isTTY && process.stdout.isTTY,
     help: false
   };
@@ -480,6 +489,21 @@ function parseSetupArgs(args) {
       case "--no-install-launchd":
         options.installLaunchd = false;
         break;
+      case "--start-dashboard":
+        options.startDashboard = true;
+        break;
+      case "--no-start-dashboard":
+        options.startDashboard = false;
+        break;
+      case "--dashboard-port":
+        options.dashboardPort = parseInt(args[++index] || "8765", 10);
+        break;
+      case "--create-starter-issues":
+        options.createStarterIssues = true;
+        break;
+      case "--no-create-starter-issues":
+        options.createStarterIssues = false;
+        break;
       case "--yes":
       case "--non-interactive":
         options.interactive = false;
@@ -503,6 +527,20 @@ function createPromptInterface() {
   });
 }
 
+function printWizardBanner() {
+  console.log("============================================================");
+  console.log("  Agent Control Plane — Setup Wizard");
+  console.log("============================================================");
+  console.log("");
+  console.log("This wizard will guide you through setting up one repo profile.");
+  console.log("Press Enter at any prompt to accept the value shown in [brackets].");
+  console.log("");
+}
+
+function printWizardStep(step, total, title) {
+  console.log(`\n[${step}/${total}] ${title}`);
+}
+
 function question(rl, prompt) {
   return new Promise((resolve) => rl.question(prompt, resolve));
 }
@@ -528,6 +566,179 @@ async function promptYesNo(rl, label, defaultValue) {
   return defaultValue;
 }
 
+const STARTER_ISSUE_CATALOG = [
+  {
+    key: "code-quality",
+    title: "Keep code quality high: fix lint warnings, type errors, and dead code",
+    body: `## Recurring: Code Quality Sweep
+
+Checklist:
+- [ ] Fix any TypeScript / ESLint / type-check errors in the codebase
+- [ ] Remove dead exports, unused imports, and unreachable code paths
+- [ ] Resolve any TODO/FIXME comments that are straightforward to address
+
+Agent schedule: every 4h
+
+- Run \`pnpm typecheck\` (or the repo-equivalent lint/typecheck) after code changes and record verification.
+`,
+    labels: ["agent-ready", "agent-keep-open"]
+  },
+  {
+    key: "test-coverage",
+    title: "Improve test coverage for critical and untested modules",
+    body: `## Recurring: Test Coverage Improvement
+
+Checklist:
+- [ ] Identify source files with zero or minimal test coverage
+- [ ] Add focused unit or integration tests for the most critical untested paths
+- [ ] Ensure new tests actually run and pass in the local test runner
+
+Agent schedule: every 6h
+
+- Run the narrowest relevant test command after code changes and record verification.
+`,
+    labels: ["agent-ready", "agent-keep-open"]
+  },
+  {
+    key: "documentation",
+    title: "Keep documentation accurate and up to date",
+    body: `## Recurring: Documentation Refresh
+
+Checklist:
+- [ ] Update README sections that are outdated or reference removed features
+- [ ] Add or fix JSDoc / inline comments for public APIs that lack them
+- [ ] Ensure setup instructions and examples still work on a clean checkout
+
+Agent schedule: every 8h
+
+- Run any doc-build or link-check command after changes and record verification.
+`,
+    labels: ["agent-ready", "agent-keep-open"]
+  },
+  {
+    key: "dependency-audit",
+    title: "Audit and update dependencies for security and freshness",
+    body: `## Recurring: Dependency Audit
+
+Checklist:
+- [ ] Run the package manager audit and fix any critical/high vulnerabilities
+- [ ] Update patch-level dependencies that have safe upgrades available
+- [ ] Verify the lockfile is consistent after changes
+
+Agent schedule: every 12h
+
+- Run \`pnpm audit\` and \`pnpm install --frozen-lockfile\` after changes and record verification.
+`,
+    labels: ["agent-ready", "agent-keep-open"]
+  },
+  {
+    key: "refactor",
+    title: "Refactor complex or duplicated code for maintainability",
+    body: `## Recurring: Refactoring Sweep
+
+Checklist:
+- [ ] Identify functions or modules with high complexity or duplication
+- [ ] Extract shared logic into well-named helpers or utilities
+- [ ] Ensure refactored code passes existing tests without behavior changes
+
+Agent schedule: every 8h
+
+- Run the narrowest relevant test command after refactoring and record verification.
+`,
+    labels: ["agent-ready", "agent-keep-open"]
+  }
+];
+
+async function maybeCreateStarterIssues(options, config, prereq) {
+  const result = { status: "skipped", created: [], reason: "not-requested" };
+
+  if (options.createStarterIssues === false) {
+    return result;
+  }
+
+  if (!prereq.ghAuthOk) {
+    result.reason = "gh-auth-not-ready";
+    return result;
+  }
+
+  let shouldCreate = options.createStarterIssues === true;
+  if (!shouldCreate && options.interactive) {
+    const rl0 = createPromptInterface();
+    try {
+      shouldCreate = await promptYesNo(rl0, "\nCreate starter issues so ACP starts working immediately", true);
+    } finally {
+      rl0.close();
+    }
+  }
+  if (!shouldCreate) {
+    return result;
+  }
+
+  let toCreate;
+  if (options.interactive) {
+    const rlSel = createPromptInterface();
+    try {
+      console.log("\nSelect which recurring issues to create (ACP will work on these continuously):\n");
+      const selections = [];
+      for (const issue of STARTER_ISSUE_CATALOG) {
+        const selected = await promptYesNo(rlSel, `  ${issue.title}`, true);
+        selections.push({ issue, selected });
+      }
+      toCreate = selections.filter((s) => s.selected);
+    } finally {
+      rlSel.close();
+    }
+  } else {
+    // Non-interactive: create all starter issues
+    toCreate = STARTER_ISSUE_CATALOG.map((issue) => ({ issue, selected: true }));
+  }
+
+  if (toCreate.length === 0) {
+    console.log("No issues selected.");
+    return result;
+  }
+
+  // Ensure labels exist
+  console.log("\nCreating labels and issues...");
+  const requiredLabels = [
+    { name: "agent-ready", color: "0E8A16", description: "Ready for agent automation" },
+    { name: "agent-keep-open", color: "D4C5F9", description: "Recurring issue — agent works on this continuously" }
+  ];
+  for (const label of requiredLabels) {
+    spawnSync("gh", ["label", "create", label.name, "--repo", config.repoSlug, "--description", label.description, "--color", label.color, "--force"], { stdio: "pipe", timeout: 15000 });
+  }
+
+  for (const { issue } of toCreate) {
+    const ghArgs = [
+      "issue", "create",
+      "--repo", config.repoSlug,
+      "--title", issue.title,
+      "--body", issue.body,
+      "--label", issue.labels.join(",")
+    ];
+    const ghResult = spawnSync("gh", ghArgs, { encoding: "utf8", stdio: "pipe", timeout: 30000 });
+    if (ghResult.status === 0) {
+      const url = (ghResult.stdout || "").trim();
+      result.created.push({ key: issue.key, title: issue.title, url });
+      console.log(`  Created: ${issue.title}`);
+      if (url) {
+        console.log(`           ${url}`);
+      }
+    } else {
+      console.log(`  Failed to create: ${issue.title}`);
+      const stderr = (ghResult.stderr || "").trim();
+      if (stderr) {
+        console.log(`           ${stderr.split("\n")[0]}`);
+      }
+    }
+  }
+
+  result.status = result.created.length > 0 ? "ok" : "failed";
+  result.reason = "";
+
+  return result;
+}
+
 function buildSetupPaths(platformHome, repoRoot, profileId, overrides) {
   const agentRoot = path.resolve(overrides.agentRoot || path.join(platformHome, "projects", profileId));
   const repoRootResolved = path.resolve(repoRoot);
@@ -575,6 +786,9 @@ function detectPackageManager() {
   if (commandExists("pacman")) {
     return { name: "pacman" };
   }
+  if (commandExists("zypper")) {
+    return { name: "zypper" };
+  }
   return null;
 }
 
@@ -665,6 +879,9 @@ function buildDependencyInstallPlan(missingTools) {
     case "pacman":
       commands.push([...prefix, "pacman", "-Sy", "--noconfirm", ...packages]);
       break;
+    case "zypper":
+      commands.push([...prefix, "zypper", "install", "-y", ...packages]);
+      break;
     default:
       return null;
   }
@@ -706,7 +923,7 @@ async function maybeInstallMissingDependencies(options, prereq) {
   if (!plan) {
     console.log("\nACP found missing core dependencies but cannot install them automatically on this machine.");
     console.log(`- missing tools: ${prereq.missingRequired.join(", ")}`);
-    console.log("- supported auto-install package managers today: brew, apt-get, dnf, yum, pacman");
+    console.log("- supported auto-install package managers today: brew, apt-get, dnf, yum, pacman, zypper");
     return {
       status: "unavailable",
       reason: "no-supported-package-manager",
@@ -1340,8 +1557,13 @@ function printSetupDryRunPlan(context, config, plan) {
     console.log(`  command preview: ${plan.workerInstallPlan.commands.map(formatCommand).join(" && ")}`);
   }
   console.log(`- GitHub auth step: ${plan.githubAuthAction.status}${plan.githubAuthAction.reason ? ` (${plan.githubAuthAction.reason})` : ""}`);
+  if (plan.githubAuthAction.status !== "not-needed") {
+    console.log(`  command preview: gh auth login`);
+  }
   console.log(`- runtime start: ${plan.runtimeStartAction.status}${plan.runtimeStartAction.reason ? ` (${plan.runtimeStartAction.reason})` : ""}`);
-  console.log(`- launchd install: ${plan.launchdAction.status}${plan.launchdAction.reason ? ` (${plan.launchdAction.reason})` : ""}`);
+  if (process.platform === "darwin") {
+    console.log(`- launchd install: ${plan.launchdAction.status}${plan.launchdAction.reason ? ` (${plan.launchdAction.reason})` : ""}`);
+  }
 }
 
 function buildSetupResultPayload(params) {
@@ -1457,6 +1679,23 @@ async function maybeRunFinalSetupFixups(options, scopedContext, config, currentS
     console.log(`- ${issue}`);
   }
 
+  // Always show actionable hints so operators know what to fix,
+  // even when running non-interactively (--yes / --json / CI).
+  if (!currentState.prereq.coreToolsOk) {
+    const missing = currentState.prereq.missingRequired.join(", ");
+    console.log(`  Fix: install missing core tools (${missing})`);
+  }
+  if (!currentState.prereq.workerAvailable) {
+    const worker = currentState.prereq.workerCommand;
+    if (worker === "codex") console.log("  Fix: npm install -g @openai/codex && codex login");
+    else if (worker === "openclaw") console.log("  Fix: npm install -g openclaw && openclaw setup");
+    else if (worker === "claude") console.log("  Fix: npm install -g @anthropic-ai/claude-code && claude auth login");
+    else console.log(`  Fix: install ${worker} and add it to PATH`);
+  }
+  if (!currentState.prereq.ghAuthOk) {
+    console.log("  Fix: run gh auth login");
+  }
+
   if (!options.interactive) {
     return {
       status: "skipped",
@@ -1597,25 +1836,26 @@ async function collectSetupConfig(options, context) {
       throw new Error("setup could not detect --repo-slug automatically; pass --repo-slug <owner/repo> or run interactively inside a git checkout with origin set");
     }
   } else {
+    printWizardBanner();
     const rl = createPromptInterface();
     try {
-      console.log("ACP setup will guide one repo profile from install to operator-ready defaults.");
-      console.log("Press Enter to accept the suggested value shown in brackets.\n");
+      printWizardStep(1, 4, "Project details");
 
       repoRoot = path.resolve(await promptText(rl, "Local repo root", detectedRepoRoot));
       repoSlug = await promptText(rl, "GitHub repo slug", repoSlug || "");
       profileId = sanitizeProfileId(await promptText(rl, "Profile id", profileId));
-      codingWorker = await promptText(rl, "Coding worker (codex|claude|openclaw)", codingWorker);
 
-      if (!["codex", "claude", "openclaw"].includes(codingWorker)) {
-        throw new Error(`unsupported coding worker: ${codingWorker}`);
+      let workerInput = codingWorker;
+      while (!["codex", "claude", "openclaw", "ollama", "pi", "opencode", "kilo"].includes(workerInput)) {
+        workerInput = await promptText(rl, "Coding worker (codex / claude / openclaw / ollama / pi / opencode / kilo)", codingWorker || "openclaw");
       }
+      codingWorker = workerInput;
     } finally {
       rl.close();
     }
   }
 
-  if (!["codex", "claude", "openclaw"].includes(codingWorker)) {
+  if (!["codex", "claude", "openclaw", "ollama", "pi", "opencode", "kilo"].includes(codingWorker)) {
     throw new Error(`unsupported coding worker: ${codingWorker}`);
   }
 
@@ -1630,6 +1870,9 @@ async function collectSetupConfig(options, context) {
     prereq
   };
 
+  if (options.interactive) {
+    printWizardStep(2, 4, "Review plan");
+  }
   renderSetupSummary(config);
 
   if (options.interactive) {
@@ -1641,7 +1884,7 @@ async function collectSetupConfig(options, context) {
       }
       const shouldContinue = await promptYesNo(rl, "Continue with these values", true);
       if (!shouldContinue) {
-        throw new Error("setup cancelled");
+        return null;
       }
       if (options.startRuntime === null) {
         options.startRuntime = await promptYesNo(rl, "Start the runtime after setup", true);
@@ -1649,6 +1892,9 @@ async function collectSetupConfig(options, context) {
       if (process.platform === "darwin" && options.installLaunchd === null && options.startRuntime) {
         options.installLaunchd = await promptYesNo(rl, "Install macOS autostart for this profile", false);
       }
+      if (options.startDashboard === null) {
+        options.startDashboard = await promptYesNo(rl, "Start the monitoring dashboard in background", true);
+      }
     } finally {
       rl.close();
     }
@@ -1660,11 +1906,16 @@ async function collectSetupConfig(options, context) {
   if (options.installLaunchd === null) {
     options.installLaunchd = false;
   }
+  if (options.startDashboard === null) {
+    options.startDashboard = false;
+  }
 
   return {
     ...config,
     startRuntime: Boolean(options.startRuntime),
-    installLaunchd: Boolean(options.installLaunchd)
+    installLaunchd: Boolean(options.installLaunchd),
+    startDashboard: Boolean(options.startDashboard),
+    dashboardPort: options.dashboardPort
   };
 }
 
@@ -1733,6 +1984,10 @@ async function runSetupFlow(forwardedArgs) {
 
   try {
     const config = await collectSetupConfig(options, context);
+    if (config === null) {
+      console.log("\nSetup cancelled. Run again when you are ready.");
+      return 0;
+    }
     if (options.dryRun) {
       const plan = buildSetupDryRunPlan(options, context, config);
       printSetupDryRunPlan(context, config, plan);
@@ -1869,6 +2124,10 @@ async function runSetupFlow(forwardedArgs) {
       return 1;
     }
 
+    if (options.interactive) {
+      printWizardStep(3, 4, "Prerequisites");
+    }
+
     let prereq = config.prereq;
     let dependencyInstall = await maybeInstallMissingDependencies(options, prereq);
     if (dependencyInstall.status === "failed") {
@@ -1886,6 +2145,59 @@ async function runSetupFlow(forwardedArgs) {
     let workerSetupStep = await maybeShowWorkerSetupGuide(options, prereq);
     prereq = collectPrereqStatus(config.codingWorker);
 
+    // Check OpenRouter API key when openclaw or pi is selected
+    if ((config.codingWorker === "openclaw" || config.codingWorker === "pi") && !process.env.OPENROUTER_API_KEY) {
+      const workerLabel = config.codingWorker === "openclaw" ? "OpenClaw" : "Pi";
+      console.log(`\n${workerLabel} requires an OpenRouter API key (OPENROUTER_API_KEY).`);
+      console.log("- Get a free key at: https://openrouter.ai/keys");
+      if (options.interactive) {
+        const rl = createPromptInterface();
+        let apiKey = "";
+        try {
+          apiKey = (await promptText(rl, "OpenRouter API key (Enter to skip)", "")).trim();
+        } finally {
+          rl.close();
+        }
+        if (apiKey) {
+          process.env.OPENROUTER_API_KEY = apiKey;
+          console.log("API key set for this session.");
+          console.log("To persist it, add the following to your shell profile (~/.zshrc or ~/.bashrc):");
+          console.log(`  export OPENROUTER_API_KEY=${JSON.stringify(apiKey)}`);
+        } else {
+          console.log("Skipped. Set OPENROUTER_API_KEY before starting the runtime.");
+        }
+      } else {
+        console.log("Set OPENROUTER_API_KEY in your environment before starting the runtime.");
+      }
+    }
+
+    // Check Ollama readiness when ollama is selected
+    if (config.codingWorker === "ollama") {
+      const ollamaRunning = spawnSync("curl", ["-sf", "http://localhost:11434/api/tags"], { timeout: 5000 });
+      if (ollamaRunning.status !== 0) {
+        console.log("\nOllama does not appear to be running at http://localhost:11434.");
+        console.log("- Install from: https://ollama.com");
+        console.log("- Start it with: ollama serve");
+      } else {
+        console.log("\nOllama is running. Checking available models...");
+        try {
+          const tagsJson = JSON.parse(ollamaRunning.stdout.toString());
+          const modelNames = (tagsJson.models || []).map((m) => m.name || m.model || "").filter(Boolean);
+          if (modelNames.length === 0) {
+            console.log("No models pulled yet. Pull one with: ollama pull qwen2.5-coder:7b");
+          } else {
+            console.log(`Available models: ${modelNames.slice(0, 5).join(", ")}${modelNames.length > 5 ? ` (+${modelNames.length - 5} more)` : ""}`);
+          }
+        } catch (_) {
+          console.log("Could not parse model list. Ensure a model is pulled: ollama pull qwen2.5-coder:7b");
+        }
+      }
+    }
+
+    if (options.interactive) {
+      printWizardStep(4, 4, "Install");
+    }
+
     const scopedContext = buildScopedContext(context, config.profileId);
     const anchorSync = buildAnchorSyncDecision(options, config.paths.sourceRepoRoot);
 
@@ -1973,6 +2285,56 @@ async function runSetupFlow(forwardedArgs) {
       }
     }
 
+    let dashboardStatus = "skipped";
+    let dashboardReason = "not-requested";
+    let dashboardUrl = "";
+    if (config.startDashboard) {
+      const dashboardScript = path.join(scopedContext.stableSkillRoot || scopedContext.packageRoot, "tools", "bin", "serve-dashboard.sh");
+      const dashboardLogDir = path.join(config.paths.agentRoot || context.platformHome, "dashboard-logs");
+      fs.mkdirSync(dashboardLogDir, { recursive: true });
+      const dashboardLogFile = path.join(dashboardLogDir, "dashboard.log");
+      const dashboardPidFile = path.join(dashboardLogDir, "dashboard.pid");
+
+      // Kill any existing dashboard on the same port
+      try {
+        if (fs.existsSync(dashboardPidFile)) {
+          const oldPid = fs.readFileSync(dashboardPidFile, "utf8").trim();
+          if (oldPid && /^\d+$/.test(oldPid)) {
+            try { process.kill(Number(oldPid), "SIGTERM"); } catch (_) { /* already dead */ }
+          }
+        }
+      } catch (_) { /* ignore */ }
+
+      console.log(`\n== Start dashboard (background, port ${config.dashboardPort}) ==`);
+      syncRuntimeHome(context, { stdio: "pipe" });
+      const rtCtx = createRuntimeExecutionContext(context);
+      const rtDashboardScript = path.join(rtCtx.stableSkillRoot, "tools", "bin", "serve-dashboard.sh");
+      const { spawn } = require("child_process");
+      const logHandle = fs.openSync(dashboardLogFile, "a");
+      const dashboardProc = spawn("bash", [rtDashboardScript, "--host", "127.0.0.1", "--port", String(config.dashboardPort)], {
+        detached: true,
+        stdio: ["ignore", logHandle, logHandle],
+        env: { ...process.env, ACP_PROFILE_REGISTRY_ROOT: context.profileRegistryRoot }
+      });
+      dashboardProc.unref();
+      fs.closeSync(logHandle);
+
+      if (dashboardProc.pid) {
+        fs.writeFileSync(dashboardPidFile, `${dashboardProc.pid}\n`);
+        dashboardUrl = `http://127.0.0.1:${config.dashboardPort}`;
+        dashboardStatus = "ok";
+        dashboardReason = "";
+        console.log(`Dashboard running at ${dashboardUrl} (PID ${dashboardProc.pid})`);
+        console.log(`Log: ${dashboardLogFile}`);
+      } else {
+        dashboardStatus = "failed";
+        dashboardReason = "spawn-failed";
+        console.log("Dashboard failed to start.");
+      }
+    }
+
+    const starterIssues = await maybeCreateStarterIssues(options, config, prereq);
+
     const finalFixup = await maybeRunFinalSetupFixups(options, scopedContext, config, {
       anchorSync,
       prereq,
@@ -2047,12 +2409,71 @@ async function runSetupFlow(forwardedArgs) {
 
     if (options.json) {
       emitSetupJsonPayload(runPayload);
+    } else if (options.interactive) {
+      // Human-friendly summary for interactive terminal runs
+      console.log("\n============================================================");
+      console.log("  Setup complete!");
+      console.log("============================================================");
+      console.log(`  Profile : ${config.profileId}`);
+      console.log(`  Repo    : ${config.repoSlug}`);
+      console.log(`  Worker  : ${config.codingWorker}`);
+      console.log(`  Runtime : ${context.runtimeHome}`);
+
+      const pendingItems = [];
+      if (!prereq.ghAuthOk) pendingItems.push("GitHub CLI not authenticated — run: gh auth login");
+      if (!prereq.workerAvailable) pendingItems.push(`${config.codingWorker} not found on PATH — install it before starting`);
+      if (config.codingWorker === "openclaw" && !process.env.OPENROUTER_API_KEY) {
+        pendingItems.push("OPENROUTER_API_KEY not set — required for openclaw workers");
+      }
+      if (anchorSync.status !== "ok") pendingItems.push(`Anchor repo sync deferred (${anchorSync.reason}) — fix git access and re-run setup`);
+      if ((doctorKv.DOCTOR_STATUS || "") !== "ok") pendingItems.push(`Doctor check flagged issues — run: npx agent-control-plane@latest doctor`);
+
+      if (pendingItems.length > 0) {
+        console.log("\n  Pending items before starting:");
+        for (const item of pendingItems) {
+          console.log(`    - ${item}`);
+        }
+      }
+
+      if (dashboardStatus === "ok" && dashboardUrl) {
+        console.log(`\n  Dashboard: ${dashboardUrl}`);
+      }
+
+      console.log("\n  Next commands:");
+      if (runtimeStartStatus !== "ok") {
+        console.log(`    npx agent-control-plane@latest runtime start --profile-id ${config.profileId}`);
+      }
+      console.log(`    npx agent-control-plane@latest runtime status --profile-id ${config.profileId}`);
+      if (dashboardStatus !== "ok") {
+        console.log(`    npx agent-control-plane@latest dashboard`);
+      }
+      console.log(`    npx agent-control-plane@latest doctor`);
+
+      if (starterIssues.created.length > 0) {
+        console.log("\n  Starter issues created (ACP will start working on these):");
+        for (const issue of starterIssues.created) {
+          console.log(`    - ${issue.title}`);
+          if (issue.url) {
+            console.log(`      ${issue.url}`);
+          }
+        }
+      } else {
+        console.log("\n  Getting started:");
+        console.log(`    1. Add the label 'agent-ready' to a GitHub issue in ${config.repoSlug}`);
+        console.log("    2. ACP picks it up automatically, assigns a worker, and opens a PR");
+        console.log("    3. Watch progress in the dashboard or with 'runtime status'");
+      }
+      if (config.codingWorker === "openclaw" || config.codingWorker === "pi") {
+        console.log(`\n  Tip: ${config.codingWorker} uses free-tier models by default.`);
+        console.log("  No API costs until you switch to a paid model in the profile YAML.");
+      }
+      console.log("");
     } else {
+      // Machine-readable KV output for non-interactive / scripted runs
       console.log("\nSetup complete.");
       console.log(`- profile: ${config.profileId}`);
       console.log(`- repo: ${config.repoSlug}`);
       console.log(`- runtime home: ${context.runtimeHome}`);
-      console.log(`- next status command: npx agent-control-plane@latest runtime status --profile-id ${config.profileId}`);
 
       console.log(`SETUP_STATUS=ok`);
       console.log(`PROFILE_ID=${config.profileId}`);
@@ -2170,6 +2591,7 @@ async function main() {
       console.log(packageJson.version);
       return 0;
     case "setup":
+    case "onboard":
       return runSetupFlow(forwardedArgs);
     case "sync":
     case "install":

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-control-plane",
-  "version": "0.1.14",
+  "version": "0.2.0",
   "description": "Help a repo keep GitHub-driven coding agents running reliably without constant human babysitting",
   "homepage": "https://github.com/ducminhnguyen0319/agent-control-plane",
   "bugs": {

package/references/architecture.md

@@ -41,10 +41,18 @@ flowchart LR
   Router --> Codex["agent-project-run-codex-session"]
   Router --> Claude["agent-project-run-claude-session"]
   Router --> OpenClaw["agent-project-run-openclaw-session"]
+  Router --> Ollama["agent-project-run-ollama-session"]
+  Router --> Pi["agent-project-run-pi-session"]
+  Router --> OpenCode["agent-project-run-opencode-session"]
+  Router --> Kilo["agent-project-run-kilo-session"]
 
   Codex --> Artifacts["run.env / runner.env /\nresult.env / verification.jsonl"]
   Claude --> Artifacts
   OpenClaw --> Artifacts
+  Ollama --> Artifacts
+  Pi --> Artifacts
+  OpenCode --> Artifacts
+  Kilo --> Artifacts
 
   Artifacts --> Reconcile["reconcile-issue-worker.sh\nreconcile-pr-worker.sh"]
   Reconcile --> GitHub["GitHub issues / PRs / labels / comments"]

package/references/control-plane-map.md

@@ -36,10 +36,14 @@ roots, labels, worker preferences, prompts, and project-specific guardrails.
   Launches Claude-backed worker sessions.
 - `tools/bin/agent-project-run-openclaw-session`
   Launches OpenClaw-backed worker sessions.
+- `tools/bin/agent-project-run-ollama-session`
+  Launches Ollama-backed worker sessions with a Node.js agentic loop.
+- `tools/bin/agent-project-run-pi-session`
+  Launches Pi-backed worker sessions in `--print --no-session` mode.
 - `tools/bin/agent-project-run-opencode-session`
-  Placeholder adapter stub for the planned `opencode` backend.
+  Launches Crush (formerly OpenCode) worker sessions via `crush run`.
 - `tools/bin/agent-project-run-kilo-session`
-  Placeholder adapter stub for the planned `kilo` backend.
+  Launches Kilo Code worker sessions via `kilo run --auto --format json`.
 - `tools/bin/project-init.sh`
   Runs scaffold + smoke + adopt + runtime sync for one installed profile.
 - `tools/bin/scaffold-profile.sh`

package/references/release-checklist.md

@@ -9,8 +9,6 @@ Maintainer checklist for shipping a new public package release of
 - confirm `package.json` version is intentional
 - review `CHANGELOG.md` and prepare release notes from
   `.github/release-template.md`
-- refresh README demo media if the dashboard UI changed:
-  `bash tools/bin/render-dashboard-demo-media.sh`
 - review `README.md`, `SECURITY.md`, `CONTRIBUTING.md`, and `CLA.md` for stale
   links or policy text
 - if a public GitHub repo now exists, set or verify the `homepage`,