@planu/cli 4.7.1 → 4.7.3

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

@@ -28,6 +28,16 @@ export class OptimizationReporter {
         record.tokensSaved += tokensSaved;
         this.totalSaved += tokensSaved;
     }
+    /**
+     * Record measured savings from reversible compaction.
+     */
+    recordCompaction(toolName, tokensSaved, retrievals = 0) {
+        const record = this.getOrCreateRecord(toolName);
+        record.compactionTokensSaved = (record.compactionTokensSaved ?? 0) + tokensSaved;
+        record.artifactRetrievals = (record.artifactRetrievals ?? 0) + retrievals;
+        record.tokensSaved += tokensSaved;
+        this.totalSaved += tokensSaved;
+    }
     /**
      * Record a cache miss for a tool.
      */
@@ -106,7 +116,8 @@ export class OptimizationReporter {
             for (const record of toolRecords) {
                 lines.push(`- ${record.toolName}: ${String(record.totalTokens)} tokens, ` +
                     `${String(record.callCount)} calls, ` +
-                    `${String(record.tokensSaved)} saved`);
+                    `${String(record.tokensSaved)} saved ` +
+                    `(compaction ${String(record.compactionTokensSaved ?? 0)}, retrievals ${String(record.artifactRetrievals ?? 0)})`);
             }
         }
         return lines.join('\n');
@@ -134,6 +145,8 @@ export class OptimizationReporter {
                 cacheHits: 0,
                 cacheMisses: 0,
                 tokensSaved: 0,
+                compactionTokensSaved: 0,
+                artifactRetrievals: 0,
             };
             this.toolRecords.set(toolName, record);
         }

package/dist/engine/validator/validation-report-writer.d.ts

@@ -1,5 +1,6 @@
 import type { Spec } from '../../types/index.js';
 import type { ValidationReportV1 } from '../../types/handoff-artifacts.js';
