dsh-continual-evolve 0.2.0 → 0.3.0

package/lib/evolve-event.js

@@ -0,0 +1,49 @@
+/**
+ * Structured "evolve complete" events (gap C4): a durable, machine-readable
+ * record emitted after every successful refinement application — whether
+ * auto-gated or manual. Third-party consumers can observe these events via
+ * the plugin log (JSONL) and the reviews.jsonl audit trail.
+ *
+ * Design: prime-agent `/refine` emits `refine_complete{id,summary,
+ * appliedEdits,scope}` extension events. We follow the same pattern with
+ * added provenance (trigger, source) so consumers know WHY the refinement
+ * happened and WHO initiated it.
+ */
+import { appendFileSync, mkdirSync } from "node:fs";
+import { join } from "node:path";
+/** Build a structured evolve-complete event from a refinement result. */
+export function buildEvolveCompleteEvent(result, trigger, sessionId) {
+    return {
+        type: "evolve_complete",
+        refinementId: result.id,
+        summary: result.summary,
+        appliedEdits: result.appliedEdits.filter((e) => e.applied).length,
+        failedEdits: result.appliedEdits.filter((e) => !e.applied).length,
+        scope: result.scope ?? "local",
+        trigger,
+        sessionId,
+        timestamp: new Date().toISOString(),
+        edits: result.appliedEdits.map((e) => ({
+            action: e.action,
+            kind: e.kind,
+            id: e.id,
+            applied: e.applied,
+        })),
+    };
+}
+/**
+ * Emit an evolve_complete event to the reviews.jsonl audit trail. The event
+ * is JSONL-formatted (one line) so consumers can tail and parse it. This is
+ * a best-effort write — failure never blocks the refinement path.
+ */
+export function emitEvolveComplete(baseDir, event) {
+    try {
+        const dir = join(baseDir, "evolve");
+        mkdirSync(dir, { recursive: true });
+        appendFileSync(join(dir, "reviews.jsonl"), `${JSON.stringify(event)}\n`, "utf8");
+    }
+    catch {
+        // Event emission is diagnostic; never interrupt the refinement path.
+    }
+}
+//# sourceMappingURL=evolve-event.js.map

package/lib/failures.d.ts

@@ -0,0 +1,39 @@
+export interface FailureRecord {
+    /** When the failure was recorded (ISO). Unknown for aggregated benchmark cells without timestamps. */
+    timestamp?: string;
+    /** Where the failure came from: "review-gate" | "benchmark:<bid>:<caseId>". */
+    source: string;
+    /** Failure class (see classifyFailure). */
+    kind: string;
+    /** The original failure text (notes or rationale). */
+    message: string;
+}
+export interface FailureSummary {
+    total: number;
+    /** Count per failure class, sorted descending (most frequent first). */
+    byKind: Record<string, number>;
+    /** Count per source (gate vs benchmark:bid). */
+    bySource: Record<string, number>;
+}
+/**
+ * Classify a failure message by prefix rules. Deterministic and additive:
+ * unknown text falls into "other" so the summary never drops a failure.
+ */
+export declare function classifyFailure(message: string): string;
+/** Aggregate a record list into counts. Empty input yields an all-zero summary. */
+export declare function summarizeFailures(records: readonly FailureRecord[]): FailureSummary;
+/**
+ * Read failed review-gate records from `<baseDir>/evolve/reviews.jsonl`
+ * (outcome === "failed"). Tolerant of a missing/corrupt file.
+ */
+export declare function readReviewFailures(baseDir: string): FailureRecord[];
+/**
+ * Read failed cells from every benchmark scoreboard under
+ * `<baseDir>/evolve/benchmarks/<bid>/`. Tolerant of missing/corrupt data.
+ */
+export declare function readBenchmarkFailures(baseDir: string): FailureRecord[];
+/** Combine both sources into one summary. */
+export declare function collectFailureSummary(baseDir: string): FailureSummary;
+/** Human-readable report for the command line. */
+export declare function formatFailureSummary(summary: FailureSummary): string;
+//# sourceMappingURL=failures.d.ts.map

