@herbertgao/pi-subagents 0.18.5 → 0.22.0-local.1

package/src/invocation-config.ts

@@ -1,4 +1,4 @@
-import { Type } from "@sinclair/typebox"
+import { Type } from "typebox"
 import type {
   AgentConfig,
   IsolationMode,

package/src/mention-clone.ts

@@ -12,31 +12,23 @@
  * So the turn happens somewhere else. The conversation is cloned into a
  * throwaway in-memory session — same messages, same system prompt, same model —
  * and that copy takes the turn off-screen. A literal clone: the session's own
- * entries, projected by pi's own `sessionEntryToContextMessages`, not
- * `inherit_context`'s text rendering of them.
+ * entries, not `inherit_context`'s text rendering of them.
+ *
+ * Pi builds every request from the session manager, so that is where the
+ * clone's history goes: the parent's root-to-leaf entries, handed to
+ * `SessionManager.inMemory`. The clone projects them itself, compaction and
+ * branch summaries included, so a long conversation clones as what the main
+ * model is actually working from. A conversation with nothing in it yet clones
+ * to nothing in it yet, which is the correct answer rather than a failure.
  *
  * Cloned from memory rather than from the session file, which cannot be relied
  * on: `SessionManager._persist` withholds every write until the first assistant
  * message lands, so a fork taken before then reads an empty file and throws.
- * `buildSessionContext()` has no such timing, and is compaction-aware — it walks
- * the leaf path and substitutes the summary for entries folded into it, so a
- * long conversation clones as what the main model is actually working from. A
- * conversation with nothing in it yet clones to nothing in it yet, which is the
- * correct answer rather than a failure.
- *
- * It is also the oldest of the equivalent Pi APIs — `buildContextEntries` on
- * ReadonlySessionManager and the `sessionEntryToContextMessages` export both
- * arrived in 0.80.5 — where this one has been exported unchanged from before
- * the declared peer floor, and is the same code path (`byId` is only an index
- * cache, so passing it or not cannot change the result). Keeping the floor
- * honest costs nothing here: see the `compat-floor-pi` job.
  *
- * Its `thinkingLevel` is NOT used, and is the one place the newer API would be
- * better. `getSessionContextSettings` starts at "off" and moves only on an
- * explicit `thinking_level_change` entry, so a session where nobody ran
- * `/think` reports "off" rather than the level it is really using. Omitting the
- * field instead lets `createAgentSession` resolve it from settings, which is
- * that real level.
+ * The system prompt cannot ride along in those entries. Pi rebuilds it from the
+ * session's own options on every request and patches the difference over the
+ * transcript, so the parent's prompt would be replaced by the clone's. It goes
+ * in through the resource loader's prompt override instead.
  *
  * Three details make the spawn belong to the real session rather than the
  * clone:
@@ -63,8 +55,6 @@
 
 import type { Model } from "@earendil-works/pi-ai"
 import {
-  buildSessionContext,
-  convertToLlm,
   createAgentSession,
   DefaultResourceLoader,
   type ExtensionContext,
@@ -74,7 +64,7 @@ import {
 } from "@earendil-works/pi-coding-agent"
 import { runInChildSessionContext } from "./child-context.js"
 import { agentMentionReminder } from "./mention.js"
-import type { SubagentType, ThinkingLevel } from "./types.js"
+import type { SubagentType } from "./types.js"
 
 export interface MentionCloneOptions {
   /** The MAIN session's context — what the spawn is attributed to, and the
@@ -156,54 +146,40 @@ export async function runMentionClone(
     const parentModelRuntime = (
       ctx.modelRegistry as unknown as { runtime?: unknown }
     ).runtime
-    // The conversation as the main session resolves it: compaction applied,
-    // branch summaries substituted.
-    const conversation = buildSessionContext(
-      ctx.sessionManager.getEntries(),
-      ctx.sessionManager.getLeafId(),
-    )
-    // Pi 0.82.0 added this; below it the field is absent and the clone takes
-    // the settings level instead, which is what a session that never ran
-    // `/think` is on anyway. Same shim shape as `modelRuntime` below.
-    const thinkingLevel = (ctx as { thinkingLevel?: ThinkingLevel })
-      .thinkingLevel
-    const sessionManager = SessionManager.inMemory(ctx.cwd)
-    for (const entry of conversation.messages) {
-      // The live prompt is copied below. Do not replay the parent's system
-      // messages: newer Pi also stores its tool declarations there.
-      if ((entry.role as string) === "system") continue
-      // Summary messages are projections, not appendable session entries.
-      // Preserve exactly the user message Pi would send for each summary.
-      if (
-        entry.role === "compactionSummary" ||
-        entry.role === "branchSummary"
-      ) {
-        for (const message of convertToLlm([entry]))
-          sessionManager.appendMessage(message)
-      } else {
-        sessionManager.appendMessage(entry)
-      }
-    }
-    const systemPrompt = ctx.getSystemPrompt?.()
-    const created = await runInChildSessionContext(async () => {
-      const resourceLoader = new DefaultResourceLoader({
-        cwd: ctx.cwd,
-        agentDir: getAgentDir(),
-        extensionFactories: [
-          (pi) => {
-            pi.on("before_agent_start", () =>
-              systemPrompt ? { systemPrompt } : undefined,
-            )
-          },
-        ],
-      })
-      await resourceLoader.reload()
-      return createAgentSession({
+    // Absent when the session has no level of its own; the clone then takes the
+    // settings level, which is what a session that never ran `/think` is on.
+    const thinkingLevel = ctx.thinkingLevel
+    // The live system prompt, not the one the clone would build from cwd and
+    // agentDir — extensions contribute to it per turn. Everything the loader
+    // would add on top (AGENTS.md, skills, APPEND_SYSTEM.md) is already in the
+    // rendered prompt, so it is suppressed, as agent-runner does.
+    const systemPrompt = ctx.getSystemPrompt()
+    const loader = new DefaultResourceLoader({
+      cwd: ctx.cwd,
+      agentDir: getAgentDir(),
+      noExtensions: true,
+      noSkills: true,
+      noPromptTemplates: true,
+      noThemes: true,
+      noContextFiles: true,
+      systemPromptOverride: (base: string | undefined) => systemPrompt || base,
+      appendSystemPromptOverride: () => [],
+    })
+    await runInChildSessionContext(() => loader.reload())
+    const created = await runInChildSessionContext(() =>
+      createAgentSession({
         cwd: ctx.cwd,
-        // Nothing about the copy is worth persisting, and an in-memory manager
-        // is also what keeps the real session untouched.
-        sessionManager,
-        resourceLoader,
+        // The parent's root-to-leaf path, which the clone projects itself:
+        // compaction applied, branch summaries substituted. Not `getEntries()`,
+        // whose last entry is not the leaf after `/tree` navigation. In memory,
+        // so nothing about the copy is persisted and the real session stays
+        // untouched.
+        sessionManager: SessionManager.inMemory(
+          ctx.cwd,
+          undefined,
+          ctx.sessionManager.getBranch(),
+        ),
+        resourceLoader: loader,
         model: ctx.model as Model<never> | undefined,
         ...(thinkingLevel && { thinkingLevel }),
         modelRegistry: ctx.modelRegistry,
@@ -220,8 +196,8 @@ export async function runMentionClone(
         // agent-runner's `tools: sessionTools` beside its nested `customTools`.
         tools: [cloneAgentTool.name],
         customTools: [cloneAgentTool],
-      } as Parameters<typeof createAgentSession>[0])
-    })
+      } as Parameters<typeof createAgentSession>[0]),
+    )
     session = created.session
 
     // User text first, reminder after — the order Claude Code's attachment

package/src/nested-tools.ts

@@ -6,7 +6,7 @@ import {
   type ExtensionContext,
   type ToolDefinition,
 } from "@earendil-works/pi-coding-agent"
-import { Type } from "@sinclair/typebox"
+import { Type } from "typebox"
 import { abortable } from "./abortable.js"
 import {
   buildAgentRegistry,

package/src/output-file.ts

@@ -122,17 +122,27 @@ export function streamToOutputFile(
   cwd: string,
   startIndex?: number,
 ): () => void {
-  // Index of the first message this stream is responsible for. A spawn writes
-  // messages[0] as the initial prompt entry, so it starts at 1. A resume hands
+  // Index of the first message this stream is responsible for. A resume hands
   // in the session's length as of just before the run: the session already
   // holds every prior turn, and re-emitting those would duplicate history that
-  // is already in the file.
-  let writtenCount = startIndex ?? 1
+  // is already in the file. A spawn has already written its prompt as the
+  // initial entry, so it starts after the first user message — found on the
+  // first flush, because pi puts a system message ahead of it and adds both
+  // only once the prompt runs.
+  let writtenCount = startIndex
 
   const flush = () => {
     const messages = session.messages
+    if (writtenCount === undefined) {
+      const prompt = messages.findIndex((m) => m.role === "user")
+      if (prompt === -1) return
+      writtenCount = prompt + 1
+    }
     while (writtenCount < messages.length) {
-      const msg = messages[writtenCount]
+      const msg = messages[writtenCount++]
+      // Pi's prompt and tool-loadout records; a Claude Code transcript has no
+      // such entry.
+      if (msg.role === "system") continue
       const entry = {
         isSidechain: true,
         agentId,
@@ -151,7 +161,6 @@ export function streamToOutputFile(
       } catch {
         /* ignore write errors */
       }
-      writtenCount++
     }
   }