pi-resume 1.2.1 → 1.3.0

package/README.md

@@ -103,8 +103,10 @@ subagent tree subdirectories. Your real top-level `*.jsonl` sessions (the ones
 
 Each pi instance with this extension records its current session file in
 `~/.pi/agent/extensions/pi-fast-resume/active/<pid>.json` (removed on exit;
-dead pids are ignored). `/r1`, `/r2`, `/rn`, `/rp`, `/rs` and `--r` never land
-on a chat you have open in another terminal.
+dead or reused pids are ignored). `/r1`, `/r2`, `/rn`, `/rp` and `--r` never
+land on a chat you have open in another terminal. `/rs` still lists such
+sessions, marked with `⦿`, so you can see where a chat went — selecting one is
+refused instead of hijacking the other instance.
 
 ### Legacy subagent forks are tidied up once
 
@@ -114,11 +116,14 @@ sessions dir — same filename shape and `parentSession` header as your own
 the canonical place is `<parent>/forks/<file>.jsonl`.
 
 On startup this extension moves such files there (detached, in the background,
-one time per file). A file is moved only if it has a `parentSession` header
-**and** contains the delegated-subagent task prompt or a `subagent-*` session
-name; manual `/fork`s are untouched. The current session and sessions open in
-other pi instances are skipped; existing targets are never overwritten. After
-that, nothing needs filtering and every command is stat-only again.
+one time per file). A file is moved only if **all** hold: it was created before
+the fix (2026-08-20), it has a `parentSession` header, it contains the
+delegated-subagent task prompt, and **no human message follows the last task
+prompt** (only orchestrator follow-ups such as steering). That last rule keeps
+manual `/fork`s safe even when their inherited history contains a subagent task.
+The current session and sessions open in other pi instances are skipped;
+existing targets are never overwritten. After that, nothing needs filtering and
+every command is stat-only again.
 
 ## How it works
 

package/extensions/index.ts

