surgent 0.7.0-alpha.0

package/src/questionnaire/types.ts

@@ -0,0 +1,47 @@
+export interface QuestionOption {
+  text: string;
+  description?: string;
+  exclusive?: boolean;
+}
+
+export interface Question {
+  prompt: string;
+  reason?: string;
+  options?: QuestionOption[];
+
+  placeholder: string;
+  multi?: boolean;
+  recommendedCount?: number;
+
+  minSelections?: number;
+  maxSelections?: number;
+}
+
+export interface QuestionnaireResult {
+  cancelled: boolean;
+  questions: string[];
+  answers: string[];
+}
+
+export interface NormalizedQuestion {
+  prompt: string;
+  reason?: string;
+  options: QuestionOption[];
+  placeholder: string;
+  multi: boolean;
+  recommendedCount?: number;
+  minSelections: number;
+  maxSelections: number;
+}
+
+export interface QuestionDraft {
+  text: string;
+  selectedIndexes: number[];
+  cursor: number;
+  editing: boolean;
+}
+
+export interface ToggleSelectionResult {
+  selectedIndexes: number[];
+  message?: string;
+}

package/src/redactor/index.ts

@@ -0,0 +1,34 @@
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { isToolCallEventType } from "@earendil-works/pi-coding-agent";
+import { containSecrets, replaceSecrets } from "./secrets.js";
+
+export default function (pi: ExtensionAPI) {
+  pi.on("tool_call", async (event, _ctx) => {
+    if (isToolCallEventType("write", event)) {
+      if (containSecrets(event.input.content ?? "")) {
+        return { block: true, reason: "Secrets detected in content to be written" };
+      }
+    } else if (isToolCallEventType("edit", event)) {
+      const edits: Array<{ oldText?: string; newText?: string }> =
+        (event.input as { edits?: Array<{ oldText?: string; newText?: string }> }).edits ?? [];
+
+      for (const edit of edits) {
+        if (containSecrets(edit.newText ?? "")) {
+          return { block: true, reason: "Secrets detected in edit content" };
+        }
+      }
+    }
+  });
+
+  pi.on("tool_result", async (event, _ctx) => {
+    if (event.toolName !== "read" && event.toolName !== "bash" && event.toolName !== "grep") return;
+
+    const content = event.content.map((block) => {
+      if (block.type !== "text") return block;
+      const redactedText = replaceSecrets(block.text);
+      return { ...block, text: redactedText };
+    });
+
+    return { details: event.details, isError: event.isError, content };
+  });
+}

package/src/redactor/patterns.ts

