@lmzhen/dsh-evolution-core 0.26.15 → 0.27.0

package/lib/types/fuzzy-match.js

@@ -0,0 +1,135 @@
+/**
+ * Fuzzy string matching and replacement for patch/restructure edits of skill files.
+ *
+ * Split out of skill-store.ts (S2-1): pure text functions with no store state.
+ * The store imports the scan, the budgets and the replace entry points directly;
+ * none of them is re-exported, so the package export surface is unchanged.
+ */
+function fuzzyIndexOf(content, pattern, from = 0) {
+    const isSpace = (char) => char !== undefined && /[ \t]/.test(char);
+    const escaped = (char) => {
+        if (char === 'n')
+            return '\n';
+        if (char === 't')
+            return '\t';
+        if (char === 'r')
+            return '\r';
+        return null;
+    };
+    for (let start = from; start < content.length; start += 1) {
+        let contentIndex = start;
+        let patternIndex = 0;
+        while (patternIndex < pattern.length && contentIndex < content.length) {
+            const patternChar = pattern[patternIndex];
+            const contentChar = content[contentIndex];
+            if (isSpace(patternChar)) {
+                // A pattern whitespace run consumes its full run plus any content run
+                // (even a shorter or empty one) before matching the next non-space.
+                while (patternIndex < pattern.length && isSpace(pattern[patternIndex]))
+                    patternIndex += 1;
+                while (contentIndex < content.length && isSpace(content[contentIndex]))
+                    contentIndex += 1;
+                continue;
+            }
+            const escapedChar = patternChar === '\\' ? escaped(pattern[patternIndex + 1]) : null;
+            if (escapedChar !== null && contentChar === escapedChar) {
+                patternIndex += 2;
+                contentIndex += 1;
+                continue;
+            }
+            if (patternChar === contentChar) {
+                contentIndex += 1;
+                patternIndex += 1;
+                continue;
+            }
+            break;
+        }
+        if (patternIndex === pattern.length)
+            return [start, contentIndex];
+    }
+    return null;
+}
+/** V6-17 (0.3.37): the fuzzy-patch scan is O(n·m) with no input bound; a
+ * non-exact anchor past these budgets would block the event loop (measured
+ * ~6s at 20k×20k). Exact matches go through the fast `includes` path and stay
+ * allowed regardless of size. */
+export const FUZZY_MAX_PATTERN_CHARS = 4096;
+export const FUZZY_MAX_WORK = 8_000_000;
+/** Trim leading whitespace of the first line and trailing whitespace of the last line. */
+export function trimPatternBoundaries(pattern) {
+    const from = pattern.search(/\S/);
+    const trimmed = from < 0 ? pattern : pattern.slice(from);
+    const trailing = trimmed.search(/\s+$/);
+    return trailing < 0 ? trimmed : trimmed.slice(0, trailing);
+}
+/** Replace only the fuzzy-matched span, preserving all surrounding bytes.
+ * V7-11 (0.3.44): the replaceAll loop accumulates the per-scan cost — the
+ * single-scan budget at the caller only bounded ONE fuzzyIndexOf, while an
+ * unbounded number of matches × O(n·m) each could still stall the loop.
+ * When the accumulated cost exceeds the budget the whole replace fails
+ * (null) instead of partially applying an arbitrary prefix. */
+function fuzzyReplace(content, oldString, newString, replaceAll) {
+    let current = content;
+    let scanFrom = 0;
+    let totalWork = 0;
+    for (;;) {
+        totalWork += current.length * oldString.length;
+        if (totalWork > FUZZY_MAX_WORK)
+            return null;
+        const match = fuzzyIndexOf(current, oldString, scanFrom);
+        if (match === null)
+            return current;
+        const [start, end] = match;
+        const next = current.slice(0, start) + newString + current.slice(end);
+        if (!replaceAll)
+            return next;
+        current = next;
+        // Resume scanning after the inserted span: a self-containing newString must
+        // not be re-matched (mirrors String.replaceAll and guarantees termination).
+        scanFrom = start + newString.length;
+    }
+}
+export function fuzzyPatch(content, oldString, newString, replaceAll = false) {
+    // An empty oldString would `includes('')` trivially and splice newString
+    // between every character; refuse it at the boundary (P0-5).
+    if (oldString === '')
+        return null;
+    if (content.includes(oldString)) {
+        // 0.3.16 (E-2): a STRING replacement expands $&/$`/$'/$$ special
+        // sequences even in the exact-match fast path — a model writing a shell
+        // replacement (`100$'`) silently corrupted the file, and the fuzzy path
+        // (string concat, literal) disagreed with the fast path. The replacement
+        // function returns the newString verbatim; the replaceAll branch's
+        // split/join is already literal.
+        return replaceAll ? content.split(oldString).join(newString) : content.replace(oldString, () => newString);
+    }
+    const boundary = trimPatternBoundaries(oldString);
+    // A whitespace-only pattern has no non-whitespace footprint; matching it
+    // would hit an empty span and splice content without consuming anything.
+    if (boundary === '')
+        return null;
+    // Stage 1: boundary trim — the model often cites a line with its leading
+    // indent (or a trailing space); trimming only the pattern's first/last line
+    // keeps the replacement span on the real text without touching other bytes.
+    if (boundary !== oldString) {
+        if (fuzzyIndexOf(content, boundary) !== null) {
+            const patched = fuzzyReplace(content, boundary, newString, replaceAll);
+            // F-317: patched === content is an IDENTITY replacement (the effective
+            // old/new text are equal), NOT "no match". Return the original so the
+            // caller's noop judgment (patch()) reports it as unchanged — returning
+            // null here made patch() say "Could not find old_string" for a patch
+            // that was actually a no-op. `null` remains exclusively "no match".
+            return patched;
+        }
+    }
+    // Stage 2: whitespace-plus-escape tolerance (pattern `\n`/`\t`/`\r` literals
+    // match real characters, runs match runs); replacement lands on the span
+    // only, so file indentation/formatting survives.
+    if (fuzzyIndexOf(content, oldString) !== null) {
+        const patched = fuzzyReplace(content, oldString, newString, replaceAll);
+        return patched;
+    }
+    return null;
+}
+/** Deterministic section-extraction plan facts; the caller owns the IO and the append semantics. */
+//# sourceMappingURL=fuzzy-match.js.map

