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

package/dist/cli.cjs

@@ -247,6 +247,7 @@ var init_events = __esm({
     SESSION_STATUS_VALUES = [
       "idle",
       "running",
+      "running-idle",
       "stopped",
       "error",
       "observing"
@@ -5996,7 +5997,7 @@ var init_feishu_auth = __esm({
 });
 
 // ../protocol/src/dispatch.ts
-var DispatchOutcomeSchema, DispatchRunArgsSchema, DispatchRunResponseSchema, DispatchCompleteArgsSchema;
+var DispatchOutcomeSchema, DispatchRunArgsSchema, DispatchCompleteArgsSchema;
 var init_dispatch = __esm({
   "../protocol/src/dispatch.ts"() {
     "use strict";
@@ -6017,21 +6018,10 @@ 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(),
-      // 精确寻址已知 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()
+      targetDeviceId: external_exports.string().min(1).optional()
     });
     DispatchCompleteArgsSchema = external_exports.object({
+      dispatchId: external_exports.string().min(1),
       outcome: DispatchOutcomeSchema
     });
   }
@@ -41563,6 +41553,8 @@ 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;
@@ -42368,14 +42360,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 路径闭包，让 cc spawn 加 --mcp-config flag
-      // 使两侧 cc 都能看到 personaDispatch / personaDispatchComplete tool（按 session 身份分工用哪个）。
-      // dispatchId 不注 cc env——complete handler 用 sessionId 反查 in-flight dispatchId 配对。
+      // Persona dispatch：透传 dispatch.mcp.json 路径闭包 + B→dispatchId 反查闭包。
+      // 见 reducer.buildSpawnContext 注 CLAWD_DISPATCH_ID env / 派生 SpawnContext.dispatchMcpConfigPath
       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 一起删
@@ -42801,10 +42793,11 @@ function compressFrameForWire(frame) {
   switch (status) {
     case "spawning":
     case "running":
-    // sub-session（persona）专属内部状态：进程仍活着等 idle-kill；wire 协议看到的是 'running'
-    case "running-idle":
       compressed = "running";
       break;
+    case "running-idle":
+      compressed = "running-idle";
+      break;
     case "stopping":
     case "stopped":
       compressed = "stopped";
@@ -42829,8 +42822,9 @@ function compressStatus(status) {
   switch (status) {
     case "spawning":
     case "running":
-    case "running-idle":
       return "running";
+    case "running-idle":
+      return "running-idle";
     case "stopping":
     case "stopped":
       return "stopped";
@@ -42859,22 +42853,9 @@ 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: "..." }`;
-}
-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}
-
-Source conversation (jsonl, same path as before, may contain new messages):
-  ${args.sourceJsonlPath}
+  - Failure: { isFailure: true, reason: "..." }
 
-When done, call \`mcp__clawd-dispatch__personaDispatchComplete\` again with your result:
-  - Success: { text: "...", filePaths?: ["abs/path", ...] }
-  - Failure: { isFailure: true, reason: "..." }`;
+dispatchId for this task: ${args.dispatchId}`;
 }
 function derivePersonaSpawnCwd(file, personaRoot) {
   const personaId = file.ownerPersonaId;
@@ -43195,13 +43176,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: dispatch.mcp.json 路径闭包透传给 reducer，让 cc spawn 加
-      // --mcp-config flag 挂 dispatch MCP server（两侧 cc 都挂，按 session 身份分工调 tool）。
-      // dispatchId 不再走 cc env——complete handler 用 sessionId 反查 in-flight dispatchId 配对。
+      // Persona dispatch (Task 7): dispatch.mcp.json 路径 + B sessionId → dispatchId 反查
+      // 闭包透传给 reducer，让 cc spawn 加 --mcp-config flag + B session 注 CLAWD_DISPATCH_ID env.
       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,
@@ -44041,11 +44022,10 @@ var SessionManager = class {
    * Persona dispatch: 启动 B session 并投递任务包当第一条 user message。
    *
    *   - 复用 persona-owner 创建路径（cwd=personaDir、scope=persona-owner、不沙箱）
-   *   - SessionFile 上写 dispatchedFromSessionId 关联回 A（UI 折叠用；mirror 一侧 strip；
-   *     targetSessionId 复用路径也按此字段校验寻址来源）
-   *   - 跟 PersonaDispatchManager 登记 dispatchId → B sessionId（complete handler 用
-   *     findInflightDispatchByBSessionId 反查回 dispatchId 配对回 A 的 waiter）
-   *   - 投任务包；包尾教 B 用 personaDispatchComplete tool 回传
+   *   - SessionFile 上写 dispatchedFromSessionId 关联回 A（UI 折叠用；mirror 一侧 strip）
+   *   - 跟 PersonaDispatchManager 双向登记 dispatchId ↔ B sessionId，让后续 reducer
+   *     buildSpawnContext 能反查到 dispatchId 注 CLAWD_DISPATCH_ID env
+   *   - 投 inject-owner-text 任务包；包尾教 B 用 personaDispatchComplete tool 回传
    *
    * cwd 派生与 SessionManager.create 的 owner persona 路径一致（derivePersonaSpawnCwd）。
    */
@@ -44100,7 +44080,8 @@ var SessionManager = class {
     });
     const taskPack = buildDispatchTaskPack({
       prompt: args.prompt,
-      sourceJsonlPath: args.sourceJsonlPath
+      sourceJsonlPath: args.sourceJsonlPath,
+      dispatchId: args.dispatchId
     });
     runner.input({ kind: "command", command: { kind: "send", text: taskPack } });
     this.deps.logger?.info("dispatch.createDispatchedSession.task-pack-sent", {
@@ -44109,59 +44090,6 @@ 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）。
@@ -47568,7 +47496,6 @@ var PersonaDispatchManager = class {
       dispatchId,
       sourceSessionId: args.sourceSessionId,
       targetPersona: args.targetPersona,
-      bSessionId: args.bSessionId,
       waiters: [],
       outcome: null
     });
@@ -47599,22 +47526,10 @@ var PersonaDispatchManager = class {
     if (!state) throw new Error(`unknown dispatchId: ${dispatchId}`);
     state.bSessionId = 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) {
+  /** reducer buildSpawnContext 调，按 B 的 sessionId 反查 dispatchId（用于注 CLAWD_DISPATCH_ID env） */
+  lookupDispatchByBSessionId(bSessionId) {
     for (const state of this.map.values()) {
-      if (state.bSessionId === bSessionId && state.outcome === null) {
-        return state.dispatchId;
-      }
+      if (state.bSessionId === bSessionId) return state.dispatchId;
     }
     return void 0;
   }
@@ -48213,28 +48128,6 @@ 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) => {
@@ -48253,21 +48146,15 @@ function buildPersonaDispatchHandlers(deps) {
       }
       logger?.info("dispatch.run.forward", {
         targetDeviceId: args.targetDeviceId,
-        targetPersona: args.targetPersona,
-        hasTargetSessionId: Boolean(args.targetSessionId)
+        targetPersona: args.targetPersona
       });
-      const { outcome: outcome2, dispatchedSessionId } = await deps.forwardToPeer({
+      const outcome2 = await deps.forwardToPeer({
         targetDeviceId: args.targetDeviceId,
         targetPersona: args.targetPersona,
-        prompt: args.prompt,
-        targetSessionId: args.targetSessionId
+        prompt: args.prompt
       });
       return {
-        response: {
-          type: "personaDispatch:run:ok",
-          outcome: outcome2,
-          ...dispatchedSessionId ? { dispatchedSessionId } : {}
-        }
+        response: { type: "personaDispatch:run:ok", outcome: outcome2 }
       };
     }
     if (ctx?.principal.kind === "guest") {
@@ -48278,65 +48165,34 @@ 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: guestSourceId,
-        targetPersona: args.targetPersona,
-        bSessionId: bSessionId2
+        sourceSessionId: ctx.principal.id,
+        targetPersona: args.targetPersona
       });
       logger?.info("dispatch.run.received.guest", {
         dispatchId: dispatchId2,
-        sourcePrincipal: guestSourceId,
+        sourcePrincipal: ctx.principal.id,
         targetPersona: args.targetPersona,
-        promptLen: args.prompt.length,
-        route: route2
+        promptLen: args.prompt.length
       });
-      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) {
+      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) => {
         const reason = err instanceof Error ? err.message : String(err);
-        logger?.warn("dispatch.spawnB.failed", { dispatchId: dispatchId2, route: route2, reason });
+        logger?.warn("dispatch.spawnB.failed", { dispatchId: dispatchId2, 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,
-          ...resolvedBSessionId2 ? { dispatchedSessionId: resolvedBSessionId2 } : {}
-        }
+        response: { type: "personaDispatch:run:ok", outcome: outcome2 }
       };
     }
     if (!sourceSessionId) {
@@ -48344,61 +48200,31 @@ 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,
-      bSessionId
+      targetPersona: args.targetPersona
     });
     logger?.info("dispatch.run.received", {
       dispatchId,
       sourceSessionId,
       targetPersona: args.targetPersona,
-      promptLen: args.prompt.length,
-      route
+      promptLen: args.prompt.length
     });
-    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) {
+    void spawnB({
+      dispatchId,
+      sourceSessionId,
+      targetPersona: args.targetPersona,
+      prompt: args.prompt
+    }).then(() => {
+      logger?.info("dispatch.spawnB.ok", { dispatchId });
+    }).catch((err) => {
       const reason = err instanceof Error ? err.message : String(err);
-      logger?.warn("dispatch.spawnB.failed", { dispatchId, route, reason });
+      logger?.warn("dispatch.spawnB.failed", { dispatchId, 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", {
@@ -48406,34 +48232,17 @@ function buildPersonaDispatchHandlers(deps) {
       outcomeKind: outcome.kind
     });
     return {
-      response: {
-        type: "personaDispatch:run:ok",
-        outcome,
-        ...resolvedBSessionId ? { dispatchedSessionId: resolvedBSessionId } : {}
-      }
+      response: { type: "personaDispatch:run:ok", outcome }
     };
   };
   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,
-      sessionId,
+      dispatchId: args.dispatchId,
       outcomeKind: args.outcome.kind
     });
-    mgr.complete(dispatchId, args.outcome);
+    mgr.complete(args.dispatchId, args.outcome);
     return {
       response: { type: "personaDispatch:complete:ok" }
     };
@@ -48463,37 +48272,25 @@ async function forwardDispatchToPeer(args) {
         authorization: `Bearer ${args.contact.connectToken}`
       },
       // 注意：不带 targetDeviceId —— B 端据此判定为本地执行（B 角色）。
-      // targetSessionId 透传：peer 那台机会按 creatorPrincipalId === A.deviceId 校验。
-      body: JSON.stringify({
-        targetPersona: args.targetPersona,
-        prompt: args.prompt,
-        ...args.targetSessionId ? { targetSessionId: args.targetSessionId } : {}
-      })
+      body: JSON.stringify({ targetPersona: args.targetPersona, prompt: args.prompt })
     });
   } catch (err) {
     const msg = err instanceof Error ? err.message : String(err);
-    return { outcome: { kind: "failure", reason: `forward to peer failed: ${msg}` } };
+    return { kind: "failure", reason: `forward to peer failed: ${msg}` };
   }
   let json;
   try {
     json = await res.json();
   } catch {
     return {
-      outcome: {
-        kind: "failure",
-        reason: `peer returned non-JSON response (HTTP ${res.status})`
-      }
+      kind: "failure",
+      reason: `peer returned non-JSON response (HTTP ${res.status})`
     };
   }
   if (json.ok === false) {
-    return {
-      outcome: { kind: "failure", reason: `peer rejected: ${json.error}: ${json.message}` }
-    };
+    return { kind: "failure", reason: `peer rejected: ${json.error}: ${json.message}` };
   }
-  return {
-    outcome: json.result.outcome,
-    dispatchedSessionId: json.result.dispatchedSessionId
-  };
+  return json.result.outcome;
 }
 async function forwardInboxPostToPeer(args) {
   const f = args.fetchImpl ?? fetch;
@@ -57831,9 +57628,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: manager 通过这两个 deps 跟 PersonaDispatchManager 协作。
-    // - personaDispatchManager: createDispatchedSession / resumeDispatchedSession 用它
-    //   registerBSession；complete handler 用 findInflightDispatchByBSessionId 反查回 dispatchId。
+    // Persona dispatch (Task 8): manager 通过这两个 deps 跟 PersonaDispatchManager 协作。
+    // - personaDispatchManager: manager.createDispatchedSession 用它 registerBSession；
+    //   reducer 通过闭包反查 dispatchId 注 CLAWD_DISPATCH_ID env。
     // - dispatchMcpConfigPath: reducer 透传到 SpawnContext，cc spawn 加 --mcp-config flag。
     personaDispatchManager,
     dispatchMcpConfigPath: dispatchMcpConfigPath2,
@@ -58215,8 +58012,7 @@ async function startDaemon(config) {
       logger.info("dispatch.spawnB.start", {
         dispatchId: args.dispatchId,
         targetPersona: args.targetPersona,
-        sourceSessionId: args.sourceSessionId,
-        route: args.route
+        sourceSessionId: args.sourceSessionId
       });
       const sourceFile = manager.findOwnedSession(args.sourceSessionId);
       if (!sourceFile && !args.guestPrincipalId) {
@@ -58235,23 +58031,9 @@ async function startDaemon(config) {
       logger.info("dispatch.spawnB.source-resolved", {
         dispatchId: args.dispatchId,
         sourceJsonlPath,
-        hasToolSessionId: Boolean(sourceFile?.toolSessionId),
-        route: args.route
+        hasToolSessionId: Boolean(sourceFile?.toolSessionId)
       });
-      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({
+      manager.createDispatchedSession({
         dispatchId: args.dispatchId,
         sourceSessionId: args.sourceSessionId,
         targetPersona: args.targetPersona,
@@ -58261,30 +58043,24 @@ 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, targetSessionId }) => {
+    forwardToPeer: async ({ targetDeviceId, targetPersona, prompt }) => {
       const contact = contactStore.get(targetDeviceId);
       if (!contact || !contact.remoteUrl || !contact.connectToken) {
         return {
-          outcome: {
-            kind: "failure",
-            reason: `unknown or unreachable contact: ${targetDeviceId}`
-          }
+          kind: "failure",
+          reason: `unknown or unreachable contact: ${targetDeviceId}`
         };
       }
       return forwardDispatchToPeer({
         contact: { remoteUrl: contact.remoteUrl, connectToken: contact.connectToken },
         targetPersona,
-        prompt,
-        targetSessionId
+        prompt
       });
     },
     // B 角色：判断 targetPersona 是否 public（跨设备授权边界，private 拒）。
-    getPersonaPublic: (personaId) => personaRegistry.get(personaId)?.public ?? false,
-    // targetSessionId 复用路径的权限校验数据源：读 B session 的 SessionFile。
-    findOwnedSession: (sessionId) => manager.findOwnedSession(sessionId)
+    getPersonaPublic: (personaId) => personaRegistry.get(personaId)?.public ?? false
   });
   handlers = { ...handlers, ...dispatchHandlers };
   const shiftHandlers = buildShiftInternalHandlers({