@blade-hq/agent-kit 1.0.14 → 1.0.16

package/dist/{chunk-3UY7SD3P.js → chunk-QEYZZDLM.js}

@@ -3,7 +3,7 @@ import {
 } from "./chunk-J3XVFPOV.js";
 import {
   BladeClient
-} from "./chunk-DN4CKDDQ.js";
+} from "./chunk-V74REX3Q.js";
 import {
   createClientActions,
   useCardStateStore
@@ -571,6 +571,1059 @@ function isUiMeta(value) {
   return true;
 }
 
+// src/react/projection/helpers.ts
+function upsertToolCall(state, toolCallId, toolName, displayName, args) {
+  if (!toolCallId) return;
+  let found = false;
+  for (let i = 0; i < state.toolCalls.length; i++) {
+    if (state.toolCalls[i].id !== toolCallId) continue;
+    const tc = state.toolCalls[i];
+    state.toolCalls[i] = {
+      ...tc,
+      tool_name: toolName || tc.tool_name,
+      display_name: displayName || tc.display_name,
+      arguments: args || tc.arguments
+    };
+    found = true;
+    break;
+  }
+  if (!found) {
+    state.toolCalls.push({
+      id: toolCallId,
+      tool_name: toolName,
+      display_name: displayName,
+      arguments: args,
+      status: "pending"
+    });
+  }
+  let blockFound = false;
+  for (let i = 0; i < state.blocks.length; i++) {
+    const b = state.blocks[i];
+    if (b.type !== "tool_use" || b.tool_call_id !== toolCallId) continue;
+    state.blocks[i] = {
+      ...b,
+      content: args || b.content,
+      tool_name: toolName || b.tool_name,
+      display_name: displayName || b.display_name
+    };
+    blockFound = true;
+    break;
+  }
+  if (!blockFound) {
+    state.blocks.push({
+      type: "tool_use",
+      content: args,
+      tool_call_id: toolCallId,
+      tool_name: toolName || null,
+      display_name: displayName || null
+    });
+  }
+}
+function applyToolResult(state, toolCallId, result, status, durationMs, sourceLoop) {
+  let toolName = "";
+  let displayName = "";
+  let finalResult = result;
+  for (let i = 0; i < state.toolCalls.length; i++) {
+    const tc = state.toolCalls[i];
+    if (tc.id !== toolCallId) continue;
+    if (typeof result === "string") {
+      finalResult = maybeEnrichAskUserResult(tc.tool_name, result, sourceLoop);
+    }
+    const update = { status, result: finalResult };
+    if (durationMs != null) update.duration_ms = durationMs;
+    state.toolCalls[i] = { ...tc, ...update };
+    toolName = tc.tool_name;
+    displayName = tc.display_name;
+    break;
+  }
+  state.blocks.push({
+    type: "tool_result",
+    content: finalResult,
+    tool_call_id: toolCallId,
+    tool_name: toolName || null,
+    display_name: displayName || null
+  });
+}
+function appendTextBlock(state, blockType, content) {
+  if (content == null || content === "") return;
+  const text = String(content);
+  const lastBlock = state.blocks[state.blocks.length - 1];
+  if (lastBlock && lastBlock.type === blockType && typeof lastBlock.content === "string") {
+    state.blocks[state.blocks.length - 1] = {
+      ...lastBlock,
+      content: lastBlock.content + text
+    };
+    return;
+  }
+  state.blocks.push({ type: blockType, content: text });
+}
+function appendToolCallArguments(state, toolCallId, delta) {
+  let newArgs = "";
+  for (let i = 0; i < state.toolCalls.length; i++) {
+    const tc = state.toolCalls[i];
+    if (tc.id === toolCallId) {
+      newArgs = tc.arguments + delta;
+      state.toolCalls[i] = { ...tc, arguments: newArgs };
+      break;
+    }
+  }
+  if (!newArgs) return;
+  for (let i = 0; i < state.blocks.length; i++) {
+    const b = state.blocks[i];
+    if (b.type === "tool_use" && b.tool_call_id === toolCallId) {
+      state.blocks[i] = { ...b, content: newArgs };
+      break;
+    }
+  }
+}
+function maybeEnrichAskUserResult(toolName, result, sourceLoop) {
+  if (!sourceLoop) return result;
+  const normalized = toolName.includes(":") ? toolName.split(":").pop() : toolName;
+  if (normalized !== "AskUserQuestion") return result;
+  try {
+    const payload = JSON.parse(result);
+    if (typeof payload !== "object" || payload === null) return result;
+    payload.source_loop = sourceLoop;
+    return JSON.stringify(payload);
+  } catch {
+    return result;
+  }
+}
+function buildSystemNotificationTurn(sequence, turnId, loopId, notificationType, status, title, detail, metadata) {
+  return {
+    id: turnId,
+    sequence,
+    turn_id: turnId,
+    loop_id: loopId,
+    kind: "message",
+    role: "system",
+    status: "completed",
+    blocks: [
+      {
+        type: "system_notification",
+        content: {
+          notification_type: notificationType,
+          status,
+          title,
+          detail,
+          metadata
+        }
+      }
+    ],
+    tool_calls: [],
+    model: null,
+    usage: null,
+    duration_ms: 0
+  };
+}
+function buildSystemNotificationBlock(notificationType, status, title, detail, metadata) {
+  return {
+    type: "system_notification",
+    content: {
+      notification_type: notificationType,
+      status,
+      title,
+      detail,
+      metadata
+    }
+  };
+}
+function buildMarkerTurn(sequence, turnId, loopId, blockType, content) {
+  return {
+    id: turnId,
+    sequence,
+    turn_id: turnId,
+    loop_id: loopId,
+    kind: "message",
+    role: "assistant",
+    status: "completed",
+    blocks: [{ type: blockType, content }],
+    tool_calls: [],
+    model: null,
+    usage: null,
+    duration_ms: 0
+  };
+}
+function buildCompactionTurn(sequence, compactionId, loopId, status, data) {
+  const tokensBefore = asInt(data.tokens_before);
+  const tokensAfter = asInt(data.tokens_after);
+  let savedRatio = null;
+  if (tokensBefore && tokensBefore > 0 && tokensAfter != null) {
+    savedRatio = 1 - tokensAfter / tokensBefore;
+  } else {
+    savedRatio = asFloat(data.saved_ratio);
+  }
+  let archivedCount = asInt(data.archived_count);
+  if (archivedCount == null && Array.isArray(data.archived_files)) {
+    archivedCount = data.archived_files.length;
+  }
+  const content = data.content;
+  const summaryFull = compactionSummaryFull(content);
+  const summaryPreview = summaryFull ? summaryFull.split("\n").map((l) => l.trim()).filter(Boolean).join(" ").slice(0, 200) : null;
+  return {
+    id: `compaction:${compactionId}`,
+    sequence,
+    turn_id: `compaction:${compactionId}`,
+    loop_id: loopId,
+    kind: "compaction",
+    role: "system",
+    status,
+    blocks: [],
+    tool_calls: [],
+    model: null,
+    usage: null,
+    duration_ms: 0,
+    compaction_id: compactionId,
+    summary_preview: summaryPreview,
+    summary_full: summaryFull,
+    archived_count: archivedCount,
+    tokens_before: tokensBefore,
+    tokens_after: tokensAfter,
+    saved_ratio: savedRatio,
+    trigger: asTrigger(data.trigger),
+    failure_reason: typeof data.reason === "string" && data.reason ? data.reason : null,
+    fallback_applied: typeof data.fallback_applied === "boolean" ? data.fallback_applied : null
+  };
+}
+function compactionSummaryFull(content) {
+  const text = String(content ?? "");
+  if (!text) return null;
+  const cleaned = text.replace("<compaction-summary>", "").replace("</compaction-summary>", "").replace(/\r\n/g, "\n").replace(/\r/g, "\n").trim();
+  return cleaned || null;
+}
+function asInt(value) {
+  if (typeof value === "boolean") return null;
+  if (typeof value === "number") return Math.trunc(value);
+  return null;
+}
+function asFloat(value) {
+  if (typeof value === "boolean") return null;
+  if (typeof value === "number") return value;
+  return null;
+}
+function asTrigger(value) {
+  if (value === "auto" || value === "manual" || value === "forced_retry") return value;
+  return null;
+}
+function setToolCallStatus(turn, toolCallId, status, result, pendingQuestionRef) {
+  if (!turn || !toolCallId) return;
+  const toolCalls = "toolCalls" in turn ? turn.toolCalls : turn.tool_calls;
+  for (let i = 0; i < toolCalls.length; i++) {
+    if (toolCalls[i].id !== toolCallId) continue;
+    toolCalls[i] = {
+      ...toolCalls[i],
+      status,
+      result,
+      pending_question_ref: pendingQuestionRef
+    };
+    return;
+  }
+}
+function applyAskUserPauseToTurn(turn, pauseToolData, toolCallId, childLoopName, description, displayNameResolver) {
+  if (!turn || !toolCallId) return;
+  const sourceLoop = childLoopName ? { loop_name: childLoopName, description } : null;
+  const toolName = String(pauseToolData.name ?? "AskUserQuestion");
+  const args = JSON.stringify(pauseToolData.arguments ?? {});
+  const result = askUserResultFromPausePayload(pauseToolData, sourceLoop);
+  const isTurnState = "toolCalls" in turn;
+  const toolCalls = isTurnState ? turn.toolCalls : turn.tool_calls;
+  const blocks = turn.blocks;
+  const displayName = displayNameResolver(toolName);
+  let found = false;
+  for (let i = 0; i < toolCalls.length; i++) {
+    if (toolCalls[i].id !== toolCallId) continue;
+    toolCalls[i] = {
+      ...toolCalls[i],
+      tool_name: toolName || toolCalls[i].tool_name,
+      display_name: displayName || toolCalls[i].display_name,
+      arguments: args || toolCalls[i].arguments
+    };
+    found = true;
+    break;
+  }
+  if (!found) {
+    toolCalls.push({
+      id: toolCallId,
+      tool_name: toolName,
+      display_name: displayName,
+      arguments: args,
+      status: "pending"
+    });
+  }
+  let blockFound = false;
+  for (let i = 0; i < blocks.length; i++) {
+    if (blocks[i].type !== "tool_use" || blocks[i].tool_call_id !== toolCallId) continue;
+    blocks[i] = { ...blocks[i], content: args, tool_name: toolName, display_name: displayName };
+    blockFound = true;
+    break;
+  }
+  if (!blockFound) {
+    blocks.push({
+      type: "tool_use",
+      content: args,
+      tool_call_id: toolCallId,
+      tool_name: toolName,
+      display_name: displayName
+    });
+  }
+  setToolCallStatus(turn, toolCallId, "awaiting_answer", result, null);
+  let resultBlockFound = false;
+  for (let i = 0; i < blocks.length; i++) {
+    if (blocks[i].type !== "tool_result" || blocks[i].tool_call_id !== toolCallId) continue;
+    blocks[i] = { ...blocks[i], content: result };
+    resultBlockFound = true;
+    break;
+  }
+  if (!resultBlockFound) {
+    blocks.push({
+      type: "tool_result",
+      content: result,
+      tool_call_id: toolCallId,
+      tool_name: toolName,
+      display_name: displayName
+    });
+  }
+}
+function applyChildPauseToParent(parentTurn, parentToolCallId, childLoopName, childToolCallId, description, displayNameResolver) {
+  if (!parentTurn || !parentToolCallId) return;
+  const toolCalls = "toolCalls" in parentTurn ? parentTurn.toolCalls : parentTurn.tool_calls;
+  const blocks = parentTurn.blocks;
+  const displayName = displayNameResolver("Agent");
+  let found = false;
+  for (let i = 0; i < toolCalls.length; i++) {
+    if (toolCalls[i].id !== parentToolCallId) continue;
+    toolCalls[i] = {
+      ...toolCalls[i],
+      tool_name: "Agent",
+      display_name: displayName || toolCalls[i].display_name
+    };
+    found = true;
+    break;
+  }
+  if (!found) {
+    toolCalls.push({
+      id: parentToolCallId,
+      tool_name: "Agent",
+      display_name: displayName,
+      arguments: "",
+      status: "pending"
+    });
+  }
+  let blockFound = false;
+  for (let i = 0; i < blocks.length; i++) {
+    if (blocks[i].type !== "tool_use" || blocks[i].tool_call_id !== parentToolCallId) continue;
+    blockFound = true;
+    break;
+  }
+  if (!blockFound) {
+    blocks.push({
+      type: "tool_use",
+      content: "",
+      tool_call_id: parentToolCallId,
+      tool_name: "Agent",
+      display_name: displayName
+    });
+  }
+  setToolCallStatus(parentTurn, parentToolCallId, "awaiting_answer", null, {
+    child_loop_name: childLoopName,
+    child_tool_call_id: childToolCallId,
+    description: description || null
+  });
+}
+function askUserResultFromPausePayload(pauseToolData, sourceLoop) {
+  const args = typeof pauseToolData.arguments === "object" && pauseToolData.arguments !== null ? pauseToolData.arguments : {};
+  const payload = { questions: args.questions ?? [] };
+  if (sourceLoop) payload.source_loop = sourceLoop;
+  return JSON.stringify(payload);
+}
+function sourceLoopFor(loopId, loopDescriptions) {
+  if (loopId === "root") return null;
+  const description = loopDescriptions.get(loopId);
+  if (!description) return null;
+  return { loop_name: loopId, description };
+}
+function normalizeChildPause(pausePayload) {
+  const rawPtd = pausePayload.pause_tool_data;
+  const pauseToolData = typeof rawPtd === "object" && rawPtd !== null ? { ...rawPtd } : { ...pausePayload };
+  let sourceLoop = pauseToolData.source_loop;
+  if (typeof sourceLoop !== "object" || sourceLoop === null) {
+    sourceLoop = pausePayload.source_loop;
+  }
+  const childLoopName = String(pausePayload.child_loop_name ?? "") || (typeof sourceLoop === "object" && sourceLoop ? String(sourceLoop.name ?? "") : "");
+  const childToolCallId = String(
+    pausePayload.child_pause_tool_call_id ?? pauseToolData.tool_call_id ?? ""
+  );
+  const description = typeof sourceLoop === "object" && sourceLoop ? String(sourceLoop.description ?? "") : "";
+  if (childLoopName && description) {
+    pauseToolData.source_loop = { name: childLoopName, description };
+  }
+  return { pauseToolData, childLoopName, childToolCallId, description };
+}
+
+// src/react/schemas/message.ts
+function inferToolStatus(resultStr) {
+  if (resultStr.includes('"Cancelled by user"')) return "cancelled";
+  try {
+    const parsed = JSON.parse(resultStr);
+    if (typeof parsed === "object" && parsed !== null) {
+      if ("error" in parsed && parsed.error) return "error";
+      const nested = parsed.result;
+      if (typeof nested === "object" && nested !== null && "error" in nested && nested.error) {
+        return "error";
+      }
+    }
+  } catch {
+  }
+  return "done";
+}
+
+// src/react/projection/state.ts
+function createTurnState(turnId, loopId, opts = {}) {
+  return {
+    turnId,
+    loopId,
+    role: "assistant",
+    model: opts.model ?? null,
+    startedAt: Date.now(),
+    contextWindow: opts.contextWindow ?? 0,
+    blocks: [],
+    toolCalls: [],
+    usage: null,
+    memoryRefs: opts.memoryRefs ?? null,
+    parentForkToolCallId: null
+  };
+}
+function snapshot(state, sequence, status) {
+  return {
+    id: state.turnId,
+    sequence,
+    turn_id: state.turnId,
+    loop_id: state.loopId,
+    kind: "message",
+    role: state.role,
+    status,
+    blocks: [...state.blocks],
+    tool_calls: [...state.toolCalls],
+    model: state.model,
+    usage: state.usage ? { ...state.usage } : null,
+    duration_ms: Math.max(0, Date.now() - state.startedAt),
+    started_at: new Date(state.startedAt).toISOString(),
+    context_window: state.contextWindow,
+    memory_refs: state.memoryRefs,
+    parent_fork_tool_call_id: state.parentForkToolCallId
+  };
+}
+var PAUSE_TOOL_NAMES = /* @__PURE__ */ new Set(["AskUserQuestion", "ExitPlanMode"]);
+function toolStatusFromResult(result) {
+  const text = typeof result === "string" ? result : Array.isArray(result) ? result.filter(
+    (p) => typeof p === "object" && p !== null && p.type === "text"
+  ).map((p) => p.text ?? "").join("\n") : String(result ?? "");
+  return inferToolStatus(text);
+}
+
+// src/react/projection/builder.ts
+var ClientProjectionBuilder = class {
+  activeTurns = /* @__PURE__ */ new Map();
+  lastTurnIds = /* @__PURE__ */ new Map();
+  latestTurns = /* @__PURE__ */ new Map();
+  loopDescriptions = /* @__PURE__ */ new Map();
+  pendingChildPauses = /* @__PURE__ */ new Map();
+  pendingMemoryRefs = /* @__PURE__ */ new Map();
+  activeCompactions = /* @__PURE__ */ new Map();
+  seq = 0;
+  syntheticCounter = 0;
+  displayNameResolver;
+  constructor(displayNameResolver) {
+    this.displayNameResolver = displayNameResolver ?? ((n) => n);
+  }
+  processBatch(events) {
+    const lastUpsertByTurn = /* @__PURE__ */ new Map();
+    const nonUpserts = [];
+    for (const event of events) {
+      const updates = this.processEvent(event);
+      if (!updates) continue;
+      for (const u of updates) {
+        if (u.kind === "upsert") {
+          lastUpsertByTurn.set(u.turn.turn_id, u);
+        } else {
+          nonUpserts.push(u);
+        }
+      }
+    }
+    return [...nonUpserts, ...lastUpsertByTurn.values()];
+  }
+  processEvent(event) {
+    const payload = event.payload;
+    const loopId = String(payload.loop_name ?? "root");
+    switch (event.type) {
+      case "memory:inject:done":
+        return this.onMemoryInject(loopId, payload);
+      case "memory:inject:none":
+        return null;
+      case "loop:turn":
+        return this.onLoopTurn(loopId, payload);
+      case "mode:change":
+        return this.onModeChange(loopId, payload);
+      case "plan:status:update":
+        return this.onPlanStatusUpdate(loopId, payload);
+      case "workspace:changed":
+        return this.onWorkspaceChanged(loopId, payload);
+      case "agent:start":
+        return this.onAgentStart(loopId, payload);
+      case "bg:started":
+        return this.onBgStarted(loopId, payload);
+      case "bg:tasks_completed":
+        return this.onBgTasksCompleted(loopId, payload);
+      case "loop:ask_user_answer":
+        return this.onAskUserAnswer(loopId, payload);
+      case "user:message":
+        return this.onUserMessage(loopId, payload);
+    }
+    if (event.type.startsWith("compaction:"))
+      return this.onCompaction(event.type, loopId, payload);
+    const state = this.activeTurns.get(loopId);
+    if (!state) {
+      if (event.type === "chat:end") {
+        this.pendingMemoryRefs.delete(loopId);
+        return null;
+      }
+      if (event.type === "agent:end") return this.onAgentEnd(null, loopId, payload);
+      return null;
+    }
+    switch (event.type) {
+      case "llm:thinking:delta":
+        return this.onDelta(state, "thinking", "", String(payload.content ?? ""));
+      case "llm:content:delta":
+        return this.onDelta(state, "text", "", String(payload.content ?? ""));
+      case "llm:tool_call:created":
+        return this.onToolCallCreated(state, payload);
+      case "llm:response:done":
+        return this.onResponseDone(state, loopId, payload);
+      case "tool:result:done":
+        return this.onToolResultDone(state, loopId, payload);
+      case "loop:tool_ui":
+        return this.onToolUi(state, payload);
+      case "loop:tool_bridge":
+        return this.onToolBridge(state, payload);
+      case "tool:approval:required":
+        return this.onToolApprovalRequired(state, payload);
+      case "loop:child_pause":
+        return this.onChildPause(state, loopId, payload);
+      case "chat:end":
+        return this.onChatEnd(state, loopId, payload);
+      case "agent:end":
+        return this.onAgentEnd(state, loopId, payload);
+      default:
+        return null;
+    }
+  }
+  reset() {
+    this.activeTurns.clear();
+    this.lastTurnIds.clear();
+    this.latestTurns.clear();
+    this.loopDescriptions.clear();
+    this.pendingChildPauses.clear();
+    this.pendingMemoryRefs.clear();
+    this.activeCompactions.clear();
+    this.seq = 0;
+    this.syntheticCounter = 0;
+  }
+  seedSequence(maxSeq) {
+    if (maxSeq > this.seq) {
+      this.seq = maxSeq;
+    }
+  }
+  // --- Event handlers ---
+  onMemoryInject(loopId, payload) {
+    const refs = payload.memory_refs;
+    const turnId = String(payload.turn_id ?? "");
+    if (Array.isArray(refs) && refs.length > 0) {
+      this.pendingMemoryRefs.set(loopId, {
+        turnId,
+        refs: refs.map((r4) => ({
+          id: Number(r4.id),
+          content_preview: String(r4.content_preview ?? ""),
+          skill_name: r4.skill_name != null ? String(r4.skill_name) : null
+        }))
+      });
+    }
+    return null;
+  }
+  onLoopTurn(loopId, payload) {
+    let turnId = String(payload.turn_id ?? this.nextTurnId(`turn:${loopId}`));
+    let memoryRefs = null;
+    const pending = this.pendingMemoryRefs.get(loopId);
+    if (pending) {
+      this.pendingMemoryRefs.delete(loopId);
+      if (pending.turnId) turnId = pending.turnId;
+      memoryRefs = pending.refs;
+    }
+    const rawCw = payload.context_window;
+    const contextWindow = typeof rawCw === "number" && rawCw > 0 ? Math.trunc(rawCw) : 0;
+    const state = createTurnState(turnId, loopId, {
+      model: optStr(payload.model),
+      contextWindow,
+      memoryRefs
+    });
+    this.activeTurns.set(loopId, state);
+    this.lastTurnIds.set(loopId, turnId);
+    const turn = snapshot(state, this.nextSeq(), "streaming");
+    this.latestTurns.set(loopId, turn);
+    return [{ kind: "upsert", turn }];
+  }
+  onModeChange(loopId, payload) {
+    const content = {};
+    if (payload.from != null && payload.from !== "") content.from = String(payload.from);
+    if (payload.to != null && payload.to !== "") content.to = String(payload.to);
+    const turn = buildMarkerTurn(
+      this.nextSeq(),
+      this.nextTurnId("mode_change"),
+      loopId,
+      "mode_change",
+      content
+    );
+    return [{ kind: "upsert", turn }];
+  }
+  onPlanStatusUpdate(loopId, payload) {
+    let statuses = payload.statuses;
+    if (typeof statuses !== "object" || statuses === null) {
+      statuses = payload._statuses ?? {};
+    }
+    const turn = buildMarkerTurn(
+      this.nextSeq(),
+      this.nextTurnId("plan_status"),
+      loopId,
+      "plan_status",
+      { plan_yaml: payload.plan_yaml ?? "", statuses }
+    );
+    return [{ kind: "upsert", turn }];
+  }
+  onWorkspaceChanged(loopId, payload) {
+    const updates = [
+      {
+        kind: "workspace_changed",
+        loopId,
+        toolCallId: optStr(payload.tool_call_id) ?? void 0,
+        toolName: toolNameFromPayload(payload) ?? void 0
+      }
+    ];
+    const state = this.activeTurns.get(loopId);
+    if (state) {
+      const turn = snapshot(state, this.nextSeq(), "streaming");
+      this.latestTurns.set(loopId, turn);
+      this.lastTurnIds.set(loopId, turn.turn_id);
+      updates.push({ kind: "upsert", turn });
+    }
+    return updates;
+  }
+  onAgentStart(loopId, payload) {
+    const description = optStr(payload.description);
+    if (description) this.loopDescriptions.set(loopId, description);
+    const turn = buildSystemNotificationTurn(
+      this.nextSeq(),
+      this.nextTurnId("agent:start"),
+      loopId,
+      "agent:start",
+      "running",
+      `Agent: ${payload.description ?? payload.skill_id ?? "agent"}`,
+      optStr(payload.prompt),
+      {
+        skill_id: optStr(payload.skill_id),
+        description: optStr(payload.description),
+        parent_fork_tool_call_id: optStr(payload.parent_fork_tool_call_id)
+      }
+    );
+    return [{ kind: "upsert", turn }];
+  }
+  onBgStarted(loopId, payload) {
+    const taskId = optStr(payload.task_id) ?? "";
+    const command = optStr(payload.command);
+    const description = optStr(payload.description);
+    const turn = buildSystemNotificationTurn(
+      this.nextSeq(),
+      this.nextTurnId("bg:started"),
+      loopId,
+      "bg:started",
+      "running",
+      description ?? `Background: ${taskId || "task"}`,
+      command,
+      { task_id: taskId, command, description }
+    );
+    return [{ kind: "upsert", turn }];
+  }
+  onBgTasksCompleted(loopId, payload) {
+    const taskIds = Array.isArray(payload.task_ids) ? payload.task_ids : [];
+    const count = typeof payload.count === "number" ? payload.count : taskIds.length;
+    const detail = taskIds.map(String).join(", ");
+    const turn = buildSystemNotificationTurn(
+      this.nextSeq(),
+      this.nextTurnId("bg:tasks_completed"),
+      loopId,
+      "bg:tasks_completed",
+      "done",
+      `Background tasks completed (${count})`,
+      detail || null,
+      { task_ids: taskIds, count }
+    );
+    return [{ kind: "upsert", turn }];
+  }
+  onAskUserAnswer(loopId, payload) {
+    const toolCallId = String(payload.tool_call_id ?? "");
+    const pending = this.pendingChildPauses.get(toolCallId);
+    const parentLoopId = pending?.parentLoopName;
+    if (pending) {
+      this.pendingChildPauses.delete(toolCallId);
+      const childTurn = this.activeTurns.get(pending.childLoopName) ?? this.latestTurns.get(pending.childLoopName);
+      setToolCallStatus(childTurn, pending.childToolCallId, "done", null, null);
+      const parentTurn = this.activeTurns.get(pending.parentLoopName) ?? this.latestTurns.get(pending.parentLoopName);
+      setToolCallStatus(parentTurn, pending.parentToolCallId, "done", null, null);
+    }
+    const directTurn = this.activeTurns.get(loopId) ?? this.latestTurns.get(loopId);
+    setToolCallStatus(directTurn, toolCallId, "done", null, null);
+    return this.collectLoopUpdates(loopId, parentLoopId);
+  }
+  onUserMessage(_loopId, payload) {
+    const entryId = String(payload.entry_id ?? this.nextTurnId("user"));
+    const displayContent = payload.display_content ?? payload.content ?? "";
+    const turn = {
+      id: entryId,
+      sequence: this.nextSeq(),
+      turn_id: entryId,
+      loop_id: "root",
+      kind: "message",
+      role: "user",
+      status: "completed",
+      blocks: [{ type: "text", content: displayContent }],
+      tool_calls: [],
+      model: null,
+      usage: null,
+      duration_ms: 0
+    };
+    return [{ kind: "upsert", turn }];
+  }
+  // --- Delta / streaming events ---
+  onDelta(state, blockType, _toolCallId, content) {
+    if (!content) return null;
+    appendTextBlock(state, blockType, content);
+    return this.syncPatch(state);
+  }
+  onToolCallCreated(state, payload) {
+    if ("arguments_delta" in payload) {
+      const delta = String(payload.arguments_delta ?? "");
+      const toolCallId2 = String(payload.id ?? "");
+      if (delta && toolCallId2) {
+        appendToolCallArguments(state, toolCallId2, delta);
+        return this.syncPatch(state);
+      }
+      return null;
+    }
+    const toolCallId = String(payload.id ?? "");
+    const toolName = toolNameFromPayload(payload);
+    const displayName = String(payload.display_name ?? "") || this.displayNameResolver(toolName);
+    const args = toolArgsFromPayload(payload);
+    upsertToolCall(state, toolCallId, toolName, displayName, args);
+    return this.syncPatch(state);
+  }
+  onResponseDone(state, loopId, payload) {
+    const model = optStr(payload.model);
+    if (model) state.model = model;
+    if (typeof payload.usage === "object" && payload.usage !== null) {
+      state.usage = { ...payload.usage };
+    }
+    const toolCalls = payload.tool_calls;
+    if (Array.isArray(toolCalls)) {
+      for (const raw of toolCalls) {
+        if (typeof raw !== "object" || raw === null) continue;
+        const tc = raw;
+        const fn = tc.function ?? {};
+        const toolName = String(fn.name ?? "");
+        const displayName = String(tc.display_name ?? "") || this.displayNameResolver(toolName);
+        upsertToolCall(
+          state,
+          String(tc.id ?? ""),
+          toolName,
+          displayName,
+          String(fn.arguments ?? "")
+        );
+      }
+    }
+    if (state.toolCalls.length === 0) {
+      return this.finalize(loopId, "completed");
+    }
+    return this.syncPatch(state);
+  }
+  onToolResultDone(state, loopId, payload) {
+    const toolCallId = String(payload.tool_call_id ?? "");
+    const content = payload.content ?? "";
+    const status = toolStatusFromResult(content);
+    const rawDuration = payload.duration_ms;
+    const durationMs = typeof rawDuration === "number" && rawDuration >= 0 ? Math.round(rawDuration) : null;
+    const sl = sourceLoopFor(state.loopId, this.loopDescriptions);
+    applyToolResult(state, toolCallId, content, status, durationMs, sl);
+    if (this.shouldFinalizeAfterToolResults(state)) {
+      return this.finalize(loopId, "completed");
+    }
+    return this.syncPatch(state);
+  }
+  onToolUi(state, payload) {
+    const toolCallId = String(payload.tool_call_id ?? "");
+    const ui = payload.ui;
+    if (toolCallId && typeof ui === "object" && ui !== null) {
+      state.blocks.push({
+        type: "tool_ui",
+        content: ui,
+        tool_call_id: toolCallId
+      });
+    }
+    return this.syncPatch(state);
+  }
+  onToolBridge(state, payload) {
+    const bridge = payload.bridge;
+    if (typeof bridge !== "object" || bridge === null) return null;
+    state.blocks.push({
+      type: "tool_bridge",
+      content: bridge,
+      tool_call_id: String(payload.tool_call_id ?? "") || null
+    });
+    return this.syncPatch(state);
+  }
+  onToolApprovalRequired(state, payload) {
+    const toolCallId = String(payload.tool_call_id ?? "");
+    const toolName = String(payload.tool_name ?? "");
+    const displayName = this.displayNameResolver(toolName);
+    upsertToolCall(state, toolCallId, toolName, displayName, "");
+    return this.syncPatch(state);
+  }
+  onChildPause(state, loopId, payload) {
+    const pauseToolData = payload.pause_tool_data;
+    if (typeof pauseToolData !== "object" || pauseToolData === null)
+      return this.syncPatch(state);
+    const ptd = pauseToolData;
+    const sourceLoop = ptd.source_loop;
+    if (typeof sourceLoop === "object" && sourceLoop) {
+      const slName = String(sourceLoop.name ?? "");
+      const slDesc = optStr(sourceLoop.description);
+      if (slName && slDesc) this.loopDescriptions.set(slName, slDesc);
+    }
+    const { childLoopName, childToolCallId, description } = normalizeChildPause(payload);
+    if (!childToolCallId) return this.syncPatch(state);
+    const existing = this.pendingChildPauses.get(childToolCallId);
+    const parentLoopName = String(
+      payload.parent_loop_name ?? existing?.parentLoopName ?? "root"
+    );
+    const parentToolCallId = String(
+      payload.parent_fork_tool_call_id ?? existing?.parentToolCallId ?? ""
+    );
+    const resolvedChildLoopName = String(payload.child_loop_name ?? "") || existing?.childLoopName || childLoopName || loopId;
+    this.pendingChildPauses.set(childToolCallId, {
+      parentLoopName,
+      parentToolCallId,
+      childLoopName: resolvedChildLoopName,
+      childToolCallId,
+      description: description || existing?.description || ""
+    });
+    applyAskUserPauseToTurn(
+      state,
+      ptd,
+      childToolCallId,
+      resolvedChildLoopName,
+      this.pendingChildPauses.get(childToolCallId).description,
+      this.displayNameResolver
+    );
+    const parentTurn = this.activeTurns.get(parentLoopName) ?? this.latestTurns.get(parentLoopName);
+    if (parentTurn) {
+      applyChildPauseToParent(
+        parentTurn,
+        parentToolCallId,
+        resolvedChildLoopName,
+        childToolCallId,
+        this.pendingChildPauses.get(childToolCallId).description,
+        this.displayNameResolver
+      );
+    }
+    return this.collectLoopUpdates(loopId, parentLoopName);
+  }
+  onChatEnd(state, loopId, payload) {
+    const status = String(payload.status ?? "completed");
+    const pauseToolData = payload.pause_tool_data;
+    if (typeof pauseToolData === "object" && pauseToolData !== null) {
+      const ptd = pauseToolData;
+      const pauseToolName = String(ptd.name ?? "");
+      const normalized = pauseToolName.includes(":") ? pauseToolName.split(":").pop() : pauseToolName;
+      const sourceLoop = ptd.source_loop;
+      if (typeof sourceLoop === "object" && sourceLoop) {
+        const slName = String(sourceLoop.name ?? "");
+        const slDesc = optStr(sourceLoop.description);
+        if (slName && slDesc) this.loopDescriptions.set(slName, slDesc);
+        if (status === "paused" && slName) {
+          applyChildPauseToParent(
+            state,
+            String(ptd.parent_fork_tool_call_id ?? ""),
+            slName,
+            String(ptd.tool_call_id ?? ""),
+            slDesc ?? "",
+            this.displayNameResolver
+          );
+          const childTurn = this.activeTurns.get(slName);
+          if (childTurn) {
+            applyAskUserPauseToTurn(
+              childTurn,
+              ptd,
+              String(ptd.tool_call_id ?? ""),
+              slName,
+              slDesc ?? "",
+              this.displayNameResolver
+            );
+          }
+        }
+      } else if (status === "paused" && normalized === "AskUserQuestion") {
+        applyAskUserPauseToTurn(
+          state,
+          ptd,
+          String(ptd.tool_call_id ?? ""),
+          "",
+          "",
+          this.displayNameResolver
+        );
+      }
+    }
+    const finalStatus = { completed: "completed", paused: "paused", failed: "failed", interrupted: "interrupted" }[status];
+    if (!finalStatus) return null;
+    if (!this.activeTurns.has(loopId)) {
+      this.pendingMemoryRefs.delete(loopId);
+    }
+    return this.finalize(loopId, finalStatus);
+  }
+  onAgentEnd(state, loopId, payload) {
+    const ok = payload.ok !== false;
+    const status = ok ? "done" : "error";
+    const title = `Agent: ${payload.description ?? payload.skill_id ?? "agent"}`;
+    const detail = optStr(payload.error);
+    const metadata = {
+      skill_id: optStr(payload.skill_id),
+      description: optStr(payload.description),
+      parent_fork_tool_call_id: optStr(payload.parent_fork_tool_call_id),
+      ok
+    };
+    if (state) {
+      state.blocks.push(buildSystemNotificationBlock("agent:end", status, title, detail, metadata));
+      return this.finalize(loopId, ok ? "completed" : "failed");
+    }
+    const turn = buildSystemNotificationTurn(
+      this.nextSeq(),
+      this.nextTurnId("agent:end"),
+      loopId,
+      "agent:end",
+      status,
+      title,
+      detail,
+      metadata
+    );
+    return [{ kind: "upsert", turn }];
+  }
+  onCompaction(eventType, loopId, payload) {
+    const compactionId = String(payload.compaction_id ?? "");
+    if (!compactionId) return null;
+    const current = {
+      ...this.activeCompactions.get(compactionId) ?? {},
+      ...payload,
+      loop_id: loopId
+    };
+    let status;
+    switch (eventType) {
+      case "compaction:start":
+        status = "streaming";
+        this.activeCompactions.set(compactionId, current);
+        break;
+      case "compaction:end":
+        status = "completed";
+        this.activeCompactions.delete(compactionId);
+        break;
+      case "compaction:abort":
+        status = "interrupted";
+        this.activeCompactions.delete(compactionId);
+        break;
+      case "compaction:error":
+        status = "failed";
+        this.activeCompactions.delete(compactionId);
+        break;
+      default:
+        status = "streaming";
+        this.activeCompactions.set(compactionId, current);
+    }
+    const turn = buildCompactionTurn(this.nextSeq(), compactionId, loopId, status, current);
+    return [{ kind: "upsert", turn }];
+  }
+  // --- Internal helpers ---
+  syncPatch(state) {
+    const turn = snapshot(state, this.nextSeq(), "streaming");
+    this.latestTurns.set(state.loopId, turn);
+    this.lastTurnIds.set(state.loopId, turn.turn_id);
+    return [{ kind: "upsert", turn }];
+  }
+  finalize(loopId, status) {
+    const state = this.activeTurns.get(loopId);
+    if (!state) return null;
+    this.activeTurns.delete(loopId);
+    const turn = snapshot(state, this.nextSeq(), status);
+    this.lastTurnIds.set(loopId, turn.turn_id);
+    this.latestTurns.set(loopId, turn);
+    return [{ kind: "upsert", turn }];
+  }
+  shouldFinalizeAfterToolResults(state) {
+    if (state.toolCalls.length === 0) return true;
+    if (state.toolCalls.some((tc) => tc.status === "pending")) return false;
+    return !state.toolCalls.some((tc) => {
+      const normalized = tc.tool_name.includes(":") ? tc.tool_name.split(":").pop() : tc.tool_name;
+      return PAUSE_TOOL_NAMES.has(normalized);
+    });
+  }
+  collectLoopUpdates(...loopIds) {
+    const updates = [];
+    for (const loopId of loopIds) {
+      if (!loopId) continue;
+      const state = this.activeTurns.get(loopId);
+      if (state) {
+        updates.push(...this.syncPatch(state));
+        continue;
+      }
+      const proj = this.latestTurns.get(loopId);
+      if (proj) {
+        const updated = { ...proj, sequence: this.nextSeq() };
+        this.latestTurns.set(loopId, updated);
+        updates.push({ kind: "upsert", turn: updated });
+      }
+    }
+    return updates;
+  }
+  nextSeq() {
+    return ++this.seq;
+  }
+  nextTurnId(prefix) {
+    this.syntheticCounter++;
+    const hex = Math.random().toString(16).slice(2, 10);
+    return `${prefix}:${this.syntheticCounter}:${hex}`;
+  }
+};
+function optStr(value) {
+  if (value == null || value === "") return null;
+  return String(value);
+}
+function toolNameFromPayload(payload) {
+  const fn = payload.function;
+  if (typeof fn === "object" && fn !== null) {
+    return String(fn.name ?? "");
+  }
+  return String(payload.tool_name ?? "");
+}
+function toolArgsFromPayload(payload) {
+  const fn = payload.function;
+  if (typeof fn === "object" && fn !== null) {
+    return String(fn.arguments ?? "");
+  }
+  return "";
+}
+
 // src/react/stores/auth-store.ts
 import { create as create6 } from "zustand";
 import { createJSONStorage, persist } from "zustand/middleware";
@@ -1624,7 +2677,7 @@ var useSessionStore = create5()((set, get) => ({
   rewindDrafts: {},
   errorMessages: {},
   _freshSessions: /* @__PURE__ */ new Set(),
-  fetchSessions: async () => {
+  fetchAllSessions: async () => {
     set({ loading: true });
     try {
       const currentState = get();
@@ -1692,7 +2745,7 @@ var useSessionStore = create5()((set, get) => ({
     });
     get().setActiveSession(session_id);
     invalidateHomeSidebarSessions();
-    get().fetchSessions().catch(() => {
+    get().fetchAllSessions().catch(() => {
     });
     return session_id;
   },
@@ -1762,7 +2815,7 @@ var useSessionStore = create5()((set, get) => ({
     await deleteSession(id);
     invalidateHomeSidebarSessions();
     const wasActive = get().activeSessionId === id;
-    await get().fetchSessions();
+    await get().fetchAllSessions();
     if (!wasActive) {
       return;
     }
@@ -1907,8 +2960,6 @@ function finishAuth(set, payload) {
     error: null
   });
   agentSocket?.reconnect();
-  useSessionStore.getState().fetchSessions().catch(() => {
-  });
 }
 function finishCookieHydration(set, payload) {
   set({
@@ -1919,8 +2970,6 @@ function finishCookieHydration(set, payload) {
     error: null
   });
   agentSocket?.reconnect();
-  useSessionStore.getState().fetchSessions().catch(() => {
-  });
 }
 function toUser(info) {
   return {
@@ -2393,6 +3442,7 @@ var AgentSocket = class {
   boardProjectRefCounts = /* @__PURE__ */ new Map();
   patchFlushHandle = null;
   patchFlushCancel = null;
+  projectionBuilder = new ClientProjectionBuilder();
   _ensureConnected() {
     if (this.socket.connected || this.socket.active) {
       return;
@@ -2499,6 +3549,33 @@ var AgentSocket = class {
       if (!sessionId) return;
       applyTurn(sessionId, data);
     });
+    s.on("turn:events", (data) => {
+      const sessionId = this._resolveSessionId(data);
+      if (!sessionId || !data.events?.length) return;
+      if (!useChatStore.getState().isStreaming[sessionId]) {
+        useSessionStore.getState().updateSessionStatus(sessionId, "running");
+        useChatStore.getState().setStreaming(sessionId, true);
+      }
+      const existingTurns = useChatStore.getState().turns[sessionId];
+      if (existingTurns?.length) {
+        this.projectionBuilder.seedSequence(
+          Math.max(...existingTurns.map((t) => t.sequence))
+        );
+      }
+      const updates = this.projectionBuilder.processBatch(data.events);
+      for (const update of updates) {
+        if (update.kind === "upsert") {
+          useChatStore.getState().upsertTurn(sessionId, update.turn);
+          const mode = extractModeFromBlocks3(update.turn.blocks);
+          if (mode === "planning" || mode === "executing") {
+            useSessionStore.getState().setMode(sessionId, mode);
+          }
+          this._applyProjectionSideEffects(sessionId, update.turn);
+        } else if (update.kind === "workspace_changed") {
+          notifyWorkspaceFilesChanged(sessionId);
+        }
+      }
+    });
     s.on("chat:start", (data) => {
       const sessionId = this._resolveSessionId(data);
       if (!sessionId) return;
@@ -2599,6 +3676,7 @@ var AgentSocket = class {
         if (!sessionId) return;
         const patch = {};
         if (typeof data.intent === "string") patch.intent = data.intent;
+        if (data.status) patch.status = data.status;
         if ("model" in data) patch.model = data.model;
         if ("bound_skill_id" in data) patch.bound_skill_id = data.bound_skill_id;
         if ("replay_state" in data) patch.replay_state = data.replay_state;
@@ -2917,6 +3995,7 @@ var AgentSocket = class {
       this.deliveredBridgeKeys.clear();
       useUiStore.getState().clearArtifacts();
       useCardStateStore.getState().clearAllStates();
+      this.projectionBuilder.reset();
     }
     if (this.joinedSessions.has(sessionId)) {
       this._refreshRunningState(sessionId);
@@ -2955,9 +4034,9 @@ var AgentSocket = class {
     };
   }
   /**
-   * 订阅 session:updated（智能体意图等会话属性变更）。全局 handler 只会
+   * 订阅 session:updated（智能体意图、状态等会话属性变更）。全局 handler 只会
    * patch 已在 useSessionStore 列表里的会话；看板任务这类不在列表里的
-   * 会话，由调用方通过本方法自行消费意图更新。
+   * 会话，由调用方通过本方法自行消费属性更新。
    */
   onSessionUpdated(handler) {
     this.socket.on("session:updated", handler);
@@ -3087,6 +4166,7 @@ var AgentSocket = class {
       mode,
       askuser_answer: askuserAnswer,
       model: extras?.model,
+      thinking_override: extras?.thinkingOverride,
       whatif: extras?.whatif,
       replay_decision: extras?.replay_decision
     };
@@ -3402,4 +4482,4 @@ export {
   bootstrapBladeClient,
   getBootstrappedClient
 };
-//# sourceMappingURL=chunk-3UY7SD3P.js.map
+//# sourceMappingURL=chunk-QEYZZDLM.js.map