package/lib/failures.js

@@ -0,0 +1,170 @@
+/**
+ * Failure-signature aggregation (gap R/D1 — observation stage): turn the
+ * free-text failure records the system already produces (review-gate failures
+ * in reviews.jsonl, failed cells in benchmark scoreboards) into a structured
+ * count by failure CLASS. This is deliberately NOT the full failure-signature
+ * Refiner from gap D1 — no routing, no policy — it is the data layer that
+ * lets a later patch decide whether a given failure class recurs often enough
+ * to deserve one.
+ *
+ * Classes are extracted with pure prefix rules (see classifyFailure), so the
+ * aggregation is deterministic and unit-testable: the same failure text
+ * always lands in the same class.
+ */
+import { existsSync, readFileSync, readdirSync } from "node:fs";
+import { join } from "node:path";
+/**
+ * Classify a failure message by prefix rules. Deterministic and additive:
+ * unknown text falls into "other" so the summary never drops a failure.
+ */
+export function classifyFailure(message) {
+    const text = (message ?? "").trim();
+    const lower = text.toLowerCase();
+    if (lower.includes("rubric decrypt failed"))
+        return "rubric-decrypt";
+    if (lower.includes("materials changed"))
+        return "material-drift";
+    if (lower.includes("executor failed") || lower.includes("executor stopped"))
+        return "executor";
+    if (lower.includes("reviewer failed") || lower.includes("reviewer stopped"))
+        return "reviewer";
+    if (lower.includes("fate assessment error"))
+        return "fate-assessor";
+    if (lower.includes("trajectory unavailable"))
+        return "trajectory";
+    if (lower.includes("output budget exhausted") || lower.includes("max-tokens"))
+        return "max-tokens";
+    if (lower.includes("llm call aborted") || lower.includes("aborted"))
+        return "aborted";
+    if (lower.includes("llm call failed"))
+        return "llm";
+    if (lower.includes("gate error"))
+        return "gate";
+    if (lower.includes("casecheck") || lower.includes("case check"))
+        return "casecheck";
+    return "other";
+}
+/** Aggregate a record list into counts. Empty input yields an all-zero summary. */
+export function summarizeFailures(records) {
+    const byKind = {};
+    const bySource = {};
+    for (const record of records) {
+        byKind[record.kind] = (byKind[record.kind] ?? 0) + 1;
+        bySource[record.source] = (bySource[record.source] ?? 0) + 1;
+    }
+    return {
+        total: records.length,
+        byKind: Object.fromEntries(Object.entries(byKind).sort((a, b) => b[1] - a[1])),
+        bySource: Object.fromEntries(Object.entries(bySource).sort((a, b) => b[1] - a[1])),
+    };
+}
+/**
+ * Read failed review-gate records from `<baseDir>/evolve/reviews.jsonl`
+ * (outcome === "failed"). Tolerant of a missing/corrupt file.
+ */
+export function readReviewFailures(baseDir) {
+    const path = join(baseDir, "evolve", "reviews.jsonl");
+    if (!existsSync(path))
+        return [];
+    const records = [];
+    try {
+        for (const line of readFileSync(path, "utf8").split("\n")) {
+            if (line.trim().length === 0)
+                continue;
+            try {
+                const raw = JSON.parse(line);
+                if (raw.outcome !== "failed" || !raw.rationale)
+                    continue;
+                records.push({
+                    ...(raw.timestamp ? { timestamp: raw.timestamp } : {}),
+                    source: `review-gate${raw.reason ? `:${raw.reason}` : ""}`,
+                    kind: classifyFailure(raw.rationale),
+                    message: raw.rationale,
+                });
+            }
+            catch {
+                // skip malformed lines — the audit file must never break reporting
+            }
+        }
+    }
+    catch {
+        return [];
+    }
+    return records;
+}
+/**
+ * Read failed cells from every benchmark scoreboard under
+ * `<baseDir>/evolve/benchmarks/<bid>/`. Tolerant of missing/corrupt data.
+ */
+export function readBenchmarkFailures(baseDir) {
+    const root = join(baseDir, "evolve", "benchmarks");
+    if (!existsSync(root))
+        return [];
+    const records = [];
+    let bids;
+    try {
+        bids = readdirSync(root);
+    }
+    catch {
+        return [];
+    }
+    for (const bid of bids) {
+        const boardPath = join(root, bid, "scoreboard.json");
+        if (!existsSync(boardPath))
+            continue;
+        let board;
+        try {
+            board = JSON.parse(readFileSync(boardPath, "utf8"));
+        }
+        catch {
+            continue;
+        }
+        const cellLists = [];
+        if (board.reference?.cells)
+            cellLists.push({ label: "reference", cells: board.reference.cells });
+        for (const entry of board.candidates ?? []) {
+            if (entry.cells)
+                cellLists.push({ label: entry.label ?? "candidate", cells: entry.cells });
+        }
+        for (const list of cellLists) {
+            for (const cell of list.cells) {
+                const c = cell;
+                if (c.status !== "failed" || !c.notes)
+                    continue;
+                records.push({
+                    source: `benchmark:${bid}:${c.caseId ?? "?"}`,
+                    kind: classifyFailure(c.notes),
+                    message: c.notes,
+                });
+            }
+        }
+    }
+    return records;
+}
+/** Combine both sources into one summary. */
+export function collectFailureSummary(baseDir) {
+    return summarizeFailures([...readReviewFailures(baseDir), ...readBenchmarkFailures(baseDir)]);
+}
+/** Human-readable report for the command line. */
+export function formatFailureSummary(summary) {
+    const lines = [`failure summary: ${summary.total} total`];
+    const kinds = Object.entries(summary.byKind);
+    if (kinds.length > 0) {
+        lines.push("by class:");
+        for (const [kind, count] of kinds) {
+            lines.push(`  ${kind}: ${count}`);
+        }
+    }
+    else {
+        lines.push("by class: (none)");
+    }
+    const sources = Object.entries(summary.bySource);
+    if (sources.length > 0) {
+        lines.push("by source:");
+        for (const [source, count] of sources) {
+            lines.push(`  ${source}: ${count}`);
+        }
+    }
+    return lines.join("\n");
+}
+//# sourceMappingURL=failures.js.map

