@zonease/happy 0.6.37 → 0.6.39

package/dist/lib.mjs

@@ -1,27 +1,33 @@
-export { A as ApiClient, a as ApiSessionClient, R as RawJSONLinesSchema, c as configuration, l as logger } from './types-DYCJXXdA.mjs';
+export { A as ApiClient, a as ApiSessionClient } from './api-CIZKyfSn.mjs';
+export { c as configuration, l as logger } from './persistence-BFjvtUad.mjs';
+export { R as RawJSONLinesSchema } from './types-BoJh4Qfv.mjs';
 import 'axios';
-import 'chalk';
-import 'fs';
-import 'node:fs';
-import 'node:os';
-import 'node:path';
 import 'node:events';
 import 'socket.io-client';
 import 'zod';
+import './index-CPKdvi7J.mjs';
 import '@paralleldrive/cuid2';
+import './time-DgsBLJA_.mjs';
 import 'node:crypto';
-import 'tweetnacl';
+import 'node:fs';
+import 'node:path';
 import 'node:child_process';
 import 'node:fs/promises';
+import 'node:os';
 import 'node:util';
 import 'child_process';
 import 'util';
 import 'fs/promises';
 import 'path';
+import './projectPath-BTBIMB57.mjs';
 import 'url';
 import 'node:module';
 import 'ws';
 import 'crypto';
+import 'tweetnacl';
 import '@stablelib/base64';
 import 'node:readline';
 import 'expo-server-sdk';
+import './sessionKeyCache-D2BwO91C.mjs';
+import 'chalk';
+import 'fs';

package/dist/{loadableToolOutput-lQH8Kb_w.mjs → loadableToolOutput-Cuygmd4K.mjs}

@@ -1,9 +1,11 @@
-import { l as logger, h as resolveToolsDir, j as projectPath, c as configuration, k as packageJson, s as startOfflineReconnection, m as saveToolOutputRecord } from './types-DYCJXXdA.mjs';
+import { l as logger, c as configuration, p as packageJson } from './persistence-BFjvtUad.mjs';
 import { randomUUID } from 'node:crypto';
 import { readFileSync, existsSync, readdirSync } from 'node:fs';
 import os, { homedir } from 'node:os';
 import { join, basename, dirname } from 'node:path';
-import { e as detectGitWorktree } from './index-DJ2VpGiR.mjs';
+import { p as projectPath } from './projectPath-BTBIMB57.mjs';
+import { r as resolveToolsDir, s as startOfflineReconnection, b as saveToolOutputRecord } from './api-CIZKyfSn.mjs';
+import { a as detectGitWorktree } from './downloadImage-DfSFLb-h.mjs';
 
 class BasePermissionHandler {
   pendingRequests = /* @__PURE__ */ new Map();

package/dist/{loadableToolOutput-CasonFIt.cjs → loadableToolOutput-DDCJjywt.cjs}

@@ -1,11 +1,13 @@
 'use strict';
 
-var persistence = require('./types-BrTorNAy.cjs');
+var logger = require('./persistence-JLUn_Nou.cjs');
 var node_crypto = require('node:crypto');
 var fs = require('node:fs');
 var os = require('node:os');
 var path = require('node:path');
-var index = require('./index-BlkHOkB3.cjs');
+var projectPath = require('./projectPath-ChLhdOyt.cjs');
+var api = require('./api-CwOCQeLH.cjs');
+var downloadImage = require('./downloadImage-MQMrUUxS.cjs');
 
 class BasePermissionHandler {
   pendingRequests = /* @__PURE__ */ new Map();
@@ -25,7 +27,7 @@ class BasePermissionHandler {
    * This is critical for avoiding stale session references after onSessionSwap.
    */
   updateSession(newSession) {
-    persistence.logger.debug(`${this.getLogPrefix()} Session reference updated`);
+    logger.logger.debug(`${this.getLogPrefix()} Session reference updated`);
     this.session = newSession;
     this.setupRpcHandler();
   }
@@ -38,7 +40,7 @@ class BasePermissionHandler {
       async (response) => {
         const pending = this.pendingRequests.get(response.id);
         if (!pending) {
-          persistence.logger.debug(`${this.getLogPrefix()} Permission request not found or already resolved`);
+          logger.logger.debug(`${this.getLogPrefix()} Permission request not found or already resolved`);
           return;
         }
         this.pendingRequests.delete(response.id);
@@ -68,7 +70,7 @@ class BasePermissionHandler {
           };
           return res;
         });
-        persistence.logger.debug(`${this.getLogPrefix()} Permission ${response.approved ? "approved" : "denied"} for ${pending.toolName}`);
+        logger.logger.debug(`${this.getLogPrefix()} Permission ${response.approved ? "approved" : "denied"} for ${pending.toolName}`);
       }
     );
   }
