@evandu/super-pi 0.1.139 → 0.1.140

package/agents/super-pi-task/core.ts

@@ -106,7 +106,7 @@ description: 用脚本清洗、转换、统计 Excel/CSV 数据
 mode: primary
 ---
 （正文从这里开始，写它的职责和工作方式。）保存后下一条消息即可使用；修改已有的自定义 Agent 就是编辑同一个目录里对应的 .md 文件。
-- 用户要多个 agent 分工协作：单个子任务用 task 工具委托，有先后依赖的流程用 workflow 工具编排。`;
+- 用户要多个 agent 分工协作：单个子任务用 task 工具委托，有先后依赖的流程用 workflow 工具编排；需要拆分多条独立并行工作线、多会话持续跟踪管理、或用户要求创建多个会话并行时，用 session_spawn 创建兄弟会话，并用 session_status / session_dispatch / session_stop 监督管理。`;
 
 /** The parameters, OpenCode's `tool/todo.ts:6-8` minus its schema wrapper. */
 export type TodoParams = { todos: TodoEntry[] };
@@ -1099,3 +1099,420 @@ export async function executeScheduledTask(
   if (action === "delete") return text(`已删除定时任务「${task.name ?? task.id}」。`);
   return text(`已保存定时任务「${task.name ?? task.id}」：${payload.describe ?? "按计划"}，下次触发 ${next}。用户可以在右侧栏「任务」tab 里看到它、修改提示词与模型、暂停它、立刻手动触发一次，或者删除它。`);
 }
