agent-carry 0.1.0 → 0.2.0

package/CHANGELOG.md

@@ -1,5 +1,18 @@
 # Changelog
 
+## 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.
+
 ## 0.1.0
 
 First release. Claude Code adapter.

package/README.md

@@ -1,156 +1,100 @@
 # agent-carry
 
-Move a coding-agent session to another machine, or another folder, and keep working.
-
-**Agents:** Claude Code is supported today. Every bundle records which agent it came from (`agent` in the header),
-so other agents can be added as adapters without changing the format; a build that doesn't know an agent refuses
-its bundles with a clear error instead of guessing. Codex is the intended next adapter and is **not implemented yet**.
-
-For Claude Code: it keeps each session in `~/.claude/projects/<folder>/<id>.jsonl`, where `<folder>` is the project's
-absolute path with every non-alphanumeric character turned into `-`. The transcript itself is full of absolute
-paths (about three quarters of the lines in a typical one). Copy the file to another machine and `--resume` can't
-find it, and if you force it, every path in the history points at a machine that isn't there.
-
-`carry` makes a session portable:
-
-- **Path-portable.** Your project root, home directory and session-store path become tokens on export and are
-  rewritten for the target machine on import. Object keys too: file-history snapshots are maps keyed by path.
-- **Merge-safe.** Records have stable `uuid`s, so import is a union, not an overwrite. Importing twice changes
-  nothing, and a session that continued on two machines becomes a two-branch history instead of a conflict.
-  The local file is the source of truth: its lines are kept byte for byte.
-- **Redacted.** Credential-shaped strings (cloud keys, tokens, JWTs, private keys, `*_SECRET=...`, URL passwords)
-  are removed before anything is written. The export prints what it removed.
-- **Complete.** Subagent transcripts and offloaded tool results travel with the session, and the references to
-  them are rewritten.
-- **Inspectable.** A bundle is newline-delimited JSON. `carry inspect` shows its header; `less` and `jq` show the rest.
+Move a coding-agent session to another machine or folder and keep working. Supports Claude Code today.
+
+Claude Code stores sessions per absolute project path, and the transcripts are full of absolute paths, so a
+copied session can't be resumed elsewhere. `carry` fixes that:
+
+- **Path-portable:** project, home and store paths become tokens on export and are rewritten on import.
+- **Merge-safe:** import is a union by record `uuid`. Importing twice changes nothing; a session continued on two machines becomes a two-branch history.
+- **Redacted:** credential-shaped strings (cloud keys, tokens, JWTs, private keys, `*_SECRET=...`, URL passwords) are removed on export, with a report.
+- **Complete:** subagent transcripts and tool results travel with the session.
+- **Inspectable:** a bundle is newline-delimited JSON (gzipped).
+
+## Usage
 
 ```
-npm i -g agent-carry
+npm i -g agent-carry          # installs `carry` (also available as `agent-carry`)
 
-# on machine A, in the project folder
+# machine A, in the project folder
 carry list
 carry export --latest -o session.carry.gz
 
-# on machine B, in the same project (wherever it lives)
+# machine B, in the same project (any path)
 carry import session.carry.gz
-claude --resume <id>        # printed by import
+claude --resume <id>          # printed by import
 ```
 
-As a Claude Code plugin (`plugin/`): `/carry:share` and `/carry:pickup` wrap the same two commands.
+Encrypt a bundle with `CARRY_PASSPHRASE` or `--passphrase-file FILE` (AES-256-GCM, scrypt key). Never pass the
+passphrase as an argument.
 
-### Keep machines in sync through any shared folder
+### Claude desktop app (Code tab)
 
-No server, account or key exchange: point both machines at a folder your existing sync tool already
-replicates (Syncthing, Dropbox, iCloud, a git working tree, a network share).
+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):
 
 ```
-export CARRY_PASSPHRASE='long passphrase'     # optional: encrypts everything written
-carry push ~/Sync/carry                        # this project's sessions -> folder
-carry pull ~/Sync/carry                        # other devices' sessions -> this machine
+carry import session.carry.gz --desktop
 ```
 
