pennyrouter 0.2.17 → 0.2.19

package/package.json

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

package/src/harnesses/claude-code.js

@@ -4,15 +4,19 @@ import { configureClaudeCodeStatusline, restoreClaudeCodeStatusline } from "../s
 const CONFIG_PATH = "~/.claude/settings.json";
 const LEGACY_MODEL_LABEL = "PennyRouter Bundle";
 const CONNECTOR_SETTING = "disableClaudeAiConnectors";
-// The slot values remain genuine Anthropic ids so Claude Code recognizes their actual context
-// windows (Haiku 200K; the 1M-capable models 1M) and sends the native id on the wire. Claude
-// Code separately supports *_MODEL_NAME and *_MODEL_DESCRIPTION for the picker, so Penny can
-// present a friendly alias without sacrificing model recognition.
+// The slot values remain genuine Anthropic ids so Claude Code recognizes them and sends the
+// native id on the wire. Claude Code separately supports *_MODEL_NAME and *_MODEL_DESCRIPTION
+// for the picker, so Penny can present a friendly alias without sacrificing model recognition.
+//
+// The 1M-context variant is a `[1m]` suffix on the id — Claude Code does NOT infer a 1M window
+// from a bare id, so a bare `claude-sonnet-5` gets 200K and auto-compacts around 150K. The
+// suffix rides the wire; the gateway strips it for the upstream model and turns it into the
+// `context-1m` beta header. Haiku has no 1M variant, so it stays bare.
 export const CLAUDE_CODE_MODELS = {
   haiku: "claude-haiku-4-5-20251001",
-  sonnet: "claude-sonnet-5",
-  opus: "claude-opus-5",
-  fable: "claude-fable-5",
+  sonnet: "claude-sonnet-5[1m]",
+  opus: "claude-opus-5[1m]",
+  fable: "claude-fable-5[1m]",
   custom: "Penny Custom",             // -> dynamic (PennyRouter cost-routing)
 };
 const CLAUDE_CODE_MODEL_PRESENTATION = {

package/src/launch.test.js

@@ -103,7 +103,10 @@ async function main() {
     assert.ok(!claude.args.includes("--plugin-dir"));
     assert.equal(claude.env.ANTHROPIC_AUTH_TOKEN, "pr-super-secret");
     assert.equal(claude.env.ANTHROPIC_BASE_URL, "https://gateway.example/");
-    assert.equal(claude.env.ANTHROPIC_DEFAULT_OPUS_MODEL, "claude-opus-5");
+    // 1M-capable slots carry the `[1m]` suffix; Haiku has no 1M variant and stays bare.
+    // Per-slot suffixes, not the global CLAUDE_CODE_MAX_CONTEXT_TOKENS override, which
+    // would wrongly hand Haiku a 1M window too.
+    assert.equal(claude.env.ANTHROPIC_DEFAULT_OPUS_MODEL, "claude-opus-5[1m]");
     assert.equal(claude.env.ANTHROPIC_DEFAULT_HAIKU_MODEL, "claude-haiku-4-5-20251001");
     assert.equal(claude.env.ANTHROPIC_DEFAULT_HAIKU_MODEL_NAME, "Haiku 4.5 (PennyRouter)");
     assert.equal(claude.env.ANTHROPIC_DEFAULT_HAIKU_MODEL_DESCRIPTION, "Fast, economical Claude model · 200K context");
@@ -128,7 +131,7 @@ async function main() {
     });
     const persistedClaude = JSON.parse(fs.readFileSync(path.join(home, ".claude", "settings.json"), "utf8"));
     assert.equal(persistedClaude.env.ANTHROPIC_DEFAULT_HAIKU_MODEL, "claude-haiku-4-5-20251001");
-    assert.equal(persistedClaude.env.ANTHROPIC_DEFAULT_SONNET_MODEL, "claude-sonnet-5");
+    assert.equal(persistedClaude.env.ANTHROPIC_DEFAULT_SONNET_MODEL, "claude-sonnet-5[1m]");
     assert.equal("CLAUDE_CODE_MAX_CONTEXT_TOKENS" in persistedClaude.env, false);
 
     await removePennyHarness("claude-code");

package/src/mcp.js

@@ -10,6 +10,7 @@
                     — the transcript never enters the caller's context, so moving a 200-turn
                     thread costs the caller nothing. That asymmetry is the whole reason for two
                     tools rather than one with a flag.
+     thread_transfer capture the current local session and write it for the other harness.
 
    Because the destination is a parameter, "resume this Perplexity thread in Codex" and "…in
    Claude Code" are the same call with a different `harness`. Each harness has its own writer:
@@ -25,6 +26,9 @@
 
 import { createInterface } from "node:readline";
 import { execFileSync } from "node:child_process";
+import { readdir, readFile, stat } from "node:fs/promises";
+import { homedir } from "node:os";
+import { join } from "node:path";
 
 import { writeSession, VERIFIED_MIN, VERIFIED_MAX } from "./thread-session.js";
 import { writeSession as writeCodexSession } from "./thread-session-codex.js";
@@ -36,7 +40,8 @@ const SERVER_INSTRUCTIONS =
   "command '@penny import session <link>', use thread_read when it is the first user turn so the " +
   "conversation enters the current session; otherwise use thread_resume to create a fresh native " +
   "session. Do not search the local workspace, fetch the link directly, or look for another resume " +
-  "utility first.";
+  "utility first. For `@penny send session to claude` or `@penny send session to codex`, call " +
+  "thread_transfer; it reads the current local session and writes only the target harness file.";
 
 const TOOLS = [
   {
@@ -98,8 +103,59 @@ const TOOLS = [
       required: ["url"],
     },
   },
+  {
+    name: "thread_transfer",
+    description:
+      "Capture the current local coding-agent session and write it as a native session for " +
+      "the other harness. Use when the user says `@penny send session to claude` or " +
+      "`@penny send session to codex`. This stays local: it never sends session contents to " +
+      "the gateway for storage. Returns a session id and the target harness's `/resume` command.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        target_harness: { type: "string", enum: ["claude-code", "codex"] },
+        directory: { type: "string", description: "Workspace of the current session." },
+      },
+      required: ["target_harness"],
+    },
+  },
 ];
 
