@planu/cli 4.7.1 → 4.7.3

package/dist/engine/minimality/analyzer.js

@@ -0,0 +1,140 @@
+import { formatMinimalImplementationReport } from './formatter.js';
+const RISK_ORDER = ['low', 'medium', 'high', 'max'];
+function riskRank(risk) {
+    const index = RISK_ORDER.indexOf(risk);
+    return index >= 0 ? index : 1;
+}
+function isExcludedPath(path, policy) {
+    return policy.excludedPathPatterns.some((pattern) => {
+        const escaped = pattern
+            .replace(/[.+^${}()|[\]\\]/g, '\\$&')
+            .replace(/\*\*/g, '.*')
+            .replace(/\*/g, '[^/]*');
+        return new RegExp(`^${escaped}$`).test(path);
+    });
+}
+function firstMatchingSafetyExclusion(text, policy) {
+    const lower = text.toLowerCase();
+    return policy.safetyExclusions.find((term) => lower.includes(term.toLowerCase())) ?? null;
+}
+function trimEvidence(value, maxChars) {
+    const compact = value.replace(/\s+/g, ' ').trim();
+    return compact.length > maxChars ? `${compact.slice(0, maxChars - 1)}...` : compact;
+}
+function lineForMatch(content, index) {
+    return content.slice(0, index).split('\n').length;
+}
+function ruleBlocksDone(rule, specRisk) {
+    if (rule.severity !== 'blocker') {
+        return false;
+    }
+    if (rule.blockWhenRiskAtLeast === undefined) {
+        return true;
+    }
+    return riskRank(specRisk) >= riskRank(rule.blockWhenRiskAtLeast);
+}
+function makeEvidence(input, rule) {
+    return [...(input.evidence ?? []), { source: 'policy', key: rule.id }];
+}
+function scanText(args) {
+    for (const pattern of args.rule.patterns) {
+        const index = args.content.toLowerCase().indexOf(pattern.toLowerCase());
+        if (index < 0) {
+            continue;
+        }
+        const evidence = trimEvidence(args.content.slice(index, index + 220), args.policy.report.maxEvidenceChars);
+        const safetyTerm = firstMatchingSafetyExclusion(args.content, args.policy);
+        if (safetyTerm !== null) {
+            return {
+                safety: {
+                    target: args.target,
+                    reason: `Matched safety exclusion: ${safetyTerm}`,
+                    evidence,
+                },
+            };
+        }
+        return {
+            finding: {
+                ruleId: args.rule.id,
+                tag: args.rule.tag,
+                severity: args.rule.severity,
+                confidence: args.rule.confidence,
+                target: args.target,
+                line: args.target.includes(':') ? undefined : lineForMatch(args.content, index),
+                evidence,
+                replacementGuidance: args.rule.replacementGuidance,
+                blocksDone: ruleBlocksDone(args.rule, args.input.specRisk),
+                evidenceSource: makeEvidence(args.input, args.rule),
+            },
+        };
+    }
+    return {};
+}
+function collectSources(input) {
+    const virtual = [];
+    if (input.specText) {
+        virtual.push({ path: 'spec.md', content: input.specText });
+    }
+    if (input.handoffText) {
+        virtual.push({ path: 'handoff', content: input.handoffText });
+    }
+    if (input.packageManifestText) {
+        virtual.push({ path: 'package.json', content: input.packageManifestText });
+    }
+    return [...virtual, ...(input.files ?? [])];
+}
+export function analyzeMinimalImplementation(input) {
+    const { policy } = input;
+    if (!policy.enabled) {
+        return {
+            enabled: false,
+            blocked: false,
+            findings: [],
+            safetyExceptions: [],
+            debtEvidence: input.acceptedDebt ?? [],
+            evidence: input.evidence ?? [],
+            markdown: '',
+        };
+    }
+    const findings = [];
+    const safetyExceptions = [];
+    for (const source of collectSources(input)) {
+        if (isExcludedPath(source.path, policy) || source.content === undefined) {
+            continue;
+        }
+        for (const rule of policy.rules) {
+            const result = scanText({
+                target: source.path,
+                content: source.content,
+                policy,
+                input,
+                rule,
+            });
+            if (result.safety) {
+                safetyExceptions.push(result.safety);
+            }
+            if (result.finding) {
+                findings.push(result.finding);
+            }
+            if (findings.length >= policy.report.maxFindings) {
+                break;
+            }
+        }
+        if (findings.length >= policy.report.maxFindings) {
+            break;
+        }
+    }
+    const report = {
+        enabled: true,
+        blocked: findings.some((finding) => finding.blocksDone),
+        findings,
+        safetyExceptions,
+        debtEvidence: input.acceptedDebt ?? [],
+        evidence: input.evidence ?? [],
+    };
+    return {
+        ...report,
+        markdown: formatMinimalImplementationReport({ ...report, markdown: '' }, policy),
+    };
+}
+//# sourceMappingURL=analyzer.js.map

