minimal-agent 0.11.0 → 0.13.0

package/src/tools/snip/snip.js

@@ -0,0 +1,67 @@
+import { createReadStream } from 'node:fs';
+import { createInterface } from 'node:readline';
+import { z } from 'zod';
+import { toToolParameters } from '../../utils/zodToJson.js';
+import { resolveToolPath } from '../shared/fileUtils.js';
+import { recordRead } from '../shared/fileState.js';
+const schema = z
+    .object({
+    file_path: z.string().min(1),
+    start_line: z.number().int().min(1),
+    end_line: z.number().int().min(1),
+    context: z.number().int().min(0).max(500).default(50).optional(),
+})
+    .refine((v) => v.end_line >= v.start_line, {
+    message: 'end_line 必须大于等于 start_line',
+});
+async function call(input, cwd, state) {
+    const resolved = resolveToolPath(input.file_path, cwd);
+    if (!resolved.ok)
+        return resolved;
+    const before = input.context ?? 50, from = Math.max(1, input.start_line - before), to = input.end_line + before;
+    const lines = [];
+    let total = 0;
+    let hasMore = false;
+    try {
+        const source = createReadStream(resolved.resolvedPath, {
+            encoding: 'utf8',
+        });
+        const rl = createInterface({
+            input: source,
+            crlfDelay: Infinity,
+        });
+        for await (const line of rl) {
+            total++;
+            if (total >= from && total <= to)
+                lines.push(`${String(total).padStart(6)}\t${line}`);
+            if (total > to) {
+                hasMore = true;
+                rl.close();
+                source.destroy();
+                break;
+            }
+        }
+    }
+    catch (e) {
+        return { ok: false, error: `Snip 读取失败：${e.message}` };
+    }
+    recordRead(resolved.resolvedPath, {
+        partial: true,
+        offset: from - 1,
+        limit: Math.max(0, Math.min(to, total) - from + 1),
+    }, state);
+    return {
+        ok: true,
+        content: `${lines.join('\n')}\n\n[requested ${input.start_line}-${input.end_line}; shown ${from}-${Math.min(to, total)}; ${hasMore ? `more than ${to} total lines; continue at ${to + 1}` : `total ${total} lines`}]`,
+    };
+}
+export const snipTool = {
+    name: 'Snip',
+    description: 'Reads a precise line range from a potentially huge text file with bounded surrounding context, without loading the whole file into memory.',
+    inputSchema: schema,
+    parameters: toToolParameters(schema),
+    isReadOnly: true,
+    isConcurrencySafe: true,
+    call: (input) => call(input),
+    callWithContext: (input, _s, ctx) => call(input, ctx.cwd, ctx.sessionState?.fileReads),
+};

package/src/tools/snip/snip.ts

@@ -0,0 +1,80 @@
+import { createReadStream } from 'node:fs';
+import { createInterface } from 'node:readline';
+import { z } from 'zod';
+import type { Tool, ToolCallContext, ToolResult } from '../../types.js';
+import { toToolParameters } from '../../utils/zodToJson.js';
+import { resolveToolPath } from '../shared/fileUtils.js';
+import { recordRead, type FileReadState } from '../shared/fileState.js';
+
+const schema = z
+  .object({
+    file_path: z.string().min(1),
+    start_line: z.number().int().min(1),
+    end_line: z.number().int().min(1),
+    context: z.number().int().min(0).max(500).default(50).optional(),
+  })
+  .refine((v) => v.end_line >= v.start_line, {
+    message: 'end_line 必须大于等于 start_line',
+  });
+type Input = z.infer<typeof schema>;
+async function call(
+  input: Input,
+  cwd?: string,
+  state?: FileReadState,
+): Promise<ToolResult> {
+  const resolved = resolveToolPath(input.file_path, cwd);
+  if (!resolved.ok) return resolved;
+  const before = input.context ?? 50,
+    from = Math.max(1, input.start_line - before),
+    to = input.end_line + before;
+  const lines: string[] = [];
+  let total = 0;
+  let hasMore = false;
+  try {
+    const source = createReadStream(resolved.resolvedPath, {
+      encoding: 'utf8',
+    });
+    const rl = createInterface({
+      input: source,
+      crlfDelay: Infinity,
+    });
+    for await (const line of rl) {
+      total++;
+      if (total >= from && total <= to)
+        lines.push(`${String(total).padStart(6)}\t${line}`);
+      if (total > to) {
+        hasMore = true;
+        rl.close();
+        source.destroy();
+        break;
+      }
+    }
+  } catch (e) {
+    return { ok: false, error: `Snip 读取失败：${(e as Error).message}` };
+  }
+  recordRead(
+    resolved.resolvedPath,
+    {
+      partial: true,
+      offset: from - 1,
+      limit: Math.max(0, Math.min(to, total) - from + 1),
+    },
+    state,
+  );
+  return {
+    ok: true,
+    content: `${lines.join('\n')}\n\n[requested ${input.start_line}-${input.end_line}; shown ${from}-${Math.min(to, total)}; ${hasMore ? `more than ${to} total lines; continue at ${to + 1}` : `total ${total} lines`}]`,
+  };
+}
+export const snipTool: Tool<Input> = {
+  name: 'Snip',
+  description:
+    'Reads a precise line range from a potentially huge text file with bounded surrounding context, without loading the whole file into memory.',
+  inputSchema: schema,
+  parameters: toToolParameters(schema),
+  isReadOnly: true,
+  isConcurrencySafe: true,
+  call: (input) => call(input),
+  callWithContext: (input, _s, ctx) =>
+    call(input, ctx.cwd, ctx.sessionState?.fileReads),
+};

