@psiclawops/hypermem 0.6.2 → 0.8.0

package/dist/contradiction-detector.js

@@ -0,0 +1,362 @@
+/**
+ * Contradiction Detector — heuristic-based contradiction detection for the fact store.
+ *
+ * Detects when a newly ingested fact contradicts existing active facts using
+ * vector similarity (when available) and FTS candidate retrieval, scored by
+ * pattern-based heuristics (negation, numeric conflict, state conflict, temporal).
+ *
+ * No LLM calls — v1 is purely heuristic. LLM-enhanced scoring is a future item.
+ */
+// ─── Internal Constants ──────────────────────────────────────────
+const DEFAULT_CONFIG = {
+    minSimilarity: 0.6,
+    autoResolveThreshold: 0.85,
+    maxCandidates: 10,
+    autoResolve: true,
+};
+/** Words whose presence/absence flips meaning. */
+const NEGATION_WORDS = new Set([
+    'not', 'no', 'never', 'none', 'neither', 'nor', 'cannot', "can't",
+    "don't", "doesn't", "didn't", "won't", "wouldn't", "shouldn't",
+    "isn't", "aren't", "wasn't", "weren't", "hasn't", "haven't", "hadn't",
+]);
+/** Antonym pairs where one in text A and the other in text B signals conflict. */
+const STATE_ANTONYMS = [
+    ['enabled', 'disabled'],
+    ['active', 'inactive'],
+    ['active', 'deprecated'],
+    ['running', 'stopped'],
+    ['running', 'crashed'],
+    ['up', 'down'],
+    ['true', 'false'],
+    ['yes', 'no'],
+    ['on', 'off'],
+    ['open', 'closed'],
+    ['allowed', 'denied'],
+    ['allowed', 'blocked'],
+    ['available', 'unavailable'],
+    ['connected', 'disconnected'],
+    ['online', 'offline'],
+    ['present', 'absent'],
+    ['healthy', 'unhealthy'],
+    ['valid', 'invalid'],
+    ['complete', 'incomplete'],
+    ['success', 'failure'],
+];
+// ─── Helpers ─────────────────────────────────────────────────────
+/** Normalize text for comparison: lowercase, collapse whitespace. */
+function normalize(text) {
+    return text.toLowerCase().replace(/\s+/g, ' ').trim();
+}
+/** Tokenize into word-boundary tokens. */
+function tokenize(text) {
+    return normalize(text).split(/[\s,;:()[\]{}]+/).filter(Boolean);
+}
+/** Convert VectorStore distance (lower = closer) to a 0-1 similarity score. */
+function distanceToSimilarity(distance) {
+    // sqlite-vec uses L2 distance by default. Convert to 0-1 similarity.
+    // distance=0 => similarity=1, distance grows => similarity decays toward 0.
+    return 1 / (1 + distance);
+}
+/**
+ * Build a safe FTS query from content. Takes the first several meaningful words
+ * to avoid FTS syntax errors from special characters.
+ */
+function buildFtsQuery(content) {
+    const words = tokenize(content)
+        .filter(w => w.length > 2 && !/^\d+$/.test(w))
+        .slice(0, 6);
+    if (words.length === 0)
+        return '';
+    // OR-join for broad recall
+    return words.join(' OR ');
+}
+/**
+ * Extract numbers and their rough context (preceding word) from text.
+ * Returns pairs of [contextWord, number].
+ */
+function extractNumbers(text) {
+    const results = [];
+    const tokens = tokenize(text);
+    for (let i = 0; i < tokens.length; i++) {
+        const num = parseFloat(tokens[i]);
+        if (!isNaN(num) && isFinite(num)) {
+            const context = i > 0 ? tokens[i - 1] : '';
+            results.push({ context, value: num });
+        }
+    }
+    return results;
+}
+/**
+ * Check if one text contains a negation of the other.
+ * Returns true if one has a negation word in a position where the other doesn't
+ * (or vice versa), given high token overlap.
+ */
+function detectNegation(tokensA, tokensB) {
+    const negA = tokensA.filter(t => NEGATION_WORDS.has(t));
+    const negB = tokensB.filter(t => NEGATION_WORDS.has(t));
+    // One has negation words, the other doesn't (or different count)
+    if (negA.length !== negB.length) {
+        // Check that the non-negation content overlaps substantially
+        const contentA = new Set(tokensA.filter(t => !NEGATION_WORDS.has(t)));
+        const contentB = new Set(tokensB.filter(t => !NEGATION_WORDS.has(t)));
+        const intersection = [...contentA].filter(t => contentB.has(t));
+        const smaller = Math.min(contentA.size, contentB.size);
+        // Need at least 40% content overlap to consider it a negation of the same claim
+        return smaller > 0 && intersection.length / smaller >= 0.4;
+    }
+    return false;
+}
+/**
+ * Check for antonym state pairs between two token sets.
+ * Returns the matching antonym pair if found, or null.
+ */
+function detectStateConflict(tokensA, tokensB) {
+    const setA = new Set(tokensA);
+    const setB = new Set(tokensB);
+    for (const [word1, word2] of STATE_ANTONYMS) {
+        if ((setA.has(word1) && setB.has(word2)) || (setA.has(word2) && setB.has(word1))) {
+            // Verify there's enough shared context (not just random words)
+            const contentA = new Set(tokensA.filter(t => t !== word1 && t !== word2));
+            const contentB = new Set(tokensB.filter(t => t !== word1 && t !== word2));
+            const intersection = [...contentA].filter(t => contentB.has(t));
+            const smaller = Math.min(contentA.size, contentB.size);
+            if (smaller > 0 && intersection.length / smaller >= 0.3) {
+                return setA.has(word1) ? [word1, word2] : [word2, word1];
+            }
+        }
+    }
+    return null;
+}
+/**
+ * Check for numeric conflicts: same contextual subject, different numbers.
+ */
+function detectNumericConflict(textA, textB) {
+    const numsA = extractNumbers(textA);
+    const numsB = extractNumbers(textB);
+    for (const a of numsA) {
+        for (const b of numsB) {
+            // Same context word, different value
+            if (a.context && a.context === b.context && a.value !== b.value) {
+                return { contextWord: a.context, valueA: a.value, valueB: b.value };
+            }
+        }
+    }
+    return null;
+}
+// ─── ContradictionDetector ───────────────────────────────────────
+export class ContradictionDetector {
+    factStore;
+    vectorStore;
+    config;
+    constructor(factStore, vectorStore, config) {
+        this.factStore = factStore;
+        this.vectorStore = vectorStore;
+        this.config = { ...DEFAULT_CONFIG, ...config };
+    }
+    /**
+     * On fact ingest, check if the new fact contradicts existing active facts.
+     * Uses vector similarity (when available) + FTS to find candidates, then
+     * scores each candidate with heuristic contradiction checks.
+     */
+    async detectOnIngest(agentId, newFact) {
+        const candidates = await this.findCandidates(agentId, newFact);
+        const contradictions = [];
+        for (const candidate of candidates) {
+            const scored = this.scoreContradiction(newFact.content, candidate);
+            if (scored) {
+                contradictions.push(scored);
+            }
+        }
+        // Sort by contradiction score descending
+        contradictions.sort((a, b) => b.contradictionScore - a.contradictionScore);
+        const result = {
+            contradictions,
+            autoResolved: false,
+            resolvedCount: 0,
+        };
+        return result;
+    }
+    /**
+     * Resolve a detected contradiction between an existing fact and a new fact.
+     */
+    resolveContradiction(oldFactId, newFactId, resolution) {
+        switch (resolution) {
+            case 'supersede':
+                this.factStore.markSuperseded(oldFactId, newFactId);
+                break;
+            case 'keep-both':
+                // No-op: both facts remain active
+                break;
+            case 'reject-new':
+                this.factStore.invalidateFact(newFactId);
+                break;
+        }
+    }
+    /**
+     * Auto-resolve high-confidence contradictions: newer supersedes older.
+     * Only resolves candidates above the autoResolveThreshold.
+     *
+     * @param agentId - The agent whose facts are being resolved (for audit trail)
+     * @param candidates - Scored contradiction candidates from detectOnIngest
+     * @returns Count of auto-resolved contradictions
+     */
+    async autoResolve(_agentId, candidates) {
+        if (!this.config.autoResolve)
+            return 0;
+        let resolved = 0;
+        for (const candidate of candidates) {
+            if (candidate.contradictionScore >= this.config.autoResolveThreshold) {
+                // The existing fact is older; the new fact (which triggered detection)
+                // is assumed to be the more recent truth. We mark the existing as superseded.
+                // Note: the caller must supply the newFactId when wiring this into ingest.
+                // For now, we invalidate the old fact since we don't have the new fact's id here.
+                this.factStore.invalidateFact(candidate.existingFactId);
+                resolved++;
+            }
+        }
+        return resolved;
+    }
+    // ─── Private Methods ────────────────────────────────────────────
+    /**
+     * Find candidate facts that might contradict the new fact.
+     * Uses vector search (if available) and FTS, deduplicates, and returns
+     * up to maxCandidates results above minSimilarity.
+     */
+    async findCandidates(agentId, newFact) {
+        const seen = new Set();
+        const candidates = [];
+        const { maxCandidates, minSimilarity } = this.config;
+        // Path 1: Vector similarity search (if VectorStore is available)
+        if (this.vectorStore) {
+            try {
+                const vectorResults = await this.vectorStore.search(newFact.content, {
+                    tables: ['facts'],
+                    limit: maxCandidates * 2, // over-fetch to allow for filtering
+                });
+                for (const vr of vectorResults) {
+                    const similarity = distanceToSimilarity(vr.distance);
+                    if (similarity < minSimilarity)
+                        continue;
+                    if (seen.has(vr.sourceId))
+                        continue;
+                    seen.add(vr.sourceId);
+                    // Retrieve the full fact row for metadata checks
+                    const facts = this.factStore.searchFacts(vr.content.slice(0, 30), {
+                        agentId,
+                        limit: 1,
+                    });
+                    const fact = facts.find(f => f.id === vr.sourceId);
+                    if (fact && !fact.supersededBy && !fact.invalidAt) {
+                        candidates.push({ fact, similarity });
+                    }
+                }
+            }
+            catch {
+                // Vector search failed (embedding model unavailable, etc.)
+                // Fall through to FTS-only path
+            }
+        }
+        // Path 2: FTS search (always available, fills gaps)
+        if (candidates.length < maxCandidates) {
+            const ftsQuery = buildFtsQuery(newFact.content);
+            if (ftsQuery) {
+                try {
+                    const ftsResults = this.factStore.searchFacts(ftsQuery, {
+                        agentId,
+                        domain: newFact.domain,
+                        limit: maxCandidates * 2,
+                    });
+                    for (const fact of ftsResults) {
+                        if (seen.has(fact.id))
+                            continue;
+                        if (fact.supersededBy || fact.invalidAt)
+                            continue;
+                        seen.add(fact.id);
+                        // Compute a rough token-overlap similarity for FTS results
+                        const similarity = this.tokenOverlapSimilarity(newFact.content, fact.content);
+                        if (similarity >= minSimilarity) {
+                            candidates.push({ fact, similarity });
+                        }
+                    }
+                }
+                catch {
+                    // FTS query failed (malformed query, etc.)
+                }
+            }
+        }
+        // Sort by similarity descending, trim to maxCandidates
+        candidates.sort((a, b) => b.similarity - a.similarity);
+        return candidates.slice(0, maxCandidates);
+    }
+    /**
+     * Score a candidate fact against the new fact content for contradiction.
+     * Returns a ContradictionCandidate if any heuristic fires, null otherwise.
+     */
+    scoreContradiction(newContent, candidate) {
+        const existingContent = candidate.fact.content;
+        const tokensNew = tokenize(newContent);
+        const tokensExisting = tokenize(existingContent);
+        let bestScore = 0;
+        let bestReason = '';
+        // Heuristic 1: Negation detection (score: 0.9)
+        if (detectNegation(tokensNew, tokensExisting)) {
+            bestScore = 0.9;
+            bestReason = 'Negation detected: one fact negates the other';
+        }
+        // Heuristic 2: State conflict via antonym pairs (score: 0.85)
+        const stateConflict = detectStateConflict(tokensNew, tokensExisting);
+        if (stateConflict && stateConflict.length === 2) {
+            const score = 0.85;
+            if (score > bestScore) {
+                bestScore = score;
+                bestReason = `State conflict: "${stateConflict[0]}" vs "${stateConflict[1]}"`;
+            }
+        }
+        // Heuristic 3: Numeric conflict (score: 0.8)
+        const numConflict = detectNumericConflict(newContent, existingContent);
+        if (numConflict) {
+            const score = 0.8;
+            if (score > bestScore) {
+                bestScore = score;
+                bestReason = `Numeric conflict on "${numConflict.contextWord}": ${numConflict.valueA} vs ${numConflict.valueB}`;
+            }
+        }
+        // Heuristic 4: Temporal supersede — high similarity, different conclusion (score: 0.7)
+        // If similarity is very high (>0.8) but content isn't identical, it's likely a revised version
+        if (bestScore === 0 && candidate.similarity > 0.8) {
+            const contentDiffers = normalize(newContent) !== normalize(existingContent);
+            if (contentDiffers) {
+                bestScore = 0.7;
+                bestReason = 'Temporal supersede: high similarity with different content (likely revised)';
+            }
+        }
+        if (bestScore === 0)
+            return null;
+        return {
+            existingFactId: candidate.fact.id,
+            existingContent,
+            similarityScore: candidate.similarity,
+            contradictionScore: bestScore,
+            reason: bestReason,
+        };
+    }
+    /**
+     * Compute Jaccard-like token overlap between two texts.
+     * Returns 0-1 where 1 means identical token sets.
+     */
+    tokenOverlapSimilarity(textA, textB) {
+        const setA = new Set(tokenize(textA));
+        const setB = new Set(tokenize(textB));
+        if (setA.size === 0 || setB.size === 0)
+            return 0;
+        let intersection = 0;
+        for (const token of setA) {
+            if (setB.has(token))
+                intersection++;
+        }
+        const union = new Set([...setA, ...setB]).size;
+        return union > 0 ? intersection / union : 0;
+    }
+}
+//# sourceMappingURL=contradiction-detector.js.map

