dsh-continual-evolve 0.3.0 → 0.5.0

package/lib/service.js

@@ -1,7 +1,10 @@
+import { CONFLICT_HINT_KEY } from "./types.js";
 import { applyRefinementProposal } from "./apply.js";
+import { randomUUID } from "node:crypto";
 import { rollbackProposal } from "./rollback.js";
 import { loadHarnessState, saveHarnessState } from "./state.js";
 import { appendResult, loadResults, snapshotBefore, storePaths } from "./store.js";
+import { CONFLICT_BLOCK_SCORE, CONFLICT_WARN_SCORE, buildConflictNotice, mostSimilarEntry } from "./promotion.js";
 export function createEvolutionEngine(baseDir, hooks = {}) {
     function load(scope, sessionId) {
         return loadHarnessState(storePaths(baseDir, scope, sessionId).stateDir, scope);
@@ -9,7 +12,29 @@ export function createEvolutionEngine(baseDir, hooks = {}) {
     function apply(scope, sessionId, proposal, context) {
         const paths = storePaths(baseDir, scope, sessionId);
         const state = context?.baselineState ?? load(scope, sessionId);
-        const id = `evolve_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 8)}`;
+        // Write-time conflict guard (R2): global creates are checked against
+        // the existing same-kind entries BEFORE any side effect — a
+        // near-duplicate is rejected with an actionable error (evolve_update
+        // instead), a moderate overlap proceeds stamped with
+        // CONFLICT_HINT_KEY. Rollbacks bypass the guard: re-creating an entry
+        // that resembles its successor is the point of rollback. Local scope
+        // is never blocked (scratch space); the wrapup/fate promotion path
+        // already enforces its own overlap policy there.
+        const warnHits = new Map();
+        if (scope === "global" && !context?.rollbackOf) {
+            for (const [index, edit] of proposal.edits.entries()) {
+                if (edit.action !== "create")
+                    continue;
+                const hit = mostSimilarEntry(Object.values(state.entries[edit.kind]), edit.title ?? "", edit.content ?? "", CONFLICT_WARN_SCORE);
+                if (!hit)
+                    continue;
+                if (hit.score >= CONFLICT_BLOCK_SCORE) {
+                    throw new Error(`create blocked: ${buildConflictNotice(hit)} already lives in the global ${edit.kind} store — use evolve_update on it instead of adding a duplicate`);
+                }
+                warnHits.set(index, hit);
+            }
+        }
+        const id = `evolve_${Date.now().toString(36)}_${randomUUID().slice(0, 8)}`;
         // Code-enforced snapshot: runs before any mutation, cannot be skipped by the model.
         snapshotBefore(paths, id);
         const result = applyRefinementProposal(state, proposal, {
@@ -19,6 +44,21 @@ export function createEvolutionEngine(baseDir, hooks = {}) {
             ...(context?.baselineState ? { baselineState: context.baselineState } : {}),
             ...(context?.rollbackOf ? { rollbackOf: context.rollbackOf } : {}),
         });
+        // Stamp warn-tier conflicts onto the freshly created entries (both the
+        // live state and the result's after-snapshot stay coherent).
+        for (const [index, hit] of warnHits) {
+            const applied = result.appliedEdits[index];
+            if (!applied?.applied || applied.action !== "create" || !applied.id)
+                continue;
+            const hint = `${applied.kind}:${hit.id}:${hit.score.toFixed(2)}`;
+            const live = state.entries[applied.kind][applied.id];
+            if (live) {
+                live.metadata[CONFLICT_HINT_KEY] = hint;
+                if (applied.after) {
+                    applied.after.metadata[CONFLICT_HINT_KEY] = hint;
+                }
+            }
+        }
         saveHarnessState(paths.stateDir, state);
         appendResult(paths, result);
         hooks.onApplied?.(result);

package/lib/skill-render.d.ts

@@ -10,6 +10,14 @@
 import type { HarnessEntry } from "./types.js";
 /** Convert a harness entry id (underscore slug) to a kebab-case skill name. */
 export declare function skillNameOf(id: string): string;
-/** Render a harness skill entry as a discoverable SKILL.md document. */
+/**
+ * Render a harness skill entry as a discoverable SKILL.md document.
+ *
+ * 2026-08-22: the frontmatter description now carries a ROUTING HINT —
+ * title plus the first meaningful content line — instead of the bare title.
+ * The skill catalog matches on description; a title-only description gave
+ * loaders nothing to route on (observed: materialized skills were 7-line
+ * stubs with a one-line description and no use-when signal).
+ */
 export declare function renderSkillMarkdown(entry: HarnessEntry): string;
 //# sourceMappingURL=skill-render.d.ts.map

package/lib/skill-render.js

@@ -2,12 +2,50 @@
 export function skillNameOf(id) {
     return id.toLowerCase().replace(/_/g, "-");
 }
-/** Render a harness skill entry as a discoverable SKILL.md document. */
+/**
+ * First content line usable as a routing hint: non-empty, not a Markdown
+ * heading, not a list marker, not frontmatter. Undefined when the body is
+ * effectively empty.
+ */
+function routingHint(content) {
+    for (const rawLine of content.split("\n")) {
+        const line = rawLine.trim();
+        if (line.length === 0)
+            continue;
+        if (line.startsWith("#") || line.startsWith("---") || line.startsWith("-") || line.startsWith("*"))
+            continue;
+        return oneLine(line);
+    }
+    return undefined;
+}
+/** Max rendered frontmatter description length (loaders truncate anyway). */
+const MAX_DESCRIPTION_LENGTH = 240;
+/**
+ * Render a harness skill entry as a discoverable SKILL.md document.
+ *
+ * 2026-08-22: the frontmatter description now carries a ROUTING HINT —
+ * title plus the first meaningful content line — instead of the bare title.
+ * The skill catalog matches on description; a title-only description gave
+ * loaders nothing to route on (observed: materialized skills were 7-line
+ * stubs with a one-line description and no use-when signal).
+ */
 export function renderSkillMarkdown(entry) {
+    const hint = routingHint(entry.content);
+    const base = oneLine(entry.title);
+    let description;
+    if (base.length === 0) {
+        description = (hint ?? "").slice(0, MAX_DESCRIPTION_LENGTH);
+    }
+    else if (hint !== undefined && !base.toLowerCase().includes(hint.toLowerCase())) {
+        description = `${base} — use when: ${hint}`.slice(0, MAX_DESCRIPTION_LENGTH);
+    }
+    else {
+        description = base.slice(0, MAX_DESCRIPTION_LENGTH);
+    }
     const lines = [
         "---",
         `name: ${skillNameOf(entry.id)}`,
-        `description: ${oneLine(entry.title)}`,
+        `description: ${description}`,
         "---",
         "",
         entry.content.trim(),

package/lib/state.js

@@ -80,8 +80,13 @@ export function loadHarnessState(stateDir, scope = "global") {
                     scope: normalizeScope(entry["scope"], scope),
                     reference: objectRecord(entry["reference"]) ?? {},
                     arguments: objectRecord(entry["arguments"]) ?? {},
+                    // skill_kind must survive persistence: /evolve mount and the
+                    // listing render branch on it (guidance vs executable).
+                    ...(entry["skill_kind"] === "guidance" || entry["skill_kind"] === "executable"
+                        ? { skill_kind: entry["skill_kind"] }
+                        : {}),
                     metadata: objectRecord(entry["metadata"]) ?? {},
-                    source: entry["source"] === "evolve" ? "evolve" : "evolve",
+                    source: "evolve",
                     created_at: typeof entry["created_at"] === "string" ? entry["created_at"] : new Date(0).toISOString(),
                     updated_at: typeof entry["updated_at"] === "string" ? entry["updated_at"] : new Date(0).toISOString(),
                     version: typeof entry["version"] === "number" ? entry["version"] : 1,

package/lib/tool.js

@@ -1,6 +1,7 @@
 import { defineTool } from "@deepseek-ai/dsh-tools";
 import { formatHarnessStateForPrompt } from "./render.js";
 import { requireGlobalApproval } from "./approval.js";
+import { CONFLICT_WARN_SCORE, buildConflictNotice, mostSimilarEntry } from "./promotion.js";
 import { entrySourceOf } from "./source.js";
 import { getUsageCount, loadUsage } from "./usage.js";
 import { buildEvolveCompleteEvent, emitEvolveComplete } from "./evolve-event.js";
@@ -72,7 +73,13 @@ export function registerEvolveTools(ctx, engine, opts) {
         execute: async (args, exec) => {
             const scope = scopeOf(args.global, "local");
             if (scope === "global" && opts.requireGlobalApproval) {
-                await requireGlobalApproval(ctx, exec.agent, exec.signal, `evolve_add ${args.kind} "${args.title}" → 跨会话全局 store`);
+                // Informed approval: surface a similarity hit against the
+                // existing global store BEFORE the human decides — the
+                // engine's write-time guard still has the final say.
+                const globalState = engine.load("global", undefined);
+                const hit = mostSimilarEntry(Object.values(globalState.entries[args.kind]), args.title ?? "", args.content ?? "", CONFLICT_WARN_SCORE);
+                const conflictNote = hit ? ` ⚠️ ${buildConflictNotice(hit)}——建议改用 evolve_update` : "";
+                await requireGlobalApproval(ctx, exec.agent, exec.signal, `evolve_add ${args.kind} "${args.title}" → 跨会话全局 store${conflictNote}`);
             }
             const edit = {
                 action: "create",

package/lib/types.d.ts

@@ -57,6 +57,14 @@ export declare const PROMOTED_AT_KEY = "promotedAt";
  * cross-session copy back to the session it was distilled from.
  */
 export declare const SOURCED_FROM_KEY = "sourcedFromLocal";
+/**
+ * Metadata key stamped on a GLOBAL entry that was created despite a
+ * moderate-similarity overlap with an existing entry (write-time conflict
+ * guard, warn tier): `<kind>:<id>:<score>` — points at the entry it may
+ * duplicate so wrapup/fate can consolidate later. Creates at/above the block
+ * threshold never reach this stamp; they are rejected outright.
+ */
+export declare const CONFLICT_HINT_KEY = "conflictHint";
 /**
  * True when the entry is archived (hidden from injection, restorable).
  * Absent or empty archivedAt means the entry is active.

package/lib/types.js

@@ -43,6 +43,14 @@ export const PROMOTED_AT_KEY = "promotedAt";
  * cross-session copy back to the session it was distilled from.
  */
 export const SOURCED_FROM_KEY = "sourcedFromLocal";
+/**
+ * Metadata key stamped on a GLOBAL entry that was created despite a
+ * moderate-similarity overlap with an existing entry (write-time conflict
+ * guard, warn tier): `<kind>:<id>:<score>` — points at the entry it may
+ * duplicate so wrapup/fate can consolidate later. Creates at/above the block
+ * threshold never reach this stamp; they are rejected outright.
+ */
+export const CONFLICT_HINT_KEY = "conflictHint";
 /**
  * True when the entry is archived (hidden from injection, restorable).
  * Absent or empty archivedAt means the entry is active.

package/lib/usage.d.ts

@@ -2,19 +2,32 @@ import type { HarnessState, RefinementKind } from "./types.js";
 export interface UsageStore {
     /** Injection count per entry key (`kind:id`). */
     counts: Record<string, number>;
+    /** Session dedup marker: the last session id each key was counted in (v2). */
+    lastSession?: Record<string, string>;
 }
-/** Load the usage store from disk; returns an empty store when absent or corrupt. */
+/**
+ * Load the usage store from disk; returns an empty store when absent or
+ * corrupt. Accepts BOTH on-disk shapes:
+ * - legacy (≤0.3.x): a flat `{ "kind:id": count }` map,
+ * - v2: `{ version: 2, counts, lastSession }` with per-session dedup.
+ */
 export declare function loadUsage(baseDir: string): UsageStore;
-/** Persist the usage store atomically. */
+/** Persist the usage store atomically (always the v2 shape). */
 export declare function saveUsage(baseDir: string, store: UsageStore): void;
 /** Build the usage key for an entry. */
 export declare function usageKey(kind: RefinementKind, id: string): string;
 /**
  * Increment injection counts for the entries that were actually injected.
  * Called after `entriesSectionText` renders the injected block. Keys not
- * present in the store are initialized to 1; existing keys are incremented.
+ * present in the store are initialized to 1.
+ *
+ * Session dedup (2026-08-22): with a sessionId, each key counts AT MOST
+ * ONCE per session — the old per-build counting produced meaningless
+ * numbers (one entry hit 2311× in a week) and hid the real "how many
+ * sessions found this useful" signal that staleness decay needs. Without
+ * a sessionId the call degrades to legacy always-increment behavior.
  */
-export declare function recordInjection(baseDir: string, injectedKeys: string[]): void;
+export declare function recordInjection(baseDir: string, injectedKeys: readonly string[], sessionId?: string): void;
 /**
  * Get the injection count for a specific entry. Returns 0 when the entry
  * has never been injected (absent from the store).

package/lib/usage.js

@@ -14,29 +14,44 @@ const USAGE_FILE = "usage.json";
 function usagePath(baseDir) {
     return join(baseDir, "evolve", USAGE_FILE);
 }
-/** Load the usage store from disk; returns an empty store when absent or corrupt. */
+/**
+ * Load the usage store from disk; returns an empty store when absent or
+ * corrupt. Accepts BOTH on-disk shapes:
+ * - legacy (≤0.3.x): a flat `{ "kind:id": count }` map,
+ * - v2: `{ version: 2, counts, lastSession }` with per-session dedup.
+ */
 export function loadUsage(baseDir) {
     const path = usagePath(baseDir);
     try {
         if (!existsSync(path))
-            return { counts: {} };
+            return { counts: {}, lastSession: {} };
         const raw = JSON.parse(readFileSync(path, "utf8"));
         if (typeof raw === "object" && raw !== null && !Array.isArray(raw)) {
-            return { counts: raw };
+            const record = raw;
+            if (record["version"] === 2 && typeof record["counts"] === "object" && record["counts"] !== null) {
+                return {
+                    counts: record["counts"],
+                    lastSession: typeof record["lastSession"] === "object" && record["lastSession"] !== null
+                        ? record["lastSession"]
+                        : {},
+                };
+            }
+            // Legacy flat map: every key is a count.
+            return { counts: raw, lastSession: {} };
         }
-        return { counts: {} };
+        return { counts: {}, lastSession: {} };
     }
     catch {
-        return { counts: {} };
+        return { counts: {}, lastSession: {} };
     }
 }
-/** Persist the usage store atomically. */
+/** Persist the usage store atomically (always the v2 shape). */
 export function saveUsage(baseDir, store) {
     const dir = join(baseDir, "evolve");
     mkdirSync(dir, { recursive: true });
     const path = usagePath(baseDir);
     const tmp = `${path}.${process.pid}.tmp`;
-    writeFileSync(tmp, `${JSON.stringify(store.counts, null, 2)}\n`, "utf8");
+    writeFileSync(tmp, `${JSON.stringify({ version: 2, counts: store.counts, lastSession: store.lastSession ?? {} }, null, 2)}\n`, "utf8");
     renameSync(tmp, path);
 }
 /** Build the usage key for an entry. */
@@ -46,16 +61,32 @@ export function usageKey(kind, id) {
 /**
  * Increment injection counts for the entries that were actually injected.
  * Called after `entriesSectionText` renders the injected block. Keys not
- * present in the store are initialized to 1; existing keys are incremented.
+ * present in the store are initialized to 1.
+ *
+ * Session dedup (2026-08-22): with a sessionId, each key counts AT MOST
+ * ONCE per session — the old per-build counting produced meaningless
+ * numbers (one entry hit 2311× in a week) and hid the real "how many
+ * sessions found this useful" signal that staleness decay needs. Without
+ * a sessionId the call degrades to legacy always-increment behavior.
  */
-export function recordInjection(baseDir, injectedKeys) {
+export function recordInjection(baseDir, injectedKeys, sessionId) {
     if (injectedKeys.length === 0)
         return;
     const store = loadUsage(baseDir);
+    let dirty = false;
     for (const key of injectedKeys) {
+        if (sessionId !== undefined && store.lastSession?.[key] === sessionId) {
+            continue;
+        }
         store.counts[key] = (store.counts[key] ?? 0) + 1;
+        if (store.lastSession && sessionId !== undefined) {
+            store.lastSession[key] = sessionId;
+        }
+        dirty = true;
+    }
+    if (dirty) {
+        saveUsage(baseDir, store);
     }
-    saveUsage(baseDir, store);
 }
 /**
  * Get the injection count for a specific entry. Returns 0 when the entry

package/lib/wrapup-command.d.ts

@@ -4,5 +4,6 @@
 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 executeWrapupCommand(ctx: Context, engine: EvolutionEngine, invocation: CommandInvocation): Promise<CommandResult>;
+import { type PromotionPolicy } from "./promotion.js";
+export declare function executeWrapupCommand(ctx: Context, engine: EvolutionEngine, invocation: CommandInvocation, policy?: PromotionPolicy): Promise<CommandResult>;
 //# sourceMappingURL=wrapup-command.d.ts.map

package/lib/wrapup-command.js

@@ -1,9 +1,10 @@
 import { questionServiceOf, requireGlobalApproval } from "./approval.js";
 import { assessLocalEntries, candidateKey, filterPromotable, listLocalCandidates, splitArchiveGuards, splitPromoteBlocked, splitPromoteProposals, wholePromoteProposals } from "./wrapup.js";
+import { DEFAULT_PROMOTION_POLICY } from "./promotion.js";
 function success(text) {
     return { kind: "success", text };
 }
-export async function executeWrapupCommand(ctx, engine, invocation) {
+export async function executeWrapupCommand(ctx, engine, invocation, policy = DEFAULT_PROMOTION_POLICY) {
     const sessionId = invocation.agent.id;
     const localState = engine.load("local", sessionId);
     const globalState = engine.load("global", undefined);
@@ -16,7 +17,7 @@ export async function executeWrapupCommand(ctx, engine, invocation) {
     const byKey = new Map(candidates.map((candidate) => [candidateKey(candidate.kind, candidate.id), candidate]));
     // 2. Partition by action. Deterministic guards re-check the LIVE global
     //    store right before anything lands (state may have changed mid-call).
-    const { promotable, skipped } = filterPromotable(assessment.items, globalState, candidates);
+    const { promotable, skipped } = filterPromotable(assessment.items, globalState, candidates, policy);
     const promoteItems = promotable.filter((item) => item.verdict === "promote");
     const archiveItems = assessment.items.filter((item) => item.verdict === "archive");
     // Split promotion (A-form): archive a mixed entry but promote ONLY the
@@ -33,7 +34,7 @@ export async function executeWrapupCommand(ctx, engine, invocation) {
             splitSkipped.push({ key: item.key, reason: "not in the audited candidate list" });
             continue;
         }
-        const blocked = splitPromoteBlocked(item, globalState, candidate.kind);
+        const blocked = splitPromoteBlocked(item, globalState, candidate.kind, policy);
         if (blocked) {
             splitSkipped.push({ key: item.key, reason: blocked });
             continue;

package/lib/wrapup.d.ts

@@ -21,6 +21,7 @@
 import type { Context } from "@deepseek-ai/cordis";
 import type { Agent } from "@deepseek-ai/dsh-agent";
 import type { HarnessEntry, HarnessState, RefinementKind, RefinementProposal } from "./types.js";
+import { type PromotionPolicy } from "./promotion.js";
 /** What should happen to one local entry at session end. */
 export type WrapupVerdict = "promote" | "archive" | "keep";
 /** A classified local entry: `key` matches one audited candidate exactly. */
@@ -138,9 +139,16 @@ export interface PromotableSplit {
  * Apply-time deterministic guard: re-check every promote verdict against the
  * global store right before it lands. The LLM classification may be stale
  * (a gate ran while assessing) or wrong; this ensures a promote never writes
- * a duplicate global entry. Pure and unit-tested.
+ * a duplicate, project-scoped, or too-thin global entry. Pure and unit-tested.
+ *
+ * Guards (2026-08-22 promotion policy):
+ * - audited candidate list + title coverage (pre-existing),
+ * - project-scoped content markers (absolute paths / session ids) — the
+ *   global store is shared across projects and must stay portable,
+ * - thin content below the policy floor (framing outweighs the fact),
+ * - near-duplicate of an existing global entry by content overlap.
  */
-export declare function filterPromotable(items: readonly WrapupItem[], globalState: HarnessState, candidates: readonly WrapupCandidate[]): PromotableSplit;
+export declare function filterPromotable(items: readonly WrapupItem[], globalState: HarnessState, candidates: readonly WrapupCandidate[], policy?: PromotionPolicy): PromotableSplit;
 export interface ArchiveReviewSplit {
     /** Archives that may proceed silently: topic already covered, no real
      * distillation source, or the archive half of an already-approved split. */
@@ -171,11 +179,12 @@ export declare function needsArchiveReview(item: WrapupItem, candidate: WrapupCa
 export declare function splitArchiveGuards(items: readonly WrapupItem[], candidates: readonly WrapupCandidate[]): ArchiveReviewSplit;
 /**
  * Apply-time guard for a split promotion (archive + promote sub-object):
- * the cleaned title must not duplicate a topic already covered globally. A
- * duplicate split is dropped (the entry still archives plain) rather than
- * half-promoting a redundancy.
+ * the cleaned payload must pass the same promotion policy as a whole
+ * promote — no global coverage duplicate, no project-scoped content, not
+ * too thin, no near-duplicate global entry. A blocked split is dropped (the
+ * entry still archives plain) rather than half-promoting a redundancy.
  */
-export declare function splitPromoteBlocked(item: WrapupItem, globalState: HarnessState, kind: RefinementKind): string | undefined;
+export declare function splitPromoteBlocked(item: WrapupItem, globalState: HarnessState, kind: RefinementKind, policy?: PromotionPolicy): string | undefined;
 /**
  * Shared proposal builders for a WHOLE promotion — used by both the
  * `/evolve wrapup` command and the gate's local-fate dimension so the two

package/lib/wrapup.js

@@ -4,6 +4,7 @@ import { compactText } from "./render.js";
 import { streamText } from "./llm-text.js";
 import { getUsageCount, loadUsage } from "./usage.js";
 import { recencyScore } from "./inject.js";
+import { DEFAULT_PROMOTION_POLICY, mostSimilarGlobalEntry, projectScopedReason } from "./promotion.js";
 export function candidateKey(kind, id) {
     return `${kind}:${id}`;
 }
@@ -158,9 +159,16 @@ export function parseWrapupAssessment(text, candidates) {
  * Apply-time deterministic guard: re-check every promote verdict against the
  * global store right before it lands. The LLM classification may be stale
  * (a gate ran while assessing) or wrong; this ensures a promote never writes
- * a duplicate global entry. Pure and unit-tested.
+ * a duplicate, project-scoped, or too-thin global entry. Pure and unit-tested.
+ *
+ * Guards (2026-08-22 promotion policy):
+ * - audited candidate list + title coverage (pre-existing),
+ * - project-scoped content markers (absolute paths / session ids) — the
+ *   global store is shared across projects and must stay portable,
+ * - thin content below the policy floor (framing outweighs the fact),
+ * - near-duplicate of an existing global entry by content overlap.
  */
-export function filterPromotable(items, globalState, candidates) {
+export function filterPromotable(items, globalState, candidates, policy = DEFAULT_PROMOTION_POLICY) {
     const byKey = new Map(candidates.map((candidate) => [candidateKey(candidate.kind, candidate.id), candidate]));
     const promotable = [];
     const skipped = [];
@@ -176,6 +184,26 @@ export function filterPromotable(items, globalState, candidates) {
             skipped.push({ key: item.key, reason: "already covered globally" });
             continue;
         }
+        const scoped = projectScopedReason(`${candidate.title}\n${candidate.content}`, policy);
+        if (scoped) {
+            skipped.push({ key: item.key, reason: scoped });
+            continue;
+        }
+        if (candidate.content.length < policy.minPromoteChars) {
+            skipped.push({
+                key: item.key,
+                reason: `too thin to promote (${candidate.content.length} < ${policy.minPromoteChars} chars) — keep local or merge`,
+            });
+            continue;
+        }
+        const similar = mostSimilarGlobalEntry(globalState, candidate.kind, candidate.title, candidate.content, policy);
+        if (similar) {
+            skipped.push({
+                key: item.key,
+                reason: `near-duplicate of global ${candidate.kind}:${similar.id} "${similar.title}" (overlap ${similar.score.toFixed(2)}) — update that entry instead`,
+            });
+            continue;
+        }
         promotable.push(item);
     }
     return { promotable, skipped };
@@ -223,16 +251,27 @@ export function splitArchiveGuards(items, candidates) {
 }
 /**
  * Apply-time guard for a split promotion (archive + promote sub-object):
- * the cleaned title must not duplicate a topic already covered globally. A
- * duplicate split is dropped (the entry still archives plain) rather than
- * half-promoting a redundancy.
+ * the cleaned payload must pass the same promotion policy as a whole
+ * promote — no global coverage duplicate, no project-scoped content, not
+ * too thin, no near-duplicate global entry. A blocked split is dropped (the
+ * entry still archives plain) rather than half-promoting a redundancy.
  */
-export function splitPromoteBlocked(item, globalState, kind) {
+export function splitPromoteBlocked(item, globalState, kind, policy = DEFAULT_PROMOTION_POLICY) {
     if (!item.promote)
         return "no split payload";
     if (globalCoverageDetected(globalState, kind, { id: "", title: item.promote.title })) {
         return "split promotion duplicates a globally covered topic";
     }
+    const scoped = projectScopedReason(`${item.promote.title}\n${item.promote.content}`, policy);
+    if (scoped)
+        return `split promotion is ${scoped}`;
+    if (item.promote.content.length < policy.minPromoteChars) {
+        return `split promotion too thin (${item.promote.content.length} < ${policy.minPromoteChars} chars)`;
+    }
+    const similar = mostSimilarGlobalEntry(globalState, kind, item.promote.title, item.promote.content, policy);
+    if (similar) {
+        return `split promotion near-duplicates global ${kind}:${similar.id} "${similar.title}" (overlap ${similar.score.toFixed(2)})`;
+    }
     return undefined;
 }
 /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-continual-evolve",
-  "version": "0.3.0",
+  "version": "0.5.0",
   "description": "Continual self-evolution plugin for DeepSeek Harness: versioned, auditable, rollback-safe harness state (prompt notes, memories, skills, subagent specs) refined from session trajectories.",
   "license": "MIT",
   "repository": {
@@ -50,6 +50,7 @@
     "dev": "tsc -p tsconfig.json --watch",
     "typecheck": "tsc -p tsconfig.json --noEmit",
     "test": "vitest run",
+    "test:coverage": "vitest run --coverage",
     "test:watch": "vitest",
     "lint": "oxlint src test",
     "clean": "rm -rf lib"
@@ -62,14 +63,15 @@
   },
   "devDependencies": {
     "@deepseek-ai/cordis": "^4.0.1",
-    "@deepseek-ai/dsh-agent": "0.1.0-rc.7",
-    "@deepseek-ai/dsh-commands": "0.1.0-rc.7",
-    "@deepseek-ai/dsh-home-paths": "0.1.0-rc.7",
-    "@deepseek-ai/dsh-llm": "0.1.0-rc.7",
-    "@deepseek-ai/dsh-system-prompt": "0.1.0-rc.7",
-    "@deepseek-ai/dsh-tools": "0.1.0-rc.7",
+    "@deepseek-ai/dsh-agent": "0.1.1-rc.2",
+    "@deepseek-ai/dsh-commands": "0.1.1-rc.2",
+    "@deepseek-ai/dsh-home-paths": "0.1.1-rc.2",
+    "@deepseek-ai/dsh-llm": "0.1.1-rc.2",
+    "@deepseek-ai/dsh-system-prompt": "0.1.1-rc.2",
+    "@deepseek-ai/dsh-tools": "0.1.1-rc.2",
     "@deepseek-ai/schemastery": "^3.18.1",
     "@types/node": "^22.10.0",
+    "@vitest/coverage-v8": "^3.2.0",
     "oxlint": "^0.16.0",
     "typescript": "^5.9.0",
     "vitest": "^3.2.0"