tinker-agent 1.8.0 → 1.10.1

package/src/tools/bounded-output-preview.ts

@@ -0,0 +1,276 @@
+import { Buffer } from "node:buffer";
+
+export const MAX_PREVIEW_LINES = 200;
+export const PREVIEW_EDGE_LINES = 100;
+export const MAX_PREVIEW_BYTES = 32 * 1024;
+export const MAX_PREVIEW_LINE_BYTES = 8 * 1024;
+
+export type BoundedOutputPreview = {
+  preview: string;
+  truncated: boolean;
+  omittedLines?: number;
+};
+
+export type OutputPreviewSource =
+  | {
+      outputLines: number;
+      lines: readonly string[];
+    }
+  | {
+      outputLines: number;
+      firstLines: readonly string[];
+      lastLines: readonly string[];
+    };
+
+type LineWindow = {
+  leadingLines: readonly string[];
+  trailingLines: readonly string[];
+  omittedLines: number;
+};
+
+type BoundedLine = {
+  text: string;
+  truncated: boolean;
+};
+
+export function buildBoundedOutputPreview(
+  source: OutputPreviewSource,
+): BoundedOutputPreview {
+  const window = selectLineWindow(source);
+  const leadingLines = window.leadingLines.map(boundLine);
+  const trailingLines = window.trailingLines.map(boundLine);
+  const lineContentTruncated = [...leadingLines, ...trailingLines].some(
+    (line) => line.truncated,
+  );
+  const lineWindowPreview = renderLineWindow({
+    leadingLines: leadingLines.map((line) => line.text),
+    trailingLines: trailingLines.map((line) => line.text),
+    outputLines: source.outputLines,
+    omittedLines: window.omittedLines,
+  });
+
+  if (utf8Bytes(lineWindowPreview) <= MAX_PREVIEW_BYTES) {
+    return {
+      preview: lineWindowPreview,
+      truncated: lineContentTruncated || window.omittedLines > 0,
+      ...(window.omittedLines > 0 ? { omittedLines: window.omittedLines } : {}),
+    };
+  }
+
+  const candidates = [...leadingLines, ...trailingLines].map((line) => line.text);
+  const totalWindow = renderTotalByteWindow(candidates);
+  const omittedLines = source.outputLines - totalWindow.retainedLines;
+
+  if (utf8Bytes(totalWindow.preview) > MAX_PREVIEW_BYTES) {
+    throw new Error("Bounded output preview exceeded its UTF-8 byte limit.");
+  }
+  if (omittedLines < 1) {
+    throw new Error("Bounded output preview byte truncation omitted no lines.");
+  }
+
+  return {
+    preview: totalWindow.preview,
+    truncated: true,
+    omittedLines,
+  };
+}
+
+export function takeUtf8Prefix(text: string, maxBytes: number): string {
+  if (maxBytes <= 0) {
+    return "";
+  }
+
+  let end = 0;
+  let bytes = 0;
+  for (const character of text) {
+    const characterBytes = utf8Bytes(character);
+    if (bytes + characterBytes > maxBytes) {
+      break;
+    }
+    bytes += characterBytes;
+    end += character.length;
+  }
+  return text.slice(0, end);
+}
+
+export function takeUtf8Suffix(text: string, maxBytes: number): string {
+  if (maxBytes <= 0) {
+    return "";
+  }
+
+  let start = text.length;
+  let bytes = 0;
+  while (start > 0) {
+    let characterStart = start - 1;
+    const lastCodeUnit = text.charCodeAt(characterStart);
+    if (
+      isLowSurrogate(lastCodeUnit) &&
+      characterStart > 0 &&
+      isHighSurrogate(text.charCodeAt(characterStart - 1))
+    ) {
+      characterStart -= 1;
+    }
+
+    const character = text.slice(characterStart, start);
+    const characterBytes = utf8Bytes(character);
+    if (bytes + characterBytes > maxBytes) {
+      break;
+    }
+    bytes += characterBytes;
+    start = characterStart;
+  }
+  return text.slice(start);
+}
+
+function selectLineWindow(source: OutputPreviewSource): LineWindow {
+  if ("lines" in source) {
+    if (source.lines.length !== source.outputLines) {
+      throw new Error("Complete output preview source has inconsistent line counts.");
+    }
+    if (source.outputLines <= MAX_PREVIEW_LINES) {
+      return {
+        leadingLines: source.lines,
+        trailingLines: [],
+        omittedLines: 0,
+      };
+    }
+
+    return {
+      leadingLines: source.lines.slice(0, PREVIEW_EDGE_LINES),
+      trailingLines: source.lines.slice(-PREVIEW_EDGE_LINES),
+      omittedLines: source.outputLines - MAX_PREVIEW_LINES,
+    };
+  }
+
+  if (
+    source.outputLines <= MAX_PREVIEW_LINES ||
+    source.firstLines.length !== PREVIEW_EDGE_LINES ||
+    source.lastLines.length !== PREVIEW_EDGE_LINES
+  ) {
+    throw new Error("Windowed output preview source has inconsistent line counts.");
+  }
+
+  return {
+    leadingLines: source.firstLines,
+    trailingLines: source.lastLines,
+    omittedLines: source.outputLines - MAX_PREVIEW_LINES,
+  };
+}
+
+function boundLine(text: string): BoundedLine {
+  const originalBytes = utf8Bytes(text);
+  if (originalBytes <= MAX_PREVIEW_LINE_BYTES) {
+    return { text, truncated: false };
+  }
+
+  let omittedBytes = originalBytes;
+  while (true) {
+    const marker = lineByteOmissionMarker(omittedBytes);
+    const remainingBytes = MAX_PREVIEW_LINE_BYTES - utf8Bytes(marker);
+    const prefix = takeUtf8Prefix(text, Math.floor(remainingBytes / 2));
+    const suffix = takeUtf8Suffix(
+      text,
+      remainingBytes - Math.floor(remainingBytes / 2),
+    );
+    const nextOmittedBytes = originalBytes - utf8Bytes(prefix) - utf8Bytes(suffix);
+
+    if (nextOmittedBytes !== omittedBytes) {
+      omittedBytes = nextOmittedBytes;
+      continue;
+    }
+
+    const bounded = `${prefix}${marker}${suffix}`;
+    if (utf8Bytes(bounded) > MAX_PREVIEW_LINE_BYTES) {
+      throw new Error("Bounded output line exceeded its UTF-8 byte limit.");
+    }
+    return { text: bounded, truncated: true };
+  }
+}
+
+function renderLineWindow(input: {
+  leadingLines: readonly string[];
+  trailingLines: readonly string[];
+  outputLines: number;
+  omittedLines: number;
+}): string {
+  if (input.omittedLines === 0) {
+    return input.leadingLines.join("\n");
+  }
+
+  const omittedStartLine = input.leadingLines.length + 1;
+  const omittedEndLine = input.outputLines - input.trailingLines.length;
+  return [
+    ...input.leadingLines,
+    `... output omitted: lines ${omittedStartLine}-${omittedEndLine} (${input.omittedLines} ${input.omittedLines === 1 ? "line" : "lines"}). Full output is available at outputFilePath.`,
+    ...input.trailingLines,
+  ].join("\n");
+}
+
+function renderTotalByteWindow(lines: readonly string[]): {
+  preview: string;
+  retainedLines: number;
+} {
+  const marker = `... output omitted to fit the ${MAX_PREVIEW_BYTES}-byte preview limit. Full output is available at outputFilePath.`;
+  const contentBudget = MAX_PREVIEW_BYTES - utf8Bytes(marker) - 2;
+  const leadingBudget = Math.floor(contentBudget / 2);
+  const trailingBudget = contentBudget - leadingBudget;
+  const leadingCount = countLeadingLinesWithin(lines, leadingBudget);
+  const trailingCount = countTrailingLinesWithin(lines, trailingBudget, leadingCount);
+
+  return {
+    preview: [
+      ...lines.slice(0, leadingCount),
+      marker,
+      ...lines.slice(lines.length - trailingCount),
+    ].join("\n"),
+    retainedLines: leadingCount + trailingCount,
+  };
+}
+
+function countLeadingLinesWithin(lines: readonly string[], maxBytes: number): number {
+  let count = 0;
+  let bytes = 0;
+  for (const line of lines) {
+    const nextBytes = utf8Bytes(line) + (count === 0 ? 0 : 1);
+    if (bytes + nextBytes > maxBytes) {
+      break;
+    }
+    bytes += nextBytes;
+    count += 1;
+  }
+  return count;
+}
+
+function countTrailingLinesWithin(
+  lines: readonly string[],
+  maxBytes: number,
+  leadingCount: number,
+): number {
+  let count = 0;
+  let bytes = 0;
+  for (let index = lines.length - 1; index >= leadingCount; index -= 1) {
+    const nextBytes = utf8Bytes(lines[index] ?? "") + (count === 0 ? 0 : 1);
+    if (bytes + nextBytes > maxBytes) {
+      break;
+    }
+    bytes += nextBytes;
+    count += 1;
+  }
+  return count;
+}
+
+function lineByteOmissionMarker(omittedBytes: number): string {
+  return `... ${omittedBytes} UTF-8 bytes omitted from this line ...`;
+}
+
+function isHighSurrogate(codeUnit: number): boolean {
+  return codeUnit >= 0xd800 && codeUnit <= 0xdbff;
+}
+
+function isLowSurrogate(codeUnit: number): boolean {
+  return codeUnit >= 0xdc00 && codeUnit <= 0xdfff;
+}
+
+function utf8Bytes(text: string): number {
+  return Buffer.byteLength(text, "utf8");
+}

