wayang-ai 0.1.0

package/dist/cli.js

@@ -0,0 +1,4407 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import * as path4 from "path";
+import meow from "meow";
+
+// src/infra/logger.ts
+import pino from "pino";
+function createLogger(level = "info", logFilePath) {
+  const opts = {
+    level,
+    serializers: {
+      err: pino.stdSerializers.err,
+      error: pino.stdSerializers.err
+    }
+  };
+  if (logFilePath) {
+    return pino(opts, pino.transport({
+      target: "pino-pretty",
+      options: {
+        destination: logFilePath,
+        colorize: false,
+        singleLine: true,
+        ignore: "pid,hostname",
+        translateTime: "SYS:HH:MM:ss.l"
+      }
+    }));
+  }
+  if (level === "silent") {
+    return pino(opts, pino.destination("/dev/null"));
+  }
+  return pino(opts, pino.transport({ target: "pino-pretty", options: { colorize: true, destination: 2 } }));
+}
+
+// src/infra/system-context.ts
+var SystemContext = class {
+  sessionId;
+  sessionDir;
+  workspaceDir;
+  startedAt;
+  logLevel;
+  controllerProvider;
+  workerProvider;
+  maxConcurrency;
+  logger;
+  abortController;
+  constructor(config, sessionId, sessionDir, workspaceDir2, logLevel) {
+    this.sessionId = sessionId;
+    this.sessionDir = sessionDir;
+    this.workspaceDir = workspaceDir2;
+    this.startedAt = Date.now();
+    this.logLevel = logLevel ?? "info";
+    this.abortController = new AbortController();
+    this.controllerProvider = config.providers[config.controller.provider];
+    this.workerProvider = config.providers[config.worker.provider];
+    this.maxConcurrency = config.worker.maxConcurrency;
+    this.logger = createLogger(this.logLevel, `${sessionDir}/wayang.log`).child({
+      session: sessionId
+    });
+  }
+};
+
+// src/infra/event-bus.ts
+var EventBus = class {
+  listeners = /* @__PURE__ */ new Map();
+  on(event, listener) {
+    if (!this.listeners.has(event)) {
+      this.listeners.set(event, /* @__PURE__ */ new Set());
+    }
+    this.listeners.get(event).add(listener);
+    return () => this.listeners.get(event)?.delete(listener);
+  }
+  emit(event, ...args) {
+    this.listeners.get(event)?.forEach((fn) => fn(...args));
+  }
+  removeAll() {
+    this.listeners.clear();
+  }
+};
+
+// src/services/task/task-pool.ts
+var TaskPool = class {
+  constructor(state, eventBus, logger) {
+    this.state = state;
+    this.eventBus = eventBus;
+    this.logger = logger;
+  }
+  state;
+  eventBus;
+  logger;
+  /** Expose state for UI subscription via useWayangState. */
+  get stateRef() {
+    return this.state;
+  }
+  add(task) {
+    this.state.append("tasks.pending", task);
+    this.eventBus.emit("task:added", task);
+    this.logger.info({ taskId: task.id }, "Task added");
+  }
+  get(id) {
+    const all = [
+      ...this.state.get("tasks.pending"),
+      ...this.state.get("tasks.running"),
+      ...this.state.get("tasks.history")
+    ];
+    return all.find((t) => t.id === id);
+  }
+  moveToRunning(id, workerSessionId) {
+    const pending = [...this.state.get("tasks.pending")];
+    const idx = pending.findIndex((t) => t.id === id);
+    if (idx === -1) {
+      this.logger.warn({ taskId: id }, "Task not found in pending");
+      return;
+    }
+    const [task] = pending.splice(idx, 1);
+    const updated = {
+      ...task,
+      status: "running",
+      startedAt: Date.now(),
+      workerSessionId
+    };
+    this.state.set("tasks.pending", pending);
+    this.state.append("tasks.running", updated);
+    this.logger.info({ taskId: id, workerId: workerSessionId }, "Task moved to running");
+  }
+  complete(id, result) {
+    this.moveToHistory(id, "completed", { result });
+    this.eventBus.emit("task:completed", { taskId: id });
+    this.logger.info({ taskId: id }, "Task completed");
+  }
+  fail(id, error) {
+    this.moveToHistory(id, "failed", { error });
+    this.eventBus.emit("task:failed", { taskId: id, error });
+    this.logger.info({ taskId: id, error }, "Task failed");
+  }
+  cancel(id) {
+    const running = this.state.get("tasks.running");
+    const runIdx = running.findIndex((t) => t.id === id);
+    if (runIdx !== -1) {
+      this.moveToHistory(id, "cancelled", {});
+      this.eventBus.emit("task:cancelled", { taskId: id });
+      this.logger.info({ taskId: id }, "Running task cancelled");
+      return true;
+    }
+    const pending = [...this.state.get("tasks.pending")];
+    const pendIdx = pending.findIndex((t) => t.id === id);
+    if (pendIdx !== -1) {
+      const [task] = pending.splice(pendIdx, 1);
+      this.state.set("tasks.pending", pending);
+      this.state.append("tasks.history", {
+        ...task,
+        status: "cancelled",
+        completedAt: Date.now()
+      });
+      this.eventBus.emit("task:cancelled", { taskId: id });
+      this.logger.info({ taskId: id }, "Pending task cancelled");
+      return true;
+    }
+    this.logger.warn({ taskId: id }, "Task not found for cancel");
+    return false;
+  }
+  /** Update a pending task's description or priority. */
+  updatePending(id, updates) {
+    const pending = [...this.state.get("tasks.pending")];
+    const idx = pending.findIndex((t) => t.id === id);
+    if (idx === -1) {
+      this.logger.warn({ taskId: id }, "Task not found in pending for update");
+      return false;
+    }
+    pending[idx] = { ...pending[idx], ...updates };
+    this.state.set("tasks.pending", pending);
+    this.logger.info({ taskId: id, updates }, "Pending task updated");
+    return true;
+  }
+  list(status) {
+    if (!status) {
+      return [
+        ...this.state.get("tasks.pending"),
+        ...this.state.get("tasks.running"),
+        ...this.state.get("tasks.history")
+      ];
+    }
+    if (status === "pending") return [...this.state.get("tasks.pending")];
+    if (status === "running") return [...this.state.get("tasks.running")];
+    return this.state.get("tasks.history").filter((t) => t.status === status);
+  }
+  hasPending() {
+    return this.state.get("tasks.pending").length > 0;
+  }
+  /** Pick the highest priority task without removing it. */
+  peekHighestPriority() {
+    const pending = this.state.get("tasks.pending");
+    if (pending.length === 0) return null;
+    const highIdx = pending.findIndex((t) => t.priority === "high");
+    const targetIdx = highIdx !== -1 ? highIdx : 0;
+    return pending[targetIdx];
+  }
+  getRunningCount() {
+    return this.state.get("tasks.running").length;
+  }
+  async restore() {
+    await this.state.restore();
+  }
+  moveToHistory(id, status, extra) {
+    const running = this.state.get("tasks.running");
+    const idx = running.findIndex((t) => t.id === id);
+    if (idx === -1) {
+      this.logger.warn({ taskId: id }, "Task not found in running");
+      return;
+    }
+    const updated = [...this.state.get("tasks.running")];
+    const [task] = updated.splice(idx, 1);
+    this.state.set("tasks.running", updated);
+    this.state.append("tasks.history", {
+      ...task,
+      ...extra,
+      status,
+      completedAt: Date.now()
+    });
+  }
+};
+
+// src/services/signal/signal-queue.ts
+var SignalQueue = class {
+  constructor(state, logger) {
+    this.state = state;
+    this.logger = logger;
+    const sigs = state.get("signals");
+    this.counter = sigs.reduce((max, s) => {
+      const n = parseInt(s.id.replace("sig-", ""), 10);
+      return isNaN(n) ? max : Math.max(max, n);
+    }, 0);
+  }
+  state;
+  logger;
+  resolveWait = null;
+  /** Expose state for UI subscription via useWayangState. */
+  get stateRef() {
+    return this.state;
+  }
+  counter;
+  enqueue(sig) {
+    const full = {
+      ...sig,
+      id: `sig-${++this.counter}`,
+      status: "unread",
+      timestamp: Date.now()
+    };
+    if (sig.source === "worker" && sig.type === "progress") {
+      const { workerId } = sig.payload;
+      if (workerId) {
+        const allSigs = this.state.get("signals");
+        let changed = false;
+        for (const old of allSigs) {
+          if (old.status === "unread" && old.source === "worker" && old.type === "progress" && old.payload.workerId === workerId) {
+            old.status = "discarded";
+            changed = true;
+          }
+        }
+        if (changed) {
+          this.state.set("signals", [...allSigs]);
+        }
+      }
+    }
+    this.state.append("signals", full);
+    this.logger.debug({ sigId: full.id, type: full.type }, "Signal enqueued");
+    if (this.resolveWait) {
+      this.resolveWait();
+      this.resolveWait = null;
+    }
+  }
+  dequeueUnread() {
+    const all = this.state.get("signals");
+    const unread = all.filter((s) => s.status === "unread");
+    this.logger.debug({ total: all.length, unreadCount: unread.length, unreadIds: unread.map((s) => s.id), allStatuses: all.map((s) => `${s.id}=${s.status}`) }, "dequeueUnread");
+    for (const sig of unread) {
+      sig.status = "read";
+    }
+    if (unread.length > 0) {
+      this.state.set("signals", [...all]);
+    }
+    return unread;
+  }
+  waitForSignal() {
+    const unread = this.state.get("signals").filter((s) => s.status === "unread");
+    if (unread.length > 0) return Promise.resolve();
+    return new Promise((resolve4) => {
+      this.resolveWait = () => {
+        this.logger.debug("waitForSignal resolved");
+        resolve4();
+      };
+    });
+  }
+  async restore() {
+    await this.state.restore();
+    const sigs = this.state.get("signals");
+    this.counter = sigs.reduce((max, s) => {
+      const n = parseInt(s.id.replace("sig-", ""), 10);
+      return isNaN(n) ? max : Math.max(max, n);
+    }, 0);
+  }
+  /** Get all unread signals without modifying state. Used by UI to display pending signals. */
+  getUnreadSignals() {
+    return this.state.get("signals").filter((s) => s.status === "unread");
+  }
+  /**
+   * Query signals by filter criteria.
+   * Returns a filtered list without modifying state.
+   */
+  query(filter) {
+    const all = this.state.get("signals");
+    return all.filter((sig) => {
+      if (filter.status !== void 0 && sig.status !== filter.status) {
+        return false;
+      }
+      if (filter.source !== void 0 && sig.source !== filter.source) {
+        return false;
+      }
+      if (filter.type !== void 0 && sig.type !== filter.type) {
+        return false;
+      }
+      return true;
+    });
+  }
+};
+
+// src/utils/llm-error.ts
+function formatLlmError(err) {
+  if (!(err instanceof Error)) return String(err);
+  const name = err.name ?? err.constructor?.name ?? "Error";
+  if (name === "AI_RetryError" || name === "RetryError") {
+    const retryErr = err;
+    const lastError = retryErr.lastError;
+    if (lastError) {
+      const inner = formatApiCallError(lastError);
+      const attempts = retryErr.errors?.length ?? "?";
+      return `LLM request failed after ${attempts} attempts: ${inner}`;
+    }
+    return `LLM request failed: ${err.message}`;
+  }
+  if (name === "AI_APICallError" || name === "APICallError") {
+    return `LLM API error: ${formatApiCallError(err)}`;
+  }
+  return err.message || String(err);
+}
+function formatApiCallError(err) {
+  const status = err.statusCode;
+  const body = err.responseBody;
+  let providerMsg = "";
+  if (typeof body === "string" && body) {
+    try {
+      const parsed = JSON.parse(body);
+      providerMsg = parsed?.error?.message ?? parsed?.message ?? "";
+    } catch {
+      providerMsg = body.slice(0, 200);
+    }
+  }
+  if (status && providerMsg) {
+    return `[${status}] ${providerMsg}`;
+  }
+  if (status) {
+    return `[${status}] ${err.message ?? "Unknown error"}`;
+  }
+  return providerMsg || err.message || String(err);
+}
+
+// src/utils/id.ts
+function generateId(prefix) {
+  return `${prefix}-${Date.now()}-${Math.random().toString(36).slice(2, 6)}`;
+}
+function formatTimestamp(date = /* @__PURE__ */ new Date()) {
+  const Y = date.getFullYear();
+  const M = String(date.getMonth() + 1).padStart(2, "0");
+  const D = String(date.getDate()).padStart(2, "0");
+  const h = String(date.getHours()).padStart(2, "0");
+  const m = String(date.getMinutes()).padStart(2, "0");
+  const s = String(date.getSeconds()).padStart(2, "0");
+  return `${Y}${M}${D}-${h}${m}${s}`;
+}
+
+// src/services/agents/worker-defaults.ts
+var PUPPET_DEFAULTS = {
+  /** Display name. */
+  label: "puppet",
+  /** Emoji icon for UI display. */
+  emoji: "\u{1F9F8}",
+  //  🧸
+  /** Description shown to the Controller LLM. */
+  description: "Built-in worker for general tasks using shell commands and file I/O.",
+  /** Capability tags. */
+  capabilities: ["shell/bash", "file-io", "general"]
+};
+function getWorkerMeta(workerType, workerConfigs) {
+  const type = workerType ?? "puppet";
+  if (type === "puppet") {
+    return { label: PUPPET_DEFAULTS.label, emoji: PUPPET_DEFAULTS.emoji };
+  }
+  const config = workerConfigs?.[type];
+  return {
+    label: type,
+    emoji: config?.emoji ?? "\u{1F916}"
+    // 🤖 fallback
+  };
+}
+
+// src/services/task/task-scheduler.ts
+var TaskScheduler = class {
+  constructor(logger, taskPool, signalQueue, eventBus, ctx, maxConcurrency = 3, workerConfigs) {
+    this.logger = logger;
+    this.taskPool = taskPool;
+    this.signalQueue = signalQueue;
+    this.eventBus = eventBus;
+    this.ctx = ctx;
+    this.maxConcurrency = maxConcurrency;
+    this.workerConfigs = workerConfigs;
+  }
+  logger;
+  taskPool;
+  signalQueue;
+  eventBus;
+  ctx;
+  maxConcurrency;
+  workerConfigs;
+  spawnFn = null;
+  /** Inject worker spawn function (breaks circular dep) */
+  setSpawnFn(fn) {
+    this.spawnFn = fn;
+  }
+  start() {
+    this.eventBus.on("task:added", () => this.schedule());
+    this.logger.info("Scheduler started");
+  }
+  schedule() {
+    while (this.taskPool.hasPending() && this.taskPool.getRunningCount() < this.maxConcurrency) {
+      const task = this.taskPool.peekHighestPriority();
+      if (!task) break;
+      if (!this.spawnFn) {
+        this.logger.error("spawnFn not set, cannot schedule task");
+        break;
+      }
+      const workerId = generateId("w");
+      const workerType = task.workerType ?? "puppet";
+      const meta = getWorkerMeta(workerType, this.workerConfigs);
+      this.taskPool.moveToRunning(task.id, workerId);
+      this.ctx.addActiveWorker({
+        workerId,
+        taskId: task.id,
+        startedAt: Date.now(),
+        workerType: meta.label,
+        taskTitle: task.title,
+        emoji: meta.emoji
+      });
+      this.spawnFn({ ...task, workerId }).then((result) => {
+        this.handleDone(workerId, task, result);
+      }).catch((err) => {
+        this.handleFail(workerId, task.id, task.title, meta.label, meta.emoji, formatLlmError(err));
+      });
+      this.logger.info({ taskId: task.id, workerId }, "Worker spawned");
+    }
+  }
+  handleDone(workerId, task, result) {
+    const { id: taskId, title: taskTitle, workerType: wt } = task;
+    const workerType = wt ?? "puppet";
+    const meta = getWorkerMeta(workerType, this.workerConfigs);
+    if (result.status === "completed") {
+      this.taskPool.complete(taskId, result.summary ?? "");
+    } else {
+      this.taskPool.fail(taskId, result.error ?? "Unknown error");
+    }
+    if (result.status === "completed") {
+      this.signalQueue.enqueue({
+        source: "worker",
+        type: "completed",
+        payload: {
+          taskId,
+          workerId,
+          taskTitle,
+          workerType,
+          emoji: meta.emoji,
+          summary: result.summary
+        }
+      });
+    } else {
+      this.signalQueue.enqueue({
+        source: "worker",
+        type: "failed",
+        payload: {
+          taskId,
+          workerId,
+          taskTitle,
+          workerType,
+          emoji: meta.emoji,
+          error: result.error ?? "Unknown error"
+        }
+      });
+    }
+    this.ctx.removeActiveWorker(workerId);
+    this.ctx.removeWorker(workerId);
+    this.schedule();
+  }
+  handleFail(workerId, taskId, taskTitle, workerType, emoji, error) {
+    this.taskPool.fail(taskId, error);
+    this.signalQueue.enqueue({
+      source: "worker",
+      type: "failed",
+      payload: { taskId, workerId, taskTitle, workerType, emoji, error }
+    });
+    this.ctx.removeActiveWorker(workerId);
+    this.ctx.removeWorker(workerId);
+    this.schedule();
+  }
+};
+
+// src/services/agents/controller-state.ts
+import { join } from "path";
+
+// src/types/config.ts
+function validateConfig(config) {
+  for (const [name, provider] of Object.entries(config.providers)) {
+    if (!provider.endpoint) return `providers.${name}.endpoint is required`;
+    if (!provider.apiKey) return `providers.${name}.apiKey is required (set WAYANG_LLM_API_KEY or configure in config file)`;
+    if (!provider.modelName) return `providers.${name}.modelName is required`;
+  }
+  const cp = config.controller.provider;
+  if (!config.providers[cp]) return `controller.provider "${cp}" not found`;
+  const wp = config.worker.provider;
+  if (!config.providers[wp]) return `worker.provider "${wp}" not found`;
+  return null;
+}
+
+// src/types/conversation.ts
+function isSystemEntry(entry) {
+  return entry.type === "system" /* System */;
+}
+function getEntryContent(entry) {
+  if (entry.type === "signal" /* Signal */ || entry.type === "system" /* System */) {
+    return entry.content;
+  }
+  return entry.message.content;
+}
+
+// src/types/signal.ts
+function getSignalField(sig, field) {
+  return sig.payload[field];
+}
+
+// src/infra/state/base-state.ts
+import { get, set, cloneDeep } from "lodash-es";
+var BaseWayangState = class {
+  data;
+  persistMappings;
+  subscriptions = /* @__PURE__ */ new Map();
+  constructor(initialData, persistMappings = []) {
+    this.data = initialData;
+    this.persistMappings = persistMappings;
+  }
+  // --- Read ---
+  get(path5) {
+    return get(this.data, path5);
+  }
+  // --- Write operations ---
+  set(path5, value) {
+    const prev = get(this.data, path5);
+    set(this.data, path5, value);
+    this.persist(path5);
+    this.notify(path5, "set", prev);
+  }
+  update(path5, partial) {
+    const prev = cloneDeep(get(this.data, path5));
+    const target = get(this.data, path5);
+    if (target && typeof target === "object") {
+      Object.assign(target, partial);
+    } else {
+      set(this.data, path5, partial);
+    }
+    this.persist(path5);
+    this.notify(path5, "update", prev);
+  }
+  append(path5, entry) {
+    const arr = get(this.data, path5);
+    if (!Array.isArray(arr)) {
+      throw new Error(`State.append: path "${path5}" is not an array`);
+    }
+    arr.push(entry);
+    set(this.data, path5, [...arr]);
+    this.persist(path5);
+    this.notify(path5, "append", void 0);
+  }
+  remove(path5, idx) {
+    const arr = get(this.data, path5);
+    if (!Array.isArray(arr)) {
+      throw new Error(`State.remove: path "${path5}" is not an array`);
+    }
+    const prev = idx !== void 0 ? arr[idx] : arr[arr.length - 1];
+    if (idx === void 0) {
+      arr.pop();
+    } else {
+      arr.splice(idx, 1);
+    }
+    this.persist(path5);
+    this.notify(path5, "remove", prev);
+  }
+  // --- Subscription ---
+  on(path5, callback) {
+    if (!this.subscriptions.has(path5)) {
+      this.subscriptions.set(path5, /* @__PURE__ */ new Set());
+    }
+    this.subscriptions.get(path5).add(callback);
+    return () => this.subscriptions.get(path5)?.delete(callback);
+  }
+  // --- Persistence ---
+  persist(path5) {
+    const topKey = path5.split(".")[0];
+    for (const mapping of this.persistMappings) {
+      if (mapping.path !== topKey) continue;
+      if (mapping.helper.mode === "save") {
+        mapping.helper.write(this.data[topKey]);
+      } else if (mapping.helper.mode === "append") {
+      }
+    }
+  }
+  /** Append-mode persistence for subclasses to call directly. */
+  persistAppend(path5, entry) {
+    const topKey = path5.split(".")[0];
+    for (const mapping of this.persistMappings) {
+      if (mapping.path === topKey && mapping.helper.mode === "append") {
+        mapping.helper.write(entry);
+      }
+    }
+  }
+  // --- Notification ---
+  notify(changePath, type, prev) {
+    const event = { type, path: changePath, data: get(this.data, changePath), prev };
+    for (const [subPath, callbacks] of this.subscriptions) {
+      if (changePath === subPath) {
+        for (const cb of callbacks) cb(event);
+        continue;
+      }
+      if (changePath.startsWith(subPath + ".")) {
+        for (const cb of callbacks) {
+          cb({ ...event, data: get(this.data, subPath) });
+        }
+        continue;
+      }
+      if (subPath.startsWith(changePath + ".")) {
+        const newVal = get(this.data, subPath);
+        for (const cb of callbacks) {
+          cb({ ...event, data: newVal });
+        }
+      }
+    }
+  }
+};
+
+// src/infra/state/persistence/json-file.ts
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from "fs";
+import { dirname } from "path";
+var JSONFileHelper = class {
+  constructor(filePath) {
+    this.filePath = filePath;
+  }
+  filePath;
+  mode = "save";
+  write(data) {
+    mkdirSync(dirname(this.filePath), { recursive: true });
+    writeFileSync(this.filePath, JSON.stringify(data, null, 2));
+  }
+  read() {
+    if (!existsSync(this.filePath)) return null;
+    return JSON.parse(readFileSync(this.filePath, "utf-8"));
+  }
+  clear() {
+    writeFileSync(this.filePath, "{}");
+  }
+};
+
+// src/infra/state/persistence/jsonl-file.ts
+import { readFileSync as readFileSync2, writeFileSync as writeFileSync2, appendFileSync, existsSync as existsSync2, mkdirSync as mkdirSync2 } from "fs";
+import { dirname as dirname2 } from "path";
+var JSONLFileHelper = class {
+  constructor(filePath) {
+    this.filePath = filePath;
+  }
+  filePath;
+  mode = "append";
+  write(entry) {
+    mkdirSync2(dirname2(this.filePath), { recursive: true });
+    appendFileSync(this.filePath, JSON.stringify(entry) + "\n");
+  }
+  read() {
+    if (!existsSync2(this.filePath)) return [];
+    return readFileSync2(this.filePath, "utf-8").trim().split("\n").filter((line) => line.length > 0).map((line) => JSON.parse(line));
+  }
+  readFromEnd(stopCondition) {
+    const all = this.read();
+    const result = [];
+    for (let i = all.length - 1; i >= 0; i--) {
+      if (stopCondition(all[i])) break;
+      result.unshift(all[i]);
+    }
+    return result;
+  }
+  clear() {
+    writeFileSync2(this.filePath, "");
+  }
+};
+
+// src/services/agents/controller-state.ts
+var ControllerAgentState = class extends BaseWayangState {
+  constructor(sessionDir, logger) {
+    const jsonFile = new JSONFileHelper(join(sessionDir, "runtime-state.json"));
+    const jsonlFile = new JSONLFileHelper(join(sessionDir, "conversation.jsonl"));
+    const initialData = {
+      runtimeState: {
+        session: { id: "", startedAt: 0 },
+        activeWorkers: [],
+        maxConcurrency: 3
+      },
+      conversation: [],
+      compactSummary: null,
+      dynamicState: { streamingEntries: [], busy: false }
+    };
+    super(initialData, [
+      { path: "runtimeState", helper: jsonFile },
+      { path: "conversation", helper: jsonlFile }
+    ]);
+    this.sessionDir = sessionDir;
+    this.logger = logger;
+    this.jsonFile = jsonFile;
+    this.jsonlFile = jsonlFile;
+  }
+  sessionDir;
+  logger;
+  jsonFile;
+  jsonlFile;
+  async restore() {
+    const runtimeState = this.jsonFile.read();
+    if (runtimeState) {
+      this.data.runtimeState = runtimeState;
+    }
+    const allEntries = this.jsonlFile.read();
+    const compactIdx = allEntries.findLastIndex(
+      (e) => isSystemEntry(e) && e.subtype === "compact" /* Compact */
+    );
+    if (compactIdx === -1) {
+      this.data.conversation = allEntries;
+    } else {
+      const RECENT_TOKEN_BUDGET2 = 2e4;
+      let budget = RECENT_TOKEN_BUDGET2;
+      let cutIdx = 0;
+      for (let i = compactIdx - 1; i >= 0; i--) {
+        const entry = allEntries[i];
+        const content = getEntryContent(entry);
+        budget -= Math.ceil(String(content).length / 4);
+        if (budget <= 0) {
+          cutIdx = i + 1;
+          break;
+        }
+      }
+      this.data.conversation = allEntries.slice(cutIdx);
+    }
+    this.logger.info({
+      entryCount: this.data.conversation.length,
+      totalEntries: allEntries.length
+    }, "ControllerAgentState restored");
+  }
+  /** Override append to ensure JSONL write-per-entry. */
+  append(path5, entry) {
+    super.append(path5, entry);
+    if (path5 === "conversation") {
+      this.persistAppend(path5, entry);
+    }
+  }
+};
+
+// src/services/task/task-pool-state.ts
+import { join as join2 } from "path";
+var TaskPoolState = class extends BaseWayangState {
+  constructor(sessionDir, logger) {
+    const jsonFile = new JSONFileHelper(join2(sessionDir, "tasks.json"));
+    super(
+      {
+        tasks: {
+          pending: [],
+          running: [],
+          history: []
+        }
+      },
+      [{ path: "tasks", helper: jsonFile }]
+    );
+    this.sessionDir = sessionDir;
+    this.logger = logger;
+    this.jsonFile = jsonFile;
+  }
+  sessionDir;
+  logger;
+  jsonFile;
+  async restore() {
+    const data = this.jsonFile.read();
+    if (data) {
+      this.data.tasks = data;
+    }
+    this.logger.info("TaskPoolState restored");
+  }
+};
+
+// src/services/signal/signal-state.ts
+import { join as join3 } from "path";
+var SignalState = class extends BaseWayangState {
+  constructor(sessionDir, logger) {
+    const jsonlFile = new JSONLFileHelper(join3(sessionDir, "signals.jsonl"));
+    const eventLogFile = new JSONLFileHelper(join3(sessionDir, "state-events.jsonl"));
+    super(
+      { signals: [] },
+      [{ path: "signals", helper: jsonlFile }]
+    );
+    this.sessionDir = sessionDir;
+    this.logger = logger;
+    this.jsonlFile = jsonlFile;
+    this.eventLogFile = eventLogFile;
+    this.on("signals", (event) => this.recordStateEvent(event));
+  }
+  sessionDir;
+  logger;
+  jsonlFile;
+  eventLogFile;
+  /** In-memory cache of event log entries. */
+  eventBuffer = [];
+  /** When true, skip recording events (used during restore to avoid re-writing). */
+  restoring = false;
+  /** Record a state change event to the event log */
+  recordStateEvent(event) {
+    if (this.restoring) return;
+    const logEntry = {
+      type: event.type,
+      path: event.path,
+      timestamp: Date.now(),
+      prev: event.prev,
+      data: event.data
+    };
+    if (event.path === "signals") {
+      if (event.type === "append" && Array.isArray(event.data) && event.data.length > 0) {
+        const sig = event.data[event.data.length - 1];
+        if (sig?.id) {
+          logEntry.signalId = sig.id;
+        }
+      } else if ((event.type === "set" || event.type === "update") && Array.isArray(event.data)) {
+        const sig = event.data.find((m) => m?.id);
+        if (sig?.id) {
+          logEntry.signalId = sig.id;
+        }
+      }
+    }
+    this.eventBuffer.push(logEntry);
+    this.eventLogFile.write(logEntry);
+    this.logger.debug({ eventType: event.type, path: event.path }, "State event recorded");
+  }
+  /** Get all state change events from the in-memory buffer. */
+  getStateEvents() {
+    return this.eventBuffer;
+  }
+  /** Get events filtered by signal ID */
+  getEventsBySignalId(signalId) {
+    return this.eventBuffer.filter((e) => e.signalId === signalId);
+  }
+  /** Get events filtered by type */
+  getEventsByType(type) {
+    return this.eventBuffer.filter((e) => e.type === type);
+  }
+  async restore() {
+    this.restoring = true;
+    try {
+      const signals = this.jsonlFile.read();
+      const sigMap = /* @__PURE__ */ new Map();
+      for (const sig of signals) {
+        sigMap.set(sig.id, { ...sig });
+      }
+      const events = this.eventLogFile.read();
+      this.eventBuffer = events;
+      for (const event of events) {
+        if (event.type === "set" && event.path === "signals" && Array.isArray(event.data)) {
+          for (const sig of event.data) {
+            if (sig?.id && sigMap.has(sig.id)) {
+              sigMap.get(sig.id).status = sig.status;
+            }
+          }
+        }
+      }
+      this.data.signals = Array.from(sigMap.values());
+      this.logger.info({
+        signalCount: this.data.signals.length,
+        eventCount: events.length
+      }, "SignalState restored");
+    } finally {
+      this.restoring = false;
+    }
+  }
+  /** Override append to ensure JSONL write-per-entry. */
+  append(path5, entry) {
+    super.append(path5, entry);
+    if (path5 === "signals") {
+      this.persistAppend(path5, entry);
+    }
+  }
+};
+
+// src/services/session/session-manager.ts
+import * as path from "path";
+
+// src/services/session/session-state.ts
+import { join as join4 } from "path";
+var SessionState = class extends BaseWayangState {
+  jsonFile;
+  constructor(sessionDir) {
+    const jsonFile = new JSONFileHelper(join4(sessionDir, "meta.json"));
+    super(
+      {
+        meta: {
+          sessionId: "",
+          workspace: "",
+          firstInput: null,
+          createdAt: 0,
+          lastActiveAt: 0
+        }
+      },
+      [{ path: "meta", helper: jsonFile }]
+    );
+    this.jsonFile = jsonFile;
+  }
+  async restore() {
+    const data = this.jsonFile.read();
+    if (data) {
+      this.data.meta = data;
+    }
+  }
+};
+
+// src/services/session/session-manager.ts
+var SessionManager = class _SessionManager {
+  sessionId;
+  sessionDir;
+  isResume;
+  state;
+  constructor(sessionId, sessionDir, isResume) {
+    this.sessionId = sessionId;
+    this.sessionDir = sessionDir;
+    this.isResume = isResume;
+    this.state = new SessionState(sessionDir);
+  }
+  /** Create a new session: generates ID, initializes meta via WayangState (auto mkdir + write). */
+  static create(homeDir2, workspaceDir2) {
+    const sessionId = `${formatTimestamp()}-${Math.random().toString(36).slice(2, 6)}`;
+    const sessionDir = path.join(homeDir2, "sessions", sessionId);
+    const mgr = new _SessionManager(sessionId, sessionDir, false);
+    mgr.state.set("meta", {
+      sessionId,
+      workspace: workspaceDir2,
+      firstInput: null,
+      createdAt: Date.now(),
+      lastActiveAt: Date.now()
+    });
+    return mgr;
+  }
+  /** Resume an existing session. State is restored in restore(). */
+  static resume(sessionId, sessionDir) {
+    return new _SessionManager(sessionId, sessionDir, true);
+  }
+  /** Restore state from disk (resume only, no-op for new sessions). */
+  async restore() {
+    if (!this.isResume) return;
+    await this.state.restore();
+  }
+  /** Workspace directory of this session. */
+  get workspace() {
+    return this.state.get("meta.workspace");
+  }
+  /** Whether firstInput has already been recorded. */
+  get hasFirstInput() {
+    return !!this.state.get("meta.firstInput");
+  }
+  /**
+   * Notify that a user input occurred.
+   * Records firstInput (idempotent) and updates lastActiveAt.
+   */
+  onUserInput(text) {
+    if (!this.hasFirstInput) {
+      this.state.set("meta.firstInput", text);
+    }
+    this.state.set("meta.lastActiveAt", Date.now());
+  }
+};
+
+// src/services/agents/base-agent.ts
+import { streamText, stepCountIs, hasToolCall } from "ai";
+
+// src/services/agents/model-factory.ts
+import { createOpenAI } from "@ai-sdk/openai";
+function createModel(provider) {
+  const openai = createOpenAI({ baseURL: provider.endpoint, apiKey: provider.apiKey });
+  return openai.chat(provider.modelName);
+}
+
+// src/services/agents/base-agent.ts
+var BaseAgent = class {
+  id;
+  abortController;
+  model;
+  hooks = {};
+  constructor(provider) {
+    this.id = generateId("agent");
+    this.abortController = new AbortController();
+    this.model = createModel(provider);
+  }
+  /** Set lifecycle hooks. */
+  setHooks(hooks) {
+    this.hooks = hooks;
+  }
+  /** Core streaming primitive — yields text chunks, returns final result.
+   *  Catches abort signal internally so callers see a clean completion. */
+  async *streamLoop(opts) {
+    const step = 0;
+    let stream;
+    const stopConditions = [];
+    if (opts.maxSteps) stopConditions.push(stepCountIs(opts.maxSteps));
+    if (opts.stopTools?.length) {
+      for (const name of opts.stopTools) {
+        stopConditions.push(hasToolCall(name));
+      }
+    }
+    let startTime;
+    try {
+      this.hooks.beforeLLM?.({ messageCount: opts.messages.length, messages: opts.messages });
+      startTime = Date.now();
+      stream = streamText({
+        model: this.model,
+        system: opts.system,
+        messages: opts.messages,
+        tools: opts.tools,
+        toolChoice: opts.toolChoice,
+        stopWhen: stopConditions.length > 0 ? stopConditions : void 0,
+        abortSignal: this.abortController.signal,
+        onStepFinish: opts.onStep
+      });
+    } catch (err) {
+      if (this.abortController.signal.aborted) {
+        return { text: "", toolResults: [], usage: void 0 };
+      }
+      throw err;
+    }
+    try {
+      for await (const chunk of stream.textStream) {
+        yield chunk;
+      }
+    } catch (err) {
+      if (this.abortController.signal.aborted) {
+        return { text: "", toolResults: [], usage: void 0 };
+      }
+      throw err;
+    }
+    const duration = Date.now() - startTime;
+    const text = await stream.text;
+    const reasoningText = await stream.reasoningText;
+    const toolResults = await stream.toolResults;
+    const rawUsage = await stream.usage;
+    const usage = rawUsage ? { inputTokens: rawUsage.inputTokens ?? 0, outputTokens: rawUsage.outputTokens ?? 0 } : void 0;
+    this.hooks.afterLLM?.({ step, usage, durationMs: duration });
+    return {
+      text,
+      reasoningText,
+      toolResults: toolResults?.map((tr) => ({
+        toolCallId: tr.toolCallId,
+        result: tr.result,
+        isError: tr.isError
+      })),
+      usage
+    };
+  }
+  /** Batch wrapper — iterates streamLoop and returns the final result. */
+  async collectLoop(opts) {
+    const gen = this.streamLoop(opts);
+    let result;
+    while (true) {
+      const { done, value } = await gen.next();
+      if (done) {
+        result = value;
+        break;
+      }
+    }
+    return result;
+  }
+  abort() {
+    this.abortController.abort();
+  }
+};
+
+// src/services/agents/utils/conversation-to-sdk-messages.ts
+function conversationToSdkMessages(entries) {
+  const messages = [];
+  for (const entry of entries) {
+    switch (entry.type) {
+      case "user" /* User */:
+        messages.push({ role: "user", content: entry.message.content });
+        break;
+      case "assistant" /* Assistant */: {
+        const hasSkipReply = entry.toolCalls?.some((tc) => tc.toolName === "skip_reply");
+        const effectiveContent = hasSkipReply ? "" : entry.message.content;
+        const parts = [];
+        if (effectiveContent) {
+          parts.push({ type: "text", text: effectiveContent });
+        }
+        if (entry.toolCalls?.length) {
+          for (const tc of entry.toolCalls) {
+            parts.push({
+              type: "tool-call",
+              toolCallId: tc.toolCallId,
+              toolName: tc.toolName,
+              input: parseJsonSafe(tc.arguments)
+            });
+          }
+        }
+        if (parts.length === 1 && parts[0].type === "text") {
+          messages.push({ role: "assistant", content: parts[0].text });
+        } else if (parts.length > 0) {
+          messages.push({ role: "assistant", content: parts });
+        }
+        if (entry.toolResults?.length) {
+          messages.push({
+            role: "tool",
+            content: entry.toolResults.map((tr) => ({
+              type: "tool-result",
+              toolCallId: tr.toolCallId,
+              toolName: tr.toolName,
+              output: tr.output
+            }))
+          });
+        }
+        if (entry.toolCalls?.length) {
+          const resultIds = new Set(entry.toolResults?.map((tr) => tr.toolCallId) ?? []);
+          const orphanCalls = entry.toolCalls.filter((tc) => !resultIds.has(tc.toolCallId));
+          if (orphanCalls.length > 0) {
+            messages.push({
+              role: "tool",
+              content: orphanCalls.map((tc) => ({
+                type: "tool-result",
+                toolCallId: tc.toolCallId,
+                toolName: tc.toolName,
+                output: { type: "text", value: "[No result \u2014 step was interrupted]" }
+              }))
+            });
+          }
+        }
+        break;
+      }
+      case "system" /* System */:
+        break;
+      case "signal" /* Signal */: {
+        const sig = entry;
+        const label = sig.subtype.replace("worker_", "").toUpperCase();
+        const taskTag = sig.taskId ? ` task=${sig.taskId}` : "";
+        messages.push({
+          role: "system",
+          content: `[WORKER PROGRESS SIGNAL: ${label}${taskTag}] ${sig.content}`
+        });
+        break;
+      }
+    }
+  }
+  return messages;
+}
+function parseJsonSafe(text) {
+  if (!text) return {};
+  try {
+    return JSON.parse(text);
+  } catch {
+    return text;
+  }
+}
+
+// src/services/agents/utils/estimate-tokens.ts
+function estimateTokens(text) {
+  if (!text) return 0;
+  return Math.ceil(text.length / 4);
+}
+function estimateConversationTokens(entries) {
+  let total = 0;
+  for (const entry of entries) {
+    if (entry.message?.content) {
+      total += estimateTokens(entry.message.content);
+    }
+    if (entry.arguments) {
+      total += estimateTokens(typeof entry.arguments === "string" ? entry.arguments : JSON.stringify(entry.arguments));
+    }
+    if (entry.result) {
+      total += estimateTokens(entry.result);
+    }
+    if (entry.content) {
+      total += estimateTokens(entry.content);
+    }
+  }
+  return total;
+}
+
+// src/utils/time.ts
+function nowISO() {
+  const now = /* @__PURE__ */ new Date();
+  const off = -now.getTimezoneOffset();
+  const sign = off >= 0 ? "+" : "-";
+  const absOff = Math.abs(off);
+  const hh = String(Math.floor(absOff / 60)).padStart(2, "0");
+  const mm = String(absOff % 60).padStart(2, "0");
+  const pad = (n, len = 2) => String(n).padStart(len, "0");
+  return `${now.getFullYear()}-${pad(now.getMonth() + 1)}-${pad(now.getDate())}T${pad(now.getHours())}:${pad(now.getMinutes())}:${pad(now.getSeconds())}.${pad(now.getMilliseconds(), 3)}${sign}${hh}:${mm}`;
+}
+
+// src/services/agents/context-manager.ts
+var DEFAULT_MAX_TOKENS = 1e5;
+var COMPACT_THRESHOLD_RATIO = 0.9;
+var RECENT_TOKEN_BUDGET = 2e4;
+var COMPACT_MAX_RETRIES = 2;
+var ContextManager = class {
+  constructor(state, staticPrompt, dynamicContextFn, maxTokens) {
+    this.state = state;
+    this.staticPrompt = staticPrompt;
+    this.dynamicContextFn = dynamicContextFn;
+    this.maxTokens = maxTokens ?? DEFAULT_MAX_TOKENS;
+  }
+  state;
+  staticPrompt;
+  dynamicContextFn;
+  maxTokens;
+  /**
+   * Cached compact state — updated by compact() and restore(), read by getMessages().
+   * Null means no compaction has occurred.
+   */
+  compactSummary = null;
+  /**
+   * Index into the conversation array: entries from this index onward are the
+   * "recent" entries that should be sent to the LLM alongside the summary.
+   * Updated together with compactSummary.
+   */
+  compactStartIdx = 0;
+  // --- Public API ---
+  getSystemPrompt() {
+    const parts = [this.staticPrompt];
+    if (this.compactSummary) {
+      parts.push(`
+[Conversation Summary]
+${this.compactSummary}`);
+    }
+    parts.push("\n" + this.dynamicContextFn());
+    return parts.join("\n\n");
+  }
+  /**
+   * Build messages for the LLM.
+   *
+   * If no compaction has occurred, converts the full conversation.
+   * If compacted, returns: [summary system msg] + [recent entries (compactStartIdx..)].
+   * No backward scanning — uses cached compactSummary and compactStartIdx.
+   */
+  getMessages() {
+    const conversation = this.state.get("conversation");
+    if (!this.compactSummary) {
+      return conversationToSdkMessages(conversation);
+    }
+    const recentEntries = conversation.slice(this.compactStartIdx);
+    return [
+      { role: "system", content: `[Conversation Summary]
+${this.compactSummary}` },
+      ...conversationToSdkMessages(recentEntries)
+    ];
+  }
+  /** Check if context exceeds the compaction threshold. */
+  isFull() {
+    const promptTokens = estimateTokens(this.getSystemPrompt());
+    const convTokens = estimateConversationTokens(this.getMessages());
+    return promptTokens + convTokens > this.maxTokens * COMPACT_THRESHOLD_RATIO;
+  }
+  /**
+   * Compact the conversation by summarizing all current entries.
+   *
+   * Appends a compact marker entry to the conversation (and JSONL file).
+   * Does NOT modify or remove any existing entries — storage is append-only.
+   *
+   * The summarizer receives ALL entries and returns a summary.
+   * After compaction, getMessages() returns [summary] + entries appended after the marker.
+   */
+  async compact(summarizer) {
+    const conversation = this.state.get("conversation");
+    if (conversation.length < 4) return;
+    const summary = await summarizer(conversation);
+    this.compactSummary = summary;
+    this.compactStartIdx = conversation.length;
+    this.state.append("conversation", {
+      type: "system" /* System */,
+      uuid: generateId("compact"),
+      parentUuid: null,
+      sessionId: this.state.get("runtimeState.session.id") ?? "",
+      timestamp: nowISO(),
+      subtype: "compact" /* Compact */,
+      content: summary,
+      compactMeta: {
+        summarizedTokenCount: estimateConversationTokens(conversation)
+      }
+    });
+  }
+  /**
+   * Restore compact state from persisted conversation.
+   *
+   * Scans for the latest compact marker, then loads recent entries within
+   * the token budget. If loaded entries are fewer than RECENT_TOKEN_BUDGET,
+   * continues loading past the marker (overlap with summary is acceptable).
+   */
+  restoreFromEntries(entries) {
+    const compactIdx = entries.findLastIndex(
+      (e) => e.type === "system" /* System */ && e.subtype === "compact" /* Compact */
+    );
+    if (compactIdx === -1) {
+      this.compactSummary = null;
+      this.compactStartIdx = 0;
+      return;
+    }
+    const summary = entries[compactIdx].content;
+    let budget = RECENT_TOKEN_BUDGET;
+    let cutIdx = 0;
+    for (let i = compactIdx - 1; i >= 0; i--) {
+      const tokens = estimateEntryTokens(entries[i]);
+      budget -= tokens;
+      if (budget <= 0) {
+        cutIdx = i + 1;
+        break;
+      }
+    }
+    this.compactSummary = summary;
+    this.compactStartIdx = compactIdx - cutIdx;
+  }
+};
+function estimateEntryTokens(entry) {
+  const content = entry.message?.content ?? entry.content ?? "";
+  let tokens = estimateTokens(String(content));
+  if (entry.toolCalls?.length) {
+    for (const tc of entry.toolCalls) {
+      tokens += estimateTokens(tc.arguments ?? "");
+    }
+  }
+  if (entry.toolResults?.length) {
+    for (const tr of entry.toolResults) {
+      tokens += estimateTokens(tr.output?.value ?? "");
+    }
+  }
+  return tokens;
+}
+
+// src/services/agents/utils/build-assistant-entry.ts
+function buildAssistantEntry(event, sessionId, uuid) {
+  const ts = nowISO();
+  const text = event.text ?? "";
+  const reasoning = event.reasoningText && event.reasoningText !== "[]" && event.reasoningText.length > 0 ? event.reasoningText : void 0;
+  const toolCalls = event.toolCalls?.length ? event.toolCalls.map((tc) => ({
+    toolCallId: tc.toolCallId,
+    toolName: tc.toolName,
+    arguments: (
+      // SDK OnStepFinishEvent type incomplete
+      typeof tc.args === "string" ? tc.args : JSON.stringify(tc.args ?? tc.input ?? {})
+    )
+  })) : [];
+  const results = [];
+  if (event.toolResults?.length) {
+    results.push(
+      ...event.toolResults.map((tr) => ({
+        toolCallId: tr.toolCallId,
+        toolName: tr.toolName,
+        output: {
+          type: "text",
+          value: (
+            // SDK OnStepFinishEvent type incomplete
+            typeof tr.output === "string" ? tr.output : JSON.stringify(tr.output ?? "")
+          )
+        }
+      }))
+    );
+  }
+  const content = event.content;
+  if (Array.isArray(content)) {
+    for (const part of content) {
+      if (part.type === "tool-error" && part.toolCallId) {
+        results.push({
+          toolCallId: part.toolCallId,
+          toolName: part.toolName ?? "unknown",
+          output: {
+            type: "text",
+            value: part.error?.message ?? part.error ?? "Tool input validation failed"
+          },
+          isError: true
+        });
+      }
+    }
+  }
+  const toolResults = results;
+  const usage = event.usage ? { inputTokens: event.usage.inputTokens ?? 0, outputTokens: event.usage.outputTokens ?? 0 } : void 0;
+  return {
+    type: "assistant" /* Assistant */,
+    uuid: uuid ?? generateId("step"),
+    parentUuid: null,
+    sessionId,
+    timestamp: ts,
+    message: {
+      role: "assistant",
+      content: text,
+      reasoning,
+      usage
+    },
+    toolCalls: toolCalls.length > 0 ? toolCalls : void 0,
+    toolResults: toolResults.length > 0 ? toolResults : void 0,
+    finishReason: event.finishReason
+  };
+}
+
+// src/services/agents/controller-agent.ts
+import { generateText } from "ai";
+
+// src/services/agents/prompts/prompt-utils.ts
+function assemble(...sections) {
+  return sections.filter((s) => typeof s === "string" && s.length > 0).join("\n\n");
+}
+function section(title, body) {
+  if (!body.trim()) return "";
+  return `# ${title}
+
+${body.trim()}`;
+}
+
+// src/services/agents/prompts/controller-prompt.ts
+var IDENTITY = section(
+  "Identity",
+  `You are Wayang \u2014 an intelligent assistant that can execute real tasks (write code, run commands, manage files) through background workers.
+From the user's perspective, you ARE the system. Never mention "Controller", "Worker", or internal architecture \u2014 just get things done.`
+);
+var RESPONSE_STYLE = section(
+  "Response style",
+  `Be direct. Minimum tokens, maximum clarity.
+
+## Responding to user messages
+Always respond to user input \u2014 never leave the user without a reply.
+- Answer questions immediately. No greetings, no filler, no preamble.
+- When the user gives a command, acknowledge briefly AND call the tool in the same turn.
+- Match the user's language automatically.
+- No emoji unless the user uses them first.
+- Output plain text only. Do NOT use Markdown formatting (no bold, no code blocks, no headings, no tables). Your output renders in a terminal that does not support Markdown rendering.
+
+## Responding to worker signals
+Worker signals are NOT user messages. Do NOT respond to them the same way.
+See the "Handling signals" section for detailed rules. In short: stay silent on PROGRESS, speak only on COMPLETED or FAILED.
+
+Examples of ideal responses to user messages:
+
+User: 12 + 13 \u7B49\u4E8E\u591A\u5C11
+Assistant: 25
+
+User: \u5E2E\u6211\u5728 src/ \u4E0B\u521B\u5EFA\u4E00\u4E2A hello.ts
+Assistant: \u597D\uFF0C\u9A6C\u4E0A\u521B\u5EFA\u3002
+[calls add_task]
+
+User: \u4EFB\u52A1\u8FDB\u5C55\u5982\u4F55\uFF1F
+Assistant: \u6B63\u5728\u6267\u884C\u4E2D\uFF0C\u8FD8\u6CA1\u5B8C\u6210\u3002
+
+User: hi
+Assistant: \u6709\u4EC0\u4E48\u9700\u8981\u5E2E\u5FD9\u7684\uFF1F`
+);
+var TOOL_USAGE = section(
+  "Task delegation",
+  `## When to create a task
+
+Use add_task when the request requires **execution** \u2014 writing code, running commands, file operations, complex content generation, etc.
+
+Answer directly (no task needed) for:
+- Simple questions, calculations, explanations
+- Clarification requests
+- Checking task status
+
+## Choosing a worker type
+
+Use the \`workerType\` parameter to choose the right worker:
+- \`puppet\` (default) \u2014 built-in worker for general tasks using shell commands and file I/O.
+- Configured worker IDs (e.g. \`claude-code\`) \u2014 specialized workers for specific domains.
+Check the "Available workers" section below for current options.
+
+## How to write a good task description
+
+The worker only sees the task description \u2014 it has NO access to your conversation.
+Write it as a **self-contained instruction**:
+1. What to do (specific, unambiguous)
+2. All context/data the worker needs
+3. Expected output (file path, format, etc.)
+4. Constraints (language, length, style)
+
+Bad: "Write the essay the user asked for"
+Good: "Write a 200-word Chinese prose essay about autumn. Save to sanwen.txt in UTF-8."
+
+## After creating a task
+
+Give the user a brief one-line acknowledgement, then STOP. Do not speculate about results.`
+);
+var SIGNAL_HANDLING = section(
+  "Handling signals",
+  `Worker signals are delivered as messages with a special prefix. They are NOT from the user.
+
+Format: [WORKER SIGNAL: TYPE task=TASK_ID] content
+
+## [WORKER SIGNAL: PROGRESS ...] \u2014 task is still running
+
+Call \`skip_reply()\` IMMEDIATELY as your ONLY action. Do not output any text before, after, or alongside it.
+
+\u2705 Correct response to ANY progress signal:
+   \u2192 call skip_reply()   (nothing else)
+
+\u274C Wrong responses:
+   \u2192 "\u6B63\u5728\u5199\u4F5C\u4E2D" then call skip_reply()   (text before tool)
+   \u2192 call skip_reply() then "\u8BF7\u7A0D\u5019"       (text after tool)
+   \u2192 "\u5C0F\u8BF4\u5DF2\u5B8C\u6210\uFF01\u4FDD\u5B58\u5728 novel.txt"          (fabricating result)
+   \u2192 call list_tasks()                      (polling)
+
+The ONLY exception: speak up if the progress indicates an unexpected error or problem.
+
+## [WORKER SIGNAL: COMPLETED ...] \u2014 task is finished
+
+NOW report the result to the user. Summarize concisely.
+If the result says "(max steps reached)" or is empty, be honest \u2014 the task did not fully complete.
+
+## [WORKER SIGNAL: FAILED ...] \u2014 task failed
+
+Explain the error. Suggest a retry or alternative.
+
+CRITICAL RULES:
+- PROGRESS \u2260 COMPLETED. Even if the progress text says "\u5B8C\u6210" or "done", it is still just a progress update. Only [WORKER SIGNAL: COMPLETED] means the task actually finished.
+- Do NOT call list_tasks or get_task_detail after receiving a signal. The signal already contains the information.
+- When handling PROGRESS, skip_reply must be the ONLY tool call with NO text output. The system will stop execution after skip_reply.`
+);
+var HARD_CONSTRAINTS = section(
+  "Hard constraints",
+  `- NEVER execute commands or write files yourself. Delegate via add_task.
+- NEVER poll or busy-wait for task completion.
+- NEVER fabricate results. Only report what you actually received.
+- NEVER ignore errors \u2014 always surface them.
+- NEVER mention internal concepts (Controller, Worker, signals) to the user. You are just "Wayang".`
+);
+function buildEnvironment() {
+  const now = /* @__PURE__ */ new Date();
+  const date = now.toLocaleDateString("zh-CN", { year: "numeric", month: "2-digit", day: "2-digit" });
+  const weekday = now.toLocaleDateString("en-US", { weekday: "long" });
+  return section("Environment", `- Date: ${date} (${weekday})`);
+}
+function buildWorkerList(workers) {
+  const lines = [`- \`puppet\` \u2014 ${PUPPET_DEFAULTS.description} [${PUPPET_DEFAULTS.capabilities.join(", ")}]`];
+  if (workers) {
+    for (const [id, config] of Object.entries(workers)) {
+      const caps = config.capabilities?.length ? ` [${config.capabilities.join(", ")}]` : "";
+      lines.push(`- \`${id}\` \u2014 ${config.description}${caps}`);
+    }
+  }
+  return section("Available workers", lines.join("\n"));
+}
+function buildControllerSystemPrompt(ctx) {
+  return assemble(
+    IDENTITY,
+    RESPONSE_STYLE,
+    TOOL_USAGE,
+    SIGNAL_HANDLING,
+    HARD_CONSTRAINTS,
+    buildWorkerList(ctx?.workers),
+    buildEnvironment()
+  );
+}
+
+// src/services/agents/prompts/worker-prompt.ts
+var IDENTITY2 = section(
+  "Identity",
+  `You are a Wayang Worker \u2014 an autonomous task executor in a multi-agent system.
+You receive a single task description as your first message. Your job is to complete it using the available tools, then report the outcome.`
+);
+var LANGUAGE_RULES = section(
+  "Language",
+  `- Match the language of the task description. If the task is in Chinese, think and output in Chinese. If in English, use English.
+- Internal tool arguments (file content, code, commands) should use the language appropriate for the content \u2014 code comments in English, prose in the task's language.
+- Progress reports and done/fail summaries should match the task's language.`
+);
+var TOOL_USAGE2 = section(
+  "Tool usage",
+  `## Mandatory termination
+
+Every run MUST end with exactly one call to \`done\` or \`fail\`. No exceptions.
+- Call \`done(summary)\` when the task is completed successfully.
+- Call \`fail(error)\` when you cannot complete the task.
+- Never end without calling one of these \u2014 the system cannot detect completion otherwise.`
+);
+var EXECUTION_STRATEGY = section(
+  "Execution strategy",
+  `## Planning
+
+Before acting, briefly plan your approach (you have a step budget \u2014 use it wisely):
+1. Understand the task requirements
+2. Break it into concrete steps
+3. Execute each step, verifying the result before moving on
+
+## File operations
+
+- Always verify write results: after write_file, use read_file to confirm content is correct.
+- Use absolute or workspace-relative paths. Do not guess paths \u2014 use bash(ls) or read_file to discover them.
+- When creating files, include ALL the content in a single write_file call. Never write an empty file intending to fill it later.
+
+## Shell commands
+
+- Prefer simple, well-known commands. Avoid complex pipelines when individual commands suffice.
+- Always check command output for errors before proceeding.
+- If a command fails, analyze stderr and try an alternative approach.
+- Long-running commands (builds, installs) may hit the 30s timeout \u2014 break them into smaller steps if needed.
+
+## Error recovery
+
+- If a tool call fails, do NOT repeat the same call blindly. Analyze the error and adjust.
+- After 2 failed attempts at the same approach, try a different strategy.
+- If the task is fundamentally impossible (missing dependencies, permission denied, etc.), call fail() with a clear explanation.`
+);
+var QUALITY_RULES = section(
+  "Quality rules",
+  `- Produce complete, working output. No placeholders, TODOs, or "fill in later" stubs.
+- When writing code: ensure it compiles/runs. When writing prose: meet the requested length and quality.
+- When writing files: include the FULL content. Never write partial content expecting to append later.
+- Verify your work before calling done(). Read back files you wrote. Run code you generated.
+- Output plain text only. Do NOT use Markdown formatting (no bold, no code blocks, no headings, no tables). Your output renders in a terminal.`
+);
+var HARD_CONSTRAINTS2 = section(
+  "Hard constraints",
+  `- MUST call done() or fail() to terminate. Never just stop.
+- NEVER write empty files. If you call write_file, the content parameter must contain the actual content.
+- NEVER exceed your step budget silently \u2014 if you're running out of steps, call done() with partial results or fail() explaining the limitation.
+- NEVER run destructive commands (rm -rf /, DROP DATABASE, etc.) without explicit instruction in the task.
+- ALL file operations (read_file, write_file) are sandboxed to the workspace directory. Paths outside will be rejected. Use relative paths or paths under the workspace shown in the Environment section.
+- bash commands run with cwd set to the workspace. Do NOT cd out of it or write to paths outside it.`
+);
+var PROGRESS_REPORTING = section(
+  "Progress reporting",
+  `Use update_progress sparingly \u2014 only at moments the user would genuinely want to know about.
+
+## GOOD times to report:
+- Task has multiple phases: report when entering the next phase (e.g., "Dependencies installed, starting build")
+- A long-running step begins (> 5s expected): "Running tests..."
+- You recovered from an error: "write_file failed, retrying with corrected path"
+- A sub-deliverable is ready: "Database schema created, now seeding data"
+
+## BAD times to report (do NOT):
+- Every individual tool call ("Reading file X", "Writing file Y")
+- Trivial progress that adds no information ("Working on it...", "Almost done")
+- Restating the task description
+- Right before calling done() or fail(). The done/fail summary IS the final report \u2014 do not duplicate it as a progress message
+
+## Summary quality
+The summary in done() is what the user sees as the final result. Make it specific:
+
+Bad: "Task completed successfully"
+Good: "Created sanwen.txt (218 words, prose about autumn rain)"
+
+Bad: "Failed"
+Good: "Failed: npm install timed out after 30s, network may be unreachable"`
+);
+function buildEnvironment2(ctx) {
+  const now = /* @__PURE__ */ new Date();
+  const date = now.toLocaleDateString("zh-CN", { year: "numeric", month: "2-digit", day: "2-digit" });
+  const lines = [];
+  lines.push(`- Date: ${date}`);
+  lines.push(`- Task ID: ${ctx.taskId}`);
+  lines.push(`- Workspace: ${ctx.workspaceDir}`);
+  return section("Environment", lines.join("\n"));
+}
+function buildWorkerSystemPrompt(ctx) {
+  return assemble(
+    IDENTITY2,
+    LANGUAGE_RULES,
+    TOOL_USAGE2,
+    EXECUTION_STRATEGY,
+    QUALITY_RULES,
+    HARD_CONSTRAINTS2,
+    PROGRESS_REPORTING,
+    ctx ? buildEnvironment2(ctx) : void 0
+  );
+}
+
+// src/services/agents/prompts/third-party-prompt.ts
+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).",
+  "Do NOT output a final summary right before completing \u2014 the system already captures the result separately.",
+  "Match the language of the task description.",
+  "</Rules>"
+].join("\n");
+function buildThirdPartyPrompt() {
+  return `${RULES}
+
+---
+
+`;
+}
+
+// src/services/agents/prompts/summarizer.ts
+var SUMMARIZER_SYSTEM_PROMPT = `You are a conversation summarizer for a multi-agent orchestration system. Create a concise but complete summary of the conversation entries below.
+
+Requirements:
+- Preserve all key decisions, task assignments, and outcomes
+- Preserve task IDs, worker IDs, and file paths mentioned
+- Note any errors or failures and their resolution status
+- Keep the summary under 500 words
+- Use bullet points for clarity`;
+function buildSummarizerPrompt(entryTexts) {
+  return `Summarize the following ${entryTexts.length} conversation entries. Focus on preserving actionable context \u2014 decisions, task IDs, outcomes, and any unresolved issues.
+
+${entryTexts.join("\n")}`;
+}
+
+// src/services/agents/controller-agent.ts
+var ControllerAgent = class extends BaseAgent {
+  state;
+  contextManager;
+  tools;
+  logger;
+  constructor(state, provider, tools, logger, workerConfigs) {
+    super(provider);
+    this.state = state;
+    this.tools = tools;
+    this.logger = logger;
+    this.contextManager = new ContextManager(
+      state,
+      buildControllerSystemPrompt({ workers: workerConfigs }),
+      () => ""
+    );
+    this.setHooks({
+      beforeLLM: ({ messages }) => {
+        this.logger.debug({ messages }, "LLM call start");
+      },
+      afterLLM: ({ step, usage, durationMs }) => {
+        this.logger.info({ agent: "controller", step, usage, durationMs }, "LLM call done");
+      }
+    });
+  }
+  /** Run the controller agent — streams text chunks while updating streamingEntries in state. */
+  async run(signals) {
+    this.state.set("dynamicState.busy", true);
+    try {
+      return await this._run(signals);
+    } finally {
+      this.state.set("dynamicState.busy", false);
+    }
+  }
+  async _run(signals) {
+    const ts = nowISO();
+    for (const sig of signals) {
+      if (sig.type === "input") {
+        const text = sig.payload.text;
+        this.state.append("conversation", {
+          type: "user" /* User */,
+          uuid: generateId("u"),
+          parentUuid: null,
+          sessionId: "controller",
+          timestamp: ts,
+          message: { role: "user", content: text }
+        });
+      } else if (sig.type === "completed") {
+        this.state.append("conversation", {
+          type: "signal" /* Signal */,
+          uuid: generateId("sig"),
+          parentUuid: null,
+          sessionId: "controller",
+          timestamp: ts,
+          subtype: "worker_completed" /* WorkerCompleted */,
+          workerId: sig.payload.workerId,
+          workerType: sig.payload.workerType,
+          emoji: sig.payload.emoji,
+          taskId: sig.payload.taskId,
+          taskTitle: sig.payload.taskTitle,
+          content: sig.payload.summary ?? JSON.stringify(sig.payload)
+        });
+      } else if (sig.type === "failed") {
+        this.state.append("conversation", {
+          type: "signal" /* Signal */,
+          uuid: generateId("sig"),
+          parentUuid: null,
+          sessionId: "controller",
+          timestamp: ts,
+          subtype: "worker_failed" /* WorkerFailed */,
+          workerId: sig.payload.workerId,
+          workerType: sig.payload.workerType,
+          emoji: sig.payload.emoji,
+          taskId: sig.payload.taskId,
+          taskTitle: sig.payload.taskTitle,
+          content: sig.payload.error
+        });
+      } else if (sig.type === "progress") {
+        this.state.append("conversation", {
+          type: "signal" /* Signal */,
+          uuid: generateId("sig"),
+          parentUuid: null,
+          sessionId: "controller",
+          timestamp: ts,
+          subtype: "worker_progress" /* WorkerProgress */,
+          workerId: sig.payload.workerId,
+          workerType: sig.payload.workerType,
+          emoji: sig.payload.emoji,
+          taskId: sig.payload.taskId,
+          taskTitle: sig.payload.taskTitle,
+          content: sig.payload.message
+        });
+      } else {
+        this.state.append("conversation", {
+          type: "signal" /* Signal */,
+          uuid: generateId("sig"),
+          parentUuid: null,
+          sessionId: "controller",
+          timestamp: ts,
+          subtype: "worker_failed" /* WorkerFailed */,
+          workerId: sig.payload.workerId,
+          workerType: sig.payload.workerType,
+          emoji: sig.payload.emoji,
+          taskId: sig.payload.taskId,
+          content: JSON.stringify(sig.payload)
+        });
+      }
+    }
+    this.state.set("dynamicState.streamingEntries", []);
+    let streamingEntry = this.createStreamingEntry();
+    const gen = this.streamLoop({
+      system: this.contextManager.getSystemPrompt(),
+      messages: this.contextManager.getMessages(),
+      tools: this.tools,
+      maxSteps: 50,
+      stopTools: ["skip_reply"],
+      onStep: (event) => {
+        const streamingEntries = this.state.get("dynamicState.streamingEntries");
+        const streamingUuid = streamingEntries?.[0]?.uuid;
+        const entry = buildAssistantEntry(event, this.id, streamingUuid);
+        this.state.append("conversation", entry);
+        this.state.set("dynamicState.streamingEntries", []);
+      }
+    });
+    let fullText = "";
+    for await (const chunk of gen) {
+      if (chunk) {
+        const current = this.state.get("dynamicState.streamingEntries");
+        if (!current || current.length === 0) {
+          streamingEntry = this.createStreamingEntry();
+        }
+        streamingEntry.message.content += chunk;
+        fullText += chunk;
+        this.state.set("dynamicState.streamingEntries", [streamingEntry]);
+      }
+    }
+    return { text: fullText };
+  }
+  /** Create a fresh streaming entry placeholder. */
+  createStreamingEntry() {
+    return {
+      type: "assistant" /* Assistant */,
+      uuid: generateId("s"),
+      parentUuid: null,
+      sessionId: "controller",
+      timestamp: nowISO(),
+      message: { role: "assistant", content: "" }
+    };
+  }
+  /** Check if context needs compaction. */
+  needsCompaction() {
+    return this.contextManager.isFull();
+  }
+  /**
+   * Run compaction — uses the LLM to summarize conversation entries.
+   *
+   * Retries up to COMPACT_MAX_RETRIES times on failure.
+   * Falls back to truncating half of the history in memory (file preserved).
+   */
+  async performCompaction() {
+    try {
+      await this.contextManager.compact(async (entries) => {
+        const entryTexts = entries.map((e, i) => {
+          const content = e.message?.content ?? e.content ?? "";
+          return `[${i}] (${e.type}) ${String(content).slice(0, 300)}`;
+        });
+        let lastError;
+        for (let attempt = 0; attempt <= COMPACT_MAX_RETRIES; attempt++) {
+          try {
+            const { text } = await generateText({
+              model: this.model,
+              // WayangModel opaque boundary
+              system: SUMMARIZER_SYSTEM_PROMPT,
+              prompt: buildSummarizerPrompt(entryTexts)
+            });
+            return text;
+          } catch (err) {
+            lastError = err;
+            this.logger.warn({ attempt: attempt + 1, error: String(err) }, "Compaction summarizer failed");
+          }
+        }
+        throw lastError;
+      });
+    } catch (err) {
+      this.logger.warn({ error: String(err) }, "Compaction failed, falling back to half-truncation");
+      const conversation = this.state.get("conversation");
+      if (conversation.length > 4) {
+        const half = Math.floor(conversation.length / 2);
+        this.state.set("conversation", conversation.slice(-half));
+        this.logger.info({ kept: half, total: conversation.length }, "History truncated (half) as compaction fallback");
+      }
+    }
+  }
+};
+
+// src/services/tools/add-task.ts
+import { z } from "zod";
+
+// src/services/tools/common.ts
+import { tool } from "ai";
+var MAX_RESULT_CHARS = 8e3;
+function truncate(result) {
+  if (result.length <= MAX_RESULT_CHARS) return result;
+  return result.slice(0, MAX_RESULT_CHARS) + "\n...(truncated)";
+}
+function safeExecute(name, fn) {
+  return async (args, _options) => {
+    try {
+      const result = await fn(args);
+      return truncate(typeof result === "string" ? result : JSON.stringify(result));
+    } catch (err) {
+      return `[ERROR] ${name}: ${err.message ?? String(err)}`;
+    }
+  };
+}
+function defineTool(def) {
+  const { parameters, ...rest } = def;
+  return tool({ ...rest, inputSchema: parameters });
+}
+
+// src/services/tools/add-task.ts
+function addTaskTool(deps) {
+  return defineTool({
+    description: "Add a new task to the queue. A Worker will execute it automatically.",
+    parameters: z.object({
+      title: z.string().max(10).describe("Brief task title, max 10 characters"),
+      description: z.string().describe("Detailed task description for the Worker"),
+      priority: z.enum(["normal", "high"]).default("normal").describe("Priority level"),
+      workerType: z.string().optional().describe('Worker type: "puppet" (default, built-in LLM) or a configured worker ID (e.g. "claude-code")')
+    }),
+    execute: safeExecute("add_task", async ({ title, description, priority, workerType }) => {
+      const resolvedType = workerType || "puppet";
+      if (deps.validateWorkerType) {
+        const err = deps.validateWorkerType(resolvedType);
+        if (err) return err;
+      }
+      const task = {
+        id: generateId("t"),
+        title,
+        description,
+        priority,
+        workerType: resolvedType,
+        status: "pending",
+        createdAt: Date.now()
+      };
+      deps.addTask(task);
+      return `Task ${task.id} added (priority: ${priority}, worker: ${task.workerType}). You will be notified when the task completes.`;
+    })
+  });
+}
+
+// src/services/tools/list-tasks.ts
+import { z as z2 } from "zod";
+function listTasksTool(deps) {
+  return defineTool({
+    description: "View the task list",
+    parameters: z2.object({
+      status: z2.enum(["pending", "running", "completed", "failed", "cancelled"]).optional().describe("Filter by status")
+    }),
+    execute: safeExecute("list_tasks", async ({ status }) => {
+      const tasks = deps.listTasks(status);
+      if (tasks.length === 0) return status ? `No ${status} tasks` : "No tasks";
+      return tasks.map(
+        (t) => `[${t.status}] ${t.id}: ${t.description}${t.result ? ` \u2192 ${t.result}` : ""}${t.error ? ` \u2717 ${t.error}` : ""}`
+      ).join("\n");
+    })
+  });
+}
+
+// src/services/tools/cancel-task.ts
+import { z as z3 } from "zod";
+function cancelTaskTool(deps) {
+  return defineTool({
+    description: "Cancel a running or pending task",
+    parameters: z3.object({
+      taskId: z3.string().describe("Task ID to cancel")
+    }),
+    execute: safeExecute("cancel_task", async ({ taskId }) => {
+      if (deps.abortWorker) {
+        deps.abortWorker(taskId);
+      }
+      const cancelled = deps.cancelTask(taskId);
+      if (!cancelled) return `Task ${taskId} not found or already completed`;
+      return `Task ${taskId} cancelled`;
+    })
+  });
+}
+
+// src/services/tools/get-task-detail.ts
+import { z as z4 } from "zod";
+function getTaskDetailTool(deps) {
+  return defineTool({
+    description: "Get detailed information about a specific task",
+    parameters: z4.object({
+      taskId: z4.string().describe("Task ID")
+    }),
+    execute: safeExecute("get_task_detail", async ({ taskId }) => {
+      const task = deps.getTask(taskId);
+      if (!task) return `Task ${taskId} not found`;
+      const lines = [
+        `ID: ${task.id}`,
+        `Status: ${task.status}`,
+        `Priority: ${task.priority}`,
+        `Description: ${task.description}`,
+        `Created: ${new Date(task.createdAt).toISOString()}`
+      ];
+      if (task.startedAt) lines.push(`Started: ${new Date(task.startedAt).toISOString()}`);
+      if (task.completedAt) lines.push(`Completed: ${new Date(task.completedAt).toISOString()}`);
+      if (task.result) lines.push(`Result: ${task.result}`);
+      if (task.error) lines.push(`Error: ${task.error}`);
+      if (task.workerSessionId) lines.push(`Worker: ${task.workerSessionId}`);
+      if (deps.getWorkerConversation) {
+        const entries = deps.getWorkerConversation(taskId);
+        if (entries.length > 0) {
+          lines.push(`
+Conversation (${entries.length} entries):`);
+          for (const entry of entries.slice(-10)) {
+            lines.push(`  [${entry.type}] ${entry.message?.content ?? entry.content ?? ""}`.slice(0, 200));
+          }
+        }
+      }
+      return lines.join("\n");
+    })
+  });
+}
+
+// src/services/tools/update-task.ts
+import { z as z5 } from "zod";
+function updateTaskTool(deps) {
+  return defineTool({
+    description: "Update a pending task description or priority",
+    parameters: z5.object({
+      taskId: z5.string().describe("Task ID to update"),
+      description: z5.string().optional().describe("New task description"),
+      priority: z5.enum(["normal", "high"]).optional().describe("New priority")
+    }),
+    execute: safeExecute("update_task", async ({ taskId, description, priority }) => {
+      if (!description && !priority) {
+        return "Nothing to update \u2014 provide description or priority";
+      }
+      const updated = deps.updateTask(taskId, { description, priority });
+      if (!updated) return `Task ${taskId} not found or not in pending status`;
+      return `Task ${taskId} updated`;
+    })
+  });
+}
+
+// src/services/tools/query-signals.ts
+import { z as z6 } from "zod";
+function querySignalsTool(deps) {
+  return defineTool({
+    description: "Query signal history by status, source, or type",
+    parameters: z6.object({
+      status: z6.enum(["unread", "read", "discarded"]).optional().describe("Filter by status"),
+      source: z6.enum(["user", "worker", "system"]).optional().describe("Filter by source"),
+      type: z6.enum(["input", "completed", "failed", "progress", "cancelled"]).optional().describe("Filter by type")
+    }),
+    execute: safeExecute("query_signals", async (filter) => {
+      const signals = deps.querySignals(filter);
+      if (signals.length === 0) return "No matching signals";
+      return signals.map(
+        (s) => `[${s.status}] ${s.source}/${s.type} ${s.id}: ${JSON.stringify(s.payload).slice(0, 150)}`
+      ).join("\n");
+    })
+  });
+}
+
+// src/services/tools/skip-reply.ts
+import { z as z7 } from "zod";
+function skipReplyTool() {
+  return defineTool({
+    description: "Acknowledge a signal without responding to the user. Call this when you receive a PROGRESS signal and have nothing meaningful to say. The user will not see anything.",
+    parameters: z7.object({}),
+    execute: safeExecute("skip_reply", async () => {
+      return "(skipped)";
+    })
+  });
+}
+
+// src/services/tools/bash.ts
+import { z as z8 } from "zod";
+import { execSync } from "child_process";
+function bashTool(deps) {
+  return defineTool({
+    description: "Execute a shell command and return its output",
+    parameters: z8.object({
+      command: z8.string().describe("Shell command to execute")
+    }),
+    execute: safeExecute("bash", async ({ command }) => {
+      try {
+        const output = execSync(command, {
+          cwd: deps.cwd,
+          timeout: 3e4,
+          maxBuffer: 1024 * 1024,
+          encoding: "utf-8"
+        });
+        return output || "(no output)";
+      } catch (err) {
+        const stderr = err.stderr?.toString() || "";
+        return `Exit code ${err.status ?? 1}
+${stderr}`;
+      }
+    })
+  });
+}
+
+// src/services/tools/read-file.ts
+import { z as z9 } from "zod";
+import { readFileSync as readFileSync3 } from "fs";
+import { resolve, relative } from "path";
+function validatePath(resolved, workspace) {
+  const rel = relative(workspace, resolved);
+  if (rel.startsWith("..") || resolve(workspace, rel) !== resolved) {
+    return `Path escapes workspace: ${resolved} (workspace: ${workspace})`;
+  }
+  return null;
+}
+function readFileTool(deps = {}) {
+  const workspace = deps.cwd ?? process.cwd();
+  return defineTool({
+    description: "Read file content. Path must be within the workspace.",
+    parameters: z9.object({
+      path: z9.string().describe("File path (relative to workspace)")
+    }),
+    execute: safeExecute("read_file", async ({ path: path5 }) => {
+      const resolved = resolve(workspace, path5);
+      const err = validatePath(resolved, workspace);
+      if (err) return `[ERROR] read_file: ${err}`;
+      return readFileSync3(resolved, "utf-8");
+    })
+  });
+}
+
+// src/services/tools/write-file.ts
+import { z as z10 } from "zod";
+import { writeFileSync as writeFileSync3, mkdirSync as mkdirSync3 } from "fs";
+import { dirname as dirname3, resolve as resolve2, relative as relative2 } from "path";
+function validatePath2(resolved, workspace) {
+  const rel = relative2(workspace, resolved);
+  if (rel.startsWith("..") || resolve2(workspace, rel) !== resolved) {
+    return `Path escapes workspace: ${resolved} (workspace: ${workspace})`;
+  }
+  return null;
+}
+function writeFileTool(deps = {}) {
+  const workspace = deps.cwd ?? process.cwd();
+  return defineTool({
+    description: "Write content to a file, creating parent directories as needed. Path must be within the workspace.",
+    parameters: z10.object({
+      path: z10.string().describe("File path (relative to workspace)"),
+      content: z10.string().describe("File content")
+    }),
+    execute: safeExecute("write_file", async ({ path: path5, content }) => {
+      const resolved = resolve2(workspace, path5);
+      const err = validatePath2(resolved, workspace);
+      if (err) return `[ERROR] write_file: ${err}`;
+      mkdirSync3(dirname3(resolved), { recursive: true });
+      writeFileSync3(resolved, content, "utf-8");
+      return `Written ${content.length} chars to ${resolved}`;
+    })
+  });
+}
+
+// src/services/tools/done.ts
+import { z as z11 } from "zod";
+function doneTool(deps) {
+  return defineTool({
+    description: "Report task completion. Worker stops executing after this call.",
+    parameters: z11.object({
+      summary: z11.string().describe("Task completion summary")
+    }),
+    execute: safeExecute("done", async ({ summary }) => {
+      deps.onComplete(summary);
+      return `Task completed: ${summary}`;
+    })
+  });
+}
+
+// src/services/tools/fail.ts
+import { z as z12 } from "zod";
+function failTool(deps) {
+  return defineTool({
+    description: "Report task failure. Worker stops executing after this call.",
+    parameters: z12.object({
+      error: z12.string().describe("Error description")
+    }),
+    execute: safeExecute("fail", async ({ error }) => {
+      deps.onFail(error);
+      return `Task failed: ${error}`;
+    })
+  });
+}
+
+// src/services/tools/update-progress.ts
+import { z as z13 } from "zod";
+function updateProgressTool(deps) {
+  return defineTool({
+    description: "Report progress for the current task (replaces automatic step-based progress)",
+    parameters: z13.object({
+      message: z13.string().describe("Progress description"),
+      percent: z13.number().min(0).max(100).optional().describe("Completion percentage (0-100)")
+    }),
+    execute: safeExecute("update_progress", async ({ message, percent }) => {
+      deps.reportProgress(message, percent);
+      const suffix = percent !== void 0 ? ` (${percent}%)` : "";
+      return `Progress reported: ${message}${suffix}`;
+    })
+  });
+}
+
+// src/services/tools/index.ts
+function createControllerTools(deps) {
+  return {
+    add_task: addTaskTool({ addTask: deps.addTask, validateWorkerType: deps.validateWorkerType }),
+    list_tasks: listTasksTool({ listTasks: deps.listTasks }),
+    cancel_task: cancelTaskTool({
+      cancelTask: deps.cancelTask,
+      abortWorker: deps.abortWorker
+    }),
+    get_task_detail: getTaskDetailTool({
+      getTask: deps.getTask
+    }),
+    update_task: updateTaskTool({ updateTask: deps.updateTask }),
+    query_signals: querySignalsTool({ querySignals: deps.queryMessages }),
+    skip_reply: skipReplyTool()
+  };
+}
+function createWorkerTools(deps) {
+  return {
+    bash: bashTool({ cwd: deps.cwd }),
+    read_file: readFileTool({ cwd: deps.cwd }),
+    write_file: writeFileTool({ cwd: deps.cwd }),
+    list_tasks: listTasksTool({ listTasks: deps.listTasks }),
+    update_progress: updateProgressTool({ reportProgress: deps.reportProgress }),
+    done: doneTool({ onComplete: deps.onComplete }),
+    fail: failTool({ onFail: deps.onFail })
+  };
+}
+
+// src/services/agents/worker-state.ts
+import { join as join6 } from "path";
+var WorkerState = class extends BaseWayangState {
+  constructor(sessionDir, workerId, logger) {
+    const workerDir = join6(sessionDir, "workers", workerId);
+    const jsonFile = new JSONFileHelper(join6(workerDir, "runtime-state.json"));
+    const jsonlFile = new JSONLFileHelper(join6(workerDir, "conversation.jsonl"));
+    const initialData = {
+      runtimeState: {
+        session: { id: workerId, startedAt: Date.now() },
+        task: { id: "", description: "" }
+      },
+      conversation: []
+    };
+    super(initialData, [
+      { path: "runtimeState", helper: jsonFile },
+      { path: "conversation", helper: jsonlFile }
+    ]);
+    this.logger = logger;
+    this.jsonFile = jsonFile;
+    this.jsonlFile = jsonlFile;
+  }
+  logger;
+  jsonFile;
+  jsonlFile;
+  async restore() {
+    const runtimeState = this.jsonFile.read();
+    if (runtimeState) {
+      this.data.runtimeState = runtimeState;
+    }
+    const conversation = this.jsonlFile.read();
+    if (conversation.length > 0) {
+      this.data.conversation = conversation;
+    }
+    this.logger.info("WorkerState restored");
+  }
+  /** Override append to ensure JSONL write-per-entry. */
+  append(path5, entry) {
+    super.append(path5, entry);
+    if (path5 === "conversation") {
+      this.persistAppend(path5, entry);
+    }
+  }
+};
+
+// src/services/agents/constants.ts
+var WORKER_AGENT_MAX_STEP = 1e3;
+
+// src/services/agents/worker-agent.ts
+var WorkerAgent = class extends BaseAgent {
+  state;
+  logger;
+  _terminalResult = null;
+  workspaceDir;
+  contextManager;
+  constructor(provider, sessionDir, workspaceDir2, logger) {
+    super(provider);
+    this.logger = logger;
+    this.workspaceDir = workspaceDir2;
+    this.state = new WorkerState(sessionDir, this.id, logger);
+    this.contextManager = new ContextManager(
+      this.state,
+      buildWorkerSystemPrompt(),
+      () => ""
+    );
+  }
+  async run(task, tools, onProgress) {
+    this.state.set("runtimeState.task", { id: task.id, description: task.description });
+    this.contextManager = new ContextManager(
+      this.state,
+      buildWorkerSystemPrompt({ taskId: task.id, workspaceDir: this.workspaceDir }),
+      () => ""
+    );
+    this._terminalResult = null;
+    this.state.append("conversation", {
+      type: "user" /* User */,
+      uuid: generateId("u"),
+      parentUuid: null,
+      sessionId: this.id,
+      timestamp: nowISO(),
+      message: { role: "user", content: task.description }
+    });
+    const result = await this.collectLoop({
+      system: this.contextManager.getSystemPrompt(),
+      messages: this.contextManager.getMessages(),
+      tools,
+      toolChoice: "required",
+      maxSteps: WORKER_AGENT_MAX_STEP,
+      stopTools: ["done", "fail"],
+      onStep: (event) => {
+        const entry = buildAssistantEntry(event, this.id);
+        this.state.append("conversation", entry);
+        if (event.text && onProgress) {
+          onProgress(event.text.slice(0, 200));
+        }
+      }
+    });
+    if (this._terminalResult) {
+      return this._terminalResult;
+    }
+    if (this.abortController.signal.aborted) {
+      return { status: "failed", error: "Aborted" };
+    }
+    return { status: "completed", summary: result.text || "(max steps reached)" };
+  }
+  /** Called by done tool callback — saves result. Loop stops via stopWhen. */
+  complete(summary) {
+    this._terminalResult = { status: "completed", summary };
+  }
+  /** Called by fail tool callback — saves result. Loop stops via stopWhen. */
+  fail(error) {
+    this._terminalResult = { status: "failed", error };
+  }
+  /** Get state for UI rendering. */
+  getState() {
+    return this.state;
+  }
+};
+
+// src/services/agents/claude-code-worker.ts
+import { query } from "@anthropic-ai/claude-agent-sdk";
+var ClaudeCodeWorker = class _ClaudeCodeWorker {
+  id;
+  config;
+  state;
+  workspaceDir;
+  logger;
+  abortController = new AbortController();
+  _terminalResult = null;
+  /**
+   * Progress debounce mechanism.
+   *
+   * Claude Code SDK streams assistant messages before the final result message.
+   * The last assistant message often contains a summary that duplicates the result.
+   * To avoid showing the user two near-identical signals (progress + completed):
+   *   1. Each assistant text is buffered for PROGRESS_DEBOUNCE_MS
+   *   2. If a result message arrives before the timer fires, the pending progress is discarded
+   *   3. If the timer fires (no result yet), the progress is emitted normally
+   */
+  static PROGRESS_DEBOUNCE_MS = 500;
+  _progressTimer = null;
+  _pendingProgress = null;
+  constructor(config, sessionDir, workspaceDir2, logger) {
+    this.id = generateId("cw");
+    this.config = config;
+    this.workspaceDir = workspaceDir2;
+    this.logger = logger;
+    this.state = new WorkerState(sessionDir, this.id, logger);
+  }
+  async run(task, _tools, onProgress) {
+    this.state.set("runtimeState.task", { id: task.id, description: task.description });
+    this.state.append("conversation", {
+      type: "user" /* User */,
+      uuid: generateId("u"),
+      parentUuid: null,
+      sessionId: this.id,
+      timestamp: nowISO(),
+      message: { role: "user", content: task.description }
+    });
+    try {
+      const options = {
+        cwd: this.workspaceDir,
+        maxTurns: this.config.maxTurns ?? 10,
+        permissionMode: "bypassPermissions",
+        abortController: this.abortController
+      };
+      if (this.config.cliPath) {
+        options.pathToClaudeCodeExecutable = this.config.cliPath;
+      }
+      const stream = query({
+        prompt: `${buildThirdPartyPrompt()}${task.description}`,
+        options
+      });
+      for await (const message of stream) {
+        if (this.abortController.signal.aborted) break;
+        this.processStreamMessage(message, onProgress);
+      }
+    } catch (err) {
+      this.logger.error({ err, taskId: task.id }, "ClaudeCodeWorker query error");
+      if (!this._terminalResult) {
+        this._terminalResult = {
+          status: "failed",
+          error: err.message ?? String(err)
+        };
+      }
+    }
+    if (!this._terminalResult) {
+      this._terminalResult = {
+        status: "failed",
+        error: this.abortController.signal.aborted ? "Aborted" : "No result received from Claude Code"
+      };
+    }
+    this.state.append("conversation", {
+      type: "system" /* System */,
+      uuid: generateId("s"),
+      parentUuid: null,
+      sessionId: this.id,
+      timestamp: nowISO(),
+      subtype: this._terminalResult.status === "completed" ? "compact" : "error",
+      content: this._terminalResult.summary ?? this._terminalResult.error ?? ""
+    });
+    return this._terminalResult;
+  }
+  abort() {
+    this.abortController.abort();
+  }
+  /** Get state for UI rendering. */
+  getState() {
+    return this.state;
+  }
+  // --- Stream message processing ---
+  processStreamMessage(message, onProgress) {
+    if (message.type === "assistant") {
+      this.handleAssistantMessage(message, onProgress);
+    } else if (message.type === "result") {
+      this.handleResultMessage(message);
+    }
+  }
+  handleAssistantMessage(msg, onProgress) {
+    const textParts = [];
+    for (const block of msg.message.content) {
+      if (block.type === "text") {
+        textParts.push(block.text);
+      }
+    }
+    const text = textParts.join("\n");
+    if (!text) return;
+    this.state.append("conversation", {
+      type: "assistant" /* Assistant */,
+      uuid: generateId("a"),
+      parentUuid: null,
+      sessionId: this.id,
+      timestamp: nowISO(),
+      message: {
+        role: "assistant",
+        content: text,
+        usage: {
+          inputTokens: msg.message.usage?.input_tokens ?? 0,
+          outputTokens: msg.message.usage?.output_tokens ?? 0
+        }
+      }
+    });
+    if (onProgress) {
+      this._pendingProgress = text.slice(0, 200);
+      if (this._progressTimer) clearTimeout(this._progressTimer);
+      this._progressTimer = setTimeout(() => {
+        if (this._pendingProgress) {
+          onProgress(this._pendingProgress);
+          this._pendingProgress = null;
+        }
+        this._progressTimer = null;
+      }, _ClaudeCodeWorker.PROGRESS_DEBOUNCE_MS);
+    }
+  }
+  handleResultMessage(msg) {
+    if (this._progressTimer) {
+      clearTimeout(this._progressTimer);
+      this._progressTimer = null;
+      this._pendingProgress = null;
+    }
+    if (msg.subtype === "success") {
+      this._terminalResult = {
+        status: "completed",
+        summary: msg.result
+      };
+    } else {
+      this._terminalResult = {
+        status: "failed",
+        error: msg.errors.join("\n") || `Claude Code error: ${msg.subtype}`
+      };
+    }
+    const prev = this.state.get("runtimeState");
+    this.state.set("runtimeState", {
+      ...prev,
+      usage: {
+        inputTokens: msg.usage.input_tokens,
+        outputTokens: msg.usage.output_tokens,
+        costUsd: msg.total_cost_usd,
+        turns: msg.num_turns,
+        durationMs: msg.duration_ms
+      }
+    });
+    this.logger.info(
+      {
+        subtype: msg.subtype,
+        turns: msg.num_turns,
+        costUsd: msg.total_cost_usd,
+        durationMs: msg.duration_ms
+      },
+      "ClaudeCodeWorker result"
+    );
+  }
+};
+
+// src/services/worker-factory.ts
+var PUPPET_WORKER_TYPE = "puppet";
+var WorkerFactory = class {
+  /**
+   * Create a worker instance for the given type.
+   *
+   * @throws Error if the worker type is unknown or unsupported.
+   */
+  create(workerType, deps) {
+    const type = workerType ?? PUPPET_WORKER_TYPE;
+    if (type === PUPPET_WORKER_TYPE) {
+      return new WorkerAgent(deps.workerProvider, deps.sessionDir, deps.workspaceDir, deps.logger);
+    }
+    const config = deps.workerConfigs?.[type];
+    if (!config) {
+      throw new Error(`Unknown worker type: "${type}". Available: ${Object.keys(deps.workerConfigs ?? {}).join(", ") || "(none)"}`);
+    }
+    if (config.enable === false) {
+      throw new Error(`Worker type "${type}" is disabled`);
+    }
+    switch (config.type) {
+      case "claude-code":
+        return new ClaudeCodeWorker(config, deps.sessionDir, deps.workspaceDir, deps.logger);
+      default:
+        throw new Error(`Unsupported worker type: "${config.type}"`);
+    }
+  }
+  /** Check whether a worker type is known (puppet or configured). */
+  isKnownType(workerType, workerConfigs) {
+    if (!workerType || workerType === PUPPET_WORKER_TYPE) return true;
+    return !!workerConfigs?.[workerType];
+  }
+};
+
+// src/services/supervisor.ts
+var Supervisor = class {
+  ctx;
+  eventBus;
+  controllerState;
+  taskPool;
+  signalQueue;
+  scheduler;
+  controllerAgent;
+  sessionManager;
+  workerFactory;
+  workers = /* @__PURE__ */ new Map();
+  /** Reverse mapping: workerId → taskId, for reliable abort lookup. */
+  workerTaskMap = /* @__PURE__ */ new Map();
+  controllerProvider;
+  workerProvider;
+  config;
+  constructor(options) {
+    const { config, workspaceDir: workspaceDir2, logLevel } = options;
+    if (options.resume) {
+      this.sessionManager = SessionManager.resume(options.resume.sessionId, options.resume.sessionDir);
+    } else {
+      if (!options.homeDir) throw new Error("homeDir is required for new sessions");
+      this.sessionManager = SessionManager.create(options.homeDir, workspaceDir2);
+    }
+    this.ctx = new SystemContext(
+      config,
+      this.sessionManager.sessionId,
+      this.sessionManager.sessionDir,
+      workspaceDir2,
+      logLevel
+    );
+    this.controllerProvider = this.ctx.controllerProvider;
+    this.workerProvider = this.ctx.workerProvider;
+    this.config = config;
+    this.workerFactory = new WorkerFactory();
+    this.ctx.logger.info(
+      { controllerEndpoint: this.controllerProvider.endpoint, controllerModel: this.controllerProvider.modelName },
+      "Provider config"
+    );
+    this.eventBus = new EventBus();
+    this.controllerState = new ControllerAgentState(this.ctx.sessionDir, this.ctx.logger);
+    const taskPoolState = new TaskPoolState(this.ctx.sessionDir, this.ctx.logger);
+    const signalState = new SignalState(this.ctx.sessionDir, this.ctx.logger);
+    this.taskPool = new TaskPool(taskPoolState, this.eventBus, this.ctx.logger);
+    this.signalQueue = new SignalQueue(signalState, this.ctx.logger);
+    this.scheduler = new TaskScheduler(
+      this.ctx.logger,
+      this.taskPool,
+      this.signalQueue,
+      this.eventBus,
+      this,
+      // SchedulerContext
+      this.ctx.maxConcurrency,
+      config.workers
+    );
+    const controllerTools = createControllerTools({
+      addTask: (task) => this.taskPool.add(task),
+      validateWorkerType: (type) => {
+        if (type === "puppet") return null;
+        const workerConfig = config.workers?.[type];
+        if (!workerConfig) return `Unknown worker type: "${type}". Available: puppet${Object.keys(config.workers ?? {}).map((k) => `, ${k}`).join("")}`;
+        if (workerConfig.enable === false) return `Worker "${type}" is disabled`;
+        return null;
+      },
+      listTasks: (status) => this.taskPool.list(status),
+      getTask: (taskId) => this.taskPool.get(taskId),
+      cancelTask: (taskId) => this.taskPool.cancel(taskId),
+      abortWorker: (taskId) => this.abortWorkerByTaskId(taskId),
+      updateTask: (taskId, updates) => this.taskPool.updatePending(taskId, updates),
+      queryMessages: (filter) => this.signalQueue.query(filter)
+    });
+    this.controllerAgent = new ControllerAgent(
+      this.controllerState,
+      this.controllerProvider,
+      controllerTools,
+      this.ctx.logger,
+      config.workers
+    );
+    this.scheduler.setSpawnFn((taskWithWorker) => {
+      return this.spawnWorker(taskWithWorker);
+    });
+  }
+  // --- Lifecycle ---
+  async restore() {
+    await Promise.all([
+      this.sessionManager.restore(),
+      this.controllerState.restore(),
+      this.taskPool.restore(),
+      this.signalQueue.restore()
+    ]);
+    this.recoverCrashedWorkers();
+    this.ctx.logger.info("Supervisor restored");
+  }
+  async start() {
+    this.controllerState.set("runtimeState.session", {
+      id: this.ctx.sessionId,
+      startedAt: this.ctx.startedAt
+    });
+    this.scheduler.start();
+    this.ctx.logger.info("Supervisor started");
+  }
+  // --- Worker management ---
+  /**
+   * Crash recovery: detect stale workers and orphaned tasks.
+   * On resume, running tasks from a crashed session are marked failed,
+   * and stale activeWorkers entries are cleared.
+   */
+  recoverCrashedWorkers() {
+    const activeWorkers = this.controllerState.get("runtimeState.activeWorkers");
+    if (activeWorkers.length > 0) {
+      this.ctx.logger.info({ count: activeWorkers.length }, "Clearing stale active workers from crash");
+      this.controllerState.set("runtimeState.activeWorkers", []);
+    }
+    const running = this.taskPool.list("running");
+    for (const task of running) {
+      this.ctx.logger.info({ taskId: task.id }, "Marking crashed running task as failed");
+      this.taskPool.fail(task.id, "Session crashed \u2014 task interrupted");
+    }
+  }
+  /** Abort a worker that is running a specific task. */
+  abortWorkerByTaskId(taskId) {
+    for (const [workerId, tId] of this.workerTaskMap) {
+      if (tId === taskId) {
+        const worker = this.workers.get(workerId);
+        worker?.abort();
+        this.ctx.logger.info({ workerId, taskId }, "Worker aborted");
+        return;
+      }
+    }
+    this.ctx.logger.warn({ taskId }, "No running worker found for task abort");
+  }
+  async spawnWorker(taskWithWorker) {
+    const { workerId, ...task } = taskWithWorker;
+    const workerType = task.workerType ?? "puppet";
+    const worker = this.workerFactory.create(workerType, {
+      workerProvider: this.workerProvider,
+      sessionDir: this.ctx.sessionDir,
+      workspaceDir: this.ctx.workspaceDir,
+      logger: this.ctx.logger,
+      workerConfigs: this.config.workers
+    });
+    this.workers.set(workerId, worker);
+    this.workerTaskMap.set(workerId, task.id);
+    const workerMeta = getWorkerMeta(workerType, this.config.workers);
+    const tools = workerType === "puppet" ? createWorkerTools({
+      listTasks: (status) => this.taskPool.list(status),
+      cwd: this.ctx.workspaceDir,
+      reportProgress: (msg, _percent) => {
+        this.signalQueue.enqueue({
+          source: "worker",
+          type: "progress",
+          payload: { workerId, taskId: task.id, taskTitle: task.title, workerType, emoji: workerMeta.emoji, message: msg }
+        });
+      },
+      onComplete: (summary) => {
+        worker.complete(summary);
+      },
+      onFail: (error) => {
+        worker.fail(error);
+      }
+    }) : {};
+    this.ctx.logger.info({ workerId, taskId: task.id, workerType }, "Worker starting");
+    return worker.run(
+      { ...task, workerId },
+      tools,
+      (msg) => {
+        this.signalQueue.enqueue({
+          source: "worker",
+          type: "progress",
+          payload: { workerId, taskId: task.id, taskTitle: task.title, workerType, emoji: workerMeta.emoji, message: msg }
+        });
+      }
+    );
+  }
+  registerWorker(worker) {
+    this.workers.set(worker.id, worker);
+  }
+  getWorker(id) {
+    return this.workers.get(id);
+  }
+  getWorkerState(id) {
+    return this.workers.get(id)?.getState() ?? null;
+  }
+  removeWorker(id) {
+    setTimeout(() => {
+      this.workers.delete(id);
+      this.workerTaskMap.delete(id);
+    }, 0);
+  }
+  // --- SchedulerContext implementation ---
+  addActiveWorker(info) {
+    this.controllerState.append("runtimeState.activeWorkers", info);
+  }
+  removeActiveWorker(workerId) {
+    const workers = this.controllerState.get("runtimeState.activeWorkers");
+    const idx = workers.findIndex((w) => w.workerId === workerId);
+    if (idx !== -1) {
+      this.controllerState.remove("runtimeState.activeWorkers", idx);
+    }
+  }
+  // --- Shutdown ---
+  async shutdown() {
+    for (const worker of this.workers.values()) {
+      worker.abort();
+    }
+    const running = this.taskPool.list("running");
+    for (const task of running) {
+      this.taskPool.cancel(task.id);
+    }
+    this.ctx.abortController.abort();
+    this.workers.clear();
+    this.workerTaskMap.clear();
+    this.ctx.logger.info("Supervisor shutdown complete");
+  }
+};
+
+// src/services/controller-loop.ts
+async function mainControllerLoop(supervisor) {
+  const { signalQueue, controllerAgent, ctx } = supervisor;
+  ctx.logger.info("Main controller loop started");
+  while (!ctx.abortController.signal.aborted) {
+    try {
+      if (controllerAgent.needsCompaction()) {
+        ctx.logger.info("Context full, triggering compaction");
+        await controllerAgent.performCompaction();
+      }
+      const signals = signalQueue.dequeueUnread();
+      ctx.logger.debug("loop start with signals:" + JSON.stringify(signals));
+      if (signals.length > 0) {
+        ctx.logger.info({ count: signals.length, sigIds: signals.map((s) => s.id), sigTypes: signals.map((s) => `${s.source}/${s.type}`) }, "Processing signals");
+        await controllerAgent.run(signals);
+        ctx.logger.debug("loop end");
+      }
+      await signalQueue.waitForSignal();
+    } catch (err) {
+      if (ctx.abortController.signal.aborted) break;
+      const friendly = formatLlmError(err);
+      ctx.logger.error({ error: friendly, statusCode: err.statusCode ?? err.lastError?.statusCode }, "Controller loop error");
+      controllerAgent.state.set("dynamicState.streamingEntries", []);
+      controllerAgent.state.append("conversation", {
+        type: "system" /* System */,
+        uuid: generateId("err"),
+        parentUuid: null,
+        sessionId: "controller",
+        timestamp: nowISO(),
+        subtype: "error" /* Error */,
+        content: friendly
+      });
+      await new Promise((r) => setTimeout(r, 1e3));
+    }
+  }
+  ctx.logger.info("Main controller loop stopped");
+}
+
+// src/infra/session-helpers.ts
+import * as fs from "fs";
+import * as path2 from "path";
+function listSessions(homeDir2) {
+  const sessionsDir = path2.join(homeDir2, "sessions");
+  if (!fs.existsSync(sessionsDir)) return [];
+  return fs.readdirSync(sessionsDir).filter((name) => fs.existsSync(path2.join(sessionsDir, name, "meta.json"))).map((name) => {
+    try {
+      return JSON.parse(fs.readFileSync(path2.join(sessionsDir, name, "meta.json"), "utf-8"));
+    } catch {
+      return null;
+    }
+  }).filter((m) => m !== null).sort((a, b) => b.createdAt - a.createdAt);
+}
+function getSession(homeDir2, sessionId) {
+  const sessionDir = path2.join(homeDir2, "sessions", sessionId);
+  const metaPath = path2.join(sessionDir, "meta.json");
+  if (!fs.existsSync(metaPath)) return null;
+  try {
+    const meta = JSON.parse(fs.readFileSync(metaPath, "utf-8"));
+    return { sessionId, sessionDir, meta };
+  } catch {
+    return null;
+  }
+}
+
+// src/tui/render.ts
+import React7 from "react";
+import { render } from "ink";
+
+// src/tui/app.tsx
+import { useRef as useRef2 } from "react";
+
+// src/tui/hooks/use-memoized-fn.ts
+import { useRef, useCallback } from "react";
+function useMemoizedFn(fn) {
+  const fnRef = useRef(fn);
+  fnRef.current = fn;
+  const memoized = useCallback((...args) => fnRef.current(...args), []);
+  return memoized;
+}
+
+// src/tui/app.tsx
+import { Box as Box12, useApp, useInput as useInput3 } from "ink";
+
+// src/tui/providers/supervisor-provider.tsx
+import { createContext, useContext } from "react";
+import { jsx } from "react/jsx-runtime";
+var SupervisorContext = createContext(null);
+function SupervisorProvider({ supervisor, children }) {
+  return /* @__PURE__ */ jsx(SupervisorContext.Provider, { value: supervisor, children });
+}
+function useSupervisor() {
+  const ctx = useContext(SupervisorContext);
+  if (!ctx) throw new Error("useSupervisor must be used within SupervisorProvider");
+  return ctx;
+}
+
+// src/tui/providers/route-provider.tsx
+import { createContext as createContext2, useContext as useContext2, useState } from "react";
+import { jsx as jsx2 } from "react/jsx-runtime";
+var RouteContext = createContext2({
+  route: { page: "controller" },
+  navigate: () => {
+  }
+});
+function RouteProvider({ children }) {
+  const [route, setRoute] = useState({ page: "controller" });
+  const navigate = useMemoizedFn((r) => setRoute(r));
+  return /* @__PURE__ */ jsx2(RouteContext.Provider, { value: { route, navigate }, children });
+}
+function useRouter() {
+  return useContext2(RouteContext);
+}
+
+// src/tui/pages/controller-page.tsx
+import { useState as useState7, useMemo as useMemo4 } from "react";
+import { Box as Box10, useStdout } from "ink";
+
+// src/tui/components/chat-area/chat-area.tsx
+import React3, { useMemo } from "react";
+import { Box as Box5, Static, Text as Text6 } from "ink";
+
+// src/tui/theme.ts
+var baseToken = {
+  /** Semantic color palette — named by usage, not by hue. */
+  color: {
+    /** Strong emphasis — important labels, highlights. */
+    textEmphasis: "yellow",
+    /** Default body text — AI responses, general content. */
+    textNormal: "white",
+    /** Subtle text — meta entries, dimmed labels, timestamps. */
+    textSubtle: "gray",
+    /** Accent — interactive elements, assistant prefix. */
+    accent: "green",
+    /** Error / danger states. */
+    error: "red",
+    /** Borders and structural lines. */
+    border: "gray"
+  },
+  /** Background fills (hex). */
+  bg: {
+    /** Highlighted row surface. */
+    surface: "#444444"
+  },
+  /** Typographic / icon characters. */
+  icon: {
+    arrowRight: "\u2192",
+    arrowLeft: "\u2190",
+    /** Status / notification flag. */
+    flag: "\u2691",
+    /** Decorative dot. */
+    dot: "\xB7"
+  },
+  /** Numeric spacing scale (terminal rows). */
+  space: {
+    xs: 0,
+    sm: 1,
+    md: 2
+  },
+  /** Animation timing (ms). */
+  timing: {
+    slow: 1e3,
+    normal: 500,
+    fast: 100
+  }
+};
+var theme = {
+  baseToken,
+  user: {
+    prefix: "\u2192",
+    bgHex: baseToken.bg.surface,
+    prefixColor: baseToken.color.textEmphasis
+  },
+  assistant: {
+    prefix: "\u2192",
+    prefixColor: baseToken.color.accent
+  },
+  toolUse: {
+    callIcon: baseToken.icon.arrowRight,
+    resultIcon: baseToken.icon.arrowLeft,
+    color: baseToken.color.textSubtle
+  },
+  signal: {
+    prefix: baseToken.icon.flag,
+    color: baseToken.color.textSubtle
+  },
+  meta: {
+    prefix: baseToken.icon.dot,
+    color: baseToken.color.textSubtle
+  },
+  spinner: {
+    frames: ["\u25CF", "\u25C6", "\u2726", "\u203B"],
+    interval: baseToken.timing.normal
+  },
+  spacing: {
+    blockGap: baseToken.space.sm
+  }
+};
+
+// src/tui/components/chat-area/user-row.tsx
+import { Box, Text } from "ink";
+import { jsx as jsx3, jsxs } from "react/jsx-runtime";
+function UserRow({ item, width }) {
+  const dim = !item.read;
+  const text = item.content;
+  const padded = text.length < width ? text + " ".repeat(4) : text;
+  return /* @__PURE__ */ jsxs(Box, { children: [
+    /* @__PURE__ */ jsxs(
+      Text,
+      {
+        backgroundColor: theme.user.bgHex,
+        color: theme.user.prefixColor,
+        bold: true,
+        children: [
+          theme.user.prefix,
+          " "
+        ]
+      }
+    ),
+    /* @__PURE__ */ jsx3(
+      Text,
+      {
+        backgroundColor: theme.user.bgHex,
+        color: dim ? theme.baseToken.color.textSubtle : theme.baseToken.color.textNormal,
+        children: padded
+      }
+    )
+  ] });
+}
+
+// src/tui/components/chat-area/assistant-step-row.tsx
+import { Box as Box2, Text as Text2 } from "ink";
+
+// src/tui/components/chat-area/constants.ts
+var TOOL_DETAIL_MAX_LENGTH = 80;
+var LONG_MSG_MAX_LENGTH = 120;
+
+// src/tui/components/chat-area/assistant-step-row.tsx
+import { jsx as jsx4, jsxs as jsxs2 } from "react/jsx-runtime";
+function AssistantStepRow({ item }) {
+  const sections = item.sections ?? [];
+  if (sections.length === 0) {
+    return /* @__PURE__ */ jsxs2(Box2, { children: [
+      /* @__PURE__ */ jsxs2(Text2, { color: theme.assistant.prefixColor, bold: true, children: [
+        theme.assistant.prefix,
+        " "
+      ] }),
+      /* @__PURE__ */ jsx4(Text2, { children: item.content })
+    ] });
+  }
+  return /* @__PURE__ */ jsx4(Box2, { flexDirection: "column", children: sections.map((sec) => {
+    const key = `${sec.kind}-${sec.id}`;
+    switch (sec.kind) {
+      case "reasoning":
+        return /* @__PURE__ */ jsx4(ReasoningRow, { section: sec }, key);
+      case "content":
+        return /* @__PURE__ */ jsx4(ContentRow, { section: sec }, key);
+      case "tool_call":
+        return /* @__PURE__ */ jsx4(ToolCallRow, { section: sec }, key);
+      case "tool_result":
+        return /* @__PURE__ */ jsx4(ToolResultRow, { section: sec }, key);
+    }
+  }) });
+}
+function ReasoningRow({ section: section2 }) {
+  return /* @__PURE__ */ jsxs2(Box2, { children: [
+    /* @__PURE__ */ jsxs2(Text2, { color: theme.meta.color, children: [
+      theme.meta.prefix,
+      " "
+    ] }),
+    /* @__PURE__ */ jsxs2(Text2, { dimColor: true, children: [
+      "thinking: ",
+      section2.text.slice(0, LONG_MSG_MAX_LENGTH)
+    ] })
+  ] });
+}
+function ContentRow({ section: section2 }) {
+  return /* @__PURE__ */ jsxs2(Box2, { children: [
+    /* @__PURE__ */ jsxs2(Text2, { color: theme.assistant.prefixColor, bold: true, children: [
+      theme.assistant.prefix,
+      " "
+    ] }),
+    /* @__PURE__ */ jsx4(Text2, { children: section2.text })
+  ] });
+}
+function ToolCallRow({ section: section2 }) {
+  return /* @__PURE__ */ jsxs2(Box2, { children: [
+    /* @__PURE__ */ jsxs2(Text2, { color: theme.meta.color, children: [
+      theme.meta.prefix,
+      " "
+    ] }),
+    /* @__PURE__ */ jsxs2(Text2, { color: theme.toolUse.color, children: [
+      theme.toolUse.callIcon,
+      " ",
+      section2.toolName,
+      ": ",
+      section2.text.slice(0, TOOL_DETAIL_MAX_LENGTH)
+    ] })
+  ] });
+}
+function ToolResultRow({ section: section2 }) {
+  const color = section2.isError ? theme.baseToken.color.error : theme.toolUse.color;
+  return /* @__PURE__ */ jsxs2(Box2, { children: [
+    /* @__PURE__ */ jsxs2(Text2, { color: theme.meta.color, children: [
+      theme.meta.prefix,
+      " "
+    ] }),
+    /* @__PURE__ */ jsxs2(Text2, { color, children: [
+      theme.toolUse.resultIcon,
+      " ",
+      section2.toolName,
+      ": ",
+      section2.text.slice(0, TOOL_DETAIL_MAX_LENGTH)
+    ] })
+  ] });
+}
+
+// src/tui/components/chat-area/signal-row.tsx
+import { Box as Box3, Text as Text3 } from "ink";
+import { jsx as jsx5, jsxs as jsxs3 } from "react/jsx-runtime";
+var MAX_CONTENT_LINES = 2;
+function trimContent(text, maxLines) {
+  const lines = text.split("\n").map((l) => l.trimEnd()).filter((l) => l.length > 0);
+  const trimmed = lines.slice(0, maxLines).join("\n");
+  return lines.length > maxLines ? trimmed + "..." : trimmed;
+}
+function SignalRow({ item }) {
+  const dim = !item.read;
+  const label = item.subtype?.replace("worker_", "") ?? "signal";
+  const color = dim ? theme.baseToken.color.textSubtle : theme.signal.color;
+  const contextParts = [];
+  if (item.taskTitle) contextParts.push(item.taskTitle);
+  if (item.workerId) contextParts.push(`w:${item.workerId.slice(-4)}`);
+  const context = contextParts.length > 0 ? `[${contextParts.join(" \xB7 ")}] ` : "";
+  const content = trimContent(item.content, MAX_CONTENT_LINES);
+  return /* @__PURE__ */ jsxs3(Box3, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsxs3(Box3, { children: [
+      /* @__PURE__ */ jsxs3(Text3, { color: theme.meta.color, children: [
+        theme.signal.prefix,
+        " "
+      ] }),
+      item.emoji && /* @__PURE__ */ jsxs3(Text3, { children: [
+        item.emoji,
+        " "
+      ] }),
+      /* @__PURE__ */ jsxs3(Text3, { dimColor: dim, color, children: [
+        context,
+        label
+      ] })
+    ] }),
+    content && /* @__PURE__ */ jsx5(Box3, { marginLeft: 3, children: /* @__PURE__ */ jsx5(Text3, { dimColor: dim, color, children: content }) })
+  ] });
+}
+
+// src/tui/components/chat-area/system-row.tsx
+import { Box as Box4, Text as Text4 } from "ink";
+import { jsx as jsx6, jsxs as jsxs4 } from "react/jsx-runtime";
+function SystemRow({ item }) {
+  const isError = item.subtype === "error";
+  const isCompact = item.subtype === "compact";
+  if (isCompact) {
+    return /* @__PURE__ */ jsx6(Box4, { children: /* @__PURE__ */ jsx6(Text4, { dimColor: true, children: "\u224B Conversation has been compacted" }) });
+  }
+  return /* @__PURE__ */ jsxs4(Box4, { children: [
+    /* @__PURE__ */ jsxs4(Text4, { color: isError ? theme.baseToken.color.error : theme.meta.color, children: [
+      isError ? "\u2718" : theme.meta.prefix,
+      " "
+    ] }),
+    /* @__PURE__ */ jsx6(Text4, { color: isError ? theme.baseToken.color.error : void 0, dimColor: !isError, children: item.content })
+  ] });
+}
+
+// src/tui/components/chat-area/item-row.tsx
+import { jsx as jsx7 } from "react/jsx-runtime";
+function ItemRow({ item, contentWidth }) {
+  switch (item.role) {
+    case "user":
+      return /* @__PURE__ */ jsx7(UserRow, { item, width: contentWidth });
+    case "assistant":
+      return /* @__PURE__ */ jsx7(AssistantStepRow, { item });
+    case "signal":
+      return /* @__PURE__ */ jsx7(SignalRow, { item });
+    case "system":
+      return /* @__PURE__ */ jsx7(SystemRow, { item });
+    default:
+      return null;
+  }
+}
+
+// src/tui/components/chat-area/streaming-spinner.tsx
+import { useState as useState2, useEffect } from "react";
+import { Text as Text5 } from "ink";
+import { jsxs as jsxs5 } from "react/jsx-runtime";
+function StreamingSpinner() {
+  const [frame, setFrame] = useState2(0);
+  useEffect(() => {
+    const timer = setInterval(() => {
+      setFrame((f) => (f + 1) % theme.spinner.frames.length);
+    }, theme.spinner.interval);
+    return () => clearInterval(timer);
+  }, []);
+  return /* @__PURE__ */ jsxs5(Text5, { color: theme.assistant.prefixColor, bold: true, children: [
+    theme.spinner.frames[frame],
+    " "
+  ] });
+}
+
+// src/tui/components/chat-area/chat-area.tsx
+import { Fragment, jsx as jsx8, jsxs as jsxs6 } from "react/jsx-runtime";
+function shouldShowGap(prev, _current) {
+  if (!prev) return false;
+  return true;
+}
+var ChatArea = React3.memo(function ChatArea2({ items, busy, streamingItems, contentWidth }) {
+  const width = contentWidth ?? 78;
+  const { staticItems, dynamicItems } = useMemo(() => {
+    const read = items.filter((i) => i.read);
+    const unread = items.filter((i) => !i.read);
+    return { staticItems: read, dynamicItems: unread };
+  }, [items]);
+  return /* @__PURE__ */ jsxs6(Fragment, { children: [
+    /* @__PURE__ */ jsx8(Static, { items: staticItems, children: (item, idx) => /* @__PURE__ */ jsx8(
+      Box5,
+      {
+        flexDirection: "column",
+        paddingX: 1,
+        marginTop: shouldShowGap(idx > 0 ? staticItems[idx - 1] : null, item) ? theme.spacing.blockGap : 0,
+        children: /* @__PURE__ */ jsx8(ItemRow, { item, contentWidth: width })
+      },
+      item.id
+    ) }, "chat"),
+    (streamingItems?.length ?? 0) > 0 && /* @__PURE__ */ jsxs6(Box5, { paddingX: 1, marginTop: items.length > 0 ? theme.spacing.blockGap : 0, children: [
+      /* @__PURE__ */ jsx8(StreamingSpinner, {}),
+      /* @__PURE__ */ jsx8(Text6, { children: streamingItems[0].content })
+    ] }),
+    dynamicItems.length > 0 && /* @__PURE__ */ jsxs6(Box5, { flexDirection: "column", paddingX: 3, marginTop: 1, marginBottom: 1, children: [
+      /* @__PURE__ */ jsx8(Box5, { justifyContent: "flex-start", children: /* @__PURE__ */ jsx8(Text6, { color: theme.baseToken.color.textSubtle, dimColor: true, children: "\xB7\xB7\xB7 waiting for process \xB7\xB7\xB7" }) }),
+      dynamicItems.map((item) => /* @__PURE__ */ jsx8(Box5, { flexDirection: "column", marginTop: shouldShowGap(null, item) ? theme.spacing.blockGap : 0, children: /* @__PURE__ */ jsx8(ItemRow, { item, contentWidth: width }) }, item.id))
+    ] })
+  ] });
+});
+
+// src/tui/components/input-area.tsx
+import { useState as useState3, useMemo as useMemo2 } from "react";
+
+// src/tui/hooks/use-slash-commands.ts
+var SLASH_COMMANDS = [
+  { name: "tasks", args: "[status]", description: "List tasks" },
+  { name: "workers", description: "List active workers" },
+  { name: "worker", args: "[id]", description: "View worker detail" },
+  { name: "cancel", args: "<id>", description: "Cancel a task" },
+  { name: "compact", description: "Compact context" },
+  { name: "exit", description: "Quit" },
+  { name: "help", description: "Show help" }
+];
+function useSlashCommands(supervisor, ctx) {
+  const handleCommand = useMemoizedFn((input) => {
+    if (!input.startsWith("/")) return { handled: false };
+    const parts = input.slice(1).split(/\s+/);
+    const cmd = parts[0]?.toLowerCase();
+    switch (cmd) {
+      case "exit":
+      case "quit":
+        return { handled: true, output: "__EXIT__" };
+      case "tasks": {
+        const status = parts[1];
+        const tasks = supervisor.taskPool.list(status);
+        if (tasks.length === 0) return { handled: true, output: "No tasks" };
+        const lines = tasks.map(
+          (t) => `[${t.status}] ${t.id}: ${t.description}${t.result ? ` \u2192 ${t.result}` : ""}`
+        );
+        return { handled: true, output: lines.join("\n") };
+      }
+      case "workers": {
+        return { handled: true, action: "workers" };
+      }
+      case "worker": {
+        const workerId = parts[1];
+        if (!workerId) {
+          const activeWorkers = supervisor.controllerState.get("runtimeState.activeWorkers");
+          if (!activeWorkers || activeWorkers.length === 0) {
+            return { handled: true, output: "No active workers. Usage: /worker <id>" };
+          }
+          const lines = activeWorkers.map(
+            (w) => `${w.workerId} \u2192 task ${w.taskId}`
+          );
+          return { handled: true, output: lines.join("\n") };
+        }
+        return { handled: true, navigate: { page: "worker", workerId } };
+      }
+      case "cancel": {
+        const taskId = parts[1];
+        if (!taskId) {
+          return { handled: true, output: "Usage: /cancel <taskId>" };
+        }
+        supervisor.taskPool.cancel(taskId);
+        supervisor.abortWorkerByTaskId(taskId);
+        return { handled: true, output: `Task ${taskId} cancelled` };
+      }
+      case "compact":
+        return { handled: true, action: "compact", output: "Compacting context..." };
+      case "help":
+        return {
+          handled: true,
+          output: [
+            "Commands:",
+            "  /tasks [status]   \u2014 List tasks",
+            "  /workers          \u2014 List active workers",
+            "  /worker [id]      \u2014 View worker detail or list all",
+            "  /cancel <id>      \u2014 Cancel a task and abort its worker",
+            "  /compact          \u2014 Compact conversation context",
+            "  /exit             \u2014 Quit",
+            "  /help             \u2014 Show this help"
+          ].join("\n")
+        };
+      default:
+        return { handled: true, output: `Unknown command: /${cmd}. Type /help for commands.` };
+    }
+  });
+  return { handleCommand };
+}
+
+// src/tui/components/input-area.tsx
+import { Box as Box6, Text as Text7, useInput } from "ink";
+import { jsx as jsx9, jsxs as jsxs7 } from "react/jsx-runtime";
+function InputArea({ onSubmit, onExit, onEscape, busy }) {
+  const [input, setInput] = useState3("");
+  const [cursor, setCursor] = useState3(0);
+  const [selectedIndex, setSelectedIndex] = useState3(0);
+  const suggestions = useMemo2(() => {
+    if (!input.startsWith("/") || input.includes(" ")) return [];
+    const typed = input.slice(1).toLowerCase();
+    return SLASH_COMMANDS.filter((c) => c.name.startsWith(typed));
+  }, [input]);
+  const showSuggestions = suggestions.length > 0;
+  const clampedIndex = showSuggestions ? Math.min(selectedIndex, suggestions.length - 1) : 0;
+  const reset = useMemoizedFn(() => {
+    setInput("");
+    setCursor(0);
+    setSelectedIndex(0);
+  });
+  const applySuggestion = useMemoizedFn((index) => {
+    const cmd = suggestions[index];
+    if (!cmd) return;
+    const text = `/${cmd.name}`;
+    const filled = "args" in cmd ? `${text} ` : text;
+    setInput(filled);
+    setCursor(filled.length);
+    setSelectedIndex(0);
+  });
+  useInput((ch, key) => {
+    if (key.return) {
+      if (showSuggestions) {
+        const cmd = suggestions[clampedIndex];
+        if (cmd) {
+          if ("args" in cmd) {
+            applySuggestion(clampedIndex);
+            return;
+          }
+          const text = `/${cmd.name}`;
+          if (text === "/exit" || text === "/quit") {
+            onExit();
+            return;
+          }
+          onSubmit(text);
+          reset();
+          return;
+        }
+      }
+      const trimmed = input.trim();
+      if (!trimmed) return;
+      if (trimmed === "/exit" || trimmed === "/quit") {
+        onExit();
+        return;
+      }
+      onSubmit(trimmed);
+      reset();
+      return;
+    }
+    if (key.tab) {
+      if (showSuggestions) {
+        applySuggestion(clampedIndex);
+      }
+      return;
+    }
+    if (key.upArrow) {
+      if (showSuggestions) {
+        setSelectedIndex((i) => (i - 1 + suggestions.length) % suggestions.length);
+      }
+      return;
+    }
+    if (key.downArrow) {
+      if (showSuggestions) {
+        setSelectedIndex((i) => (i + 1) % suggestions.length);
+      }
+      return;
+    }
+    if (key.escape) {
+      if (showSuggestions) {
+        setInput("");
+        setCursor(0);
+        setSelectedIndex(0);
+      } else {
+        onEscape?.();
+        reset();
+      }
+      return;
+    }
+    if (key.backspace || key.delete) {
+      if (cursor === 0) return;
+      setInput((prev) => prev.slice(0, cursor - 1) + prev.slice(cursor));
+      setCursor((c) => Math.max(0, c - 1));
+      setSelectedIndex(0);
+      return;
+    }
+    if (key.leftArrow) {
+      setCursor((c) => Math.max(0, c - 1));
+      return;
+    }
+    if (key.rightArrow) {
+      setCursor((c) => Math.min(input.length, c + 1));
+      return;
+    }
+    if (ch && !key.ctrl && !key.meta) {
+      setInput((prev) => prev.slice(0, cursor) + ch + prev.slice(cursor));
+      setCursor((c) => c + ch.length);
+      setSelectedIndex(0);
+    }
+  });
+  const before = input.slice(0, cursor);
+  const after = input.slice(cursor);
+  return /* @__PURE__ */ jsxs7(Box6, { flexDirection: "column", children: [
+    showSuggestions && /* @__PURE__ */ jsx9(Box6, { flexDirection: "column", paddingX: 1, marginBottom: 0, children: suggestions.map((cmd, i) => {
+      const isSelected = i === clampedIndex;
+      const nameWithArgs = "args" in cmd ? `/${cmd.name} ${cmd.args}` : `/${cmd.name}`;
+      return /* @__PURE__ */ jsxs7(Box6, { children: [
+        /* @__PURE__ */ jsx9(Text7, { color: isSelected ? theme.baseToken.color.accent : void 0, children: isSelected ? "\u25B8 " : "  " }),
+        /* @__PURE__ */ jsx9(Text7, { bold: isSelected, color: isSelected ? theme.baseToken.color.accent : theme.baseToken.color.textNormal, children: nameWithArgs.padEnd(20) }),
+        /* @__PURE__ */ jsxs7(Text7, { dimColor: true, children: [
+          " ",
+          cmd.description
+        ] })
+      ] }, cmd.name);
+    }) }),
+    /* @__PURE__ */ jsxs7(
+      Box6,
+      {
+        borderStyle: "single",
+        borderColor: "gray",
+        borderLeft: false,
+        borderRight: false,
+        paddingX: 1,
+        children: [
+          /* @__PURE__ */ jsx9(Text7, { color: theme.user.prefixColor, bold: true, children: theme.user.prefix }),
+          /* @__PURE__ */ jsxs7(Text7, { children: [
+            " ",
+            before
+          ] }),
+          /* @__PURE__ */ jsx9(Text7, { color: "white", inverse: true, children: after.length > 0 ? after[0] : " " }),
+          /* @__PURE__ */ jsx9(Text7, { children: after.slice(1) }),
+          /* @__PURE__ */ jsx9(Text7, { dimColor: true, children: busy ? " (thinking...)" : "" })
+        ]
+      }
+    )
+  ] });
+}
+
+// src/tui/components/status-bar.tsx
+import React5, { useMemo as useMemo3, useState as useState4, useEffect as useEffect2 } from "react";
+import { Box as Box7, Text as Text8 } from "ink";
+import { jsx as jsx10, jsxs as jsxs8 } from "react/jsx-runtime";
+function StatusBar({
+  activeWorkers,
+  pendingTasks,
+  runningTasks
+}) {
+  const [now, setNow] = useState4(() => Date.now());
+  useEffect2(() => {
+    if (activeWorkers.length === 0) return;
+    const timer = setInterval(() => setNow(Date.now()), 1e3);
+    return () => clearInterval(timer);
+  }, [activeWorkers.length]);
+  const workerRows = useMemo3(
+    () => {
+      return activeWorkers.map((w) => {
+        const task = runningTasks.find((t) => t.id === w.taskId);
+        const elapsed = Math.round((now - w.startedAt) / 1e3);
+        const label = task ? task.title || task.description.slice(0, 10) : w.taskId.slice(0, 8);
+        return { workerId: w.workerId, label, elapsed };
+      });
+    },
+    [activeWorkers, runningTasks, now]
+  );
+  if (activeWorkers.length === 0 && pendingTasks.length === 0) {
+    return null;
+  }
+  const parts = [];
+  if (pendingTasks.length > 0) {
+    parts.push(`pending tasks:${pendingTasks.length}`);
+  }
+  if (activeWorkers.length > 0) {
+    parts.push(`active workers:${activeWorkers.length}`);
+  }
+  return /* @__PURE__ */ jsxs8(Box7, { paddingX: 1, marginTop: 0, children: [
+    /* @__PURE__ */ jsxs8(Text8, { dimColor: true, children: [
+      " ",
+      parts.join(" \u2502 "),
+      " "
+    ] }),
+    workerRows.map((r, i) => /* @__PURE__ */ jsxs8(React5.Fragment, { children: [
+      i > 0 && /* @__PURE__ */ jsx10(Text8, { dimColor: true, children: " \xB7 " }),
+      /* @__PURE__ */ jsxs8(Text8, { dimColor: true, color: "blue", children: [
+        r.label,
+        " (",
+        r.elapsed,
+        "s)"
+      ] })
+    ] }, r.workerId))
+  ] });
+}
+
+// src/tui/components/overlay-panel.tsx
+import { Box as Box8, Text as Text9 } from "ink";
+import { jsx as jsx11, jsxs as jsxs9 } from "react/jsx-runtime";
+function OverlayPanel({ overlay }) {
+  return /* @__PURE__ */ jsxs9(Box8, { flexDirection: "column", marginTop: 1, children: [
+    overlay.kind === "text" ? /* @__PURE__ */ jsx11(Box8, { paddingX: 1, borderStyle: "single", borderColor: "gray", flexDirection: "column", children: /* @__PURE__ */ jsx11(Text9, { color: "gray", children: overlay.content }) }) : overlay.render(),
+    overlay.hint && /* @__PURE__ */ jsxs9(Text9, { dimColor: true, children: [
+      "  ",
+      overlay.hint
+    ] })
+  ] });
+}
+
+// src/tui/components/worker-list-overlay.tsx
+import { useState as useState5 } from "react";
+import { Box as Box9, Text as Text10, useInput as useInput2 } from "ink";
+import { jsx as jsx12, jsxs as jsxs10 } from "react/jsx-runtime";
+function WorkerListOverlay({ workers, onSelect, onDismiss }) {
+  const [selectedIndex, setSelectedIndex] = useState5(0);
+  useInput2((_ch, key) => {
+    if (key.escape) {
+      onDismiss();
+      return;
+    }
+    if (key.return && workers.length > 0) {
+      onSelect(workers[selectedIndex].workerId);
+      return;
+    }
+    if (key.upArrow) {
+      setSelectedIndex((i) => (i - 1 + workers.length) % workers.length);
+      return;
+    }
+    if (key.downArrow) {
+      setSelectedIndex((i) => (i + 1) % workers.length);
+      return;
+    }
+  });
+  if (workers.length === 0) {
+    return /* @__PURE__ */ jsx12(Box9, { paddingX: 1, borderStyle: "single", borderColor: "gray", children: /* @__PURE__ */ jsx12(Text10, { dimColor: true, children: "No active workers" }) });
+  }
+  return /* @__PURE__ */ jsxs10(Box9, { flexDirection: "column", paddingX: 1, borderStyle: "single", borderColor: "gray", children: [
+    /* @__PURE__ */ jsxs10(Text10, { bold: true, dimColor: true, children: [
+      "Workers (",
+      workers.length,
+      ")"
+    ] }),
+    workers.map((w, i) => {
+      const isSelected = i === selectedIndex;
+      const elapsed = Math.round((Date.now() - w.startedAt) / 1e3);
+      const mins = Math.floor(elapsed / 60);
+      const secs = elapsed % 60;
+      const timeStr = mins > 0 ? `${mins}m${secs}s` : `${secs}s`;
+      return /* @__PURE__ */ jsxs10(Box9, { children: [
+        /* @__PURE__ */ jsx12(Text10, { color: isSelected ? theme.baseToken.color.accent : void 0, children: isSelected ? "\u25B8 " : "  " }),
+        /* @__PURE__ */ jsxs10(Text10, { bold: isSelected, color: isSelected ? theme.baseToken.color.accent : theme.baseToken.color.textNormal, children: [
+          w.emoji,
+          " ",
+          w.taskTitle
+        ] }),
+        /* @__PURE__ */ jsxs10(Text10, { dimColor: true, children: [
+          " ",
+          w.workerType,
+          " \xB7 ",
+          w.taskId,
+          " \xB7 ",
+          timeStr
+        ] })
+      ] }, w.workerId);
+    })
+  ] });
+}
+
+// src/tui/hooks/use-wayang-state.ts
+import { useState as useState6, useEffect as useEffect3 } from "react";
+function useWayangState(state, path5) {
+  const [value, setValue] = useState6(() => state.get(path5));
+  useEffect3(() => {
+    const unSub = state.on(path5, (_event) => {
+      setValue(state.get(path5));
+    });
+    setValue(state.get(path5));
+    return unSub;
+  }, [state, path5]);
+  return value;
+}
+
+// src/tui/types/display-item.ts
+function entryToDisplayItem(entry) {
+  const base = {
+    id: entry.uuid,
+    timestamp: new Date(entry.timestamp).getTime(),
+    read: true
+  };
+  switch (entry.type) {
+    case "user" /* User */:
+      return { ...base, role: "user", content: entry.message.content };
+    case "assistant" /* Assistant */: {
+      const hasSkipReply = entry.toolCalls?.some((tc) => tc.toolName === "skip_reply");
+      if (hasSkipReply) return null;
+      const sections = [];
+      if (entry.message.reasoning) {
+        sections.push({ kind: "reasoning", id: "reasoning", text: entry.message.reasoning });
+      }
+      if (entry.message.content) {
+        sections.push({ kind: "content", id: "content", text: entry.message.content });
+      }
+      for (const tc of entry.toolCalls ?? []) {
+        sections.push({
+          kind: "tool_call",
+          id: tc.toolCallId,
+          text: tc.arguments,
+          toolName: tc.toolName
+        });
+      }
+      for (const tr of entry.toolResults ?? []) {
+        sections.push({
+          kind: "tool_result",
+          id: tr.toolCallId,
+          text: tr.output.value,
+          toolName: tr.toolName,
+          isError: tr.isError
+        });
+      }
+      return {
+        ...base,
+        role: "assistant",
+        content: entry.message.content,
+        sections
+      };
+    }
+    case "signal" /* Signal */:
+      return { ...base, role: "signal", subtype: entry.subtype, content: entry.content, taskId: entry.taskId, taskTitle: entry.taskTitle, workerId: entry.workerId, workerType: entry.workerType, emoji: entry.emoji };
+    case "system" /* System */:
+      return { ...base, role: "system", subtype: entry.subtype, content: entry.content };
+  }
+}
+function signalToDisplayItem(signal) {
+  const base = {
+    id: signal.id,
+    timestamp: signal.timestamp,
+    read: false
+  };
+  if (signal.type === "input") {
+    return {
+      ...base,
+      role: "user",
+      content: signal.payload.text
+    };
+  }
+  const subtype = signal.type === "completed" ? "worker_completed" /* WorkerCompleted */ : signal.type === "failed" ? "worker_failed" /* WorkerFailed */ : "worker_progress" /* WorkerProgress */;
+  const content = getSignalField(signal, "summary") ?? getSignalField(signal, "error") ?? getSignalField(signal, "message") ?? "";
+  const taskId = getSignalField(signal, "taskId");
+  const taskTitle = getSignalField(signal, "taskTitle");
+  return {
+    ...base,
+    role: "signal",
+    subtype,
+    content,
+    taskId,
+    workerId: getSignalField(signal, "workerId"),
+    workerType: getSignalField(signal, "workerType"),
+    emoji: getSignalField(signal, "emoji"),
+    taskTitle
+  };
+}
+
+// src/tui/pages/controller-page.tsx
+import { jsx as jsx13, jsxs as jsxs11 } from "react/jsx-runtime";
+function ControllerPage({ onExit }) {
+  const supervisor = useSupervisor();
+  const { navigate } = useRouter();
+  const { stdout } = useStdout();
+  const terminalCols = stdout?.columns ?? 80;
+  const chatContentWidth = terminalCols - 4;
+  const conversation = useWayangState(
+    supervisor.controllerState,
+    "conversation"
+  );
+  const streamingEntries = useWayangState(
+    supervisor.controllerState,
+    "dynamicState.streamingEntries"
+  );
+  const signals = useWayangState(
+    supervisor.signalQueue.stateRef,
+    "signals"
+  );
+  const activeWorkers = useWayangState(
+    supervisor.controllerState,
+    "runtimeState.activeWorkers"
+  );
+  const pendingTasks = useWayangState(
+    supervisor.taskPool.stateRef,
+    "tasks.pending"
+  );
+  const runningTasks = useWayangState(
+    supervisor.taskPool.stateRef,
+    "tasks.running"
+  );
+  const agentBusy = useWayangState(
+    supervisor.controllerState,
+    "dynamicState.busy"
+  );
+  const displayItems = useMemo4(() => {
+    const readItems = (conversation ?? []).map(entryToDisplayItem).filter((d) => d !== null);
+    const unreadSignals = (signals ?? []).filter((s) => s.status === "unread").map(signalToDisplayItem);
+    return [...readItems, ...unreadSignals];
+  }, [conversation, signals]);
+  const streamingItems = useMemo4(() => {
+    const entries = streamingEntries ?? [];
+    if (entries.length === 0) return [];
+    const conversationIds = new Set((conversation ?? []).map((e) => e.uuid));
+    return entries.filter((e) => !conversationIds.has(e.uuid)).map(entryToDisplayItem).filter((d) => d !== null);
+  }, [streamingEntries, conversation]);
+  const [overlay, setOverlay] = useState7(null);
+  const busy = agentBusy ?? false;
+  const dismissOverlay = useMemoizedFn(() => setOverlay(null));
+  const slashCtx = useMemo4(() => ({
+    navigate
+  }), [navigate]);
+  const { handleCommand } = useSlashCommands(supervisor, slashCtx);
+  const handleSubmit = useMemoizedFn((input) => {
+    const cmdResult = handleCommand(input);
+    if (cmdResult.handled) {
+      if (cmdResult.output === "__EXIT__") {
+        onExit();
+        return;
+      }
+      if (cmdResult.navigate) {
+        navigate(cmdResult.navigate);
+        return;
+      }
+      if (cmdResult.action === "workers") {
+        setOverlay({
+          kind: "component",
+          render: () => /* @__PURE__ */ jsx13(
+            WorkerListOverlay,
+            {
+              workers: activeWorkers ?? [],
+              onSelect: (workerId) => {
+                dismissOverlay();
+                navigate({ page: "worker", workerId });
+              },
+              onDismiss: dismissOverlay
+            }
+          ),
+          hint: "\u2191\u2193 select \xB7 enter to view \xB7 esc to dismiss"
+        });
+        return;
+      }
+      if (cmdResult.action === "compact") {
+        setOverlay(cmdResult.output ? { kind: "text", content: cmdResult.output } : null);
+        supervisor.controllerAgent.performCompaction().then(() => setOverlay(null)).catch(() => setOverlay({ kind: "text", content: "Compaction failed", hint: "(esc to dismiss)" }));
+        return;
+      }
+      if (cmdResult.output) {
+        setOverlay({ kind: "text", content: cmdResult.output, hint: "(esc to dismiss)" });
+      }
+      return;
+    }
+    setOverlay(null);
+    supervisor.signalQueue.enqueue({
+      source: "user",
+      type: "input",
+      payload: { text: input }
+    });
+    supervisor.sessionManager.onUserInput(input);
+  });
+  return /* @__PURE__ */ jsxs11(Box10, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsx13(Box10, { marginBottom: 1, children: /* @__PURE__ */ jsx13(
+      ChatArea,
+      {
+        items: displayItems,
+        busy,
+        streamingItems,
+        contentWidth: chatContentWidth
+      }
+    ) }),
+    overlay && /* @__PURE__ */ jsx13(OverlayPanel, { overlay }),
+    /* @__PURE__ */ jsx13(InputArea, { onSubmit: handleSubmit, onExit, onEscape: dismissOverlay, busy }),
+    /* @__PURE__ */ jsx13(
+      StatusBar,
+      {
+        activeWorkers: activeWorkers ?? [],
+        pendingTasks: pendingTasks ?? [],
+        runningTasks: runningTasks ?? []
+      }
+    )
+  ] });
+}
+
+// src/tui/pages/worker-detail-page.tsx
+import { useState as useState8, useEffect as useEffect4, useMemo as useMemo5 } from "react";
+import { Box as Box11, Text as Text11 } from "ink";
+import { Fragment as Fragment2, jsx as jsx14, jsxs as jsxs12 } from "react/jsx-runtime";
+var MAX_VISIBLE_ENTRIES = 15;
+var CONTENT_MAX_LENGTH = 100;
+var TOOL_CONTENT_MAX_LENGTH = 80;
+function WorkerDetailPage({ workerId, onBack }) {
+  const supervisor = useSupervisor();
+  const workerState = supervisor.getWorkerState(workerId);
+  if (!workerState) {
+    return /* @__PURE__ */ jsxs12(Box11, { flexDirection: "column", padding: 1, children: [
+      /* @__PURE__ */ jsxs12(Text11, { color: "red", children: [
+        "Worker ",
+        workerId,
+        " not found"
+      ] }),
+      /* @__PURE__ */ jsx14(Text11, { color: "gray", children: "Press ESC to go back" })
+    ] });
+  }
+  return /* @__PURE__ */ jsx14(WorkerContent, { workerState, workerId });
+}
+function WorkerContent({ workerState, workerId }) {
+  const supervisor = useSupervisor();
+  const taskInfo = useWayangState(workerState, "runtimeState.task");
+  const conversation = useWayangState(workerState, "conversation");
+  const activeWorkers = useWayangState(
+    supervisor.controllerState,
+    "runtimeState.activeWorkers"
+  );
+  const workerInfo = useMemo5(
+    () => (activeWorkers ?? []).find((w) => w.workerId === workerId),
+    [activeWorkers, workerId]
+  );
+  const isRunning = !!workerInfo;
+  const emoji = workerInfo?.emoji ?? "?";
+  const workerType = workerInfo?.workerType ?? "puppet";
+  const taskTitle = workerInfo?.taskTitle ?? taskInfo?.title ?? "N/A";
+  return /* @__PURE__ */ jsxs12(Box11, { flexDirection: "column", height: "100%", children: [
+    /* @__PURE__ */ jsxs12(Box11, { borderStyle: "bold", borderColor: "yellow", paddingX: 1, children: [
+      /* @__PURE__ */ jsxs12(Text11, { color: "yellow", bold: true, children: [
+        emoji,
+        " ",
+        workerType
+      ] }),
+      /* @__PURE__ */ jsx14(Text11, { dimColor: true, children: " \xB7 " }),
+      /* @__PURE__ */ jsx14(Text11, { bold: true, children: taskTitle })
+    ] }),
+    /* @__PURE__ */ jsxs12(Box11, { flexDirection: "column", flexGrow: 1, padding: 1, children: [
+      /* @__PURE__ */ jsx14(Text11, { bold: true, children: "Task:" }),
+      /* @__PURE__ */ jsxs12(Text11, { children: [
+        "  ",
+        taskInfo?.description ?? "N/A"
+      ] }),
+      /* @__PURE__ */ jsxs12(Text11, { bold: true, children: [
+        "Conversation (",
+        conversation?.length ?? 0,
+        " entries):"
+      ] }),
+      (conversation ?? []).slice(-MAX_VISIBLE_ENTRIES).map((entry, i) => /* @__PURE__ */ jsx14(ConversationRow, { entry }, `${entry.uuid}-${i}`))
+    ] }),
+    /* @__PURE__ */ jsxs12(Box11, { paddingX: 1, justifyContent: "space-between", children: [
+      /* @__PURE__ */ jsx14(Text11, { dimColor: true, children: "Press Esc to go back" }),
+      isRunning && /* @__PURE__ */ jsx14(WorkerTimer, { startedAt: workerInfo.startedAt }),
+      !isRunning && /* @__PURE__ */ jsx14(Text11, { dimColor: true, children: "Done" })
+    ] })
+  ] });
+}
+function WorkerTimer({ startedAt }) {
+  const [now, setNow] = useState8(Date.now());
+  const [frame, setFrame] = useState8(0);
+  useEffect4(() => {
+    const timer = setInterval(() => {
+      setNow(Date.now());
+      setFrame((f) => (f + 1) % theme.spinner.frames.length);
+    }, 500);
+    return () => clearInterval(timer);
+  }, []);
+  const elapsed = Math.round((now - startedAt) / 1e3);
+  const mins = Math.floor(elapsed / 60);
+  const secs = elapsed % 60;
+  const timeStr = mins > 0 ? `${mins}m${secs}s` : `${secs}s`;
+  return /* @__PURE__ */ jsxs12(Text11, { children: [
+    /* @__PURE__ */ jsxs12(Text11, { color: theme.assistant.prefixColor, bold: true, children: [
+      theme.spinner.frames[frame],
+      " "
+    ] }),
+    /* @__PURE__ */ jsxs12(Text11, { dimColor: true, children: [
+      "Running ",
+      timeStr
+    ] })
+  ] });
+}
+function ConversationRow({ entry }) {
+  switch (entry.type) {
+    case "user":
+      return /* @__PURE__ */ jsxs12(Text11, { children: [
+        /* @__PURE__ */ jsx14(Text11, { color: "cyan", bold: true, children: "> " }),
+        entry.message?.content?.slice(0, CONTENT_MAX_LENGTH)
+      ] });
+    case "assistant": {
+      const items = [];
+      if (entry.message?.content) {
+        items.push(
+          /* @__PURE__ */ jsxs12(Text11, { children: [
+            /* @__PURE__ */ jsx14(Text11, { color: "green", children: "  " }),
+            entry.message.content.slice(0, CONTENT_MAX_LENGTH)
+          ] }, "text")
+        );
+      }
+      if (entry.toolCalls?.length) {
+        for (const tc of entry.toolCalls) {
+          items.push(
+            /* @__PURE__ */ jsxs12(Text11, { dimColor: true, children: [
+              "  [",
+              tc.toolName,
+              "] ",
+              tc.arguments.slice(0, TOOL_CONTENT_MAX_LENGTH)
+            ] }, `tc-${tc.toolCallId}`)
+          );
+        }
+      }
+      if (entry.toolResults?.length) {
+        for (const tr of entry.toolResults) {
+          items.push(
+            /* @__PURE__ */ jsxs12(Text11, { dimColor: true, children: [
+              "  [",
+              tr.toolName,
+              "] ",
+              tr.output.value.slice(0, TOOL_CONTENT_MAX_LENGTH)
+            ] }, `tr-${tr.toolCallId}`)
+          );
+        }
+      }
+      return items.length > 0 ? /* @__PURE__ */ jsx14(Fragment2, { children: items }) : null;
+    }
+    case "signal":
+      return /* @__PURE__ */ jsxs12(Text11, { color: "yellow", children: [
+        "  [sig] ",
+        entry.content?.slice(0, TOOL_CONTENT_MAX_LENGTH)
+      ] });
+    case "system":
+      return /* @__PURE__ */ jsxs12(Text11, { color: "gray", children: [
+        "  [sys] ",
+        entry.content?.slice(0, TOOL_CONTENT_MAX_LENGTH)
+      ] });
+    default:
+      return null;
+  }
+}
+
+// src/tui/app.tsx
+import { jsx as jsx15, jsxs as jsxs13 } from "react/jsx-runtime";
+function App({ supervisor }) {
+  return /* @__PURE__ */ jsx15(SupervisorProvider, { supervisor, children: /* @__PURE__ */ jsx15(RouteProvider, { children: /* @__PURE__ */ jsx15(AppContent, {}) }) });
+}
+function AppContent() {
+  const { exit } = useApp();
+  const supervisor = useSupervisor();
+  const { route, navigate } = useRouter();
+  const busy = useWayangState(supervisor.controllerState, "dynamicState.busy") ?? false;
+  const lastCtrlC = useRef2(0);
+  const handleExit = useMemoizedFn(() => {
+    exit();
+  });
+  useInput3((_ch, key) => {
+    if (key.escape && route.page === "worker") {
+      navigate({ page: "controller" });
+    }
+    if (key.ctrl && _ch === "c") {
+      if (busy) {
+        supervisor.controllerAgent.abort();
+        return;
+      }
+      const now = Date.now();
+      if (lastCtrlC.current && now - lastCtrlC.current < 1e3) {
+        supervisor.shutdown().then(() => exit());
+      } else {
+        lastCtrlC.current = now;
+      }
+    }
+  });
+  return /* @__PURE__ */ jsxs13(Box12, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsx15(Box12, { display: route.page === "controller" ? "flex" : "none", flexDirection: "column", children: /* @__PURE__ */ jsx15(ControllerPage, { onExit: handleExit }) }),
+    route.page === "worker" && /* @__PURE__ */ jsx15(WorkerDetailPage, { workerId: route.workerId, onBack: () => navigate({ page: "controller" }) })
+  ] });
+}
+
+// package.json
+var package_default = {
+  name: "wayang-ai",
+  version: "0.1.0",
+  description: "Multi-agent orchestration platform",
+  type: "module",
+  license: "MIT",
+  author: "pgYou",
+  repository: {
+    type: "git",
+    url: "git+https://github.com/pgYou/wayang.git"
+  },
+  homepage: "https://github.com/pgYou/wayang#readme",
+  bugs: {
+    url: "https://github.com/pgYou/wayang/issues"
+  },
+  keywords: [
+    "ai",
+    "agent",
+    "multi-agent",
+    "orchestration",
+    "cli",
+    "llm",
+    "claude"
+  ],
+  bin: {
+    wayang: "./dist/cli.js",
+    waya: "./dist/cli.js"
+  },
+  files: [
+    "dist",
+    "!dist/**/*.map"
+  ],
+  scripts: {
+    build: "tsup",
+    "dev:watch": "tsup --watch",
+    dev: "tsup && node --env-file=.env.local dist/cli.js --home-dir . -w . -c ./config.local.json --verbose",
+    start: "node dist/cli.js",
+    prepublishOnly: "npm run build",
+    test: "vitest run",
+    "test:watch": "vitest",
+    "test:coverage": "vitest run --coverage",
+    lint: "tsc --noEmit && eslint src/"
+  },
+  engines: {
+    node: ">=20"
+  },
+  dependencies: {
+    "@ai-sdk/openai": "^3.0.50",
+    "@anthropic-ai/claude-agent-sdk": "^0.2.98",
+    "@types/react": "^18.3.28",
+    ai: "^6.0.145",
+    ink: "^4.4.1",
+    "lodash-es": "^4.18.1",
+    meow: "^14.1.0",
+    pino: "^9.6.0",
+    "pino-pretty": "^13.0.0",
+    prompts: "^2.4.2",
+    react: "^18.3.1",
+    zod: "^4.3.6"
+  },
+  devDependencies: {
+    "@eslint/js": "^9.0.0",
+    "@types/lodash-es": "^4.17.12",
+    "@types/node": "^22.0.0",
+    "@types/prompts": "^2.4.9",
+    eslint: "^9.0.0",
+    "eslint-plugin-react-hooks": "^5.2.0",
+    tsup: "^8.5.1",
+    typescript: "^5.8.0",
+    "typescript-eslint": "^8.58.0",
+    vitest: "^4.1.2"
+  }
+};
+
+// src/tui/welcome.ts
+var logo3d = `
+  \u2588\u2588\u2557    \u2588\u2588\u2557 \u2588\u2588\u2588\u2588\u2588\u2557 \u2588\u2588\u2557   \u2588\u2588\u2557 \u2588\u2588\u2588\u2588\u2588\u2557 \u2588\u2588\u2588\u2557   \u2588\u2588\u2557 \u2588\u2588\u2588\u2588\u2588\u2588\u2557 
+  \u2588\u2588\u2551    \u2588\u2588\u2551\u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2557\u255A\u2588\u2588\u2557 \u2588\u2588\u2554\u255D\u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2557\u2588\u2588\u2588\u2588\u2557  \u2588\u2588\u2551\u2588\u2588\u2554\u2550\u2550\u2550\u2550\u255D 
+  \u2588\u2588\u2551 \u2588\u2557 \u2588\u2588\u2551\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2551 \u255A\u2588\u2588\u2588\u2588\u2554\u255D \u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2551\u2588\u2588\u2554\u2588\u2588\u2557 \u2588\u2588\u2551\u2588\u2588\u2551  \u2588\u2588\u2588\u2557
+  \u2588\u2588\u2551\u2588\u2588\u2588\u2557\u2588\u2588\u2551\u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2551  \u255A\u2588\u2588\u2554\u255D  \u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2551\u2588\u2588\u2551\u255A\u2588\u2588\u2557\u2588\u2588\u2551\u2588\u2588\u2551   \u2588\u2588\u2551
+  \u255A\u2588\u2588\u2588\u2554\u2588\u2588\u2588\u2554\u255D\u2588\u2588\u2551  \u2588\u2588\u2551   \u2588\u2588\u2551   \u2588\u2588\u2551  \u2588\u2588\u2551\u2588\u2588\u2551 \u255A\u2588\u2588\u2588\u2588\u2551\u255A\u2588\u2588\u2588\u2588\u2588\u2588\u2554\u255D
+   \u255A\u2550\u2550\u255D\u255A\u2550\u2550\u255D \u255A\u2550\u255D  \u255A\u2550\u255D   \u255A\u2550\u255D   \u255A\u2550\u255D  \u255A\u2550\u255D\u255A\u2550\u255D  \u255A\u2550\u2550\u2550\u255D \u255A\u2550\u2550\u2550\u2550\u2550\u255D                                                                                             
+`;
+var pkgVersion = package_default.version;
+function writeWelcome(workspace) {
+  const GREEN = "\x1B[32m";
+  const BOLD = "\x1B[1m";
+  const DIM = "\x1B[2m";
+  const RESET = "\x1B[0m";
+  process.stdout.write("\n");
+  process.stdout.write(GREEN + logo3d + RESET);
+  process.stdout.write("\n");
+  process.stdout.write(`  Welcome to play with ${BOLD}Wayang${RESET}
+`);
+  process.stdout.write(`  ${DIM}${pkgVersion} \xB7 ${workspace}${RESET}
+`);
+  process.stdout.write("\n");
+}
+
+// src/tui/render.ts
+function renderInkUI(supervisor) {
+  return new Promise((resolve4) => {
+    process.stdout.write("\x1B[2J\x1B[H");
+    writeWelcome(supervisor.ctx.workspaceDir);
+    const { waitUntilExit } = render(
+      React7.createElement(App, { supervisor })
+    );
+    waitUntilExit().then(() => resolve4());
+  });
+}
+
+// src/onboard.ts
+import * as fs2 from "fs";
+import * as path3 from "path";
+import * as childProcess from "child_process";
+import prompts from "prompts";
+function fillApiKeys(config) {
+  const envKey = process.env.WAYANG_LLM_API_KEY || "";
+  for (const provider of Object.values(config.providers)) {
+    if (!provider.apiKey && envKey) {
+      provider.apiKey = envKey;
+    }
+  }
+}
+function detectClaudeCode() {
+  try {
+    const result = childProcess.execSync("which claude 2>/dev/null", { encoding: "utf-8" }).trim();
+    return result || null;
+  } catch {
+    return null;
+  }
+}
+async function promptClaudeCodeWorker(claudeDetected) {
+  const hint = claudeDetected ? "Claude Code detected. Configure as a worker?" : "Configure Claude Code worker? (install Claude Code CLI first)";
+  const { enable } = await prompts({
+    type: "confirm",
+    name: "enable",
+    message: hint,
+    initial: claudeDetected
+  });
+  if (!enable) return void 0;
+  const answers = await prompts([
+    {
+      type: "text",
+      name: "emoji",
+      message: "Worker emoji",
+      initial: "\u{1F980}"
+    },
+    {
+      type: "text",
+      name: "cliPath",
+      message: "Path to Claude Code CLI (leave empty for auto-detect)",
+      initial: ""
+    },
+    {
+      type: "number",
+      name: "maxTurns",
+      message: "Max turns per task",
+      initial: 10,
+      min: 1,
+      max: 100
+    }
+  ]);
+  return {
+    type: "claude-code",
+    enable: true,
+    emoji: answers.emoji || "\u{1F980}",
+    description: "Coding assistant powered by Claude Code \u2014 excels at writing, debugging, and refactoring code",
+    capabilities: ["code", "debug", "refactor", "git"],
+    maxTurns: answers.maxTurns ?? 10,
+    cliPath: answers.cliPath || void 0
+  };
+}
+async function buildConfigInteractive() {
+  console.log("\n  Welcome to paly with Wayang! Let's configure your setup.\n");
+  const answers = await prompts([
+    {
+      type: "text",
+      name: "endpoint",
+      message: "API endpoint (OpenAI-compatible base URL, e.g. https://api.openai.com/v1)"
+    },
+    {
+      type: "text",
+      name: "apiKey",
+      message: "API key"
+    },
+    {
+      type: "text",
+      name: "modelName",
+      message: "Model name"
+    },
+    {
+      type: "number",
+      name: "maxConcurrency",
+      message: "Max concurrent workers",
+      initial: 3,
+      min: 1,
+      max: 10
+    }
+  ]);
+  if (!answers.apiKey) {
+    console.error("Error: API key is required.");
+    process.exit(1);
+  }
+  const config = {
+    providers: {
+      default: {
+        endpoint: answers.endpoint,
+        apiKey: answers.apiKey,
+        modelName: answers.modelName
+      }
+    },
+    controller: { provider: "default" },
+    worker: { provider: "default", maxConcurrency: answers.maxConcurrency ?? 3 }
+  };
+  const claudePath = detectClaudeCode();
+  const workerConfig = await promptClaudeCodeWorker(!!claudePath);
+  if (workerConfig) {
+    config.workers = { "claude-code": workerConfig };
+  }
+  return config;
+}
+async function loadConfig(configPath2) {
+  let config;
+  if (fs2.existsSync(configPath2)) {
+    config = JSON.parse(fs2.readFileSync(configPath2, "utf-8"));
+  } else {
+    const envKey = process.env.WAYANG_LLM_API_KEY || "";
+    const envEndpoint = process.env.WAYANG_ENDPOINT || "";
+    const envModel = process.env.WAYANG_MODEL || "";
+    if (envKey && envEndpoint && envModel) {
+      config = {
+        providers: { default: { endpoint: envEndpoint, apiKey: envKey, modelName: envModel } },
+        controller: { provider: "default" },
+        worker: { provider: "default", maxConcurrency: 3 }
+      };
+    } else {
+      config = await buildConfigInteractive();
+    }
+    fs2.mkdirSync(path3.dirname(configPath2), { recursive: true });
+    fs2.writeFileSync(configPath2, JSON.stringify(config, null, 2));
+  }
+  fillApiKeys(config);
+  const err = validateConfig(config);
+  if (err) {
+    console.error(`Error: ${err}`);
+    console.error("Run `wayang` without arguments to configure.");
+    process.exit(1);
+  }
+  return config;
+}
+
+// src/session-select.ts
+import prompts2 from "prompts";
+function formatSessionChoice(meta, showWorkspace) {
+  const date = new Date(meta.createdAt).toLocaleString();
+  const label = meta.firstInput ? `"${meta.firstInput}"` : "(no input yet)";
+  const ws = showWorkspace ? `  [${meta.workspace}]` : "";
+  return `${meta.sessionId}  ${date}  ${label}${ws}`;
+}
+async function selectSessionInteractive(homeDir2, workspaceDir2, showAll) {
+  let sessions = listSessions(homeDir2);
+  if (!showAll) {
+    sessions = sessions.filter((m) => m.workspace === workspaceDir2);
+  }
+  if (sessions.length === 0) {
+    const scope = showAll ? "any workspace" : `workspace ${workspaceDir2}`;
+    console.error(`Error: No sessions found for ${scope}. Start a new session first.`);
+    process.exit(1);
+  }
+  const { selected } = await prompts2({
+    type: "select",
+    name: "selected",
+    message: "Select a session to resume",
+    choices: sessions.map((m) => ({
+      title: formatSessionChoice(m, showAll),
+      value: m.sessionId
+    }))
+  });
+  if (!selected) {
+    process.exit(0);
+  }
+  const result = getSession(homeDir2, selected);
+  if (!result) {
+    console.error(`Error: Session "${selected}" not found.`);
+    process.exit(1);
+  }
+  if (result.meta.workspace !== workspaceDir2) {
+    const { confirm } = await prompts2({
+      type: "confirm",
+      name: "confirm",
+      message: `Session workspace is ${result.meta.workspace}, current dir is ${workspaceDir2}. Switch?`,
+      initial: true
+    });
+    if (!confirm) {
+      process.exit(0);
+    }
+  }
+  return result;
+}
+
+// src/bootstrap.ts
+function die(msg) {
+  console.error(`Error: ${msg}`);
+  process.exit(1);
+}
+async function bootstrap(options) {
+  const config = await loadConfig(options.configPath);
+  const supervisorOpts = {
+    config,
+    workspaceDir: options.workspaceDir,
+    logLevel: options.logLevel,
+    homeDir: options.homeDir
+  };
+  if (options.resume === void 0) {
+  } else if (options.resume === "") {
+    const result = await selectSessionInteractive(options.homeDir, options.workspaceDir, options.showAll ?? false);
+    supervisorOpts.workspaceDir = result.meta.workspace;
+    supervisorOpts.resume = { sessionId: result.sessionId, sessionDir: result.sessionDir };
+    console.log(`  Resuming session ${result.sessionId}`);
+  } else {
+    const existing = getSession(options.homeDir, options.resume);
+    if (!existing) {
+      die(`Session "${options.resume}" not found.`);
+    }
+    supervisorOpts.workspaceDir = existing.meta.workspace;
+    supervisorOpts.resume = { sessionId: existing.sessionId, sessionDir: existing.sessionDir };
+    console.log(`  Resuming session ${existing.sessionId}`);
+  }
+  const supervisor = new Supervisor(supervisorOpts);
+  await supervisor.restore();
+  await supervisor.start();
+  mainControllerLoop(supervisor).catch((err) => {
+    supervisor.ctx.logger.error({ error: err.message }, "Controller loop crashed");
+  });
+  process.on("SIGTERM", () => {
+    supervisor.shutdown().then(() => process.exit(0));
+  });
+  await renderInkUI(supervisor);
+  await supervisor.shutdown();
+}
+
+// src/cli.ts
+var cli = meow(`
+  Usage
+    $ wayang                       New session
+    $ wayang --resume              Interactive session select
+    $ wayang --resume <id>         Resume specific session
+    $ wayang --resume --all        Show all workspaces
+
+  Options
+    --home-dir <path>       Root directory for sessions & config (default: $HOME)
+    --workspace-dir, -w     Working directory for tools (default: pwd)
+    --config, -c            Config file path
+    --resume, -r            Resume a previous session
+    --all                   List sessions across all workspaces (with --resume)
+    --verbose, -v           Enable debug logging
+`, {
+  importMeta: import.meta,
+  flags: {
+    homeDir: {
+      type: "string",
+      default: process.env.HOME || "~"
+    },
+    workspaceDir: {
+      type: "string",
+      shortFlag: "w",
+      default: process.cwd()
+    },
+    config: {
+      type: "string",
+      shortFlag: "c"
+    },
+    resume: {
+      type: "boolean",
+      shortFlag: "r",
+      default: false
+    },
+    all: {
+      type: "boolean",
+      default: false
+    },
+    verbose: {
+      type: "boolean",
+      shortFlag: "v",
+      default: false
+    }
+  }
+});
+var homeDir = path4.resolve(cli.flags.homeDir);
+var workspaceDir = path4.resolve(cli.flags.workspaceDir);
+var configPath = cli.flags.config ? path4.resolve(cli.flags.config) : path4.join(homeDir, ".wayang.config.json");
+var resumeFlag = cli.flags.resume;
+var resumeId = resumeFlag ? cli.input.at(0) || void 0 : void 0;
+bootstrap({
+  configPath,
+  homeDir: path4.join(homeDir, ".wayang"),
+  workspaceDir,
+  logLevel: cli.flags.verbose ? "debug" : "info",
+  resume: resumeFlag ? resumeId ?? "" : void 0,
+  showAll: cli.flags.all
+}).catch((err) => {
+  console.error("Fatal:", err);
+  process.exit(1);
+});
+//# sourceMappingURL=cli.js.map