pi-resume 1.1.0 → 1.2.1

package/README.md

@@ -12,8 +12,8 @@ Commands that use `stat()` + lazy partial reads:
 
 | Command | What it does | Speed |
 |---------|-------------|-------|
-| `/r1` … `/r5` | Instantly switch to the N-th most recent session (`/r1` = latest) | <50ms (stat-only) |
-| `pi --r N` / `--r1`…`--r5` / `--rn` | Startup flag: open pi and immediately resume the N-th most recent session | <50ms (stat-only) |
+| `/r1` / `/r2` | Instantly switch to the latest / 2nd most recent session | <50ms (stat-only) |
+| `pi --r N` / `--r1` / `--r2` / `--rn` | Startup flag: open pi and immediately resume the N-th most recent session | <50ms (stat-only) |
 | `/rn` / `/rp` | Step to the next (older) / previous (newer) session relative to the current one | <50ms (stat-only) |
 | `/rs` | Paginated picker: last 20, with tier navigation | <200ms first page |
 | `/rds` | Delete subagent session trees for the current project (with confirmation) | — |
@@ -21,18 +21,21 @@ Commands that use `stat()` + lazy partial reads:
 ## Install
 
 ```bash
-pi install npm:pi-fast-resume
+pi install npm:pi-resume
 ```
 
 ## Commands
 
-### `/r1` … `/r5` — Instant Ranked Resume
+### `/r1` / `/r2` — Instant Ranked Resume
 
 Switch to the N-th most recent session (by mtime) in one step. No picker, no parsing.
 
 - `/r1` — most recent session
 - `/r2` — 2nd most recent
-- … up to `/r5` — 5th most recent
+
+For anything further back use `/rn` / `/rp` — the rank changes every time you
+switch (the current session is excluded), so deep ranks are more confusing
+than stepping.
 
 The current session is always excluded from the ranking, so `/r1` reliably jumps
 to the previous session. If fewer sessions exist than the requested rank, a
@@ -40,16 +43,16 @@ notice is shown and nothing is switched.
 
 ### `pi --r N` — Resume at Startup
 
-Start pi and immediately switch to the N-th most recent session (1-5):
+Start pi and immediately switch to the N-th most recent session (1-2):
 
 ```bash
 pi --r1    # open pi in the latest session
 pi --rn    # same (alias for --r1)
-pi --r3    # open pi in the 3rd most recent
-pi --r 3   # same, numeric form
+pi --r2    # open pi in the 2nd most recent
+pi --r 2   # same, numeric form
 ```
 
-Same ranking as `/r1`…`/r5`. Invalid values show an error and start a normal
+Same ranking as `/r1`/`/r2`. Invalid values show an error and start a normal
 new session. Interactive mode only (ignored with `-p`).
 
 ### `/rn` / `/rp` — Step Navigation
@@ -94,11 +97,32 @@ by hundreds of MB.
 `/rds` scans the **current project only**, shows how many trees / runs / MB
 would be freed, asks for **confirmation**, then recursively deletes just those
 subagent tree subdirectories. Your real top-level `*.jsonl` sessions (the ones
-`/r1`…`/r5` and `/rs` list) are never touched.
+`/r1`/`/r2` and `/rs` list) are never touched.
+
+### Sessions open in another pi are skipped
+
+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.
+
+### Legacy subagent forks are tidied up once
+
+pi-subagents < 0.53 stored forked child sessions **loose** in the project
+sessions dir — same filename shape and `parentSession` header as your own
+`/fork`s, so they polluted `/resume` and every navigation command. Since 0.53
+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.
 
 ## How it works
 
-1. **`/r1`…`/r5`**: `readdir` → `stat` each `.jsonl` → sort by mtime → exclude current → `switchSession(others[rank-1])`
+1. **`/r1`/`/r2`**: `readdir` → `stat` each `.jsonl` → sort by mtime → exclude current + open elsewhere → `switchSession(others[rank-1])`
 2. **`/rs`**: Same stat scan, then read only the **first ~50 lines** of each file on the current page to extract session name and first user message
 
 No full file parsing. No `buildSessionInfo()`. No reading message content beyond the first user message.
