dsh-continual-evolve 0.10.5 → 0.11.0

package/lib/injection-directory.js

@@ -0,0 +1,78 @@
+import { MEMORY_TYPE_KEY, isArchived, isMemoryType } from "./types.js";
+import { rankEntries } from "./injection-rank.js";
+import { MAX_INJECTED_ENTRIES_PER_KIND } from "./injection-caps.js";
+/** Directory lines injected per build before folding into a counter. */
+export const DEFAULT_DIRECTORY_LINES = 15;
+/** One directory index line: memory lines carry their recall-type hook. */
+export function directoryLine(entry) {
+    if (entry.kind === "memory") {
+        const type = entry.metadata[MEMORY_TYPE_KEY];
+        const hook = isMemoryType(type) ? `:${type}` : "";
+        return `- [memory${hook}:${entry.id}] ${entry.title}`;
+    }
+    return `- [${entry.kind}:${entry.id}] ${entry.title}`;
+}
+/** Positional contract for the directory variadics: the first two arrays
+ * must be the content-section kinds (prompt, subagent) — the redundancy
+ * check counts exactly those as already visible. Callers pass
+ * (prompt, subagent, memory, skill); any other order miscounts. */
+const CONTENT_SECTION_KINDS = 2;
+export function formatEntriesDirectory(...kindEntries) {
+    return formatEntriesDirectoryCapped(DEFAULT_DIRECTORY_LINES, ...kindEntries);
+}
+/** {@link formatEntriesDirectory} with an explicit cap (configurable). */
+export function formatEntriesDirectoryCapped(maxLines, ...kindEntries) {
+    return formatEntriesDirectoryRanked(maxLines, undefined, ...kindEntries);
+}
+/**
+ * {@link formatEntriesDirectoryCapped} with a relevance query: entries are
+ * ordered by {@link rankEntries} (relevance first, then recency) so the cap
+ * folds the least relevant entries — never the dictionary tail. An empty
+ * query degrades to the valence/recency/stable order, still deterministic.
+ */
+export function formatEntriesDirectoryRanked(maxLines, query, ...kindEntries) {
+    const total = kindEntries.flat().filter((e) => !isArchived(e)).length;
+    if (total === 0) {
+        return "";
+    }
+    // Suppressed (every entry already content-visible) renders as "" — the
+    // prompt renderer then drops the section entirely.
+    const shown = rankedDirectoryEntries(maxLines, query, ...kindEntries);
+    if (shown.length === 0) {
+        return "";
+    }
+    const lines = ["# Continual Harness — Entry Directory", "All entries (use evolve_list for full text of any entry):"];
+    for (const entry of shown) {
+        lines.push(directoryLine(entry));
+    }
+    const hidden = total - shown.length;
+    if (hidden > 0) {
+        lines.push(`- …and ${hidden} more entries (evolve_list for the full index)`);
+    }
+    return lines.join("\n");
+}
+/**
+ * The directory entries actually shown under the cap, in display order —
+ * the single source for both the rendered text and usage accounting (so a
+ * memory's injection IS its directory line even with the `:type` hook).
+ * Returns [] when the directory is suppressed or empty.
+ */
+export function rankedDirectoryEntries(maxLines, query, ...kindEntries) {
+    const allEntries = kindEntries.flat().filter((e) => !isArchived(e));
+    if (allEntries.length === 0) {
+        return [];
+    }
+    // Skip the directory only when EVERY entry is already content-visible.
+    // Only the first two arrays (prompt, subagent) have curated sections —
+    // memories and skills have NO content injection, so they are invisible
+    // unless the directory lists them (pre-2026-08-22 the redundancy check
+    // wrongly counted them as "already shown", hiding small stores entirely).
+    const contentVisible = kindEntries
+        .slice(0, CONTENT_SECTION_KINDS)
+        .reduce((sum, entries) => sum + Math.min(entries.filter((e) => !isArchived(e)).length, MAX_INJECTED_ENTRIES_PER_KIND), 0);
+    if (allEntries.length <= contentVisible) {
+        return [];
+    }
+    return rankEntries(allEntries, query).slice(0, Math.max(maxLines, 1));
+}
+//# sourceMappingURL=injection-directory.js.map

