agent-carry 0.2.1 → 0.4.1

package/CHANGELOG.md

@@ -1,16 +1,33 @@
 # Changelog
 
-## Unreleased
+Plugin, marketplace entry and package share one version number; `npm version` keeps them in step.
 
-- Plugin 0.2.1: commands check the CLI version first and say how to upgrade if it is older, instead of aborting on an unknown-command error.
-- Plugin 0.2.0: `/carry:share` and `/carry:pickup` ask what they need (session, encryption, passphrase source, destination folder, desktop app and account) instead of expecting flags. Needs the CLI from this release.
+## 0.4.1
+- `/carry:pickup` no longer asks which account to use or shows ids. `--desktop` picks the account the desktop app is signed in to (read from the app's own config, with the log as a fallback), and in a terminal asks only when the terminal and the desktop app are logged in as different accounts.
+- Accounts are described by name and email where known (the terminal's login), otherwise by the sessions they hold, never by id: `carry desktop-dirs` and the import output now say which account's Code tab got the session.
+
+## 0.4.0
+
+Finding sessions without knowing where they are stored. (0.3.0 was tagged but never published to npm.)
+
+- `carry list --all` shows the most recent sessions across every folder, newest first, each tagged by where it was started (`[desktop]`, `[terminal]`, `[print mode]`) with the title the desktop app shows. Background-agent sessions (for example a memory plugin's observer) are hidden unless `--everything`.
+- `carry list` options: `--limit N|all`, `--project DIR` (one folder), `--match TEXT` (title, folder or id), `--desktop` / `--terminal` (only sessions started there). Archived desktop sessions are marked; a desktop conversation with no project folder shows as "desktop scratch folder".
+- `carry export` with no id offers a numbered picker that takes the same options.
+- `/carry:share` uses the list; the plugin commands need CLI 0.4.0 or newer.
+
+## 0.2.1
+
+- Plugin commands check the CLI version first and say how to upgrade if it is older, instead of aborting on an unknown-command error.
+
+## 0.2.0
+
+- `carry import --desktop` adds the session to the Claude desktop app's Code tab (macOS). It targets the signed-in account (read from the app's log) and works for a freshly signed-in account by borrowing only app-level settings. Terminal colour codes in newly imported text are stripped, since the app shows them as literal characters.
+- `export --latest` skips sessions with no prompts.
+- Interactive plugin commands: `/carry:share` and `/carry:pickup` ask what they need (session, encryption, passphrase source, destination folder, desktop app and account). Installable with `/plugin install carry --marketplace harshhh28/agent-carry`.
 - `export --generate-passphrase` (saved to `FILE.pass`, never printed); `carry bundles`; `carry desktop-dirs`.
-- `--desktop` targets the signed-in account (read from the app's log) instead of any folder with sessions, and works for a freshly signed-in account by borrowing only app-level settings.
 
-- Plugin installable from this repo: `/plugin install carry --marketplace harshhh28/agent-carry`.
-- `export --latest` skips sessions with no prompts, so an opened-and-closed session no longer shadows the real one.
-- `--desktop` strips terminal colour codes from newly imported text, which the app shows as literal characters.
-- `carry import --desktop` adds the session to the Claude desktop app's Code tab (macOS).
+## 0.1.1
+
 - `agent-carry` works as a second command name for `carry`.
 - README trimmed; plugin author set.
 

package/README.md

@@ -16,9 +16,11 @@ copied session can't be resumed elsewhere. `carry` fixes that:
 ```
 npm i -g agent-carry          # installs `carry` (also available as `agent-carry`)
 
-# machine A, in the project folder
-carry list
-carry export --latest -o session.carry.gz
+# machine A (any folder): pick a session from a numbered list, with desktop-app titles
+carry export -o session.carry.gz
+# or: carry list --all   then   carry export <id> -o session.carry.gz
+# more rows: --limit 50 | --limit all    one folder: --project DIR    search: --match word
+# only desktop-app sessions: --desktop    only terminal ones: --terminal   (each row is tagged [desktop] / [terminal])
 
 # machine B, in the same project (any path)
 carry import session.carry.gz
@@ -40,7 +42,7 @@ carry import session.carry.gz --desktop
 App settings are copied from that account's newest Code-tab session (or, for a new account, another account's), so use the Code tab at least once first.
 Terminal colour codes in the imported text are stripped (the app would show them as literal `[38;2;…m`). Restart the desktop app if the session doesn't show.
 
-The session is added to the account that is signed in (read from the app's log). If it can't tell, or you want another account, use `--desktop-dir DIR`; `carry desktop-dirs` lists the choices. A freshly signed-in account with no sessions borrows only app-level settings from another account, never its connectors or permissions. Cowork is a different store and isn't supported.
+The session is added to the account the desktop app is signed in to. From a terminal that is logged in as a different account, `carry` stops and asks which Code tab you mean, naming the accounts (by name and email where known, otherwise by the sessions they hold). To choose explicitly use `--desktop-dir DIR`; `carry desktop-dirs` lists the accounts. A freshly signed-in account with no sessions borrows only app-level settings from another account, never its connectors or permissions. Cowork is a different store and isn't supported.
 
 ### Sync through a shared folder
 
@@ -59,7 +61,7 @@ Projects are matched by git remote, not path. Each file has one writer, so there
 /plugin install carry --marketplace harshhh28/agent-carry
 ```
 
-Needs `npm i -g agent-carry` (or falls back to `npx`). Works the same in the terminal and in the desktop app's Code tab.
+Needs the CLI (`npm i -g agent-carry`, 0.4.0 or newer). Works the same in the terminal and in the desktop app's Code tab. To update later: `npm i -g agent-carry@latest`, then `/plugin marketplace update agent-carry` and `/reload-plugins`.
 
 - `/carry:share` asks which session, whether to encrypt (generate a passphrase, use your own file, or type one), and where to save.
 - `/carry:pickup` lists bundles in this folder, ~/Downloads and ~/Desktop, then asks which one, the passphrase source, which folder to import into, and whether to add it to the desktop app (and which account).
@@ -70,8 +72,8 @@ Passphrases are never put on a command line. A generated one is saved beside the
 
 | command | |
 |---|---|
-| `carry list [--all]` | sessions for this folder, or all |
-| `carry export <id\|--latest> [-o FILE]` | `--generate-passphrase`, `--no-redact`, `--redact-emails`, `--strip-thinking`, `--allow-thinking-secrets`, `--project-root DIR` |
+| `carry list [--all] [--project DIR] [--desktop\|--terminal] [--match TEXT] [--limit N]` | sessions for this folder, or `--all`: recent sessions from every folder, each tagged by where it was started (`[desktop]`, `[terminal]`, `[print mode]`) with the desktop app's title. `--desktop` / `--terminal` keep only those. Background-agent sessions are hidden; `--everything` shows them |
+| `carry export [id\|--latest] [-o FILE]` | with no id, pick from a numbered list (takes the same `--desktop`, `--terminal`, `--project`, `--match`). Also `--generate-passphrase`, `--no-redact`, `--redact-emails`, `--strip-thinking`, `--allow-thinking-secrets`, `--project-root DIR` |
 | `carry inspect FILE` | header, parts, redaction counts |
 | `carry import FILE [--project-root DIR] [--dry-run]` | write into the target folder's session store |
 | `carry bundles` / `carry desktop-dirs` | bundle files nearby; desktop-app account folders |
@@ -79,6 +81,7 @@ Passphrases are never put on a command line. A generated one is saved beside the
 
 ## Limits
 
+- **Usage limit:** the CLI needs no Claude usage, so it still works when you have hit your limit; the plugin commands do not, because Claude has to run them.
 - **Resume** is verified on one real session (Claude Code 2.1.299); the transcript format is internal and can change. Run `scripts/verify-resume.sh <id>` to check yours.
 - **Thinking blocks are signed**, so they travel verbatim. If one contains a credential-like string, export refuses unless you pass `--strip-thinking` (resume with stripped thinking is untested) or `--allow-thinking-secrets`. `push` skips such sessions.
 - **Redaction is best effort.** It misses passwords that read like sentences and letters-only lowercase `password=word`. Read `carry inspect` before sharing, and encrypt anything you send to someone else.
@@ -89,7 +92,7 @@ Passphrases are never put on a command line. A generated one is saved beside the
 ## Development
 
 ```
-npm test                  # 49 tests, synthetic two-machine setups
+npm test                  # 56 tests, synthetic two-machine setups
 npm run check:real        # read-only round trip of your own ~/.claude sessions
 ```
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-carry",
-  "version": "0.2.1",
+  "version": "0.4.1",
   "description": "Move coding-agent sessions between machines and folders: path-portable, redacted, encrypted, merge-safe bundles. Claude Code today; adapter-ready for Codex and others.",
   "type": "module",
   "bin": {
@@ -20,7 +20,9 @@
   },
   "scripts": {
     "test": "node --test \"test/*.test.js\"",
-    "check:real": "node scripts/check-real.js"
+    "check:real": "node scripts/check-real.js",
+    "preversion": "npm test",
+    "version": "node scripts/sync-version.js && git add plugin/.claude-plugin/plugin.json .claude-plugin/marketplace.json CHANGELOG.md"
   },
   "keywords": [
     "claude-code",

package/plugin/.claude-plugin/plugin.json

@@ -1,7 +1,10 @@
 {
   "name": "carry",
-  "version": "0.2.1",
+  "version": "0.4.1",
   "description": "Move coding-agent sessions between machines and folders: /carry:share exports a redacted, path-portable bundle, /carry:pickup imports one.",
-  "author": { "name": "Harsh Gajjar", "email": "harshgajjar2812@gmail.com" },
+  "author": {
+    "name": "Harsh Gajjar",
+    "email": "harshgajjar2812@gmail.com"
+  },
   "license": "MIT"
 }

package/plugin/commands/pickup.md

@@ -4,7 +4,7 @@ argument-hint: [bundle-file]
 allowed-tools: Bash(carry:*), Bash(npx -y agent-carry@latest:*), Bash(ls:*), Bash(pwd), AskUserQuestion
 ---
 
-carry CLI version (this command needs 0.2.0 or newer): !`carry --version 2>&1 || echo 'not installed'`
+carry CLI version (this command needs 0.4.0 or newer): !`carry --version 2>&1 || echo 'not installed'`
 
 Bundle files nearby (this folder, ~/Downloads, ~/Desktop), newest first:
 
@@ -12,13 +12,13 @@ Bundle files nearby (this folder, ~/Downloads, ~/Desktop), newest first:
 
 Current folder: !`pwd`
 
-Claude desktop app account folders (macOS only; an error here just means no desktop app):
+Claude desktop app accounts (macOS only; an error here just means no desktop app):
 
 !`carry desktop-dirs 2>&1 || true`
 
 Arguments the user typed: $ARGUMENTS
 
-**Step 0.** Look at the version line above. If it says "not installed" or shows anything older than 0.2.0, stop and say exactly this, with nothing else: "This command needs the carry CLI 0.2.0 or newer. Run `npm i -g agent-carry@latest`, then try again." (If that install still gives an older version, 0.2.0 has not been published to npm yet.) Any error text shown in the listings below comes from the same cause; do not try to work around it.
+**Step 0.** Look at the version line above. If it says "not installed" or shows anything older than 0.4.0, stop and say exactly this, with nothing else: "This command needs the carry CLI 0.4.0 or newer. Run `npm i -g agent-carry@latest`, then try again." (If that install still gives an older version, 0.4.0 has not been published to npm yet.) Any error text shown in the listings below comes from the same cause; do not try to work around it.
 
 You are importing one session with the `carry` CLI.
 
@@ -31,6 +31,6 @@ Ask with the AskUserQuestion tool, one short question at a time, and skip any qu
    - "I'll type it here": warn that it is stored in this conversation's history. Pass it as `CARRY_PASSPHRASE='…' carry import …` and never repeat it back.
    (If `CARRY_PASSPHRASE` is already set in the environment, nothing is needed.) On a wrong-passphrase error, say so and ask once more.
 3. **Which folder.** Claude Code finds a session by the folder you run `claude` in, so this should be the folder they will work in. Offer the current folder as "(Recommended)" or another path (create it with `mkdir -p` only if the user says so). Pass it as `--project-root`.
-4. **Claude desktop app (only if account folders are listed above).** Ask "Also show it in the Claude desktop app's Code tab?" If yes and more than one folder is listed, ask which account: the one marked "* signed in" is "(Recommended)"; the rest are listed by their folder name and session count. Use `--desktop` for the signed-in account, or `--desktop-dir <folder>` for another one. If the import says it cannot tell which account is signed in, ask the user to choose from the list it printed.
+4. **Claude desktop app (only if account folders are listed above).** Ask only "Also show it in the Claude desktop app's Code tab?" Do not ask which account: `--desktop` picks the right one by itself (the account the desktop app is signed in to; in a terminal, the one that matches this terminal's login). Never show the user folder paths or ids. If the import fails with "this terminal is logged in as one Claude account but the desktop app is signed in as another", or "cannot tell which desktop account is signed in", ask once with AskUserQuestion, labelling each option with the account name and email, session count and example titles taken from that error (never ids or paths), and re-run with `--desktop-dir <that option's folder>`. A line starting with `*` in the listing above marks the account the desktop app is signed in to.
 5. **Run** `carry import <bundle> --project-root <folder> [--passphrase-file F] [--desktop | --desktop-dir D]` (add `--dry-run` if the user typed it, and say nothing was written).
-6. **Report in at most five lines:** the session id, the folder it went into, and any warning. Then the next step: exit this session, then `cd <folder> && claude --resume <id>`; for the desktop app, restart it if the session does not appear and open the Code tab. A running session cannot swap its own history, so do not run `claude --resume` yourself.
+6. **Report in at most five lines:** the session id, the folder it went into, which account's Code tab it was added to (use the "Code tab of:" line from the import, e.g. a name and email; say it can be redone for another account if that is wrong), and any warning. Then the next step: exit this session, then `cd <folder> && claude --resume <id>`; for the desktop app, restart it if the session does not appear and open the Code tab. A running session cannot swap its own history, so do not run `claude --resume` yourself.

package/plugin/commands/share.md

@@ -4,21 +4,23 @@ argument-hint: [optional carry export flags, e.g. -o FILE --strip-thinking]
 allowed-tools: Bash(carry:*), Bash(npx -y agent-carry@latest:*), AskUserQuestion
 ---
 
-carry CLI version (this command needs 0.2.0 or newer): !`carry --version 2>&1 || echo 'not installed'`
+carry CLI version (this command needs 0.4.0 or newer): !`carry --version 2>&1 || echo 'not installed'`
 
-Sessions in this folder, newest first (the top one is usually this conversation):
+Recent sessions from every folder, newest first, including ones started in the Claude desktop app (the top one is usually this conversation):
 
-!`carry list 2>&1 || npx -y agent-carry@latest list 2>&1 || true`
+!`carry list --all --limit 8 2>&1 || true`
+
+Current folder: !`pwd`
 
 Arguments the user typed: $ARGUMENTS
 
-**Step 0.** Look at the version line above. If it says "not installed" or shows anything older than 0.2.0, stop and say exactly this, with nothing else: "This command needs the carry CLI 0.2.0 or newer. Run `npm i -g agent-carry@latest`, then try again." (If that install still gives an older version, 0.2.0 has not been published to npm yet.) Any error text shown in the listings below comes from the same cause; do not try to work around it.
+**Step 0.** Look at the version line above. If it says "not installed" or shows anything older than 0.4.0, stop and say exactly this, with nothing else: "This command needs the carry CLI 0.4.0 or newer. Run `npm i -g agent-carry@latest`, then try again." (If that install still gives an older version, 0.4.0 has not been published to npm yet.) Any error text shown in the listings below comes from the same cause; do not try to work around it.
 
 You are exporting one session with the `carry` CLI.
 
 Ask with the AskUserQuestion tool, one short question at a time, and skip any question the typed arguments already answer. If AskUserQuestion is not available, ask the same questions as a short numbered list in plain text and wait for the reply.
 
-1. **Which session.** Ignore rows with 0 turns. If only one has turns, use it without asking. Otherwise ask, offering the newest first as "(Recommended)" and up to three more; label each with its id prefix and title, and describe it with its date and turn count.
+1. **Which session.** The user may not know where sessions are stored, so offer them from the list above, never ask for a folder. If the arguments name a session or `--latest`, use it. Otherwise ask, offering the newest first as "(Recommended)" and up to three more; label each with its title, and describe it with its folder, date, turn count and `[desktop app]` when shown. If none fit, offer "show more" (`carry list --all --limit 30`), or search by a word from the title or folder (`carry list --all --match WORD`), or one folder (`carry list --project DIR`). If the user only wants sessions from the Claude desktop app (or only terminal ones), list them with `carry list --all --desktop` (or `--terminal`); each row's tag in brackets shows where it was started. Export by id: `carry export <id>` works from any folder.
 2. **Encrypt?** Options:
    - "No, plain file": readable by anyone who gets it (secrets are still redacted).
    - "Yes, generate a passphrase (Recommended when sending it to someone)": run with `--generate-passphrase`.

package/src/browse.js

@@ -0,0 +1,69 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { projectFolders } from './store.js';
+import { parseJsonl, summarize } from './transcript.js';
+import { desktopSessionInfo, firstPrompt } from './desktop.js';
+
+// The desktop app runs a conversation that has no project folder in a scratch folder with a long account/org path.
+const SCRATCH = /\/scratch-workspaces\/[0-9a-f-]{36}\/[0-9a-f-]{36}(?:\/(.*))?$/;
+const tilde = (p, home) => {
+  const scratch = p && SCRATCH.exec(p);
+  if (scratch) return `(desktop scratch folder${scratch[1] ? `: ${scratch[1]}` : ''})`;
+  return p && home && (p === home || p.startsWith(home + path.sep)) ? `~${p.slice(home.length)}` : p;
+};
+
+// Programmatic agents (for example a memory plugin's background observer) record this entrypoint. They are
+// not conversations a person had, and on a machine with such a plugin they can outnumber real sessions 50 to 1.
+/**
+ * Where a session was started, from the entrypoint Claude records on every line: `claude-desktop` is the desktop
+ * app, `cli` the terminal, `sdk-cli` a `claude -p` run. A session the desktop app lists in its index counts as
+ * desktop even if it began elsewhere (for example one imported with --desktop).
+ */
+export function sourceOf(sum, inDesktopIndex) {
+  const e = sum.entrypoints;
+  if (inDesktopIndex || e.includes('claude-desktop')) return 'desktop';
+  if (e.includes('cli')) return 'terminal';
+  if (e.some((x) => x.startsWith('sdk'))) return 'print mode';
+  return e[0] ?? 'unknown';
+}
+
+const isBackgroundAgent = (sum) => sum.entrypoints.length > 0 && sum.entrypoints.every((e) => e === 'sdk-ts');
+
+/**
+ * The most recent sessions across every project folder, so nobody needs to know where Claude keeps them.
+ * Skips sessions with no prompts and background-agent sessions (unless `everything`). Each gets the title the
+ * desktop app shows for it when there is one, else Claude's own title, else the first prompt.
+ * `source` ('desktop' or 'terminal') keeps only sessions started there. `folders` restricts the search to those project folders; `match` keeps rows whose title, folder or id contains the text.
+ */
+export function recentSessions({ home, userHome, limit = 20, everything = false, folders, match, source }) {
+  const files = [];
+  for (const folder of folders ?? projectFolders(home)) {
+    if (!fs.existsSync(folder)) continue;
+    for (const n of fs.readdirSync(folder)) {
+      if (!n.endsWith('.jsonl')) continue;
+      const file = path.join(folder, n);
+      files.push({ file, folder, id: n.slice(0, -'.jsonl'.length), mtimeMs: fs.statSync(file).mtimeMs });
+    }
+  }
+  files.sort((a, b) => b.mtimeMs - a.mtimeMs);
+  const desk = desktopSessionInfo({ home: userHome });
+  const needle = match ? String(match).toLowerCase() : null;
+  const out = [];
+  for (const x of files) {
+    if (out.length >= limit) break;
+    const entries = parseJsonl(fs.readFileSync(x.file, 'utf8'));
+    const sum = summarize(entries);
+    if (sum.turns === 0 || (!everything && isBackgroundAgent(sum))) continue;
+    const d = desk.get(x.id);
+    const row = { ...x, ...sum, source: sourceOf(sum, !!d), archived: !!d?.archived, label: d?.title || sum.title || firstPrompt(entries) || '(untitled)', where: tilde(sum.dominantCwd ?? x.folder, userHome) };
+    if (source && row.source !== source) continue;
+    if (needle && !`${row.label} ${row.where} ${row.id}`.toLowerCase().includes(needle)) continue;
+    out.push(row);
+  }
+  return out;
+}
+
+export const formatSession = (s, n) => {
+  const when = new Date(s.mtimeMs).toISOString().slice(0, 16).replace('T', ' ');
+  return `${n === undefined ? '' : `${String(n).padStart(2)}. `}${s.id.slice(0, 8)}  ${when}  ${String(s.turns).padStart(3)} turns  ${s.label}  [${s.source}${s.archived ? ', archived' : ''}]  ${s.where}`;
+};

package/src/cli.js

@@ -10,11 +10,14 @@ import crypto from 'node:crypto';
 import { isEncrypted } from './crypto.js';
 import { pushProject, pullProject } from './sync.js';
 import { registerDesktopSession, listDesktopDirs } from './desktop.js';
+import { recentSessions, formatSession } from './browse.js';
 
 const HELP = `carry (agent-carry): move coding-agent sessions between machines and folders. Supported agent: claude-code
 
-  carry list    [--all] [--project DIR]
-  carry export  <id|prefix|--latest> [-o FILE] [--project-root DIR]
+  carry list    [--all] [--project DIR] [--desktop | --terminal] [--match TEXT] [--limit N|all] [--everything]
+                (this folder, or --project DIR; --all: recent sessions from every folder; --desktop: only sessions
+                 from the Claude desktop app; --terminal: only terminal ones; --match: title, folder or id contains TEXT)
+  carry export  [id|prefix|--latest] [-o FILE]   no id: pick from a numbered list (also --desktop, --terminal, --project DIR, --match TEXT, --limit N) [--project-root DIR]
                 [--no-redact] [--redact-emails] [--strip-thinking | --allow-thinking-secrets]
                 [--generate-passphrase]   encrypt with a random passphrase saved next to the bundle as FILE.pass
   carry bundles                                            bundle files in this folder, ~/Downloads and ~/Desktop
@@ -32,7 +35,7 @@ Global: --claude-home DIR (default $CLAUDE_CONFIG_DIR or ~/.claude), --home DIR
 function parseArgs(argv) {
   const flags = {};
   const pos = [];
-  const valued = new Set(['-o', '--out', '--project', '--project-root', '--claude-home', '--home', '--name', '--passphrase-file', '--desktop-dir']);
+  const valued = new Set(['-o', '--out', '--project', '--project-root', '--claude-home', '--home', '--name', '--passphrase-file', '--desktop-dir', '--limit', '--match']);
   for (let i = 0; i < argv.length; i++) {
     const a = argv[i];
     if (a.startsWith('-') && a !== '-') {
@@ -43,6 +46,29 @@ function parseArgs(argv) {
   return { flags, pos };
 }
 
+/** One line from stdin, or null at end of input. Synchronous so the rest of the CLI stays simple. */
+function readLine() {
+  const buf = Buffer.alloc(1);
+  let line = '';
+  let got = false;
+  for (;;) {
+    let n;
+    try {
+      n = fs.readSync(0, buf, 0, 1, null);
+    } catch (e) {
+      if (e.code === 'EAGAIN') continue;
+      if (e.code === 'EOF') break;
+      throw e;
+    }
+    if (n === 0) break;
+    got = true;
+    const c = buf.toString();
+    if (c === '\n') return line.trim();
+    line += c;
+  }
+  return got ? line.trim() : null;
+}
+
 function fail(msg) {
   process.stderr.write(`carry: ${msg}\n`);
   process.exit(1);
@@ -60,22 +86,25 @@ function main() {
   const cwd = flags['project-root'] || flags.project || process.cwd();
   let passphrase = flags['passphrase-file'] ? fs.readFileSync(flags['passphrase-file'], 'utf8').replace(/\r?\n$/, '') : process.env.CARRY_PASSPHRASE || undefined;
   const say = (m) => flags.quiet || process.stdout.write(`${m}\n`);
+  // --desktop / --terminal on list and export: only sessions started in the desktop app / in a terminal.
+  const sourceFlag = () => {
+    if (flags.desktop && flags.terminal) fail('use --desktop or --terminal, not both');
+    return flags.desktop ? 'desktop' : flags.terminal ? 'terminal' : undefined;
+  };
 
   try {
     if (!cmd || cmd === 'help' || flags.help) return process.stdout.write(HELP);
 
     if (cmd === 'list') {
-      const folders = flags.all ? projectFolders(home) : [path.join(projectsDir(home), mangle(realpathOr(cwd)))];
-      let n = 0;
-      for (const f of folders) {
-        for (const s of listSessions(f)) {
-          n++;
-          const when = new Date(s.mtimeMs).toISOString().slice(0, 16).replace('T', ' ');
-          const where = flags.all ? `  ${s.dominantCwd ?? path.basename(f)}` : '';
-          process.stdout.write(`${s.id.slice(0, 8)}  ${when}  ${String(s.turns).padStart(3)} turns  ${s.title ?? '(untitled)'}${where}\n`);
-        }
-      }
-      if (!n) process.stdout.write(`no sessions found for ${flags.all ? 'any project' : realpathOr(cwd)}\n`);
+      // Default: this folder (or --project DIR), every session. --all: recent sessions from every folder.
+      const scope = flags.all ? undefined : [path.join(projectsDir(home), mangle(realpathOr(cwd)))];
+      const limit = flags.limit === 'all' ? Infinity : Number(flags.limit) || (flags.all ? 20 : Infinity);
+      const list = recentSessions({ home, userHome, limit, everything: !!flags.everything, folders: scope, match: flags.match, source: sourceFlag() });
+      for (const x of list) process.stdout.write(`${formatSession(x)}\n`);
+      const where = flags.all ? 'any project' : realpathOr(cwd);
+      const what = sourceFlag() ? `${sourceFlag()} ` : '';
+      if (!list.length) process.stdout.write(`no ${what}sessions found for ${where}${flags.match ? ` matching "${flags.match}"` : ''}${flags.all ? '' : '; try: carry list --all'}\n`);
+      else if (list.length === limit) process.stdout.write(`(showing the ${limit} most recent; --limit N or --limit all for more)\n`);
       return;
     }
 
@@ -91,8 +120,19 @@ function main() {
         if (!s) fail(`every session for ${realpathOr(cwd)} is empty (no prompts yet); run \`carry list\``);
         if (s !== all[0]) process.stderr.write(`carry: skipped ${all.indexOf(s)} newer empty session(s); exporting ${s.id.slice(0, 8)}\n`);
         target = { folder: here, id: s.id };
+      } else if (!pos[0]) {
+        // No id and no --latest: pick from recent sessions anywhere, so nobody needs to know where they are stored.
+        const scope = flags.project ? [path.join(projectsDir(home), mangle(realpathOr(flags.project)))] : undefined;
+        const list = recentSessions({ home, userHome, limit: Number(flags.limit) || 10, folders: scope, match: flags.match, source: sourceFlag() });
+        if (!list.length) fail('no sessions found' + (flags.match ? ` matching "${flags.match}"` : '') + '; nothing to export');
+        list.forEach((x, i) => process.stdout.write(`${formatSession(x, i + 1)}\n`));
+        process.stdout.write('Export which one? [1] ');
+        const ans = readLine();
+        if (ans === null) fail('no session chosen; pass an id (see `carry list --all`) or --latest');
+        const pick = list[(ans === '' ? 1 : Number(ans)) - 1];
+        if (!pick) fail(`"${ans}" is not one of the numbers above`);
+        target = { folder: pick.folder, id: pick.id };
       } else {
-        if (!pos[0]) fail('export needs a session id (see `carry list`) or --latest');
         // Same id can exist in several project folders (a session that was carried). Prefer the folder
         // named by --project, else the current one, and only then search everything.
         const scoped = path.join(projectsDir(home), mangle(realpathOr(flags.project || process.cwd())));
@@ -127,7 +167,7 @@ function main() {
       if (generated) fs.writeFileSync(`${out}.pass`, `${generated}\n`, { mode: 0o600 });
       const red = Object.entries(header.redaction.counts || {}).map(([k, v]) => `${k}:${v}`).join(' ') || 'none found';
       process.stdout.write(
-        `exported ${header.sessionId.slice(0, 8)} "${header.title ?? 'untitled'}" -> ${out}\n` +
+        `exported ${header.sessionId.slice(0, 8)} "${header.title ?? 'untitled'}" -> ${path.resolve(out)}\n` +
           `  parts: ${header.parts.length}   paths rewritten: ${header.pathsRewritten}\n` +
           `  redacted: ${header.redaction.enabled ? red : 'OFF'}   encrypted: ${passphrase ? 'yes' : 'no'}\n` +
           (generated ? `  passphrase saved to ${out}.pass (not printed); share it by a different channel than the bundle\n` : ''),
@@ -179,7 +219,10 @@ function main() {
 
     if (cmd === 'desktop-dirs') {
       const list = listDesktopDirs({ home: userHome });
-      for (const x of list) process.stdout.write(`${x.active ? '* signed in' : '  other    '}  ${x.entries} session${x.entries === 1 ? ' ' : 's'}  ${x.dir}\n`);
+      for (const x of list) {
+        const tags = [x.active ? 'signed in to the desktop app' : null, x.cli ? 'this terminal\'s login' : null].filter(Boolean).join(', ');
+        process.stdout.write(`${x.active ? '*' : ' '} ${x.label}${tags ? `  [${tags}]` : ''}\n    --desktop-dir "${x.dir}"\n`);
+      }
       if (!list.length) process.stdout.write('no desktop account folders found\n');
       return;
     }
@@ -208,7 +251,7 @@ function main() {
           const d = registerDesktopSession({ id: plan.id, root: plan.root, mainFile: main.dest, home: userHome, dir: flags['desktop-dir'], dryRun: !!flags['dry-run'] });
           const verb = { registered: 'added to the desktop Code tab', exists: 'already in the desktop Code tab', 'would-register': 'would be added to the desktop Code tab' }[d.status];
           process.stdout.write(`  ${verb} (${d.file}); restart the Claude desktop app if it does not appear\n`);
-          process.stdout.write(`  desktop folder: ${d.dir}\n`);
+          if (d.label) process.stdout.write(`  Code tab of: ${d.label}\n`);
           if (d.status === 'exists' && d.entryCwd && d.entryCwd !== plan.root) process.stdout.write(`  note: that Code-tab entry points at ${d.entryCwd}, not ${plan.root}\n`);
           process.stdout.write(`  chosen as: ${d.how}${d.borrowed ? '; this account has no sessions yet, so app settings were borrowed from another account' : ''}\n`);
         } catch (e) {

package/src/desktop.js

@@ -59,37 +59,101 @@ export function activeAccountFromLog(home, platform = process.platform) {
   }
 }
 
-/** Every <root>/<account>/<org> folder, with how many sessions it holds and whether it is the signed-in one. */
+/** The account the Claude Code CLI is logged in to, with its readable name, from ~/.claude.json. */
+export function cliAccount(userHome) {
+  try {
+    const j = JSON.parse(fs.readFileSync(path.join(userHome, '.claude.json'), 'utf8'));
+    const a = j.oauthAccount;
+    if (!a?.accountUuid) return null;
+    return { account: a.accountUuid, org: a.organizationUuid ?? null, name: a.fullName || a.displayName || null, email: a.emailAddress ?? null, orgName: a.organizationName && !(a.emailAddress && a.organizationName.includes(a.emailAddress)) ? a.organizationName : null };
+  } catch {
+    return null;
+  }
+}
+
+/** The account the desktop app is signed in to: its own config.json records the last one. */
+export function desktopSignedInAccount(home, platform = process.platform) {
+  if (platform !== 'darwin') return null;
+  try {
+    const j = JSON.parse(fs.readFileSync(path.join(home, 'Library', 'Application Support', 'Claude', 'config.json'), 'utf8'));
+    return typeof j.lastKnownAccountUuid === 'string' ? j.lastKnownAccountUuid : null;
+  } catch {
+    return null;
+  }
+}
+
+const plural = (n, w) => `${n} ${w}${n === 1 ? '' : 's'}`;
+
+/**
+ * Every <root>/<account>/<org> folder, with a readable label. The app stores accounts by id only, so a name is
+ * known for the account this machine's Claude Code CLI is logged in to; any other account is described by how
+ * many sessions it holds and a title or two, which is what a person can recognise.
+ * `active`: the account the desktop app is signed in to. `cli`: the account the CLI uses.
+ */
 export function listDesktopDirs({ home, platform }) {
   const root = desktopRoot(home, platform);
   if (!fs.existsSync(root)) throw new Error(`no Claude desktop Code-tab data at ${root}; open the Code tab once first`);
-  const active = activeAccountFromLog(home, platform);
-  return subdirs(root).flatMap((a) =>
+  const me = cliAccount(home);
+  const leaves = subdirs(root).flatMap((a) =>
     subdirs(a).map((d) => {
-      const files = fs.readdirSync(d).filter((f) => /^local_.*\.json$/.test(f));
-      const newest = Math.max(0, ...files.map((f) => fs.statSync(path.join(d, f)).mtimeMs));
-      return { dir: d, account: path.basename(a), org: path.basename(d), entries: files.length, newest, active: !!active && active.account === path.basename(a) && active.org === path.basename(d) };
+      const entries = readEntries(d);
+      const files = entries.length;
+      const newest = Math.max(0, ...fs.readdirSync(d).filter((f) => /^local_.*\.json$/.test(f)).map((f) => fs.statSync(path.join(d, f)).mtimeMs));
+      const account = path.basename(a);
+      const org = path.basename(d);
+      const isMe = !!me && me.account === account;
+      const titles = entries.filter(({ json }) => json.title && !json.isArchived).sort((x, y) => (y.json.lastActivityAt || 0) - (x.json.lastActivityAt || 0)).map(({ json }) => String(json.title).slice(0, 40)).filter((t, i, all) => all.indexOf(t) === i).slice(0, 2).map((t) => `“${t}”`);
+      const who = isMe ? [me.name, me.email && `<${me.email}>`].filter(Boolean).join(' ') || 'This Claude Code login' : 'A different Claude account';
+      const orgName = isMe && me.org === org && me.orgName ? ` · ${me.orgName}` : '';
+      const label = `${who}${orgName} (${files === 0 ? 'no sessions in the Code tab yet' : `${plural(files, 'session')} in the Code tab`}${titles.length ? `, e.g. ${titles.join(', ')}` : ''})`;
+      return { dir: d, account, org, entries: files, newest, cli: isMe, name: isMe ? me.name : null, email: isMe ? me.email : null, label };
     }),
   );
+  // The signed-in desktop account (config.json; the app log as a fallback), and within it the org in use.
+  const log = activeAccountFromLog(home, platform);
+  const acct = desktopSignedInAccount(home, platform) ?? log?.account ?? null;
+  let activeDir = null;
+  if (acct) {
+    const mine = leaves.filter((x) => x.account === acct);
+    const pick = (log && log.account === acct && mine.find((x) => x.org === log.org)) || (me && me.account === acct && mine.find((x) => x.org === me.org)) || [...mine].sort((x, y) => y.newest - x.newest)[0];
+    activeDir = pick?.dir ?? null;
+  }
+  return leaves.map((x) => ({ ...x, active: x.dir === activeDir }));
 }
 
 /**
- * Which folder to write to: --desktop-dir if given, else the signed-in account/org (from the app log), else
- * the only folder if there is just one. With several and no signal it refuses rather than guess, because a
- * session written into another account's folder would never be seen.
+ * Which folder to write to, so nobody has to know account ids:
+ *  - --desktop-dir if given;
+ *  - in the desktop app, or when only one account could be meant: the account the desktop app is signed in to;
+ *  - in a terminal: that same account if the terminal is logged in to it, but if the terminal and the desktop app
+ *    are logged in as different accounts, ask (the error lists them by name), because a session written into the
+ *    wrong account's Code tab would never be seen.
+ * `surface` is CLAUDE_CODE_ENTRYPOINT: 'cli' for a terminal, 'claude-desktop' for the desktop app.
  */
-export function resolveDesktopDir({ home, dir, platform }) {
+export function resolveDesktopDir({ home, dir, platform, surface = process.env.CLAUDE_CODE_ENTRYPOINT }) {
   if (dir) {
     if (!fs.existsSync(dir)) throw new Error(`desktop folder not found: ${dir}`);
-    return { dir: path.resolve(dir), how: 'given' };
+    return { dir: path.resolve(dir), how: 'chosen by you', label: null };
   }
   const all = listDesktopDirs({ home, platform });
   if (all.length === 0) throw new Error('no account folder in the desktop app data; open the Code tab once first');
-  const active = all.find((x) => x.active);
-  if (active) return { dir: active.dir, how: 'signed-in account (from the app log)' };
-  if (all.length === 1) return { dir: all[0].dir, how: 'only account folder' };
-  const rows = all.map((x) => `  ${x.dir}  (${x.entries} session${x.entries === 1 ? '' : 's'})`).join('\n');
-  throw new Error(`cannot tell which desktop account is signed in; pick one with --desktop-dir:\n${rows}`);
+  const desk = all.find((x) => x.active);
+  const mine = all.filter((x) => x.cli);
+  const cli = mine.find((x) => x.active) ?? [...mine].sort((x, y) => y.newest - x.newest)[0];
+  if (surface === 'cli' && cli && desk && cli.account !== desk.account) {
+    const e = new Error(
+      `this terminal is logged in as one Claude account but the desktop app is signed in as another; which Code tab should get the session?\n` +
+        `  1. ${cli.label}   (--desktop-dir "${cli.dir}")\n  2. ${desk.label}   (--desktop-dir "${desk.dir}")`,
+    );
+    e.choices = [cli, desk];
+    throw e;
+  }
+  const chosen = desk ?? (surface === 'cli' ? cli : null) ?? (all.length === 1 ? all[0] : null);
+  if (chosen) return { dir: chosen.dir, how: chosen === desk ? 'the signed-in desktop account' : 'the only account folder', label: chosen.label };
+  const rows = all.map((x, i) => `  ${i + 1}. ${x.label}   (--desktop-dir "${x.dir}")`).join('\n');
+  const e = new Error(`cannot tell which desktop account is signed in; choose one:\n${rows}`);
+  e.choices = all;
+  throw e;
 }
 
 function readEntries(dir) {
@@ -111,7 +175,7 @@ function lastModel(entries) {
   return model;
 }
 
-function firstPrompt(entries) {
+export function firstPrompt(entries) {
   for (const { rec } of entries) {
     if (rec?.type !== 'user' || rec.isMeta || rec.isSidechain) continue;
     const c = rec.message?.content;
@@ -162,10 +226,10 @@ export function buildDesktopEntry({ template, cliSessionId, root, transcript, no
  * Returns { status: 'registered' | 'exists' | 'would-register', file, dir }.
  */
 export function registerDesktopSession({ id, root, mainFile, home, dir, platform, dryRun = false }) {
-  const { dir: target, how } = resolveDesktopDir({ home, dir, platform });
+  const { dir: target, how, label } = resolveDesktopDir({ home, dir, platform });
   const existing = readEntries(target);
   const have = existing.find(({ json }) => json.cliSessionId === id || (Array.isArray(json.priorCliSessionIds) && json.priorCliSessionIds.includes(id)));
-  if (have) return { status: 'exists', file: have.file, dir: target, how, entryCwd: have.json.cwd };
+  if (have) return { status: 'exists', file: have.file, dir: target, how, label, entryCwd: have.json.cwd };
   const newest = (list) => list.filter(({ json }) => !json.isArchived).sort((a, b) => (b.json.lastActivityAt || 0) - (a.json.lastActivityAt || 0))[0]?.json;
   let template = newest(existing);
   let borrowed = false;
@@ -179,7 +243,7 @@ export function registerDesktopSession({ id, root, mainFile, home, dir, platform
     }
   }
   if (!template) throw new Error('no existing Code-tab session anywhere to copy app settings from; start one session in the desktop app Code tab first');
-  if (dryRun) return { status: 'would-register', file: 'a new local_*.json', dir: target, how, borrowed };
+  if (dryRun) return { status: 'would-register', file: 'a new local_*.json', dir: target, how, label, borrowed };
 
   const entry = buildDesktopEntry({ template, cliSessionId: id, root, transcript: parseJsonl(fs.readFileSync(mainFile, 'utf8')) });
   const file = `${entry.sessionId}.json`;
@@ -187,5 +251,18 @@ export function registerDesktopSession({ id, root, mainFile, home, dir, platform
   const tmp = `${dest}.carry-tmp`;
   fs.writeFileSync(tmp, JSON.stringify(entry), { mode: 0o600 });
   fs.renameSync(tmp, dest);
-  return { status: 'registered', file, dir: target, how, borrowed };
+  return { status: 'registered', file, dir: target, how, label, borrowed };
+}
+
+/** cliSessionId -> { title, archived } as the desktop app lists it. Empty when there is no desktop app data. */
+export function desktopSessionInfo({ home, platform }) {
+  const out = new Map();
+  try {
+    for (const { dir } of listDesktopDirs({ home, platform })) {
+      for (const { json } of readEntries(dir)) if (json.cliSessionId) out.set(json.cliSessionId, { title: json.title || null, archived: !!json.isArchived });
+    }
+  } catch {
+    // no desktop app, unreadable data, or a platform we don't know: this is a nicety, not a requirement
+  }
+  return out;
 }