@dadado/agent-kit-cli 4.6.0 → 4.7.0

package/dist/index.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 
 // src/index.ts
-import { defineCommand as defineCommand12, runMain } from "citty";
+import { defineCommand as defineCommand13, runMain } from "citty";
 
 // src/commands/add.ts
 import { defineCommand } from "citty";
@@ -997,6 +997,10 @@ var L0_ARTIFACTS = [
   },
   { source: ".cursor/commands/handoff.md", target: ".cursor/commands/handoff.md" },
   { source: ".cursor/commands/summary.md", target: ".cursor/commands/summary.md" },
+  {
+    source: ".cursor/commands/dashboard.md",
+    target: ".cursor/commands/dashboard.md"
+  },
   {
     source: ".cursor/commands/git-staging.md",
     target: ".cursor/commands/git-staging.md"
@@ -1350,12 +1354,75 @@ var contributeCommand = defineCommand2({
   }
 });
 
-// src/commands/diff.ts
+// src/commands/dashboard.ts
+import { spawn } from "child_process";
+import { access as access2 } from "fs/promises";
+import path9 from "path";
 import { defineCommand as defineCommand3 } from "citty";
+async function findDashboardStart(cwd) {
+  let dir = path9.resolve(cwd);
+  for (; ; ) {
+    const candidate2 = path9.join(dir, "dashboard", "start.mjs");
+    try {
+      await access2(candidate2);
+      return candidate2;
+    } catch {
+    }
+    const parent = path9.dirname(dir);
+    if (parent === dir) return null;
+    dir = parent;
+  }
+}
+function runStartScript(startPath, env) {
+  return new Promise((resolve, reject) => {
+    const child = spawn(process.execPath, [startPath], {
+      cwd: path9.dirname(path9.dirname(startPath)),
+      env,
+      stdio: "inherit"
+    });
+    child.on("error", reject);
+    child.on("close", (code) => resolve(code ?? 1));
+  });
+}
+var dashboardCommand = defineCommand3({
+  meta: {
+    name: "dashboard",
+    description: "Start Mission Control if needed and open http://localhost:3333 (terminal counterpart to /dashboard)."
+  },
+  args: {
+    cwd: {
+      type: "string",
+      default: process.cwd(),
+      description: "Directory to search upward for dashboard/start.mjs"
+    },
+    "no-open": {
+      type: "boolean",
+      default: false,
+      description: "Do not open a browser; only ensure the server is up and print the URL"
+    }
+  },
+  async run({ args }) {
+    const startPath = await findDashboardStart(args.cwd);
+    if (!startPath) {
+      logger.error(
+        "No dashboard/start.mjs found. Mission Control ships with the agent-kit repo; run from that tree, or use npm run dashboard there."
+      );
+      process.exitCode = 1;
+      return;
+    }
+    const env = { ...process.env };
+    if (args["no-open"]) env.MISSION_CONTROL_NO_OPEN = "1";
+    const code = await runStartScript(startPath, env);
+    if (code !== 0) process.exitCode = code;
+  }
+});
+
+// src/commands/diff.ts
+import { defineCommand as defineCommand4 } from "citty";
 
 // src/lifecycle/diff.ts
 import { readFile as readFile5 } from "fs/promises";
