@shepai/cli 1.180.0 → 1.181.0-pr539.0993dc0

package/dist/packages/core/src/infrastructure/services/agents/feature-agent/prompt-optimization-context.js

@@ -0,0 +1,92 @@
+/**
+ * Prompt Optimization Context
+ *
+ * Module-level singleton that exposes the token-optimization layer to
+ * executeNode() in node-helpers.ts without changing its public API.
+ *
+ * The worker calls setPromptOptimizationContext() once after DI init.
+ * Node helpers call optimizePromptIfEnabled() before invoking the agent
+ * executor and recordOptimizationMetricsIfEnabled() after the phase
+ * timing record is updated.
+ *
+ * Errors are swallowed so optimization failures never block graph execution.
+ */
+import { hasSettings, getSettings } from '../../../services/settings.service.js';
+let contextOptimizer;
+let contextMetricsService;
+let contextRunId;
+let contextFeatureId;
+/**
+ * Set the prompt-optimization context. Called once by the worker after DI init.
+ */
+export function setPromptOptimizationContext(optimizer, metricsService, runId, featureId) {
+    contextOptimizer = optimizer;
+    contextMetricsService = metricsService;
+    contextRunId = runId;
+    contextFeatureId = featureId;
+}
+/**
+ * Clear the prompt-optimization context. Useful for testing.
+ */
+export function clearPromptOptimizationContext() {
+    contextOptimizer = undefined;
+    contextMetricsService = undefined;
+    contextRunId = undefined;
+    contextFeatureId = undefined;
+}
+/**
+ * Resolve the effective TokenOptimizationConfig from settings. Returns
+ * undefined if settings are not initialized.
+ */
+function resolveConfig() {
+    if (!hasSettings())
+        return undefined;
+    return getSettings().workflow?.tokenOptimization;
+}
+/**
+ * Optimize the given prompt if the optimizer context is set and the
+ * master toggle is enabled. Falls back to a passthrough result on any
+ * error so node execution is never blocked by optimization failures.
+ */
+export async function optimizePromptIfEnabled(prompt, phaseName, modelId, previousSpecFileHashes) {
+    if (!contextOptimizer || !contextRunId || !contextFeatureId) {
+        return { prompt, metrics: null, specFileHashes: previousSpecFileHashes ?? {} };
+    }
+    const config = resolveConfig();
+    if (!config?.enabled) {
+        return { prompt, metrics: null, specFileHashes: previousSpecFileHashes ?? {} };
+    }
+    try {
+        const result = await contextOptimizer.optimize(prompt, {
+            phaseName,
+            modelId,
+            featureId: contextFeatureId,
+            agentRunId: contextRunId,
+            previousSpecFileHashes,
+            config,
+        });
+        return {
+            prompt: result.prompt,
+            metrics: result.metrics,
+            specFileHashes: result.specFileHashes,
+        };
+    }
+    catch {
+        // Swallow — optimization failure must never block phase execution
+        return { prompt, metrics: null, specFileHashes: previousSpecFileHashes ?? {} };
+    }
+}
+/**
+ * Persist optimization metrics on the given phase timing row.
+ * No-op if context is not set, timingId is null, or metrics are null.
+ */
+export async function recordOptimizationMetricsIfEnabled(timingId, metrics) {
+    if (!contextMetricsService || !timingId || !metrics)
+        return;
+    try {
+        await contextMetricsService.record(timingId, metrics);
+    }
+    catch {
+        // Swallow — metrics persistence failure is non-fatal
+    }
+}

package/dist/packages/core/src/infrastructure/services/agents/feature-agent/state.d.ts

@@ -59,6 +59,7 @@ export declare const FeatureAgentAnnotation: import("@langchain/langgraph").Anno
     ciFixAttempts: import("@langchain/langgraph").BinaryOperatorAggregate<number, number>;
     ciFixHistory: import("@langchain/langgraph").BinaryOperatorAggregate<CiFixRecord[], CiFixRecord[]>;
     ciFixStatus: import("@langchain/langgraph").BinaryOperatorAggregate<"success" | "timeout" | "idle" | "watching" | "fixing" | "exhausted", "success" | "timeout" | "idle" | "watching" | "fixing" | "exhausted">;
+    specFileHashes: import("@langchain/langgraph").BinaryOperatorAggregate<Record<string, string>, Record<string, string>>;
 }>;
 export type FeatureAgentState = typeof FeatureAgentAnnotation.State;
 //# sourceMappingURL=state.d.ts.map

