dsh-continual-evolve 0.11.0 → 0.12.1

package/lib/memory-apply.js

@@ -1,202 +0,0 @@
-import { MEMORY_TYPE_KEY } from "./types.js";
-import { requestScopeApproval } from "./approval.js";
-import { fingerprintMemoryBatch, isDeclinedRepeat, loadDeclinedMemory, recordDeclinedMemory, } from "./declines.js";
-import { compactText } from "./render.js";
-import { buildConflictNotice, CONFLICT_WARN_SCORE, mostSimilarEntry } from "./promotion.js";
-import { EvolutionApplyPostCommitError } from "./service.js";
-/**
- * Render the authoritative persistent-scope diff shown to the human. Model
- * prose is retained only as an explicitly untrusted summary; actions, targets,
- * content previews, memory types, and conflict warnings come from code.
- */
-export function renderMemoryApprovalDetails(proposal, scope, state, maxChars = 6000) {
-    const edits = proposal.edits.filter((candidate) => candidate.targetScope === scope);
-    const details = edits.map((edit) => {
-        const before = edit.id ? state.entries.memory[edit.id] : undefined;
-        const title = edit.title ?? before?.title ?? "(existing title unchanged)";
-        const path = edit.path ?? before?.path ?? "(path unchanged)";
-        const content = edit.content ?? (edit.action === "update" ? "(content unchanged)" : "(no content field)");
-        const type = edit.metadata?.[MEMORY_TYPE_KEY] ?? before?.metadata[MEMORY_TYPE_KEY] ?? "untyped";
-        const candidates = Object.values(state.entries.memory).filter((entry) => entry.id !== edit.id);
-        const hit = edit.action === "create" || edit.action === "update"
-            ? mostSimilarEntry(candidates, edit.title ?? before?.title ?? "", edit.content ?? before?.content ?? "", CONFLICT_WARN_SCORE)
-            : undefined;
-        const conflict = hit ? `; conflict: ${compactText(buildConflictNotice(hit), 120)}` : "";
-        const targetId = edit.id === undefined ? "(new)" : JSON.stringify(edit.id);
-        return {
-            target: `- ${edit.action} ${scope}:${targetId} — ${compactText(title, 80)}`,
-            detail: `  path=${compactText(path, 60)}; memoryType=${String(type)}; content=${compactText(content, 100)}${conflict}`,
-        };
-    });
-    let titleLimit = 80;
-    let targets = details.map((detail) => detail.target.replace(/ — .*$/, ` — ${compactText(detail.target.split(" — ")[1] ?? "", titleLimit)}`));
-    let base = ["edits to approve:", ...targets].join("\n");
-    while (base.length > maxChars && titleLimit > 20) {
-        titleLimit = Math.floor(titleLimit / 2);
-        targets = details.map((detail) => `- ${detail.target.split(" — ")[0]} — ${compactText(detail.target.split(" — ")[1] ?? "", titleLimit)}`);
-        base = ["edits to approve:", ...targets].join("\n");
-    }
-    if (base.length > maxChars)
-        throw new Error(`memory approval diff exceeds ${maxChars} characters`);
-    const output = [base];
-    const summary = `model summary (untrusted): ${compactText(proposal.summary, 180)}`;
-    if ([...output, summary].join("\n").length <= maxChars)
-        output.push(summary);
-    for (const detail of details) {
-        const line = detail.detail;
-        if ([...output, line].join("\n").length <= maxChars)
-            output.push(line);
-    }
-    if ([...output, "  (additional previews omitted; every target is listed above)"].join("\n").length <= maxChars) {
-        output.push("  (additional previews omitted; every target is listed above)");
-    }
-    return output.join("\n");
-}
-function memoryScopeDecisionKey(cursor, scope, edits) {
-    return `${cursor}:${scope}:${JSON.stringify(edits.map(stripTargetScope))}`;
-}
-class MemoryApplyBatchError extends Error {
-    result;
-    scope;
-    storeId;
-    constructor(message, result, scope, storeId) {
-        super(message);
-        this.result = result;
-        this.scope = scope;
-        this.storeId = storeId;
-    }
-}
-/**
- * Apply one accepted proposal through the only mutation engine. All persistent
- * approvals are resolved before the first write, so an unavailable approval
- * boundary cannot leave a partially applied batch. Explicit rejection is a
- * no-op for that scope; service/question failures remain retryable errors.
- */
-export async function applyMemoryExtractionProposal(ctx, engine, proposal, options) {
-    const scopeOrder = ["local", "project", "global"];
-    const editsByScope = new Map();
-    for (const scope of scopeOrder) {
-        const edits = proposal.edits.filter((edit) => edit.targetScope === scope);
-        if (edits.length > 0)
-            editsByScope.set(scope, edits);
-    }
-    if (editsByScope.has("project") && !options.projectKey) {
-        throw new Error("memory agent cannot target project scope without a resolved project key");
-    }
-    const approvedScopes = new Set();
-    const declinedScopes = [];
-    for (const scope of ["project", "global"]) {
-        if (!editsByScope.has(scope))
-            continue;
-        if (!options.requireApproval) {
-            approvedScopes.add(scope);
-            continue;
-        }
-        const baseline = options.baselines[scope];
-        if (!baseline)
-            throw new Error(`memory agent has no ${scope} baseline`);
-        const scopeEdits = proposal.edits.filter((edit) => edit.targetScope === scope);
-        const fingerprint = fingerprintMemoryBatch(scope, scopeEdits);
-        if (isDeclinedRepeat(loadDeclinedMemory(engine.baseDir), scope, fingerprint)) {
-            ctx.logger("continual-evolve").info(`memory ${scope} proposal repeat-suppressed (declined before, no popup)`);
-            declinedScopes.push(scope);
-            continue;
-        }
-        const decisionKey = options.decisionCursor === undefined
-            ? undefined
-            : memoryScopeDecisionKey(options.decisionCursor, scope, proposal.edits.filter((edit) => edit.targetScope === scope));
-        const previous = decisionKey === undefined ? undefined : options.scopeDecisions?.[decisionKey];
-        if (previous === "approved") {
-            approvedScopes.add(scope);
-            continue;
-        }
-        if (previous === "declined") {
-            declinedScopes.push(scope);
-            continue;
-        }
-        const approved = await requestScopeApproval(ctx, options.agent, options.signal, scope, renderMemoryApprovalDetails(proposal, scope, baseline), options.recordLanguage);
-        if (decisionKey !== undefined)
-            options.onScopeDecision?.(decisionKey, approved);
-        if (approved === "approved")
-            approvedScopes.add(scope);
-        else {
-            declinedScopes.push(scope);
-            try {
-                recordDeclinedMemory(engine.baseDir, scope, scopeEdits, compactText(scopeEdits[0]?.title ?? proposal.summary, 120));
-            }
-            catch (error) {
-                ctx.logger("continual-evolve").warn(`declined-memory ledger write failed: ${error instanceof Error ? error.message : String(error)}`);
-            }
-        }
-    }
-    const results = [];
-    const applied = [];
-    try {
-        for (const scope of scopeOrder) {
-            const edits = editsByScope.get(scope);
-            if (!edits)
-                continue;
-            if (scope !== "local" && !approvedScopes.has(scope))
-                continue;
-            options.signal?.throwIfAborted();
-            const storeId = scope === "local" ? options.agent.id : scope === "project" ? options.projectKey : undefined;
-            const baseline = options.baselines[scope];
-            if (!baseline)
-                throw new Error(`memory agent has no ${scope} baseline`);
-            const result = engine.apply(scope, storeId, {
-                summary: proposal.summary,
-                rationale: proposal.rationale,
-                expectedOutcome: proposal.expectedOutcome,
-                edits: prepareMemoryEdits(edits, baseline),
-            }, {
-                scope,
-                baselineState: baseline,
-                ...(options.source ? { source: options.source } : {}),
-            });
-            const failed = result.appliedEdits.filter((edit) => !edit.applied);
-            if (failed.length > 0) {
-                throw new MemoryApplyBatchError(`${scope} batch ${result.id} left ${failed.length} edit(s) unapplied: ${failed.map((edit) => edit.error ?? "unknown").join("; ")}`, result, scope, storeId);
-            }
-            results.push(result);
-            applied.push({ scope, storeId, result });
-        }
-        return { results, declinedScopes };
-    }
-    catch (cause) {
-        const attempted = [...applied];
-        if (cause instanceof MemoryApplyBatchError && cause.result && cause.scope) {
-            attempted.push({ scope: cause.scope, storeId: cause.storeId, result: cause.result });
-        }
-        else if (cause instanceof EvolutionApplyPostCommitError) {
-            attempted.push({ scope: cause.scope, storeId: cause.storeId, result: cause.result });
-        }
-        const rollbackErrors = [];
-        for (const item of attempted.reverse()) {
-            try {
-                const rollback = engine.rollbackResult(item.scope, item.storeId, item.result);
-                const failed = rollback.appliedEdits.filter((edit) => !edit.applied);
-                if (failed.length > 0)
-                    rollbackErrors.push(`${item.scope}:${item.result.id} left ${failed.length} rollback edit(s) unapplied`);
-            }
-            catch (rollbackCause) {
-                rollbackErrors.push(`${item.scope}:${item.result.id} rollback failed: ${rollbackCause instanceof Error ? rollbackCause.message : String(rollbackCause)}`);
-            }
-        }
-        const suffix = rollbackErrors.length > 0 ? `; compensation errors: ${rollbackErrors.join("; ")}` : "; prior memory writes were rolled back";
-        throw new Error(`memory agent apply failed: ${cause instanceof Error ? cause.message : String(cause)}${suffix}`);
-    }
-}
-function prepareMemoryEdits(edits, baseline) {
-    return edits.map((edit) => {
-        const plain = stripTargetScope(edit);
-        if (plain.action !== "update" || plain.metadata === undefined || plain.id === undefined)
-            return plain;
-        const before = baseline.entries.memory[plain.id];
-        return before ? { ...plain, metadata: { ...before.metadata, ...plain.metadata } } : plain;
-    });
-}
-function stripTargetScope(edit) {
-    const { targetScope: _targetScope, ...plain } = edit;
-    return plain;
-}
-//# sourceMappingURL=memory-apply.js.map

