dsh-continual-evolve 0.11.0 → 0.12.1

package/lib/inject.js

@@ -1,164 +0,0 @@
-import { isArchived } from "./types.js";
-import { mergeHarnessStates } from "./state.js";
-import { projectKeyOf } from "./project.js";
-import { entryLine } from "./render.js";
-import { recordInjection } from "./usage.js";
-import { recentUserText, rankEntries, } from "./injection-rank.js";
-import { formatEntriesDirectoryRanked, rankedDirectoryEntries } from "./injection-directory.js";
-import { MAX_INJECTED_ENTRIES_PER_KIND, MAX_INJECTED_CONTENT_LENGTH } from "./injection-caps.js";
-import { DEFAULT_DIRECTORY_LINES } from "./injection-directory.js";
-/** Compat surface: ranking + directory + caps moved out 2026-10-03. */
-export { rankEntries, recencyScore, recentUserText, sessionEventsOf, tokenize } from "./injection-rank.js";
-export { RECENCY_HALF_LIFE_MS, MAX_QUERY_MESSAGES, MAX_QUERY_CHARS } from "./injection-rank.js";
-export { directoryLine, formatEntriesDirectory, formatEntriesDirectoryCapped, formatEntriesDirectoryRanked, rankedDirectoryEntries, DEFAULT_DIRECTORY_LINES, } from "./injection-directory.js";
-export { MAX_INJECTED_ENTRIES_PER_KIND, MAX_INJECTED_CONTENT_LENGTH } from "./injection-caps.js";
-/** How many `parentSession` hops a child walks to inherit entries. */
-export const MAX_PARENT_CHAIN_DEPTH = 8;
-/** True when the state carries at least one entry of any kind. */
-export function hasAnyEntries(state) {
-    return Object.values(state.entries).some((byKind) => Object.keys(byKind).length > 0);
-}
-/** The additive prompt-notes block (empty when there are no visible prompt entries). */
-export function formatPromptEntriesSection(entries, query) {
-    const visible = entries.filter((entry) => !isArchived(entry));
-    if (visible.length === 0) {
-        return "";
-    }
-    const lines = [
-        "# Continual Harness — Prompt Notes",
-        "Supplemental prompt notes (the base system prompt is immutable). Use evolve_list for the full text of any note.",
-    ];
-    for (const entry of rankEntries(visible, query).slice(0, MAX_INJECTED_ENTRIES_PER_KIND)) {
-        lines.push(entryLine(entry, MAX_INJECTED_CONTENT_LENGTH));
-    }
-    const overflow = visible.length - Math.min(visible.length, MAX_INJECTED_ENTRIES_PER_KIND);
-    if (overflow > 0) {
-        lines.push(`- +${overflow} more prompt notes (evolve_list)`);
-    }
-    return lines.join("\n");
-}
-/** The reusable delegation-specs block (empty when there are no visible subagent entries). */
-export function formatSubagentSpecsSection(entries, query) {
-    const visible = entries.filter((entry) => !isArchived(entry));
-    if (visible.length === 0) {
-        return "";
-    }
-    const lines = [
-        "# Continual Harness — Delegation Specs",
-        "Reusable subagent specs: when you delegate work that matches a spec, assemble the child prompt from its content. Children inherit these specs through their parent chain.",
-    ];
-    for (const entry of rankEntries(visible, query).slice(0, MAX_INJECTED_ENTRIES_PER_KIND)) {
-        lines.push(entryLine(entry, MAX_INJECTED_CONTENT_LENGTH));
-    }
-    const overflow = visible.length - Math.min(visible.length, MAX_INJECTED_ENTRIES_PER_KIND);
-    if (overflow > 0) {
-        lines.push(`- +${overflow} more delegation specs (evolve_list)`);
-    }
-    return lines.join("\n");
-}
-/**
- * Walk the parent-session chain from `agent` upward and return the nearest
- * session whose local store is non-empty, if any. Children inherit their
- * ancestor's prompt notes and delegation specs; the chain walk stops at the
- * first store that has entries (deep descendants do not re-inject ancestors
- * beyond the nearest carrying store).
- */
-export function nearestLocalStateWithEntries(engine, agent) {
-    let cursor = agent;
-    for (let depth = 0; cursor !== undefined && depth < MAX_PARENT_CHAIN_DEPTH; depth += 1) {
-        const state = engine.load("local", cursor.id);
-        if (hasAnyEntries(state)) {
-            return state;
-        }
-        cursor = cursor.session?.header?.parentSession
-            ? { id: cursor.session.header.parentSession }
-            : undefined;
-    }
-    return undefined;
-}
-/**
- * The single three-store merge every injection path reads from: the global
- * store merged with this project's store (when the session cwd resolves one)
- * and the nearest carrying local store (precedence global < project < local —
- * see {@link mergeHarnessStates}). One home, so the memory section and the
- * entry directory can never disagree about what the model can see.
- */
-export function mergedInjectionState(engine, agent, opts) {
-    const globalState = engine.load("global", undefined);
-    const projectKey = opts?.projectKey ?? projectKeyOf(agent);
-    const projectState = projectKey ? engine.load("project", projectKey) : undefined;
-    const localState = nearestLocalStateWithEntries(engine, agent);
-    return mergeHarnessStates(globalState, localState, projectState ? { projectState } : undefined);
-}
-/**
- * Compose the full injected block for one assembling agent: global entries
- * merged with this project's store (when the session cwd resolves one) and
- * the nearest carrying local store (precedence global < project < local).
- * The optional `query` — when absent, derived from the agent's most recent
- * direct user messages — ranks which entries fill the per-kind cap
- * (relevance first, then recency; see {@link rankEntries}). Returns "" when
- * nothing is injectable — the prompt renderer then drops the section, so an
- * empty store adds zero tokens to every assembly.
- *
- * `opts.directoryLines` caps the entry-directory index (2026-08-22 throttle);
- * `opts.projectKey` pins the project layer explicitly (tests, tools) —
- * otherwise it is derived from the agent's session cwd, best-effort.
- * `opts.includeMemoryDirectory` (default true) drops memory lines from the
- * directory when the memory section already carries them (evolve v2) — one
- * fact, one home, so the same memories are never paid for twice.
- * Usage recording covers ALL kinds — memories and skills appear as directory
- * lines, prompts/subagents as content — and is deduped per session so the
- * counts read "how many sessions saw this", not "how many prompt builds".
- */
-export function entriesSectionText(engine, agent, query, opts) {
-    if (!agent) {
-        return "";
-    }
-    const merged = mergedInjectionState(engine, agent, opts);
-    const promptEntries = Object.values(merged.entries.prompt);
-    const subagentEntries = Object.values(merged.entries.subagent);
-    const relevanceQuery = (query ?? recentUserText(agent)).trim();
-    // Build injected text and collect which entries were included (gap B1).
-    const promptText = formatPromptEntriesSection(promptEntries, relevanceQuery);
-    const subagentText = formatSubagentSpecsSection(subagentEntries, relevanceQuery);
-    const injectedKeys = new Set();
-    // Collect keys from the visible (ranked, capped) entries that actually appear.
-    const visiblePrompt = promptEntries.filter((e) => !isArchived(e));
-    const visibleSubagent = subagentEntries.filter((e) => !isArchived(e));
-    for (const entry of rankEntries(visiblePrompt, relevanceQuery).slice(0, MAX_INJECTED_ENTRIES_PER_KIND)) {
-        injectedKeys.add(`prompt:${entry.id}`);
-    }
-    for (const entry of rankEntries(visibleSubagent, relevanceQuery).slice(0, MAX_INJECTED_ENTRIES_PER_KIND)) {
-        injectedKeys.add(`subagent:${entry.id}`);
-    }
-    // Gap B3: lightweight directory of ALL entries (id+title, one line each).
-    // Zero-cost index so the model knows what exists and can ask for full text.
-    const directoryLines = opts?.directoryLines ?? DEFAULT_DIRECTORY_LINES;
-    const promptKind = Object.values(merged.entries.prompt);
-    const subagentKind = Object.values(merged.entries.subagent);
-    // v2: memories live in their own content-carrying section, so the directory
-    // stops listing them (passing [] keeps the positional contract intact).
-    const memoryKind = (opts?.includeMemoryDirectory ?? true) ? Object.values(merged.entries.memory) : [];
-    const skillKind = Object.values(merged.entries.skill);
-    const directoryText = formatEntriesDirectoryRanked(directoryLines, relevanceQuery, promptKind, subagentKind, memoryKind, skillKind);
-    // Directory-visible keys count too: a memory's injection IS its directory
-    // line. Set semantics keep content-injected entries single-counted. Keys
-    // come from the single display-ordered source (type hooks included), not
-    // substring matching on the rendered text.
-    for (const entry of rankedDirectoryEntries(directoryLines, relevanceQuery, promptKind, subagentKind, memoryKind, skillKind)) {
-        injectedKeys.add(`${entry.kind}:${entry.id}`);
-    }
-    // Record usage durably (best-effort: failure never blocks injection).
-    // Deduped per session — see recordInjection.
-    if (injectedKeys.size > 0) {
-        try {
-            recordInjection(engine.baseDir, [...injectedKeys], agent.id);
-        }
-        catch {
-            // Usage recording is diagnostic; never interrupt the injection path.
-        }
-    }
-    const parts = [promptText, subagentText, directoryText].filter((part) => part.length > 0);
-    return parts.join("\n\n");
-}
-//# sourceMappingURL=inject.js.map

