@appsforgood/next-supabase-kit 0.1.3 → 0.1.4

package/dist/index.js

@@ -141,12 +141,12 @@ function addSkill(cwd, skillName, options = {}) {
 }
 
 // src/install/adapter-validate.ts
-import { existsSync as existsSync11, readFileSync as readFileSync8 } from "fs";
-import { join as join11, normalize } from "path";
+import { existsSync as existsSync12, readFileSync as readFileSync9 } from "fs";
+import { join as join12, normalize } from "path";
 
 // src/config/defaults.ts
 var PACKAGE_NAME = "@appsforgood/next-supabase-kit";
-var PACKAGE_VERSION = "0.1.3";
+var PACKAGE_VERSION = "0.1.4";
 var DEFAULT_CONFIG = {
   stack: "next-supabase",
   projectType: "saas",
@@ -215,6 +215,20 @@ var CURSOR_ADAPTER_FILES = [
     target: ".cursor/rules/cursor-model-selection.mdc"
   }
 ];
+var CURSOR_SCOPED_ADAPTER_FILES = [
+  {
+    source: "assistant-adapters/cursor-planner.mdc",
+    target: ".cursor/rules/cursor-planner.mdc"
+  },
+  {
+    source: "assistant-adapters/cursor-security.mdc",
+    target: ".cursor/rules/cursor-security.mdc"
+  },
+  {
+    source: "assistant-adapters/cursor-frontend.mdc",
+    target: ".cursor/rules/cursor-frontend.mdc"
+  }
+];
 var COPILOT_INSTRUCTION_FILES = [
   {
     source: "assistant-adapters/github-copilot-instructions.md",
@@ -345,8 +359,8 @@ function unique(values) {
 }
 
 // src/install/audit.ts
-import { existsSync as existsSync10, readFileSync as readFileSync7, statSync } from "fs";
-import { join as join10 } from "path";
+import { existsSync as existsSync11, readFileSync as readFileSync8, statSync } from "fs";
+import { join as join11 } from "path";
 
 // src/config/contracts.ts
 import { z } from "zod";
@@ -1100,11 +1114,15 @@ function onboardingStateExists(cwd) {
 }
 
 // src/install/install.ts
+import { existsSync as existsSync10, readFileSync as readFileSync7 } from "fs";
+import { join as join10 } from "path";
+
+// src/install/ide-activate.ts
 import { existsSync as existsSync9, readFileSync as readFileSync6 } from "fs";
 import { join as join9 } from "path";
 
-// src/install/ide-activate.ts
-import { existsSync as existsSync8, readFileSync as readFileSync5 } from "fs";
+// src/install/roster-adapters.ts
+import { existsSync as existsSync8, readFileSync as readFileSync5, readdirSync as readdirSync2 } from "fs";
 import { join as join8 } from "path";
 
 // src/studio/wizard/roster.ts
@@ -1188,8 +1206,224 @@ function agentBriefFieldName(agentId) {
   return `agentBrief_${agentId}`;
 }
 
-// src/install/ide-activate.ts
+// src/install/assistant-adapters-table.ts
+function extractAssistantAdapterRow(adaptersDoc, toolLabel) {
+  for (const line of adaptersDoc.split("\n")) {
+    const trimmed = line.trim();
+    if (!trimmed.startsWith("|")) continue;
+    const cells = trimmed.split("|").map((cell) => cell.trim()).filter((cell) => cell.length > 0);
+    if (cells[0] === toolLabel) return trimmed;
+  }
+  return null;
+}
+function assistantAdapterRowIsActive(adaptersDoc, toolLabel) {
+  const row = extractAssistantAdapterRow(adaptersDoc, toolLabel);
+  if (!row) return false;
+  const cells = row.split("|").map((cell) => cell.trim()).filter((cell) => cell.length > 0);
+  const instructionStatus = cells[2] ?? "";
+  return /^Active/i.test(instructionStatus) && !/^TBD/i.test(instructionStatus);
+}
+
+// src/install/roster-adapters.ts
 var CANONICAL_READ_LIST = "`AGENTS.md`, `AGENT_ROSTER.md`, `.agent-kit/agent-roster.json`, `MODEL_ROUTING.md`, `.agent-kit/model-routing.json`, `.agent-kit/project-context.json`, `.agent-kit/project-context.md`, `.agent-kit/agent-briefs.md` when present, `.agent-kit/corrections/project-rules.json`, `.agent-kit/corrections/agent-rules.json`, `COUNCIL.md`, `.agent-kit/council-sessions/`, and `QUALITY_GATES.md`";
+function quoteYamlScalar(value) {
+  return JSON.stringify(value);
+}
+function buildAgentHint(agentId, name) {
+  if (agentId === "planner") return "Start with the Planner workflow.";
+  if (agentId === "lead-architect") return "Convene council for core changes before implementation.";
+  if (agentId === "frontend-design-lead") {
+    return "Require brand/content intake, creative-direction rationale, and visual QA evidence for UI changes.";
+  }
+  if (agentId === "security-reviewer") {
+    return "Review auth, RLS, data mutation, dependency, external-call, secret, and release-risk changes.";
+  }
+  return `Use for ${name.toLowerCase()} work defined in the roster.`;
+}
+function buildProactiveSuffix(agentId) {
+  const suffixes = {
+    planner: "Use proactively for planning, scope breakdown, ambiguous requests, and workflow routing.",
+    "lead-architect": "Use proactively for core changes, architecture, and cross-layer decisions.",
+    "security-reviewer": "Use proactively for auth, RLS, API, Server Action, data mutation, dependency, secret, and release-risk changes.",
+    "frontend-design-lead": "Use proactively for UI, design system, accessibility, and visual QA work.",
+    "qa-engineer": "Use proactively after behavior changes to add or verify tests and acceptance evidence.",
+    "supabase-postgres-engineer": "Use proactively for schema, migrations, RLS, auth, and SQL changes.",
+    "nextjs-engineer": "Use proactively for App Router, Server Components, route handlers, and UI state work.",
+    "marketing-copy-lead": "Use proactively for public-facing copy, positioning, and conversion surfaces.",
+    "docs-maintainer": "Use proactively after significant changes to update living documentation.",
+    "deployment-observability-engineer": "Use proactively for release, env var, migration order, monitoring, and rollback work."
+  };
+  return suffixes[agentId] ?? "";
+}
+function buildSubagentDescription(agent, proactive) {
+  const base = agent.roleSummary.length > 140 ? `${agent.roleSummary.slice(0, 137)}...` : agent.roleSummary;
+  if (!proactive) return base;
+  const suffix = buildProactiveSuffix(agent.id);
+  return suffix ? `${base} ${suffix}` : base;
+}
+function buildSubagentMarkdown(agent, options = {}) {
+  const description = buildSubagentDescription(agent, Boolean(options.proactive));
+  const agentFile = agent.file ?? `.agent-kit/agents/${agent.id}.md`;
+  const hint = buildAgentHint(agent.id, agent.name);
+  return `---
+name: ${quoteYamlScalar(agent.id)}
+description: ${quoteYamlScalar(description)}
+---
+
+Read ${CANONICAL_READ_LIST} before making routing or implementation decisions.
+
+Also read \`${agentFile}\` for this role's detailed contract.
+
+${hint}
+
+For council work, delegate to this subagent instead of role-playing the council in the main thread.
+
+Record meaningful decisions, risks, handoffs, human corrections, artifacts, evidence, and verification through \`agent-kit session checkpoint\` or individual \`agent-kit session ...\` commands when available.
+`;
+}
+function writeGeneratedAgentFile(cwd, relativePath, content, force, result) {
+  const targetPath = join8(cwd, relativePath);
+  if (!force && existsSync8(targetPath)) {
+    const existing = readFileSync5(targetPath, "utf8");
+    if (existing === content) {
+      result.unchanged.push(relativePath);
+      return;
+    }
+    const conflictPath = join8(cwd, ".agent-kit", "conflicts", relativePath.replace(/\//g, "__"));
+    ensureDir(join8(cwd, ".agent-kit", "conflicts"));
+    writeText(conflictPath, existing);
+    result.conflicts.push(`${relativePath} -> ${conflictPath}`);
+    return;
+  }
+  ensureDir(join8(cwd, relativePath.split("/").slice(0, -1).join("/")));
+  writeText(targetPath, content);
+  result.copied.push(relativePath);
+}
+function generateMarkdownSubagents(cwd, agentsDir, options) {
+  ensureDir(join8(cwd, agentsDir));
+  for (const agent of loadProjectRosterAgents(cwd)) {
+    const relativePath = `${agentsDir}/${agent.id}.md`;
+    writeGeneratedAgentFile(cwd, relativePath, buildSubagentMarkdown(agent, options), options.force, options.result);
+  }
+}
+var CURSOR_AGENTS_README = `# Cursor council subagents
+
+Project subagents generated from \`.agent-kit/agent-roster.json\`. Use them for isolated specialist context instead of role-playing the whole council in one chat.
+
+## Delegation
+
+| Risk / work type | Subagent |
+| --- | --- |
+| Planning / scope | \`@planner\` |
+| Core architecture | \`@lead-architect\` |
+| Auth / RLS / secrets | \`@security-reviewer\` or Task \`security-review\` |
+| Frontend UI | \`@frontend-design-lead\` |
+| QA / tests | \`@qa-engineer\` |
+
+Record handoffs with \`agent-kit session checkpoint --file <json>\` when the CLI is available.
+
+Regenerate with \`agent-kit init --activate cursor\` after roster changes.
+`;
+function generateCursorSubagents(cwd, force, result) {
+  generateMarkdownSubagents(cwd, ".cursor/agents", { proactive: true, force, result });
+  writeGeneratedAgentFile(cwd, ".cursor/agents/README.md", CURSOR_AGENTS_README, force, result);
+}
+function loadAgentReasoningEffortMap(cwd) {
+  const path = join8(cwd, ".agent-kit/model-routing.json");
+  const map = /* @__PURE__ */ new Map();
+  if (!existsSync8(path)) return map;
+  try {
+    const parsed = JSON.parse(readFileSync5(path, "utf8"));
+    const profileEffort = /* @__PURE__ */ new Map();
+    for (const profile of parsed.profiles ?? []) {
+      if (profile.id && profile.reasoningEffort) {
+        const effort = profile.reasoningEffort;
+        if (effort === "low" || effort === "medium" || effort === "high") {
+          profileEffort.set(profile.id, effort);
+        }
+      }
+    }
+    for (const binding of parsed.agentRoutes ?? []) {
+      if (!binding.agentId) continue;
+      const direct = binding.defaultEffort;
+      if (direct === "low" || direct === "medium" || direct === "high") {
+        map.set(binding.agentId, direct);
+        continue;
+      }
+      if (binding.profileId && profileEffort.has(binding.profileId)) {
+        map.set(binding.agentId, profileEffort.get(binding.profileId));
+      }
+    }
+  } catch {
+    return map;
+  }
+  return map;
+}
+function escapeTomlString(value) {
+  return value.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
+}
+function buildCodexAgentToml(agent, effort) {
+  const description = buildSubagentDescription(agent, true);
+  const agentFile = agent.file ?? `.agent-kit/agents/${agent.id}.md`;
+  const hint = buildAgentHint(agent.id, agent.name);
+  const instructions = [
+    `Read AGENTS.md, AGENT_ROSTER.md, .agent-kit/agent-roster.json, MODEL_ROUTING.md,`,
+    `.agent-kit/model-routing.json, project context, corrections, COUNCIL.md, QUALITY_GATES.md,`,
+    `and ${agentFile} before reviewing or implementing.`,
+    "",
+    hint,
+    "",
+    "Record meaningful decisions, risks, handoffs, and verification through agent-kit session checkpoint when available."
+  ].join("\n");
+  return `name = "${agent.id}"
+description = "${escapeTomlString(description)}"
+# model = "gpt-5.5"  # verify in your Codex environment; see MODEL_ROUTING.md
+model_reasoning_effort = "${effort}"
+
+developer_instructions = """
+${instructions}
+"""
+`;
+}
+function generateCodexCustomAgents(cwd, force, result) {
+  ensureDir(join8(cwd, ".codex/agents"));
+  const effortMap = loadAgentReasoningEffortMap(cwd);
+  for (const agent of loadProjectRosterAgents(cwd)) {
+    const effort = effortMap.get(agent.id) ?? "medium";
+    const relativePath = `.codex/agents/${agent.id}.toml`;
+    writeGeneratedAgentFile(cwd, relativePath, buildCodexAgentToml(agent, effort), force, result);
+  }
+}
+function skillDescriptionFromMarkdown(text, skillId) {
+  const useWhen = text.match(/## Use When\s*\n+\s*([^\n#]+)/);
+  if (useWhen?.[1]) return useWhen[1].trim().slice(0, 200);
+  const firstHeading = text.match(/^#\s+(.+)/m);
+  if (firstHeading?.[1]) return `${firstHeading[1].trim()} \u2014 Agent Kit council skill.`;
+  return `Agent Kit skill for ${skillId.replace(/-/g, " ")}.`;
+}
+function kitSkillToCursorSkill(skillId, kitMarkdown) {
+  const description = skillDescriptionFromMarkdown(kitMarkdown, skillId);
+  const body = kitMarkdown.replace(/^#\s+.+\n+/, "").trimStart();
+  return `---
+name: ${quoteYamlScalar(skillId)}
+description: ${quoteYamlScalar(description)}
+---
+
+${body.trim()}
+`;
+}
+function generateCursorSkillsFromKit(cwd, force, result) {
+  const skillsRoot = join8(cwd, ".agent-kit/skills");
+  if (!existsSync8(skillsRoot)) return;
+  for (const file of readdirSync2(skillsRoot).filter((name) => name.endsWith(".md"))) {
+    const skillId = file.replace(/\.md$/, "");
+    const kitMarkdown = readFileSync5(join8(skillsRoot, file), "utf8");
+    const relativePath = `.cursor/skills/${skillId}/SKILL.md`;
+    writeGeneratedAgentFile(cwd, relativePath, kitSkillToCursorSkill(skillId, kitMarkdown), force, result);
+  }
+}
+
+// src/install/ide-activate.ts
 function normalizeTargets(targets) {
   const allowed = /* @__PURE__ */ new Set(["cursor", "claude", "codex", "copilot", "antigravity"]);
   const normalized = /* @__PURE__ */ new Set();
@@ -1204,9 +1438,9 @@ function normalizeTargets(targets) {
   return [...normalized];
 }
 function copyAdapterFile(cwd, packageRoot, source, target, force, result) {
-  const copyResult = copyTextWithConflict(join8(packageRoot, source), cwd, target, {
+  const copyResult = copyTextWithConflict(join9(packageRoot, source), cwd, target, {
     force,
-    conflictRoot: join8(cwd, ".agent-kit", "conflicts")
+    conflictRoot: join9(cwd, ".agent-kit", "conflicts")
   });
   if (copyResult.action === "created") result.copied.push(copyResult.target);
   if (copyResult.action === "unchanged") result.unchanged.push(copyResult.target);
@@ -1215,53 +1449,18 @@ function copyAdapterFile(cwd, packageRoot, source, target, force, result) {
     result.conflicts.push(`${copyResult.target} -> ${copyResult.conflictPath}`);
   }
 }
-function buildClaudeSubagentMarkdown(agentId, name, description) {
-  const defaultForHint = agentId === "planner" ? "Start with the Planner workflow." : agentId === "lead-architect" ? "Convene council for core changes before implementation." : agentId === "frontend-design-lead" ? "Require brand/content intake, creative-direction rationale, and visual QA evidence for UI changes." : agentId === "security-reviewer" ? "Review auth, RLS, data mutation, dependency, external-call, secret, and release-risk changes." : `Use for ${name.toLowerCase()} work defined in the roster.`;
-  return `---
-name: ${agentId}
-description: ${description}
----
-
-Read ${CANONICAL_READ_LIST} before making routing or implementation decisions.
-
-${defaultForHint}
-
-Record meaningful decisions, risks, handoffs, human corrections, artifacts, evidence, and verification through \`agent-kit session checkpoint\` or individual \`agent-kit session ...\` commands when available.
-`;
-}
 function generateClaudeSubagents(cwd, packageRoot, force, result) {
-  ensureDir(join8(cwd, ".claude", "agents"));
-  const agents = loadProjectRosterAgents(cwd);
-  for (const agent of agents) {
-    const description = agent.roleSummary.length > 180 ? `${agent.roleSummary.slice(0, 177)}...` : agent.roleSummary;
-    const target = `.claude/agents/${agent.id}.md`;
-    const content = buildClaudeSubagentMarkdown(agent.id, agent.name, description);
-    const targetPath = join8(cwd, target);
-    if (!force && existsSync8(targetPath)) {
-      const existing = readFileSync5(targetPath, "utf8");
-      if (existing === content) {
-        result.unchanged.push(target);
-        continue;
-      }
-      const conflictPath = join8(cwd, ".agent-kit", "conflicts", target.replace(/\//g, "__"));
-      ensureDir(join8(cwd, ".agent-kit", "conflicts"));
-      writeText(conflictPath, existing);
-      result.conflicts.push(`${target} -> ${conflictPath}`);
-      continue;
-    }
-    writeText(targetPath, content);
-    result.copied.push(target);
-  }
+  generateMarkdownSubagents(cwd, ".claude/agents", { proactive: false, force, result });
   copyAdapterFile(cwd, packageRoot, CLAUDE_TEMPLATE, "CLAUDE.md", force, result);
 }
 function copyDirectoryAsConflicts(cwd, packageRoot, sourceDir, targetDir, force, result) {
-  for (const file of listFilesRecursive(join8(packageRoot, sourceDir))) {
-    copyAdapterFile(cwd, packageRoot, join8(sourceDir, file), join8(targetDir, file).replace(/\\/g, "/"), force, result);
+  for (const file of listFilesRecursive(join9(packageRoot, sourceDir))) {
+    copyAdapterFile(cwd, packageRoot, join9(sourceDir, file), join9(targetDir, file).replace(/\\/g, "/"), force, result);
   }
 }
 function installAntigravityAdapter(cwd, packageRoot, force, result) {
-  ensureDir(join8(cwd, ".antigravity", "agent-kit", "commands"));
-  ensureDir(join8(cwd, ".antigravity", "runtime-skills"));
+  ensureDir(join9(cwd, ".antigravity", "agent-kit", "commands"));
+  ensureDir(join9(cwd, ".antigravity", "runtime-skills"));
   for (const file of ANTIGRAVITY_PLUGIN_FILES) {
     copyAdapterFile(cwd, packageRoot, file.source, file.target, force, result);
   }
@@ -1283,38 +1482,38 @@ function installAntigravityAdapter(cwd, packageRoot, force, result) {
   );
 }
 function updateAssistantAdaptersTable(cwd, activated) {
-  const path = join8(cwd, "ASSISTANT_ADAPTERS.md");
-  if (!existsSync8(path)) return;
-  let content = readFileSync5(path, "utf8");
+  const path = join9(cwd, "ASSISTANT_ADAPTERS.md");
+  if (!existsSync9(path)) return;
+  let content = readFileSync6(path, "utf8");
   const today = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
   if (activated.has("cursor") && content.includes("| Cursor |")) {
     content = content.replace(
       /\| Cursor \|[^|]*\|[^|]*\|[^|]*\|[^|]*\|[^|]*\|[^|]*\|/,
-      "| Cursor | `.cursor/rules/cursor-agent-kit.mdc` and `.cursor/rules/cursor-model-selection.mdc` | Active on init | Advisory | Advisory | `agent-kit init` copies rules; verify in Cursor Settings > Rules. | Installed via `agent-kit init` or `agent-kit init --activate cursor`. |"
+      `| Cursor | \`.cursor/rules/*.mdc\`, \`.cursor/agents/*.md\`, \`.cursor/skills/*/SKILL.md\` | Active | Partial | Partial | \`agent-kit init --activate cursor\` on ${today}; verify subagents in Cursor. | Delegate to council subagents instead of role-playing; run \`agent-kit adapter validate cursor\`. |`
     );
   }
   if (activated.has("copilot") && content.includes("| GitHub Copilot")) {
     content = content.replace(
       /\| GitHub Copilot[^|]*\|[^|]*\|[^|]*\|[^|]*\|[^|]*\|[^|]*\|[^|]*\|/,
-      "| GitHub Copilot / VS Code | `.github/copilot-instructions.md` and `.github/instructions/next-supabase.instructions.md` | Active | Advisory | Advisory | `agent-kit init --activate copilot` on ${today}. | Copilot loads repository and path-specific instructions automatically in VS Code. |"
+      `| GitHub Copilot / VS Code | \`.github/copilot-instructions.md\` and \`.github/instructions/next-supabase.instructions.md\` | Active | Advisory | Advisory | \`agent-kit init --activate copilot\` on ${today}. | Copilot loads repository and path-specific instructions automatically in VS Code. |`
     );
   }
   if (activated.has("claude") && content.includes("| Claude Code |")) {
     content = content.replace(
       /\| Claude Code \|[^|]*\|[^|]*\|[^|]*\|[^|]*\|[^|]*\|[^|]*\|/,
-      "| Claude Code | `.claude/agents/*.md` and `CLAUDE.md` | Active | Partial | Partial | `agent-kit init --activate claude` generated subagents on ${today}. | Subagents generated from `.agent-kit/agent-roster.json`; verify in Claude Code project settings. |"
+      `| Claude Code | \`.claude/agents/*.md\` and \`CLAUDE.md\` | Active | Partial | Partial | \`agent-kit init --activate claude\` generated subagents on ${today}. | Subagents generated from \`.agent-kit/agent-roster.json\`; verify in Claude Code project settings. |`
     );
   }
   if (activated.has("codex") && content.includes("| Codex / AGENTS.md-compatible tools |")) {
     content = content.replace(
       /\| Codex \/ AGENTS\.md-compatible tools \|[^|]*\|[^|]*\|[^|]*\|[^|]*\|[^|]*\|[^|]*\|/,
-      "| Codex / AGENTS.md-compatible tools | `AGENTS.md`, `.codex/config.toml` | Active | Partial | Partial | Root `AGENTS.md` on init; optional `.codex/config.toml` via `agent-kit init --activate codex`. | Confirm Codex loads root `AGENTS.md` and optional model routing comments. |"
+      `| Codex / AGENTS.md-compatible tools | \`AGENTS.md\`, \`.codex/config.toml\`, \`.codex/agents/*.toml\` | Active | Partial | Partial | \`agent-kit init --activate codex\` on ${today}. | Spawn council custom agents from \`.codex/agents/\`; run \`agent-kit adapter validate codex\`. |`
     );
   }
   if (activated.has("antigravity") && content.includes("| Antigravity |")) {
     content = content.replace(
       /\| Antigravity \|[^|]*\|[^|]*\|[^|]*\|[^|]*\|[^|]*\|[^|]*\|/,
-      "| Antigravity | `.antigravity/agent-kit/plugin.json`, `.antigravity/agent-kit/commands/*.toml`, `.antigravity/runtime-skills/*/SKILL.md` | Active | Advisory | Advisory | `agent-kit init --activate antigravity` on ${today}; run `agent-kit adapter validate antigravity`. | Native commands wrap the Agent Kit council/session contract; runtime validation is structural unless `agy` is installed. |"
+      `| Antigravity | \`.antigravity/agent-kit/plugin.json\`, \`.antigravity/agent-kit/commands/*.toml\`, \`.antigravity/runtime-skills/*/SKILL.md\` | Active | Advisory | Advisory | \`agent-kit init --activate antigravity\` on ${today}; run \`agent-kit adapter validate antigravity\`. | Native commands wrap the Agent Kit council/session contract; runtime validation is structural unless \`agy\` is installed. |`
     );
   }
   writeText(path, content);
@@ -1341,9 +1540,14 @@ function activateIdeTargets(options) {
     for (const adapter2 of CURSOR_ADAPTER_FILES) {
       copyAdapterFile(cwd, packageRoot, adapter2.source, adapter2.target, force, result);
     }
+    for (const adapter2 of CURSOR_SCOPED_ADAPTER_FILES) {
+      copyAdapterFile(cwd, packageRoot, adapter2.source, adapter2.target, force, result);
+    }
+    generateCursorSubagents(cwd, force, result);
+    generateCursorSkillsFromKit(cwd, force, result);
   }
   if (activated.has("copilot")) {
-    ensureDir(join8(cwd, ".github", "instructions"));
+    ensureDir(join9(cwd, ".github", "instructions"));
     for (const file of COPILOT_INSTRUCTION_FILES) {
       copyAdapterFile(cwd, packageRoot, file.source, file.target, force, result);
     }
@@ -1352,8 +1556,9 @@ function activateIdeTargets(options) {
     generateClaudeSubagents(cwd, packageRoot, force, result);
   }
   if (activated.has("codex")) {
-    ensureDir(join8(cwd, ".codex"));
+    ensureDir(join9(cwd, ".codex"));
     copyAdapterFile(cwd, packageRoot, CODEX_CONFIG_SOURCE, ".codex/config.toml", force, result);
+    generateCodexCustomAgents(cwd, force, result);
   }
   if (activated.has("antigravity")) {
     installAntigravityAdapter(cwd, packageRoot, force, result);
@@ -1361,18 +1566,25 @@ function activateIdeTargets(options) {
   updateAssistantAdaptersTable(cwd, activated);
   return result;
 }
+function ideSurfaceToActivateTarget(ideSurface) {
+  const value = ideSurface.trim().toLowerCase();
+  if (value === "cursor" || value === "claude" || value === "codex" || value === "copilot") {
+    return value;
+  }
+  return null;
+}
 
 // src/install/install.ts
 function initProject(options) {
   const cwd = options.cwd;
   const stack = options.stack ?? DEFAULT_CONFIG.stack;
   const packageRoot = findPackageRoot();
-  const templateRoot = join9(packageRoot, "templates", stack);
-  if (!existsSync9(templateRoot)) {
+  const templateRoot = join10(packageRoot, "templates", stack);
+  if (!existsSync10(templateRoot)) {
     throw new Error(`Unsupported stack profile: ${stack}`);
   }
-  ensureDir(join9(cwd, ".agent-kit"));
-  ensureDir(join9(cwd, ".agent-kit", "conflicts"));
+  ensureDir(join10(cwd, ".agent-kit"));
+  ensureDir(join10(cwd, ".agent-kit", "conflicts"));
   const result = {
     copied: [],
     unchanged: [],
@@ -1382,11 +1594,11 @@ function initProject(options) {
   };
   const templateHashes = {};
   for (const doc of ROOT_DOCS) {
-    const templatePath = join9(templateRoot, doc);
-    templateHashes[doc] = sha256(readFileSync6(templatePath, "utf8"));
+    const templatePath = join10(templateRoot, doc);
+    templateHashes[doc] = sha256(readFileSync7(templatePath, "utf8"));
     const copyResult = copyTextWithConflict(templatePath, cwd, doc, {
       force: Boolean(options.force),
-      conflictRoot: join9(cwd, ".agent-kit", "conflicts")
+      conflictRoot: join10(cwd, ".agent-kit", "conflicts")
     });
     if (copyResult.action === "created") result.copied.push(copyResult.target);
     if (copyResult.action === "unchanged") result.unchanged.push(copyResult.target);
@@ -1396,12 +1608,12 @@ function initProject(options) {
     }
   }
   for (const folder of LIBRARY_FOLDERS) {
-    copyDirectory(join9(packageRoot, folder), join9(cwd, ".agent-kit", folder));
+    copyDirectory(join10(packageRoot, folder), join10(cwd, ".agent-kit", folder));
   }
   for (const adapter2 of CURSOR_ADAPTER_FILES) {
-    const adapterCopy = copyTextWithConflict(join9(packageRoot, adapter2.source), cwd, adapter2.target, {
+    const adapterCopy = copyTextWithConflict(join10(packageRoot, adapter2.source), cwd, adapter2.target, {
       force: Boolean(options.force),
-      conflictRoot: join9(cwd, ".agent-kit", "conflicts")
+      conflictRoot: join10(cwd, ".agent-kit", "conflicts")
     });
     if (adapterCopy.action === "created") result.copied.push(adapterCopy.target);
     if (adapterCopy.action === "unchanged") result.unchanged.push(adapterCopy.target);
@@ -1410,17 +1622,17 @@ function initProject(options) {
       result.conflicts.push(`${adapterCopy.target} -> ${adapterCopy.conflictPath}`);
     }
   }
-  const rosterCopy = copyTextWithConflict(join9(packageRoot, DEFAULT_AGENT_ROSTER_SOURCE), cwd, DEFAULT_AGENT_ROSTER_TARGET, {
+  const rosterCopy = copyTextWithConflict(join10(packageRoot, DEFAULT_AGENT_ROSTER_SOURCE), cwd, DEFAULT_AGENT_ROSTER_TARGET, {
     force: Boolean(options.force),
-    conflictRoot: join9(cwd, ".agent-kit", "conflicts")
+    conflictRoot: join10(cwd, ".agent-kit", "conflicts")
   });
   if (rosterCopy.action === "created") result.copied.push(rosterCopy.target);
   if (rosterCopy.action === "unchanged") result.unchanged.push(rosterCopy.target);
   if (rosterCopy.action === "overwritten") result.overwritten.push(rosterCopy.target);
   if (rosterCopy.action === "conflict") result.conflicts.push(`${rosterCopy.target} -> ${rosterCopy.conflictPath}`);
-  const modelRoutingCopy = copyTextWithConflict(join9(packageRoot, DEFAULT_MODEL_ROUTING_SOURCE), cwd, DEFAULT_MODEL_ROUTING_TARGET, {
+  const modelRoutingCopy = copyTextWithConflict(join10(packageRoot, DEFAULT_MODEL_ROUTING_SOURCE), cwd, DEFAULT_MODEL_ROUTING_TARGET, {
     force: Boolean(options.force),
-    conflictRoot: join9(cwd, ".agent-kit", "conflicts")
+    conflictRoot: join10(cwd, ".agent-kit", "conflicts")
   });
   if (modelRoutingCopy.action === "created") result.copied.push(modelRoutingCopy.target);
   if (modelRoutingCopy.action === "unchanged") result.unchanged.push(modelRoutingCopy.target);
@@ -1437,17 +1649,17 @@ function initProject(options) {
     modelRouting: DEFAULT_MODEL_ROUTING_TARGET,
     templateHashes
   };
-  writeText(join9(cwd, ".agent-kit", "manifest.json"), `${JSON.stringify(manifest, null, 2)}
+  writeText(join10(cwd, ".agent-kit", "manifest.json"), `${JSON.stringify(manifest, null, 2)}
 `);
-  writeText(join9(cwd, ".agent-kit", "config.json"), `${JSON.stringify(DEFAULT_CONFIG, null, 2)}
+  writeText(join10(cwd, ".agent-kit", "config.json"), `${JSON.stringify(DEFAULT_CONFIG, null, 2)}
 `);
-  const overridesPath = join9(cwd, ".agent-kit", "overrides.json");
-  if (!existsSync9(overridesPath)) writeText(overridesPath, `${JSON.stringify({ templates: {} }, null, 2)}
+  const overridesPath = join10(cwd, ".agent-kit", "overrides.json");
+  if (!existsSync10(overridesPath)) writeText(overridesPath, `${JSON.stringify({ templates: {} }, null, 2)}
 `);
   for (const template of CI_TEMPLATE_FILES) {
-    const ciCopy = copyTextWithConflict(join9(packageRoot, template.source), cwd, template.target, {
+    const ciCopy = copyTextWithConflict(join10(packageRoot, template.source), cwd, template.target, {
       force: Boolean(options.force),
-      conflictRoot: join9(cwd, ".agent-kit", "conflicts")
+      conflictRoot: join10(cwd, ".agent-kit", "conflicts")
     });
     if (ciCopy.action === "created") result.copied.push(ciCopy.target);
     if (ciCopy.action === "unchanged") result.unchanged.push(ciCopy.target);
@@ -1471,9 +1683,9 @@ function initProject(options) {
   return result;
 }
 function readManifest(cwd) {
-  const manifestPath = join9(cwd, ".agent-kit", "manifest.json");
-  if (!existsSync9(manifestPath)) return null;
-  return JSON.parse(readFileSync6(manifestPath, "utf8"));
+  const manifestPath = join10(cwd, ".agent-kit", "manifest.json");
+  if (!existsSync10(manifestPath)) return null;
+  return JSON.parse(readFileSync7(manifestPath, "utf8"));
 }
 
 // src/install/audit.ts
@@ -1542,24 +1754,24 @@ function includesAll(text, values) {
   return values.every((value) => lower.includes(value.toLowerCase()));
 }
 function readDoc(cwd, file) {
-  const path = join10(cwd, file);
-  return existsSync10(path) ? readFileSync7(path, "utf8") : "";
+  const path = join11(cwd, file);
+  return existsSync11(path) ? readFileSync8(path, "utf8") : "";
 }
 function isPackageRepository(cwd) {
-  const packagePath = join10(cwd, "package.json");
-  if (!existsSync10(packagePath)) return false;
+  const packagePath = join11(cwd, "package.json");
+  if (!existsSync11(packagePath)) return false;
   try {
-    const packageJson = JSON.parse(readFileSync7(packagePath, "utf8"));
-    return packageJson.name === "@appsforgood/next-supabase-kit" && existsSync10(join10(cwd, "src", "cli", "index.ts")) && existsSync10(join10(cwd, "templates", "next-supabase")) && existsSync10(join10(cwd, "rosters", "next-supabase-default-council.json"));
+    const packageJson = JSON.parse(readFileSync8(packagePath, "utf8"));
+    return packageJson.name === "@appsforgood/next-supabase-kit" && existsSync11(join11(cwd, "src", "cli", "index.ts")) && existsSync11(join11(cwd, "templates", "next-supabase")) && existsSync11(join11(cwd, "rosters", "next-supabase-default-council.json"));
   } catch {
     return false;
   }
 }
 function readOverrides(cwd) {
-  const path = join10(cwd, ".agent-kit", "overrides.json");
-  if (!existsSync10(path)) return {};
+  const path = join11(cwd, ".agent-kit", "overrides.json");
+  if (!existsSync11(path)) return {};
   try {
-    const parsed = JSON.parse(readFileSync7(path, "utf8"));
+    const parsed = JSON.parse(readFileSync8(path, "utf8"));
     const templates = parsed.templates ?? {};
     return Object.fromEntries(
       Object.entries(templates).map(([file, override]) => [
@@ -1572,8 +1784,8 @@ function readOverrides(cwd) {
   }
 }
 function readTemplate(stack, file) {
-  const path = join10(findPackageRoot(), "templates", stack, file);
-  return existsSync10(path) ? readFileSync7(path, "utf8") : null;
+  const path = join11(findPackageRoot(), "templates", stack, file);
+  return existsSync11(path) ? readFileSync8(path, "utf8") : null;
 }
 function asStringArray(value) {
   if (!Array.isArray(value)) return [];
@@ -1583,8 +1795,8 @@ function isRecord(value) {
   return typeof value === "object" && value !== null;
 }
 function addAgentRosterFindings(cwd, findings, rosterRelativePath = DEFAULT_AGENT_ROSTER_TARGET) {
-  const rosterPath = join10(cwd, rosterRelativePath);
-  if (!existsSync10(rosterPath)) {
+  const rosterPath = join11(cwd, rosterRelativePath);
+  if (!existsSync11(rosterPath)) {
     findings.push({
       level: "fail",
       area: "agents",
@@ -1595,7 +1807,7 @@ function addAgentRosterFindings(cwd, findings, rosterRelativePath = DEFAULT_AGEN
   }
   let roster;
   try {
-    const parsed = JSON.parse(readFileSync7(rosterPath, "utf8"));
+    const parsed = JSON.parse(readFileSync8(rosterPath, "utf8"));
     if (!isRecord(parsed)) throw new Error("Roster must be a JSON object.");
     const contractResult = AgentRosterContract.safeParse(parsed);
     if (!contractResult.success) {
@@ -1782,15 +1994,15 @@ function addAgentRosterFindings(cwd, findings, rosterRelativePath = DEFAULT_AGEN
   }
 }
 function addCouncilSessionRecordFindings(cwd, findings) {
-  const sessionsRoot = join10(cwd, COUNCIL_SESSION_DIR);
-  if (!existsSync10(sessionsRoot)) return;
+  const sessionsRoot = join11(cwd, COUNCIL_SESSION_DIR);
+  if (!existsSync11(sessionsRoot)) return;
   const sessionFiles = listFilesRecursive(sessionsRoot).filter((file) => file.endsWith(".json") && !/[\\/]/.test(file));
   if (sessionFiles.length === 0) return;
   let invalidCount = 0;
   for (const sessionFile of sessionFiles) {
     const displayPath = `${COUNCIL_SESSION_DIR}/${sessionFile}`;
     try {
-      const parsed = JSON.parse(readFileSync7(join10(sessionsRoot, sessionFile), "utf8"));
+      const parsed = JSON.parse(readFileSync8(join11(sessionsRoot, sessionFile), "utf8"));
       const contractResult = CouncilSessionContract.safeParse(parsed);
       if (!contractResult.success) {
         invalidCount += 1;
@@ -1821,8 +2033,8 @@ function addCouncilSessionRecordFindings(cwd, findings) {
 }
 function addSchemaFindings(cwd, findings, schemaRootRelativePath = ".agent-kit/schemas") {
   for (const schemaFile of REQUIRED_SCHEMA_FILES) {
-    const schemaPath = join10(cwd, schemaRootRelativePath, schemaFile);
-    if (!existsSync10(schemaPath)) {
+    const schemaPath = join11(cwd, schemaRootRelativePath, schemaFile);
+    if (!existsSync11(schemaPath)) {
       findings.push({
         level: "warn",
         area: "agents",
@@ -1832,7 +2044,7 @@ function addSchemaFindings(cwd, findings, schemaRootRelativePath = ".agent-kit/s
       continue;
     }
     try {
-      const parsed = JSON.parse(readFileSync7(schemaPath, "utf8"));
+      const parsed = JSON.parse(readFileSync8(schemaPath, "utf8"));
       if (!isRecord(parsed) || typeof parsed.$schema !== "string" || !isRecord(parsed.properties)) {
         throw new Error("Schema file is missing JSON Schema metadata.");
       }
@@ -1852,8 +2064,8 @@ function addSchemaFindings(cwd, findings, schemaRootRelativePath = ".agent-kit/s
   }
 }
 function addAgentStudioFindings(cwd, findings) {
-  const contextPath = join10(cwd, CONTEXT_JSON);
-  if (!existsSync10(contextPath)) {
+  const contextPath = join11(cwd, CONTEXT_JSON);
+  if (!existsSync11(contextPath)) {
     findings.push({
       level: "warn",
       area: "studio",
@@ -1862,7 +2074,7 @@ function addAgentStudioFindings(cwd, findings) {
     });
   } else {
     try {
-      const parsed = JSON.parse(readFileSync7(contextPath, "utf8"));
+      const parsed = JSON.parse(readFileSync8(contextPath, "utf8"));
       const result = ProjectContextContract.safeParse(parsed);
       if (!result.success) {
         findings.push({
@@ -1926,8 +2138,8 @@ function addAgentStudioFindings(cwd, findings) {
       });
     }
   }
-  const contextMdPath = join10(cwd, CONTEXT_MD);
-  if (existsSync10(contextPath) && !existsSync10(contextMdPath)) {
+  const contextMdPath = join11(cwd, CONTEXT_MD);
+  if (existsSync11(contextPath) && !existsSync11(contextMdPath)) {
     findings.push({
       level: "warn",
       area: "studio",
@@ -1936,10 +2148,10 @@ function addAgentStudioFindings(cwd, findings) {
     });
   }
   for (const relativePath of [PROJECT_RULES_JSON, AGENT_RULES_JSON]) {
-    const path = join10(cwd, relativePath);
-    if (!existsSync10(path)) continue;
+    const path = join11(cwd, relativePath);
+    if (!existsSync11(path)) continue;
     try {
-      const parsed = JSON.parse(readFileSync7(path, "utf8"));
+      const parsed = JSON.parse(readFileSync8(path, "utf8"));
       const result = CorrectionRulesContract.safeParse(parsed);
       if (!result.success) {
         findings.push({
@@ -1964,9 +2176,9 @@ function addAgentStudioFindings(cwd, findings) {
       });
     }
   }
-  const studioExportPath = join10(cwd, STUDIO_EXPORT_HTML);
-  if (existsSync10(studioExportPath)) {
-    const exportHtml = readFileSync7(studioExportPath, "utf8");
+  const studioExportPath = join11(cwd, STUDIO_EXPORT_HTML);
+  if (existsSync11(studioExportPath)) {
+    const exportHtml = readFileSync8(studioExportPath, "utf8");
     if (containsLikelySecret(exportHtml)) {
       findings.push({
         level: "fail",
@@ -1989,8 +2201,8 @@ function addAgentStudioFindings(cwd, findings) {
       });
     }
   }
-  const sessionsRoot = join10(cwd, COUNCIL_SESSION_DIR);
-  if (!existsSync10(sessionsRoot)) return;
+  const sessionsRoot = join11(cwd, COUNCIL_SESSION_DIR);
+  if (!existsSync11(sessionsRoot)) return;
   const files = listFilesRecursive(sessionsRoot);
   const studioSessionFiles = files.filter((file) => /[\\/]session\.json$/.test(file));
   for (const sessionFile of studioSessionFiles) {
@@ -2001,10 +2213,10 @@ function addAgentStudioFindings(cwd, findings) {
     const eventsRelative = `${COUNCIL_SESSION_DIR}/${normalizedSessionDir}/events.jsonl`;
     const indexRelative = `${COUNCIL_SESSION_DIR}/${normalizedSessionDir}/index.md`;
     const transcriptRelative = `${COUNCIL_SESSION_DIR}/${normalizedSessionDir}/transcript.md`;
-    const sessionDirPath = join10(sessionsRoot, sessionDir2);
+    const sessionDirPath = join11(sessionsRoot, sessionDir2);
     let sessionResult = null;
     try {
-      sessionResult = StudioSessionContract.safeParse(JSON.parse(readFileSync7(join10(sessionDirPath, "session.json"), "utf8")));
+      sessionResult = StudioSessionContract.safeParse(JSON.parse(readFileSync8(join11(sessionDirPath, "session.json"), "utf8")));
       if (!sessionResult.success) {
         findings.push({
           level: "fail",
@@ -2023,8 +2235,8 @@ function addAgentStudioFindings(cwd, findings) {
       });
       continue;
     }
-    const eventsPath2 = join10(sessionDirPath, "events.jsonl");
-    if (!existsSync10(eventsPath2)) {
+    const eventsPath2 = join11(sessionDirPath, "events.jsonl");
+    if (!existsSync11(eventsPath2)) {
       findings.push({
         level: "fail",
         area: "studio",
@@ -2033,7 +2245,7 @@ function addAgentStudioFindings(cwd, findings) {
       });
       continue;
     }
-    const eventText = readFileSync7(eventsPath2, "utf8");
+    const eventText = readFileSync8(eventsPath2, "utf8");
     if (containsLikelySecret(eventText)) {
       findings.push({
         level: "fail",
@@ -2068,7 +2280,7 @@ function addAgentStudioFindings(cwd, findings) {
         });
       }
     }
-    if (!existsSync10(join10(sessionDirPath, "index.md")) || !existsSync10(join10(sessionDirPath, "transcript.md"))) {
+    if (!existsSync11(join11(sessionDirPath, "index.md")) || !existsSync11(join11(sessionDirPath, "transcript.md"))) {
       findings.push({
         level: "warn",
         area: "studio",
@@ -2076,8 +2288,8 @@ function addAgentStudioFindings(cwd, findings) {
         remediation: "Run agent-kit session render so humans can inspect the current agent transcript and handoffs."
       });
     } else {
-      const indexText = readFileSync7(join10(sessionDirPath, "index.md"), "utf8");
-      const transcriptText = readFileSync7(join10(sessionDirPath, "transcript.md"), "utf8");
+      const indexText = readFileSync8(join11(sessionDirPath, "index.md"), "utf8");
+      const transcriptText = readFileSync8(join11(sessionDirPath, "transcript.md"), "utf8");
       if (containsLikelySecret(indexText) || containsLikelySecret(transcriptText)) {
         findings.push({
           level: "fail",
@@ -2086,7 +2298,7 @@ function addAgentStudioFindings(cwd, findings) {
           remediation: "Regenerate Markdown after redacting sensitive values from the event log."
         });
       }
-      if (statSync(eventsPath2).mtimeMs > statSync(join10(sessionDirPath, "index.md")).mtimeMs) {
+      if (statSync(eventsPath2).mtimeMs > statSync(join11(sessionDirPath, "index.md")).mtimeMs) {
         findings.push({
           level: "warn",
           area: "studio",
@@ -2136,8 +2348,8 @@ function addCouncilDocFindings(cwd, findings) {
 }
 function addAssistantAdapterFindings(cwd, findings, adapterRootRelativePath = ".agent-kit/assistant-adapters", docsCwd = cwd) {
   const adaptersDoc = readDoc(docsCwd, "ASSISTANT_ADAPTERS.md");
-  const adapterRoot = join10(cwd, adapterRootRelativePath);
-  if (!existsSync10(adapterRoot)) {
+  const adapterRoot = join11(cwd, adapterRootRelativePath);
+  if (!existsSync11(adapterRoot)) {
     findings.push({
       level: "warn",
       area: "agents",
@@ -2157,7 +2369,7 @@ function addAssistantAdapterFindings(cwd, findings, adapterRootRelativePath = ".
       level: "warn",
       area: "agents",
       message: "ASSISTANT_ADAPTERS.md does not map the council roster to supported tool instruction surfaces.",
-      remediation: "Document Codex/AGENTS.md, GitHub Copilot, Cursor rules, Claude Code subagents, and the source-of-truth rule for avoiding divergent agent instructions."
+      remediation: "Document Codex/AGENTS.md, GitHub Copilot, Cursor rules and subagents, Claude Code subagents, and the source-of-truth rule for avoiding divergent agent instructions."
     });
   } else {
     findings.push({
@@ -2166,6 +2378,22 @@ function addAssistantAdapterFindings(cwd, findings, adapterRootRelativePath = ".
       message: "ASSISTANT_ADAPTERS.md maps the council roster to tool-specific instruction surfaces."
     });
   }
+  if (assistantAdapterRowIsActive(adaptersDoc, "Cursor") && !existsSync11(join11(cwd, ".cursor/agents/planner.md"))) {
+    findings.push({
+      level: "warn",
+      area: "agents",
+      message: "Cursor is marked Active but .cursor/agents/planner.md is missing.",
+      remediation: "Run agent-kit init --activate cursor to generate council subagents from the roster."
+    });
+  }
+  if (assistantAdapterRowIsActive(adaptersDoc, "Codex / AGENTS.md-compatible tools") && !existsSync11(join11(cwd, ".codex/agents/planner.toml"))) {
+    findings.push({
+      level: "warn",
+      area: "agents",
+      message: "Codex is marked Active but .codex/agents/planner.toml is missing.",
+      remediation: "Run agent-kit init --activate codex to generate council custom agents from the roster."
+    });
+  }
   if (!includesAll(adaptersDoc, ["model selection", "enforcement", "MODEL_ROUTING.md", "model-routing.json"])) {
     findings.push({
       level: "warn",
@@ -2206,8 +2434,8 @@ function addModelRoutingFindings(cwd, findings, routingRelativePath = DEFAULT_MO
       message: "MODEL_ROUTING.md documents agent model profiles and IDE enforcement limits."
     });
   }
-  const routingPath = join10(cwd, routingRelativePath);
-  if (!existsSync10(routingPath)) {
+  const routingPath = join11(cwd, routingRelativePath);
+  if (!existsSync11(routingPath)) {
     findings.push({
       level: "warn",
       area: "models",
@@ -2218,7 +2446,7 @@ function addModelRoutingFindings(cwd, findings, routingRelativePath = DEFAULT_MO
   }
   let routing;
   try {
-    routing = JSON.parse(readFileSync7(routingPath, "utf8"));
+    routing = JSON.parse(readFileSync8(routingPath, "utf8"));
   } catch {
     findings.push({
       level: "warn",
@@ -2276,11 +2504,11 @@ function addTemplateHashFindings(cwd, findings) {
   if (!manifest) return;
   const overrides = readOverrides(cwd);
   for (const doc of ROOT_DOCS) {
-    const targetPath = join10(cwd, doc);
-    if (!existsSync10(targetPath)) continue;
+    const targetPath = join11(cwd, doc);
+    if (!existsSync11(targetPath)) continue;
     const currentTemplate = readTemplate(manifest.stack, doc);
     if (!currentTemplate) continue;
-    const targetHash = sha256(readFileSync7(targetPath, "utf8"));
+    const targetHash = sha256(readFileSync8(targetPath, "utf8"));
     const currentTemplateHash = sha256(currentTemplate);
     const installedTemplateHash = manifest.templateHashes?.[doc];
     const override = overrides[doc];
@@ -2584,7 +2812,7 @@ function auditProject(cwd) {
   const manifest = readManifest(cwd);
   const packageRepository = isPackageRepository(cwd);
   const packageSourceMode = packageRepository && !manifest;
-  const docsCwd = packageSourceMode ? join10(cwd, "templates", "next-supabase") : cwd;
+  const docsCwd = packageSourceMode ? join11(cwd, "templates", "next-supabase") : cwd;
   if (!manifest) {
     if (packageRepository) {
       findings.push({
@@ -2611,13 +2839,13 @@ function auditProject(cwd) {
   addAgentRosterFindings(cwd, findings, packageSourceMode ? "rosters/next-supabase-default-council.json" : DEFAULT_AGENT_ROSTER_TARGET);
   addSchemaFindings(cwd, findings, packageSourceMode ? "schemas" : ".agent-kit/schemas");
   addCouncilSessionRecordFindings(cwd, findings);
-  if (!packageRepository || existsSync10(join10(cwd, CONTEXT_JSON)) || existsSync10(join10(cwd, COUNCIL_SESSION_DIR))) {
+  if (!packageRepository || existsSync11(join11(cwd, CONTEXT_JSON)) || existsSync11(join11(cwd, COUNCIL_SESSION_DIR))) {
     addAgentStudioFindings(cwd, findings);
   }
   for (const doc of ROOT_DOCS) {
-    const docPath = join10(docsCwd, doc);
+    const docPath = join11(docsCwd, doc);
     const displayPath = packageSourceMode ? `templates/next-supabase/${doc}` : doc;
-    if (existsSync10(docPath)) {
+    if (existsSync11(docPath)) {
       findings.push({ level: "pass", area: "docs", message: `${displayPath} exists.` });
     } else {
       findings.push({
@@ -2682,10 +2910,10 @@ function auditProject(cwd) {
   return findings;
 }
 function readPackageJson2(cwd) {
-  const path = join10(cwd, "package.json");
-  if (!existsSync10(path)) return null;
+  const path = join11(cwd, "package.json");
+  if (!existsSync11(path)) return null;
   try {
-    return JSON.parse(readFileSync7(path, "utf8"));
+    return JSON.parse(readFileSync8(path, "utf8"));
   } catch {
     return null;
   }
@@ -2699,8 +2927,8 @@ function containsLikelySecretForAudit(relativeFile, content) {
   return containsLikelySecret(content);
 }
 function addProjectRealityFindings(cwd, findings, options = {}) {
-  const migrationsDir = join10(cwd, "supabase", "migrations");
-  if (existsSync10(migrationsDir)) {
+  const migrationsDir = join11(cwd, "supabase", "migrations");
+  if (existsSync11(migrationsDir)) {
     const sqlFiles = listFilesRecursive(migrationsDir).filter((file) => file.endsWith(".sql"));
     if (sqlFiles.length === 0) {
       findings.push({
@@ -2711,7 +2939,7 @@ function addProjectRealityFindings(cwd, findings, options = {}) {
       });
     } else {
       const rlsFiles = sqlFiles.filter((file) => {
-        const content = readFileSync7(join10(migrationsDir, file), "utf8");
+        const content = readFileSync8(join11(migrationsDir, file), "utf8");
         return /enable\s+row\s+level\s+security/i.test(content);
       });
       if (rlsFiles.length === 0) {
@@ -2761,7 +2989,7 @@ function addProjectRealityFindings(cwd, findings, options = {}) {
     return /\.(ts|tsx|js|jsx|env|json)$/.test(file);
   });
   const secretHits = trackedSourceFiles.map((file) => {
-    const content = readFileSync7(join10(cwd, file), "utf8");
+    const content = readFileSync8(join11(cwd, file), "utf8");
     return containsLikelySecretForAudit(file, content) ? file : null;
   }).filter((file) => file !== null).slice(0, 5);
   if (secretHits.length > 0) {
@@ -2784,7 +3012,7 @@ function addProjectRealityFindings(cwd, findings, options = {}) {
       area: "project-reality",
       message: "Package source repository mode does not require installed-project context files."
     });
-  } else if (!existsSync10(join10(cwd, CONTEXT_JSON))) {
+  } else if (!existsSync11(join11(cwd, CONTEXT_JSON))) {
     findings.push({
       level: "warn",
       area: "project-reality",
@@ -2850,7 +3078,7 @@ function report(target, findings) {
 }
 function readJson(path) {
   try {
-    return JSON.parse(readFileSync8(path, "utf8"));
+    return JSON.parse(readFileSync9(path, "utf8"));
   } catch {
     return null;
   }
@@ -2864,24 +3092,24 @@ function isSafeRelativePath(path) {
   return !normalized.startsWith("/") && !normalized.startsWith("../") && !normalized.includes("/../");
 }
 function findAntigravityLayout(cwd) {
-  const sourcePlugin = join11(cwd, "antigravity", "plugin.json");
-  if (existsSync11(sourcePlugin)) {
+  const sourcePlugin = join12(cwd, "antigravity", "plugin.json");
+  if (existsSync12(sourcePlugin)) {
     return {
       mode: "source",
-      pluginRoot: join11(cwd, "antigravity"),
-      commandsRoot: join11(cwd, ANTIGRAVITY_COMMANDS_SOURCE_DIR),
-      runtimeSkillsRoot: join11(cwd, RUNTIME_SKILLS_SOURCE_DIR),
-      adapterDocPath: join11(cwd, "assistant-adapters", "antigravity.md")
+      pluginRoot: join12(cwd, "antigravity"),
+      commandsRoot: join12(cwd, ANTIGRAVITY_COMMANDS_SOURCE_DIR),
+      runtimeSkillsRoot: join12(cwd, RUNTIME_SKILLS_SOURCE_DIR),
+      adapterDocPath: join12(cwd, "assistant-adapters", "antigravity.md")
     };
   }
-  const installedPlugin = join11(cwd, ".antigravity", "agent-kit", "plugin.json");
-  if (existsSync11(installedPlugin)) {
+  const installedPlugin = join12(cwd, ".antigravity", "agent-kit", "plugin.json");
+  if (existsSync12(installedPlugin)) {
     return {
       mode: "installed",
-      pluginRoot: join11(cwd, ".antigravity", "agent-kit"),
-      commandsRoot: join11(cwd, ANTIGRAVITY_COMMANDS_TARGET_DIR),
-      runtimeSkillsRoot: join11(cwd, ANTIGRAVITY_RUNTIME_SKILLS_TARGET_DIR),
-      adapterDocPath: join11(cwd, ".antigravity", "agent-kit", "README.md")
+      pluginRoot: join12(cwd, ".antigravity", "agent-kit"),
+      commandsRoot: join12(cwd, ANTIGRAVITY_COMMANDS_TARGET_DIR),
+      runtimeSkillsRoot: join12(cwd, ANTIGRAVITY_RUNTIME_SKILLS_TARGET_DIR),
+      adapterDocPath: join12(cwd, ".antigravity", "agent-kit", "README.md")
     };
   }
   return null;
@@ -2905,8 +3133,8 @@ function validateAntigravityCommands(layout, findings) {
   const commandNames = /* @__PURE__ */ new Set();
   for (const command of REQUIRED_COMMANDS) {
     const relativePath = `${command}.toml`;
-    const path = join11(layout.commandsRoot, relativePath);
-    if (!existsSync11(path)) {
+    const path = join12(layout.commandsRoot, relativePath);
+    if (!existsSync12(path)) {
       findings.push({
         level: "fail",
         area: "commands",
@@ -2915,7 +3143,7 @@ function validateAntigravityCommands(layout, findings) {
       });
       continue;
     }
-    const text = readFileSync8(path, "utf8");
+    const text = readFileSync9(path, "utf8");
     addSecretFinding(relativePath, text, findings);
     const name = commandField(text, "name");
     const description = commandField(text, "description");
@@ -2972,7 +3200,7 @@ function validateAntigravityCommands(layout, findings) {
   }
 }
 function validateAntigravityPlugin(layout, findings) {
-  const pluginPath = join11(layout.pluginRoot, "plugin.json");
+  const pluginPath = join12(layout.pluginRoot, "plugin.json");
   const plugin = readJson(pluginPath);
   if (!plugin || !isRecord2(plugin)) {
     findings.push({
@@ -3012,8 +3240,8 @@ function validateAntigravityPlugin(layout, findings) {
       });
       continue;
     }
-    const resolved = join11(layout.pluginRoot, path);
-    if (!existsSync11(resolved)) {
+    const resolved = join12(layout.pluginRoot, path);
+    if (!existsSync12(resolved)) {
       findings.push({
         level: "fail",
         area: "manifest",
@@ -3022,7 +3250,7 @@ function validateAntigravityPlugin(layout, findings) {
       });
     }
   }
-  const pluginText = readFileSync8(pluginPath, "utf8");
+  const pluginText = readFileSync9(pluginPath, "utf8");
   addSecretFinding("plugin.json", pluginText, findings);
   if (Array.isArray(plugin.sourceOfTruth) && plugin.sourceOfTruth.includes("AGENTS.md") && plugin.sourceOfTruth.includes(".agent-kit/agent-roster.json")) {
     findings.push({
@@ -3040,13 +3268,13 @@ function validateAntigravityPlugin(layout, findings) {
   }
 }
 function validateRuntimeSkills(cwd, layout, findings) {
-  const canonicalSkillsRoot = existsSync11(join11(cwd, "skills")) ? join11(cwd, "skills") : join11(cwd, ".agent-kit", "skills");
+  const canonicalSkillsRoot = existsSync12(join12(cwd, "skills")) ? join12(cwd, "skills") : join12(cwd, ".agent-kit", "skills");
   const canonicalSkillNames = listFilesRecursive(canonicalSkillsRoot).filter((file) => file.endsWith(".md")).map((file) => file.replace(/\.md$/, ""));
   const runtimeSkillFiles = listFilesRecursive(layout.runtimeSkillsRoot).filter((file) => file.endsWith("/SKILL.md") || file === "SKILL.md");
   const runtimeSkillNames = runtimeSkillFiles.map((file) => file.split(/[\\/]/)[0]).filter((value) => typeof value === "string" && value.length > 0).filter((value, index, values) => values.indexOf(value) === index);
   for (const skillName of canonicalSkillNames) {
-    const runtimePath = join11(layout.runtimeSkillsRoot, skillName, "SKILL.md");
-    if (!existsSync11(runtimePath)) {
+    const runtimePath = join12(layout.runtimeSkillsRoot, skillName, "SKILL.md");
+    if (!existsSync12(runtimePath)) {
       findings.push({
         level: "fail",
         area: "runtime-skills",
@@ -3055,7 +3283,7 @@ function validateRuntimeSkills(cwd, layout, findings) {
       });
       continue;
     }
-    const text = readFileSync8(runtimePath, "utf8");
+    const text = readFileSync9(runtimePath, "utf8");
     addSecretFinding(`${skillName}/SKILL.md`, text, findings);
     if (!/^---\nname: .+\ndescription: .+\n---/m.test(text)) {
       findings.push({
@@ -3083,7 +3311,7 @@ function validateRuntimeSkills(cwd, layout, findings) {
       remediation: "Add canonical skills or remove orphan runtime wrappers."
     });
   }
-  if (canonicalSkillNames.length > 0 && canonicalSkillNames.every((skillName) => existsSync11(join11(layout.runtimeSkillsRoot, skillName, "SKILL.md")))) {
+  if (canonicalSkillNames.length > 0 && canonicalSkillNames.every((skillName) => existsSync12(join12(layout.runtimeSkillsRoot, skillName, "SKILL.md")))) {
     findings.push({
       level: "pass",
       area: "runtime-skills",
@@ -3104,7 +3332,7 @@ function validateAntigravity(cwd) {
       }
     ]);
   }
-  const adapterDoc = existsSync11(layout.adapterDocPath) ? readFileSync8(layout.adapterDocPath, "utf8") : "";
+  const adapterDoc = existsSync12(layout.adapterDocPath) ? readFileSync9(layout.adapterDocPath, "utf8") : "";
   if (!adapterDoc) {
     findings.push({
       level: "fail",
@@ -3133,7 +3361,7 @@ function validateAntigravity(cwd) {
   validateAntigravityCommands(layout, findings);
   validateRuntimeSkills(cwd, layout, findings);
   if (layout.mode === "source") {
-    const packageJson = readJson(join11(cwd, "package.json"));
+    const packageJson = readJson(join12(cwd, "package.json"));
     const files = isRecord2(packageJson) && Array.isArray(packageJson.files) ? packageJson.files : [];
     for (const requiredFile of ["antigravity", "runtime-skills", "assistant-adapters"]) {
       if (!files.includes(requiredFile)) {
@@ -3157,40 +3385,145 @@ function validateAntigravity(cwd) {
 }
 function validateBasicAdapter(cwd, target) {
   const findings = [];
-  const sourcePaths = {
-    cursor: ["assistant-adapters/cursor-agent-kit.mdc", "assistant-adapters/model-selection/cursor-model-selection.mdc"],
-    claude: ["assistant-adapters/claude-code-subagents.md"],
-    codex: ["assistant-adapters/codex-agents.md", "assistant-adapters/model-selection/codex-config.example.toml"],
-    copilot: ["assistant-adapters/github-copilot-instructions.md", "assistant-adapters/github-next-supabase.instructions.md"]
-  };
-  for (const relativePath of sourcePaths[target]) {
-    const path = join11(cwd, relativePath);
-    if (!existsSync11(path)) {
+  const isPackageSource = existsSync12(join12(cwd, "package.json")) && existsSync12(join12(cwd, "src")) && existsSync12(join12(cwd, "templates"));
+  if (isPackageSource) {
+    const sourcePaths = {
+      cursor: [
+        "assistant-adapters/cursor-agent-kit.mdc",
+        "assistant-adapters/model-selection/cursor-model-selection.mdc",
+        "assistant-adapters/cursor-planner.mdc"
+      ],
+      claude: ["assistant-adapters/claude-code-subagents.md"],
+      codex: ["assistant-adapters/codex-agents.md", "assistant-adapters/model-selection/codex-config.example.toml"],
+      copilot: ["assistant-adapters/github-copilot-instructions.md", "assistant-adapters/github-next-supabase.instructions.md"]
+    };
+    for (const relativePath of sourcePaths[target]) {
+      const path = join12(cwd, relativePath);
+      if (!existsSync12(path)) {
+        findings.push({
+          level: "fail",
+          area: "adapter",
+          message: `${relativePath} is missing.`,
+          remediation: "Restore the adapter template or run agent-kit update."
+        });
+        continue;
+      }
+      const text = readFileSync9(path, "utf8");
+      addSecretFinding(relativePath, text, findings);
+      if (!text.includes("AGENTS.md") && !text.includes("MODEL_ROUTING.md")) {
+        findings.push({
+          level: "warn",
+          area: "adapter",
+          message: `${relativePath} does not clearly reference Agent Kit source-of-truth files.`,
+          remediation: "Adapter templates should point back to AGENTS.md, MODEL_ROUTING.md, and the roster contract."
+        });
+      }
+    }
+  } else {
+    findings.push(...validateInstalledIdeAdapter(cwd, target).findings);
+  }
+  if (findings.every((finding) => finding.level !== "fail")) {
+    findings.push({
+      level: "pass",
+      area: "adapter",
+      message: `${target} adapter ${isPackageSource ? "templates are present" : "activation assets are present"}.`
+    });
+  }
+  return report(target, findings);
+}
+function readAssistantAdaptersDoc(cwd) {
+  const path = join12(cwd, "ASSISTANT_ADAPTERS.md");
+  return existsSync12(path) ? readFileSync9(path, "utf8") : "";
+}
+function adaptersRowIsActive(doc, toolLabel) {
+  return assistantAdapterRowIsActive(doc, toolLabel);
+}
+function validateInstalledIdeAdapter(cwd, target) {
+  const findings = [];
+  const adaptersDoc = readAssistantAdaptersDoc(cwd);
+  if (target === "cursor") {
+    const rulesPath = join12(cwd, ".cursor/rules/cursor-agent-kit.mdc");
+    if (!existsSync12(rulesPath)) {
       findings.push({
         level: "fail",
         area: "adapter",
-        message: `${relativePath} is missing.`,
-        remediation: "Restore the adapter template or run agent-kit update."
+        message: ".cursor/rules/cursor-agent-kit.mdc is missing.",
+        remediation: "Run agent-kit init or agent-kit init --activate cursor."
       });
-      continue;
+    } else {
+      addSecretFinding(".cursor/rules/cursor-agent-kit.mdc", readFileSync9(rulesPath, "utf8"), findings);
     }
-    const text = readFileSync8(path, "utf8");
-    addSecretFinding(relativePath, text, findings);
-    if (!text.includes("AGENTS.md") && !text.includes("MODEL_ROUTING.md")) {
+    const plannerAgent = join12(cwd, ".cursor/agents/planner.md");
+    if (existsSync12(plannerAgent)) {
+      findings.push({
+        level: "pass",
+        area: "adapter",
+        message: ".cursor/agents/planner.md is installed."
+      });
+    } else if (adaptersRowIsActive(adaptersDoc, "Cursor")) {
       findings.push({
         level: "warn",
         area: "adapter",
-        message: `${relativePath} does not clearly reference Agent Kit source-of-truth files.`,
-        remediation: "Adapter templates should point back to AGENTS.md, MODEL_ROUTING.md, and the roster contract."
+        message: "Cursor is marked Active but .cursor/agents/planner.md is missing.",
+        remediation: "Run agent-kit init --activate cursor to generate council subagents from the roster."
+      });
+    }
+    const skillSample = join12(cwd, ".cursor/skills/planning-council/SKILL.md");
+    if (existsSync12(skillSample)) {
+      findings.push({
+        level: "pass",
+        area: "adapter",
+        message: ".cursor/skills/*/SKILL.md project skills are installed."
       });
     }
   }
-  if (findings.every((finding) => finding.level !== "fail")) {
-    findings.push({
-      level: "pass",
-      area: "adapter",
-      message: `${target} adapter templates are present.`
-    });
+  if (target === "claude") {
+    const plannerAgent = join12(cwd, ".claude/agents/planner.md");
+    if (!existsSync12(plannerAgent)) {
+      findings.push({
+        level: "fail",
+        area: "adapter",
+        message: ".claude/agents/planner.md is missing.",
+        remediation: "Run agent-kit init --activate claude."
+      });
+    }
+  }
+  if (target === "codex") {
+    const configPath = join12(cwd, ".codex/config.toml");
+    if (!existsSync12(configPath)) {
+      findings.push({
+        level: "fail",
+        area: "adapter",
+        message: ".codex/config.toml is missing.",
+        remediation: "Run agent-kit init --activate codex."
+      });
+    }
+    const plannerAgent = join12(cwd, ".codex/agents/planner.toml");
+    if (existsSync12(plannerAgent)) {
+      findings.push({
+        level: "pass",
+        area: "adapter",
+        message: ".codex/agents/planner.toml is installed."
+      });
+    } else if (adaptersRowIsActive(adaptersDoc, "Codex / AGENTS.md-compatible tools")) {
+      findings.push({
+        level: "warn",
+        area: "adapter",
+        message: "Codex is marked Active but .codex/agents/planner.toml is missing.",
+        remediation: "Run agent-kit init --activate codex to generate council custom agents from the roster."
+      });
+    }
+  }
+  if (target === "copilot") {
+    const instructions = join12(cwd, ".github/copilot-instructions.md");
+    if (!existsSync12(instructions)) {
+      findings.push({
+        level: "fail",
+        area: "adapter",
+        message: ".github/copilot-instructions.md is missing.",
+        remediation: "Run agent-kit init --activate copilot."
+      });
+    }
   }
   return report(target, findings);
 }
@@ -3207,7 +3540,7 @@ function validateAdapter(cwd, target = "antigravity") {
 }
 function validatePackage(cwd) {
   const findings = [];
-  const sourceMode = existsSync11(join11(cwd, "package.json")) && existsSync11(join11(cwd, "src")) && existsSync11(join11(cwd, "templates"));
+  const sourceMode = existsSync12(join12(cwd, "package.json")) && existsSync12(join12(cwd, "src")) && existsSync12(join12(cwd, "templates"));
   if (!sourceMode) {
     return report("package", [
       {
@@ -3220,8 +3553,8 @@ function validatePackage(cwd) {
   }
   findings.push(...validateAntigravity(cwd).findings);
   for (const doc of ["README.md", "DOCS.md", "SPEC.md", "DECISIONS.md", "QUALITY_GATES.md", "TESTING.md", "UPGRADE.md"]) {
-    const path = join11(cwd, doc);
-    const text = existsSync11(path) ? readFileSync8(path, "utf8") : "";
+    const path = join12(cwd, doc);
+    const text = existsSync12(path) ? readFileSync9(path, "utf8") : "";
     const lower = text.toLowerCase();
     if (!lower.includes("antigravity") && !lower.includes("runtime command") && !lower.includes("runtime adapter")) {
       findings.push({
@@ -3238,7 +3571,7 @@ function validatePackage(cwd) {
     "examples/next-supabase-installed/.agent-kit/manifest.json",
     "examples/next-supabase-installed/audit-output.json"
   ]) {
-    if (!existsSync11(join11(cwd, examplePath))) {
+    if (!existsSync12(join12(cwd, examplePath))) {
       findings.push({
         level: "fail",
         area: "examples",
@@ -3273,17 +3606,17 @@ function validatePackage(cwd) {
 }
 
 // src/install/diff.ts
-import { existsSync as existsSync12, readFileSync as readFileSync9 } from "fs";
-import { join as join12 } from "path";
+import { existsSync as existsSync13, readFileSync as readFileSync10 } from "fs";
+import { join as join13 } from "path";
 function statusForTextFile(target, template) {
-  if (!existsSync12(target)) return "missing";
-  const targetHash = sha256(readFileSync9(target, "utf8"));
-  const templateHash = sha256(readFileSync9(template, "utf8"));
+  if (!existsSync13(target)) return "missing";
+  const targetHash = sha256(readFileSync10(target, "utf8"));
+  const templateHash = sha256(readFileSync10(template, "utf8"));
   return targetHash === templateHash ? "unchanged" : "changed";
 }
 function diffProject(cwd, stack = "next-supabase") {
   const packageRoot = findPackageRoot();
-  const templateRoot = join12(packageRoot, "templates", stack);
+  const templateRoot = join13(packageRoot, "templates", stack);
   const libraryFolders = {
     missing: [],
     present: [],
@@ -3307,8 +3640,8 @@ function diffProject(cwd, stack = "next-supabase") {
     }
   };
   for (const doc of ROOT_DOCS) {
-    const target = join12(cwd, doc);
-    const template = join12(templateRoot, doc);
+    const target = join13(cwd, doc);
+    const template = join13(templateRoot, doc);
     const status = statusForTextFile(target, template);
     if (status === "missing") {
       result.missing.push(doc);
@@ -3321,7 +3654,7 @@ function diffProject(cwd, stack = "next-supabase") {
       result.preview.wouldWriteConflicts.push(doc);
     }
   }
-  result.agentRoster = statusForTextFile(join12(cwd, DEFAULT_AGENT_ROSTER_TARGET), join12(packageRoot, DEFAULT_AGENT_ROSTER_SOURCE));
+  result.agentRoster = statusForTextFile(join13(cwd, DEFAULT_AGENT_ROSTER_TARGET), join13(packageRoot, DEFAULT_AGENT_ROSTER_SOURCE));
   if (result.agentRoster === "missing") {
     result.preview.wouldCreate.push(DEFAULT_AGENT_ROSTER_TARGET);
     result.preview.wouldCreateAgentRoster = true;
@@ -3330,7 +3663,7 @@ function diffProject(cwd, stack = "next-supabase") {
     result.preview.wouldWriteConflicts.push(DEFAULT_AGENT_ROSTER_TARGET);
     result.preview.wouldWriteAgentRosterConflict = true;
   }
-  result.modelRouting = statusForTextFile(join12(cwd, DEFAULT_MODEL_ROUTING_TARGET), join12(packageRoot, DEFAULT_MODEL_ROUTING_SOURCE));
+  result.modelRouting = statusForTextFile(join13(cwd, DEFAULT_MODEL_ROUTING_TARGET), join13(packageRoot, DEFAULT_MODEL_ROUTING_SOURCE));
   if (result.modelRouting === "missing") {
     result.preview.wouldCreate.push(DEFAULT_MODEL_ROUTING_TARGET);
     result.preview.wouldCreateModelRouting = true;
@@ -3340,8 +3673,8 @@ function diffProject(cwd, stack = "next-supabase") {
     result.preview.wouldWriteModelRoutingConflict = true;
   }
   for (const folder of LIBRARY_FOLDERS) {
-    const target = join12(cwd, ".agent-kit", folder);
-    if (existsSync12(target)) libraryFolders.present.push(folder);
+    const target = join13(cwd, ".agent-kit", folder);
+    if (existsSync13(target)) libraryFolders.present.push(folder);
     else libraryFolders.missing.push(folder);
   }
   return result;
@@ -3349,8 +3682,8 @@ function diffProject(cwd, stack = "next-supabase") {
 
 // src/research/discover.ts
 import { Octokit } from "@octokit/rest";
-import { readFileSync as readFileSync10 } from "fs";
-import { join as join13 } from "path";
+import { readFileSync as readFileSync11 } from "fs";
+import { join as join14 } from "path";
 
 // src/research/config.ts
 import { z as z2 } from "zod";
@@ -3375,8 +3708,8 @@ var researchConfigSchema = z2.object({
 // src/research/discover.ts
 async function discoverRepos(options) {
   const packageRoot = findPackageRoot();
-  const configPath = join13(packageRoot, "research", "scan-config.json");
-  const config = researchConfigSchema.parse(JSON.parse(readFileSync10(configPath, "utf8")));
+  const configPath = join14(packageRoot, "research", "scan-config.json");
+  const config = researchConfigSchema.parse(JSON.parse(readFileSync11(configPath, "utf8")));
   const token = options.token ?? process.env.GITHUB_TOKEN;
   if (!token) {
     throw new Error("GITHUB_TOKEN is required for GitHub API research discovery.");
@@ -3437,20 +3770,20 @@ async function discoverRepos(options) {
     }
   }
   const candidates = [...deduped.values()].slice(0, maxRepos);
-  const output = options.output ?? join13(options.cwd, "research", "repo-candidates.json");
+  const output = options.output ?? join14(options.cwd, "research", "repo-candidates.json");
   writeText(output, `${JSON.stringify(candidates, null, 2)}
 `);
   return candidates;
 }
 
 // src/research/scan.ts
-import { existsSync as existsSync15, mkdirSync as mkdirSync2, readFileSync as readFileSync12, rmSync } from "fs";
-import { join as join15 } from "path";
+import { existsSync as existsSync16, mkdirSync as mkdirSync2, readFileSync as readFileSync13, rmSync } from "fs";
+import { join as join16 } from "path";
 import { simpleGit } from "simple-git";
 
 // src/research/analyze.ts
-import { existsSync as existsSync14, readFileSync as readFileSync11 } from "fs";
-import { join as join14 } from "path";
+import { existsSync as existsSync15, readFileSync as readFileSync12 } from "fs";
+import { join as join15 } from "path";
 function normalizeRelativePath(file) {
   return file.replace(/\\/g, "/");
 }
@@ -3458,8 +3791,8 @@ function hasFile(files, matcher) {
   return files.some((file) => matcher.test(normalizeRelativePath(file)));
 }
 function fileText(root, file) {
-  const path = join14(root, file);
-  return existsSync14(path) ? readFileSync11(path, "utf8") : "";
+  const path = join15(root, file);
+  return existsSync15(path) ? readFileSync12(path, "utf8") : "";
 }
 function textIncludes(root, files, matcher, terms) {
   const lowerTerms = terms.map((term) => term.toLowerCase());
@@ -3590,24 +3923,24 @@ ${finding.impactOnKit.map((item) => `- ${item}`).join("\n")}
 `;
 }
 async function scanRepos(options) {
-  const candidatesPath = options.candidatesPath ?? join15(options.cwd, "research", "repo-candidates.json");
-  if (!existsSync15(candidatesPath)) {
+  const candidatesPath = options.candidatesPath ?? join16(options.cwd, "research", "repo-candidates.json");
+  if (!existsSync16(candidatesPath)) {
     throw new Error(`Candidates file not found: ${candidatesPath}`);
   }
-  const candidates = JSON.parse(readFileSync12(candidatesPath, "utf8"));
-  const workdir = options.workdir ?? join15(options.cwd, "research", "workdir");
+  const candidates = JSON.parse(readFileSync13(candidatesPath, "utf8"));
+  const workdir = options.workdir ?? join16(options.cwd, "research", "workdir");
   mkdirSync2(workdir, { recursive: true });
-  mkdirSync2(join15(options.cwd, "research", "findings"), { recursive: true });
+  mkdirSync2(join16(options.cwd, "research", "findings"), { recursive: true });
   const findings = [];
   const git = simpleGit();
   for (const candidate of candidates) {
     const repoSlug = candidate.fullName.replace("/", "__");
-    const repoPath = join15(workdir, repoSlug);
-    if (existsSync15(repoPath)) rmSync(repoPath, { recursive: true, force: true });
+    const repoPath = join16(workdir, repoSlug);
+    if (existsSync16(repoPath)) rmSync(repoPath, { recursive: true, force: true });
     await git.raw(["clone", "--depth", "1", candidate.htmlUrl, repoPath]);
     const finding = analyzeRepository(candidate, repoPath);
     findings.push(finding);
-    writeText(join15(options.cwd, "research", "findings", `${repoSlug}.md`), findingToMarkdown(finding));
+    writeText(join16(options.cwd, "research", "findings", `${repoSlug}.md`), findingToMarkdown(finding));
     if (!options.keepClones) {
       rmSync(repoPath, { recursive: true, force: true });
     }
@@ -3616,8 +3949,8 @@ async function scanRepos(options) {
 }
 
 // src/research/summarize.ts
-import { existsSync as existsSync16, readFileSync as readFileSync13, readdirSync as readdirSync2 } from "fs";
-import { join as join16 } from "path";
+import { existsSync as existsSync17, readFileSync as readFileSync14, readdirSync as readdirSync3 } from "fs";
+import { join as join17 } from "path";
 var SUMMARY_TARGETS = {
   "nextjs-patterns": {
     title: "Next.js Patterns",
@@ -3720,12 +4053,12 @@ function renderRepoList(findings, scoreKeys) {
   return findings.slice().sort((a, b) => scoreFor(b, scoreKeys) - scoreFor(a, scoreKeys) || b.totalScore - a.totalScore || b.stars - a.stars).slice(0, 12).map((finding) => `- ${finding.fullName} (${finding.category}) - focus score ${scoreFor(finding, scoreKeys)}, total ${finding.totalScore}/${maxTotalScore}`).join("\n");
 }
 function summarizeFindings(cwd) {
-  const findingsDir = join16(cwd, "research", "findings");
-  if (!existsSync16(findingsDir)) {
+  const findingsDir = join17(cwd, "research", "findings");
+  if (!existsSync17(findingsDir)) {
     throw new Error("No research/findings directory exists. Run agent-kit research scan first.");
   }
-  const findingFiles = readdirSync2(findingsDir).filter((file) => file.endsWith(".md"));
-  const findings = findingFiles.map((file) => parseFinding(file, readFileSync13(join16(findingsDir, file), "utf8"))).filter((finding) => finding !== null);
+  const findingFiles = readdirSync3(findingsDir).filter((file) => file.endsWith(".md"));
+  const findings = findingFiles.map((file) => parseFinding(file, readFileSync14(join17(findingsDir, file), "utf8"))).filter((finding) => finding !== null);
   const categoryCounts = countBy(findings.map((finding) => finding.category));
   const outputs = [];
   const overview = `# Research Scan Overview
@@ -3744,13 +4077,13 @@ ${countBy(findings.flatMap((finding) => finding.strongPractices)).slice(0, 12).m
 ## Most Repeated Gaps
 ${countBy(findings.flatMap((finding) => finding.weakPractices)).slice(0, 12).map(([practice, count]) => `- ${practice} (${count})`).join("\n")}
 `;
-  const overviewPath = join16(cwd, "research", "summaries", "scan-overview.md");
+  const overviewPath = join17(cwd, "research", "summaries", "scan-overview.md");
   writeText(overviewPath, overview);
   outputs.push(overviewPath);
   for (const [target, config] of Object.entries(SUMMARY_TARGETS)) {
     const categories = config.categories;
     const scopedFindings = findings.filter((finding) => categories.includes(finding.category));
-    const path = join16(cwd, "research", "summaries", `${target}.md`);
+    const path = join17(cwd, "research", "summaries", `${target}.md`);
     const summary2 = `# ${config.title}
 
 Generated from ${scopedFindings.length} relevant repository findings.
@@ -3791,7 +4124,7 @@ Review the generated research summaries, then convert repeated best practices in
 
 Do not copy source code from scanned repositories. Adopt only generalized practices with clear rationale.
 `;
-  const path = join16(cwd, "research", "proposed-updates.md");
+  const path = join17(cwd, "research", "proposed-updates.md");
   writeText(path, output);
   return path;
 }
@@ -3900,8 +4233,8 @@ function proposeCorrectionUpstream(cwd, id) {
 }
 
 // src/studio/session.ts
-import { existsSync as existsSync17, readFileSync as readFileSync14, readdirSync as readdirSync3, statSync as statSync2 } from "fs";
-import { join as join17 } from "path";
+import { existsSync as existsSync18, readFileSync as readFileSync15, readdirSync as readdirSync4, statSync as statSync2 } from "fs";
+import { join as join18 } from "path";
 function sessionDir(sessionId) {
   return `${COUNCIL_SESSIONS_DIR}/${safeSlug(sessionId)}`;
 }
@@ -3958,9 +4291,9 @@ function startSession(cwd, options) {
   return { sessionId, sessionPath: sessionDir(sessionId) };
 }
 function listSessions(cwd) {
-  const root = join17(cwd, COUNCIL_SESSIONS_DIR);
-  if (!existsSync17(root)) return [];
-  return readdirSync3(root).filter((entry) => entry !== "active").map((entry) => join17(root, entry, "session.json")).filter((path) => existsSync17(path) && statSync2(path).isFile()).map((path) => StudioSessionContract.parse(JSON.parse(readFileSync14(path, "utf8")))).sort((a, b) => a.createdAt.localeCompare(b.createdAt));
+  const root = join18(cwd, COUNCIL_SESSIONS_DIR);
+  if (!existsSync18(root)) return [];
+  return readdirSync4(root).filter((entry) => entry !== "active").map((entry) => join18(root, entry, "session.json")).filter((path) => existsSync18(path) && statSync2(path).isFile()).map((path) => StudioSessionContract.parse(JSON.parse(readFileSync15(path, "utf8")))).sort((a, b) => a.createdAt.localeCompare(b.createdAt));
 }
 function getActiveSessionId(cwd) {
   const active = readTextFile(cwd, ACTIVE_SESSION_FILE)?.trim();
@@ -4658,13 +4991,13 @@ function parseSetupFormPayload(raw) {
 }
 
 // src/studio/wizard/checklist.ts
-import { existsSync as existsSync18, readFileSync as readFileSync15 } from "fs";
-import { join as join18 } from "path";
+import { existsSync as existsSync19, readFileSync as readFileSync16 } from "fs";
+import { join as join19 } from "path";
 var IDE_PATHS = {
-  cursor: ".cursor/rules/cursor-agent-kit.mdc",
+  cursor: ".cursor/agents/planner.md",
   copilot: ".github/copilot-instructions.md",
-  claude: ".claude/agents/",
-  codex: "AGENTS.md",
+  claude: ".claude/agents/planner.md",
+  codex: ".codex/agents/planner.toml",
   other: "ASSISTANT_ADAPTERS.md"
 };
 function saveIdeChecklist(cwd, ideSurface) {
@@ -4679,10 +5012,13 @@ function saveIdeChecklist(cwd, ideSurface) {
 }
 function detectIdeRulePresent(cwd, ideSurface) {
   const rel = IDE_PATHS[ideSurface];
+  if (ideSurface === "cursor") {
+    return existsSync19(join19(cwd, rel)) || existsSync19(join19(cwd, ".cursor/rules/cursor-agent-kit.mdc"));
+  }
   if (rel.endsWith("/")) {
-    return existsSync18(join18(cwd, rel));
+    return existsSync19(join19(cwd, rel));
   }
-  return existsSync18(join18(cwd, rel));
+  return existsSync19(join19(cwd, rel));
 }
 var VISUAL_QA_MARKER = "## Visual QA Tier";
 var VISUAL_QA_BLOCKS = {
@@ -4710,11 +5046,11 @@ This project uses the **Mature** visual QA tier.
 };
 function writeVisualQaTier(cwd, tier) {
   const path = "TESTING.md";
-  const fullPath = join18(cwd, path);
-  if (!existsSync18(fullPath)) {
+  const fullPath = join19(cwd, path);
+  if (!existsSync19(fullPath)) {
     return { updated: false, path, reason: "TESTING.md not found in project root." };
   }
-  const current = readFileSync15(fullPath, "utf8");
+  const current = readFileSync16(fullPath, "utf8");
   if (current.includes(VISUAL_QA_MARKER)) {
     return {
       updated: false,
@@ -4890,8 +5226,8 @@ function extractSetupFormFromWizardForm(form) {
 }
 
 // src/studio/wizard/drafts.ts
-import { existsSync as existsSync19, readFileSync as readFileSync16 } from "fs";
-import { join as join19 } from "path";
+import { existsSync as existsSync20, readFileSync as readFileSync17 } from "fs";
+import { join as join20 } from "path";
 var DESIGN_DRAFT_JSON = ".agent-kit/onboarding/design-draft.json";
 var MESSAGING_DRAFT_JSON = ".agent-kit/onboarding/messaging-draft.json";
 function loadDesignDraft(cwd) {
@@ -4936,11 +5272,11 @@ function previewMessagingMarkdown(draft) {
 `;
 }
 function appendSectionToDoc(cwd, doc, sectionMarkdown) {
-  const fullPath = join19(cwd, doc);
-  if (!existsSync19(fullPath)) {
+  const fullPath = join20(cwd, doc);
+  if (!existsSync20(fullPath)) {
     return { target: doc, action: "missing" };
   }
-  const current = readFileSync16(fullPath, "utf8");
+  const current = readFileSync17(fullPath, "utf8");
   if (current.includes("(wizard draft)")) {
     return { target: doc, action: "conflict", conflictPath: `.agent-kit/conflicts/wizard-${doc}` };
   }
@@ -4979,8 +5315,8 @@ function applyDrafts(cwd) {
 }
 
 // src/studio/office/render.ts
-import { readFileSync as readFileSync17 } from "fs";
-import { join as join20 } from "path";
+import { readFileSync as readFileSync18 } from "fs";
+import { join as join21 } from "path";
 
 // src/studio/office/map.ts
 var MAP_WIDTH = 28;
@@ -5114,12 +5450,12 @@ var PRODUCT_CATEGORIES = [
 var TENANT_MODELS = ["single-user", "team", "tenant", "marketplace", "admin", "public-content"];
 function readOfficeAsset(name) {
   const root = findPackageRoot();
-  const distPath = join20(root, "dist", "studio", "office", "assets", name);
-  const srcPath = join20(root, "src", "studio", "office", "assets", name);
+  const distPath = join21(root, "dist", "studio", "office", "assets", name);
+  const srcPath = join21(root, "src", "studio", "office", "assets", name);
   try {
-    return readFileSync17(distPath, "utf8");
+    return readFileSync18(distPath, "utf8");
   } catch {
-    return readFileSync17(srcPath, "utf8");
+    return readFileSync18(srcPath, "utf8");
   }
 }
 function buildOfficeBootConfig(cwd, viewModel) {
@@ -5286,8 +5622,8 @@ function allAgentBriefsComplete(form, agentIds) {
 }
 
 // src/studio/wizard/render.ts
-import { readFileSync as readFileSync18 } from "fs";
-import { join as join21 } from "path";
+import { readFileSync as readFileSync19 } from "fs";
+import { join as join22 } from "path";
 var PRODUCT_CATEGORIES2 = [
   "content-app",
   "saas",
@@ -5304,12 +5640,12 @@ var PRODUCT_CATEGORIES2 = [
 var TENANT_MODELS2 = ["single-user", "team", "tenant", "marketplace", "admin", "public-content"];
 function readWizardAsset(name) {
   const root = findPackageRoot();
-  const distPath = join21(root, "dist", "studio", "wizard", "assets", name);
-  const srcPath = join21(root, "src", "studio", "wizard", "assets", name);
+  const distPath = join22(root, "dist", "studio", "wizard", "assets", name);
+  const srcPath = join22(root, "src", "studio", "wizard", "assets", name);
   try {
-    return readFileSync18(distPath, "utf8");
+    return readFileSync19(distPath, "utf8");
   } catch {
-    return readFileSync18(srcPath, "utf8");
+    return readFileSync19(srcPath, "utf8");
   }
 }
 function mergeWizardSteps(cwd) {
@@ -5574,9 +5910,20 @@ async function handleRequest(cwd, request, response) {
     try {
       const body = await readJsonBody(request);
       if (!body.ideSurface) throw new Error("ideSurface is required.");
+      const activateTarget = ideSurfaceToActivateTarget(body.ideSurface);
+      let activation;
+      if (activateTarget) {
+        const activateResult = activateIdeTargets({ cwd, targets: [activateTarget] });
+        activation = {
+          activated: activateResult.activated,
+          copied: activateResult.copied,
+          unchanged: activateResult.unchanged,
+          conflicts: activateResult.conflicts
+        };
+      }
       const result = saveIdeChecklist(cwd, body.ideSurface);
       markSectionComplete(cwd, "ide");
-      sendJson(response, 200, { ...result, ...buildStatePayload(cwd) });
+      sendJson(response, 200, { ...result, activation, ...buildStatePayload(cwd) });
     } catch (error) {
       sendJson(response, 400, { error: error instanceof Error ? error.message : String(error) });
     }
@@ -5689,7 +6036,7 @@ async function startSetupServer(options) {
 // src/studio/studio-server.ts
 import { watch } from "fs";
 import { createServer as createServer2 } from "http";
-import { join as join22 } from "path";
+import { join as join23 } from "path";
 var DEFAULT_PORT2 = 9331;
 var DEFAULT_HOST2 = "127.0.0.1";
 var sseClients = /* @__PURE__ */ new Set();
@@ -5731,7 +6078,7 @@ function stopWatcher() {
   }
 }
 function watchSessionEvents(cwd, sessionId) {
-  const eventsPath2 = join22(cwd, COUNCIL_SESSIONS_DIR, sessionId, "events.jsonl");
+  const eventsPath2 = join23(cwd, COUNCIL_SESSIONS_DIR, sessionId, "events.jsonl");
   if (watchedEventsPath === eventsPath2 && activeWatcher) return;
   stopWatcher();
   watchedEventsPath = eventsPath2;
@@ -5887,8 +6234,8 @@ async function startStudioServer(options) {
 }
 
 // src/studio/session-checkpoint.ts
-import { existsSync as existsSync20, readFileSync as readFileSync19 } from "fs";
-import { extname, join as join23 } from "path";
+import { existsSync as existsSync21, readFileSync as readFileSync20 } from "fs";
+import { extname, join as join24 } from "path";
 function parseCheckpointMarkdown(content) {
   const payload = { notes: [], decisions: [], handoffs: [], outputs: [] };
   const sections = content.split(/^## /m).slice(1);
@@ -5944,7 +6291,7 @@ function parseCheckpointMarkdown(content) {
   return payload;
 }
 function parseCheckpointFile(filePath) {
-  const content = readFileSync19(filePath, "utf8");
+  const content = readFileSync20(filePath, "utf8");
   const ext = extname(filePath).toLowerCase();
   if (ext === ".json") {
     const parsed = JSON.parse(content);
@@ -6020,8 +6367,8 @@ function applySessionCheckpoint(cwd, payload) {
   };
 }
 function checkpointSessionFromFile(cwd, filePath) {
-  const absolute = join23(cwd, filePath);
-  if (!existsSync20(absolute)) throw new Error(`Checkpoint file not found: ${filePath}`);
+  const absolute = join24(cwd, filePath);
+  if (!existsSync21(absolute)) throw new Error(`Checkpoint file not found: ${filePath}`);
   return applySessionCheckpoint(cwd, parseCheckpointFile(absolute));
 }