-import path9 from "path";
+import path10 from "path";
 async function readIfExists(abs) {
   try {
     return await readFile5(abs, "utf8");
@@ -1364,7 +1431,7 @@ async function readIfExists(abs) {
   }
 }
 async function comparePair(registryRoot, projectRoot, sourceRel, targetRel, protectedGlobs) {
-  const posixTarget = targetRel.split(path9.sep).join("/");
+  const posixTarget = targetRel.split(path10.sep).join("/");
   if (isProtectedPath(posixTarget, protectedGlobs)) {
     return { path: posixTarget, status: "protected" };
   }
@@ -1394,7 +1461,7 @@ async function diffAgainstRegistry(registryRoot, projectRoot, manifest) {
   const entries = [];
   const seen = /* @__PURE__ */ new Set();
   const pushUnique = async (sourceRel, targetRel) => {
-    const key = targetRel.split(path9.sep).join("/");
+    const key = targetRel.split(path10.sep).join("/");
     if (seen.has(key)) return;
     seen.add(key);
     entries.push(
@@ -1421,8 +1488,8 @@ async function diffAgainstRegistry(registryRoot, projectRoot, manifest) {
         continue;
       }
       const category = skill.path.includes("/core/") ? "core" : "community";
-      const sourceRel = path9.posix.join(skill.path, "SKILL.md");
-      const targetRel = path9.posix.join(".cursor", "skills", category, skill.id, "SKILL.md");
+      const sourceRel = path10.posix.join(skill.path, "SKILL.md");
+      const targetRel = path10.posix.join(".cursor", "skills", category, skill.id, "SKILL.md");
       await pushUnique(sourceRel, targetRel);
     }
   }
@@ -1441,7 +1508,7 @@ function summarizeDiff(entries) {
 }
 
 // src/commands/diff.ts
-var diffCommand = defineCommand3({
+var diffCommand = defineCommand4({
   meta: {
     name: "diff",
     description: "Compare installed kit artifacts to the registry (respects L3 protected)."
@@ -1490,8 +1557,8 @@ var diffCommand = defineCommand3({
 });
 
 // src/commands/doctor.ts
-import path19 from "path";
-import { defineCommand as defineCommand4 } from "citty";
+import path20 from "path";
+import { defineCommand as defineCommand5 } from "citty";
 
 // src/scanner/readiness.ts
 import { createHash as createHash2 } from "crypto";
@@ -1741,11 +1808,11 @@ function createReadinessReport(scan, options) {
 
 // src/scanner/safe-fixes.ts
 import { readFile as readFile8, writeFile as writeFile3 } from "fs/promises";
-import path17 from "path";
+import path18 from "path";
 
 // src/scanner/detect-repository.ts
 import { readFile as readFile6 } from "fs/promises";
-import path10 from "path";
+import path11 from "path";
 var CONTEXT_PATHS = [
   ["README.md", "README"],
   ["README", "README"],
@@ -1764,7 +1831,7 @@ var CONTEXT_PATHS = [
 async function existingEvidence(rootDir, candidates) {
   const evidence = await Promise.all(
     candidates.map(
-      async ([relativePath, label]) => await fileExists(path10.join(rootDir, relativePath)) ? { source: "file", value: `${relativePath}:${label}` } : void 0
+      async ([relativePath, label]) => await fileExists(path11.join(rootDir, relativePath)) ? { source: "file", value: `${relativePath}:${label}` } : void 0
     )
   );
   return evidence.flatMap((item) => item ? [item] : []);
@@ -1785,7 +1852,7 @@ async function detectContext(rootDir) {
 async function detectPurpose(rootDir, stack) {
   const entries = await listDirectory(rootDir);
   const lowerEntries = entries.map((entry) => entry.toLowerCase());
-  const packageJson = await readJson(path10.join(rootDir, "package.json"));
+  const packageJson = await readJson(path11.join(rootDir, "package.json"));
   const categories = [];
   const evidence = [];
   const add = (category, value2) => {
@@ -1825,16 +1892,16 @@ async function detectPurpose(rootDir, stack) {
 }
 async function detectAgentKit(rootDir) {
   const manifestRelativePath = ".cursor/agent-kit.json";
-  const manifestPath = path10.join(rootDir, manifestRelativePath);
+  const manifestPath = path11.join(rootDir, manifestRelativePath);
   const installed = await fileExists(manifestPath);
   const manifest = installed ? await readJson(manifestPath) : null;
   return {
     installed,
     manifestPath: installed ? manifestRelativePath : void 0,
     version: manifest?.version,
-    hasPlans: await fileExists(path10.join(rootDir, ".cursor/plans")),
-    hasHandoff: await fileExists(path10.join(rootDir, ".cursor/HANDOFF.md")),
-    hasMemory: await fileExists(path10.join(rootDir, ".cursor/memory"))
+    hasPlans: await fileExists(path11.join(rootDir, ".cursor/plans")),
+    hasHandoff: await fileExists(path11.join(rootDir, ".cursor/HANDOFF.md")),
+    hasMemory: await fileExists(path11.join(rootDir, ".cursor/memory"))
   };
 }
 var REQUIRED_SECRET_PATTERNS = [
@@ -1848,7 +1915,7 @@ var REQUIRED_SECRET_PATTERNS = [
   "*service-account*.json"
 ];
 async function detectSafety(rootDir, trackedFiles) {
-  const gitignorePath = path10.join(rootDir, ".gitignore");
+  const gitignorePath = path11.join(rootDir, ".gitignore");
   const hasGitignore = await fileExists(gitignorePath);
   const gitignore = hasGitignore ? await readFile6(gitignorePath, "utf8") : "";
   const lines = gitignore.split(/\r?\n/).map((line) => line.trim()).filter((line) => line && !line.startsWith("#"));
@@ -1859,7 +1926,7 @@ async function detectSafety(rootDir, trackedFiles) {
     (file) => /(^|\/)(\.env(\..+)?|.*\.(key|pem|p12|pfx)|.*credentials.*\.json)$/i.test(file)
   );
   const hookPaths = [".husky", ".git/hooks/pre-commit", "git-hooks/pre-commit"];
-  const hasHooks = (await Promise.all(hookPaths.map((item) => fileExists(path10.join(rootDir, item))))).some(Boolean);
+  const hasHooks = (await Promise.all(hookPaths.map((item) => fileExists(path11.join(rootDir, item))))).some(Boolean);
   const guardCandidates = [
     ".husky/pre-commit",
     ".husky/pre-push",
@@ -1868,7 +1935,7 @@ async function detectSafety(rootDir, trackedFiles) {
   ];
   const guardContents = await Promise.all(
     guardCandidates.map(
-      async (item) => await fileExists(path10.join(rootDir, item)) ? readFile6(path10.join(rootDir, item), "utf8") : ""
+      async (item) => await fileExists(path11.join(rootDir, item)) ? readFile6(path11.join(rootDir, item), "utf8") : ""
     )
   );
   return {
@@ -1886,11 +1953,11 @@ async function detectSafety(rootDir, trackedFiles) {
 }
 
 // src/scanner/scan.ts
-import path16 from "path";
+import path17 from "path";
 
 // src/scanner/detect-git.ts
 import { execFile as execFile2 } from "child_process";
-import path11 from "path";
+import path12 from "path";
 import { promisify as promisify2 } from "util";
 var exec = promisify2(execFile2);
 function remoteHostname(remoteUrl) {
@@ -1914,7 +1981,7 @@ function sanitizeRemoteUrl(remoteUrl) {
 }
 async function detectProvider(rootDir, remoteUrl) {
   const configuration = await readJson(
-    path11.join(rootDir, ".cursor", "agent-kit.config.json")
+    path12.join(rootDir, ".cursor", "agent-kit.config.json")
   );
   const configuredProvider = configuration?.git?.provider;
   if (configuredProvider) {
@@ -1971,7 +2038,7 @@ async function detectProvider(rootDir, remoteUrl) {
       evidence: remoteEvidence
     };
   }
-  if (await fileExists(path11.join(rootDir, ".gitlab-ci.yml"))) {
+  if (await fileExists(path12.join(rootDir, ".gitlab-ci.yml"))) {
     return {
       provider: "gitlab",
       providerKind: "gitlab-self-hosted",
@@ -2060,11 +2127,11 @@ async function detectGit(rootDir) {
 }
 
 // src/scanner/detect-ide.ts
-import path12 from "path";
+import path13 from "path";
 async function detectIde(rootDir) {
-  const hasCursor = await fileExists(path12.join(rootDir, ".cursor"));
-  const hasVSCode = await fileExists(path12.join(rootDir, ".vscode"));
-  const hasWindsurf = await fileExists(path12.join(rootDir, ".windsurfrules"));
+  const hasCursor = await fileExists(path13.join(rootDir, ".cursor"));
+  const hasVSCode = await fileExists(path13.join(rootDir, ".vscode"));
+  const hasWindsurf = await fileExists(path13.join(rootDir, ".windsurfrules"));
   if (hasCursor) return { ide: "cursor", plan: "cursor-pro" };
   if (hasVSCode) return { ide: "vscode", plan: "vscode-pro" };
   if (hasWindsurf) return { ide: "windsurf", plan: "windsurf" };
@@ -2072,7 +2139,7 @@ async function detectIde(rootDir) {
 }
 
 // src/scanner/detect-infra.ts
-import path13 from "path";
+import path14 from "path";
 
 // src/types.ts
 var CI_PLATFORM_FILES = {
@@ -2101,12 +2168,12 @@ var PM_TOOL_LABELS = {
 
 // src/scanner/detect-infra.ts
 async function detectInfra(rootDir) {
-  const docker = await fileExists(path13.join(rootDir, "Dockerfile")) || await fileExists(path13.join(rootDir, "docker-compose.yml")) || await fileExists(path13.join(rootDir, "docker-compose.yaml"));
-  const kubernetes = await fileExists(path13.join(rootDir, "k8s")) || await fileExists(path13.join(rootDir, "kubernetes"));
+  const docker = await fileExists(path14.join(rootDir, "Dockerfile")) || await fileExists(path14.join(rootDir, "docker-compose.yml")) || await fileExists(path14.join(rootDir, "docker-compose.yaml"));
+  const kubernetes = await fileExists(path14.join(rootDir, "k8s")) || await fileExists(path14.join(rootDir, "kubernetes"));
   let ci = "none";
   const ciFiles = [];
   for (const [platform, filePath] of Object.entries(CI_PLATFORM_FILES)) {
-    if (await fileExists(path13.join(rootDir, filePath))) {
+    if (await fileExists(path14.join(rootDir, filePath))) {
       if (ci === "none") ci = platform;
       ciFiles.push(filePath);
     }
@@ -2131,12 +2198,12 @@ async function detectInfra(rootDir) {
   ];
   const infrastructureFiles = (await Promise.all(
     infrastructureCandidates.map(
-      async (file) => await fileExists(path13.join(rootDir, file)) ? file : void 0
+      async (file) => await fileExists(path14.join(rootDir, file)) ? file : void 0
     )
   )).filter((file) => file !== void 0);
   const deploymentFiles = (await Promise.all(
     deploymentCandidates.map(
-      async (file) => await fileExists(path13.join(rootDir, file)) ? file : void 0
+      async (file) => await fileExists(path14.join(rootDir, file)) ? file : void 0
     )
   )).filter((file) => file !== void 0);
   return { docker, kubernetes, ci, ciFiles, infrastructureFiles, deploymentFiles };
@@ -2144,12 +2211,12 @@ async function detectInfra(rootDir) {
 
 // src/scanner/detect-services.ts
 import { readFile as readFile7 } from "fs/promises";
-import path14 from "path";
+import path15 from "path";
 async function detectProjectManagement(rootDir) {
   const tools = [];
   const mcpConfigPaths = [
-    path14.join(rootDir, ".cursor", "mcp.json"),
-    path14.join(rootDir, "mcp.json")
+    path15.join(rootDir, ".cursor", "mcp.json"),
+    path15.join(rootDir, "mcp.json")
   ];
   for (const configPath of mcpConfigPaths) {
     if (!await fileExists(configPath)) continue;
@@ -2165,20 +2232,20 @@ async function detectProjectManagement(rootDir) {
     } catch {
     }
   }
-  if (await fileExists(path14.join(rootDir, ".github", "ISSUE_TEMPLATE"))) {
+  if (await fileExists(path15.join(rootDir, ".github", "ISSUE_TEMPLATE"))) {
     tools.push("github-issues");
   }
-  if (await fileExists(path14.join(rootDir, ".github", "projects"))) {
+  if (await fileExists(path15.join(rootDir, ".github", "projects"))) {
     tools.push("github-projects");
   }
   return [...new Set(tools)];
 }
 async function detectServices(rootDir) {
-  const hasPrisma = await fileExists(path14.join(rootDir, "prisma/schema.prisma"));
-  const hasSequelize = await fileExists(path14.join(rootDir, "sequelize"));
-  const hasDrizzle = await fileExists(path14.join(rootDir, "drizzle.config.ts"));
-  const hasKnex = await fileExists(path14.join(rootDir, "knexfile.ts"));
-  const hasTypeorm = await fileExists(path14.join(rootDir, "ormconfig.json"));
+  const hasPrisma = await fileExists(path15.join(rootDir, "prisma/schema.prisma"));
+  const hasSequelize = await fileExists(path15.join(rootDir, "sequelize"));
+  const hasDrizzle = await fileExists(path15.join(rootDir, "drizzle.config.ts"));
+  const hasKnex = await fileExists(path15.join(rootDir, "knexfile.ts"));
+  const hasTypeorm = await fileExists(path15.join(rootDir, "ormconfig.json"));
   const database = hasPrisma || hasSequelize || hasDrizzle || hasKnex || hasTypeorm ? "postgresql" : void 0;
   const orm = hasPrisma ? "prisma" : hasDrizzle ? "drizzle" : hasSequelize ? "sequelize" : hasKnex ? "knex" : hasTypeorm ? "typeorm" : void 0;
   const projectManagement = await detectProjectManagement(rootDir);
@@ -2190,7 +2257,7 @@ async function detectServices(rootDir) {
 }
 
 // src/scanner/detect-stack.ts
-import path15 from "path";
+import path16 from "path";
 var PROJECT_MARKERS = [
   "package.json",
   "requirements.txt",
@@ -2219,7 +2286,7 @@ async function detectPackageManager(rootDir, packageJson) {
     };
   }
   for (const [lockfile, packageManager] of LOCKFILES) {
-    if (await fileExists(path15.join(rootDir, lockfile))) {
+    if (await fileExists(path16.join(rootDir, lockfile))) {
       return {
         packageManager,
         evidence: [{ source: "file", value: lockfile }]
@@ -2236,27 +2303,27 @@ function commandsForScripts(scripts, packageManager) {
   return { testCommands, validationCommands };
 }
 async function detectStack(rootDir) {
-  const hasAnyProjectMarker = (await Promise.all(PROJECT_MARKERS.map((item) => fileExists(path15.join(rootDir, item))))).some(Boolean);
-  const hasPackageJson = await fileExists(path15.join(rootDir, "package.json"));
+  const hasAnyProjectMarker = (await Promise.all(PROJECT_MARKERS.map((item) => fileExists(path16.join(rootDir, item))))).some(Boolean);
+  const hasPackageJson = await fileExists(path16.join(rootDir, "package.json"));
   if (hasPackageJson) {
-    const packageJson = await readJson(path15.join(rootDir, "package.json")) ?? {};
+    const packageJson = await readJson(path16.join(rootDir, "package.json")) ?? {};
     const scripts = packageJson.scripts ?? {};
     const packageManager = await detectPackageManager(rootDir, packageJson);
     const commands = commandsForScripts(scripts, packageManager.packageManager);
-    const hasNextConfig = await fileExists(path15.join(rootDir, "next.config.js")) || await fileExists(path15.join(rootDir, "next.config.mjs")) || await fileExists(path15.join(rootDir, "next.config.ts"));
-    const hasNestConfig = await fileExists(path15.join(rootDir, "nest-cli.json"));
+    const hasNextConfig = await fileExists(path16.join(rootDir, "next.config.js")) || await fileExists(path16.join(rootDir, "next.config.mjs")) || await fileExists(path16.join(rootDir, "next.config.ts"));
+    const hasNestConfig = await fileExists(path16.join(rootDir, "nest-cli.json"));
     return {
       language: "node",
       framework: hasNextConfig ? "nextjs" : hasNestConfig ? "nestjs" : "node",
       packageManager: packageManager.packageManager,
       packageManagerEvidence: packageManager.evidence,
       scripts,
-      workspaces: packageJson.workspaces !== void 0 || await fileExists(path15.join(rootDir, "pnpm-workspace.yaml")),
+      workspaces: packageJson.workspaces !== void 0 || await fileExists(path16.join(rootDir, "pnpm-workspace.yaml")),
       ...commands,
       hasProjectFiles: hasAnyProjectMarker
     };
   }
-  if (await fileExists(path15.join(rootDir, "pyproject.toml"))) {
+  if (await fileExists(path16.join(rootDir, "pyproject.toml"))) {
     return {
       language: "python",
       framework: "python",
@@ -2266,7 +2333,7 @@ async function detectStack(rootDir) {
       hasProjectFiles: hasAnyProjectMarker
     };
   }
-  if (await fileExists(path15.join(rootDir, "go.mod"))) {
+  if (await fileExists(path16.join(rootDir, "go.mod"))) {
     return {
       language: "go",
       framework: "go",
@@ -2276,7 +2343,7 @@ async function detectStack(rootDir) {
       hasProjectFiles: hasAnyProjectMarker
     };
   }
-  if (await fileExists(path15.join(rootDir, "Cargo.toml"))) {
+  if (await fileExists(path16.join(rootDir, "Cargo.toml"))) {
     return {
       language: "rust",
       framework: "rust",
@@ -2286,7 +2353,7 @@ async function detectStack(rootDir) {
       hasProjectFiles: hasAnyProjectMarker
     };
   }
-  if (await fileExists(path15.join(rootDir, "composer.json"))) {
+  if (await fileExists(path16.join(rootDir, "composer.json"))) {
     return {
       language: "php",
       framework: "php",
@@ -2319,7 +2386,7 @@ function isGreenfieldByEntries(entries) {
   return meaningful.length === 0;
 }
 async function runScanner(rootDir) {
-  const normalizedRoot = path16.resolve(rootDir);
+  const normalizedRoot = path17.resolve(rootDir);
   const entries = await listDirectory(normalizedRoot);
   const stack = await detectStack(normalizedRoot);
   const purpose = await detectPurpose(normalizedRoot, stack);
@@ -2520,7 +2587,7 @@ async function executeSafeReadinessFixes(rootDir, options) {
   });
   const changes = [];
   for (const relativePath of ESSENTIAL_DIRECTORIES) {
-    const absolutePath = path17.join(beforeScan.rootDir, relativePath);
+    const absolutePath = path18.join(beforeScan.rootDir, relativePath);
     const exists = await fileExists(absolutePath);
     if (!exists && !dryRun) await ensureDir(absolutePath);
     recordChange(
@@ -2533,7 +2600,7 @@ async function executeSafeReadinessFixes(rootDir, options) {
     );
   }
   const gitignoreRelativePath = ".gitignore";
-  const gitignorePath = path17.join(beforeScan.rootDir, gitignoreRelativePath);
+  const gitignorePath = path18.join(beforeScan.rootDir, gitignoreRelativePath);
   const existingGitignore = await fileExists(gitignorePath) ? await readFile8(gitignorePath, "utf8") : "";
   const mergedGitignore = mergeSecretIgnores(existingGitignore);
   const gitignoreChanged = mergedGitignore !== existingGitignore;
@@ -2549,7 +2616,7 @@ async function executeSafeReadinessFixes(rootDir, options) {
       gitignoreChanged ? "required secret patterns are missing" : "required patterns are present"
     )
   );
-  const profilePath = path17.join(beforeScan.rootDir, PROFILE_RELATIVE_PATH);
+  const profilePath = path18.join(beforeScan.rootDir, PROFILE_RELATIVE_PATH);
   const existingProfile = await readJson(profilePath) ?? {};
   const desiredProfile = createProfile(beforeScan, before, generatedAt);
   const mergedProfile = mergeMissing(existingProfile, desiredProfile);
@@ -2571,7 +2638,7 @@ async function executeSafeReadinessFixes(rootDir, options) {
     generatorVersion: options.generatorVersion,
     generatedAt
   });
-  const contextConfigPath = path17.join(beforeScan.rootDir, CONTEXT_CONFIG_RELATIVE_PATH);
+  const contextConfigPath = path18.join(beforeScan.rootDir, CONTEXT_CONFIG_RELATIVE_PATH);
   const existingContextConfig = await readJson(contextConfigPath) ?? {};
   const onboarding = reconcileOnboardingState(evidenceReport, existingContextConfig, generatedAt);
   const defaults = preferenceDefaults(onboarding, existingContextConfig.onboarded);
@@ -2600,17 +2667,17 @@ async function executeSafeReadinessFixes(rootDir, options) {
 }
 
 // src/scanner/snapshot.ts
-import path18 from "path";
+import path19 from "path";
 var READINESS_SNAPSHOT_RELATIVE_PATH = ".cursor/context/readiness.json";
 async function writeReadinessSnapshot(rootDir, report) {
-  const snapshotPath = path18.join(rootDir, READINESS_SNAPSHOT_RELATIVE_PATH);
+  const snapshotPath = path19.join(rootDir, READINESS_SNAPSHOT_RELATIVE_PATH);
   await writeJson(snapshotPath, report);
   return snapshotPath;
 }
 
 // src/commands/doctor.ts
 async function runDoctor(cwd, options = {}) {
-  const rootDir = path19.resolve(cwd);
+  const rootDir = path20.resolve(cwd);
   if (options.fixSafe) {
     const execution = await executeSafeReadinessFixes(rootDir, {
       generatorVersion: KIT_VERSION,
@@ -2641,7 +2708,7 @@ function printDoctorSummary(result) {
     nextAction ? `Next: ${nextAction.recommendation}` : "Next: repository readiness checks are complete"
   );
 }
-var doctorCommand = defineCommand4({
+var doctorCommand = defineCommand5({
   meta: {
     name: "doctor",
     description: "Diagnose repository readiness and optionally apply safe local fixes."
@@ -2673,10 +2740,10 @@ var doctorCommand = defineCommand4({
 });
 
 // src/commands/handoff.ts
-import { spawn } from "child_process";
+import { spawn as spawn2 } from "child_process";
 import { readFile as readFile9, readdir as readdir2, writeFile as writeFile4 } from "fs/promises";
-import path20 from "path";
-import { defineCommand as defineCommand5 } from "citty";
+import path21 from "path";
+import { defineCommand as defineCommand6 } from "citty";
 function parsePlanFrontmatter(raw) {
   const match = raw.match(/^---\n([\s\S]*?)\n---/);
   if (!match?.[1]) return null;
@@ -2695,19 +2762,19 @@ async function findActivePlan(plansDir) {
   if (!await fileExists(plansDir)) return null;
   const files = (await readdir2(plansDir)).filter((f) => f.endsWith(".plan.md")).sort().reverse();
   for (const file of files) {
-    const raw = await readFile9(path20.join(plansDir, file), "utf8");
+    const raw = await readFile9(path21.join(plansDir, file), "utf8");
     const fm = parsePlanFrontmatter(raw);
     if (fm?.todos?.some((t) => t.status !== "completed" && t.status !== "cancelled")) {
       return { file, raw };
     }
   }
-  return files[0] ? { file: files[0], raw: await readFile9(path20.join(plansDir, files[0]), "utf8") } : null;
+  return files[0] ? { file: files[0], raw: await readFile9(path21.join(plansDir, files[0]), "utf8") } : null;
 }
 function now() {
   return (/* @__PURE__ */ new Date()).toISOString().replace("T", " ").slice(0, 16);
 }
 async function loadProfile(rootDir) {
-  const configPath = path20.join(rootDir, ".cursor", "agent-kit.config.json");
+  const configPath = path21.join(rootDir, ".cursor", "agent-kit.config.json");
   try {
     return await readJson(configPath);
   } catch {
@@ -2785,7 +2852,7 @@ function printV3Guidance() {
 }
 function runCursorHandoff(scriptPath, cwd) {
   return new Promise((resolve, reject) => {
-    const child = spawn("sh", [scriptPath, "handoff"], {
+    const child = spawn2("sh", [scriptPath, "handoff"], {
       cwd,
       stdio: "inherit"
     });
@@ -2793,7 +2860,7 @@ function runCursorHandoff(scriptPath, cwd) {
     child.on("close", (code) => resolve(code ?? 1));
   });
 }
-var handoffCommand = defineCommand5({
+var handoffCommand = defineCommand6({
   meta: {
     name: "handoff",
     description: "Write .cursor/HANDOFF.md from the active Cursor plan, or run ./cursor-handoff handoff when no plan exists."
@@ -2807,13 +2874,13 @@ var handoffCommand = defineCommand5({
   },
   async run({ args }) {
     const profile = await loadProfile(args.cwd);
-    const plansDir = path20.join(args.cwd, ".cursor", "plans");
-    const handoffPath = path20.join(args.cwd, ".cursor", "HANDOFF.md");
+    const plansDir = path21.join(args.cwd, ".cursor", "plans");
+    const handoffPath = path21.join(args.cwd, ".cursor", "HANDOFF.md");
     const plan = await findActivePlan(plansDir);
     if (plan) {
       const fm = parsePlanFrontmatter(plan.raw);
       if (fm) {
-        await ensureDir(path20.join(args.cwd, ".cursor"));
+        await ensureDir(path21.join(args.cwd, ".cursor"));
         const content = buildHandoff(plan.file, fm, profile);
         await writeFile4(handoffPath, content, "utf8");
         logger.success("HANDOFF.md updated: .cursor/HANDOFF.md");
@@ -2833,7 +2900,7 @@ var handoffCommand = defineCommand5({
       }
       logger.warn(`Plan ${plan.file} without valid frontmatter; trying legacy flow.`);
     }
-    const scriptPath = path20.join(args.cwd, "cursor-handoff");
+    const scriptPath = path21.join(args.cwd, "cursor-handoff");
     if (!await fileExists(scriptPath)) {
       printV3Guidance();
       return;
@@ -2859,15 +2926,15 @@ var handoffCommand = defineCommand5({
 
 // src/commands/init.ts
 import { intro, outro } from "@clack/prompts";
-import { defineCommand as defineCommand7 } from "citty";
+import { defineCommand as defineCommand8 } from "citty";
 
 // src/commands/install.ts
-import path23 from "path";
-import { defineCommand as defineCommand6 } from "citty";
+import path24 from "path";
+import { defineCommand as defineCommand7 } from "citty";
 
 // src/generator/personalization.ts
 import { readFile as readFile10, writeFile as writeFile5 } from "fs/promises";
-import path21 from "path";
+import path22 from "path";
 var PERSONALIZATION_CONTRACT_VERSION = 1;
 var CONTEXT_PATH = ".cursor/project-context.md";
 var AGENTS_PATH = "AGENTS.md";
@@ -3018,7 +3085,7 @@ function renderProjectContext(profile) {
 `;
 }
 async function createOwnedFile(rootDir, relativePath, content, evidence) {
-  const target = path21.join(rootDir, relativePath);
+  const target = path22.join(rootDir, relativePath);
   if (await fileExists(target)) {
     return {
       kind: "file",
@@ -3028,7 +3095,7 @@ async function createOwnedFile(rootDir, relativePath, content, evidence) {
       evidence
     };
   }
-  await ensureDir(path21.dirname(target));
+  await ensureDir(path22.dirname(target));
   await writeFile5(target, content, "utf8");
   return {
     kind: "file",
@@ -3045,7 +3112,7 @@ async function packTargets(registryRoot, packId) {
 async function existingTargets(projectRoot, targets) {
   const checks = await Promise.all(
     targets.map(
-      async (target) => await fileExists(path21.join(projectRoot, target)) ? target : null
+      async (target) => await fileExists(path22.join(projectRoot, target)) ? target : null
     )
   );
   return checks.filter((target) => target !== null);
@@ -3067,14 +3134,14 @@ async function applyPersonalization(input) {
         componentResults.push({ ...item, status: "unavailable" });
         continue;
       }
-      const target = path21.posix.join(
+      const target = path22.posix.join(
         ".cursor",
         "skills",
         skill.path.includes("/core/") ? "core" : "community",
         skill.id,
         "SKILL.md"
       );
-      if (await fileExists(path21.join(input.rootDir, target))) {
+      if (await fileExists(path22.join(input.rootDir, target))) {
         componentResults.push({ ...item, status: "skipped-customized", path: target });
         protectedPaths.add(target);
         continue;
@@ -3129,7 +3196,7 @@ async function applyPersonalization(input) {
     items: [...fileResults, ...componentResults],
     protectedPaths: [...protectedPaths].sort()
   };
-  await writeJson(path21.join(input.rootDir, RESULT_PATH), result);
+  await writeJson(path22.join(input.rootDir, RESULT_PATH), result);
   return {
     result,
     manifest: {
@@ -3147,7 +3214,7 @@ async function applyPersonalization(input) {
   };
 }
 async function readRepositoryProfile(rootDir) {
-  const target = path21.join(rootDir, ".cursor/agent-kit.config.json");
+  const target = path22.join(rootDir, ".cursor/agent-kit.config.json");
   if (!await fileExists(target)) return null;
   return JSON.parse(await readFile10(target, "utf8"));
 }
@@ -3155,16 +3222,16 @@ async function readRepositoryProfile(rootDir) {
 // src/lifecycle/onboard-migration.ts
 import { createHash as createHash3 } from "crypto";
 import { readFile as readFile11, unlink } from "fs/promises";
-import path22 from "path";
+import path23 from "path";
 var LEGACY_ONBOARD_PATH = ".cursor/commands/onboard.md";
 var NAMESPACED_ONBOARD_PATH = ".cursor/commands/agent-kit-onboard.md";
 var MANAGED_LEGACY_HASHES = /* @__PURE__ */ new Set([
   "b274a68941813f19b185893cb7c5561dff027f53270890029992f208e24992fe"
 ]);
 async function migrateLegacyOnboardCommand(projectRoot, managedHashes = MANAGED_LEGACY_HASHES) {
-  const legacyPath = path22.join(projectRoot, LEGACY_ONBOARD_PATH);
+  const legacyPath = path23.join(projectRoot, LEGACY_ONBOARD_PATH);
   if (!await fileExists(legacyPath)) return "absent";
-  const namespacedPath = path22.join(projectRoot, NAMESPACED_ONBOARD_PATH);
+  const namespacedPath = path23.join(projectRoot, NAMESPACED_ONBOARD_PATH);
   if (!await fileExists(namespacedPath)) return "preserved-customized";
   const content = await readFile11(legacyPath);
   const hash = createHash3("sha256").update(content).digest("hex");
@@ -3235,7 +3302,7 @@ function printReadinessNarrative(result) {
   );
 }
 async function performInstall(options) {
-  const projectRoot = path23.resolve(options.cwd);
+  const projectRoot = path24.resolve(options.cwd);
   const packs = parsePackList(options.pack);
   const existing = await loadAgentKitManifest(projectRoot);
   const registry = await resolveRegistryFromCli({
@@ -3289,7 +3356,7 @@ async function performInstall(options) {
     safeChanges: readinessExecution.changes
   };
 }
-var installCommand = defineCommand6({
+var installCommand = defineCommand7({
   meta: {
     name: "install",
     description: "Bootstrap L0 (+ optional packs) from the registry and write agent-kit.json."
@@ -3311,7 +3378,7 @@ var installCommand = defineCommand6({
     ...REGISTRY_CLI_ARGS
   },
   async run({ args }) {
-    const projectRoot = path23.resolve(args.cwd);
+    const projectRoot = path24.resolve(args.cwd);
     logger.info(`Installing into: ${projectRoot}`);
     const packs = parsePackList(args.pack);
     for (const id of packs) {
@@ -3339,7 +3406,7 @@ var installCommand = defineCommand6({
 async function runInitCompatibility(cwd, installer = performInstall) {
   return installer({ cwd });
 }
-var initCommand = defineCommand7({
+var initCommand = defineCommand8({
   meta: {
     name: "init",
     description: "Guided compatibility entry point for install and repository readiness."
@@ -3364,11 +3431,11 @@ var initCommand = defineCommand7({
 });
 
 // src/commands/run-plan.ts
-import path28 from "path";
-import { defineCommand as defineCommand8 } from "citty";
+import path29 from "path";
+import { defineCommand as defineCommand9 } from "citty";
 
 // src/plan-loop/backends.ts
-import { execFileSync, spawn as spawn2 } from "child_process";
+import { execFileSync, spawn as spawn3 } from "child_process";
 import { createWriteStream } from "fs";
 async function which(bin) {
   try {
@@ -3381,7 +3448,7 @@ async function which(bin) {
 function spawnLogged(command, args, logPath) {
   return new Promise((resolve, reject) => {
     const out = createWriteStream(logPath, { flags: "w" });
-    const child = spawn2(command, args, {
+    const child = spawn3(command, args, {
       stdio: ["ignore", "pipe", "pipe"]
     });
     const onData = (chunk) => {
@@ -3450,13 +3517,13 @@ function listBackendIds() {
 
 // src/plan-loop/run-loop.ts
 import { mkdir as mkdir4, readFile as readFile14, rm, unlink as unlink2 } from "fs/promises";
-import path27 from "path";
+import path28 from "path";
 
 // src/plan-loop/external-review.ts
-import { spawn as spawn3 } from "child_process";
-import path24 from "path";
-var CANONICAL_REL = path24.join(".cursor", "scripts", "plan-external-review.sh");
-var FALLBACK_REL = path24.join("scripts", "plan-external-review.sh");
+import { spawn as spawn4 } from "child_process";
+import path25 from "path";
+var CANONICAL_REL = path25.join(".cursor", "scripts", "plan-external-review.sh");
+var FALLBACK_REL = path25.join("scripts", "plan-external-review.sh");
 function isPlanExhaustedReason(reason) {
   const r = reason.trim().toLowerCase();
   if (!r) return false;
@@ -3474,12 +3541,12 @@ function shouldArmExternalPlanReview(input) {
   return false;
 }
 async function armExternalPlanReview(root, options = {}) {
-  const spawnFn = options.spawnFn ?? spawn3;
+  const spawnFn = options.spawnFn ?? spawn4;
   const existsFn = options.existsFn ?? fileExists;
   const log = options.log ?? ((line) => console.log(line));
   const force = options.force === true;
-  const canonicalPath = path24.join(root, CANONICAL_REL);
-  const fallbackPath = path24.join(root, FALLBACK_REL);
+  const canonicalPath = path25.join(root, CANONICAL_REL);
+  const fallbackPath = path25.join(root, FALLBACK_REL);
   let scriptPath = null;
   let scriptRel = CANONICAL_REL;
   if (await existsFn(canonicalPath)) {
@@ -3533,7 +3600,7 @@ async function armExternalPlanReview(root, options = {}) {
 
 // src/plan-loop/plan-state.ts
 import { readFile as readFile12, readdir as readdir3 } from "fs/promises";
-import path25 from "path";
+import path26 from "path";
 function countPendingTodos(raw) {
   const lines = raw.split(/\r?\n/);
   let inFront = 0;
@@ -3561,7 +3628,7 @@ function countPendingTodos(raw) {
 async function findActivePlanFile(plansDir) {
   if (!await fileExists(plansDir)) return null;
   const files = (await readdir3(plansDir)).filter((f) => f.endsWith(".plan.md")).sort();
-  return files[0] ? path25.join(plansDir, files[0]) : null;
+  return files[0] ? path26.join(plansDir, files[0]) : null;
 }
 async function readPlan(planPath) {
   return readFile12(planPath, "utf8");
@@ -3628,7 +3695,7 @@ function formatSentinelLine(sentinel) {
 }
 
 // src/plan-loop/skin-banners.ts
-import path26 from "path";
+import path27 from "path";
 import {
   blue,
   cyan as cyan2,
@@ -3664,7 +3731,7 @@ function resolveColor(name, fallback) {
 async function resolveCliSkinId(root) {
   try {
     const cfg = await readJson(
-      path26.join(root, ".cursor", "context", "config.json")
+      path27.join(root, ".cursor", "context", "config.json")
     );
     const id = cfg?.workspaceSkin?.modes?.[CLI_RUN_PLAN_MODE];
     if (typeof id === "string" && id.trim()) return id.trim();
@@ -3674,7 +3741,7 @@ async function resolveCliSkinId(root) {
 }
 async function loadSkinPack(root, skinId) {
   try {
-    const skinPath = path26.join(root, "registry", "skins", "core", skinId, "skin.json");
+    const skinPath = path27.join(root, "registry", "skins", "core", skinId, "skin.json");
     const pack = await readJson(skinPath);
     if (!pack || typeof pack.id !== "string") return null;
     return pack;
@@ -3733,9 +3800,9 @@ function sleep(ms) {
   return new Promise((r) => setTimeout(r, ms));
 }
 async function runPlanLoop(opts) {
-  const plansDir = path27.join(opts.root, ".cursor", "plans");
-  const stopFile = path27.join(opts.root, ".cursor", "loop.stop");
-  const logDir = path27.join(opts.root, ".cursor", "loop-logs");
+  const plansDir = path28.join(opts.root, ".cursor", "plans");
+  const stopFile = path28.join(opts.root, ".cursor", "loop.stop");
+  const logDir = path28.join(opts.root, ".cursor", "loop-logs");
   const planPath = await findActivePlanFile(plansDir);
   if (!planPath) {
     logger.error("No active plan in .cursor/plans/");
@@ -3756,7 +3823,7 @@ async function runPlanLoop(opts) {
   try {
     const skin = await loadCliRunPlanSkin(opts.root);
     const banners = createSkinBannerPrinter(skin);
-    console.log(`Active plan: ${path27.basename(planPath)}`);
+    console.log(`Active plan: ${path28.basename(planPath)}`);
     console.log(`Pending to-dos: ${await pending()} | max ticks: ${opts.maxTicks}`);
     console.log(`Backend: ${opts.backend.id}`);
     if (skin) {
@@ -3799,8 +3866,8 @@ async function runPlanLoop(opts) {
         planExhausted = true;
         break;
       }
-      const logPath = path27.join(logDir, `tick-${stamp()}.log`);
-      const relLog = path27.relative(opts.root, logPath);
+      const logPath = path28.join(logDir, `tick-${stamp()}.log`);
+      const relLog = path28.relative(opts.root, logPath);
       console.log("");
       const tickLine = `=== tick ${tick}/${opts.maxTicks} - pending: ${before} - log: ${relLog} ===`;
       if (banners) banners.tickStart(tickLine);
@@ -3876,7 +3943,7 @@ async function runPlanLoop(opts) {
     const finishDetail = `after ${tick} tick(s); pending: ${pendingNow}`;
     if (banners) banners.phaseComplete(finishDetail);
     console.log(
-      `Loop finished after ${tick} tick(s). Pending now: ${pendingNow}. Logs in ${path27.relative(opts.root, logDir)}/`
+      `Loop finished after ${tick} tick(s). Pending now: ${pendingNow}. Logs in ${path28.relative(opts.root, logDir)}/`
     );
     if (planExhausted || shouldArmExternalPlanReview({ pending: pendingNow, stopReason })) {
       await armExternalPlanReview(opts.root);
@@ -3888,7 +3955,7 @@ async function runPlanLoop(opts) {
 }
 
 // src/commands/run-plan.ts
-var runPlanCommand = defineCommand8({
+var runPlanCommand = defineCommand9({
   meta: {
     name: "run-plan",
     description: "Headless continuous plan runner: one fresh agent per tick (LOOP_TICK_RESULT contract). Never git-prod."
@@ -3947,7 +4014,7 @@ var runPlanCommand = defineCommand8({
       return;
     }
     const code = await runPlanLoop({
-      root: path28.resolve(args.cwd),
+      root: path29.resolve(args.cwd),
       maxTicks,
       sleepSeconds,
       model: args.model ? String(args.model) : void 0,
@@ -3959,8 +4026,8 @@ var runPlanCommand = defineCommand8({
 });
 
 // src/commands/scan.ts
-import { defineCommand as defineCommand9 } from "citty";
-var scanCommand = defineCommand9({
+import { defineCommand as defineCommand10 } from "citty";
+var scanCommand = defineCommand10({
   meta: {
     name: "scan",
     description: "Scan the current repository and print detected profile."
@@ -3981,8 +4048,8 @@ var scanCommand = defineCommand9({
 });
 
 // src/commands/status.ts
-import path29 from "path";
-import { defineCommand as defineCommand10 } from "citty";
+import path30 from "path";
+import { defineCommand as defineCommand11 } from "citty";
 function profileStatus(profile) {
   if (!profile) return { origin: "none", evidence: [], profile: null };
   if ("detection" in profile && profile.detection && typeof profile.detection === "object") {
@@ -3995,7 +4062,7 @@ function profileStatus(profile) {
   }
   return { origin: "legacy-wizard", evidence: [], profile };
 }
-var statusCommand = defineCommand10({
+var statusCommand = defineCommand11({
   meta: {
     name: "status",
     description: "Show Agent Kit distribution status (manifest + optional wizard profile)."
@@ -4012,11 +4079,11 @@ var statusCommand = defineCommand10({
     }
   },
   async run({ args }) {
-    const rootDir = path29.resolve(args.cwd);
+    const rootDir = path30.resolve(args.cwd);
     const [manifest, rawProfile, scan] = await Promise.all([
       loadAgentKitManifest(rootDir),
       readJson(
-        path29.join(rootDir, ".cursor", "agent-kit.config.json")
+        path30.join(rootDir, ".cursor", "agent-kit.config.json")
       ),
       runScanner(rootDir)
     ]);
@@ -4071,8 +4138,8 @@ var statusCommand = defineCommand10({
 });
 
 // src/commands/update.ts
-import { defineCommand as defineCommand11 } from "citty";
-var updateCommand = defineCommand11({
+import { defineCommand as defineCommand12 } from "citty";
+var updateCommand = defineCommand12({
   meta: {
     name: "update",
     description: "Re-apply L0/packs/skills from the registry; never overwrites L3 protected paths."
@@ -4117,7 +4184,7 @@ var updateCommand = defineCommand11({
 });
 
 // src/index.ts
-var main = defineCommand12({
+var main = defineCommand13({
   meta: {
     name: "agent-kit",
     description: "HITL framework for AI-assisted IDEs"
@@ -4133,7 +4200,8 @@ var main = defineCommand12({
     diff: diffCommand,
     contribute: contributeCommand,
     handoff: handoffCommand,
-    "run-plan": runPlanCommand
+    "run-plan": runPlanCommand,
+    dashboard: dashboardCommand
   }
 });
 runMain(main);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dadado/agent-kit-cli",
-  "version": "4.6.0",
+  "version": "4.7.0",
   "description": "Agent Kit CLI: HITL framework install and tooling for AI-assisted IDEs (rules, skills, plan/handoff, context).",
   "type": "module",
   "bin": {