@gotgenes/pi-subagents 5.8.2 → 6.0.1

package/src/agent-runner.ts

@@ -17,6 +17,7 @@ import {
 import { buildParentContext, extractText } from "./context.js";
 import { detectEnv } from "./env.js";
 import { assembleSessionConfig } from "./session-config.js";
+import { deriveSubagentSessionDir } from "./session-dir.js";
 import type { SubagentType, ThinkingLevel } from "./types.js";
 
 /** Names of tools registered by this extension that subagents must NOT inherit. */
@@ -82,6 +83,10 @@ export interface RunOptions {
   thinkingLevel?: ThinkingLevel;
   /** Override working directory (e.g. for worktree isolation). */
   cwd?: string;
+  /** Path to the parent session's JSONL file (for deriving the subagent session directory). */
+  parentSessionFile?: string;
+  /** Session ID of the parent agent (stored in the child session's parentSession header). */
+  parentSessionId?: string;
   /** Called on tool start/end with activity info. */
   onToolActivity?: (activity: ToolActivity) => void;
   /** Called on streaming text deltas from the assistant response. */
@@ -127,6 +132,8 @@ export interface RunResult {
   aborted: boolean;
   /** True if the agent was steered to wrap up (hit soft turn limit) but finished in time. */
   steered: boolean;
+  /** Path to the persisted session JSONL file, if the session was persisted. */
+  sessionFile?: string;
 }
 
 /** Options for resuming an existing agent session. */
@@ -240,10 +247,17 @@ export async function runAgent(
   });
   await loader.reload();
 
+  // Create a persisted SessionManager so transcripts are written in Pi's
+  // official JSONL format. Falls back to a temp directory when the parent
+  // session is not persisted (e.g. headless/API mode).
+  const sessionDir = deriveSubagentSessionDir(options.parentSessionFile, cfg.effectiveCwd);
+  const sessionManager = SessionManager.create(cfg.effectiveCwd, sessionDir);
+  sessionManager.newSession({ parentSession: options.parentSessionId });
+
   const sessionOpts: Parameters<typeof createAgentSession>[0] = {
     cwd: cfg.effectiveCwd,
     agentDir,
-    sessionManager: SessionManager.inMemory(cfg.effectiveCwd),
+    sessionManager,
     settingsManager: SettingsManager.create(cfg.effectiveCwd, agentDir),
     modelRegistry: ctx.modelRegistry,
     model: cfg.model as Model<any> | undefined,
@@ -383,7 +397,13 @@ export async function runAgent(
 
   const responseText =
     collector.getText().trim() || getLastAssistantText(session);
-  return { responseText, session, aborted, steered: softLimitReached };
+  return {
+    responseText,
+    session,
+    aborted,
+    steered: softLimitReached,
+    sessionFile: sessionManager.getSessionFile(),
+  };
 }
 
 /**

package/src/session-dir.ts

@@ -0,0 +1,38 @@
+/**
+ * session-dir.ts — Pure function for deriving subagent session directories.
+ *
+ * Subagent sessions are nested under the parent session's basename so they are
+ * discoverable via the parent session path without cluttering the main session list.
+ */
+
+import { tmpdir } from "node:os";
+import { basename, dirname, join } from "node:path";
+
+/**
+ * Derive the session directory for a subagent from the parent session file.
+ *
+ * Layout: `<parent-dir>/<parent-basename>/tasks/`
+ *
+ * Example:
+ *   parent: `~/.pi/agent/sessions/--project--/2026-05-20T12-00-00Z_.jsonl`
+ *   result: `~/.pi/agent/sessions/--project--/2026-05-20T12-00-00Z_/tasks`
+ *
+ * Falls back to a temp directory when the parent session is not persisted
+ * (e.g. API/headless mode where the parent uses `SessionManager.inMemory()`).
+ */
+export function deriveSubagentSessionDir(
+  parentSessionFile: string | undefined,
+  cwd: string,
+): string {
+  if (parentSessionFile) {
+    const dir = dirname(parentSessionFile);
+    const base = basename(parentSessionFile, ".jsonl");
+    return join(dir, base, "tasks");
+  }
+
+  // Fallback: use a temp directory keyed by uid and cwd so different
+  // projects don't collide when the parent session is not persisted.
+  const encoded = cwd.replace(/[/\\]/g, "-").replace(/^[A-Za-z]:-/, "").replace(/^-+/, "");
+  const root = join(tmpdir(), `pi-subagents-${process.getuid?.() ?? 0}`);
+  return join(root, encoded, "tasks");
+}

package/src/tools/agent-tool.ts

@@ -6,7 +6,7 @@ import { normalizeMaxTurns } from "../agent-runner.js";
 import { resolveAgentConfig, resolveType } from "../agent-types.js";
 import { resolveAgentInvocationConfig } from "../invocation-config.js";
 import { resolveInvocationModel } from "../model-resolver.js";
-import { createOutputFilePath, streamToOutputFile, writeInitialEntry } from "../output-file.js";
+
 import type { AgentInvocation, AgentRecord, SubagentType } from "../types.js";
 import {
   type AgentActivity,
@@ -454,19 +454,12 @@ Guidelines:
         const { state: bgState, callbacks: bgCallbacks } =
           createActivityTracker(effectiveMaxTurns);
 
-        // Wrap onSessionCreated to wire output file streaming.
         let id: string;
-        const origBgOnSession = bgCallbacks.onSessionCreated;
-        bgCallbacks.onSessionCreated = (session: any) => {
-          origBgOnSession(session);
-          const rec = deps.manager.getRecord(id);
-          if (rec?.outputFile) {
-            rec.outputCleanup = streamToOutputFile(session, rec.outputFile, id, ctx.cwd);
-          }
-        };
 
         try {
           id = deps.manager.spawn(ctx, subagentType, params.prompt as string, {
+            parentSessionFile: ctx.sessionManager.getSessionFile(),
+            parentSessionId: ctx.sessionManager.getSessionId(),
             description: params.description as string,
             model,
             maxTurns: effectiveMaxTurns,
@@ -482,16 +475,9 @@ Guidelines:
           return textResult(err instanceof Error ? err.message : String(err));
         }
 
-        // Set output file synchronously after spawn
         const record = deps.manager.getRecord(id);
         if (record) {
           record.toolCallId = toolCallId;
-          record.outputFile = createOutputFilePath(
-            ctx.cwd,
-            id,
-            ctx.sessionManager.getSessionId(),
-          );
-          writeInitialEntry(record.outputFile, id, params.prompt as string, ctx.cwd);
         }
 
         deps.agentActivity.set(id, bgState);
@@ -596,6 +582,8 @@ Guidelines:
             isolation,
             invocation: agentInvocation,
             signal,
+            parentSessionFile: ctx.sessionManager.getSessionFile(),
+            parentSessionId: ctx.sessionManager.getSessionId(),
             ...fgCallbacks,
           },
         );

package/src/types.ts

@@ -78,10 +78,8 @@ export interface AgentRecord {
   worktreeResult?: { hasChanges: boolean; branch?: string };
   /** The tool_use_id from the original Agent tool call. */
   toolCallId?: string;
-  /** Path to the streaming output transcript file. */
+  /** Path to the persisted session transcript file. */
   outputFile?: string;
-  /** Cleanup function for the output file stream subscription. */
-  outputCleanup?: () => void;
   /**
    * Lifetime usage breakdown, accumulated via `message_end` events. Survives
    * compaction. Total = input + output + cacheWrite (cacheRead deliberately

package/src/output-file.ts

@@ -1,99 +0,0 @@
-/**
- * output-file.ts — Streaming JSONL output file for agent transcripts.
- *
- * Creates a per-agent output file that streams conversation turns as JSONL,
- * matching Claude Code's task output file format.
- */
-
-import { appendFileSync, chmodSync, mkdirSync, writeFileSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import type { AgentSession, AgentSessionEvent } from "@earendil-works/pi-coding-agent";
-import { debugLog } from "./debug.js";
-
-/**
- * Encode a cwd path as a filesystem-safe directory name. Handles:
- *   - POSIX:   "/home/user/project"        → "home-user-project"
- *   - Windows: "C:\Users\foo\project"      → "Users-foo-project"
- *   - UNC:     "\\\\server\\share\\project"  → "server-share-project"
- */
-export function encodeCwd(cwd: string): string {
-  return cwd
-    .replace(/[/\\]/g, "-")        // both separators → dash
-    .replace(/^[A-Za-z]:-/, "")    // strip Windows drive prefix ("C:-")
-    .replace(/^-+/, "");           // strip leading dashes (POSIX root, UNC)
-}
-
-/** Create the output file path, ensuring the directory exists.
- *  Mirrors Claude Code's layout: /tmp/{prefix}-{uid}/{encoded-cwd}/{sessionId}/tasks/{agentId}.output */
-export function createOutputFilePath(cwd: string, agentId: string, sessionId: string): string {
-  const encoded = encodeCwd(cwd);
-  const root = join(tmpdir(), `pi-subagents-${process.getuid?.() ?? 0}`);
-  mkdirSync(root, { recursive: true, mode: 0o700 });
-  // chmod is a no-op on Windows and throws on some Windows filesystems.
-  // On Unix we still want to enforce 0o700 past umask, so only swallow on Windows.
-  try {
-    chmodSync(root, 0o700);
-  } catch (err) {
-    if (process.platform !== "win32") throw err;
-  }
-  const dir = join(root, encoded, sessionId, "tasks");
-  mkdirSync(dir, { recursive: true });
-  return join(dir, `${agentId}.output`);
-}
-
-/** Write the initial user prompt entry. */
-export function writeInitialEntry(path: string, agentId: string, prompt: string, cwd: string): void {
-  const entry = {
-    isSidechain: true,
-    agentId,
-    type: "user",
-    message: { role: "user", content: prompt },
-    timestamp: new Date().toISOString(),
-    cwd,
-  };
-  writeFileSync(path, JSON.stringify(entry) + "\n", "utf-8");
-}
-
-/**
- * Subscribe to session events and flush new messages to the output file on each turn_end.
- * Returns a cleanup function that does a final flush and unsubscribes.
- */
-export function streamToOutputFile(
-  session: AgentSession,
-  path: string,
-  agentId: string,
-  cwd: string,
-): () => void {
-  let writtenCount = 1; // initial user prompt already written
-
-  const flush = () => {
-    const messages = session.messages;
-    while (writtenCount < messages.length) {
-      const msg = messages[writtenCount];
-      const entry = {
-        isSidechain: true,
-        agentId,
-        type: msg.role === "assistant" ? "assistant" : msg.role === "user" ? "user" : "toolResult",
-        message: msg,
-        timestamp: new Date().toISOString(),
-        cwd,
-      };
-      try {
-        appendFileSync(path, JSON.stringify(entry) + "\n", "utf-8");
-      } catch (err) {
-        debugLog("write JSONL chunk", err);
-      }
-      writtenCount++;
-    }
-  };
-
-  const unsubscribe = session.subscribe((event: AgentSessionEvent) => {
-    if (event.type === "turn_end") flush();
-  });
-
-  return () => {
-    flush();
-    unsubscribe();
-  };
-}