pi-sessions 0.18.1 → 0.20.0

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,
+      },
+    ),
+  ];
+}

package/extensions/session-messaging/pi/install.ts

@@ -0,0 +1,102 @@
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import type { SessionDirectory } from "../directory.ts";
+import { createDirectoryTools } from "./directory-tools.ts";
+import { SESSION_REACHABLE_PARAMS, SESSION_REACHABLE_USER_PARAMS } from "./reachable-contract.ts";
+
+export function installDirectoryTools(
+  pi: ExtensionAPI,
+  deps: {
+    peers: SessionDirectory;
+    subagents?: SessionDirectory;
+    claimsPeers(): boolean;
+  },
+): { refresh(): void } {
+  const ownedPeerNames = new Set<string>();
+  const refresh = (): void => {
+    const parentSessionId = deps.peers.getParentSessionId();
+    if (deps.claimsPeers()) {
+      // Pi has no unregisterTool. Remove only definitions we installed from the model's
+      // loadout, not a host's load-time tools. Retained definitions are execution-guarded.
+      pi.setActiveTools(pi.getActiveTools().filter((name) => !ownedPeerNames.has(name)));
+    } else {
+      const tools = createDirectoryTools(deps.peers, {
+        list: {
+          name: "session_reachable",
+          description: "List live user-facing Pi sessions.",
+          promptSnippet: "Find live peer sessions",
+          promptGuidelines: [],
+          parameters: SESSION_REACHABLE_USER_PARAMS,
+          defaultScope: "user",
+        },
+        send: {
+          name: "session_send_message",
+          description: "Send a message to another live Pi session.",
+          promptSnippet: "Message a live peer",
+          promptGuidelines: [
+            "Use session_reachable to find the target.",
+            ...(parentSessionId
+              ? ["Report to your parent with submit_task_report, never peer messaging."]
+              : []),
+          ],
+        },
+        cancel: {
+          name: "session_cancel",
+          description: "Cancel another live Pi session's turn.",
+          promptSnippet: "Cancel a peer turn",
+          promptGuidelines: [
+            "Only cancel a user session when the user directs it.",
+            ...(parentSessionId ? ["Never cancel your parent session."] : []),
+          ],
+        },
+      });
+      for (const tool of tools) {
+        ownedPeerNames.add(tool.name);
+        pi.registerTool({
+          ...tool,
+          execute: async (...args) => {
+            if (deps.claimsPeers()) throw new Error("Peer tools belong to the current host.");
+            return tool.execute(...args);
+          },
+        });
+      }
+      pi.setActiveTools([...new Set([...pi.getActiveTools(), ...ownedPeerNames])]);
+    }
+    if (deps.subagents) {
+      const tools = createDirectoryTools(deps.subagents, {
+        list: {
+          name: "subagent_list",
+          description: "List owned subagents in the branch or tree.",
+          promptSnippet: "Find delegated subagents",
+          promptGuidelines: [],
+          parameters: SESSION_REACHABLE_PARAMS,
+          defaultScope: "branch",
+        },
+        send: {
+          name: "subagent_send",
+          description: parentSessionId
+            ? "Send a message to another subagent; dormant owned workers wake automatically."
+            : "Send a message to a subagent; dormant owned workers wake automatically.",
+          promptSnippet: "Steer or follow up with a subagent",
+          promptGuidelines: [
+            "Use subagent_list to find the target.",
+            ...(parentSessionId
+              ? ["Report to your parent with submit_task_report, not subagent_send."]
+              : []),
+          ],
+        },
+        cancel: {
+          name: "subagent_cancel",
+          description: "Stop a subagent.",
+          promptSnippet: "Cancel delegated work",
+          promptGuidelines: parentSessionId
+            ? ["Never cancel your parent session; it is waiting on your report."]
+            : [],
+        },
+      });
+      for (const tool of tools) pi.registerTool(tool);
+      pi.setActiveTools([...new Set([...pi.getActiveTools(), ...tools.map((tool) => tool.name)])]);
+    }
+  };
+  pi.on("session_tree", refresh);
+  return { refresh };
+}

package/extensions/session-messaging/pi/message-contracts.ts