+
+// ---------------------------------------------------------------------------------------------
+// The `session_*` orchestrator tools: manage sibling conversations in the current workspace.
+//
+// WHY THESE TOOLS EXIST. A primary agent can already delegate a single transient job to a subagent
+// via `task` (a one-shot Pi process), or pipeline 2-8 steps via `workflow`. What was missing was the
+// ability to spin up INDEPENDENT, PERSISTENT sibling conversations in Super Pi — sessions that appear
+// in the workspace sidebar, carry their own full message history, run concurrently in the background,
+// and can be conversed with over multiple turns via `session_dispatch`, monitored via `session_status`,
+// or cancelled via `session_stop`.
+//
+// WHY THEY DIFFER FROM `task`. `task` runs an ephemeral child process: it has no conversation history,
+// cannot be conversed with across turns, does not appear in the sidebar, and dies upon returning its
+// final text. Sibling conversations are first-class Super Pi conversations: they retain their own
+// transcripts, can be opened and viewed by the user in the UI, and can execute complex multi-phase
+// work in parallel with the orchestrator.
+// ---------------------------------------------------------------------------------------------
+
+/**
+ * The orchestrator extension's half of the environment contract.
+ * `src/server/task-tool.ts` is the other end; `scripts/task-tool.test.mjs` asserts the two copies agree.
+ */
+export const ORCHESTRATOR_ENDPOINT_ENV = "SUPER_PI_ORCHESTRATOR_ENDPOINT";
+
+/** Tool names registered with Pi. */
+export const SESSION_SPAWN_TOOL_NAME = "session_spawn";
+export const SESSION_STATUS_TOOL_NAME = "session_status";
+export const SESSION_DISPATCH_TOOL_NAME = "session_dispatch";
+export const SESSION_STOP_TOOL_NAME = "session_stop";
+
+/** Model-facing description for session_spawn. */
+export const SESSION_SPAWN_DESCRIPTION = `Create a new sibling conversation in the current workspace and immediately dispatch its initial task.
+
+DIFFERENCE FROM THE 'task' TOOL:
+- The 'task' tool delegates to a transient, one-shot subagent process (scout, critic, patcher) that runs once, returns its final text, and terminates. It has no conversation history and does not appear in the workspace sidebar.
+- 'session_spawn' creates a real, persistent sibling CONVERSATION in Super Pi. It appears in the sidebar, retains multi-turn message history, can receive follow-up messages via session_dispatch, can be inspected via session_status, and can be stopped via session_stop. The user can also switch to it in the Web UI.
+
+WHEN TO USE THIS:
+- Long-running, multi-phase tracks of work that require ongoing context, multiple turns of dialogue, or independent user visibility.
+- Parallel work streams (e.g., Track A: backend refactor, Track B: frontend component update) where both need full conversational capabilities.
+- When the user asks you to act as an orchestrator/manager who delegates to multiple sessions.
+
+WHEN NOT TO USE THIS:
+- For one-off, focused delegation with a single answer: use 'task' (with scout/critic/patcher). It is faster, cheaper, and returns directly to your transcript.
+- For running shell commands or build watchers: use 'run_async'.
+- For a linear multi-step subagent pipeline: use 'workflow'.
+
+Usage notes:
+1. Spawning is ASYNCHRONOUS by default: it creates the conversation, enqueues the initial task, and returns the new conversationId immediately. The sibling session runs in the background.
+2. The initial task should provide clear context and goals since the new session starts with a fresh conversation history.
+3. Use session_status with the returned conversationId to check progress, or session_dispatch to send further messages.`;
+
+/** Model-facing description for session_status. */
+export const SESSION_STATUS_DESCRIPTION = `Inspect the progress, run state, and latest activity of sibling conversations created by the orchestrator.
+
+WHEN TO USE THIS:
+- To check whether a spawned sibling conversation is still running, has finished (idle), is stopped, or encountered an error.
+- To read the latest assistant progress snippet without bloating your context with the session's entire raw message transcript.
+- To list all sibling conversations under your coordination when conversationId is omitted.
+
+Usage notes:
+1. When 'conversationId' is provided: returns a compact summary for that specific session, including its run status ('idle', 'running', 'waiting', 'stopped', 'failed'), messageCount, turnCount, lastAssistantSnippet, lastUserSnippet, activeTool, and error (if any).
+2. When 'conversationId' is omitted: returns a summary list of ALL sibling conversations spawned by this orchestrator session.
+3. This tool never returns full transcripts; it returns concise summaries and snippets to keep your context window lean.`;
+
+/** Model-facing description for session_dispatch. */
+export const SESSION_DISPATCH_DESCRIPTION = `Send a message, follow-up instructions, or steering guidance to an existing sibling conversation.
+
+WHEN TO USE THIS:
+- To follow up with a sibling session after reading its progress with session_status.
+- To give feedback, provide additional requirements, or answer a question from a sibling session.
+- To kick off a new turn on an idle or stopped sibling session.
+
+Usage notes:
+1. 'conversationId' is required and must identify an existing sibling conversation.
+2. 'content' is the text instruction sent to that session, just as if typed by a user in that session's chat.
+3. Dispatch is ASYNCHRONOUS by default: it enqueues the message into the session's queue and returns immediately.
+4. If the sibling session is currently busy running a turn, the dispatched message is placed in its waiting queue and processed when the active turn completes.`;
+
+/** Model-facing description for session_stop. */
+export const SESSION_STOP_DESCRIPTION = `Stop execution in a sibling conversation.
+
+WHEN TO USE THIS:
+- When a sibling session has gone down the wrong path, is stuck in an unwanted loop, or when the overall goal has changed and remaining work should be aborted.
+- To clear pending queued messages before they start running.
+
+Usage notes:
+1. 'mode' controls what to stop:
+   - 'all' (default): stops the currently running turn and cancels all pending queued messages in the session.
+   - 'active': only interrupts the active running turn; leaves any pending queued messages untouched.
+   - 'queued': only cancels pending queued messages; lets the currently running turn complete naturally.
+2. Use 'messageId' if you want to cancel or interrupt one specific queued message instead of all queued messages.`;
+
+/** Compact summary returned for an orchestrated session. */
+export type OrchestratorSessionSummary = {
+  conversationId: string;
+  workspaceId: string;
+  title: string;
+  status: string;
+  origin: "user" | "orchestrator";
+  parentConversationId?: string;
+  task?: string;
+  messageCount: number;
+  turnCount: number;
+  lastAssistantSnippet?: string;
+  lastUserSnippet?: string;
+  hasPendingQuestion: boolean;
+  activeTool?: { label: string; detail?: string };
+  error?: string;
+  updatedAt: string;
+  createdAt?: number;
+  lastProgress?: string;
+};
+
+export type OrchestratorToolConfig = {
+  endpoint: string;
+  conversationId: string;
+  token?: string;
+  capability?: string;
+};
+
+/** Read orchestrator configuration from extension environment. */
+export function readOrchestratorConfig(env: Record<string, string | undefined>): OrchestratorToolConfig {
+  const token = env.SUPER_PI_ACCESS_TOKEN;
+  const capability = env[TASK_CAPABILITY_ENV];
+  return {
+    endpoint: env[ORCHESTRATOR_ENDPOINT_ENV] ?? "",
+    conversationId: env[TASK_CONVERSATION_ENV] ?? "",
+    ...(token ? { token } : {}),
+    ...(capability ? { capability } : {}),
+  };
+}
+
+export type SessionSpawnParams = {
+  task: string;
+  title?: string;
+  agentId?: string;
+  thinkingLevel?: string;
+  wait?: boolean;
+};
+
+export type SessionStatusParams = {
+  conversationId?: string;
+};
+
+export type SessionDispatchParams = {
+  conversationId: string;
+  content: string;
+  wait?: boolean;
+};
+
+export type SessionStopParams = {
+  conversationId: string;
+  mode?: "active" | "queued" | "all";
+  messageId?: string;
+};
+
+/** Execute session_spawn: creates a new sibling conversation and queues initial prompt. */
+export async function executeSessionSpawn(
+  params: SessionSpawnParams,
+  config: OrchestratorToolConfig,
+  deps: { signal?: AbortSignal; fetch?: TaskFetch } = {},
+): Promise<TaskToolResult> {
+  const text = (body: string, isError?: boolean): TaskToolResult => ({
+    content: [{ type: "text", text: body }],
+    details: undefined,
+    ...(isError ? { isError: true } : {}),
+  });
+
+  if (!config.endpoint) {
+    return text("The session_spawn tool is not available in this session: SUPER_PI_ORCHESTRATOR_ENDPOINT is not set.", true);
+  }
+  if (!params.task || !params.task.trim()) {
+    return text("session_spawn requires a non-empty `task` parameter describing what the sibling session should do.", true);
+  }
+
+  const send = deps.fetch ?? (globalFetch as unknown as TaskFetch);
+  try {
+    const response = await send(config.endpoint, {
+      method: "POST",
+      headers: {
+        "content-type": "application/json",
+        ...(config.token ? { authorization: `Bearer ${config.token}` } : {}),
+      },
+      body: JSON.stringify({
+        action: "spawn",
+        task: params.task.trim(),
+        title: params.title?.trim() || undefined,
+        agentId: params.agentId?.trim() || undefined,
+        thinkingLevel: params.thinkingLevel?.trim() || undefined,
+        wait: Boolean(params.wait),
+        parentConversationId: config.conversationId || undefined,
+        capability: config.capability,
+      }),
+      ...(deps.signal ? { signal: deps.signal } : {}),
+    });
+
+    const bodyText = await response.text();
+    let payload: { ok?: boolean; conversationId?: string; error?: string };
+    try {
+      payload = JSON.parse(bodyText);
+    } catch {
+      return text(`The orchestrator endpoint returned HTTP ${response.status}: ${bodyText}`, true);
+    }
+
+    if (!response.ok || !payload.ok || !payload.conversationId) {
+      return text(`Failed to spawn sibling session: ${payload.error ?? `HTTP ${response.status}`}`, true);
+    }
+
+    const convId = payload.conversationId;
+    return text(
+      `<session id="${convId}" state="running">\n` +
+      `<title>${params.title?.trim() || `任务：${params.task.trim().slice(0, 30)}`}</title>\n` +
+      `<task>${params.task.trim()}</task>\n` +
+      `<session_result>Sibling session created and initial task enqueued successfully. Use session_status with conversationId="${convId}" to monitor progress, or session_dispatch to send follow-up instructions.</session_result>\n` +
+      `</session>`
+    );
+  } catch (error) {
+    return text(`session_spawn network error: ${error instanceof Error ? error.message : String(error)}`, true);
+  }
+}
+
+/** Execute session_status: queries status of a single session or lists all sibling sessions. */
+export async function executeSessionStatus(
+  params: SessionStatusParams,
+  config: OrchestratorToolConfig,
+  deps: { signal?: AbortSignal; fetch?: TaskFetch } = {},
+): Promise<TaskToolResult> {
+  const text = (body: string, isError?: boolean): TaskToolResult => ({
+    content: [{ type: "text", text: body }],
+    details: undefined,
+    ...(isError ? { isError: true } : {}),
+  });
+
+  if (!config.endpoint) {
+    return text("The session_status tool is not available in this session: SUPER_PI_ORCHESTRATOR_ENDPOINT is not set.", true);
+  }
+
+  const send = deps.fetch ?? (globalFetch as unknown as TaskFetch);
+  const targetId = params.conversationId?.trim();
+
+  try {
+    const response = await send(config.endpoint, {
+      method: "POST",
+      headers: {
+        "content-type": "application/json",
+        ...(config.token ? { authorization: `Bearer ${config.token}` } : {}),
+      },
+      body: JSON.stringify({
+        action: targetId ? "status" : "list",
+        conversationId: targetId || undefined,
+        parentConversationId: config.conversationId || undefined,
+        capability: config.capability,
+      }),
+      ...(deps.signal ? { signal: deps.signal } : {}),
+    });
+
+    const bodyText = await response.text();
+    let payload: { ok?: boolean; summary?: OrchestratorSessionSummary; sessions?: OrchestratorSessionSummary[]; error?: string };
+    try {
+      payload = JSON.parse(bodyText);
+    } catch {
+      return text(`The orchestrator endpoint returned HTTP ${response.status}: ${bodyText}`, true);
+    }
+
+    if (!response.ok || !payload.ok) {
+      return text(`Failed to query session status: ${payload.error ?? `HTTP ${response.status}`}`, true);
+    }
+
+    if (targetId && payload.summary) {
+      const s = payload.summary;
+      const lines = [
+        `Session Status for ${s.conversationId}:`,
+        `- Title: ${s.title}`,
+        `- Status: ${s.status}`,
+        `- Turns: ${s.turnCount} (Messages: ${s.messageCount})`,
+        `- Active Tool: ${s.activeTool ? `${s.activeTool.label}${s.activeTool.detail ? ` (${s.activeTool.detail})` : ""}` : "none"}`,
+        `- Pending Question: ${s.hasPendingQuestion ? "yes" : "no"}`,
+        ...(s.error ? [`- Error: ${s.error}`] : []),
+        ...(s.lastAssistantSnippet ? [`- Latest Assistant Progress: "${s.lastAssistantSnippet}"`] : []),
+        ...(s.lastUserSnippet ? [`- Latest User/Prompt Snippet: "${s.lastUserSnippet}"`] : []),
+      ];
+      return text(lines.join("\n"));
+    }
+
+    if (payload.sessions) {
+      if (!payload.sessions.length) {
+        return text("No sibling sessions found for this parent conversation.");
+      }
+      const listSummary = payload.sessions.map((s, idx) => {
+        const snippet = s.lastAssistantSnippet ?? s.lastProgress ?? s.task ?? "No output yet";
+        return `${idx + 1}. [${s.conversationId}] "${s.title}" — Status: ${s.status}, Turns: ${s.turnCount}, Latest: "${snippet}"`;
+      }).join("\n");
+      return text(`Sibling sessions (${payload.sessions.length}):\n${listSummary}`);
+    }
+
+    return text(bodyText);
+  } catch (error) {
+    return text(`session_status network error: ${error instanceof Error ? error.message : String(error)}`, true);
+  }
+}
+
+/** Execute session_dispatch: sends a follow-up message to an existing sibling conversation. */
+export async function executeSessionDispatch(
+  params: SessionDispatchParams,
+  config: OrchestratorToolConfig,
+  deps: { signal?: AbortSignal; fetch?: TaskFetch } = {},
+): Promise<TaskToolResult> {
+  const text = (body: string, isError?: boolean): TaskToolResult => ({
+    content: [{ type: "text", text: body }],
+    details: undefined,
+    ...(isError ? { isError: true } : {}),
+  });
+
+  if (!config.endpoint) {
+    return text("The session_dispatch tool is not available in this session: SUPER_PI_ORCHESTRATOR_ENDPOINT is not set.", true);
+  }
+  if (!params.conversationId?.trim()) {
+    return text("session_dispatch requires a valid `conversationId`.", true);
+  }
+  if (!params.content?.trim()) {
+    return text("session_dispatch requires a non-empty `content` message.", true);
+  }
+
+  const send = deps.fetch ?? (globalFetch as unknown as TaskFetch);
+  try {
+    const response = await send(config.endpoint, {
+      method: "POST",
+      headers: {
+        "content-type": "application/json",
+        ...(config.token ? { authorization: `Bearer ${config.token}` } : {}),
+      },
+      body: JSON.stringify({
+        action: "dispatch",
+        conversationId: params.conversationId.trim(),
+        content: params.content.trim(),
+        wait: Boolean(params.wait),
+        parentConversationId: config.conversationId || undefined,
+        capability: config.capability,
+      }),
+      ...(deps.signal ? { signal: deps.signal } : {}),
+    });
+
+    const bodyText = await response.text();
+    let payload: { ok?: boolean; conversationId?: string; error?: string };
+    try {
+      payload = JSON.parse(bodyText);
+    } catch {
+      return text(`The orchestrator endpoint returned HTTP ${response.status}: ${bodyText}`, true);
+    }
+
+    if (!response.ok || !payload.ok) {
+      return text(`Failed to dispatch message to session ${params.conversationId}: ${payload.error ?? `HTTP ${response.status}`}`, true);
+    }
+
+    return text(`Message successfully dispatched to session ${params.conversationId}. The turn has been enqueued.`);
+  } catch (error) {
+    return text(`session_dispatch network error: ${error instanceof Error ? error.message : String(error)}`, true);
+  }
+}
+
+/** Execute session_stop: stops execution in a sibling conversation. */
+export async function executeSessionStop(
+  params: SessionStopParams,
+  config: OrchestratorToolConfig,
+  deps: { signal?: AbortSignal; fetch?: TaskFetch } = {},
+): Promise<TaskToolResult> {
+  const text = (body: string, isError?: boolean): TaskToolResult => ({
+    content: [{ type: "text", text: body }],
+    details: undefined,
+    ...(isError ? { isError: true } : {}),
+  });
+
+  if (!config.endpoint) {
+    return text("The session_stop tool is not available in this session: SUPER_PI_ORCHESTRATOR_ENDPOINT is not set.", true);
+  }
+  if (!params.conversationId?.trim()) {
+    return text("session_stop requires a valid `conversationId`.", true);
+  }
+
+  const send = deps.fetch ?? (globalFetch as unknown as TaskFetch);
+  try {
+    const response = await send(config.endpoint, {
+      method: "POST",
+      headers: {
+        "content-type": "application/json",
+        ...(config.token ? { authorization: `Bearer ${config.token}` } : {}),
+      },
+      body: JSON.stringify({
+        action: "stop",
+        conversationId: params.conversationId.trim(),
+        mode: params.mode ?? "all",
+        messageId: params.messageId?.trim() || undefined,
+        parentConversationId: config.conversationId || undefined,
+        capability: config.capability,
+      }),
+      ...(deps.signal ? { signal: deps.signal } : {}),
+    });
+
+    const bodyText = await response.text();
+    let payload: { ok?: boolean; stopped?: boolean; mode?: string; error?: string };
+    try {
+      payload = JSON.parse(bodyText);
+    } catch {
+      return text(`The orchestrator endpoint returned HTTP ${response.status}: ${bodyText}`, true);
+    }
+
+    if (!response.ok || !payload.ok) {
+      return text(`Failed to stop session ${params.conversationId}: ${payload.error ?? `HTTP ${response.status}`}`, true);
+    }
+
+    return text(`Session ${params.conversationId} stopped (mode: ${payload.mode ?? params.mode ?? "all"}).`);
+  } catch (error) {
+    return text(`session_stop network error: ${error instanceof Error ? error.message : String(error)}`, true);
+  }
+}
+

