supipowers 1.5.3 → 2.0.1

package/src/context-mode/model.ts

@@ -0,0 +1,24 @@
+// src/context-mode/model.ts
+//
+// Registers the model-action ID used by the context-mode compaction-time
+// LLM summarizer. The summarizer is wired in `src/context-mode/hooks.ts`
+// at `session_before_compact` and gated by
+// `contextMode.llmSummarization && byteLength(snapshot) > contextMode.llmThreshold`.
+//
+// Registering here (rather than at the call site) keeps registration as a
+// module side-effect, mirroring the pattern in `src/quality/ai-setup.ts`,
+// `src/commands/plan.ts`, etc.
+
+import { modelRegistry } from "../config/model-registry-instance.js";
+
+export const COMPACTION_SUMMARIZER_ACTION_ID = "context-mode.compaction-summarizer";
+
+modelRegistry.register({
+  id: COMPACTION_SUMMARIZER_ACTION_ID,
+  category: "command",
+  label: "Compaction summarizer",
+  // Summarization is cheap text reduction; the cheapest available model is
+  // fine. "default" keeps it inheriting from the user's main session model
+  // when no per-action override is configured.
+  harnessRoleHint: "default",
+});

package/src/context-mode/processor-keys.ts

@@ -0,0 +1,29 @@
+// src/context-mode/processor-keys.ts
+//
+// Canonical mapping from a canonical native-tool name to the
+// `ProcessorKey` used for both metric rows and compressor labels.
+//
+// Two consumers of this map exist today:
+//   - the compressor labels its emitted result with the same processor key
+//     that the metrics row will carry.
+//   - the metrics recorder classifies the row when the compressor passed
+//     a result through.
+// Importing from one source prevents the two paths from drifting.
+import type { ProcessorKey } from "./metrics-store.js";
+
+/**
+ * Canonical processor key for each native tool the metrics layer recognises.
+ * Tools not listed here resolve to `null` (the recorder treats them as
+ * unknown; the compressor short-circuits to no-op).
+ */
+export const NATIVE_TOOL_PROCESSOR_KEYS: Record<string, ProcessorKey> = {
+  bash: "bash",
+  read: "read",
+  search: "search",
+  find: "find",
+};
+
+/** Resolve the canonical processor key for a given canonical tool name. */
+export function processorKeyForTool(canonicalTool: string): ProcessorKey {
+  return NATIVE_TOOL_PROCESSOR_KEYS[canonicalTool] ?? null;
+}

package/src/context-mode/processors/build.ts

@@ -0,0 +1,66 @@
+import type { ProcessorContext, ProcessorInvariant, ProcessorOutput } from "./types.js";
+
+const encoder = new TextEncoder();
+
+export const BUILD_INVARIANT: ProcessorInvariant = {
+  key: "build",
+  maxBytes: 8192,
+  preserve: ["error diagnostics", "file/line/column", "warnings", "summary tail"],
+};
+
+const ERROR_SHAPE_RE = /\b(?:error|ERROR|failed|FAIL)\b|\S+\.ts\(\d+,\d+\)|\S+\.(?:rs|go|ts):\d+:\d+/i;
+
+function byteLength(text: string): number {
+  return encoder.encode(text).byteLength;
+}
+
+function normalizeEol(text: string, eol: ProcessorContext["eol"]): string {
+  return text.replace(/\r?\n/g, eol);
+}
+
+function isImportant(line: string): boolean {
+  return ERROR_SHAPE_RE.test(line)
+    || /\bwarning\b/i.test(line)
+    || /^\s*-->/i.test(line)
+    || /^\s*\d+ \|/.test(line)
+    || /^\s*[\^╵]/.test(line)
+    || /Found \d+ errors?|\d+ errors?|could not compile|Build failed/i.test(line);
+}
+
+function capLines(lines: string[], eol: ProcessorContext["eol"]): string {
+  let output = lines.join(eol);
+  if (byteLength(output) <= BUILD_INVARIANT.maxBytes) return output;
+
+  const marker = `[...build processor omitted lines to stay under ${BUILD_INVARIANT.maxBytes} bytes...]`;
+  const kept: string[] = [];
+  for (const line of lines) {
+    const candidate = [...kept, line, marker].join(eol);
+    if (byteLength(candidate) > BUILD_INVARIANT.maxBytes) break;
+    kept.push(line);
+  }
+  output = [...kept, marker].join(eol);
+  while (byteLength(output) > BUILD_INVARIANT.maxBytes && kept.length > 0) {
+    kept.pop();
+    output = [...kept, marker].join(eol);
+  }
+  return output;
+}
+
+export function buildProcessor(text: string, ctx: ProcessorContext): ProcessorOutput {
+  if (!ERROR_SHAPE_RE.test(text)) {
+    return { text, processorKey: "build", passthrough: true };
+  }
+
+  const normalized = normalizeEol(text, ctx.eol);
+  const lines = normalized.split(ctx.eol);
+  const keep = new Set<number>();
+  for (let index = 0; index < lines.length; index += 1) {
+    if (!isImportant(lines[index])) continue;
+    keep.add(index);
+    if (index > 0) keep.add(index - 1);
+    if (index + 1 < lines.length) keep.add(index + 1);
+  }
+
+  const selected = [...keep].sort((a, b) => a - b).map((index) => lines[index]);
+  return { text: capLines(selected.length > 0 ? selected : lines, ctx.eol), processorKey: "build", passthrough: false };
+}

