cc-codeconductor 0.3.0 → 0.3.2

package/dist/index.js

@@ -7044,7 +7044,7 @@ function getExitCode(error) {
 // package.json
 var package_default = {
   name: "cc-codeconductor",
-  version: "0.3.0",
+  version: "0.3.2",
   description: "A multi-agent orchestration framework for AI-assisted software engineering workflows.",
   keywords: [
     "ai",
@@ -7511,7 +7511,8 @@ function getRecommendedPresets(profile) {
 }
 
 // src/commands/doctor.command.ts
-import { join } from "node:path";
+import { join as join4 } from "node:path";
+import { homedir as homedir3 } from "node:os";
 
 // src/core/config/config-loader.ts
 import { readFile } from "node:fs/promises";
@@ -11721,251 +11722,1011 @@ async function loadTargetSecurityCompatibility() {
   });
 }
 
-// src/commands/doctor.command.ts
-async function doctorCommand(options) {
-  const { projectRoot, output } = options;
-  const checks = [];
-  try {
-    const hasConfig = await configExists(projectRoot);
-    if (hasConfig) {
-      checks.push({
-        name: "config-exists",
-        status: "pass",
-        message: ".codeconductor/config.yml exists"
-      });
-    } else {
-      checks.push({
-        name: "config-exists",
-        status: "fail",
-        message: ".codeconductor/config.yml not found. Run `codeconductor init` first."
-      });
-      return {
-        code: 4,
-        data: {
-          success: false,
-          command: "doctor",
-          checks
-        }
-      };
-    }
-    const configResult = await loadConfig(projectRoot);
-    if (configResult.success) {
-      checks.push({
-        name: "config-valid",
-        status: "pass",
-        message: "Config is valid"
-      });
-    } else {
-      checks.push({
-        name: "config-valid",
-        status: "fail",
-        message: `Config validation failed: ${configResult.error.message}`
-      });
-      return {
-        code: 1,
-        data: {
-          success: false,
-          command: "doctor",
-          checks
-        }
-      };
-    }
-    const runnerDirs = [".opencode", ".claude", ".codex"];
-    for (const dir of runnerDirs) {
-      try {
-        const { access: access2 } = await import("node:fs/promises");
-        await access2(join(projectRoot, dir));
-        checks.push({
-          name: `dir-${dir}`,
-          status: "pass",
-          message: `${dir}/ exists`
-        });
-      } catch {
-        checks.push({
-          name: `dir-${dir}`,
-          status: "warn",
-          message: `${dir}/ not found (optional)`
-        });
-      }
-    }
-    const config = configResult.data;
-    if (config.presets.council.enabled) {
-      checks.push({
-        name: "council-enabled",
-        status: "pass",
-        message: `Council preset enabled (v${config.presets.council.version})`
-      });
-    }
-    const securityCompatibility = await loadTargetSecurityCompatibility();
-    for (const compatibility of securityCompatibility) {
-      checks.push({
-        name: `security-${compatibility.target}`,
-        status: compatibility.status,
-        message: compatibility.status === "pass" ? `${compatibility.target} can represent the canonical policy model` : `${compatibility.target} cannot enforce: ${compatibility.unsupportedRules.join(", ") || "see warnings"}`
-      });
-    }
-    const failedCount = checks.filter((c) => c.status === "fail").length;
-    if (failedCount > 0) {
-      return {
-        code: 4,
-        data: {
-          success: false,
-          command: "doctor",
-          checks
-        }
-      };
-    }
-    return {
-      code: 0,
-      data: {
-        success: true,
-        command: "doctor",
-        checks,
-        securityCompatibility
-      }
-    };
-  } catch (error) {
-    return {
-      code: 1,
-      data: {
-        success: false,
-        command: "doctor",
-        errors: [String(error)]
-      }
-    };
-  }
+// src/core/presets/update-checker.ts
+import { stat as stat2, readFile as readFile5 } from "node:fs/promises";
+import { resolve as resolve4, join as join3 } from "node:path";
+import { homedir as homedir2 } from "node:os";
+
+// src/core/presets/manifest-loader.ts
+import { readFile as readFile3 } from "node:fs/promises";
+import { join } from "node:path";
+var MANIFESTS_DIR = join(SRC_PRESETS_DIR, "manifests");
+var MODELS_DIR = join(SRC_PRESETS_DIR, "models");
+var PRESETS_DIR = ROOT_PRESETS_DIR;
+async function loadManifest(target) {
+  const manifestPath = join(MANIFESTS_DIR, `${target}.yml`);
+  const content = await readFile3(manifestPath, "utf-8");
+  const data = $parse(content);
+  return InstallManifestSchema.parse(data);
+}
+async function loadModelConfig(target) {
+  const modelPath = join(MODELS_DIR, `${target}.yml`);
+  const content = await readFile3(modelPath, "utf-8");
+  const data = $parse(content);
+  return ModelConfigSchema.parse(data);
 }
 
-// src/commands/init.command.ts
-import { access as access3, mkdir as mkdir2, readFile as readFile3, writeFile as writeFile2 } from "node:fs/promises";
+// src/core/presets/file-copier.ts
+import { mkdir, readdir, readFile as readFile4, stat, writeFile } from "node:fs/promises";
 import { homedir } from "node:os";
-import { basename, resolve as resolve4 } from "node:path";
-
-// src/core/config/config-writer.ts
-import { access as access2, mkdir, writeFile } from "node:fs/promises";
-import { resolve as resolve3 } from "node:path";
+import { dirname as dirname2, join as join2, relative, resolve as resolve3 } from "node:path";
 
-// src/core/config/codeconductor-config.ts
-var DEFAULT_CONFIG = {
-  version: "0.2.0",
-  project: {
-    name: "unnamed-project"
-  },
-  defaults: {
-    target: "opencode",
-    overwrite: false,
-    locale: "en"
-  },
-  presets: {
-    council: {
-      enabled: true,
-      version: "0.1.0"
-    }
-  },
-  safety: {
-    destructiveCommands: ["rm -rf", "drop table", "delete from"],
-    secretPatterns: ["password", "secret", "api_key", "token"]
-  }
+// src/core/i18n/language-instructions.ts
+var SUPPORTED_LOCALES = ["en", "es"];
+var LANGUAGE_INSTRUCTIONS = {
+  en: 'Prose/docs/code comments: be terse and direct. Prefer concrete nouns over abstract ones. Omit filler phrases ("note that", "please", "as mentioned"). One idea per sentence.',
+  es: "Spanish prose/docs/reports/Markdown: preserve natural Spanish orthography, including accents, `ñ`, `¿`, `¡`, and normal Unicode. The ASCII-only editing preference does not apply to these artifacts."
 };
+var COMMIT_STYLE = {
+  en: `---
+trigger: always_on
+description: Rules for generating commit messages using Conventional Commits format
+---
 
-// src/core/config/config-writer.ts
-var CONFIG_DIR = ".codeconductor";
-var CONFIG_FILE2 = "config.yml";
-async function writeConfig(projectRoot, config = {}, force = false) {
-  try {
-    const configDir = resolve3(projectRoot, CONFIG_DIR);
-    await mkdir(configDir, { recursive: true });
-    const configPath = resolve3(configDir, CONFIG_FILE2);
-    if (!force) {
-      try {
-        await access2(configPath);
-        return ok(undefined);
-      } catch {}
-    }
-    const mergedConfig = {
-      ...DEFAULT_CONFIG,
-      ...config,
-      project: {
-        ...DEFAULT_CONFIG.project,
-        ...config.project
-      },
-      defaults: {
-        ...DEFAULT_CONFIG.defaults,
-        ...config.defaults
-      },
-      presets: {
-        ...DEFAULT_CONFIG.presets,
-        ...config.presets
-      },
-      safety: {
-        ...DEFAULT_CONFIG.safety,
-        ...config.safety
-      }
-    };
-    const yamlContent = $stringify(mergedConfig);
-    await writeFile(configPath, yamlContent, "utf-8");
-    return ok(undefined);
-  } catch (error) {
-    return err(new ValidationError("Failed to write config", error));
-  }
-}
+## Git Commit Messages
 
-// src/core/presets/preset-resolver.ts
-var CURRENT_PRESET_VERSION = "v0.3.0";
-function resolvePreset(target, profile) {
-  const stack = resolveStack(profile);
-  const isMonorepo = profile.signals.some((s) => [
-    "pnpm-workspace.yaml",
-    "lerna.json",
-    "go.work",
-    "package.json-workspaces",
-    "Cargo.toml-workspace"
-  ].includes(s));
-  const architecture = isMonorepo ? "monorepo" : profile.signals.length > 0 ? "single-project" : "unknown";
-  const warnings = [];
-  if (profile.confidence === "low") {
-    warnings.push("Detection confidence is low; review the selected preset before applying it.");
-  }
-  if (stack === "unknown") {
-    warnings.push("No supported stack was detected; using the generic CodeConductor workflow preset.");
-  } else {
-    warnings.push(`${stack} projects currently receive the generic ${target} workflow plus matching skills; stack-specific asset pruning is not implemented yet.`);
-  }
-  if (architecture === "unknown") {
-    warnings.push("Project architecture could not be inferred from available signals.");
-  }
-  return {
-    target,
-    stack,
-    architecture,
-    confidence: profile.confidence,
-    presetVersion: CURRENT_PRESET_VERSION,
-    assets: resolveAssets(target),
-    warnings
-  };
-}
-function resolveStack(profile) {
-  if (profile.frameworks.includes("spring"))
-    return "spring";
-  if (profile.frameworks.includes("django"))
-    return "django";
-  if (profile.frameworks.includes("astro"))
-    return "astro";
-  if (profile.frameworks.includes("nextjs"))
-    return "nextjs";
-  if (profile.frameworks.includes("fastapi"))
-    return "fastapi";
-  if (profile.frameworks.includes("backend"))
-    return "backend";
-  if (profile.frameworks.includes("frontend"))
-    return "frontend";
-  if (profile.frameworks.includes("android"))
-    return "android";
-  if (profile.frameworks.includes("laravel"))
-    return "laravel";
-  if (profile.runtimes.includes("php"))
-    return "php";
-  if (profile.runtimes.includes("bun"))
+### Format
+
+\`\`\`
+<type>(<scope>): <short description>
+
+- <detail 1>
+- <detail 2>
+\`\`\`
+
+### Valid Types
+
+\`feat\` \`fix\` \`docs\` \`style\` \`refactor\` \`test\` \`chore\` \`perf\` \`ci\` \`build\`
+\`revert\`
+
+### Rules
+
+- Language: **neutral English** always
+- Header: maximum 69 characters, no trailing period
+- Body: concise bullet points, one idea per line
+- Footer: only for breaking changes or issues
+- No gerunds ("adding", "fixing")
+- Use infinitive or imperative ("add", "fix", "update")`,
+  es: `---
+trigger: always_on
+description: Reglas para generar mensajes de commit con formato Conventional Commits
+---
+
+## Git Commit Messages
+
+### Formato
+
+\`\`\`
+<tipo>(<scope>): <descripcion corta>
+
+- <detalle 1>
+- <detalle 2>
+\`\`\`
+
+### Tipos validos
+
+\`feat\` \`fix\` \`docs\` \`style\` \`refactor\` \`test\` \`chore\` \`perf\` \`ci\` \`build\`
+\`revert\`
+
+### Reglas
+
+- Idioma: **inglés neutro** siempre
+- Encabezado: maximo 69 caracteres, sin punto final
+- Cuerpo: viñetas concisas, una idea por linea
+- Footer: solo para breaking changes o issues
+- Sin gerundios ("agregando", "corrigiendo")
+- Usar infinitivo o imperativo ("agregar", "corregir", "actualizar")`
+};
+var COMMIT_WORKFLOW = {
+  en: `---
+name: commit
+description: Generates a commit in English following Conventional Commits based on staged changes
+---
+
+// turbo-all
+
+## Steps
+
+1. View staged changes: \`git diff --cached --stat\`
+2. If nothing is staged, suggest \`git add .\` or specific files
+3. Get full diff: \`git diff --cached\`
+4. Check recent style: \`git log -n 3 --oneline\`
+5. Generate message following \`.agents/rules/commit-style.md\`
+6. Show proposal and confirm with the user
+7. Execute: \`git commit -m "<message>"\`
+8. Confirm success: \`git status\``,
+  es: `---
+name: commit
+description: Genera un commit en inglés siguiendo Conventional Commits basado en los cambios staged
+---
+
+// turbo-all
+
+## Pasos
+
+1. Ver cambios staged: \`git diff --cached --stat\`
+2. Si no hay nada staged, sugiere \`git add .\` o archivos específicos
+3. Obtener diff completo: \`git diff --cached\`
+4. Ver estilo reciente: \`git log -n 3 --oneline\`
+5. Generar mensaje siguiendo \`.agents/rules/commit-style.md\`
+6. Mostrar propuesta y confirmar con el usuario
+7. Ejecutar: \`git commit -m "<mensaje>"\`
+8. Confirmar éxito: \`git status\``
+};
+function getLanguageInstruction(locale) {
+  const key = SUPPORTED_LOCALES.includes(locale) ? locale : "en";
+  return `- ${LANGUAGE_INSTRUCTIONS[key]}`;
+}
+var LOCALE_PLACEHOLDER = "{{LANGUAGE_INSTRUCTIONS}}";
+
+// src/core/filesystem/safe-merger.ts
+var MANAGED_BEGIN_MARKER = "<!-- CODECONDUCTOR:BEGIN managed -->";
+var MANAGED_END_MARKER = "<!-- CODECONDUCTOR:END managed -->";
+function mergeManagedBlock(existing, incoming) {
+  validateMarkers(incoming, "incoming content");
+  if (!existing) {
+    return { content: incoming, action: "written" };
+  }
+  const hasBegin = existing.includes(MANAGED_BEGIN_MARKER);
+  const hasEnd = existing.includes(MANAGED_END_MARKER);
+  if (!hasBegin && !hasEnd) {
+    return { content: incoming, action: "written" };
+  }
+  validateMarkers(existing, "existing content");
+  const existingBlock = getManagedBlockRange(existing);
+  const incomingBlock = getManagedBlockRange(incoming);
+  return {
+    content: existing.slice(0, existingBlock.start) + incoming.slice(incomingBlock.start, incomingBlock.end) + existing.slice(existingBlock.end),
+    action: "merged"
+  };
+}
+function validateMarkers(content, label) {
+  const beginCount = countOccurrences(content, MANAGED_BEGIN_MARKER);
+  const endCount = countOccurrences(content, MANAGED_END_MARKER);
+  if (beginCount !== 1 || endCount !== 1) {
+    throw new Error(`${label} must contain exactly one managed begin marker and one managed end marker`);
+  }
+  if (content.indexOf(MANAGED_BEGIN_MARKER) > content.indexOf(MANAGED_END_MARKER)) {
+    throw new Error(`${label} has managed markers in the wrong order`);
+  }
+}
+function getManagedBlockRange(content) {
+  const start = content.indexOf(MANAGED_BEGIN_MARKER);
+  const end = content.indexOf(MANAGED_END_MARKER) + MANAGED_END_MARKER.length;
+  return { start, end };
+}
+function countOccurrences(content, needle) {
+  return content.split(needle).length - 1;
+}
+
+// src/core/presets/file-copier.ts
+async function listFilesRecursive(dir, base = dir) {
+  const entries = await readdir(dir, { withFileTypes: true });
+  const files = [];
+  for (const entry of entries) {
+    const full = join2(dir, entry.name);
+    if (entry.isDirectory()) {
+      files.push(...await listFilesRecursive(full, base));
+    } else {
+      files.push(relative(base, full));
+    }
+  }
+  return files;
+}
+async function resolveEntryFiles(entry, presetsDir, baseDir) {
+  const srcAbsolute = resolve3(presetsDir, entry.src);
+  try {
+    const s = await stat(srcAbsolute);
+    if (s.isDirectory()) {
+      const files = await listFilesRecursive(srcAbsolute);
+      return files.map((f) => ({
+        src: join2(srcAbsolute, f),
+        dest: resolve3(baseDir, entry.dest, f)
+      }));
+    }
+    return [{ src: srcAbsolute, dest: resolve3(baseDir, entry.dest) }];
+  } catch {
+    return [];
+  }
+}
+function mergeDeep(target, source) {
+  const result = { ...target };
+  for (const key of Object.keys(source)) {
+    const srcVal = source[key];
+    const tgtVal = target[key];
+    if (Array.isArray(srcVal) && Array.isArray(tgtVal)) {
+      result[key] = [...new Set([...tgtVal, ...srcVal])];
+    } else if (srcVal && typeof srcVal === "object" && !Array.isArray(srcVal) && tgtVal && typeof tgtVal === "object" && !Array.isArray(tgtVal)) {
+      result[key] = mergeDeep(tgtVal, srcVal);
+    } else {
+      result[key] = srcVal;
+    }
+  }
+  return result;
+}
+function extractAgentRole(filePath) {
+  const parts = filePath.replace(/\\/g, "/").split("/");
+  const basename = parts[parts.length - 1];
+  const name = basename.replace(/\.md$/, "");
+  const knownRoles = [
+    "architect",
+    "implementer",
+    "tester",
+    "orchestrator",
+    "reviewer",
+    "docs",
+    "task-coach",
+    "repo-explorer"
+  ];
+  return knownRoles.includes(name) ? name : null;
+}
+function renderTemplate(content, modelConfig, filePath, locale = "en") {
+  const cleanLocale = locale === "es" || locale === "en" ? locale : "en";
+  const templatedContent = content.replace(/\{\{COMMIT_STYLE\}\}/g, COMMIT_STYLE[cleanLocale]).replace(/\{\{COMMIT_WORKFLOW\}\}/g, COMMIT_WORKFLOW[cleanLocale]);
+  const agentRole = extractAgentRole(filePath);
+  if (agentRole && modelConfig.agents[agentRole]) {
+    const agentModels = modelConfig.agents[agentRole];
+    const targetModel = agentModels[modelConfig.target];
+    let result2 = templatedContent.replace(/\{\{MODEL\}\}/g, targetModel ?? "").replace(/\{\{MODEL_CLAUDE\}\}/g, agentModels.claude ?? "").replace(/\{\{MODEL_OPENCODE\}\}/g, agentModels.opencode ?? "").replace(/\{\{MODEL_CODEX\}\}/g, agentModels.codex ?? "").replace(/\{\{MODEL_GEMINI\}\}/g, agentModels.gemini ?? "").replace(/\{\{MODEL_CURSOR\}\}/g, agentModels.cursor ?? "").replace(new RegExp(LOCALE_PLACEHOLDER.replace(/[{}]/g, "\\$&"), "g"), getLanguageInstruction(locale));
+    if (modelConfig.tools || modelConfig.permissions) {
+      result2 = substituteToolNames(result2, modelConfig);
+    }
+    return result2;
+  }
+  const knownRoles = [
+    "orchestrator",
+    "task-coach",
+    "architect",
+    "implementer",
+    "tester",
+    "reviewer",
+    "docs",
+    "repo-explorer"
+  ];
+  let result = templatedContent;
+  for (const role of knownRoles) {
+    if (!modelConfig.agents[role])
+      continue;
+    const agentModels = modelConfig.agents[role];
+    const sectionRegex = new RegExp(`(### ${role}[\\s\\S]*?)(?=### |## |$)`, "gi");
+    const sectionMatch = result.match(sectionRegex);
+    if (sectionMatch) {
+      for (const section of sectionMatch) {
+        const renderedSection = section.replace(/\{\{MODEL_CLAUDE\}\}/g, agentModels.claude ?? "").replace(/\{\{MODEL_OPENCODE\}\}/g, agentModels.opencode ?? "").replace(/\{\{MODEL_CODEX\}\}/g, agentModels.codex ?? "").replace(/\{\{MODEL_GEMINI\}\}/g, agentModels.gemini ?? "").replace(/\{\{MODEL_CURSOR\}\}/g, agentModels.cursor ?? "");
+        result = result.replace(section, renderedSection);
+      }
+    }
+  }
+  result = result.replace(new RegExp(LOCALE_PLACEHOLDER.replace(/[{}]/g, "\\$&"), "g"), getLanguageInstruction(locale));
+  if (modelConfig.tools || modelConfig.permissions) {
+    result = substituteToolNames(result, modelConfig);
+  }
+  return result;
+}
+function substituteToolNames(content, modelConfig) {
+  if (!modelConfig.tools && !modelConfig.permissions)
+    return content;
+  const target = modelConfig.target;
+  const fmMatch = content.match(/^---\r?\n([\s\S]*?)\r?\n---/);
+  if (!fmMatch)
+    return content;
+  const frontmatter = fmMatch[1];
+  if (target === "opencode" && modelConfig.permissions) {
+    const updatedFrontmatter2 = frontmatter.replace(/^tools:\s*(.+)\r?\n?/m, "");
+    return content.replace(fmMatch[0], `---
+${updatedFrontmatter2}
+---`);
+  }
+  if (!modelConfig.tools)
+    return content;
+  const updatedFrontmatter = frontmatter.replace(/^tools:\s*(.+)$/m, (_match, toolsLine) => {
+    const baseNames = toolsLine.split(",").map((t) => t.trim());
+    const mappedNames = baseNames.map((baseName) => {
+      const toolMapping = modelConfig.tools?.[baseName];
+      if (toolMapping && toolMapping[target]) {
+        return toolMapping[target];
+      }
+      return baseName;
+    });
+    return `tools: ${mappedNames.join(", ")}`;
+  });
+  return content.replace(fmMatch[0], `---
+${updatedFrontmatter}
+---`);
+}
+async function applySingleFile(srcPath, destPath, strategy, force, dryRun, isTemplate, modelConfig, locale) {
+  if (strategy === "skip") {
+    return { src: srcPath, dest: destPath, action: "skipped", dryRun };
+  }
+  let content;
+  try {
+    content = await readFile4(srcPath, "utf-8");
+  } catch (e) {
+    return { src: srcPath, dest: destPath, action: "error", error: `Cannot read source: ${e}` };
+  }
+  const incomingContent = isTemplate && modelConfig ? renderTemplate(content, modelConfig, srcPath, locale) : content;
+  let finalContent = incomingContent;
+  let action = "written";
+  if (strategy === "append") {
+    let existing = "";
+    try {
+      existing = await readFile4(destPath, "utf-8");
+    } catch {}
+    if (existing) {
+      finalContent = existing + `
+
+---
+
+` + incomingContent;
+    }
+    action = "appended";
+  } else if (strategy === "merge-json") {
+    let existing = {};
+    try {
+      existing = JSON.parse(await readFile4(destPath, "utf-8"));
+    } catch {}
+    try {
+      const incoming = JSON.parse(incomingContent);
+      finalContent = JSON.stringify(mergeDeep(existing, incoming), null, 2);
+    } catch (e) {
+      return { src: srcPath, dest: destPath, action: "error", error: `JSON merge failed: ${e}` };
+    }
+    action = "merged";
+  } else if (strategy === "merge-managed") {
+    let existing = null;
+    try {
+      existing = await readFile4(destPath, "utf-8");
+    } catch {}
+    try {
+      const merged = mergeManagedBlock(existing, incomingContent);
+      finalContent = merged.content;
+      action = merged.action;
+    } catch (e) {
+      return { src: srcPath, dest: destPath, action: "error", error: `Managed merge failed: ${e}` };
+    }
+  }
+  if (dryRun) {
+    return { src: srcPath, dest: destPath, action, dryRun: true };
+  }
+  try {
+    await mkdir(dirname2(destPath), { recursive: true });
+    await writeFile(destPath, finalContent, "utf-8");
+    return { src: srcPath, dest: destPath, action };
+  } catch (e) {
+    return { src: srcPath, dest: destPath, action: "error", error: String(e) };
+  }
+}
+async function copyFromManifest(manifest, presetsDir, baseDir, isGlobal, dryRun, force, modelConfig = null, locale = "en") {
+  const results = [];
+  for (const entry of manifest.entries) {
+    const strategy = isGlobal && entry.globalStrategy ? entry.globalStrategy : entry.strategy;
+    let resolvedBaseDir = baseDir;
+    let resolvedEntry = entry;
+    if (manifest.target === "agy" && isGlobal) {
+      resolvedBaseDir = join2(homedir(), ".gemini", "config");
+      resolvedEntry = {
+        ...entry,
+        dest: entry.dest.replace(/^\.agents\/?/, "")
+      };
+    }
+    const files = await resolveEntryFiles(resolvedEntry, presetsDir, resolvedBaseDir);
+    const isTemplate = entry.template === true;
+    for (const { src, dest } of files) {
+      results.push(await applySingleFile(src, dest, strategy, force, dryRun, isTemplate, modelConfig, locale));
+    }
+  }
+  return results;
+}
+
+// src/core/presets/update-checker.ts
+function getTargetInstallationPath(target, basePath, isGlobal) {
+  if (target === "agy") {
+    return isGlobal ? resolve4(basePath, ".gemini", "config") : resolve4(basePath, ".agents");
+  }
+  return resolve4(basePath, `.${target}`);
+}
+async function isTargetInstalled(target, basePath, isGlobal) {
+  const path = getTargetInstallationPath(target, basePath, isGlobal);
+  try {
+    const s = await stat2(path);
+    return s.isDirectory();
+  } catch {
+    return false;
+  }
+}
+async function validateAgentFileSizes(basePath, isGlobal) {
+  const filesToCheck = [];
+  filesToCheck.push(resolve4(basePath, ".claude", "CLAUDE.md"));
+  filesToCheck.push(resolve4(basePath, ".codex", "AGENTS.md"));
+  if (isGlobal) {
+    filesToCheck.push(resolve4(basePath, ".gemini", "config", "AGENTS.md"));
+  } else {
+    filesToCheck.push(resolve4(basePath, ".agents", "AGENTS.md"));
+  }
+  const largeFiles = [];
+  for (const filePath of filesToCheck) {
+    try {
+      const s = await stat2(filePath);
+      if (s.isFile() && s.size > 40 * 1024) {
+        largeFiles.push({ path: filePath, size: s.size });
+      }
+    } catch {}
+  }
+  return largeFiles;
+}
+async function validateAgentMarkers(basePath, isGlobal) {
+  const targetsToCheck = [
+    "opencode",
+    "claude",
+    "codex",
+    "gemini",
+    "cursor",
+    "agy"
+  ];
+  const results = [];
+  for (const target of targetsToCheck) {
+    const isInstalled = await isTargetInstalled(target, basePath, isGlobal);
+    if (!isInstalled) {
+      continue;
+    }
+    let manifest;
+    try {
+      manifest = await loadManifest(target);
+    } catch {
+      continue;
+    }
+    for (const entry of manifest.entries) {
+      const strategy = isGlobal && entry.globalStrategy ? entry.globalStrategy : entry.strategy;
+      if (strategy !== "merge-managed") {
+        continue;
+      }
+      let resolvedEntry = entry;
+      let targetBaseDir = basePath;
+      if (target === "agy" && isGlobal) {
+        targetBaseDir = join3(homedir2(), ".gemini", "config");
+        resolvedEntry = {
+          ...entry,
+          dest: entry.dest.replace(/^\.agents\/?/, "")
+        };
+      }
+      const files = await resolveEntryFiles(resolvedEntry, PRESETS_DIR, targetBaseDir);
+      for (const { dest } of files) {
+        try {
+          const content = await readFile5(dest, "utf-8");
+          const beginCount = content.split(MANAGED_BEGIN_MARKER).length - 1;
+          const endCount = content.split(MANAGED_END_MARKER).length - 1;
+          if (beginCount === 0 && endCount === 0) {
+            results.push({ path: dest, error: "Missing managed markers" });
+          } else if (beginCount !== 1 || endCount !== 1) {
+            results.push({
+              path: dest,
+              error: "Must contain exactly one managed begin marker and one managed end marker"
+            });
+          } else if (content.indexOf(MANAGED_BEGIN_MARKER) > content.indexOf(MANAGED_END_MARKER)) {
+            results.push({
+              path: dest,
+              error: "Managed markers are in the wrong order"
+            });
+          }
+        } catch {}
+      }
+    }
+  }
+  return results;
+}
+async function fileContentDiffers(pathA, pathB) {
+  try {
+    const contentA = await readFile5(pathA, "utf-8");
+    const contentB = await readFile5(pathB, "utf-8");
+    return contentA.trim() !== contentB.trim();
+  } catch {
+    try {
+      await stat2(pathB);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+}
+async function loadSkillsLock(basePath) {
+  const paths = [
+    resolve4(basePath, ".codeconductor", "skills-lock.json"),
+    resolve4(basePath, ".agents", "skills-lock.json")
+  ];
+  for (const p of paths) {
+    try {
+      const content = await readFile5(p, "utf-8");
+      return JSON.parse(content);
+    } catch {}
+  }
+  return null;
+}
+async function getLatestSkillVersion(skillId) {
+  const targets = [
+    "opencode",
+    "agy",
+    "claude",
+    "codex",
+    "gemini",
+    "cursor"
+  ];
+  for (const target of targets) {
+    const skillPath = resolve4(ROOT_PRESETS_DIR, target, "skills", skillId, "SKILL.md");
+    try {
+      const content = await readFile5(skillPath, "utf-8");
+      const fmMatch = content.match(/^---\r?\n([\s\S]*?)\r?\n---/);
+      if (fmMatch) {
+        const parsed = $parse(fmMatch[1]);
+        if (parsed && parsed.id === skillId && parsed.version) {
+          return String(parsed.version);
+        }
+      }
+    } catch {}
+  }
+  return null;
+}
+async function checkUpdates(basePath, isGlobal) {
+  const localCouncil = resolve4(basePath, ".codeconductor", "presets", "council.yml");
+  const bundledCouncil = resolve4(SRC_PRESETS_DIR, "council", "council.yml");
+  const councilHasUpdate = await fileContentDiffers(localCouncil, bundledCouncil);
+  const localPolicy = resolve4(basePath, ".codeconductor", "presets", "policy.yml");
+  const policyHasUpdate = await fileContentDiffers(localPolicy, POLICY_PATH);
+  const targetsToCheck = [
+    "opencode",
+    "claude",
+    "codex",
+    "gemini",
+    "cursor",
+    "agy"
+  ];
+  const targetResults = [];
+  let locale = "en";
+  try {
+    const configResult = await loadConfig(basePath);
+    if (configResult.success) {
+      locale = configResult.data.defaults.locale ?? "en";
+    }
+  } catch {}
+  for (const target of targetsToCheck) {
+    const isInstalled = await isTargetInstalled(target, basePath, isGlobal);
+    if (!isInstalled) {
+      continue;
+    }
+    let manifest;
+    let modelConfig;
+    try {
+      manifest = await loadManifest(target);
+      modelConfig = await loadModelConfig(target);
+    } catch {
+      continue;
+    }
+    const changedFiles = [];
+    for (const entry of manifest.entries) {
+      const strategy = isGlobal && entry.globalStrategy ? entry.globalStrategy : entry.strategy;
+      if (strategy === "skip")
+        continue;
+      let resolvedEntry = entry;
+      let targetBaseDir = basePath;
+      if (target === "agy" && isGlobal) {
+        targetBaseDir = join3(homedir2(), ".gemini", "config");
+        resolvedEntry = {
+          ...entry,
+          dest: entry.dest.replace(/^\.agents\/?/, "")
+        };
+      }
+      const files = await resolveEntryFiles(resolvedEntry, PRESETS_DIR, targetBaseDir);
+      const isTemplate = entry.template === true;
+      for (const { src, dest } of files) {
+        let expectedContent;
+        try {
+          const srcContent = await readFile5(src, "utf-8");
+          expectedContent = isTemplate && modelConfig ? renderTemplate(srcContent, modelConfig, src, locale) : srcContent;
+        } catch {
+          continue;
+        }
+        let destContent;
+        try {
+          destContent = await readFile5(dest, "utf-8");
+        } catch {
+          changedFiles.push(dest);
+          continue;
+        }
+        let fileHasUpdate = false;
+        if (strategy === "overwrite") {
+          if (destContent.trim() !== expectedContent.trim()) {
+            fileHasUpdate = true;
+          }
+        } else if (strategy === "append") {
+          if (!destContent.includes(expectedContent)) {
+            fileHasUpdate = true;
+          }
+        } else if (strategy === "merge-json") {
+          try {
+            const destJson = JSON.parse(destContent);
+            const expectedJson = JSON.parse(expectedContent);
+            const merged = mergeDeep(destJson, expectedJson);
+            if (JSON.stringify(merged) !== JSON.stringify(destJson)) {
+              fileHasUpdate = true;
+            }
+          } catch {
+            fileHasUpdate = true;
+          }
+        } else if (strategy === "merge-managed") {
+          try {
+            const merged = mergeManagedBlock(destContent, expectedContent);
+            if (merged.content.trim() !== destContent.trim()) {
+              fileHasUpdate = true;
+            }
+          } catch {
+            fileHasUpdate = true;
+          }
+        }
+        if (fileHasUpdate) {
+          changedFiles.push(dest);
+        }
+      }
+    }
+    targetResults.push({
+      target,
+      hasUpdate: changedFiles.length > 0,
+      files: changedFiles
+    });
+  }
+  const skillResults = [];
+  const skillsLock = await loadSkillsLock(basePath);
+  if (skillsLock) {
+    for (const [skillId, currentVersion] of Object.entries(skillsLock)) {
+      const latestVersion = await getLatestSkillVersion(skillId);
+      if (latestVersion && latestVersion !== currentVersion) {
+        skillResults.push({
+          id: skillId,
+          currentVersion,
+          latestVersion,
+          hasUpdate: true
+        });
+      } else {
+        skillResults.push({
+          id: skillId,
+          currentVersion,
+          latestVersion: latestVersion || currentVersion,
+          hasUpdate: false
+        });
+      }
+    }
+  }
+  const hasPresetUpdates = councilHasUpdate || policyHasUpdate;
+  const hasTargetUpdates = targetResults.some((t) => t.hasUpdate);
+  const hasSkillUpdates = skillResults.some((s) => s.hasUpdate);
+  return {
+    hasUpdates: hasPresetUpdates || hasTargetUpdates || hasSkillUpdates,
+    council: councilHasUpdate,
+    policy: policyHasUpdate,
+    targets: targetResults,
+    skills: skillResults
+  };
+}
+
+// src/commands/doctor.command.ts
+async function doctorCommand(options) {
+  const { projectRoot, output } = options;
+  const checks = [];
+  try {
+    const hasConfig = await configExists(projectRoot);
+    if (hasConfig) {
+      checks.push({
+        name: "config-exists",
+        status: "pass",
+        message: ".codeconductor/config.yml exists"
+      });
+    } else {
+      checks.push({
+        name: "config-exists",
+        status: "fail",
+        message: ".codeconductor/config.yml not found. Run `codeconductor init` first."
+      });
+      return {
+        code: 4,
+        data: {
+          success: false,
+          command: "doctor",
+          checks
+        }
+      };
+    }
+    const configResult = await loadConfig(projectRoot);
+    if (configResult.success) {
+      checks.push({
+        name: "config-valid",
+        status: "pass",
+        message: "Config is valid"
+      });
+    } else {
+      checks.push({
+        name: "config-valid",
+        status: "fail",
+        message: `Config validation failed: ${configResult.error.message}`
+      });
+      return {
+        code: 1,
+        data: {
+          success: false,
+          command: "doctor",
+          checks
+        }
+      };
+    }
+    const runnerDirs = [".opencode", ".claude", ".codex"];
+    for (const dir of runnerDirs) {
+      try {
+        const { access: access2 } = await import("node:fs/promises");
+        await access2(join4(projectRoot, dir));
+        checks.push({
+          name: `dir-${dir}`,
+          status: "pass",
+          message: `${dir}/ exists`
+        });
+      } catch {
+        checks.push({
+          name: `dir-${dir}`,
+          status: "warn",
+          message: `${dir}/ not found (optional)`
+        });
+      }
+    }
+    const config = configResult.data;
+    if (config.presets.council.enabled) {
+      checks.push({
+        name: "council-enabled",
+        status: "pass",
+        message: `Council preset enabled (v${config.presets.council.version})`
+      });
+    }
+    const localUpdates = await checkUpdates(projectRoot, false);
+    const globalUpdates = await checkUpdates(homedir3(), true);
+    const updateDetails = [];
+    if (localUpdates.hasUpdates) {
+      if (localUpdates.council)
+        updateDetails.push("local council preset");
+      if (localUpdates.policy)
+        updateDetails.push("local policy");
+      const updatedLocalTargets = localUpdates.targets.filter((t) => t.hasUpdate).map((t) => t.target);
+      if (updatedLocalTargets.length > 0) {
+        updateDetails.push(`local targets (${updatedLocalTargets.join(", ")})`);
+      }
+      const updatedLocalSkills = localUpdates.skills.filter((s) => s.hasUpdate).map((s) => s.id);
+      if (updatedLocalSkills.length > 0) {
+        updateDetails.push(`local skills (${updatedLocalSkills.join(", ")})`);
+      }
+    }
+    if (globalUpdates.hasUpdates) {
+      if (globalUpdates.council)
+        updateDetails.push("global council preset");
+      if (globalUpdates.policy)
+        updateDetails.push("global policy");
+      const updatedGlobalTargets = globalUpdates.targets.filter((t) => t.hasUpdate).map((t) => t.target);
+      if (updatedGlobalTargets.length > 0) {
+        updateDetails.push(`global targets (${updatedGlobalTargets.join(", ")})`);
+      }
+      const updatedGlobalSkills = globalUpdates.skills.filter((s) => s.hasUpdate).map((s) => s.id);
+      if (updatedGlobalSkills.length > 0) {
+        updateDetails.push(`global skills (${updatedGlobalSkills.join(", ")})`);
+      }
+    }
+    if (updateDetails.length > 0) {
+      checks.push({
+        name: "updates-available",
+        status: "warn",
+        message: `Updates available for: ${updateDetails.join(", ")}`
+      });
+    } else {
+      checks.push({
+        name: "updates-available",
+        status: "pass",
+        message: "All presets, targets, and skills are up to date"
+      });
+    }
+    const largeFilesLocal = await validateAgentFileSizes(projectRoot, false);
+    const largeFilesGlobal = await validateAgentFileSizes(homedir3(), true);
+    const allLargeFiles = [...largeFilesLocal, ...largeFilesGlobal];
+    if (allLargeFiles.length > 0) {
+      checks.push({
+        name: "agent-file-sizes",
+        status: "warn",
+        message: `The following files exceed 40KB: ${allLargeFiles.map((f) => f.path).join(", ")}`
+      });
+    } else {
+      checks.push({
+        name: "agent-file-sizes",
+        status: "pass",
+        message: "All agent files (AGENTS.md/CLAUDE.md) are under 40KB"
+      });
+    }
+    const missingMarkersLocal = await validateAgentMarkers(projectRoot, false);
+    const missingMarkersGlobal = await validateAgentMarkers(homedir3(), true);
+    const allMissingMarkers = [...missingMarkersLocal, ...missingMarkersGlobal];
+    if (allMissingMarkers.length > 0) {
+      checks.push({
+        name: "agent-file-markers",
+        status: "warn",
+        message: `The following files have missing or invalid managed markers: ${allMissingMarkers.map((f) => `${f.path} (${f.error})`).join(", ")}`
+      });
+    } else {
+      checks.push({
+        name: "agent-file-markers",
+        status: "pass",
+        message: "All agent files have valid managed markers"
+      });
+    }
+    const securityCompatibility = await loadTargetSecurityCompatibility();
+    for (const compatibility of securityCompatibility) {
+      checks.push({
+        name: `security-${compatibility.target}`,
+        status: compatibility.status,
+        message: compatibility.status === "pass" ? `${compatibility.target} can represent the canonical policy model` : `${compatibility.target} cannot enforce: ${compatibility.unsupportedRules.join(", ") || "see warnings"}`
+      });
+    }
+    const failedCount = checks.filter((c) => c.status === "fail").length;
+    if (failedCount > 0) {
+      return {
+        code: 4,
+        data: {
+          success: false,
+          command: "doctor",
+          checks
+        }
+      };
+    }
+    return {
+      code: 0,
+      data: {
+        success: true,
+        command: "doctor",
+        checks,
+        securityCompatibility
+      }
+    };
+  } catch (error) {
+    return {
+      code: 1,
+      data: {
+        success: false,
+        command: "doctor",
+        errors: [String(error)]
+      }
+    };
+  }
+}
+
+// src/commands/init.command.ts
+import { access as access3, mkdir as mkdir3, readFile as readFile6, writeFile as writeFile3 } from "node:fs/promises";
+import { homedir as homedir4 } from "node:os";
+import { basename, resolve as resolve6 } from "node:path";
+
+// src/core/config/config-writer.ts
+import { access as access2, mkdir as mkdir2, writeFile as writeFile2 } from "node:fs/promises";
+import { resolve as resolve5 } from "node:path";
+
+// src/core/config/codeconductor-config.ts
+var DEFAULT_CONFIG = {
+  version: "0.2.0",
+  project: {
+    name: "unnamed-project"
+  },
+  defaults: {
+    target: "opencode",
+    overwrite: false,
+    locale: "en"
+  },
+  presets: {
+    council: {
+      enabled: true,
+      version: "0.1.0"
+    }
+  },
+  safety: {
+    destructiveCommands: ["rm -rf", "drop table", "delete from"],
+    secretPatterns: ["password", "secret", "api_key", "token"]
+  }
+};
+
+// src/core/config/config-writer.ts
+var CONFIG_DIR = ".codeconductor";
+var CONFIG_FILE2 = "config.yml";
+async function writeConfig(projectRoot, config = {}, force = false) {
+  try {
+    const configDir = resolve5(projectRoot, CONFIG_DIR);
+    await mkdir2(configDir, { recursive: true });
+    const configPath = resolve5(configDir, CONFIG_FILE2);
+    if (!force) {
+      try {
+        await access2(configPath);
+        return ok(undefined);
+      } catch {}
+    }
+    const mergedConfig = {
+      ...DEFAULT_CONFIG,
+      ...config,
+      project: {
+        ...DEFAULT_CONFIG.project,
+        ...config.project
+      },
+      defaults: {
+        ...DEFAULT_CONFIG.defaults,
+        ...config.defaults
+      },
+      presets: {
+        ...DEFAULT_CONFIG.presets,
+        ...config.presets
+      },
+      safety: {
+        ...DEFAULT_CONFIG.safety,
+        ...config.safety
+      }
+    };
+    const yamlContent = $stringify(mergedConfig);
+    await writeFile2(configPath, yamlContent, "utf-8");
+    return ok(undefined);
+  } catch (error) {
+    return err(new ValidationError("Failed to write config", error));
+  }
+}
+
+// src/core/presets/preset-resolver.ts
+var CURRENT_PRESET_VERSION = "v0.3.0";
+function resolvePreset(target, profile) {
+  const stack = resolveStack(profile);
+  const isMonorepo = profile.signals.some((s) => [
+    "pnpm-workspace.yaml",
+    "lerna.json",
+    "go.work",
+    "package.json-workspaces",
+    "Cargo.toml-workspace"
+  ].includes(s));
+  const architecture = isMonorepo ? "monorepo" : profile.signals.length > 0 ? "single-project" : "unknown";
+  const warnings = [];
+  if (profile.confidence === "low") {
+    warnings.push("Detection confidence is low; review the selected preset before applying it.");
+  }
+  if (stack === "unknown") {
+    warnings.push("No supported stack was detected; using the generic CodeConductor workflow preset.");
+  } else {
+    warnings.push(`${stack} projects currently receive the generic ${target} workflow plus matching skills; stack-specific asset pruning is not implemented yet.`);
+  }
+  if (architecture === "unknown") {
+    warnings.push("Project architecture could not be inferred from available signals.");
+  }
+  return {
+    target,
+    stack,
+    architecture,
+    confidence: profile.confidence,
+    presetVersion: CURRENT_PRESET_VERSION,
+    assets: resolveAssets(target),
+    warnings
+  };
+}
+function resolveStack(profile) {
+  if (profile.frameworks.includes("spring"))
+    return "spring";
+  if (profile.frameworks.includes("django"))
+    return "django";
+  if (profile.frameworks.includes("astro"))
+    return "astro";
+  if (profile.frameworks.includes("nextjs"))
+    return "nextjs";
+  if (profile.frameworks.includes("fastapi"))
+    return "fastapi";
+  if (profile.frameworks.includes("backend"))
+    return "backend";
+  if (profile.frameworks.includes("frontend"))
+    return "frontend";
+  if (profile.frameworks.includes("android"))
+    return "android";
+  if (profile.frameworks.includes("laravel"))
+    return "laravel";
+  if (profile.runtimes.includes("php"))
+    return "php";
+  if (profile.runtimes.includes("bun"))
     return "bun";
   if (profile.runtimes.includes("node"))
     return "node";
@@ -11991,7 +12752,7 @@ function resolveAssets(target) {
 // src/commands/init.command.ts
 async function initCommand(options) {
   const { projectRoot, dryRun, force, global: isGlobal, output, locale } = options;
-  const baseDir = isGlobal ? homedir() : projectRoot;
+  const baseDir = isGlobal ? homedir4() : projectRoot;
   try {
     let profile = null;
     if (!isGlobal) {
@@ -12098,7 +12859,7 @@ async function initCommand(options) {
 }
 async function resolvePresetsToCopy() {
   const sources = [];
-  const bundledCouncil = resolve4(SRC_PRESETS_DIR, "council", "council.yml");
+  const bundledCouncil = resolve6(SRC_PRESETS_DIR, "council", "council.yml");
   if (await fileExists2(bundledCouncil)) {
     sources.push({ name: "council.yml", sourcePath: bundledCouncil });
   }
@@ -12109,17 +12870,17 @@ async function resolvePresetsToCopy() {
   return sources;
 }
 async function copyPresets(baseDir, presets, force) {
-  const presetsDir = resolve4(baseDir, ".codeconductor", "presets");
-  await mkdir2(presetsDir, { recursive: true });
+  const presetsDir = resolve6(baseDir, ".codeconductor", "presets");
+  await mkdir3(presetsDir, { recursive: true });
   const copied = [];
   for (const preset of presets) {
-    const destPath = resolve4(presetsDir, preset.name);
+    const destPath = resolve6(presetsDir, preset.name);
     if (!force && await fileExists2(destPath)) {
       continue;
     }
     try {
-      const content = await readFile3(preset.sourcePath, "utf-8");
-      await writeFile2(destPath, content, "utf-8");
+      const content = await readFile6(preset.sourcePath, "utf-8");
+      await writeFile3(destPath, content, "utf-8");
       copied.push(`.codeconductor/presets/${preset.name}`);
     } catch (err2) {
       const code = err2.code;
@@ -12141,8 +12902,8 @@ async function fileExists2(path) {
 }
 
 // src/commands/install.command.ts
-import { homedir as homedir3 } from "node:os";
-import { resolve as resolve7 } from "node:path";
+import { homedir as homedir5 } from "node:os";
+import { resolve as resolve8 } from "node:path";
 
 // src/domain/council/council-agent.ts
 function getResponsibilities(agentId) {
@@ -12200,281 +12961,63 @@ function generateAgentContent(agent) {
 ## Role
 ${agent.role}
 
-## Context
-${agent.context === "repo-readonly" ? "Can read repository but cannot modify files" : "Only receives prompts, no direct repository access"}
-
-## Model Hint
-${agent.modelHint}
-
-## Focus Areas
-${agent.focus.map((f) => `- ${f}`).join(`
-`)}
-
-## Responsibilities
-${getResponsibilities(agent.id)}
-`;
-}
-
-// src/adapters/claude/claude-council-generator.ts
-function generateClaudeFiles(spec) {
-  const files = [];
-  files.push({
-    path: ".claude/skills/council/SKILL.md",
-    content: generateCouncilSkill(spec),
-    overwrite: false
-  });
-  for (const agent of spec.agents) {
-    files.push({
-      path: `.claude/agents/council-${agent.id}.md`,
-      content: generateAgentContent(agent),
-      overwrite: false
-    });
-  }
-  return files;
-}
-function generateCouncilSkill(spec) {
-  return `# Council Skill
-
-## Description
-${spec.description}
-
-## Version
-${spec.version}
-
-## Agents
-${spec.agents.map((a) => `- **${a.role}** (${a.id}): ${a.focus.join(", ")}`).join(`
-`)}
-
-## Usage
-Use the council agents to get multi-perspective analysis on code changes, architecture decisions, and security reviews.
-
-## Context
-${spec.outputContract}
-`;
-}
-
-// src/adapters/claude/claude-installer.ts
-class ClaudeInstaller {
-  name = "claude";
-  target = "claude";
-  spec = null;
-  setSpec(spec) {
-    this.spec = spec;
-  }
-  async generate() {
-    if (!this.spec) {
-      throw new Error("Council spec not set");
-    }
-    return generateClaudeFiles(this.spec);
-  }
-  async isAvailable() {
-    return true;
-  }
-}
-function createClaudeInstaller(spec) {
-  const installer = new ClaudeInstaller;
-  installer.setSpec(spec);
-  return installer;
-}
-
-// src/adapters/codex/codex-council-generator.ts
-function generateCodexFiles(spec) {
-  const files = [];
-  files.push({
-    path: ".codex/config.toml",
-    content: generateCodexConfig(spec),
-    overwrite: false
-  });
-  for (const agent of spec.agents) {
-    files.push({
-      path: `.codex/agents/council_${agent.id}.toml`,
-      content: generateCodexAgent(agent),
-      overwrite: true
-    });
-  }
-  files.push({
-    path: ".codex/skills/council/SKILL.md",
-    content: generateCodexSkill(spec),
-    overwrite: true
-  });
-  return files;
-}
-function generateCodexConfig(spec) {
-  const agentTables = spec.agents.map((agent) => {
-    const focusAreas = agent.focus.join(", ");
-    return `
-[agents.${agent.id}]
-description = "${agent.role} council agent. Focus: ${focusAreas}. Context: ${agent.context}. Model hint: ${agent.modelHint}."
-nickname_candidates = ["${agent.role}", "Council ${agent.role}"]`;
-  }).join(`
-`);
-  return `# Codex Council Configuration
-
-[project]
-name = "council"
-version = "${spec.version}"
-${agentTables}
-`;
-}
-function generateCodexAgent(agent) {
-  const focusAreas = agent.focus.join(", ");
-  return `name = "${agent.role}"
-description = "${agent.role} council agent. Focus: ${focusAreas}. Context: ${agent.context}. Model hint: ${agent.modelHint}."
-nickname_candidates = ["${agent.role}", "Council ${agent.role}"]
-developer_instructions = "You are the ${agent.role} council agent. Your focus areas are: ${focusAreas}. Context: ${agent.context}. Apply ${agent.modelHint} reasoning to your analysis."
-`;
-}
-function generateCodexSkill(spec) {
-  return `---
-name: council
-description: ${spec.description}
-version: ${spec.version}
----
-
-## Agents
-${spec.agents.map((a) => `- **${a.role}** (${a.id}): ${a.focus.join(", ")}`).join(`
-`)}
-
-## Usage
-Use the council agents to get multi-perspective analysis on code changes, architecture decisions, and security reviews.
-`;
-}
-
-// src/adapters/codex/codex-installer.ts
-class CodexInstaller {
-  name = "codex";
-  target = "codex";
-  spec = null;
-  setSpec(spec) {
-    this.spec = spec;
-  }
-  async generate() {
-    if (!this.spec) {
-      throw new Error("Council spec not set");
-    }
-    return generateCodexFiles(this.spec);
-  }
-  async isAvailable() {
-    return true;
-  }
-}
-function createCodexInstaller(spec) {
-  const installer = new CodexInstaller;
-  installer.setSpec(spec);
-  return installer;
-}
-
-// src/adapters/opencode/opencode-council-generator.ts
-function generateOpenCodeFiles(spec) {
-  const files = [];
-  files.push({
-    path: ".opencode/commands/cc-council.md",
-    content: generateCouncilCommand(spec),
-    overwrite: false
-  });
-  files.push({
-    path: ".opencode/agents/council-lead.md",
-    content: generateCouncilLead(spec),
-    overwrite: false
-  });
-  for (const agent of spec.agents) {
-    files.push({
-      path: `.opencode/agents/council-${agent.id}.md`,
-      content: generateOpenCodeAgentContent(agent),
-      overwrite: false
-    });
-  }
-  return files;
-}
-function generateCouncilCommand(spec) {
-  return `---
-description: ${yamlString(spec.description)}
-agent: council-lead
-subtask: true
----
-
-Run the CodeConductor council for multi-perspective analysis.
-
-## Version
-${spec.version}
-
-## Agents
-${spec.agents.map((a) => `- ${a.role} (${a.id})`).join(`
-`)}
-
-## Instructions
-Coordinate with the council agents and synthesize their perspectives into the configured output contract.
-`;
-}
-function generateCouncilLead(spec) {
-  return `---
-description: ${yamlString(`${spec.description} Council lead. Coordinates council members and synthesizes recommendations.`)}
-mode: subagent
-permission:
-  read: allow
-  edit: deny
-  bash: deny
-  glob: allow
-  grep: allow
-  webfetch: deny
-  websearch: deny
----
-
-# Council Lead Agent
-
-## Role
-Coordinates the council and synthesizes perspectives
+## Context
+${agent.context === "repo-readonly" ? "Can read repository but cannot modify files" : "Only receives prompts, no direct repository access"}
 
-## Version
-${spec.version}
+## Model Hint
+${agent.modelHint}
 
-## Council Members
-${spec.agents.map((a) => `- ${a.role}: ${a.focus.join(", ")}`).join(`
+## Focus Areas
+${agent.focus.map((f) => `- ${f}`).join(`
 `)}
 
 ## Responsibilities
-- Coordinate agent responses
-- Synthesize different perspectives
-- Identify consensus and disagreements
-- Provide final recommendation
+${getResponsibilities(agent.id)}
 `;
 }
-function generateOpenCodeAgentContent(agent) {
-  return `---
-description: ${yamlString(`${agent.role} council agent. Focus: ${agent.focus.join(", ")}. Context: ${agent.context}. Model hint: ${agent.modelHint}.`)}
-mode: subagent
-permission:
-${generatePermissionBlock(agent.context)}
----
 
-${generateAgentContent(agent)}`;
-}
-function generatePermissionBlock(context) {
-  if (context === "repo-readonly") {
-    return `  read: allow
-  edit: deny
-  bash: deny
-  glob: allow
-  grep: allow
-  webfetch: deny
-  websearch: deny`;
+// src/adapters/claude/claude-council-generator.ts
+function generateClaudeFiles(spec) {
+  const files = [];
+  files.push({
+    path: ".claude/skills/council/SKILL.md",
+    content: generateCouncilSkill(spec),
+    overwrite: false
+  });
+  for (const agent of spec.agents) {
+    files.push({
+      path: `.claude/agents/council-${agent.id}.md`,
+      content: generateAgentContent(agent),
+      overwrite: false
+    });
   }
-  return `  read: deny
-  edit: deny
-  bash: deny
-  glob: deny
-  grep: deny
-  webfetch: deny
-  websearch: deny`;
+  return files;
 }
-function yamlString(value) {
-  return JSON.stringify(value);
+function generateCouncilSkill(spec) {
+  return `# Council Skill
+
+## Description
+${spec.description}
+
+## Version
+${spec.version}
+
+## Agents
+${spec.agents.map((a) => `- **${a.role}** (${a.id}): ${a.focus.join(", ")}`).join(`
+`)}
+
+## Usage
+Use the council agents to get multi-perspective analysis on code changes, architecture decisions, and security reviews.
+
+## Context
+${spec.outputContract}
+`;
 }
 
-// src/adapters/opencode/opencode-installer.ts
-class OpenCodeInstaller {
-  name = "opencode";
-  target = "opencode";
+// src/adapters/claude/claude-installer.ts
+class ClaudeInstaller {
+  name = "claude";
+  target = "claude";
   spec = null;
   setSpec(spec) {
     this.spec = spec;
@@ -12483,467 +13026,299 @@ class OpenCodeInstaller {
     if (!this.spec) {
       throw new Error("Council spec not set");
     }
-    return generateOpenCodeFiles(this.spec);
+    return generateClaudeFiles(this.spec);
   }
   async isAvailable() {
     return true;
   }
 }
-function createOpenCodeInstaller(spec) {
-  const installer = new OpenCodeInstaller;
+function createClaudeInstaller(spec) {
+  const installer = new ClaudeInstaller;
   installer.setSpec(spec);
   return installer;
 }
 
-// src/core/filesystem/file-writer.ts
-import { access as access4, mkdir as mkdir3, writeFile as writeFile3 } from "node:fs/promises";
-import { dirname as dirname2 } from "node:path";
-init_safety();
-async function writeGeneratedFiles(files, options) {
-  const results = [];
-  for (const file of files) {
-    if (!validateWritePath(file.path)) {
-      results.push({
-        path: file.path,
-        success: false,
-        error: "Protected path"
-      });
-      continue;
-    }
-    if (options.dryRun) {
-      results.push({
-        path: file.path,
-        success: true
-      });
-      continue;
-    }
-    if (!options.force) {
-      try {
-        await access4(file.path);
-        results.push({
-          path: file.path,
-          success: false,
-          error: "File exists, use --force to overwrite"
-        });
-        continue;
-      } catch {}
-    }
-    try {
-      const dir = dirname2(file.path);
-      await mkdir3(dir, { recursive: true });
-      await writeFile3(file.path, file.content, "utf-8");
-      results.push({
-        path: file.path,
-        success: true
-      });
-    } catch (error) {
-      results.push({
-        path: file.path,
-        success: false,
-        error: String(error)
-      });
-    }
+// src/adapters/codex/codex-council-generator.ts
+function generateCodexFiles(spec) {
+  const files = [];
+  files.push({
+    path: ".codex/config.toml",
+    content: generateCodexConfig(spec),
+    overwrite: false
+  });
+  for (const agent of spec.agents) {
+    files.push({
+      path: `.codex/agents/council_${agent.id}.toml`,
+      content: generateCodexAgent(agent),
+      overwrite: true
+    });
   }
-  return results;
+  files.push({
+    path: ".codex/skills/council/SKILL.md",
+    content: generateCodexSkill(spec),
+    overwrite: true
+  });
+  return files;
 }
+function generateCodexConfig(spec) {
+  const agentTables = spec.agents.map((agent) => {
+    const focusAreas = agent.focus.join(", ");
+    return `
+[agents.${agent.id}]
+description = "${agent.role} council agent. Focus: ${focusAreas}. Context: ${agent.context}. Model hint: ${agent.modelHint}."
+nickname_candidates = ["${agent.role}", "Council ${agent.role}"]`;
+  }).join(`
+`);
+  return `# Codex Council Configuration
 
-// src/core/presets/file-copier.ts
-import { mkdir as mkdir4, readdir, readFile as readFile4, stat, writeFile as writeFile4 } from "node:fs/promises";
-import { homedir as homedir2 } from "node:os";
-import { dirname as dirname3, join as join2, relative, resolve as resolve5 } from "node:path";
-
-// src/core/i18n/language-instructions.ts
-var SUPPORTED_LOCALES = ["en", "es"];
-var LANGUAGE_INSTRUCTIONS = {
-  en: 'Prose/docs/code comments: be terse and direct. Prefer concrete nouns over abstract ones. Omit filler phrases ("note that", "please", "as mentioned"). One idea per sentence.',
-  es: "Spanish prose/docs/reports/Markdown: preserve natural Spanish orthography, including accents, `ñ`, `¿`, `¡`, and normal Unicode. The ASCII-only editing preference does not apply to these artifacts."
-};
-var COMMIT_STYLE = {
-  en: `---
-trigger: always_on
-description: Rules for generating commit messages using Conventional Commits format
----
-
-## Git Commit Messages
-
-### Format
-
-\`\`\`
-<type>(<scope>): <short description>
-
-- <detail 1>
-- <detail 2>
-\`\`\`
-
-### Valid Types
-
-\`feat\` \`fix\` \`docs\` \`style\` \`refactor\` \`test\` \`chore\` \`perf\` \`ci\` \`build\`
-\`revert\`
-
-### Rules
-
-- Language: **neutral English** always
-- Header: maximum 69 characters, no trailing period
-- Body: concise bullet points, one idea per line
-- Footer: only for breaking changes or issues
-- No gerunds ("adding", "fixing")
-- Use infinitive or imperative ("add", "fix", "update")`,
-  es: `---
-trigger: always_on
-description: Reglas para generar mensajes de commit con formato Conventional Commits
----
-
-## Git Commit Messages
-
-### Formato
-
-\`\`\`
-<tipo>(<scope>): <descripcion corta>
-
-- <detalle 1>
-- <detalle 2>
-\`\`\`
-
-### Tipos validos
-
-\`feat\` \`fix\` \`docs\` \`style\` \`refactor\` \`test\` \`chore\` \`perf\` \`ci\` \`build\`
-\`revert\`
-
-### Reglas
-
-- Idioma: **inglés neutro** siempre
-- Encabezado: maximo 69 caracteres, sin punto final
-- Cuerpo: viñetas concisas, una idea por linea
-- Footer: solo para breaking changes o issues
-- Sin gerundios ("agregando", "corrigiendo")
-- Usar infinitivo o imperativo ("agregar", "corregir", "actualizar")`
-};
-var COMMIT_WORKFLOW = {
-  en: `---
-name: commit
-description: Generates a commit in English following Conventional Commits based on staged changes
----
-
-// turbo-all
-
-## Steps
-
-1. View staged changes: \`git diff --cached --stat\`
-2. If nothing is staged, suggest \`git add .\` or specific files
-3. Get full diff: \`git diff --cached\`
-4. Check recent style: \`git log -n 3 --oneline\`
-5. Generate message following \`.agents/rules/commit-style.md\`
-6. Show proposal and confirm with the user
-7. Execute: \`git commit -m "<message>"\`
-8. Confirm success: \`git status\``,
-  es: `---
-name: commit
-description: Genera un commit en inglés siguiendo Conventional Commits basado en los cambios staged
----
-
-// turbo-all
+[project]
+name = "council"
+version = "${spec.version}"
+${agentTables}
+`;
+}
+function generateCodexAgent(agent) {
+  const focusAreas = agent.focus.join(", ");
+  return `name = "${agent.role}"
+description = "${agent.role} council agent. Focus: ${focusAreas}. Context: ${agent.context}. Model hint: ${agent.modelHint}."
+nickname_candidates = ["${agent.role}", "Council ${agent.role}"]
+developer_instructions = "You are the ${agent.role} council agent. Your focus areas are: ${focusAreas}. Context: ${agent.context}. Apply ${agent.modelHint} reasoning to your analysis."
+`;
+}
+function generateCodexSkill(spec) {
+  return `---
+name: council
+description: ${spec.description}
+version: ${spec.version}
+---
 
-## Pasos
+## Agents
+${spec.agents.map((a) => `- **${a.role}** (${a.id}): ${a.focus.join(", ")}`).join(`
+`)}
 
-1. Ver cambios staged: \`git diff --cached --stat\`
-2. Si no hay nada staged, sugiere \`git add .\` o archivos específicos
-3. Obtener diff completo: \`git diff --cached\`
-4. Ver estilo reciente: \`git log -n 3 --oneline\`
-5. Generar mensaje siguiendo \`.agents/rules/commit-style.md\`
-6. Mostrar propuesta y confirmar con el usuario
-7. Ejecutar: \`git commit -m "<mensaje>"\`
-8. Confirmar éxito: \`git status\``
-};
-function getLanguageInstruction(locale) {
-  const key = SUPPORTED_LOCALES.includes(locale) ? locale : "en";
-  return `- ${LANGUAGE_INSTRUCTIONS[key]}`;
+## Usage
+Use the council agents to get multi-perspective analysis on code changes, architecture decisions, and security reviews.
+`;
 }
-var LOCALE_PLACEHOLDER = "{{LANGUAGE_INSTRUCTIONS}}";
 
-// src/core/filesystem/safe-merger.ts
-var MANAGED_BEGIN_MARKER = "<!-- CODECONDUCTOR:BEGIN managed -->";
-var MANAGED_END_MARKER = "<!-- CODECONDUCTOR:END managed -->";
-function mergeManagedBlock(existing, incoming) {
-  validateMarkers(incoming, "incoming content");
-  if (!existing) {
-    return { content: incoming, action: "written" };
+// src/adapters/codex/codex-installer.ts
+class CodexInstaller {
+  name = "codex";
+  target = "codex";
+  spec = null;
+  setSpec(spec) {
+    this.spec = spec;
   }
-  validateMarkers(existing, "existing content");
-  const existingBlock = getManagedBlockRange(existing);
-  const incomingBlock = getManagedBlockRange(incoming);
-  return {
-    content: existing.slice(0, existingBlock.start) + incoming.slice(incomingBlock.start, incomingBlock.end) + existing.slice(existingBlock.end),
-    action: "merged"
-  };
-}
-function validateMarkers(content, label) {
-  const beginCount = countOccurrences(content, MANAGED_BEGIN_MARKER);
-  const endCount = countOccurrences(content, MANAGED_END_MARKER);
-  if (beginCount !== 1 || endCount !== 1) {
-    throw new Error(`${label} must contain exactly one managed begin marker and one managed end marker`);
+  async generate() {
+    if (!this.spec) {
+      throw new Error("Council spec not set");
+    }
+    return generateCodexFiles(this.spec);
   }
-  if (content.indexOf(MANAGED_BEGIN_MARKER) > content.indexOf(MANAGED_END_MARKER)) {
-    throw new Error(`${label} has managed markers in the wrong order`);
+  async isAvailable() {
+    return true;
   }
 }
-function getManagedBlockRange(content) {
-  const start = content.indexOf(MANAGED_BEGIN_MARKER);
-  const end = content.indexOf(MANAGED_END_MARKER) + MANAGED_END_MARKER.length;
-  return { start, end };
-}
-function countOccurrences(content, needle) {
-  return content.split(needle).length - 1;
+function createCodexInstaller(spec) {
+  const installer = new CodexInstaller;
+  installer.setSpec(spec);
+  return installer;
 }
 
-// src/core/presets/file-copier.ts
-async function listFilesRecursive(dir, base = dir) {
-  const entries = await readdir(dir, { withFileTypes: true });
+// src/adapters/opencode/opencode-council-generator.ts
+function generateOpenCodeFiles(spec) {
   const files = [];
-  for (const entry of entries) {
-    const full = join2(dir, entry.name);
-    if (entry.isDirectory()) {
-      files.push(...await listFilesRecursive(full, base));
-    } else {
-      files.push(relative(base, full));
-    }
+  files.push({
+    path: ".opencode/commands/cc-council.md",
+    content: generateCouncilCommand(spec),
+    overwrite: false
+  });
+  files.push({
+    path: ".opencode/agents/council-lead.md",
+    content: generateCouncilLead(spec),
+    overwrite: false
+  });
+  for (const agent of spec.agents) {
+    files.push({
+      path: `.opencode/agents/council-${agent.id}.md`,
+      content: generateOpenCodeAgentContent(agent),
+      overwrite: false
+    });
   }
   return files;
 }
-async function resolveEntryFiles(entry, presetsDir, baseDir) {
-  const srcAbsolute = resolve5(presetsDir, entry.src);
-  try {
-    const s = await stat(srcAbsolute);
-    if (s.isDirectory()) {
-      const files = await listFilesRecursive(srcAbsolute);
-      return files.map((f) => ({
-        src: join2(srcAbsolute, f),
-        dest: resolve5(baseDir, entry.dest, f)
-      }));
-    }
-    return [{ src: srcAbsolute, dest: resolve5(baseDir, entry.dest) }];
-  } catch {
-    return [];
-  }
-}
-function mergeDeep(target, source) {
-  const result = { ...target };
-  for (const key of Object.keys(source)) {
-    const srcVal = source[key];
-    const tgtVal = target[key];
-    if (Array.isArray(srcVal) && Array.isArray(tgtVal)) {
-      result[key] = [...new Set([...tgtVal, ...srcVal])];
-    } else if (srcVal && typeof srcVal === "object" && !Array.isArray(srcVal) && tgtVal && typeof tgtVal === "object" && !Array.isArray(tgtVal)) {
-      result[key] = mergeDeep(tgtVal, srcVal);
-    } else {
-      result[key] = srcVal;
-    }
-  }
-  return result;
+function generateCouncilCommand(spec) {
+  return `---
+description: ${yamlString(spec.description)}
+agent: council-lead
+subtask: true
+---
+
+Run the CodeConductor council for multi-perspective analysis.
+
+## Version
+${spec.version}
+
+## Agents
+${spec.agents.map((a) => `- ${a.role} (${a.id})`).join(`
+`)}
+
+## Instructions
+Coordinate with the council agents and synthesize their perspectives into the configured output contract.
+`;
 }
-function extractAgentRole(filePath) {
-  const parts = filePath.replace(/\\/g, "/").split("/");
-  const basename2 = parts[parts.length - 1];
-  const name = basename2.replace(/\.md$/, "");
-  const knownRoles = [
-    "architect",
-    "implementer",
-    "tester",
-    "orchestrator",
-    "reviewer",
-    "docs",
-    "task-coach",
-    "repo-explorer"
-  ];
-  return knownRoles.includes(name) ? name : null;
+function generateCouncilLead(spec) {
+  return `---
+description: ${yamlString(`${spec.description} Council lead. Coordinates council members and synthesizes recommendations.`)}
+mode: subagent
+permission:
+  read: allow
+  edit: deny
+  bash: deny
+  glob: allow
+  grep: allow
+  webfetch: deny
+  websearch: deny
+---
+
+# Council Lead Agent
+
+## Role
+Coordinates the council and synthesizes perspectives
+
+## Version
+${spec.version}
+
+## Council Members
+${spec.agents.map((a) => `- ${a.role}: ${a.focus.join(", ")}`).join(`
+`)}
+
+## Responsibilities
+- Coordinate agent responses
+- Synthesize different perspectives
+- Identify consensus and disagreements
+- Provide final recommendation
+`;
 }
-function renderTemplate(content, modelConfig, filePath, locale = "en") {
-  const cleanLocale = locale === "es" || locale === "en" ? locale : "en";
-  const templatedContent = content.replace(/\{\{COMMIT_STYLE\}\}/g, COMMIT_STYLE[cleanLocale]).replace(/\{\{COMMIT_WORKFLOW\}\}/g, COMMIT_WORKFLOW[cleanLocale]);
-  const agentRole = extractAgentRole(filePath);
-  if (agentRole && modelConfig.agents[agentRole]) {
-    const agentModels = modelConfig.agents[agentRole];
-    const targetModel = agentModels[modelConfig.target];
-    let result2 = templatedContent.replace(/\{\{MODEL\}\}/g, targetModel ?? "").replace(/\{\{MODEL_CLAUDE\}\}/g, agentModels.claude ?? "").replace(/\{\{MODEL_OPENCODE\}\}/g, agentModels.opencode ?? "").replace(/\{\{MODEL_CODEX\}\}/g, agentModels.codex ?? "").replace(/\{\{MODEL_GEMINI\}\}/g, agentModels.gemini ?? "").replace(/\{\{MODEL_CURSOR\}\}/g, agentModels.cursor ?? "").replace(new RegExp(LOCALE_PLACEHOLDER.replace(/[{}]/g, "\\$&"), "g"), getLanguageInstruction(locale));
-    if (modelConfig.tools || modelConfig.permissions) {
-      result2 = substituteToolNames(result2, modelConfig);
-    }
-    return result2;
-  }
-  const knownRoles = [
-    "orchestrator",
-    "task-coach",
-    "architect",
-    "implementer",
-    "tester",
-    "reviewer",
-    "docs",
-    "repo-explorer"
-  ];
-  let result = templatedContent;
-  for (const role of knownRoles) {
-    if (!modelConfig.agents[role])
-      continue;
-    const agentModels = modelConfig.agents[role];
-    const sectionRegex = new RegExp(`(### ${role}[\\s\\S]*?)(?=### |## |$)`, "gi");
-    const sectionMatch = result.match(sectionRegex);
-    if (sectionMatch) {
-      for (const section of sectionMatch) {
-        const renderedSection = section.replace(/\{\{MODEL_CLAUDE\}\}/g, agentModels.claude ?? "").replace(/\{\{MODEL_OPENCODE\}\}/g, agentModels.opencode ?? "").replace(/\{\{MODEL_CODEX\}\}/g, agentModels.codex ?? "").replace(/\{\{MODEL_GEMINI\}\}/g, agentModels.gemini ?? "").replace(/\{\{MODEL_CURSOR\}\}/g, agentModels.cursor ?? "");
-        result = result.replace(section, renderedSection);
-      }
-    }
-  }
-  result = result.replace(new RegExp(LOCALE_PLACEHOLDER.replace(/[{}]/g, "\\$&"), "g"), getLanguageInstruction(locale));
-  if (modelConfig.tools || modelConfig.permissions) {
-    result = substituteToolNames(result, modelConfig);
-  }
-  return result;
+function generateOpenCodeAgentContent(agent) {
+  return `---
+description: ${yamlString(`${agent.role} council agent. Focus: ${agent.focus.join(", ")}. Context: ${agent.context}. Model hint: ${agent.modelHint}.`)}
+mode: subagent
+permission:
+${generatePermissionBlock(agent.context)}
+---
+
+${generateAgentContent(agent)}`;
 }
-function substituteToolNames(content, modelConfig) {
-  if (!modelConfig.tools && !modelConfig.permissions)
-    return content;
-  const target = modelConfig.target;
-  const fmMatch = content.match(/^---\r?\n([\s\S]*?)\r?\n---/);
-  if (!fmMatch)
-    return content;
-  const frontmatter = fmMatch[1];
-  if (target === "opencode" && modelConfig.permissions) {
-    const updatedFrontmatter2 = frontmatter.replace(/^tools:\s*(.+)\r?\n?/m, "");
-    return content.replace(fmMatch[0], `---
-${updatedFrontmatter2}
----`);
+function generatePermissionBlock(context) {
+  if (context === "repo-readonly") {
+    return `  read: allow
+  edit: deny
+  bash: deny
+  glob: allow
+  grep: allow
+  webfetch: deny
+  websearch: deny`;
   }
-  if (!modelConfig.tools)
-    return content;
-  const updatedFrontmatter = frontmatter.replace(/^tools:\s*(.+)$/m, (_match, toolsLine) => {
-    const baseNames = toolsLine.split(",").map((t) => t.trim());
-    const mappedNames = baseNames.map((baseName) => {
-      const toolMapping = modelConfig.tools?.[baseName];
-      if (toolMapping && toolMapping[target]) {
-        return toolMapping[target];
-      }
-      return baseName;
-    });
-    return `tools: ${mappedNames.join(", ")}`;
-  });
-  return content.replace(fmMatch[0], `---
-${updatedFrontmatter}
----`);
+  return `  read: deny
+  edit: deny
+  bash: deny
+  glob: deny
+  grep: deny
+  webfetch: deny
+  websearch: deny`;
+}
+function yamlString(value) {
+  return JSON.stringify(value);
 }
-async function applySingleFile(srcPath, destPath, strategy, force, dryRun, isTemplate, modelConfig, locale) {
-  if (strategy === "skip") {
-    return { src: srcPath, dest: destPath, action: "skipped", dryRun };
-  }
-  let content;
-  try {
-    content = await readFile4(srcPath, "utf-8");
-  } catch (e) {
-    return { src: srcPath, dest: destPath, action: "error", error: `Cannot read source: ${e}` };
-  }
-  const incomingContent = isTemplate && modelConfig ? renderTemplate(content, modelConfig, srcPath, locale) : content;
-  let finalContent = incomingContent;
-  let action = "written";
-  if (strategy === "append") {
-    let existing = "";
-    try {
-      existing = await readFile4(destPath, "utf-8");
-    } catch {}
-    if (existing) {
-      finalContent = existing + `
-
----
 
-` + incomingContent;
-    }
-    action = "appended";
-  } else if (strategy === "merge-json") {
-    let existing = {};
-    try {
-      existing = JSON.parse(await readFile4(destPath, "utf-8"));
-    } catch {}
-    try {
-      const incoming = JSON.parse(incomingContent);
-      finalContent = JSON.stringify(mergeDeep(existing, incoming), null, 2);
-    } catch (e) {
-      return { src: srcPath, dest: destPath, action: "error", error: `JSON merge failed: ${e}` };
-    }
-    action = "merged";
-  } else if (strategy === "merge-managed") {
-    let existing = null;
-    try {
-      existing = await readFile4(destPath, "utf-8");
-    } catch {}
-    try {
-      const merged = mergeManagedBlock(existing, incomingContent);
-      finalContent = merged.content;
-      action = merged.action;
-    } catch (e) {
-      return { src: srcPath, dest: destPath, action: "error", error: `Managed merge failed: ${e}` };
-    }
+// src/adapters/opencode/opencode-installer.ts
+class OpenCodeInstaller {
+  name = "opencode";
+  target = "opencode";
+  spec = null;
+  setSpec(spec) {
+    this.spec = spec;
   }
-  if (dryRun) {
-    return { src: srcPath, dest: destPath, action, dryRun: true };
+  async generate() {
+    if (!this.spec) {
+      throw new Error("Council spec not set");
+    }
+    return generateOpenCodeFiles(this.spec);
   }
-  try {
-    await mkdir4(dirname3(destPath), { recursive: true });
-    await writeFile4(destPath, finalContent, "utf-8");
-    return { src: srcPath, dest: destPath, action };
-  } catch (e) {
-    return { src: srcPath, dest: destPath, action: "error", error: String(e) };
+  async isAvailable() {
+    return true;
   }
 }
-async function copyFromManifest(manifest, presetsDir, baseDir, isGlobal, dryRun, force, modelConfig = null, locale = "en") {
+function createOpenCodeInstaller(spec) {
+  const installer = new OpenCodeInstaller;
+  installer.setSpec(spec);
+  return installer;
+}
+
+// src/core/filesystem/file-writer.ts
+import { access as access4, mkdir as mkdir4, writeFile as writeFile4 } from "node:fs/promises";
+import { dirname as dirname3 } from "node:path";
+init_safety();
+async function writeGeneratedFiles(files, options) {
   const results = [];
-  for (const entry of manifest.entries) {
-    const strategy = isGlobal && entry.globalStrategy ? entry.globalStrategy : entry.strategy;
-    let resolvedBaseDir = baseDir;
-    let resolvedEntry = entry;
-    if (manifest.target === "agy" && isGlobal) {
-      resolvedBaseDir = join2(homedir2(), ".gemini", "config");
-      resolvedEntry = {
-        ...entry,
-        dest: entry.dest.replace(/^\.agents\/?/, "")
-      };
+  for (const file of files) {
+    if (!validateWritePath(file.path)) {
+      results.push({
+        path: file.path,
+        success: false,
+        error: "Protected path"
+      });
+      continue;
     }
-    const files = await resolveEntryFiles(resolvedEntry, presetsDir, resolvedBaseDir);
-    const isTemplate = entry.template === true;
-    for (const { src, dest } of files) {
-      results.push(await applySingleFile(src, dest, strategy, force, dryRun, isTemplate, modelConfig, locale));
+    if (options.dryRun) {
+      results.push({
+        path: file.path,
+        success: true
+      });
+      continue;
+    }
+    if (!options.force) {
+      try {
+        await access4(file.path);
+        results.push({
+          path: file.path,
+          success: false,
+          error: "File exists, use --force to overwrite"
+        });
+        continue;
+      } catch {}
+    }
+    try {
+      const dir = dirname3(file.path);
+      await mkdir4(dir, { recursive: true });
+      await writeFile4(file.path, file.content, "utf-8");
+      results.push({
+        path: file.path,
+        success: true
+      });
+    } catch (error) {
+      results.push({
+        path: file.path,
+        success: false,
+        error: String(error)
+      });
     }
   }
   return results;
 }
 
-// src/core/presets/manifest-loader.ts
-import { readFile as readFile5 } from "node:fs/promises";
-import { join as join3 } from "node:path";
-var MANIFESTS_DIR = join3(SRC_PRESETS_DIR, "manifests");
-var MODELS_DIR = join3(SRC_PRESETS_DIR, "models");
-var PRESETS_DIR = ROOT_PRESETS_DIR;
-async function loadManifest(target) {
-  const manifestPath = join3(MANIFESTS_DIR, `${target}.yml`);
-  const content = await readFile5(manifestPath, "utf-8");
-  const data = $parse(content);
-  return InstallManifestSchema.parse(data);
-}
-async function loadModelConfig(target) {
-  const modelPath = join3(MODELS_DIR, `${target}.yml`);
-  const content = await readFile5(modelPath, "utf-8");
-  const data = $parse(content);
-  return ModelConfigSchema.parse(data);
-}
-
 // src/core/presets/preset-loader.ts
-import { readFile as readFile6 } from "node:fs/promises";
-import { resolve as resolve6 } from "node:path";
+import { readFile as readFile7 } from "node:fs/promises";
+import { resolve as resolve7 } from "node:path";
 async function loadPreset(name, projectRoot = process.cwd()) {
   const candidates = [
-    resolve6(projectRoot, ".codeconductor", "presets", `${name}.yml`),
-    resolve6(SRC_PRESETS_DIR, name, `${name}.yml`)
+    resolve7(projectRoot, ".codeconductor", "presets", `${name}.yml`),
+    resolve7(SRC_PRESETS_DIR, name, `${name}.yml`)
   ];
   for (const presetPath of candidates) {
     try {
-      const content = await readFile6(presetPath, "utf-8");
+      const content = await readFile7(presetPath, "utf-8");
       const data = $parse(content);
       if (!data)
         continue;
@@ -12987,7 +13362,7 @@ function getIndividualTargets(target) {
 // src/commands/install.command.ts
 async function installCommand(options) {
   const { target, dryRun, force, global: isGlobal, output, projectRoot } = options;
-  const baseDir = isGlobal ? homedir3() : projectRoot;
+  const baseDir = isGlobal ? homedir5() : projectRoot;
   try {
     const runnerTarget = parseRunnerTarget(target);
     const targets = getIndividualTargets(runnerTarget);
@@ -13023,7 +13398,7 @@ async function installCommand(options) {
       const generatedFiles = await installer.generate();
       const resolvedFiles = generatedFiles.map((f) => ({
         ...f,
-        path: resolve7(baseDir, f.path)
+        path: resolve8(baseDir, f.path)
       }));
       const results = await writeGeneratedFiles(resolvedFiles, writeOptions);
       for (const result of results) {
@@ -13082,7 +13457,7 @@ async function installCommand(options) {
 }
 async function installPresetCommand(options) {
   const { target, dryRun, force, global: isGlobal, projectRoot } = options;
-  const baseDir = isGlobal ? homedir3() : projectRoot;
+  const baseDir = isGlobal ? homedir5() : projectRoot;
   try {
     const runnerTarget = parseRunnerTarget(target);
     const targets = getIndividualTargets(runnerTarget);
@@ -13132,8 +13507,8 @@ async function installPresetCommand(options) {
 }
 
 // src/commands/install-lsp.command.ts
-import { homedir as homedir5 } from "node:os";
-import { resolve as resolve8 } from "node:path";
+import { homedir as homedir7 } from "node:os";
+import { resolve as resolve9 } from "node:path";
 
 // src/core/lsp/lsp-config-utils.ts
 function getLanguageServerConfig(lspIds) {
@@ -13377,15 +13752,15 @@ function createOpenCodeLspGenerator() {
 // src/core/lsp/lsp-installer.ts
 import { execFile } from "node:child_process";
 import { access as access5, mkdir as mkdir5 } from "node:fs/promises";
-import { homedir as homedir4 } from "node:os";
-import { join as join4 } from "node:path";
+import { homedir as homedir6 } from "node:os";
+import { join as join5 } from "node:path";
 import { promisify } from "node:util";
 var execFileAsync = promisify(execFile);
 
 class LspInstaller {
   lspBinDir;
   constructor() {
-    this.lspBinDir = join4(homedir4(), ".codeconductor", "lsp", "bin");
+    this.lspBinDir = join5(homedir6(), ".codeconductor", "lsp", "bin");
   }
   async checkInstalled(def) {
     try {
@@ -13512,7 +13887,7 @@ class LspInstaller {
       throw new Error(`No binary available for platform: ${platformKey}`);
     }
     await mkdir5(this.lspBinDir, { recursive: true });
-    const destPath = join4(this.lspBinDir, def.binaryName);
+    const destPath = join5(this.lspBinDir, def.binaryName);
     try {
       await access5(destPath);
       return;
@@ -13619,7 +13994,7 @@ function resolveLsps(languages) {
 // src/commands/install-lsp.command.ts
 async function installLspCommand(options) {
   const { target, lang, dryRun, force, global: isGlobal, output, projectRoot } = options;
-  const baseDir = isGlobal ? homedir5() : projectRoot;
+  const baseDir = isGlobal ? homedir7() : projectRoot;
   try {
     const runnerTarget = parseRunnerTarget(target);
     const targets = getIndividualTargets(runnerTarget);
@@ -13665,7 +14040,7 @@ async function installLspCommand(options) {
       const generatedFiles = generator.generate(installReport.results);
       const resolvedFiles = generatedFiles.map((f) => ({
         ...f,
-        path: resolve8(baseDir, f.path)
+        path: resolve9(baseDir, f.path)
       }));
       const results = await writeGeneratedFiles(resolvedFiles, writeOptions);
       for (const result of results) {
@@ -13759,7 +14134,7 @@ function getLspConfigGenerator(target) {
 
 // src/commands/seo-audit.command.ts
 import { writeFile as writeFile5, mkdir as mkdir6 } from "node:fs/promises";
-import { dirname as dirname4, resolve as resolve9 } from "node:path";
+import { dirname as dirname4, resolve as resolve10 } from "node:path";
 
 // src/infrastructure/http/safe-fetch.ts
 import { lookup } from "node:dns/promises";
@@ -13846,7 +14221,7 @@ async function safeFetch(urlString, options = {}) {
   }
 }
 async function delay(ms) {
-  return new Promise((resolve9) => setTimeout(resolve9, ms));
+  return new Promise((resolve10) => setTimeout(resolve10, ms));
 }
 
 // src/infrastructure/parsers/sitemap-parser.ts
@@ -15050,12 +15425,12 @@ async function seoAuditCommand(options) {
         formattedOutput = formatCli(report);
     }
     if (output) {
-      const outputPath = resolve9(options.projectRoot, output);
+      const outputPath = resolve10(options.projectRoot, output);
       await mkdir6(dirname4(outputPath), { recursive: true });
       await writeFile5(outputPath, formattedOutput, "utf-8");
     } else if (format === "markdown") {
       const timestamp = new Date().toISOString().replace(/[:.]/g, "-").slice(0, 19);
-      const defaultPath = resolve9(options.projectRoot, "seo-reports", `audit-report-${timestamp}.md`);
+      const defaultPath = resolve10(options.projectRoot, "seo-reports", `audit-report-${timestamp}.md`);
       await mkdir6(dirname4(defaultPath), { recursive: true });
       await writeFile5(defaultPath, formattedOutput, "utf-8");
       process.stderr.write(`Report saved to: ${defaultPath}
@@ -15069,7 +15444,7 @@ async function seoAuditCommand(options) {
         command: "seo audit",
         report,
         output: formattedOutput,
-        outputFile: output ? resolve9(options.projectRoot, output) : format === "markdown" ? resolve9(options.projectRoot, "seo-reports") : undefined
+        outputFile: output ? resolve10(options.projectRoot, output) : format === "markdown" ? resolve10(options.projectRoot, "seo-reports") : undefined
       }
     };
   } catch (error) {
@@ -15086,7 +15461,7 @@ async function seoAuditCommand(options) {
 
 // src/commands/seo-llms.command.ts
 import { writeFile as writeFile6, mkdir as mkdir7 } from "node:fs/promises";
-import { dirname as dirname5, resolve as resolve10 } from "node:path";
+import { dirname as dirname5, resolve as resolve11 } from "node:path";
 
 // src/domain/seo/llms-generator.ts
 function extractTitle2(html) {
@@ -15229,7 +15604,7 @@ async function seoLlmsCommand(options) {
       }
     }) : await generateLlmsTxtFromUrl(url);
     process.stderr.write("\r" + " ".repeat(80) + "\r");
-    const outputPath = output ? resolve10(options.projectRoot, output) : resolve10(options.projectRoot, "llms.txt");
+    const outputPath = output ? resolve11(options.projectRoot, output) : resolve11(options.projectRoot, "llms.txt");
     await mkdir7(dirname5(outputPath), { recursive: true });
     await writeFile6(outputPath, result.content, "utf-8");
     process.stderr.write(`Generated: ${outputPath} (${result.entries.length} entries)
@@ -15257,10 +15632,14 @@ async function seoLlmsCommand(options) {
 }
 
 // src/commands/update.command.ts
+import { homedir as homedir8 } from "node:os";
+import { resolve as resolve12, dirname as dirname6 } from "node:path";
+import { mkdir as mkdir8, readFile as readFile8, writeFile as writeFile7, stat as stat3 } from "node:fs/promises";
 async function updateCommand(options) {
-  const { dryRun, force, output, projectRoot } = options;
+  const { dryRun, force, global: isGlobal, output, projectRoot } = options;
+  const basePath = isGlobal ? homedir8() : projectRoot;
   try {
-    const configResult = await loadConfig(projectRoot);
+    const configResult = await loadConfig(basePath);
     if (!configResult.success) {
       return {
         code: 1,
@@ -15272,42 +15651,40 @@ async function updateCommand(options) {
       };
     }
     const config = configResult.data;
-    if (!config.presets.council.enabled) {
-      return {
-        code: 4,
-        data: {
-          success: false,
-          command: "update",
-          errors: ["Council preset is not enabled"]
-        }
-      };
-    }
-    const presetResult = await loadCouncilPreset(projectRoot);
-    if (!presetResult.success) {
-      return {
-        code: 1,
-        data: {
-          success: false,
-          command: "update",
-          errors: ["Failed to load preset"]
-        }
-      };
+    const updateResults = await checkUpdates(basePath, isGlobal);
+    const largeFiles = await validateAgentFileSizes(basePath, isGlobal);
+    if (largeFiles.length > 0) {
+      largeFiles.forEach((file) => {
+        console.warn(`[WARNING] File exceeds 40KB: ${file.path} (${(file.size / 1024).toFixed(1)} KB)`);
+      });
     }
-    const spec = presetResult.data;
-    const currentVersion = config.presets.council.version;
-    const newVersion = spec.version;
-    if (currentVersion === newVersion) {
+    if (!updateResults.hasUpdates) {
       return {
         code: 0,
         data: {
           success: true,
           command: "update",
           message: "Already up to date",
-          currentVersion,
-          newVersion
+          wouldUpdate: [],
+          updated: []
         }
       };
     }
+    const wouldUpdate = [];
+    if (updateResults.council)
+      wouldUpdate.push("council preset");
+    if (updateResults.policy)
+      wouldUpdate.push("policy file");
+    for (const t of updateResults.targets) {
+      if (t.hasUpdate) {
+        wouldUpdate.push(`${t.target} target files`);
+      }
+    }
+    for (const s of updateResults.skills) {
+      if (s.hasUpdate) {
+        wouldUpdate.push(`skill ${s.id} to v${s.latestVersion}`);
+      }
+    }
     if (dryRun) {
       return {
         code: 0,
@@ -15315,48 +15692,77 @@ async function updateCommand(options) {
           success: true,
           command: "update",
           message: "Dry run - would update",
-          currentVersion,
-          newVersion,
-          wouldUpdate: ["council preset files"]
+          wouldUpdate,
+          updated: []
         }
       };
     }
-    const writeOptions = { dryRun: false, force };
-    const target = config.defaults.target;
-    let installer;
-    switch (target) {
-      case "opencode":
-        installer = createOpenCodeInstaller(spec);
-        break;
-      case "claude":
-        installer = createClaudeInstaller(spec);
-        break;
-      case "codex":
-        installer = createCodexInstaller(spec);
-        break;
-      default:
-        return {
-          code: 1,
-          data: {
-            success: false,
-            command: "update",
-            errors: [`Unknown target: ${target}`]
+    const updated = [];
+    if (updateResults.council) {
+      const localCouncil = resolve12(basePath, ".codeconductor", "presets", "council.yml");
+      const bundledCouncil = resolve12(SRC_PRESETS_DIR, "council", "council.yml");
+      try {
+        const content = await readFile8(bundledCouncil, "utf-8");
+        await mkdir8(dirname6(localCouncil), { recursive: true });
+        await writeFile7(localCouncil, content, "utf-8");
+        updated.push(localCouncil);
+      } catch (e) {
+        throw new Error(`Failed to update council.yml: ${e}`);
+      }
+    }
+    if (updateResults.policy) {
+      const localPolicy = resolve12(basePath, ".codeconductor", "presets", "policy.yml");
+      try {
+        const content = await readFile8(POLICY_PATH, "utf-8");
+        await mkdir8(dirname6(localPolicy), { recursive: true });
+        await writeFile7(localPolicy, content, "utf-8");
+        updated.push(localPolicy);
+      } catch (e) {
+        throw new Error(`Failed to update policy.yml: ${e}`);
+      }
+    }
+    const locale = config?.defaults?.locale ?? "en";
+    for (const t of updateResults.targets) {
+      if (t.hasUpdate) {
+        const targetName = t.target;
+        const manifest = await loadManifest(targetName);
+        const modelConfig = await loadModelConfig(targetName);
+        const results = await copyFromManifest(manifest, PRESETS_DIR, basePath, isGlobal, false, force, modelConfig, locale);
+        for (const r of results) {
+          if (r.action !== "skipped" && r.action !== "error") {
+            updated.push(r.dest);
+          } else if (r.action === "error") {
+            throw new Error(`Failed to copy target file: ${r.error}`);
           }
-        };
+        }
+      }
     }
-    const files = await installer.generate();
-    const results = await writeGeneratedFiles(files, writeOptions);
-    const updated = results.filter((r) => r.success).map((r) => r.path);
-    const errors3 = results.filter((r) => !r.success).map((r) => `${r.path}: ${r.error}`);
-    if (errors3.length > 0) {
-      return {
-        code: 2,
-        data: {
-          success: false,
-          command: "update",
-          errors: errors3
+    if (updateResults.skills.some((s) => s.hasUpdate)) {
+      const newSkillsLock = {};
+      const currentLock = await loadSkillsLock(basePath) || {};
+      for (const [id, ver] of Object.entries(currentLock)) {
+        newSkillsLock[id] = ver;
+      }
+      for (const s of updateResults.skills) {
+        newSkillsLock[s.id] = s.latestVersion;
+      }
+      let lockDest = resolve12(basePath, ".codeconductor", "skills-lock.json");
+      try {
+        const statAgents = await stat3(resolve12(basePath, ".agents"));
+        if (statAgents.isDirectory()) {
+          const statCodeConductor = await stat3(resolve12(basePath, ".codeconductor")).catch(() => null);
+          if (!statCodeConductor) {
+            lockDest = resolve12(basePath, ".agents", "skills-lock.json");
+          }
         }
-      };
+      } catch {}
+      try {
+        await mkdir8(dirname6(lockDest), { recursive: true });
+        await writeFile7(lockDest, JSON.stringify(newSkillsLock, null, 2), "utf-8");
+        updated.push(lockDest);
+      } catch (e) {
+        throw new Error(`Failed to write skills-lock.json: ${e}`);
+      }
     }
     return {
       code: 0,
@@ -15364,8 +15770,7 @@ async function updateCommand(options) {
         success: true,
         command: "update",
         message: "Updated successfully",
-        currentVersion,
-        newVersion,
+        wouldUpdate: [],
         updated
       }
     };
@@ -15570,6 +15975,7 @@ async function routeCommand(args, projectRoot) {
         projectRoot,
         dryRun: flags.dryRun,
         force: flags.force,
+        global: options.global === true || options.global === "true",
         output: flags.output
       });
     case "seo": {