@clawos-dev/clawd 0.2.141 → 0.2.142-beta.297.e4b56a8

package/dist/cli.cjs

@@ -5952,10 +5952,12 @@ var init_dispatch = __esm({
     ]);
     DispatchRunArgsSchema = external_exports.object({
       targetPersona: external_exports.string().min(1),
-      prompt: external_exports.string()
+      prompt: external_exports.string(),
+      // mode='continue' 时 daemon 反查 (sourceSessionId, targetPersona) 最近 B session 复用；
+      // 'new' 或 undefined（默认）= 当前行为，新建 B。
+      mode: external_exports.enum(["new", "continue"]).optional()
     });
     DispatchCompleteArgsSchema = external_exports.object({
-      dispatchId: external_exports.string().min(1),
       outcome: DispatchOutcomeSchema
     });
   }
@@ -31802,8 +31804,6 @@ function buildSpawnContext(state, deps) {
   env.CLAWD_SESSION_ID = file.sessionId;
   const daemonUrl = deps.getDaemonUrl?.() ?? null;
   if (daemonUrl) env.CLAWD_DAEMON_URL = daemonUrl;
-  const dispatchId = deps.lookupDispatchByBSessionId?.(file.sessionId);
-  if (dispatchId) env.CLAWD_DISPATCH_ID = dispatchId;
   const dispatchMcpConfigPath2 = deps.getDispatchMcpConfigPath?.() ?? null;
   const ctx = {
     cwd: file.cwd,
@@ -32566,10 +32566,9 @@ var SessionRunner = class {
       // 单栏 refactor (spec 2026-06-02 §5.1): cc 子进程 env 注入 CLAWD_DAEMON_URL，让 assistant
       // curl daemon HTTP RPC adapter (/api/rpc/<method>) 触发管理操作。null = HTTP adapter 未启。
       getDaemonUrl: this.hooks.getDaemonUrl,
-      // Persona dispatch：透传 dispatch.mcp.json 路径闭包 + B→dispatchId 反查闭包。
-      // 见 reducer.buildSpawnContext 注 CLAWD_DISPATCH_ID env / 派生 SpawnContext.dispatchMcpConfigPath
+      // Persona dispatch：透传 dispatch.mcp.json 路径闭包；cc spawn 加 --mcp-config 让两侧
+      // cc 都能看到 personaDispatch / personaDispatchComplete tool（按 session 身份区分用哪个）。
       getDispatchMcpConfigPath: this.hooks.getDispatchMcpConfigPath,
-      lookupDispatchByBSessionId: this.hooks.lookupDispatchByBSessionId,
       // ReadyGate v2：透传 mode 让 reducer send / ready-detected 分支决定走暂存队列还是直写
       mode: this.hooks.mode,
       // [RG-DBG] 注入 logger 让 reducer rgDbg 走 pino 进 clawd.log；定位完跟 rgDbg 一起删
@@ -33041,9 +33040,22 @@ You may read this file with your Read tool to understand context. You do not hav
 
 When done, call the MCP tool \`mcp__clawd-dispatch__personaDispatchComplete\` with your result:
   - Success: { text: "...", filePaths?: ["abs/path", ...] }
-  - Failure: { isFailure: true, reason: "..." }
+  - Failure: { isFailure: true, reason: "..." }`;
+}
+function buildDispatchContinuationPack(args) {
+  return `[Dispatched from owner \u2014 follow-up query]
+
+Although you reported back on the previous task, the owner has a follow-up question. Continue from where you left off.
 
-dispatchId for this task: ${args.dispatchId}`;
+Owner's new message:
+${args.prompt}
+
+Source conversation (jsonl, same path as before, may contain new messages):
+  ${args.sourceJsonlPath}
+
+When done, call \`mcp__clawd-dispatch__personaDispatchComplete\` again with your result:
+  - Success: { text: "...", filePaths?: ["abs/path", ...] }
+  - Failure: { isFailure: true, reason: "..." }`;
 }
 function derivePersonaSpawnCwd(file, personaRoot) {
   const personaId = file.ownerPersonaId;
@@ -33245,6 +33257,23 @@ var SessionManager = class {
     const file = this.findOwnedSession(sessionId);
     return file ? this.scopeForFile(file) : null;
   }
+  /**
+   * 反查 (sourceSessionId, targetPersona) 最近一次被 dispatched 出的 B session。
+   * mode='continue' 路径用：命中 → 复用该 B；不命中 → fallback 走新建路径。
+   *
+   * 反查源是 SessionStore 持久化字段（dispatchedFromSessionId + ownerPersonaId），不引入新表，
+   * daemon 重启不丢。同对历史多条按 updatedAt 取最近（reducer 写入时持续更新）。
+   */
+  findLatestDispatchedSession(args) {
+    const candidates = this.listAllOwned().filter(
+      (f) => f.dispatchedFromSessionId === args.sourceSessionId && f.ownerPersonaId === args.targetPersona
+    );
+    if (candidates.length === 0) return null;
+    candidates.sort(
+      (a, b2) => a.updatedAt > b2.updatedAt ? -1 : a.updatedAt < b2.updatedAt ? 1 : 0
+    );
+    return candidates[0];
+  }
   // 合并 default + 每个 persona 的 owner/ + guests/<capId>/ —— 桌面 App 主 session 列表入口.
   // guest sessions 由 handlers/session.ts list 处按 ctx.principal.kind === 'guest' 做权限过滤
   // (creatorPrincipalId === capId), 这里仅负责数据源汇总.
@@ -33351,10 +33380,9 @@ var SessionManager = class {
       // 单栏 refactor (spec 2026-06-02 §5.1): 透传 daemon HTTP RPC base URL 闭包,
       // reducer 把它注入 cc 子进程 env CLAWD_DAEMON_URL.
       getDaemonUrl: this.deps.getDaemonUrl,
-      // Persona dispatch (Task 7): dispatch.mcp.json 路径 + B sessionId → dispatchId 反查
-      // 闭包透传给 reducer，让 cc spawn 加 --mcp-config flag + B session 注 CLAWD_DISPATCH_ID env.
+      // Persona dispatch: dispatch.mcp.json 路径闭包透传给 reducer，让 cc spawn 加 --mcp-config flag。
+      // dispatchId 不再走 cc env——complete handler 用 sessionId 反查 in-flight dispatchId 配对。
       getDispatchMcpConfigPath: this.deps.dispatchMcpConfigPath ? () => this.deps.dispatchMcpConfigPath ?? null : void 0,
-      lookupDispatchByBSessionId: this.deps.personaDispatchManager ? (bSid) => this.deps.personaDispatchManager?.lookupDispatchByBSessionId(bSid) : void 0,
       // file-sharing (spec §6 PR 3)：闭包 scope + sessionId，runner 只暴露 tool/relPath/cwd
       onFileEdit: attachmentGroup ? (input) => attachmentGroup.onFileEdit({
         scope,
@@ -34172,10 +34200,11 @@ var SessionManager = class {
    * Persona dispatch: 启动 B session 并投递任务包当第一条 user message。
    *
    *   - 复用 persona-owner 创建路径（cwd=personaDir、scope=persona-owner、不沙箱）
-   *   - SessionFile 上写 dispatchedFromSessionId 关联回 A（UI 折叠用；mirror 一侧 strip）
-   *   - 跟 PersonaDispatchManager 双向登记 dispatchId ↔ B sessionId，让后续 reducer
-   *     buildSpawnContext 能反查到 dispatchId 注 CLAWD_DISPATCH_ID env
-   *   - 投 inject-owner-text 任务包；包尾教 B 用 personaDispatchComplete tool 回传
+   *   - SessionFile 上写 dispatchedFromSessionId 关联回 A（UI 折叠用；mirror 一侧 strip；
+   *     mode='continue' 路径 findLatestDispatchedSession 也按此字段反查复用）
+   *   - 跟 PersonaDispatchManager 登记 dispatchId → B sessionId（complete handler 用
+   *     findInflightDispatchByBSessionId 反查回 dispatchId 配对 A 的 waiter）
+   *   - 投任务包；包尾教 B 用 personaDispatchComplete tool 回传
    *
    * cwd 派生与 SessionManager.create 的 owner persona 路径一致（derivePersonaSpawnCwd）。
    */
@@ -34218,8 +34247,7 @@ var SessionManager = class {
     });
     const taskPack = buildDispatchTaskPack({
       prompt: args.prompt,
-      sourceJsonlPath: args.sourceJsonlPath,
-      dispatchId: args.dispatchId
+      sourceJsonlPath: args.sourceJsonlPath
     });
     runner.input({ kind: "command", command: { kind: "send", text: taskPack } });
     this.deps.logger?.info("dispatch.createDispatchedSession.task-pack-sent", {
@@ -34228,6 +34256,41 @@ var SessionManager = class {
     });
     return { sessionId };
   }
+  /**
+   * mode='continue' 复用已有 B session，投 continuation pack 给 runner。
+   *
+   * 关键差异 vs createDispatchedSession：
+   *   - 不 newSessionId() / 不 storeFor(scope).write()——SessionFile 复用
+   *   - 跟 PersonaDispatchManager 重新登记 dispatchId → bSessionId（新 dispatchId、同 bSessionId）
+   *   - ensureRunnerForScope 在 runner 不存在时建；存在则复用
+   *   - runner.input send 投 continuationPack：runner / reducer 内部决定 cc 死活；
+   *     cc 活 → 自然续；cc 死 → spawn 时 jsonl 已存在自动 --resume <toolSessionId>
+   */
+  resumeDispatchedSession(args) {
+    if (!this.deps.personaDispatchManager) {
+      throw new Error("resumeDispatchedSession: personaDispatchManager missing in ManagerDeps");
+    }
+    const file = this.findOwnedSession(args.bSessionId);
+    if (!file) {
+      throw new Error(`resumeDispatchedSession: B session ${args.bSessionId} not found`);
+    }
+    const scope = this.scopeForFile(file);
+    this.deps.personaDispatchManager.registerBSession(args.dispatchId, args.bSessionId);
+    this.deps.logger?.info("dispatch.resumeDispatchedSession.registered", {
+      dispatchId: args.dispatchId,
+      bSessionId: args.bSessionId
+    });
+    const runner = this.ensureRunnerForScope(file, scope);
+    const pack = buildDispatchContinuationPack({
+      prompt: args.prompt,
+      sourceJsonlPath: args.sourceJsonlPath
+    });
+    runner.input({ kind: "command", command: { kind: "send", text: pack } });
+    this.deps.logger?.info("dispatch.resumeDispatchedSession.continuation-sent", {
+      dispatchId: args.dispatchId,
+      bSessionId: args.bSessionId
+    });
+  }
   /**
    * 老板插话：把 'inject-owner-text' input 喂给对应 runner，
    * runner 不存在时按 scope 懒创建。
@@ -36929,6 +36992,7 @@ var PersonaDispatchManager = class {
       dispatchId,
       sourceSessionId: args.sourceSessionId,
       targetPersona: args.targetPersona,
+      bSessionId: args.bSessionId,
       waiters: [],
       outcome: null
     });
@@ -36959,10 +37023,22 @@ var PersonaDispatchManager = class {
     if (!state) throw new Error(`unknown dispatchId: ${dispatchId}`);
     state.bSessionId = bSessionId;
   }
-  /** reducer buildSpawnContext 调，按 B 的 sessionId 反查 dispatchId（用于注 CLAWD_DISPATCH_ID env） */
-  lookupDispatchByBSessionId(bSessionId) {
+  /**
+   * 按 B sessionId 找当前 in-flight（未 resolved）的 dispatchId。
+   * complete handler 用这个把 B 的 outcome 配对回 A 的 waiter——dispatchId 不再走 cc env，
+   * 全靠 (bSessionId → in-flight dispatchId) 反查。
+   *
+   * 同一 bSessionId 不会同时有多个 in-flight（A 拿不到 outcome 不会发起新 dispatch；
+   * mode='continue' 入口已防御重入）。
+   *
+   * 历史 entry（已 resolved）暂不清——单 daemon lifetime 累积可接受；未来用量大了加 TTL GC
+   * （complete 后 5min 删 entry）。
+   */
+  findInflightDispatchByBSessionId(bSessionId) {
     for (const state of this.map.values()) {
-      if (state.bSessionId === bSessionId) return state.dispatchId;
+      if (state.bSessionId === bSessionId && state.outcome === null) {
+        return state.dispatchId;
+      }
     }
     return void 0;
   }
@@ -36994,6 +37070,15 @@ function writeDispatchMcpConfig(args) {
 
 // src/handlers/persona-dispatch.ts
 init_protocol();
+var NO_PREVIOUS_PREFIX = "(no previous session found, started fresh)";
+function prefixNoPreviousOutcome(outcome) {
+  if (outcome.kind === "success") {
+    return { ...outcome, text: `${NO_PREVIOUS_PREFIX}
+
+${outcome.text}` };
+  }
+  return { ...outcome, reason: `${NO_PREVIOUS_PREFIX} ${outcome.reason}` };
+}
 function buildPersonaDispatchHandlers(deps) {
   const { personaDispatchManager: mgr, spawnB, logger } = deps;
   const run = async (frame) => {
@@ -37005,26 +37090,66 @@ function buildPersonaDispatchHandlers(deps) {
         "personaDispatch:run requires sessionId (caller must pass x-clawd-session-id header)"
       );
     }
+    const requestedMode = args.mode ?? "new";
+    let route = "new";
+    let bSessionId;
+    let noPrevious = false;
+    if (requestedMode === "continue") {
+      const bFile = deps.findLatestDispatchedSession?.({
+        sourceSessionId,
+        targetPersona: args.targetPersona
+      });
+      if (bFile) {
+        const inflight = deps.findInflightDispatchByBSessionId?.(bFile.sessionId);
+        if (inflight) {
+          logger?.warn("dispatch.run.continue.busy", {
+            sourceSessionId,
+            targetPersona: args.targetPersona,
+            bSessionId: bFile.sessionId,
+            inflightDispatchId: inflight
+          });
+          return {
+            response: {
+              type: "personaDispatch:run:ok",
+              outcome: {
+                kind: "failure",
+                reason: "previous dispatch to this persona session not yet complete"
+              }
+            }
+          };
+        }
+        route = "continue";
+        bSessionId = bFile.sessionId;
+      } else {
+        noPrevious = true;
+      }
+    }
     const { dispatchId } = mgr.start({
       sourceSessionId,
-      targetPersona: args.targetPersona
+      targetPersona: args.targetPersona,
+      bSessionId
     });
     logger?.info("dispatch.run.received", {
       dispatchId,
       sourceSessionId,
       targetPersona: args.targetPersona,
-      promptLen: args.prompt.length
+      promptLen: args.prompt.length,
+      requestedMode,
+      route,
+      noPrevious
     });
     void spawnB({
       dispatchId,
       sourceSessionId,
       targetPersona: args.targetPersona,
-      prompt: args.prompt
+      prompt: args.prompt,
+      route,
+      bSessionId
     }).then(() => {
-      logger?.info("dispatch.spawnB.ok", { dispatchId });
+      logger?.info("dispatch.spawnB.ok", { dispatchId, route });
     }).catch((err) => {
       const reason = err instanceof Error ? err.message : String(err);
-      logger?.warn("dispatch.spawnB.failed", { dispatchId, reason });
+      logger?.warn("dispatch.spawnB.failed", { dispatchId, route, reason });
       mgr.complete(dispatchId, {
         kind: "failure",
         reason: `failed to spawn B: ${reason}`
@@ -37036,18 +37161,32 @@ function buildPersonaDispatchHandlers(deps) {
       dispatchId,
       outcomeKind: outcome.kind
     });
+    const finalOutcome = noPrevious ? prefixNoPreviousOutcome(outcome) : outcome;
     return {
-      response: { type: "personaDispatch:run:ok", outcome }
+      response: { type: "personaDispatch:run:ok", outcome: finalOutcome }
     };
   };
   const complete = async (frame) => {
     const { type: _t, requestId: _r, ...rest } = frame;
+    const sessionId = typeof rest.sessionId === "string" ? rest.sessionId : void 0;
     const args = DispatchCompleteArgsSchema.parse(rest);
+    if (!sessionId) {
+      throw new Error(
+        "personaDispatch:complete requires sessionId (caller must pass x-clawd-session-id header)"
+      );
+    }
+    const dispatchId = mgr.findInflightDispatchByBSessionId(sessionId);
+    if (!dispatchId) {
+      throw new Error(
+        `no in-flight dispatch for session ${sessionId} (already completed or B was never dispatched)`
+      );
+    }
     logger?.info("dispatch.complete.received", {
-      dispatchId: args.dispatchId,
+      dispatchId,
+      sessionId,
       outcomeKind: args.outcome.kind
     });
-    mgr.complete(args.dispatchId, args.outcome);
+    mgr.complete(dispatchId, args.outcome);
     return {
       response: { type: "personaDispatch:complete:ok" }
     };
@@ -45723,9 +45862,9 @@ async function startDaemon(config) {
     // 127.0.0.1（不是 config.host）—— cc 跑在本机，loopback 最稳；外部访问限制 + http-router
     // 的 isLoopback 兜底已确保安全。
     getDaemonUrl: () => `http://127.0.0.1:${config.port}`,
-    // Persona dispatch (Task 8): manager 通过这两个 deps 跟 PersonaDispatchManager 协作。
-    // - personaDispatchManager: manager.createDispatchedSession 用它 registerBSession；
-    //   reducer 通过闭包反查 dispatchId 注 CLAWD_DISPATCH_ID env。
+    // Persona dispatch: manager 通过这两个 deps 跟 PersonaDispatchManager 协作。
+    // - personaDispatchManager: createDispatchedSession / resumeDispatchedSession 用它
+    //   registerBSession；complete handler 用 findInflightDispatchByBSessionId 反查回 dispatchId。
     // - dispatchMcpConfigPath: reducer 透传到 SpawnContext，cc spawn 加 --mcp-config flag。
     personaDispatchManager,
     dispatchMcpConfigPath: dispatchMcpConfigPath2,
@@ -46054,11 +46193,16 @@ async function startDaemon(config) {
   const dispatchHandlers = buildPersonaDispatchHandlers({
     personaDispatchManager,
     logger,
+    // continue 路径反查（命中 → 走 resumeDispatchedSession；不命中 → fallback 新建 + outcome 前缀）
+    findLatestDispatchedSession: (q) => manager.findLatestDispatchedSession(q),
+    // continue 路径防御：B 仍有 in-flight 时直接 fail（老板规则不会触发，但兜底）
+    findInflightDispatchByBSessionId: (sid) => personaDispatchManager.findInflightDispatchByBSessionId(sid),
     spawnB: async (args) => {
       logger.info("dispatch.spawnB.start", {
         dispatchId: args.dispatchId,
         targetPersona: args.targetPersona,
-        sourceSessionId: args.sourceSessionId
+        sourceSessionId: args.sourceSessionId,
+        route: args.route
       });
       const sourceFile = manager.findOwnedSession(args.sourceSessionId);
       if (!sourceFile) {
@@ -46074,15 +46218,28 @@ async function startDaemon(config) {
       logger.info("dispatch.spawnB.source-resolved", {
         dispatchId: args.dispatchId,
         sourceJsonlPath,
-        hasToolSessionId: Boolean(sourceFile.toolSessionId)
-      });
-      manager.createDispatchedSession({
-        dispatchId: args.dispatchId,
-        sourceSessionId: args.sourceSessionId,
-        targetPersona: args.targetPersona,
-        prompt: args.prompt,
-        sourceJsonlPath
+        hasToolSessionId: Boolean(sourceFile.toolSessionId),
+        route: args.route
       });
+      if (args.route === "continue") {
+        if (!args.bSessionId) {
+          throw new Error("continue route requires bSessionId");
+        }
+        manager.resumeDispatchedSession({
+          dispatchId: args.dispatchId,
+          bSessionId: args.bSessionId,
+          prompt: args.prompt,
+          sourceJsonlPath
+        });
+      } else {
+        manager.createDispatchedSession({
+          dispatchId: args.dispatchId,
+          sourceSessionId: args.sourceSessionId,
+          targetPersona: args.targetPersona,
+          prompt: args.prompt,
+          sourceJsonlPath
+        });
+      }
     }
   });
   handlers = { ...handlers, ...dispatchHandlers };

package/dist/dispatch/mcp-server.cjs

@@ -39574,9 +39574,11 @@ async function handlePersonaDispatchToolCall(input, ctx) {
         "content-type": "application/json",
         "x-clawd-session-id": ctx.sessionId
       },
+      // input.mode === undefined → JSON.stringify omit；daemon parse 用 .optional() 接住缺省。
       body: JSON.stringify({
         targetPersona: input.targetPersona,
-        prompt: input.prompt
+        prompt: input.prompt,
+        mode: input.mode
       })
     });
   } catch (err) {
@@ -39626,16 +39628,16 @@ async function handlePersonaDispatchCompleteToolCall(input, ctx) {
     isFailure: Boolean(input.isFailure),
     textLen: input.text?.length ?? 0,
     filePathCount: input.filePaths?.length ?? 0,
-    dispatchId: ctx.dispatchId,
+    sessionId: ctx.sessionId,
     daemonUrl: ctx.daemonUrl
   });
-  if (!ctx.dispatchId) {
-    log("personaDispatchComplete CLAWD_DISPATCH_ID missing");
+  if (!ctx.sessionId) {
+    log("personaDispatchComplete CLAWD_SESSION_ID missing");
     return {
       content: [
         {
           type: "text",
-          text: "Error: CLAWD_DISPATCH_ID env not set; this session was not dispatched."
+          text: "Error: CLAWD_SESSION_ID env not set; daemon cannot resolve in-flight dispatch without sessionId."
         }
       ],
       isError: true
@@ -39650,14 +39652,15 @@ async function handlePersonaDispatchCompleteToolCall(input, ctx) {
     filePaths: input.filePaths
   };
   const url = `${ctx.daemonUrl}/api/rpc/personaDispatch.complete`;
-  log("personaDispatchComplete pre-fetch", { url, hasSessionId: Boolean(ctx.sessionId) });
-  const headers = { "content-type": "application/json" };
-  if (ctx.sessionId) headers["x-clawd-session-id"] = ctx.sessionId;
+  log("personaDispatchComplete pre-fetch", { url, sessionId: ctx.sessionId });
   try {
     const res = await f(url, {
       method: "POST",
-      headers,
-      body: JSON.stringify({ dispatchId: ctx.dispatchId, outcome })
+      headers: {
+        "content-type": "application/json",
+        "x-clawd-session-id": ctx.sessionId
+      },
+      body: JSON.stringify({ outcome })
     });
     log("personaDispatchComplete post-fetch", { url, status: res.status });
   } catch (err) {
@@ -39681,12 +39684,10 @@ async function handlePersonaDispatchCompleteToolCall(input, ctx) {
 async function main() {
   const daemonUrl = process.env.CLAWD_DAEMON_URL;
   const sessionId = process.env.CLAWD_SESSION_ID;
-  const dispatchId = process.env.CLAWD_DISPATCH_ID;
   log("boot", {
     pid: process.pid,
     hasDaemonUrl: Boolean(daemonUrl),
     hasSessionId: Boolean(sessionId),
-    hasDispatchId: Boolean(dispatchId),
     logPath: DISPATCH_LOG ?? "(stderr)"
   });
   if (!daemonUrl) {
@@ -39703,11 +39704,14 @@ async function main() {
     "personaDispatch",
     {
       title: "Dispatch task to another persona",
-      description: "Delegate a task to another clawd persona. Use this when the user message contains `@persona/<id>` to hand the task off to that persona. The tool blocks until the other persona finishes and returns its result.",
+      description: "Delegate a task to another clawd persona. Use this when the user message contains `@persona/<id>` to hand the task off to that persona. The tool blocks until the other persona finishes and returns its result. Pass mode='continue' when the user's follow-up message is clearly a continuation of the task you already dispatched to this persona (the previous B session is resumed with its full context). Omit (or pass 'new') for an independent new task. Default is 'new'.",
       inputSchema: {
         targetPersona: external_exports.string().describe("persona id (e.g. persona-bug-fixer)"),
         prompt: external_exports.string().describe(
           "the task to perform, with the @persona/<id> token stripped out"
+        ),
+        mode: external_exports.enum(["new", "continue"]).optional().describe(
+          "continue = resume the previous B session for this (sourceSession, targetPersona) pair; new (default) = fresh B session"
         )
       }
     },
@@ -39726,8 +39730,8 @@ async function main() {
       }
     },
     // sessionId 透传：complete RPC 必须带 x-clawd-session-id header（rpc-adapter 强制）。
-    // B session 的 cc env 有 CLAWD_SESSION_ID = B 的 sessionId。
-    async (input) => handlePersonaDispatchCompleteToolCall(input, { daemonUrl, sessionId, dispatchId })
+    // daemon 用该 sessionId 反查 PersonaDispatchManager 里该 B 的 in-flight dispatchId 配对回 A 的 waiter。
+    async (input) => handlePersonaDispatchCompleteToolCall(input, { daemonUrl, sessionId })
   );
   await server.connect(new StdioServerTransport());
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@clawos-dev/clawd",
-  "version": "0.2.141",
+  "version": "0.2.142-beta.297.e4b56a8",
   "description": "Standalone clawd daemon — Claude Code (and future Codex) session server over WebSocket",
   "type": "module",
   "license": "MIT",