@ian-pascoe/pi-minimal-subagents 0.6.5 → 0.7.0

package/src/minimal-subagents-sessions.ts

@@ -1,5 +1,5 @@
 import { execFile } from "node:child_process";
-import { existsSync, writeFileSync } from "node:fs";
+import { existsSync, readFileSync, statSync, writeFileSync } from "node:fs";
 import { unlink } from "node:fs/promises";
 import { resolve } from "node:path";
 import type { AgentMessage, ThinkingLevel } from "@earendil-works/pi-agent-core";
@@ -12,6 +12,7 @@ import {
   findCutPoint,
   generateSummaryWithUsage,
   ModelRuntime,
+  parseSessionEntries,
   SessionManager,
   SettingsManager,
   sessionEntryToContextMessages,
@@ -362,6 +363,9 @@ export function verifyChildSessionIdentity(
       `Minimal subagents session identity mismatch: session ID for ${agent.agent_id}`,
     );
   }
+  if (agent.session_leaf_id && !sessionManager.getEntry(agent.session_leaf_id)) {
+    throw new Error(`Minimal subagents session identity mismatch: leaf for ${agent.agent_id}`);
+  }
   const identityBranch = sessionManager.getBranch(agent.session_leaf_id);
   const generation = findLatestForkGeneration(identityBranch);
   const identity =
@@ -401,9 +405,6 @@ export function verifyChildSessionIdentity(
       );
     }
   }
-  if (agent.session_leaf_id && !sessionManager.getEntry(agent.session_leaf_id)) {
-    throw new Error(`Minimal subagents session identity mismatch: leaf for ${agent.agent_id}`);
-  }
 }
 
 /** Find durable keyed evidence for exactly-once wait or custom-result delivery. */