package/lib/memory-benchmark.d.ts

@@ -1,76 +0,0 @@
-import type { HarnessEntry } from "./types.js";
-/** One labeled fact the extractor should (or, when outdated, should not) produce. */
-export interface MemoryBenchmarkFact {
-    id: string;
-    memoryType: string;
-    /** Key phrases; an edit matches when its title+content carry every phrase. */
-    mustContain: string[];
-    /** Outdated facts must be avoided (create/update) or removed (archive/delete). */
-    outdated?: boolean;
-}
-export interface MemoryBenchmarkReference {
-    facts: MemoryBenchmarkFact[];
-}
-/** One proposed edit in the shape the memory loop emits. */
-export interface MemoryBenchmarkEdit {
-    action: "create" | "update" | "delete" | "archive";
-    title?: string;
-    content?: string;
-    /** Target entry id for update/delete/archive. */
-    id?: string;
-}
-export interface ScoredMemoryBenchmarkEdit {
-    action: MemoryBenchmarkEdit["action"];
-    matchedFactIds: string[];
-    duplicateOf?: string;
-    staleReason?: string;
-    noisyReason?: string;
-}
-export interface MemoryBenchmarkScore {
-    totalEdits: number;
-    matchedFacts: number;
-    precision: number;
-    recall: number;
-    duplicate: number;
-    stale: number;
-    noise: number;
-    uncoveredFactIds: string[];
-    edits: ScoredMemoryBenchmarkEdit[];
-}
-export interface MemoryGradeThresholds {
-    minPrecision: number;
-    minRecall: number;
-    maxDuplicate: number;
-    maxStale: number;
-    maxNoise: number;
-}
-/** Strict-by-default gate: duplicates and stale operations never pass unnoticed. */
-export declare const DEFAULT_MEMORY_GRADE_THRESHOLDS: MemoryGradeThresholds;
-/**
- * v1 exclusion heuristics for noise ("不该记什么" in mechanical form):
- * git history, repo paths re-readable from disk, stack traces, and
- * explicitly temporary session state. Keep this list short and documented —
- * every pattern here is a precision/recall tradeoff, not ground truth.
- */
-export declare const MEMORY_NOISE_PATTERNS: readonly RegExp[];
-/** Content shorter than this is too thin to be a durable fact. */
-export declare const MEMORY_MIN_FACT_CHARS = 30;
-/**
- * Score one proposal against the reference and the pre-extraction manifest.
- *
- * @param reference Labeled facts (live + outdated).
- * @param edits The proposal's memory edits.
- * @param manifest Memory entries visible before extraction (duplicate source).
- * @returns Per-dimension counts plus a per-edit breakdown.
- */
-export declare function scoreMemoryExtraction(reference: MemoryBenchmarkReference, edits: readonly MemoryBenchmarkEdit[], manifest: readonly HarnessEntry[]): MemoryBenchmarkScore;
-/**
- * Grade a score against explicit thresholds.
- *
- * @returns pass plus one failure line per violated dimension (empty when passing).
- */
-export declare function gradeMemoryScore(score: MemoryBenchmarkScore, thresholds?: MemoryGradeThresholds): {
-    pass: boolean;
-    failures: string[];
-};
-//# sourceMappingURL=memory-benchmark.d.ts.map

