cc-codeconductor 0.4.3 → 0.5.0

package/dist/index.js

@@ -11126,7 +11126,7 @@ function validateCouncilSpec(data) {
 function validateConfig(data) {
   return CodeConductorConfigSchema.parse(data);
 }
-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, MemoryPointerSchema, MemoryIndexSchema, GoalTaskSchema, GoalGraphSchema;
+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, MemoryPointerSchema, MemoryIndexSchema, GoalTaskSchema, GoalGraphSchema, BacklogStatusSchema, BacklogTypeSchema, BacklogPrioritySchema, BacklogGlobalSchema, BacklogItemSchema, BacklogDocumentSchema, OpenspecTaskCardPhaseSchema, OpenspecTaskCardStatusSchema, OpenspecTaskCardSchema, OpenspecStateSchema, ScorecardVerdictSchema, ScorecardCriterionIdSchema, ScorecardCriterionSchema, ScorecardRecordSchema, TaskOutcomeSourceSchema, TaskOutcomeStatusSchema, TaskOutcomeSchema, EvaluationIndexSchema, ExecutionProfileNameSchema, ExecutionProfileSchema;
 var init_schemas = __esm(() => {
   init_zod();
   CouncilAgentSpecSchema = exports_external.object({
@@ -11234,7 +11234,8 @@ var init_schemas = __esm(() => {
       codex: exports_external.string().optional(),
       gemini: exports_external.string().optional(),
       cursor: exports_external.string().optional(),
-      agy: exports_external.string().optional()
+      agy: exports_external.string().optional(),
+      grok: exports_external.string().optional()
     })),
     tools: exports_external.record(exports_external.string(), ToolProviderNamesSchema).optional(),
     permissions: PermissionProviderNamesSchema.optional()
@@ -11341,6 +11342,153 @@ var init_schemas = __esm(() => {
     tasks: exports_external.array(GoalTaskSchema),
     created_at: exports_external.string()
   });
+  BacklogStatusSchema = exports_external.enum([
+    "TODO",
+    "READY",
+    "PLANNED",
+    "IN_PROGRESS",
+    "BLOCKED",
+    "REVIEW",
+    "DONE"
+  ]);
+  BacklogTypeSchema = exports_external.enum(["feature", "bug", "refactor", "tech-debt"]);
+  BacklogPrioritySchema = exports_external.enum(["P0", "P1", "P2", "P3"]);
+  BacklogGlobalSchema = exports_external.object({
+    product: exports_external.string().min(1),
+    strategy: exports_external.string().min(1),
+    policy: exports_external.string().min(1),
+    reviewRequired: exports_external.boolean(),
+    tddRequired: exports_external.boolean()
+  });
+  BacklogItemSchema = exports_external.object({
+    id: exports_external.string().regex(/^BC-\d{3,}$/),
+    title: exports_external.string().min(1),
+    priority: BacklogPrioritySchema,
+    status: BacklogStatusSchema,
+    type: BacklogTypeSchema,
+    owner: exports_external.string().optional(),
+    dependencies: exports_external.array(exports_external.string()).default([]),
+    description: exports_external.string().min(1),
+    scope: exports_external.string().min(1),
+    outOfScope: exports_external.string().default(""),
+    businessValue: exports_external.string().optional(),
+    acceptanceCriteria: exports_external.array(exports_external.string().min(1)).min(1),
+    risks: exports_external.string().optional(),
+    progress: exports_external.number().int().min(0).max(100),
+    branch: exports_external.string().optional(),
+    reviewer: exports_external.string().optional(),
+    lastUpdate: exports_external.string().optional()
+  });
+  BacklogDocumentSchema = exports_external.object({
+    global: BacklogGlobalSchema,
+    items: exports_external.array(BacklogItemSchema),
+    archive: exports_external.array(BacklogItemSchema).default([])
+  });
+  OpenspecTaskCardPhaseSchema = exports_external.enum([
+    "discover",
+    "design",
+    "implement",
+    "test",
+    "review"
+  ]);
+  OpenspecTaskCardStatusSchema = exports_external.enum(["pending", "doing", "blocked", "done"]);
+  OpenspecTaskCardSchema = exports_external.object({
+    id: exports_external.string(),
+    backlogId: exports_external.string(),
+    phase: OpenspecTaskCardPhaseSchema,
+    title: exports_external.string(),
+    prompt: exports_external.string(),
+    agent: exports_external.string(),
+    modelHint: exports_external.string().optional(),
+    dependsOn: exports_external.array(exports_external.string()).default([]),
+    acceptanceCriteria: exports_external.array(exports_external.string()),
+    status: OpenspecTaskCardStatusSchema
+  });
+  OpenspecStateSchema = exports_external.object({
+    version: exports_external.literal(1),
+    activeItemId: exports_external.string().optional(),
+    taskCards: exports_external.array(OpenspecTaskCardSchema).default([]),
+    lastScanHash: exports_external.string().optional(),
+    lastScanAt: exports_external.string().optional(),
+    changePaths: exports_external.record(exports_external.string(), exports_external.string()).optional().default({}),
+    itemSnapshots: exports_external.record(exports_external.string(), exports_external.string()).optional().default({})
+  });
+  ScorecardVerdictSchema = exports_external.enum(["PASS", "REVISE", "REJECT"]);
+  ScorecardCriterionIdSchema = exports_external.enum([
+    "acceptance",
+    "minimal_diff",
+    "tests",
+    "regressions",
+    "conventions",
+    "documentation",
+    "context_discipline",
+    "cc_gain"
+  ]);
+  ScorecardCriterionSchema = exports_external.object({
+    id: ScorecardCriterionIdSchema,
+    label: exports_external.string(),
+    weight: exports_external.number().min(0).max(1),
+    score: exports_external.number().int().min(0).max(3),
+    notes: exports_external.string().optional(),
+    autoSuggested: exports_external.boolean().optional()
+  });
+  ScorecardRecordSchema = exports_external.object({
+    id: exports_external.string(),
+    taskId: exports_external.string(),
+    agent: exports_external.string(),
+    model: exports_external.string().optional(),
+    contractVersion: exports_external.string(),
+    evaluator: exports_external.string().optional(),
+    criteria: exports_external.array(ScorecardCriterionSchema),
+    weightedScore: exports_external.number(),
+    verdict: ScorecardVerdictSchema,
+    findings: exports_external.array(exports_external.string()).optional().default([]),
+    createdAt: exports_external.string(),
+    backlogId: exports_external.string().optional(),
+    source: exports_external.enum(["openspec", "review", "manual", "pipeline"]).optional()
+  });
+  TaskOutcomeSourceSchema = exports_external.enum(["openspec", "review", "manual", "pipeline"]);
+  TaskOutcomeStatusSchema = exports_external.enum([
+    "phase_done",
+    "phase_failed",
+    "pass",
+    "revise",
+    "reject"
+  ]);
+  TaskOutcomeSchema = exports_external.object({
+    id: exports_external.string(),
+    taskId: exports_external.string(),
+    source: TaskOutcomeSourceSchema,
+    agent: exports_external.string(),
+    model: exports_external.string(),
+    contractVersion: exports_external.string(),
+    timestamp: exports_external.string(),
+    status: TaskOutcomeStatusSchema.optional(),
+    verdict: ScorecardVerdictSchema.optional(),
+    weightedScore: exports_external.number().optional(),
+    taskCardId: exports_external.string().optional(),
+    backlogId: exports_external.string().optional(),
+    phase: exports_external.string().optional(),
+    scorecardId: exports_external.string().optional(),
+    tokensIn: exports_external.number().optional(),
+    tokensOut: exports_external.number().optional(),
+    costUsd: exports_external.number().optional(),
+    durationMs: exports_external.number().optional()
+  });
+  EvaluationIndexSchema = exports_external.object({
+    version: exports_external.literal(1),
+    lastOutcomeId: exports_external.string().optional()
+  });
+  ExecutionProfileNameSchema = exports_external.enum(["balanced", "quality", "economical"]);
+  ExecutionProfileSchema = exports_external.object({
+    profile: ExecutionProfileNameSchema.default("balanced"),
+    target: exports_external.enum(["opencode", "claude", "codex", "gemini", "cursor", "agy"]).optional(),
+    overrides: exports_external.record(exports_external.string(), exports_external.string()).optional().default({}),
+    subagentPolicy: exports_external.object({
+      orchestrator: exports_external.enum(["primary", "delegate"]).optional(),
+      testerReviewer: exports_external.enum(["primary", "delegate"]).optional()
+    }).optional()
+  });
 });
 
 // src/core/presets/package-paths.ts
@@ -12166,7 +12314,7 @@ init_errors();
 // package.json
 var package_default = {
   name: "cc-codeconductor",
-  version: "0.4.3",
+  version: "0.5.0",
   description: "A multi-agent orchestration framework for AI-assisted software engineering workflows.",
   keywords: [
     "ai",
@@ -12998,7 +13146,11 @@ function extractAgentRole(filePath) {
     "reviewer",
     "docs",
     "task-coach",
-    "repo-explorer"
+    "repo-explorer",
+    "complexity-auditor",
+    "security-reviewer",
+    "goal-planner",
+    "contract-builder"
   ];
   return knownRoles.includes(name) ? name : null;
 }
@@ -13074,7 +13226,7 @@ function renderTemplate(content, modelConfig, filePath, locale = "en") {
   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));
+    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(/\{\{MODEL_GROK\}\}/g, agentModels.grok ?? "").replace(new RegExp(LOCALE_PLACEHOLDER.replace(/[{}]/g, "\\$&"), "g"), getLanguageInstruction(locale));
     if (modelConfig.tools || modelConfig.permissions) {
       result2 = substituteToolNames(result2, modelConfig);
     }
@@ -13089,7 +13241,10 @@ function renderTemplate(content, modelConfig, filePath, locale = "en") {
     "reviewer",
     "docs",
     "repo-explorer",
-    "goal-planner"
+    "goal-planner",
+    "complexity-auditor",
+    "security-reviewer",
+    "contract-builder"
   ];
   let result = templatedContent;
   for (const role of knownRoles) {
@@ -13100,7 +13255,7 @@ function renderTemplate(content, modelConfig, filePath, locale = "en") {
     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 ?? "");
+        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 ?? "").replace(/\{\{MODEL_GROK\}\}/g, agentModels.grok ?? "");
         result = result.replace(section, renderedSection);
       }
     }
