@fitchmultz/pi-subagents 0.49.1 → 0.51.0

package/src/shared/fork-context.ts

@@ -1,72 +0,0 @@
-import * as fs from "node:fs";
-import { SessionManager } from "@earendil-works/pi-coding-agent";
-import { requestChildExecutionCwd } from "../runs/shared/child-execution-cwd.ts";
-import { errorMessage } from "./unknown.ts";
-
-type SubagentExecutionContext = "fresh" | "fork";
-
-interface ForkableSessionManager {
-  readonly getSessionFile: () => string | undefined;
-  readonly getLeafId: () => string | null;
-  readonly getSessionDir: () => string;
-}
-
-interface ForkContextResolver {
-  readonly sessionFileForIndex: (index?: number) => string | undefined;
-}
-
-export function resolveSubagentContext(value?: unknown): SubagentExecutionContext {
-  return value === "fork" ? "fork" : "fresh";
-}
-
-export function createForkContextResolver(
-  sessionManager: ForkableSessionManager,
-): ForkContextResolver {
-  const parentSessionFile = sessionManager.getSessionFile();
-  if (parentSessionFile === undefined || parentSessionFile === "") {
-    throw new Error("Forked subagent context requires a persisted parent session.");
-  }
-
-  const leafId = sessionManager.getLeafId();
-  if (leafId === null || leafId === "") {
-    throw new Error("Forked subagent context requires a current leaf to fork from.");
-  }
-
-  const sessionDir = sessionManager.getSessionDir();
-  const cachedSessionFiles = new Map<number, string>();
-
-  return {
-    sessionFileForIndex(index = 0): string | undefined {
-      const cached = cachedSessionFiles.get(index);
-      if (cached !== undefined && cached !== "") {
-        return cached;
-      }
-      try {
-        if (!fs.existsSync(parentSessionFile)) {
-          throw new Error(
-            `Parent session file does not exist: ${parentSessionFile}. Pi has not persisted enough history to fork yet.`,
-          );
-        }
-        const sessionFile = SessionManager.open(
-          parentSessionFile,
-          sessionDir,
-        ).createBranchedSession(leafId);
-        if (sessionFile === undefined || sessionFile === "") {
-          throw new Error("Session manager did not return a forked session file.");
-        }
-        if (!fs.existsSync(sessionFile)) {
-          throw new Error(
-            `Session manager returned a forked session file that does not exist: ${sessionFile}`,
-          );
-        }
-        requestChildExecutionCwd(sessionFile);
-        cachedSessionFiles.set(index, sessionFile);
-        return sessionFile;
-      } catch (error) {
-        throw new Error(`Failed to create forked subagent session: ${errorMessage(error)}`, {
-          cause: error,
-        });
-      }
-    },
-  };
-}

package/src/shared/formatters.ts

