wayang-ai 0.6.2 → 0.7.0

package/dist/cli.js

@@ -192,9 +192,9 @@ var RpcClient = class {
       return Promise.reject(new Error("RPC transport closed: cannot send request"));
     }
     const id = this.nextId++;
-    return new Promise((resolve11, reject) => {
+    return new Promise((resolve12, reject) => {
       this.pending.set(id, {
-        resolve: (v) => resolve11(v),
+        resolve: (v) => resolve12(v),
         reject
       });
       this.transport.send({ id, method, params });
@@ -398,8 +398,8 @@ async function connectRemoteServer(options) {
   child.stderr?.on("data", (chunk) => {
     stderrTail = (stderrTail + chunk).slice(-4e3);
   });
-  const exited = new Promise((resolve11) => {
-    child.on("exit", (code) => resolve11(code));
+  const exited = new Promise((resolve12) => {
+    child.on("exit", (code) => resolve12(code));
   });
   const transport = createStreamTransport(child.stdout, child.stdin);
   const rpc = new RpcClient(transport);
@@ -418,10 +418,10 @@ async function connectRemoteServer(options) {
     }
     const exitOrKill = Promise.race([
       exited,
-      new Promise((resolve11) => {
+      new Promise((resolve12) => {
         setTimeout(() => {
           child.kill("SIGKILL");
-          resolve11(null);
+          resolve12(null);
         }, SHUTDOWN_GRACE_MS);
       })
     ]);
@@ -439,7 +439,7 @@ ${stderrTail}`);
   return { remote, stop };
 }
 function waitForReady(child, rpc, exited, getStderrTail, timeoutMs) {
-  return new Promise((resolve11, reject) => {
+  return new Promise((resolve12, reject) => {
     let settled = false;
     const finish = (err) => {
       if (settled) return;
@@ -447,7 +447,7 @@ function waitForReady(child, rpc, exited, getStderrTail, timeoutMs) {
       clearTimeout(timer);
       offReady();
       if (err) reject(err);
-      else resolve11();
+      else resolve12();
     };
     const timer = setTimeout(() => {
       child.kill("SIGKILL");
@@ -604,7 +604,7 @@ import React6 from "react";
 import { render } from "ink";
 
 // src/tui/app.tsx
-import { useRef as useRef2 } from "react";
+import { useRef as useRef3 } from "react";
 
 // src/tui/hooks/use-memoized-fn.ts
 import { useRef, useCallback } from "react";
@@ -1104,14 +1104,17 @@ function summarizeWorkerMessage(argsJson, width, result, maxLines = 3) {
   const message = args ? str(args.message) ?? "" : argsJson;
   const { lines, hidden } = previewLines(message, maxLines, width);
   const failed = result !== void 0 && (result.isError === true || /^\[ERROR\]/.test(result.text));
+  let delivery;
+  if (result !== void 0 && !failed) {
+    delivery = /\bqueued\b/i.test(result.text) ? "queued" : /\bdelivered\b/i.test(result.text) ? "delivered" : void 0;
+  }
   return {
     ...workerId && { workerId },
     lines,
     hiddenLines: hidden,
     outcome: result === void 0 ? "pending" : failed ? "failed" : "ok",
     failure: failed ? failureText(result.text, width) : "",
-    ...result !== void 0 && !failed && /\bqueued\b/.test(result.text) && { delivery: "queued" },
-    ...result !== void 0 && !failed && /\bdelivered\b/.test(result.text) && { delivery: "delivered" }
+    ...delivery && { delivery }
   };
 }
 var TASK_ID_RE = /^Task (\S+) (?:added|assigned)/;
@@ -1369,6 +1372,7 @@ function WorkerMessageRow({ section: section2, result, lookups }) {
   const worker = summary.workerId ? lookups.workers.get(summary.workerId) : void 0;
   const target = formatWorkerTag(worker ?? { workerId: summary.workerId }) || "(\u672A\u77E5 worker)";
   const iconColor = summary.outcome === "failed" ? theme.action.failColor : theme.action.color;
+  const delivered = summary.delivery === "queued" ? "\u5DF2\u6392\u961F" : summary.delivery === "delivered" ? "\u5DF2\u9001\u8FBE" : "\u5DF2\u53D1\u9001";
   return /* @__PURE__ */ jsxs2(Box2, { flexDirection: "column", children: [
     /* @__PURE__ */ jsxs2(Box2, { children: [
       /* @__PURE__ */ jsxs2(Text2, { color: iconColor, bold: true, children: [
@@ -1379,7 +1383,7 @@ function WorkerMessageRow({ section: section2, result, lookups }) {
         " ",
         target
       ] }),
-      /* @__PURE__ */ jsx3(OutcomeMark, { outcome: summary.outcome, ok: summary.delivery === "queued" ? "\u5DF2\u6392\u961F" : "\u5DF2\u9001\u8FBE", failed: "\u672A\u9001\u8FBE" })
+      /* @__PURE__ */ jsx3(OutcomeMark, { outcome: summary.outcome, ok: delivered, failed: "\u672A\u9001\u8FBE" })
     ] }),
     /* @__PURE__ */ jsx3(PreviewLines, { lines: summary.lines, hidden: summary.hiddenLines }),
     summary.failure && /* @__PURE__ */ jsx3(SecondaryLine, { color: theme.action.failColor, children: summary.failure })
@@ -1651,7 +1655,7 @@ var ChatArea = React2.memo(function ChatArea2({ items, busy, streamingItems, con
 });
 
 // src/tui/components/input-area.tsx
-import { useState as useState2, useMemo as useMemo2 } from "react";
+import { useState as useState2, useMemo as useMemo2, useRef as useRef2 } from "react";
 
 // src/tui/utils/format-tokens.ts
 function formatTokenCount(tokens) {
@@ -1798,21 +1802,302 @@ function useSlashCommands(supervisor) {
 
 // src/tui/components/input-area.tsx
 import { Box as Box6, Text as Text7, useInput } from "ink";
-import { jsx as jsx9, jsxs as jsxs6 } from "react/jsx-runtime";
-function InputArea({ onSubmit, onExit, onEscape, busy }) {
+
+// src/tui/utils/input-display.ts
+function normalizeInputText(s) {
+  return s.replace(/\r\n?/g, "\n");
+}
+function isHighSurrogate(codeUnit) {
+  return codeUnit >= 55296 && codeUnit <= 56319;
+}
+function isLowSurrogate(codeUnit) {
+  return codeUnit >= 56320 && codeUnit <= 57343;
+}
+function prevCodePointLength(s, index) {
+  if (index <= 0) return 0;
+  if (index >= 2 && isHighSurrogate(s.charCodeAt(index - 2)) && isLowSurrogate(s.charCodeAt(index - 1))) {
+    return 2;
+  }
+  return 1;
+}
+function nextCodePointLength(s, index) {
+  if (index < 0 || index >= s.length) return 0;
+  if (index + 1 < s.length && isHighSurrogate(s.charCodeAt(index)) && isLowSurrogate(s.charCodeAt(index + 1))) {
+    return 2;
+  }
+  return 1;
+}
+function wrapByDisplayWidth(line, maxWidth) {
+  const limit = Math.max(1, Math.floor(maxWidth));
+  if (stringWidth(line) <= limit) return [line];
+  const segments = [];
+  let current = "";
+  let width = 0;
+  for (const ch of line) {
+    const cw = charWidth(ch.codePointAt(0) ?? 0);
+    if (current !== "" && width + cw > limit) {
+      segments.push(current);
+      current = ch;
+      width = cw;
+    } else {
+      current += ch;
+      width += cw;
+    }
+  }
+  if (current !== "") segments.push(current);
+  return segments.length > 0 ? segments : [""];
+}
+function splitLineBySelection(line, selection) {
+  const lo = line.offset;
+  const hi = line.offset + line.text.length;
+  const s = Math.max(lo, Math.min(hi, selection.start));
+  const e = Math.max(lo, Math.min(hi, selection.end));
+  if (s >= e) return [{ text: line.text, selected: false }];
+  const out = [];
+  if (s > lo) out.push({ text: line.text.slice(0, s - lo), selected: false });
+  out.push({ text: line.text.slice(s - lo, e - lo), selected: true });
+  if (e < hi) out.push({ text: line.text.slice(e - lo), selected: false });
+  return out.filter((seg) => seg.text.length > 0);
+}
+function layoutInput(value, cursor, maxWidth) {
+  const c = Math.max(0, Math.min(value.length, cursor));
+  const logicalLines = value.split("\n");
+  const lines = [];
+  let cursorLine = 0;
+  let cursorCol = 0;
+  let offset = 0;
+  for (const lineText of logicalLines) {
+    const col = c - offset;
+    const ownsCursor = col >= 0 && col <= lineText.length;
+    const segments = wrapByDisplayWidth(lineText, maxWidth);
+    for (const segment of segments) {
+      lines.push({ text: segment, offset });
+      offset += segment.length;
+    }
+    if (ownsCursor) {
+      let base = 0;
+      for (let i = 0; i < segments.length; i++) {
+        const segment = segments[i];
+        const segEnd = base + segment.length;
+        const isLastSegment = i === segments.length - 1;
+        if (col < segEnd || col === segEnd && isLastSegment) {
+          cursorLine = lines.length - segments.length + i;
+          cursorCol = col - base;
+          break;
+        }
+        base = segEnd;
+      }
+    }
+    offset += 1;
+  }
+  return { lines, cursorLine, cursorCol };
+}
+
+// src/tui/utils/input-editing.ts
+function clampIndex(value, index) {
+  return Math.max(0, Math.min(value.length, index));
+}
+function normalizeCursorIndex(value, index) {
+  const i = clampIndex(value, index);
+  if (i > 0 && i < value.length && (value.codePointAt(i - 1) ?? 0) > 65535) {
+    return i + 1;
+  }
+  return i;
+}
+var CJK_RANGES = [
+  // Hiragana + Katakana, incl. the prolonged sound mark ー (the middle dot ・
+  // is punctuation and filtered out before this check).
+  [12352, 12543],
+  // CJK Extension A + Unified Ideographs.
+  [13312, 40959],
+  // CJK compatibility ideographs.
+  [63744, 64255],
+  // CJK Extension B and beyond.
+  [131072, 262143]
+];
+var WHITESPACE = /\s/u;
+var PUNCTUATION = new RegExp("\\p{P}", "u");
+function classifyCodePoint(cp) {
+  if (cp === 95) return "word";
+  const ch = String.fromCodePoint(cp);
+  if (WHITESPACE.test(ch)) return "separator";
+  if (PUNCTUATION.test(ch)) return "separator";
+  for (const [lo, hi] of CJK_RANGES) {
+    if (cp >= lo && cp <= hi) return "cjk";
+  }
+  return "word";
+}
+function classBefore(value, index) {
+  if (index <= 0) return "separator";
+  const len = prevCodePointLength(value, index);
+  return classifyCodePoint(value.codePointAt(index - len) ?? 0);
+}
+function classAt(value, index) {
+  return classifyCodePoint(value.codePointAt(index) ?? 0);
+}
+function wordLeft(value, index) {
+  let i = normalizeCursorIndex(value, index);
+  while (i > 0 && classBefore(value, i) === "separator") {
+    i -= prevCodePointLength(value, i);
+  }
+  if (i === 0) return 0;
+  if (classBefore(value, i) === "cjk") {
+    return i - prevCodePointLength(value, i);
+  }
+  while (i > 0 && classBefore(value, i) === "word") {
+    i -= prevCodePointLength(value, i);
+  }
+  return i;
+}
+function wordRight(value, index) {
+  const len = value.length;
+  let i = normalizeCursorIndex(value, index);
+  while (i < len && classAt(value, i) === "separator") {
+    i += nextCodePointLength(value, i);
+  }
+  if (i === len) return len;
+  if (classAt(value, i) === "cjk") {
+    return i + nextCodePointLength(value, i);
+  }
+  while (i < len && classAt(value, i) === "word") {
+    i += nextCodePointLength(value, i);
+  }
+  return i;
+}
+function lineStart(value, index) {
+  let i = normalizeCursorIndex(value, index);
+  while (i > 0 && value.charCodeAt(i - 1) !== 10) i -= 1;
+  return i;
+}
+function lineEnd(value, index) {
+  let i = normalizeCursorIndex(value, index);
+  while (i < value.length && value.charCodeAt(i) !== 10) i += 1;
+  return i;
+}
+function killToLineEnd(value, index) {
+  const cursor = normalizeCursorIndex(value, index);
+  const end = lineEnd(value, cursor);
+  return { value: value.slice(0, cursor) + value.slice(end), cursor };
+}
+function killToLineStart(value, index) {
+  const cursor = normalizeCursorIndex(value, index);
+  const start = lineStart(value, cursor);
+  return { value: value.slice(0, start) + value.slice(cursor), cursor: start };
+}
+function killWordBefore(value, index) {
+  const cursor = normalizeCursorIndex(value, index);
+  const start = wordLeft(value, cursor);
+  return { value: value.slice(0, start) + value.slice(cursor), cursor: start };
+}
+function normalizeSelection(value, anchor, cursor) {
+  const c = normalizeCursorIndex(value, cursor);
+  const a = anchor === null ? c : normalizeCursorIndex(value, anchor);
+  return a <= c ? { start: a, end: c } : { start: c, end: a };
+}
+function replaceRange(value, start, end, insert) {
+  let a = clampIndex(value, start);
+  let b = clampIndex(value, end);
+  if (a > b) [a, b] = [b, a];
+  return { value: value.slice(0, a) + insert + value.slice(b), cursor: a + insert.length };
+}
+
+// src/tui/utils/input-history.ts
+var MERGE_WINDOW_MS = 500;
+var MAX_ENTRIES = 100;
+function initInputHistory(value, ts = Date.now()) {
+  return {
+    entries: [{ value, cursor: value.length, anchor: null, ts, kind: "snap" }],
+    pointer: 0,
+    rewound: false
+  };
+}
+function continuesRun(prev, edit) {
+  if (prev.kind === "insert" && edit.kind === "insert") {
+    const lenDiff = edit.value.length - prev.value.length;
+    return (lenDiff === 1 || lenDiff === 2) && edit.cursor === prev.cursor + lenDiff;
+  }
+  if (prev.kind === "delete" && edit.kind === "delete") {
+    const diff = prev.value.length - edit.value.length;
+    return (diff === 1 || diff === 2) && edit.cursor === prev.cursor - diff;
+  }
+  return false;
+}
+function commitEdit(history, edit) {
+  const { entries, pointer, rewound } = history;
+  const prev = entries[pointer];
+  const atTail = pointer === entries.length - 1;
+  if (prev && atTail && !rewound && edit.ts - prev.ts < MERGE_WINDOW_MS && continuesRun(prev, edit)) {
+    const merged = entries.slice();
+    merged[pointer] = { ...edit };
+    return { entries: merged, pointer, rewound: false };
+  }
+  const next = [...entries.slice(0, pointer + 1), { ...edit }];
+  if (next.length > MAX_ENTRIES) {
+    const trimmed = next.slice(next.length - MAX_ENTRIES);
+    return { entries: trimmed, pointer: trimmed.length - 1, rewound: false };
+  }
+  return { entries: next, pointer: next.length - 1, rewound: false };
+}
+function undoEdit(history) {
+  if (history.pointer === 0) return null;
+  return { entries: history.entries, pointer: history.pointer - 1, rewound: true };
+}
+function redoEdit(history) {
+  if (history.pointer === history.entries.length - 1) return null;
+  return { entries: history.entries, pointer: history.pointer + 1, rewound: true };
+}
+
+// src/tui/components/input-area.tsx
+import { Fragment as Fragment3, jsx as jsx9, jsxs as jsxs6 } from "react/jsx-runtime";
+var PREFIX2 = `${theme.user.prefix} `;
+var PREFIX_WIDTH2 = stringWidth(PREFIX2);
+function InputArea({ onSubmit, onExit, onEscape, busy, width }) {
   const [input, setInput] = useState2("");
   const [cursor, setCursor] = useState2(0);
+  const [anchor, setAnchor] = useState2(null);
   const [selectedIndex, setSelectedIndex] = useState2(0);
+  const historyRef = useRef2(initInputHistory(""));
   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 sel = useMemo2(
+    () => normalizeSelection(input, anchor, cursor),
+    [input, anchor, cursor]
+  );
+  const hasSelection = sel.start < sel.end;
+  const visibleSelection = hasSelection && input.slice(sel.start, sel.end).replace(/\n/g, "").length > 0;
   const clampedIndex = showSuggestions ? Math.min(selectedIndex, suggestions.length - 1) : 0;
   const reset = useMemoizedFn(() => {
     setInput("");
     setCursor(0);
+    setAnchor(null);
+    setSelectedIndex(0);
+    historyRef.current = initInputHistory("");
+  });
+  const applyEdit = useMemoizedFn((r, kind) => {
+    setInput(r.value);
+    setCursor(r.cursor);
+    setAnchor(null);
+    setSelectedIndex(0);
+    if (r.value === input && r.cursor === cursor) return;
+    historyRef.current = commitEdit(historyRef.current, {
+      value: r.value,
+      cursor: r.cursor,
+      anchor: null,
+      ts: Date.now(),
+      kind
+    });
+  });
+  const applySnapshot = useMemoizedFn((history) => {
+    const entry = history.entries[history.pointer];
+    if (!entry) return;
+    historyRef.current = history;
+    setInput(entry.value);
+    setCursor(entry.cursor);
+    setAnchor(entry.anchor);
     setSelectedIndex(0);
   });
   const applySuggestion = useMemoizedFn((index) => {
@@ -1820,9 +2105,7 @@ function InputArea({ onSubmit, onExit, onEscape, busy }) {
     if (!cmd) return;
     const text = `/${cmd.name}`;
     const filled = "args" in cmd ? `${text} ` : text;
-    setInput(filled);
-    setCursor(filled.length);
-    setSelectedIndex(0);
+    applyEdit(replaceRange(input, 0, input.length, filled), "replace");
   });
   useInput((ch, key) => {
     if (key.return) {
@@ -1872,39 +2155,133 @@ function InputArea({ onSubmit, onExit, onEscape, busy }) {
       return;
     }
     if (key.escape) {
+      if (hasSelection) {
+        setAnchor(null);
+        return;
+      }
       if (showSuggestions) {
-        setInput("");
-        setCursor(0);
-        setSelectedIndex(0);
+        reset();
       } else {
         onEscape?.();
         reset();
       }
       return;
     }
+    if (key.ctrl && ch === "a") {
+      setAnchor(0);
+      setCursor(input.length);
+      return;
+    }
+    if (key.ctrl && ch === "e") {
+      setAnchor(null);
+      setCursor(lineEnd(input, cursor));
+      return;
+    }
+    if (key.ctrl && ch === "k") {
+      if (hasSelection) {
+        applyEdit(replaceRange(input, sel.start, sel.end, ""), "replace");
+      } else {
+        applyEdit(killToLineEnd(input, cursor), "kill");
+      }
+      return;
+    }
+    if (key.ctrl && ch === "u") {
+      if (hasSelection) {
+        applyEdit(replaceRange(input, sel.start, sel.end, ""), "replace");
+      } else {
+        applyEdit(killToLineStart(input, cursor), "kill");
+      }
+      return;
+    }
+    if (key.ctrl && ch === "w") {
+      if (hasSelection) {
+        applyEdit(replaceRange(input, sel.start, sel.end, ""), "replace");
+      } else {
+        applyEdit(killWordBefore(input, cursor), "kill");
+      }
+      return;
+    }
+    const moveWordLeft = () => {
+      if (key.shift) setAnchor((a) => a ?? cursor);
+      else setAnchor(null);
+      setCursor(wordLeft(input, cursor));
+    };
+    const moveWordRight = () => {
+      if (key.shift) setAnchor((a) => a ?? cursor);
+      else setAnchor(null);
+      setCursor(wordRight(input, cursor));
+    };
+    if (key.ctrl && key.leftArrow) {
+      moveWordLeft();
+      return;
+    }
+    if (key.ctrl && key.rightArrow) {
+      moveWordRight();
+      return;
+    }
+    if (key.meta && !key.escape && ch === "b") {
+      moveWordLeft();
+      return;
+    }
+    if (key.meta && !key.escape && ch === "f") {
+      moveWordRight();
+      return;
+    }
+    if (key.ctrl && ch === "z") {
+      const next = undoEdit(historyRef.current);
+      if (next) applySnapshot(next);
+      return;
+    }
+    if (key.ctrl && ch === "y") {
+      const next = redoEdit(historyRef.current);
+      if (next) applySnapshot(next);
+      return;
+    }
+    if (key.shift && key.leftArrow) {
+      setAnchor((a) => a ?? cursor);
+      setCursor((c) => Math.max(0, c - prevCodePointLength(input, c)));
+      return;
+    }
+    if (key.shift && key.rightArrow) {
+      setAnchor((a) => a ?? cursor);
+      setCursor((c) => Math.min(input.length, c + nextCodePointLength(input, c)));
+      return;
+    }
     if (key.backspace || key.delete) {
+      if (hasSelection) {
+        applyEdit(replaceRange(input, sel.start, sel.end, ""), "delete");
+        return;
+      }
       if (cursor === 0) return;
-      setInput((prev) => prev.slice(0, cursor - 1) + prev.slice(cursor));
-      setCursor((c) => Math.max(0, c - 1));
-      setSelectedIndex(0);
+      const len = prevCodePointLength(input, cursor);
+      applyEdit(
+        { value: input.slice(0, cursor - len) + input.slice(cursor), cursor: cursor - len },
+        "delete"
+      );
       return;
     }
     if (key.leftArrow) {
-      setCursor((c) => Math.max(0, c - 1));
+      setAnchor(null);
+      setCursor((c) => Math.max(0, c - prevCodePointLength(input, c)));
       return;
     }
     if (key.rightArrow) {
-      setCursor((c) => Math.min(input.length, c + 1));
+      setAnchor(null);
+      setCursor((c) => Math.min(input.length, c + nextCodePointLength(input, c)));
       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 text = normalizeInputText(ch);
+      if (text.length === 0) return;
+      const r = replaceRange(input, sel.start, sel.end, text);
+      applyEdit(r, [...text].length === 1 ? "insert" : "paste");
     }
   });
-  const before = input.slice(0, cursor);
-  const after = input.slice(cursor);
+  const textBudget = Math.max(1, width - 2 - PREFIX_WIDTH2);
+  const layout = useMemo2(
+    () => layoutInput(input, cursor, textBudget),
+    [input, cursor, textBudget]
+  );
   return /* @__PURE__ */ jsxs6(Box6, { flexDirection: "column", children: [
     showSuggestions && /* @__PURE__ */ jsx9(Box6, { flexDirection: "column", paddingX: 1, marginBottom: 0, children: suggestions.map((cmd, i) => {
       const isSelected = i === clampedIndex;
@@ -1918,7 +2295,7 @@ function InputArea({ onSubmit, onExit, onEscape, busy }) {
         ] })
       ] }, cmd.name);
     }) }),
-    /* @__PURE__ */ jsxs6(
+    /* @__PURE__ */ jsx9(
       Box6,
       {
         borderStyle: "single",
@@ -1926,16 +2303,26 @@ function InputArea({ onSubmit, onExit, onEscape, busy }) {
         borderLeft: false,
         borderRight: false,
         paddingX: 1,
-        children: [
-          /* @__PURE__ */ jsx9(Text7, { color: theme.user.prefixColor, bold: true, children: theme.user.prefix }),
-          /* @__PURE__ */ jsxs6(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...)" : "" })
-        ]
+        children: /* @__PURE__ */ jsx9(Box6, { flexDirection: "column", children: layout.lines.map((line, i) => {
+          const isCursorLine = i === layout.cursorLine;
+          const col = layout.cursorCol;
+          const charLen = isCursorLine ? nextCodePointLength(line.text, col) : 0;
+          const before = isCursorLine ? line.text.slice(0, col) : line.text;
+          const cursorCell = isCursorLine && charLen > 0 ? line.text.slice(col, col + charLen) : " ";
+          const after = isCursorLine ? line.text.slice(col + charLen) : "";
+          return /* @__PURE__ */ jsxs6(Box6, { children: [
+            i === 0 ? /* @__PURE__ */ jsx9(Text7, { color: theme.user.prefixColor, bold: true, children: theme.user.prefix }) : /* @__PURE__ */ jsx9(Text7, { children: " ".repeat(PREFIX_WIDTH2) }),
+            visibleSelection ? /* @__PURE__ */ jsxs6(Fragment3, { children: [
+              i === 0 && /* @__PURE__ */ jsx9(Text7, { children: " " }),
+              splitLineBySelection(line, sel).map((seg, j) => /* @__PURE__ */ jsx9(Text7, { inverse: seg.selected, children: seg.text }, j))
+            ] }) : /* @__PURE__ */ jsxs6(Fragment3, { children: [
+              /* @__PURE__ */ jsx9(Text7, { children: i === 0 ? ` ${before}` : before }),
+              isCursorLine && /* @__PURE__ */ jsx9(Text7, { color: "white", inverse: true, children: cursorCell }),
+              /* @__PURE__ */ jsx9(Text7, { children: after })
+            ] }),
+            isCursorLine && busy && /* @__PURE__ */ jsx9(Text7, { dimColor: true, children: " (thinking...)" })
+          ] }, i);
+        }) })
       }
     )
   ] });
@@ -1944,13 +2331,59 @@ function InputArea({ onSubmit, onExit, onEscape, busy }) {
 // src/tui/components/inquiry-prompt.tsx
 import React4, { useState as useState3 } from "react";
 import { Box as Box7, Text as Text8, useInput as useInput2 } from "ink";
+
+// 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 window = provider.contextWindowTokens;
+    if (window !== void 0 && !(Number.isInteger(window) && window > 0)) {
+      return `providers.${name}.contextWindowTokens must be a positive integer (got ${JSON.stringify(window)})`;
+    }
+  }
+  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/signal.ts
+function getSignalField(sig, field) {
+  return sig.payload[field];
+}
+
+// src/types/inquiry.ts
+var INQUIRE_OTHER_OPTION = "\u5176\u4ED6\uFF08\u81EA\u884C\u8F93\u5165\uFF09";
+var INQUIRE_CUSTOM_ANSWER_PREFIX = "[Other] ";
+function buildSelectChoices(options, allowOther) {
+  return allowOther === false ? options : [...options, INQUIRE_OTHER_OPTION];
+}
+function isOtherChoice(choice) {
+  return choice === INQUIRE_OTHER_OPTION;
+}
+function formatCustomAnswer(text) {
+  return `${INQUIRE_CUSTOM_ANSWER_PREFIX}${text}`;
+}
+
+// src/tui/components/inquiry-prompt.tsx
 import { jsx as jsx10, jsxs as jsxs7 } from "react/jsx-runtime";
 function InquiryPrompt({ inquiry, onAnswer }) {
   if (inquiry.type === "confirm") {
     return /* @__PURE__ */ jsx10(ConfirmPrompt, { message: inquiry.message, defaultVal: inquiry.default, onAnswer });
   }
   if (inquiry.type === "select") {
-    return /* @__PURE__ */ jsx10(SelectPrompt, { message: inquiry.message, options: inquiry.options ?? [], onAnswer });
+    return /* @__PURE__ */ jsx10(
+      SelectPrompt,
+      {
+        message: inquiry.message,
+        options: inquiry.options ?? [],
+        allowOther: inquiry.allowOther,
+        onAnswer
+      }
+    );
   }
   return /* @__PURE__ */ jsx10(TextPrompt, { message: inquiry.message, onAnswer });
 }
@@ -1974,25 +2407,53 @@ function ConfirmPrompt({ message, defaultVal, onAnswer }) {
     ] }, opt)) })
   ] });
 }
-function SelectPrompt({ message, options, onAnswer }) {
+function SelectPrompt({ message, options, allowOther, onAnswer }) {
+  const [awaitingCustom, setAwaitingCustom] = useState3(false);
+  if (awaitingCustom) {
+    return /* @__PURE__ */ jsx10(
+      TextPrompt,
+      {
+        message,
+        inputLabel: INQUIRE_OTHER_OPTION,
+        onAnswer: (text) => onAnswer(formatCustomAnswer(text))
+      }
+    );
+  }
+  return /* @__PURE__ */ jsx10(
+    SelectList,
+    {
+      message,
+      options,
+      allowOther,
+      onAnswer,
+      onRequestCustom: () => setAwaitingCustom(true)
+    }
+  );
+}
+function SelectList({ message, options, allowOther, onAnswer, onRequestCustom }) {
+  const choices = buildSelectChoices(options, allowOther);
   const [selected, setSelected] = useState3(0);
   useInput2((_ch, key) => {
-    if (key.upArrow) setSelected((i) => (i - 1 + options.length) % options.length);
-    if (key.downArrow) setSelected((i) => (i + 1) % options.length);
-    if (key.return && options.length > 0) onAnswer(options[selected]);
+    if (key.upArrow && choices.length > 0) setSelected((i) => (i - 1 + choices.length) % choices.length);
+    if (key.downArrow && choices.length > 0) setSelected((i) => (i + 1) % choices.length);
+    if (key.return && choices.length > 0) {
+      const choice = choices[selected];
+      if (isOtherChoice(choice)) onRequestCustom();
+      else onAnswer(choice);
+    }
   });
   return /* @__PURE__ */ jsxs7(Box7, { flexDirection: "column", children: [
     /* @__PURE__ */ jsxs7(Box7, { paddingX: 1, borderStyle: "single", borderColor: "gray", borderLeft: false, borderRight: false, children: [
       /* @__PURE__ */ jsx10(Text8, { color: "cyan", children: "? " }),
       /* @__PURE__ */ jsx10(Text8, { bold: true, children: message })
     ] }),
-    /* @__PURE__ */ jsx10(Box7, { flexDirection: "column", paddingX: 1, children: options.map((opt, i) => /* @__PURE__ */ jsxs7(Box7, { children: [
+    /* @__PURE__ */ jsx10(Box7, { flexDirection: "column", paddingX: 1, children: choices.map((choice, i) => /* @__PURE__ */ jsxs7(Box7, { children: [
       /* @__PURE__ */ jsx10(Text8, { color: i === selected ? theme.baseToken.color.accent : void 0, children: i === selected ? "\u25B8 " : "  " }),
-      /* @__PURE__ */ jsx10(Text8, { bold: i === selected, color: i === selected ? theme.baseToken.color.accent : void 0, children: opt })
+      /* @__PURE__ */ jsx10(Text8, { bold: i === selected, color: i === selected ? theme.baseToken.color.accent : void 0, dimColor: isOtherChoice(choice) && i !== selected, children: choice })
     ] }, i)) })
   ] });
 }
-function TextPrompt({ message, onAnswer }) {
+function TextPrompt({ message, onAnswer, inputLabel }) {
   const [input, setInput] = useState3("");
   const [cursor, setCursor] = useState3(0);
   useInput2((ch, key) => {
@@ -2028,10 +2489,12 @@ function TextPrompt({ message, onAnswer }) {
       /* @__PURE__ */ jsx10(Text8, { bold: true, children: message })
     ] }),
     /* @__PURE__ */ jsxs7(Box7, { paddingX: 1, borderStyle: "single", borderColor: "gray", borderLeft: false, borderRight: false, children: [
-      /* @__PURE__ */ jsxs7(Text8, { children: [
+      inputLabel ? /* @__PURE__ */ jsxs7(Text8, { dimColor: true, children: [
         "  ",
-        before
-      ] }),
+        inputLabel,
+        ": "
+      ] }) : /* @__PURE__ */ jsx10(Text8, { children: "  " }),
+      /* @__PURE__ */ jsx10(Text8, { children: before }),
       /* @__PURE__ */ jsx10(Text8, { color: "white", inverse: true, children: after.length > 0 ? after[0] : " " }),
       /* @__PURE__ */ jsx10(Text8, { children: after.slice(1) })
     ] })
@@ -2170,11 +2633,6 @@ function OverlayPanel({ overlay }) {
   ] });
 }
 
-// src/types/signal.ts
-function getSignalField(sig, field) {
-  return sig.payload[field];
-}
-
 // src/tui/types/display-item.ts
 function entryToDisplayItem(entry) {
   const base = {
@@ -2402,7 +2860,7 @@ function ControllerPage({ onExit }) {
       }
     ) }),
     overlay && /* @__PURE__ */ jsx13(OverlayPanel, { overlay }),
-    pendingInquiry ? /* @__PURE__ */ jsx13(InquiryPrompt, { inquiry: pendingInquiry, onAnswer: (answer) => supervisor.resolveInquiry(answer) }) : /* @__PURE__ */ jsx13(InputArea, { onSubmit: handleSubmit, onExit, onEscape: dismissOverlay, busy }),
+    pendingInquiry ? /* @__PURE__ */ jsx13(InquiryPrompt, { inquiry: pendingInquiry, onAnswer: (answer) => supervisor.resolveInquiry(answer) }) : /* @__PURE__ */ jsx13(InputArea, { onSubmit: handleSubmit, onExit, onEscape: dismissOverlay, busy, width: terminalCols }),
     /* @__PURE__ */ jsx13(
       StatusBar,
       {
@@ -2424,7 +2882,7 @@ function AppContent() {
   const { exit } = useApp();
   const supervisor = useSupervisor();
   const busy = useWayangState(supervisor.controllerAgent, "dynamicState.busy") ?? false;
-  const lastCtrlC = useRef2(0);
+  const lastCtrlC = useRef3(0);
   const handleExit = useMemoizedFn(() => {
     exit();
   });
@@ -2448,7 +2906,7 @@ function AppContent() {
 // package.json
 var package_default = {
   name: "wayang-ai",
-  version: "0.6.2",
+  version: "0.7.0",
   description: "Multi-agent orchestration platform",
   type: "module",
   license: "MIT",
@@ -2550,13 +3008,13 @@ function writeWelcome(workspace) {
 
 // src/tui/render.ts
 function renderInkUI(supervisor) {
-  return new Promise((resolve11) => {
+  return new Promise((resolve12) => {
     process.stdout.write("\x1B[2J\x1B[H");
     writeWelcome(supervisor.ctx.workspaceDir);
     const { waitUntilExit } = render(
       React6.createElement(App, { supervisor })
     );
-    waitUntilExit().then(() => resolve11());
+    waitUntilExit().then(() => resolve12());
   });
 }
 
@@ -2565,26 +3023,6 @@ import * as fs3 from "fs";
 import * as path3 from "path";
 import * as childProcess from "child_process";
 import prompts from "prompts";
-
-// 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 window = provider.contextWindowTokens;
-    if (window !== void 0 && !(Number.isInteger(window) && window > 0)) {
-      return `providers.${name}.contextWindowTokens must be a positive integer (got ${JSON.stringify(window)})`;
-    }
-  }
-  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/onboard.ts
 function fillApiKeys(config) {
   const envKey = process.env.WAYANG_LLM_API_KEY || "";
   for (const provider of Object.values(config.providers)) {
@@ -3508,10 +3946,10 @@ var SignalQueue = class {
   waitForSignal() {
     const unread = this.state.get("signals").filter((s) => s.status === "unread");
     if (unread.length > 0) return Promise.resolve();
-    return new Promise((resolve11) => {
+    return new Promise((resolve12) => {
       this.resolveWait = () => {
         this.logger.debug("waitForSignal resolved");
-        resolve11();
+        resolve12();
       };
     });
   }
@@ -3571,267 +4009,12 @@ var SignalQueue = class {
   }
 };
 
-// src/services/task/task-pool-state.ts
-import { join as join6 } from "path";
-var TaskPoolState = class extends BaseWayangState {
-  jsonFile;
-  logger;
-  constructor(ctx) {
-    const jsonFile = new JSONFileHelper(join6(ctx.sessionDir, "tasks.json"));
-    super(
-      {
-        tasks: {
-          pending: [],
-          running: [],
-          history: []
-        }
-      },
-      [{ path: "tasks", helper: jsonFile }]
-    );
-    this.jsonFile = jsonFile;
-    this.logger = ctx.logger;
-  }
-  async restore() {
-    const data = this.jsonFile.read();
-    if (data) {
-      this.data.tasks = data;
-    }
-    this.logger.info("TaskPoolState restored");
-  }
-};
-
-// src/services/agents/base-agent.ts
-import { streamText, stepCountIs, hasToolCall } from "ai";
-
-// src/services/agents/model-factory.ts
-import { createOpenAICompatible } from "@ai-sdk/openai-compatible";
-function createModel(provider) {
-  const compatible = createOpenAICompatible({
-    name: "wayang",
-    baseURL: provider.endpoint,
-    apiKey: provider.apiKey
-  });
-  return compatible.chatModel(provider.modelName);
-}
-
-// 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/worker-transcript.ts
+import { closeSync as closeSync2, existsSync as existsSync5, openSync as openSync2, readSync, statSync } from "fs";
+import { join as join7 } from "path";
 
-// 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/base-agent.ts
-var DEFAULT_LLM_IDLE_TIMEOUT_MS = 3e5;
-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;
-    const idleTimeoutMs = opts.llmIdleTimeoutMs ?? DEFAULT_LLM_IDLE_TIMEOUT_MS;
-    const callAbort = new AbortController();
-    const forwardAbort = () => callAbort.abort();
-    if (this.abortController.signal.aborted) {
-      callAbort.abort();
-    } else {
-      this.abortController.signal.addEventListener("abort", forwardAbort);
-    }
-    let watchdog = null;
-    let timedOut = false;
-    let toolsInFlight = 0;
-    let finished = false;
-    const clearWatchdog = () => {
-      if (watchdog !== null) {
-        clearTimeout(watchdog);
-        watchdog = null;
-      }
-    };
-    const armWatchdog = () => {
-      if (idleTimeoutMs <= 0 || finished || toolsInFlight > 0) return;
-      clearWatchdog();
-      watchdog = setTimeout(() => {
-        timedOut = true;
-        callAbort.abort();
-      }, idleTimeoutMs);
-    };
-    const tools = pauseWatchdogDuringTools(
-      opts.tools,
-      () => {
-        toolsInFlight++;
-        clearWatchdog();
-      },
-      () => {
-        toolsInFlight--;
-        if (toolsInFlight === 0) armWatchdog();
-      }
-    );
-    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;
-    let firstChunkAt;
-    let stepStartedAt;
-    const onStep = opts.onStep ? (event) => {
-      armWatchdog();
-      const meta = { startedAt: stepStartedAt, firstTokenAt: firstChunkAt };
-      firstChunkAt = void 0;
-      stepStartedAt = nowISO();
-      opts.onStep(event, meta);
-    } : void 0;
-    try {
-      this.hooks.beforeLLM?.({ messageCount: opts.messages.length, messages: opts.messages });
-      startTime = Date.now();
-      stepStartedAt = nowISO();
-      armWatchdog();
-      stream = streamText({
-        model: this.model,
-        system: opts.system,
-        messages: opts.messages,
-        tools,
-        toolChoice: opts.toolChoice,
-        stopWhen: stopConditions.length > 0 ? stopConditions : void 0,
-        abortSignal: callAbort.signal,
-        ...opts.prepareStep && { prepareStep: opts.prepareStep },
-        onStepFinish: onStep,
-        onError: ({ error }) => {
-          opts.onStreamError?.(error);
-        },
-        // SignalEntry entries are trusted system-generated notifications emitted
-        // as `system`-role messages (in-band, order-sensitive). AI SDK v6 warns
-        // on any system message inside `messages` unless this is opted in.
-        allowSystemInMessages: true
-      });
-    } catch (err) {
-      finished = true;
-      clearWatchdog();
-      this.abortController.signal.removeEventListener("abort", forwardAbort);
-      if (this.abortController.signal.aborted) {
-        return { text: "", toolResults: [], usage: void 0 };
-      }
-      throw err;
-    }
-    try {
-      for await (const chunk of stream.textStream) {
-        armWatchdog();
-        if (chunk && firstChunkAt === void 0) firstChunkAt = nowISO();
-        yield chunk;
-      }
-    } catch (err) {
-      if (this.abortController.signal.aborted) {
-        return { text: "", toolResults: [], usage: void 0 };
-      }
-      if (timedOut) {
-        throw new Error(
-          `LLM call idle timeout: no stream progress (text chunk or step finish) for ${idleTimeoutMs}ms`
-        );
-      }
-      if (this.abortController.signal.aborted) {
-        return { text: "", toolResults: [], usage: void 0 };
-      }
-      throw err;
-    } finally {
-      finished = true;
-      clearWatchdog();
-      this.abortController.signal.removeEventListener("abort", forwardAbort);
-    }
-    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 finishReason = await stream.finishReason;
-    const steps = await stream.steps;
-    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,
-      finishReason,
-      steps: steps?.length
-    };
-  }
-  /** 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();
-  }
-};
-function pauseWatchdogDuringTools(tools, onStart, onEnd) {
-  const wrapped = {};
-  for (const [name, def] of Object.entries(tools ?? {})) {
-    const original = def?.execute;
-    if (typeof original !== "function") {
-      wrapped[name] = def;
-      continue;
-    }
-    wrapped[name] = {
-      ...def,
-      execute: async (...args) => {
-        onStart();
-        try {
-          return await original(...args);
-        } finally {
-          onEnd();
-        }
-      }
-    };
-  }
-  return wrapped;
-}
+// src/services/agents/worker-state.ts
+import { join as join6 } from "path";
 
 // src/services/agents/utils/conversation-to-sdk-messages.ts
 function conversationToSdkMessages(entries) {
@@ -4005,6 +4188,32 @@ function toolOutputText(output) {
   return toolPayloadText(output);
 }
 
+// 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/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_CONTEXT_WINDOW_TOKENS = 256e3;
 var COMPACT_THRESHOLD_RATIO = 0.9;
@@ -4180,121 +4389,641 @@ ${this.compactSummary}` : "";
         }
       }
     }
-    breakdown.total = breakdown.systemPrompt + breakdown.user + breakdown.assistant + breakdown.toolCalls + breakdown.toolResults + breakdown.compactSummary;
-    return breakdown;
-  }
-  /**
-   * Restore compact state from a summary computed by the state layer.
-   *
-   * Call this after the state layer's restore() has already sliced the
-   * in-memory conversation to the restore window (entries before the cut are
-   * gone from memory). The window itself is the verbatim zone, so
-   * compactStartIdx resets to 0 — see the field's semantics note.
-   */
-  restoreCompact(summary) {
-    this.compactSummary = summary;
-    this.compactStartIdx = 0;
-  }
-  /** Get the cached compaction summary, or null if no compaction is active. */
-  getCompactSummary() {
-    return this.compactSummary;
+    breakdown.total = breakdown.systemPrompt + breakdown.user + breakdown.assistant + breakdown.toolCalls + breakdown.toolResults + breakdown.compactSummary;
+    return breakdown;
+  }
+  /**
+   * Restore compact state from a summary computed by the state layer.
+   *
+   * Call this after the state layer's restore() has already sliced the
+   * in-memory conversation to the restore window (entries before the cut are
+   * gone from memory). The window itself is the verbatim zone, so
+   * compactStartIdx resets to 0 — see the field's semantics note.
+   */
+  restoreCompact(summary) {
+    this.compactSummary = summary;
+    this.compactStartIdx = 0;
+  }
+  /** Get the cached compaction summary, or null if no compaction is active. */
+  getCompactSummary() {
+    return this.compactSummary;
+  }
+  /**
+   * 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, getSystemPrompt() carries the summary and getMessages() returns only the entries appended after the marker.
+   *
+   * @param meta Optional provenance recorded on the marker (model name).
+   */
+  async compact(summarizer, meta) {
+    const conversation = this.state.get("conversation");
+    if (conversation.length < 4) return;
+    const fromEntryId = conversation[0]?.uuid;
+    const toEntryId = conversation[conversation.length - 1]?.uuid;
+    const summary = await summarizer(conversation);
+    this.compactSummary = summary;
+    this.compactStartIdx = conversation.length;
+    this.lastReportedTokens = null;
+    const markerTs = nowISO();
+    this.state.append("conversation", {
+      type: "system" /* System */,
+      uuid: generateId("compact"),
+      parentUuid: null,
+      sessionId: this.state.get("runtimeState.session.id") ?? "",
+      timestamp: markerTs,
+      subtype: "compact" /* Compact */,
+      content: summary,
+      // System entries are point-in-time events: startedAt/endedAt share the
+      // marker's creation moment.
+      startedAt: markerTs,
+      endedAt: markerTs,
+      compactMeta: {
+        summarizedTokenCount: estimateConversationTokens(conversation),
+        ...fromEntryId !== void 0 && { fromEntryId },
+        ...toEntryId !== void 0 && { toEntryId },
+        ...meta?.model !== void 0 && { model: meta.model },
+        createdAt: markerTs
+      }
+    });
+  }
+};
+
+// src/services/agents/worker-state.ts
+function workerDir(sessionDir, workerId) {
+  return join6(sessionDir, "workers", workerId);
+}
+var WorkerState = class extends BaseWayangState {
+  constructor(sessionDir, workerId, logger) {
+    const dir = workerDir(sessionDir, workerId);
+    const jsonFile = new JSONFileHelper(join6(dir, "runtime-state.json"));
+    const jsonlFile = new JSONLFileHelper(join6(dir, "conversation.jsonl"));
+    const initialData = {
+      runtimeState: {
+        session: { id: workerId, startedAt: Date.now() },
+        task: { id: "", description: "" }
+      },
+      conversation: [],
+      inbox: []
+    };
+    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 allEntries = this.jsonlFile.read();
+    const compactIdx = allEntries.findLastIndex(isCompactMarker);
+    if (compactIdx === -1) {
+      if (allEntries.length > 0) {
+        this.data.conversation = allEntries;
+      }
+    } else {
+      let budget = RECENT_TOKEN_BUDGET;
+      let cutIdx = 0;
+      for (let i = compactIdx - 1; i >= 0; i--) {
+        budget -= estimateEntryTokens(allEntries[i]);
+        if (budget <= 0) {
+          cutIdx = i + 1;
+          break;
+        }
+      }
+      this.data.conversation = allEntries.slice(cutIdx);
+    }
+    this.logger.info("WorkerState restored");
+  }
+};
+
+// src/services/worker-transcript.ts
+var WORKER_TRANSCRIPT_FILE = "conversation.jsonl";
+var MAX_TRANSCRIPT_RESULT_CHARS = 4e4;
+var WORKER_ID_PATTERN = /^[A-Za-z0-9_-]+$/;
+function isValidWorkerId(workerId) {
+  return WORKER_ID_PATTERN.test(workerId) && workerId !== "." && workerId !== "..";
+}
+function workerTranscriptPath(sessionDir, workerId) {
+  return join7(workerDir(sessionDir, workerId), WORKER_TRANSCRIPT_FILE);
+}
+function readWorkerTranscript(sessionDir, workerId) {
+  if (!isValidWorkerId(workerId)) return null;
+  const path7 = workerTranscriptPath(sessionDir, workerId);
+  if (!existsSync5(path7)) return null;
+  return new JSONLFileHelper(path7).read();
+}
+var MAX_TRANSCRIPT_WINDOW_BYTES = 2 * 1024 * 1024;
+var MIN_WINDOW_BYTES = 64 * 1024;
+var ENTRY_BYTES_ESTIMATE = 1024;
+function parseWindow(text, startsAtFileHead) {
+  let body = text;
+  if (!startsAtFileHead) {
+    const nl = body.indexOf("\n");
+    if (nl === -1) return { entries: [], incompleteTail: false };
+    body = body.slice(nl + 1);
+  }
+  const endsComplete = body.endsWith("\n");
+  const lines = body.split("\n");
+  if (endsComplete) lines.pop();
+  const entries = [];
+  let incompleteTail = false;
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    if (line.length === 0) continue;
+    try {
+      entries.push(JSON.parse(line));
+    } catch {
+      if (i === lines.length - 1 && !endsComplete) incompleteTail = true;
+    }
+  }
+  return { entries, incompleteTail };
+}
+function readWorkerTranscriptWindow(sessionDir, workerId, opts = {}) {
+  if (!isValidWorkerId(workerId)) return null;
+  const path7 = workerTranscriptPath(sessionDir, workerId);
+  let size;
+  try {
+    size = statSync(path7).size;
+  } catch {
+    return null;
+  }
+  if (size === 0) {
+    return { entries: [], incompleteTail: false, windowTruncated: false, coversFile: true };
+  }
+  const matches = opts.matches ?? (() => true);
+  const need = opts.need ?? Number.POSITIVE_INFINITY;
+  let windowBytes = need === Number.POSITIVE_INFINITY ? MAX_TRANSCRIPT_WINDOW_BYTES : Math.min(MAX_TRANSCRIPT_WINDOW_BYTES, Math.max(MIN_WINDOW_BYTES, Math.ceil(need) * ENTRY_BYTES_ESTIMATE));
+  for (; ; ) {
+    const readLen = Math.min(size, windowBytes);
+    const start = size - readLen;
+    const chunk = Buffer.alloc(readLen);
+    const fd = openSync2(path7, "r");
+    try {
+      readSync(fd, chunk, 0, readLen, start);
+    } finally {
+      closeSync2(fd);
+    }
+    const parsed = parseWindow(chunk.toString("utf8"), start === 0);
+    const enough = parsed.entries.filter(matches).length >= need;
+    const canGrow = start > 0 && windowBytes < MAX_TRANSCRIPT_WINDOW_BYTES;
+    if (enough || !canGrow) {
+      return {
+        entries: parsed.entries,
+        incompleteTail: parsed.incompleteTail,
+        windowTruncated: start > 0,
+        coversFile: start === 0
+      };
+    }
+    windowBytes = Math.min(MAX_TRANSCRIPT_WINDOW_BYTES, windowBytes * 2);
+  }
+}
+function blockText(block) {
+  if (typeof block === "string") return block;
+  if (block && typeof block === "object") {
+    const b = block;
+    if (b.type === "text" && typeof b.text === "string") return b.text;
+    return JSON.stringify(block);
+  }
+  return String(block ?? "");
+}
+function entryText(entry) {
+  const raw = entry;
+  const content = raw.message?.content ?? raw.content ?? "";
+  if (typeof content === "string") return content;
+  if (Array.isArray(content)) return content.map(blockText).join("\n");
+  return content === null || content === void 0 ? "" : String(content);
+}
+function entryToolCalls(entry) {
+  const calls = entry.toolCalls;
+  if (!Array.isArray(calls)) return [];
+  return calls.filter((c) => typeof c?.toolName === "string").map((c) => ({ toolName: c.toolName, arguments: c.arguments }));
+}
+function entryToolResults(entry) {
+  const results = entry.toolResults;
+  if (!Array.isArray(results)) return [];
+  return results.map((r) => ({
+    output: toolOutputText(r.output),
+    isError: r.isError
+  }));
+}
+function entryLabel(entry) {
+  const subtype = entry.subtype;
+  return subtype ? `${entry.type}/${subtype}` : entry.type;
+}
+var TERMINAL_SUBTYPES = /* @__PURE__ */ new Set(["task_result" /* TaskResult */, "error" /* Error */]);
+function entryTimestamp(entry) {
+  const e = entry;
+  for (const raw of [e.timestamp, e.endedAt, e.startedAt]) {
+    if (typeof raw === "string") {
+      const ms = Date.parse(raw);
+      if (Number.isFinite(ms)) return ms;
+    }
+  }
+  return null;
+}
+function summarizeTranscript(entries) {
+  let lastActivityAt = null;
+  for (let i = entries.length - 1; i >= 0; i--) {
+    lastActivityAt = entryTimestamp(entries[i]);
+    if (lastActivityAt !== null) break;
+  }
+  let currentTool = null;
+  let terminalSubtype = null;
+  for (let i = entries.length - 1; i >= 0 && (currentTool === null || terminalSubtype === null); i--) {
+    const entry = entries[i];
+    if (currentTool === null) {
+      const calls = entryToolCalls(entry);
+      if (calls.length > 0) currentTool = calls[calls.length - 1].toolName;
+    }
+    if (terminalSubtype === null && entry.type === "system" /* System */ && TERMINAL_SUBTYPES.has(String(entry.subtype))) {
+      terminalSubtype = String(entry.subtype);
+    }
+  }
+  return {
+    totalEntries: entries.length,
+    lastActivityAt,
+    lastEntryType: entries.length > 0 ? entries[entries.length - 1].type : null,
+    currentTool,
+    hasTerminalEntry: terminalSubtype !== null,
+    terminalSubtype
+  };
+}
+function formatDuration(ms) {
+  if (!Number.isFinite(ms)) return "unknown";
+  const abs = Math.max(0, ms);
+  if (abs < 1e3) return `${Math.round(abs)}ms`;
+  if (abs < 6e4) return `${(abs / 1e3).toFixed(1)}s`;
+  if (abs < 36e5) {
+    const m2 = Math.floor(abs / 6e4);
+    const s = Math.floor(abs % 6e4 / 1e3);
+    return `${m2}m ${String(s).padStart(2, "0")}s`;
+  }
+  const h = Math.floor(abs / 36e5);
+  const m = Math.floor(abs % 36e5 / 6e4);
+  return `${h}h ${String(m).padStart(2, "0")}m`;
+}
+function formatLastActivity(lastActivityAt, now) {
+  if (lastActivityAt === null) return "unknown";
+  return `${new Date(lastActivityAt).toISOString()} (${formatDuration(now - lastActivityAt)} ago)`;
+}
+function selectWindow(entries, offset, limit) {
+  const total = entries.length;
+  const safeOffset = Math.max(0, Number.isFinite(offset) ? Math.trunc(offset) : 0);
+  const safeLimit = Math.max(0, Number.isFinite(limit) ? Math.trunc(limit) : 0);
+  const end = Math.max(0, total - safeOffset);
+  const start = safeLimit === 0 ? end : Math.max(0, end - safeLimit);
+  const window = entries.slice(start, end);
+  return {
+    entries: window,
+    totalEntries: total,
+    returnedEntries: window.length,
+    offset: safeOffset,
+    limit: safeLimit,
+    startIndex: window.length > 0 ? start + 1 : 0,
+    endIndex: window.length > 0 ? end : 0,
+    windowTruncated: window.length < total
+  };
+}
+function formatTranscriptEntry(entry, position, opts) {
+  const body = entryText(entry).replace(/\r/g, "");
+  const toolNames = entryToolCalls(entry).map((c) => c.toolName);
+  const toolNote = toolNames.length > 0 ? ` (tools: ${toolNames.join(", ")})` : "";
+  const head = `  #${position} [${entryLabel(entry)}]${toolNote}`;
+  const cap = opts.maxChars;
+  const cut2 = cap !== null && body.length > cap;
+  const shown = cut2 ? body.slice(0, cap) + "\u2026" : body;
+  const marker = cut2 ? ` (truncated: ${cap}/${body.length} chars)` : "";
+  const lines = [];
+  if (shown.length === 0) {
+    lines.push(`${head}${marker} (empty)`);
+  } else if (!shown.includes("\n")) {
+    lines.push(`${head}${marker} ${shown}`);
+  } else {
+    lines.push(`${head}${marker}`);
+    for (const line of shown.split("\n")) lines.push(`      ${line}`);
+  }
+  if (opts.includeToolDetail) {
+    for (const call of entryToolCalls(entry)) {
+      const args = call.arguments ?? "";
+      const argsShown = cap !== null && args.length > cap ? args.slice(0, cap) + "\u2026" : args;
+      lines.push(`      \u21B3 ${call.toolName} ${argsShown}`.trimEnd());
+    }
+    for (const result of entryToolResults(entry)) {
+      const output = result.output ?? "";
+      const outputShown = cap !== null && output.length > cap ? output.slice(0, cap) + "\u2026" : output;
+      lines.push(`      \u21B3 result${result.isError ? " [error]" : ""}: ${outputShown}`.trimEnd());
+    }
+  }
+  return { lines, truncated: cut2, originalChars: body.length };
+}
+function shrinkWindow(win, dropFromStart) {
+  const drop = Math.max(0, Math.min(dropFromStart, win.entries.length));
+  if (drop === 0) return win;
+  const entries = win.entries.slice(drop);
+  return {
+    ...win,
+    entries,
+    returnedEntries: entries.length,
+    startIndex: win.startIndex + drop,
+    windowTruncated: true
+  };
+}
+function renderEntriesFitting(entries, startIndex, opts, budgetChars) {
+  const formatted = entries.map((entry, i) => formatTranscriptEntry(entry, startIndex + i, opts));
+  let used = 0;
+  let first = formatted.length;
+  for (let i = formatted.length - 1; i >= 0; i--) {
+    const size = formatted[i].lines.reduce((n, line) => n + line.length + 1, 0);
+    if (used + size > budgetChars && first < formatted.length) break;
+    used += size;
+    first = i;
+  }
+  const kept = formatted.slice(first);
+  return {
+    lines: kept.flatMap((f) => f.lines),
+    dropped: first,
+    shortened: kept.filter((f) => f.truncated).length
+  };
+}
+function buildWindowMeta(win, opts) {
+  return {
+    totalEntries: win.totalEntries,
+    returnedEntries: win.returnedEntries,
+    offset: win.offset,
+    limit: win.limit,
+    maxChars: opts.maxChars,
+    full: opts.full,
+    truncated: win.windowTruncated || opts.shortenedEntries > 0,
+    windowTruncated: win.windowTruncated,
+    startIndex: win.startIndex,
+    endIndex: win.endIndex,
+    shortenedEntries: opts.shortenedEntries
+  };
+}
+function buildTruncationNotice(meta) {
+  const perEntry = meta.maxChars === null ? "none" : `${meta.maxChars}`;
+  const shortened = meta.shortenedEntries > 0 ? ` (${meta.shortenedEntries} entries shortened)` : "";
+  if (meta.windowTruncated) {
+    const how = meta.full ? "output cap reached \u2014 page further back with offset" : "pass offset/limit or full=true";
+    return `[truncated: showing ${meta.returnedEntries} of ${meta.totalEntries} entries (${meta.startIndex}-${meta.endIndex}), per-entry limit ${perEntry} chars${shortened}; ${how}]`;
+  }
+  if (meta.shortenedEntries > 0) {
+    return `[truncated: showing all ${meta.totalEntries} entries, per-entry limit ${perEntry} chars${shortened}; pass full=true for complete content]`;
+  }
+  return null;
+}
+function buildTranscriptHeader(meta) {
+  if (meta.totalEntries === 0) return "Conversation (0 entries):";
+  if (!meta.windowTruncated) return `Conversation (${meta.totalEntries} entries):`;
+  return `Conversation (${meta.totalEntries} entries total, showing ${meta.startIndex}-${meta.endIndex} by offset=${meta.offset} limit=${meta.limit}):`;
+}
+
+// src/services/task/task-pool-state.ts
+import { join as join8 } from "path";
+var TaskPoolState = class extends BaseWayangState {
+  jsonFile;
+  logger;
+  constructor(ctx) {
+    const jsonFile = new JSONFileHelper(join8(ctx.sessionDir, "tasks.json"));
+    super(
+      {
+        tasks: {
+          pending: [],
+          running: [],
+          history: []
+        }
+      },
+      [{ path: "tasks", helper: jsonFile }]
+    );
+    this.jsonFile = jsonFile;
+    this.logger = ctx.logger;
+  }
+  async restore() {
+    const data = this.jsonFile.read();
+    if (data) {
+      this.data.tasks = data;
+    }
+    this.logger.info("TaskPoolState restored");
+  }
+};
+
+// src/services/agents/base-agent.ts
+import { streamText, stepCountIs, hasToolCall } from "ai";
+
+// src/services/agents/model-factory.ts
+import { createOpenAICompatible } from "@ai-sdk/openai-compatible";
+function createModel(provider) {
+  const compatible = createOpenAICompatible({
+    name: "wayang",
+    baseURL: provider.endpoint,
+    apiKey: provider.apiKey
+  });
+  return compatible.chatModel(provider.modelName);
+}
+
+// src/services/agents/base-agent.ts
+var DEFAULT_LLM_IDLE_TIMEOUT_MS = 3e5;
+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;
+    const idleTimeoutMs = opts.llmIdleTimeoutMs ?? DEFAULT_LLM_IDLE_TIMEOUT_MS;
+    const callAbort = new AbortController();
+    const forwardAbort = () => callAbort.abort();
+    if (this.abortController.signal.aborted) {
+      callAbort.abort();
+    } else {
+      this.abortController.signal.addEventListener("abort", forwardAbort);
+    }
+    let watchdog = null;
+    let timedOut = false;
+    let toolsInFlight = 0;
+    let finished = false;
+    const clearWatchdog = () => {
+      if (watchdog !== null) {
+        clearTimeout(watchdog);
+        watchdog = null;
+      }
+    };
+    const armWatchdog = () => {
+      if (idleTimeoutMs <= 0 || finished || toolsInFlight > 0) return;
+      clearWatchdog();
+      watchdog = setTimeout(() => {
+        timedOut = true;
+        callAbort.abort();
+      }, idleTimeoutMs);
+    };
+    const tools = pauseWatchdogDuringTools(
+      opts.tools,
+      () => {
+        toolsInFlight++;
+        clearWatchdog();
+      },
+      () => {
+        toolsInFlight--;
+        if (toolsInFlight === 0) armWatchdog();
+      }
+    );
+    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;
+    let firstChunkAt;
+    let stepStartedAt;
+    const onStep = opts.onStep ? (event) => {
+      armWatchdog();
+      const meta = { startedAt: stepStartedAt, firstTokenAt: firstChunkAt };
+      firstChunkAt = void 0;
+      stepStartedAt = nowISO();
+      opts.onStep(event, meta);
+    } : void 0;
+    try {
+      this.hooks.beforeLLM?.({ messageCount: opts.messages.length, messages: opts.messages });
+      startTime = Date.now();
+      stepStartedAt = nowISO();
+      armWatchdog();
+      stream = streamText({
+        model: this.model,
+        system: opts.system,
+        messages: opts.messages,
+        tools,
+        toolChoice: opts.toolChoice,
+        stopWhen: stopConditions.length > 0 ? stopConditions : void 0,
+        abortSignal: callAbort.signal,
+        ...opts.prepareStep && { prepareStep: opts.prepareStep },
+        onStepFinish: onStep,
+        onError: ({ error }) => {
+          opts.onStreamError?.(error);
+        },
+        // SignalEntry entries are trusted system-generated notifications emitted
+        // as `system`-role messages (in-band, order-sensitive). AI SDK v6 warns
+        // on any system message inside `messages` unless this is opted in.
+        allowSystemInMessages: true
+      });
+    } catch (err) {
+      finished = true;
+      clearWatchdog();
+      this.abortController.signal.removeEventListener("abort", forwardAbort);
+      if (this.abortController.signal.aborted) {
+        return { text: "", toolResults: [], usage: void 0 };
+      }
+      throw err;
+    }
+    try {
+      for await (const chunk of stream.textStream) {
+        armWatchdog();
+        if (chunk && firstChunkAt === void 0) firstChunkAt = nowISO();
+        yield chunk;
+      }
+    } catch (err) {
+      if (this.abortController.signal.aborted) {
+        return { text: "", toolResults: [], usage: void 0 };
+      }
+      if (timedOut) {
+        throw new Error(
+          `LLM call idle timeout: no stream progress (text chunk or step finish) for ${idleTimeoutMs}ms`
+        );
+      }
+      if (this.abortController.signal.aborted) {
+        return { text: "", toolResults: [], usage: void 0 };
+      }
+      throw err;
+    } finally {
+      finished = true;
+      clearWatchdog();
+      this.abortController.signal.removeEventListener("abort", forwardAbort);
+    }
+    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 finishReason = await stream.finishReason;
+    const steps = await stream.steps;
+    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,
+      finishReason,
+      steps: steps?.length
+    };
   }
-  /**
-   * 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, getSystemPrompt() carries the summary and getMessages() returns only the entries appended after the marker.
-   *
-   * @param meta Optional provenance recorded on the marker (model name).
-   */
-  async compact(summarizer, meta) {
-    const conversation = this.state.get("conversation");
-    if (conversation.length < 4) return;
-    const fromEntryId = conversation[0]?.uuid;
-    const toEntryId = conversation[conversation.length - 1]?.uuid;
-    const summary = await summarizer(conversation);
-    this.compactSummary = summary;
-    this.compactStartIdx = conversation.length;
-    this.lastReportedTokens = null;
-    const markerTs = nowISO();
-    this.state.append("conversation", {
-      type: "system" /* System */,
-      uuid: generateId("compact"),
-      parentUuid: null,
-      sessionId: this.state.get("runtimeState.session.id") ?? "",
-      timestamp: markerTs,
-      subtype: "compact" /* Compact */,
-      content: summary,
-      // System entries are point-in-time events: startedAt/endedAt share the
-      // marker's creation moment.
-      startedAt: markerTs,
-      endedAt: markerTs,
-      compactMeta: {
-        summarizedTokenCount: estimateConversationTokens(conversation),
-        ...fromEntryId !== void 0 && { fromEntryId },
-        ...toEntryId !== void 0 && { toEntryId },
-        ...meta?.model !== void 0 && { model: meta.model },
-        createdAt: markerTs
+  /** 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;
   }
-};
-
-// src/services/agents/worker-state.ts
-import { join as join7 } from "path";
-var WorkerState = class extends BaseWayangState {
-  constructor(sessionDir, workerId, logger) {
-    const workerDir = join7(sessionDir, "workers", workerId);
-    const jsonFile = new JSONFileHelper(join7(workerDir, "runtime-state.json"));
-    const jsonlFile = new JSONLFileHelper(join7(workerDir, "conversation.jsonl"));
-    const initialData = {
-      runtimeState: {
-        session: { id: workerId, startedAt: Date.now() },
-        task: { id: "", description: "" }
-      },
-      conversation: [],
-      inbox: []
-    };
-    super(initialData, [
-      { path: "runtimeState", helper: jsonFile },
-      { path: "conversation", helper: jsonlFile }
-    ]);
-    this.logger = logger;
-    this.jsonFile = jsonFile;
-    this.jsonlFile = jsonlFile;
+  abort() {
+    this.abortController.abort();
   }
-  logger;
-  jsonFile;
-  jsonlFile;
-  async restore() {
-    const runtimeState = this.jsonFile.read();
-    if (runtimeState) {
-      this.data.runtimeState = runtimeState;
+};
+function pauseWatchdogDuringTools(tools, onStart, onEnd) {
+  const wrapped = {};
+  for (const [name, def] of Object.entries(tools ?? {})) {
+    const original = def?.execute;
+    if (typeof original !== "function") {
+      wrapped[name] = def;
+      continue;
     }
-    const allEntries = this.jsonlFile.read();
-    const compactIdx = allEntries.findLastIndex(isCompactMarker);
-    if (compactIdx === -1) {
-      if (allEntries.length > 0) {
-        this.data.conversation = allEntries;
-      }
-    } else {
-      let budget = RECENT_TOKEN_BUDGET;
-      let cutIdx = 0;
-      for (let i = compactIdx - 1; i >= 0; i--) {
-        budget -= estimateEntryTokens(allEntries[i]);
-        if (budget <= 0) {
-          cutIdx = i + 1;
-          break;
+    wrapped[name] = {
+      ...def,
+      execute: async (...args) => {
+        onStart();
+        try {
+          return await original(...args);
+        } finally {
+          onEnd();
         }
       }
-      this.data.conversation = allEntries.slice(cutIdx);
-    }
-    this.logger.info("WorkerState restored");
+    };
   }
-};
+  return wrapped;
+}
 
 // src/services/agents/utils/build-assistant-entry.ts
 function buildAssistantEntry(event, sessionId, uuid, extras) {
@@ -4537,18 +5266,39 @@ function controllerMessageContent(content) {
   return `[Controller message] ${content}`;
 }
 function createInboxInjection(deps) {
+  let baseLength = null;
   const injected = [];
   return {
     prepareStep({ messages }) {
       const fresh = deps.drainInbox();
       if (fresh.length === 0 && injected.length === 0) return void 0;
+      if (baseLength === null) baseLength = messages.length;
+      const responseCount = Math.max(0, messages.length - baseLength);
       for (const m of fresh) {
-        injected.push({ role: "user", content: controllerMessageContent(m.content) });
+        injected.push({
+          message: { role: "user", content: controllerMessageContent(m.content) },
+          // After the response messages that exist NOW — i.e. at the tail of
+          // the conversation as this step sees it, before this step's reply.
+          insertAfter: responseCount
+        });
         deps.onInject(m.content);
       }
-      return { messages: [...messages, ...injected] };
+      const merged = messages.slice(0, baseLength);
+      let cursor = 0;
+      for (const inj of injected) {
+        while (cursor < Math.min(inj.insertAfter, responseCount)) {
+          merged.push(messages[baseLength + cursor]);
+          cursor++;
+        }
+        merged.push(inj.message);
+      }
+      while (cursor < responseCount) {
+        merged.push(messages[baseLength + cursor]);
+        cursor++;
+      }
+      return { messages: merged };
     },
-    injectedMessages: () => [...injected]
+    injectedMessages: () => injected.map((i) => i.message)
   };
 }
 
@@ -4566,15 +5316,16 @@ function isInsideWorkspace(resolved, workspace) {
   const rel = relative(workspace, resolved);
   return !rel.startsWith("..") && resolve(workspace, rel) === resolved;
 }
-function truncate(result) {
-  if (result.length <= MAX_RESULT_CHARS) return result;
-  return result.slice(0, MAX_RESULT_CHARS) + "\n...(truncated)";
+function truncate(result, maxChars = MAX_RESULT_CHARS) {
+  if (result.length <= maxChars) return result;
+  return result.slice(0, maxChars) + "\n...(truncated)";
 }
-function safeExecute(name, fn) {
-  return async (args, options) => {
+function safeExecute(name, fn, options) {
+  const maxChars = options?.maxResultChars ?? MAX_RESULT_CHARS;
+  return async (args, callOptions) => {
     try {
-      const result = await fn(args, options);
-      return truncate(typeof result === "string" ? result : JSON.stringify(result));
+      const result = await fn(args, callOptions);
+      return truncate(typeof result === "string" ? result : JSON.stringify(result), maxChars);
     } catch (err) {
       return `[ERROR] ${name}: ${err.message ?? String(err)}`;
     }
@@ -4728,12 +5479,12 @@ 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)
+5. Acceptance criteria \u2014 what counts as done
 
 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."
@@ -4799,11 +5550,37 @@ Use get_task_detail when you need more information about a specific task:
 - You need to understand what a worker actually did before deciding next steps
 - Checking the error details of a failed task before retrying
 
-The tool shows task metadata (status, result, error) and recent worker conversation entries (tool calls and outputs).
+The tool shows task metadata (status, result, error) and the worker conversation. The conversation comes from the worker's live in-memory state while it runs, and from its on-disk transcript after the worker ended (marked [from transcript]). The conversation is paginated and ALWAYS says what was cut:
+- Pagination semantics: \`offset\` skips N entries counted back from the newest; output is ordered oldest\u2192newest; type filtering is applied BEFORE pagination.
+- \`limit\` (default 10, counted back from the newest), \`offset\` (default 0, skip the newest N), \`maxChars\` (per-entry cap, default 200), \`full=true\` (complete text, all entries).
+- A meta line reports \`totalEntries / returnedEntries / offset / truncated\`; a \`[truncated: ...]\` line appears whenever anything was cut, and each cut entry carries \`(truncated: 200/4642 chars)\`.
+- NEVER conclude that a worker "stopped mid-sentence" from a truncated entry. If an entry is marked truncated, re-read it with full=true (or page back with offset) before judging.
+
+## Reading a worker's full transcript (read_worker_conversation)
+
+read_worker_conversation(workerId, limit?, offset?, maxChars?, full?, type?) reads a worker's conversation with a layered source: while the engine still tracks the worker (running or idle), its live in-memory conversation is returned (meta \`source="memory"\`); after the worker finished/failed/was cancelled or disposed, its append-only on-disk \`conversation.jsonl\` is read instead (meta \`source="disk"\`). So it works for running AND already-finished workers, including after cancel_task.
+- Pagination semantics: \`offset\` skips N entries counted back from the newest; output is ordered oldest\u2192newest; type filtering is applied BEFORE pagination.
+- Same per-entry truncation markers as get_task_detail; entries print in chronological order.
+- \`type\` filters: user / assistant / system / signal / tool ("tool" = assistant entries that made tool calls).
+- A \`[note: last entry is incomplete \u2014 the transcript is still being written]\` line means the newest entry was mid-append when you read it: re-read in a moment instead of treating the tail as the final state. \`readWindowTruncated\` in the meta means older entries exist beyond the read window's byte cap \u2014 page back with offset.
+- Use it to see what a worker actually produced before you report, retry, or cancel.
+
+## Checking whether a worker is alive (get_worker_status)
+
+get_worker_status(workerId?) \u2014 with an id returns that worker's status object, without one returns all current workers.
+Fields: workerId, type, taskId, status, runningForMs, lastActivityAt (epoch ms of the newest transcript entry) with lastActivityAgoMs (how long ago that was), currentTool, streamEnded, resultReceived, idleSince.
+Use it to tell "still working" from "stuck / already finished but not released":
+- Many minutes without a new transcript entry and no current tool \u2192 likely stuck: inspect with read_worker_conversation, then cancel_task.
+- resultReceived=true but streamEnded=false / status still running \u2192 the worker is in its wrap-up; wait or inspect instead of cancelling.
+- Unknown worker ids return a not-found message (never an exception).
 
 ## Sending messages to workers (chat_worker)
 
-Use chat_worker(workerId, message) to send guidance to a running worker. The worker will see the message next time it calls check_controller_messages.
+Use chat_worker(workerId, message) to send guidance to a running worker.
+The worker reads it at its next step (puppet) or turn boundary (third-party) \u2014 a tool call in progress is NEVER interrupted; an idle multi-stage worker reads it when its next stage starts.
+Delivery is blind: "queued" only means the message sits in the worker's inbox until that boundary. A stuck worker never reads it.
+A third-party worker that already finished its session rejects the message with an explicit [ERROR] \u2014 inspect its output instead of retrying.
+Before chatting, check get_worker_status; if the worker is stuck, cancel_task is the honest action (a queued message will not revive it).
 Use sparingly \u2014 only when you need to:
 - Correct a worker that is going in the wrong direction
 - Provide additional context the worker did not have
@@ -4840,7 +5617,8 @@ Types:
 Guidelines:
 - Prefer confirm and select over text. Less typing = better experience.
 - Keep messages short and specific.
-- For select, provide 2-5 clear options. Not too many.`
+- For select, provide 2-5 clear preset options \u2014 an "Other" choice is appended automatically so the user can always type a custom answer, so never add your own catch-all option. Custom answers come back prefixed with "[Other] ".
+- Set allowOther=false only when the answer must be one of the preset options.`
 );
 var SIGNAL_HANDLING = section(
   "Handling signals",
@@ -4876,8 +5654,9 @@ Explain the error. Suggest a retry or alternative.
 ## [HEARTBEAT] \u2014 periodic check-in while workers are running
 
 You were woken up because workers are running but no events arrived for a while.
-Review the worker status in the heartbeat message:
-- A worker has been running unusually long \u2192 inform the user proactively
+Review the worker status in the heartbeat message (runningForMs, last activity, current tool):
+- A worker has been running unusually long AND its last activity is old (or it shows no tool) \u2192 inspect it: get_worker_status then read_worker_conversation. If it is genuinely stuck, cancel_task and report honestly.
+- A worker has been running unusually long but activity is recent \u2192 inform the user proactively
 - Everything looks normal \u2192 call skip_reply()
 
 ## [PERMISSION REQUEST ...] \u2014 worker needs approval
@@ -4900,6 +5679,39 @@ You resumed a previous session that had unfinished tasks. Workers were NOT autom
 
 Do NOT blindly re-create everything. The user may have moved on. Prefer to summarize and ask unless the intent is obvious.`
 );
+var WORKING_PRINCIPLES = section(
+  "Working principles",
+  `\u3010\u4EFB\u52A1\u62C6\u5206\u3011
+- \u4E00\u4E2A\u4EFB\u52A1\u53EA\u4EA4\u4ED8\u4E00\u4E2A\u53EF\u72EC\u7ACB\u9A8C\u6536\u7684\u7ED3\u679C\uFF1B\u4E0D\u8981\u628A\u8BBE\u8BA1\u3001\u5B9E\u73B0\u3001\u6D4B\u8BD5\u585E\u8FDB\u540C\u4E00\u6BB5\u3002
+- \u5148\u505A\u80FD\u88AB\u5355\u6D4B\u65AD\u8A00\u7684\u6838\u5FC3\u903B\u8F91\uFF0C\u628A\u8FB9\u754C\uFF08\u5BBD\u5B57\u7B26\u3001\u4EE3\u7406\u5BF9\u3001\u6298\u884C\u4F4D\u7F6E\u4E4B\u7C7B\uFF09\u56FA\u5316\u6210\u7528\u4F8B\uFF0C\u518D\u53E0\u52A0\u96C6\u6210\u4E0E\u4EA4\u4E92\u5C42\u3002
+- \u4EFB\u52A1\u63CF\u8FF0\u5FC5\u987B\u81EA\u5305\u542B\uFF1A\u80CC\u666F\u3001\u76EE\u6807\u3001\u8F93\u5165\u8F93\u51FA\u3001\u7EA6\u675F\u3001\u9A8C\u6536\u6807\u51C6\u3002\u6267\u884C\u65B9\u770B\u4E0D\u5230\u4F60\u7684\u5BF9\u8BDD\u3002
+
+\u3010\u5206\u5DE5\u4E0E\u5BA1\u6838\u3011
+- \u8BBE\u8BA1\u5224\u65AD\u4E0E\u673A\u68B0\u5B9E\u73B0\u5206\u5F00\u6D3E\uFF1A\u8BBE\u8BA1\u65B9\u5148\u5B9E\u6D4B\u5173\u952E\u884C\u4E3A\uFF0C\u4EA7\u51FA\u300C\u6539\u54EA\u4E2A\u6587\u4EF6\u3001\u51FD\u6570\u7B7E\u540D\u3001\u6570\u636E\u7ED3\u6784\u3001\u8FB9\u754C\u60C5\u51B5\u3001\u6D4B\u8BD5\u6E05\u5355\u300D\u7684\u65B9\u6848\uFF1B\u6267\u884C\u65B9\u7167\u65B9\u6848\u7F16\u7801\uFF0C\u4E0D\u505A\u8BBE\u8BA1\u51B3\u7B56\u3002
+- \u65B9\u6848\u91CC\u8981\u663E\u5F0F\u5199\u51FA\u300C\u4E0D\u8981\u505A\u4EC0\u4E48\u300D\uFF0C\u5426\u5219\u6267\u884C\u65B9\u4F1A\u987A\u624B\u91CD\u6784\u65E0\u5173\u4EE3\u7801\u3002
+- \u5B9E\u73B0\u5B8C\u6210\u540E\u8BA9\u8BBE\u8BA1\u65B9\u56DE\u5BA1\uFF0C\u53EA\u67E5 diff\u3001\u4E0D\u53D8\u91CF\u4E0E\u56DE\u5F52\uFF0C\u4E0D\u63D0\u98CE\u683C\u504F\u597D\u3002
+
+\u3010\u5E76\u884C\u3011
+- \u53EA\u6709\u72EC\u7ACB\u5DE5\u4F5C\u533A\u624D\u80FD\u5E76\u884C\uFF1B\u540C\u4E00\u5DE5\u4F5C\u533A\u5185\u7684\u5199\u5165\u4E0E\u63D0\u4EA4\u5FC5\u987B\u4E32\u884C\u3002
+- \u8DE8\u53D8\u4F53\u642C\u8FD0\u6539\u52A8\u65F6\u53EA\u642C\u6539\u52A8\u672C\u8EAB\uFF1A\u5265\u79BB\u6765\u6E90\u5206\u652F\u7684\u9644\u5E26\u4F9D\u8D56\uFF0C\u5408\u6D41\u4EE5\u76EE\u6807\u57FA\u5EA7\u7684\u8BED\u4E49\u4E3A\u51C6\u3002
+
+\u3010\u5224\u65AD\u4E0E\u5904\u7F6E\u3011
+- \u4E0D\u8981\u51ED\u300C\u6CA1\u6709\u65B0\u8F93\u51FA\u300D\u5224\u65AD\u6B7B\u6D3B\u3002\u5148\u53D6\u8BC1\uFF1A\u6267\u884C\u75D5\u8FF9\u6700\u540E\u4E00\u6761\u662F\u4EC0\u4E48\u3001\u6709\u6CA1\u6709\u60AC\u7A7A\u7684\u8C03\u7528\u3001\u8D44\u6E90\u5360\u7528\u662F\u5426\u5728\u589E\u957F\uFF0C\u518D\u51B3\u5B9A\u7B49\u5F85\u3001\u62C6\u5C0F\u91CD\u6D3E\u8FD8\u662F\u53D6\u6D88\u3002
+- \u5DF2\u7ECF\u9677\u5165\u5FAA\u73AF\u7684\uFF08\u53CD\u590D\u88AB max_tokens \u622A\u65AD\u3001\u957F\u65F6\u95F4\u65E0\u4EA7\u51FA\uFF09\u7B49\u4E0D\u51FA\u6765\uFF0C\u53CA\u65F6\u62C6\u5C0F\u6216\u6362\u7B56\u7565\u3002
+- \u8FD0\u884C\u65F6\u7684\u4EA4\u4E92\u8BED\u4E49\u662F\u7248\u672C\u76F8\u5173\u7684\uFF08\u4F8B\u5982\u4E2D\u9014\u6D88\u606F\u662F\u6253\u65AD\u5F53\u524D\u56DE\u5408\u8FD8\u662F\u5728\u8FB9\u754C\u4EA4\u4ED8\uFF09\uFF0C\u4F9D\u8D56\u524D\u5148\u5728\u5F53\u524D\u7248\u672C\u5B9E\u6D4B\u3002
+
+\u3010\u9A8C\u8BC1\u3011
+- \u6BCF\u6B21\u6539\u52A8\u8DD1\u540C\u4E00\u5957\u95E8\u69DB\uFF08\u7C7B\u578B\u68C0\u67E5\u3001lint\u3001\u6D4B\u8BD5\u3001\u6784\u5EFA\uFF09\uFF0C\u8303\u56F4\u968F\u5F71\u54CD\u9762\u4F38\u7F29\uFF1A\u5C0F\u6539\u8DD1\u76F8\u5173\u5B50\u96C6\uFF0C\u5927\u6539\u8DD1\u5168\u91CF\u3002
+- \u91CD\u6392\u5386\u53F2\u3001\u8DE8\u5206\u652F\u642C\u8FD0\u540E\uFF0C\u7528\u7B26\u53F7\u68C0\u7D22\u4E0E tree hash \u8FD9\u7C7B\u673A\u68B0\u8BC1\u636E\u9A8C\u8BC1\u7B49\u4EF7\uFF0C\u4E0D\u8981\u8089\u773C\u590D\u67E5\u3002
+- \u4EA4\u4E92\u7C7B\u6539\u52A8\u8981\u6709\u4E00\u6B21\u771F\u5B9E\u8FD0\u884C\u7684\u7AEF\u5230\u7AEF\u590D\u6F14\uFF1B\u5355\u6D4B\u5168\u7EFF\u4E0D\u7B49\u4E8E\u5B8C\u6210\u3002
+
+\u3010\u9519\u8BEF\u6A21\u5F0F\u3011
+- \u6DF7\u6742\u6D3E\u5DE5 \u2014\u2014 \u628A\u8BBE\u8BA1\u3001\u5B9E\u73B0\u3001\u6D4B\u8BD5\u585E\u8FDB\u4E00\u4E2A\u4EFB\u52A1\uFF0C\u7ED3\u679C\u957F\u65F6\u95F4\u7A7A\u8F6C\u3001\u6700\u7EC8\u4EA4\u4ED8\u4E3A\u7A7A\u3002
+- \u540C\u533A\u4E92\u5377 \u2014\u2014 \u8BA9\u4E24\u4E2A\u6267\u884C\u8005\u5728\u540C\u4E00\u5DE5\u4F5C\u533A\u5E76\u53D1\u63D0\u4EA4\uFF0C\u4E92\u76F8\u628A\u5BF9\u65B9\u7684\u6539\u52A8\u5377\u8FDB\u81EA\u5DF1\u7684 commit\u3002
+- \u9759\u9ED8\u5224\u6B7B \u2014\u2014 \u51ED\u8F93\u51FA\u9759\u9ED8\u5224\u65AD\u6B7B\u6D3B\uFF1A\u628A\u5728\u8DD1\u957F\u4EFB\u52A1\u5F53\u6210\u5361\u6B7B\u6740\u6389\uFF0C\u6216\u628A\u6D3B\u9501\u5F53\u6210\u6162\u4EFB\u52A1\u6B7B\u7B49\u3002
+- \u7EFF\u706F\u5373\u5B8C\u6210 \u2014\u2014 \u5355\u6D4B\u6216\u6D41\u7A0B\u5168\u7EFF\u5C31\u5BA3\u5E03\u5B8C\u6210\uFF1B\u5076\u53D1\u5931\u8D25\u590D\u8DD1\u4E00\u6B21\u901A\u8FC7\u5C31\u5F53\u6CA1\u53D1\u751F\uFF0C\u4E0D\u505A\u8BB0\u5F55\u3002
+- \u96F6\u788E\u53D6\u8BC1 \u2014\u2014 \u628A\u4E00\u6B21\u53D6\u8BC1\u62C6\u6210\u51E0\u5341\u6761\u96F6\u788E\u53EA\u8BFB\u547D\u4EE4\u9010\u6761\u7B49\u6279\u51C6\uFF0C\u6392\u969C\u88AB\u6D41\u7A0B\u672C\u8EAB\u62D6\u6B7B\u3002`
+);
 var HARD_CONSTRAINTS = section(
   "Hard constraints",
   `- NEVER execute commands or write files yourself. Delegate via add_task\uFF08worker will execute\uFF09.
@@ -4925,6 +5737,7 @@ function buildControllerSystemPrompt(ctx, skills) {
     TOOL_USAGE,
     PLANNING_TOOLS,
     SIGNAL_HANDLING,
+    WORKING_PRINCIPLES,
     HARD_CONSTRAINTS,
     buildWorkerList(ctx.config.workers),
     buildSkillCatalog(skills),
@@ -4932,6 +5745,54 @@ function buildControllerSystemPrompt(ctx, skills) {
   );
 }
 
+// src/services/agents/prompts/project-rules.ts
+import { existsSync as existsSync6, readFileSync as readFileSync6, statSync as statSync2 } from "fs";
+import { basename as basename2, dirname as dirname4, join as join9, resolve as resolve2 } from "path";
+var RULE_FILE_NAMES = ["AGENTS.md", "CLAUDE.md"];
+var MAX_LEVELS = 5;
+var PROJECT_RULES_MAX_LENGTH = 8e3;
+function findProjectRules(startDir) {
+  let current = resolve2(startDir);
+  for (let level = 0; level < MAX_LEVELS; level++) {
+    const found = readRuleFile(current);
+    if (found) return found;
+    if (existsSync6(join9(current, ".git"))) break;
+    const parent = dirname4(current);
+    if (parent === current) break;
+    current = parent;
+  }
+  return null;
+}
+function readRuleFile(dir) {
+  for (const name of RULE_FILE_NAMES) {
+    const path7 = join9(dir, name);
+    try {
+      if (!statSync2(path7).isFile()) continue;
+      const content = readFileSync6(path7, "utf8");
+      if (!content.trim()) continue;
+      return { path: path7, content };
+    } catch {
+    }
+  }
+  return null;
+}
+function buildProjectRulesSection(rules) {
+  if (!rules) return "";
+  const name = basename2(rules.path);
+  const truncated = rules.content.length > PROJECT_RULES_MAX_LENGTH;
+  const content = truncated ? `${rules.content.slice(0, PROJECT_RULES_MAX_LENGTH).trimEnd()}
+
+...truncated (rules file exceeded ${PROJECT_RULES_MAX_LENGTH} characters)` : rules.content.trimEnd();
+  return section(
+    `Project rules (${name})`,
+    `Rules from this project's ${name}. They apply to all work on the task \u2014 follow them unless the task description explicitly overrides them.
+
+Source: ${rules.path}
+
+${content}`
+  );
+}
+
 // src/services/agents/prompts/worker-prompt.ts
 var IDENTITY2 = section(
   "Identity",
@@ -5083,6 +5944,10 @@ function buildWorkerSystemPrompt(ctx, skills) {
     TOOL_USAGE2,
     EXECUTION_STRATEGY,
     PROJECT_CONVENTIONS,
+    // Project rules discovered near the task workspace (AGENTS.md, falling
+    // back to CLAUDE.md). Empty when no rules file exists — assemble() drops
+    // the section, so no empty paragraph leaks into the prompt.
+    buildProjectRulesSection(findProjectRules(ctx.workspaceDir ?? process.cwd())),
     QUALITY_RULES,
     HARD_CONSTRAINTS2,
     CONTROLLER_COMMUNICATION,
@@ -5261,6 +6126,15 @@ var WorkerAgent = class extends BaseAgent {
   getState() {
     return this.state;
   }
+  /**
+   * Live run flags (issue #16). A puppet worker has no SDK result/stream
+   * concept: `resultReceived` means the model already called done/fail, and
+   * `streamEnded` is not tracked (null), so status readers fall back to the
+   * transcript / task state instead of guessing.
+   */
+  getLiveStatus() {
+    return { resultReceived: this._terminalResult !== null, streamEnded: null };
+  }
   /** Get conversation entries. */
   getConversation() {
     return this.state.get("conversation") ?? [];
@@ -5272,7 +6146,11 @@ var WorkerAgent = class extends BaseAgent {
   getSnapshot(path7) {
     return this.state.get(path7);
   }
-  /** Accept a message from the controller — writes to internal inbox. */
+  /**
+   * Accept a message from the controller — writes to internal inbox. The
+   * puppet reads it at its next LLM step, so a running (or idle) worker
+   * always accepts.
+   */
   acceptMessage(message) {
     this.state.append("inbox", {
       id: generateId("msg"),
@@ -5280,6 +6158,7 @@ var WorkerAgent = class extends BaseAgent {
       timestamp: Date.now()
     });
     this.logger.info({ workerId: this.id }, "Controller message accepted");
+    return true;
   }
   /** Unread controller messages (non-destructive) — engine reports these when the run ends. */
   pendingMessages() {
@@ -5312,11 +6191,61 @@ var WorkerAgent = class extends BaseAgent {
       message: { role: "user", content: controllerMessageContent(content) }
     }, turnEnv));
   }
-};
-
-// src/services/agents/claude-code-worker.ts
-import { query, createSdkMcpServer } from "@anthropic-ai/claude-agent-sdk";
-import { z as z2 } from "zod";
+};
+
+// src/services/agents/claude-code-worker.ts
+import { query, createSdkMcpServer } from "@anthropic-ai/claude-agent-sdk";
+import { z as z2 } from "zod";
+
+// src/services/agents/utils/claude-tool-records.ts
+var CLAUDE_TOOL_RESULT_STORE_CHARS = 2e3;
+var CLAUDE_TOOL_ARGS_STORE_CHARS = 8e3;
+function truncateForStorage(text, maxChars) {
+  if (text.length <= maxChars) return text;
+  return `${text.slice(0, maxChars)}... [truncated, ${text.length} chars]`;
+}
+function toolUseBlockToRecord(block, startedAt) {
+  return {
+    toolCallId: block.id,
+    toolName: block.name,
+    arguments: truncateForStorage(toolPayloadText(block.input) || "{}", CLAUDE_TOOL_ARGS_STORE_CHARS),
+    status: "running",
+    startedAt
+  };
+}
+function flattenToolResultContent(content) {
+  if (content === void 0 || content === null) return "";
+  if (typeof content === "string") return content;
+  if (!Array.isArray(content)) return toolPayloadText(content);
+  const parts = [];
+  for (const block of content) {
+    if (block && typeof block === "object" && "type" in block) {
+      const b = block;
+      if (b.type === "text" && typeof b.text === "string") {
+        parts.push(b.text);
+      } else {
+        parts.push(`[${String(b.type)} block]`);
+      }
+    } else if (typeof block === "string") {
+      parts.push(block);
+    }
+  }
+  return parts.join("\n");
+}
+function toolResultBlockToRecord(block, toolName, endedAt) {
+  const isError = block.is_error === true;
+  return {
+    toolCallId: block.tool_use_id,
+    toolName,
+    output: {
+      type: "text",
+      value: truncateForStorage(flattenToolResultContent(block.content), CLAUDE_TOOL_RESULT_STORE_CHARS)
+    },
+    ...isError && { isError: true, errorType: "ToolError" },
+    status: isError ? "failed" : "succeeded",
+    endedAt
+  };
+}
 
 // src/infra/blocking-requests.ts
 var BlockingRequestMap = class {
@@ -5329,14 +6258,14 @@ var BlockingRequestMap = class {
     if (this.pending.has(id)) {
       throw new Error(`BlockingRequestMap: duplicate wait id "${id}"`);
     }
-    return new Promise((resolve11) => {
+    return new Promise((resolve12) => {
       const settle = (value) => {
         this.pending.delete(id);
-        resolve11(value);
+        resolve12(value);
       };
       const timer = setTimeout(() => {
         this.pending.delete(id);
-        resolve11(makeTimeoutValue());
+        resolve12(makeTimeoutValue());
       }, timeoutMs);
       if (typeof timer === "object" && timer && "unref" in timer) {
         timer.unref();
@@ -5373,17 +6302,35 @@ var ClaudeCodeWorker = class _ClaudeCodeWorker {
   logger;
   abortController = new AbortController();
   _terminalResult = null;
+  /** True once the SDK message stream of the current run has closed (issue #16). */
+  _streamEnded = false;
   // --- Controller messaging via streamInput ---
   _messageQueue = [];
   _messageResolve = null;
-  /** Active SDK query — interrupted to deliver controller messages promptly. */
-  _activeQuery = null;
   /**
-   * Interrupt requested while a permission was pending — delivered right
-   * after the permission settles (interrupting mid-permission is unproven
-   * SDK territory; see docs/develop/v0.6-design.md §3).
+   * True while run() is executing. Controller messages are rejected once the
+   * run's input has closed (see `_inputClosed`), but idle multi-stage workers
+   * (no run in flight) keep accepting — the next stage folds them into its
+   * opening prompt.
+   */
+  _runInFlight = false;
+  /**
+   * True once the prompt iterator reported done for the current run: the
+   * session can no longer take input (a turn result arrived with nothing
+   * queued, or the run was aborted). Further acceptMessage calls fail
+   * explicitly instead of pretending to queue.
+   */
+  _inputClosed = false;
+  // --- Tool-call recording (see utils/claude-tool-records.ts) ---
+  /**
+   * Assistant steps buffered while their tool results are still in flight.
+   * The SDK stream splits one LLM step across two messages (assistant
+   * tool_use → user tool_result), but the schema stores a step atomically on
+   * one AssistantEntry and storage is append-only — so the entry waits in
+   * memory until its results arrive (or the stream ends). FIFO order is kept:
+   * only the head is flushed, so the file order always matches arrival order.
    */
-  _interruptQueued = false;
+  _pendingToolSteps = [];
   // --- ask_controller via in-process SDK MCP server ---
   _askController = null;
   // --- Permission control via canUseTool ---
@@ -5392,31 +6339,17 @@ var ClaudeCodeWorker = class _ClaudeCodeWorker {
   /** Exposed for engine to resolve pending permission requests. */
   permissionHandler = {
     resolvePermission: (requestId, approved, reason) => {
-      const ok = this._pendingPermissions.resolve(
+      return this._pendingPermissions.resolve(
         requestId,
         approved ? { behavior: "allow" } : { behavior: "deny", message: reason ?? "Denied by controller" }
       );
-      if (ok) this.afterPermissionSettled();
-      return ok;
     },
     cleanup: () => {
-      this._interruptQueued = false;
       this._pendingPermissions.cleanupAll(() => ({ behavior: "deny", message: "Worker aborted" }));
     },
     wrappedTools: {}
     // not used for ClaudeCodeWorker
   };
-  /**
-   * A permission settled (approved / denied / timed out). If a controller
-   * message was waiting for the permission window to close, deliver its
-   * interrupt now — this runs on BOTH the resolve and the timeout path.
-   */
-  afterPermissionSettled() {
-    if (this._interruptQueued && this._pendingPermissions.size === 0) {
-      this._interruptQueued = false;
-      this.requestInterrupt();
-    }
-  }
   // Signal context set during run()
   _signalQueue = null;
   _runContext = null;
@@ -5463,6 +6396,10 @@ var ClaudeCodeWorker = class _ClaudeCodeWorker {
   }
   async run(task, _tools, onProgress) {
     this._terminalResult = null;
+    this._streamEnded = false;
+    this._inputClosed = false;
+    this._runInFlight = true;
+    this._pendingToolSteps = [];
     this.state.set("runtimeState.task", { id: task.id, description: task.description });
     const turnEnv = this.buildTurnEnv(task);
     this._currentTurnEnv = turnEnv;
@@ -5520,18 +6457,20 @@ var ClaudeCodeWorker = class _ClaudeCodeWorker {
         prompt: this.buildPromptIterable(task.description),
         options
       });
-      this._activeQuery = stream;
       try {
         for await (const message of stream) {
           if (this.abortController.signal.aborted) break;
           this.processStreamMessage(message, onProgress);
-          if (this._terminalResult) break;
         }
       } finally {
-        this._activeQuery = null;
+        this._streamEnded = true;
+        this._inputClosed = true;
+        this.clearPendingProgress();
+        this.flushAllToolSteps();
       }
     } catch (err) {
       this.logger.error({ err, taskId: task.id }, "ClaudeCodeWorker query error");
+      this._inputClosed = true;
       if (!this._terminalResult) {
         this._terminalResult = {
           status: "failed",
@@ -5558,6 +6497,7 @@ var ClaudeCodeWorker = class _ClaudeCodeWorker {
       startedAt: resultTs,
       endedAt: resultTs
     }, turnEnv));
+    this._runInFlight = false;
     return this._terminalResult;
   }
   /** Set signal context for permission requests. Called by engine before run(). */
@@ -5568,6 +6508,7 @@ var ClaudeCodeWorker = class _ClaudeCodeWorker {
   }
   abort() {
     this.abortController.abort();
+    this.clearPendingProgress();
     this.permissionHandler.cleanup();
     this.flushMessageQueue();
   }
@@ -5575,6 +6516,14 @@ var ClaudeCodeWorker = class _ClaudeCodeWorker {
   getState() {
     return this.state;
   }
+  /**
+   * Live run flags (issue #16): `resultReceived` flips as soon as the SDK result
+   * message lands, `streamEnded` when the message loop exits. The gap between
+   * them is exactly the #15 window where the controller saw nothing.
+   */
+  getLiveStatus() {
+    return { resultReceived: this._terminalResult !== null, streamEnded: this._streamEnded };
+  }
   /** Get conversation entries. */
   getConversation() {
     return this.state.get("conversation") ?? [];
@@ -5586,34 +6535,36 @@ var ClaudeCodeWorker = class _ClaudeCodeWorker {
   getSnapshot(path7) {
     return this.state.get(path7);
   }
-  /** Accept a message from the controller — injects into running session via streamInput. */
+  /**
+   * Accept a message from the controller. The message is queued and handed
+   * to the SDK only when it pulls the next prompt: the CLI parks pulled
+   * prompts in an internal queue that it drains strictly BETWEEN turns, so
+   * delivery always lands on a turn boundary — a tool call in progress is
+   * never cut off (the v0.6 interrupt delivery did exactly that and killed
+   * the session with an orphaned tool_use; see docs/develop/v0.6-design.md
+   * §6.1 — the hazard is any unclosed tool_use, not just a pending
+   * permission).
+   *
+   * Returns false when delivery is impossible: the run's input has closed
+   * (final result received) or the worker was aborted. Idle multi-stage
+   * workers (no run in flight) always accept — the next stage folds the
+   * message into its opening prompt.
+   */
   acceptMessage(message) {
+    if (this.abortController.signal.aborted) return false;
+    if (this._runInFlight && this._inputClosed) return false;
     this._messageQueue.push(message);
     if (this._messageResolve) {
       this._messageResolve();
       this._messageResolve = null;
     }
-    if ((this.config.interruptOnMessage ?? "immediate") === "immediate") {
-      this.requestInterrupt();
-    }
     this.logger.info({ workerId: this.id }, "Controller message accepted");
+    return true;
   }
   /** Unread controller messages (non-destructive) — engine reports these when the run ends. */
   pendingMessages() {
     return [...this._messageQueue];
   }
-  /** Interrupt the active query unless a permission is pending (queued until it settles). */
-  requestInterrupt() {
-    if (this.abortController.signal.aborted || !this._activeQuery) return;
-    if (this._pendingPermissions.size > 0) {
-      this._interruptQueued = true;
-      return;
-    }
-    if (typeof this._activeQuery.interrupt !== "function") return;
-    this._activeQuery.interrupt().catch((err) => {
-      this.logger.warn({ workerId: this.id, err: String(err) }, "interrupt() failed");
-    });
-  }
   /**
    * Provide the engine-backed ask_controller implementation. Once set, the
    * worker exposes it to Claude Code as an in-process SDK MCP tool.
@@ -5651,9 +6602,7 @@ var ClaudeCodeWorker = class _ClaudeCodeWorker {
       ...this._turnLineage
     });
     return this._pendingPermissions.wait(requestId, _ClaudeCodeWorker.PERMISSION_TIMEOUT_MS, () => {
-      const value = { behavior: "deny", message: "Permission request timed out" };
-      this.afterPermissionSettled();
-      return value;
+      return { behavior: "deny", message: "Permission request timed out" };
     });
   }
   // --- Prompt as AsyncIterable (supports follow-up messages) ---
@@ -5680,13 +6629,22 @@ ${leftoverText}` : `${buildThirdPartyPrompt(this.skills)}${initialPrompt}`;
               };
             }
             while (true) {
-              if (this.abortController.signal.aborted || this._terminalResult) {
+              if (this.abortController.signal.aborted) {
+                this._inputClosed = true;
                 return { value: void 0, done: true };
               }
-              if (this._messageQueue.length > 0) break;
-              await new Promise((resolve11) => {
-                this._messageResolve = resolve11;
-              });
+              if (this._terminalResult) {
+                if (this._messageQueue.length === 0) {
+                  this._inputClosed = true;
+                  return { value: void 0, done: true };
+                }
+              } else if (this._messageQueue.length === 0) {
+                await new Promise((resolve12) => {
+                  this._messageResolve = resolve12;
+                });
+                continue;
+              }
+              break;
             }
             const msg = this._messageQueue.shift();
             return {
@@ -5751,25 +6709,49 @@ controller: ${answer}`,
   processStreamMessage(message, onProgress) {
     if (message.type === "assistant") {
       this.handleAssistantMessage(message, onProgress);
+    } else if (message.type === "user") {
+      this.handleUserMessage(message);
     } else if (message.type === "result") {
       this.handleResultMessage(message);
     }
   }
+  /** Append one entry to the conversation under the current turn envelope. */
+  appendConversationEntry(entry) {
+    this.state.append("conversation", applyTurnEnvelope(entry, this._currentTurnEnv ?? void 0));
+  }
+  /**
+   * Drop a debounced progress delivery: cancel the timer and the buffered
+   * text. Called when a result supersedes the progress, when the run is
+   * aborted, and when the stream loop exits (all paths — the run is over, so
+   * nothing may be delivered afterwards).
+   */
+  clearPendingProgress() {
+    if (this._progressTimer) {
+      clearTimeout(this._progressTimer);
+      this._progressTimer = null;
+    }
+    this._pendingProgress = null;
+  }
   handleAssistantMessage(msg, onProgress) {
     const textParts = [];
+    const toolCalls = [];
+    const ts = nowISO();
     for (const block of msg.message.content) {
       if (block.type === "text") {
         textParts.push(block.text);
+      } else if (block.type === "tool_use") {
+        toolCalls.push(toolUseBlockToRecord(block, ts));
       }
     }
     const text = textParts.join("\n");
-    if (!text) return;
-    this.state.append("conversation", applyTurnEnvelope({
+    if (!text && toolCalls.length === 0) return;
+    const entry = {
       type: "assistant" /* Assistant */,
       uuid: generateId("a"),
       parentUuid: null,
       sessionId: this.ctx.sessionId,
-      timestamp: nowISO(),
+      timestamp: ts,
+      startedAt: ts,
       message: {
         role: "assistant",
         content: text,
@@ -5780,26 +6762,112 @@ controller: ${answer}`,
             cachedInputTokens: msg.message.usage.cache_read_input_tokens
           }
         }
-      }
-    }, this._currentTurnEnv ?? void 0));
-    if (onProgress) {
+      },
+      ...toolCalls.length > 0 && { toolCalls }
+    };
+    if (this._pendingToolSteps.length > 0 || toolCalls.length > 0) {
+      this._pendingToolSteps.push(entry);
+    } else {
+      entry.endedAt = ts;
+      this.appendConversationEntry(entry);
+    }
+    if (text && onProgress) {
       this._pendingProgress = text.slice(0, 200);
       if (this._progressTimer) clearTimeout(this._progressTimer);
       this._progressTimer = setTimeout(() => {
-        if (this._pendingProgress) {
-          onProgress(this._pendingProgress);
+        this._progressTimer = null;
+        if (this._pendingProgress === null || this.abortController.signal.aborted || this._streamEnded || this._terminalResult !== null) {
           this._pendingProgress = null;
+          return;
         }
-        this._progressTimer = null;
+        const pending = this._pendingProgress;
+        this._pendingProgress = null;
+        onProgress(pending);
       }, _ClaudeCodeWorker.PROGRESS_DEBOUNCE_MS);
     }
   }
-  handleResultMessage(msg) {
-    if (this._progressTimer) {
-      clearTimeout(this._progressTimer);
-      this._progressTimer = null;
-      this._pendingProgress = null;
+  /**
+   * SDK user messages carry the tool_result blocks for the preceding
+   * assistant step's tool_use calls. Each result is merged into the buffered
+   * entry that issued the matching id; completed steps are then written,
+   * oldest first.
+   *
+   * User messages WITHOUT tool_result blocks (echoes of the task prompt or of
+   * controller messages this worker itself injected) are ignored — the task
+   * entry is written by run() and controller messages are audited elsewhere,
+   * so writing them here would duplicate entries.
+   */
+  handleUserMessage(msg) {
+    const content = msg.message.content;
+    if (!Array.isArray(content)) return;
+    const ts = nowISO();
+    for (const block of content) {
+      if (!block || block.type !== "tool_result") continue;
+      const resultBlock = block;
+      const owner = this._pendingToolSteps.find(
+        (step) => step.toolCalls?.some((tc) => tc.toolCallId === resultBlock.tool_use_id)
+      );
+      if (!owner) {
+        this.logger.debug(
+          { toolUseId: resultBlock.tool_use_id },
+          "tool_result with no matching pending tool_use \u2014 dropped"
+        );
+        continue;
+      }
+      const call = owner.toolCalls.find((tc) => tc.toolCallId === resultBlock.tool_use_id);
+      const result = toolResultBlockToRecord(resultBlock, call.toolName, ts);
+      (owner.toolResults ??= []).push(result);
+      call.status = result.status;
+      call.endedAt = ts;
+    }
+    this.flushCompletedToolSteps();
+  }
+  /**
+   * Write buffered steps whose tool calls have ALL received results, from the
+   * head of the queue (order-preserving). Steps still missing results stay
+   * buffered — a later user message or the end-of-stream flush resolves them.
+   */
+  flushCompletedToolSteps() {
+    while (this._pendingToolSteps.length > 0) {
+      const head = this._pendingToolSteps[0];
+      const callIds = new Set(head.toolCalls?.map((tc) => tc.toolCallId) ?? []);
+      const resultIds = new Set(head.toolResults?.map((tr) => tr.toolCallId) ?? []);
+      let complete = true;
+      for (const id of callIds) {
+        if (!resultIds.has(id)) {
+          complete = false;
+          break;
+        }
+      }
+      if (!complete) break;
+      this._pendingToolSteps.shift();
+      head.endedAt = nowISO();
+      this.appendConversationEntry(head);
+    }
+  }
+  /**
+   * End-of-stream fallback: write every still-buffered step so nothing is
+   * lost. Tool calls that never received a result (abort, CLI death mid-tool)
+   * are marked 'cancelled' instead of claiming to run forever.
+   */
+  flushAllToolSteps() {
+    if (this._pendingToolSteps.length === 0) return;
+    const ts = nowISO();
+    for (const entry of this._pendingToolSteps) {
+      const resultIds = new Set(entry.toolResults?.map((tr) => tr.toolCallId) ?? []);
+      for (const tc of entry.toolCalls ?? []) {
+        if (!resultIds.has(tc.toolCallId)) {
+          tc.status = "cancelled";
+          if (tc.endedAt === void 0) tc.endedAt = ts;
+        }
+      }
+      entry.endedAt = ts;
+      this.appendConversationEntry(entry);
     }
+    this._pendingToolSteps = [];
+  }
+  handleResultMessage(msg) {
+    this.clearPendingProgress();
     if (msg.subtype === "success") {
       this._terminalResult = {
         status: "completed",
@@ -5812,9 +6880,9 @@ controller: ${answer}`,
       };
     }
     if (this._messageResolve) {
-      const resolve11 = this._messageResolve;
+      const resolve12 = this._messageResolve;
       this._messageResolve = null;
-      resolve11();
+      resolve12();
     }
     const prev = this.state.get("runtimeState");
     this.state.set("runtimeState", {
@@ -5954,13 +7022,21 @@ function disposeWorkerTool(deps) {
 
 // src/services/tools/get-task-detail.ts
 import { z as z7 } from "zod";
+var OUTPUT_OVERHEAD_CHARS = 1500;
+var DEFAULT_LIMIT = 10;
+var DEFAULT_MAX_CHARS = 200;
 function getTaskDetailTool(deps) {
   return defineTool({
-    description: "Get detailed information about a specific task",
+    description: "Get detailed information about a specific task, including its worker conversation. The conversation comes from the worker's live in-memory state while it runs, and from its on-disk transcript after the worker ended (marked [from transcript]). The conversation is paginated and truncation is always marked explicitly: offset skips N entries counted back from the newest; output is ordered oldest\u2192newest; type filtering is applied BEFORE pagination. limit (default 10 entries, counted back from the newest), maxChars (per-entry character cap, default 200) and full=true (complete text, all entries). A machine-readable meta line reports totalEntries / returnedEntries / offset / truncated.",
     parameters: z7.object({
-      taskId: z7.string().describe("Task ID")
+      taskId: z7.string().describe("Task ID"),
+      limit: z7.number().int().min(1).optional().describe(`Max entries to return (default ${DEFAULT_LIMIT})`),
+      offset: z7.number().int().min(0).optional().describe("Skip the newest N entries (default 0)"),
+      maxChars: z7.number().int().min(1).optional().describe(`Per-entry character cap (default ${DEFAULT_MAX_CHARS})`),
+      full: z7.boolean().optional().describe("Return complete entry text and all entries (ignores limit/maxChars)")
     }),
-    execute: safeExecute("get_task_detail", async ({ taskId }) => {
+    // Full reports can be far longer than the default tool-output cap.
+    execute: safeExecute("get_task_detail", async ({ taskId, limit, offset, maxChars, full }) => {
       const task = deps.getTask(taskId);
       if (!task) return `Task ${taskId} not found`;
       const lines = [
@@ -5975,30 +7051,313 @@ function getTaskDetailTool(deps) {
       if (task.result) lines.push(`Result: ${task.result}`);
       if (task.error) lines.push(`Error: ${task.error}`);
       if (task.workerSessionId) lines.push(`Worker: ${task.workerSessionId}`);
+      const isFull = full === true;
+      const requestedLimit = limit ?? DEFAULT_LIMIT;
+      let entries = [];
+      let source = "none";
+      let incompleteTail = false;
+      let readWindowTruncated = false;
       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));
+        entries = deps.getWorkerConversation(taskId);
+        if (entries.length > 0) source = "memory";
+      }
+      if (entries.length === 0 && deps.readTranscriptWindow) {
+        const diskIds = [task.workerTranscriptId, task.workerSessionId].filter((id) => typeof id === "string");
+        for (const id of [...new Set(diskIds)]) {
+          const win2 = deps.readTranscriptWindow(id, {
+            need: isFull ? void 0 : (offset ?? 0) + requestedLimit
+          });
+          if (win2 && win2.entries.length > 0) {
+            entries = win2.entries;
+            source = "transcript";
+            incompleteTail = win2.incompleteTail;
+            readWindowTruncated = win2.windowTruncated;
+            break;
           }
         }
       }
+      if (entries.length === 0) return lines.join("\n");
+      const perEntryCap = isFull ? null : maxChars ?? DEFAULT_MAX_CHARS;
+      const requested = selectWindow(entries, offset ?? 0, isFull ? entries.length : requestedLimit);
+      const rendered = renderEntriesFitting(
+        requested.entries,
+        requested.startIndex,
+        { maxChars: perEntryCap, includeToolDetail: isFull },
+        MAX_TRANSCRIPT_RESULT_CHARS - OUTPUT_OVERHEAD_CHARS
+      );
+      const win = shrinkWindow(requested, rendered.dropped);
+      const body = rendered.lines;
+      const base = buildWindowMeta(win, { maxChars: perEntryCap, full: isFull, shortenedEntries: rendered.shortened });
+      const meta = {
+        ...base,
+        source,
+        incompleteTail,
+        readWindowTruncated,
+        windowTruncated: base.windowTruncated || readWindowTruncated,
+        truncated: base.truncated || readWindowTruncated
+      };
+      lines.push("");
+      let header = buildTranscriptHeader(meta);
+      if (readWindowTruncated) {
+        header = `Conversation (${meta.totalEntries} entries in read window, showing ${meta.startIndex}-${meta.endIndex}; older entries exist beyond the read-window cap)`;
+      }
+      lines.push(`${header}${source === "transcript" ? " [from transcript]" : ""}`);
+      lines.push(...body);
+      if (incompleteTail) {
+        lines.push("[note: last entry is incomplete \u2014 the transcript is still being written]");
+      }
+      if (readWindowTruncated) {
+        lines.push("[note: transcript read window hit its byte cap \u2014 older entries were not read; page back with offset/limit]");
+      }
+      const notice = buildTruncationNotice(meta);
+      if (notice) lines.push(notice);
+      lines.push(`[conversation-meta] ${JSON.stringify(meta)}`);
       return lines.join("\n");
-    })
+    }, { maxResultChars: MAX_TRANSCRIPT_RESULT_CHARS })
   });
 }
 
-// src/services/tools/update-task.ts
+// src/services/tools/read-worker-conversation.ts
 import { z as z8 } from "zod";
+var OUTPUT_OVERHEAD_CHARS2 = 1500;
+var DEFAULT_LIMIT2 = 20;
+var DEFAULT_MAX_CHARS2 = 200;
+var FILTER_TYPES = ["user", "assistant", "system", "signal", "tool"];
+function typeMatches(entry, filter) {
+  if (filter === "tool") {
+    const calls = entry.toolCalls;
+    return Array.isArray(calls) && calls.length > 0;
+  }
+  return entry.type === filter;
+}
+function readWorkerConversationTool(deps) {
+  return defineTool({
+    description: `Read a worker's conversation transcript. Layered source: while the engine still tracks the worker (running or idle), its live in-memory conversation is returned (meta source="memory"); once the worker finished/failed/was cancelled or disposed, the append-only on-disk file <sessionDir>/workers/<transcript id>/conversation.jsonl is read instead (meta source="disk") \u2014 so it works for running AND completed/failed/cancelled workers. Pagination: offset skips N entries counted back from the newest; output is ordered oldest\u2192newest; type filtering is applied BEFORE pagination. limit (default 20, max entries), maxChars (per-entry cap, default 200), full=true (complete text, all entries \u2014 still bounded by a 2 MB read window), type (filter: user/assistant/system/signal/tool). Truncation is always marked explicitly and reported as totalEntries / returnedEntries / offset / truncated, plus incompleteTail (last entry still being written) and readWindowTruncated (older entries exist beyond the read-window cap \u2014 page back with offset).`,
+    parameters: z8.object({
+      workerId: z8.string().describe("Worker ID (e.g. w-1793587065421-6h37)"),
+      limit: z8.number().int().min(1).optional().describe(`Max entries to return (default ${DEFAULT_LIMIT2})`),
+      offset: z8.number().int().min(0).optional().describe("Skip the newest N entries (default 0)"),
+      maxChars: z8.number().int().min(1).optional().describe(`Per-entry character cap (default ${DEFAULT_MAX_CHARS2})`),
+      full: z8.boolean().optional().describe("Return complete entry text and all entries (ignores limit/maxChars)"),
+      type: z8.enum(FILTER_TYPES).optional().describe('Only entries of this type; "tool" = assistant entries that made tool calls')
+    }),
+    execute: safeExecute("read_worker_conversation", async ({ workerId, limit, offset, maxChars, full, type }) => {
+      const now = deps.now?.() ?? Date.now();
+      if (!isValidWorkerId(workerId)) {
+        return `Invalid worker id "${workerId}" \u2014 worker ids are alphanumeric with dashes/underscores only.`;
+      }
+      const task = deps.listTasks?.().find((t) => t.workerSessionId === workerId);
+      const isActive = deps.listWorkers?.().some((w) => w.workerId === workerId) ?? false;
+      const liveTranscriptId = deps.getWorkerTranscriptId?.(workerId);
+      const isFull = full === true;
+      const requestedLimit = limit ?? DEFAULT_LIMIT2;
+      const need = isFull ? void 0 : (offset ?? 0) + requestedLimit;
+      const matches = type === void 0 ? void 0 : (e) => typeMatches(e, type);
+      const memory = deps.getWorkerConversationByWorkerId?.(workerId);
+      if (memory !== void 0 && memory.length > 0) {
+        return render2({ source: "memory", entries: memory });
+      }
+      const candidates = [];
+      for (const id of [task?.workerTranscriptId, liveTranscriptId, workerId]) {
+        if (typeof id === "string" && !candidates.includes(id)) candidates.push(id);
+      }
+      let disk = null;
+      for (const id of candidates) {
+        const win = deps.readTranscriptWindow(id, { need, matches });
+        if (win !== null) {
+          disk = { id, win };
+          break;
+        }
+      }
+      if (disk !== null) {
+        return render2({
+          source: "disk",
+          entries: disk.win.entries,
+          transcriptId: disk.id,
+          incompleteTail: disk.win.incompleteTail,
+          readWindowTruncated: disk.win.windowTruncated
+        });
+      }
+      const known = isActive || task !== void 0 || memory !== void 0;
+      if (!known) {
+        return `Unknown worker ${workerId}: no active worker and no task references it.`;
+      }
+      if (isActive) {
+        return `Worker ${workerId} is running but has not written any transcript entries yet.`;
+      }
+      const resolved = task?.workerTranscriptId ?? liveTranscriptId;
+      if (resolved !== void 0) {
+        return `Worker ${workerId} exists but its transcript directory is missing on disk (expected ${workerTranscriptPath(deps.sessionDir, resolved)}).`;
+      }
+      return `Worker ${workerId} exists but its transcript cannot be located on disk (legacy session id layout?).`;
+      function render2(src) {
+        const { source, entries } = src;
+        const incompleteTail = src.incompleteTail ?? false;
+        const readWindowTruncated = src.readWindowTruncated ?? false;
+        if (entries.length === 0) {
+          const emptyMsg = `Transcript for worker ${workerId} exists but contains no complete entries yet.`;
+          return incompleteTail ? `${emptyMsg}
+[note: last entry is incomplete \u2014 the transcript is still being written]` : emptyMsg;
+        }
+        const filter = type;
+        const population = filter === void 0 ? entries : entries.filter((e) => typeMatches(e, filter));
+        const reqLimit = isFull ? population.length : requestedLimit;
+        const perEntryCap = isFull ? null : maxChars ?? DEFAULT_MAX_CHARS2;
+        const requested = selectWindow(population, offset ?? 0, reqLimit);
+        const rendered = renderEntriesFitting(
+          requested.entries,
+          requested.startIndex,
+          { maxChars: perEntryCap, includeToolDetail: isFull },
+          MAX_TRANSCRIPT_RESULT_CHARS - OUTPUT_OVERHEAD_CHARS2
+        );
+        const win = shrinkWindow(requested, rendered.dropped);
+        const body = rendered.lines;
+        const base = buildWindowMeta(win, {
+          maxChars: perEntryCap,
+          full: isFull,
+          shortenedEntries: rendered.shortened
+        });
+        const meta = {
+          workerId,
+          source,
+          ...src.transcriptId !== void 0 && { transcriptId: src.transcriptId },
+          ...base,
+          incompleteTail,
+          readWindowTruncated,
+          windowTruncated: base.windowTruncated || readWindowTruncated,
+          truncated: base.truncated || readWindowTruncated,
+          ...filter !== void 0 && { filter, totalEntriesBeforeFilter: entries.length }
+        };
+        const summary = summarizeTranscript(entries);
+        const headLine = source === "disk" ? `Worker ${workerId} transcript (source=disk, dir id ${src.transcriptId}): ` + workerTranscriptPath(deps.sessionDir, src.transcriptId ?? workerId) : `Worker ${workerId} conversation (source=memory \u2014 live in-memory state of the tracked worker)`;
+        const lines = [
+          headLine,
+          `Last activity: ${formatLastActivity(summary.lastActivityAt, now)}; currentTool: ${summary.currentTool ?? "-"}; terminal marker: ${summary.terminalSubtype ?? "-"}`
+        ];
+        let header = buildTranscriptHeader(meta);
+        if (readWindowTruncated) {
+          header = `Conversation (${meta.totalEntries} entries in read window, showing ${meta.startIndex}-${meta.endIndex}; older entries exist beyond the read-window cap):`;
+        }
+        lines.push(header + (filter !== void 0 ? ` [type=${filter}; ${entries.length} entries in transcript]` : ""));
+        lines.push(...body);
+        if (incompleteTail) {
+          lines.push("[note: last entry is incomplete \u2014 the transcript is still being written]");
+        }
+        if (readWindowTruncated) {
+          lines.push("[note: transcript read window hit its byte cap \u2014 older entries were not read; page back with offset/limit]");
+        }
+        const notice = buildTruncationNotice(meta);
+        if (notice) lines.push(notice);
+        lines.push(`[transcript-meta] ${JSON.stringify(meta)}`);
+        return lines.join("\n");
+      }
+    }, { maxResultChars: MAX_TRANSCRIPT_RESULT_CHARS })
+  });
+}
+
+// src/services/tools/get-worker-status.ts
+import { z as z9 } from "zod";
+var SETTLED_TASK_STATUSES = /* @__PURE__ */ new Set(["completed", "failed", "cancelled"]);
+function taskStatusToWorkerStatus(status) {
+  if (status === "running") return "running";
+  if (SETTLED_TASK_STATUSES.has(status)) return status;
+  return "unknown";
+}
+function buildSnapshot(workerId, deps, now) {
+  const active = deps.listWorkers().find((w) => w.workerId === workerId);
+  const tasks = deps.listTasks();
+  const task = active ? tasks.find((t) => t.id === active.taskId) : tasks.find((t) => t.workerSessionId === workerId);
+  const entries = deps.readTranscript(workerId);
+  if (!active && !task && entries === null) return null;
+  const summary = summarizeTranscript(entries ?? []);
+  const live = deps.getLiveStatus?.(workerId);
+  const workerType = active?.workerType ?? task?.workerType ?? "unknown";
+  const settled = task ? SETTLED_TASK_STATUSES.has(task.status) : false;
+  const terminalTracked = workerType !== "puppet";
+  const inferredTerminal = summary.hasTerminalEntry || settled;
+  let runningForMs = null;
+  if (active) {
+    runningForMs = Math.max(0, now - active.startedAt);
+  } else if (task?.startedAt) {
+    runningForMs = Math.max(0, (task.completedAt ?? now) - task.startedAt);
+  }
+  return {
+    workerId,
+    type: workerType,
+    taskId: active?.taskId ?? task?.id ?? null,
+    status: active?.status ?? (task ? taskStatusToWorkerStatus(task.status) : "unknown"),
+    runningForMs,
+    lastActivityAt: summary.lastActivityAt,
+    lastActivityAgoMs: summary.lastActivityAt === null ? null : Math.max(0, now - summary.lastActivityAt),
+    currentTool: summary.currentTool,
+    streamEnded: live?.streamEnded ?? (inferredTerminal ? true : terminalTracked ? false : null),
+    resultReceived: live?.resultReceived ?? (inferredTerminal ? true : terminalTracked ? false : null),
+    idleSince: active?.status === "idle" ? active.idleSinceMs ?? null : null,
+    live: active !== void 0,
+    lastEntryType: summary.lastEntryType,
+    entries: summary.totalEntries
+  };
+}
+function boolLabel(v) {
+  return v === null ? "unknown" : String(v);
+}
+function formatSnapshot(s, now) {
+  return [
+    `Worker ${s.workerId} (${s.type})`,
+    `  task: ${s.taskId ?? "-"}`,
+    `  status: ${s.status}${s.live ? " (tracked)" : " (no longer tracked)"}`,
+    `  runningForMs: ${s.runningForMs === null ? "unknown" : `${s.runningForMs} (${formatDuration(s.runningForMs)})`}`,
+    `  lastActivityAt: ${formatLastActivity(s.lastActivityAt, now)}`,
+    `  currentTool: ${s.currentTool ?? "-"}`,
+    `  streamEnded: ${boolLabel(s.streamEnded)}`,
+    `  resultReceived: ${boolLabel(s.resultReceived)}`,
+    `  idleSince: ${s.idleSince === null ? "-" : formatLastActivity(s.idleSince, now)}`,
+    `  entries: ${s.entries} (last: ${s.lastEntryType ?? "-"})`
+  ];
+}
+function formatSnapshotLine(s) {
+  const activity = s.lastActivityAgoMs === null ? "none" : `${formatDuration(s.lastActivityAgoMs)} ago`;
+  return `  [${s.status}] ${s.workerId} (${s.type}) task=${s.taskId ?? "-"} runningFor=${s.runningForMs === null ? "unknown" : formatDuration(s.runningForMs)} lastActivity=${activity} tool=${s.currentTool ?? "-"} streamEnded=${boolLabel(s.streamEnded)} resultReceived=${boolLabel(s.resultReceived)}`;
+}
+function getWorkerStatusTool(deps) {
+  return defineTool({
+    description: 'Get the liveness of one worker (workerId given) or of all current workers (omitted). Reports status, runningForMs, lastActivityAt (epoch ms of the newest transcript entry; lastActivityAgoMs is how long ago that was), currentTool, streamEnded, resultReceived and idleSince \u2014 use it to tell "still working" from "stuck / already finished and just not released" before deciding to wait, chat, or cancel. Unknown worker ids return a not-found message instead of throwing. A machine-readable [worker-status] line carries the same data as JSON.',
+    parameters: z9.object({
+      workerId: z9.string().optional().describe("Worker ID; omit to list all current workers")
+    }),
+    execute: safeExecute("get_worker_status", async ({ workerId }) => {
+      const now = deps.now?.() ?? Date.now();
+      if (workerId !== void 0 && !isValidWorkerId(workerId)) {
+        return `Invalid worker id "${workerId}" \u2014 worker ids are alphanumeric with dashes/underscores only.`;
+      }
+      if (workerId === void 0) {
+        const workers = deps.listWorkers();
+        if (workers.length === 0) {
+          return "No workers are running or idle.\n[worker-status] []";
+        }
+        const snapshots = workers.map((w) => buildSnapshot(w.workerId, deps, now)).filter((s) => s !== null);
+        const lines = [`Workers (${snapshots.length}):`, ...snapshots.map(formatSnapshotLine)];
+        lines.push(`[worker-status] ${JSON.stringify(snapshots)}`);
+        return lines.join("\n");
+      }
+      const snapshot = buildSnapshot(workerId, deps, now);
+      if (!snapshot) {
+        return `Worker ${workerId} not found (not tracked, no task references it, no transcript on disk).`;
+      }
+      return [...formatSnapshot(snapshot, now), `[worker-status] ${JSON.stringify(snapshot)}`].join("\n");
+    }, { maxResultChars: MAX_TRANSCRIPT_RESULT_CHARS })
+  });
+}
+
+// src/services/tools/update-task.ts
+import { z as z10 } from "zod";
 function updateTaskTool(deps) {
   return defineTool({
     description: "Update a pending task description or priority",
-    parameters: z8.object({
-      taskId: z8.string().describe("Task ID to update"),
-      description: z8.string().optional().describe("New task description"),
-      priority: z8.enum(["normal", "high"]).optional().describe("New priority")
+    parameters: z10.object({
+      taskId: z10.string().describe("Task ID to update"),
+      description: z10.string().optional().describe("New task description"),
+      priority: z10.enum(["normal", "high"]).optional().describe("New priority")
     }),
     execute: safeExecute("update_task", async ({ taskId, description, priority }) => {
       if (!description && !priority) {
@@ -6012,14 +7371,14 @@ function updateTaskTool(deps) {
 }
 
 // src/services/tools/query-signals.ts
-import { z as z9 } from "zod";
+import { z as z11 } from "zod";
 function querySignalsTool(deps) {
   return defineTool({
     description: "Query signal history by status, source, or type",
-    parameters: z9.object({
-      status: z9.enum(["unread", "read", "discarded"]).optional().describe("Filter by status"),
-      source: z9.enum(["user", "worker", "system"]).optional().describe("Filter by source"),
-      type: z9.enum(["input", "completed", "failed", "progress", "cancelled"]).optional().describe("Filter by type")
+    parameters: z11.object({
+      status: z11.enum(["unread", "read", "discarded"]).optional().describe("Filter by status"),
+      source: z11.enum(["user", "worker", "system"]).optional().describe("Filter by source"),
+      type: z11.enum(["input", "completed", "failed", "progress", "cancelled"]).optional().describe("Filter by type")
     }),
     execute: safeExecute("query_signals", async (filter) => {
       const signals = deps.querySignals(filter);
@@ -6032,11 +7391,11 @@ function querySignalsTool(deps) {
 }
 
 // src/services/tools/skip-reply.ts
-import { z as z10 } from "zod";
+import { z as z12 } from "zod";
 function skipReplyTool() {
   return defineTool({
     description: "Acknowledge a signal without responding to the user. IMPORTANT: this tool terminates the turn immediately. You MUST NOT output any text in the same response \u2014 your response must contain ONLY this tool call. Any co-emitted text will leak to the user as a broken message.",
-    parameters: z10.object({}),
+    parameters: z12.object({}),
     execute: safeExecute("skip_reply", async () => {
       return "(skipped)";
     })
@@ -6044,13 +7403,13 @@ function skipReplyTool() {
 }
 
 // src/services/tools/bash.ts
-import { z as z11 } from "zod";
+import { z as z13 } from "zod";
 import { execSync as execSync2 } from "child_process";
 function bashTool(deps) {
   return defineTool({
     description: "Execute a shell command and return its output",
-    parameters: z11.object({
-      command: z11.string().describe("Shell command to execute")
+    parameters: z13.object({
+      command: z13.string().describe("Shell command to execute")
     }),
     execute: safeExecute("bash", async ({ command }) => {
       try {
@@ -6072,22 +7431,22 @@ ${detail}`;
 }
 
 // src/services/tools/read-file.ts
-import { z as z12 } from "zod";
-import { readFileSync as readFileSync6 } from "fs";
-import { resolve as resolve2 } from "path";
+import { z as z14 } from "zod";
+import { readFileSync as readFileSync7 } from "fs";
+import { resolve as resolve3 } from "path";
 var DEFAULT_MAX_LINES = 500;
 function readFileTool(deps = {}) {
   const workspace = deps.cwd ?? process.cwd();
   return defineTool({
     description: `Read file content (with line numbers). Returns at most ${DEFAULT_MAX_LINES} lines by default. Use offset (1-based start line) and limit to read specific sections of large files.`,
-    parameters: z12.object({
-      path: z12.string().describe("File path (relative to workspace or absolute)"),
-      offset: z12.number().int().min(1).optional().describe("Start line number (1-based)"),
-      limit: z12.number().int().min(1).optional().describe("Number of lines to read")
+    parameters: z14.object({
+      path: z14.string().describe("File path (relative to workspace or absolute)"),
+      offset: z14.number().int().min(1).optional().describe("Start line number (1-based)"),
+      limit: z14.number().int().min(1).optional().describe("Number of lines to read")
     }),
     execute: safeExecute("read_file", async ({ path: path7, offset, limit }) => {
-      const resolved = resolve2(workspace, path7);
-      const content = readFileSync6(resolved, "utf-8");
+      const resolved = resolve3(workspace, path7);
+      const content = readFileSync7(resolved, "utf-8");
       const lines = content.split("\n");
       const totalLines = lines.length;
       const start = offset ? offset - 1 : 0;
@@ -6106,23 +7465,23 @@ function readFileTool(deps = {}) {
 }
 
 // src/services/tools/write-file.ts
-import { z as z13 } from "zod";
-import { writeFileSync as writeFileSync3, mkdirSync as mkdirSync4, existsSync as existsSync5 } from "fs";
-import { dirname as dirname4, resolve as resolve3 } from "path";
+import { z as z15 } from "zod";
+import { writeFileSync as writeFileSync3, mkdirSync as mkdirSync4, existsSync as existsSync7 } from "fs";
+import { dirname as dirname5, resolve as resolve4 } from "path";
 function writeFileTool(deps = {}) {
   const workspace = deps.cwd ?? process.cwd();
   return defineTool({
     description: "Create a new file with the given content. Creates parent directories as needed. Use edit_file to modify existing files.",
-    parameters: z13.object({
-      path: z13.string().describe("File path (relative to workspace or absolute)"),
-      content: z13.string().describe("File content")
+    parameters: z15.object({
+      path: z15.string().describe("File path (relative to workspace or absolute)"),
+      content: z15.string().describe("File content")
     }),
     execute: safeExecute("write_file", async ({ path: path7, content }) => {
-      const resolved = resolve3(workspace, path7);
-      if (existsSync5(resolved)) {
+      const resolved = resolve4(workspace, path7);
+      if (existsSync7(resolved)) {
         return `[ERROR] write_file: File already exists: ${path7}. Use edit_file to modify existing files.`;
       }
-      mkdirSync4(dirname4(resolved), { recursive: true });
+      mkdirSync4(dirname5(resolved), { recursive: true });
       writeFileSync3(resolved, content, "utf-8");
       return `Written ${content.length} chars to ${resolved}`;
     })
@@ -6130,23 +7489,23 @@ function writeFileTool(deps = {}) {
 }
 
 // src/services/tools/edit-file.ts
-import { readFileSync as readFileSync7, writeFileSync as writeFileSync4 } from "fs";
-import { resolve as resolve4 } from "path";
-import { z as z14 } from "zod";
+import { readFileSync as readFileSync8, writeFileSync as writeFileSync4 } from "fs";
+import { resolve as resolve5 } from "path";
+import { z as z16 } from "zod";
 function editFileTool(deps) {
   const workspace = deps.cwd ?? process.cwd();
   return defineTool({
     description: "Edit a file by replacing a unique string. old_string must appear exactly once in the file \u2014 if it matches multiple times, expand the surrounding context to make it unique.",
-    parameters: z14.object({
-      path: z14.string().describe("File path (relative to workspace or absolute)"),
-      old_string: z14.string().describe("Exact text to find (must be unique in file)"),
-      new_string: z14.string().describe("Replacement text")
+    parameters: z16.object({
+      path: z16.string().describe("File path (relative to workspace or absolute)"),
+      old_string: z16.string().describe("Exact text to find (must be unique in file)"),
+      new_string: z16.string().describe("Replacement text")
     }),
     execute: safeExecute("edit_file", async ({ path: path7, old_string, new_string }) => {
-      const resolved = resolve4(workspace, path7);
+      const resolved = resolve5(workspace, path7);
       let content;
       try {
-        content = readFileSync7(resolved, "utf-8");
+        content = readFileSync8(resolved, "utf-8");
       } catch {
         return `[ERROR] edit_file: File not found: ${path7}`;
       }
@@ -6164,18 +7523,18 @@ function editFileTool(deps) {
 
 // src/services/tools/search-files.ts
 import fg from "fast-glob";
-import { resolve as resolve5 } from "path";
-import { z as z15 } from "zod";
+import { resolve as resolve6 } from "path";
+import { z as z17 } from "zod";
 function searchFilesTool(deps) {
   const workspace = deps.cwd ?? process.cwd();
   return defineTool({
     description: "Search for files matching a glob pattern. Returns matching file paths relative to workspace.",
-    parameters: z15.object({
-      pattern: z15.string().describe('Glob pattern (e.g. "**/*.ts", "src/**/*.test.ts")'),
-      path: z15.string().optional().describe("Base directory for search (default: workspace root)")
+    parameters: z17.object({
+      pattern: z17.string().describe('Glob pattern (e.g. "**/*.ts", "src/**/*.test.ts")'),
+      path: z17.string().optional().describe("Base directory for search (default: workspace root)")
     }),
     execute: safeExecute("search_files", async ({ pattern, path: path7 }) => {
-      const basePath = path7 ? resolve5(workspace, path7) : workspace;
+      const basePath = path7 ? resolve6(workspace, path7) : workspace;
       const entries = await fg(pattern, {
         cwd: basePath,
         onlyFiles: true,
@@ -6189,8 +7548,8 @@ function searchFilesTool(deps) {
 
 // src/services/tools/search-content.ts
 import { execSync as execSync3 } from "child_process";
-import { resolve as resolve6 } from "path";
-import { z as z16 } from "zod";
+import { resolve as resolve7 } from "path";
+import { z as z18 } from "zod";
 function shellQuote(s) {
   return `'${s.replace(/'/g, "'\\''")}'`;
 }
@@ -6198,13 +7557,13 @@ function searchContentTool(deps) {
   const workspace = deps.cwd ?? process.cwd();
   return defineTool({
     description: "Search file contents for a text pattern. Returns matching lines in file:line:content format.",
-    parameters: z16.object({
-      query: z16.string().describe("Search text or regex pattern"),
-      path: z16.string().optional().describe("Directory to search in (default: workspace root)"),
-      include: z16.string().optional().describe('File pattern to include (e.g. "*.ts", "*.py")')
+    parameters: z18.object({
+      query: z18.string().describe("Search text or regex pattern"),
+      path: z18.string().optional().describe("Directory to search in (default: workspace root)"),
+      include: z18.string().optional().describe('File pattern to include (e.g. "*.ts", "*.py")')
     }),
     execute: safeExecute("search_content", async ({ query: query2, path: path7, include }) => {
-      const searchDir = path7 ? resolve6(workspace, path7) : workspace;
+      const searchDir = path7 ? resolve7(workspace, path7) : workspace;
       const cmd = `grep -rn${include ? ` --include=${shellQuote(include)}` : ""} -- ${shellQuote(query2)} ${shellQuote(searchDir)}`;
       try {
         const output = execSync3(cmd, {
@@ -6223,13 +7582,13 @@ ${err.stderr?.toString() || ""}`;
 }
 
 // src/services/tools/web-search.ts
-import { z as z17 } from "zod";
+import { z as z19 } from "zod";
 function webSearchTool(deps) {
   const apiKey = deps.tavilyApiKey;
   return defineTool({
     description: "Search the web using Tavily. Returns top results with title, URL, and content snippet.",
-    parameters: z17.object({
-      query: z17.string().describe("Search query")
+    parameters: z19.object({
+      query: z19.string().describe("Search query")
     }),
     execute: safeExecute("web_search", async ({ query: query2 }) => {
       if (!apiKey) {
@@ -6260,11 +7619,11 @@ function webSearchTool(deps) {
 }
 
 // src/services/tools/notebook.ts
-import { z as z18 } from "zod";
+import { z as z20 } from "zod";
 function readNotebookTool(deps) {
   return defineTool({
     description: "Read the current notebook content. The notebook is a private scratchpad that persists across context compaction \u2014 use it to store plans, notes, and working context.",
-    parameters: z18.object({}),
+    parameters: z20.object({}),
     execute: safeExecute("read_notebook", async () => {
       const content = deps.getNotebook();
       return content || "(notebook is empty)";
@@ -6274,9 +7633,9 @@ function readNotebookTool(deps) {
 function updateNotebookTool(deps) {
   return defineTool({
     description: 'Update the notebook content. Use "replace" to overwrite the entire notebook, or "append" to add to the end. The notebook persists across context compaction.',
-    parameters: z18.object({
-      content: z18.string().describe("Content to write"),
-      mode: z18.enum(["replace", "append"]).optional().describe('Write mode: "replace" overwrites, "append" adds to the end (default: replace)')
+    parameters: z20.object({
+      content: z20.string().describe("Content to write"),
+      mode: z20.enum(["replace", "append"]).optional().describe('Write mode: "replace" overwrites, "append" adds to the end (default: replace)')
     }),
     execute: safeExecute("update_notebook", async ({ content, mode }) => {
       deps.setNotebook(content, mode ?? "replace");
@@ -6286,15 +7645,16 @@ function updateNotebookTool(deps) {
 }
 
 // src/services/tools/inquire.ts
-import { z as z19 } from "zod";
+import { z as z21 } from "zod";
 function inquireTool(deps) {
   return defineTool({
-    description: "Ask the user a structured question and wait for their response. Use this to clarify ambiguous requests, confirm approach, or let the user choose between options. The tool blocks until the user answers.",
-    parameters: z19.object({
-      message: z19.string().describe("Question to ask the user"),
-      type: z19.enum(["confirm", "select", "text"]).describe('Question type: "confirm" for yes/no, "select" for choosing from options, "text" for free-form input'),
-      options: z19.array(z19.string()).optional().describe('Available choices (required for "select" type)'),
-      default: z19.string().optional().describe("Default value or pre-selected option")
+    description: 'Ask the user a structured question and wait for their response. Use this to clarify ambiguous requests, confirm approach, or let the user choose between options. The tool blocks until the user answers. For "select" questions an "Other" choice is appended automatically so the user can always answer outside the preset options \u2014 do not add your own catch-all option. Answers typed via "Other" come back prefixed with "[Other] ".',
+    parameters: z21.object({
+      message: z21.string().describe("Question to ask the user"),
+      type: z21.enum(["confirm", "select", "text"]).describe('Question type: "confirm" for yes/no, "select" for choosing from options, "text" for free-form input'),
+      options: z21.array(z21.string()).optional().describe('Available choices (required for "select" type). Provide 2-5 clear preset options \u2014 an "Other" choice for free-form input is appended automatically'),
+      default: z21.string().optional().describe("Default value or pre-selected option"),
+      allowOther: z21.boolean().optional().describe('"select" only: append an "Other" choice letting the user type a custom answer (default true). Set false to restrict answers to the preset options')
     }),
     execute: safeExecute("inquire", async (args) => {
       return deps.inquire(args);
@@ -6303,12 +7663,12 @@ function inquireTool(deps) {
 }
 
 // src/services/tools/done.ts
-import { z as z20 } from "zod";
+import { z as z22 } from "zod";
 function doneTool(deps) {
   return defineTool({
     description: "Report task completion. Worker stops executing after this call.",
-    parameters: z20.object({
-      summary: z20.string().describe("Task completion summary")
+    parameters: z22.object({
+      summary: z22.string().describe("Task completion summary")
     }),
     execute: safeExecute("done", async ({ summary }) => {
       deps.onComplete(summary);
@@ -6318,12 +7678,12 @@ function doneTool(deps) {
 }
 
 // src/services/tools/fail.ts
-import { z as z21 } from "zod";
+import { z as z23 } from "zod";
 function failTool(deps) {
   return defineTool({
     description: "Report task failure. Worker stops executing after this call.",
-    parameters: z21.object({
-      error: z21.string().describe("Error description")
+    parameters: z23.object({
+      error: z23.string().describe("Error description")
     }),
     execute: safeExecute("fail", async ({ error }) => {
       deps.onFail(error);
@@ -6333,13 +7693,13 @@ function failTool(deps) {
 }
 
 // src/services/tools/update-progress.ts
-import { z as z22 } from "zod";
+import { z as z24 } from "zod";
 function updateProgressTool(deps) {
   return defineTool({
     description: "Report progress for the current task (replaces automatic step-based progress)",
-    parameters: z22.object({
-      message: z22.string().describe("Progress description"),
-      percent: z22.number().min(0).max(100).optional().describe("Completion percentage (0-100)")
+    parameters: z24.object({
+      message: z24.string().describe("Progress description"),
+      percent: z24.number().min(0).max(100).optional().describe("Completion percentage (0-100)")
     }),
     execute: safeExecute("update_progress", async ({ message, percent }) => {
       deps.reportProgress(message, percent);
@@ -6350,21 +7710,24 @@ function updateProgressTool(deps) {
 }
 
 // src/services/tools/chat-worker.ts
-import { z as z23 } from "zod";
+import { z as z25 } from "zod";
 function chatWorkerTool(deps) {
   return defineTool({
-    description: "Send a message to a running worker. Use this to provide additional guidance, correct the worker's approach, or ask the worker to check something. The worker reads it at its next step (puppet) or turn boundary (third-party); idle multi-stage workers read it when their next stage starts.",
-    parameters: z23.object({
-      workerId: z23.string().describe("ID of the target worker"),
-      message: z23.string().describe("Message to send to the worker")
+    description: `Send a message to a running worker. Use this to provide additional guidance, correct the worker's approach, or ask the worker to check something. The worker reads it at its next step (puppet) or turn boundary (third-party); idle multi-stage workers read it when their next stage starts. A third-party worker NEVER acts on the message mid-tool-call: it finishes the current turn first, so "queued" can mean a delay of minutes. If the worker has already finished, this tool fails explicitly \u2014 inspect its output instead.`,
+    parameters: z25.object({
+      workerId: z25.string().describe("ID of the target worker"),
+      message: z25.string().describe("Message to send to the worker")
     }),
     execute: safeExecute("chat_worker", async ({ workerId, message }) => {
       const status = deps.sendMessageToWorker(workerId, message);
       if (status === "not_running") {
-        return `[ERROR] Worker ${workerId} is not running (it may have just finished).`;
+        return `[ERROR] Worker ${workerId} is not running (it may have just finished). Use get_worker_status("${workerId}") or read_worker_conversation("${workerId}") to inspect what it produced.`;
+      }
+      if (status === "finished") {
+        return `[ERROR] Worker ${workerId} has already finished; message not delivered. Use read_worker_conversation("${workerId}") / get_task_detail to inspect its output.`;
       }
       if (status === "queued") {
-        return `Message queued for worker ${workerId} \u2014 it will be read when the current turn ends or the next stage starts.`;
+        return `Message queued for worker ${workerId} \u2014 QUEUED only, not delivered yet: the worker reads it at its next step (puppet), turn boundary (third-party \u2014 the current turn, including any running tool call, finishes first) or next stage start (idle). A stuck worker will never reach that point. Verify with get_worker_status("${workerId}") (lastActivityAt / currentTool); if it looks stuck, use cancel_task instead of waiting for this message.`;
       }
       return `Message delivered to worker ${workerId} \u2014 it will be read at the worker's next step.`;
     })
@@ -6372,14 +7735,14 @@ function chatWorkerTool(deps) {
 }
 
 // src/services/tools/respond-permission.ts
-import { z as z24 } from "zod";
+import { z as z26 } from "zod";
 function respondPermissionTool(deps) {
   return defineTool({
     description: "Respond to a worker's permission request. Approve to allow the operation, deny to reject it.",
-    parameters: z24.object({
-      requestId: z24.string().describe("The request ID from the permission_request signal"),
-      approved: z24.boolean().describe("true to approve, false to deny"),
-      reason: z24.string().optional().describe("Reason for denial (shown to worker)")
+    parameters: z26.object({
+      requestId: z26.string().describe("The request ID from the permission_request signal"),
+      approved: z26.boolean().describe("true to approve, false to deny"),
+      reason: z26.string().optional().describe("Reason for denial (shown to worker)")
     }),
     execute: safeExecute("respond_permission", async ({ requestId, approved, reason }) => {
       const handled = deps.respondPermission(requestId, approved, reason);
@@ -6390,13 +7753,13 @@ function respondPermissionTool(deps) {
 }
 
 // src/services/tools/respond-inquiry.ts
-import { z as z25 } from "zod";
+import { z as z27 } from "zod";
 function respondInquiryTool(deps) {
   return defineTool({
     description: "Answer a worker's question (from a worker_inquiry signal). The blocked worker resumes with your answer as the tool result. If the decision belongs to the user, ask them first via inquire, then answer here.",
-    parameters: z25.object({
-      inquiryId: z25.string().describe("The inquiryId from the worker_inquiry signal"),
-      answer: z25.string().max(4e3).describe("The answer/instruction for the worker. Self-contained \u2014 the worker sees only this text.")
+    parameters: z27.object({
+      inquiryId: z27.string().describe("The inquiryId from the worker_inquiry signal"),
+      answer: z27.string().max(4e3).describe("The answer/instruction for the worker. Self-contained \u2014 the worker sees only this text.")
     }),
     execute: safeExecute("respond_inquiry", async ({ inquiryId, answer }) => {
       const status = deps.respondInquiry(inquiryId, answer);
@@ -6412,7 +7775,7 @@ function respondInquiryTool(deps) {
 }
 
 // src/services/tools/use-skill.ts
-import { z as z26 } from "zod";
+import { z as z28 } from "zod";
 function formatSkillContent(skill) {
   const header = `# Skill: ${skill.name}
 
@@ -6434,8 +7797,8 @@ ${skill.content}${resources}`;
 function useSkillTool(deps) {
   return defineTool({
     description: `Load a skill's full instructions by name. Skills are on-demand expertise (workflows, conventions, scripts). Use this when a task matches a skill in the "Skills" section. Returns the skill body plus a list of its resource files (invoke those with your shell/file tools, not here).`,
-    parameters: z26.object({
-      name: z26.string().describe('Skill name, exactly as shown in the "Skills" section')
+    parameters: z28.object({
+      name: z28.string().describe('Skill name, exactly as shown in the "Skills" section')
     }),
     execute: safeExecute("use-skill", async ({ name }) => {
       const content = deps.registry.get(name);
@@ -6467,7 +7830,26 @@ function createControllerTools(deps) {
     }),
     get_task_detail: getTaskDetailTool({
       getTask: deps.getTask,
-      getWorkerConversation: deps.getWorkerConversation
+      getWorkerConversation: deps.getWorkerConversation,
+      readTranscriptWindow: deps.readTranscriptWindow
+    }),
+    read_worker_conversation: readWorkerConversationTool({
+      sessionDir: deps.sessionDir,
+      getWorkerConversationByWorkerId: deps.getWorkerConversationByWorkerId,
+      getWorkerTranscriptId: deps.getWorkerTranscriptId,
+      readTranscriptWindow: (workerId, opts) => {
+        const reader = deps.readTranscriptWindow;
+        if (!reader) throw new Error("readTranscriptWindow dep not wired");
+        return reader(workerId, opts);
+      },
+      listWorkers: () => deps.getActiveWorkers?.() ?? [],
+      listTasks: () => deps.listTasks()
+    }),
+    get_worker_status: getWorkerStatusTool({
+      listWorkers: () => deps.getActiveWorkers?.() ?? [],
+      listTasks: () => deps.listTasks(),
+      readTranscript: deps.readTranscript,
+      getLiveStatus: deps.getWorkerLiveStatus
     }),
     update_task: updateTaskTool({ updateTask: deps.updateTask }),
     query_signals: querySignalsTool({ querySignals: deps.queryMessages }),
@@ -6507,13 +7889,13 @@ function createWorkerTools(deps) {
 }
 
 // src/services/tools/ask-controller.ts
-import { z as z27 } from "zod";
+import { z as z29 } from "zod";
 function askControllerTool(deps) {
   return defineTool({
     description: "Ask the controller a question and WAIT for the answer. Use ONLY when you are blocked: execution cannot continue as instructed (contradiction, missing resource, unexpected state), or continuing would risk significant wasted work. Do NOT use it for decisions you can make yourself \u2014 decide those autonomously and report via update_progress / done.",
-    parameters: z27.object({
-      question: z27.string().max(500).describe("The specific question you need answered to proceed. Be concise and self-contained."),
-      context: z27.string().max(1e3).optional().describe("What you have tried and where you are stuck, so the controller can answer precisely.")
+    parameters: z29.object({
+      question: z29.string().max(500).describe("The specific question you need answered to proceed. Be concise and self-contained."),
+      context: z29.string().max(1e3).optional().describe("What you have tried and where you are stuck, so the controller can answer precisely.")
     }),
     execute: safeExecute("ask_controller", async ({ question, context }) => {
       return deps.ask(question, context);
@@ -6555,16 +7937,16 @@ function wrapWithPermissionMiddleware(tools, config, deps) {
           },
           ...deps.turnLineage ?? {}
         });
-        const result = await new Promise((resolve11) => {
+        const result = await new Promise((resolve12) => {
           const timer = setTimeout(() => {
             pending.delete(requestId);
-            resolve11({ approved: false, reason: "timeout" });
+            resolve12({ approved: false, reason: "timeout" });
           }, timeoutMs);
           pending.set(requestId, {
             resolve: (ok, reason) => {
               clearTimeout(timer);
               pending.delete(requestId);
-              resolve11({ approved: ok, reason });
+              resolve12({ approved: ok, reason });
             },
             timer
           });
@@ -6601,14 +7983,14 @@ function wrapWithPermissionMiddleware(tools, config, deps) {
 }
 
 // src/services/tools/permission-rules.ts
-import { resolve as resolve7 } from "path";
+import { resolve as resolve8 } from "path";
 import { homedir } from "os";
 var FILE_TOOL_NAMES = ["read_file", "write_file", "edit_file", "search_files", "search_content"];
 var DANGEROUS_BASH_PATTERN = /(?:^|\||;|&&)\s*(?:rm\s|sudo\b|chmod\b|chown\b|mkfs\b|dd\s|shutdown\b|reboot\b|kill\s+-9)/;
 var URL_RE = /[a-zA-Z][a-zA-Z0-9+.-]*:\/\/\S+/g;
 function expandHome(p) {
   if (p === "~") return homedir();
-  if (p.startsWith("~/")) return resolve7(homedir(), p.slice(2));
+  if (p.startsWith("~/")) return resolve8(homedir(), p.slice(2));
   return p;
 }
 function extractPathCandidates(command) {
@@ -6623,7 +8005,7 @@ function extractPathCandidates(command) {
 function needsFilePermission(workspace, args) {
   const rawPath = args.path;
   if (typeof rawPath !== "string" || !rawPath) return false;
-  return !isInsideWorkspace(resolve7(workspace, expandHome(rawPath)), workspace);
+  return !isInsideWorkspace(resolve8(workspace, expandHome(rawPath)), workspace);
 }
 function needsBashPermission(workspace, command) {
   if (DANGEROUS_BASH_PATTERN.test(command)) return true;
@@ -6673,7 +8055,7 @@ function formatApiCallError(err) {
 }
 
 // src/services/task-execute-engine.ts
-import { resolve as resolve8 } from "path";
+import { resolve as resolve9 } from "path";
 var RuntimeState = class extends BaseWayangState {
   constructor(initialData) {
     super(initialData, []);
@@ -6885,14 +8267,16 @@ var TaskExecuteEngine = class {
    * Send a message to a worker. Delivery is judged by the activeWorkers
    * runtime state — NOT by the workers Map, which lingers one tick past
    * disposal (removeWorkerTracking defers) and would accept messages for a
-   * worker that is already gone.
+   * worker that is already gone. A worker that rejects the message (its run
+   * can no longer take input) is reported as 'finished' — never a fake
+   * 'queued'.
    */
   sendMessageToWorker(workerId, message) {
     const info = this.getActiveWorkers().find((w) => w.workerId === workerId);
     if (!info) return "not_running";
     const worker = this.workers.get(workerId);
     if (!worker) return "not_running";
-    worker.acceptMessage(message);
+    if (!worker.acceptMessage(message)) return "finished";
     if (info.status === "idle") return "queued";
     return worker instanceof WorkerAgent ? "delivered" : "queued";
   }
@@ -6948,6 +8332,24 @@ var TaskExecuteEngine = class {
       }
     });
   }
+  /**
+   * Live run flags of a worker instance — "has the result arrived?" and "has
+   * the stream closed?" (issue #16). Returns undefined for workers that do not
+   * report them or are no longer tracked.
+   */
+  getWorkerLiveStatus(workerId) {
+    return this.workers.get(workerId)?.getLiveStatus?.();
+  }
+  /**
+   * Per-worker activity derived from the in-memory conversation: when it last
+   * produced an entry, and which tool it called last. Fed into heartbeat
+   * signals so the controller can spot a stall without calling a tool.
+   */
+  getWorkerActivity(workerId) {
+    const entries = this.workers.get(workerId)?.getConversation() ?? [];
+    const summary = summarizeTranscript(entries);
+    return { lastActivityAt: summary.lastActivityAt, currentTool: summary.currentTool };
+  }
   getWorkerConversation(taskId) {
     for (const [workerId, tId] of this.workerTaskMap) {
       if (tId === taskId) {
@@ -6957,6 +8359,25 @@ var TaskExecuteEngine = class {
     }
     return [];
   }
+  /**
+   * Live in-memory conversation of a worker looked up by worker id (not task
+   * id). Undefined once the worker is no longer tracked — the on-disk
+   * transcript (via the task's workerTranscriptId) takes over then.
+   */
+  getWorkerConversationByWorkerId(workerId) {
+    const worker = this.workers.get(workerId);
+    return worker === void 0 ? void 0 : worker.getConversation();
+  }
+  /**
+   * The worker instance's OWN id (agent-…/cw-…) — the directory name under
+   * `<sessionDir>/workers/` where its conversation.jsonl lives. Distinct from
+   * the engine worker id (w-…) used in tasks/signals. Only resolvable while
+   * the engine tracks the worker; afterwards the task's persisted
+   * `workerTranscriptId` is the source of truth.
+   */
+  getWorkerTranscriptId(workerId) {
+    return this.workers.get(workerId)?.id;
+  }
   getRunningCount() {
     return this.taskState.get("tasks.running").length;
   }
@@ -7113,6 +8534,20 @@ var TaskExecuteEngine = class {
     this.taskState.append("tasks.running", updated);
     this.logger.info({ taskId: id, workerId: workerSessionId }, "Task moved to running");
   }
+  /**
+   * Record the worker instance's own id (the on-disk transcript directory
+   * name) on the running task. Called right after the worker instance is
+   * created, before its run starts, so the link is on disk even if the
+   * process crashes mid-run.
+   */
+  stampWorkerTranscriptId(taskId, transcriptId) {
+    const running = [...this.taskState.get("tasks.running")];
+    const idx = running.findIndex((t) => t.id === taskId);
+    if (idx === -1) return;
+    if (running[idx].workerTranscriptId === transcriptId) return;
+    running[idx] = { ...running[idx], workerTranscriptId: transcriptId };
+    this.taskState.set("tasks.running", running);
+  }
   completeTask(id, result) {
     this.moveToHistory(id, "completed", { result });
     this.logger.info({ taskId: id }, "Task completed");
@@ -7250,6 +8685,7 @@ var TaskExecuteEngine = class {
     const worker = this.createWorker(workerType);
     this.workers.set(workerId, worker);
     this.workerTaskMap.set(workerId, task.id);
+    this.stampWorkerTranscriptId(task.id, worker.id);
     const executionTurnId = this.registerWorkerTurn(workerId, task);
     const onProgress = this.buildProgressEmitter(workerId, task, workerType);
     const tools = this.wireWorker(worker, task, workerId, workerType);
@@ -7280,7 +8716,9 @@ var TaskExecuteEngine = class {
       assignedFromWorkerId: workerId,
       status: "running",
       startedAt: Date.now(),
-      workerSessionId: workerId
+      workerSessionId: workerId,
+      // Same instance keeps writing the same conversation.jsonl.
+      workerTranscriptId: worker.id
     };
     this.taskState.append("tasks.running", taskWithOrigin);
     this.workerTaskMap.set(workerId, task.id);
@@ -7308,10 +8746,22 @@ var TaskExecuteEngine = class {
   buildProgressEmitter(workerId, task, workerType) {
     const meta = getWorkerMeta(workerType, this.workerConfigs);
     return (msg) => {
+      const activity = this.getWorkerActivity(workerId);
       this.enqueueWorkerSignal(workerId, {
         source: "worker",
         type: "progress",
-        payload: { workerId, taskId: task.id, taskTitle: task.title, workerType, emoji: meta.emoji, message: msg }
+        payload: {
+          workerId,
+          taskId: task.id,
+          taskTitle: task.title,
+          workerType,
+          emoji: meta.emoji,
+          message: msg,
+          // Activity rides along (issue #16) so the controller sees liveness
+          // from the signal itself instead of polling.
+          lastActivityAt: activity.lastActivityAt,
+          currentTool: activity.currentTool
+        }
       });
     };
   }
@@ -7361,10 +8811,20 @@ var TaskExecuteEngine = class {
         tavilyApiKey: this.ctx.config.tavilyApiKey,
         registry: this.skills,
         reportProgress: (msg, _percent) => {
+          const activity = this.getWorkerActivity(workerId);
           this.enqueueWorkerSignal(workerId, {
             source: "worker",
             type: "progress",
-            payload: { workerId, taskId: task.id, taskTitle: task.title, workerType, emoji: workerMeta.emoji, message: msg }
+            payload: {
+              workerId,
+              taskId: task.id,
+              taskTitle: task.title,
+              workerType,
+              emoji: workerMeta.emoji,
+              message: msg,
+              lastActivityAt: activity.lastActivityAt,
+              currentTool: activity.currentTool
+            }
           });
         },
         onComplete: (summary) => {
@@ -7396,7 +8856,7 @@ var TaskExecuteEngine = class {
           if (toolName === "bash") return `Execute shell command: ${args.command}`;
           if (FILE_TOOL_NAMES.includes(toolName)) {
             const rawPath = typeof args.path === "string" ? args.path : "";
-            const resolved = rawPath ? resolve8(workspace, rawPath) : workspace;
+            const resolved = rawPath ? resolve9(workspace, rawPath) : workspace;
             return `${toolName}: ${rawPath || "(workspace root)"} (resolved: ${resolved})`;
           }
           return `${toolName}: ${JSON.stringify(args)}`;
@@ -7556,7 +9016,7 @@ var ControllerLoop = class {
     this.signalQueue = signalQueue;
     this.controllerAgent = controllerAgent;
     this.heartbeatProvider = heartbeatProvider;
-    this.heartbeatIntervalMs = options?.heartbeatIntervalMs ?? 3e4;
+    this.heartbeatIntervalMs = options?.heartbeatIntervalMs ?? 6e4;
   }
   ctx;
   signalQueue;
@@ -7632,13 +9092,21 @@ var ControllerLoop = class {
       payload: {
         reason: "Workers are running but no signals for a while. Review status and decide if action is needed.",
         idleSinceMs: now - lastWakeAt,
-        workers: activeWorkers.map((w) => ({
-          workerId: w.workerId,
-          taskId: w.taskId,
-          taskTitle: w.taskTitle,
-          workerType: w.workerType,
-          runningForMs: now - w.startedAt
-        })),
+        workers: activeWorkers.map((w) => {
+          const activity = this.heartbeatProvider.getWorkerActivity?.(w.workerId);
+          return {
+            workerId: w.workerId,
+            taskId: w.taskId,
+            taskTitle: w.taskTitle,
+            workerType: w.workerType,
+            runningForMs: now - w.startedAt,
+            ...activity ? {
+              lastActivityAt: activity.lastActivityAt,
+              lastActivityAgoMs: activity.lastActivityAt === null ? null : Math.max(0, now - activity.lastActivityAt),
+              currentTool: activity.currentTool
+            } : {}
+          };
+        }),
         pendingTaskCount: this.heartbeatProvider.getPendingCount()
       }
     });
@@ -7655,11 +9123,11 @@ var ControllerLoop = class {
 import * as path5 from "path";
 
 // src/services/session/session-state.ts
-import { join as join8 } from "path";
+import { join as join10 } from "path";
 var SessionState = class extends BaseWayangState {
   jsonFile;
   constructor(sessionDir) {
-    const jsonFile = new JSONFileHelper(join8(sessionDir, "meta.json"));
+    const jsonFile = new JSONFileHelper(join10(sessionDir, "meta.json"));
     super(
       {
         meta: {
@@ -7765,7 +9233,7 @@ var SessionManager = class _SessionManager {
 };
 
 // src/services/agents/controller-state.ts
-import { join as join10 } from "path";
+import { join as join12 } from "path";
 
 // src/services/conversation/conversation-index.ts
 function emptyUsage() {
@@ -7986,8 +9454,8 @@ var ControllerAgentState = class extends BaseWayangState {
   /** In-memory resolve function for the current inquiry — never persisted. */
   inquiryResolver = null;
   constructor(ctx) {
-    const jsonFile = new JSONFileHelper(join10(ctx.sessionDir, "runtime-state.json"));
-    const jsonlFile = new JSONLFileHelper(join10(ctx.sessionDir, "conversation.jsonl"));
+    const jsonFile = new JSONFileHelper(join12(ctx.sessionDir, "runtime-state.json"));
+    const jsonlFile = new JSONLFileHelper(join12(ctx.sessionDir, "conversation.jsonl"));
     const initialData = {
       runtimeState: {
         session: { id: "", startedAt: 0 },
@@ -8062,8 +9530,8 @@ var ControllerAgentState = class extends BaseWayangState {
   }
   /** Set a pending inquiry and return a Promise that resolves when the user answers. */
   askInquiry(question) {
-    return new Promise((resolve11) => {
-      this.inquiryResolver = resolve11;
+    return new Promise((resolve12) => {
+      this.inquiryResolver = resolve12;
       this.set("runtimeState.pendingInquiry", question);
     });
   }
@@ -8223,6 +9691,19 @@ var ControllerAgent = class _ControllerAgent extends BaseAgent {
       listTasks: (status) => engine.list(status),
       getTask: (taskId) => engine.get(taskId),
       getWorkerConversation: (taskId) => engine.getWorkerConversation(taskId),
+      // On-disk transcript access (issue #16): survives worker disposal, so a
+      // finished/cancelled worker's scene stays readable by the controller.
+      readTranscript: (workerId) => readWorkerTranscript(ctx.sessionDir, workerId),
+      // Layered transcript access (issue #16 review): while the engine tracks
+      // the worker, its live in-memory conversation is the source; the on-disk
+      // jsonl lives under the worker instance's OWN id (agent-/cw-…), which
+      // the engine exposes and tasks persist as workerTranscriptId.
+      getWorkerConversationByWorkerId: (workerId) => engine.getWorkerConversationByWorkerId(workerId),
+      getWorkerTranscriptId: (workerId) => engine.getWorkerTranscriptId(workerId),
+      readTranscriptWindow: (workerId, opts2) => readWorkerTranscriptWindow(ctx.sessionDir, workerId, opts2),
+      sessionDir: ctx.sessionDir,
+      getActiveWorkers: () => engine.getActiveWorkers(),
+      getWorkerLiveStatus: (workerId) => engine.getWorkerLiveStatus(workerId),
       cancelTask: (taskId) => engine.cancel(taskId),
       abortWorker: (taskId) => engine.abortByTaskId(taskId),
       updateTask: (taskId, updates) => engine.updatePending(taskId, updates),
@@ -8522,6 +10003,14 @@ function isoMs(ms) {
   if (typeof ms !== "number" || !Number.isFinite(ms)) return void 0;
   return new Date(ms).toISOString();
 }
+function signalActivityTail(currentTool, lastActivityAt) {
+  const parts = [];
+  if (currentTool) parts.push(`tool=${currentTool}`);
+  if (typeof lastActivityAt === "number" && Number.isFinite(lastActivityAt)) {
+    parts.push(`lastEntry=${new Date(lastActivityAt).toISOString().replace(/\.\d{3}Z$/, "Z")}`);
+  }
+  return parts.length > 0 ? `[activity: ${parts.join(", ")}]` : null;
+}
 var signalConverters = {
   input: (sig, ts, sessionId) => ({
     type: "user" /* User */,
@@ -8563,6 +10052,7 @@ var signalConverters = {
   },
   progress: (sig, ts, sessionId) => {
     const p = sig.payload;
+    const activity = signalActivityTail(p.currentTool, p.lastActivityAt);
     return {
       ...signalBase(ts, sessionId),
       subtype: "worker_progress" /* WorkerProgress */,
@@ -8571,12 +10061,17 @@ var signalConverters = {
       emoji: p.emoji,
       taskId: p.taskId,
       taskTitle: p.taskTitle,
-      content: p.message
+      content: activity ? `${p.message}
+${activity}` : p.message
     };
   },
   heartbeat: (sig, ts, sessionId) => {
     const p = sig.payload;
-    const workerSummary = p.workers.map((w) => `${w.taskTitle} (${w.workerType}, running ${Math.round(w.runningForMs / 1e3)}s)`).join(", ");
+    const workerSummary = p.workers.map((w) => {
+      const tool2 = w.currentTool ? `, tool ${w.currentTool}` : "";
+      const idle = w.lastActivityAgoMs !== null && w.lastActivityAgoMs !== void 0 ? `, last activity ${Math.round(w.lastActivityAgoMs / 1e3)}s ago` : "";
+      return `${w.taskTitle} [${w.workerId}] (${w.workerType}, running ${Math.round(w.runningForMs / 1e3)}s${tool2}${idle})`;
+    }).join(", ");
     return {
       ...signalBase(ts, sessionId),
       subtype: "heartbeat" /* Heartbeat */,
@@ -8739,8 +10234,8 @@ function signalToEntry(sig, ts, sessionId) {
 }
 
 // src/services/skills/registry.ts
-import { readFileSync as readFileSync8, readdirSync as readdirSync2, statSync } from "fs";
-import { join as join11 } from "path";
+import { readFileSync as readFileSync9, readdirSync as readdirSync2, statSync as statSync3 } from "fs";
+import { join as join13 } from "path";
 import { parse as parseYaml } from "yaml";
 var SKILL_FILE = "SKILL.md";
 function parseFrontmatter(raw) {
@@ -8775,7 +10270,7 @@ function listResources(skillDir) {
   const walk = (relDir) => {
     let entries;
     try {
-      entries = readdirSync2(join11(skillDir, relDir), { withFileTypes: true });
+      entries = readdirSync2(join13(skillDir, relDir), { withFileTypes: true });
     } catch {
       return;
     }
@@ -8822,10 +10317,10 @@ var SkillRegistry = class {
     if (existing) return existing;
     const desc = this.descriptors.get(name);
     if (!desc) return void 0;
-    const filePath = join11(desc.dir, SKILL_FILE);
+    const filePath = join13(desc.dir, SKILL_FILE);
     let raw;
     try {
-      raw = readFileSync8(filePath, "utf-8");
+      raw = readFileSync9(filePath, "utf-8");
     } catch (err) {
       this.logger?.warn({ skill: name, error: err instanceof Error ? err.message : String(err) }, "Failed to read skill file");
       return void 0;
@@ -8853,8 +10348,8 @@ var SkillRegistry = class {
     for (const entry of entries) {
       if (!entry.isDirectory()) continue;
       if (entry.name.startsWith(".") || entry.name === "node_modules") continue;
-      const skillDir = join11(dir, entry.name);
-      const skillFile = join11(skillDir, SKILL_FILE);
+      const skillDir = join13(dir, entry.name);
+      const skillFile = join13(skillDir, SKILL_FILE);
       if (!existsAsFile(skillFile)) continue;
       const { frontmatter } = safeReadFrontmatter(skillFile);
       const description = asString(frontmatter.description);
@@ -8869,35 +10364,35 @@ var SkillRegistry = class {
 };
 function existsAsFile(path7) {
   try {
-    return statSync(path7).isFile();
+    return statSync3(path7).isFile();
   } catch {
     return false;
   }
 }
 function safeReadFrontmatter(path7) {
   try {
-    return parseFrontmatter(readFileSync8(path7, "utf-8"));
+    return parseFrontmatter(readFileSync9(path7, "utf-8"));
   } catch {
     return { frontmatter: {}, body: "" };
   }
 }
 
 // src/services/skills/skill-dir.ts
-import { existsSync as existsSync6 } from "fs";
+import { existsSync as existsSync8 } from "fs";
 import { homedir as homedir2 } from "os";
-import { join as join12, resolve as resolve9 } from "path";
+import { join as join14, resolve as resolve10 } from "path";
 function resolveSkillDirs(workspaceDir2, configDirs) {
   const candidates = [
-    join12(homedir2(), ".wayang", "skills"),
-    join12(workspaceDir2, ".wayang", "skills"),
-    ...(configDirs ?? []).map((d) => resolve9(d))
+    join14(homedir2(), ".wayang", "skills"),
+    join14(workspaceDir2, ".wayang", "skills"),
+    ...(configDirs ?? []).map((d) => resolve10(d))
   ];
   const seen = /* @__PURE__ */ new Set();
   const dirs = [];
   for (const dir of candidates) {
     if (seen.has(dir)) continue;
     seen.add(dir);
-    if (existsSync6(dir)) dirs.push(dir);
+    if (existsSync8(dir)) dirs.push(dir);
   }
   return dirs;
 }
@@ -8956,7 +10451,8 @@ var Supervisor = class {
       {
         getRunningCount: () => this.engine.getRunningCount(),
         getActiveWorkers: () => this.engine.getActiveWorkers(),
-        getPendingCount: () => this.engine.list("pending").length
+        getPendingCount: () => this.engine.list("pending").length,
+        getWorkerActivity: (workerId) => this.engine.getWorkerActivity(workerId)
       }
     );
   }
@@ -9245,8 +10741,11 @@ async function runWayangServer(options, io = process) {
     return { status };
   });
   rpc.register(METHOD.CHAT_WORKER, (params) => {
-    supervisor.engine.sendMessageToWorker(requiredString(params, "workerId"), requiredString(params, "message"));
-    return {};
+    const status = supervisor.engine.sendMessageToWorker(
+      requiredString(params, "workerId"),
+      requiredString(params, "message")
+    );
+    return { status };
   });
   rpc.register(METHOD.DISPOSE_WORKER, (params) => {
     supervisor.engine.abortByWorkerId(requiredString(params, "workerId"));