@compaction/cli 0.1.0

package/dist/core/trace-parser.js

@@ -0,0 +1,143 @@
+import { readFile } from "node:fs/promises";
+import { z } from "zod";
+export const CURRENT_AGENT_TRACE_ARTIFACT_VERSION = "agent-trace-v1";
+const isoTimestampSchema = z.string().datetime({ offset: true });
+const traceMessageSchema = z.object({
+    id: z.string().min(1),
+    role: z.enum(["system", "user", "assistant", "tool", "stdout", "stderr"]),
+    content: z.string(),
+    timestamp: isoTimestampSchema,
+    toolName: z.string().min(1).optional(),
+    metadata: z.record(z.unknown()).optional()
+});
+const commandMetadataSchema = z.object({
+    command: z.string().min(1),
+    args: z.array(z.string()),
+    cwd: z.string().min(1).optional(),
+    shell: z.string().min(1).optional()
+});
+// `codex_import` is deliberately NOT a command trace: an imported `codex exec --json`
+// JSONL export carries no command/exitCode/durationMs provenance, so it must not be
+// subjected to command-trace validation (that is why the Codex import path could not
+// reuse `cli_wrapper`/`local_command`). Keep this exclusion in lockstep with the
+// `imported_local` evidence mapping in safety-report.ts.
+function isCommandTrace(source) {
+    return source === "cli_wrapper" || source === "local_command";
+}
+const rawAgentTraceSchema = z
+    .object({
+    id: z.string().min(1),
+    title: z.string().min(1),
+    artifactVersion: z.string().min(1).optional(),
+    artifact_version: z.string().min(1).optional(),
+    source: z.enum(["manual", "cli_wrapper", "local_command", "demo", "real_captured", "provider_usage", "codex_import"]).optional(),
+    createdAt: isoTimestampSchema.optional(),
+    created_at: isoTimestampSchema.optional(),
+    generatedAt: isoTimestampSchema.optional(),
+    generated_at: isoTimestampSchema.optional(),
+    model: z.string().min(1),
+    command: commandMetadataSchema.optional(),
+    durationMs: z.number().int().nonnegative().optional(),
+    duration_ms: z.number().int().nonnegative().optional(),
+    exitCode: z.number().int().min(0).max(255).optional(),
+    exit_code: z.number().int().min(0).max(255).optional(),
+    messages: z.array(traceMessageSchema)
+})
+    .superRefine((trace, context) => {
+    const createdAt = trace.createdAt ?? trace.created_at;
+    const generatedAt = trace.generatedAt ?? trace.generated_at;
+    if (!createdAt) {
+        context.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: "Trace must include createdAt or created_at.",
+            path: ["createdAt"]
+        });
+    }
+    if (trace.createdAt && trace.created_at && trace.createdAt !== trace.created_at) {
+        context.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: "createdAt and created_at must match when both are present.",
+            path: ["created_at"]
+        });
+    }
+    if (trace.generatedAt && trace.generated_at && trace.generatedAt !== trace.generated_at) {
+        context.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: "generatedAt and generated_at must match when both are present.",
+            path: ["generated_at"]
+        });
+    }
+    if (trace.artifactVersion && trace.artifact_version && trace.artifactVersion !== trace.artifact_version) {
+        context.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: "artifactVersion and artifact_version must match when both are present.",
+            path: ["artifact_version"]
+        });
+    }
+    if (trace.durationMs !== undefined && trace.duration_ms !== undefined && trace.durationMs !== trace.duration_ms) {
+        context.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: "durationMs and duration_ms must match when both are present.",
+            path: ["duration_ms"]
+        });
+    }
+    if (trace.exitCode !== undefined && trace.exit_code !== undefined && trace.exitCode !== trace.exit_code) {
+        context.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: "exitCode and exit_code must match when both are present.",
+            path: ["exit_code"]
+        });
+    }
+    if (isCommandTrace(trace.source) && !trace.command) {
+        context.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: "Command traces must include command metadata.",
+            path: ["command"]
+        });
+    }
+    if (isCommandTrace(trace.source) && trace.exitCode === undefined && trace.exit_code === undefined) {
+        context.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: "Command traces must include exitCode or exit_code.",
+            path: ["exitCode"]
+        });
+    }
+    if (isCommandTrace(trace.source) && trace.durationMs === undefined && trace.duration_ms === undefined) {
+        context.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: "Command traces must include durationMs or duration_ms.",
+            path: ["durationMs"]
+        });
+    }
+    if (generatedAt && createdAt && new Date(generatedAt).getTime() < new Date(createdAt).getTime()) {
+        context.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: "generatedAt must not be earlier than createdAt.",
+            path: ["generatedAt"]
+        });
+    }
+});
+export const agentTraceSchema = rawAgentTraceSchema.transform((trace) => {
+    const createdAt = trace.createdAt ?? trace.created_at;
+    if (!createdAt) {
+        throw new Error("Trace must include createdAt or created_at.");
+    }
+    return {
+        id: trace.id,
+        title: trace.title,
+        artifactVersion: trace.artifactVersion ?? trace.artifact_version ?? CURRENT_AGENT_TRACE_ARTIFACT_VERSION,
+        source: trace.source ?? "manual",
+        createdAt,
+        generatedAt: trace.generatedAt ?? trace.generated_at ?? createdAt,
+        model: trace.model,
+        command: trace.command,
+        durationMs: trace.durationMs ?? trace.duration_ms,
+        exitCode: trace.exitCode ?? trace.exit_code,
+        messages: trace.messages
+    };
+});
+export async function parseTraceFile(traceFile) {
+    const rawTrace = await readFile(traceFile, "utf8");
+    return agentTraceSchema.parse(JSON.parse(rawTrace));
+}
+//# sourceMappingURL=trace-parser.js.map