@@ -1,125 +0,0 @@
-/**
- * Formatting utilities for display output
- */
-
-import type { Usage } from "./types.ts";
-import { splitKnownThinkingSuffix, THINKING_LEVELS } from "./model-info.ts";
-import type { ReadonlyDeep } from "type-fest";
-
-/**
- * Format token count with k suffix for large numbers
- */
-export function formatTokens(n: number): string {
-  if (n < 1000) {
-    return String(n);
-  }
-  return n < 10000 ? `${(n / 1000).toFixed(1)}k` : `${Math.round(n / 1000)}k`;
-}
-
-export function formatModelThinking(model?: string, thinking?: string): string {
-  const parsed = model !== undefined && model !== "" ? splitKnownThinkingSuffix(model) : undefined;
-  const displayModel = parsed?.baseModel ?? model;
-  const explicitThinking = THINKING_LEVELS.find((level) => level === thinking?.trim());
-  const displayThinking =
-    parsed?.thinkingSuffix !== undefined && parsed.thinkingSuffix !== ""
-      ? parsed.thinkingSuffix.slice(1)
-      : explicitThinking;
-  return [
-    displayModel,
-    displayThinking !== undefined && displayThinking !== ""
-      ? `thinking ${displayThinking}`
-      : undefined,
-  ]
-    .filter(Boolean)
-    .join(" · ");
-}
-
-function hasUsageValue(value: number): boolean {
-  return value !== 0 && !Number.isNaN(value);
-}
-
-/**
- * Format usage statistics into a compact string
- */
-export function formatUsage(u: ReadonlyDeep<Usage>, model?: string): string {
-  const parts: string[] = [];
-  if (hasUsageValue(u.turns)) {
-    parts.push(`${u.turns} turn${u.turns > 1 ? "s" : ""}`);
-  }
-  if (hasUsageValue(u.input)) {
-    parts.push(`in:${formatTokens(u.input)}`);
-  }
-  if (hasUsageValue(u.output)) {
-    parts.push(`out:${formatTokens(u.output)}`);
-  }
-  if (hasUsageValue(u.cacheRead)) {
-    parts.push(`R${formatTokens(u.cacheRead)}`);
-  }
-  if (hasUsageValue(u.cacheWrite)) {
-    parts.push(`W${formatTokens(u.cacheWrite)}`);
-  }
-  if (hasUsageValue(u.cost)) {
-    parts.push(`$${u.cost.toFixed(4)}`);
-  }
-  if (model !== undefined && model !== "") {
-    parts.push(model);
-  }
-  return parts.join(" ");
-}
-
-/**
- * Format duration in human-readable form
- */
-export function formatDuration(ms: number): string {
-  if (ms < 1000) {
-    return `${ms}ms`;
-  }
-  if (ms < 60000) {
-    return `${(ms / 1000).toFixed(1)}s`;
-  }
-  return `${Math.floor(ms / 60000)}m${Math.floor((ms % 60000) / 1000)}s`;
-}
-
-/**
- * Format a tool call for display
- */
-export function formatToolCall(
-  name: string,
-  args: Readonly<Record<string, unknown>>,
-  expanded = false,
-): string {
-  switch (name) {
-    case "bash": {
-      const command = typeof args.command === "string" ? args.command : "";
-      const maxLength = expanded ? 240 : 60;
-      return `$ ${command.slice(0, maxLength)}${command.length > maxLength ? "..." : ""}`;
-    }
-    case "read":
-    case "write":
-    case "edit": {
-      let target = "";
-      if (typeof args.path === "string") {
-        target = args.path;
-      } else if (typeof args.file_path === "string") {
-        target = args.file_path;
-      }
-      return `${name} ${shortenPath(target)}`;
-    }
-    default: {
-      const s = JSON.stringify(args);
-      const maxLength = expanded ? 160 : 40;
-      return `${name} ${s.slice(0, maxLength)}${s.length > maxLength ? "..." : ""}`;
-    }
-  }
-}
-
-/**
- * Shorten a path by replacing home directory with ~
- */
-export function shortenPath(p: string): string {
-  const home = process.env.HOME;
-  if (home !== undefined && home !== "" && p.startsWith(home)) {
-    return `~${p.slice(home.length)}`;
-  }
-  return p;
-}

package/src/shared/journal-reader.ts

@@ -1,18 +0,0 @@
-// Stable public journal entry point; each module owns one storage responsibility.
-export { JsonProjection, type Projection, type ProjectionLimits } from "./json-projection.ts";
-export {
-  JournalFrames,
-  scanJournal,
-  readJsonProjection,
-  type JournalRecord,
-  type JournalPolicy,
-  type JournalOptions,
-} from "./journal-frames.ts";
-export { ownerProjection, nativeProjection } from "./journal-projections.ts";
-export {
-  NativeJournal,
-  journalStamp,
-  type NativeRecord,
-  type NativePreview,
-} from "./native-journal.ts";
-export { readOutputPage } from "./output-page.ts";

package/src/shared/lazy-tools.ts

