@lmzhen/dsh-evolution-core 0.26.15 → 0.27.0

package/lib/types/composition/ensure.d.ts

@@ -0,0 +1,10 @@
+import type { Context } from '@deepseek-ai/cordis';
+import { type RestrictedPresetRequest, type RestrictedPresetState } from './restricted-preset.ts';
+export interface EnsureRestrictedPresetArgs extends RestrictedPresetRequest {
+}
+export declare function ensureRestrictedPreset(ctx: Context, req: EnsureRestrictedPresetArgs): Promise<RestrictedPresetState>;
+/** Read-only view of the current registration (doctor runtime row). */
+export declare function restrictedPresetState(ctx: Context, kind: RestrictedPresetRequest['kind']): RestrictedPresetState | undefined;
+/** Release the registration for one kind (HMR/tests); the fiber effect also calls this. */
+export declare function disposeRestrictedPreset(ctx: Context, kind: RestrictedPresetRequest['kind']): Promise<void>;
+//# sourceMappingURL=ensure.d.ts.map

package/lib/types/composition/ensure.js

@@ -0,0 +1,95 @@
+import { normalizeAllow } from "./preset-ids.js";
+import { composeRestrictedPresetDefinition, } from "./restricted-preset.js";
+const SLOTS = new WeakMap();
+function slotFor(ctx, kind) {
+    let byKind = SLOTS.get(ctx);
+    if (byKind === undefined) {
+        byKind = new Map();
+        SLOTS.set(ctx, byKind);
+    }
+    let slot = byKind.get(kind);
+    if (slot === undefined) {
+        slot = {};
+        byKind.set(kind, slot);
+    }
+    return slot;
+}
+function registryOf(ctx) {
+    const candidate = ctx.get('agentPresets');
+    if (candidate === undefined)
+        return undefined;
+    if (typeof candidate.readDocument !== 'function' || typeof candidate.register !== 'function')
+        return undefined;
+    return candidate;
+}
+function installReleaseEffect(ctx, slot) {
+    if (slot.effectInstalled === true)
+        return;
+    const effect = ctx.effect;
+    if (effect === undefined)
+        return;
+    slot.effectInstalled = true;
+    effect.call(ctx, () => () => { void releaseRestrictedPreset(ctx, undefined, slot); }, 'evolution-restricted-preset');
+}
+async function releaseRestrictedPreset(ctx, kind, explicitSlot) {
+    const slot = explicitSlot ?? (kind === undefined ? undefined : slotFor(ctx, kind));
+    if (slot === undefined)
+        return;
+    const release = slot.release;
+    slot.release = undefined;
+    slot.readyKey = undefined;
+    slot.state = undefined;
+    if (release !== undefined)
+        await release();
+}
+export async function ensureRestrictedPreset(ctx, req) {
+    const allow = normalizeAllow(req.allow);
+    const key = req.parentPresetId + '\n' + allow.join('\n');
+    const slot = slotFor(ctx, req.kind);
+    if (slot.readyKey === key && slot.state !== undefined && slot.state.kind === 'ready')
+        return slot.state;
+    if (slot.inflight !== undefined)
+        return slot.inflight;
+    slot.inflight = (async () => {
+        await releaseRestrictedPreset(ctx, req.kind, slot);
+        if (allow.length === 0) {
+            slot.state = { kind: 'failed', code: 'E-324', reason: 'allow set is empty' };
+            return slot.state;
+        }
+        const registry = registryOf(ctx);
+        if (registry === undefined) {
+            slot.state = { kind: 'failed', code: 'E-324', reason: 'agentPresets service unavailable or incomplete' };
+            return slot.state;
+        }
+        try {
+            const document = await registry.readDocument(req.parentPresetId);
+            const definition = composeRestrictedPresetDefinition(document, { kind: req.kind, parentPresetId: req.parentPresetId, allow });
+            const release = await registry.register(definition);
+            slot.release = release;
+            slot.readyKey = key;
+            slot.state = { kind: 'ready', presetId: definition.id, parentPresetId: req.parentPresetId, allow };
+            installReleaseEffect(ctx, slot);
+            return slot.state;
+        }
+        catch (error) {
+            slot.readyKey = undefined;
+            slot.state = { kind: 'failed', code: 'E-324', reason: error instanceof Error ? error.message : String(error) };
+            return slot.state;
+        }
+    })();
+    try {
+        return await slot.inflight;
+    }
+    finally {
+        slot.inflight = undefined;
+    }
+}
+/** Read-only view of the current registration (doctor runtime row). */
+export function restrictedPresetState(ctx, kind) {
+    return SLOTS.get(ctx)?.get(kind)?.state;
+}
+/** Release the registration for one kind (HMR/tests); the fiber effect also calls this. */
+export async function disposeRestrictedPreset(ctx, kind) {
+    await releaseRestrictedPreset(ctx, kind);
+}
+//# sourceMappingURL=ensure.js.map

