respawn-session 0.0.5 → 0.0.9

package/README.md

@@ -25,7 +25,9 @@ Initialize once on each machine. This creates `~/.respawn/index.json` and instal
 respawn init
 ```
 
-Work normally in Claude Code or Codex. `respawn init` makes sessions autosave when the agent stops. To save immediately from inside an active agent session, run:
+Work normally in Claude Code or Codex. `respawn init` makes sessions autosave when the agent stops. If the branch has a GitHub PR, autosave also updates a hidden PR comment so `respawn <pr-number>` works after the worktree or branch is gone.
+
+To save immediately from inside an active agent session, run:
 
 ```sh
 respawn save
@@ -37,10 +39,11 @@ Resume the latest saved session for a branch:
 respawn angela/fix-bugs
 ```
 
-Resume from a PR that was tagged with `respawn tag`:
+Resume from a PR that was autosaved or tagged:
 
 ```sh
 respawn 123
+respawn internetbackyard/gnomos-app#514
 respawn https://github.com/org/repo/pull/123
 ```
 
@@ -80,25 +83,53 @@ After that, Claude Code and Codex Stop hooks run:
 respawn autosave
 ```
 
-Autosave hashes the transcript and skips unchanged sessions, so repeated Stop events do not create duplicate gists.
+Autosave hashes the transcript and skips unchanged sessions, so repeated Stop events do not create duplicate gists. When the current branch has a GitHub PR, autosave also writes or updates the hidden respawn PR comment. That is the normal path for:
+
+```sh
+respawn 517
+```
+
+after you delete the worktree.
 
 ### PR Tagging
 
-Use this when you want a session to survive branch deletion after merge:
+Use this when you want to force-save and attach the current session to the current PR manually:
 
 ```sh
 respawn tag
 ```
 
-That writes or updates a hidden metadata comment on the current GitHub PR. The comment stores session pointers, not the transcript body. Transcripts still live in your private gists.
+That writes or updates the same hidden metadata comment on the current GitHub PR. The comment stores session pointers, not the transcript body. Transcripts still live in your private gists.
 
 Later, resume from the PR:
 
 ```sh
 respawn 123
+respawn internetbackyard/gnomos-app#514
 respawn https://github.com/org/repo/pull/123
 ```
 
+### Link Imported Sessions To PRs
+
+This is for old sessions from before autosave tagged PRs automatically. After `respawn import`, sync saved sessions to matching PRs in a repo:
+
+```sh
+respawn import internetbackyard/gnomos-app
+respawn link internetbackyard/gnomos-app --dry-run
+respawn link internetbackyard/gnomos-app
+```
+
+Link matches sessions to PRs by branch name first, then by PR head SHA when available. It only writes PR metadata comments; it does not upload transcripts.
+
+Always run the dry-run first. It prints the exact PRs it would touch:
+
+```sh
+Would link 1 PRs in internetbackyard/gnomos-app; 0 sessions unmatched
+  #514 feat/int-1194-tool-actor-context (1 session)
+```
+
+If the PR you want is not listed, `respawn` does not have enough local evidence to link it automatically yet. The usual cause is an old transcript from a deleted worktree that has not been imported with `respawn import owner/repo`.
+
 ### List Saved Sessions
 
 Show every saved session in your local index:
@@ -117,18 +148,33 @@ respawn import
 
 Import scans Claude Code and Codex transcripts, groups them by their recorded cwd, and saves sessions whose cwd is still an available git worktree. It skips transcripts that are already in `~/.respawn/index.json` and skips deleted or non-git worktrees.
 
+If the worktree was deleted, give `respawn` the repo explicitly:
+
+```sh
+respawn import internetbackyard/gnomos-app
+```
+
+For deleted worktrees, `respawn` can still import Claude Code project transcripts when the original cwd contains the repo name and the transcript has embedded branch metadata. Those imported rows use `sha: "unknown"`, but `respawn link` can still match them to PRs by branch.
+
 ## Commands
 
 | Command | What it does |
 | --- | --- |
 | `respawn init` | Creates the local index and installs autosave hooks |
 | `respawn save` | Saves the active Claude Code or Codex transcript |
-| `respawn autosave` | Saves only if the transcript changed |
+| `respawn autosave` | Saves only if the transcript changed and tags the current PR when one exists |
 | `respawn tag` | Saves and attaches session metadata to the current PR |
 | `respawn import` | Backfills existing local Claude Code and Codex sessions |