@@ -1,85 +0,0 @@
-import { getCurrentSystemMessage } from "@earendil-works/pi-ai";
-import type {
-  ExtensionAPI,
-  ExtensionContext,
-  SessionManager,
-} from "@earendil-works/pi-coding-agent";
-
-const declarations = new WeakMap<
-  ExtensionContext["sessionManager"],
-  {
-    leaf: string | null;
-    count: number | undefined;
-    current: ReturnType<typeof getCurrentSystemMessage>;
-  }
->();
-
-/** Only our unnamespaced tools are owned here; foreign public IDs pass through untouched. */
-export function activateTools(pi: ExtensionAPI, names: readonly string[]): void {
-  const available = pi.getAllTools();
-  const active = pi.getActiveTools();
-  const added = names.filter(
-    (name) =>
-      !active.includes(name) &&
-      available.some(
-        (tool) =>
-          tool.name === name &&
-          !("namespace" in tool && typeof tool.namespace === "string" && tool.namespace !== ""),
-      ),
-  );
-  if (added.length > 0) {
-    pi.setActiveTools([...active, ...new Set(added)]);
-  }
-}
-
-/** Official 1.0 SDK creation omits initial resume restoration; tree/reload are native. */
-export function restoreLazyTools(
-  pi: ExtensionAPI,
-  ctx: ExtensionContext,
-  loader: string,
-  names: readonly string[],
-): void {
-  const available = pi.getAllTools();
-  // A tool-only allowlist must remain usable without its discovery entry.
-  if (
-    !available.some(
-      (tool) =>
-        tool.name === loader &&
-        !("namespace" in tool && typeof tool.namespace === "string" && tool.namespace !== ""),
-    )
-  ) {
-    activateTools(pi, names);
-    return;
-  }
-  const manager = ctx.sessionManager,
-    leaf = manager.getLeafId(),
-    count = (manager as Partial<SessionManager>).getEntryCount?.();
-  let cached = declarations.get(manager);
-  if (count === undefined || !cached || cached.leaf !== leaf || cached.count !== count) {
-    cached = {
-      leaf,
-      count,
-      current: getCurrentSystemMessage(manager.buildSessionProjection().messages),
-    };
-    declarations.set(manager, cached);
-  }
-  const declared = cached.current;
-  if (!declared) {
-    return;
-  }
-  const selected = declared.toolsAdded ?? [];
-  const restored = names.filter(
-    (name) =>
-      selected.some(
-        (tool) =>
-          tool.name === name &&
-          !("namespace" in tool && typeof tool.namespace === "string" && tool.namespace !== ""),
-      ) &&
-      available.some(
-        (tool) =>
-          tool.name === name &&
-          !("namespace" in tool && typeof tool.namespace === "string" && tool.namespace !== ""),
-      ),
-  );
-  activateTools(pi, restored);
-}

package/src/shared/message-output.ts