package/src/tools/tasks/backgroundTaskService.js

@@ -1,17 +1,20 @@
-import { randomUUID } from 'node:crypto';
+import { createHash, randomUUID } from 'node:crypto';
 import { spawn } from 'node:child_process';
 import { EventEmitter } from 'node:events';
-import { closeSync, createWriteStream, existsSync, openSync, readSync, statSync } from 'node:fs';
+import { closeSync, createWriteStream, existsSync, openSync, readSync, statSync, } from 'node:fs';
 import { mkdir, readdir, rm, stat } from 'node:fs/promises';
 import { homedir } from 'node:os';
 import { basename, join } from 'node:path';
 import { killTree } from '../shared/killTree.js';
-export function createBackgroundTaskState() { return { tasks: new Map() }; }
+import { pruneRuntimeOutputs, registerRuntimeOutput, sessionRuntimeDir, unregisterRuntimeOutput, } from '../../session/runtimeStore.js';
+export function createBackgroundTaskState() {
+    return { tasks: new Map() };
+}
 const fallbackState = createBackgroundTaskState();
 /** Contains only states that currently own at least one running child. */
 const liveStates = new Set();
 const TASK_ROOT = join(homedir(), '.minimal-agent', 'tasks');
-const MAX_LOG_BYTES = 16 * 1024 * 1024;
+const MAX_LOG_BYTES = 512 * 1024 * 1024;
 const MAX_COMPLETED_PER_STATE = 50;
 const MAX_GLOBAL_LOGS = 500;
 const LOG_RETENTION_MS = 7 * 24 * 60 * 60_000;