package/lib/types/gates.js

@@ -0,0 +1,51 @@
+/**
+ * The control-plane protection sets, held once and queried everywhere
+ * (decision B, rc.44 plan M2): the lifecycle engine, the scope view, the LLM
+ * nomination gate and the control-plane consolidate all answer "is this name
+ * off limits — and why" from the same instance, so the gate sets can never
+ * drift apart the way the three pre-rc.46 implementations did.
+ *
+ * Scope boundary: a GateSet covers NAME-SET protections only. Marker-based
+ * protections (pinned / bundled / hub-installed) are file markers resolved by
+ * `SkillLibrary.writeProtection` / `deleteProtection` — they depend on the
+ * filesystem and the write origin, not on a name list.
+ * @module @lmzhen/dsh-evolution-core
+ */
+import { PROTECTED_BUILTIN_SKILLS } from "./constants.js";
+export class EvolutionGateSet {
+    exclude;
+    referenced;
+    suppressed;
+    constructor(inputs = {}) {
+        this.exclude = inputs.exclude ?? new Set();
+        this.referenced = inputs.referenced ?? new Set();
+        this.suppressed = inputs.suppressed ?? new Set();
+    }
+    /**
+     * The first protection blocking this name, or null. Any hit blocks — the
+     * order is diagnostic only, so a name in two sets reports the first.
+     */
+    blockReason(name) {
+        if (this.exclude.has(name))
+            return 'excluded';
+        if (this.referenced.has(name))
+            return 'referenced';
+        if (this.suppressed.has(name))
+            return 'suppressed';
+        if (PROTECTED_BUILTIN_SKILLS.has(name))
+            return 'protected-builtin';
+        return null;
+    }
+    isBlocked(name) {
+        return this.blockReason(name) !== null;
+    }
+}
+/** Build a GateSet from the curator-style config field names. */
+export function createGateSet(config) {
+    return new EvolutionGateSet({
+        exclude: config.excludeSkillNames,
+        referenced: config.referencedSkillNames,
+        suppressed: config.suppressedNames,
+    });
+}
+//# sourceMappingURL=gates.js.map