@@ -11,12 +11,10 @@ export const SEND_MESSAGE_PARAMS = Type.Object({
   message: Type.String({
     description: "Message to send to the target session.",
   }),
-  requestResponse: Type.Optional(
-    Type.Boolean({
-      description:
-        "Whether the target session should respond with completion/results back to this session.",
-    }),
-  ),
+  requestResponse: Type.Boolean({
+    description:
+      "Whether the target session should respond with completion/results back to this session.",
+  }),
 });
 
 export const SEND_MESSAGE_TOOL_DETAILS_SCHEMA = Type.Object({

package/extensions/session-messaging/pi/reachable-contract.ts

@@ -9,9 +9,9 @@ const SCOPE_SCHEMA = Type.Union([
 /** Registered when subagents are active; the roster is what makes branch/tree answerable. */
 export const SESSION_REACHABLE_PARAMS = Type.Object({
   scope: Type.Optional(
-    Type.Union([Type.Literal("user"), Type.Literal("branch"), Type.Literal("tree")], {
+    Type.Union([Type.Literal("branch"), Type.Literal("tree")], {
       description:
-        'Which sessions to list: "user" for live user-facing sessions, "branch" for subagents launched from the active conversation branch, "tree" for subagents launched anywhere in this session\'s conversation tree. Defaults to "user".',
+        '"branch" lists subagents from the active conversation branch; "tree" lists subagents anywhere in this session\'s conversation tree. Defaults to "branch".',
     }),
   ),
 });
@@ -26,8 +26,7 @@ const REACHABLE_USER_SESSION_SCHEMA = Type.Object({
   cwd: Type.Optional(Type.String()),
   modifiedAt: Type.Optional(Type.String()),
   relation: Type.Optional(Type.String()),
-  host: Type.Optional(Type.String()),
-  state: Type.Union([Type.Literal("live"), Type.Literal("starting"), Type.Literal("dormant")]),
+  state: Type.Union([Type.Literal("live"), Type.Literal("starting")]),
 });
 
 const REACHABLE_SUBAGENT_SCHEMA = Type.Object({

package/extensions/session-messaging/pi/reachable-tool.ts

@@ -1,26 +1,12 @@
-import {
-  defineTool,
-  type ExtensionContext,
-  SessionManager,
-  type ToolDefinition,
-} from "@earendil-works/pi-coding-agent";
+import { defineTool, type ToolDefinition } from "@earendil-works/pi-coding-agent";
 import { Text } from "@earendil-works/pi-tui";
-import type { HostedSession } from "../../hosts/contract.ts";
-import { isSessionStarting } from "../../session-handoff/metadata.ts";
-import { formatError } from "../../shared/errors.ts";
 import { ExpandableContentLayout } from "../../shared/rendering/expandable-content-layout.ts";
-import {
-  getSessionById,
-  type SessionLineageRow,
-  withSessionIndex,
-} from "../../shared/session-index/index.ts";
 import { safeParseTypeBoxValue } from "../../shared/typebox.ts";
+import type { SessionDirectory } from "../directory.ts";
 import {
-  type ReachableSubagent,
-  type ReachableUserSession,
-  SESSION_REACHABLE_PARAMS,
+  type SESSION_REACHABLE_PARAMS,
   SESSION_REACHABLE_TOOL_DETAILS_SCHEMA,
-  SESSION_REACHABLE_USER_PARAMS,
+  type SESSION_REACHABLE_USER_PARAMS,
   type SessionReachableParams,
   type SessionReachableScope,
   type SessionReachableToolDetails,
@@ -28,76 +14,37 @@ import {
 import { buildSessionReachablePresentation } from "./reachable-presenter.ts";
 import { buildSessionReachableView } from "./reachable-view-model.ts";
 
-/** The subagent facts this tool 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;
-  hostedSessions?: boolean;
-  listSessions(): Promise<string[]>;
-  listHostedSessions?: () => Promise<HostedSession[]>;
-  getRelationTo(sessionId: string): string | undefined;
-  listSubagents?:
-    | ((
-        scope: Exclude<SessionReachableScope, "user">,
-      ) => Promise<readonly ReachableSubagentEntry[]>)
-    | undefined;
-  /** Resolved per call; the parent is unreachable from a subagent, so it stays off the menu. */
-  getParentSessionId?: (() => string | undefined) | undefined;
-}
-
 interface SessionReachableRendererState {
   layout?: ExpandableContentLayout | undefined;
 }
 
-export function createSessionReachableTool(deps: SessionReachableDeps): ToolDefinition {
-  const subagentsAvailable = Boolean(deps.listSubagents);
+export interface ReachableToolOptions {
+  name: string;
+  description: string;
+  promptSnippet: string;
+  promptGuidelines: string[];
+  parameters: typeof SESSION_REACHABLE_PARAMS | typeof SESSION_REACHABLE_USER_PARAMS;
+  defaultScope: SessionReachableScope;
+}
 
+export function createSessionReachableTool(
+  directory: SessionDirectory,
+  options: ReachableToolOptions,
+): ToolDefinition {
   return defineTool({
-    name: "session_reachable",
+    name: options.name,
     label: "Reachable Sessions",
-    description: subagentsAvailable
-      ? "List the sessions this session can address: live user sessions, or its own subagents."
-      : "List the live user sessions this session can address.",
-    promptSnippet: subagentsAvailable
-      ? "List addressable live sessions and owned subagents"
-      : "List addressable live sessions",
-    promptGuidelines: [
-      "Before session_send_message, use session_reachable to find the target session id.",
-      ...(deps.hostedSessions
-        ? [
-            "User sessions include dormant hosted sessions. session_send_message wakes them automatically; the host field identifies their host.",
-          ]
-        : []),
-    ],
+    description: options.description,
+    promptSnippet: options.promptSnippet,
+    promptGuidelines: options.promptGuidelines,
     annotations: { readOnlyHint: true, openWorldHint: false },
-    parameters: subagentsAvailable ? SESSION_REACHABLE_PARAMS : SESSION_REACHABLE_USER_PARAMS,
+    parameters: options.parameters,
     outputSchema: SESSION_REACHABLE_TOOL_DETAILS_SCHEMA,
     renderResult(result, options, theme, context) {
       const output = result.content.find((item) => item.type === "text")?.text ?? "";
-      if (context.isError) {
-        return new Text(output ? theme.fg("error", output) : "", 0, 0);
-      }
-
+      if (context.isError) return new Text(output ? theme.fg("error", output) : "", 0, 0);
       const details = safeParseTypeBoxValue(SESSION_REACHABLE_TOOL_DETAILS_SCHEMA, result.details);
-      if (!details) {
-        return new Text(output, 0, 0);
-      }
-
+      if (!details) return new Text(output, 0, 0);
       const state = context.state as SessionReachableRendererState;
       const layout = state.layout ?? new ExpandableContentLayout(theme);
       state.layout = layout;
@@ -108,12 +55,8 @@ export function createSessionReachableTool(deps: SessionReachableDeps): ToolDefi
       return layout;
     },
     async execute(_toolCallId, params: SessionReachableParams, _signal, _onUpdate, ctx) {
-      const scope = params.scope ?? "user";
-      const sessions =
-        scope === "user"
-          ? await listReachableUserSessions(deps, ctx)
-          : await listReachableSubagents(deps, scope);
-
+      const scope = params.scope ?? options.defaultScope;
+      const sessions = await directory.list(scope, ctx);
       const details: SessionReachableToolDetails = { scope, sessions };
       return {
         content: [{ type: "text" as const, text: JSON.stringify(details, null, 2) }],
@@ -123,96 +66,3 @@ export function createSessionReachableTool(deps: SessionReachableDeps): ToolDefi
     },
   });
 }
-
-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 hostedSessions = new Map(
-    ((await deps.listHostedSessions?.()) ?? []).map((session) => [session.sessionId, session]),
-  );
-  const liveIds = new Set(liveSessionIds);
-  const targetIds = [...new Set([...liveSessionIds, ...hostedSessions.keys()])].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);
-      const hosted = hostedSessions.get(sessionId);
-      const title = hosted?.title ?? row?.sessionName;
-      const cwd = hosted?.cwd ?? row?.cwd;
-      sessions.push({
-        kind: "user",
-        sessionId,
-        state: !liveIds.has(sessionId)
-          ? "dormant"
-          : row && isStartingSession(row)
-            ? "starting"
-            : "live",
-        ...(hosted ? { host: hosted.host } : {}),
-        ...(title ? { title } : {}),
-        ...(cwd ? { cwd } : {}),
-        ...(row?.modifiedAt ? { modifiedAt: row.modifiedAt } : {}),
-        ...(relation === undefined ? {} : { relation }),
-      });
-    }
-    return sessions.sort(compareByModifiedDesc);
-  });
-}
-
-async function listReachableSubagents(
-  deps: SessionReachableDeps,
-  scope: Exclude<SessionReachableScope, "user">,
-): Promise<ReachableSubagent[]> {
-  if (!deps.listSubagents) {
-    throw new Error(`session_reachable scope "${scope}" requires subagents to be active.`);
-  }
-
-  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;
-  }
-}
-
-function compareByModifiedDesc(left: ReachableUserSession, right: ReachableUserSession): number {
-  return (right.modifiedAt ?? "").localeCompare(left.modifiedAt ?? "");
-}