agent-carry 0.1.1 → 0.2.0

package/CHANGELOG.md

@@ -2,6 +2,14 @@
 
 ## Unreleased
 
+- 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.
+- `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).
 - `agent-carry` works as a second command name for `carry`.
 - README trimmed; plugin author set.
 

package/README.md

@@ -28,6 +28,20 @@ claude --resume <id>          # printed by import
 Encrypt a bundle with `CARRY_PASSPHRASE` or `--passphrase-file FILE` (AES-256-GCM, scrypt key). Never pass the
 passphrase as an argument.
 
+### Claude desktop app (Code tab)
+
+The Code tab lists sessions from its own index, so an imported session resumes in a terminal but doesn't appear
+there. Add `--desktop` to also write the index entry (macOS; the signed-in account is used):
+
+```
+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.
+
 ### Sync through a shared folder
 
 Point both machines at a folder your sync tool already replicates (Dropbox, iCloud, Syncthing, a git tree).
@@ -41,17 +55,26 @@ Projects are matched by git remote, not path. Each file has one writer, so there
 
 ### Claude Code plugin
 
-`plugin/` adds `/carry:share` and `/carry:pickup`. With `CARRY_SYNC_DIR` set, bundled hooks pull on session
-start and push on session end (hooks not yet exercised in a live Claude Code).
+```
+/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.
+
+- `/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).
+
+Passphrases are never put on a command line. A generated one is saved beside the bundle as `FILE.pass` (mode 600) and never printed; a typed one is stored in that conversation's history, so use it only for throwaway passphrases. With `CARRY_SYNC_DIR` set, bundled hooks pull on session start and push on session end (hooks not yet exercised live).
 
 ## Commands
 
 | command | |
 |---|---|
 | `carry list [--all]` | sessions for this folder, or all |
-| `carry export <id\|--latest> [-o FILE]` | `--no-redact`, `--redact-emails`, `--strip-thinking`, `--allow-thinking-secrets`, `--project-root DIR` |
+| `carry export <id\|--latest> [-o FILE]` | `--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 |
 | `carry push DIR` / `carry pull DIR` | folder sync (`--name`, `--dry-run`, `--quiet`) |
 
 ## Limits
@@ -59,13 +82,14 @@ start and push on session end (hooks not yet exercised in a live Claude Code).
 - **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.
-- Not handled: Windows paths, Cowork/desktop sessions, file-history (rewind) backups.
+- `--desktop` writes the app's index format, which is internal and undocumented; it is tested against fixtures and a dry run on a real Code-tab folder, but not yet confirmed by resuming from the app itself.
+- Not handled: Windows paths, Cowork, file-history (rewind) backups.
 - `push` re-uploads pulled sessions, so a sync folder grows with devices × sessions.
 
 ## Development
 
 ```
