wayang-ai 0.9.3 → 0.9.4

package/dist/cli.js

@@ -1457,7 +1457,7 @@ function validateWorkerEntry(id, worker) {
     return `${at}.emoji must be a string (got ${JSON.stringify(worker.emoji)})`;
   }
   if (type === "claude-code") {
-    for (const key of ["command", "args", "env", "protocol", "trustUpdatesAfterCancel"]) {
+    for (const key of ["command", "args", "env", "protocol", "trustUpdatesAfterCancel", "mcp"]) {
       if (worker[key] !== void 0) {
         return `${at}.${key} is not supported for type "claude-code" (claude-code uses cliPath)`;
       }
@@ -1473,6 +1473,22 @@ function validateWorkerEntry(id, worker) {
     if (worker.trustUpdatesAfterCancel !== void 0 && typeof worker.trustUpdatesAfterCancel !== "boolean") {
       return `${at}.trustUpdatesAfterCancel must be a boolean (got ${JSON.stringify(worker.trustUpdatesAfterCancel)})`;
     }
+    const mcp = worker.mcp;
+    if (mcp !== void 0) {
+      if (typeof mcp !== "object" || mcp === null || Array.isArray(mcp)) {
+        return `${at}.mcp must be an object (got ${JSON.stringify(mcp)})`;
+      }
+      const record = mcp;
+      for (const key of Object.keys(record)) {
+        if (key !== "enabled" && key !== "fallbackMs") return `${at}.mcp.${key} is not a known option (allowed: enabled, fallbackMs)`;
+      }
+      if (record.enabled !== void 0 && typeof record.enabled !== "boolean") {
+        return `${at}.mcp.enabled must be a boolean (got ${JSON.stringify(record.enabled)})`;
+      }
+      if (record.fallbackMs !== void 0 && !(typeof record.fallbackMs === "number" && Number.isFinite(record.fallbackMs) && record.fallbackMs > 0)) {
+        return `${at}.mcp.fallbackMs must be a positive number (got ${JSON.stringify(record.fallbackMs)})`;
+      }
+    }
     if (worker.args !== void 0 && (!Array.isArray(worker.args) || worker.args.some((a) => typeof a !== "string"))) {
       return `${at}.args must be an array of strings (got ${JSON.stringify(worker.args)})`;
     }
@@ -5694,7 +5710,7 @@ function AppContent() {
 // package.json
 var package_default = {
   name: "wayang-ai",
-  version: "0.9.3",
+  version: "0.9.4",
   description: "Multi-agent orchestration platform",
   type: "module",
   license: "MIT",
@@ -8051,7 +8067,8 @@ function buildWorkerSystemPrompt(ctx, skills, workspaceDir2) {
 var RULES = [
   "<Rules>",
   "Output plain text only. No Markdown formatting.",
-  "Report meaningful progress as you work (entering a new phase, completing a sub-step, recovering from an error).",
+  "Report meaningful progress as you work (entering a new phase, completing a sub-step, recovering from an error). When an update_progress tool is available it is the primary channel \u2014 call it with a concise message; plain assistant text is only a degraded fallback.",
+  "If no update_progress is reported for 2 minutes, the system reports your latest complete reply automatically (capped at 20000 characters), so keep reporting progress yourself to stay in control of what the controller sees.",
   "Do NOT output a final summary right before completing \u2014 the system already captures the result separately.",
   "Match the language of the task description.",
   "Keep scratch files and intermediate artifacts in `.agents/tmp/` inside the task workspace \u2014 never `/tmp`, the home directory, or the repository root.",
@@ -12389,7 +12406,7 @@ var AcpClient = class {
       () => new AcpError("agent-error", `authenticate(${methodId}): no response within ${this.timeouts.handshakeMs}ms`)
     );
   }
-  /** mcpServers is required by the v1 schema; 0.9.0 always passes []. Unknown response fields are ignored. */
+  /** mcpServers is required by the v1 schema; the worker layer passes its injection (or [] on degrade). Unknown response fields are ignored. */
   async sessionNew(input2) {
     const raw = await this.rpcRequest(
       "session/new",
@@ -12658,10 +12675,7 @@ function mapSessionUpdate(update, acc) {
     const { content, messageId } = update;
     const text = content && content.type === "text" ? content.text : "";
     if (!text) return [{ kind: "ignored", variant, reason: "empty-chunk" }];
-    return [
-      { kind: "agent-text", text, messageId: messageId ?? null },
-      { kind: "progress", text }
-    ];
+    return [{ kind: "agent-text", text, messageId: messageId ?? null }];
   }
   if (variant === "agent_thought_chunk") {
     return [{ kind: "ignored", variant, reason: "thought" }];
@@ -12709,6 +12723,48 @@ function mapSessionUpdate(update, acc) {
   return [{ kind: "ignored", variant, reason: "unknown-variant" }];
 }
 
+// src/services/agents/acp/mcp-schemas.ts
+var MCP_SERVER_NAME = "wayang";
+var MCP_PROTOCOL_VERSION = "2025-06-18";
+var MAX_PROGRESS_CHARS = 2e4;
+var MAX_QUESTION_CHARS = 500;
+var MAX_CONTEXT_CHARS = 1e3;
+var TRUNCATION_MARKER = "\n\u2026[truncated]";
+var PROGRESS_FALLBACK_MS = 6e4;
+var MCP_PROGRESS_TIMEOUT_MS = 5e3;
+var MCP_ASK_TIMEOUT_MS = 31e4;
+var MCP_TOOLS = [
+  {
+    name: "update_progress",
+    description: "Report progress for the current task. This is the PRIMARY progress channel: call it when entering a new phase, finishing a sub-deliverable, recovering from an error. Do not rely on session/update text \u2014 it is only a degraded fallback.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        message: { type: "string", maxLength: MAX_PROGRESS_CHARS, description: "Progress description" }
+      },
+      required: ["message"],
+      additionalProperties: false
+    }
+  },
+  {
+    name: "ask_controller",
+    description: "Ask the controller a question and WAIT for the answer. Use ONLY when blocked: execution cannot continue as instructed (contradiction, missing resource, unexpected state), or continuing would risk significant wasted work. Do NOT use it for decisions you can make yourself \u2014 decide those autonomously and report via update_progress.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        question: { type: "string", maxLength: MAX_QUESTION_CHARS, description: "The specific question you need answered to proceed. Be concise and self-contained." },
+        context: { type: "string", maxLength: MAX_CONTEXT_CHARS, description: "What you have tried and where you are stuck, so the controller can answer precisely." }
+      },
+      required: ["question"],
+      additionalProperties: false
+    }
+  }
+];
+var MCP_TOOL_NAMES = MCP_TOOLS.map((tool2) => tool2.name);
+function capText(text, max = MAX_PROGRESS_CHARS) {
+  return text.length > max ? `${text.slice(0, max)}${TRUNCATION_MARKER}` : text;
+}
+
 // src/services/agents/acp/permission-bridge.ts
 var ACP_PERMISSION_TIMEOUT_MS = 3e5;
 function pathFromSnapshot(snapshot) {
@@ -12733,7 +12789,37 @@ function commandFromSnapshot(snapshot) {
   if (Array.isArray(cmd)) return cmd.every((part) => typeof part === "string") ? cmd.join(" ") : void 0;
   return void 0;
 }
+var SAFE_WAYANG_MCP_TOOLS = /* @__PURE__ */ new Set([
+  "update_progress",
+  "ask_controller"
+]);
+function mcpToolIdentity(name) {
+  const lower = name.trim().toLowerCase();
+  if (lower.startsWith("mcp__")) {
+    const rest = lower.slice("mcp__".length);
+    const sep2 = rest.lastIndexOf("__");
+    if (sep2 <= 0 || sep2 + 2 >= rest.length) return void 0;
+    return { server: rest.slice(0, sep2), tool: rest.slice(sep2 + 2) };
+  }
+  const qualified = /^([a-z0-9_]+)[.-]([a-z0-9_]+)$/.exec(lower);
+  return qualified ? { server: qualified[1], tool: qualified[2] } : void 0;
+}
+function safeOwnMcpTool(snapshot) {
+  const raw = snapshot.rawInput;
+  const declared = raw && typeof raw === "object" && !Array.isArray(raw) ? raw.toolName : void 0;
+  for (const candidate of [snapshot.name, declared]) {
+    if (typeof candidate !== "string" || candidate.length === 0) continue;
+    const identity = mcpToolIdentity(candidate);
+    if (!identity || identity.server !== MCP_SERVER_NAME) continue;
+    const tool2 = identity.tool;
+    if (SAFE_WAYANG_MCP_TOOLS.has(tool2)) return tool2;
+  }
+  return void 0;
+}
 function classifyAcpToolCall(snapshot) {
+  if (safeOwnMcpTool(snapshot) !== void 0) {
+    return { type: "direct-allow", reason: "wayang MCP controller-facing tool" };
+  }
   const kind = snapshot.kind;
   if (kind === "fetch" || kind === "think" || kind === "switch_mode") {
     return { type: "direct-allow", reason: `non-path kind "${kind}"` };
@@ -13033,6 +13119,14 @@ var AcpTurnWriter = class {
   lastText() {
     return this.lastFlushedText;
   }
+  /**
+   * Read-only view of the OPEN text segment: every `agent-text` chunk the run
+   * has aggregated since the last flush. This is the single text source for
+   * progress reporting (the degraded path must never keep a second copy).
+   */
+  openText() {
+    return this.openTextParts.join("");
+  }
   /**
    * Buffer a tool call. A same-id record (running → terminal evolution of one
    * call) replaces the previous one inside its owning step instead of piling
@@ -13418,9 +13512,10 @@ var BaseAcpWorker = class {
   _grants = new ApprovalMemory();
   _approvalMemory = "task";
   _currentTurnEnv = null;
-  // --- Progress debounce ---
-  _progressTimer = null;
-  _pendingProgress = null;
+  // --- Progress (update_progress is primary; the idle tracker is the net) ---
+  _onProgress = null;
+  /** Engine-backed inquiry channel, exposed to the agent as ask_controller. */
+  _askController = null;
   // --- ACP runtime (per run) ---
   _accumulator = createAcpToolAccumulator();
   _turnWriter;
@@ -13558,6 +13653,14 @@ var BaseAcpWorker = class {
     this._grants = deps.grants ?? new ApprovalMemory();
     this._approvalMemory = deps.approvalMemory ?? "task";
   }
+  /**
+   * Wire the engine-backed ask_controller implementation. The per-run Wayang
+   * MCP bridge serves it over a Unix socket (member presence is what the
+   * engine's `wireWorker` probe detects, as with ClaudeCodeWorker).
+   */
+  setInquirySupport(ask) {
+    this._askController = ask;
+  }
   getState() {
     return this.state;
   }
@@ -13620,13 +13723,6 @@ var BaseAcpWorker = class {
     const prev = this.state.get("runtimeState") ?? {};
     this.state.set("runtimeState", { ...prev, acp: { ...prev.acp ?? {}, ...fields } });
   }
-  clearPendingProgress() {
-    if (this._progressTimer) {
-      clearTimeout(this._progressTimer);
-      this._progressTimer = null;
-    }
-    this._pendingProgress = null;
-  }
 };
 
 // src/services/agents/acp/acp-worker-run.ts
@@ -13670,13 +13766,678 @@ function makeTerminalResult(category, verdictReason, denials, summary, stopReaso
   return { status: "failed", error };
 }
 
+// src/services/agents/acp/mcp-transport.ts
+import { createServer } from "net";
+import { chmodSync, existsSync as existsSync11, mkdirSync as mkdirSync8, unlinkSync as unlinkSync4 } from "fs";
+import { dirname as dirname9, join as join18 } from "path";
+import { fileURLToPath } from "url";
+import { randomBytes, timingSafeEqual } from "crypto";
+
+// src/services/agents/acp/mcp-protocol.ts
+function mcpResult(id, result2) {
+  return { jsonrpc: "2.0", id, result: result2 };
+}
+function mcpError(id, code, message) {
+  return { jsonrpc: "2.0", id, error: { code, message } };
+}
+function mcpToolResultPayload(call) {
+  return {
+    content: [{ type: "text", text: call.text }],
+    ...call.isError ? { isError: true } : {}
+  };
+}
+function createMcpDispatcher(invoker, serverInfo) {
+  return async (frame) => {
+    const method = typeof frame.method === "string" ? frame.method : "";
+    if (frame.id === void 0 || frame.id === null || method.startsWith("notifications/")) return null;
+    const id = frame.id;
+    switch (method) {
+      case "initialize":
+        return mcpResult(id, {
+          protocolVersion: MCP_PROTOCOL_VERSION,
+          capabilities: { tools: {} },
+          serverInfo
+        });
+      case "ping":
+        return mcpResult(id, {});
+      case "tools/list":
+        return mcpResult(id, { tools: MCP_TOOLS });
+      case "tools/call": {
+        const params = frame.params ?? {};
+        const name = typeof params.name === "string" ? params.name : "";
+        if (!MCP_TOOL_NAMES.includes(name)) {
+          return mcpError(id, -32602, `unknown tool "${name}" (available: ${MCP_TOOL_NAMES.join(", ")})`);
+        }
+        const args = params.arguments && typeof params.arguments === "object" ? params.arguments : {};
+        try {
+          const call = await invoker(name, args);
+          return mcpResult(id, mcpToolResultPayload(call));
+        } catch (err) {
+          const message = err instanceof Error ? err.message : String(err);
+          return mcpResult(id, mcpToolResultPayload({ text: `[MCP ERROR] ${message}`, isError: true }));
+        }
+      }
+      default:
+        return mcpError(id, -32601, `method not found: ${method || "(missing)"}`);
+    }
+  };
+}
+var DEFAULT_MCP_SERVER_INFO = { name: MCP_SERVER_NAME, version: "wayang" };
+
+// src/services/agents/acp/mcp-transport.ts
+var MCP_ENV_SOCKET = "WAYANG_MCP_SOCK";
+var MCP_ENV_TOKEN = "WAYANG_MCP_TOKEN";
+var MCP_ENV_WORKER_ID = "WAYANG_MCP_WORKER_ID";
+var MCP_HANDSHAKE_TIMEOUT_MS = 1e4;
+var MCP_MAX_CONNECTIONS = 4;
+function generateMcpToken() {
+  return randomBytes(32).toString("hex");
+}
+function mcpSocketPathFor(sessionDir, workerId, suffix) {
+  return join18(sessionDir, ".mcp", `acp-mcp-${workerId}-${suffix}.sock`);
+}
+function resolveMcpBridgeEntryPath(importMetaUrl) {
+  const dir = dirname9(fileURLToPath(importMetaUrl));
+  const candidates = [
+    join18(dir, "mcp-bridge-entry.js"),
+    join18(dir, "services/agents/acp/mcp-bridge-entry.js"),
+    join18(dir, "mcp-bridge-entry.ts")
+  ];
+  return candidates.find((candidate) => existsSync11(candidate)) ?? candidates[0];
+}
+function safeEqualToken(expected, actual) {
+  if (typeof actual !== "string") return false;
+  const a = Buffer.from(expected, "utf8");
+  const b = Buffer.from(actual, "utf8");
+  return a.length === b.length && timingSafeEqual(a, b);
+}
+function stopBridgeProcesses(pids, logger, workerId) {
+  const alive = [...pids].filter((pid) => pid > 0 && pid !== process.pid);
+  if (alive.length === 0) return;
+  for (const pid of alive) {
+    try {
+      process.kill(pid, "SIGTERM");
+    } catch {
+    }
+  }
+  const ladder = setTimeout(() => {
+    for (const pid of alive) {
+      try {
+        process.kill(pid, 0);
+        process.kill(pid, "SIGKILL");
+      } catch {
+      }
+    }
+  }, 2e3);
+  ladder.unref?.();
+  logger.debug({ workerId, count: alive.length, reason: "bridge-cleanup" }, "ACP MCP bridge processes signalled");
+}
+async function startMcpHost(opts) {
+  const dir = dirname9(opts.socketPath);
+  mkdirSync8(dir, { recursive: true, mode: 448 });
+  chmodSync(dir, 448);
+  try {
+    unlinkSync4(opts.socketPath);
+  } catch (err) {
+    if (err.code !== "ENOENT") throw err;
+  }
+  let closed = false;
+  let ready = false;
+  let resolveReady = () => void 0;
+  const readyPromise = new Promise((resolve15) => {
+    resolveReady = resolve15;
+  });
+  const connections = /* @__PURE__ */ new Set();
+  const bridgePids = /* @__PURE__ */ new Set();
+  const handshakeTimer = setTimeout(() => {
+    if (!closed && !ready) {
+      opts.logger.warn({ workerId: opts.workerId, reason: "mcp-handshake-timeout" }, "ACP MCP bridge did not connect");
+      resolveReady(false);
+    }
+  }, opts.handshakeTimeoutMs ?? MCP_HANDSHAKE_TIMEOUT_MS);
+  handshakeTimer.unref?.();
+  const dispatcher = createMcpDispatcher(
+    (name, args) => opts.invoker.invoke(name, args),
+    opts.serverInfo ?? DEFAULT_MCP_SERVER_INFO
+  );
+  const handleFrame = async (frame, socket) => {
+    if (closed || typeof frame.method !== "string") return;
+    try {
+      const response = await dispatcher(frame);
+      if (response && !socket.destroyed) {
+        socket.write(`${JSON.stringify(response)}
+`);
+      }
+    } catch (err) {
+      opts.logger.debug({ workerId: opts.workerId, err, reason: "mcp-dispatch" }, "ACP MCP request failed");
+    }
+  };
+  const accept = (socket) => {
+    if (closed || connections.size >= MCP_MAX_CONNECTIONS) {
+      socket.destroy();
+      return;
+    }
+    connections.add(socket);
+    socket.unref?.();
+    const codec = new LineCodec();
+    let helloChecked = false;
+    socket.setEncoding("utf8");
+    socket.on("data", (chunk) => {
+      const frames = codec.push(chunk);
+      for (const frame of frames) {
+        if (!helloChecked) {
+          helloChecked = true;
+          const params = frame?.params ?? {};
+          const valid = frame?.method === "hello" && params.workerId === opts.workerId && safeEqualToken(opts.token, params.token);
+          if (!valid) {
+            opts.logger.warn({ workerId: opts.workerId, reason: "mcp-hello-rejected" }, "ACP MCP bridge hello rejected");
+            socket.destroy();
+            return;
+          }
+          const pid = Number(params.pid);
+          if (Number.isInteger(pid) && pid > 0) bridgePids.add(pid);
+          ready = true;
+          clearTimeout(handshakeTimer);
+          resolveReady(true);
+          continue;
+        }
+        void handleFrame(frame, socket);
+      }
+    });
+    socket.on("close", () => connections.delete(socket));
+    socket.on("error", () => {
+    });
+  };
+  const server = createServer(accept);
+  await new Promise((resolve15, reject) => {
+    const onError = (err) => reject(err);
+    server.once("error", onError);
+    server.listen(opts.socketPath, () => {
+      server.off("error", onError);
+      resolve15();
+    });
+  });
+  chmodSync(opts.socketPath, 384);
+  server.unref();
+  const close = async () => {
+    if (closed) return;
+    closed = true;
+    clearTimeout(handshakeTimer);
+    if (!ready) resolveReady(false);
+    opts.invoker.settlePending();
+    await new Promise((resolve15) => setImmediate(resolve15));
+    for (const socket of connections) socket.destroy();
+    connections.clear();
+    await new Promise((resolve15) => {
+      if (!server.listening) return resolve15();
+      server.close(() => resolve15());
+    });
+    try {
+      unlinkSync4(opts.socketPath);
+    } catch {
+    }
+    stopBridgeProcesses(bridgePids, opts.logger, opts.workerId);
+  };
+  return { ready: readyPromise, isReady: () => ready && !closed, close };
+}
+function buildMcpServerDescriptor(opts) {
+  return {
+    name: MCP_SERVER_NAME,
+    command: opts.nodeExecutable ?? process.execPath,
+    args: [opts.bridgeEntryPath],
+    env: [
+      { name: MCP_ENV_SOCKET, value: opts.socketPath },
+      { name: MCP_ENV_TOKEN, value: opts.token },
+      { name: MCP_ENV_WORKER_ID, value: opts.workerId }
+    ]
+  };
+}
+async function startStdioMcpTransport(opts) {
+  const socketPath = mcpSocketPathFor(opts.sessionDir, opts.workerId, generateMcpToken().slice(0, 12));
+  const token = generateMcpToken();
+  const bridgeEntryPath = resolveMcpBridgeEntryPath(import.meta.url);
+  const host = await startMcpHost({
+    socketPath,
+    token,
+    workerId: opts.workerId,
+    invoker: opts.invoker,
+    logger: opts.logger,
+    serverInfo: opts.serverInfo
+  });
+  return {
+    descriptor: buildMcpServerDescriptor({ socketPath, token, workerId: opts.workerId, bridgeEntryPath }),
+    ready: host.ready,
+    isReady: host.isReady,
+    close: host.close
+  };
+}
+
+// src/services/agents/acp/mcp-progress-fallback.ts
+function isAfter(a, b) {
+  return a.turn > b.turn || a.turn === b.turn && a.chars > b.chars;
+}
+var McpProgressTracker = class {
+  canFire;
+  emit;
+  now;
+  idleMs;
+  maxChars;
+  timer = null;
+  lastProgressAt = 0;
+  /** The latest complete entry handed by the run layer (single slot). */
+  reply = null;
+  /**
+   * Everything up to here counts as reported — by a real `update_progress`
+   * (to the CURRENT position) or by the fallback itself (to the entry it
+   * emitted). A candidate at/before this line is stale.
+   */
+  watermark = { turn: 0, chars: 0 };
+  constructor(opts) {
+    this.canFire = opts.canFire;
+    this.emit = opts.emit;
+    this.idleMs = opts.idleMs ?? PROGRESS_FALLBACK_MS;
+    this.maxChars = opts.maxChars ?? MAX_PROGRESS_CHARS;
+    this.now = opts.now ?? (() => Date.now());
+  }
+  setIdleMs(ms) {
+    this.idleMs = ms > 0 ? ms : PROGRESS_FALLBACK_MS;
+  }
+  /** Task start: fresh state and a fresh idle window. */
+  start() {
+    this.stop();
+    this.reply = null;
+    this.watermark = { turn: 0, chars: 0 };
+    this.lastProgressAt = this.now();
+    this.arm();
+  }
+  stop() {
+    if (this.timer) {
+      clearTimeout(this.timer);
+      this.timer = null;
+    }
+  }
+  /**
+   * A real update_progress resets the idle window and advances the watermark
+   * to the current position: everything produced so far counts as reported,
+   * so a later window must not re-announce it. The MCP channel carries no
+   * message id and takes no part in any dedupe.
+   */
+  noteProgress(position) {
+    if (isAfter(position, this.watermark)) this.watermark = position;
+    this.lastProgressAt = this.now();
+    this.arm();
+  }
+  /** New prompt / turn start: new idle window. Emits nothing by itself. */
+  noteNewMessage() {
+    this.lastProgressAt = this.now();
+    this.arm();
+  }
+  /** Turn end resets the idle window. Emits nothing by itself. */
+  noteTurnEnd() {
+    this.lastProgressAt = this.now();
+    this.arm();
+  }
+  /**
+   * One complete entry flushed to the transcript (a tool call closed the open
+   * segment, or the turn ended). The text IS the writer's own aggregation —
+   * this tracker never joins chunks and never keeps more than the latest
+   * entry. Sealing never emits anything.
+   */
+  noteReplySealed(text, position) {
+    this.reply = { text, position };
+  }
+  /**
+   * Report the latest complete, never-reported entry NOW (turn end on the
+   * degraded path — no need to wait out the idle window). Verbatim, capped at
+   * maxChars; never a join, never a summary. Returns whether anything was
+   * emitted; either way the idle window restarts.
+   */
+  flush() {
+    if (!this.canFire()) return false;
+    const reply = this.reply;
+    this.lastProgressAt = this.now();
+    if (!reply || !isAfter(reply.position, this.watermark)) {
+      this.arm();
+      return false;
+    }
+    this.watermark = reply.position;
+    this.emit(capText(reply.text, this.maxChars), "fallback");
+    this.arm();
+    return true;
+  }
+  arm() {
+    this.stop();
+    if (!this.canFire()) return;
+    const remaining = Math.max(0, this.idleMs - (this.now() - this.lastProgressAt));
+    this.timer = setTimeout(() => this.fire(), remaining);
+    this.timer.unref?.();
+  }
+  fire() {
+    this.timer = null;
+    if (!this.canFire()) return;
+    if (this.now() - this.lastProgressAt < this.idleMs) {
+      this.arm();
+      return;
+    }
+    this.flush();
+  }
+};
+
+// src/services/agents/acp/acp-progress.ts
+var PROGRESS_FILLER_RE = /[\s\p{P}]/gu;
+function hasProgressSubstance(text) {
+  return text.replace(PROGRESS_FILLER_RE, "").length > 0;
+}
+var AcpProgress = class {
+  tracker;
+  deps;
+  constructor(deps) {
+    this.deps = deps;
+    this.tracker = new McpProgressTracker({
+      canFire: deps.canFire,
+      emit: (message) => deps.onProgress(message),
+      ...deps.idleMs !== void 0 && { idleMs: deps.idleMs }
+    });
+  }
+  /** Task start: fresh tracker state and a fresh idle window. */
+  start() {
+    this.tracker.start();
+  }
+  /** Run finally / abort / loop exit: never report after this. */
+  stop() {
+    this.tracker.stop();
+  }
+  /** New prompt / turn start: new idle window. */
+  noteNewMessage() {
+    this.tracker.noteNewMessage();
+  }
+  /** Turn end resets the idle window. */
+  noteTurnEnd() {
+    this.tracker.noteTurnEnd();
+  }
+  /**
+   * Single choke point for a real `update_progress` (the MCP tool layer calls
+   * this). Guards FIRST — a late tool call must not re-arm the idle timer
+   * either — then advance the watermark to the current position: everything
+   * produced so far counts as announced.
+   */
+  report(message) {
+    if (!this.deps.canFire()) return;
+    this.tracker.noteProgress(this.deps.position());
+    this.deps.onProgress(capText(message));
+  }
+  /**
+   * One complete entry flushed to the transcript (a tool call closed the open
+   * segment, or the turn ended and finishTurn wrote it): hand it to the
+   * tracker as the fallback candidate. Recording never emits anything.
+   */
+  recordReply() {
+    if (!this.deps.canFire()) return;
+    const text = this.deps.writer.lastText();
+    if (text === null || text.length === 0) return;
+    if (!hasProgressSubstance(text)) return;
+    this.tracker.noteReplySealed(text, this.deps.position());
+  }
+  /**
+   * Turn-end catch-up on the degraded path: report the latest complete,
+   * never-reported entry NOW instead of waiting out the idle window.
+   */
+  flush() {
+    return this.tracker.flush();
+  }
+};
+
+// src/services/agents/acp/mcp-tools.ts
+var TIMED_OUT = /* @__PURE__ */ Symbol("wayang-mcp-tool-timeout");
+var ABORTED = /* @__PURE__ */ Symbol("wayang-mcp-tool-aborted");
+function withTimeout(work, ms, pending) {
+  return new Promise((resolve15, reject) => {
+    let done = false;
+    const finish = (value) => {
+      if (done) return;
+      done = true;
+      clearTimeout(timer);
+      pending.delete(cancel);
+      resolve15(value);
+    };
+    const fail = (err) => {
+      if (done) return;
+      done = true;
+      clearTimeout(timer);
+      pending.delete(cancel);
+      reject(err);
+    };
+    const timer = setTimeout(() => finish(TIMED_OUT), ms);
+    timer.unref?.();
+    const cancel = () => finish(ABORTED);
+    pending.add(cancel);
+    work.then(finish, fail);
+  });
+}
+function createWayangMcpToolInvoker(deps) {
+  const pending = /* @__PURE__ */ new Set();
+  const invoke = async (name, args) => {
+    const started = Date.now();
+    if (name === "update_progress") {
+      if (typeof args.message !== "string" || args.message.length === 0) {
+        return { text: '[MCP ERROR] update_progress requires a non-empty string "message"', isError: true };
+      }
+      const message = capText(args.message);
+      const settled = await withTimeout(
+        Promise.resolve().then(() => deps.onProgress(message)),
+        deps.progressTimeoutMs ?? MCP_PROGRESS_TIMEOUT_MS,
+        pending
+      );
+      if (settled === ABORTED) return { text: "[ABORTED] Worker is shutting down.", isError: true };
+      if (settled === TIMED_OUT) {
+        return { text: "[TIMEOUT] The progress report was not delivered within 5s.", isError: true };
+      }
+      deps.logger.debug(
+        { workerId: deps.workerId, toolName: name, charLen: message.length, durationMs: Date.now() - started, mcpAvailable: true, reason: "progress" },
+        "ACP MCP tool served"
+      );
+      return { text: `Progress reported: ${message}` };
+    }
+    if (name === "ask_controller") {
+      const question = capText(typeof args.question === "string" ? args.question : "", MAX_QUESTION_CHARS);
+      if (!question) return { text: '[MCP ERROR] ask_controller requires a non-empty string "question"', isError: true };
+      const context = args.context === void 0 ? void 0 : capText(String(args.context), MAX_CONTEXT_CHARS);
+      const settled = await withTimeout(
+        deps.ask(question, context),
+        deps.askTimeoutMs ?? MCP_ASK_TIMEOUT_MS,
+        pending
+      );
+      const answer = settled === TIMED_OUT ? "[TIMEOUT] No answer from the controller within 5 minutes. Use your best judgment to continue." : settled === ABORTED ? "[ABORTED] Worker is shutting down." : settled;
+      deps.logger.debug(
+        { workerId: deps.workerId, toolName: name, charLen: answer.length, durationMs: Date.now() - started, mcpAvailable: true, reason: "ask" },
+        "ACP MCP tool served"
+      );
+      return { text: answer, isError: settled === TIMED_OUT || settled === ABORTED };
+    }
+    return { text: `Unknown tool: ${name}`, isError: true };
+  };
+  return {
+    invoke,
+    settlePending: () => {
+      for (const cancel of [...pending]) cancel();
+      pending.clear();
+    }
+  };
+}
+
+// src/services/agents/acp/acp-mcp-host.ts
+var AcpMcpHost = class {
+  deps;
+  transport = null;
+  handshakeTimer = null;
+  available = false;
+  warned = false;
+  /** Set by close(): a watchdog already on the timer queue must stay inert. */
+  stopped = false;
+  constructor(deps) {
+    this.deps = deps;
+  }
+  /** Whether the injected server is live this run (false once degraded). */
+  get mcpAvailable() {
+    return this.available;
+  }
+  /**
+   * Spawn the bridge transport (unless disabled) and return the mcpServers
+   * descriptor for session/new. A failed start degrades immediately and
+   * returns [] — session/new must still happen.
+   */
+  async prepare() {
+    if (!this.deps.enabled()) return [];
+    const invoker = createWayangMcpToolInvoker({
+      workerId: this.deps.workerId,
+      logger: this.deps.logger,
+      onProgress: (message) => this.deps.onProgress(message),
+      ask: (question, context) => this.deps.ask(question, context)
+    });
+    try {
+      const transport = await this.deps.spawnTransport({
+        sessionDir: this.deps.sessionDir,
+        workerId: this.deps.workerId,
+        invoker,
+        logger: this.deps.logger,
+        serverInfo: { name: "wayang", version: package_default.version }
+      });
+      this.transport = transport;
+      this.available = true;
+      this.armHandshakeWatchdog(transport);
+      this.deps.recordRuntime({ mcpAvailable: true });
+      this.deps.logger.debug({ workerId: this.deps.workerId, reason: "mcp-injected" }, "ACP MCP server injected");
+      return [transport.descriptor];
+    } catch (err) {
+      this.warnDegraded("transport-start-failed", err);
+      return [];
+    }
+  }
+  /**
+   * Disable MCP, stop the watchdog and shut the transport (and thus the
+   * bridge) down. The idle fallback stays armed: after degradation
+   * session/update text is the only progress source.
+   */
+  async degrade(reason, err) {
+    if (this.stopped) return;
+    if (this.available) {
+      this.available = false;
+      this.deps.onDegraded();
+      this.deps.recordRuntime({ mcpAvailable: false });
+    }
+    await this.close();
+    this.warnDegraded(reason, err);
+  }
+  /** Close the transport (idempotent) and stop the handshake watchdog. */
+  async close() {
+    this.stopped = true;
+    this.stopWatchdog();
+    const transport = this.transport;
+    this.transport = null;
+    if (!transport) return;
+    try {
+      await transport.close();
+    } catch (err) {
+      this.deps.logger.debug({ workerId: this.deps.workerId, err, reason: "mcp-transport-close" }, "ACP MCP transport close failed");
+    }
+  }
+  /** Stop the handshake watchdog (run finally / abort path). */
+  stopWatchdog() {
+    if (this.handshakeTimer) {
+      clearTimeout(this.handshakeTimer);
+      this.handshakeTimer = null;
+    }
+  }
+  /** A session/new that succeeded with injection but no hello within 10s degrades. */
+  armHandshakeWatchdog(transport) {
+    this.stopWatchdog();
+    const timer = setTimeout(() => {
+      this.handshakeTimer = null;
+      if (this.stopped || !this.available || transport.isReady()) return;
+      void this.degrade("handshake-timeout");
+    }, MCP_HANDSHAKE_TIMEOUT_MS);
+    timer.unref?.();
+    this.handshakeTimer = timer;
+  }
+  /** Metadata-only warning: no token, path, question, answer or reply text. */
+  warnDegraded(reason, err) {
+    if (this.warned) return;
+    this.warned = true;
+    const rpcCode = err instanceof AcpError ? err.detail?.rpc?.code : void 0;
+    this.deps.logger.warn(
+      { provider: this.deps.provider, workerId: this.deps.workerId, reason, ...rpcCode !== void 0 && { rpcCode }, mcpAvailable: false },
+      "ACP MCP injection degraded \u2014 session/update progress is the fallback"
+    );
+  }
+};
+
+// src/services/agents/acp/acp-session-open.ts
+async function trySessionNew(client, cwd, mcpServers, setAuthHit) {
+  const authHit = new Promise((_, reject) => {
+    setAuthHit((line) => reject(new AcpError("auth-required", `auth keyword on stderr during session/new: ${line}`, { stderrTail: [line] })));
+  });
+  authHit.catch(() => void 0);
+  try {
+    const { sessionId } = await Promise.race([
+      client.sessionNew({ cwd, mcpServers }),
+      authHit
+    ]);
+    return sessionId;
+  } finally {
+    setAuthHit(null);
+  }
+}
+function mcpRetryable(err, deps) {
+  const readiness = deps.isReady({
+    handshake: deps.handshake,
+    phase: "session-new",
+    error: err,
+    stderrTail: deps.transport.stderrTail()
+  });
+  if (!readiness.ready) return false;
+  if (err instanceof AcpError && ["auth-required", "cancelled", "transport-closed"].includes(err.code)) return false;
+  return true;
+}
+function attributeSessionNewError(err, deps) {
+  const readiness = deps.isReady({
+    handshake: deps.handshake,
+    phase: "session-new",
+    error: err,
+    stderrTail: deps.transport.stderrTail()
+  });
+  if (!readiness.ready) {
+    throw new AcpError(readiness.kind ?? "agent-error", readiness.message ?? "agent not ready after session/new");
+  }
+  throw deps.normalizeError(err, "session-new");
+}
+async function openAcpSession(deps) {
+  try {
+    return await trySessionNew(deps.client, deps.cwd, deps.mcpServers, deps.setAuthHit);
+  } catch (firstError) {
+    if (deps.mcpServers.length > 0 && mcpRetryable(firstError, deps)) {
+      await deps.degrade("session-new-mcp-error", firstError);
+      try {
+        return await trySessionNew(deps.client, deps.cwd, [], deps.setAuthHit);
+      } catch (secondError) {
+        attributeSessionNewError(secondError, deps);
+      }
+    }
+    attributeSessionNewError(firstError, deps);
+  }
+}
+
 // src/services/agents/acp/acp-worker-run.ts
-var PROGRESS_DEBOUNCE_MS = 500;
 var AcpWorkerRun = class extends BaseAcpWorker {
   /** Per-turn work counters feeding the guard's progressSig (#56). */
   _turnTextChars = 0;
   _turnToolCalls = 0;
   _turnToolResults = 0;
+  /** Turn counter: the turn component of the progress position. */
+  _turnSeq = 0;
+  /** Progress wiring (update_progress primary, idle fallback net). */
+  _progress = null;
+  /** Per-run MCP host lifecycle (injection / watchdog / degradation). */
+  _mcpHost = null;
   async run(task, _tools, onProgress) {
     this._terminalResult = null;
     this._streamEnded = false;
@@ -13692,6 +14453,18 @@ var AcpWorkerRun = class extends BaseAcpWorker {
     this._turnGuard = resetTurnGuard(Date.now());
     this._accumulator = createAcpToolAccumulator();
     this._turnWriter.reset();
+    this._onProgress = onProgress ?? null;
+    this._turnSeq = 0;
+    this._progress = new AcpProgress({
+      canFire: () => this.progressGuardsOpen(),
+      onProgress: (message) => {
+        this._onProgress?.(message);
+      },
+      writer: this._turnWriter,
+      position: () => this.progressPosition(),
+      idleMs: this.acpUserConfig().mcp?.fallbackMs
+    });
+    this._progress.start();
     this.state.set("runtimeState.task", { id: task.id, description: task.description });
     const turnEnv = this.buildTurnEnv(task);
     this._currentTurnEnv = turnEnv;
@@ -13746,7 +14519,32 @@ var AcpWorkerRun = class extends BaseAcpWorker {
       if (!postHandshake.ready) {
         throw new AcpError(postHandshake.kind ?? "agent-error", postHandshake.message ?? "agent not ready");
       }
-      const sessionId = await this.openSession(client, handshake, transport);
+      this._mcpHost = new AcpMcpHost({
+        workerId: this.id,
+        provider: this.config.type,
+        sessionDir: this.sessionDir,
+        logger: this.logger,
+        enabled: () => this.acpUserConfig().mcp?.enabled !== false,
+        spawnTransport: (opts) => this.createMcpTransport(opts),
+        onProgress: (message) => this._progress.report(message),
+        ask: (question, context) => this.mcpAsk(question, context),
+        recordRuntime: (fields) => this.recordAcpRuntime(fields),
+        onDegraded: () => this._progress?.noteNewMessage()
+      });
+      const mcpServers = await this._mcpHost.prepare();
+      const sessionId = await openAcpSession({
+        client,
+        handshake,
+        transport,
+        cwd: this.workspaceDir,
+        mcpServers,
+        isReady: (ctx) => this.isReady(ctx),
+        normalizeError: (err, phase) => this.normalizeError(err, phase),
+        degrade: (reason, err) => this._mcpHost.degrade(reason, err),
+        setAuthHit: (handler) => {
+          this._sessionAuthHit = handler;
+        }
+      });
       this._sessionId = sessionId;
       this.recordAcpRuntime({ pid: transport.pid, command: launch.command, provider: this.config.type });
       const unregisterPermission = client.onPermissionRequest(async (req) => {
@@ -13786,7 +14584,7 @@ var AcpWorkerRun = class extends BaseAcpWorker {
         };
         return this.mapPermission(req, acpCtx);
       });
-      const unregisterUpdates = client.onUpdate((update) => this.handleSessionUpdate(update, onProgress));
+      const unregisterUpdates = client.onUpdate((update) => this.handleSessionUpdate(update));
       try {
         let promptText = `${buildThirdPartyPrompt(this.skills)}${task.description}`;
         const initialQueued = this._messageQueue.splice(0, this._messageQueue.length);
@@ -13796,9 +14594,13 @@ ${joinControllerMessages(initialQueued)}`;
         while (!this.abortController.signal.aborted) {
           const cancelBaseline = client.cancelSentCount;
           this.resetTurnProgress();
+          this._turnSeq += 1;
+          this._progress.noteNewMessage();
           const result2 = await client.sessionPrompt(sessionId, [{ type: "text", text: promptText }]);
           this._resultReceived = true;
           this.settleTurn();
+          this._progress.recordReply();
+          this._progress.noteTurnEnd();
           const denials = this.takeTurnDenials();
           const cancelFact = client.cancelSentCount > cancelBaseline ? client.lastCancelReason : null;
           const hasQueuedMessages = this._messageQueue.length > 0;
@@ -13821,6 +14623,7 @@ ${joinControllerMessages(initialQueued)}`;
             );
             break;
           }
+          if (!this._mcpHost.mcpAvailable) this._progress.flush();
           const queued = this._messageQueue.splice(0, this._messageQueue.length);
           if (verdict.action === "reissue") {
             this._turnGuard.denialReissues += 1;
@@ -13832,6 +14635,7 @@ ${joinControllerMessages(initialQueued)}`;
           this.state.append("conversation", applyTurnEnvelope(makeInjectedEntry(promptText, injectedKind, this.ctx.sessionId), this._currentTurnEnv ?? void 0));
         }
       } finally {
+        this._progress?.stop();
         unregisterUpdates();
         unregisterPermission();
       }
@@ -13848,6 +14652,7 @@ ${joinControllerMessages(initialQueued)}`;
     } finally {
       this._streamEnded = true;
       this.clearPendingProgress();
+      await this._mcpHost?.close();
       if (this._cancelGraceTimer) {
         clearTimeout(this._cancelGraceTimer);
         this._cancelGraceTimer = null;
@@ -13882,6 +14687,7 @@ ${joinControllerMessages(initialQueued)}`;
   abort() {
     this.abortController.abort();
     this.clearPendingProgress();
+    void this._mcpHost?.close();
     this.permissionHandler.cleanup();
     const client = this._client;
     if (!client || !this._sessionId || this._terminalResult) return;
@@ -13899,31 +14705,50 @@ ${joinControllerMessages(initialQueued)}`;
     }, policy.cancelGraceMs);
   }
   // --- Internals ---
-  /**
-   * session/new with the stderr login short-circuit: a stderr line hitting the
-   * auth pattern rejects the race immediately (03 §2.2 — do not wait out the
-   * timeout); every failure is then attributed through the isReady hook.
-   */
-  async openSession(client, handshake, transport) {
-    const authHit = new Promise((_, reject) => {
-      this._sessionAuthHit = (line) => reject(new AcpError("auth-required", `auth keyword on stderr during session/new: ${line}`, { stderrTail: [line] }));
-    });
-    authHit.catch(() => void 0);
+  /** Clear progress state: stop the idle tracker and the MCP handshake watchdog. */
+  clearPendingProgress() {
+    this._progress?.stop();
+    this._mcpHost?.stopWatchdog();
+  }
+  /** The four guards: no progress after turn end / cancel / abort / agent exit. */
+  progressGuardsOpen() {
+    return this._runInFlight && !this._inputClosed && !this.abortController.signal.aborted && !this._streamEnded && this._terminalResult === null && this._cancelledAt === null;
+  }
+  /** Where the run currently is in its own text stream (turn + chars so far). */
+  progressPosition() {
+    return { turn: this._turnSeq, chars: this._turnTextChars };
+  }
+  /** ask_controller: same blocking engine channel as ClaudeCodeWorker, with an audit entry. */
+  async mcpAsk(question, context) {
+    const ask = this._askController;
+    if (!ask || !this._mcpHost?.mcpAvailable) {
+      return "[UNAVAILABLE] The controller inquiry channel is not available for this worker.";
+    }
+    const q = capText(question, MAX_QUESTION_CHARS);
+    const c = context === void 0 ? void 0 : capText(context, MAX_CONTEXT_CHARS);
+    let answer;
     try {
-      const { sessionId } = await Promise.race([
-        client.sessionNew({ cwd: this.workspaceDir, mcpServers: [] }),
-        authHit
-      ]);
-      return sessionId;
+      answer = await ask(q, c);
     } catch (err) {
-      const readiness = this.isReady({ handshake, phase: "session-new", error: err, stderrTail: transport.stderrTail() });
-      if (!readiness.ready) {
-        throw new AcpError(readiness.kind ?? "agent-error", readiness.message ?? "agent not ready after session/new");
-      }
-      throw this.normalizeError(err, "session-new");
-    } finally {
-      this._sessionAuthHit = null;
+      answer = `[UNAVAILABLE] ${err instanceof Error ? err.message : String(err)}`;
     }
+    this.recordInquiryAudit(q, answer);
+    return answer;
+  }
+  recordInquiryAudit(question, answer) {
+    const ts = nowISO();
+    this.state.append("conversation", applyTurnEnvelope({
+      type: "system" /* System */,
+      uuid: generateId("s"),
+      parentUuid: null,
+      sessionId: this.ctx.sessionId,
+      timestamp: ts,
+      subtype: "inquiry" /* Inquiry */,
+      content: `ask_controller: ${question}
+controller: ${answer}`,
+      startedAt: ts,
+      endedAt: ts
+    }, this._currentTurnEnv ?? void 0));
   }
   handleStderrLine(line) {
     this._stderrLines.push(line);
@@ -13934,7 +14759,7 @@ ${joinControllerMessages(initialQueued)}`;
     }
   }
   /** Route one session/update through the mapper and persist/forward the result. */
-  handleSessionUpdate(update, onProgress) {
+  handleSessionUpdate(update) {
     if (this._cancelledAt !== null && !this.stopPolicy().trustUpdatesAfterCancel) {
       this._discardedAfterCancel += 1;
       this.logger.debug(
@@ -13952,17 +14777,16 @@ ${joinControllerMessages(initialQueued)}`;
     }
     for (const event of events) {
       switch (event.kind) {
-        case "agent-text":
+        case "agent-text": {
           this._turnWriter.addText(event.text);
           this._turnTextChars += event.text.length;
           break;
-        case "progress":
-          this.emitDebouncedProgress(event.text, onProgress);
-          break;
+        }
         case "tool-call":
           this._sawToolCall = true;
           this._turnWriter.addToolCall(event.record);
           this._turnToolCalls += 1;
+          this._progress?.recordReply();
           break;
         case "tool-result":
           this._turnWriter.addToolResult(event.record);
@@ -13992,22 +14816,6 @@ ${joinControllerMessages(initialQueued)}`;
     }
     this._turnWriter.finishTurn();
   }
-  /** Progress debounce (02 §5): 500ms, dropped once the run is over. */
-  emitDebouncedProgress(text, onProgress) {
-    if (!onProgress) return;
-    this._pendingProgress = text.slice(0, 200);
-    if (this._progressTimer) clearTimeout(this._progressTimer);
-    this._progressTimer = setTimeout(() => {
-      this._progressTimer = null;
-      if (this._pendingProgress === null || this.abortController.signal.aborted || this._streamEnded || this._terminalResult !== null) {
-        this._pendingProgress = null;
-        return;
-      }
-      const pending = this._pendingProgress;
-      this._pendingProgress = null;
-      onProgress(pending);
-    }, PROGRESS_DEBOUNCE_MS);
-  }
   /** Display-ready error text with the full context (frozen §2.5 acpUserMessage). */
   userFacingError(err) {
     return acpUserMessage(err.code, {
@@ -14052,6 +14860,15 @@ ${joinControllerMessages(initialQueued)}`;
   createTransport(config) {
     return new StdioAcpTransport(config);
   }
+  /**
+   * MCP transport factory — the ONLY seam between the worker run and the MCP
+   * plumbing. Swapping the stdio bridge for an ACP v2 `acp` tunnel means
+   * replacing this one call (plus capability detection), not the tool layer.
+   * Overridable in tests to inject a fake transport.
+   */
+  createMcpTransport(opts) {
+    return startStdioMcpTransport(opts);
+  }
   /** Capability observation snapshot for diagnostics/tests (02 §6). */
   get observedCapabilities() {
     return this.getCapabilities();
@@ -14236,13 +15053,13 @@ function formatApiCallError(err) {
 }
 
 // src/services/tools/add-task.ts
-import { mkdirSync as mkdirSync8 } from "fs";
+import { mkdirSync as mkdirSync9 } from "fs";
 import * as path8 from "path";
 import { z as z3 } from "zod";
 
 // src/services/tools/workspace-rules.ts
 import { readFileSync as readFileSync10, statSync as statSync6 } from "fs";
-import { join as join18 } from "path";
+import { join as join19 } from "path";
 var RULE_FILE_NAMES2 = ["AGENTS.md", "CLAUDE.md"];
 var WORKSPACE_RULES_MAX_LINES = 40;
 var WORKSPACE_RULES_MAX_CHARS = 2e3;
@@ -14250,7 +15067,7 @@ function buildWorkspaceRulesSummary(input2) {
   const workspacePath = input2.workspacePath;
   if (!workspacePath) return "";
   for (const name of RULE_FILE_NAMES2) {
-    const rulesPath = join18(workspacePath, name);
+    const rulesPath = join19(workspacePath, name);
     if (!isRegularFile(rulesPath)) continue;
     const header = `Workspace rules (from ${rulesPath}):`;
     const refusal = describeRefusal(rulesPath, workspacePath, input2);
@@ -14325,7 +15142,7 @@ function readTextFile(p) {
 // src/services/tools/add-task.ts
 function ensureWorkspaceDir(dirPath) {
   try {
-    mkdirSync8(dirPath, { recursive: true });
+    mkdirSync9(dirPath, { recursive: true });
     return null;
   } catch (err) {
     return `Cannot create workspace ${dirPath}: ${err.message}. The task was NOT created.`;
@@ -15033,8 +15850,8 @@ function readFileTool(deps = {}) {
 
 // src/services/tools/write-file.ts
 import { z as z15 } from "zod";
-import { writeFileSync as writeFileSync5, mkdirSync as mkdirSync9, existsSync as existsSync11 } from "fs";
-import { dirname as dirname9, resolve as resolve9 } from "path";
+import { writeFileSync as writeFileSync5, mkdirSync as mkdirSync10, existsSync as existsSync12 } from "fs";
+import { dirname as dirname10, resolve as resolve9 } from "path";
 function writeFileTool(deps = {}) {
   const workspace = deps.cwd ?? process.cwd();
   return defineTool({
@@ -15045,10 +15862,10 @@ function writeFileTool(deps = {}) {
     }),
     execute: safeExecute("write_file", async ({ path: path10, content }) => {
       const resolved = resolve9(workspace, expandHome(path10).path);
-      if (existsSync11(resolved)) {
+      if (existsSync12(resolved)) {
         return `[ERROR] write_file: File already exists: ${path10}. Use edit_file to modify existing files.`;
       }
-      mkdirSync9(dirname9(resolved), { recursive: true });
+      mkdirSync10(dirname10(resolved), { recursive: true });
       writeFileSync5(resolved, content, "utf-8");
       return `Written ${content.length} chars to ${resolved}`;
     })
@@ -15503,12 +16320,12 @@ function askControllerTool(deps) {
 import { resolve as resolve12 } from "path";
 
 // src/services/task/task-pool-state.ts
-import { join as join19 } from "path";
+import { join as join20 } from "path";
 var TaskPoolState = class extends BaseWayangState {
   jsonFile;
   logger;
   constructor(ctx) {
-    const jsonFile = new JSONFileHelper(join19(ctx.sessionDir, "tasks.json"));
+    const jsonFile = new JSONFileHelper(join20(ctx.sessionDir, "tasks.json"));
     super(
       {
         tasks: {
@@ -16339,7 +17156,7 @@ var WorkerWiringEngine = class extends WorkerTrackingEngine {
         // (accessScope) judges expanded paths with — no injection needed.
         tavilyApiKey: this.ctx.config.tavilyApiKey,
         registry: this.skills,
-        reportProgress: (msg, _percent) => {
+        reportProgress: (msg) => {
           const activity = this.getWorkerActivity(workerId);
           this.enqueueWorkerSignal(workerId, {
             source: "worker",
@@ -16871,7 +17688,7 @@ var ControllerLoop = class {
 };
 
 // src/services/agents/controller-state.ts
-import { join as join20 } from "path";
+import { join as join21 } from "path";
 
 // src/services/conversation/conversation-index.ts
 function emptyUsage() {
@@ -17095,8 +17912,8 @@ var ControllerAgentState = class extends BaseWayangState {
   /** In-memory resolve function for the current inquiry — never persisted. */
   inquiryResolver = null;
   constructor(ctx) {
-    const jsonFile = new JSONFileHelper(join20(ctx.sessionDir, "runtime-state.json"));
-    const jsonlFile = new JSONLFileHelper(join20(ctx.sessionDir, "conversation.jsonl"));
+    const jsonFile = new JSONFileHelper(join21(ctx.sessionDir, "runtime-state.json"));
+    const jsonlFile = new JSONLFileHelper(join21(ctx.sessionDir, "conversation.jsonl"));
     const initialData = {
       runtimeState: {
         session: { id: "", startedAt: 0 },
@@ -18086,7 +18903,7 @@ var ControllerAgent = class _ControllerAgent extends ControllerTurnRun {
 
 // src/services/skills/registry.ts
 import { readFileSync as readFileSync13, readdirSync as readdirSync2, statSync as statSync7 } from "fs";
-import { join as join21 } from "path";
+import { join as join22 } from "path";
 import { parse as parseYaml } from "yaml";
 var SKILL_FILE = "SKILL.md";
 function parseFrontmatter(raw) {
@@ -18121,7 +18938,7 @@ function listResources(skillDir) {
   const walk = (relDir) => {
     let entries;
     try {
-      entries = readdirSync2(join21(skillDir, relDir), { withFileTypes: true });
+      entries = readdirSync2(join22(skillDir, relDir), { withFileTypes: true });
     } catch {
       return;
     }
@@ -18168,7 +18985,7 @@ var SkillRegistry = class {
     if (existing) return existing;
     const desc = this.descriptors.get(name);
     if (!desc) return void 0;
-    const filePath = join21(desc.dir, SKILL_FILE);
+    const filePath = join22(desc.dir, SKILL_FILE);
     let raw;
     try {
       raw = readFileSync13(filePath, "utf-8");
@@ -18199,8 +19016,8 @@ var SkillRegistry = class {
     for (const entry of entries) {
       if (!entry.isDirectory()) continue;
       if (entry.name.startsWith(".") || entry.name === "node_modules") continue;
-      const skillDir = join21(dir, entry.name);
-      const skillFile = join21(skillDir, SKILL_FILE);
+      const skillDir = join22(dir, entry.name);
+      const skillFile = join22(skillDir, SKILL_FILE);
       if (!existsAsFile(skillFile)) continue;
       const { frontmatter } = safeReadFrontmatter(skillFile);
       const description = asString(frontmatter.description);
@@ -18229,12 +19046,12 @@ function safeReadFrontmatter(path10) {
 }
 
 // src/services/skills/skill-dir.ts
-import { existsSync as existsSync12 } from "fs";
-import { join as join22, resolve as resolve13 } from "path";
+import { existsSync as existsSync13 } from "fs";
+import { join as join23, resolve as resolve13 } from "path";
 function resolveSkillDirs(dataDir, workspaceDir2, configDirs) {
   const candidates = [
-    join22(dataDir, "skills"),
-    join22(workspaceDir2, ".wayang", "skills"),
+    join23(dataDir, "skills"),
+    join23(workspaceDir2, ".wayang", "skills"),
     ...(configDirs ?? []).map((d) => resolve13(d))
   ];
   const seen = /* @__PURE__ */ new Set();
@@ -18242,14 +19059,14 @@ function resolveSkillDirs(dataDir, workspaceDir2, configDirs) {
   for (const dir of candidates) {
     if (seen.has(dir)) continue;
     seen.add(dir);
-    if (existsSync12(dir)) dirs.push(dir);
+    if (existsSync13(dir)) dirs.push(dir);
   }
   return dirs;
 }
 
 // src/services/supervisor.ts
 import { homedir as homedir8 } from "os";
-import { join as join23 } from "path";
+import { join as join24 } from "path";
 var Supervisor = class {
   ctx;
   signalQueue;
@@ -18298,7 +19115,7 @@ var Supervisor = class {
     );
     this.signalQueue = new SignalQueue(this.ctx);
     this.skills = new SkillRegistry(
-      resolveSkillDirs(options.dataDir ?? join23(homedir8(), ".wayang"), workspaceDir2, config.skillsDirs),
+      resolveSkillDirs(options.dataDir ?? join24(homedir8(), ".wayang"), workspaceDir2, config.skillsDirs),
       this.ctx.logger
     );
     this.engine = new TaskExecuteEngine(this.ctx, this.signalQueue, this.skills, {