package/dist/core/types.d.ts

@@ -0,0 +1,238 @@
+export type TraceRole = "system" | "user" | "assistant" | "tool" | "stdout" | "stderr";
+export type TraceSource = "manual" | "cli_wrapper" | "local_command" | "demo" | "real_captured" | "provider_usage" | "codex_import";
+export interface TraceCommandMetadata {
+    command: string;
+    args: string[];
+    cwd?: string;
+    shell?: string;
+}
+export interface TraceMessage {
+    id: string;
+    role: TraceRole;
+    content: string;
+    timestamp: string;
+    toolName?: string;
+    metadata?: Record<string, unknown>;
+}
+export interface AgentTrace {
+    id: string;
+    title: string;
+    artifactVersion: string;
+    source: TraceSource;
+    createdAt: string;
+    generatedAt: string;
+    model: string;
+    command?: TraceCommandMetadata;
+    durationMs?: number;
+    exitCode?: number;
+    messages: TraceMessage[];
+}
+export interface TokenEstimate {
+    inputTokens: number;
+    outputTokens: number;
+    totalTokens: number;
+}
+export interface CostEstimate {
+    model: string;
+    inputCostUsd: number;
+    outputCostUsd: number;
+    /** Present only when cache_read_input_tokens > 0 and priced at ~10% of standard input rate (estimated). */
+    cacheReadCostUsd?: number;
+    /** Present only when cache_creation_input_tokens > 0 and priced at ~125% of standard input rate (estimated). */
+    cacheCreationCostUsd?: number;
+    totalCostUsd: number;
+}
+export interface WasteFinding {
+    category: "repeated_tool_output" | "stale_context" | "verbose_observation" | "repeated_skill_injection";
+    messageIds: string[];
+    summary: string;
+    estimatedTokens: number;
+}
+export interface StateCapsuleProvenanceEntry {
+    source_trace_id?: string;
+    source_message_id?: string;
+    source_pointer?: string;
+    source_hash?: string;
+    source_hash_algorithm?: "sha256";
+    source_excerpt_preview?: string;
+    source_recoverable: boolean | "unknown";
+    source_recovery_path?: string;
+    original_payload_token_count?: number;
+    capsule_token_count?: number;
+    compacted_message_ids?: string[];
+    replacement_mode?: string;
+}
+export interface StateCapsule {
+    traceId: string;
+    source_trace_id?: string;
+    source_message_id?: string;
+    source_pointer?: string;
+    source_hash?: string;
+    source_hash_algorithm?: "sha256";
+    source_excerpt_preview?: string;
+    source_recoverable?: boolean | "unknown";
+    source_recovery_path?: string;
+    original_payload_token_count?: number;
+    capsule_token_count?: number;
+    preserved_commitments?: string[];
+    omitted_or_unknown_commitments?: string[];
+    unsupported_additions_check?: string;
+    provenance_limitations?: string[];
+    provenance_entries?: StateCapsuleProvenanceEntry[];
+    retainedFacts: string[];
+    openQuestions: string[];
+    safetyNotes: string[];
+}
+export type ApprovalReadinessStatus = "not_ready" | "conditional" | "ready";
+/**
+ * Report-only advisory for repeated byte-identical, same-skill role:user skill injections.
+ * Detection/reporting ONLY: nothing in this advisory is compacted, removed, or applied.
+ * All token figures are estimated (chars/4), not billing-confirmed, not realized savings.
+ */
+export interface SkillInjectionAdvisorySummary {
+    report_only: true;
+    skills: {
+        skill_name: string;
+        redundant_byte_identical_copies: number;
+        estimated_tokens: number;
+        redundant_copy_message_ids: string[];
+    }[];
+    total_redundant_byte_identical_copies: number;
+    total_addressable_estimated_tokens: number;
+    /** Price-table est cost equivalent of the addressable token volume (advisory, not realized). */
+    estimated_cost_equivalent_usd: number;
+    first_copy_count: number;
+    estimate_label: string;
+    recommendation: string;
+}
+/**
+ * Value-proof classification of the report's token/cost deltas against the four
+ * ROADMAP "MVP value path" claims (strongest last, never conflated). This object
+ * does NOT introduce new numbers — it classifies the already-computed
+ * tokens_saved / cost deltas into their honest tier and states plainly which
+ * stronger claims are NOT made by this artifact.
+ *
+ * - Tier 1 (trace-token reduction): the local-estimate token reduction. CLAIMED.
+ * - Tier 2 (estimated provider cost reduction): price-table estimate from the token
+ *   delta, NOT billing-confirmed. CLAIMED as an estimate only.
+ * - Tier 3 (billing-confirmed savings): a measured provider usage/billing delta.
+ *   NOT claimed here — no provider usage/billing delta is measured.
+ * - Tier 4 (fixed-plan workflow-extension value): more work under a fixed-price cap.
+ *   NOT quantified here.
+ */
+export interface ValueProof {
+    /** Tier 1 — fewer tokens in the persisted/compacted trace (local estimate). */
+    trace_token_reduction: {
+        claim: "trace-token reduction (estimated, local heuristic)";
+        tier: 1;
+        estimated: true;
+        tokens_saved: number;
+        percent_reduction: number;
+    };
+    /** Tier 2 — price-table estimate from the token delta, NOT billing-confirmed. */
+    estimated_provider_cost_reduction: {
+        claim: "estimated provider cost reduction (price-table estimate, NOT billing-confirmed)";
+        tier: 2;
+        estimated: true;
+        billing_confirmed: false;
+        saving_per_run_usd: number;
+    };
+    /** Tier 3 — measured provider usage/billing delta. NOT claimed here. */
+    billing_confirmed_savings: {
+        claim: "billing-confirmed savings (measured provider usage/billing delta)";
+        tier: 3;
+        claimed: false;
+        billing_confirmed: false;
+        note: string;
+    };
+    /** Tier 4 — more useful work under a fixed-price cap. NOT quantified here. */
+    fixed_plan_workflow_extension_value: {
+        claim: "fixed-plan workflow-extension value";
+        tier: 4;
+        quantified: false;
+        note: string;
+    };
+}
+/**
+ * Concise "where spend came from" summary surfaced in the compaction report
+ * (additive, optional, backward-compatible). Built by REUSING the spend-attribution
+ * computation (buildSpendSummaryFromTrace) — it does not reimplement attribution.
+ *
+ * All figures are LOCAL ESTIMATES: tokens are a chars/4 trace-token heuristic and
+ * costs are price-table estimates. These describe WHERE estimated context spend
+ * comes from. They are NOT billing-confirmed and NOT realized/applied savings.
+ */
+export interface SpendBySourceSummary {
+    estimated: true;
+    billing_confirmed: false;
+    /** Human label clarifying the estimate basis. */
+    estimate_label: string;
+    /** Top role/category buckets by estimated tokens. */
+    top_roles: {
+        name: string;
+        estimated_tokens: number;
+        estimated_cost_usd: number;
+    }[];
+    /** Top repeated tool-output buckets by estimated tokens. */
+    top_tool_outputs: {
+        tool_name: string;
+        estimated_tokens: number;
+        repeated_count: number;
+        estimated_cost_usd: number;
+    }[];
+    /** Top policy candidate by estimated tokens saved, if any (null when none). */
+    top_policy_candidate: {
+        policy_name: string;
+        estimated_tokens_saved: number;
+        estimated_saving_per_run_usd: number;
+    } | null;
+}
+export interface CompactionReport {
+    run_id: string;
+    trace_title: string;
+    model: string;
+    original_input_tokens: number;
+    compacted_input_tokens: number;
+    tokens_saved: number;
+    percent_reduction: number;
+    savings_scope?: string;
+    cost_before_per_run: number;
+    cost_after_per_run: number;
+    saving_per_run: number;
+    policy_name: string;
+    waste_pattern: WasteFinding["category"] | null;
+    source_message_id: string | null;
+    repeated_count: number;
+    compacted_message_ids: string[];
+    artifact_version: string;
+    created_at: string;
+    generated_at: string;
+    approval_readiness_status: ApprovalReadinessStatus;
+    approval_readiness_reason: string;
+    /**
+     * Value-proof tier classification of the token/cost deltas above (additive,
+     * backward-compatible). Classifies existing numbers only; makes no new claim.
+     */
+    value_proof?: ValueProof;
+    /**
+     * Report-only advisory section (repeated_skill_injection). Distinct from the actual
+     * compaction summary above. Detection/reporting only — nothing here is compacted.
+     */
+    skill_injection_advisory?: SkillInjectionAdvisorySummary;
+    /**
+     * Concise "where spend came from" summary (additive, optional, backward-compatible).
+     * Reuses the spend-attribution computation. Figures are local estimates (chars/4 /
+     * price-table), NOT billing-confirmed and NOT realized savings.
+     */
+    spend_by_source?: SpendBySourceSummary;
+}
+export interface CompactionPolicy {
+    policy_name: string;
+    policy_version: string;
+    trigger: string;
+    condition: string;
+    action: string;
+    safety_guarantees: string[];
+    expected_savings: string;
+    risk_notes: string[];
+}

