pennyrouter 0.2.14 → 0.2.17

package/package.json

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

package/src/cli.js

@@ -690,7 +690,11 @@ async function serveMcp(flags) {
     || process.env.PENNYROUTER_GATEWAY_BASE_URL
     || "https://api.pennyrouter.com";
 
-  await runMcpServer({ gatewayBaseUrl, apiKey });
+  await runMcpServer({
+    gatewayBaseUrl,
+    apiKey,
+    harness: process.env.PENNYROUTER_MCP_HARNESS,
+  });
 }
 
 // Refresh the managed local files to this package version WITHOUT re-running any of the
@@ -1838,7 +1842,7 @@ function printHelp() {
 
 Usage:
   pennyrouter install [--harness ${SUPPORTED_HARNESS_IDS}] [--all] [--yes] [--dry-run] [--make-default|--penny-only] [--no-path-update] [--no-mcp] [--anthropic-auth|--no-anthropic-auth] [--anthropic-api-key KEY] [--openai-api-key KEY] [--openrouter-api-key KEY] [--local[=URL]] [--allow-running-harnesses]
-  pennyrouter update [--harness ${SUPPORTED_HARNESS_IDS}] [--all] [--dry-run] [--penny-key pr-...] [--gateway-base-url URL] [--no-mcp] [--allow-running-harnesses]
+  pennyrouter update [--harness ${SUPPORTED_HARNESS_IDS}] [--all] [--dry-run] [--penny-key pr-...] [--gateway-base-url URL|--local[=URL]] [--no-mcp] [--allow-running-harnesses]
   pennyrouter auth anthropic [--penny-key pr-...] [--token oauth-token] [--token-command CMD] [--gateway-base-url URL] [--forget]
   pennyrouter disable [--harness ${SUPPORTED_HARNESS_IDS}] [--all] [--yes]
   pennyrouter enable [--harness ${SUPPORTED_HARNESS_IDS}] [--all] [--yes]
@@ -1865,6 +1869,8 @@ Examples:
   npx pennyrouter update
   npx pennyrouter update --dry-run
   npx pennyrouter update --harness claude-code
+  npx pennyrouter update --harness codex --local
+  npx pennyrouter update --all --local
   npx pennyrouter install
   npx pennyrouter install --make-default
   npx pennyrouter install --penny-only

package/src/mcp-register.js

@@ -30,8 +30,12 @@ const MANAGED_START = "# --- PennyRouter managed MCP server ---";
 const MANAGED_END = "# --- end PennyRouter managed MCP server ---";
 
 /** What we register. Shared by both harnesses so the two configs cannot drift apart. */
-export function serverEntry() {
-  return { command: "npx", args: ["-y", "pennyrouter", "mcp"] };
+export function serverEntry(harness = "claude-code") {
+  return {
+    command: "npx",
+    args: ["-y", "pennyrouter", "mcp"],
+    env: { PENNYROUTER_MCP_HARNESS: harness },
+  };
 }
 
 /** True when an entry is one of ours, so re-installing updates rather than duplicating and
@@ -59,7 +63,7 @@ export function applyClaudeRegistry(config, { remove = false } = {}) {
           "write. Rename it before installing so your configuration is not overwritten.",
       );
     }
-    servers[SERVER_NAME] = serverEntry();
+    servers[SERVER_NAME] = serverEntry("claude-code");
   }
 
   if (Object.keys(servers).length) next.mcpServers = servers;
@@ -96,12 +100,13 @@ export function renderCodexMcp(text, { remove = false } = {}) {
     );
   }
 
-  const entry = serverEntry();
+  const entry = serverEntry("codex");
   const block = [
     MANAGED_START,
     `[mcp_servers.${SERVER_NAME}]`,
     `command = "${entry.command}"`,
     `args = [${entry.args.map((a) => `"${a}"`).join(", ")}]`,
+    `env = { PENNYROUTER_MCP_HARNESS = "${entry.env.PENNYROUTER_MCP_HARNESS}" }`,
     MANAGED_END,
   ].join("\n");
 

package/src/mcp-register.test.js

@@ -17,6 +17,7 @@ import {
   const entry = serverEntry();
   assert.equal(entry.command, "npx");
   assert.deepEqual(entry.args, ["-y", "pennyrouter", "mcp"]);
+  assert.equal(entry.env.PENNYROUTER_MCP_HARNESS, "claude-code");
   assert.ok(!JSON.stringify(entry).includes("/"), "no absolute paths");
   assert.ok(!/pennyrouter@/.test(JSON.stringify(entry)), "not version-pinned");
 }
@@ -85,6 +86,7 @@ assert.equal(isManagedEntry({}), false);
   assert.ok(written.includes(`[mcp_servers.${SERVER_NAME}]`));
   assert.ok(written.includes('command = "npx"'));
   assert.ok(written.includes('args = ["-y", "pennyrouter", "mcp"]'));
+  assert.ok(written.includes('PENNYROUTER_MCP_HARNESS = "codex"'));
   assert.ok(written.includes("[mcp_servers.node_repl]"), "existing servers survive");
 
   // A TOML table header captures every key after it, so our block must be appended — splicing

package/src/mcp.js

@@ -30,6 +30,13 @@ import { writeSession, VERIFIED_MIN, VERIFIED_MAX } from "./thread-session.js";
 import { writeSession as writeCodexSession } from "./thread-session-codex.js";
 
 const PROTOCOL_VERSION = "2024-11-05";
+const SERVER_INSTRUCTIONS =
+  "When the user provides an AI share link and asks to resume, continue, import, or build from " +
+  "that conversation in a coding agent, call a PennyRouter thread tool immediately. For the exact " +
+  "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.";
 
 const TOOLS = [
   {
@@ -39,6 +46,8 @@ const TOOLS = [
       "return its transcript. Use when the user wants to discuss, summarize or ask about a " +
       "past conversation. The transcript enters your context — for long threads that are " +
       "meant to be continued as work, prefer thread_resume. " +
+      "For `@penny import session <link>` on the FIRST user turn, call this tool immediately: " +
+      "the desired result is to continue in the current session. " +
       "This tool is the only supported way to read a share link: those pages are " +
       "JavaScript-rendered shells that return markup, not conversation, to a plain fetch. Never " +
       "fall back to fetching the URL directly, and never guess at the contents. If this call " +
@@ -57,8 +66,13 @@ const TOOLS = [
     description:
       "Fetch an AI conversation from a share link and write it as a resumable coding-agent " +
       "session (Claude Code or Codex), so the user can resume into it and continue coding with " +
-      "that conversation as history. Use when the user wants to CONTINUE or BUILD FROM a past " +
-      "chat rather than talk about it. Returns a session id and path; the transcript is " +
+      "that conversation as history. When the user asks to RESUME, CONTINUE, IMPORT, or BUILD " +
+      "FROM a share link, call this tool immediately — do not search the workspace or look for " +
+      "another resume utility first. Use this instead of thread_read when they want to work from " +
+      "the conversation rather than discuss it. For `@penny import session <link>` AFTER the " +
+      "first user turn, call this tool: a new native session avoids injecting a large transcript " +
+      "into an active conversation. The configured harness is the default; do not guess the other " +
+      "one. Returns a session id and path; the transcript is " +
       "deliberately NOT returned, so importing a long thread costs you no context. That is by " +
       "design and is not a failure — do not read the thread another way to 'check' it, and do " +
       "not fetch the share URL directly. Report the resume command to the user. If this call " +
@@ -77,8 +91,8 @@ const TOOLS = [
           type: "string",
           enum: ["claude-code", "codex"],
           description:
-            "Which agent should be able to resume it. Defaults to claude-code. Use codex when " +
-            "the user asks to continue the conversation in Codex.",
+            "Which agent should be able to resume it. Defaults to the harness that launched this " +
+            "MCP server. Supply this only to override that active harness.",
         },
       },
       required: ["url"],
@@ -153,7 +167,7 @@ async function callTool(name, args, context) {
 
   if (name === "thread_resume") {
     const cwd = String(args?.directory || process.cwd());
-    const harness = String(args?.harness || "claude-code").toLowerCase();
+    const harness = String(args?.harness || context.harness || "claude-code").toLowerCase();
     if (harness !== "claude-code" && harness !== "codex") {
       throw new Error(`unknown harness "${harness}"; expected claude-code or codex`);
     }
@@ -173,7 +187,7 @@ async function callTool(name, args, context) {
       "",
       "Resume it with:",
       codex
-        ? `  cd ${cwd} && codex resume ${sessionId}`
+        ? `  cd ${cwd} && penny codex resume ${sessionId}`
         : `  cd ${cwd} && claude --resume ${sessionId}`,
       "",
       codex
@@ -204,7 +218,7 @@ function toolError(id, error) {
   });
 }
 
-export async function runMcpServer({ gatewayBaseUrl, apiKey }) {
+export async function runMcpServer({ gatewayBaseUrl, apiKey, harness = process.env.PENNYROUTER_MCP_HARNESS }) {
   if (!apiKey) {
     process.stderr.write(
       "pennyrouter mcp: no API key. Run `npx pennyrouter install` first.\n",
@@ -213,7 +227,7 @@ export async function runMcpServer({ gatewayBaseUrl, apiKey }) {
     return;
   }
 
-  const context = { gatewayBaseUrl, apiKey };
+  const context = { gatewayBaseUrl, apiKey, harness };
   const rl = createInterface({ input: process.stdin });
 
   for await (const line of rl) {
@@ -233,6 +247,7 @@ export async function runMcpServer({ gatewayBaseUrl, apiKey }) {
           protocolVersion: PROTOCOL_VERSION,
           capabilities: { tools: {} },
           serverInfo: { name: "pennyrouter", version: "1.0.0" },
+          instructions: SERVER_INSTRUCTIONS,
         });
       } else if (method === "tools/list") {
         reply(id, { tools: TOOLS });

package/src/mcp.test.js

@@ -41,12 +41,15 @@ function stubGateway(handler) {
 }
 
 /** Drive the server over stdio and collect the responses to `requests`. */
-function rpc(requests, { port, home }) {
+function rpc(requests, { port, home, harness }) {
   return new Promise((resolve, reject) => {
     const child = spawn(
       process.execPath,
       [binary, "mcp", "--penny-key", "pr-test", "--gateway-base-url", `http://127.0.0.1:${port}`],
-      { stdio: ["pipe", "pipe", "pipe"], env: { ...process.env, HOME: home } },
+      {
+        stdio: ["pipe", "pipe", "pipe"],
+        env: { ...process.env, HOME: home, ...(harness ? { PENNYROUTER_MCP_HARNESS: harness } : {}) },
+      },
     );
     let out = "";
     let err = "";
@@ -108,6 +111,8 @@ const workspace = mkdtempSync(join(tmpdir(), "pr-mcp-ws-"));
 
   assert.equal(byId.get(1).result.protocolVersion, "2024-11-05");
   assert.equal(byId.get(1).result.serverInfo.name, "pennyrouter");
+  assert.match(byId.get(1).result.instructions, /thread_read when it is the first user turn/i);
+  assert.match(byId.get(1).result.instructions, /otherwise use thread_resume/i);
 
   assert.deepEqual(
     byId.get(2).result.tools.map((t) => t.name),
@@ -122,6 +127,10 @@ const workspace = mkdtempSync(join(tmpdir(), "pr-mcp-ws-"));
     assert.match(tool.description, /not fetch|Never fall back to fetching/i, tool.name);
     assert.match(tool.description, /blocked/i, tool.name);
   }
+  assert.match(
+    byId.get(2).result.tools.find((tool) => tool.name === "thread_resume").description,
+    /do not search the workspace/i,
+  );
 
   // The URL is forwarded to the gateway under the caller's key; no provider logic runs here.
   assert.equal(JSON.parse(requestBody).url, "https://www.perplexity.ai/search/x");
@@ -161,7 +170,7 @@ const workspace = mkdtempSync(join(tmpdir(), "pr-mcp-ws-"));
         method: "tools/call",
         params: {
           name: "thread_resume",
-          arguments: { url: "https://x/y", directory: workspace, harness: "codex" },
+          arguments: { url: "https://x/y", directory: workspace },
         },
       },
       {
@@ -174,7 +183,7 @@ const workspace = mkdtempSync(join(tmpdir(), "pr-mcp-ws-"));
         },
       },
     ],
-    { port, home },
+    { port, home, harness: "codex" },
   );
   server.close();
 
@@ -187,7 +196,8 @@ 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("codex resume"), "prints the codex resume command");
+    assert.ok(codex.content[0].text.includes("penny codex resume"),
+      "prints the Penny-profile Codex resume command");
     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

@@ -1,15 +1,16 @@
 /* Write a canonical thread into a Codex rollout it will resume from.
 
-   `codex resume <session-id>` reads ~/.codex/sessions/YYYY/MM/DD/rollout-<stamp>-<uuid>.jsonl,
+   `penny codex resume <session-id>` reads ~/.codex/sessions/YYYY/MM/DD/rollout-<stamp>-<uuid>.jsonl,
    so a synthesized rollout in that tree resumes like any other session. Verified end-to-end on
-   codex-cli 0.146.0: a file written by this shape resumed and the model answered from history it
+   codex-cli 0.147.0: a file written by this shape resumed and the model answered from history it
    never lived.
 
    The format differs from Claude Code's in every structural respect, which is why this is a
    separate writer rather than a flag on the other one:
 
-     - Records are a {timestamp, type, payload} envelope, not flat message objects.
-     - There is no parentUuid chain. Order in the file IS the order; nothing to link.
+     - Records are an ordinal-bearing {timestamp, type, payload} envelope, not flat messages.
+     - Paginated history uses task and item events grouped by turn id; response_item records alone
+       produce an empty thread in 0.147 even though the file itself can be found.
      - The first record is a `session_meta` header carrying cwd, cli_version and the id.
      - User content is `input_text`; assistant content is `output_text`. Using the wrong key
        for a role is the one mistake that produces a file which loads but renders empty.
@@ -28,7 +29,7 @@ import { join } from "node:path";
 import { orientation, renderMessage } from "./thread-session.js";
 
 /** Versions this writer has been verified against. */
-export const VERIFIED_MIN = "0.100.0";
+export const VERIFIED_MIN = "0.147.0";
 export const VERIFIED_MAX = "0.999.999";
 
 /** UUIDv7: 48-bit big-endian millisecond timestamp, then version/variant bits, then random.
@@ -62,38 +63,55 @@ function compare(a, b) {
 
 export function versionSupported(version) {
   if (!version) return false;
-  // `codex --version` prints "codex-cli 0.146.0"; take the numeric field wherever it sits.
+  // `codex --version` prints "codex-cli 0.147.0"; take the numeric field wherever it sits.
   const match = String(version).match(/(\d+\.\d+\.\d+)/);
   if (!match) return false;
   return compare(match[1], VERIFIED_MIN) >= 0 && compare(match[1], VERIFIED_MAX) <= 0;
 }
 
-/** ~/.codex/sessions/YYYY/MM/DD — Codex partitions rollouts by date. */
+/** ~/.codex/sessions/YYYY/MM/DD — Codex partitions rollouts by local date. */
 export function sessionDirFor(date = new Date()) {
-  const yyyy = String(date.getUTCFullYear());
-  const mm = String(date.getUTCMonth() + 1).padStart(2, "0");
-  const dd = String(date.getUTCDate()).padStart(2, "0");
+  const yyyy = String(date.getFullYear());
+  const mm = String(date.getMonth() + 1).padStart(2, "0");
+  const dd = String(date.getDate()).padStart(2, "0");
   return join(homedir(), ".codex", "sessions", yyyy, mm, dd);
 }
 
-/** The stamp embedded in a rollout filename: 2026-08-09T22-15-30. */
+/** The local-wall-time stamp embedded in a rollout filename: 2026-08-09T22-15-30. */
 export function fileStamp(date = new Date()) {
-  return date.toISOString().replace(/\.\d+Z$/, "").replace(/:/g, "-");
+  const pad = (value) => String(value).padStart(2, "0");
+  return `${date.getFullYear()}-${pad(date.getMonth() + 1)}-${pad(date.getDate())}` +
+    `T${pad(date.getHours())}-${pad(date.getMinutes())}-${pad(date.getSeconds())}`;
 }
 
 export function buildRecords(thread, { cwd, sessionId, version, timestamp = new Date() }) {
   const ts = timestamp.toISOString();
-  const envelope = (type, payload) => ({ timestamp: ts, type, payload });
-
-  const message = (role, text) =>
-    envelope("response_item", {
-      type: "message",
-      id: `msg_${uuidv7(timestamp.getTime())}`,
-      role,
-      // The content key is role-dependent. Swapping them yields a file that loads and shows
-      // nothing, which is the worst failure mode available here.
-      content: [{ type: role === "assistant" ? "output_text" : "input_text", text }],
-    });
+  const epochSeconds = Math.floor(timestamp.getTime() / 1000);
+  let ordinal = 0;
+  const envelope = (type, payload) => ({ timestamp: ts, ordinal: ordinal++, type, payload });
+
+  const message = (role, text, turnId, { final = false } = {}) => ({
+    type: "message",
+    id: `msg_${uuidv7(timestamp.getTime())}`,
+    role,
+    content: [{ type: role === "assistant" ? "output_text" : "input_text", text }],
+    ...(final ? { phase: "final_answer" } : {}),
+    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."],
+  }];
+  for (const entry of thread.messages || []) {
+    const text = renderMessage(entry);
+    if (!text) continue;
+    if (entry.role === "user") turns.push({ user: text, assistants: [] });
+    else if (entry.role === "assistant") {
+      if (!turns.length) turns.push({ user: "Continue the imported conversation.", assistants: [] });
+      turns.at(-1).assistants.push(text);
+    }
+  }
 
   const records = [
     envelope("session_meta", {
@@ -105,18 +123,63 @@ export function buildRecords(thread, { cwd, sessionId, version, timestamp = new
       cli_version: String(version || "").match(/(\d+\.\d+\.\d+)/)?.[1] || "0.0.0",
       source: "cli",
       thread_source: "user",
-      model_provider: "openai",
-      history_mode: "legacy",
+      model_provider: "pennyrouter",
+      history_mode: "paginated",
     }),
-    message("user", orientation(thread)),
-    message("assistant", "Understood — I have the imported conversation and will continue from it."),
   ];
 
-  for (const entry of thread.messages || []) {
-    const text = renderMessage(entry);
-    if (!text) continue;
-    if (entry.role === "assistant") records.push(message("assistant", text));
-    else if (entry.role === "user") records.push(message("user", text));
+  for (const turn of turns) {
+    const turnId = uuidv7(timestamp.getTime());
+    records.push(envelope("event_msg", {
+      type: "task_started",
+      turn_id: turnId,
+      started_at: epochSeconds,
+      model_context_window: null,
+      collaboration_mode_kind: "default",
+    }));
+    const userMessage = message("user", turn.user, turnId);
+    records.push(envelope("response_item", userMessage));
+    records.push(envelope("event_msg", {
+      type: "item_completed",
+      thread_id: sessionId,
+      turn_id: turnId,
+      item: {
+        type: "UserMessage",
+        id: uuidv7(timestamp.getTime()),
+        content: [{ type: "text", text: turn.user, text_elements: [] }],
+      },
+      started_at_ms: timestamp.getTime(),
+      completed_at_ms: timestamp.getTime(),
+    }));
+
+    let lastAssistant = "";
+    for (const text of turn.assistants) {
+      lastAssistant = text;
+      const assistantMessage = message("assistant", text, turnId, { final: true });
+      records.push(envelope("event_msg", {
+        type: "item_completed",
+        thread_id: sessionId,
+        turn_id: turnId,
+        item: {
+          type: "AgentMessage",
+          id: assistantMessage.id,
+          content: [{ type: "Text", text }],
+          phase: "final_answer",
+        },
+        started_at_ms: timestamp.getTime(),
+        completed_at_ms: timestamp.getTime(),
+      }));
+      records.push(envelope("response_item", assistantMessage));
+    }
+    records.push(envelope("event_msg", {
+      type: "task_complete",
+      turn_id: turnId,
+      last_agent_message: lastAssistant,
+      started_at: epochSeconds,
+      completed_at: epochSeconds,
+      duration_ms: 0,
+      time_to_first_token_ms: 0,
+    }));
   }
 
   return records;

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

@@ -45,16 +45,23 @@ const thread = {
 
 // -- paths ----------------------------------------------------------------
 {
-  const date = new Date(Date.UTC(2026, 7, 9, 22, 15, 30));
-  assert.ok(sessionDirFor(date).endsWith(join(".codex", "sessions", "2026", "08", "09")));
-  assert.equal(fileStamp(date), "2026-08-09T22-15-30");
+  const originalTz = process.env.TZ;
+  process.env.TZ = "America/New_York";
+  try {
+    // Codex filenames use local wall time, including when UTC crossed into the next day.
+    const date = new Date(Date.UTC(2026, 7, 10, 2, 15, 30));
+    assert.ok(sessionDirFor(date).endsWith(join(".codex", "sessions", "2026", "08", "09")));
+    assert.equal(fileStamp(date), "2026-08-09T22-15-30");
+  } finally {
+    if (originalTz === undefined) delete process.env.TZ;
+    else process.env.TZ = originalTz;
+  }
 }
 
 // -- version gate ---------------------------------------------------------
-// `codex --version` prints "codex-cli 0.146.0", so the number has to be found, not assumed.
-assert.equal(versionSupported("codex-cli 0.146.0"), true);
-assert.equal(versionSupported("0.100.0"), true);
-assert.equal(versionSupported("0.99.0"), false);
+// `codex --version` prints "codex-cli 0.147.0", so the number has to be found, not assumed.
+assert.equal(versionSupported("codex-cli 0.147.0"), true);
+assert.equal(versionSupported("0.146.0"), false);
 assert.equal(versionSupported("1.0.0"), false);
 assert.equal(versionSupported("not-a-version"), false);
 assert.equal(versionSupported(null), false);
@@ -64,40 +71,45 @@ assert.equal(versionSupported(null), false);
   const records = buildRecords(thread, {
     cwd: "/tmp/ws",
     sessionId: "sid-1",
-    version: "codex-cli 0.146.0",
+    version: "codex-cli 0.147.0",
   });
 
-  // Every record is the {timestamp, type, payload} envelope.
+  // Codex 0.147 uses an ordinal-bearing paginated rollout envelope.
   for (const record of records) {
-    assert.deepEqual(Object.keys(record).sort(), ["payload", "timestamp", "type"]);
+    assert.deepEqual(Object.keys(record).sort(), ["ordinal", "payload", "timestamp", "type"]);
   }
 
   const [meta, ...rest] = records;
   assert.equal(meta.type, "session_meta");
   assert.equal(meta.payload.session_id, "sid-1");
   assert.equal(meta.payload.cwd, "/tmp/ws");
-  assert.equal(meta.payload.cli_version, "0.146.0", "the bare number, not the whole string");
+  assert.equal(meta.payload.cli_version, "0.147.0", "the bare number, not the whole string");
+  assert.equal(meta.payload.history_mode, "paginated");
 
   // Content key is role-dependent. Getting this wrong yields a rollout that loads and renders
   // empty, which is the failure mode least likely to be noticed before a user hits it.
-  for (const record of rest) {
-    assert.equal(record.type, "response_item");
+  const messages = rest.filter((record) => record.type === "response_item");
+  for (const record of messages) {
     assert.equal(record.payload.type, "message");
     const key = record.payload.content[0].type;
     assert.equal(key, record.payload.role === "assistant" ? "output_text" : "input_text");
     assert.match(record.payload.id, /^msg_/);
+    assert.ok(record.payload.internal_chat_message_metadata_passthrough.turn_id);
   }
 
   assert.deepEqual(
-    rest.map((r) => r.payload.role),
+    messages.map((r) => r.payload.role),
     ["user", "assistant", "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);
 
   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(rest[0].payload.content[0].text.includes("Perplexity"), "orientation names origin");
+  assert.ok(messages[0].payload.content[0].text.includes("Perplexity"), "orientation names origin");
 }
 
 // -- writing --------------------------------------------------------------
@@ -106,7 +118,7 @@ assert.equal(versionSupported(null), false);
   const originalHome = process.env.HOME;
   process.env.HOME = home;
   try {
-    const result = writeSession(thread, { cwd: "/tmp/ws", version: "codex-cli 0.146.0" });
+    const result = writeSession(thread, { cwd: "/tmp/ws", version: "codex-cli 0.147.0" });
 
     // The filename carries both the stamp and the id; Codex's picker reads both.
     assert.match(result.path, /rollout-\d{4}-\d{2}-\d{2}T\d{2}-\d{2}-\d{2}-[0-9a-f-]{36}\.jsonl$/);
@@ -119,7 +131,7 @@ assert.equal(versionSupported(null), false);
     assert.equal(parsed[0].payload.id, result.sessionId);
 
     // Never overwrite an existing session.
-    const again = writeSession(thread, { cwd: "/tmp/ws", version: "codex-cli 0.146.0" });
+    const again = writeSession(thread, { cwd: "/tmp/ws", version: "codex-cli 0.147.0" });
     assert.notEqual(again.sessionId, result.sessionId);
     assert.notEqual(again.path, result.path);