@@ -532,6 +533,10 @@ export async function captureChildTurnOutcome(
 class PiChildAgentRuntime implements ChildAgentRuntime {
   private aborted = false;
   private readonly unsubscribe: () => void;
+  private transcriptLeafId: string | null | undefined;
+  private readonly transcriptEntries = new WeakMap<SessionEntry, AgentMessage[]>();
+  private transcriptMessages: AgentMessage[] = [];
+  private transcriptSources = new Set<AgentMessage>();
 
   constructor(
     private readonly session: AgentSession,
@@ -629,10 +634,46 @@ class PiChildAgentRuntime implements ChildAgentRuntime {
   }
 
   snapshotActivityTranscript(): ChildAgentTranscriptSnapshot {
-    const snapshot = selectChildAgentTranscript(
-      this.session.messages,
-      this.session.state.streamingMessage,
+    const manager = this.session.sessionManager;
+    const leafId = manager.getLeafId();
+    if (this.transcriptLeafId !== leafId) {
+      this.transcriptSources = new Set();
+      this.transcriptMessages = manager.getBranch().flatMap((entry) => {
+        const source = sessionEntryToContextMessages(entry);
+        for (const message of source) this.transcriptSources.add(message);
+        let messages = this.transcriptEntries.get(entry);
+        if (!messages) {
+          messages = selectChildAgentTranscript(source).messages;
+          this.transcriptEntries.set(entry, messages);
+        }
+        return messages;
+      });
+      this.transcriptLeafId = leafId;
+    }
+    const state = this.session.state;
+    // Native message_end finalizes agent state before async extension handlers persist it.
+    const pending = state.messages.filter(
+      (message) =>
+        (message.role === "user" ||
+          message.role === "assistant" ||
+          message.role === "toolResult") &&
+        !this.transcriptSources.has(message),
+    );
+    const streaming = state.streamingMessage;
+    const tail = selectChildAgentTranscript(
+      pending,
+      streaming && !this.transcriptSources.has(streaming) ? streaming : undefined,
     );
+    const snapshot: ChildAgentTranscriptSnapshot = {
+      messages: tail.messages.length
+        ? [...this.transcriptMessages, ...tail.messages]
+        : this.transcriptMessages,
+      streamingAssistantIndex:
+        tail.streamingAssistantIndex === undefined
+          ? undefined
+          : this.transcriptMessages.length + tail.streamingAssistantIndex,
+      toolDefinitions: [],
+    };
     const toolNames = new Set<string>();
     for (const message of snapshot.messages) {
       if (message.role !== "assistant") continue;
@@ -740,6 +781,7 @@ export class PiAgentSessionFactory implements AgentSessionFactory {
   private readonly availableToolNames: Set<string>;
   private readonly discoveredToolNames = new Map<string, Promise<Set<string>>>();
   private readonly sessionFileTrash: SessionFileTrashCapability;
+  private savedTranscript?: { key: string; snapshot: ChildAgentTranscriptSnapshot };
 
   constructor(private readonly options: PiAgentSessionFactoryOptions) {
     this.modelById = new Map(
@@ -763,6 +805,40 @@ export class PiAgentSessionFactory implements AgentSessionFactory {
     });
   }
 
+  /** Read one verified saved Child Session Position without opening a writable runtime. */
+  readTranscript(agent: PersistedAgent): ChildAgentTranscriptSnapshot {
+    if (!agent.session_file || !agent.session_id || !agent.session_leaf_id) {
+      throw new Error(`Child Session Position is unavailable for ${agent.agent_id}.`);
+    }
+    const sessionFile = canonicalPath(agent.session_file);
+    const stat = statSync(sessionFile);
+    const key = JSON.stringify([
+      sessionFile,
+      agent.agent_id,
+      agent.parent_id,
+      agent.created_at,
+      agent.session_id,
+      agent.session_leaf_id,
+      stat.dev,
+      stat.ino,
+      stat.size,
+      stat.mtimeMs,
+      stat.ctimeMs,
+    ]);
+    if (this.savedTranscript?.key === key) return this.savedTranscript.snapshot;
+    const entries = parseSessionEntries(readFileSync(sessionFile, "utf8"));
+    if (entries[0]?.type !== "session")
+      throw new Error(`Invalid child session file: ${sessionFile}`);
+    // SessionManager.open can migrate/rewrite files; an in-memory reader cannot write them.
+    const manager = SessionManager.inMemory(this.options.cwd, undefined, entries);
+    verifyChildSessionIdentity(manager, agent, this.options.rootSessionId);
+    const snapshot = selectChildAgentTranscript(
+      manager.getBranch(agent.session_leaf_id).flatMap(sessionEntryToContextMessages),
+    );
+    this.savedTranscript = { key, snapshot };
+    return snapshot;
+  }
+
   resolveLaunchMissingDependencies(agent: PersistedAgent): Promise<string[]> {
     return this.findMissingDependencies(agent, false);
   }

package/src/minimal-subagents-settings-writer.ts

@@ -4,8 +4,6 @@ import { randomUUID } from "node:crypto";
 import { mkdir, open, readFile, rename, rm, stat } from "node:fs/promises";
 import { basename, dirname, join, resolve } from "node:path";
 import lockfile from "proper-lockfile";
-import { Type } from "typebox";
-import { Value } from "typebox/value";
 
 /** Identifies the standard Pi settings file changed by a Subagent Access command. */
 export type MinimalSubagentsSettingsScope = "global" | "project";
@@ -64,8 +62,10 @@ interface ExistingSettingsDocument {
   readonly mode: number;
 }
 
-const JsonValueSchema = Type.Unsafe<JsonValue>({});
-const SettingsJsonObjectSchema = Type.Record(Type.String(), JsonValueSchema);
+function isSettingsJsonObject(value: JsonValue | undefined): value is SettingsJsonObject {
+  // oxlint-disable-next-line anti-slop/no-runtime-typeof -- JSON.parse already established JSON data; distinguish object roots and settings blocks from primitives and arrays.
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
 const SETTINGS_LOCK_RETRY_DELAY_MS = 20;
 const SETTINGS_LOCK_RETRIES = 100;
 const NEW_SETTINGS_FILE_MODE = 0o600;
@@ -92,7 +92,8 @@ function parseSettingsDocument(
   scope: MinimalSubagentsSettingsScope,
   path: string,
 ): ParsedSettingsDocument {
-  let parsed: unknown;
+  // JSON.parse is the provenance for this JSON type; the object shape is checked below.
+  let parsed: JsonValue;
   try {
     parsed = JSON.parse(stripUtf8Bom(content));
   } catch (cause) {
@@ -109,11 +110,11 @@ function parseSettingsDocument(
     };
   }
 
-  if (!Value.Check(SettingsJsonObjectSchema, parsed)) {
+  if (!isSettingsJsonObject(parsed)) {
     return { ok: false, error: settingsContractError(scope, path, "expected an object root") };
   }
   const minimalSubagents = parsed.minimalSubagents;
-  if (minimalSubagents !== undefined && !Value.Check(SettingsJsonObjectSchema, minimalSubagents)) {
+  if (minimalSubagents !== undefined && !isSettingsJsonObject(minimalSubagents)) {
     return {
       ok: false,
       error: settingsContractError(
@@ -131,7 +132,7 @@ function mutateMinimalSubagentsEnabled(
   enabled: boolean | undefined,
 ): void {
   const currentMinimalSubagents = settings.minimalSubagents;
-  const minimalSubagents = Value.Check(SettingsJsonObjectSchema, currentMinimalSubagents)
+  const minimalSubagents = isSettingsJsonObject(currentMinimalSubagents)
     ? currentMinimalSubagents
     : {};