oh-my-codex 0.14.4 → 0.15.1

package/src/scripts/codex-native-pre-post.ts

@@ -1,5 +1,13 @@
+import {
+  buildDocumentRefreshAdvisoryOutput,
+  evaluateStagedDocumentRefresh,
+} from "../document-refresh/enforcer.js";
+import { resolveCodexExecutionSurface } from "./codex-execution-surface.js";
+
 type CodexHookPayload = Record<string, unknown>;
 
+type GitRepositorySelection = "current-cwd" | "explicit-target";
+
 export interface NormalizedPreToolUsePayload {
   toolName: string;
   toolUseId: string;
@@ -45,6 +53,16 @@ function safeObject(value: unknown): Record<string, unknown> | null {
     : null;
 }
 
+function isNativeOutsideTmuxSurface(payload: CodexHookPayload): boolean {
+  const cwd = safeString(payload.cwd).trim() || process.cwd();
+  const surface = resolveCodexExecutionSurface(cwd, {
+    hookEventName: "PreToolUse",
+    payload,
+    nativeSessionId: safeString(payload.session_id ?? payload.sessionId).trim(),
+  });
+  return surface.launcher === "native" && surface.transport === "outside-tmux";
+}
+
 function tryParseJsonString(value: unknown): Record<string, unknown> | null {
   const text = safeString(value).trim();
   if (!text) return null;
@@ -134,6 +152,7 @@ export function detectMcpTransportFailure(
   payload: CodexHookPayload,
 ): McpTransportFailureSignal | null {
   const normalized = normalizePostToolUsePayload(payload);
+  if (normalized.isBash) return null;
   const combined = [
     normalized.stderrText,
     normalized.stdoutText,
@@ -268,6 +287,7 @@ function tokenizeShellCommand(commandText: string): string[] | null {
 interface GitCommitCommandParseResult {
   isGitCommit: boolean;
   inlineMessage: string | null;
+  repositorySelection: GitRepositorySelection;
   requiresExternalMessageSource: boolean;
 }
 
@@ -348,6 +368,14 @@ function gitOptionConsumesNextValue(token: string): boolean {
     || token === "--attr-source";
 }
 
+function gitOptionSelectsRepository(token: string): boolean {
+  return token === "-C"
+    || token === "--git-dir"
+    || token === "--work-tree"
+    || token.startsWith("--git-dir=")
+    || token.startsWith("--work-tree=");
+}
+
 function gitOptionStopsBeforeSubcommand(token: string): boolean {
   return token === "-h"
     || token === "--help"
@@ -382,12 +410,22 @@ function findGitSubcommandIndex(tokens: string[], gitTokenIndex: number): number
   return index < tokens.length ? index : -1;
 }
 
-function parseGitCommitCommand(commandText: string): GitCommitCommandParseResult {
+function readGitRepositorySelection(tokens: string[], gitTokenIndex: number, subcommandIndex: number): GitRepositorySelection {
+  for (let index = gitTokenIndex + 1; index < subcommandIndex; index += 1) {
+    const token = tokens[index] ?? "";
+    if (gitOptionSelectsRepository(token)) return "explicit-target";
+    if (gitOptionConsumesNextValue(token)) index += 1;
+  }
+  return "current-cwd";
+}
+
+export function parseGitCommitCommand(commandText: string): GitCommitCommandParseResult {
   const tokens = tokenizeShellCommand(commandText);
   if (!tokens) {
     return {
       isGitCommit: false,
       inlineMessage: null,
+      repositorySelection: "current-cwd",
       requiresExternalMessageSource: false,
     };
   }
@@ -397,6 +435,7 @@ function parseGitCommitCommand(commandText: string): GitCommitCommandParseResult
     return {
       isGitCommit: false,
       inlineMessage: null,
+      repositorySelection: "current-cwd",
       requiresExternalMessageSource: false,
     };
   }
@@ -406,10 +445,12 @@ function parseGitCommitCommand(commandText: string): GitCommitCommandParseResult
     return {
       isGitCommit: false,
       inlineMessage: null,
+      repositorySelection: "current-cwd",
       requiresExternalMessageSource: false,
     };
   }
 
+  const repositorySelection = readGitRepositorySelection(tokens, gitTokenIndex, subcommandIndex);
   const messageParts: string[] = [];
   let requiresExternalMessageSource = false;
   const args = tokens.slice(subcommandIndex + 1);
@@ -452,6 +493,7 @@ function parseGitCommitCommand(commandText: string): GitCommitCommandParseResult
   return {
     isGitCommit: true,
     inlineMessage: messageParts.length > 0 ? messageParts.join("\n\n").trim() : null,
+    repositorySelection,
     requiresExternalMessageSource,
   };
 }
@@ -550,10 +592,6 @@ function buildGitCommitEnforcementOutput(commandText: string): Record<string, un
       "git commit is blocked until the inline commit message satisfies the Lore format and includes the required OmX co-author trailer.",
     hookSpecificOutput: {
       hookEventName: "PreToolUse",
-      additionalContext: [
-        "Lore-format git commit enforcement triggered.",
-        ...errors.map((error) => `- ${error}`),
-      ].join("\n"),
     },
     systemMessage: [
       "git commit is blocked until the inline commit message follows the Lore protocol and includes `Co-authored-by: OmX <omx@oh-my-codex.dev>`.",
@@ -562,6 +600,22 @@ function buildGitCommitEnforcementOutput(commandText: string): Record<string, un
   };
 }
 
+
+function buildDocumentRefreshPreToolUseOutput(
+  commandText: string,
+  cwd: string,
+): Record<string, unknown> | null {
+  const parsed = parseGitCommitCommand(commandText);
+  if (!parsed.isGitCommit) return null;
+
+  if (parsed.repositorySelection !== "current-cwd") return null;
+
+  const warning = evaluateStagedDocumentRefresh(cwd, parsed.inlineMessage);
+  if (!warning) return null;
+
+  return buildDocumentRefreshAdvisoryOutput(warning, "PreToolUse");
+}
+
 function commandInvokesOmxQuestion(command: string): boolean {
   const tokens = tokenizeShellCommand(command)?.map((token) => token.toLowerCase()) ?? [];
   for (let index = 0; index < tokens.length; index += 1) {
@@ -582,26 +636,95 @@ function isQuestionReturnPaneAssignment(token: string): boolean {
   return /^%\d+$/.test(value) || /^\$\{?TMUX_PANE\}?$/.test(value);
 }
 
+function hasInheritedQuestionReturnPaneBridge(): boolean {
+  // Intentionally trust only the explicit bridge envs that question renderer
+  // already accepts outside tmux; TMUX_PANE alone is not stable across all
+  // Bash/background-terminal tool paths that this enforcement protects.
+  const explicitPane = safeString(
+    process.env.OMX_QUESTION_RETURN_PANE || process.env.OMX_LEADER_PANE_ID,
+  ).trim();
+  return /^%\d+$/.test(explicitPane);
+}
+
+function commandHasPowerShellQuestionReturnPane(command: string): boolean {
+  return /\$env:(?:OMX_QUESTION_RETURN_PANE|OMX_LEADER_PANE_ID)\s*=\s*(?:['"]?%\d+['"]?|\$env:TMUX_PANE)\b/i.test(command)
+    || /\$env:TMUX_PANE\s*=\s*['"]?%\d+['"]?/i.test(command);
+}
+
 function commandHasQuestionReturnPane(command: string): boolean {
+  if (hasInheritedQuestionReturnPaneBridge()) return true;
+  if (commandHasPowerShellQuestionReturnPane(command)) return true;
   return (tokenizeShellCommand(command) ?? []).some(isQuestionReturnPaneAssignment);
 }
 
-function buildOmxQuestionPreToolUseEnforcementOutput(command: string): Record<string, unknown> | null {
+function commandInvokesOmxTeam(command: string): boolean {
+  const tokens = tokenizeShellCommand(command)?.map((token) => token.toLowerCase()) ?? [];
+  for (let index = 0; index < tokens.length; index += 1) {
+    const rawToken = tokens[index] || '';
+    const token = rawToken.replace(/\\/g, '/').split('/').pop() || '';
+    if ((token === 'omx' || token === 'omx.js') && tokens[index + 1] === 'team') return true;
+    if ((token === 'node' || token === 'node.exe') && /(?:^|\/)omx\.js$/.test(tokens[index + 1] || '') && tokens[index + 2] === 'team') return true;
+  }
+  return /\bomx\s+team\b/i.test(command) || /\bomx\.js['"]?\s+team\b/i.test(command);
+}
+
+function commandInvokesOmxHud(command: string): boolean {
+  const tokens = tokenizeShellCommand(command)?.map((token) => token.toLowerCase()) ?? [];
+  for (let index = 0; index < tokens.length; index += 1) {
+    const rawToken = tokens[index] || '';
+    const token = rawToken.replace(/\\/g, '/').split('/').pop() || '';
+    if ((token === 'omx' || token === 'omx.js') && tokens[index + 1] === 'hud') return true;
+    if ((token === 'node' || token === 'node.exe') && /(?:^|\/)omx\.js$/.test(tokens[index + 1] || '') && tokens[index + 2] === 'hud') return true;
+  }
+  return /\bomx\s+hud\b/i.test(command) || /\bomx\.js['"]?\s+hud\b/i.test(command);
+}
+
+function buildNativeOmxHudPreToolUseEnforcementOutput(
+  command: string,
+  payload: CodexHookPayload,
+): Record<string, unknown> | null {
+  if (!isNativeOutsideTmuxSurface(payload) || !commandInvokesOmxHud(command)) return null;
+
+  return {
+    decision: "block",
+    reason: "omx hud cannot be launched directly from Codex App/native outside-tmux Bash sessions.",
+    systemMessage: "omx hud is blocked from Bash in Codex App/native outside-tmux sessions; use SessionStart/HUD context instead, or launch OMX CLI from an attached tmux shell first for the tmux HUD runtime.",
+  };
+}
+
+function buildNativeOmxTeamPreToolUseEnforcementOutput(
+  command: string,
+  payload: CodexHookPayload,
+): Record<string, unknown> | null {
+  if (!isNativeOutsideTmuxSurface(payload) || !commandInvokesOmxTeam(command)) return null;
+
+  return {
+    decision: "block",
+    reason: "omx team cannot be launched directly from Codex App/native outside-tmux Bash sessions.",
+    systemMessage: `omx team is blocked from Bash in Codex App/native outside-tmux sessions; launch OMX CLI from an attached tmux shell first. Original command: ${command}`,
+  };
+}
+
+function buildOmxQuestionPreToolUseEnforcementOutput(
+  command: string,
+  payload: CodexHookPayload,
+): Record<string, unknown> | null {
   if (!commandInvokesOmxQuestion(command)) return null;
+
+  if (isNativeOutsideTmuxSurface(payload)) {
+    return {
+      decision: "block",
+      reason: "omx question cannot be launched directly from Codex App/native outside-tmux Bash sessions.",
+      systemMessage: `omx question is blocked from Codex App/native outside-tmux Bash because no attached tmux pane is available. Use the native structured question tool when available, or ask exactly one concise plain-text question. Original command: ${command}`,
+    };
+  }
+
   if (commandHasQuestionReturnPane(command)) return null;
 
   return {
     decision: "block",
     reason: "omx question Bash invocations must preserve the leader pane return target.",
-    hookSpecificOutput: {
-      hookEventName: "PreToolUse",
-      additionalContext: [
-        "omx question leader-pane enforcement triggered.",
-        "Prefix the Bash command with `OMX_QUESTION_RETURN_PANE=$TMUX_PANE` (or a concrete `%pane` value) so `[omx question answered]` returns to the leader pane even when the tool path drops/stales TMUX_PANE.",
-        `Original command: ${command}`,
-      ].join("\n"),
-    },
-    systemMessage: "omx question is blocked from Bash until the command preserves the leader pane with `OMX_QUESTION_RETURN_PANE=$TMUX_PANE` or an explicit `%pane` value.",
+    systemMessage: `omx question is blocked from Bash until the command preserves the leader pane with \`OMX_QUESTION_RETURN_PANE=$TMUX_PANE\` or an explicit \`%pane\` value. Original command: ${command}`,
   };
 }
 
@@ -612,8 +735,17 @@ export function buildNativePreToolUseOutput(
   if (!normalized.isBash) return null;
   const gitCommitEnforcement = buildGitCommitEnforcementOutput(normalized.normalizedCommand);
   if (gitCommitEnforcement) return gitCommitEnforcement;
-  const questionEnforcement = buildOmxQuestionPreToolUseEnforcementOutput(normalized.normalizedCommand);
+  const hudEnforcement = buildNativeOmxHudPreToolUseEnforcementOutput(normalized.normalizedCommand, payload);
+  if (hudEnforcement) return hudEnforcement;
+  const teamEnforcement = buildNativeOmxTeamPreToolUseEnforcementOutput(normalized.normalizedCommand, payload);
+  if (teamEnforcement) return teamEnforcement;
+  const questionEnforcement = buildOmxQuestionPreToolUseEnforcementOutput(normalized.normalizedCommand, payload);
   if (questionEnforcement) return questionEnforcement;
+  const documentRefreshWarning = buildDocumentRefreshPreToolUseOutput(
+    normalized.normalizedCommand,
+    safeString(payload.cwd).trim() || process.cwd(),
+  );
+  if (documentRefreshWarning) return documentRefreshWarning;
   if (!matchesDestructiveFixture(normalized.normalizedCommand)) return null;
 
   return {
@@ -629,10 +761,17 @@ function containsHardFailure(text: string): boolean {
   return /command not found|permission denied|no such file or directory/i.test(text);
 }
 
+function hasActionableBashHardFailure(normalized: NormalizedPostToolUsePayload): boolean {
+  if (containsHardFailure(normalized.stderrText)) return true;
+  if (normalized.exitCode === null || normalized.exitCode === 0) return false;
+  return containsHardFailure(`${normalized.stderrText}\n${normalized.stdoutText}`);
+}
+
 export function buildNativePostToolUseOutput(
   payload: CodexHookPayload,
 ): Record<string, unknown> | null {
-  const mcpTransportFailure = detectMcpTransportFailure(payload);
+  const normalized = normalizePostToolUsePayload(payload);
+  const mcpTransportFailure = normalized.isBash ? null : detectMcpTransportFailure(payload);
   if (mcpTransportFailure) {
     const fallbackCommand = buildOmxParityFallbackCommand(payload, mcpTransportFailure.toolName);
     const fallbackText = fallbackCommand
@@ -649,11 +788,10 @@ export function buildNativePostToolUseOutput(
     };
   }
 
-  const normalized = normalizePostToolUsePayload(payload);
   if (!normalized.isBash) return null;
 
   const combined = `${normalized.stderrText}\n${normalized.stdoutText}`.trim();
-  if (containsHardFailure(combined)) {
+  if (hasActionableBashHardFailure(normalized)) {
     return {
       decision: "block",
       reason: "The Bash output indicates a command/setup failure that should be fixed before retrying.",

package/src/scripts/generate-release-body.ts

@@ -75,6 +75,15 @@ export function resolveCurrentTag(cwd: string, explicit?: string): string {
   throw new Error('unable to determine current release tag; pass --current-tag or set GITHUB_REF_NAME');
 }
 
+function isAncestorTag(cwd: string, possibleAncestor: string, currentTag: string): boolean {
+  const result = spawnSync('git', ['merge-base', '--is-ancestor', possibleAncestor, currentTag], {
+    cwd,
+    encoding: 'utf-8',
+    stdio: 'pipe',
+  });
+  return result.status === 0;
+}
+
 export function resolvePreviousTag(cwd: string, currentTag: string, explicit?: string): string | undefined {
   if (explicit) return explicit;
   const tags = runGit(['tag', '--list', 'v*', '--sort=-v:refname'], cwd, true)
@@ -83,8 +92,30 @@ export function resolvePreviousTag(cwd: string, currentTag: string, explicit?: s
     .filter(Boolean);
   if (tags.length === 0) return undefined;
   const currentIndex = tags.indexOf(currentTag);
-  if (currentIndex >= 0) return tags.slice(currentIndex + 1).find(Boolean);
-  return tags.find((tag) => tag !== currentTag);
+  const candidates = currentIndex >= 0
+    ? tags.slice(currentIndex + 1)
+    : tags.filter((tag) => tag !== currentTag);
+  return candidates.find((tag) => isAncestorTag(cwd, tag, currentTag));
+}
+
+function verifyGitCommitRef(cwd: string, ref: string, label: string): void {
+  if (!runGit(['rev-parse', '--verify', '--quiet', `${ref}^{commit}`], cwd, true)) {
+    throw new Error(`unable to verify ${label} ref for release compare: ${ref}`);
+  }
+}
+
+export function verifyCompareRange(cwd: string, currentTag: string, previousTag?: string): void {
+  if (!previousTag) return;
+  verifyGitCommitRef(cwd, previousTag, 'previous tag');
+  verifyGitCommitRef(cwd, currentTag, 'current tag');
+  const mergeBase = spawnSync('git', ['merge-base', '--is-ancestor', previousTag, currentTag], {
+    cwd,
+    encoding: 'utf-8',
+    stdio: 'pipe',
+  });
+  if (mergeBase.status !== 0) {
+    throw new Error(`invalid release compare range: ${previousTag} is not an ancestor of ${currentTag}`);
+  }
 }
 
 function normalizeContributors(contributors: Contributor[]): Contributor[] {
@@ -256,6 +287,7 @@ export async function generateReleaseBody(options: GenerateReleaseBodyOptions):
   const outPath = resolve(cwd, options.outPath);
   const currentTag = resolveCurrentTag(cwd, options.currentTag);
   const previousTag = resolvePreviousTag(cwd, currentTag, options.previousTag);
+  verifyCompareRange(cwd, currentTag, previousTag);
   const repo = options.repo || process.env.GITHUB_REPOSITORY || resolveRepositoryFromRemote(cwd);
   const contributors = await resolveContributors({
     cwd,

package/src/scripts/hook-derived-watcher.ts

@@ -1,9 +1,10 @@
 #!/usr/bin/env node
 
 import { existsSync } from 'fs';
-import { appendFile, mkdir, readFile, readdir, stat, writeFile } from 'fs/promises';
+import { appendFile, mkdir, open, readFile, readdir, stat, writeFile } from 'fs/promises';
 import { dirname, join, resolve } from 'path';
 import { homedir } from 'os';
+import { StringDecoder } from 'string_decoder';
 import {
   buildOperationalContext,
   classifyExecCommand,
@@ -40,6 +41,7 @@ interface FileMeta {
   partial: string;
   dispatched: number;
   currentTurnId: string;
+  decoder: StringDecoder;
 }
 
 interface PendingCall {
@@ -415,7 +417,9 @@ async function ensureTrackedFiles(): Promise<void> {
     const firstLine = await readFirstLine(path).catch(() => '');
     const meta = shouldTrackSessionMeta(firstLine);
     if (!meta) continue;
-    const size = (await stat(path).catch(() => ({ size: 0 }))).size || 0;
+    const fileStat = await stat(path).catch(() => null);
+    if (!fileStat) continue;
+    const size = fileStat.size || 0;
     const offset = runOnce ? 0 : size;
     fileState.set(path, {
       ...meta,
@@ -423,6 +427,7 @@ async function ensureTrackedFiles(): Promise<void> {
       partial: '',
       dispatched: 0,
       currentTurnId: '',
+      decoder: new StringDecoder('utf8'),
     });
   }
 }
@@ -504,16 +509,54 @@ async function processLine(meta: FileMeta, line: string): Promise<void> {
   meta.dispatched += 1;
 }
 
+async function readFileDelta(
+  path: string,
+  offset: number,
+  currentSize: number,
+): Promise<{ bytes: Buffer; nextOffset: number }> {
+  const length = currentSize - offset;
+  if (length <= 0) return { bytes: Buffer.alloc(0), nextOffset: offset };
+  const handle = await open(path, 'r');
+  try {
+    const buffer = Buffer.allocUnsafe(length);
+    let totalBytesRead = 0;
+    while (totalBytesRead < length) {
+      const { bytesRead } = await handle.read(
+        buffer,
+        totalBytesRead,
+        length - totalBytesRead,
+        offset + totalBytesRead,
+      );
+      if (bytesRead === 0) break;
+      totalBytesRead += bytesRead;
+    }
+    return {
+      bytes: buffer.subarray(0, totalBytesRead),
+      nextOffset: offset + totalBytesRead,
+    };
+  } finally {
+    await handle.close().catch(() => {});
+  }
+}
+
 async function pollFiles(): Promise<void> {
   for (const [path, meta] of fileState.entries()) {
-    const currentSize = (await stat(path).catch(() => ({ size: 0 }))).size || 0;
+    const fileStat = await stat(path).catch(() => null);
+    if (!fileStat) continue;
+    const currentSize = fileStat.size || 0;
+    if (currentSize < meta.offset) {
+      meta.offset = 0;
+      meta.partial = '';
+      meta.decoder = new StringDecoder('utf8');
+    }
     if (currentSize <= meta.offset) continue;
 
-    const content = await readFile(path, 'utf-8').catch(() => '');
-    if (!content) continue;
-
-    const delta = content.slice(meta.offset);
-    meta.offset = currentSize;
+    const read = await readFileDelta(path, meta.offset, currentSize).catch(() => null);
+    if (!read || read.bytes.length === 0) continue;
+    const { bytes, nextOffset } = read;
+    meta.offset = nextOffset;
+    const delta = meta.decoder.write(bytes);
+    if (!delta) continue;
     const merged = meta.partial + delta;
     const lines = merged.split('\n');
     meta.partial = lines.pop() || '';

package/src/scripts/notify-fallback-watcher.ts

@@ -5,6 +5,7 @@ import { appendFile, mkdir, open, readFile, readdir, rename, rm, stat, unlink, w
 import { spawnSync } from 'child_process';
 import { dirname, join, resolve } from 'path';
 import { homedir } from 'os';
+import { StringDecoder } from 'string_decoder';
 import { spawnPlatformCommandSync } from '../utils/platform-command.js';
 import { drainPendingTeamDispatch } from './notify-hook/team-dispatch.js';
 import {
@@ -93,6 +94,19 @@ function sleep(ms: number): Promise<void> {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
 
+let atomicJsonWriteCounter = 0;
+
+async function writeJsonObjectAtomically(path: string, value: unknown): Promise<void> {
+  const tempPath = `${path}.${process.pid}.${Date.now()}.${++atomicJsonWriteCounter}.tmp`;
+  try {
+    await writeFile(tempPath, JSON.stringify(value, null, 2));
+    await rename(tempPath, path);
+  } catch (error) {
+    await rm(tempPath, { force: true }).catch(() => {});
+    throw error;
+  }
+}
+
 async function waitForPidExit(pid: number, timeoutMs = 3000, stepMs = 50): Promise<boolean> {
   const deadline = Date.now() + timeoutMs;
   while (Date.now() < deadline) {
@@ -156,6 +170,7 @@ interface WatcherFileMeta {
   offset: number;
   size: number;
   partial: string;
+  decoder: StringDecoder;
 }
 
 interface RalphContinueSteerState {
@@ -1334,7 +1349,7 @@ async function writeState(extra: Record<string, unknown> = {}): Promise<void> {
     },
     ...extra,
   };
-  await writeFile(statePath, JSON.stringify(state, null, 2)).catch(() => {});
+  await writeJsonObjectAtomically(statePath, state).catch(() => {});
 }
 
 async function writeAuthorityBackoffState(): Promise<void> {
@@ -1343,7 +1358,7 @@ async function writeAuthorityBackoffState(): Promise<void> {
   const state = existing && typeof existing === 'object'
     ? { ...existing, authority_backoff: lastAuthorityBackoff }
     : { authority_backoff: lastAuthorityBackoff };
-  await writeFile(statePath, JSON.stringify(state, null, 2)).catch(() => {});
+  await writeJsonObjectAtomically(statePath, state).catch(() => {});
 }
 
 async function readJsonObject(path: string): Promise<Record<string, unknown> | null> {
@@ -1683,9 +1698,11 @@ async function ensureTrackedFiles(): Promise<void> {
     const line = await readFirstLine(path).catch(() => '');
     const threadId = shouldTrackSessionMeta(line);
     if (!threadId) continue;
-    const size = (await stat(path).catch(() => ({ size: 0 }))).size || 0;
+    const fileStat = await stat(path).catch(() => null);
+    if (!fileStat) continue;
+    const size = fileStat.size || 0;
     const offset = runOnce ? 0 : size;
-    fileState.set(path, { threadId, offset, size, partial: '' });
+    fileState.set(path, { threadId, offset, size, partial: '', decoder: new StringDecoder('utf8') });
   }
 }
 
@@ -1698,15 +1715,54 @@ function splitBufferedLines(partial: string, delta: string): { lines: string[];
   };
 }
 
+async function readFileDelta(
+  path: string,
+  offset: number,
+  currentSize: number,
+): Promise<{ bytes: Buffer; nextOffset: number }> {
+  const length = currentSize - offset;
+  if (length <= 0) return { bytes: Buffer.alloc(0), nextOffset: offset };
+  const handle = await open(path, 'r');
+  try {
+    const buffer = Buffer.allocUnsafe(length);
+    let totalBytesRead = 0;
+    while (totalBytesRead < length) {
+      const { bytesRead } = await handle.read(
+        buffer,
+        totalBytesRead,
+        length - totalBytesRead,
+        offset + totalBytesRead,
+      );
+      if (bytesRead === 0) break;
+      totalBytesRead += bytesRead;
+    }
+    return {
+      bytes: buffer.subarray(0, totalBytesRead),
+      nextOffset: offset + totalBytesRead,
+    };
+  } finally {
+    await handle.close().catch(() => {});
+  }
+}
+
 async function pollFiles(): Promise<number> {
   let processedCount = 0;
   for (const [path, meta] of fileState.entries()) {
-    const currentSize = (await stat(path).catch(() => ({ size: 0 }))).size || 0;
+    const fileStat = await stat(path).catch(() => null);
+    if (!fileStat) continue;
+    const currentSize = fileStat.size || 0;
+    if (currentSize < meta.offset) {
+      meta.offset = 0;
+      meta.partial = '';
+      meta.decoder = new StringDecoder('utf8');
+    }
     if (currentSize <= meta.offset) continue;
-    const content = await readFile(path, 'utf-8').catch(() => '');
-    if (!content) continue;
-    const delta = content.slice(meta.offset);
-    meta.offset = currentSize;
+    const read = await readFileDelta(path, meta.offset, currentSize).catch(() => null);
+    if (!read || read.bytes.length === 0) continue;
+    const { bytes, nextOffset } = read;
+    meta.offset = nextOffset;
+    const delta = meta.decoder.write(bytes);
+    if (!delta) continue;
     const buffered = splitBufferedLines(meta.partial, delta);
     const lines = buffered.lines;
     meta.partial = buffered.partial;