dsh-continual-evolve 0.15.12 → 0.15.13

package/lib/review.js

@@ -6,148 +6,35 @@
  * only know keep/rewrite/quarantine) and oversized rewrites degrade to
  * quarantine instead of landing.
  *
+ * This module owns the batch: the hard daily cap, the rollup, and the
+ * scheduler; the queue it drains is `review-candidates.ts`, and the per-item
+ * walk itself is a responsibility chain (`review-ring.ts`) the batch assembles
+ * once per run — gate → evolve → landing — so the order is visible in one
+ * place and each step is one link.
+ *
  * This track is independent from the extraction pipeline by construction:
  * own prompts (`review-prompt.ts`), own budget (`review_daily`), own ledger
  * (`review_log`), no cursor, no increment. It only shares the store's write
  * gates (`applyProposals` / `applySkillProposals` / `quarantine`).
  */
-import { normalizeUsage, zeroUsage } from "./token-usage.js";
-import { evolvePrompt, gatePrompt, parseEvolveAnswer, parseGateAnswer, REVIEW_CHEAP_SYSTEM_PROMPT, REVIEW_MEMORY_SYSTEM_PROMPT, REVIEW_SKILL_SYSTEM_PROMPT, } from "./review-prompt.js";
+import { runChain } from "./chain.js";
+import { resolveCallRoute } from "./llm-call.js";
 import { cwdOf } from "./memory-section.js";
-import { resolveCallRoute, streamOnce } from "./llm-call.js";
-/** A rewrite lands only when the body-length ratio stays within this bound. */
-export const REWRITE_MAGNITUDE_CAP = 0.3;
-/**
- * Output budget for one cheap-gate call: a verdict JSON **plus** the reasoning
- * a thinking model spends before emitting it. A 512-token budget cut the gate
- * off on reasoning-model calls (2026-10-13) and the cut was ledgered as a
- * route failure, so the per-item failure rate read as a network problem.
- */
-export const GATE_MAX_TOKENS = 1024;
-/** Output budget for the evolve pass: a verdict plus full replacement text. */
-export const EVOLVE_MAX_TOKENS = 4096;
+import { collectCandidates } from "./review-candidates.js";
+import { reviewChain } from "./review-ring.js";
+import { subagentLoaderFor } from "./subagent.js";
+import { zeroUsage } from "./token-usage.js";
 /** Defaults for the review settings the host may override — and edit live. */
 export const REVIEW_DEFAULT_DRY_RUN = true;
 export const REVIEW_DEFAULT_DAILY_BUDGET = 100;
 export const REVIEW_DEFAULT_BATCH_SIZE = 10;
 export const REVIEW_DEFAULT_STALE_DAYS = 30;