package/lib/injection-rank.d.ts

@@ -0,0 +1,85 @@
+/**
+ * Injection ranking core: deterministic entry ordering (relevance →
+ * negative valence → recency → stable order) and the relevance query
+ * composed from the assembling agent's most recent direct user messages.
+ * Pure logic — no store access, no host API.
+ */
+import type { HarnessEntry } from "./types.js";
+import { tokenize } from "./search.js";
+/** Recency half-life for the injection ranking: an entry this old scores 0. */
+export declare const RECENCY_HALF_LIFE_MS: number;
+/** At most this many recent user messages feed the relevance query. */
+export declare const MAX_QUERY_MESSAGES = 3;
+/** Query text handed to the relevance scorer is capped at this many chars. */
+export declare const MAX_QUERY_CHARS = 400;
+/** A user-message event's durable shape, loosened for duck typing. */
+export interface UserMessageEventLike {
+    type?: string;
+    data?: {
+        content?: unknown;
+        source?: {
+            kind?: string;
+        };
+    };
+}
+/** The minimal agent shape the section provider needs (duck-typed). */
+export interface AgentLike {
+    id: string;
+    session?: {
+        header?: {
+            parentSession?: string;
+        };
+        /**
+         * Live append-only session log as the public `session.events` getter.
+         * Typed loosely (`unknown[]`) so the real `SessionEvent[]` union from
+         * dsh-session is assignable; rows are narrowed to
+         * {@link UserMessageEventLike} at read time.
+         */
+        events?: readonly unknown[];
+        /**
+         * Full-log snapshot reader that answers the same rows in the same order
+         * where the `events` getter is absent. Called with no arguments for the
+         * whole log, which is the read {@link sessionEventsOf} needs.
+         */
+        snapshotEvents?: () => readonly unknown[];
+    };
+}
+/**
+ * The session's event log through whichever reader the running harness
+ * generation exposes. Returns [] when neither is present, so every caller
+ * degrades to its empty-log path rather than throwing.
+ */
+export declare function sessionEventsOf(agent: AgentLike | undefined): readonly unknown[];
+/**
+ * Normalized recency in [0, 1]: 1 when the entry was just updated, decaying
+ * linearly to 0 after {@link RECENCY_HALF_LIFE_MS}. Unparseable timestamps
+ * score 0 (never preferred over a timestamped entry).
+ */
+export declare function recencyScore(entry: HarnessEntry, now: number): number;
+/**
+ * Rank entries for injection, best first. With no query the ranking is
+ * negative-valence first (contradicted entries last), then pure recency
+ * (newest first). With a query, entries are scored once against a per-call
+ * BM25 index (CJK bigrams; field-weighted title ×2 — see search.ts): any
+ * entry with a positive score (≥1 matched token) outranks every hit-less
+ * entry (score exactly 0), scores decide the order among relevant entries,
+ * the negative-valence counter breaks remaining ties (contradicted entries
+ * sink), recency breaks remaining ties, and the stable dictionary order is
+ * the final tiebreak, so the result is deterministic. The input is never
+ * mutated.
+ */
+export declare function rankEntries(entries: readonly HarnessEntry[], query?: string, now?: number): HarnessEntry[];
+/**
+ * Compose the relevance query from the assembling agent's most recent direct
+ * user messages (event rows whose `type` is `user/message` and whose source
+ * is a human `user`, so injected plugin context and tool results never leak
+ * into the query). Returns "" when nothing qualifies — the ranking then
+ * falls back to pure recency.
+ */
+export declare function recentUserText(agent: AgentLike | undefined, opts?: {
+    maxMessages?: number;
+    maxChars?: number;
+}): string;
+/** CJK-bigram tokenizer re-exported for ranking consumers (see search.ts). */
+export { tokenize };
+//# sourceMappingURL=injection-rank.d.ts.map

package/lib/injection-rank.js