package/src/context-mode/processors/docker.ts

@@ -0,0 +1,57 @@
+import type { ProcessorContext, ProcessorInvariant, ProcessorOutput } from "./types.js";
+
+const encoder = new TextEncoder();
+
+export const DOCKER_INVARIANT: ProcessorInvariant = {
+  key: "docker",
+  maxBytes: 8192,
+  preserve: ["table headers", "12-character ids", "names", "statuses", "last 20 log lines"],
+};
+
+function byteLength(text: string): number {
+  return encoder.encode(text).byteLength;
+}
+
+function normalizeEol(text: string, eol: ProcessorContext["eol"]): string {
+  return text.replace(/\r?\n/g, eol);
+}
+
+function capLines(lines: string[], eol: ProcessorContext["eol"]): string {
+  let output = lines.join(eol);
+  if (byteLength(output) <= DOCKER_INVARIANT.maxBytes) return output;
+  const marker = `[...docker processor omitted lines to stay under ${DOCKER_INVARIANT.maxBytes} bytes...]`;
+  const kept: string[] = [];
+  for (const line of lines) {
+    const candidate = [...kept, line, marker].join(eol);
+    if (byteLength(candidate) > DOCKER_INVARIANT.maxBytes) break;
+    kept.push(line);
+  }
+  return [...kept, marker].join(eol);
+}
+
+function isDockerTable(lines: string[]): boolean {
+  return lines.some((line) => /\b(?:CONTAINER ID|IMAGE ID)\b/.test(line));
+}
+
+function isBuildOutput(lines: string[]): boolean {
+  return lines.some((line) => /\bERROR\b|failed to solve|exit code:/i.test(line));
+}
+
+export function dockerProcessor(text: string, ctx: ProcessorContext): ProcessorOutput {
+  const normalized = normalizeEol(text, ctx.eol);
+  const lines = normalized.split(ctx.eol).filter((line) => line.length > 0);
+
+  let compressed: string | null = null;
+  if (isDockerTable(lines)) {
+    compressed = capLines(lines, ctx.eol);
+  } else if (isBuildOutput(lines)) {
+    compressed = capLines(lines.filter((line) => /#\d+|ERROR|failed|exit code/i.test(line)), ctx.eol);
+  } else if (lines.length > 20) {
+    compressed = capLines(lines.slice(-20), ctx.eol);
+  }
+
+  if (compressed === null) {
+    return { text, processorKey: "docker", passthrough: true };
+  }
+  return { text: compressed, processorKey: "docker", passthrough: false };
+}

package/src/context-mode/processors/git.ts

@@ -0,0 +1,111 @@
+import type { ProcessorContext, ProcessorInvariant, ProcessorOutput } from "./types.js";
+
+const encoder = new TextEncoder();
+
+export const GIT_INVARIANT: ProcessorInvariant = {
+  key: "git",
+  maxBytes: 4096,
+  preserve: [
+    "branch line",
+    "per-path status codes",
+    "rename from/to lines",
+    "hunk markers",
+    "net plus/minus counts",
+    "last five commits",
+  ],
+};
+
+function normalizeEol(text: string, eol: ProcessorContext["eol"]): string {
+  return text.replace(/\r?\n/g, eol);
+}
+
+function byteLength(text: string): number {
+  return encoder.encode(text).byteLength;
+}
+
+function capText(text: string, maxBytes: number, eol: ProcessorContext["eol"]): string {
+  if (byteLength(text) <= maxBytes) return text;
+
+  const lines = text.split(/\r?\n/);
+  const marker = `[...git processor omitted ${lines.length} original lines to stay under ${maxBytes} bytes...]`;
+  const kept: string[] = [];
+  for (const line of lines) {
+    const candidate = [...kept, line, marker].join(eol);
+    if (byteLength(candidate) > maxBytes) break;
+    kept.push(line);
+  }
+
+  let capped = [...kept, marker].join(eol);
+  while (byteLength(capped) > maxBytes && kept.length > 0) {
+    kept.pop();
+    capped = [...kept, marker].join(eol);
+  }
+  return capped;
+}
+
+function countDiffChanges(text: string): { plus: number; minus: number } {
+  let plus = 0;
+  let minus = 0;
+  for (const line of text.split(/\r?\n/)) {
+    if (line.startsWith("+++") || line.startsWith("---")) continue;
+    if (line.startsWith("+")) plus += 1;
+    if (line.startsWith("-")) minus += 1;
+  }
+  return { plus, minus };
+}
+
+function looksLikeDiff(text: string): boolean {
+  return /^diff --git /m.test(text) || /^@@ /m.test(text);
+}
+
+function looksLikeLog(text: string): boolean {
+  const lines = text.split(/\r?\n/).filter(Boolean);
+  if (lines.length === 0) return false;
+  return lines.every((line) => /^[0-9a-z]{7,40}\s+/.test(line));
+}
+
+function looksLikeStatus(text: string): boolean {
+  return /^##\s+/m.test(text) || /^(?:[ MARC?D!U]{1,2}|R\s)\s+\S/m.test(text);
+}
+
+function compressDiff(text: string, ctx: ProcessorContext): string {
+  const normalized = normalizeEol(text, ctx.eol);
+  const { plus, minus } = countDiffChanges(text);
+  return capText(`Net changes: +${plus} -${minus}${ctx.eol}${normalized}`, GIT_INVARIANT.maxBytes, ctx.eol);
+}
+
+function compressLog(text: string, ctx: ProcessorContext): string {
+  const normalized = normalizeEol(text, ctx.eol);
+  const lines = normalized.split(ctx.eol).filter(Boolean);
+  if (lines.length <= 10) return capText(normalized, GIT_INVARIANT.maxBytes, ctx.eol);
+  const head = lines.slice(0, 5);
+  const tail = lines.slice(-5);
+  return capText(
+    [...head, `[...git log omitted ${lines.length - head.length - tail.length} commits...]`, ...tail].join(ctx.eol),
+    GIT_INVARIANT.maxBytes,
+    ctx.eol,
+  );
+}
+
+function compressStatusOrOther(text: string, ctx: ProcessorContext): string {
+  return capText(normalizeEol(text, ctx.eol), GIT_INVARIANT.maxBytes, ctx.eol);
+}
+
+export function gitProcessor(text: string, ctx: ProcessorContext): ProcessorOutput {
+  if (ctx.exitCode !== null && ctx.exitCode !== 0) {
+    return { text, processorKey: "git", passthrough: true };
+  }
+
+  let compressed: string;
+  if (looksLikeDiff(text)) {
+    compressed = compressDiff(text, ctx);
+  } else if (looksLikeLog(text)) {
+    compressed = compressLog(text, ctx);
+  } else if (looksLikeStatus(text)) {
+    compressed = compressStatusOrOther(text, ctx);
+  } else {
+    compressed = compressStatusOrOther(text, ctx);
+  }
+
+  return { text: compressed, processorKey: "git", passthrough: false };
+}

package/src/context-mode/processors/json.ts

@@ -0,0 +1,112 @@
+import type { ProcessorContext, ProcessorInvariant, ProcessorOutput } from "./types.js";
+
+const encoder = new TextEncoder();
+
+export const JSON_INVARIANT: ProcessorInvariant = {
+  key: "json",
+  maxBytes: 4096,
+  preserve: [
+    "top-level keys",
+    "array item counts",
+    "first five array elements",
+    "nested object key counts",
+    "parse failures passthrough",
+  ],
+};
+
+function byteLength(text: string): number {
+  return encoder.encode(text).byteLength;
+}
+
+function tryParseJson(text: string): unknown | null {
+  const trimmed = text.trim();
+  if (!trimmed.startsWith("{") && !trimmed.startsWith("[")) return null;
+  try {
+    const parsed = JSON.parse(trimmed) as unknown;
+    return parsed !== null && (Array.isArray(parsed) || typeof parsed === "object") ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+
+export function jsonContentSniff(text: string): boolean {
+  return tryParseJson(text) !== null;
+}
+
+function summarizeValue(value: unknown): string {
+  if (Array.isArray(value)) return `array(items=${value.length})`;
+  if (value === null) return "null";
+  switch (typeof value) {
+    case "object":
+      return `object(keys=${Object.keys(value as Record<string, unknown>).length})`;
+    case "string":
+      return `string(len=${value.length})`;
+    case "number":
+      return "number";
+    case "boolean":
+      return "boolean";
+    default:
+      return typeof value;
+  }
+}
+
+function summarizeArrayItem(value: unknown): string {
+  if (Array.isArray(value)) return `[array(${value.length})]`;
+  if (value && typeof value === "object") {
+    return `{${Object.keys(value as Record<string, unknown>).join(", ")}}`;
+  }
+  if (typeof value === "string") return JSON.stringify(value);
+  return String(value);
+}
+
+function capLines(lines: string[], eol: ProcessorContext["eol"]): string {
+  let output = lines.join(eol);
+  if (byteLength(output) <= JSON_INVARIANT.maxBytes) return output;
+
+  const marker = `[...json processor omitted lines to stay under ${JSON_INVARIANT.maxBytes} bytes...]`;
+  const kept: string[] = [];
+  for (const line of lines) {
+    const candidate = [...kept, line, marker].join(eol);
+    if (byteLength(candidate) > JSON_INVARIANT.maxBytes) break;
+    kept.push(line);
+  }
+  output = [...kept, marker].join(eol);
+  while (byteLength(output) > JSON_INVARIANT.maxBytes && kept.length > 0) {
+    kept.pop();
+    output = [...kept, marker].join(eol);
+  }
+  return output;
+}
+
+function summarizeObject(value: Record<string, unknown>, ctx: ProcessorContext): string {
+  const keys = Object.keys(value);
+  const lines = [
+    "JSON summary",
+    "type: object",
+    `topLevelKeys (${keys.length}): ${keys.join(", ")}`,
+  ];
+  for (const key of keys) {
+    lines.push(`${key}: ${summarizeValue(value[key])}`);
+  }
+  return capLines(lines, ctx.eol);
+}
+
+function summarizeArray(value: unknown[], ctx: ProcessorContext): string {
+  const lines = ["JSON summary", "type: array", `items: ${value.length}`];
+  value.slice(0, 5).forEach((item, index) => {
+    lines.push(`[${index}]: ${summarizeArrayItem(item)}`);
+  });
+  return capLines(lines, ctx.eol);
+}
+
+export function jsonProcessor(text: string, ctx: ProcessorContext): ProcessorOutput {
+  const parsed = tryParseJson(text);
+  if (parsed === null) {
+    return { text, processorKey: "json", passthrough: true };
+  }
+
+  const summary = Array.isArray(parsed)
+    ? summarizeArray(parsed, ctx)
+    : summarizeObject(parsed as Record<string, unknown>, ctx);
+  return { text: summary, processorKey: "json", passthrough: false };
+}

package/src/context-mode/processors/k8s.ts

@@ -0,0 +1,67 @@
+import type { ProcessorContext, ProcessorInvariant, ProcessorOutput } from "./types.js";
+
+const encoder = new TextEncoder();
+
+export const K8S_INVARIANT: ProcessorInvariant = {
+  key: "k8s",
+  maxBytes: 8192,
+  preserve: ["get headers", "resource status", "describe name/status/events", "last 20 log lines"],
+};
+
+function byteLength(text: string): number {
+  return encoder.encode(text).byteLength;
+}
+
+function normalizeEol(text: string, eol: ProcessorContext["eol"]): string {
+  return text.replace(/\r?\n/g, eol);
+}
+
+function capLines(lines: string[], eol: ProcessorContext["eol"]): string {
+  let output = lines.join(eol);
+  if (byteLength(output) <= K8S_INVARIANT.maxBytes) return output;
+  const marker = `[...k8s processor omitted lines to stay under ${K8S_INVARIANT.maxBytes} bytes...]`;
+  const kept: string[] = [];
+  for (const line of lines) {
+    const candidate = [...kept, line, marker].join(eol);
+    if (byteLength(candidate) > K8S_INVARIANT.maxBytes) break;
+    kept.push(line);
+  }
+  return [...kept, marker].join(eol);
+}
+
+function isGetTable(lines: string[]): boolean {
+  return lines.some((line) => /\bNAME\b/.test(line) && /\bSTATUS\b/.test(line));
+}
+
+function isDescribe(lines: string[]): boolean {
+  return lines.some((line) => line.startsWith("Name:")) && lines.some((line) => line.startsWith("Status:"));
+}
+
+function compressDescribe(lines: string[], eol: ProcessorContext["eol"]): string {
+  const keep = new Set<number>();
+  const eventsIndex = lines.findIndex((line) => line.startsWith("Events:"));
+  lines.forEach((line, index) => {
+    if (/^(Name|Namespace|Status):/.test(line)) keep.add(index);
+    if (eventsIndex >= 0 && index >= eventsIndex) keep.add(index);
+  });
+  return capLines([...keep].sort((a, b) => a - b).map((index) => lines[index]), eol);
+}
+
+export function k8sProcessor(text: string, ctx: ProcessorContext): ProcessorOutput {
+  const normalized = normalizeEol(text, ctx.eol);
+  const lines = normalized.split(ctx.eol).filter((line) => line.length > 0);
+
+  let compressed: string | null = null;
+  if (isGetTable(lines)) {
+    compressed = capLines(lines, ctx.eol);
+  } else if (isDescribe(lines)) {
+    compressed = compressDescribe(lines, ctx.eol);
+  } else if (lines.length > 20) {
+    compressed = capLines(lines.slice(-20), ctx.eol);
+  }
+
+  if (compressed === null) {
+    return { text, processorKey: "k8s", passthrough: true };
+  }
+  return { text: compressed, processorKey: "k8s", passthrough: false };
+}

package/src/context-mode/processors/lint.ts

@@ -0,0 +1,67 @@
+import type { ProcessorContext, ProcessorInvariant, ProcessorOutput } from "./types.js";
+
+const encoder = new TextEncoder();
+
+export const LINT_INVARIANT: ProcessorInvariant = {
+  key: "lint",
+  maxBytes: 8192,
+  preserve: ["file/line/column", "severity", "rule name", "final tally"],
+};
+
+const DIAGNOSTIC_RE = /(?:\S+\.tsx?:\d+:\d+|^\s*\d+:\d+\s+(?:error|warning)|\b(?:error|warning)\b|\[warn\]|✖|⚠|\b(?:problems|Found \d+ error|Code style issues)\b)/i;
+
+function byteLength(text: string): number {
+  return encoder.encode(text).byteLength;
+}
+
+function normalizeEol(text: string, eol: ProcessorContext["eol"]): string {
+  return text.replace(/\r?\n/g, eol);
+}
+
+function hasDiagnostics(text: string): boolean {
+  return DIAGNOSTIC_RE.test(text);
+}
+
+function isImportant(line: string): boolean {
+  return DIAGNOSTIC_RE.test(line)
+    || /^\S.*\.tsx?$/.test(line)
+    || /^Checked \d+ files/i.test(line);
+}
+
+function capLines(lines: string[], eol: ProcessorContext["eol"]): string {
+  let output = lines.join(eol);
+  if (byteLength(output) <= LINT_INVARIANT.maxBytes) return output;
+
+  const marker = `[...lint processor omitted lines to stay under ${LINT_INVARIANT.maxBytes} bytes...]`;
+  const kept: string[] = [];
+  for (const line of lines) {
+    const candidate = [...kept, line, marker].join(eol);
+    if (byteLength(candidate) > LINT_INVARIANT.maxBytes) break;
+    kept.push(line);
+  }
+  output = [...kept, marker].join(eol);
+  while (byteLength(output) > LINT_INVARIANT.maxBytes && kept.length > 0) {
+    kept.pop();
+    output = [...kept, marker].join(eol);
+  }
+  return output;
+}
+
+export function lintProcessor(text: string, ctx: ProcessorContext): ProcessorOutput {
+  if (!hasDiagnostics(text)) {
+    return { text, processorKey: "lint", passthrough: true };
+  }
+
+  const normalized = normalizeEol(text, ctx.eol);
+  const lines = normalized.split(ctx.eol);
+  const keep = new Set<number>();
+  for (let index = 0; index < lines.length; index += 1) {
+    if (!isImportant(lines[index])) continue;
+    keep.add(index);
+    if (index > 0 && /^\S/.test(lines[index - 1])) keep.add(index - 1);
+    if (index + 1 < lines.length && /^\s+(?:✖|⚠|\d|[A-Z])/.test(lines[index + 1])) keep.add(index + 1);
+  }
+
+  const selected = [...keep].sort((a, b) => a - b).map((index) => lines[index]);
+  return { text: capLines(selected.length > 0 ? selected : lines, ctx.eol), processorKey: "lint", passthrough: false };
+}

package/src/context-mode/processors/log.ts

@@ -0,0 +1,86 @@
+import type { ProcessorContext, ProcessorInvariant, ProcessorOutput } from "./types.js";
+
+const encoder = new TextEncoder();
+
+export const LOG_INVARIANT: ProcessorInvariant = {
+  key: "log",
+  maxBytes: 8192,
+  preserve: [
+    "last 30 timestamped lines",
+    "up to 20 ERROR/FATAL/PANIC lines",
+    "prompt-injection-shaped log lines verbatim",
+    "EOL style",
+  ],
+};
+
+const TIMESTAMP_RE = /^(?:\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?Z?|[A-Z][a-z]{2}\s+\d{1,2}\s+\d{2}:\d{2}:\d{2}|\[\d{4}-\d{2}-\d{2}\s+\d{2}:\d{2}:\d{2}\])/;
+const IMPORTANT_RE = /\b(?:ERROR|FATAL|PANIC)\b|IGNORE PREVIOUS INSTRUCTIONS|system prompt|reveal secrets/i;
+
+function byteLength(text: string): number {
+  return encoder.encode(text).byteLength;
+}
+
+function normalizeEol(text: string, eol: ProcessorContext["eol"]): string {
+  return text.replace(/\r?\n/g, eol);
+}
+
+function nonBlankLines(text: string): string[] {
+  return text.split(/\r?\n/).filter((line) => line.trim().length > 0);
+}
+
+function isTimestamped(line: string): boolean {
+  return TIMESTAMP_RE.test(line);
+}
+
+export function logContentSniff(text: string): boolean {
+  const lines = nonBlankLines(text);
+  if (lines.length === 0) return false;
+  const timestamped = lines.filter(isTimestamped).length;
+  return timestamped / lines.length >= 0.8;
+}
+
+function capLines(lines: string[], eol: ProcessorContext["eol"]): string {
+  let output = lines.join(eol);
+  if (byteLength(output) <= LOG_INVARIANT.maxBytes) return output;
+
+  const marker = `[...log processor omitted lines to stay under ${LOG_INVARIANT.maxBytes} bytes...]`;
+  const kept: string[] = [];
+  for (const line of lines) {
+    const candidate = [...kept, line, marker].join(eol);
+    if (byteLength(candidate) > LOG_INVARIANT.maxBytes) break;
+    kept.push(line);
+  }
+  output = [...kept, marker].join(eol);
+  while (byteLength(output) > LOG_INVARIANT.maxBytes && kept.length > 0) {
+    kept.pop();
+    output = [...kept, marker].join(eol);
+  }
+  return output;
+}
+
+export function logProcessor(text: string, ctx: ProcessorContext): ProcessorOutput {
+  if (!logContentSniff(text)) {
+    return { text, processorKey: "log", passthrough: true };
+  }
+
+  const normalized = normalizeEol(text, ctx.eol);
+  const lines = normalized.split(ctx.eol).filter((line) => line.trim().length > 0);
+  const timestamped = lines
+    .map((line, index) => ({ line, index }))
+    .filter((entry) => isTimestamped(entry.line));
+  const lastTimestamped = timestamped.slice(-30);
+  const important = lines
+    .map((line, index) => ({ line, index }))
+    .filter((entry) => IMPORTANT_RE.test(entry.line))
+    .slice(0, 20);
+
+  const keep = new Map<number, string>();
+  for (const entry of important) keep.set(entry.index, entry.line);
+  for (const entry of lastTimestamped) keep.set(entry.index, entry.line);
+
+  const selected = [...keep.entries()]
+    .sort(([a], [b]) => a - b)
+    .map(([, line]) => line);
+
+  return { text: capLines(selected, ctx.eol), processorKey: "log", passthrough: false };
+}