@@ -150,7 +152,7 @@ class BasePermissionHandler {
    */
   reset() {
     if (this.isResetting) {
-      persistence.logger.debug(`${this.getLogPrefix()} Reset already in progress, skipping`);
+      logger.logger.debug(`${this.getLogPrefix()} Reset already in progress, skipping`);
       return;
     }
     this.isResetting = true;
@@ -161,7 +163,7 @@ class BasePermissionHandler {
         try {
           pending.reject(new Error("Session reset"));
         } catch (err) {
-          persistence.logger.debug(`${this.getLogPrefix()} Error rejecting pending request ${id}:`, err);
+          logger.logger.debug(`${this.getLogPrefix()} Error rejecting pending request ${id}:`, err);
         }
       }
       this.session.updateAgentState((currentState) => {
@@ -181,7 +183,7 @@ class BasePermissionHandler {
           completedRequests
         };
       });
-      persistence.logger.debug(`${this.getLogPrefix()} Permission handler reset`);
+      logger.logger.debug(`${this.getLogPrefix()} Permission handler reset`);
     } finally {
       this.isResetting = false;
     }
@@ -214,7 +216,7 @@ class BaseReasoningProcessor {
   handleSectionBreak() {
     this.finishCurrentToolCall("canceled");
     this.resetState();
-    persistence.logger.debug(`${this.getLogPrefix()} Section break - reset state`);
+    logger.logger.debug(`${this.getLogPrefix()} Section break - reset state`);
   }
   /**
    * Process a reasoning delta/chunk and accumulate content.
@@ -225,7 +227,7 @@ class BaseReasoningProcessor {
       if (this.accumulator.startsWith("**")) {
         this.inTitleCapture = true;
         this.titleBuffer = this.accumulator.substring(2);
-        persistence.logger.debug(`${this.getLogPrefix()} Started title capture`);
+        logger.logger.debug(`${this.getLogPrefix()} Started title capture`);
       } else if (this.accumulator.length > 0) {
         this.contentBuffer = this.accumulator;
       }
@@ -240,7 +242,7 @@ class BaseReasoningProcessor {
         this.currentTitle = title;
         this.contentBuffer = afterTitle;
         this.currentCallId = node_crypto.randomUUID();
-        persistence.logger.debug(`${this.getLogPrefix()} Title captured: "${title}"`);
+        logger.logger.debug(`${this.getLogPrefix()} Title captured: "${title}"`);
         this.sendToolCallStart(title);
       }
     } else if (this.hasTitle) {
@@ -270,7 +272,7 @@ class BaseReasoningProcessor {
       },
       id: node_crypto.randomUUID()
     };
-    persistence.logger.debug(`${this.getLogPrefix()} Sending tool call start for: "${title}"`);
+    logger.logger.debug(`${this.getLogPrefix()} Sending tool call start for: "${title}"`);
     this.onMessage?.(toolCall);
     this.toolCallStarted = true;
   }
@@ -281,7 +283,7 @@ class BaseReasoningProcessor {
   completeReasoning(fullText) {
     const text = fullText ?? this.accumulator;
     if (!text.trim() && !this.toolCallStarted) {
-      persistence.logger.debug(`${this.getLogPrefix()} Complete called but no content accumulated, skipping`);
+      logger.logger.debug(`${this.getLogPrefix()} Complete called but no content accumulated, skipping`);
       return false;
     }
     let title;
@@ -293,7 +295,7 @@ class BaseReasoningProcessor {
         content = text.substring(titleEndIndex + 2).trim();
       }
     }
-    persistence.logger.debug(`${this.getLogPrefix()} Complete reasoning - Title: "${title}", Has content: ${content.length > 0}`);
+    logger.logger.debug(`${this.getLogPrefix()} Complete reasoning - Title: "${title}", Has content: ${content.length > 0}`);
     if (title && !this.toolCallStarted) {
       this.currentCallId = this.currentCallId || node_crypto.randomUUID();
       this.sendToolCallStart(title);
@@ -308,7 +310,7 @@ class BaseReasoningProcessor {
         },
         id: node_crypto.randomUUID()
       };
-      persistence.logger.debug(`${this.getLogPrefix()} Sending tool call result`);
+      logger.logger.debug(`${this.getLogPrefix()} Sending tool call result`);
       this.onMessage?.(toolResult);
     } else if (content.trim()) {
       const reasoningMessage = {
@@ -316,7 +318,7 @@ class BaseReasoningProcessor {
         message: content,
         id: node_crypto.randomUUID()
       };
-      persistence.logger.debug(`${this.getLogPrefix()} Sending reasoning message`);
+      logger.logger.debug(`${this.getLogPrefix()} Sending reasoning message`);
       this.onMessage?.(reasoningMessage);
     }
     this.resetState();
@@ -326,7 +328,7 @@ class BaseReasoningProcessor {
    * Abort the current reasoning section.
    */
   abort() {
-    persistence.logger.debug(`${this.getLogPrefix()} Abort called`);
+    logger.logger.debug(`${this.getLogPrefix()} Abort called`);
     this.finishCurrentToolCall("canceled");
     this.resetState();
   }
@@ -351,7 +353,7 @@ class BaseReasoningProcessor {
         },
         id: node_crypto.randomUUID()
       };
-      persistence.logger.debug(`${this.getLogPrefix()} Sending tool call result with status: ${status}`);
+      logger.logger.debug(`${this.getLogPrefix()} Sending tool call result with status: ${status}`);
       this.onMessage?.(toolResult);
     }
   }