package/lib/types/guards.js

@@ -0,0 +1,27 @@
+/**
+ * The family's plain-object predicate, in ONE place (v46 G7.1 / audit A8).
+ *
+ * The audit found the same guard — "a non-null object that is not an array" — rewritten fifteen
+ * times across nine packages, four times inside core itself, and with two byte-identical `asRecord`
+ * copies in evolution-policy and evolution-threat. This module is the single definition; callers
+ * import it instead of spelling the clause again.
+ *
+ * @module @lmzhen/dsh-evolution-core
+ */
+/**
+ * Is this a non-null, non-array object (what JSON calls an object)?
+ * @param value - the value to test.
+ * @returns whether it is a plain object.
+ */
+export function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+/**
+ * Read a value as a record, or undefined when it is not one.
+ * @param value - the value to read.
+ * @returns the value typed as a record, or undefined.
+ */
+export function asRecord(value) {
+    return isRecord(value) ? value : undefined;
+}
+//# sourceMappingURL=guards.js.map

package/lib/types/health-baseline.js

@@ -0,0 +1,63 @@
+/*
+ * health-baseline — calibration and rule ADMISSION, as pure functions (G1, contract §4).
+ *
+ * A rule may only enter the engine when it is worth its noise, and that is a fact about two corpora,
+ * not an opinion: the platform's own skills must not trip it at all (a rule the shipped library
+ * already violates is a rule nobody can satisfy), and on the user's library it must bite often
+ * enough to matter but not so often that it is furniture. This module holds the counting and the
+ * verdict; walking the corpora and writing the artifact stay in the caller.
+ *
+ * Pure: no IO. `values` is keyed by rule id so a diff between two baselines is a map diff.
+ */
+import { lintSkill, RULES } from "./skill-lint.js";
+export const DEFAULT_ADMISSION = { minUserHitRate: 0.05, maxUserHitRate: 0.25 };
+export function buildHealthBaseline(skills) {
+    const values = {};
+    for (const rule of RULES)
+        values[rule.id] = { platformHits: 0, userHits: 0, userHitRate: 0 };
+    let user = 0;
+    let platform = 0;
+    for (const skill of skills) {
+        if (skill.corpus === 'user')
+            user += 1;
+        else
+            platform += 1;
+        for (const finding of lintSkill(skill.facts)) {
+            const row = values[finding.rule];
+            if (row === undefined)
+                continue;
+            if (skill.corpus === 'user')
+                row.userHits += 1;
+            else
+                row.platformHits += 1;
+        }
+    }
+    for (const row of Object.values(values))
+        row.userHitRate = user === 0 ? 0 : row.userHits / user;
+    return {
+        unit: 'chars',
+        scope: 'references markdown file count',
+        corpora: { user, platform },
+        values,
+    };
+}
+/** The admission verdict for ONE rule id (contract §4): platform corpus must not trip it, and the
+ * user-library hit rate must land inside the band. Every failure names the number it failed on. */
+export function admissionVerdict(baseline, ruleId, thresholds = DEFAULT_ADMISSION) {
+    const row = baseline.values[ruleId];
+    const failures = [];
+    if (row === undefined)
+        return { admitted: false, failures: ['rule ' + ruleId + ' has no baseline row'] };
+    if (baseline.corpora.platform === 0)
+        failures.push('no platform-corpus skills measured — a vacuous 0-hit count admits any rule');
+    else if (row.platformHits !== 0)
+        failures.push('platform corpus trips ' + ruleId + ' ' + String(row.platformHits) + ' time(s) — a rule the shipped library violates is unsatisfiable');
+    if (baseline.corpora.user === 0)
+        failures.push('no user-library skills measured — a rate over an empty corpus proves nothing');
+    else if (row.userHitRate < thresholds.minUserHitRate)
+        failures.push(ruleId + ' hits ' + row.userHitRate.toFixed(3) + ' of the user library, below ' + String(thresholds.minUserHitRate) + ' — too rare to be worth a rule');
+    else if (row.userHitRate > thresholds.maxUserHitRate)
+        failures.push(ruleId + ' hits ' + row.userHitRate.toFixed(3) + ' of the user library, above ' + String(thresholds.maxUserHitRate) + ' — furniture, no signal');
+    return { admitted: failures.length === 0, failures };
+}
+//# sourceMappingURL=health-baseline.js.map