+| `respawn import owner/repo` | Backfills deleted-worktree transcripts for a repo when branch metadata exists |
+| `respawn link owner/repo` | Links imported sessions to matching PRs |
+| `respawn link owner/repo --dry-run` | Previews PR links without writing comments |
 | `respawn <branch>` | Restores the newest session for a branch |
+| `respawn owner/repo:branch` | Restores a branch session without being in that repo |
+| `respawn --repo owner/repo <branch>` | Restores a branch session for an explicit repo |
 | `respawn <pr-number>` | Restores the newest session from a tagged PR |
+| `respawn owner/repo#123` | Restores a tagged PR without being in that repo |
 | `respawn <pr-url>` | Restores the newest session from a tagged PR URL |
+| `respawn --repo owner/repo 123` | Restores a tagged PR for an explicit repo |
 | `respawn list` | Lists locally indexed sessions |
 | `respawn version` | Prints the installed CLI version |
 | `respawn update` | Updates the global npm install to the latest release |
@@ -143,7 +189,7 @@ npm install -g respawn-session@latest
 
 `respawn save` detects the active agent in this order:
 
-1. Claude Code via `CLAUDE_SESSION_ID`, then `~/.claude/sessions/*.json`
+1. Claude Code via `CLAUDE_SESSION_ID`, then `~/.claude/sessions/*.json` and `~/.claude/projects/**/*.jsonl`
 2. Codex via `CODEX_TUI_SESSION_LOG_PATH`, `CODEX_SESSION_ID`, or the newest `~/.codex/sessions/**.jsonl` transcript for the current cwd
 
 It then runs:
@@ -162,6 +208,10 @@ The local index lives at:
 
 Branches can have multiple saved sessions. `respawn <branch>` restores the newest `savedAt` entry for the current repo and branch. `respawn list` shows every saved entry so older sessions remain discoverable.
 