package/dist/core/types.js

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

package/dist/core/usage-metadata.d.ts

@@ -0,0 +1,51 @@
+import type { AgentTrace } from "./types.js";
+export type CostSource = "provider_reported" | "price_table_estimate" | "local_estimate" | "missing" | "unknown";
+export type CostConfidence = "high" | "medium" | "low" | "unknown";
+export interface UsageMetadata {
+    input_tokens?: number;
+    output_tokens?: number;
+    total_tokens?: number;
+    /** Cache read tokens (priced at ~10% of standard input rate — estimated, not billing-confirmed). */
+    cache_read_input_tokens?: number;
+    /** Cache creation tokens (priced at ~125% of standard input rate — estimated, not billing-confirmed). */
+    cache_creation_input_tokens?: number;
+    provider_reported_tokens: boolean;
+    estimated_tokens: boolean;
+    synthetic_demo?: boolean;
+    cost_source: CostSource;
+    cost_confidence: CostConfidence;
+    currency?: string;
+    model?: string;
+    provider?: string;
+    pricing_assumption?: string;
+    limitations: string[];
+}
+interface UsageMetadataInput {
+    inputTokens?: number;
+    outputTokens?: number;
+    totalTokens?: number;
+    /** Cache read tokens from the provider API response. Priced at reduced rate in cost estimates. */
+    cacheReadInputTokens?: number;
+    /** Cache creation tokens from the provider API response. Priced at elevated rate in cost estimates. */
+    cacheCreationInputTokens?: number;
+    providerReportedTokens: boolean;
+    estimatedTokens: boolean;
+    syntheticDemo?: boolean;
+    providerReportedCost?: boolean;
+    currency?: string;
+    model?: string;
+    provider?: string;
+    pricingAssumption?: string;
+    limitations?: string[];
+}
+export declare function createUsageMetadata(input: UsageMetadataInput): UsageMetadata;
+export declare function missingUsageMetadata(input?: {
+    model?: string;
+    provider?: string;
+    limitations?: string[];
+}): UsageMetadata;
+export declare function localEstimateUsageMetadata(trace: AgentTrace, limitations?: string[]): UsageMetadata;
+export declare function priceTableEstimateForUsage(metadata: UsageMetadata): number | null;
+export declare function describeTokenMetadata(metadata: UsageMetadata): string[];
+export declare function describeCostMetadata(metadata: UsageMetadata): string[];
+export {};

