dsh-continual-evolve 0.2.0 → 0.4.0

package/lib/evolve-event.d.ts

@@ -0,0 +1,38 @@
+import type { RefinementResult } from "./types.js";
+/** The structured event payload emitted after every successful refinement. */
+export interface EvolveCompleteEvent {
+    /** Event discriminator for consumers. */
+    type: "evolve_complete";
+    /** The refinement id (same as the result). */
+    refinementId: string;
+    /** One-line summary of the refinement. */
+    summary: string;
+    /** Number of edits that were actually applied. */
+    appliedEdits: number;
+    /** Number of edits that failed to apply. */
+    failedEdits: number;
+    /** Scope of the refinement ("local" or "global"). */
+    scope: string;
+    /** What triggered this refinement (e.g. "auto_review", "manual_plan", "manual_tool"). */
+    trigger: string;
+    /** Session id that owns the refinement (auto or manual). */
+    sessionId: string;
+    /** ISO timestamp. */
+    timestamp: string;
+    /** Per-edit summaries (kind + id + action) for consumers that want detail. */
+    edits: {
+        action: string;
+        kind: string;
+        id: string;
+        applied: boolean;
+    }[];
+}
+/** Build a structured evolve-complete event from a refinement result. */
+export declare function buildEvolveCompleteEvent(result: RefinementResult, trigger: string, sessionId: string): EvolveCompleteEvent;
+/**
+ * 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 declare function emitEvolveComplete(baseDir: string, event: EvolveCompleteEvent): void;
+//# sourceMappingURL=evolve-event.d.ts.map

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

@@ -34,6 +34,7 @@ import type { HarnessState, RefinementResult } from "./types.js";
 import type { EvolutionEngine } from "./service.js";
 import type { AutoRefineReason } from "./review.js";
 import type { AutoReviewConfig, GateState, ReviewRecord } from "./auto.js";
+import { type PromotionPolicy } from "./promotion.js";
 import { type WrapupCandidate, type WrapupItem } from "./wrapup.js";
 /** Turns a declined local-fate proposal stays silent before being offered again. */
 export declare const FATE_CONSULT_COOLDOWN_TURNS = 10;
@@ -68,7 +69,7 @@ export interface FatePlan {
  * may have changed while the LLM call was in flight). Pure and unit-tested;
  * mirrors the partition step of the wrap-up command.
  */
