open-coleslaw 0.2.2 → 0.3.0

package/dist/index.js

@@ -308,47 +308,6 @@ function rowToWorker(row) {
     costUsd: row.cost_usd
   };
 }
-function createWorker(worker) {
-  const db = getDb();
-  const id = worker.id ?? uuidv43();
-  const status = worker.status ?? "pending";
-  const spawnedAt = worker.spawnedAt ?? Date.now();
-  const completedAt = worker.completedAt ?? null;
-  const costUsd = worker.costUsd ?? 0;
-  db.prepare(
-    `INSERT INTO workers (id, leader_id, meeting_id, task_description, task_type, status, input_context, output_result, error_message, dependencies, spawned_at, completed_at, cost_usd)
-     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
-  ).run(
-    id,
-    worker.leaderId,
-    worker.meetingId,
-    worker.taskDescription,
-    worker.taskType,
-    status,
-    worker.inputContext,
-    worker.outputResult,
-    worker.errorMessage,
-    JSON.stringify(worker.dependencies),
-    spawnedAt,
-    completedAt,
-    costUsd
-  );
-  return {
-    id,
-    leaderId: worker.leaderId,
-    meetingId: worker.meetingId,
-    taskDescription: worker.taskDescription,
-    taskType: worker.taskType,
-    status,
-    inputContext: worker.inputContext,
-    outputResult: worker.outputResult,
-    errorMessage: worker.errorMessage,
-    dependencies: worker.dependencies,
-    spawnedAt,
-    completedAt,
-    costUsd
-  };
-}
 function getWorker(id) {
   const db = getDb();
   const row = db.prepare("SELECT * FROM workers WHERE id = ?").get(id);
@@ -554,20 +513,6 @@ function getTasksFromMinutes(meetingId) {
 }
 
 // src/types/agent.ts
-var TIER_CONFIGS = {
-  orchestrator: {
-    model: "claude-opus-4-6",
-    maxTurns: 10
-  },
-  leader: {
-    model: "claude-sonnet-4-6",
-    maxTurns: 20
-  },
-  worker: {
-    model: "claude-sonnet-4-6",
-    maxTurns: 30
-  }
-};
 var DEPARTMENT_TOOLS = {
   architecture: ["Read", "Grep", "Glob"],
   engineering: ["Read", "Grep", "Glob", "Write", "Edit", "Bash"],
@@ -576,13 +521,6 @@ var DEPARTMENT_TOOLS = {
   research: ["Read", "Grep", "Glob", "WebSearch"]
 };
 
-// src/types/meeting.ts
-var DEFAULT_MEETING_CONFIG = {
-  maxRoundsPerItem: 3,
-  convergenceThreshold: 0.8,
-  model: "claude-sonnet-4-6"
-};
-
 // src/agents/departments.ts
 var DEPARTMENT_REGISTRY = /* @__PURE__ */ new Map([
   [
@@ -836,1489 +774,6 @@ var LeaderPool = class {
   }
 };
 
-// src/agents/leader-prompts.ts
-function rulesBlock(extraRules) {
-  const base = [
-    "Never modify files outside the project root unless explicitly told to.",
-    "Never commit, push, or deploy without a confirmed user decision.",
-    "If you encounter ambiguity that could lead to significant rework, emit @USER_DECISION_NEEDED immediately rather than guessing.",
-    "Keep responses concise. Prefer structured output (lists, tables) over prose.",
-    "When delegating to workers, provide clear task descriptions with explicit acceptance criteria.",
-    "Respect the tool allowlist for your department \u2014 do not attempt to use tools you have not been granted.",
-    "Report cost and token usage whenever you complete a significant sub-task."
-  ];
-  const rules = extraRules ? [...base, ...extraRules] : base;
-  return rules.map((r, i) => `${i + 1}. ${r}`).join("\n");
-}
-function meetingProtocol() {
-  return `## MEETING PROTOCOL
-
-When participating in a meeting you MUST follow these rules:
-
-1. **Opening phase** \u2014 Listen to the agenda presented by the orchestrator. Acknowledge understanding. Surface any concerns or dependencies your department has regarding the agenda items.
-
-2. **Discussion phase** \u2014 Contribute your department's perspective on each agenda item. Be specific: reference files, modules, or prior decisions. If you disagree with another leader, state your reasoning clearly and propose an alternative.
-
-3. **When to emit @USER_DECISION_NEEDED** \u2014 Emit this tag ONLY when:
-   - Two or more leaders have irreconcilable positions after a full discussion round.
-   - A decision has significant cost, security, or architectural implications that exceed the meeting's delegated authority.
-   - The user explicitly asked to be looped in on a particular topic.
-   Include: a concise summary of the options, who supports each option, and your recommended default.
-
-4. **Synthesis phase** \u2014 Confirm or amend the proposed action items. Ensure your department's commitments are accurate and achievable.
-
-5. **Post-meeting** \u2014 Execute your assigned action items by spawning workers or performing lightweight tasks directly.`;
-}
-function workforceManagement(deptDescription, workerTypes) {
-  return `## WORKFORCE MANAGEMENT
-
-You lead the department: ${deptDescription}
-
-Available worker types you can spawn: ${workerTypes.join(", ")}
-
-### When to spawn workers
-- Spawn workers for tasks that require focused execution (file changes, test runs, research).
-- Do NOT spawn workers for simple questions you can answer from context.
-- Prefer spawning multiple independent workers in parallel over sequential single-worker chains.
-
-### How to spawn workers
-When you decide a worker is needed, output a structured worker-spawn request:
-\`\`\`
-SPAWN_WORKER:
-  type: <worker-type>
-  task: <one-line description>
-  context: <relevant files, decisions, or constraints>
-  acceptance_criteria:
-    - <criterion 1>
-    - <criterion 2>
-\`\`\`
-
-### Aggregating results
-When workers complete, review their output:
-- If a worker succeeded \u2014 incorporate the result and move forward.
-- If a worker failed \u2014 diagnose the failure. Retry with adjusted instructions or escalate in the meeting.
-- Summarise aggregated results before reporting back to the meeting.`;
-}
-var IDENTITIES = {
-  "arch-leader": `## IDENTITY
-
-You are the **Architecture Leader**. You own system design decisions for this project.
-
-Your responsibilities:
-- Evaluate and propose system architecture (module boundaries, data flow, APIs).
-- Design database schemas and data models.
-- Analyse dependency graphs and flag coupling or circular-dependency risks.
-- Ensure new features fit the existing architecture; propose refactors when they do not.
-- Produce architecture decision records (ADRs) when significant choices are made.
-
-You are a planner, not an implementer. You produce blueprints and hand implementation to Engineering.`,
-  "eng-leader": `## IDENTITY
-
-You are the **Engineering Leader**. You own code quality and delivery for this project.
-
-Your responsibilities:
-- Break down approved designs into implementable tasks.
-- Assign coding work to feature-dev, bug-fixer, and refactorer workers.
-- Review worker output for correctness, style, and adherence to project conventions.
-- Coordinate with QA to ensure changes are testable.
-- Flag technical debt and propose refactoring when it reaches a threshold.
-
-You write and ship code through your workers. You translate architecture into working software.`,
-  "qa-leader": `## IDENTITY
-
-You are the **QA Leader**. You own quality assurance, testing strategy, and security posture.
-
-Your responsibilities:
-- Define test plans: unit tests, integration tests, and end-to-end flows.
-- Spawn test-writer workers to create tests for new or changed code.
-- Spawn test-runner workers to execute test suites and report results.
-- Spawn security-auditor workers when new dependencies or sensitive code paths are introduced.
-- Spawn perf-tester workers for performance-critical changes.
-- Block merges that lack adequate test coverage or have failing tests.
-
-You are the project's quality gate. Nothing ships without your sign-off.`,
-  "pm-leader": `## IDENTITY
-
-You are the **Product Leader**. You own requirements clarity and user-facing coherence.
-
-Your responsibilities:
-- Analyse user requests and translate them into structured requirements.
-- Map user flows to ensure feature completeness and good UX.
-- Prioritise work items when resources are limited.
-- Ensure the team is building what the user actually asked for, not what was assumed.
-- Write acceptance criteria that other departments can verify against.
-
-You are the voice of the user inside the team. You bridge intent and implementation.`,
-  "research-leader": `## IDENTITY
-
-You are the **Research Leader**. You own information gathering and knowledge synthesis.
-
-Your responsibilities:
-- Explore the existing codebase to answer questions from other departments.
-- Search documentation, READMEs, and external resources for relevant context.
-- Run benchmarks when quantitative data is needed for a decision.
-- Summarise findings in a structured, citable format.
-- Maintain a knowledge base of discovered facts about the project.
-
-You provide the evidence base. Other departments make decisions; you supply the facts.`
-};
-function getLeaderSystemPrompt(department, rules, projectContext) {
-  const dept = getDepartment(department);
-  const identity = IDENTITIES[dept.leaderRole];
-  if (!identity) {
-    throw new Error(`No identity prompt defined for leader role: ${dept.leaderRole}`);
-  }
-  const sections = [
-    identity,
-    meetingProtocol(),
-    workforceManagement(dept.description, dept.workerTypes),
-    `## RULES
-
-${rulesBlock(rules)}`
-  ];
-  if (projectContext) {
-    sections.push(projectContext);
-  }
-  return sections.join("\n\n");
-}
-
-// src/agents/tiers.ts
-function getTierConfig(tier) {
-  const config = TIER_CONFIGS[tier];
-  if (!config) {
-    throw new Error(`Unknown agent tier: ${tier}`);
-  }
-  return { ...config };
-}
-
-// src/agents/worker-prompts.ts
-var WORKER_DESCRIPTIONS = {
-  // Architecture workers
-  "schema-designer": "You design database schemas and data models. Output CREATE TABLE statements, type definitions, or ERD descriptions.",
-  "api-designer": "You design API surfaces \u2014 REST endpoints, RPC methods, or function signatures. Output OpenAPI snippets or typed interface definitions.",
-  "dependency-analyzer": "You analyse project dependencies and module coupling. Output dependency graphs, circular-dependency reports, or upgrade recommendations.",
-  // Engineering workers
-  "feature-dev": "You implement new features by writing production code. Follow the project conventions. Output complete, working code changes.",
-  "bug-fixer": "You diagnose and fix bugs. Read the relevant code, identify the root cause, and produce a minimal correct fix.",
-  "refactorer": "You improve existing code without changing its behaviour. Focus on readability, performance, or reducing duplication.",
-  // QA workers
-  "test-writer": "You write test cases \u2014 unit, integration, or end-to-end. Ensure each test has a clear assertion and covers the acceptance criteria.",
-  "test-runner": "You execute test suites and report results. Run commands, capture output, and summarise pass/fail counts and failures.",
-  "security-auditor": "You audit code for security vulnerabilities \u2014 injection, auth issues, insecure dependencies, exposed secrets. Output a structured finding list.",
-  "perf-tester": "You run performance tests and benchmarks. Measure response time, throughput, or resource usage and report quantitative results.",
-  // Product workers
-  "requirements-analyzer": "You analyse user requests and existing documentation to produce structured requirements with acceptance criteria.",
-  "user-flow-mapper": "You trace user-facing flows through the system \u2014 from input to output \u2014 and document each step, decision point, and edge case.",
-  // Research workers
-  "code-explorer": "You explore the codebase to answer specific questions. Read files, trace call chains, and summarise your findings.",
-  "doc-searcher": "You search documentation, READMEs, comments, and external references to find relevant information.",
-  "benchmark-runner": "You run benchmarks and collect quantitative data. Output structured results with methodology notes.",
-  // Cross-cutting workers
-  "minutes-writer": "You write structured meeting minutes from a transcript. Output: summary, decisions, action items, and @mentions.",
-  compactor: "You compact long conversation transcripts into a shorter summary that preserves all decisions, action items, and open questions."
-};
-function buildWorkerPrompt(opts) {
-  const { workerType, department, task, context, projectContext } = opts;
-  const description = WORKER_DESCRIPTIONS[workerType];
-  if (!description) {
-    throw new Error(`Unknown worker type: ${workerType}`);
-  }
-  const sections = [
-    `## IDENTITY
-
-You are a **${workerType}** worker in the **${department}** department.
-
-${description}`,
-    `## TASK
-
-${task}`
-  ];
-  if (context) {
-    sections.push(`## CONTEXT
-
-${context}`);
-  }
-  if (projectContext) {
-    sections.push(projectContext);
-  }
-  sections.push(`## OUTPUT RULES
-
-1. Stay focused on the single task above. Do not wander into unrelated work.
-2. If the task is impossible or blocked, explain why clearly and stop \u2014 do not produce partial or guessed output.
-3. Prefer structured output: code blocks, lists, tables.
-4. Include file paths (always absolute) when referencing code.
-5. When your task is complete, end with a brief summary of what you did and any caveats.
-6. Respect the tool allowlist for the ${department} department \u2014 do not attempt to use tools you have not been granted.
-7. Do not commit, push, or deploy. Your output will be reviewed by your leader before any permanent action is taken.`);
-  return sections.join("\n\n");
-}
-
-// src/agents/agent-factory.ts
-var ORCHESTRATOR_SYSTEM_PROMPT = `## IDENTITY
-
-You are the **Orchestrator** \u2014 a proxy and router, NOT a CEO. Your job is to receive the user's request, decompose it into department-level concerns, convene meetings, and route work to the appropriate leaders. You do not make product, architecture, or engineering decisions yourself.
-
-## CORE RESPONSIBILITIES
-
-1. **Request analysis** \u2014 When the user submits a request, determine which departments are relevant. Most requests involve 2-4 departments.
-
-2. **Meeting convening** \u2014 Create a meeting with an agenda derived from the request. Invite the relevant leaders. You chair the meeting but you do not dominate it.
-
-3. **Auto-routing** \u2014 For straightforward, single-department tasks (e.g., "run the tests"), skip the full meeting flow and route directly to the responsible leader.
-
-4. **@USER mentions** \u2014 When a leader emits @USER_DECISION_NEEDED during a meeting:
-   - Pause the meeting.
-   - Surface the decision to the user with full context (options, trade-offs, supporters).
-   - Resume the meeting once the user responds.
-
-5. **Progress tracking** \u2014 Monitor worker completion events. Nudge leaders if a task is overdue or failed. Report final results back to the user.
-
-## RULES
-
-1. You are a facilitator. Do NOT override leader recommendations unless they conflict with an explicit user instruction.
-2. Keep your own token usage minimal \u2014 delegate analysis and execution to leaders and workers.
-3. Always preserve the user's exact wording when forwarding a request to a meeting.
-4. If the user's request is ambiguous, ask a clarifying question BEFORE convening a meeting.
-5. Never modify files, run tests, or execute code directly. All execution happens through workers spawned by leaders.
-6. When multiple departments disagree, facilitate resolution. Escalate to the user only when the team cannot converge after a full discussion round.
-7. After a meeting completes, provide the user with a concise summary: decisions made, action items, and any pending @USER items.
-8. Respect budget limits. If projected cost approaches the meeting budget, warn the user and request approval before proceeding.
-
-## DEPARTMENT OVERVIEW
-
-You can route work to these departments:
-- **architecture** \u2014 System design, schemas, API surfaces, dependency analysis.
-- **engineering** \u2014 Feature implementation, bug fixes, refactoring.
-- **qa** \u2014 Testing, security audits, performance testing.
-- **product** \u2014 Requirements analysis, user-flow mapping, prioritisation.
-- **research** \u2014 Codebase exploration, documentation search, benchmarks.
-
-## OUTPUT FORMAT
-
-When you need to convene a meeting, output:
-\`\`\`
-CONVENE_MEETING:
-  topic: <meeting topic>
-  agenda:
-    - <item 1>
-    - <item 2>
-  departments:
-    - <dept 1>
-    - <dept 2>
-\`\`\`
-
-When you route directly to a leader (no meeting), output:
-\`\`\`
-DIRECT_ROUTE:
-  department: <department>
-  task: <task description>
-\`\`\`
-`;
-function createAgentConfig(opts) {
-  const { tier, role, department, task, context } = opts;
-  const tierCfg = getTierConfig(tier);
-  const allowedTools = [...DEPARTMENT_TOOLS[department] ?? []];
-  let systemPrompt;
-  switch (tier) {
-    case "orchestrator": {
-      systemPrompt = ORCHESTRATOR_SYSTEM_PROMPT;
-      break;
-    }
-    case "leader": {
-      systemPrompt = getLeaderSystemPrompt(department);
-      break;
-    }
-    case "worker": {
-      if (!task) {
-        throw new Error("Worker agents require a task description");
-      }
-      systemPrompt = buildWorkerPrompt({
-        workerType: role,
-        department,
-        task,
-        context
-      });
-      break;
-    }
-    default: {
-      const _exhaustive = tier;
-      throw new Error(`Unknown tier: ${_exhaustive}`);
-    }
-  }
-  const model = tier === "worker" && department === "research" ? "claude-haiku-4-5" : tierCfg.model;
-  return {
-    model,
-    maxTurns: tierCfg.maxTurns,
-    allowedTools
-  };
-}
-
-// src/agents/claude-invoker.ts
-import { spawn } from "child_process";
-import { execSync } from "child_process";
-var _claudeAvailable = null;
-function isClaudeAvailable() {
-  if (_claudeAvailable !== null) return _claudeAvailable;
-  try {
-    execSync("which claude", { stdio: "ignore" });
-    _claudeAvailable = true;
-  } catch {
-    _claudeAvailable = false;
-  }
-  return _claudeAvailable;
-}
-function isMockMode() {
-  if (process.env["COLESLAW_MOCK"] === "1") return true;
-  return !isClaudeAvailable();
-}
-async function invokeMock(options) {
-  await new Promise((resolve) => setTimeout(resolve, 30 + Math.random() * 70));
-  const lower = options.prompt.toLowerCase();
-  let output;
-  if (lower.includes("opening") || lower.includes("initial position")) {
-    output = "[Mock] Acknowledged the agenda. From my department perspective, I see several important considerations. We should ensure proper separation of concerns and define clear boundaries. Key concern: we must avoid tight coupling between new and existing components.";
-  } else if (lower.includes("synthesis") || lower.includes("final position")) {
-    output = "[Mock] FINAL POSITION: I support the agreed approach. Action items for my department: (1) Deliver the agreed outputs, (2) Coordinate with dependent departments, (3) Report completion status once done.";
-  } else if (lower.includes("discussion") || lower.includes("perspective")) {
-    output = "[Mock] Building on the previous points, I propose we move forward with the discussed approach. This aligns with existing patterns and allows parallel work across departments. I can have my team start on the deliverables immediately.";
-  } else if (lower.includes("schema") || lower.includes("design")) {
-    output = "[Mock] Schema analysis complete. Proposed 3 tables with proper foreign-key relationships and indexes. No circular dependencies detected.";
-  } else if (lower.includes("test")) {
-    output = "[Mock] Test suite generated: 8 unit tests, 2 integration tests. All assertions use strict equality. Coverage target: 90%.";
-  } else if (lower.includes("implement") || lower.includes("build") || lower.includes("feature")) {
-    output = "[Mock] Implementation complete. Created 2 new files, modified 1 existing file. All changes follow project conventions.";
-  } else if (lower.includes("research") || lower.includes("explore")) {
-    output = "[Mock] Research complete. Found 5 relevant code references and 2 documentation entries. Summary provided in structured format.";
-  } else if (lower.includes("security") || lower.includes("audit")) {
-    output = "[Mock] Security audit complete. No critical vulnerabilities found. 1 advisory: ensure input validation on user-facing endpoints.";
-  } else if (lower.includes("fix") || lower.includes("bug")) {
-    output = "[Mock] Bug fix applied. Root cause identified and corrected. Fix verified with regression test.";
-  } else {
-    output = "[Mock] Task completed successfully. Output ready for review.";
-  }
-  return {
-    success: true,
-    output,
-    costUsd: 0
-  };
-}
-async function invokeReal(options) {
-  const {
-    prompt,
-    systemPrompt,
-    allowedTools,
-    maxTurns,
-    cwd,
-    timeoutMs = 3e5
-  } = options;
-  const args = [
-    "--print",
-    "--output-format",
-    "json",
-    "--no-session-persistence",
-    "--bare"
-    // CRITICAL: skip hooks, plugins, MCP — prevents infinite recursion
-  ];
-  if (systemPrompt) {
-    args.push("--system-prompt", systemPrompt);
-  }
-  if (allowedTools.length > 0) {
-    args.push("--allowedTools", allowedTools.join(","));
-  }
-  logger.info("Invoking Claude CLI", {
-    promptLength: prompt.length,
-    toolCount: allowedTools.length
-  });
-  return new Promise((resolve) => {
-    const child = spawn("claude", args, {
-      cwd: cwd ?? process.cwd(),
-      stdio: ["pipe", "pipe", "pipe"],
-      env: { ...process.env }
-    });
-    child.stdin.write(prompt);
-    child.stdin.end();
-    const stdoutChunks = [];
-    const stderrChunks = [];
-    child.stdout.on("data", (chunk) => {
-      stdoutChunks.push(chunk);
-    });
-    child.stderr.on("data", (chunk) => {
-      stderrChunks.push(chunk);
-    });
-    const timer = setTimeout(() => {
-      logger.warn("Claude CLI timed out, killing process", { timeoutMs });
-      child.kill("SIGTERM");
-      setTimeout(() => {
-        if (!child.killed) child.kill("SIGKILL");
-      }, 5e3);
-    }, timeoutMs);
-    child.on("close", (code) => {
-      clearTimeout(timer);
-      const rawStdout = Buffer.concat(stdoutChunks).toString("utf-8");
-      const rawStderr = Buffer.concat(stderrChunks).toString("utf-8");
-      if (code !== 0) {
-        logger.error("Claude CLI exited with non-zero code", {
-          exitCode: String(code)
-        });
-        resolve({
-          success: false,
-          output: "",
-          error: rawStderr || `Claude CLI exited with code ${code}`
-        });
-        return;
-      }
-      const parsed = parseCliOutput(rawStdout);
-      logger.info("Claude CLI invocation completed", {
-        outputLength: String(parsed.output.length)
-      });
-      resolve(parsed);
-    });
-    child.on("error", (err) => {
-      clearTimeout(timer);
-      logger.error("Failed to spawn Claude CLI", { error: err.message });
-      resolve({
-        success: false,
-        output: "",
-        error: `Failed to spawn Claude CLI: ${err.message}`
-      });
-    });
-  });
-}
-function parseCliOutput(raw) {
-  const trimmed = raw.trim();
-  if (!trimmed) {
-    return { success: false, output: "", error: "Empty output from Claude CLI" };
-  }
-  try {
-    const json = JSON.parse(trimmed);
-    if (json.is_error || json.error) {
-      return {
-        success: false,
-        output: json.result ?? json.output ?? "",
-        error: json.error ?? "Unknown CLI error",
-        costUsd: json.cost_usd
-      };
-    }
-    return {
-      success: true,
-      output: json.result ?? json.output ?? trimmed,
-      costUsd: json.cost_usd
-    };
-  } catch {
-    return {
-      success: true,
-      output: trimmed
-    };
-  }
-}
-async function invokeClaude(options) {
-  if (isMockMode()) {
-    if (!isClaudeAvailable()) {
-      logger.warn("Claude CLI not found on PATH \u2014 using mock mode");
-    } else {
-      logger.info("COLESLAW_MOCK=1 set \u2014 using mock mode");
-    }
-    return invokeMock(options);
-  }
-  return invokeReal(options);
-}
-function buildInvokeOptions(config, prompt, systemPrompt, cwd) {
-  return {
-    prompt,
-    systemPrompt,
-    allowedTools: config.allowedTools,
-    maxTurns: config.maxTurns,
-    cwd
-  };
-}
-
-// src/orchestrator/meeting-runner.ts
-async function queryAgent(config, prompt) {
-  const agentConfig = createAgentConfig({
-    tier: "leader",
-    role: config.role,
-    department: config.department
-  });
-  const invokeOpts = buildInvokeOptions(
-    agentConfig,
-    prompt,
-    config.systemPrompt
-  );
-  invokeOpts.timeoutMs = 6e5;
-  const result = await invokeClaude(invokeOpts);
-  if (!result.success) {
-    logger.warn(`Agent query failed for ${config.role}: ${result.error}`);
-    return `[Error from ${config.role}] ${result.error ?? "Unknown error during agent invocation"}`;
-  }
-  return result.output;
-}
-function insertTranscriptEntry(meetingId, speakerId, speakerRole, agendaItemIndex, roundNumber, content) {
-  const db = getDb();
-  const now = Date.now();
-  const tokenCount = Math.ceil(content.length / 4);
-  const result = db.prepare(
-    `INSERT INTO transcript_entries
-         (meeting_id, speaker_id, speaker_role, agenda_item_index, round_number, content, token_count, created_at)
-       VALUES (?, ?, ?, ?, ?, ?, ?, ?)`
-  ).run(meetingId, speakerId, speakerRole, agendaItemIndex, roundNumber, content, tokenCount, now);
-  return {
-    id: Number(result.lastInsertRowid),
-    meetingId,
-    speakerId,
-    speakerRole,
-    agendaItemIndex,
-    roundNumber,
-    content,
-    tokenCount,
-    createdAt: now
-  };
-}
-function getTranscript(meetingId) {
-  const db = getDb();
-  const rows = db.prepare("SELECT * FROM transcript_entries WHERE meeting_id = ? ORDER BY created_at ASC").all(meetingId);
-  return rows.map((r) => ({
-    id: r.id,
-    meetingId: r.meeting_id,
-    speakerId: r.speaker_id,
-    speakerRole: r.speaker_role,
-    agendaItemIndex: r.agenda_item_index,
-    roundNumber: r.round_number,
-    content: r.content,
-    tokenCount: r.token_count,
-    createdAt: r.created_at
-  }));
-}
-var MeetingRunner = class {
-  meetingId;
-  leaders;
-  maxRoundsPerItem;
-  projectContext;
-  constructor(meetingId, leaders, projectContext) {
-    this.meetingId = meetingId;
-    this.leaders = leaders;
-    this.maxRoundsPerItem = DEFAULT_MEETING_CONFIG.maxRoundsPerItem;
-    this.projectContext = projectContext;
-  }
-  // ---- public entry point -------------------------------------------------
-  /**
-   * Run the complete meeting lifecycle: opening -> discussion -> synthesis -> minutes.
-   */
-  async run() {
-    const meeting = getMeeting(this.meetingId);
-    if (!meeting) {
-      throw new Error(`Meeting not found: ${this.meetingId}`);
-    }
-    logger.info(`Starting meeting: ${meeting.topic}`, { meetingId: this.meetingId });
-    try {
-      await this.openingPhase();
-      await this.discussionPhase();
-      await this.synthesisPhase();
-      await this.generateMinutes();
-      updateMeeting(this.meetingId, {
-        status: "completed",
-        completedAt: Date.now()
-      });
-      logger.info(`Meeting completed: ${meeting.topic}`, { meetingId: this.meetingId });
-    } catch (err) {
-      const errorMsg = err instanceof Error ? err.message : String(err);
-      logger.error(`Meeting failed: ${errorMsg}`, { meetingId: this.meetingId });
-      updateMeeting(this.meetingId, {
-        status: "failed",
-        completedAt: Date.now()
-      });
-      throw err;
-    }
-  }
-  // ---- phases -------------------------------------------------------------
-  /**
-   * Opening phase: each leader states their initial position on the meeting
-   * topic and agenda.
-   */
-  async openingPhase() {
-    this.setPhase("opening");
-    const meeting = getMeeting(this.meetingId);
-    const agendaText = meeting.agenda.map((a, i) => `  ${i + 1}. ${a}`).join("\n");
-    for (const leader of this.leaders) {
-      const prompt = `MEETING OPENING
-
-Topic: ${meeting.topic}
-Agenda:
-${agendaText}
-
-Please state your initial position on this topic from your department's perspective. Identify any concerns, dependencies, or risks relevant to your area.`;
-      const config = {
-        role: leader.role,
-        department: leader.department,
-        systemPrompt: getLeaderSystemPrompt(leader.department, void 0, this.projectContext)
-      };
-      const response = await queryAgent(config, prompt);
-      insertTranscriptEntry(
-        this.meetingId,
-        leader.id,
-        leader.role,
-        -1,
-        // -1 signals the opening phase (not tied to a specific agenda item)
-        0,
-        response
-      );
-      eventBus.emitAgentEvent({
-        kind: "message_sent",
-        fromId: leader.id,
-        toId: "meeting",
-        summary: `[Opening] ${leader.role}: ${response.slice(0, 80)}...`
-      });
-      logger.debug(`Opening statement from ${leader.role}`, {
-        meetingId: this.meetingId,
-        agentId: leader.id
-      });
-    }
-  }
-  /**
-   * Discussion phase: for each agenda item, leaders take turns responding in
-   * round-robin fashion for up to `maxRoundsPerItem` rounds.
-   */
-  async discussionPhase() {
-    this.setPhase("discussion");
-    const meeting = getMeeting(this.meetingId);
-    for (let itemIdx = 0; itemIdx < meeting.agenda.length; itemIdx++) {
-      const agendaItem = meeting.agenda[itemIdx];
-      logger.info(`Discussing agenda item ${itemIdx + 1}: ${agendaItem}`, {
-        meetingId: this.meetingId
-      });
-      for (let round = 1; round <= this.maxRoundsPerItem; round++) {
-        for (const leader of this.leaders) {
-          const transcript = getTranscript(this.meetingId);
-          const transcriptText = this.formatTranscript(transcript);
-          const prompt = `MEETING DISCUSSION \u2014 Round ${round}/${this.maxRoundsPerItem}
-
-Current agenda item (${itemIdx + 1}/${meeting.agenda.length}): ${agendaItem}
-
-Transcript so far:
-${transcriptText}
-
-Provide your department's perspective on this agenda item. Build on what others have said. If you agree, say so and add specifics. If you disagree, state your reasoning and propose an alternative.`;
-          const config = {
-            role: leader.role,
-            department: leader.department,
-            systemPrompt: getLeaderSystemPrompt(leader.department, void 0, this.projectContext)
-          };
-          const response = await queryAgent(config, prompt);
-          insertTranscriptEntry(
-            this.meetingId,
-            leader.id,
-            leader.role,
-            itemIdx,
-            round,
-            response
-          );
-          eventBus.emitAgentEvent({
-            kind: "message_sent",
-            fromId: leader.id,
-            toId: "meeting",
-            summary: `[Item ${itemIdx + 1}, R${round}] ${leader.role}: ${response.slice(0, 80)}...`
-          });
-        }
-      }
-    }
-  }
-  /**
-   * Synthesis phase: each leader states their final position, commitments,
-   * and action items.
-   */
-  async synthesisPhase() {
-    this.setPhase("synthesis");
-    const transcript = getTranscript(this.meetingId);
-    const transcriptText = this.formatTranscript(transcript);
-    for (const leader of this.leaders) {
-      const prompt = `MEETING SYNTHESIS
-
-The discussion is complete. Here is the full transcript:
-${transcriptText}
-
-State your final position. List the action items your department commits to. Flag any unresolved concerns or items requiring user decision.`;
-      const config = {
-        role: leader.role,
-        department: leader.department,
-        systemPrompt: getLeaderSystemPrompt(leader.department, void 0, this.projectContext)
-      };
-      const response = await queryAgent(config, prompt);
-      insertTranscriptEntry(
-        this.meetingId,
-        leader.id,
-        leader.role,
-        -2,
-        // -2 signals synthesis phase
-        0,
-        response
-      );
-      eventBus.emitAgentEvent({
-        kind: "message_sent",
-        fromId: leader.id,
-        toId: "meeting",
-        summary: `[Synthesis] ${leader.role}: ${response.slice(0, 80)}...`
-      });
-    }
-  }
-  /**
-   * Generate meeting minutes by concatenating and formatting the transcript.
-   *
-   * In the future this will use a dedicated minutes-writer agent.  For now it
-   * formats the transcript into a structured summary.
-   */
-  async generateMinutes() {
-    this.setPhase("minutes-generation");
-    const meeting = getMeeting(this.meetingId);
-    const transcript = getTranscript(this.meetingId);
-    const sections = [];
-    sections.push(`# Meeting Minutes`);
-    sections.push(`## Topic: ${meeting.topic}`);
-    sections.push(`## Date: ${(/* @__PURE__ */ new Date()).toISOString()}`);
-    sections.push(`## Participants: ${this.leaders.map((l) => l.role).join(", ")}`);
-    sections.push("");
-    sections.push(`## Agenda`);
-    meeting.agenda.forEach((item, i) => {
-      sections.push(`${i + 1}. ${item}`);
-    });
-    sections.push("");
-    const openingEntries = transcript.filter((e) => e.agendaItemIndex === -1);
-    if (openingEntries.length > 0) {
-      sections.push(`## Opening Statements`);
-      for (const entry of openingEntries) {
-        sections.push(`### ${entry.speakerRole}`);
-        sections.push(entry.content);
-        sections.push("");
-      }
-    }
-    for (let i = 0; i < meeting.agenda.length; i++) {
-      const itemEntries = transcript.filter((e) => e.agendaItemIndex === i);
-      if (itemEntries.length > 0) {
-        sections.push(`## Discussion: ${meeting.agenda[i]}`);
-        for (const entry of itemEntries) {
-          sections.push(`**${entry.speakerRole}** (round ${entry.roundNumber}):`);
-          sections.push(entry.content);
-          sections.push("");
-        }
-      }
-    }
-    const synthesisEntries = transcript.filter((e) => e.agendaItemIndex === -2);
-    if (synthesisEntries.length > 0) {
-      sections.push(`## Final Positions`);
-      for (const entry of synthesisEntries) {
-        sections.push(`### ${entry.speakerRole}`);
-        sections.push(entry.content);
-        sections.push("");
-      }
-    }
-    const content = sections.join("\n");
-    const actionItems = this.leaders.map((leader, idx) => ({
-      id: `action-${this.meetingId}-${idx}`,
-      title: `${leader.role} deliverables`,
-      description: `Action items committed by ${leader.role} during synthesis phase`,
-      assignedDepartment: leader.department,
-      assignedRole: leader.role,
-      priority: "medium",
-      dependencies: [],
-      acceptanceCriteria: ["Deliverables completed as stated in final position"]
-    }));
-    createMinutes({
-      meetingId: this.meetingId,
-      format: "summary",
-      content,
-      actionItems
-    });
-    logger.info("Minutes generated", { meetingId: this.meetingId });
-  }
-  // ---- helpers ------------------------------------------------------------
-  setPhase(phase) {
-    const statusMap = {
-      "orchestrator-phase": "pending",
-      "convening": "convening",
-      "opening": "opening",
-      "discussion": "discussion",
-      "research-break": "discussion",
-      "synthesis": "synthesis",
-      "minutes-generation": "minutes-generation"
-    };
-    updateMeeting(this.meetingId, {
-      phase,
-      status: statusMap[phase] ?? "discussion"
-    });
-    logger.debug(`Meeting phase: ${phase}`, { meetingId: this.meetingId });
-  }
-  formatTranscript(entries) {
-    if (entries.length === 0) return "(No transcript entries yet)";
-    return entries.map((e) => {
-      let phaseLabel;
-      if (e.agendaItemIndex === -1) phaseLabel = "Opening";
-      else if (e.agendaItemIndex === -2) phaseLabel = "Synthesis";
-      else phaseLabel = `Item ${e.agendaItemIndex + 1}, Round ${e.roundNumber}`;
-      return `[${phaseLabel}] ${e.speakerRole}: ${e.content}`;
-    }).join("\n\n");
-  }
-};
-
-// src/agents/project-analyzer.ts
-import { existsSync, readFileSync, readdirSync, statSync } from "fs";
-import { join, basename, extname } from "path";
-var CONFIG_FILE_PATTERNS = [
-  "tsconfig.json",
-  "tsconfig.build.json",
-  "tsconfig.node.json",
-  ".eslintrc",
-  ".eslintrc.js",
-  ".eslintrc.cjs",
-  ".eslintrc.json",
-  ".eslintrc.yml",
-  ".eslintrc.yaml",
-  "eslint.config.js",
-  "eslint.config.mjs",
-  "eslint.config.cjs",
-  "eslint.config.ts",
-  ".prettierrc",
-  ".prettierrc.js",
-  ".prettierrc.cjs",
-  ".prettierrc.json",
-  ".prettierrc.yml",
-  ".prettierrc.yaml",
-  "prettier.config.js",
-  "prettier.config.mjs",
-  "prettier.config.cjs",
-  "biome.json",
-  "biome.jsonc",
-  "vite.config.ts",
-  "vite.config.js",
-  "vite.config.mjs",
-  "webpack.config.js",
-  "webpack.config.ts",
-  "webpack.config.mjs",
-  "rollup.config.js",
-  "rollup.config.ts",
-  "rollup.config.mjs",
-  "tsup.config.ts",
-  "tsup.config.js",
-  "esbuild.config.js",
-  "esbuild.config.ts",
-  "jest.config.js",
-  "jest.config.ts",
-  "jest.config.mjs",
-  "vitest.config.ts",
-  "vitest.config.js",
-  "vitest.config.mts",
-  ".mocharc.yml",
-  ".mocharc.json",
-  ".mocharc.js",
-  ".babelrc",
-  "babel.config.js",
-  "babel.config.json",
-  ".swcrc",
-  "turbo.json",
-  "nx.json"
-];
-var UTIL_DIR_NAMES = ["utils", "lib", "helpers", "shared", "common"];
-var MANIFEST_FILES = [
-  // -- JavaScript / TypeScript --
-  {
-    file: "package.json",
-    language: "typescript",
-    // refined later if no TS config
-    parse: (content) => {
-      const raw = JSON.parse(content);
-      return {
-        dependencies: raw.dependencies ?? {},
-        devDependencies: raw.devDependencies ?? {},
-        scripts: raw.scripts ?? {},
-        metadata: { type: raw.type ?? "commonjs", name: raw.name ?? "" }
-      };
-    }
-  },
-  // -- Python --
-  {
-    file: "pyproject.toml",
-    language: "python",
-    parse: (content) => {
-      const deps = {};
-      const devDeps = {};
-      const scripts = {};
-      for (const m of content.matchAll(/^\s*"([^"]+?)(?:[><=!~]+.*)?".*$/gm)) {
-        deps[m[1]] = "*";
-      }
-      for (const m of content.matchAll(/^(\w[\w-]*)\s*=\s*"([^"]+)"/gm)) {
-        scripts[m[1]] = m[2];
-      }
-      return { dependencies: deps, devDependencies: devDeps, scripts, metadata: {} };
-    }
-  },
-  {
-    file: "requirements.txt",
-    language: "python",
-    parse: (content) => {
-      const deps = {};
-      for (const line of content.split("\n")) {
-        const trimmed = line.trim();
-        if (!trimmed || trimmed.startsWith("#") || trimmed.startsWith("-")) continue;
-        const match = trimmed.match(/^([a-zA-Z0-9_-]+)\s*([><=!~].*)?$/);
-        if (match) deps[match[1]] = match[2]?.trim() ?? "*";
-      }
-      return { dependencies: deps, devDependencies: {}, scripts: {}, metadata: {} };
-    }
-  },
-  {
-    file: "Pipfile",
-    language: "python",
-    parse: (content) => {
-      const deps = {};
-      const inPackages = content.indexOf("[packages]");
-      if (inPackages >= 0) {
-        const section = content.slice(inPackages);
-        for (const m of section.matchAll(/^(\w[\w-]*)\s*=\s*"([^"]+)"/gm)) {
-          deps[m[1]] = m[2];
-        }
-      }
-      return { dependencies: deps, devDependencies: {}, scripts: {}, metadata: {} };
-    }
-  },
-  // -- Java / Kotlin (Gradle) --
-  {
-    file: "build.gradle",
-    language: "java",
-    parse: (content) => {
-      const deps = {};
-      for (const m of content.matchAll(/(?:implementation|api|compileOnly)\s+['"]([^'"]+)['"]/g)) {
-        const parts = m[1].split(":");
-        if (parts.length >= 2) deps[`${parts[0]}:${parts[1]}`] = parts[2] ?? "*";
-      }
-      return { dependencies: deps, devDependencies: {}, scripts: {}, metadata: { buildSystem: "gradle" } };
-    }
-  },
-  {
-    file: "build.gradle.kts",
-    language: "kotlin",
-    parse: (content) => {
-      const deps = {};
-      for (const m of content.matchAll(/(?:implementation|api|compileOnly)\s*\(\s*"([^"]+)"\s*\)/g)) {
-        const parts = m[1].split(":");
-        if (parts.length >= 2) deps[`${parts[0]}:${parts[1]}`] = parts[2] ?? "*";
-      }
-      return { dependencies: deps, devDependencies: {}, scripts: {}, metadata: { buildSystem: "gradle-kts" } };
-    }
-  },
-  {
-    file: "pom.xml",
-    language: "java",
-    parse: (content) => {
-      const deps = {};
-      for (const m of content.matchAll(/<dependency>\s*<groupId>([^<]+)<\/groupId>\s*<artifactId>([^<]+)<\/artifactId>(?:\s*<version>([^<]+)<\/version>)?/gs)) {
-        deps[`${m[1]}:${m[2]}`] = m[3] ?? "*";
-      }
-      return { dependencies: deps, devDependencies: {}, scripts: {}, metadata: { buildSystem: "maven" } };
-    }
-  },
-  // -- Go --
-  {
-    file: "go.mod",
-    language: "go",
-    parse: (content) => {
-      const deps = {};
-      for (const m of content.matchAll(/^\s+(\S+)\s+(v[\d.]+\S*)/gm)) {
-        deps[m[1]] = m[2];
-      }
-      const moduleMatch = content.match(/^module\s+(\S+)/m);
-      return { dependencies: deps, devDependencies: {}, scripts: {}, metadata: { module: moduleMatch?.[1] ?? "" } };
-    }
-  },
-  // -- Rust --
-  {
-    file: "Cargo.toml",
-    language: "rust",
-    parse: (content) => {
-      const deps = {};
-      const devDeps = {};
-      let inDeps = false;
-      let inDevDeps = false;
-      for (const line of content.split("\n")) {
-        if (line.match(/^\[dependencies\]/)) {
-          inDeps = true;
-          inDevDeps = false;
-          continue;
-        }
-        if (line.match(/^\[dev-dependencies\]/)) {
-          inDevDeps = true;
-          inDeps = false;
-          continue;
-        }
-        if (line.match(/^\[/)) {
-          inDeps = false;
-          inDevDeps = false;
-          continue;
-        }
-        const m = line.match(/^(\w[\w-]*)\s*=\s*"([^"]+)"/);
-        if (m) {
-          if (inDeps) deps[m[1]] = m[2];
-          if (inDevDeps) devDeps[m[1]] = m[2];
-        }
-      }
-      return { dependencies: deps, devDependencies: devDeps, scripts: {}, metadata: {} };
-    }
-  },
-  // -- Swift --
-  {
-    file: "Package.swift",
-    language: "swift",
-    parse: (content) => {
-      const deps = {};
-      for (const m of content.matchAll(/\.package\s*\(\s*url:\s*"([^"]+)"/g)) {
-        const name = m[1].split("/").pop()?.replace(".git", "") ?? m[1];
-        deps[name] = "*";
-      }
-      return { dependencies: deps, devDependencies: {}, scripts: {}, metadata: {} };
-    }
-  },
-  // -- Dart / Flutter --
-  {
-    file: "pubspec.yaml",
-    language: "dart",
-    parse: (content) => {
-      const deps = {};
-      let inDeps = false;
-      for (const line of content.split("\n")) {
-        if (line.match(/^dependencies:/)) {
-          inDeps = true;
-          continue;
-        }
-        if (line.match(/^\S/) && inDeps) {
-          inDeps = false;
-          continue;
-        }
-        if (inDeps) {
-          const m = line.match(/^\s+(\w[\w_-]*):\s*(.+)?/);
-          if (m) deps[m[1]] = m[2]?.trim() ?? "*";
-        }
-      }
-      return { dependencies: deps, devDependencies: {}, scripts: {}, metadata: {} };
-    }
-  },
-  // -- Ruby --
-  {
-    file: "Gemfile",
-    language: "ruby",
-    parse: (content) => {
-      const deps = {};
-      for (const m of content.matchAll(/gem\s+['"]([^'"]+)['"]/g)) {
-        deps[m[1]] = "*";
-      }
-      return { dependencies: deps, devDependencies: {}, scripts: {}, metadata: {} };
-    }
-  },
-  // -- C# / .NET --
-  {
-    file: "*.csproj",
-    // handled specially in the scanner
-    language: "csharp",
-    parse: (content) => {
-      const deps = {};
-      for (const m of content.matchAll(/<PackageReference\s+Include="([^"]+)"\s+Version="([^"]+)"/g)) {
-        deps[m[1]] = m[2];
-      }
-      return { dependencies: deps, devDependencies: {}, scripts: {}, metadata: { buildSystem: "dotnet" } };
-    }
-  }
-];
-function detectLanguage(projectDir, manifests) {
-  if (manifests.length === 0) return "unknown";
-  if (existsSync(join(projectDir, "tsconfig.json"))) return "typescript";
-  const languages = manifests.map((m) => m.language);
-  if (languages.includes("typescript")) return "typescript";
-  if (languages.includes("kotlin")) return "kotlin";
-  return languages[0];
-}
-function scanManifests(projectDir) {
-  const results = [];
-  for (const spec of MANIFEST_FILES) {
-    if (spec.file.includes("*")) {
-      const ext = spec.file.replace("*", "");
-      try {
-        const entries = readdirSync(projectDir);
-        for (const entry of entries) {
-          if (entry.endsWith(ext)) {
-            const content = readFileSync(join(projectDir, entry), "utf-8");
-            try {
-              const parsed = spec.parse(content, projectDir);
-              results.push({ file: entry, language: spec.language, ...parsed });
-            } catch {
-            }
-          }
-        }
-      } catch {
-      }
-      continue;
-    }
-    const filePath = join(projectDir, spec.file);
-    if (!existsSync(filePath)) continue;
-    try {
-      const content = readFileSync(filePath, "utf-8");
-      const parsed = spec.parse(content, projectDir);
-      results.push({ file: spec.file, language: spec.language, ...parsed });
-    } catch {
-      logger.debug(`Failed to parse manifest: ${spec.file}`);
-    }
-  }
-  return results;
-}
-function readJsonSafe(filePath) {
-  try {
-    const raw = readFileSync(filePath, "utf-8");
-    return JSON.parse(raw);
-  } catch {
-    return null;
-  }
-}
-function extractExports(filePath) {
-  try {
-    const content = readFileSync(filePath, "utf-8");
-    const exports = [];
-    for (const m of content.matchAll(/export\s+(?:async\s+)?function\s+(\w+)/g)) {
-      exports.push(m[1]);
-    }
-    for (const m of content.matchAll(/export\s+class\s+(\w+)/g)) {
-      exports.push(m[1]);
-    }
-    for (const m of content.matchAll(/export\s+(?:const|let|var)\s+(\w+)/g)) {
-      exports.push(m[1]);
-    }
-    for (const m of content.matchAll(/export\s+(?:interface|type)\s+(\w+)/g)) {
-      exports.push(m[1]);
-    }
-    for (const m of content.matchAll(/export\s+enum\s+(\w+)/g)) {
-      exports.push(m[1]);
-    }
-    if (/export\s+default\s/.test(content)) {
-      exports.push("default");
-    }
-    return [...new Set(exports)];
-  } catch {
-    return [];
-  }
-}
-function sampleSourceFiles(dir, max) {
-  const results = [];
-  const extensions = /* @__PURE__ */ new Set([".ts", ".js", ".mts", ".mjs", ".cts", ".cjs"]);
-  function walk(currentDir, depth) {
-    if (depth > 2 || results.length >= max) return;
-    let entries;
-    try {
-      entries = readdirSync(currentDir);
-    } catch {
-      return;
-    }
-    for (const entry of entries) {
-      if (results.length >= max) return;
-      if (entry.startsWith(".") || entry === "node_modules" || entry === "dist") continue;
-      const full = join(currentDir, entry);
-      try {
-        const stat = statSync(full);
-        if (stat.isDirectory()) {
-          walk(full, depth + 1);
-        } else if (stat.isFile() && extensions.has(extname(entry))) {
-          results.push(full);
-        }
-      } catch {
-      }
-    }
-  }
-  walk(dir, 0);
-  return results;
-}
-function detectImportStyle(projectDir, packageType) {
-  const sourceDir = existsSync(join(projectDir, "src")) ? join(projectDir, "src") : projectDir;
-  const files = sampleSourceFiles(sourceDir, 10);
-  let esmCount = 0;
-  let cjsCount = 0;
-  for (const file of files) {
-    try {
-      const content = readFileSync(file, "utf-8");
-      if (/\bimport\s+/.test(content) || /\bexport\s+/.test(content)) {
-        esmCount++;
-      }
-      if (/\brequire\s*\(/.test(content) || /\bmodule\.exports\b/.test(content)) {
-        cjsCount++;
-      }
-    } catch {
-    }
-  }
-  if (esmCount === 0 && cjsCount === 0) {
-    return packageType === "module" ? "esm" : "commonjs";
-  }
-  if (esmCount > 0 && cjsCount > 0) return "mixed";
-  if (esmCount > 0) return "esm";
-  return "commonjs";
-}
-function detectTestFramework(deps) {
-  const candidates = [
-    ["vitest", "vitest"],
-    ["jest", "jest"],
-    ["@jest/core", "jest"],
-    ["mocha", "mocha"],
-    ["ava", "ava"],
-    ["tap", "tap"],
-    ["uvu", "uvu"]
-  ];
-  for (const [pkg, name] of candidates) {
-    if (pkg in deps) return name;
-  }
-  return null;
-}
-function detectLinter(deps, configFiles) {
-  if ("biome" in deps || "@biomejs/biome" in deps || configFiles.some((f) => f.startsWith("biome."))) {
-    return "biome";
-  }
-  if ("eslint" in deps || configFiles.some((f) => f.includes("eslint"))) {
-    return "eslint";
-  }
-  return null;
-}
-function detectFormatter(deps, configFiles) {
-  if ("prettier" in deps || configFiles.some((f) => f.includes("prettier"))) {
-    return "prettier";
-  }
-  if ("biome" in deps || "@biomejs/biome" in deps || configFiles.some((f) => f.startsWith("biome."))) {
-    return "biome";
-  }
-  return null;
-}
-function detectBuildTool(deps, scripts) {
-  const candidates = [
-    ["tsup", "tsup"],
-    ["esbuild", "esbuild"],
-    ["vite", "vite"],
-    ["webpack", "webpack"],
-    ["rollup", "rollup"],
-    ["@swc/core", "swc"],
-    ["turbopack", "turbopack"],
-    ["parcel", "parcel"]
-  ];
-  for (const [pkg, name] of candidates) {
-    if (pkg in deps) return name;
-  }
-  const buildScript = scripts["build"] ?? "";
-  for (const [, name] of candidates) {
-    if (buildScript.includes(name)) return name;
-  }
-  if (buildScript.includes("tsc")) return "tsc";
-  return null;
-}
-function detectEntryPoints(projectDir, packageJson) {
-  const entries = [];
-  if (packageJson) {
-    const raw = readJsonSafe(join(projectDir, "package.json"));
-    if (raw) {
-      if (typeof raw["main"] === "string") entries.push(raw["main"]);
-      if (typeof raw["module"] === "string") entries.push(raw["module"]);
-      if (raw["exports"] && typeof raw["exports"] === "object") {
-        const exp = raw["exports"];
-        const dot = exp["."];
-        if (typeof dot === "string") {
-          entries.push(dot);
-        } else if (dot && typeof dot === "object") {
-          const dotObj = dot;
-          if (typeof dotObj["import"] === "string") entries.push(dotObj["import"]);
-          if (typeof dotObj["require"] === "string") entries.push(dotObj["require"]);
-        }
-      }
-    }
-  }
-  const commonEntries = ["src/index.ts", "src/main.ts", "src/index.js", "src/main.js", "index.ts", "index.js"];
-  for (const candidate of commonEntries) {
-    if (existsSync(join(projectDir, candidate)) && !entries.includes(candidate)) {
-      entries.push(candidate);
-    }
-  }
-  return [...new Set(entries)];
-}
-function collectUtilFiles(projectDir) {
-  const results = [];
-  const srcDir = join(projectDir, "src");
-  const extensions = /* @__PURE__ */ new Set([".ts", ".js", ".mts", ".mjs"]);
-  for (const dirName of UTIL_DIR_NAMES) {
-    const utilDir = join(srcDir, dirName);
-    if (!existsSync(utilDir)) continue;
-    let entries;
-    try {
-      entries = readdirSync(utilDir);
-    } catch {
-      continue;
-    }
-    for (const entry of entries) {
-      const ext = extname(entry);
-      if (!extensions.has(ext)) continue;
-      if (basename(entry, ext) === "index") continue;
-      const filePath = join(utilDir, entry);
-      try {
-        if (!statSync(filePath).isFile()) continue;
-      } catch {
-        continue;
-      }
-      const exports = extractExports(filePath);
-      if (exports.length > 0) {
-        const relPath = filePath.slice(projectDir.length + 1);
-        results.push({ file: relPath, exports });
-      }
-    }
-  }
-  return results;
-}
-async function analyzeProject(projectDir) {
-  logger.debug(`Analyzing project: ${projectDir}`);
-  let packageJson = null;
-  const pkgPath = join(projectDir, "package.json");
-  if (existsSync(pkgPath)) {
-    const raw = readJsonSafe(pkgPath);
-    if (raw) {
-      packageJson = {
-        name: raw["name"] ?? "",
-        dependencies: raw["dependencies"] ?? {},
-        devDependencies: raw["devDependencies"] ?? {},
-        scripts: raw["scripts"] ?? {},
-        type: raw["type"]
-      };
-    }
-  }
-  const configFiles = [];
-  for (const pattern of CONFIG_FILE_PATTERNS) {
-    if (existsSync(join(projectDir, pattern))) {
-      configFiles.push(pattern);
-    }
-  }
-  const hasTypescript = existsSync(join(projectDir, "tsconfig.json")) || configFiles.some((f) => f.startsWith("tsconfig"));
-  const hasSrcDir = existsSync(join(projectDir, "src"));
-  const hasTestDir = existsSync(join(projectDir, "test")) || existsSync(join(projectDir, "tests")) || existsSync(join(projectDir, "__tests__"));
-  const entryPoints = detectEntryPoints(projectDir, packageJson);
-  const structure = {
-    hasTypescript,
-    hasSrcDir,
-    hasTestDir,
-    configFiles,
-    entryPoints
-  };
-  const allDeps = {
-    ...packageJson?.dependencies ?? {},
-    ...packageJson?.devDependencies ?? {}
-  };
-  const patterns = {
-    importStyle: detectImportStyle(projectDir, packageJson?.type),
-    testFramework: detectTestFramework(allDeps),
-    linter: detectLinter(allDeps, configFiles),
-    formatter: detectFormatter(allDeps, configFiles),
-    buildTool: detectBuildTool(allDeps, packageJson?.scripts ?? {})
-  };
-  const existingUtils = collectUtilFiles(projectDir);
-  const manifests = scanManifests(projectDir);
-  const language = detectLanguage(projectDir, manifests);
-  logger.debug(`Project analysis complete: ${packageJson?.name ?? "(unnamed)"}, language: ${language}, manifests: ${manifests.length}`, {
-    department: "research"
-  });
-  return {
-    language,
-    manifests,
-    packageJson,
-    structure,
-    patterns,
-    existingUtils
-  };
-}
-function formatProjectContext(analysis) {
-  const sections = [];
-  sections.push("## Project Context");
-  sections.push("");
-  sections.push(`**Primary Language:** ${analysis.language}`);
-  sections.push("");
-  const nonJsManifests = analysis.manifests.filter((m) => m.file !== "package.json");
-  if (nonJsManifests.length > 0) {
-    sections.push("### Dependency Manifests");
-    for (const manifest of nonJsManifests) {
-      sections.push(`#### ${manifest.file} (${manifest.language})`);
-      const depNames = Object.keys(manifest.dependencies);
-      if (depNames.length > 0) {
-        sections.push(depNames.slice(0, 30).map((d) => `- \`${d}\`: ${manifest.dependencies[d]}`).join("\n"));
-        if (depNames.length > 30) sections.push(`- ... and ${depNames.length - 30} more`);
-      }
-      if (Object.keys(manifest.metadata).length > 0) {
-        sections.push(`- Metadata: ${JSON.stringify(manifest.metadata)}`);
-      }
-      sections.push("");
-    }
-  }
-  if (analysis.packageJson) {
-    const pkg = analysis.packageJson;
-    sections.push(`**Project:** ${pkg.name || "(unnamed)"}`);
-    sections.push(`**Module system:** ${pkg.type ?? "commonjs (default)"}`);
-    sections.push("");
-    const depNames = Object.keys(pkg.dependencies);
-    if (depNames.length > 0) {
-      sections.push("### Dependencies");
-      sections.push(depNames.map((d) => `- \`${d}\`: ${pkg.dependencies[d]}`).join("\n"));
-      sections.push("");
-    }
-    const devDepNames = Object.keys(pkg.devDependencies);
-    if (devDepNames.length > 0) {
-      sections.push("### Dev Dependencies");
-      sections.push(devDepNames.map((d) => `- \`${d}\`: ${pkg.devDependencies[d]}`).join("\n"));
-      sections.push("");
-    }
-    const scriptEntries = Object.entries(pkg.scripts);
-    if (scriptEntries.length > 0) {
-      sections.push("### Scripts");
-      sections.push(scriptEntries.map(([k, v]) => `- \`${k}\`: \`${v}\``).join("\n"));
-      sections.push("");
-    }
-  } else {
-    sections.push("*No package.json found.*");
-    sections.push("");
-  }
-  sections.push("### Project Structure");
-  sections.push(`- TypeScript: ${analysis.structure.hasTypescript ? "yes" : "no"}`);
-  sections.push(`- src/ directory: ${analysis.structure.hasSrcDir ? "yes" : "no"}`);
-  sections.push(`- Test directory: ${analysis.structure.hasTestDir ? "yes" : "no"}`);
-  if (analysis.structure.entryPoints.length > 0) {
-    sections.push(`- Entry points: ${analysis.structure.entryPoints.map((e) => `\`${e}\``).join(", ")}`);
-  }
-  if (analysis.structure.configFiles.length > 0) {
-    sections.push(`- Config files: ${analysis.structure.configFiles.map((f) => `\`${f}\``).join(", ")}`);
-  }
-  sections.push("");
-  sections.push("### Detected Patterns");
-  sections.push(`- Import style: **${analysis.patterns.importStyle}**`);
-  sections.push(`- Test framework: ${analysis.patterns.testFramework ?? "none detected"}`);
-  sections.push(`- Linter: ${analysis.patterns.linter ?? "none detected"}`);
-  sections.push(`- Formatter: ${analysis.patterns.formatter ?? "none detected"}`);
-  sections.push(`- Build tool: ${analysis.patterns.buildTool ?? "none detected"}`);
-  sections.push("");
-  if (analysis.existingUtils.length > 0) {
-    sections.push("### Existing Utilities (reuse before creating new ones)");
-    for (const util of analysis.existingUtils) {
-      sections.push(`- **\`${util.file}\`**: ${util.exports.map((e) => `\`${e}\``).join(", ")}`);
-    }
-    sections.push("");
-  }
-  sections.push("### Key Guidance");
-  if (analysis.patterns.importStyle === "esm") {
-    sections.push("- Use ESM imports (`import`/`export`). Use `.js` extensions in relative imports if TypeScript with bundler resolution.");
-  } else if (analysis.patterns.importStyle === "commonjs") {
-    sections.push("- Use CommonJS (`require`/`module.exports`).");
-  } else {
-    sections.push("- Mixed import styles detected. Prefer the dominant style in the module you are editing.");
-  }
-  if (analysis.packageJson) {
-    sections.push("- Do NOT run `npm install` for packages already listed in dependencies or devDependencies.");
-  }
-  if (analysis.patterns.testFramework) {
-    sections.push(`- Write tests using **${analysis.patterns.testFramework}** (already installed).`);
-  }
-  if (analysis.patterns.buildTool) {
-    sections.push(`- Build with **${analysis.patterns.buildTool}** (already configured).`);
-  }
-  return sections.join("\n");
-}
-
 // src/orchestrator/orchestrator.ts
 var DEPARTMENT_KEYWORDS = {
   architecture: [
@@ -2460,69 +915,46 @@ var Orchestrator = class {
   }
   // ---- start meeting ------------------------------------------------------
   /**
-   * Start a new meeting.
+   * Create a new meeting record and return meeting info + recommended leaders.
    *
-   * 1. Selects departments (if not provided).
-   * 2. Creates the meeting record in SQLite.
-   * 3. Spawns leaders via the LeaderPool.
-   * 4. Runs the MeetingRunner lifecycle (opening -> discussion -> synthesis -> minutes).
-   * 5. Deactivates leaders after completion.
-   *
-   * Returns the meeting ID.
+   * Does NOT run the meeting. The calling agent (via skill markdown) is
+   * responsible for orchestrating the meeting phases using add-transcript
+   * and generate-minutes MCP tools.
    */
-  async startMeeting(opts) {
+  startMeeting(opts) {
     const { topic, agenda } = opts;
     const departments = opts.departments ?? this.selectLeaders(topic, agenda);
-    logger.info(`Starting meeting: "${topic}" with departments: [${departments.join(", ")}]`);
-    let projectContext;
-    try {
-      const analysis = await analyzeProject(process.cwd());
-      projectContext = formatProjectContext(analysis);
-      logger.debug("Project analysis complete", { meetingId: topic });
-    } catch (err) {
-      const msg = err instanceof Error ? err.message : String(err);
-      logger.warn(`Project analysis failed (proceeding without context): ${msg}`);
-    }
+    logger.info(`Creating meeting: "${topic}" with departments: [${departments.join(", ")}]`);
     const meetingId = uuidv46();
-    const meeting = createMeeting({
+    createMeeting({
       id: meetingId,
       topic,
       agenda,
-      participantIds: [],
-      // Will be filled in after leader spawning
+      participantIds: departments.map((d) => `${d}-leader`),
       initiatedBy: this.orchestratorId,
-      status: "convening",
-      phase: "convening",
+      status: "pending",
+      phase: "orchestrator-phase",
       startedAt: Date.now(),
       previousMeetingId: opts.previousMeetingId ?? null
     });
-    const leaders = [];
-    for (const dept of departments) {
-      const leader = this.leaderPool.spawnLeader(dept, meetingId);
-      leaders.push(leader);
-    }
-    updateMeeting(meetingId, {
-      participantIds: leaders.map((l) => l.id)
-    });
-    const runner = new MeetingRunner(meetingId, leaders, projectContext);
-    try {
-      await runner.run();
-    } finally {
-      for (const leader of leaders) {
-        this.leaderPool.deactivateLeader(leader.id);
-      }
-    }
-    return meetingId;
+    return {
+      meetingId,
+      departments,
+      agenda,
+      topic
+    };
   }
   // ---- chain meeting -------------------------------------------------------
   /**
-   * Chain a new meeting from the output of a previous meeting.
+   * Create a new meeting chained from a previous meeting.
    *
    * Loads minutes from the previous meeting and includes them as context for
    * the new meeting topic. The new meeting's `previousMeetingId` is set for
    * traceability.
+   *
+   * Does NOT run the meeting (same as startMeeting).
    */
-  async chainMeeting(opts) {
+  chainMeeting(opts) {
     const previousMeeting = getMeeting(opts.previousMeetingId);
     if (!previousMeeting) {
       throw new Error(`Previous meeting not found: ${opts.previousMeetingId}`);
@@ -2592,18 +1024,11 @@ async function startMeetingHandler({
 }) {
   try {
     const orchestrator = new Orchestrator();
-    const meetingId = await orchestrator.startMeeting({
+    const result = orchestrator.startMeeting({
       topic,
       agenda,
       departments
     });
-    const result = {
-      meetingId,
-      status: "started",
-      topic,
-      agenda,
-      departments: departments ?? orchestrator.selectLeaders(topic, agenda)
-    };
     return {
       content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
     };
@@ -3006,219 +1431,6 @@ async function compactMinutesHandler({
 
 // src/tools/execute-tasks.ts
 import { z as z5 } from "zod";
-
-// src/orchestrator/worker-manager.ts
-async function executeWorkerAgent(worker) {
-  const department = inferDepartment(worker);
-  const workerRole = inferWorkerRole(worker);
-  const agentConfig = createAgentConfig({
-    tier: "worker",
-    role: workerRole,
-    department,
-    task: worker.taskDescription,
-    context: worker.inputContext ?? void 0
-  });
-  const systemPrompt = buildWorkerPrompt({
-    workerType: workerRole,
-    department,
-    task: worker.taskDescription,
-    context: worker.inputContext ?? void 0
-  });
-  const prompt = `Execute the following task:
-
-Task: ${worker.taskDescription}
-` + (worker.inputContext ? `
-Context: ${worker.inputContext}
-` : "") + `
-Provide a clear, structured result.`;
-  const invokeOpts = buildInvokeOptions(agentConfig, prompt, systemPrompt);
-  invokeOpts.timeoutMs = 3e5;
-  const result = await invokeClaude(invokeOpts);
-  if (!result.success) {
-    throw new Error(result.error ?? "Worker agent invocation failed");
-  }
-  return result.output;
-}
-function inferDepartment(worker) {
-  switch (worker.taskType) {
-    case "research":
-      return "research";
-    case "testing":
-      return "qa";
-    case "analysis":
-      return "architecture";
-    case "implementation":
-    default:
-      return "engineering";
-  }
-}
-function inferWorkerRole(worker) {
-  const desc = worker.taskDescription.toLowerCase();
-  if (desc.includes("schema") || desc.includes("data model")) return "schema-designer";
-  if (desc.includes("api") || desc.includes("endpoint")) return "api-designer";
-  if (desc.includes("dependency") || desc.includes("coupling")) return "dependency-analyzer";
-  if (desc.includes("test")) return "test-writer";
-  if (desc.includes("security") || desc.includes("audit")) return "security-auditor";
-  if (desc.includes("performance") || desc.includes("benchmark")) return "perf-tester";
-  if (desc.includes("research") || desc.includes("explore") || desc.includes("investigate")) return "code-explorer";
-  if (desc.includes("document") || desc.includes("search")) return "doc-searcher";
-  if (desc.includes("fix") || desc.includes("bug")) return "bug-fixer";
-  if (desc.includes("refactor")) return "refactorer";
-  return "feature-dev";
-}
-function inferTaskType(description) {
-  const lower = description.toLowerCase();
-  if (lower.includes("research") || lower.includes("explore") || lower.includes("search")) {
-    return "research";
-  }
-  if (lower.includes("test") || lower.includes("audit") || lower.includes("benchmark")) {
-    return "testing";
-  }
-  if (lower.includes("analys") || lower.includes("design") || lower.includes("schema")) {
-    return "analysis";
-  }
-  return "implementation";
-}
-var WorkerManager = class {
-  // ---- spawn workers ------------------------------------------------------
-  /**
-   * Spawn a batch of workers on behalf of a leader.
-   *
-   * Each task assignment is persisted to SQLite and an `agent_spawned` event is
-   * emitted.  The returned records are in `pending` status.
-   */
-  async spawnWorkers(leaderId, meetingId, tasks) {
-    const workers = [];
-    for (const task of tasks) {
-      const worker = createWorker({
-        leaderId,
-        meetingId,
-        taskDescription: task.description,
-        taskType: inferTaskType(task.description),
-        inputContext: task.inputPaths.length > 0 ? task.inputPaths.join(", ") : null,
-        outputResult: null,
-        errorMessage: null,
-        dependencies: task.dependencies
-      });
-      workers.push(worker);
-      logger.info(`Spawned worker for leader ${leaderId}`, {
-        agentId: worker.id,
-        meetingId,
-        department: "worker"
-      });
-      eventBus.emitAgentEvent({
-        kind: "agent_spawned",
-        agentId: worker.id,
-        agentType: "worker",
-        parentId: leaderId,
-        label: task.description.slice(0, 60),
-        department: "engineering"
-        // Workers inherit; refined later if needed
-      });
-    }
-    return workers;
-  }
-  // ---- execute workers ----------------------------------------------------
-  /**
-   * Execute a list of workers, respecting dependency ordering.
-   *
-   * - Workers with no unresolved dependencies run in parallel.
-   * - Workers whose dependencies are all completed run next.
-   * - Continues until all workers are done or a dependency cycle is detected.
-   */
-  async executeWorkers(workers) {
-    const completed = /* @__PURE__ */ new Set();
-    const results = [];
-    const pending = new Map(workers.map((w) => [w.id, w]));
-    while (pending.size > 0) {
-      const ready = [];
-      for (const worker of pending.values()) {
-        const depsReady = worker.dependencies.every((dep) => completed.has(dep));
-        if (depsReady) {
-          ready.push(worker);
-        }
-      }
-      if (ready.length === 0) {
-        logger.warn("Dependency cycle or unsatisfiable deps detected; failing remaining workers");
-        for (const worker of pending.values()) {
-          const failed = updateWorker(worker.id, {
-            status: "failed",
-            errorMessage: "Unresolvable dependency",
-            completedAt: Date.now()
-          });
-          results.push(failed ?? worker);
-          eventBus.emitAgentEvent({
-            kind: "task_completed",
-            agentId: worker.id,
-            result: "failure"
-          });
-        }
-        break;
-      }
-      const batchResults = await Promise.allSettled(
-        ready.map(async (worker) => {
-          updateWorker(worker.id, { status: "running" });
-          eventBus.emitAgentEvent({
-            kind: "state_changed",
-            agentId: worker.id,
-            from: "idle",
-            to: "working"
-          });
-          try {
-            const output = await executeWorkerAgent(worker);
-            const updated = updateWorker(worker.id, {
-              status: "completed",
-              outputResult: output,
-              completedAt: Date.now(),
-              costUsd: 0.01
-              // Approximate cost; real cost tracked by CLI
-            });
-            eventBus.emitAgentEvent({
-              kind: "task_completed",
-              agentId: worker.id,
-              result: "success"
-            });
-            return updated ?? worker;
-          } catch (err) {
-            const errorMsg = err instanceof Error ? err.message : String(err);
-            const updated = updateWorker(worker.id, {
-              status: "failed",
-              errorMessage: errorMsg,
-              completedAt: Date.now()
-            });
-            eventBus.emitAgentEvent({
-              kind: "task_completed",
-              agentId: worker.id,
-              result: "failure"
-            });
-            return updated ?? worker;
-          }
-        })
-      );
-      for (let i = 0; i < ready.length; i++) {
-        const worker = ready[i];
-        pending.delete(worker.id);
-        completed.add(worker.id);
-        const settlement = batchResults[i];
-        if (settlement.status === "fulfilled") {
-          results.push(settlement.value);
-        } else {
-          results.push(worker);
-        }
-      }
-    }
-    return results;
-  }
-  // ---- status query -------------------------------------------------------
-  /**
-   * Get the current status of all workers under a given leader.
-   */
-  getWorkerStatus(leaderId) {
-    return listWorkersByLeader(leaderId);
-  }
-};
-
-// src/tools/execute-tasks.ts
 var executeTasksSchema = {
   meetingId: z5.string().describe("Meeting ID"),
   taskIds: z5.array(z5.string()).optional().describe("Specific tasks to execute, or all")
@@ -3270,58 +1482,15 @@ async function executeTasksHandler({
       }
       tasksByDepartment.get(dept).push(task);
     }
-    const workerManager = new WorkerManager();
-    const executionResults = [];
+    const departments = [];
     for (const [department, tasks] of tasksByDepartment) {
-      const assignments = tasks.map((task) => ({
-        workerId: task.id,
-        description: `${task.title}: ${task.description}`,
-        inputPaths: [],
-        outputPath: "",
-        dependencies: task.dependencies,
-        status: "pending",
-        result: null
-      }));
-      const leaderId = `${department}-leader-${meetingId}`;
-      const workers = await workerManager.spawnWorkers(
-        leaderId,
-        meetingId,
-        assignments
-      );
-      const completedWorkers = await workerManager.executeWorkers(workers);
-      executionResults.push({
-        department,
-        taskCount: tasks.length,
-        workers: completedWorkers.map((w) => ({
-          id: w.id,
-          status: w.status,
-          taskDescription: w.taskDescription,
-          outputResult: w.outputResult,
-          errorMessage: w.errorMessage
-        }))
-      });
+      departments.push({ department, tasks });
     }
-    const totalWorkers = executionResults.reduce(
-      (acc, r) => acc + r.workers.length,
-      0
-    );
-    const completedCount = executionResults.reduce(
-      (acc, r) => acc + r.workers.filter((w) => w.status === "completed").length,
-      0
-    );
-    const failedCount = executionResults.reduce(
-      (acc, r) => acc + r.workers.filter((w) => w.status === "failed").length,
-      0
-    );
     const result = {
       meetingId,
-      summary: {
-        totalTasks: tasksToExecute.length,
-        totalWorkers,
-        completed: completedCount,
-        failed: failedCount
-      },
-      departments: executionResults
+      totalTasks: tasksToExecute.length,
+      departments,
+      instructions: "These tasks should be dispatched to implementer agents. The orchestrator agent will use Claude Code Agent tool to run each task."
     };
     return {
       content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
@@ -3767,19 +1936,19 @@ async function getTaskReportHandler({
 import { z as z11 } from "zod";
 
 // src/extension/capability-registry.ts
-import { readFileSync as readFileSync2, writeFileSync, existsSync as existsSync2 } from "fs";
-import { join as join3 } from "path";
+import { readFileSync, writeFileSync, existsSync } from "fs";
+import { join as join2 } from "path";
 
 // src/utils/config.ts
 import { mkdirSync } from "fs";
 import { homedir } from "os";
-import { join as join2 } from "path";
+import { join } from "path";
 function buildConfig() {
-  const DATA_DIR = join2(homedir(), ".open-coleslaw");
+  const DATA_DIR = join(homedir(), ".open-coleslaw");
   return {
     DATA_DIR,
-    DB_PATH: join2(DATA_DIR, "data.db"),
-    MINUTES_DIR: join2(DATA_DIR, "minutes"),
+    DB_PATH: join(DATA_DIR, "data.db"),
+    MINUTES_DIR: join(DATA_DIR, "minutes"),
     DASHBOARD_PORT: 35143
   };
 }
@@ -3902,7 +2071,7 @@ var CapabilityRegistry = class {
   registryPath;
   constructor() {
     const { DATA_DIR } = getConfig();
-    this.registryPath = join3(DATA_DIR, "registry.json");
+    this.registryPath = join2(DATA_DIR, "registry.json");
   }
   /**
    * Load all capabilities: built-in (hardcoded) + custom (from registry.json).
@@ -3977,11 +2146,11 @@ ${lines.join("\n")}`);
   // Private helpers
   // -------------------------------------------------------------------------
   readCustomEntries() {
-    if (!existsSync2(this.registryPath)) {
+    if (!existsSync(this.registryPath)) {
       return [];
     }
     try {
-      const raw = readFileSync2(this.registryPath, "utf-8");
+      const raw = readFileSync(this.registryPath, "utf-8");
       const parsed = JSON.parse(raw);
       if (!Array.isArray(parsed)) return [];
       return parsed;
@@ -3996,7 +2165,7 @@ ${lines.join("\n")}`);
 
 // src/extension/generator.ts
 import { mkdirSync as mkdirSync2, writeFileSync as writeFileSync2 } from "fs";
-import { join as join4 } from "path";
+import { join as join3 } from "path";
 function sanitizeName(name) {
   return name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
 }
@@ -4013,7 +2182,7 @@ function header(request) {
 }
 function customDir(type) {
   const { DATA_DIR } = getConfig();
-  const dir = join4(DATA_DIR, `custom-${type}s`);
+  const dir = join3(DATA_DIR, `custom-${type}s`);
   mkdirSync2(dir, { recursive: true });
   return dir;
 }
@@ -4234,7 +2403,7 @@ function generateCapability(request) {
     ext = ".js";
   }
   const dir = customDir(request.type);
-  const filePath = join4(dir, `${safeName}${ext}`);
+  const filePath = join3(dir, `${safeName}${ext}`);
   let code;
   switch (request.type) {
     case "hook":
@@ -4269,11 +2438,11 @@ function generateCapability(request) {
 }
 
 // src/extension/guide-updater.ts
-import { readFileSync as readFileSync3, writeFileSync as writeFileSync3 } from "fs";
-import { join as join5 } from "path";
+import { readFileSync as readFileSync2, writeFileSync as writeFileSync3 } from "fs";
+import { join as join4 } from "path";
 async function updatePluginGuide(registry) {
   const { DATA_DIR } = getConfig();
-  const guidePath = join5(DATA_DIR, "plugin-guide.md");
+  const guidePath = join4(DATA_DIR, "plugin-guide.md");
   const capSection = registry.formatForGuide();
   const guide = [
     "# Open-Coleslaw Plugin Guide",
@@ -4666,19 +2835,249 @@ async function chainMeetingHandler({
 }) {
   try {
     const orchestrator = new Orchestrator();
-    const meetingId = await orchestrator.chainMeeting({
+    const result = orchestrator.chainMeeting({
       previousMeetingId,
       topic,
       agenda,
       departments
     });
+    return {
+      content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+    };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return {
+      content: [
+        { type: "text", text: JSON.stringify({ error: message }, null, 2) }
+      ],
+      isError: true
+    };
+  }
+}
+
+// src/tools/add-transcript.ts
+import { z as z14 } from "zod";
+
+// src/orchestrator/meeting-runner.ts
+function insertTranscriptEntry(meetingId, speakerId, speakerRole, agendaItemIndex, roundNumber, content) {
+  const db = getDb();
+  const now = Date.now();
+  const tokenCount = Math.ceil(content.length / 4);
+  const result = db.prepare(
+    `INSERT INTO transcript_entries
+         (meeting_id, speaker_id, speaker_role, agenda_item_index, round_number, content, token_count, created_at)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?)`
+  ).run(meetingId, speakerId, speakerRole, agendaItemIndex, roundNumber, content, tokenCount, now);
+  return {
+    id: Number(result.lastInsertRowid),
+    meetingId,
+    speakerId,
+    speakerRole,
+    agendaItemIndex,
+    roundNumber,
+    content,
+    tokenCount,
+    createdAt: now
+  };
+}
+function getTranscript(meetingId) {
+  const db = getDb();
+  const rows = db.prepare("SELECT * FROM transcript_entries WHERE meeting_id = ? ORDER BY created_at ASC").all(meetingId);
+  return rows.map((r) => ({
+    id: r.id,
+    meetingId: r.meeting_id,
+    speakerId: r.speaker_id,
+    speakerRole: r.speaker_role,
+    agendaItemIndex: r.agenda_item_index,
+    roundNumber: r.round_number,
+    content: r.content,
+    tokenCount: r.token_count,
+    createdAt: r.created_at
+  }));
+}
+var MeetingRunner = class {
+  meetingId;
+  constructor(meetingId) {
+    this.meetingId = meetingId;
+  }
+  // ---- Add transcript entry (called by MCP tool add-transcript) -----------
+  /**
+   * Add a transcript entry for this meeting.
+   * Returns the created TranscriptEntry.
+   */
+  addTranscript(speakerRole, agendaItemIndex, roundNumber, content) {
+    const meeting = getMeeting(this.meetingId);
+    if (!meeting) {
+      throw new Error(`Meeting not found: ${this.meetingId}`);
+    }
+    const entry = insertTranscriptEntry(
+      this.meetingId,
+      speakerRole,
+      speakerRole,
+      agendaItemIndex,
+      roundNumber,
+      content
+    );
+    logger.debug(`Transcript added: ${speakerRole} (item ${agendaItemIndex}, round ${roundNumber})`, {
+      meetingId: this.meetingId
+    });
+    return entry;
+  }
+  // ---- Generate minutes from all transcripts ------------------------------
+  /**
+   * Generate meeting minutes by formatting all stored transcript entries.
+   * Returns the minutesId of the created minutes record.
+   */
+  async generateMinutes() {
+    const meeting = getMeeting(this.meetingId);
+    if (!meeting) {
+      throw new Error(`Meeting not found: ${this.meetingId}`);
+    }
+    updateMeeting(this.meetingId, {
+      phase: "minutes-generation",
+      status: "minutes-generation"
+    });
+    const transcript = getTranscript(this.meetingId);
+    const sections = [];
+    const speakerRoles = [...new Set(transcript.map((e) => e.speakerRole))];
+    sections.push(`# Meeting Minutes`);
+    sections.push(`## Topic: ${meeting.topic}`);
+    sections.push(`## Date: ${(/* @__PURE__ */ new Date()).toISOString()}`);
+    sections.push(`## Participants: ${speakerRoles.join(", ")}`);
+    sections.push("");
+    sections.push(`## Agenda`);
+    meeting.agenda.forEach((item, i) => {
+      sections.push(`${i + 1}. ${item}`);
+    });
+    sections.push("");
+    const openingEntries = transcript.filter((e) => e.agendaItemIndex === -1);
+    if (openingEntries.length > 0) {
+      sections.push(`## Opening Statements`);
+      for (const entry of openingEntries) {
+        sections.push(`### ${entry.speakerRole}`);
+        sections.push(entry.content);
+        sections.push("");
+      }
+    }
+    for (let i = 0; i < meeting.agenda.length; i++) {
+      const itemEntries = transcript.filter((e) => e.agendaItemIndex === i);
+      if (itemEntries.length > 0) {
+        sections.push(`## Discussion: ${meeting.agenda[i]}`);
+        for (const entry of itemEntries) {
+          sections.push(`**${entry.speakerRole}** (round ${entry.roundNumber}):`);
+          sections.push(entry.content);
+          sections.push("");
+        }
+      }
+    }
+    const synthesisEntries = transcript.filter((e) => e.agendaItemIndex === -2);
+    if (synthesisEntries.length > 0) {
+      sections.push(`## Final Positions`);
+      for (const entry of synthesisEntries) {
+        sections.push(`### ${entry.speakerRole}`);
+        sections.push(entry.content);
+        sections.push("");
+      }
+    }
+    const content = sections.join("\n");
+    const actionItems = speakerRoles.map((role, idx) => ({
+      id: `action-${this.meetingId}-${idx}`,
+      title: `${role} deliverables`,
+      description: `Action items committed by ${role} during synthesis phase`,
+      assignedDepartment: "engineering",
+      // default; will be refined by compactor
+      assignedRole: role,
+      priority: "medium",
+      dependencies: [],
+      acceptanceCriteria: ["Deliverables completed as stated in final position"]
+    }));
+    const minutesRecord = createMinutes({
+      meetingId: this.meetingId,
+      format: "summary",
+      content,
+      actionItems
+    });
+    updateMeeting(this.meetingId, {
+      status: "completed",
+      completedAt: Date.now()
+    });
+    logger.info("Minutes generated", { meetingId: this.meetingId });
+    return minutesRecord.id;
+  }
+  // ---- Completion status --------------------------------------------------
+  /**
+   * Check whether the meeting has been completed (minutes generated).
+   */
+  isComplete() {
+    const meeting = getMeeting(this.meetingId);
+    if (!meeting) return false;
+    return ["completed", "compacted", "reported"].includes(meeting.status);
+  }
+  // ---- Transcript access --------------------------------------------------
+  /**
+   * Get all transcript entries for this meeting.
+   */
+  getTranscript() {
+    return getTranscript(this.meetingId);
+  }
+};
+
+// src/tools/add-transcript.ts
+var addTranscriptSchema = {
+  meetingId: z14.string().describe("Meeting ID"),
+  speakerRole: z14.string().describe('Role of the speaker (e.g. "Architecture Lead", "Engineering Lead")'),
+  agendaItemIndex: z14.number().describe("Agenda item index (0-based). Use -1 for opening statements, -2 for synthesis"),
+  roundNumber: z14.number().describe("Discussion round number (0 for opening/synthesis)"),
+  content: z14.string().describe("The transcript content from the speaker")
+};
+async function addTranscriptHandler({
+  meetingId,
+  speakerRole,
+  agendaItemIndex,
+  roundNumber,
+  content
+}) {
+  try {
+    const runner = new MeetingRunner(meetingId);
+    const entry = runner.addTranscript(speakerRole, agendaItemIndex, roundNumber, content);
     const result = {
+      success: true,
+      entryId: entry.id,
       meetingId,
-      status: "started",
-      chainedFrom: previousMeetingId,
-      topic,
-      agenda,
-      departments: departments ?? orchestrator.selectLeaders(topic, agenda)
+      speakerRole,
+      agendaItemIndex,
+      roundNumber
+    };
+    return {
+      content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+    };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return {
+      content: [
+        { type: "text", text: JSON.stringify({ error: message }, null, 2) }
+      ],
+      isError: true
+    };
+  }
+}
+
+// src/tools/generate-minutes.ts
+import { z as z15 } from "zod";
+var generateMinutesSchema = {
+  meetingId: z15.string().describe("Meeting ID to generate minutes for")
+};
+async function generateMinutesHandler({
+  meetingId
+}) {
+  try {
+    const runner = new MeetingRunner(meetingId);
+    const minutesId = await runner.generateMinutes();
+    const minutes = getMinutesByMeeting(meetingId);
+    const result = {
+      minutesId,
+      meetingId,
+      content: minutes?.content ?? ""
     };
     return {
       content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
@@ -4702,7 +3101,7 @@ function createServer() {
   });
   server.tool(
     "start-meeting",
-    "Start a new multi-agent meeting on a topic with agenda items",
+    "Create a new meeting record with topic and agenda. Returns meetingId and recommended departments. Does NOT run the meeting.",
     startMeetingSchema,
     startMeetingHandler
   );
@@ -4726,7 +3125,7 @@ function createServer() {
   );
   server.tool(
     "execute-tasks",
-    "Execute tasks from compacted minutes by spawning workers per department",
+    "Get the task list from compacted minutes for agent dispatch. Does NOT spawn workers.",
     executeTasksSchema,
     executeTasksHandler
   );
@@ -4779,10 +3178,22 @@ function createServer() {
   );
   server.tool(
     "chain-meeting",
-    "Start a new meeting chained from a previous meeting, using its minutes as context",
+    "Create a new meeting chained from a previous meeting, using its minutes as context. Does NOT run the meeting.",
     chainMeetingSchema,
     chainMeetingHandler
   );
+  server.tool(
+    "add-transcript",
+    "Add a transcript entry to a meeting. Used to record speaker contributions during meeting phases.",
+    addTranscriptSchema,
+    addTranscriptHandler
+  );
+  server.tool(
+    "generate-minutes",
+    "Generate PRD minutes from all stored transcripts for a meeting. Marks the meeting as completed.",
+    generateMinutesSchema,
+    generateMinutesHandler
+  );
   return server;
 }