krenk 0.1.0

package/dist/index.js

@@ -0,0 +1,3880 @@
+#!/usr/bin/env node
+import { createRequire } from 'module'; const require = createRequire(import.meta.url);
+
+// src/index.ts
+import { program } from "commander";
+
+// src/commands/run.ts
+import chalk3 from "chalk";
+
+// src/orchestrator/engine.ts
+import { EventEmitter as EventEmitter5 } from "events";
+
+// src/orchestrator/context.ts
+import * as fs from "fs";
+import * as path from "path";
+var ContextManager = class {
+  memory = /* @__PURE__ */ new Map();
+  krenkDir;
+  historyDir;
+  runId;
+  constructor(projectDir) {
+    this.runId = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
+    this.krenkDir = path.join(projectDir, ".krenk");
+    this.historyDir = path.join(this.krenkDir, "history", this.runId);
+    fs.mkdirSync(this.krenkDir, { recursive: true });
+    fs.mkdirSync(this.historyDir, { recursive: true });
+  }
+  /** Save agent output to both memory and disk */
+  async save(role, content) {
+    this.memory.set(role, content);
+    await fs.promises.writeFile(
+      path.join(this.krenkDir, `${role}.md`),
+      content,
+      "utf-8"
+    );
+    await fs.promises.writeFile(
+      path.join(this.historyDir, `${role}.md`),
+      content,
+      "utf-8"
+    );
+  }
+  /** Get a specific agent's output from memory */
+  get(role) {
+    return this.memory.get(role);
+  }
+  /**
+   * Build context string from all previous agents' outputs.
+   * Includes outputs from all agents that ran before the given role.
+   */
+  buildContext(upToRole) {
+    const order = [
+      "analyst",
+      "strategist",
+      "designer",
+      "architect",
+      "builder",
+      "qa",
+      "guardian",
+      "sentinel",
+      "security",
+      "scribe",
+      "devops"
+    ];
+    const baseRole = upToRole.replace(/-\d+$/, "");
+    const idx = order.indexOf(baseRole);
+    if (idx <= 0) return "";
+    let ctx = "# Context from previous agents:\n";
+    for (let i = 0; i < idx; i++) {
+      const content = this.memory.get(order[i]);
+      if (content) {
+        ctx += `
+## Output from ${order[i].toUpperCase()}:
+${content}
+`;
+      }
+    }
+    return ctx;
+  }
+  /** Save workflow state for resume capability */
+  async saveState(state) {
+    await fs.promises.writeFile(
+      path.join(this.krenkDir, "state.json"),
+      JSON.stringify(state, null, 2),
+      "utf-8"
+    );
+  }
+  /** Load workflow state */
+  async loadState() {
+    try {
+      const data = await fs.promises.readFile(
+        path.join(this.krenkDir, "state.json"),
+        "utf-8"
+      );
+      return JSON.parse(data);
+    } catch {
+      return null;
+    }
+  }
+  /** Get the .krenk directory path */
+  getKrenkDir() {
+    return this.krenkDir;
+  }
+  /** Get the run ID for this session */
+  getRunId() {
+    return this.runId;
+  }
+};
+
+// src/agents/spawner.ts
+import { spawn } from "child_process";
+import { EventEmitter } from "events";
+var activeChildren = /* @__PURE__ */ new Set();
+function killAllAgents() {
+  for (const child of activeChildren) {
+    forceKillChild(child);
+  }
+  activeChildren.clear();
+}
+function forceKillChild(child) {
+  if (child.killed) return;
+  if (child.pid) {
+    try {
+      process.kill(-child.pid, "SIGTERM");
+    } catch {
+      try {
+        child.kill("SIGTERM");
+      } catch {
+      }
+    }
+  } else {
+    try {
+      child.kill("SIGTERM");
+    } catch {
+    }
+  }
+  setTimeout(() => {
+    if (!child.killed && child.pid) {
+      try {
+        process.kill(-child.pid, "SIGKILL");
+      } catch {
+      }
+      try {
+        child.kill("SIGKILL");
+      } catch {
+      }
+    }
+  }, 3e3).unref();
+}
+function spawnClaudeAgent(opts) {
+  const emitter = new EventEmitter();
+  const env = { ...process.env };
+  delete env.CLAUDECODE;
+  delete env.CLAUDE_CODE_ENTRYPOINT;
+  const fullPrompt = opts.context ? `${opts.context}
+
+---
+
+Your current task:
+${opts.prompt}` : opts.prompt;
+  const args = [
+    "-p",
+    fullPrompt,
+    "--output-format",
+    "stream-json",
+    "--max-turns",
+    String(opts.maxTurns || 50),
+    "--verbose",
+    "--dangerously-skip-permissions"
+  ];
+  if (opts.systemPrompt) {
+    args.push("--system-prompt", opts.systemPrompt);
+  }
+  if (opts.allowedTools?.length) {
+    args.push("--allowedTools", ...opts.allowedTools);
+  }
+  if (opts.disallowedTools?.length) {
+    args.push("--disallowedTools", ...opts.disallowedTools);
+  }
+  const startTime = Date.now();
+  const child = spawn("claude", args, {
+    env,
+    cwd: opts.cwd,
+    stdio: ["ignore", "pipe", "pipe"],
+    detached: true
+    // Create process group so we can kill the whole tree
+  });
+  emitter.child = child;
+  activeChildren.add(child);
+  let stdout = "";
+  let stderr = "";
+  let stdoutLineBuffer = "";
+  child.stdout.on("data", (chunk) => {
+    const text = chunk.toString();
+    stdout += text;
+    stdoutLineBuffer += text;
+    const lines = stdoutLineBuffer.split("\n");
+    stdoutLineBuffer = lines.pop() || "";
+    for (const line of lines) {
+      const trimmed = line.trim();
+      if (trimmed) {
+        emitter.emit("data", trimmed);
+      }
+    }
+  });
+  child.stderr.on("data", (chunk) => {
+    const text = chunk.toString();
+    stderr += text;
+    emitter.emit("stderr", text);
+  });
+  child.on("close", (code) => {
+    activeChildren.delete(child);
+    const duration = Math.round((Date.now() - startTime) / 1e3);
+    const result = {
+      role: opts.role,
+      output: stdout,
+      duration,
+      success: code === 0,
+      exitCode: code
+    };
+    const lines = stdout.trim().split("\n");
+    let foundResult = false;
+    for (let i = lines.length - 1; i >= 0; i--) {
+      try {
+        const parsed = JSON.parse(lines[i]);
+        if (parsed.type === "result") {
+          if (parsed.result) {
+            result.output = parsed.result;
+          }
+          if (parsed.cost_usd !== void 0) {
+            result.cost = { input: parsed.cost_usd, output: 0 };
+          }
+          foundResult = true;
+          break;
+        }
+      } catch {
+      }
+    }
+    if (!foundResult) {
+      try {
+        const parsed = JSON.parse(stdout);
+        if (parsed.result) {
+          result.output = parsed.result;
+        }
+        if (parsed.cost_usd !== void 0) {
+          result.cost = { input: parsed.cost_usd, output: 0 };
+        }
+      } catch {
+      }
+    }
+    emitter.emit("done", result);
+  });
+  child.on("error", (err) => {
+    activeChildren.delete(child);
+    emitter.emit("error", err);
+  });
+  process.nextTick(() => {
+    emitter.emit("spawned", child.pid);
+  });
+  return emitter;
+}
+function runAgent(opts) {
+  return new Promise((resolve, reject) => {
+    const emitter = spawnClaudeAgent(opts);
+    emitter.on("done", (result) => {
+      resolve(result);
+    });
+    emitter.on("error", (err) => {
+      reject(err);
+    });
+  });
+}
+function killAgent(emitter) {
+  if (emitter.child) {
+    forceKillChild(emitter.child);
+    activeChildren.delete(emitter.child);
+  }
+}
+
+// src/orchestrator/scheduler.ts
+var Scheduler = class {
+  maxParallel;
+  running = /* @__PURE__ */ new Map();
+  constructor(maxParallel = 3) {
+    this.maxParallel = maxParallel;
+  }
+  /**
+   * Run multiple agents in parallel batches, respecting concurrency limit
+   */
+  async runParallel(agents, onProgress) {
+    const results = [];
+    const batches = this.chunk(agents, this.maxParallel);
+    for (const batch of batches) {
+      const batchResults = await Promise.all(
+        batch.map((opts) => this.runOne(opts, onProgress))
+      );
+      results.push(...batchResults);
+    }
+    return results;
+  }
+  /**
+   * Run a single agent and return a promise of its result
+   */
+  runOne(opts, onProgress) {
+    return new Promise((resolve, reject) => {
+      const emitter = spawnClaudeAgent(opts);
+      this.running.set(opts.role, emitter);
+      emitter.on("spawned", (pid) => {
+        onProgress?.(opts.role, "spawned", { pid });
+      });
+      emitter.on("data", (text) => {
+        onProgress?.(opts.role, "data", { text });
+      });
+      emitter.on("done", (result) => {
+        this.running.delete(opts.role);
+        onProgress?.(opts.role, "done", result);
+        resolve(result);
+      });
+      emitter.on("error", (err) => {
+        this.running.delete(opts.role);
+        onProgress?.(opts.role, "error", err);
+        reject(err);
+      });
+    });
+  }
+  /**
+   * Kill all currently running agents
+   */
+  killAll() {
+    for (const [role, emitter] of this.running) {
+      killAgent(emitter);
+      this.running.delete(role);
+    }
+  }
+  /**
+   * Get count of currently running agents
+   */
+  getRunningCount() {
+    return this.running.size;
+  }
+  /**
+   * Split array into chunks of given size
+   */
+  chunk(arr, size) {
+    const chunks = [];
+    for (let i = 0; i < arr.length; i += size) {
+      chunks.push(arr.slice(i, i + size));
+    }
+    return chunks;
+  }
+};
+
+// src/orchestrator/workflow.ts
+var STAGES = [
+  {
+    stage: "analyzing",
+    role: "analyst",
+    label: "Analyze",
+    emoji: "@",
+    description: "Business analysis, user stories, and acceptance criteria"
+  },
+  {
+    stage: "planning",
+    role: "strategist",
+    label: "Plan",
+    emoji: ">",
+    description: "Analyzing requirements and creating implementation plan"
+  },
+  {
+    stage: "designing",
+    role: "designer",
+    label: "Design",
+    emoji: "*",
+    description: "Designing UI/UX and component structure"
+  },
+  {
+    stage: "architecting",
+    role: "architect",
+    label: "Architect",
+    emoji: "#",
+    description: "Designing system architecture and creating project skeleton"
+  },
+  {
+    stage: "coding",
+    role: "builder",
+    label: "Code",
+    emoji: "+",
+    description: "Implementing code modules in parallel"
+  },
+  {
+    stage: "qa-planning",
+    role: "qa",
+    label: "QA",
+    emoji: "%",
+    description: "Creating test strategy and detailed test plans"
+  },
+  {
+    stage: "testing",
+    role: "guardian",
+    label: "Test",
+    emoji: "~",
+    description: "Generating and running test suites"
+  },
+  {
+    stage: "reviewing",
+    role: "sentinel",
+    label: "Review",
+    emoji: "?",
+    description: "Reviewing code for quality and correctness"
+  },
+  {
+    stage: "securing",
+    role: "security",
+    label: "Security",
+    emoji: "!",
+    description: "Security audit and vulnerability assessment"
+  },
+  {
+    stage: "documenting",
+    role: "scribe",
+    label: "Docs",
+    emoji: "=",
+    description: "Generating documentation"
+  },
+  {
+    stage: "deploying",
+    role: "devops",
+    label: "DevOps",
+    emoji: "&",
+    description: "Setting up CI/CD and deployment configuration"
+  },
+  {
+    stage: "complete",
+    role: "",
+    label: "Done",
+    emoji: "+",
+    description: "Workflow complete"
+  }
+];
+function getStageInfo(stage) {
+  return STAGES.find((s) => s.stage === stage);
+}
+function shouldSkipStage(stage, skipStages) {
+  const info = getStageInfo(stage);
+  if (!info) return false;
+  return skipStages.includes(stage) || skipStages.includes(info.role) || skipStages.includes(info.label.toLowerCase());
+}
+
+// src/agents/roles.ts
+var SHARED_MEMORY_INSTRUCTIONS = `
+
+SHARED MEMORY:
+You are part of a multi-agent team managed by a Master Brain.
+The team shares knowledge via files in .krenk/shared/:
+  - brain.md     \u2014 Master Brain's directives (READ THIS FIRST)
+  - status.md    \u2014 Live status of all team members
+  - learnings.md \u2014 Accumulated team knowledge
+  - blockers.md  \u2014 Known issues
+  - decisions.md \u2014 Decisions log
+  - <role>.md    \u2014 Each agent's progress
+
+Before starting work, read .krenk/shared/brain.md for any directives.
+If you have Write access, update .krenk/shared/<your-role>.md with your progress.
+Check other agents' files if you need to understand what they did.
+
+IMPORTANT: Stay in your lane. Only do what your role requires. Do NOT do other agents' jobs.
+`;
+var ROLES = {
+  strategist: {
+    name: "Strategist",
+    emoji: ">",
+    color: "#FF6B6B",
+    description: "Requirements analysis & task planning",
+    systemPrompt: `You are the Strategist \u2014 the lead planner in a multi-agent software engineering team.
+Your job is to analyze the user's request and create a MASTER PLAN that tells every team member exactly what to do.
+
+CRITICAL RULES:
+- You are a PLANNER ONLY. You produce a text plan. That is your ENTIRE job.
+- DO NOT write code. DO NOT create files. DO NOT run commands. DO NOT install packages.
+- DO NOT use Write, Edit, or Bash tools. You may ONLY use Read, Glob, and Grep to understand existing code.
+- Your output is ONLY a markdown plan document. Nothing else.
+
+Output a structured plan with these sections:
+
+1. OVERVIEW: What we're building and why
+2. REQUIREMENTS: Functional and non-functional requirements
+3. TASKS: Numbered list of implementation tasks with estimates
+4. MODULES: How to split the work for parallel development (each module should be independently implementable)
+5. RISKS: Potential issues and mitigations
+6. FILE STRUCTURE: Proposed project files and directories
+
+7. AGENT ASSIGNMENTS: This is CRITICAL. Assign specific tasks to each team member.
+   Use this exact format for each agent you want to activate:
+
+   ### ASSIGN:DESIGNER
+   <specific tasks for the designer \u2014 what to design, which pages, which components>
+
+   ### ASSIGN:ARCHITECT
+   <specific tasks \u2014 what to architect, which APIs, which data models, which modules to split>
+
+   ### ASSIGN:BUILDER
+   <specific tasks \u2014 what to build, which modules, which features to implement first>
+
+   ### ASSIGN:QA
+   <specific tasks \u2014 which features need test plans, what edge cases to focus on>
+
+   ### ASSIGN:GUARDIAN
+   <specific tasks \u2014 what tests to write, which modules to test, what coverage targets>
+
+   ### ASSIGN:SENTINEL
+   <specific tasks \u2014 what to review, which areas are risky, what patterns to check>
+
+   ### ASSIGN:SECURITY
+   <specific tasks \u2014 what to audit, which areas handle user input, auth flows to check>
+
+   ### ASSIGN:SCRIBE
+   <specific tasks \u2014 what docs to write, README sections, API docs needed>
+
+   ### ASSIGN:DEVOPS
+   <specific tasks \u2014 CI pipeline, Docker setup, deployment target, env variables>
+
+   Only include ASSIGN sections for agents that are actually needed. Skip any that aren't relevant.
+   Each assignment should be specific and actionable \u2014 tell them exactly what to do, not generic instructions.
+
+Be thorough but practical. Focus on actionable tasks.
+Format your output in clear markdown sections.
+REMINDER: Output ONLY a text plan. Do NOT create files, write code, or run any commands.`,
+    allowedTools: ["Read", "Glob", "Grep", "WebSearch", "WebFetch"],
+    disallowedTools: ["Write", "Edit", "Bash", "NotebookEdit"]
+  },
+  designer: {
+    name: "Pixel",
+    emoji: "*",
+    color: "#4ECDC4",
+    description: "UI/UX design & component structure",
+    systemPrompt: `You are Pixel, the UI/UX design agent.
+Your job is to design the user interface and experience.
+
+CRITICAL RULES:
+- You are a DESIGNER ONLY. You produce a design spec document. That is your ENTIRE job.
+- DO NOT write full application code. DO NOT install packages. DO NOT run commands.
+- You may write component scaffold files to illustrate your design, but do NOT implement business logic.
+- Focus on structure, layout, and visual specs \u2014 the Builder will implement the actual code.
+
+Output:
+1. USER FLOWS: Key user journeys
+2. COMPONENT TREE: UI component hierarchy
+3. LAYOUT: Page/screen layouts described in detail
+4. STYLING: Color palette, typography, spacing guidelines
+5. INTERACTIONS: Animations, transitions, states
+6. RESPONSIVE: Mobile/desktop considerations
+
+Write component scaffolds when useful. Focus on developer-implementable specs.
+Format your output in clear markdown sections.`,
+    allowedTools: ["Read", "Write", "Glob", "Grep", "WebSearch"]
+  },
+  architect: {
+    name: "Blueprint",
+    emoji: "#",
+    color: "#45B7D1",
+    description: "System architecture & API design",
+    systemPrompt: `You are Blueprint, the system architect agent.
+Your job is to design the technical architecture and create the project skeleton.
+
+CRITICAL RULES:
+- You are an ARCHITECT. You create the project skeleton, configs, and boilerplate ONLY.
+- You set up the project structure, install dependencies, and write config files.
+- DO NOT implement business logic or features \u2014 the Builder will do that.
+- Keep your code to: project init, folder structure, config files, type definitions, and empty/skeleton files.
+
+Output:
+1. ARCHITECTURE: System design with clear boundaries
+2. DATA MODEL: Database schema or data structures
+3. API DESIGN: Endpoints, request/response shapes
+4. FILE STRUCTURE: Create the actual directory structure and boilerplate files
+5. DEPENDENCIES: Required packages with versions
+6. PATTERNS: Design patterns to follow
+7. MODULE SPLIT: Define independent modules that can be coded in parallel. Format each module as:
+   ### MODULE: <name>
+   **Files:** <comma-separated file paths>
+   **Description:** <what this module does>
+
+Create actual files for the project structure, configs, and boilerplate.
+The MODULE SPLIT section is critical - it tells the system how to parallelize coding.
+REMINDER: Set up skeleton only. Do NOT implement features \u2014 that's the Builder's job.`,
+    allowedTools: ["Read", "Write", "Edit", "Bash", "Glob", "Grep"]
+  },
+  builder: {
+    name: "Builder",
+    emoji: "+",
+    color: "#96CEB4",
+    description: "Code implementation",
+    systemPrompt: `You are Builder, the implementation agent.
+Your job is to write production-quality code based on the plan and architecture.
+
+Rules:
+- Follow the architecture exactly
+- Write clean, well-structured code
+- Handle errors properly
+- Follow the existing code style
+- Install dependencies as needed
+- Make sure files are complete and runnable
+
+Focus on your assigned module. Do not modify files outside your scope unless absolutely necessary.`,
+    allowedTools: ["Read", "Write", "Edit", "Bash", "Glob", "Grep"]
+  },
+  guardian: {
+    name: "Guardian",
+    emoji: "~",
+    color: "#FFEAA7",
+    description: "Testing & test suite generation",
+    systemPrompt: `You are Guardian, the testing agent.
+Your job is to create comprehensive test suites and run them.
+
+Tasks:
+1. Analyze the codebase to understand what to test
+2. Write unit tests for all modules
+3. Write integration tests for APIs/flows
+4. Run the tests and fix any failures
+5. Report test coverage and results
+
+Use the project's testing framework or set one up if none exists.
+Output your results with clear PASS/FAIL indicators.`,
+    allowedTools: ["Read", "Write", "Edit", "Bash", "Glob", "Grep"]
+  },
+  sentinel: {
+    name: "Sentinel",
+    emoji: "?",
+    color: "#DDA0DD",
+    description: "Code review & quality assurance",
+    systemPrompt: `You are Sentinel, the code review agent.
+Your job is to review all code changes for quality and correctness.
+
+CRITICAL RULES:
+- You are a REVIEWER ONLY. You produce a review report. That is your ENTIRE job.
+- DO NOT write code. DO NOT create files. DO NOT fix bugs. DO NOT run commands.
+- DO NOT use Write, Edit, or Bash tools. You may ONLY use Read, Glob, and Grep.
+- Your output is ONLY a review report. The Builder will fix any issues you find.
+
+Review for:
+1. BUGS: Logic errors, edge cases, race conditions
+2. SECURITY: Injection, XSS, auth issues, secrets in code
+3. PERFORMANCE: N+1 queries, memory leaks, unnecessary computation
+4. STYLE: Consistency, naming, dead code
+5. ARCHITECTURE: Does implementation match the design?
+
+Output a structured review with severity levels: CRITICAL, WARNING, INFO.
+If critical issues are found, include "NEEDS_REVISION" at the top with specific fixes required.
+If everything looks good, include "APPROVED" at the top.`,
+    allowedTools: ["Read", "Glob", "Grep"],
+    disallowedTools: ["Write", "Edit", "Bash", "NotebookEdit"]
+  },
+  scribe: {
+    name: "Scribe",
+    emoji: "=",
+    color: "#B8E986",
+    description: "Documentation generation",
+    systemPrompt: `You are Scribe, the documentation agent.
+Your job is to create clear, useful documentation.
+
+Create:
+1. README.md with setup instructions, usage, and examples
+2. API documentation if applicable
+3. Architecture decision records for key choices
+4. Inline code comments where logic is complex
+
+Keep docs concise, practical, and developer-friendly.
+Do not over-document obvious code.`,
+    allowedTools: ["Read", "Write", "Edit", "Glob", "Grep"]
+  },
+  analyst: {
+    name: "Analyst",
+    emoji: "@",
+    color: "#F0A500",
+    description: "Business analysis & user stories",
+    systemPrompt: `You are the Analyst (Business Analyst) agent in a software engineering team.
+Your job is to deeply understand the business requirements and translate them into clear, actionable specs.
+
+CRITICAL RULES:
+- You are an ANALYST ONLY. You produce a requirements document. That is your ENTIRE job.
+- DO NOT write code. DO NOT create files. DO NOT run commands.
+- DO NOT use Write, Edit, or Bash tools. You may ONLY use Read, Glob, and Grep to understand existing code.
+- Your output is ONLY a markdown analysis document. Nothing else.
+
+Output:
+1. PROBLEM STATEMENT: What problem are we solving and for whom
+2. USER PERSONAS: Who are the target users, their goals and pain points
+3. USER STORIES: Write user stories in "As a [user], I want [goal] so that [reason]" format
+4. ACCEPTANCE CRITERIA: Clear pass/fail criteria for each user story
+5. EDGE CASES: Unusual scenarios and how they should be handled
+6. PRIORITIES: MoSCoW prioritization (Must have, Should have, Could have, Won't have)
+7. SUCCESS METRICS: How we'll measure if this is working
+
+Be thorough. Think about what the developer needs to know to build the right thing.
+Format your output in clear markdown sections.
+REMINDER: Output ONLY a text document. Do NOT create files, write code, or run any commands.`,
+    allowedTools: ["Read", "Glob", "Grep", "WebSearch", "WebFetch"],
+    disallowedTools: ["Write", "Edit", "Bash", "NotebookEdit"]
+  },
+  qa: {
+    name: "QA Lead",
+    emoji: "%",
+    color: "#E17055",
+    description: "Test planning & quality strategy",
+    systemPrompt: `You are the QA Lead agent in a software engineering team.
+Your job is to create a comprehensive test strategy and detailed test plans BEFORE code is tested.
+
+CRITICAL RULES:
+- You are a QA PLANNER. You produce test plans and test case documents.
+- You may write test case files as examples, but the Guardian will execute and expand them.
+- DO NOT implement features. DO NOT modify source code. DO NOT run the application.
+
+Output:
+1. TEST STRATEGY: Overall approach (unit, integration, e2e, manual)
+2. TEST PLAN: Detailed test cases organized by feature/module
+   - Test ID, description, preconditions, steps, expected result, priority
+3. TEST MATRIX: Coverage matrix mapping requirements to test cases
+4. REGRESSION CHECKLIST: Critical paths that must always pass
+5. EDGE CASES: Boundary values, error conditions, concurrency scenarios
+6. PERFORMANCE CRITERIA: Load expectations, response time targets
+7. ACCESSIBILITY CHECKLIST: A11y requirements if applicable
+8. TEST DATA: Sample data sets needed for testing
+
+Write actual test case files when useful. Be specific about what to verify.
+Format your output in clear markdown sections.`,
+    allowedTools: ["Read", "Write", "Glob", "Grep"]
+  },
+  devops: {
+    name: "DevOps",
+    emoji: "&",
+    color: "#6C5CE7",
+    description: "CI/CD, deployment & infrastructure",
+    systemPrompt: `You are the DevOps agent in a software engineering team.
+Your job is to set up CI/CD pipelines, deployment configuration, and infrastructure.
+
+Tasks:
+1. CI PIPELINE: Set up GitHub Actions or similar CI workflow
+   - Lint, test, build, deploy steps
+2. DOCKER: Create Dockerfile and docker-compose.yml if appropriate
+3. DEPLOYMENT: Configure deployment (Vercel, Railway, AWS, etc.)
+4. ENVIRONMENT: Set up .env.example with all required variables
+5. SCRIPTS: Add useful npm/make scripts for dev workflow
+6. MONITORING: Basic health checks and logging setup
+7. SECURITY: Environment variable management, secrets handling
+
+Create actual config files. Focus on a simple, working setup.
+Format your output in clear markdown sections.`,
+    allowedTools: ["Read", "Write", "Edit", "Bash", "Glob", "Grep"]
+  },
+  security: {
+    name: "Shield",
+    emoji: "!",
+    color: "#D63031",
+    description: "Security audit & vulnerability assessment",
+    systemPrompt: `You are Shield, the security audit agent in a software engineering team.
+Your job is to perform a thorough security assessment of the codebase.
+
+CRITICAL RULES:
+- You are an AUDITOR ONLY. You produce a security report. That is your ENTIRE job.
+- DO NOT write code. DO NOT create files. DO NOT fix issues.
+- DO NOT use Write or Edit tools. You may use Read, Glob, Grep, and Bash (for npm audit only).
+- Your output is ONLY a security report. The Builder will fix any issues you find.
+
+Audit for:
+1. INJECTION: SQL injection, command injection, XSS, template injection
+2. AUTHENTICATION: Weak auth, missing auth checks, session handling
+3. AUTHORIZATION: Privilege escalation, IDOR, missing access controls
+4. DATA EXPOSURE: Secrets in code, sensitive data in logs, PII handling
+5. DEPENDENCIES: Known vulnerabilities in dependencies (run npm audit or similar)
+6. CONFIGURATION: Insecure defaults, debug mode, CORS, CSP headers
+7. CRYPTOGRAPHY: Weak hashing, insecure random, hardcoded keys
+8. API SECURITY: Rate limiting, input validation, error leakage
+
+Output a structured report with severity levels: CRITICAL, HIGH, MEDIUM, LOW.
+Include specific file paths, line numbers, and recommended fixes.
+If critical issues are found, include "NEEDS_REVISION" at the top.
+If everything looks good, include "APPROVED" at the top.`,
+    allowedTools: ["Read", "Bash", "Glob", "Grep"],
+    disallowedTools: ["Write", "Edit", "NotebookEdit"]
+  }
+};
+for (const role of Object.values(ROLES)) {
+  role.systemPrompt += SHARED_MEMORY_INSTRUCTIONS;
+}
+
+// src/agents/registry.ts
+var AgentRegistry = class {
+  agents = /* @__PURE__ */ new Map();
+  register(role, name, emoji, color) {
+    this.agents.set(role, {
+      role,
+      name,
+      emoji,
+      color,
+      status: "idle",
+      output: []
+    });
+  }
+  activate(role, pid, emitter) {
+    const entry = this.agents.get(role);
+    if (entry) {
+      entry.status = "active";
+      entry.pid = pid;
+      entry.emitter = emitter;
+      entry.startTime = Date.now();
+    }
+  }
+  complete(role, result) {
+    const entry = this.agents.get(role);
+    if (entry) {
+      entry.status = result.success ? "done" : "failed";
+      entry.result = result;
+      entry.endTime = Date.now();
+    }
+  }
+  appendOutput(role, line) {
+    const entry = this.agents.get(role);
+    if (entry) {
+      entry.output.push(line);
+      if (entry.output.length > 100) {
+        entry.output = entry.output.slice(-100);
+      }
+    }
+  }
+  get(role) {
+    return this.agents.get(role);
+  }
+  getAll() {
+    return Array.from(this.agents.values());
+  }
+  getActive() {
+    return this.getAll().filter((a) => a.status === "active");
+  }
+  getDuration(role) {
+    const entry = this.agents.get(role);
+    if (!entry?.startTime) return void 0;
+    const end = entry.endTime || Date.now();
+    return Math.round((end - entry.startTime) / 1e3);
+  }
+  /**
+   * Kill all active agent processes (for graceful shutdown)
+   */
+  killAll() {
+    for (const entry of this.getActive()) {
+      if (entry.emitter) {
+        killAgent(entry.emitter);
+      }
+    }
+  }
+};
+
+// src/utils/logger.ts
+import chalk from "chalk";
+var LOG_LEVELS = {
+  debug: 0,
+  info: 1,
+  warn: 2,
+  error: 3
+};
+var Logger = class {
+  level = "info";
+  quiet = false;
+  setLevel(level) {
+    this.level = level;
+  }
+  setQuiet(quiet) {
+    this.quiet = quiet;
+  }
+  debug(msg, ...args) {
+    if (this.shouldLog("debug")) {
+      console.error(chalk.gray(`[DEBUG] ${msg}`), ...args);
+    }
+  }
+  info(msg, ...args) {
+    if (this.shouldLog("info")) {
+      console.error(chalk.blue(`[INFO] ${msg}`), ...args);
+    }
+  }
+  warn(msg, ...args) {
+    if (this.shouldLog("warn")) {
+      console.error(chalk.yellow(`[WARN] ${msg}`), ...args);
+    }
+  }
+  error(msg, ...args) {
+    if (this.shouldLog("error")) {
+      console.error(chalk.red(`[ERROR] ${msg}`), ...args);
+    }
+  }
+  success(msg, ...args) {
+    if (this.shouldLog("info")) {
+      console.error(chalk.green(`[OK] ${msg}`), ...args);
+    }
+  }
+  shouldLog(level) {
+    if (this.quiet) return level === "error";
+    return LOG_LEVELS[level] >= LOG_LEVELS[this.level];
+  }
+};
+var logger = new Logger();
+
+// src/orchestrator/supervisor.ts
+import { EventEmitter as EventEmitter2 } from "events";
+import { execSync } from "child_process";
+var DEFAULT_LIMITS = {
+  maxMemoryMB: 512,
+  maxTimeSeconds: 600,
+  hungWarningSeconds: 120,
+  hungKillSeconds: 300,
+  pollIntervalMs: 5e3
+};
+var ProcessSupervisor = class extends EventEmitter2 {
+  tracked = /* @__PURE__ */ new Map();
+  pollTimer = null;
+  limits;
+  constructor(limits) {
+    super();
+    this.limits = { ...DEFAULT_LIMITS, ...limits };
+  }
+  /**
+   * Start watching a spawned child process.
+   */
+  track(role, child) {
+    if (!child.pid) return;
+    const entry = {
+      pid: child.pid,
+      role,
+      child,
+      spawnedAt: Date.now(),
+      lastOutputAt: Date.now(),
+      warned: false
+    };
+    this.tracked.set(child.pid, entry);
+    child.stdout?.on("data", () => {
+      entry.lastOutputAt = Date.now();
+    });
+    child.stderr?.on("data", () => {
+      entry.lastOutputAt = Date.now();
+    });
+    child.on("close", () => {
+      this.tracked.delete(entry.pid);
+    });
+    child.on("error", () => {
+      this.tracked.delete(entry.pid);
+    });
+    if (!this.pollTimer) {
+      this.startPolling();
+    }
+  }
+  /**
+   * Manually refresh output timestamp for a role (e.g. from engine events).
+   */
+  heartbeat(role) {
+    for (const entry of this.tracked.values()) {
+      if (entry.role === role) {
+        entry.lastOutputAt = Date.now();
+      }
+    }
+  }
+  /**
+   * Get current stats for all tracked processes.
+   */
+  getStats() {
+    const pids = Array.from(this.tracked.keys());
+    if (pids.length === 0) return [];
+    const resourceMap = this.pollResources(pids);
+    const now = Date.now();
+    const stats = [];
+    for (const entry of this.tracked.values()) {
+      const res = resourceMap.get(entry.pid);
+      const uptime = Math.round((now - entry.spawnedAt) / 1e3);
+      const lastOutputAge = Math.round((now - entry.lastOutputAt) / 1e3);
+      const memoryMB = res?.memoryMB ?? 0;
+      const cpuPercent = res?.cpuPercent ?? 0;
+      let status = "healthy";
+      if (memoryMB > this.limits.maxMemoryMB * 0.8 || uptime > this.limits.maxTimeSeconds * 0.8 || lastOutputAge > this.limits.hungWarningSeconds) {
+        status = "warning";
+      }
+      if (memoryMB > this.limits.maxMemoryMB || uptime > this.limits.maxTimeSeconds || lastOutputAge > this.limits.hungKillSeconds) {
+        status = "critical";
+      }
+      stats.push({
+        pid: entry.pid,
+        role: entry.role,
+        memoryMB,
+        cpuPercent,
+        uptime,
+        lastOutputAge,
+        status
+      });
+    }
+    return stats;
+  }
+  /**
+   * Stop supervising. Clears poll timer but does NOT kill tracked processes.
+   */
+  stop() {
+    if (this.pollTimer) {
+      clearInterval(this.pollTimer);
+      this.pollTimer = null;
+    }
+  }
+  /**
+   * Stop supervising and kill ALL tracked processes immediately.
+   */
+  killAll() {
+    this.stop();
+    for (const entry of this.tracked.values()) {
+      this.killProcess(entry, "supervisor shutdown");
+    }
+    this.tracked.clear();
+  }
+  /**
+   * Get number of active tracked processes.
+   */
+  get activeCount() {
+    return this.tracked.size;
+  }
+  // ── Private ──────────────────────────────────────────────
+  startPolling() {
+    this.pollTimer = setInterval(() => {
+      this.runChecks();
+    }, this.limits.pollIntervalMs);
+    this.pollTimer.unref();
+  }
+  runChecks() {
+    if (this.tracked.size === 0) {
+      this.stop();
+      return;
+    }
+    const stats = this.getStats();
+    this.emit("stats", stats);
+    for (const stat of stats) {
+      const entry = this.tracked.get(stat.pid);
+      if (!entry) continue;
+      if (stat.memoryMB > this.limits.maxMemoryMB) {
+        this.killProcess(entry, `memory limit exceeded (${Math.round(stat.memoryMB)}MB > ${this.limits.maxMemoryMB}MB)`);
+        continue;
+      }
+      if (stat.uptime > this.limits.maxTimeSeconds) {
+        this.killProcess(entry, `timeout exceeded (${stat.uptime}s > ${this.limits.maxTimeSeconds}s)`);
+        continue;
+      }
+      if (stat.lastOutputAge > this.limits.hungKillSeconds) {
+        this.killProcess(entry, `no output for ${stat.lastOutputAge}s (limit: ${this.limits.hungKillSeconds}s)`);
+        continue;
+      }
+      if (stat.lastOutputAge > this.limits.hungWarningSeconds && !entry.warned) {
+        entry.warned = true;
+        this.emit("warning", {
+          role: entry.role,
+          pid: entry.pid,
+          reason: `no output for ${stat.lastOutputAge}s`,
+          stats: stat
+        });
+      }
+      if (stat.memoryMB > this.limits.maxMemoryMB * 0.8 && !entry.warned) {
+        entry.warned = true;
+        this.emit("warning", {
+          role: entry.role,
+          pid: entry.pid,
+          reason: `high memory usage (${Math.round(stat.memoryMB)}MB)`,
+          stats: stat
+        });
+      }
+      if (stat.uptime > this.limits.maxTimeSeconds * 0.8 && !entry.warned) {
+        entry.warned = true;
+        this.emit("warning", {
+          role: entry.role,
+          pid: entry.pid,
+          reason: `approaching timeout (${stat.uptime}s / ${this.limits.maxTimeSeconds}s)`,
+          stats: stat
+        });
+      }
+    }
+  }
+  /**
+   * Use `ps` to get memory (RSS) and CPU% for a list of PIDs.
+   * Works on macOS and Linux.
+   */
+  pollResources(pids) {
+    const result = /* @__PURE__ */ new Map();
+    try {
+      const pidList = pids.join(",");
+      const output = execSync(`ps -o pid=,rss=,pcpu= -p ${pidList} 2>/dev/null`, {
+        encoding: "utf-8",
+        timeout: 3e3
+      });
+      for (const line of output.trim().split("\n")) {
+        const parts = line.trim().split(/\s+/);
+        if (parts.length >= 3) {
+          const pid = parseInt(parts[0], 10);
+          const rssKB = parseInt(parts[1], 10);
+          const cpu = parseFloat(parts[2]);
+          if (!isNaN(pid) && !isNaN(rssKB)) {
+            result.set(pid, {
+              memoryMB: Math.round(rssKB / 1024 * 10) / 10,
+              cpuPercent: isNaN(cpu) ? 0 : cpu
+            });
+          }
+        }
+      }
+    } catch {
+    }
+    return result;
+  }
+  killProcess(entry, reason) {
+    logger.info(`Supervisor killing ${entry.role} (PID ${entry.pid}): ${reason}`);
+    this.emit("killed", {
+      role: entry.role,
+      pid: entry.pid,
+      reason
+    });
+    try {
+      process.kill(-entry.pid, "SIGTERM");
+    } catch {
+      try {
+        entry.child.kill("SIGTERM");
+      } catch {
+      }
+    }
+    setTimeout(() => {
+      try {
+        process.kill(-entry.pid, "SIGKILL");
+      } catch {
+      }
+      try {
+        entry.child.kill("SIGKILL");
+      } catch {
+      }
+    }, 3e3).unref();
+    this.tracked.delete(entry.pid);
+  }
+};
+
+// src/orchestrator/plan-parser.ts
+var ROLE_KEY_MAP = {
+  ANALYST: "analyst",
+  STRATEGIST: "strategist",
+  DESIGNER: "designer",
+  PIXEL: "designer",
+  ARCHITECT: "architect",
+  BLUEPRINT: "architect",
+  BUILDER: "builder",
+  QA: "qa",
+  "QA LEAD": "qa",
+  GUARDIAN: "guardian",
+  TESTER: "guardian",
+  SENTINEL: "sentinel",
+  REVIEWER: "sentinel",
+  SECURITY: "security",
+  SHIELD: "security",
+  SCRIBE: "scribe",
+  DOCS: "scribe",
+  DOCUMENTATION: "scribe",
+  DEVOPS: "devops",
+  DEPLOY: "devops",
+  DEPLOYMENT: "devops"
+};
+function parsePlan(planText) {
+  const assignments = /* @__PURE__ */ new Map();
+  const assignRegex = /###\s*ASSIGN\s*:\s*(\w[\w\s]*?)[\n\r]([\s\S]*?)(?=###\s*ASSIGN\s*:|$)/gi;
+  let match;
+  while ((match = assignRegex.exec(planText)) !== null) {
+    const rawRole = match[1].trim().toUpperCase();
+    const taskBody = match[2].trim();
+    const roleKey = ROLE_KEY_MAP[rawRole];
+    if (roleKey && taskBody) {
+      assignments.set(roleKey, taskBody);
+    }
+  }
+  const modules = extractModules(planText);
+  const overview = extractSection(planText, "OVERVIEW") || "";
+  return {
+    raw: planText,
+    assignments,
+    modules,
+    overview
+  };
+}
+function getAgentTask(plan, role, fallbackPrompt) {
+  const assignment = plan.assignments.get(role);
+  if (assignment) {
+    return `You have been assigned the following tasks by the team Strategist:
+
+${assignment}
+
+Here is the full plan for context:
+
+${plan.raw}`;
+  }
+  return `${fallbackPrompt}
+
+Here is the master plan from the Strategist:
+
+${plan.raw}`;
+}
+function extractModules(text) {
+  const moduleRegex = /### MODULE:\s*(.+?)(?:\n|$)([\s\S]*?)(?=### MODULE:|$)/g;
+  const modules = [];
+  let match;
+  while ((match = moduleRegex.exec(text)) !== null) {
+    const moduleName = match[1].trim();
+    const moduleBody = match[2].trim();
+    modules.push(`${moduleName}
+${moduleBody}`);
+  }
+  return modules;
+}
+function extractSection(text, sectionName) {
+  const regex = new RegExp(
+    `(?:#{1,3}\\s*(?:\\d+\\.?\\s*)?${sectionName}[:\\s]*\\n)([\\s\\S]*?)(?=\\n#{1,3}\\s|$)`,
+    "i"
+  );
+  const match = regex.exec(text);
+  return match ? match[1].trim() : null;
+}
+
+// src/orchestrator/brain.ts
+import { EventEmitter as EventEmitter4 } from "events";
+
+// src/orchestrator/memory.ts
+import * as fs2 from "fs";
+import * as path2 from "path";
+import { EventEmitter as EventEmitter3 } from "events";
+var SharedMemory = class extends EventEmitter3 {
+  store = /* @__PURE__ */ new Map();
+  sharedDir;
+  krenkDir;
+  constructor(projectDir) {
+    super();
+    this.krenkDir = path2.join(projectDir, ".krenk");
+    this.sharedDir = path2.join(this.krenkDir, "shared");
+    fs2.mkdirSync(this.sharedDir, { recursive: true });
+    this.writeSection("brain", "# Master Brain Directives\n\n_No directives yet._\n");
+    this.writeSection("status", "# Agent Status\n\n_Starting..._\n");
+    this.writeSection("learnings", "# Team Learnings\n\n");
+    this.writeSection("blockers", "# Known Blockers\n\n_None yet._\n");
+    this.writeSection("decisions", "# Decisions Log\n\n");
+  }
+  // ── Read ────────────────────────────────────────────────
+  /**
+   * Get a section from memory.
+   */
+  get(section) {
+    return this.store.get(section) || "";
+  }
+  /**
+   * Get the full shared memory as a single context string.
+   * This is injected into agent prompts so they see the team state.
+   */
+  getFullContext() {
+    const parts = ["# Shared Team Memory (.krenk/shared/)\n"];
+    parts.push("You can read these files with the Read tool for more detail.\n");
+    const brain = this.store.get("brain");
+    if (brain) {
+      parts.push(brain);
+      parts.push("");
+    }
+    const status = this.store.get("status");
+    if (status) {
+      parts.push(status);
+      parts.push("");
+    }
+    const learnings = this.store.get("learnings");
+    if (learnings && learnings.split("\n").length > 3) {
+      parts.push(learnings);
+      parts.push("");
+    }
+    const blockers = this.store.get("blockers");
+    if (blockers && !blockers.includes("None yet")) {
+      parts.push(blockers);
+      parts.push("");
+    }
+    const decisions = this.store.get("decisions");
+    if (decisions && decisions.split("\n").length > 3) {
+      parts.push(decisions);
+      parts.push("");
+    }
+    return parts.join("\n");
+  }
+  /**
+   * Get the path to the shared directory (so agents know where to look).
+   */
+  getSharedDir() {
+    return this.sharedDir;
+  }
+  // ── Write ───────────────────────────────────────────────
+  /**
+   * Write/overwrite a section.
+   */
+  writeSection(section, content) {
+    this.store.set(section, content);
+    this.writeToDisk(section, content);
+    this.emit("update", { section, content });
+  }
+  /**
+   * Append to a section.
+   */
+  appendSection(section, line) {
+    const existing = this.store.get(section) || "";
+    const updated = existing + line + "\n";
+    this.store.set(section, updated);
+    this.writeToDisk(section, updated);
+    this.emit("update", { section, content: updated });
+  }
+  // ── Agent Status ────────────────────────────────────────
+  /**
+   * Update the live status board.
+   */
+  updateAgentStatus(agents) {
+    const lines = ["# Agent Status\n"];
+    const now = (/* @__PURE__ */ new Date()).toLocaleTimeString();
+    lines.push(`_Updated: ${now}_
+`);
+    for (const a of agents) {
+      const statusIcon = a.status === "active" ? ">" : a.status === "done" ? "+" : a.status === "failed" ? "x" : a.status === "idle" ? "-" : "?";
+      const info = a.info ? ` \u2014 ${a.info}` : "";
+      lines.push(`${statusIcon} **${a.name}**: ${a.status}${info}`);
+    }
+    this.writeSection("status", lines.join("\n") + "\n");
+  }
+  /**
+   * Write an individual agent's progress file.
+   */
+  writeAgentProgress(role, content) {
+    this.store.set(`agent-${role}`, content);
+    this.writeToDisk(role, content);
+  }
+  // ── Brain Directives ────────────────────────────────────
+  /**
+   * Write a directive from the Master Brain.
+   */
+  writeDirective(directive) {
+    this.appendSection("brain", `
+---
+${directive}
+`);
+  }
+  /**
+   * Log a decision.
+   */
+  logDecision(decision) {
+    const timestamp = (/* @__PURE__ */ new Date()).toLocaleTimeString();
+    this.appendSection("decisions", `- [${timestamp}] ${decision}
+`);
+  }
+  /**
+   * Log a learning.
+   */
+  logLearning(learning) {
+    this.appendSection("learnings", `- ${learning}
+`);
+  }
+  /**
+   * Log a blocker.
+   */
+  logBlocker(role, blocker) {
+    const content = this.store.get("blockers") || "";
+    const updated = content.includes("None yet") ? `# Known Blockers
+
+- [${role}] ${blocker}
+` : content + `- [${role}] ${blocker}
+`;
+    this.writeSection("blockers", updated);
+  }
+  // ── Private ─────────────────────────────────────────────
+  writeToDisk(name, content) {
+    try {
+      const filePath = path2.join(this.sharedDir, `${name}.md`);
+      fs2.writeFileSync(filePath, content, "utf-8");
+    } catch (err) {
+      logger.error(`SharedMemory: failed to write ${name}.md`);
+    }
+  }
+};
+
+// src/orchestrator/brain.ts
+var MasterBrain = class extends EventEmitter4 {
+  memory;
+  plan = null;
+  agentOutputs = /* @__PURE__ */ new Map();
+  agentLiveBuffer = /* @__PURE__ */ new Map();
+  redoCounts = /* @__PURE__ */ new Map();
+  MAX_REDOS = 2;
+  completedRoles = /* @__PURE__ */ new Set();
+  activeRoles = /* @__PURE__ */ new Set();
+  // Error detection patterns
+  issuePatterns = [
+    /error:\s+(?!.*test|.*expect|.*assert)/i,
+    /FATAL/,
+    /panic:/i,
+    /cannot find module/i,
+    /unhandled.*rejection/i,
+    /out of memory/i,
+    /maximum call stack/i,
+    /ENOSPC/i,
+    /permission denied/i
+  ];
+  // Off-track detection per role
+  offTrackPatterns = /* @__PURE__ */ new Map([
+    ["builder", [/writing tests/i, /writing documentation/i, /reviewing code/i]],
+    ["guardian", [/implementing feature/i, /refactoring/i]],
+    ["sentinel", [/fixing.*bug/i, /implementing/i]],
+    ["scribe", [/implementing/i, /writing tests/i]]
+  ]);
+  constructor(projectDir) {
+    super();
+    this.memory = new SharedMemory(projectDir);
+  }
+  // ── Plan ────────────────────────────────────────────────
+  setPlan(plan) {
+    this.plan = plan;
+    this.memory.logDecision("Master plan received from Strategist");
+    const assignedRoles = Array.from(plan.assignments.keys());
+    this.memory.writeDirective(
+      `## Master Plan Active
+
+Assigned agents: ${assignedRoles.map((r) => ROLES[r]?.name || r).join(", ")}
+Modules: ${plan.modules.length}
+
+All agents: follow your ASSIGN section from the plan.`
+    );
+  }
+  // ── Agent Lifecycle ─────────────────────────────────────
+  /**
+   * Called when an agent is about to run.
+   * Prepares a complete brief with:
+   *   - Shared memory context (what the team knows)
+   *   - Brain's directives and decisions
+   *   - Cross-agent learnings
+   *   - Role-specific guardrails
+   *   - Path to shared dir so agent can read more
+   */
+  prepareBrief(role, basePrompt) {
+    this.activeRoles.add(role);
+    this.updateStatusBoard();
+    const parts = [];
+    const memoryContext = this.memory.getFullContext();
+    if (memoryContext) {
+      parts.push(memoryContext);
+    }
+    parts.push(`## Shared Memory Location`);
+    parts.push(`The team's shared memory is at: ${this.memory.getSharedDir()}/`);
+    parts.push(`You can read any .md file there with the Read tool for full context.`);
+    parts.push(`Write your progress updates to: ${this.memory.getSharedDir()}/${role}.md`);
+    parts.push("");
+    const guardrails = this.getGuardrails(role);
+    if (guardrails) {
+      parts.push("## Constraints from Master Brain:");
+      parts.push(guardrails);
+      parts.push("");
+    }
+    const brief = parts.length > 0 ? `${parts.join("\n")}
+---
+
+${basePrompt}` : basePrompt;
+    this.emit("brief", { role, brief: parts.join("\n") });
+    this.memory.logDecision(`Briefed ${ROLES[role]?.name || role} and sent to work`);
+    return brief;
+  }
+  /**
+   * Called with every chunk of output from a running agent.
+   * Monitors in real-time, detects problems, writes updates to shared memory.
+   */
+  monitorOutput(role, chunk) {
+    const existing = this.agentLiveBuffer.get(role) || "";
+    this.agentLiveBuffer.set(role, existing + chunk);
+    const buffer = this.agentLiveBuffer.get(role) || "";
+    if (buffer.length > 0 && buffer.length % 2e3 < chunk.length) {
+      const lastLines = buffer.split("\n").slice(-5).join("\n");
+      this.memory.writeAgentProgress(role, `# ${ROLES[role]?.name || role} \u2014 Progress
+
+_Live output (last few lines):_
+\`\`\`
+${lastLines}
+\`\`\`
+`);
+    }
+    for (const pattern of this.issuePatterns) {
+      if (pattern.test(chunk)) {
+        const msg = `Error detected in ${role}: ${chunk.trim().slice(0, 100)}`;
+        this.memory.logBlocker(role, msg);
+        this.emit("intervention", { role, type: "error_detected", message: msg });
+        return null;
+      }
+    }
+    if (buffer.length > 2e3) {
+      const patterns = this.offTrackPatterns.get(role);
+      if (patterns) {
+        for (const pattern of patterns) {
+          if (pattern.test(chunk)) {
+            const msg = `${role} appears to be doing work outside its scope`;
+            logger.info(`Brain: ${msg}`);
+            this.memory.writeDirective(
+              `## Attention ${ROLES[role]?.name || role}
+
+You appear to be going off-track. Please stay focused on your assigned task. Do NOT do: ${pattern.source}`
+            );
+            this.emit("intervention", { role, type: "off_track", message: msg });
+            return { type: "warn", role, reason: `Off-track: ${pattern.source}` };
+          }
+        }
+      }
+    }
+    return null;
+  }
+  /**
+   * Called when an agent finishes.
+   * Reviews quality, extracts learnings, updates shared memory, decides next action.
+   */
+  reviewOutput(role, result) {
+    this.agentOutputs.set(role, result.output);
+    this.agentLiveBuffer.delete(role);
+    this.activeRoles.delete(role);
+    const summary = this.summarizeOutput(role, result.output);
+    this.memory.writeAgentProgress(
+      role,
+      `# ${ROLES[role]?.name || role} \u2014 Complete
+
+Status: ${result.success ? "SUCCESS" : "FAILED"}
+Duration: ${result.duration}s
+
+## Summary:
+${summary}
+`
+    );
+    if (!result.output || result.output.trim().length < 50) {
+      if (result.success) {
+        this.completedRoles.add(role);
+        this.memory.logDecision(`${role}: accepted (minimal output but success)`);
+        this.updateStatusBoard();
+        this.emit("review", { role, verdict: "accept", notes: "Minimal output" });
+        return { verdict: "accept", notes: "Minimal output" };
+      }
+      const redos = this.redoCounts.get(role) || 0;
+      if (redos < this.MAX_REDOS) {
+        this.redoCounts.set(role, redos + 1);
+        this.memory.logDecision(`${role}: ordering REDO (failed with no output)`);
+        this.emit("review", { role, verdict: "redo", notes: `Redo ${redos + 1}/${this.MAX_REDOS}` });
+        return {
+          verdict: "redo",
+          notes: "Failed with no output",
+          correction: "The previous attempt failed. Please try again carefully."
+        };
+      }
+      this.completedRoles.add(role);
+      this.memory.logDecision(`${role}: accepting failure (max redos reached)`);
+      this.updateStatusBoard();
+      this.emit("review", { role, verdict: "accept", notes: "Max redos reached" });
+      return { verdict: "accept", notes: "Max redos reached" };
+    }
+    if (!result.success) {
+      const redos = this.redoCounts.get(role) || 0;
+      if (redos < this.MAX_REDOS) {
+        this.redoCounts.set(role, redos + 1);
+        const errors = this.extractErrors(result.output);
+        this.memory.logBlocker(role, `Failed (exit ${result.exitCode})`);
+        this.memory.logDecision(`${role}: ordering REDO (exit code ${result.exitCode})`);
+        this.emit("review", { role, verdict: "redo", notes: `Failed, redo ${redos + 1}` });
+        return {
+          verdict: "redo",
+          notes: `Failed (exit ${result.exitCode})`,
+          correction: `Previous attempt failed:
+
+${errors}
+
+Please fix and try again.`
+        };
+      }
+    }
+    this.extractLearnings(role, result.output);
+    const qualityIssue = this.checkQuality(role, result.output);
+    if (qualityIssue) {
+      const redos = this.redoCounts.get(role) || 0;
+      if (redos < this.MAX_REDOS) {
+        this.redoCounts.set(role, redos + 1);
+        this.memory.logDecision(`${role}: ordering REDO (quality issue: ${qualityIssue})`);
+        this.emit("review", { role, verdict: "redo", notes: qualityIssue });
+        return {
+          verdict: "redo",
+          notes: qualityIssue,
+          correction: `Quality review found issues:
+
+${qualityIssue}
+
+Please address these.`
+        };
+      }
+    }
+    this.detectConflicts(role, result.output);
+    this.completedRoles.add(role);
+    this.memory.logDecision(`${role}: ACCEPTED`);
+    this.updateStatusBoard();
+    this.emit("review", { role, verdict: "accept", notes: "OK" });
+    return { verdict: "accept", notes: "OK" };
+  }
+  // ── Phased Execution ────────────────────────────────────
+  /**
+   * Get execution phases for a role.
+   * Builder gets 3 phases with review between each.
+   */
+  getPhases(role, fullPrompt) {
+    if (role !== "builder" || fullPrompt.length < 500) {
+      return [fullPrompt];
+    }
+    this.memory.logDecision("Builder task is large \u2014 splitting into 3 phases");
+    return [
+      `PHASE 1 of 3 \u2014 SETUP
+
+Focus ONLY on: directory structure, installing dependencies, config files, boilerplate. Do NOT implement features.
+
+Write your progress to the shared memory: ${this.memory.getSharedDir()}/builder.md
+
+${fullPrompt}`,
+      `PHASE 2 of 3 \u2014 CORE
+
+Setup is done. Now implement the core features and main logic. Check ${this.memory.getSharedDir()}/brain.md for any directives from the Master Brain.
+
+Continue from where you left off.`,
+      `PHASE 3 of 3 \u2014 POLISH
+
+Core is done. Handle edge cases, error handling, cleanup. Check ${this.memory.getSharedDir()}/brain.md for any final directives.
+
+Continue from where you left off.`
+    ];
+  }
+  /**
+   * Prepare a corrected prompt for redo.
+   */
+  prepareRedoPrompt(role, originalPrompt, correction) {
+    this.memory.writeDirective(`## Redo: ${ROLES[role]?.name || role}
+
+${correction}`);
+    return `${correction}
+
+---
+
+Original task:
+${originalPrompt}`;
+  }
+  getRedoCount(role) {
+    return this.redoCounts.get(role) || 0;
+  }
+  // ── Shared Memory Helpers ───────────────────────────────
+  updateStatusBoard() {
+    const allRoles = Object.keys(ROLES);
+    const agents = allRoles.map((role) => {
+      let status;
+      let info;
+      if (this.completedRoles.has(role)) {
+        const output = this.agentOutputs.get(role);
+        status = "done";
+        info = output ? `${output.length} chars output` : void 0;
+      } else if (this.activeRoles.has(role)) {
+        status = "active";
+        const buf = this.agentLiveBuffer.get(role);
+        info = buf ? `${buf.length} chars so far` : "starting...";
+      } else {
+        status = "idle";
+      }
+      return { role, name: ROLES[role]?.name || role, status, info };
+    });
+    this.memory.updateAgentStatus(agents);
+  }
+  detectConflicts(role, output) {
+    const fileRefs = output.match(/(?:wrote|created|modified|updated|edited)\s+[`"']?([^\s`"']+\.\w+)/gi) || [];
+    for (const [otherRole, otherOutput] of this.agentOutputs) {
+      if (otherRole === role) continue;
+      const otherFiles = (otherOutput.match(/(?:wrote|created|modified)\s+[`"']?([^\s`"']+\.\w+)/gi) || []).map((m) => m.replace(/^(wrote|created|modified|updated|edited)\s+[`"']?/i, ""));
+      for (const ref of fileRefs) {
+        const file = ref.replace(/^(wrote|created|modified|updated|edited)\s+[`"']?/i, "");
+        if (otherFiles.some((f) => f === file)) {
+          const msg = `Possible conflict: ${role} and ${otherRole} both touched ${file}`;
+          logger.info(`Brain: ${msg}`);
+          this.memory.logBlocker(role, msg);
+          this.memory.logDecision(`CONFLICT DETECTED: ${msg}`);
+          this.emit("intervention", { role, type: "conflict", message: msg });
+        }
+      }
+    }
+  }
+  // ── Analysis Helpers ────────────────────────────────────
+  summarizeOutput(role, output) {
+    const lines = output.split("\n");
+    const keyLines = [];
+    for (const line of lines) {
+      if (line.startsWith("#") || line.includes("CRITICAL") || line.includes("IMPORTANT") || line.includes("NOTE:") || line.includes("WARNING") || line.includes("MODULE:") || line.includes("ASSIGN:") || line.includes("APPROVED") || line.includes("NEEDS_REVISION")) {
+        keyLines.push(line);
+      }
+    }
+    return keyLines.length > 0 ? keyLines.slice(0, 20).join("\n") : output.slice(0, 500);
+  }
+  getGuardrails(role) {
+    const base = {
+      builder: [
+        "- Stay in scope: only implement what was assigned",
+        "- Do NOT write tests (Guardian handles that)",
+        "- Do NOT write docs (Scribe handles that)",
+        "- Write progress updates to your shared memory file",
+        "- Check brain.md for any directives before starting"
+      ].join("\n"),
+      guardian: [
+        "- Focus on TESTING only \u2014 do not fix bugs, just report them",
+        "- Use the QA test plan from shared memory if available",
+        "- Report results with PASS/FAIL for each test"
+      ].join("\n"),
+      sentinel: [
+        "- Code REVIEW only \u2014 do NOT modify any code",
+        "- Be specific: file path, line number, issue, fix",
+        "- Say NEEDS_REVISION if critical issues found"
+      ].join("\n"),
+      security: [
+        "- Security AUDIT only \u2014 do NOT modify any code",
+        "- Check OWASP Top 10",
+        "- Run dependency audits",
+        "- Say NEEDS_REVISION if critical issues found"
+      ].join("\n"),
+      scribe: [
+        "- Write docs based on ACTUAL code, not the plan",
+        "- Read the codebase first",
+        "- Keep docs concise"
+      ].join("\n")
+    };
+    return base[role] || null;
+  }
+  extractErrors(output) {
+    const lines = output.split("\n");
+    const errors = lines.filter(
+      (l) => /error|failed|exception|ENOENT|cannot find/i.test(l)
+    ).slice(0, 15);
+    return errors.length > 0 ? errors.join("\n") : output.slice(-500);
+  }
+  extractLearnings(role, output) {
+    if (role === "architect" || role === "strategist") {
+      const techs = [
+        ["typescript", "Project uses TypeScript"],
+        ["react", "Frontend uses React"],
+        ["Next.js", "Using Next.js"],
+        ["express", "Backend uses Express"],
+        ["postgres", "Database is PostgreSQL"],
+        ["prisma", "Using Prisma ORM"],
+        ["tailwind", "Using Tailwind CSS"]
+      ];
+      for (const [keyword, learning] of techs) {
+        if (output.toLowerCase().includes(keyword.toLowerCase())) {
+          this.memory.logLearning(learning);
+        }
+      }
+    }
+    if (role === "builder") {
+      const fileMatches = output.match(/(?:created|wrote|updated)\s+(?:file\s+)?[`"]?([^\s`"]+\.\w+)/gi);
+      if (fileMatches) {
+        this.memory.logLearning(`Builder created/modified ${fileMatches.length} files`);
+      }
+    }
+    if (role === "guardian") {
+      const passMatch = output.match(/(\d+)\s+(?:tests?\s+)?pass/i);
+      const failMatch = output.match(/(\d+)\s+(?:tests?\s+)?fail/i);
+      if (passMatch || failMatch) {
+        this.memory.logLearning(`Tests: ${passMatch?.[1] || 0} passed, ${failMatch?.[1] || 0} failed`);
+      }
+    }
+    if (role === "sentinel") {
+      if (output.includes("APPROVED")) this.memory.logLearning("Code review: APPROVED");
+      if (output.includes("NEEDS_REVISION")) this.memory.logLearning("Code review: NEEDS REVISION");
+    }
+    if (role === "security") {
+      if (output.includes("APPROVED")) this.memory.logLearning("Security audit: PASSED");
+      if (output.includes("NEEDS_REVISION")) this.memory.logLearning("Security audit: ISSUES FOUND");
+    }
+  }
+  checkQuality(role, output) {
+    if (role === "architect" && !output.match(/file|directory|structure/i)) {
+      return "Missing file structure / directory layout";
+    }
+    if (role === "strategist" && !output.match(/task|step|todo|\- \[/i)) {
+      return "Missing concrete tasks";
+    }
+    if (role === "guardian" && !output.match(/pass|fail|test/i)) {
+      return "Missing test results \u2014 did tests actually run?";
+    }
+    return null;
+  }
+};
+
+// src/orchestrator/engine.ts
+var OrchestrationEngine = class extends EventEmitter5 {
+  context;
+  scheduler;
+  registry;
+  supervisor;
+  brain;
+  opts;
+  _stage = "analyzing";
+  _currentOutput = [];
+  _activeAgent = "";
+  _artifacts = [];
+  _startTime = 0;
+  _revisionCount = 0;
+  MAX_REVISIONS = 2;
+  constructor(opts) {
+    super();
+    this.opts = opts;
+    this.context = new ContextManager(opts.cwd);
+    this.scheduler = new Scheduler(opts.maxParallel);
+    this.registry = new AgentRegistry();
+    this.supervisor = new ProcessSupervisor(opts.supervisorLimits);
+    this.brain = new MasterBrain(opts.cwd);
+    for (const [key, role] of Object.entries(ROLES)) {
+      this.registry.register(key, role.name, role.emoji, role.color);
+    }
+    this.supervisor.on("stats", (stats) => this.emit("supervisor:stats", stats));
+    this.supervisor.on("warning", (data) => this.emit("supervisor:warning", data));
+    this.supervisor.on("killed", (data) => this.emit("supervisor:killed", data));
+    this.brain.on("brief", (data) => this.emit("director:brief", data));
+    this.brain.on("review", (data) => this.emit("director:review", data));
+    this.brain.on("intervention", (data) => this.emit("director:intervention", data));
+    this.brain.on("directive", (data) => this.emit("director:directive", data));
+    this.brain.on("decision", (data) => this.emit("brain:decision", data));
+  }
+  get state() {
+    return {
+      stage: this._stage,
+      stages: STAGES,
+      agents: this.registry,
+      activeAgent: this._activeAgent,
+      currentOutput: this._currentOutput,
+      artifacts: this._artifacts,
+      startTime: this._startTime
+    };
+  }
+  /**
+   * Run the full orchestration pipeline.
+   *
+   * Flow:
+   *   1. Analyst analyzes the request
+   *   2. Strategist creates a MASTER PLAN with per-agent assignments
+   *   3. Plan is parsed → Director gets it
+   *   4. For each agent:
+   *      a. Director prepares a brief (plan assignment + learnings + guardrails)
+   *      b. Agent runs (with real-time monitoring by Director)
+   *      c. Director reviews output → accept / redo / skip
+   *      d. If redo → re-run with Director's corrections
+   *   5. Supervisor watches memory/CPU/timeouts throughout
+   */
+  async run(userPrompt) {
+    this._startTime = Date.now();
+    let stageCount = 0;
+    let plan = null;
+    try {
+      if (!this.shouldSkip("analyzing")) {
+        this.setStage("analyzing");
+        const result = await this.runDirectedAgent(
+          "analyst",
+          `Analyze the following request and produce detailed user stories, acceptance criteria, and priorities:
+
+${userPrompt}`
+        );
+        await this.context.save("analyst", result.output);
+        stageCount++;
+      }
+      if (!this.shouldSkip("planning")) {
+        this.setStage("planning");
+        const analysisContext = this.context.get("analyst");
+        const planPrompt = analysisContext ? `${userPrompt}
+
+Business Analysis:
+${analysisContext}` : userPrompt;
+        const planResult = await this.runDirectedAgent("strategist", planPrompt);
+        await this.context.save("strategist", planResult.output);
+        stageCount++;
+        plan = parsePlan(planResult.output);
+        this.brain.setPlan(plan);
+        logger.info(
+          `Plan parsed: ${plan.assignments.size} agent assignments, ${plan.modules.length} modules`
+        );
+        this.emit("plan:parsed", {
+          assignments: Array.from(plan.assignments.keys()),
+          modules: plan.modules.length
+        });
+      }
+      if (!this.shouldSkip("designing") && this.needsDesign()) {
+        this.setStage("designing");
+        const prompt = plan ? getAgentTask(plan, "designer", userPrompt) : userPrompt;
+        const result = await this.runDirectedAgent("designer", prompt);
+        await this.context.save("designer", result.output);
+        stageCount++;
+      }
+      if (!this.shouldSkip("architecting")) {
+        this.setStage("architecting");
+        const prompt = plan ? getAgentTask(plan, "architect", userPrompt) : userPrompt;
+        const result = await this.runDirectedAgent("architect", prompt);
+        await this.context.save("architect", result.output);
+        stageCount++;
+        if (plan) {
+          const archModules = this.extractModules(result.output);
+          if (archModules.length > 0) {
+            plan.modules = archModules;
+          }
+        }
+      }
+      if (!this.shouldSkip("coding")) {
+        this.setStage("coding");
+        const prompt = plan ? getAgentTask(plan, "builder", userPrompt) : userPrompt;
+        await this.runCodingStage(prompt, plan);
+        stageCount++;
+      }
+      if (!this.shouldSkip("qa-planning")) {
+        this.setStage("qa-planning");
+        const prompt = plan ? getAgentTask(plan, "qa", "Create a comprehensive test strategy and detailed test plans.") : "Create a comprehensive test strategy and detailed test plans for the codebase.";
+        const result = await this.runDirectedAgent("qa", prompt);
+        await this.context.save("qa", result.output);
+        stageCount++;
+      }
+      if (!this.shouldSkip("testing")) {
+        this.setStage("testing");
+        const prompt = plan ? getAgentTask(plan, "guardian", "Write and run comprehensive tests.") : "Analyze the codebase and write comprehensive tests. Run them and report results.";
+        const result = await this.runDirectedAgent("guardian", prompt);
+        await this.context.save("guardian", result.output);
+        stageCount++;
+      }
+      if (!this.shouldSkip("reviewing")) {
+        this.setStage("reviewing");
+        const prompt = plan ? getAgentTask(plan, "sentinel", "Review all code for bugs, security issues, and quality.") : "Review all code in this project for bugs, security issues, and quality.";
+        const review = await this.runDirectedAgent("sentinel", prompt);
+        await this.context.save("sentinel", review.output);
+        stageCount++;
+        if (review.output.includes("NEEDS_REVISION") && this._revisionCount < this.MAX_REVISIONS) {
+          this._revisionCount++;
+          logger.info(`Revision ${this._revisionCount}/${this.MAX_REVISIONS} - fixing review issues`);
+          this.setStage("coding");
+          const fix = await this.runDirectedAgent(
+            "builder",
+            `Fix the following issues from code review:
+${review.output}`
+          );
+          await this.context.save("builder", fix.output);
+          stageCount++;
+        }
+      }
+      if (!this.shouldSkip("securing")) {
+        this.setStage("securing");
+        const prompt = plan ? getAgentTask(plan, "security", "Perform a thorough security audit.") : "Perform a thorough security audit of this project.";
+        const secAudit = await this.runDirectedAgent("security", prompt);
+        await this.context.save("security", secAudit.output);
+        stageCount++;
+        if (secAudit.output.includes("NEEDS_REVISION") && this._revisionCount < this.MAX_REVISIONS) {
+          this._revisionCount++;
+          logger.info(`Security revision ${this._revisionCount}/${this.MAX_REVISIONS}`);
+          this.setStage("coding");
+          const fix = await this.runDirectedAgent(
+            "builder",
+            `Fix the following security issues:
+${secAudit.output}`
+          );
+          await this.context.save("builder", fix.output);
+          stageCount++;
+        }
+      }
+      if (!this.shouldSkip("documenting")) {
+        this.setStage("documenting");
+        const prompt = plan ? getAgentTask(plan, "scribe", "Write comprehensive documentation.") : "Write comprehensive documentation for this project.";
+        const result = await this.runDirectedAgent("scribe", prompt);
+        await this.context.save("scribe", result.output);
+        stageCount++;
+      }
+      if (!this.shouldSkip("deploying")) {
+        this.setStage("deploying");
+        const prompt = plan ? getAgentTask(plan, "devops", "Set up CI/CD, Docker, and deployment.") : "Set up CI/CD pipeline, Docker configuration, and deployment setup.";
+        const result = await this.runDirectedAgent("devops", prompt);
+        await this.context.save("devops", result.output);
+        stageCount++;
+      }
+      this.setStage("complete");
+      this.supervisor.stop();
+      const duration = Math.round((Date.now() - this._startTime) / 1e3);
+      await this.context.saveState({
+        stage: "complete",
+        stageCount,
+        duration,
+        runId: this.context.getRunId(),
+        planAssignments: plan ? Array.from(plan.assignments.keys()) : []
+      });
+      return { success: true, stages: stageCount, duration };
+    } catch (error) {
+      const msg = error instanceof Error ? error.message : String(error);
+      logger.error(`Engine failed: ${msg}`);
+      this.emit("error", error);
+      return {
+        success: false,
+        stages: stageCount,
+        duration: Math.round((Date.now() - this._startTime) / 1e3)
+      };
+    }
+  }
+  /**
+   * Run only the planning stage
+   */
+  async runPlanOnly(userPrompt) {
+    this._startTime = Date.now();
+    this.setStage("planning");
+    const plan = await this.runDirectedAgent("strategist", userPrompt);
+    await this.context.save("strategist", plan.output);
+    this.setStage("complete");
+    return plan;
+  }
+  // ── Director-driven agent execution ─────────────────────
+  /**
+   * Run an agent through the full Director cycle:
+   *   1. Director prepares brief (learnings + guardrails + cross-agent context)
+   *   2. Agent runs (Director monitors output in real-time)
+   *   3. Director reviews result → accept / redo
+   *   4. If redo → re-run with Director's corrections
+   */
+  async runDirectedAgent(role, basePrompt) {
+    const briefedPrompt = this.brain.prepareBrief(role, basePrompt);
+    let result = await this.runSingleAgent(role, briefedPrompt);
+    const verdict = this.brain.reviewOutput(role, result);
+    if (verdict.verdict === "redo" && verdict.correction) {
+      logger.info(`Director: redo ${role} \u2014 ${verdict.notes}`);
+      this.emit("director:redo", { role, reason: verdict.notes });
+      const redoPrompt = this.brain.prepareRedoPrompt(
+        role,
+        basePrompt,
+        verdict.correction
+      );
+      result = await this.runSingleAgent(role, redoPrompt);
+      this.brain.reviewOutput(role, result);
+    }
+    return result;
+  }
+  /**
+   * Run coding stage with phased execution and parallel modules.
+   *
+   * For the builder, the Director can split work into phases:
+   *   Phase 1: Setup (structure, deps, configs)
+   *   Phase 2: Core implementation
+   *   Phase 3: Polish (error handling, edge cases)
+   *
+   * Between each phase, the Director reviews and can course-correct.
+   */
+  async runCodingStage(builderPrompt, plan) {
+    let modules = plan?.modules || [];
+    if (modules.length === 0) {
+      const archOutput = this.context.get("architect") || "";
+      modules = this.extractModules(archOutput);
+    }
+    if (modules.length > 1) {
+      logger.info(`Found ${modules.length} modules - spawning parallel builders`);
+      const builderRole = ROLES.builder;
+      const contextStr = this.context.buildContext("builder");
+      const briefedPrompt = this.brain.prepareBrief("builder", builderPrompt);
+      const spawnOpts = modules.map((mod, i) => ({
+        role: `builder-${i}`,
+        prompt: `${briefedPrompt}
+
+---
+
+You are assigned MODULE ${i + 1} of ${modules.length}:
+
+${mod}
+
+Focus only on this module.`,
+        systemPrompt: builderRole.systemPrompt,
+        cwd: this.opts.cwd,
+        maxTurns: this.opts.agentConfig?.builder?.maxTurns || 50,
+        allowedTools: builderRole.allowedTools,
+        context: contextStr
+      }));
+      const results = await this.scheduler.runParallel(
+        spawnOpts,
+        (role, event, data) => {
+          this._activeAgent = role;
+          if (event === "data" && data && typeof data === "object" && "text" in data) {
+            const text = String(data.text);
+            this.brain.monitorOutput(role, text);
+            this._currentOutput.push(text);
+            if (this._currentOutput.length > 50) {
+              this._currentOutput = this._currentOutput.slice(-50);
+            }
+            this.emit("output", { role, text });
+          }
+        }
+      );
+      const combinedOutput = results.map((r) => r.output).join("\n---\n");
+      await this.context.save("builder", combinedOutput);
+    } else {
+      const phases = this.brain.getPhases("builder", builderPrompt);
+      if (phases.length > 1) {
+        let combinedOutput = "";
+        for (let i = 0; i < phases.length; i++) {
+          this.emit("director:phase", {
+            role: "builder",
+            phase: i + 1,
+            total: phases.length
+          });
+          const phasePrompt = this.brain.prepareBrief("builder", phases[i]);
+          const result = await this.runSingleAgent("builder", phasePrompt);
+          combinedOutput += result.output + "\n---\n";
+          if (i < phases.length - 1) {
+            const verdict = this.brain.reviewOutput("builder", result);
+            if (verdict.verdict === "redo" && verdict.correction) {
+              logger.info(`Director: redo builder phase ${i + 1} \u2014 ${verdict.notes}`);
+              this.emit("director:redo", { role: "builder", reason: `Phase ${i + 1}: ${verdict.notes}` });
+              const redoPrompt = this.brain.prepareRedoPrompt(
+                "builder",
+                phases[i],
+                verdict.correction
+              );
+              const redoResult = await this.runSingleAgent("builder", redoPrompt);
+              combinedOutput += redoResult.output + "\n---\n";
+              this.brain.reviewOutput("builder", redoResult);
+            }
+          }
+        }
+        await this.context.save("builder", combinedOutput);
+      } else {
+        const result = await this.runDirectedAgent("builder", builderPrompt);
+        await this.context.save("builder", result.output);
+      }
+    }
+  }
+  // ── Low-level agent spawn ───────────────────────────────
+  /**
+   * Spawn a single agent and wait for completion.
+   * Handles supervised mode approval, supervisor tracking, and output monitoring.
+   */
+  async runSingleAgent(role, prompt) {
+    const roleDef = ROLES[role] || ROLES[role.replace(/-\d+$/, "")];
+    if (!roleDef) {
+      throw new Error(`Unknown role: ${role}`);
+    }
+    const decision = await this.requestApproval(role, roleDef.allowedTools);
+    if (decision === "abort") {
+      throw new Error("Aborted by user");
+    }
+    if (decision === "skip") {
+      return {
+        role,
+        output: "",
+        duration: 0,
+        success: true,
+        exitCode: 0
+      };
+    }
+    return new Promise((resolve, reject) => {
+      this._activeAgent = role;
+      this._currentOutput = [];
+      const prevContext = this.context.buildContext(role);
+      const sharedContext = this.brain.memory.getFullContext();
+      const contextStr = prevContext ? `${prevContext}
+
+${sharedContext}` : sharedContext;
+      const baseRole = role.replace(/-\d+$/, "");
+      const maxTurns = this.opts.agentConfig?.[baseRole]?.maxTurns || 50;
+      const emitter = spawnClaudeAgent({
+        role,
+        prompt,
+        systemPrompt: roleDef.systemPrompt,
+        cwd: this.opts.cwd,
+        maxTurns,
+        allowedTools: roleDef.allowedTools,
+        disallowedTools: roleDef.disallowedTools,
+        context: contextStr
+      });
+      emitter.on("spawned", (pid) => {
+        this.registry.activate(role, pid, emitter);
+        if (emitter.child) {
+          this.supervisor.track(role, emitter.child);
+        }
+        this.emit("agent:spawned", { role, pid });
+        logger.info(`${roleDef.emoji} ${roleDef.name} spawned (PID: ${pid})`);
+      });
+      emitter.on("data", (text) => {
+        this.registry.appendOutput(role, text);
+        this.supervisor.heartbeat(role);
+        const intervention = this.brain.monitorOutput(role, text);
+        if (intervention) {
+          this.emit("director:intervention", intervention);
+        }
+        this._currentOutput.push(text);
+        if (this._currentOutput.length > 50) {
+          this._currentOutput = this._currentOutput.slice(-50);
+        }
+        this.emit("output", { role, text });
+      });
+      emitter.on("done", (result) => {
+        this.registry.complete(role, result);
+        this._artifacts.push(`${role}: ${result.success ? "completed" : "failed"} in ${result.duration}s`);
+        this.emit("agent:done", { role, result });
+        logger.info(
+          `${roleDef.emoji} ${roleDef.name} ${result.success ? "completed" : "failed"} in ${result.duration}s`
+        );
+        resolve(result);
+      });
+      emitter.on("error", (err) => {
+        this.registry.complete(role, {
+          role,
+          output: "",
+          duration: 0,
+          success: false,
+          exitCode: 1
+        });
+        this.emit("agent:error", { role, error: err });
+        logger.error(`${roleDef.emoji} ${roleDef.name} error: ${err.message}`);
+        reject(err);
+      });
+    });
+  }
+  /**
+   * Request approval from user before spawning (supervised mode).
+   */
+  requestApproval(role, tools) {
+    return new Promise((resolve) => {
+      if (!this.opts.supervised) {
+        resolve("approve");
+        return;
+      }
+      const handler = (response) => {
+        resolve(response);
+      };
+      this.once("approve:response", handler);
+      this.emit("approve:request", { role, tools });
+    });
+  }
+  // ── Helpers ─────────────────────────────────────────────
+  extractModules(archOutput) {
+    const moduleRegex = /### MODULE:\s*(.+?)(?:\n|$)([\s\S]*?)(?=### MODULE:|$)/g;
+    const modules = [];
+    let match;
+    while ((match = moduleRegex.exec(archOutput)) !== null) {
+      modules.push(`${match[1].trim()}
+${match[2].trim()}`);
+    }
+    return modules;
+  }
+  needsDesign() {
+    const planOutput = this.context.get("strategist") || "";
+    const uiKeywords = [
+      "ui",
+      "frontend",
+      "react",
+      "vue",
+      "angular",
+      "svelte",
+      "component",
+      "page",
+      "layout",
+      "css",
+      "html",
+      "web app",
+      "website",
+      "dashboard",
+      "interface",
+      "design"
+    ];
+    const lower = planOutput.toLowerCase();
+    return uiKeywords.some((kw) => lower.includes(kw));
+  }
+  shouldSkip(stage) {
+    return shouldSkipStage(stage, this.opts.skipStages);
+  }
+  setStage(stage) {
+    this._stage = stage;
+    this.emit("stage", stage);
+    logger.info(`
+--- Stage: ${stage.toUpperCase()} ---`);
+  }
+  /**
+   * Graceful shutdown
+   */
+  shutdown() {
+    this.supervisor.stop();
+    this.scheduler.killAll();
+    this.registry.killAll();
+    killAllAgents();
+  }
+};
+
+// src/ui/renderer.ts
+import chalk2 from "chalk";
+import ora from "ora";
+import boxen from "boxen";
+import gradient from "gradient-string";
+import figlet from "figlet";
+
+// src/ui/theme.ts
+var THEME = {
+  primary: "#A78BFA",
+  secondary: "#60A5FA",
+  success: "#34D399",
+  warning: "#FBBF24",
+  error: "#F87171",
+  muted: "#6B7280",
+  bg: "#1F2937",
+  gradient: ["#7C3AED", "#A78BFA", "#C084FC"]
+};
+
+// src/utils/process.ts
+function setupGracefulShutdown(engine, onCleanup) {
+  let shuttingDown = false;
+  const shutdown = (signal) => {
+    if (shuttingDown) {
+      console.error("\nForce exit.");
+      killAllAgents();
+      process.exit(1);
+    }
+    shuttingDown = true;
+    console.error(`
+Received ${signal}, shutting down all agents...`);
+    onCleanup?.();
+    engine.shutdown();
+    killAllAgents();
+    setTimeout(() => {
+      killAllAgents();
+      process.exit(signal === "SIGINT" ? 130 : 143);
+    }, 3e3).unref();
+  };
+  process.on("SIGINT", () => shutdown("SIGINT"));
+  process.on("SIGTERM", () => shutdown("SIGTERM"));
+  process.on("uncaughtException", (err) => {
+    console.error("Uncaught exception:", err.message);
+    onCleanup?.();
+    engine.shutdown();
+    killAllAgents();
+    process.exit(1);
+  });
+  process.on("unhandledRejection", (reason) => {
+    console.error("Unhandled rejection:", reason);
+    onCleanup?.();
+    engine.shutdown();
+    killAllAgents();
+    process.exit(1);
+  });
+}
+function formatDuration(seconds) {
+  if (seconds < 60) return `${seconds}s`;
+  const mins = Math.floor(seconds / 60);
+  const secs = seconds % 60;
+  if (mins < 60) return `${mins}m ${secs}s`;
+  const hours = Math.floor(mins / 60);
+  const remainMins = mins % 60;
+  return `${hours}h ${remainMins}m ${secs}s`;
+}
+
+// src/ui/renderer.ts
+var AGENT_PHASES = {
+  strategist: [
+    "analyzing requirements...",
+    "breaking down the problem...",
+    "identifying modules and tasks...",
+    "estimating complexity...",
+    "drafting implementation plan...",
+    "defining file structure...",
+    "mapping dependencies...",
+    "finalizing plan..."
+  ],
+  designer: [
+    "studying user flows...",
+    "mapping component hierarchy...",
+    "designing layouts...",
+    "choosing color palette and typography...",
+    "planning interactions and animations...",
+    "writing component specs..."
+  ],
+  architect: [
+    "designing system architecture...",
+    "defining data models...",
+    "planning API endpoints...",
+    "setting up project skeleton...",
+    "resolving dependencies...",
+    "splitting into parallel modules...",
+    "creating boilerplate files..."
+  ],
+  builder: [
+    "reading the plan and architecture...",
+    "installing dependencies...",
+    "writing core modules...",
+    "implementing features...",
+    "connecting components...",
+    "handling edge cases...",
+    "cleaning up code..."
+  ],
+  guardian: [
+    "scanning the codebase...",
+    "writing unit tests...",
+    "writing integration tests...",
+    "running test suite...",
+    "checking coverage...",
+    "fixing failing tests...",
+    "reporting results..."
+  ],
+  sentinel: [
+    "reading through all files...",
+    "checking for bugs and logic errors...",
+    "scanning for security issues...",
+    "reviewing performance patterns...",
+    "checking code style and consistency...",
+    "verifying architecture compliance...",
+    "writing review summary..."
+  ],
+  scribe: [
+    "reading the codebase...",
+    "writing README...",
+    "documenting API endpoints...",
+    "adding setup instructions...",
+    "writing usage examples...",
+    "finalizing docs..."
+  ],
+  analyst: [
+    "understanding the problem domain...",
+    "identifying user personas...",
+    "writing user stories...",
+    "defining acceptance criteria...",
+    "mapping edge cases...",
+    "prioritizing requirements...",
+    "finalizing business specs..."
+  ],
+  qa: [
+    "analyzing codebase for testability...",
+    "defining test strategy...",
+    "writing test cases...",
+    "creating test matrix...",
+    "identifying edge cases and boundaries...",
+    "building regression checklist...",
+    "finalizing test plan..."
+  ],
+  devops: [
+    "analyzing project structure...",
+    "setting up CI pipeline...",
+    "writing Dockerfile...",
+    "configuring deployment...",
+    "setting up environment variables...",
+    "adding health checks...",
+    "finalizing infrastructure..."
+  ],
+  security: [
+    "scanning for injection vulnerabilities...",
+    "checking authentication flows...",
+    "reviewing authorization logic...",
+    "searching for exposed secrets...",
+    "auditing dependencies...",
+    "checking configuration security...",
+    "writing security report..."
+  ]
+};
+var TerminalRenderer = class {
+  engine;
+  spinners = /* @__PURE__ */ new Map();
+  agentTimings = [];
+  completedStages = 0;
+  totalStages = 0;
+  currentStage = null;
+  phaseTimers = /* @__PURE__ */ new Map();
+  phaseIndex = /* @__PURE__ */ new Map();
+  latestStats = [];
+  killedAgents = [];
+  lastRealUpdate = /* @__PURE__ */ new Map();
+  constructor(engine) {
+    this.engine = engine;
+    this.totalStages = this.countActiveStages();
+    this.bindEvents();
+  }
+  /**
+   * Print the ASCII banner with gradient
+   */
+  printBanner() {
+    const ascii = figlet.textSync("KRENK", { font: "ANSI Shadow" });
+    console.log(gradient(THEME.gradient)(ascii));
+    console.log(chalk2.gray("  Multi-Agent Software Engineering Orchestrator"));
+    console.log(chalk2.gray("  " + "-".repeat(50)));
+    console.log();
+  }
+  /**
+   * Print the user prompt being executed
+   */
+  printPrompt(prompt) {
+    console.log(chalk2.dim(`  Prompt: ${prompt}`));
+    console.log();
+  }
+  /**
+   * Print the final summary after engine completes
+   */
+  printSummary(result) {
+    console.log();
+    const lines = [];
+    if (result.success) {
+      lines.push(chalk2.bold.green("[done] Workflow Complete"));
+    } else {
+      lines.push(chalk2.bold.red("[fail] Workflow Failed"));
+    }
+    lines.push("");
+    lines.push(chalk2.white(`  Stages completed: ${chalk2.bold(String(result.stages))}`));
+    lines.push(chalk2.white(`  Total duration:   ${chalk2.bold(formatDuration(result.duration))}`));
+    lines.push("");
+    lines.push(chalk2.bold.white("  Agent Results:"));
+    for (const agent of this.agentTimings) {
+      const duration = agent.endTime ? Math.round((agent.endTime - agent.startTime) / 1e3) : 0;
+      const killed = this.killedAgents.find((k) => k.role === agent.role);
+      let status;
+      if (killed) {
+        status = chalk2.red("x killed");
+      } else if (agent.success) {
+        status = chalk2.green("+ pass");
+      } else {
+        status = chalk2.red("x fail");
+      }
+      const stat = this.latestStats.find((s) => s.role === agent.role);
+      const memInfo = stat ? chalk2.dim(` ${stat.memoryMB}MB`) : "";
+      lines.push(
+        `    ${agent.emoji} ${chalk2.white(agent.name.padEnd(12))} ${status}  ${chalk2.dim(`${duration}s`)}${memInfo}`
+      );
+    }
+    if (this.killedAgents.length > 0) {
+      lines.push("");
+      lines.push(chalk2.bold.yellow("  Supervisor Actions:"));
+      for (const k of this.killedAgents) {
+        const roleDef = ROLES[k.role] || ROLES[k.role.replace(/-\d+$/, "")];
+        const name = roleDef?.name || k.role;
+        lines.push(chalk2.yellow(`    x ${name} (PID ${k.pid}): ${k.reason}`));
+      }
+    }
+    const panel = boxen(lines.join("\n"), {
+      padding: 1,
+      margin: { top: 0, bottom: 1, left: 1, right: 1 },
+      borderStyle: "round",
+      borderColor: result.success ? "green" : "red"
+    });
+    console.log(panel);
+  }
+  /**
+   * Prompt user to approve/skip/abort an agent (supervised mode).
+   * Uses arrow-key selection directly in the terminal.
+   */
+  handleApprovalRequest({ role, tools }) {
+    const roleDef = ROLES[role] || ROLES[role.replace(/-\d+$/, "")];
+    const name = roleDef?.name || role;
+    const emoji = roleDef?.emoji || ">";
+    const desc = roleDef?.description || "";
+    console.log();
+    console.log(chalk2.bold.hex("#A78BFA")(`  -- Approval Required --`));
+    console.log();
+    console.log(chalk2.white(`  Agent:  ${emoji} ${chalk2.bold(name)}`));
+    console.log(chalk2.dim(`          ${desc}`));
+    console.log(chalk2.dim(`  Tools:  ${tools.join(", ")}`));
+    console.log();
+    const options = ["Approve", "Skip", "Abort"];
+    let selected = 0;
+    const render = () => {
+      for (let i = 0; i < options.length; i++) {
+        const pointer = i === selected ? chalk2.hex("#A78BFA")(">") : " ";
+        const label = i === selected ? chalk2.bold.white(options[i]) : chalk2.dim(options[i]);
+        process.stdout.write(`    ${pointer} ${label}
+`);
+      }
+    };
+    const clear = () => {
+      for (let i = 0; i < options.length; i++) {
+        process.stdout.write("\x1B[1A\x1B[2K");
+      }
+    };
+    render();
+    const wasRaw = process.stdin.isRaw;
+    if (process.stdin.isTTY) process.stdin.setRawMode(true);
+    process.stdin.resume();
+    const onKey = (key) => {
+      const str = key.toString();
+      if (str === "") {
+        if (process.stdin.isTTY) process.stdin.setRawMode(wasRaw ?? false);
+        process.stdin.pause();
+        process.stdin.removeListener("data", onKey);
+        this.engine.emit("approve:response", "abort");
+        return;
+      }
+      if (str === "\x1B[A" && selected > 0) {
+        selected--;
+        clear();
+        render();
+      }
+      if (str === "\x1B[B" && selected < options.length - 1) {
+        selected++;
+        clear();
+        render();
+      }
+      if (str === "\r" || str === "\n") {
+        if (process.stdin.isTTY) process.stdin.setRawMode(wasRaw ?? false);
+        process.stdin.pause();
+        process.stdin.removeListener("data", onKey);
+        clear();
+        const choice = options[selected];
+        const color = choice === "Approve" ? chalk2.green : choice === "Skip" ? chalk2.yellow : chalk2.red;
+        console.log(`    ${color(">")} ${chalk2.bold(choice)}`);
+        console.log();
+        const response = choice.toLowerCase();
+        this.engine.emit("approve:response", response);
+      }
+    };
+    process.stdin.on("data", onKey);
+  }
+  /**
+   * Stop all active spinners (for Ctrl+C cleanup)
+   */
+  cleanup() {
+    for (const [, timer] of this.phaseTimers) {
+      clearInterval(timer);
+    }
+    this.phaseTimers.clear();
+    for (const [, spinner] of this.spinners) {
+      spinner.stop();
+    }
+    this.spinners.clear();
+  }
+  // ── Private ──────────────────────────────────────────────
+  bindEvents() {
+    this.engine.on("stage", (stage) => this.onStage(stage));
+    this.engine.on(
+      "agent:spawned",
+      ({ role, pid }) => this.onAgentSpawned(role, pid)
+    );
+    this.engine.on(
+      "output",
+      ({ role, text }) => this.onAgentOutput(role, text)
+    );
+    this.engine.on(
+      "agent:done",
+      ({ role, result }) => this.onAgentDone(role, result)
+    );
+    this.engine.on(
+      "agent:error",
+      ({ role, error }) => this.onAgentError(role, error)
+    );
+    this.engine.on(
+      "approve:request",
+      (data) => this.handleApprovalRequest(data)
+    );
+    this.engine.on("plan:parsed", ({ assignments, modules }) => {
+      this.onPlanParsed(assignments, modules);
+    });
+    this.engine.on("director:review", ({ role, verdict, notes }) => {
+      this.onDirectorReview(role, verdict, notes);
+    });
+    this.engine.on("director:redo", ({ role, reason }) => {
+      this.onDirectorRedo(role, reason);
+    });
+    this.engine.on("director:intervention", ({ role, type, message }) => {
+      this.onDirectorIntervention(role, type, message);
+    });
+    this.engine.on("director:phase", ({ role, phase, total }) => {
+      this.onDirectorPhase(role, phase, total);
+    });
+    this.engine.on("supervisor:stats", (stats) => {
+      this.latestStats = stats;
+    });
+    this.engine.on("supervisor:warning", ({ role, reason }) => {
+      this.onSupervisorWarning(role, reason);
+    });
+    this.engine.on("supervisor:killed", ({ role, pid, reason }) => {
+      this.onSupervisorKilled(role, pid, reason);
+    });
+  }
+  onStage(stage) {
+    this.currentStage = stage;
+    if (stage === "complete") return;
+    const info = STAGES.find((s) => s.stage === stage);
+    if (!info) return;
+    const label = `${info.emoji} ${info.label.toUpperCase()}`;
+    const line = "-".repeat(Math.max(0, 45 - label.length));
+    console.log();
+    console.log(chalk2.bold.cyan(`  --- ${label} ${line}`));
+    console.log(chalk2.dim(`  ${info.description}`));
+    console.log();
+  }
+  onAgentSpawned(role, _pid) {
+    const baseRole = role.replace(/-\d+$/, "");
+    const roleDef = ROLES[role] || ROLES[baseRole];
+    const name = roleDef?.name || role;
+    const emoji = roleDef?.emoji || ">";
+    this.agentTimings.push({
+      role,
+      name,
+      emoji,
+      startTime: Date.now()
+    });
+    const phases = AGENT_PHASES[baseRole] || [`${name} is working...`];
+    this.phaseIndex.set(role, 0);
+    const spinner = ora({
+      text: `${name} -- ${chalk2.dim(phases[0])}`,
+      prefixText: `  ${emoji}`,
+      spinner: "dots"
+    }).start();
+    this.spinners.set(role, spinner);
+    const timer = setInterval(() => {
+      const lastReal = this.lastRealUpdate.get(role) || 0;
+      const sinceReal = Date.now() - lastReal;
+      if (sinceReal < 1e4) return;
+      const idx = (this.phaseIndex.get(role) || 0) + 1;
+      this.phaseIndex.set(role, idx % phases.length);
+      const currentIdx = idx % phases.length;
+      const elapsed = Math.round((Date.now() - (this.agentTimings.find((a) => a.role === role)?.startTime || Date.now())) / 1e3);
+      const sp = this.spinners.get(role);
+      if (sp) {
+        const stat = this.latestStats.find((s) => s.role === role);
+        const memStr = stat ? chalk2.dim(` | ${stat.memoryMB}MB`) : "";
+        sp.text = `${name} -- ${chalk2.dim(phases[currentIdx])}  ${chalk2.dim.italic(`${elapsed}s`)}${memStr}`;
+      }
+    }, 8e3);
+    this.phaseTimers.set(role, timer);
+  }
+  onAgentOutput(role, text) {
+    const spinner = this.spinners.get(role);
+    if (!spinner) return;
+    const baseRole = role.replace(/-\d+$/, "");
+    const roleDef = ROLES[role] || ROLES[baseRole];
+    const name = roleDef?.name || role;
+    const elapsed = Math.round((Date.now() - (this.agentTimings.find((a) => a.role === role)?.startTime || Date.now())) / 1e3);
+    const stat = this.latestStats.find((s) => s.role === role);
+    const memStr = stat ? chalk2.dim(` | ${stat.memoryMB}MB`) : "";
+    try {
+      const event = JSON.parse(text);
+      if (event.type === "assistant" && event.message?.content) {
+        for (const block of event.message.content) {
+          if (block.type === "tool_use") {
+            const toolName = block.name || "";
+            const input = block.input || {};
+            let detail = "";
+            if (toolName === "Read" && input.file_path) {
+              detail = `reading ${input.file_path.split("/").pop()}`;
+            } else if (toolName === "Write" && input.file_path) {
+              detail = `writing ${input.file_path.split("/").pop()}`;
+            } else if (toolName === "Edit" && input.file_path) {
+              detail = `editing ${input.file_path.split("/").pop()}`;
+            } else if (toolName === "Bash") {
+              const cmd = (input.command || "").slice(0, 40);
+              detail = `running: ${cmd}`;
+            } else if (toolName === "Glob") {
+              detail = `searching files: ${input.pattern || ""}`;
+            } else if (toolName === "Grep") {
+              detail = `searching for: ${(input.pattern || "").slice(0, 30)}`;
+            } else if (toolName === "WebSearch") {
+              detail = `searching web: ${(input.query || "").slice(0, 30)}`;
+            } else {
+              detail = `using ${toolName}`;
+            }
+            spinner.text = `${name} -- ${chalk2.dim(detail)}  ${chalk2.dim.italic(`${elapsed}s`)}${memStr}`;
+            this.lastRealUpdate.set(role, Date.now());
+            return;
+          }
+          if (block.type === "text" && block.text) {
+            const snippet = block.text.trim().slice(0, 70).replace(/\n/g, " ");
+            if (snippet) {
+              spinner.text = `${name} -- ${chalk2.dim(snippet)}  ${chalk2.dim.italic(`${elapsed}s`)}${memStr}`;
+              this.lastRealUpdate.set(role, Date.now());
+              return;
+            }
+          }
+        }
+      }
+      if (event.type === "user") {
+        spinner.text = `${name} -- ${chalk2.dim("processing result...")}  ${chalk2.dim.italic(`${elapsed}s`)}${memStr}`;
+        this.lastRealUpdate.set(role, Date.now());
+        return;
+      }
+    } catch {
+    }
+  }
+  onAgentDone(role, result) {
+    const timer = this.phaseTimers.get(role);
+    if (timer) {
+      clearInterval(timer);
+      this.phaseTimers.delete(role);
+    }
+    const spinner = this.spinners.get(role);
+    const roleDef = ROLES[role] || ROLES[role.replace(/-\d+$/, "")];
+    const name = roleDef?.name || role;
+    const emoji = roleDef?.emoji || ">";
+    const timing = this.agentTimings.find((a) => a.role === role);
+    if (timing) {
+      timing.endTime = Date.now();
+      timing.success = result.success;
+    }
+    if (spinner) {
+      if (result.success) {
+        spinner.succeed(`${emoji} ${name} completed (${result.duration}s)`);
+      } else {
+        spinner.fail(`${emoji} ${name} failed (${result.duration}s)`);
+      }
+      this.spinners.delete(role);
+    }
+    if (!role.includes("-")) {
+      this.completedStages++;
+      this.printProgress();
+    }
+  }
+  onAgentError(role, error) {
+    const timer = this.phaseTimers.get(role);
+    if (timer) {
+      clearInterval(timer);
+      this.phaseTimers.delete(role);
+    }
+    const spinner = this.spinners.get(role);
+    const roleDef = ROLES[role] || ROLES[role.replace(/-\d+$/, "")];
+    const name = roleDef?.name || role;
+    const emoji = roleDef?.emoji || ">";
+    const timing = this.agentTimings.find((a) => a.role === role);
+    if (timing) {
+      timing.endTime = Date.now();
+      timing.success = false;
+    }
+    if (spinner) {
+      spinner.fail(`${emoji} ${name} error: ${error.message}`);
+      this.spinners.delete(role);
+    }
+  }
+  onDirectorReview(role, verdict, notes) {
+    const roleDef = ROLES[role] || ROLES[role.replace(/-\d+$/, "")];
+    const name = roleDef?.name || role;
+    if (verdict === "redo") {
+      console.log(chalk2.yellow(`  PM: ${name} output needs work \u2014 ${notes}`));
+    }
+  }
+  onDirectorRedo(role, reason) {
+    const roleDef = ROLES[role] || ROLES[role.replace(/-\d+$/, "")];
+    const name = roleDef?.name || role;
+    const emoji = roleDef?.emoji || ">";
+    console.log();
+    console.log(chalk2.yellow(`  ${emoji} PM is re-running ${name}: ${reason}`));
+    console.log();
+  }
+  onDirectorIntervention(role, type, message) {
+    const roleDef = ROLES[role] || ROLES[role.replace(/-\d+$/, "")];
+    const name = roleDef?.name || role;
+    const spinner = this.spinners.get(role);
+    if (spinner && type === "off_track") {
+      const prevText = spinner.text;
+      spinner.color = "yellow";
+      spinner.text = `${name} -- ${chalk2.yellow(`PM: ${message}`)}`;
+      setTimeout(() => {
+        if (this.spinners.has(role)) {
+          spinner.color = "cyan";
+          spinner.text = prevText;
+        }
+      }, 5e3);
+    } else if (type === "error_detected") {
+      if (spinner) {
+        const prevText = spinner.text;
+        spinner.color = "red";
+        setTimeout(() => {
+          if (this.spinners.has(role)) {
+            spinner.color = "cyan";
+            spinner.text = prevText;
+          }
+        }, 3e3);
+      }
+    }
+  }
+  onDirectorPhase(role, phase, total) {
+    const roleDef = ROLES[role] || ROLES[role.replace(/-\d+$/, "")];
+    const name = roleDef?.name || role;
+    const emoji = roleDef?.emoji || ">";
+    console.log();
+    console.log(chalk2.hex(THEME.primary)(`  ${emoji} ${name} \u2014 Phase ${phase}/${total}`));
+  }
+  onPlanParsed(assignments, modules) {
+    console.log();
+    console.log(chalk2.bold.hex(THEME.primary)("  --- MASTER PLAN READY ---"));
+    console.log();
+    if (assignments.length > 0) {
+      console.log(chalk2.white("  Agent assignments:"));
+      for (const role of assignments) {
+        const roleDef = ROLES[role];
+        if (roleDef) {
+          console.log(chalk2.dim(`    ${roleDef.emoji} ${roleDef.name}: assigned`));
+        }
+      }
+    }
+    if (modules > 0) {
+      console.log(chalk2.dim(`
+  ${modules} module(s) identified for parallel coding`));
+    }
+    console.log();
+  }
+  onSupervisorWarning(role, reason) {
+    const roleDef = ROLES[role] || ROLES[role.replace(/-\d+$/, "")];
+    const name = roleDef?.name || role;
+    const spinner = this.spinners.get(role);
+    if (spinner) {
+      const prevText = spinner.text;
+      spinner.color = "yellow";
+      spinner.text = `${name} -- ${chalk2.yellow(`! ${reason}`)}`;
+      setTimeout(() => {
+        if (this.spinners.has(role)) {
+          spinner.color = "cyan";
+          spinner.text = prevText;
+        }
+      }, 5e3);
+    }
+  }
+  onSupervisorKilled(role, pid, reason) {
+    const roleDef = ROLES[role] || ROLES[role.replace(/-\d+$/, "")];
+    const name = roleDef?.name || role;
+    const emoji = roleDef?.emoji || ">";
+    const spinner = this.spinners.get(role);
+    this.killedAgents.push({ role, pid, reason });
+    if (spinner) {
+      spinner.fail(`${emoji} ${name} killed by supervisor: ${reason}`);
+      this.spinners.delete(role);
+    } else {
+      console.log(chalk2.red(`  x ${emoji} ${name} killed by supervisor: ${reason}`));
+    }
+    const timer = this.phaseTimers.get(role);
+    if (timer) {
+      clearInterval(timer);
+      this.phaseTimers.delete(role);
+    }
+  }
+  printProgress() {
+    const total = this.totalStages;
+    const done = this.completedStages;
+    const filled = "#".repeat(done);
+    const empty = "-".repeat(Math.max(0, total - done));
+    console.log(chalk2.dim(`  [${filled}${empty}] ${done}/${total} stages`));
+  }
+  countActiveStages() {
+    const skipStages = this.engine["opts"]?.skipStages || [];
+    return STAGES.filter(
+      (s) => s.stage !== "complete" && !skipStages.includes(s.stage)
+    ).length;
+  }
+};
+
+// src/config/loader.ts
+import { cosmiconfig } from "cosmiconfig";
+
+// src/config/defaults.ts
+var DEFAULT_CONFIG = {
+  maxParallelAgents: 3,
+  claudePath: "claude",
+  workflow: ["plan", "design", "architect", "code", "test", "review", "docs"],
+  skipStages: [],
+  agents: {
+    analyst: { maxTurns: 30 },
+    strategist: { maxTurns: 30 },
+    designer: { maxTurns: 30 },
+    architect: { maxTurns: 50 },
+    builder: { maxTurns: 100 },
+    qa: { maxTurns: 40 },
+    guardian: { maxTurns: 50 },
+    sentinel: { maxTurns: 30 },
+    security: { maxTurns: 30 },
+    scribe: { maxTurns: 30 },
+    devops: { maxTurns: 40 }
+  }
+};
+
+// src/config/loader.ts
+var MODULE_NAME = "krenk";
+async function loadConfig(cwd) {
+  const explorer = cosmiconfig(MODULE_NAME, {
+    searchPlaces: [
+      `.${MODULE_NAME}rc`,
+      `.${MODULE_NAME}rc.json`,
+      `.${MODULE_NAME}rc.yaml`,
+      `.${MODULE_NAME}rc.yml`,
+      `${MODULE_NAME}.config.js`,
+      `${MODULE_NAME}.config.mjs`,
+      "package.json"
+    ]
+  });
+  try {
+    const result = await explorer.search(cwd);
+    if (result && result.config) {
+      return mergeConfig(DEFAULT_CONFIG, result.config);
+    }
+  } catch {
+  }
+  return { ...DEFAULT_CONFIG };
+}
+function mergeConfig(defaults, user) {
+  return {
+    maxParallelAgents: user.maxParallelAgents ?? defaults.maxParallelAgents,
+    claudePath: user.claudePath ?? defaults.claudePath,
+    workflow: user.workflow ?? defaults.workflow,
+    skipStages: user.skipStages ?? defaults.skipStages,
+    agents: {
+      ...defaults.agents,
+      ...user.agents || {}
+    }
+  };
+}
+
+// src/commands/run.ts
+async function runCommand(prompt, options) {
+  const cwd = process.cwd();
+  const config = await loadConfig(cwd);
+  const engine = new OrchestrationEngine({
+    cwd,
+    maxParallel: parseInt(options.parallel || String(config.maxParallelAgents), 10),
+    skipStages: options.skip || config.skipStages,
+    noUi: options.ui === false,
+    supervised: options.supervised || false,
+    agentConfig: config.agents
+  });
+  if (options.ui !== false) {
+    const renderer = new TerminalRenderer(engine);
+    setupGracefulShutdown(engine, () => renderer.cleanup());
+    renderer.printBanner();
+    renderer.printPrompt(prompt);
+    const result = await engine.run(prompt);
+    renderer.printSummary(result);
+    if (!result.success) {
+      process.exit(1);
+    }
+  } else {
+    setupGracefulShutdown(engine);
+    printBannerPlain();
+    console.log(chalk3.dim(`Prompt: ${prompt}
+`));
+    engine.on("stage", (stage) => {
+      console.log(chalk3.bold.cyan(`
+--- ${stage.toUpperCase()} ---
+`));
+    });
+    engine.on("agent:spawned", ({ role, pid }) => {
+      console.log(chalk3.dim(`  Spawned ${role} (PID: ${pid})`));
+    });
+    engine.on("agent:done", ({ role, result: result2 }) => {
+      const status = result2.success ? chalk3.green("done") : chalk3.red("failed");
+      console.log(chalk3.dim(`  ${role} ${status} (${result2.duration}s)`));
+    });
+    const result = await engine.run(prompt);
+    if (result.success) {
+      console.log(
+        chalk3.green(
+          `
+[done] Completed ${result.stages} stages in ${formatDuration(result.duration)}`
+        )
+      );
+    } else {
+      console.error(
+        chalk3.red(`
+[fail] Workflow failed after ${result.stages} stages`)
+      );
+      process.exit(1);
+    }
+  }
+}
+function printBannerPlain() {
+  console.log(chalk3.bold.cyan("\nKRENK"));
+  console.log(chalk3.gray("Multi-Agent Software Engineering Orchestrator"));
+  console.log(chalk3.gray("-".repeat(55)));
+}
+
+// src/commands/plan.ts
+import chalk4 from "chalk";
+async function planCommand(prompt) {
+  const cwd = process.cwd();
+  const config = await loadConfig(cwd);
+  console.log(chalk4.bold.cyan("\n> Planning: ") + prompt + "\n");
+  const engine = new OrchestrationEngine({
+    cwd,
+    maxParallel: 1,
+    skipStages: [],
+    noUi: true,
+    supervised: false,
+    agentConfig: config.agents
+  });
+  setupGracefulShutdown(engine);
+  const result = await engine.runPlanOnly(prompt);
+  if (result.success) {
+    console.log(chalk4.green("\n+ Plan created successfully"));
+    console.log(chalk4.dim(`Duration: ${result.duration}s`));
+    console.log(chalk4.dim(`Saved to: .krenk/strategist.md`));
+    console.log(chalk4.dim("\nRun `krenk build` to execute this plan."));
+  } else {
+    console.error(chalk4.red("\nx Planning failed"));
+    if (result.output) {
+      console.error(chalk4.dim(result.output.substring(0, 500)));
+    }
+    process.exit(1);
+  }
+}
+
+// src/commands/build.ts
+import * as fs3 from "fs";
+import * as path3 from "path";
+import chalk5 from "chalk";
+async function buildCommand() {
+  const cwd = process.cwd();
+  const planFile = path3.join(cwd, ".krenk", "strategist.md");
+  if (!fs3.existsSync(planFile)) {
+    console.error(
+      chalk5.red(
+        'No plan found. Run `krenk plan "your prompt"` first, or use `krenk run "prompt"` for the full pipeline.'
+      )
+    );
+    process.exit(1);
+  }
+  const plan = fs3.readFileSync(planFile, "utf-8");
+  console.log(chalk5.bold.cyan("\n# Building from existing plan...\n"));
+  console.log(chalk5.dim(plan.substring(0, 200) + "...\n"));
+  const config = await loadConfig(cwd);
+  const engine = new OrchestrationEngine({
+    cwd,
+    maxParallel: config.maxParallelAgents,
+    skipStages: ["planning"],
+    // Skip planning since we have the plan
+    noUi: true,
+    supervised: false,
+    agentConfig: config.agents
+  });
+  setupGracefulShutdown(engine);
+  const result = await engine.run(
+    `Execute the following plan:
+
+${plan}`
+  );
+  if (result.success) {
+    console.log(
+      chalk5.green(
+        `
++ Build completed in ${formatDuration(result.duration)}`
+      )
+    );
+  } else {
+    console.error(chalk5.red("\nx Build failed"));
+    process.exit(1);
+  }
+}
+
+// src/commands/test.ts
+import chalk6 from "chalk";
+async function testCommand() {
+  const cwd = process.cwd();
+  const config = await loadConfig(cwd);
+  const role = ROLES.guardian;
+  console.log(
+    chalk6.bold.cyan(
+      `
+${role.emoji} ${role.name} - Generating and running tests...
+`
+    )
+  );
+  const result = await runAgent({
+    role: "guardian",
+    prompt: "Analyze this project, write comprehensive tests (unit + integration), and run them. Report results with PASS/FAIL status.",
+    systemPrompt: role.systemPrompt,
+    cwd,
+    maxTurns: config.agents.guardian?.maxTurns || 50,
+    allowedTools: role.allowedTools
+  });
+  if (result.success) {
+    console.log(chalk6.green(`
++ Testing completed in ${formatDuration(result.duration)}`));
+    console.log(chalk6.dim("\nTest output:"));
+    console.log(result.output.substring(0, 2e3));
+  } else {
+    console.error(chalk6.red(`
+x Testing failed after ${result.duration}s`));
+    if (result.output) {
+      console.error(chalk6.dim(result.output.substring(0, 1e3)));
+    }
+    process.exit(1);
+  }
+}
+
+// src/commands/review.ts
+import chalk7 from "chalk";
+async function reviewCommand() {
+  const cwd = process.cwd();
+  const config = await loadConfig(cwd);
+  const role = ROLES.sentinel;
+  console.log(
+    chalk7.bold.cyan(
+      `
+${role.emoji} ${role.name} - Reviewing code quality...
+`
+    )
+  );
+  const result = await runAgent({
+    role: "sentinel",
+    prompt: "Review all code in this project for bugs, security issues, performance problems, and style inconsistencies. Output a structured review with severity levels.",
+    systemPrompt: role.systemPrompt,
+    cwd,
+    maxTurns: config.agents.sentinel?.maxTurns || 30,
+    allowedTools: role.allowedTools
+  });
+  if (result.success) {
+    console.log(chalk7.green(`
++ Review completed in ${formatDuration(result.duration)}`));
+    console.log(chalk7.dim("\nReview output:"));
+    console.log(result.output.substring(0, 3e3));
+  } else {
+    console.error(chalk7.red(`
+x Review failed after ${result.duration}s`));
+    if (result.output) {
+      console.error(chalk7.dim(result.output.substring(0, 1e3)));
+    }
+    process.exit(1);
+  }
+}
+
+// src/commands/init.ts
+import * as fs4 from "fs";
+import * as path4 from "path";
+import chalk8 from "chalk";
+async function initCommand() {
+  const cwd = process.cwd();
+  const krenkDir = path4.join(cwd, ".krenk");
+  const rcFile = path4.join(cwd, ".krenkrc");
+  console.log(chalk8.bold.cyan("\n> Initializing Krenk...\n"));
+  if (!fs4.existsSync(krenkDir)) {
+    fs4.mkdirSync(krenkDir, { recursive: true });
+    console.log(chalk8.green("  + Created .krenk/ directory"));
+  } else {
+    console.log(chalk8.dim("  - .krenk/ directory already exists"));
+  }
+  const historyDir = path4.join(krenkDir, "history");
+  if (!fs4.existsSync(historyDir)) {
+    fs4.mkdirSync(historyDir, { recursive: true });
+    console.log(chalk8.green("  + Created .krenk/history/ directory"));
+  }
+  if (!fs4.existsSync(rcFile)) {
+    const config = {
+      maxParallelAgents: DEFAULT_CONFIG.maxParallelAgents,
+      claudePath: DEFAULT_CONFIG.claudePath,
+      workflow: DEFAULT_CONFIG.workflow,
+      skipStages: DEFAULT_CONFIG.skipStages,
+      agents: {
+        builder: { maxTurns: 100 },
+        guardian: { maxTurns: 50 }
+      }
+    };
+    fs4.writeFileSync(rcFile, JSON.stringify(config, null, 2) + "\n", "utf-8");
+    console.log(chalk8.green("  + Created .krenkrc config file"));
+  } else {
+    console.log(chalk8.dim("  - .krenkrc already exists"));
+  }
+  const gitignore = path4.join(cwd, ".gitignore");
+  if (fs4.existsSync(gitignore)) {
+    const content = fs4.readFileSync(gitignore, "utf-8");
+    if (!content.includes(".krenk")) {
+      fs4.appendFileSync(gitignore, "\n# Krenk orchestrator\n.krenk/\n");
+      console.log(chalk8.green("  + Added .krenk/ to .gitignore"));
+    }
+  }
+  console.log(chalk8.green('\n[done] Krenk initialized! Run `krenk run "your prompt"` to start.\n'));
+}
+
+// src/commands/status.ts
+import * as fs5 from "fs";
+import * as path5 from "path";
+import chalk9 from "chalk";
+async function statusCommand() {
+  const cwd = process.cwd();
+  const krenkDir = path5.join(cwd, ".krenk");
+  if (!fs5.existsSync(krenkDir)) {
+    console.log(
+      chalk9.yellow(
+        '\nNo .krenk/ directory found. Run `krenk init` or `krenk run "prompt"` first.\n'
+      )
+    );
+    return;
+  }
+  console.log(chalk9.bold.cyan("\n> Krenk Status\n"));
+  const stateFile = path5.join(krenkDir, "state.json");
+  if (fs5.existsSync(stateFile)) {
+    try {
+      const state = JSON.parse(fs5.readFileSync(stateFile, "utf-8"));
+      console.log(chalk9.white("  Last run:"));
+      console.log(chalk9.dim(`    Stage: ${state.stage || "unknown"}`));
+      console.log(chalk9.dim(`    Stages completed: ${state.stageCount || 0}`));
+      if (state.duration) {
+        console.log(chalk9.dim(`    Duration: ${state.duration}s`));
+      }
+      if (state.runId) {
+        console.log(chalk9.dim(`    Run ID: ${state.runId}`));
+      }
+      console.log();
+    } catch {
+      console.log(chalk9.dim("  Could not parse state.json\n"));
+    }
+  }
+  console.log(chalk9.white("  Agent outputs:"));
+  const roleKeys = Object.keys(ROLES);
+  let hasOutputs = false;
+  for (const key of roleKeys) {
+    const file = path5.join(krenkDir, `${key}.md`);
+    if (fs5.existsSync(file)) {
+      const stat = fs5.statSync(file);
+      const size = formatSize(stat.size);
+      const modified = stat.mtime.toLocaleString();
+      const role = ROLES[key];
+      console.log(
+        chalk9.dim(`    ${role.emoji} ${role.name.padEnd(12)} ${size.padEnd(8)} ${modified}`)
+      );
+      hasOutputs = true;
+    }
+  }
+  if (!hasOutputs) {
+    console.log(chalk9.dim("    No agent outputs found"));
+  }
+  const historyDir = path5.join(krenkDir, "history");
+  if (fs5.existsSync(historyDir)) {
+    const runs = fs5.readdirSync(historyDir).filter((d) => {
+      return fs5.statSync(path5.join(historyDir, d)).isDirectory();
+    });
+    if (runs.length > 0) {
+      console.log(chalk9.white(`
+  History: ${runs.length} previous run(s)`));
+      for (const run of runs.slice(-5)) {
+        console.log(chalk9.dim(`    ${run}`));
+      }
+    }
+  }
+  console.log();
+}
+function formatSize(bytes) {
+  if (bytes < 1024) return `${bytes}B`;
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)}KB`;
+  return `${(bytes / (1024 * 1024)).toFixed(1)}MB`;
+}
+
+// src/ui/interactive.ts
+import * as readline from "readline";
+import { spawn as spawnProcess } from "child_process";
+import chalk10 from "chalk";
+import gradient2 from "gradient-string";
+import figlet2 from "figlet";
+import boxen2 from "boxen";
+import ora2 from "ora";
+var TEAM_PRESETS = [
+  {
+    label: "Full Team",
+    description: "All 11 agents - BA, plan, design, arch, code, QA, test, review, security, docs, devops",
+    roles: ["analyst", "strategist", "designer", "architect", "builder", "qa", "guardian", "sentinel", "security", "scribe", "devops"],
+    skipStages: []
+  },
+  {
+    label: "Engineering",
+    description: "Plan, architect, code, test, review",
+    roles: ["strategist", "architect", "builder", "guardian", "sentinel"],
+    skipStages: ["analyzing", "designing", "qa-planning", "securing", "documenting", "deploying"]
+  },
+  {
+    label: "QA Focused",
+    description: "BA, plan, code, QA, test, review -- quality first",
+    roles: ["analyst", "strategist", "builder", "qa", "guardian", "sentinel"],
+    skipStages: ["designing", "architecting", "securing", "documenting", "deploying"]
+  },
+  {
+    label: "Startup MVP",
+    description: "BA, plan, architect, code, review, docs -- ship fast",
+    roles: ["analyst", "strategist", "architect", "builder", "sentinel", "scribe"],
+    skipStages: ["designing", "qa-planning", "testing", "securing", "deploying"]
+  },
+  {
+    label: "Enterprise",
+    description: "BA, plan, design, arch, code, QA, test, security, review, docs, devops",
+    roles: ["analyst", "strategist", "designer", "architect", "builder", "qa", "guardian", "sentinel", "security", "scribe", "devops"],
+    skipStages: []
+  },
+  {
+    label: "Quick Build",
+    description: "Plan and code only -- fastest path",
+    roles: ["strategist", "builder"],
+    skipStages: ["analyzing", "designing", "architecting", "qa-planning", "testing", "reviewing", "securing", "documenting", "deploying"]
+  },
+  {
+    label: "Custom",
+    description: "Pick your agents",
+    roles: [],
+    skipStages: []
+  }
+];
+var ALL_AGENTS = [
+  { key: "analyst", label: "Analyst (BA)", desc: "Business analysis & user stories" },
+  { key: "strategist", label: "Strategist", desc: "Requirements & planning" },
+  { key: "designer", label: "Pixel", desc: "UI/UX design" },
+  { key: "architect", label: "Blueprint", desc: "System architecture" },
+  { key: "builder", label: "Builder", desc: "Code implementation" },
+  { key: "qa", label: "QA Lead", desc: "Test strategy & test plans" },
+  { key: "guardian", label: "Guardian", desc: "Test execution" },
+  { key: "sentinel", label: "Sentinel", desc: "Code review" },
+  { key: "security", label: "Shield", desc: "Security audit" },
+  { key: "scribe", label: "Scribe", desc: "Documentation" },
+  { key: "devops", label: "DevOps", desc: "CI/CD & deployment" }
+];
+function renderMenu(items, selected, multi, checked) {
+  for (let i = 0; i < items.length; i++) {
+    const isSelected = i === selected;
+    const pointer = isSelected ? chalk10.hex(THEME.primary)(">") : " ";
+    const label = isSelected ? chalk10.bold.white(items[i].label.padEnd(14)) : chalk10.white(items[i].label.padEnd(14));
+    const desc = chalk10.dim(items[i].description);
+    let check = "";
+    if (multi && checked) {
+      check = checked.has(i) ? chalk10.hex(THEME.primary)(" [x] ") : chalk10.dim(" [ ] ");
+    }
+    process.stdout.write(`    ${pointer}${check} ${label} ${desc}
+`);
+  }
+}
+function clearMenu(count) {
+  for (let i = 0; i < count; i++) {
+    process.stdout.write("\x1B[1A\x1B[2K");
+  }
+}
+function arrowSelect(items) {
+  return new Promise((resolve) => {
+    let selected = 0;
+    renderMenu(items, selected);
+    const wasRaw = process.stdin.isRaw;
+    if (process.stdin.isTTY) process.stdin.setRawMode(true);
+    process.stdin.resume();
+    const onKey = (key) => {
+      const str = key.toString();
+      if (str === "") {
+        if (process.stdin.isTTY) process.stdin.setRawMode(wasRaw ?? false);
+        process.stdin.pause();
+        process.stdin.removeListener("data", onKey);
+        process.exit(0);
+      }
+      if (str === "\x1B[A" && selected > 0) {
+        selected--;
+        clearMenu(items.length);
+        renderMenu(items, selected);
+      }
+      if (str === "\x1B[B" && selected < items.length - 1) {
+        selected++;
+        clearMenu(items.length);
+        renderMenu(items, selected);
+      }
+      if (str === "\r" || str === "\n") {
+        if (process.stdin.isTTY) process.stdin.setRawMode(wasRaw ?? false);
+        process.stdin.pause();
+        process.stdin.removeListener("data", onKey);
+        clearMenu(items.length);
+        const item = items[selected];
+        console.log(`    ${chalk10.hex(THEME.primary)(">")} ${chalk10.bold.white(item.label)}`);
+        resolve(selected);
+      }
+    };
+    process.stdin.on("data", onKey);
+  });
+}
+function arrowMultiSelect(items) {
+  return new Promise((resolve) => {
+    let selected = 0;
+    const checked = /* @__PURE__ */ new Set();
+    renderMenu(items, selected, true, checked);
+    const wasRaw = process.stdin.isRaw;
+    if (process.stdin.isTTY) process.stdin.setRawMode(true);
+    process.stdin.resume();
+    const onKey = (key) => {
+      const str = key.toString();
+      if (str === "") {
+        if (process.stdin.isTTY) process.stdin.setRawMode(wasRaw ?? false);
+        process.stdin.pause();
+        process.stdin.removeListener("data", onKey);
+        process.exit(0);
+      }
+      if (str === "\x1B[A" && selected > 0) {
+        selected--;
+        clearMenu(items.length);
+        renderMenu(items, selected, true, checked);
+      }
+      if (str === "\x1B[B" && selected < items.length - 1) {
+        selected++;
+        clearMenu(items.length);
+        renderMenu(items, selected, true, checked);
+      }
+      if (str === " ") {
+        if (checked.has(selected)) {
+          checked.delete(selected);
+        } else {
+          checked.add(selected);
+        }
+        clearMenu(items.length);
+        renderMenu(items, selected, true, checked);
+      }
+      if (str === "\r" || str === "\n") {
+        if (process.stdin.isTTY) process.stdin.setRawMode(wasRaw ?? false);
+        process.stdin.pause();
+        process.stdin.removeListener("data", onKey);
+        clearMenu(items.length);
+        const picks = Array.from(checked).sort();
+        if (picks.length > 0) {
+          const names = picks.map((i) => items[i].label).join(", ");
+          console.log(`    ${chalk10.hex(THEME.primary)(">")} ${chalk10.bold.white(names)}`);
+        }
+        resolve(picks);
+      }
+    };
+    process.stdin.on("data", onKey);
+  });
+}
+function ask(rl, question) {
+  return new Promise((resolve) => {
+    rl.question(question, (answer) => resolve(answer.trim()));
+  });
+}
+function printBanner() {
+  console.log("\n\n");
+  const ascii = figlet2.textSync("KRENK", { font: "ANSI Shadow" });
+  console.log(gradient2(THEME.gradient)(ascii));
+  console.log(chalk10.dim("  like claude code, but with a team"));
+  console.log(chalk10.dim("  " + "-".repeat(50)));
+  console.log(chalk10.dim("  built by Krishna with mass amount of \u2615"));
+  console.log();
+}
+function resolveSkipStages(selectedRoles) {
+  const roleToStage = {
+    analyst: "analyzing",
+    strategist: "planning",
+    designer: "designing",
+    architect: "architecting",
+    builder: "coding",
+    qa: "qa-planning",
+    guardian: "testing",
+    sentinel: "reviewing",
+    security: "securing",
+    scribe: "documenting",
+    devops: "deploying"
+  };
+  const skip = [];
+  for (const [role, stage] of Object.entries(roleToStage)) {
+    if (!selectedRoles.includes(role)) {
+      skip.push(stage);
+    }
+  }
+  return skip;
+}
+function detectFollowUps(task) {
+  const lower = task.toLowerCase();
+  const followUps = [];
+  const webKeywords = ["web", "frontend", "ui", "website", "dashboard", "app", "page", "component", "react", "vue", "svelte", "next"];
+  const backendKeywords = ["backend", "api", "server", "rest", "graphql", "endpoint", "microservice"];
+  const dbKeywords = ["database", "db", "data", "store", "crud", "model", "schema", "postgres", "mongo", "sql"];
+  if (webKeywords.some((kw) => lower.includes(kw))) {
+    followUps.push({
+      question: "What framework? (react/vue/svelte/skip) ",
+      key: "framework"
+    });
+  }
+  if (backendKeywords.some((kw) => lower.includes(kw))) {
+    followUps.push({
+      question: "What runtime? (node/python/go/skip) ",
+      key: "runtime"
+    });
+  }
+  if (dbKeywords.some((kw) => lower.includes(kw))) {
+    followUps.push({
+      question: "What database? (postgres/mongo/sqlite/skip) ",
+      key: "database"
+    });
+  }
+  if (followUps.length === 0) {
+    followUps.push({
+      question: "Any tech stack or constraints? (press enter to skip) ",
+      key: "constraints"
+    });
+  }
+  return followUps.slice(0, 2);
+}
+async function refinePromptWithClaude(rawTask, answers, roles, spinner) {
+  const agentNames = roles.map((r) => ROLES[r]?.name || r);
+  let answerContext = "";
+  if (answers.framework) answerContext += `
+Framework: ${answers.framework}`;
+  if (answers.runtime) answerContext += `
+Runtime: ${answers.runtime}`;
+  if (answers.database) answerContext += `
+Database: ${answers.database}`;
+  if (answers.constraints) answerContext += `
+Constraints: ${answers.constraints}`;
+  const refinementPrompt = `You are a prompt refinement assistant. Take the user's raw input and produce a clean, structured project prompt.
+
+Raw user input: "${rawTask}"
+${answerContext ? `
+User preferences:${answerContext}` : ""}
+Team: ${agentNames.join(", ")}
+
+Respond ONLY with valid JSON (no markdown, no code fences, no explanation) in this exact format:
+{
+  "title": "A clear, concise 1-sentence project description",
+  "requirements": ["requirement 1", "requirement 2", ...],
+  "techStack": ["tech1", "tech2", ...],
+  "fullPrompt": "The complete, well-structured prompt for the engineering team to execute. Include the title, all requirements, tech stack, and any constraints. Be specific and actionable."
+}
+
+Rules:
+- title: Clean up the raw input into a professional project description
+- requirements: Extract implicit AND explicit requirements (auth, responsive, real-time, etc). Include 3-8 requirements.
+- techStack: Infer technologies from context, user answers, and task. If unclear, suggest sensible defaults.
+- fullPrompt: This is what the engineering team will actually read. Make it detailed, actionable, and clear. Include all context.`;
+  try {
+    const env = { ...process.env };
+    delete env.CLAUDECODE;
+    delete env.CLAUDE_CODE_ENTRYPOINT;
+    const output = await new Promise((resolve, reject) => {
+      const phases = [
+        "Understanding your request...",
+        "Extracting requirements...",
+        "Identifying tech stack...",
+        "Structuring the prompt...",
+        "Finalizing..."
+      ];
+      let phaseIdx = 0;
+      const phaseTimer = setInterval(() => {
+        phaseIdx++;
+        if (spinner && phaseIdx < phases.length) {
+          spinner.text = phases[phaseIdx];
+        }
+      }, 3e3);
+      const child = spawnProcess("claude", [
+        "-p",
+        refinementPrompt,
+        "--output-format",
+        "stream-json",
+        "--verbose",
+        "--max-turns",
+        "1",
+        "--dangerously-skip-permissions"
+      ], {
+        env,
+        cwd: process.cwd(),
+        stdio: ["ignore", "pipe", "pipe"]
+      });
+      let stdout = "";
+      let stderr = "";
+      let lineBuffer = "";
+      child.stdout.on("data", (chunk) => {
+        const text = chunk.toString();
+        stdout += text;
+        lineBuffer += text;
+        const lines = lineBuffer.split("\n");
+        lineBuffer = lines.pop() || "";
+        for (const line of lines) {
+          const trimmed = line.trim();
+          if (!trimmed) continue;
+          if (spinner && phaseIdx < phases.length) {
+            spinner.text = phases[phaseIdx];
+            phaseIdx++;
+          }
+        }
+      });
+      child.stderr.on("data", (chunk) => {
+        stderr += chunk.toString();
+      });
+      const timeout = setTimeout(() => {
+        clearInterval(phaseTimer);
+        child.kill("SIGTERM");
+        reject(new Error("timeout"));
+      }, 6e4);
+      child.on("close", (code) => {
+        clearInterval(phaseTimer);
+        clearTimeout(timeout);
+        if (code === 0 && stdout.trim()) {
+          resolve(stdout);
+        } else {
+          reject(new Error(`exit ${code}: ${stderr.slice(0, 200)}`));
+        }
+      });
+      child.on("error", (err) => {
+        clearInterval(phaseTimer);
+        clearTimeout(timeout);
+        reject(err);
+      });
+    });
+    let responseText = "";
+    const outputLines = output.trim().split("\n");
+    for (let i = outputLines.length - 1; i >= 0; i--) {
+      try {
+        const event = JSON.parse(outputLines[i]);
+        if (event.type === "result" && event.result) {
+          responseText = event.result;
+          break;
+        }
+      } catch {
+      }
+    }
+    if (!responseText) {
+      try {
+        const wrapper = JSON.parse(output.trim());
+        if (wrapper.result) responseText = wrapper.result;
+        else responseText = output.trim();
+      } catch {
+        responseText = output.trim();
+      }
+    }
+    responseText = responseText.replace(/^```json\s*/i, "").replace(/^```\s*/i, "").replace(/\s*```$/i, "").trim();
+    const parsed = JSON.parse(responseText);
+    return {
+      title: parsed.title || rawTask,
+      requirements: Array.isArray(parsed.requirements) ? parsed.requirements : [],
+      techStack: Array.isArray(parsed.techStack) ? parsed.techStack : [],
+      fullPrompt: parsed.fullPrompt || rawTask
+    };
+  } catch {
+    return refinePromptLocal(rawTask, answers, roles);
+  }
+}
+function refinePromptLocal(rawTask, answers, roles) {
+  let title = rawTask.trim();
+  title = title.charAt(0).toUpperCase() + title.slice(1);
+  if (!title.endsWith(".") && !title.endsWith("!") && !title.endsWith("?")) {
+    title += ".";
+  }
+  const requirements = [];
+  const lower = rawTask.toLowerCase();
+  if (lower.includes("auth") || lower.includes("login")) requirements.push("User authentication");
+  if (lower.includes("responsive") || lower.includes("mobile")) requirements.push("Responsive design");
+  if (lower.includes("realtime") || lower.includes("real-time")) requirements.push("Real-time updates");
+  if (lower.includes("deploy") || lower.includes("production")) requirements.push("Production-ready");
+  if (lower.includes("test")) requirements.push("Test coverage");
+  const techStack = [];
+  if (answers.framework) techStack.push(answers.framework);
+  if (answers.runtime) techStack.push(answers.runtime);
+  if (answers.database) techStack.push(answers.database);
+  if (answers.constraints) {
+    const c = answers.constraints.toLowerCase();
+    const knownTech = ["react", "vue", "svelte", "angular", "next", "nuxt", "node", "express", "python", "django", "flask", "go", "rust", "postgres", "mongodb", "sqlite", "redis", "tailwind", "typescript"];
+    for (const tech of knownTech) {
+      if (c.includes(tech) && !techStack.some((t) => t.toLowerCase().includes(tech))) {
+        techStack.push(tech.charAt(0).toUpperCase() + tech.slice(1));
+      }
+    }
+    if (techStack.length === 0) {
+      techStack.push(answers.constraints);
+    }
+  }
+  if (lower.includes("drag") && lower.includes("drop")) requirements.push("Drag and drop functionality");
+  if (lower.includes("todo") || lower.includes("task")) requirements.push("Task management");
+  if (lower.includes("column") || lower.includes("kanban") || lower.includes("board")) requirements.push("Column/board layout");
+  if (lower.includes("status")) requirements.push("Status tracking");
+  const agentNames = roles.map((r) => ROLES[r]?.name || r);
+  let fullPrompt = title;
+  if (requirements.length > 0) {
+    fullPrompt += "\n\nRequirements:\n" + requirements.map((r) => `- ${r}`).join("\n");
+  }
+  if (techStack.length > 0) {
+    fullPrompt += "\n\nTech stack: " + techStack.join(", ") + ".";
+  }
+  fullPrompt += `
+
+Team: ${agentNames.join(", ")}.`;
+  return { title, requirements, techStack, fullPrompt };
+}
+async function startInteractiveSession() {
+  printBanner();
+  console.log(chalk10.bold.white("  Select your team:"));
+  console.log(chalk10.dim("  (use arrow keys, press enter to select)\n"));
+  const teamItems = TEAM_PRESETS.map((p) => ({
+    label: p.label,
+    description: p.description
+  }));
+  const teamIndex = await arrowSelect(teamItems);
+  let skipStages;
+  let selectedRoles;
+  if (teamIndex < TEAM_PRESETS.length - 1) {
+    const preset = TEAM_PRESETS[teamIndex];
+    skipStages = preset.skipStages;
+    selectedRoles = preset.roles;
+  } else {
+    console.log(chalk10.bold.white("\n  Pick your agents:"));
+    console.log(chalk10.dim("  (space to toggle, enter to confirm)\n"));
+    const agentItems = ALL_AGENTS.map((a) => ({
+      label: a.label,
+      description: a.desc
+    }));
+    const picks = await arrowMultiSelect(agentItems);
+    if (picks.length === 0) {
+      selectedRoles = TEAM_PRESETS[0].roles;
+      skipStages = [];
+      console.log(chalk10.dim("\n  No selection, using Full Team"));
+    } else {
+      selectedRoles = picks.map((i) => ALL_AGENTS[i].key);
+      if (!selectedRoles.includes("strategist")) selectedRoles.unshift("strategist");
+      if (!selectedRoles.includes("builder")) selectedRoles.push("builder");
+      skipStages = resolveSkipStages(selectedRoles);
+    }
+  }
+  console.log(chalk10.bold.white("\n  Run mode:"));
+  console.log(chalk10.dim("  (use arrow keys, press enter to select)\n"));
+  const modeItems = [
+    { label: "Autonomous", description: "Agents run without asking -- fastest" },
+    { label: "Supervised", description: "Approve each agent before it runs -- you stay in control" }
+  ];
+  const modeIndex = await arrowSelect(modeItems);
+  const supervised = modeIndex === 1;
+  console.log();
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+  const task = await ask(rl, chalk10.bold.white("  What do you want to build? ") + chalk10.hex(THEME.primary)("> "));
+  if (!task) {
+    console.log(chalk10.dim("\n  No task provided. Exiting.\n"));
+    rl.close();
+    return;
+  }
+  const followUps = detectFollowUps(task);
+  const answers = {};
+  console.log();
+  for (const fu of followUps) {
+    const answer = await ask(rl, chalk10.dim("  ") + chalk10.white(fu.question));
+    if (answer && answer.toLowerCase() !== "skip") {
+      answers[fu.key] = answer;
+    }
+  }
+  rl.close();
+  console.log();
+  const refineSpinner = ora2({
+    text: "Understanding your request...",
+    prefixText: "  ",
+    spinner: "dots"
+  }).start();
+  const refined = await refinePromptWithClaude(task, answers, selectedRoles, refineSpinner);
+  refineSpinner.succeed("Prompt refined");
+  console.log();
+  const teamNames = selectedRoles.map((r) => ROLES[r]?.name || r).join(", ");
+  const lines = [];
+  lines.push(chalk10.bold.hex(THEME.primary)("  Refined Prompt"));
+  lines.push("");
+  lines.push(chalk10.white(`  ${refined.title}`));
+  lines.push("");
+  if (refined.requirements.length > 0) {
+    lines.push(chalk10.dim("  Requirements:"));
+    for (const req of refined.requirements) {
+      lines.push(chalk10.dim(`    - ${req}`));
+    }
+    lines.push("");
+  }
+  if (refined.techStack.length > 0) {
+    lines.push(chalk10.dim("  Tech Stack:"));
+    lines.push(chalk10.dim(`    ${refined.techStack.join(" + ")}`));
+    lines.push("");
+  }
+  lines.push(chalk10.dim(`  Team: ${teamNames}`));
+  lines.push(chalk10.dim(`  Mode: ${supervised ? "Supervised" : "Autonomous"}`));
+  const panel = boxen2(lines.join("\n"), {
+    padding: 1,
+    margin: { top: 0, bottom: 0, left: 1, right: 1 },
+    borderStyle: "round",
+    borderColor: "#7C3AED"
+  });
+  console.log(panel);
+  console.log();
+  const cwd = process.cwd();
+  const config = await loadConfig(cwd);
+  const engine = new OrchestrationEngine({
+    cwd,
+    maxParallel: config.maxParallelAgents,
+    skipStages,
+    noUi: false,
+    supervised,
+    agentConfig: config.agents
+  });
+  const renderer = new TerminalRenderer(engine);
+  setupGracefulShutdown(engine, () => renderer.cleanup());
+  const result = await engine.run(refined.fullPrompt);
+  renderer.printSummary(result);
+  if (!result.success) {
+    process.exit(1);
+  }
+}
+
+// src/index.ts
+program.name("krenk").description(
+  "Multi-agent software engineering orchestrator powered by Claude Code"
+).version("0.1.0").action(async () => {
+  await startInteractiveSession();
+});
+program.command("run").description("Run full engineering workflow with all agents").argument("<prompt>", "What to build").option("--skip <stages...>", "Skip specific stages (e.g. --skip design test)").option("--parallel <n>", "Max parallel agents", "3").option("--no-ui", "Disable fancy UI, use plain output").option("--supervised", "Approve each agent before it runs").action(runCommand);
+program.command("plan").description("Run only the planning stage").argument("<prompt>", "What to plan").action(planCommand);
+program.command("build").description("Execute from an existing plan in .krenk/strategist.md").action(buildCommand);
+program.command("test").description("Generate and run tests for the current project").action(testCommand);
+program.command("review").description("Run code review on the current project").action(reviewCommand);
+program.command("init").description("Initialize Krenk in the current directory").action(initCommand);
+program.command("status").description("Show the current Krenk state and last run info").action(statusCommand);
+program.parse();
+//# sourceMappingURL=index.js.map