@dadado/agent-kit-cli 4.7.2 → 4.8.0

package/dist/index.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 
 // src/index.ts
-import { defineCommand as defineCommand13, runMain } from "citty";
+import { defineCommand as defineCommand14, runMain } from "citty";
 
 // src/commands/add.ts
 import { defineCommand } from "citty";
@@ -974,6 +974,22 @@ var L0_ARTIFACTS = [
     source: ".cursor/commands/start-project.md",
     target: ".cursor/commands/start-project.md"
   },
+  {
+    source: ".cursor/commands/backlog-add.md",
+    target: ".cursor/commands/backlog-add.md"
+  },
+  {
+    source: ".cursor/commands/backlog-edit.md",
+    target: ".cursor/commands/backlog-edit.md"
+  },
+  {
+    source: ".cursor/commands/backlog-delete.md",
+    target: ".cursor/commands/backlog-delete.md"
+  },
+  {
+    source: ".cursor/commands/backlog-cancel.md",
+    target: ".cursor/commands/backlog-cancel.md"
+  },
   {
     source: ".cursor/commands/agent-kit-onboard.md",
     target: ".cursor/commands/agent-kit-onboard.md"
@@ -986,6 +1002,14 @@ var L0_ARTIFACTS = [
     source: ".cursor/commands/run-plan.md",
     target: ".cursor/commands/run-plan.md"
   },
+  {
+    source: ".cursor/commands/hotfix.md",
+    target: ".cursor/commands/hotfix.md"
+  },
+  {
+    source: ".cursor/commands/run-plan-all.md",
+    target: ".cursor/commands/run-plan-all.md"
+  },
   // Deprecated aliases of /run-plan (kept so existing references keep working)
   {
     source: ".cursor/commands/run-plan-loop.md",
@@ -1014,6 +1038,10 @@ var L0_ARTIFACTS = [
     source: ".cursor/commands/plan-review-triage.md",
     target: ".cursor/commands/plan-review-triage.md"
   },
+  {
+    source: ".cursor/commands/field-report-resolve.md",
+    target: ".cursor/commands/field-report-resolve.md"
+  },
   // Context (templates + example config; private config.json is not L0)
   {
     source: ".cursor/context/templates/plan-external-review-prompt.md",
@@ -1047,11 +1075,19 @@ var L0_ARTIFACTS = [
     source: ".cursor/context/config.example.json",
     target: ".cursor/context/config.example.json"
   },
-  // Scripts (canonical launcher; consumers never receive repo-root scripts/)
+  // Scripts (canonical launchers; consumers never receive repo-root scripts/)
   {
     source: ".cursor/scripts/plan-external-review.sh",
     target: ".cursor/scripts/plan-external-review.sh"
   },
+  {
+    source: ".cursor/scripts/field-report-cadence-bump.sh",
+    target: ".cursor/scripts/field-report-cadence-bump.sh"
+  },
+  {
+    source: ".cursor/scripts/run-plan-all-consolidate.sh",
+    target: ".cursor/scripts/run-plan-all-consolidate.sh"
+  },
   // Secrets gate (structural)
   {
     source: ".cursor/hooks/pre-commit/check-secrets.sh",
@@ -1354,6 +1390,12 @@ var contributeCommand = defineCommand2({
   }
 });
 
+// src/commands/dashboard-broadcast.ts
+import { spawn as spawn2 } from "child_process";
+import { access as access3 } from "fs/promises";
+import path10 from "path";
+import { defineCommand as defineCommand4 } from "citty";
+
 // src/commands/dashboard.ts
 import { spawn } from "child_process";
 import { access as access2 } from "fs/promises";
@@ -1417,12 +1459,72 @@ var dashboardCommand = defineCommand3({
   }
 });
 
+// src/commands/dashboard-broadcast.ts
+async function findDashboardBroadcastStart(cwd) {
+  let dir = path10.resolve(cwd);
+  for (; ; ) {
+    const candidate2 = path10.join(dir, "dashboard", "start-broadcast.mjs");
+    try {
+      await access3(candidate2);
+      return candidate2;
+    } catch {
+    }
+    const parent = path10.dirname(dir);
+    if (parent === dir) return null;
+    dir = parent;
+  }
+}
+function runStartScript2(startPath, env) {
+  return new Promise((resolve, reject) => {
+    const child = spawn2(process.execPath, [startPath], {
+      cwd: path10.dirname(path10.dirname(startPath)),
+      env,
+      stdio: "inherit"
+    });
+    child.on("error", reject);
+    child.on("close", (code) => resolve(code ?? 1));
+  });
+}
+var dashboardBroadcastCommand = defineCommand4({
+  meta: {
+    name: "dashboard-broadcast",
+    description: "Opt-in LAN Mission Control (token-gated). Terminal counterpart to /dashboard-broadcast. Does not change loopback /dashboard."
+  },
+  args: {
+    cwd: {
+      type: "string",
+      default: process.cwd(),
+      description: "Directory to search upward for dashboard/start-broadcast.mjs"
+    },
+    "no-open": {
+      type: "boolean",
+      default: false,
+      description: "Do not open a browser; only ensure the server is up and print LAN URL + token"
+    }
+  },
+  async run({ args }) {
+    const startPath = await findDashboardBroadcastStart(args.cwd);
+    if (!startPath) {
+      const loopback = await findDashboardStart(args.cwd);
+      logger.error(
+        loopback ? "No dashboard/start-broadcast.mjs found beside dashboard/start.mjs. Update the agent-kit tree, then retry." : "No dashboard/start-broadcast.mjs found. Mission Control ships with the agent-kit repo; run from that tree."
+      );
+      process.exitCode = 1;
+      return;
+    }
+    const env = { ...process.env };
+    if (args["no-open"]) env.MISSION_CONTROL_NO_OPEN = "1";
+    const code = await runStartScript2(startPath, env);
+    if (code !== 0) process.exitCode = code;
+  }
+});
+
 // src/commands/diff.ts
-import { defineCommand as defineCommand4 } from "citty";
+import { defineCommand as defineCommand5 } from "citty";
 
 // src/lifecycle/diff.ts
 import { readFile as readFile5 } from "fs/promises";
-import path10 from "path";
+import path11 from "path";
 async function readIfExists(abs) {
   try {
     return await readFile5(abs, "utf8");
@@ -1431,7 +1533,7 @@ async function readIfExists(abs) {
   }
 }
 async function comparePair(registryRoot, projectRoot, sourceRel, targetRel, protectedGlobs) {
-  const posixTarget = targetRel.split(path10.sep).join("/");
+  const posixTarget = targetRel.split(path11.sep).join("/");
   if (isProtectedPath(posixTarget, protectedGlobs)) {
     return { path: posixTarget, status: "protected" };
   }
@@ -1461,7 +1563,7 @@ async function diffAgainstRegistry(registryRoot, projectRoot, manifest) {
   const entries = [];
   const seen = /* @__PURE__ */ new Set();
   const pushUnique = async (sourceRel, targetRel) => {
-    const key = targetRel.split(path10.sep).join("/");
+    const key = targetRel.split(path11.sep).join("/");
     if (seen.has(key)) return;
     seen.add(key);
     entries.push(
@@ -1488,8 +1590,8 @@ async function diffAgainstRegistry(registryRoot, projectRoot, manifest) {
         continue;
       }
       const category = skill.path.includes("/core/") ? "core" : "community";
-      const sourceRel = path10.posix.join(skill.path, "SKILL.md");
-      const targetRel = path10.posix.join(".cursor", "skills", category, skill.id, "SKILL.md");
+      const sourceRel = path11.posix.join(skill.path, "SKILL.md");
+      const targetRel = path11.posix.join(".cursor", "skills", category, skill.id, "SKILL.md");
       await pushUnique(sourceRel, targetRel);
     }
   }
@@ -1508,7 +1610,7 @@ function summarizeDiff(entries) {
 }
 
 // src/commands/diff.ts
-var diffCommand = defineCommand4({
+var diffCommand = defineCommand5({
   meta: {
     name: "diff",
     description: "Compare installed kit artifacts to the registry (respects L3 protected)."
@@ -1557,8 +1659,8 @@ var diffCommand = defineCommand4({
 });
 
 // src/commands/doctor.ts
-import path20 from "path";
-import { defineCommand as defineCommand5 } from "citty";
+import path21 from "path";
+import { defineCommand as defineCommand6 } from "citty";
 
 // src/scanner/readiness.ts
 import { createHash as createHash2 } from "crypto";
@@ -1808,11 +1910,11 @@ function createReadinessReport(scan, options) {
 
 // src/scanner/safe-fixes.ts
 import { readFile as readFile8, writeFile as writeFile3 } from "fs/promises";
-import path18 from "path";
+import path19 from "path";
 
 // src/scanner/detect-repository.ts
 import { readFile as readFile6 } from "fs/promises";
-import path11 from "path";
+import path12 from "path";
 var CONTEXT_PATHS = [
   ["README.md", "README"],
   ["README", "README"],
@@ -1831,7 +1933,7 @@ var CONTEXT_PATHS = [
 async function existingEvidence(rootDir, candidates) {
   const evidence = await Promise.all(
     candidates.map(
-      async ([relativePath, label]) => await fileExists(path11.join(rootDir, relativePath)) ? { source: "file", value: `${relativePath}:${label}` } : void 0
+      async ([relativePath, label]) => await fileExists(path12.join(rootDir, relativePath)) ? { source: "file", value: `${relativePath}:${label}` } : void 0
     )
   );
   return evidence.flatMap((item) => item ? [item] : []);
@@ -1852,7 +1954,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(path11.join(rootDir, "package.json"));
+  const packageJson = await readJson(path12.join(rootDir, "package.json"));
   const categories = [];
   const evidence = [];
   const add = (category, value2) => {
@@ -1892,16 +1994,16 @@ async function detectPurpose(rootDir, stack) {
 }
 async function detectAgentKit(rootDir) {
   const manifestRelativePath = ".cursor/agent-kit.json";
-  const manifestPath = path11.join(rootDir, manifestRelativePath);
+  const manifestPath = path12.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(path11.join(rootDir, ".cursor/plans")),
-    hasHandoff: await fileExists(path11.join(rootDir, ".cursor/HANDOFF.md")),
-    hasMemory: await fileExists(path11.join(rootDir, ".cursor/memory"))
+    hasPlans: await fileExists(path12.join(rootDir, ".cursor/plans")),
+    hasHandoff: await fileExists(path12.join(rootDir, ".cursor/HANDOFF.md")),
+    hasMemory: await fileExists(path12.join(rootDir, ".cursor/memory"))
   };
 }
 var REQUIRED_SECRET_PATTERNS = [
@@ -1915,7 +2017,7 @@ var REQUIRED_SECRET_PATTERNS = [
   "*service-account*.json"
 ];
 async function detectSafety(rootDir, trackedFiles) {
-  const gitignorePath = path11.join(rootDir, ".gitignore");
+  const gitignorePath = path12.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("#"));
@@ -1926,7 +2028,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(path11.join(rootDir, item))))).some(Boolean);
+  const hasHooks = (await Promise.all(hookPaths.map((item) => fileExists(path12.join(rootDir, item))))).some(Boolean);
   const guardCandidates = [
     ".husky/pre-commit",
     ".husky/pre-push",
@@ -1935,7 +2037,7 @@ async function detectSafety(rootDir, trackedFiles) {
   ];
   const guardContents = await Promise.all(
     guardCandidates.map(
-      async (item) => await fileExists(path11.join(rootDir, item)) ? readFile6(path11.join(rootDir, item), "utf8") : ""
+      async (item) => await fileExists(path12.join(rootDir, item)) ? readFile6(path12.join(rootDir, item), "utf8") : ""
     )
   );
   return {
@@ -1953,11 +2055,11 @@ async function detectSafety(rootDir, trackedFiles) {
 }
 
 // src/scanner/scan.ts
-import path17 from "path";
+import path18 from "path";
 
 // src/scanner/detect-git.ts
 import { execFile as execFile2 } from "child_process";
-import path12 from "path";
+import path13 from "path";
 import { promisify as promisify2 } from "util";
 var exec = promisify2(execFile2);
 function remoteHostname(remoteUrl) {
@@ -1981,7 +2083,7 @@ function sanitizeRemoteUrl(remoteUrl) {
 }
 async function detectProvider(rootDir, remoteUrl) {
   const configuration = await readJson(
-    path12.join(rootDir, ".cursor", "agent-kit.config.json")
+    path13.join(rootDir, ".cursor", "agent-kit.config.json")
   );
   const configuredProvider = configuration?.git?.provider;
   if (configuredProvider) {
@@ -2038,7 +2140,7 @@ async function detectProvider(rootDir, remoteUrl) {
       evidence: remoteEvidence
     };
   }
-  if (await fileExists(path12.join(rootDir, ".gitlab-ci.yml"))) {
+  if (await fileExists(path13.join(rootDir, ".gitlab-ci.yml"))) {
     return {
       provider: "gitlab",
       providerKind: "gitlab-self-hosted",
@@ -2127,11 +2229,11 @@ async function detectGit(rootDir) {
 }
 
 // src/scanner/detect-ide.ts
-import path13 from "path";
+import path14 from "path";
 async function detectIde(rootDir) {
-  const hasCursor = await fileExists(path13.join(rootDir, ".cursor"));
-  const hasVSCode = await fileExists(path13.join(rootDir, ".vscode"));
-  const hasWindsurf = await fileExists(path13.join(rootDir, ".windsurfrules"));
+  const hasCursor = await fileExists(path14.join(rootDir, ".cursor"));
+  const hasVSCode = await fileExists(path14.join(rootDir, ".vscode"));
+  const hasWindsurf = await fileExists(path14.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" };
@@ -2139,7 +2241,7 @@ async function detectIde(rootDir) {
 }
 
 // src/scanner/detect-infra.ts
-import path14 from "path";
+import path15 from "path";
 
 // src/types.ts
 var CI_PLATFORM_FILES = {
@@ -2168,12 +2270,12 @@ var PM_TOOL_LABELS = {
 
 // src/scanner/detect-infra.ts
 async function detectInfra(rootDir) {
-  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"));
+  const docker = await fileExists(path15.join(rootDir, "Dockerfile")) || await fileExists(path15.join(rootDir, "docker-compose.yml")) || await fileExists(path15.join(rootDir, "docker-compose.yaml"));
+  const kubernetes = await fileExists(path15.join(rootDir, "k8s")) || await fileExists(path15.join(rootDir, "kubernetes"));
   let ci = "none";
   const ciFiles = [];
   for (const [platform, filePath] of Object.entries(CI_PLATFORM_FILES)) {
-    if (await fileExists(path14.join(rootDir, filePath))) {
+    if (await fileExists(path15.join(rootDir, filePath))) {
       if (ci === "none") ci = platform;
       ciFiles.push(filePath);
     }
@@ -2198,12 +2300,12 @@ async function detectInfra(rootDir) {
   ];
   const infrastructureFiles = (await Promise.all(
     infrastructureCandidates.map(
-      async (file) => await fileExists(path14.join(rootDir, file)) ? file : void 0
+      async (file) => await fileExists(path15.join(rootDir, file)) ? file : void 0
     )
   )).filter((file) => file !== void 0);
   const deploymentFiles = (await Promise.all(
     deploymentCandidates.map(
-      async (file) => await fileExists(path14.join(rootDir, file)) ? file : void 0
+      async (file) => await fileExists(path15.join(rootDir, file)) ? file : void 0
     )
   )).filter((file) => file !== void 0);
   return { docker, kubernetes, ci, ciFiles, infrastructureFiles, deploymentFiles };
@@ -2211,12 +2313,12 @@ async function detectInfra(rootDir) {
 
 // src/scanner/detect-services.ts
 import { readFile as readFile7 } from "fs/promises";
-import path15 from "path";
+import path16 from "path";
 async function detectProjectManagement(rootDir) {
   const tools = [];
   const mcpConfigPaths = [
-    path15.join(rootDir, ".cursor", "mcp.json"),
-    path15.join(rootDir, "mcp.json")
+    path16.join(rootDir, ".cursor", "mcp.json"),
+    path16.join(rootDir, "mcp.json")
   ];
   for (const configPath of mcpConfigPaths) {
     if (!await fileExists(configPath)) continue;
@@ -2232,20 +2334,20 @@ async function detectProjectManagement(rootDir) {
     } catch {
     }
   }
-  if (await fileExists(path15.join(rootDir, ".github", "ISSUE_TEMPLATE"))) {
+  if (await fileExists(path16.join(rootDir, ".github", "ISSUE_TEMPLATE"))) {
     tools.push("github-issues");
   }
-  if (await fileExists(path15.join(rootDir, ".github", "projects"))) {
+  if (await fileExists(path16.join(rootDir, ".github", "projects"))) {
     tools.push("github-projects");
   }
   return [...new Set(tools)];
 }
 async function detectServices(rootDir) {
-  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 hasPrisma = await fileExists(path16.join(rootDir, "prisma/schema.prisma"));
+  const hasSequelize = await fileExists(path16.join(rootDir, "sequelize"));
+  const hasDrizzle = await fileExists(path16.join(rootDir, "drizzle.config.ts"));
+  const hasKnex = await fileExists(path16.join(rootDir, "knexfile.ts"));
+  const hasTypeorm = await fileExists(path16.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);
@@ -2257,7 +2359,7 @@ async function detectServices(rootDir) {
 }
 
 // src/scanner/detect-stack.ts
-import path16 from "path";
+import path17 from "path";
 var PROJECT_MARKERS = [
   "package.json",
   "requirements.txt",
@@ -2286,7 +2388,7 @@ async function detectPackageManager(rootDir, packageJson) {
     };
   }
   for (const [lockfile, packageManager] of LOCKFILES) {
-    if (await fileExists(path16.join(rootDir, lockfile))) {
+    if (await fileExists(path17.join(rootDir, lockfile))) {
       return {
         packageManager,
         evidence: [{ source: "file", value: lockfile }]
@@ -2303,27 +2405,27 @@ function commandsForScripts(scripts, packageManager) {
   return { testCommands, validationCommands };
 }
 async function detectStack(rootDir) {
-  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"));
+  const hasAnyProjectMarker = (await Promise.all(PROJECT_MARKERS.map((item) => fileExists(path17.join(rootDir, item))))).some(Boolean);
+  const hasPackageJson = await fileExists(path17.join(rootDir, "package.json"));
   if (hasPackageJson) {
-    const packageJson = await readJson(path16.join(rootDir, "package.json")) ?? {};
+    const packageJson = await readJson(path17.join(rootDir, "package.json")) ?? {};
     const scripts = packageJson.scripts ?? {};
     const packageManager = await detectPackageManager(rootDir, packageJson);
     const commands = commandsForScripts(scripts, packageManager.packageManager);
-    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"));
+    const hasNextConfig = await fileExists(path17.join(rootDir, "next.config.js")) || await fileExists(path17.join(rootDir, "next.config.mjs")) || await fileExists(path17.join(rootDir, "next.config.ts"));
+    const hasNestConfig = await fileExists(path17.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(path16.join(rootDir, "pnpm-workspace.yaml")),
+      workspaces: packageJson.workspaces !== void 0 || await fileExists(path17.join(rootDir, "pnpm-workspace.yaml")),
       ...commands,
       hasProjectFiles: hasAnyProjectMarker
     };
   }
-  if (await fileExists(path16.join(rootDir, "pyproject.toml"))) {
+  if (await fileExists(path17.join(rootDir, "pyproject.toml"))) {
     return {
       language: "python",
       framework: "python",
@@ -2333,7 +2435,7 @@ async function detectStack(rootDir) {
       hasProjectFiles: hasAnyProjectMarker
     };
   }
-  if (await fileExists(path16.join(rootDir, "go.mod"))) {
+  if (await fileExists(path17.join(rootDir, "go.mod"))) {
     return {
       language: "go",
       framework: "go",
@@ -2343,7 +2445,7 @@ async function detectStack(rootDir) {
       hasProjectFiles: hasAnyProjectMarker
     };
   }
-  if (await fileExists(path16.join(rootDir, "Cargo.toml"))) {
+  if (await fileExists(path17.join(rootDir, "Cargo.toml"))) {
     return {
       language: "rust",
       framework: "rust",
@@ -2353,7 +2455,7 @@ async function detectStack(rootDir) {
       hasProjectFiles: hasAnyProjectMarker
     };
   }
-  if (await fileExists(path16.join(rootDir, "composer.json"))) {
+  if (await fileExists(path17.join(rootDir, "composer.json"))) {
     return {
       language: "php",
       framework: "php",
@@ -2386,7 +2488,7 @@ function isGreenfieldByEntries(entries) {
   return meaningful.length === 0;
 }
 async function runScanner(rootDir) {
-  const normalizedRoot = path17.resolve(rootDir);
+  const normalizedRoot = path18.resolve(rootDir);
   const entries = await listDirectory(normalizedRoot);
   const stack = await detectStack(normalizedRoot);
   const purpose = await detectPurpose(normalizedRoot, stack);
@@ -2537,10 +2639,13 @@ function preferenceDefaults(onboarding, onboarded) {
       enabled: false,
       backend: "claude",
       autoRemediate: false,
-      offerOnExhausted: true
+      offerOnExhausted: true,
+      mode: "paste",
+      midBatchAudits: false,
+      preflight: "off"
     },
     autoHandoff: false,
-    workspaceSkin: {
+    agentPersona: {
       default: "autopilot",
       modes: {
         "continue-plan": "autopilot",
@@ -2587,7 +2692,7 @@ async function executeSafeReadinessFixes(rootDir, options) {
   });
   const changes = [];
   for (const relativePath of ESSENTIAL_DIRECTORIES) {
-    const absolutePath = path18.join(beforeScan.rootDir, relativePath);
+    const absolutePath = path19.join(beforeScan.rootDir, relativePath);
     const exists = await fileExists(absolutePath);
     if (!exists && !dryRun) await ensureDir(absolutePath);
     recordChange(
@@ -2600,7 +2705,7 @@ async function executeSafeReadinessFixes(rootDir, options) {
     );
   }
   const gitignoreRelativePath = ".gitignore";
-  const gitignorePath = path18.join(beforeScan.rootDir, gitignoreRelativePath);
+  const gitignorePath = path19.join(beforeScan.rootDir, gitignoreRelativePath);
   const existingGitignore = await fileExists(gitignorePath) ? await readFile8(gitignorePath, "utf8") : "";
   const mergedGitignore = mergeSecretIgnores(existingGitignore);
   const gitignoreChanged = mergedGitignore !== existingGitignore;
@@ -2616,7 +2721,7 @@ async function executeSafeReadinessFixes(rootDir, options) {
       gitignoreChanged ? "required secret patterns are missing" : "required patterns are present"
     )
   );
-  const profilePath = path18.join(beforeScan.rootDir, PROFILE_RELATIVE_PATH);
+  const profilePath = path19.join(beforeScan.rootDir, PROFILE_RELATIVE_PATH);
   const existingProfile = await readJson(profilePath) ?? {};
   const desiredProfile = createProfile(beforeScan, before, generatedAt);
   const mergedProfile = mergeMissing(existingProfile, desiredProfile);
@@ -2638,7 +2743,7 @@ async function executeSafeReadinessFixes(rootDir, options) {
     generatorVersion: options.generatorVersion,
     generatedAt
   });
-  const contextConfigPath = path18.join(beforeScan.rootDir, CONTEXT_CONFIG_RELATIVE_PATH);
+  const contextConfigPath = path19.join(beforeScan.rootDir, CONTEXT_CONFIG_RELATIVE_PATH);
   const existingContextConfig = await readJson(contextConfigPath) ?? {};
   const onboarding = reconcileOnboardingState(evidenceReport, existingContextConfig, generatedAt);
   const defaults = preferenceDefaults(onboarding, existingContextConfig.onboarded);
@@ -2667,17 +2772,17 @@ async function executeSafeReadinessFixes(rootDir, options) {
 }
 
 // src/scanner/snapshot.ts
-import path19 from "path";
+import path20 from "path";
 var READINESS_SNAPSHOT_RELATIVE_PATH = ".cursor/context/readiness.json";
 async function writeReadinessSnapshot(rootDir, report) {
-  const snapshotPath = path19.join(rootDir, READINESS_SNAPSHOT_RELATIVE_PATH);
+  const snapshotPath = path20.join(rootDir, READINESS_SNAPSHOT_RELATIVE_PATH);
   await writeJson(snapshotPath, report);
   return snapshotPath;
 }
 
 // src/commands/doctor.ts
 async function runDoctor(cwd, options = {}) {
-  const rootDir = path20.resolve(cwd);
+  const rootDir = path21.resolve(cwd);
   if (options.fixSafe) {
     const execution = await executeSafeReadinessFixes(rootDir, {
       generatorVersion: KIT_VERSION,
@@ -2708,7 +2813,7 @@ function printDoctorSummary(result) {
     nextAction ? `Next: ${nextAction.recommendation}` : "Next: repository readiness checks are complete"
   );
 }
-var doctorCommand = defineCommand5({
+var doctorCommand = defineCommand6({
   meta: {
     name: "doctor",
     description: "Diagnose repository readiness and optionally apply safe local fixes."
@@ -2740,10 +2845,10 @@ var doctorCommand = defineCommand5({
 });
 
 // src/commands/handoff.ts
-import { spawn as spawn2 } from "child_process";
+import { spawn as spawn3 } from "child_process";
 import { readFile as readFile9, readdir as readdir2, writeFile as writeFile4 } from "fs/promises";
-import path21 from "path";
-import { defineCommand as defineCommand6 } from "citty";
+import path22 from "path";
+import { defineCommand as defineCommand7 } from "citty";
 function parsePlanFrontmatter(raw) {
   const match = raw.match(/^---\n([\s\S]*?)\n---/);
   if (!match?.[1]) return null;
@@ -2762,19 +2867,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(path21.join(plansDir, file), "utf8");
+    const raw = await readFile9(path22.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(path21.join(plansDir, files[0]), "utf8") } : null;
+  return files[0] ? { file: files[0], raw: await readFile9(path22.join(plansDir, files[0]), "utf8") } : null;
 }
 function now() {
   return (/* @__PURE__ */ new Date()).toISOString().replace("T", " ").slice(0, 16);
 }
 async function loadProfile(rootDir) {
-  const configPath = path21.join(rootDir, ".cursor", "agent-kit.config.json");
+  const configPath = path22.join(rootDir, ".cursor", "agent-kit.config.json");
   try {
     return await readJson(configPath);
   } catch {
@@ -2852,7 +2957,7 @@ function printV3Guidance() {
 }
 function runCursorHandoff(scriptPath, cwd) {
   return new Promise((resolve, reject) => {
-    const child = spawn2("sh", [scriptPath, "handoff"], {
+    const child = spawn3("sh", [scriptPath, "handoff"], {
       cwd,
       stdio: "inherit"
     });
@@ -2860,7 +2965,7 @@ function runCursorHandoff(scriptPath, cwd) {
     child.on("close", (code) => resolve(code ?? 1));
   });
 }
-var handoffCommand = defineCommand6({
+var handoffCommand = defineCommand7({
   meta: {
     name: "handoff",
     description: "Write .cursor/HANDOFF.md from the active Cursor plan, or run ./cursor-handoff handoff when no plan exists."
@@ -2874,13 +2979,13 @@ var handoffCommand = defineCommand6({
   },
   async run({ args }) {
     const profile = await loadProfile(args.cwd);
-    const plansDir = path21.join(args.cwd, ".cursor", "plans");
-    const handoffPath = path21.join(args.cwd, ".cursor", "HANDOFF.md");
+    const plansDir = path22.join(args.cwd, ".cursor", "plans");
+    const handoffPath = path22.join(args.cwd, ".cursor", "HANDOFF.md");
     const plan = await findActivePlan(plansDir);
     if (plan) {
       const fm = parsePlanFrontmatter(plan.raw);
       if (fm) {
-        await ensureDir(path21.join(args.cwd, ".cursor"));
+        await ensureDir(path22.join(args.cwd, ".cursor"));
         const content = buildHandoff(plan.file, fm, profile);
         await writeFile4(handoffPath, content, "utf8");
         logger.success("HANDOFF.md updated: .cursor/HANDOFF.md");
@@ -2900,7 +3005,7 @@ var handoffCommand = defineCommand6({
       }
       logger.warn(`Plan ${plan.file} without valid frontmatter; trying legacy flow.`);
     }
-    const scriptPath = path21.join(args.cwd, "cursor-handoff");
+    const scriptPath = path22.join(args.cwd, "cursor-handoff");
     if (!await fileExists(scriptPath)) {
       printV3Guidance();
       return;
@@ -2926,15 +3031,15 @@ var handoffCommand = defineCommand6({
 
 // src/commands/init.ts
 import { intro, outro } from "@clack/prompts";
-import { defineCommand as defineCommand8 } from "citty";
+import { defineCommand as defineCommand9 } from "citty";
 
 // src/commands/install.ts
-import path24 from "path";
-import { defineCommand as defineCommand7 } from "citty";
+import path25 from "path";
+import { defineCommand as defineCommand8 } from "citty";
 
 // src/generator/personalization.ts
 import { readFile as readFile10, writeFile as writeFile5 } from "fs/promises";
-import path22 from "path";
+import path23 from "path";
 var PERSONALIZATION_CONTRACT_VERSION = 1;
 var CONTEXT_PATH = ".cursor/project-context.md";
 var AGENTS_PATH = "AGENTS.md";
@@ -3085,7 +3190,7 @@ function renderProjectContext(profile) {
 `;
 }
 async function createOwnedFile(rootDir, relativePath, content, evidence) {
-  const target = path22.join(rootDir, relativePath);
+  const target = path23.join(rootDir, relativePath);
   if (await fileExists(target)) {
     return {
       kind: "file",
@@ -3095,7 +3200,7 @@ async function createOwnedFile(rootDir, relativePath, content, evidence) {
       evidence
     };
   }
-  await ensureDir(path22.dirname(target));
+  await ensureDir(path23.dirname(target));
   await writeFile5(target, content, "utf8");
   return {
     kind: "file",
@@ -3112,7 +3217,7 @@ async function packTargets(registryRoot, packId) {
 async function existingTargets(projectRoot, targets) {
   const checks = await Promise.all(
     targets.map(
-      async (target) => await fileExists(path22.join(projectRoot, target)) ? target : null
+      async (target) => await fileExists(path23.join(projectRoot, target)) ? target : null
     )
   );
   return checks.filter((target) => target !== null);
@@ -3134,14 +3239,14 @@ async function applyPersonalization(input) {
         componentResults.push({ ...item, status: "unavailable" });
         continue;
       }
-      const target = path22.posix.join(
+      const target = path23.posix.join(
         ".cursor",
         "skills",
         skill.path.includes("/core/") ? "core" : "community",
         skill.id,
         "SKILL.md"
       );
-      if (await fileExists(path22.join(input.rootDir, target))) {
+      if (await fileExists(path23.join(input.rootDir, target))) {
         componentResults.push({ ...item, status: "skipped-customized", path: target });
         protectedPaths.add(target);
         continue;
@@ -3196,7 +3301,7 @@ async function applyPersonalization(input) {
     items: [...fileResults, ...componentResults],
     protectedPaths: [...protectedPaths].sort()
   };
-  await writeJson(path22.join(input.rootDir, RESULT_PATH), result);
+  await writeJson(path23.join(input.rootDir, RESULT_PATH), result);
   return {
     result,
     manifest: {
@@ -3214,7 +3319,7 @@ async function applyPersonalization(input) {
   };
 }
 async function readRepositoryProfile(rootDir) {
-  const target = path22.join(rootDir, ".cursor/agent-kit.config.json");
+  const target = path23.join(rootDir, ".cursor/agent-kit.config.json");
   if (!await fileExists(target)) return null;
   return JSON.parse(await readFile10(target, "utf8"));
 }
@@ -3222,16 +3327,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 path23 from "path";
+import path24 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 = path23.join(projectRoot, LEGACY_ONBOARD_PATH);
+  const legacyPath = path24.join(projectRoot, LEGACY_ONBOARD_PATH);
   if (!await fileExists(legacyPath)) return "absent";
-  const namespacedPath = path23.join(projectRoot, NAMESPACED_ONBOARD_PATH);
+  const namespacedPath = path24.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");
@@ -3302,7 +3407,7 @@ function printReadinessNarrative(result) {
   );
 }
 async function performInstall(options) {
-  const projectRoot = path24.resolve(options.cwd);
+  const projectRoot = path25.resolve(options.cwd);
   const packs = parsePackList(options.pack);
   const existing = await loadAgentKitManifest(projectRoot);
   const registry = await resolveRegistryFromCli({
@@ -3356,7 +3461,7 @@ async function performInstall(options) {
     safeChanges: readinessExecution.changes
   };
 }
-var installCommand = defineCommand7({
+var installCommand = defineCommand8({
   meta: {
     name: "install",
     description: "Bootstrap L0 (+ optional packs) from the registry and write agent-kit.json."
@@ -3378,7 +3483,7 @@ var installCommand = defineCommand7({
     ...REGISTRY_CLI_ARGS
   },
   async run({ args }) {
-    const projectRoot = path24.resolve(args.cwd);
+    const projectRoot = path25.resolve(args.cwd);
     logger.info(`Installing into: ${projectRoot}`);
     const packs = parsePackList(args.pack);
     for (const id of packs) {
@@ -3406,7 +3511,7 @@ var installCommand = defineCommand7({
 async function runInitCompatibility(cwd, installer = performInstall) {
   return installer({ cwd });
 }
-var initCommand = defineCommand8({
+var initCommand = defineCommand9({
   meta: {
     name: "init",
     description: "Guided compatibility entry point for install and repository readiness."
@@ -3431,11 +3536,11 @@ var initCommand = defineCommand8({
 });
 
 // src/commands/run-plan.ts
-import path29 from "path";
-import { defineCommand as defineCommand9 } from "citty";
+import path30 from "path";
+import { defineCommand as defineCommand10 } from "citty";
 
 // src/plan-loop/backends.ts
-import { execFileSync, spawn as spawn3 } from "child_process";
+import { execFileSync, spawn as spawn4 } from "child_process";
 import { createWriteStream } from "fs";
 async function which(bin) {
   try {
@@ -3448,7 +3553,7 @@ async function which(bin) {
 function spawnLogged(command, args, logPath) {
   return new Promise((resolve, reject) => {
     const out = createWriteStream(logPath, { flags: "w" });
-    const child = spawn3(command, args, {
+    const child = spawn4(command, args, {
       stdio: ["ignore", "pipe", "pipe"]
     });
     const onData = (chunk) => {
@@ -3517,13 +3622,13 @@ function listBackendIds() {
 
 // src/plan-loop/run-loop.ts
 import { mkdir as mkdir4, readFile as readFile14, rm, unlink as unlink2 } from "fs/promises";
-import path28 from "path";
+import path29 from "path";
 
 // src/plan-loop/external-review.ts
-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");
+import { spawn as spawn5 } from "child_process";
+import path26 from "path";
+var CANONICAL_REL = path26.join(".cursor", "scripts", "plan-external-review.sh");
+var FALLBACK_REL = path26.join("scripts", "plan-external-review.sh");
 function isPlanExhaustedReason(reason) {
   const r = reason.trim().toLowerCase();
   if (!r) return false;
@@ -3541,12 +3646,12 @@ function shouldArmExternalPlanReview(input) {
   return false;
 }
 async function armExternalPlanReview(root, options = {}) {
-  const spawnFn = options.spawnFn ?? spawn4;
+  const spawnFn = options.spawnFn ?? spawn5;
   const existsFn = options.existsFn ?? fileExists;
   const log = options.log ?? ((line) => console.log(line));
   const force = options.force === true;
-  const canonicalPath = path25.join(root, CANONICAL_REL);
-  const fallbackPath = path25.join(root, FALLBACK_REL);
+  const canonicalPath = path26.join(root, CANONICAL_REL);
+  const fallbackPath = path26.join(root, FALLBACK_REL);
   let scriptPath = null;
   let scriptRel = CANONICAL_REL;
   if (await existsFn(canonicalPath)) {
@@ -3563,11 +3668,11 @@ async function armExternalPlanReview(root, options = {}) {
     return { invoked: false, exitCode: null, output: "" };
   }
   log("Plan exhausted: arming optional external plan review (opt-in handled by script)...");
-  const args = force ? [scriptPath, "--force"] : [scriptPath];
+  const args = force ? [scriptPath, "--force", "--print"] : [scriptPath, "--print"];
   return new Promise((resolve) => {
     const child = spawnFn("bash", args, {
       cwd: root,
-      env: process.env
+      env: { ...process.env, AGENT_KIT_HEADLESS: "1" }
     });
     let output = "";
     const append = (chunk) => {
@@ -3598,9 +3703,105 @@ async function armExternalPlanReview(root, options = {}) {
   });
 }
 
+// src/plan-loop/persona-banners.ts
+import path27 from "path";
+import {
+  blue,
+  cyan as cyan2,
+  gray,
+  green as green2,
+  lightGray,
+  lightGreen,
+  magenta,
+  red as red2,
+  white,
+  yellow as yellow2
+} from "kolorist";
+var CLI_RUN_PLAN_MODE = "cli-run-plan";
+var DEFAULT_CLI_PERSONA_ID = "ghost-runner";
+var COLORS = {
+  white,
+  gray,
+  green: green2,
+  cyan: cyan2,
+  magenta,
+  yellow: yellow2,
+  red: red2,
+  blue,
+  "light-green": lightGreen,
+  lightgreen: lightGreen,
+  "light-gray": lightGray,
+  lightgray: lightGray
+};
+function resolveColor(name, fallback) {
+  if (!name) return fallback;
+  return COLORS[name.toLowerCase()] ?? fallback;
+}
+async function resolveCliPersonaId(root) {
+  try {
+    const cfg = await readJson(
+      path27.join(root, ".cursor", "context", "config.json")
+    );
+    const modes = cfg?.agentPersona?.modes ?? cfg?.workspaceSkin?.modes;
+    const id = modes?.[CLI_RUN_PLAN_MODE];
+    if (typeof id === "string" && id.trim()) return id.trim();
+  } catch {
+  }
+  return DEFAULT_CLI_PERSONA_ID;
+}
+async function loadPersonaPack(root, personaId) {
+  try {
+    const personaPath = path27.join(root, "registry", "personas", "core", personaId, "persona.json");
+    const pack = await readJson(personaPath);
+    if (!pack || typeof pack.id !== "string") return null;
+    return pack;
+  } catch {
+    return null;
+  }
+}
+async function loadCliRunPlanPersona(root) {
+  const id = await resolveCliPersonaId(root);
+  return loadPersonaPack(root, id);
+}
+function createPersonaBannerPrinter(persona) {
+  if (!persona?.cliBanners) return null;
+  const banners = persona.cliBanners;
+  if (!banners.tickStart && !banners.tickEnd && !banners.phaseComplete) return null;
+  const primary = resolveColor(persona.ansiPalette?.primary, white);
+  const secondary = resolveColor(persona.ansiPalette?.secondary, gray);
+  const accent = resolveColor(persona.ansiPalette?.accent, green2);
+  return {
+    tickStart(detail) {
+      if (banners.tickStart) {
+        console.log(`${accent(banners.tickStart)} ${primary(detail)}`);
+      } else {
+        console.log(primary(detail));
+      }
+    },
+    tickEnd(detail) {
+      if (!banners.tickEnd) return;
+      const line = detail ? `${banners.tickEnd} ${detail}` : banners.tickEnd;
+      console.log(secondary(line));
+    },
+    phaseComplete(detail) {
+      if (!banners.phaseComplete) return;
+      const line = detail ? `${banners.phaseComplete} ${detail}` : banners.phaseComplete;
+      console.log(accent(line));
+    },
+    sleep(seconds) {
+      console.log(secondary(`sleep ${seconds}s`));
+    },
+    stop(reason) {
+      if (banners.tickEnd) {
+        console.log(secondary(`${banners.tickEnd} ${reason}`));
+      }
+    }
+  };
+}
+
 // src/plan-loop/plan-state.ts
 import { readFile as readFile12, readdir as readdir3 } from "fs/promises";
-import path26 from "path";
+import path28 from "path";
 function countPendingTodos(raw) {
   const lines = raw.split(/\r?\n/);
   let inFront = 0;
@@ -3628,7 +3829,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] ? path26.join(plansDir, files[0]) : null;
+  return files[0] ? path28.join(plansDir, files[0]) : null;
 }
 async function readPlan(planPath) {
   return readFile12(planPath, "utf8");
@@ -3694,101 +3895,6 @@ function formatSentinelLine(sentinel) {
   return "";
 }
 
-// src/plan-loop/skin-banners.ts
-import path27 from "path";
-import {
-  blue,
-  cyan as cyan2,
-  gray,
-  green as green2,
-  lightGray,
-  lightGreen,
-  magenta,
-  red as red2,
-  white,
-  yellow as yellow2
-} from "kolorist";
-var CLI_RUN_PLAN_MODE = "cli-run-plan";
-var DEFAULT_CLI_SKIN_ID = "ghost-runner";
-var COLORS = {
-  white,
-  gray,
-  green: green2,
-  cyan: cyan2,
-  magenta,
-  yellow: yellow2,
-  red: red2,
-  blue,
-  "light-green": lightGreen,
-  lightgreen: lightGreen,
-  "light-gray": lightGray,
-  lightgray: lightGray
-};
-function resolveColor(name, fallback) {
-  if (!name) return fallback;
-  return COLORS[name.toLowerCase()] ?? fallback;
-}
-async function resolveCliSkinId(root) {
-  try {
-    const cfg = await readJson(
-      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();
-  } catch {
-  }
-  return DEFAULT_CLI_SKIN_ID;
-}
-async function loadSkinPack(root, skinId) {
-  try {
-    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;
-  } catch {
-    return null;
-  }
-}
-async function loadCliRunPlanSkin(root) {
-  const id = await resolveCliSkinId(root);
-  return loadSkinPack(root, id);
-}
-function createSkinBannerPrinter(skin) {
-  if (!skin?.cliBanners) return null;
-  const banners = skin.cliBanners;
-  if (!banners.tickStart && !banners.tickEnd && !banners.phaseComplete) return null;
-  const primary = resolveColor(skin.ansiPalette?.primary, white);
-  const secondary = resolveColor(skin.ansiPalette?.secondary, gray);
-  const accent = resolveColor(skin.ansiPalette?.accent, green2);
-  return {
-    tickStart(detail) {
-      if (banners.tickStart) {
-        console.log(`${accent(banners.tickStart)} ${primary(detail)}`);
-      } else {
-        console.log(primary(detail));
-      }
-    },
-    tickEnd(detail) {
-      if (!banners.tickEnd) return;
-      const line = detail ? `${banners.tickEnd} ${detail}` : banners.tickEnd;
-      console.log(secondary(line));
-    },
-    phaseComplete(detail) {
-      if (!banners.phaseComplete) return;
-      const line = detail ? `${banners.phaseComplete} ${detail}` : banners.phaseComplete;
-      console.log(accent(line));
-    },
-    sleep(seconds) {
-      console.log(secondary(`sleep ${seconds}s`));
-    },
-    stop(reason) {
-      if (banners.tickEnd) {
-        console.log(secondary(`${banners.tickEnd} ${reason}`));
-      }
-    }
-  };
-}
-
 // src/plan-loop/run-loop.ts
 var TICK_PROMPT = '/run-plan - single tick from the headless runner (agent-kit run-plan). Read .cursor/HANDOFF.md and the active plan in .cursor/plans/. Mark the next to-do as in_progress in the frontmatter, execute ONLY that to-do, mark completed and update HANDOFF. If there is a commitable diff: run /git-staging without asking for confirmation. NEVER /git-prod. Do NOT re-arm an internal Loop skill - the external runner starts the next agent. End the response with exactly one line: "LOOP_TICK_RESULT: continue" if implementable to-dos remain, or "LOOP_TICK_RESULT: stop - <reason>" (plan exhausted, external blocker, or human decision needed).';
 function stamp() {
@@ -3800,9 +3906,9 @@ function sleep(ms) {
   return new Promise((r) => setTimeout(r, ms));
 }
 async function runPlanLoop(opts) {
-  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 plansDir = path29.join(opts.root, ".cursor", "plans");
+  const stopFile = path29.join(opts.root, ".cursor", "loop.stop");
+  const logDir = path29.join(opts.root, ".cursor", "loop-logs");
   const planPath = await findActivePlanFile(plansDir);
   if (!planPath) {
     logger.error("No active plan in .cursor/plans/");
@@ -3821,13 +3927,13 @@ async function runPlanLoop(opts) {
   };
   process.on("SIGINT", onSigInt);
   try {
-    const skin = await loadCliRunPlanSkin(opts.root);
-    const banners = createSkinBannerPrinter(skin);
-    console.log(`Active plan: ${path28.basename(planPath)}`);
+    const persona = await loadCliRunPlanPersona(opts.root);
+    const banners = createPersonaBannerPrinter(persona);
+    console.log(`Active plan: ${path29.basename(planPath)}`);
     console.log(`Pending to-dos: ${await pending()} | max ticks: ${opts.maxTicks}`);
     console.log(`Backend: ${opts.backend.id}`);
-    if (skin) {
-      console.log(`CLI skin: ${skin.displayName ?? skin.id}`);
+    if (persona) {
+      console.log(`CLI persona: ${persona.displayName ?? persona.id}`);
     }
     if (opts.dryRun) {
       console.log("--dry-run: no agent will be started. Tick prompt:");
@@ -3866,8 +3972,8 @@ async function runPlanLoop(opts) {
         planExhausted = true;
         break;
       }
-      const logPath = path28.join(logDir, `tick-${stamp()}.log`);
-      const relLog = path28.relative(opts.root, logPath);
+      const logPath = path29.join(logDir, `tick-${stamp()}.log`);
+      const relLog = path29.relative(opts.root, logPath);
       console.log("");
       const tickLine = `=== tick ${tick}/${opts.maxTicks} - pending: ${before} - log: ${relLog} ===`;
       if (banners) banners.tickStart(tickLine);
@@ -3943,7 +4049,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 ${path28.relative(opts.root, logDir)}/`
+      `Loop finished after ${tick} tick(s). Pending now: ${pendingNow}. Logs in ${path29.relative(opts.root, logDir)}/`
     );
     if (planExhausted || shouldArmExternalPlanReview({ pending: pendingNow, stopReason })) {
       await armExternalPlanReview(opts.root);
@@ -3955,7 +4061,7 @@ async function runPlanLoop(opts) {
 }
 
 // src/commands/run-plan.ts
-var runPlanCommand = defineCommand9({
+var runPlanCommand = defineCommand10({
   meta: {
     name: "run-plan",
     description: "Headless continuous plan runner: one fresh agent per tick (LOOP_TICK_RESULT contract). Never git-prod."
@@ -4014,7 +4120,7 @@ var runPlanCommand = defineCommand9({
       return;
     }
     const code = await runPlanLoop({
-      root: path29.resolve(args.cwd),
+      root: path30.resolve(args.cwd),
       maxTicks,
       sleepSeconds,
       model: args.model ? String(args.model) : void 0,
@@ -4026,8 +4132,8 @@ var runPlanCommand = defineCommand9({
 });
 
 // src/commands/scan.ts
-import { defineCommand as defineCommand10 } from "citty";
-var scanCommand = defineCommand10({
+import { defineCommand as defineCommand11 } from "citty";
+var scanCommand = defineCommand11({
   meta: {
     name: "scan",
     description: "Scan the current repository and print detected profile."
@@ -4048,8 +4154,8 @@ var scanCommand = defineCommand10({
 });
 
 // src/commands/status.ts
-import path30 from "path";
-import { defineCommand as defineCommand11 } from "citty";
+import path31 from "path";
+import { defineCommand as defineCommand12 } from "citty";
 function profileStatus(profile) {
   if (!profile) return { origin: "none", evidence: [], profile: null };
   if ("detection" in profile && profile.detection && typeof profile.detection === "object") {
@@ -4062,7 +4168,7 @@ function profileStatus(profile) {
   }
   return { origin: "legacy-wizard", evidence: [], profile };
 }
-var statusCommand = defineCommand11({
+var statusCommand = defineCommand12({
   meta: {
     name: "status",
     description: "Show Agent Kit distribution status (manifest + optional wizard profile)."
@@ -4079,11 +4185,11 @@ var statusCommand = defineCommand11({
     }
   },
   async run({ args }) {
-    const rootDir = path30.resolve(args.cwd);
+    const rootDir = path31.resolve(args.cwd);
     const [manifest, rawProfile, scan] = await Promise.all([
       loadAgentKitManifest(rootDir),
       readJson(
-        path30.join(rootDir, ".cursor", "agent-kit.config.json")
+        path31.join(rootDir, ".cursor", "agent-kit.config.json")
       ),
       runScanner(rootDir)
     ]);
@@ -4138,20 +4244,297 @@ var statusCommand = defineCommand11({
 });
 
 // src/commands/update.ts
-import { defineCommand as defineCommand12 } from "citty";
-var updateCommand = defineCommand12({
+import { defineCommand as defineCommand13 } from "citty";
+
+// src/lifecycle/check-updates.ts
+import { execFile as execFile3 } from "child_process";
+import path32 from "path";
+import { promisify as promisify3 } from "util";
+var execFileAsync2 = promisify3(execFile3);
+var SEMVER_CORE = /^v?(\d+)\.(\d+)\.(\d+)(?:[-+].*)?$/i;
+var FACTORY_URL_MARKERS = ["agent-kit-dev"];
+var FACTORY_REFS = /* @__PURE__ */ new Set(["staging", "homologacao", "develop", "dev"]);
+var DEFAULT_UPDATE_CHECK = {
+  enabled: false,
+  intervalDays: 7,
+  lastCheckedAt: null
+};
+function gitEnv2() {
+  return { ...process.env, GIT_ALLOW_PROTOCOL: "https" };
+}
+function compareSemver(a, b) {
+  const pa = parseSemverParts(a);
+  const pb = parseSemverParts(b);
+  if (!pa || !pb) {
+    throw new Error(`Invalid semver for compare: "${a}" vs "${b}"`);
+  }
+  for (let i = 0; i < 3; i++) {
+    const d = (pa[i] ?? 0) - (pb[i] ?? 0);
+    if (d !== 0) return d < 0 ? -1 : 1;
+  }
+  return 0;
+}
+function parseSemverParts(version) {
+  const m = SEMVER_CORE.exec(version.trim());
+  if (!m) return null;
+  return [Number(m[1]), Number(m[2]), Number(m[3])];
+}
+function normalizeSemver(version) {
+  const parts = parseSemverParts(version);
+  if (!parts) return null;
+  return `${parts[0]}.${parts[1]}.${parts[2]}`;
+}
+function isFactoryOrDevRegistry(url, ref) {
+  if (url) {
+    const lower = url.toLowerCase();
+    if (FACTORY_URL_MARKERS.some((m) => lower.includes(m))) return true;
+  }
+  if (ref && FACTORY_REFS.has(ref.toLowerCase())) return true;
+  return false;
+}
+function pickLatestSemverTag(lsRemoteStdout) {
+  let best = null;
+  for (const line of lsRemoteStdout.split("\n")) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+    const ref = trimmed.split(/\s+/)[1];
+    if (!ref?.startsWith("refs/tags/")) continue;
+    if (ref.endsWith("^{}")) continue;
+    const tag = ref.slice("refs/tags/".length);
+    const norm = normalizeSemver(tag);
+    if (!norm) continue;
+    if (!best || compareSemver(norm, best) > 0) best = norm;
+  }
+  return best;
+}
+async function fetchLatestPublicVersion(registryUrl = DEFAULT_REGISTRY_URL) {
+  assertSafeRegistrySource(registryUrl, "main");
+  const { stdout } = await execFileAsync2("git", ["ls-remote", "--tags", "--", registryUrl], {
+    env: gitEnv2(),
+    timeout: 2e4
+  });
+  return pickLatestSemverTag(stdout);
+}
+function readUpdateCheckPrefs(config) {
+  if (!config || typeof config !== "object" || Array.isArray(config)) {
+    return { ...DEFAULT_UPDATE_CHECK };
+  }
+  const raw = config.updateCheck;
+  if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
+    return { ...DEFAULT_UPDATE_CHECK };
+  }
+  const uc = raw;
+  const intervalDays = typeof uc.intervalDays === "number" && Number.isInteger(uc.intervalDays) && uc.intervalDays >= 1 ? uc.intervalDays : DEFAULT_UPDATE_CHECK.intervalDays;
+  return {
+    enabled: uc.enabled === true,
+    intervalDays,
+    lastCheckedAt: typeof uc.lastCheckedAt === "string" ? uc.lastCheckedAt : null
+  };
+}
+function intervalElapsed(lastCheckedAt, intervalDays) {
+  if (!lastCheckedAt) return true;
+  const last = Date.parse(lastCheckedAt);
+  if (Number.isNaN(last)) return true;
+  const ms = intervalDays * 24 * 60 * 60 * 1e3;
+  return Date.now() - last >= ms;
+}
+async function loadContextConfig(cwd) {
+  const configPath = path32.join(cwd, ".cursor", "context", "config.json");
+  return readJson(configPath);
+}
+async function stampLastCheckedAt(cwd) {
+  const configPath = path32.join(cwd, ".cursor", "context", "config.json");
+  const existing = await loadContextConfig(cwd) ?? {};
+  const prev = existing.updateCheck && typeof existing.updateCheck === "object" ? { ...existing.updateCheck } : {};
+  existing.updateCheck = {
+    ...DEFAULT_UPDATE_CHECK,
+    ...prev,
+    lastCheckedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  await writeJson(configPath, existing);
+}
+async function checkForUpdates(cwd, options = {}) {
+  const manifest = await loadAgentKitManifest(cwd);
+  if (!manifest) {
+    return {
+      status: "skipped-no-manifest",
+      installedVersion: null,
+      latestVersion: null,
+      registryUrl: null,
+      registryRef: null,
+      applyRecommended: false,
+      message: "No .cursor/agent-kit.json \u2014 run agent-kit install first."
+    };
+  }
+  const registryUrl = manifest.registry?.url ?? null;
+  const registryRef = manifest.registry?.ref ?? null;
+  if (isFactoryOrDevRegistry(registryUrl, registryRef)) {
+    return {
+      status: "skipped-factory",
+      installedVersion: manifest.version,
+      latestVersion: null,
+      registryUrl,
+      registryRef,
+      applyRecommended: false,
+      message: "Factory/dev registry detected \u2014 skipping public update check. Use /update only with explicit consumer intent."
+    };
+  }
+  if (options.respectPrefs) {
+    const config = await loadContextConfig(cwd);
+    const prefs = readUpdateCheckPrefs(config);
+    if (!prefs.enabled) {
+      return {
+        status: "skipped-disabled",
+        installedVersion: manifest.version,
+        latestVersion: null,
+        registryUrl,
+        registryRef,
+        applyRecommended: false,
+        message: "updateCheck.enabled is false (opt-in). Set true in .cursor/context/config.json to nudge."
+      };
+    }
+    if (!intervalElapsed(prefs.lastCheckedAt, prefs.intervalDays)) {
+      return {
+        status: "skipped-interval",
+        installedVersion: manifest.version,
+        latestVersion: null,
+        registryUrl,
+        registryRef,
+        applyRecommended: false,
+        message: `Within updateCheck.intervalDays (${prefs.intervalDays}); last check ${prefs.lastCheckedAt}.`
+      };
+    }
+  }
+  let latest;
+  try {
+    latest = options.latestVersion !== void 0 ? options.latestVersion : await fetchLatestPublicVersion(options.publicRegistryUrl ?? DEFAULT_REGISTRY_URL);
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    return {
+      status: "error",
+      installedVersion: manifest.version,
+      latestVersion: null,
+      registryUrl,
+      registryRef,
+      applyRecommended: false,
+      message: `Failed to fetch public tags: ${msg}`
+    };
+  }
+  if (options.stamp) {
+    try {
+      await stampLastCheckedAt(cwd);
+    } catch {
+    }
+  }
+  const installed = normalizeSemver(manifest.version);
+  if (!installed) {
+    return {
+      status: "error",
+      installedVersion: manifest.version,
+      latestVersion: latest,
+      registryUrl,
+      registryRef,
+      applyRecommended: false,
+      message: `Installed version "${manifest.version}" is not valid semver.`
+    };
+  }
+  if (!latest) {
+    return {
+      status: "error",
+      installedVersion: installed,
+      latestVersion: null,
+      registryUrl,
+      registryRef,
+      applyRecommended: false,
+      message: "No semver tags found on the public registry."
+    };
+  }
+  const cmp = compareSemver(installed, latest);
+  if (cmp === 0) {
+    return {
+      status: "up-to-date",
+      installedVersion: installed,
+      latestVersion: latest,
+      registryUrl,
+      registryRef,
+      applyRecommended: false,
+      message: `Installed v${installed} matches latest public v${latest}.`
+    };
+  }
+  if (cmp < 0) {
+    return {
+      status: "update-available",
+      installedVersion: installed,
+      latestVersion: latest,
+      registryUrl,
+      registryRef,
+      applyRecommended: false,
+      message: `Update available: v${installed} \u2192 v${latest}. Run /update (Ask confirm) to apply; never silent.`
+    };
+  }
+  return {
+    status: "ahead-of-public",
+    installedVersion: installed,
+    latestVersion: latest,
+    registryUrl,
+    registryRef,
+    applyRecommended: false,
+    message: `Installed v${installed} is ahead of latest public v${latest} (dev/local build).`
+  };
+}
+
+// src/commands/update.ts
+var updateCommand = defineCommand13({
   meta: {
     name: "update",
-    description: "Re-apply L0/packs/skills from the registry; never overwrites L3 protected paths."
+    description: "Re-apply L0/packs/skills from the registry; never overwrites L3 protected paths. Use --check for notify-only."
   },
   args: {
     cwd: {
       type: "string",
       default: process.cwd()
     },
+    check: {
+      type: "boolean",
+      description: "Check-only: compare installed version to latest public tag; never apply L0 writes",
+      default: false
+    },
+    json: {
+      type: "boolean",
+      description: "Print machine-readable JSON (with --check)",
+      default: false
+    },
+    "respect-prefs": {
+      type: "boolean",
+      description: "Honor updateCheck.enabled and intervalDays from .cursor/context/config.json (hooks)",
+      default: false
+    },
+    stamp: {
+      type: "boolean",
+      description: "Persist updateCheck.lastCheckedAt after a network check",
+      default: false
+    },
     ...REGISTRY_CLI_ARGS
   },
   async run({ args }) {
+    if (args.check) {
+      const result = await checkForUpdates(args.cwd, {
+        respectPrefs: Boolean(args["respect-prefs"]),
+        stamp: Boolean(args.stamp),
+        publicRegistryUrl: typeof args.url === "string" && args.url ? args.url : void 0
+      });
+      if (args.json) {
+        console.log(JSON.stringify(result, null, 2));
+      } else {
+        const line = `[${result.status}] ${result.message}`;
+        if (result.status === "error") logger.error(line);
+        else if (result.status === "update-available") logger.warn(line);
+        else if (result.status.startsWith("skipped-")) logger.warn(line);
+        else logger.info(line);
+      }
+      if (result.status === "error") process.exitCode = 2;
+      return;
+    }
     const existing = await loadAgentKitManifest(args.cwd);
     if (!existing) {
       logger.warn("No .cursor/agent-kit.json \u2014 run agent-kit install first.");
@@ -4184,7 +4567,7 @@ var updateCommand = defineCommand12({
 });
 
 // src/index.ts
-var main = defineCommand13({
+var main = defineCommand14({
   meta: {
     name: "agent-kit",
     description: "HITL framework for AI-assisted IDEs"
@@ -4201,7 +4584,8 @@ var main = defineCommand13({
     contribute: contributeCommand,
     handoff: handoffCommand,
     "run-plan": runPlanCommand,
-    dashboard: dashboardCommand
+    dashboard: dashboardCommand,
+    "dashboard-broadcast": dashboardBroadcastCommand
   }
 });
 runMain(main);