dsh-continual-evolve 0.1.0 → 0.2.0

package/lib/fate.js

@@ -0,0 +1,338 @@
+import { createUserMessage } from "@deepseek-ai/dsh-llm";
+import { assessLocalEntries, candidateKey, filterPromotable, listLocalCandidates, splitArchiveGuards, splitPromoteBlocked, splitPromoteProposals, wholePromoteProposals, } from "./wrapup.js";
+/** Turns a declined local-fate proposal stays silent before being offered again. */
+export const FATE_CONSULT_COOLDOWN_TURNS = 10;
+/**
+ * Partition an assessed wrap-up classification into concrete fate actions,
+ * re-running the deterministic guards against the LIVE global store (state
+ * may have changed while the LLM call was in flight). Pure and unit-tested;
+ * mirrors the partition step of the wrap-up command.
+ */
+export function planLocalFates(items, candidates, globalState) {
+    const byKey = new Map(candidates.map((candidate) => [candidateKey(candidate.kind, candidate.id), candidate]));
+    const { promotable, skipped } = filterPromotable(items, globalState, candidates);
+    const promoteItems = promotable.filter((item) => item.verdict === "promote");
+    const archiveItems = items.filter((item) => item.verdict === "archive");
+    const splits = [];
+    const splitSkipped = [];
+    for (const item of archiveItems) {
+        if (!item.promote)
+            continue;
+        const candidate = byKey.get(item.key);
+        if (!candidate) {
+            splitSkipped.push({ key: item.key, reason: "not in the audited candidate list" });
+            continue;
+        }
+        const blocked = splitPromoteBlocked(item, globalState, candidate.kind);
+        if (blocked) {
+            splitSkipped.push({ key: item.key, reason: blocked });
+            continue;
+        }
+        splits.push({ item, candidate });
+    }
+    const plainArchives = archiveItems.filter((item) => !item.promote);
+    const { silent: silentArchives, review: reviewArchives } = splitArchiveGuards(plainArchives, candidates);
+    return { candidates, promotable: promoteItems, splits, silentArchives, reviewArchives, skipped, splitSkipped };
+}
+/**
+ * The cooldown key of a candidate set: the sorted `kind:id` list. The set is
+ * the unit of consultation — a declined proposal is not offered again within
+ * the cooldown window, and a changed set (new entries appeared) starts a
+ * fresh consultation.
+ */
+export function fateSetKey(candidates) {
+    return candidates
+        .map((candidate) => candidateKey(candidate.kind, candidate.id))
+        .sort()
+        .join("|");
+}
+/**
+ * Whether the local-fate dimension is due for this gate run. Turn-interval
+ * gates respect the fate cadence (an independent counter — goal-driven
+ * sessions run the review EVERY round, the fate assessment must not);
+ * compaction is unconditional: experiences about to be summarized away get
+ * their fate check regardless.
+ */
+export function fateCadenceDue(state, reason, intervalTurns) {
+    if (reason === "compact")
+        return true;
+    return state.turns - state.lastFateAt >= intervalTurns;
+}
+/**
+ * Ask the user whether to execute the gate's local-fate proposal. ONE dialog
+ * covers every governed action (promotes, split promotions, review-required
+ * archives) — the gate never spams questions. Conservative on every edge:
+ * no question service → not approved; the question call fails → not approved;
+ * the same candidate set was declined within the cooldown → not asked again.
+ * A decline records the cooldown (the consultSkillEdits pattern).
+ */
+export async function consultLocalFates(ctx, agent, plan, gate) {
+    const needsDialog = plan.promotable.length + plan.splits.length + plan.reviewArchives.length > 0;
+    if (!needsDialog) {
+        return { approved: true, asked: false, reason: "nothing-to-ask" };
+    }
+    const setKey = fateSetKey(plan.candidates);
+    const lastReject = gate.fateRejects.get(setKey);
+    if (lastReject !== undefined && gate.turns - lastReject < FATE_CONSULT_COOLDOWN_TURNS) {
+        return { approved: false, asked: false, reason: "cooldown" };
+    }
+    const userQuestions = ctx.userQuestions;
+    if (!userQuestions) {
+        return { approved: false, asked: false, reason: "unavailable" };
+    }
+    try {
+        const answer = await userQuestions.ask({
+            questions: [
+                {
+                    id: "evolve-fate-consult",
+                    question: consultQuestion(plan),
+                    options: [{ label: "执行" }, { label: "不执行" }],
+                },
+            ],
+            agent,
+        });
+        const approved = answer.answers?.find((entry) => entry.id === "evolve-fate-consult")?.selected?.includes("执行") ?? false;
+        if (!approved) {
+            gate.fateRejects.set(setKey, gate.turns);
+        }
+        return { approved, asked: true, reason: approved ? "consented" : "declined" };
+    }
+    catch {
+        return { approved: false, asked: true, reason: "error" };
+    }
+}
+/** The user-visible fate proposal: every governed action, with real titles. */
+function consultQuestion(plan) {
+    const byKey = new Map(plan.candidates.map((candidate) => [candidateKey(candidate.kind, candidate.id), candidate]));
+    const lines = [];
+    if (plan.promotable.length > 0 || plan.splits.length > 0) {
+        lines.push("【提升到跨会话全局 store】");
+        for (const item of plan.promotable) {
+            lines.push(`- ${item.key}「${byKey.get(item.key)?.title ?? item.key}」 — ${item.reason}`);
+        }
+        for (const { item } of plan.splits) {
+            lines.push(`- ${item.key} → 拆出提升「${item.promote?.title}」（原条目随之归档）`);
+        }
+    }
+    if (plan.reviewArchives.length > 0) {
+        lines.push("【归档（未被全局覆盖且源自真实对话，需确认）】");
+        for (const item of plan.reviewArchives) {
+            lines.push(`- ${item.key}「${byKey.get(item.key)?.title ?? item.key}」 — ${item.reason}`);
+        }
+    }
+    return [
+        "自进化门禁检测到本会话的 local 条目需要归宿处理（提升条目将写入跨会话全局 store，归档条目隐藏但可恢复）：",
+        ...lines,
+        "是否执行？",
+    ].join("\n");
+}
+/**
+ * Deterministically apply the fate plan. `"full"` applies everything
+ * (promotes, splits, silent + review archives); `"silent-only"` applies only
+ * the deterministic silent archives (the compaction path — nothing governed).
+ * Promotes go through the SAME proposals as the wrap-up command
+ * (wholePromoteProposals / splitPromoteProposals), so both paths write
+ * identical global entries and local retirement stamps.
+ */
+export function applyLocalFates(engine, sessionId, plan, localState, mode) {
+    const applied = [];
+    const results = [];
+    const byKey = new Map(plan.candidates.map((candidate) => [candidateKey(candidate.kind, candidate.id), candidate]));
+    if (mode === "full") {
+        for (const item of plan.promotable) {
+            const candidate = byKey.get(item.key);
+            if (!candidate)
+                continue;
+            const proposals = wholePromoteProposals(item, candidate, sessionId);
+            const globalResult = engine.apply("global", undefined, proposals.global, { scope: "global" });
+            const createdId = globalResult.appliedEdits.find((edit) => edit.applied)?.id ?? candidate.id;
+            const localResult = engine.apply("local", sessionId, proposals.localStamp(createdId), {
+                scope: "local",
+                baselineState: localState,
+            });
+            results.push(globalResult, localResult);
+            applied.push(`提升 ${item.key} → 全局 store（global:${createdId}，本地副本已归档）`);
+        }
+        for (const { item, candidate } of plan.splits) {
+            if (!item.promote)
+                continue;
+            const proposals = splitPromoteProposals(item, candidate, sessionId);
+            const globalResult = engine.apply("global", undefined, proposals.global, { scope: "global" });
+            const createdId = globalResult.appliedEdits.find((edit) => edit.applied)?.id ?? candidate.id;
+            const localResult = engine.apply("local", sessionId, proposals.localStamp(createdId), {
+                scope: "local",
+                baselineState: localState,
+            });
+            results.push(globalResult, localResult);
+            applied.push(`拆解 ${item.key} → 清洗「${item.promote.title}」入全局（原条目已归档）`);
+        }
+    }
+    const archives = mode === "full" ? [...plan.silentArchives, ...plan.reviewArchives] : plan.silentArchives;
+    for (const item of archives) {
+        const candidate = byKey.get(item.key);
+        if (!candidate)
+            continue;
+        const proposal = {
+            summary: `gate fate: archive local ${item.key} — ${item.reason}`,
+            rationale: item.reason,
+            expectedOutcome: "The entry stops being injected but stays restorable.",
+            edits: [{ action: "archive", kind: candidate.kind, id: candidate.id }],
+        };
+        const result = engine.apply("local", sessionId, proposal, { scope: "local", baselineState: localState });
+        results.push(result);
+        applied.push(`归档 ${item.key}「${candidate.title}」`);
+    }
+    return { applied, results };
+}
+/**
+ * The gate's local-fate phase. Runs after the review phase on every gate
+ * trigger (turn_interval / compact), subject to cadence and cooldown. All
+ * failures are contained and recorded — a broken fate dimension never
+ * disturbs the agent loop.
+ */
+export async function runLocalFatePhase(ctx, engine, agent, config, state, reason, record) {
+    if (!config.localFate)
+        return;
+    const logger = ctx.logger("continual-evolve");
+    const sessionId = agent.id;
+    const localState = engine.load("local", sessionId);
+    const globalState = engine.load("global", undefined);
+    const candidates = listLocalCandidates(localState, globalState);
+    if (candidates.length === 0)
+        return;
+    if (!fateCadenceDue(state, reason, config.fateIntervalTurns))
+        return;
+    const setKey = fateSetKey(candidates);
+    const lastReject = state.fateRejects.get(setKey);
+    if (lastReject !== undefined && state.turns - lastReject < FATE_CONSULT_COOLDOWN_TURNS) {
+        logger.info(`auto-review local-fate skipped [${sessionId}]: candidate set declined ${state.turns - lastReject} turns ago (cooldown)`);
+        return;
+    }
+    const turnsSinceFate = state.turns - state.lastFateAt;
+    state.lastFateAt = state.turns;
+    let assessment;
+    try {
+        assessment = await assessLocalEntries(ctx, agent, candidates);
+    }
+    catch (cause) {
+        const message = cause instanceof Error ? cause.message : String(cause);
+        logger.warn(`auto-review local-fate failed for ${sessionId}: ${message}`);
+        record({
+            sessionId,
+            reason,
+            turnsSinceLastReview: turnsSinceFate,
+            outcome: "failed",
+            rationale: `fate assessment error: ${message}`,
+        });
+        return;
+    }
+    const plan = planLocalFates(assessment.items, candidates, globalState);
+    const needsDialog = plan.promotable.length + plan.splits.length + plan.reviewArchives.length > 0;
+    let consent = { approved: false, asked: false, reason: "nothing-to-ask" };
+    if (reason !== "compact" && needsDialog) {
+        consent = await consultLocalFates(ctx, agent, plan, state);
+    }
+    if (consent.approved) {
+        const { applied, results } = applyLocalFates(engine, sessionId, plan, localState, "full");
+        logger.info(`auto-review local-fate approved (${reason}) [${sessionId}]: ${plan.promotable.length} promoted, ${plan.splits.length} split, ${plan.reviewArchives.length} review-archived, ${plan.silentArchives.length} silent-archived — ${assessment.rationale}`);
+        record({
+            sessionId,
+            reason,
+            turnsSinceLastReview: turnsSinceFate,
+            outcome: "approved",
+            rationale: `fate: ${assessment.rationale} (${applied.join("; ")})`,
+            refinementId: results.map((result) => result.id).join(","),
+        });
+        if (config.notifyOnAutoReview && reason === "turn_interval" && applied.length > 0) {
+            notifyFateApplied(ctx, agent, applied);
+        }
+        return;
+    }
+    if (consent.reason === "declined" || consent.reason === "unavailable" || consent.reason === "error") {
+        const withheld = consent.reason;
+        const outcome = withheld === "declined" ? "declined" : "deferred";
+        logger.info(`auto-review local-fate ${outcome} (${reason}) [${sessionId}]: ${plan.promotable.length} promotes, ${plan.splits.length} splits, ${plan.reviewArchives.length} review-archives withheld — ${assessment.rationale}`);
+        record({
+            sessionId,
+            reason,
+            turnsSinceLastReview: turnsSinceFate,
+            outcome,
+            rationale: `fate ${withheld}: ${assessment.rationale} (${plan.promotable.length} promotes, ${plan.splits.length} splits, ${plan.reviewArchives.length} review-archives withheld)`,
+        });
+        return;
+    }
+    if (reason === "compact" && needsDialog) {
+        // Compaction: no dialog. Only deterministic silent archives apply;
+        // governed actions are deferred with an audit record.
+        const { applied, results } = applyLocalFates(engine, sessionId, plan, localState, "silent-only");
+        if (applied.length > 0) {
+            logger.info(`auto-review local-fate (compact) [${sessionId}]: silent-archived ${applied.length} — ${assessment.rationale}`);
+            record({
+                sessionId,
+                reason,
+                turnsSinceLastReview: turnsSinceFate,
+                outcome: "approved",
+                rationale: `fate (compact): ${assessment.rationale} (${applied.join("; ")})`,
+                refinementId: results.map((result) => result.id).join(","),
+            });
+        }
+        record({
+            sessionId,
+            reason,
+            turnsSinceLastReview: turnsSinceFate,
+            outcome: "deferred",
+            rationale: `fate (compact): ${plan.promotable.length} promotes, ${plan.splits.length} splits, ${plan.reviewArchives.length} review-archives deferred — run /evolve wrapup for a full session exit`,
+        });
+        return;
+    }
+    // Silent archives on a plain turn-interval gate with nothing to ask.
+    if (plan.silentArchives.length > 0) {
+        const { applied, results } = applyLocalFates(engine, sessionId, plan, localState, "silent-only");
+        logger.info(`auto-review local-fate (${reason}) [${sessionId}]: silent-archived ${applied.length} covered/operational entries — ${assessment.rationale}`);
+        record({
+            sessionId,
+            reason,
+            turnsSinceLastReview: turnsSinceFate,
+            outcome: "approved",
+            rationale: `fate: ${assessment.rationale} (${applied.join("; ")})`,
+            refinementId: results.map((result) => result.id).join(","),
+        });
+        if (config.notifyOnAutoReview && reason === "turn_interval") {
+            notifyFateApplied(ctx, agent, applied);
+        }
+        return;
+    }
+    // Assessed, nothing to do.
+    logger.info(`auto-review local-fate assessed (${reason}) [${sessionId}]: ${candidates.length} candidates, no action — ${assessment.rationale}`);
+    record({
+        sessionId,
+        reason,
+        turnsSinceLastReview: turnsSinceFate,
+        outcome: "assessed",
+        rationale: `fate: ${assessment.rationale} (${candidates.length} candidates, no action)`,
+    });
+}
+/** The user-visible notice after the gate applied local-fate actions. */
+export function buildFateNotice(applied) {
+    return [
+        "🔎 自动进化门禁：本会话 local 条目归宿处理完成：",
+        applied.map((line) => `- ${line}`).join("\n"),
+        "查看全部条目：/evolve list；撤销：/evolve rollback <refinement id>",
+        "请用一句话简短确认即可，不要调用任何工具。",
+    ].join("\n");
+}
+/** Queue the follow-up notice turn (turn_interval only, like the review notice). */
+function notifyFateApplied(ctx, agent, applied) {
+    try {
+        agent.followup(createUserMessage({
+            content: [{ type: "text", text: buildFateNotice(applied) }],
+            source: { kind: "plugin", plugin: "dsh-continual-evolve" },
+        }));
+    }
+    catch (cause) {
+        ctx
+            .logger("continual-evolve")
+            .warn(`local-fate notice failed for ${agent.id}: ${cause instanceof Error ? cause.message : String(cause)}`);
+    }
+}
+//# sourceMappingURL=fate.js.map