+`respawn autosave` is what makes the main workflow work: it saves the transcript and, when `gh pr view` can resolve the current branch's PR, writes the session pointer to that PR. Later `respawn <pr-number>` reads that pointer, restores the transcript, checks out the PR, and resumes the agent.
+
+`respawn import owner/repo` exists for old deleted worktrees. It scans local transcripts whose recorded cwd contains that repo name and imports the ones with embedded branch metadata. This is best-effort recovery for sessions that were created before `respawn` was installed.
+
 `respawn tag` writes a hidden metadata comment to the current PR. The comment stores session pointers, not the transcript body. Transcripts still live in your private gists. This lets `respawn <pr-url|number>` recover the newest tagged session after a branch is merged or deleted.
 
 ## Agent Paths

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "respawn-session",
-  "version": "0.0.5",
+  "version": "0.0.9",
   "description": "Save and resume Claude Code or Codex agent sessions by git branch.",
   "type": "module",
   "bin": {

package/src/agents/claude.ts

@@ -1,10 +1,10 @@
-import { existsSync, readdirSync, readFileSync } from "node:fs";
+import { existsSync, readdirSync, readFileSync, statSync } from "node:fs";
 import { homedir } from "node:os";
-import { join } from "node:path";
+import { basename, join } from "node:path";
 import type { ImportableTranscript, LocatedTranscript, LocateOptions } from "./types";
 
 export function encodeClaudeProjectPath(cwd: string): string {
-  return cwd.replace(/[^A-Za-z0-9._-]/g, "-");
+  return cwd.replace(/[^A-Za-z0-9_-]/g, "-");
 }
 
 export function transcriptPath(
@@ -41,10 +41,11 @@ export function resumeCmd(sessionId: string): string[] {
 
 export function listTranscripts(options: LocateOptions = {}): ImportableTranscript[] {
   const home = options.home ?? homedir();
+  const projectTranscripts = listProjectTranscripts(home);
   const sessionsDir = join(home, ".claude", "sessions");
-  if (!existsSync(sessionsDir)) return [];
+  if (!existsSync(sessionsDir)) return projectTranscripts;
 
-  return readdirSync(sessionsDir, { withFileTypes: true })
+  const registryTranscripts = readdirSync(sessionsDir, { withFileTypes: true })
     .filter((entry) => entry.isFile() && entry.name.endsWith(".json"))
     .map((entry) => readSessionRecord(join(sessionsDir, entry.name)))
     .filter(
@@ -68,6 +69,11 @@ export function listTranscripts(options: LocateOptions = {}): ImportableTranscri
       };
     })
     .filter((transcript): transcript is ImportableTranscript => transcript !== null);
+
+  return uniqueByPath([
+    ...projectTranscripts,
+    ...registryTranscripts,
+  ]);
 }
 
 type ClaudeSessionRecord = {
@@ -76,6 +82,45 @@ type ClaudeSessionRecord = {
   updatedAt?: number;
 };
 
+type ClaudeProjectMeta = {
+  sessionId?: string;
+  cwd?: string;
+  gitBranch?: string;
+  timestamp?: string;
+};
+
+function listProjectTranscripts(home: string): ImportableTranscript[] {
+  const projectsDir = join(home, ".claude", "projects");
+  if (!existsSync(projectsDir)) return [];
+
+  return readdirSync(projectsDir, { withFileTypes: true })
+    .filter((entry) => entry.isDirectory())
+    .flatMap((project) =>
+      readdirSync(join(projectsDir, project.name), { withFileTypes: true })
+        .filter((entry) => entry.isFile() && entry.name.endsWith(".jsonl"))
+        .map((entry) => join(projectsDir, project.name, entry.name)),
+    )
+    .map((path): ImportableTranscript | null => {
+      const meta = readProjectTranscriptMeta(path);
+      const sessionId = meta?.sessionId ?? basename(path, ".jsonl");
+      if (!sessionId || !meta?.cwd) return null;
+      return {
+        agent: "claude" as const,
+        path,
+        sessionId,
+        cwd: meta.cwd,
+        branch:
+          meta.gitBranch && meta.gitBranch !== "HEAD"
+            ? meta.gitBranch
+            : undefined,
+        savedAt: meta.timestamp
+          ? new Date(meta.timestamp).toISOString()
+          : statSync(path).mtime.toISOString(),
+      };
+    })
+    .filter((transcript): transcript is ImportableTranscript => transcript !== null);
+}
+
 function locateFromSessionRegistry(
   options: LocateOptions = {},
 ): LocatedTranscript | null {
@@ -110,3 +155,31 @@ function readSessionRecord(path: string): ClaudeSessionRecord | null {
     return null;
   }
 }
+
+function readProjectTranscriptMeta(path: string): ClaudeProjectMeta | null {
+  try {
+    const lines = readFileSync(path, "utf8").split("\n").slice(0, 100);
+    const meta: ClaudeProjectMeta = {};
+    for (const line of lines) {
+      if (!line.trim()) continue;
+      const parsed = JSON.parse(line) as ClaudeProjectMeta;
+      meta.sessionId ??= parsed.sessionId;
+      meta.cwd ??= parsed.cwd;
+      meta.gitBranch ??= parsed.gitBranch;
+      meta.timestamp ??= parsed.timestamp;
+      if (meta.cwd && meta.sessionId && meta.gitBranch) return meta;
+    }
+    return meta.cwd ? meta : null;
+  } catch {
+    return null;
+  }
+}
+
+function uniqueByPath(transcripts: ImportableTranscript[]): ImportableTranscript[] {
+  const seen = new Set<string>();
+  return transcripts.filter((transcript) => {
+    if (seen.has(transcript.path)) return false;
+    seen.add(transcript.path);
+    return true;
+  });
+}

package/src/agents/types.ts

@@ -9,6 +9,7 @@ export type LocatedTranscript = {
 
 export type ImportableTranscript = LocatedTranscript & {
   cwd: string;
+  branch?: string;
   savedAt?: string;
 };
 

package/src/cli.ts

@@ -1,6 +1,8 @@
 #!/usr/bin/env bun
 import { initRespawn } from "./commands/init";
+import { autosaveSession } from "./commands/autosave";
 import { importSessions } from "./commands/import";
+import { linkRepo } from "./commands/link";
 import { listSessions } from "./commands/list";
 import { resumePrSession, resumeSession } from "./commands/resume";
 import { saveSession } from "./commands/save";
@@ -13,36 +15,51 @@ export type Route =
   | { name: "autosave" }
   | { name: "list" }
   | { name: "init" }
-  | { name: "import" }
+  | { name: "import"; repo?: string }
+  | { name: "link"; repo: string; dryRun: boolean }
   | { name: "tag" }
   | { name: "version" }
   | { name: "update" }
-  | { name: "resume"; branch: string }
-  | { name: "resume-pr"; prRef: string };
+  | { name: "resume"; branch: string; repo?: string }
+  | { name: "resume-pr"; prRef: string; repo?: string };
 
 export function route(args: string[]): Route {
-  const [command] = args;
+  const { repo, rest } = parseGlobalOptions(args);
+  const [command] = rest;
   if (!command || command === "help" || command === "--help" || command === "-h") {
     return { name: "help" };
   }
   if (command === "version" || command === "--version" || command === "-v") {
     return { name: "version" };
   }
+  if (command === "link") {
+    const linkArgs = rest.slice(1).filter((arg) => arg !== "--dry-run");
+    return {
+      name: "link",
+      repo: linkArgs[0] ?? "",
+      dryRun: rest.includes("--dry-run"),
+    };
+  }
   if (
     command === "save" ||
     command === "autosave" ||
     command === "list" ||
     command === "init" ||
-    command === "import" ||
     command === "tag" ||
     command === "update"
   ) {
     return { name: command };
   }
+  if (command === "import") {
+    return {
+      name: "import",
+      repo: repo ?? rest.slice(1).find((arg) => !arg.startsWith("-")),
+    };
+  }
   if (isPrRef(command)) {
-    return { name: "resume-pr", prRef: command };
+    return parsePrRoute(command, repo);
   }
-  return { name: "resume", branch: command };
+  return parseBranchRoute(command, repo);
 }
 
 export async function main(args = Bun.argv.slice(2)): Promise<void> {
@@ -56,7 +73,7 @@ export async function main(args = Bun.argv.slice(2)): Promise<void> {
     return;
   }
   if (selected.name === "autosave") {
-    console.log((await saveSession({ mode: "autosave" })).message);
+    console.log((await autosaveSession()).message);
     return;
   }
   if (selected.name === "list") {
@@ -68,7 +85,14 @@ export async function main(args = Bun.argv.slice(2)): Promise<void> {
     return;
   }
   if (selected.name === "import") {
-    console.log((await importSessions()).message);
+    console.log((await importSessions({ repo: selected.repo })).message);
+    return;
+  }
+  if (selected.name === "link") {
+    if (!selected.repo) throw new Error("Usage: respawn link owner/repo [--dry-run]");
+    console.log(
+      (await linkRepo(selected.repo, { dryRun: selected.dryRun })).message,
+    );
     return;
   }
   if (selected.name === "tag") {
@@ -86,8 +110,8 @@ export async function main(args = Bun.argv.slice(2)): Promise<void> {
 
   const result =
     selected.name === "resume-pr"
-      ? await resumePrSession(selected.prRef)
-      : await resumeSession(selected.branch);
+      ? await resumePrSession(selected.prRef, { repo: selected.repo })
+      : await resumeSession(selected.branch, { repo: selected.repo });
   const [cmd, ...cmdArgs] = result.command;
   const proc = Bun.spawn([cmd, ...cmdArgs], {
     stdin: "inherit",
@@ -105,16 +129,52 @@ function helpText(): string {
     "  respawn tag",
     "  respawn <branch>",
     "  respawn <pr-url|number>",
+    "  respawn owner/repo:branch",
+    "  respawn owner/repo#123",
+    "  respawn --repo owner/repo <branch|number>",
     "  respawn list",
     "  respawn init",
     "  respawn import",
+    "  respawn import owner/repo",
+    "  respawn link owner/repo [--dry-run]",
     "  respawn version",
     "  respawn update",
   ].join("\n");
 }
 
 function isPrRef(value: string): boolean {
-  return /^\d+$/.test(value) || /github\.com\/[^/]+\/[^/]+\/pull\/\d+/.test(value);
+  return (
+    /^\d+$/.test(value) ||
+    /^[^/\s]+\/[^#:\s]+#\d+$/.test(value) ||
+    /github\.com\/[^/]+\/[^/]+\/pull\/\d+/.test(value)
+  );
+}
+
+function parseGlobalOptions(args: string[]): { repo?: string; rest: string[] } {
+  if (args[0] === "--repo") {
+    return { repo: args[1], rest: args.slice(2) };
+  }
+  return { rest: args };
+}
+
+function parsePrRoute(value: string, repo?: string): Route {
+  const url = value.match(/^https:\/\/github\.com\/([^/]+\/[^/]+)\/pull\/(\d+)$/);
+  if (url) return { name: "resume-pr", repo: url[1], prRef: url[2] };
+
+  const qualified = value.match(/^([^/\s]+\/[^#:\s]+)#(\d+)$/);
+  if (qualified) {
+    return { name: "resume-pr", repo: qualified[1], prRef: qualified[2] };
+  }
+
+  return { name: "resume-pr", prRef: value, repo };
+}
+
+function parseBranchRoute(value: string, repo?: string): Route {
+  const qualified = value.match(/^([^/\s]+\/[^#:\s]+):(.+)$/);
+  if (qualified) {
+    return { name: "resume", repo: qualified[1], branch: qualified[2] };
+  }
+  return { name: "resume", branch: value, repo };
 }
 
 if (import.meta.main) {

package/src/commands/autosave.ts

@@ -0,0 +1,100 @@
+import {
+  currentPr,
+  getRespawnTag,
+  parseGitHubRepo,
+  upsertRespawnComment,
+} from "../github";
+import type { RespawnPrTag } from "../github";
+import { saveSession, type SaveDeps, type SaveResult } from "./save";
+
+export type AutosaveDeps = SaveDeps & {
+  saveSession?: typeof saveSession;
+  currentPr?: typeof currentPr;
+  getRespawnTag?: typeof getRespawnTag;
+  upsertRespawnComment?: typeof upsertRespawnComment;
+};
+
+export type AutosaveResult = SaveResult & {
+  tag?: RespawnPrTag;
+};
+
+export async function autosaveSession(
+  deps: AutosaveDeps = {},
+): Promise<AutosaveResult> {
+  const {
+    saveSession: save,
+    currentPr: current,
+    getRespawnTag: getTag,
+    upsertRespawnComment: upsert,
+    ...saveDeps
+  } = deps;
+
+  const saved = await (save ?? saveSession)({
+    ...saveDeps,
+    mode: "autosave",
+  });
+
+  const pr = await maybeCurrentPr(current ?? currentPr);
+  if (!pr) return saved;
+
+  try {
+    const repo = parseGitHubRepo(saved.session.repo);
+    const repoName = `${repo.owner}/${repo.name}`;
+    const existing = await (getTag ?? getRespawnTag)(String(pr.number), repoName);
+    const sessions = appendSession(existing?.sessions ?? [], saved.session);
+    const tag: RespawnPrTag = {
+      version: 1,
+      repo: repoName,
+      pr: pr.number,
+      branch: pr.headRefName,
+      sessions,
+    };
+
+    await (upsert ?? upsertRespawnComment)({
+      owner: repo.owner,
+      name: repo.name,
+      pr: pr.number,
+      tag,
+    });
+
+    return {
+      ...saved,
+      message: `${saved.message}; tagged PR #${pr.number} with session ${saved.session.sessionId}`,
+      tag,
+    };
+  } catch (error) {
+    return {
+      ...saved,
+      message: `${saved.message}; PR tag failed: ${errorMessage(error)}`,
+    };
+  }
+}
+
+async function maybeCurrentPr(
+  detect: typeof currentPr,
+): Promise<Awaited<ReturnType<typeof currentPr>> | null> {
+  try {
+    return await detect();
+  } catch {
+    return null;
+  }
+}
+
+function appendSession(
+  sessions: RespawnPrTag["sessions"],
+  session: RespawnPrTag["sessions"][number],
+): RespawnPrTag["sessions"] {
+  const key = sessionKey(session);
+  if (sessions.some((existing) => sessionKey(existing) === key)) {
+    return sessions;
+  }
+  return [...sessions, session];
+}
+
+function sessionKey(session: RespawnPrTag["sessions"][number]): string {
+  return `${session.agent}:${session.sessionId}:${session.gistUrl}`;
+}
+
+function errorMessage(error: unknown): string {
+  return error instanceof Error ? error.message : String(error);
+}

package/src/commands/import.ts

@@ -10,6 +10,7 @@ import {
   type SavedSession,
 } from "../index-file";
 import { createGist } from "../storage/gist";
+import { parseGitHubRepo } from "../github";
 
 export type ImportResult = {
   imported: number;
@@ -20,6 +21,7 @@ export type ImportResult = {
 
 export type ImportDeps = {
   indexPath?: string;
+  repo?: string;
   listTranscripts?: typeof listAllTranscripts;
   gitInfoForCwd?: typeof gitInfoForCwd;
   createGist?: typeof createGist;
@@ -38,7 +40,9 @@ export async function importSessions(
   let skipped = 0;
 
   for (const transcript of transcripts) {
-    const info = await gitInfo(transcript.cwd);
+    const info =
+      (await gitInfo(transcript.cwd)) ??
+      fallbackGitInfo(transcript, deps.repo);
     if (!info) {
       skipped += 1;
       continue;
@@ -77,6 +81,29 @@ export async function importSessions(
   };
 }
 
+function fallbackGitInfo(
+  transcript: ImportableTranscript,
+  repo?: string,
+): GitInfo | null {
+  if (!repo || !transcript.branch || !cwdLooksLikeRepo(transcript.cwd, repo)) {
+    return null;
+  }
+  return {
+    repo,
+    branch: transcript.branch,
+    sha: "unknown",
+  };
+}
+
+function cwdLooksLikeRepo(cwd: string, repo: string): boolean {
+  try {
+    const repoName = parseGitHubRepo(repo).name;
+    return cwd.split(/[\\/]/).includes(repoName);
+  } catch {
+    return false;
+  }
+}
+
 async function isDuplicate(
   indexPath: string,
   info: GitInfo,

package/src/commands/link.ts

@@ -0,0 +1,109 @@
+import {
+  listPullRequests,
+  parseGitHubRepo,
+  repoKey,
+  upsertRespawnComment,
+  type PrInfo,
+  type RespawnPrTag,
+} from "../github";
+import {
+  defaultIndexPath,
+  readIndex,
+  type SavedSession,
+} from "../index-file";
+
+export type LinkResult = {
+  linked: number;
+  dryRun: boolean;
+  unmatchedSessions: number;
+  message: string;
+};
+
+export type LinkDeps = {
+  indexPath?: string;
+  dryRun?: boolean;
+  listPullRequests?: typeof listPullRequests;
+  upsertRespawnComment?: typeof upsertRespawnComment;
+};
+
+export async function linkRepo(
+  repo: string,
+  deps: LinkDeps = {},
+): Promise<LinkResult> {
+  const index = await readIndex(deps.indexPath ?? defaultIndexPath());
+  const key = repoKey(repo);
+  const sessions = index.sessions.filter((session) => safeRepoKey(session.repo) === key);
+  const prs = await (deps.listPullRequests ?? listPullRequests)(key);
+  const used = new Set<SavedSession>();
+  const details: string[] = [];
+  let linked = 0;
+
+  for (const pr of prs) {
+    const matches = uniqueSessions(
+      sessions.filter((session) => sessionMatchesPr(session, pr)),
+    );
+    if (matches.length === 0) continue;
+
+    for (const session of matches) used.add(session);
+    linked += 1;
+    details.push(
+      `  #${pr.number} ${pr.headRefName} (${matches.length} ${plural(matches.length, "session")})`,
+    );
+
+    if (!deps.dryRun) {
+      const parsed = parseGitHubRepo(key);
+      await (deps.upsertRespawnComment ?? upsertRespawnComment)({
+        owner: parsed.owner,
+        name: parsed.name,
+        pr: pr.number,
+        tag: {
+          version: 1,
+          repo: key,
+          pr: pr.number,
+          branch: pr.headRefName,
+          sessions: matches.sort((a, b) => a.savedAt.localeCompare(b.savedAt)),
+        },
+      });
+    }
+  }
+
+  const unmatchedSessions = sessions.filter((session) => !used.has(session)).length;
+  const prefix = deps.dryRun ? "Would link" : "Linked";
+  return {
+    linked,
+    dryRun: Boolean(deps.dryRun),
+    unmatchedSessions,
+    message: [
+      `${prefix} ${linked} PRs in ${key}; ${unmatchedSessions} ${plural(unmatchedSessions, "session")} unmatched`,
+      ...details,
+    ].join("\n"),
+  };
+}
+
+function sessionMatchesPr(session: SavedSession, pr: PrInfo): boolean {
+  if (session.branch === pr.headRefName) return true;
+  if (pr.headRefOid && session.sha === pr.headRefOid) return true;
+  return Boolean(pr.commits?.some((commit) => commit.oid === session.sha));
+}
+
+function uniqueSessions(sessions: SavedSession[]): SavedSession[] {
+  const seen = new Set<string>();
+  return sessions.filter((session) => {
+    const key = `${session.agent}:${session.sessionId}:${session.gistUrl}`;
+    if (seen.has(key)) return false;
+    seen.add(key);
+    return true;
+  });
+}
+
+function safeRepoKey(repo: string): string | null {
+  try {
+    return repoKey(repo);
+  } catch {
+    return null;
+  }
+}
+
+function plural(count: number, noun: string): string {
+  return `${noun}${count === 1 ? "" : "s"}`;
+}

package/src/commands/resume.ts

@@ -2,7 +2,7 @@ import { mkdir, writeFile } from "node:fs/promises";
 import { dirname } from "node:path";
 import { resumeCmd, targetTranscriptPath } from "../agents";
 import { checkoutBranch, currentRepo } from "../git";
-import { checkoutPr, getRespawnTag } from "../github";
+import { checkoutPr, getRespawnTag, repoKey } from "../github";
 import {
   defaultIndexPath,
   findLatestSession,
@@ -12,6 +12,7 @@ import { downloadGist } from "../storage/gist";
 
 export type ResumeDeps = {
   indexPath?: string;
+  repo?: string;
   currentRepo?: typeof currentRepo;
   downloadGist?: typeof downloadGist;
   checkoutBranch?: typeof checkoutBranch;
@@ -19,6 +20,7 @@ export type ResumeDeps = {
 };
 
 export type ResumePrDeps = {
+  repo?: string;
   currentRepo?: typeof currentRepo;
   getRespawnTag?: typeof getRespawnTag;
   downloadGist?: typeof downloadGist;
@@ -34,25 +36,28 @@ export async function resumeSession(
   path: string;
   session: SavedSession;
 }> {
-  const repo = await (deps.currentRepo ?? currentRepo)();
+  const repo = deps.repo ?? (await (deps.currentRepo ?? currentRepo)());
   const session = await findLatestSession(deps.indexPath ?? defaultIndexPath(), {
-    repo,
+    repo: repo,
     branch,
   });
-  if (!session) {
+  const matchedSession =
+    session ??
+    (await findLatestByRepoKey(deps.indexPath ?? defaultIndexPath(), repo, branch));
+  if (!matchedSession) {
     throw new Error(`No saved respawn session found for ${repo}@${branch}`);
   }
 
-  const transcript = await (deps.downloadGist ?? downloadGist)(session.gistUrl);
-  const path = (deps.targetTranscriptPath ?? targetTranscriptPath)(session);
+  const transcript = await (deps.downloadGist ?? downloadGist)(matchedSession.gistUrl);
+  const path = (deps.targetTranscriptPath ?? targetTranscriptPath)(matchedSession);
   await mkdir(dirname(path), { recursive: true });
   await writeFile(path, transcript);
   await (deps.checkoutBranch ?? checkoutBranch)(branch);
 
   return {
-    command: resumeCmd(session.agent, session.sessionId),
+    command: resumeCmd(matchedSession.agent, matchedSession.sessionId),
     path,
-    session,
+    session: matchedSession,
   };
 }
 
@@ -64,9 +69,9 @@ export async function resumePrSession(
   path: string;
   session: SavedSession;
 }> {
-  const repo = await (deps.currentRepo ?? currentRepo)();
-  const tag = await (deps.getRespawnTag ?? getRespawnTag)(prRef);
-  if (!tag || tag.repo !== repo) {
+  const repo = deps.repo ?? (await (deps.currentRepo ?? currentRepo)());
+  const tag = await (deps.getRespawnTag ?? getRespawnTag)(prRef, deps.repo);
+  if (!tag || !reposMatch(tag.repo, repo)) {
     throw new Error(`No respawn PR tag found for ${repo}#${prRef}`);
   }
 
@@ -81,7 +86,7 @@ export async function resumePrSession(
   const path = (deps.targetTranscriptPath ?? targetTranscriptPath)(session);
   await mkdir(dirname(path), { recursive: true });
   await writeFile(path, transcript);
-  await (deps.checkoutPr ?? checkoutPr)(prRef);
+  await (deps.checkoutPr ?? checkoutPr)(prRef, deps.repo);
 
   return {
     command: resumeCmd(session.agent, session.sessionId),
@@ -89,3 +94,37 @@ export async function resumePrSession(
     session,
   };
 }
+
+async function findLatestByRepoKey(
+  indexPath: string,
+  repo: string,
+  branch: string,
+): Promise<SavedSession | null> {
+  const { readIndex } = await import("../index-file");
+  const key = repoKey(repo);
+  const index = await readIndex(indexPath);
+  return (
+    index.sessions
+      .filter(
+        (session) =>
+          session.branch === branch && safeRepoKey(session.repo) === key,
+      )
+      .sort((a, b) => a.savedAt.localeCompare(b.savedAt))
+      .at(-1) ?? null
+  );
+}
+
+function safeRepoKey(repo: string): string | null {
+  try {
+    return repoKey(repo);
+  } catch {
+    return null;
+  }
+}
+
+function reposMatch(a: string, b: string): boolean {
+  if (a === b) return true;
+  const aKey = safeRepoKey(a);
+  const bKey = safeRepoKey(b);
+  return Boolean(aKey && bKey && aKey === bKey);
+}

package/src/commands/save.ts

@@ -21,11 +21,13 @@ export type SaveDeps = {
   now?: () => Date;
 };
 
-export async function saveSession(deps: SaveDeps = {}): Promise<{
+export type SaveResult = {
   message: string;
   saved: boolean;
   session: SavedSession;
-}> {
+};
+
+export async function saveSession(deps: SaveDeps = {}): Promise<SaveResult> {
   const locate = deps.locateActiveTranscript ?? locateActiveTranscript;
   const transcript = locate();
   if (!transcript) {

package/src/github.ts

@@ -13,6 +13,10 @@ export type PrInfo = {
   number: number;
   url: string;
   headRefName: string;
+  headRefOid?: string;
+  state?: string;
+  title?: string;
+  commits?: Array<{ oid: string }>;
 };
 
 export type RespawnPrTag = {
@@ -30,15 +34,32 @@ type GhComment = {
 
 export function parseGitHubRepo(remote: string): GitHubRepo {
   const trimmed = remote.trim();
+  const prUrl = trimmed.match(
+    /^https:\/\/github\.com\/([^/]+)\/([^/]+)\/pull\/\d+$/,
+  );
+  if (prUrl) return { owner: prUrl[1], name: prUrl[2].replace(/\.git$/, "") };
+
   const ssh = trimmed.match(/^git@github\.com:([^/]+)\/(.+?)(?:\.git)?$/);
   if (ssh) return { owner: ssh[1], name: ssh[2] };
 
   const https = trimmed.match(/^https:\/\/github\.com\/([^/]+)\/(.+?)(?:\.git)?$/);
   if (https) return { owner: https[1], name: https[2] };
 
+  const short = trimmed.match(/^([^/\s]+)\/([^/\s]+)$/);
+  if (short) return { owner: short[1], name: short[2].replace(/\.git$/, "") };
+
   throw new Error(`Unsupported GitHub remote: ${remote}`);
 }
 
+export function repoKey(remote: string): string {
+  const repo = parseGitHubRepo(remote);
+  return `${repo.owner}/${repo.name}`;
+}
+
+export function prNumberFromRef(prRef: string): string {
+  return prRef.match(/github\.com\/[^/]+\/[^/]+\/pull\/(\d+)/)?.[1] ?? prRef;
+}
+
 export function encodeRespawnComment(tag: RespawnPrTag): string {
   return `${markerStart}\n${JSON.stringify(tag, null, 2)}\n${markerEnd}`;
 }
@@ -69,11 +90,33 @@ export async function currentPr(run: RunCommand = runCommand): Promise<PrInfo> {
   return parsed;
 }
 
+export async function listPullRequests(
+  repo: string,
+  run: RunCommand = runCommand,
+): Promise<PrInfo[]> {
+  const raw = await run("gh", [
+    "pr",
+    "list",
+    "--repo",
+    repo,
+    "--state",
+    "all",
+    "--limit",
+    "1000",
+    "--json",
+    "number,url,headRefName,headRefOid,state,title",
+  ]);
+  return JSON.parse(raw) as PrInfo[];
+}
+
 export async function getRespawnTag(
   prRef: string,
+  repo?: string,
   run: RunCommand = runCommand,
 ): Promise<RespawnPrTag | null> {
-  const raw = await run("gh", ["pr", "view", prRef, "--json", "comments"]);
+  const args = ["pr", "view", prNumberFromRef(prRef), "--json", "comments"];
+  if (repo) args.push("--repo", repo);
+  const raw = await run("gh", args);
   const parsed = JSON.parse(raw) as { comments?: GhComment[] };
   return findRespawnComment(parsed.comments ?? [])?.tag ?? null;
 }
@@ -87,10 +130,13 @@ export async function upsertRespawnComment(
   },
   run: RunCommand = runCommand,
 ): Promise<RespawnPrTag> {
+  const repo = `${input.owner}/${input.name}`;
   const raw = await run("gh", [
     "pr",
     "view",
     String(input.pr),
+    "--repo",
+    repo,
     "--json",
     "comments",
   ]);
@@ -108,7 +154,15 @@ export async function upsertRespawnComment(
       `body=${body}`,
     ]);
   } else {
-    await run("gh", ["pr", "comment", String(input.pr), "--body", body]);
+    await run("gh", [
+      "pr",
+      "comment",
+      String(input.pr),
+      "--repo",
+      repo,
+      "--body",
+      body,
+    ]);
   }
 
   return input.tag;
@@ -116,9 +170,12 @@ export async function upsertRespawnComment(
 
 export async function checkoutPr(
   prRef: string,
+  repo?: string,
   run: RunCommand = runCommand,
 ): Promise<void> {
-  await run("gh", ["pr", "checkout", prRef]);
+  const args = ["pr", "checkout", prNumberFromRef(prRef)];
+  if (repo) args.push("--repo", repo);
+  await run("gh", args);
 }
 
 function findRespawnComment(