@@ -0,0 +1,161 @@
+import { VALENCE_NEGATIVE_KEY } from "./types.js";
+import { buildRelevanceIndex, relevanceScore, tokenize } from "./search.js";
+/** Recency half-life for the injection ranking: an entry this old scores 0. */
+export const RECENCY_HALF_LIFE_MS = 30 * 24 * 60 * 60 * 1000;
+/** At most this many recent user messages feed the relevance query. */
+export const MAX_QUERY_MESSAGES = 3;
+/** Query text handed to the relevance scorer is capped at this many chars. */
+export const MAX_QUERY_CHARS = 400;
+/**
+ * The session's event log through whichever reader the running harness
+ * generation exposes. Returns [] when neither is present, so every caller
+ * degrades to its empty-log path rather than throwing.
+ */
+export function sessionEventsOf(agent) {
+    const session = agent?.session;
+    if (session === undefined) {
+        return [];
+    }
+    if (Array.isArray(session.events)) {
+        return session.events;
+    }
+    const snapshot = session.snapshotEvents?.();
+    return Array.isArray(snapshot) ? snapshot : [];
+}
+/** Stable dictionary-order tiebreak used when two entries score equally. */
+function stableCompare(a, b) {
+    return [a.path, a.title, a.id].join("\0").localeCompare([b.path, b.title, b.id].join("\0"));
+}
+/**
+ * Normalized recency in [0, 1]: 1 when the entry was just updated, decaying
+ * linearly to 0 after {@link RECENCY_HALF_LIFE_MS}. Unparseable timestamps
+ * score 0 (never preferred over a timestamped entry).
+ */
+export function recencyScore(entry, now) {
+    const updatedAt = Date.parse(entry.updated_at);
+    if (Number.isNaN(updatedAt)) {
+        return 0;
+    }
+    const age = now - updatedAt;
+    if (age <= 0) {
+        return 1;
+    }
+    return Math.max(0, 1 - age / RECENCY_HALF_LIFE_MS);
+}
+/**
+ * Negative-valence counter (P1 效价反馈): entries contradicted by later
+ * assessments sink below clean ones at equal relevance/recency — the
+ * behavioral analog of a confidence penalty (pi-continuous-learning's
+ * contradicted −0.15), without inventing a new score axis.
+ */
+function negativeValence(entry) {
+    const value = entry.metadata[VALENCE_NEGATIVE_KEY];
+    return typeof value === "number" && Number.isFinite(value) && value > 0 ? value : 0;
+}
+/**
+ * Rank entries for injection, best first. With no query the ranking is
+ * negative-valence first (contradicted entries last), then pure recency
+ * (newest first). With a query, entries are scored once against a per-call
+ * BM25 index (CJK bigrams; field-weighted title ×2 — see search.ts): any
+ * entry with a positive score (≥1 matched token) outranks every hit-less
+ * entry (score exactly 0), scores decide the order among relevant entries,
+ * the negative-valence counter breaks remaining ties (contradicted entries
+ * sink), recency breaks remaining ties, and the stable dictionary order is
+ * the final tiebreak, so the result is deterministic. The input is never
+ * mutated.
+ */
+export function rankEntries(entries, query, now = Date.now()) {
+    const q = (query ?? "").trim();
+    if (q.length === 0) {
+        return [...entries].sort((a, b) => {
+            const valenceDelta = negativeValence(a) - negativeValence(b);
+            if (valenceDelta !== 0) {
+                return valenceDelta;
+            }
+            const recencyDelta = recencyScore(b, now) - recencyScore(a, now);
+            if (recencyDelta !== 0) {
+                return recencyDelta;
+            }
+            return stableCompare(a, b);
+        });
+    }
+    // Precompute scores once: the old comparator re-tokenized both sides on
+    // every comparison (O(n log n) tokenizations); one index + one score per
+    // entry turns the pass into table lookups.
+    const index = buildRelevanceIndex(entries);
+    const scores = new Map(entries.map((entry) => [entry, relevanceScore(index, entry, q)]));
+    return [...entries].sort((a, b) => {
+        const relevanceDelta = (scores.get(b) ?? 0) - (scores.get(a) ?? 0);
+        if (relevanceDelta !== 0) {
+            return relevanceDelta;
+        }
+        const valenceDelta = negativeValence(a) - negativeValence(b);
+        if (valenceDelta !== 0) {
+            return valenceDelta;
+        }
+        const recencyDelta = recencyScore(b, now) - recencyScore(a, now);
+        if (recencyDelta !== 0) {
+            return recencyDelta;
+        }
+        return stableCompare(a, b);
+    });
+}
+/**
+ * Extract the text of a message's content blocks without depending on the
+ * dsh-llm ContentBlock type: string blocks pass through, object blocks
+ * contribute their `text` field when present.
+ */
+function extractBlockText(content) {
+    if (typeof content === "string") {
+        return content;
+    }
+    if (!Array.isArray(content)) {
+        return "";
+    }
+    return content
+        .map((block) => {
+        if (typeof block === "string") {
+            return block;
+        }
+        if (block !== null && typeof block === "object" && "text" in block && typeof block.text === "string") {
+            return block.text;
+        }
+        return "";
+    })
+        .filter((text) => text.length > 0)
+        .join(" ");
+}
+/**
+ * Compose the relevance query from the assembling agent's most recent direct
+ * user messages (event rows whose `type` is `user/message` and whose source
+ * is a human `user`, so injected plugin context and tool results never leak
+ * into the query). Returns "" when nothing qualifies — the ranking then
+ * falls back to pure recency.
+ */
+export function recentUserText(agent, opts) {
+    const events = sessionEventsOf(agent);
+    if (events.length === 0) {
+        return "";
+    }
+    const maxMessages = opts?.maxMessages ?? MAX_QUERY_MESSAGES;
+    const maxChars = opts?.maxChars ?? MAX_QUERY_CHARS;
+    const parts = [];
+    for (let i = events.length - 1; i >= 0 && parts.length < maxMessages; i -= 1) {
+        const event = events[i];
+        if (event?.type !== "user/message") {
+            continue;
+        }
+        const source = event.data?.source;
+        if (source && source.kind !== "user") {
+            continue;
+        }
+        const text = extractBlockText(event.data?.content).trim();
+        if (text.length > 0) {
+            parts.unshift(text);
+        }
+    }
+    return parts.join(" ").slice(0, maxChars);
+}
+/** CJK-bigram tokenizer re-exported for ranking consumers (see search.ts). */
+export { tokenize };
+//# sourceMappingURL=injection-rank.js.map

