cc-codeconductor 0.4.1 → 0.4.3

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;
+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 init_schemas = __esm(() => {
   init_zod();
   CouncilAgentSpecSchema = exports_external.object({
@@ -11167,7 +11167,11 @@ var init_schemas = __esm(() => {
   LoopConfigSchema = exports_external.object({
     enabled: exports_external.boolean().optional().default(true),
     maxIterations: exports_external.number().int().positive().optional().default(3),
-    maxTokenBudget: exports_external.number().nonnegative().optional().default(0)
+    maxTokenBudget: exports_external.number().nonnegative().optional().default(0),
+    compaction: exports_external.object({
+      enabled: exports_external.boolean().optional().default(true),
+      historyFile: exports_external.string().optional()
+    }).optional()
   });
   CodeConductorConfigSchema = exports_external.object({
     version: exports_external.string(),
@@ -11309,6 +11313,34 @@ var init_schemas = __esm(() => {
     environment: exports_external.string().optional(),
     release: exports_external.string().optional()
   });
+  MemoryPointerSchema = exports_external.object({
+    topic_key: exports_external.string().min(1).max(128),
+    id: exports_external.number().int().positive(),
+    file: exports_external.string().min(1),
+    summary: exports_external.string().min(1).max(200),
+    timestamp: exports_external.string().datetime(),
+    tags: exports_external.array(exports_external.string().max(64)).max(10).optional().default([])
+  });
+  MemoryIndexSchema = exports_external.object({
+    version: exports_external.literal(1),
+    pointers: exports_external.array(MemoryPointerSchema)
+  });
+  GoalTaskSchema = exports_external.object({
+    id: exports_external.string(),
+    title: exports_external.string(),
+    type: exports_external.enum(["feature", "fix", "refactor", "test", "docs"]),
+    risk: exports_external.enum(["low", "medium", "high"]),
+    status: exports_external.enum(["pending", "in-progress", "done", "blocked"]),
+    depends_on: exports_external.array(exports_external.string()).optional().default([]),
+    acceptance_criteria: exports_external.array(exports_external.string()),
+    blocked_reason: exports_external.string().optional(),
+    context_scope: exports_external.enum(["isolated", "continuation", "full"]).optional().default("isolated")
+  });
+  GoalGraphSchema = exports_external.object({
+    objective: exports_external.string(),
+    tasks: exports_external.array(GoalTaskSchema),
+    created_at: exports_external.string()
+  });
 });
 
 // src/core/presets/package-paths.ts
@@ -12134,7 +12166,7 @@ init_errors();
 // package.json
 var package_default = {
   name: "cc-codeconductor",
-  version: "0.4.1",
+  version: "0.4.3",
   description: "A multi-agent orchestration framework for AI-assisted software engineering workflows.",
   keywords: [
     "ai",
@@ -13056,7 +13088,8 @@ function renderTemplate(content, modelConfig, filePath, locale = "en") {
     "tester",
     "reviewer",
     "docs",
-    "repo-explorer"
+    "repo-explorer",
+    "goal-planner"
   ];
   let result = templatedContent;
   for (const role of knownRoles) {
@@ -13144,8 +13177,20 @@ function injectMcpServers(jsonString, filePath) {
     if (isClaudeSettings || isAgyMcpConfig) {
       obj.mcpServers = mergeDeep(obj.mcpServers || {}, mcpServers);
     } else if (isOpencodeJsonc) {
-      obj.mcp = obj.mcp || {};
-      obj.mcp.servers = mergeDeep(obj.mcp.servers || {}, mcpServers);
+      const opencodeMcp = {};
+      for (const [key, server] of Object.entries(mcpServers)) {
+        const commandArray = typeof server.command === "string" ? [server.command, ...server.args || []] : server.command;
+        const formattedServer = {
+          type: "local",
+          command: commandArray,
+          enabled: true
+        };
+        if (server.env) {
+          formattedServer.environment = server.env;
+        }
+        opencodeMcp[key] = formattedServer;
+      }
+      obj.mcp = mergeDeep(obj.mcp || {}, opencodeMcp);
     }
     return JSON.stringify(obj, null, 2);
   } catch {
@@ -13887,7 +13932,7 @@ async function writeConfig(projectRoot, config = {}, force = false) {
 init_package_paths();
 
 // src/core/presets/preset-resolver.ts
-var CURRENT_PRESET_VERSION = "v0.3.0";
+var CURRENT_PRESET_VERSION = "v0.4.0";
 function resolvePreset(target, profile) {
   const stack = resolveStack(profile);
   const isMonorepo = profile.signals.some((s) => [
@@ -13950,17 +13995,17 @@ function resolveStack(profile) {
 function resolveAssets(target) {
   switch (target) {
     case "opencode":
-      return ["opencode.jsonc", "agents", "commands", "prompts/v0.3.0", "skills"];
+      return ["opencode.jsonc", "agents", "commands", "prompts/v0.4.0", "skills"];
     case "claude":
-      return ["CLAUDE.md", "settings.json", "commands", "skills", "agents", "prompts/v0.3.0"];
+      return ["CLAUDE.md", "settings.json", "commands", "skills", "agents", "prompts/v0.4.0"];
     case "codex":
-      return ["AGENTS.md", "skills", "prompts/v0.3.0"];
+      return ["AGENTS.md", "skills", "prompts/v0.4.0"];
     case "gemini":
-      return ["agents", "prompts/v0.3.0"];
+      return ["agents", "prompts/v0.4.0"];
     case "cursor":
-      return ["agents", "prompts/v0.3.0"];
+      return ["agents", "prompts/v0.4.0"];
     case "agy":
-      return ["AGENTS.md", "rules", "workflows", "skills", "prompts/v0.3.0"];
+      return ["AGENTS.md", "rules", "workflows", "skills", "prompts/v0.4.0"];
   }
 }
 
@@ -15080,6 +15125,522 @@ async function debtHarvestCommand(options) {
   }
 }
 
+// src/core/goal/goal-planner.ts
+var TEMPLATES = [
+  {
+    keywords: ["login", "auth", "authentication", "signin", "sign-in"],
+    tasks: [
+      {
+        id: "auth-schema",
+        title: "Define auth data model and DB schema",
+        type: "feature",
+        risk: "high",
+        status: "pending",
+        context_scope: "isolated",
+        depends_on: [],
+        acceptance_criteria: [
+          "User entity with email, password_hash, created_at fields",
+          "Migration script creates users table",
+          "Schema supports password reset token"
+        ]
+      },
+      {
+        id: "auth-api",
+        title: "Define auth API contract",
+        type: "feature",
+        risk: "medium",
+        status: "pending",
+        context_scope: "isolated",
+        depends_on: ["auth-schema"],
+        acceptance_criteria: [
+          "POST /auth/register endpoint defined",
+          "POST /auth/login endpoint defined",
+          "POST /auth/logout endpoint defined",
+          "OpenAPI spec updated"
+        ]
+      },
+      {
+        id: "auth-impl",
+        title: "Implement auth endpoints",
+        type: "feature",
+        risk: "high",
+        status: "pending",
+        context_scope: "isolated",
+        depends_on: ["auth-api"],
+        acceptance_criteria: [
+          "Register endpoint hashes password and stores user",
+          "Login endpoint validates credentials and returns session",
+          "Logout endpoint invalidates session",
+          "Input validation on all endpoints"
+        ]
+      },
+      {
+        id: "auth-tests",
+        title: "Write auth tests",
+        type: "test",
+        risk: "medium",
+        status: "pending",
+        context_scope: "isolated",
+        depends_on: ["auth-impl"],
+        acceptance_criteria: [
+          "Unit tests for password hashing",
+          "Integration tests for register/login/logout flow",
+          "Edge cases: duplicate email, invalid password, expired token"
+        ]
+      }
+    ]
+  },
+  {
+    keywords: ["crud", "resource", "api", "endpoint", "rest"],
+    tasks: [
+      {
+        id: "crud-model",
+        title: "Define data model and schema",
+        type: "feature",
+        risk: "medium",
+        status: "pending",
+        context_scope: "isolated",
+        depends_on: [],
+        acceptance_criteria: [
+          "Entity definition with required fields",
+          "Database migration script",
+          "Schema follows project conventions"
+        ]
+      },
+      {
+        id: "crud-service",
+        title: "Implement repository/service layer",
+        type: "feature",
+        risk: "medium",
+        status: "pending",
+        context_scope: "isolated",
+        depends_on: ["crud-model"],
+        acceptance_criteria: [
+          "Create, Read (list + by id), Update, Delete operations",
+          "Input validation",
+          "Error handling for not-found and conflict"
+        ]
+      },
+      {
+        id: "crud-api",
+        title: "Implement API endpoints",
+        type: "feature",
+        risk: "medium",
+        status: "pending",
+        context_scope: "isolated",
+        depends_on: ["crud-service"],
+        acceptance_criteria: [
+          "REST endpoints for all CRUD operations",
+          "Proper HTTP status codes",
+          "Request/response schemas"
+        ]
+      },
+      {
+        id: "crud-tests",
+        title: "Write tests",
+        type: "test",
+        risk: "low",
+        status: "pending",
+        context_scope: "isolated",
+        depends_on: ["crud-api"],
+        acceptance_criteria: [
+          "Unit tests for service layer",
+          "Integration tests for API endpoints",
+          "Edge cases covered"
+        ]
+      }
+    ]
+  },
+  {
+    keywords: ["search", "filter", "query", "full-text", "fts"],
+    tasks: [
+      {
+        id: "search-schema",
+        title: "Design search schema and indexing strategy",
+        type: "feature",
+        risk: "medium",
+        status: "pending",
+        context_scope: "isolated",
+        depends_on: [],
+        acceptance_criteria: [
+          "Search index definition",
+          "Indexing strategy documented",
+          "Performance requirements defined"
+        ]
+      },
+      {
+        id: "search-service",
+        title: "Implement search service",
+        type: "feature",
+        risk: "medium",
+        status: "pending",
+        context_scope: "isolated",
+        depends_on: ["search-schema"],
+        acceptance_criteria: [
+          "Full-text search with ranking",
+          "Filter support",
+          "Pagination"
+        ]
+      },
+      {
+        id: "search-api",
+        title: "Implement search API",
+        type: "feature",
+        risk: "low",
+        status: "pending",
+        context_scope: "isolated",
+        depends_on: ["search-service"],
+        acceptance_criteria: [
+          "GET /search endpoint with query params",
+          "Response includes results + metadata",
+          "Rate limiting applied"
+        ]
+      },
+      {
+        id: "search-tests",
+        title: "Write search tests",
+        type: "test",
+        risk: "low",
+        status: "pending",
+        context_scope: "isolated",
+        depends_on: ["search-api"],
+        acceptance_criteria: [
+          "Unit tests for search logic",
+          "Integration tests with sample data",
+          "Performance test for large datasets"
+        ]
+      }
+    ]
+  },
+  {
+    keywords: ["notification", "email", "alert", "push", "notify"],
+    tasks: [
+      {
+        id: "notif-model",
+        title: "Design notification data model",
+        type: "feature",
+        risk: "medium",
+        status: "pending",
+        context_scope: "isolated",
+        depends_on: [],
+        acceptance_criteria: [
+          "Notification entity with type, payload, status, user_id",
+          "Database migration",
+          "Enum for notification types"
+        ]
+      },
+      {
+        id: "notif-service",
+        title: "Implement notification service",
+        type: "feature",
+        risk: "medium",
+        status: "pending",
+        context_scope: "isolated",
+        depends_on: ["notif-model"],
+        acceptance_criteria: [
+          "Send notification by type",
+          "Queue-based delivery",
+          "Retry logic for failed deliveries"
+        ]
+      },
+      {
+        id: "notif-api",
+        title: "Implement notification API",
+        type: "feature",
+        risk: "low",
+        status: "pending",
+        context_scope: "isolated",
+        depends_on: ["notif-service"],
+        acceptance_criteria: [
+          "POST /notifications endpoint",
+          "GET /notifications endpoint with read/unread filter",
+          "PATCH /notifications/:id/read endpoint"
+        ]
+      },
+      {
+        id: "notif-tests",
+        title: "Write notification tests",
+        type: "test",
+        risk: "low",
+        status: "pending",
+        context_scope: "isolated",
+        depends_on: ["notif-api"],
+        acceptance_criteria: [
+          "Unit tests for notification logic",
+          "Integration tests for API",
+          "Edge cases: invalid type, missing user"
+        ]
+      }
+    ]
+  },
+  {
+    keywords: ["migration", "migrate", "schema change", "database change", "column"],
+    tasks: [
+      {
+        id: "migrate-script",
+        title: "Write migration script",
+        type: "feature",
+        risk: "high",
+        status: "pending",
+        context_scope: "isolated",
+        depends_on: [],
+        acceptance_criteria: [
+          "Migration is reversible",
+          "Handles existing data gracefully",
+          "Rollback script included"
+        ]
+      },
+      {
+        id: "migrate-model",
+        title: "Update domain model",
+        type: "refactor",
+        risk: "medium",
+        status: "pending",
+        context_scope: "isolated",
+        depends_on: ["migrate-script"],
+        acceptance_criteria: [
+          "Domain model reflects new schema",
+          "Existing code paths updated",
+          "Backward compatibility maintained"
+        ]
+      },
+      {
+        id: "migrate-dal",
+        title: "Update data access layer",
+        type: "refactor",
+        risk: "medium",
+        status: "pending",
+        context_scope: "isolated",
+        depends_on: ["migrate-model"],
+        acceptance_criteria: [
+          "Repository/service reads/writes new schema",
+          "No broken queries",
+          "Performance not degraded"
+        ]
+      },
+      {
+        id: "migrate-tests",
+        title: "Write migration tests",
+        type: "test",
+        risk: "high",
+        status: "pending",
+        context_scope: "isolated",
+        depends_on: ["migrate-dal"],
+        acceptance_criteria: [
+          "Migration up/down test",
+          "Data integrity test",
+          "Integration tests with new schema"
+        ]
+      }
+    ]
+  }
+];
+var GENERIC_TEMPLATE = [
+  {
+    id: "plan-scope",
+    title: "Clarify requirements and scope",
+    type: "feature",
+    risk: "low",
+    status: "pending",
+    context_scope: "isolated",
+    depends_on: [],
+    acceptance_criteria: ["Objective is well-defined", "Scope boundaries identified"]
+  },
+  {
+    id: "plan-design",
+    title: "Design technical approach",
+    type: "feature",
+    risk: "medium",
+    status: "pending",
+    context_scope: "isolated",
+    depends_on: ["plan-scope"],
+    acceptance_criteria: ["Architecture decisions documented", "API contracts defined"]
+  },
+  {
+    id: "plan-impl",
+    title: "Implement solution",
+    type: "feature",
+    risk: "medium",
+    status: "pending",
+    context_scope: "isolated",
+    depends_on: ["plan-design"],
+    acceptance_criteria: ["Core functionality implemented", "Follows project conventions"]
+  },
+  {
+    id: "plan-tests",
+    title: "Write tests and verify",
+    type: "test",
+    risk: "low",
+    status: "pending",
+    context_scope: "isolated",
+    depends_on: ["plan-impl"],
+    acceptance_criteria: ["Unit tests pass", "Integration tests pass", "No regressions"]
+  }
+];
+function matchTemplate(objective) {
+  const lower = objective.toLowerCase();
+  for (const template of TEMPLATES) {
+    const matched = template.keywords.some((kw) => lower.includes(kw));
+    if (matched)
+      return template.tasks;
+  }
+  return GENERIC_TEMPLATE;
+}
+function planGoal(objective) {
+  const tasks = matchTemplate(objective);
+  return {
+    objective,
+    tasks: tasks.map((t) => ({ ...t, status: "pending" })),
+    created_at: new Date().toISOString()
+  };
+}
+
+// src/core/goal/goal-state.ts
+init_dist();
+init_schemas();
+import { mkdir as mkdir7, readFile as readFile10, writeFile as writeFile6 } from "node:fs/promises";
+import { resolve as resolve10 } from "node:path";
+function validateGoalGraph(graph) {
+  const ids = new Set(graph.tasks.map((t) => t.id));
+  if (ids.size !== graph.tasks.length) {
+    return err(new Error("Duplicate task IDs in goal graph"));
+  }
+  for (const task of graph.tasks) {
+    for (const dep of task.depends_on ?? []) {
+      if (!ids.has(dep)) {
+        return err(new Error(`Task "${task.id}" depends on unknown task "${dep}"`));
+      }
+    }
+  }
+  const visited = new Set;
+  const inStack = new Set;
+  function dfs(taskId) {
+    if (inStack.has(taskId))
+      return true;
+    if (visited.has(taskId))
+      return false;
+    visited.add(taskId);
+    inStack.add(taskId);
+    const task = graph.tasks.find((t) => t.id === taskId);
+    if (task) {
+      for (const dep of task.depends_on ?? []) {
+        if (dfs(dep))
+          return true;
+      }
+    }
+    inStack.delete(taskId);
+    return false;
+  }
+  for (const task of graph.tasks) {
+    if (dfs(task.id)) {
+      return err(new Error(`Cycle detected involving task "${task.id}"`));
+    }
+  }
+  return ok(graph);
+}
+async function writeGoal(projectRoot, graph) {
+  const validation = validateGoalGraph(graph);
+  if (!validation.success)
+    return validation;
+  const dir = resolve10(projectRoot, ".codeconductor");
+  await mkdir7(dir, { recursive: true });
+  const yaml = $stringify(graph);
+  await writeFile6(resolve10(dir, "current-goal.yml"), yaml, "utf-8");
+  return ok(undefined);
+}
+
+// src/commands/goal.command.ts
+function renderDependencyTree(tasks) {
+  const lines = [];
+  const taskMap = new Map(tasks.map((t) => [t.id, t]));
+  const roots = tasks.filter((t) => !t.depends_on || t.depends_on.length === 0);
+  function render(taskId, prefix, isLast) {
+    const task = taskMap.get(taskId);
+    if (!task)
+      return;
+    const connector = isLast ? "└── " : "├── ";
+    const label = `${task.id}: ${task.title}`;
+    lines.push(`${prefix}${connector}${label}`);
+    const children = tasks.filter((t) => t.depends_on && t.depends_on.includes(taskId));
+    const childPrefix = prefix + (isLast ? "    " : "│   ");
+    children.forEach((child, i) => {
+      render(child.id, childPrefix, i === children.length - 1);
+    });
+  }
+  roots.forEach((root, i) => {
+    render(root.id, "", i === roots.length - 1);
+  });
+  return lines.join(`
+`);
+}
+async function goalCommand(options) {
+  const { objective, projectRoot, output } = options;
+  if (!objective || objective.trim().length === 0) {
+    return {
+      code: 1,
+      data: {
+        success: false,
+        command: "goal",
+        errors: ['Objective is required. Usage: codeconductor goal "<objective>"']
+      }
+    };
+  }
+  try {
+    const graph = planGoal(objective);
+    const writeResult = await writeGoal(projectRoot, graph);
+    if (!writeResult.success) {
+      return {
+        code: 1,
+        data: {
+          success: false,
+          command: "goal",
+          errors: [`Failed to write goal: ${writeResult.error.message}`]
+        }
+      };
+    }
+    if (output === "json") {
+      return {
+        code: 0,
+        data: {
+          success: true,
+          command: "goal",
+          objective: graph.objective,
+          tasks: graph.tasks,
+          file: ".codeconductor/current-goal.yml"
+        }
+      };
+    }
+    const tree = renderDependencyTree(graph.tasks);
+    const lines = [
+      `Objective: ${graph.objective}`,
+      "",
+      "Task dependency graph:",
+      tree,
+      "",
+      `Tasks: ${graph.tasks.length} total`,
+      `File: .codeconductor/current-goal.yml`
+    ];
+    return {
+      code: 0,
+      data: {
+        success: true,
+        command: "goal",
+        output: lines.join(`
+`)
+      }
+    };
+  } catch (e) {
+    return {
+      code: 1,
+      data: {
+        success: false,
+        command: "goal",
+        errors: [e instanceof Error ? e.message : String(e)]
+      }
+    };
+  }
+}
+
 // src/commands/help.command.ts
 import { readdir as readdir3 } from "node:fs/promises";
 import { join as join8 } from "node:path";
@@ -15159,6 +15720,14 @@ function renderHuman(inventory, defaultTarget) {
       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(`
 `);
 }
@@ -15207,8 +15776,8 @@ async function helpCommand(options) {
 }
 
 // src/commands/seo-audit.command.ts
-import { writeFile as writeFile6, mkdir as mkdir7 } from "node:fs/promises";
-import { dirname as dirname4, resolve as resolve10 } from "node:path";
+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";
@@ -15295,7 +15864,7 @@ async function safeFetch(urlString, options = {}) {
   }
 }
 async function delay(ms) {
-  return new Promise((resolve10) => setTimeout(resolve10, ms));
+  return new Promise((resolve11) => setTimeout(resolve11, ms));
 }
 
 // src/infrastructure/parsers/sitemap-parser.ts
@@ -16499,14 +17068,14 @@ async function seoAuditCommand(options) {
         formattedOutput = formatCli(report);
     }
     if (output) {
-      const outputPath = resolve10(options.projectRoot, output);
-      await mkdir7(dirname4(outputPath), { recursive: true });
-      await writeFile6(outputPath, formattedOutput, "utf-8");
+      const outputPath = resolve11(options.projectRoot, output);
+      await mkdir8(dirname4(outputPath), { recursive: true });
+      await writeFile7(outputPath, formattedOutput, "utf-8");
     } else if (format === "markdown") {
       const timestamp = new Date().toISOString().replace(/[:.]/g, "-").slice(0, 19);
-      const defaultPath = resolve10(options.projectRoot, "seo-reports", `audit-report-${timestamp}.md`);
-      await mkdir7(dirname4(defaultPath), { recursive: true });
-      await writeFile6(defaultPath, formattedOutput, "utf-8");
+      const defaultPath = resolve11(options.projectRoot, "seo-reports", `audit-report-${timestamp}.md`);
+      await mkdir8(dirname4(defaultPath), { recursive: true });
+      await writeFile7(defaultPath, formattedOutput, "utf-8");
       process.stderr.write(`Report saved to: ${defaultPath}
 `);
     }
@@ -16518,7 +17087,7 @@ async function seoAuditCommand(options) {
         command: "seo audit",
         report,
         output: formattedOutput,
-        outputFile: output ? resolve10(options.projectRoot, output) : format === "markdown" ? resolve10(options.projectRoot, "seo-reports") : undefined
+        outputFile: output ? resolve11(options.projectRoot, output) : format === "markdown" ? resolve11(options.projectRoot, "seo-reports") : undefined
       }
     };
   } catch (error) {
@@ -16534,8 +17103,8 @@ async function seoAuditCommand(options) {
 }
 
 // src/commands/seo-llms.command.ts
-import { writeFile as writeFile7, mkdir as mkdir8 } from "node:fs/promises";
-import { dirname as dirname5, resolve as resolve11 } from "node:path";
+import { writeFile as writeFile8, mkdir as mkdir9 } from "node:fs/promises";
+import { dirname as dirname5, resolve as resolve12 } from "node:path";
 
 // src/domain/seo/llms-generator.ts
 function extractTitle2(html) {
@@ -16678,9 +17247,9 @@ async function seoLlmsCommand(options) {
       }
     }) : await generateLlmsTxtFromUrl(url);
     process.stderr.write("\r" + " ".repeat(80) + "\r");
-    const outputPath = output ? resolve11(options.projectRoot, output) : resolve11(options.projectRoot, "llms.txt");
-    await mkdir8(dirname5(outputPath), { recursive: true });
-    await writeFile7(outputPath, result.content, "utf-8");
+    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");
     process.stderr.write(`Generated: ${outputPath} (${result.entries.length} entries)
 `);
     return {
@@ -16707,8 +17276,8 @@ async function seoLlmsCommand(options) {
 
 // src/commands/update.command.ts
 import { homedir as homedir9 } from "node:os";
-import { resolve as resolve12, dirname as dirname6 } from "node:path";
-import { mkdir as mkdir9, readFile as readFile10, writeFile as writeFile8, stat as stat3 } from "node:fs/promises";
+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";
 init_package_paths();
 async function updateCommand(options) {
   const { dryRun, force, global: isGlobal, output, projectRoot } = options;
@@ -16774,23 +17343,23 @@ async function updateCommand(options) {
     }
     const updated = [];
     if (updateResults.council) {
-      const localCouncil = resolve12(basePath, ".codeconductor", "presets", "council.yml");
-      const bundledCouncil = resolve12(SRC_PRESETS_DIR, "council", "council.yml");
+      const localCouncil = resolve13(basePath, ".codeconductor", "presets", "council.yml");
+      const bundledCouncil = resolve13(SRC_PRESETS_DIR, "council", "council.yml");
       try {
-        const content = await readFile10(bundledCouncil, "utf-8");
-        await mkdir9(dirname6(localCouncil), { recursive: true });
-        await writeFile8(localCouncil, content, "utf-8");
+        const content = await readFile11(bundledCouncil, "utf-8");
+        await mkdir10(dirname6(localCouncil), { recursive: true });
+        await writeFile9(localCouncil, content, "utf-8");
         updated.push(localCouncil);
       } catch (e) {
         throw new Error(`Failed to update council.yml: ${e}`);
       }
     }
     if (updateResults.policy) {
-      const localPolicy = resolve12(basePath, ".codeconductor", "presets", "policy.yml");
+      const localPolicy = resolve13(basePath, ".codeconductor", "presets", "policy.yml");
       try {
-        const content = await readFile10(POLICY_PATH, "utf-8");
-        await mkdir9(dirname6(localPolicy), { recursive: true });
-        await writeFile8(localPolicy, content, "utf-8");
+        const content = await readFile11(POLICY_PATH, "utf-8");
+        await mkdir10(dirname6(localPolicy), { recursive: true });
+        await writeFile9(localPolicy, content, "utf-8");
         updated.push(localPolicy);
       } catch (e) {
         throw new Error(`Failed to update policy.yml: ${e}`);
@@ -16842,12 +17411,12 @@ async function updateCommand(options) {
                 let targetPath = f.path;
                 let targetBase = basePath;
                 if ((targetName === "agy" || targetName === "gemini") && isGlobal) {
-                  targetBase = resolve12(homedir9(), ".gemini", "config");
+                  targetBase = resolve13(homedir9(), ".gemini", "config");
                   targetPath = targetPath.replace(/^\.agents\/?/, "");
                 }
                 return {
                   ...f,
-                  path: resolve12(targetBase, targetPath)
+                  path: resolve13(targetBase, targetPath)
                 };
               });
               const filesToWrite = resolvedFiles.filter((f) => t.files.includes(f.path));
@@ -16875,19 +17444,19 @@ async function updateCommand(options) {
       for (const s of updateResults.skills) {
         newSkillsLock[s.id] = s.latestVersion;
       }
-      let lockDest = resolve12(basePath, ".codeconductor", "skills-lock.json");
+      let lockDest = resolve13(basePath, ".codeconductor", "skills-lock.json");
       try {
-        const statAgents = await stat3(resolve12(basePath, ".agents"));
+        const statAgents = await stat3(resolve13(basePath, ".agents"));
         if (statAgents.isDirectory()) {
-          const statCodeConductor = await stat3(resolve12(basePath, ".codeconductor")).catch(() => null);
+          const statCodeConductor = await stat3(resolve13(basePath, ".codeconductor")).catch(() => null);
           if (!statCodeConductor) {
-            lockDest = resolve12(basePath, ".agents", "skills-lock.json");
+            lockDest = resolve13(basePath, ".agents", "skills-lock.json");
           }
         }
       } catch {}
       try {
-        await mkdir9(dirname6(lockDest), { recursive: true });
-        await writeFile8(lockDest, JSON.stringify(newSkillsLock, null, 2), "utf-8");
+        await mkdir10(dirname6(lockDest), { recursive: true });
+        await writeFile9(lockDest, JSON.stringify(newSkillsLock, null, 2), "utf-8");
         updated.push(lockDest);
       } catch (e) {
         throw new Error(`Failed to write skills-lock.json: ${e}`);
@@ -16988,26 +17557,47 @@ Usage: npx cc-codeconductor <command> [options]
 
 Commands:
   init                    Initialize CodeConductor in a project
-  detect                 Detect project stack and recommended presets
-  install council        Install generated council spec files to runner targets
-  install preset         Install full preset (agents, prompts, skills, commands)
-  install lsp            Install and configure LSP servers for AI coding tools
-  seo audit              Run SEO audit on a URL or sitemap
-  seo llms               Generate llms.txt from a URL or sitemap
-  doctor                 Validate configuration and generated files
-  update                 Update installed presets
-  help / cc-help         Show preset inventory (skills, subagents, commands)
-  debt-harvest / harvest Scan source files for deferred debt items
+  detect                  Detect project stack and recommended presets
+  install council         Install generated council spec files to runner targets
+  install preset          Install full preset (agents, prompts, skills, commands)
+  install lsp             Install and configure LSP servers for AI coding tools
+  seo audit               Run SEO audit on a URL or sitemap
+  seo llms                Generate llms.txt from a URL or sitemap
+  doctor                  Validate configuration and generated files
+  update                  Update installed presets
+  help / cc-help          Show preset inventory (skills, subagents, commands)
+  debt-harvest / harvest  Scan source files for deferred debt items
+  goal / cc-goal          Plan goal into task graph with dependencies
 
 Options:
-  --help, -h             Show this help message
-  --version, -v          Show package version
-  --dry-run              Show what would happen without writing files
-  --force                Allow overwriting existing files
-  --global               Install to home directory (~/.claude, ~/.opencode, etc.)
-  --output, -o           Output mode: human or json
-  --lang                 Comma-separated list of languages (e.g., typescript,php,python)
-  --locale               Instruction language for agent files: en (default) | es
+  --help, -h              Show this help message
+  --version, -v           Show package version
+  --dry-run               Show what would happen without writing files
+  --force                 Allow overwriting existing files
+  --global                Install to home directory (~/.claude, ~/.opencode, etc.)
+  --output, -o            Output mode: human or json
+  --lang                  Comma-separated list of languages (e.g., typescript,php,python)
+  --locale                Instruction language for agent files: en (default) | es
+  --target                Runner target: opencode, claude, codex, gemini, cursor, agy, all
+
+Stack-specific presets (v0.4.0, registered in preset-registry):
+  ts-next-drizzle         Next.js / Astro, Tailwind, Drizzle ORM, Bun, Postgres
+  spring-kotlin-jpa       Spring Boot, Kotlin/Java, Gradle, JPA, Hibernate
+  laravel-tall            Laravel, Blade, Livewire, Alpine.js
+  python-data-api         Python, FastAPI, Django, uv
+  Listed programmatically via listPresets() in src/core/presets/preset-registry.ts.
+  Stack detection wires matching specialized skills automatically when
+  init/detect identifies the stack.
+
+Workflow Loop Core (v0.4.0):
+  runWorkflowPipeline() in src/core/pipeline/workflow-loop.ts runs the
+  8-phase loop (intake -> structure -> design -> test -> implement ->
+  validate -> council -> compact) with wall-clock, files-modified and
+  lines-changed guardrails and STOP gates after Design and Council.
+
+Council consensus v0.4.0:
+  Per-agent confidence thresholds (< 0.6 or average < 0.7 escalate)
+  and a complianceVeto channel that overrides majority like securityVeto.
 
 Examples:
   npx cc-codeconductor init
@@ -17036,6 +17626,16 @@ Examples:
   npx cc-codeconductor seo audit --sitemap https://example.com/sitemap.xml --format markdown
   npx cc-codeconductor seo llms --sitemap https://example.com/sitemap.xml
   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 help --target opencode
+  npx cc-codeconductor help --target claude --output json
+
+Docs: https://github.com/lgzarturo/codeconductor/tree/main/docs
+  docs/v0.4.0-release-notes.md   v0.4.0 feature breakdown
+  docs/routing-policy.md         Risk-based routing (v0.4.0)
+  docs/prompt-versioning.md      Agent contract versions
+  docs/usage-cli.md              Detailed CLI reference
 `;
 }
 async function routeCommand(args, projectRoot) {
@@ -17123,6 +17723,13 @@ async function routeCommand(args, projectRoot) {
         dir: options.dir,
         output: flags.output
       });
+    case "goal":
+    case "cc-goal":
+      return goalCommand({
+        objective: subcommand || options.objective || "",
+        projectRoot,
+        output: flags.output
+      });
     case "seo": {
       if (subcommand === "audit") {
         return seoAuditCommand({
@@ -17187,6 +17794,8 @@ async function runCli(args) {
         const data = result.data;
         if ("help" in data) {
           console.log(data.help);
+        } else if ("message" in data && typeof data.message === "string") {
+          console.log(data.message);
         } else {
           if ("errors" in data && Array.isArray(data.errors) && data.errors.length > 0) {
             data.errors.forEach((e) => console.error(e));