@@ -1,146 +0,0 @@
-import { formatToolCall } from "./formatters.ts";
-import type {
-  DisplayItem,
-  ErrorInfo,
-  ObservedMessage,
-  ReadonlySingleResult,
-  SingleResult,
-  ToolCallSummary,
-} from "./types.ts";
-
-type AssistantObservation = Extract<ObservedMessage, { role: "assistant" }>;
-type ToolObservation = Extract<ObservedMessage, { role: "toolResult" }>;
-function assistantText(message: AssistantObservation): string {
-  if (
-    (message.errorMessage !== undefined && message.errorMessage.length > 0) ||
-    message.stopReason === "error"
-  ) {
-    return "";
-  }
-  for (let j = message.content.length - 1; j >= 0; j--) {
-    const part = message.content[j];
-    if (part.type === "text" && part.text.trim().length > 0) {
-      return part.text;
-    }
-  }
-  return "";
-}
-/** Last non-error assistant text, accepting honest incomplete native observations. */
-export function getFinalOutput(messages: readonly ObservedMessage[]): string {
-  for (let i = messages.length - 1; i >= 0; i--) {
-    const message = messages[i];
-    if (message.role === "assistant") {
-      const text = assistantText(message);
-      if (text !== "") {
-        return text;
-      }
-    }
-  }
-  return "";
-}
-export function getSingleResultOutput(
-  result: Readonly<Pick<SingleResult, "finalOutput" | "messages">>,
-): string {
-  return result.finalOutput ?? getFinalOutput(result.messages ?? []);
-}
-export function formatResourceLimitExceeded(input: {
-  readonly agent: string;
-  readonly kind: "maxExecutionTimeMs" | "maxTokens";
-  readonly limit: number;
-  readonly observed?: number;
-}): string {
-  if (input.kind === "maxExecutionTimeMs") {
-    return `Resource limit exceeded for ${input.agent}: maxExecutionTimeMs ${input.limit}ms.`;
-  }
-  return `Resource limit exceeded for ${input.agent}: maxTokens ${input.limit}${input.observed !== undefined ? ` (observed ${input.observed})` : ""}.`;
-}
-function assistantItems(message: AssistantObservation): DisplayItem[] {
-  return message.content.flatMap((part): DisplayItem[] => {
-    if (part.type === "text") {
-      return [{ type: "text", text: part.text }];
-    }
-    return part.type === "toolCall"
-      ? [{ type: "tool", name: part.name, args: part.arguments }]
-      : [];
-  });
-}
-export function getDisplayItems(messages: readonly ObservedMessage[] | undefined): DisplayItem[] {
-  return (messages ?? []).flatMap((message) =>
-    message.role === "assistant" ? assistantItems(message) : [],
-  );
-}
-function extractToolCallSummaries(
-  messages: readonly ObservedMessage[] | undefined,
-): ToolCallSummary[] {
-  return (messages ?? []).flatMap((message) => {
-    if (message.role !== "assistant") {
-      return [];
-    }
-    return message.content.flatMap((part) =>
-      part.type === "toolCall"
-        ? [
-            {
-              text: formatToolCall(part.name, part.arguments),
-              expandedText: formatToolCall(part.name, part.arguments, true),
-            },
-          ]
-        : [],
-    );
-  });
-}
-export function compactForegroundResult(result: ReadonlySingleResult): ReadonlySingleResult {
-  if (result.progress?.status === "running") {
-    return result;
-  }
-  const toolCalls =
-    result.toolCalls !== undefined && result.toolCalls.length > 0
-      ? result.toolCalls
-      : extractToolCallSummaries(result.messages);
-  return {
-    ...result,
-    messages: undefined,
-    progress: undefined,
-    toolCalls: toolCalls.length > 0 ? toolCalls : undefined,
-  };
-}
-function lastAssistantText(messages: readonly ObservedMessage[]): number {
-  return messages.findLastIndex(
-    (message) =>
-      message.role === "assistant" &&
-      message.content.some((part) => part.type === "text" && part.text.trim().length > 0),
-  );
-}
-function toolExitCode(message: ToolObservation, text: string | undefined): number | undefined {
-  const match = text?.match(/exit(?:ed)?\s*(?:with\s*)?(?:code|status)?\s*[:\s]?\s*(\d+)/i);
-  return message.observedExitCode ?? (match ? parseInt(match[1], 10) : undefined);
-}
-function toolError(message: ToolObservation): ErrorInfo | undefined {
-  const text = message.content.find((part) => part.type === "text")?.text;
-  const code = toolExitCode(message, text);
-  if (message.isError === true) {
-    return {
-      hasError: true,
-      exitCode: code ?? 1,
-      errorType: message.toolName !== "" ? message.toolName : "tool",
-      details: text?.slice(0, 200),
-    };
-  }
-  if (message.toolName === "bash" && text !== undefined && code !== undefined && code !== 0) {
-    return { hasError: true, exitCode: code, errorType: "bash", details: text.slice(0, 200) };
-  }
-  return undefined;
-}
-/** Errors superseded by later assistant success do not fail the result. */
-export function detectSubagentError(messages: readonly ObservedMessage[]): ErrorInfo {
-  const start = lastAssistantText(messages) + 1;
-  for (let i = messages.length - 1; i >= start; i--) {
-    const message = messages[i];
-    if (message.role === "toolResult") {
-      const error = toolError(message);
-      if (error) {
-        return error;
-      }
-    }
-  }
-  return { hasError: false };
-}

package/src/shared/model-info.ts

