dsh-continual-evolve 0.1.1 → 0.3.0

package/lib/fate.js

@@ -0,0 +1,342 @@
+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;
+/**
+ * Partition an assessed wrap-up classification into concrete fate actions,
+ * re-running the deterministic guards against the LIVE global store (state
+ * may have changed while the LLM call was in flight). Pure and unit-tested;
+ * mirrors the partition step of the wrap-up command.
+ */
+export function planLocalFates(items, candidates, globalState) {
+    const byKey = new Map(candidates.map((candidate) => [candidateKey(candidate.kind, candidate.id), candidate]));
+    const { promotable, skipped } = filterPromotable(items, globalState, candidates);
+    const promoteItems = promotable.filter((item) => item.verdict === "promote");
+    const archiveItems = items.filter((item) => item.verdict === "archive");
+    const splits = [];
+    const splitSkipped = [];
+    for (const item of archiveItems) {
+        if (!item.promote)
+            continue;
+        const candidate = byKey.get(item.key);
+        if (!candidate) {
+            splitSkipped.push({ key: item.key, reason: "not in the audited candidate list" });
+            continue;
+        }
+        const blocked = splitPromoteBlocked(item, globalState, candidate.kind);
+        if (blocked) {
+            splitSkipped.push({ key: item.key, reason: blocked });
+            continue;
+        }
+        splits.push({ item, candidate });
+    }
+    const plainArchives = archiveItems.filter((item) => !item.promote);
+    const { silent: silentArchives, review: reviewArchives } = splitArchiveGuards(plainArchives, candidates);
+    return { candidates, promotable: promoteItems, splits, silentArchives, reviewArchives, skipped, splitSkipped };
+}
+/**
+ * The cooldown key of a candidate set: the sorted `kind:id` list. The set is
+ * the unit of consultation — a declined proposal is not offered again within
+ * the cooldown window, and a changed set (new entries appeared) starts a
+ * fresh consultation.
+ */
+export function fateSetKey(candidates) {
+    return candidates
+        .map((candidate) => candidateKey(candidate.kind, candidate.id))
+        .sort()
+        .join("|");
+}
+/**
+ * Whether the local-fate dimension is due for this gate run. Turn-interval
+ * 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. 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) {
+    // Compact and goal-blocked assessments bypass the cadence (see header).
+    if (reason === "compact" || reason === "goal_blocked")
+        return true;
+    return state.turns - state.lastFateAt >= intervalTurns;
+}
+/**
+ * Ask the user whether to execute the gate's local-fate proposal. ONE dialog
+ * covers every governed action (promotes, split promotions, review-required
+ * archives) — the gate never spams questions. Conservative on every edge:
+ * no question service → not approved; the question call fails → not approved;
+ * the same candidate set was declined within the cooldown → not asked again.
+ * A decline records the cooldown (the consultSkillEdits pattern).
+ */
+export async function consultLocalFates(ctx, agent, plan, gate) {
+    const needsDialog = plan.promotable.length + plan.splits.length + plan.reviewArchives.length > 0;
+    if (!needsDialog) {
+        return { approved: true, asked: false, reason: "nothing-to-ask" };
+    }
+    const setKey = fateSetKey(plan.candidates);
+    const lastReject = gate.fateRejects.get(setKey);
+    if (lastReject !== undefined && gate.turns - lastReject < FATE_CONSULT_COOLDOWN_TURNS) {
+        return { approved: false, asked: false, reason: "cooldown" };
+    }
+    const userQuestions = questionServiceOf(ctx);
+    if (!userQuestions) {
+        return { approved: false, asked: false, reason: "unavailable" };
+    }
+    try {
+        const answer = await userQuestions.ask({
+            questions: [
+                {
+                    id: "evolve-fate-consult",
+                    question: consultQuestion(plan),
+                    options: [{ label: "执行" }, { label: "不执行" }],
+                },
+            ],
+            agent,
+        });
+        const approved = answer.answers?.find((entry) => entry.id === "evolve-fate-consult")?.selected?.includes("执行") ?? false;
+        if (!approved) {
+            gate.fateRejects.set(setKey, gate.turns);
+        }
+        return { approved, asked: true, reason: approved ? "consented" : "declined" };
+    }
+    catch {
+        return { approved: false, asked: true, reason: "error" };
+    }
+}
+/** The user-visible fate proposal: every governed action, with real titles. */
+function consultQuestion(plan) {
+    const byKey = new Map(plan.candidates.map((candidate) => [candidateKey(candidate.kind, candidate.id), candidate]));
+    const lines = [];
+    if (plan.promotable.length > 0 || plan.splits.length > 0) {
+        lines.push("【提升到跨会话全局 store】");
+        for (const item of plan.promotable) {
+            lines.push(`- ${item.key}「${byKey.get(item.key)?.title ?? item.key}」 — ${item.reason}`);
+        }
+        for (const { item } of plan.splits) {
+            lines.push(`- ${item.key} → 拆出提升「${item.promote?.title}」（原条目随之归档）`);
+        }
+    }
+    if (plan.reviewArchives.length > 0) {
+        lines.push("【归档（未被全局覆盖且源自真实对话，需确认）】");
+        for (const item of plan.reviewArchives) {
+            lines.push(`- ${item.key}「${byKey.get(item.key)?.title ?? item.key}」 — ${item.reason}`);
+        }
+    }
+    return [
+        "自进化门禁检测到本会话的 local 条目需要归宿处理（提升条目将写入跨会话全局 store，归档条目隐藏但可恢复）：",
+        ...lines,
+        "是否执行？",
+    ].join("\n");
+}
+/**
+ * Deterministically apply the fate plan. `"full"` applies everything
+ * (promotes, splits, silent + review archives); `"silent-only"` applies only
+ * the deterministic silent archives (the compaction path — nothing governed).
+ * Promotes go through the SAME proposals as the wrap-up command
+ * (wholePromoteProposals / splitPromoteProposals), so both paths write
+ * identical global entries and local retirement stamps.
+ */
+export function applyLocalFates(engine, sessionId, plan, localState, mode) {
+    const applied = [];
+    const results = [];
+    const byKey = new Map(plan.candidates.map((candidate) => [candidateKey(candidate.kind, candidate.id), candidate]));
+    if (mode === "full") {
+        for (const item of plan.promotable) {
+            const candidate = byKey.get(item.key);
+            if (!candidate)
+                continue;
+            const proposals = wholePromoteProposals(item, candidate, sessionId);
+            const globalResult = engine.apply("global", undefined, proposals.global, { scope: "global" });
+            const createdId = globalResult.appliedEdits.find((edit) => edit.applied)?.id ?? candidate.id;
+            const localResult = engine.apply("local", sessionId, proposals.localStamp(createdId), {
+                scope: "local",
+                baselineState: localState,
+            });
+            results.push(globalResult, localResult);
+            applied.push(`提升 ${item.key} → 全局 store（global:${createdId}，本地副本已归档）`);
+        }
+        for (const { item, candidate } of plan.splits) {
+            if (!item.promote)
+                continue;
+            const proposals = splitPromoteProposals(item, candidate, sessionId);
+            const globalResult = engine.apply("global", undefined, proposals.global, { scope: "global" });
+            const createdId = globalResult.appliedEdits.find((edit) => edit.applied)?.id ?? candidate.id;
+            const localResult = engine.apply("local", sessionId, proposals.localStamp(createdId), {
+                scope: "local",
+                baselineState: localState,
+            });
+            results.push(globalResult, localResult);
+            applied.push(`拆解 ${item.key} → 清洗「${item.promote.title}」入全局（原条目已归档）`);
+        }
+    }
+    const archives = mode === "full" ? [...plan.silentArchives, ...plan.reviewArchives] : plan.silentArchives;
+    for (const item of archives) {
+        const candidate = byKey.get(item.key);
+        if (!candidate)
+            continue;
+        const proposal = {
+            summary: `gate fate: archive local ${item.key} — ${item.reason}`,
+            rationale: item.reason,
+            expectedOutcome: "The entry stops being injected but stays restorable.",
+            edits: [{ action: "archive", kind: candidate.kind, id: candidate.id }],
+        };
+        const result = engine.apply("local", sessionId, proposal, { scope: "local", baselineState: localState });
+        results.push(result);
+        applied.push(`归档 ${item.key}「${candidate.title}」`);
+    }
+    return { applied, results };
+}
+/**
+ * The gate's local-fate phase. Runs after the review phase on every gate
+ * trigger (turn_interval / compact), subject to cadence and cooldown. All
+ * failures are contained and recorded — a broken fate dimension never
+ * disturbs the agent loop.
+ */
+export async function runLocalFatePhase(ctx, engine, agent, config, state, reason, record) {
+    if (!config.localFate)
+        return;
+    const logger = ctx.logger("continual-evolve");
+    const sessionId = agent.id;
+    const localState = engine.load("local", sessionId);
+    const globalState = engine.load("global", undefined);
+    const candidates = listLocalCandidates(localState, globalState, engine.baseDir);
+    if (candidates.length === 0)
+        return;
+    if (!fateCadenceDue(state, reason, config.fateIntervalTurns))
+        return;
+    const setKey = fateSetKey(candidates);
+    const lastReject = state.fateRejects.get(setKey);
+    if (lastReject !== undefined && state.turns - lastReject < FATE_CONSULT_COOLDOWN_TURNS) {
+        logger.info(`auto-review local-fate skipped [${sessionId}]: candidate set declined ${state.turns - lastReject} turns ago (cooldown)`);
+        return;
+    }
+    const turnsSinceFate = state.turns - state.lastFateAt;
+    state.lastFateAt = state.turns;
+    let assessment;
+    try {
+        assessment = await assessLocalEntries(ctx, agent, candidates);
+    }
+    catch (cause) {
+        const message = cause instanceof Error ? cause.message : String(cause);
+        logger.warn(`auto-review local-fate failed for ${sessionId}: ${message}`);
+        record({
+            sessionId,
+            reason,
+            turnsSinceLastReview: turnsSinceFate,
+            outcome: "failed",
+            rationale: `fate assessment error: ${message}`,
+        });
+        return;
+    }
+    const plan = planLocalFates(assessment.items, candidates, globalState);
+    const needsDialog = plan.promotable.length + plan.splits.length + plan.reviewArchives.length > 0;
+    let consent = { approved: false, asked: false, reason: "nothing-to-ask" };
+    if (reason !== "compact" && needsDialog) {
+        consent = await consultLocalFates(ctx, agent, plan, state);
+    }
+    if (consent.approved) {
+        const { applied, results } = applyLocalFates(engine, sessionId, plan, localState, "full");
+        logger.info(`auto-review local-fate approved (${reason}) [${sessionId}]: ${plan.promotable.length} promoted, ${plan.splits.length} split, ${plan.reviewArchives.length} review-archived, ${plan.silentArchives.length} silent-archived — ${assessment.rationale}`);
+        record({
+            sessionId,
+            reason,
+            turnsSinceLastReview: turnsSinceFate,
+            outcome: "approved",
+            rationale: `fate: ${assessment.rationale} (${applied.join("; ")})`,
+            refinementId: results.map((result) => result.id).join(","),
+        });
+        if (config.notifyOnAutoReview && reason === "turn_interval" && applied.length > 0) {
+            notifyFateApplied(ctx, agent, applied);
+        }
+        return;
+    }
+    if (consent.reason === "declined" || consent.reason === "unavailable" || consent.reason === "error") {
+        const withheld = consent.reason;
+        const outcome = withheld === "declined" ? "declined" : "deferred";
+        logger.info(`auto-review local-fate ${outcome} (${reason}) [${sessionId}]: ${plan.promotable.length} promotes, ${plan.splits.length} splits, ${plan.reviewArchives.length} review-archives withheld — ${assessment.rationale}`);
+        record({
+            sessionId,
+            reason,
+            turnsSinceLastReview: turnsSinceFate,
+            outcome,
+            rationale: `fate ${withheld}: ${assessment.rationale} (${plan.promotable.length} promotes, ${plan.splits.length} splits, ${plan.reviewArchives.length} review-archives withheld)`,
+        });
+        return;
+    }
+    if (reason === "compact" && needsDialog) {
+        // Compaction: no dialog. Only deterministic silent archives apply;
+        // governed actions are deferred with an audit record.
+        const { applied, results } = applyLocalFates(engine, sessionId, plan, localState, "silent-only");
+        if (applied.length > 0) {
+            logger.info(`auto-review local-fate (compact) [${sessionId}]: silent-archived ${applied.length} — ${assessment.rationale}`);
+            record({
+                sessionId,
+                reason,
+                turnsSinceLastReview: turnsSinceFate,
+                outcome: "approved",
+                rationale: `fate (compact): ${assessment.rationale} (${applied.join("; ")})`,
+                refinementId: results.map((result) => result.id).join(","),
+            });
+        }
+        record({
+            sessionId,
+            reason,
+            turnsSinceLastReview: turnsSinceFate,
+            outcome: "deferred",
+            rationale: `fate (compact): ${plan.promotable.length} promotes, ${plan.splits.length} splits, ${plan.reviewArchives.length} review-archives deferred — run /evolve wrapup for a full session exit`,
+        });
+        return;
+    }
+    // Silent archives on a plain turn-interval gate with nothing to ask.
+    if (plan.silentArchives.length > 0) {
+        const { applied, results } = applyLocalFates(engine, sessionId, plan, localState, "silent-only");
+        logger.info(`auto-review local-fate (${reason}) [${sessionId}]: silent-archived ${applied.length} covered/operational entries — ${assessment.rationale}`);
+        record({
+            sessionId,
+            reason,
+            turnsSinceLastReview: turnsSinceFate,
+            outcome: "approved",
+            rationale: `fate: ${assessment.rationale} (${applied.join("; ")})`,
+            refinementId: results.map((result) => result.id).join(","),
+        });
+        if (config.notifyOnAutoReview && reason === "turn_interval") {
+            notifyFateApplied(ctx, agent, applied);
+        }
+        return;
+    }
+    // Assessed, nothing to do.
+    logger.info(`auto-review local-fate assessed (${reason}) [${sessionId}]: ${candidates.length} candidates, no action — ${assessment.rationale}`);
+    record({
+        sessionId,
+        reason,
+        turnsSinceLastReview: turnsSinceFate,
+        outcome: "assessed",
+        rationale: `fate: ${assessment.rationale} (${candidates.length} candidates, no action)`,
+    });
+}
+/** The user-visible notice after the gate applied local-fate actions. */
+export function buildFateNotice(applied) {
+    return [
+        "🔎 自动进化门禁：本会话 local 条目归宿处理完成：",
+        applied.map((line) => `- ${line}`).join("\n"),
+        "查看全部条目：/evolve list；撤销：/evolve rollback <refinement id>",
+        "请用一句话简短确认即可，不要调用任何工具。",
+    ].join("\n");
+}
+/** Queue the follow-up notice turn (turn_interval only, like the review notice). */
+function notifyFateApplied(ctx, agent, applied) {
+    try {
+        agent.followup(createUserMessage({
+            content: [{ type: "text", text: buildFateNotice(applied) }],
+            source: { kind: "plugin", plugin: "dsh-continual-evolve" },
+        }));
+    }
+    catch (cause) {
+        ctx
+            .logger("continual-evolve")
+            .warn(`local-fate notice failed for ${agent.id}: ${cause instanceof Error ? cause.message : String(cause)}`);
+    }
+}
+//# sourceMappingURL=fate.js.map

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,29 @@ 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
+     * first, never written silently. Only meaningful with autoReview on.
+     */
+    localFate: z<boolean, boolean>;
+    /**
+     * Minimum turns between local-fate assessments on the turn-interval path
+     * (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>;
@@ -63,28 +86,35 @@ 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
+     * first, never written silently. Only meaningful with autoReview on.
+     */
+    localFate: z<boolean, boolean>;
+    /**
+     * Minimum turns between local-fate assessments on the turn-interval path
+     * (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;
-}
+/**
+ * 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,29 @@ 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
+     * first, never written silently. Only meaningful with autoReview on.
+     */
+    localFate: z.boolean().default(true),
+    /**
+     * Minimum turns between local-fate assessments on the turn-interval path
+     * (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);
@@ -59,7 +82,10 @@ export function apply(ctx, config) {
     const engine = createEvolutionEngine(baseDir, {
         onApplied: (result) => {
             try {
-                syncSkillsFromResult(skillsRoot, result);
+                const warnings = syncSkillsFromResult(skillsRoot, result);
+                for (const warning of warnings) {
+                    ctx.logger("continual-evolve").warn(warning);
+                }
             }
             catch (cause) {
                 ctx
@@ -108,8 +134,12 @@ export function apply(ctx, config) {
             maxInputChars: config.maxReviewInputChars ?? 40000,
             budgetTokens: config.reviewBudgetTokens ?? 4096,
             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)`);
+        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)`);
     }
     ctx.logger("continual-evolve").info(`continual-evolve mounted (baseDir=${baseDir})`);
 }

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