@gotcos/glasses-server 6.48.1 → 6.48.2

package/CHANGELOG.md

@@ -1,3 +1,11 @@
+## 6.48.2
+
+Continue and Fork work again on a session whose transcript opens with a big row. Reported from the lens on 6.9.482 (Miles, 2026-09-15): Continue on a Claude session answered "Can't continue. Fork thread instead" while the row said the session was attachable.
+
+- The attach route reads the session's working directory out of the transcript's first rows. It read a fixed 512 KiB, and a session whose first prompt carried pasted screenshots opens with one row of about 1 MB, so the window held four bookkeeping rows and a torn fifth, no `cwd`, and every Continue and Fork on that session was refused `target_unresolvable`. The read now widens (512 KiB, 2 MiB, 8 MiB, 16 MiB) while the window keeps ending inside a row with no `cwd` seen, and stops as soon as the whole file has been read or a row boundary shows the transcript records none.
+- The first `cwd` in the transcript is the workspace. Two different values used to refuse the attach as a disagreement; on the release Mac every such transcript was one session whose shell had `cd`-ed into a subfolder inside a turn, and Claude stamps each row with the process cwd of the moment. The directory the session started in keys its project folder and is the only place `--resume` finds it, so it is the answer. On the release Mac 738 of 758 transcripts resolve (before: 703); the 20 that do not are scratch sessions whose temporary directory has since been deleted, which is a refusal by design.
+- Tests: the first-cwd rule for Claude and Codex, the torn-window signal, the widening sequence against the production shape (four bookkeeping rows, a 950 KB image row, then the cwd), a short file read once, a first row past the cap refused at the cap. Mutation gate: the widening and the first-cwd rule.
+
 ## 6.48.1
 
 One derivation everywhere, a Desktop turn ends when the engine says it ended, a queued follow-up drains then instead of on the 30 s idle window, and the live feed carries the same state every row does. No client change is required: the next Control and EHPK builds read the new keys, and today's consumers ignore them.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gotcos/glasses-server",