package/src/tools/recall.ts

@@ -22,15 +22,14 @@ import {
   type ToolExecutor,
 } from "./types";
 
-export const RECALL_TOOL_DEFINITION: ToolDefinition = Object.freeze({
-  name: "Recall",
+export const RECALL_SEARCH_TOOL_DEFINITION: ToolDefinition = Object.freeze({
+  name: "RecallSearch",
   description:
-    "Search or retrieve immutable model-visible history from the current session. Search matches literal substrings: use a short distinctive anchor such as a path, symbol, project, command fragment, or error text, not a whole natural-language question. Results are historical snapshots and may differ from the current workspace. Use search to find a source, get to retrieve exact content, and Read/Grep for current files.",
+    "Search immutable model-visible history from the current session. Matches literal substrings: use a short distinctive anchor such as a path, symbol, project, command fragment, or error text, not a whole natural-language question. Results are historical snapshots and may differ from the current workspace. Use RecallGet with a returned source to retrieve exact content, and Read/Grep for current files.",
   parameters: {
     type: "object",
     additionalProperties: false,
     properties: {
-      mode: { type: "string", enum: ["search", "get"] },
       query: { type: "string", maxLength: 1024 },
       roles: {
         type: "array",
@@ -50,6 +49,19 @@ export const RECALL_TOOL_DEFINITION: ToolDefinition = Object.freeze({
       limit: { type: "integer", minimum: 1, maximum: 20, default: 10 },
       offset: { type: "integer", minimum: 0, default: 0 },
       snapshot_through_ordinal: { type: "integer", minimum: 1 },
+    },
+    required: ["query"],
+  },
+});
+
+export const RECALL_GET_TOOL_DEFINITION: ToolDefinition = Object.freeze({
+  name: "RecallGet",
+  description:
+    "Retrieve exact immutable model-visible historical content from the current session using a ctx://message/<UUID> source returned by RecallSearch. Results are historical snapshots and may differ from the current workspace; use Read/Grep for current files.",
+  parameters: {
+    type: "object",
+    additionalProperties: false,
+    properties: {
       source: { type: "string" },
       byte_offset: { type: "integer", minimum: 0, default: 0 },
       byte_limit: {
@@ -59,10 +71,15 @@ export const RECALL_TOOL_DEFINITION: ToolDefinition = Object.freeze({
         default: 12_000,
       },
     },
-    required: ["mode"],
+    required: ["source"],
   },
 });
 
+export const RECALL_TOOL_DEFINITIONS: readonly ToolDefinition[] = Object.freeze([
+  RECALL_SEARCH_TOOL_DEFINITION,
+  RECALL_GET_TOOL_DEFINITION,
+]);
+
 type RecallSearchArgs = {
   mode: "search";
   query: string;
@@ -93,18 +110,32 @@ type ParseResult =
       error: string;
     };
 
-export function createRecallToolExecutor(options: {
+export function createRecallSearchToolExecutor(options: {
+  historyReader: SessionHistoryReader;
+}): ToolExecutor {
+  return createRecallToolExecutor("search", options);
+}
+
+export function createRecallGetToolExecutor(options: {
   historyReader: SessionHistoryReader;
 }): ToolExecutor {
+  return createRecallToolExecutor("get", options);
+}
+
+function createRecallToolExecutor(
+  mode: "search" | "get",
+  options: { historyReader: SessionHistoryReader },
+): ToolExecutor {
   return defineToolExecutor("recall", {
-    definition: RECALL_TOOL_DEFINITION,
+    definition:
+      mode === "search" ? RECALL_SEARCH_TOOL_DEFINITION : RECALL_GET_TOOL_DEFINITION,
     async execute(
       args,
       _call,
       context: ToolExecutionContext,
     ): Promise<RecallRawResult> {
       throwIfTurnCancelled(context.signal);
-      const parsed = parseRecallArgs(args);
+      const parsed = mode === "search" ? parseSearchArgs(args) : parseGetArgs(args);
       if (!parsed.ok) {
         return recallFailure(parsed.mode, parsed.errorCode, parsed.error);
       }
@@ -167,20 +198,11 @@ export function createRecallToolExecutor(options: {
   });
 }
 
-function parseRecallArgs(args: unknown): ParseResult {
+function parseSearchArgs(args: unknown): ParseResult {
   if (!isRecord(args)) {
-    return argsFailure("search", "Recall arguments must be an object.");
-  }
-  const mode = args.mode === "get" ? "get" : "search";
-  if (args.mode !== "search" && args.mode !== "get") {
-    return argsFailure(mode, 'Recall.mode must be "search" or "get".');
+    return argsFailure("search", "RecallSearch arguments must be an object.");
   }
-  return args.mode === "search" ? parseSearchArgs(args) : parseGetArgs(args);
-}
-
-function parseSearchArgs(args: Record<string, unknown>): ParseResult {
   const allowed = new Set([
-    "mode",
     "query",
     "roles",
     "tool_names",
@@ -194,7 +216,7 @@ function parseSearchArgs(args: Record<string, unknown>): ParseResult {
   if (unexpected !== undefined) {
     return argsFailure(
       "search",
-      `Recall search received unexpected field: ${unexpected}.`,
+      `RecallSearch received unexpected field: ${unexpected}.`,
     );
   }
   if (
@@ -204,7 +226,7 @@ function parseSearchArgs(args: Record<string, unknown>): ParseResult {
   ) {
     return argsFailure(
       "search",
-      "Recall search query must be non-empty and at most 1024 UTF-8 bytes.",
+      "RecallSearch query must be non-empty and at most 1024 UTF-8 bytes.",
     );
   }
 
@@ -223,15 +245,15 @@ function parseSearchArgs(args: Record<string, unknown>): ParseResult {
   ) {
     return argsFailure(
       "search",
-      "Recall.tool_names requires roles to be omitted or contain only tool.",
+      "RecallSearch.tool_names requires roles to be omitted or contain only tool.",
     );
   }
 
-  const turnFrom = optionalInteger(args.turn_from, "Recall.turn_from", 1);
+  const turnFrom = optionalInteger(args.turn_from, "RecallSearch.turn_from", 1);
   if (!turnFrom.ok) {
     return argsFailure("search", turnFrom.error);
   }
-  const turnTo = optionalInteger(args.turn_to, "Recall.turn_to", 1);
+  const turnTo = optionalInteger(args.turn_to, "RecallSearch.turn_to", 1);
   if (!turnTo.ok) {
     return argsFailure("search", turnTo.error);
   }
@@ -240,19 +262,19 @@ function parseSearchArgs(args: Record<string, unknown>): ParseResult {
     turnTo.value !== undefined &&
     turnFrom.value > turnTo.value
   ) {
-    return argsFailure("search", "Recall.turn_from must not exceed turn_to.");
+    return argsFailure("search", "RecallSearch.turn_from must not exceed turn_to.");
   }
-  const limit = optionalInteger(args.limit, "Recall.limit", 1, 20);
+  const limit = optionalInteger(args.limit, "RecallSearch.limit", 1, 20);
   if (!limit.ok) {
     return argsFailure("search", limit.error);
   }
-  const offset = optionalInteger(args.offset, "Recall.offset", 0);
+  const offset = optionalInteger(args.offset, "RecallSearch.offset", 0);
   if (!offset.ok) {
     return argsFailure("search", offset.error);
   }
   const snapshot = optionalInteger(
     args.snapshot_through_ordinal,
-    "Recall.snapshot_through_ordinal",
+    "RecallSearch.snapshot_through_ordinal",
     1,
   );
   if (!snapshot.ok) {
@@ -277,14 +299,17 @@ function parseSearchArgs(args: Record<string, unknown>): ParseResult {
   };
 }
 
-function parseGetArgs(args: Record<string, unknown>): ParseResult {
-  const allowed = new Set(["mode", "source", "byte_offset", "byte_limit"]);
+function parseGetArgs(args: unknown): ParseResult {
+  if (!isRecord(args)) {
+    return argsFailure("get", "RecallGet arguments must be an object.");
+  }
+  const allowed = new Set(["source", "byte_offset", "byte_limit"]);
   const unexpected = Object.keys(args).find((key) => !allowed.has(key));
   if (unexpected !== undefined) {
-    return argsFailure("get", `Recall get received unexpected field: ${unexpected}.`);
+    return argsFailure("get", `RecallGet received unexpected field: ${unexpected}.`);
   }
   if (typeof args.source !== "string") {
-    return sourceFailure("Recall.source must be a string.");
+    return sourceFailure("RecallGet.source must be a string.");
   }
   let source: MessageSource;
   try {
@@ -296,11 +321,16 @@ function parseGetArgs(args: Record<string, unknown>): ParseResult {
     }
     throw error;
   }
-  const byteOffset = optionalInteger(args.byte_offset, "Recall.byte_offset", 0);
+  const byteOffset = optionalInteger(args.byte_offset, "RecallGet.byte_offset", 0);
   if (!byteOffset.ok) {
     return argsFailure("get", byteOffset.error);
   }
-  const byteLimit = optionalInteger(args.byte_limit, "Recall.byte_limit", 256, 20_000);
+  const byteLimit = optionalInteger(
+    args.byte_limit,
+    "RecallGet.byte_limit",
+    256,
+    20_000,
+  );
   if (!byteLimit.ok) {
     return argsFailure("get", byteLimit.error);
   }
@@ -332,7 +362,7 @@ function parseRoles(
     return {
       ok: false,
       error:
-        "Recall.roles must be a non-empty, unique list of user, assistant, or tool.",
+        "RecallSearch.roles must be a non-empty, unique list of user, assistant, or tool.",
     };
   }
   return { ok: true, value: value as RecallRole[] };
@@ -353,7 +383,8 @@ function parseToolNames(
   ) {
     return {
       ok: false,
-      error: "Recall.tool_names must contain 1 to 16 unique, non-empty tool names.",
+      error:
+        "RecallSearch.tool_names must contain 1 to 16 unique, non-empty tool names.",
     };
   }
   return { ok: true, value: value as string[] };

package/src/tools/registry.ts

@@ -6,11 +6,12 @@ import { createEditToolExecutor } from "./edit";
 import { createGlobToolExecutor } from "./glob";
 import { createGrepToolExecutor } from "./grep";
 import { createReadToolExecutor } from "./read";
-import { createRecallToolExecutor } from "./recall";
+import { createRecallGetToolExecutor, createRecallSearchToolExecutor } from "./recall";
 import { createTaskListToolExecutor } from "./task-list";
 import { createTaskInputToolExecutor } from "./task-input";
 import { createTaskOutputToolExecutor } from "./task-output-tool";
 import { createTaskStopToolExecutor } from "./task-stop";
+import { createUpdatePlanToolExecutor } from "./update-plan";
 import { createWebFetchToolExecutor } from "./web-fetch";
 import type { Refiner } from "./web-fetch/refiner";
 import { createWebSearchToolExecutor } from "./web-search";
@@ -205,7 +206,12 @@ export function createDefaultTooling(options: {
       maxContentBytes: options.maxReadContentBytes,
     }),
   );
-  registry.register(createRecallToolExecutor({ historyReader: options.historyReader }));
+  registry.register(
+    createRecallSearchToolExecutor({ historyReader: options.historyReader }),
+  );
+  registry.register(
+    createRecallGetToolExecutor({ historyReader: options.historyReader }),
+  );
   if (options.memorySearch !== undefined) {
     registry.register(options.memorySearch);
   }
@@ -255,6 +261,7 @@ export function createDefaultTooling(options: {
       maxTimeoutMs: toolingConfig.bashMaxTimeoutMs,
     }),
   );
+  registry.register(createUpdatePlanToolExecutor());
   registry.register(createTaskListToolExecutor({ taskManager }));
   registry.register(createTaskOutputToolExecutor({ taskManager }));
   registry.register(createTaskInputToolExecutor({ taskManager }));

package/src/tools/task-output-snapshot.ts

@@ -1,35 +1,19 @@
 import { Buffer } from "node:buffer";
+import { buildBoundedOutputPreview } from "./bounded-output-preview";
 import type { TaskOutputSnapshot } from "./task-output";
 
-const maxPreviewLines = 200;
-const previewEdgeLines = 100;
-
 export function buildOutputSnapshotFromText(bytes: Buffer): TaskOutputSnapshot {
   const text = bytes.toString("utf8");
   const lines = splitLines(text);
+  const bounded = buildBoundedOutputPreview({
+    outputLines: lines.length,
+    lines,
+  });
 
-  if (lines.length <= maxPreviewLines) {
-    return {
-      outputBytes: bytes.byteLength,
-      outputLines: lines.length,
-      preview: lines.join("\n"),
-      truncated: false,
-    };
-  }
-
-  const omittedLines = lines.length - maxPreviewLines;
-  const omittedStartLine = previewEdgeLines + 1;
-  const omittedEndLine = lines.length - previewEdgeLines;
   return {
     outputBytes: bytes.byteLength,
     outputLines: lines.length,
-    preview: [
-      ...lines.slice(0, previewEdgeLines),
-      `... output omitted: lines ${omittedStartLine}-${omittedEndLine} (${omittedLines} ${omittedLines === 1 ? "line" : "lines"}). Full output is available at outputFilePath.`,
-      ...lines.slice(-previewEdgeLines),
-    ].join("\n"),
-    truncated: true,
-    omittedLines,
+    ...bounded,
   };
 }
 

package/src/tools/task-output.ts

@@ -2,6 +2,12 @@ import { mkdir } from "node:fs/promises";
 import { createWriteStream, type WriteStream } from "node:fs";
 import path from "node:path";
 import { StringDecoder } from "node:string_decoder";
+import {
+  buildBoundedOutputPreview,
+  MAX_PREVIEW_LINES,
+  PREVIEW_EDGE_LINES,
+  type OutputPreviewSource,
+} from "./bounded-output-preview";
 
 export type TaskOutputSnapshot = {
   outputBytes: number;
@@ -11,9 +17,6 @@ export type TaskOutputSnapshot = {
   omittedLines?: number;
 };
 
-const maxPreviewLines = 200;
-const previewEdgeLines = 100;
-
 export class TaskOutput {
   private readonly decoder = new StringDecoder("utf8");
   private readonly stream: WriteStream;
@@ -68,30 +71,23 @@ export class TaskOutput {
 
   snapshot(): TaskOutputSnapshot {
     const outputLines = this.outputLines + (this.pendingLine === "" ? 0 : 1);
-    const lines = this.previewLines();
-
-    if (outputLines <= maxPreviewLines) {
-      return {
-        outputBytes: this.outputBytes,
-        outputLines,
-        preview: lines.join("\n"),
-        truncated: false,
-      };
-    }
+    const source: OutputPreviewSource =
+      this.fullPreviewLines === undefined
+        ? {
+            outputLines,
+            firstLines: this.firstLines,
+            lastLines: this.lastPreviewLines(),
+          }
+        : {
+            outputLines,
+            lines: this.previewLines(),
+          };
+    const bounded = buildBoundedOutputPreview(source);
 
-    const omittedLines = outputLines - maxPreviewLines;
-    const omittedStartLine = previewEdgeLines + 1;
-    const omittedEndLine = outputLines - previewEdgeLines;
     return {
       outputBytes: this.outputBytes,
       outputLines,
-      preview: [
-        ...this.firstLines,
-        `... output omitted: lines ${omittedStartLine}-${omittedEndLine} (${omittedLines} ${omittedLines === 1 ? "line" : "lines"}). Full output is available at outputFilePath.`,
-        ...this.lastPreviewLines(),
-      ].join("\n"),
-      truncated: true,
-      omittedLines,
+      ...bounded,
     };
   }
 
@@ -113,18 +109,18 @@ export class TaskOutput {
   private pushLine(line: string): void {
     this.outputLines += 1;
 
-    if (this.firstLines.length < previewEdgeLines) {
+    if (this.firstLines.length < PREVIEW_EDGE_LINES) {
       this.firstLines.push(line);
     }
 
     this.lastLines.push(line);
-    if (this.lastLines.length > previewEdgeLines) {
+    if (this.lastLines.length > PREVIEW_EDGE_LINES) {
       this.lastLines.shift();
     }
 
     if (this.fullPreviewLines !== undefined) {
       this.fullPreviewLines.push(line);
-      if (this.fullPreviewLines.length > maxPreviewLines) {
+      if (this.fullPreviewLines.length > MAX_PREVIEW_LINES) {
         this.fullPreviewLines = undefined;
       }
     }
@@ -150,7 +146,7 @@ export class TaskOutput {
       lines.push(this.pendingLine);
     }
 
-    return lines.slice(-previewEdgeLines);
+    return lines.slice(-PREVIEW_EDGE_LINES);
   }
 }