switchroom 0.14.4 → 0.14.5

package/dist/cli/switchroom.js

@@ -49352,8 +49352,8 @@ var {
 } = import__.default;
 
 // src/build-info.ts
-var VERSION = "0.14.4";
-var COMMIT_SHA = "a9f2d29a";
+var VERSION = "0.14.5";
+var COMMIT_SHA = "c12d4240";
 
 // src/cli/agent.ts
 init_source();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "switchroom",
-  "version": "0.14.4",
+  "version": "0.14.5",
   "description": "Run Claude Code 24/7 on your Claude Pro/Max subscription over Telegram. Open-source alternative to OpenClaw and NanoClaw — no API keys.",
   "type": "module",
   "bin": {

package/telegram-plugin/dist/bridge/bridge.js

@@ -23422,6 +23422,46 @@ function extractAssistantText(obj) {
   }
   return parts.join(" ").trim();
 }
+function computeFirstAttachCursor(file, size) {
+  const SCAN_CAP = 1024 * 1024;
+  const scanStart = Math.max(0, size - SCAN_CAP);
+  let buf;
+  try {
+    const fd = openSync(file, "r");
+    try {
+      buf = Buffer.allocUnsafe(size - scanStart);
+      readSync(fd, buf, 0, buf.length, scanStart);
+    } finally {
+      closeSync(fd);
+    }
+  } catch {
+    return size;
+  }
+  let lastEnqueueOffset = -1;
+  let turnEndedAfterEnqueue = false;
+  let lineStart = 0;
+  let skipPartial = scanStart > 0;
+  for (let i = 0;i <= buf.length; i++) {
+    if (i !== buf.length && buf[i] !== 10)
+      continue;
+    if (skipPartial) {
+      skipPartial = false;
+    } else if (i > lineStart) {
+      const line = buf.toString("utf8", lineStart, i);
+      if (line.includes('"type":"queue-operation"') && line.includes('"operation":"enqueue"')) {
+        lastEnqueueOffset = scanStart + lineStart;
+        turnEndedAfterEnqueue = false;
+      } else if (lastEnqueueOffset >= 0 && line.includes('"subtype":"turn_duration"')) {
+        turnEndedAfterEnqueue = true;
+      }
+    }
+    lineStart = i + 1;
+  }
+  if (lastEnqueueOffset >= 0 && !turnEndedAfterEnqueue) {
+    return lastEnqueueOffset;
+  }
+  return size;
+}
 function startSessionTail(config2) {
   const cwd = config2.cwd ?? process.cwd();
   const claudeHome = config2.claudeHome ?? process.env.CLAUDE_CONFIG_DIR ?? join3(homedir2(), ".claude");
@@ -23558,11 +23598,16 @@ function startSessionTail(config2) {
     } else {
       pendingPartial = "";
       try {
-        cursor = statSync3(file).size;
+        const size = statSync3(file).size;
+        cursor = computeFirstAttachCursor(file, size);
+        if (cursor < size) {
+          log?.(`session-tail: attached to ${file} (cursor=${cursor}, replaying in-flight turn from offset; size=${size})`);
+        } else {
+          log?.(`session-tail: attached to ${file} (cursor=${cursor})`);
+        }
       } catch {
         cursor = 0;
       }
-      log?.(`session-tail: attached to ${file} (cursor=${cursor})`);
     }
     const attachSid = sessionIdForFile(file);
     if (attachSid)

package/telegram-plugin/dist/gateway/gateway.js

@@ -50068,11 +50068,11 @@ function sweepStaleTurnActiveMarker(stateDir, opts) {
 }
 
 // ../src/build-info.ts
-var VERSION = "0.14.4";
-var COMMIT_SHA = "a9f2d29a";
-var COMMIT_DATE = "2026-05-28T20:55:22+10:00";
+var VERSION = "0.14.5";
+var COMMIT_SHA = "c12d4240";
+var COMMIT_DATE = "2026-05-28T21:57:39+10:00";
 var LATEST_PR = null;
-var COMMITS_AHEAD_OF_TAG = 5;
+var COMMITS_AHEAD_OF_TAG = 2;
 
 // gateway/boot-version.ts
 function formatRelativeAgo(iso) {

package/telegram-plugin/dist/server.js

@@ -17460,6 +17460,46 @@ function extractAssistantText(obj) {
   }
   return parts.join(" ").trim();
 }
+function computeFirstAttachCursor(file, size) {
+  const SCAN_CAP = 1024 * 1024;
+  const scanStart = Math.max(0, size - SCAN_CAP);
+  let buf;
+  try {
+    const fd = openSync(file, "r");
+    try {
+      buf = Buffer.allocUnsafe(size - scanStart);
+      readSync(fd, buf, 0, buf.length, scanStart);
+    } finally {
+      closeSync(fd);
+    }
+  } catch {
+    return size;
+  }
+  let lastEnqueueOffset = -1;
+  let turnEndedAfterEnqueue = false;
+  let lineStart = 0;
+  let skipPartial = scanStart > 0;
+  for (let i = 0;i <= buf.length; i++) {
+    if (i !== buf.length && buf[i] !== 10)
+      continue;
+    if (skipPartial) {
+      skipPartial = false;
+    } else if (i > lineStart) {
+      const line = buf.toString("utf8", lineStart, i);
+      if (line.includes('"type":"queue-operation"') && line.includes('"operation":"enqueue"')) {
+        lastEnqueueOffset = scanStart + lineStart;
+        turnEndedAfterEnqueue = false;
+      } else if (lastEnqueueOffset >= 0 && line.includes('"subtype":"turn_duration"')) {
+        turnEndedAfterEnqueue = true;
+      }
+    }
+    lineStart = i + 1;
+  }
+  if (lastEnqueueOffset >= 0 && !turnEndedAfterEnqueue) {
+    return lastEnqueueOffset;
+  }
+  return size;
+}
 function startSessionTail(config2) {
   const cwd = config2.cwd ?? process.cwd();
   const claudeHome = config2.claudeHome ?? process.env.CLAUDE_CONFIG_DIR ?? join4(homedir3(), ".claude");
@@ -17596,11 +17636,16 @@ function startSessionTail(config2) {
     } else {
       pendingPartial = "";
       try {
-        cursor = statSync4(file).size;
+        const size = statSync4(file).size;
+        cursor = computeFirstAttachCursor(file, size);
+        if (cursor < size) {
+          log?.(`session-tail: attached to ${file} (cursor=${cursor}, replaying in-flight turn from offset; size=${size})`);
+        } else {
+          log?.(`session-tail: attached to ${file} (cursor=${cursor})`);
+        }
       } catch {
         cursor = 0;
       }
-      log?.(`session-tail: attached to ${file} (cursor=${cursor})`);
     }
     const attachSid = sessionIdForFile(file);
     if (attachSid)

package/telegram-plugin/session-tail.ts

@@ -603,6 +603,66 @@ export interface SessionTailHandle {
   getActiveFile(): string | null
 }
 
+/**
+ * Byte offset to seek to on the FIRST attach to a session transcript.
+ *
+ * Normally EOF — we only want NEW events, not replayed history. But if the
+ * agent restarted MID-TURN (the bridge's session-tail starts only after
+ * claude has already written this turn's `queue-operation enqueue` line),
+ * a plain seek-to-EOF skips that enqueue. `enqueue` is the ONLY event that
+ * carries the chatId and that sets the gateway's `currentTurn`, so missing
+ * it leaves the first post-restart turn with no currentTurn — killing the
+ * progress card, draft-mirror, and silence-poke for that turn.
+ *
+ * Fix: in a bounded tail scan, find the last `enqueue` that has NO
+ * `turn_duration` (turn_end) after it — an in-flight turn — and return its
+ * line offset so it (and the turn's subsequent events) replay. A completed
+ * turn (a `turn_duration` follows the enqueue) returns EOF: no replay.
+ */
+export function computeFirstAttachCursor(file: string, size: number): number {
+  const SCAN_CAP = 1024 * 1024 // bound the tail read at 1 MiB
+  const scanStart = Math.max(0, size - SCAN_CAP)
+  let buf: Buffer
+  try {
+    const fd = openSync(file, 'r')
+    try {
+      buf = Buffer.allocUnsafe(size - scanStart)
+      readSync(fd, buf, 0, buf.length, scanStart)
+    } finally {
+      closeSync(fd)
+    }
+  } catch {
+    return size
+  }
+  let lastEnqueueOffset = -1
+  let turnEndedAfterEnqueue = false
+  let lineStart = 0
+  // If the scan didn't start at byte 0, the first line is a partial — skip it.
+  let skipPartial = scanStart > 0
+  for (let i = 0; i <= buf.length; i++) {
+    if (i !== buf.length && buf[i] !== 0x0a) continue
+    if (skipPartial) {
+      skipPartial = false
+    } else if (i > lineStart) {
+      const line = buf.toString('utf8', lineStart, i)
+      if (
+        line.includes('"type":"queue-operation"') &&
+        line.includes('"operation":"enqueue"')
+      ) {
+        lastEnqueueOffset = scanStart + lineStart
+        turnEndedAfterEnqueue = false
+      } else if (lastEnqueueOffset >= 0 && line.includes('"subtype":"turn_duration"')) {
+        turnEndedAfterEnqueue = true
+      }
+    }
+    lineStart = i + 1
+  }
+  if (lastEnqueueOffset >= 0 && !turnEndedAfterEnqueue) {
+    return lastEnqueueOffset
+  }
+  return size
+}
+
 /**
  * Start tailing the active Claude Code session file. The tailer:
  *  1. Polls the projects dir for the most recent .jsonl
@@ -778,14 +838,20 @@ export function startSessionTail(config: SessionTailConfig): SessionTailHandle {
       log?.(`session-tail: re-attached to ${file} (cursor=${cursor}, restored)`)
     } else {
       // First attach to this file — seek to current end so we only see
-      // new events, not history.
+      // new events, EXCEPT replay from an in-flight turn's enqueue if the
+      // agent restarted mid-turn (see firstAttachCursor).
       pendingPartial = ''
       try {
-        cursor = statSync(file).size
+        const size = statSync(file).size
+        cursor = computeFirstAttachCursor(file, size)
+        if (cursor < size) {
+          log?.(`session-tail: attached to ${file} (cursor=${cursor}, replaying in-flight turn from offset; size=${size})`)
+        } else {
+          log?.(`session-tail: attached to ${file} (cursor=${cursor})`)
+        }
       } catch {
         cursor = 0
       }
-      log?.(`session-tail: attached to ${file} (cursor=${cursor})`)
     }
     // Eagerly create + subscribe the PreToolUse sidecar for this session
     // NOW (on attach), not lazily on the first JSONL tool_use — otherwise

package/telegram-plugin/tests/session-tail-first-attach.test.ts

@@ -0,0 +1,65 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest'
+import { mkdtempSync, rmSync, writeFileSync, statSync } from 'node:fs'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import { computeFirstAttachCursor } from '../session-tail.js'
+
+/**
+ * computeFirstAttachCursor: on first attach to a transcript, seek to EOF
+ * UNLESS the agent restarted mid-turn (an `enqueue` with no `turn_duration`
+ * after it). Missing that enqueue strands the first post-restart turn with
+ * no currentTurn (dead progress card / draft-mirror / silence-poke).
+ */
+
+const ENQUEUE = '{"type":"queue-operation","operation":"enqueue","content":"chat:123 msg:1"}'
+const DEQUEUE = '{"type":"queue-operation","operation":"dequeue"}'
+const ASSISTANT = '{"type":"assistant","message":{"content":[{"type":"text","text":"hi"}]}}'
+const TURN_DURATION = '{"type":"system","subtype":"turn_duration","durationMs":4200}'
+
+function writeTranscript(dir: string, lines: string[]): { file: string; size: number } {
+  const file = join(dir, 'sess.jsonl')
+  writeFileSync(file, lines.join('\n') + '\n')
+  return { file, size: statSync(file).size }
+}
+
+function offsetOfLine(lines: string[], index: number): number {
+  let off = 0
+  for (let i = 0; i < index; i++) off += Buffer.byteLength(lines[i]!, 'utf8') + 1 // +1 for '\n'
+  return off
+}
+
+describe('computeFirstAttachCursor', () => {
+  let dir: string
+  beforeEach(() => { dir = mkdtempSync(join(tmpdir(), 'first-attach-')) })
+  afterEach(() => { rmSync(dir, { recursive: true, force: true }) })
+
+  it('in-flight turn (enqueue, no turn_duration after) → replays from the enqueue offset', () => {
+    const lines = [ASSISTANT, ENQUEUE, DEQUEUE, ASSISTANT] // enqueue at index 1, no turn_duration
+    const { file, size } = writeTranscript(dir, lines)
+    expect(computeFirstAttachCursor(file, size)).toBe(offsetOfLine(lines, 1))
+  })
+
+  it('completed turn (turn_duration after the enqueue) → EOF, no replay', () => {
+    const lines = [ENQUEUE, DEQUEUE, ASSISTANT, TURN_DURATION]
+    const { file, size } = writeTranscript(dir, lines)
+    expect(computeFirstAttachCursor(file, size)).toBe(size)
+  })
+
+  it('no enqueue in the tail → EOF', () => {
+    const lines = [ASSISTANT, ASSISTANT, TURN_DURATION]
+    const { file, size } = writeTranscript(dir, lines)
+    expect(computeFirstAttachCursor(file, size)).toBe(size)
+  })
+
+  it('completed turn followed by a NEW in-flight turn → replays from the second enqueue', () => {
+    // turn 1: enqueue+turn_duration (done). turn 2: enqueue, still running.
+    const lines = [ENQUEUE, ASSISTANT, TURN_DURATION, ENQUEUE, DEQUEUE, ASSISTANT]
+    const { file, size } = writeTranscript(dir, lines)
+    expect(computeFirstAttachCursor(file, size)).toBe(offsetOfLine(lines, 3))
+  })
+
+  it('empty / missing file → returns the given size (degrades to EOF)', () => {
+    const missing = join(dir, 'nope.jsonl')
+    expect(computeFirstAttachCursor(missing, 0)).toBe(0)
+  })
+})