package/agents/super-pi-task/index.ts

@@ -36,6 +36,25 @@ import {
   readScheduledTaskConfig,
   type ScheduledTaskParams,
 } from "./core.ts";
+import {
+  SESSION_SPAWN_TOOL_NAME,
+  SESSION_STATUS_TOOL_NAME,
+  SESSION_DISPATCH_TOOL_NAME,
+  SESSION_STOP_TOOL_NAME,
+  SESSION_SPAWN_DESCRIPTION,
+  SESSION_STATUS_DESCRIPTION,
+  SESSION_DISPATCH_DESCRIPTION,
+  SESSION_STOP_DESCRIPTION,
+  executeSessionSpawn,
+  executeSessionStatus,
+  executeSessionDispatch,
+  executeSessionStop,
+  readOrchestratorConfig,
+  type SessionSpawnParams,
+  type SessionStatusParams,
+  type SessionDispatchParams,
+  type SessionStopParams,
+} from "./core.ts";
 
 /**
  * The Pi adapter for the `task` and `todowrite` tools. Everything with a decision in it is in
@@ -360,6 +379,102 @@ const extension = (pi: ExtensionApi): void => {
     execute: async (_toolCallId, params, signal) =>
       await executeScheduledTask(params as ScheduledTaskParams, scheduledTaskConfig, { signal: signal ?? undefined }),
   });
+
+  const orchestratorConfig = readOrchestratorConfig(process.env);
+
+  const SessionSpawnParameters = Type.Object({
+    task: Type.String({
+      description: "The high-level task or instructions to be performed by the new sibling session. This is sent as the initial prompt.",
+    }),
+    title: Type.Optional(Type.String({
+      description: "An optional title for the new sibling conversation in the sidebar. If omitted, derived from task.",
+    })),
+    agentId: Type.Optional(Type.String({
+      description: "Optional agent definition to assign to the new session (e.g. 'coder', 'planner'). Defaults to the workspace default.",
+    })),
+    thinkingLevel: Type.Optional(Type.String({
+      description: "Optional thinking level override ('off', 'low', 'medium', 'high'). Defaults to workspace setting.",
+    })),
+    wait: Type.Optional(Type.Boolean({
+      description: "Whether to await turn completion before returning (default: false, asynchronous).",
+    })),
+  });
+
+  const SessionStatusParameters = Type.Object({
+    conversationId: Type.Optional(Type.String({
+      description: "The ID of the sibling conversation to inspect. Omit to list all sibling conversations created under this session.",
+    })),
+  });
+
+  const SessionDispatchParameters = Type.Object({
+    conversationId: Type.String({
+      description: "The ID of the target sibling conversation to send a message to.",
+    }),
+    content: Type.String({
+      description: "The text message or instructions to send to the sibling conversation.",
+    }),
+    wait: Type.Optional(Type.Boolean({
+      description: "Whether to await turn completion before returning (default: false, asynchronous).",
+    })),
+  });
+
+  const SessionStopParameters = Type.Object({
+    conversationId: Type.String({
+      description: "The conversation ID of the sibling session to stop.",
+    }),
+    mode: Type.Optional(Type.Union([
+      Type.Literal("active", { description: "Interrupt current running turn only" }),
+      Type.Literal("queued", { description: "Cancel pending queued messages only" }),
+      Type.Literal("all", { description: "Stop active turn and cancel all queued messages (default)" }),
+    ], {
+      description: "Stop mode: 'active', 'queued', or 'all' (default).",
+    })),
+    messageId: Type.Optional(Type.String({
+      description: "Optional specific queued message ID to cancel or interrupt.",
+    })),
+  });
+
+  if (orchestratorConfig.endpoint) {
+    pi.registerTool({
+      name: SESSION_SPAWN_TOOL_NAME,
+      label: "Spawn Sibling Session",
+      description: SESSION_SPAWN_DESCRIPTION,
+      promptSnippet: "spawn a persistent sibling conversation for an independent work stream",
+      parameters: SessionSpawnParameters,
+      execute: async (_toolCallId, params, signal) =>
+        await executeSessionSpawn(params as SessionSpawnParams, orchestratorConfig, { signal: signal ?? undefined }),
+    });
+
+    pi.registerTool({
+      name: SESSION_STATUS_TOOL_NAME,
+      label: "Session Status",
+      description: SESSION_STATUS_DESCRIPTION,
+      promptSnippet: "check progress, turn count and activity of sibling sessions",
+      parameters: SessionStatusParameters,
+      execute: async (_toolCallId, params, signal) =>
+        await executeSessionStatus(params as SessionStatusParams, orchestratorConfig, { signal: signal ?? undefined }),
+    });
+
+    pi.registerTool({
+      name: SESSION_DISPATCH_TOOL_NAME,
+      label: "Dispatch to Session",
+      description: SESSION_DISPATCH_DESCRIPTION,
+      promptSnippet: "send a message or follow-up prompt to an existing sibling session",
+      parameters: SessionDispatchParameters,
+      execute: async (_toolCallId, params, signal) =>
+        await executeSessionDispatch(params as SessionDispatchParams, orchestratorConfig, { signal: signal ?? undefined }),
+    });
+
+    pi.registerTool({
+      name: SESSION_STOP_TOOL_NAME,
+      label: "Stop Session",
+      description: SESSION_STOP_DESCRIPTION,
+      promptSnippet: "interrupt an active turn or cancel queued messages in a sibling session",
+      parameters: SessionStopParameters,
+      execute: async (_toolCallId, params, signal) =>
+        await executeSessionStop(params as SessionStopParams, orchestratorConfig, { signal: signal ?? undefined }),
+    });
+  }
 };
 
 export default extension;

package/dist/.super-pi-check-inputs.json

@@ -1,4 +1,4 @@
 {
-  "hash": "b6a20ac07efc6e59a600bec521cc5df0e05c45e3e21ff20cb48996e41bc98efd",
-  "recordedAt": "2026-10-29T01:57:07.384Z"
+  "hash": "bec2d0f2cdd605d5039fb0f94c0776b2641eb996561128fe0c654002639f81e7",
+  "recordedAt": "2026-10-29T10:22:38.683Z"
 }

package/dist/client/.super-pi-client-sources.json

@@ -1,7 +1,7 @@
 {
-  "hash": "a3b6dcff143bcb64c02bbd26c3ce835f2eb5f4406dc8b16e8a2068ecdabfab0d",
+  "hash": "f452eac806eb9b524339a3014bad75b0e38512de1a657b0e20833bed50947ad7",
   "files": {
-    "src/client/App.tsx": "23715233c81a35b61bbf32851a9b0bd407c80bd21bea1f9f54cf3bcc07da08aa",
+    "src/client/App.tsx": "625097a2298f4413e83c6cc620e2855b245aa28cb0d5c2b47c225b54b6f40825",
     "src/client/CodeMirrorEditor.tsx": "b6b6479effa1482eda710f04a26f3af843515526e129ca5bc70692cca9074b09",
     "src/client/ErrorBoundary.tsx": "d16376f9f6c7cc1fab8590c65a66438127642f7d6bb8023cec53d8a6cc9f3964",
     "src/client/FeishuPanel.tsx": "52f116eba265bfde683338f5893107ad5559fd2f7d4a9e0df935507a46862a3b",
@@ -13,6 +13,7 @@
     "src/client/MarkdownView.tsx": "4f04a8f3c9381946e5d2f957ac4fb74a6b16272e90375fb4dc6bd3a43d7c744d",
     "src/client/MemoryPanel.tsx": "2cc1f4ee709f6d56ede8b0ceced228ea4c935cfd1cc803275558dbbd5f5244fb",
     "src/client/ScheduledTasksPanel.tsx": "eb05526241ba9072acd4ee7c08425e89a2054493ec7017f7041f01879971c224",
+    "src/client/SessionOverviewPanel.tsx": "fe654d49989c660ef67bc160d67e644d4f5bfffb2d04027ab15da64130033d39",
     "src/client/SlashCommandMenu.tsx": "69cd0a9d5e35f41f703e91a845e5bd750c952d2957be03b5528e156e60bf6ecb",
     "src/client/Tabs.tsx": "53323a198c0948887cb0cd018284ecd5c9b36025364484a91426f8e1e2198000",
     "src/client/TerminalPanel.tsx": "6a8dbb0e0806ccfef6fd67ae16f580177dca9a7a8943fd5b801da555e424ad72",
@@ -26,13 +27,13 @@
     "src/client/markdown.ts": "1499893ea5ce29d49f26c193cc0e6001ffa8a31d039ccee343ba407cd2cdbf1b",
     "src/client/pending-operations.ts": "8a5f9e9711c0f875c8ed194196c218162de5270298dad4091351d41294c859d7",
     "src/client/slash-commands.ts": "b792018fb67bd9e6f777397b0720b8b3aa565a4d8f7a76f94fec097ddf749480",
-    "src/client/styles.css": "a917d325dc6deede9e7b865c2a2bbe2fd936b87a53cc7fa947da7098de6cc2cd",
+    "src/client/styles.css": "0b8bdb92f90ada2997e1a941c8556f634c95ede144e8714c1d22a123948f9aa4",
     "src/client/terminal-emulator.ts": "ffcc4f5fbddaf25cebcc9e03dbe5d7d0ad2c21586f5d169e57c04c82e2308b3b",
     "src/client/theme.tsx": "5892479a802f41e7d45adeb5170efbf555b240f8581528bcde7bf2d99c635010",
     "src/client/tool-sharing.ts": "679c97f6d40be466964f2f1076aa7ea55f4a585c3deff8214675070220921059",
     "src/client/tools.ts": "58fe41f0edbd490e3fab7f12f258b1dbc2163b653553b03ac61caf1543618e50",
-    "src/client/types.ts": "83588e25552d8cc33ce2bf50fc716b1078e5c5f73d0fb49df988786835ec276e",
+    "src/client/types.ts": "cc8405d6bf1a9933b16c9e29692bfec746ee0a0b3fe27bab4bbe6f16f25c5131",
     "src/client/vite-env.d.ts": "65996936fbb042915f7b74a200fcdde7e410f32a669b1ab9597cfaa4b0faddb5"
   },
-  "recordedAt": "2026-10-29T05:40:48.337Z"
+  "recordedAt": "2026-10-29T10:32:39.121Z"
 }