replicas-engine 0.1.236 → 0.1.238

package/dist/src/index.js

@@ -1779,11 +1779,11 @@ function parseReplicasConfigString(content, filename) {
 // ../shared/src/claude-auth.ts
 function isClaudeAuthErrorText(text) {
   const lower = text.toLowerCase();
-  return lower.includes("failed to authenticate") || lower.includes("authentication_error") || lower.includes("authentication_failed") || lower.includes("authentication failed") || lower.includes("invalid authentication credentials") || lower.includes("not logged in") || lower.includes("please run /login") || lower.includes("401") && lower.includes("authentic");
+  return lower.includes("failed to authenticate") || lower.includes("authentication_error") || lower.includes("authentication_failed") || lower.includes("authentication failed") || lower.includes("invalid authentication credentials") || lower.includes("not logged in") || lower.includes("please run /login") || lower.includes("credit balance is too low") || lower.includes("401") && lower.includes("authentic");
 }
 
 // ../shared/src/engine/environment.ts
-var DAYTONA_SNAPSHOT_ID = "29-05-2026-royal-york-v7";
+var DAYTONA_SNAPSHOT_ID = "29-05-2026-royal-york-v9";
 var DESKTOP_NOVNC_PORT = 6080;
 
 // ../shared/src/engine/types.ts
@@ -1802,9 +1802,9 @@ function normalizeClaudeModel(model) {
 }
 var MODEL_LABELS = {
   sonnet: "Sonnet 4.5",
-  opus: "Opus 4.7",
-  [CLAUDE_OPUS_1M_MODEL]: "Opus 4.7 (1M)",
-  [LEGACY_CLAUDE_OPUS_1M_MODEL]: "Opus 4.7 (1M)",
+  opus: "Opus 4.8",
+  [CLAUDE_OPUS_1M_MODEL]: "Opus 4.8 (1M)",
+  [LEGACY_CLAUDE_OPUS_1M_MODEL]: "Opus 4.8 (1M)",
   haiku: "Haiku 4.5",
   "gpt-5.5": "GPT-5.5",
   "gpt-5.4": "GPT-5.4",
@@ -1905,6 +1905,174 @@ var AUDIT_LOG_ACTION = {
 };
 var AUDIT_LOG_ACTIONS = Object.values(AUDIT_LOG_ACTION);
 
+// ../shared/src/display-message/types.ts
+var BACKGROUND_TASK_SUBTYPES = /* @__PURE__ */ new Set([
+  "task_started",
+  "task_progress",
+  "task_updated",
+  "task_notification"
+]);
+function isBackgroundTaskSubtype(subtype) {
+  return typeof subtype === "string" && BACKGROUND_TASK_SUBTYPES.has(subtype);
+}
+function optionalString(value) {
+  return typeof value === "string" ? value : void 0;
+}
+function coerceBackgroundTaskPayload(payload) {
+  if (!isRecord(payload)) return null;
+  const subtype = payload.subtype;
+  if (!isBackgroundTaskSubtype(subtype)) return null;
+  const taskId = payload.task_id;
+  if (typeof taskId !== "string" || !taskId) return null;
+  const patch = isRecord(payload.patch) ? {
+    status: optionalString(payload.patch.status),
+    description: optionalString(payload.patch.description),
+    error: optionalString(payload.patch.error)
+  } : void 0;
+  return {
+    subtype,
+    taskId,
+    description: optionalString(payload.description),
+    summary: optionalString(payload.summary),
+    outputFile: optionalString(payload.output_file),
+    status: optionalString(payload.status),
+    patch
+  };
+}
+function normalizeBackgroundTaskStatus(status) {
+  if (status === "completed" || status === "failed" || status === "stopped") {
+    return status;
+  }
+  if (status === "killed") {
+    return "stopped";
+  }
+  return "in_progress";
+}
+function isTerminalBackgroundTaskStatus(status) {
+  return normalizeBackgroundTaskStatus(status) !== "in_progress";
+}
+
+// ../shared/src/display-message/task-accumulator.ts
+function mapTaskStatus(status) {
+  if (status === "in_progress" || status === "completed") return status;
+  return "pending";
+}
+function toAccumulatorInput(input) {
+  if (typeof input === "string") {
+    try {
+      const parsed = JSON.parse(input);
+      return isRecord(parsed) ? parsed : {};
+    } catch {
+      return {};
+    }
+  }
+  return isRecord(input) ? input : {};
+}
+function extractToolResultText(content, separator = "\n") {
+  if (typeof content === "string") return content;
+  if (!Array.isArray(content)) return "";
+  const texts = [];
+  for (const part of content) {
+    if (isRecord(part) && part.type === "text" && typeof part.text === "string") {
+      texts.push(part.text);
+    }
+  }
+  return texts.join(separator);
+}
+function parseStringField(value) {
+  if (typeof value !== "string") return null;
+  const trimmed = value.trim();
+  return trimmed ? trimmed : null;
+}
+function parseCreateResultTaskId(resultText) {
+  try {
+    const parsed = JSON.parse(resultText);
+    if (isRecord(parsed) && isRecord(parsed.task)) {
+      return parseStringField(parsed.task.id);
+    }
+  } catch {
+  }
+  return resultText.match(/\bTask\s+#?([A-Za-z0-9_-]+)\s+created\b/i)?.[1] ?? null;
+}
+var TaskAccumulator = class {
+  tasksByTaskId = /* @__PURE__ */ new Map();
+  tasksByCreateToolUseId = /* @__PURE__ */ new Map();
+  orderedKeys = [];
+  processToolUse(toolName, toolUseId, input) {
+    if (toolName === "TaskCreate") {
+      const subject = parseStringField(input.subject);
+      if (!subject) return false;
+      this.tasksByCreateToolUseId.set(toolUseId, { subject, status: "pending" });
+      this.orderedKeys.push(toolUseId);
+      return true;
+    }
+    if (toolName === "TaskUpdate") {
+      const taskId = parseStringField(input.taskId);
+      if (!taskId) return false;
+      if (input.status === "deleted") {
+        if (!this.tasksByTaskId.delete(taskId)) return false;
+        const idx = this.orderedKeys.indexOf(taskId);
+        if (idx !== -1) this.orderedKeys.splice(idx, 1);
+        return true;
+      }
+      const existing = this.tasksByTaskId.get(taskId);
+      const subject = parseStringField(input.subject) ?? existing?.subject;
+      if (!subject) return false;
+      const status = input.status !== void 0 ? mapTaskStatus(input.status) : existing?.status ?? "pending";
+      this.tasksByTaskId.set(taskId, { subject, status });
+      if (!existing) this.orderedKeys.push(taskId);
+      return true;
+    }
+    if (toolName === "TaskList") {
+      if (!Array.isArray(input.tasks)) return false;
+      let changed = false;
+      for (const raw of input.tasks) {
+        if (!isRecord(raw)) continue;
+        const id = parseStringField(raw.id);
+        const subject = parseStringField(raw.subject);
+        if (!id || !subject) continue;
+        const existing = this.tasksByTaskId.get(id);
+        const next = { subject, status: mapTaskStatus(raw.status) };
+        if (existing && existing.subject === next.subject && existing.status === next.status) continue;
+        this.tasksByTaskId.set(id, next);
+        if (!existing) this.orderedKeys.push(id);
+        changed = true;
+      }
+      return changed;
+    }
+    return false;
+  }
+  processCreateResult(toolUseId, resultText) {
+    const pending = this.tasksByCreateToolUseId.get(toolUseId);
+    if (!pending) return false;
+    const taskId = parseCreateResultTaskId(resultText);
+    if (!taskId) return false;
+    this.tasksByTaskId.set(taskId, pending);
+    this.tasksByCreateToolUseId.delete(toolUseId);
+    const idx = this.orderedKeys.indexOf(toolUseId);
+    if (idx !== -1) this.orderedKeys.splice(idx, 1, taskId);
+    return true;
+  }
+  getTasks() {
+    const out = [];
+    for (const key of this.orderedKeys) {
+      const task = this.tasksByTaskId.get(key) ?? this.tasksByCreateToolUseId.get(key);
+      if (task && task.subject) out.push(task);
+    }
+    return out;
+  }
+  processContentBlock(block) {
+    if (!isRecord(block)) return false;
+    if (block.type === "tool_use" && typeof block.name === "string" && typeof block.id === "string") {
+      return this.processToolUse(block.name, block.id, toAccumulatorInput(block.input));
+    }
+    if (block.type === "tool_result" && typeof block.tool_use_id === "string") {
+      return this.processCreateResult(block.tool_use_id, extractToolResultText(block.content, ""));
+    }
+    return false;
+  }
+};
+
 // ../shared/src/agent-event-utils.ts
 function getUserMessage(event) {
   return event.type === "event_msg" && event.payload.type === "user_message" && typeof event.payload.message === "string" ? event.payload.message : null;
@@ -3282,15 +3450,15 @@ function withPreview(stored) {
 function isObject(value) {
   return typeof value === "object" && value !== null;
 }
-function optionalString(value) {
+function optionalString2(value) {
   return typeof value === "string" ? value : void 0;
 }
 function normalizeStored(raw) {
   if (!isObject(raw)) return null;
   if (typeof raw.output !== "string" || typeof raw.exitCode !== "number") return null;
   const hookType = raw.hookType === "environment" ? "environment" : "repository";
-  const repoNameField = optionalString(raw.repoName);
-  const hookName = optionalString(raw.hookName) ?? repoNameField ?? "";
+  const repoNameField = optionalString2(raw.repoName);
+  const hookName = optionalString2(raw.hookName) ?? repoNameField ?? "";
   const repoName = repoNameField ?? hookName;
   const hookCommands = Array.isArray(raw.hookCommands) ? raw.hookCommands.filter((c) => typeof c === "string") : [];
   return {
@@ -3301,7 +3469,7 @@ function normalizeStored(raw) {
     output: raw.output,
     exitCode: raw.exitCode,
     timedOut: typeof raw.timedOut === "boolean" ? raw.timedOut : false,
-    executedAt: optionalString(raw.executedAt) ?? ""
+    executedAt: optionalString2(raw.executedAt) ?? ""
   };
 }
 var StartHookLogsService = class {
@@ -4004,14 +4172,8 @@ function summarizeInput(input) {
     if (obj.pattern) return `pattern: ${String(obj.pattern)}`;
     if (obj.query) return String(obj.query);
     if (obj.url) return String(obj.url);
-    if (obj.todos && Array.isArray(obj.todos)) {
-      const todos = obj.todos;
-      const completed = todos.filter((t) => t.status === "completed").length;
-      const total = todos.length;
-      const currentTask = todos.find((t) => t.status === "in_progress");
-      const summary = `${completed}/${total}`;
-      return currentTask?.content ? `${summary}: ${currentTask.content}` : summary;
-    }
+    if (typeof obj.activeForm === "string" && obj.activeForm) return String(obj.activeForm);
+    if (typeof obj.subject === "string" && obj.subject) return String(obj.subject);
     const keys = Object.keys(obj);
     if (keys.length > 0) {
       const firstKey = keys[0];
@@ -4075,7 +4237,10 @@ function convertClaudeEvent(event, linearSessionId) {
           case "Task":
             action = "Spawning subagent";
             break;
-          case "TodoWrite":
+          case "TaskCreate":
+          case "TaskUpdate":
+          case "TaskList":
+          case "TaskGet":
             action = "Updating plan";
             break;
         }
@@ -4095,12 +4260,7 @@ function convertClaudeEvent(event, linearSessionId) {
     const contentBlocks = message.message?.content || [];
     for (const block of contentBlocks) {
       if (block.type === "tool_result") {
-        let resultText = "";
-        if (typeof block.content === "string") {
-          resultText = block.content;
-        } else if (Array.isArray(block.content)) {
-          resultText = block.content.filter((c) => c.type === "text").map((c) => c.text || "").join("\n");
-        }
+        const resultText = extractToolResultText(block.content);
         const isError = block.is_error || false;
         const result = isError ? `Error: ${resultText}` : resultText || "Done";
         return {
@@ -4129,34 +4289,6 @@ function mapTodoStatus(status) {
   }
   return "pending";
 }
-function extractPlanFromClaudeEvent(event) {
-  if (event.type !== "assistant") {
-    return null;
-  }
-  const message = event;
-  const contentBlocks = message.message?.content || [];
-  for (const block of contentBlocks) {
-    if (block.type !== "tool_use" || block.name !== "TodoWrite") {
-      continue;
-    }
-    const input = typeof block.input === "string" ? (() => {
-      try {
-        return JSON.parse(block.input);
-      } catch {
-        return null;
-      }
-    })() : typeof block.input === "object" && block.input !== null ? block.input : null;
-    const todos = input?.todos;
-    if (!todos || todos.length === 0) {
-      return null;
-    }
-    return todos.filter((todo) => Boolean(todo.content && todo.content.trim().length > 0)).map((todo) => ({
-      content: todo.content.trim(),
-      status: mapTodoStatus(todo.status)
-    }));
-  }
-  return null;
-}
 function convertCodexEvent(event, linearSessionId) {
   if (event.type === "turn.started") {
     return {
@@ -4950,6 +5082,7 @@ function isLinearThoughtEvent(event) {
 }
 var LinearEventForwarder = class {
   linearSessionId;
+  taskAccumulator = new TaskAccumulator();
   latestThoughtEvent = null;
   constructor(linearSessionId) {
     this.linearSessionId = linearSessionId;
@@ -4962,6 +5095,25 @@ var LinearEventForwarder = class {
     }).catch(() => {
     });
   }
+  processClaudeEventForPlan(event) {
+    if (!this.linearSessionId) return;
+    if (!this.routeEventToAccumulator(event)) return;
+    const plan = this.taskAccumulator.getTasks().map((task) => ({
+      content: task.subject,
+      status: mapTodoStatus(task.status)
+    }));
+    this.sendPlan(plan);
+  }
+  routeEventToAccumulator(event) {
+    if (event.type !== "assistant" && event.type !== "user") return false;
+    const content = event.message.content;
+    if (!Array.isArray(content)) return false;
+    let changed = false;
+    for (const block of content) {
+      if (this.taskAccumulator.processContentBlock(block)) changed = true;
+    }
+    return changed;
+  }
   sendEvent(linearEvent) {
     if (!this.linearSessionId || !linearEvent) return;
     if (this.latestThoughtEvent) {
@@ -5032,7 +5184,10 @@ var ALWAYS_ALLOWED_TOOLS = [
   "Grep",
   "WebSearch",
   "WebFetch",
-  "TodoWrite",
+  "TaskCreate",
+  "TaskUpdate",
+  "TaskGet",
+  "TaskList",
   "Agent",
   "ListMcpResourcesTool",
   "ReadMcpResourceTool",
@@ -5144,7 +5299,14 @@ var ClaudeManager = class _ClaudeManager extends CodingAgentManager {
   sessionId = null;
   activeQuery = null;
   activePromptStream = null;
+  activeSessionSignature = null;
+  activeSessionModel = null;
+  activeSessionPermissionMode = null;
+  sessionLoop = null;
+  sessionLinearForwarder = null;
+  pendingTurn = null;
   pendingInterrupt = false;
+  activeBackgroundTasks = /* @__PURE__ */ new Set();
   systemPromptOverride;
   toolsOverride;
   mcpServersConfig;
@@ -5165,7 +5327,6 @@ var ClaudeManager = class _ClaudeManager extends CodingAgentManager {
   }
   async interruptActiveTurn() {
     this.pendingInterrupt = true;
-    this.activePromptStream?.close();
     if (this.activeQuery) {
       await this.activeQuery.interrupt();
     }
@@ -5347,117 +5508,271 @@ var ClaudeManager = class _ClaudeManager extends CodingAgentManager {
       thinkingLevel,
       enableInteractiveTools
     } = request;
-    const linearSessionId = ENGINE_ENV.LINEAR_SESSION_ID;
     if (!message || !message.trim()) {
       throw new Error("Message cannot be empty");
     }
     await this.initialized;
-    try {
-      const content = [
-        {
-          type: "text",
-          text: message
+    this.pendingInterrupt = false;
+    const content = [
+      {
+        type: "text",
+        text: message
+      }
+    ];
+    if (images && images.length > 0) {
+      const normalizedImages = await normalizeImages(images);
+      for (const image of normalizedImages) {
+        content.push({
+          type: "image",
+          source: {
+            type: "base64",
+            media_type: image.source.media_type,
+            data: image.source.data
+          }
+        });
+      }
+    }
+    const userMessage = {
+      type: "user",
+      message: {
+        role: "user",
+        content
+      },
+      parent_tool_use_id: null,
+      session_id: this.sessionId ?? ""
+    };
+    if (!options.skipUserMessageRecord) {
+      await this.recordEvent(userMessage);
+    }
+    const combinedInstructions = this.buildCombinedInstructions(customInstructions);
+    const resolvedModel = normalizeClaudeModel(model) || CLAUDE_OPUS_1M_MODEL;
+    const resolvedPermissionMode = permissionMode === "read" ? "plan" : "bypassPermissions";
+    const signature = {
+      combinedInstructions,
+      thinkingLevel,
+      // enableInteractiveTools only matters when permissionMode is 'read'; the
+      // session signature tracks the effective flag so a permissionMode change
+      // can hot-swap via setPermissionMode without restarting.
+      enableInteractiveTools: Boolean(enableInteractiveTools)
+    };
+    await this.ensureSession({
+      signature,
+      combinedInstructions,
+      resolvedModel,
+      resolvedPermissionMode,
+      enableInteractiveTools: signature.enableInteractiveTools,
+      thinkingLevel
+    });
+    const promptStream = this.activePromptStream;
+    const activeQuery = this.activeQuery;
+    if (!promptStream || !activeQuery) {
+      throw new Error("Claude session unavailable after ensureSession");
+    }
+    if (this.pendingInterrupt) {
+      this.pendingInterrupt = false;
+      return;
+    }
+    await new Promise((resolve3, reject) => {
+      this.pendingTurn = { resolve: resolve3, reject };
+      promptStream.push(userMessage);
+    });
+  }
+  async ensureSession(args) {
+    const {
+      signature,
+      combinedInstructions,
+      resolvedModel,
+      resolvedPermissionMode,
+      enableInteractiveTools,
+      thinkingLevel
+    } = args;
+    if (this.activeQuery && this.activeSessionSignature && this.sessionSignaturesMatch(this.activeSessionSignature, signature)) {
+      if (this.activeSessionModel !== resolvedModel) {
+        try {
+          await this.activeQuery.setModel(resolvedModel);
+          this.activeSessionModel = resolvedModel;
+        } catch (err) {
+          console.warn("[ClaudeManager] setModel failed; recreating session:", err);
+          await this.tearDownSession();
         }
-      ];
-      if (images && images.length > 0) {
-        const normalizedImages = await normalizeImages(images);
-        for (const image of normalizedImages) {
-          content.push({
-            type: "image",
-            source: {
-              type: "base64",
-              media_type: image.source.media_type,
-              data: image.source.data
-            }
-          });
+      }
+      if (this.activeQuery && this.activeSessionPermissionMode !== resolvedPermissionMode) {
+        try {
+          await this.activeQuery.setPermissionMode(resolvedPermissionMode);
+          this.activeSessionPermissionMode = resolvedPermissionMode;
+        } catch (err) {
+          console.warn("[ClaudeManager] setPermissionMode failed; recreating session:", err);
+          await this.tearDownSession();
         }
       }
-      const userMessage = {
-        type: "user",
-        message: {
-          role: "user",
-          content
-        },
-        parent_tool_use_id: null,
-        session_id: this.sessionId ?? ""
-      };
-      if (!options.skipUserMessageRecord) {
-        await this.recordEvent(userMessage);
+      if (this.activeQuery) return;
+    } else if (this.activeQuery) {
+      await this.tearDownSession();
+    }
+    await this.startSession({
+      combinedInstructions,
+      resolvedModel,
+      resolvedPermissionMode,
+      enableInteractiveTools,
+      thinkingLevel,
+      signature
+    });
+  }
+  sessionSignaturesMatch(a, b) {
+    return a.combinedInstructions === b.combinedInstructions && a.thinkingLevel === b.thinkingLevel && a.enableInteractiveTools === b.enableInteractiveTools;
+  }
+  async startSession(args) {
+    const {
+      combinedInstructions,
+      resolvedModel,
+      resolvedPermissionMode,
+      enableInteractiveTools,
+      thinkingLevel,
+      signature
+    } = args;
+    const systemPrompt = this.systemPromptOverride ? this.systemPromptOverride(combinedInstructions) : {
+      type: "preset",
+      preset: "claude_code",
+      append: combinedInstructions
+    };
+    const queryEnv = buildClaudeAgentEnv(this.envOverrides);
+    const additionalDirectories = await getAgentAdditionalDirectories();
+    const interactiveAllowed = enableInteractiveTools && resolvedPermissionMode === "plan";
+    const useDefaultToolPolicy = !this.toolsOverride;
+    const allowedTools = useDefaultToolPolicy ? [
+      ...ALWAYS_ALLOWED_TOOLS,
+      ...interactiveAllowed ? INTERACTIVE_TOOL_NAMES : []
+    ] : void 0;
+    const disallowedTools = [
+      ...this.disallowedToolsOverride ?? [],
+      ...useDefaultToolPolicy ? ALWAYS_DISALLOWED_TOOLS : [],
+      ...interactiveAllowed ? [] : INTERACTIVE_TOOL_NAMES
+    ];
+    const promptStream = new PromptStream();
+    const response = query({
+      prompt: promptStream,
+      options: {
+        resume: this.sessionId || void 0,
+        cwd: this.workingDirectory,
+        additionalDirectories,
+        permissionMode: resolvedPermissionMode,
+        allowDangerouslySkipPermissions: resolvedPermissionMode === "bypassPermissions",
+        ...this.toolsOverride ? { tools: this.toolsOverride } : {},
+        ...allowedTools ? { allowedTools } : {},
+        ...disallowedTools.length > 0 ? { disallowedTools } : {},
+        settingSources: ["user", "project", "local"],
+        systemPrompt,
+        ...this.mcpServersConfig ? { mcpServers: this.mcpServersConfig } : {},
+        env: queryEnv,
+        model: resolvedModel,
+        ...thinkingLevel ? { effort: thinkingLevel } : {},
+        canUseTool: this.buildCanUseTool()
       }
-      const promptStream = new PromptStream();
-      promptStream.push(userMessage);
-      this.activePromptStream = promptStream;
-      const combinedInstructions = this.buildCombinedInstructions(customInstructions);
-      const systemPrompt = this.systemPromptOverride ? this.systemPromptOverride(combinedInstructions) : {
-        type: "preset",
-        preset: "claude_code",
-        append: combinedInstructions
-      };
-      const queryEnv = buildClaudeAgentEnv(this.envOverrides);
-      const additionalDirectories = await getAgentAdditionalDirectories();
-      const resolvedModel = normalizeClaudeModel(model) || CLAUDE_OPUS_1M_MODEL;
-      const interactiveAllowed = enableInteractiveTools && permissionMode === "read";
-      const useDefaultToolPolicy = !this.toolsOverride;
-      const allowedTools = useDefaultToolPolicy ? [
-        ...ALWAYS_ALLOWED_TOOLS,
-        ...interactiveAllowed ? INTERACTIVE_TOOL_NAMES : []
-      ] : void 0;
-      const disallowedTools = [
-        ...this.disallowedToolsOverride ?? [],
-        ...useDefaultToolPolicy ? ALWAYS_DISALLOWED_TOOLS : [],
-        ...interactiveAllowed ? [] : INTERACTIVE_TOOL_NAMES
-      ];
-      const response = query({
-        prompt: promptStream,
-        options: {
-          resume: this.sessionId || void 0,
-          cwd: this.workingDirectory,
-          additionalDirectories,
-          permissionMode: permissionMode === "read" ? "plan" : "bypassPermissions",
-          allowDangerouslySkipPermissions: permissionMode !== "read",
-          ...this.toolsOverride ? { tools: this.toolsOverride } : {},
-          ...allowedTools ? { allowedTools } : {},
-          ...disallowedTools.length > 0 ? { disallowedTools } : {},
-          settingSources: ["user", "project", "local"],
-          systemPrompt,
-          ...this.mcpServersConfig ? { mcpServers: this.mcpServersConfig } : {},
-          env: queryEnv,
-          model: resolvedModel,
-          ...thinkingLevel ? { effort: thinkingLevel } : {},
-          canUseTool: this.buildCanUseTool()
-        }
-      });
-      this.activeQuery = response;
-      if (this.pendingInterrupt) {
-        this.pendingInterrupt = false;
-        this.activePromptStream?.close();
-        await this.activeQuery.interrupt();
-      }
-      const linearForwarder = new LinearEventForwarder(linearSessionId);
-      for await (const msg of response) {
+    });
+    this.activeQuery = response;
+    this.activePromptStream = promptStream;
+    this.activeSessionSignature = signature;
+    this.activeSessionModel = resolvedModel;
+    this.activeSessionPermissionMode = resolvedPermissionMode;
+    this.sessionLinearForwarder = new LinearEventForwarder(ENGINE_ENV.LINEAR_SESSION_ID);
+    this.activeBackgroundTasks.clear();
+    this.sessionLoop = this.runSessionLoop(response).catch((err) => {
+      console.error("[ClaudeManager] Session loop crashed:", err);
+    });
+  }
+  async runSessionLoop(response) {
+    const linearSessionId = ENGINE_ENV.LINEAR_SESSION_ID;
+    const iterator = response[Symbol.asyncIterator]();
+    try {
+      while (true) {
+        const next = await iterator.next();
+        if (next.done) break;
+        const msg = next.value;
         const authErrorMessage = _ClaudeManager.detectAuthErrorInMessage(msg);
         if (authErrorMessage) {
-          this.activePromptStream?.close();
-          throw new ClaudeAuthError(authErrorMessage);
+          this.failPendingTurn(new ClaudeAuthError(authErrorMessage));
+          try {
+            response.close();
+          } catch (err) {
+            console.warn("[ClaudeManager] query.close() during auth error failed:", err);
+          }
+          return;
         }
         this.setAuthRetrying(false);
         await this.handleMessage(msg);
-        if (linearSessionId) {
-          linearForwarder.sendPlan(extractPlanFromClaudeEvent(msg));
-          linearForwarder.sendEvent(convertClaudeEvent(msg, linearSessionId));
+        _ClaudeManager.updateBackgroundTaskState(msg, this.activeBackgroundTasks);
+        if (linearSessionId && this.sessionLinearForwarder) {
+          this.sessionLinearForwarder.processClaudeEventForPlan(msg);
+          this.sessionLinearForwarder.sendEvent(convertClaudeEvent(msg, linearSessionId));
         }
         if (msg.type === "result") {
           await this.recordContextUsage(response);
-          this.activePromptStream?.close();
-          break;
+          this.sessionLinearForwarder?.flushThoughtAsResponse();
+          this.resolvePendingTurn();
         }
       }
-      linearForwarder.flushThoughtAsResponse();
     } finally {
-      this.activeQuery = null;
-      this.activePromptStream?.close();
-      this.activePromptStream = null;
-      this.pendingInterrupt = false;
+      this.sessionLinearForwarder?.flushThoughtAsResponse();
+      this.failPendingTurn(new Error("Claude session ended unexpectedly"));
+      if (this.activeQuery === response) {
+        this.clearSessionState();
+      }
+    }
+  }
+  clearSessionState() {
+    this.activeQuery = null;
+    this.activePromptStream = null;
+    this.activeSessionSignature = null;
+    this.activeSessionModel = null;
+    this.activeSessionPermissionMode = null;
+    this.sessionLinearForwarder = null;
+    this.sessionLoop = null;
+    this.activeBackgroundTasks.clear();
+  }
+  resolvePendingTurn() {
+    const pending = this.pendingTurn;
+    if (!pending) return;
+    this.pendingTurn = null;
+    this.pendingInterrupt = false;
+    pending.resolve();
+  }
+  failPendingTurn(err) {
+    const pending = this.pendingTurn;
+    if (!pending) return;
+    this.pendingTurn = null;
+    this.pendingInterrupt = false;
+    pending.reject(err);
+  }
+  async tearDownSession() {
+    const query2 = this.activeQuery;
+    const stream = this.activePromptStream;
+    const loop = this.sessionLoop;
+    this.failPendingTurn(new Error("Claude session torn down"));
+    this.clearSessionState();
+    if (query2) {
+      try {
+        query2.close();
+      } catch (err) {
+        console.warn("[ClaudeManager] query.close() failed:", err);
+      }
+    }
+    stream?.close();
+    if (loop) {
+      try {
+        await loop;
+      } catch {
+      }
+    }
+  }
+  static updateBackgroundTaskState(message, activeTasks) {
+    if (message.type !== "system") return;
+    const payload = coerceBackgroundTaskPayload(message);
+    if (!payload) return;
+    const status = payload.subtype === "task_updated" ? payload.patch?.status : payload.status;
+    if (isTerminalBackgroundTaskStatus(status)) {
+      activeTasks.delete(payload.taskId);
+    } else {
+      activeTasks.add(payload.taskId);
     }
   }
   getContextUsageProvider() {
@@ -5775,7 +6090,7 @@ var AspClient = class {
 // src/managers/codex-asp/app-server-process.ts
 var DEFAULT_CODEX_BINARY = "codex";
 var DEFAULT_CODEX_ARGS = ["app-server", "--listen", "stdio://"];
-var ENGINE_PACKAGE_VERSION = "0.1.213";
+var ENGINE_PACKAGE_VERSION = "0.1.238";
 var INITIALIZE_METHOD = "initialize";
 var INITIALIZED_NOTIFICATION = "initialized";
 var ACCOUNT_LOGIN_START_METHOD = "account/login/start";
@@ -8140,7 +8455,7 @@ function getEnvironmentSection() {
     `Platform: ${process.platform}`,
     getShellInfoLine(),
     `OS Version: ${unameSR}`,
-    `The most recent Claude model family is Claude 4.5/4.6/4.7. Model IDs \u2014 Opus 4.7: 'claude-opus-4-7', Sonnet 4.6: 'claude-sonnet-4-6', Haiku 4.5: 'claude-haiku-4-5-20251001'. When building AI applications, default to the latest and most capable Claude models.`
+    `The most recent Claude model family is Claude 4.5/4.6/4.8. Model IDs \u2014 Opus 4.8: 'claude-opus-4-8', Sonnet 4.6: 'claude-sonnet-4-6', Haiku 4.5: 'claude-haiku-4-5-20251001'. When building AI applications, default to the latest and most capable Claude models.`
   ];
   return [
     `# Environment`,
@@ -8176,7 +8491,10 @@ var RELAY_TOOLS = [
   "WebSearch",
   "WebFetch",
   "Skill",
-  "TodoWrite",
+  "TaskCreate",
+  "TaskUpdate",
+  "TaskGet",
+  "TaskList",
   "TaskOutput",
   "TaskStop"
 ];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "replicas-engine",
-  "version": "0.1.236",
+  "version": "0.1.238",
   "description": "Lightweight API server for Replicas workspaces",
   "type": "module",
   "main": "dist/src/index.js",