-npm test                  # 36 tests, synthetic two-machine setups
+npm test                  # 49 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.1.1",
+  "version": "0.2.0",
   "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": {

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

@@ -1,6 +1,6 @@
 {
   "name": "carry",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "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" },
   "license": "MIT"

package/plugin/commands/pickup.md

@@ -1,13 +1,32 @@
 ---
-description: Import a carry bundle into this folder so it can be resumed
-argument-hint: <bundle-file> [--dry-run]
-allowed-tools: Bash(carry import:*)
+description: Import a carry bundle into a folder (and optionally the Claude desktop app); asks which bundle, passphrase, and where
+argument-hint: [bundle-file]
+allowed-tools: Bash(carry:*), Bash(npx -y agent-carry@latest:*), Bash(ls:*), Bash(pwd), AskUserQuestion
 ---
 
-Import result:
+Bundle files nearby (this folder, ~/Downloads, ~/Desktop), newest first:
 
-!`carry import $ARGUMENTS 2>&1 || echo "carry is not installed: run npm i -g agent-carry"`
+!`carry bundles 2>&1 || npx -y agent-carry@latest bundles 2>&1`
 
-Tell the user the session was imported into this folder and that a running session cannot swap its own
-history: they should exit and run the `claude --resume <id>` line printed above. If `--dry-run` was used,
-say nothing was written.
+Current folder: !`pwd`
+
+Claude desktop app account folders (macOS only; an error here just means no desktop app):
+
+!`carry desktop-dirs 2>&1`
+
+Arguments the user typed: $ARGUMENTS
+
+You are importing one session with the `carry` CLI. If `carry` was not found above, use `npx -y agent-carry@latest` in its place; if that also fails, tell the user to run `npm i -g agent-carry` and stop. If a command says it is unknown, the CLI is old: tell the user to run `npm i -g agent-carry@latest`.
+
+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 as a short numbered list in plain text and wait.
+
+1. **Which bundle.** If the arguments name a file, use it. Otherwise offer up to four of the listed bundles (label: file name; description: date, size and what it holds). If none were found, ask for a path.
+2. **Passphrase, only if the bundle is encrypted.** Options:
+   - "Use the .pass file next to it": offer only if `ls <bundle>.pass` shows it exists.
+   - "A passphrase file at another path": ask for the path, then `--passphrase-file PATH`.
+   - "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.
+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.

package/plugin/commands/share.md

@@ -1,13 +1,27 @@
 ---
-description: Export this project's latest session as a portable, redacted carry bundle
-argument-hint: [-o FILE] [--strip-thinking] [--redact-emails]
-allowed-tools: Bash(carry export:*)
+description: Export a session as a portable, redacted bundle; asks which session, whether to encrypt, and where to save
+argument-hint: [optional carry export flags, e.g. -o FILE --strip-thinking]
+allowed-tools: Bash(carry:*), Bash(npx -y agent-carry@latest:*), AskUserQuestion
 ---
 
-Export result (this runs the `carry` CLI from `npm i -g agent-carry`):
+Sessions in this folder, newest first (the top one is usually this conversation):
 
-!`carry export --latest $ARGUMENTS 2>&1 || echo "carry is not installed: run npm i -g agent-carry"`
+!`carry list 2>&1 || npx -y agent-carry@latest list 2>&1`
 
-Report in at most three lines: the file that was written, how many secrets were redacted, and any warning above.
-If there is a warning about credential-like strings in thinking blocks, tell the user to re-run `/carry:share --strip-thinking`.
-Do not open or print the bundle's contents.
+Arguments the user typed: $ARGUMENTS
+
+You are exporting one session with the `carry` CLI. If `carry` was not found above, use `npx -y agent-carry@latest` in its place; if that also fails, tell the user to run `npm i -g agent-carry` and stop. If a command below says it is unknown, the CLI is old: tell the user to run `npm i -g agent-carry@latest`.
+
+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.
+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`.
+   - "Yes, use my passphrase file": ask for the path, then use `--passphrase-file PATH`.
+   - "Yes, I'll type one here": warn that whatever is typed is stored in this conversation's history, so use only a throwaway passphrase. Take it from a follow-up question and pass it as `CARRY_PASSPHRASE='…' carry export …`. Never repeat it back, never put it in a file name.
+3. **Where to save.** Options: this folder (default), Desktop, or another path. Name the file `<first 8 chars of the id>.carry.gz`, or `.carry.enc` when encrypting, and pass it with `-o`.
+4. **Run** `carry export <id> -o <file> [flags]` (with `--project-root` only if the user asked). If it refuses because signed thinking blocks contain credential-like strings, ask: "Drop thinking blocks (Recommended)" or "Keep them as they are (the strings stay in the file)", then re-run with `--strip-thinking` or `--allow-thinking-secrets`.
+5. **Report in at most five lines:** the file path, how many secrets were redacted, whether it is encrypted, and any warning. If a passphrase was generated, say it is saved in `<file>.pass` (mode 600) and must be sent by a different channel than the bundle; do not print it. Tell them the other side runs `/carry:pickup` or `carry import <file>`.
+
+Never open or print the bundle's contents, and never put a passphrase on a command line other than as `CARRY_PASSPHRASE` above.

package/src/bundle.js

@@ -170,11 +170,15 @@ export function readBundle(file, { passphrase } = {}) {
  * Write a bundle into a Claude home for a target project root. Returns a plan;
  * with dryRun it writes nothing.
  */
-export function importBundle({ bundle, claudeHome, root, home, dryRun = false }) {
+const ANSI = /\x1b\[[0-9;]*[A-Za-z]/g;
+
+/** `stripAnsi` drops terminal colour codes from incoming text, for apps that show them as literal characters. */
+export function importBundle({ bundle, claudeHome, root, home, dryRun = false, stripAnsi = false }) {
   const realRoot = realpathOr(root);
   const folder = path.join(projectsDir(claudeHome), mangle(realRoot));
   const where = { store: folder, root: realRoot, home };
   const back = fromPortable(where);
+  const text = stripAnsi ? (v) => back.fn(v).replace(ANSI, '') : back.fn;
   const id = bundle.header.sessionId;
   const plan = { id, folder, root: realRoot, files: [], warnings: [] };
   if (mangle(realRoot).length > 200) {
@@ -195,7 +199,7 @@ export function importBundle({ bundle, claudeHome, root, home, dryRun = false })
     let stat;
     if (kind === 'jsonl') {
       const incoming = rows.map((r) => {
-        const raw = r.l !== undefined ? JSON.stringify(mapStrings(r.l, back.fn)) : back.fn(r.x);
+        const raw = r.l !== undefined ? JSON.stringify(mapStrings(r.l, text)) : back.fn(r.x);
         return { raw, rec: r.l !== undefined ? JSON.parse(raw) : null };
       });
       const local = fs.existsSync(dest) ? parseJsonl(fs.readFileSync(dest, 'utf8')) : [];

package/src/cli.js

@@ -6,16 +6,22 @@ import { projectFolders, listSessions, findSession } from './store.js';
 import { buildBundle, writeBundle, readBundle, importBundle } from './bundle.js';
 import { parseJsonl, summarize } from './transcript.js';
 import fs from 'node:fs';
+import crypto from 'node:crypto';
+import { isEncrypted } from './crypto.js';
 import { pushProject, pullProject } from './sync.js';
+import { registerDesktopSession, listDesktopDirs } from './desktop.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]
                 [--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
   carry inspect <bundle>
-  carry import  <bundle> [--project-root DIR] [--dry-run]
+  carry import  <bundle> [--project-root DIR] [--dry-run] [--desktop [--desktop-dir DIR]]
   carry push    <dir> [--name PROJECT] [--quiet]     sync every session of this project to a shared folder
+  carry desktop-dirs                                       desktop-app account folders (which one is signed in)
   carry pull    <dir> [--name PROJECT] [--dry-run] [--quiet]
 
 Encryption (export, import, push, pull): set CARRY_PASSPHRASE or pass --passphrase-file FILE.
@@ -26,7 +32,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']);
+  const valued = new Set(['-o', '--out', '--project', '--project-root', '--claude-home', '--home', '--name', '--passphrase-file', '--desktop-dir']);
   for (let i = 0; i < argv.length; i++) {
     const a = argv[i];
     if (a.startsWith('-') && a !== '-') {
@@ -52,7 +58,7 @@ function main() {
   const home = flags['claude-home'] ? path.resolve(flags['claude-home']) : claudeHome();
   const userHome = flags.home ? path.resolve(flags.home) : os.homedir();
   const cwd = flags['project-root'] || flags.project || process.cwd();
-  const passphrase = flags['passphrase-file'] ? fs.readFileSync(flags['passphrase-file'], 'utf8').replace(/\r?\n$/, '') : process.env.CARRY_PASSPHRASE || undefined;
+  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`);
 
   try {
@@ -78,8 +84,12 @@ function main() {
       let target;
       if (flags.latest) {
         const here = path.join(projectsDir(home), mangle(realpathOr(cwd)));
-        const s = listSessions(here)[0];
-        if (!s) fail(`no sessions for ${realpathOr(cwd)}`);
+        const all = listSessions(here);
+        if (!all.length) fail(`no sessions for ${realpathOr(cwd)}`);
+        // A session opened and closed without a prompt has nothing to carry; don't let it shadow the real one.
+        const s = all.find((x) => x.turns > 0);
+        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]) fail('export needs a session id (see `carry list`) or --latest');
@@ -106,13 +116,21 @@ function main() {
         stripThinking: !!flags['strip-thinking'],
         allowThinkingSecrets: !!flags['allow-thinking-secrets'],
       });