@@ -1,117 +0,0 @@
-export const THINKING_LEVELS = ["off", "minimal", "low", "medium", "high", "xhigh", "max"] as const;
-import type { ModelInfo, ThinkingLevel, ThinkingLevelMap } from "./types/config.ts";
-export type { ModelInfo, ThinkingLevel, ThinkingLevelMap } from "./types/config.ts";
-
-interface RegistryModelLike {
-  readonly provider: string;
-  readonly id: string;
-  readonly reasoning?: boolean;
-  readonly thinkingLevelMap?: ThinkingLevelMap;
-}
-
-export function toModelInfo(model: RegistryModelLike): ModelInfo {
-  return {
-    provider: model.provider,
-    id: model.id,
-    fullId: `${model.provider}/${model.id}`,
-    reasoning: model.reasoning,
-    thinkingLevelMap: model.thinkingLevelMap,
-  };
-}
-
-export function providerQualifiedModelId(
-  provider: string | undefined,
-  model: string | undefined,
-): string | undefined {
-  if (model === undefined || model.length === 0) {
-    return undefined;
-  }
-  return provider !== undefined && provider.length > 0 && !model.startsWith(`${provider}/`)
-    ? `${provider}/${model}`
-    : model;
-}
-
-/** Resolve the effective thinking level from a model string (which may contain a known suffix like `:high`)
- * and an explicit thinking config value. Returns `undefined` when no thinking is applicable
- * (e.g. no model was specified, or the model has no suffix and no config was provided). */
-export function resolveEffectiveThinking(
-  model: string | undefined,
-  configThinking: string | undefined,
-): string | undefined {
-  if (model === undefined || model.length === 0) {
-    return undefined;
-  }
-  const { thinkingSuffix } = splitKnownThinkingSuffix(model);
-  if (thinkingSuffix.length > 0) {
-    return thinkingSuffix.slice(1);
-  }
-  return THINKING_LEVELS.find((level) => level === configThinking);
-}
-
-export function splitKnownThinkingSuffix(model: string): {
-  baseModel: string;
-  thinkingSuffix: string;
-} {
-  const colonIdx = model.lastIndexOf(":");
-  if (colonIdx === -1) {
-    return { baseModel: model, thinkingSuffix: "" };
-  }
-  const suffix = THINKING_LEVELS.find((level) => level === model.substring(colonIdx + 1));
-  if (suffix === undefined) {
-    return { baseModel: model, thinkingSuffix: "" };
-  }
-  return {
-    baseModel: model.substring(0, colonIdx),
-    thinkingSuffix: `:${suffix}`,
-  };
-}
-
-export function findModelInfo(
-  model: string | undefined,
-  availableModels: readonly ModelInfo[] | undefined,
-  preferredProvider?: string,
-): ModelInfo | undefined {
-  if (
-    model === undefined ||
-    model.length === 0 ||
-    availableModels === undefined ||
-    availableModels.length === 0
-  ) {
-    return undefined;
-  }
-  const { baseModel } = splitKnownThinkingSuffix(model);
-  const exact = availableModels.find((entry) => entry.fullId === baseModel);
-  if (exact) {
-    return exact;
-  }
-
-  const matches = availableModels.filter((entry) => entry.id === baseModel);
-  if (preferredProvider !== undefined && preferredProvider.length > 0) {
-    const preferred = matches.find((entry) => entry.provider === preferredProvider);
-    if (preferred) {
-      return preferred;
-    }
-  }
-  return matches.length === 1 ? matches[0] : undefined;
-}
-
-export function getSupportedThinkingLevels(model: ModelInfo | undefined): ThinkingLevel[] {
-  if (model === undefined) {
-    return [...THINKING_LEVELS];
-  }
-  if (model.reasoning === false) {
-    return ["off"];
-  }
-
-  const levels = THINKING_LEVELS.filter((level) => {
-    const mapped = model.thinkingLevelMap?.[level];
-    if (mapped === null) {
-      return false;
-    }
-    if (level === "xhigh" || level === "max") {
-      return mapped !== undefined;
-    }
-    return true;
-  });
-  return levels;
-}

package/src/shared/native-import.ts

@@ -1,25 +0,0 @@
-import { registerHooks } from "node:module";
-
-/** Resolve only this native Node importer's literal SDK import to the selected host. */
-// ponytail: Jiti rewrites callback imports and loses their originating parent URL.
-// Jiti adapters must use the approved declaration-typed selected URL import boundary.
-export async function importSelectedNative<T>(
-  parentURL: string,
-  specifier: string,
-  targetURL: string,
-  load: () => Promise<T>,
-): Promise<T> {
-  const hooks = registerHooks({
-    resolve(request, context, nextResolve) {
-      if (request === specifier && context.parentURL === parentURL) {
-        return nextResolve(targetURL, context);
-      }
-      return nextResolve(request, context);
-    },
-  });
-  try {
-    return await load();
-  } finally {
-    hooks.deregister();
-  }
-}

package/src/shared/native-session-loader.ts

@@ -1,13 +0,0 @@
-import * as path from "node:path";
-import { pathToFileURL } from "node:url";
-import type * as NativeSession from "@earendil-works/pi-coding-agent";
-
-export async function loadNativeSession(packageRoot: string): Promise<typeof NativeSession> {
-  // The trusted selected Pi package supplies this exact SDK declaration contract.
-  // A computed URL is required: Jiti rewrites literal SDK imports to its own host graph.
-  // oxlint-disable-next-line typescript/no-unsafe-assignment
-  const sessionModule: typeof NativeSession = await import(
-    pathToFileURL(path.join(packageRoot, "dist/index.js")).href
-  );
-  return sessionModule;
-}