package/lib/fate.d.ts

@@ -81,7 +81,9 @@ export declare function fateSetKey(candidates: readonly WrapupCandidate[]): stri
  * gates respect the fate cadence (an independent counter — goal-driven
  * sessions run the review EVERY round, the fate assessment must not);
  * compaction is unconditional: experiences about to be summarized away get
- * their fate check regardless.
+ * their fate check regardless. Goal-blocked assessments are unconditional
+ * here too — the gate's own streak counter (auto.ts runGoalBlockedFate)
+ * already gates their frequency, so the cadence must not re-block them.
  */
 export declare function fateCadenceDue(state: GateState, reason: AutoRefineReason, intervalTurns: number): boolean;
 export interface FateConsultResult {

package/lib/fate.js

@@ -1,4 +1,5 @@
 import { createUserMessage } from "@deepseek-ai/dsh-llm";
+import { questionServiceOf } from "./approval.js";
 import { assessLocalEntries, candidateKey, filterPromotable, listLocalCandidates, splitArchiveGuards, splitPromoteBlocked, splitPromoteProposals, wholePromoteProposals, } from "./wrapup.js";
 /** Turns a declined local-fate proposal stays silent before being offered again. */
 export const FATE_CONSULT_COOLDOWN_TURNS = 10;
@@ -51,10 +52,13 @@ export function fateSetKey(candidates) {
  * gates respect the fate cadence (an independent counter — goal-driven
  * sessions run the review EVERY round, the fate assessment must not);
  * compaction is unconditional: experiences about to be summarized away get
- * their fate check regardless.
+ * their fate check regardless. Goal-blocked assessments are unconditional
+ * here too — the gate's own streak counter (auto.ts runGoalBlockedFate)
+ * already gates their frequency, so the cadence must not re-block them.
  */
 export function fateCadenceDue(state, reason, intervalTurns) {
-    if (reason === "compact")
+    // Compact and goal-blocked assessments bypass the cadence (see header).
+    if (reason === "compact" || reason === "goal_blocked")
         return true;
     return state.turns - state.lastFateAt >= intervalTurns;
 }
@@ -76,7 +80,7 @@ export async function consultLocalFates(ctx, agent, plan, gate) {
     if (lastReject !== undefined && gate.turns - lastReject < FATE_CONSULT_COOLDOWN_TURNS) {
         return { approved: false, asked: false, reason: "cooldown" };
     }
-    const userQuestions = ctx.userQuestions;
+    const userQuestions = questionServiceOf(ctx);
     if (!userQuestions) {
         return { approved: false, asked: false, reason: "unavailable" };
     }
@@ -197,7 +201,7 @@ export async function runLocalFatePhase(ctx, engine, agent, config, state, reaso
     const sessionId = agent.id;
     const localState = engine.load("local", sessionId);
     const globalState = engine.load("global", undefined);
-    const candidates = listLocalCandidates(localState, globalState);
+    const candidates = listLocalCandidates(localState, globalState, engine.baseDir);
     if (candidates.length === 0)
         return;
     if (!fateCadenceDue(state, reason, config.fateIntervalTurns))

package/lib/goal-command.d.ts

@@ -0,0 +1,7 @@
+/**
+ * The `/evolve goal` subcommand handler. Extracted from command.ts (P2-2).
+ */
+import type { Context } from "@deepseek-ai/cordis";
+import type { CommandInvocation, CommandResult } from "@deepseek-ai/dsh-commands";
+export declare function executeGoalCommand(ctx: Context, invocation: CommandInvocation, rest: string[]): CommandResult;
+//# sourceMappingURL=goal-command.d.ts.map

package/lib/goal-command.js

@@ -0,0 +1,37 @@
+import { blockEvolutionGoal, completeEvolutionGoal, goalServiceOf, goalStatusText, upsertEvolutionGoal } from "./goal.js";
+function success(text) {
+    return { kind: "success", text };
+}
+function error(text) {
+    return { kind: "error", text };
+}
+export function executeGoalCommand(ctx, invocation, rest) {
+    const agent = invocation.agent;
+    const goals = goalServiceOf(ctx);
+    if (!goals) {
+        return error(`/evolve goal requires the goals service (load @deepseek-ai/dsh-goal)`);
+    }
+    const sub = rest[0] ?? "";
+    try {
+        if (sub === "done") {
+            const view = completeEvolutionGoal(ctx, agent);
+            return view ? success(`evolution goal completed: ${goalStatusText(view)}`) : success("(no goal to complete)");
+        }
+        if (sub === "block") {
+            const reason = rest.slice(1).join(" ") || "user requested block";
+            const view = blockEvolutionGoal(ctx, agent, reason);
+            return view ? success(`evolution goal blocked: ${goalStatusText(view)}`) : success("(no active goal to block)");
+        }
+        if (sub.length === 0) {
+            const current = goals.get(agent);
+            return current ? success(goalStatusText(current)) : success("(no evolution goal — /evolve goal <objective> to create one)");
+        }
+        const objective = rest.join(" ");
+        const view = upsertEvolutionGoal(ctx, agent, objective);
+        return success(`evolution goal ready: ${goalStatusText(view)}\n(active goal drives the review gate every round)`);
+    }
+    catch (cause) {
+        return error(cause instanceof Error ? cause.message : String(cause));
+    }
+}
+//# sourceMappingURL=goal-command.js.map

package/lib/index.d.ts

@@ -34,6 +34,12 @@ export declare const Config: z<Schemastery.ObjectS<{
     logMaxBytes: z<number, number>;
     /** After a benchmark decision rejects a candidate, roll the refinement back automatically. */
     autoRollbackOnReject: z<boolean, boolean>;
+    /**
+     * Gap C1: optional model override for the review gate (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.
+     */
+    reviewModel: z<string, string>;
     /**
      * Gate local-fate dimension (#11 P2): the gate audits the session's local
      * entries on its own cadence and proposes promote/archive — consulted
@@ -45,6 +51,12 @@ export declare const Config: z<Schemastery.ObjectS<{
      * (compaction is unconditional). Absent → follows reviewIntervalTurns.
      */
     fateIntervalTurns: z<number, number>;
+    /**
+     * 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.
+     */
+    goalBlockedWrapupTurns: z<number, number>;
 }>, Schemastery.ObjectT<{
     /** Root for evolution stores; defaults to the resolved DSH home. */
     baseDir: z<string, string>;
@@ -74,6 +86,12 @@ export declare const Config: z<Schemastery.ObjectS<{
     logMaxBytes: z<number, number>;
     /** After a benchmark decision rejects a candidate, roll the refinement back automatically. */
     autoRollbackOnReject: z<boolean, boolean>;
+    /**
+     * Gap C1: optional model override for the review gate (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.
+     */
+    reviewModel: z<string, string>;
     /**
      * Gate local-fate dimension (#11 P2): the gate audits the session's local
      * entries on its own cadence and proposes promote/archive — consulted
@@ -85,32 +103,18 @@ export declare const Config: z<Schemastery.ObjectS<{
      * (compaction is unconditional). Absent → follows reviewIntervalTurns.
      */
     fateIntervalTurns: z<number, number>;
+    /**
+     * 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.
+     */
+    goalBlockedWrapupTurns: z<number, number>;
 }>>;
-/** Structurally typed resolved config (loader passes the validated object). */
-export interface EvolveConfig {
-    baseDir?: string;
-    sectionOrder?: number;
-    autoReview?: boolean;
-    reviewIntervalTurns?: number;
-    maxReviewInputChars?: number;
-    reviewBudgetTokens?: number;
-    notifyOnAutoReview?: boolean;
-    requireGlobalApproval?: boolean;
-    skillsDir?: string;
-    rubricKey?: string;
-    /** Write all cordis log messages to <baseDir>/evolve/plugin.log (JSONL). */
-    logToFile?: boolean;
-    /** File log level: 0=error, 1=info, 2=warn, 3=debug. */
-    logLevel?: number;
-    /** Rotate the file log when it exceeds this many bytes. */
-    logMaxBytes?: number;
-    /** After a benchmark decision rejects a candidate, roll the refinement back automatically. */
-    autoRollbackOnReject?: boolean;
-    /** Gate local-fate dimension: propose promote/archive of local entries automatically. */
-    localFate?: boolean;
-    /** Minimum turns between local-fate assessments (compaction is unconditional). */
-    fateIntervalTurns?: number;
-}
+/**
+ * Structurally typed resolved config (loader passes the validated object).
+ * Derived from the schemastery schema — single source of truth, no manual sync.
+ */
+export type EvolveConfig = Partial<Schemastery.TypeT<typeof Config>>;
 export interface EvolutionService {
     readonly engine: EvolutionEngine;
     readonly baseDir: string;

package/lib/index.js

@@ -52,6 +52,12 @@ export const Config = z.object({
     logMaxBytes: z.natural().default(5 * 1024 * 1024),
     /** After a benchmark decision rejects a candidate, roll the refinement back automatically. */
     autoRollbackOnReject: z.boolean().default(true),
+    /**
+     * Gap C1: optional model override for the review gate (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.
+     */
+    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
@@ -63,6 +69,12 @@ export const Config = z.object({
      * (compaction is unconditional). Absent → follows reviewIntervalTurns.
      */
     fateIntervalTurns: z.natural(),
+    /**
+     * 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.
+     */
+    goalBlockedWrapupTurns: z.natural().min(0).default(3),
 });
 export function apply(ctx, config) {
     const baseDir = resolveDshHome(config.baseDir);
@@ -124,6 +136,8 @@ export function apply(ctx, config) {
             notifyOnAutoReview: config.notifyOnAutoReview ?? true,
             localFate: config.localFate ?? true,
             fateIntervalTurns: config.fateIntervalTurns ?? config.reviewIntervalTurns ?? 6,
+            goalBlockedWrapupTurns: config.goalBlockedWrapupTurns ?? 3,
+            ...(config.reviewModel ? { reviewModel: config.reviewModel } : {}),
         });
         ctx.logger("continual-evolve").info(`continual-evolve auto-review enabled (every ${config.reviewIntervalTurns ?? 6} turns; local-fate ${config.localFate ?? true ? "on" : "off"} every ${config.fateIntervalTurns ?? config.reviewIntervalTurns ?? 6} turns)`);
     }

package/lib/inject.d.ts

@@ -103,6 +103,14 @@ export declare function hasAnyEntries(state: HarnessState): boolean;
 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 (`- [kind:id] title`), no content. 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.
+ */
+export declare function formatEntriesDirectory(...kindEntries: readonly HarnessEntry[][]): string;
 /**
  * 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,6 +1,7 @@
 import { isArchived } from "./types.js";
 import { mergeHarnessStates } from "./state.js";
 import { entryLine } from "./render.js";
+import { recordInjection } from "./usage.js";
 /** 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). */
@@ -183,6 +184,30 @@ 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 (`- [kind:id] title`), no content. 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.
+ */
+export function formatEntriesDirectory(...kindEntries) {
+    const allEntries = kindEntries.flat().filter((e) => !isArchived(e));
+    if (allEntries.length === 0) {
+        return "";
+    }
+    // Skip the directory when it would be redundant (all entries already shown
+    // in the curated sections above — 6/kind cap means ≤6 entries total).
+    const totalCapped = kindEntries.reduce((sum, entries) => sum + Math.min(entries.filter((e) => !isArchived(e)).length, MAX_INJECTED_ENTRIES_PER_KIND), 0);
+    if (allEntries.length <= totalCapped) {
+        return "";
+    }
+    const lines = ["# Continual Harness — Entry Directory", "All entries (use evolve_list for full text of any entry):"];
+    for (const entry of allEntries.sort((a, b) => `${a.kind}:${a.id}`.localeCompare(`${b.kind}:${b.id}`))) {
+        lines.push(`- [${entry.kind}:${entry.id}] ${entry.title}`);
+    }
+    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
@@ -222,10 +247,32 @@ export function entriesSectionText(engine, agent, query) {
     const promptEntries = Object.values(merged.entries.prompt);
     const subagentEntries = Object.values(merged.entries.subagent);
     const relevanceQuery = (query ?? recentUserText(agent)).trim();
-    const parts = [
-        formatPromptEntriesSection(promptEntries, relevanceQuery),
-        formatSubagentSpecsSection(subagentEntries, relevanceQuery),
-    ].filter((part) => part.length > 0);
+    // Build injected text and collect which entries were included (gap B1).
+    const promptText = formatPromptEntriesSection(promptEntries, relevanceQuery);
+    const subagentText = formatSubagentSpecsSection(subagentEntries, relevanceQuery);
+    const injectedKeys = [];
+    // 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.push(`prompt:${entry.id}`);
+    }
+    for (const entry of rankEntries(visibleSubagent, relevanceQuery).slice(0, MAX_INJECTED_ENTRIES_PER_KIND)) {
+        injectedKeys.push(`subagent:${entry.id}`);
+    }
+    // Record usage durably (best-effort: failure never blocks injection).
+    if (injectedKeys.length > 0) {
+        try {
+            recordInjection(engine.baseDir, injectedKeys);
+        }
+        catch {
+            // Usage recording is diagnostic; never interrupt the injection path.
+        }
+    }
+    // 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 directoryText = formatEntriesDirectory(Object.values(merged.entries.prompt), Object.values(merged.entries.memory), Object.values(merged.entries.skill), Object.values(merged.entries.subagent));
+    const parts = [promptText, subagentText, directoryText].filter((part) => part.length > 0);
     return parts.join("\n\n");
 }
 //# sourceMappingURL=inject.js.map

package/lib/llm-text.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Unified LLM text call: a shared streaming-text helper used by the review
+ * gate, planner, and wrap-up assessor. Eliminates ~120 lines of duplicated
+ * BlockAssembler + finish-state-check + text-extraction boilerplate.
+ *
+ * Every caller needs the same sequence:
+ *   provider/model validation → stream → assemble → check finish → extract text
+ * This module owns that sequence; callers keep only their prompt construction
+ * and JSON parsing.
+ */
+import type { Context } from "@deepseek-ai/cordis";
+export interface StreamTextOptions {
+    provider: string;
+    model: string;
+    system: string;
+    prompt: string;
+    maxTokens?: number;
+    signal?: AbortSignal | undefined;
+}
+/**
+ * Stream a single-turn text completion through `ctx.llm`. Forces
+ * `reasoningEffort: off` so the model spends its budget on the answer,
+ * not visible thinking (reasoning models otherwise produce zero text
+ * blocks — the exact failure recorded in FAQ #7).
+ *
+ * @returns The concatenated text blocks from the response.
+ * @throws On provider error, abort, max-token truncation, or empty output.
+ */
+export declare function streamText(ctx: Context, opts: StreamTextOptions): Promise<string>;
+//# sourceMappingURL=llm-text.d.ts.map

package/lib/llm-text.js

@@ -0,0 +1,49 @@
+import { BlockAssembler, createUserMessage, ReasoningEffortId } from "@deepseek-ai/dsh-llm";
+/**
+ * Stream a single-turn text completion through `ctx.llm`. Forces
+ * `reasoningEffort: off` so the model spends its budget on the answer,
+ * not visible thinking (reasoning models otherwise produce zero text
+ * blocks — the exact failure recorded in FAQ #7).
+ *
+ * @returns The concatenated text blocks from the response.
+ * @throws On provider error, abort, max-token truncation, or empty output.
+ */
+export async function streamText(ctx, opts) {
+    const assembler = new BlockAssembler();
+    for await (const chunk of ctx.llm.stream({
+        provider: opts.provider,
+        model: opts.model,
+        system: opts.system,
+        messages: [
+            createUserMessage({
+                content: [{ type: "text", text: opts.prompt }],
+                source: { kind: "plugin", plugin: "dsh-continual-evolve" },
+            }),
+        ],
+        reasoningEffort: ReasoningEffortId("off"),
+        maxTokens: opts.maxTokens ?? 8000,
+        ...(opts.signal ? { signal: opts.signal } : {}),
+    })) {
+        assembler.push(chunk);
+    }
+    const finish = assembler.finish;
+    if (finish.kind === "error") {
+        throw new Error(`evolve: LLM call failed: ${finish.failure?.message ?? "unknown"}`);
+    }
+    if (finish.kind === "aborted") {
+        throw new Error("evolve: LLM call aborted");
+    }
+    if (finish.kind === "max-tokens") {
+        throw new Error("evolve: LLM output budget exhausted (max-tokens)");
+    }
+    const text = assembler
+        .blocks()
+        .filter((block) => block.type === "text")
+        .map((block) => block.text)
+        .join("\n");
+    if (text.length === 0) {
+        throw new Error("evolve: LLM produced no text output");
+    }
+    return text;
+}
+//# sourceMappingURL=llm-text.js.map

package/lib/mount-command.d.ts

@@ -0,0 +1,10 @@
+/**
+ * The `/evolve mount` and `/evolve unmount` subcommand handlers.
+ * Extracted from command.ts (P2-2).
+ */
+import type { Context } from "@deepseek-ai/cordis";
+import type { CommandInvocation, CommandResult } from "@deepseek-ai/dsh-commands";
+import type { EvolutionEngine } from "./service.js";
+export declare function executeMountCommand(ctx: Context, engine: EvolutionEngine, invocation: CommandInvocation, rest: string[]): Promise<CommandResult>;
+export declare function executeUnmountCommand(ctx: Context, engine: EvolutionEngine, rest: string[]): Promise<CommandResult>;
+//# sourceMappingURL=mount-command.d.ts.map