package/dist/packages/core/src/infrastructure/services/agents/feature-agent/state.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"state.d.ts","sourceRoot":"","sources":["../../../../../../../../packages/core/src/infrastructure/services/agents/feature-agent/state.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,aAAa,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,8BAA8B,CAAC;AAEzF;;;;;;GAMG;AACH,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAwHjC,CAAC;AAEH,MAAM,MAAM,iBAAiB,GAAG,OAAO,sBAAsB,CAAC,KAAK,CAAC"}
+{"version":3,"file":"state.d.ts","sourceRoot":"","sources":["../../../../../../../../packages/core/src/infrastructure/services/agents/feature-agent/state.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,aAAa,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,8BAA8B,CAAC;AAEzF;;;;;;GAMG;AACH,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA6HjC,CAAC;AAEH,MAAM,MAAM,iBAAiB,GAAG,OAAO,sBAAsB,CAAC,KAAK,CAAC"}

package/dist/packages/core/src/infrastructure/services/agents/feature-agent/state.js

@@ -126,4 +126,9 @@ export const FeatureAgentAnnotation = Annotation.Root({
         reducer: (_prev, next) => next,
         default: () => 'idle',
     }),
+    // --- Token optimization state ---
+    specFileHashes: Annotation({
+        reducer: (_prev, next) => next,
+        default: () => ({}),
+    }),
 });

package/dist/packages/core/src/infrastructure/services/agents/feature-agent/subprocess-filter-context.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Subprocess Filter Context
+ *
+ * Lazily creates and caches a shim directory for the lifetime of the
+ * worker process. The shim dir contains wrapper scripts (git, npm,
+ * pnpm, yarn) that pipe command output through shep-filter before
+ * returning it to Claude Code.
+ *
+ * The shim dir is created once on the first call to
+ * resolveSubprocessFilterShimDir(true) and reused for all subsequent
+ * calls. It's automatically cleaned up when the worker process exits
+ * (via process.on('exit')).
+ */
+/**
+ * Resolve the shim directory path, creating it lazily if needed.
+ *
+ * @param enabled - Whether subprocess filtering is enabled in settings
+ * @returns The absolute path to the shim directory, or undefined if disabled
+ */
+export declare function resolveSubprocessFilterShimDir(enabled: boolean): string | undefined;
+/**
+ * Clear the cached shim directory. Useful for testing.
+ */
+export declare function clearSubprocessFilterContext(): void;
+//# sourceMappingURL=subprocess-filter-context.d.ts.map

package/dist/packages/core/src/infrastructure/services/agents/feature-agent/subprocess-filter-context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"subprocess-filter-context.d.ts","sourceRoot":"","sources":["../../../../../../../../packages/core/src/infrastructure/services/agents/feature-agent/subprocess-filter-context.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAmBH;;;;;GAKG;AACH,wBAAgB,8BAA8B,CAAC,OAAO,EAAE,OAAO,GAAG,MAAM,GAAG,SAAS,CAmBnF;AAED;;GAEG;AACH,wBAAgB,4BAA4B,IAAI,IAAI,CASnD"}

package/dist/packages/core/src/infrastructure/services/agents/feature-agent/subprocess-filter-context.js

