feat: rename to cowork2code; carry MCP servers over as .mcp.json

- rebrand package/CLI/MCP/launcher to cowork2code (history preserved via git mv)
- rehome now emits a ready-to-use .mcp.json from the session's remote MCP servers
  (never clobbers an existing one); surfaced in CLI + MCP output
- README: headline trimmed; lead with 'what comes across' (conversation, files,
  MCP servers, plugins/skills); document .mcp.json
- 55 tests passing, ruff clean, wheel builds

Author: ebeckner-looptech

README.md

@@ -1,73 +1,72 @@
-# claude-cowork-resume
+# cowork2code
 
-Resume a **Claude Cowork** conversation in **Claude Code** so you can change the model.
+**Resume a Claude Cowork conversation in Claude Code.**
 
 [![License: MIT](https://img.shields.io/badge/License-MIT-informational.svg)](LICENSE)
 [![Python 3.10+](https://img.shields.io/badge/python-3.10%2B-blue.svg)](https://www.python.org/downloads/)
 
-Claude Cowork ("local agent mode") fixes the model for the life of a session — once a
-session starts on, say, `claude-haiku-4-5`, there is no way to switch it to a stronger
-model. `claude-cowork-resume` lifts an existing Cowork conversation into Claude Code,
-where the model is just a runtime flag, so you can continue the exact same thread on
-whatever model you want.
+Claude Cowork ("local agent mode") locks the model for the life of a session. `cowork2code`
+moves an existing Cowork conversation into Claude Code — where the model is just a runtime
+flag — so you pick up the exact same thread on whatever model you want.
 
-It is not a format converter. A Cowork session already stores its conversation as a
-standard Claude Code transcript inside a sandboxed home, so this tool simply re-homes
-that transcript into a real working directory, brings along the working files, and hands
-you the `claude --resume` command.
+## What comes across
 
----
+A Cowork session is a whole working environment, not just a chat log. `cowork2code` carries
+all of it into Claude Code:
 
-## How it works
+- **The full conversation** — re-homed as a native Claude Code session you resume with
+  `claude --resume` and continue on any model.
+- **Every working file** — the session's `outputs/` and `memory/` are copied into your
+  target directory.
+- **The MCP servers** — written to a ready-to-use `.mcp.json` in the target directory, so
+  Claude Code reconnects them automatically.
+- **Plugins, skills, and slash commands** — captured in a `COWORK_SESSION.md` sidecar (with
+  the raw session config) so you can re-enable them in your Claude Code setup.
 
-```
-Claude Cowork session (sandboxed)                Claude Code (your home)
----------------------------------                -----------------------
-local_<id>/                                      ~/.claude/projects/
-  .claude/projects/<dir>/                          <escaped-target-cwd>/
-    <cliSessionId>.jsonl   --- re-home (rewrite cwd) --->  <cliSessionId>.jsonl
-  outputs/                 --- copy ----------------->   <target-cwd>/
-  memory/                  --- copy ----------------->   <target-cwd>/memory/
-local_<id>.json (config)   --- notes ---------------->   <target-cwd>/COWORK_SESSION.md
-```
+The original Cowork session is never modified — the source is read-only.
+
+## Why this works (and isn't a converter)
 
-1. **Locate** the session's embedded transcript (found by globbing the sandbox, never by
-   guessing its folder name).
-2. **Re-home** it to `~/.claude/projects/<escaped-target-cwd>/<id>.jsonl`, rewriting every
-   record's working directory to the target so `claude --resume` finds and loads it.
-3. **Copy** the session's working files (`outputs/`, `memory/`) into the target directory.
-4. **Document** the original configuration (model, system prompt, MCP servers, slash
-   commands) in a `COWORK_SESSION.md` sidecar for reference.
-5. **Print** the exact resume command (or launch it for you).
+A Cowork session already stores its conversation as a standard Claude Code transcript inside
+a sandboxed home. `cowork2code` does not translate any format — it re-homes that transcript
+into a real working directory, rewrites the recorded paths, brings the rest of the
+environment along, and hands you the `claude --resume` command.
 
----
+```
+Claude Cowork session (sandboxed)            Claude Code (your home)
+---------------------------------            -----------------------
+local_<id>/
+  .claude/projects/<dir>/<id>.jsonl  --re-home-->  ~/.claude/projects/<escaped-cwd>/<id>.jsonl
+  outputs/                           --copy----->  <target>/
+  memory/                            --copy----->  <target>/memory/
+local_<id>.json (config)             --MCP------>  <target>/.mcp.json
+                                     --notes---->  <target>/COWORK_SESSION.md
+```
 
 ## Installation
 
 ```console
-$ git clone https://github.com/looptech-ai/claude-cowork-resume.git
-$ cd claude-cowork-resume
+$ git clone https://github.com/looptech-ai/cowork2code.git
+$ cd cowork2code
 $ ./install.sh
 ```
 
-`install.sh` puts the `cowork-resume` command on your `PATH` (`~/.local/bin`) and registers
-a local MCP server with Claude Code so an agent can perform the migration for you.
+`install.sh` puts the `cowork2code` command on your `PATH` (`~/.local/bin`) and registers a
+local MCP server with Claude Code so an agent can perform the migration for you.
 
 Requirements: `python3` >= 3.10 (the CLI core is standard-library only) and, for the MCP
 server, [`uv`](https://docs.astral.sh/uv/) — which resolves the single `mcp` dependency on
 demand, with no global install.
 
 Prefer a packaged install? `uv tool install .` or `pipx install .` both expose the same
-`cowork-resume` command via the project's entry point.
-
----
+`cowork2code` command via the project's entry point.
 
 ## Usage
 
 ### List your Cowork sessions
 
 ```console
-$ cowork-resume list
+$ cowork2code list
 2026-06-12 09:41  claude-haiku-4-5-20251001     Research: emerging LLM productivity trends        id=local_e51809de-...
 2026-06-11 16:02  claude-sonnet-4-6             Draft quarterly board update                      id=local_7a2c91b4-...
 2026-06-10 08:55  claude-opus-4-8[1m]           Refactor ingestion pipeline                       id=local_3c4d77af-...
@@ -78,11 +77,12 @@ Add `--all` to include archived sessions, or `--json` for machine-readable outpu
 ### Re-home a session and get the resume command
 
 ```console
-$ cowork-resume rehome --title "emerging" --into ~/dev/llm-trends-resume
+$ cowork2code rehome --title "emerging" --into ~/dev/llm-trends-resume
 Session: Research: emerging LLM productivity trends  (claude-haiku-4-5-20251001 -> opus-4-8[1m])
 Target cwd:  /Users/you/dev/llm-trends-resume
 Transcript:  /Users/you/.claude/projects/-Users-you-dev-llm-trends-resume/a1803cbc-....jsonl
 Copied 3 file(s); notes: /Users/you/dev/llm-trends-resume/COWORK_SESSION.md
+MCP servers -> /Users/you/dev/llm-trends-resume/.mcp.json
 
 cd /Users/you/dev/llm-trends-resume && claude --resume a1803cbc-... --model 'opus-4-8[1m]'
 ```
@@ -98,28 +98,26 @@ $ cd ~/dev/llm-trends-resume && claude --resume a1803cbc-... --model 'opus-4-8[1
 
 ```console
 # Resume in the directory the conversation originated from (no --into):
-$ cowork-resume rehome --id a1803cbc-... --original
+$ cowork2code rehome --id a1803cbc-... --original
 
 # Preview without writing anything:
-$ cowork-resume rehome --title "emerging" --into ~/tmp/x --dry-run
+$ cowork2code rehome --title "emerging" --into ~/tmp/x --dry-run
 
 # Re-home and launch Claude Code immediately on a chosen model:
-$ cowork-resume rehome --title "emerging" --into ~/tmp/x --model opus-4-8 --launch
+$ cowork2code rehome --title "emerging" --into ~/tmp/x --model opus-4-8 --launch
 
 # Point at a specific session folder instead of searching:
-$ cowork-resume rehome --from "~/Library/Application Support/Claude/local-agent-mode-sessions/<acct>/<wks>/local_<id>" --into ~/tmp/x
+$ cowork2code rehome --from "~/Library/Application Support/Claude/local-agent-mode-sessions/<acct>/<wks>/local_<id>" --into ~/tmp/x
 ```
 
 Selectors (`--title`, `--id`, `--from`) are mutually exclusive, and so are the targets
 (`--into`, `--original`); supply exactly one of each. The default launch model is
 `opus-4-8[1m]`. If a title is ambiguous, the tool lists the matches and exits so you can
 refine the selector or use `--id`.
 
----
-
 ## MCP usage
 
-After `install.sh`, Claude Code exposes a `cowork-resume` MCP server with two tools:
+After `install.sh`, Claude Code exposes a `cowork2code` MCP server with two tools:
 
 | Tool | Purpose |
 | --- | --- |
@@ -135,38 +133,33 @@ the agent calls these tools and reports back the resume command.
 > directory, so registering this server inside Cowork may not work even though registering
 > it in Claude Code does.
 
----
-
-## What gets created
-
-In the target directory:
+## What gets created in the target directory
 
-- `COWORK_SESSION.md` — informational notes describing the original session (model, system
-  prompt, MCP servers, slash commands, initial message). These are **not** applied to the
-  resumed session.
+- The session's `outputs/` and `memory/` files.
+- `.mcp.json` — the session's remote MCP servers, ready for Claude Code to reconnect (never
+  overwrites an existing `.mcp.json`).
+- `COWORK_SESSION.md` — notes describing the original session (model, system prompt, MCP
+  servers, slash commands, initial message). Informational; not auto-applied.
 - `cowork-session-config.json` — the raw original session configuration.
-- Any `outputs/` and `memory/` files from the original session.
 
-In `~/.claude/projects/<escaped-target-cwd>/` the re-homed transcript, named for its
+The re-homed transcript lands in `~/.claude/projects/<escaped-target-cwd>/`, named for its
 session id, so `claude --resume <id>` loads it from the target directory.
 
----
-
 ## Design notes and limits
 
 - **Source is read-only.** Nothing under the Cowork sessions directory is modified, moved,
-  or deleted. The tool only ever reads it.
+  or deleted.
 - **Project-directory naming** follows Claude Code's exact scheme (each non-alphanumeric
   byte becomes `-`), verified against real `~/.claude/projects` directories.
 - **No clobbering.** If a transcript already exists at the target, the tool stops; use
-  `--new-id` to mint a fresh session id or `--force` to overwrite.
+  `--new-id` to mint a fresh session id or `--force` to overwrite. An existing `.mcp.json`
+  is never overwritten.
+- **Symlinks** in the session's working files are skipped, not followed.
 - **Sensitive content.** The notes and config sidecars copy the original system prompt and
   MCP server list. Review them before sharing the target directory.
 - **Platform.** macOS in this release. The sessions root is configurable with
   `--sessions-root`, so other layouts can be added without code changes elsewhere.
 
----
-
 ## Development
 
 ```console
@@ -179,20 +172,18 @@ and never touches your real Claude data.
 Project layout:
 
 ```
-cowork_resume/
+cowork2code/
   paths.py        project-directory escaping and path resolution
   transcript.py   locate, rewrite, and write transcript JSONL
   discover.py     scan the sessions root and resolve selectors
   notes.py        render the configuration-notes sidecar
   rehome.py       plan and execute a re-home
-  cli.py          the cowork-resume command
+  cli.py          the cowork2code command
   mcp_server.py   the local MCP server
-cowork_mcp.py     zero-install uv launcher for the MCP server
-install.sh        install the CLI and register the MCP server
+cowork2code_mcp.py  zero-install uv launcher for the MCP server
+install.sh          install the CLI and register the MCP server
 ```
 
----
-
 ## License
 
 [MIT](LICENSE) (c) LoopTech.

bin/cowork-resume bin/cowork2codebin/cowork-resume renamed to bin/cowork2code

@@ -3,4 +3,4 @@
 # install.sh writes an equivalent copy to ~/.local/bin with the repo path baked in.
 REPO="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
 export PYTHONPATH="${REPO}:${PYTHONPATH:-}"
-exec python3 -m cowork_resume.cli "$@"
+exec python3 -m cowork2code.cli "$@"

cowork2code/__init__.py

@@ -0,0 +1,3 @@
+"""cowork2code: re-home a Claude Cowork session into a resumable Claude Code session."""
+
+__version__ = "0.1.0"

cowork_resume/cli.py cowork2code/cli.pycowork_resume/cli.py renamed to cowork2code/cli.py

@@ -1,4 +1,4 @@
-"""Command-line frontend for claude-cowork-resume."""
+"""Command-line frontend for cowork2code."""
 
 import argparse
 import datetime
@@ -19,7 +19,7 @@ def _fmt_ts(ms: int | None) -> str:
 
 def _build_parser() -> argparse.ArgumentParser:
     parser = argparse.ArgumentParser(
-        prog="cowork-resume",
+        prog="cowork2code",
         description="Resume a Claude Cowork session in Claude Code so you can change the model.",
     )
     sub = parser.add_subparsers(dest="cmd", required=True)
@@ -103,6 +103,8 @@ def _cmd_rehome(args) -> int:
     print(f"{tag}Target cwd:  {plan.target_cwd}")
     print(f"{tag}Transcript:  {plan.transcript_dest}")
     print(f"{tag}Copied {len(plan.copied)} file(s); notes: {plan.notes_path}")
+    if plan.mcp_config_path:
+        print(f"{tag}MCP servers -> {plan.mcp_config_path}")
     for warning in plan.warnings:
         print(f"{tag}warn: {warning}")
     print()

cowork_resume/discover.py cowork2code/discover.pycowork_resume/discover.py renamed to cowork2code/discover.py

@@ -1,4 +1,4 @@
-"""Local MCP server exposing cowork-resume operations as tools.
+"""Local MCP server exposing cowork2code operations as tools.
 
 The module-level handlers import only the standard library and the local core
 package, so they are importable for tests even when ``mcp`` is not installed.
@@ -66,6 +66,7 @@ def rehome_session(
         "resume_command": plan.resume_command,
         "copied": plan.copied,
         "notes_path": str(plan.notes_path) if plan.notes_path else None,
+        "mcp_config_path": str(plan.mcp_config_path) if plan.mcp_config_path else None,
         "warnings": plan.warnings,
         "dry_run": dry_run,
     }
@@ -75,7 +76,7 @@ def main() -> None:
     """Run the stdio MCP server (requires the optional ``mcp`` dependency)."""
     from mcp.server.fastmcp import FastMCP
 
-    server = FastMCP("cowork-resume")
+    server = FastMCP("cowork2code")
 
     @server.tool()
     def cowork_session_list(

cowork_resume/mcp_server.py cowork2code/mcp_server.pycowork_resume/mcp_server.py renamed to cowork2code/mcp_server.py

@@ -26,6 +26,7 @@ class RehomePlan:
     copied: list[str] = field(default_factory=list)
     notes_path: Path | None = None
     config_copy_path: Path | None = None
+    mcp_config_path: Path | None = None
     resume_command: str = ""
     warnings: list[str] = field(default_factory=list)
 
@@ -34,6 +35,20 @@ def _new_session_id() -> str:
     return str(uuid.uuid4())
 
 
+def _mcp_servers_from_config(cfg: dict) -> dict:
+    """Build a Claude Code ``.mcp.json`` server map from the Cowork session config.
+
+    Only the session's remote (URL-based) MCP servers can be carried over directly;
+    they are emitted so Claude Code reconnects them from the target directory.
+    """
+    servers: dict[str, dict] = {}
+    for server in cfg.get("remoteMcpServersConfig") or []:
+        name, url = server.get("name"), server.get("url")
+        if name and url:
+            servers[name] = {"type": "http", "url": url}
+    return servers
+
+
 def build_plan(
     ref: SessionRef,
     *,
@@ -131,10 +146,24 @@ def execute_plan(
     if not dry_run:
         tx.write_transcript(records, plan.transcript_dest)
 
+    cfg = json.loads(ref.config_path.read_text(encoding="utf-8"))
     plan.notes_path = target / "COWORK_SESSION.md"
     plan.config_copy_path = target / "cowork-session-config.json"
+
+    # Carry the session's remote MCP servers over as a ready-to-use .mcp.json so
+    # Claude Code reconnects them. Never clobber an existing project .mcp.json.
+    mcp_servers = _mcp_servers_from_config(cfg)
+    mcp_path = target / ".mcp.json"
+    if mcp_servers and mcp_path.exists():
+        plan.warnings.append("skip existing .mcp.json")
+    elif mcp_servers:
+        plan.mcp_config_path = mcp_path
+
     if not dry_run:
-        cfg = json.loads(ref.config_path.read_text(encoding="utf-8"))
         plan.notes_path.write_text(render_notes(cfg), encoding="utf-8")
         plan.config_copy_path.write_text(json.dumps(cfg, indent=2), encoding="utf-8")
+        if plan.mcp_config_path:
+            plan.mcp_config_path.write_text(
+                json.dumps({"mcpServers": mcp_servers}, indent=2), encoding="utf-8"
+            )
     return plan