package/lib/types/composition/index.d.ts

@@ -0,0 +1,5 @@
+export * from './composer.ts';
+export * from './preset-ids.ts';
+export * from './restricted-preset.ts';
+export * from './ensure.ts';
+//# sourceMappingURL=index.d.ts.map

package/lib/types/composition/index.js

@@ -0,0 +1,7 @@
+// Composition subpath: the ONE composer implementation + preset identities + the restricted
+// preset lifecycle (see restricted-preset.ts / ensure.ts).
+export * from "./composer.js";
+export * from "./preset-ids.js";
+export * from "./restricted-preset.js";
+export * from "./ensure.js";
+//# sourceMappingURL=index.js.map

package/lib/types/composition/preset-ids.d.ts

@@ -0,0 +1,17 @@
+export type RestrictedPresetKind = 'reviewer' | 'maintainer';
+export declare const EVOLUTION_PRESET_IDS: readonly ["evolution", "evolution-ptc", "evolution-cordis", "evolution-minimal"];
+export declare const REVIEWER_PRESET_ID: "evolution-reviewer-readonly";
+export declare const MAINTAINER_PRESET_ID: "evolution-maintainer-readonly";
+export declare const RESTRICTED_TOOLS_ROW_ID: "evolution-restricted-tools";
+export declare const RESTRICTOR_MODULE: string;
+export declare const RESTRICTED_PRESET_DELIVERY: "runtime" | "installer";
+export interface RestrictedPresetDisplay {
+    readonly name: string;
+    readonly description: string;
+    readonly order: number;
+}
+export declare const RESTRICTED_PRESET_DISPLAY: Readonly<Record<RestrictedPresetKind, RestrictedPresetDisplay>>;
+export declare function restrictedPresetId(kind: RestrictedPresetKind): string;
+/** Trim, drop blanks, de-duplicate and sort: ONE spelling for an allow/deny set. */
+export declare function normalizeAllow(names: readonly string[]): readonly string[];
+//# sourceMappingURL=preset-ids.d.ts.map

package/lib/types/composition/preset-ids.js

@@ -0,0 +1,21 @@
+// The frozen preset identities and restricted-preset display/transport constants.
+import { scopedPackageName } from "../package-identity.js";
+// Derived from bases.json (single source: packages/evolution-agent/bases.json).
+export const EVOLUTION_PRESET_IDS = ['evolution', 'evolution-ptc', 'evolution-cordis', 'evolution-minimal'];
+export const REVIEWER_PRESET_ID = 'evolution-reviewer-readonly';
+export const MAINTAINER_PRESET_ID = 'evolution-maintainer-readonly';
+export const RESTRICTED_TOOLS_ROW_ID = 'evolution-restricted-tools';
+export const RESTRICTOR_MODULE = scopedPackageName('dsh-evolution-core/restrictor', import.meta.url);
+export const RESTRICTED_PRESET_DELIVERY = 'runtime';
+export const RESTRICTED_PRESET_DISPLAY = {
+    reviewer: { name: 'evolution reviewer (read-only)', description: 'Internal restricted preset used by the family review channel.', order: 900 },
+    maintainer: { name: 'evolution maintainer (read-only)', description: 'Internal restricted preset used by the family maintenance channel.', order: 901 },
+};
+export function restrictedPresetId(kind) {
+    return kind === 'reviewer' ? REVIEWER_PRESET_ID : MAINTAINER_PRESET_ID;
+}
+/** Trim, drop blanks, de-duplicate and sort: ONE spelling for an allow/deny set. */
+export function normalizeAllow(names) {
+    return [...new Set(names.map(name => name.trim()).filter(name => name !== ''))].sort();
+}
+//# sourceMappingURL=preset-ids.js.map

