workermill 0.3.1 → 0.3.3

package/dist/{orchestrator-2M4BCHQR.js → orchestrator-VRGIOUHT.js}

@@ -5,23 +5,24 @@ import {
   createModel,
   createToolDefinitions,
   getProviderForPersona,
-  info
-} from "./chunk-NGQKIYVB.js";
+  init_esm_shims
+} from "./chunk-KL7SFKGG.js";
 
-// src/orchestrator.js
-import chalk3 from "chalk";
-import ora from "ora";
+// src/orchestrator.ts
+init_esm_shims();
 import { streamText, generateObject, generateText, stepCountIs } from "ai";
 import { z } from "zod";
+import fs2 from "fs";
+import path2 from "path";
 
-// src/personas.js
+// src/personas.ts
+init_esm_shims();
 import fs from "fs";
 import path from "path";
 import os from "os";
 function parsePersonaFile(content) {
   const match = content.match(/^---\n([\s\S]*?)\n---\n([\s\S]*)$/);
-  if (!match)
-    return null;
+  if (!match) return null;
   const frontmatter = match[1];
   const body = match[2].trim();
   const meta = {};
@@ -36,8 +37,7 @@ function parsePersonaFile(content) {
       meta[key] = value;
     }
   }
-  if (!meta.name || !meta.slug)
-    return null;
+  if (!meta.name || !meta.slug) return null;
   return {
     name: meta.name,
     slug: meta.slug,
@@ -65,8 +65,7 @@ function loadPersona(slug) {
       if (fs.existsSync(loc)) {
         const content = fs.readFileSync(loc, "utf-8");
         const persona = parsePersonaFile(content);
-        if (persona)
-          return persona;
+        if (persona) return persona;
       }
     } catch {
       continue;
@@ -81,234 +80,21 @@ function loadPersona(slug) {
   };
 }
 
-// src/permissions.js
-import readline from "readline";
-import chalk from "chalk";
-var READ_TOOLS = /* @__PURE__ */ new Set(["read_file", "glob", "grep", "ls", "sub_agent"]);
-var DANGEROUS_PATTERNS = [
-  { pattern: /rm\s+(-[a-z]*f|-[a-z]*r|--force|--recursive)/i, label: "recursive/forced delete" },
-  { pattern: /git\s+reset\s+--hard/i, label: "hard reset" },
-  { pattern: /git\s+push\s+.*--force/i, label: "force push" },
-  { pattern: /git\s+clean\s+-[a-z]*f/i, label: "git clean" },
-  { pattern: /drop\s+table/i, label: "drop table" },
-  { pattern: /truncate\s+/i, label: "truncate" },
-  { pattern: /DELETE\s+FROM\s+\w+\s*;/i, label: "DELETE without WHERE" },
-  { pattern: /chmod\s+777/i, label: "chmod 777" },
-  { pattern: />(\/dev\/sda|\/dev\/disk)/i, label: "write to disk device" }
-];
-function isDangerous(command) {
-  for (const { pattern, label } of DANGEROUS_PATTERNS) {
-    if (pattern.test(command))
-      return label;
-  }
-  return null;
-}
-var PermissionManager = class {
-  sessionAllow = /* @__PURE__ */ new Set();
-  trustAll;
-  configTrust;
-  rl = null;
-  cancelCurrentPrompt = null;
-  /** True while rl.question() is active — external line handlers must ignore input */
-  questionActive = false;
-  constructor(trustAll = false, configTrust = []) {
-    this.trustAll = trustAll;
-    this.configTrust = new Set(configTrust);
-  }
-  /** Bind to the agent's readline instance so we reuse it for prompts */
-  setReadline(rl) {
-    this.rl = rl;
-  }
-  cancelPrompt() {
-    if (this.cancelCurrentPrompt) {
-      this.cancelCurrentPrompt();
-      this.cancelCurrentPrompt = null;
-    }
-  }
-  async checkPermission(toolName, toolInput) {
-    if (toolName === "bash") {
-      const cmd = String(toolInput.command || "");
-      const danger = isDangerous(cmd);
-      if (danger) {
-        if (this.trustAll)
-          return true;
-        console.log();
-        console.log(chalk.red.bold(`  \u26A0 DANGEROUS: ${danger}`));
-        console.log(chalk.red(`  Command: ${cmd}`));
-        const answer = await this.askUser(chalk.red("  Are you sure? (yes to confirm): "));
-        if (answer.trim().toLowerCase() !== "yes")
-          return false;
-        return true;
-      }
-    }
-    if (this.trustAll)
-      return true;
-    if (READ_TOOLS.has(toolName))
-      return true;
-    if (this.sessionAllow.has(toolName))
-      return true;
-    if (this.configTrust.has(toolName))
-      return true;
-    return this.promptUser(toolName, toolInput);
-  }
-  async promptUser(toolName, toolInput) {
-    const display = this.formatToolCall(toolName, toolInput);
-    console.log();
-    console.log(chalk.cyan(`  \u250C\u2500 ${toolName} ${"\u2500".repeat(Math.max(0, 40 - toolName.length))}\u2510`));
-    for (const line of display.split("\n")) {
-      console.log(chalk.cyan("  \u2502 ") + chalk.white(line));
-    }
-    console.log(chalk.cyan(`  \u2514${"\u2500".repeat(43)}\u2518`));
-    const answer = await this.askUser(chalk.dim("  Allow? ") + chalk.white("(y)es / (n)o / (a)lways this tool / (t)rust all: "));
-    const choice = answer.trim().toLowerCase();
-    if (choice === "t" || choice === "trust") {
-      this.trustAll = true;
-      return true;
-    }
-    if (choice === "a" || choice === "always") {
-      this.sessionAllow.add(toolName);
-      return true;
-    }
-    return choice === "y" || choice === "yes";
-  }
-  /**
-   * Prompt the user with a question. Sets questionActive flag so the
-   * agent's line handler knows to ignore this input.
-   */
-  askUser(prompt) {
-    return new Promise((resolve, reject) => {
-      this.cancelCurrentPrompt = () => {
-        this.questionActive = false;
-        reject(new Error("cancelled"));
-      };
-      if (this.rl) {
-        this.questionActive = true;
-        this.rl.resume();
-        this.rl.question(prompt, (answer) => {
-          this.questionActive = false;
-          this.cancelCurrentPrompt = null;
-          this.rl.pause();
-          resolve(answer);
-        });
-      } else {
-        const questionRl = readline.createInterface({
-          input: process.stdin,
-          output: process.stdout
-        });
-        this.questionActive = true;
-        questionRl.question(prompt, (answer) => {
-          this.questionActive = false;
-          this.cancelCurrentPrompt = null;
-          questionRl.close();
-          resolve(answer);
-        });
-      }
-    });
-  }
-  formatToolCall(toolName, input) {
-    switch (toolName) {
-      case "bash":
-        return String(input.command || "");
-      case "write_file":
-      case "edit_file":
-        return `${input.path || ""}`;
-      case "patch":
-        return String(input.patch_text || "").slice(0, 200) + "...";
-      case "fetch":
-        return String(input.url || "");
-      default:
-        return JSON.stringify(input, null, 2).slice(0, 200);
-    }
-  }
-};
+// src/orchestrator.ts
+function resolveTaskInput(task, workingDir) {
+  const trimmed = task.trim();
+  if (!trimmed.includes(" ") && /\.\w{1,10}$/.test(trimmed)) {
+    const fullPath = path2.resolve(workingDir, trimmed);
+    try {
+      const content = fs2.readFileSync(fullPath, "utf-8");
+      return `Implement the following specification from ${trimmed}:
 
-// src/tui.js
-import chalk2 from "chalk";
-import { execSync } from "child_process";
-function formatToolCall(toolName, toolInput) {
-  let msg = `Tool: ${toolName}`;
-  if (toolInput) {
-    if (toolInput.file_path)
-      msg += ` \u2192 ${toolInput.file_path}`;
-    else if (toolInput.path)
-      msg += ` \u2192 ${toolInput.path}`;
-    else if (toolInput.command)
-      msg += ` \u2192 ${String(toolInput.command).substring(0, 500)}`;
-    else if (toolInput.pattern)
-      msg += ` \u2192 pattern: ${toolInput.pattern}`;
-    else {
-      const keys = Object.keys(toolInput).slice(0, 3);
-      if (keys.length > 0) {
-        msg += ` \u2192 ${keys.map((k) => `${k}: ${String(toolInput[k]).substring(0, 200)}`).join(", ")}`;
-      }
+${content}`;
+    } catch {
     }
   }
-  return msg;
-}
-var PERSONA_EMOJIS = {
-  frontend_developer: "\u{1F3A8}",
-  // 🎨
-  backend_developer: "\u{1F4BB}",
-  // 💻
-  fullstack_developer: "\u{1F4BB}",
-  // 💻 (same as backend)
-  devops_engineer: "\u{1F527}",
-  // 🔧
-  security_engineer: "\u{1F512}",
-  // 🔐
-  qa_engineer: "\u{1F9EA}",
-  // 🧪
-  tech_writer: "\u{1F4DD}",
-  // 📝
-  project_manager: "\u{1F4CB}",
-  // 📋
-  architect: "\u{1F3D7}\uFE0F",
-  // 🏗️
-  database_engineer: "\u{1F4CA}",
-  // 📊
-  data_engineer: "\u{1F4CA}",
-  // 📊
-  data_ml_engineer: "\u{1F4CA}",
-  // 📊
-  ml_engineer: "\u{1F4CA}",
-  // 📊
-  mobile_developer: "\u{1F4F1}",
-  // 📱
-  tech_lead: "\u{1F451}",
-  // 👑
-  manager: "\u{1F454}",
-  // 👔
-  support_agent: "\u{1F4AC}",
-  // 💬
-  planner: "\u{1F4A1}",
-  // 💡 (planning_agent)
-  coordinator: "\u{1F3AF}",
-  // 🎯
-  critic: "\u{1F50D}",
-  // 🔍
-  reviewer: "\u{1F50D}"
-  // 🔍
-};
-function getPersonaEmoji(persona) {
-  return PERSONA_EMOJIS[persona] || "\u{1F916}";
-}
-function wmLog(persona, message) {
-  const emoji = getPersonaEmoji(persona);
-  console.log(chalk2.cyan(`[${emoji} ${persona} \u{1F3E0}] `) + chalk2.white(message));
-  info(`[${persona}] ${message}`);
-}
-function wmCoordinatorLog(message) {
-  console.log(chalk2.cyan("[coordinator] ") + chalk2.white(message));
-  info(`[coordinator] ${message}`);
+  return task;
 }
-function printError(message) {
-  console.log(chalk2.red(`
-  \u2717 ${message}
-`));
-}
-var sessionStartTime = Date.now();
-
-// src/orchestrator.js
 var LEARNING_INSTRUCTIONS = `
 
 ## Reporting Learnings
@@ -368,21 +154,77 @@ function buildReasoningOptions(provider, modelName) {
   }
 }
 function isTransientError(error) {
-  if (!error || typeof error !== "object")
-    return false;
+  if (!error || typeof error !== "object") return false;
   const msg = error instanceof Error ? error.message : String(error);
   if (/status code (502|503|504)|socket hang up|ECONNRESET|ETIMEDOUT|network error|ECONNREFUSED/i.test(msg)) {
     return true;
   }
   return false;
 }
-async function classifyComplexity(config, userInput) {
+var READ_TOOLS = /* @__PURE__ */ new Set(["read_file", "glob", "grep", "ls", "sub_agent"]);
+var DANGEROUS_PATTERNS = [
+  { pattern: /rm\s+(-[a-z]*f|-[a-z]*r|--force|--recursive)/i, label: "recursive/forced delete" },
+  { pattern: /git\s+reset\s+--hard/i, label: "hard reset" },
+  { pattern: /git\s+push\s+.*--force/i, label: "force push" },
+  { pattern: /git\s+clean\s+-[a-z]*f/i, label: "git clean" },
+  { pattern: /drop\s+table/i, label: "drop table" },
+  { pattern: /truncate\s+/i, label: "truncate" },
+  { pattern: /DELETE\s+FROM\s+\w+\s*;/i, label: "DELETE without WHERE" },
+  { pattern: /chmod\s+777/i, label: "chmod 777" },
+  { pattern: />(\/dev\/sda|\/dev\/disk)/i, label: "write to disk device" }
+];
+function isDangerous(command) {
+  for (const { pattern, label } of DANGEROUS_PATTERNS) {
+    if (pattern.test(command)) return label;
+  }
+  return null;
+}
+async function checkToolPermission(toolName, toolInput, trustAll, sessionAllow, output) {
+  if (toolName === "bash") {
+    const cmd = String(toolInput.command || "");
+    const danger = isDangerous(cmd);
+    if (danger) {
+      if (trustAll) return true;
+      output.error(`DANGEROUS: ${danger}`);
+      output.error(`Command: ${cmd}`);
+      const confirmed2 = await output.confirm("This is a dangerous operation. Are you sure?");
+      return confirmed2;
+    }
+  }
+  if (trustAll) return true;
+  if (READ_TOOLS.has(toolName)) return true;
+  if (sessionAllow.has(toolName)) return true;
+  const display = formatToolCallDisplay(toolName, toolInput);
+  output.log("system", `Tool: ${toolName} -- ${display}`);
+  const confirmed = await output.confirm(`Allow ${toolName}?`);
+  if (confirmed) {
+    sessionAllow.add(toolName);
+  }
+  return confirmed;
+}
+function formatToolCallDisplay(toolName, toolInput) {
+  let msg = `Tool: ${toolName}`;
+  if (toolInput) {
+    if (toolInput.file_path) msg += ` -> ${toolInput.file_path}`;
+    else if (toolInput.path) msg += ` -> ${toolInput.path}`;
+    else if (toolInput.command) msg += ` -> ${String(toolInput.command).substring(0, 500)}`;
+    else if (toolInput.pattern) msg += ` -> pattern: ${toolInput.pattern}`;
+    else {
+      const keys = Object.keys(toolInput).slice(0, 3);
+      if (keys.length > 0) {
+        msg += ` -> ${keys.map((k) => `${k}: ${String(toolInput[k]).substring(0, 200)}`).join(", ")}`;
+      }
+    }
+  }
+  return msg;
+}
+async function classifyComplexity(config, userInput, output) {
+  const resolvedInput = resolveTaskInput(userInput, process.cwd());
   const { provider, model: modelName, apiKey, host, contextLength } = getProviderForPersona(config);
   if (apiKey) {
-    const envMap = { anthropic: "ANTHROPIC_API_KEY", openai: "OPENAI_API_KEY", google: "GOOGLE_API_KEY" };
+    const envMap = { anthropic: "ANTHROPIC_API_KEY", openai: "OPENAI_API_KEY", google: "GOOGLE_GENERATIVE_AI_API_KEY" };
     const envVar = envMap[provider];
-    if (envVar && !process.env[envVar])
-      process.env[envVar] = apiKey;
+    if (envVar && !process.env[envVar]) process.env[envVar] = apiKey;
   }
   const model = createModel(provider, modelName, host, contextLength);
   try {
@@ -395,7 +237,7 @@ async function classifyComplexity(config, userInput) {
       prompt: `Analyze this coding task. If it involves multiple distinct concerns that would benefit from different specialist personas (e.g., database + backend + frontend + devops), classify as "multi". If it's a focused task that one developer could handle, classify as "single". Just classify \u2014 do not break down into stories.
 
 Task:
-${userInput}`
+${resolvedInput}`
     });
     return {
       isMulti: result.object.complexity === "multi",
@@ -407,7 +249,7 @@ ${userInput}`
         model,
         prompt: `Is this task "single" (one developer) or "multi" (needs multiple specialists)? Respond with just "single" or "multi" and a brief reason.
 
-Task: ${userInput}`
+Task: ${resolvedInput}`
       });
       const isMulti = /\bmulti\b/i.test(textResult.text);
       return { isMulti, reason: textResult.text.slice(0, 200) };
