@esso0428/pi-subagents 0.15.5 → 0.15.6

package/dist/worktree.js

@@ -1,4 +1,3 @@
-"use strict";
 /**
  * worktree.ts — Git worktree isolation for agents.
  *
@@ -6,51 +5,47 @@
  * On completion, if no changes were made, the worktree is cleaned up.
  * If changes exist, a branch is created and returned in the result.
  */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createWorktree = createWorktree;
-exports.cleanupWorktree = cleanupWorktree;
-exports.pruneWorktrees = pruneWorktrees;
-const node_child_process_1 = require("node:child_process");
-const node_crypto_1 = require("node:crypto");
-const node_fs_1 = require("node:fs");
-const node_os_1 = require("node:os");
-const node_path_1 = require("node:path");
+import { execFileSync } from "node:child_process";
+import { randomUUID } from "node:crypto";
+import { existsSync, realpathSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join, relative } from "node:path";
 /**
  * Create a temporary git worktree for an agent.
  * Returns the worktree path, or undefined if not in a git repo.
  */
-function createWorktree(cwd, agentId) {
+export function createWorktree(cwd, agentId) {
     // Verify we're in a git repo with at least one commit (HEAD must exist)
     let baseSha;
     let subdir;
     try {
-        (0, node_child_process_1.execFileSync)("git", ["rev-parse", "--is-inside-work-tree"], { cwd, stdio: "pipe", timeout: 5000 });
-        baseSha = (0, node_child_process_1.execFileSync)("git", ["rev-parse", "HEAD"], { cwd, stdio: "pipe", timeout: 5000 })
+        execFileSync("git", ["rev-parse", "--is-inside-work-tree"], { cwd, stdio: "pipe", timeout: 5000 });
+        baseSha = execFileSync("git", ["rev-parse", "HEAD"], { cwd, stdio: "pipe", timeout: 5000 })
             .toString()
             .trim();
         // Where cwd sits inside the repo ("" at the root): the agent must work at
         // the same subdirectory inside the copy, or a monorepo-package cwd would
         // silently widen to the whole repo. realpath both sides — git emits
         // resolved paths while cwd may arrive through a symlink (macOS /tmp).
-        const topLevel = (0, node_child_process_1.execFileSync)("git", ["rev-parse", "--show-toplevel"], { cwd, stdio: "pipe", timeout: 5000 })
+        const topLevel = execFileSync("git", ["rev-parse", "--show-toplevel"], { cwd, stdio: "pipe", timeout: 5000 })
             .toString()
             .trim();
-        subdir = (0, node_path_1.relative)((0, node_fs_1.realpathSync)(topLevel), (0, node_fs_1.realpathSync)(cwd));
+        subdir = relative(realpathSync(topLevel), realpathSync(cwd));
     }
     catch {
         return undefined;
     }
     const branch = `pi-agent-${agentId}`;
-    const suffix = (0, node_crypto_1.randomUUID)().slice(0, 8);
-    const worktreePath = (0, node_path_1.join)((0, node_os_1.tmpdir)(), `pi-agent-${agentId}-${suffix}`);
+    const suffix = randomUUID().slice(0, 8);
+    const worktreePath = join(tmpdir(), `pi-agent-${agentId}-${suffix}`);
     try {
         // Create detached worktree at HEAD
-        (0, node_child_process_1.execFileSync)("git", ["worktree", "add", "--detach", worktreePath, "HEAD"], {
+        execFileSync("git", ["worktree", "add", "--detach", worktreePath, "HEAD"], {
             cwd,
             stdio: "pipe",
             timeout: 30000,
         });
-        return { path: worktreePath, branch, baseSha, workPath: subdir ? (0, node_path_1.join)(worktreePath, subdir) : worktreePath };
+        return { path: worktreePath, branch, baseSha, workPath: subdir ? join(worktreePath, subdir) : worktreePath };
     }
     catch {
         // If worktree creation fails, return undefined (agent runs in normal cwd)
@@ -62,31 +57,31 @@ function createWorktree(cwd, agentId) {
  * - If no changes: remove worktree entirely.
  * - If changes exist: create a branch, commit changes, return branch info.
  */
-function cleanupWorktree(cwd, worktree, agentDescription) {
-    if (!(0, node_fs_1.existsSync)(worktree.path)) {
+export function cleanupWorktree(cwd, worktree, agentDescription) {
+    if (!existsSync(worktree.path)) {
         return { hasChanges: false };
     }
     try {
         // Check for uncommitted changes in the worktree
-        const status = (0, node_child_process_1.execFileSync)("git", ["status", "--porcelain"], {
+        const status = execFileSync("git", ["status", "--porcelain"], {
             cwd: worktree.path,
             stdio: "pipe",
             timeout: 10000,
         }).toString().trim();
         if (status) {
             // Changes exist — stage, commit, and create a branch
-            (0, node_child_process_1.execFileSync)("git", ["add", "-A"], { cwd: worktree.path, stdio: "pipe", timeout: 10000 });
+            execFileSync("git", ["add", "-A"], { cwd: worktree.path, stdio: "pipe", timeout: 10000 });
             // Truncate description for commit message (no shell sanitization needed — execFileSync uses argv)
             const safeDesc = agentDescription.slice(0, 200);
             const commitMsg = `pi-agent: ${safeDesc}`;
-            (0, node_child_process_1.execFileSync)("git", ["commit", "--no-verify", "-m", commitMsg], {
+            execFileSync("git", ["commit", "--no-verify", "-m", commitMsg], {
                 cwd: worktree.path,
                 stdio: "pipe",
                 timeout: 10000,
             });
         }
         else {
-            const currentSha = (0, node_child_process_1.execFileSync)("git", ["rev-parse", "HEAD"], {
+            const currentSha = execFileSync("git", ["rev-parse", "HEAD"], {
                 cwd: worktree.path,
                 stdio: "pipe",
                 timeout: 5000,
@@ -101,7 +96,7 @@ function cleanupWorktree(cwd, worktree, agentDescription) {
         // If the branch already exists, append a suffix to avoid overwriting previous work.
         let branchName = worktree.branch;
         try {
-            (0, node_child_process_1.execFileSync)("git", ["branch", branchName], {
+            execFileSync("git", ["branch", branchName], {
                 cwd: worktree.path,
                 stdio: "pipe",
                 timeout: 5000,
@@ -110,7 +105,7 @@ function cleanupWorktree(cwd, worktree, agentDescription) {
         catch {
             // Branch already exists — use a unique suffix
             branchName = `${worktree.branch}-${Date.now()}`;
-            (0, node_child_process_1.execFileSync)("git", ["branch", branchName], {
+            execFileSync("git", ["branch", branchName], {
                 cwd: worktree.path,
                 stdio: "pipe",
                 timeout: 5000,
@@ -140,7 +135,7 @@ function cleanupWorktree(cwd, worktree, agentDescription) {
  */
 function removeWorktree(cwd, worktreePath) {
     try {
-        (0, node_child_process_1.execFileSync)("git", ["worktree", "remove", "--force", worktreePath], {
+        execFileSync("git", ["worktree", "remove", "--force", worktreePath], {
             cwd,
             stdio: "pipe",
             timeout: 10000,
@@ -149,7 +144,7 @@ function removeWorktree(cwd, worktreePath) {
     catch {
         // If git worktree remove fails, try pruning
         try {
-            (0, node_child_process_1.execFileSync)("git", ["worktree", "prune"], { cwd, stdio: "pipe", timeout: 5000 });
+            execFileSync("git", ["worktree", "prune"], { cwd, stdio: "pipe", timeout: 5000 });
         }
         catch { /* ignore */ }
     }
@@ -157,9 +152,9 @@ function removeWorktree(cwd, worktreePath) {
 /**
  * Prune any orphaned worktrees (crash recovery).
  */
-function pruneWorktrees(cwd) {
+export function pruneWorktrees(cwd) {
     try {
-        (0, node_child_process_1.execFileSync)("git", ["worktree", "prune"], { cwd, stdio: "pipe", timeout: 5000 });
+        execFileSync("git", ["worktree", "prune"], { cwd, stdio: "pipe", timeout: 5000 });
     }
     catch { /* ignore */ }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@esso0428/pi-subagents",
-  "version": "0.15.5",
+  "version": "0.15.6",
   "description": "A pi extension that brings smart Claude Code-style autonomous sub-agents to pi, with npm:pi-subagents-style JSON agent overrides.",
   "author": "ESSO0428",
   "repository": {

package/src/agent-history-list.ts

@@ -0,0 +1,91 @@
+/** Helpers for separating openable active agents from terminal history. */
+
+import { hasAgentHistory } from "./agent-history.js";
+import type { AgentRecord } from "./types.js";
+import { getAgentConfig } from "./agent-types.js";
+import { formatDuration, getDisplayName } from "./ui/agent-widget.js";
+
+export type AgentHistoryStatus =
+  | "completed"
+  | "steered"
+  | "stopped"
+  | "aborted"
+  | "error";
+
+const TERMINAL_STATUSES: ReadonlySet<string> = new Set<AgentHistoryStatus>([
+  "completed",
+  "steered",
+  "stopped",
+  "aborted",
+  "error",
+]);
+
+/** Return whether a record status represents a terminal agent run. */
+export function isTerminalAgentStatus(status: string): status is AgentHistoryStatus {
+  return TERMINAL_STATUSES.has(status);
+}
+
+/** Return whether an active record has a live session that can be opened. */
+export function canOpenActiveAgent(record: AgentRecord): boolean {
+  return (record.status === "running" || record.status === "queued")
+    && record.session !== undefined;
+}
+
+/** Return whether a terminal record has an in-memory or durable conversation. */
+export function canOpenAgentHistory(record: AgentRecord, cwd: string | undefined): boolean {
+  if (!isTerminalAgentStatus(record.status)) return false;
+  return record.session !== undefined
+    || (cwd !== undefined && hasAgentHistory(cwd, record.transcriptPath));
+}
+
+/** Split records into openable active and terminal-history buckets. */
+export function splitAgentRecords(
+  records: readonly AgentRecord[],
+  cwd: string | undefined,
+): { active: AgentRecord[]; history: AgentRecord[] } {
+  const active: AgentRecord[] = [];
+  const history: AgentRecord[] = [];
+
+  for (const record of records) {
+    if (canOpenActiveAgent(record)) {
+      active.push(record);
+    } else if (canOpenAgentHistory(record, cwd)) {
+      history.push(record);
+    }
+  }
+
+  return { active, history };
+}
+
+const DESCRIPTION_LIMIT = 72;
+const LABEL_LIMIT = 140;
+
+function boundedDescription(description: string): string {
+  const line = description.split("\n").find((part) => part.trim())?.trim() ?? "";
+  if (line.length <= DESCRIPTION_LIMIT) return line;
+  return `${line.slice(0, DESCRIPTION_LIMIT - 1)}…`;
+}
+
+/** Format a bounded, single-line history menu option. */
+export function formatAgentHistoryOption(record: AgentRecord, now: number): string {
+  const duration = formatDuration(record.startedAt, record.completedAt ?? now);
+  // Unit consumers may format persisted records before the registry has been
+  // initialized; preserve the persisted type instead of falling back to
+  // general-purpose's generic display name in that case.
+  const displayName = getAgentConfig(record.type)?.displayName
+    ?? (record.type === "general-purpose" ? getDisplayName(record.type) : record.type);
+  const option = `[${record.status}] ${displayName} · ${boundedDescription(record.description)} · ${duration}`;
+  return option.length <= LABEL_LIMIT ? option : `${option.slice(0, LABEL_LIMIT - 1)}…`;
+}
+
+/** Build the visible status-section labels for the agents menu. */
+export function buildAgentStatusMenuEntries(
+  records: readonly AgentRecord[],
+  cwd: string | undefined,
+): string[] {
+  const { active, history } = splitAgentRecords(records, cwd);
+  return [
+    ...(active.length > 0 ? [`Running agents (${active.length})`] : []),
+    ...(history.length > 0 ? [`Agent history (${history.length})`] : []),
+  ];
+}

package/src/agent-history.ts

@@ -19,14 +19,12 @@ export function ensureSubagentsGitignore(cwd: string): string {
   const directory = join(cwd, SUBAGENTS_DIR);
   mkdirSync(directory, { recursive: true });
   const path = join(directory, ".gitignore");
-
   let content = "";
   try {
     content = readFileSync(path, "utf8");
   } catch {
     // The append below also creates a missing file.
   }
-
   if (!content.split(/\r?\n/).some((line) => line.trim() === "*")) {
     const separator = content.length > 0 && !/[\r\n]$/.test(content) ? "\n" : "";
     appendFileSync(path, `${separator}*\n`, "utf8");
@@ -35,17 +33,12 @@ export function ensureSubagentsGitignore(cwd: string): string {
 }
 
 /** Return the durable transcript path for an agent. */
-export function createAgentHistoryPath(
-  cwd: string,
-  agentId: string,
-  agentType = "agent",
-): string {
+export function createAgentHistoryPath(cwd: string, agentId: string): string {
   ensureSubagentsGitignore(cwd);
   const directory = join(cwd, SUBAGENTS_DIR, TRANSCRIPTS_DIR);
   mkdirSync(directory, { recursive: true });
   const safeId = agentId.replace(/[^A-Za-z0-9._-]+/g, "-") || "agent";
-  const safeType = agentType.replace(/[^A-Za-z0-9._-]+/g, "-") || "agent";
-  return join(directory, `${safeId}_${safeType}_transcript.jsonl`);
+  return join(directory, `${safeId}.jsonl`);
 }
 
 /** Return the project-relative path stored in the parent session record. */
@@ -55,7 +48,12 @@ export function agentHistoryLocator(cwd: string, historyPath: string): string {
 
 /** Resolve only paths in this package's project-local transcript namespace. */
 export function resolveAgentHistoryPath(cwd: string, locator: string): string | undefined {
-  if (!locator || isAbsolute(locator)) return undefined;
+  // Locators are persisted data, not arbitrary paths. Reject traversal syntax
+  // before resolving so a path which normalizes back inside the namespace is
+  // still not accepted as an unsafe locator.
+  if (!locator || isAbsolute(locator) || locator.includes("\0") || locator.includes("\\")) return undefined;
+  const segments = locator.split("/");
+  if (segments.some((segment) => segment === ".." || segment === "")) return undefined;
   const root = resolve(cwd, SUBAGENTS_DIR, TRANSCRIPTS_DIR);
   const candidate = resolve(cwd, locator);
   if (candidate !== root && !candidate.startsWith(`${root}${sep}`)) return undefined;
@@ -74,12 +72,9 @@ export function hasAgentHistory(cwd: string, locator: string | undefined): boole
  * conversation viewer. Malformed lines and unknown records are skipped so one
  * damaged entry cannot hide the rest of a history.
  */
-export function readAgentHistory(
-  cwd: string,
-  locator: string,
-): AgentSession["messages"] | undefined {
+export function readAgentHistory(cwd: string, locator: string): AgentSession["messages"] | undefined {
   const path = resolveAgentHistoryPath(cwd, locator);
-  if (!path) return undefined;
+  if (!path || !existsSync(path)) return undefined;
 
   let raw: string;
   try {
@@ -93,8 +88,8 @@ export function readAgentHistory(
   for (const line of raw.split(/\r?\n/)) {
     if (!line.trim()) continue;
     try {
-      const entry = JSON.parse(line) as { message?: unknown };
-      const message = entry.message;
+      const entry: unknown = JSON.parse(line);
+      const message = (entry as { message?: unknown } | null)?.message;
       if (!message || typeof message !== "object") continue;
       const role = (message as { role?: unknown }).role;
       if (typeof role !== "string") continue;

package/src/agent-manager.ts

@@ -23,13 +23,67 @@ export type CompactionInfo = { reason: "manual" | "threshold" | "overflow"; toke
 
 /** Default max concurrent background agents. */
 const DEFAULT_MAX_CONCURRENT = 4;
-const TERMINAL_STATUSES = new Set<AgentRecord["status"]>([
-  "completed",
-  "steered",
-  "aborted",
-  "stopped",
-  "error",
-]);
+const RESTORABLE_STATUSES = new Set(["completed", "steered", "stopped", "aborted", "error"] as const);
+
+type RestorableAgentStatus = "completed" | "steered" | "stopped" | "aborted" | "error";
+
+/** Narrow persisted strings before putting them into runtime/UI state. */
+function isSafePersistedString(value: unknown, maxLength: number): value is string {
+  return typeof value === "string" && value.length > 0 && value.length <= maxLength && !/[\0\r\n]/.test(value);
+}
+
+function isFiniteTimestamp(value: unknown): value is number {
+  return typeof value === "number" && Number.isFinite(value) && Number.isInteger(value) && value >= 0;
+}
+
+function isValidUsage(value: unknown): value is { input: number; output: number; cacheWrite: number } {
+  if (!value || typeof value !== "object") return false;
+  const usage = value as Record<string, unknown>;
+  return ["input", "output", "cacheWrite"].every((key) => {
+    const n = usage[key];
+    return typeof n === "number" && Number.isFinite(n) && n >= 0;
+  });
+}
+
+function isSafeTranscriptLocator(value: unknown): value is string {
+  return typeof value === "string"
+    && /^\.pi-subagents\/agent-transcripts\/[^/]+\.jsonl$/.test(value)
+    && !value.includes("..")
+    && !value.includes("\\")
+    && !value.includes("\0");
+}
+
+/** Validate one persisted terminal record without constructing runtime handles. */
+export function isRestorableAgentRecord(value: unknown): value is {
+  id: string;
+  type: string;
+  description: string;
+  status: RestorableAgentStatus;
+  startedAt: number;
+  completedAt: number;
+  result?: string;
+  error?: string;
+  toolUses?: number;
+  lifetimeUsage?: { input: number; output: number; cacheWrite: number };
+  transcriptPath?: string;
+} {
+  if (!value || typeof value !== "object") return false;
+  const record = value as Record<string, unknown>;
+  if (!isSafePersistedString(record.id, 256)
+    || !isSafePersistedString(record.type, 256)
+    || !isSafePersistedString(record.description, 4096)
+    || typeof record.status !== "string"
+    || !RESTORABLE_STATUSES.has(record.status as RestorableAgentStatus)
+    || !isFiniteTimestamp(record.startedAt)
+    || !isFiniteTimestamp(record.completedAt)
+    || record.completedAt < record.startedAt) return false;
+  if (record.result !== undefined && !isSafePersistedString(record.result, 2_000_000)) return false;
+  if (record.error !== undefined && !isSafePersistedString(record.error, 64_000)) return false;
+  if (record.toolUses !== undefined && (!Number.isInteger(record.toolUses) || (record.toolUses as number) < 0)) return false;
+  if (record.lifetimeUsage !== undefined && !isValidUsage(record.lifetimeUsage)) return false;
+  if (record.transcriptPath !== undefined && !isSafeTranscriptLocator(record.transcriptPath)) return false;
+  return true;
+}
 
 /**
  * Validate a caller-supplied SpawnOptions.cwd. `undefined`/`null` mean "unset"
@@ -104,45 +158,6 @@ interface SpawnOptions {
   onCompaction?: (info: CompactionInfo) => void;
 }
 
-const RESTORABLE_STATUSES = new Set<AgentRecord["status"]>([
-  "completed",
-  "steered",
-  "aborted",
-  "stopped",
-  "error",
-]);
-
-type PersistedAgentRecord = Pick<
-  AgentRecord,
-  "id" | "type" | "description" | "status" | "result" | "error" | "startedAt" | "completedAt" | "transcriptPath"
->;
-
-function isRestorableRecord(value: unknown): value is PersistedAgentRecord {
-  if (!value || typeof value !== "object") return false;
-  const record = value as Record<string, unknown>;
-  const transcriptPath = record.transcriptPath;
-  const validTranscriptPath =
-    transcriptPath === undefined ||
-    (typeof transcriptPath === "string" &&
-      transcriptPath.startsWith(".pi-subagents/agent-transcripts/") &&
-      !transcriptPath.includes("..") &&
-      !transcriptPath.includes("\\"));
-  return (
-    typeof record.id === "string" &&
-    record.id.length > 0 &&
-    typeof record.type === "string" &&
-    typeof record.description === "string" &&
-    RESTORABLE_STATUSES.has(record.status as AgentRecord["status"]) &&
-    typeof record.startedAt === "number" &&
-    Number.isFinite(record.startedAt) &&
-    typeof record.completedAt === "number" &&
-    Number.isFinite(record.completedAt) &&
-    (record.result === undefined || typeof record.result === "string") &&
-    (record.error === undefined || typeof record.error === "string") &&
-    validTranscriptPath
-  );
-}
-
 export class AgentManager {
   private agents = new Map<string, AgentRecord>();
   private cleanupInterval: ReturnType<typeof setInterval>;
@@ -556,47 +571,59 @@ export class AgentManager {
     return this.agents.get(id);
   }
 
-  /**
-   * Restore terminal records persisted in a parent session.
-   *
-   * Restored records deliberately have no live session, promise, or abort
-   * controller. Invalid data is ignored because session entries are persisted
-   * extension data and may have been written by an older version.
-   */
-  restoreCompleted(records: readonly unknown[]): void {
-    const restoredIds = new Set<string>();
-    // getBranch() is chronological; newest persisted state wins on duplicate IDs.
-    for (const value of [...records].reverse()) {
-      if (!isRestorableRecord(value)) continue;
-      if (restoredIds.has(value.id) || this.agents.has(value.id)) continue;
-      restoredIds.add(value.id);
-
-      this.agents.set(value.id, {
-        id: value.id,
-        type: value.type,
-        description: value.description,
-        status: value.status,
-        result: value.result,
-        error: value.error,
-        transcriptPath: value.transcriptPath,
-        toolUses: 0,
-        startedAt: value.startedAt,
-        completedAt: value.completedAt,
-        lifetimeUsage: { input: 0, output: 0, cacheWrite: 0 },
-        compactionCount: 0,
-        // Historical records have no inline tool surface and should remain
-        // visible in the background widget.
-        isBackground: true,
-      });
-    }
-  }
-
   listAgents(): AgentRecord[] {
     return [...this.agents.values()].sort(
       (a, b) => b.startedAt - a.startedAt,
     );
   }
 
+  /** Restore terminal records persisted by a parent branch without runtime handles. */
+  restoreCompleted(records: readonly unknown[]): void {
+    const latest = new Map<string, ReturnType<typeof this.createRestoredRecord>>();
+    for (const value of records) {
+      if (isRestorableAgentRecord(value)) {
+        latest.set(value.id, this.createRestoredRecord(value));
+      }
+    }
+
+    for (const [id, restored] of latest) {
+      const existing = this.agents.get(id);
+      if (existing?.status === "running" || existing?.status === "queued") continue;
+      this.agents.set(id, restored);
+    }
+  }
+
+  private createRestoredRecord(record: {
+    id: string;
+    type: string;
+    description: string;
+    status: RestorableAgentStatus;
+    startedAt: number;
+    completedAt: number;
+    result?: string;
+    error?: string;
+    toolUses?: number;
+    lifetimeUsage?: { input: number; output: number; cacheWrite: number };
+    transcriptPath?: string;
+  }): AgentRecord {
+    return {
+      id: record.id,
+      type: record.type,
+      description: record.description,
+      status: record.status,
+      result: record.result,
+      error: record.error,
+      toolUses: record.toolUses ?? 0,
+      startedAt: record.startedAt,
+      completedAt: record.completedAt,
+      transcriptPath: record.transcriptPath,
+      lifetimeUsage: record.lifetimeUsage
+        ? { ...record.lifetimeUsage }
+        : { input: 0, output: 0, cacheWrite: 0 },
+      compactionCount: 0,
+    };
+  }
+
   abort(id: string): boolean {
     const record = this.agents.get(id);
     if (!record) return false;

package/src/agent-runner.ts

@@ -6,7 +6,7 @@ import { readFileSync } from "node:fs";
 import { homedir } from "node:os";
 import { basename, dirname, isAbsolute, join, resolve } from "node:path";
 import type { Model } from "@earendil-works/pi-ai";
-import type { ExtensionContext, LoadExtensionsResult } from "@earendil-works/pi-coding-agent";
+import type { ExtensionContext, LoadExtensionsResult, ModelRuntime } from "@earendil-works/pi-coding-agent";
 import {
   type AgentSession,
   type AgentSessionEvent,
@@ -785,25 +785,17 @@ export async function runAgent(
   // Pi 0.80.8 replaced createAgentSession's modelRegistry option with
   // modelRuntime, but ExtensionContext still exposes only the registry facade.
   // Pass both so the full supported Pi range retains the parent's providers.
-  const parentModelRuntime = (ctx.modelRegistry as unknown as { runtime?: unknown }).runtime;
-  type CreateAgentSessionOptions = NonNullable<Parameters<typeof createAgentSession>[0]>;
-  // `modelRuntime` was added in Pi 0.80.8. Infer it when available, while
-  // falling back to unknown for older Pi declarations.
-  type CompatibleModelRuntime = CreateAgentSessionOptions extends {
-    modelRuntime?: infer Runtime;
-  } ? Runtime : unknown;
-  const sessionOpts: CreateAgentSessionOptions & {
+  const parentModelRuntime = (ctx.modelRegistry as unknown as { runtime?: ModelRuntime | null }).runtime ?? undefined;
+  const sessionOpts: Parameters<typeof createAgentSession>[0] & {
     modelRegistry: ExtensionContext["modelRegistry"];
-    modelRuntime?: CompatibleModelRuntime;
+    modelRuntime?: ModelRuntime;
   } = {
     cwd: effectiveCwd,
     agentDir,
     sessionManager,
     settingsManager,
     modelRegistry: ctx.modelRegistry,
-    ...(parentModelRuntime != null && {
-      modelRuntime: parentModelRuntime as CompatibleModelRuntime,
-    }),
+    ...(parentModelRuntime !== undefined && { modelRuntime: parentModelRuntime }),
     model,
     tools: sessionTools,
     resourceLoader: loader,