@@ -0,0 +1,234 @@
+interface SecretPattern {
+  name: string;
+  pattern: RegExp;
+  severe: boolean;
+}
+
+export const SECRET_PATTERNS: SecretPattern[] = [
+  // ── AWS ──
+  {
+    name: "AWS Access Key",
+    pattern: /(?<![A-Z0-9])(AKIA[0-9A-Z]{16})(?![A-Z0-9])/,
+    severe: true,
+  },
+  {
+    name: "AWS Secret Key",
+    pattern: /aws[_\-]?secret[_\-]?(?:access[_\-]?)?key["':\s=]+([A-Za-z0-9\/+]{40})/i,
+    severe: true,
+  },
+
+  // ── GCP ──
+  {
+    name: "GCP API Key",
+    pattern: /AIza[0-9A-Za-z\-_]{35}/,
+    severe: true,
+  },
+
+  // ── GitHub ──
+  {
+    name: "GitHub Token (classic)",
+    pattern: /ghp_[A-Za-z0-9]{36}/,
+    severe: true,
+  },
+  {
+    name: "GitHub Fine-grained Token",
+    pattern: /github_pat_[A-Za-z0-9_]{82}/,
+    severe: true,
+  },
+  {
+    name: "GitHub OAuth Token",
+    pattern: /gho_[A-Za-z0-9]{36}/,
+    severe: true,
+  },
+
+  // ── Stripe ──
+  {
+    name: "Stripe Secret Key",
+    pattern: /sk_live_[0-9a-zA-Z]{24,}/,
+    severe: true,
+  },
+  {
+    name: "Stripe Publishable Key",
+    pattern: /pk_live_[0-9a-zA-Z]{24,}/,
+    severe: true,
+  },
+  {
+    name: "Stripe Test Key",
+    pattern: /sk_test_[0-9a-zA-Z]{24,}/,
+    severe: false,
+  },
+
+  // ── Twilio ──
+  {
+    name: "Twilio Account SID",
+    pattern: /twilio.*?account[_\-]?sid["':\s=]+([AC][0-9a-fA-F]{32})/is,
+    severe: true,
+  },
+  {
+    name: "Twilio Auth Token",
+    pattern: /twilio.*?auth.*?token["':\s=]+([a-f0-9]{32})/i,
+    severe: true,
+  },
+
+  // ── SendGrid ──
+  {
+    name: "SendGrid API Key",
+    pattern: /SG\.[A-Za-z0-9_\-]{22}\.[A-Za-z0-9_\-]{43}/,
+    severe: true,
+  },
+
+  // ── Mailgun ──
+  {
+    name: "Mailgun API Key",
+    pattern: /key-[0-9a-zA-Z]{32}/,
+    severe: true,
+  },
+
+  // ── Slack ──
+  {
+    name: "Slack Bot Token",
+    pattern: /xoxb-[0-9]{11,13}-[0-9]{11,13}-[a-zA-Z0-9]{24}/,
+    severe: true,
+  },
+  {
+    name: "Slack User Token",
+    pattern: /xoxp-[0-9]+-[0-9]+-[0-9]+-[a-f0-9]+/,
+    severe: true,
+  },
+  {
+    name: "Slack Webhook URL",
+    pattern: /https:\/\/hooks\.slack\.com\/services\/[A-Z0-9]+\/[A-Z0-9]+\/[a-zA-Z0-9]+/,
+    severe: true,
+  },
+
+  // ── Firebase ──
+  {
+    name: "Firebase API Key",
+    pattern: /"apiKey"\s*:\s*"(AIza[0-9A-Za-z\-_]{35})"/,
+    severe: true,
+  },
+
+  // ── JWT ──
+  {
+    name: "JWT Token",
+    pattern: /eyJ[A-Za-z0-9_\-]{10,}\.[A-Za-z0-9_\-]{10,}\.[A-Za-z0-9_\-]{10,}/,
+    severe: true,
+  },
+
+  // ── OAuth / Generic ──
+  {
+    name: "OAuth Client Secret",
+    pattern: /client[_\-]?secret["':\s=]+([A-Za-z0-9_\-]{20,80})/i,
+    severe: true,
+  },
+  {
+    name: "OAuth Client ID",
+    pattern: /client[_\-]?id["':\s=]+([A-Za-z0-9_\-]{15,60})/i,
+    severe: false,
+  },
+
+  // ── Authorization Headers ──
+  {
+    name: "Hardcoded Authorization Header",
+    pattern:
+      /["']Authorization["']\s*:\s*["'](?:Bearer|Basic|Token)\s+([A-Za-z0-9+\/=_.\-]{20,})["']/,
+    severe: true,
+  },
+  {
+    name: "Hardcoded X-API-Key Header",
+    pattern: /["']x-api-key["']\s*:\s*["']([A-Za-z0-9_\-]{20,80})["']/i,
+    severe: true,
+  },
+
+  // ── Private Keys ──
+  {
+    name: "RSA Private Key",
+    pattern: /-----BEGIN RSA PRIVATE KEY-----/,
+    severe: true,
+  },
+  {
+    name: "EC Private Key",
+    pattern: /-----BEGIN EC PRIVATE KEY-----/,
+    severe: true,
+  },
+  {
+    name: "Private Key (generic)",
+    pattern: /-----BEGIN PRIVATE KEY-----/,
+    severe: true,
+  },
+
+  // ── Crypto / Web3 ──
+  {
+    name: "Ethereum Private Key",
+    pattern: /(?:0x)?[0-9a-fA-F]{64}/,
+    severe: true,
+  },
+  {
+    name: "Mnemonic Phrase",
+    pattern: /(?:mnemonic|seed[_\s]?phrase)["']?\s*[:=]\s*["']([^"']{20,})["']/i,
+    severe: true,
+  },
+
+  // ── Database URIs ──
+  {
+    name: "MongoDB URI",
+    pattern: /mongodb(?:\+srv)?:\/\/[^\s"'<>]+/,
+    severe: true,
+  },
+  {
+    name: "PostgreSQL URI",
+    pattern: /postgres(?:ql)?:\/\/[^\s"'<>]+/i,
+    severe: true,
+  },
+  {
+    name: "MySQL URI",
+    pattern: /mysql:\/\/[^\s"'<>]+/,
+    severe: true,
+  },
+  {
+    name: "Redis URI",
+    pattern: /rediss?:\/\/[^\s"'<>]+/,
+    severe: true,
+  },
+
+  // ── Cloud Storage ──
+  {
+    name: "AWS S3 Bucket URL",
+    pattern: /https?:\/\/[a-z0-9.\-]+\.s3(?:[\-\.][a-z0-9\-]+)?\.amazonaws\.com/i,
+    severe: false,
+  },
+  {
+    name: "GCS Bucket URL",
+    pattern: /https:\/\/storage\.googleapis\.com\/[a-z0-9_.\-]+/,
+    severe: false,
+  },
+  {
+    name: "Azure Blob Storage URL",
+    pattern: /https:\/\/[a-z0-9]+\.blob\.core\.windows\.net\/[^\s"'<>]+/i,
+    severe: false,
+  },
+
+  // ── Internal URLs with credentials ──
+  {
+    name: "URL with Embedded Credentials",
+    pattern: /https?:\/\/[^:@\s"']+:[^@\s"']+@[^\s"'<>]+/,
+    severe: true,
+  },
+
+  // ── Generic secrets (with entropy check) ──
+  {
+    name: "Generic API Key",
+    pattern: /(?:api[_\-]?key|apikey)["']?\s*[:=]\s*["']([A-Za-z0-9_\-]{20,60})["']/i,
+    severe: false,
+  },
+  {
+    name: "Generic Secret",
+    pattern: /(?:secret|client_secret)["']?\s*[:=]\s*["']([A-Za-z0-9_\-+\/]{20,80})["']/i,
+    severe: false,
+  },
+  {
+    name: "Generic Password",
+    pattern: /(?:password|passwd|pwd)["']?\s*[:=]\s*["']([^"']{8,50})["']/i,
+    severe: false,
+  },
+];

package/src/redactor/secrets.ts

@@ -0,0 +1,113 @@
+import { SECRET_PATTERNS } from "./patterns.js";
+
+const ENTROPY_THRESHOLDS = { hex: 3.2, b64: 4.2, any: 3.8 };
+const ENTROPY_SECRET_PATTERN =
+  /(?:token|secret|key|password|credential|auth|api|private)[_\-]?[a-z]*["']?\s*[:=]\s*["']?([A-Za-z0-9+\/=\-_]{20,120})/gi;
+
+function shannonEntropy(value: string): number {
+  const characterFrequencies = new Map<string, number>();
+  for (const character of value) {
+    characterFrequencies.set(character, (characterFrequencies.get(character) ?? 0) + 1);
+  }
+
+  let entropy = 0;
+  for (const count of characterFrequencies.values()) {
+    const probability = count / value.length;
+    entropy -= probability * Math.log2(probability);
+  }
+
+  return entropy;
+}
+
+function isHighEntropy(value: string, minimumLength = 20): boolean {
+  if (value.length < minimumLength) return false;
+  const entropy = shannonEntropy(value);
+  if (/^[0-9a-fA-F]+$/.test(value)) return entropy > ENTROPY_THRESHOLDS.hex;
+  if (/^[A-Za-z0-9+/=_\-]+$/.test(value)) return entropy > ENTROPY_THRESHOLDS.b64;
+  return entropy > ENTROPY_THRESHOLDS.any;
+}
+
+function isFalsePositive(value: string): boolean {
+  const normalized = value.toLowerCase().trim();
+  if (/^[a-z_\-]+$/.test(normalized)) return true;
+  if (/^[\d.]+$/.test(normalized)) return true;
+  if (new Set(normalized.replace(/[-_]/g, "")).size < 3) return true;
+  return false;
+}
+
+// Sub-milisecond overhead
+export function containSecrets(input: string): boolean {
+  for (const { pattern, severe } of SECRET_PATTERNS) {
+    const match = pattern.exec(input);
+    if (!match) continue;
+    const value = match[1] ?? match[0];
+    if (value.length < 8 || isFalsePositive(value) || (!severe && !isHighEntropy(value))) continue;
+    return true;
+  }
+
+  let match: RegExpExecArray | null;
+  ENTROPY_SECRET_PATTERN.lastIndex = 0;
+
+  while ((match = ENTROPY_SECRET_PATTERN.exec(input)) !== null) {
+    const value = match[1] ?? "";
+    if (value && !isFalsePositive(value) && isHighEntropy(value)) return true;
+  }
+
+  return false;
+}
+
+export function replaceSecrets(input: string): string {
+  const replacements: Array<{ start: number; end: number }> = [];
+
+  for (const { pattern, severe } of SECRET_PATTERNS) {
+    const globalPattern = new RegExp(
+      pattern.source,
+      pattern.flags.includes("g") ? pattern.flags : `${pattern.flags}g`,
+    );
+    let match: RegExpExecArray | null;
+
+    while ((match = globalPattern.exec(input)) !== null) {
+      const value = match[1] ?? match[0];
+      if (value.length < 8 || isFalsePositive(value) || (!severe && !isHighEntropy(value)))
+        continue;
+
+      if (match[1]) {
+        const capturedValueOffset = match[0].indexOf(match[1]);
+        if (capturedValueOffset >= 0) {
+          replacements.push({
+            start: match.index + capturedValueOffset,
+            end: match.index + capturedValueOffset + match[1].length,
+          });
+          continue;
+        }
+      }
+
+      replacements.push({ start: match.index, end: match.index + match[0].length });
+    }
+  }
+
+  let entropyMatch: RegExpExecArray | null;
+  ENTROPY_SECRET_PATTERN.lastIndex = 0;
+  while ((entropyMatch = ENTROPY_SECRET_PATTERN.exec(input)) !== null) {
+    const value = entropyMatch[1] ?? "";
+    if (!value || isFalsePositive(value) || !isHighEntropy(value)) continue;
+
+    const capturedValueOffset = entropyMatch[0].indexOf(value);
+    if (capturedValueOffset < 0) continue;
+
+    replacements.push({
+      start: entropyMatch.index + capturedValueOffset,
+      end: entropyMatch.index + capturedValueOffset + value.length,
+    });
+  }
+
+  let redacted = input;
+  let nextAppliedStart = input.length + 1;
+  for (const replacement of replacements.sort((first, second) => second.start - first.start)) {
+    if (replacement.end > nextAppliedStart) continue;
+    redacted = `${redacted.slice(0, replacement.start)}(redacted texts)${redacted.slice(replacement.end)}`;
+    nextAppliedStart = replacement.start;
+  }
+
+  return redacted;
+}

package/src/subagent/helpers.ts

@@ -0,0 +1,93 @@
+import type {
+  AgentSession,
+  ExtensionContext,
+  InlineExtension,
+} from "@earendil-works/pi-coding-agent";
+import type { SubsessionResult, SubsessionSnapshot } from "./types.js";
+import type { AgentMeta } from "../agent/types.js";
+import { createQuestionnaireTool } from "../questionnaire/index.js";
+import { enforceToolPermission } from "../permission/index.js";
+import { readAgentMode } from "../permission/storage.js";
+import webFetchTool from "../web-tools/web-fetch/index.js";
+import webSearchTool from "../web-tools/web-search/index.js";
+
+const PATH_TOOLS = new Set(["read", "write", "edit", "grep", "find", "ls"]);
+
+export function createSubsessionBridge(
+  ctx: ExtensionContext,
+  agentMeta: AgentMeta,
+  sessionId: string,
+): InlineExtension {
+  return {
+    name: "subsession-bridge",
+    factory(pi) {
+      pi.registerTool(createQuestionnaireTool(ctx));
+      pi.registerTool(webFetchTool);
+      pi.registerTool(webSearchTool);
+
+      pi.on("tool_call", async (event) => {
+        const path = (event.input as { path?: unknown }).path;
+        if (PATH_TOOLS.has(event.toolName) && typeof path !== "string") {
+          return { block: true, reason: "Explicit path required in subsession" };
+        }
+
+        const agentMode = await readAgentMode();
+        return enforceToolPermission(pi, event, ctx, agentMeta, sessionId, agentMode);
+      });
+    },
+  };
+}
+
+function formatUsageCount(value: number): string {
+  if (value >= 10000) {
+    return `${Math.trunc(value / 1000)}k`;
+  }
+  return `${(value / 1000).toFixed(1)}k`;
+}
+
+export function formatSnapshotText(snapshot: SubsessionSnapshot): string[] {
+  const context = snapshot.contextUsage?.percent;
+  const recentToolCalls = snapshot.toolsUsed.slice(-5);
+  const lines = [
+    `tools_used=${snapshot.usage.toolCalls} | in=${formatUsageCount(snapshot.usage.input)} | out=${formatUsageCount(snapshot.usage.output)} | cost=$${snapshot.usage.cost.toFixed(3)} | ctx=${context === null || context === undefined ? "n/a" : `${context.toFixed(1)}%`}`,
+  ];
+
+  for (let toolCallIndex = 0; toolCallIndex < recentToolCalls.length; toolCallIndex += 1) {
+    const branchIndicator = toolCallIndex === recentToolCalls.length - 1 ? "└─" : "├─";
+    lines.push(`${branchIndicator} ${recentToolCalls[toolCallIndex]}`);
+  }
+
+  return lines;
+}
+
+export function createErrorResult(message: string): SubsessionResult {
+  return {
+    status: "error",
+    output: message,
+    usage: { input: 0, output: 0, toolCalls: 0, cost: 0 },
+    toolCounts: {},
+  };
+}
+
+export function formatToolUse(name: string, argumentsValue: unknown): string {
+  if (!argumentsValue || typeof argumentsValue !== "object") {
+    return `${name}()`;
+  }
+  try {
+    return `${name}(${JSON.stringify(argumentsValue)})`;
+  } catch {
+    return `${name}(<args>)`;
+  }
+}
+
+export function getLastAssistantOutput(session: AgentSession): string {
+  for (const message of [...session.messages].reverse()) {
+    if (message.role !== "assistant") continue;
+    for (const contentPart of [...message.content].reverse()) {
+      if (contentPart.type === "text") {
+        return contentPart.text;
+      }
+    }
+  }
+  return "";
+}

package/src/subagent/index.ts

@@ -0,0 +1,81 @@
+import { type ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { Container, Text, TruncatedText } from "@earendil-works/pi-tui";
+import { Type } from "typebox";
+import { openSubsession } from "./subsession.js";
+import { formatSnapshotText } from "./helpers.js";
+import type { SubsessionRequest, SubsessionSnapshot } from "./types.js";
+import { renderResultText } from "../utils.js";
+
+export default function (pi: ExtensionAPI) {
+  pi.registerTool({
+    name: "subagent",
+    label: "Subagent",
+    description:
+      "Delegate bounded, self-contained work to a configured agent. Choose by agent description, provide complete context and expected output, batch independent calls, and do not duplicate delegated work.",
+    promptSnippet: "Offload bounded, context-heavy work to configured agents",
+    parameters: Type.Object({
+      agent: Type.String({ description: "Configured agent profile selected by its description" }),
+      task: Type.String({
+        description:
+          "Standalone task with outcome, scope, known context, constraints, expected output, and done condition",
+      }),
+    }),
+    async execute(_toolCallId, params, signal, onUpdate, ctx) {
+      let snapshot: SubsessionSnapshot | undefined;
+      const request: SubsessionRequest = {
+        ctx,
+        label: "subagent",
+        agent: params.agent,
+        signal,
+        onSnapshot: (nextSnapshot) => {
+          snapshot = nextSnapshot;
+          onUpdate?.({ content: [], details: nextSnapshot });
+        },
+      };
+
+      const subsession = await openSubsession(request);
+      try {
+        if (subsession.result.status !== "error") {
+          await subsession.exec(params.task, signal);
+        }
+        return {
+          content: [{ type: "text", text: subsession.result.output || subsession.result.status }],
+          details: snapshot ?? { status: subsession.result.status, usage: subsession.result.usage },
+        };
+      } finally {
+        await subsession.dispose();
+      }
+    },
+    renderCall(args, theme) {
+      return new Text(
+        `${theme.fg("toolTitle", "subagent")} ${theme.fg("accent", `"${args.task}"`)}\n`,
+        0,
+        0,
+      );
+    },
+    renderResult(result, { expanded, isPartial }, theme, context) {
+      if (!isPartial) {
+        const output = result.content[0];
+        const text = output?.type === "text" ? output.text : "";
+        return renderResultText(text, theme, expanded);
+      }
+
+      const snapshot = result.details as SubsessionSnapshot | undefined;
+      if (!snapshot?.toolsUsed) {
+        return new Text(theme.fg("toolOutput", `Subagent ${context.args.agent}: starting`), 0, 0);
+      }
+
+      const lines = [
+        theme.bold(`${context.args.agent}: ${snapshot.status}`),
+        ...formatSnapshotText(snapshot).map((line) => `  ${line}`),
+      ];
+
+      const output = new Container();
+      for (const line of lines) {
+        output.addChild(new TruncatedText(theme.fg("toolOutput", line), 1, 0));
+      }
+
+      return output;
+    },
+  });
+}

package/src/subagent/storage.ts

@@ -0,0 +1,100 @@
+import { SessionManager } from "@earendil-works/pi-coding-agent";
+import { isBuiltIn, loadAgents } from "../agent/storage.js";
+import { getPiPath, readJson, writeJson } from "../utils.js";
+import type { StoredSubsessions, RuntimeConfig, Subsession } from "./types.js";
+import { unlink } from "node:fs/promises";
+
+const MARKDOWN_HEADING_PATTERN = /^\s*#\s+(.+?)\s*$/m;
+
+function extractSubsessionTitle(output: string): string | undefined {
+  const headingMatch = output.match(MARKDOWN_HEADING_PATTERN);
+  if (!headingMatch) return;
+
+  const headingText = headingMatch[1]?.trim();
+  if (!headingText) return;
+
+  const separatorIdx = headingText.indexOf(":");
+  const title = separatorIdx >= 0 ? headingText.slice(separatorIdx + 1).trim() : headingText;
+  if (!title) return;
+
+  return title;
+}
+
+export async function findSubsessionFile(cwd: string, id: string) {
+  const dir = getPiPath("subsessionsDir", cwd);
+  const sessions = await SessionManager.list(cwd, dir);
+  const session = sessions.find((item) => item.id === id);
+  if (session) return { path: session.path, dir };
+}
+
+async function loadStore(cwd: string) {
+  return readJson<StoredSubsessions>(getPiPath("subsessions", cwd), {});
+}
+
+export async function findSubsession(cwd: string, id?: string, pid?: string) {
+  if (!id) return null;
+  const subsessions = await loadStore(cwd);
+  const found = subsessions[id];
+  if (!found || (pid && found.pid !== pid)) return null;
+  return found;
+}
+
+export async function saveSubsession(cwd: string, subsession: Subsession) {
+  if (!subsession.result.id || subsession.label === "subagent") return;
+  if (subsession.result.status === "done") {
+    subsession.title = extractSubsessionTitle(subsession.result.output) ?? "Untitled";
+  }
+
+  const subsessions = await loadStore(cwd);
+  subsessions[subsession.result.id] = {
+    agent: subsession.runtime.agent,
+    label: subsession.label,
+    pid: subsession.pid,
+    title: subsession.title,
+    usage: subsession.result.usage,
+  };
+  await writeJson(getPiPath("subsessions", cwd), subsessions);
+}
+
+export async function loadSubsessionOutput(cwd: string, id: string): Promise<string> {
+  try {
+    const file = await findSubsessionFile(cwd, id);
+    if (!file) return "";
+
+    const sessionManager = SessionManager.open(file.path, file.dir, cwd);
+    const branchEntries = sessionManager.getBranch();
+
+    for (let entryIndex = branchEntries.length - 1; entryIndex >= 0; entryIndex -= 1) {
+      const branchEntry = branchEntries[entryIndex];
+      if (!branchEntry || branchEntry.type !== "message") continue;
+
+      const message = branchEntry.message;
+      if (message.role !== "assistant") continue;
+
+      for (let idx = message.content.length - 1; idx >= 0; idx -= 1) {
+        const contentPart = message.content[idx] as { type?: unknown; text?: unknown };
+        if (contentPart.type === "text" && typeof contentPart.text === "string") {
+          return contentPart.text;
+        }
+      }
+    }
+    return "";
+  } catch {
+    return "";
+  }
+}
+
+export async function terminateSubsession(cwd: string, id: string) {
+  const subsessions = await loadStore(cwd);
+  delete subsessions[id];
+  await writeJson(getPiPath("subsessions", cwd), subsessions);
+
+  const file = await findSubsessionFile(cwd, id);
+  if (!file) return;
+  await unlink(file.path);
+}
+
+export async function resolveRuntime(cwd: string, agent: string): Promise<RuntimeConfig> {
+  const [cfg] = await loadAgents(cwd, agent);
+  return { agent, builtIn: isBuiltIn(cfg.filePath), meta: cfg.meta, systemPrompt: cfg.body };
+}