@ian-pascoe/pi-codemode 0.1.0 → 0.3.0

package/src/codemode-tool-catalog.ts

@@ -95,10 +95,6 @@ function schemaRecord(value: CodeModeJsonValue | undefined): CodeModeJsonObject
   return value !== undefined && isCodeModeJsonObject(value) ? value : undefined;
 }
 
-function jsonLiteral(value: CodeModeJsonValue): string | undefined {
-  return JSON.stringify(value);
-}
-
 function quotedName(name: string): string {
   return JSON.stringify(name);
 }
@@ -139,9 +135,11 @@ function schemaType(
 
   const constant = record.const;
   if (Object.hasOwn(record, "const") && constant !== undefined) {
-    return jsonLiteral(constant) ?? "unknown";
+    return JSON.stringify(constant) ?? "unknown";
   }
-  const enumValues = Array.isArray(record.enum) ? record.enum.map(jsonLiteral) : undefined;
+  const enumValues = Array.isArray(record.enum)
+    ? record.enum.map((value) => JSON.stringify(value))
+    : undefined;
   if (
     enumValues !== undefined &&
     enumValues.length > 0 &&

package/src/codemode-tool-contract.ts

@@ -8,11 +8,17 @@ import type {
 import type { Usage } from "@earendil-works/pi-ai";
 import { type Static, Type } from "typebox";
 import { Value } from "typebox/value";
+import {
+  CODEMODE_CONSOLE_METHODS,
+  type CodeModeConsoleEntry,
+  type CodeModeConsoleMethod,
+} from "./codemode-console-output.js";
 
 const CODEMODE_TOOL_NAMES = {
   execute: "codemode_execute",
   result: "codemode_result",
   cancel: "codemode_cancel",
+  sessions: "codemode_sessions",
 } as const;
 const RESERVED_CODEMODE_TOOL_NAMES = new Set<string>(Object.values(CODEMODE_TOOL_NAMES));
 
@@ -26,6 +32,7 @@ export const CODEMODE_ERROR_CODES = [
   "unknown",
   "busy",
   "capacity",
+  "eviction",
   "script",
   "serialization",
   "timeout",
@@ -116,12 +123,17 @@ export const CodeModeCancelParametersSchema = Type.Object(
   { additionalProperties: false },
 );
 
+/** Strict empty arguments accepted by the read-only `codemode_sessions` tool. */
+export const CodeModeSessionsParametersSchema = Type.Object({}, { additionalProperties: false });
+
 /** Parsed arguments for `codemode_execute`. */
 export type CodeModeExecuteParameters = Static<typeof CodeModeExecuteParametersSchema>;
 /** Parsed arguments for `codemode_result`. */
 export type CodeModeResultParameters = Static<typeof CodeModeResultParametersSchema>;
 /** Parsed arguments for `codemode_cancel`. */
 export type CodeModeCancelParameters = Static<typeof CodeModeCancelParametersSchema>;
+/** Parsed arguments for the read-only `codemode_sessions` tool. */
+export type CodeModeSessionsParameters = Static<typeof CodeModeSessionsParametersSchema>;
 
 /** A JSON object accepted in a successful CodeMode result. */
 export type CodeModeJsonObject = { readonly [key: string]: CodeModeJsonValue };
@@ -163,6 +175,15 @@ const CodeModeErrorCodeSchema = Type.Unsafe<CodeModeErrorCode>({
   type: "string",
   enum: [...CODEMODE_ERROR_CODES],
 });
+const CodeModeConsoleMethodSchema = Type.Unsafe<CodeModeConsoleMethod>({
+  type: "string",
+  enum: [...CODEMODE_CONSOLE_METHODS],
+});
+const CodeModeConsoleEntrySchema = Type.Object(
+  { method: CodeModeConsoleMethodSchema, text: Type.String() },
+  { additionalProperties: false },
+);
+const CodeModeConsoleOutputSchema = Type.Array(CodeModeConsoleEntrySchema, { minItems: 1 });
 
 /** Stable error retained by a failed CodeMode result. */
 export const CodeModeErrorSchema = Type.Object(
@@ -178,9 +199,35 @@ const CodeModeSuccessSchema = Type.Object(
     result: Type.Literal("success"),
     sessionId: SessionIdSchema,
     data: Type.Optional(CodeModeJsonValueSchema),
+    reclaimedSessionId: Type.Optional(SessionIdSchema),
+    console: Type.Optional(CodeModeConsoleOutputSchema),
+  },
+  { additionalProperties: false },
+);
+
+/** One live CodeMode Session with its Unix-epoch last-activity time. */
+export const CodeModeSessionListEntrySchema = Type.Object(
+  {
+    sessionId: SessionIdSchema,
+    state: Type.Union([Type.Literal("idle"), Type.Literal("running")]),
+    cellCount: NonNegativeSafeIntegerSchema,
+    lastActivityAtMs: NonNegativeSafeIntegerSchema,
   },
   { additionalProperties: false },
 );
+
+/** Idle-LRU-first, then running-LRU aggregate returned by `codemode_sessions`. */
+export const CodeModeSessionsResultSchema = Type.Object(
+  {
+    result: Type.Literal("success"),
+    sessions: Type.Array(CodeModeSessionListEntrySchema),
+  },
+  { additionalProperties: false },
+);
+
+/** Schema-derived live Session list ordered by reclamation priority. */
+export type CodeModeSessionsResult = Static<typeof CodeModeSessionsResultSchema>;
+
 const CodeModePendingSchema = Type.Object(
   {
     result: Type.Literal("pending"),
@@ -193,18 +240,19 @@ const CodeModeFailedSchema = Type.Object(
     result: Type.Literal("failed"),
     sessionId: SessionIdSchema,
     error: CodeModeErrorSchema,
+    console: Type.Optional(CodeModeConsoleOutputSchema),
   },
   { additionalProperties: false },
 );
 
-/** Schema-derived result union shared by all three public CodeMode tools. */
+/** Schema-derived result union shared by the execute, result, and cancel tools. */
 export const CodeModeResultSchema = Type.Union([
   CodeModeSuccessSchema,
   CodeModePendingSchema,
   CodeModeFailedSchema,
 ]);
 
-/** Schema-derived result returned by every public CodeMode tool. */
+/** Schema-derived result returned by one session-scoped CodeMode operation. */
 export type CodeModeResult = Static<typeof CodeModeResultSchema>;
 
 const CodeModeSuccessDetailsSchema = Type.Object(
@@ -212,6 +260,8 @@ const CodeModeSuccessDetailsSchema = Type.Object(
     result: Type.Literal("success"),
     sessionId: SessionIdSchema,
     data: Type.Optional(CodeModeJsonValueSchema),
+    reclaimedSessionId: Type.Optional(SessionIdSchema),
+    console: Type.Optional(CodeModeConsoleOutputSchema),
     presentation: Type.Optional(CodeModePresentationSnapshotSchema),
   },
   { additionalProperties: false },
@@ -229,6 +279,7 @@ const CodeModeFailedDetailsSchema = Type.Object(
     result: Type.Literal("failed"),
     sessionId: SessionIdSchema,
     error: CodeModeErrorSchema,
+    console: Type.Optional(CodeModeConsoleOutputSchema),
     presentation: Type.Optional(CodeModePresentationSnapshotSchema),
   },
   { additionalProperties: false },
@@ -240,14 +291,22 @@ export const CodeModeResultDetailsSchema = Type.Union([
   CodeModePendingDetailsSchema,
   CodeModeFailedDetailsSchema,
 ]);
-/** Schema-derived details retained by every public CodeMode tool. */
+/** Schema-derived details retained by one session-scoped CodeMode operation. */
 export type CodeModeResultDetails = Static<typeof CodeModeResultDetailsSchema>;
 
-/** A successful result with optional JSON data. */
-export function createCodeModeSuccess(sessionId: string, data?: CodeModeJsonValue): CodeModeResult {
-  return data === undefined
-    ? { result: "success", sessionId }
-    : { result: "success", sessionId, data };
+/** A success with optional data and non-empty Cell Console output; empty Console lists are omitted. */
+export function createCodeModeSuccess(
+  sessionId: string,
+  data?: CodeModeJsonValue,
+  consoleEntries?: readonly CodeModeConsoleEntry[],
+): CodeModeResult {
+  const result =
+    data === undefined
+      ? { result: "success" as const, sessionId }
+      : { result: "success" as const, sessionId, data };
+  return consoleEntries === undefined || consoleEntries.length === 0
+    ? result
+    : { ...result, console: [...consoleEntries] };
 }
 
 /** A polling result for a live Cell. */
@@ -255,13 +314,17 @@ export function createCodeModePending(sessionId: string): CodeModeResult {
   return { result: "pending", sessionId };
 }
 
-/** A stable expected failure result. */
+/** A stable expected failure with non-empty Cell Console output; empty Console lists are omitted. */
 export function createCodeModeFailure(
   sessionId: string,
   code: CodeModeErrorCode,
   message: string,
+  consoleEntries?: readonly CodeModeConsoleEntry[],
 ): CodeModeResult {
-  return { result: "failed", sessionId, error: { code, message } };
+  const result = { result: "failed" as const, sessionId, error: { code, message } };
+  return consoleEntries === undefined || consoleEntries.length === 0
+    ? result
+    : { ...result, console: [...consoleEntries] };
 }
 
 /** A bounded JSON compatibility parse that never invokes getters or `toJSON`. */
@@ -402,7 +465,7 @@ export type CodeModeToolOperationResult = {
   readonly presentation?: CodeModePresentationSnapshot;
 };
 
-/** Operations supplied by the session coordinator to build the three Pi tools. */
+/** Operations supplied by the session coordinator to build the four Pi tools. */
 export interface CodeModeToolOperations {
   execute(
     input: CodeModeExecuteParameters,
@@ -412,6 +475,7 @@ export interface CodeModeToolOperations {
   ): Promise<CodeModeToolOperationResult>;
   result(input: CodeModeResultParameters): Promise<CodeModeToolOperationResult>;
   cancel(input: CodeModeCancelParameters): Promise<CodeModeToolOperationResult>;
+  sessions(): Promise<CodeModeSessionsResult>;
 }
 
 function structuredCodeModeResult(
@@ -438,9 +502,19 @@ type CodeModeToolDefinitions = readonly [
   ToolDefinition<typeof CodeModeExecuteParametersSchema, CodeModeResultDetails>,
   ToolDefinition<typeof CodeModeResultParametersSchema, CodeModeResultDetails>,
   ToolDefinition<typeof CodeModeCancelParametersSchema, CodeModeResultDetails>,
+  ToolDefinition<typeof CodeModeSessionsParametersSchema, CodeModeSessionsResult>,
 ];
 
-/** Creates the three stable Pi definitions while leaving admission and session policy to the coordinator. */
+function structuredCodeModeSessionsResult(
+  result: CodeModeSessionsResult,
+): AgentToolResult<CodeModeSessionsResult> {
+  return {
+    content: [{ type: "text", text: JSON.stringify(result) }],
+    details: result,
+  };
+}
+
+/** Creates the four stable Pi definitions while leaving admission and session policy to the coordinator. */
 export function createCodeModeToolDefinitions(
   operations: CodeModeToolOperations,
   executeDescription = "Execute TypeScript in a persistent isolated Deno CodeMode Session.",
@@ -450,6 +524,13 @@ export function createCodeModeToolDefinitions(
       name: CODEMODE_TOOL_NAMES.execute,
       label: "CodeMode Execute",
       description: executeDescription,
+      promptSnippet:
+        "Batch, filter, and aggregate Pi tool calls in TypeScript with less latency and context usage.",
+      promptGuidelines: [
+        "Prefer codemode_execute when multiple Pi tool calls can be filtered, joined, aggregated, paginated, or used to drive later calls, or when one large result can be reduced before returning. Use direct parallel calls for a few small results needed verbatim.",
+        "Return only decision-relevant CodeMode data while preserving paths, line numbers, IDs, URLs, source names, and concise evidence needed for verification.",
+        "Reuse a CodeMode Session for related work. Prefer direct tools for simple one-off calls, full raw output, and confirmation-sensitive or destructive actions; use CodeMode mutations only when conditional sequencing is the point, and fall back to direct tools when the CodeMode boundary does not fit.",
+      ],
       parameters: CodeModeExecuteParametersSchema,
       executionMode: "sequential",
       async execute(_toolCallId, input, signal, onUpdate, context) {
@@ -469,12 +550,25 @@ export function createCodeModeToolDefinitions(
   const cancelTool: ToolDefinition<typeof CodeModeCancelParametersSchema, CodeModeResultDetails> = {
     name: CODEMODE_TOOL_NAMES.cancel,
     label: "CodeMode Cancel",
-    description: "Cancel a live CodeMode session and retain its terminal result.",
+    description: "Cancel a live CodeMode Session, free its capacity, and retain its result.",
     parameters: CodeModeCancelParametersSchema,
     executionMode: "sequential",
     async execute(_toolCallId, input) {
       return structuredCodeModeResult(await operations.cancel(input));
     },
   };
-  return [executeTool, resultTool, cancelTool];
+  const sessionsTool: ToolDefinition<
+    typeof CodeModeSessionsParametersSchema,
+    CodeModeSessionsResult
+  > = {
+    name: CODEMODE_TOOL_NAMES.sessions,
+    label: "List Sessions",
+    description: "List live CodeMode Sessions without changing their recency or state.",
+    parameters: CodeModeSessionsParametersSchema,
+    executionMode: "sequential",
+    async execute() {
+      return structuredCodeModeSessionsResult(await operations.sessions());
+    },
+  };
+  return [executeTool, resultTool, cancelTool, sessionsTool];
 }

package/src/codemode-tool-rendering.ts

@@ -1,5 +1,6 @@
 import {
   getMarkdownTheme,
+  highlightCode,
   keyText,
   truncateHead,
   type AgentToolResult,
@@ -20,11 +21,14 @@ import {
 import { Type } from "typebox";
 import { Value } from "typebox/value";
 import { formatCodeModePresentationData } from "./codemode-presentation-output.js";
+import { formatCodeModeDuration } from "./codemode-session-coordinator.js";
 import {
   CodeModeCancelParametersSchema,
   CodeModeExecuteParametersSchema,
   CodeModeResultDetailsSchema,
   CodeModeResultParametersSchema,
+  CodeModeSessionsParametersSchema,
+  CodeModeSessionsResultSchema,
   createCodeModeToolDefinitions,
   type CodeModeCancelParameters,
   type CodeModeErrorCode,
@@ -34,17 +38,24 @@ import {
   type CodeModePresentationSnapshot,
   type CodeModeResultDetails,
   type CodeModeResultParameters,
+  type CodeModeSessionsParameters,
+  type CodeModeSessionsResult,
   type CodeModeToolOperations,
 } from "./codemode-tool-contract.js";
 
-/** Names of the three CodeMode tools with semantic Transcript rendering. */
-export type CodeModeRenderedToolName = "codemode_execute" | "codemode_result" | "codemode_cancel";
+/** Names of the four CodeMode tools with semantic Transcript rendering. */
+export type CodeModeRenderedToolName =
+  | "codemode_execute"
+  | "codemode_result"
+  | "codemode_cancel"
+  | "codemode_sessions";
 
-/** Parsed arguments accepted by one of the three CodeMode Transcript renderers. */
+/** Parsed arguments accepted by one of the four CodeMode Transcript renderers. */
 export type CodeModeRenderedToolParameters =
   | CodeModeExecuteParameters
   | CodeModeResultParameters
-  | CodeModeCancelParameters;
+  | CodeModeCancelParameters
+  | CodeModeSessionsParameters;
 
 /** Theme operations used by CodeMode Transcript renderers. */
 export type CodeModeRenderTheme = Pick<Theme, "bold" | "fg">;
@@ -62,7 +73,7 @@ const CODEMODE_STATUS_PRESENTATION = {
   cancelled: { color: "warning", label: "■ cancelled" },
   timed_out: { color: "error", label: "! timed out" },
 } satisfies Record<CodeModeCellState, CodeModeStatusPresentation>;
-const CODEMODE_SCRIPT_MAX_LINES = 200;
+const CODEMODE_COLLAPSED_SCRIPT_LINES = 8;
 const CODEMODE_PRESENTATION_MAX_BYTES = 50 * 1024;
 const CodeModeJsonStringSchema = Type.String();
 
@@ -82,14 +93,6 @@ function boundedCodeModePreview(text: string, width = 72): string {
   return `${sliceByColumn(singleLine, 0, width - 1, true).trimEnd()}…`;
 }
 
-function firstMeaningfulScriptLine(script: string): string | undefined {
-  const line = sanitizeCodeModeText(script)
-    .split("\n")
-    .map((candidate) => candidate.trim())
-    .find(Boolean);
-  return line === undefined ? undefined : boundedCodeModePreview(line);
-}
-
 function parseCodeModeRenderedToolParameters(
   toolName: CodeModeRenderedToolName,
   parameters: CodeModeJsonValue,
@@ -100,7 +103,10 @@ function parseCodeModeRenderedToolParameters(
   if (toolName === "codemode_result") {
     return Value.Check(CodeModeResultParametersSchema, parameters) ? parameters : undefined;
   }
-  return Value.Check(CodeModeCancelParametersSchema, parameters) ? parameters : undefined;
+  if (toolName === "codemode_cancel") {
+    return Value.Check(CodeModeCancelParametersSchema, parameters) ? parameters : undefined;
+  }
+  return Value.Check(CodeModeSessionsParametersSchema, parameters) ? parameters : undefined;
 }
 
 function shortCodeModeSessionId(sessionId: string): string {
@@ -111,13 +117,6 @@ function shortCodeModeSessionId(sessionId: string): string {
 /** Resolves one Session ID to the shortest unambiguous CodeMode Transcript label. */
 export type CodeModeSessionPrefixFormatter = (sessionId: string) => string;
 
-function formatCodeModeDuration(elapsedMs: number): string {
-  if (elapsedMs < 1_000) return `${elapsedMs}ms`;
-  if (elapsedMs < 60_000) return `${(elapsedMs / 1_000).toFixed(1)}s`;
-  const seconds = Math.floor(elapsedMs / 1_000);
-  return `${Math.floor(seconds / 60)}m ${String(seconds % 60).padStart(2, "0")}s`;
-}
-
 function pluralizedCodeModeCount(count: number, noun: string): string {
   return `${count} ${noun}${count === 1 ? "" : "s"}`;
 }
@@ -139,6 +138,9 @@ function codeModeSessionLifecycle(
   toolName: CodeModeRenderedToolName,
   details: CodeModeResultDetails,
 ): "Session reusable" | "Session closed" | "No reusable Session" {
+  if (details.result === "failed" && details.error.code === "eviction") {
+    return "Session closed";
+  }
   if (details.presentation !== undefined) {
     return details.presentation.session_state === "live" ? "Session reusable" : "Session closed";
   }
@@ -192,6 +194,16 @@ function appendCodeModeBlock(container: Container, language: "ts" | "json", cont
   );
 }
 
+function highlightedCodeModeSource(source: string): string {
+  return highlightCode(source, "typescript")
+    .map((line) => `  ${line}`)
+    .join("\n");
+}
+
+function appendHighlightedCodeModeSource(container: Container, source: string): void {
+  container.addChild(new Text(highlightedCodeModeSource(source), 0, 0));
+}
+
 function boundedCodeModeText(text: string, maxLines: number): string {
   const safe = sanitizeCodeModeText(text);
   const truncated = truncateHead(safe, {
@@ -234,8 +246,12 @@ function renderCodeModeSummary(
   formatSessionPrefix: CodeModeSessionPrefixFormatter,
 ): string {
   const presentation = details.presentation;
+  const consoleEntries = details.result === "pending" ? undefined : details.console;
   const state = codeModeCellState(toolName, details);
-  const status = CODEMODE_STATUS_PRESENTATION[state];
+  const status =
+    details.result === "failed" && details.error.code === "eviction"
+      ? { color: "warning" as const, label: "■ reclaimed" }
+      : CODEMODE_STATUS_PRESENTATION[state];
   const activeToolNames = presentation?.active_tool_names.slice(0, 3) ?? [];
   const omittedActiveToolCount = Math.max(
     0,
@@ -258,6 +274,9 @@ function renderCodeModeSummary(
       : undefined,
     details.result === "failed" ? theme.fg("muted", details.error.code) : undefined,
     details.result === "failed" ? boundedCodeModePreview(details.error.message, 64) : undefined,
+    consoleEntries === undefined
+      ? undefined
+      : theme.fg("muted", pluralizedCodeModeCount(consoleEntries.length, "console call")),
     state !== "running" && presentation !== undefined && presentation.nested_tool_count > 0
       ? theme.fg("muted", pluralizedCodeModeCount(presentation.nested_tool_count, "tool"))
       : undefined,
@@ -268,7 +287,7 @@ function renderCodeModeSummary(
   return parts.join("  ");
 }
 
-/** Render one CodeMode tool call as a semantic operation with bounded source detail. */
+/** Render one CodeMode tool call with a bounded collapsed preview or complete expanded source. */
 export function renderCodeModeToolCall(
   toolName: CodeModeRenderedToolName,
   parameters: CodeModeJsonValue,
@@ -281,7 +300,9 @@ export function renderCodeModeToolCall(
       ? "Run Cell"
       : toolName === "codemode_result"
         ? "Poll"
-        : "Cancel";
+        : toolName === "codemode_cancel"
+          ? "Cancel"
+          : "List Sessions";
   const parsedParameters = parseCodeModeRenderedToolParameters(toolName, parameters);
   const executeParameters =
     toolName === "codemode_execute" &&
@@ -289,11 +310,14 @@ export function renderCodeModeToolCall(
     "script" in parsedParameters
       ? parsedParameters
       : undefined;
-  const sessionId = parsedParameters?.sessionId;
-  const preview =
-    executeParameters === undefined
-      ? undefined
-      : firstMeaningfulScriptLine(executeParameters.script);
+  const sessionId =
+    parsedParameters !== undefined && "sessionId" in parsedParameters
+      ? parsedParameters.sessionId
+      : undefined;
+  const source =
+    executeParameters === undefined ? undefined : sanitizeCodeModeText(executeParameters.script);
+  const oneLineSource = source !== undefined && !source.includes("\n") ? source : undefined;
+  const expansionHint = `${keyText("app.tools.expand")} to expand`;
   const container = new Container();
   container.addChild(
     new Text(
@@ -301,7 +325,12 @@ export function renderCodeModeToolCall(
         theme.fg("toolTitle", theme.bold("CodeMode")),
         theme.fg("accent", operation),
         theme.fg("muted", sessionId === undefined ? "new" : formatSessionPrefix(sessionId)),
-        preview === undefined ? undefined : theme.fg("dim", preview),
+        !expanded && oneLineSource !== undefined
+          ? highlightCode(oneLineSource, "typescript")[0]
+          : undefined,
+        !expanded && oneLineSource !== undefined
+          ? theme.fg("dim", `·  ${expansionHint}`)
+          : undefined,
       ]
         .filter((part): part is string => part !== undefined)
         .join("  "),
@@ -309,7 +338,17 @@ export function renderCodeModeToolCall(
       0,
     ),
   );
-  if (!expanded) return container;
+  if (!expanded) {
+    if (source === undefined || oneLineSource !== undefined) return container;
+    const sourceLines = source.split("\n");
+    const visibleSource = sourceLines.slice(0, CODEMODE_COLLAPSED_SCRIPT_LINES).join("\n");
+    appendHighlightedCodeModeSource(container, visibleSource);
+    const omittedLines = Math.max(0, sourceLines.length - CODEMODE_COLLAPSED_SCRIPT_LINES);
+    const omitted =
+      omittedLines === 0 ? "" : `… ${pluralizedCodeModeCount(omittedLines, "line")} omitted  ·  `;
+    container.addChild(new Text(theme.fg("dim", `  ${omitted}${expansionHint}`), 0, 0));
+    return container;
+  }
   container.addChild(new Spacer(1));
   if (sessionId !== undefined) appendCodeModeField(container, theme, "Session", sessionId);
   if (executeParameters === undefined) return container;
@@ -319,8 +358,41 @@ export function renderCodeModeToolCall(
     appendCodeModeField(container, theme, "Timeout", `${executeParameters.timeoutMs}ms`);
   container.addChild(new Spacer(1));
   container.addChild(new Text(theme.fg("muted", theme.bold("TypeScript")), 0, 0));
-  const script = boundedCodeModeText(executeParameters.script, CODEMODE_SCRIPT_MAX_LINES);
-  appendCodeModeBlock(container, "ts", script);
+  appendHighlightedCodeModeSource(container, source ?? "");
+  return container;
+}
+
+function renderCodeModeSessionsResult(
+  result: AgentToolResult<unknown>,
+  options: ToolRenderResultOptions,
+  theme: CodeModeRenderTheme,
+): Component {
+  if (!Value.Check(CodeModeSessionsResultSchema, result.details)) {
+    return renderCodeModeFallback(result, options, theme, false);
+  }
+  const sessions: CodeModeSessionsResult = result.details;
+  const summary = `${theme.fg("success", "✓")} ${pluralizedCodeModeCount(sessions.sessions.length, "session")}`;
+  if (!options.expanded) {
+    const hint = options.isPartial ? "" : `  ·  ${keyText("app.tools.expand")} to expand`;
+    return new Text(`${summary}${hint}`, 0, 0);
+  }
+  const container = new Container();
+  container.addChild(new Text(summary, 0, 0));
+  if (sessions.sessions.length === 0) {
+    container.addChild(new Spacer(1));
+    container.addChild(new Text(theme.fg("dim", "No live Sessions"), 0, 0));
+    return container;
+  }
+  container.addChild(new Spacer(1));
+  for (const session of sessions.sessions) {
+    container.addChild(
+      new Text(
+        `${theme.fg(session.state === "running" ? "accent" : "muted", session.state)}  ${sanitizeCodeModeText(session.sessionId)}  ${pluralizedCodeModeCount(session.cellCount, "cell")}  ${session.lastActivityAtMs}`,
+        0,
+        0,
+      ),
+    );
+  }
   return container;
 }
 
@@ -330,14 +402,17 @@ export function renderCodeModeToolResult(
   result: AgentToolResult<unknown>,
   options: ToolRenderResultOptions,
   theme: CodeModeRenderTheme,
-  parameters: CodeModeRenderedToolParameters,
   isError: boolean,
   formatSessionPrefix: CodeModeSessionPrefixFormatter = shortCodeModeSessionId,
 ): Component {
+  if (toolName === "codemode_sessions") {
+    return renderCodeModeSessionsResult(result, options, theme);
+  }
   if (!Value.Check(CodeModeResultDetailsSchema, result.details)) {
     return renderCodeModeFallback(result, options, theme, isError);
   }
   const details = result.details;
+  const consoleEntries = details.result === "pending" ? undefined : details.console;
   const summary = renderCodeModeSummary(details, toolName, theme, formatSessionPrefix);
   if (!options.expanded) {
     const hint = options.isPartial ? "" : `  ·  ${keyText("app.tools.expand")} to expand`;
@@ -386,6 +461,13 @@ export function renderCodeModeToolResult(
     }
   }
 
+  if (consoleEntries !== undefined) {
+    container.addChild(new Spacer(1));
+    container.addChild(new Text(theme.fg("muted", theme.bold("Console")), 0, 0));
+    const output = consoleEntries.map((entry) => `${entry.method}: ${entry.text}`).join("\n");
+    container.addChild(new Text(theme.fg("toolOutput", boundedCodeModeText(output, 2_000)), 0, 0));
+  }
+
   if (details.result === "success") {
     container.addChild(new Spacer(1));
     container.addChild(new Text(theme.fg("muted", theme.bold("Result")), 0, 0));
@@ -409,13 +491,13 @@ export function renderCodeModeToolResult(
   return container;
 }
 
-/** Create the three CodeMode tools with semantic call and result Transcript renderers. */
+/** Create the four CodeMode tools with semantic call and result Transcript renderers. */
 export function createRenderedCodeModeToolDefinitions(
   operations: CodeModeToolOperations,
   executeDescription?: string,
   formatSessionPrefix: CodeModeSessionPrefixFormatter = shortCodeModeSessionId,
 ): ReturnType<typeof createCodeModeToolDefinitions> {
-  const [executeTool, resultTool, cancelTool] = createCodeModeToolDefinitions(
+  const [executeTool, resultTool, cancelTool, sessionsTool] = createCodeModeToolDefinitions(
     operations,
     executeDescription,
   );
@@ -436,7 +518,6 @@ export function createRenderedCodeModeToolDefinitions(
           result,
           options,
           theme,
-          context.args,
           context.isError,
           formatSessionPrefix,
         ),
@@ -457,7 +538,6 @@ export function createRenderedCodeModeToolDefinitions(
           result,
           options,
           theme,
-          context.args,
           context.isError,
           formatSessionPrefix,
         ),
@@ -478,7 +558,26 @@ export function createRenderedCodeModeToolDefinitions(
           result,
           options,
           theme,
-          context.args,
+          context.isError,
+          formatSessionPrefix,
+        ),
+    },
+    {
+      ...sessionsTool,
+      renderCall: (_args, theme, context) =>
+        renderCodeModeToolCall(
+          "codemode_sessions",
+          {},
+          theme,
+          context.expanded,
+          formatSessionPrefix,
+        ),
+      renderResult: (result, options, theme, context) =>
+        renderCodeModeToolResult(
+          "codemode_sessions",
+          result,
+          options,
+          theme,
           context.isError,
           formatSessionPrefix,
         ),