package/lib/listener.d.ts

@@ -0,0 +1,45 @@
+/**
+ * The moment-driven extraction listener: registers the host event wiring and
+ * the per-session serial scheduler. The extraction logic itself lives in
+ * `extraction-phase.ts`; this module owns only WHEN it runs.
+ *
+ * Moments (refactor 2026-10-03, B verdict):
+ * - `session/event` (compaction/start) — before trajectory data is summarized away.
+ * - goal blocked streak — `goalBlockedWrapupTurns` consecutive idle probes
+ *   observing the session goal in phase "blocked" trigger one extraction so
+ *   the stuck encounter is distilled before the session moves on. The probe
+ *   is a mechanical in-memory check; it costs no LLM call until the moment fires.
+ * - session close — the bounded drain (`sessionCloseDrainMs`) lets an
+ *   in-flight extraction settle before the owner signal aborts.
+ * - manual `/evolve wrapup` — its own consultation flow (`wrapup.ts`).
+ *
+ * Per-turn snapshot extraction was removed: it burned 90% of the plugin's
+ * direct LLM calls for a fifth of the sediment (audit 2026-10-03). A
+ * successful turn only advances mechanical counters.
+ *
+ * All auxiliary work is fire-and-forget with error containment: an automatic
+ * failure never disturbs the agent loop, and every decision lands in the
+ * shared `reviews.jsonl` audit trail (see `audit-log.ts`).
+ */
+import type { Context } from "@deepseek-ai/cordis";
+import type { EvolutionEngine } from "./service.js";
+import { type ReviewScheduler } from "./review-scheduler.js";
+import { type TurnSnapshot } from "./turn-snapshot.js";
+import { type AutoReviewConfig } from "./extraction-phase.js";
+/** Default session-close drain budget: an in-flight extraction gets 15s to settle. */
+export declare const SESSION_CLOSE_DRAIN_MS_DEFAULT = 15000;
+/**
+ * Resolve the session-close drain budget: absent/invalid → default, 0 →
+ * immediate abort (legacy). Negative or non-finite values fail back to the
+ * default rather than silently disabling the drain.
+ */
+export declare function resolveSessionCloseDrainMs(raw?: number): number;
+/**
+ * Bounded session-close drain for one scheduler: wait for in-flight work up
+ * to drainMs, then abort the owner signal and drop pending captures. Never
+ * rejects — disposal must not hang the host on a stuck model call, and the
+ * abort below is idempotent when the drain already settled.
+ */
+export declare function drainSchedulerOnDispose(scheduler: Pick<ReviewScheduler<TurnSnapshot>, "drain" | "shutdown">, drainMs: number): Promise<void>;
+export declare function registerAutoReview(ctx: Context, engine: EvolutionEngine, config: AutoReviewConfig): void;
+//# sourceMappingURL=listener.d.ts.map