package/lib/types/composition/restricted-preset.d.ts

@@ -0,0 +1,36 @@
+import * as yaml from 'js-yaml';
+export declare const entryListSchema: yaml.Schema;
+import { type RestrictedPresetKind } from './preset-ids.ts';
+export interface PresetDocumentLike {
+    readonly agentPreset: string;
+    readonly content: string;
+}
+export interface PresetRegistryLike {
+    readDocument(agentPreset: string): Promise<PresetDocumentLike>;
+    register(definition: RestrictedPresetDefinition): Promise<() => Promise<void>>;
+}
+export interface RestrictedPresetDefinition {
+    readonly id: string;
+    readonly name: string;
+    readonly description: string;
+    readonly order: number;
+    readonly plugins: readonly unknown[];
+}
+export interface RestrictedPresetRequest {
+    readonly kind: RestrictedPresetKind;
+    readonly parentPresetId: string;
+    readonly allow: readonly string[];
+}
+export type RestrictedPresetState = {
+    readonly kind: 'ready';
+    readonly presetId: string;
+    readonly parentPresetId: string;
+    readonly allow: readonly string[];
+} | {
+    readonly kind: 'failed';
+    readonly code: 'E-324';
+    readonly reason: string;
+};
+export declare function parsePresetRows(content: string): readonly unknown[];
+export declare function composeRestrictedPresetDefinition(source: PresetDocumentLike, req: RestrictedPresetRequest): RestrictedPresetDefinition;
+//# sourceMappingURL=restricted-preset.d.ts.map

package/lib/types/composition/restricted-preset.js

@@ -0,0 +1,42 @@
+// Build one restricted preset DEFINITION by cloning the live parent preset rows and appending the
+// single restrictor row. The parent rows are read through agentPresets.readDocument (the Loader's
+// own YAML dialect), so the child keeps every base row the parent had.
+import * as yaml from 'js-yaml';
+import { errorText } from "../errors.js";
+// The Loader's entry-list YAML dialect: `JSON_SCHEMA` plus one `!!js` scalar tag whose node keeps
+// the source text for activation-time evaluation. It is DEFINED here rather than imported from the
+// platform's include package: the family library has to load in a tree where only the family libs
+// are built (the CI overlay runs the family tests against platform sources without building the
+// platform), and the two definitions must round-trip the same documents. The shape (JSON_SCHEMA
+// extended with the js tag, node `{ __jsExpr }`) is pinned by the parent document the registry
+// hands back and by its golden tests.
+const JsExpr = new yaml.Type('tag:yaml.org,2002:js', {
+    kind: 'scalar',
+    resolve: (data) => typeof data === 'string',
+    construct: (data) => ({ __jsExpr: data }),
+    represent: data => data.__jsExpr,
+});
+export const entryListSchema = yaml.JSON_SCHEMA.extend(JsExpr);
+import { RESTRICTED_PRESET_DISPLAY, RESTRICTED_TOOLS_ROW_ID, RESTRICTOR_MODULE, restrictedPresetId, normalizeAllow, } from "./preset-ids.js";
+export function parsePresetRows(content) {
+    const parsed = yaml.load(content, { schema: entryListSchema });
+    if (!Array.isArray(parsed))
+        throw new Error(errorText('e-324-restricted-preset-unavailable', { a1: 'parent preset composition is not a top-level list' }));
+    return parsed;
+}
+export function composeRestrictedPresetDefinition(source, req) {
+    const allow = normalizeAllow(req.allow);
+    if (allow.length === 0)
+        throw new Error(errorText('e-324-restricted-preset-unavailable', { a1: 'restricted preset needs a non-empty allow set' }));
+    const rows = parsePresetRows(source.content);
+    const display = RESTRICTED_PRESET_DISPLAY[req.kind];
+    const restrictorRow = { id: RESTRICTED_TOOLS_ROW_ID, name: RESTRICTOR_MODULE, config: { allow, presetId: restrictedPresetId(req.kind) } };
+    return {
+        id: restrictedPresetId(req.kind),
+        name: display.name,
+        description: display.description,
+        order: display.order,
+        plugins: [...rows, restrictorRow],
+    };
+}
+//# sourceMappingURL=restricted-preset.js.map

