pennyrouter 0.3.51 → 0.3.53

package/standalone/web-demo/server.mjs

@@ -9,11 +9,12 @@ import { promisify } from 'node:util';
 import { WebSocketServer } from 'ws';
 import pty from 'node-pty';
 import { ClaudeMeter, CodexMeter, galleryReport, pricingProfiles, saveReport } from './claude-meter.mjs';
-import { publishToGallery } from './gallery-submit.mjs';
+import { publishToGallery, sendFeedback } from './gallery-submit.mjs';
 import { applyPaneOptions, describePaneOptions, normalizePaneOptions } from './pane-options.mjs';
 import { listArtifacts, readArtifact } from './artifacts.mjs';
 import { readTelemetry, telemetryEnv, telemetryRoute } from './telemetry.mjs';
 import { Readable } from 'node:stream';
+import { bundleTranscripts, maxTranscriptBytes, transcriptBytes } from './session-transcripts.mjs';
 
 const here = dirname(fileURLToPath(import.meta.url));
 const compareDir = dirname(here);
@@ -46,6 +47,8 @@ const artifactSessions = new Map();
 const telemetryMeters = new Map();
 // Finished comparisons that may still be published, by one-time publish token.
 const publishable = new Map();
+// Each finished comparison's session transcript files, by the same token as its report.
+const sessionTranscripts = new Map();
 const publishWindowMs = 60 * 60_000;
 // `npm start` runs from this package's folder; INIT_CWD is where it was invoked.
 const launchDirectory = process.env.INIT_CWD || process.cwd();
