wayang-ai 0.5.0 → 0.5.1

package/dist/cli.js

@@ -156,7 +156,11 @@ var METHOD = {
   GET_SNAPSHOT: "get_snapshot",
   SUBSCRIBE: "subscribe",
   UNSUBSCRIBE: "unsubscribe",
-  SHUTDOWN: "shutdown"
+  SHUTDOWN: "shutdown",
+  /** Read-only: list turns of the controller conversation (limit/offset). */
+  CONVERSATION_LIST_TURNS: "conversation_list_turns",
+  /** Read-only: one turn of the controller conversation by turnId. */
+  CONVERSATION_GET_TURN: "conversation_get_turn"
 };
 var NOTIFY = {
   READY: "ready",
@@ -819,14 +823,8 @@ function ToolResultRow({ section: section2 }) {
 import { Box as Box3, Text as Text3 } from "ink";
 
 // src/types/conversation.ts
-function isSystemEntry(entry) {
-  return entry.type === "system" /* System */;
-}
-function getEntryContent(entry) {
-  if (entry.type === "signal" /* Signal */ || entry.type === "system" /* System */) {
-    return entry.content;
-  }
-  return entry.message.content;
+function isCompactMarker(entry) {
+  return entry.type === "system" /* System */ && entry.subtype === "compact" /* Compact */ && entry.compactMeta !== void 0;
 }
 
 // src/tui/components/chat-area/signal-row.tsx
@@ -868,12 +866,19 @@ function SignalRow({ item }) {
 // src/tui/components/chat-area/system-row.tsx
 import { Box as Box4, Text as Text4 } from "ink";
 import { jsx as jsx5, jsxs as jsxs4 } from "react/jsx-runtime";
+function isCompactSystemItem(item) {
+  return item.subtype === "compact" /* Compact */ && item.compactMeta !== void 0;
+}
 function SystemRow({ item }) {
-  const isError = item.subtype === "error";
-  const isCompact = item.subtype === "compact";
+  const isError = item.subtype === "error" /* Error */;
+  const isCompact = isCompactSystemItem(item);
+  const isTaskResult = item.subtype === "task_result" /* TaskResult */;
   if (isCompact) {
     return /* @__PURE__ */ jsx5(Box4, { children: /* @__PURE__ */ jsx5(Text4, { dimColor: true, children: "\u224B Conversation has been compacted" }) });
   }
+  if (isTaskResult) {
+    return /* @__PURE__ */ jsx5(Box4, { children: /* @__PURE__ */ jsx5(Text4, { dimColor: true, children: item.content }) });
+  }
   return /* @__PURE__ */ jsxs4(Box4, { children: [
     /* @__PURE__ */ jsxs4(Text4, { color: isError ? theme.baseToken.color.error : theme.meta.color, children: [
       isError ? "\u2718" : theme.meta.prefix,
@@ -1396,7 +1401,7 @@ function entryToDisplayItem(entry) {
     case "signal" /* Signal */:
       return { ...base, role: "signal", subtype: entry.subtype, content: entry.content, taskId: entry.taskId, taskTitle: entry.taskTitle, workerId: entry.workerId, workerType: entry.workerType, emoji: entry.emoji };
     case "system" /* System */:
-      return { ...base, role: "system", subtype: entry.subtype, content: entry.content };
+      return { ...base, role: "system", subtype: entry.subtype, content: entry.content, compactMeta: entry.compactMeta };
   }
 }
 var signalSubtypeMap = {
@@ -1404,7 +1409,8 @@ var signalSubtypeMap = {
   failed: "worker_failed" /* WorkerFailed */,
   progress: "worker_progress" /* WorkerProgress */,
   heartbeat: "heartbeat" /* Heartbeat */,
-  cancelled: "worker_failed" /* WorkerFailed */
+  cancelled: "worker_failed" /* WorkerFailed */,
+  task_cancelled: "task_cancelled" /* TaskCancelled */
 };
 function signalToDisplayItem(signal) {
   const base = {
@@ -1570,7 +1576,7 @@ function AppContent() {
 // package.json
 var package_default = {
   name: "wayang-ai",
-  version: "0.5.0",
+  version: "0.5.1",
   description: "Multi-agent orchestration platform",
   type: "module",
   license: "MIT",
@@ -2034,6 +2040,21 @@ import { join as join5 } from "path";
 
 // src/infra/state/base-state.ts
 import { get, set, cloneDeep } from "lodash-es";
+
+// src/infra/state/conversation-envelope.ts
+var ENVELOPE_VERSION = 1;
+function applyAppendEnvelope(entry, conversation) {
+  if (entry === null || typeof entry !== "object") return entry;
+  if (entry.v === void 0) entry.v = ENVELOPE_VERSION;
+  if (entry.parentId === void 0) {
+    const last = conversation.length > 0 ? conversation[conversation.length - 1] : void 0;
+    const lastIsMarker = last !== null && typeof last === "object" && isCompactMarker(last);
+    entry.parentId = !last || lastIsMarker || isCompactMarker(entry) || typeof last.uuid !== "string" ? null : last.uuid;
+  }
+  return entry;
+}
+
+// src/infra/state/base-state.ts
 var BaseWayangState = class {
   data;
   persistMappings;
@@ -2069,9 +2090,10 @@ var BaseWayangState = class {
     if (!Array.isArray(arr)) {
       throw new Error(`State.append: path "${path7}" is not an array`);
     }
-    arr.push(entry);
+    const stamped = path7 === "conversation" ? applyAppendEnvelope(entry, arr) : entry;
+    arr.push(stamped);
     set(this.data, path7, [...arr]);
-    this.persist(path7, "append", entry);
+    this.persist(path7, "append", stamped);
     this.notify(path7, "append", void 0);
   }
   remove(path7, idx) {
@@ -2714,6 +2736,18 @@ function formatTimestamp(date = /* @__PURE__ */ new Date()) {
   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/base-agent.ts
 var BaseAgent = class {
   id;
@@ -2742,9 +2776,18 @@ var BaseAgent = class {
       }
     }
     let startTime;
+    let firstChunkAt;
+    let stepStartedAt;
+    const onStep = opts.onStep ? (event) => {
+      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();
       stream = streamText({
         model: this.model,
         system: opts.system,
@@ -2753,7 +2796,7 @@ var BaseAgent = class {
         toolChoice: opts.toolChoice,
         stopWhen: stopConditions.length > 0 ? stopConditions : void 0,
         abortSignal: this.abortController.signal,
-        onStepFinish: opts.onStep,
+        onStepFinish: onStep,
         onError: ({ error }) => {
           opts.onStreamError?.(error);
         },
@@ -2770,6 +2813,7 @@ var BaseAgent = class {
     }
     try {
       for await (const chunk of stream.textStream) {
+        if (chunk && firstChunkAt === void 0) firstChunkAt = nowISO();
         yield chunk;
       }
     } catch (err) {
@@ -2913,37 +2957,30 @@ function estimateTokens(text) {
   if (!text) return 0;
   return Math.ceil(text.length / 4);
 }
+function estimateEntryTokens(entry) {
+  if (!entry) return 0;
+  const content = entry.message?.content ?? entry.content ?? "";
+  let tokens = estimateTokens(String(content ?? ""));
+  if (entry.toolCalls?.length) {
+    for (const tc of entry.toolCalls) {
+      tokens += estimateTokens(tc.arguments ?? "");
+    }
+  }
+  if (entry.toolResults?.length) {
+    for (const tr of entry.toolResults) {
+      tokens += estimateTokens(tr.output?.value ?? "");
+    }
+  }
+  return tokens;
+}
 function estimateConversationTokens(entries) {
   let total = 0;
   for (const entry of entries) {
-    if (entry.message?.content) {
-      total += estimateTokens(entry.message.content);
-    }
-    if (entry.arguments) {
-      total += estimateTokens(typeof entry.arguments === "string" ? entry.arguments : JSON.stringify(entry.arguments));
-    }
-    if (entry.result) {
-      total += estimateTokens(entry.result);
-    }
-    if (entry.content) {
-      total += estimateTokens(entry.content);
-    }
+    total += estimateEntryTokens(entry);
   }
   return total;
 }
 
-// src/utils/time.ts
-function nowISO() {
-  const now = /* @__PURE__ */ new Date();
-  const off = -now.getTimezoneOffset();
-  const sign = off >= 0 ? "+" : "-";
-  const absOff = Math.abs(off);
-  const hh = String(Math.floor(absOff / 60)).padStart(2, "0");
-  const mm = String(absOff % 60).padStart(2, "0");
-  const pad = (n, len = 2) => String(n).padStart(len, "0");
-  return `${now.getFullYear()}-${pad(now.getMonth() + 1)}-${pad(now.getDate())}T${pad(now.getHours())}:${pad(now.getMinutes())}:${pad(now.getSeconds())}.${pad(now.getMilliseconds(), 3)}${sign}${hh}:${mm}`;
-}
-
 // src/services/agents/context-manager.ts
 var DEFAULT_MAX_TOKENS = 1e5;
 var COMPACT_THRESHOLD_RATIO = 0.9;
@@ -2959,13 +2996,22 @@ var ContextManager = class {
   staticPrompt;
   maxTokens;
   /**
-   * Cached compact state — updated by compact() and restore(), read by getMessages().
-   * Null means no compaction has occurred.
+   * Cached compact state — updated by compact() and restoreCompact(), read by
+   * getMessages()/getSystemPrompt(). Null means no compaction is active.
    */
   compactSummary = null;
   /**
-   * Index into the conversation array: entries from this index onward are the
-   * "recent" entries that should be sent to the LLM alongside the summary.
+   * Index into the conversation array: entries from this index onward form the
+   * "verbatim zone" — entries sent to the LLM as-is alongside the summary.
+   *
+   * Semantics (unified):
+   * - After compact(): conversation.length. Only entries appended AFTER the
+   *   compaction belong to the verbatim zone; pre-compaction entries live on
+   *   in the summary (and in the append-only JSONL history).
+   * - After restoreCompact(): 0. The state layer has already sliced the
+   *   in-memory conversation to the restore window, so the whole array IS
+   *   the verbatim zone.
+   *
    * Updated together with compactSummary.
    */
   compactStartIdx = 0;
@@ -3004,6 +3050,22 @@ ${this.compactSummary}` },
     const convTokens = estimateConversationTokens(this.getMessages());
     return promptTokens + convTokens > this.maxTokens * COMPACT_THRESHOLD_RATIO;
   }
+  /**
+   * 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.
    *
@@ -3012,72 +3074,40 @@ ${this.compactSummary}` },
    *
    * The summarizer receives ALL entries and returns a summary.
    * After compaction, getMessages() returns [summary] + entries appended after the marker.
+   *
+   * @param meta Optional provenance recorded on the marker (model name).
    */
-  async compact(summarizer) {
+  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;
+    const markerTs = nowISO();
     this.state.append("conversation", {
       type: "system" /* System */,
       uuid: generateId("compact"),
       parentUuid: null,
       sessionId: this.state.get("runtimeState.session.id") ?? "",
-      timestamp: nowISO(),
+      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)
+        summarizedTokenCount: estimateConversationTokens(conversation),
+        ...fromEntryId !== void 0 && { fromEntryId },
+        ...toEntryId !== void 0 && { toEntryId },
+        ...meta?.model !== void 0 && { model: meta.model },
+        createdAt: markerTs
       }
     });
   }
-  /**
-   * Restore compact state from persisted conversation.
-   *
-   * Scans for the latest compact marker, then loads recent entries within
-   * the token budget. If loaded entries are fewer than RECENT_TOKEN_BUDGET,
-   * continues loading past the marker (overlap with summary is acceptable).
-   */
-  restoreFromEntries(entries) {
-    const compactIdx = entries.findLastIndex(
-      (e) => e.type === "system" /* System */ && e.subtype === "compact" /* Compact */
-    );
-    if (compactIdx === -1) {
-      this.compactSummary = null;
-      this.compactStartIdx = 0;
-      return;
-    }
-    const summary = entries[compactIdx].content;
-    let budget = RECENT_TOKEN_BUDGET;
-    let cutIdx = 0;
-    for (let i = compactIdx - 1; i >= 0; i--) {
-      const tokens = estimateEntryTokens(entries[i]);
-      budget -= tokens;
-      if (budget <= 0) {
-        cutIdx = i + 1;
-        break;
-      }
-    }
-    this.compactSummary = summary;
-    this.compactStartIdx = compactIdx - cutIdx;
-  }
 };
-function estimateEntryTokens(entry) {
-  const content = entry.message?.content ?? entry.content ?? "";
-  let tokens = estimateTokens(String(content));
-  if (entry.toolCalls?.length) {
-    for (const tc of entry.toolCalls) {
-      tokens += estimateTokens(tc.arguments ?? "");
-    }
-  }
-  if (entry.toolResults?.length) {
-    for (const tr of entry.toolResults) {
-      tokens += estimateTokens(tr.output?.value ?? "");
-    }
-  }
-  return tokens;
-}
 
 // src/services/agents/worker-state.ts
 import { join as join7 } from "path";
@@ -3110,33 +3140,67 @@ var WorkerState = class extends BaseWayangState {
     if (runtimeState) {
       this.data.runtimeState = runtimeState;
     }
-    const conversation = this.jsonlFile.read();
-    if (conversation.length > 0) {
-      this.data.conversation = conversation;
+    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/agents/utils/build-assistant-entry.ts
-function buildAssistantEntry(event, sessionId, uuid) {
+function buildAssistantEntry(event, sessionId, uuid, extras) {
   const ts = nowISO();
   const text = event.text ?? "";
   const reasoningText = event.reasoningText?.trim() || // Fallback: join per-part reasoning when reasoningText is not populated
   (event.reasoning ?? []).map((r) => r.text).filter(Boolean).join("\n") || void 0;
   const reasoning = reasoningText && reasoningText !== "[]" ? reasoningText : void 0;
-  const toolCalls = event.toolCalls?.length ? event.toolCalls.map((tc) => ({
-    toolCallId: tc.toolCallId,
-    toolName: tc.toolName,
-    arguments: (
-      // SDK OnStepFinishEvent type incomplete
-      typeof tc.args === "string" ? tc.args : JSON.stringify(tc.args ?? tc.input ?? {})
-    )
-  })) : [];
+  const lookupRecord = extras?.recordedToolCalls;
+  const toolCalls = event.toolCalls?.length ? event.toolCalls.map((tc) => {
+    const rec = lookupRecord?.(tc.toolCallId);
+    return {
+      toolCallId: tc.toolCallId,
+      toolName: tc.toolName,
+      arguments: (
+        // SDK OnStepFinishEvent type incomplete
+        typeof tc.args === "string" ? tc.args : JSON.stringify(tc.args ?? tc.input ?? {})
+      ),
+      ...rec?.taskId !== void 0 && { taskId: rec.taskId },
+      ...rec?.status !== void 0 && { status: rec.status },
+      ...rec?.startedAt !== void 0 && { startedAt: rec.startedAt },
+      ...rec?.endedAt !== void 0 && { endedAt: rec.endedAt },
+      ...rec?.errorType !== void 0 && { errorType: rec.errorType }
+    };
+  }) : [];
   const results = [];
+  const withRecordMeta = (r) => {
+    const rec = lookupRecord?.(r.toolCallId);
+    if (!rec) return r;
+    return {
+      ...r,
+      ...rec.status !== void 0 && { status: rec.status },
+      ...rec.errorType !== void 0 && { errorType: rec.errorType },
+      ...rec.startedAt !== void 0 && { startedAt: rec.startedAt },
+      ...rec.endedAt !== void 0 && { endedAt: rec.endedAt }
+    };
+  };
   if (event.toolResults?.length) {
     results.push(
-      ...event.toolResults.map((tr) => ({
+      ...event.toolResults.map((tr) => withRecordMeta({
         toolCallId: tr.toolCallId,
         toolName: tr.toolName,
         output: {
@@ -3153,20 +3217,49 @@ function buildAssistantEntry(event, sessionId, uuid) {
   if (Array.isArray(content)) {
     for (const part of content) {
       if (part.type === "tool-error" && part.toolCallId) {
-        results.push({
+        results.push(withRecordMeta({
           toolCallId: part.toolCallId,
           toolName: part.toolName ?? "unknown",
           output: {
             type: "text",
             value: part.error?.message ?? part.error ?? "Tool input validation failed"
           },
-          isError: true
-        });
+          isError: true,
+          status: "failed",
+          errorType: "ToolInputValidationError"
+        }));
       }
     }
   }
   const toolResults = results;
-  const usage = event.usage ? { inputTokens: event.usage.inputTokens ?? 0, outputTokens: event.usage.outputTokens ?? 0 } : void 0;
+  const rawUsage = event.usage;
+  const usage = rawUsage ? {
+    inputTokens: rawUsage.inputTokens ?? 0,
+    outputTokens: rawUsage.outputTokens ?? 0,
+    ...cachedInputOf(rawUsage) !== void 0 && { cachedInputTokens: cachedInputOf(rawUsage) },
+    ...reasoningTokensOf(rawUsage) !== void 0 && { reasoningTokens: reasoningTokensOf(rawUsage) },
+    ...rawUsage.totalTokens !== void 0 && { totalTokens: rawUsage.totalTokens }
+  } : void 0;
+  const modelInfo = event.model;
+  const model = modelInfo && (modelInfo.provider !== void 0 || modelInfo.modelId !== void 0) || extras?.temperature !== void 0 || extras?.maxOutputTokens !== void 0 ? {
+    ...modelInfo?.provider !== void 0 && { provider: modelInfo.provider },
+    ...modelInfo?.modelId !== void 0 && { model: modelInfo.modelId },
+    ...extras?.temperature !== void 0 && { temperature: extras.temperature },
+    ...extras?.maxOutputTokens !== void 0 && { maxOutputTokens: extras.maxOutputTokens }
+  } : void 0;
+  const stepStartedAt = toIso(event.response?.timestamp) ?? extras?.startedAt;
+  const endedAt = extras?.endedAt ?? ts;
+  const durationMs = stepStartedAt !== void 0 ? Math.max(0, new Date(endedAt).getTime() - new Date(stepStartedAt).getTime()) : void 0;
+  const firstTokenAt = extras?.firstTokenAt;
+  const timing = stepStartedAt !== void 0 || firstTokenAt !== void 0 ? {
+    ...stepStartedAt !== void 0 && { startedAt: stepStartedAt },
+    ...firstTokenAt !== void 0 && { firstTokenAt },
+    endedAt,
+    ...durationMs !== void 0 && { durationMs }
+  } : { endedAt };
+  const responseId = event.response?.id;
+  const requestId = typeof responseId === "string" && responseId.length > 0 ? responseId : void 0;
+  const stepNumber = event.stepNumber;
   return {
     type: "assistant" /* Assistant */,
     uuid: uuid ?? generateId("step"),
@@ -3181,9 +3274,129 @@ function buildAssistantEntry(event, sessionId, uuid) {
     },
     toolCalls: toolCalls.length > 0 ? toolCalls : void 0,
     toolResults: toolResults.length > 0 ? toolResults : void 0,
-    finishReason: event.finishReason
+    finishReason: event.finishReason,
+    ...typeof stepNumber === "number" && { stepIndex: stepNumber },
+    ...model !== void 0 && { model },
+    ...timing !== void 0 && { timing },
+    ...requestId !== void 0 && { requestId },
+    ...extras?.traceId !== void 0 && { traceId: extras.traceId },
+    ...extras?.spanId !== void 0 && { spanId: extras.spanId }
   };
 }
+function cachedInputOf(usage) {
+  if (usage.cachedInputTokens !== void 0) return usage.cachedInputTokens;
+  return usage.inputTokenDetails?.cacheReadTokens;
+}
+function reasoningTokensOf(usage) {
+  if (usage.reasoningTokens !== void 0) return usage.reasoningTokens;
+  return usage.outputTokenDetails?.reasoningTokens;
+}
+function toIso(value) {
+  if (value instanceof Date) {
+    return Number.isNaN(value.getTime()) ? void 0 : value.toISOString();
+  }
+  if (typeof value === "string" && value.length > 0) {
+    const d = new Date(value);
+    return Number.isNaN(d.getTime()) ? void 0 : d.toISOString();
+  }
+  if (typeof value === "number" && Number.isFinite(value)) {
+    return new Date(value).toISOString();
+  }
+  return void 0;
+}
+
+// src/services/agents/utils/entry-envelope.ts
+function applyTurnEnvelope(entry, env) {
+  if (!env) return entry;
+  if (entry.turnId === void 0) entry.turnId = env.turnId;
+  if (entry.rootTurnId === void 0 && env.rootTurnId !== void 0) entry.rootTurnId = env.rootTurnId;
+  if (entry.causationId === void 0 && env.causationId !== void 0) entry.causationId = env.causationId;
+  if (entry.actor === void 0 && env.actor !== void 0) entry.actor = env.actor;
+  return entry;
+}
+function syncStepTimestamps(entry) {
+  if (entry.type !== "assistant" /* Assistant */) return;
+  if (entry.timing?.startedAt !== void 0) entry.startedAt = entry.timing.startedAt;
+  if (entry.timing?.endedAt !== void 0) entry.endedAt = entry.timing.endedAt;
+}
+
+// src/services/agents/utils/tool-call-recorder.ts
+var ToolCallRecorder = class {
+  /**
+   * @param logger Optional logger — used for debug diagnostics (e.g. an
+   * attachTask call that finds no live record). Absent in unit tests.
+   */
+  constructor(logger) {
+    this.logger = logger;
+  }
+  logger;
+  records = /* @__PURE__ */ new Map();
+  /** Clear records from previous runs. Call at the start of each agent run. */
+  beginTurn() {
+    this.records.clear();
+  }
+  start(toolCallId, toolName) {
+    this.records.set(toolCallId, { toolCallId, toolName, status: "running", startedAt: nowISO() });
+  }
+  finish(toolCallId, status, errorType) {
+    const rec = this.records.get(toolCallId);
+    if (!rec) return;
+    rec.status = status;
+    rec.endedAt = nowISO();
+    if (errorType) rec.errorType = errorType;
+  }
+  /**
+   * Attach an async task dispatched by this call (e.g. add_task) and mark the
+   * call as 'running': the tool returned, but the dispatched task is what
+   * stays in flight. Terminal state arrives later via signal entries —
+   * append-only storage means this record is never updated afterwards.
+   */
+  attachTask(toolCallId, taskId) {
+    const rec = this.records.get(toolCallId);
+    if (!rec) {
+      this.logger?.debug({ toolCallId, taskId }, "attachTask: no live tool-call record for toolCallId");
+      return;
+    }
+    rec.taskId = taskId;
+    rec.status = "running";
+    rec.endedAt = nowISO();
+  }
+  /** Look up a live record (used by the assistant-entry builder). */
+  lookup(toolCallId) {
+    return this.records.get(toolCallId);
+  }
+};
+var TOOL_ERROR_PREFIX = "[ERROR]";
+function recordToolCalls(tools, recorder) {
+  const wrapped = {};
+  for (const [name, def] of Object.entries(tools)) {
+    if (!def || typeof def.execute !== "function") {
+      wrapped[name] = def;
+      continue;
+    }
+    const original = def.execute;
+    wrapped[name] = {
+      ...def,
+      execute: async (args, options) => {
+        const toolCallId = options?.toolCallId ?? `${name}-${Date.now()}-${Math.random().toString(36).slice(2, 6)}`;
+        recorder.start(toolCallId, name);
+        try {
+          const result = await original(args, options);
+          if (typeof result === "string" && result.startsWith(TOOL_ERROR_PREFIX)) {
+            recorder.finish(toolCallId, "failed", "ToolError");
+          } else {
+            recorder.finish(toolCallId, "succeeded");
+          }
+          return result;
+        } catch (err) {
+          recorder.finish(toolCallId, "failed", err?.constructor?.name ?? "Error");
+          throw err;
+        }
+      }
+    };
+  }
+  return wrapped;
+}
 
 // src/services/agents/constants.ts
 var WORKER_AGENT_MAX_STEP = 1e3;
@@ -3204,9 +3417,9 @@ function truncate(result) {
   return result.slice(0, MAX_RESULT_CHARS) + "\n...(truncated)";
 }
 function safeExecute(name, fn) {
-  return async (args, _options) => {
+  return async (args, options) => {
     try {
-      const result = await fn(args);
+      const result = await fn(args, options);
       return truncate(typeof result === "string" ? result : JSON.stringify(result));
     } catch (err) {
       return `[ERROR] ${name}: ${err.message ?? String(err)}`;
@@ -3762,10 +3975,14 @@ var WorkerAgent = class extends BaseAgent {
   _terminalResult = null;
   workspaceDir;
   toolChoice;
+  provider;
   contextManager;
   ctx;
+  /** Live tool execution records — merged into entries at step finish. */
+  recorder = new ToolCallRecorder();
   constructor(provider, ctx, skills, toolChoice) {
     super(provider);
+    this.provider = provider;
     this.ctx = ctx;
     this.logger = ctx.logger;
     this.workspaceDir = ctx.workspaceDir;
@@ -3788,20 +4005,31 @@ var WorkerAgent = class extends BaseAgent {
     this.logger.debug({ task }, "WorkerAgent run called");
     this.state.set("runtimeState.task", { id: task.id, description: task.description });
     this._terminalResult = null;
-    this.state.append("conversation", {
+    const turnEnv = {
+      turnId: task.executionTurnId ?? generateId("turn"),
+      ...(task.rootTurnId ?? task.turnId) !== void 0 && { rootTurnId: task.rootTurnId ?? task.turnId },
+      causationId: task.id,
+      actor: { kind: "worker", id: task.workerId, taskId: task.id }
+    };
+    this.recorder.beginTurn();
+    const promptTs = nowISO();
+    this.state.append("conversation", applyTurnEnvelope({
       type: "user" /* User */,
       uuid: generateId("u"),
       parentUuid: null,
-      sessionId: this.id,
-      timestamp: nowISO(),
+      sessionId: this.ctx.sessionId,
+      timestamp: promptTs,
+      actor: { kind: "system", id: "engine", taskId: task.id },
+      // Delivery of the task prompt completes at write time.
+      endedAt: promptTs,
       message: { role: "user", content: task.description }
-    });
-    const allTools = {
+    }, turnEnv));
+    const allTools = recordToolCalls({
       ...tools,
       check_controller_messages: checkControllerMessagesTool({
         drainInbox: () => this.drainInbox()
       })
-    };
+    }, this.recorder);
     const result = await this.collectLoop({
       system: this.contextManager.getSystemPrompt(),
       messages: this.contextManager.getMessages(),
@@ -3812,8 +4040,16 @@ var WorkerAgent = class extends BaseAgent {
       onStreamError: (err) => {
         this.logger.error({ workerId: this.id, err }, "LLM stream error");
       },
-      onStep: (event) => {
-        const entry = buildAssistantEntry(event, this.id);
+      onStep: (event, meta) => {
+        const entry = buildAssistantEntry(event, this.ctx.sessionId, void 0, {
+          startedAt: meta?.startedAt,
+          firstTokenAt: meta?.firstTokenAt,
+          temperature: this.provider.temperature,
+          maxOutputTokens: this.provider.maxOutputTokens,
+          recordedToolCalls: (toolCallId) => this.recorder.lookup(toolCallId)
+        });
+        applyTurnEnvelope(entry, turnEnv);
+        syncStepTimestamps(entry);
         this.state.append("conversation", entry);
         const toolNames = entry.toolCalls?.map((tc) => tc.toolName) ?? [];
         const hasError = entry.toolResults?.some((tr) => tr.isError);
@@ -3932,6 +4168,23 @@ var ClaudeCodeWorker = class _ClaudeCodeWorker {
   // Signal context set during run()
   _signalQueue = null;
   _runContext = null;
+  /** Turn lineage for permission-request signals emitted by this worker. */
+  _turnLineage = {};
+  /** Turn lineage stamped on entries written by the run in flight. */
+  _currentTurnEnv = null;
+  /**
+   * Turn identity: one worker run = one turn. The engine passes the task's
+   * execution turn id; rootTurnId is inherited from the task; the task is
+   * the direct cause of this activation.
+   */
+  buildTurnEnv(task) {
+    return {
+      turnId: task.executionTurnId ?? generateId("turn"),
+      ...(task.rootTurnId ?? task.turnId) !== void 0 && { rootTurnId: task.rootTurnId ?? task.turnId },
+      causationId: task.id,
+      actor: { kind: "worker", id: task.workerId, taskId: task.id }
+    };
+  }
   /**
    * Progress debounce mechanism.
    *
@@ -3959,14 +4212,20 @@ var ClaudeCodeWorker = class _ClaudeCodeWorker {
   async run(task, _tools, onProgress) {
     this._terminalResult = null;
     this.state.set("runtimeState.task", { id: task.id, description: task.description });
-    this.state.append("conversation", {
+    const turnEnv = this.buildTurnEnv(task);
+    this._currentTurnEnv = turnEnv;
+    const promptTs = nowISO();
+    this.state.append("conversation", applyTurnEnvelope({
       type: "user" /* User */,
       uuid: generateId("u"),
       parentUuid: null,
-      sessionId: this.id,
-      timestamp: nowISO(),
+      sessionId: this.ctx.sessionId,
+      timestamp: promptTs,
+      actor: { kind: "system", id: "engine", taskId: task.id },
+      // Delivery of the task prompt completes at write time.
+      endedAt: promptTs,
       message: { role: "user", content: task.description }
-    });
+    }, turnEnv));
     try {
       const options = {
         cwd: this.workspaceDir,
@@ -4005,21 +4264,25 @@ var ClaudeCodeWorker = class _ClaudeCodeWorker {
     }
     this.permissionHandler.cleanup();
     this.flushMessageQueue();
-    this.state.append("conversation", {
+    const resultTs = nowISO();
+    this.state.append("conversation", applyTurnEnvelope({
       type: "system" /* System */,
       uuid: generateId("s"),
       parentUuid: null,
-      sessionId: this.id,
-      timestamp: nowISO(),
-      subtype: this._terminalResult.status === "completed" ? "compact" : "error",
-      content: this._terminalResult.summary ?? this._terminalResult.error ?? ""
-    });
+      sessionId: this.ctx.sessionId,
+      timestamp: resultTs,
+      subtype: this._terminalResult.status === "completed" ? "task_result" /* TaskResult */ : "error" /* Error */,
+      content: this._terminalResult.summary ?? this._terminalResult.error ?? "",
+      startedAt: resultTs,
+      endedAt: resultTs
+    }, turnEnv));
     return this._terminalResult;
   }
   /** Set signal context for permission requests. Called by engine before run(). */
   setSignalContext(deps) {
     this._signalQueue = deps.signalQueue;
     this._runContext = deps;
+    this._turnLineage = deps.turnLineage ?? {};
   }
   abort() {
     this.abortController.abort();
@@ -4076,7 +4339,8 @@ var ClaudeCodeWorker = class _ClaudeCodeWorker {
         toolName,
         toolArgs: input,
         description
-      }
+      },
+      ...this._turnLineage
     });
     return new Promise((resolve11) => {
       const timer = setTimeout(() => {
@@ -4150,21 +4414,24 @@ var ClaudeCodeWorker = class _ClaudeCodeWorker {
     }
     const text = textParts.join("\n");
     if (!text) return;
-    this.state.append("conversation", {
+    this.state.append("conversation", applyTurnEnvelope({
       type: "assistant" /* Assistant */,
       uuid: generateId("a"),
       parentUuid: null,
-      sessionId: this.id,
+      sessionId: this.ctx.sessionId,
       timestamp: nowISO(),
       message: {
         role: "assistant",
         content: text,
         usage: {
           inputTokens: msg.message.usage?.input_tokens ?? 0,
-          outputTokens: msg.message.usage?.output_tokens ?? 0
+          outputTokens: msg.message.usage?.output_tokens ?? 0,
+          ...msg.message.usage?.cache_read_input_tokens != null && {
+            cachedInputTokens: msg.message.usage.cache_read_input_tokens
+          }
         }
       }
-    });
+    }, this._currentTurnEnv ?? void 0));
     if (onProgress) {
       this._pendingProgress = text.slice(0, 200);
       if (this._progressTimer) clearTimeout(this._progressTimer);
@@ -4235,7 +4502,7 @@ function addTaskTool(deps) {
         "Dispatch this task to an existing idle worker (the workerId returned from a prior multiStage task). The worker resumes with its accumulated context. Omit for a fresh worker."
       )
     }),
-    execute: safeExecute("add_task", async ({ title, description, priority, workerType, multiStage, assignToWorker }) => {
+    execute: safeExecute("add_task", async ({ title, description, priority, workerType, multiStage, assignToWorker }, options) => {
       const resolvedType = workerType || "puppet";
       if (deps.validateWorkerType) {
         const err = deps.validateWorkerType(resolvedType);
@@ -4248,6 +4515,8 @@ function addTaskTool(deps) {
         const err = deps.validateIdleWorker(assignToWorker);
         if (err) return err;
       }
+      const toolCallId = options?.toolCallId;
+      const turnCtx = deps.getTurnContext?.();
       const task = {
         id: generateId("t"),
         title,
@@ -4257,14 +4526,19 @@ function addTaskTool(deps) {
         status: "pending",
         createdAt: Date.now(),
         multiStage,
-        assignToWorker
+        assignToWorker,
+        ...turnCtx?.turnId !== void 0 && { turnId: turnCtx.turnId },
+        ...turnCtx?.rootTurnId !== void 0 && { rootTurnId: turnCtx.rootTurnId },
+        ...(toolCallId ?? turnCtx?.causationId) !== void 0 && { causationId: toolCallId ?? turnCtx?.causationId }
       };
       if (assignToWorker && deps.assignToWorker) {
         const ok = deps.assignToWorker(assignToWorker, task);
-        if (!ok) return `Worker ${assignToWorker} could not accept the task (no longer idle?).`;
+        if (ok) deps.onTaskDispatched?.({ toolCallId, taskId: task.id });
+        else return `Worker ${assignToWorker} could not accept the task (no longer idle?).`;
         return `Task ${task.id} assigned to worker ${assignToWorker} (reusing its context, priority: ${priority}, worker: ${resolvedType}). You will be notified when the task completes.`;
       }
       deps.addTask(task);
+      deps.onTaskDispatched?.({ toolCallId, taskId: task.id });
       const stageNote = multiStage ? " [multi-stage: worker will idle after completion]" : "";
       return `Task ${task.id} added (priority: ${priority}, worker: ${task.workerType})${stageNote}. You will be notified when the task completes.`;
     })
@@ -4801,7 +5075,9 @@ function createControllerTools(deps) {
       addTask: deps.addTask,
       validateWorkerType: deps.validateWorkerType,
       assignToWorker: deps.assignToWorker,
-      validateIdleWorker: deps.validateIdleWorker
+      validateIdleWorker: deps.validateIdleWorker,
+      getTurnContext: deps.getTurnContext,
+      onTaskDispatched: deps.onTaskDispatched
     }),
     list_tasks: listTasksTool({ listTasks: deps.listTasks }),
     cancel_task: cancelTaskTool({
@@ -4877,7 +5153,8 @@ function wrapWithPermissionMiddleware(tools, config, deps) {
             toolName,
             toolArgs: args,
             description
-          }
+          },
+          ...deps.turnLineage ?? {}
         });
         const result = await new Promise((resolve11) => {
           const timer = setTimeout(() => {
@@ -5035,6 +5312,19 @@ var TaskExecuteEngine = class {
   workerTaskMap = /* @__PURE__ */ new Map();
   /** Permission middleware resolvers keyed by workerId. */
   permissionResolvers = /* @__PURE__ */ new Map();
+  /**
+   * Turn lineage of each active worker's current run: the execution turn id
+   * (also handed to the worker for stamping its entries), the chain's root
+   * turn, and the task id (used as signals' causationId).
+   */
+  workerTurnLineage = /* @__PURE__ */ new Map();
+  /**
+   * Running tasks cancelled via cancel(): their (aborted) worker resolution
+   * must not re-classify the task or emit a worker_failed signal — the
+   * task_cancelled signal was already emitted at cancel time. Cleared when
+   * the worker's run promise settles (handleDone/handleFail).
+   */
+  cancelledTaskIds = /* @__PURE__ */ new Set();
   /** Idle-reaping timers keyed by workerId (multi-stage workers only). */
   idleTimers = /* @__PURE__ */ new Map();
   /** Idle TTL (ms). Idle workers are disposed after this if not reused. */
@@ -5086,8 +5376,12 @@ var TaskExecuteEngine = class {
     const running = this.taskState.get("tasks.running");
     const runIdx = running.findIndex((t) => t.id === id);
     if (runIdx !== -1) {
+      const task = running[runIdx];
+      const workerId = [...this.workerTaskMap.entries()].find(([, tId]) => tId === id)?.[0];
       this.abortByTaskId(id);
       this.moveToHistory(id, "cancelled", {});
+      this.cancelledTaskIds.add(id);
+      this.emitTaskCancelled(task, workerId);
       this.logger.info({ taskId: id }, "Running task cancelled");
       this.ctx.hooks.emit("task:cancelled", { taskId: id });
       return true;
@@ -5102,6 +5396,7 @@ var TaskExecuteEngine = class {
         status: "cancelled",
         completedAt: Date.now()
       });
+      this.emitTaskCancelled(task);
       this.logger.info({ taskId: id }, "Pending task cancelled");
       this.ctx.hooks.emit("task:cancelled", { taskId: id });
       return true;
@@ -5109,6 +5404,34 @@ var TaskExecuteEngine = class {
     this.logger.warn({ taskId: id }, "Task not found for cancel");
     return false;
   }
+  /**
+   * Announce a task cancellation on the signal queue (subtype
+   * task_cancelled — terminal for the dispatched task, but not a failure).
+   * Running tasks carry their worker's lineage; pending tasks fall back to
+   * the task's own chain fields.
+   */
+  emitTaskCancelled(task, workerId) {
+    const workerType = task.workerType ?? PUPPET_WORKER_TYPE;
+    const meta = getWorkerMeta(workerType, this.workerConfigs);
+    const payload = {
+      taskId: task.id,
+      ...workerId !== void 0 && { workerId },
+      taskTitle: task.title,
+      workerType,
+      emoji: meta.emoji
+    };
+    if (workerId !== void 0) {
+      this.enqueueWorkerSignal(workerId, { source: "system", type: "task_cancelled", payload });
+      return;
+    }
+    this.signalQueue.enqueue({
+      source: "system",
+      type: "task_cancelled",
+      payload,
+      ...(task.rootTurnId ?? task.turnId) !== void 0 && { rootTurnId: task.rootTurnId ?? task.turnId },
+      causationId: task.id
+    });
+  }
   updatePending(id, updates) {
     const pending = [...this.taskState.get("tasks.pending")];
     const idx = pending.findIndex((t) => t.id === id);
@@ -5179,6 +5502,39 @@ var TaskExecuteEngine = class {
     return this.taskState.get("tasks.running").length;
   }
   // ---------------------------------------------------------------------------
+  // Worker turn lineage
+  // ---------------------------------------------------------------------------
+  /**
+   * Register the execution turn for a worker run and return it. The id is
+   * handed to the worker (stamped on its entries) and reused on every signal
+   * the engine emits for this worker, so the worker's conversation file and
+   * the controller's signal records share the same turn id.
+   */
+  registerWorkerTurn(workerId, task) {
+    const executionTurnId = generateId("turn");
+    this.workerTurnLineage.set(workerId, {
+      turnId: executionTurnId,
+      ...task.rootTurnId !== void 0 && { rootTurnId: task.rootTurnId },
+      ...task.rootTurnId === void 0 && task.turnId !== void 0 && { rootTurnId: task.turnId },
+      taskId: task.id
+    });
+    return executionTurnId;
+  }
+  /** Turn lineage to attach to signals emitted for a worker. */
+  workerLineage(workerId) {
+    const lin = this.workerTurnLineage.get(workerId);
+    if (!lin) return {};
+    return {
+      turnId: lin.turnId,
+      ...lin.rootTurnId !== void 0 && { rootTurnId: lin.rootTurnId },
+      causationId: lin.taskId
+    };
+  }
+  /** Enqueue a worker signal with the worker's turn lineage attached. */
+  enqueueWorkerSignal(workerId, sig) {
+    this.signalQueue.enqueue({ ...sig, ...this.workerLineage(workerId) });
+  }
+  // ---------------------------------------------------------------------------
   // Scheduling (direct calls, no hooks)
   // ---------------------------------------------------------------------------
   /** Attempt to schedule pending tasks up to maxConcurrency. */
@@ -5382,7 +5738,7 @@ var TaskExecuteEngine = class {
     const worker = this.workers.get(workerId);
     worker?.abort();
     this.clearIdleTimer(workerId);
-    this.signalQueue.enqueue({
+    this.enqueueWorkerSignal(workerId, {
       source: "system",
       type: "cancelled",
       payload: {
@@ -5424,10 +5780,11 @@ var TaskExecuteEngine = class {
     const worker = this.createWorker(workerType);
     this.workers.set(workerId, worker);
     this.workerTaskMap.set(workerId, task.id);
+    const executionTurnId = this.registerWorkerTurn(workerId, task);
     const onProgress = this.buildProgressEmitter(workerId, task, workerType);
     const tools = this.wireWorker(worker, task, workerId, workerType);
-    this.logger.info({ workerId, taskId: task.id, workerType }, "Worker starting");
-    return worker.run({ ...task, workerId }, tools, onProgress);
+    this.logger.info({ workerId, taskId: task.id, workerType, executionTurnId }, "Worker starting");
+    return worker.run({ ...task, workerId, executionTurnId }, tools, onProgress);
   }
   /**
    * Dispatch a follow-up task to an existing idle (multi-stage) worker.
@@ -5457,6 +5814,7 @@ var TaskExecuteEngine = class {
     };
     this.taskState.append("tasks.running", taskWithOrigin);
     this.workerTaskMap.set(workerId, task.id);
+    const executionTurnId = this.registerWorkerTurn(workerId, taskWithOrigin);
     this.updateActiveWorker(workerId, {
       status: "running",
       taskId: task.id,
@@ -5469,8 +5827,8 @@ var TaskExecuteEngine = class {
     });
     const onProgress = this.buildProgressEmitter(workerId, task, workerType);
     const tools = this.wireWorker(worker, task, workerId, workerType);
-    this.logger.info({ workerId, taskId: task.id, workerType }, "Idle worker reused");
-    worker.run({ ...taskWithOrigin, workerId }, tools, onProgress).then((result) => this.handleDone(workerId, taskWithOrigin, result)).catch((err2) => this.handleFail(workerId, taskWithOrigin, formatLlmError(err2)));
+    this.logger.info({ workerId, taskId: task.id, workerType, executionTurnId }, "Idle worker reused");
+    worker.run({ ...taskWithOrigin, workerId, executionTurnId }, tools, onProgress).then((result) => this.handleDone(workerId, taskWithOrigin, result)).catch((err2) => this.handleFail(workerId, taskWithOrigin, formatLlmError(err2)));
     return true;
   }
   /**
@@ -5480,7 +5838,7 @@ var TaskExecuteEngine = class {
   buildProgressEmitter(workerId, task, workerType) {
     const meta = getWorkerMeta(workerType, this.workerConfigs);
     return (msg) => {
-      this.signalQueue.enqueue({
+      this.enqueueWorkerSignal(workerId, {
         source: "worker",
         type: "progress",
         payload: { workerId, taskId: task.id, taskTitle: task.title, workerType, emoji: meta.emoji, message: msg }
@@ -5500,7 +5858,7 @@ var TaskExecuteEngine = class {
       tavilyApiKey: this.ctx.config.tavilyApiKey,
       registry: this.skills,
       reportProgress: (msg, _percent) => {
-        this.signalQueue.enqueue({
+        this.enqueueWorkerSignal(workerId, {
           source: "worker",
           type: "progress",
           payload: { workerId, taskId: task.id, taskTitle: task.title, workerType, emoji: workerMeta.emoji, message: msg }
@@ -5541,7 +5899,8 @@ var TaskExecuteEngine = class {
         taskTitle: task.title,
         workerType,
         emoji: workerMeta.emoji,
-        signalQueue: this.signalQueue
+        signalQueue: this.signalQueue,
+        turnLineage: this.workerLineage(workerId)
       });
       tools = middleware.wrappedTools;
       this.permissionResolvers.set(workerId, middleware);
@@ -5553,18 +5912,25 @@ var TaskExecuteEngine = class {
         taskId: task.id,
         taskTitle: task.title,
         workerType,
-        emoji: workerMeta.emoji
+        emoji: workerMeta.emoji,
+        turnLineage: this.workerLineage(workerId)
       });
       this.permissionResolvers.set(workerId, worker.permissionHandler);
     }
     return tools;
   }
   handleDone(workerId, task, result) {
+    if (this.consumeCancelled(task.id)) {
+      this.removeActiveWorker(workerId);
+      this.removeWorkerTracking(workerId);
+      this.scheduleNext();
+      return;
+    }
     const workerType = task.workerType ?? PUPPET_WORKER_TYPE;
     const meta = getWorkerMeta(workerType, this.workerConfigs);
     if (result.status !== "completed") {
       this.failTask(task.id, result.error ?? "Unknown error");
-      this.signalQueue.enqueue({
+      this.enqueueWorkerSignal(workerId, {
         source: "worker",
         type: "failed",
         payload: {
@@ -5583,7 +5949,7 @@ var TaskExecuteEngine = class {
     }
     if (task.multiStage) {
       this.completeTask(task.id, result.summary ?? "");
-      this.signalQueue.enqueue({
+      this.enqueueWorkerSignal(workerId, {
         source: "worker",
         type: "completed",
         payload: {
@@ -5600,7 +5966,7 @@ var TaskExecuteEngine = class {
       return;
     }
     this.completeTask(task.id, result.summary ?? "");
-    this.signalQueue.enqueue({
+    this.enqueueWorkerSignal(workerId, {
       source: "worker",
       type: "completed",
       payload: {
@@ -5617,10 +5983,16 @@ var TaskExecuteEngine = class {
     this.scheduleNext();
   }
   handleFail(workerId, task, error) {
+    if (this.consumeCancelled(task.id)) {
+      this.removeActiveWorker(workerId);
+      this.removeWorkerTracking(workerId);
+      this.scheduleNext();
+      return;
+    }
     const workerType = task.workerType ?? PUPPET_WORKER_TYPE;
     const meta = getWorkerMeta(workerType, this.workerConfigs);
     this.failTask(task.id, error);
-    this.signalQueue.enqueue({
+    this.enqueueWorkerSignal(workerId, {
       source: "worker",
       type: "failed",
       payload: {
@@ -5636,8 +6008,16 @@ var TaskExecuteEngine = class {
     this.removeWorkerTracking(workerId);
     this.scheduleNext();
   }
+  /** Whether the task was cancelled; clears the marker (one-shot). */
+  consumeCancelled(taskId) {
+    if (!this.cancelledTaskIds.has(taskId)) return false;
+    this.cancelledTaskIds.delete(taskId);
+    this.logger.info({ taskId }, "Worker resolution for cancelled task suppressed");
+    return true;
+  }
   removeWorkerTracking(workerId) {
     this.clearIdleTimer(workerId);
+    this.workerTurnLineage.delete(workerId);
     setTimeout(() => {
       this.permissionResolvers.get(workerId)?.cleanup();
       this.permissionResolvers.delete(workerId);
@@ -5874,10 +6254,223 @@ var SessionManager = class _SessionManager {
 
 // src/services/agents/controller-state.ts
 import { join as join10 } from "path";
+
+// src/services/conversation/conversation-index.ts
+function emptyUsage() {
+  return { inputTokens: 0, outputTokens: 0, cachedInputTokens: 0, reasoningTokens: 0, totalTokens: 0 };
+}
+function newTurn(turnId) {
+  const view = {
+    turnId,
+    status: "running",
+    steps: [],
+    signals: [],
+    toolCalls: [],
+    usage: emptyUsage(),
+    entryIds: []
+  };
+  return { view, unfinishedTaskIds: /* @__PURE__ */ new Set(), hasSyncRunning: false, hasFailure: false, hasCancelled: false, toolCallById: /* @__PURE__ */ new Map() };
+}
+function trackTimeBounds(view, iso, pick) {
+  if (iso === void 0) return;
+  const t = Date.parse(iso);
+  if (Number.isNaN(t)) return;
+  const current = pick === "start" ? view.startedAt : view.endedAt;
+  if (current === void 0) {
+    if (pick === "start") view.startedAt = iso;
+    else view.endedAt = iso;
+    return;
+  }
+  const cur = Date.parse(current);
+  if (Number.isNaN(cur)) return;
+  if (pick === "start" ? t < cur : t > cur) {
+    if (pick === "start") view.startedAt = iso;
+    else view.endedAt = iso;
+  }
+}
+function terminalSignalForTask(subtype) {
+  if (subtype === "worker_failed" /* WorkerFailed */) return "terminal-failed";
+  if (subtype === "task_cancelled" /* TaskCancelled */) return "terminal-cancelled";
+  if (subtype === "worker_completed" /* WorkerCompleted */ || subtype === "worker_disposed" /* WorkerDisposed */) return "terminal-ok";
+  return null;
+}
+var ConversationIndexBuilder = class {
+  accs = [];
+  byTurnId = /* @__PURE__ */ new Map();
+  byEntryIdMap = /* @__PURE__ */ new Map();
+  /** taskId → turn that dispatched it (for terminal-signal resolution). */
+  taskDispatchTurn = /* @__PURE__ */ new Map();
+  /** Sequence for derived legacy turn ids. */
+  legacySeq = 0;
+  /** Turn id derived for the most recent entry lacking an explicit turnId. */
+  currentDerivedTurnId;
+  constructor(entries) {
+    for (const entry of entries ?? []) this.onAppend(entry);
+  }
+  /**
+   * Feed one more entry. O(1) amortized (a terminal signal also updates the
+   * dispatching turn). Duplicate uuids are ignored, making append feeds
+   * idempotent.
+   */
+  onAppend(entry) {
+    if (entry.uuid !== void 0 && this.byEntryIdMap.has(entry.uuid)) return;
+    const turnId = this.resolveTurnId(entry);
+    let acc = this.byTurnId.get(turnId);
+    if (!acc) {
+      acc = newTurn(turnId);
+      this.accs.push(acc);
+      this.byTurnId.set(turnId, acc);
+    }
+    const { view } = acc;
+    this.byEntryIdMap.set(entry.uuid, view);
+    view.entryIds.push(entry.uuid);
+    trackTimeBounds(view, entry.startedAt ?? entry.timestamp, "start");
+    trackTimeBounds(view, entry.endedAt ?? entry.timestamp, "end");
+    if (view.rootTurnId === void 0 && entry.rootTurnId !== void 0) {
+      view.rootTurnId = entry.rootTurnId;
+    }
+    if (entry.actor !== void 0) {
+      if (acc.firstActor === void 0) acc.firstActor = entry.actor;
+      if (acc.agentActor === void 0 && (entry.type === "assistant" /* Assistant */ || entry.type === "system" /* System */)) {
+        acc.agentActor = entry.actor;
+      }
+    }
+    view.actor = acc.agentActor ?? acc.firstActor;
+    switch (entry.type) {
+      case "user" /* User */:
+        this.applyUserEntry(acc, entry);
+        break;
+      case "assistant" /* Assistant */:
+        this.applyAssistantEntry(acc, entry);
+        break;
+      case "signal" /* Signal */:
+        this.applySignalEntry(acc, entry);
+        break;
+      case "system" /* System */:
+        this.applySystemEntry(acc, entry);
+        break;
+    }
+    this.recomputeStatus(acc);
+  }
+  /** Read-only index snapshot (live objects — callers must not mutate). */
+  getIndex() {
+    return { turns: this.accs.map((a) => a.view), byEntryId: this.byEntryIdMap };
+  }
+  /** Look up a turn by id. */
+  getTurn(turnId) {
+    return this.byTurnId.get(turnId)?.view;
+  }
+  /** Look up the turn an entry belongs to. */
+  getTurnByEntryId(entryId) {
+    return this.byEntryIdMap.get(entryId);
+  }
+  get turnCount() {
+    return this.accs.length;
+  }
+  // --- Internals ---
+  /**
+   * Resolve the turn an entry belongs to. New data carries `turnId`; legacy
+   * data is backfilled: a user entry starts a new derived turn, anything else
+   * attaches to the most recent turn.
+   */
+  resolveTurnId(entry) {
+    if (entry.turnId !== void 0 && entry.turnId !== null) {
+      this.currentDerivedTurnId = entry.turnId;
+      return entry.turnId;
+    }
+    if (entry.type === "user" /* User */ || this.currentDerivedTurnId === void 0) {
+      this.currentDerivedTurnId = `legacy-turn-${this.legacySeq++}`;
+    }
+    return this.currentDerivedTurnId;
+  }
+  applyUserEntry(acc, entry) {
+    if (acc.view.userEntry === void 0) acc.view.userEntry = entry;
+  }
+  applyAssistantEntry(acc, entry) {
+    const { view } = acc;
+    view.steps.push(entry);
+    const u = entry.message?.usage;
+    if (u) {
+      view.usage.inputTokens += u.inputTokens ?? 0;
+      view.usage.outputTokens += u.outputTokens ?? 0;
+      view.usage.cachedInputTokens += u.cachedInputTokens ?? 0;
+      view.usage.reasoningTokens += u.reasoningTokens ?? 0;
+      view.usage.totalTokens += u.totalTokens ?? (u.inputTokens ?? 0) + (u.outputTokens ?? 0);
+    }
+    if (entry.toolCalls) {
+      for (const tc of entry.toolCalls) {
+        const vtc = {
+          toolCallId: tc.toolCallId,
+          toolName: tc.toolName,
+          ...tc.taskId !== void 0 && { taskId: tc.taskId },
+          ...tc.status !== void 0 && { status: tc.status },
+          ...tc.startedAt !== void 0 && { startedAt: tc.startedAt },
+          ...tc.endedAt !== void 0 && { endedAt: tc.endedAt }
+        };
+        view.toolCalls.push(vtc);
+        acc.toolCallById.set(tc.toolCallId, vtc);
+        if (tc.status === "failed") acc.hasFailure = true;
+        if (tc.status === "pending" || tc.status === "running") {
+          if (tc.taskId !== void 0) {
+            acc.unfinishedTaskIds.add(tc.taskId);
+            this.taskDispatchTurn.set(tc.taskId, acc);
+          } else {
+            acc.hasSyncRunning = true;
+          }
+        }
+      }
+    }
+    if (entry.toolResults) {
+      for (const tr of entry.toolResults) {
+        const status = tr.status ?? (tr.isError ? "failed" : "succeeded");
+        const vtc = acc.toolCallById.get(tr.toolCallId);
+        if (vtc && status !== void 0) vtc.resultStatus = status;
+        if (tr.isError || status === "failed") acc.hasFailure = true;
+      }
+    }
+  }
+  applySignalEntry(acc, entry) {
+    const { view } = acc;
+    view.signals.push(entry);
+    const terminal = terminalSignalForTask(entry.subtype);
+    if (terminal !== null && entry.taskId !== void 0) {
+      if (terminal === "terminal-failed") acc.hasFailure = true;
+      const dispatchAcc = this.taskDispatchTurn.get(entry.taskId);
+      if (dispatchAcc) {
+        dispatchAcc.unfinishedTaskIds.delete(entry.taskId);
+        if (terminal === "terminal-failed") dispatchAcc.hasFailure = true;
+        if (terminal === "terminal-cancelled") dispatchAcc.hasCancelled = true;
+        this.recomputeStatus(dispatchAcc);
+      }
+    }
+  }
+  applySystemEntry(acc, entry) {
+    if (!isCompactMarker(entry) && entry.subtype === "error" /* Error */) {
+      acc.hasFailure = true;
+    }
+  }
+  recomputeStatus(acc) {
+    let status;
+    if (acc.unfinishedTaskIds.size > 0 || acc.hasSyncRunning) {
+      status = "running";
+    } else if (acc.hasFailure) {
+      status = "failed";
+    } else if (acc.hasCancelled) {
+      status = "cancelled";
+    } else {
+      status = "completed";
+    }
+    acc.view.status = status;
+  }
+};
+
+// src/services/agents/controller-state.ts
 var ControllerAgentState = class extends BaseWayangState {
   jsonFile;
   jsonlFile;
   logger;
+  /** In-memory turn index — built in restore(), fed incrementally on append. */
+  convIndex = null;
   /** In-memory resolve function for the current inquiry — never persisted. */
   inquiryResolver = null;
   constructor(ctx) {
@@ -5891,7 +6484,7 @@ var ControllerAgentState = class extends BaseWayangState {
       },
       conversation: [],
       compactSummary: null,
-      dynamicState: { streamingEntries: [], busy: false }
+      dynamicState: { streamingEntries: [], busy: false, currentTurn: null }
     };
     super(initialData, [
       { path: "runtimeState", helper: jsonFile },
@@ -5901,36 +6494,59 @@ var ControllerAgentState = class extends BaseWayangState {
     this.jsonlFile = jsonlFile;
     this.logger = ctx.logger;
   }
+  /**
+   * Append with turn-index feeding: mechanical envelope fields (v / parentId,
+   * compaction-boundary aware) are stamped by BaseWayangState.append via the
+   * shared conversation-envelope module — the single source of truth. This
+   * override only feeds the in-memory turn index incrementally.
+   */
+  append(path7, entry) {
+    super.append(path7, entry);
+    if (path7 === "conversation" && this.convIndex) {
+      this.convIndex.onAppend(entry);
+    }
+  }
+  /** Read the full persisted conversation (all JSONL lines, ignoring the in-memory window). */
+  readFullConversation() {
+    return this.jsonlFile.read();
+  }
+  /** Read-only turn index (live view; callers must not mutate). */
+  getConversationIndex() {
+    return this.convIndex?.getIndex() ?? { turns: [], byEntryId: /* @__PURE__ */ new Map() };
+  }
+  /** Look up one turn by id. */
+  getTurn(turnId) {
+    return this.convIndex?.getTurn(turnId);
+  }
   async restore() {
     const runtimeState = this.jsonFile.read();
     if (runtimeState) {
       this.data.runtimeState = runtimeState;
     }
     const allEntries = this.jsonlFile.read();
-    const compactIdx = allEntries.findLastIndex(
-      (e) => isSystemEntry(e) && e.subtype === "compact" /* Compact */
-    );
+    const compactIdx = allEntries.findLastIndex(isCompactMarker);
     if (compactIdx === -1) {
       this.data.conversation = allEntries;
+      this.data.compactSummary = null;
     } else {
-      const RECENT_TOKEN_BUDGET2 = 2e4;
-      let budget = RECENT_TOKEN_BUDGET2;
+      let budget = RECENT_TOKEN_BUDGET;
       let cutIdx = 0;
       for (let i = compactIdx - 1; i >= 0; i--) {
-        const entry = allEntries[i];
-        const content = getEntryContent(entry);
-        budget -= Math.ceil(String(content).length / 4);
+        budget -= estimateEntryTokens(allEntries[i]);
         if (budget <= 0) {
           cutIdx = i + 1;
           break;
         }
       }
       this.data.conversation = allEntries.slice(cutIdx);
+      const marker = allEntries[compactIdx];
+      this.data.compactSummary = marker.content;
     }
     this.logger.info({
       entryCount: this.data.conversation.length,
       totalEntries: allEntries.length
     }, "ControllerAgentState restored");
+    this.convIndex = new ConversationIndexBuilder(allEntries);
   }
   /** Set a pending inquiry and return a Promise that resolves when the user answers. */
   askInquiry(question) {
@@ -5957,11 +6573,18 @@ var ControllerAgent = class _ControllerAgent extends BaseAgent {
   tools;
   logger;
   ctx;
-  constructor(ctx, state, provider, tools, skills) {
+  provider;
+  /** Live tool execution records — merged into entries at step finish. */
+  recorder;
+  /** Turn id of the most recent run — used to stamp late error entries. */
+  lastTurnId = null;
+  constructor(ctx, state, provider, tools, skills, recorder = new ToolCallRecorder()) {
     super(provider);
     this.ctx = ctx;
     this.state = state;
-    this.tools = tools;
+    this.provider = provider;
+    this.recorder = recorder;
+    this.tools = recordToolCalls(tools, recorder);
     this.logger = ctx.logger;
     this.contextManager = new ContextManager(
       state,
@@ -5984,6 +6607,7 @@ var ControllerAgent = class _ControllerAgent extends BaseAgent {
   static create(opts) {
     const { ctx, provider, config, engine, signalQueue, skills } = opts;
     const state = new ControllerAgentState(ctx);
+    const recorder = new ToolCallRecorder(ctx.logger);
     const tools = createControllerTools({
       addTask: (task) => engine.add(task),
       validateWorkerType: (type) => engine.validateWorkerType(type),
@@ -6006,9 +6630,16 @@ var ControllerAgent = class _ControllerAgent extends BaseAgent {
       sendMessageToWorker: (workerId, message) => engine.sendMessageToWorker(workerId, message),
       resolvePermission: (requestId, approved, reason) => engine.resolvePermission(requestId, approved, reason),
       registry: skills,
-      disposeWorker: (workerId) => engine.abortByWorkerId(workerId)
+      disposeWorker: (workerId) => engine.abortByWorkerId(workerId),
+      // Turn lineage for tasks created by add_task (read from dynamicState,
+      // which run() sets at the start of every controller activation).
+      getTurnContext: () => state.get("dynamicState.currentTurn") ?? void 0,
+      // toolCall→task audit link, consumed when the step entry is built.
+      onTaskDispatched: ({ toolCallId, taskId }) => {
+        if (toolCallId) recorder.attachTask(toolCallId, taskId);
+      }
     });
-    return new _ControllerAgent(ctx, state, provider, tools, skills);
+    return new _ControllerAgent(ctx, state, provider, tools, skills, recorder);
   }
   /** Run the controller agent — streams text chunks while updating streamingEntries in state. */
   async run(signals) {
@@ -6021,8 +6652,23 @@ var ControllerAgent = class _ControllerAgent extends BaseAgent {
   }
   async _run(signals) {
     const ts = nowISO();
+    const turnId = generateId("turn");
+    const hasUserInput = signals.some((s) => s.type === "input");
+    const rootTurnId = hasUserInput ? turnId : signals.find((s) => s.rootTurnId !== void 0)?.rootTurnId;
+    const causationId = signals[0]?.id;
+    const turnEnv = {
+      turnId,
+      ...rootTurnId !== void 0 && { rootTurnId },
+      ...causationId !== void 0 && { causationId },
+      actor: { kind: "controller", id: this.id }
+    };
+    this.state.set("dynamicState.currentTurn", turnEnv);
+    this.lastTurnId = turnId;
+    this.recorder.beginTurn();
     for (const sig of signals) {
-      this.state.append("conversation", signalToEntry(sig, ts));
+      const entry = signalToEntry(sig, ts, this.ctx.sessionId);
+      applyTurnEnvelope(entry, turnEnv);
+      this.state.append("conversation", entry);
     }
     this.state.set("dynamicState.streamingEntries", []);
     let streamingEntry = this.createStreamingEntry();
@@ -6035,10 +6681,18 @@ var ControllerAgent = class _ControllerAgent extends BaseAgent {
       onStreamError: (err) => {
         this.logger.error({ agent: "controller", err }, "LLM stream error");
       },
-      onStep: (event) => {
+      onStep: (event, meta) => {
         const streamingEntries = this.state.get("dynamicState.streamingEntries");
         const streamingUuid = streamingEntries?.[0]?.uuid;
-        const entry = buildAssistantEntry(event, this.id, streamingUuid);
+        const entry = buildAssistantEntry(event, this.ctx.sessionId, streamingUuid, {
+          startedAt: meta?.startedAt,
+          firstTokenAt: meta?.firstTokenAt,
+          temperature: this.provider.temperature,
+          maxOutputTokens: this.provider.maxOutputTokens,
+          recordedToolCalls: (toolCallId) => this.recorder.lookup(toolCallId)
+        });
+        applyTurnEnvelope(entry, turnEnv);
+        syncStepTimestamps(entry);
         this.state.append("conversation", entry);
         this.state.set("dynamicState.streamingEntries", []);
       }
@@ -6063,7 +6717,7 @@ var ControllerAgent = class _ControllerAgent extends BaseAgent {
       type: "assistant" /* Assistant */,
       uuid: generateId("s"),
       parentUuid: null,
-      sessionId: "controller",
+      sessionId: this.ctx.sessionId,
       timestamp: nowISO(),
       message: { role: "assistant", content: "" }
     };
@@ -6071,6 +6725,10 @@ var ControllerAgent = class _ControllerAgent extends BaseAgent {
   /** Restore persisted state (conversation, runtime). Called by Supervisor. */
   async restore() {
     await this.state.restore();
+    const summary = this.state.get("compactSummary");
+    if (summary) {
+      this.contextManager.restoreCompact(summary);
+    }
   }
   /** Initialize session metadata. Called by Supervisor at start. */
   initSession(session) {
@@ -6083,15 +6741,29 @@ var ControllerAgent = class _ControllerAgent extends BaseAgent {
   /** Surface an error in the UI as a system conversation entry. */
   reportError(message) {
     this.state.set("dynamicState.streamingEntries", []);
-    this.state.append("conversation", {
+    const errTs = nowISO();
+    const entry = {
       type: "system" /* System */,
       uuid: generateId("err"),
       parentUuid: null,
-      sessionId: "controller",
-      timestamp: nowISO(),
+      sessionId: this.ctx.sessionId,
+      timestamp: errTs,
       subtype: "error" /* Error */,
-      content: message
-    });
+      content: message,
+      // Point-in-time event: startedAt/endedAt share the recording moment.
+      startedAt: errTs,
+      endedAt: errTs
+    };
+    applyTurnEnvelope(entry, this.lastTurnId !== null ? { turnId: this.lastTurnId, actor: { kind: "controller", id: this.id } } : void 0);
+    this.state.append("conversation", entry);
+  }
+  /** Read-only turn index over the controller conversation. */
+  getConversationIndex() {
+    return this.state.getConversationIndex();
+  }
+  /** Look up one turn by id. */
+  getTurn(turnId) {
+    return this.state.getTurn(turnId);
   }
   // --- Subscribable ---
   subscribe(path7, callback) {
@@ -6112,28 +6784,36 @@ var ControllerAgent = class _ControllerAgent extends BaseAgent {
    */
   async performCompaction() {
     try {
-      await this.contextManager.compact(async (entries) => {
-        const entryTexts = entries.map((e, i) => {
-          const content = e.message?.content ?? e.content ?? "";
-          return `[${i}] (${e.type}) ${String(content).slice(0, 300)}`;
-        });
-        let lastError;
-        for (let attempt = 0; attempt <= COMPACT_MAX_RETRIES; attempt++) {
-          try {
-            const { text } = await generateText({
-              model: this.model,
-              // WayangModel opaque boundary
-              system: SUMMARIZER_SYSTEM_PROMPT,
-              prompt: buildSummarizerPrompt(entryTexts)
-            });
-            return text;
-          } catch (err) {
-            lastError = err;
-            this.logger.warn({ attempt: attempt + 1, error: String(err) }, "Compaction summarizer failed");
+      const previousSummary = this.contextManager.getCompactSummary();
+      await this.contextManager.compact(
+        async (entries) => {
+          const entryTexts = entries.map((e, i) => {
+            const content = e.message?.content ?? e.content ?? "";
+            return `[${i}] (${e.type}) ${String(content).slice(0, 300)}`;
+          });
+          if (previousSummary) {
+            entryTexts.unshift(`[Previous Summary]
+${previousSummary}`);
           }
-        }
-        throw lastError;
-      });
+          let lastError;
+          for (let attempt = 0; attempt <= COMPACT_MAX_RETRIES; attempt++) {
+            try {
+              const { text } = await generateText({
+                model: this.model,
+                // WayangModel opaque boundary
+                system: SUMMARIZER_SYSTEM_PROMPT,
+                prompt: buildSummarizerPrompt(entryTexts)
+              });
+              return text;
+            } catch (err) {
+              lastError = err;
+              this.logger.warn({ attempt: attempt + 1, error: String(err) }, "Compaction summarizer failed");
+            }
+          }
+          throw lastError;
+        },
+        { model: this.provider.modelName }
+      );
     } catch (err) {
       this.logger.warn({ error: String(err) }, "Compaction failed, falling back to half-truncation");
       const conversation = this.state.get("conversation");
@@ -6145,28 +6825,36 @@ var ControllerAgent = class _ControllerAgent extends BaseAgent {
     }
   }
 };
-function signalBase(ts) {
+function signalBase(ts, sessionId) {
   return {
     type: "signal" /* Signal */,
     uuid: generateId("sig"),
     parentUuid: null,
-    sessionId: "controller",
+    sessionId,
     timestamp: ts
   };
 }
+function isoMs(ms) {
+  if (typeof ms !== "number" || !Number.isFinite(ms)) return void 0;
+  return new Date(ms).toISOString();
+}
 var signalConverters = {
-  input: (sig, ts) => ({
+  input: (sig, ts, sessionId) => ({
     type: "user" /* User */,
     uuid: generateId("u"),
     parentUuid: null,
-    sessionId: "controller",
+    sessionId,
     timestamp: ts,
+    actor: { kind: "user", id: "user" },
+    startedAt: isoMs(sig.timestamp),
+    // Delivery/processing of the input is complete when it is recorded here.
+    endedAt: ts,
     message: { role: "user", content: sig.payload.text }
   }),
-  completed: (sig, ts) => {
+  completed: (sig, ts, sessionId) => {
     const p = sig.payload;
     return {
-      ...signalBase(ts),
+      ...signalBase(ts, sessionId),
       subtype: "worker_completed" /* WorkerCompleted */,
       workerId: p.workerId,
       workerType: p.workerType,
@@ -6176,10 +6864,10 @@ var signalConverters = {
       content: p.summary ?? JSON.stringify(sig.payload)
     };
   },
-  failed: (sig, ts) => {
+  failed: (sig, ts, sessionId) => {
     const p = sig.payload;
     return {
-      ...signalBase(ts),
+      ...signalBase(ts, sessionId),
       subtype: "worker_failed" /* WorkerFailed */,
       workerId: p.workerId,
       workerType: p.workerType,
@@ -6189,10 +6877,10 @@ var signalConverters = {
       content: p.error
     };
   },
-  progress: (sig, ts) => {
+  progress: (sig, ts, sessionId) => {
     const p = sig.payload;
     return {
-      ...signalBase(ts),
+      ...signalBase(ts, sessionId),
       subtype: "worker_progress" /* WorkerProgress */,
       workerId: p.workerId,
       workerType: p.workerType,
@@ -6202,11 +6890,11 @@ var signalConverters = {
       content: p.message
     };
   },
-  heartbeat: (sig, ts) => {
+  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(", ");
     return {
-      ...signalBase(ts),
+      ...signalBase(ts, sessionId),
       subtype: "heartbeat" /* Heartbeat */,
       taskTitle: "heartbeat",
       content: `[HEARTBEAT] ${p.reason}
@@ -6215,10 +6903,10 @@ Workers: ${workerSummary}
 Pending tasks: ${p.pendingTaskCount}`
     };
   },
-  permission_request: (sig, ts) => {
+  permission_request: (sig, ts, sessionId) => {
     const p = sig.payload;
     return {
-      ...signalBase(ts),
+      ...signalBase(ts, sessionId),
       subtype: "permission_request" /* PermissionRequest */,
       workerId: p.workerId,
       workerType: p.workerType,
@@ -6231,10 +6919,10 @@ Request ID: ${p.requestId}
 Use respond_permission to approve or deny.`
     };
   },
-  cancelled: (sig, ts) => {
+  cancelled: (sig, ts, sessionId) => {
     const p = sig.payload;
     return {
-      ...signalBase(ts),
+      ...signalBase(ts, sessionId),
       subtype: "worker_disposed" /* WorkerDisposed */,
       workerId: p.workerId,
       workerType: p.workerType,
@@ -6244,11 +6932,24 @@ Use respond_permission to approve or deny.`
       content: `[WORKER DISPOSED] Idle (multi-stage) worker ${p.workerId} was disposed (reaped by timeout or manually). No task failed \u2014 its last stage already completed. If you still need this worker's context, create a fresh multi-stage task instead.`
     };
   },
-  previous_session_tasks: (sig, ts) => {
+  task_cancelled: (sig, ts, sessionId) => {
+    const p = sig.payload;
+    return {
+      ...signalBase(ts, sessionId),
+      subtype: "task_cancelled" /* TaskCancelled */,
+      workerId: p.workerId,
+      workerType: p.workerType,
+      emoji: p.emoji,
+      taskId: p.taskId,
+      taskTitle: p.taskTitle ?? "task_cancelled",
+      content: `[TASK CANCELLED] Task ${p.taskId}${p.taskTitle ? ` (${p.taskTitle})` : ""} was cancelled by the user/controller. This is not a failure \u2014 the task terminated as cancelled.`
+    };
+  },
+  previous_session_tasks: (sig, ts, sessionId) => {
     const p = sig.payload;
     const lines = p.tasks.map((t) => `- [${t.status}] ${t.title} (id: ${t.taskId}): ${t.description}`);
     return {
-      ...signalBase(ts),
+      ...signalBase(ts, sessionId),
       subtype: "previous_session_tasks" /* PreviousSessionTasks */,
       taskTitle: "previous_session_tasks",
       content: `[PREVIOUS SESSION] ${p.tasks.length} unfinished task(s) from session ${p.sessionId} (last active ${new Date(p.lastActiveAt).toLocaleString()}):
@@ -6257,20 +6958,43 @@ Workers were NOT resumed. Decide: re-dispatch with add_task, treat as stale, or
     };
   }
 };
-function signalToEntry(sig, ts) {
+function signalToEntry(sig, ts, sessionId) {
   const converter = signalConverters[sig.type];
-  if (converter) return converter(sig, ts);
-  const p = sig.payload;
-  return {
-    ...signalBase(ts),
-    subtype: "worker_failed" /* WorkerFailed */,
-    workerId: p.workerId,
-    workerType: p.workerType,
-    emoji: p.emoji,
-    taskId: p.taskId,
-    taskTitle: p.taskTitle ?? sig.type,
-    content: JSON.stringify(sig.payload)
-  };
+  let entry;
+  if (converter) {
+    entry = converter(sig, ts, sessionId);
+  } else {
+    const p = sig.payload;
+    entry = {
+      ...signalBase(ts, sessionId),
+      subtype: "worker_failed" /* WorkerFailed */,
+      workerId: p.workerId,
+      workerType: p.workerType,
+      emoji: p.emoji,
+      taskId: p.taskId,
+      taskTitle: p.taskTitle ?? sig.type,
+      content: JSON.stringify(sig.payload)
+    };
+  }
+  if (entry.type === "signal" /* Signal */) {
+    const s = entry;
+    s.signalId = sig.id;
+    if (sig.rootTurnId !== void 0) s.rootTurnId = sig.rootTurnId;
+    if (sig.causationId !== void 0) s.causationId = sig.causationId;
+    s.startedAt = isoMs(sig.timestamp);
+    s.endedAt = ts;
+    const payload = sig.payload;
+    if (sig.source === "worker" && typeof payload.workerId === "string") {
+      s.actor = {
+        kind: "worker",
+        id: payload.workerId,
+        ...typeof payload.taskId === "string" && { taskId: payload.taskId }
+      };
+    } else if (sig.source === "system") {
+      s.actor = { kind: "system", id: "system" };
+    }
+  }
+  return entry;
 }
 
 // src/services/skills/registry.ts
@@ -6545,6 +7269,15 @@ var Supervisor = class {
   resolveInquiry(answer) {
     this.controllerAgent.resolveInquiry(answer);
   }
+  // --- Read-only conversation index (WebUI / audit) ---
+  /** Grouped turn view over the controller conversation. */
+  getConversationIndex() {
+    return this.controllerAgent.getConversationIndex();
+  }
+  /** Look up one turn of the controller conversation by id. */
+  getTurn(turnId) {
+    return this.controllerAgent.getTurn(turnId);
+  }
   // --- Shutdown ---
   async shutdown() {
     this.controllerLoop.shutdown();
@@ -6591,6 +7324,96 @@ var RpcServer = class {
   }
 };
 
+// src/services/conversation/turn-serialize.ts
+var DEFAULT_TURN_TEXT_LIMIT = 2e3;
+function cut(text, limit) {
+  if (text === void 0) return { value: "", truncated: false };
+  if (text.length <= limit) return { value: text, truncated: false };
+  return { value: `${text.slice(0, limit)}\u2026[truncated]`, truncated: true };
+}
+function serializeTurnView(view, limits = {}) {
+  const textLimit = limits.maxTextLength ?? DEFAULT_TURN_TEXT_LIMIT;
+  return {
+    turnId: view.turnId,
+    ...view.rootTurnId !== void 0 && { rootTurnId: view.rootTurnId },
+    ...view.actor !== void 0 && { actor: view.actor },
+    ...view.startedAt !== void 0 && { startedAt: view.startedAt },
+    ...view.endedAt !== void 0 && { endedAt: view.endedAt },
+    status: view.status,
+    ...view.userEntry !== void 0 && (() => {
+      const u = cut(view.userEntry.message?.content, textLimit);
+      return {
+        userEntry: {
+          uuid: view.userEntry.uuid,
+          timestamp: view.userEntry.timestamp,
+          content: u.value,
+          contentTruncated: u.truncated
+        }
+      };
+    })(),
+    steps: view.steps.map((step) => {
+      const content = cut(step.message?.content, textLimit);
+      const reasoning = step.message?.reasoning !== void 0 ? cut(step.message.reasoning, textLimit) : void 0;
+      return {
+        uuid: step.uuid,
+        ...step.stepIndex !== void 0 && { stepIndex: step.stepIndex },
+        timestamp: step.timestamp,
+        content: content.value,
+        contentTruncated: content.truncated,
+        ...reasoning !== void 0 && {
+          reasoning: reasoning.value,
+          reasoningTruncated: reasoning.truncated
+        },
+        ...step.finishReason !== void 0 && { finishReason: step.finishReason },
+        ...step.model !== void 0 && { model: step.model },
+        ...step.timing !== void 0 && { timing: step.timing },
+        ...step.requestId !== void 0 && { requestId: step.requestId },
+        ...step.message?.usage !== void 0 && { usage: step.message.usage },
+        toolCallCount: step.toolCalls?.length ?? 0,
+        toolResultCount: step.toolResults?.length ?? 0
+      };
+    }),
+    signals: view.signals.map((sig) => {
+      const c = cut(sig.content, textLimit);
+      return {
+        uuid: sig.uuid,
+        subtype: sig.subtype,
+        ...sig.signalId !== void 0 && { signalId: sig.signalId },
+        ...sig.workerId !== void 0 && { workerId: sig.workerId },
+        ...sig.taskId !== void 0 && { taskId: sig.taskId },
+        taskTitle: sig.taskTitle,
+        timestamp: sig.timestamp,
+        content: c.value,
+        contentTruncated: c.truncated
+      };
+    }),
+    toolCalls: view.toolCalls,
+    usage: view.usage,
+    entryIds: view.entryIds
+  };
+}
+function summarizeTurn(view, limits = {}) {
+  const previewLimit = Math.min(limits.maxTextLength ?? 200, 200);
+  const preview = view.userEntry !== void 0 ? cut(view.userEntry.message?.content, previewLimit) : void 0;
+  return {
+    turnId: view.turnId,
+    ...view.rootTurnId !== void 0 && { rootTurnId: view.rootTurnId },
+    ...view.actor !== void 0 && { actor: view.actor },
+    ...view.startedAt !== void 0 && { startedAt: view.startedAt },
+    ...view.endedAt !== void 0 && { endedAt: view.endedAt },
+    status: view.status,
+    usage: view.usage,
+    stepCount: view.steps.length,
+    signalCount: view.signals.length,
+    toolCallCount: view.toolCalls.length,
+    entryCount: view.entryIds.length,
+    ...preview !== void 0 && {
+      userPreview: preview.value,
+      userPreviewTruncated: preview.truncated
+    }
+  };
+}
+
 // src/server/wayang-server.ts
 async function runWayangServer(options, io = process) {
   const config = await loadConfig(options.configPath, { nonInteractive: true });
@@ -6703,6 +7526,24 @@ async function runWayangServer(options, io = process) {
     const data = target.getSnapshot(requiredString(params, "path"));
     return { data: data === void 0 ? null : data };
   });
+  rpc.register(METHOD.CONVERSATION_LIST_TURNS, (params) => {
+    const index = supervisor.getConversationIndex();
+    const limit = optionalInt(params, "limit", 50, 1, 500);
+    const offset = optionalInt(params, "offset", 0, 0, Number.MAX_SAFE_INTEGER);
+    const turns = index.turns.slice(offset, offset + limit).map((view) => summarizeTurn(view, { maxTextLength: optionalInt(params, "previewLength", 200, 1, 2e3) }));
+    return { total: index.turns.length, offset, limit, turns };
+  });
+  rpc.register(METHOD.CONVERSATION_GET_TURN, (params) => {
+    const turnId = requiredString(params, "turnId");
+    const view = supervisor.getTurn(turnId);
+    if (!view) {
+      throw new RpcError(RPC_ERROR.INVALID_PARAMS, `Unknown turnId: ${turnId}`);
+    }
+    return serializeTurnView(view, {
+      // Optional — falls back to the serializer's DEFAULT_TURN_TEXT_LIMIT.
+      maxTextLength: optionalInt(params, "maxTextLength", DEFAULT_TURN_TEXT_LIMIT, 1, 1e5)
+    });
+  });
   rpc.register(METHOD.SHUTDOWN, () => {
     setImmediate(() => {
       void supervisor.shutdown().catch(() => {
@@ -6727,6 +7568,19 @@ function requiredString(params, key) {
   }
   return value;
 }
+function optionalInt(params, key, defaultValue, min, max) {
+  const raw = params[key];
+  if (raw === void 0 || raw === null) {
+    if (defaultValue === void 0) {
+      throw new RpcError(RPC_ERROR.INVALID_PARAMS, `Missing required number param: ${key}`);
+    }
+    return defaultValue;
+  }
+  if (typeof raw !== "number" || !Number.isInteger(raw) || raw < min || raw > max) {
+    throw new RpcError(RPC_ERROR.INVALID_PARAMS, `Param ${key} must be an integer in [${min}, ${max}]`);
+  }
+  return raw;
+}
 
 // src/server/main.ts
 async function serverMain(options) {