package/lib/types/constants.js

@@ -0,0 +1,223 @@
+/**
+ * Shared constants for the dsh-evolution plugin family.
+ *
+ * Two classes of value live here, deliberately separated by section so future
+ * edits do not blur the semantic boundary:
+ *
+ * 1. **Fixed protocol/format/security invariants** — changing these breaks an
+ *    on-disk format, a naming/format contract, a path-security boundary, or a
+ *    cross-component invariant. They are NOT exposed as deployment config.
+ *
+ * 2. **Cross-package shared tunable defaults** — the same semantic default is
+ *    read (with a config override path) by more than one package (e.g.
+ *    `evolution-policy` and `evolution-curator` both default `staleAfterDays`
+ *    to 30). Centralizing them here means one authoritative default: a config
+ *    override still applies per package, but the fallback is single-sourced.
+ *
+ * Package-private tunables (used by exactly one package) stay in that package,
+ * not here — see evolution-replay's `DEFAULT_WEIGHTS` and evolution-feedback's
+ * threshold, which are intentionally left where they are used.
+ * @module @lmzhen/dsh-evolution-core
+ */
+// ── Fixed protocol / format / security invariants ────────────────────────────
+/**
+ * Required argument names per `skill_manage` action — the SINGLE SOURCE read
+ * by the tool's argument gate (tool-skill-manage write-gates.ts) and the plan
+ * validator (evolution-plan-validator), so the two can never drift.
+ * OPT-05 (2026-09): the plan validator used to accept a `write_file`/
+ * `remove_file` op without `file_path` while the executor required it — the
+ * staged write then failed at EVERY approve until rejected.
+ * Rows here are the op-level requirements only: `delete` additionally
+ * requires `absorbed_into` at the PLAN layer (review passes may only delete
+ * into an umbrella) and `pin`/`unpin` are tool-only actions — each consumer
+ * adds its own extras on top of this table. An empty-string argument is NOT
+ * caught here (the tool's gate deliberately lets it reach the library for a
+ * more specific remedy message); the validator adds its own `.trim()`
+ * emptiness checks for payload fields.
+ */
+export const SKILL_ACTION_REQUIRED_FIELDS = {
+    create: ['name', 'content'],
+    edit: ['name', 'content'],
+    update: ['name', 'content'],
+    patch: ['name', 'old_string', 'new_string'],
+    delete: ['name'],
+    write_file: ['name', 'file_path', 'file_content'],
+    remove_file: ['name', 'file_path'],
+    restructure: ['name'],
+    pin: ['name'],
+    unpin: ['name'],
+};
+/** Skill frontmatter `name` validated for the file name (lowercase + hyphen).
+ * 计划 B-4 (v18): tightened to the UPSTREAM `SKILL_NAME` shape
+ * (`/^[a-z0-9]+(?:-[a-z0-9]+)*$/`, packages/skill/skill/src/index.ts:21). The
+ * old form admitted trailing/consecutive hyphens, which upstream
+ * `validateCandidate` throws on — and that throw aborts the WHOLE `ctx.skills`
+ * collection. The catalog provider still filters such legacy tree entries so
+ * an existing tree cannot break a session. */
+export const SKILL_NAME_RE = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
+/** Allowed skill support-file subdirectories (path-traversal boundary). */
+export const SUPPORT_DIRS = ['references', 'templates', 'scripts', 'assets'];
+/** Delimiter between durable memory entries (on-disk storage format). */
+export const ENTRY_DELIMITER = '\n§\n';
+/** Built-in skill names the curator must never lifecycle-manage. */
+export const PROTECTED_BUILTIN_SKILLS = new Set(['plan']);
+// ── Skill-limit bounds ───────────────────────────────────────────────────────
+// These are the values that make up `DEFAULT_SKILL_LIMITS` (the shared default
+// the tool config lowers/raises from). Kept under their historic names so the
+// public export surface is unchanged.
+export const MAX_SKILL_NAME_LENGTH = 64;
+export const MAX_DESCRIPTION_LENGTH = 1024;
+export const MAX_SKILL_CONTENT_CHARS = 100_000;
+/** How many content versions to retain per skill (skill-history.ts). 20 mirrors the count
+ * KiroCrew settled on for the same job (its `MAX_SKILL_VERSIONS`), and is an E2 deployment
+ * parameter — the value is a retention policy, not a protocol constant. */
+export const DEFAULT_SKILL_VERSION_KEEP = 20;
+/** The authoring DISCIPLINE band, taken from the upstream standard (archive §5):
+ * peer skills sit at 8-14k characters and a body pushing past 20k belongs in
+ * `references/*.md`. Deliberately separate from `MAX_SKILL_CONTENT_CHARS`: the
+ * hard ceiling is a deployment-tunable limit, this band is the authoring
+ * standard — deriving the band from the ceiling is exactly what let a 40k
+ * ceiling hide a 99k body without a single signal saying "split me" (V3). */
+export const AUTHORING_SPLIT_LINE_CHARS = 20_000;
+/** Upstream's conversion basis for CHARACTER LIMITS: 2.75 chars/token, labelled
+ * model-independent in the config template (\`cli-config.yaml.example:538\`), and the
+ * basis behind every quoted token figure there — memory 2200 chars ≈ 800 tokens,
+ * user 1375 ≈ 500, SKILL.md 100_000 ≈ 36k (\`tools/skill_manager_tool.py:455\`).
+ * Limits are deliberately conservative, so this is the basis a BORROWED LIMIT must
+ * be converted with. */
+export const UPSTREAM_LIMIT_CHARS_PER_TOKEN = 2.75;
+/** The platform's own estimate basis: \`CHARS_PER_TOKEN = 4\` in
+ * \`@deepseek-ai/dsh-token-meter/estimate.ts\` (its comment reads "used until exact
+ * tokenization is needed"), matching upstream's ESTIMATE-side heuristic — "~4
+ * chars/token is the usual English heuristic" (\`agent/prompt_builder.py:1179\`).
+ * Estimates use this; limits use the constant above. */
+export const PLATFORM_ESTIMATE_CHARS_PER_TOKEN = 4;
+export const MAX_SKILL_FILE_BYTES = 1_048_576;
+// ── Cross-package shared tunable defaults ────────────────────────────────────
+// Fallback defaults when no config override is set. Single-sourced here;
+// packages reference them via `z.default(DEFAULT_*)` or `config.x ?? DEFAULT_*`.
+export const DEFAULT_REVIEW_MEMORY_INTERVAL = 10;
+export const DEFAULT_REVIEW_SKILL_INTERVAL = 10;
+/** Skill-review completion channel trigger mode: 'cadence' | 'completion' | 'both'.
+ * 0.3.39 (V6-53 follow-up): default is 'cadence' — since 0.3.38 the cadence
+ * channel's review is executed at conversation END (deferred), so 'both' would
+ * inject a second (task-complete) prompt at the same boundary; the cadence
+ * deferral alone IS the end-of-conversation summary. */
+export const DEFAULT_SKILL_REVIEW_TRIGGER = 'cadence';
+/** Cumulative session tool calls before a session counts as "proven long" for the completion channel. */
+export const DEFAULT_SKILL_REVIEW_COMPLETION_MIN_TOOL_CALLS = 20;
+export const DEFAULT_SUBSTANTIVE_MIN_TOOL_CALLS = 3;
+export const DEFAULT_SUBSTANTIVE_MIN_USER_CHARS = 200;
+export const DEFAULT_SUBSTANTIVE_MIN_AGENT_CHARS = 500;
+export const DEFAULT_MAX_OPS_PER_PLAN = 32;
+export const DEFAULT_CURATOR_INTERVAL_HOURS = 168;
+export const DEFAULT_MIN_IDLE_HOURS = 2;
+export const DEFAULT_STALE_AFTER_DAYS = 30;
+export const DEFAULT_ARCHIVE_AFTER_DAYS = 90;
+/**
+ * Support-file count above which `references-sprawl` warns. **NOT CALIBRATED YET** — 60 is a
+ * placeholder: the platform corpus is empty (no platform skills available here), so the admission
+ * band cannot be checked. Until `gen-health-baseline` reports both corpora, the rule is
+ * REPORT-ONLY: its count must not be shown as a number on any surface (plan G4 ③).
+ */
+export const SUPPORT_SPRAWL_FILES = 60;
+export const DEFAULT_MEMORY_CHAR_LIMIT = 2200;
+export const DEFAULT_USER_CHAR_LIMIT = 1375;
+/** Consolidation-failure backoff cap, shared by MemoryStore and memory-files' Config default. */
+export const DEFAULT_CONSOLIDATION_FAILURES = 3;
+/** F-20 (v18): the authored-body budget and the hard ceiling are the same
+ * number today. Derive it so a future divergence is one edit, not two names
+ * that silently disagree. */
+export const DEFAULT_SKILL_CONTENT_CHARS = MAX_SKILL_CONTENT_CHARS;
+/** P3-19 (v14): defaults that were written twice (schema `.default()` AND the
+ * clamp fallback literal) now have one home per value. */
+export const DEFAULT_REVIEW_TIMEOUT_MS = 120_000;
+export const DEFAULT_REVIEW_CONTEXT_MESSAGES = 60;
+export const DEFAULT_REVIEW_MESSAGE_CHARS = 2_000;
+export const DEFAULT_CURATOR_BOOT_GRACE_SECONDS = 10;
+export const DEFAULT_CURATOR_REVIEW_MAX_TOKENS = 2_048;
+/** Threat-scan WINDOW SIZE (not a total cap — E-12: the whole text is scanned in
+ * overlapping windows, so content beyond this stays in scope). The coverage
+ * floor is `PATTERN_OVERLAP + 1` (V6-05). Single home for the core scanners'
+ * default parameter and clamp fallback, plus evolution-threat's Config default
+ * — the two packages previously wrote 65_536 independently (G0/S0.1). */
+export const DEFAULT_THREAT_MAX_SCAN_CHARS = 65_536;
+/** 0.3.17 (S3.10, T-1): control-plane fields a model-facing write call may
+ * never carry — single source for plan-validator, evolution-policy and the
+ * threat scanner (they used to each hardcode the list).
+ * P2-13 (v37): staged_from_sha256 joins the list — it is the replay's own
+ * staleness anchor, and the tool-arguments root is an OPEN object, so a model
+ * could otherwise choose the anchor that decides the write's outcome. */
+export const FORBIDDEN_CONTROL_KEYS = ['policy', 'threshold', 'prompt_hash', 'model_route', 'evolution_config', 'staged_from_sha256'];
+/** 0.3.17 (S3.10): the model-facing write tools the policy guard and threat
+ * scanner cover. */
+export const EVOLUTION_WRITE_TOOLS = ['memory', 'skill_manage'];
+/** Hermes authoring quality bar for descriptions (the 60-char Rule). The
+ * platform's own index limit stays in validateFrontmatter; this bar is the
+ * target the authoring standard names, enforced as ADVISORY feedback.
+ * 0.3.16 (T-4): moved here from skill-store.ts so drift-signals (pure, no IO)
+ * can reference it without importing the skill-store module. */
+export const AUTHORING_DESCRIPTION_BAR = 60;
+/** The PLATFORM's default cap on the description a skill catalog shows —
+ * `catalogDescriptionMaxLength` on the platform's `tool-skill` row (default 500).
+ *
+ * Recorded here because it is the third number in the description-length relationship, and the one
+ * that is easiest to misread as a family rule: the family's own host/all rows SET that field to
+ * `AUTHORING_DESCRIPTION_BAR` (60), so what a family deployment truncates at is the ROW's value —
+ * this default only governs compositions that do not override it. It is NOT a refusal threshold:
+ * the only refusal is `MAX_DESCRIPTION_LENGTH` / the row's `maxDescriptionLength`, and the catalog
+ * cut is a view, not a validation. See tool-skill-manage/README.md for the three-number table. */
+export const PLATFORM_CATALOG_DESCRIPTION_DEFAULT = 500;
+/** The split hint both size refusals share (0.5.0 V1). The same sentence used to
+ * be copied into validateFrontmatter AND the patch path, and neither copy named
+ * where the content should go — the upstream cap message names the destination
+ * directories, and that is the part a model actually acts on. */
+export const CONTENT_SPLIT_HINT = '建议拆成更小的 SKILL.md，把支撑文件放进 references/ 或 templates/。';
+/** V27 G2.4: the largest millisecond delay a timer accepts. `AbortSignal.timeout`
+ * (and `setTimeout`) coerce anything larger to 1ms after a Node warning, so a
+ * timeout configured above this ceiling silently collapses to "immediately
+ * aborted". The curator's review timeout and the review timeout each carried
+ * their own copy of the literal; the bound is one protocol constant.
+ * (v19 P2-10 corrected the value from 2^32-1 to Node's real 2^31-1 ceiling.) */
+export const MAX_TIMER_DELAY_MS = 2_147_483_647;
+/**
+ * Model-facing budget of one `maintenance_probe` call (ms) — a HANG GUARD, not a
+ * performance knob.
+ *
+ * Measured (2026-10-10): one probe costs 188/220/225 ms on the deployed library
+ * (28 skills / 418 KB) and scales linearly at ~5.5 ms per skill (100 skills
+ * 0.4-0.6 s, 400 skills 1.9-2.5 s), so this default is ~50x the worst measured
+ * case and ~600x the deployed one — it will not fire in normal use, and the
+ * ~305 s desktop interaction wall is ~5e4 skills away.
+ *
+ * It exists for the state the probe cannot report itself: a provider that never
+ * answers. The platform's tool-timeout guard reads this budget off the tool
+ * definition and turns the hang into a diagnosable `tool call timed out after
+ * <ms>ms` error result, instead of a request that ends with nothing to read.
+ * Reopen the default when the library approaches ~1e4 skills, when the
+ * `evolutionIo` provider stops being local, or when a model leg enters a tool's
+ * execute (the same conditions the probe's own note lists).
+ */
+export const DEFAULT_PROBE_TIMEOUT_MS = 120_000;
+/** V27 G2.4: the model each review/curation leg defaults to. The policy schema,
+ * the policy resolver and the curator's LLM nomination pass each carried their
+ * own copy of these strings — a deployment that changed the policy default used
+ * to leave the curator passing a different model than the reviews. */
+export const DEFAULT_MEMORY_REVIEW_MODEL = 'deepseek-v4-flash';
+export const DEFAULT_SKILL_REVIEW_MODEL = 'deepseek-v4-pro';
+export const DEFAULT_CURATOR_MODEL = 'deepseek-v4-pro';
+// ── Model-visible prompt-section orders ──────────────────────────────────────
+// The platform's `PromptSection.order` scale is a platform-internal constant
+// table (`SECTION_ORDERS`, core/system-prompt), not a published contract: the
+// 0.1.5 line re-scaled every first-party section from -1000 to 10200
+// (`DEPLOYMENT_PERSONA_SUFFIX` is the highest), so a third-party literal that
+// used to sort last could silently sort into the middle of the tool guidance.
+// Both family sections are operational guidance for the model, so they belong
+// AFTER every first-party section on every line. These values sit above 0.1.5's
+// maximum; scripts/verify-platform-contract.mjs --upstream re-reads the
+// platform's scale and fails when it grows past them.
+/** Order of the `evolution:memory-guidance` section (before the skills one). */
+export const MEMORY_GUIDANCE_SECTION_ORDER = 11000;
+/** Order of the `evolution-skills-guidance` section (last of the two). */
+export const SKILLS_GUIDANCE_SECTION_ORDER = 11100;
+//# sourceMappingURL=constants.js.map