+import type { MinimalImplementationReport } from '../../types/minimal-implementation-gate.js';
 export declare function writeImplementationReviewReport(input: {
     projectId: string;
     specId: string;
@@ -8,6 +9,7 @@ export declare function writeImplementationReviewReport(input: {
     score: number | null;
     lintPassed?: boolean;
     conventionRegression?: boolean;
+    minimalityReport?: MinimalImplementationReport;
 }): Promise<{
     written: boolean;
     path?: string;

package/dist/engine/validator/validation-report-writer.js

@@ -7,6 +7,7 @@ export async function writeImplementationReviewReport(input) {
         lintPassed: input.lintPassed ?? true,
         conventionRegression: input.conventionRegression ?? false,
         specCompliance,
+        minimalityReport: input.minimalityReport,
     });
     const passed = gates.every((gate) => gate.passed);
     const reviewer = {
@@ -22,6 +23,7 @@ export async function writeImplementationReviewReport(input) {
         gates,
         reviewer,
         specCompliance: reportCompliance,
+        minimalityReport: input.minimalityReport,
         score: input.score ?? undefined,
         completedAt: new Date().toISOString(),
     };
@@ -73,8 +75,25 @@ function buildGates(args) {
             reason: args.conventionRegression ? 'Convention baseline regression detected.' : undefined,
         },
         buildSpecComplianceGate(args.specCompliance),
+        buildMinimalityGate(args.minimalityReport),
     ];
 }
+function buildMinimalityGate(report) {
+    if (report?.enabled !== true) {
+        return {
+            name: 'minimal-implementation',
+            passed: true,
+            reason: 'Minimal implementation report unavailable or disabled.',
+        };
+    }
+    return {
+        name: 'minimal-implementation',
+        passed: !report.blocked,
+        reason: report.blocked
+            ? `Blocking minimality findings: ${String(report.findings.filter((finding) => finding.blocksDone).length)}.`
+            : undefined,
+    };
+}
 function buildSpecComplianceGate(result) {
     if (result.perScenario.length === 0) {
         return {

package/dist/engine/web-fetcher/docs-fetcher.js

@@ -1,6 +1,7 @@
 // Planu — Web Fetcher: consultDocs orchestration
 import { searchAndRegisterFramework, saveRegistry } from '../registry-updater.js';
 import { loadDocsRegistry, findDocsEntry, setDocsRegistryCache, getStoredRegistryPath, } from './registry-loader.js';
+import { DEFAULT_CONFIG } from './cache.js';
 import { fetchUrl } from './http-client.js';
 import { extractTextContent, extractCodeBlocks, extractBestPractices, buildSummaryFromContent, buildPlaceholderSummary, buildPlaceholderExamples, buildPlaceholderBestPractices, } from './content-extractor.js';
 export async function consultDocsImpl(topic, framework) {
@@ -25,7 +26,10 @@ export async function consultDocsImpl(topic, framework) {
         : `https://www.google.com/search?q=${encodeURIComponent(`${resolvedFramework} ${topic} documentation`)}`;
     const baseUrl = docsEntry?.base ?? '';
     if (baseUrl) {
-        const fetchResult = await fetchUrl(docsUrl);
+        const fetchResult = await fetchUrl(docsUrl, {
+            ...DEFAULT_CONFIG,
+            timeoutMs: 2_500,
+        });
         if (fetchResult) {
             const textContent = extractTextContent(fetchResult.content);
             const codeBlocks = extractCodeBlocks(fetchResult.content);

package/dist/tools/challenge-spec.js

@@ -24,6 +24,7 @@ import { generateResilienceChallengeScenarios } from './challenge-spec/resilienc
 import { detectContradictions as detectDecisionContradictions, searchPriorDecisions, } from '../engine/prior-decisions/index.js';
 import { getDecisions } from '../storage/decision-store.js';
 import { calculateTokenBudget, injectBudgetIntoPrompt } from '../engine/token-budget/index.js';
+import { analyzeMinimalImplementation, loadMinimalImplementationPolicy, } from '../engine/minimality/index.js';
 const ALL_FOCUS_AREAS = [
     'failures',
     'concurrency',
@@ -127,6 +128,30 @@ export async function handleChallengeSpec(args, server) {
     const focusAreas = focus && focus.length > 0 ? focus : ALL_FOCUS_AREAS;
     // 5. Generate failure scenarios
     const failureScenarios = [];
+    try {
+        const { policy, evidence } = await loadMinimalImplementationPolicy(knowledge.projectPath);
+        const minimality = analyzeMinimalImplementation({
+            policy,
+            specId,
+            specRisk: spec.risk,
+            specText: specContent,
+            evidence,
+        });
+        for (const finding of minimality.findings.slice(0, 5)) {
+            failureScenarios.push({
+                scenario: `Minimal implementation concern: ${finding.tag}`,
+                probability: finding.confidence === 'high' ? 'high' : 'medium',
+                impact: finding.blocksDone ? 'high' : 'low',
+                currentHandling: `${finding.target}${finding.line ? `:${String(finding.line)}` : ''} — ${finding.evidence}`,
+                requiredHandling: finding.replacementGuidance,
+                dataConsistency: 'Scope control risk',
+                userExperience: 'Avoidable implementation complexity can increase token use and maintenance cost',
+            });
+        }
+    }
+    catch {
+        // Minimality challenge is best-effort and must not hide resilience findings.
+    }
     if (focusAreas.includes('failures')) {
         failureScenarios.push(...generateFailureScenarios(spec, specContent, knowledge));
     }

package/dist/tools/package-handoff.js

@@ -6,6 +6,7 @@ import { detectParadigms } from '../engine/paradigm-detector.js';
 import { analyzeContextPreflight, buildTokenWasteReport, formatTokenWasteReport, loadTokenWastePolicy, recommendRelevantTools, toolsFromPolicyGroups, } from '../engine/token-optimizer/index.js';
 import { appendTransitionEvent } from '../storage/transition-log.js';
 import { formatProjectGraphContext, queryProjectGraphSlice, } from '../engine/project-graph/index.js';
+import { analyzeMinimalImplementation, loadMinimalImplementationPolicy, } from '../engine/minimality/index.js';
 // ── Formatting helpers ───────────────────────────────────────────────────────
 function formatHandoff(pkg) {
     const lines = [];
@@ -196,6 +197,22 @@ async function buildGraphContextSection(args) {
         return null;
     }
 }
+async function buildMinimalImplementationReport(pkg, knowledge, spec, handoffText) {
+    try {
+        const { policy, evidence } = await loadMinimalImplementationPolicy(knowledge.projectPath);
+        return analyzeMinimalImplementation({
+            policy,
+            specId: spec.id,
+            specRisk: spec.risk,
+            handoffText,
+            files: [...pkg.filesToModify, ...pkg.filesToCreate].map((path) => ({ path, content: path })),
+            evidence,
+        });
+    }
+    catch {
+        return null;
+    }
+}
 // ── Handler ──────────────────────────────────────────────────────────────────
 export async function handlePackageHandoff(args) {
     const { projectId, specId } = args;
@@ -256,9 +273,13 @@ export async function handlePackageHandoff(args) {
         projectPath: knowledge.projectPath,
         specId,
     });
-    const handoffText = graphContext !== null
+    const baseHandoffText = graphContext !== null
         ? `${formatHandoff(pkgWithScore)}\n${graphContext.text}`
         : formatHandoff(pkgWithScore);
+    const minimalityReport = await buildMinimalImplementationReport(pkgWithScore, knowledge, spec, baseHandoffText);
+    const handoffText = minimalityReport !== null && minimalityReport.markdown.length > 0
+        ? `${baseHandoffText}\n${minimalityReport.markdown}`
+        : baseHandoffText;
     const formatted = tokenWasteReport !== null
         ? `${handoffText}\n${formatTokenWasteReport(tokenWasteReport)}`
         : handoffText;
@@ -282,6 +303,7 @@ export async function handlePackageHandoff(args) {
             blockers: pkgWithScore.blockers,
             handoffPath: pkgWithScore.handoffPath,
             contextHash: pkgWithScore.contextHash,
+            ...(minimalityReport !== null ? { minimality: minimalityReport } : {}),
             ...(tokenWasteReport !== null ? { tokenWaste: tokenWasteReport } : {}),
             ...(graphContext !== null ? { graphContext: graphContext.structured } : {}),
         },

package/dist/tools/safe-handler.js

@@ -268,7 +268,10 @@ function safeWithTelemetry(toolName, handler) {
             // SPEC-455: Compress verbose JSON outputs to save LLM tokens
             const compressed = compressToolOutput(result);
             // SPEC-922: Apply compact mode middleware
-            const compacted = applyCompactMode(compressed, decision);
+            const compacted = applyCompactMode(compressed, decision, {
+                projectPath,
+                flow: toolName,
+            });
             // Inject pending drift banner (non-blocking, informational only)
             const driftBanner = projectPath !== undefined ? await checkPendingDriftBanner(projectPath) : null;
             const withDrift = injectDriftBanner(compacted, driftBanner);

package/dist/tools/token-usage-handler.js

@@ -27,10 +27,12 @@ export function handleTokenUsage(args) {
     let details;
     if (groupBy === 'tool' && toolRecords.length > 0) {
         const lines = toolRecords.map((r) => `| ${r.toolName} | ${String(r.totalTokens)} | ${String(r.callCount)} | ` +
-            `${String(r.cacheHits)}/${String(r.cacheHits + r.cacheMisses)} | ${String(r.tokensSaved)} |`);
+            `${String(r.cacheHits)}/${String(r.cacheHits + r.cacheMisses)} | ` +
+            `${String(r.tokensSaved)} | ${String(r.compactionTokensSaved ?? 0)} | ` +
+            `${String(r.artifactRetrievals ?? 0)} |`);
         details = [
-            '| Tool | Tokens | Calls | Cache H/T | Saved |',
-            '|------|--------|-------|-----------|-------|',
+            '| Tool | Tokens | Calls | Cache H/T | Saved | Compaction Saved | Retrievals |',
+            '|------|--------|-------|-----------|-------|------------------|------------|',
             ...lines,
         ].join('\n');
     }

package/dist/tools/update-status/dod-gates.js

@@ -299,6 +299,15 @@ export async function checkValidationReportGate(specId, projectId, force) {
                 fixHint: 'Fix failing gates and re-run validate before marking done.',
             });
         }
+        if (result.payload.minimalityReport?.blocked) {
+            return validationReportGateError({
+                specId,
+                error: 'minimality_findings_block_done',
+                message: 'Validation report contains blocking minimal implementation findings. Remove avoidable complexity or provide an audited forceStatusReason.',
+                gates: result.payload.gates,
+                fixHint: 'Fix blocking minimality findings and re-run validate before marking done. Use forceStatus only with an audited reason for accepted complexity.',
+            });
+        }
         if (result.payload.reviewer.verdict !== 'approved' ||
             result.payload.reviewer.agent.trim().length === 0) {
             return validationReportGateError({

package/dist/tools/validate.js

@@ -18,6 +18,7 @@ import { compareWithBaseline } from '../storage/convention-baseline.js';
 import { writeImplementationReviewReport } from '../engine/validator/validation-report-writer.js';
 import { evaluateNewCodeGate } from '../engine/ai-assurance/index.js';
 import { queryProjectGraphSlice } from '../engine/project-graph/index.js';
+import { analyzeMinimalImplementation, loadMinimalImplementationPolicy, } from '../engine/minimality/index.js';
 // Re-export for external use (SPEC-018)
 export { validateContractCompliance };
 function graphCoverageGaps(slice) {
@@ -47,6 +48,25 @@ function formatGraphCoverageText(report) {
         ? `\nGRAPH     ${String(report.gaps.length)} graph-backed coverage gap(s)`
         : '';
 }
+async function buildMinimalityReport(args) {
+    try {
+        const { policy, evidence } = await loadMinimalImplementationPolicy(args.projectPath);
+        return analyzeMinimalImplementation({
+            policy,
+            specId: args.specId,
+            specRisk: args.risk,
+            specText: [args.title ?? '', ...args.missing, ...args.extra].join('\n'),
+            files: args.qualityIssues.map((issue) => ({
+                path: issue.file,
+                content: [issue.rule, issue.message, issue.suggestion ?? ''].join('\n'),
+            })),
+            evidence,
+        });
+    }
+    catch {
+        return null;
+    }
+}
 async function validateStrictLayoutOrError(args) {
     try {
         const { validateStrictPlanuLayout } = await import('../engine/spec-migrator/index.js');
@@ -176,6 +196,15 @@ export async function handleValidate(args, server) {
     // 7. Lint check (best-effort — non-blocking)
     const lintCheck = runLintCheck(projectPath, knowledge.lintCommand ?? null);
     const assuranceGates = runAssuranceGates(projectPath);
+    const minimalityReport = await buildMinimalityReport({
+        projectPath,
+        specId,
+        risk: spec.risk,
+        title: spec.title,
+        missing: result.missing,
+        extra: result.extra,
+        qualityIssues: result.qualityIssues,
+    });
     // SPEC-1050: Generate a mandatory implementation-review artifact.
     const validationReport = await writeImplementationReviewReport({
         projectId,
@@ -185,6 +214,7 @@ export async function handleValidate(args, server) {
         score: result.score,
         lintPassed: lintCheck.passed,
         conventionRegression: regressionDetected,
+        minimalityReport: minimalityReport ?? undefined,
     });
     // 8. Build output
     const output = {
@@ -262,6 +292,7 @@ export async function handleValidate(args, server) {
         lintCheck,
         assuranceGates,
         validationReport,
+        minimalityReport,
         graphCoverage,
     };
     // SPEC-612: Scope boundary validation — warn if impl files match outOfScope items
@@ -312,6 +343,9 @@ export async function handleValidate(args, server) {
     if (!assuranceGates.newCode.passed) {
         suggestions.push(`Assurance gate failed: ${String(assuranceGates.newCode.findings.length)} new-code domain inference issue(s) found.`);
     }
+    if (minimalityReport?.blocked) {
+        suggestions.push(`${minimalityReport.findings.filter((finding) => finding.blocksDone).length} blocking minimality finding(s) detected. Remove avoidable complexity or record accepted debt before marking done.`);
+    }
     const outputWithSuggestions = compactObj({
         ...output,
         suggestions: suggestions.length > 0 ? suggestions : undefined,

package/dist/types/compact/compact-mode.d.ts

@@ -20,6 +20,11 @@ export interface CompactDecision {
     contextUsed?: number;
     reason: 'header_above_enter' | 'header_below_exit' | 'hysteresis_keep' | 'no_header';
 }
+export interface CompactModeOptions {
+    projectPath?: string;
+    sourcePath?: string;
+    flow?: string;
+}
 export interface CompactMetrics {
     compactDecisions: number;
     verboseDecisions: number;

package/dist/types/context-artifacts.d.ts

@@ -0,0 +1,96 @@
+export type ContextArtifactContentType = 'json' | 'test-log' | 'runtime-log' | 'search-results' | 'code' | 'spec-or-handoff' | 'generic-text';
+export interface ContextArtifactCompactionMetadata {
+    artifactRef: string;
+    originalTokens: number;
+    compactTokens: number;
+    tokensSaved: number;
+    strategy: string;
+    contentType: ContextArtifactContentType;
+    expiresAt: string;
+    retrievalHint: string;
+}
+export interface ContextArtifact {
+    ref: string;
+    contentHash: string;
+    createdAt: string;
+    expiresAt: string;
+    ttlMs: number;
+    projectId: string;
+    contentType: ContextArtifactContentType;
+    strategy: string;
+    originalTokens: number;
+    compactTokens: number;
+    tokensSaved: number;
+    retrievalCount: number;
+    metadata: Record<string, string | number | boolean>;
+    originalContent: string;
+    compactContent: string;
+}
+export interface StoreContextArtifactInput {
+    projectPath: string;
+    originalContent: string;
+    compactContent: string;
+    contentType: ContextArtifactContentType;
+    strategy: string;
+    originalTokens: number;
+    compactTokens: number;
+    ttlMs: number;
+    sourcePath?: string;
+    flow?: string;
+    metadata?: Record<string, unknown>;
+}
+export interface StoreContextArtifactResult {
+    stored: boolean;
+    artifact?: ContextArtifact;
+    metadata?: ContextArtifactCompactionMetadata;
+    refusedReason?: string;
+}
+export interface RetrieveContextArtifactResult {
+    found: boolean;
+    artifact?: ContextArtifact;
+    reason?: 'missing' | 'expired' | 'corrupt' | 'invalid-ref' | 'unauthorized';
+    hint: string;
+}
+export interface ContextArtifactStats {
+    artifactCount: number;
+    totalOriginalTokens: number;
+    totalCompactTokens: number;
+    totalTokensSaved: number;
+    retrievalCount: number;
+}
+export interface ContentAwareCompactionInput {
+    text: string;
+    policy: {
+        contextArtifacts?: {
+            enabled?: boolean;
+            ttlMs?: number;
+            minTokens?: number;
+        };
+        contentCompaction?: {
+            strategies?: Partial<Record<ContextArtifactContentType, {
+                maxLines?: number;
+                maxSnippetChars?: number;
+            }>>;
+        };
+        redaction: {
+            maxSnippetChars: number;
+            redactPatterns: string[];
+        };
+    };
+    projectPath?: string;
+    kind?: string;
+    sourcePath?: string;
+    flow?: string;
+    metadata?: Record<string, unknown>;
+}
+export interface ContentAwareCompactionResult {
+    text: string;
+    originalTokens: number;
+    compactTokens: number;
+    tokensSaved: number;
+    strategy: string;
+    contentType: ContextArtifactContentType;
+    artifact?: ContextArtifactCompactionMetadata;
+    refusedReason?: string;
+}
+//# sourceMappingURL=context-artifacts.d.ts.map

package/dist/types/context-artifacts.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=context-artifacts.js.map

package/dist/types/handoff-artifacts.d.ts

@@ -72,6 +72,7 @@ export interface ValidationReportV1 {
             evidence: string[];
         }[];
     };
+    minimalityReport?: MinimalImplementationReport;
     score?: number;
     completedAt: string;
 }
@@ -83,4 +84,5 @@ export interface ArtifactPayloadMap {
     'validation-report': ValidationReportV1;
 }
 export type ArtifactPayload<K extends ArtifactKind> = ArtifactPayloadMap[K];
+import type { MinimalImplementationReport } from './minimal-implementation-gate.js';
 //# sourceMappingURL=handoff-artifacts.d.ts.map

package/dist/types/index.d.ts

@@ -80,6 +80,8 @@ export * from './workers.js';
 export * from './orchestration-runtime.js';
 export * from './token-optimization.js';
 export * from './token-waste-autopilot.js';
+export * from './context-artifacts.js';
+export * from './minimal-implementation-gate.js';
 export * from './llm-providers.js';
 export * from './plugins.js';
 export * from './github.js';

package/dist/types/index.js

@@ -81,6 +81,8 @@ export * from './workers.js';
 export * from './orchestration-runtime.js';
 export * from './token-optimization.js';
 export * from './token-waste-autopilot.js';
+export * from './context-artifacts.js';
+export * from './minimal-implementation-gate.js';
 export * from './llm-providers.js';
 export * from './plugins.js';
 export * from './github.js';

package/dist/types/minimal-implementation-gate.d.ts

@@ -0,0 +1,92 @@
+export type MinimalImplementationTag = string;
+export type MinimalImplementationSeverity = 'info' | 'warning' | 'blocker';
+export type MinimalImplementationConfidence = 'low' | 'medium' | 'high';
+export type MinimalImplementationSource = 'policy' | 'project-config' | 'runtime' | 'spec';
+export interface MinimalImplementationPolicyLoadOptions {
+    defaultPolicyPath?: string;
+}
+export interface MinimalImplementationEvidence {
+    source: MinimalImplementationSource;
+    key: string;
+    value?: string | number | boolean;
+}
+export interface MinimalImplementationRule {
+    id: string;
+    tag: MinimalImplementationTag;
+    severity: MinimalImplementationSeverity;
+    confidence: MinimalImplementationConfidence;
+    patterns: string[];
+    replacementGuidance: string;
+    blockWhenRiskAtLeast?: 'low' | 'medium' | 'high' | 'max';
+}
+export interface MinimalImplementationPolicy {
+    version: 1;
+    enabled: boolean;
+    report: {
+        maxFindings: number;
+        maxMarkdownLines: number;
+        maxEvidenceChars: number;
+    };
+    tags: Record<string, {
+        description: string;
+    }>;
+    rules: MinimalImplementationRule[];
+    safetyExclusions: string[];
+    excludedPathPatterns: string[];
+    debtEvidence: {
+        requiredFields: string[];
+    };
+}
+export interface LoadedMinimalImplementationPolicy {
+    policy: MinimalImplementationPolicy;
+    evidence: MinimalImplementationEvidence[];
+}
+export interface MinimalImplementationFileSignal {
+    path: string;
+    content?: string;
+}
+export interface MinimalImplementationInput {
+    policy: MinimalImplementationPolicy;
+    specId?: string;
+    specRisk?: string;
+    specText?: string;
+    handoffText?: string;
+    files?: MinimalImplementationFileSignal[];
+    packageManifestText?: string;
+    acceptedDebt?: MinimalImplementationDebtEvidence[];
+    evidence?: MinimalImplementationEvidence[];
+}
+export interface MinimalImplementationFinding {
+    ruleId: string;
+    tag: MinimalImplementationTag;
+    severity: MinimalImplementationSeverity;
+    confidence: MinimalImplementationConfidence;
+    target: string;
+    line?: number;
+    evidence: string;
+    replacementGuidance: string;
+    blocksDone: boolean;
+    evidenceSource: MinimalImplementationEvidence[];
+}
+export interface MinimalImplementationSafetyException {
+    target: string;
+    reason: string;
+    evidence: string;
+}
+export interface MinimalImplementationDebtEvidence {
+    specId: string;
+    files: string[];
+    ceiling: string;
+    upgradeTrigger: string;
+    reviewRationale: string;
+}
+export interface MinimalImplementationReport {
+    enabled: boolean;
+    blocked: boolean;
+    findings: MinimalImplementationFinding[];
+    safetyExceptions: MinimalImplementationSafetyException[];
+    debtEvidence: MinimalImplementationDebtEvidence[];
+    evidence: MinimalImplementationEvidence[];
+    markdown: string;
+}
+//# sourceMappingURL=minimal-implementation-gate.d.ts.map

package/dist/types/minimal-implementation-gate.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=minimal-implementation-gate.js.map

package/dist/types/token-optimization.d.ts

@@ -104,6 +104,8 @@ export interface ToolTokenRecord {
     cacheHits: number;
     cacheMisses: number;
     tokensSaved: number;
+    compactionTokensSaved?: number;
+    artifactRetrievals?: number;
 }
 export interface BatchEntry {
     input: unknown;

package/dist/types/token-waste-autopilot.d.ts

@@ -1,3 +1,4 @@
+import type { ContextArtifactCompactionMetadata } from './context-artifacts.js';
 export type TokenWasteDecisionKind = 'include' | 'summarize' | 'exclude' | 'recommend' | 'avoid' | 'warn' | 'override';
 export type TokenWasteConfidence = 'high' | 'medium' | 'low';
 export type TokenWasteAction = string;
@@ -21,6 +22,7 @@ export interface TokenWasteOutputStrategy {
     keepFailures?: boolean;
     uniqueOnly?: boolean;
     summarizeKeys?: boolean;
+    maxSnippetChars?: number;
 }
 export interface TokenWastePolicy {
     version: 1;
@@ -35,6 +37,14 @@ export interface TokenWastePolicy {
     outputs: {
         strategies: Record<string, TokenWasteOutputStrategy>;
     };
+    contextArtifacts?: {
+        enabled: boolean;
+        ttlMs: number;
+        minTokens: number;
+    };
+    contentCompaction?: {
+        strategies: Record<string, TokenWasteOutputStrategy>;
+    };
     tools: {
         groups: Record<string, string[]>;
         maxRecommended: number;
@@ -83,12 +93,17 @@ export interface VerboseOutputInput {
     text: string;
     policy: TokenWastePolicy;
     fullOutputRef?: string;
+    projectPath?: string;
+    sourcePath?: string;
+    flow?: string;
+    metadata?: Record<string, unknown>;
 }
 export interface VerboseOutputResult {
     text: string;
     originalLines: number;
     returnedLines: number;
     fullOutputRef?: string;
+    compaction?: ContextArtifactCompactionMetadata;
     decisions: TokenWasteDecision[];
 }
 export interface ToolRelevanceInput {