@@ -67,6 +70,10 @@ const server = createServer(async (request, response) => {
     await submitToGallery(request, response);
     return;
   }
+  if (url.pathname === '/feedback/submit') {
+    await submitFeedback(request, response);
+    return;
+  }
   const telemetryMeter = telemetryMeters.get(url.pathname);
   if (telemetryMeter && request.method === 'POST') {
     try {
@@ -128,14 +135,56 @@ async function submitToGallery(request, response) {
     const form = await new Request('http://localhost/gallery/submit', { method: 'POST',
       headers: { 'content-type': request.headers['content-type'] || '' },
       body: Readable.toWeb(request), duplex: 'half' }).formData();
+    await attachSessionTranscripts(form, token);
     const result = await publishToGallery(report, form);
     publishable.delete(token);
+    sessionTranscripts.delete(token);
     reply(201, result);
   } catch (error) {
     reply(400, { error: error.message || 'Could not publish to the gallery.' });
   }
 }
 
+// When the submitter ticked "include transcripts", the page sends no file: the server bundles the
+// two sessions it launched.
+async function attachSessionTranscripts(form, token) {
+  if (form.get('include_transcript') !== '1') return;
+  const bundle = await bundleTranscripts(sessionTranscripts.get(token) ?? []);
+  if (!bundle) throw new Error('No session transcripts were found to include.');
+  if (bundle.size > maxTranscriptBytes) throw new Error('The session transcripts are over 10 MB.');
+  form.set('transcript', bundle, 'transcripts.jsonl');
+}
+
+async function submitFeedback(request, response) {
+  const reply = (status, body) => response.writeHead(status, { 'Content-Type': 'application/json',
+    'Cache-Control': 'no-store' }).end(JSON.stringify(body));
+  const allowedOrigins = new Set([`http://127.0.0.1:${port}`, `http://localhost:${port}`]);
+  if (request.method !== 'POST' || !allowedOrigins.has(request.headers.origin)) {
+    reply(403, { error: 'Could not send the comment.' });
+    return;
+  }
+  try {
+    const chunks = [];
+    let size = 0;
+    for await (const chunk of request) {
+      size += chunk.length;
+      if (size > 11 * 1024 * 1024) { reply(413, { error: 'The submission is too large.' }); return; }
+      chunks.push(chunk);
+    }
+    const form = await new Request('http://localhost/feedback/submit', { method: 'POST',
+      headers: { 'content-type': request.headers['content-type'] || '' },
+      body: Buffer.concat(chunks), duplex: 'half' }).formData();
+    const comment = form.get('comment');
+    if (typeof comment !== 'string' || !comment.trim()) { reply(400, { error: 'Write a comment first.' }); return; }
+    const token = request.headers.authorization?.replace(/^Bearer /, '');
+    const report = publishable.get(token) ?? '';
+    await attachSessionTranscripts(form, token);
+    reply(201, await sendFeedback(comment.trim(), report, form.get('transcript')));
+  } catch (error) {
+    reply(400, { error: error.message || 'Could not send the comment.' });
+  }
+}
+
 const wss = new WebSocketServer({ noServer: true, maxPayload: 64 * 1024 });
 server.on('upgrade', (request, socket, head) => {
   const allowedOrigins = new Set([`http://127.0.0.1:${port}`, `http://localhost:${port}`]);
@@ -267,6 +316,39 @@ wss.on('connection', (ws) => {
     sessions.clear();
     if (meterTimer) clearInterval(meterTimer);
   };
+  let finishing = null;
+  // Reports the comparison once and stops its panes; resolves false when no report could be made.
+  const finishSession = () => finishing ??= (async () => {
+    try {
+      // Telemetry is exported every second; let the last batch land before closing the books.
+      if (telemetryRoutesBySide.size) await new Promise((done) => setTimeout(done, 1500));
+      await pollMeters();
+      for (const meter of meters.values()) meter.chargeSideCalls({ final: true });
+      const left = meters.get('left');
+      const right = meters.get('right');
+      if (!left || !right) throw new Error('Both compare panes must start before a report can be saved.');
+      const report = galleryReport(left, right, { environment, harnessVersions: await harnessVersions });
+      const publishToken = report ? randomUUID() : null;
+      if (publishToken) {
+        publishable.set(publishToken, report);
+        const transcripts = [left, right].map((meter) => ({ role: meter.role, harness: meter.snapshot().harness,
+          files: meter.transcriptFiles }));
+        sessionTranscripts.set(publishToken, transcripts);
+        setTimeout(() => { publishable.delete(publishToken); sessionTranscripts.delete(publishToken); },
+          publishWindowMs).unref();
+      }
+      send({ type: 'report', ...await saveReport(left, right, join(compareDir, 'reports'), environment),
+        gallery: publishToken ? { publishToken, transcriptBytes: await transcriptBytes(sessionTranscripts.get(publishToken)) } : null });
+      if (meterTimer) clearInterval(meterTimer);
+      for (const session of sessions.values()) {
+        try { session.kill(); } catch { /* already exited */ }
+      }
+      return true;
+    } catch (error) {
+      send({ type: 'report-error', error: error.message });
+      return false;
+    }
+  })();
   const handle = async (raw) => {
     let message;
     try { message = JSON.parse(raw); } catch { return; }
@@ -294,30 +376,16 @@ wss.on('connection', (ws) => {
       }
       return;
     }
+    // "finish" freezes the comparison and reports it while the panes' transcripts stay on disk, so a
+    // Gallery submission or comment can still read them; "exit" then ends the server-side session.
+    if (message.type === 'finish') {
+      if (compare && !await finishSession()) { dispose(); ws.close(); }
+      return;
+    }
     if (message.type === 'exit') {
       if (exiting) return;
       exiting = true;
-      if (compare) {
-        try {
-          // Telemetry is exported every second; let the last batch land before closing the books.
-          if (telemetryRoutesBySide.size) await new Promise((done) => setTimeout(done, 1500));
-          await pollMeters();
-          for (const meter of meters.values()) meter.chargeSideCalls({ final: true });
-          const left = meters.get('left');
-          const right = meters.get('right');
-          if (!left || !right) throw new Error('Both compare panes must start before a report can be saved.');
-          const report = galleryReport(left, right, { environment, harnessVersions: await harnessVersions });
-          const publishToken = report ? randomUUID() : null;
-          if (publishToken) {
-            publishable.set(publishToken, report);
-            setTimeout(() => publishable.delete(publishToken), publishWindowMs).unref();
-          }
-          send({ type: 'report', ...await saveReport(left, right, join(compareDir, 'reports'), environment),
-            gallery: publishToken ? { publishToken } : null });
-        } catch (error) {
-          send({ type: 'report-error', error: error.message });
-        }
-      }
+      if (compare && !await finishSession()) { /* the error was already reported */ }
       dispose();
       ws.close();
       return;

package/standalone/web-demo/session-transcripts.mjs

@@ -0,0 +1,37 @@
+import { readFile, stat } from 'node:fs/promises';
+
+// The Gallery stores one transcript per submission. A finished comparison has two sessions, so
+// they travel as a single JSONL file: a header line naming each session, then that session's
+// own lines unchanged (the root transcript first, then any subagent or child transcripts).
+export const maxTranscriptBytes = 10 * 1024 * 1024;
+
+const header = (role, harness, file) => `${JSON.stringify({ penny_compare_session: role, harness, file })}\n`;
+
+async function sessionParts({ role, harness, files }) {
+  const parts = [];
+  for (const [index, path] of files.entries()) {
+    let text;
+    try { text = await readFile(path, 'utf8'); } catch { continue; }
+    if (!text) continue;
+    parts.push(header(role, harness, index === 0 ? 'root' : 'child'), text.endsWith('\n') ? text : `${text}\n`);
+  }
+  return parts;
+}
+
+/** The two sessions' transcripts as one JSONL blob, or null when neither left a readable file. */
+export async function bundleTranscripts(sessions) {
+  const parts = (await Promise.all(sessions.map(sessionParts))).flat();
+  return parts.length ? new Blob(parts, { type: 'application/x-ndjson' }) : null;
+}
+
+/** Bytes the bundle will occupy, without reading the files (a file with no final newline gains one). */
+export async function transcriptBytes(sessions) {
+  let total = 0;
+  for (const { role, harness, files } of sessions) {
+    for (const [index, path] of files.entries()) {
+      const info = await stat(path).catch(() => null);
+      if (info?.size) total += info.size + Buffer.byteLength(header(role, harness, index === 0 ? 'root' : 'child'));
+    }
+  }
+  return total;
+}

package/standalone/remote/rc_echo.py

@@ -1,298 +0,0 @@
-"""Experimental, text-only worker for Anthropic's captured Remote Control protocol.
-
-No inference, tools, shell execution, or gateway changes. Uses a fresh session and
-the current user's full-scope Claude login; credentials remain in memory. This is
-an undocumented protocol probe, not supported native Claude Code integration.
-"""
-
-from __future__ import annotations
-
-import argparse
-import asyncio
-import json
-import os
-from pathlib import Path
-import subprocess
-import sys
-import time
-import uuid
-
-import httpx
-
-BASE = "https://api.anthropic.com"
-MODEL = "claude-sonnet-5-5"
-REPLY = "Penny echo bridge received your phone message. No model or tools were used."
-
-
-def read_login() -> str:
-    """Read an existing login without refreshing or persisting credentials."""
-    credentials = Path(os.environ.get("CLAUDE_CONFIG_DIR", str(Path.home() / ".claude"))) / ".credentials.json"
-    if credentials.exists():
-        data = json.loads(credentials.read_text())
-    elif sys.platform == "darwin":
-        result = subprocess.run(
-            ["security", "find-generic-password", "-s", "Claude Code-credentials", "-w"],
-            capture_output=True, text=True, check=False,
-        )
-        if result.returncode:
-            raise RuntimeError("Cannot read Claude login. Sign in with Claude Code /login first.")
-        data = json.loads(result.stdout)
-    else:
-        raise RuntimeError("No Claude login found. Sign in with Claude Code /login first.")
-    oauth = data.get("claudeAiOauth", {})
-    if oauth.get("expiresAt", 0) < (time.time() + 600) * 1000:
-        raise RuntimeError("Claude login expires too soon. Refresh it through Claude Code /login.")
-    token = oauth.get("accessToken", "")
-    if not token.startswith("sk-ant-oat"):
-        raise RuntimeError("A Claude subscription OAuth login is required.")
-    return token
-
-
-class EchoWorker:
-    def __init__(self, client: httpx.AsyncClient, oauth: str):
-        self.client = client
-        self.oauth = oauth
-        self.worker_token = ""
-        self.session = ""
-        self.local_session = str(uuid.uuid4())
-        self.epoch = 0
-        self.seen: set[str] = set()
-        self.stopping = False
-        self.replies = 0
-        self.title = "Penny echo bridge test"
-        self.model = MODEL
-        self.tools = []
-        self.cwd = "/private/tmp"
-        self.last_event_id = ""
-        self.force_reconnect = asyncio.Event()
-        self.stream_connections = 0
-
-    async def api(self, method: str, path: str, body=None, *, account=False):
-        # Retry only the worker operations, not account-level session creation.
-        # Event bodies keep their original UUIDs across retries for server deduplication.
-        for attempt in range(5):
-            try:
-                response = await self.client.request(method, BASE + path,
-                    headers={"Authorization": "Bearer " + (self.oauth if account else self.worker_token)},
-                    timeout=30,
-                    **({"json": body} if body is not None else {}))
-            except httpx.TransportError:
-                if account or attempt == 4:
-                    raise
-            else:
-                if account or response.status_code not in {429, 500, 502, 503, 504} or attempt == 4:
-                    break
-            await asyncio.sleep(min(2 ** attempt, 8))
-        if not response.is_success:
-            # Never include raw bodies/headers: private API errors may contain credentials.
-            raise RuntimeError(f"{method} {path.rsplit('/', 1)[-1]} returned HTTP {response.status_code}")
-        return response.json() if response.content else {}
-
-    @property
-    def path(self):
-        return f"/v1/code/sessions/{self.session}"
-
-    def payload(self, kind, **fields):
-        return {"type": kind, "session_id": self.local_session, "uuid": str(uuid.uuid4()), **fields}
-
-    async def events(self, *payloads):
-        result = await self.api("POST", self.path + "/worker/events", {
-            "worker_epoch": self.epoch, "events": [{"payload": p} for p in payloads]})
-        print(f"Published {','.join(p['type'] for p in payloads)}; subscribers={result.get('has_subscribers')}", flush=True)
-
-    async def delivery(self, event_id, status):
-        await self.api("POST", self.path + "/worker/events/delivery", {
-            "worker_epoch": self.epoch, "updates": [{"event_id": event_id, "status": status}]})
-
-    async def status(self, status):
-        await self.api("PUT", self.path + "/worker", {
-            "worker_epoch": self.epoch, "worker_status": status,
-            "requires_action_details": None})
-
-    async def start(self):
-        result = await self.api("POST", "/v1/code/sessions", {
-            "title": self.title, "bridge": {}, "tags": ["remote-control-repl", "penny-echo-probe"],
-            "config": {"cwd": self.cwd, "model": self.model, "sources": [], "outcomes": [],
-                       "reuse_outcome_branches": False}}, account=True)
-        self.session = result["session"]["id"]
-        bridge = await self.api("POST", self.path + "/bridge", {}, account=True)
-        if bridge["api_base_url"].rstrip("/") != BASE:
-            raise RuntimeError("Unexpected worker host; refusing to forward credentials.")
-        self.worker_token = bridge["worker_jwt"]
-        self.epoch = int(bridge["worker_epoch"])
-        await self.api("GET", self.path + "/worker")
-        await self.api("PUT", self.path + "/worker", {
-            "worker_epoch": self.epoch, "external_metadata": {"permission_mode": "default", "model": self.model}})
-        await self.status("idle")
-        await self.events(self.payload("system", subtype="init", cwd=self.cwd, tools=self.tools,
-            mcp_servers=[], model=self.model, permissionMode="default", apiKeySource="none",
-            output_style="default", agents=[], skills=[], plugins=[], slash_commands=[],
-            terminal_slash_commands=[], capabilities=[], analytics_disabled=True,
-            product_feedback_disabled=True))
-        print(f"OPEN https://claude.ai/code/{self.session}", flush=True)
-
-    async def handle(self, envelope):
-        event_id = envelope.get("event_id")
-        if not event_id or event_id in self.seen:
-            return
-        payload = envelope.get("payload", {})
-        kind = payload.get("type")
-        await self.delivery(event_id, "received")
-        print(f"Received {kind}" + (f"/{payload.get('request', {}).get('subtype')}" if kind == "control_request" else ""), flush=True)
-        if kind == "control_request":
-            request = payload.get("request", {})
-            subtype = request.get("subtype")
-            response = {"request_id": payload.get("request_id"), "subtype": "success"}
-            if subtype == "initialize":
-                response["response"] = {"commands": [], "agents": [], "output_style": "normal",
-                    "available_output_styles": ["normal"], "models": [], "account": {},
-                    "pid": os.getpid(), "inbound_read_receipts": True,
-                    "current_model": self.model, "current_permission_mode": "default"}
-                response.update(pending_permission_requests=list(getattr(self, "pending_permissions", {}).values()),
-                                pending_user_dialog_requests=[])
-            elif subtype == "end_session":
-                response["response"] = {}
-                self.stopping = True
-            else:
-                response.update(subtype="error", error="Echo probe supports only text messages and initialization.")
-            await self.events(self.payload("control_response", response=response))
-        elif kind == "user":
-            await self.delivery(event_id, "processing")
-            await self.status("running")
-            # Client-origin messages already exist in the remote transcript. Posting
-            # them again with a worker UUID creates a second visible input bubble.
-            await self.answer(payload)
-            await self.status("idle")
-            self.replies += 1
-        else:
-            raise RuntimeError("Unexpected inbound event type; stopping the echo probe.")
-        await self.delivery(event_id, "processed")
-        self.seen.add(event_id)
-
-    async def answer(self, payload):
-        message = {"id": "msg_" + uuid.uuid4().hex, "type": "message", "role": "assistant",
-                   "model": MODEL, "content": [], "stop_reason": None,
-                   "stop_sequence": None, "usage": {"input_tokens": 0, "output_tokens": 0}}
-        stream = [{"type": "message_start", "message": message},
-            {"type": "content_block_start", "index": 0, "content_block": {"type": "text", "text": ""}},
-            {"type": "content_block_delta", "index": 0, "delta": {"type": "text_delta", "text": REPLY}},
-            {"type": "content_block_stop", "index": 0},
-            {"type": "message_delta", "delta": {"stop_reason": "end_turn", "stop_sequence": None},
-             "usage": {"output_tokens": 0}}, {"type": "message_stop"}]
-        await self.events(*(self.payload("stream_event", event=e, parent_tool_use_id=None) for e in stream))
-        await self.events(self.payload("assistant", parent_tool_use_id=None,
-            message={**message, "content": [{"type": "text", "text": REPLY}], "stop_reason": "end_turn"}),
-            self.payload("result", subtype="success", result=REPLY, is_error=False,
-                user_message_uuid=payload.get("uuid"), duration_ms=0, duration_api_ms=0,
-                total_cost_usd=0, usage={"input_tokens": 0, "output_tokens": 0}, modelUsage={},
-                permission_denials=[], num_turns=1, stop_reason="end_turn", terminal_reason="completed"))
-
-    async def heartbeat(self):
-        while not self.stopping:
-            result = await self.api("POST", self.path + "/worker/heartbeat", {
-                "session_id": self.session, "worker_epoch": self.epoch,
-                "supports_heartbeat_probe": False, "current_interval_seconds": 20, "idle_seconds": 0})
-            await asyncio.sleep(max(5, min(60, result.get("heartbeat_interval_seconds", 20))))
-
-    async def _listen_once(self):
-        headers = {"Authorization": "Bearer " + self.worker_token, "Accept": "text/event-stream"}
-        if self.last_event_id:
-            headers["Last-Event-ID"] = self.last_event_id
-        async with self.client.stream("GET", BASE + self.path + "/worker/events/stream",
-            headers=headers) as response:
-            if response.status_code != 200:
-                if response.status_code in {429, 500, 502, 503, 504}:
-                    raise httpx.ReadError("Transient worker stream failure")
-                raise RuntimeError(f"Worker stream returned HTTP {response.status_code}")
-            self.stream_connections += 1
-            print(f"Worker stream connected #{self.stream_connections}; resuming={bool(self.last_event_id)}", flush=True)
-            data = []
-            frame_id = ""
-            async for line in response.aiter_lines():
-                if line.startswith("data:"):
-                    data.append(line[5:].lstrip())
-                elif line.startswith("id:"):
-                    frame_id = line[3:].strip()
-                elif not line and data:
-                    await self.handle(json.loads("\n".join(data)))
-                    if frame_id:
-                        self.last_event_id = frame_id
-                    data = []
-                    frame_id = ""
-                    if self.stopping:
-                        return
-
-    async def listen(self):
-        failures = 0
-        while not self.stopping:
-            reader = asyncio.create_task(self._listen_once())
-            forced = asyncio.create_task(self.force_reconnect.wait())
-            cursor_before = self.last_event_id
-            try:
-                done, _ = await asyncio.wait([reader, forced], return_when=asyncio.FIRST_COMPLETED)
-                if forced in done:
-                    self.force_reconnect.clear()
-                    print("Simulating a three-second worker stream drop; keeping Claude alive", flush=True)
-                else:
-                    try:
-                        reader.result()
-                    except httpx.TransportError:
-                        pass
-                    if self.stopping:
-                        return
-                failures = 1 if self.last_event_id != cursor_before else failures + 1
-                if failures >= 5:
-                    raise RuntimeError("Worker stream reconnect attempts exhausted.")
-            finally:
-                reader.cancel()
-                forced.cancel()
-                await asyncio.gather(reader, forced, return_exceptions=True)
-            await asyncio.sleep(3 if forced in done else min(2 ** (failures - 1), 8))
-
-    async def close(self):
-        self.stopping = True
-        if not self.session:
-            return
-        try:
-            if self.worker_token:
-                await self.api("PUT", self.path + "/worker", {
-                    "worker_epoch": self.epoch, "connection_status": "disconnected"})
-        except (RuntimeError, httpx.HTTPError):
-            print("Worker disconnect update failed; attempting to archive the test session.", flush=True)
-        try:
-            await self.api("POST", self.path + "/archive", {}, account=True)
-            print(f"Archived test session; replies={self.replies}", flush=True)
-        except (RuntimeError, httpx.HTTPError):
-            print("Test session cleanup failed; archive Penny echo bridge test in Claude manually.", flush=True)
-        self.oauth = self.worker_token = ""
-
-
-async def run(seconds):
-    async with httpx.AsyncClient(headers={"anthropic-version": "2023-06-01",
-        "User-Agent": "penny-rc-echo-probe/0.1"}, timeout=httpx.Timeout(30, read=None), trust_env=False) as client:
-        worker = EchoWorker(client, read_login())
-        tasks = []
-        try:
-            await worker.start()
-            tasks = [asyncio.create_task(worker.listen()), asyncio.create_task(worker.heartbeat())]
-            done, _ = await asyncio.wait(tasks, timeout=seconds, return_when=asyncio.FIRST_COMPLETED)
-            for task in done:
-                task.result()
-        finally:
-            for task in tasks:
-                task.cancel()
-            await asyncio.gather(*tasks, return_exceptions=True)
-            await worker.close()
-
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser(description=__doc__)
-    parser.add_argument("--seconds", type=int, default=600, help="Test lifetime (default: 10 minutes)")
-    args = parser.parse_args()
-    try:
-        asyncio.run(run(max(1, min(args.seconds, 1800))))
-    except KeyboardInterrupt:
-        pass
-    except (RuntimeError, httpx.HTTPError) as error:
-        print(str(error) if isinstance(error, RuntimeError) else "Network request failed.", file=sys.stderr)
-        sys.exit(1)

package/standalone/remote/rc_local.py

@@ -1,110 +0,0 @@
-"""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}