@@ -13932,7 +14087,7 @@ async function writeConfig(projectRoot, config = {}, force = false) {
 init_package_paths();
 
 // src/core/presets/preset-resolver.ts
-var CURRENT_PRESET_VERSION = "v0.4.0";
+var CURRENT_PRESET_VERSION = "v0.5.0";
 function resolvePreset(target, profile) {
   const stack = resolveStack(profile);
   const isMonorepo = profile.signals.some((s) => [
@@ -13995,17 +14150,17 @@ function resolveStack(profile) {
 function resolveAssets(target) {
   switch (target) {
     case "opencode":
-      return ["opencode.jsonc", "agents", "commands", "prompts/v0.4.0", "skills"];
+      return ["opencode.jsonc", "agents", "commands", "prompts/v0.5.0", "skills"];
     case "claude":
-      return ["CLAUDE.md", "settings.json", "commands", "skills", "agents", "prompts/v0.4.0"];
+      return ["CLAUDE.md", "settings.json", "commands", "skills", "agents", "prompts/v0.5.0"];
     case "codex":
-      return ["AGENTS.md", "skills", "prompts/v0.4.0"];
+      return ["AGENTS.md", "skills", "prompts/v0.5.0"];
     case "gemini":
-      return ["agents", "prompts/v0.4.0"];
+      return ["agents", "prompts/v0.5.0"];
     case "cursor":
-      return ["agents", "prompts/v0.4.0"];
+      return ["AGENTS.md", ".cursorignore", "rules", "commands", "skills", "agents", "prompts/v0.5.0"];
     case "agy":
-      return ["AGENTS.md", "rules", "workflows", "skills", "prompts/v0.4.0"];
+      return ["AGENTS.md", "rules", "workflows", "skills", "prompts/v0.5.0"];
   }
 }
 
@@ -14088,12 +14243,14 @@ async function initCommand(options) {
       };
     }
     const copiedPresets = await copyPresets(baseDir, presetsToCopy, force);
+    const openspecCreated = await initOpenspecArtifacts(baseDir, force);
+    const evalCreated = await initEvaluationArtifacts(baseDir, force);
     return {
       code: 0,
       data: {
         success: true,
         command: "init",
-        created: [".codeconductor/config.yml", ...copiedPresets],
+        created: [".codeconductor/config.yml", ...copiedPresets, ...openspecCreated, ...evalCreated],
         ...profile ? {
           detected: {
             languages: profile.languages,
@@ -14160,6 +14317,62 @@ async function fileExists2(path) {
     return false;
   }
 }
+async function initOpenspecArtifacts(baseDir, force) {
+  if (baseDir === homedir5())
+    return [];
+  const created = [];
+  const backlogDest = resolve7(baseDir, "BACKLOG.md");
+  const backlogTemplate = resolve7(ROOT_PRESETS_DIR, "templates", "BACKLOG.md");
+  if (force || !await fileExists2(backlogDest)) {
+    if (await fileExists2(backlogTemplate)) {
+      const content = await readFile8(backlogTemplate, "utf-8");
+      await writeFile3(backlogDest, content, "utf-8");
+      created.push("BACKLOG.md");
+    }
+  }
+  const stateDir = resolve7(baseDir, ".codeconductor");
+  await mkdir3(stateDir, { recursive: true });
+  const stateDest = resolve7(stateDir, "openspec-state.json");
+  if (force || !await fileExists2(stateDest)) {
+    const initialState = JSON.stringify({
+      version: 1,
+      taskCards: [],
+      changePaths: {},
+      itemSnapshots: {}
+    }, null, 2);
+    await writeFile3(stateDest, initialState, "utf-8");
+    created.push(".codeconductor/openspec-state.json");
+  }
+  return created;
+}
+async function initEvaluationArtifacts(baseDir, force) {
+  if (baseDir === homedir5())
+    return [];
+  const created = [];
+  const evalDir = resolve7(baseDir, ".codeconductor", "evaluation");
+  await mkdir3(evalDir, { recursive: true });
+  await mkdir3(resolve7(evalDir, "scorecards"), { recursive: true });
+  const indexPath = resolve7(evalDir, "index.json");
+  if (force || !await fileExists2(indexPath)) {
+    await writeFile3(indexPath, JSON.stringify({ version: 1 }, null, 2), "utf-8");
+    created.push(".codeconductor/evaluation/index.json");
+  }
+  const outcomesPath = resolve7(evalDir, "outcomes.jsonl");
+  if (force || !await fileExists2(outcomesPath)) {
+    await writeFile3(outcomesPath, "", "utf-8");
+    created.push(".codeconductor/evaluation/outcomes.jsonl");
+  }
+  const profileDest = resolve7(evalDir, "execution-profile.yml");
+  const profileTemplate = resolve7(ROOT_PRESETS_DIR, "templates", "execution-profile.yml");
+  if (force || !await fileExists2(profileDest)) {
+    if (await fileExists2(profileTemplate)) {
+      const content = await readFile8(profileTemplate, "utf-8");
+      await writeFile3(profileDest, content, "utf-8");
+      created.push(".codeconductor/evaluation/execution-profile.yml");
+    }
+  }
+  return created;
+}
 
 // src/commands/install.command.ts
 init_agy_installer();
@@ -15641,207 +15854,2326 @@ async function goalCommand(options) {
   }
 }
 
-// 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;
+// src/commands/openspec.command.ts
+import { readFile as readFile14, writeFile as writeFile9 } from "node:fs/promises";
+import { resolve as resolve15 } from "node:path";
+
+// src/core/openspec/backlog-parser.ts
+import { readFile as readFile11 } from "node:fs/promises";
+import { resolve as resolve11 } from "node:path";
+var BACKLOG_FILE = "BACKLOG.md";
+var ITEM_HEADER_RE = /^###\s+(?:\[[^\]]+\]\s*)*(BC-\d{3,})\s*(?:\||-)\s*(.+)$/i;
+var GLOBAL_SECTION_RE = /^##\s+Global\s*$/i;
+var ITEMS_SECTION_RE = /^##\s+Items\s*$/i;
+var ARCHIVE_SECTION_RE = /^##\s+Archive\s*$/i;
+var FIELD_RE = /^-\s+([^:]+):\s*(.*)$/;
+function parseBool(value) {
+  const v = value.trim().toLowerCase();
+  return v === "yes" || v === "true";
 }
-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}`);
+function parseDependencies(value) {
+  const v = value.trim().toLowerCase();
+  if (!v || v === "none")
+    return [];
+  return value.split(",").map((s) => s.trim()).filter((s) => s.length > 0);
+}
+function parseProgress(value) {
+  const match = value.trim().match(/^(\d+)%?$/);
+  if (!match)
+    return 0;
+  const n = parseInt(match[1], 10);
+  return Math.min(100, Math.max(0, n));
+}
+function parseAcceptanceLines(lines, startIndex) {
+  const criteria = [];
+  let i = startIndex;
+  while (i < lines.length) {
+    const line = lines[i];
+    if (line.match(/^-\s+\w+:/) || line.match(/^###\s+/) || line.match(/^##\s+/))
+      break;
+    const checkbox = line.match(/^(\s*)-\s+\[[ xX]\]\s*(.+)$/);
+    const bullet = line.match(/^(\s*)-\s+(.+)$/);
+    if (checkbox) {
+      criteria.push(checkbox[2].trim());
+      i++;
+    } else if (bullet && bullet[1].length > 0) {
+      criteria.push(bullet[2].trim());
+      i++;
+    } else if (line.trim() === "") {
+      i++;
+    } else {
+      break;
     }
   }
-  lines.push("");
-  lines.push("Stack-specific presets (v0.4.0):");
-  lines.push("  ts-next-drizzle     Next.js / Astro, Tailwind, Drizzle ORM, Bun, Postgres");
-  lines.push("  spring-kotlin-jpa   Spring Boot, Kotlin/Java, Gradle, JPA, Hibernate");
-  lines.push("  laravel-tall        Laravel, Blade, Livewire, Alpine.js");
-  lines.push("  python-data-api     Python, FastAPI, Django, uv");
-  lines.push("  Browse: presets/<preset-name>/agents/ — copy into the target runner.");
-  lines.push("  Registry: src/core/presets/preset-registry.ts (listPresets / getPreset).");
-  return lines.join(`
-`);
+  return { criteria, nextIndex: i };
 }
-async function helpCommand(options) {
-  const { projectRoot, target: overrideTarget, output } = options;
+function parseGlobalField(key, value, global) {
+  const k = key.trim().toLowerCase();
+  if (k === "product")
+    global.product = value.trim();
+  else if (k === "strategy")
+    global.strategy = value.trim();
+  else if (k === "policy")
+    global.policy = value.trim();
+  else if (k === "review required")
+    global.reviewRequired = parseBool(value);
+  else if (k === "tdd required")
+    global.tddRequired = parseBool(value);
+}
+function emptyItem(id, title) {
+  return {
+    id,
+    title,
+    priority: "P2",
+    status: "TODO",
+    type: "feature",
+    dependencies: [],
+    description: "",
+    scope: "",
+    outOfScope: "",
+    acceptanceCriteria: [],
+    progress: 0
+  };
+}
+function parseItemField(key, value, item, lines, lineIndex) {
+  const k = key.trim().toLowerCase();
+  if (k === "priority")
+    item.priority = value.trim();
+  else if (k === "status")
+    item.status = value.trim().toUpperCase();
+  else if (k === "type")
+    item.type = value.trim();
+  else if (k === "owner")
+    item.owner = value.trim();
+  else if (k === "depends on")
+    item.dependencies = parseDependencies(value);
+  else if (k === "description")
+    item.description = value.trim();
+  else if (k === "scope")
+    item.scope = value.trim();
+  else if (k === "out of scope")
+    item.outOfScope = value.trim();
+  else if (k === "business value")
+    item.businessValue = value.trim();
+  else if (k === "risks")
+    item.risks = value.trim();
+  else if (k === "progress")
+    item.progress = parseProgress(value);
+  else if (k === "branch")
+    item.branch = value.trim();
+  else if (k === "reviewer")
+    item.reviewer = value.trim();
+  else if (k === "last update")
+    item.lastUpdate = value.trim();
+  else if (k === "acceptance") {
+    const { criteria, nextIndex } = parseAcceptanceLines(lines, lineIndex + 1);
+    item.acceptanceCriteria = criteria;
+    return nextIndex - 1;
+  }
+  return lineIndex;
+}
+function parseBacklogMarkdown(content) {
   try {
-    let defaultTarget = "opencode";
-    try {
-      const configResult = await loadConfig(projectRoot);
-      if (configResult.success) {
-        defaultTarget = configResult.data.defaults.target;
+    const lines = content.split(`
+`);
+    let section = "none";
+    const global = {};
+    const items = [];
+    const archive = [];
+    let currentItem = null;
+    for (let i = 0;i < lines.length; i++) {
+      const line = lines[i];
+      if (GLOBAL_SECTION_RE.test(line)) {
+        section = "global";
+        currentItem = null;
+        continue;
       }
-    } 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
+      if (ITEMS_SECTION_RE.test(line)) {
+        section = "items";
+        currentItem = null;
+        continue;
       }
-    };
-  } catch (error) {
-    return {
-      code: 1,
-      data: {
-        success: false,
-        command: "help",
-        errors: [String(error)]
+      if (ARCHIVE_SECTION_RE.test(line)) {
+        section = "archive";
+        currentItem = null;
+        continue;
+      }
+      const headerMatch = line.match(ITEM_HEADER_RE);
+      if (headerMatch) {
+        const id = headerMatch[1].toUpperCase();
+        const title = headerMatch[2].trim();
+        currentItem = emptyItem(id, title);
+        if (section === "archive")
+          archive.push(currentItem);
+        else if (section === "items")
+          items.push(currentItem);
+        continue;
       }
+      const fieldMatch = line.match(FIELD_RE);
+      if (!fieldMatch)
+        continue;
+      const [, key, value] = fieldMatch;
+      if (section === "global") {
+        parseGlobalField(key, value, global);
+      } else if (currentItem && (section === "items" || section === "archive")) {
+        i = parseItemField(key, value, currentItem, lines, i);
+      }
+    }
+    if (!global.product || !global.strategy || !global.policy) {
+      return err(new Error("BACKLOG.md missing required Global fields (Product, Strategy, Policy)"));
+    }
+    const document = {
+      global: {
+        product: global.product,
+        strategy: global.strategy,
+        policy: global.policy,
+        reviewRequired: global.reviewRequired ?? true,
+        tddRequired: global.tddRequired ?? true
+      },
+      items,
+      archive
     };
+    return ok(document);
+  } catch (e) {
+    return err(e instanceof Error ? e : new Error(String(e)));
   }
 }
+async function loadBacklog(projectRoot) {
+  try {
+    const filePath = resolve11(projectRoot, BACKLOG_FILE);
+    const content = await readFile11(filePath, "utf-8");
+    return parseBacklogMarkdown(content);
+  } catch (e) {
+    return err(e instanceof Error ? e : new Error(String(e)));
+  }
+}
+var BACKLOG_FILENAME = BACKLOG_FILE;
 
-// src/commands/seo-audit.command.ts
-import { writeFile as writeFile7, mkdir as mkdir8 } 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";
-var PRIVATE_IP_RANGES = [
-  /^10\./,
-  /^172\.(1[6-9]|2\d|3[01])\./,
-  /^192\.168\./,
-  /^127\./,
-  /^0\./,
-  /^169\.254\./,
-  /^::1$/,
-  /^fc00:/i,
-  /^fe80:/i
+// src/core/openspec/backlog-validator.ts
+init_schemas();
+var VAGUE_PATTERNS = [
+  /^mejorar\s/i,
+  /^fix\s+bugs?$/i,
+  /^refactor$/i,
+  /^hacer\s+refactor/i,
+  /^arreglar\s+bugs?/i,
+  /^improve\s+ux$/i,
+  /^better\s+ux$/i,
+  /^cleanup$/i,
+  /^misc$/i
 ];
-function isPrivateIp(ip) {
-  return PRIVATE_IP_RANGES.some((range) => range.test(ip));
+function allItems(doc) {
+  return [...doc.items, ...doc.archive];
 }
-async function validateUrl(urlString) {
-  let parsed;
-  try {
-    parsed = new URL(urlString);
-  } catch {
-    throw new Error(`Invalid URL: ${urlString}`);
+function detectCycle(items) {
+  const ids = new Set(items.map((i) => i.id));
+  const graph = new Map;
+  for (const item of items) {
+    graph.set(item.id, item.dependencies.filter((d) => ids.has(d)));
   }
-  if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
-    throw new Error(`Blocked scheme: ${parsed.protocol}. Only http and https are allowed.`);
+  const visited = new Set;
+  const inStack = new Set;
+  function dfs(id) {
+    if (inStack.has(id))
+      return true;
+    if (visited.has(id))
+      return false;
+    visited.add(id);
+    inStack.add(id);
+    for (const dep of graph.get(id) ?? []) {
+      if (dfs(dep))
+        return true;
+    }
+    inStack.delete(id);
+    return false;
   }
-  const hostname = parsed.hostname;
-  if (hostname === "localhost" || hostname.endsWith(".localhost")) {
-    throw new Error(`Blocked hostname: ${hostname}`);
+  for (const id of ids) {
+    if (dfs(id))
+      return id;
   }
+  return null;
+}
+function isVagueCriterion(text) {
+  const t = text.trim();
+  if (t.length < 8)
+    return true;
+  return VAGUE_PATTERNS.some((p) => p.test(t));
+}
+function validateBacklog(doc) {
+  const errors3 = [];
+  const recommendations = [];
   try {
-    const addresses = await lookup(hostname, { all: true });
-    const addrList = Array.isArray(addresses) ? addresses : [addresses];
-    for (const addr of addrList) {
-      if (isPrivateIp(addr.address)) {
-        throw new Error(`SSRF blocked: ${hostname} resolves to private IP ${addr.address}`);
+    BacklogDocumentSchema.parse(doc);
+  } catch (e) {
+    errors3.push({
+      code: "SCHEMA",
+      message: e instanceof Error ? e.message : String(e)
+    });
+    return { valid: false, errors: errors3, recommendations: buildRecommendations(errors3) };
+  }
+  const all = allItems(doc);
+  const idCounts = new Map;
+  for (const item of all) {
+    idCounts.set(item.id, (idCounts.get(item.id) ?? 0) + 1);
+  }
+  for (const [id, count] of idCounts) {
+    if (count > 1) {
+      errors3.push({
+        code: "DUPLICATE_ID",
+        message: `Duplicate backlog ID "${id}"`,
+        itemId: id
+      });
+    }
+  }
+  const knownIds = new Set(all.map((i) => i.id));
+  for (const item of doc.items) {
+    if (!item.description.trim()) {
+      errors3.push({
+        code: "MISSING_DESCRIPTION",
+        message: `Item ${item.id} missing Description`,
+        itemId: item.id
+      });
+    }
+    if (!item.scope.trim()) {
+      errors3.push({
+        code: "MISSING_SCOPE",
+        message: `Item ${item.id} missing Scope`,
+        itemId: item.id
+      });
+    }
+    if (item.acceptanceCriteria.length === 0) {
+      errors3.push({
+        code: "MISSING_ACCEPTANCE",
+        message: `Item ${item.id} must have at least one Acceptance criterion`,
+        itemId: item.id
+      });
+    }
+    for (const criterion of item.acceptanceCriteria) {
+      if (isVagueCriterion(criterion)) {
+        errors3.push({
+          code: "VAGUE_ACCEPTANCE",
+          message: `Item ${item.id} has vague acceptance criterion: "${criterion}"`,
+          itemId: item.id
+        });
       }
     }
-  } catch (error) {
-    if (error instanceof Error && error.message.startsWith("SSRF blocked")) {
-      throw error;
+    for (const dep of item.dependencies) {
+      if (!knownIds.has(dep)) {
+        errors3.push({
+          code: "UNKNOWN_DEPENDENCY",
+          message: `Item ${item.id} depends on unknown ID "${dep}"`,
+          itemId: item.id
+        });
+      }
     }
-    throw new Error(`DNS resolution failed for ${hostname}: ${String(error)}`);
   }
-}
-async function safeFetch(urlString, options = {}) {
-  const { timeout = 1e4, followRedirects = false } = options;
-  await validateUrl(urlString);
-  const controller = new AbortController;
-  const timer = setTimeout(() => controller.abort(), timeout);
-  const start = Date.now();
-  try {
-    const response = await fetch(urlString, {
-      method: "GET",
-      signal: controller.signal,
-      redirect: followRedirects ? "follow" : "manual",
-      headers: {
-        "User-Agent": "CodeConductor-SEO/0.3.0",
-        Accept: "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8"
-      }
+  const cycleId = detectCycle(doc.items);
+  if (cycleId) {
+    errors3.push({
+      code: "DEPENDENCY_CYCLE",
+      message: `Dependency cycle detected involving ${cycleId}`,
+      itemId: cycleId
     });
-    const responseTime = Date.now() - start;
-    const body = await response.text();
+  }
+  if (doc.items.length === 0 && doc.archive.length === 0) {
+    recommendations.push("Add at least one item under ## Items with a unique BC-xxx ID.");
+  }
+  return {
+    valid: errors3.length === 0,
+    errors: errors3,
+    recommendations: buildRecommendations(errors3, recommendations)
+  };
+}
+function buildRecommendations(errors3, extra = []) {
+  const recs = [...extra];
+  if (errors3.some((e) => e.code === "SCHEMA" || e.code === "MISSING_ACCEPTANCE")) {
+    recs.push("Use the canonical BACKLOG.md format: ## Global, ## Items, ### BC-001 | Title, with Priority, Status, Type, Depends on, Description, Scope, Acceptance list.");
+  }
+  if (errors3.some((e) => e.code === "VAGUE_ACCEPTANCE")) {
+    recs.push('Acceptance criteria must be measurable (e.g. "openspec validate rejects malformed BACKLOG.md" not "improve UX").');
+  }
+  if (errors3.some((e) => e.code === "UNKNOWN_DEPENDENCY" || e.code === "DEPENDENCY_CYCLE")) {
+    recs.push("Ensure Depends on lists only existing BC-xxx IDs with no circular dependencies.");
+  }
+  if (errors3.some((e) => e.code === "DUPLICATE_ID")) {
+    recs.push("Each BC-xxx ID must appear only once across Items and Archive.");
+  }
+  return recs;
+}
+
+// src/core/openspec/backlog-scanner.ts
+import { execSync as execSync2 } from "node:child_process";
+import { readFile as readFile13 } from "node:fs/promises";
+import { resolve as resolve13 } from "node:path";
+
+// src/core/openspec/openspec-state.ts
+init_schemas();
+import { createHash } from "node:crypto";
+import { mkdir as mkdir8, readFile as readFile12, writeFile as writeFile7 } from "node:fs/promises";
+import { resolve as resolve12 } from "node:path";
+var STATE_FILE = ".codeconductor/openspec-state.json";
+async function loadOpenspecState(projectRoot) {
+  try {
+    const filePath = resolve12(projectRoot, STATE_FILE);
+    const content = await readFile12(filePath, "utf-8");
+    const data = JSON.parse(content);
+    return ok(OpenspecStateSchema.parse(data));
+  } catch (e) {
+    if (e.code === "ENOENT") {
+      return ok({
+        version: 1,
+        taskCards: [],
+        changePaths: {},
+        itemSnapshots: {}
+      });
+    }
+    return err(e instanceof Error ? e : new Error(String(e)));
+  }
+}
+async function writeOpenspecState(projectRoot, state) {
+  try {
+    const dir = resolve12(projectRoot, ".codeconductor");
+    await mkdir8(dir, { recursive: true });
+    const validated = OpenspecStateSchema.parse(state);
+    await writeFile7(resolve12(dir, "openspec-state.json"), JSON.stringify(validated, null, 2), "utf-8");
+    return ok(undefined);
+  } catch (e) {
+    return err(e instanceof Error ? e : new Error(String(e)));
+  }
+}
+function getNextTaskCard(state) {
+  const done = new Set(state.taskCards.filter((c) => c.status === "done").map((c) => c.id));
+  for (const card of state.taskCards) {
+    if (card.status === "done" || card.status === "blocked")
+      continue;
+    const depsOk = card.dependsOn.every((d) => done.has(d));
+    if (depsOk && card.status === "pending")
+      return card;
+  }
+  return null;
+}
+function hashContent(content) {
+  return createHash("sha256").update(content).digest("hex").slice(0, 16);
+}
+function updateBacklogItemInMarkdown(content, itemId, updates) {
+  const lines = content.split(`
+`);
+  let inTargetItem = false;
+  const idPattern = new RegExp(`^###\\s+.*${itemId}\\b`, "i");
+  for (let i = 0;i < lines.length; i++) {
+    const line = lines[i];
+    if (line.match(/^###\s+/)) {
+      inTargetItem = idPattern.test(line);
+      continue;
+    }
+    if (!inTargetItem)
+      continue;
+    if (updates.status && line.match(/^-\s+Status:/i)) {
+      lines[i] = `- Status: ${updates.status}`;
+    }
+    if (updates.progress !== undefined && line.match(/^-\s+Progress:/i)) {
+      lines[i] = `- Progress: ${updates.progress}%`;
+    }
+  }
+  return lines.join(`
+`);
+}
+
+// src/core/openspec/backlog-scanner.ts
+function itemSnapshot(items) {
+  const snap = {};
+  for (const item of items) {
+    snap[item.id] = JSON.stringify({
+      status: item.status,
+      progress: item.progress,
+      title: item.title
+    });
+  }
+  return snap;
+}
+async function scanBacklog(projectRoot, previousSnapshot = {}) {
+  try {
+    const filePath = resolve13(projectRoot, BACKLOG_FILENAME);
+    const content = await readFile13(filePath, "utf-8");
+    const hash = hashContent(content);
+    let fileChanged = true;
+    try {
+      const diff = execSync2(`git diff --name-only -- ${BACKLOG_FILENAME}`, {
+        cwd: projectRoot,
+        encoding: "utf-8",
+        stdio: ["ignore", "pipe", "ignore"]
+      });
+      fileChanged = diff.trim().length > 0;
+    } catch {
+      fileChanged = true;
+    }
+    const parseResult = parseBacklogMarkdown(content);
+    if (!parseResult.success)
+      return parseResult;
+    const doc = parseResult.data;
+    const current = itemSnapshot([...doc.items, ...doc.archive]);
+    const newItems = [];
+    const modifiedItems = [];
+    const closedItems = [];
+    for (const [id, snap] of Object.entries(current)) {
+      if (!previousSnapshot[id]) {
+        newItems.push(id);
+      } else if (previousSnapshot[id] !== snap) {
+        modifiedItems.push(id);
+      }
+    }
+    for (const id of Object.keys(previousSnapshot)) {
+      if (!current[id])
+        closedItems.push(id);
+    }
+    for (const item of doc.archive) {
+      if (!closedItems.includes(item.id))
+        closedItems.push(item.id);
+    }
+    for (const item of doc.items) {
+      if (item.status === "DONE" && !closedItems.includes(item.id)) {
+        closedItems.push(item.id);
+      }
+    }
+    return ok({
+      fileChanged,
+      contentHash: hash,
+      newItems,
+      modifiedItems,
+      closedItems
+    });
+  } catch (e) {
+    return err(e instanceof Error ? e : new Error(String(e)));
+  }
+}
+function buildItemSnapshot(items, archive) {
+  return itemSnapshot([...items, ...archive]);
+}
+
+// src/core/openspec/agent-router.ts
+var PHASE_ROUTES = {
+  discover: { agent: "repo-explorer", modelKey: "repo-explorer" },
+  design: { agent: "architect", modelKey: "architect" },
+  implement: { agent: "implementer", modelKey: "implementer" },
+  test: { agent: "tester", modelKey: "tester" },
+  review: { agent: "reviewer", modelKey: "reviewer" }
+};
+function routePhaseToAgent(phase) {
+  return PHASE_ROUTES[phase];
+}
+
+// src/core/openspec/backlog-planner.ts
+var DEFAULT_PHASE_ORDER = [
+  "discover",
+  "design",
+  "implement",
+  "test",
+  "review"
+];
+var TDD_PHASE_ORDER = [
+  "discover",
+  "design",
+  "test",
+  "implement",
+  "review"
+];
+function slugify(title) {
+  return title.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 48);
+}
+function phaseTitle(phase, item) {
+  const labels = {
+    discover: "Discover scope and impact",
+    design: "Technical design",
+    implement: "Implementation",
+    test: "Test coverage",
+    review: "Review and validation"
+  };
+  return `${item.id}: ${labels[phase]}`;
+}
+function phasePrompt(phase, item) {
+  const base = `Backlog item ${item.id} — ${item.title}
+
+Description: ${item.description}
+Scope: ${item.scope}`;
+  switch (phase) {
+    case "discover":
+      return `${base}
+
+Map repository structure, conventions, and impact radius for this change.`;
+    case "design":
+      return `${base}
+
+Produce a Technical Plan with approach, files affected, risks, and edge cases.`;
+    case "test":
+      return `${base}
+
+Write TDD tests covering acceptance criteria before or after implementation per project policy.`;
+    case "implement":
+      return `${base}
+
+Implement the minimal diff to satisfy tests and acceptance criteria.`;
+    case "review":
+      return `${base}
+
+Verify acceptance criteria, test coverage, scope alignment, and code quality.`;
+  }
+}
+function phaseAcceptance(phase, item) {
+  switch (phase) {
+    case "discover":
+      return ["Repo map identifies relevant files and impact radius"];
+    case "design":
+      return ["Technical plan lists files affected and approach"];
+    case "test":
+      return item.acceptanceCriteria.map((c) => `Test covers: ${c}`);
+    case "implement":
+      return item.acceptanceCriteria;
+    case "review":
+      return [
+        "All acceptance criteria verified",
+        "Tests pass",
+        "No scope creep beyond backlog item"
+      ];
+  }
+}
+function getPhaseOrder(doc) {
+  return doc.global.tddRequired ? [...TDD_PHASE_ORDER] : [...DEFAULT_PHASE_ORDER];
+}
+function planTaskCardsForItem(item, doc, existingCards = []) {
+  const phases = getPhaseOrder(doc);
+  const cards = [];
+  let prevId;
+  for (const phase of phases) {
+    const id = `${item.id}-${phase}`;
+    const existing = existingCards.find((c) => c.id === id);
+    const route = routePhaseToAgent(phase);
+    const dependsOn = prevId ? [prevId] : [];
+    cards.push({
+      id,
+      backlogId: item.id,
+      phase,
+      title: phaseTitle(phase, item),
+      prompt: phasePrompt(phase, item),
+      agent: route.agent,
+      modelHint: route.modelKey,
+      dependsOn,
+      acceptanceCriteria: phaseAcceptance(phase, item),
+      status: existing?.status ?? "pending"
+    });
+    prevId = id;
+  }
+  return cards;
+}
+function comparePriority(a, b) {
+  const order = { P0: 0, P1: 1, P2: 2, P3: 3 };
+  return order[a.priority] - order[b.priority];
+}
+function selectNextItem(doc, itemId) {
+  const doneOrArchived = new Set(doc.archive.map((i) => i.id).concat(doc.items.filter((i) => i.status === "DONE").map((i) => i.id)));
+  const candidates = doc.items.filter((i) => {
+    if (itemId)
+      return i.id === itemId;
+    if (doneOrArchived.has(i.id))
+      return false;
+    return i.status === "READY" || i.status === "PLANNED" || i.status === "IN_PROGRESS";
+  }).sort(comparePriority);
+  for (const item of candidates) {
+    const depsOk = item.dependencies.every((dep) => {
+      const depItem = doc.items.find((i) => i.id === dep) ?? doc.archive.find((i) => i.id === dep);
+      return depItem?.status === "DONE" || doc.archive.some((a) => a.id === dep);
+    });
+    if (depsOk)
+      return item;
+  }
+  return null;
+}
+function buildChangeSlug(item) {
+  const num = item.id.replace(/^BC-/i, "").toLowerCase();
+  const slug = slugify(item.title);
+  return `bc-${num}-${slug}`;
+}
+
+// src/core/openspec/openspec-generator.ts
+import { mkdir as mkdir9, writeFile as writeFile8 } from "node:fs/promises";
+import { resolve as resolve14 } from "node:path";
+function proposalContent(item) {
+  return `# Proposal: ${item.title}
+
+## Why
+
+${item.description}
+
+${item.businessValue ? `**Business value:** ${item.businessValue}` : ""}
+
+## What Changes
+
+- ${item.scope}
+
+## Capabilities
+
+- **New Capabilities:** (to be refined in design phase)
+- **Modified Capabilities:** (to be refined in design phase)
+
+## Impact
+
+${item.risks ? `Risks: ${item.risks}` : "See design.md for technical impact."}
+
+**Out of scope:** ${item.outOfScope || "None specified."}
+`;
+}
+function designPlaceholder(item) {
+  return `# Design: ${item.title}
+
+## Approach
+
+(To be completed in design phase.)
+
+## Files Affected
+
+${item.scope}
+
+## Acceptance Criteria
+
+${item.acceptanceCriteria.map((c) => `- ${c}`).join(`
+`)}
+`;
+}
+function tasksContent(cards) {
+  const implCards = cards.filter((c) => c.phase === "implement" || c.phase === "test");
+  const lines = ["# Implementation Tasks", ""];
+  for (const card of implCards) {
+    const checked = card.status === "done" ? "x" : " ";
+    lines.push(`- [${checked}] ${card.title} (${card.id})`);
+  }
+  if (implCards.length === 0) {
+    lines.push("- [ ] Implementation tasks (generated after plan)");
+  }
+  return lines.join(`
+`);
+}
+async function generateOpenspecChange(projectRoot, item, taskCards) {
+  const slug = buildChangeSlug(item);
+  const changeDir = resolve14(projectRoot, "openspec", "changes", slug);
+  await mkdir9(resolve14(changeDir, "specs"), { recursive: true });
+  await writeFile8(resolve14(changeDir, "proposal.md"), proposalContent(item), "utf-8");
+  await writeFile8(resolve14(changeDir, "design.md"), designPlaceholder(item), "utf-8");
+  await writeFile8(resolve14(changeDir, "tasks.md"), tasksContent(taskCards), "utf-8");
+  const specStub = `# Delta Spec: ${item.title}
+
+## ADDED Requirements
+
+${item.acceptanceCriteria.map((c) => `- ${c}`).join(`
+`)}
+`;
+  await writeFile8(resolve14(changeDir, "specs", "delta.md"), specStub, "utf-8");
+  return `openspec/changes/${slug}`;
+}
+async function ensureOpenspecConfig(projectRoot) {
+  const configPath = resolve14(projectRoot, "openspec", "config.yaml");
+  try {
+    const { access: access6 } = await import("node:fs/promises");
+    await access6(configPath);
+  } catch {
+    await mkdir9(resolve14(projectRoot, "openspec"), { recursive: true });
+    const stub = `# OpenSpec project config (CodeConductor native compatible)
+schema: spec-driven
+`;
+    await writeFile8(configPath, stub, "utf-8");
+  }
+}
+
+// src/commands/openspec.command.ts
+async function openspecCommand(options) {
+  const { subcommand, itemId, projectRoot, output } = options;
+  switch (subcommand) {
+    case "validate":
+      return handleValidate(projectRoot);
+    case "scan":
+      return handleScan(projectRoot);
+    case "plan":
+      return handlePlan(projectRoot, itemId);
+    case "status":
+      return handleStatus(projectRoot);
+    case "next":
+      return handleNext(projectRoot);
+    default:
+      return {
+        code: 1,
+        data: {
+          success: false,
+          command: "openspec",
+          errors: [
+            `Unknown subcommand: ${subcommand}. Use: validate, scan, plan, status, next`
+          ]
+        }
+      };
+  }
+}
+async function handleValidate(projectRoot) {
+  const loadResult = await loadBacklog(projectRoot);
+  if (!loadResult.success) {
+    return {
+      code: 1,
+      data: {
+        success: false,
+        command: "openspec validate",
+        errors: [loadResult.error.message],
+        recommendations: [
+          "Create BACKLOG.md at project root using the CodeConductor template."
+        ]
+      }
+    };
+  }
+  const report = validateBacklog(loadResult.data);
+  return {
+    code: report.valid ? 0 : 1,
+    data: {
+      success: report.valid,
+      command: "openspec validate",
+      valid: report.valid,
+      errors: report.errors.map((e) => e.message),
+      recommendations: report.recommendations,
+      itemCount: loadResult.data.items.length,
+      archiveCount: loadResult.data.archive.length
+    }
+  };
+}
+async function handleScan(projectRoot) {
+  const stateResult = await loadOpenspecState(projectRoot);
+  const prevSnap = stateResult.success ? stateResult.data.itemSnapshots ?? {} : {};
+  const scanResult = await scanBacklog(projectRoot, prevSnap);
+  if (!scanResult.success) {
+    return {
+      code: 1,
+      data: {
+        success: false,
+        command: "openspec scan",
+        errors: [scanResult.error.message]
+      }
+    };
+  }
+  const loadResult = await loadBacklog(projectRoot);
+  if (loadResult.success && stateResult.success) {
+    const snapshots = buildItemSnapshot(loadResult.data.items, loadResult.data.archive);
+    const state = {
+      ...stateResult.data,
+      lastScanHash: scanResult.data.contentHash,
+      lastScanAt: new Date().toISOString(),
+      itemSnapshots: snapshots
+    };
+    await writeOpenspecState(projectRoot, state);
+  }
+  return {
+    code: 0,
+    data: {
+      success: true,
+      command: "openspec scan",
+      ...scanResult.data
+    }
+  };
+}
+async function handlePlan(projectRoot, itemId) {
+  const validateFirst = await handleValidate(projectRoot);
+  if (validateFirst.code !== 0)
+    return validateFirst;
+  const loadResult = await loadBacklog(projectRoot);
+  if (!loadResult.success) {
+    return { code: 1, data: { success: false, errors: [loadResult.error.message] } };
+  }
+  const doc = loadResult.data;
+  const item = selectNextItem(doc, itemId);
+  if (!item) {
+    return {
+      code: 1,
+      data: {
+        success: false,
+        command: "openspec plan",
+        errors: [
+          itemId ? `Item ${itemId} not found or not eligible` : "No READY backlog item with satisfied dependencies"
+        ]
+      }
+    };
+  }
+  const stateResult = await loadOpenspecState(projectRoot);
+  const existingState = stateResult.success ? stateResult.data : {
+    version: 1,
+    taskCards: [],
+    changePaths: {},
+    itemSnapshots: {}
+  };
+  const taskCards = planTaskCardsForItem(item, doc, existingState.taskCards);
+  await ensureOpenspecConfig(projectRoot);
+  const changePath = await generateOpenspecChange(projectRoot, item, taskCards);
+  const newState = {
+    ...existingState,
+    version: 1,
+    activeItemId: item.id,
+    taskCards,
+    changePaths: {
+      ...existingState.changePaths,
+      [item.id]: changePath
+    }
+  };
+  await writeOpenspecState(projectRoot, newState);
+  const backlogPath = resolve15(projectRoot, BACKLOG_FILENAME);
+  let content = await readFile14(backlogPath, "utf-8");
+  content = updateBacklogItemInMarkdown(content, item.id, {
+    status: "PLANNED",
+    progress: item.progress
+  });
+  await writeFile9(backlogPath, content, "utf-8");
+  return {
+    code: 0,
+    data: {
+      success: true,
+      command: "openspec plan",
+      itemId: item.id,
+      title: item.title,
+      changePath,
+      taskCards
+    }
+  };
+}
+async function handleStatus(projectRoot) {
+  const loadResult = await loadBacklog(projectRoot);
+  const stateResult = await loadOpenspecState(projectRoot);
+  const nextItem = loadResult.success ? selectNextItem(loadResult.data) : null;
+  const state = stateResult.success ? stateResult.data : null;
+  const pendingCards = state?.taskCards.filter((c) => c.status === "pending").length ?? 0;
+  const doneCards = state?.taskCards.filter((c) => c.status === "done").length ?? 0;
+  return {
+    code: 0,
+    data: {
+      success: true,
+      command: "openspec status",
+      activeItemId: state?.activeItemId,
+      nextItemId: nextItem?.id,
+      nextItemTitle: nextItem?.title,
+      taskCardsPending: pendingCards,
+      taskCardsDone: doneCards,
+      changePaths: state?.changePaths ?? {}
+    }
+  };
+}
+async function handleNext(projectRoot) {
+  const stateResult = await loadOpenspecState(projectRoot);
+  if (!stateResult.success) {
+    return {
+      code: 1,
+      data: {
+        success: false,
+        command: "openspec next",
+        errors: [stateResult.error.message]
+      }
+    };
+  }
+  const next = getNextTaskCard(stateResult.data);
+  if (!next) {
+    return {
+      code: 0,
+      data: {
+        success: true,
+        command: "openspec next",
+        taskCard: null,
+        message: "No pending task cards. Run openspec plan first."
+      }
+    };
+  }
+  return {
+    code: 0,
+    data: {
+      success: true,
+      command: "openspec next",
+      taskCard: next
+    }
+  };
+}
+
+// src/commands/scorecard.command.ts
+import { readFile as readFile19 } from "node:fs/promises";
+import { resolve as resolve21 } from "node:path";
+
+// src/core/evaluation/scorecard-constants.ts
+var SCORECARD_CRITERIA_DEF = [
+  { id: "acceptance", label: "Acceptance criteria met", weight: 0.3 },
+  { id: "minimal_diff", label: "Minimal diff (no scope creep)", weight: 0.2 },
+  { id: "tests", label: "Tests present and passing", weight: 0.15 },
+  { id: "regressions", label: "No regressions introduced", weight: 0.15 },
+  { id: "conventions", label: "Code follows project conventions", weight: 0.1 },
+  { id: "documentation", label: "Documentation updated if required", weight: 0.05 },
+  { id: "context_discipline", label: "Context discipline", weight: 0.05 },
+  { id: "cc_gain", label: "Complexity diffusion (cc-gain)", weight: 0.05 }
+];
+
+// src/core/evaluation/scorecard-calculator.ts
+var PASS_THRESHOLD = 2;
+function createDefaultCriteria(overrides = {}) {
+  return SCORECARD_CRITERIA_DEF.map((def) => {
+    const o = overrides[def.id];
+    return {
+      id: def.id,
+      label: def.label,
+      weight: def.weight,
+      score: o?.score ?? 2,
+      notes: o?.notes,
+      autoSuggested: o?.autoSuggested
+    };
+  });
+}
+function computeWeightedScore(criteria) {
+  let total = 0;
+  for (const c of criteria) {
+    total += c.score * c.weight;
+  }
+  return Math.round(total * 1000) / 1000;
+}
+function computeVerdict(criteria, weightedScore) {
+  const byId = new Map(criteria.map((c) => [c.id, c.score]));
+  const acceptance = byId.get("acceptance") ?? 0;
+  const minimalDiff = byId.get("minimal_diff") ?? 0;
+  const regressions = byId.get("regressions") ?? 0;
+  if (acceptance === 0 || minimalDiff === 0 || regressions === 0) {
+    return "REJECT";
+  }
+  if (weightedScore < 1.5) {
+    return "REJECT";
+  }
+  if (weightedScore >= PASS_THRESHOLD && !criteria.some((c) => c.score === 0)) {
+    return "PASS";
+  }
+  return "REVISE";
+}
+function buildScorecardRecord(params) {
+  const weightedScore = computeWeightedScore(params.criteria);
+  const verdict = computeVerdict(params.criteria, weightedScore);
+  return {
+    id: params.id,
+    taskId: params.taskId,
+    agent: params.agent,
+    model: params.model,
+    contractVersion: params.contractVersion,
+    evaluator: params.evaluator,
+    criteria: params.criteria,
+    weightedScore,
+    verdict,
+    findings: params.findings ?? [],
+    createdAt: new Date().toISOString(),
+    backlogId: params.backlogId,
+    source: params.source
+  };
+}
+
+// src/core/evaluation/outcome-store.ts
+init_schemas();
+import { appendFile, mkdir as mkdir10, readFile as readFile15, writeFile as writeFile10 } from "node:fs/promises";
+import { resolve as resolve16 } from "node:path";
+var EVAL_DIR = ".codeconductor/evaluation";
+var OUTCOMES_FILE = "outcomes.jsonl";
+var SCORECARDS_DIR = "scorecards";
+var INDEX_FILE = "index.json";
+async function ensureEvaluationDir(projectRoot) {
+  const dir = resolve16(projectRoot, EVAL_DIR);
+  await mkdir10(dir, { recursive: true });
+  await mkdir10(resolve16(dir, SCORECARDS_DIR), { recursive: true });
+  return dir;
+}
+async function appendOutcome(projectRoot, outcome) {
+  try {
+    const dir = await ensureEvaluationDir(projectRoot);
+    const validated = TaskOutcomeSchema.parse(outcome);
+    await appendFile(resolve16(dir, OUTCOMES_FILE), JSON.stringify(validated) + `
+`, "utf-8");
+    const indexPath = resolve16(dir, INDEX_FILE);
+    let index = { version: 1, lastOutcomeId: validated.id };
+    try {
+      const raw = await readFile15(indexPath, "utf-8");
+      index = EvaluationIndexSchema.parse(JSON.parse(raw));
+      index.lastOutcomeId = validated.id;
+    } catch {}
+    await writeFile10(indexPath, JSON.stringify(index, null, 2), "utf-8");
+    return ok(undefined);
+  } catch (e) {
+    return err(e instanceof Error ? e : new Error(String(e)));
+  }
+}
+async function listOutcomes(projectRoot, filter = {}) {
+  try {
+    const path = resolve16(projectRoot, EVAL_DIR, OUTCOMES_FILE);
+    const content = await readFile15(path, "utf-8");
+    const lines = content.split(`
+`).filter((l) => l.trim().length > 0);
+    const outcomes = [];
+    for (const line of lines) {
+      const parsed = TaskOutcomeSchema.parse(JSON.parse(line));
+      if (filter.agent && parsed.agent !== filter.agent)
+        continue;
+      if (filter.model && parsed.model !== filter.model)
+        continue;
+      if (filter.taskId && parsed.taskId !== filter.taskId)
+        continue;
+      if (filter.backlogId && parsed.backlogId !== filter.backlogId)
+        continue;
+      if (filter.source && parsed.source !== filter.source)
+        continue;
+      if (filter.since && parsed.timestamp < filter.since)
+        continue;
+      outcomes.push(parsed);
+    }
+    return ok(outcomes);
+  } catch (e) {
+    if (e.code === "ENOENT") {
+      return ok([]);
+    }
+    return err(e instanceof Error ? e : new Error(String(e)));
+  }
+}
+async function saveScorecard(projectRoot, record) {
+  try {
+    const dir = await ensureEvaluationDir(projectRoot);
+    const validated = ScorecardRecordSchema.parse(record);
+    const filePath = resolve16(dir, SCORECARDS_DIR, `${validated.id}.json`);
+    await writeFile10(filePath, JSON.stringify(validated, null, 2), "utf-8");
+    return ok(filePath);
+  } catch (e) {
+    return err(e instanceof Error ? e : new Error(String(e)));
+  }
+}
+async function loadScorecard(projectRoot, id) {
+  try {
+    const filePath = resolve16(projectRoot, EVAL_DIR, SCORECARDS_DIR, `${id}.json`);
+    const content = await readFile15(filePath, "utf-8");
+    return ok(ScorecardRecordSchema.parse(JSON.parse(content)));
+  } catch (e) {
+    return err(e instanceof Error ? e : new Error(String(e)));
+  }
+}
+function aggregateOutcomes(outcomes) {
+  const withScore = outcomes.filter((o) => o.weightedScore !== undefined);
+  const passed = outcomes.filter((o) => o.verdict === "PASS" || o.status === "pass");
+  const avgWeightedScore = withScore.length > 0 ? withScore.reduce((s, o) => s + (o.weightedScore ?? 0), 0) / withScore.length : 0;
+  const byAgent = {};
+  const byModel = {};
+  for (const o of outcomes) {
+    if (!byAgent[o.agent])
+      byAgent[o.agent] = { count: 0, avgScore: 0 };
+    byAgent[o.agent].count++;
+    if (o.weightedScore !== undefined) {
+      byAgent[o.agent].avgScore += o.weightedScore;
+    }
+    if (!byModel[o.model])
+      byModel[o.model] = { count: 0, avgScore: 0 };
+    byModel[o.model].count++;
+    if (o.weightedScore !== undefined)
+      byModel[o.model].avgScore += o.weightedScore;
+    if (o.costUsd !== undefined) {
+      byModel[o.model].avgCost = (byModel[o.model].avgCost ?? 0) + o.costUsd;
+    }
+    const tokens = (o.tokensIn ?? 0) + (o.tokensOut ?? 0);
+    if (tokens > 0) {
+      byModel[o.model].avgTokens = (byModel[o.model].avgTokens ?? 0) + tokens;
+    }
+  }
+  for (const agent of Object.keys(byAgent)) {
+    const entry = byAgent[agent];
+    entry.avgScore = entry.count > 0 ? entry.avgScore / entry.count : 0;
+  }
+  for (const model of Object.keys(byModel)) {
+    const entry = byModel[model];
+    entry.avgScore = entry.count > 0 ? entry.avgScore / entry.count : 0;
+    if (entry.avgCost !== undefined)
+      entry.avgCost /= entry.count;
+    if (entry.avgTokens !== undefined)
+      entry.avgTokens /= entry.count;
+  }
+  return {
+    total: outcomes.length,
+    passRate: outcomes.length > 0 ? passed.length / outcomes.length : 0,
+    avgWeightedScore: Math.round(avgWeightedScore * 1000) / 1000,
+    byAgent,
+    byModel
+  };
+}
+function generateEvalId(prefix) {
+  const ts = Date.now().toString(36);
+  const rand = Math.random().toString(36).slice(2, 6);
+  return `${prefix}-${ts}-${rand}`;
+}
+
+// src/core/evaluation/scorecard-signals.ts
+import { execSync as execSync3 } from "node:child_process";
+
+// src/core/complexity/complexity-auditor.ts
+var DIFF_FILE_REGEX = /^\+\+\+ b\/(.+)$/;
+var HUNK_HEADER_REGEX = /^@@ -\d+(?:,\d+)? \+(\d+)(?:,\d+)? @@/;
+function parseDiffHunks(diffContent) {
+  const lines = diffContent.split(`
+`);
+  const hunks = [];
+  let current = null;
+  for (const line of lines) {
+    const fileMatch = line.match(DIFF_FILE_REGEX);
+    if (fileMatch) {
+      current = { file: fileMatch[1], addedLines: [], removedLines: [] };
+      hunks.push(current);
+      continue;
+    }
+    if (HUNK_HEADER_REGEX.test(line)) {
+      if (current) {
+        const newHunk = {
+          file: current.file,
+          addedLines: [],
+          removedLines: []
+        };
+        hunks.push(newHunk);
+        current = newHunk;
+      }
+      continue;
+    }
+    if (!current)
+      continue;
+    if (line.startsWith("+") && !line.startsWith("+++")) {
+      current.addedLines.push(line.slice(1));
+    } else if (line.startsWith("-") && !line.startsWith("---")) {
+      current.removedLines.push(line.slice(1));
+    }
+  }
+  return hunks;
+}
+function countNonEmptyLines(lines) {
+  return lines.filter((l) => l.trim().length > 0).length;
+}
+function analyzeLoc(hunks) {
+  let added = 0;
+  let removed = 0;
+  for (const hunk of hunks) {
+    added += countNonEmptyLines(hunk.addedLines);
+    removed += countNonEmptyLines(hunk.removedLines);
+  }
+  return { added, removed };
+}
+var IMPORT_REGEX = /^import\s+(?:.*from\s+)?['"]([^'"]+)['"]/;
+var REQUIRE_REGEX = /require\s*\(\s*['"]([^'"]+)['"]\s*\)/;
+var NODE_BUILTINS = new Set([
+  "assert",
+  "buffer",
+  "child_process",
+  "cluster",
+  "console",
+  "constants",
+  "crypto",
+  "dgram",
+  "dns",
+  "domain",
+  "events",
+  "fs",
+  "http",
+  "http2",
+  "https",
+  "inspector",
+  "module",
+  "net",
+  "os",
+  "path",
+  "perf_hooks",
+  "process",
+  "punycode",
+  "querystring",
+  "readline",
+  "repl",
+  "stream",
+  "string_decoder",
+  "sys",
+  "timers",
+  "tls",
+  "trace_events",
+  "tty",
+  "url",
+  "util",
+  "v8",
+  "vm",
+  "worker_threads",
+  "zlib"
+]);
+function isExternalDep(specifier) {
+  const cleaned = specifier.replace(/^node:/, "");
+  if (cleaned.startsWith(".") || cleaned.startsWith("/"))
+    return false;
+  const pkg = cleaned.startsWith("@") ? cleaned.split("/").slice(0, 2).join("/") : cleaned.split("/")[0];
+  return !NODE_BUILTINS.has(pkg);
+}
+function analyzeDeps(hunks) {
+  const added = [];
+  const removed = [];
+  for (const hunk of hunks) {
+    for (const line of hunk.addedLines) {
+      const match = line.match(IMPORT_REGEX) || line.match(REQUIRE_REGEX);
+      if (match && isExternalDep(match[1])) {
+        added.push({ name: match[1], type: "import", file: hunk.file });
+      }
+    }
+    for (const line of hunk.removedLines) {
+      const match = line.match(IMPORT_REGEX) || line.match(REQUIRE_REGEX);
+      if (match && isExternalDep(match[1])) {
+        removed.push({ name: match[1], type: "import", file: hunk.file });
+      }
+    }
+  }
+  return { added, removed };
+}
+var COMPLEXITY_KEYWORDS = [
+  /\bif\s*\(/,
+  /\belse\s+if\b/,
+  /\bfor\s*\(/,
+  /\bwhile\s*\(/,
+  /\bswitch\s*\(/,
+  /\bcase\s+/,
+  /\bcatch\s*\(/,
+  /\b\?\s*[^.]/,
+  /&&/,
+  /\|\|/
+];
+function countComplexityKeywords(lines) {
+  let count = 0;
+  for (const line of lines) {
+    for (const regex of COMPLEXITY_KEYWORDS) {
+      if (regex.test(line))
+        count++;
+    }
+  }
+  return count;
+}
+function analyzeComplexity(hunks) {
+  let added = 0;
+  let removed = 0;
+  for (const hunk of hunks) {
+    added += countComplexityKeywords(hunk.addedLines);
+    removed += countComplexityKeywords(hunk.removedLines);
+  }
+  return { added, removed };
+}
+function detectBloatPatterns(hunks) {
+  const findings = [];
+  for (const hunk of hunks) {
+    const allLines = [...hunk.addedLines];
+    for (let i = 0;i < allLines.length; i++) {
+      const line = allLines[i];
+      const lineNum = i + 1;
+      if (/^\s*export\s+interface\s+\w+/.test(line)) {
+        const hasSingleImpl = hunk.addedLines.some((l) => /implements\s+\w+/.test(l) || /implements\s+\{/.test(l));
+        if (hasSingleImpl) {
+          findings.push({
+            severity: "warning",
+            pattern: "single-implementation-interface",
+            file: hunk.file,
+            line: lineNum,
+            message: "Interface with only one implementation — consider a concrete class",
+            action: "delete"
+          });
+        }
+      }
+      if (/^\s*(export\s+)?(async\s+)?function\s+(\w+)/.test(line)) {
+        const funcBody = allLines.slice(i + 1, i + 5).join(`
+`);
+        if (/return\s+\w+\s*\(/.test(funcBody) && funcBody.split(`
+`).filter((l) => l.trim()).length <= 3) {
+          findings.push({
+            severity: "info",
+            pattern: "trivial-wrapper",
+            file: hunk.file,
+            line: lineNum,
+            message: "Function appears to be a trivial wrapper — callers could invoke directly",
+            action: "delete"
+          });
+        }
+      }
+      if (/^\s*(export\s+)?class\s+(\w+)/.test(line)) {
+        const classBlock = allLines.slice(i + 1, i + 20).join(`
+`);
+        const methodCount = (classBlock.match(/\b(method|get\s+\w+|set\s+\w+)\s*\(/g) || []).length;
+        if (methodCount <= 1) {
+          findings.push({
+            severity: "warning",
+            pattern: "one-method-class",
+            file: hunk.file,
+            line: lineNum,
+            message: "Class with only one method — a function may suffice",
+            action: "delete"
+          });
+        }
+      }
+      if (/^\s*import\s+(\w+)/.test(line)) {
+        const importedName = line.match(/import\s+(\w+)/)?.[1];
+        if (importedName) {
+          const restOfFile = allLines.join(`
+`);
+          const afterImport = allLines.slice(i + 1).join(`
+`);
+          if (!afterImport.includes(importedName)) {
+            findings.push({
+              severity: "info",
+              pattern: "unused-import",
+              file: hunk.file,
+              line: lineNum,
+              message: `Import "${importedName}" does not appear used in added code`,
+              action: "delete"
+            });
+          }
+        }
+      }
+      if (/^\s*import\s+.*from\s+['"]/.test(line)) {
+        const depMatch = line.match(/from\s+['"]([^'"]+)['"]/);
+        if (depMatch && isExternalDep(depMatch[1])) {
+          const pkg = depMatch[1].startsWith("@") ? depMatch[1].split("/").slice(0, 2).join("/") : depMatch[1].split("/")[0];
+          if (NATIVE_REPLACEMENTS.has(pkg)) {
+            findings.push({
+              severity: "warning",
+              pattern: "external-dep-for-native",
+              file: hunk.file,
+              line: lineNum,
+              message: `"${pkg}" can be replaced with native: ${NATIVE_REPLACEMENTS.get(pkg)}`,
+              action: "replace-native"
+            });
+          }
+        }
+      }
+      if (/^\s*(export\s+)?(abstract\s+)?class\s+(\w+).*extends\s+(\w+)/.test(line)) {
+        findings.push({
+          severity: "info",
+          pattern: "excessive-abstraction",
+          file: hunk.file,
+          line: lineNum,
+          message: "Deep class hierarchy — consider composition over inheritance",
+          action: "delete"
+        });
+      }
+    }
+  }
+  return findings;
+}
+var NATIVE_REPLACEMENTS = new Map([
+  ["lodash", "Array/Object native methods"],
+  ["lodash-es", "Array/Object native methods"],
+  ["underscore", "Array/Object native methods"],
+  ["moment", "Intl.DateTimeFormat, Date.parse, Temporal API"],
+  ["date-fns", "Intl.DateTimeFormat, Date methods"],
+  ["axios", "node:https or fetch()"],
+  ["node-fetch", "node:https or global fetch"],
+  ["uuid", "crypto.randomUUID()"],
+  ["qs", "URLSearchParams"],
+  ["semver", "node:semver (stdlib)"],
+  ["chalk", "ANSI escape codes"]
+]);
+function analyzeDiff(diffContent) {
+  const hunks = parseDiffHunks(diffContent);
+  const loc = analyzeLoc(hunks);
+  const deps = analyzeDeps(hunks);
+  const complexity = analyzeComplexity(hunks);
+  const findings = detectBloatPatterns(hunks);
+  return {
+    locAdded: loc.added,
+    locRemoved: loc.removed,
+    locDelta: loc.added - loc.removed,
+    depsAdded: deps.added,
+    depsRemoved: deps.removed,
+    depsDelta: deps.added.length - deps.removed.length,
+    cyclomaticAdded: complexity.added,
+    cyclomaticRemoved: complexity.removed,
+    cyclomaticDelta: complexity.added - complexity.removed,
+    findings
+  };
+}
+
+// src/core/complexity/cc-gain.ts
+function computeCcGain(report) {
+  const locContribution = report.locRemoved * 0.4;
+  const depsAvoided = report.depsRemoved.length - report.depsAdded.length;
+  const depContribution = depsAvoided * 1.5;
+  const complexityReduced = report.cyclomaticRemoved - report.cyclomaticAdded;
+  const complexityContribution = complexityReduced * 2;
+  const abstractionFindings = report.findings.filter((f) => f.pattern === "excessive-abstraction" || f.pattern === "single-implementation-interface" || f.pattern === "one-method-class" || f.pattern === "trivial-wrapper").length;
+  const abstractionPenalty = abstractionFindings * 1;
+  const raw = locContribution + depContribution + complexityContribution - abstractionPenalty;
+  const MAX_RAW = 50;
+  const normalized = Math.max(-1, Math.min(1, raw / MAX_RAW));
+  const verdict = normalized > 0.05 ? "positive" : normalized < -0.05 ? "negative" : "neutral";
+  return {
+    raw,
+    normalized,
+    verdict,
+    breakdown: {
+      locContribution,
+      depContribution,
+      complexityContribution,
+      abstractionPenalty
+    }
+  };
+}
+function ccGainToScorecardImpact(result) {
+  if (result.verdict === "negative")
+    return 0;
+  if (result.verdict === "neutral")
+    return 1;
+  if (result.raw >= 10)
+    return 3;
+  return 2;
+}
+
+// src/core/evaluation/scorecard-signals.ts
+function collectScorecardSignals(projectRoot, scopeFiles) {
+  const findings = [];
+  const overrides = {};
+  let diff = "";
+  try {
+    diff = execSync3("git diff HEAD", {
+      cwd: projectRoot,
+      encoding: "utf-8",
+      stdio: ["ignore", "pipe", "ignore"]
+    });
+  } catch {
+    findings.push("Could not read git diff; scope audit skipped.");
+    return { criteriaOverrides: overrides, findings };
+  }
+  if (!diff.trim()) {
+    overrides.minimal_diff = { score: 2, notes: "No diff detected", autoSuggested: true };
+    return { criteriaOverrides: overrides, findings };
+  }
+  const changedFiles = new Set;
+  for (const line of diff.split(`
+`)) {
+    const m = line.match(/^\+\+\+ b\/(.+)$/);
+    if (m)
+      changedFiles.add(m[1]);
+  }
+  if (scopeFiles && scopeFiles.length > 0) {
+    const outOfScope = [...changedFiles].filter((f) => !scopeFiles.some((s) => f.includes(s.replace(/\*\*/g, ""))));
+    if (outOfScope.length > 0) {
+      overrides.minimal_diff = {
+        score: 0,
+        notes: `Files outside scope: ${outOfScope.slice(0, 5).join(", ")}`,
+        autoSuggested: true
+      };
+      findings.push(`Scope creep detected in ${outOfScope.length} file(s).`);
+    } else {
+      overrides.minimal_diff = { score: 2, notes: "Diff within declared scope", autoSuggested: true };
+    }
+  }
+  try {
+    const report = analyzeDiff(diff);
+    const gain = computeCcGain(report);
+    const ccScore = ccGainToScorecardImpact(gain);
+    overrides.cc_gain = {
+      score: ccScore,
+      notes: `cc-gain raw=${gain.raw}, verdict=${gain.verdict}`,
+      autoSuggested: true
+    };
+    if (report.findings.length > 0) {
+      findings.push(`Complexity auditor: ${report.findings.length} finding(s).`);
+    }
+  } catch {
+    findings.push("Complexity audit skipped.");
+  }
+  return { criteriaOverrides: overrides, findings };
+}
+function criteriaFromSignals(hints) {
+  return createDefaultCriteria(hints.criteriaOverrides);
+}
+
+// src/core/evaluation/execution-profile.ts
+init_dist();
+import { readFile as readFile16 } from "node:fs/promises";
+import { resolve as resolve17 } from "node:path";
+init_schemas();
+var PROFILE_FILE = ".codeconductor/evaluation/execution-profile.yml";
+var PROFILE_AGENT_OVERRIDES = {
+  balanced: {},
+  quality: {
+    architect: "strong",
+    reviewer: "strong",
+    orchestrator: "strong"
+  },
+  economical: {
+    "repo-explorer": "economical",
+    tester: "economical",
+    docs: "economical",
+    "task-coach": "economical"
+  }
+};
+var ECONOMICAL_AGENTS = new Set([
+  "repo-explorer",
+  "tester",
+  "docs",
+  "task-coach",
+  "goal-planner"
+]);
+var STRONG_AGENTS = new Set(["architect", "reviewer", "orchestrator"]);
+async function loadExecutionProfile(projectRoot, defaultTarget = "opencode") {
+  try {
+    const content = await readFile16(resolve17(projectRoot, PROFILE_FILE), "utf-8");
+    const data = $parse(content);
+    return ExecutionProfileSchema.parse(data);
+  } catch {
+    return ExecutionProfileSchema.parse({ profile: "balanced", target: defaultTarget });
+  }
+}
+function pickModelForAgent(modelConfig, target, agentKey, profile) {
+  const agents = modelConfig.agents[agentKey];
+  if (!agents)
+    return;
+  const override = PROFILE_AGENT_OVERRIDES[profile][agentKey];
+  if (override === "economical" && ECONOMICAL_AGENTS.has(agentKey)) {}
+  if (override === "strong" && STRONG_AGENTS.has(agentKey)) {}
+  const t = target ?? modelConfig.target;
+  return agents[t] ?? agents.opencode ?? agents.claude ?? Object.values(agents).find((v) => v !== undefined);
+}
+async function resolvePhaseModels(projectRoot, target) {
+  try {
+    const profile = await loadExecutionProfile(projectRoot, target);
+    const effectiveTarget = profile.target ?? target ?? "opencode";
+    const modelConfig = await loadModelConfig(effectiveTarget);
+    const phases = [
+      "discover",
+      "design",
+      "test",
+      "implement",
+      "review"
+    ];
+    const delegateTesterReviewer = profile.subagentPolicy?.testerReviewer === "delegate" || profile.profile === "economical";
+    const resolved = [];
+    for (const phase of phases) {
+      const route = routePhaseToAgent(phase);
+      const overrideModel = profile.overrides?.[route.agent] ?? profile.overrides?.[route.modelKey];
+      const model = overrideModel ?? pickModelForAgent(modelConfig, effectiveTarget, route.modelKey, profile.profile) ?? "unknown";
+      const subagentDelegate = (route.agent === "tester" || route.agent === "reviewer") && delegateTesterReviewer;
+      resolved.push({
+        phase,
+        agent: route.agent,
+        model,
+        modelKey: route.modelKey,
+        subagentDelegate
+      });
+    }
+    return ok(resolved);
+  } catch (e) {
+    return err(e instanceof Error ? e : new Error(String(e)));
+  }
+}
+
+// src/core/evaluation/prompt-diff.ts
+init_package_paths();
+import { readFile as readFile17, readdir as readdir3 } from "node:fs/promises";
+import { join as join8, resolve as resolve18 } from "node:path";
+function normalizeVersion(v) {
+  return v.startsWith("v") ? v : `v${v}`;
+}
+async function listPromptFiles(dir) {
+  try {
+    const entries = await readdir3(dir, { withFileTypes: true });
+    return entries.filter((e) => e.isFile() && e.name.endsWith(".md")).map((e) => e.name);
+  } catch {
+    return [];
+  }
+}
+function lineDiff(oldText, newText, path) {
+  const oldLines = oldText.split(`
+`);
+  const newLines = newText.split(`
+`);
+  const hunks = [];
+  let added = 0;
+  let removed = 0;
+  const max = Math.max(oldLines.length, newLines.length);
+  for (let i = 0;i < max; i++) {
+    const o = oldLines[i];
+    const n = newLines[i];
+    if (o === n)
+      continue;
+    if (o === undefined) {
+      added++;
+      hunks.push(`+ ${n}`);
+    } else if (n === undefined) {
+      removed++;
+      hunks.push(`- ${o}`);
+    } else {
+      removed++;
+      added++;
+      hunks.push(`- ${o}`);
+      hunks.push(`+ ${n}`);
+    }
+  }
+  if (hunks.length > 0) {
+    hunks.unshift(`### ${path}`);
+  }
+  return { added, removed, hunks };
+}
+async function diffPromptVersions(fromVersion, toVersion, options = {}) {
+  const target = options.target ?? "opencode";
+  const fromV = normalizeVersion(fromVersion);
+  const toV = normalizeVersion(toVersion);
+  const searchRoots = [
+    resolve18(options.projectRoot ?? PACKAGE_ROOT, ".agents", "prompts"),
+    join8(ROOT_PRESETS_DIR, target, "prompts"),
+    join8(ROOT_PRESETS_DIR, "opencode", "prompts")
+  ];
+  let fromDir = "";
+  let toDir = "";
+  for (const root of searchRoots) {
+    const f = join8(root, fromV);
+    const t = join8(root, toV);
+    try {
+      await readFile17(join8(f, "orchestrator.md"), "utf-8");
+      fromDir = f;
+      toDir = t;
+      break;
+    } catch {}
+  }
+  if (!fromDir) {
+    fromDir = join8(ROOT_PRESETS_DIR, "opencode", "prompts", fromV);
+    toDir = join8(ROOT_PRESETS_DIR, "opencode", "prompts", toV);
+  } else {
+    try {
+      await readFile17(join8(toDir, "orchestrator.md"), "utf-8");
+    } catch {
+      toDir = join8(ROOT_PRESETS_DIR, "opencode", "prompts", toV);
+    }
+  }
+  const fromFiles = await listPromptFiles(fromDir);
+  const toFiles = await listPromptFiles(toDir);
+  const allNames = new Set([...fromFiles, ...toFiles]);
+  if (options.agent) {
+    const agentFile = `${options.agent}.md`;
+    if (allNames.has(agentFile)) {
+      allNames.clear();
+      allNames.add(agentFile);
+    }
+  }
+  const files = [];
+  for (const name of allNames) {
+    let oldText = "";
+    let newText = "";
+    try {
+      oldText = await readFile17(join8(fromDir, name), "utf-8");
+    } catch {
+      oldText = "";
+    }
+    try {
+      newText = await readFile17(join8(toDir, name), "utf-8");
+    } catch {
+      newText = "";
+    }
+    const { added, removed, hunks } = lineDiff(oldText, newText, name);
+    files.push({
+      path: name,
+      changed: oldText !== newText,
+      addedLines: added,
+      removedLines: removed,
+      hunks
+    });
+  }
+  return { fromVersion: fromV, toVersion: toV, target, files };
+}
+function formatPromptDiffMarkdown(result) {
+  const lines = [
+    `# Prompt diff: ${result.fromVersion} → ${result.toVersion}`,
+    "",
+    `Target: ${result.target}`,
+    ""
+  ];
+  const changed = result.files.filter((f) => f.changed);
+  lines.push(`Changed files: ${changed.length} / ${result.files.length}`, "");
+  for (const f of changed) {
+    lines.push(`## ${f.path} (+${f.addedLines} -${f.removedLines})`, "");
+    lines.push(...f.hunks.slice(0, 40));
+    if (f.hunks.length > 40)
+      lines.push("... (truncated)");
+    lines.push("");
+  }
+  return lines.join(`
+`);
+}
+
+// src/core/evaluation/regression-checklist.ts
+init_dist();
+init_package_paths();
+import { execSync as execSync4 } from "node:child_process";
+import { readFile as readFile18, writeFile as writeFile11 } from "node:fs/promises";
+import { resolve as resolve19 } from "node:path";
+async function loadRegressionChecklist() {
+  try {
+    const path = resolve19(ROOT_PRESETS_DIR, "templates", "regression-checklist.yml");
+    const content = await readFile18(path, "utf-8");
+    const data = $parse(content);
+    return data.checks ?? [];
+  } catch {
+    return [
+      { id: "doctor_config", command: "npx cc-codeconductor doctor", required: false }
+    ];
+  }
+}
+async function runRegressionChecklist(projectRoot, options = {}) {
+  try {
+    const defs = await loadRegressionChecklist();
+    const checks = [];
+    for (const def of defs) {
+      if (def.type === "diff_scope") {
+        checks.push({
+          id: def.id,
+          required: def.required ?? false,
+          passed: true,
+          message: "diff_scope check requires task context; skipped in CLI (manual in workflow)"
+        });
+        continue;
+      }
+      const cmd = options.command && def.id === "tests_pass" ? options.command : def.command;
+      if (!cmd)
+        continue;
+      try {
+        execSync4(cmd, {
+          cwd: projectRoot,
+          encoding: "utf-8",
+          stdio: ["ignore", "pipe", "pipe"],
+          timeout: 120000
+        });
+        checks.push({
+          id: def.id,
+          required: def.required ?? true,
+          passed: true,
+          message: `Command succeeded: ${cmd}`
+        });
+      } catch (e) {
+        const msg = e instanceof Error ? e.message : String(e);
+        checks.push({
+          id: def.id,
+          required: def.required ?? true,
+          passed: false,
+          message: `Command failed: ${cmd} — ${msg.slice(0, 200)}`
+        });
+      }
+    }
+    const report = {
+      passed: checks.every((c) => !c.required || c.passed),
+      checks,
+      timestamp: new Date().toISOString()
+    };
+    const outPath = resolve19(projectRoot, ".codeconductor/evaluation/regression-last.json");
+    await writeFile11(outPath, JSON.stringify(report, null, 2), "utf-8");
+    return ok(report);
+  } catch (e) {
+    return err(e instanceof Error ? e : new Error(String(e)));
+  }
+}
+
+// src/core/evaluation/model-comparison.ts
+function generateModelComparisonMarkdown(outcomes, modelsFilter) {
+  const agg = aggregateOutcomes(outcomes);
+  const models = modelsFilter ?? Object.keys(agg.byModel);
+  const lines = [
+    "# Model Comparison Report",
+    "",
+    `Generated: ${new Date().toISOString()}`,
+    "",
+    "| Model | Tasks | Pass % | Avg score | Avg tokens | Avg cost |",
+    "|-------|-------|--------|-----------|------------|----------|"
+  ];
+  for (const model of models) {
+    const entry = agg.byModel[model];
+    if (!entry)
+      continue;
+    const modelOutcomes = outcomes.filter((o) => o.model === model);
+    const passed = modelOutcomes.filter((o) => o.verdict === "PASS" || o.status === "pass");
+    const passPct = modelOutcomes.length > 0 ? passed.length / modelOutcomes.length * 100 : 0;
+    lines.push(`| ${model} | ${entry.count} | ${passPct.toFixed(0)}% | ${entry.avgScore.toFixed(2)} | ${entry.avgTokens?.toFixed(0) ?? "—"} | ${entry.avgCost?.toFixed(4) ?? "—"} |`);
+  }
+  lines.push("", "## Notes", "", "- Cost and tokens are optional; reported by agents or CLI flags.");
+  return lines.join(`
+`);
+}
+
+// src/core/evaluation/cost-quality-matrix.ts
+init_dist();
+import { writeFile as writeFile12 } from "node:fs/promises";
+import { resolve as resolve20 } from "node:path";
+async function buildCostQualityMatrix(projectRoot, outcomes) {
+  const agg = aggregateOutcomes(outcomes);
+  const rows = Object.entries(agg.byModel).map(([model, entry]) => {
+    const modelOutcomes = outcomes.filter((o) => o.model === model);
+    const passed = modelOutcomes.filter((o) => o.verdict === "PASS" || o.status === "pass");
+    return {
+      model,
+      taskCount: entry.count,
+      passRate: modelOutcomes.length > 0 ? passed.length / modelOutcomes.length : 0,
+      avgWeightedScore: entry.avgScore,
+      avgTokens: entry.avgTokens,
+      avgCostUsd: entry.avgCost
+    };
+  });
+  const matrix = {
+    generatedAt: new Date().toISOString(),
+    rows
+  };
+  const dir = await ensureEvaluationDir(projectRoot);
+  await writeFile12(resolve20(dir, "matrix.yml"), $stringify(matrix), "utf-8");
+  return matrix;
+}
+function formatMatrixMarkdown(matrix) {
+  const lines = [
+    "# Cost / Quality Matrix",
+    "",
+    `Generated: ${matrix.generatedAt}`,
+    "",
+    "| Model | Tasks | Pass rate | Avg score | Avg tokens | Avg cost USD |",
+    "|-------|-------|-----------|-----------|------------|--------------|"
+  ];
+  for (const row of matrix.rows) {
+    lines.push(`| ${row.model} | ${row.taskCount} | ${(row.passRate * 100).toFixed(0)}% | ${row.avgWeightedScore.toFixed(2)} | ${row.avgTokens?.toFixed(0) ?? "—"} | ${row.avgCostUsd?.toFixed(4) ?? "—"} |`);
+  }
+  return lines.join(`
+`);
+}
+
+// src/commands/scorecard.command.ts
+function contractVersion() {
+  return package_default.version;
+}
+async function scorecardCommand(options) {
+  const { subcommand, projectRoot } = options;
+  switch (subcommand) {
+    case "create":
+      return handleCreate(projectRoot, options);
+    case "show":
+      return handleShow(projectRoot, options.id);
+    case "record":
+      return handleRecord(projectRoot, options);
+    case "list":
+      return handleList(projectRoot, options);
+    case "aggregate":
+      return handleAggregate(projectRoot, options);
+    case "models":
+      return handleModels(projectRoot, options.profile);
+    case "prompt-diff":
+      return handlePromptDiff(projectRoot, options);
+    case "regression":
+      return handleRegression(projectRoot);
+    case "matrix":
+      return handleMatrix(projectRoot);
+    case "compare-models":
+      return handleCompareModels(projectRoot, options);
+    default:
+      return {
+        code: 1,
+        data: {
+          success: false,
+          command: "scorecard",
+          errors: [
+            `Unknown subcommand: ${subcommand}. Use: create, show, record, list, aggregate, models, prompt-diff, regression, matrix, compare-models`
+          ]
+        }
+      };
+  }
+}
+async function handleCreate(projectRoot, options) {
+  const taskId = options.taskId ?? "unknown-task";
+  const agent = options.agent ?? "reviewer";
+  let criteria = createDefaultCriteria();
+  let findings = [];
+  if (options.fromDiff) {
+    let scopeFiles;
+    const backlog = await loadBacklog(projectRoot);
+    if (backlog.success && options.taskId) {
+      const item = backlog.data.items.find((i) => i.id === options.taskId);
+      if (item) {
+        scopeFiles = item.scope.split(/[,;]/).map((s) => s.trim()).filter(Boolean);
+      }
+    }
+    const hints = collectScorecardSignals(projectRoot, scopeFiles);
+    criteria = criteriaFromSignals(hints);
+    findings = hints.findings;
+  }
+  const id = generateEvalId("sc");
+  const configResult = await loadConfig(projectRoot);
+  const target = configResult.success ? configResult.data.defaults.target : "opencode";
+  const modelResult = await resolvePhaseModels(projectRoot, target);
+  const model = options.model ?? (modelResult.success ? modelResult.data.find((r) => r.agent === agent)?.model : undefined);
+  const record = buildScorecardRecord({
+    id,
+    taskId,
+    agent,
+    contractVersion: contractVersion(),
+    criteria,
+    model,
+    findings,
+    backlogId: options.taskId?.startsWith("BC-") ? options.taskId : undefined,
+    source: options.source ?? "manual"
+  });
+  const save = await saveScorecard(projectRoot, record);
+  if (!save.success) {
+    return { code: 1, data: { success: false, errors: [save.error.message] } };
+  }
+  return {
+    code: 0,
+    data: {
+      success: true,
+      command: "scorecard create",
+      scorecard: record,
+      path: save.data
+    }
+  };
+}
+async function handleShow(projectRoot, id) {
+  if (!id) {
+    return {
+      code: 1,
+      data: { success: false, errors: ["Scorecard id required. Usage: scorecard show <id>"] }
+    };
+  }
+  const result = await loadScorecard(projectRoot, id);
+  if (!result.success) {
+    return { code: 1, data: { success: false, errors: [result.error.message] } };
+  }
+  return { code: 0, data: { success: true, command: "scorecard show", scorecard: result.data } };
+}
+async function handleRecord(projectRoot, options) {
+  const taskId = options.taskId ?? "unknown-task";
+  const outcome = {
+    id: generateEvalId("out"),
+    taskId,
+    source: options.source ?? "manual",
+    agent: options.agent ?? "reviewer",
+    model: options.model ?? "unknown",
+    contractVersion: contractVersion(),
+    timestamp: new Date().toISOString(),
+    verdict: options.verdict,
+    weightedScore: options.weightedScore,
+    backlogId: taskId.startsWith("BC-") ? taskId : undefined,
+    costUsd: options.costUsd,
+    tokensIn: options.tokens,
+    durationMs: options.durationMs,
+    status: options.verdict === "PASS" ? "pass" : options.verdict === "REJECT" ? "reject" : undefined
+  };
+  const result = await appendOutcome(projectRoot, outcome);
+  if (!result.success) {
+    return { code: 1, data: { success: false, errors: [result.error.message] } };
+  }
+  return { code: 0, data: { success: true, command: "scorecard record", outcome } };
+}
+async function handleList(projectRoot, options) {
+  const filter = {
+    agent: options.agent,
+    model: options.model,
+    taskId: options.taskId,
+    since: options.since,
+    source: options.source
+  };
+  const result = await listOutcomes(projectRoot, filter);
+  if (!result.success) {
+    return { code: 1, data: { success: false, errors: [result.error.message] } };
+  }
+  return {
+    code: 0,
+    data: { success: true, command: "scorecard list", outcomes: result.data, count: result.data.length }
+  };
+}
+async function handleAggregate(projectRoot, options) {
+  const filter = { since: options.since, agent: options.agent, model: options.model };
+  const list = await listOutcomes(projectRoot, filter);
+  if (!list.success) {
+    return { code: 1, data: { success: false, errors: [list.error.message] } };
+  }
+  const agg = aggregateOutcomes(list.data);
+  return { code: 0, data: { success: true, command: "scorecard aggregate", ...agg } };
+}
+async function handleModels(projectRoot, profile) {
+  const configResult = await loadConfig(projectRoot);
+  const target = configResult.success ? configResult.data.defaults.target : "opencode";
+  const result = await resolvePhaseModels(projectRoot, target);
+  if (!result.success) {
+    return { code: 1, data: { success: false, errors: [result.error.message] } };
+  }
+  return {
+    code: 0,
+    data: {
+      success: true,
+      command: "scorecard models",
+      profile: profile ?? "balanced",
+      phases: result.data
+    }
+  };
+}
+async function handlePromptDiff(projectRoot, options) {
+  if (!options.fromVersion || !options.toVersion) {
+    return {
+      code: 1,
+      data: {
+        success: false,
+        errors: ["Usage: scorecard prompt-diff <fromVersion> <toVersion>"]
+      }
+    };
+  }
+  const configResult = await loadConfig(projectRoot);
+  const target = configResult.success ? configResult.data.defaults.target : "opencode";
+  const diff = await diffPromptVersions(options.fromVersion, options.toVersion, {
+    target,
+    agent: options.agent,
+    projectRoot
+  });
+  const markdown = formatPromptDiffMarkdown(diff);
+  return {
+    code: 0,
+    data: { success: true, command: "scorecard prompt-diff", diff, markdown }
+  };
+}
+async function handleRegression(projectRoot) {
+  const result = await runRegressionChecklist(projectRoot);
+  if (!result.success) {
+    return { code: 1, data: { success: false, errors: [result.error.message] } };
+  }
+  return {
+    code: result.data.passed ? 0 : 1,
+    data: { success: result.data.passed, command: "scorecard regression", report: result.data }
+  };
+}
+async function handleMatrix(projectRoot) {
+  const list = await listOutcomes(projectRoot);
+  if (!list.success) {
+    return { code: 1, data: { success: false, errors: [list.error.message] } };
+  }
+  const matrix = await buildCostQualityMatrix(projectRoot, list.data);
+  const markdown = formatMatrixMarkdown(matrix);
+  return {
+    code: 0,
+    data: { success: true, command: "scorecard matrix", matrix, markdown }
+  };
+}
+async function handleCompareModels(projectRoot, options) {
+  const filter = { since: options.since };
+  const list = await listOutcomes(projectRoot, filter);
+  if (!list.success) {
+    return { code: 1, data: { success: false, errors: [list.error.message] } };
+  }
+  let outcomes = list.data;
+  if (options.modelsFilter && options.modelsFilter.length > 0) {
+    outcomes = outcomes.filter((o) => options.modelsFilter.includes(o.model));
+  }
+  const markdown = generateModelComparisonMarkdown(outcomes, options.modelsFilter);
+  const templatePath = resolve21(projectRoot, ".codeconductor/evaluation/model-comparison-last.md");
+  try {
+    await readFile19(templatePath);
+  } catch {}
+  const { writeFile: writeFile13, mkdir: mkdir11 } = await import("node:fs/promises");
+  await mkdir11(resolve21(projectRoot, ".codeconductor/evaluation"), { recursive: true });
+  await writeFile13(templatePath, markdown, "utf-8");
+  return {
+    code: 0,
+    data: {
+      success: true,
+      command: "scorecard compare-models",
+      markdown,
+      path: templatePath,
+      outcomeCount: outcomes.length
+    }
+  };
+}
+
+// src/commands/help.command.ts
+import { readdir as readdir4 } from "node:fs/promises";
+import { join as join9 } from "node:path";
+async function scanPresetDir(projectRoot, target) {
+  const inventory = {
+    target,
+    skills: [],
+    commands: [],
+    agents: [],
+    workflows: []
+  };
+  const presetDir = join9(projectRoot, "presets", target);
+  try {
+    const entries = await readdir4(presetDir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (entry.isDirectory()) {
+        const subDir = join9(presetDir, entry.name);
+        const subEntries = await readdir4(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}`);
+    }
+  }
+  lines.push("");
+  lines.push("Stack-specific presets (v0.4.0):");
+  lines.push("  ts-next-drizzle     Next.js / Astro, Tailwind, Drizzle ORM, Bun, Postgres");
+  lines.push("  spring-kotlin-jpa   Spring Boot, Kotlin/Java, Gradle, JPA, Hibernate");
+  lines.push("  laravel-tall        Laravel, Blade, Livewire, Alpine.js");
+  lines.push("  python-data-api     Python, FastAPI, Django, uv");
+  lines.push("  Browse: presets/<preset-name>/agents/ — copy into the target runner.");
+  lines.push("  Registry: src/core/presets/preset-registry.ts (listPresets / getPreset).");
+  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 writeFile13, mkdir as mkdir11 } from "node:fs/promises";
+import { dirname as dirname4, resolve as resolve22 } from "node:path";
+
+// src/infrastructure/http/safe-fetch.ts
+import { lookup } from "node:dns/promises";
+var PRIVATE_IP_RANGES = [
+  /^10\./,
+  /^172\.(1[6-9]|2\d|3[01])\./,
+  /^192\.168\./,
+  /^127\./,
+  /^0\./,
+  /^169\.254\./,
+  /^::1$/,
+  /^fc00:/i,
+  /^fe80:/i
+];
+function isPrivateIp(ip) {
+  return PRIVATE_IP_RANGES.some((range) => range.test(ip));
+}
+async function validateUrl(urlString) {
+  let parsed;
+  try {
+    parsed = new URL(urlString);
+  } catch {
+    throw new Error(`Invalid URL: ${urlString}`);
+  }
+  if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
+    throw new Error(`Blocked scheme: ${parsed.protocol}. Only http and https are allowed.`);
+  }
+  const hostname = parsed.hostname;
+  if (hostname === "localhost" || hostname.endsWith(".localhost")) {
+    throw new Error(`Blocked hostname: ${hostname}`);
+  }
+  try {
+    const addresses = await lookup(hostname, { all: true });
+    const addrList = Array.isArray(addresses) ? addresses : [addresses];
+    for (const addr of addrList) {
+      if (isPrivateIp(addr.address)) {
+        throw new Error(`SSRF blocked: ${hostname} resolves to private IP ${addr.address}`);
+      }
+    }
+  } catch (error) {
+    if (error instanceof Error && error.message.startsWith("SSRF blocked")) {
+      throw error;
+    }
+    throw new Error(`DNS resolution failed for ${hostname}: ${String(error)}`);
+  }
+}
+async function safeFetch(urlString, options = {}) {
+  const { timeout = 1e4, followRedirects = false } = options;
+  await validateUrl(urlString);
+  const controller = new AbortController;
+  const timer = setTimeout(() => controller.abort(), timeout);
+  const start = Date.now();
+  try {
+    const response = await fetch(urlString, {
+      method: "GET",
+      signal: controller.signal,
+      redirect: followRedirects ? "follow" : "manual",
+      headers: {
+        "User-Agent": "CodeConductor-SEO/0.3.0",
+        Accept: "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8"
+      }
+    });
+    const responseTime = Date.now() - start;
+    const body = await response.text();
     const headers = {};
     response.headers.forEach((value, key) => {
       headers[key] = value;
@@ -15864,7 +18196,7 @@ async function safeFetch(urlString, options = {}) {
   }
 }
 async function delay(ms) {
-  return new Promise((resolve11) => setTimeout(resolve11, ms));
+  return new Promise((resolve22) => setTimeout(resolve22, ms));
 }
 
 // src/infrastructure/parsers/sitemap-parser.ts
@@ -17068,14 +19400,14 @@ async function seoAuditCommand(options) {
         formattedOutput = formatCli(report);
     }
     if (output) {
-      const outputPath = resolve11(options.projectRoot, output);
-      await mkdir8(dirname4(outputPath), { recursive: true });
-      await writeFile7(outputPath, formattedOutput, "utf-8");
+      const outputPath = resolve22(options.projectRoot, output);
+      await mkdir11(dirname4(outputPath), { recursive: true });
+      await writeFile13(outputPath, formattedOutput, "utf-8");
     } else if (format === "markdown") {
       const timestamp = new Date().toISOString().replace(/[:.]/g, "-").slice(0, 19);
-      const defaultPath = resolve11(options.projectRoot, "seo-reports", `audit-report-${timestamp}.md`);
-      await mkdir8(dirname4(defaultPath), { recursive: true });
-      await writeFile7(defaultPath, formattedOutput, "utf-8");
+      const defaultPath = resolve22(options.projectRoot, "seo-reports", `audit-report-${timestamp}.md`);
+      await mkdir11(dirname4(defaultPath), { recursive: true });
+      await writeFile13(defaultPath, formattedOutput, "utf-8");
       process.stderr.write(`Report saved to: ${defaultPath}
 `);
     }
@@ -17087,7 +19419,7 @@ async function seoAuditCommand(options) {
         command: "seo audit",
         report,
         output: formattedOutput,
-        outputFile: output ? resolve11(options.projectRoot, output) : format === "markdown" ? resolve11(options.projectRoot, "seo-reports") : undefined
+        outputFile: output ? resolve22(options.projectRoot, output) : format === "markdown" ? resolve22(options.projectRoot, "seo-reports") : undefined
       }
     };
   } catch (error) {
@@ -17103,8 +19435,8 @@ async function seoAuditCommand(options) {
 }
 
 // src/commands/seo-llms.command.ts
-import { writeFile as writeFile8, mkdir as mkdir9 } from "node:fs/promises";
-import { dirname as dirname5, resolve as resolve12 } from "node:path";
+import { writeFile as writeFile14, mkdir as mkdir12 } from "node:fs/promises";
+import { dirname as dirname5, resolve as resolve23 } from "node:path";
 
 // src/domain/seo/llms-generator.ts
 function extractTitle2(html) {
@@ -17247,9 +19579,9 @@ async function seoLlmsCommand(options) {
       }
     }) : await generateLlmsTxtFromUrl(url);
     process.stderr.write("\r" + " ".repeat(80) + "\r");
-    const outputPath = output ? resolve12(options.projectRoot, output) : resolve12(options.projectRoot, "llms.txt");
-    await mkdir9(dirname5(outputPath), { recursive: true });
-    await writeFile8(outputPath, result.content, "utf-8");
+    const outputPath = output ? resolve23(options.projectRoot, output) : resolve23(options.projectRoot, "llms.txt");
+    await mkdir12(dirname5(outputPath), { recursive: true });
+    await writeFile14(outputPath, result.content, "utf-8");
     process.stderr.write(`Generated: ${outputPath} (${result.entries.length} entries)
 `);
     return {
@@ -17276,8 +19608,8 @@ async function seoLlmsCommand(options) {
 
 // src/commands/update.command.ts
 import { homedir as homedir9 } from "node:os";
-import { resolve as resolve13, dirname as dirname6 } from "node:path";
-import { mkdir as mkdir10, readFile as readFile11, writeFile as writeFile9, stat as stat3 } from "node:fs/promises";
+import { resolve as resolve24, dirname as dirname6 } from "node:path";
+import { mkdir as mkdir13, readFile as readFile20, writeFile as writeFile15, stat as stat3 } from "node:fs/promises";
 init_package_paths();
 async function updateCommand(options) {
   const { dryRun, force, global: isGlobal, output, projectRoot } = options;
@@ -17343,23 +19675,23 @@ async function updateCommand(options) {
     }
     const updated = [];
     if (updateResults.council) {
-      const localCouncil = resolve13(basePath, ".codeconductor", "presets", "council.yml");
-      const bundledCouncil = resolve13(SRC_PRESETS_DIR, "council", "council.yml");
+      const localCouncil = resolve24(basePath, ".codeconductor", "presets", "council.yml");
+      const bundledCouncil = resolve24(SRC_PRESETS_DIR, "council", "council.yml");
       try {
-        const content = await readFile11(bundledCouncil, "utf-8");
-        await mkdir10(dirname6(localCouncil), { recursive: true });
-        await writeFile9(localCouncil, content, "utf-8");
+        const content = await readFile20(bundledCouncil, "utf-8");
+        await mkdir13(dirname6(localCouncil), { recursive: true });
+        await writeFile15(localCouncil, content, "utf-8");
         updated.push(localCouncil);
       } catch (e) {
         throw new Error(`Failed to update council.yml: ${e}`);
       }
     }
     if (updateResults.policy) {
-      const localPolicy = resolve13(basePath, ".codeconductor", "presets", "policy.yml");
+      const localPolicy = resolve24(basePath, ".codeconductor", "presets", "policy.yml");
       try {
-        const content = await readFile11(POLICY_PATH, "utf-8");
-        await mkdir10(dirname6(localPolicy), { recursive: true });
-        await writeFile9(localPolicy, content, "utf-8");
+        const content = await readFile20(POLICY_PATH, "utf-8");
+        await mkdir13(dirname6(localPolicy), { recursive: true });
+        await writeFile15(localPolicy, content, "utf-8");
         updated.push(localPolicy);
       } catch (e) {
         throw new Error(`Failed to update policy.yml: ${e}`);
@@ -17411,12 +19743,12 @@ async function updateCommand(options) {
                 let targetPath = f.path;
                 let targetBase = basePath;
                 if ((targetName === "agy" || targetName === "gemini") && isGlobal) {
-                  targetBase = resolve13(homedir9(), ".gemini", "config");
+                  targetBase = resolve24(homedir9(), ".gemini", "config");
                   targetPath = targetPath.replace(/^\.agents\/?/, "");
                 }
                 return {
                   ...f,
-                  path: resolve13(targetBase, targetPath)
+                  path: resolve24(targetBase, targetPath)
                 };
               });
               const filesToWrite = resolvedFiles.filter((f) => t.files.includes(f.path));
@@ -17444,19 +19776,19 @@ async function updateCommand(options) {
       for (const s of updateResults.skills) {
         newSkillsLock[s.id] = s.latestVersion;
       }
-      let lockDest = resolve13(basePath, ".codeconductor", "skills-lock.json");
+      let lockDest = resolve24(basePath, ".codeconductor", "skills-lock.json");
       try {
-        const statAgents = await stat3(resolve13(basePath, ".agents"));
+        const statAgents = await stat3(resolve24(basePath, ".agents"));
         if (statAgents.isDirectory()) {
-          const statCodeConductor = await stat3(resolve13(basePath, ".codeconductor")).catch(() => null);
+          const statCodeConductor = await stat3(resolve24(basePath, ".codeconductor")).catch(() => null);
           if (!statCodeConductor) {
-            lockDest = resolve13(basePath, ".agents", "skills-lock.json");
+            lockDest = resolve24(basePath, ".agents", "skills-lock.json");
           }
         }
       } catch {}
       try {
-        await mkdir10(dirname6(lockDest), { recursive: true });
-        await writeFile9(lockDest, JSON.stringify(newSkillsLock, null, 2), "utf-8");
+        await mkdir13(dirname6(lockDest), { recursive: true });
+        await writeFile15(lockDest, JSON.stringify(newSkillsLock, null, 2), "utf-8");
         updated.push(lockDest);
       } catch (e) {
         throw new Error(`Failed to write skills-lock.json: ${e}`);
@@ -17527,25 +19859,38 @@ function parseArgs(args) {
   }
   const command = remaining[0] || "help";
   const subcommand = remaining[1] && !remaining[1].startsWith("-") ? remaining[1] : undefined;
+  const consumed = new Set;
   for (let i = 1;i < remaining.length; i++) {
     const arg = remaining[i];
     if (arg.startsWith("--")) {
       const [key, value] = arg.slice(2).split("=");
       if (key === "lang") {
         const langValue = value !== undefined ? value : remaining[++i];
+        consumed.add(i);
         if (langValue && typeof langValue === "string") {
           options[key] = langValue.split(",").map((s) => s.trim());
         }
       } else if (value !== undefined) {
         options[key] = value;
+        consumed.add(i);
       } else if (remaining[i + 1] && !remaining[i + 1].startsWith("-")) {
         options[key] = remaining[++i];
+        consumed.add(i - 1);
+        consumed.add(i);
       } else {
         options[key] = true;
+        consumed.add(i);
       }
     }
   }
-  return { command, subcommand, options, flags };
+  const rest = [];
+  const startIdx = subcommand ? 2 : 1;
+  for (let i = startIdx;i < remaining.length; i++) {
+    if (!consumed.has(i) && !remaining[i].startsWith("-")) {
+      rest.push(remaining[i]);
+    }
+  }
+  return { command, subcommand, options, flags, rest };
 }
 function getVersion() {
   return `${package_default.name} v${package_default.version}`;
@@ -17607,6 +19952,7 @@ Examples:
   npx cc-codeconductor install preset --target opencode
   npx cc-codeconductor install preset --target claude
   npx cc-codeconductor install preset --target codex
+  npx cc-codeconductor install preset --target cursor
   npx cc-codeconductor install preset --target agy
   npx cc-codeconductor install preset --target all
   npx cc-codeconductor install preset --target claude --global
@@ -17628,6 +19974,14 @@ Examples:
   npx cc-codeconductor seo llms --url https://example.com --output llms.txt
   npx cc-codeconductor goal "Add user authentication"
   npx cc-codeconductor cc-goal "Implement CRUD for invoices"
+  npx cc-codeconductor openspec validate
+  npx cc-codeconductor openspec scan
+  npx cc-codeconductor openspec plan BC-001
+  npx cc-codeconductor openspec status
+  npx cc-codeconductor openspec next
+  npx cc-codeconductor scorecard create --task BC-001 --from-diff
+  npx cc-codeconductor scorecard models
+  npx cc-codeconductor scorecard aggregate
   npx cc-codeconductor help --target opencode
   npx cc-codeconductor help --target claude --output json
 
@@ -17730,6 +20084,68 @@ async function routeCommand(args, projectRoot) {
         projectRoot,
         output: flags.output
       });
+    case "openspec":
+    case "cc-openspec": {
+      const validSubs = ["validate", "scan", "plan", "status", "next"];
+      let openspecSub = "validate";
+      let itemId = options.item || undefined;
+      if (subcommand && validSubs.includes(subcommand)) {
+        openspecSub = subcommand;
+        itemId = itemId ?? args.rest?.[0];
+      } else if (subcommand && /^BC-\d+$/i.test(subcommand)) {
+        openspecSub = "plan";
+        itemId = subcommand;
+      } else if (subcommand) {
+        openspecSub = subcommand;
+      }
+      return openspecCommand({
+        subcommand: openspecSub,
+        itemId,
+        projectRoot,
+        output: flags.output
+      });
+    }
+    case "scorecard":
+    case "cc-scorecard": {
+      const validSubs = [
+        "create",
+        "show",
+        "record",
+        "list",
+        "aggregate",
+        "models",
+        "prompt-diff",
+        "regression",
+        "matrix",
+        "compare-models"
+      ];
+      let scorecardSub = subcommand && validSubs.includes(subcommand) ? subcommand : "aggregate";
+      if (!subcommand || !validSubs.includes(subcommand)) {
+        scorecardSub = "aggregate";
+      }
+      const modelsFilter = typeof options.models === "string" ? options.models.split(",").map((s) => s.trim()) : undefined;
+      return scorecardCommand({
+        subcommand: scorecardSub,
+        projectRoot,
+        output: flags.output,
+        id: scorecardSub === "show" ? args.rest?.[0] ?? options.id : options.id,
+        taskId: options.task ?? options.item,
+        agent: options.agent,
+        model: options.model,
+        fromDiff: options["from-diff"] === true || options.fromDiff === true,
+        fromVersion: scorecardSub === "prompt-diff" ? args.rest?.[0] ?? options.from : options.from,
+        toVersion: scorecardSub === "prompt-diff" ? args.rest?.[1] ?? options.to : options.to,
+        profile: options.profile,
+        costUsd: options.cost ? parseFloat(String(options.cost)) : undefined,
+        tokens: options.tokens ? parseInt(String(options.tokens), 10) : undefined,
+        durationMs: options.duration ? parseInt(String(options.duration), 10) : undefined,
+        verdict: options.verdict,
+        weightedScore: options.score ? parseFloat(String(options.score)) : undefined,
+        source: options.source,
+        since: options.since,
+        modelsFilter
+      });
+    }
     case "seo": {
       if (subcommand === "audit") {
         return seoAuditCommand({