package/dist/engine/minimality/formatter.d.ts

@@ -0,0 +1,3 @@
+import type { MinimalImplementationPolicy, MinimalImplementationReport } from '../../types/minimal-implementation-gate.js';
+export declare function formatMinimalImplementationReport(report: MinimalImplementationReport, policy?: MinimalImplementationPolicy): string;
+//# sourceMappingURL=formatter.d.ts.map

package/dist/engine/minimality/formatter.js

@@ -0,0 +1,25 @@
+export function formatMinimalImplementationReport(report, policy) {
+    if (!report.enabled) {
+        return '';
+    }
+    const maxLines = policy?.report.maxMarkdownLines ?? 12;
+    const lines = ['## Minimal Implementation', ''];
+    if (report.findings.length === 0) {
+        lines.push('- No avoidable complexity findings from the current policy.');
+    }
+    else {
+        for (const finding of report.findings.slice(0, Math.max(1, maxLines - 4))) {
+            const location = finding.line !== undefined ? `${finding.target}:${String(finding.line)}` : finding.target;
+            const marker = finding.blocksDone ? 'BLOCK' : finding.severity.toUpperCase();
+            lines.push(`- [${marker}] ${finding.tag} ${location}: ${finding.replacementGuidance}`);
+        }
+    }
+    if (report.safetyExceptions.length > 0) {
+        lines.push(`- Safety exceptions preserved: ${String(report.safetyExceptions.length)} required safeguard(s).`);
+    }
+    if (report.debtEvidence.length > 0) {
+        lines.push(`- Structured debt evidence recorded: ${String(report.debtEvidence.length)} item(s).`);
+    }
+    return lines.slice(0, maxLines).join('\n');
+}
+//# sourceMappingURL=formatter.js.map

package/dist/engine/minimality/index.d.ts

@@ -0,0 +1,4 @@
+export { loadMinimalImplementationPolicy } from './policy-loader.js';
+export { analyzeMinimalImplementation } from './analyzer.js';
+export { formatMinimalImplementationReport } from './formatter.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/engine/minimality/index.js

@@ -0,0 +1,4 @@
+export { loadMinimalImplementationPolicy } from './policy-loader.js';
+export { analyzeMinimalImplementation } from './analyzer.js';
+export { formatMinimalImplementationReport } from './formatter.js';
+//# sourceMappingURL=index.js.map

package/dist/engine/minimality/policy-loader.d.ts

@@ -0,0 +1,3 @@
+import type { LoadedMinimalImplementationPolicy, MinimalImplementationPolicyLoadOptions } from '../../types/minimal-implementation-gate.js';
+export declare function loadMinimalImplementationPolicy(projectPath?: string, options?: MinimalImplementationPolicyLoadOptions): Promise<LoadedMinimalImplementationPolicy>;
+//# sourceMappingURL=policy-loader.d.ts.map

package/dist/engine/minimality/policy-loader.js