-Layout: `<dir>/<project>/<session-id>/<device>.carry.gz` (or `.carry.enc`). Every file has exactly one writer,
-so a sync tool never sees a conflict; `pull` unions the other devices' files into your local session. The
-project is identified by its git remote, not its path, so `~/work/app` and `D:\code\app` find each other. Push
-skips sessions that haven't changed, so the folder doesn't churn.
+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.
 
-With the plugin installed, set `CARRY_SYNC_DIR` and the bundled hooks pull on session start and push on session
-end. (Hooks are written to the plugin spec but I have not exercised them inside a live Claude Code yet.)
+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.
 
-| command | |
-|---|---|
-| `carry list [--all]` | sessions for this folder (or every folder) |
-| `carry export <id\|--latest> [-o FILE]` | build a bundle. `--no-redact`, `--redact-emails`, `--strip-thinking`, `--project-root DIR` |
-| `carry inspect FILE` | header: parts, redaction counts, warnings |
-| `carry import FILE [--project-root DIR] [--dry-run]` | write into the target folder's session store |
-| `carry push DIR` / `carry pull DIR [--name P] [--dry-run] [--quiet]` | folder sync, described above |
-
-Passphrase: `CARRY_PASSPHRASE` or `--passphrase-file`. AES-256-GCM with a scrypt-derived key (node:crypto), header
-authenticated. Never pass a passphrase as an argument; it would land in shell history.
-
-`--claude-home` and `--home` override `~/.claude` and the home directory, which is how the tests run two
-machines in one process.
-
-## Compared with ctxhop
-
-[ctxhop](https://github.com/CCCCY-ci/ctxhop) is the larger, more mature tool and solves a wider problem. If you
-want a continuously syncing, multi-device product with its own encrypted store, use it. Where the two differ
-(from reading its README and adapter source, not from running it):
-
-| | agent-carry | ctxhop |
-|---|---|---|
-| Scope | Claude Code sessions; share one, or sync a project through a folder | Claude Code + Codex, cross-agent switch, workspace and Git handoff, device authorisation, key rotation |
-| Setup | none for a file; a shared folder for sync | `init` with an S3/R2/directory backend, passphrase, device invites |
-| Runtime | Node, zero dependencies | Go binary, installers |
-| Paths inside commands, prose and tool output | rewritten (boundary-aware); 0 leaks on 1,150 real sessions | left alone by design (only known path fields and bare paths are tokenised), so source paths and usernames stay in the history |
-| Secrets inside transcript content | redacted before leaving the machine, with a report | not scanned; protected by encryption in transit and at rest |
-| Sharing with someone else | a single inspectable file | designed for your own authorised devices |
-| Inspectability | newline-delimited JSON, readable with `jq` | encrypted objects in a remote |
-| Platforms | macOS, Linux | adds Windows |
-
-So: carry is better when you want to *hand a session to someone*, keep secrets out of it, or sync with
-nothing but a folder. ctxhop is better for an always-on personal sync across many devices and agents.
-
-## What is verified
-
-- `npm test`: 36 tests on synthetic two-machine setups: planted secrets and paths, merge, tampering, encryption, folder sync convergence.
-- `npm run check:real` round-trips every session in your own `~/.claude` into a temp store under a different
-  root, read-only on the real one. On the author's 1,150 sessions (58k records): no record lost, no dangling
-  parent that wasn't already dangling, no source path left outside thinking blocks, re-import byte-identical.
-  The same run redacted 200+ credential-shaped strings, so the problem the redactor solves is not hypothetical.
-
-## What is not verified, or not handled
-
-- **`claude --resume` on an imported session** is verified on one real session (900 KB, 418 paths rewritten,
-  Claude Code 2.1.299): resumed from a folder it never ran in, it recalled its first request and reported the new
-  working directory. That is one session on one version. Run `scripts/verify-resume.sh` on yours. The transcript
-  format is internal and undocumented and can change; carry parses tolerantly and carries unknown lines through.
-- **Thinking blocks are signed**, so they are carried verbatim: not path-rewritten, not redacted. If one contains
-  a credential-like string, export **refuses** unless you pass `--strip-thinking` (drop thinking blocks; resume
-  with stripped thinking is untested) or `--allow-thinking-secrets`. `carry push` skips those sessions.
-- **Redaction is pattern-based and best effort.** It will not find a password that looks like a sentence, or a
-  letters-only lower-case `password=correcthorse` (lower-case names need a digit in the value, to avoid mangling
-  code like `token = parseToken(x)`). ALL_CAPS names like `DB_PASSWORD=` are always redacted. Base64 is only
-  caught when it decodes to something the other rules catch. A bundle
-  is not encrypted. Don't commit one to a public repo, and read `carry inspect` before sharing.
-- **Cowork / desktop**: not checked. If it stores sessions somewhere else, it needs its own adapter.
-- **Push re-uploads sessions you pulled** (one file per device, merged on pull), so folder size grows with devices x sessions.
-- **Windows paths** (drive letters, backslashes) are not handled. Folder names longer than ~200 characters may
-  be shortened differently by Claude Code; import warns.
-- **File-history backups** (`~/.claude/file-history`, used for rewind) are not carried.
-- Relative traversal text like `../../Users/x` is tokenised for privacy, so it is cosmetically wrong after import.
-
-## Verify resume yourself
+### Sync through a shared folder
+
+Point both machines at a folder your sync tool already replicates (Dropbox, iCloud, Syncthing, a git tree).
+
+```
+carry push ~/Sync/carry       # this project's sessions -> folder
+carry pull ~/Sync/carry       # other devices' sessions -> this machine
+```
+
+Projects are matched by git remote, not path. Each file has one writer, so there are no sync conflicts.
+
+### Claude Code plugin
 
 ```
-node src/cli.js list --all                       # pick a session with real content
-sh scripts/verify-resume.sh <session-id-prefix>
+/plugin install carry --marketplace harshhh28/agent-carry
 ```
 
-Exports the session, imports it into a throwaway folder, runs `claude -p --resume` there, and deletes both the
-folder and the imported copy. The original is only read. PASS means the answer matches that session's first
-request and names the new folder.
+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
 
-## Adding another agent
+| 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 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`) |
 
-Everything Claude-specific is in four small places: how a project maps to a session folder (`src/paths.js`), how a
-session and its sidecar files are found and read (`src/store.js`), how a transcript line is identified and
-summarised (`src/transcript.js`), and the `AGENT` constant stamped into bundles (`src/bundle.js`). Path rewriting,
-redaction, merging, encryption and folder sync work on parsed JSON and don't care which agent produced it.
-An adapter for Codex would supply those four pieces for its own session format.
+## Limits
 
-## Layout
+- **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.
+- `--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
 
 ```
-src/paths.js      folder-key mangling, claude home
-src/portable.js   path <-> token rewriting (boundary-aware, keys included, thinking skipped)
-src/redact.js     secret patterns
-src/merge.js      uuid union; local lines kept first
-src/store.js      list / read a session and its sidecar files
-src/bundle.js     build, read, import; integrity hash; path-traversal guard
-src/crypto.js     passphrase encryption (scrypt + AES-256-GCM)
-src/sync.js       push / pull over a shared folder
-src/cli.js        carry
+npm test                  # 49 tests, synthetic two-machine setups
+npm run check:real        # read-only round trip of your own ~/.claude sessions
 ```
 
-MIT.
+To add an agent, supply its session-folder mapping (`src/paths.js`), session reader (`src/store.js`), transcript
+record identity (`src/transcript.js`) and the `AGENT` constant (`src/bundle.js`). Path rewriting, redaction,
+merging, encryption and sync are agent-independent. Codex is not implemented yet.
+
+MIT

package/package.json

@@ -1,10 +1,11 @@
 {
   "name": "agent-carry",
-  "version": "0.1.0",
+  "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": {
-    "carry": "src/cli.js"
+    "carry": "src/cli.js",
+    "agent-carry": "src/cli.js"
   },
   "files": [
     "src",

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

@@ -1,7 +1,7 @@
 {
   "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": "agent-carry contributors" },
+  "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 };
+}