@retasc/cli 1.42.0 → 1.42.1

package/CHANGELOG.md

@@ -6,6 +6,20 @@ release commits and the issues they reference.
 
 Dates are the npm publish date. Each entry names the RTSC issue behind it.
 
+## 1.42.1 (2026-09-05)
+
+- **RTSC-832** — the model now actually appears. 1.42.0 read it from the SessionStart
+  hook's `model` field, and Claude Code 2.1.261 does not send one: a captured payload is
+  `session_id`, `transcript_path`, `cwd`, `hook_event_name`, `source` and nothing else.
+  The row therefore filled in only after a `/model` switch, which is backwards.
+  Claude Code does write the model on every assistant message in the transcript, so the
+  proxy reads it from there instead, and every session gets one.
+- The read is bounded to the last 64KB: transcripts reach megabytes and this runs on a
+  throttle for the whole session. Reading backwards from the end also means a `/model`
+  switch is picked up by the same read, with or without the hook.
+- Only the model STRING is ever sent. The transcript path stays on the machine that
+  wrote it, and nothing else from the file leaves it.
+
 ## 1.42.0 (2026-09-05)
 
 - **RTSC-821** — a session now reports WHICH MODEL ran it. The MCP handshake carries the

package/dist/index.js

@@ -625,6 +625,8 @@ hook
                 ...(parsed.model ? { model: parsed.model } : {}),
                 ...(parsed.agentType ? { agentType: parsed.agentType } : {}),
                 ...(parsed.agentId ? { agentId: parsed.agentId } : {}),
+                // RTSC-832 — the proxy reads the model out of this. Stays on this machine.
+                ...(parsed.transcriptPath ? { transcriptPath: parsed.transcriptPath } : {}),
             });
         }
     }

package/dist/lib/sessionHook.js

@@ -1,5 +1,5 @@
 import { createHash } from "node:crypto";
-import { existsSync, mkdirSync, readFileSync, readdirSync, realpathSync, statSync, unlinkSync, writeFileSync } from "node:fs";
+import { closeSync, existsSync, mkdirSync, openSync, readFileSync, readSync, readdirSync, realpathSync, statSync, unlinkSync, writeFileSync } from "node:fs";
 import { spawnSync } from "node:child_process";
 import { dirname, join, resolve } from "node:path";
 import { homedir } from "node:os";
@@ -105,8 +105,96 @@ export function readHookRecord(cwd, opts = {}) {
         ...(ident(rec.model, 60) ? { model: ident(rec.model, 60) } : {}),
         ...(ident(rec.agentType, 60) ? { agentType: ident(rec.agentType, 60) } : {}),
         ...(ident(rec.agentId, 100) ? { agentId: ident(rec.agentId, 100) } : {}),
+        ...(typeof rec.transcriptPath === "string" && rec.transcriptPath ? { transcriptPath: rec.transcriptPath } : {}),
     };
 }