package/dist/contradiction-resolution-policy.d.ts

@@ -0,0 +1,21 @@
+/**
+ * hypermem Contradiction Resolution Policy
+ *
+ * Defines thresholds and flags that control how the background indexer acts
+ * on detected contradictions during fact ingest.
+ *
+ * Tiers (by contradictionScore):
+ *   >= autoSupersedeThreshold  → mark old fact superseded, remove stale vector
+ *   >= autoInvalidateThreshold → mark old fact invalid (no supersede linkage)
+ *   below autoInvalidateThreshold → log-only (pending review)
+ */
+export interface ContradictionResolutionPolicy {
+    /** Score threshold at or above which the old fact is auto-superseded by the new one. Default: 0.80 */
+    autoSupersedeThreshold: number;
+    /** Score threshold at or above which the old fact is auto-invalidated. Default: 0.60 */
+    autoInvalidateThreshold: number;
+    /** When true, always write an audit row regardless of tier. Default: true */
+    alwaysAudit: boolean;
+}
+export declare const DEFAULT_CONTRADICTION_POLICY: ContradictionResolutionPolicy;
+//# sourceMappingURL=contradiction-resolution-policy.d.ts.map

package/dist/contradiction-resolution-policy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"contradiction-resolution-policy.d.ts","sourceRoot":"","sources":["../src/contradiction-resolution-policy.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,MAAM,WAAW,6BAA6B;IAC5C,sGAAsG;IACtG,sBAAsB,EAAE,MAAM,CAAC;IAC/B,wFAAwF;IACxF,uBAAuB,EAAE,MAAM,CAAC;IAChC,6EAA6E;IAC7E,WAAW,EAAE,OAAO,CAAC;CACtB;AAED,eAAO,MAAM,4BAA4B,EAAE,6BAI1C,CAAC"}

