pi-sessions 0.18.0 → 0.19.0

package/extensions/session-handoff/install.ts

@@ -2,7 +2,6 @@ import type { Api, Model } from "@earendil-works/pi-ai";
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import { Text } from "@earendil-works/pi-tui";
 import { Type } from "typebox";
-import type { Host } from "../hosts/contract.ts";
 import type { IndexHandle, SessionLifecycle } from "../shared/composition.ts";
 import type { ModelRuntimeProvider } from "../shared/model-runtime.ts";
 import { isTuiMode } from "../shared/pi-mode.ts";
@@ -21,11 +20,7 @@ import { HANDOFF_BOOTSTRAP_FAILED_CUSTOM_TYPE } from "./metadata.ts";
 import { openSessionReferencePicker } from "./picker.ts";
 import { SESSION_TOKEN_PREFIX } from "./query.ts";
 import { type HandoffRoster, resolveHandoffRoster } from "./roster.ts";
-import {
-  executeSessionHandoffTool,
-  type HandoffToolParams,
-  MAX_HANDOFF_TITLE_LENGTH,
-} from "./tool.ts";
+import { executeSessionHandoffTool, MAX_HANDOFF_TITLE_LENGTH } from "./tool.ts";
 import { HANDOFF_TOOL_DETAILS_SCHEMA } from "./tool-contract.ts";
 import { HandoffToolComponent } from "./tool-renderer.ts";
 import {
@@ -51,7 +46,7 @@ export function installHandoff(
     index: IndexHandle;
     getModelRuntime: ModelRuntimeProvider;
     getLaunchTargets?: (() => readonly HandoffLaunchTarget[]) | undefined;
-    getHosts?: () => readonly Host[];
+    claimsPeers: () => boolean;
     board: HandoffBoardServices;
   },
 ): SessionLifecycle {
@@ -69,16 +64,17 @@ export function installHandoff(
     models: readonly Model<Api>[],
     launchTargets: readonly HandoffLaunchTarget[],
     roster: HandoffRoster | undefined,
+    name: "session_handoff" | "subagent_launch",
   ): void {
     const offersSubagent = offersSubagentLaunch(launchTargets);
     pi.registerTool({
-      name: "session_handoff",
+      name,
       label: "Session Handoff",
       description: "Start a new Pi session with a self-contained task.",
       // Nested calls write no toolResult entry, so the board would never see the launch receipt.
       exposure: "model-only",
       promptSnippet: offersSubagent
-        ? "Delegate bounded work to a background subagent or hand off context to another Pi session"
+        ? "Delegate bounded work to a background subagent"
         : "Hand off context to another Pi session",
       promptGuidelines: buildHandoffPromptGuidelines(launchTargets, models, roster),
       parameters: Type.Object({
@@ -91,17 +87,16 @@ export function installHandoff(
           description:
             "Short display title for the child session, 64 characters or less. Summarize the mission; do not repeat the full goal.",
         }),
-        launch: buildHandoffLaunchSchema(launchTargets),
+        ...(name === "session_handoff" ? { launch: buildHandoffLaunchSchema(launchTargets) } : {}),
         cwd: Type.Optional(
           Type.String({
             description: "Optional target working directory (defaults to current).",
           }),
         ),
-        requestResponse: Type.Optional(
-          Type.Boolean({
-            description: `Whether the child session should report completion/results of its task back to this session. ${offersSubagent ? "Defaults to true for subagent launches and false otherwise." : "Defaults to false."}`,
-          }),
-        ),
+        requestResponse: Type.Boolean({
+          description:
+            "Whether the child session should report completion/results of its task back to this session.",
+        }),
         provider: Type.Optional(
           Type.String({
             description: "Model provider for the child session.",
@@ -127,7 +122,7 @@ export function installHandoff(
         const state = context.state as HandoffToolRendererState;
         const component = state.callComponent ?? new HandoffToolComponent(theme);
         state.callComponent = component;
-        component.update(buildHandoffToolView(args), context.expanded);
+        component.update(buildHandoffToolView(args, undefined, name), context.expanded);
         return component;
       },
       renderResult(result, options, theme, context) {
@@ -143,17 +138,23 @@ export function installHandoff(
         }
 
         state.callComponent.update(
-          buildHandoffToolView(context.args, details),
+          buildHandoffToolView(context.args, details, name),
           options.expanded,
           clipboardStatusBySessionId.get(details.sessionId),
         );
         return new Text("", 0, 0);
       },
-      async execute(_toolCallId, params: HandoffToolParams, _signal, _onUpdate, ctx) {
+      async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
+        if (name === "session_handoff" && deps.claimsPeers())
+          throw new Error("Peer tools belong to the current host.");
+        const launch = name === "subagent_launch" ? "subagent" : params.launch;
+        if (typeof launch !== "string") throw new Error("session_handoff requires launch.");
+        if (name === "subagent_launch" && !deps.getLaunchTargets?.().length)
+          throw new Error("Subagent launch is unavailable.");
         const modelRuntime = await deps.getModelRuntime(ctx.modelRegistry);
         return executeSessionHandoffTool(
           pi,
-          params,
+          { ...params, launch },
           ctx,
           modelRuntime,
           launchTargets,
@@ -205,7 +206,7 @@ export function installHandoff(
   });
 
   pi.on("before_agent_start", async (event, ctx) => {
-    if (!deps.getHosts?.().length && splitBackend?.identifyTerminalId && ctx) {
+    if (!deps.claimsPeers() && splitBackend?.identifyTerminalId && ctx) {
       identifiedGhosttyTerminalId =
         (await splitBackend.identifyTerminalId(ctx.cwd)) ?? identifiedGhosttyTerminalId;
     }
@@ -216,21 +217,34 @@ export function installHandoff(
   return {
     async onSessionStart(_event, ctx) {
       const models = ctx.modelRegistry.getAvailable();
-      registerHandoffTool(
+      const roster = resolveHandoffRoster({
         models,
-        createHandoffLaunchTargets({
-          pi,
-          splitBackend,
-          deferred: settings.handoff.deferred,
-          additionalTargets: deps.getLaunchTargets?.() ?? [],
-          hosts: deps.getHosts?.() ?? [],
-        }),
-        resolveHandoffRoster({
+        patterns: settings.handoff.roster,
+        scopedModels: ctx.scopedModels,
+      });
+      if (!deps.claimsPeers?.()) {
+        registerHandoffTool(
           models,
-          patterns: settings.handoff.roster,
-          scopedModels: ctx.scopedModels,
-        }),
-      );
+          createHandoffLaunchTargets({
+            pi,
+            splitBackend,
+            deferred: settings.handoff.deferred,
+            additionalTargets: [],
+          }),
+          roster,
+          "session_handoff",
+        );
+        pi.setActiveTools([...new Set([...pi.getActiveTools(), "session_handoff"])]);
+      } else {
+        pi.setActiveTools(pi.getActiveTools().filter((name) => name !== "session_handoff"));
+      }
+      const subagentTargets = deps.getLaunchTargets?.() ?? [];
+      if (subagentTargets.length) {
+        registerHandoffTool(models, subagentTargets, roster, "subagent_launch");
+        pi.setActiveTools([...new Set([...pi.getActiveTools(), "subagent_launch"])]);
+      } else {
+        pi.setActiveTools(pi.getActiveTools().filter((name) => name !== "subagent_launch"));
+      }
 
       await consumePendingHandoffBootstrap(
         pi,

package/extensions/session-handoff/launch/backend.ts

@@ -1,9 +1,21 @@
-import type { Host, HostLaunchInput } from "../../hosts/contract.ts";
-
 export type HandoffSplitDirection = "left" | "right" | "up" | "down";
 
-export type LaunchInput = HostLaunchInput;
+export interface LaunchInput {
+  sessionId: string;
+  sessionFile: string;
+  cwd: string;
+  title: string;
+  model: string;
+  resumeCommand: string;
+}
 
 export type ClipboardStatus = "copied" | "failed";
 
-export type LaunchBackend = Host;
+export interface LaunchBackend {
+  name: string;
+  launch(
+    input: LaunchInput,
+  ): Promise<
+    { success: true; clipboardStatus?: ClipboardStatus } | { success: false; error: string }
+  >;
+}

package/extensions/session-handoff/launch-options.ts

@@ -1,5 +1,4 @@
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
-import type { Host } from "../hosts/contract.ts";
 import type { HandoffSettings } from "../shared/settings.ts";
 import { createDeferredLaunchBackend } from "./launch/deferred.ts";
 import type { SplitLaunchBackend } from "./launch/resolution.ts";
@@ -21,10 +20,8 @@ export function createHandoffLaunchTargets(options: {
   splitBackend: SplitLaunchBackend | undefined;
   deferred: HandoffSettings["deferred"];
   additionalTargets: readonly HandoffLaunchTarget[];
-  hosts?: readonly Host[];
 }): HandoffLaunchTarget[] {
-  const hosts = options.hosts ?? [];
-  const splitBackend = hosts.length ? undefined : options.splitBackend;
+  const splitBackend = options.splitBackend;
   const splitTargets = splitBackend
     ? LAUNCH_DIRECTIONS.map((direction, index) =>
         createBackendLaunchTarget(
@@ -45,19 +42,7 @@ export function createHandoffLaunchTargets(options: {
         ),
       ]
     : [];
-  return [
-    ...hosts.map((host) =>
-      createBackendLaunchTarget(
-        host.name,
-        host,
-        `'${host.name}' opens a session in ${host.name}.`,
-        true,
-      ),
-    ),
-    ...splitTargets,
-    ...deferredTargets,
-    ...options.additionalTargets,
-  ];
+  return [...splitTargets, ...deferredTargets, ...options.additionalTargets];
 }
 
 export function resolveHandoffLaunchTarget(

package/extensions/session-handoff/launch-target.ts

@@ -1,8 +1,7 @@
 import type { SessionManager } from "@earendil-works/pi-coding-agent";
 import { type Static, Type } from "typebox";
-import type { Host } from "../hosts/contract.ts";
 import { formatError } from "../shared/errors.ts";
-import type { ClipboardStatus } from "./launch/backend.ts";
+import type { ClipboardStatus, LaunchBackend } from "./launch/backend.ts";
 import type { HandoffSubagent } from "./metadata.ts";
 import type { PreparedHandoff } from "./spawn.ts";
 
@@ -58,7 +57,6 @@ export type HandoffLaunchTargetOutcome =
 export interface HandoffLaunchTarget {
   value: HandoffLaunchValue;
   description?: string | undefined;
-  requestResponseDefault: boolean;
   bootstrapMode: "review" | "automatic";
   /** Unattended children skip the startup trust prompt; watched ones let the user answer it. */
   approveProjectTrust: boolean;
@@ -75,17 +73,14 @@ export interface HandoffLaunchTarget {
 
 export function createBackendLaunchTarget(
   value: string,
-  host: Host,
+  host: LaunchBackend,
   description?: string | undefined,
-  external = false,
 ): HandoffLaunchTarget {
   return {
     value,
     ...(description ? { description } : {}),
-    requestResponseDefault: false,
-    bootstrapMode: external ? "automatic" : "review",
-    approveProjectTrust: external,
-    useDefaultSessionDir: external,
+    bootstrapMode: "review",
+    approveProjectTrust: false,
     prepareChild() {},
     async launch(input) {
       try {

package/extensions/session-handoff/receipt.ts

@@ -35,7 +35,7 @@ export function parseHandoffLaunchReceiptEntry(
   if (
     entry.type === "message" &&
     entry.message.role === "toolResult" &&
-    entry.message.toolName === "session_handoff"
+    (entry.message.toolName === "session_handoff" || entry.message.toolName === "subagent_launch")
   ) {
     return safeParseTypeBoxValue(HANDOFF_LAUNCH_RECEIPT_SCHEMA, entry.message.details);
   }

package/extensions/session-handoff/tool-presenter.ts

@@ -18,7 +18,7 @@ export function buildHandoffToolPresentation(
 
   return {
     header: [
-      theme.fg("accent", "session_handoff"),
+      theme.fg("accent", model.toolName ?? "session_handoff"),
       theme.fg("dim", `[${model.launch ?? PENDING}]`),
       theme.bold(model.title ?? PENDING),
     ].join(" "),

package/extensions/session-handoff/tool-schema.ts

@@ -21,7 +21,7 @@ export function buildHandoffLaunchSchema(targets: readonly HandoffLaunchTarget[]
 }
 
 const SUBAGENT_GUIDELINES = [
-  'Use session_handoff with launch: "subagent" for a concrete, bounded task that can proceed independently while useful work continues in the current session.',
+  "Use subagent_launch for a concrete, bounded task that can proceed independently while useful work continues in the current session.",
   "Do not launch a subagent for work that is trivial, duplicates work already underway, requires frequent coordination, or is tightly coupled to the current session's immediate next step.",
   "Tell every subagent explicitly whether it may modify files or should only investigate and report.",
   "Give concurrent subagents disjoint responsibilities and non-overlapping write scopes.",
@@ -73,14 +73,6 @@ function describeUserFacingLaunchKinds(targets: readonly HandoffLaunchTarget[]):
   const isDirection = (value: string) => LAUNCH_DIRECTIONS.some((direction) => direction === value);
   const kinds = [
     targets.some((target) => isDirection(target.value)) ? "directional" : undefined,
-    targets.some(
-      (target) =>
-        target.value !== SUBAGENT_LAUNCH &&
-        target.value !== DEFERRED_LAUNCH &&
-        !isDirection(target.value),
-    )
-      ? "host"
-      : undefined,
     targets.some((target) => target.value === DEFERRED_LAUNCH) ? "deferred" : undefined,
   ];
   return kinds.filter((kind) => kind !== undefined).join(" or ");

package/extensions/session-handoff/tool-view-model.ts

@@ -4,6 +4,7 @@ import { isThinkingLevel } from "../shared/thinking-levels.ts";
 import type { HandoffToolDetails } from "./tool-contract.ts";
 
 export interface HandoffToolViewModel {
+  toolName: string;
   launch?: string | undefined;
   title?: string | undefined;
   goal?: string | undefined;
@@ -15,14 +16,17 @@ export interface HandoffToolViewModel {
 
 export function buildHandoffToolView(
   args: unknown,
-  result?: HandoffToolDetails | undefined,
+  result: HandoffToolDetails | undefined,
+  toolName: string,
 ): HandoffToolViewModel {
   const record = isRecord(args) ? args : {};
   const provider = normalizeOptionalText(result?.provider) ?? readString(record.provider);
   const model = normalizeOptionalText(result?.modelName) ?? readString(record.model);
   const thinkingLevel = result?.thinkingLevel ?? readThinkingLevel(record.thinkingLevel);
   return {
-    launch: readString(record.launch) ?? result?.launch,
+    toolName,
+    launch:
+      toolName === "subagent_launch" ? "subagent" : (readString(record.launch) ?? result?.launch),
     title: readString(record.title) ?? result?.title,
     goal: readString(record.goal),
     ...(provider ? { provider } : {}),

package/extensions/session-handoff/tool.ts

@@ -28,7 +28,7 @@ export interface HandoffToolParams {
   title: string;
   launch: HandoffLaunchValue;
   cwd?: string | undefined;
-  requestResponse?: boolean | undefined;
+  requestResponse: boolean;
   provider?: string | undefined;
   model?: string | undefined;
   thinkingLevel?: ThinkingLevel | undefined;
@@ -84,7 +84,7 @@ export async function executeSessionHandoffTool(
 
   resolveHandoffSource(ctx.sessionManager, sourceLeafId);
 
-  const requestResponse = params.requestResponse ?? target.requestResponseDefault;
+  const requestResponse = params.requestResponse;
   const provider = params.provider?.trim();
   const modelId = params.model?.trim();
   if (Boolean(provider) !== Boolean(modelId)) {

package/extensions/session-messaging/directory-list.ts

@@ -0,0 +1,115 @@
+import { type ExtensionContext, SessionManager } from "@earendil-works/pi-coding-agent";
+import { isSessionStarting } from "../session-handoff/metadata.ts";
+import { formatError } from "../shared/errors.ts";
+import {
+  getSessionById,
+  type SessionLineageRow,
+  withSessionIndex,
+} from "../shared/session-index/index.ts";
+import type {
+  ReachableSubagent,
+  ReachableUserSession,
+  SessionReachableScope,
+} from "./pi/reachable-contract.ts";
+
+/** The subagent facts the directory needs; the roster satisfies it structurally. */
+export interface ReachableSubagentEntry {
+  sessionId: string;
+  title: string;
+  goal: string;
+  cwd: string;
+  state: string;
+  depth: number;
+  onActiveBranch: boolean;
+  launchedAt: string;
+  model?: string | undefined;
+  ownerSessionId: string;
+  ownerTitle: string;
+  ownerIsCurrentSession: boolean;
+  resumeCommand: string;
+}
+
+export interface SessionReachableDeps {
+  indexPath: string;
+  listSessions(): Promise<string[]>;
+  getRelationTo(sessionId: string): string | undefined;
+  listSubagents?:
+    | ((
+        scope: Exclude<SessionReachableScope, "user">,
+      ) => Promise<readonly ReachableSubagentEntry[]>)
+    | undefined;
+  getParentSessionId?: (() => string | undefined) | undefined;
+}
+
+export async function listReachableUserSessions(
+  deps: SessionReachableDeps,
+  ctx: ExtensionContext,
+): Promise<ReachableUserSession[]> {
+  const currentSessionId = ctx.sessionManager.getSessionId();
+  let liveSessionIds: string[];
+  try {
+    liveSessionIds = await deps.listSessions();
+  } catch (error) {
+    throw new Error(`Session messaging is unavailable: ${formatError(error)}`);
+  }
+  const parentSessionId = deps.getParentSessionId?.();
+  const targetIds = [...new Set(liveSessionIds)].filter(
+    (sessionId) => sessionId !== currentSessionId && sessionId !== parentSessionId,
+  );
+  return withSessionIndex(deps.indexPath, { mode: "read", required: true }, ({ db }) => {
+    const sessions: ReachableUserSession[] = [];
+    for (const sessionId of targetIds) {
+      const row = getSessionById(db, sessionId);
+      if (row?.sessionOrigin === "subagent") continue;
+      const relation = deps.getRelationTo(sessionId);
+      sessions.push({
+        kind: "user",
+        sessionId,
+        state: row && isStartingSession(row) ? "starting" : "live",
+        ...(row?.sessionName ? { title: row.sessionName } : {}),
+        ...(row?.cwd ? { cwd: row.cwd } : {}),
+        ...(row?.modifiedAt ? { modifiedAt: row.modifiedAt } : {}),
+        ...(relation === undefined ? {} : { relation }),
+      });
+    }
+    return sessions.sort((left, right) =>
+      (right.modifiedAt ?? "").localeCompare(left.modifiedAt ?? ""),
+    );
+  });
+}
+
+export async function listReachableSubagents(
+  deps: SessionReachableDeps,
+  scope: Exclude<SessionReachableScope, "user">,
+): Promise<ReachableSubagent[]> {
+  if (!deps.listSubagents) throw new Error("Subagent roster is unavailable.");
+  try {
+    const entries = await deps.listSubagents(scope);
+    return entries.map((entry) => ({
+      kind: "subagent",
+      sessionId: entry.sessionId,
+      title: entry.title,
+      goal: entry.goal,
+      cwd: entry.cwd,
+      state: entry.state,
+      depth: entry.depth,
+      onActiveBranch: entry.onActiveBranch,
+      launchedAt: entry.launchedAt,
+      ...(entry.model === undefined ? {} : { model: entry.model }),
+      ownerSessionId: entry.ownerSessionId,
+      ownerTitle: entry.ownerTitle,
+      ownerIsCurrentSession: entry.ownerIsCurrentSession,
+      resumeCommand: entry.resumeCommand,
+    }));
+  } catch (error) {
+    throw new Error(`Subagent roster is unavailable: ${formatError(error)}`);
+  }
+}
+
+function isStartingSession(row: SessionLineageRow): boolean {
+  try {
+    return isSessionStarting(SessionManager.open(row.sessionPath).getBranch());
+  } catch {
+    return false;
+  }
+}

package/extensions/session-messaging/directory.ts

@@ -0,0 +1,114 @@
+import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { getSessionById, withSessionIndex } from "../shared/session-index/index.ts";
+import type { SubagentsHandle } from "../subagents/install.ts";
+import {
+  listReachableSubagents,
+  listReachableUserSessions,
+  type SessionReachableDeps,
+} from "./directory-list.ts";
+import type { MessagingHandle } from "./install.ts";
+import type { MessageRouter } from "./message-router.ts";
+import type { ReachableSession, SessionReachableScope } from "./pi/reachable-contract.ts";
+import type { CancelSessionResult, SendMessageRequest, SendMessageResult } from "./pi/service.ts";
+import type { ManagedCancelSessionResult } from "./pi/tools.ts";
+
+/** The addressable set, not a transport. Resolution is enforced before every mutation. */
+export interface SessionDirectory {
+  list(scope: SessionReachableScope, ctx: ExtensionContext): Promise<ReachableSession[]>;
+  resolve(sessionId: string, ctx: ExtensionContext): Promise<{ sessionId: string }>;
+  send(request: SendMessageRequest, ctx: ExtensionContext): Promise<SendMessageResult>;
+  cancel(
+    sessionId: string,
+    ctx: ExtensionContext,
+  ): Promise<CancelSessionResult | ManagedCancelSessionResult>;
+  wake(sessionId: string): Promise<void>;
+  getRelationTo(sessionId: string | undefined): string | undefined;
+  getParentSessionId(): string | undefined;
+}
+
+export function createPeerDirectory(
+  messaging: MessagingHandle,
+  deps: SessionReachableDeps,
+): SessionDirectory {
+  const directory: SessionDirectory = {
+    list: (scope, ctx) => {
+      if (scope !== "user") throw new Error("Peer discovery has no subagent scope.");
+      return listReachableUserSessions(deps, ctx);
+    },
+    async resolve(sessionId, ctx) {
+      const target = (await directory.list("user", ctx)).find(
+        (entry) => entry.sessionId === sessionId,
+      );
+      if (!target) throw new Error(`No reachable user session: ${sessionId}`);
+      return target;
+    },
+    async send(request, ctx) {
+      await directory.resolve(request.target, ctx);
+      return messaging.sendMessage(request);
+    },
+    async cancel(sessionId, ctx) {
+      await directory.resolve(sessionId, ctx);
+      return messaging.cancelSession(sessionId);
+    },
+    async wake() {
+      throw new Error("Peer sessions must already be live.");
+    },
+    getRelationTo: messaging.getCachedRelationTo,
+    getParentSessionId: () => deps.getParentSessionId?.(),
+  };
+  return directory;
+}
+
+export function createSubagentDirectory(
+  subagents: SubagentsHandle,
+  router: MessageRouter,
+  messaging: MessagingHandle,
+  indexPath: string,
+): SessionDirectory {
+  const deps: SessionReachableDeps = {
+    indexPath,
+    listSessions: () => messaging.listSessions(),
+    getRelationTo: messaging.getCachedRelationTo,
+    listSubagents: async (scope) => (await subagents.roster.resolve(scope)).entries,
+  };
+  const directory: SessionDirectory = {
+    list: (scope) => {
+      if (scope === "user") throw new Error("Subagent discovery requires branch or tree scope.");
+      return listReachableSubagents(deps, scope);
+    },
+    async resolve(sessionId, ctx) {
+      if (sessionId === subagents.getParentSessionId())
+        throw new Error("The parent session is not addressable. Use submit_task_report.");
+      if (sessionId === ctx.sessionManager.getSessionId())
+        throw new Error("The current session is not a subagent target.");
+      const target = (await directory.list("tree", ctx)).find(
+        (entry) => entry.sessionId === sessionId,
+      );
+      if (target) return target;
+      // Known live workers (including siblings) remain addressable without transferring
+      // ownership. Only the caller's own ledger can authorize dormant wake or teardown.
+      const live = (await messaging.listSessions()).includes(sessionId);
+      const worker =
+        live &&
+        withSessionIndex(
+          indexPath,
+          { mode: "read", required: true },
+          ({ db }) => getSessionById(db, sessionId)?.sessionOrigin === "subagent",
+        );
+      if (worker) return { sessionId };
+      throw new Error(`No reachable subagent: ${sessionId}`);
+    },
+    async send(request, ctx) {
+      await directory.resolve(request.target, ctx);
+      return router.sendMessage(request);
+    },
+    async cancel(sessionId, ctx) {
+      await directory.resolve(sessionId, ctx);
+      return subagents.cancelSession(sessionId);
+    },
+    wake: (sessionId) => subagents.waker.wake(sessionId),
+    getRelationTo: messaging.getCachedRelationTo,
+    getParentSessionId: () => subagents.getParentSessionId(),
+  };
+  return directory;
+}

package/extensions/session-messaging/message-router.ts

@@ -18,7 +18,7 @@ export class MessageRouter {
 
   constructor(
     private readonly messaging: WakeMessaging,
-    private readonly wakers: readonly SessionWaker[],
+    private readonly getWaker: () => SessionWaker | undefined,
     private readonly getEpoch: () => number,
     private readonly readyTimeoutMs = 30_000,
   ) {}
@@ -32,13 +32,8 @@ export class MessageRouter {
       if (!isTargetDeparture(result)) return result;
       failedLiveSend = result;
     }
-    let owner: SessionWaker | undefined;
-    for (const waker of this.wakers) {
-      if (await waker.owns(request.target)) {
-        owner = waker;
-        break;
-      }
-    }
+    const waker = this.getWaker();
+    const owner = waker && (await waker.owns(request.target)) ? waker : undefined;
     this.requireCurrent(epoch);
     if (!owner) return failedLiveSend ?? this.messaging.sendMessage(request);
 

package/extensions/session-messaging/pi/directory-tools.ts

@@ -0,0 +1,41 @@
+import type { ToolDefinition } from "@earendil-works/pi-coding-agent";
+import type { SessionDirectory } from "../directory.ts";
+import { createSessionReachableTool, type ReachableToolOptions } from "./reachable-tool.ts";
+import {
+  createSessionCancelTool,
+  createSessionSendMessageTool,
+  type SendMessageToolWording,
+} from "./tools.ts";
+
+export interface DirectoryToolWording {
+  list: ReachableToolOptions;
+  send: SendMessageToolWording & { name: string };
+  cancel: SendMessageToolWording & { name: string };
+}
+
+/** Both public tool sets share execution, validation and native rendering. */
+export function createDirectoryTools(
+  directory: SessionDirectory,
+  wording: DirectoryToolWording,
+): ToolDefinition[] {
+  return [
+    createSessionReachableTool(directory, wording.list),
+    createSessionSendMessageTool(
+      { sendMessage: directory.send },
+      {
+        name: wording.send.name,
+        wording: wording.send,
+        getCachedRelationTo: directory.getRelationTo,
+        getParentSessionId: directory.getParentSessionId,
+      },
+    ),
+    createSessionCancelTool(
+      { cancelSession: directory.cancel },
+      {
+        name: wording.cancel.name,
+        wording: wording.cancel,
+        getParentSessionId: directory.getParentSessionId,
+      },
+    ),
+  ];
+}