@parall/daemon 1.55.0 → 1.55.2

package/bundle/parall-claude-agent.js

@@ -51863,6 +51863,13 @@ var ENDPOINTS = {
   PROJECTS: (orgId) => `${API_BASE}/orgs/${orgId}/projects`,
   PROJECT_TASK_SUMMARY: (orgId) => `${API_BASE}/orgs/${orgId}/projects/task-summary`,
   PROJECT: (orgId, projectId) => `${API_BASE}/orgs/${orgId}/projects/${projectId}`,
+  PROJECT_MEMBERS: (orgId, projectId) => `${API_BASE}/orgs/${orgId}/projects/${projectId}/members`,
+  PROJECT_READERS: (orgId, projectId) => `${API_BASE}/orgs/${orgId}/projects/${projectId}/readers`,
+  PROJECT_LIBRARY: (orgId) => `${API_BASE}/orgs/${orgId}/projects/library`,
+  PROJECT_JOIN: (orgId, projectId) => `${API_BASE}/orgs/${orgId}/projects/${projectId}/join`,
+  PROJECT_JOIN_REQUESTS: (orgId, projectId) => `${API_BASE}/orgs/${orgId}/projects/${projectId}/join-requests`,
+  // subject is a bare user ID or a bare team ID; both are path-segment safe.
+  PROJECT_MEMBER: (orgId, projectId, subject) => `${API_BASE}/orgs/${orgId}/projects/${projectId}/members/${subject}`,
   // Schedules (org-scoped, platform time trigger primitive)
   SCHEDULES: (orgId) => `${API_BASE}/orgs/${orgId}/schedules`,
   SCHEDULE: (orgId, id) => `${API_BASE}/orgs/${orgId}/schedules/${id}`,
@@ -52080,6 +52087,9 @@ var ENDPOINTS = {
   ORG_EDGE_PROFILES: (orgId, edgeId) => `/api/v1/orgs/${orgId}/edge/${edgeId}/profiles`,
   // Per-profile egress proxy (hosted Cloud Profiles; manager-only, human-only).
   ORG_EDGE_PROFILE_PROXY: (orgId, edgeId, profileName) => `/api/v1/orgs/${orgId}/edge/${edgeId}/profiles/${encodeURIComponent(profileName)}/proxy`,
+  // Per-profile one-shot cookie seed (hosted Cloud Profiles; manager-only,
+  // human-only, idle-only). Injected at the next cold start, then consumed.
+  ORG_EDGE_PROFILE_COOKIES: (orgId, edgeId, profileName) => `/api/v1/orgs/${orgId}/edge/${edgeId}/profiles/${encodeURIComponent(profileName)}/cookies`,
   ORG_EDGE_EXEC: (orgId) => `/api/v1/orgs/${orgId}/edge/exec`,
   // Cloud Edge live viewer command (V1b) — api-server, gated on cap:edge-viewer.
   // Same request/reply shape as the v2 browser-profile viewer, on the v3 edge
@@ -52121,6 +52131,7 @@ var WS_EVENTS = {
   PONG: "pong",
   WATCHING: "watching",
   MESSAGE_NEW: "message.new",
+  /** @deprecated `message.patch` is retired and never published; kept for compile compatibility. */
   MESSAGE_PATCH: "message.patch",
   MESSAGE_EDIT: "message.edit",
   MESSAGE_DELETE: "message.delete",
@@ -52316,6 +52327,62 @@ var ProjectTaskClient = class {
   async deleteProject(orgId, projectId) {
     return this.request("DELETE", ENDPOINTS.PROJECT(orgId, projectId));
   }
+  /** Roster with display info; readable by anyone who can read the project. */
+  async getProjectMembers(orgId, projectId) {
+    const res = await this.request("GET", ENDPOINTS.PROJECT_MEMBERS(orgId, projectId));
+    return res.data;
+  }
+  /**
+   * User IDs who may read the project — the assignee-eligibility set. Every
+   * tier answers the roster expansion (direct, team-reached, org
+   * owners/admins); visibility only shapes admission, never reach.
+   */
+  async getProjectReaders(orgId, projectId) {
+    const res = await this.request("GET", ENDPOINTS.PROJECT_READERS(orgId, projectId));
+    return res.data;
+  }
+  /** The join library: every discoverable project (public + restricted, plus
+   * private for org owners/admins) with the caller's admission state. */
+  async getProjectLibrary(orgId) {
+    const res = await this.request("GET", ENDPOINTS.PROJECT_LIBRARY(orgId));
+    return res.data;
+  }
+  /** Public-tier self-admission: writes the caller's own member row.
+   * Other tiers answer `404 PROJECT_NOT_FOUND`; a duplicate answers
+   * `409 MEMBER_EXISTS`. */
+  async joinProject(orgId, projectId) {
+    return this.request("POST", ENDPOINTS.PROJECT_JOIN(orgId, projectId));
+  }
+  /** Restricted-tier admission petition. A pending duplicate answers
+   * `409 REQUEST_EXISTS`; membership answers `409 MEMBER_EXISTS`. */
+  async createProjectJoinRequest(orgId, projectId) {
+    return this.request("POST", ENDPOINTS.PROJECT_JOIN_REQUESTS(orgId, projectId));
+  }
+  /** Pending petitions for one project — manager standing required. */
+  async listProjectJoinRequests(orgId, projectId) {
+    const res = await this.request("GET", ENDPOINTS.PROJECT_JOIN_REQUESTS(orgId, projectId));
+    return res.data;
+  }
+  /** Withdraws the caller's own pending petition. */
+  async cancelProjectJoinRequest(orgId, projectId) {
+    return this.request("DELETE", ENDPOINTS.PROJECT_JOIN_REQUESTS(orgId, projectId));
+  }
+  /**
+   * Adds one subject (user ID or team ID) to the roster. Manager-only,
+   * create-only: an existing row answers `409 MEMBER_EXISTS` — change roles
+   * through updateProjectMember instead.
+   */
+  async addProjectMember(orgId, projectId, req) {
+    return this.request("POST", ENDPOINTS.PROJECT_MEMBERS(orgId, projectId), req);
+  }
+  /** Sets one roster entry's role. Demoting the last manager answers `400 LAST_MANAGER`. */
+  async updateProjectMember(orgId, projectId, subject, req) {
+    return this.request("PATCH", ENDPOINTS.PROJECT_MEMBER(orgId, projectId, subject), req);
+  }
+  /** Removes one roster entry. Removing the last manager answers `400 LAST_MANAGER`. */
+  async removeProjectMember(orgId, projectId, subject) {
+    return this.request("DELETE", ENDPOINTS.PROJECT_MEMBER(orgId, projectId, subject));
+  }
 };
 
 // ts/sdk/dist/task-label-client.js
@@ -52708,8 +52775,9 @@ var ParallClient = class _ParallClient extends TaskLabelClient {
     return this.request("POST", ENDPOINTS.TEAMS(orgId), req);
   }
   /**
-   * Renames a team. The slug cannot be changed — wiki ACL rows reference it as
-   * `@slug`, so the server answers 400 SLUG_IMMUTABLE if one is sent.
+   * Renames a team. Renaming is an ordinary edit: ACL rows reference teams by
+   * ID. Names are org-unique (case-insensitive); a duplicate answers 409
+   * NAME_TAKEN.
    */
   async updateTeam(orgId, teamId, req) {
     return this.request("PATCH", ENDPOINTS.TEAM(orgId, teamId), req);
@@ -54338,15 +54406,18 @@ var ParallClient = class _ParallClient extends TaskLabelClient {
   /**
    * Read a clip's per-org agent exec access. Org-member readable (agents
    * included, so a denied agent can learn why exec answered
-   * `CLIP_AGENT_NOT_ALLOWED`).
+   * `CLIP_AGENT_NOT_ALLOWED` / `CLIP_AGENT_CONNECTION_NOT_ALLOWED`).
    */
   async getClipAgentExecAccess(orgId, clipId) {
     return this.request("GET", ENDPOINTS.ORG_CLIP_EXEC_ACCESS(orgId, clipId));
   }
   /**
    * Replace a clip's per-org agent exec access. Human-only (agent principals
-   * get 403); under `all_agents` the `agent_ids` must be empty. Every granted
-   * id must be an active agent of this org (else `400 INVALID_INPUT`).
+   * get 403); under `all_agents` both lists must be empty; pass either
+   * `agent_ids` (legacy flat form → every agent gets `connection_scope: 'all'`)
+   * or `grants` (connection-scoped), never both. Every granted id must be an
+   * active agent of this org, and every `connection_ids` entry a connection of
+   * THIS clip in this org (else `400 INVALID_INPUT`).
    */
   async putClipAgentExecAccess(orgId, clipId, access) {
     return this.request("PUT", ENDPOINTS.ORG_CLIP_EXEC_ACCESS(orgId, clipId), access);
@@ -54432,6 +54503,41 @@ var ParallClient = class _ParallClient extends TaskLabelClient {
       headers: expectedVersion ? { "If-Match": `"proxy-${expectedVersion}"` } : void 0
     });
   }
+  /**
+   * Read a hosted Cloud Profile's one-shot cookie-seed status (manager-only:
+   * hosted human maintainer or org admin). Sanitized — cookie VALUES never come
+   * back, only `cookie_count` and the distinct target `domains`. `can_mutate` /
+   * `lease_status` are the authoritative idle gate. Typed errors: `EDGE_NOT_HOSTED`
+   * (BYOC device), `NOT_FOUND` (unknown profile).
+   */
+  async getEdgeProfileCookieSeed(orgId, edgeId, profileName) {
+    return this.request("GET", ENDPOINTS.ORG_EDGE_PROFILE_COOKIES(orgId, edgeId, profileName));
+  }
+  /**
+   * Set/replace the profile's one-shot cookie seed (the full normalized cookie
+   * array every time) — IDLE ONLY: while the profile's hosted browser is running
+   * the server answers 409 `EDGE_PROFILE_IN_USE`; close the viewer, wait for idle
+   * scale-to-zero, and retry. The next cold start injects the cookies into the
+   * profile partition and consumes the seed. Other typed errors:
+   * `EDGE_COOKIE_SEED_STALE` (409 — expectedVersion lost a tab race, sent as the
+   * `cookieseed-<version>` If-Match), `EDGE_DELETING` (409), and
+   * `SECRETBOX_UNCONFIGURED` (503 — server cannot store cookies safely).
+   */
+  async setEdgeProfileCookieSeed(orgId, edgeId, profileName, req, expectedVersion) {
+    return this.request("PUT", ENDPOINTS.ORG_EDGE_PROFILE_COOKIES(orgId, edgeId, profileName), req, void 0, false, {
+      headers: expectedVersion ? { "If-Match": `"cookieseed-${expectedVersion}"` } : void 0
+    });
+  }
+  /**
+   * Clear the pending cookie seed (does NOT sign the profile out — cookies
+   * already injected into the partition stay). Idle-only like set — 409
+   * `EDGE_PROFILE_IN_USE` while the browser is live.
+   */
+  async clearEdgeProfileCookieSeed(orgId, edgeId, profileName, expectedVersion) {
+    return this.request("DELETE", ENDPOINTS.ORG_EDGE_PROFILE_COOKIES(orgId, edgeId, profileName), void 0, void 0, false, {
+      headers: expectedVersion ? { "If-Match": `"cookieseed-${expectedVersion}"` } : void 0
+    });
+  }
   /**
    * Execute a registry clip command on an Edge device.
    *
@@ -55779,6 +55885,56 @@ async function consumeMessageWorkItem(host, item) {
   }
 }
 
+// ts/agent-core/dist/dispatch-inactivity-deadline.js
+var DispatchInactivityDeadline = class {
+  timeoutMs;
+  onExpire;
+  onDispose;
+  timer = null;
+  expired = false;
+  disposed = false;
+  constructor(timeoutMs, onExpire, onDispose) {
+    this.timeoutMs = timeoutMs;
+    this.onExpire = onExpire;
+    this.onDispose = onDispose;
+  }
+  touch = () => {
+    if (this.timeoutMs <= 0 || this.expired || this.disposed)
+      return;
+    if (this.timer)
+      clearTimeout(this.timer);
+    this.timer = setTimeout(() => {
+      this.timer = null;
+      this.expired = true;
+      this.onExpire();
+    }, this.timeoutMs);
+  };
+  dispose() {
+    if (this.disposed)
+      return;
+    this.disposed = true;
+    if (this.timer)
+      clearTimeout(this.timer);
+    this.timer = null;
+    this.onDispose();
+  }
+};
+var DispatchInactivityDeadlines = class {
+  active = /* @__PURE__ */ new Map();
+  start(sessionKey, timeoutMs, onExpire) {
+    const deadline = new DispatchInactivityDeadline(timeoutMs, onExpire, () => {
+      if (this.active.get(sessionKey) === deadline)
+        this.active.delete(sessionKey);
+    });
+    this.active.set(sessionKey, deadline);
+    deadline.touch();
+    return deadline;
+  }
+  touch(sessionKey) {
+    this.active.get(sessionKey)?.touch();
+  }
+};
+
 // ts/agent-core/dist/routing.js
 var MAX_CONCURRENT_FORKS = 20;
 var defaultRoutingStrategy = (event, state) => {
@@ -57324,6 +57480,7 @@ var ParallAgentGateway = class {
    * an unrelated stalled fork's lane leased forever).
    */
   sessionActiveLanes = /* @__PURE__ */ new Map();
+  dispatchInactivityDeadlines = new DispatchInactivityDeadlines();
   noteSessionLane(sessionKey, laneKey) {
     if (laneKey == null)
       this.sessionActiveLanes.delete(sessionKey);
@@ -57333,11 +57490,12 @@ var ParallAgentGateway = class {
   /**
    * External runtime-activity signal for adapters whose tool activity does
    * not flow through the RuntimeEvent stream (openclaw hooks call this from
-   * the tool-call lifecycle): renews the session's OWN active ledger lane so
-   * a long tool call cannot outlive the lease and get dethroned mid-turn.
-   * No-op without an active ledger lane for the session.
+   * the tool-call lifecycle): refreshes the dispatch inactivity deadline and
+   * renews the session's OWN active ledger lane, when present, so a long tool
+   * call cannot time out or get dethroned mid-turn.
    */
   touchRuntimeActivity(sessionKey) {
+    this.dispatchInactivityDeadlines.touch(sessionKey);
     if (this.ledgerDisabled)
       return;
     const laneKey = this.sessionActiveLanes.get(sessionKey);
@@ -57813,14 +57971,14 @@ var ParallAgentGateway = class {
         this.writeContextFile(laneContextFilePath2, contextBody);
       }
       this.inFlightDispatches++;
-      const deadlineTimer = this.DISPATCH_DEADLINE_MS > 0 ? setTimeout(() => {
-        this.opts.log?.warn(`dispatch deadline exceeded (${this.DISPATCH_DEADLINE_MS}ms) for ${event.messageId} on ${sessionKey}; aborting`);
+      const dispatchDeadline = this.dispatchInactivityDeadlines.start(sessionKey, this.DISPATCH_DEADLINE_MS, () => {
+        this.opts.log?.warn(`dispatch inactivity deadline exceeded (${this.DISPATCH_DEADLINE_MS}ms) for ${event.messageId} on ${sessionKey}; aborting`);
         try {
           this.opts.dispatchAdapter.abortDispatch?.(sessionKey);
         } catch (err) {
           this.opts.log?.warn(`abortDispatch threw for ${sessionKey}: ${String(err)}`);
         }
-      }, this.DISPATCH_DEADLINE_MS) : null;
+      });
       let binding = this.sessionBindings.get(sessionKey);
       let inputStepsCreated = false;
       let turnHandle;
@@ -57841,8 +57999,10 @@ var ParallAgentGateway = class {
           bodyForAgent,
           sessionKey,
           context: dispatchContext,
-          inputLifecycle
+          inputLifecycle,
+          noteActivity: dispatchDeadline.touch
         })) {
+          dispatchDeadline.touch();
           if (runtimeEvent.type === "runtime_session") {
             const priorAgentSessionId = binding?.agentSessionId;
             binding = await this.bindRuntimeSession(sessionKey, runtimeEvent, contextFilePath, laneContextFilePath2);
@@ -57979,8 +58139,7 @@ var ParallAgentGateway = class {
         }
         throw err;
       } finally {
-        if (deadlineTimer)
-          clearTimeout(deadlineTimer);
+        dispatchDeadline.dispose();
         const metricsSnapshot = getDispatchMetrics(sessionKey);
         const durationMs = metricsSnapshot ? Date.now() - metricsSnapshot.started_at : 0;
         const effectiveOutcome = turnOutcomeEvent?.outcome ?? (dispatchError || sawErrorEvent ? "runtime_crash" : "ok");
@@ -60516,6 +60675,7 @@ function parseTweets(data) { /* ... */ }
 - \`tab.cookie(name)\` \xB7 \`tab.fetch(url, opts)\` (in-browser fetch, carries the session)
 - \`tab.eval(expr)\` (escape hatch) \xB7 \`tab.click(sel)\` \xB7 \`tab.fill(sel, text)\` \xB7 \`tab.navigate(url)\`
 - \`tab.waitForSelector(sel)\` \xB7 \`tab.getTitle()\` \xB7 \`tab.getURL()\` \xB7 \`tab.screenshot()\` \xB7 \`tab.close()\`
+- \`tab.setFileInput(sel, url, opts?)\` \u2014 upload a file into an \`<input type=file>\`
 - \`fetch\` \u2014 runtime-side HTTP, does NOT go through the browser (no session)
 - \`console\` \u2014 logs \xB7 \`args\` \u2014 the invocation input
 
@@ -60524,6 +60684,40 @@ returns structured data; eval is the last resort. Always \`tab.close()\` what yo
 open, and do it in a \`finally\` \u2014 an early return or a thrown fetch is exactly
 when the tab leaks.
 
+### Uploading a file
+
+\`tab.setFileInput\` takes a URL, never a path, and the runtime \u2014 not the page \u2014
+fetches the bytes. That is what makes it work where an in-page \`fetch\` +
+\`DataTransfer\` cannot: upload targets ship a Content-Security-Policy that
+forbids the page from fetching an arbitrary file host (Instagram's \`default-src\`
+allows only its own domains), and you cannot change a header on their site. The
+runtime is not a page, so no CSP applies to it \u2014 and a large video never has to
+pass through the page's memory.
+
+\`\`\`js
+await tab.setFileInput("input[type=file]", videoUrl, { filename: "clip.mp4" });
+await tab.click("button[type=submit]");
+await tab.waitForSelector(".upload-complete");   // \u2190 do not skip this
+\`\`\`
+
+Four rules that decide whether your clip works:
+
+1. **The URL must be fetchable with no credentials** \u2014 a public direct link or a
+   signed temporary one. The runtime sends no cookies, so a Drive or Feishu link
+   copied from the address bar will not work: those are HTML pages behind a
+   login. If the file needs a session, use a logged-in tab to obtain a signed
+   direct link first, then pass THAT here. An HTML answer is refused with
+   \`EDGE_FILE_SOURCE_NOT_A_FILE\` rather than uploaded as if it were a file.
+2. **Finish the upload inside the same command.** The browser reads the file when
+   the page submits, and the runtime deletes it when your command ends. Injecting
+   and returning immediately uploads nothing \u2014 wait for the site to confirm.
+3. **Main-document inputs only.** An input inside an iframe or a shadow root is
+   not addressable and returns \`EDGE_FILE_SELECTOR_MISS\`. If the page rebuilds
+   the input after you inject (navigation, re-render), inject again.
+4. **\`opts.filename\` is what the page sees**, and many sites validate by
+   extension \u2014 set it when the URL has none. \`opts.timeoutMs\` bounds the
+   download. One file per call; there is no multi-file form yet.
+
 ## Develop \u2192 publish \u2192 iterate
 
 Use the platform \`parall clip\` subcommands \u2014 they reuse the credentials you
@@ -60630,18 +60824,30 @@ and the folder is just a manifest:
 }
 \`\`\`
 
-- The \`mcp\` block takes ONLY \`server_url\` and \`auth\` (\`"none" | "bearer" |
-  "api_key" | "oauth"\`). Any other key is refused at publish \u2014 a credential
-  belongs to the installing org's own configuration, NEVER to the clip
-  definition.
+- The \`mcp\` block takes ONLY \`server_url\`, \`auth\` (\`"none" | "api_key" |
+  "basic" | "oauth"\`, legacy \`"bearer"\` accepted) and \`auth_headers\`. Any
+  other key is refused at publish \u2014 a credential belongs to the installing
+  org's own configuration, NEVER to the clip definition.
+- \`auth\` is REQUIRED at publish: you know what your server speaks, and this
+  one word decides what the install form asks for (\`none\` = zero input,
+  \`api_key\` = key field(s), \`basic\` = username + password, \`oauth\` = a
+  Connect button).
+- \`api_key\` delivers as a single \`X-API-Key\` header by default. When the
+  server wants a different shape, declare \`auth_headers\` (max 4 slots, one
+  admin-supplied value each): \`[{"name": "Authorization", "scheme":
+  "Bearer"}]\` for Bearer tokens, \`[{"name": "api-key"}]\` for a custom
+  header, or a pair like \`[{"name": "CF-Access-Client-Id"}, {"name":
+  "CF-Access-Client-Secret"}]\`. Framing/platform headers (Host, Cookie,
+  X-Prll-*, \u2026) are refused.
 - \`server_url\` must be an absolute **https** URL with no embedded credentials,
   query, or fragment. It is review material, frozen with the approved version.
+  It stays OPTIONAL for self-hosted products where each org connects its own
+  instance URL.
 - Do NOT put the server in the top-level \`server\` / \`auth\` manifest keys \u2014
   those are legacy Edge-manifest fields nothing reads. Only the \`mcp\` block
   declares the server.
-- Both fields are optional, but what you declare is LOCKED: the installing
-  org's config must match it, and changing the URL or auth mode means
-  republishing.
+- What you declare is LOCKED: the installing org's config must match it, and
+  changing the URL, auth mode, or header shape means republishing.
 - Entering the credential / completing OAuth is a HUMAN step in the Clip
   Console (the config-write endpoints are session-only \u2014 an API key cannot
   call them). An org can add SEVERAL connections to one MCP clip \u2014 one
@@ -60727,14 +60933,17 @@ ${lines.join("\n")}
 }
 
 // ts/agent-core/dist/platform-instructions.js
-function buildBridgePlatformInstructions(workspaceDir, identity, capabilityFragments) {
+function buildPlatformInstructions(workspaceDir, runtimeAppendix, identity, capabilityFragments) {
   return renderPlatformInstructions({
     identity,
-    runtimeAppendix: PLATFORM_BRIDGE_WORKSPACE_INSTRUCTIONS,
+    runtimeAppendix,
     capabilityFragments,
     skillReferences: buildSkillReferences(workspaceDir)
   });
 }
+function buildBridgePlatformInstructions(workspaceDir, identity, capabilityFragments) {
+  return buildPlatformInstructions(workspaceDir, PLATFORM_BRIDGE_WORKSPACE_INSTRUCTIONS, identity, capabilityFragments);
+}
 
 // ts/agent-core/dist/prompt-fragments.js
 function identityFromMe(me) {
@@ -61666,8 +61875,10 @@ async function* parseClaudeStreamJson(readable) {
           yield { type: "assistant_error", message: message2 };
         continue;
       }
-      if (asTrimmedString(eventRecord.parent_tool_use_id))
+      if (asTrimmedString(eventRecord.parent_tool_use_id)) {
+        yield { type: "runtime_activity" };
         continue;
+      }
       const message = eventRecord.message;
       const content = message && typeof message === "object" ? message.content : void 0;
       if (!Array.isArray(content))
@@ -61712,8 +61923,10 @@ async function* parseClaudeStreamJson(readable) {
       continue;
     }
     if (eventRecord.type === "user") {
-      if (asTrimmedString(eventRecord.parent_tool_use_id))
+      if (asTrimmedString(eventRecord.parent_tool_use_id)) {
+        yield { type: "runtime_activity" };
         continue;
+      }
       const message = eventRecord.message;
       const content = message && typeof message === "object" ? message.content : void 0;
       if (!Array.isArray(content))
@@ -62076,7 +62289,7 @@ var ClaudeCodeAdapter = class {
       return false;
     return state.inputs.hasPendingInjections();
   }
-  async *dispatch({ event, bodyForAgent, sessionKey, context: context2, inputLifecycle }) {
+  async *dispatch({ event, bodyForAgent, sessionKey, context: context2, inputLifecycle, noteActivity }) {
     const deliveryKey = inputLifecycle?.deliveryKey ?? event.dispatchEventId ?? event.messageId;
     const existingState = this.processes.get(sessionKey);
     const injected = existingState?.inputs.getByKey(deliveryKey);
@@ -62087,7 +62300,7 @@ var ClaudeCodeAdapter = class {
         injected.drained = true;
         context2.log?.info?.(`consuming steer input ${injected.commandUuid}`);
         try {
-          yield* this.consumeDelivery(sessionKey, existingState, injected, context2.log);
+          yield* this.consumeDelivery(sessionKey, existingState, injected, context2.log, noteActivity);
         } finally {
           existingState.inputs.remove(injected);
         }
@@ -62117,7 +62330,7 @@ var ClaudeCodeAdapter = class {
       context2.log?.warn?.(`failed to prepare local attachments: ${String(err)}`);
     }
     try {
-      yield* this.runTurn(sessionKey, promptBody, deliveryKey, inputLifecycle, context2.log);
+      yield* this.runTurn(sessionKey, promptBody, deliveryKey, inputLifecycle, context2.log, noteActivity);
     } finally {
       releasePreparedAttachments();
     }
@@ -62158,7 +62371,7 @@ var ClaudeCodeAdapter = class {
     this.resetProcesses();
     await this.opts.sessionManager.shutdownAll();
   }
-  async *runTurn(sessionKey, promptBody, deliveryKey, lifecycle, log2) {
+  async *runTurn(sessionKey, promptBody, deliveryKey, lifecycle, log2, noteActivity) {
     let state;
     try {
       await this.ensureRuntimeCapability(log2);
@@ -62183,7 +62396,7 @@ var ClaudeCodeAdapter = class {
       return;
     }
     try {
-      yield* this.consumeDelivery(sessionKey, state, delivery, log2);
+      yield* this.consumeDelivery(sessionKey, state, delivery, log2, noteActivity);
     } finally {
       state.inputs.remove(delivery);
     }
@@ -62248,7 +62461,7 @@ var ClaudeCodeAdapter = class {
    * finish while this drain is active; their callbacks advance independently
    * and their later bookkeeping dispatch becomes a no-op.
    */
-  async *consumeDelivery(sessionKey, state, target, log2) {
+  async *consumeDelivery(sessionKey, state, target, log2, noteActivity) {
     if (target.terminal)
       return;
     const groupKey = randomUUID3();
@@ -62279,6 +62492,9 @@ var ClaudeCodeAdapter = class {
         return;
       }
       const parsed = next.value;
+      noteActivity?.();
+      if (parsed.type === "runtime_activity")
+        continue;
       if (parsed.type === "runtime_init") {
         state.capabilities = new Set(parsed.capabilities);
         if (parsed.sessionId) {