package/lib/listener.js

@@ -0,0 +1,199 @@
+import { goalServiceOf } from "./goal.js";
+import { isGateEnabled } from "./runtime.js";
+import { createReviewScheduler } from "./review-scheduler.js";
+import { captureTurnSnapshot } from "./turn-snapshot.js";
+import { appendReviewRecord, writeArmedMarker } from "./audit-log.js";
+import { runMemoryExtractionPhase, stateFor, } from "./extraction-phase.js";
+/** Default session-close drain budget: an in-flight extraction gets 15s to settle. */
+export const SESSION_CLOSE_DRAIN_MS_DEFAULT = 15000;
+/**
+ * Resolve the session-close drain budget: absent/invalid → default, 0 →
+ * immediate abort (legacy). Negative or non-finite values fail back to the
+ * default rather than silently disabling the drain.
+ */
+export function resolveSessionCloseDrainMs(raw) {
+    if (raw === undefined)
+        return SESSION_CLOSE_DRAIN_MS_DEFAULT;
+    if (typeof raw !== "number" || !Number.isFinite(raw) || raw < 0)
+        return SESSION_CLOSE_DRAIN_MS_DEFAULT;
+    return Math.floor(raw);
+}
+/**
+ * Bounded session-close drain for one scheduler: wait for in-flight work up
+ * to drainMs, then abort the owner signal and drop pending captures. Never
+ * rejects — disposal must not hang the host on a stuck model call, and the
+ * abort below is idempotent when the drain already settled.
+ */
+export function drainSchedulerOnDispose(scheduler, drainMs) {
+    if (drainMs <= 0) {
+        try {
+            scheduler.shutdown();
+        }
+        catch {
+            // shutdown is flag-setting plus abort: nothing observable to do
+        }
+        return Promise.resolve();
+    }
+    let timer;
+    const timeout = new Promise((resolve) => {
+        timer = setTimeout(resolve, drainMs);
+    });
+    const settle = () => {
+        if (timer !== undefined)
+            clearTimeout(timer);
+        try {
+            scheduler.shutdown();
+        }
+        catch {
+            // same as above — the abort is best-effort by design
+        }
+    };
+    return Promise.race([scheduler.drain(), timeout]).then(settle, settle);
+}
+export function registerAutoReview(ctx, engine, config) {
+    const perSession = new Map();
+    const schedulers = new Map();
+    const captureTails = new Map();
+    const disposedSessions = new Set();
+    const logger = ctx.logger("continual-evolve");
+    const defaultEnabled = config.enabledByDefault ?? true;
+    const record = (entry) => {
+        appendReviewRecord(engine.baseDir, entry, config.reviewsRetain, (cause) => logger.warn(`failed to record auto-review: ${cause instanceof Error ? cause.message : String(cause)}`));
+    };
+    const schedulerFor = (agent, state) => {
+        const existing = schedulers.get(agent.id);
+        if (existing)
+            return existing;
+        const scheduler = createReviewScheduler(async ({ snapshot, signal }) => {
+            if (!isGateEnabled(engine.baseDir, defaultEnabled))
+                return "aborted";
+            if (!snapshot.eligible) {
+                record({
+                    sessionId: snapshot.sessionId,
+                    reason: snapshot.reason,
+                    turnsSinceLastReview: state.turns - state.lastReviewAt,
+                    outcome: "skipped",
+                    rationale: `snapshot ${snapshot.cursor} skipped: ${snapshot.skipReason ?? "not eligible"}`,
+                });
+                return "no-op";
+            }
+            try {
+                await runMemoryExtractionPhase(ctx, engine, agent, config, state, snapshot, record, signal);
+                return "success";
+            }
+            catch (cause) {
+                const message = cause instanceof Error ? cause.message : String(cause);
+                logger.warn(`memory extraction failed for ${agent.id}: ${message}`);
+                record({
+                    sessionId: agent.id,
+                    reason: snapshot.reason,
+                    turnsSinceLastReview: state.turns - state.lastReviewAt,
+                    outcome: "failed",
+                    rationale: `extraction error: ${message}`,
+                });
+                return "error";
+            }
+        }, (snapshot) => snapshot.cursor);
+        schedulers.set(agent.id, scheduler);
+        return scheduler;
+    };
+    const captureAndSchedule = (agent, state, reason) => {
+        if (disposedSessions.has(agent.id) || !isGateEnabled(engine.baseDir, defaultEnabled))
+            return;
+        const previousCapture = captureTails.get(agent.id) ?? Promise.resolve();
+        const captureTask = previousCapture.then(async () => {
+            if (disposedSessions.has(agent.id) || !isGateEnabled(engine.baseDir, defaultEnabled))
+                return;
+            const cursor = schedulerFor(agent, state).getCursor();
+            const snapshot = await captureTurnSnapshot(ctx, agent, {
+                turn: state.completedTurn,
+                reason,
+                ...(cursor !== undefined ? { cursor } : {}),
+                maxChars: config.maxInputChars,
+                ...(config.memoryMinUserWords !== undefined ? { minUserWords: config.memoryMinUserWords } : {}),
+            });
+            if (!disposedSessions.has(agent.id))
+                schedulerFor(agent, state).schedule(snapshot);
+        }).catch((cause) => {
+            const message = cause instanceof Error ? cause.message : String(cause);
+            logger.warn(`memory snapshot failed for ${agent.id}: ${message}`);
+            record({
+                sessionId: agent.id,
+                reason,
+                turnsSinceLastReview: state.turns - state.lastReviewAt,
+                outcome: "failed",
+                rationale: `snapshot error: ${message}`,
+            });
+        });
+        captureTails.set(agent.id, captureTask);
+    };
+    // DSH emits this awaited boundary when a turn is about to close. It only
+    // advances the mechanical counters — extraction is moment-driven, so a
+    // successful turn never costs an LLM call by itself.
+    ctx.on("agent/turn-stopping", (payload) => {
+        const agent = payload.agent;
+        if (!agent) {
+            logger.warn(`memory extraction listener: agent/turn-stopping payload missing agent; skipping count`);
+            return;
+        }
+        const state = stateFor(perSession, agent.id);
+        state.turns += 1;
+        if (typeof payload.turn === "number")
+            state.completedTurn = Math.max(state.completedTurn, payload.turn);
+    });
+    // The idle transition is the safe point at which to read the durable
+    // surface. It probes the goal phase (mechanical, zero LLM) and fires the
+    // goal-blocked moment when the streak reaches the threshold.
+    ctx.on("agent/status", (payload) => {
+        const agent = payload.agent;
+        if (!agent || payload.status !== "idle")
+            return;
+        if (config.goalBlockedWrapupTurns <= 0)
+            return;
+        const state = stateFor(perSession, agent.id);
+        const goal = goalServiceOf(ctx)?.get(agent);
+        if (goal?.phase !== "blocked") {
+            state.goalBlockStreak = 0;
+            return;
+        }
+        state.goalBlockStreak += 1;
+        if (state.goalBlockStreak < config.goalBlockedWrapupTurns)
+            return;
+        state.goalBlockStreak = 0; // one moment per streak; declines re-arm after the next full streak
+        logger.info(`goal-blocked moment [${agent.id}]: ${config.goalBlockedWrapupTurns} consecutive blocked rounds → memory extraction`);
+        captureAndSchedule(agent, state, "goal_blocked");
+    });
+    // Boot-time diagnostic: proves the listener was registered even when its
+    // runtime default is off, distinguishing "not registered" from "off".
+    writeArmedMarker(engine.baseDir, `automatic evolution listener registered (mode=memory-only; default=${defaultEnabled ? "on" : "off"}; moments=compaction/goal-blocked/session-close-drain/manual-wrapup)`, (cause) => logger.warn(`failed to write armed marker: ${cause instanceof Error ? cause.message : String(cause)}`));
+    ctx.on("agent/disposed", (payload) => {
+        const agent = payload.agent;
+        if (!agent)
+            return;
+        disposedSessions.add(agent.id);
+        const scheduler = schedulers.get(agent.id);
+        schedulers.delete(agent.id);
+        captureTails.delete(agent.id);
+        perSession.delete(agent.id);
+        if (scheduler) {
+            // Bounded session-close drain: an in-flight extraction gets drainMs
+            // to settle so its result is not lost on session close; afterwards
+            // the owner signal aborts. Fire-and-forget — disposal must never
+            // hang the host, and the helper never rejects.
+            void drainSchedulerOnDispose(scheduler, resolveSessionCloseDrainMs(config.sessionCloseDrainMs));
+        }
+    });
+    ctx.on("session/event", (session, event) => {
+        // Compaction moment: extract before the pre-compaction trajectory is
+        // summarized away. Cold sessions (no live agent) are ignored.
+        if (event.type !== "compaction/start")
+            return;
+        const agents = ctx.agents;
+        const agent = agents?.get(session.id);
+        if (!agent)
+            return;
+        const state = stateFor(perSession, agent.id);
+        captureAndSchedule(agent, state, "compact");
+    });
+}
+//# sourceMappingURL=listener.js.map

