@flyingrobots/graft 0.5.0 → 0.6.0

package/src/mcp/repo-tool-job.ts

@@ -1,20 +1,11 @@
 import { z } from "zod";
-import { CanonicalJsonCodec } from "../adapters/canonical-json.js";
-import { nodeFs } from "../adapters/node-fs.js";
-import { nodeGit } from "../adapters/node-git.js";
-import { nodeProcessRunner } from "../adapters/node-process-runner.js";
-import { openWarp } from "../warp/open.js";
-import { SessionTracker, type SessionTrackerSnapshot } from "../session/tracker.js";
-import { buildReceiptResult, type McpToolReceipt, type McpToolResult } from "./receipt.js";
-import { createPathResolver, type ToolContext, type ToolDefinition, type ToolHandler } from "./context.js";
-import { resolveRunCaptureConfig } from "./run-capture-config.js";
-import { resolveRuntimeObservabilityState } from "./runtime-observability.js";
-import { Metrics, diffMetrics, type MetricsDelta, type MetricsSnapshot } from "./metrics.js";
-import { ObservationCache, type ObservationSnapshot } from "./cache.js";
+import type { GovernorTrackerSnapshot } from "../session/tracker.js";
+import type { McpToolReceipt, McpToolResult } from "./receipt.js";
+import type { ToolDefinition, ToolHandler } from "./context.js";
+import type { MetricsDelta, MetricsSnapshot } from "./metrics.js";
+import type { ObservationSnapshot } from "./cache.js";
 import type { RepoObservation } from "./repo-state.js";
-import type { WorkspaceCapabilityProfile, WorkspaceStatus } from "./workspace-router.js";
-import { evaluateMcpPolicy } from "./policy.js";
-import { RefusedResult } from "../policy/types.js";
+import type { WorkspaceCapabilityProfile } from "./workspace-router.js";
 import { graftDiffTool } from "./tools/graft-diff.js";
 import { sinceTool } from "./tools/since.js";
 import { mapTool } from "./tools/map.js";
@@ -24,19 +15,19 @@ import { codeShowTool, runCodeShow } from "./tools/code-show.js";
 import { safeReadTool } from "./tools/safe-read.js";
 import { fileOutlineTool } from "./tools/file-outline.js";
 import { changedSinceTool } from "./tools/changed-since.js";
