workermill 0.1.8 → 0.2.0

package/dist/{orchestrator-NMTZUS23.js → orchestrator-5I7BGPC7.js}

@@ -1,23 +1,14 @@
 import {
   CostTracker,
-  PermissionManager,
+  __dirname,
+  buildOllamaOptions,
   createModel,
   createToolDefinitions,
-  getPersonaEmoji,
-  getProviderForPersona,
-  printError,
-  printToolCall,
-  printToolResult,
-  wmCoordinatorLog,
-  wmLog,
-  wmLogPrefix
-} from "./chunk-3KIFXIBC.js";
-import {
-  __dirname
-} from "./chunk-2NTK7H4W.js";
+  getProviderForPersona
+} from "./chunk-VC6VNVEY.js";
 
 // src/orchestrator.js
-import chalk from "chalk";
+import chalk3 from "chalk";
 import ora from "ora";
 import { streamText, generateObject, generateText, stepCountIs } from "ai";
 import { z } from "zod";
@@ -58,10 +49,14 @@ function parsePersonaFile(content) {
 }
 function loadPersona(slug) {
   const locations = [
+    // Project-level persona overrides
     path.join(process.cwd(), ".workermill", "personas", `${slug}.md`),
+    // User-level persona overrides
     path.join(os.homedir(), ".workermill", "personas", `${slug}.md`),
+    // Bundled with the npm package (cli/personas/)
+    path.join(import.meta.dirname || __dirname, "../personas", `${slug}.md`),
+    // Dev mode — resolve from monorepo
     path.join(import.meta.dirname || __dirname, "../../packages/engine/src/personas", `${slug}.md`),
-    // Also try relative to the repo root
     path.join(process.cwd(), "packages/engine/src/personas", `${slug}.md`)
   ];
   for (const loc of locations) {
@@ -85,16 +80,341 @@ 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/tui.js
+import chalk2 from "chalk";
+import { execSync } from "child_process";
+
+// src/logger.js
+import fs2 from "fs";
+import path2 from "path";
+var LOG_DIR = path2.join(process.cwd(), ".workermill");
+var LOG_FILE = path2.join(LOG_DIR, "cli.log");
+var logStream = null;
+function ensureLogDir() {
+  if (!fs2.existsSync(LOG_DIR)) {
+    fs2.mkdirSync(LOG_DIR, { recursive: true });
+  }
+}
+function getStream() {
+  if (!logStream) {
+    ensureLogDir();
+    logStream = fs2.createWriteStream(LOG_FILE, { flags: "a" });
+  }
+  return logStream;
+}
+function timestamp() {
+  return (/* @__PURE__ */ new Date()).toISOString();
+}
+function log(level, message, data) {
+  const entry = data ? `[${timestamp()}] ${level}: ${message} ${JSON.stringify(data)}` : `[${timestamp()}] ${level}: ${message}`;
+  getStream().write(entry + "\n");
+}
+function info(message, data) {
+  log("INFO", message, data);
+}
+
+// src/tui.js
+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(", ")}`;
+      }
+    }
+  }
+  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}`);
+}
+function printError(message) {
+  console.log(chalk2.red(`
+  \u2717 ${message}
+`));
+}
+var sessionStartTime = Date.now();
+
 // src/orchestrator.js