package/lib/maintenance-commands.d.ts

@@ -0,0 +1,23 @@
+import type { Context } from "@deepseek-ai/cordis";
+import type { CommandInvocation } from "@deepseek-ai/dsh-commands";
+import { type HarnessScope } from "./types.js";
+import type { EvolutionEngine } from "./service.js";
+import { type CommandTextResult } from "./command-util.js";
+type ScopeArg = {
+    scope: HarnessScope;
+    rest: string[];
+};
+/** `/evolve archive|unarchive <id> [global|project]` — hide or restore an entry. */
+export declare function executeArchiveCommand(_ctx: Context, engine: EvolutionEngine, invocation: CommandInvocation, sub: "archive" | "unarchive", parsed: ScopeArg, usage: string): Promise<CommandTextResult>;
+/** `/evolve consolidate [apply] [merge]` — deterministic global-store hygiene. */
+export declare function executeConsolidateCommand(engine: EvolutionEngine, rest: string[]): CommandTextResult;
+/** `/evolve failures` — failure-signature aggregation (D1 observation). */
+export declare function executeFailuresCommand(engine: EvolutionEngine): CommandTextResult;
+/** `/evolve log [tail N] [session <sessionId>]` — plugin file log inspection. */
+export declare function executeLogCommand(engine: EvolutionEngine, rest: string[], usage: string): CommandTextResult;
+/** `/evolve export [global|project] <path>` — backup a store to a JSON file. */
+export declare function executeExportCommand(engine: EvolutionEngine, invocation: CommandInvocation, parsed: ScopeArg, usage: string): CommandTextResult;
+/** `/evolve import [global|project] <path>` — restore a store from an export file. */
+export declare function executeImportCommand(engine: EvolutionEngine, invocation: CommandInvocation, parsed: ScopeArg, path: string | undefined): CommandTextResult;
+export {};
+//# sourceMappingURL=maintenance-commands.d.ts.map