package/lib/types/http-routes.d.ts

@@ -1,49 +1,81 @@
 /**
- * The loopback HTTP plumbing every family route surface shares (E-302-era conventions).
+ * The Host data-plane contract + Fetch-shaped helpers every family route surface shares (W1/W6).
  *
- * WHY THIS IS IN CORE: the fence, the bounded body reader and the JSON writer are the same for every
- * family route surface, and `evolution-core` is the one package all of them already depend on. The
- * canonical platform implementation (packages/client/connection/src/api-request-trust.ts) is not part
- * of that package's published surface, so the family keeps its own copy of the RULES here — once.
+ * WHY THIS IS IN CORE: HOST_ROUTES is the ONE path table (clients are generated from it), and the
+ * response/body helpers are thin platform-Request utilities. The loopback fence that used to live here
+ * is GONE (G4): trust, browser auth and owner admission are applied by the platform's connection
+ * carrier BEFORE a route's fetch(request) runs, so a family copy of those rules was a second admission
+ * path (and did diverge).
  *
  * Layering: pure transport. Nothing here knows about skills, approvals, curators or route tables.
  * @module @lmzhen/dsh-evolution-core/http-routes
  */
-import type { IncomingMessage, ServerResponse } from 'node:http';
+import type { Context } from '@deepseek-ai/cordis';
 /** Largest request body a family route accepts; a bigger one reads as "no body" (400 from the handler). */
 export declare const MAX_REQUEST_BODY_BYTES: number;
-/** The request facts the trust fence reads: a Node request, or the same fields in a spec fixture. */
-export interface FenceRequest {
-    readonly headers: Record<string, string | string[] | undefined>;
-    readonly socket?: {
-        readonly remoteAddress?: string | undefined;
-    } | undefined;
-}
 /**
- * Whether one request may enter a family route.
- *
- * Rules, in order: the SOCKET must be loopback (authoritative — X-Forwarded-For is never trusted), the
- * Host header must name a loopback authority (DNS-rebinding defense), an explicit cross-site marker is
- * refused, and an attached Origin must be exactly this authority.
- * @param request - the request to judge.
- * @returns true when the request may proceed.
- */
-export declare function isLoopbackRequest(request: FenceRequest): boolean;
-/** Write one JSON response. The routes own their response lifecycle, so every path ends here. */
-export declare function writeJson(res: ServerResponse, status: number, value: unknown): void;
-/**
- * Read one JSON request body, bounded.
- * @param req - the request.
- * @returns the parsed value, or null when the body is oversized, empty, or not JSON.
+ * Read one JSON request body that must be an OBJECT, bounded.
+ * @param request - the platform Fetch Request handed to a route.
+ * @param maxBytes - the body bound (defaults to MAX_REQUEST_BODY_BYTES).
+ * @returns the body as a plain object, or null when it is absent, oversized, not JSON, or not an object.
  */