package/lib/injection-caps.d.ts

@@ -1,4 +0,0 @@
-/** Shared injection budgets (mirrors render.ts caps). */
-export declare const MAX_INJECTED_ENTRIES_PER_KIND = 6;
-export declare const MAX_INJECTED_CONTENT_LENGTH = 180;
-//# sourceMappingURL=injection-caps.d.ts.map

package/lib/injection-caps.js

@@ -1,4 +0,0 @@
-/** Shared injection budgets (mirrors render.ts caps). */
-export const MAX_INJECTED_ENTRIES_PER_KIND = 6;
-export const MAX_INJECTED_CONTENT_LENGTH = 180;
-//# sourceMappingURL=injection-caps.js.map

package/lib/injection-directory.d.ts

@@ -1,29 +0,0 @@
-/**
- * The entry directory: a lightweight one-line-per-entry index of ALL
- * non-archived entries across kinds, appended after the curated top-N
- * injection sections so the model has a zero-cost overview of what exists
- * and can ask for full text via `evolve_list`.
- */
-import type { HarnessEntry } from "./types.js";
-/** Directory lines injected per build before folding into a counter. */
-export declare const DEFAULT_DIRECTORY_LINES = 15;
-/** One directory index line: memory lines carry their recall-type hook. */
-export declare function directoryLine(entry: HarnessEntry): string;
-export declare function formatEntriesDirectory(...kindEntries: readonly HarnessEntry[][]): string;
-/** {@link formatEntriesDirectory} with an explicit cap (configurable). */
-export declare function formatEntriesDirectoryCapped(maxLines: number, ...kindEntries: readonly HarnessEntry[][]): string;
-/**
- * {@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 declare function formatEntriesDirectoryRanked(maxLines: number, query: string | undefined, ...kindEntries: readonly HarnessEntry[][]): string;
-/**
- * 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 declare function rankedDirectoryEntries(maxLines: number, query: string | undefined, ...kindEntries: readonly HarnessEntry[][]): HarnessEntry[];
-//# sourceMappingURL=injection-directory.d.ts.map

package/lib/injection-directory.js

@@ -1,78 +0,0 @@
-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

@@ -1,85 +0,0 @@
-/**
- * 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

@@ -1,161 +0,0 @@
-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

@@ -1,45 +0,0 @@
-/**
- * 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