pennyrouter 0.3.47 → 0.3.48

package/README.md

@@ -368,3 +368,26 @@ From this repository, without updating the installed Penny command:
 ```sh
 node packages/pennyrouter-cli/bin/penny.js remote /path/to/project
 ```
+
+#### Hand off a terminal conversation
+
+Finish the current turn and exit the local `penny claude` chat. From that same
+project directory, run:
+
+```sh
+penny remote --continue
+```
+
+This selects the most recently saved local Claude session in that project.
+Alternatively, `penny remote --local-session <UUID>` selects an exact session.
+The bridge resumes the original native transcript and places its visible text
+history in the new phone conversation. Tool results and reasoning remain in
+Claude's native context; only visible chat text is mirrored into the phone UI.
+An active local session or an unfinished final turn blocks the handoff.
+
+To return to terminal chat, disconnect the bridge with Ctrl+C and run the
+printed `penny claude --resume <UUID>` command from the same project. The phone
+turns are saved in that original transcript. This is a sequential handoff;
+the interactive terminal and the bridge cannot run the same session together.
+The bridge continues to offer only its current Read/Edit tools, even when the
+original terminal conversation used additional tools.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pennyrouter",
-  "version": "0.3.47",
+  "version": "0.3.48",
   "description": "Install and manage PennyRouter local coding-agent integrations.",
   "homepage": "https://pennyrouter.com",
   "bugs": {

package/standalone/penny-compare

@@ -102,10 +102,10 @@ choose() {
 claude_models=(default opus sonnet haiku fable)
 
 # The current Codex catalog (apps/gateway/pennyrouter/main.py, _CODEX_NATIVE_MODELS), newest
-# first. That tuple also carries three PennyRouter-only aliases (gpt-penny-deepseek/glm/grok)
+# first, without its legacy GPT-5.4 rows. That tuple also carries three PennyRouter-only aliases (gpt-penny-deepseek/glm/grok)
 # that route to other providers entirely; those are left out here since a native Codex pane would
 # reject them, making an "identical model on both sides" comparison impossible.
-codex_models=(default gpt-5.6-sol gpt-5.6-terra gpt-5.6-luna gpt-5.5 gpt-5.4 gpt-5.4-mini)
+codex_models=(default gpt-6.1-sol gpt-6-astra gpt-6-sol gpt-6-luna gpt-5.6-sol gpt-5.6-terra gpt-5.6-luna gpt-5.5)
 
 # OpenCode's configured default is the only portable alias; users can pass a full
 # provider/model id with --model when both panes must use a specific model.

package/standalone/rates.json

@@ -1,6 +1,6 @@
 {
  "source": "bifrost_datasheet",
- "generated_at": "2026-09-29T15:31:58+00:00",
+ "generated_at": "2026-10-04T20:39:28+00:00",
  "order": [
   "input",
   "cache_read",
@@ -1027,6 +1027,25 @@
     ]
    }
   },
+  "gpt-6.1-sol": {
+   "rates": [
+    2e-06,
+    1e-07,
+    2.5e-06,
+    2.5e-06,
+    1e-05
+   ],
+   "above": {
+    "threshold": 272000,
+    "rates": [
+     4e-06,
+     2e-07,
+     5e-06,
+     5e-06,
+     1.5e-05
+    ]
+   }
+  },
   "gpt-daybreak-blue-latest": {
    "rates": [
     4e-06,

package/standalone/remote/rc_local.py

@@ -0,0 +1,110 @@
+"""Locate a completed native Claude transcript for an explicit terminal handoff."""
+
+import json
+import os
+from pathlib import Path
+import re
+import uuid
+
+
+def claude_directory():
+    return Path(os.environ.get("CLAUDE_CONFIG_DIR", str(Path.home() / ".claude"))).expanduser().resolve()
+
+
+def project_directory(config_dir, project):
+    return Path(config_dir) / "projects" / re.sub(r"[^a-zA-Z0-9]", "-", str(Path(project).resolve()))
+
+
+def ensure_inactive(config_dir, session_id):
+    for path in (Path(config_dir) / "sessions").glob("*.json"):
+        try:
+            record = json.loads(path.read_text())
+        except (OSError, ValueError):
+            continue
+        if record.get("sessionId") != session_id:
+            continue
+        pid = record.get("pid")
+        if not isinstance(pid, int) or pid <= 0:
+            continue
+        try:
+            os.kill(pid, 0)
+        except ProcessLookupError:
+            continue
+        except PermissionError:
+            pass
+        raise RuntimeError("This Claude session is still running. Finish its turn and exit the local chat first.")
+
+
+def read_local(project, session_id=None, config_dir=None):
+    config_dir = Path(config_dir or claude_directory()).resolve()
+    folder = project_directory(config_dir, project)
+    if session_id:
+        try:
+            session_id = str(uuid.UUID(session_id))
+        except ValueError:
+            raise RuntimeError("Local session ID must be a UUID.") from None
+        source = folder / (session_id + ".jsonl")
+        if not source.is_file():
+            raise RuntimeError("Local Claude session was not found in this project.")
+    else:
+        files = list(folder.glob("*.jsonl"))
+        if not files:
+            raise RuntimeError("No local Claude conversations were found for this project.")
+        source = max(files, key=lambda p: p.stat().st_mtime_ns)
+        session_id = source.stem
+        try:
+            uuid.UUID(session_id)
+        except ValueError:
+            raise RuntimeError("Latest local transcript has an invalid session ID.") from None
+    ensure_inactive(config_dir, session_id)
+    records = []
+    try:
+        with source.open() as handle:
+            for line in handle:
+                record = json.loads(line)
+                if not record.get("isSidechain"):
+                    records.append(record)
+    except (OSError, ValueError):
+        raise RuntimeError("Cannot read a complete local Claude transcript.") from None
+    messages = [r for r in records if r.get("type") in {"user", "assistant"} and not r.get("isMeta")]
+    if not messages or messages[-1].get("type") != "assistant" or messages[-1].get("message", {}).get("stop_reason") not in {"end_turn", "stop_sequence", "max_tokens"}:
+        raise RuntimeError("The local conversation has no completed final turn. Finish it in Claude before handing it off.")
+    if any(r.get("sessionId") != session_id or Path(r.get("cwd", "")).resolve() != Path(project).resolve() for r in messages):
+        raise RuntimeError("Transcript session or project does not match the requested handoff.")
+    # Follow the last branch; older abandoned branches should not appear on the phone.
+    indexed = {r["uuid"]: r for r in records if r.get("uuid")}
+    current = messages[-1]
+    chain, visited = [], set()
+    while current:
+        record_id = current.get("uuid")
+        if not record_id or record_id in visited:
+            raise RuntimeError("Local transcript contains an invalid message chain.")
+        visited.add(record_id)
+        chain.append(current)
+        current = indexed.get(current.get("parentUuid"))
+    chain.reverse()
+    return {"session_id": session_id, "config_dir": str(config_dir),
+            "model": messages[-1]["message"].get("model"), "records": chain}
+
+
+def phone_history(records, session_id):
+    """Mirror visible text, retaining UUIDs. Native resume keeps the full local context."""
+    for record in records:
+        kind = record.get("type")
+        if kind not in {"user", "assistant"} or record.get("isMeta"):
+            continue
+        message = record.get("message", {})
+        content = message.get("content", [])
+        if isinstance(content, str):
+            text = content
+        else:
+            text = "\n".join(block.get("text", "") for block in content if block.get("type") == "text")
+        if not text.strip():
+            continue
+        clean = {"role": kind, "content": text if kind == "user" else [{"type": "text", "text": text}]}
+        if kind == "assistant":
+            clean.update(id=message.get("id", "msg_" + record["uuid"].replace("-", "")),
+                         type="message", model=message.get("model"), stop_reason="end_turn",
+                         stop_sequence=None, usage={"input_tokens": 0, "output_tokens": 0})
+        yield {"type": kind, "uuid": record["uuid"], "session_id": session_id,
+               "message": clean, "parent_tool_use_id": None}

package/standalone/remote/rc_project.py

@@ -18,13 +18,42 @@ from rc_echo import EchoWorker, read_login
 from rc_penny import read_profile
 from rc_restart import RestartWorker
 from rc_tools import ToolsWorker
+from rc_local import ensure_inactive, phone_history, read_local
 
 
 class ProjectWorker(RestartWorker, ToolsWorker):
-    def __init__(self, client, oauth, profile, model, directory, project):
+    def __init__(self, client, oauth, profile, model, directory, project, local=None):
         super().__init__(client, oauth, profile, model, directory, project)
         self.title = "Penny: " + Path(self.cwd).name
         self.phase = "idle"
+        self.history = []
+        if self.resuming:
+            saved = json.loads(self.state_path.read_text())
+            if saved.get("native_config_dir"):
+                self.extra_state = {"native_config_dir": saved["native_config_dir"],
+                                    "history_synced": saved.get("history_synced", False)}
+                ensure_inactive(saved["native_config_dir"], self.local_session)
+                self.claude.persistence_dir = Path(saved["native_config_dir"])
+                self.claude.resume = True
+                if not self.extra_state["history_synced"]:
+                    local = read_local(project, self.local_session, saved["native_config_dir"])
+        if local:
+            self.local_session = local["session_id"]
+            self.claude.session_id = self.local_session
+            self.claude.persistence_dir = Path(local["config_dir"])
+            self.claude.resume = True
+            self.extra_state = {"native_config_dir": local["config_dir"], "history_synced": False}
+            self.history = list(phone_history(local["records"], self.local_session))
+
+    async def start(self):
+        await super().start()
+        if self.extra_state and not self.extra_state["history_synced"]:
+            for offset in range(0, len(self.history), 20):
+                await self.events(*self.history[offset:offset + 20])
+            self.extra_state["history_synced"] = True
+            self.save("idle")
+        print("Local session: " + self.local_session, flush=True)
+        print("Return to terminal: penny claude --resume " + self.local_session, flush=True)
 
     async def handle(self, envelope):
         event_id = envelope.get("event_id")
@@ -51,7 +80,7 @@ class ProjectWorker(RestartWorker, ToolsWorker):
                 self.inbox.task_done()
 
 
-async def run(project, state_dir, effort):
+async def run(project, state_dir, effort, local_session=None, continue_local=False):
     directory = Path(state_dir).resolve()
     directory.mkdir(mode=0o700, parents=True, exist_ok=True)
     with (directory / "lock").open("w") as lock:
@@ -60,12 +89,23 @@ async def run(project, state_dir, effort):
         except BlockingIOError:
             raise RuntimeError("This remote session is already running.") from None
         profile, model = read_profile()
+        local = None
+        state_path = directory / "bridge.json"
+        if local_session or continue_local:
+            if state_path.exists():
+                raise RuntimeError("Use a fresh state folder for a local session handoff.")
+            local = read_local(project, local_session)
+            model = local["model"] or model
+        elif state_path.exists():
+            saved = json.loads(state_path.read_text())
+            if saved.get("native_config_dir"):
+                model = saved["model"]
         async with httpx.AsyncClient(headers={"anthropic-version": "2023-06-01",
             "User-Agent": "penny-rc-project/0.1"}, timeout=httpx.Timeout(30, read=None), trust_env=False) as client:
             response = await client.get(profile["gateway_base_url"].rstrip("/") + "/health", timeout=5)
             if response.status_code != 200:
                 raise RuntimeError("Configured Penny gateway is not healthy.")
-            worker = ProjectWorker(client, read_login(), profile, model, directory, project)
+            worker = ProjectWorker(client, read_login(), profile, model, directory, project, local)
             worker.claude.effort = effort
             tasks = []
             try:
@@ -90,10 +130,16 @@ def main():
     parser.add_argument("project", nargs="?", default=None, help="Project folder (defaults to current directory)")
     parser.add_argument("--resume", metavar="STATE_FOLDER", help="Resume a saved Penny remote session")
     parser.add_argument("--state-dir", help="State folder for a new session")
+    local_group = parser.add_mutually_exclusive_group()
+    local_group.add_argument("--continue", dest="continue_local", action="store_true",
+                             help="Hand off the latest completed local Claude conversation in this project")
+    local_group.add_argument("--local-session", metavar="UUID", help="Hand off a specific local Claude session")
     parser.add_argument("--effort", choices=["low", "medium", "high"], default="low")
     args = parser.parse_args()
     if args.resume and args.state_dir:
         parser.error("Use --resume or --state-dir, not both.")
+    if args.resume and (args.local_session or args.continue_local):
+        parser.error("Use --resume for a bridge session, or --continue/--local-session for a local handoff.")
     config_root = Path(os.environ.get("XDG_CONFIG_HOME", str(Path.home() / ".config")))
     directory = args.resume or args.state_dir or str(config_root / "pennyrouter/remote" / str(uuid.uuid4()))
     project = args.project
@@ -107,7 +153,8 @@ def main():
         project = project or str(Path.cwd())
         if (Path(directory).expanduser() / "bridge.json").exists():
             parser.error("State folder already contains a session; use --resume.")
-    asyncio.run(run(Path(project).expanduser(), Path(directory).expanduser(), args.effort))
+    asyncio.run(run(Path(project).expanduser(), Path(directory).expanduser(), args.effort,
+                    args.local_session, args.continue_local))
 
 
 if __name__ == "__main__":

package/standalone/remote/rc_restart.py

@@ -20,6 +20,7 @@ from rc_penny import PennyWorker, read_profile
 class RestartWorker(PennyWorker):
     def __init__(self, client, oauth, profile, model, directory, project=None):
         self.directory = Path(directory).resolve()
+        self.extra_state = {}
         self.directory.mkdir(mode=0o700, parents=True, exist_ok=True)
         self.state_path = self.directory / "bridge.json"
         cwd = Path(project).resolve() if project else self.directory / "workspace"
@@ -55,7 +56,7 @@ class RestartWorker(PennyWorker):
         state = {"version": 1, "phase": phase, "remote_session": self.session,
                  "local_session": self.local_session, "model": self.model,
                  "cursor": self.last_event_id, "seen": sorted(self.seen), "replies": self.replies,
-                 "cwd": self.cwd}
+                 "cwd": self.cwd, **self.extra_state}
         temporary = self.state_path.with_suffix(".tmp")
         descriptor = os.open(temporary, os.O_WRONLY | os.O_CREAT | os.O_TRUNC, 0o600)
         with os.fdopen(descriptor, "w") as handle:

package/standalone/web-demo/compare.html

@@ -1271,8 +1271,9 @@
         // ids), so the alias is what is sent; the label names the model it currently resolves to.
         claude: [['opus', 'Claude Opus 5.5'], ['sonnet', 'Claude Sonnet 5.5'], ['haiku', 'Claude Haiku 4.5'],
           ['fable', 'Claude Fable 5.1']],
-        codex: [['gpt-5.6-sol', 'GPT-5.6 Sol'], ['gpt-5.6-terra', 'GPT-5.6 Terra'], ['gpt-5.6-luna', 'GPT-5.6 Luna'],
-          ['gpt-5.5', 'GPT-5.5'], ['gpt-5.4', 'GPT-5.4'], ['gpt-5.4-mini', 'GPT-5.4 mini']],
+        codex: [['gpt-6.1-sol', 'GPT-6.1 Sol'], ['gpt-6-astra', 'GPT-6 Astra'], ['gpt-6-sol', 'GPT-6 Sol'],
+          ['gpt-6-luna', 'GPT-6 Luna'], ['gpt-5.6-sol', 'GPT-5.6 Sol'], ['gpt-5.6-terra', 'GPT-5.6 Terra'],
+          ['gpt-5.6-luna', 'GPT-5.6 Luna'], ['gpt-5.5', 'GPT-5.5']],
       };
       $('left-variant').value = config.defaultHarness;
       $('right-variant').value = `penny-${config.defaultHarness}`;

package/standalone/web-demo/server.mjs

@@ -170,7 +170,8 @@ function validateEnvironment(environment = {}) {
 const safeModel = /^[A-Za-z0-9._/-]{1,160}$/;
 
 async function validateConfig(config) {
-  const codexModels = ['gpt-5.6-sol', 'gpt-5.6-terra', 'gpt-5.6-luna', 'gpt-5.5', 'gpt-5.4', 'gpt-5.4-mini'];
+  const codexModels = ['gpt-6.1-sol', 'gpt-6-astra', 'gpt-6-sol', 'gpt-6-luna', 'gpt-5.6-sol', 'gpt-5.6-terra',
+    'gpt-5.6-luna', 'gpt-5.5'];
   const claudeModels = ['opus', 'sonnet', 'haiku', 'fable'];
   if (!config || !variants.has(config.variant) || typeof config.cwd !== 'string' ||
       config.cwd.length > 4096 || typeof config.label !== 'string' || config.label.length > 80 ||