-export declare function readJsonBody(req: IncomingMessage): Promise<unknown>;
+export declare function readJsonObject(request: Request, maxBytes?: number): Promise<Record<string, unknown> | null>;
+export type HttpMethod = 'GET' | 'HEAD' | 'POST';
+export type HostRoutePath = `/api/dsh-evolution/${string}`;
+export interface HostRouteSpec {
+    readonly path: HostRoutePath;
+    readonly methods: readonly HttpMethod[];
+    readonly requestBody: 'buffered' | 'streaming';
+}
+export interface ConnectionFetchRouteLike extends HostRouteSpec {
+    fetch(request: Request): Promise<Response>;
+}
+export interface DecisionAudit {
+    readonly channel: 'connection.fetch' | 'command';
+    readonly principal: 'owner';
+    readonly deploymentAllowsRemote: boolean;
+}
+export declare const HOST_ROUTES: {
+    readonly approval: {
+        readonly pending: "/api/dsh-evolution/approval/pending";
+        readonly preview: "/api/dsh-evolution/approval/preview";
+        readonly approve: "/api/dsh-evolution/approval/approve";
+        readonly reject: "/api/dsh-evolution/approval/reject";
+    };
+    readonly skillHistory: {
+        readonly skills: "/api/dsh-evolution/skill-history/skills";
+        readonly versions: "/api/dsh-evolution/skill-history/versions";
+        readonly diff: "/api/dsh-evolution/skill-history/versions/diff";
+        readonly body: "/api/dsh-evolution/skill-history/versions/body";
+        readonly undo: "/api/dsh-evolution/skill-history/undo";
+        readonly health: "/api/dsh-evolution/skill-history/health";
+    };
+    readonly skillHealth: {
+        readonly rows: "/api/dsh-evolution/skill-health/rows";
+    };
+    readonly diagnostics: {
+        readonly view: "/api/dsh-evolution/diagnostics";
+    };
+};
+export type HostSurface = {
+    readonly available: true;
+    readonly allowsRemoteAuthorities: boolean;
+} | {
+    readonly available: false;
+    readonly code: 'E-325';
+    readonly reason: 'connection-missing' | 'service-absent';
+};
+export declare function hostSurface(ctx: Context): HostSurface;
 /**
- * Read one JSON request body that must be an OBJECT.
+ * Register the family host surface on the platform's exact-route carrier.
  *
- * The three route surfaces all take named fields, so "array or scalar" is a bad request rather than a
- * shape each handler has to re-check.
- * @param req - the request.
- * @returns the body as a plain object, or null when it is absent, oversized, not JSON, or not an object.
+ * The platform owns admission (Host/Origin hygiene + browserAuth + exact-route owner peer) and the
+ * disposer is bound to the CALLING fiber, not the connection service: the connection service can
+ * outlive a reloaded family fiber, so the family must release its own registrations on dispose.
+ * Routes carry the audit snapshot taken at registration time (deployment-level facts only — the
+ * exact-route handler receives a Request, not the peer identity).
  */
-export declare function readJsonObject(req: IncomingMessage): Promise<Record<string, unknown> | null>;
+export declare function registerHostRoutes(owner: Context, build: (audit: DecisionAudit) => readonly ConnectionFetchRouteLike[]): void;
+export declare function json(status: number, body: unknown): Response;
+export declare function methodNotAllowed(allowed: readonly HttpMethod[]): Response;
 //# sourceMappingURL=http-routes.d.ts.map

package/lib/types/http-routes.js

