pi-resume 1.2.1 → 1.3.1

package/README.md

@@ -63,7 +63,12 @@ Walk the mtime-sorted session list relative to the **current** session:
 - `/rp` — previous session (one step **newer**)
 
 Useful after `/r1` lands on the wrong session: keep pressing `/rn` to walk back
-in time instead of recalculating ranks. A `(pos/total)` indicator is shown on
+in time instead of recalculating ranks.
+
+`/rn` / `/rp` walk by **creation time** (the timestamp in the session filename),
+not by mtime: resuming a session makes extensions append to it, which bumps its
+mtime and would otherwise reshuffle the list into a ping-pong between two
+sessions. `/r1` and `/rs` still rank by last activity (mtime). A `(pos/total)` indicator is shown on
 each switch. At the ends of the list a notice is shown and nothing is switched.
 
 ### `/rs` — Smart Resume
@@ -103,8 +108,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 +121,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

@@ -37,7 +37,7 @@ import {
 import { formatEntry, truncate, sessionLabel, formatSize } from "../src/format.ts";
 import { loadConfig, saveConfig, clampPage, clampDays } from "../src/config.ts";
 import { getSessionDir } from "../src/session-dir.ts";
-import { rankTarget, navTarget, parseRankFlag, type Hidden } from "../src/nav.ts";
+import { rankTarget, navTarget, sortByCreated, parseRankFlag, type Hidden } from "../src/nav.ts";
 import { buildPickerItems, resolveChoice } from "../src/picker.ts";
 import { markActive, unmarkActive, activeElsewhere } from "../src/active.ts";
 import { findLegacyForks, migrateLegacyForks } from "../src/migrate.ts";
@@ -214,7 +214,9 @@ export default function (pi: ExtensionAPI) {
 
         const currentFile = ctx.sessionManager.getSessionFile() ?? undefined;
         const hidden = await hiddenPredicate();
-        const { target, pos, total } = await navTarget(files, currentFile, dir, hidden);
+        // Walk by creation time: resuming bumps mtime, which would reshuffle
+        // an mtime-ordered walk into a ping-pong between two sessions.
+        const { target, pos, total } = await navTarget(sortByCreated(files), currentFile, dir, hidden);
 
         if (!target) {
           ctx.ui.notify(edge, "info");
@@ -313,7 +315,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 +334,6 @@ export default function (pi: ExtensionAPI) {
           currentDays > 0 ? currentDays : undefined,
           currentFile,
           onError,
-          hidden,
         );
 
         if (entries.length === 0 && offset === 0) {
@@ -343,7 +347,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 +372,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.1",
   "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;

package/src/nav.ts

@@ -16,6 +16,36 @@ export type Hidden<T extends FileRef> = (f: T) => Promise<boolean>;
 
 const never = async () => false;
 
+// pi session filenames: `<ISO timestamp with '-' instead of ':' and '.'>_<uuid>.jsonl`
+// e.g. 2026-08-10T14-31-05-921Z_019fec15-....jsonl
+const FILENAME_TS_RE = /(\d{4}-\d{2}-\d{2})T(\d{2})-(\d{2})-(\d{2})-(\d{3})Z_/;
+
+/**
+ * Session creation time from the filename (immutable), or undefined if the
+ * name doesn't follow pi's pattern.
+ */
+export function createdAtFromName(file: string): number | undefined {
+  const base = file.slice(file.lastIndexOf("/") + 1);
+  const m = FILENAME_TS_RE.exec(base);
+  if (!m) return undefined;
+  const t = Date.parse(`${m[1]}T${m[2]}:${m[3]}:${m[4]}.${m[5]}Z`);
+  return isNaN(t) ? undefined : t;
+}
+
+/**
+ * Stable order for step navigation: newest-created first.
+ *
+ * mtime is NOT stable for walking: resuming a session makes extensions append
+ * entries (e.g. state on session_start), which bumps its mtime to "now" and
+ * reshuffles the list, so /rn, /rn, /rn ping-pongs between two sessions.
+ * Creation time never changes, so a walk over it is predictable. Files
+ * without a parseable timestamp fall back to mtime.
+ */
+export function sortByCreated<T extends FileRef & { mtime: Date }>(files: T[]): T[] {
+  const key = (f: T) => createdAtFromName(f.file) ?? f.mtime.getTime();
+  return [...files].sort((a, b) => key(b) - key(a));
+}
+
 /**
  * Rank-th most recent visible session, current excluded (rank 1 = latest).
  * Returns the target or undefined, plus how many visible candidates were seen.
@@ -36,8 +66,8 @@ export async function rankTarget<T extends FileRef>(
 }
 
 /**
- * Step relative to the current session in the mtime-sorted list, skipping
- * hidden files. dir = 1 → older, dir = -1 → newer. An unsaved current session
+ * Step relative to the current session in the given list (callers pass
+ * sortByCreated() output for a stable walk), skipping hidden files. dir = 1 → older, dir = -1 → newer. An unsaved current session
  * (not in the list) is treated as the newest. `pos`/`total` are raw list
  * indices (1-based) for the on-screen indicator.
  */