pim-agent 0.10.0 → 0.12.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pim-agent",
-  "version": "0.10.0",
+  "version": "0.12.0",
   "description": "A batteries-included distro of Pi, accessible in your terminal, browser and Telegram.",
   "license": "MIT",
   "type": "module",
@@ -56,7 +56,6 @@
     "web:dev": "cd packages/web && vite"
   },
   "devDependencies": {
-    "@fontsource/commit-mono": "^5.3.0",
     "@happy-dom/global-registrator": "^20.14.0",
     "@iconify-json/griddy-icons": "^1.2.0",
     "@iconify-json/solar": "^1.2.10",
@@ -76,8 +75,8 @@
     "vite": "^8.2.2"
   },
   "dependencies": {
-    "@earendil-works/pi-coding-agent": "0.85.1",
-    "@earendil-works/pi-server": "0.85.1",
+    "@earendil-works/pi-coding-agent": "0.87.1",
+    "@earendil-works/pi-server": "0.87.1",
     "diff": "^9.0.0",
     "fzf": "^0.5.2",
     "grammy": "^1.46.0",

package/packages/core/src/extensions/apply-patch/model.ts

@@ -4,8 +4,6 @@ type ModelLike = {
   readonly id?: string;
 };
 
-const CLAUDE_APPLY_PATCH_MAJOR = 5;
-
 // Never match a GPT-named non-OpenAI model (`eleutherai/gpt-neo`): a false positive hands it a tool it was not trained on.
 function isGptModel(model: ModelLike | undefined): boolean {
   const provider = (model?.provider ?? "").toLowerCase();
@@ -25,15 +23,6 @@ function isGptModel(model: ModelLike | undefined): boolean {
   );
 }
 
-function claudeMajorVersion(id: string): number | undefined {
-  const match = /(?:^|[/.])claude-[a-z]+-(\d+)/.exec(id);
-  return match ? Number(match[1]) : undefined;
-}
-
 export function prefersApplyPatch(model: ModelLike | undefined): boolean {
-  if (isGptModel(model)) {
-    return true;
-  }
-  const major = claudeMajorVersion((model?.id ?? "").toLowerCase());
-  return major !== undefined && major >= CLAUDE_APPLY_PATCH_MAJOR;
+  return isGptModel(model);
 }

package/packages/core/src/extensions/bash/index.ts

@@ -42,7 +42,8 @@ export default function (pi: ExtensionAPI): void {
     name: "bash",
     label: "bash",
     description:
-      "Execute a bash command in the cwd. " +
+      "Execute a bash command in the cwd from <environment>. " +
+      "Never prefix `cd <cwd> &&`; pass paths relative to cwd or absolute. " +
       "Returns exit code, signal (if any), and stdout/stderr captured separately. " +
       "Stdout that is a png/jpeg/gif/webp is returned as a picture. " +
       "Prefer commands that emit only what you need; keep output as small as possible.",

package/packages/core/src/extensions/bash/run.ts

@@ -14,6 +14,12 @@ type Reader = ReadableStreamDefaultReader<Uint8Array>;
 
 const activePids = new Set<number>();
 
+const COMMAND_VAR = "PIM_BASH_COMMAND";
+// argv is what `pkill -f`/`pgrep -f` match, so a command naming its own target would
+// signal this shell before its target. The env hands it over out of argv's reach, and
+// the unset keeps it out of every child's environment too.
+const RUNNER = `__pim_command=$${COMMAND_VAR}; unset ${COMMAND_VAR}; eval "$__pim_command"`;
+
 export function killAllActiveBashGroups(sig: NodeJS.Signals = "SIGTERM"): void {
   for (const pid of activePids) {
     killGroup(pid, sig);
@@ -97,11 +103,11 @@ export async function runBashCommand(
 
   // setsid gives the tree its own process group (pgid == proc.pid) so the whole tree can be signalled.
   const proc = Bun.spawn({
-    cmd: ["setsid", "bash", "-lc", command],
+    cmd: ["setsid", "bash", "-lc", RUNNER],
     cwd,
     stdout: "pipe",
     stderr: "pipe",
-    env: { ...process.env },
+    env: { ...process.env, [COMMAND_VAR]: command },
   });
   if (proc.pid !== undefined) {
     activePids.add(proc.pid);

package/packages/core/src/extensions/edit/index.ts

@@ -10,7 +10,7 @@ export default function (pi: ExtensionAPI): void {
     name: "edit",
     label: "edit",
     description:
-      "Replace strings in a UTF-8 text file. " +
+      "Replace strings in a UTF-8 text file; batch several replacements in one call via `edits`. " +
       "Prefer edit over write for changes to existing files.",
     parameters: editSchema,
     renderShell: "self",

package/packages/core/src/extensions/subagent/index.ts

@@ -12,7 +12,7 @@ export default function (pi: ExtensionAPI): void {
     label: "subagent",
     description:
       "Run a task in an isolated subagent with a fresh context. " +
-      "The subagent inherits the currently active tools, except subagent itself. " +
+      "The subagent inherits the current model, thinking level and active tools, except subagent itself. " +
       "Multiple subagent calls in one turn run in parallel. " +
       "Subagent output returned to the main agent is capped at 32KB.",
     parameters: subagentSchema,
@@ -26,6 +26,7 @@ export default function (pi: ExtensionAPI): void {
         signal,
         onUpdate,
         activeToolNames: pi.getActiveTools(),
+        thinkingLevel: pi.getThinkingLevel(),
       });
     },
     toViewModel: subagentView,

package/packages/core/src/extensions/subagent/subagent.ts

@@ -1,4 +1,5 @@
 import { AsyncLocalStorage } from "node:async_hooks";
+import type { ThinkingLevel } from "@earendil-works/pi-agent-core";
 import type {
   AgentSessionEvent,
   AgentToolResult,
@@ -66,6 +67,8 @@ export type SubagentSession = {
 
 export type SubagentSessionSpec = {
   readonly activeToolNames?: readonly string[];
+  /** The parent's live level; left unset, pi falls back to settings, not to the parent. */
+  readonly thinkingLevel?: ThinkingLevel;
   /** The parent's tool call id, which names the child's log on disk. */
   readonly callId?: string;
 };
@@ -111,6 +114,7 @@ export async function createSdkSubagentSession(
     cwd: parentCtx.cwd,
     agentDir: getAgentDir(),
     model: parentCtx.model,
+    thinkingLevel: spec.thinkingLevel,
     sessionManager: await childSessionManager(parentCtx, spec.callId),
     resourceLoader: loader,
     tools: spec.activeToolNames
@@ -144,6 +148,7 @@ export async function runSubagent(
     onUpdate,
     createSession = createSdkSubagentSession,
     activeToolNames,
+    thinkingLevel,
     callId,
   } = run;
 
@@ -175,7 +180,11 @@ export async function runSubagent(
     };
 
     try {
-      session = await createSession(parentCtx, { activeToolNames, callId });
+      session = await createSession(parentCtx, {
+        activeToolNames,
+        thinkingLevel,
+        callId,
+      });
       capture.noteSessionId(session.sessionId);
       session.subscribe((event) => capture.handle(event));
       signal?.addEventListener("abort", onAbort, { once: true });

package/packages/core/src/extensions/system-prompt/index.ts

@@ -2,35 +2,44 @@ import type {
   ExtensionAPI,
   ExtensionFactory,
 } from "@earendil-works/pi-coding-agent";
-import { formatSkillsForPrompt } from "@earendil-works/pi-coding-agent";
-
 import type { Surface } from "../../shared/Surface";
-import { buildSystemPrompt } from "./prompt";
+import {
+  buildEnvironment,
+  buildInstructions,
+  formatDatetime,
+  leadWithSystemPrompt,
+} from "./prompt";
+
+const DATETIME_MESSAGE_TYPE = "pim-datetime";
 
 export default function (surface?: Surface): ExtensionFactory {
   return (pi: ExtensionAPI): void => {
+    // On submit rather than in `before_agent_start`, which can only append
+    // behind the user's message.
+    pi.on("input", () => {
+      pi.sendMessage(
+        {
+          customType: DATETIME_MESSAGE_TYPE,
+          content: `<datetime>${formatDatetime(new Date())}</datetime>`,
+          display: false,
+        },
+        { triggerTurn: false }
+      );
+      return { action: "continue" };
+    });
     pi.on("before_agent_start", (event, ctx) => {
-      const {
-        cwd,
-        contextFiles,
-        skills,
-        promptGuidelines,
-        appendSystemPrompt,
-        customPrompt,
-      } = event.systemPromptOptions;
-      return {
-        systemPrompt: buildSystemPrompt({
-          model: ctx.model,
-          cwd,
-          contextFiles: contextFiles ?? [],
-          skillsBlock:
-            skills && skills.length > 0 ? formatSkillsForPrompt(skills) : "",
-          toolGuidelines: promptGuidelines ?? [],
-          appendSystemPrompt,
-          customPrompt,
-          ...(surface === undefined ? {} : { surface }),
-        }),
-      };
+      const options = event.systemPromptOptions;
+      if (!options.customPrompt?.trim()) {
+        options.customPrompt = buildInstructions(options);
+      }
+      options.sections.environment = buildEnvironment({
+        model: ctx.model,
+        surface,
+      });
+    });
+    pi.on("context_with_system", (event) => {
+      const messages = leadWithSystemPrompt(event.messages);
+      return messages ? { messages } : undefined;
     });
   };
 }

package/packages/core/src/extensions/system-prompt/prompt.ts

@@ -1,18 +1,14 @@
-import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
+import type { NormalizedBuildSystemPromptOptions } from "@earendil-works/pi-coding-agent";
 
 import type { Surface } from "../../shared/Surface";
 
-type BuildOptions = {
-  readonly model?: ExtensionContext["model"];
-  readonly cwd: string;
-  readonly contextFiles: ReadonlyArray<{
-    readonly path: string;
-    readonly content: string;
-  }>;
-  readonly skillsBlock: string;
-  readonly toolGuidelines: ReadonlyArray<string>;
-  readonly appendSystemPrompt?: string;
-  readonly customPrompt?: string;
+type GuidelineOptions = Pick<
+  NormalizedBuildSystemPromptOptions,
+  "selectedTools" | "toolGuidelines" | "promptGuidelines"
+>;
+
+type EnvironmentOptions = {
+  readonly model?: { readonly id: string; readonly provider: string };
   readonly os?: string;
   readonly surface?: Surface;
 };
@@ -34,57 +30,45 @@ function dynamicGuidelines(): ReadonlyArray<string> {
   return guidelines;
 }
 
-export function buildSystemPrompt(opts: BuildOptions): string {
-  const sections: string[] = [];
-
-  if (opts.customPrompt && opts.customPrompt.trim().length > 0) {
-    sections.push(opts.customPrompt);
-  } else {
-    sections.push(
-      [
-        "<system_instructions>",
-        "You are Pim (Pi IMproved), a batteries-included agent built on the Pi harness.",
-        ...opts.toolGuidelines.map((g) => `- ${g}`),
-        ...dynamicGuidelines().map((g) => `- ${g}`),
-        "</system_instructions>",
-      ].join("\n")
-    );
+export function buildInstructions(options: GuidelineOptions): string {
+  const guidelines = new Set([
+    ...options.selectedTools.flatMap(
+      (name) => options.toolGuidelines[name] ?? []
+    ),
+    ...options.promptGuidelines,
+    ...dynamicGuidelines(),
+  ]);
+  return [
+    "<system_instructions>",
+    "You are Pim (Pi IMproved), a batteries-included agent built on the Pi harness.",
+    ...[...guidelines].map((g) => `- ${g}`),
+    "</system_instructions>",
+  ].join("\n");
+}
+
+export function leadWithSystemPrompt<T extends { readonly role: string }>(
+  messages: ReadonlyArray<T>
+): T[] | undefined {
+  const first = messages.findIndex((message) => message.role === "system");
+  if (first <= 0) {
+    return undefined;
   }
+  return [
+    messages[first]!,
+    ...messages.slice(0, first),
+    ...messages.slice(first + 1),
+  ];
+}
 
+export function buildEnvironment(opts: EnvironmentOptions): string {
   const model = opts.model
     ? `${opts.model.id} via ${opts.model.provider}`
     : "unknown";
-  sections.push(
-    [
-      "<environment>",
-      `- cwd: ${opts.cwd}`,
-      `- os: ${opts.os ?? describeOs()}`,
-      `- model: ${model}`,
-      ...(opts.surface ? [`- surface: ${opts.surface}`] : []),
-      `- datetime: ${formatDatetime(new Date())}`,
-      "</environment>",
-    ].join("\n")
-  );
-
-  if (opts.contextFiles.length > 0) {
-    const files = opts.contextFiles
-      .map(
-        ({ path, content }) =>
-          `<file path="${escapeXmlAttr(path)}">\n${content}\n</file>`
-      )
-      .join("\n");
-    sections.push(`<project_instructions>\n${files}\n</project_instructions>`);
-  }
-
-  if (opts.skillsBlock) {
-    sections.push(opts.skillsBlock.trimStart());
-  }
-
-  if (opts.appendSystemPrompt && opts.appendSystemPrompt.trim().length > 0) {
-    sections.push(opts.appendSystemPrompt);
-  }
-
-  return sections.join("\n\n");
+  return [
+    `- os: ${opts.os ?? describeOs()}`,
+    `- model: ${model}`,
+    ...(opts.surface ? [`- surface: ${opts.surface}`] : []),
+  ].join("\n");
 }
 
 export function describeOs(options: OsDescriptionOptions = {}): string {
@@ -210,7 +194,7 @@ function unquoteValue(value: string): string {
   return quote === "'" ? unquoted : unquoted.replace(/\\(["\\$`])/g, "$1");
 }
 
-function formatDatetime(d: Date): string {
+export function formatDatetime(d: Date): string {
   const pad = (n: number): string => String(n).padStart(2, "0");
   const offsetMinutes = -d.getTimezoneOffset();
   const sign = offsetMinutes >= 0 ? "+" : "-";
@@ -222,11 +206,3 @@ function formatDatetime(d: Date): string {
   const day = d.toLocaleDateString("en-US", { weekday: "long" });
   return `${iso} (${day})`;
 }
-
-function escapeXmlAttr(value: string): string {
-  return value
-    .replace(/&/g, "&amp;")
-    .replace(/"/g, "&quot;")
-    .replace(/</g, "&lt;")
-    .replace(/>/g, "&gt;");
-}

package/packages/core/src/session/SessionHost.ts

@@ -15,6 +15,7 @@ import {
   SettingsManager,
   type AgentSessionEvent,
   type CompactionResult,
+  type ExtensionError,
   type ToolDefinition,
 } from "@earendil-works/pi-coding-agent";
 import { unlink } from "node:fs/promises";
@@ -30,6 +31,7 @@ import {
   type LeaseRecord,
 } from "./SessionLease";
 import { SessionName } from "./SessionName";
+import { adaptSessionUi, type SessionUi } from "./SessionUi";
 import { WriteMark } from "./WriteMark";
 
 /** What the agent is doing right now. */
@@ -102,6 +104,13 @@ export type SessionHostDeps = {
   ) => readonly ToolDefinition[];
   /** Runs after the agent is disposed, before the session file is forgotten. */
   readonly onRetire?: (sessionPath: string) => Promise<void>;
+  /**
+   * Where this host's extensions say things, resolved per call so an agent
+   * rebuilt under the host follows its live target. Omit to leave pi's no-op
+   * UI in place: pi freezes the mode at `bindExtensions`, so this is a dep
+   * rather than something a caller can turn on once a session exists.
+   */
+  readonly ui?: () => SessionUi | undefined;
 };
 
 /** What a frontend's own tools are built against. */
@@ -770,16 +779,33 @@ export class SessionHost {
       ],
     });
 
-    // Emits session_start; without it extension tools are registered but never usable.
-    await agent.bindExtensions({
-      mode: "print",
-      onError: (err) => {
-        console.warn(
-          `[${this.label}] extension ${err.extensionPath} (${err.event}):`,
-          err.error
+    const onError = (err: ExtensionError) => {
+      console.warn(
+        `[${this.label}] extension ${err.extensionPath} (${err.event}):`,
+        err.error
+      );
+      // Pi answers a command handler that threw as if it had succeeded, so
+      // without this the user's message vanishes and only stderr says why.
+      this.deps
+        .ui?.()
+        ?.notify(
+          `${err.extensionPath} (${err.event}) failed: ${err.error}`,
+          "error"
         );
-      },
-    });
+    };
+    const ui = this.deps.ui;
+    // Emits session_start; without it extension tools are registered but never usable.
+    await agent.bindExtensions(
+      ui
+        ? // Any context at all makes pi's `hasUI()` true (`uiContext !== noOpUIContext`,
+          // runner.js:318); "rpc" is its own name for dialog-capable but not a terminal.
+          {
+            uiContext: adaptSessionUi(ui),
+            mode: "rpc",
+            onError,
+          }
+        : { mode: "print", onError }
+    );
 
     return { agent, cwd };
   }

package/packages/core/src/session/SessionRegistry.ts

@@ -18,6 +18,7 @@ import {
 } from "./SessionHost";
 import { SessionLease } from "./SessionLease";
 import { SessionName } from "./SessionName";
+import type { SessionUi } from "./SessionUi";
 
 /** A session as pi stores it: one JSONL file under a cwd-encoded directory. */
 export type SessionSummary = {
@@ -58,6 +59,7 @@ export class SessionRegistry {
   private readonly deps: SessionRegistryDeps;
   private readonly runtime: AgentRuntime;
   private readonly hosts: SessionCache<SessionHost>;
+  private ui: ((host: SessionHost) => SessionUi | undefined) | undefined;
 
   public constructor(deps: SessionRegistryDeps) {
     this.deps = deps;
@@ -65,10 +67,24 @@ export class SessionRegistry {
     this.hosts = new SessionCache(deps.capacity);
   }
 
+  /**
+   * Where the extensions of every host built from here speak. It belongs to the
+   * registry rather than each caller because `create` binds an agent eagerly,
+   * and pi freezes a session's UI mode at that bind. Resolved per call: a
+   * host outlives the stream that speaks for it.
+   */
+  public setUi(ui: (host: SessionHost) => SessionUi | undefined): void {
+    this.ui = ui;
+  }
+
   public get sessionsRoot(): string {
     return join(this.runtime.agentDir, "sessions");
   }
 
+  public get agentDir(): string {
+    return this.runtime.agentDir;
+  }
+
   public async init(): Promise<void> {
     await this.runtime.init();
   }
@@ -207,7 +223,10 @@ export class SessionRegistry {
   }
 
   private buildHost(label: string, settings: HostSettings): SessionHost {
-    return new SessionHost({
+    const ui = this.ui;
+    // Named so the sink can reach back for the host it belongs to; the closure
+    // only ever runs once construction has returned.
+    const host: SessionHost = new SessionHost({
       label: `session ${label}`,
       settings,
       defaults: this.deps.defaults,
@@ -225,7 +244,9 @@ export class SessionRegistry {
       ...(this.deps.surface === undefined
         ? {}
         : { surface: this.deps.surface }),
+      ...(ui === undefined ? {} : { ui: () => ui(host) }),
     });
+    return host;
   }
 }
 

package/packages/core/src/session/SessionUi.ts

@@ -0,0 +1,127 @@
+import type {
+  ExtensionUIContext,
+  Theme,
+} from "@earendil-works/pi-coding-agent";
+
+import type { NoticeSeverity } from "../view/ViewBlock";
+
+/** The slice of pi's dialog options a surface without a terminal can honour; the rest is countdown chrome. */
+export type UiAsk = {
+  readonly timeout?: number;
+  readonly signal?: AbortSignal;
+};
+
+/** Where an extension's own words go. Four of pi's thirty methods: the ones that address a human rather than a terminal. */
+export type SessionUi = {
+  readonly notify: (text: string, severity: NoticeSeverity) => void;
+  readonly select: (
+    title: string,
+    options: readonly string[],
+    opts?: UiAsk
+  ) => Promise<string | undefined>;
+  readonly confirm: (
+    title: string,
+    message: string,
+    opts?: UiAsk
+  ) => Promise<boolean>;
+  readonly input: (
+    title: string,
+    placeholder?: string,
+    opts?: UiAsk
+  ) => Promise<string | undefined>;
+};
+
+/** Everything off the terminal paints with; also what pi's border getters hand back. */
+const IDENTITY = (text: string): string => text;
+
+/**
+ * pi keeps its own `theme` instance to itself, and nothing off the terminal has
+ * colours to paint with. `satisfies` covers the whole public surface — `keyof`
+ * skips the private fields the cast is for — so a method pi adds is a type
+ * error here rather than a throw inside somebody's event handler.
+ */
+const PLAIN_THEME = {
+  fg: (_color: string, text: string) => text,
+  bg: (_color: string, text: string) => text,
+  bold: IDENTITY,
+  italic: IDENTITY,
+  underline: IDENTITY,
+  inverse: IDENTITY,
+  strikethrough: IDENTITY,
+  getFgAnsi: () => "",
+  getBgAnsi: () => "",
+  getColorMode: () => "truecolor",
+  getThinkingBorderColor: () => IDENTITY,
+  getBashModeBorderColor: () => IDENTITY,
+} satisfies { [K in keyof Theme]: Theme[K] } as unknown as Theme;
+
+function severityOf(
+  kind: Parameters<ExtensionUIContext["notify"]>[1]
+): NoticeSeverity {
+  return kind === "warning" ? "warn" : (kind ?? "info");
+}
+
+/** A dialog an extension awaits goes unanswered rather than ever throwing at it. */
+async function settle<T>(
+  ask: () => Promise<T> | undefined
+): Promise<T | undefined> {
+  try {
+    return await ask();
+  } catch (err) {
+    console.warn("[SessionUi] dialog sink failed:", err);
+    return undefined;
+  }
+}
+
+/**
+ * Widens the sink onto pi's `ExtensionUIContext`, no-opping everything a
+ * terminal owns exactly as pi's own RPC mode does. `sink` is read per call, so
+ * an agent rebuilt under a host keeps whatever its host was last handed.
+ *
+ * Every method has to be an *own* property: pi re-wraps what it is given with
+ * `{ ...ui }` (`runner.js:274`), which copies own enumerable keys only. A class
+ * instance would arrive with `notify` and the rest of the prototype missing.
+ */
+export function adaptSessionUi(
+  sink: () => SessionUi | undefined
+): ExtensionUIContext {
+  return {
+    select: (title, options, opts) =>
+      settle(() => sink()?.select(title, options, opts)),
+    confirm: async (title, message, opts) =>
+      (await settle(() => sink()?.confirm(title, message, opts))) === true,
+    input: (title, placeholder, opts) =>
+      settle(() => sink()?.input(title, placeholder, opts)),
+    notify: (message, kind) => {
+      try {
+        sink()?.notify(message, severityOf(kind));
+      } catch (err) {
+        console.warn("[SessionUi] notify sink failed:", err);
+      }
+    },
+    onTerminalInput: () => () => {},
+    setStatus: () => {},
+    setWorkingMessage: () => {},
+    setWorkingVisible: () => {},
+    setWorkingIndicator: () => {},
+    setHiddenThinkingLabel: () => {},
+    setWidget: () => {},
+    setFooter: () => {},
+    setHeader: () => {},
+    setTitle: () => {},
+    custom: async <T>() => undefined as T,
+    pasteToEditor: () => {},
+    setEditorText: () => {},
+    getEditorText: () => "",
+    editor: async () => undefined,
+    addAutocompleteProvider: () => {},
+    setEditorComponent: () => {},
+    getEditorComponent: () => undefined,
+    theme: PLAIN_THEME,
+    getAllThemes: () => [],
+    getTheme: () => undefined,
+    setTheme: () => ({ success: false, error: "UI not available" }),
+    getToolsExpanded: () => false,
+    setToolsExpanded: () => {},
+  };
+}