@@ -0,0 +1,135 @@
+/**
+ * The Host data-plane contract + Fetch-shaped helpers every family route surface shares (W1/W6).
+ *
+ * WHY THIS IS IN CORE: HOST_ROUTES is the ONE path table (clients are generated from it), and the
+ * response/body helpers are thin platform-Request utilities. The loopback fence that used to live here
+ * is GONE (G4): trust, browser auth and owner admission are applied by the platform's connection
+ * carrier BEFORE a route's fetch(request) runs, so a family copy of those rules was a second admission
+ * path (and did diverge).
+ *
+ * Layering: pure transport. Nothing here knows about skills, approvals, curators or route tables.
+ * @module @lmzhen/dsh-evolution-core/http-routes
+ */
+import { isRecord } from "./guards.js";
+/** Largest request body a family route accepts; a bigger one reads as "no body" (400 from the handler). */
+export const MAX_REQUEST_BODY_BYTES = 64 * 1024;
+/**
+ * Read one JSON request body that must be an OBJECT, bounded.
+ * @param request - the platform Fetch Request handed to a route.
+ * @param maxBytes - the body bound (defaults to MAX_REQUEST_BODY_BYTES).
+ * @returns the body as a plain object, or null when it is absent, oversized, not JSON, or not an object.
+ */
+export async function readJsonObject(request, maxBytes = MAX_REQUEST_BODY_BYTES) {
+    const buffer = await request.arrayBuffer();
+    if (buffer.byteLength > maxBytes || buffer.byteLength === 0)
+        return null;
+    let parsed;
+    try {
+        parsed = JSON.parse(Buffer.from(buffer).toString('utf8'));
+    }
+    catch {
+        return null;
+    }
+    return isRecord(parsed) ? parsed : null;
+}
+export const HOST_ROUTES = {
+    approval: {
+        pending: '/api/dsh-evolution/approval/pending',
+        preview: '/api/dsh-evolution/approval/preview',
+        approve: '/api/dsh-evolution/approval/approve',
+        reject: '/api/dsh-evolution/approval/reject',
+    },
+    skillHistory: {
+        skills: '/api/dsh-evolution/skill-history/skills',
+        versions: '/api/dsh-evolution/skill-history/versions',
+        diff: '/api/dsh-evolution/skill-history/versions/diff',
+        body: '/api/dsh-evolution/skill-history/versions/body',
+        undo: '/api/dsh-evolution/skill-history/undo',
+        health: '/api/dsh-evolution/skill-history/health',
+    },
+    skillHealth: {
+        rows: '/api/dsh-evolution/skill-health/rows',
+    },
+    diagnostics: {
+        view: '/api/dsh-evolution/diagnostics',
+    },
+};
+export function hostSurface(ctx) {
+    const connection = ctx.get('connection');
+    if (connection === undefined)
+        return { available: false, code: 'E-325', reason: 'connection-missing' };
+    const allows = connection.allowsRemoteAuthorities === true;
+    return { available: true, allowsRemoteAuthorities: allows };
+}
+/**
+ * Register the family host surface on the platform's exact-route carrier.
+ *
+ * The platform owns admission (Host/Origin hygiene + browserAuth + exact-route owner peer) and the
+ * disposer is bound to the CALLING fiber, not the connection service: the connection service can
+ * outlive a reloaded family fiber, so the family must release its own registrations on dispose.
+ * Routes carry the audit snapshot taken at registration time (deployment-level facts only — the
+ * exact-route handler receives a Request, not the peer identity).
+ */
+export function registerHostRoutes(owner, build) {
+    const injecting = owner;
+    if (typeof injecting.inject !== 'function')
+        throw new Error('host routes require a context that owns inject()');
+    injecting.inject(['connection'], (scope) => {
+        const connection = scope.connection;
+        if (connection === undefined || connection.fetch === undefined || typeof connection.fetch.register !== 'function') {
+            throw new Error('connection service is mounted without fetch.register()');
+        }
+        const register = connection.fetch.register.bind(connection.fetch);
+        const audit = {
+            channel: 'connection.fetch',
+            principal: 'owner',
+            deploymentAllowsRemote: connection.allowsRemoteAuthorities === true,
+        };
+        const routes = build(audit);
+        for (const route of routes) {
+            if (!route.path.startsWith('/api/dsh-evolution/')) {
+                throw new Error('host route path must carry the /api/dsh-evolution/ prefix: ' + route.path);
+            }
+        }
+        const effect = scope.effect;
+        if (typeof effect !== 'function')
+            throw new Error('connection scope has no effect() to own the registration');
+        effect.call(scope, () => {
+            const disposers = [];
+            try {
+                for (const route of routes)
+                    disposers.push(register(route));
+            }
+            catch (error) {
+                for (const dispose of disposers) {
+                    try {
+                        void dispose();
+                    }
+                    catch { /* best-effort rollback */ }
+                }
+                throw error;
+            }
+            return () => {
+                for (const dispose of disposers) {
+                    try {
+                        void dispose();
+                    }
+                    catch { /* a failed disposer must not mask the others */ }
+                }
+            };
+        }, 'evolution-host-routes');
+    });
+}
+export function json(status, body) {
+    return new Response(JSON.stringify(body), {
+        status,
+        headers: { 'content-type': 'application/json; charset=utf-8' },
+    });
+}
+export function methodNotAllowed(allowed) {
+    return new Response(JSON.stringify({ error: 'method-not-allowed' }), {
+        status: 405,
+        headers: { 'content-type': 'application/json; charset=utf-8', allow: allowed.join(', ') },
+    });
+}
+//# sourceMappingURL=http-routes.js.map

