@clawos-dev/clawd 0.2.191 → 0.2.192-beta.386.33a5833

package/dist/cli.cjs

@@ -5996,7 +5996,7 @@ var init_feishu_auth = __esm({
 });
 
 // ../protocol/src/dispatch.ts
-var DispatchOutcomeSchema, DispatchRunArgsSchema, DispatchCompleteArgsSchema;
+var DispatchOutcomeSchema, DispatchRunArgsSchema, DispatchRunResponseSchema, DispatchCompleteArgsSchema;
 var init_dispatch = __esm({
   "../protocol/src/dispatch.ts"() {
     "use strict";
@@ -6017,10 +6017,21 @@ var init_dispatch = __esm({
       prompt: external_exports.string(),
       // 跨设备 dispatch：非空 = A 角色，转发到该 contact deviceId 的 peer daemon；
       // 省略 = 本地 dispatch / B 角色本地执行。A 转发给 B 时 body 不带此字段。
-      targetDeviceId: external_exports.string().min(1).optional()
+      targetDeviceId: external_exports.string().min(1).optional(),
+      // 精确寻址已知 B session（复用其上下文）：
+      //   - 本地（targetDeviceId 缺省）：daemon 校验目标为本机 session 且
+      //     dispatchedFromSessionId 匹配 A 的 sessionId（防越权）
+      //   - 跨设备（targetDeviceId 非空）：peer daemon 在其本地按同规则校验
+      //     creatorPrincipalId === A.deviceId
+      //   - 省略 = 新建 B session
+      targetSessionId: external_exports.string().min(1).optional()
+    });
+    DispatchRunResponseSchema = external_exports.object({
+      type: external_exports.literal("personaDispatch:run:ok"),
+      outcome: DispatchOutcomeSchema,
+      dispatchedSessionId: external_exports.string().min(1).optional()
     });
     DispatchCompleteArgsSchema = external_exports.object({
-      dispatchId: external_exports.string().min(1),
       outcome: DispatchOutcomeSchema
     });
   }
@@ -41552,8 +41563,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 personaId = file.ownerPersonaId;
   if (personaId) env.CLAWD_PERSONA_ID = personaId;
   const dispatchMcpConfigPath2 = deps.getDispatchMcpConfigPath?.() ?? null;
@@ -42359,14 +42368,14 @@ 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 flag
+      // 使两侧 cc 都能看到 personaDispatch / personaDispatchComplete tool（按 session 身份分工用哪个）。
+      // dispatchId 不注 cc env——complete handler 用 sessionId 反查 in-flight dispatchId 配对。
       getDispatchMcpConfigPath: this.hooks.getDispatchMcpConfigPath,
       getShiftMcpConfigPath: this.hooks.getShiftMcpConfigPath,
       getInboxMcpConfigPath: this.hooks.getInboxMcpConfigPath,
       // Ticket MCP：透传 ticket.mcp.json 路径闭包（reducer 内做 persona-ticket-manager gating）
       getTicketMcpConfigPath: this.hooks.getTicketMcpConfigPath,
-      lookupDispatchByBSessionId: this.hooks.lookupDispatchByBSessionId,
       // ReadyGate v2：透传 mode 让 reducer send / ready-detected 分支决定走暂存队列还是直写
       mode: this.hooks.mode,
       // [RG-DBG] 注入 logger 让 reducer rgDbg 走 pino 进 clawd.log；定位完跟 rgDbg 一起删
@@ -42850,9 +42859,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.
+
+Owner's new message:
+${args.prompt}
 
-dispatchId for this task: ${args.dispatchId}`;
+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;
@@ -43173,13 +43195,13 @@ 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 挂 dispatch MCP server（两侧 cc 都挂，按 session 身份分工调 tool）。
+      // dispatchId 不再走 cc env——complete handler 用 sessionId 反查 in-flight dispatchId 配对。
       getDispatchMcpConfigPath: this.deps.dispatchMcpConfigPath ? () => this.deps.dispatchMcpConfigPath ?? null : void 0,
       getTicketMcpConfigPath: this.deps.ticketMcpConfigPath ? () => this.deps.ticketMcpConfigPath ?? null : void 0,
       getShiftMcpConfigPath: this.deps.shiftMcpConfigPath ? () => this.deps.shiftMcpConfigPath ?? null : void 0,
       getInboxMcpConfigPath: this.deps.inboxMcpConfigPath ? () => this.deps.inboxMcpConfigPath ?? 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,
@@ -44019,10 +44041,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；
+   *     targetSessionId 复用路径也按此字段校验寻址来源）
+   *   - 跟 PersonaDispatchManager 登记 dispatchId → B sessionId（complete handler 用
+   *     findInflightDispatchByBSessionId 反查回 dispatchId 配对回 A 的 waiter）
+   *   - 投任务包；包尾教 B 用 personaDispatchComplete tool 回传
    *
    * cwd 派生与 SessionManager.create 的 owner persona 路径一致（derivePersonaSpawnCwd）。
    */
@@ -44077,8 +44100,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", {
@@ -44087,6 +44109,59 @@ var SessionManager = class {
     });
     return { sessionId };
   }
+  /**
+   * targetSessionId 精确寻址已知 B session 复用其上下文。投 continuation pack 给 runner。
+   *
+   * 关键差异 vs createDispatchedSession：
+   *   - 不 newSessionId() / 不写 SessionFile —— B session 复用（走 findOwnedSession）
+   *   - 权限校验：本地 dispatch → SessionFile.dispatchedFromSessionId === A 的 sessionId；
+   *     跨设备 B 角色 → SessionFile.creatorPrincipalId === A 的 deviceId
+   *   - 跟 PersonaDispatchManager 重新登记（新 dispatchId 复用同 bSessionId）
+   *   - ensureRunnerForScope: cc 活复用；cc 死时首次 send 触发 spawn，jsonl 已存在自动 --resume
+   *
+   * @param callerIdentity 权限校验依据：
+   *   - kind='local': A 的 sessionId（本机 dispatch），校验 dispatchedFromSessionId 匹配
+   *   - kind='guest': A 的 deviceId（跨设备转发进来的 A），校验 creatorPrincipalId 匹配
+   */
+  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`);
+    }
+    if (args.callerIdentity.kind === "local") {
+      if (file.dispatchedFromSessionId !== args.callerIdentity.sourceSessionId) {
+        throw new Error(
+          `resumeDispatchedSession: session ${args.bSessionId} not dispatched by caller (dispatchedFromSessionId mismatch)`
+        );
+      }
+    } else {
+      if (file.creatorPrincipalId !== args.callerIdentity.sourcePrincipalId) {
+        throw new Error(
+          `resumeDispatchedSession: session ${args.bSessionId} not dispatched by caller device (creatorPrincipalId mismatch)`
+        );
+      }
+    }
+    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
+    });
+    return { sessionId: args.bSessionId };
+  }
   /**
    * shift v1 (spec 2026-06-24-clawd-shift)：到点 fire 时由 ShiftScheduler 调，
    * 起一个新 cc session 跑 prompt（fire-and-forget，不绑 dispatchId / 不挂 caller）。
@@ -47493,6 +47568,7 @@ var PersonaDispatchManager = class {
       dispatchId,
       sourceSessionId: args.sourceSessionId,
       targetPersona: args.targetPersona,
+      bSessionId: args.bSessionId,
       waiters: [],
       outcome: null
     });
@@ -47523,10 +47599,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；
+   * 老板规则下 A 一次只能挂一个 waiter。
+   *
+   * 历史 entry（已 resolved）暂不清 —— 单 daemon lifetime 累积可接受；未来用量大了加
+   * TTL GC（complete 后 N min 删 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;
   }
@@ -48125,6 +48213,28 @@ function canAccessPersona(grants, personaId, action) {
 }
 
 // src/handlers/persona-dispatch.ts
+function assertLocalReuseAllowed(bFile, sourceSessionId) {
+  if (bFile.dispatchedFromSessionId !== sourceSessionId) {
+    throw new ClawdError(
+      ERROR_CODES.UNAUTHORIZED,
+      `targetSessionId not dispatched by caller (dispatchedFromSessionId mismatch)`
+    );
+  }
+}
+function assertGuestReuseAllowed(bFile, sourcePrincipalId, targetPersona) {
+  if (bFile.ownerPersonaId !== targetPersona) {
+    throw new ClawdError(
+      ERROR_CODES.UNAUTHORIZED,
+      `targetSessionId does not belong to targetPersona`
+    );
+  }
+  if (bFile.creatorPrincipalId !== sourcePrincipalId) {
+    throw new ClawdError(
+      ERROR_CODES.UNAUTHORIZED,
+      `targetSessionId not dispatched by caller device (creatorPrincipalId mismatch)`
+    );
+  }
+}
 function buildPersonaDispatchHandlers(deps) {
   const { personaDispatchManager: mgr, spawnB, logger } = deps;
   const run = async (frame, _client, ctx) => {
@@ -48143,15 +48253,21 @@ function buildPersonaDispatchHandlers(deps) {
       }
       logger?.info("dispatch.run.forward", {
         targetDeviceId: args.targetDeviceId,
-        targetPersona: args.targetPersona
+        targetPersona: args.targetPersona,
+        hasTargetSessionId: Boolean(args.targetSessionId)
       });
-      const outcome2 = await deps.forwardToPeer({
+      const { outcome: outcome2, dispatchedSessionId } = await deps.forwardToPeer({
         targetDeviceId: args.targetDeviceId,
         targetPersona: args.targetPersona,
-        prompt: args.prompt
+        prompt: args.prompt,
+        targetSessionId: args.targetSessionId
       });
       return {
-        response: { type: "personaDispatch:run:ok", outcome: outcome2 }
+        response: {
+          type: "personaDispatch:run:ok",
+          outcome: outcome2,
+          ...dispatchedSessionId ? { dispatchedSessionId } : {}
+        }
       };
     }
     if (ctx?.principal.kind === "guest") {
@@ -48162,34 +48278,65 @@ function buildPersonaDispatchHandlers(deps) {
           `persona not dispatchable: ${args.targetPersona}`
         );
       }
+      const guestSourceId = ctx.principal.id;
+      let bSessionId2;
+      let route2 = "new";
+      if (args.targetSessionId) {
+        if (!deps.findOwnedSession) {
+          throw new Error("targetSessionId reuse not wired (findOwnedSession missing)");
+        }
+        const bFile = deps.findOwnedSession(args.targetSessionId);
+        if (!bFile) {
+          throw new ClawdError(
+            ERROR_CODES.SESSION_NOT_FOUND,
+            `targetSessionId not found: ${args.targetSessionId}`
+          );
+        }
+        assertGuestReuseAllowed(bFile, guestSourceId, args.targetPersona);
+        route2 = "resume";
+        bSessionId2 = args.targetSessionId;
+      }
       const { dispatchId: dispatchId2 } = mgr.start({
-        sourceSessionId: ctx.principal.id,
-        targetPersona: args.targetPersona
+        sourceSessionId: guestSourceId,
+        targetPersona: args.targetPersona,
+        bSessionId: bSessionId2
       });
       logger?.info("dispatch.run.received.guest", {
         dispatchId: dispatchId2,
-        sourcePrincipal: ctx.principal.id,
+        sourcePrincipal: guestSourceId,
         targetPersona: args.targetPersona,
-        promptLen: args.prompt.length
+        promptLen: args.prompt.length,
+        route: route2
       });
-      void spawnB({
-        dispatchId: dispatchId2,
-        sourceSessionId: ctx.principal.id,
-        targetPersona: args.targetPersona,
-        prompt: args.prompt,
-        guestPrincipalId: ctx.principal.id,
-        guestDisplayName: ctx.principal.displayName
-      }).then(() => logger?.info("dispatch.spawnB.ok", { dispatchId: dispatchId2 })).catch((err) => {
+      let resolvedBSessionId2 = bSessionId2;
+      try {
+        const { bSessionId: minted } = await spawnB({
+          dispatchId: dispatchId2,
+          sourceSessionId: guestSourceId,
+          targetPersona: args.targetPersona,
+          prompt: args.prompt,
+          route: route2,
+          bSessionId: bSessionId2,
+          guestPrincipalId: guestSourceId,
+          guestDisplayName: ctx.principal.displayName
+        });
+        resolvedBSessionId2 = minted;
+        logger?.info("dispatch.spawnB.ok", { dispatchId: dispatchId2, route: route2 });
+      } catch (err) {
         const reason = err instanceof Error ? err.message : String(err);
-        logger?.warn("dispatch.spawnB.failed", { dispatchId: dispatchId2, reason });
+        logger?.warn("dispatch.spawnB.failed", { dispatchId: dispatchId2, route: route2, reason });
         mgr.complete(dispatchId2, {
           kind: "failure",
           reason: `failed to spawn B: ${reason}`
         });
-      });
+      }
       const outcome2 = await mgr.wait(dispatchId2);
       return {
-        response: { type: "personaDispatch:run:ok", outcome: outcome2 }
+        response: {
+          type: "personaDispatch:run:ok",
+          outcome: outcome2,
+          ...resolvedBSessionId2 ? { dispatchedSessionId: resolvedBSessionId2 } : {}
+        }
       };
     }
     if (!sourceSessionId) {
@@ -48197,31 +48344,61 @@ function buildPersonaDispatchHandlers(deps) {
         "personaDispatch:run requires sessionId (caller must pass x-clawd-session-id header)"
       );
     }
+    let bSessionId;
+    let route = "new";
+    if (args.targetSessionId) {
+      if (!deps.findOwnedSession) {
+        throw new Error("targetSessionId reuse not wired (findOwnedSession missing)");
+      }
+      const bFile = deps.findOwnedSession(args.targetSessionId);
+      if (!bFile) {
+        throw new ClawdError(
+          ERROR_CODES.SESSION_NOT_FOUND,
+          `targetSessionId not found: ${args.targetSessionId}`
+        );
+      }
+      if (bFile.ownerPersonaId !== args.targetPersona) {
+        throw new ClawdError(
+          ERROR_CODES.UNAUTHORIZED,
+          `targetSessionId does not belong to targetPersona`
+        );
+      }
+      assertLocalReuseAllowed(bFile, sourceSessionId);
+      route = "resume";
+      bSessionId = args.targetSessionId;
+    }
     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,
+      route
     });
-    void spawnB({
-      dispatchId,
-      sourceSessionId,
-      targetPersona: args.targetPersona,
-      prompt: args.prompt
-    }).then(() => {
-      logger?.info("dispatch.spawnB.ok", { dispatchId });
-    }).catch((err) => {
+    let resolvedBSessionId = bSessionId;
+    try {
+      const { bSessionId: minted } = await spawnB({
+        dispatchId,
+        sourceSessionId,
+        targetPersona: args.targetPersona,
+        prompt: args.prompt,
+        route,
+        bSessionId
+      });
+      resolvedBSessionId = minted;
+      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}`
       });
-    });
+    }
     logger?.info("dispatch.run.waiting", { dispatchId });
     const outcome = await mgr.wait(dispatchId);
     logger?.info("dispatch.run.resolved", {
@@ -48229,17 +48406,34 @@ function buildPersonaDispatchHandlers(deps) {
       outcomeKind: outcome.kind
     });
     return {
-      response: { type: "personaDispatch:run:ok", outcome }
+      response: {
+        type: "personaDispatch:run:ok",
+        outcome,
+        ...resolvedBSessionId ? { dispatchedSessionId: resolvedBSessionId } : {}
+      }
     };
   };
   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" }
     };
@@ -48269,25 +48463,37 @@ async function forwardDispatchToPeer(args) {
         authorization: `Bearer ${args.contact.connectToken}`
       },
       // 注意：不带 targetDeviceId —— B 端据此判定为本地执行（B 角色）。
-      body: JSON.stringify({ targetPersona: args.targetPersona, prompt: args.prompt })
+      // targetSessionId 透传：peer 那台机会按 creatorPrincipalId === A.deviceId 校验。
+      body: JSON.stringify({
+        targetPersona: args.targetPersona,
+        prompt: args.prompt,
+        ...args.targetSessionId ? { targetSessionId: args.targetSessionId } : {}
+      })
     });
   } catch (err) {
     const msg = err instanceof Error ? err.message : String(err);
-    return { kind: "failure", reason: `forward to peer failed: ${msg}` };
+    return { outcome: { kind: "failure", reason: `forward to peer failed: ${msg}` } };
   }
   let json;
   try {
     json = await res.json();
   } catch {
     return {
-      kind: "failure",
-      reason: `peer returned non-JSON response (HTTP ${res.status})`
+      outcome: {
+        kind: "failure",
+        reason: `peer returned non-JSON response (HTTP ${res.status})`
+      }
     };
   }
   if (json.ok === false) {
-    return { kind: "failure", reason: `peer rejected: ${json.error}: ${json.message}` };
+    return {
+      outcome: { kind: "failure", reason: `peer rejected: ${json.error}: ${json.message}` }
+    };
   }
-  return json.result.outcome;
+  return {
+    outcome: json.result.outcome,
+    dispatchedSessionId: json.result.dispatchedSessionId
+  };
 }
 async function forwardInboxPostToPeer(args) {
   const f = args.fetchImpl ?? fetch;
@@ -57625,9 +57831,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,
@@ -58009,7 +58215,8 @@ async function startDaemon(config) {
       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 && !args.guestPrincipalId) {
@@ -58028,9 +58235,23 @@ async function startDaemon(config) {
       logger.info("dispatch.spawnB.source-resolved", {
         dispatchId: args.dispatchId,
         sourceJsonlPath,
-        hasToolSessionId: Boolean(sourceFile?.toolSessionId)
+        hasToolSessionId: Boolean(sourceFile?.toolSessionId),
+        route: args.route
       });
-      manager.createDispatchedSession({
+      if (args.route === "resume") {
+        if (!args.bSessionId) {
+          throw new Error("resume route requires bSessionId");
+        }
+        const { sessionId: sessionId2 } = manager.resumeDispatchedSession({
+          dispatchId: args.dispatchId,
+          bSessionId: args.bSessionId,
+          prompt: args.prompt,
+          sourceJsonlPath,
+          callerIdentity: args.guestPrincipalId ? { kind: "guest", sourcePrincipalId: args.guestPrincipalId } : { kind: "local", sourceSessionId: args.sourceSessionId }
+        });
+        return { bSessionId: sessionId2 };
+      }
+      const { sessionId } = manager.createDispatchedSession({
         dispatchId: args.dispatchId,
         sourceSessionId: args.sourceSessionId,
         targetPersona: args.targetPersona,
@@ -58040,24 +58261,30 @@ async function startDaemon(config) {
         guestPrincipalId: args.guestPrincipalId,
         guestDisplayName: args.guestDisplayName
       });
+      return { bSessionId: sessionId };
     },
     // A 角色：从 ContactStore 取 peer 可达 URL + connect token，转发到对端 daemon /rpc。
-    forwardToPeer: async ({ targetDeviceId, targetPersona, prompt }) => {
+    forwardToPeer: async ({ targetDeviceId, targetPersona, prompt, targetSessionId }) => {
       const contact = contactStore.get(targetDeviceId);
       if (!contact || !contact.remoteUrl || !contact.connectToken) {
         return {
-          kind: "failure",
-          reason: `unknown or unreachable contact: ${targetDeviceId}`
+          outcome: {
+            kind: "failure",
+            reason: `unknown or unreachable contact: ${targetDeviceId}`
+          }
         };
       }
       return forwardDispatchToPeer({
         contact: { remoteUrl: contact.remoteUrl, connectToken: contact.connectToken },
         targetPersona,
-        prompt
+        prompt,
+        targetSessionId
       });
     },
     // B 角色：判断 targetPersona 是否 public（跨设备授权边界，private 拒）。
-    getPersonaPublic: (personaId) => personaRegistry.get(personaId)?.public ?? false
+    getPersonaPublic: (personaId) => personaRegistry.get(personaId)?.public ?? false,
+    // targetSessionId 复用路径的权限校验数据源：读 B session 的 SessionFile。
+    findOwnedSession: (sessionId) => manager.findOwnedSession(sessionId)
   });
   handlers = { ...handlers, ...dispatchHandlers };
   const shiftHandlers = buildShiftInternalHandlers({