@@ -422,42 +264,37 @@ function topologicalSort(stories) {
   const result = [];
   const visiting = /* @__PURE__ */ new Set();
   function visit(id) {
-    if (visited.has(id))
-      return;
+    if (visited.has(id)) return;
     if (visiting.has(id)) {
-      console.log(chalk3.yellow(`  \u26A0 Circular dependency at ${id}, using input order`));
       return;
     }
     visiting.add(id);
     const story = idMap.get(id);
     if (story?.dependsOn) {
       for (const dep of story.dependsOn) {
-        if (idMap.has(dep))
-          visit(dep);
+        if (idMap.has(dep)) visit(dep);
       }
     }
     visiting.delete(id);
     visited.add(id);
-    if (story)
-      result.push(story);
+    if (story) result.push(story);
   }
   for (const story of stories) {
     visit(story.id);
   }
   return result;
 }
-async function planStories(config, userTask, workingDir, sandboxed = true) {
+async function planStories(config, userTask, workingDir, sandboxed, output) {
   const planner = loadPersona("planner");
   const { provider: pProvider, model: pModel, host: pHost, contextLength: pCtx } = getProviderForPersona(config, "planner");
   if (pProvider) {
     const pApiKey = config.providers[pProvider]?.apiKey;
     if (pApiKey) {
-      const envMap = { anthropic: "ANTHROPIC_API_KEY", openai: "OPENAI_API_KEY", google: "GOOGLE_API_KEY" };
+      const envMap = { anthropic: "ANTHROPIC_API_KEY", openai: "OPENAI_API_KEY", google: "GOOGLE_GENERATIVE_AI_API_KEY" };
       const envVar = envMap[pProvider];
       if (envVar && !process.env[envVar]) {
         const key = pApiKey.startsWith("{env:") ? process.env[pApiKey.slice(5, -1)] : pApiKey;
-        if (key)
-          process.env[envVar] = key;
+        if (key) process.env[envVar] = key;
       }
     }
   }
@@ -471,7 +308,7 @@ async function planStories(config, userTask, workingDir, sandboxed = true) {
         readOnlyTools[toolName] = {
           ...toolDef,
           execute: async (input) => {
-            wmLog("planner", formatToolCall(toolName, input));
+            output.toolCall("planner", toolName, input);
             const result = await toolDef.execute(input);
             return result;
           }
@@ -479,16 +316,39 @@ async function planStories(config, userTask, workingDir, sandboxed = true) {
       }
     }
   }
+  const fileRefPattern = /(?:^|\s)([\w./-]+\.(?:md|txt|yaml|yml|json|toml|ts|js|py|go|rs|spec|requirements|prd|plan))\b/gi;
+  const referencedFiles = [...new Set([...userTask.matchAll(fileRefPattern)].map((m) => m[1]))];
+  let inlinedFileContext = "";
+  if (referencedFiles.length > 0) {
+    const fs3 = await import("fs");
+    const path3 = await import("path");
+    for (const ref of referencedFiles) {
+      const fullPath = path3.default.resolve(workingDir, ref);
+      try {
+        const content = fs3.default.readFileSync(fullPath, "utf-8");
+        inlinedFileContext += `
+### File: ${ref}
+\`\`\`
+${content}
+\`\`\`
+`;
+        output.log("planner", `Read referenced file: ${ref}`);
+      } catch {
+      }
+    }
+  }
   const plannerPrompt = `You are an expert implementation planner. Analyze this task and create a high-quality implementation plan.
 
 ## Task
 ${userTask}
-
+${inlinedFileContext ? `
+## Referenced Files
+${inlinedFileContext}` : ""}
 ## Working directory
 ${workingDir}
 
 ## Instructions
-1. Use your tools to explore the working directory and understand what exists. Stay within the working directory.
+1. Use your tools to explore the working directory and understand what exists. Stay within the working directory.${referencedFiles.length > 0 ? "\n   The referenced files above have been inlined for you. Read any additional files you need for context." : ""}
 2. Design a plan that breaks the task into focused stories, each assigned to a specialist persona.
 3. Each story should be a meaningful unit of work \u2014 not too granular, not too broad.
 4. Quality criteria:
@@ -514,8 +374,8 @@ Return ONLY a JSON code block with this structure:
 \`\`\`
 
 Available personas: backend_developer, frontend_developer, devops_engineer, qa_engineer, security_engineer, data_ml_engineer, mobile_developer, tech_writer, tech_lead`;
-  wmLog("planner", `Starting planning agent using ${pModel}`);
-  wmLog("planner", "Reading repository structure...");
+  output.log("planner", `Starting planning agent using ${pModel}`);
+  output.log("planner", "Reading repository structure...");
   let planText = "";
   const planStream = streamText({
     model: plannerModel,
@@ -529,9 +389,8 @@ Available personas: backend_developer, frontend_developer, devops_engineer, qa_e
       if (text) {
         const lines = text.split("\n").filter((l) => l.trim());
         for (const line of lines) {
-          if (line.trim().startsWith("{") || line.trim().startsWith("}") || line.trim().startsWith('"') || line.trim().startsWith("[") || line.trim().startsWith("]") || line.includes("```"))
-            continue;
-          wmLog("planner", line);
+          if (line.trim().startsWith("{") || line.trim().startsWith("}") || line.trim().startsWith('"') || line.trim().startsWith("[") || line.trim().startsWith("]") || line.includes("```")) continue;
+          output.log("planner", line);
         }
       }
     }
@@ -542,9 +401,10 @@ Available personas: backend_developer, frontend_developer, devops_engineer, qa_e
   if (finalText && finalText.length > planText.length) {
     planText = finalText;
   }
-  let stories = parseStoriesFromText(planText);
+  const planUsage = await planStream.totalUsage;
+  let stories = parseStoriesFromText(planText, output);
   if (stories.length === 0) {
-    console.log(chalk3.yellow("  \u26A0 Planner didn't produce structured stories, falling back to single story"));
+    output.log("system", "Planner didn't produce structured stories, falling back to single story");
     stories = [{
       id: "implement",
       title: userTask.slice(0, 60),
@@ -552,14 +412,19 @@ Available personas: backend_developer, frontend_developer, devops_engineer, qa_e
       description: userTask
     }];
   }
-  return stories;
+  return {
+    stories,
+    provider: pProvider,
+    model: pModel,
+    inputTokens: planUsage?.inputTokens || 0,
+    outputTokens: planUsage?.outputTokens || 0
+  };
 }
-function parseStoriesFromText(text) {
+function parseStoriesFromText(text, output) {
   const codeBlocks = [...text.matchAll(/```(?:json)?\s*\n?([\s\S]*?)```/g)];
   for (const match of codeBlocks) {
     const stories2 = tryParseStories(match[1].trim());
-    if (stories2)
-      return stories2;
+    if (stories2) return stories2;
   }
   const storiesIdx = text.indexOf('"stories"');
   if (storiesIdx !== -1) {
@@ -568,8 +433,7 @@ function parseStoriesFromText(text) {
       const json = extractBalancedJSON(text, braceStart);
       if (json) {
         const stories2 = tryParseStories(json);
-        if (stories2)
-          return stories2;
+        if (stories2) return stories2;
       }
     }
   }
@@ -578,27 +442,23 @@ function parseStoriesFromText(text) {
     const json = extractBalancedJSON(text, arrayStart);
     if (json) {
       const stories2 = tryParseStories(json);
-      if (stories2)
-        return stories2;
+      if (stories2) return stories2;
     }
   }
   const stories = tryParseStories(text.trim());
-  if (stories)
-    return stories;
+  if (stories) return stories;
   const preview = text.slice(0, 500);
-  console.log(chalk3.dim(`  (planner output preview: ${preview}${text.length > 500 ? "..." : ""})`));
+  output.log("system", `(planner output preview: ${preview}${text.length > 500 ? "..." : ""})`);
   return [];
 }
 function tryParseStories(text) {
   try {
     const parsed = JSON.parse(text);
     if (Array.isArray(parsed)) {
-      if (parsed.length > 0 && parsed[0].persona)
-        return parsed;
+      if (parsed.length > 0 && parsed[0].persona) return parsed;
     }
     if (parsed && Array.isArray(parsed.stories)) {
-      if (parsed.stories.length > 0)
-        return parsed.stories;
+      if (parsed.stories.length > 0) return parsed.stories;
     }
   } catch {
   }
@@ -607,8 +467,7 @@ function tryParseStories(text) {
 function extractBalancedJSON(text, start) {
   const open = text[start];
   const close = open === "{" ? "}" : open === "[" ? "]" : null;
-  if (!close)
-    return null;
+  if (!close) return null;
   let depth = 0;
   let inString = false;
   let escape = false;
@@ -626,10 +485,8 @@ function extractBalancedJSON(text, start) {
       inString = !inString;
       continue;
     }
-    if (inString)
-      continue;
-    if (ch === open)
-      depth++;
+    if (inString) continue;
+    if (ch === open) depth++;
     if (ch === close) {
       depth--;
       if (depth === 0) {
@@ -640,36 +497,31 @@ function extractBalancedJSON(text, start) {
   return null;
 }
 function extractScore(text) {
-  const markerMatch = text.match(/::review_score::(\d+)/);
-  if (markerMatch)
-    return parseInt(markerMatch[1], 10);
+  const markerMatches = [...text.matchAll(/::review_score::(\d+)/g)];
+  if (markerMatches.length > 0) {
+    return parseInt(markerMatches[markerMatches.length - 1][1], 10);
+  }
   const scorePatterns = [
-    /\bscore[:\s]+(\d+)\s*\/\s*100/i,
-    /\b(\d+)\s*\/\s*100/,
-    /\bscore[:\s]+(\d+)/i,
-    /\brating[:\s]+(\d+)/i
+    /\bscore[:\s]+(\d+)\s*\/\s*100/gi,
+    /\bscore[:\s]+(\d+)/gi,
+    /\brating[:\s]+(\d+)/gi
   ];
   for (const pattern of scorePatterns) {
-    const match = text.match(pattern);
-    if (match) {
-      const n = parseInt(match[1], 10);
-      if (n >= 0 && n <= 100)
-        return n;
+    const matches = [...text.matchAll(pattern)];
+    if (matches.length > 0) {
+      const n = parseInt(matches[matches.length - 1][1], 10);
+      if (n >= 0 && n <= 100) return n;
     }
   }
-  if (/\bapprove/i.test(text))
-    return 85;
-  if (/\brevis/i.test(text))
-    return 60;
+  if (/\bapprove/i.test(text)) return 85;
+  if (/\brevis/i.test(text)) return 60;
   return 75;
 }
 function parseAffectedStories(text) {
   const storiesMatch = text.match(/AFFECTED_STORIES:\s*\[([^\]]+)\]/i);
-  if (!storiesMatch)
-    return null;
+  if (!storiesMatch) return null;
   const stories = storiesMatch[1].split(",").map((s) => parseInt(s.trim(), 10)).filter((n) => !isNaN(n));
-  if (stories.length === 0)
-    return null;
+  if (stories.length === 0) return null;
   let reasons = {};
   const reasonsMatch = text.match(/AFFECTED_REASONS:\s*(\{[\s\S]*?\})/i);
   if (reasonsMatch) {
@@ -686,7 +538,8 @@ function parseAffectedStories(text) {
   }
   return { stories, reasons };
 }
-async function runOrchestration(config, userTask, trustAll, sandboxed = true, agentRl) {
+async function runOrchestration(config, userTask, trustAll, sandboxed, output) {
+  userTask = resolveTaskInput(userTask, process.cwd());
   const costTracker = new CostTracker();
   const context = {
     filesCreated: [],
@@ -694,18 +547,18 @@ async function runOrchestration(config, userTask, trustAll, sandboxed = true, ag
     decisions: [],
     learnings: []
   };
-  const permissions = new PermissionManager(trustAll);
-  if (agentRl)
-    permissions.setReadline(agentRl);
+  const sessionAllow = /* @__PURE__ */ new Set();
   const workingDir = process.cwd();
-  const plannerStories = await planStories(config, userTask, workingDir, sandboxed);
-  wmLog("planner", `Plan generated: ${plannerStories.length} stories`);
+  const planResult = await planStories(config, userTask, workingDir, sandboxed, output);
+  const plannerStories = planResult.stories;
+  costTracker.addUsage("Planner", planResult.provider, planResult.model, planResult.inputTokens, planResult.outputTokens);
+  output.updateCost?.(costTracker.getTotalCost());
+  output.log("planner", `Plan generated: ${plannerStories.length} stories`);
   plannerStories.forEach((s, i) => {
-    const emoji = getPersonaEmoji(s.persona);
-    wmLog("planner", `Step ${i + 1}: [${s.persona}] ${s.title}${s.dependsOn?.length ? ` (after: ${s.dependsOn.join(", ")})` : ""}`);
+    output.log("planner", `Step ${i + 1}: [${s.persona}] ${s.title}${s.dependsOn?.length ? ` (after: ${s.dependsOn.join(", ")})` : ""}`);
   });
-  wmLog("planner", `Plan validated: ${plannerStories.length} stories. Task queued for execution.`);
-  console.log();
+  output.log("planner", `Plan validated: ${plannerStories.length} stories. Task queued for execution.`);
+  output.log("system", "");
   if (config.review?.useCritic) {
     const critic = loadPersona("critic");
     if (critic) {
@@ -719,14 +572,14 @@ async function runOrchestration(config, userTask, trustAll, sandboxed = true, ag
           criticReadOnly[name] = {
             ...toolDef,
             execute: async (input) => {
-              wmLog("critic", formatToolCall(name, input));
+              output.log("critic", formatToolCallDisplay(name, input));
               const result = await toolDef.execute(input);
               return result;
             }
           };
         }
       }
-      const criticSpinner = ora({ stream: process.stdout, text: chalk3.white("Critic reviewing plan..."), prefixText: "  " }).start();
+      output.status("Critic reviewing plan...");
       const criticStream = streamText({
         model: criticModel,
         system: critic.systemPrompt,
@@ -742,52 +595,47 @@ ${plannerStories.map((s) => `- ${s.id}: ${s.title} (${s.persona}) \u2014 ${s.des
       for await (const _chunk of criticStream.textStream) {
       }
       const criticText = await criticStream.text;
-      criticSpinner.stop();
+      output.statusDone();
       const score = extractScore(criticText);
-      wmLog("critic", `::review_score::${score}`);
-      wmLog("critic", score >= 80 ? "Plan approved" : "Plan needs revision");
-      console.log();
+      output.log("critic", `::review_score::${score}`);
+      output.log("critic", score >= 80 ? "Plan approved" : "Plan needs revision");
+      output.log("system", "");
     }
   }
   const sorted = topologicalSort(plannerStories);
   if (!trustAll) {
-    let answer = "n";
+    let proceed = false;
     try {
-      answer = await permissions.askUser(chalk3.dim("  Execute this plan? (y/n): "));
+      proceed = await output.confirm("Execute this plan?");
     } catch {
     }
-    if (answer.trim().toLowerCase() !== "y" && answer.trim().toLowerCase() !== "yes") {
-      console.log(chalk3.dim("  Plan cancelled.\n"));
+    if (!proceed) {
+      output.log("system", "Plan cancelled.");
       return;
     }
-    console.log();
+    output.log("system", "");
   }
   for (let i = 0; i < sorted.length; i++) {
     const story = sorted[i];
     const persona = loadPersona(story.persona);
     if (!persona) {
-      printError(`Unknown persona: ${story.persona}`);
+      output.error(`Unknown persona: ${story.persona}`);
       continue;
     }
-    const { provider, model: modelName, apiKey, host, contextLength } = getProviderForPersona(config, persona.provider || story.persona);
+    const { provider, model: modelName, apiKey, host, contextLength } = getProviderForPersona(
+      config,
+      persona.provider || story.persona
+    );
     if (apiKey) {
-      const envMap = { anthropic: "ANTHROPIC_API_KEY", openai: "OPENAI_API_KEY", google: "GOOGLE_API_KEY" };
+      const envMap = { anthropic: "ANTHROPIC_API_KEY", openai: "OPENAI_API_KEY", google: "GOOGLE_GENERATIVE_AI_API_KEY" };
       const envVar = envMap[provider];
-      if (envVar && !process.env[envVar])
-        process.env[envVar] = apiKey;
+      if (envVar && !process.env[envVar]) process.env[envVar] = apiKey;
     }
-    console.log(chalk3.bold(`
-  \u2500\u2500\u2500 Story ${i + 1}/${sorted.length} \u2500\u2500\u2500
-`));
-    wmCoordinatorLog(`Task claimed by orchestrator`);
-    wmLog(story.persona, `Starting ${story.title}`);
-    wmLog(story.persona, `Executing story with AIClient (model: ${modelName})...`);
-    const spinner = ora({
-      stream: process.stdout,
-      text: "",
-      prefixText: "",
-      spinner: "dots"
-    }).start();
+    output.log("system", `--- Story ${i + 1}/${sorted.length} ---`);
+    output.coordinatorLog(`Task claimed by orchestrator`);
+    output.log(story.persona, `Starting ${story.title}`);
+    output.log(story.persona, `Executing story with AIClient (model: ${modelName})...`);
+    output.status("");
     const model = createModel(provider, modelName, host, contextLength);
     const allTools = createToolDefinitions(workingDir, model, sandboxed);
     const personaTools = {};
@@ -798,18 +646,17 @@ ${plannerStories.map((s) => `- ${s.id}: ${s.title} (${s.persona}) \u2014 ${s.des
         personaTools[toolName] = {
           ...toolDef,
           execute: async (input) => {
-            const allowed = await permissions.checkPermission(toolName, input);
-            if (!allowed)
-              return "Tool execution denied by user.";
-            const callKey = `${toolName}:${JSON.stringify(input)}`;
-            const isDuplicate = callKey === lastToolCall;
-            lastToolCall = callKey;
+            const allowed = await checkToolPermission(toolName, input, trustAll, sessionAllow, output);
+            if (!allowed) return "Tool execution denied by user.";
+            const sig = `${toolName}:${JSON.stringify(input)}`;
+            const isDuplicate = sig === lastToolCall;
+            lastToolCall = sig;
             if (!isDuplicate) {
-              spinner.stop();
-              wmLog(story.persona, formatToolCall(toolName, input));
+              output.statusDone();
+              output.toolCall(story.persona, toolName, input);
             }
             const result = await toolDef.execute(input);
-            spinner.start();
+            output.status("");
             return result;
           }
         };
@@ -872,12 +719,11 @@ ${revisionFeedback}` : ""}`;
           ...buildOllamaOptions(provider, contextLength),
           onStepFinish({ text: text2 }) {
             if (text2) {
-              spinner.stop();
+              output.statusDone();
               const lines = text2.split("\n").filter((l) => l.trim());
               for (const line of lines) {
-                if (line.includes("::decision::") || line.includes("::learning::") || line.includes("::file_created::") || line.includes("::file_modified::"))
-                  continue;
-                wmLog(story.persona, line);
+                if (line.includes("::decision::") || line.includes("::learning::") || line.includes("::file_created::") || line.includes("::file_modified::")) continue;
+                output.log(story.persona, line);
               }
             }
           }
@@ -887,13 +733,13 @@ ${revisionFeedback}` : ""}`;
         const text = await stream.text;
         allText = text;
         const usage = await stream.totalUsage;
-        spinner.stop();
+        output.statusDone();
         const decisionMatches = text.match(/::decision::(.*?)(?=::\w+::|$)/gs);
         if (decisionMatches) {
           for (const m of decisionMatches) {
             const decision = m.replace("::decision::", "").trim();
             context.decisions.push(decision);
-            wmLog(story.persona, decision);
+            output.log(story.persona, decision);
           }
         }
         const learningMatches = text.match(/::learning::(.*?)(?=::\w+::|$)/gs);
@@ -917,17 +763,18 @@ ${revisionFeedback}` : ""}`;
         const inTokens = usage?.inputTokens || 0;
         const outTokens = usage?.outputTokens || 0;
         costTracker.addUsage(persona.name, provider, modelName, inTokens, outTokens);
-        wmLog(story.persona, `${story.title} \u2014 completed! (${i + 1}/${sorted.length})`);
-        console.log();
+        output.updateCost?.(costTracker.getTotalCost());
+        output.log(story.persona, `${story.title} \u2014 completed! (${i + 1}/${sorted.length})`);
+        output.log("system", "");
         break;
       } catch (err) {
-        spinner.stop();
+        output.statusDone();
         const errMsg = err instanceof Error ? err.message : String(err);
         if (isTransientError(err) && revision < 2) {
-          wmLog(story.persona, `Transient error: ${errMsg} \u2014 retrying...`);
+          output.log(story.persona, `Transient error: ${errMsg} \u2014 retrying...`);
           continue;
         }
-        printError(`Story ${i + 1} failed: ${errMsg}`);
+        output.error(`Story ${i + 1} failed: ${errMsg}`);
         break;
       }
     }
@@ -935,16 +782,18 @@ ${revisionFeedback}` : ""}`;
   const maxRevisions = config.review?.maxRevisions ?? 2;
   const autoRevise = config.review?.autoRevise ?? false;
   const approvalThreshold = config.review?.approvalThreshold ?? 80;
-  const reviewer = loadPersona("reviewer");
+  const reviewer = loadPersona("tech_lead");
   if (reviewer) {
-    const { provider: revProvider, model: revModel, host: revHost, contextLength: revCtx } = getProviderForPersona(config, reviewer.provider || "reviewer");
+    const { provider: revProvider, model: revModel, host: revHost, contextLength: revCtx } = getProviderForPersona(
+      config,
+      "tech_lead"
+    );
     const revApiKey = config.providers[revProvider]?.apiKey;
     if (revApiKey) {
-      const envMap = { anthropic: "ANTHROPIC_API_KEY", openai: "OPENAI_API_KEY", google: "GOOGLE_API_KEY" };
+      const envMap = { anthropic: "ANTHROPIC_API_KEY", openai: "OPENAI_API_KEY", google: "GOOGLE_GENERATIVE_AI_API_KEY" };
       const envVar = envMap[revProvider];
       const key = revApiKey.startsWith("{env:") ? process.env[revApiKey.slice(5, -1)] : revApiKey;
-      if (envVar && key && !process.env[envVar])
-        process.env[envVar] = key;
+      if (envVar && key && !process.env[envVar]) process.env[envVar] = key;
     }
     const reviewModel = createModel(revProvider, revModel, revHost, revCtx);
     const reviewTools = createToolDefinitions(workingDir, reviewModel, sandboxed);
@@ -955,7 +804,7 @@ ${revisionFeedback}` : ""}`;
         reviewerTools[toolName] = {
           ...toolDef,
           execute: async (input) => {
-            wmLog("tech_lead", formatToolCall(toolName, input));
+            output.log("tech_lead", formatToolCallDisplay(toolName, input));
             const result = await toolDef.execute(input);
             return result;
           }
@@ -965,13 +814,9 @@ ${revisionFeedback}` : ""}`;
     let previousReviewFeedback = "";
     for (let reviewRound = 0; reviewRound <= maxRevisions; reviewRound++) {
       const isRevision = reviewRound > 0;
-      wmCoordinatorLog(isRevision ? `Starting Tech Lead review (revision ${reviewRound}/${maxRevisions})...` : "Starting Tech Lead review...");
-      wmLog("tech_lead", "Starting agent execution");
-      const reviewSpinner = ora({
-        stream: process.stdout,
-        text: chalk3.white(isRevision ? "Reviewer \u2014 Re-checking after revisions" : "Reviewer \u2014 Checking code quality"),
-        prefixText: "  "
-      }).start();
+      output.coordinatorLog(isRevision ? `Starting Tech Lead review (revision ${reviewRound}/${maxRevisions})...` : "Starting Tech Lead review...");
+      output.log("tech_lead", `Starting agent execution (model: ${revModel})`);
+      output.status(isRevision ? "Reviewer -- Re-checking after revisions" : "Reviewer -- Checking code quality");
       try {
         const previousFeedbackSection = isRevision && previousReviewFeedback ? `## Previous Review Feedback (Review ${reviewRound}/${maxRevisions})
 This is a revision attempt. The previous code was reviewed and these issues were identified:
@@ -1034,7 +879,7 @@ AFFECTED_REASONS: {"2": "Missing error handling in auth controller", "3": "Front
 - Only include stories that have ACTUAL implementation issues
 - If ALL stories need revision, you may omit AFFECTED_STORIES (all will re-run)
 - Be specific in AFFECTED_REASONS so developers know exactly what to fix`;
-        let allReviewText = "";
+        let reviewerOutput = "";
         const reviewStream = streamText({
           model: reviewModel,
           system: reviewer.systemPrompt,
@@ -1045,95 +890,95 @@ AFFECTED_REASONS: {"2": "Missing error handling in auth controller", "3": "Front
           ...buildOllamaOptions(revProvider, revCtx),
           onStepFinish({ text }) {
             if (text) {
-              reviewSpinner.stop();
+              reviewerOutput += text + "\n";
+              output.statusDone();
               const lines = text.split("\n").filter((l) => l.trim());
               for (const line of lines) {
-                if (line.includes("::review_score::") || line.includes("::review_verdict::"))
-                  continue;
-                wmLog("tech_lead", line);
+                if (line.includes("::review_score::") || line.includes("::review_verdict::")) continue;
+                output.log("tech_lead", line);
               }
             }
           }
         });
         for await (const _chunk of reviewStream.textStream) {
         }
-        const finalReviewText = await reviewStream.text;
-        const reviewText = finalReviewText && finalReviewText.length > allReviewText.length ? finalReviewText : allReviewText;
+        const reviewText = reviewerOutput;
         const reviewUsage = await reviewStream.totalUsage;
-        reviewSpinner.stop();
+        output.statusDone();
         const score = extractScore(reviewText);
         const approved = score >= approvalThreshold;
-        wmLog("tech_lead", `::code_quality_score::${score}`);
-        wmLog("tech_lead", `::review_decision::${approved ? "approved" : "needs_revision"}`);
-        wmCoordinatorLog(approved ? `Review approved (score: ${score}/100)` : `Review needs revision (score: ${score}/100)`);
+        output.log("tech_lead", `::code_quality_score::${score}`);
+        output.log("tech_lead", `::review_decision::${approved ? "approved" : "needs_revision"}`);
+        output.coordinatorLog(approved ? `Review approved (score: ${score}/100)` : `Review needs revision (score: ${score}/100)`);
         previousReviewFeedback = reviewText;
-        console.log();
-        costTracker.addUsage(`Reviewer (round ${reviewRound + 1})`, revProvider, revModel, reviewUsage?.inputTokens || 0, reviewUsage?.outputTokens || 0);
-        if (approved)
-          break;
+        output.log("system", "");
+        costTracker.addUsage(
+          `Reviewer (round ${reviewRound + 1})`,
+          revProvider,
+          revModel,
+          reviewUsage?.inputTokens || 0,
+          reviewUsage?.outputTokens || 0
+        );
+        output.updateCost?.(costTracker.getTotalCost());
+        if (approved) break;
         if (reviewRound >= maxRevisions) {
-          console.log(chalk3.yellow(`  \u26A0 Max review revisions (${maxRevisions}) reached`));
+          output.log("system", `Max review revisions (${maxRevisions}) reached`);
           break;
         }
         let shouldRevise = autoRevise;
         if (!autoRevise) {
           try {
-            const answer = await permissions.askUser(chalk3.dim("  Revise and re-review? ") + chalk3.white(`(y/n, ${maxRevisions - reviewRound} attempt${maxRevisions - reviewRound > 1 ? "s" : ""} left): `));
-            shouldRevise = answer.trim().toLowerCase() === "y" || answer.trim().toLowerCase() === "yes";
+            shouldRevise = await output.confirm(`Revise and re-review? (${maxRevisions - reviewRound} attempt${maxRevisions - reviewRound > 1 ? "s" : ""} left)`);
           } catch {
             shouldRevise = false;
           }
         } else {
-          console.log(chalk3.dim(`  Auto-revising (${maxRevisions - reviewRound} attempt${maxRevisions - reviewRound > 1 ? "s" : ""} left)...`));
+          output.log("system", `Auto-revising (${maxRevisions - reviewRound} attempt${maxRevisions - reviewRound > 1 ? "s" : ""} left)...`);
         }
         if (!shouldRevise) {
-          console.log(chalk3.dim("  Skipping revision, proceeding to commit."));
+          output.log("system", "Skipping revision, proceeding to commit.");
           break;
         }
         const affected = parseAffectedStories(reviewText);
         const affectedSet = affected ? new Set(affected.stories) : null;
         if (affected) {
           const selectiveInfo = `stories ${affected.stories.join(", ")}`;
-          wmCoordinatorLog(`Selective revision: ${selectiveInfo}`);
+          output.coordinatorLog(`Selective revision: ${selectiveInfo}`);
           if (Object.keys(affected.reasons).length > 0) {
             for (const [idx, reason] of Object.entries(affected.reasons)) {
-              wmCoordinatorLog(`  Story ${idx}: ${reason}`);
+              output.coordinatorLog(`  Story ${idx}: ${reason}`);
             }
           }
         } else {
-          wmCoordinatorLog("Full revision (all stories)");
+          output.coordinatorLog("Full revision (all stories)");
         }
-        console.log(chalk3.bold("\n  \u2500\u2500\u2500 Revision Pass \u2500\u2500\u2500\n"));
+        output.log("system", "--- Revision Pass ---");
         for (let i = 0; i < sorted.length; i++) {
           const story = sorted[i];
           if (affectedSet && !affectedSet.has(i + 1)) {
-            wmCoordinatorLog(`Skipping story ${i + 1}/${sorted.length} \u2014 not affected`);
+            output.coordinatorLog(`Skipping story ${i + 1}/${sorted.length} \u2014 not affected`);
             continue;
           }
           const storyPersona = loadPersona(story.persona);
-          if (!storyPersona)
-            continue;
-          const { provider: sProvider, model: sModel, host: sHost, contextLength: sCtx } = getProviderForPersona(config, storyPersona.provider || story.persona);
+          if (!storyPersona) continue;
+          const { provider: sProvider, model: sModel, host: sHost, contextLength: sCtx } = getProviderForPersona(
+            config,
+            storyPersona.provider || story.persona
+          );
           if (sProvider) {
             const sApiKey = config.providers[sProvider]?.apiKey;
             if (sApiKey) {
-              const envMap = { anthropic: "ANTHROPIC_API_KEY", openai: "OPENAI_API_KEY", google: "GOOGLE_API_KEY" };
+              const envMap = { anthropic: "ANTHROPIC_API_KEY", openai: "OPENAI_API_KEY", google: "GOOGLE_GENERATIVE_AI_API_KEY" };
               const envVar = envMap[sProvider];
               if (envVar && !process.env[envVar]) {
                 const key = sApiKey.startsWith("{env:") ? process.env[sApiKey.slice(5, -1)] : sApiKey;
-                if (key)
-                  process.env[envVar] = key;
+                if (key) process.env[envVar] = key;
               }
             }
           }
-          wmCoordinatorLog(`Revision pass for story ${i + 1}/${sorted.length}`);
-          wmLog(story.persona, `Starting revision: ${story.title}`);
-          const revSpinner = ora({
-            stream: process.stdout,
-            text: "",
-            prefixText: "",
-            spinner: "dots"
-          }).start();
+          output.coordinatorLog(`Revision pass for story ${i + 1}/${sorted.length}`);
+          output.log(story.persona, `Starting revision: ${story.title} (model: ${sModel})`);
+          output.status("");
           const storyModel = createModel(sProvider, sModel, sHost, sCtx);
           const storyAllTools = createToolDefinitions(workingDir, storyModel, sandboxed);
           const storyTools = {};
@@ -1143,13 +988,12 @@ AFFECTED_REASONS: {"2": "Missing error handling in auth controller", "3": "Front
               storyTools[toolName] = {
                 ...toolDef,
                 execute: async (input) => {
-                  const allowed = await permissions.checkPermission(toolName, input);
-                  if (!allowed)
-                    return "Tool execution denied by user.";
-                  revSpinner.stop();
-                  wmLog(story.persona, formatToolCall(toolName, input));
+                  const allowed = await checkToolPermission(toolName, input, trustAll, sessionAllow, output);
+                  if (!allowed) return "Tool execution denied by user.";
+                  output.statusDone();
+                  output.log(story.persona, formatToolCallDisplay(toolName, input));
                   const result = await toolDef.execute(input);
-                  revSpinner.start();
+                  output.status("");
                   return result;
                 }
               };
@@ -1186,12 +1030,11 @@ ${story.description}`,
               ...buildOllamaOptions(sProvider, sCtx),
               onStepFinish({ text }) {
                 if (text) {
-                  revSpinner.stop();
+                  output.statusDone();
                   const lines = text.split("\n").filter((l) => l.trim());
                   for (const line of lines) {
-                    if (line.includes("::"))
-                      continue;
-                    wmLog(story.persona, line);
+                    if (line.includes("::")) continue;
+                    output.log(story.persona, line);
                   }
                 }
               }
@@ -1199,80 +1042,87 @@ ${story.description}`,
             for await (const _chunk of revStream.textStream) {
             }
             const revUsage = await revStream.totalUsage;
-            revSpinner.stop();
-            costTracker.addUsage(`${storyPersona.name} (revision)`, sProvider, sModel, revUsage?.inputTokens || 0, revUsage?.outputTokens || 0);
-            wmLog(story.persona, `${story.title} \u2014 revision complete!`);
+            output.statusDone();
+            costTracker.addUsage(
+              `${storyPersona.name} (revision)`,
+              sProvider,
+              sModel,
+              revUsage?.inputTokens || 0,
+              revUsage?.outputTokens || 0
+            );
+            output.updateCost?.(costTracker.getTotalCost());
+            output.log(story.persona, `${story.title} \u2014 revision complete!`);
           } catch (err) {
-            revSpinner.stop();
-            console.log(chalk3.yellow(`  \u26A0 Revision failed for story ${i + 1}: ${err instanceof Error ? err.message : String(err)}`));
+            output.statusDone();
+            output.log("system", `Revision failed for story ${i + 1}: ${err instanceof Error ? err.message : String(err)}`);
           }
         }
-        console.log();
+        output.log("system", "");
       } catch (err) {
-        reviewSpinner.stop();
-        console.log(chalk3.yellow(`  \u26A0 Review skipped: ${err instanceof Error ? err.message : String(err)}`));
-        console.log();
+        output.statusDone();
+        output.log("system", `Review skipped: ${err instanceof Error ? err.message : String(err)}`);
+        output.log("system", "");
         break;
       }
     }
   }
   try {
-    const { execSync: execSync2 } = await import("child_process");
+    const { execSync } = await import("child_process");
     try {
-      execSync2("git rev-parse --git-dir", { cwd: workingDir, encoding: "utf-8", stdio: "pipe" });
+      execSync("git rev-parse --git-dir", { cwd: workingDir, encoding: "utf-8", stdio: "pipe" });
     } catch {
-      wmCoordinatorLog("Initializing git repository...");
-      execSync2("git init", { cwd: workingDir, encoding: "utf-8", stdio: "pipe" });
-      const fs2 = await import("fs");
+      output.coordinatorLog("Initializing git repository...");
+      execSync("git init", { cwd: workingDir, encoding: "utf-8", stdio: "pipe" });
+      const fs3 = await import("fs");
       const gitignorePath = `${workingDir}/.gitignore`;
-      if (!fs2.existsSync(gitignorePath)) {
-        fs2.writeFileSync(gitignorePath, "node_modules/\ndist/\n.env\n.workermill/\n*.log\n", "utf-8");
+      if (!fs3.existsSync(gitignorePath)) {
+        fs3.writeFileSync(gitignorePath, "node_modules/\ndist/\n.env\n.workermill/\n*.log\n", "utf-8");
       }
-      wmCoordinatorLog("Git repo initialized");
+      output.coordinatorLog("Git repo initialized");
     }
-    const diff = execSync2("git diff --stat", { cwd: workingDir, encoding: "utf-8", stdio: "pipe" }).trim();
-    const untracked = execSync2("git ls-files --others --exclude-standard", { cwd: workingDir, encoding: "utf-8", stdio: "pipe" }).trim();
+    const diff = execSync("git diff --stat", { cwd: workingDir, encoding: "utf-8", stdio: "pipe" }).trim();
+    const untracked = execSync("git ls-files --others --exclude-standard", { cwd: workingDir, encoding: "utf-8", stdio: "pipe" }).trim();
     const hasChanges = diff || untracked;
     if (hasChanges) {
-      console.log(chalk3.bold("  \u2500\u2500\u2500 Changes \u2500\u2500\u2500"));
+      output.log("system", "--- Changes ---");
       if (diff) {
-        console.log(chalk3.dim("  " + diff.split("\n").join("\n  ")));
+        output.log("system", diff);
       }
       if (untracked) {
         const untrackedFiles = untracked.split("\n");
-        console.log(chalk3.dim("  New files:"));
+        output.log("system", "New files:");
         for (const f of untrackedFiles) {
-          console.log(chalk3.dim(`    + ${f}`));
+          output.log("system", `  + ${f}`);
         }
       }
-      console.log();
+      output.log("system", "");
       if (!trustAll) {
-        const answer = await permissions.askUser(chalk3.dim("  Commit these changes? (y/n): "));
-        if (answer.trim().toLowerCase() === "y" || answer.trim().toLowerCase() === "yes") {
+        const commitConfirmed = await output.confirm("Commit these changes?");
+        if (commitConfirmed) {
           const filesToStage = [...context.filesCreated, ...context.filesModified].filter(Boolean);
           if (filesToStage.length > 0) {
             for (const f of filesToStage) {
               try {
-                execSync2(`git add "${f}"`, { cwd: workingDir, stdio: "pipe" });
+                execSync(`git add "${f}"`, { cwd: workingDir, stdio: "pipe" });
               } catch {
               }
             }
           } else {
-            execSync2("git add -u", { cwd: workingDir, stdio: "pipe" });
+            execSync("git add -u", { cwd: workingDir, stdio: "pipe" });
           }
           const storyTitles = sorted.map((s) => s.title).join(", ");
           const msg = `feat: ${storyTitles}`.slice(0, 72);
-          execSync2(`git commit -m "${msg.replace(/"/g, '\\"')}"`, { cwd: workingDir, stdio: "pipe" });
-          console.log(chalk3.green("  \u2713 Changes committed"));
+          execSync(`git commit -m "${msg.replace(/"/g, '\\"')}"`, { cwd: workingDir, stdio: "pipe" });
+          output.log("system", "Changes committed");
         }
       }
     }
   } catch (err) {
   }
-  console.log(chalk3.bold("  \u2500\u2500\u2500 Session Complete \u2500\u2500\u2500"));
-  console.log();
-  console.log(chalk3.dim("  " + costTracker.getSummary().split("\n").join("\n  ")));
-  console.log();
+  output.log("system", "--- Session Complete ---");
+  output.log("system", "");
+  output.log("system", costTracker.getSummary());
+  output.log("system", "");
 }
 export {
   classifyComplexity,