package/lib/types/index.d.ts

@@ -24,7 +24,7 @@
  *   IO-seam consumer), `memory-store.ts`, `usage.ts`, `curator.ts`,
  *   `quality.ts`, `signals.ts`, `skill-reads.ts` (the read-before-write rule, shared by the
  *   tool path and the review's plan path), `drift-signals.ts`, `skill-health.ts`,
- *   `preset-composition.ts`, `prompts.ts`, `learn-prompt.ts`,
+ *   `composition/composer.ts`, `prompts.ts`, `learn-prompt.ts`,
  *   `evolution-events.ts`, `evidence.ts` (which session frames count as content, for the plan
  *   path's evidence-class report), `session-projection.ts` (the live per-session units the family's
  *   log-shaped readers read instead of re-reading the session log), `io.ts` (the ctx.evolutionIo
@@ -32,6 +32,10 @@
  * @module @lmzhen/dsh-evolution-core
  */
 export * from './citations.ts';
+export * from './tree-write.ts';
+export * from './package-identity.ts';
+export * from './write-authority.ts';
+export * from './write-gates.ts';
 export * from './reference-rewrite.ts';
 export * from './cost.ts';
 export * from './skill-lint.ts';
@@ -49,7 +53,6 @@ export * from './io.ts';
 export * from './learn-prompt.ts';
 export * from './memory-store.ts';
 export * from './mutations.ts';
-export * from './preset-composition.ts';
 export * from './prompts.ts';
 export * from './quality.ts';
 export * from './redact.ts';
@@ -74,6 +77,8 @@ export * from './drift-signals.ts';
 export * from './skill-history.ts';
 export * from './unit-members.ts';
 export * from './skill-store.ts';
+export * from './store-ledger.ts';
+export * from './reachability.ts';
 export * from './state-store.ts';
 export * from './threats.ts';
 export * from './tool-dispatch.ts';
@@ -86,4 +91,10 @@ export * from './numeric.ts';
 export * from './opt-in.ts';
 export * from './payload.ts';
 export * from './fold-untrusted.ts';
+export * from './subagent/index.ts';
+export { EVOLUTION_PRESET_IDS, REVIEWER_PRESET_ID, MAINTAINER_PRESET_ID, RESTRICTED_TOOLS_ROW_ID, RESTRICTOR_MODULE, RESTRICTED_PRESET_DISPLAY, } from './composition/index.ts';
+export type { RestrictedPresetKind, RestrictedPresetDisplay, RestrictedPresetRequest, RestrictedPresetState, } from './composition/index.ts';
+export * from './diagnostics.ts';
+export * from './platform-line.generated.ts';
+export * from './session-fold.ts';
 //# sourceMappingURL=index.d.ts.map