package/lib/memory-benchmark.js

@@ -1,170 +0,0 @@
-/**
- * Memory-specific extraction benchmark (P1): deterministic scoring of one
- * memory proposal against a labeled reference.
- *
- * Unlike the harness benchmark (which runs subagents against rubrics), this
- * module scores a proposal's SHAPE without any model call: precision and
- * recall over reference facts, duplicate creates (update-first violations),
- * stale operations (re-proposing outdated facts, or removing live ones), and
- * noise (unmatched or exclusion-list material). Suite authors hand-build
- * small references plus transcripts; the extraction loop under test produces
- * the proposal, this module grades it.
- *
- * Matching is phrase-substring based (case-insensitive): a reference fact
- * lists must-contain phrases, and a proposed edit matches when its title
- * plus content carry every phrase. Deliberately mechanical — the benchmark
- * measures extraction coverage, not paraphrase quality.
- */
-import { CONFLICT_BLOCK_SCORE, mostSimilarEntry } from "./promotion.js";
-import { isArchived } from "./types.js";
-/** Strict-by-default gate: duplicates and stale operations never pass unnoticed. */
-export const DEFAULT_MEMORY_GRADE_THRESHOLDS = {
-    minPrecision: 0.7,
-    minRecall: 0.7,
-    maxDuplicate: 0,
-    maxStale: 0,
-    maxNoise: 0,
-};
-/**
- * v1 exclusion heuristics for noise ("不该记什么" in mechanical form):
- * git history, repo paths re-readable from disk, stack traces, and
- * explicitly temporary session state. Keep this list short and documented —
- * every pattern here is a precision/recall tradeoff, not ground truth.
- */
-export const MEMORY_NOISE_PATTERNS = [
-    /\bgit\s+(log|show|commit|diff)\b/i,
-    /\bcommit\s+[0-9a-f]{5,40}\b/i,
-    /\b[0-9a-f]{40}\b/,
-    /(?:^|[\s("'])((?:src|lib|test|tests|docs|scripts)\/[A-Za-z0-9_./-]+\.[a-z]+)/,
-    /\bat\s+[\w$.]+\s*\(.*:\d+:\d+\)/,
-    /\b(temporary|one-off debugging|current task progress|in this session only)\b/i,
-];
-/** Content shorter than this is too thin to be a durable fact. */
-export const MEMORY_MIN_FACT_CHARS = 30;
-/**
- * Score one proposal against the reference and the pre-extraction manifest.
- *
- * @param reference Labeled facts (live + outdated).
- * @param edits The proposal's memory edits.
- * @param manifest Memory entries visible before extraction (duplicate source).
- * @returns Per-dimension counts plus a per-edit breakdown.
- */
-export function scoreMemoryExtraction(reference, edits, manifest) {
-    const live = reference.facts.filter((fact) => !fact.outdated);
-    const outdated = reference.facts.filter((fact) => fact.outdated);
-    const liveMatched = new Set();
-    const outdatedHandled = new Set();
-    const scored = [];
-    let duplicate = 0;
-    let stale = 0;
-    let noise = 0;
-    for (const edit of edits) {
-        const text = `${edit.title ?? ""}\n${edit.content ?? ""}`;
-        const liveHits = live.filter((fact) => matchesFact(text, fact));
-        const outdatedHits = outdated.filter((fact) => matchesFact(text, fact));
-        const entry = { action: edit.action, matchedFactIds: [] };
-        if (edit.action === "create" || edit.action === "update") {
-            if (outdatedHits.length > 0) {
-                stale += 1;
-                entry.staleReason = `re-proposes outdated fact(s): ${outdatedHits.map((fact) => fact.id).join(",")}`;
-            }
-            else if (edit.action === "create") {
-                const hit = mostSimilarEntry(manifest.filter((candidate) => candidate.kind === "memory"), edit.title ?? "", edit.content ?? "", CONFLICT_BLOCK_SCORE);
-                if (hit) {
-                    duplicate += 1;
-                    entry.duplicateOf = hit.id;
-                }
-                else if (liveHits.length > 0) {
-                    for (const fact of liveHits) {
-                        liveMatched.add(fact.id);
-                        entry.matchedFactIds.push(fact.id);
-                    }
-                }
-                else {
-                    noise += 1;
-                    entry.noisyReason = noiseReason(text);
-                }
-            }
-            else if (liveHits.length > 0) {
-                for (const fact of liveHits) {
-                    liveMatched.add(fact.id);
-                    entry.matchedFactIds.push(fact.id);
-                }
-            }
-            else {
-                noise += 1;
-                entry.noisyReason = noiseReason(text);
-            }
-        }
-        else {
-            // delete/archive: correct only against outdated facts.
-            const targetHits = [...liveHits, ...outdatedHits];
-            const targetOutdated = outdatedHits.length > 0;
-            const targetEntry = edit.id !== undefined ? manifest.find((candidate) => candidate.id === edit.id) : undefined;
-            if (targetOutdated) {
-                for (const fact of outdatedHits) {
-                    outdatedHandled.add(fact.id);
-                    entry.matchedFactIds.push(fact.id);
-                }
-            }
-            else if (targetEntry !== undefined && isArchived(targetEntry)) {
-                // Re-archiving an already archived entry is harmless housekeeping.
-                entry.matchedFactIds.push(`archived:${targetEntry.id}`);
-            }
-            else if (targetHits.length > 0 || (targetEntry !== undefined && !isArchived(targetEntry))) {
-                stale += 1;
-                entry.staleReason = `removes live fact(s): ${targetHits.map((fact) => fact.id).join(",") || targetEntry?.id || "(unknown target)"}`;
-            }
-            else {
-                noise += 1;
-                entry.noisyReason = "removal matches no reference fact";
-            }
-        }
-        scored.push(entry);
-    }
-    const total = edits.length;
-    const preciseEdits = scored.filter((entry) => entry.matchedFactIds.length > 0).length;
-    const precision = total === 0 ? 1 : preciseEdits / total;
-    const recall = live.length === 0 ? 1 : liveMatched.size / live.length;
-    return {
-        totalEdits: total,
-        matchedFacts: liveMatched.size + outdatedHandled.size,
-        precision,
-        recall,
-        duplicate,
-        stale,
-        noise,
-        uncoveredFactIds: live.filter((fact) => !liveMatched.has(fact.id)).map((fact) => fact.id),
-        edits: scored,
-    };
-}
-/**
- * Grade a score against explicit thresholds.
- *
- * @returns pass plus one failure line per violated dimension (empty when passing).
- */
-export function gradeMemoryScore(score, thresholds = DEFAULT_MEMORY_GRADE_THRESHOLDS) {
-    const failures = [];
-    if (score.precision < thresholds.minPrecision)
-        failures.push(`precision ${score.precision.toFixed(2)} < ${thresholds.minPrecision}`);
-    if (score.recall < thresholds.minRecall)
-        failures.push(`recall ${score.recall.toFixed(2)} < ${thresholds.minRecall}`);
-    if (score.duplicate > thresholds.maxDuplicate)
-        failures.push(`duplicate ${score.duplicate} > ${thresholds.maxDuplicate}`);
-    if (score.stale > thresholds.maxStale)
-        failures.push(`stale ${score.stale} > ${thresholds.maxStale}`);
-    if (score.noise > thresholds.maxNoise)
-        failures.push(`noise ${score.noise} > ${thresholds.maxNoise}`);
-    return { pass: failures.length === 0, failures };
-}
-function matchesFact(text, fact) {
-    const lowered = text.toLowerCase();
-    return fact.mustContain.every((phrase) => lowered.includes(phrase.toLowerCase()));
-}
-function noiseReason(text) {
-    if (text.trim().length < MEMORY_MIN_FACT_CHARS)
-        return `thin content (<${MEMORY_MIN_FACT_CHARS} chars)`;
-    const hit = MEMORY_NOISE_PATTERNS.findIndex((pattern) => pattern.test(text));
-    return hit >= 0 ? `matches exclusion pattern #${hit + 1}` : "matches no reference fact";
-}
-//# sourceMappingURL=memory-benchmark.js.map

package/lib/memory-index.d.ts

@@ -1,114 +0,0 @@
-/**
- * evolve v2 — the passive read path: the `evolve:memory-index` system-prompt
- * section that puts memory CONTENT in front of the model at session start.
- *
- * Why not just hand out a path: the memory store lives in `<dshHome>/evolve/`,
- * outside the workspace sandbox, so the model's read tool cannot open it.
- * The section therefore carries the entries themselves — full body while the
- * character budget allows, then one-line index rows, then a `evolve_recall`
- * pointer for the rest. Budget is hard: a bounded prompt beats an unbounded one.
- *
- * Session-freeze contract (the prompt-cache guard): the section is computed
- * once per session and reused byte-for-byte afterwards, so the system prompt
- * stays stable within a session and cache reads keep hitting. A memory written
- * mid-session becomes visible in the NEXT session; `evolve_recall` covers the
- * immediate need. See `.agents/notes/proposed/feature/2026-10-01-evolve-v2-passive-read-write.md`.
- */
-import type { HarnessEntry } from "./types.js";
-import { type MemoryRecallType } from "./types.js";
-import type { EvolutionEngine } from "./service.js";
-import { type AgentLike } from "./inject.js";
-/** Hard character budget for the `<memories>` block. */
-export declare const DEFAULT_MEMORY_INDEX_MAX_CHARS = 6000;
-/** Prompt-section order of the memory index (empty 1–499 slot, see ADR). */
-export declare const DEFAULT_MEMORY_SECTION_ORDER = 400;
-/** Sessions whose frozen section text is kept before LRU eviction. */
-export declare const DEFAULT_FROZEN_SESSIONS = 32;
-/** Name of the injected section (unique — duplicate names throw upstream). */
-export declare const MEMORY_SECTION_NAME = "evolve:memory-index";
-/**
- * Recall-type priority for the budget: durable, behavior-shaping types first.
- * `project` (current work context) > `feedback` (how to behave) > `user` (who
- * the user is) > `reference` (external pointers). Entries without a valid
- * memoryType sink below every typed entry.
- */
-export declare const MEMORY_TYPE_PRIORITY: Record<MemoryRecallType, number>;
-/** The entry's recall type, or undefined when the metadata key is absent/invalid. */
-export declare function memoryTypeOf(entry: HarnessEntry): MemoryRecallType | undefined;
-/**
- * Order memories for injection: recall-type priority first
- * ({@link MEMORY_TYPE_PRIORITY}), then recency (newest first), then the stable
- * dictionary order — deterministic for equal inputs, so a frozen section is
- * reproducible across builds. The input is never mutated.
- */
-export declare function rankMemories(entries: readonly HarnessEntry[], now?: number): HarnessEntry[];
-/** One memory rendered in full, as a list item with the body indented. */
-export declare function memoryFullLine(entry: HarnessEntry): string;
-/** What a budget-bounded memory block shows. */
-export interface MemorySelection {
-    /** Entries rendered with their full body, in display order. */
-    full: HarnessEntry[];
-    /** Entries degraded to a one-line index row (`id` + title hook). */
-    indexed: HarnessEntry[];
-    /** Entries that fit neither and are only counted. */
-    dropped: number;
-    /** Entries actually shown (full + indexed), in display order. */
-    shown: HarnessEntry[];
-}
-/**
- * Greedy budget fill over {@link rankMemories}: each entry takes the full body
- * while it fits, otherwise degrades to an index row, otherwise is dropped —
- * and because the ranking is fixed, the first entry that fits neither means
- * every later one is dropped too (their rows are no smaller).
- */
-export declare function selectMemoryInjection(entries: readonly HarnessEntry[], maxChars?: number): MemorySelection;
-/** The `evolve_recall` pointer appended when rows had to be degraded or dropped. */
-export declare const MEMORY_OVERFLOW_HINT = "- \u66F4\u591A\u8BB0\u5FC6\u53EF\u7528 evolve_recall \u6309\u9700\u8BFB\u53D6";
-/**
- * Render a selection as the `<memories>` block, or "" when nothing is shown.
- * Full bodies come first in display order, then the degraded index rows, then
- * the `evolve_recall` pointer with the degradation/drop counts.
- */
-export declare function renderMemorySelection(selection: MemorySelection): string;
-/** {@link renderMemorySelection} over a fresh selection (convenience). */
-export declare function formatMemoriesBlock(entries: readonly HarnessEntry[], maxChars?: number): string;
-/** Options for {@link memoryIndexSectionText}. */
-export interface MemoryIndexOptions {
-    /** Hard budget for the memories block (default 6000). */
-    maxChars?: number;
-    /** Include the when_to_save guide (default true). */
-    guide?: boolean;
-    /** Pin the project layer explicitly (tests/tools); otherwise derived from cwd. */
-    projectKey?: string;
-}
-/**
- * Compose the full `evolve:memory-index` section for one assembling agent:
- * the persistent-memory guide (when to save / how to maintain) wrapped around
- * the budget-bounded memories block. With the guide off and no memories the
- * result is "" — the prompt renderer then drops the section, so an empty store
- * keeps costing zero tokens.
- *
- * Injection usage is recorded for everything shown (best-effort; a failure
- * never blocks injection), deduped per session by {@link recordInjection}.
- */
-export declare function memoryIndexSectionText(engine: EvolutionEngine, agent: AgentLike | undefined, opts?: MemoryIndexOptions): string;
-/** A per-session frozen view of the memory section text. */
-export interface FrozenMemorySection {
-    /**
-     * The section text for this agent: built on first use per `agent.id` and
-     * reused byte-for-byte afterwards. `undefined` agent → "" (unbuilt).
-     */
-    textFor(agent: AgentLike | undefined, build: (agent: AgentLike) => string): string;
-    /** Sessions currently frozen (test/observability hook). */
-    size(): number;
-    /** Drop every frozen session (tests; a restart rebuilds naturally). */
-    clear(): void;
-}
-/**
- * Freeze the section text per session id. The frozen value is what keeps the
- * system prompt stable across a session's assemblies (prompt-cache guard);
- * bounded by `maxSessions` with insertion-order (LRU) eviction, so a long-lived
- * process cannot grow without limit.
- */
-export declare function createFrozenMemorySection(maxSessions?: number): FrozenMemorySection;
-//# sourceMappingURL=memory-index.d.ts.map