@@ -106,7 +130,7 @@ No full file parsing. No `buildSessionInfo()`. No reading message content beyond
 ## Development
 
 ```bash
-git clone https://github.com/spex66/pi-fast-resume.git
+git clone https://github.com/axelbaumlisto/pi-fast-resume.git
 cd pi-fast-resume
 npm install
 npm test

package/extensions/index.ts

@@ -2,10 +2,10 @@
  * pi-fast-resume — fast session resume without reading all .jsonl files.
  *
  * Commands:
- *   /r1 .. /r5       — instantly switch to the N-th most recent session
- *                      (stat-only; /r1 = latest, /r5 = 5th, current excluded)
+ *   /r1 .. /r2       — instantly switch to the N-th most recent session
+ *                      (stat-only; /r1 = latest, /r2 = 2nd, current excluded)
  *   pi --r N         — same as /rN but at startup (pi --r 1 = resume latest)
- *   pi --r1 .. --r5  — boolean form of the same (pi --r1 = resume latest)
+ *   pi --r1 .. --r2  — boolean form of the same (pi --r1 = resume latest)
  *   pi --rn          — alias for --r1 (mirrors /rn from a fresh session)
  *   /rn / /rp        — step to the next (older) / previous (newer) session
  *                      relative to the current one (by mtime)
@@ -14,6 +14,11 @@
  *   /rs set days N   — set maxDays filter (0-30, 0 = no limit)
  *   /rds             — delete all subagent session trees for the current project
  *                      (asks for confirmation; top-level sessions untouched)
+ *
+ * All navigation skips sessions currently open in another live pi process
+ * (src/active.ts). At startup, legacy subagent fork sessions left loose by
+ * pi-subagents < 0.53 are moved once into `<parent>/forks/` (src/migrate.ts),
+ * so afterwards nothing needs filtering and every command stays stat-only.
  */
 
 import type {
@@ -32,13 +37,15 @@ 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 } from "../src/nav.ts";
+import { rankTarget, navTarget, 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";
 
 const DAY_TIERS = [7, 14, 0] as const;
 
 // How many ranked instant-resume commands to register: /r1 .. /rN.
-const MAX_RANK = 5;
+const MAX_RANK = 2;
 
 const ordinal = (n: number): string => {
   if (n === 1) return "most recent";
@@ -53,6 +60,31 @@ const scanErrorNotifier = (ctx: ExtensionContext) => (message: string) =>
 const sessionDirFor = (ctx: ExtensionContext): string =>
   getSessionDir(ctx.cwd, ctx.sessionManager.getSessionFile() ?? undefined);
 
+/** Hidden-file predicate: sessions open in another live pi (one readdir). */
+async function hiddenPredicate(): Promise<Hidden<{ file: string }>> {
+  const elsewhere = await activeElsewhere();
+  return async (f) => elsewhere.has(f.file);
+}
+
+/**
+ * Move legacy loose subagent forks into `<parent>/forks/`. Runs detached in
+ * the background at startup; only reports when something actually moved.
+ * Skips the current session and sessions held by other live pi processes.
+ */
+async function migrateForksInBackground(ctx: ExtensionContext): Promise<void> {
+  const sessionDir = sessionDirFor(ctx);
+  const files = await statScan(sessionDir);
+  const skip = await activeElsewhere();
+  const current = ctx.sessionManager.getSessionFile();
+  if (current) skip.add(current);
+  const forks = await findLegacyForks(files, skip);
+  if (forks.length === 0) return;
+  const moved = await migrateLegacyForks(forks);
+  if (moved > 0) {
+    ctx.ui.notify(`Moved ${moved} legacy subagent fork session${moved === 1 ? "" : "s"} into <parent>/forks/`, "info");
+  }
+}
+
 /** Switch to a session file with a "Resumed: <label>" notice. */
 async function switchTo(
   ctx: ExtensionCommandContext,
@@ -92,7 +124,8 @@ async function resumeRank(rank: number, baseCtx: ExtensionContext): Promise<void
   }
 
   const currentFile = ctx.sessionManager.getSessionFile() ?? undefined;
-  const { target, othersCount } = rankTarget(files, currentFile, rank);
+  const hidden = await hiddenPredicate();
+  const { target, othersCount } = await rankTarget(files, currentFile, rank, hidden);
 
   if (!target) {
     ctx.ui.notify(
@@ -116,7 +149,7 @@ export default function (pi: ExtensionAPI) {
     });
   }
 
-  // Startup flags: pi --r N, pi --r1 .. --r5, pi --rn (alias for --r1).
+  // Startup flags: pi --r N, pi --r1 .. --r2, pi --rn (alias for --r1).
   pi.registerFlag("r", {
     description: `Resume the N-th most recent session at startup (1-${MAX_RANK}, 1 = latest)`,
     type: "string",
@@ -150,11 +183,19 @@ export default function (pi: ExtensionAPI) {
   };
 
   pi.on("session_start", async (event: SessionStartEvent, ctx) => {
+    // Advertise which session this pi holds so other instances skip it.
+    await markActive(ctx.sessionManager.getSessionFile() ?? undefined);
     if (event.reason !== "startup") return;
+    void migrateForksInBackground(ctx).catch(() => {});
     const rank = startupRank(ctx);
     if (rank !== undefined) await resumeRank(rank, ctx);
   });
 
+  // Fires on switch (followed by session_start) and on exit.
+  pi.on("session_shutdown", async () => {
+    await unmarkActive();
+  });
+
   // /rn — step to the next OLDER session; /rp — step to the next NEWER one.
   const NAV = [
     { cmd: "rn", dir: 1, desc: "Resume the next (older) session", edge: "Already at the oldest session" },
@@ -172,7 +213,8 @@ export default function (pi: ExtensionAPI) {
         }
 
         const currentFile = ctx.sessionManager.getSessionFile() ?? undefined;
-        const { target, pos, total } = navTarget(files, currentFile, dir);
+        const hidden = await hiddenPredicate();
+        const { target, pos, total } = await navTarget(files, currentFile, dir, hidden);
 
         if (!target) {
           ctx.ui.notify(edge, "info");
@@ -271,6 +313,7 @@ export default function (pi: ExtensionAPI) {
       const sessionDir = sessionDirFor(ctx);
       const currentFile = ctx.sessionManager.getSessionFile() ?? undefined;
       const onError = scanErrorNotifier(ctx);
+      const hidden = await hiddenPredicate();
 
       let tierIndex = 0;
       let offset = 0;
@@ -286,6 +329,7 @@ export default function (pi: ExtensionAPI) {
           currentDays > 0 ? currentDays : undefined,
           currentFile,
           onError,
+          hidden,
         );
 
         if (entries.length === 0 && offset === 0) {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "pi-resume",
-  "version": "1.1.0",
-  "description": "Fast session resume for pi coding agent — /r1../r5 ranked resume, /rn and /rp step navigation, pi --r1/--rn startup flags, /rs paginated picker, /rds subagent session cleanup",
+  "version": "1.2.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",
   "keywords": [
@@ -13,7 +13,7 @@
   ],
   "repository": {
     "type": "git",
-    "url": "https://github.com/spex66/pi-fast-resume.git"
+    "url": "https://github.com/axelbaumlisto/pi-fast-resume.git"
   },
   "files": [
     "extensions",

package/src/active.ts

@@ -0,0 +1,77 @@
+/**
+ * Registry of sessions currently open in live pi processes on this machine.
+ *
+ * Every pi instance that loads this extension writes
+ * `<pi-agent-dir>/extensions/pi-fast-resume/active/<pid>.json` = { file }
+ * on session_start and removes it on session_shutdown. Readers skip records
+ * whose pid is dead (crash / kill -9), so stale files are harmless and are
+ * cleaned up opportunistically.
+ */
+
+import { readdir, readFile, writeFile, mkdir, unlink } from "node:fs/promises";
+import { join } from "node:path";
+import { getPiAgentDir } from "./pi-dir.ts";
+
+const activeDir = (): string => join(getPiAgentDir(), "extensions", "pi-fast-resume", "active");
+const recordPath = (pid: number): string => join(activeDir(), `${pid}.json`);
+
+function pidAlive(pid: number): boolean {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (err: any) {
+    // EPERM = exists but not ours; still alive.
+    return err?.code === "EPERM";
+  }
+}
+
+/** 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) {
+    await unmarkActive(pid);
+    return;
+  }
+  try {
+    await mkdir(activeDir(), { recursive: true });
+    await writeFile(recordPath(pid), JSON.stringify({ file }));
+  } catch {}
+}
+
+/** Remove this process's record (session closed / pi exiting). */
+export async function unmarkActive(pid = process.pid): Promise<void> {
+  try {
+    await unlink(recordPath(pid));
+  } catch {}
+}
+
+/**
+ * Session files held open by OTHER live processes. Stale records (dead pid)
+ * are deleted as a side effect.
+ */
+export async function activeElsewhere(selfPid = process.pid): Promise<Set<string>> {
+  const result = new Set<string>();
+  let names: string[];
+  try {
+    names = await readdir(activeDir());
+  } catch {
+    return result;
+  }
+  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 {}
+        return;
+      }
+      try {
+        const rec = JSON.parse(await readFile(path, "utf8"));
+        if (typeof rec?.file === "string") result.add(rec.file);
+      } catch {}
+    }),
+  );
+  return result;
+}

package/src/migrate.ts

@@ -0,0 +1,128 @@
+/**
+ * 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).
+ *
+ * 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.
+ */
+
+import { open, rename, mkdir, access } from "node:fs/promises";
+import { createReadStream } from "node:fs";
+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-';
+
+async function readSlice(file: string, position: number, length: number): Promise<string> {
+  const fh = await open(file, "r");
+  try {
+    const buf = Buffer.alloc(length);
+    const { bytesRead } = await fh.read(buf, 0, length, position);
+    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));
+  } catch {
+    return undefined;
+  }
+  const firstLine = head.split("\n", 1)[0] ?? "";
+  if (!firstLine.includes('"parentSession"')) return undefined;
+  try {
+    const parent = JSON.parse(firstLine)?.parentSession;
+    return typeof parent === "string" && parent ? parent : undefined;
+  } catch {
+    return undefined;
+  }
+}
+
+/** Is this fork a subagent child (vs. a manual /fork)? */
+async function isSubagentChild(ref: StatResult): Promise<boolean> {
+  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);
+}
+
+export interface LegacyFork {
+  file: string;
+  target: string;
+}
+
+/**
+ * Canonical nested location for a fork: next to the parent's session tree,
+ * inside the child's own sessions dir.
+ */
+export function forkTarget(file: string, parentSession: string): string {
+  return join(dirname(file), basename(parentSession, ".jsonl"), "forks", basename(file));
+}
+
+/** 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;
+    const parent = await parentOf(ref);
+    if (!parent) continue;
+    if (!(await isSubagentChild(ref))) continue;
+    out.push({ file: ref.file, target: forkTarget(ref.file, parent) });
+  }
+  return out;
+}
+
+/** Rename each fork into place. Existing targets are never overwritten. Returns moved count. */
+export async function migrateLegacyForks(forks: LegacyFork[]): Promise<number> {
+  let moved = 0;
+  for (const { file, target } of forks) {
+    try {
+      await access(target);
+      continue; // already there — leave both untouched, never clobber
+    } catch {}
+    try {
+      await mkdir(dirname(target), { recursive: true });
+      await rename(file, target);
+      moved++;
+    } catch {}
+  }
+  return moved;
+}

package/src/nav.ts

@@ -1,39 +1,67 @@
 /**
  * Pure session-navigation logic: ranked resume (/r1../rN, --r) and
  * step navigation (/rn, /rp). No pi SDK dependency.
+ *
+ * All walkers take an async `hidden` predicate and skip files it rejects.
+ * The predicate is evaluated lazily, only for files actually visited, so a
+ * costly check (e.g. scanning a fork file) is paid per candidate, not per
+ * directory.
  */
 
 export interface FileRef {
   file: string;
 }
 
+export type Hidden<T extends FileRef> = (f: T) => Promise<boolean>;
+
+const never = async () => false;
+
 /**
- * Rank-th most recent session, current excluded (rank 1 = latest).
- * Returns the target or undefined, plus how many candidates exist.
+ * Rank-th most recent visible session, current excluded (rank 1 = latest).
+ * Returns the target or undefined, plus how many visible candidates were seen.
  */
-export function rankTarget<T extends FileRef>(
+export async function rankTarget<T extends FileRef>(
   files: T[],
   currentFile: string | undefined,
   rank: number,
-): { target?: T; othersCount: number } {
-  const others = files.filter((f) => f.file !== currentFile);
-  return { target: others[rank - 1], othersCount: others.length };
+  hidden: Hidden<T> = never,
+): Promise<{ target?: T; othersCount: number }> {
+  let seen = 0;
+  for (const f of files) {
+    if (f.file === currentFile || (await hidden(f))) continue;
+    seen++;
+    if (seen === rank) return { target: f, othersCount: seen };
+  }
+  return { target: undefined, othersCount: seen };
 }
 
 /**
- * Step relative to the current session in the mtime-sorted list.
- * dir = 1 → older, dir = -1 → newer. An unsaved current session
- * (not in the list) is treated as the newest.
+ * Step relative to the current session in the mtime-sorted list, 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.
  */
-export function navTarget<T extends FileRef>(
+export async function navTarget<T extends FileRef>(
   files: T[],
   currentFile: string | undefined,
   dir: 1 | -1,
-): { target?: T; pos: number; total: number } {
+  hidden: Hidden<T> = never,
+): Promise<{ target?: T; pos: number; total: number }> {
   const idx = files.findIndex((f) => f.file === currentFile);
-  const target = idx === -1 ? (dir === 1 ? files[0] : undefined) : files[idx + dir];
-  const pos = target ? files.indexOf(target) + 1 : 0;
-  return { target, pos, total: files.length };
+  let i = idx === -1 ? (dir === 1 ? 0 : -1) : idx + dir;
+  while (i >= 0 && i < files.length) {
+    const f = files[i]!;
+    if (!(await hidden(f))) return { target: f, pos: i + 1, total: files.length };
+    i += dir;
+  }
+  return { target: undefined, pos: 0, total: files.length };
+}
+
+/** Keep only visible files (order preserved). */
+export async function filterVisible<T extends FileRef>(files: T[], hidden: Hidden<T>): Promise<T[]> {
+  const out: T[] = [];
+  for (const f of files) if (!(await hidden(f))) out.push(f);
+  return out;
 }
 
 /**

package/src/scanner.ts

@@ -223,6 +223,7 @@ export async function scanPage(
   maxDays?: number,
   excludeFile?: string,
   onError?: (message: string) => void,
+  hidden?: (f: StatResult) => Promise<boolean>,
 ): Promise<{ entries: SessionEntry[]; total: number; hasMore: boolean }> {
   const all = await statScan(sessionDir, onError);
 
@@ -236,6 +237,12 @@ export async function scanPage(
     filtered = filtered.filter((f) => f.file !== excludeFile);
   }
 
+  if (hidden) {
+    const kept: StatResult[] = [];
+    for (const f of filtered) if (!(await hidden(f))) kept.push(f);
+    filtered = kept;
+  }
+
   const total = filtered.length;
   const page = filtered.slice(offset, offset + limit);
   const hasMore = offset + limit < total;