pi-sessions 0.18.0 → 0.19.0

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 ?? "");
-}

package/extensions/session-messaging/pi/send-message-presenter.ts

@@ -5,6 +5,7 @@ import type { SendMessageViewModel } from "./send-message-view-model.ts";
 export function buildSendMessagePresentation(
   model: SendMessageViewModel,
   theme: RenderTheme,
+  toolName = "session_send_message",
 ): ExpandableContentPresentation {
   const target =
     model.status === "delivered"
@@ -18,7 +19,7 @@ export function buildSendMessagePresentation(
   const action = model.status === "delivered" ? "delivered to" : "to";
 
   return {
-    header: `${theme.fg("toolTitle", theme.bold("session_send_message"))} ${theme.fg(
+    header: `${theme.fg("toolTitle", theme.bold(toolName))} ${theme.fg(
       "muted",
       `${action} ${target}${metadataHint}`,
     )}`,

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

@@ -1,4 +1,8 @@
-import { defineTool, type ToolDefinition } from "@earendil-works/pi-coding-agent";
+import {
+  defineTool,
+  type ExtensionContext,
+  type ToolDefinition,
+} from "@earendil-works/pi-coding-agent";
 import { Text } from "@earendil-works/pi-tui";
 import { formatError } from "../../shared/errors.ts";
 import { ExpandableContentLayout } from "../../shared/rendering/expandable-content-layout.ts";
@@ -26,10 +30,11 @@ import { buildDeliveredMessageView, buildSendingMessageView } from "./send-messa
 import type { CancelSessionResult, SendMessageRequest, SendMessageResult } from "./service.ts";
 
 interface SendMessageService {
-  sendMessage(request: SendMessageRequest): Promise<SendMessageResult>;
+  sendMessage(request: SendMessageRequest, ctx: ExtensionContext): Promise<SendMessageResult>;
 }
 
-interface ManagedCancelSessionResult {
+/** A subagent's cancel goes through its parent's ledger, which reports the state it reconciled to. */
+export interface ManagedCancelSessionResult {
   kind: "managed";
   accepted: true;
   target: {
@@ -43,17 +48,15 @@ interface ManagedCancelSessionResult {
 }
 
 interface CancelSessionService {
-  cancelSession(sessionId: string): Promise<CancelSessionResult | ManagedCancelSessionResult>;
+  cancelSession(
+    sessionId: string,
+    ctx: ExtensionContext,
+  ): Promise<CancelSessionResult | ManagedCancelSessionResult>;
 }
 
-export type SessionSendMessageRole =
-  | { kind: "plain" }
-  | { kind: "wakeCapable" }
-  | { kind: "subagent" };
-
 export interface SessionSendMessageToolOptions {
-  role: SessionSendMessageRole;
-  hostedSessions?: boolean;
+  name: string;
+  wording: SendMessageToolWording;
   getCachedRelationTo(sessionId: string | undefined): string | undefined;
   /**
    * Resolved on every call: subagent identity depends on the active branch, so a rewind can
@@ -62,10 +65,9 @@ export interface SessionSendMessageToolOptions {
   getParentSessionId?: (() => string | undefined) | undefined;
 }
 
-export type SessionCancelRole = { kind: "plain" } | { kind: "subagent" };
-
 export interface SessionCancelToolOptions {
-  role: SessionCancelRole;
+  name: string;
+  wording: SendMessageToolWording;
   /**
    * Resolved on every call: subagent identity depends on the active branch, so a rewind can
    * turn a plain session into a subagent without re-registering this tool.
@@ -73,38 +75,12 @@ export interface SessionCancelToolOptions {
   getParentSessionId?: (() => string | undefined) | undefined;
 }
 
-interface SendMessageToolWording {
+export interface SendMessageToolWording {
   description: string;
   promptSnippet: string;
   promptGuidelines: string[];
 }
 
-function getSendMessageWording(role: SessionSendMessageRole): SendMessageToolWording {
-  switch (role.kind) {
-    case "plain":
-      return {
-        description: "Send a message to another live pi session.",
-        promptSnippet: "Send a message to another live pi session",
-        promptGuidelines: ["Use session_reachable to list live sessions and find the target."],
-      };
-    case "wakeCapable":
-      return {
-        description: "Send a message to another live pi session or a subagent.",
-        promptSnippet: "Send a message to another pi session or a subagent",
-        promptGuidelines: ["Use session_reachable to discover live sessions and owned subagents."],
-      };
-    case "subagent":
-      return {
-        description: "Send a message to another subagent.",
-        promptSnippet: "Send a message to another subagent",
-        promptGuidelines: [
-          "Use session_reachable to discover reachable subagents.",
-          "Report to your parent with submit_task_report; it cannot be reached with session_send_message.",
-        ],
-      };
-  }
-}
-
 interface SendMessageRendererState {
   callComponent?: ExpandableContentLayout | undefined;
 }
@@ -113,21 +89,14 @@ export function createSessionSendMessageTool(
   service: SendMessageService,
   options: SessionSendMessageToolOptions,
 ): ToolDefinition {
-  const { description, promptSnippet, promptGuidelines } = getSendMessageWording(options.role);
+  const { description, promptSnippet, promptGuidelines } = options.wording;
 
   return defineTool({
-    name: "session_send_message",
+    name: options.name,
     label: "Send Message to Session",
     description,
     promptSnippet,
-    promptGuidelines: [
-      ...promptGuidelines,
-      ...(options.hostedSessions
-        ? [
-            "session_reachable also lists dormant hosted sessions; sending a message wakes them automatically.",
-          ]
-        : []),
-    ],
+    promptGuidelines,
     parameters: SEND_MESSAGE_PARAMS,
     renderCall(args, theme, context) {
       const state = context.state as SendMessageRendererState;
@@ -137,12 +106,13 @@ export function createSessionSendMessageTool(
         buildSendMessagePresentation(
           buildSendingMessageView(args, options.getCachedRelationTo(args?.session)),
           theme,
+          options.name,
         ),
         context.expanded,
       );
       return component;
     },
-    renderResult(result, options, theme, context) {
+    renderResult(result, renderOptions, theme, context) {
       if (context.isError) {
         const output = getFirstText(result);
         return new Text(output ? `\n${theme.fg("error", output)}` : "", 0, 0);
@@ -155,29 +125,36 @@ export function createSessionSendMessageTool(
       }
 
       state.callComponent.update(
-        buildSendMessagePresentation(buildDeliveredMessageView(context.args, details), theme),
-        options.expanded,
+        buildSendMessagePresentation(
+          buildDeliveredMessageView(context.args, details),
+          theme,
+          options.name,
+        ),
+        renderOptions.expanded,
       );
       return new Text("", 0, 0);
     },
-    async execute(toolCallId, params: SendMessageParams, _signal, _onUpdate, _ctx) {
-      const target = parseSessionTarget(params.session, "session_send_message");
+    async execute(toolCallId, params: SendMessageParams, _signal, _onUpdate, ctx) {
+      const target = parseSessionTarget(params.session, options.name);
       if (target === options.getParentSessionId?.()) {
         throw new Error("The parent session cannot be messaged. Use submit_task_report.");
       }
 
       const body = params.message.trim();
       if (!body) {
-        throw new Error("session_send_message requires a non-empty message.");
+        throw new Error(`${options.name} requires a non-empty message.`);
       }
 
       try {
-        const result = await service.sendMessage({
-          target,
-          body,
-          requestResponse: params.requestResponse,
-          sourceToolCallId: toolCallId,
-        });
+        const result = await service.sendMessage(
+          {
+            target,
+            body,
+            requestResponse: params.requestResponse,
+            sourceToolCallId: toolCallId,
+          },
+          ctx,
+        );
         if (!result.delivered) {
           throw new Error(result.error ?? "Message was not delivered.");
         }
@@ -203,28 +180,14 @@ export function createSessionSendMessageTool(
   });
 }
 
-function getCancelPromptGuidelines(role: SessionCancelRole): string[] {
-  switch (role.kind) {
-    case "plain":
-      return ["Only cancel a user session when the user directs it."];
-    case "subagent":
-      return [
-        "Only cancel a user session when the user directs it.",
-        "Never cancel your parent session; it is waiting on your report.",
-      ];
-  }
-}
-
 export function createSessionCancelTool(
   service: CancelSessionService,
   options: SessionCancelToolOptions,
 ): ToolDefinition {
   return defineTool<typeof CANCEL_SESSION_PARAMS, CancelSessionToolDetails>({
-    name: "session_cancel",
+    name: options.name,
     label: "Cancel a running session",
-    description: "Cancel another running pi session",
-    promptSnippet: "Cancel another running pi session",
-    promptGuidelines: getCancelPromptGuidelines(options.role),
+    ...options.wording,
     parameters: CANCEL_SESSION_PARAMS,
     renderResult(result, options, theme, context) {
       const output = getFirstText(result);
@@ -244,14 +207,17 @@ export function createSessionCancelTool(
       }
       return new Text(text, 0, 0);
     },
-    async execute(_toolCallId, params: CancelSessionParams) {
-      const target = parseSessionTarget(params.session, "session_cancel");
+    async execute(_toolCallId, params: CancelSessionParams, _signal, _onUpdate, ctx) {
+      const target = parseSessionTarget(params.session, options.name);
       if (target === options.getParentSessionId?.()) {
         throw new Error("The parent session cannot be cancelled. It is waiting on your report.");
       }
 
-      const result = await service.cancelSession(target);
+      const result = await service.cancelSession(target, ctx);
       if (result.kind === "managed") {
+        if (!isConfirmedManagedCancellation(result.state)) {
+          throw new Error(buildUnknownCancellationError(result.target));
+        }
         const details: CancelSessionToolDetails = {
           kind: "managed",
           accepted: true,
@@ -260,16 +226,8 @@ export function createSessionCancelTool(
           ...(result.cancelId === undefined ? {} : { cancelId: result.cancelId }),
           ...(result.relation === undefined ? {} : { relation: result.relation }),
         };
-        if (!isConfirmedManagedCancellation(result.state)) {
-          throw new Error(buildUnknownCancellationError(result.target));
-        }
         return {
-          content: [
-            {
-              type: "text" as const,
-              text: buildCancelSessionModelText(details),
-            },
-          ],
+          content: [{ type: "text" as const, text: buildCancelSessionModelText(details) }],
           details,
         };
       }