@@ -19,22 +22,32 @@ function safeSegment(value) {
     return value.replace(/[^a-zA-Z0-9._-]/g, '_').slice(0, 80) || 'local';
 }
 export async function startBackgroundTask(spec, state = fallbackState) {
-    const sessionDir = join(TASK_ROOT, safeSegment(spec.sessionId ?? 'local'));
+    const sessionDir = join(sessionRuntimeDir(spec), 'outputs');
     await mkdir(sessionDir, { recursive: true });
-    const id = randomUUID();
+    const id = `proc_${randomUUID()}`;
     const logPath = join(sessionDir, `${id}.log`);
+    registerRuntimeOutput(logPath);
     const log = createWriteStream(logPath, { flags: 'wx', encoding: 'utf8' });
     const child = spec.executable
         ? spawn(spec.executable, spec.args ?? [], {
-            cwd: spec.cwd, env: spec.env, stdio: ['ignore', 'pipe', 'pipe'],
-            windowsHide: true, detached: process.platform !== 'win32',
+            cwd: spec.cwd,
+            env: spec.env,
+            stdio: ['ignore', 'pipe', 'pipe'],
+            windowsHide: true,
+            detached: process.platform !== 'win32',
         })
         : spawn(spec.command, {
-            cwd: spec.cwd, env: spec.env, shell: spec.shell ?? true, stdio: ['ignore', 'pipe', 'pipe'],
-            windowsHide: true, detached: process.platform !== 'win32',
+            cwd: spec.cwd,
+            env: spec.env,
+            shell: spec.shell ?? true,
+            stdio: ['ignore', 'pipe', 'pipe'],
+            windowsHide: true,
+            detached: process.platform !== 'win32',
         });
     let settle;
-    const completion = new Promise((resolvePromise) => { settle = resolvePromise; });
+    const completion = new Promise((resolvePromise) => {
+        settle = resolvePromise;
+    });
     const task = {
         id,
         command: spec.command,
@@ -50,9 +63,16 @@ export async function startBackgroundTask(spec, state = fallbackState) {
     state.tasks.set(id, task);
     liveStates.add(state);
     let written = 0;
+    let truncated = false;
+    const outputHash = createHash('sha256');
     const writeChunk = (source, value) => {
-        if (written >= MAX_LOG_BYTES)
-            return;
+        if (written >= MAX_LOG_BYTES) {
+            if (!truncated) {
+                truncated = true;
+                log.write('\n[log truncated at 512 MiB; complete=false]\n');
+            }
+            return true;
+        }
         const raw = Buffer.from(value);
         const chunk = source === 'stderr'
             ? Buffer.concat([Buffer.from('[stderr] '), raw])
@@ -60,12 +80,26 @@ export async function startBackgroundTask(spec, state = fallbackState) {
         const remaining = MAX_LOG_BYTES - written;
         const selected = chunk.subarray(0, remaining);
         written += selected.length;
-        log.write(selected, () => task.events.emit('change'));
-        if (written >= MAX_LOG_BYTES)
-            log.write('\n[log truncated at 16 MiB]\n');
+        outputHash.update(selected);
+        const accepted = log.write(selected, () => task.events.emit('change'));
+        if (selected.length < chunk.length) {
+            truncated = true;
+            log.write('\n[log truncated at 512 MiB; complete=false]\n');
+        }
+        return accepted;
     };
-    child.stdout?.on('data', (chunk) => writeChunk('stdout', chunk));
-    child.stderr?.on('data', (chunk) => writeChunk('stderr', chunk));
+    child.stdout?.on('data', (chunk) => {
+        if (!writeChunk('stdout', chunk)) {
+            child.stdout?.pause();
+            log.once('drain', () => child.stdout?.resume());
+        }
+    });
+    child.stderr?.on('data', (chunk) => {
+        if (!writeChunk('stderr', chunk)) {
+            child.stderr?.pause();
+            log.once('drain', () => child.stderr?.resume());
+        }
+    });
     let finalized = false;
     const finalize = (status, code, error) => {
         if (finalized)
@@ -75,7 +109,12 @@ export async function startBackgroundTask(spec, state = fallbackState) {
         task.finishedAt = Date.now();
         task.exitCode = code;
         task.child = undefined;
+        task.outputBytes = written;
+        task.outputSha256 = outputHash.digest('hex');
+        task.complete = !truncated;
         log.end(error ? `[stderr] Failed to start: ${error}\n` : undefined, () => {
+            unregisterRuntimeOutput(logPath);
+            void pruneRuntimeOutputs();
             task.events.emit('change');
             settle();
             pruneCompletedTasks(state);
@@ -87,16 +126,21 @@ export async function startBackgroundTask(spec, state = fallbackState) {
         finalize('failed', null, error.message);
     });
     child.once('close', (code) => {
-        finalize(task.status === 'stopped' ? 'stopped' : code === 0 ? 'completed' : 'failed', code);
+        finalize(task.status === 'stopped'
+            ? 'stopped'
+            : code === 0
+                ? 'completed'
+                : 'failed', code);
     });
     void pruneTaskLogs();
     return task;
 }
 export function getBackgroundTask(id, state = fallbackState) {
-    return state.tasks.get(id);
+    return (state.tasks.get(id) ??
+        state.tasks.get(id.startsWith('proc_') ? id.slice(5) : `proc_${id}`));
 }
 export function stopBackgroundTask(id, state = fallbackState) {
-    const task = state.tasks.get(id);
+    const task = getBackgroundTask(id, state);
     if (!task)
         return undefined;
     if (task.status === 'running' && task.child) {
@@ -148,9 +192,12 @@ function completeUtf8PrefixLength(bytes) {
     if (index < 0)
         return bytes.length;
     const lead = bytes[index];
-    const expectedLength = lead >= 0xf0 && lead <= 0xf7 ? 4
-        : lead >= 0xe0 && lead <= 0xef ? 3
-            : lead >= 0xc0 && lead <= 0xdf ? 2
+    const expectedLength = lead >= 0xf0 && lead <= 0xf7
+        ? 4
+        : lead >= 0xe0 && lead <= 0xef
+            ? 3
+            : lead >= 0xc0 && lead <= 0xdf
+                ? 2
                 : 1;
     return expectedLength > continuationBytes + 1 ? index : bytes.length;
 }
@@ -216,9 +263,13 @@ async function pruneTaskLogsInner() {
     catch { }
 }
 function pruneTaskLogs() {
-    prunePromise ??= pruneTaskLogsInner().finally(() => { prunePromise = undefined; });
+    prunePromise ??= pruneTaskLogsInner().finally(() => {
+        prunePromise = undefined;
+    });
     return prunePromise;
 }
-process.once('exit', () => { for (const state of liveStates)
-    for (const task of state.tasks.values())
-        stopBackgroundTask(task.id, state); });
+process.once('exit', () => {
+    for (const state of liveStates)
+        for (const task of state.tasks.values())
+            stopBackgroundTask(task.id, state);
+});

package/src/tools/tasks/backgroundTaskService.ts

@@ -1,14 +1,28 @@
-import { randomUUID } from 'node:crypto';
+import { createHash, randomUUID } from 'node:crypto';
 import { spawn, type ChildProcess } from 'node:child_process';
 import { EventEmitter } from 'node:events';
-import { closeSync, createWriteStream, existsSync, openSync, readSync, statSync } from 'node:fs';
+import {
+  closeSync,
+  createWriteStream,
+  existsSync,
+  openSync,
+  readSync,
+  statSync,
+} from 'node:fs';
 import { mkdir, readdir, rm, stat } from 'node:fs/promises';
 import { homedir } from 'node:os';
 import { basename, join } from 'node:path';
 
 import { killTree } from '../shared/killTree.js';
+import {
+  pruneRuntimeOutputs,
+  registerRuntimeOutput,
+  sessionRuntimeDir,
+  unregisterRuntimeOutput,
+} from '../../session/runtimeStore.js';
 
-export type BackgroundTaskStatus = 'running' | 'completed' | 'failed' | 'stopped';
+export type BackgroundTaskStatus =
+  'running' | 'completed' | 'failed' | 'stopped';
 export interface BackgroundTask {
   id: string;
   command: string;
@@ -18,19 +32,26 @@ export interface BackgroundTask {
   finishedAt?: number;
   status: BackgroundTaskStatus;
   exitCode?: number | null;
+  outputBytes?: number;
+  outputSha256?: string;
+  complete?: boolean;
   child?: ChildProcess;
   completion: Promise<void>;
   events: EventEmitter;
   shell: 'bash' | 'powershell';
 }
-export interface BackgroundTaskState { tasks: Map<string, BackgroundTask> }
-export function createBackgroundTaskState(): BackgroundTaskState { return { tasks: new Map() }; }
+export interface BackgroundTaskState {
+  tasks: Map<string, BackgroundTask>;
+}
+export function createBackgroundTaskState(): BackgroundTaskState {
+  return { tasks: new Map() };
+}
 
 const fallbackState = createBackgroundTaskState();
 /** Contains only states that currently own at least one running child. */
 const liveStates = new Set<BackgroundTaskState>();
 const TASK_ROOT = join(homedir(), '.minimal-agent', 'tasks');
-const MAX_LOG_BYTES = 16 * 1024 * 1024;
+const MAX_LOG_BYTES = 512 * 1024 * 1024;
 const MAX_COMPLETED_PER_STATE = 50;
 const MAX_GLOBAL_LOGS = 500;
 const LOG_RETENTION_MS = 7 * 24 * 60 * 60_000;
@@ -47,6 +68,7 @@ export interface BackgroundSpawnSpec {
   args?: string[];
   shell?: boolean;
   sessionId?: string;
+  workspaceId?: string;
   shellKind?: 'bash' | 'powershell';
 }
 
@@ -54,23 +76,33 @@ export async function startBackgroundTask(
   spec: BackgroundSpawnSpec,
   state: BackgroundTaskState = fallbackState,
 ): Promise<BackgroundTask> {
-  const sessionDir = join(TASK_ROOT, safeSegment(spec.sessionId ?? 'local'));
+  const sessionDir = join(sessionRuntimeDir(spec), 'outputs');
   await mkdir(sessionDir, { recursive: true });
-  const id = randomUUID();
+  const id = `proc_${randomUUID()}`;
   const logPath = join(sessionDir, `${id}.log`);
+  registerRuntimeOutput(logPath);
   const log = createWriteStream(logPath, { flags: 'wx', encoding: 'utf8' });
   const child = spec.executable
     ? spawn(spec.executable, spec.args ?? [], {
-        cwd: spec.cwd, env: spec.env, stdio: ['ignore', 'pipe', 'pipe'],
-        windowsHide: true, detached: process.platform !== 'win32',
+        cwd: spec.cwd,
+        env: spec.env,
+        stdio: ['ignore', 'pipe', 'pipe'],
+        windowsHide: true,
+        detached: process.platform !== 'win32',
       })
     : spawn(spec.command, {
-        cwd: spec.cwd, env: spec.env, shell: spec.shell ?? true, stdio: ['ignore', 'pipe', 'pipe'],
-        windowsHide: true, detached: process.platform !== 'win32',
+        cwd: spec.cwd,
+        env: spec.env,
+        shell: spec.shell ?? true,
+        stdio: ['ignore', 'pipe', 'pipe'],
+        windowsHide: true,
+        detached: process.platform !== 'win32',
       });
 
   let settle!: () => void;
-  const completion = new Promise<void>((resolvePromise) => { settle = resolvePromise; });
+  const completion = new Promise<void>((resolvePromise) => {
+    settle = resolvePromise;
+  });
   const task: BackgroundTask = {
     id,
     command: spec.command,
@@ -87,58 +119,120 @@ export async function startBackgroundTask(
   liveStates.add(state);
 
   let written = 0;
-  const writeChunk = (source: 'stdout' | 'stderr', value: Buffer | string) => {
-    if (written >= MAX_LOG_BYTES) return;
+  let truncated = false;
+  const outputHash = createHash('sha256');
+  const writeChunk = (
+    source: 'stdout' | 'stderr',
+    value: Buffer | string,
+  ): boolean => {
+    if (written >= MAX_LOG_BYTES) {
+      if (!truncated) {
+        truncated = true;
+        log.write('\n[log truncated at 512 MiB; complete=false]\n');
+      }
+      return true;
+    }
     const raw = Buffer.from(value);
-    const chunk = source === 'stderr'
-      ? Buffer.concat([Buffer.from('[stderr] '), raw])
-      : raw;
+    const chunk =
+      source === 'stderr'
+        ? Buffer.concat([Buffer.from('[stderr] '), raw])
+        : raw;
     const remaining = MAX_LOG_BYTES - written;
     const selected = chunk.subarray(0, remaining);
     written += selected.length;
-    log.write(selected, () => task.events.emit('change'));
-    if (written >= MAX_LOG_BYTES) log.write('\n[log truncated at 16 MiB]\n');
+    outputHash.update(selected);
+    const accepted = log.write(selected, () => task.events.emit('change'));
+    if (selected.length < chunk.length) {
+      truncated = true;
+      log.write('\n[log truncated at 512 MiB; complete=false]\n');
+    }
+    return accepted;
   };
-  child.stdout?.on('data', (chunk) => writeChunk('stdout', chunk));
-  child.stderr?.on('data', (chunk) => writeChunk('stderr', chunk));
+  child.stdout?.on('data', (chunk) => {
+    if (!writeChunk('stdout', chunk)) {
+      child.stdout?.pause();
+      log.once('drain', () => child.stdout?.resume());
+    }
+  });
+  child.stderr?.on('data', (chunk) => {
+    if (!writeChunk('stderr', chunk)) {
+      child.stderr?.pause();
+      log.once('drain', () => child.stderr?.resume());
+    }
+  });
   let finalized = false;
-  const finalize = (status: BackgroundTaskStatus, code: number | null, error?: string) => {
+  const finalize = (
+    status: BackgroundTaskStatus,
+    code: number | null,
+    error?: string,
+  ) => {
     if (finalized) return;
     finalized = true;
-    task.status = status; task.finishedAt = Date.now(); task.exitCode = code; task.child = undefined;
+    task.status = status;
+    task.finishedAt = Date.now();
+    task.exitCode = code;
+    task.child = undefined;
+    task.outputBytes = written;
+    task.outputSha256 = outputHash.digest('hex');
+    task.complete = !truncated;
     log.end(error ? `[stderr] Failed to start: ${error}\n` : undefined, () => {
+      unregisterRuntimeOutput(logPath);
+      void pruneRuntimeOutputs();
       task.events.emit('change');
       settle();
       pruneCompletedTasks(state);
-      if (![...state.tasks.values()].some((item) => item.status === 'running')) liveStates.delete(state);
+      if (![...state.tasks.values()].some((item) => item.status === 'running'))
+        liveStates.delete(state);
     });
   };
   child.once('error', (error) => {
     finalize('failed', null, error.message);
   });
   child.once('close', (code) => {
-    finalize(task.status === 'stopped' ? 'stopped' : code === 0 ? 'completed' : 'failed', code);
+    finalize(
+      task.status === 'stopped'
+        ? 'stopped'
+        : code === 0
+          ? 'completed'
+          : 'failed',
+      code,
+    );
   });
   void pruneTaskLogs();
   return task;
 }
 
-export function getBackgroundTask(id: string, state: BackgroundTaskState = fallbackState): BackgroundTask | undefined {
-  return state.tasks.get(id);
+export function getBackgroundTask(
+  id: string,
+  state: BackgroundTaskState = fallbackState,
+): BackgroundTask | undefined {
+  return (
+    state.tasks.get(id) ??
+    state.tasks.get(id.startsWith('proc_') ? id.slice(5) : `proc_${id}`)
+  );
 }
 
-export function stopBackgroundTask(id: string, state: BackgroundTaskState = fallbackState): BackgroundTask | undefined {
-  const task = state.tasks.get(id);
+export function stopBackgroundTask(
+  id: string,
+  state: BackgroundTaskState = fallbackState,
+): BackgroundTask | undefined {
+  const task = getBackgroundTask(id, state);
   if (!task) return undefined;
   if (task.status === 'running' && task.child) {
-    task.status = 'stopped'; task.finishedAt = Date.now();
+    task.status = 'stopped';
+    task.finishedAt = Date.now();
     killTree(task.child);
   }
   return task;
 }
 
-export function readTaskLog(task: BackgroundTask, offset = 0, limit = 30_000): { text: string; nextOffset: number; totalBytes: number } {
-  if (!existsSync(task.logPath)) return { text: '', nextOffset: offset, totalBytes: 0 };
+export function readTaskLog(
+  task: BackgroundTask,
+  offset = 0,
+  limit = 30_000,
+): { text: string; nextOffset: number; totalBytes: number } {
+  if (!existsSync(task.logPath))
+    return { text: '', nextOffset: offset, totalBytes: 0 };
   const totalBytes = statSync(task.logPath).size;
   const start = Math.max(0, Math.min(offset, totalBytes));
   const requestedLength = Math.max(0, Math.min(limit, totalBytes - start));
@@ -155,7 +249,8 @@ export function readTaskLog(task: BackgroundTask, offset = 0, limit = 30_000): {
     closeSync(descriptor);
   }
   let pageLength = Math.min(requestedLength, bytesRead);
-  while (pageLength < bytesRead && (bytes[pageLength]! & 0xc0) === 0x80) pageLength += 1;
+  while (pageLength < bytesRead && (bytes[pageLength]! & 0xc0) === 0x80)
+    pageLength += 1;
   const validLength = completeUtf8PrefixLength(bytes.subarray(0, pageLength));
   return {
     text: bytes.subarray(0, validLength).toString('utf8'),
@@ -174,14 +269,20 @@ function completeUtf8PrefixLength(bytes: Uint8Array): number {
   }
   if (index < 0) return bytes.length;
   const lead = bytes[index]!;
-  const expectedLength = lead >= 0xf0 && lead <= 0xf7 ? 4
-    : lead >= 0xe0 && lead <= 0xef ? 3
-      : lead >= 0xc0 && lead <= 0xdf ? 2
-        : 1;
+  const expectedLength =
+    lead >= 0xf0 && lead <= 0xf7
+      ? 4
+      : lead >= 0xe0 && lead <= 0xef
+        ? 3
+        : lead >= 0xc0 && lead <= 0xdf
+          ? 2
+          : 1;
   return expectedLength > continuationBytes + 1 ? index : bytes.length;
 }
 
-export async function stopAllBackgroundTasks(state?: BackgroundTaskState): Promise<void> {
+export async function stopAllBackgroundTasks(
+  state?: BackgroundTaskState,
+): Promise<void> {
   const states = state ? [state] : [...liveStates];
   const completions: Promise<void>[] = [];
   for (const item of states) {
@@ -202,7 +303,9 @@ export async function stopAllBackgroundTasks(state?: BackgroundTaskState): Promi
 }
 
 /** Release all process/task resources owned by a disposed host session. */
-export async function disposeBackgroundTaskState(state: BackgroundTaskState): Promise<void> {
+export async function disposeBackgroundTaskState(
+  state: BackgroundTaskState,
+): Promise<void> {
   await stopAllBackgroundTasks(state);
   state.tasks.clear();
   liveStates.delete(state);
@@ -211,7 +314,9 @@ export async function disposeBackgroundTaskState(state: BackgroundTaskState): Pr
 function pruneCompletedTasks(state: BackgroundTaskState): void {
   const completed = [...state.tasks.values()]
     .filter((task) => task.status !== 'running')
-    .sort((a, b) => (b.finishedAt ?? b.startedAt) - (a.finishedAt ?? a.startedAt));
+    .sort(
+      (a, b) => (b.finishedAt ?? b.startedAt) - (a.finishedAt ?? a.startedAt),
+    );
   for (const task of completed.slice(MAX_COMPLETED_PER_STATE)) {
     state.tasks.delete(task.id);
     task.events.removeAllListeners();
@@ -233,21 +338,32 @@ async function pruneTaskLogsInner(): Promise<void> {
     }
     files.sort((a, b) => b.mtime - a.mtime);
     const activeLogs = new Set(
-      [...liveStates].flatMap((state) => [...state.tasks.values()]
-        .filter((task) => task.status === 'running')
-        .map((task) => task.logPath)),
+      [...liveStates].flatMap((state) =>
+        [...state.tasks.values()]
+          .filter((task) => task.status === 'running')
+          .map((task) => task.logPath),
+      ),
     );
     const completedFiles = files.filter((item) => !activeLogs.has(item.path));
     const cutoff = Date.now() - LOG_RETENTION_MS;
-    await Promise.all(completedFiles
-      .filter((item, index) => index >= MAX_GLOBAL_LOGS || item.mtime < cutoff)
-      .map((item) => rm(item.path, { force: true })));
+    await Promise.all(
+      completedFiles
+        .filter(
+          (item, index) => index >= MAX_GLOBAL_LOGS || item.mtime < cutoff,
+        )
+        .map((item) => rm(item.path, { force: true })),
+    );
   } catch {}
 }
 
 function pruneTaskLogs(): Promise<void> {
-  prunePromise ??= pruneTaskLogsInner().finally(() => { prunePromise = undefined; });
+  prunePromise ??= pruneTaskLogsInner().finally(() => {
+    prunePromise = undefined;
+  });
   return prunePromise;
 }
 
-process.once('exit', () => { for (const state of liveStates) for (const task of state.tasks.values()) stopBackgroundTask(task.id, state); });
+process.once('exit', () => {
+  for (const state of liveStates)
+    for (const task of state.tasks.values()) stopBackgroundTask(task.id, state);
+});