-/** Relative body change: |new-old| / max(old, 1). Above the cap → quarantine. */
-export function rewriteMagnitude(oldBody, newBody) {
-    return Math.abs(newBody.length - oldBody.length) / Math.max(oldBody.length, 1);
-}
 /**
- * Collect review candidates across every workspace carrying active items:
- * new items first (newest first), then corrects-linked requeues, then stale
- * requeues (30 days untouched). bounded by `limit`.
- */
-export function collectCandidates(store, opts = {}) {
-    const now = opts.now ?? Date.now();
-    const staleMs = (opts.staleDays ?? 30) * 24 * 60 * 60 * 1000;
-    const limit = opts.limit ?? 100;
-    const fresh = [];
-    const requeued = [];
-    const stale = [];
-    // One push per enumerated row: store primary keys make (workspace, kind,
-    // id) unique, so no dedup set is needed — a duplicate here would mean a
-    // store invariant broke, and failing loud beats silently merging.
-    const push = (candidate) => {
-        (candidate.priority === 0 ? fresh : candidate.priority === 1 ? requeued : stale).push(candidate);
-    };
-    const partitions = new Set();
-    for (const summary of store.listWorkspaces()) {
-        partitions.add(summary.workspaceId);
-    }
-    for (const summary of store.listSkillWorkspaces()) {
-        partitions.add(summary.workspaceId);
-    }
-    partitions.add("");
-    for (const workspaceId of partitions) {
-        const correctsTargets = new Set();
-        const memories = store.listAll(workspaceId);
-        for (const record of memories) {
-            if (record.corrects !== null && record.corrects.length > 0) {
-                correctsTargets.add(record.corrects);
-            }
-        }
-        for (const record of memories) {
-            if (record.status !== "active") {
-                continue;
-            }
-            const state = store.reviewStateOf(workspaceId, "memory", record.id);
-            const updatedAt = Date.parse(record.updatedAt) || 0;
-            if (state === undefined) {
-                push({ workspaceId, kind: "memory", id: record.id, priority: 0, title: record.title, description: record.description, body: record.body, memoryType: record.type });
-            }
-            else if (correctsTargets.has(record.id)) {
-                push({ workspaceId, kind: "memory", id: record.id, priority: 1, title: record.title, description: record.description, body: record.body, memoryType: record.type });
-            }
-            else if (now - updatedAt >= staleMs) {
-                push({ workspaceId, kind: "memory", id: record.id, priority: 2, title: record.title, description: record.description, body: record.body, memoryType: record.type });
-            }
-        }
-        const projectSeen = new Set();
-        const skillsOf = (partition, scope) => {
-            for (const record of store.listAllSkills(partition)) {
-                if (record.status !== "active" || projectSeen.has(record.id)) {
-                    continue;
-                }
-                projectSeen.add(record.id);
-                const state = store.reviewStateOf(partition, "skill", record.id);
-                const updatedAt = Date.parse(record.updatedAt) || 0;
-                const candidate = {
-                    workspaceId: partition, kind: "skill", id: record.id,
-                    priority: state === undefined ? 0 : 2,
-                    title: record.title, description: record.description, body: record.body, scope,
-                };
-                if (state === undefined || now - updatedAt >= staleMs) {
-                    push(candidate);
-                }
-            }
-        };
-        if (workspaceId !== "") {
-            skillsOf(workspaceId, "project");
-        }
-    }
-    // Global skills ride along once (project rows shadow them per id).
-    skillsGlobal(store, now, staleMs, push);
-    const byPriority = (a, b) => (a.priority - b.priority);
-    return [...fresh, ...requeued, ...stale].sort(byPriority).slice(0, limit);
-}
-function skillsGlobal(store, now, staleMs, push) {
-    const projectIds = new Set();
-    for (const summary of store.listSkillWorkspaces()) {
-        if (summary.workspaceId === "") {
-            continue;
-        }
-        for (const record of store.listAllSkills(summary.workspaceId)) {
-            // Archived rows shadow nothing (readWithScope shows the global
-            // row once the project row archives after a move-to-global).
-            if (record.status === "active") {
-                projectIds.add(record.id);
-            }
-        }
-    }
-    for (const record of store.listAllSkills("")) {
-        if (record.status !== "active" || projectIds.has(record.id)) {
-            continue;
-        }
-        const state = store.reviewStateOf("", "skill", record.id);
-        const updatedAt = Date.parse(record.updatedAt) || 0;
-        if (state === undefined || now - updatedAt >= staleMs) {
-            push({
-                workspaceId: "", kind: "skill", id: record.id,
-                priority: state === undefined ? 0 : 2,
-                title: record.title, description: record.description, body: record.body, scope: "global",
-            });
-        }
-    }
-}
-/**
- * Run one review batch: cheap gate per item, evolve pass on approval,
- * safeguards before landing, one `item-review` row per terminal path, one
- * daily merge at the end. Never throws: LLM and parse failures degrade to
- * skip rows (the run keeps going), exactly like extraction's fail-ledgered
- * discipline.
+ * Run one review batch: assemble the per-item chain once, then walk each
+ * candidate through it — cheap gate, evolve pass on approval, safeguards
+ * before landing, one `item-review` row per terminal path, one daily merge at
+ * the end. LLM and parse failures degrade to skip rows inside the chain (the
+ * run keeps going), exactly like extraction's fail-ledgered discipline.
  */
 export async function runReviewBatch(deps, candidates, opts) {
     const summary = { reviewed: 0, approved: 0, applied: 0, dropped: 0, backlog: 0, cheapToken: 0, evolveToken: 0 };
@@ -159,7 +46,10 @@ export async function runReviewBatch(deps, candidates, opts) {
     const route = opts.provider === undefined || opts.model === undefined
         ? undefined
         : { provider: opts.provider, model: opts.model };
-    const noRoute = deps.llm === undefined || route === undefined;
+    const llm = deps.llm;
+    // The environment class: one loader and one chain for the whole run, in the
+    // order the ring declares. Without a route there is no ring to walk.
+    const ring = route === undefined || llm === undefined ? undefined : assembleRing({ llm, route, sessionId: opts.sessionId });
     let position = 0;
     for (const candidate of batch) {
         const remaining = deps.store.consumeReviewBudget(opts.day, opts.budget);
@@ -183,7 +73,7 @@ export async function runReviewBatch(deps, candidates, opts) {
         else {
             requeued += 1;
         }
-        if (noRoute || route === undefined) {
+        if (route === undefined || ring === undefined) {
             deps.store.logReview({
                 runId, workspaceId: candidate.workspaceId, itemKind: candidate.kind, itemId: candidate.id,
                 verdict: "skip", reason: "no-route", applied: 0,
@@ -192,7 +82,11 @@ export async function runReviewBatch(deps, candidates, opts) {
             position += 1;
             continue;
         }
-        await reviewOne(deps, runId, candidate, opts, route, summary, skipReasons);
+        const item = {
+            deps, loader: ring.loader, route, runId, candidate, opts, summary, skipReasons,
+            gate: { usage: zeroUsage(), raw: undefined },
+        };
+        await runChain(ring.links, item);
         position += 1;
     }
     summary.backlog = Math.max(0, candidates.length - summary.reviewed - summary.dropped);
@@ -204,191 +98,15 @@ export async function runReviewBatch(deps, candidates, opts) {
     });
     return summary;
 }
-async function reviewOne(deps, runId, candidate, opts, route, summary, skipReasons) {
-    const base = {
-        runId, workspaceId: candidate.workspaceId, itemKind: candidate.kind, itemId: candidate.id,
-    };
-    // ── Cheap gate ──────────────────────────────────────────────
-    let gateUsage = zeroUsage();
-    let gateRaw;
-    try {
-        const answer = await streamOnce(deps.llm, route, opts.sessionId, REVIEW_CHEAP_SYSTEM_PROMPT, gatePrompt(candidate), GATE_MAX_TOKENS);
-        gateRaw = answer.usage;
-        const gate = parseGateAnswer(answer.text);
-        if (gate === null) {
-            // A cut gate is a failure only when no complete verdict came
-            // through: the JSON usually lands before the budget runs out, so
-            // parse first and blame the finish reason only if it did not.
-            if (answer.finish !== undefined && answer.finish !== "stop") {
-                throw new Error(`stream finished with ${answer.finish}`);
-            }
-            deps.store.logReview({ ...base, verdict: "skip", reason: "gate-parse-failed", cheapUsage: gateRaw, applied: 0 });
-            skipReasons.push("gate-parse-failed");
-            return;
-        }
-        if (!gate.worthReview) {
-            summary.cheapToken += totalOf(gateRaw);
-            deps.store.logReview({ ...base, verdict: "skip", reason: gate.reason, cheapUsage: gateRaw, applied: 0 });
-            skipReasons.push("cheap-gate");
-            return;
-        }
-        summary.cheapToken += totalOf(gateRaw);
-        gateUsage = normalizedOf(gateRaw);
-    }
-    catch (error) {
-        // The error text rides the row: a bare `gate-llm-failed` hid a ~50%
-        // per-item failure rate in production (2026-10-12) with no way to
-        // tell transient route faults from systematic ones.
-        deps.store.logReview({ ...base, verdict: "skip", reason: `gate-llm-failed: ${failureHead(error)}`, applied: 0 });
-        skipReasons.push("gate-llm-failed");
-        return;
-    }
-    summary.approved += 1;
-    // ── Evolve pass ─────────────────────────────────────────────
-    const neighbors = neighborHooks(deps.store, candidate);
-    const extra = candidate.kind === "memory" && candidate.memoryType === "feedback"
-        ? "注意：feedback 类正文必须带 Why 与 How to apply 两行。"
-        : undefined;
-    let evolveRaw;
-    try {
-        const system = candidate.kind === "memory" ? REVIEW_MEMORY_SYSTEM_PROMPT : REVIEW_SKILL_SYSTEM_PROMPT;
-        const answer = await streamOnce(deps.llm, route, opts.sessionId, system, evolvePrompt({ id: candidate.id, title: candidate.title, description: candidate.description, body: candidate.body, extra, scope: candidate.scope }, neighbors), EVOLVE_MAX_TOKENS);
-        evolveRaw = answer.usage;
-        summary.evolveToken += totalOf(evolveRaw);
-        // The evolve pass carries full replacement text: a cut stream may hold
-        // half a body, so it never becomes a verdict.
-        if (answer.finish !== undefined && answer.finish !== "stop") {
-            throw new Error(`stream finished with ${answer.finish}`);
-        }
-        const evolved = parseEvolveAnswer(answer.text);
-        if (evolved === null) {
-            deps.store.logReview({ ...base, verdict: "skip", reason: "evolve-parse-failed", cheapUsage: gateUsage, evolveUsage: evolveRaw, applied: 0 });
-            skipReasons.push("evolve-parse-failed");
-            return;
-        }
-        if (evolved.verdict === "keep") {
-            deps.store.logReview({ ...base, verdict: "keep", reason: evolved.reason, cheapUsage: gateUsage, evolveUsage: evolveRaw, applied: 0 });
-            return;
-        }
-        if (evolved.verdict === "quarantine") {
-            landQuarantine(deps, base, candidate, opts, evolved.reason, gateUsage, evolveRaw, proposedOf(evolved), summary);
-            return;
-        }
-        // ── Rewrite: magnitude cap first, dry-run second, gates last ──
-        const nextBody = evolved.body ?? candidate.body;
-        if (rewriteMagnitude(candidate.body, nextBody) > REWRITE_MAGNITUDE_CAP) {
-            landQuarantine(deps, base, candidate, opts, `幅度超限转隔离：${evolved.reason}`, gateUsage, evolveRaw, proposedOf(evolved), summary);
-            return;
-        }
-        if (opts.dryRun) {
-            deps.store.logReview({ ...base, verdict: "rewrite", reason: `试运行未落盘：${evolved.reason}`, proposed: proposedOf(evolved), cheapUsage: gateUsage, evolveUsage: evolveRaw, applied: 0 });
-            return;
-        }
-        landRewrite(deps, base, candidate, opts, evolved, gateUsage, evolveRaw, summary);
-    }
-    catch (error) {
-        deps.store.logReview({ ...base, verdict: "skip", reason: `evolve-llm-failed: ${failureHead(error)}`, cheapUsage: gateUsage, evolveUsage: evolveRaw, applied: 0 });
-        skipReasons.push("evolve-llm-failed");
-    }
-}
-/**
- * The rewrite payload a non-landing row keeps: exactly the fields the model
- * supplied, or `undefined` when it proposed no text at all.
- */
-function proposedOf(evolved) {
-    const payload = {};
-    if (evolved.title !== undefined) {
-        payload.title = evolved.title;
-    }
-    if (evolved.description !== undefined) {
-        payload.description = evolved.description;
-    }
-    if (evolved.body !== undefined) {
-        payload.body = evolved.body;
-    }
-    if (evolved.corrects !== undefined) {
-        payload.corrects = evolved.corrects;
-    }
-    return Object.keys(payload).length === 0 ? undefined : payload;
-}
-function neighborHooks(store, candidate) {
-    try {
-        if (candidate.kind === "memory") {
-            const query = candidate.title.slice(0, 60);
-            const hits = query.length >= 3 ? store.search(candidate.workspaceId, query, 5) : store.list(candidate.workspaceId).slice(0, 5);
-            return hits.filter((hit) => hit.id !== candidate.id).slice(0, 4).map((hit) => ({ id: hit.id, title: hit.title, description: hit.description }));
-        }
-        const hits = store.searchSkills(candidate.workspaceId, candidate.title.slice(0, 60), 5);
-        return hits.filter((hit) => hit.id !== candidate.id).slice(0, 4).map((hit) => ({ id: hit.id, title: hit.title, description: hit.description }));
-    }
-    catch {
-        return [];
-    }
-}
-function landQuarantine(deps, base, candidate, opts, reason, gateUsage, evolveRaw, proposed, summary) {
-    const prior = deps.store.reviewStateOf(candidate.workspaceId, candidate.kind, candidate.id)?.evolveCount ?? 0;
-    if (opts.dryRun) {
-        deps.store.logReview({ ...base, verdict: "quarantine", reason: `试运行未隔离：${reason}`, proposed, cheapUsage: gateUsage, evolveUsage: evolveRaw, applied: 0, evolveCount: prior });
-        return;
-    }
-    const ok = deps.store.quarantine(candidate.workspaceId, candidate.kind, candidate.id);
-    deps.store.logReview({
-        ...base, verdict: "quarantine", reason, cheapUsage: gateUsage, evolveUsage: evolveRaw,
-        applied: ok ? 1 : 0, evolveCount: ok ? prior + 1 : prior,
-    });
-    if (ok) {
-        summary.applied += 1;
-    }
-}
-function landRewrite(deps, base, candidate, opts, evolved, gateUsage, evolveRaw, summary) {
-    const prior = deps.store.reviewStateOf(candidate.workspaceId, candidate.kind, candidate.id)?.evolveCount ?? 0;
-    const ctx = { workspaceId: candidate.workspaceId, trigger: "item-review", sessionId: opts.sessionId, runId: base.runId, model: opts.model, decision: evolved.reason };
-    if (candidate.kind === "memory") {
-        const [outcome] = deps.store.applyProposals(ctx, [{
-                action: "update", id: candidate.id,
-                title: evolved.title, description: evolved.description, body: evolved.body,
-                corrects: evolved.corrects,
-            }]);
-        const ok = outcome !== undefined && outcome.ok;
-        deps.store.logReview({
-            ...base, verdict: "rewrite", reason: ok ? evolved.reason : `门禁拒绝：${outcome?.reason ?? "未知原因"}`,
-            cheapUsage: gateUsage, evolveUsage: evolveRaw, applied: ok ? 1 : 0, evolveCount: ok ? prior + 1 : prior,
-        });
-        if (ok) {
-            summary.applied += 1;
-        }
-        return;
-    }
-    const { outcomes } = deps.store.applySkillProposals(ctx, [{
-            action: "update", scope: candidate.scope ?? "project", id: candidate.id,
-            title: evolved.title, description: evolved.description, body: evolved.body,
-        }]);
-    const outcome = outcomes[0];
-    const ok = outcome !== undefined && outcome.ok;
-    deps.store.logReview({
-        ...base, verdict: "rewrite", reason: ok ? evolved.reason : `门禁拒绝：${outcome?.reason ?? "未知原因"}`,
-        cheapUsage: gateUsage, evolveUsage: evolveRaw, applied: ok ? 1 : 0, evolveCount: ok ? prior + 1 : prior,
-    });
-    if (ok) {
-        summary.applied += 1;
-    }
-}
-function totalOf(raw) {
-    return normalizeUsage(raw)?.total ?? 0;
-}
-/** One-line error head for ledger rows (fail-loud shape, capped length). */
-export function failureHead(error, max = 120) {
-    const message = error instanceof Error ? error.message : String(error);
-    const head = message.split("\n", 1)[0] ?? "";
-    return head.length > max ? `${head.slice(0, max)}…` : head;
-}
-function normalizedOf(raw) {
-    return normalizeUsage(raw) ?? zeroUsage();
-}
 /** Current UTC day `YYYY-MM-DD` for the hard-cap account. */
 export function todayUtc() {
     return new Date().toISOString().slice(0, 10);
 }
+/** Assemble one run's ring (simple factory: one context, one bound loader, one chain). */
+function assembleRing(call) {
+    const loader = subagentLoaderFor(call);
+    return { loader, links: reviewChain() };
+}
 /**
  * Wire the review triggers onto the host context. Global single-flight with
  * a minimum interval: turn boundaries arm the pending workspace, compaction

package/lib/store.d.ts

@@ -57,6 +57,8 @@ export interface ReviewLogEntry {
     itemId: string;
     verdict: "keep" | "rewrite" | "quarantine" | "skip";
     reason?: string | undefined;
+    /** The model this verdict ran on; `undefined` only when the run had no route at all. */
+    model?: string | undefined;
     /** Normalized usage JSON of the cheap gate call, `undefined` when skipped before any call. */
     cheapUsage?: unknown;
     /** Normalized usage JSON of the evolve call, `undefined` unless rewritten. */

package/lib/store.js

@@ -131,7 +131,8 @@ CREATE TABLE IF NOT EXISTS memory_usage (
   PRIMARY KEY (workspace_id, memory_id)
 ) STRICT;
 -- Per-item content-review verdicts (the item-review trigger's account):
--- one row per reviewed item per run. Pruned with the ledgers.
+-- one row per reviewed item per run, with the model it ran on so a failure
+-- rate can be attributed instead of guessed at. Pruned with the ledgers.
 CREATE TABLE IF NOT EXISTS review_log (
   run_id TEXT, ts TEXT NOT NULL, workspace_id TEXT,
   item_kind TEXT NOT NULL CHECK (item_kind IN ('memory','skill')),
@@ -139,6 +140,7 @@ CREATE TABLE IF NOT EXISTS review_log (
   verdict TEXT NOT NULL CHECK (verdict IN ('keep','rewrite','quarantine','skip')),
   reason TEXT,
   proposed TEXT,
+  model TEXT,
   cheap_usage TEXT, evolve_usage TEXT,
   applied INTEGER NOT NULL DEFAULT 0,
   evolve_count INTEGER NOT NULL DEFAULT 0
@@ -313,6 +315,7 @@ export async function openMemoryStore(explicitPath) {
     ensureExtractionCheapUsage(database);
     ensureExtractionCheapError(database);
     ensureReviewProposed(database);
+    ensureReviewModel(database);
     const stmts = {
         get: database.prepare("SELECT * FROM memories WHERE workspace_id = ? AND id = ?"),
         list: database.prepare(`SELECT * FROM memories WHERE workspace_id = ? AND status = 'active' ${LIST_ORDER}`),
@@ -367,8 +370,8 @@ export async function openMemoryStore(explicitPath) {
         memUseGet: database.prepare("SELECT use_count, last_used_at FROM memory_usage WHERE workspace_id = ? AND memory_id = ?"),
         memUseUpsert: database.prepare("INSERT INTO memory_usage (workspace_id, memory_id, use_count, last_used_at) VALUES (?, ?, 1, ?) " +
             "ON CONFLICT (workspace_id, memory_id) DO UPDATE SET use_count = use_count + 1, last_used_at = excluded.last_used_at"),
-        reviewLog: database.prepare("INSERT INTO review_log (run_id, ts, workspace_id, item_kind, item_id, verdict, reason, proposed, cheap_usage, evolve_usage, applied, evolve_count) " +
-            "VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)"),
+        reviewLog: database.prepare("INSERT INTO review_log (run_id, ts, workspace_id, item_kind, item_id, verdict, reason, proposed, model, cheap_usage, evolve_usage, applied, evolve_count) " +
+            "VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)"),
         reviewLast: database.prepare(`SELECT ts, applied FROM review_log WHERE workspace_id IS ? AND item_kind = ? AND item_id = ? AND NOT ${INCOMPLETE_REVIEW_SQL} ORDER BY rowid DESC LIMIT 1`),
         reviewEvolved: database.prepare("SELECT COUNT(*) AS n FROM review_log WHERE workspace_id IS ? AND item_kind = ? AND item_id = ? AND applied = 1"),
         reviewPrune: database.prepare("DELETE FROM review_log WHERE ts < ?"),
@@ -913,7 +916,7 @@ export async function openMemoryStore(explicitPath) {
             }
         },
         logReview(entry) {
-            stmts.reviewLog.run(entry.runId ?? null, new Date().toISOString(), entry.workspaceId ?? null, entry.itemKind, entry.itemId, entry.verdict, entry.reason ?? null, entry.proposed === undefined ? null : JSON.stringify(entry.proposed), entry.cheapUsage === undefined ? null : JSON.stringify(entry.cheapUsage), entry.evolveUsage === undefined ? null : JSON.stringify(entry.evolveUsage), entry.applied ?? 0, entry.evolveCount ?? 0);
+            stmts.reviewLog.run(entry.runId ?? null, new Date().toISOString(), entry.workspaceId ?? null, entry.itemKind, entry.itemId, entry.verdict, entry.reason ?? null, entry.proposed === undefined ? null : JSON.stringify(entry.proposed), entry.model ?? null, entry.cheapUsage === undefined ? null : JSON.stringify(entry.cheapUsage), entry.evolveUsage === undefined ? null : JSON.stringify(entry.evolveUsage), entry.applied ?? 0, entry.evolveCount ?? 0);
         },
         consumeReviewBudget(day, budget) {
             stmts.dailyUpsert.run(day, budget);
@@ -1038,6 +1041,18 @@ function ensureReviewProposed(database) {
     }
     database.exec("ALTER TABLE review_log ADD COLUMN proposed TEXT");
 }
+/**
+ * Add the review ledger `model` column to a store created before verdict rows
+ * recorded the model they ran on. Same single-migration discipline as the
+ * columns above.
+ */
+function ensureReviewModel(database) {
+    const columns = database.prepare("SELECT name FROM pragma_table_info('review_log')").all();
+    if (columns.some((column) => column.name === "model")) {
+        return;
+    }
+    database.exec("ALTER TABLE review_log ADD COLUMN model TEXT");
+}
 /** Parse the daily skip-counts map; corrupt payloads degrade to empty. */
 function parseCounts(raw) {
     if (raw === null) {

package/lib/subagent-defs.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Every subagent this plugin runs, declared in one table.
+ *
+ * A definition carries the job's identity, its whole instruction (system
+ * prompt), its output-budget fallback and its answer parser. Feature code
+ * loads definitions from here and never writes a prompt or a budget inline;
+ * adding a job means adding a row, and a job with no row cannot be called.
+ *
+ * The four review jobs are separate definitions on purpose: the memory rubric
+ * requires a memory to survive having its repo name stripped, while a project
+ * skill is *supposed* to be repo-bound, so one prompt cannot serve both.
+ */
+import { type CheapVerdict, type ParsedAnswer } from "./extraction-prompt.js";
+import { type EvolveVerdict, type GateVerdict } from "./review-prompt.js";
+import type { SubagentDefinition } from "./subagent.js";
+/**
+ * Output-budget fallbacks, used only for adapters that advertise no
+ * per-request cap of their own. A gate verdict is one JSON object plus the
+ * reasoning a thinking model spends before emitting it; the evolve/proposal
+ * calls additionally carry full replacement bodies.
+ */
+export declare const GATE_MAX_TOKENS = 1024;
+export declare const EVOLVE_MAX_TOKENS = 4096;
+export declare const EXTRACTION_MAX_TOKENS = 4096;
+/** The memory cheap gate: is this entry worth a close look at all? */
+export declare const reviewGateMemory: SubagentDefinition<GateVerdict | null>;
+/** The skill cheap gate: same question, scope-relative home rules. */
+export declare const reviewGateSkill: SubagentDefinition<GateVerdict | null>;
+/** The memory evolve pass: five-dimension judgment plus the proposed rewrite. */
+export declare const reviewEvolveMemory: SubagentDefinition<EvolveVerdict | null>;
+/** The skill evolve pass: scope-relative reuse, executability, duplication. */
+export declare const reviewEvolveSkill: SubagentDefinition<EvolveVerdict | null>;
+/** The extraction pre-gate: does this increment hold anything worth proposing? */
+export declare const extractionGate: SubagentDefinition<CheapVerdict | null>;
+/** The extraction proposal call: the run's one expensive call. */
+export declare const extractionMain: SubagentDefinition<ParsedAnswer>;
+/** Every definition, for the "which jobs exist" read and the id-uniqueness check. */
+export declare const SUBAGENT_DEFINITIONS: readonly SubagentDefinition<unknown>[];
+/** The gate definition one review candidate loads, by item kind. */
+export declare const REVIEW_GATE_BY_KIND: Readonly<Record<"memory" | "skill", SubagentDefinition<GateVerdict | null>>>;
+/** The evolve definition one review candidate loads, by item kind. */
+export declare const REVIEW_EVOLVE_BY_KIND: Readonly<Record<"memory" | "skill", SubagentDefinition<EvolveVerdict | null>>>;
+//# sourceMappingURL=subagent-defs.d.ts.map

package/lib/subagent-defs.js

@@ -0,0 +1,85 @@
+/**
+ * Every subagent this plugin runs, declared in one table.
+ *
+ * A definition carries the job's identity, its whole instruction (system
+ * prompt), its output-budget fallback and its answer parser. Feature code
+ * loads definitions from here and never writes a prompt or a budget inline;
+ * adding a job means adding a row, and a job with no row cannot be called.
+ *
+ * The four review jobs are separate definitions on purpose: the memory rubric
+ * requires a memory to survive having its repo name stripped, while a project
+ * skill is *supposed* to be repo-bound, so one prompt cannot serve both.
+ */
+import { EXTRACTION_CHEAP_SYSTEM_PROMPT, EXTRACTION_SYSTEM_PROMPT, parseCheapAnswer, parseExtractionAnswer, } from "./extraction-prompt.js";
+import { parseEvolveAnswer, parseGateAnswer, REVIEW_MEMORY_CHEAP_SYSTEM_PROMPT, REVIEW_MEMORY_SYSTEM_PROMPT, REVIEW_SKILL_CHEAP_SYSTEM_PROMPT, REVIEW_SKILL_SYSTEM_PROMPT, } from "./review-prompt.js";
+/**
+ * Output-budget fallbacks, used only for adapters that advertise no
+ * per-request cap of their own. A gate verdict is one JSON object plus the
+ * reasoning a thinking model spends before emitting it; the evolve/proposal
+ * calls additionally carry full replacement bodies.
+ */
+export const GATE_MAX_TOKENS = 1024;
+export const EVOLVE_MAX_TOKENS = 4096;
+export const EXTRACTION_MAX_TOKENS = 4096;
+/** The memory cheap gate: is this entry worth a close look at all? */
+export const reviewGateMemory = {
+    id: "review-gate-memory",
+    system: REVIEW_MEMORY_CHEAP_SYSTEM_PROMPT,
+    maxTokens: GATE_MAX_TOKENS,
+    parse: (text) => parseGateAnswer(text),
+};
+/** The skill cheap gate: same question, scope-relative home rules. */
+export const reviewGateSkill = {
+    id: "review-gate-skill",
+    system: REVIEW_SKILL_CHEAP_SYSTEM_PROMPT,
+    maxTokens: GATE_MAX_TOKENS,
+    parse: (text) => parseGateAnswer(text),
+};
+/** The memory evolve pass: five-dimension judgment plus the proposed rewrite. */
+export const reviewEvolveMemory = {
+    id: "review-evolve-memory",
+    system: REVIEW_MEMORY_SYSTEM_PROMPT,
+    maxTokens: EVOLVE_MAX_TOKENS,
+    parse: (text) => parseEvolveAnswer(text),
+};
+/** The skill evolve pass: scope-relative reuse, executability, duplication. */
+export const reviewEvolveSkill = {
+    id: "review-evolve-skill",
+    system: REVIEW_SKILL_SYSTEM_PROMPT,
+    maxTokens: EVOLVE_MAX_TOKENS,
+    parse: (text) => parseEvolveAnswer(text),
+};
+/** The extraction pre-gate: does this increment hold anything worth proposing? */
+export const extractionGate = {
+    id: "extraction-gate",
+    system: EXTRACTION_CHEAP_SYSTEM_PROMPT,
+    maxTokens: GATE_MAX_TOKENS,
+    parse: (text) => parseCheapAnswer(text),
+};
+/** The extraction proposal call: the run's one expensive call. */
+export const extractionMain = {
+    id: "extraction-main",
+    system: EXTRACTION_SYSTEM_PROMPT,
+    maxTokens: EXTRACTION_MAX_TOKENS,
+    parse: (text) => parseExtractionAnswer(text),
+};
+/** Every definition, for the "which jobs exist" read and the id-uniqueness check. */
+export const SUBAGENT_DEFINITIONS = [
+    reviewGateMemory,
+    reviewGateSkill,
+    reviewEvolveMemory,
+    reviewEvolveSkill,
+    extractionGate,
+    extractionMain,
+];
+/** The gate definition one review candidate loads, by item kind. */
+export const REVIEW_GATE_BY_KIND = {
+    memory: reviewGateMemory,
+    skill: reviewGateSkill,
+};
+/** The evolve definition one review candidate loads, by item kind. */
+export const REVIEW_EVOLVE_BY_KIND = {
+    memory: reviewEvolveMemory,
+    skill: reviewEvolveSkill,
+};
+//# sourceMappingURL=subagent-defs.js.map