@parall/daemon 1.28.1 → 1.29.1

package/bundle/parall-claude-agent.js

@@ -112,6 +112,9 @@ function buildEventBody(event) {
   }
   return lines.join("\n") + buildSendMessageHint(event);
 }
+function buildEventBodyForForkResult(event) {
+  return buildEventBody(event).replace(/\n<system-reminder>[\s\S]*<\/system-reminder>$/, "");
+}
 function buildSendMessageHint(event) {
   if (event.noReply)
     return "";
@@ -143,14 +146,16 @@ function buildForkResultPrefix(results) {
   if (!results.length)
     return "";
   const blocks = results.map((result) => {
-    const lines = [`[Fork result]`];
-    lines.push(`[Handled: ${result.sourceEvent.type} \u2014 ${result.sourceEvent.summary}]`);
+    const lines = [];
+    for (const body of result.eventBodies) {
+      lines.push(body);
+    }
+    lines.push(`[This event was handled by a parallel fork session. Do NOT re-handle, re-reply, or duplicate work for it.]`);
+    lines.push(`[Fork summary: ${result.agentSummary ? sanitizeMeta(result.agentSummary) : "No fork summary available \u2014 the fork completed without producing a text summary. Check the target chat/task for any actions the fork already took before acting."}]`);
     if (result.actions.length)
-      lines.push(`[Actions: ${result.actions.join("; ")}]`);
-    if (result.agentSummary)
-      lines.push(`[Summary: ${sanitizeMeta(result.agentSummary)}]`);
+      lines.push(`[Fork actions: ${result.actions.join("; ")}]`);
     if (result.historyPath)
-      lines.push(`[History: ${result.historyPath}]`);
+      lines.push(`[Fork history: ${result.historyPath}]`);
     return lines.join("\n");
   });
   return blocks.join("\n\n") + "\n\n---\n\n";
@@ -418,11 +423,19 @@ Messages may arrive with a \`[Thread: prll://msg_xxx]\` line in the event block,
 - Keep thread replies focused on the original topic
 `;
 
+// ts/agent-core/dist/logger.js
+function createLogger(prefix) {
+  return {
+    info: (msg) => console.log(`${(/* @__PURE__ */ new Date()).toISOString()} [${prefix}] ${msg}`),
+    warn: (msg) => console.warn(`${(/* @__PURE__ */ new Date()).toISOString()} [${prefix}] ${msg}`),
+    error: (msg) => console.error(`${(/* @__PURE__ */ new Date()).toISOString()} [${prefix}] ${msg}`)
+  };
+}
+
 // ts/agent-core/dist/gateway-base.js
 import * as os from "node:os";
 import * as fs from "node:fs";
 import * as path from "node:path";
-import { randomUUID } from "node:crypto";
 
 // ts/sdk/dist/types.js
 var MENTION_ALL_USER_ID = "all";
@@ -440,6 +453,8 @@ var ENDPOINTS = {
   AUTH_CHECK_EMAIL: `${API_BASE}/auth/check-email`,
   AUTH_VERIFY_EMAIL: `${API_BASE}/auth/verify-email`,
   AUTH_RESEND_CODE: `${API_BASE}/auth/resend-code`,
+  AUTH_FORGOT_PASSWORD: `${API_BASE}/auth/forgot-password`,
+  AUTH_RESET_PASSWORD: `${API_BASE}/auth/reset-password`,
   // Users
   USERS_ME: `${API_BASE}/users/me`,
   USER_AVATAR: `${API_BASE}/users/me/avatar`,
@@ -473,8 +488,10 @@ var ENDPOINTS = {
   CHAT_MESSAGES: (orgId, chatId) => `${API_BASE}/orgs/${orgId}/chats/${chatId}/messages`,
   // Messages (global, by message ID)
   MESSAGE: (id) => `${API_BASE}/messages/${id}`,
-  MESSAGE_PATCHES: (id) => `${API_BASE}/messages/${id}/patches`,
   MESSAGE_REPLIES: (id) => `${API_BASE}/messages/${id}/replies`,
+  MESSAGE_WATCH: (id) => `${API_BASE}/messages/${id}/watch`,
+  MESSAGE_WATCHERS: (id) => `${API_BASE}/messages/${id}/watchers`,
+  MESSAGE_WATCHING: (id) => `${API_BASE}/messages/${id}/watching`,
   // Upload (org-scoped)
   UPLOAD_PRESIGN: (orgId) => `${API_BASE}/orgs/${orgId}/upload/presign`,
   UPLOAD_COMPLETE: (orgId) => `${API_BASE}/orgs/${orgId}/upload/complete`,
@@ -500,6 +517,7 @@ var ENDPOINTS = {
   AGENT_SESSION: (orgId, agentId, sessionId) => `${API_BASE}/orgs/${orgId}/agents/${agentId}/sessions/${sessionId}`,
   AGENT_SESSION_STEPS: (orgId, agentId, sessionId) => `${API_BASE}/orgs/${orgId}/agents/${agentId}/sessions/${sessionId}/steps`,
   AGENT_SESSION_STEP: (orgId, agentId, sessionId, stepId) => `${API_BASE}/orgs/${orgId}/agents/${agentId}/sessions/${sessionId}/steps/${stepId}`,
+  AGENT_STEP_BY_ID: (orgId, stepId) => `${API_BASE}/orgs/${orgId}/agent-steps/${stepId}`,
   AGENT_TASKS: (orgId, agentId) => `${API_BASE}/orgs/${orgId}/agents/${agentId}/tasks`,
   AGENT_RUNTIME_AUTH: (orgId, agentId) => `${API_BASE}/orgs/${orgId}/agents/${agentId}/runtime-auth`,
   AGENT_RUNTIME_AUTH_SESSIONS: (orgId, agentId) => `${API_BASE}/orgs/${orgId}/agents/${agentId}/runtime-auth-sessions`,
@@ -524,9 +542,15 @@ var ENDPOINTS = {
   // Attach/Detach bind an agent to/from a daemon Machine.
   MACHINE_ATTACH_AGENT: (orgId, machineId, agentId) => `${API_BASE}/orgs/${orgId}/machines/${machineId}/agents/${agentId}`,
   MACHINE_DETACH_AGENT: (orgId, machineId, agentId) => `${API_BASE}/orgs/${orgId}/machines/${machineId}/agents/${agentId}`,
+  MACHINE_WORKSPACE_STATES: (orgId, machineId) => `${API_BASE}/orgs/${orgId}/machines/${machineId}/workspace-states`,
+  MACHINE_AGENT_DAEMON_CONFIG: (orgId, machineId, agentId) => `${API_BASE}/orgs/${orgId}/machines/${machineId}/agents/${agentId}/daemon-config`,
+  MACHINE_AGENT_WORKSPACE_SETUP: (orgId, machineId, agentId) => `${API_BASE}/orgs/${orgId}/machines/${machineId}/agents/${agentId}/workspace/setup`,
+  MACHINE_LLM_SOURCE: (orgId, machineId) => `${API_BASE}/orgs/${orgId}/machines/${machineId}/llm-source`,
   MACHINE_RUNTIME_AUTH: (orgId, machineId) => `${API_BASE}/orgs/${orgId}/machines/${machineId}/runtime-auth`,
   MACHINE_KEYS: (orgId, machineId) => `${API_BASE}/orgs/${orgId}/machines/${machineId}/keys`,
   MACHINE_KEY: (orgId, machineId, keyId) => `${API_BASE}/orgs/${orgId}/machines/${machineId}/keys/${keyId}`,
+  MACHINE_RUNTIME_AUTH_SESSIONS: (orgId, machineId) => `${API_BASE}/orgs/${orgId}/machines/${machineId}/runtime-auth-sessions`,
+  MACHINE_RUNTIME_AUTH_SESSION_COMPLETE: (orgId, machineId, sessionId) => `${API_BASE}/orgs/${orgId}/machines/${machineId}/runtime-auth-sessions/${sessionId}/complete`,
   // Machine self-control-plane (mck_-scoped). The bearer token implicitly
   // identifies the Machine, so there is no `:mid` URL parameter — these are
   // "self" routes called by the daemon for its own host.
@@ -534,6 +558,7 @@ var ENDPOINTS = {
   MACHINES_ME_AGENTS: `${API_BASE}/machines/me/agents`,
   MACHINES_ME_HEALTH: `${API_BASE}/machines/me/health`,
   MACHINES_ME_AGENT_LAUNCH_CREDENTIAL: (agentId) => `${API_BASE}/machines/me/agents/${agentId}/launch-credential`,
+  MACHINES_ME_AGENT_WORKSPACE_STATE: (agentId) => `${API_BASE}/machines/me/agents/${agentId}/workspace-state`,
   MACHINES_ME_WS_TICKET: `${API_BASE}/machines/me/ws/ticket`,
   // Tasks (org-scoped)
   TASKS: (orgId) => `${API_BASE}/orgs/${orgId}/tasks`,
@@ -713,7 +738,8 @@ var WS_EVENTS = {
   MACHINE_HELLO: "machine.hello",
   MACHINE_AGENT_ATTACHED: "machine.agent.attached",
   MACHINE_AGENT_DETACHED: "machine.agent.detached",
-  MACHINE_STOP: "machine.stop"
+  MACHINE_STOP: "machine.stop",
+  MACHINE_WORKSPACE_SETUP_REQUESTED: "machine.workspace.setup.requested"
 };
 
 // ts/sdk/dist/client.js
@@ -733,7 +759,9 @@ var ParallClient = class _ParallClient {
     "/auth/logout",
     "/auth/verify-email",
     "/auth/resend-code",
-    "/auth/check-email"
+    "/auth/check-email",
+    "/auth/forgot-password",
+    "/auth/reset-password"
   ]);
   /** Proactive refresh when token expires within this window (seconds). */
   static REFRESH_THRESHOLD_S = 5 * 60;
@@ -971,6 +999,12 @@ var ParallClient = class _ParallClient {
   async resendCode(email) {
     return this.request("POST", ENDPOINTS.AUTH_RESEND_CODE, { email });
   }
+  async forgotPassword(email) {
+    return this.request("POST", ENDPOINTS.AUTH_FORGOT_PASSWORD, { email });
+  }
+  async resetPassword(token, newPassword) {
+    return this.request("POST", ENDPOINTS.AUTH_RESET_PASSWORD, { token, new_password: newPassword });
+  }
   // ---- WebSocket ----
   async getWsTicket() {
     return this.request("POST", ENDPOINTS.WS_TICKET);
@@ -1167,9 +1201,6 @@ var ParallClient = class _ParallClient {
   async deleteMessage(id) {
     return this.request("DELETE", ENDPOINTS.MESSAGE(id));
   }
-  async patchMessage(id, req) {
-    return this.request("POST", ENDPOINTS.MESSAGE_PATCHES(id), req);
-  }
   async getMessageReplies(id, params) {
     return this.request("GET", ENDPOINTS.MESSAGE_REPLIES(id), void 0, params);
   }
@@ -1180,8 +1211,8 @@ var ParallClient = class _ParallClient {
   async completeUpload(orgId, attachmentId) {
     return this.request("POST", ENDPOINTS.UPLOAD_COMPLETE(orgId), { attachment_id: attachmentId });
   }
-  async getFileUrl(id) {
-    return this.request("GET", ENDPOINTS.FILE(id));
+  async getFileUrl(id, opts) {
+    return this.request("GET", ENDPOINTS.FILE(id), void 0, opts?.download ? { download: true } : void 0);
   }
   // ---- Approvals ----
   async getApproval(id) {
@@ -1262,8 +1293,7 @@ var ParallClient = class _ParallClient {
    * @param params.status - Comma-separated status filter (e.g., `'open'`).
    */
   async getAgentSessions(orgId, agentId, params) {
-    const res = await this.request("GET", ENDPOINTS.AGENT_SESSIONS(orgId, agentId), void 0, params);
-    return res.data;
+    return this.request("GET", ENDPOINTS.AGENT_SESSIONS(orgId, agentId), void 0, params);
   }
   async getAgentSession(orgId, agentId, sessionId) {
     return this.request("GET", ENDPOINTS.AGENT_SESSION(orgId, agentId, sessionId));
@@ -1275,12 +1305,14 @@ var ParallClient = class _ParallClient {
     return this.request("POST", ENDPOINTS.AGENT_SESSION_STEPS(orgId, agentId, sessionId), req);
   }
   async getAgentSessionSteps(orgId, agentId, sessionId, params) {
-    const res = await this.request("GET", ENDPOINTS.AGENT_SESSION_STEPS(orgId, agentId, sessionId), void 0, params);
-    return res.data;
+    return this.request("GET", ENDPOINTS.AGENT_SESSION_STEPS(orgId, agentId, sessionId), void 0, params);
   }
   async getAgentSessionStep(orgId, agentId, sessionId, stepId) {
     return this.request("GET", ENDPOINTS.AGENT_SESSION_STEP(orgId, agentId, sessionId, stepId));
   }
+  async getAgentStepById(orgId, stepId) {
+    return this.request("GET", ENDPOINTS.AGENT_STEP_BY_ID(orgId, stepId));
+  }
   // ---- Agent runtime auth (hosted Claude OAuth) ----
   async getAgentRuntimeAuth(orgId, agentId) {
     return this.request("GET", ENDPOINTS.AGENT_RUNTIME_AUTH(orgId, agentId));
@@ -1377,10 +1409,32 @@ var ParallClient = class _ParallClient {
   async detachAgent(orgId, machineId, agentId) {
     return this.request("DELETE", ENDPOINTS.MACHINE_DETACH_AGENT(orgId, machineId, agentId));
   }
+  async listAgentWorkspaceStates(orgId, machineId) {
+    const res = await this.request("GET", ENDPOINTS.MACHINE_WORKSPACE_STATES(orgId, machineId));
+    return res.data;
+  }
+  async patchAgentDaemonConfig(orgId, machineId, agentId, daemonConfig) {
+    return this.request("PATCH", ENDPOINTS.MACHINE_AGENT_DAEMON_CONFIG(orgId, machineId, agentId), { daemon_config: daemonConfig });
+  }
+  async retryAgentWorkspaceSetup(orgId, machineId, agentId) {
+    return this.request("POST", ENDPOINTS.MACHINE_AGENT_WORKSPACE_SETUP(orgId, machineId, agentId));
+  }
+  async patchMachineLLMSource(orgId, machineId, llmSource) {
+    return this.request("PATCH", ENDPOINTS.MACHINE_LLM_SOURCE(orgId, machineId), { llm_source: llmSource });
+  }
   /** Get machine-level runtime auth state. */
   async getMachineRuntimeAuth(orgId, machineId) {
     return this.request("GET", ENDPOINTS.MACHINE_RUNTIME_AUTH(orgId, machineId));
   }
+  async startMachineRuntimeAuthSession(orgId, machineId, req = {}) {
+    return this.request("POST", ENDPOINTS.MACHINE_RUNTIME_AUTH_SESSIONS(orgId, machineId), req);
+  }
+  async completeMachineRuntimeAuthSession(orgId, machineId, sessionId, req) {
+    return this.request("POST", ENDPOINTS.MACHINE_RUNTIME_AUTH_SESSION_COMPLETE(orgId, machineId, sessionId), req);
+  }
+  async disconnectMachineRuntimeAuth(orgId, machineId) {
+    return this.request("DELETE", ENDPOINTS.MACHINE_RUNTIME_AUTH(orgId, machineId));
+  }
   // ---- Machine self-control-plane (mck_-scoped) ----
   //
   // The four methods below are intended to be called from a daemon-mode
@@ -1410,6 +1464,12 @@ var ParallClient = class _ParallClient {
   async postMachineHeartbeat() {
     return this.request("POST", ENDPOINTS.MACHINES_ME_HEALTH);
   }
+  async reportAgentWorkspaceState(agentId, state) {
+    const res = await this.request("PUT", ENDPOINTS.MACHINES_ME_AGENT_WORKSPACE_STATE(agentId), state);
+    if (res?.status === "ignored_stale") {
+      throw new ApiError(409, "Workspace state report ignored as stale", "STALE_WORKSPACE_STATE");
+    }
+  }
   /**
    * `POST /machines/me/agents/{agentId}/launch-credential` — mint a
    * short-lived `agk_*` for one of this Machine's attached agents. The
@@ -1559,6 +1619,20 @@ var ParallClient = class _ParallClient {
     const res = await this.request("GET", ENDPOINTS.TASK_WATCHERS(orgId, taskId));
     return res.data;
   }
+  async watchThread(threadRootId) {
+    return this.request("POST", ENDPOINTS.MESSAGE_WATCH(threadRootId));
+  }
+  async unwatchThread(threadRootId) {
+    return this.request("DELETE", ENDPOINTS.MESSAGE_WATCH(threadRootId));
+  }
+  async getThreadWatchers(threadRootId) {
+    const res = await this.request("GET", ENDPOINTS.MESSAGE_WATCHERS(threadRootId));
+    return res.data;
+  }
+  async isWatchingThread(threadRootId) {
+    const res = await this.request("GET", ENDPOINTS.MESSAGE_WATCHING(threadRootId));
+    return res.watching;
+  }
   async getSubtasks(orgId, taskId) {
     const res = await this.request("GET", ENDPOINTS.TASK_SUBTASKS(orgId, taskId));
     return res.data;
@@ -1855,14 +1929,28 @@ var ParallClient = class _ParallClient {
       params.set("machine_id", opts.machine_id);
     if (opts?.unresolved_machine)
       params.set("unresolved_machine", "true");
+    if (opts?.from)
+      params.set("from", opts.from);
+    if (opts?.to)
+      params.set("to", opts.to);
     const qs = params.toString();
     return this.request("GET", `${ENDPOINTS.BILLING_TRANSACTIONS(orgId)}${qs ? `?${qs}` : ""}`);
   }
-  async listBillingTransactionAgentGroups(orgId) {
-    return this.request("GET", `${ENDPOINTS.BILLING_TRANSACTIONS(orgId)}?group_by=agent`);
-  }
-  async listBillingTransactionMachineGroups(orgId) {
-    return this.request("GET", `${ENDPOINTS.BILLING_TRANSACTIONS(orgId)}?group_by=machine`);
+  async listBillingTransactionAgentGroups(orgId, opts) {
+    const params = new URLSearchParams({ group_by: "agent" });
+    if (opts?.from)
+      params.set("from", opts.from);
+    if (opts?.to)
+      params.set("to", opts.to);
+    return this.request("GET", `${ENDPOINTS.BILLING_TRANSACTIONS(orgId)}?${params}`);
+  }
+  async listBillingTransactionMachineGroups(orgId, opts) {
+    const params = new URLSearchParams({ group_by: "machine" });
+    if (opts?.from)
+      params.set("from", opts.from);
+    if (opts?.to)
+      params.set("to", opts.to);
+    return this.request("GET", `${ENDPOINTS.BILLING_TRANSACTIONS(orgId)}?${params}`);
   }
   async createCheckout(orgId, req) {
     return this.request("POST", ENDPOINTS.BILLING_CHECKOUT(orgId), req);
@@ -1913,6 +2001,12 @@ var ApiError = class extends Error {
 };
 
 // ts/sdk/dist/ws.js
+function isRetryableNetworkError(err) {
+  return err instanceof Error && err.name === "ApiError" && "status" in err && err.status === 0;
+}
+function isBrowserRuntime() {
+  return typeof window !== "undefined";
+}
 var ParallWs = class {
   ws = null;
   options;
@@ -1948,7 +2042,11 @@ var ParallWs = class {
     try {
       ticket = await this.options.getTicket();
     } catch (err) {
-      console.error("Failed to get WS ticket:", err);
+      if (isBrowserRuntime() && isRetryableNetworkError(err)) {
+        console.warn("Failed to get WS ticket:", err);
+      } else {
+        console.error("Failed to get WS ticket:", err);
+      }
       if (this.options.reconnect) {
         this.scheduleReconnect();
       } else {
@@ -2277,6 +2375,7 @@ var ParallAgentGateway = class {
   opts;
   chatInfoMap = /* @__PURE__ */ new Map();
   activeDispatches = /* @__PURE__ */ new Map();
+  injectedTypingCounts = /* @__PURE__ */ new Map();
   dispatchedTasks = /* @__PURE__ */ new Set();
   dispatchedMessages = /* @__PURE__ */ new Set();
   forkStates = /* @__PURE__ */ new Map();
@@ -2312,9 +2411,9 @@ var ParallAgentGateway = class {
     this.SHUTDOWN_DEADLINE_MS = opts.shutdownDeadlineMs ?? 6e4;
   }
   async run(abortSignal) {
-    const { ws, log } = this.opts;
+    const { ws, log: log2 } = this.opts;
     ws.onStateChange((state) => {
-      log?.info(`parall[${this.opts.accountId}]: connection state \u2192 ${state}`);
+      log2?.info(`parall[${this.opts.accountId}]: connection state \u2192 ${state}`);
     });
     ws.on("hello", async (data) => {
       await this.handleHello(data);
@@ -2471,6 +2570,34 @@ var ParallAgentGateway = class {
     if (this.opts.ws.state === "connected")
       this.opts.ws.sendTyping(chatId, "stop");
   }
+  shouldShowTyping(event) {
+    return event.type === "message" && event.targetId.startsWith("cht_") && !event.noReply;
+  }
+  startInjectedTyping(event) {
+    if (!this.shouldShowTyping(event))
+      return;
+    this.startTyping(event.targetId);
+    this.injectedTypingCounts.set(event.targetId, (this.injectedTypingCounts.get(event.targetId) ?? 0) + 1);
+  }
+  takeInjectedTypingCount(chatId) {
+    const count = this.injectedTypingCounts.get(chatId) ?? 0;
+    this.injectedTypingCounts.delete(chatId);
+    return count;
+  }
+  async runDispatchWithTyping(event, sessionKey, bodyForAgent, earlierEvents = [], captureText, opts = {}) {
+    const showTyping = !opts.suppressStart && (this.shouldShowTyping(event) || earlierEvents.some((e) => this.shouldShowTyping(e)));
+    if (showTyping)
+      this.startTyping(event.targetId);
+    try {
+      return await this.runDispatch(event, sessionKey, bodyForAgent, earlierEvents, captureText);
+    } finally {
+      if (showTyping)
+        this.stopTyping(event.targetId);
+      for (let i = 0; i < (opts.injectedTypingCount ?? 0); i++) {
+        this.stopTyping(event.targetId);
+      }
+    }
+  }
   buildDispatchContext(event, sessionKey) {
     const binding = this.sessionBindings.get(sessionKey);
     return {
@@ -2503,7 +2630,8 @@ var ParallAgentGateway = class {
           trigger_ref: event.type === "task" ? { task_id: event.targetId } : event.type === "task_comment" ? { comment_id: event.messageId, task_id: event.targetId } : event.type === "schedule" ? { schedule_id: event.targetId, run_id: event.messageId } : event.type === "approval" ? { approval_id: event.messageId } : { message_id: event.messageId },
           sender_id: event.senderId,
           sender_name: event.senderName,
-          summary: event.body.substring(0, 200)
+          summary: event.body.substring(0, 200),
+          ...event.sentAt ? { sent_at: event.sentAt } : {}
         }
       });
     } catch (err) {
@@ -2727,7 +2855,8 @@ var ParallAgentGateway = class {
           continue;
         }
         if (!binding) {
-          throw new Error(`runtime emitted ${runtimeEvent.type} before runtime_session`);
+          const detail = runtimeEvent.type === "error" ? `: ${runtimeEvent.message}` : "";
+          throw new Error(`runtime emitted ${runtimeEvent.type} before runtime_session${detail}`);
         }
         if (!triggerMessageSet) {
           triggerMessageSet = true;
@@ -2801,7 +2930,7 @@ var ParallAgentGateway = class {
         const earlier = events.slice(0, -1);
         try {
           const batchText = [];
-          const dispatched = await this.runDispatch(last, fork.fork.sessionKey, buildForkScopePrefix(last) + buildEventBody(last), earlier, batchText);
+          const dispatched = await this.runDispatchWithTyping(last, fork.fork.sessionKey, buildForkScopePrefix(last) + buildEventBody(last), earlier, batchText);
           if (!dispatched) {
             for (const item of items) {
               item.resolve(false);
@@ -2842,6 +2971,7 @@ var ParallAgentGateway = class {
             targetId: fork.targetId,
             summary: fork.processedEvents.length === 1 ? `${first.type} from ${first.senderName} in ${first.targetName ?? fork.targetId}` : `${fork.processedEvents.length} events in ${first.targetName ?? fork.targetId}`
           },
+          eventBodies: fork.processedEvents.map((e) => buildEventBodyForForkResult(e)),
           actions: [],
           agentSummary,
           historyPath
@@ -2881,32 +3011,11 @@ var ParallAgentGateway = class {
       return;
     this.draining = true;
     try {
-      while (this.dispatchState.mainBuffer.length > 0 || this.dispatchState.pendingForkResults.length > 0) {
+      while (this.dispatchState.mainBuffer.length > 0) {
         if (this.shuttingDown) {
           this.opts.log?.info(`parall[${this.opts.accountId}]: drainMainBuffer halted (shutting down) \u2014 ${this.dispatchState.mainBuffer.length} buffered, ${this.dispatchState.pendingForkResults.length} pending fork results left for catch-up`);
           break;
         }
-        if (this.dispatchState.mainBuffer.length === 0 && this.dispatchState.pendingForkResults.length > 0) {
-          const pending = this.dispatchState.pendingForkResults.splice(0);
-          const forkPrefix2 = buildForkResultPrefix(pending);
-          const syntheticEvent = {
-            type: "message",
-            targetId: "_orchestrator",
-            targetType: "system",
-            senderId: "system",
-            senderName: "system",
-            messageId: `synthetic-${this.opts.accountId}-${randomUUID()}`,
-            body: "[Orchestrator: fork session(s) completed \u2014 review results above]"
-          };
-          this.dispatchState.mainCurrentTargetId = void 0;
-          this.dispatchState.mainPreDispatchBranchPoint = this.opts.dispatchAdapter.getBranchPoint?.(this.opts.runtimeKey);
-          const dispatched2 = await this.runDispatch(syntheticEvent, this.opts.runtimeKey, forkPrefix2 + buildEventBody(syntheticEvent));
-          if (!dispatched2) {
-            this.dispatchState.pendingForkResults.unshift(...pending);
-            break;
-          }
-          continue;
-        }
         const targetId = this.dispatchState.mainBuffer[0].targetId;
         const events = [];
         while (this.dispatchState.mainBuffer[0]?.targetId === targetId) {
@@ -2914,12 +3023,13 @@ var ParallAgentGateway = class {
         }
         const event = events[events.length - 1];
         const earlier = events.slice(0, -1);
-        const skipForkSplice = this.opts.dispatchAdapter.hasPendingInjections?.(this.opts.runtimeKey) ?? false;
-        const pendingFork = skipForkSplice ? [] : this.dispatchState.pendingForkResults.splice(0);
+        const hasPendingInjections = this.opts.dispatchAdapter.hasPendingInjections?.(this.opts.runtimeKey) ?? false;
+        const injectedTypingCount = hasPendingInjections ? this.takeInjectedTypingCount(event.targetId) : 0;
+        const pendingFork = hasPendingInjections ? [] : this.dispatchState.pendingForkResults.splice(0);
         const forkPrefix = buildForkResultPrefix(pendingFork);
         this.dispatchState.mainCurrentTargetId = event.targetId;
         this.dispatchState.mainPreDispatchBranchPoint = this.opts.dispatchAdapter.getBranchPoint?.(this.opts.runtimeKey);
-        const dispatched = await this.runDispatch(event, this.opts.runtimeKey, forkPrefix + buildEventBody(event), earlier);
+        const dispatched = await this.runDispatchWithTyping(event, this.opts.runtimeKey, forkPrefix + buildEventBody(event), earlier, void 0, { suppressStart: injectedTypingCount > 0, injectedTypingCount });
         if (!dispatched) {
           this.dispatchState.mainBuffer.unshift(...events);
           this.dispatchState.pendingForkResults.unshift(...pendingFork);
@@ -2953,7 +3063,7 @@ var ParallAgentGateway = class {
         this.dispatchState.mainPreDispatchBranchPoint = this.opts.dispatchAdapter.getBranchPoint?.(this.opts.runtimeKey);
         let dispatched = false;
         try {
-          dispatched = await this.runDispatch(event, this.opts.runtimeKey, forkPrefix + buildEventBody(event));
+          dispatched = await this.runDispatchWithTyping(event, this.opts.runtimeKey, forkPrefix + buildEventBody(event));
           if (!dispatched) {
             this.dispatchState.pendingForkResults.unshift(...pendingFork);
           }
@@ -2966,10 +3076,15 @@ var ParallAgentGateway = class {
         if (this.shuttingDown) {
           return false;
         }
-        if (this.dispatchState.mainCurrentTargetId === event.targetId && this.opts.dispatchAdapter.enqueueDuringDispatch?.(this.opts.runtimeKey, buildEventBody(event))) {
-          this.opts.log?.info(`parall[${this.opts.accountId}]: steer injected to stdin for ${event.messageId} (will drain for bookkeeping)`);
-        }
         this.dispatchState.mainBuffer.push(event);
+        if (this.dispatchState.mainCurrentTargetId === event.targetId && await this.opts.dispatchAdapter.enqueueDuringDispatch?.(this.opts.runtimeKey, buildEventBody(event))) {
+          this.startInjectedTyping(event);
+          this.opts.log?.info(`parall[${this.opts.accountId}]: steer injected for ${event.messageId} (will drain for bookkeeping)`);
+        }
+        if (!this.dispatchState.mainDispatching && !this.draining && this.dispatchState.mainBuffer.length > 0) {
+          this.dispatchState.mainDispatching = true;
+          void this.drainMainBuffer();
+        }
         return false;
       }
       case "buffer-fork": {
@@ -3071,6 +3186,7 @@ var ParallAgentGateway = class {
         threadRootId: message.thread_root_id ?? void 0,
         noReply: message.hints?.no_reply ?? false,
         attachments: attachments.length > 0 ? attachments : void 0,
+        sentAt: message.created_at,
         ackSourceType: "message",
         ackSourceId: message.id
       }
@@ -3092,9 +3208,6 @@ var ParallAgentGateway = class {
       return;
     }
     const event = decision.event;
-    const willDispatch = !this.dispatchState.mainDispatching || this.dispatchState.mainCurrentTargetId !== chatId;
-    if (willDispatch)
-      this.startTyping(chatId);
     try {
       const dispatched = await this.handleInboundEvent(event);
       if (dispatched) {
@@ -3106,9 +3219,6 @@ var ParallAgentGateway = class {
     } catch (err) {
       this.opts.log?.error(`parall[${this.opts.accountId}]: event dispatch failed for ${data.id}: ${String(err)}`);
       this.dispatchedMessages.delete(data.id);
-    } finally {
-      if (willDispatch)
-        this.stopTyping(chatId);
     }
   }
   async handleTaskAssignment(task, ackSourceId) {
@@ -3138,6 +3248,7 @@ var ParallAgentGateway = class {
       senderName: "system",
       messageId: task.id,
       body: parts.join("\n"),
+      sentAt: task.updated_at ?? task.created_at,
       ackSourceType: "task_activity",
       ackSourceId
     };
@@ -3438,12 +3549,12 @@ var ParallAgentGateway = class {
     }
   }
   async handleHello(data) {
-    const { client, config, log } = this.opts;
+    const { client, config, log: log2 } = this.opts;
     this.sessionId = data.session_id ?? "";
     const intervalSec = data.heartbeat_interval > 0 ? data.heartbeat_interval : 30;
     try {
       const count = await fetchAllChats(client, config.org_id, this.chatInfoMap);
-      log?.info(`parall[${this.opts.accountId}]: WebSocket connected, ${count} chats cached`);
+      log2?.info(`parall[${this.opts.accountId}]: WebSocket connected, ${count} chats cached`);
       await this.opts.onSessionReady?.({
         activeSessionId: this.activeSessionId,
         ws: this.opts.ws,
@@ -3457,7 +3568,7 @@ var ParallAgentGateway = class {
         const expectedMs = intervalSec * 1e3;
         const drift = now - this.lastHeartbeatAt - expectedMs;
         if (drift > 15e3) {
-          log?.warn(`parall[${this.opts.accountId}]: heartbeat drift ${drift}ms \u2014 event loop may be blocked`);
+          log2?.warn(`parall[${this.opts.accountId}]: heartbeat drift ${drift}ms \u2014 event loop may be blocked`);
         }
         this.lastHeartbeatAt = now;
         if (this.opts.ws.state !== "connected")
@@ -3473,10 +3584,10 @@ var ParallAgentGateway = class {
       const isFirstHello = !this.hadSuccessfulHello;
       this.hadSuccessfulHello = true;
       this.catchUpFromDispatch(isFirstHello).catch((err) => {
-        log?.warn(`parall[${this.opts.accountId}]: dispatch catch-up failed: ${String(err)}`);
+        log2?.warn(`parall[${this.opts.accountId}]: dispatch catch-up failed: ${String(err)}`);
       });
     } catch (err) {
-      log?.error(`parall[${this.opts.accountId}]: failed to fetch chats: ${String(err)}`);
+      log2?.error(`parall[${this.opts.accountId}]: failed to fetch chats: ${String(err)}`);
     }
   }
   // Resolves when in-flight dispatches hit 0 or the deadline elapses.
@@ -3581,7 +3692,7 @@ function extractDefaults(config, runtimeType) {
   return { model, thinkingEffort };
 }
 function createPlatformConfigManager(opts) {
-  const { client, stateDir, runtimeType, log } = opts;
+  const { client, stateDir, runtimeType, log: log2 } = opts;
   let cachedVersion;
   let currentDefaults = { model: null, thinkingEffort: null };
   let currentRawConfig = null;
@@ -3598,20 +3709,20 @@ function createPlatformConfigManager(opts) {
         fresh = await client.getPlatformConfig(cachedVersion);
       } catch (err) {
         if (cached) {
-          log?.warn(`platform config fetch failed, using cached version ${cachedVersion}: ${String(err)}`);
+          log2?.warn(`platform config fetch failed, using cached version ${cachedVersion}: ${String(err)}`);
           return currentDefaults;
         }
-        log?.warn(`platform config fetch failed and no cache available: ${String(err)}`);
+        log2?.warn(`platform config fetch failed and no cache available: ${String(err)}`);
         return currentDefaults;
       }
       if (fresh === null) {
         return currentDefaults;
       }
       if (fresh.schema_version !== void 0 && fresh.schema_version > SUPPORTED_SCHEMA_VERSION) {
-        log?.warn(`platform config schema_version ${fresh.schema_version} > supported (${SUPPORTED_SCHEMA_VERSION}), keeping current`);
+        log2?.warn(`platform config schema_version ${fresh.schema_version} > supported (${SUPPORTED_SCHEMA_VERSION}), keeping current`);
         return currentDefaults;
       }
-      log?.info(`platform config updated to version ${fresh.version}`);
+      log2?.info(`platform config updated to version ${fresh.version}`);
       saveCache(stateDir, fresh);
       cachedVersion = fresh.version;
       currentRawConfig = fresh.config;
@@ -4187,8 +4298,8 @@ function stepIdFilePathForSession(stateDir, sessionKey) {
 // ts/claude-agent/dist/dispatch.js
 import * as fs5 from "node:fs";
 import * as path6 from "node:path";
-import { randomUUID as randomUUID2 } from "node:crypto";
-import { spawn } from "node:child_process";
+import { randomUUID } from "node:crypto";
+import { execSync as execSync2, spawn } from "node:child_process";
 
 // ts/agent-core/dist/internal/attachment-input.js
 import { execSync } from "node:child_process";
@@ -4489,7 +4600,7 @@ function sameFileIdentity(a, b) {
 function sameFile(a, b) {
   return sameFileIdentity(a, b) && a.size === b.size && a.mtimeMs === b.mtimeMs;
 }
-async function cleanupOldAttachmentFiles(rootDir, ttlMs, log, preserveDirs) {
+async function cleanupOldAttachmentFiles(rootDir, ttlMs, log2, preserveDirs) {
   let entries;
   try {
     entries = await fs4.readdir(rootDir, { withFileTypes: true });
@@ -4511,11 +4622,11 @@ async function cleanupOldAttachmentFiles(rootDir, ttlMs, log, preserveDirs) {
         await fs4.rm(fullPath, { recursive: true, force: true });
       }
     } catch (err) {
-      log?.warn?.(`agent-core: failed to clean attachment temp dir ${fullPath}: ${String(err)}`);
+      log2?.warn?.(`agent-core: failed to clean attachment temp dir ${fullPath}: ${String(err)}`);
     }
   }));
 }
-async function pruneAttachmentCache(rootDir, maxBytes, log, preserveDirs) {
+async function pruneAttachmentCache(rootDir, maxBytes, log2, preserveDirs) {
   if (maxBytes <= 0)
     return;
   let entries;
@@ -4538,7 +4649,7 @@ async function pruneAttachmentCache(rootDir, maxBytes, log, preserveDirs) {
       dirs.push({ path: fullPath, mtimeMs: stat.mtimeMs, size });
       total += size;
     } catch (err) {
-      log?.warn?.(`agent-core: failed to inspect attachment cache dir ${fullPath}: ${String(err)}`);
+      log2?.warn?.(`agent-core: failed to inspect attachment cache dir ${fullPath}: ${String(err)}`);
     }
   }
   if (total <= maxBytes)
@@ -4553,7 +4664,7 @@ async function pruneAttachmentCache(rootDir, maxBytes, log, preserveDirs) {
       await fs4.rm(dir.path, { recursive: true, force: true });
       total -= dir.size;
     } catch (err) {
-      log?.warn?.(`agent-core: failed to prune attachment cache dir ${dir.path}: ${String(err)}`);
+      log2?.warn?.(`agent-core: failed to prune attachment cache dir ${dir.path}: ${String(err)}`);
     }
   }
 }
@@ -4948,6 +5059,20 @@ async function* parseClaudeStreamJson(readable) {
 }
 
 // ts/claude-agent/dist/dispatch.js
+var IS_WIN32 = process.platform === "win32";
+function quoteWin32Arg(arg) {
+  if (!/[\s"&|^<>()]/.test(arg))
+    return arg;
+  return `"${arg.replace(/"/g, '""')}"`;
+}
+function killWin32Tree(pid) {
+  try {
+    execSync2(`taskkill /T /F /PID ${pid}`, { windowsHide: true, stdio: "ignore" });
+    return true;
+  } catch {
+    return false;
+  }
+}
 function buildSpawnEnv(parentEnv, claudeHome, context, opts) {
   const env = { ...parentEnv };
   if (!opts.allowApiKey) {
@@ -5089,12 +5214,12 @@ var ClaudeCodeAdapter = class _ClaudeCodeAdapter {
    * state.steerReadPending so the next runTurn can drain it instead of
    * silently losing the first event of the subsequent turn.
    */
-  async *consumeSteerTurn(sessionKey, log) {
+  async *consumeSteerTurn(sessionKey, log2) {
     const state = this.processes.get(sessionKey);
     if (!state || state.done) {
       throw new Error("claude-agent: process dead during steer consumption");
     }
-    const groupKey = randomUUID2();
+    const groupKey = randomUUID();
     const parserNext = state.parser.next();
     const firstRead = await Promise.race([
       parserNext.then((r) => ({ kind: "value", result: r })),
@@ -5102,7 +5227,7 @@ var ClaudeCodeAdapter = class _ClaudeCodeAdapter {
     ]);
     if (firstRead.kind === "timeout") {
       state.steerReadPending = parserNext;
-      log?.info?.(`claude-agent: steer turn timeout \u2014 steer was incorporated into previous turn`);
+      log2?.info?.(`claude-agent: steer turn timeout \u2014 steer was incorporated into previous turn`);
       return;
     }
     let next = firstRead.result;
@@ -5132,15 +5257,15 @@ var ClaudeCodeAdapter = class _ClaudeCodeAdapter {
       next = await state.parser.next();
     }
   }
-  async *runTurn(sessionKey, promptBody, log) {
+  async *runTurn(sessionKey, promptBody, log2) {
     let state;
     try {
-      state = this.ensureProcess(sessionKey, log);
+      state = this.ensureProcess(sessionKey, log2);
     } catch (err) {
       yield { type: "error", message: `Claude spawn failed: ${String(err)}` };
       return;
     }
-    const groupKey = randomUUID2();
+    const groupKey = randomUUID();
     let sawError = false;
     try {
       this.writeUserMessage(state.handle, promptBody);
@@ -5178,9 +5303,12 @@ var ClaudeCodeAdapter = class _ClaudeCodeAdapter {
       if (next.done) {
         state.done = true;
         this.processes.delete(sessionKey);
+        const detail = state.handle.stderrChunks.join("").trim();
+        const exit = await state.handle.exitPromise.catch(() => ({ code: null, signal: null }));
+        if (detail) {
+          log2?.warn?.(`claude-agent: subprocess stderr: ${detail}`);
+        }
         if (!sawError) {
-          const detail = state.handle.stderrChunks.join("").trim();
-          const exit = await state.handle.exitPromise.catch(() => ({ code: null, signal: null }));
           yield {
             type: "error",
             message: detail || `Claude exited with code ${exit.code ?? "unknown"}${exit.signal ? ` (${exit.signal})` : ""}`
@@ -5220,7 +5348,7 @@ var ClaudeCodeAdapter = class _ClaudeCodeAdapter {
       yield { ...parsed, groupKey };
     }
   }
-  ensureProcess(sessionKey, log) {
+  ensureProcess(sessionKey, log2) {
     if (this.shuttingDown) {
       throw new Error("claude-agent: adapter shutting down, refusing new process");
     }
@@ -5235,21 +5363,22 @@ var ClaudeCodeAdapter = class _ClaudeCodeAdapter {
         this.processes.delete(sessionKey);
       }
     }
-    const handle = this.spawnProcess(sessionKey, log);
+    const handle = this.spawnProcess(sessionKey, log2);
     const parser = parseClaudeStreamJson(handle.proc.stdout);
     const state = { handle, parser, done: false, needsRestart: false };
     this.processes.set(sessionKey, state);
     this.opts.sessionManager.registerProcess(sessionKey, handle);
     return state;
   }
-  spawnProcess(sessionKey, log) {
+  spawnProcess(sessionKey, log2) {
     const args = this.buildArgs(sessionKey);
     const env = buildSpawnEnv(process.env, this.opts.claudeHome, this.buildPlaceholderContext(sessionKey), { allowApiKey: this.opts.allowApiKey, effortLevel: this._effortLevel });
-    log?.info(`claude-agent: spawn long-lived ${this.opts.claudeBin} (session ${sessionKey}, model=${this._model || "default"}, effort=${this._effortLevel || "default"}, mode=${this.opts.permissionMode})`);
-    const proc = spawn(this.opts.claudeBin, args, {
+    log2?.info(`claude-agent: spawn long-lived ${this.opts.claudeBin} (session ${sessionKey}, model=${this._model || "default"}, effort=${this._effortLevel || "default"}, mode=${this.opts.permissionMode})`);
+    const proc = spawn(IS_WIN32 ? quoteWin32Arg(this.opts.claudeBin) : this.opts.claudeBin, IS_WIN32 ? args.map(quoteWin32Arg) : args, {
       cwd: this.opts.workspaceDir,
       env,
-      stdio: ["pipe", "pipe", "pipe"]
+      stdio: ["pipe", "pipe", "pipe"],
+      shell: IS_WIN32
     });
     if (!proc.stdout || !proc.stderr || !proc.stdin) {
       throw new Error("Claude subprocess did not provide stdio pipes");
@@ -5261,7 +5390,9 @@ var ClaudeCodeAdapter = class _ClaudeCodeAdapter {
     proc.stdin.on("error", () => {
       proc.stdin.destroy();
       if (proc.exitCode === null && proc.signalCode === null) {
-        proc.kill("SIGTERM");
+        if (!IS_WIN32 || !proc.pid || !killWin32Tree(proc.pid)) {
+          proc.kill("SIGTERM");
+        }
       }
     });
     const exitPromise = new Promise((resolve3) => {
@@ -5282,7 +5413,9 @@ var ClaudeCodeAdapter = class _ClaudeCodeAdapter {
     }
     if (state.handle.proc.exitCode === null && state.handle.proc.signalCode === null) {
       try {
-        state.handle.proc.kill("SIGTERM");
+        if (!IS_WIN32 || !state.handle.proc.pid || !killWin32Tree(state.handle.proc.pid)) {
+          state.handle.proc.kill("SIGTERM");
+        }
       } catch {
       }
     }
@@ -5300,7 +5433,6 @@ var ClaudeCodeAdapter = class _ClaudeCodeAdapter {
   }
   buildArgs(sessionKey) {
     const args = [
-      "-p",
       "--verbose",
       "--input-format",
       "stream-json",
@@ -5351,7 +5483,7 @@ var ClaudeCodeAdapter = class _ClaudeCodeAdapter {
 // ts/claude-agent/dist/session-manager.js
 import * as fs6 from "node:fs";
 import * as path7 from "node:path";
-import { randomUUID as randomUUID3 } from "node:crypto";
+import { randomUUID as randomUUID2 } from "node:crypto";
 var ClaudeSessionManager = class _ClaudeSessionManager {
   mainSessionKey;
   stateFilePath;
@@ -5388,7 +5520,7 @@ var ClaudeSessionManager = class _ClaudeSessionManager {
     const parentSessionId = this.sessionIds.get(parentSessionKey);
     if (!parentSessionId)
       return null;
-    const sessionKey = `claude-fork:${randomUUID3()}`;
+    const sessionKey = `claude-fork:${randomUUID2()}`;
     this.pendingForkParents.set(sessionKey, parentSessionId);
     return {
       sessionKey,
@@ -5522,7 +5654,7 @@ var ClaudeSessionManager = class _ClaudeSessionManager {
 // ts/claude-agent/dist/workspace.js
 import * as fs7 from "node:fs";
 import * as path8 from "node:path";
-function ensureClaudeWorkspace(workspaceDir, log, agentIdentity) {
+function ensureClaudeWorkspace(workspaceDir, log2, agentIdentity) {
   const systemPrompt = [
     buildIdentity(agentIdentity),
     BRIDGE_WORKSPACE_INSTRUCTIONS,
@@ -5540,13 +5672,7 @@ function ensureClaudeWorkspace(workspaceDir, log, agentIdentity) {
 }
 
 // ts/claude-agent/dist/index.js
-function createLogger(prefix) {
-  return {
-    info: (msg) => console.log(`[${prefix}] ${msg}`),
-    warn: (msg) => console.warn(`[${prefix}] ${msg}`),
-    error: (msg) => console.error(`[${prefix}] ${msg}`)
-  };
-}
+var log = createLogger("claude-agent");
 async function getAgentMeWithLegacyFallback(client, orgId) {
   try {
     return await client.getAgentMe(orgId);
@@ -5560,7 +5686,6 @@ async function getAgentMeWithLegacyFallback(client, orgId) {
 }
 async function main() {
   const config = resolveClaudeAgentConfig(process.env);
-  const log = createLogger("claude-agent");
   if (config.allowApiKey && (process.env.ANTHROPIC_API_KEY || process.env.ANTHROPIC_AUTH_TOKEN)) {
     log.warn("PRLL_CLAUDE_ALLOW_API_KEY=1 \u2014 ANTHROPIC_API_KEY/ANTHROPIC_AUTH_TOKEN will reach the Claude CLI; billing routes through Anthropic API pay-per-use instead of Claude.ai OAuth.");
   }
@@ -5680,6 +5805,6 @@ async function main() {
   }
 }
 main().catch((err) => {
-  console.error(`[claude-agent] fatal: ${String(err)}`);
+  log.error(`fatal: ${String(err)}`);
   process.exitCode = 1;
 });