cc-codeconductor 0.3.3 → 0.4.0

package/dist/index.js

@@ -36,14 +36,15 @@ function getExitCode(error) {
   }
   return ExitCode.VALIDATION_ERROR;
 }
-var ExitCode, CliError, ValidationError, UnsafeOperationError;
+var ExitCode, CliError, ValidationError, UnsafeOperationError, CredentialGuardError;
 var init_errors = __esm(() => {
   ExitCode = {
     SUCCESS: 0,
     VALIDATION_ERROR: 1,
     UNSAFE_OPERATION: 2,
     UNSUPPORTED_PROJECT: 3,
-    CONFIG_CONFLICT: 4
+    CONFIG_CONFLICT: 4,
+    CREDENTIAL_LEAK: 5
   };
   CliError = class CliError extends Error {
     code;
@@ -67,14 +68,24 @@ var init_errors = __esm(() => {
       this.name = "UnsafeOperationError";
     }
   };
+  CredentialGuardError = class CredentialGuardError extends CliError {
+    matches;
+    constructor(message, matches, details) {
+      super(message, ExitCode.CREDENTIAL_LEAK, details);
+      this.matches = matches;
+      this.name = "CredentialGuardError";
+    }
+  };
 });
 
 // src/core/filesystem/safety.ts
 var exports_safety = {};
 __export(exports_safety, {
   validateWritePath: () => validateWritePath,
+  scanForCredentials: () => scanForCredentials,
   isWritable: () => isWritable,
   isProtectedPath: () => isProtectedPath,
+  isCredentialContent: () => isCredentialContent,
   fileExists: () => fileExists
 });
 import { constants } from "node:fs";
@@ -103,6 +114,42 @@ async function isWritable(dir) {
     return false;
   }
 }