@@ -313,7 +313,10 @@ export default function (pi: ExtensionAPI) {
       const sessionDir = sessionDirFor(ctx);
       const currentFile = ctx.sessionManager.getSessionFile() ?? undefined;
       const onError = scanErrorNotifier(ctx);
-      const hidden = await hiddenPredicate();
+      // The picker SHOWS sessions open in another pi (marked) instead of hiding
+      // them, so the user can see where a "missing" chat went; selecting one is
+      // refused rather than hijacking the other instance's session.
+      const elsewhere = await activeElsewhere();
 
       let tierIndex = 0;
       let offset = 0;
@@ -329,7 +332,6 @@ export default function (pi: ExtensionAPI) {
           currentDays > 0 ? currentDays : undefined,
           currentFile,
           onError,
-          hidden,
         );
 
         if (entries.length === 0 && offset === 0) {
@@ -343,7 +345,7 @@ export default function (pi: ExtensionAPI) {
 
         const termWidth = process.stdout.columns || 80;
         const items = buildPickerItems(
-          entries.map((e) => formatEntry(e, termWidth)),
+          entries.map((e) => formatEntry(e, termWidth, elsewhere.has(e.file))),
           {
             remaining: hasMore ? total - offset - entries.length : undefined,
             nextTierLabel:
@@ -368,6 +370,10 @@ export default function (pi: ExtensionAPI) {
           case "entry": {
             const selected = entries[action.index];
             if (!selected) return;
+            if (elsewhere.has(selected.file)) {
+              ctx.ui.notify("That session is open in another pi — not switching", "info");
+              continue;
+            }
             const result = await ctx.switchSession(selected.file, {
               withSession: async (newCtx) => {
                 newCtx.ui.notify(`Resumed: ${truncate(sessionLabel(selected), 50)}`, "info");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-resume",
-  "version": "1.2.1",
+  "version": "1.3.0",
   "description": "Fast session resume for pi coding agent — /r1,/r2 ranked resume, /rn and /rp step navigation, pi --r1/--rn startup flags, /rs paginated picker, /rds subagent session cleanup; skips sessions open in other pi instances, tidies legacy subagent forks",
   "type": "module",
   "license": "MIT",

package/src/active.ts

@@ -9,7 +9,8 @@
  */
 
 import { readdir, readFile, writeFile, mkdir, unlink } from "node:fs/promises";
-import { join } from "node:path";
+import { execFile } from "node:child_process";
+import { basename, join } from "node:path";
 import { getPiAgentDir } from "./pi-dir.ts";
 
 const activeDir = (): string => join(getPiAgentDir(), "extensions", "pi-fast-resume", "active");
@@ -25,6 +26,42 @@ function pidAlive(pid: number): boolean {
   }
 }
 
+/**
+ * `ps` command names for the given pids (one call). Empty map when `ps` is
+ * unavailable (Windows, minimal containers). Names are compared like-for-like
+ * — whatever `ps` reports for our own pid at write time vs. now — so script
+ * launchers (`pi` via `#!/usr/bin/env node`) and comm truncation don't matter.
+ */
+async function psNames(pids: number[]): Promise<Map<number, string>> {
+  const names = new Map<number, string>();
+  if (pids.length === 0 || process.platform === "win32") return names;
+  const out = await new Promise<string>((resolve) =>
+    execFile("ps", ["-o", "pid=,comm=", "-p", pids.join(",")], (err, stdout) => resolve(err ? "" : stdout)),
+  );
+  for (const line of out.split("\n")) {
+    const m = line.trim().match(/^(\d+)\s+(.*)$/);
+    if (m) names.set(Number(m[1]), basename(m[2]!.trim()));
+  }
+  return names;
+}
+
+/**
+ * Guard against pid reuse after a crash: a stale record whose pid was later
+ * handed to an unrelated process must not hide a session forever. Records
+ * carry the `ps` name seen at write time; a live pid whose current name
+ * differs is treated as stale. Returns pids that pass (or cannot be checked).
+ */
+async function verifyExecutables(expected: Map<number, string>): Promise<Set<number>> {
+  const current = await psNames([...expected.keys()]);
+  if (current.size === 0) return new Set(expected.keys()); // no ps — trust liveness
+  const ok = new Set<number>();
+  for (const [pid, exe] of expected) {
+    const now = current.get(pid);
+    if (now === undefined || now === exe) ok.add(pid);
+  }
+  return ok;
+}
+
 /** Record that this process has `file` open. No-op for unsaved sessions. */
 export async function markActive(file: string | undefined, pid = process.pid): Promise<void> {
   if (!file) {
@@ -32,8 +69,9 @@ export async function markActive(file: string | undefined, pid = process.pid): P
     return;
   }
   try {
+    const exe = (await psNames([pid])).get(pid);
     await mkdir(activeDir(), { recursive: true });
-    await writeFile(recordPath(pid), JSON.stringify({ file }));
+    await writeFile(recordPath(pid), JSON.stringify(exe ? { file, exe } : { file }));
   } catch {}
 }
 
@@ -45,8 +83,8 @@ export async function unmarkActive(pid = process.pid): Promise<void> {
 }
 
 /**
- * Session files held open by OTHER live processes. Stale records (dead pid)
- * are deleted as a side effect.
+ * Session files held open by OTHER live pi processes. Stale records (dead
+ * pid, or pid reused by a different executable) are deleted as a side effect.
  */
 export async function activeElsewhere(selfPid = process.pid): Promise<Set<string>> {
   const result = new Set<string>();
@@ -56,22 +94,37 @@ export async function activeElsewhere(selfPid = process.pid): Promise<Set<string
   } catch {
     return result;
   }
+
+  const live = new Map<number, { path: string; file: string; exe?: string }>();
   await Promise.all(
     names.map(async (name) => {
       const pid = parseInt(name, 10);
       if (!name.endsWith(".json") || isNaN(pid) || pid === selfPid) return;
       const path = join(activeDir(), name);
       if (!pidAlive(pid)) {
-        try {
-          await unlink(path);
-        } catch {}
+        await unlink(path).catch(() => {});
         return;
       }
       try {
         const rec = JSON.parse(await readFile(path, "utf8"));
-        if (typeof rec?.file === "string") result.add(rec.file);
+        if (typeof rec?.file === "string") {
+          live.set(pid, { path, file: rec.file, exe: typeof rec.exe === "string" ? rec.exe : undefined });
+        }
       } catch {}
     }),
   );
+
+  // Records with an exe name get verified; legacy records without one are trusted.
+  const toVerify = new Map<number, string>();
+  for (const [pid, rec] of live) if (rec.exe) toVerify.set(pid, rec.exe);
+  const verified = await verifyExecutables(toVerify);
+
+  for (const [pid, rec] of live) {
+    if (rec.exe && !verified.has(pid)) {
+      await unlink(rec.path).catch(() => {});
+      continue;
+    }
+    result.add(rec.file);
+  }
   return result;
 }

package/src/format.ts

@@ -40,8 +40,12 @@ export function sessionLabel(e: SessionEntry): string {
 // break cursor navigation in the picker.
 const PICKER_ROW_MARGIN = 6;
 
-export function formatEntry(e: SessionEntry, maxWidth = 80): string {
+/** Label marker for a session currently open in another pi process. */
+export const OPEN_ELSEWHERE_MARK = "⦿ ";
+
+export function formatEntry(e: SessionEntry, maxWidth = 80, openElsewhere = false): string {
   const prefix = `${formatAge(e.mtime).padEnd(10)} ${formatSize(e.size).padEnd(8)} `;
-  const labelMax = Math.max(10, maxWidth - prefix.length - PICKER_ROW_MARGIN);
-  return prefix + truncate(sessionLabel(e), labelMax);
+  const mark = openElsewhere ? OPEN_ELSEWHERE_MARK : "";
+  const labelMax = Math.max(10, maxWidth - prefix.length - mark.length - PICKER_ROW_MARGIN);
+  return prefix + mark + truncate(sessionLabel(e), labelMax);
 }

package/src/migrate.ts

@@ -1,66 +1,59 @@
 /**
  * One-time migration of legacy subagent fork sessions.
  *
- * pi-subagents < 0.53 wrote forked child sessions loose in the project
- * sessions dir, so they show up in /resume and in every navigation command.
- * Since 0.53 the canonical location is `<parent-basename>/forks/<file>.jsonl`
- * (nested under the parent's session tree, invisible to top-level listings,
- * removed together with the tree by /rds).
+ * pi-subagents < 0.53 (2026-08-20) wrote forked child sessions loose in the
+ * project sessions dir, so they show up in /resume and in every navigation
+ * command. Since 0.53 the canonical location is
+ * `<parent-basename>/forks/<file>.jsonl` (nested under the parent's session
+ * tree, invisible to top-level listings, removed together with the tree by
+ * /rds).
  *
- * This module finds loose files that (a) carry a `parentSession` header and
- * (b) contain the delegated-subagent task prompt or a `subagent-*` session
- * name, and renames them into the canonical location. Manual /fork sessions
- * have (a) but not (b) and are left alone. After one run there is nothing
- * left to scan, so navigation stays stat-only.
+ * A loose file is a subagent fork when ALL hold:
+ *   1. it was created before the fix (filename timestamp < LEGACY_CUTOFF);
+ *   2. its header carries `parentSession`;
+ *   3. it contains the delegated-subagent task prompt;
+ *   4. after the LAST task prompt there is no human user message — only
+ *      orchestrator follow-ups (`Task:`, `Mid-run steering…`, attachments).
+ *
+ * (4) is essential: a manual /fork of a session whose history contains a
+ * subagent task inherits the marker text but then continues with the user's
+ * own messages. Such sessions must never be touched.
+ *
+ * After one run nothing is left to scan (only legacy manual forks, which are
+ * re-verified — a small, non-growing set), so navigation stays stat-only.
  */
 
 import { open, rename, mkdir, access } from "node:fs/promises";
 import { createReadStream } from "node:fs";
+import { createInterface } from "node:readline";
 import { join, dirname, basename } from "node:path";
 import type { StatResult } from "./scanner.ts";
 
 const HEAD_BYTES = 2048;
-const TAIL_BYTES = 4096;
 const TASK_MARKER = "You are a delegated subagent";
-const NAME_MARKER = '"name":"subagent-';
+/** User-role messages a subagent orchestrator injects (not a human). */
+const ORCHESTRATOR_PREFIXES = ["Task:", "Mid-run steering", "<file ", "<attachment"];
+/** pi-subagents 0.53.0 release: forks created on/after this are already nested. */
+export const LEGACY_CUTOFF = "2026-08-20";
 
-async function readSlice(file: string, position: number, length: number): Promise<string> {
+async function readHead(file: string, size: number): Promise<string> {
   const fh = await open(file, "r");
   try {
-    const buf = Buffer.alloc(length);
-    const { bytesRead } = await fh.read(buf, 0, length, position);
+    const len = Math.min(HEAD_BYTES, size);
+    const buf = Buffer.alloc(len);
+    const { bytesRead } = await fh.read(buf, 0, len, 0);
     return buf.subarray(0, bytesRead).toString("utf8");
   } finally {
     await fh.close();
   }
 }
 
-/** Streamed substring search; never buffers the whole file. */
-function streamContains(file: string, marker: string): Promise<boolean> {
-  return new Promise((resolve) => {
-    const stream = createReadStream(file, { encoding: "utf8", highWaterMark: 1 << 20 });
-    let carry = "";
-    const keep = marker.length - 1;
-    stream.on("data", (chunk) => {
-      const text = carry + chunk;
-      if (text.includes(marker)) {
-        stream.destroy();
-        resolve(true);
-        return;
-      }
-      carry = text.slice(-keep);
-    });
-    stream.on("end", () => resolve(false));
-    stream.on("error", () => resolve(false));
-  });
-}
-
 /** Parent session path from the header line, or undefined if not a fork. */
 async function parentOf(ref: StatResult): Promise<string | undefined> {
   if (ref.size === 0) return undefined;
   let head: string;
   try {
-    head = await readSlice(ref.file, 0, Math.min(HEAD_BYTES, ref.size));
+    head = await readHead(ref.file, ref.size);
   } catch {
     return undefined;
   }
@@ -74,14 +67,50 @@ async function parentOf(ref: StatResult): Promise<string | undefined> {
   }
 }
 
-/** Is this fork a subagent child (vs. a manual /fork)? */
-async function isSubagentChild(ref: StatResult): Promise<boolean> {
+/** Text of a user-role message line, or undefined if it is not one. */
+function userText(line: string): string | undefined {
+  if (!line.includes('"role":"user"')) return undefined;
   try {
-    const len = Math.min(TAIL_BYTES, ref.size);
-    const tail = await readSlice(ref.file, ref.size - len, len);
-    if (tail.includes(NAME_MARKER)) return true;
-  } catch {}
-  return streamContains(ref.file, TASK_MARKER);
+    const msg = JSON.parse(line)?.message;
+    if (msg?.role !== "user" || !Array.isArray(msg.content)) return undefined;
+    return msg.content
+      .filter((b: any) => b?.type === "text" && typeof b.text === "string")
+      .map((b: any) => b.text)
+      .join("")
+      .trimStart();
+  } catch {
+    return undefined;
+  }
+}
+
+const isOrchestrator = (text: string): boolean => ORCHESTRATOR_PREFIXES.some((p) => text.startsWith(p));
+
+/**
+ * Single streamed pass: was a task prompt seen, and did a human write
+ * anything after the last one? Never buffers the file.
+ */
+async function isSubagentChild(file: string): Promise<boolean> {
+  let markerSeen = false;
+  let humanAfter = false;
+  try {
+    const rl = createInterface({
+      input: createReadStream(file, { encoding: "utf8" }),
+      crlfDelay: Infinity,
+    });
+    for await (const line of rl) {
+      if (line.includes(TASK_MARKER)) {
+        markerSeen = true;
+        humanAfter = false;
+        continue;
+      }
+      if (!markerSeen || humanAfter) continue;
+      const text = userText(line);
+      if (text && !isOrchestrator(text)) humanAfter = true;
+    }
+  } catch {
+    return false;
+  }
+  return markerSeen && !humanAfter;
 }
 
 export interface LegacyFork {
@@ -97,14 +126,19 @@ export function forkTarget(file: string, parentSession: string): string {
   return join(dirname(file), basename(parentSession, ".jsonl"), "forks", basename(file));
 }
 
+/** Created before the pi-subagents fix? (ISO timestamp prefix sorts lexically.) */
+export function isLegacyName(file: string): boolean {
+  return basename(file) < LEGACY_CUTOFF;
+}
+
 /** Find loose subagent fork sessions among `files`, skipping `skip` paths. */
 export async function findLegacyForks(files: StatResult[], skip: Set<string> = new Set()): Promise<LegacyFork[]> {
   const out: LegacyFork[] = [];
   for (const ref of files) {
-    if (skip.has(ref.file)) continue;
+    if (skip.has(ref.file) || !isLegacyName(ref.file)) continue;
     const parent = await parentOf(ref);
     if (!parent) continue;
-    if (!(await isSubagentChild(ref))) continue;
+    if (!(await isSubagentChild(ref.file))) continue;
     out.push({ file: ref.file, target: forkTarget(ref.file, parent) });
   }
   return out;