-export declare function planLocalFates(items: readonly WrapupItem[], candidates: readonly WrapupCandidate[], globalState: HarnessState): FatePlan;
+export declare function planLocalFates(items: readonly WrapupItem[], candidates: readonly WrapupCandidate[], globalState: HarnessState, policy?: PromotionPolicy): FatePlan;
 /**
  * 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
@@ -81,7 +82,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,6 @@
 import { createUserMessage } from "@deepseek-ai/dsh-llm";
+import { DEFAULT_PROMOTION_POLICY } from "./promotion.js";
+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;
@@ -8,9 +10,9 @@ export const FATE_CONSULT_COOLDOWN_TURNS = 10;
  * 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) {
+export function planLocalFates(items, candidates, globalState, policy = DEFAULT_PROMOTION_POLICY) {
     const byKey = new Map(candidates.map((candidate) => [candidateKey(candidate.kind, candidate.id), candidate]));
-    const { promotable, skipped } = filterPromotable(items, globalState, candidates);
+    const { promotable, skipped } = filterPromotable(items, globalState, candidates, policy);
     const promoteItems = promotable.filter((item) => item.verdict === "promote");
     const archiveItems = items.filter((item) => item.verdict === "archive");
     const splits = [];
@@ -23,7 +25,7 @@ export function planLocalFates(items, candidates, globalState) {
             splitSkipped.push({ key: item.key, reason: "not in the audited candidate list" });
             continue;
         }
-        const blocked = splitPromoteBlocked(item, globalState, candidate.kind);
+        const blocked = splitPromoteBlocked(item, globalState, candidate.kind, policy);
         if (blocked) {
             splitSkipped.push({ key: item.key, reason: blocked });
             continue;
@@ -51,10 +53,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 +81,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 +202,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))
@@ -226,7 +231,7 @@ export async function runLocalFatePhase(ctx, engine, agent, config, state, reaso
         });
         return;
     }
-    const plan = planLocalFates(assessment.items, candidates, globalState);
+    const plan = planLocalFates(assessment.items, candidates, globalState, config.promotionPolicy);
     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) {

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,23 @@ 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>;
+    /**
+     * 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.
+     */
+    promotionBlockPatterns: z<string[], string[]>;
+    /** Whole promotions below this content length stay local (chars). */
+    promotionMinChars: z<number, number>;
+    /** Entry-directory lines injected per build before folding into a counter. */
+    injectionDirectoryLines: z<number, number>;
 }>, Schemastery.ObjectT<{
     /** Root for evolution stores; defaults to the resolved DSH home. */
     baseDir: z<string, string>;
@@ -74,6 +97,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 +114,29 @@ 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>;
+    /**
+     * 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.
+     */
+    promotionBlockPatterns: z<string[], string[]>;
+    /** Whole promotions below this content length stay local (chars). */
+    promotionMinChars: z<number, number>;
+    /** Entry-directory lines injected per build before folding into a counter. */
+    injectionDirectoryLines: 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

@@ -19,6 +19,7 @@ import { entriesSectionText } from "./inject.js";
 import { resolveRubricKey } from "./rubric.js";
 import { restoreMounted } from "./mount.js";
 import { registerFileLogger } from "./logfile.js";
+import { resolvePromotionPolicy } from "./promotion.js";
 export const name = "continual-evolve";
 /** Service key under which the evolution engine is published. */
 export const EVOLUTION_SERVICE = "evolution";
@@ -52,6 +53,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 +70,23 @@ 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),
+    /**
+     * 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.
+     */
+    promotionBlockPatterns: z.array(z.string()),
+    /** Whole promotions below this content length stay local (chars). */
+    promotionMinChars: z.natural().default(100),
+    /** Entry-directory lines injected per build before folding into a counter. */
+    injectionDirectoryLines: z.natural().default(15),
 });
 export function apply(ctx, config) {
     const baseDir = resolveDshHome(config.baseDir);
@@ -95,13 +119,18 @@ export function apply(ctx, config) {
     ctx.systemPrompt.section({
         name: "tool:continual-evolve:entries",
         order: (config.sectionOrder ?? 118) + 1,
-        text: (context) => entriesSectionText(engine, context.agent),
+        text: (context) => entriesSectionText(engine, context.agent, undefined, { directoryLines: config.injectionDirectoryLines ?? 15 }),
     });
     const gate = { requireGlobalApproval: config.requireGlobalApproval ?? true };
+    const promotionPolicy = resolvePromotionPolicy({
+        blockPatterns: config.promotionBlockPatterns,
+        minPromoteChars: config.promotionMinChars,
+    });
     registerEvolveTools(ctx, engine, gate);
     registerEvolveCommand(ctx, engine, gate, {
         rubricKey: resolveRubricKey(baseDir, config.rubricKey, process.env, (m) => ctx.logger("continual-evolve").warn(m)),
         autoRollbackOnReject: config.autoRollbackOnReject ?? true,
+        promotionPolicy,
     });
     // Plugin-owned file logging: every cordis log message lands in
     // <baseDir>/evolve/plugin.log regardless of how dsh web was launched —
@@ -124,6 +153,9 @@ export function apply(ctx, config) {
             notifyOnAutoReview: config.notifyOnAutoReview ?? true,
             localFate: config.localFate ?? true,
             fateIntervalTurns: config.fateIntervalTurns ?? config.reviewIntervalTurns ?? 6,
+            goalBlockedWrapupTurns: config.goalBlockedWrapupTurns ?? 3,
+            promotionPolicy,
+            ...(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,22 @@ 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.
+ *
+ * 2026-08-22 throttle: the directory is CAPPED at {@link DEFAULT_DIRECTORY_LINES}
+ * lines (oldest-sorted stable order) 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.
+ */
+export declare const DEFAULT_DIRECTORY_LINES = 15;
+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;
 /**
  * Walk the parent-session chain from `agent` upward and return the nearest
  * session whose local store is non-empty, if any. Children inherit their
@@ -119,6 +135,13 @@ export declare function nearestLocalStateWithEntries(engine: EvolutionEngine, ag
  * (relevance first, then recency; see {@link rankEntries}). Returns "" when
  * nothing is injectable — the prompt renderer then drops the section, so an
  * empty store adds zero tokens to every assembly.
+ *
+ * `opts.directoryLines` caps the entry-directory index (2026-08-22 throttle).
+ * Usage recording covers ALL kinds — memories and skills appear as directory
+ * lines, prompts/subagents as content — and is deduped per session so the
+ * counts read "how many sessions saw this", not "how many prompt builds".
  */
-export declare function entriesSectionText(engine: EvolutionEngine, agent: AgentLike | undefined, query?: string): string;
+export declare function entriesSectionText(engine: EvolutionEngine, agent: AgentLike | undefined, query?: string, opts?: {
+    directoryLines?: number;
+}): string;
 //# sourceMappingURL=inject.d.ts.map