@planu/cli 4.4.3 → 4.6.0

package/CHANGELOG.md

@@ -1,3 +1,22 @@
+## [4.6.0] - 2026-06-11
+
+### Features
+- feat(SPEC-1084): add token waste autopilot
+
+### Chores
+- chore(deps): sync lockfile
+- chore(deps): update patch dependencies
+
+
+## [4.5.0] - 2026-06-10
+
+### Features
+- feat(create-spec): generate intent-grounded questions
+
+### Chores
+- chore(deps): update release tooling
+
+
 ## [4.4.3] - 2026-06-09
 
 ### Features
@@ -4042,4 +4061,4 @@ Format: [Keep a Changelog](https://keepachangelog.com/en/1.1.0/) · Versioning:
 - Mermaid diagram generation (architecture, sequence, state machine, ER, data flow)
 - Multi-language i18n (EN/ES/PT) for generated specs
 - Clean Architecture (hexagonal) — engine, tools, storage, types layers
-- 10,857 tests with ≥95% coverage
+- 10,857 tests with ≥95% coverage

package/dist/config/token-waste-autopilot.json

@@ -0,0 +1,48 @@
+{
+  "version": 1,
+  "enabled": true,
+  "context": {
+    "generatedPatterns": ["dist/**", "coverage/**", ".next/**", "build/**"],
+    "stalePatterns": ["*.log", "*.bak", "*.tmp"],
+    "summarizePatterns": ["pnpm-lock.yaml", "package-lock.json", "yarn.lock"],
+    "staleSessionMinutes": 60,
+    "safetyOverrideActions": ["release", "security", "license", "lockfile", "exact-reproduction"]
+  },
+  "outputs": {
+    "strategies": {
+      "test": { "maxLines": 40, "keepFailures": true },
+      "log": { "maxLines": 30, "uniqueOnly": true },
+      "json": { "maxLines": 40, "summarizeKeys": true },
+      "dependency": { "maxLines": 50, "keepFailures": true },
+      "generic": { "maxLines": 60 }
+    }
+  },
+  "tools": {
+    "groups": {
+      "spec": ["create_spec", "check_readiness", "challenge_spec", "update_status"],
+      "handoff": ["package_handoff", "generate_execution_plan"],
+      "status": ["planu_status", "session_checkpoint"],
+      "token": ["token_intelligence", "tokens", "context_budget"]
+    },
+    "maxRecommended": 8
+  },
+  "loops": {
+    "thresholds": {
+      "file_read": 3,
+      "search": 3,
+      "test_run": 2,
+      "failure": 2
+    },
+    "safetyOverrideActions": ["release", "security", "license"]
+  },
+  "modelEffort": {
+    "lowRisk": "low",
+    "default": "medium",
+    "highRisk": "high",
+    "maxRisk": "max"
+  },
+  "redaction": {
+    "maxSnippetChars": 240,
+    "redactPatterns": ["secret", "token", "password", "api_key"]
+  }
+}

package/dist/engine/elicitation/answer-extractor.js

@@ -5,6 +5,12 @@ const BACKEND_TERMS = /\b(api|endpoint|route|handler|migration|query|rpc|action|
 const INFRA_TERMS = /\b(deploy|ci|cd|docker|pipeline|config|env)\b/;
 const BILLING_TERMS = /\b(payment|billing|invoice|subscription|checkout|pricing|pay)\b/;
 const DATABASE_TERMS = /\b(database|schema|migration|table|query|sql|rls|rpc|persist|persistence|data access)\b/;
+const ACTION_RE = /\b(add|build|create|fix|update|remove|delete|integrate|sync|import|export|approve|reject|upload|download|migrate|configure|validate)\b\s+(?:(?:a|an|the|new)\s+)?([a-z0-9][a-z0-9 -]{1,60})/i;
+const ACTOR_TERMS = /\b(admin|administrator|manager|owner|customer|user|member|team|approver)\b/gi;
+const DATA_OBJECT_TERMS = /\b(account|profile|request|invoice|subscription|payment|order|report|file|avatar|table|policy|record|settings)\b/gi;
+const PERMISSION_TERMS = /\b(approval|approve|reject|admin|permission|role|rls|policy|access|auth|login|oauth|owner|manager)\b/;
+const DESTRUCTIVE_TERMS = /\b(delete|remove|archive|discard|drop|truncate|revoke|reset)\b/;
+const RISK_TERMS = /\b(approval|approve|payment|billing|auth|login|permission|role|delete|remove|migration|sync|webhook|external|api|rls|privacy|security)\b/gi;
 const PAYMENT_PROVIDERS = [
     { name: 'Stripe', pattern: /\bstripe\b/ },
     { name: 'PayPal', pattern: /\bpaypal\b/ },
@@ -33,7 +39,34 @@ export function extractSignals(description) {
     const hasBilling = BILLING_TERMS.test(lower) || namedProvider !== null;
     const wordCount = description.trim().split(/\s+/).length;
     const hasScope = wordCount >= 10;
-    return { hasTarget, hasBilling, hasDatabase, hasUi, namedProvider, hasScope };
+    const actionMatch = ACTION_RE.exec(lower);
+    const action = actionMatch?.[1] ?? null;
+    const domainObject = cleanDomainObject(actionMatch?.[2] ?? null);
+    const actors = uniqueMatches(lower, ACTOR_TERMS);
+    const dataObjects = uniqueMatches(lower, DATA_OBJECT_TERMS);
+    const riskTerms = uniqueMatches(lower, RISK_TERMS);
+    const integrations = [
+        ...PAYMENT_PROVIDERS.filter(({ pattern }) => pattern.test(lower)).map(({ name }) => name),
+        ...extractExternalIntegrations(lower),
+    ];
+    const hasPermissionRisk = PERMISSION_TERMS.test(lower);
+    const hasDestructiveAction = DESTRUCTIVE_TERMS.test(lower);
+    return {
+        hasTarget,
+        hasBilling,
+        hasDatabase,
+        hasUi,
+        namedProvider,
+        hasScope,
+        action,
+        domainObject,
+        actors,
+        integrations,
+        dataObjects,
+        hasPermissionRisk,
+        hasDestructiveAction,
+        riskTerms,
+    };
 }
 function stripIncidentalReferences(description) {
     return description
@@ -41,4 +74,23 @@ function stripIncidentalReferences(description) {
         .replace(/\b\S+\/\S+\b/g, ' ')
         .replace(/\b[\w-]+\.(?:ts|tsx|js|jsx|mjs|cjs|json|md|css|scss|py|go|rs|java|rb|php)\b/g, ' ');
 }
+function cleanDomainObject(value) {
+    if (value === null) {
+        return null;
+    }
+    const cleaned = value
+        .replace(/\b(that|with|to|from|when|where|and|or|but|using|in)\b.*$/i, '')
+        .replace(/\s+/g, ' ')
+        .trim();
+    return cleaned.length > 0 ? cleaned : null;
+}
+function uniqueMatches(text, pattern) {
+    const flags = pattern.flags.includes('g') ? pattern.flags : `${pattern.flags}g`;
+    const globalPattern = new RegExp(pattern.source, flags);
+    return Array.from(new Set(Array.from(text.matchAll(globalPattern)).map((match) => match[0])));
+}
+function extractExternalIntegrations(text) {
+    const matches = text.match(/\b([a-z][a-z0-9-]+)\s+(?:api|webhook|sdk|integration)\b/gi) ?? [];
+    return Array.from(new Set(matches.map((match) => match.replace(/\s+(api|webhook|sdk|integration)$/i, ''))));
+}
 //# sourceMappingURL=answer-extractor.js.map

package/dist/engine/elicitation/decision-gap-detector.d.ts

@@ -0,0 +1,3 @@
+import type { DecisionGap, ProjectKnowledge, DescriptionSignals } from '../../types/index.js';
+export declare function detectDecisionGaps(signals: DescriptionSignals, _projectContext: ProjectKnowledge | null): DecisionGap[];
+//# sourceMappingURL=decision-gap-detector.d.ts.map

package/dist/engine/elicitation/decision-gap-detector.js

@@ -0,0 +1,162 @@
+const MAX_GAPS = 3;
+export function detectDecisionGaps(signals, _projectContext) {
+    const gaps = [
+        buildPermissionGap(signals),
+        buildProviderGap(signals),
+        buildBillingModelGap(signals),
+        buildDataGap(signals),
+        buildFailureGap(signals),
+    ].filter((gap) => gap !== null);
+    if (gaps.length === 0 && !signals.hasScope) {
+        gaps.push(buildBehaviorGap(signals));
+    }
+    return gaps.slice(0, MAX_GAPS);
+}
+function buildPermissionGap(signals) {
+    if (!signals.hasPermissionRisk || signals.actors.length > 0) {
+        return null;
+    }
+    const subject = formatSubject(signals);
+    return makeGap({
+        id: 'permission-owner',
+        kind: 'permission',
+        header: 'Permission',
+        question: `For ${subject}, who is allowed to perform this action? This changes permissions, validation, and audit behavior.`,
+        evidence: evidenceFrom(signals, ['permission-sensitive wording']),
+        impact: 'Changes authorization checks and acceptance criteria.',
+        options: options([
+            ['Role-based owner (Recommended)', 'Use the existing role or owner model for this action.'],
+            ['Admin only', 'Restrict the behavior to administrators.'],
+            ['Any signed-in user', 'Allow all authenticated users and keep checks minimal.'],
+        ]),
+    });
+}
+function buildProviderGap(signals) {
+    if (!signals.hasBilling || signals.namedProvider !== null) {
+        return null;
+    }
+    const subject = formatSubject(signals);
+    return makeGap({
+        id: 'payment-provider',
+        kind: 'provider',
+        header: 'Provider',
+        question: `For ${subject}, which payment provider should own the payment flow? This changes API contracts, webhook handling, and test fixtures.`,
+        evidence: evidenceFrom(signals, ['billing/payment wording']),
+        impact: 'Changes integration code, webhook behavior, and verification fixtures.',
+        options: options([
+            ['Stripe (Recommended)', 'Use the most common provider for subscription and checkout flows.'],
+            ['PayPal', 'Use PayPal checkout and payment APIs.'],
+            [
+                'No provider yet',
+                'Keep provider integration out of scope and define internal contracts only.',
+            ],
+        ]),
+    });
+}
+function buildBillingModelGap(signals) {
+    if (!signals.hasBilling) {
+        return null;
+    }
+    const subject = formatSubject(signals);
+    return makeGap({
+        id: 'billing-model',
+        kind: 'billing-model',
+        header: 'Billing',
+        question: `For ${subject}, is the billing behavior recurring, one-time, or invoice-based? This changes states, events, and acceptance criteria.`,
+        evidence: evidenceFrom(signals, ['billing/payment wording']),
+        impact: 'Changes lifecycle states and acceptance criteria.',
+        options: options([
+            ['Recurring subscription (Recommended)', 'Model ongoing subscriptions and renewal states.'],
+            ['One-time checkout', 'Model a single payment completion flow.'],
+            ['Invoice-based', 'Model invoice creation, payment, and overdue states.'],
+        ]),
+    });
+}
+function buildDataGap(signals) {
+    if (!signals.hasDatabase || signals.dataObjects.length > 0) {
+        return null;
+    }
+    const subject = formatSubject(signals);
+    return makeGap({
+        id: 'data-shape',
+        kind: 'data',
+        header: 'Data',
+        question: `For ${subject}, what data must be stored or updated? This changes schema, validation, and migration work.`,
+        evidence: evidenceFrom(signals, ['database/data wording']),
+        impact: 'Changes schema, persistence, and validation requirements.',
+        options: options([
+            [
+                'Existing records only (Recommended)',
+                'Use existing tables or records without a new schema.',
+            ],
+            ['New table or field', 'Add persistence changes and migration coverage.'],
+            ['Read-only data', 'Do not persist new state for this behavior.'],
+        ]),
+    });
+}
+function buildFailureGap(signals) {
+    if (signals.integrations.length === 0 &&
+        !signals.riskTerms.includes('sync') &&
+        !signals.riskTerms.includes('api')) {
+        return null;
+    }
+    const subject = formatSubject(signals);
+    return makeGap({
+        id: 'failure-handling',
+        kind: 'failure',
+        header: 'Failure',
+        question: `For ${subject}, what should happen if ${formatIntegration(signals)} fails? This changes retry, error, and user-visible behavior.`,
+        evidence: evidenceFrom(signals, signals.integrations.length > 0 ? signals.integrations : ['integration/API wording']),
+        impact: 'Changes error handling, retries, and tests.',
+        options: options([
+            ['Show recoverable error (Recommended)', 'Return a clear error and preserve current state.'],
+            ['Retry automatically', 'Retry transient failures before surfacing an error.'],
+            ['Queue for later', 'Persist work for asynchronous retry.'],
+        ]),
+    });
+}
+function buildBehaviorGap(signals) {
+    const subject = formatSubject(signals);
+    return makeGap({
+        id: 'behavior-outcome',
+        kind: 'behavior',
+        header: 'Behavior',
+        question: `For ${subject}, what observable outcome should prove the work is done? This becomes the primary acceptance criterion.`,
+        evidence: evidenceFrom(signals, ['short request']),
+        impact: 'Changes the main acceptance criterion and verification command.',
+        options: options([
+            ['User-visible workflow (Recommended)', 'Define the end-to-end behavior a user can observe.'],
+            ['Backend behavior', 'Define API, persistence, job, or integration behavior.'],
+            ['Cleanup or fix', 'Define the before/after bug or cleanup result.'],
+        ]),
+    });
+}
+function makeGap(gap) {
+    return { ...gap, multiSelect: gap.multiSelect ?? false, blocking: true };
+}
+function formatSubject(signals) {
+    const action = signals.action ?? 'this request';
+    const object = signals.domainObject;
+    return object === null ? action : `${action} ${object}`;
+}
+function formatIntegration(signals) {
+    if (signals.integrations.length > 0) {
+        return signals.integrations[0] ?? 'the integration';
+    }
+    if (signals.riskTerms.includes('sync')) {
+        return 'the sync';
+    }
+    return 'the API';
+}
+function evidenceFrom(signals, extra) {
+    return [
+        ...(signals.action ? [`action:${signals.action}`] : []),
+        ...(signals.domainObject ? [`object:${signals.domainObject}`] : []),
+        ...signals.riskTerms.map((term) => `risk:${term}`),
+        ...extra,
+    ].slice(0, 6);
+}
+function options(items) {
+    return items.map(([label, description]) => ({ label, description }));
+}
+//# sourceMappingURL=decision-gap-detector.js.map

package/dist/engine/elicitation/question-grounding-gate.d.ts

@@ -0,0 +1,3 @@
+import type { InteractiveQuestion, QuestionGroundingContext, QuestionGroundingResult } from '../../types/index.js';
+export declare function validateQuestionGrounding(question: InteractiveQuestion, context: QuestionGroundingContext): QuestionGroundingResult;
+//# sourceMappingURL=question-grounding-gate.d.ts.map

package/dist/engine/elicitation/question-grounding-gate.js

@@ -0,0 +1,54 @@
+const GENERIC_QUESTION_PATTERNS = [
+    /^who (are|is) the users\??$/i,
+    /^what are the edge cases\??$/i,
+    /^what should happen\??$/i,
+    /^what is the scope\??$/i,
+    /^what data is needed\??$/i,
+    /^what are the requirements\??$/i,
+];
+export function validateQuestionGrounding(question, context) {
+    const text = question.question.trim();
+    if (GENERIC_QUESTION_PATTERNS.some((pattern) => pattern.test(text))) {
+        return { passed: false, reason: 'Question is a generic reusable prompt.' };
+    }
+    const lowerQuestion = text.toLowerCase();
+    const lowerEvidence = [context.requestText, ...context.gap.evidence].join(' ').toLowerCase();
+    const evidenceTokens = tokenSet(lowerEvidence);
+    const hasRequestEvidence = Array.from(evidenceTokens).some((token) => token.length >= 3 && lowerQuestion.includes(token));
+    if (!hasRequestEvidence) {
+        return {
+            passed: false,
+            reason: 'Question does not include evidence from the request or detected gap.',
+        };
+    }
+    if (!/\bchanges?\b|\bthis changes\b|\baffects?\b|\bbecause\b|\bbecomes?\b/i.test(text)) {
+        return {
+            passed: false,
+            reason: 'Question does not explain why the answer matters for the spec.',
+        };
+    }
+    return { passed: true };
+}
+function tokenSet(text) {
+    return new Set(text
+        .replace(/[^a-z0-9 ]/gi, ' ')
+        .split(/\s+/)
+        .filter((token) => !STOP_WORDS.has(token) && token.length > 2));
+}
+const STOP_WORDS = new Set([
+    'the',
+    'and',
+    'for',
+    'this',
+    'that',
+    'with',
+    'from',
+    'what',
+    'when',
+    'where',
+    'should',
+    'action',
+    'object',
+    'risk',
+]);
+//# sourceMappingURL=question-grounding-gate.js.map

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

@@ -0,0 +1,5 @@
+import type { TokenWasteAutopilotInput, TokenWasteReport } from '../../types/token-waste-autopilot.js';
+export declare function redactSnippet(text: string, patterns: string[], maxChars: number): string;
+export declare function buildTokenWasteReport(input: TokenWasteAutopilotInput): TokenWasteReport;
+export declare function formatTokenWasteReport(report: TokenWasteReport): string;
+//# sourceMappingURL=autopilot.d.ts.map

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

@@ -0,0 +1,93 @@
+function collectEvidence(decisions) {
+    return decisions.flatMap((decision) => decision.evidence);
+}
+function modelAdvice(input) {
+    const risk = input.spec?.risk ?? 'medium';
+    const effort = risk === 'critical'
+        ? input.policy.modelEffort.maxRisk
+        : risk === 'high'
+            ? input.policy.modelEffort.highRisk
+            : risk === 'low'
+                ? input.policy.modelEffort.lowRisk
+                : input.policy.modelEffort.default;
+    return {
+        effort,
+        reason: `Selected ${effort} effort from spec risk ${risk}.`,
+        evidence: [
+            { source: 'spec', key: 'risk', value: risk },
+            { source: 'policy', key: 'modelEffort' },
+        ],
+    };
+}
+function escapeInert(text) {
+    return text.replace(/</g, '&lt;').replace(/>/g, '&gt;');
+}
+export function redactSnippet(text, patterns, maxChars) {
+    const truncated = text.slice(0, maxChars);
+    return patterns.reduce((current, pattern) => {
+        const re = new RegExp(pattern, 'gi');
+        return current.replace(re, '[redacted]');
+    }, truncated);
+}
+function sanitizeDecision(decision, patterns, maxChars) {
+    return {
+        ...decision,
+        target: redactSnippet(decision.target, patterns, maxChars),
+        reason: redactSnippet(decision.reason, patterns, maxChars),
+        evidence: decision.evidence.map((item) => ({
+            ...item,
+            ...(typeof item.value === 'string'
+                ? { value: redactSnippet(item.value, patterns, maxChars) }
+                : {}),
+        })),
+    };
+}
+function sanitizeDecisions(decisions, input) {
+    return decisions.map((decision) => sanitizeDecision(decision, input.policy.redaction.redactPatterns, input.policy.redaction.maxSnippetChars));
+}
+export function buildTokenWasteReport(input) {
+    const actionsTaken = sanitizeDecisions([
+        ...(input.context?.summarize ?? []),
+        ...(input.context?.exclude ?? []),
+        ...(input.output?.decisions ?? []),
+    ], input);
+    const recommendations = sanitizeDecisions([...(input.context?.include ?? []), ...(input.tools?.recommended ?? [])], input);
+    const risks = sanitizeDecisions([...(input.tools?.avoided ?? []), ...(input.loops?.warnings ?? [])], input);
+    const modelEffort = modelAdvice(input);
+    return {
+        actionsTaken,
+        recommendations,
+        risks,
+        evidence: [
+            ...collectEvidence(actionsTaken),
+            ...collectEvidence(recommendations),
+            ...collectEvidence(risks),
+            ...modelEffort.evidence,
+        ],
+        modelEffort,
+    };
+}
+export function formatTokenWasteReport(report) {
+    const lines = ['## Token Waste Autopilot', ''];
+    lines.push(`Model effort: ${escapeInert(report.modelEffort.effort)} — ${escapeInert(report.modelEffort.reason)}`);
+    if (report.actionsTaken.length > 0) {
+        lines.push('', 'Actions taken:');
+        for (const item of report.actionsTaken.slice(0, 6)) {
+            lines.push(`- ${escapeInert(item.decision)}: ${escapeInert(item.target)} — ${escapeInert(item.reason)}`);
+        }
+    }
+    if (report.recommendations.length > 0) {
+        lines.push('', 'Recommendations:');
+        for (const item of report.recommendations.slice(0, 6)) {
+            lines.push(`- ${escapeInert(item.target)}: ${escapeInert(item.reason)}`);
+        }
+    }
+    if (report.risks.length > 0) {
+        lines.push('', 'Risks:');
+        for (const item of report.risks.slice(0, 6)) {
+            lines.push(`- ${escapeInert(item.target)}: ${escapeInert(item.reason)}`);
+        }
+    }
+    return lines.join('\n');
+}
+//# sourceMappingURL=autopilot.js.map

package/dist/engine/token-optimizer/context-preflight.d.ts

@@ -0,0 +1,3 @@
+import type { ContextPreflightInput, ContextPreflightResult } from '../../types/token-waste-autopilot.js';
+export declare function analyzeContextPreflight(input: ContextPreflightInput): ContextPreflightResult;
+//# sourceMappingURL=context-preflight.d.ts.map

package/dist/engine/token-optimizer/context-preflight.js

@@ -0,0 +1,64 @@
+function globToRegExp(pattern) {
+    const escaped = pattern
+        .replace(/[.+^${}()|[\]\\]/g, '\\$&')
+        .replace(/\*\*/g, '::DOUBLE_STAR::')
+        .replace(/\*/g, '[^/]*')
+        .replace(/::DOUBLE_STAR::/g, '.*');
+    return new RegExp(`^${escaped}$`);
+}
+function matchesAny(path, patterns) {
+    return patterns.find((pattern) => globToRegExp(pattern).test(path));
+}
+function decision(kind, target, reason, key) {
+    return {
+        decision: kind,
+        target,
+        reason,
+        evidence: [{ source: 'policy', key }],
+        confidence: 'high',
+    };
+}
+function hasSafetyOverride(action, policy) {
+    return policy.context.safetyOverrideActions.includes(action);
+}
+function classifyCandidate(candidate, input) {
+    if (hasSafetyOverride(input.action, input.policy)) {
+        return decision('override', candidate.path, `Action ${input.action} requires exact context according to policy.`, 'context.safetyOverrideActions');
+    }
+    const generated = matchesAny(candidate.path, input.policy.context.generatedPatterns);
+    if (generated !== undefined) {
+        return decision('exclude', candidate.path, `Matches generated context pattern ${generated}.`, 'context.generatedPatterns');
+    }
+    const stale = matchesAny(candidate.path, input.policy.context.stalePatterns);
+    if (stale !== undefined) {
+        return decision('exclude', candidate.path, `Matches stale context pattern ${stale}.`, 'context.stalePatterns');
+    }
+    const summarize = matchesAny(candidate.path, input.policy.context.summarizePatterns);
+    if (summarize !== undefined) {
+        return decision('summarize', candidate.path, `Matches summarizable context pattern ${summarize}.`, 'context.summarizePatterns');
+    }
+    return {
+        decision: 'include',
+        target: candidate.path,
+        reason: candidate.reason ?? 'Candidate context is relevant and not excluded by policy.',
+        evidence: [{ source: 'runtime', key: 'candidate.path', value: candidate.path }],
+        confidence: 'medium',
+    };
+}
+export function analyzeContextPreflight(input) {
+    const result = { include: [], summarize: [], exclude: [] };
+    for (const candidate of input.candidates) {
+        const item = classifyCandidate(candidate, input);
+        if (item.decision === 'exclude') {
+            result.exclude.push(item);
+        }
+        else if (item.decision === 'summarize') {
+            result.summarize.push(item);
+        }
+        else {
+            result.include.push(item);
+        }
+    }
+    return result;
+}
+//# sourceMappingURL=context-preflight.js.map

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

@@ -8,5 +8,11 @@ export { BudgetManager } from './budget.js';
 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 { analyzeContextPreflight } from './context-preflight.js';
+export { filterVerboseOutput } from './output-filter.js';
+export { recommendRelevantTools, toolsFromPolicyGroups } from './tool-relevance.js';
+export { detectTokenWasteLoops } from './loop-detector.js';
+export { buildTokenWasteReport, formatTokenWasteReport, redactSnippet } from './autopilot.js';
 export type { DailyBreakdown, TrendResult, Anomaly, TopConsumer, OptimizationSavings, } from './analytics.js';
 //# sourceMappingURL=index.d.ts.map

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

@@ -9,4 +9,10 @@ export { BudgetManager } from './budget.js';
 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 { analyzeContextPreflight } from './context-preflight.js';
+export { filterVerboseOutput } from './output-filter.js';
+export { recommendRelevantTools, toolsFromPolicyGroups } from './tool-relevance.js';
+export { detectTokenWasteLoops } from './loop-detector.js';
+export { buildTokenWasteReport, formatTokenWasteReport, redactSnippet } from './autopilot.js';
 //# sourceMappingURL=index.js.map

package/dist/engine/token-optimizer/loop-detector.d.ts

@@ -0,0 +1,3 @@
+import type { TokenWasteLoopResult, TokenWastePolicy, TokenWasteRuntimeEvent } from '../../types/token-waste-autopilot.js';
+export declare function detectTokenWasteLoops(events: TokenWasteRuntimeEvent[], policy: TokenWastePolicy, action?: string): TokenWasteLoopResult;
+//# sourceMappingURL=loop-detector.d.ts.map

package/dist/engine/token-optimizer/loop-detector.js

@@ -0,0 +1,32 @@
+export function detectTokenWasteLoops(events, policy, action = 'default') {
+    if (policy.loops.safetyOverrideActions.includes(action)) {
+        return { warnings: [] };
+    }
+    const counts = new Map();
+    for (const event of events) {
+        if (event.changedSincePrevious === true) {
+            continue;
+        }
+        const key = `${event.type}:${event.key}`;
+        counts.set(key, (counts.get(key) ?? 0) + 1);
+    }
+    const warnings = [];
+    for (const [key, count] of counts) {
+        const [type = 'unknown', target = key] = key.split(':');
+        const threshold = policy.loops.thresholds[type] ?? Number.POSITIVE_INFINITY;
+        if (count >= threshold) {
+            warnings.push({
+                decision: 'warn',
+                target,
+                reason: `Repeated ${type} operation detected ${String(count)} times without an intervening change.`,
+                evidence: [
+                    { source: 'policy', key: `loops.thresholds.${type}`, value: threshold },
+                    { source: 'runtime', key: 'event.count', value: count },
+                ],
+                confidence: 'high',
+            });
+        }
+    }
+    return { warnings };
+}
+//# sourceMappingURL=loop-detector.js.map

package/dist/engine/token-optimizer/output-filter.d.ts

@@ -0,0 +1,3 @@
+import type { VerboseOutputInput, VerboseOutputResult } from '../../types/token-waste-autopilot.js';
+export declare function filterVerboseOutput(input: VerboseOutputInput): VerboseOutputResult;
+//# sourceMappingURL=output-filter.d.ts.map