+var LEARNING_INSTRUCTIONS = `
+
+## Reporting Learnings
+
+When you discover something specific and actionable about this codebase, emit a learning marker:
+
+\`\`\`
+::learning::The test suite requires DATABASE_URL env var or tests silently pass without running
+::learning::New API routes must be registered in backend/src/routes/index.ts or they won't load
+\`\`\`
+
+**Emit a learning when you discover:**
+- A non-obvious requirement (specific env vars, config files, build steps)
+- A codebase convention not documented elsewhere (naming patterns, file organization)
+- A gotcha you had to work around (unexpected failures, ordering dependencies)
+- Files that must be modified together (route + model + migration + test)
+
+**Do NOT emit generic advice** like "write tests" or "handle errors properly."
+Include file paths, commands, and exact details. Only emit when you genuinely discover something non-obvious.
+`;
+var DOCKER_INSTRUCTIONS = `
+
+## Development Environment
+
+If this task requires databases, caches, or other services, use Docker to run real instances instead of mocking them. Do NOT mock or stub external services.
+
+### Common Services
+- PostgreSQL: \`docker run -d --rm -p 5432:5432 -e POSTGRES_PASSWORD=test --name postgres-test postgres:16-alpine\`
+- Redis: \`docker run -d --rm -p 6379:6379 --name redis-test redis:7-alpine\`
+- MongoDB: \`docker run -d --rm -p 27017:27017 --name mongo-test mongo:7\`
+- MySQL: \`docker run -d --rm -p 3306:3306 -e MYSQL_ROOT_PASSWORD=test --name mysql-test mysql:8\`
+- If the project has a \`docker-compose.yml\`, use \`docker compose up -d\`
+
+Tests that pass against mocks but fail against real services are worthless.
+
+### CI/CD \u2014 Always add service containers
+When creating GitHub Actions CI workflows that run tests requiring databases, add \`services:\` blocks so CI has real instances. Match your local Docker setup with CI service containers.
+`;
+var VERSION_TRUST = `
+
+## Technology Versions \u2014 Trust the Spec
+
+If the ticket, PRD, or task description specifies a dependency version, USE THAT VERSION. Do NOT downgrade or "fix" versions you don't recognize \u2014 your training data has a cutoff and newer releases exist. Trust the spec over your knowledge.
+`;
+function buildReasoningOptions(provider, modelName) {
+  switch (provider) {
+    case "openai":
+      return { providerOptions: { openai: { reasoningSummary: "detailed" } } };
+    case "google":
+    case "gemini":
+      if (modelName && modelName.includes("gemini-3")) {
+        return { providerOptions: { google: { thinkingConfig: { thinkingLevel: "high", includeThoughts: true } } } };
+      }
+      return { providerOptions: { google: { thinkingConfig: { thinkingBudget: 8192, includeThoughts: true } } } };
+    default:
+      return {};
+  }
+}
+function isTransientError(error) {
+  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) {
-  const { provider, model: modelName, apiKey, host } = getProviderForPersona(config);
+  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 envVar = envMap[provider];
     if (envVar && !process.env[envVar])
       process.env[envVar] = apiKey;
   }