@@ -0,0 +1,133 @@
+import { readFile } from 'node:fs/promises';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+function configPath() {
+    return join(dirname(fileURLToPath(import.meta.url)), '../../config/minimal-implementation-gate.json');
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function mergeDeep(base, override) {
+    const result = { ...base };
+    for (const [key, value] of Object.entries(override)) {
+        const current = result[key];
+        result[key] = isRecord(current) && isRecord(value) ? mergeDeep(current, value) : value;
+    }
+    return result;
+}
+function assertString(value, path) {
+    if (value === undefined) {
+        throw new Error(`Invalid minimal implementation policy at ${path}: string is required`);
+    }
+    if (value === null) {
+        throw new Error(`Invalid minimal implementation policy at ${path}: null is not allowed`);
+    }
+    if (typeof value !== 'string') {
+        throw new Error(`Invalid minimal implementation policy at ${path}: expected string`);
+    }
+    if (value.length === 0) {
+        throw new Error(`Invalid minimal implementation policy at ${path}: empty string is not allowed`);
+    }
+    if (value.trim().length === 0) {
+        throw new Error(`Invalid minimal implementation policy at ${path}: whitespace-only string is not allowed`);
+    }
+    if (value.length > 500) {
+        throw new Error(`Invalid minimal implementation policy at ${path}: string is too long`);
+    }
+}
+function assertStringArray(value, path) {
+    if (!Array.isArray(value)) {
+        throw new Error(`Invalid minimal implementation policy at ${path}: expected string[]`);
+    }
+    value.forEach((item, index) => {
+        assertString(item, `${path}.${String(index)}`);
+    });
+}
+function validateRule(value, path) {
+    if (!isRecord(value)) {
+        throw new Error(`Invalid minimal implementation policy at ${path}: expected object`);
+    }
+    assertString(value.id, `${path}.id`);
+    assertString(value.tag, `${path}.tag`);
+    if (!['info', 'warning', 'blocker'].includes(String(value.severity))) {
+        throw new Error(`Invalid minimal implementation policy at ${path}.severity`);
+    }
+    if (!['low', 'medium', 'high'].includes(String(value.confidence))) {
+        throw new Error(`Invalid minimal implementation policy at ${path}.confidence`);
+    }
+    assertStringArray(value.patterns, `${path}.patterns`);
+    assertString(value.replacementGuidance, `${path}.replacementGuidance`);
+    if (value.blockWhenRiskAtLeast !== undefined &&
+        (typeof value.blockWhenRiskAtLeast !== 'string' ||
+            !['low', 'medium', 'high', 'max'].includes(value.blockWhenRiskAtLeast))) {
+        throw new Error(`Invalid minimal implementation policy at ${path}.blockWhenRiskAtLeast`);
+    }
+    return value;
+}
+function validatePolicy(value) {
+    if (!isRecord(value)) {
+        throw new Error('Invalid minimal implementation policy: expected object');
+    }
+    if (value.version !== 1) {
+        throw new Error('Invalid minimal implementation policy: version must be 1');
+    }
+    const policy = value;
+    if (typeof policy.enabled !== 'boolean') {
+        throw new Error('Invalid minimal implementation policy at enabled: expected boolean');
+    }
+    if (!isRecord(policy.report)) {
+        throw new Error('Invalid minimal implementation policy at report: expected object');
+    }
+    for (const key of ['maxFindings', 'maxMarkdownLines', 'maxEvidenceChars']) {
+        if (!Number.isFinite(policy.report[key]) || policy.report[key] < 1) {
+            throw new Error(`Invalid minimal implementation policy at report.${key}`);
+        }
+    }
+    if (!isRecord(policy.tags)) {
+        throw new Error('Invalid minimal implementation policy at tags: expected object');
+    }
+    for (const [tag, definition] of Object.entries(policy.tags)) {
+        assertString(tag, `tags.${tag}`);
+        if (!isRecord(definition)) {
+            throw new Error(`Invalid minimal implementation policy at tags.${tag}: expected object`);
+        }
+        assertString(definition.description, `tags.${tag}.description`);
+    }
+    if (!Array.isArray(policy.rules) || policy.rules.length === 0) {
+        throw new Error('Invalid minimal implementation policy at rules: expected non-empty array');
+    }
+    policy.rules.forEach((rule, index) => validateRule(rule, `rules.${String(index)}`));
+    assertStringArray(policy.safetyExclusions, 'safetyExclusions');
+    assertStringArray(policy.excludedPathPatterns, 'excludedPathPatterns');
+    if (!isRecord(policy.debtEvidence)) {
+        throw new Error('Invalid minimal implementation policy at debtEvidence: expected object');
+    }
+    assertStringArray(policy.debtEvidence.requiredFields, 'debtEvidence.requiredFields');
+    return policy;
+}
+async function readJson(path) {
+    return JSON.parse(await readFile(path, 'utf-8'));
+}
+export async function loadMinimalImplementationPolicy(projectPath, options = {}) {
+    const defaultPolicyPath = options.defaultPolicyPath ?? configPath();
+    const defaultPolicy = validatePolicy(await readJson(defaultPolicyPath));
+    const evidence = [
+        { source: 'policy', key: defaultPolicyPath },
+    ];
+    let merged = defaultPolicy;
+    if (projectPath !== undefined) {
+        const planuConfigPath = join(projectPath, 'planu.json');
+        try {
+            const config = await readJson(planuConfigPath);
+            if (isRecord(config) && isRecord(config.minimalImplementationGate)) {
+                merged = validatePolicy(mergeDeep(defaultPolicy, config.minimalImplementationGate));
+                evidence.push({ source: 'project-config', key: 'planu.json.minimalImplementationGate' });
+            }
+        }
+        catch {
+            // Missing or malformed project config does not block default policy loading.
+        }
+    }
+    return { policy: merged, evidence };
+}
+//# sourceMappingURL=policy-loader.js.map

package/dist/engine/token-optimizer/content-aware-compactor.d.ts

@@ -0,0 +1,4 @@
+import type { ContentAwareCompactionInput, ContentAwareCompactionResult, ContextArtifactContentType } from '../../types/context-artifacts.js';
+export declare function classifyContentType(kind: string | undefined, text: string): ContextArtifactContentType;
+export declare function compactContentAware(input: ContentAwareCompactionInput): ContentAwareCompactionResult;
+//# sourceMappingURL=content-aware-compactor.d.ts.map

package/dist/engine/token-optimizer/content-aware-compactor.js

@@ -0,0 +1,230 @@
+import { countTokens } from './counter.js';
+import { storeContextArtifact } from '../context-artifacts/store.js';
+const DEFAULT_TTL_MS = 24 * 60 * 60 * 1000;
+const DEFAULT_MIN_TOKENS = 200;
+function redact(text, patterns) {
+    return patterns.reduce((current, pattern) => {
+        const re = new RegExp(pattern, 'gi');
+        return current.replace(re, '[redacted]');
+    }, text);
+}
+function escapeInert(text) {
+    return text.replace(/</g, '&lt;').replace(/>/g, '&gt;');
+}
+function bounded(value, maxChars) {
+    return value.length <= maxChars ? value : `${value.slice(0, maxChars)}...`;
+}
+function isLikelyJson(text) {
+    const trimmed = text.trim();
+    return ((trimmed.startsWith('{') && trimmed.endsWith('}')) ||
+        (trimmed.startsWith('[') && trimmed.endsWith(']')));
+}
+function isSearchResult(text) {
+    return text
+        .split('\n')
+        .some((line) => /^[^:\n]+:\d+(?::\d+)?:/.test(line) || /^[^:\n]+\(\d+,\d+\):/.test(line));
+}
+function isCode(text) {
+    const lines = text.split('\n');
+    const codeLines = lines.filter((line) => /^\s*(import|export|function|class|interface|type |const |let |var |def |fn |pub |func |struct |enum )/.test(line));
+    return lines.length > 0 && codeLines.length / lines.length > 0.12;
+}
+function isSpecOrHandoff(text) {
+    return (/\bSPEC-\d+\b/.test(text) ||
+        /\b(acceptance criteria|handoff|validation score|next action)\b/i.test(text));
+}
+export function classifyContentType(kind, text) {
+    const normalized = kind?.toLowerCase() ?? '';
+    if (normalized.includes('json') || isLikelyJson(text)) {
+        return 'json';
+    }
+    if (normalized.includes('test') ||
+        /\b(vitest|jest|failed tests?|test files?|assertionerror)\b/i.test(text)) {
+        return 'test-log';
+    }
+    if (normalized.includes('log') ||
+        /\b(error|warn|exception|stack trace|exit code)\b/i.test(text)) {
+        return 'runtime-log';
+    }
+    if (normalized.includes('search') || isSearchResult(text)) {
+        return 'search-results';
+    }
+    if (normalized.includes('code') || isCode(text)) {
+        return 'code';
+    }
+    if (normalized.includes('spec') || normalized.includes('handoff') || isSpecOrHandoff(text)) {
+        return 'spec-or-handoff';
+    }
+    return 'generic-text';
+}
+function summarizeJsonValue(value, depth = 0) {
+    if (value === null || typeof value === 'boolean' || typeof value === 'number') {
+        return value;
+    }
+    if (typeof value === 'string') {
+        return value.length <= 80 ? value : `${value.slice(0, 80)}...`;
+    }
+    if (Array.isArray(value)) {
+        return {
+            length: value.length,
+            sample: value.slice(0, 3).map((item) => summarizeJsonValue(item, depth + 1)),
+        };
+    }
+    if (typeof value === 'object') {
+        const out = {};
+        for (const [key, child] of Object.entries(value).slice(0, depth > 1 ? 12 : 40)) {
+            if (/^(status|state|count|total|id|uuid|name|ok|success|error|errors|warning|warnings)$/i.test(key)) {
+                out[key] = summarizeJsonValue(child, depth + 1);
+            }
+            else if (depth < 2) {
+                out[key] = summarizeJsonValue(child, depth + 1);
+            }
+        }
+        return out;
+    }
+    if (typeof value === 'undefined') {
+        return 'undefined';
+    }
+    if (typeof value === 'bigint') {
+        return value.toString();
+    }
+    if (typeof value === 'symbol') {
+        return value.description ?? 'symbol';
+    }
+    return '[unsupported]';
+}
+function compactJson(text) {
+    try {
+        const parsed = JSON.parse(text);
+        return JSON.stringify(summarizeJsonValue(parsed), null, 2);
+    }
+    catch {
+        return compactGenericText(text);
+    }
+}
+function compactLog(text, maxLines) {
+    const lines = text.split('\n');
+    const important = lines.filter((line) => /\b(error|fail|failed|failure|exception|stack|trace|warning|warn|duration|total|passed|exit code|exit status)\b/i.test(line));
+    const selected = important.length > 0 ? important : lines;
+    return [...new Set(selected)].slice(0, maxLines).join('\n');
+}
+function compactSearchResults(text, maxLines, maxSnippetChars) {
+    const grouped = new Map();
+    for (const line of text.split('\n')) {
+        const match = /^([^:\n]+):(\d+)(?::\d+)?:\s?(.*)$/.exec(line);
+        if (!match) {
+            continue;
+        }
+        const [, path, lineNumber, snippet] = match;
+        if (path === undefined || lineNumber === undefined) {
+            continue;
+        }
+        const entries = grouped.get(path) ?? [];
+        entries.push(`  ${lineNumber}: ${bounded(snippet ?? '', maxSnippetChars)}`);
+        grouped.set(path, [...new Set(entries)]);
+    }
+    if (grouped.size === 0) {
+        return compactGenericText(text);
+    }
+    const out = [];
+    for (const [path, entries] of grouped.entries()) {
+        out.push(path, ...entries.slice(0, maxLines));
+    }
+    return out.slice(0, maxLines).join('\n');
+}
+function bracesBalanced(text) {
+    let balance = 0;
+    for (const char of text) {
+        if (char === '{') {
+            balance += 1;
+        }
+        else if (char === '}') {
+            balance -= 1;
+        }
+        if (balance < 0) {
+            return false;
+        }
+    }
+    return balance === 0;
+}
+function compactCode(text) {
+    if (!bracesBalanced(text)) {
+        return compactGenericText(text);
+    }
+    const preserved = text
+        .split('\n')
+        .filter((line) => /^\s*(import|export|interface|type |class |function |async function|const [A-Z0-9_]+|enum |struct |def |fn |pub )/.test(line));
+    return preserved.length > 0 ? preserved.join('\n') : compactGenericText(text);
+}
+function compactSpecOrHandoff(text) {
+    const lines = text.split('\n');
+    const important = lines.filter((line) => /\b(SPEC-\d+|title:|status|acceptance criteria|blocker|blocked|files?|validation score|risk|security|privacy|next action|implementation|handoff)\b/i.test(line) ||
+        /^-\s*\[[ xX]\]\s+/.test(line) ||
+        /^#{1,3}\s/.test(line));
+    return (important.length > 0 ? important : lines).slice(0, 80).join('\n');
+}
+function compactGenericText(text) {
+    const lines = text.split('\n').filter((line) => line.trim().length > 0);
+    const important = lines.filter((line) => /^#{1,3}\s/.test(line) ||
+        /\b(error|failed|blocked|warning|todo|next action|pnpm|npm|git|https?:\/\/|\w+\/[\w./-]+\.\w+)\b/i.test(line));
+    return (important.length > 0 ? important : lines).slice(0, 60).join('\n');
+}
+function compactByType(type, text, maxLines, maxSnippetChars) {
+    switch (type) {
+        case 'json':
+            return compactJson(text);
+        case 'test-log':
+        case 'runtime-log':
+            return compactLog(text, maxLines);
+        case 'search-results':
+            return compactSearchResults(text, maxLines, maxSnippetChars);
+        case 'code':
+            return compactCode(text);
+        case 'spec-or-handoff':
+            return compactSpecOrHandoff(text);
+        case 'generic-text':
+            return compactGenericText(text);
+    }
+}
+export function compactContentAware(input) {
+    const contentType = classifyContentType(input.kind, input.text);
+    const strategyConfig = input.policy.contentCompaction?.strategies?.[contentType];
+    const maxLines = strategyConfig?.maxLines ?? 60;
+    const maxSnippetChars = strategyConfig?.maxSnippetChars ?? input.policy.redaction.maxSnippetChars;
+    const redacted = redact(input.text, input.policy.redaction.redactPatterns);
+    const compact = escapeInert(compactByType(contentType, redacted, maxLines, maxSnippetChars));
+    const originalTokens = countTokens(input.text).tokens;
+    const compactTokens = countTokens(compact).tokens;
+    const result = {
+        text: compact,
+        originalTokens,
+        compactTokens,
+        tokensSaved: Math.max(0, originalTokens - compactTokens),
+        strategy: contentType,
+        contentType,
+    };
+    const artifactsEnabled = input.policy.contextArtifacts?.enabled !== false;
+    const minTokens = input.policy.contextArtifacts?.minTokens ?? DEFAULT_MIN_TOKENS;
+    if (!artifactsEnabled || input.projectPath === undefined || originalTokens < minTokens) {
+        return result;
+    }
+    const stored = storeContextArtifact({
+        projectPath: input.projectPath,
+        originalContent: input.text,
+        compactContent: compact,
+        contentType,
+        strategy: contentType,
+        originalTokens,
+        compactTokens,
+        ttlMs: input.policy.contextArtifacts?.ttlMs ?? DEFAULT_TTL_MS,
+        sourcePath: input.sourcePath,
+        flow: input.flow,
+        metadata: input.metadata,
+    });
+    return {
+        ...result,
+        ...(stored.metadata !== undefined ? { artifact: stored.metadata } : {}),
+        ...(stored.refusedReason !== undefined ? { refusedReason: stored.refusedReason } : {}),
+    };
+}
+//# sourceMappingURL=content-aware-compactor.js.map

package/dist/engine/token-optimizer/index.d.ts

@@ -9,6 +9,7 @@ export { OptimizationReporter } from './reporter.js';
 export { TokenOptimizer } from './optimizer.js';
 export { aggregateEntries, computeDailyBreakdown, detectTrend, detectAnomalies, computeBudgetStatus, getTopConsumers, computeOptimizationSavings, } from './analytics.js';
 export { loadTokenWastePolicy } from './policy-loader.js';
+export { classifyContentType, compactContentAware } from './content-aware-compactor.js';
 export { analyzeContextPreflight } from './context-preflight.js';
 export { filterVerboseOutput } from './output-filter.js';
 export { recommendRelevantTools, toolsFromPolicyGroups } from './tool-relevance.js';

package/dist/engine/token-optimizer/index.js

@@ -10,6 +10,7 @@ export { OptimizationReporter } from './reporter.js';
 export { TokenOptimizer } from './optimizer.js';
 export { aggregateEntries, computeDailyBreakdown, detectTrend, detectAnomalies, computeBudgetStatus, getTopConsumers, computeOptimizationSavings, } from './analytics.js';
 export { loadTokenWastePolicy } from './policy-loader.js';
+export { classifyContentType, compactContentAware } from './content-aware-compactor.js';
 export { analyzeContextPreflight } from './context-preflight.js';
 export { filterVerboseOutput } from './output-filter.js';
 export { recommendRelevantTools, toolsFromPolicyGroups } from './tool-relevance.js';

package/dist/engine/token-optimizer/output-filter.js

@@ -1,3 +1,4 @@
+import { compactContentAware } from './content-aware-compactor.js';
 function escapeInert(text) {
     return text.replace(/</g, '&lt;').replace(/>/g, '&gt;');
 }
@@ -46,7 +47,21 @@ export function filterVerboseOutput(input) {
     const strategy = selectStrategy(input);
     const originalLines = input.text.split('\n').length;
     const lines = compactLines(input, strategy);
-    const compact = redact(escapeInert(lines.join('\n')), input.policy.redaction.redactPatterns);
+    let compact = redact(escapeInert(lines.join('\n')), input.policy.redaction.redactPatterns);
+    let compaction;
+    if (input.policy.contextArtifacts?.enabled === true && input.projectPath !== undefined) {
+        const contentAware = compactContentAware({
+            text: input.text,
+            policy: input.policy,
+            kind: input.kind,
+            projectPath: input.projectPath,
+            sourcePath: input.sourcePath,
+            flow: input.flow,
+            metadata: input.metadata,
+        });
+        compact = contentAware.text;
+        compaction = contentAware.artifact;
+    }
     const decisions = [
         {
             decision: originalLines > lines.length ? 'summarize' : 'include',
@@ -59,8 +74,9 @@ export function filterVerboseOutput(input) {
     return {
         text: compact,
         originalLines,
-        returnedLines: lines.length,
+        returnedLines: compact.split('\n').length,
         ...(input.fullOutputRef !== undefined ? { fullOutputRef: input.fullOutputRef } : {}),
+        ...(compaction !== undefined ? { compaction } : {}),
         decisions,
     };
 }

package/dist/engine/token-optimizer/policy-loader.js

@@ -39,6 +39,18 @@ function validatePolicy(value) {
     if (!isRecord(policy.outputs.strategies)) {
         throw new Error('Invalid token waste policy at outputs.strategies: expected object');
     }
+    if (policy.contextArtifacts !== undefined) {
+        if (!Number.isFinite(policy.contextArtifacts.ttlMs) || policy.contextArtifacts.ttlMs < 1) {
+            throw new Error('Invalid token waste policy at contextArtifacts.ttlMs: expected positive number');
+        }
+        if (!Number.isFinite(policy.contextArtifacts.minTokens) ||
+            policy.contextArtifacts.minTokens < 1) {
+            throw new Error('Invalid token waste policy at contextArtifacts.minTokens: expected positive number');
+        }
+    }
+    if (policy.contentCompaction !== undefined && !isRecord(policy.contentCompaction.strategies)) {
+        throw new Error('Invalid token waste policy at contentCompaction.strategies: expected object');
+    }
     if (!isRecord(policy.tools.groups)) {
         throw new Error('Invalid token waste policy at tools.groups: expected object');
     }

package/dist/engine/token-optimizer/reporter.d.ts

@@ -18,6 +18,10 @@ export declare class OptimizationReporter {
      * Record a cache hit for a tool.
      */
     recordCacheHit(toolName: string, tokensSaved: number): void;
+    /**
+     * Record measured savings from reversible compaction.
+     */
+    recordCompaction(toolName: string, tokensSaved: number, retrievals?: number): void;
     /**
      * Record a cache miss for a tool.
      */