@@ -0,0 +1,67 @@
+/**
+ * Subprocess Filter Context
+ *
+ * Lazily creates and caches a shim directory for the lifetime of the
+ * worker process. The shim dir contains wrapper scripts (git, npm,
+ * pnpm, yarn) that pipe command output through shep-filter before
+ * returning it to Claude Code.
+ *
+ * The shim dir is created once on the first call to
+ * resolveSubprocessFilterShimDir(true) and reused for all subsequent
+ * calls. It's automatically cleaned up when the worker process exits
+ * (via process.on('exit')).
+ */
+import { join, dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { rmSync } from 'node:fs';
+import { createShimDirectory } from '../../subprocess-filter/shim-generator.js';
+let cachedShimDir;
+/**
+ * Resolve the path to the compiled shep-filter.js entry point.
+ * This is relative to the current file's location in the dist tree.
+ */
+function resolveShepFilterPath() {
+    const thisDir = dirname(fileURLToPath(import.meta.url));
+    // From dist/.../agents/feature-agent/ → dist/.../subprocess-filter/shep-filter.js
+    return join(thisDir, '..', '..', 'subprocess-filter', 'shep-filter.js');
+}
+/**
+ * Resolve the shim directory path, creating it lazily if needed.
+ *
+ * @param enabled - Whether subprocess filtering is enabled in settings
+ * @returns The absolute path to the shim directory, or undefined if disabled
+ */
+export function resolveSubprocessFilterShimDir(enabled) {
+    if (!enabled)
+        return undefined;
+    if (!cachedShimDir) {
+        const shepFilterPath = resolveShepFilterPath();
+        const shim = createShimDirectory(shepFilterPath);
+        cachedShimDir = shim.path;
+        // Register cleanup on process exit
+        process.on('exit', () => {
+            try {
+                if (cachedShimDir)
+                    rmSync(cachedShimDir, { recursive: true, force: true });
+            }
+            catch {
+                // best-effort cleanup
+            }
+        });
+    }
+    return cachedShimDir;
+}
+/**
+ * Clear the cached shim directory. Useful for testing.
+ */
+export function clearSubprocessFilterContext() {
+    if (cachedShimDir) {
+        try {
+            rmSync(cachedShimDir, { recursive: true, force: true });
+        }
+        catch {
+            // best-effort
+        }
+    }
+    cachedShimDir = undefined;
+}

package/dist/packages/core/src/infrastructure/services/subprocess-filter/filters/generic-filter.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Generic output filter — fallback for commands without a dedicated
+ * filter. Applies ANSI stripping, blank-line collapsing, line
+ * deduplication, and middle-truncation.
+ *
+ * This is intentionally conservative: it never drops content that
+ * might be meaningful, it only compresses repeated/blank/color noise.
+ */
+/**
+ * Apply generic output cleanup. Safe for any command.
+ */
+export declare function filterGeneric(output: string): string;
+//# sourceMappingURL=generic-filter.d.ts.map

package/dist/packages/core/src/infrastructure/services/subprocess-filter/filters/generic-filter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"generic-filter.d.ts","sourceRoot":"","sources":["../../../../../../../../packages/core/src/infrastructure/services/subprocess-filter/filters/generic-filter.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAWH;;GAEG;AACH,wBAAgB,aAAa,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAOpD"}

package/dist/packages/core/src/infrastructure/services/subprocess-filter/filters/generic-filter.js

@@ -0,0 +1,21 @@
+/**
+ * Generic output filter — fallback for commands without a dedicated
+ * filter. Applies ANSI stripping, blank-line collapsing, line
+ * deduplication, and middle-truncation.
+ *
+ * This is intentionally conservative: it never drops content that
+ * might be meaningful, it only compresses repeated/blank/color noise.
+ */
+import { stripAnsi, collapseBlankLines, deduplicateLines, truncateMiddle, } from './shared-helpers.js';
+const MAX_LINES = 150;
+/**
+ * Apply generic output cleanup. Safe for any command.
+ */
+export function filterGeneric(output) {
+    const clean = stripAnsi(output).trim();
+    if (clean.length === 0)
+        return '';
+    const deduped = deduplicateLines(clean);
+    const collapsed = collapseBlankLines(deduped);
+    return truncateMiddle(collapsed, MAX_LINES);
+}

package/dist/packages/core/src/infrastructure/services/subprocess-filter/filters/git-filter.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Git output filter — filters the output of git subcommands to reduce
+ * token consumption when Claude Code ingests tool results.
+ *
+ * Covers: status, log, diff, show, add, commit, push, pull, fetch,
+ * branch, stash, worktree. Unrecognized subcommands fall through to
+ * the generic filter.
+ */
+/**
+ * Filter git command output. Dispatches to a subcommand-specific
+ * handler when one exists, otherwise returns the input with basic
+ * cleanup (ANSI strip + blank collapse).
+ */
+export declare function filterGit(subcommand: string, output: string): string;
+//# sourceMappingURL=git-filter.d.ts.map

package/dist/packages/core/src/infrastructure/services/subprocess-filter/filters/git-filter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"git-filter.d.ts","sourceRoot":"","sources":["../../../../../../../../packages/core/src/infrastructure/services/subprocess-filter/filters/git-filter.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAOH;;;;GAIG;AACH,wBAAgB,SAAS,CAAC,UAAU,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM,CAgCpE"}

package/dist/packages/core/src/infrastructure/services/subprocess-filter/filters/git-filter.js

@@ -0,0 +1,189 @@
+/**
+ * Git output filter — filters the output of git subcommands to reduce
+ * token consumption when Claude Code ingests tool results.
+ *
+ * Covers: status, log, diff, show, add, commit, push, pull, fetch,
+ * branch, stash, worktree. Unrecognized subcommands fall through to
+ * the generic filter.
+ */
+import { stripAnsi, collapseBlankLines, truncateMiddle } from './shared-helpers.js';
+const MAX_DIFF_LINES = 200;
+const MAX_LOG_LINES = 100;
+/**
+ * Filter git command output. Dispatches to a subcommand-specific
+ * handler when one exists, otherwise returns the input with basic
+ * cleanup (ANSI strip + blank collapse).
+ */
+export function filterGit(subcommand, output) {
+    const clean = stripAnsi(output).trimEnd();
+    if (clean.trim().length === 0)
+        return 'ok';
+    switch (subcommand) {
+        case 'status':
+            return filterStatus(clean);
+        case 'log':
+            return filterLog(clean);
+        case 'diff':
+            return filterDiff(clean);
+        case 'show':
+            return filterShow(clean);
+        case 'add':
+            return filterSimpleOk(clean, 'added');
+        case 'commit':
+            return filterCommit(clean);
+        case 'push':
+            return filterPush(clean);
+        case 'pull':
+            return filterPull(clean);
+        case 'fetch':
+            return filterSimpleOk(clean, 'fetched');
+        case 'branch':
+            return filterBranch(clean);
+        case 'stash':
+            return filterSimpleOk(clean, 'stash');
+        case 'worktree':
+            return collapseBlankLines(clean);
+        default:
+            return collapseBlankLines(truncateMiddle(clean, MAX_LOG_LINES));
+    }
+}
+/**
+ * Parse git status output into a compact format.
+ * Handles both porcelain and human-readable output.
+ */
+function filterStatus(output) {
+    const lines = output.split('\n').filter((l) => l.trim().length > 0);
+    // Detect porcelain format (lines start with XY + space)
+    const porcelainPattern = /^[ MADRCU?!]{2} /;
+    const isPorcelain = lines.length > 0 && lines.every((l) => porcelainPattern.test(l));
+    if (isPorcelain) {
+        return lines
+            .map((line) => {
+            const status = line.slice(0, 2).trim();
+            const file = line.slice(3);
+            return `[${status || '?'}] ${file}`;
+        })
+            .join('\n');
+    }
+    // Human-readable format: keep but compress. Remove "On branch" and
+    // "Your branch is up to date" boilerplate; keep the file lists.
+    const result = lines.filter((l) => !l.startsWith('On branch') &&
+        !l.startsWith('Your branch is up to date') &&
+        !l.startsWith('  (use "git'));
+    return result.length > 0 ? collapseBlankLines(result.join('\n')) : 'clean';
+}
+/**
+ * Compress git log to one-line-per-commit format, capped at MAX_LOG_LINES.
+ */
+function filterLog(output) {
+    // If already one-line format (--oneline), just truncate
+    const lines = output.split('\n');
+    const isOneline = lines.every((l) => !l.startsWith('commit ') && !l.startsWith('Author:'));
+    if (isOneline) {
+        return truncateMiddle(output, MAX_LOG_LINES);
+    }
+    // Full log format: extract hash + subject from each commit block
+    const commits = [];
+    let currentHash = '';
+    for (const line of lines) {
+        const commitMatch = line.match(/^commit ([a-f0-9]{7,40})/);
+        if (commitMatch) {
+            currentHash = commitMatch[1].slice(0, 7);
+            continue;
+        }
+        if (line.startsWith('    ') && currentHash) {
+            commits.push(`${currentHash} ${line.trim()}`);
+            currentHash = '';
+        }
+    }
+    return commits.length > 0
+        ? truncateMiddle(commits.join('\n'), MAX_LOG_LINES)
+        : truncateMiddle(output, MAX_LOG_LINES);
+}
+/**
+ * Compact git diff by removing context lines (unchanged lines starting
+ * with space in unified format) and capping total length.
+ */
+function filterDiff(output) {
+    const lines = output.split('\n');
+    const result = [];
+    let inHunk = false;
+    for (const line of lines) {
+        // Keep diff/file headers
+        if (line.startsWith('diff --git') ||
+            line.startsWith('---') ||
+            line.startsWith('+++') ||
+            line.startsWith('@@')) {
+            result.push(line);
+            inHunk = line.startsWith('@@');
+            continue;
+        }
+        // Inside a hunk: keep only changed lines (+ and -)
+        if (inHunk) {
+            if (line.startsWith('+') || line.startsWith('-')) {
+                result.push(line);
+            }
+            // Skip context lines (start with space)
+            continue;
+        }
+        // Outside hunks: keep (e.g., binary file notices, mode changes)
+        result.push(line);
+    }
+    return truncateMiddle(result.join('\n'), MAX_DIFF_LINES);
+}
+/**
+ * Filter git show — use --stat format when possible, otherwise
+ * treat as diff.
+ */
+function filterShow(output) {
+    // If output looks like a stat summary (has " | " column), keep as-is
+    if (output.includes(' | ')) {
+        return truncateMiddle(output, MAX_LOG_LINES);
+    }
+    // Otherwise treat as a diff
+    return filterDiff(output);
+}
+/** Extract the commit hash from git commit output. */
+function filterCommit(output) {
+    const match = output.match(/\[[\w/.-]+ ([a-f0-9]{7,})\]/);
+    return match ? `ok ${match[1]}` : 'ok';
+}
+/** Extract branch/remote info from git push output. */
+function filterPush(output) {
+    const branchMatch = output.match(/(\S+)\s*->\s*(\S+)/);
+    if (branchMatch)
+        return `ok ${branchMatch[1]} → ${branchMatch[2]}`;
+    // "Everything up-to-date" case
+    if (output.toLowerCase().includes('up-to-date') || output.toLowerCase().includes('up to date')) {
+        return 'ok (up-to-date)';
+    }
+    return 'ok';
+}
+/** Extract stats from git pull output. */
+function filterPull(output) {
+    if (output.includes('Already up to date'))
+        return 'ok (up-to-date)';
+    const statsMatch = output.match(/(\d+) files? changed(?:, (\d+) insertions?\(\+\))?(?:, (\d+) deletions?\(-\))?/);
+    if (statsMatch) {
+        const files = statsMatch[1];
+        const ins = statsMatch[2] ?? '0';
+        const del = statsMatch[3] ?? '0';
+        return `ok ${files} files +${ins} -${del}`;
+    }
+    return 'ok';
+}
+/** Filter git branch — just the branch names, no decoration noise. */
+function filterBranch(output) {
+    return output
+        .split('\n')
+        .map((l) => l.replace(/^\*?\s+/, '').trim())
+        .filter((l) => l.length > 0)
+        .join('\n');
+}
+/** Simple "ok" filter for commands whose output we mostly don't need. */
+function filterSimpleOk(output, label) {
+    if (output.toLowerCase().includes('error') || output.toLowerCase().includes('fatal')) {
+        return output;
+    }
+    return `ok (${label})`;
+}

package/dist/packages/core/src/infrastructure/services/subprocess-filter/filters/npm-filter.d.ts

@@ -0,0 +1,13 @@
+/**
+ * npm/pnpm/yarn output filter — strips boilerplate from package
+ * manager commands, keeping errors and actionable output.
+ *
+ * Covers: install, test, run (build/lint/etc.), list/ls.
+ * Unrecognized subcommands fall through to basic cleanup.
+ */
+/**
+ * Filter npm/pnpm/yarn output. The `manager` param is the binary name
+ * ("npm", "pnpm", or "yarn") — filtering logic is the same for all.
+ */
+export declare function filterNpm(subcommand: string, output: string): string;
+//# sourceMappingURL=npm-filter.d.ts.map

package/dist/packages/core/src/infrastructure/services/subprocess-filter/filters/npm-filter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"npm-filter.d.ts","sourceRoot":"","sources":["../../../../../../../../packages/core/src/infrastructure/services/subprocess-filter/filters/npm-filter.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAWH;;;GAGG;AACH,wBAAgB,SAAS,CAAC,UAAU,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM,CA2BpE"}

package/dist/packages/core/src/infrastructure/services/subprocess-filter/filters/npm-filter.js

@@ -0,0 +1,96 @@
+/**
+ * npm/pnpm/yarn output filter — strips boilerplate from package
+ * manager commands, keeping errors and actionable output.
+ *
+ * Covers: install, test, run (build/lint/etc.), list/ls.
+ * Unrecognized subcommands fall through to basic cleanup.
+ */
+import { stripAnsi, collapseBlankLines, deduplicateLines, truncateMiddle, } from './shared-helpers.js';
+const MAX_LINES = 80;
+/**
+ * Filter npm/pnpm/yarn output. The `manager` param is the binary name
+ * ("npm", "pnpm", or "yarn") — filtering logic is the same for all.
+ */
+export function filterNpm(subcommand, output) {
+    const clean = stripAnsi(output).trim();
+    if (clean.length === 0)
+        return 'ok';
+    // Preserve error output unfiltered
+    if (hasErrors(clean)) {
+        return collapseBlankLines(truncateMiddle(clean, MAX_LINES));
+    }
+    switch (subcommand) {
+        case 'install':
+        case 'i':
+        case 'ci':
+        case 'add':
+            return filterInstall(clean);
+        case 'test':
+        case 'run':
+        case 'exec':
+            return filterRun(clean);
+        case 'list':
+        case 'ls':
+            return filterList(clean);
+        case 'outdated':
+            return filterOutdated(clean);
+        default:
+            return collapseBlankLines(truncateMiddle(clean, MAX_LINES));
+    }
+}
+/** Check for error indicators that mean we should preserve full output. */
+function hasErrors(output) {
+    const lower = output.toLowerCase();
+    return (lower.includes('err!') ||
+        lower.includes('error') ||
+        lower.includes('enoent') ||
+        lower.includes('eacces') ||
+        lower.includes('npm warn') ||
+        lower.includes('failed'));
+}
+/**
+ * Filter install output — strip download/resolution progress, keep
+ * the final summary.
+ */
+function filterInstall(output) {
+    const lines = output.split('\n');
+    const result = lines.filter((l) => !l.startsWith('npm warn deprecated') &&
+        !l.match(/^\s*$/) &&
+        !l.includes('packages in') &&
+        !l.includes('added ') &&
+        !l.includes('removed ') &&
+        !l.includes('up to date') &&
+        !l.includes('reused ') &&
+        !l.includes('Resolving') &&
+        !l.includes('Downloading') &&
+        !l.includes('looking for funding'));
+    if (result.length === 0)
+        return 'ok (installed)';
+    return truncateMiddle(result.join('\n'), MAX_LINES);
+}
+/**
+ * Filter test/run output — strip lifecycle boilerplate, keep test
+ * results and errors.
+ */
+function filterRun(output) {
+    const lines = output.split('\n');
+    const result = lines.filter((l) => !l.match(/^> [\w@/.-]+ /) && // Strip "> project@1.0.0 test" prefix
+        !l.match(/^\s*$/));
+    const filtered = deduplicateLines(result.join('\n'));
+    return collapseBlankLines(truncateMiddle(filtered, MAX_LINES));
+}
+/**
+ * Filter list output — truncate to top-level deps only.
+ */
+function filterList(output) {
+    const lines = output.split('\n');
+    // Keep only depth-0 lines (no leading whitespace beyond the tree markers)
+    const topLevel = lines.filter((l) => !l.startsWith('  ') || l.startsWith('├─') || l.startsWith('└─'));
+    return truncateMiddle(topLevel.join('\n'), MAX_LINES);
+}
+/**
+ * Filter outdated — keep the table but truncate.
+ */
+function filterOutdated(output) {
+    return truncateMiddle(output, MAX_LINES);
+}

package/dist/packages/core/src/infrastructure/services/subprocess-filter/filters/shared-helpers.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Shared helpers used across all subprocess output filters.
+ *
+ * These are small, pure functions for text transformation —
+ * deduplication, blank-line collapsing, ANSI stripping, and
+ * middle-truncation. Each filter composes from these primitives.
+ */
+export declare function stripAnsi(text: string): string;
+/**
+ * Collapse runs of 3+ consecutive blank lines into a single blank line.
+ * Trims trailing whitespace from each line as a side effect.
+ */
+export declare function collapseBlankLines(text: string): string;
+/**
+ * Deduplicate consecutive identical lines, appending a count.
+ *
+ * Example:
+ *   "ok\nok\nok\nfail" → "ok (×3)\nfail"
+ */
+export declare function deduplicateLines(text: string): string;
+/**
+ * Truncate text that exceeds maxLines by keeping the top half and
+ * bottom quarter, inserting an omission marker in the middle.
+ *
+ * Preserves the head (most likely context/setup) and tail (most
+ * likely summary/errors) which are the parts LLMs benefit from most.
+ */
+export declare function truncateMiddle(text: string, maxLines: number): string;
+//# sourceMappingURL=shared-helpers.d.ts.map

package/dist/packages/core/src/infrastructure/services/subprocess-filter/filters/shared-helpers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shared-helpers.d.ts","sourceRoot":"","sources":["../../../../../../../../packages/core/src/infrastructure/services/subprocess-filter/filters/shared-helpers.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AASH,wBAAgB,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAE9C;AAED;;;GAGG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAmBvD;AAED;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAoBrD;AAED;;;;;;GAMG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,CAarE"}