package/dist/contradiction-resolution-policy.js

@@ -0,0 +1,17 @@
+/**
+ * hypermem Contradiction Resolution Policy
+ *
+ * Defines thresholds and flags that control how the background indexer acts
+ * on detected contradictions during fact ingest.
+ *
+ * Tiers (by contradictionScore):
+ *   >= autoSupersedeThreshold  → mark old fact superseded, remove stale vector
+ *   >= autoInvalidateThreshold → mark old fact invalid (no supersede linkage)
+ *   below autoInvalidateThreshold → log-only (pending review)
+ */
+export const DEFAULT_CONTRADICTION_POLICY = {
+    autoSupersedeThreshold: 0.80,
+    autoInvalidateThreshold: 0.60,
+    alwaysAudit: true,
+};
+//# sourceMappingURL=contradiction-resolution-policy.js.map

package/dist/cross-agent.d.ts

@@ -27,7 +27,7 @@ export interface OrgRegistry {
  * Default fleet org structure.
  *
  * ── EXAMPLE DATA ──────────────────────────────────────────────────────────
- * The agent names below (agent1, agent2, director1, etc.) are PLACEHOLDERS.
+ * The agent names below (alice, bob, director1, etc.) are PLACEHOLDERS.
  * Replace them with your own agent IDs to match your fleet configuration.
  *
  * Single-agent installs: you don't need to edit this. Your agent ID is

package/dist/cross-agent.js

@@ -21,7 +21,7 @@ import { FleetStore } from './fleet-store.js';
  * Default fleet org structure.
  *
  * ── EXAMPLE DATA ──────────────────────────────────────────────────────────
- * The agent names below (agent1, agent2, director1, etc.) are PLACEHOLDERS.
+ * The agent names below (alice, bob, director1, etc.) are PLACEHOLDERS.
  * Replace them with your own agent IDs to match your fleet configuration.
  *
  * Single-agent installs: you don't need to edit this. Your agent ID is
@@ -34,27 +34,27 @@ import { FleetStore } from './fleet-store.js';
  */
 export function defaultOrgRegistry() {
     const agents = {
-        agent1: { agentId: 'agent1', tier: 'council' },
-        agent2: { agentId: 'agent2', tier: 'council' },
+        alice: { agentId: 'alice', tier: 'council' },
+        bob: { agentId: 'bob', tier: 'council' },
         agent4: { agentId: 'agent4', tier: 'council' },
-        agent3: { agentId: 'agent3', tier: 'council' },
-        agent6: { agentId: 'agent6', tier: 'council' },
-        agent5: { agentId: 'agent5', tier: 'council' },
-        director1: { agentId: 'director1', tier: 'director', org: 'agent1-org', councilLead: 'agent1' },
-        director2: { agentId: 'director2', tier: 'director', org: 'agent1-org', councilLead: 'agent1' },
-        director3: { agentId: 'director3', tier: 'director', org: 'agent1-org', councilLead: 'agent1' },
-        director4: { agentId: 'director4', tier: 'director', org: 'agent2-org', councilLead: 'agent2' },
-        director5: { agentId: 'director5', tier: 'director', org: 'agent2-org', councilLead: 'agent2' },
-        director6: { agentId: 'director6', tier: 'director', org: 'agent2-org', councilLead: 'agent2' },
-        director7: { agentId: 'director7', tier: 'director', org: 'agent3-org', councilLead: 'agent3' },
-        director8: { agentId: 'director8', tier: 'director', org: 'agent3-org', councilLead: 'agent3' },
+        dave: { agentId: 'dave', tier: 'council' },
+        carol: { agentId: 'carol', tier: 'council' },
+        oscar: { agentId: 'oscar', tier: 'council' },
+        director1: { agentId: 'director1', tier: 'director', org: 'alice-org', councilLead: 'alice' },
+        director2: { agentId: 'director2', tier: 'director', org: 'alice-org', councilLead: 'alice' },
+        director3: { agentId: 'director3', tier: 'director', org: 'alice-org', councilLead: 'alice' },
+        director4: { agentId: 'director4', tier: 'director', org: 'bob-org', councilLead: 'bob' },
+        director5: { agentId: 'director5', tier: 'director', org: 'bob-org', councilLead: 'bob' },
+        director6: { agentId: 'director6', tier: 'director', org: 'bob-org', councilLead: 'bob' },
+        director7: { agentId: 'director7', tier: 'director', org: 'dave-org', councilLead: 'dave' },
+        director8: { agentId: 'director8', tier: 'director', org: 'dave-org', councilLead: 'dave' },
         specialist1: { agentId: 'specialist1', tier: 'specialist' },
         specialist2: { agentId: 'specialist2', tier: 'specialist' },
     };
     const orgs = {
-        'agent1-org': ['agent1', 'director1', 'director2', 'director3'],
-        'agent2-org': ['agent2', 'director4', 'director5', 'director6'],
-        'agent3-org': ['agent3', 'director7', 'director8'],
+        'alice-org': ['alice', 'director1', 'director2', 'director3'],
+        'bob-org': ['bob', 'director4', 'director5', 'director6'],
+        'dave-org': ['dave', 'director7', 'director8'],
     };
     return { orgs, agents };
 }

package/dist/degradation.d.ts

@@ -0,0 +1,102 @@
+/**
+ * HyperMem Canonical Degradation Contracts, Phase C0.2
+ *
+ * Defines the typed surfaces, reason enum, and format builders for degraded
+ * prompt-visible outputs. These shapes stay in volatile context and should not
+ * cross the stable-prefix boundary.
+ */
+/**
+ * Closed set of reasons for any degradation decision.
+ * Use these values in telemetry and tests instead of ad-hoc strings.
+ */
+export type DegradationReason = 'gradient_t2_prose' | 'gradient_t3_stub' | 'eviction_oversize' | 'eviction_turn0_trim' | 'wave_guard_pressure_high' | 'wave_guard_pressure_elevated' | 'budget_cluster_drop' | 'artifact_oversize' | 'artifact_fetch_hint' | 'replay_cold_redis' | 'replay_stabilizing' | 'replay_exited' | 'pressure_mismatch' | 'unknown';
+/** All valid DegradationReason values as a readonly array. */
+export declare const DEGRADATION_REASONS: readonly ["gradient_t2_prose", "gradient_t3_stub", "eviction_oversize", "eviction_turn0_trim", "wave_guard_pressure_high", "wave_guard_pressure_elevated", "budget_cluster_drop", "artifact_oversize", "artifact_fetch_hint", "replay_cold_redis", "replay_stabilizing", "replay_exited", "pressure_mismatch", "unknown"];
+/** Field-length caps for canonical degraded strings. */
+export declare const DEGRADATION_LIMITS: {
+    readonly toolName: 64;
+    readonly toolId: 64;
+    readonly reason: 48;
+    readonly toolSummary: 120;
+    readonly toolArtifactId: 64;
+    readonly artifactId: 64;
+    readonly artifactPath: 160;
+    readonly artifactFetchHint: 80;
+    readonly replayState: 32;
+    readonly replaySummary: 120;
+};
+export declare function isDegradationReason(value: string): value is DegradationReason;
+/**
+ * Canonical shape for a degraded tool call/result pair.
+ *
+ * Prompt-visible format:
+ *   [tool:<name> id=<id> status=ejected reason=<reason> summary=<stub>]
+ *
+ * Optional artifact pointer (Phase 1 of tool_artifacts):
+ *   [tool:<name> id=<id> status=ejected reason=<reason> artifact=<artifactId> summary=<stub>]
+ *
+ * The `artifact=` field is backwards-compatible and optional. When present, it
+ * lets the compositor rehydrate the full tool result payload from the
+ * tool_artifacts table without needing to rewrite the transcript.
+ */
+export interface ToolChainStub {
+    name: string;
+    id: string;
+    status: 'ejected';
+    reason: DegradationReason;
+    summary: string;
+    /** Optional durable pointer into the tool_artifacts table. */
+    artifactId?: string;
+}
+export declare function formatToolChainStub(stub: ToolChainStub): string;
+export declare function parseToolChainStub(text: string): ToolChainStub | null;
+export declare function isToolChainStub(text: string): boolean;
+/**
+ * Canonical shape for a degraded oversized artifact replaced by a pointer.
+ *
+ * Prompt-visible format:
+ *   [artifact:<id> path=<path> size=<tokens> status=degraded fetch=<hint>]
+ */
+export interface ArtifactRef {
+    id: string;
+    path: string;
+    sizeTokens: number;
+    status: 'degraded';
+    reason: DegradationReason;
+    fetchHint: string;
+}
+export declare function formatArtifactRef(ref: ArtifactRef): string;
+export declare function parseArtifactRef(text: string): ArtifactRef | null;
+export declare function isArtifactRef(text: string): boolean;
+/**
+ * State of the replay recovery window.
+ */
+export type ReplayState = 'entering' | 'stabilizing' | 'exited';
+export declare function isReplayState(value: string): value is ReplayState;
+/**
+ * Canonical shape for a replay recovery mode marker.
+ *
+ * Prompt-visible format:
+ *   [replay state=<state> status=bounded reason=<reason> summary=<stub>]
+ */
+export interface ReplayMarker {
+    state: ReplayState;
+    status: 'bounded';
+    reason: DegradationReason;
+    summary: string;
+}
+export declare function formatReplayMarker(marker: ReplayMarker): string;
+export declare function parseReplayMarker(text: string): ReplayMarker | null;
+export declare function isReplayMarker(text: string): boolean;
+export declare function isDegradedContent(text: string): boolean;
+export interface DegradationEvent {
+    event: 'degradation';
+    ts: string;
+    agentId: string;
+    sessionKey: string;
+    degradationClass: 'tool_chain' | 'artifact' | 'replay';
+    reason: DegradationReason;
+    tokensSaved: number;
+    emittedText: string;
+}
+//# sourceMappingURL=degradation.d.ts.map

package/dist/degradation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"degradation.d.ts","sourceRoot":"","sources":["../src/degradation.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAIH;;;GAGG;AACH,MAAM,MAAM,iBAAiB,GACzB,mBAAmB,GACnB,kBAAkB,GAClB,mBAAmB,GACnB,qBAAqB,GACrB,0BAA0B,GAC1B,8BAA8B,GAC9B,qBAAqB,GACrB,mBAAmB,GACnB,qBAAqB,GACrB,mBAAmB,GACnB,oBAAoB,GACpB,eAAe,GACf,mBAAmB,GACnB,SAAS,CAAC;AAEd,8DAA8D;AAC9D,eAAO,MAAM,mBAAmB,2TAeiB,CAAC;AAElD,wDAAwD;AACxD,eAAO,MAAM,kBAAkB;;;;;;;;;;;CAWrB,CAAC;AAiBX,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,MAAM,GAAG,KAAK,IAAI,iBAAiB,CAE7E;AAID;;;;;;;;;;;;GAYG;AACH,MAAM,WAAW,aAAa;IAC5B,IAAI,EAAE,MAAM,CAAC;IACb,EAAE,EAAE,MAAM,CAAC;IACX,MAAM,EAAE,SAAS,CAAC;IAClB,MAAM,EAAE,iBAAiB,CAAC;IAC1B,OAAO,EAAE,MAAM,CAAC;IAChB,8DAA8D;IAC9D,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAKD,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,aAAa,GAAG,MAAM,CAS/D;AAED,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,MAAM,GAAG,aAAa,GAAG,IAAI,CAQrE;AAED,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAErD;AAID;;;;;GAKG;AACH,MAAM,WAAW,WAAW;IAC1B,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,UAAU,EAAE,MAAM,CAAC;IACnB,MAAM,EAAE,UAAU,CAAC;IACnB,MAAM,EAAE,iBAAiB,CAAC;IAC1B,SAAS,EAAE,MAAM,CAAC;CACnB;AAID,wBAAgB,iBAAiB,CAAC,GAAG,EAAE,WAAW,GAAG,MAAM,CAM1D;AAED,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,GAAG,WAAW,GAAG,IAAI,CAajE;AAED,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAEnD;AAID;;GAEG;AACH,MAAM,MAAM,WAAW,GAAG,UAAU,GAAG,aAAa,GAAG,QAAQ,CAAC;AAEhE,wBAAgB,aAAa,CAAC,KAAK,EAAE,MAAM,GAAG,KAAK,IAAI,WAAW,CAEjE;AAED;;;;;GAKG;AACH,MAAM,WAAW,YAAY;IAC3B,KAAK,EAAE,WAAW,CAAC;IACnB,MAAM,EAAE,SAAS,CAAC;IAClB,MAAM,EAAE,iBAAiB,CAAC;IAC1B,OAAO,EAAE,MAAM,CAAC;CACjB;AAID,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,YAAY,GAAG,MAAM,CAK/D;AAED,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,MAAM,GAAG,YAAY,GAAG,IAAI,CAWnE;AAED,wBAAgB,cAAc,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAEpD;AAID,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAEvD;AAID,MAAM,WAAW,gBAAgB;IAC/B,KAAK,EAAE,aAAa,CAAC;IACrB,EAAE,EAAE,MAAM,CAAC;IACX,OAAO,EAAE,MAAM,CAAC;IAChB,UAAU,EAAE,MAAM,CAAC;IACnB,gBAAgB,EAAE,YAAY,GAAG,UAAU,GAAG,QAAQ,CAAC;IACvD,MAAM,EAAE,iBAAiB,CAAC;IAC1B,WAAW,EAAE,MAAM,CAAC;IACpB,WAAW,EAAE,MAAM,CAAC;CACrB"}