dsh-continual-evolve 0.10.5 → 0.11.0

package/lib/index.js

@@ -19,7 +19,7 @@ import { expandHomePath, resolveDshHome } from "@deepseek-ai/dsh-home-paths";
 import { createEvolutionEngine } from "./service.js";
 import { registerEvolveTools } from "./tool.js";
 import { registerEvolveCommand } from "./command.js";
-import { registerAutoReview } from "./auto.js";
+import { registerAutoReview } from "./listener.js";
 import { syncSkillsFromResult } from "./skill.js";
 import { entriesSectionText } from "./inject.js";
 import { createFrozenMemorySection, DEFAULT_MEMORY_INDEX_MAX_CHARS, DEFAULT_MEMORY_SECTION_ORDER, MEMORY_SECTION_NAME, memoryIndexSectionText, } from "./memory-index.js";
@@ -45,9 +45,7 @@ export const Config = z.object({
      * Absent → 15s; 0 restores the legacy immediate abort on dispose.
      */
     sessionCloseDrainMs: z.natural().default(15000),
-    /** Legacy/local-fate cadence fallback; successful-turn review is snapshot-driven. */
-    reviewIntervalTurns: z.natural().default(6),
-    /** Trajectory slice handed to the gate, in characters. */
+    /** Trajectory slice handed to the extractor, in characters. */
     maxReviewInputChars: z.natural().default(40000),
     /** Output budget for the cheap gate call. */
     reviewBudgetTokens: z.natural().default(4096),
@@ -90,29 +88,23 @@ export const Config = z.object({
      */
     autoCase: z.boolean().default(true),
     /**
-     * Gap C1: optional model override for the review gate (cheaper model).
+     * Optional model override for the memory extractor (cheaper model).
      * Format: "provider/model" or just "model" (same provider as the agent).
-     * When absent, the review gate uses the agent's own provider/model.
+     * When absent, the extractor uses the agent's own provider/model.
      */
     reviewModel: z.string(),
     /**
-     * Gate local-fate dimension (#11 P2): the gate audits the session's local
-     * entries on its own cadence and proposes promote/archive — consulted
-     * first, never written silently. Only meaningful with autoReview on;
-     * disabled by default even when the automatic pipeline is explicitly enabled.
+     * Goal-blocked moment: after this many CONSECUTIVE idle probes that
+     * observe the session goal in phase "blocked", run one memory extraction
+     * so the stuck encounter is distilled. 0 disables.
      */
-    localFate: z.boolean().default(false),
-    /**
-     * Minimum turns between local-fate assessments on the turn-interval path
-     * (compaction is unconditional). Absent → follows reviewIntervalTurns.
-     */
-    fateIntervalTurns: z.natural(),
+    goalBlockedWrapupTurns: z.natural().min(0).default(3),
     /**
-     * Goal-blocked trigger (D3): after this many CONSECUTIVE gate runs that
-     * observe the session goal in phase "blocked", run one local-fate
-     * assessment so the encounter is distilled. 0 disables.
+     * Promotion policy (2026-08-22): regex sources whose match in a
+     * candidate's title/content marks it project-scoped — such entries are
+     * never promoted to the cross-session global store. Replaces the built-in
+     * defaults when set.
      */
-    goalBlockedWrapupTurns: z.natural().min(0).default(3),
     /**
      * Promotion policy (2026-08-22): regex sources whose match in a
      * candidate's title/content marks it project-scoped — such entries are
@@ -209,7 +201,10 @@ export function apply(ctx, config) {
             text: (context) => frozenMemories.textFor(context.agent, (agent) => memoryIndexSectionText(engine, agent, { maxChars: memoryIndexMaxChars, guide: memoryIndexGuide })),
         });
     }
-    const gate = { requireGlobalApproval: config.requireGlobalApproval ?? true };
+    const gate = {
+        requireGlobalApproval: config.requireGlobalApproval ?? true,
+        ...(config.recordLanguage !== undefined ? { recordLanguage: config.recordLanguage } : {}),
+    };
     const promotionPolicy = resolvePromotionPolicy({
         blockPatterns: config.promotionBlockPatterns,
         minPromoteChars: config.promotionMinChars,
@@ -222,6 +217,7 @@ export function apply(ctx, config) {
         autoCase: config.autoCase ?? true,
         promotionPolicy,
         autoReview: config.autoReview ?? false,
+        ...(config.recordLanguage !== undefined ? { recordLanguage: config.recordLanguage } : {}),
     });
     // Plugin-owned file logging: every cordis log message lands in
     // <baseDir>/evolve/plugin.log regardless of how dsh web was launched —
@@ -236,26 +232,20 @@ export function apply(ctx, config) {
     void restoreMounted(ctx, baseDir).catch((cause) => {
         ctx.logger("continual-evolve").warn(`mount restore failed: ${cause instanceof Error ? cause.message : String(cause)}`);
     });
-    // The Memory Agent listener is always registered: an install must work
-    // without profile edits, so `autoReview` is only the initial default when
-    // no `evolve/runtime.json` exists yet — `/evolve pause|resume` own the
-    // switch afterwards. The general review/planner, prompt/skill writes, and
-    // local-fate phases are not reachable from this listener.
+    // The memory extraction listener is always registered: an install must
+    // work without profile edits, so `autoReview` is only the initial default
+    // when no `evolve/runtime.json` exists yet — `/evolve pause|resume` own
+    // the switch afterwards. Extraction is moment-driven: compaction,
+    // goal-blocked streaks, the session-close drain, and manual
+    // `/evolve wrapup` — successful turns never cost an LLM call.
     registerAutoReview(ctx, engine, {
-        intervalTurns: config.reviewIntervalTurns ?? 6,
         enabledByDefault: config.autoReview ?? false,
-        memoryOnly: true,
         memoryMinUserWords: config.memoryMinUserWords ?? 3,
         sessionCloseDrainMs: config.sessionCloseDrainMs ?? 15000,
         maxInputChars: config.maxReviewInputChars ?? 40000,
         budgetTokens: config.reviewBudgetTokens ?? 4096,
         notifyOnAutoReview: config.notifyOnAutoReview ?? true,
-        localFate: config.localFate ?? false,
-        fateIntervalTurns: config.fateIntervalTurns ?? config.reviewIntervalTurns ?? 6,
         goalBlockedWrapupTurns: config.goalBlockedWrapupTurns ?? 3,
-        promotionPolicy,
-        autoCase: config.autoCase ?? true,
-        rubricKey,
         ...(config.historyRetain?.reviews !== undefined ? { reviewsRetain: config.historyRetain.reviews } : {}),
         ...(config.reviewModel ? { reviewModel: config.reviewModel } : {}),
         requireGlobalApproval: config.requireGlobalApproval ?? true,
@@ -263,7 +253,7 @@ export function apply(ctx, config) {
         ...(config.plannerPrefixMaxChars !== undefined ? { prefixMaxChars: config.plannerPrefixMaxChars } : {}),
         ...(config.recordLanguage !== undefined ? { recordLanguage: config.recordLanguage } : {}),
     });
-    ctx.logger("continual-evolve").info("continual-evolve automatic listener registered (Memory Agent only; generic review/planner/fate disconnected)");
+    ctx.logger("continual-evolve").info("continual-evolve moment-driven memory extraction listener registered (compaction / goal-blocked / session-close drain; manual wrapup via /evolve wrapup)");
     ctx.logger("continual-evolve").info(`continual-evolve mounted (baseDir=${baseDir})`);
 }
 //# sourceMappingURL=index.js.map

package/lib/inject.d.ts

@@ -16,140 +16,34 @@
  *   sort), keeping the injected cost bounded no matter how the store grows;
  * - full text stays one `evolve_list` call away: the injected block is a
  *   summary index, not a duplicate of the store.
+ *
+ * Split (2026-10-03 refactor): ranking lives in `injection-rank.ts`, the
+ * entry directory in `injection-directory.ts`, shared caps in
+ * `injection-caps.ts`; this module owns section rendering and the
+ * three-store merge. Moved symbols are re-exported here so the public
+ * surface stays on one module.
  */
 import type { HarnessEntry, HarnessState } from "./types.js";
 import type { EvolutionEngine } from "./service.js";
-import { tokenize } from "./search.js";
-/** CJK-bigram tokenizer re-exported for ranking consumers (see search.ts). */
-export { tokenize };
-/** Prompt sections render at most this many entries per kind. */
-export declare const MAX_INJECTED_ENTRIES_PER_KIND = 6;
-/** Per-entry content budget inside the injected block (matches render.ts). */
-export declare const MAX_INJECTED_CONTENT_LENGTH = 180;
+import { type AgentLike } from "./injection-rank.js";
+/** Compat surface: ranking + directory + caps moved out 2026-10-03. */
+export { rankEntries, recencyScore, recentUserText, sessionEventsOf, tokenize } from "./injection-rank.js";
+export type { AgentLike, UserMessageEventLike } 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 declare const MAX_PARENT_CHAIN_DEPTH = 8;
-/** 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[];
 /** The section-provider context shape we consume (subset of AssembleContext). */
 export interface InjectContext {
     agent?: AgentLike;
 }
-/**
- * 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;
 /** True when the state carries at least one entry of any kind. */
 export declare function hasAnyEntries(state: HarnessState): boolean;
 /** The additive prompt-notes block (empty when there are no visible prompt entries). */
 export declare function formatPromptEntriesSection(entries: readonly HarnessEntry[], query?: string): string;
 /** The reusable delegation-specs block (empty when there are no visible subagent entries). */
 export declare function formatSubagentSpecsSection(entries: readonly HarnessEntry[], query?: string): string;
-/**
- * Gap B3: a lightweight directory of ALL non-archived entries across all
- * kinds — one line per entry, no content. Memory lines carry their recall
- * type (`- [memory:feedback:id] title`) so the model can judge relevance
- * from the index alone. This gives the model a zero-cost overview of what
- * exists so it can ask for full text via `evolve_list` or `/evolve list`.
- * The directory is appended after the curated top-N injection sections and
- * adds minimal tokens.
- *
- * 2026-08-22 throttle: the directory is CAPPED at {@link DEFAULT_DIRECTORY_LINES}
- * lines with the remainder folded into a single counter line — an uncapped
- * directory across a polluted global store was measured at ~2K chars of
- * every build in every project.
- *
- * 2026-09-23 relevance order: the directory is sorted by
- * {@link rankEntries} against the assembly's relevance query, so the lines
- * folded below the cap are the least relevant — not the dictionary tail.
- */
-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[];
 /**
  * Walk the parent-session chain from `agent` upward and return the nearest
  * session whose local store is non-empty, if any. Children inherit their

package/lib/inject.js

@@ -1,176 +1,19 @@
-import { MEMORY_TYPE_KEY, isArchived, isMemoryType, VALENCE_NEGATIVE_KEY } from "./types.js";
+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 { buildRelevanceIndex, relevanceScore, tokenize } from "./search.js";
-/** CJK-bigram tokenizer re-exported for ranking consumers (see search.ts). */
-export { tokenize };
-/** Prompt sections render at most this many entries per kind. */
-export const MAX_INJECTED_ENTRIES_PER_KIND = 6;
-/** Per-entry content budget inside the injected block (matches render.ts). */
-export const MAX_INJECTED_CONTENT_LENGTH = 180;
+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;
-/** 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);
-    });
-}
-function sortedEntries(entries, query) {
-    return rankEntries(entries, query);
-}
-/**
- * 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);
-}
 /** 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);
@@ -185,7 +28,7 @@ export function formatPromptEntriesSection(entries, query) {
         "# 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 sortedEntries(visible, query).slice(0, MAX_INJECTED_ENTRIES_PER_KIND)) {
+    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);
@@ -204,7 +47,7 @@ export function formatSubagentSpecsSection(entries, query) {
         "# 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 sortedEntries(visible, query).slice(0, MAX_INJECTED_ENTRIES_PER_KIND)) {
+    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);
@@ -213,97 +56,6 @@ export function formatSubagentSpecsSection(entries, query) {
     }
     return lines.join("\n");
 }
-/**
- * Gap B3: a lightweight directory of ALL non-archived entries across all
- * kinds — one line per entry, no content. Memory lines carry their recall
- * type (`- [memory:feedback:id] title`) so the model can judge relevance
- * from the index alone. This gives the model a zero-cost overview of what
- * exists so it can ask for full text via `evolve_list` or `/evolve list`.
- * The directory is appended after the curated top-N injection sections and
- * adds minimal tokens.
- *
- * 2026-08-22 throttle: the directory is CAPPED at {@link DEFAULT_DIRECTORY_LINES}
- * lines with the remainder folded into a single counter line — an uncapped
- * directory across a polluted global store was measured at ~2K chars of
- * every build in every project.
- *
- * 2026-09-23 relevance order: the directory is sorted by
- * {@link rankEntries} against the assembly's relevance query, so the lines
- * folded below the cap are the least relevant — not the dictionary tail.
- */
-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));
-}
 /**
  * Walk the parent-session chain from `agent` upward and return the nearest
  * session whose local store is non-empty, if any. Children inherit their

package/lib/injection-caps.d.ts

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

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

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