package/lib/types/cost.js

@@ -0,0 +1,67 @@
+/**
+ * Context-cost accounting for skill bodies (design §5.2).
+ *
+ * A raw character count is a poor budget: the same 100k characters cost very
+ * different amounts of context in Chinese-heavy prose and in English. The
+ * weighted unit makes the two comparable, and the token range exists only to
+ * make the load cost visible next to the character count — it is an ESTIMATE,
+ * never a measurement.
+ *
+ * Accounting basis: the ON-DISK form (`skillMdOnDisk()`, the same view the
+ * write limit uses), so a body that is exactly at the limit cannot read as
+ * over-limit here and pass there (the v37 P2-1 deadlock class).
+ */
+import { UPSTREAM_LIMIT_CHARS_PER_TOKEN } from "./constants.js";
+import { skillMdOnDisk } from "./frontmatter.js";
+/** Token weight of one CJK / kana / full-width code unit on the LIMIT basis —
+ * upstream's model-independent conversion is 2.75 chars/token for prose, and CJK
+ * prose is ~1 token per character (the conservative end of the 0.6–1.0 range the
+ * estimate side reports). Thresholds are compared on THIS basis so a borrowed
+ * character line keeps its meaning; the estimate range below reports the spread. */
+export const TOKEN_CJK_WEIGHT = 1;
+/** Token weight of one non-CJK code unit on the LIMIT basis (1 / 2.75 ≈ 0.364). */
+export const TOKEN_ASCII_WEIGHT = 1 / UPSTREAM_LIMIT_CHARS_PER_TOKEN;
+/** Token-per-unit bounds of the estimate range (CJK: 0.6–1.0, non-CJK: 1/4–1/3).
+ * The range is the 4-chars/token estimate family, so on ASCII-heavy bodies the
+ * LIMIT-basis `tokens` point can sit above `tokensHigh` (1/2.75 > 1/3): the two
+ * answer different questions and are never nested by construction. */
+export const COST_CJK_TOKEN_LOW = 0.6;
+export const COST_CJK_TOKEN_HIGH = 1;
+export const COST_ASCII_TOKEN_LOW = 0.25;
+export const COST_ASCII_TOKEN_HIGH = 1 / 3;
+/** The token line a borrowed CHARACTER threshold draws for ONE body: 20k characters
+ * of THIS composition, expressed in the same tokens `bodyCost` counts. Comparing
+ * `tokens` against this line is deliberately equivalent to "chars >= line" — that
+ * equivalence is what keeps a borrowed line's textual effect identical — while the
+ * judgment itself, and every number reported, stays on the token scale.
+ * @param lineChars - the borrowed character line (whole-body characters).
+ * @param cost - the body's own cost breakdown.
+ * @returns the equivalent token line (0 when the body is empty). */
+export function tokenLineFor(lineChars, cost) {
+    if (cost.chars === 0)
+        return 0;
+    return Math.round((lineChars * cost.tokens) / cost.chars);
+}
+/** CJK ideographs, kana, full-width forms and CJK punctuation. */
+const CJK_RE = /[\u3000-\u303f\u3040-\u30ff\u3400-\u4dbf\u4e00-\u9fff\uf900-\ufaff\uff00-\uffef]/g;
+/**
+ * Cost of one skill body.
+ * @param content - the body text as written (trailing whitespace is normalized
+ *   away by the on-disk accounting, so callers need not pre-trim).
+ * @returns the cost breakdown; an empty body answers all-zero.
+ */
+export function bodyCost(content) {
+    const onDisk = skillMdOnDisk(content);
+    const cjk = [...onDisk.matchAll(CJK_RE)].length;
+    const chars = onDisk.length;
+    const ascii = chars - cjk;
+    return {
+        chars,
+        cjk,
+        ascii,
+        tokens: Math.round(cjk * TOKEN_CJK_WEIGHT + ascii * TOKEN_ASCII_WEIGHT),
+        tokensLow: Math.round(cjk * COST_CJK_TOKEN_LOW + ascii * COST_ASCII_TOKEN_LOW),
+        tokensHigh: Math.round(cjk * COST_CJK_TOKEN_HIGH + ascii * COST_ASCII_TOKEN_HIGH),
+    };
+}
+//# sourceMappingURL=cost.js.map

package/lib/types/curator.d.ts

@@ -93,6 +93,7 @@ export interface CuratorRunReport {
     llmReviewEnabled?: boolean;
     /** V6-35 (0.3.36): lenient-parse shape notes from the LLM nomination block. */
     nominationsWarnings?: string[];
+    scanWarnings?: string[];
     /** 0.5.0 V1 (design §16.6-④): archived entries past the retention window that
      * the CURRENT policy keeps rather than deletes. Present (even empty) only when
      * the retention policy was `report`, so a report cannot read as "nothing
@@ -117,6 +118,7 @@ export interface CuratorReportInput {
     snapshotPath?: string;
     llmReviewEnabled?: boolean;
     nominationsWarnings?: readonly string[];
+    scanWarnings?: readonly string[];
     wouldPrune?: readonly string[] | null;
 }
 export declare function buildCuratorRunReport(input: CuratorReportInput): CuratorRunReport;