dsh-continual-evolve 0.2.0 → 0.4.0

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,53 @@ 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.
+ *
+ * 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 const DEFAULT_DIRECTORY_LINES = 15;
+/** How many of the variadic arrays are content-section kinds (prompt, subagent). */
+const CONTENT_SECTION_KINDS = 2;
+export function formatEntriesDirectory(...kindEntries) {
+    return formatEntriesDirectoryCapped(DEFAULT_DIRECTORY_LINES, ...kindEntries);
+}
+/** {@link formatEntriesDirectory} with an explicit cap (configurable). */
+export function formatEntriesDirectoryCapped(maxLines, ...kindEntries) {
+    const allEntries = kindEntries.flat().filter((e) => !isArchived(e));
+    if (allEntries.length === 0) {
+        return "";
+    }
+    // Skip the directory only when EVERY entry is already content-visible.
+    // Only the first two arrays (prompt, subagent) have curated sections —
+    // memories and skills have NO content injection, so they are invisible
+    // unless the directory lists them (pre-2026-08-22 the redundancy check
+    // wrongly counted them as "already shown", hiding small stores entirely).
+    const contentVisible = kindEntries
+        .slice(0, CONTENT_SECTION_KINDS)
+        .reduce((sum, entries) => sum + Math.min(entries.filter((e) => !isArchived(e)).length, MAX_INJECTED_ENTRIES_PER_KIND), 0);
+    if (allEntries.length <= contentVisible) {
+        return "";
+    }
+    const sorted = [...allEntries].sort((a, b) => `${a.kind}:${a.id}`.localeCompare(`${b.kind}:${b.id}`));
+    const lines = ["# Continual Harness — Entry Directory", "All entries (use evolve_list for full text of any entry):"];
+    const shown = sorted.slice(0, Math.max(maxLines, 1));
+    for (const entry of shown) {
+        lines.push(`- [${entry.kind}:${entry.id}] ${entry.title}`);
+    }
+    const hidden = sorted.length - shown.length;
+    if (hidden > 0) {
+        lines.push(`- …and ${hidden} more entries (evolve_list for the full index)`);
+    }
+    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
@@ -211,8 +259,13 @@ export function nearestLocalStateWithEntries(engine, agent) {
  * (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 function entriesSectionText(engine, agent, query) {
+export function entriesSectionText(engine, agent, query, opts) {
     if (!agent) {
         return "";
     }
@@ -222,10 +275,45 @@ 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 = new Set();
+    // 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.add(`prompt:${entry.id}`);
+    }
+    for (const entry of rankEntries(visibleSubagent, relevanceQuery).slice(0, MAX_INJECTED_ENTRIES_PER_KIND)) {
+        injectedKeys.add(`subagent:${entry.id}`);
+    }
+    // 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 = formatEntriesDirectoryCapped(opts?.directoryLines ?? DEFAULT_DIRECTORY_LINES, Object.values(merged.entries.prompt), Object.values(merged.entries.memory), Object.values(merged.entries.skill), Object.values(merged.entries.subagent));
+    // Directory-visible keys count too: a memory's injection IS its directory
+    // line. Set semantics keep content-injected entries single-counted.
+    for (const kind of ["prompt", "memory", "skill", "subagent"]) {
+        for (const entry of Object.values(merged.entries[kind])) {
+            if (isArchived(entry))
+                continue;
+            const key = `${kind}:${entry.id}`;
+            if (injectedKeys.has(key) || directoryText.includes(`[${key}]`)) {
+                injectedKeys.add(key);
+            }
+        }
+    }
+    // Record usage durably (best-effort: failure never blocks injection).
+    // Deduped per session — see recordInjection.
+    if (injectedKeys.size > 0) {
+        try {
+            recordInjection(engine.baseDir, [...injectedKeys], agent.id);
+        }
+        catch {
+            // Usage recording is diagnostic; never interrupt the injection path.
+        }
+    }
+    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

package/lib/llm-text.js

@@ -0,0 +1,49 @@
+import { BlockAssembler, createUserMessage, ReasoningEffortId } from "@deepseek-ai/dsh-llm";
+/**
+ * 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 async function streamText(ctx, opts) {
+    const assembler = new BlockAssembler();
+    for await (const chunk of ctx.llm.stream({
+        provider: opts.provider,
+        model: opts.model,
+        system: opts.system,
+        messages: [
+            createUserMessage({
+                content: [{ type: "text", text: opts.prompt }],
+                source: { kind: "plugin", plugin: "dsh-continual-evolve" },
+            }),
+        ],
+        reasoningEffort: ReasoningEffortId("off"),
+        maxTokens: opts.maxTokens ?? 8000,
+        ...(opts.signal ? { signal: opts.signal } : {}),
+    })) {
+        assembler.push(chunk);
+    }
+    const finish = assembler.finish;
+    if (finish.kind === "error") {
+        throw new Error(`evolve: LLM call failed: ${finish.failure?.message ?? "unknown"}`);
+    }
+    if (finish.kind === "aborted") {
+        throw new Error("evolve: LLM call aborted");
+    }
+    if (finish.kind === "max-tokens") {
+        throw new Error("evolve: LLM output budget exhausted (max-tokens)");
+    }
+    const text = assembler
+        .blocks()
+        .filter((block) => block.type === "text")
+        .map((block) => block.text)
+        .join("\n");
+    if (text.length === 0) {
+        throw new Error("evolve: LLM produced no text output");
+    }
+    return text;
+}
+//# sourceMappingURL=llm-text.js.map

package/lib/mount-command.d.ts

@@ -0,0 +1,10 @@
+/**
+ * The `/evolve mount` and `/evolve unmount` subcommand handlers.
+ * Extracted from command.ts (P2-2).
+ */
+import type { Context } from "@deepseek-ai/cordis";
+import type { CommandInvocation, CommandResult } from "@deepseek-ai/dsh-commands";
+import type { EvolutionEngine } from "./service.js";
+export declare function executeMountCommand(ctx: Context, engine: EvolutionEngine, invocation: CommandInvocation, rest: string[]): Promise<CommandResult>;
+export declare function executeUnmountCommand(ctx: Context, engine: EvolutionEngine, rest: string[]): Promise<CommandResult>;
+//# sourceMappingURL=mount-command.d.ts.map

package/lib/mount-command.js

@@ -0,0 +1,48 @@
+import { loadLedger, mountSkill, unmountSkill } from "./mount.js";
+import { stripAngleBrackets } from "./command.js";
+function success(text) {
+    return { kind: "success", text };
+}
+function error(text) {
+    return { kind: "error", text };
+}
+export async function executeMountCommand(ctx, engine, invocation, rest) {
+    const sub = rest[0] ?? "";
+    if (sub === "list") {
+        const ledger = loadLedger(engine.baseDir);
+        if (ledger.mounted.length === 0) {
+            return success("(no hot-mounted plugins — /evolve mount <skillId>)");
+        }
+        return success(ledger.mounted.map((m) => `- ${m.id} (${m.entryId}, v${m.version}, ${m.mountedAt})`).join("\n"));
+    }
+    const skillId = stripAngleBrackets(sub);
+    if (!skillId) {
+        return error(`mount requires a skill entry id.\nUsage: /evolve mount <skillId> | /evolve mount list`);
+    }
+    const sessionId = invocation.agent.id;
+    const local = engine.load("local", sessionId);
+    const globalState = engine.load("global", undefined);
+    const entry = local.entries.skill[skillId] ??
+        globalState.entries.skill[skillId] ??
+        Object.values(local.entries.skill).find((e) => e.id === skillId) ??
+        Object.values(globalState.entries.skill).find((e) => e.id === skillId);
+    if (!entry) {
+        return error(`skill entry ${skillId} not found in local or global store`);
+    }
+    try {
+        const record = await mountSkill(ctx, engine.baseDir, entry);
+        return success(`mounted ${record.id} as ${record.entryId} (v${record.version}) — tool: skill_${record.id.replace(/_/g, "-")}`);
+    }
+    catch (cause) {
+        return error(cause instanceof Error ? cause.message : String(cause));
+    }
+}
+export async function executeUnmountCommand(ctx, engine, rest) {
+    const id = stripAngleBrackets(rest[0] ?? "");
+    if (!id) {
+        return error(`unmount requires a mount id (see /evolve mount list).`);
+    }
+    const record = await unmountSkill(ctx, engine.baseDir, id);
+    return record ? success(`unmounted ${record.id} (${record.entryId})`) : error(`no mount found for ${id}`);
+}
+//# sourceMappingURL=mount-command.js.map

package/lib/plan.js

@@ -99,6 +99,11 @@ export function parseProposal(text) {
             assignIfString(built, "content", edit["content"]);
             assignIfString(built, "path", edit["path"]);
             assignIfString(built, "reason", edit["reason"]);
+            // Gap C2: validate blastRadius values.
+            const br = asString(edit["blastRadius"]);
+            if (br === "general" || br === "project" || br === "session") {
+                built.blastRadius = br;
+            }
             const reference = asRecord(edit["reference"]);
             if (reference)
                 built.reference = reference;

package/lib/planner.d.ts

@@ -9,7 +9,7 @@
 import type { Context } from "@deepseek-ai/cordis";
 import type { Agent } from "@deepseek-ai/dsh-agent";
 import type { HarnessState, RefinementProposal, RefinementResult } from "./types.js";
-export declare const PLANNER_SYSTEM_PROMPT = "You are the /evolve continual harness subsystem.\n\nYour job is to improve the editable continual harness state. Instead of\nsummarizing the conversation you emit precise Create, Update, or Delete edits\nto reusable state: prompt notes, memories, skills, and subagent specs.\n\nRules:\n- The base system prompt is immutable and MUST NOT be rewritten (never edit id \"base_system_prompt\").\n- Prefer small evidence-backed edits. If no useful edit is justified, return an empty edits array.\n- prompt = narrow behavioral policy addendums; memory = durable facts/preferences/failures;\n  skill = repeatable procedures (must carry a python reference {type:\"python\", import, callable}\n  and an arguments object); subagent = reusable delegation roles.\n- Skill entries are authored to the DSH skill quality standard\n  (skill-creator, distilled from the official deepseek-harness 11 skills;\n  the full facts are provided in the <skill_quality_standard> block below):\n  only for a REAL trigger scenario grounded in the trajectory\n  (who, in what real task, what signal) \u2014 never invent one to pad the store;\n  never duplicate the official 11 skills or existing entries; content is a\n  SKILL.md document (frontmatter routing with \"use when / do not use when\"\n  description, boundary declaration, prerequisites and exclusions, layered\n  information, verifiable completion criteria). Self-check every proposed\n  skill against the 7 structural features and state the result in its\n  reason field.\n- Repeated multi-step workflows (session start/end routines, recurring\n  wrap-up or handoff procedures) may be proposed as guidance skills:\n  kind=skill, skill_kind=\"guidance\", content = a SKILL.md document (no\n  python reference \u2014 executable skills keep requiring reference +\n  arguments). Only propose with repeated evidence in the trajectory, never\n  for one-off flows. Guidance skills materialize as discoverable SKILL.md\n  files under <skillsRoot>/<kebab-name>/SKILL.md and are always offered to\n  the user for a decision before they land.\n- Local edits are session-scoped; global edits persist across sessions.\n- Ground every edit in evidence: the session trajectory (recent direct user\n  messages) is provided when available; prefer edits backed by it over\n  speculation, and never invent preferences the user did not express.\n- Stale entries (superseded by newer ones, never referenced in recent\n  trajectories, obsolete facts): propose action \"archive\" instead of\n  \"delete\" \u2014 archive hides the entry from injection while keeping its data\n  restorable; it requires only kind + id.\n- Output JSON only, exactly this shape:\n{\n  \"summary\": \"one sentence\",\n  \"rationale\": \"why these edits are justified by the evidence\",\n  \"expectedOutcome\": \"what should improve and how to validate it\",\n  \"edits\": [\n    {\n      \"action\": \"create|update|delete\",\n      \"kind\": \"prompt|memory|skill|subagent\",\n      \"id\": \"stable id for update/delete, optional for create\",\n      \"title\": \"required for create/update except delete\",\n      \"content\": \"required for create/update except delete\",\n      \"path\": \"optional grouping path\",\n      \"reference\": {\"type\":\"python\",\"import\":\"pkg.mod\",\"callable\":\"fn\"} ,\n      \"arguments\": {\"name\": {\"type\":\"string\",\"required\":true,\"description\":\"...\"}},\n      \"skill_kind\": \"executable|guidance (optional; skill kind only \u2014 guidance = SKILL.md document without reference)\",\n      \"metadata\": {},\n      \"reason\": \"why this edit is useful\"\n    }\n  ]\n}";
+export declare const PLANNER_SYSTEM_PROMPT = "You are the /evolve continual harness subsystem.\n\nYour job is to improve the editable continual harness state. Instead of\nsummarizing the conversation you emit precise Create, Update, or Delete edits\nto reusable state: prompt notes, memories, skills, and subagent specs.\n\nRules:\n- The base system prompt is immutable and MUST NOT be rewritten (never edit id \"base_system_prompt\").\n- Prefer small evidence-backed edits. If no useful edit is justified, return an empty edits array.\n- prompt = narrow behavioral policy addendums; memory = durable facts/preferences/failures;\n  skill = repeatable procedures (must carry a python reference {type:\"python\", import, callable}\n  and an arguments object); subagent = reusable delegation roles.\n- Skill entries are authored to the DSH skill quality standard\n  (skill-creator, distilled from the official deepseek-harness 11 skills;\n  the full facts are provided in the <skill_quality_standard> block below):\n  only for a REAL trigger scenario grounded in the trajectory\n  (who, in what real task, what signal) \u2014 never invent one to pad the store;\n  never duplicate the official 11 skills or existing entries; content is a\n  SKILL.md document (frontmatter routing with \"use when / do not use when\"\n  description, boundary declaration, prerequisites and exclusions, layered\n  information, verifiable completion criteria). Self-check every proposed\n  skill against the 7 structural features and state the result in its\n  reason field.\n- Repeated multi-step workflows (session start/end routines, recurring\n  wrap-up or handoff procedures) may be proposed as guidance skills:\n  kind=skill, skill_kind=\"guidance\", content = a SKILL.md document (no\n  python reference \u2014 executable skills keep requiring reference +\n  arguments). Only propose with repeated evidence in the trajectory, never\n  for one-off flows. Guidance skills materialize as discoverable SKILL.md\n  files under <skillsRoot>/<kebab-name>/SKILL.md and are always offered to\n  the user for a decision before they land.\n- Local edits are session-scoped; global edits persist across sessions.\n- Gap C2: EVERY edit MUST include a \"blastRadius\" field indicating how broadly\n  the edit applies: \"general\" (cross-project tactical rule, applies everywhere),\n  \"project\" (valid for the current project/repo), or \"session\" (one-off,\n  specific to this session's context). The review gate validates that\n  local-scope edits use \"session\" or \"project\", and global-scope edits use\n  \"general\" or \"project\". When in doubt, prefer narrower blast radius.\n- Ground every edit in evidence: the session trajectory (recent direct user\n  messages) is provided when available; prefer edits backed by it over\n  speculation, and never invent preferences the user did not express.\n- Stale entries (superseded by newer ones, never referenced in recent\n  trajectories, obsolete facts): propose action \"archive\" instead of\n  \"delete\" \u2014 archive hides the entry from injection while keeping its data\n  restorable; it requires only kind + id.\n- Output JSON only, exactly this shape:\n{\n  \"summary\": \"one sentence\",\n  \"rationale\": \"why these edits are justified by the evidence\",\n  \"expectedOutcome\": \"what should improve and how to validate it\",\n  \"edits\": [\n    {\n      \"action\": \"create|update|delete\",\n      \"kind\": \"prompt|memory|skill|subagent\",\n      \"id\": \"stable id for update/delete, optional for create\",\n      \"title\": \"required for create/update except delete\",\n      \"content\": \"required for create/update except delete\",\n      \"path\": \"optional grouping path\",\n      \"reference\": {\"type\":\"python\",\"import\":\"pkg.mod\",\"callable\":\"fn\"} ,\n      \"arguments\": {\"name\": {\"type\":\"string\",\"required\":true,\"description\":\"...\"}},\n      \"skill_kind\": \"executable|guidance (optional; skill kind only \u2014 guidance = SKILL.md document without reference)\",\n      \"metadata\": {},\n      \"reason\": \"why this edit is useful\",\n      \"blastRadius\": \"general|project|session\"\n    }\n  ]\n}";
 export interface PlanOptions {
     agent: Agent;
     state: HarnessState;

package/lib/planner.js

@@ -1,8 +1,8 @@
-import { BlockAssembler, createUserMessage, ReasoningEffortId } from "@deepseek-ai/dsh-llm";
 import { parseProposal } from "./plan.js";
 import { formatHarnessStateForPrompt, historyForPrompt } from "./render.js";
 import { recentUserText } from "./inject.js";
 import { skillQualityGuide } from "./skillquality.js";
+import { streamText } from "./llm-text.js";
 export const PLANNER_SYSTEM_PROMPT = `You are the /evolve continual harness subsystem.
 
 Your job is to improve the editable continual harness state. Instead of
@@ -35,6 +35,12 @@ Rules:
   files under <skillsRoot>/<kebab-name>/SKILL.md and are always offered to
   the user for a decision before they land.
 - Local edits are session-scoped; global edits persist across sessions.
+- Gap C2: EVERY edit MUST include a "blastRadius" field indicating how broadly
+  the edit applies: "general" (cross-project tactical rule, applies everywhere),
+  "project" (valid for the current project/repo), or "session" (one-off,
+  specific to this session's context). The review gate validates that
+  local-scope edits use "session" or "project", and global-scope edits use
+  "general" or "project". When in doubt, prefer narrower blast radius.
 - Ground every edit in evidence: the session trajectory (recent direct user
   messages) is provided when available; prefer edits backed by it over
   speculation, and never invent preferences the user did not express.
@@ -59,7 +65,8 @@ Rules:
       "arguments": {"name": {"type":"string","required":true,"description":"..."}},
       "skill_kind": "executable|guidance (optional; skill kind only — guidance = SKILL.md document without reference)",
       "metadata": {},
-      "reason": "why this edit is useful"
+      "reason": "why this edit is useful",
+      "blastRadius": "general|project|session"
     }
   ]
 }`;
@@ -91,47 +98,14 @@ export async function planWithLlm(ctx, options) {
     ]
         .filter(Boolean)
         .join("\n\n");
-    const assembler = new BlockAssembler();
-    for await (const chunk of ctx.llm.stream({
+    const text = await streamText(ctx, {
         provider: agent.options.provider,
         model: agent.options.model,
         system: PLANNER_SYSTEM_PROMPT,
-        messages: [
-            createUserMessage({
-                content: [{ type: "text", text: userPrompt }],
-                source: { kind: "plugin", plugin: "dsh-continual-evolve" },
-            }),
-        ],
-        // Force non-reasoning output: the proposal must be pure JSON text.
-        reasoningEffort: ReasoningEffortId("off"),
+        prompt: userPrompt,
         maxTokens: options.maxOutputTokens ?? 8000,
-        ...(options.signal ? { signal: options.signal } : {}),
-    })) {
-        assembler.push(chunk);
-    }
-    throwOnFinishError(assembler.finish);
-    const blocks = assembler.blocks();
-    const text = blocks
-        .filter((block) => block.type === "text")
-        .map((block) => block.text)
-        .join("\n");
-    if (text.length === 0) {
-        throw new Error("evolve: planner produced no text output");
-    }
+        signal: options.signal,
+    });
     return parseProposal(text);
 }
-/** Surface terminal stream states as errors so the caller never sees a silent partial plan. */
-function throwOnFinishError(finish) {
-    switch (finish.kind) {
-        case "stop":
-        case "tool-calls":
-            return;
-        case "max-tokens":
-            throw new Error("evolve: planner output budget exhausted (max-tokens)");
-        case "aborted":
-            throw new Error("evolve: planner call aborted");
-        case "error":
-            throw new Error(`evolve: planner call failed: ${finish.failure?.message ?? "unknown error"}`);
-    }
-}
 //# sourceMappingURL=planner.js.map

package/lib/promotion.d.ts

@@ -0,0 +1,62 @@
+/**
+ * Promotion policy: mechanical, code-enforced gates that decide whether a
+ * local entry MAY be promoted to the cross-session global store ("模型提议，
+ * 代码保证"). The LLM classification proposes; these guards dispose.
+ *
+ * Rationale (2026-08-22 store audit): the global store is shared by every
+ * project on one profile, so promoting project-scoped knowledge taxes every
+ * future session in every project. Measured failure modes:
+ * - absolute paths / session ids in promoted content (project-scoped),
+ * - near-duplicates of existing global entries re-promoted from later
+ *   sessions (title matching alone missed them),
+ * - one-line facts whose framing costs more than their content.
+ *
+ * Pure functions only — the callers (wrapup command, gate local-fate phase)
+ * supply the resolved {@link PromotionPolicy}.
+ */
+import type { HarnessState, RefinementKind } from "./types.js";
+export interface PromotionPolicy {
+    /** Content matching any pattern is project-scoped and stays local. */
+    blockPatterns: RegExp[];
+    /** Whole promotions below this content length stay local (chars). */
+    minPromoteChars: number;
+    /** Content overlap above this against a global entry = duplicate. */
+    maxContentOverlap: number;
+}
+export declare const DEFAULT_PROMOTION_POLICY: PromotionPolicy;
+/**
+ * Build a policy from config values (schemastery strings compiled here so
+ * the config layer never touches RegExp). Invalid patterns are skipped —
+ * a broken user pattern must not disable the remaining guards.
+ */
+export declare function resolvePromotionPolicy(options: {
+    blockPatterns?: readonly string[] | undefined;
+    minPromoteChars?: number | undefined;
+    maxContentOverlap?: number | undefined;
+}): PromotionPolicy;
+/**
+ * First reason the content reads as project-scoped, or undefined when it
+ * looks portable. Returns the matched pattern source so skip reports stay
+ * explainable in reviews.jsonl rationales.
+ */
+export declare function projectScopedReason(content: string, policy: PromotionPolicy): string | undefined;
+/**
+ * Tokenize for cheap similarity: ASCII words plus CJK character bigrams
+ * (single CJK chars are too ambiguous; bigrams survive segmentation-free
+ * Chinese text). Lowercased; single-char ASCII tokens dropped as noise.
+ */
+export declare function normalizedTokens(text: string): Set<string>;
+/** Jaccard similarity of two texts' normalized token sets (0..1). */
+export declare function contentOverlap(a: string, b: string): number;
+export interface SimilarEntryHit {
+    id: string;
+    title: string;
+    score: number;
+}
+/**
+ * The most similar non-archived global entry of the same kind, above the
+ * policy threshold. Title and content both feed the comparison (titles are
+ * short; content carries the real signal).
+ */
+export declare function mostSimilarGlobalEntry(globalState: HarnessState, kind: RefinementKind, title: string, content: string, policy: PromotionPolicy): SimilarEntryHit | undefined;
+//# sourceMappingURL=promotion.d.ts.map

package/lib/promotion.js

@@ -0,0 +1,102 @@
+import { isArchived } from "./types.js";
+/** Regex sources that mark content as project-scoped (never global). */
+const DEFAULT_BLOCK_PATTERNS = [
+    String.raw `\/(?:mnt|home|Users)\/`, // absolute POSIX paths: "/home/…", "/mnt/…", "/Users/…"
+    String.raw `\bsession-[0-9a-f]{8}\b`, // session-scoped identifiers
+    String.raw `~/\.dsh\b`, // user harness home references
+];
+export const DEFAULT_PROMOTION_POLICY = {
+    blockPatterns: DEFAULT_BLOCK_PATTERNS.map((source) => new RegExp(source, "i")),
+    minPromoteChars: 100,
+    maxContentOverlap: 0.6,
+};
+/**
+ * Build a policy from config values (schemastery strings compiled here so
+ * the config layer never touches RegExp). Invalid patterns are skipped —
+ * a broken user pattern must not disable the remaining guards.
+ */
+export function resolvePromotionPolicy(options) {
+    const patterns = [...(options.blockPatterns ?? [])]
+        .map((source) => {
+        try {
+            return new RegExp(source, "i");
+        }
+        catch {
+            return undefined;
+        }
+    })
+        .filter((pattern) => pattern !== undefined);
+    return {
+        blockPatterns: patterns.length > 0 ? patterns : DEFAULT_PROMOTION_POLICY.blockPatterns,
+        minPromoteChars: options.minPromoteChars ?? DEFAULT_PROMOTION_POLICY.minPromoteChars,
+        maxContentOverlap: options.maxContentOverlap ?? DEFAULT_PROMOTION_POLICY.maxContentOverlap,
+    };
+}
+/**
+ * First reason the content reads as project-scoped, or undefined when it
+ * looks portable. Returns the matched pattern source so skip reports stay
+ * explainable in reviews.jsonl rationales.
+ */
+export function projectScopedReason(content, policy) {
+    for (const pattern of policy.blockPatterns) {
+        if (pattern.test(content)) {
+            return `project-scoped content (matches /${pattern.source}/)`;
+        }
+    }
+    return undefined;
+}
+/**
+ * Tokenize for cheap similarity: ASCII words plus CJK character bigrams
+ * (single CJK chars are too ambiguous; bigrams survive segmentation-free
+ * Chinese text). Lowercased; single-char ASCII tokens dropped as noise.
+ */
+export function normalizedTokens(text) {
+    const lowered = text.toLowerCase();
+    const tokens = new Set();
+    for (const match of lowered.matchAll(/[a-z0-9_]{2,}/g)) {
+        tokens.add(match[0] ?? "");
+    }
+    let previous;
+    for (const match of lowered.matchAll(/[\u3400-\u9fff]/g)) {
+        const char = match[0] ?? "";
+        if (previous !== undefined) {
+            tokens.add(`${previous}${char}`);
+        }
+        previous = char;
+    }
+    tokens.delete("");
+    return tokens;
+}
+/** Jaccard similarity of two texts' normalized token sets (0..1). */
+export function contentOverlap(a, b) {
+    const left = normalizedTokens(a);
+    const right = normalizedTokens(b);
+    if (left.size === 0 || right.size === 0) {
+        return 0;
+    }
+    let intersection = 0;
+    for (const token of left) {
+        if (right.has(token)) {
+            intersection += 1;
+        }
+    }
+    return intersection / (left.size + right.size - intersection);
+}
+/**
+ * The most similar non-archived global entry of the same kind, above the
+ * policy threshold. Title and content both feed the comparison (titles are
+ * short; content carries the real signal).
+ */
+export function mostSimilarGlobalEntry(globalState, kind, title, content, policy) {
+    let best;
+    for (const other of Object.values(globalState.entries[kind])) {
+        if (isArchived(other))
+            continue;
+        const score = Math.max(contentOverlap(title, other.title), contentOverlap(content, other.content));
+        if (score >= policy.maxContentOverlap && (best === undefined || score > best.score)) {
+            best = { id: other.id, title: other.title, score };
+        }
+    }
+    return best;
+}
+//# sourceMappingURL=promotion.js.map

package/lib/render.d.ts

@@ -3,13 +3,11 @@
  * refinement history. Every cap exists to keep token cost predictable no
  * matter how large the store grows.
  */
-import type { HarnessEntry, HarnessRefinementEvent, HarnessState, RefinementResult } from "./types.js";
+import type { HarnessEntry, HarnessState, RefinementResult } from "./types.js";
 export declare function compactText(text: string, maxLength: number): string;
 export declare function entryLine(entry: HarnessEntry, maxContentLength: number): string;
 /** Render the full merged state as a bounded overview for the system prompt. */
 export declare function formatHarnessStateForPrompt(state: HarnessState): string;
 /** Render recent refinement results for the planner. */
 export declare function historyForPrompt(history: readonly RefinementResult[]): string;
-/** Serialize a refinement event for persistence (lightweight). */
-export declare function eventToLine(event: HarnessRefinementEvent): string;
 //# sourceMappingURL=render.d.ts.map

package/lib/render.js

@@ -77,8 +77,4 @@ export function historyForPrompt(history) {
     })
         .join("\n\n");
 }
-/** Serialize a refinement event for persistence (lightweight). */
-export function eventToLine(event) {
-    return JSON.stringify(event);
-}
 //# sourceMappingURL=render.js.map

package/lib/review.d.ts

@@ -13,7 +13,7 @@ export interface AutoRefineReview {
     rationale: string;
     instructions?: string;
 }
-export type AutoRefineReason = "turn_interval" | "compact";
+export type AutoRefineReason = "turn_interval" | "compact" | "goal_blocked";
 export interface AutoRefineReviewContext {
     reason: AutoRefineReason;
     turnsSinceLastReview: number;
@@ -27,6 +27,9 @@ export interface ReviewOptions {
     trajectory?: string;
     signal?: AbortSignal;
     budgetTokens?: number;
+    /** Gap C1: optional provider/model override for the review gate (cheaper model). */
+    overrideProvider?: string;
+    overrideModel?: string;
 }
 export declare const AUTO_REVIEW_SYSTEM_PROMPT = "You are the automatic /evolve review gate.\n\nDecide whether this checkpoint should run /evolve. Auto /evolve writes local\nharness state by default, so approve when the trajectory contains evidence\nuseful to this session's future turns: a repeated failure, a reusable tactic,\na repeated delegation role, a durable fact or preference, a user correction\nthat should persist, or a narrow behavioral policy.\n\nThe current harness state below includes GLOBAL entries (scope=global) plus\nthis session's local entries (scope=local). When a topic is already covered\nby a global entry, do NOT approve a local duplicate of it \u2014 decline and say\nin the rationale that the topic is already covered globally.\n\nReject one-off noise, unsupported hypotheses, transient tool outputs, and\nrequests that carry no reusable content.\n\nStale local entries (superseded, long-unused, obsolete facts) are a valid\nrefine target: approve with instructions naming the entry ids, and tell the\nplanner to archive them (archive hides from injection, data stays restorable)\nrather than delete.\n\nSkill-related trajectories (the evidence concerns creating or improving a\nskill entry) are judged against the DSH skill quality standard (skill-audit\ndimensions: frontmatter routing, the 7 structural features, paragraph\nskeleton, no duplication of the official 11 skills or covered skills).\nApprove only when the trajectory shows a REAL trigger scenario and the\nresulting skill would meet the standard; otherwise decline and say in the\nrationale what must improve \u2014 drafting follows skill-creator, and the\nplanner receives the standard as its <skill_quality_standard> block.\n\nRepeated multi-step workflows (session start/end routines, recurring\nwrap-up or handoff procedures) are a valid refine target: approve with\ninstructions telling the planner to propose a guidance skill (kind=skill,\nskill_kind=guidance \u2014 a SKILL.md document, no python reference). Only\npropose when the same workflow recurs in the trajectory \u2014 never for\none-off flows. Auto-created skills are always offered to the user for a\ndecision before they land; the gate never writes a skill silently.\n\nReturn JSON only:\n{\n  \"shouldRefine\": true|false,\n  \"rationale\": \"short reason\",\n  \"instructions\": \"optional concise instructions for /evolve if shouldRefine is true\"\n}";
 /** Parse the gate's JSON reply. */