package/lib/index.d.ts

@@ -34,6 +34,17 @@ export declare const Config: z<Schemastery.ObjectS<{
     logMaxBytes: z<number, number>;
     /** After a benchmark decision rejects a candidate, roll the refinement back automatically. */
     autoRollbackOnReject: z<boolean, boolean>;
+    /**
+     * Gate local-fate dimension (#11 P2): the gate audits the session's local
+     * entries on its own cadence and proposes promote/archive — consulted
+     * first, never written silently. Only meaningful with autoReview on.
+     */
+    localFate: z<boolean, boolean>;
+    /**
+     * Minimum turns between local-fate assessments on the turn-interval path
+     * (compaction is unconditional). Absent → follows reviewIntervalTurns.
+     */
+    fateIntervalTurns: z<number, number>;
 }>, Schemastery.ObjectT<{
     /** Root for evolution stores; defaults to the resolved DSH home. */
     baseDir: z<string, string>;
@@ -63,6 +74,17 @@ export declare const Config: z<Schemastery.ObjectS<{
     logMaxBytes: z<number, number>;
     /** After a benchmark decision rejects a candidate, roll the refinement back automatically. */
     autoRollbackOnReject: z<boolean, boolean>;
+    /**
+     * Gate local-fate dimension (#11 P2): the gate audits the session's local
+     * entries on its own cadence and proposes promote/archive — consulted
+     * first, never written silently. Only meaningful with autoReview on.
+     */
+    localFate: z<boolean, boolean>;
+    /**
+     * Minimum turns between local-fate assessments on the turn-interval path
+     * (compaction is unconditional). Absent → follows reviewIntervalTurns.
+     */
+    fateIntervalTurns: z<number, number>;
 }>>;
 /** Structurally typed resolved config (loader passes the validated object). */
 export interface EvolveConfig {
@@ -84,6 +106,10 @@ export interface EvolveConfig {
     logMaxBytes?: number;
     /** After a benchmark decision rejects a candidate, roll the refinement back automatically. */
     autoRollbackOnReject?: boolean;
+    /** Gate local-fate dimension: propose promote/archive of local entries automatically. */
+    localFate?: boolean;
+    /** Minimum turns between local-fate assessments (compaction is unconditional). */
+    fateIntervalTurns?: number;
 }
 export interface EvolutionService {
     readonly engine: EvolutionEngine;

package/lib/index.js

@@ -52,6 +52,17 @@ export const Config = z.object({
     logMaxBytes: z.natural().default(5 * 1024 * 1024),
     /** After a benchmark decision rejects a candidate, roll the refinement back automatically. */
     autoRollbackOnReject: z.boolean().default(true),
+    /**
+     * Gate local-fate dimension (#11 P2): the gate audits the session's local
+     * entries on its own cadence and proposes promote/archive — consulted
+     * first, never written silently. Only meaningful with autoReview on.
+     */
+    localFate: z.boolean().default(true),
+    /**
+     * Minimum turns between local-fate assessments on the turn-interval path
+     * (compaction is unconditional). Absent → follows reviewIntervalTurns.
+     */
+    fateIntervalTurns: z.natural(),
 });
 export function apply(ctx, config) {
     const baseDir = resolveDshHome(config.baseDir);
@@ -59,7 +70,10 @@ export function apply(ctx, config) {
     const engine = createEvolutionEngine(baseDir, {
         onApplied: (result) => {
             try {
-                syncSkillsFromResult(skillsRoot, result);
+                const warnings = syncSkillsFromResult(skillsRoot, result);
+                for (const warning of warnings) {
+                    ctx.logger("continual-evolve").warn(warning);
+                }
             }
             catch (cause) {
                 ctx
@@ -108,8 +122,10 @@ export function apply(ctx, config) {
             maxInputChars: config.maxReviewInputChars ?? 40000,
             budgetTokens: config.reviewBudgetTokens ?? 4096,
             notifyOnAutoReview: config.notifyOnAutoReview ?? true,
+            localFate: config.localFate ?? true,
+            fateIntervalTurns: config.fateIntervalTurns ?? config.reviewIntervalTurns ?? 6,
         });
-        ctx.logger("continual-evolve").info(`continual-evolve auto-review enabled (every ${config.reviewIntervalTurns ?? 6} turns)`);
+        ctx.logger("continual-evolve").info(`continual-evolve auto-review enabled (every ${config.reviewIntervalTurns ?? 6} turns; local-fate ${config.localFate ?? true ? "on" : "off"} every ${config.fateIntervalTurns ?? config.reviewIntervalTurns ?? 6} turns)`);
     }
     ctx.logger("continual-evolve").info(`continual-evolve mounted (baseDir=${baseDir})`);
 }

package/lib/mount.js

@@ -124,6 +124,11 @@ export function renderParameters(entry) {
  * the ledger records the entry for the next boot.
  */
 export async function mountSkill(ctx, baseDir, entry) {
+    // Guidance skills are SKILL.md documents with no python reference — there
+    // is no function to mount as a tool; only executable skills can hot-mount.
+    if (entry.skill_kind === "guidance" || Object.keys(entry.reference ?? {}).length === 0) {
+        throw new Error(`skill ${entry.id} has no python reference (guidance skills cannot be mounted — load them with the skill tool instead)`);
+    }
     const dir = renderMountPackage(baseDir, entry);
     const entryId = `evolve-mount-${skillNameOf(entry.id)}`;
     const loader = ctx.get("loader");

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- 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      \"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- 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 interface PlanOptions {
     agent: Agent;
     state: HarnessState;
@@ -22,6 +22,13 @@ export interface PlanOptions {
      * every planning call is grounded in what the user actually said.
      */
     trajectory?: string;
+    /**
+     * Skills root to read the skill-creator template facts from
+     * (`<root>/skill-creator/references/template.md`). When omitted or the
+     * skills are not installed, the builtin distilled quality guide is
+     * injected instead — the skill standard is always present.
+     */
+    skillsRoot?: string;
     global?: boolean;
     signal?: AbortSignal;
     maxOutputTokens?: number;

package/lib/planner.js

@@ -2,6 +2,7 @@ import { BlockAssembler, createUserMessage, ReasoningEffortId } from "@deepseek-
 import { parseProposal } from "./plan.js";
 import { formatHarnessStateForPrompt, historyForPrompt } from "./render.js";
 import { recentUserText } from "./inject.js";
+import { skillQualityGuide } from "./skillquality.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
@@ -14,6 +15,25 @@ Rules:
 - prompt = narrow behavioral policy addendums; memory = durable facts/preferences/failures;
   skill = repeatable procedures (must carry a python reference {type:"python", import, callable}
   and an arguments object); subagent = reusable delegation roles.
+- Skill entries are authored to the DSH skill quality standard
+  (skill-creator, distilled from the official deepseek-harness 11 skills;
+  the full facts are provided in the <skill_quality_standard> block below):
+  only for a REAL trigger scenario grounded in the trajectory
+  (who, in what real task, what signal) — never invent one to pad the store;
+  never duplicate the official 11 skills or existing entries; content is a
+  SKILL.md document (frontmatter routing with "use when / do not use when"
+  description, boundary declaration, prerequisites and exclusions, layered
+  information, verifiable completion criteria). Self-check every proposed
+  skill against the 7 structural features and state the result in its
+  reason field.
+- Repeated multi-step workflows (session start/end routines, recurring
+  wrap-up or handoff procedures) may be proposed as guidance skills:
+  kind=skill, skill_kind="guidance", content = a SKILL.md document (no
+  python reference — executable skills keep requiring reference +
+  arguments). Only propose with repeated evidence in the trajectory, never
+  for one-off flows. Guidance skills materialize as discoverable SKILL.md
+  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.
 - Ground every edit in evidence: the session trajectory (recent direct user
   messages) is provided when available; prefer edits backed by it over
@@ -37,6 +57,7 @@ Rules:
       "path": "optional grouping path",
       "reference": {"type":"python","import":"pkg.mod","callable":"fn"} ,
       "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"
     }
@@ -54,11 +75,17 @@ export async function planWithLlm(ctx, options) {
     // most recent direct user messages ("" when none qualify — the block is
     // then omitted entirely, keeping an empty trajectory zero-cost).
     const trajectory = options.trajectory ?? recentUserText(agent);
+    // The skill quality standard is always present: the skill-creator
+    // template facts when installed, the builtin distilled guide otherwise
+    // (~1KB — planning is low-frequency, and the standard keeps skill
+    // proposals from drifting off the quality bar).
+    const qualityGuide = skillQualityGuide(options.skillsRoot);
     const userPrompt = [
         `<current_harness_state>\n${formatHarnessStateForPrompt(state)}\n</current_harness_state>`,
         `<refinement_history>\n${historyForPrompt(history)}\n</refinement_history>`,
         `<scope_policy>\n${scopeInstruction}\n</scope_policy>`,
         trajectory ? `<session_trajectory>\n${trajectory}\n</session_trajectory>` : "",
+        `<skill_quality_standard>\n${qualityGuide.text}\n</skill_quality_standard>`,
         options.instructions ? `<user_instructions>\n${options.instructions}\n</user_instructions>` : "",
         "Return only JSON edits. If no useful edit is justified, return an empty edits array with a rationale.",
     ]

package/lib/render.js

@@ -18,7 +18,8 @@ export function entryLine(entry, maxContentLength) {
         : "";
     const citationText = citationSuffix(entry);
     const archivedText = isArchived(entry) ? " [archived]" : "";
-    return `- [${entry.scope}:${entry.id}] ${entry.title} (${entry.path}, v${entry.version})${archivedText}${referenceText}${argumentsText}${citationText}: ${compactText(entry.content, maxContentLength)}`;
+    const formText = entry.kind === "skill" && entry.skill_kind === "guidance" ? " [guidance]" : "";
+    return `- [${entry.scope}:${entry.id}] ${entry.title} (${entry.path}, v${entry.version})${archivedText}${formText}${referenceText}${argumentsText}${citationText}: ${compactText(entry.content, maxContentLength)}`;
 }
 /** Trajectory citation suffix (` src=sessionId:1,2`), empty when uncited. */
 function citationSuffix(entry) {

package/lib/review.d.ts

@@ -28,7 +28,7 @@ export interface ReviewOptions {
     signal?: AbortSignal;
     budgetTokens?: number;
 }
-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\nReturn JSON only:\n{\n  \"shouldRefine\": true|false,\n  \"rationale\": \"short reason\",\n  \"instructions\": \"optional concise instructions for /evolve if shouldRefine is true\"\n}";
+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. */
 export declare function parseAutoRefineReview(text: string): AutoRefineReview;
 /** Serialize surface events to bounded role-prefixed text. */

package/lib/review.js

@@ -22,6 +22,23 @@ refine target: approve with instructions naming the entry ids, and tell the
 planner to archive them (archive hides from injection, data stays restorable)
 rather than delete.
 
+Skill-related trajectories (the evidence concerns creating or improving a
+skill entry) are judged against the DSH skill quality standard (skill-audit
+dimensions: frontmatter routing, the 7 structural features, paragraph
+skeleton, no duplication of the official 11 skills or covered skills).
+Approve only when the trajectory shows a REAL trigger scenario and the
+resulting skill would meet the standard; otherwise decline and say in the
+rationale what must improve — drafting follows skill-creator, and the
+planner receives the standard as its <skill_quality_standard> block.
+
+Repeated multi-step workflows (session start/end routines, recurring
+wrap-up or handoff procedures) are a valid refine target: approve with
+instructions telling the planner to propose a guidance skill (kind=skill,
+skill_kind=guidance — a SKILL.md document, no python reference). Only
+propose when the same workflow recurs in the trajectory — never for
+one-off flows. Auto-created skills are always offered to the user for a
+decision before they land; the gate never writes a skill silently.
+
 Return JSON only:
 {
   "shouldRefine": true|false,

package/lib/score.d.ts

@@ -9,12 +9,28 @@ export interface AggregateOptions {
     passThreshold: number;
     /** Per-case regression tolerance: candidate may drop below reference by at most this much. */
     regressionTolerance: number;
+    /**
+     * Failure-cell protocol (gap A2): a round with more failed cells than
+     * this is rejected outright — failed cells are NEVER averaged in as
+     * zeros. Default 0 (any failure rejects the round).
+     */
+    maxFailedCells: number;
 }
 export declare const DEFAULT_AGGREGATE: AggregateOptions;
-/** Aggregate raw cells into code-owned per-case means + overall mean. */
-export declare function aggregate(cells: readonly CellScore[]): Record<string, number | null> & {
+export interface AggregateResult extends Record<string, number | null> {
     overall: number | null;
-};
+    /** Count of failed cells (excluded from every mean). */
+    failed: number;
+    /** Total cells considered (ok + failed). */
+    total: number;
+}
+/**
+ * Aggregate raw cells into code-owned per-case means + overall mean.
+ * Failure-cell protocol (gap A2): failed cells are EXCLUDED from means and
+ * counted separately — a crashed unit can never silently drag the mean down
+ * like a zero. A case whose cells all failed reports null (no mean).
+ */
+export declare function aggregate(cells: readonly CellScore[]): AggregateResult;
 export declare function entryFromCells(label: string, cells: readonly CellScore[], refinementId?: string): EvaluationEntry;
 export interface Decision {
     accepted: boolean;
@@ -25,7 +41,9 @@ export declare function decisionReport(reference: EvaluationEntry, candidate: Ev
 /**
  * Non-regressive acceptance rule (Self-Harness style):
  * the candidate is accepted iff its overall mean is STRICTLY higher than the
- * reference AND no case regresses by more than `regressionTolerance` points.
+ * reference, no case regresses by more than `regressionTolerance` points,
+ * and neither side has more failed cells than `maxFailedCells` (failure-cell
+ * protocol, gap A2 — a partial/invalid round is never accepted).
  */
 export declare function decide(reference: EvaluationEntry, candidate: EvaluationEntry, opts: AggregateOptions): Decision;
 //# sourceMappingURL=score.d.ts.map