pi-sessions 0.8.0 → 0.9.0

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

@@ -1,51 +1,119 @@
-import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { defineTool, type ToolDefinition } from "@earendil-works/pi-coding-agent";
 import { Text } from "@earendil-works/pi-tui";
-import { SEND_MESSAGE_PARAMS, type SendMessageParams } from "./message-contracts.ts";
-import { formatSendMessageCall } from "./message-view.ts";
-import type { SessionMessagingService } from "./service.ts";
-
-export function registerSessionMessagingTools(
-  pi: ExtensionAPI,
-  service: SessionMessagingService,
-): void {
-  pi.registerTool({
+import { formatError } from "../../shared/errors.ts";
+import { ExpandableContentLayout } from "../../shared/rendering/expandable-content-layout.ts";
+import { safeParseTypeBoxValue } from "../../shared/typebox.ts";
+import {
+  buildCancelSessionModelText,
+  buildCancelSessionUserError,
+  buildCancelSessionUserText,
+  buildDeadSessionError,
+  buildUnknownCancellationError,
+  isConfirmedManagedCancellation,
+} from "./cancel-session-presenter.ts";
+import {
+  CANCEL_SESSION_PARAMS,
+  CANCEL_SESSION_TOOL_DETAILS_SCHEMA,
+  type CancelSessionParams,
+  type CancelSessionToolDetails,
+  SEND_MESSAGE_PARAMS,
+  SEND_MESSAGE_TOOL_DETAILS_SCHEMA,
+  type SendMessageParams,
+  type SendMessageToolDetails,
+} from "./message-contracts.ts";
+import { buildSendMessagePresentation } from "./send-message-presenter.ts";
+import { buildDeliveredMessageView, buildSendingMessageView } from "./send-message-view-model.ts";
+import type { CancelSessionResult, SendMessageRequest, SendMessageResult } from "./service.ts";
+
+interface SendMessageService {
+  sendMessage(request: SendMessageRequest): Promise<SendMessageResult>;
+}
+
+interface ManagedCancelSessionResult {
+  kind: "managed";
+  accepted: true;
+  target: {
+    sessionId: string;
+    sessionName?: string;
+    cwd?: string;
+  };
+  state: string;
+  cancelId?: string;
+  relation?: string;
+}
+
+interface CancelSessionService {
+  cancelSession(sessionId: string): Promise<CancelSessionResult | ManagedCancelSessionResult>;
+}
+
+export interface SessionSendMessageToolOptions {
+  wakeCapable: boolean;
+  getCachedRelationTo(sessionId: string | undefined): string | undefined;
+}
+
+interface SendMessageRendererState {
+  callComponent?: ExpandableContentLayout | undefined;
+}
+
+export function createSessionSendMessageTool(
+  service: SendMessageService,
+  options: SessionSendMessageToolOptions,
+): ToolDefinition {
+  const description = options.wakeCapable
+    ? "Send a message to another live pi session or a subagent."
+    : "Send a message to another live pi session.";
+  const promptSnippet = options.wakeCapable
+    ? "Send a message to another pi session or a subagent"
+    : "Send a message to another live pi session";
+  const promptGuidelines = options.wakeCapable
+    ? [
+        "Use session_search with live: true to discover live sessions.",
+        "It is always possible to session_send_message to an owned subagent",
+      ]
+    : [
+        "Before session_send_message, use session_search with live: true to list all live sessions and find the target.",
+      ];
+
+  return defineTool({
     name: "session_send_message",
     label: "Send Message to Session",
-    description: "Send a message to another live pi session",
-    promptSnippet: "Send a message to another live pi session",
-    promptGuidelines: [
-      "Before session_send_message, use session_search with live: true (no other filters) to list all live sessions and find the target.",
-    ],
+    description,
+    promptSnippet,
+    promptGuidelines,
     parameters: SEND_MESSAGE_PARAMS,
     renderCall(args, theme, context) {
-      const component = (context.lastComponent as Text | undefined) ?? new Text("", 0, 0);
-      component.setText(
-        formatSendMessageCall(
-          args,
-          context.expanded,
-          "sending",
+      const state = context.state as SendMessageRendererState;
+      const component = state.callComponent ?? new ExpandableContentLayout(theme);
+      state.callComponent = component;
+      component.update(
+        buildSendMessagePresentation(
+          buildSendingMessageView(args, options.getCachedRelationTo(args?.session)),
           theme,
-          service.getCachedRelationTo(args?.session),
         ),
+        context.expanded,
       );
       return component;
     },
-    renderResult(result, _options, theme, context) {
-      if (!context.isError) {
-        return new Text("", 0, 0);
+    renderResult(result, options, theme, context) {
+      if (context.isError) {
+        const output = getFirstText(result);
+        return new Text(output ? `\n${theme.fg("error", output)}` : "", 0, 0);
       }
 
-      const output = getFirstText(result);
-      return new Text(output ? `\n${theme.fg("error", output)}` : "", 0, 0);
+      const details = safeParseTypeBoxValue(SEND_MESSAGE_TOOL_DETAILS_SCHEMA, result.details);
+      const state = context.state as SendMessageRendererState;
+      if (!details || !state.callComponent) {
+        return new Text(getFirstText(result), 0, 0);
+      }
+
+      state.callComponent.update(
+        buildSendMessagePresentation(buildDeliveredMessageView(context.args, details), theme),
+        options.expanded,
+      );
+      return new Text("", 0, 0);
     },
     async execute(toolCallId, params: SendMessageParams, _signal, _onUpdate, _ctx) {
-      const target = params.session.trim();
-      if (!target) {
-        throw new Error("session_send_message requires a target session id.");
-      }
-      if (target.startsWith("@session:")) {
-        throw new Error("Use the bare session UUID, not an @session token.");
-      }
+      const target = parseSessionTarget(params.session, "session_send_message");
 
       const body = params.message.trim();
       if (!body) {
@@ -73,8 +141,9 @@ export function registerSessionMessagingTools(
           details: {
             delivered: true,
             messageId: result.messageId,
-            targetSessionId: target,
-          },
+            target: result.target,
+            ...(result.relation === undefined ? {} : { relation: result.relation }),
+          } satisfies SendMessageToolDetails,
         };
       } catch (error) {
         throw new Error(formatError(error));
@@ -83,10 +152,85 @@ export function registerSessionMessagingTools(
   });
 }
 
-function getFirstText(result: { content: Array<{ type: string; text?: string }> }): string {
-  return result.content.find((item) => item.type === "text")?.text ?? "";
+export function createSessionCancelTool(service: CancelSessionService): ToolDefinition {
+  return defineTool<typeof CANCEL_SESSION_PARAMS, CancelSessionToolDetails>({
+    name: "session_cancel",
+    label: "Cancel a running session",
+    description: "Cancel another running pi session",
+    promptSnippet: "Cancel another running pi session",
+    promptGuidelines: ["Only cancel a user session when the user directs it."],
+    parameters: CANCEL_SESSION_PARAMS,
+    renderResult(result, options, theme, context) {
+      const output = getFirstText(result);
+      if (context.isError) {
+        const error = buildCancelSessionUserError(output, options.expanded);
+        return new Text(error ? theme.fg("error", error) : "", 0, 0);
+      }
+
+      const details = safeParseTypeBoxValue(CANCEL_SESSION_TOOL_DETAILS_SCHEMA, result.details);
+      if (!details) {
+        return new Text(output, 0, 0);
+      }
+
+      let text = theme.fg("toolOutput", buildCancelSessionUserText(details));
+      if (options.expanded && details.target.sessionName) {
+        text += `\n${theme.fg("dim", `${theme.bold("session")} ${details.target.sessionId}`)}`;
+      }
+      return new Text(text, 0, 0);
+    },
+    async execute(_toolCallId, params: CancelSessionParams) {
+      const target = parseSessionTarget(params.session, "session_cancel");
+      const result = await service.cancelSession(target);
+      if (result.kind === "managed") {
+        const details: CancelSessionToolDetails = {
+          kind: "managed",
+          accepted: true,
+          target: result.target,
+          state: result.state,
+          ...(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) }],
+          details,
+        };
+      }
+      if (!result.delivered) {
+        if (result.reason === "no_session") {
+          throw new Error(buildDeadSessionError(target));
+        }
+        throw new Error(result.error ?? "Cancellation was not delivered.");
+      }
+
+      const details: CancelSessionToolDetails = {
+        kind: "transport",
+        delivered: true,
+        cancelId: result.cancelId,
+        target: result.target,
+        ...(result.relation === undefined ? {} : { relation: result.relation }),
+      };
+      return {
+        content: [{ type: "text" as const, text: buildCancelSessionModelText(details) }],
+        details,
+      };
+    },
+  });
+}
+
+function parseSessionTarget(raw: string, toolName: string): string {
+  const target = raw.trim();
+  if (!target) {
+    throw new Error(`${toolName} requires a target session id.`);
+  }
+  if (target.startsWith("@session:")) {
+    throw new Error("Use the bare session UUID, not an @session token.");
+  }
+  return target;
 }
 
-function formatError(error: unknown): string {
-  return error instanceof Error && error.message.trim() ? error.message : String(error);
+function getFirstText(result: { content: Array<{ type: string; text?: string }> }): string {
+  return result.content.find((item) => item.type === "text")?.text ?? "";
 }

package/extensions/session-search/extract.ts

@@ -26,6 +26,7 @@ import {
 import type { SessionOrigin } from "../shared/session-index/index.ts";
 import { contentToText, isRecord } from "../shared/text.ts";
 import { safeParseTypeBoxValue } from "../shared/typebox.ts";
+import { SUBAGENT_LAUNCHED_CUSTOM_TYPE, SUBAGENT_LAUNCHED_SCHEMA } from "../subagents/ledger.ts";
 import {
   deriveSessionRepoRoots,
   type FileTouchOp,
@@ -78,7 +79,6 @@ export interface ExtractedSessionRecord {
   parentSessionId?: string | undefined;
   sessionOrigin?: SessionOrigin | undefined;
   handoffGoal?: string | undefined;
-  handoffNextTask?: string | undefined;
   indexedFileSize: number;
   indexedFileMtimeMs: number;
   indexedFileAnchor: string;
@@ -181,6 +181,9 @@ export function extractSessionRecord(sessionPath: string): ExtractedSessionRecor
   appendDurableHandoffMetadataChunks(chunks, scan.handoffMetadata);
 
   const parentSessionPath = normalizeParentSessionPath(parsed.header.parentSession);
+  const parentSession = parentSessionPath
+    ? inspectParentSession(parentSessionPath, parsed.header.id, sessionPath)
+    : undefined;
 
   return {
     sessionId: parsed.header.id,
@@ -194,10 +197,13 @@ export function extractSessionRecord(sessionPath: string): ExtractedSessionRecor
     messageCount: scan.messageCount,
     entryCount: scan.entryCount,
     parentSessionPath,
-    parentSessionId: parentSessionPath ? readSessionIdFromPath(parentSessionPath) : undefined,
-    sessionOrigin: inferSessionOrigin(parentSessionPath, scan.handoffMetadata?.metadata),
+    parentSessionId: parentSession?.sessionId,
+    sessionOrigin: deriveSessionOrigin(
+      parentSessionPath,
+      parentSession?.launchedSubagent ?? false,
+      scan.handoffMetadata?.metadata,
+    ),
     handoffGoal: scan.handoffMetadata?.metadata.goal,
-    handoffNextTask: scan.handoffMetadata?.metadata.nextTask,
     indexedFileSize: slice.consumedBytes,
     indexedFileMtimeMs,
     indexedFileAnchor: buildFileAnchor(buffer, slice.consumedBytes),
@@ -429,7 +435,7 @@ export function parseSessionContent(raw: string): ParsedSessionFile | undefined
   }
 
   const header = fileEntries[0];
-  if (!header || header.type !== "session") {
+  if (header?.type !== "session") {
     return undefined;
   }
 
@@ -458,23 +464,66 @@ function normalizeParentSessionPath(parentSession: string | undefined): string |
   return trimmed.length > 0 ? trimmed : undefined;
 }
 
-function readSessionIdFromPath(sessionPath: string): string | undefined {
+interface ParentSessionInspection {
+  sessionId: string;
+  launchedSubagent: boolean;
+}
+
+export function inferSessionOrigin(
+  sessionId: string,
+  sessionPath: string,
+  parentSessionPath: string | undefined,
+  handoffMetadata: HandoffSessionMetadata | undefined,
+): SessionOrigin | undefined {
+  const parentSession = parentSessionPath
+    ? inspectParentSession(parentSessionPath, sessionId, sessionPath)
+    : undefined;
+  return deriveSessionOrigin(
+    parentSessionPath,
+    parentSession?.launchedSubagent ?? false,
+    handoffMetadata,
+  );
+}
+
+function inspectParentSession(
+  parentSessionPath: string,
+  childSessionId: string,
+  childSessionPath: string,
+): ParentSessionInspection | undefined {
   try {
-    const parsed = parseSessionFile(sessionPath);
-    return parsed?.header.id;
+    const parent = parseSessionFile(parentSessionPath);
+    if (!parent) {
+      return undefined;
+    }
+
+    const launchedSubagent = parent.entries.some((entry) => {
+      if (entry.type !== "custom" || entry.customType !== SUBAGENT_LAUNCHED_CUSTOM_TYPE) {
+        return false;
+      }
+      const launch = safeParseTypeBoxValue(SUBAGENT_LAUNCHED_SCHEMA, entry.data);
+      return (
+        launch?.writerSessionId === parent.header.id &&
+        launch.childSessionId === childSessionId &&
+        launch.childSessionFile === childSessionPath
+      );
+    });
+    return { sessionId: parent.header.id, launchedSubagent };
   } catch {
     return undefined;
   }
 }
 
-function inferSessionOrigin(
+function deriveSessionOrigin(
   parentSessionPath: string | undefined,
+  launchedSubagent: boolean,
   handoffMetadata: HandoffSessionMetadata | undefined,
 ): SessionOrigin | undefined {
   if (!parentSessionPath) {
     return undefined;
   }
-
+  if (launchedSubagent) {
+    return "subagent";
+  }
   return handoffMetadata?.origin === "handoff" ? "handoff" : "unknown_child";
 }
 
@@ -507,10 +556,7 @@ function appendDurableHandoffMetadataChunks(
   }
 
   const { entryId, ts, metadata } = durableHandoffMetadata;
-  chunks.push(
-    createMetadataChunk(entryId, ts, "handoff_goal", metadata.goal),
-    createMetadataChunk(entryId, ts, "handoff_next_task", metadata.nextTask),
-  );
+  chunks.push(createMetadataChunk(entryId, ts, "handoff_goal", metadata.goal));
 }
 
 function createMetadataChunk(

package/extensions/session-search/hooks.ts

@@ -27,6 +27,7 @@ import {
   type ExtractedSessionTail,
   extractSessionRecord,
   extractSessionTail,
+  inferSessionOrigin,
   type SessionFileTouch,
 } from "./extract.ts";
 import { deriveSessionRepoRoots } from "./normalize.ts";
@@ -361,14 +362,6 @@ function applyTailSync(
           sourceKind: "handoff_goal",
           text: metadata.goal,
         });
-        insertTextChunk(db, {
-          sessionId: baseline.sessionId,
-          entryId,
-          entryType: "custom",
-          ts,
-          sourceKind: "handoff_next_task",
-          text: metadata.nextTask,
-        });
       }
 
       for (const chunk of scan.chunks) {
@@ -392,10 +385,15 @@ function buildTailSessionRow(
 ): SessionRow {
   const scan = tail.scan;
   const tailHandoffMetadata = baseline.handoffGoal ? undefined : scan.handoffMetadata?.metadata;
-  const tailOrigin =
-    baseline.parentSessionPath && tailHandoffMetadata?.origin === "handoff"
-      ? ("handoff" as const)
-      : undefined;
+  let tailOrigin: SessionOrigin | undefined;
+  if (baseline.sessionOrigin !== "subagent" && baseline.sessionOrigin !== "fork") {
+    tailOrigin = inferSessionOrigin(
+      baseline.sessionId,
+      baseline.sessionPath,
+      baseline.parentSessionPath,
+      tailHandoffMetadata,
+    );
+  }
   const nextOrigin = resolveSessionOrigin(sessionOrigin, tailOrigin, baseline.sessionOrigin);
 
   return {
@@ -416,7 +414,6 @@ function buildTailSessionRow(
     parentSessionId: baseline.parentSessionId,
     sessionOrigin: baseline.parentSessionPath ? (nextOrigin ?? "unknown_child") : undefined,
     handoffGoal: baseline.handoffGoal ?? tailHandoffMetadata?.goal,
-    handoffNextTask: baseline.handoffNextTask ?? tailHandoffMetadata?.nextTask,
     indexedFileSize: tail.indexedFileSize,
     indexedFileMtimeMs: tail.indexedFileMtimeMs,
     indexedFileAnchor: tail.indexedFileAnchor,