-import { buildRuntimeCausalContext } from "./runtime-causal-context.js";
+import { buildRepoToolWorkerContext, wrapWithPolicyCheck } from "./repo-tool-worker-context.js";
 
 const codeFindLiveWorkerTool: ToolDefinition = {
   ...codeFindTool,
-  createHandler(ctx: ToolContext): ToolHandler {
-    return (args) => runCodeFind(ctx, args, { allowWarp: false });
+  createHandler(): ToolHandler {
+    return (args, ctx) => runCodeFind(ctx, args, { allowWarp: false });
   },
 };
 
 const codeShowLiveWorkerTool: ToolDefinition = {
   ...codeShowTool,
-  createHandler(ctx: ToolContext): ToolHandler {
-    return (args) => runCodeShow(ctx, args, { allowWarp: false });
+  createHandler(): ToolHandler {
+    return (args, ctx) => runCodeShow(ctx, args, { allowWarp: false });
   },
 };
 
@@ -75,7 +66,7 @@ export interface RepoToolWorkerJob {
   readonly writerId: string;
   readonly capabilityProfile: WorkspaceCapabilityProfile;
   readonly repoState: RepoObservation;
-  readonly sessionSnapshot: SessionTrackerSnapshot;
+  readonly governorSnapshot: GovernorTrackerSnapshot;
   readonly metricsSnapshot: MetricsSnapshot;
   readonly cacheSnapshots?: Readonly<Record<string, ObservationSnapshot>>;
 }
@@ -92,211 +83,20 @@ export interface RepoToolWorkerResult {
   }[];
 }
 
-function unsupported(name: string): never {
-  throw new Error(`${name} is not available in repo-tool worker mode`);
-}
-
-function wrapWithPolicyCheck(toolName: ToolDefinition["name"], inner: ToolHandler, ctx: ToolContext): ToolHandler {
-  return async (args: Record<string, unknown>) => {
-    const rawPath = args["path"];
-    if (typeof rawPath !== "string") return inner(args);
-
-    const filePath = ctx.resolvePath(rawPath);
-    let content: string;
-    try {
-      content = await ctx.fs.readFile(filePath, "utf-8");
-    } catch {
-      return inner(args);
-    }
-
-    const actual = { lines: content.split("\n").length, bytes: Buffer.byteLength(content) };
-    const policy = evaluateMcpPolicy(ctx, filePath, actual);
-    if (policy instanceof RefusedResult) {
-      ctx.metrics.recordRefusal();
-      return ctx.respond(toolName, {
-        path: filePath,
-        projection: "refused",
-        reason: policy.reason,
-        reasonDetail: policy.reasonDetail,
-        next: [...policy.next],
-        actual,
-      });
-    }
-    return inner(args);
-  };
-}
-
-function workerStatus(job: RepoToolWorkerJob): WorkspaceStatus {
-  return {
-    sessionMode: "daemon",
-    bindState: "bound",
-    repoId: job.repoId,
-    worktreeId: job.worktreeId,
-    worktreeRoot: job.projectRoot,
-    gitCommonDir: job.gitCommonDir,
-    graftDir: job.graftDir,
-    capabilityProfile: job.capabilityProfile,
-  };
-}
-
-function buildWorkerContext(
-  job: RepoToolWorkerJob,
-): { ctx: ToolContext; metrics: Metrics; session: SessionTracker; takeResponse: () => RepoToolWorkerResult } {
-  const codec = new CanonicalJsonCodec();
-  const session = SessionTracker.fromSnapshot(job.sessionSnapshot);
-  const metrics = Metrics.fromSnapshot(job.metricsSnapshot);
-  const cache = ObservationCache.fromSnapshots(job.cacheSnapshots);
-  const trackedCachePaths = new Set<string>(Object.keys(job.cacheSnapshots ?? {}));
-  if (typeof job.args["path"] === "string") {
-    trackedCachePaths.add(createPathResolver(job.projectRoot)(job.args["path"]));
-  }
-  let response: Omit<RepoToolWorkerResult, "metricsDelta" | "cacheUpdates"> | null = null;
-
-  const ctx: ToolContext = {
-    projectRoot: job.projectRoot,
-    graftDir: job.graftDir,
-    graftignorePatterns: job.graftignorePatterns,
-    session,
-    cache,
-    metrics,
-    fs: nodeFs,
-    codec,
-    process: nodeProcessRunner,
-    git: nodeGit,
-    runCapture: resolveRunCaptureConfig({}),
-    observability: resolveRuntimeObservabilityState({ graftDir: job.graftDir }),
-    respond(tool, data) {
-      const tripwires = session.checkTripwires();
-      const built = buildReceiptResult(tool, data, {
-        sessionId: job.sessionId,
-        traceId: job.traceId,
-        seq: job.seq,
-        latencyMs: Date.now() - job.startedAtMs,
-        codec,
-        metrics: metrics.snapshot(),
-        tripwires,
-        budget: session.getBudget(),
-      });
-      response = {
-        result: built.result,
-        textBytes: built.textBytes,
-        receipt: built.receipt,
-        tripwireSignals: tripwires.map((wire) => wire.signal),
-      };
-      return built.result;
-    },
-    resolvePath: createPathResolver(job.projectRoot),
-    getWarp() {
-      return openWarp({ cwd: job.projectRoot, writerId: job.writerId });
-    },
-    getRepoState() {
-      return job.repoState;
-    },
-    getCausalContext() {
-      return buildRuntimeCausalContext({
-        transportSessionId: job.sessionId,
-        workspaceSliceId: job.workspaceSliceId,
-        repoId: job.repoId,
-        worktreeId: job.worktreeId,
-        checkoutEpoch: job.repoState.checkoutEpoch,
-        warpWriterId: job.writerId,
-      });
-    },
-    getPersistedLocalHistorySummary() {
-      return unsupported("getPersistedLocalHistorySummary");
-    },
-    getPersistedLocalActivityWindow() {
-      return unsupported("getPersistedLocalActivityWindow");
-    },
-    getRepoConcurrencySummary() {
-      return Promise.resolve(null);
-    },
-    getWorkspaceOverlayFooting() {
-      return unsupported("getWorkspaceOverlayFooting");
-    },
-    declareCausalAttach() {
-      return unsupported("declareCausalAttach");
-    },
-    getWorkspaceStatus() {
-      return workerStatus(job);
-    },
-    bindWorkspace() {
-      return unsupported("bindWorkspace");
-    },
-    rebindWorkspace() {
-      return unsupported("rebindWorkspace");
-    },
-    getDaemonStatus() {
-      return unsupported("getDaemonStatus");
-    },
-    listDaemonRepos() {
-      return unsupported("listDaemonRepos");
-    },
-    listDaemonSessions() {
-      return unsupported("listDaemonSessions");
-    },
-    listDaemonMonitors() {
-      return unsupported("listDaemonMonitors");
-    },
-    startMonitor() {
-      return unsupported("startMonitor");
-    },
-    pauseMonitor() {
-      return unsupported("pauseMonitor");
-    },
-    resumeMonitor() {
-      return unsupported("resumeMonitor");
-    },
-    stopMonitor() {
-      return unsupported("stopMonitor");
-    },
-    listWorkspaceAuthorizations() {
-      return unsupported("listWorkspaceAuthorizations");
-    },
-    authorizeWorkspace() {
-      return unsupported("authorizeWorkspace");
-    },
-    revokeWorkspace() {
-      return unsupported("revokeWorkspace");
-    },
-  };
-
-  return {
-    ctx,
-    metrics,
-    session,
-    takeResponse() {
-      if (response === null) {
-        throw new Error(`repo-tool worker ${job.tool} completed without calling respond()`);
-      }
-      return {
-        ...response,
-        metricsDelta: diffMetrics(job.metricsSnapshot, metrics.snapshot()),
-        cacheUpdates: [...trackedCachePaths].map((filePath) => {
-          return {
-            path: filePath,
-            observation: cache.snapshotEntry(filePath),
-          };
-        }),
-      };
-    },
-  };
-}
-
 function resolveRepoToolDefinition(tool: OffloadedRepoToolName): ToolDefinition {
   return OFFLOADED_REPO_TOOL_DEFINITIONS[tool];
 }
 
 export async function runRepoToolJob(job: RepoToolWorkerJob): Promise<RepoToolWorkerResult> {
   const definition = resolveRepoToolDefinition(job.tool);
-  const { ctx, takeResponse } = buildWorkerContext(job);
-  const rawHandler = definition.createHandler(ctx);
-  const handler = definition.policyCheck === true ? wrapWithPolicyCheck(definition.name, rawHandler, ctx) : rawHandler;
+  const { ctx, takeResponse } = buildRepoToolWorkerContext(job);
+  const rawHandler = definition.createHandler();
+  const handler = definition.policyCheck === true ? wrapWithPolicyCheck(definition.name, rawHandler) : rawHandler;
 
   if (definition.schema !== undefined) {
     z.object(definition.schema).strict().parse(job.args);
   }
 
-  await handler(job.args);
+  await handler(job.args, ctx);
   return takeResponse();
 }

package/src/mcp/repo-tool-worker-context.ts

@@ -0,0 +1,212 @@
+import { CanonicalJsonCodec } from "../adapters/canonical-json.js";
+import { nodeFs } from "../adapters/node-fs.js";
+import { nodeGit } from "../adapters/node-git.js";
+import { nodeProcessRunner } from "../adapters/node-process-runner.js";
+import { createRepoPathResolver } from "../adapters/repo-paths.js";
+import { openWarp } from "../warp/open.js";
+import { GovernorTracker } from "../session/tracker.js";
+import { RefusedResult } from "../policy/types.js";
+import type { WorkspaceStatus } from "./workspace-router.js";
+import { buildReceiptResult } from "./receipt.js";
+import type { ToolContext, ToolDefinition, ToolHandler } from "./context.js";
+import { Metrics, diffMetrics } from "./metrics.js";
+import { ObservationCache } from "./cache.js";
+import { evaluateMcpPolicy } from "./policy.js";
+import { resolveRunCaptureConfig } from "./run-capture-config.js";
+import { resolveRuntimeObservabilityState } from "./runtime-observability.js";
+import { buildRuntimeCausalContext } from "./runtime-causal-context.js";
+import type { RepoToolWorkerJob, RepoToolWorkerResult } from "./repo-tool-job.js";
+
+function unsupported(name: string): never {
+  throw new Error(`${name} is not available in repo-tool worker mode`);
+}
+
+function workerStatus(job: RepoToolWorkerJob): WorkspaceStatus {
+  return {
+    sessionMode: "daemon",
+    bindState: "bound",
+    repoId: job.repoId,
+    worktreeId: job.worktreeId,
+    worktreeRoot: job.projectRoot,
+    gitCommonDir: job.gitCommonDir,
+    graftDir: job.graftDir,
+    capabilityProfile: job.capabilityProfile,
+  };
+}
+
+export function wrapWithPolicyCheck(
+  toolName: ToolDefinition["name"],
+  inner: ToolHandler,
+): ToolHandler {
+  return async (args: Record<string, unknown>, ctx: ToolContext) => {
+    const rawPath = args["path"];
+    if (typeof rawPath !== "string") return inner(args, ctx);
+
+    const filePath = ctx.resolvePath(rawPath);
+    let content: string;
+    try {
+      content = await ctx.fs.readFile(filePath, "utf-8");
+    } catch {
+      return inner(args, ctx);
+    }
+
+    const actual = { lines: content.split("\n").length, bytes: Buffer.byteLength(content) };
+    const policy = evaluateMcpPolicy(ctx, filePath, actual);
+    if (policy instanceof RefusedResult) {
+      ctx.metrics.recordRefusal();
+      return ctx.respond(toolName, {
+        path: filePath,
+        projection: "refused",
+        reason: policy.reason,
+        reasonDetail: policy.reasonDetail,
+        next: [...policy.next],
+        actual,
+      });
+    }
+    return inner(args, ctx);
+  };
+}
+
+export function buildRepoToolWorkerContext(
+  job: RepoToolWorkerJob,
+): { ctx: ToolContext; takeResponse: () => RepoToolWorkerResult } {
+  const codec = new CanonicalJsonCodec();
+  const governor = GovernorTracker.fromSnapshot(job.governorSnapshot);
+  const metrics = Metrics.fromSnapshot(job.metricsSnapshot);
+  const cache = ObservationCache.fromSnapshots(job.cacheSnapshots);
+  const trackedCachePaths = new Set<string>(Object.keys(job.cacheSnapshots ?? {}));
+  if (typeof job.args["path"] === "string") {
+    trackedCachePaths.add(createRepoPathResolver(job.projectRoot)(job.args["path"]));
+  }
+  let response: Omit<RepoToolWorkerResult, "metricsDelta" | "cacheUpdates"> | null = null;
+
+  const ctx: ToolContext = {
+    projectRoot: job.projectRoot,
+    graftDir: job.graftDir,
+    graftignorePatterns: job.graftignorePatterns,
+    governor,
+    cache,
+    metrics,
+    fs: nodeFs,
+    codec,
+    process: nodeProcessRunner,
+    git: nodeGit,
+    runCapture: resolveRunCaptureConfig({}),
+    observability: resolveRuntimeObservabilityState({ graftDir: job.graftDir }),
+    respond(tool, data) {
+      const tripwires = governor.checkTripwires();
+      const built = buildReceiptResult(tool, data, {
+        sessionId: job.sessionId,
+        traceId: job.traceId,
+        seq: job.seq,
+        latencyMs: Date.now() - job.startedAtMs,
+        codec,
+        metrics: metrics.snapshot(),
+        tripwires,
+        budget: governor.getBudget(),
+      });
+      response = {
+        result: built.result,
+        textBytes: built.textBytes,
+        receipt: built.receipt,
+        tripwireSignals: tripwires.map((wire) => wire.signal),
+      };
+      return built.result;
+    },
+    recordFootprint() {
+      // Worker-thread footprints are not collected — the main thread
+      // captures footprint via AsyncLocalStorage in the invocation engine.
+    },
+    resolvePath: createRepoPathResolver(job.projectRoot),
+    getWarp() {
+      return openWarp({ cwd: job.projectRoot, writerId: job.writerId });
+    },
+    getRepoState() {
+      return job.repoState;
+    },
+    getCausalContext() {
+      return buildRuntimeCausalContext({
+        transportSessionId: job.sessionId,
+        workspaceSliceId: job.workspaceSliceId,
+        repoId: job.repoId,
+        worktreeId: job.worktreeId,
+        checkoutEpoch: job.repoState.checkoutEpoch,
+        warpWriterId: job.writerId,
+      });
+    },
+    getPersistedLocalHistorySummary() {
+      return unsupported("getPersistedLocalHistorySummary");
+    },
+    getPersistedLocalActivityWindow() {
+      return unsupported("getPersistedLocalActivityWindow");
+    },
+    getRepoConcurrencySummary() {
+      return Promise.resolve(null);
+    },
+    getWorkspaceOverlayFooting() {
+      return unsupported("getWorkspaceOverlayFooting");
+    },
+    declareCausalAttach() {
+      return unsupported("declareCausalAttach");
+    },
+    getWorkspaceStatus() {
+      return workerStatus(job);
+    },
+    bindWorkspace() {
+      return unsupported("bindWorkspace");
+    },
+    rebindWorkspace() {
+      return unsupported("rebindWorkspace");
+    },
+    getDaemonStatus() {
+      return unsupported("getDaemonStatus");
+    },
+    listDaemonRepos() {
+      return unsupported("listDaemonRepos");
+    },
+    listDaemonSessions() {
+      return unsupported("listDaemonSessions");
+    },
+    listDaemonMonitors() {
+      return unsupported("listDaemonMonitors");
+    },
+    startMonitor() {
+      return unsupported("startMonitor");
+    },
+    pauseMonitor() {
+      return unsupported("pauseMonitor");
+    },
+    resumeMonitor() {
+      return unsupported("resumeMonitor");
+    },
+    stopMonitor() {
+      return unsupported("stopMonitor");
+    },
+    listWorkspaceAuthorizations() {
+      return unsupported("listWorkspaceAuthorizations");
+    },
+    authorizeWorkspace() {
+      return unsupported("authorizeWorkspace");
+    },
+    revokeWorkspace() {
+      return unsupported("revokeWorkspace");
+    },
+  };
+
+  return {
+    ctx,
+    takeResponse() {
+      if (response === null) {
+        throw new Error(`repo-tool worker ${job.tool} completed without calling respond()`);
+      }
+      return {
+        ...response,
+        metricsDelta: diffMetrics(job.metricsSnapshot, metrics.snapshot()),
+        cacheUpdates: [...trackedCachePaths].map((filePath) => ({
+          path: filePath,
+          observation: cache.snapshotEntry(filePath),
+        })),
+      };
+    },
+  };
+}

package/src/mcp/repo-workspace.ts

@@ -0,0 +1,21 @@
+import { toRepoPolicyPath } from "../adapters/repo-paths.js";
+import { RepoWorkspace } from "../operations/repo-workspace.js";
+import type { ToolContext } from "./context.js";
+
+export function createRepoWorkspaceFromToolContext(
+  ctx: Pick<
+    ToolContext,
+    "projectRoot" | "fs" | "codec" | "graftignorePatterns" | "resolvePath" | "governor" | "cache"
+  >,
+): RepoWorkspace {
+  return new RepoWorkspace({
+    projectRoot: ctx.projectRoot,
+    fs: ctx.fs,
+    codec: ctx.codec,
+    graftignorePatterns: ctx.graftignorePatterns,
+    resolvePath: ctx.resolvePath,
+    toPolicyPath: (resolvedPath) => toRepoPolicyPath(ctx.projectRoot, resolvedPath),
+    governor: ctx.governor,
+    cache: ctx.cache,
+  });
+}

package/src/mcp/runtime-observability.ts

@@ -1,10 +1,11 @@
 import * as path from "node:path";
 import { ZodError } from "zod";
+import { RotatingNdjsonLog } from "../adapters/rotating-ndjson-log.js";
 import type { JsonCodec } from "../ports/codec.js";
 import type { FileSystem } from "../ports/filesystem.js";
 import type { MetricsSnapshot } from "./metrics.js";
 import type { BurdenKind } from "./burden.js";
-import type { SessionDepth } from "../session/types.js";
+import type { GovernorDepth } from "../session/types.js";
 
 export type RuntimeLogPolicy = "metadata_only";
 
@@ -67,7 +68,27 @@ export interface RuntimeToolCallStartedEvent {
   readonly traceId: string;
   readonly tool: string;
   readonly argKeys: readonly string[];
-  readonly sessionDepth: SessionDepth;
+  readonly sessionDepth: GovernorDepth;
+}
+
+/**
+ * Per-tool-call footprint capturing which files, symbols, and regions
+ * were observed. Enables provenance tracing at sub-file granularity.
+ */
+export interface ToolCallFootprint {
+  /** File paths read or scanned by this tool call. */
+  readonly paths: readonly string[];
+  /** Symbol names inspected (when available from outline/precision tools). */
+  readonly symbols: readonly string[];
+  /** Line regions accessed (when available from read_range). */
+  readonly regions: readonly ToolCallFootprintRegion[];
+}
+
+/** A line region within a specific file. */
+export interface ToolCallFootprintRegion {
+  readonly path: string;
+  readonly startLine: number;
+  readonly endLine: number;
 }
 
 export interface RuntimeToolCallCompletedEvent {
@@ -83,9 +104,11 @@ export interface RuntimeToolCallCompletedEvent {
   readonly nonReadBurden: boolean;
   readonly returnedBytes: number;
   readonly fileBytes: number | null;
-  readonly sessionDepth: SessionDepth;
+  readonly sessionDepth: GovernorDepth;
   readonly tripwireSignals: readonly string[];
   readonly metrics: MetricsSnapshot;
+  /** Optional sub-file footprint for provenance granularity. */
+  readonly footprint?: ToolCallFootprint;
 }
 
 export type RuntimeFailureKind = "validation_error" | "tool_error" | "unknown_error";
@@ -96,7 +119,7 @@ export interface RuntimeToolCallFailedEvent {
   readonly traceId: string;
   readonly tool: string;
   readonly latencyMs: number;
-  readonly sessionDepth: SessionDepth;
+  readonly sessionDepth: GovernorDepth;
   readonly argKeys: readonly string[];
   readonly errorKind: RuntimeFailureKind;
   readonly errorName: string;
@@ -130,7 +153,7 @@ export async function ensureGraftDirExcluded(
 
   let existing: string;
   try {
-    existing = fs.readFileSync(excludePath, "utf-8");
+    existing = await fs.readFile(excludePath, "utf-8");
   } catch {
     return;
   }
@@ -161,59 +184,34 @@ export function classifyRuntimeFailure(error: unknown): {
   return { kind: "unknown_error", name: "UnknownError" };
 }
 
+export { sanitizeArgValues } from "./secret-scrub.js";
+
 export function sanitizeArgKeys(args: Record<string, unknown>): string[] {
   return Object.keys(args).sort();
 }
 
 export class RuntimeEventLogger {
-  private readonly fs: FileSystem;
-  private readonly codec: JsonCodec;
-  private readonly logPath: string;
-  private readonly maxBytes: number;
+  private readonly logWriter: RotatingNdjsonLog;
   private queue: Promise<void> = Promise.resolve();
 
   constructor(options: RuntimeEventLoggerOptions) {
-    this.fs = options.fs;
-    this.codec = options.codec;
-    this.logPath = options.logPath;
-    this.maxBytes = options.maxBytes;
+    this.logWriter = new RotatingNdjsonLog({
+      fs: options.fs,
+      codec: options.codec,
+      logPath: options.logPath,
+      maxBytes: options.maxBytes,
+    });
   }
 
   log(event: RuntimeEvent): Promise<void> {
     const prior = this.queue.catch((_error: unknown) => undefined);
     this.queue = prior
       .then(async () => {
-        const line = this.codec.encode({ ts: new Date().toISOString(), ...event }) + "\n";
-        const dir = path.dirname(this.logPath);
-        await this.fs.mkdir(dir, { recursive: true });
-        await this.fs.appendFile(this.logPath, line, "utf-8");
-        await this.rotateIfNeeded();
+        await this.logWriter.append({
+          ts: new Date().toISOString(),
+          ...event,
+        });
       });
     return this.queue;
   }
-
-  private async rotateIfNeeded(): Promise<void> {
-    let stat: { size: number };
-    try {
-      stat = await this.fs.stat(this.logPath);
-    } catch {
-      return;
-    }
-
-    if (stat.size <= this.maxBytes) {
-      return;
-    }
-
-    const content = await this.fs.readFile(this.logPath, "utf-8");
-    const lines = content.trimEnd().split("\n");
-    let kept = lines.slice(Math.ceil(lines.length / 2));
-    let result = kept.join("\n") + "\n";
-
-    while (Buffer.byteLength(result, "utf-8") > this.maxBytes && kept.length > 1) {
-      kept = kept.slice(Math.ceil(kept.length / 2));
-      result = kept.join("\n") + "\n";
-    }
-
-    await this.fs.writeFile(this.logPath, result, "utf-8");
-  }
 }