+      let generated = null;
+      if (flags['generate-passphrase']) {
+        if (passphrase) fail('use either --generate-passphrase or a passphrase of your own, not both');
+        generated = crypto.randomBytes(18).toString('base64url');
+        passphrase = generated;
+      }
       const out = flags.o || flags.out || `${target.id.slice(0, 8)}${passphrase ? '.carry.enc' : '.carry.gz'}`;
       writeBundle(out, text, { passphrase });
+      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` +
           `  parts: ${header.parts.length}   paths rewritten: ${header.pathsRewritten}\n` +
-          `  redacted: ${header.redaction.enabled ? red : 'OFF'}   encrypted: ${passphrase ? 'yes' : 'no'}\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` : ''),
       );
       if (header.residualHomePaths > 0) {
         process.stderr.write(`  warning: ${header.residualHomePaths} other absolute home path(s) remain in the bundle (other users or tools). Review with \`carry inspect\`.\n`);
@@ -124,6 +142,48 @@ function main() {
       return;
     }
 
+    if (cmd === 'bundles') {
+      const seen = new Set();
+      const found = [];
+      for (const dir of [process.cwd(), path.join(userHome, 'Downloads'), path.join(userHome, 'Desktop')]) {
+        let names = [];
+        try {
+          names = fs.readdirSync(dir);
+        } catch {
+          continue;
+        }
+        for (const n of names.filter((n) => /\.carry\.(gz|enc)$/.test(n))) {
+          const file = path.join(dir, n);
+          if (seen.has(file)) continue;
+          seen.add(file);
+          found.push({ file, st: fs.statSync(file) });
+        }
+      }
+      found.sort((a, b) => b.st.mtimeMs - a.st.mtimeMs);
+      for (const { file, st } of found.slice(0, 10)) {
+        const enc = isEncrypted(fs.readFileSync(file).subarray(0, 64));
+        let what = 'encrypted: needs its passphrase';
+        if (!enc) {
+          try {
+            const { header } = readBundle(file, {});
+            what = `"${header.title ?? 'untitled'}", ${header.turns} turn(s), session ${header.sessionId.slice(0, 8)}`;
+          } catch {
+            what = 'unreadable';
+          }
+        }
+        process.stdout.write(`${file}\n    ${enc ? 'encrypted' : 'plain'}  ${st.mtime.toISOString().slice(0, 16).replace('T', ' ')}  ${(st.size / 1024).toFixed(1)} KB  ${what}\n`);
+      }
+      if (!found.length) process.stdout.write('no .carry.gz or .carry.enc files found here, in ~/Downloads or ~/Desktop\n');
+      return;
+    }
+
+    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`);
+      if (!list.length) process.stdout.write('no desktop account folders found\n');
+      return;
+    }
+
     if (cmd === 'inspect') {
       if (!pos[0]) fail('inspect needs a bundle file');
       const { header } = readBundle(pos[0], { passphrase });
@@ -134,7 +194,7 @@ function main() {
     if (cmd === 'import') {
       if (!pos[0]) fail('import needs a bundle file');
       const bundle = readBundle(pos[0], { passphrase });
-      const plan = importBundle({ bundle, claudeHome: home, root: cwd, home: userHome, dryRun: !!flags['dry-run'] });
+      const plan = importBundle({ bundle, claudeHome: home, root: cwd, home: userHome, dryRun: !!flags['dry-run'], stripAnsi: !!(flags.desktop || flags['desktop-dir']) });
       process.stdout.write(`${flags['dry-run'] ? 'would import' : 'imported'} ${plan.id.slice(0, 8)} into ${plan.folder}\n`);
       for (const f of plan.files.filter((f) => f.kind === 'jsonl')) {
         process.stdout.write(`  ${f.rel}: +${f.added} new, ${f.skipped} already present\n`);
@@ -142,6 +202,19 @@ function main() {
       const side = plan.files.filter((f) => f.kind !== 'jsonl');
       if (side.length) process.stdout.write(`  sidecar files: ${side.filter((f) => f.added).length} new, ${side.filter((f) => !f.added).length} kept\n`);
       for (const w of plan.warnings) process.stderr.write(`  warning: ${w}\n`);
+      if (flags.desktop || flags['desktop-dir']) {
+        try {
+          const main = plan.files.find((f) => f.rel === 'main.jsonl');
+          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.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) {
+          process.stderr.write(`  desktop: ${e.message}\n  the session itself was imported and resumes from a terminal\n`);
+        }
+      }
       if (!flags['dry-run']) process.stdout.write(`\nresume with:\n  cd ${plan.root} && claude --resume ${plan.id}\n`);
       return;
     }

package/src/desktop.js

@@ -0,0 +1,191 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import crypto from 'node:crypto';
+import { parseJsonl, summarize } from './transcript.js';
+
+/**
+ * The Claude desktop app's Code tab lists sessions from its own index, one
+ * `local_<uuid>.json` per session, whose `cliSessionId` points at the normal
+ * Claude Code transcript. Importing a transcript does not add it to that
+ * index, so it would resume in a terminal but not show up in the Code tab.
+ *
+ * This writes the missing index entry. App-level settings (MCP servers,
+ * prompt snapshot, ...) are copied from the newest existing entry rather than
+ * invented, so a Code tab that has never been used cannot be targeted.
+ */
+
+// Settings that belong to the app, not to an account: safe to borrow from a session of another account.
+const GENERIC_KEYS = ['effort', 'classifierSummaryEnabled', 'reportFindingsCard', 'promptAppendSnapshot', 'chromePermissionMode'];
+
+// Everything below also reflects one account's MCP connectors and tool toggles, so it is copied only from the same account.
+const KEEP_FROM_TEMPLATE = [
+  'effort',
+  'permissionMode',
+  'enabledMcpTools',
+  'remoteMcpServersConfig',
+  'chromePermissionMode',
+  'classifierSummaryEnabled',
+  'reportFindingsCard',
+  'promptAppendSnapshot',
+  'toolSurfaceSnapshot',
+];
+
+export function desktopRoot(home, platform = process.platform) {
+  if (platform === 'darwin') return path.join(home, 'Library', 'Application Support', 'Claude', 'claude-code-sessions');
+  throw new Error('automatic desktop-app lookup is only implemented for macOS; pass --desktop-dir');
+}
+
+const subdirs = (d) => fs.readdirSync(d, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => path.join(d, e.name));
+
+/**
+ * The app's most recently active account/org, read from its own log: the app starts every session under
+ * scratch-workspaces/<account>/<org>/, so the last such path names whoever is signed in now.
+ */
+export function activeAccountFromLog(home, platform = process.platform) {
+  if (platform !== 'darwin') return null;
+  const log = path.join(home, 'Library', 'Logs', 'Claude', 'main.log');
+  try {
+    const size = fs.statSync(log).size;
+    const fd = fs.openSync(log, 'r');
+    const len = Math.min(size, 4 * 1024 * 1024);
+    const buf = Buffer.alloc(len);
+    fs.readSync(fd, buf, 0, len, size - len);
+    fs.closeSync(fd);
+    const all = [...buf.toString('utf8').matchAll(/scratch-workspaces\/([0-9a-f-]{36})\/([0-9a-f-]{36})/g)];
+    const last = all[all.length - 1];
+    return last ? { account: last[1], org: last[2] } : null;
+  } catch {
+    return null;
+  }
+}
+
+/** Every <root>/<account>/<org> folder, with how many sessions it holds and whether it is the signed-in one. */
+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) =>
+    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) };
+    }),
+  );
+}
+
+/**
+ * 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.
+ */
+export function resolveDesktopDir({ home, dir, platform }) {
+  if (dir) {
+    if (!fs.existsSync(dir)) throw new Error(`desktop folder not found: ${dir}`);
+    return { dir: path.resolve(dir), how: 'given' };
+  }
+  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}`);
+}
+
+function readEntries(dir) {
+  const out = [];
+  for (const f of fs.readdirSync(dir)) {
+    if (!/^local_.*\.json$/.test(f)) continue;
+    try {
+      out.push({ file: f, json: JSON.parse(fs.readFileSync(path.join(dir, f), 'utf8')) });
+    } catch {
+      // an unreadable entry is not ours to judge; skip it
+    }
+  }
+  return out;
+}
+
+function lastModel(entries) {
+  let model = null;
+  for (const { rec } of entries) if (rec?.type === 'assistant' && typeof rec.message?.model === 'string') model = rec.message.model;
+  return model;
+}
+
+function firstPrompt(entries) {
+  for (const { rec } of entries) {
+    if (rec?.type !== 'user' || rec.isMeta || rec.isSidechain) continue;
+    const c = rec.message?.content;
+    const text = typeof c === 'string' ? c : Array.isArray(c) ? c.find((p) => p?.type === 'text')?.text : null;
+    if (text && !text.startsWith('<')) return text.replace(/\s+/g, ' ').trim().slice(0, 60);
+  }
+  return null;
+}
+
+/** Build the index entry for an already-imported session. Pure; no I/O. */
+export function buildDesktopEntry({ template, cliSessionId, root, transcript, now = Date.now(), uuid = crypto.randomUUID() }) {
+  const s = summarize(transcript);
+  const at = (iso, fallback) => (iso && Number.isFinite(Date.parse(iso)) ? Date.parse(iso) : fallback);
+  const entry = {
+    sessionId: `local_${uuid}`,
+    cliSessionId,
+    cwd: root,
+    originCwd: root,
+    createdAt: at(s.first, now),
+    lastActivityAt: at(s.last, now),
+    lastFocusedAt: at(s.last, now),
+    model: lastModel(transcript) || template.model,
+    isArchived: false,
+    title: s.title || firstPrompt(transcript) || `Imported session ${cliSessionId.slice(0, 8)}`,
+    titleSource: 'auto',
+    completedTurns: s.turns,
+    lastSpawnRootDetected: false,
+    alwaysAllowedReasons: [],
+    sessionPermissionUpdates: [],
+    spawnSeed: {},
+  };
+  if (template.generic) {
+    // Another account's session: take app settings only. Connectors and permission grants are account-specific,
+    // and the safest permission mode is the default one.
+    for (const k of GENERIC_KEYS) if (template[k] !== undefined) entry[k] = template[k];
+    entry.permissionMode = 'default';
+    entry.enabledMcpTools = {};
+    entry.remoteMcpServersConfig = [];
+  } else {
+    for (const k of KEEP_FROM_TEMPLATE) if (template[k] !== undefined) entry[k] = template[k];
+  }
+  return entry;
+}
+
+/**
+ * Register an imported session with the desktop app. Idempotent: a session
+ * that already has an index entry is left alone.
+ * 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 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 };
+  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;
+  if (!template) {
+    // A freshly signed-in account has no sessions yet; borrow app-level settings from any other account's.
+    const others = listDesktopDirs({ home, platform }).filter((x) => x.dir !== target).flatMap((x) => readEntries(x.dir));
+    const t = newest(others);
+    if (t) {
+      template = { ...t, generic: true };
+      borrowed = true;
+    }
+  }
+  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 };
+
+  const entry = buildDesktopEntry({ template, cliSessionId: id, root, transcript: parseJsonl(fs.readFileSync(mainFile, 'utf8')) });
+  const file = `${entry.sessionId}.json`;
+  const dest = path.join(target, file);
+  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 };
+}