agent-carry 0.4.0 → 0.4.1

package/CHANGELOG.md

@@ -1,18 +1,33 @@
 # Changelog
 
-## Unreleased
+Plugin, marketplace entry and package share one version number; `npm version` keeps them in step.
 
-- `carry list --all` now shows the most recent sessions across every folder, newest first, with the title the desktop app shows and the folder; background-agent sessions (e.g. a memory plugin's observer) are hidden unless `--everything`. `carry export` with no id offers a numbered picker. `--limit N|all` shows more, `--project DIR` lists one folder, `--match TEXT` filters by title, folder or id, and `--desktop` / `--terminal` keep only sessions started in the desktop app or a terminal (every row is tagged; archived desktop sessions are marked; a desktop session with no project folder shows as "desktop scratch folder"). Nobody needs to know where sessions are stored. `/carry:share` uses it (plugin 0.3.0).
+## 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.
 
-- Plugin 0.2.1 (released): 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.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

@@ -42,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
 
@@ -61,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).
@@ -73,7 +73,7 @@ Passphrases are never put on a command line. A generated one is saved beside the
 | command | |
 |---|---|
 | `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`).  `--generate-passphrase`, `--no-redact`, `--redact-emails`, `--strip-thinking`, `--allow-thinking-secrets`, `--project-root DIR` |
+| `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 |
@@ -92,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.4.0",
+  "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.3.0",
+  "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,7 +4,7 @@ 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'`
 
 Recent sessions from every folder, newest first, including ones started in the Claude desktop app (the top one is usually this conversation):
 
@@ -14,7 +14,7 @@ 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.
 

package/src/cli.js

@@ -219,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;
     }
@@ -248,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) {
@@ -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,7 +251,7 @@ 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. */