dsh-continual-evolve 0.15.11 → 0.15.13

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

package/lib/subagent.d.ts

@@ -0,0 +1,81 @@
+/**
+ * The generic subagent and its loader: the only path from plugin feature code
+ * to an LLM call.
+ *
+ * A subagent is data — a strategy holding its identity, system prompt, output
+ * budget fallback and answer parser. The loader binds that strategy to one
+ * route and session, then runs it through one fixed skeleton (the template
+ * method): assemble the call, stream it, parse the answer, account for what
+ * happened. Failure accounting rides the same skeleton as success: the route
+ * and the usage a stream reported before it died come back on the thrown
+ * error, so a failed call can be audited exactly like a successful one.
+ *
+ * The structure is the point. "Which subagents exist and what each one is
+ * told" is readable in one table (`subagent-defs.ts`) instead of being spread
+ * across call sites, and a job that has no definition cannot be called.
+ */
+import { SubagentCallError, type LlmRuntime, type ModelSelection } from "./llm-call.js";
+/** One subagent definition: everything that distinguishes one job from another. */
+export interface SubagentDefinition<Answer> {
+    /** The job's name, for diagnostics; unique across the registry (asserted by test). */
+    readonly id: string;
+    /** The job's entire instruction, sent as the system prompt — nothing is appended at the call site. */
+    readonly system: string;
+    /** Output budget fallback; the exact model's advertised cap wins when it has one. */
+    readonly maxTokens: number;
+    /**
+     * Parse the answer text into this definition's answer type. A parser that
+     * can miss (`parseGateAnswer`, `parseCheapAnswer` …) includes `null` in its
+     * answer type: "no answer in the agreed shape" is a value, not a throw.
+     */
+    readonly parse: (text: string) => Answer;
+}
+/** What one call is bound to: the LLM service, the exact route, the session identity. */
+export interface SubagentCall {
+    llm: LlmRuntime | undefined;
+    route: ModelSelection;
+    sessionId: string | undefined;
+}
+/** One finished call: the parsed answer, the raw text, and the observed call facts. */
+export interface SubagentAnswer<Answer> {
+    answer: Answer;
+    text: string;
+    /** The provider's usage payload, exactly as observed; `undefined` when it reported none. */
+    usage: unknown;
+    /** The terminal finish kind (`stop`, `max-tokens`, …); `undefined` when the stream omitted it. */
+    finish: string | undefined;
+}
+/** The loader feature code holds: bound to one route/session, it runs definitions. */
+export interface SubagentLoader {
+    /**
+     * Run one definition once.
+     *
+     * @param definition - The subagent strategy to run.
+     * @param prompt - This call's user prompt.
+     * @returns The parsed answer plus the observed usage and finish kind.
+     * @throws On call failures (a `SubagentCallError` carries the observed usage and route) or a missing route.
+     */
+    run<Answer>(definition: SubagentDefinition<Answer>, prompt: string): Promise<SubagentAnswer<Answer>>;
+}
+/**
+ * Build the loader for one call context — the simple factory: the context
+ * produces the bound runner, the definitions table produces the strategies.
+ *
+ * @param call - The LLM service, the exact route, and the session identity to send.
+ * @returns A loader whose `run` is the only LLM entry point a feature needs.
+ */
+export declare function subagentLoaderFor(call: SubagentCall): SubagentLoader;
+/**
+ * Reject one answer as a failed call because the stream was cut.
+ *
+ * A cut answer is unusable by design — a half-written body must never become a
+ * verdict, and a gate that produced no verdict is not an approval. The error
+ * carries the facts the call already reported, so the failure is accounted
+ * exactly like a transport failure instead of vanishing.
+ *
+ * @param answer - The cut answer.
+ * @param route - The route it ran on.
+ * @returns The error to throw.
+ */
+export declare function cutFailureOf<Answer>(answer: SubagentAnswer<Answer>, route: ModelSelection): SubagentCallError;
+//# sourceMappingURL=subagent.d.ts.map

package/lib/subagent.js

@@ -0,0 +1,52 @@
+/**
+ * The generic subagent and its loader: the only path from plugin feature code
+ * to an LLM call.
+ *
+ * A subagent is data — a strategy holding its identity, system prompt, output
+ * budget fallback and answer parser. The loader binds that strategy to one
+ * route and session, then runs it through one fixed skeleton (the template
+ * method): assemble the call, stream it, parse the answer, account for what
+ * happened. Failure accounting rides the same skeleton as success: the route
+ * and the usage a stream reported before it died come back on the thrown
+ * error, so a failed call can be audited exactly like a successful one.
+ *
+ * The structure is the point. "Which subagents exist and what each one is
+ * told" is readable in one table (`subagent-defs.ts`) instead of being spread
+ * across call sites, and a job that has no definition cannot be called.
+ */
+import { SubagentCallError, streamOnce } from "./llm-call.js";
+/**
+ * Build the loader for one call context — the simple factory: the context
+ * produces the bound runner, the definitions table produces the strategies.
+ *
+ * @param call - The LLM service, the exact route, and the session identity to send.
+ * @returns A loader whose `run` is the only LLM entry point a feature needs.
+ */
+export function subagentLoaderFor(call) {
+    return {
+        async run(definition, prompt) {
+            const result = await streamOnce(call.llm, call.route, call.sessionId, definition.system, prompt, definition.maxTokens);
+            return { answer: definition.parse(result.text), text: result.text, usage: result.usage, finish: result.finish };
+        },
+    };
+}
+/**
+ * Reject one answer as a failed call because the stream was cut.
+ *
+ * A cut answer is unusable by design — a half-written body must never become a
+ * verdict, and a gate that produced no verdict is not an approval. The error
+ * carries the facts the call already reported, so the failure is accounted
+ * exactly like a transport failure instead of vanishing.
+ *
+ * @param answer - The cut answer.
+ * @param route - The route it ran on.
+ * @returns The error to throw.
+ */
+export function cutFailureOf(answer, route) {
+    return new SubagentCallError(`stream finished with ${answer.finish ?? "unknown"}`, {
+        usage: answer.usage,
+        finish: answer.finish,
+        route,
+    });
+}
+//# sourceMappingURL=subagent.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-continual-evolve",
-  "version": "0.15.11",
+  "version": "0.15.13",
   "description": "ZCode-style workspace memory for DeepSeek Harness: one central SQLite store partitioned by workspace, index injection, and sole-writer gated writes.",
   "license": "MIT",
   "repository": {