dsh-continual-evolve 0.15.11 → 0.15.13

package/lib/review-ring.js

@@ -0,0 +1,257 @@
+import { observedUsageOf } from "./llm-call.js";
+import { evolvePrompt, gatePrompt } from "./review-prompt.js";
+import { REVIEW_EVOLVE_BY_KIND, REVIEW_GATE_BY_KIND } from "./subagent-defs.js";
+import { cutFailureOf } from "./subagent.js";
+import { normalizeUsage, zeroUsage } from "./token-usage.js";
+/** A rewrite lands only when the body-length ratio stays within this bound. */
+export const REWRITE_MAGNITUDE_CAP = 0.3;
+/**
+ * Assemble the review chain: the environment class owns the order, the links
+ * own their step, and the item carries the run's loader and route.
+ *
+ * @returns The chain, in order, ending in the landing link.
+ */
+export function reviewChain() {
+    return [gateLink(), evolveLink(), landLink()];
+}
+/** Cheap gate: decide whether the item deserves the expensive pass at all. */
+function gateLink() {
+    return {
+        name: "review-gate",
+        async handle(item) {
+            const { deps, candidate } = item;
+            const base = rowBaseOf(item);
+            try {
+                const answer = await item.loader.run(REVIEW_GATE_BY_KIND[candidate.kind], gatePrompt(candidate));
+                const verdict = answer.answer;
+                if (verdict === 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 cutFailureOf(answer, item.route);
+                    }
+                    deps.store.logReview({ ...base, verdict: "skip", reason: "gate-parse-failed", cheapUsage: answer.usage, applied: 0 });
+                    item.skipReasons.push("gate-parse-failed");
+                    return "handled";
+                }
+                if (!verdict.worthReview) {
+                    item.summary.cheapToken += totalOf(answer.usage);
+                    deps.store.logReview({ ...base, verdict: "skip", reason: verdict.reason, cheapUsage: answer.usage, applied: 0 });
+                    item.skipReasons.push("cheap-gate");
+                    return "handled";
+                }
+                item.summary.cheapToken += totalOf(answer.usage);
+                item.gate = { usage: normalizedOf(answer.usage), raw: answer.usage };
+                // Approved counts the gate's decision, not the outcome: the
+                // evolve leg may still fail and ledger its own skip row.
+                item.summary.approved += 1;
+                return "next";
+            }
+            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 — and the usage
+                // the call already reported rides it too, or a failed call burns
+                // tokens that no account shows.
+                deps.store.logReview({
+                    ...base, verdict: "skip", reason: `gate-llm-failed: ${failureHead(error)}`,
+                    cheapUsage: observedUsageOf(error), applied: 0,
+                });
+                item.skipReasons.push("gate-llm-failed");
+                return "handled";
+            }
+        },
+    };
+}
+/** The evolve pass: judge the item and produce a verdict, or ledger why not. */
+function evolveLink() {
+    return {
+        name: "review-evolve",
+        async handle(item) {
+            const { deps, candidate } = item;
+            const base = rowBaseOf(item);
+            try {
+                const definition = REVIEW_EVOLVE_BY_KIND[candidate.kind];
+                const neighbors = neighborHooks(deps.store, candidate);
+                const answer = await item.loader.run(definition, evolvePrompt({ id: candidate.id, title: candidate.title, description: candidate.description, body: candidate.body, scope: candidate.scope }, neighbors));
+                item.evolveUsage = answer.usage;
+                item.summary.evolveToken += totalOf(answer.usage);
+                // 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 cutFailureOf(answer, item.route);
+                }
+                if (answer.answer === null) {
+                    deps.store.logReview({
+                        ...base, verdict: "skip", reason: "evolve-parse-failed",
+                        cheapUsage: item.gate.usage, evolveUsage: item.evolveUsage, applied: 0,
+                    });
+                    item.skipReasons.push("evolve-parse-failed");
+                    return "handled";
+                }
+                item.evolved = answer.answer;
+                return "next";
+            }
+            catch (error) {
+                deps.store.logReview({
+                    ...base, verdict: "skip", reason: `evolve-llm-failed: ${failureHead(error)}`,
+                    cheapUsage: item.gate.usage, evolveUsage: observedUsageOf(error) ?? item.evolveUsage, applied: 0,
+                });
+                item.skipReasons.push("evolve-llm-failed");
+                return "handled";
+            }
+        },
+    };
+}
+/** Landing: turn one verdict into a row, and (outside dry-run) into a change. */
+function landLink() {
+    return {
+        name: "review-land",
+        handle(item) {
+            const evolved = item.evolved;
+            if (evolved === undefined) {
+                // A landing link reached without a verdict is a wiring bug: fail
+                // loud instead of writing a row with nothing behind it.
+                throw new Error(`review landing reached without a verdict for ${item.candidate.kind} ${item.candidate.id}`);
+            }
+            if (evolved.verdict === "keep") {
+                item.deps.store.logReview({
+                    ...rowBaseOf(item), verdict: "keep", reason: evolved.reason,
+                    cheapUsage: item.gate.usage, evolveUsage: item.evolveUsage, applied: 0,
+                });
+                return "handled";
+            }
+            if (evolved.verdict === "quarantine") {
+                landQuarantine(item, evolved, evolved.reason);
+                return "handled";
+            }
+            // Rewrite: magnitude cap first, dry-run second, gates last.
+            const nextBody = evolved.body ?? item.candidate.body;
+            if (rewriteMagnitude(item.candidate.body, nextBody) > REWRITE_MAGNITUDE_CAP) {
+                landQuarantine(item, evolved, `幅度超限转隔离：${evolved.reason}`);
+                return "handled";
+            }
+            if (item.opts.dryRun) {
+                item.deps.store.logReview({
+                    ...rowBaseOf(item), verdict: "rewrite", reason: `试运行未落盘：${evolved.reason}`,
+                    proposed: proposedOf(evolved), cheapUsage: item.gate.usage, evolveUsage: item.evolveUsage, applied: 0,
+                });
+                return "handled";
+            }
+            landRewrite(item, evolved);
+            return "handled";
+        },
+    };
+}
+/** Quarantine (or, in trial mode, the row it would have written). */
+function landQuarantine(item, evolved, reason) {
+    const { deps, candidate, opts, summary } = item;
+    const prior = evolveCountOf(deps.store, candidate);
+    if (opts.dryRun) {
+        deps.store.logReview({
+            ...rowBaseOf(item), verdict: "quarantine", reason: `试运行未隔离：${reason}`, proposed: proposedOf(evolved),
+            cheapUsage: item.gate.usage, evolveUsage: item.evolveUsage, applied: 0, evolveCount: prior,
+        });
+        return;
+    }
+    const ok = deps.store.quarantine(candidate.workspaceId, candidate.kind, candidate.id);
+    deps.store.logReview({
+        ...rowBaseOf(item), verdict: "quarantine", reason,
+        cheapUsage: item.gate.usage, evolveUsage: item.evolveUsage,
+        applied: ok ? 1 : 0, evolveCount: ok ? prior + 1 : prior,
+    });
+    if (ok) {
+        summary.applied += 1;
+    }
+}
+/** Apply one rewrite through the store's write gates. */
+function landRewrite(item, evolved) {
+    const { deps, candidate, opts, summary } = item;
+    const prior = evolveCountOf(deps.store, candidate);
+    const ctx = {
+        workspaceId: candidate.workspaceId, trigger: "item-review",
+        sessionId: opts.sessionId, runId: item.runId, model: opts.model, decision: evolved.reason,
+    };
+    const outcome = candidate.kind === "memory"
+        ? deps.store.applyProposals(ctx, [{
+                action: "update", id: candidate.id,
+                title: evolved.title, description: evolved.description, body: evolved.body, corrects: evolved.corrects,
+            }])[0]
+        : deps.store.applySkillProposals(ctx, [{
+                action: "update", scope: candidate.scope ?? "project", id: candidate.id,
+                title: evolved.title, description: evolved.description, body: evolved.body,
+            }]).outcomes[0];
+    const ok = outcome !== undefined && outcome.ok;
+    deps.store.logReview({
+        ...rowBaseOf(item), verdict: "rewrite", reason: ok ? evolved.reason : `门禁拒绝：${outcome?.reason ?? "未知原因"}`,
+        cheapUsage: item.gate.usage, evolveUsage: item.evolveUsage, applied: ok ? 1 : 0, evolveCount: ok ? prior + 1 : prior,
+    });
+    if (ok) {
+        summary.applied += 1;
+    }
+}
+function rowBaseOf(item) {
+    return {
+        runId: item.runId,
+        workspaceId: item.candidate.workspaceId,
+        itemKind: item.candidate.kind,
+        itemId: item.candidate.id,
+        model: item.route.model,
+    };
+}
+function evolveCountOf(store, candidate) {
+    return store.reviewStateOf(candidate.workspaceId, candidate.kind, candidate.id)?.evolveCount ?? 0;
+}
+/**
+ * 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;
+}
+/** Similar existing items (hooks only) for the model's duplication check. */
+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 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;
+}
+/** 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);
+}
+function normalizedOf(raw) {
+    return normalizeUsage(raw) ?? zeroUsage();
+}
+//# sourceMappingURL=review-ring.js.map

package/lib/review.d.ts

@@ -1,11 +1,16 @@
+import { type LlmRuntime, type RouteResolver } from "./llm-call.js";
 import type { MemoryStore } from "./store.js";
-/** The minimal LLM face review calls (same duck-typed host service as extraction). */
-export interface ReviewLlm {
-    stream(options: Record<string, unknown>): AsyncIterable<unknown>;
-}
+/** The LLM face review calls, aliased so each scheduler can name its own. */
+export type ReviewLlm = LlmRuntime;
 export interface ReviewDeps {
     store: MemoryStore;
-    llm: ReviewLlm | undefined;
+    llm: LlmRuntime | undefined;
+    /**
+     * Route resolution for a direct call: the agent's explicit selection first,
+     * the host default model second. Absent keeps the legacy agent-options-only
+     * behavior (tests and older hosts).
+     */
+    resolveRoute?: RouteResolver | undefined;
 }
 export interface ReviewCandidate {
     workspaceId: string;
@@ -46,42 +51,19 @@ export interface ReviewRunSummary {
     cheapToken: number;
     evolveToken: number;
 }
-/** A rewrite lands only when the body-length ratio stays within this bound. */
-export declare 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 declare const GATE_MAX_TOKENS = 1024;
 /** Defaults for the review settings the host may override — and edit live. */
 export declare const REVIEW_DEFAULT_DRY_RUN = true;
 export declare const REVIEW_DEFAULT_DAILY_BUDGET = 100;
 export declare const REVIEW_DEFAULT_BATCH_SIZE = 10;
 export declare const REVIEW_DEFAULT_STALE_DAYS = 30;
-/** Relative body change: |new-old| / max(old, 1). Above the cap → quarantine. */
-export declare function rewriteMagnitude(oldBody: string, newBody: string): number;
-/**
- * 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 declare function collectCandidates(store: MemoryStore, opts?: {
-    now?: number | undefined;
-    staleDays?: number | undefined;
-    limit?: number | undefined;
-}): ReviewCandidate[];
 /**
- * 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 declare function runReviewBatch(deps: ReviewDeps, candidates: readonly ReviewCandidate[], opts: ReviewRunOptions): Promise<ReviewRunSummary>;
-/** One-line error head for ledger rows (fail-loud shape, capped length). */
-export declare function failureHead(error: unknown, max?: number): string;
 /** Current UTC day `YYYY-MM-DD` for the hard-cap account. */
 export declare function todayUtc(): string;
 /** The event wiring surface (duck-typed cordis context, mirrors extraction). */