package/dist/core/usage-metadata.js

@@ -0,0 +1,122 @@
+import { calculateCost } from "./cost-calculator.js";
+import { hasModelPricing } from "./pricing.js";
+import { estimateTraceTokens } from "./token-estimator.js";
+function cleanNumber(value) {
+    return typeof value === "number" && Number.isFinite(value) && value >= 0 ? value : undefined;
+}
+function costSourceFor(input) {
+    if (input.providerReportedCost)
+        return "provider_reported";
+    if (input.providerReportedTokens && input.model && hasModelPricing(input.model))
+        return "price_table_estimate";
+    if (input.estimatedTokens)
+        return "local_estimate";
+    if (!input.providerReportedTokens && !input.estimatedTokens)
+        return "missing";
+    return "unknown";
+}
+function costConfidenceFor(source, providerReportedTokens) {
+    if (source === "provider_reported")
+        return "high";
+    if (source === "price_table_estimate")
+        return providerReportedTokens ? "medium" : "low";
+    if (source === "local_estimate")
+        return "low";
+    return "unknown";
+}
+export function createUsageMetadata(input) {
+    const inputTokens = cleanNumber(input.inputTokens);
+    const outputTokens = cleanNumber(input.outputTokens);
+    const cacheReadInputTokens = cleanNumber(input.cacheReadInputTokens);
+    const cacheCreationInputTokens = cleanNumber(input.cacheCreationInputTokens);
+    const totalTokens = cleanNumber(input.totalTokens) ?? (inputTokens !== undefined || outputTokens !== undefined ? (inputTokens ?? 0) + (outputTokens ?? 0) : undefined);
+    const costSource = costSourceFor(input);
+    const pricingAssumption = input.pricingAssumption ??
+        (costSource === "price_table_estimate" && input.model ? `price table estimate for ${input.model}` : costSource === "local_estimate" && input.model ? `local token estimate priced with fallback table for ${input.model}` : undefined);
+    return {
+        ...(inputTokens !== undefined ? { input_tokens: inputTokens } : {}),
+        ...(outputTokens !== undefined ? { output_tokens: outputTokens } : {}),
+        ...(totalTokens !== undefined ? { total_tokens: totalTokens } : {}),
+        ...(cacheReadInputTokens !== undefined && cacheReadInputTokens > 0 ? { cache_read_input_tokens: cacheReadInputTokens } : {}),
+        ...(cacheCreationInputTokens !== undefined && cacheCreationInputTokens > 0 ? { cache_creation_input_tokens: cacheCreationInputTokens } : {}),
+        provider_reported_tokens: input.providerReportedTokens,
+        estimated_tokens: input.estimatedTokens,
+        ...(input.syntheticDemo ? { synthetic_demo: true } : {}),
+        cost_source: costSource,
+        cost_confidence: costConfidenceFor(costSource, input.providerReportedTokens),
+        ...(input.currency ? { currency: input.currency } : {}),
+        ...(input.model ? { model: input.model } : {}),
+        ...(input.provider ? { provider: input.provider } : {}),
+        ...(pricingAssumption ? { pricing_assumption: pricingAssumption } : {}),
+        limitations: [...(input.limitations ?? [])]
+    };
+}
+export function missingUsageMetadata(input = {}) {
+    return createUsageMetadata({
+        providerReportedTokens: false,
+        estimatedTokens: false,
+        model: input.model,
+        provider: input.provider,
+        limitations: input.limitations ?? ["Token metadata is missing/unknown and was not invented.", "Cost metadata is missing/unknown."]
+    });
+}
+export function localEstimateUsageMetadata(trace, limitations = []) {
+    const estimate = estimateTraceTokens(trace);
+    return createUsageMetadata({
+        inputTokens: estimate.inputTokens,
+        outputTokens: estimate.outputTokens,
+        totalTokens: estimate.totalTokens,
+        providerReportedTokens: false,
+        estimatedTokens: true,
+        model: trace.model,
+        pricingAssumption: `local token estimate priced with fallback table for ${trace.model}`,
+        limitations: ["Tokens are estimated locally from trace text; provider billing accuracy is not implied.", ...limitations]
+    });
+}
+export function priceTableEstimateForUsage(metadata) {
+    if (metadata.input_tokens === undefined && metadata.output_tokens === undefined)
+        return null;
+    if (!metadata.model)
+        return null;
+    const cost = calculateCost(metadata.model, {
+        inputTokens: metadata.input_tokens ?? 0,
+        outputTokens: metadata.output_tokens ?? 0,
+        totalTokens: metadata.total_tokens ?? (metadata.input_tokens ?? 0) + (metadata.output_tokens ?? 0)
+    }, {
+        cacheReadTokens: metadata.cache_read_input_tokens,
+        cacheCreationTokens: metadata.cache_creation_input_tokens
+    });
+    return Number(cost.totalCostUsd.toFixed(6));
+}
+export function describeTokenMetadata(metadata) {
+    if (metadata.provider_reported_tokens) {
+        const prefix = metadata.synthetic_demo ? "synthetic-demo provider-reported" : "provider-reported";
+        const label = metadata.synthetic_demo ? " (not production billing data)" : "";
+        return [
+            `${prefix} input tokens: ${metadata.input_tokens ?? "unknown"}${label}`,
+            `${prefix} output tokens: ${metadata.output_tokens ?? "unknown"}${label}`,
+            `${prefix} total tokens: ${metadata.total_tokens ?? "unknown"}${label}`
+        ];
+    }
+    if (metadata.estimated_tokens) {
+        return [
+            `estimated input tokens: ${metadata.input_tokens ?? "unknown"}`,
+            `estimated output tokens: ${metadata.output_tokens ?? "unknown"}`,
+            `estimated total tokens: ${metadata.total_tokens ?? "unknown"}`
+        ];
+    }
+    return ["Token metadata: missing / unknown"];
+}
+export function describeCostMetadata(metadata) {
+    const missingCostLine = metadata.cost_source === "missing" || metadata.cost_source === "unknown" ? "Cost metadata: missing / unknown" : null;
+    const syntheticLine = metadata.synthetic_demo ? "usage metadata label: synthetic-demo (not production billing data)" : null;
+    return [
+        ...(syntheticLine ? [syntheticLine] : []),
+        ...(missingCostLine ? [missingCostLine] : []),
+        `cost source: ${metadata.cost_source}`,
+        `cost confidence: ${metadata.cost_confidence}`,
+        ...(metadata.currency ? [`currency: ${metadata.currency}`] : []),
+        ...(metadata.pricing_assumption ? [`pricing assumption: ${metadata.pricing_assumption}`] : [])
+    ];
+}
+//# sourceMappingURL=usage-metadata.js.map