+function flattenClaudeProject(cwd) {
+  return cwd.replace(/[/.\\]/g, "-");
+}
+
+async function newestSessionFile(harness, cwd) {
+  const roots = harness === "codex"
+    ? [join(homedir(), ".codex", "sessions")]
+    : [join(homedir(), ".claude", "projects", flattenClaudeProject(cwd))];
+  const candidates = [];
+  async function walk(dir, depth = 0) {
+    if (depth > 4) return;
+    let entries;
+    try { entries = await readdir(dir, { withFileTypes: true }); } catch { return; }
+    for (const entry of entries) {
+      const path = join(dir, entry.name);
+      if (entry.isDirectory()) await walk(path, depth + 1);
+      else if (entry.isFile() && entry.name.endsWith(".jsonl")) {
+        try {
+          const first = (await readFile(path, "utf8")).split("\n", 1)[0];
+          if (harness === "codex") {
+            const row = JSON.parse(first);
+            if (row?.payload?.cwd !== cwd) continue;
+          }
+          const info = await stat(path);
+          candidates.push({ path, mtimeMs: info.mtimeMs });
+        } catch { /* incomplete/foreign session; keep searching */ }
+      }
+    }
+  }
+  for (const root of roots) await walk(root);
+  candidates.sort((a, b) => b.mtimeMs - a.mtimeMs);
+  if (!candidates[0]) throw new Error(`could not find the current ${harness} session for ${cwd}`);
+  return candidates[0].path;
+}
+
 /** `<tool> --version`, or null when the tool is not installed. The writers version-gate on this
     and refuse rather than write a session file that only fails at resume time. */
 function toolVersion(binary) {
@@ -134,6 +190,21 @@ async function fetchCanonical(url, { gatewayBaseUrl, apiKey }) {
   return response.json();
 }
 
+async function fetchCanonicalFile(path, source, { gatewayBaseUrl, apiKey }) {
+  const payload = await readFile(path);
+  const response = await fetch(`${gatewayBaseUrl}/v1/penny/threads/canonical-file?source=${encodeURIComponent(source)}`, {
+    method: "POST",
+    headers: { "content-type": "application/json", authorization: `Bearer ${apiKey}` },
+    body: payload,
+  });
+  if (!response.ok) {
+    let detail = `HTTP ${response.status}`;
+    try { detail = (await response.json())?.detail || detail; } catch { /* status is enough */ }
+    throw new Error(detail);
+  }
+  return response.json();
+}
+
 function transcript(thread) {
   const lines = [`# ${thread.title || "Imported thread"}`];
   if (thread.source_url) lines.push(`Source: ${thread.source_url}`);
@@ -158,14 +229,15 @@ function transcript(thread) {
 
 async function callTool(name, args, context) {
   const url = String(args?.url || "").trim();
-  if (!url) throw new Error("a share link is required");
 
   if (name === "thread_read") {
+    if (!url) throw new Error("a share link is required");
     const thread = await fetchCanonical(url, context);
     return transcript(thread);
   }
 
   if (name === "thread_resume") {
+    if (!url) throw new Error("a share link is required");
     const cwd = String(args?.directory || process.cwd());
     const harness = String(args?.harness || context.harness || "claude-code").toLowerCase();
     if (harness !== "claude-code" && harness !== "codex") {
@@ -186,9 +258,7 @@ async function callTool(name, args, context) {
       `  ${path}`,
       "",
       "Resume it with:",
-      codex
-        ? `  cd ${cwd} && penny codex resume ${sessionId}`
-        : `  cd ${cwd} && claude --resume ${sessionId}`,
+      `  /resume ${sessionId}`,
       "",
       codex
         ? "Tool calls were rendered as prose: Codex and the source harness do not share a tool " +
@@ -198,6 +268,32 @@ async function callTool(name, args, context) {
     ].join("\n");
   }
 
+  if (name === "thread_transfer") {
+    const cwd = String(args?.directory || process.cwd());
+    const sourceHarness = String(context.harness || "codex").toLowerCase();
+    const targetHarness = String(args?.target_harness || "").toLowerCase();
+    if (!["claude-code", "codex"].includes(targetHarness)) {
+      throw new Error(`unknown target harness "${targetHarness}"; expected claude-code or codex`);
+    }
+    if (!["claude-code", "codex"].includes(sourceHarness)) {
+      throw new Error(`unknown source harness "${sourceHarness}"`);
+    }
+    if (sourceHarness === targetHarness) throw new Error("target harness is already active");
+    const sourcePath = await newestSessionFile(sourceHarness, cwd);
+    const thread = await fetchCanonicalFile(
+      sourcePath,
+      sourceHarness === "codex" ? "codex_jsonl" : "claude_code_jsonl",
+      context,
+    );
+    const version = toolVersion(targetHarness === "codex" ? "codex" : "claude");
+    const write = targetHarness === "codex" ? writeCodexSession : writeSession;
+    const { sessionId, path, messageCount } = write(thread, { cwd, version });
+    return [
+      `Transferred "${thread.title}" to ${targetHarness === "codex" ? "Codex" : "Claude Code"}.`,
+      `Wrote ${messageCount} records:`, `  ${path}`, "", `  /resume ${sessionId}`,
+    ].join("\n");
+  }
+
   throw new Error(`unknown tool: ${name}`);
 }
 

package/src/mcp.test.js

@@ -116,7 +116,7 @@ const workspace = mkdtempSync(join(tmpdir(), "pr-mcp-ws-"));
 
   assert.deepEqual(
     byId.get(2).result.tools.map((t) => t.name),
-    ["thread_read", "thread_resume"],
+    ["thread_read", "thread_resume", "thread_transfer"],
   );
 
   // Observed in a real session: a blocked tool call is indistinguishable from an empty one, so
@@ -146,7 +146,7 @@ const workspace = mkdtempSync(join(tmpdir(), "pr-mcp-ws-"));
   const resumed = byId.get(4).result.content[0].text;
   assert.ok(!resumed.includes("UNIQUE-QUESTION"), "thread_resume must not return the transcript");
   assert.ok(!resumed.includes("UNIQUE-ANSWER"), "thread_resume must not return the transcript");
-  assert.ok(resumed.includes("claude --resume"), "it must tell the user how to resume");
+  assert.match(resumed, /\/resume [0-9a-f-]{36}/, "it must tell the user how to resume");
   assert.ok(resumed.includes("Kickplate removal"));
   assert.equal(byId.get(4).result.isError, undefined);
 }
@@ -196,8 +196,9 @@ const workspace = mkdtempSync(join(tmpdir(), "pr-mcp-ws-"));
   if (codex.isError) {
     assert.match(codex.content[0].text, /Codex .*outside the range|ENOENT|not.*install/i);
   } else {
-    assert.ok(codex.content[0].text.includes("penny codex resume"),
-      "prints the Penny-profile Codex resume command");
+    assert.match(codex.content[0].text, /\/resume [0-9a-f-]{36}/,
+      "prints the native Codex resume command");
+    assert.ok(!codex.content[0].text.includes("penny codex resume"));
     assert.ok(!codex.content[0].text.includes("claude --resume"));
     assert.ok(!codex.content[0].text.includes("UNIQUE-QUESTION"), "still returns no transcript");
   }

package/src/thread-session-codex.js

@@ -99,10 +99,10 @@ export function buildRecords(thread, { cwd, sessionId, version, timestamp = new
     internal_chat_message_metadata_passthrough: { turn_id: turnId },
   });
 
-  const turns = [{
-    user: orientation(thread),
-    assistants: ["Understood — I have the imported conversation and will continue from it."],
-  }];
+  // Keep the import handoff out of the visible conversation. Codex accepts a developer
+  // response_item in a rollout; it is injected as context but is not rendered as a user turn.
+  // The imported transcript should begin with the source's actual first user message.
+  const turns = [];
   for (const entry of thread.messages || []) {
     const text = renderMessage(entry);
     if (!text) continue;
@@ -128,7 +128,7 @@ export function buildRecords(thread, { cwd, sessionId, version, timestamp = new
     }),
   ];
 
-  for (const turn of turns) {
+  for (const [turnIndex, turn] of turns.entries()) {
     const turnId = uuidv7(timestamp.getTime());
     records.push(envelope("event_msg", {
       type: "task_started",
@@ -137,6 +137,9 @@ export function buildRecords(thread, { cwd, sessionId, version, timestamp = new
       model_context_window: null,
       collaboration_mode_kind: "default",
     }));
+    if (turnIndex === 0) {
+      records.push(envelope("response_item", message("developer", orientation(thread), turnId)));
+    }
     const userMessage = message("user", turn.user, turnId);
     records.push(envelope("response_item", userMessage));
     records.push(envelope("event_msg", {

package/src/thread-session-codex.test.js

@@ -99,17 +99,20 @@ assert.equal(versionSupported(null), false);
 
   assert.deepEqual(
     messages.map((r) => r.payload.role),
-    ["user", "assistant", "user", "assistant"],
+    ["developer", "user", "assistant"],
   );
-  assert.equal(rest.filter((r) => r.payload.type === "task_started").length, 2);
-  assert.equal(rest.filter((r) => r.payload.type === "task_complete").length, 2);
-  assert.equal(rest.filter((r) => r.payload.type === "item_completed").length, 4);
+  assert.equal(messages[0].payload.role, "developer");
+  assert.ok(messages[0].payload.content[0].text.includes("Perplexity"), "handoff is developer context");
+  assert.equal(messages[1].payload.role, "user");
+  assert.equal(rest.filter((r) => r.payload.type === "task_started").length, 1);
+  assert.equal(rest.filter((r) => r.payload.type === "task_complete").length, 1);
+  assert.equal(rest.filter((r) => r.payload.type === "item_completed").length, 2);
 
   const serialized = JSON.stringify(records);
   assert.ok(!serialized.includes("REASONING-TRACE"), "thinking must never reach a handoff");
   assert.ok(!serialized.includes("SYSTEM-PREAMBLE"), "system turns are not replayed");
   assert.ok(serialized.includes("USER-TURN") && serialized.includes("ASSISTANT-TURN"));
-  assert.ok(messages[0].payload.content[0].text.includes("Perplexity"), "orientation names origin");
+  assert.ok(!messages.some((r) => r.payload.role === "user" && r.payload.content[0].text.includes("This session was imported")));
 }
 
 // -- writing --------------------------------------------------------------