-  "version": "6.48.1",
+  "version": "6.48.2",
   "description": "COS Glasses \u2014 self-hosted AI heads-up-display server for Even G2 smart glasses, powered by Claude Code, Codex, Cursor Agent CLI, or local Ollama",
   "type": "module",
   "bin": {

package/server/lib/attached-workspace.ts

@@ -61,9 +61,20 @@ export interface AttachedWorkspaceDeps {
   cursorSpawnWorkspace?: (threadId: string) => string | null
 }
 
-/** Enough to reach a Claude message row or the Codex session meta row. */
+/**
+ * The first window read for the cwd: enough to reach a Claude message row or the Codex
+ * session meta row in the common case. NOT enough on its own (6.48.2): a session whose
+ * first prompt carries pasted screenshots opens with a single row of ~1 MB, so 512 KiB
+ * held four bookkeeping rows and a torn fifth, no cwd, and every Continue on that
+ * session was refused `target_unresolvable` (Miles, 2026-09-15, from the lens; 55 of
+ * 758 transcripts on the release Mac). When a window ends inside a row before any cwd
+ * was seen, the read widens up to WORKSPACE_SCAN_BYTES_MAX.
+ */
 export const WORKSPACE_SCAN_BYTES = 512 * 1024
 
+/** The widest head read: a first prompt with ten screenshots fits; a 13 GB rollout does not get read. */
+export const WORKSPACE_SCAN_BYTES_MAX = 16 * 1024 * 1024
+
 /** Rows to inspect before giving up. Bounds a pathological single-line file. */
 export const WORKSPACE_SCAN_ROWS = 400
 
@@ -72,19 +83,37 @@ export function fingerprint(value: string): string {
 }
 
 /**
- * Pull the recorded cwd out of transcript text.
+ * Pull the recorded cwd out of transcript text: the FIRST row that records one.
  *
  * Claude puts it at the row's top level; Codex puts it in the session meta row's
  * `payload`. A torn trailing line is NORMAL — these files are appended to — so a
  * parse failure on any single row is skipped rather than fatal.
  *
- * Returns null when no row records one, and DISAGREEMENT is also null: a transcript
- * whose rows claim two different working directories is not something to guess at.
+ * THE FIRST cwd IS THE WORKSPACE (6.48.2). Until 6.48.1 two different values in the
+ * window refused the attach as a disagreement. On the release Mac every such
+ * transcript was one session whose shell `cd`-ed inside a turn (`operations/scripts`,
+ * a weekly folder): Claude stamps each row with the process cwd of the moment, all
+ * under the directory the session was started in. That starting directory is the
+ * workspace: it keys the transcript's project folder, it is the only place
+ * `claude --resume` finds the session, and it is what the first row records.
+ *
+ * Returns null only when no row in the window records one.
  */
 export function cwdFromTranscript(text: string): string | null {
-  const seen = new Set<string>()
+  return scanForCwd(text).cwd
+}
+
+/**
+ * The scan with its outcome: the cwd, or whether the window ended INSIDE a row before
+ * any cwd was seen (a first prompt of pasted screenshots is one row of ~1 MB), which
+ * tells the resolver that a wider read can still answer.
+ */
+export function scanForCwd(text: string): { cwd: string | null; endedMidRow: boolean; rows: number } {
   let rows = 0
-  for (const line of text.split('\n')) {
+  const lines = text.split('\n')
+  // A window that does not end with a newline ended inside whatever row came last.
+  const endedMidRow = text.length > 0 && !text.endsWith('\n')
+  for (const line of lines) {
     if (rows >= WORKSPACE_SCAN_ROWS) break
     const trimmed = line.trim()
     if (!trimmed) continue
@@ -94,18 +123,14 @@ export function cwdFromTranscript(text: string): string | null {
     if (!row || typeof row !== 'object' || Array.isArray(row)) continue
     const record = row as Record<string, unknown>
     const direct = record.cwd
-    if (typeof direct === 'string' && direct.length > 0) seen.add(direct)
+    if (typeof direct === 'string' && direct.length > 0) return { cwd: direct, endedMidRow: false, rows }
     const payload = record.payload
     if (payload && typeof payload === 'object' && !Array.isArray(payload)) {
       const nested = (payload as Record<string, unknown>).cwd
-      if (typeof nested === 'string' && nested.length > 0) seen.add(nested)
+      if (typeof nested === 'string' && nested.length > 0) return { cwd: nested, endedMidRow: false, rows }
     }
-    // One consistent answer found early is enough; keep scanning only while it is
-    // still the only one, so a disagreement is detected rather than short-circuited.
-    if (seen.size > 1) return null
   }
-  if (seen.size !== 1) return null
-  return [...seen][0]!
+  return { cwd: null, endedMidRow, rows }
 }
 
 /**
@@ -145,17 +170,27 @@ export function resolveAttachedWorkspace(
   }
   if (provider !== 'claude' && provider !== 'codex') return null
   let path: string | null
-  let text: string | null
+  let cwd: string | null = null
   try {
     path = deps.transcriptPath(provider, threadId)
     if (path === null) return null
-    text = deps.readHead(path, WORKSPACE_SCAN_BYTES)
+    // Widen the head read while the window keeps ending inside a row with no cwd seen:
+    // 512 KiB, 2 MiB, 8 MiB, then the cap. A window that ended on a row boundary with
+    // no cwd is a transcript that records none, and widening would not change that.
+    let window = WORKSPACE_SCAN_BYTES
+    for (;;) {
+      const text = deps.readHead(path, window)
+      if (text === null) return null
+      const scan = scanForCwd(text)
+      cwd = scan.cwd
+      // The whole file came back (shorter than the window): there is nothing wider to read.
+      const wholeFile = Buffer.byteLength(text, 'utf8') < window
+      if (cwd !== null || wholeFile || !scan.endedMidRow || scan.rows >= WORKSPACE_SCAN_ROWS || window >= WORKSPACE_SCAN_BYTES_MAX) break
+      window = Math.min(window * 4, WORKSPACE_SCAN_BYTES_MAX)
+    }
   } catch {
     return null
   }
-  if (text === null) return null
-
-  const cwd = cwdFromTranscript(text)
   if (cwd === null) return null
   // A relative cwd would resolve against the SERVER's working directory, which is
   // not a location we control and is never what the user meant.