package/src/shared/native-session.ts

@@ -1,6 +0,0 @@
-import { requirePiPackageRoot } from "../runs/shared/pi-spawn.ts";
-import { loadNativeSession } from "./native-session-loader.ts";
-
-// Detached Node runners do not get Pi's extension-loader package aliases.
-export const { buildSessionContext, parseSessionEntries, migrateSessionEntries, SessionManager } =
-  await loadNativeSession(requirePiPackageRoot());

package/src/shared/native-tui.ts

@@ -1,20 +0,0 @@
-import { findPackageJSON } from "node:module";
-import * as path from "node:path";
-import { pathToFileURL } from "node:url";
-import type * as NativeTui from "@earendil-works/pi-tui";
-import { requirePiPackageRoot } from "../runs/shared/pi-spawn.ts";
-
-// Detached Node workers use the selected host's TUI, without extension-loader aliases.
-const manifest = findPackageJSON(
-  "@earendil-works/pi-tui",
-  pathToFileURL(path.join(requirePiPackageRoot(), "dist/index.js")),
-);
-if (manifest === undefined || manifest === "") {
-  throw new Error("Could not locate the selected Pi TUI package.");
-}
-const selectedTuiURL = new URL("./dist/utils.js", pathToFileURL(manifest)).href;
-// The trusted selected TUI export implements this exact native string-transform contract.
-// Jiti aliases literal TUI imports to its host, so this selected dependency URL is required.
-// oxlint-disable-next-line typescript/no-unsafe-assignment
-const tui: Pick<typeof NativeTui, "stripTerminalSequences"> = await import(selectedTuiURL);
-export const { stripTerminalSequences } = tui;

package/src/shared/native-typebox.ts

@@ -1,29 +0,0 @@
-import { createRequire } from "node:module";
-import * as path from "node:path";
-import { pathToFileURL } from "node:url";
-import type * as NativeTypebox from "typebox";
-import type * as NativeCompile from "typebox/compile";
-import type * as NativeValue from "typebox/value";
-import { requirePiPackageRoot } from "../runs/shared/pi-spawn.ts";
-
-// Detached Node runners do not get Pi's extension-loader package aliases.
-const require = createRequire(path.join(requirePiPackageRoot(), "dist/index.js"));
-const typeboxURL = pathToFileURL(require.resolve("typebox")).href;
-const compileURL = pathToFileURL(require.resolve("typebox/compile")).href;
-const valueURL = pathToFileURL(require.resolve("typebox/value")).href;
-// This trusted selected-host dependency supplies the actual TypeBox declarations.
-// Jiti aliases literal imports to its own graph, so the resolved URL must remain authoritative.
-// oxlint-disable-next-line typescript/no-unsafe-assignment
-const typebox: typeof NativeTypebox = await import(typeboxURL);
-// The selected host's TypeBox compiler implements this exact native compile contract.
-// A computed URL prevents Jiti from substituting another host's compiler graph.
-// oxlint-disable-next-line typescript/no-unsafe-assignment
-const compile: typeof NativeCompile = await import(compileURL);
-// The selected host's value module implements these native Check/Errors signatures.
-// A computed URL preserves its real dependency graph under Jiti and detached Node.
-// oxlint-disable-next-line typescript/no-unsafe-assignment
-const value: typeof NativeValue = await import(valueURL);
-
-export const { Type } = typebox;
-export const { Compile } = compile;
-export const { Check, Errors } = value;

package/src/shared/prompt-sections.ts

@@ -1,16 +0,0 @@
-import type { NormalizedBuildSystemPromptOptions } from "@earendil-works/pi-coding-agent";
-
-export function setPromptSection(
-  options: NormalizedBuildSystemPromptOptions,
-  name: string,
-  content: string,
-): void {
-  // Pi owns this mutable prompt-building options object. This SDK hook updates
-  // sections and its legacy exact override in place; callers observe the same object.
-  options.sections[name] = content;
-  // Pi projects an earlier exact override instead of sections. Preserve its content;
-  // this compatibility path replaces the leading prompt and cannot preserve its cache prefix.
-  if (options.forceSystemPrompt !== undefined) {
-    options.forceSystemPrompt += `\n\n<${name}>\n${content}\n</${name}>`;
-  }
-}