-  const model = createModel(provider, modelName, host);
+  const model = createModel(provider, modelName, host, contextLength);
   try {
     const result = await generateObject({
       model,
@@ -135,7 +455,7 @@ function topologicalSort(stories) {
     if (visited.has(id))
       return;
     if (visiting.has(id)) {
-      console.log(chalk.yellow(`  \u26A0 Circular dependency at ${id}, using input order`));
+      console.log(chalk3.yellow(`  \u26A0 Circular dependency at ${id}, using input order`));
       return;
     }
     visiting.add(id);
@@ -158,7 +478,7 @@ function topologicalSort(stories) {
 }
 async function planStories(config, userTask, workingDir, sandboxed = true) {
   const planner = loadPersona("planner");
-  const { provider: pProvider, model: pModel, host: pHost } = getProviderForPersona(config, "planner");
+  const { provider: pProvider, model: pModel, host: pHost, contextLength: pCtx } = getProviderForPersona(config, "planner");
   if (pProvider) {
     const pApiKey = config.providers[pProvider]?.apiKey;
     if (pApiKey) {
@@ -171,13 +491,21 @@ async function planStories(config, userTask, workingDir, sandboxed = true) {
       }
     }
   }
-  const plannerModel = createModel(pProvider, pModel, pHost);
+  const plannerModel = createModel(pProvider, pModel, pHost, pCtx);
   const plannerTools = createToolDefinitions(workingDir, plannerModel, sandboxed);
   const readOnlyTools = {};
   if (planner) {
     for (const toolName of planner.tools) {
-      if (plannerTools[toolName]) {
-        readOnlyTools[toolName] = plannerTools[toolName];
+      const toolDef = plannerTools[toolName];
+      if (toolDef) {
+        readOnlyTools[toolName] = {
+          ...toolDef,
+          execute: async (input) => {
+            wmLog("planner", formatToolCall(toolName, input));
+            const result = await toolDef.execute(input);
+            return result;
+          }
+        };
       }
     }
   }
@@ -215,56 +543,42 @@ Return ONLY a JSON code block with this structure:
 }
 \`\`\`
 
-Available personas: architect, backend_developer, frontend_developer, fullstack_developer, devops_engineer, qa_engineer, security_engineer, database_engineer, mobile_developer, data_engineer, ml_engineer`;
+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...");
+  let planText = "";
   const planStream = streamText({
     model: plannerModel,
     system: planner?.systemPrompt || "You are an implementation planner.",
     prompt: plannerPrompt,
     tools: readOnlyTools,
     stopWhen: stepCountIs(100),
-    abortSignal: AbortSignal.timeout(3 * 60 * 1e3)
-  });
-  let planText = "";
-  const planPrefix = wmLogPrefix("planner");
-  let planNeedsPrefix = true;
-  let inJsonBlock = false;
-  for await (const chunk of planStream.textStream) {
-    if (chunk) {
-      planText += chunk;
-      if (chunk.includes("```json")) {
-        inJsonBlock = true;
-        continue;
-      }
-      if (chunk.includes("```") && inJsonBlock) {
-        inJsonBlock = false;
-        continue;
-      }
-      if (inJsonBlock)
-        continue;
-      if (planNeedsPrefix) {
-        process.stdout.write(planPrefix);
-        planNeedsPrefix = false;
+    timeout: { totalMs: 3 * 60 * 1e3, chunkMs: 12e4 },
+    ...buildOllamaOptions(pProvider, pCtx),
+    onStepFinish({ text }) {
+      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);
+        }
       }
-      process.stdout.write(chalk.white(chunk));
-      if (chunk.endsWith("\n"))
-        planNeedsPrefix = true;
     }
+  });
+  for await (const _chunk of planStream.textStream) {
   }
-  if (!planNeedsPrefix)
-    process.stdout.write("\n");
   const finalText = await planStream.text;
   if (finalText && finalText.length > planText.length) {
     planText = finalText;
   }
   let stories = parseStoriesFromText(planText);
   if (stories.length === 0) {
-    console.log(chalk.yellow("  \u26A0 Planner didn't produce structured stories, falling back to single story"));
+    console.log(chalk3.yellow("  \u26A0 Planner didn't produce structured stories, falling back to single story"));
     stories = [{
       id: "implement",
       title: userTask.slice(0, 60),
-      persona: "fullstack_developer",
+      persona: "backend_developer",
       description: userTask
     }];
   }
@@ -302,7 +616,7 @@ function parseStoriesFromText(text) {
   if (stories)
     return stories;
   const preview = text.slice(0, 500);
-  console.log(chalk.dim(`  (planner output preview: ${preview}${text.length > 500 ? "..." : ""})`));
+  console.log(chalk3.dim(`  (planner output preview: ${preview}${text.length > 500 ? "..." : ""})`));
   return [];
 }
 function tryParseStories(text) {
@@ -379,6 +693,29 @@ function extractScore(text) {
     return 60;
   return 75;
 }
+function parseAffectedStories(text) {
+  const storiesMatch = text.match(/AFFECTED_STORIES:\s*\[([^\]]+)\]/i);
+  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;
+  let reasons = {};
+  const reasonsMatch = text.match(/AFFECTED_REASONS:\s*(\{[\s\S]*?\})/i);
+  if (reasonsMatch) {
+    try {
+      const parsed = JSON.parse(reasonsMatch[1]);
+      for (const [key, value] of Object.entries(parsed)) {
+        const storyIndex = parseInt(key, 10);
+        if (!isNaN(storyIndex) && typeof value === "string") {
+          reasons[storyIndex] = value;
+        }
+      }
+    } catch {
+    }
+  }
+  return { stories, reasons };
+}
 async function runOrchestration(config, userTask, trustAll, sandboxed = true, agentRl) {
   const costTracker = new CostTracker();
   const context = {
@@ -402,16 +739,24 @@ async function runOrchestration(config, userTask, trustAll, sandboxed = true, ag
   if (config.review?.useCritic) {
     const critic = loadPersona("critic");
     if (critic) {
-      const { provider: cProvider, model: cModel, host: cHost } = getProviderForPersona(config, "critic");
-      const criticModel = createModel(cProvider, cModel, cHost);
+      const { provider: cProvider, model: cModel, host: cHost, contextLength: cCtx } = getProviderForPersona(config, "critic");
+      const criticModel = createModel(cProvider, cModel, cHost, cCtx);
       const criticTools = createToolDefinitions(workingDir, criticModel, sandboxed);
       const criticReadOnly = {};
       for (const name of critic.tools) {
-        if (criticTools[name]) {
-          criticReadOnly[name] = criticTools[name];
+        const toolDef = criticTools[name];
+        if (toolDef) {
+          criticReadOnly[name] = {
+            ...toolDef,
+            execute: async (input) => {
+              wmLog("critic", formatToolCall(name, input));
+              const result = await toolDef.execute(input);
+              return result;
+            }
+          };
         }
       }
-      const criticSpinner = ora({ stream: process.stdout, text: chalk.white("Critic reviewing plan..."), prefixText: "  " }).start();
+      const criticSpinner = ora({ stream: process.stdout, text: chalk3.white("Critic reviewing plan..."), prefixText: "  " }).start();
       const criticStream = streamText({
         model: criticModel,
         system: critic.systemPrompt,
@@ -421,7 +766,8 @@ Stories:
 ${plannerStories.map((s) => `- ${s.id}: ${s.title} (${s.persona}) \u2014 ${s.description}`).join("\n")}`,
         tools: criticReadOnly,
         stopWhen: stepCountIs(100),
-        abortSignal: AbortSignal.timeout(3 * 60 * 1e3)
+        timeout: { totalMs: 3 * 60 * 1e3, chunkMs: 12e4 },
+        ...buildOllamaOptions(cProvider, cCtx)
       });
       for await (const _chunk of criticStream.textStream) {
       }
@@ -437,11 +783,11 @@ ${plannerStories.map((s) => `- ${s.id}: ${s.title} (${s.persona}) \u2014 ${s.des
   if (!trustAll) {
     let answer = "n";
     try {
-      answer = await permissions.askUser(chalk.dim("  Execute this plan? (y/n): "));
+      answer = await permissions.askUser(chalk3.dim("  Execute this plan? (y/n): "));
     } catch {
     }
     if (answer.trim().toLowerCase() !== "y" && answer.trim().toLowerCase() !== "yes") {
-      console.log(chalk.dim("  Plan cancelled.\n"));
+      console.log(chalk3.dim("  Plan cancelled.\n"));
       return;
     }
     console.log();
@@ -453,13 +799,16 @@ ${plannerStories.map((s) => `- ${s.id}: ${s.title} (${s.persona}) \u2014 ${s.des
       printError(`Unknown persona: ${story.persona}`);
       continue;
     }
-    const { provider, model: modelName, apiKey, host } = 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 envVar = envMap[provider];
       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})...`);
@@ -469,7 +818,7 @@ ${plannerStories.map((s) => `- ${s.id}: ${s.title} (${s.persona}) \u2014 ${s.des
       prefixText: "",
       spinner: "dots"
     }).start();
-    const model = createModel(provider, modelName, host);
+    const model = createModel(provider, modelName, host, contextLength);
     const allTools = createToolDefinitions(workingDir, model, sandboxed);
     const personaTools = {};
     let lastToolCall = "";
@@ -487,13 +836,9 @@ ${plannerStories.map((s) => `- ${s.id}: ${s.title} (${s.persona}) \u2014 ${s.des
             lastToolCall = callKey;
             if (!isDuplicate) {
               spinner.stop();
-              wmLog(story.persona, `Tool: ${toolName}`);
+              wmLog(story.persona, formatToolCall(toolName, input));
             }
             const result = await toolDef.execute(input);
-            const resultStr = typeof result === "string" ? result : JSON.stringify(result);
-            if (!isDuplicate) {
-              printToolResult(toolName, resultStr);
-            }
             spinner.start();
             return result;
           }
@@ -525,6 +870,12 @@ Working directory: ${workingDir}
 
 Your task: ${story.description}
 
+## Communication Style
+
+Write in a professional, direct tone. Do NOT open messages with filler words or pleasantries like "Perfect!", "Great!", "Awesome!", "Sure!", "Absolutely!", or similar. Start with the substance \u2014 what you did, what you found, or what you need. Be concise and informative. Do NOT repeat what you said in previous steps \u2014 each response should add new information only.
+
+When summarizing your work at the end, describe decisions in plain language. The internal DEC-xxx markers are parsed by the system automatically \u2014 your summary should restate decisions in readable form.
+
 ## Critical rules
 - NEVER start long-running processes (dev servers, watch modes, npm start, npm run dev, nodemon, tsc --watch, webpack serve, etc.). These block execution indefinitely.
 - NEVER run interactive commands that wait for user input.
@@ -532,45 +883,39 @@ Your task: ${story.description}
 - If you need to verify a server works, check that the code compiles or run a quick test \u2014 do NOT start the actual server.
 
 When you make a decision that affects other parts of the system, include ::decision:: markers in your output.
-When you learn something useful, include ::learning:: markers.
 When you create a file, include ::file_created::path markers.
-When you modify a file, include ::file_modified::path markers.${revisionFeedback ? `
+When you modify a file, include ::file_modified::path markers.
+${LEARNING_INSTRUCTIONS}${DOCKER_INSTRUCTIONS}${VERSION_TRUST}${revisionFeedback ? `
 
 ## Revision requested
 ${revisionFeedback}` : ""}`;
       try {
+        let allText = "";
         const stream = streamText({
           model,
           system: systemPrompt,
           prompt: story.description,
           tools: personaTools,
           stopWhen: stepCountIs(100),
-          abortSignal: AbortSignal.timeout(10 * 60 * 1e3)
-        });
-        let allText = "";
-        const storyPrefix = wmLogPrefix(story.persona);
-        let needsPrefix = true;
-        for await (const chunk of stream.textStream) {
-          if (chunk) {
-            allText += chunk;
-            if (chunk.includes("::decision::") || chunk.includes("::learning::") || chunk.includes("::file_created::") || chunk.includes("::file_modified::"))
-              continue;
-            spinner.stop();
-            if (needsPrefix) {
-              process.stdout.write(storyPrefix);
-              needsPrefix = false;
-            }
-            process.stdout.write(chalk.white(chunk));
-            if (chunk.endsWith("\n")) {
-              needsPrefix = true;
+          timeout: { totalMs: 10 * 60 * 1e3, chunkMs: 12e4 },
+          ...buildReasoningOptions(provider, modelName),
+          ...buildOllamaOptions(provider, contextLength),
+          onStepFinish({ text: text2 }) {
+            if (text2) {
+              spinner.stop();
+              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);
+              }
             }
           }
+        });
+        for await (const _chunk of stream.textStream) {
         }
-        if (!needsPrefix) {
-          process.stdout.write("\n");
-        }
-        const finalStreamText = await stream.text;
-        const text = finalStreamText && finalStreamText.length > allText.length ? finalStreamText : allText;
+        const text = await stream.text;
+        allText = text;
         const usage = await stream.totalUsage;
         spinner.stop();
         const decisionMatches = text.match(/::decision::(.*?)(?=::\w+::|$)/gs);
@@ -602,12 +947,17 @@ ${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!`);
+        wmLog(story.persona, `${story.title} \u2014 completed! (${i + 1}/${sorted.length})`);
         console.log();
         break;
       } catch (err) {
         spinner.stop();
-        printError(`Story ${i + 1} failed: ${err instanceof Error ? err.message : String(err)}`);
+        const errMsg = err instanceof Error ? err.message : String(err);
+        if (isTransientError(err) && revision < 2) {
+          wmLog(story.persona, `Transient error: ${errMsg} \u2014 retrying...`);
+          continue;
+        }
+        printError(`Story ${i + 1} failed: ${errMsg}`);
         break;
       }
     }
@@ -617,7 +967,7 @@ ${revisionFeedback}` : ""}`;
   const approvalThreshold = config.review?.approvalThreshold ?? 80;
   const reviewer = loadPersona("reviewer");
   if (reviewer) {
-    const { provider: revProvider, model: revModel, host: revHost } = getProviderForPersona(config, reviewer.provider || "reviewer");
+    const { provider: revProvider, model: revModel, host: revHost, contextLength: revCtx } = getProviderForPersona(config, reviewer.provider || "reviewer");
     const revApiKey = config.providers[revProvider]?.apiKey;
     if (revApiKey) {
       const envMap = { anthropic: "ANTHROPIC_API_KEY", openai: "OPENAI_API_KEY", google: "GOOGLE_API_KEY" };
@@ -626,68 +976,117 @@ ${revisionFeedback}` : ""}`;
       if (envVar && key && !process.env[envVar])
         process.env[envVar] = key;
     }
-    const reviewModel = createModel(revProvider, revModel, revHost);
+    const reviewModel = createModel(revProvider, revModel, revHost, revCtx);
     const reviewTools = createToolDefinitions(workingDir, reviewModel, sandboxed);
     const reviewerTools = {};
     for (const toolName of reviewer.tools) {
-      if (reviewTools[toolName]) {
-        reviewerTools[toolName] = reviewTools[toolName];
+      const toolDef = reviewTools[toolName];
+      if (toolDef) {
+        reviewerTools[toolName] = {
+          ...toolDef,
+          execute: async (input) => {
+            wmLog("tech_lead", formatToolCall(toolName, input));
+            const result = await toolDef.execute(input);
+            return result;
+          }
+        };
       }
     }
+    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: chalk.white(isRevision ? "Reviewer \u2014 Re-checking after revisions" : "Reviewer \u2014 Checking code quality"),
+        text: chalk3.white(isRevision ? "Reviewer \u2014 Re-checking after revisions" : "Reviewer \u2014 Checking code quality"),
         prefixText: "  "
       }).start();
       try {
-        const reviewPrompt = `Review the changes made by the following experts:
+        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:
+
+${previousReviewFeedback}
+
+**IMPORTANT: Check if ALL issues above have been addressed, not just some of them.**
+- The developer was instructed to fix every item
+- If ANY issue remains unaddressed, request another revision
+- Be specific about which items are still outstanding
+
+---
+
+` : "";
+        const storySummaryRows = sorted.map((s, idx) => {
+          const files = [...context.filesCreated, ...context.filesModified].slice(0, 3).join(", ") || "(none)";
+          return `| ${idx + 1} | ${s.persona} | ${s.title} | ${files} |`;
+        }).join("\n");
+        const reviewPrompt = `${previousFeedbackSection}## Original Task
+
+${userTask}
+
+## Story Summary
+
+| # | Persona | Title | Files |
+|---|---------|-------|-------|
+${storySummaryRows}
 
-${sorted.map((s, idx) => `${idx + 1}. ${s.persona}: ${s.title} \u2014 ${s.description}`).join("\n")}
+## Changes Made
 
 Files created: ${context.filesCreated.join(", ") || "none"}
 Files modified: ${context.filesModified.join(", ") || "none"}
+${context.decisions.length > 0 ? `
+Decisions made:
+${context.decisions.map((d) => `- ${d}`).join("\n")}` : ""}
+
+## Review Instructions
+
+Use read_file, glob, grep, and git tools to examine the actual code. Check:
+- Does the code correctly implement the original task requirements?
+- Are there bugs, logic errors, or security issues?
+- Does the code follow existing project conventions?
+- Is error handling appropriate?
+- Are there missing pieces from the task requirements?
 
-Use the read_file, glob, and grep tools to examine the actual changes. Look for:
-- Bugs or logic errors
-- Missing error handling
-- Security issues
-- Code that doesn't follow project conventions
-- Missing tests
+Use \`git diff\` or read individual files to see the actual changes.
 
 Provide a review with a quality score (0-100) using ::review_score:: marker and a verdict using ::review_verdict::approved or ::review_verdict::needs_revision.
-If there are issues, be specific about which files and what needs to change.`;
+
+### For REVISION_NEEDED Decisions - Specify Affected Stories
+
+When requesting revision, you MUST specify which stories need changes. Use the story numbers from the Story Summary table above.
+
+\`\`\`
+AFFECTED_STORIES: [2, 3]
+AFFECTED_REASONS: {"2": "Missing error handling in auth controller", "3": "Frontend form has no validation"}
+\`\`\`
+
+**Guidelines:**
+- 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 = "";
         const reviewStream = streamText({
           model: reviewModel,
           system: reviewer.systemPrompt,
           prompt: reviewPrompt,
           tools: reviewerTools,
           stopWhen: stepCountIs(100),
-          abortSignal: AbortSignal.timeout(5 * 60 * 1e3)
-        });
-        let allReviewText = "";
-        const revPrefix = wmLogPrefix("tech_lead");
-        let revNeedsPrefix = true;
-        for await (const chunk of reviewStream.textStream) {
-          if (chunk) {
-            allReviewText += chunk;
-            if (chunk.includes("::review_score::") || chunk.includes("::review_verdict::"))
-              continue;
-            reviewSpinner.stop();
-            if (revNeedsPrefix) {
-              process.stdout.write(revPrefix);
-              revNeedsPrefix = false;
+          timeout: { totalMs: 5 * 60 * 1e3, chunkMs: 12e4 },
+          ...buildOllamaOptions(revProvider, revCtx),
+          onStepFinish({ text }) {
+            if (text) {
+              reviewSpinner.stop();
+              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);
+              }
             }
-            process.stdout.write(chalk.white(chunk));
-            if (chunk.endsWith("\n"))
-              revNeedsPrefix = true;
           }
+        });
+        for await (const _chunk of reviewStream.textStream) {
         }
-        if (!revNeedsPrefix)
-          process.stdout.write("\n");
         const finalReviewText = await reviewStream.text;
         const reviewText = finalReviewText && finalReviewText.length > allReviewText.length ? finalReviewText : allReviewText;
         const reviewUsage = await reviewStream.totalUsage;
@@ -697,36 +1096,54 @@ If there are issues, be specific about which files and what needs to change.`;
         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)`);
+        previousReviewFeedback = reviewText;
         console.log();
         costTracker.addUsage(`Reviewer (round ${reviewRound + 1})`, revProvider, revModel, reviewUsage?.inputTokens || 0, reviewUsage?.outputTokens || 0);
         if (approved)
           break;
         if (reviewRound >= maxRevisions) {
-          console.log(chalk.yellow(`  \u26A0 Max review revisions (${maxRevisions}) reached`));
+          console.log(chalk3.yellow(`  \u26A0 Max review revisions (${maxRevisions}) reached`));
           break;
         }
         let shouldRevise = autoRevise;
         if (!autoRevise) {
           try {
-            const answer = await permissions.askUser(chalk.dim("  Revise and re-review? ") + chalk.white(`(y/n, ${maxRevisions - reviewRound} attempt${maxRevisions - reviewRound > 1 ? "s" : ""} left): `));
+            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";
           } catch {
             shouldRevise = false;
           }
         } else {
-          console.log(chalk.dim(`  Auto-revising (${maxRevisions - reviewRound} attempt${maxRevisions - reviewRound > 1 ? "s" : ""} left)...`));
+          console.log(chalk3.dim(`  Auto-revising (${maxRevisions - reviewRound} attempt${maxRevisions - reviewRound > 1 ? "s" : ""} left)...`));
         }
         if (!shouldRevise) {
-          console.log(chalk.dim("  Skipping revision, proceeding to commit."));
+          console.log(chalk3.dim("  Skipping revision, proceeding to commit."));
           break;
         }
-        console.log(chalk.bold("\n  \u2500\u2500\u2500 Revision Pass \u2500\u2500\u2500\n"));
+        const affected = parseAffectedStories(reviewText);
+        const affectedSet = affected ? new Set(affected.stories) : null;
+        if (affected) {
+          const selectiveInfo = `stories ${affected.stories.join(", ")}`;
+          wmCoordinatorLog(`Selective revision: ${selectiveInfo}`);
+          if (Object.keys(affected.reasons).length > 0) {
+            for (const [idx, reason] of Object.entries(affected.reasons)) {
+              wmCoordinatorLog(`  Story ${idx}: ${reason}`);
+            }
+          }
+        } else {
+          wmCoordinatorLog("Full revision (all stories)");
+        }
+        console.log(chalk3.bold("\n  \u2500\u2500\u2500 Revision Pass \u2500\u2500\u2500\n"));
         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`);
+            continue;
+          }
           const storyPersona = loadPersona(story.persona);
           if (!storyPersona)
             continue;
-          const { provider: sProvider, model: sModel, host: sHost } = getProviderForPersona(config, storyPersona.provider || story.persona);
+          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) {
@@ -739,12 +1156,15 @@ If there are issues, be specific about which files and what needs to change.`;
               }
             }
           }
+          wmCoordinatorLog(`Revision pass for story ${i + 1}/${sorted.length}`);
+          wmLog(story.persona, `Starting revision: ${story.title}`);
           const revSpinner = ora({
             stream: process.stdout,
-            text: chalk.white(`Revising ${i + 1}/${sorted.length} \u2014 ${storyPersona.name} \u2014 ${story.title}`),
-            prefixText: "  "
+            text: "",
+            prefixText: "",
+            spinner: "dots"
           }).start();
-          const storyModel = createModel(sProvider, sModel, sHost);
+          const storyModel = createModel(sProvider, sModel, sHost, sCtx);
           const storyAllTools = createToolDefinitions(workingDir, storyModel, sandboxed);
           const storyTools = {};
           for (const toolName of storyPersona.tools) {
@@ -757,10 +1177,8 @@ If there are issues, be specific about which files and what needs to change.`;
                   if (!allowed)
                     return "Tool execution denied by user.";
                   revSpinner.stop();
-                  printToolCall(toolName, input);
+                  wmLog(story.persona, formatToolCall(toolName, input));
                   const result = await toolDef.execute(input);
-                  const resultStr = typeof result === "string" ? result : JSON.stringify(result);
-                  printToolResult(toolName, resultStr);
                   revSpinner.start();
                   return result;
                 }
@@ -771,6 +1189,10 @@ If there are issues, be specific about which files and what needs to change.`;
 
 Working directory: ${workingDir}
 
+## Communication Style
+
+Write in a professional, direct tone. Do NOT open messages with filler words or pleasantries like "Perfect!", "Great!", "Awesome!", "Sure!", "Absolutely!", or similar. Start with the substance \u2014 what you did, what you found, or what you need. Be concise and informative. Do NOT repeat what you said in previous steps \u2014 each response should add new information only.
+
 ## Critical rules
 - NEVER start long-running processes (dev servers, watch modes, npm start, npm run dev, nodemon, tsc --watch, etc.)
 - NEVER run interactive commands that wait for user input
@@ -789,7 +1211,20 @@ Your task: Address the reviewer's feedback for "${story.title}". Fix the specifi
 ${story.description}`,
               tools: storyTools,
               stopWhen: stepCountIs(100),
-              abortSignal: AbortSignal.timeout(5 * 60 * 1e3)
+              timeout: { totalMs: 5 * 60 * 1e3, chunkMs: 12e4 },
+              ...buildReasoningOptions(sProvider, sModel),
+              ...buildOllamaOptions(sProvider, sCtx),
+              onStepFinish({ text }) {
+                if (text) {
+                  revSpinner.stop();
+                  const lines = text.split("\n").filter((l) => l.trim());
+                  for (const line of lines) {
+                    if (line.includes("::"))
+                      continue;
+                    wmLog(story.persona, line);
+                  }
+                }
+              }
             });
             for await (const _chunk of revStream.textStream) {
             }
@@ -799,74 +1234,74 @@ ${story.description}`,
             wmLog(story.persona, `${story.title} \u2014 revision complete!`);
           } catch (err) {
             revSpinner.stop();
-            console.log(chalk.yellow(`  \u26A0 Revision failed for story ${i + 1}: ${err instanceof Error ? err.message : String(err)}`));
+            console.log(chalk3.yellow(`  \u26A0 Revision failed for story ${i + 1}: ${err instanceof Error ? err.message : String(err)}`));
           }
         }
         console.log();
       } catch (err) {
         reviewSpinner.stop();
-        console.log(chalk.yellow(`  \u26A0 Review skipped: ${err instanceof Error ? err.message : String(err)}`));
+        console.log(chalk3.yellow(`  \u26A0 Review skipped: ${err instanceof Error ? err.message : String(err)}`));
         console.log();
         break;
       }
     }
   }
   try {
-    const { execSync } = await import("child_process");
+    const { execSync: execSync2 } = await import("child_process");
     try {
-      execSync("git rev-parse --git-dir", { cwd: workingDir, encoding: "utf-8", stdio: "pipe" });
+      execSync2("git rev-parse --git-dir", { cwd: workingDir, encoding: "utf-8", stdio: "pipe" });
     } catch {
       wmCoordinatorLog("Initializing git repository...");
-      execSync("git init", { cwd: workingDir, encoding: "utf-8", stdio: "pipe" });
-      const fs2 = await import("fs");
+      execSync2("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");
     }
-    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 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 hasChanges = diff || untracked;
     if (hasChanges) {
-      console.log(chalk.bold("  \u2500\u2500\u2500 Changes \u2500\u2500\u2500"));
+      console.log(chalk3.bold("  \u2500\u2500\u2500 Changes \u2500\u2500\u2500"));
       if (diff) {
-        console.log(chalk.dim("  " + diff.split("\n").join("\n  ")));
+        console.log(chalk3.dim("  " + diff.split("\n").join("\n  ")));
       }
       if (untracked) {
         const untrackedFiles = untracked.split("\n");
-        console.log(chalk.dim("  New files:"));
+        console.log(chalk3.dim("  New files:"));
         for (const f of untrackedFiles) {
-          console.log(chalk.dim(`    + ${f}`));
+          console.log(chalk3.dim(`    + ${f}`));
         }
       }
       console.log();
       if (!trustAll) {
-        const answer = await permissions.askUser(chalk.dim("  Commit these changes? (y/n): "));
+        const answer = await permissions.askUser(chalk3.dim("  Commit these changes? (y/n): "));
         if (answer.trim().toLowerCase() === "y" || answer.trim().toLowerCase() === "yes") {
           const filesToStage = [...context.filesCreated, ...context.filesModified].filter(Boolean);
           if (filesToStage.length > 0) {
             for (const f of filesToStage) {
               try {
-                execSync(`git add "${f}"`, { cwd: workingDir, stdio: "pipe" });
+                execSync2(`git add "${f}"`, { cwd: workingDir, stdio: "pipe" });
               } catch {
               }
             }
           } else {
-            execSync("git add -u", { cwd: workingDir, stdio: "pipe" });
+            execSync2("git add -u", { cwd: workingDir, stdio: "pipe" });
           }
           const storyTitles = sorted.map((s) => s.title).join(", ");
           const msg = `feat: ${storyTitles}`.slice(0, 72);
-          execSync(`git commit -m "${msg.replace(/"/g, '\\"')}"`, { cwd: workingDir, stdio: "pipe" });
-          console.log(chalk.green("  \u2713 Changes committed"));
+          execSync2(`git commit -m "${msg.replace(/"/g, '\\"')}"`, { cwd: workingDir, stdio: "pipe" });
+          console.log(chalk3.green("  \u2713 Changes committed"));
         }
       }
     }
   } catch (err) {
   }
-  console.log(chalk.bold("  \u2500\u2500\u2500 Session Complete \u2500\u2500\u2500"));
+  console.log(chalk3.bold("  \u2500\u2500\u2500 Session Complete \u2500\u2500\u2500"));
   console.log();
-  console.log(chalk.dim("  " + costTracker.getSummary().split("\n").join("\n  ")));
+  console.log(chalk3.dim("  " + costTracker.getSummary().split("\n").join("\n  ")));
   console.log();
 }
 export {