package/dist/core/waste-detector.d.ts

@@ -0,0 +1,8 @@
+import type { AgentTrace, WasteFinding } from "./types.js";
+export { detectSkillInjectionRepetition, buildSkillInjectionAdvisory, isSkillInjection, parseSkillName, type SkillInjectionFinding, type SkillInjectionAdvisory, type SkillInjectionSkillAttribution } from "./skill-injection-detector.js";
+export interface WasteDetectionThresholds {
+    minDuplicateTokens?: number;
+    minDuplicateCharacters?: number;
+}
+export declare function detectWaste(trace: AgentTrace, thresholds?: WasteDetectionThresholds): WasteFinding[];
+export declare function getCompactedMessageIds(findings: WasteFinding[]): Set<string>;

package/dist/core/waste-detector.js

@@ -0,0 +1,58 @@
+import { estimateTextTokens } from "./token-estimator.js";
+// Report-only skill-injection repetition detector. Re-exported here so callers have a
+// single waste-detection entry point, but it builds its OWN dedup map (separate from the
+// tool-output map below) and its `repeated_skill_injection` findings are intentionally
+// NOT compacted — see getCompactedMessageIds.
+export { detectSkillInjectionRepetition, buildSkillInjectionAdvisory, isSkillInjection, parseSkillName } from "./skill-injection-detector.js";
+function normalizeContent(content) {
+    return content.trim().replace(/\s+/g, " ");
+}
+function describeTool(message) {
+    return message.toolName ? `${message.toolName} tool output` : "tool output";
+}
+export function detectWaste(trace, thresholds = {}) {
+    const findings = [];
+    const firstToolOutputBySignature = new Map();
+    for (const message of trace.messages) {
+        if (message.role !== "tool") {
+            continue;
+        }
+        const signature = `${message.toolName ?? "tool"}:${normalizeContent(message.content)}`;
+        const originalMessage = firstToolOutputBySignature.get(signature);
+        if (originalMessage) {
+            const estimatedTokens = estimateTextTokens(message.content);
+            if (estimatedTokens < (thresholds.minDuplicateTokens ?? 0) ||
+                message.content.length < (thresholds.minDuplicateCharacters ?? 0)) {
+                continue;
+            }
+            findings.push({
+                category: "repeated_tool_output",
+                messageIds: [originalMessage.id, message.id],
+                summary: `Repeated ${describeTool(message)}. Keep ${originalMessage.id} and compact ${message.id}.`,
+                estimatedTokens
+            });
+            continue;
+        }
+        firstToolOutputBySignature.set(signature, message);
+    }
+    return findings;
+}
+export function getCompactedMessageIds(findings) {
+    const compactedIds = new Set();
+    for (const finding of findings) {
+        // ONLY "repeated_tool_output" findings are ever compacted. This is the report-only
+        // safety boundary for "repeated_skill_injection": such findings are detected and
+        // reported but, by this guard, never enter the compacted message-id set and never
+        // alter the compacted trace. policy-middleware also independently filters to
+        // "repeated_tool_output" (findRepeatCandidates), so skill injections are never applied.
+        if (finding.category !== "repeated_tool_output") {
+            continue;
+        }
+        const [, ...duplicateIds] = finding.messageIds;
+        for (const duplicateId of duplicateIds) {
+            compactedIds.add(duplicateId);
+        }
+    }
+    return compactedIds;
+}
+//# sourceMappingURL=waste-detector.js.map