@bermudi/pi-delegate 0.1.6 → 0.1.7

package/dispatch.ts

@@ -293,7 +293,6 @@ export function dispatchAsync(input: AsyncDispatchInput): DelegateToolResult {
   const asyncEnv: TaskRunEnv = {
     signal: ticketSignal,
     modelRegistry,
-    parentSessionManager: ctx.sessionManager,
     ticketId,
     delegateStartedAt: ticket.created,
     telemetryCallId: callSpan?.id,
@@ -426,7 +425,6 @@ export async function dispatchSync(
   const syncEnv: TaskRunEnv = {
     signal,
     modelRegistry: ctx.modelRegistry,
-    parentSessionManager: ctx.sessionManager,
     ticketId: undefined,
     delegateStartedAt: startedAt,
     telemetryCallId: callSpan?.id,

package/lifecycle.ts

@@ -18,7 +18,6 @@ import { isSessionBusy } from "./tickets.ts";
 import {
   createSubagentSessionManager,
   persistSessionHeader,
-  setParentSession,
 } from "./sessions.ts";
 import { runAgentSession, formatDeadlineExceededError } from "./runner.ts";
 import { getGitChangedFiles } from "./file-tracking.ts";
@@ -329,8 +328,8 @@ async function sleepForWholeTaskRetry(
 }
 
 /** Build the AgentSession for a fresh or resumed subagent via createAgentSession.
- *  Reuses the caller-supplied sessionManager (so parent-linking + per-task .jsonl
- *  files stay under our control). Extension-free host deps may be cached, while
+ *  Reuses the caller-supplied sessionManager (so per-task .jsonl files stay under
+ *  our control). Extension-free host deps may be cached, while
  *  provider-configured or allowlisted-extension deps are session-local because
  *  Pi binds mutable extension callbacks onto each loader runtime. */
 async function buildDelegateSession(
@@ -484,10 +483,6 @@ async function acquireAgentSession(
       };
     }
 
-    // Link resumed session to parent for /resume discoverability.
-    const parentFile = env.parentSessionManager?.getSessionFile?.();
-    if (parentFile) setParentSession(resumed, parentFile);
-
     const session = await buildDelegateSession(
       task,
       resumed,
@@ -508,10 +503,7 @@ async function acquireAgentSession(
     // isolation. Keep scratch transcripts in memory only.
     sessionManager = SessionManager.inMemory(task.cwd);
   } else {
-    const fresh = createSubagentSessionManager(
-      env.parentSessionManager,
-      task.cwd,
-    );
+    const fresh = createSubagentSessionManager(task.cwd);
     if (!fresh) {
       return {
         error: failTask(task, "Internal: could not create session file"),

package/migrate-delegate-sessions.ts

@@ -0,0 +1,202 @@
+/**
+ * Move old pi-delegate sessions out of Pi's normal session index.
+ *
+ * This is intentionally a standalone migration, not extension startup code:
+ * `pi -r` indexes sessions before extensions are loaded.
+ *
+ * Usage:
+ *   bun run migrate-delegate-sessions.ts          # report only
+ *   bun run migrate-delegate-sessions.ts --apply  # unlink and move
+ */
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { getAgentDir } from "@earendil-works/pi-coding-agent";
+
+type JsonObject = Record<string, unknown>;
+
+const agentDir = getAgentDir();
+const sourceDir = path.join(agentDir, "sessions");
+const destinationDir = path.join(agentDir, "delegate-sessions");
+const apply = process.argv.includes("--apply");
+
+function isObject(value: unknown): value is JsonObject {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+function isWithin(root: string, candidate: string): boolean {
+  const relative = path.relative(root, candidate);
+  return (
+    relative === "" ||
+    (!relative.startsWith(`..${path.sep}`) &&
+      relative !== ".." &&
+      !path.isAbsolute(relative))
+  );
+}
+
+function readSession(file: string): JsonObject[] | undefined {
+  try {
+    const lines = fs.readFileSync(file, "utf8").split(/\r?\n/);
+    const entries: JsonObject[] = [];
+    for (const line of lines) {
+      if (!line.trim()) continue;
+      const parsed: unknown = JSON.parse(line);
+      if (!isObject(parsed)) return undefined;
+      entries.push(parsed);
+    }
+    return entries;
+  } catch {
+    return undefined;
+  }
+}
+
+function readSessionHeader(file: string): JsonObject | undefined {
+  try {
+    const firstLine = fs.readFileSync(file, "utf8").split(/\r?\n/, 1)[0];
+    const parsed: unknown = JSON.parse(firstLine);
+    return isObject(parsed) && parsed.type === "session" ? parsed : undefined;
+  } catch {
+    return undefined;
+  }
+}
+
+function sessionHeader(entries: JsonObject[]): JsonObject | undefined {
+  const header = entries[0];
+  return header?.type === "session" ? header : undefined;
+}
+
+function entryKey(entry: JsonObject): string {
+  return JSON.stringify(entry);
+}
+
+/**
+ * Pi's forkFrom() copies every non-header entry from the source session before
+ * writing anything new. Old delegate sessions do not copy the parent history.
+ * This is the discriminator: parentSession by itself is deliberately not
+ * sufficient because genuine Pi forks also have it.
+ */
+function isPiFork(
+  childEntries: JsonObject[],
+  parentEntries: JsonObject[],
+): boolean {
+  const childBody = childEntries.slice(1);
+  const parentBody = parentEntries.slice(1);
+  if (parentBody.length === 0 || childBody.length < parentBody.length) {
+    return false;
+  }
+  return parentBody.every(
+    (entry, index) => entryKey(entry) === entryKey(childBody[index]),
+  );
+}
+
+function findJsonlFiles(directory: string): string[] {
+  if (!fs.existsSync(directory)) return [];
+  const files: string[] = [];
+  const visit = (current: string): void => {
+    for (const entry of fs.readdirSync(current, { withFileTypes: true })) {
+      const candidate = path.join(current, entry.name);
+      if (entry.isDirectory()) visit(candidate);
+      else if (entry.isFile() && entry.name.endsWith(".jsonl"))
+        files.push(candidate);
+    }
+  };
+  visit(directory);
+  return files;
+}
+
+interface MigrationCandidate {
+  source: string;
+  destination: string;
+}
+
+const candidates: MigrationCandidate[] = [];
+let skipped = 0;
+const parentCache = new Map<string, JsonObject[] | undefined>();
+
+for (const file of findJsonlFiles(sourceDir)) {
+  const header = readSessionHeader(file);
+  const parent = header?.parentSession;
+  if (!header || typeof parent !== "string") continue;
+
+  const parentPath = path.resolve(parent);
+  if (!isWithin(sourceDir, parentPath) || !fs.existsSync(parentPath)) {
+    skipped++;
+    console.warn(`skip (parent unavailable): ${file}`);
+    continue;
+  }
+
+  let parentEntries = parentCache.get(parentPath);
+  if (parentEntries === undefined && !parentCache.has(parentPath)) {
+    parentEntries = readSession(parentPath);
+    parentCache.set(parentPath, parentEntries);
+  }
+  const entries = readSession(file);
+  if (!entries) {
+    skipped++;
+    console.warn(`skip (invalid session): ${file}`);
+    continue;
+  }
+  if (!parentEntries || isPiFork(entries, parentEntries)) continue;
+
+  const relative = path.relative(sourceDir, file);
+  candidates.push({
+    source: file,
+    destination: path.join(destinationDir, relative),
+  });
+}
+
+console.log(
+  `${apply ? "Migrating" : "Found"} ${candidates.length} delegate session(s); ` +
+    `${skipped} skipped because their parent could not be verified.`,
+);
+
+if (!apply) {
+  for (const candidate of candidates) {
+    console.log(`would move: ${candidate.source} -> ${candidate.destination}`);
+  }
+  console.log("Nothing changed. Re-run with --apply to perform the migration.");
+  process.exit(0);
+}
+
+let moved = 0;
+for (const candidate of candidates) {
+  const entries = readSession(candidate.source);
+  const header = entries && sessionHeader(entries);
+  if (!entries || !header) {
+    console.warn(`skip (changed during migration): ${candidate.source}`);
+    continue;
+  }
+
+  delete header.parentSession;
+  const parent = path.dirname(candidate.destination);
+  fs.mkdirSync(parent, { recursive: true });
+
+  const temporary = `${candidate.source}.delegate-migration-${process.pid}.tmp`;
+  try {
+    if (fs.existsSync(candidate.destination)) {
+      throw new Error("destination already exists");
+    }
+    fs.writeFileSync(
+      temporary,
+      `${entries.map((entry) => JSON.stringify(entry)).join("\n")}\n`,
+      { flag: "wx", mode: 0o600 },
+    );
+    fs.renameSync(temporary, candidate.source);
+    fs.renameSync(candidate.source, candidate.destination);
+    console.log(`moved: ${candidate.source} -> ${candidate.destination}`);
+    moved++;
+  } catch (error) {
+    try {
+      if (fs.existsSync(temporary)) fs.unlinkSync(temporary);
+    } catch {
+      // Preserve the original error below; the temp file is harmless and
+      // uniquely named for this process.
+    }
+    console.error(
+      `failed: ${candidate.source}: ${
+        error instanceof Error ? error.message : String(error)
+      }`,
+    );
+  }
+}
+
+console.log(`Moved ${moved}/${candidates.length} delegate session(s).`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bermudi/pi-delegate",
-  "version": "0.1.6",
+  "version": "0.1.7",
   "description": "Delegate tool for the Pi coding agent.",
   "keywords": [
     "pi-package"

package/sessions.ts

@@ -1,67 +1,26 @@
 import * as fs from "node:fs";
-import { SessionManager } from "@earendil-works/pi-coding-agent";
+import { join } from "node:path";
+import { SessionManager, getAgentDir } from "@earendil-works/pi-coding-agent";
 
-/** Link a subagent session to its parent and persist the header when possible. */
-export function setParentSession(sm: SessionManager, parentPath: string): void {
-  const inner = sm as unknown as {
-    fileEntries: Array<{ type: string; parentSession?: string }>;
-    getSessionFile?: () => string | undefined;
-    _rewriteFile?: () => void;
-  };
-  const header = inner.fileEntries[0];
-  if (header && header.type === "session") {
-    header.parentSession = parentPath;
-    // For a *resumed* session the file already exists on disk and the manager
-    // is flushed (SessionManager.open/setSessionFile sets flushed=true). The
-    // in-memory header mutation above is otherwise lost: upstream _persist()
-    // only *appends* new entries once flushed — it never rewrites the header.
-    // So a resumeFrom session would never surface as a child in /resume despite
-    // the link being set in memory. Rewrite the whole file (header + entries)
-    // so the parentSession field is actually persisted. Fresh sessions skip
-    // this (file doesn't exist yet); their first _persist() writes the mutated
-    // header along with the rest, and rewriting early would trip the
-    // duplicate-header bug in _persist()'s not-yet-flushed path.
-    const file = inner.getSessionFile?.();
-    if (file && fs.existsSync(file)) {
-      try {
-        inner._rewriteFile?.();
-      } catch {
-        /* best effort — link stays in-memory; not fatal */
-      }
-    }
-  }
+/** Persistent storage for delegate-only conversations. */
+export function getDelegateSessionDir(): string {
+  return join(getAgentDir(), "delegate-sessions");
 }
 
 /**
  * Create a session manager for a subagent run.
  *
- * Always creates a standalone session file in the target cwd.
- * Sets `parentSession` in the header so subagent work is discoverable
- * as a child of the parent session in `/resume`.
- *
- * Returns the concrete `SessionManager` (ready to hand to `createAgentSession`)
- * and its file path (for result reporting + pool bookkeeping).
+ * Delegate sessions are deliberately standalone and live in their own
+ * directory. They are not attached to the parent's session tree.
  */
 export function createSubagentSessionManager(
-  parentSessionManager: unknown,
   cwd: string,
 ): { manager: SessionManager; file: string } | undefined {
-  // Resolve parent session file path for linking.
-  const parentFile = (
-    parentSessionManager as
-      { getSessionFile?(): string | undefined } | undefined
-  )?.getSessionFile?.();
-
-  // Always persist subagent work so the main agent can search it later.
-  const sm = SessionManager.create(cwd);
+  // Always persist subagent work separately from the parent's session tree.
+  const sm = SessionManager.create(cwd, getDelegateSessionDir());
   const sessionFile = sm.getSessionFile();
   if (!sessionFile) return undefined;
 
-  // Link to parent session so subagent appears as a child in /resume.
-  if (parentFile) {
-    setParentSession(sm, parentFile);
-  }
-
   return { manager: sm, file: sessionFile };
 }
 

package/types.ts

@@ -251,8 +251,6 @@ export interface TaskRunEnv {
   /** Abort signal — parent's for sync, ticket's for async. May be undefined when no parent signal is available. */
   signal: AbortSignal | undefined;
   modelRegistry: ModelRegistry;
-  /** Parent session manager — used to link subagent sessions for /resume. */
-  parentSessionManager: { getSessionFile?(): string | undefined } | undefined;
   /** Ticket id for busy-guard self-checks. undefined for sync. */
   ticketId?: string;
   /** When the delegate started. Used for close/list progress (elapsed time). */