@herbertgao/pi-subagents 0.18.4 → 0.19.0

package/CHANGELOG.md

@@ -1,5 +1,19 @@
 # Changelog
 
+## 0.19.0
+
+### Minor Changes
+
+- [#273](https://github.com/HerbertGao/pi-extensions/pull/273) [`e6ee379`](https://github.com/HerbertGao/pi-extensions/commit/e6ee379393c9f5dde67955d4c28da650835d857f) Thanks [@HerbertGao](https://github.com/HerbertGao)! - Rebase `@herbertgao/pi-subagents` onto upstream v0.20.0 (`13106ab`) and adopt upstream's own mention-clone rewrite: the clone takes its history through `SessionManager.inMemory` and receives the live system prompt through a `DefaultResourceLoader` override instead of the previous context-projection path. The local behavior that hands the spawn the main session's context augmented with the clone's `tools` and `executeTool` is retained, so mentioned agents keep Pi 1.x tool-call capabilities while staying attributed to the main session.
+
+  Two local patches remain because their upstream pull requests are still open: preserving a worktree when cleanup fails (`tintinweb/pi-subagents#268`, with the refused `--no-gpg-sign` preservation commit) and retaining unconsumed terminal results past the automatic cleanup timer (`tintinweb/pi-subagents#348`). Upstream now declares `typebox` as a host-provided peer and drops `@sinclair/typebox` from runtime dependencies. No installed configuration, credentials, or sessions are migrated.
+
+## 0.18.5
+
+### Patch Changes
+
+- [#258](https://github.com/HerbertGao/pi-extensions/pull/258) [`4f505b1`](https://github.com/HerbertGao/pi-extensions/commit/4f505b1456c5ea766121ee915f14ad29e48973e7) Thanks [@HerbertGao](https://github.com/HerbertGao)! - Keep Pi 1.x tool-call capabilities when starting a mentioned agent through a conversation clone, while preserving attribution to the main session.
+
 ## 0.18.4
 
 ### Patch Changes

package/README.md

@@ -47,7 +47,7 @@ Or load directly for development:
 pi -e ./src/index.ts
 ```
 
-Requires pi **0.84.0 or newer**: the [`SubagentWorkflow`](#subagentworkflow) tool builds on `constrainedSampling` (pi 0.82.0) and pi-tui's `stripTerminalSequences` (0.84.0). The `peerDependencies` range declares it, so npm flags an older pi at install time.
+Requires pi **1.1.0 or newer**: pi 0.86 and 0.87 moved the system prompt and conversation history into the session transcript, and the `@handle` conversation clone and the agent transcript files are built on that model. The `peerDependencies` range declares it, so npm flags an older pi at install time.
 
 ### Other hosts
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@herbertgao/pi-subagents",
-  "version": "0.18.4",
+  "version": "0.19.0",
   "description": "Claude Code-style autonomous subagents and workflow orchestration for Pi, with HerbertGao-maintained UI extensions.",
   "keywords": [
     "agent",
@@ -55,7 +55,6 @@
     "@earendil-works/pi-ai": "*",
     "@earendil-works/pi-coding-agent": "*",
     "@earendil-works/pi-tui": "*",
-    "@sinclair/typebox": "*",
     "typebox": "*"
   },
   "engines": {
@@ -70,9 +69,9 @@
   },
   "x-upstream": {
     "package": "@tintinweb/pi-subagents",
-    "version": "0.19.0",
-    "reviewedVersion": "0.19.0",
+    "version": "0.20.0",
+    "reviewedVersion": "0.20.0",
     "repository": "https://github.com/tintinweb/pi-subagents",
-    "commit": "95d10867f391636e6563e3885e972618083f306b"
+    "commit": "13106ab6f608b3acc54185da5299ee7fbaabb6b9"
   }
 }

package/src/index.ts

@@ -35,7 +35,7 @@ import {
   Spacer,
   Text,
 } from "@earendil-works/pi-tui"
-import { Type } from "@sinclair/typebox"
+import { Type } from "typebox"
 import { abortable } from "./abortable.js"
 import { hasAgentBadge, renderAgentName } from "./agent-color.js"
 import {

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
@@ -108,7 +98,7 @@ export async function runMentionClone(
   let spawned = false
   const cloneAgentTool: ToolDefinition = {
     ...agentTool,
-    execute: (_cloneToolCallId, params, signal, onUpdate, _cloneCtx) => {
+    execute: (_cloneToolCallId, params, signal, onUpdate, cloneCtx) => {
       // One spawn per mention. The clone has a single tool and every reason to
       // stop after using it, but a model that decides to "also" launch a second
       // agent would do it where nobody can see and nobody asked.
@@ -138,7 +128,8 @@ export async function runMentionClone(
         } as typeof params,
         signal,
         onUpdate,
-        ctx,
+        // Keep Pi's tool-call capabilities, but attribute the spawn to the main session.
+        { ...ctx, tools: cloneCtx.tools, executeTool: cloneCtx.executeTool },
       )
     },
   }
@@ -155,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,
@@ -219,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++
     }
   }
 

package/src/workflow/collisions.ts

@@ -46,11 +46,14 @@ import { SUBAGENT_TOOL_NAMES } from "../agent-runner.js"
  *
  * Our own name, because pi resolves a duplicate registration silently, and
  * Claude Code's bare `Workflow`, because a port of that tool is what a second
- * workflow extension most likely calls itself.
+ * workflow extension most likely calls itself. Lowercase `workflow` is the same
+ * tool by pi convention: it is what `@quintinshaw/pi-dynamic-workflows`
+ * registers, and the match here is exact, so the case has to be listed by hand.
  */
 export const FOREIGN_WORKFLOW_TOOL_NAMES: ReadonlySet<string> = new Set([
   SUBAGENT_TOOL_NAMES.WORKFLOW,
   "Workflow",
+  "workflow",
 ])
 
 /** The fields of a registered tool this decision reads. */

package/src/workflow/json-schema.ts

@@ -7,14 +7,15 @@
  *
  * ## Which typebox
  *
- * **`typebox`, not `@sinclair/typebox`.** They are different packages and both
- * are installed here. `@sinclair/typebox` (0.34) dispatches on a `Kind` symbol
- * that a schema arriving over the wire does not carry, so `Value.Check` throws
- * `Unknown type` on a plain JSON Schema — and `Type.Unsafe` does not help, it
- * stamps a `Kind` that is not registered. `typebox` v1 is a standards JSON
- * Schema validator and takes the schema as-is. It is also the package pi itself
- * types `ToolDefinition.parameters` against, so the same schema object serves
- * both roles with no conversion.
+ * **`typebox`, not `@sinclair/typebox`.** They are different packages.
+ * `@sinclair/typebox` (0.34) dispatches on a `Kind` symbol that a schema
+ * arriving over the wire does not carry, so `Value.Check` throws `Unknown type`
+ * on a plain JSON Schema — and `Type.Unsafe` does not help, it stamps a `Kind`
+ * that is not registered. `typebox` v1 is a standards JSON Schema validator and
+ * takes the schema as-is. It is also the package pi itself types
+ * `ToolDefinition.parameters` against and supplies to extensions at runtime
+ * (a peer dependency here), so the same schema object serves both roles with no
+ * conversion.
  *
  * ## Why we validate at all
  *