@leing2021/super-pi 0.14.2 → 0.16.0

package/extensions/ce-core/index.ts

@@ -1,7 +1,5 @@
-import type { AssistantMessage } from "@mariozechner/pi-ai"
 import type { ExtensionAPI } from "@mariozechner/pi-coding-agent"
 import { Type } from "@sinclair/typebox"
-import { truncateToWidth, visibleWidth } from "@mariozechner/pi-tui"
 import { createArtifactHelperTool, type ArtifactType } from "./tools/artifact-helper"
 import { createAskUserQuestionTool } from "./tools/ask-user-question"
 import { createSubagentTool } from "./tools/subagent"
@@ -15,6 +13,9 @@ import { createBrainstormDialogTool } from "./tools/brainstorm-dialog"
 import { createPlanDiffTool } from "./tools/plan-diff"
 import { createSessionHistoryTool } from "./tools/session-history"
 import { createPatternExtractorTool } from "./tools/pattern-extractor"
+import { filterBashOutput } from "./tools/bash-output-filter"
+import { filterReadOutput } from "./tools/read-output-filter"
+import { COMPACTION_FOCUS_INSTRUCTIONS } from "./tools/compaction-optimizer"
 
 const artifactHelperParams = Type.Object({
   repoRoot: Type.String({ description: "Repository root where workflow artifacts should be created" }),
@@ -171,36 +172,6 @@ const patternExtractorParams = Type.Object({
   categories: Type.Optional(Type.Record(Type.String(), Type.Array(Type.String()), { description: "Category name to keyword mapping" })),
 })
 
-// Session-scoped stats for custom footer
-let statsEnabled = false
-const toolCounts = new Map<string, number>()
-let subagentCount = 0
-let projectPath = ""
-let footerTui: any = null
-
-function renderStatsFooter(ctx: any, tui: any, theme: any, footerData: any, width: number): string[] {
-  const shortPath = projectPath
-    .replace(/^\/Users\/[^/]+/, "~")
-    .split("/")
-    .slice(-2)
-    .join("/")
-
-  const sorted = [...toolCounts.entries()].sort((a, b) => b[1] - a[1])
-  const total = sorted.reduce((sum, e) => sum + e[1], 0)
-  const top3 = sorted.slice(0, 3).map(([name, count]) => `${name}:${count}`).join(" ")
-  const toolsStr = total > 0 ? `tools(${total}) ${top3}` : ""
-  const subStr = subagentCount > 0 ? `sub:${subagentCount}` : ""
-  const branch = footerData.getGitBranch()
-  const branchStr = branch ? ` (${branch})` : ""
-
-  const left = theme.fg("dim", `${shortPath}${branchStr}`)
-  const rightParts = [subStr, toolsStr].filter(Boolean)
-  const right = rightParts.length > 0 ? theme.fg("dim", rightParts.join(" │ ")) : ""
-
-  const pad = " ".repeat(Math.max(1, width - visibleWidth(left) - visibleWidth(right)))
-  return [truncateToWidth(left + pad + right, width)]
-}
-
 export default function ceCoreExtension(pi: ExtensionAPI) {
   const artifactHelper = createArtifactHelperTool()
   const askUserQuestion = createAskUserQuestionTool()
@@ -537,68 +508,90 @@ export default function ceCoreExtension(pi: ExtensionAPI) {
     },
   })
 
-  // Track tool calls for stats footer
-  pi.on("tool_call", async (event, _ctx) => {
-    if (!statsEnabled) return
-    const name = event.toolName
-    toolCounts.set(name, (toolCounts.get(name) || 0) + 1)
-    if (name === "subagent" || name === "parallel_subagent") {
-      subagentCount++
+  // Bash output smart filter — reduces context waste from verbose command output
+  pi.on("tool_result", async (event, _ctx) => {
+    if (event.toolName !== "bash") return undefined
+
+    // Extract command from input
+    const command = (event.input as any)?.command ?? ""
+    if (!command) return undefined
+
+    // Extract text content from tool result
+    const textBlocks = (event.content as Array<any>)?.filter((b: any) => b.type === "text") ?? []
+    if (textBlocks.length === 0) return undefined
+
+    const output = textBlocks.map((b: any) => b.text).join("")
+    const fullOutputPath = (event.details as any)?.fullOutputPath
+
+    const result = filterBashOutput({
+      command,
+      output,
+      isError: event.isError ?? false,
+      fullOutputPath,
+    })
+
+    if (!result.filtered) return undefined
+
+    // Replace content with filtered version
+    return {
+      content: [{ type: "text", text: result.output }],
+      details: {
+        ...event.details,
+        bashFilter: {
+          strategy: result.strategy,
+          originalBytes: result.originalBytes,
+          filteredBytes: result.filteredBytes,
+        },
+      },
     }
-    if (footerTui) footerTui.requestRender()
   })
 
-  // Enable custom footer on session start
-  pi.on("session_start", async (_event, ctx) => {
-    projectPath = process.cwd()
-    statsEnabled = true
-    toolCounts.clear()
-    subagentCount = 0
-    ctx.ui.setFooter((tui, theme, footerData) => {
-      footerTui = tui
-      const unsub = footerData.onBranchChange(() => tui.requestRender())
-      return {
-        dispose: () => {
-          unsub()
-          footerTui = null
-        },
-        invalidate() {},
-        render(width: number): string[] {
-          return renderStatsFooter(ctx, tui, theme, footerData, width)
-        },
-      }
+  // Read output smart filter — reduces context waste from large file reads
+  pi.on("tool_result", async (event, _ctx) => {
+    if (event.toolName !== "read") return undefined
+
+    // Extract path from input
+    const path = (event.input as any)?.path ?? ""
+    if (!path) return undefined
+
+    // Extract text content from tool result
+    const textBlocks = (event.content as Array<any>)?.filter((b: any) => b.type === "text") ?? []
+    if (textBlocks.length === 0) return undefined
+
+    const output = textBlocks.map((b: any) => b.text).join("")
+    const isImage = (event.content as Array<any>)?.some((b: any) => b.type === "image") ?? false
+
+    const result = filterReadOutput({
+      path,
+      output,
+      isError: event.isError ?? false,
+      isImage,
     })
+
+    if (!result.filtered) return undefined
+
+    return {
+      content: [{ type: "text", text: result.output }],
+      details: {
+        ...event.details,
+        readFilter: {
+          strategy: result.strategy,
+          originalBytes: result.originalBytes,
+          filteredBytes: result.filteredBytes,
+        },
+      },
+    }
   })
 
-  // /stats command to toggle footer
-  pi.registerCommand("stats", {
-    description: "Toggle stats footer (project path, tool usage, subagent count)",
-    handler: async (_args, ctx) => {
-      statsEnabled = !statsEnabled
-      if (statsEnabled) {
-        ctx.ui.setFooter((tui, theme, footerData) => {
-          footerTui = tui
-          const unsub = footerData.onBranchChange(() => tui.requestRender())
-          return {
-            dispose: () => {
-              unsub()
-              footerTui = null
-            },
-            invalidate() {},
-            render(width: number): string[] {
-              return renderStatsFooter(ctx, tui, theme, footerData, width)
-            },
-          }
-        })
-        ctx.ui.notify("Stats footer enabled", "info")
-      } else {
-        ctx.ui.setFooter(undefined)
-        ctx.ui.notify("Default footer restored", "info")
-      }
-    },
+  // Compaction prompt optimizer — makes summaries more focused and useful
+  pi.on("session_before_compact", async (_event, _ctx) => {
+    return {
+      customInstructions: COMPACTION_FOCUS_INSTRUCTIONS,
+    }
   })
 }
 
+
 export { createArtifactHelperTool } from "./tools/artifact-helper"
 export { createAskUserQuestionTool } from "./tools/ask-user-question"
 export { createSubagentTool } from "./tools/subagent"
@@ -619,3 +612,6 @@ export {
   getRunArtifactPath,
 } from "./utils/artifact-paths"
 export { normalizeSlug } from "./utils/name-utils"
+export { filterBashOutput } from "./tools/bash-output-filter"
+export { filterReadOutput } from "./tools/read-output-filter"
+export { COMPACTION_FOCUS_INSTRUCTIONS, TURN_PREFIX_FOCUS_INSTRUCTIONS } from "./tools/compaction-optimizer"

package/extensions/ce-core/tools/bash-output-filter.ts

@@ -0,0 +1,402 @@
+import { Type } from "@sinclair/typebox"
+
+// ============================================================================
+// Types
+// ============================================================================
+
+export interface BashOutputFilterInput {
+  /** The bash command that was run */
+  command: string
+  /** The raw output text */
+  output: string
+  /** Whether the command exited with an error */
+  isError: boolean
+  /** Original full output path (if truncated by pi) */
+  fullOutputPath?: string
+}
+
+export interface BashOutputFilterResult {
+  /** Filtered output text */
+  output: string
+  /** Whether filtering was applied */
+  filtered: boolean
+  /** Original size in bytes */
+  originalBytes: number
+  /** Filtered size in bytes */
+  filteredBytes: number
+  /** The filter strategy that was applied */
+  strategy: string
+}
+
+// ============================================================================
+// Command Classification
+// ============================================================================
+
+type CommandCategory = "install" | "test" | "build" | "search" | "git-diff" | "list" | "http" | "unknown"
+
+interface CommandPattern {
+  pattern: RegExp
+  category: CommandCategory
+  /** Whether this is a "means" command (output is a side-effect) */
+  isMeans: boolean
+}
+
+const COMMAND_PATTERNS: CommandPattern[] = [
+  // Install commands — output is a side-effect
+  { pattern: /\b(npm|yarn|pnpm|bun)\s+(install|i|add|ci|update|upgrade)\b/, category: "install", isMeans: true },
+  { pattern: /\b(pip|pip3|poetry|conda)\s+(install|add)\b/, category: "install", isMeans: true },
+  { pattern: /\b(cargo)\s+(install|add|update)\b/, category: "install", isMeans: true },
+  { pattern: /\b(bundle|gem)\s+(install)\b/, category: "install", isMeans: true },
+  { pattern: /\b(go)\s+(get|install|mod\s+(tidy|download))\b/, category: "install", isMeans: true },
+  // Test commands — output is mostly noise (pass lines), failures are signal
+  { pattern: /\b(npm|yarn|pnpm|bun)\s+(test|t|run\s+test)/, category: "test", isMeans: true },
+  { pattern: /\b(vitest|jest|mocha|pytest|cargo\s+test|go\s+test|ruby|-Ilib)\b.*\b(test|spec)\b/, category: "test", isMeans: true },
+  { pattern: /\b(jest|vitest|mocha|pytest|npx\s+(jest|vitest|mocha))\b/, category: "test", isMeans: true },
+  { pattern: /\b(cargo)\s+test\b/, category: "test", isMeans: true },
+  { pattern: /\b(go)\s+test\b/, category: "test", isMeans: true },
+  // Build/compile commands — warnings/errors are signal
+  { pattern: /\b(tsc|typescript|tscl)\b/, category: "build", isMeans: true },
+  { pattern: /\b(npm|yarn|pnpm|bun)\s+(run\s+)?(build|compile)\b/, category: "build", isMeans: true },
+  { pattern: /\b(cargo)\s+(build|check|clippy)\b/, category: "build", isMeans: true },
+  { pattern: /\b(make|cmake|gcc|g\+\+|clang)\b/, category: "build", isMeans: true },
+  { pattern: /\b(dotnet)\s+(build|publish)\b/, category: "build", isMeans: true },
+  { pattern: /\b(gradle|mvn|mvnw)\b/, category: "build", isMeans: true },
+  // Search commands — output IS the purpose, don't filter
+  { pattern: /\b(grep|rg|ag|ack|git\s+grep)\b/, category: "search", isMeans: false },
+  { pattern: /\b(rg|ripgrep)\b/, category: "search", isMeans: false },
+  // Git diff/log — output IS the purpose
+  { pattern: /\bgit\s+(diff|log|show|range-diff)\b/, category: "git-diff", isMeans: false },
+  // File listing — moderate filtering ok
+  { pattern: /\b(find|fd|ls\s+-R|tree|du|ncdu)\b/, category: "list", isMeans: false },
+  // HTTP requests — can be verbose
+  { pattern: /\b(curl|wget|httpie|http\s+)\b/, category: "http", isMeans: false },
+]
+
+function classifyCommand(command: string): CommandPattern | null {
+  // Normalize command: remove leading whitespace, handle pipes
+  const cmd = command.trim()
+
+  // Check primary command (before any pipe)
+  const primaryCmd = cmd.split("|")[0].trim()
+
+  for (const pattern of COMMAND_PATTERNS) {
+    if (pattern.pattern.test(primaryCmd)) {
+      return pattern
+    }
+  }
+
+  return null
+}
+
+// ============================================================================
+// Output Filters
+// ============================================================================
+
+/**
+ * Filter for install command output.
+ * Keep: error lines, warning lines, summary lines (added/removed/changed counts).
+ * Remove: progress bars, download lines, individual package install lines.
+ */
+function filterInstallOutput(output: string): string {
+  const lines = output.split("\n")
+  const kept: string[] = []
+  let removedCount = 0
+
+  for (const line of lines) {
+    // Always keep: empty lines (structure), errors, warnings, summary
+    if (
+      line.trim() === "" ||
+      /(error|ERR!|fatal|FAILED|failed|abort|timeout)/i.test(line) ||
+      /\b(warn|WARN|warning|deprecat)\b/i.test(line) ||
+      /\b(added|removed|changed|updated|audited)\s+\d+/i.test(line) ||
+      /\bpackages?\b.*\b(look|found|installed|removed)\b/i.test(line) ||
+      /\bvulnerabilities\b/i.test(line) ||
+      /^\s*$/.test(line) ||
+      line.startsWith("[") ||
+      /^\s*(\d+ packages?|up to date|already|nothing)/i.test(line)
+    ) {
+      kept.push(line)
+    } else {
+      removedCount++
+    }
+  }
+
+  // Deduplicate consecutive empty lines
+  return deduplicateEmptyLines(kept.join("\n"))
+}
+
+/**
+ * Filter for test command output.
+ * Keep: FAIL, ERROR, summary, test suite headers.
+ * Remove: PASS lines (✓, ✔, PASS, ✓), progress dots.
+ */
+function filterTestOutput(output: string): string {
+  const lines = output.split("\n")
+  const kept: string[] = []
+  let removedCount = 0
+
+  for (const line of lines) {
+    // Always keep: errors, failures, summary, suite names
+    if (
+      line.trim() === "" ||
+      /\b(FAIL|FAILING|FAILED|ERROR|✕|✗|×|✘|broken)\b/i.test(line) ||
+      /\b(fail|failure|error|timeout|crash)\b.*\d/i.test(line) ||
+      /\b(tests?|suites?|files?|passed|failed|skipped|pending)\s*[:=]?\s*\d/i.test(line) ||
+      /\b(RUN|RUNS)\s/i.test(line) || // vitest running indicator
+      /^\s*(FAIL|PASS|ERROR|SKIP|TODO)\s+(?:\s|\[)/i.test(line) ||
+      /^[\s│┌┐└┘├┤┬┴┼─]+/.test(line) || // Box drawing (test summaries)
+      /\b(synopsis|assert|expect|received|expected)\b/i.test(line) ||
+      /\s+(→|at)\s+.*\.\w+\s*$/i.test(line) || // Stack traces
+      /\d+\.\d+\s*(s|ms)\s*$/.test(line.trim()) || // Timing lines
+      line.includes("Test Suites:") ||
+      line.includes("Tests:") ||
+      line.includes("Snapshots:") ||
+      line.includes("Time:")
+    ) {
+      kept.push(line)
+    } else if (
+      // Specifically skip PASS lines
+      /^\s*✓|✔|PASS|✅|·/.test(line) ||
+      /^\s*√/.test(line) ||
+      /^\s*ok\s+\d+/.test(line) ||
+      /^\s*\.\s*$/.test(line.trim()) // Progress dots
+    ) {
+      removedCount++
+    } else {
+      // Keep lines that don't match pass patterns (context lines)
+      kept.push(line)
+    }
+  }
+
+  return deduplicateEmptyLines(kept.join("\n"))
+}
+
+/**
+ * Filter for build/compile output.
+ * Keep: error lines, warning lines (deduplicated), summary.
+ * Remove: successful compilation lines, progress indicators.
+ */
+function filterBuildOutput(output: string): string {
+  const lines = output.split("\n")
+  const kept: string[] = []
+  const seenWarnings = new Set<string>()
+  let removedCount = 0
+
+  for (const line of lines) {
+    if (line.trim() === "") {
+      kept.push(line)
+      continue
+    }
+
+    // Always keep errors
+    if (/\b(error|Error:|fatal|FAILED|failed)\b/i.test(line)) {
+      kept.push(line)
+      continue
+    }
+
+    // Deduplicate warnings (keep first occurrence)
+    if (/\b(warning|warn)\b/i.test(line)) {
+      const normalized = line.replace(/:\d+:\d+/g, ":N:N").trim()
+      if (!seenWarnings.has(normalized)) {
+        seenWarnings.add(normalized)
+        kept.push(line)
+      } else {
+        kept.push(`  ... (${countByPattern(lines, normalized)} similar warnings omitted)`)
+      }
+      continue
+    }
+
+    // Keep summary lines
+    if (
+      /\b(compiled|built|generated|error|warning)\s*\d/i.test(line) ||
+      /\b(Finished|Compiling|Building)\b/i.test(line) ||
+      /error\(s\)|warning\(s\)/i.test(line)
+    ) {
+      kept.push(line)
+      continue
+    }
+
+    // Skip progress/success lines
+    if (
+      /^\s*(Compiling|Building|Generating)\s/i.test(line) ||
+      /^\s*\[.*\]\s/.test(line) // [1/10] style progress
+    ) {
+      removedCount++
+      continue
+    }
+
+    // Keep everything else (might be important context)
+    kept.push(line)
+  }
+
+  return deduplicateEmptyLines(kept.join("\n"))
+}
+
+/**
+ * General filter for any large output.
+ * Applies safe, universal compression:
+ * - Collapse consecutive empty lines
+ * - Remove ANSI escape sequences
+ * - Trim trailing whitespace
+ */
+function filterGenericOutput(output: string): string {
+  // Remove ANSI escape sequences
+  const cleaned = output.replace(/\x1b\[[0-9;]*[a-zA-Z]/g, "")
+  // Deduplicate empty lines
+  return deduplicateEmptyLines(cleaned)
+}
+
+// ============================================================================
+// Helpers
+// ============================================================================
+
+function deduplicateEmptyLines(text: string): string {
+  return text.replace(/\n{3,}/g, "\n\n")
+}
+
+function countByPattern(lines: string[], normalizedPattern: string): number {
+  let count = 0
+  for (const line of lines) {
+    if (line.replace(/:\d+:\d+/g, ":N:N").trim() === normalizedPattern) {
+      count++
+    }
+  }
+  return count
+}
+
+function formatBytes(bytes: number): string {
+  if (bytes < 1024) return `${bytes}B`
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)}KB`
+  return `${(bytes / (1024 * 1024)).toFixed(1)}MB`
+}
+
+// ============================================================================
+// Main Filter Function
+// ============================================================================
+
+/** Minimum output size (bytes) to trigger any filtering */
+const MIN_FILTER_THRESHOLD = 2048 // 2KB
+
+/** Maximum filtered output size (bytes) — aggressive cutoff for very large outputs */
+const MAX_FILTERED_SIZE = 30720 // 30KB
+
+export function filterBashOutput(input: BashOutputFilterInput): BashOutputFilterResult {
+  const { command, output, isError, fullOutputPath } = input
+  const originalBytes = Buffer.byteLength(output, "utf-8")
+
+  // Don't filter small outputs
+  if (originalBytes < MIN_FILTER_THRESHOLD) {
+    return {
+      output,
+      filtered: false,
+      originalBytes,
+      filteredBytes: originalBytes,
+      strategy: "none (below threshold)",
+    }
+  }
+
+  // Don't filter error outputs — they need to be complete
+  if (isError) {
+    return {
+      output,
+      filtered: false,
+      originalBytes,
+      filteredBytes: originalBytes,
+      strategy: "none (error output)",
+    }
+  }
+
+  const matched = classifyCommand(command)
+
+  // If no pattern matched, apply generic filtering for large outputs
+  if (!matched) {
+    if (originalBytes > MAX_FILTERED_SIZE) {
+      const filtered = filterGenericOutput(output)
+      const filteredBytes = Buffer.byteLength(filtered, "utf-8")
+      if (filteredBytes < originalBytes * 0.9) {
+        return {
+          output: appendFilterNotice(filtered, originalBytes, filteredBytes, "generic", fullOutputPath),
+          filtered: true,
+          originalBytes,
+          filteredBytes,
+          strategy: "generic (large unknown command)",
+        }
+      }
+    }
+    return {
+      output,
+      filtered: false,
+      originalBytes,
+      filteredBytes: originalBytes,
+      strategy: "none (unknown command, below aggressive threshold)",
+    }
+  }
+
+  // Don't filter "purpose" commands (search, git diff) unless extremely large
+  if (!matched.isMeans && originalBytes < MAX_FILTERED_SIZE) {
+    return {
+      output,
+      filtered: false,
+      originalBytes,
+      filteredBytes: originalBytes,
+      strategy: `none (${matched.category}: purpose command, within limit)`,
+    }
+  }
+
+  // Apply category-specific filter
+  let filtered: string
+  let strategyName: string
+
+  switch (matched.category) {
+    case "install":
+      filtered = filterInstallOutput(output)
+      strategyName = "install (errors + summary only)"
+      break
+    case "test":
+      filtered = filterTestOutput(output)
+      strategyName = "test (failures + summary only)"
+      break
+    case "build":
+      filtered = filterBuildOutput(output)
+      strategyName = "build (errors + deduplicated warnings)"
+      break
+    default:
+      // Purpose commands that are very large get generic filtering
+      filtered = filterGenericOutput(output)
+      strategyName = `generic (${matched.category}: large output)`
+      break
+  }
+
+  const filteredBytes = Buffer.byteLength(filtered, "utf-8")
+
+  // If filtering didn't help much (< 20% reduction), keep original
+  if (filteredBytes > originalBytes * 0.8) {
+    return {
+      output,
+      filtered: false,
+      originalBytes,
+      filteredBytes,
+      strategy: `none (${matched.category}: filtering insufficient, <20% reduction)`,
+    }
+  }
+
+  return {
+    output: appendFilterNotice(filtered, originalBytes, filteredBytes, strategyName, fullOutputPath),
+    filtered: true,
+    originalBytes,
+    filteredBytes,
+    strategy: strategyName,
+  }
+}
+
+function appendFilterNotice(
+  output: string,
+  originalBytes: number,
+  filteredBytes: number,
+  strategy: string,
+  fullOutputPath?: string,
+): string {
+  const saved = formatBytes(originalBytes - filteredBytes)
+  const notice = `\n\n[Output filtered: ${formatBytes(originalBytes)} → ${formatBytes(filteredBytes)} (${saved} saved, strategy: ${strategy})${fullOutputPath ? `. Full output: ${fullOutputPath}` : ""}]`
+  return output + notice
+}

package/extensions/ce-core/tools/compaction-optimizer.ts

@@ -0,0 +1,38 @@
+// ============================================================================
+// Compaction Prompt Optimizer
+// ============================================================================
+//
+// Hooks into `session_before_compact` to inject custom instructions that make
+// compaction summaries more focused and useful for coding agent context.
+//
+// This is a "prompt-only" optimization — it doesn't replace pi's compaction
+// flow, just adds focus instructions to the summarization prompt.
+
+/**
+ * Custom instructions appended to compaction summarization prompts.
+ *
+ * Goals:
+ * 1. Preserve exact technical identifiers (paths, names, error messages)
+ * 2. Be terse on reasoning process, verbose on concrete state changes
+ * 3. Summarize file reads by purpose rather than including code snippets
+ * 4. Keep Critical Context section detailed for continuation
+ */
+export const COMPACTION_FOCUS_INSTRUCTIONS = `Additional focus for this summary:
+
+1. Preserve EXACT file paths, function names, class names, variable names, and error messages — never paraphrase these
+2. For each code change, note: file path, function/class, what changed, and why
+3. Summarize file reads by their purpose (e.g., "read auth.ts to understand JWT middleware flow") rather than including code snippets
+4. Be concise on the agent's reasoning process; be verbose on concrete state changes and decisions
+5. Keep the "Critical Context" section detailed — this is what the agent needs to continue working
+6. If any tests were run, summarize results by: file, pass/fail count, and specific failure messages
+7. Note any blocked items and their exact error state`
+
+/**
+ * Additional instructions for turn-prefix summaries (split turns).
+ * These are more concise since the turn suffix is retained.
+ */
+export const TURN_PREFIX_FOCUS_INSTRUCTIONS = `Focus the turn-prefix summary on:
+- What the user originally asked for
+- Key decisions made in the prefix
+- Exact file paths and identifiers needed to understand the retained suffix
+Skip reasoning details — only keep actionable context.`

package/extensions/ce-core/tools/read-output-filter.ts

@@ -0,0 +1,506 @@
+// ============================================================================
+// Read Output Filter
+// ============================================================================
+//
+// Filters `read` tool output at the source (via tool_result hook) to reduce
+// context waste from large file reads. Symmetric with bash-output-filter.ts.
+//
+// Strategies:
+// 1. Lock / generated files → extreme compression (summary only)
+// 2. package.json → keep scripts + dep summary, drop full version lists
+// 3. Large code files → keep signatures/structure, collapse bodies
+// 4. Large markdown → keep headings + first paragraph per section
+// 5. Generic → head/tail truncation for very large files
+
+// ============================================================================
+// Types
+// ============================================================================
+
+export interface ReadOutputFilterInput {
+  /** File path that was read */
+  path: string
+  /** The raw output text */
+  output: string
+  /** Whether the read resulted in an error */
+  isError?: boolean
+  /** Whether the file is an image (skip filtering) */
+  isImage?: boolean
+}
+
+export interface ReadOutputFilterResult {
+  /** Filtered output text */
+  output: string
+  /** Whether filtering was applied */
+  filtered: boolean
+  /** Original size in bytes */
+  originalBytes: number
+  /** Filtered size in bytes */
+  filteredBytes: number
+  /** The filter strategy that was applied */
+  strategy: string
+}
+
+// ============================================================================
+// File Classification
+// ============================================================================
+
+type FileCategory =
+  | "lock-file"
+  | "generated-file"
+  | "minified-file"
+  | "package-json"
+  | "code"
+  | "markdown"
+  | "config"
+  | "unknown"
+
+interface FilePattern {
+  test: (path: string) => boolean
+  category: FileCategory
+}
+
+const FILE_PATTERNS: FilePattern[] = [
+  // Lock files — extreme compression
+  { test: (p) => /(^|\/)(package-lock\.json|yarn\.lock|bun\.lock|pnpm-lock\.yaml|Gemfile\.lock|Podfile\.lock|composer\.lock|Cargo\.lock)$/.test(p), category: "lock-file" },
+  // Minified / bundle files
+  { test: (p) => /\.(min\.js|min\.css|bundle\.js|chunk\.js|vendor\.js)$/i.test(p), category: "minified-file" },
+  // Generated files
+  { test: (p) => /\.(generated\.\w+|auto\.\w+|pb\.ts)$/i.test(p) || /(?:^|\/)(generated|auto-generated|__generated__)\//i.test(p), category: "generated-file" },
+  // package.json — smart filter
+  { test: (p) => /(^|\/)package\.json$/.test(p), category: "package-json" },
+  // Markdown
+  { test: (p) => /\.(md|mdx)$/i.test(p), category: "markdown" },
+  // Config files (JSON/YAML/TOML without lock)
+  { test: (p) => /\.(jsonc?|ya?ml|toml|ini|conf|rc)$/i.test(p) && !/lock/i.test(p), category: "config" },
+  // Code files
+  { test: (p) => /\.(ts|tsx|js|jsx|py|rs|go|java|kt|rb|c|cpp|h|hpp|cs|swift|zig|scala|clj)$/i.test(p), category: "code" },
+  // Code files (alternate extensions)
+  { test: (p) => /\.(vue|svelte|astro|sol|dart|lua|r|pl|pm|sh|bash|zsh|fish|ps1)$/i.test(p), category: "code" },
+]
+
+function classifyFile(path: string): FileCategory {
+  const normalized = path.replace(/\\/g, "/")
+  for (const pattern of FILE_PATTERNS) {
+    if (pattern.test(normalized)) return pattern.category
+  }
+  return "unknown"
+}
+
+// ============================================================================
+// Constants
+// ============================================================================
+
+/** Minimum output size (bytes) to trigger any filtering */
+const MIN_FILTER_THRESHOLD = 2048 // 2KB
+
+/** Maximum size for structural code compression trigger */
+const CODE_COMPRESS_THRESHOLD = 8192 // 8KB
+
+/** Maximum filtered output size (bytes) */
+const MAX_FILTERED_SIZE = 30720 // 30KB
+
+// ============================================================================
+// Filter: Lock Files
+// ============================================================================
+
+function filterLockFile(output: string, path: string): string {
+  const bytes = Buffer.byteLength(output, "utf-8")
+  const lines = output.split("\n").length
+
+  // Try to extract name and lockfileVersion from JSON lock files
+  let summary = `Lock file: ${path.split("/").pop()}`
+
+  try {
+    const data = JSON.parse(output)
+    if (data.name) summary += `\nProject: ${data.name}`
+    if (data.lockfileVersion) summary += `\nLockfile version: ${data.lockfileVersion}`
+    if (data.packages) {
+      const pkgCount = Object.keys(data.packages).length
+      summary += `\nPackages: ${pkgCount}`
+    }
+  } catch {
+    // Not JSON (yarn.lock, etc.) — count lines
+    summary += `\nLines: ${lines}`
+  }
+
+  summary += `\nOriginal size: ${formatBytes(bytes)}`
+  return summary
+}
+
+// ============================================================================
+// Filter: Minified / Generated Files
+// ============================================================================
+
+function filterMinifiedFile(output: string, path: string): string {
+  const bytes = Buffer.byteLength(output, "utf-8")
+  const ext = path.split(".").pop() ?? ""
+  return [
+    `Minified ${ext} file: ${path.split("/").pop()}`,
+    `Size: ${formatBytes(bytes)} (${output.split("\n").length} lines)`,
+    `First 500 chars:`,
+    output.slice(0, 500),
+    "",
+    `[... ${formatBytes(bytes - 500)} omitted]`,
+  ].join("\n")
+}
+
+function filterGeneratedFile(output: string, path: string): string {
+  const bytes = Buffer.byteLength(output, "utf-8")
+  const lines = output.split("\n")
+
+  // Keep first 30 lines + last 10 lines + count
+  if (lines.length <= 50) return output
+
+  const head = lines.slice(0, 30)
+  const tail = lines.slice(-10)
+  const omitted = lines.length - 40
+
+  return [
+    ...head,
+    "",
+    `[... ${omitted} lines omitted (generated file, ${formatBytes(bytes)})]`,
+    "",
+    ...tail,
+  ].join("\n")
+}
+
+// ============================================================================
+// Filter: package.json
+// ============================================================================
+
+function filterPackageJson(output: string): string {
+  try {
+    const pkg = JSON.parse(output)
+    const sections: string[] = []
+
+    sections.push(`Name: ${pkg.name ?? "unknown"}`)
+    if (pkg.version) sections.push(`Version: ${pkg.version}`)
+    if (pkg.description) sections.push(`Description: ${pkg.description}`)
+
+    if (pkg.scripts && Object.keys(pkg.scripts).length > 0) {
+      sections.push("")
+      sections.push("Scripts:")
+      for (const [name, cmd] of Object.entries(pkg.scripts)) {
+        sections.push(`  ${name}: ${cmd}`)
+      }
+    }
+
+    if (pkg.dependencies) {
+      const depCount = Object.keys(pkg.dependencies).length
+      sections.push("")
+      sections.push(`Dependencies (${depCount}):`)
+      if (depCount <= 15) {
+        for (const [name, ver] of Object.entries(pkg.dependencies)) {
+          sections.push(`  ${name}: ${ver}`)
+        }
+      } else {
+        // Show first 10 + summary
+        const entries = Object.entries(pkg.dependencies)
+        for (const [name, ver] of entries.slice(0, 10)) {
+          sections.push(`  ${name}: ${ver}`)
+        }
+        sections.push(`  ... and ${depCount - 10} more`)
+      }
+    }
+
+    if (pkg.devDependencies) {
+      const devCount = Object.keys(pkg.devDependencies).length
+      sections.push("")
+      sections.push(`DevDependencies (${devCount}):`)
+      if (devCount <= 10) {
+        for (const [name, ver] of Object.entries(pkg.devDependencies)) {
+          sections.push(`  ${name}: ${ver}`)
+        }
+      } else {
+        const entries = Object.entries(pkg.devDependencies)
+        for (const [name, ver] of entries.slice(0, 5)) {
+          sections.push(`  ${name}: ${ver}`)
+        }
+        sections.push(`  ... and ${devCount - 5} more`)
+      }
+    }
+
+    return sections.join("\n")
+  } catch {
+    // Not valid JSON — generic truncation
+    return truncateGeneric(output)
+  }
+}
+
+// ============================================================================
+// Filter: Large Code Files — Structural Compression
+// ============================================================================
+
+/**
+ * Structural compression for code files.
+ * Keeps: imports, exports, type definitions, function/class signatures, comments with TODO/FIXME/HACK
+ * Collapses: function bodies > N lines, consecutive blank lines
+ */
+function filterCodeFile(output: string): string {
+  const lines = output.split("\n")
+  const kept: string[] = []
+  let bodyDepth = 0
+  let bodyLines = 0
+  let skippedInBody = 0
+  const MAX_BODY_LINES = 8 // keep first N lines of a body
+
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i]
+    const trimmed = line.trim()
+
+    // Track brace depth for body detection
+    const opens = (line.match(/\{/g) || []).length
+    const closes = (line.match(/\}/g) || []).length
+
+    // Always keep: empty lines (structure), imports, exports, type/interface/class declarations
+    // comments with TODO/FIXME/HACK, decorators
+    if (
+      trimmed === "" ||
+      /^(import |export |from )/.test(trimmed) ||
+      /^(export )?(default |abstract |async |const |let |var |function |class |interface |type |enum )/.test(trimmed) ||
+      /^(\/\/|#|\/\*|\*)/.test(trimmed) ||
+      /\b(TODO|FIXME|HACK|XXX|WARN|BUG|NOTE)\b/i.test(trimmed) ||
+      /^@/.test(trimmed) || // decorators
+      /^}\s*$/.test(trimmed) // closing brace
+    ) {
+      // If we were skipping body lines, add omission marker
+      if (skippedInBody > 0) {
+        kept.push(`  [... ${skippedInBody} lines omitted]`)
+        skippedInBody = 0
+      }
+      kept.push(line)
+      bodyDepth += opens - closes
+      bodyLines = 0
+      continue
+    }
+
+    // Inside a body (after opening brace)
+    bodyDepth += opens - closes
+
+    if (bodyDepth > 1 || (bodyDepth === 1 && bodyLines < MAX_BODY_LINES)) {
+      kept.push(line)
+      bodyLines++
+    } else if (bodyDepth === 1 && bodyLines >= MAX_BODY_LINES) {
+      // Skip body lines but track count
+      skippedInBody++
+      bodyLines++
+    } else {
+      // Top-level or unknown — keep it
+      kept.push(line)
+    }
+  }
+
+  // Final omission marker
+  if (skippedInBody > 0) {
+    kept.push(`  [... ${skippedInBody} lines omitted]`)
+  }
+
+  return deduplicateEmptyLines(kept.join("\n"))
+}
+
+// ============================================================================
+// Filter: Markdown
+// ============================================================================
+
+function filterMarkdown(output: string): string {
+  const lines = output.split("\n")
+  const kept: string[] = []
+  let inParagraph = false
+  let paragraphLineCount = 0
+  let inCodeBlock = false
+
+  for (const line of lines) {
+    const trimmed = line.trim()
+
+    // Track code block state
+    if (trimmed.startsWith("```")) {
+      inCodeBlock = !inCodeBlock
+      kept.push(line)
+      continue
+    }
+
+    // Keep all lines inside code blocks
+    if (inCodeBlock) {
+      kept.push(line)
+      continue
+    }
+
+    // Always keep headings
+    if (/^#{1,6}\s/.test(trimmed)) {
+      kept.push(line)
+      inParagraph = false
+      paragraphLineCount = 0
+      continue
+    }
+
+    // Empty lines
+    if (trimmed === "") {
+      kept.push(line)
+      inParagraph = false
+      paragraphLineCount = 0
+      continue
+    }
+
+    // Keep first paragraph line after heading, skip the rest
+    if (!inParagraph) {
+      kept.push(line)
+      inParagraph = true
+      paragraphLineCount = 1
+    } else {
+      paragraphLineCount++
+      // Skip subsequent paragraph lines
+      if (paragraphLineCount === 2) {
+        kept.push(`  [... additional paragraph content omitted]`)
+      }
+    }
+  }
+
+  return deduplicateEmptyLines(kept.join("\n"))
+}
+
+// ============================================================================
+// Filter: Generic
+// ============================================================================
+
+function truncateGeneric(output: string): string {
+  const lines = output.split("\n")
+  const bytes = Buffer.byteLength(output, "utf-8")
+
+  if (lines.length <= 100) return output
+
+  const head = lines.slice(0, 50)
+  const tail = lines.slice(-10)
+  const omitted = lines.length - 60
+
+  return [
+    ...head,
+    "",
+    `[... ${omitted} lines omitted (${formatBytes(bytes)})]`,
+    "",
+    ...tail,
+  ].join("\n")
+}
+
+// ============================================================================
+// Helpers
+// ============================================================================
+
+function deduplicateEmptyLines(text: string): string {
+  return text.replace(/\n{3,}/g, "\n\n")
+}
+
+function formatBytes(bytes: number): string {
+  if (bytes < 1024) return `${bytes}B`
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)}KB`
+  return `${(bytes / (1024 * 1024)).toFixed(1)}MB`
+}
+
+function appendFilterNotice(
+  output: string,
+  originalBytes: number,
+  filteredBytes: number,
+  strategy: string,
+): string {
+  const saved = formatBytes(originalBytes - filteredBytes)
+  return `${output}\n\n[Read output filtered: ${formatBytes(originalBytes)} → ${formatBytes(filteredBytes)} (${saved} saved, strategy: ${strategy})]`
+}
+
+// ============================================================================
+// Main Filter Function
+// ============================================================================
+
+export function filterReadOutput(input: ReadOutputFilterInput): ReadOutputFilterResult {
+  const { path, output, isError, isImage } = input
+  const originalBytes = Buffer.byteLength(output, "utf-8")
+
+  // Don't filter images
+  if (isImage) {
+    return { output, filtered: false, originalBytes, filteredBytes: originalBytes, strategy: "none (image)" }
+  }
+
+  // Don't filter error outputs
+  if (isError) {
+    return { output, filtered: false, originalBytes, filteredBytes: originalBytes, strategy: "none (error)" }
+  }
+
+  // Don't filter small outputs
+  if (originalBytes < MIN_FILTER_THRESHOLD) {
+    return { output, filtered: false, originalBytes, filteredBytes: originalBytes, strategy: "none (below threshold)" }
+  }
+
+  const category = classifyFile(path)
+
+  let filtered: string
+  let strategyName: string
+
+  switch (category) {
+    case "lock-file":
+      filtered = filterLockFile(output, path)
+      strategyName = "lock-file (summary only)"
+      break
+
+    case "minified-file":
+      filtered = filterMinifiedFile(output, path)
+      strategyName = "minified (head only)"
+      break
+
+    case "generated-file":
+      filtered = filterGeneratedFile(output, path)
+      strategyName = "generated (head + tail)"
+      break
+
+    case "package-json":
+      filtered = filterPackageJson(output)
+      strategyName = "package.json (scripts + dep summary)"
+      break
+
+    case "code":
+      if (originalBytes >= CODE_COMPRESS_THRESHOLD) {
+        filtered = filterCodeFile(output)
+        strategyName = "code (structural compression)"
+      } else {
+        return { output, filtered: false, originalBytes, filteredBytes: originalBytes, strategy: "none (code file below threshold)" }
+      }
+      break
+
+    case "markdown":
+      filtered = filterMarkdown(output)
+      strategyName = "markdown (headings + first paragraph)"
+      break
+
+    case "config":
+      // Config files: only filter if very large
+      if (originalBytes > MAX_FILTERED_SIZE) {
+        filtered = truncateGeneric(output)
+        strategyName = "config (generic truncation)"
+      } else {
+        return { output, filtered: false, originalBytes, filteredBytes: originalBytes, strategy: "none (config, within limit)" }
+      }
+      break
+
+    default:
+      // Unknown files: only filter if very large
+      if (originalBytes > MAX_FILTERED_SIZE) {
+        filtered = truncateGeneric(output)
+        strategyName = "generic (large unknown file)"
+      } else {
+        return { output, filtered: false, originalBytes, filteredBytes: originalBytes, strategy: "none (unknown, within limit)" }
+      }
+      break
+  }
+
+  const filteredBytes = Buffer.byteLength(filtered, "utf-8")
+
+  // If filtering didn't help much (< 20% reduction), keep original
+  if (filteredBytes > originalBytes * 0.8) {
+    return { output, filtered: false, originalBytes, filteredBytes, strategy: `none (${category}: filtering insufficient, <20% reduction)` }
+  }
+
+  return {
+    output: appendFilterNotice(filtered, originalBytes, filteredBytes, strategyName),
+    filtered: true,
+    originalBytes,
+    filteredBytes,
+    strategy: strategyName,
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@leing2021/super-pi",
-  "version": "0.14.2",
+  "version": "0.16.0",
   "private": false,
   "type": "module",
   "description": "Pi-native Compound Engineering package for iterative development workflows",