+/**
+ * The model the harness is CURRENTLY running, read out of the transcript it writes
+ * (RTSC-832).
+ *
+ * Claude Code never puts `model` in the SessionStart payload, so this is the only source
+ * that works for a session nobody has run `/model` in — which is most of them. Each
+ * assistant message in the `.jsonl` carries `message.model`, and the LAST one is the
+ * model in force now, so a `/model` switch is picked up by the same read.
+ *
+ * Reads the TAIL only. Transcripts reach 24MB in this repo, and this is called on a
+ * throttle for the life of a session; pulling the whole file each time would be a
+ * megabyte-scale read on the proxy's response path. The last chunk is where the newest
+ * message is, and a line straddling the chunk boundary is simply skipped as unparseable.
+ *
+ * Never throws: a missing, empty, truncated or half-written file just means no model
+ * this time, exactly as a harness that reports none.
+ */
+const TRANSCRIPT_TAIL_BYTES = 64 * 1024;
+/** The one retry, for a session whose newest message is bigger than the window. */
+const TRANSCRIPT_WIDE_BYTES = 2 * 1024 * 1024;
+export function modelFromTranscript(path, tailBytes = TRANSCRIPT_TAIL_BYTES) {
+    // A single assistant message can exceed the window: 563 lines over 64KB exist on this
+    // machine, the largest 1.18MB. The window then holds only that line's tail fragment,
+    // which is not parseable JSON, and the read would report nothing at all. So a scan
+    // that finds nothing widens once before giving up.
+    return scanTail(path, tailBytes) ?? (tailBytes < TRANSCRIPT_WIDE_BYTES ? scanTail(path, TRANSCRIPT_WIDE_BYTES) : undefined);
+}
+function scanTail(path, tailBytes) {
+    let fd;
+    try {
+        const st = statSync(path);
+        // isFile FIRST, and it is load-bearing: `openSync` on a FIFO with no writer blocks
+        // forever, and this runs on the proxy's synchronous response path. The size check
+        // happened to prevent that before; relying on that ordering was an accident.
+        if (!st.isFile() || !st.size)
+            return undefined;
+        const start = Math.max(0, st.size - tailBytes);
+        const len = st.size - start;
+        const buf = Buffer.alloc(len);
+        fd = openSync(path, "r");
+        // The harness is APPENDING to this file. A short read, or a truncation between the
+        // stat and the read, leaves the rest of the zero-filled buffer glued to the newest
+        // line, which then fails to parse and silently yields an older model. Only the bytes
+        // actually read are text.
+        const n = readSync(fd, buf, 0, len, start);
+        if (!n)
+            return undefined;
+        const lines = buf.subarray(0, n).toString("utf8").split("\n");
+        // Backwards: the newest assistant message wins, so a mid-session switch lands.
+        for (let i = lines.length - 1; i >= 0; i--) {
+            const line = lines[i].trim();
+            if (!line || line[0] !== "{")
+                continue;
+            try {
+                const j = JSON.parse(line);
+                // ONLY a top-level assistant turn. Measured across 40 real transcripts, MCP
+                // sampling records (`attributionMcpServer` / `attributionMcpTool`, 91-271 per
+                // file) also carry `message.model`, and so do sidechain entries — a subagent on
+                // a different model would otherwise be reported as the session's model, and each
+                // flip would spend one of the 40 lookups plus a server round trip.
+                // `type: "assistant"` alone is NOT enough: a sampling record wears it too.
+                if (j?.type !== "assistant")
+                    continue;
+                if (j?.isSidechain || j?.attributionMcpServer || j?.attributionMcpTool)
+                    continue;
+                const m = ident(j?.message?.model, 60);
+                if (m)
+                    return m;
+            }
+            catch {
+                /* a truncated line, or the one straddling the chunk edge */
+            }
+        }
+        return undefined;
+    }
+    catch {
+        return undefined;
+    }
+    finally {
+        if (fd !== undefined) {
+            try {
+                closeSync(fd);
+            }
+            catch { /* nothing to do */ }
+        }
+    }
+}
 /**
  * Rewrite the model on the record for this folder, in place (RTSC-821).
  *
@@ -164,8 +252,13 @@ function ident(raw, max) {
 /**
  * Parse what Claude Code hands a SessionStart hook on stdin. Verified against the hooks
  * reference (2026-09-04): `session_id`, `transcript_path`, `cwd`, `hook_event_name`,
- * `source`, and `model` / `agent_id` / `agent_type` when it has them. The transcript
- * path is NOT kept: it is derivable and would bake in a username (RTSC-791).
+ * `source`, and `model` / `agent_id` / `agent_type` when it has them.
+ *
+ * The transcript path IS kept (RTSC-832), reversing RTSC-820. That was dropped on
+ * RTSC-791's rule that a path bakes in a username, and the rule still holds: it governs
+ * what we SEND, and the path never leaves this machine. It is kept because 2.1.261 puts
+ * no `model` in this payload at all, so the transcript is the only place the model
+ * exists. See `HookRecord.transcriptPath`.
  *
  * `model` is absent from some payloads by design, so a parse that finds an id and no
  * model is a SUCCESS carrying less, never a failure.
@@ -188,6 +281,8 @@ export function parseClaudeHookInput(stdin) {
         ...(ident(j?.model, 60) ? { model: ident(j.model, 60) } : {}),
         ...(ident(j?.agent_type, 60) ? { agentType: ident(j.agent_type, 60) } : {}),
         ...(ident(j?.agent_id, 100) ? { agentId: ident(j.agent_id, 100) } : {}),
+        // Kept for the proxy to READ, never to send. See `HookRecord.transcriptPath`.
+        ...(typeof j?.transcript_path === "string" && j.transcript_path ? { transcriptPath: j.transcript_path } : {}),
     };
 }
 /**

package/dist/proxy.js

@@ -14,7 +14,7 @@ import { applyObservation, heartbeatRequest, isClaimLost, isUnauthorized, should
 import { AUTO_WORKSPACE, resolveConn } from "./lib/keystore.js";
 import { toolResult as parseTool } from "./lib/toolresult.js";
 import { mintSessionKey, appendFallbackNotice, recordSession, nameWorkspace, RPC_ID } from "./lib/session.js";
-import { readHookRecord, clearHookRecord } from "./lib/sessionHook.js";
+import { readHookRecord, clearHookRecord, modelFromTranscript } from "./lib/sessionHook.js";
 import { attachRoot, isLocalAttachCall, mergeAttachTool, readAttachFile, resolveAttachPath, uploadFailureMessage, uploadUrlWith, } from "./lib/attachFile.js";
 import { MAX_FETCH_BYTES, downloadFailureMessage, existingDownload, isLocalFetchCall, mergeFetchTool, resolveDownloadTarget, writeDownloadedFile, } from "./lib/fetchFile.js";
 // RTSC-92/98: resolve the workspace key via the SHARED resolver, so the proxy and
@@ -62,6 +62,7 @@ let transcriptRecorded = false;
 // longer the end of this proxy's interest in the record.
 let reportedModel;
 let lastModelCheckAt = 0;
+let pendingModel;
 const MODEL_CHECK_INTERVAL_MS = 3_000;
 let transcriptLookups = 0;
 let transcriptInFlight = null;
@@ -233,6 +234,24 @@ function ownRecordModel() {
     const rec = readHookRecord(process.cwd(), { maxAgeMs: Number.POSITIVE_INFINITY });
     if (!rec || rec.sessionId !== transcript.id)
         return undefined;
+    // RTSC-832 — the TRANSCRIPT is the authority, and the only source that works at all
+    // for a session nobody ran `/model` in: Claude Code 2.1.261 puts no `model` in the
+    // SessionStart payload (captured 2026-09-05), so `rec.model` is set only by the
+    // PostModelSwitch hook. The file has one on every assistant message, newest last,
+    // so reading it covers the plain case AND a switch. `rec.model` stays as the fallback
+    // for a harness that reports a model but writes no transcript we can read.
+    // The switch hook is FRESHER than the file: right after `/model`, `rec.model` already
+    // holds the new one while the newest assistant line still holds the old. Preferring
+    // the file here delayed a switch to the next turn and lost it entirely if the session
+    // ended first, which 1.42.0 got right. Once reported, this falls through and the file
+    // is authoritative again (it also catches a switch that produced no hook at all).
+    if (rec.model && rec.model !== reportedModel)
+        return rec.model;
+    if (rec.transcriptPath) {
+        const fromFile = modelFromTranscript(rec.transcriptPath);
+        if (fromFile)
+            return fromFile;
+    }
     return rec.model;
 }
 /**
@@ -252,8 +271,10 @@ function modelMayHaveChanged() {
     if (now - lastModelCheckAt < MODEL_CHECK_INTERVAL_MS)
         return false;
     lastModelCheckAt = now;
-    const model = ownRecordModel();
-    return !!model && model !== reportedModel;
+    // Cached for the reporter that runs next: this whole path is synchronous on the
+    // response path, and scanning the transcript twice per change tick is pure waste.
+    pendingModel = ownRecordModel();
+    return !!pendingModel && pendingModel !== reportedModel;
 }
 async function reportTranscriptOnce() {
     // One budget for looking AND for asking: a server that keeps refusing is not asked
@@ -263,7 +284,8 @@ async function reportTranscriptOnce() {
     transcriptLookups += 1;
     if (transcriptRecorded) {
         // Recorded already, so we are here only for a model change — and only for OURS.
-        const model = ownRecordModel();
+        // `modelMayHaveChanged` just did this scan; reuse it rather than paying it twice.
+        const model = pendingModel ?? ownRecordModel();
         if (!model || model === reportedModel || !transcript)
             return;
         const switched = await recordSession({ url: MCP_URL, key: activeKey, transcriptId: transcript.id, harness: transcript.harness, model, warn: log });
@@ -293,7 +315,11 @@ async function reportTranscriptOnce() {
         // harness, not our record (a Codex pane opened in a folder a Claude hook wrote for).
         if (rec.harness === "claude-code" && clientName && !/claude/i.test(clientName))
             return;
-        transcript = { id: rec.sessionId, harness: rec.harness, model: rec.model, agentType: rec.agentType, agentId: rec.agentId };
+        // RTSC-832 — the transcript usually has no assistant message yet at this point, so
+        // this is normally undefined and the model arrives on a later re-report. It matters
+        // when the proxy comes up mid-session (a restart), where the file already has one.
+        const startModel = (rec.transcriptPath ? modelFromTranscript(rec.transcriptPath) : undefined) ?? rec.model;
+        transcript = { id: rec.sessionId, harness: rec.harness, model: startModel, agentType: rec.agentType, agentId: rec.agentId };
     }
     const ok = await recordSession({
         url: MCP_URL,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@retasc/cli",
-  "version": "1.42.0",
+  "version": "1.42.1",
   "description": "Retasc CLI — the issue tracker AI agents pull work from. Sign in with GitHub or Google, create projects, mint agent API keys, and wire your agent to the Retasc MCP server in one command.",
   "type": "module",
   "bin": {