+function buildCredentialRegexes(patterns) {
+  return patterns.map((keyword) => new RegExp(`(?:${keyword})\\s*[:=]\\s*[^\\s]{8,}`, "i"));
+}
+function scanForCredentials(filePath, content, secretPatterns) {
+  const regexes = buildCredentialRegexes(secretPatterns);
+  const lines = content.split(`
+`);
+  const matches = [];
+  for (let i = 0;i < lines.length; i++) {
+    const line = lines[i];
+    for (const regex of regexes) {
+      const m = regex.exec(line);
+      if (m) {
+        matches.push({
+          filePath,
+          line: i + 1,
+          pattern: regex.source,
+          matched: m[0]
+        });
+      }
+    }
+  }
+  return matches;
+}
+function isCredentialContent(content, secretPatterns) {
+  const regexes = buildCredentialRegexes(secretPatterns);
+  const lines = content.split(`
+`);
+  for (const line of lines) {
+    for (const regex of regexes) {
+      if (regex.test(line))
+        return true;
+    }
+  }
+  return false;
+}
 var PROTECTED_PATHS;
 var init_safety = __esm(() => {
   PROTECTED_PATHS = [".git", ".env", ".env.local", ".env.production", "secrets", "credentials"];
@@ -11079,7 +11126,7 @@ function validateCouncilSpec(data) {
 function validateConfig(data) {
   return CodeConductorConfigSchema.parse(data);
 }
-var CouncilAgentSpecSchema, CouncilSpecSchema, ProjectProfileSchema, CodeConductorConfigSchema, RunnerTargetSchema, InstallStrategySchema, ManifestEntrySchema, InstallManifestSchema, ToolProviderNamesSchema, PermissionProviderNamesSchema, ModelConfigSchema;
+var CouncilAgentSpecSchema, CouncilSpecSchema, ProjectProfileSchema, CompileCheckConfigSchema, LoopConfigSchema, CodeConductorConfigSchema, RunnerTargetSchema, InstallStrategySchema, ManifestEntrySchema, InstallManifestSchema, ToolProviderNamesSchema, PermissionProviderNamesSchema, ModelConfigSchema, ContractTargetSchema, ContractFormatSchema, AgentContractSchema, CouncilFindingSchema, CouncilVerdictInputSchema, ConsensusConfigSchema, CouncilVerdictSchema, ClaudeAgentFileSchema, OpenCodeAgentFileSchema, SentryStackFrameSchema, SentryWebhookSchema;
 var init_schemas = __esm(() => {
   init_zod();
   CouncilAgentSpecSchema = exports_external.object({
@@ -11112,6 +11159,16 @@ var init_schemas = __esm(() => {
     signals: exports_external.array(exports_external.string()),
     confidence: exports_external.enum(["low", "medium", "high"])
   });
+  CompileCheckConfigSchema = exports_external.object({
+    enabled: exports_external.boolean(),
+    command: exports_external.string().optional(),
+    timeoutMs: exports_external.number().positive().optional()
+  });
+  LoopConfigSchema = exports_external.object({
+    enabled: exports_external.boolean().optional().default(true),
+    maxIterations: exports_external.number().int().positive().optional().default(3),
+    maxTokenBudget: exports_external.number().nonnegative().optional().default(0)
+  });
   CodeConductorConfigSchema = exports_external.object({
     version: exports_external.string(),
     project: exports_external.object({
@@ -11131,8 +11188,10 @@ var init_schemas = __esm(() => {
     }),
     safety: exports_external.object({
       destructiveCommands: exports_external.array(exports_external.string()),
-      secretPatterns: exports_external.array(exports_external.string())
-    })
+      secretPatterns: exports_external.array(exports_external.string()),
+      compileCheck: CompileCheckConfigSchema.optional()
+    }),
+    loop: LoopConfigSchema.optional()
   });
   RunnerTargetSchema = exports_external.enum([
     "opencode",
@@ -11176,6 +11235,80 @@ var init_schemas = __esm(() => {
     tools: exports_external.record(exports_external.string(), ToolProviderNamesSchema).optional(),
     permissions: PermissionProviderNamesSchema.optional()
   });
+  ContractTargetSchema = exports_external.enum([
+    "claude",
+    "opencode",
+    "codex",
+    "gemini",
+    "cursor",
+    "agy"
+  ]);
+  ContractFormatSchema = exports_external.object({
+    target: ContractTargetSchema,
+    options: exports_external.record(exports_external.unknown()).optional()
+  });
+  AgentContractSchema = exports_external.object({
+    council: CouncilSpecSchema,
+    targets: exports_external.array(ContractFormatSchema),
+    contractVersion: exports_external.string(),
+    renderHints: exports_external.record(ContractTargetSchema, exports_external.record(exports_external.unknown())).optional()
+  });
+  CouncilFindingSchema = exports_external.object({
+    category: exports_external.string(),
+    severity: exports_external.enum(["info", "warning", "critical"]),
+    message: exports_external.string(),
+    agentId: exports_external.string()
+  });
+  CouncilVerdictInputSchema = exports_external.object({
+    agentId: exports_external.string(),
+    agentRole: exports_external.string(),
+    status: exports_external.enum(["APPROVED", "REJECTED", "ABSTAIN"]),
+    securityVeto: exports_external.boolean(),
+    findings: exports_external.array(CouncilFindingSchema),
+    summary: exports_external.string()
+  });
+  ConsensusConfigSchema = exports_external.object({
+    algorithm: exports_external.enum(["majority", "unanimous"]),
+    allowSecurityVeto: exports_external.boolean()
+  });
+  CouncilVerdictSchema = exports_external.object({
+    status: exports_external.enum(["APPROVED", "REJECTED", "ESCALATED"]),
+    totalAgents: exports_external.number(),
+    approvedCount: exports_external.number(),
+    rejectedCount: exports_external.number(),
+    abstainedCount: exports_external.number(),
+    vetoApplied: exports_external.boolean(),
+    vetoByAgentId: exports_external.string().optional(),
+    findings: exports_external.array(CouncilFindingSchema),
+    summary: exports_external.string(),
+    individualVerdicts: exports_external.array(CouncilVerdictInputSchema)
+  });
+  ClaudeAgentFileSchema = exports_external.object({
+    path: exports_external.string().startsWith(".claude/"),
+    content: exports_external.string(),
+    overwrite: exports_external.boolean()
+  });
+  OpenCodeAgentFileSchema = exports_external.object({
+    path: exports_external.string().startsWith(".opencode/"),
+    content: exports_external.string(),
+    overwrite: exports_external.boolean()
+  });
+  SentryStackFrameSchema = exports_external.object({
+    filename: exports_external.string(),
+    function: exports_external.string(),
+    lineNo: exports_external.number(),
+    colNo: exports_external.number().optional(),
+    context: exports_external.array(exports_external.string())
+  });
+  SentryWebhookSchema = exports_external.object({
+    issueId: exports_external.string(),
+    title: exports_external.string(),
+    culprit: exports_external.string(),
+    filename: exports_external.string().optional(),
+    stackTrace: exports_external.array(SentryStackFrameSchema),
+    environment: exports_external.string().optional(),
+    release: exports_external.string().optional()
+  });
 });
 
 // src/core/presets/package-paths.ts
@@ -11865,6 +11998,59 @@ var init_agy_installer = __esm(() => {
   init_agy_council_generator();
 });
 
+// src/core/filesystem/credential-guard.ts
+import { readFile as readFile7 } from "node:fs/promises";
+import { resolve as resolve6 } from "node:path";
+async function loadPolicyPatterns() {
+  try {
+    const content = await readFile7(POLICY_PATH2, "utf-8");
+    const parsed = $parse(content);
+    if (Array.isArray(parsed.secretPatterns) && parsed.secretPatterns.length > 0) {
+      return parsed.secretPatterns;
+    }
+  } catch {}
+  return [];
+}
+function mergePatterns(...arrays) {
+  const seen = new Set;
+  const result = [];
+  for (const arr of arrays) {
+    for (const p of arr) {
+      if (!seen.has(p)) {
+        seen.add(p);
+        result.push(p);
+      }
+    }
+  }
+  return result;
+}
+async function loadCredentialPatterns(config) {
+  const policyPatterns = await loadPolicyPatterns();
+  const configPatterns = config?.safety?.secretPatterns;
+  if (configPatterns && configPatterns.length > 0) {
+    return mergePatterns(configPatterns, policyPatterns, DEFAULT_SECRET_PATTERNS);
+  }
+  if (policyPatterns.length > 0) {
+    return mergePatterns(policyPatterns, DEFAULT_SECRET_PATTERNS);
+  }
+  return DEFAULT_SECRET_PATTERNS;
+}
+var DEFAULT_SECRET_PATTERNS, POLICY_PATH2;
+var init_credential_guard = __esm(() => {
+  init_dist();
+  DEFAULT_SECRET_PATTERNS = [
+    "password",
+    "secret",
+    "api_key",
+    "token",
+    "api[_-]?key",
+    "access[_-]?token",
+    "auth[_-]?token",
+    "private[_-]?key"
+  ];
+  POLICY_PATH2 = resolve6(import.meta.dir, "..", "..", "..", "policy.yml");
+});
+
 // src/core/filesystem/file-writer.ts
 var exports_file_writer = {};
 __export(exports_file_writer, {
@@ -11875,6 +12061,13 @@ import { access as access4, mkdir as mkdir4, writeFile as writeFile4 } from "nod
 import { dirname as dirname3 } from "node:path";
 async function writeGeneratedFiles(files, options) {
   const results = [];
+  const secretPatterns = await loadCredentialPatterns(options.config);
+  const allMatches = files.flatMap((file) => {
+    return scanForCredentials(file.path, file.content, secretPatterns);
+  });
+  if (allMatches.length > 0) {
+    throw new CredentialGuardError(`Credential leak detected in ${allMatches.length} file(s). No files written.`, allMatches);
+  }
   for (const file of files) {
     if (!validateWritePath(file.path)) {
       results.push({
@@ -11933,6 +12126,7 @@ async function writeSingleFile(path, content, options) {
 }
 var init_file_writer = __esm(() => {
   init_errors();
+  init_credential_guard();
   init_safety();
 });
 
@@ -11941,7 +12135,7 @@ init_errors();
 // package.json
 var package_default = {
   name: "cc-codeconductor",
-  version: "0.3.3",
+  version: "0.4.0",
   description: "A multi-agent orchestration framework for AI-assisted software engineering workflows.",
   keywords: [
     "ai",
@@ -13604,17 +13798,18 @@ async function doctorCommand(options) {
 }
 
 // src/commands/init.command.ts
-import { access as access3, mkdir as mkdir3, readFile as readFile7, writeFile as writeFile3 } from "node:fs/promises";
+import { access as access3, mkdir as mkdir3, readFile as readFile8, writeFile as writeFile3 } from "node:fs/promises";
 import { homedir as homedir5 } from "node:os";
-import { basename, resolve as resolve7 } from "node:path";
+import { basename, resolve as resolve8 } from "node:path";
 
 // src/core/config/config-writer.ts
 init_dist();
 init_errors();
 import { access as access2, mkdir as mkdir2, writeFile as writeFile2 } from "node:fs/promises";
-import { resolve as resolve6 } from "node:path";
+import { resolve as resolve7 } from "node:path";
 
 // src/core/config/codeconductor-config.ts
+init_credential_guard();
 var DEFAULT_CONFIG = {
   version: "0.2.0",
   project: {
@@ -13633,7 +13828,17 @@ var DEFAULT_CONFIG = {
   },
   safety: {
     destructiveCommands: ["rm -rf", "drop table", "delete from"],
-    secretPatterns: ["password", "secret", "api_key", "token"]
+    secretPatterns: DEFAULT_SECRET_PATTERNS,
+    compileCheck: {
+      enabled: true,
+      command: "tsc --noEmit",
+      timeoutMs: 120000
+    }
+  },
+  loop: {
+    enabled: true,
+    maxIterations: 3,
+    maxTokenBudget: 0
   }
 };
 
@@ -13642,9 +13847,9 @@ var CONFIG_DIR = ".codeconductor";
 var CONFIG_FILE2 = "config.yml";
 async function writeConfig(projectRoot, config = {}, force = false) {
   try {
-    const configDir = resolve6(projectRoot, CONFIG_DIR);
+    const configDir = resolve7(projectRoot, CONFIG_DIR);
     await mkdir2(configDir, { recursive: true });
-    const configPath = resolve6(configDir, CONFIG_FILE2);
+    const configPath = resolve7(configDir, CONFIG_FILE2);
     if (!force) {
       try {
         await access2(configPath);
@@ -13870,7 +14075,7 @@ async function initCommand(options) {
 }
 async function resolvePresetsToCopy() {
   const sources = [];
-  const bundledCouncil = resolve7(SRC_PRESETS_DIR, "council", "council.yml");
+  const bundledCouncil = resolve8(SRC_PRESETS_DIR, "council", "council.yml");
   if (await fileExists2(bundledCouncil)) {
     sources.push({ name: "council.yml", sourcePath: bundledCouncil });
   }
@@ -13881,16 +14086,16 @@ async function resolvePresetsToCopy() {
   return sources;
 }
 async function copyPresets(baseDir, presets, force) {
-  const presetsDir = resolve7(baseDir, ".codeconductor", "presets");
+  const presetsDir = resolve8(baseDir, ".codeconductor", "presets");
   await mkdir3(presetsDir, { recursive: true });
   const copied = [];
   for (const preset of presets) {
-    const destPath = resolve7(presetsDir, preset.name);
+    const destPath = resolve8(presetsDir, preset.name);
     if (!force && await fileExists2(destPath)) {
       continue;
     }
     try {
-      const content = await readFile7(preset.sourcePath, "utf-8");
+      const content = await readFile8(preset.sourcePath, "utf-8");
       await writeFile3(destPath, content, "utf-8");
       copied.push(`.codeconductor/presets/${preset.name}`);
     } catch (err2) {
@@ -13918,7 +14123,7 @@ init_claude_installer();
 init_codex_installer();
 init_opencode_installer();
 import { homedir as homedir6 } from "node:os";
-import { resolve as resolve8 } from "node:path";
+import { resolve as resolve9 } from "node:path";
 init_file_writer();
 init_preset_loader();
 
@@ -13959,8 +14164,10 @@ async function installCommand(options) {
         }
       };
     }
+    const configResult = await loadConfig(projectRoot);
+    const config = configResult.success ? configResult.data : undefined;
     const spec = presetResult.data;
-    const writeOptions = { dryRun, force };
+    const writeOptions = { dryRun, force, config };
     const allFiles = [];
     for (const t of targets) {
       let installer;
@@ -13986,12 +14193,12 @@ async function installCommand(options) {
         let targetPath = f.path;
         let targetBase = baseDir;
         if ((t === "agy" || t === "gemini") && isGlobal) {
-          targetBase = resolve8(homedir6(), ".gemini", "config");
+          targetBase = resolve9(homedir6(), ".gemini", "config");
           targetPath = targetPath.replace(/^\.agents\/?/, "");
         }
         return {
           ...f,
-          path: resolve8(targetBase, targetPath)
+          path: resolve9(targetBase, targetPath)
         };
       });
       const results = await writeGeneratedFiles(resolvedFiles, writeOptions);
@@ -14102,7 +14309,7 @@ async function installPresetCommand(options) {
 
 // src/commands/install-lsp.command.ts
 import { homedir as homedir8 } from "node:os";
-import { resolve as resolve9 } from "node:path";
+import { resolve as resolve10 } from "node:path";
 
 // src/core/lsp/lsp-config-utils.ts
 function getLanguageServerConfig(lspIds) {
@@ -14627,7 +14834,9 @@ async function installLspCommand(options) {
     }
     const installer = createLspInstaller();
     const installReport = await installer.installAll(lsps, { dryRun });
-    const writeOptions = { dryRun, force };
+    const configResult = await loadConfig(projectRoot);
+    const config = configResult.success ? configResult.data : undefined;
+    const writeOptions = { dryRun, force, config };
     const allConfigResults = [];
     for (const t of targets) {
       const generator = getLspConfigGenerator(t);
@@ -14637,7 +14846,7 @@ async function installLspCommand(options) {
       const generatedFiles = generator.generate(installReport.results);
       const resolvedFiles = generatedFiles.map((f) => ({
         ...f,
-        path: resolve9(baseDir, f.path)
+        path: resolve10(baseDir, f.path)
       }));
       const results = await writeGeneratedFiles(resolvedFiles, writeOptions);
       for (const result of results) {
@@ -14729,9 +14938,278 @@ function getLspConfigGenerator(target) {
   }
 }
 
+// src/commands/debt-harvest.command.ts
+import { readdir as readdir2, readFile as readFile9, writeFile as writeFile5, mkdir as mkdir6 } from "node:fs/promises";
+import { join as join7, relative as relative2, extname } from "node:path";
+var DEFER_REGEX = /\/\/\s*defer\s*[-:]\s*(.+?)(?:\s*--(\w+))?\s*$/gm;
+var SOURCE_EXTENSIONS = new Set([
+  ".ts",
+  ".tsx",
+  ".js",
+  ".jsx",
+  ".mjs",
+  ".cjs",
+  ".go",
+  ".rs",
+  ".java",
+  ".kt",
+  ".swift",
+  ".cs",
+  ".php",
+  ".scala",
+  ".dart",
+  ".c",
+  ".cpp",
+  ".h",
+  ".hpp"
+]);
+async function walkDir(dir, extensions) {
+  const results = [];
+  try {
+    const entries = await readdir2(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      const fullPath = join7(dir, entry.name);
+      if (entry.isDirectory()) {
+        if (entry.name.startsWith(".") || entry.name === "node_modules")
+          continue;
+        results.push(...await walkDir(fullPath, extensions));
+      } else if (extensions.has(extname(entry.name))) {
+        results.push(fullPath);
+      }
+    }
+  } catch {}
+  return results;
+}
+function extractDefers(content, filePath) {
+  const entries = [];
+  const lines = content.split(`
+`);
+  for (let i = 0;i < lines.length; i++) {
+    const line = lines[i];
+    DEFER_REGEX.lastIndex = 0;
+    const match = DEFER_REGEX.exec(line);
+    if (match) {
+      entries.push({
+        file: filePath,
+        line: i + 1,
+        reason: match[1].trim(),
+        tag: match[2]
+      });
+    }
+  }
+  return entries;
+}
+function renderLedger(entries) {
+  const grouped = new Map;
+  for (const entry of entries) {
+    const tag = entry.tag ?? "unclassified";
+    const group = grouped.get(tag) ?? [];
+    group.push(entry);
+    grouped.set(tag, group);
+  }
+  const lines = [
+    "<!-- CODECONDUCTOR:BEGIN managed -->",
+    "",
+    "# Debt Ledger",
+    "",
+    "> Auto-generated by `codeconductor debt-harvest`. Do not edit manually.",
+    ""
+  ];
+  const sortedTags = [...grouped.keys()].sort();
+  for (const tag of sortedTags) {
+    const tagEntries = grouped.get(tag);
+    lines.push(`## ${tag}`);
+    lines.push("");
+    lines.push("| File | Line | Reason |");
+    lines.push("| ---- | ---- | ------ |");
+    for (const entry of tagEntries) {
+      lines.push(`| ${entry.file} | ${entry.line} | ${entry.reason} |`);
+    }
+    lines.push("");
+  }
+  lines.push("<!-- CODECONDUCTOR:END managed -->");
+  lines.push("");
+  return lines.join(`
+`);
+}
+async function debtHarvestCommand(options) {
+  const { projectRoot, dir = "src", output } = options;
+  try {
+    const targetDir = join7(projectRoot, dir);
+    const files = await walkDir(targetDir, SOURCE_EXTENSIONS);
+    const allEntries = [];
+    for (const file of files) {
+      const content = await readFile9(file, "utf-8");
+      const entries = extractDefers(content, relative2(projectRoot, file));
+      allEntries.push(...entries);
+    }
+    const ledgerDir = join7(projectRoot, ".codeconductor");
+    await mkdir6(ledgerDir, { recursive: true });
+    const ledgerPath = join7(ledgerDir, "debt-ledger.md");
+    const ledgerContent = renderLedger(allEntries);
+    await writeFile5(ledgerPath, ledgerContent, "utf-8");
+    if (output === "json") {
+      return {
+        code: 0,
+        data: {
+          success: true,
+          command: "debt-harvest",
+          entries: allEntries,
+          entryCount: allEntries.length,
+          ledger: ledgerPath
+        }
+      };
+    }
+    return {
+      code: 0,
+      data: {
+        success: true,
+        command: "debt-harvest",
+        message: `Found ${allEntries.length} deferred item(s) across ${files.length} file(s). Ledger written to ${ledgerPath}`,
+        entries: allEntries
+      }
+    };
+  } catch (error) {
+    return {
+      code: 1,
+      data: {
+        success: false,
+        command: "debt-harvest",
+        errors: [String(error)]
+      }
+    };
+  }
+}
+
+// src/commands/help.command.ts
+import { readdir as readdir3 } from "node:fs/promises";
+import { join as join8 } from "node:path";
+async function scanPresetDir(projectRoot, target) {
+  const inventory = {
+    target,
+    skills: [],
+    commands: [],
+    agents: [],
+    workflows: []
+  };
+  const presetDir = join8(projectRoot, "presets", target);
+  try {
+    const entries = await readdir3(presetDir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (entry.isDirectory()) {
+        const subDir = join8(presetDir, entry.name);
+        const subEntries = await readdir3(subDir, { withFileTypes: true });
+        for (const sub of subEntries) {
+          if (sub.isFile()) {
+            const itemName = sub.name.replace(/\.[^.]+$/, "");
+            if (entry.name === "skills")
+              inventory.skills.push(itemName);
+            else if (entry.name === "commands")
+              inventory.commands.push(itemName);
+            else if (entry.name === "agents")
+              inventory.agents.push(itemName);
+            else if (entry.name === "workflows")
+              inventory.workflows.push(itemName);
+          } else if (sub.isDirectory()) {
+            if (entry.name === "skills")
+              inventory.skills.push(sub.name);
+            else if (entry.name === "agents")
+              inventory.agents.push(sub.name);
+          }
+        }
+      }
+    }
+  } catch {}
+  return inventory;
+}
+function renderHuman(inventory, defaultTarget) {
+  const lines = [
+    `CodeConductor Help — ${inventory.target}${inventory.target === defaultTarget ? " (active)" : ""}`,
+    ""
+  ];
+  lines.push(`Skills (${inventory.skills.length}):`);
+  if (inventory.skills.length === 0) {
+    lines.push("  (none)");
+  } else {
+    for (const skill of inventory.skills.sort()) {
+      lines.push(`  - ${skill}`);
+    }
+  }
+  lines.push("");
+  lines.push(`Subagents (${inventory.agents.length}):`);
+  if (inventory.agents.length === 0) {
+    lines.push("  (none)");
+  } else {
+    for (const agent of inventory.agents.sort()) {
+      lines.push(`  - ${agent}`);
+    }
+  }
+  lines.push("");
+  lines.push(`Commands (${inventory.commands.length}):`);
+  if (inventory.commands.length === 0) {
+    lines.push("  (none)");
+  } else {
+    for (const cmd of inventory.commands.sort()) {
+      lines.push(`  - ${cmd}`);
+    }
+  }
+  if (inventory.workflows.length > 0) {
+    lines.push("");
+    lines.push(`Workflows (${inventory.workflows.length}):`);
+    for (const wf of inventory.workflows.sort()) {
+      lines.push(`  - ${wf}`);
+    }
+  }
+  return lines.join(`
+`);
+}
+async function helpCommand(options) {
+  const { projectRoot, target: overrideTarget, output } = options;
+  try {
+    let defaultTarget = "opencode";
+    try {
+      const configResult = await loadConfig(projectRoot);
+      if (configResult.success) {
+        defaultTarget = configResult.data.defaults.target;
+      }
+    } catch {}
+    const target = overrideTarget ?? defaultTarget;
+    const inventory = await scanPresetDir(projectRoot, target);
+    if (output === "json") {
+      return {
+        code: 0,
+        data: {
+          success: true,
+          command: "help",
+          inventory,
+          defaultTarget
+        }
+      };
+    }
+    return {
+      code: 0,
+      data: {
+        success: true,
+        command: "help",
+        message: renderHuman(inventory, defaultTarget),
+        inventory
+      }
+    };
+  } catch (error) {
+    return {
+      code: 1,
+      data: {
+        success: false,
+        command: "help",
+        errors: [String(error)]
+      }
+    };
+  }
+}
+
 // src/commands/seo-audit.command.ts
-import { writeFile as writeFile5, mkdir as mkdir6 } from "node:fs/promises";
-import { dirname as dirname4, resolve as resolve10 } from "node:path";
+import { writeFile as writeFile6, mkdir as mkdir7 } from "node:fs/promises";
+import { dirname as dirname4, resolve as resolve11 } from "node:path";
 
 // src/infrastructure/http/safe-fetch.ts
 import { lookup } from "node:dns/promises";
@@ -14818,7 +15296,7 @@ async function safeFetch(urlString, options = {}) {
   }
 }
 async function delay(ms) {
-  return new Promise((resolve10) => setTimeout(resolve10, ms));
+  return new Promise((resolve11) => setTimeout(resolve11, ms));
 }
 
 // src/infrastructure/parsers/sitemap-parser.ts
@@ -16022,14 +16500,14 @@ async function seoAuditCommand(options) {
         formattedOutput = formatCli(report);
     }
     if (output) {
-      const outputPath = resolve10(options.projectRoot, output);
-      await mkdir6(dirname4(outputPath), { recursive: true });
-      await writeFile5(outputPath, formattedOutput, "utf-8");
+      const outputPath = resolve11(options.projectRoot, output);
+      await mkdir7(dirname4(outputPath), { recursive: true });
+      await writeFile6(outputPath, formattedOutput, "utf-8");
     } else if (format === "markdown") {
       const timestamp = new Date().toISOString().replace(/[:.]/g, "-").slice(0, 19);
-      const defaultPath = resolve10(options.projectRoot, "seo-reports", `audit-report-${timestamp}.md`);
-      await mkdir6(dirname4(defaultPath), { recursive: true });
-      await writeFile5(defaultPath, formattedOutput, "utf-8");
+      const defaultPath = resolve11(options.projectRoot, "seo-reports", `audit-report-${timestamp}.md`);
+      await mkdir7(dirname4(defaultPath), { recursive: true });
+      await writeFile6(defaultPath, formattedOutput, "utf-8");
       process.stderr.write(`Report saved to: ${defaultPath}
 `);
     }
@@ -16041,7 +16519,7 @@ async function seoAuditCommand(options) {
         command: "seo audit",
         report,
         output: formattedOutput,
-        outputFile: output ? resolve10(options.projectRoot, output) : format === "markdown" ? resolve10(options.projectRoot, "seo-reports") : undefined
+        outputFile: output ? resolve11(options.projectRoot, output) : format === "markdown" ? resolve11(options.projectRoot, "seo-reports") : undefined
       }
     };
   } catch (error) {
@@ -16057,8 +16535,8 @@ 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 resolve11 } from "node:path";
+import { writeFile as writeFile7, mkdir as mkdir8 } from "node:fs/promises";
+import { dirname as dirname5, resolve as resolve12 } from "node:path";
 
 // src/domain/seo/llms-generator.ts
 function extractTitle2(html) {
@@ -16201,9 +16679,9 @@ async function seoLlmsCommand(options) {
       }
     }) : await generateLlmsTxtFromUrl(url);
     process.stderr.write("\r" + " ".repeat(80) + "\r");
-    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");
+    const outputPath = output ? resolve12(options.projectRoot, output) : resolve12(options.projectRoot, "llms.txt");
+    await mkdir8(dirname5(outputPath), { recursive: true });
+    await writeFile7(outputPath, result.content, "utf-8");
     process.stderr.write(`Generated: ${outputPath} (${result.entries.length} entries)
 `);
     return {
@@ -16230,8 +16708,8 @@ async function seoLlmsCommand(options) {
 
 // src/commands/update.command.ts
 import { homedir as homedir9 } 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";
+import { resolve as resolve13, dirname as dirname6 } from "node:path";
+import { mkdir as mkdir9, readFile as readFile10, writeFile as writeFile8, stat as stat3 } from "node:fs/promises";
 init_package_paths();
 async function updateCommand(options) {
   const { dryRun, force, global: isGlobal, output, projectRoot } = options;
@@ -16297,23 +16775,23 @@ async function updateCommand(options) {
     }
     const updated = [];
     if (updateResults.council) {
-      const localCouncil = resolve12(basePath, ".codeconductor", "presets", "council.yml");
-      const bundledCouncil = resolve12(SRC_PRESETS_DIR, "council", "council.yml");
+      const localCouncil = resolve13(basePath, ".codeconductor", "presets", "council.yml");
+      const bundledCouncil = resolve13(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");
+        const content = await readFile10(bundledCouncil, "utf-8");
+        await mkdir9(dirname6(localCouncil), { recursive: true });
+        await writeFile8(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");
+      const localPolicy = resolve13(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");
+        const content = await readFile10(POLICY_PATH, "utf-8");
+        await mkdir9(dirname6(localPolicy), { recursive: true });
+        await writeFile8(localPolicy, content, "utf-8");
         updated.push(localPolicy);
       } catch (e) {
         throw new Error(`Failed to update policy.yml: ${e}`);
@@ -16365,17 +16843,17 @@ async function updateCommand(options) {
                 let targetPath = f.path;
                 let targetBase = basePath;
                 if ((targetName === "agy" || targetName === "gemini") && isGlobal) {
-                  targetBase = resolve12(homedir9(), ".gemini", "config");
+                  targetBase = resolve13(homedir9(), ".gemini", "config");
                   targetPath = targetPath.replace(/^\.agents\/?/, "");
                 }
                 return {
                   ...f,
-                  path: resolve12(targetBase, targetPath)
+                  path: resolve13(targetBase, targetPath)
                 };
               });
               const filesToWrite = resolvedFiles.filter((f) => t.files.includes(f.path));
               if (filesToWrite.length > 0) {
-                const writeResults = await writeGeneratedFiles2(filesToWrite, { dryRun: false, force: true });
+                const writeResults = await writeGeneratedFiles2(filesToWrite, { dryRun: false, force: true, config });
                 for (const wr of writeResults) {
                   if (wr.success) {
                     updated.push(wr.path);
@@ -16398,19 +16876,19 @@ async function updateCommand(options) {
       for (const s of updateResults.skills) {
         newSkillsLock[s.id] = s.latestVersion;
       }
-      let lockDest = resolve12(basePath, ".codeconductor", "skills-lock.json");
+      let lockDest = resolve13(basePath, ".codeconductor", "skills-lock.json");
       try {
-        const statAgents = await stat3(resolve12(basePath, ".agents"));
+        const statAgents = await stat3(resolve13(basePath, ".agents"));
         if (statAgents.isDirectory()) {
-          const statCodeConductor = await stat3(resolve12(basePath, ".codeconductor")).catch(() => null);
+          const statCodeConductor = await stat3(resolve13(basePath, ".codeconductor")).catch(() => null);
           if (!statCodeConductor) {
-            lockDest = resolve12(basePath, ".agents", "skills-lock.json");
+            lockDest = resolve13(basePath, ".agents", "skills-lock.json");
           }
         }
       } catch {}
       try {
-        await mkdir8(dirname6(lockDest), { recursive: true });
-        await writeFile7(lockDest, JSON.stringify(newSkillsLock, null, 2), "utf-8");
+        await mkdir9(dirname6(lockDest), { recursive: true });
+        await writeFile8(lockDest, JSON.stringify(newSkillsLock, null, 2), "utf-8");
         updated.push(lockDest);
       } catch (e) {
         throw new Error(`Failed to write skills-lock.json: ${e}`);
@@ -16519,6 +16997,8 @@ Commands:
   seo llms               Generate llms.txt from a URL or sitemap
   doctor                 Validate configuration and generated files
   update                 Update installed presets
+  help / cc-help         Show preset inventory (skills, subagents, commands)
+  debt-harvest / harvest Scan source files for deferred debt items
 
 Options:
   --help, -h             Show this help message
@@ -16562,8 +17042,6 @@ Examples:
 async function routeCommand(args, projectRoot) {
   const { command, subcommand, options, flags } = args;
   switch (command) {
-    case "help":
-      return { code: 0, data: { help: getHelp() } };
     case "init":
       return initCommand({
         projectRoot,
@@ -16632,6 +17110,20 @@ async function routeCommand(args, projectRoot) {
         global: options.global === true || options.global === "true",
         output: flags.output
       });
+    case "help":
+    case "cc-help":
+      return helpCommand({
+        projectRoot,
+        target: options.target,
+        output: flags.output
+      });
+    case "debt-harvest":
+    case "harvest":
+      return debtHarvestCommand({
+        projectRoot,
+        dir: options.dir,
+        output: flags.output
+      });
     case "seo": {
       if (subcommand === "audit") {
         return seoAuditCommand({