@@ -504,7 +506,7 @@ function detectWorkspaceSubdirectories(cwd) {
     for (const entry of entries) {
       if (!entry.isDirectory() || entry.name.startsWith(".")) continue;
       const subDir = path.join(cwd, entry.name);
-      const info = index.detectGitWorktree(subDir);
+      const info = downloadImage.detectGitWorktree(subDir);
       if (info.isWorktree && info.worktreeBasePath && info.worktreeBranchName) {
         repos.push({
           path: subDir,
@@ -544,7 +546,7 @@ function detectWorktreeMetadata() {
       worktreeBranchName: process.env.HAPPY_WORKTREE_BRANCH_NAME
     };
   }
-  const info = index.detectGitWorktree(process.cwd());
+  const info = downloadImage.detectGitWorktree(process.cwd());
   if (info.isWorktree) {
     return {
       isWorktree: true,
@@ -565,13 +567,13 @@ function createSessionMetadata(opts) {
   const metadata = {
     path: process.cwd(),
     host: os.hostname(),
-    version: persistence.packageJson.version,
+    version: logger.packageJson.version,
     os: os.platform(),
     machineId: opts.machineId,
     homeDir: os.homedir(),
-    happyHomeDir: persistence.configuration.happyHomeDir,
-    happyLibDir: persistence.projectPath(),
-    happyToolsDir: persistence.resolveToolsDir(),
+    happyHomeDir: logger.configuration.happyHomeDir,
+    happyLibDir: projectPath.projectPath(),
+    happyToolsDir: api.resolveToolsDir(),
     startedFromDaemon: opts.startedBy === "daemon",
     hostPid: process.pid,
     startedBy: opts.startedBy || "terminal",
@@ -624,17 +626,17 @@ function createOfflineSessionStub(sessionTag) {
 }
 
 function setupOfflineReconnection(opts) {
-  const { api, sessionTag, metadata, state, response, onSessionSwap } = opts;
+  const { api: api$1, sessionTag, metadata, state, response, onSessionSwap } = opts;
   let session;
   let reconnectionHandle = null;
   if (!response) {
     session = createOfflineSessionStub(sessionTag);
-    reconnectionHandle = persistence.startOfflineReconnection({
-      serverUrl: persistence.configuration.serverUrl,
+    reconnectionHandle = api.startOfflineReconnection({
+      serverUrl: logger.configuration.serverUrl,
       onReconnected: async () => {
-        const resp = await api.getOrCreateSession({ tag: sessionTag, metadata, state });
+        const resp = await api$1.getOrCreateSession({ tag: sessionTag, metadata, state });
         if (!resp) throw new Error("Server unavailable");
-        const realSession = api.sessionSyncClient(resp);
+        const realSession = api$1.sessionSyncClient(resp);
         onSessionSwap(realSession);
         return realSession;
       },
@@ -644,7 +646,7 @@ function setupOfflineReconnection(opts) {
     });
     return { session, reconnectionHandle, isOffline: true };
   } else {
-    session = api.sessionSyncClient(response);
+    session = api$1.sessionSyncClient(response);
     return { session, reconnectionHandle: null, isOffline: false };
   }
 }
@@ -877,7 +879,7 @@ function handleAgentMessageChunk(update, ctx) {
       payload: { text }
     });
   } else {
-    persistence.logger.debug(`[AcpBackend] Received message chunk (length: ${text.length}): ${text.substring(0, 50)}...`);
+    logger.logger.debug(`[AcpBackend] Received message chunk (length: ${text.length}): ${text.substring(0, 50)}...`);
     ctx.emit({
       type: "model-output",
       textDelta: text
@@ -886,10 +888,10 @@ function handleAgentMessageChunk(update, ctx) {
     const idleTimeoutMs = ctx.transport.getIdleTimeout?.() ?? DEFAULT_IDLE_TIMEOUT_MS;
     ctx.setIdleTimeout(() => {
       if (ctx.activeToolCalls.size === 0) {
-        persistence.logger.debug("[AcpBackend] No more chunks received, emitting idle status");
+        logger.logger.debug("[AcpBackend] No more chunks received, emitting idle status");
         ctx.emitIdleStatus();
       } else {
-        persistence.logger.debug(`[AcpBackend] Delaying idle status - ${ctx.activeToolCalls.size} active tool calls`);
+        logger.logger.debug(`[AcpBackend] Delaying idle status - ${ctx.activeToolCalls.size} active tool calls`);
       }
     }, idleTimeoutMs);
   }
@@ -906,7 +908,7 @@ function handleAgentThoughtChunk(update, ctx) {
   }
   if (ctx.activeToolCalls.size > 0) {
     const activeToolCallsList = Array.from(ctx.activeToolCalls);
-    persistence.logger.debug(`[AcpBackend] \u{1F4AD} Thinking chunk received (${text.length} chars) during active tool calls: ${activeToolCallsList.join(", ")}`);
+    logger.logger.debug(`[AcpBackend] \u{1F4AD} Thinking chunk received (${text.length} chars) during active tool calls: ${activeToolCallsList.join(", ")}`);
   }
   ctx.emit({
     type: "event",
@@ -924,28 +926,28 @@ function startToolCall(toolCallId, toolKind, update, ctx, source) {
   ctx.toolCallIdToNameMap.set(toolCallId, realToolName);
   ctx.activeToolCalls.add(toolCallId);
   ctx.toolCallStartTimes.set(toolCallId, startTime);
-  persistence.logger.debug(`[AcpBackend] \u23F1\uFE0F Set startTime for ${toolCallId} at ${new Date(startTime).toISOString()} (from ${source})`);
-  persistence.logger.debug(`[AcpBackend] \u{1F527} Tool call START: ${toolCallId} (${toolKind} -> ${realToolName})${isInvestigation ? " [INVESTIGATION TOOL]" : ""}`);
+  logger.logger.debug(`[AcpBackend] \u23F1\uFE0F Set startTime for ${toolCallId} at ${new Date(startTime).toISOString()} (from ${source})`);
+  logger.logger.debug(`[AcpBackend] \u{1F527} Tool call START: ${toolCallId} (${toolKind} -> ${realToolName})${isInvestigation ? " [INVESTIGATION TOOL]" : ""}`);
   if (isInvestigation) {
-    persistence.logger.debug(`[AcpBackend] \u{1F50D} Investigation tool detected - extended timeout (10min) will be used`);
+    logger.logger.debug(`[AcpBackend] \u{1F50D} Investigation tool detected - extended timeout (10min) will be used`);
   }
   const timeoutMs = ctx.transport.getToolCallTimeout?.(toolCallId, toolKindStr) ?? DEFAULT_TOOL_CALL_TIMEOUT_MS;
   if (!ctx.toolCallTimeouts.has(toolCallId)) {
     const timeout = setTimeout(() => {
       const duration = formatDuration(ctx.toolCallStartTimes.get(toolCallId));
-      persistence.logger.debug(`[AcpBackend] \u23F1\uFE0F Tool call TIMEOUT (from ${source}): ${toolCallId} (${toolKind}) after ${(timeoutMs / 1e3).toFixed(0)}s - Duration: ${duration}, removing from active set`);
+      logger.logger.debug(`[AcpBackend] \u23F1\uFE0F Tool call TIMEOUT (from ${source}): ${toolCallId} (${toolKind}) after ${(timeoutMs / 1e3).toFixed(0)}s - Duration: ${duration}, removing from active set`);
       ctx.activeToolCalls.delete(toolCallId);
       ctx.toolCallStartTimes.delete(toolCallId);
       ctx.toolCallTimeouts.delete(toolCallId);
       if (ctx.activeToolCalls.size === 0) {
-        persistence.logger.debug("[AcpBackend] No more active tool calls after timeout, emitting idle status");
+        logger.logger.debug("[AcpBackend] No more active tool calls after timeout, emitting idle status");
         ctx.emitIdleStatus();
       }
     }, timeoutMs);
     ctx.toolCallTimeouts.set(toolCallId, timeout);
-    persistence.logger.debug(`[AcpBackend] \u23F1\uFE0F Set timeout for ${toolCallId}: ${(timeoutMs / 1e3).toFixed(0)}s${isInvestigation ? " (investigation tool)" : ""}`);
+    logger.logger.debug(`[AcpBackend] \u23F1\uFE0F Set timeout for ${toolCallId}: ${(timeoutMs / 1e3).toFixed(0)}s${isInvestigation ? " (investigation tool)" : ""}`);
   } else {
-    persistence.logger.debug(`[AcpBackend] Timeout already set for ${toolCallId}, skipping`);
+    logger.logger.debug(`[AcpBackend] Timeout already set for ${toolCallId}, skipping`);
   }
   ctx.clearIdleTimeout();
   ctx.emit({ type: "status", status: "running" });
@@ -958,7 +960,7 @@ function startToolCall(toolCallId, toolKind, update, ctx, source) {
     args.locations = update.locations;
   }
   if (isInvestigation && args.objective) {
-    persistence.logger.debug(`[AcpBackend] \u{1F50D} Investigation tool objective: ${String(args.objective).substring(0, 100)}...`);
+    logger.logger.debug(`[AcpBackend] \u{1F50D} Investigation tool objective: ${String(args.objective).substring(0, 100)}...`);
   }
   ctx.emit({
     type: "tool-call",
@@ -978,7 +980,7 @@ function completeToolCall(toolCallId, toolKind, content, ctx) {
     clearTimeout(timeout);
     ctx.toolCallTimeouts.delete(toolCallId);
   }
-  persistence.logger.debug(`[AcpBackend] \u2705 Tool call COMPLETED: ${toolCallId} (${toolKindStr}) - Duration: ${duration}. Active tool calls: ${ctx.activeToolCalls.size}`);
+  logger.logger.debug(`[AcpBackend] \u2705 Tool call COMPLETED: ${toolCallId} (${toolKindStr}) - Duration: ${duration}. Active tool calls: ${ctx.activeToolCalls.size}`);
   ctx.emit({
     type: "tool-result",
     toolName: toolKindStr,
@@ -987,7 +989,7 @@ function completeToolCall(toolCallId, toolKind, content, ctx) {
   });
   if (ctx.activeToolCalls.size === 0) {
     ctx.clearIdleTimeout();
-    persistence.logger.debug("[AcpBackend] All tool calls completed, emitting idle status");
+    logger.logger.debug("[AcpBackend] All tool calls completed, emitting idle status");
     ctx.emitIdleStatus();
   }
 }
@@ -1000,17 +1002,17 @@ function failToolCall(toolCallId, status, toolKind, content, ctx) {
   if (isInvestigation) {
     const durationStr2 = formatDuration(startTime);
     const durationMinutes = formatDurationMinutes(startTime);
-    persistence.logger.debug(`[AcpBackend] \u{1F50D} Investigation tool ${status.toUpperCase()} after ${durationMinutes} minutes (${durationStr2})`);
+    logger.logger.debug(`[AcpBackend] \u{1F50D} Investigation tool ${status.toUpperCase()} after ${durationMinutes} minutes (${durationStr2})`);
     if (duration) {
       const threeMinutes = 3 * 60 * 1e3;
       const tolerance = 5e3;
       if (Math.abs(duration - threeMinutes) < tolerance) {
-        persistence.logger.debug(`[AcpBackend] \u{1F50D} \u26A0\uFE0F Investigation tool failed at ~3 minutes - likely Gemini CLI timeout, not our timeout`);
+        logger.logger.debug(`[AcpBackend] \u{1F50D} \u26A0\uFE0F Investigation tool failed at ~3 minutes - likely Gemini CLI timeout, not our timeout`);
       }
     }
-    persistence.logger.debug(`[AcpBackend] \u{1F50D} Investigation tool FAILED - full content:`, JSON.stringify(content, null, 2));
-    persistence.logger.debug(`[AcpBackend] \u{1F50D} Investigation tool timeout status BEFORE cleanup: ${hadTimeout ? "timeout was set" : "no timeout was set"}`);
-    persistence.logger.debug(`[AcpBackend] \u{1F50D} Investigation tool startTime status BEFORE cleanup: ${startTime ? `set at ${new Date(startTime).toISOString()}` : "not set"}`);
+    logger.logger.debug(`[AcpBackend] \u{1F50D} Investigation tool FAILED - full content:`, JSON.stringify(content, null, 2));
+    logger.logger.debug(`[AcpBackend] \u{1F50D} Investigation tool timeout status BEFORE cleanup: ${hadTimeout ? "timeout was set" : "no timeout was set"}`);
+    logger.logger.debug(`[AcpBackend] \u{1F50D} Investigation tool startTime status BEFORE cleanup: ${startTime ? `set at ${new Date(startTime).toISOString()}` : "not set"}`);
   }
   ctx.activeToolCalls.delete(toolCallId);
   ctx.toolCallStartTimes.delete(toolCallId);
@@ -1018,17 +1020,17 @@ function failToolCall(toolCallId, status, toolKind, content, ctx) {
   if (timeout) {
     clearTimeout(timeout);
     ctx.toolCallTimeouts.delete(toolCallId);
-    persistence.logger.debug(`[AcpBackend] Cleared timeout for ${toolCallId} (tool call ${status})`);
+    logger.logger.debug(`[AcpBackend] Cleared timeout for ${toolCallId} (tool call ${status})`);
   } else {
-    persistence.logger.debug(`[AcpBackend] No timeout found for ${toolCallId} (tool call ${status}) - timeout may not have been set`);
+    logger.logger.debug(`[AcpBackend] No timeout found for ${toolCallId} (tool call ${status}) - timeout may not have been set`);
   }
   const durationStr = formatDuration(startTime);
-  persistence.logger.debug(`[AcpBackend] \u274C Tool call ${status.toUpperCase()}: ${toolCallId} (${toolKindStr}) - Duration: ${durationStr}. Active tool calls: ${ctx.activeToolCalls.size}`);
+  logger.logger.debug(`[AcpBackend] \u274C Tool call ${status.toUpperCase()}: ${toolCallId} (${toolKindStr}) - Duration: ${durationStr}. Active tool calls: ${ctx.activeToolCalls.size}`);
   const errorDetail = extractErrorDetail(content);
   if (errorDetail) {
-    persistence.logger.debug(`[AcpBackend] \u274C Tool call error details: ${errorDetail.substring(0, 500)}`);
+    logger.logger.debug(`[AcpBackend] \u274C Tool call error details: ${errorDetail.substring(0, 500)}`);
   } else {
-    persistence.logger.debug(`[AcpBackend] \u274C Tool call ${status} but no error details in content`);
+    logger.logger.debug(`[AcpBackend] \u274C Tool call ${status} but no error details in content`);
   }
   ctx.emit({
     type: "tool-result",
@@ -1038,7 +1040,7 @@ function failToolCall(toolCallId, status, toolKind, content, ctx) {
   });
   if (ctx.activeToolCalls.size === 0) {
     ctx.clearIdleTimeout();
-    persistence.logger.debug("[AcpBackend] All tool calls completed/failed, emitting idle status");
+    logger.logger.debug("[AcpBackend] All tool calls completed/failed, emitting idle status");
     ctx.emitIdleStatus();
   }
 }
@@ -1046,7 +1048,7 @@ function handleToolCallUpdate(update, ctx) {
   const status = update.status;
   const toolCallId = update.toolCallId;
   if (!toolCallId) {
-    persistence.logger.debug("[AcpBackend] Tool call update without toolCallId:", update);
+    logger.logger.debug("[AcpBackend] Tool call update without toolCallId:", update);
     return { handled: false };
   }
   const toolKind = update.kind || "unknown";
@@ -1056,7 +1058,7 @@ function handleToolCallUpdate(update, ctx) {
       toolCallCountSincePrompt++;
       startToolCall(toolCallId, toolKind, update, ctx, "tool_call_update");
     } else {
-      persistence.logger.debug(`[AcpBackend] Tool call ${toolCallId} already tracked, status: ${status}`);
+      logger.logger.debug(`[AcpBackend] Tool call ${toolCallId} already tracked, status: ${status}`);
     }
   } else if (status === "completed") {
     completeToolCall(toolCallId, toolKind, update.content, ctx);
@@ -1068,14 +1070,14 @@ function handleToolCallUpdate(update, ctx) {
 function handleToolCall(update, ctx) {
   const toolCallId = update.toolCallId;
   const status = update.status;
-  persistence.logger.debug(`[AcpBackend] Received tool_call: toolCallId=${toolCallId}, status=${status}, kind=${update.kind}`);
+  logger.logger.debug(`[AcpBackend] Received tool_call: toolCallId=${toolCallId}, status=${status}, kind=${update.kind}`);
   const isInProgress = !status || status === "in_progress" || status === "pending";
   if (!toolCallId || !isInProgress) {
-    persistence.logger.debug(`[AcpBackend] Tool call ${toolCallId} not in progress (status: ${status}), skipping`);
+    logger.logger.debug(`[AcpBackend] Tool call ${toolCallId} not in progress (status: ${status}), skipping`);
     return { handled: false };
   }
   if (ctx.activeToolCalls.has(toolCallId)) {
-    persistence.logger.debug(`[AcpBackend] Tool call ${toolCallId} already in active set, skipping`);
+    logger.logger.debug(`[AcpBackend] Tool call ${toolCallId} already in active set, skipping`);
     return { handled: true };
   }
   startToolCall(toolCallId, update.kind, update, ctx, "tool_call");
@@ -1158,7 +1160,7 @@ function handleConfigMetadataEvent(eventName, payload, updateMetadata) {
 
 function createLoadableToolOutput(options) {
   if (options.persist !== false) {
-    persistence.saveToolOutputRecord(options.sessionId, {
+    api.saveToolOutputRecord(options.sessionId, {
       callId: options.callId,
       toolName: options.toolName,
       agent: options.agent,

package/dist/mcpToolSchemas-CjeTfrAs.mjs

@@ -0,0 +1,62 @@
+import { z } from 'zod';
+
+const orchestratorTargetTypeSchema = z.preprocess(
+  (value) => value === "machine" ? "machine_id" : value,
+  z.enum(["current_machine", "machine_id"])
+).describe('Dispatch target type. Use "current_machine" for this machine, or "machine_id" for explicit machine routing. Alias "machine" is accepted and normalized to "machine_id".');
+const orchestratorTaskSchema = z.object({
+  taskKey: z.string().min(1).max(128).optional(),
+  title: z.string().min(1).max(256).optional(),
+  provider: z.enum(["claude", "codex", "gemini"]).describe("AI agent provider to execute the task."),
+  model: z.string().min(1).max(128).optional().describe('Optional model mode for the selected provider. Prefer values from orchestrator_get_context.data.modelModes[provider]. Use "default" to follow CLI defaults.'),
+  prompt: z.string().min(1).max(65536),
+  workingDirectory: z.string().max(512).optional().describe("Absolute path for task execution. Defaults to the controller session working directory from get_context."),
+  dependsOn: z.array(z.string().min(1).max(128)).max(31).optional().describe("Optional list of prerequisite taskKeys (use taskKey, not taskId). This controls execution order only: the task starts after all listed tasks complete, but receives NONE of their output or context."),
+  retry: z.object({
+    maxAttempts: z.number().int().min(1).max(10).optional().describe("Maximum attempts for this task (including first run)."),
+    backoffMs: z.number().int().min(0).max(24 * 60 * 60 * 1e3).optional().describe("Retry backoff delay in milliseconds before the next attempt.")
+  }).optional(),
+  target: z.object({
+    type: orchestratorTargetTypeSchema,
+    machineId: z.string().optional().describe('Required when target.type is "machine_id" (or alias "machine").')
+  }).optional().describe("Optional dispatch routing target."),
+  metadata: z.record(z.string(), z.string()).optional()
+});
+({
+  inputSchema: {
+    title: z.string().min(1).max(256).describe("Run title"),
+    tasks: z.array(orchestratorTaskSchema).min(1).max(32),
+    maxConcurrency: z.number().int().min(1).max(8).optional(),
+    idempotencyKey: z.string().min(1).max(128).optional(),
+    metadata: z.record(z.string(), z.unknown()).optional(),
+    controllerSessionId: z.string().optional().describe("Optional controller session ID. Defaults to current MCP session when omitted.")
+  }
+});
+({
+  inputSchema: {
+    runId: z.string().describe("Run ID"),
+    cursor: z.string().optional(),
+    waitFor: z.enum(["change", "terminal"]).optional(),
+    timeoutMs: z.number().int().min(0).max(36e5).optional().describe("Total wait timeout in ms. Defaults to 10 minutes when omitted."),
+    include: z.enum(["summary", "all_tasks"]).optional().describe('"summary" returns run-level status only; "all_tasks" includes per-task details.')
+  }
+});
+({
+  inputSchema: {
+    status: z.enum(["active", "terminal", "queued", "running", "canceling", "completed", "failed", "cancelled"]).optional().describe('Filter by status. "active" = queued|running|canceling; "terminal" = completed|failed|cancelled.'),
+    limit: z.number().int().min(1).max(50).optional(),
+    cursor: z.string().optional()
+  }
+});
+({
+  inputSchema: {
+    runId: z.string().describe("Run ID"),
+    reason: z.string().max(512).optional()
+  }
+});
+({
+  inputSchema: {
+    taskId: z.string().describe("Task ID to resume"),
+    message: z.string().min(1).max(65536).describe("Message to send to the existing child session")
+  }
+});

package/dist/mcpToolSchemas-DK42yoZ_.cjs

@@ -0,0 +1,64 @@
+'use strict';
+
+var z = require('zod');
+
+const orchestratorTargetTypeSchema = z.z.preprocess(
+  (value) => value === "machine" ? "machine_id" : value,
+  z.z.enum(["current_machine", "machine_id"])
+).describe('Dispatch target type. Use "current_machine" for this machine, or "machine_id" for explicit machine routing. Alias "machine" is accepted and normalized to "machine_id".');
+const orchestratorTaskSchema = z.z.object({
+  taskKey: z.z.string().min(1).max(128).optional(),
+  title: z.z.string().min(1).max(256).optional(),
+  provider: z.z.enum(["claude", "codex", "gemini"]).describe("AI agent provider to execute the task."),
+  model: z.z.string().min(1).max(128).optional().describe('Optional model mode for the selected provider. Prefer values from orchestrator_get_context.data.modelModes[provider]. Use "default" to follow CLI defaults.'),
+  prompt: z.z.string().min(1).max(65536),
+  workingDirectory: z.z.string().max(512).optional().describe("Absolute path for task execution. Defaults to the controller session working directory from get_context."),
+  dependsOn: z.z.array(z.z.string().min(1).max(128)).max(31).optional().describe("Optional list of prerequisite taskKeys (use taskKey, not taskId). This controls execution order only: the task starts after all listed tasks complete, but receives NONE of their output or context."),
+  retry: z.z.object({
+    maxAttempts: z.z.number().int().min(1).max(10).optional().describe("Maximum attempts for this task (including first run)."),
+    backoffMs: z.z.number().int().min(0).max(24 * 60 * 60 * 1e3).optional().describe("Retry backoff delay in milliseconds before the next attempt.")
+  }).optional(),
+  target: z.z.object({
+    type: orchestratorTargetTypeSchema,
+    machineId: z.z.string().optional().describe('Required when target.type is "machine_id" (or alias "machine").')
+  }).optional().describe("Optional dispatch routing target."),
+  metadata: z.z.record(z.z.string(), z.z.string()).optional()
+});
+({
+  inputSchema: {
+    title: z.z.string().min(1).max(256).describe("Run title"),
+    tasks: z.z.array(orchestratorTaskSchema).min(1).max(32),
+    maxConcurrency: z.z.number().int().min(1).max(8).optional(),
+    idempotencyKey: z.z.string().min(1).max(128).optional(),
+    metadata: z.z.record(z.z.string(), z.z.unknown()).optional(),
+    controllerSessionId: z.z.string().optional().describe("Optional controller session ID. Defaults to current MCP session when omitted.")
+  }
+});
+({
+  inputSchema: {
+    runId: z.z.string().describe("Run ID"),
+    cursor: z.z.string().optional(),
+    waitFor: z.z.enum(["change", "terminal"]).optional(),
+    timeoutMs: z.z.number().int().min(0).max(36e5).optional().describe("Total wait timeout in ms. Defaults to 10 minutes when omitted."),
+    include: z.z.enum(["summary", "all_tasks"]).optional().describe('"summary" returns run-level status only; "all_tasks" includes per-task details.')
+  }
+});
+({
+  inputSchema: {
+    status: z.z.enum(["active", "terminal", "queued", "running", "canceling", "completed", "failed", "cancelled"]).optional().describe('Filter by status. "active" = queued|running|canceling; "terminal" = completed|failed|cancelled.'),
+    limit: z.z.number().int().min(1).max(50).optional(),
+    cursor: z.z.string().optional()
+  }
+});
+({
+  inputSchema: {
+    runId: z.z.string().describe("Run ID"),
+    reason: z.z.string().max(512).optional()
+  }
+});
+({
+  inputSchema: {
+    taskId: z.z.string().describe("Task ID to resume"),
+    message: z.z.string().min(1).max(65536).describe("Message to send to the existing child session")
+  }
+});