dsh-continual-evolve 0.11.0 → 0.12.1

package/lib/memory-index.js

@@ -1,197 +0,0 @@
-import { MEMORY_TYPE_KEY, isArchived, isMemoryType } from "./types.js";
-import { recordInjection } from "./usage.js";
-import { MEMORY_GUIDE_INTRO, MEMORY_GUIDE_RULES } from "./memory-guide.js";
-import { directoryLine, mergedInjectionState, recencyScore } from "./inject.js";
-/** Hard character budget for the `<memories>` block. */
-export const DEFAULT_MEMORY_INDEX_MAX_CHARS = 6000;
-/** Prompt-section order of the memory index (empty 1–499 slot, see ADR). */
-export const DEFAULT_MEMORY_SECTION_ORDER = 400;
-/** Sessions whose frozen section text is kept before LRU eviction. */
-export const DEFAULT_FROZEN_SESSIONS = 32;
-/** Name of the injected section (unique — duplicate names throw upstream). */
-export const MEMORY_SECTION_NAME = "evolve:memory-index";
-/**
- * Recall-type priority for the budget: durable, behavior-shaping types first.
- * `project` (current work context) > `feedback` (how to behave) > `user` (who
- * the user is) > `reference` (external pointers). Entries without a valid
- * memoryType sink below every typed entry.
- */
-export const MEMORY_TYPE_PRIORITY = {
-    project: 0,
-    feedback: 1,
-    user: 2,
-    reference: 3,
-};
-/** Priority of an entry whose metadata carries no valid recall type. */
-const UNTYPED_PRIORITY = 4;
-/** The entry's recall type, or undefined when the metadata key is absent/invalid. */
-export function memoryTypeOf(entry) {
-    const value = entry.metadata[MEMORY_TYPE_KEY];
-    return isMemoryType(value) ? value : undefined;
-}
-/** Deterministic final tiebreak (matches `inject.ts` ranking). */
-function stableCompare(a, b) {
-    return [a.path, a.title, a.id].join("\0").localeCompare([b.path, b.title, b.id].join("\0"));
-}
-/**
- * Order memories for injection: recall-type priority first
- * ({@link MEMORY_TYPE_PRIORITY}), then recency (newest first), then the stable
- * dictionary order — deterministic for equal inputs, so a frozen section is
- * reproducible across builds. The input is never mutated.
- */
-export function rankMemories(entries, now = Date.now()) {
-    return [...entries].sort((a, b) => {
-        const aType = memoryTypeOf(a);
-        const bType = memoryTypeOf(b);
-        const priorityDelta = (aType ? MEMORY_TYPE_PRIORITY[aType] : UNTYPED_PRIORITY) - (bType ? MEMORY_TYPE_PRIORITY[bType] : UNTYPED_PRIORITY);
-        if (priorityDelta !== 0) {
-            return priorityDelta;
-        }
-        const recencyDelta = recencyScore(b, now) - recencyScore(a, now);
-        if (recencyDelta !== 0) {
-            return recencyDelta;
-        }
-        return stableCompare(a, b);
-    });
-}
-/** One memory rendered in full, as a list item with the body indented. */
-export function memoryFullLine(entry) {
-    const type = memoryTypeOf(entry);
-    const body = entry.content.trim().replace(/\n/g, "\n  ");
-    const head = `- [memory${type ? `:${type}` : ""}:${entry.id}] ${entry.title}`;
-    return body.length > 0 ? `${head}\n  ${body}` : head;
-}
-/**
- * Greedy budget fill over {@link rankMemories}: each entry takes the full body
- * while it fits, otherwise degrades to an index row, otherwise is dropped —
- * and because the ranking is fixed, the first entry that fits neither means
- * every later one is dropped too (their rows are no smaller).
- */
-export function selectMemoryInjection(entries, maxChars = DEFAULT_MEMORY_INDEX_MAX_CHARS) {
-    const visible = entries.filter((entry) => !isArchived(entry));
-    const ranked = rankMemories(visible);
-    const budget = Math.max(0, maxChars);
-    const full = [];
-    const indexed = [];
-    const shown = [];
-    let used = 0;
-    let dropped = 0;
-    for (const entry of ranked) {
-        const fullLine = memoryFullLine(entry);
-        if (used + fullLine.length <= budget) {
-            full.push(entry);
-            shown.push(entry);
-            used += fullLine.length;
-            continue;
-        }
-        const indexLine = directoryLine(entry);
-        if (used + indexLine.length <= budget) {
-            indexed.push(entry);
-            shown.push(entry);
-            used += indexLine.length;
-            continue;
-        }
-        dropped = ranked.length - shown.length;
-        break;
-    }
-    return { full, indexed, dropped, shown };
-}
-/** The `evolve_recall` pointer appended when rows had to be degraded or dropped. */
-export const MEMORY_OVERFLOW_HINT = "- 更多记忆可用 evolve_recall 按需读取";
-/**
- * Render a selection as the `<memories>` block, or "" when nothing is shown.
- * Full bodies come first in display order, then the degraded index rows, then
- * the `evolve_recall` pointer with the degradation/drop counts.
- */
-export function renderMemorySelection(selection) {
-    const { full, indexed, dropped, shown } = selection;
-    if (shown.length === 0) {
-        return "";
-    }
-    const lines = [];
-    for (const entry of full) {
-        lines.push(memoryFullLine(entry));
-    }
-    for (const entry of indexed) {
-        lines.push(directoryLine(entry));
-    }
-    const omitted = [];
-    if (indexed.length > 0) {
-        omitted.push(`${indexed.length} 条仅列索引`);
-    }
-    if (dropped > 0) {
-        omitted.push(`${dropped} 条未列出`);
-    }
-    lines.push(omitted.length > 0 ? `${MEMORY_OVERFLOW_HINT}（${omitted.join("，")}）` : MEMORY_OVERFLOW_HINT);
-    return `<memories>\n${lines.join("\n")}\n</memories>`;
-}
-/** {@link renderMemorySelection} over a fresh selection (convenience). */
-export function formatMemoriesBlock(entries, maxChars = DEFAULT_MEMORY_INDEX_MAX_CHARS) {
-    return renderMemorySelection(selectMemoryInjection(entries, maxChars));
-}
-/**
- * Compose the full `evolve:memory-index` section for one assembling agent:
- * the persistent-memory guide (when to save / how to maintain) wrapped around
- * the budget-bounded memories block. With the guide off and no memories the
- * result is "" — the prompt renderer then drops the section, so an empty store
- * keeps costing zero tokens.
- *
- * Injection usage is recorded for everything shown (best-effort; a failure
- * never blocks injection), deduped per session by {@link recordInjection}.
- */
-export function memoryIndexSectionText(engine, agent, opts) {
-    if (!agent) {
-        return "";
-    }
-    const guide = opts?.guide ?? true;
-    const maxChars = opts?.maxChars ?? DEFAULT_MEMORY_INDEX_MAX_CHARS;
-    const merged = mergedInjectionState(engine, agent, opts);
-    const selection = selectMemoryInjection(Object.values(merged.entries.memory), maxChars);
-    const block = renderMemorySelection(selection);
-    if (selection.shown.length > 0) {
-        try {
-            recordInjection(engine.baseDir, selection.shown.map((entry) => `${entry.kind}:${entry.id}`), agent.id);
-        }
-        catch {
-            // Usage recording is diagnostic; never interrupt the injection path.
-        }
-    }
-    if (!guide) {
-        return block;
-    }
-    return [MEMORY_GUIDE_INTRO, block.length > 0 ? block : "<memories>\n（暂无记忆）\n</memories>", MEMORY_GUIDE_RULES].join("\n\n");
-}
-/**
- * Freeze the section text per session id. The frozen value is what keeps the
- * system prompt stable across a session's assemblies (prompt-cache guard);
- * bounded by `maxSessions` with insertion-order (LRU) eviction, so a long-lived
- * process cannot grow without limit.
- */
-export function createFrozenMemorySection(maxSessions = DEFAULT_FROZEN_SESSIONS) {
-    const limit = Math.max(1, maxSessions);
-    const frozen = new Map();
-    return {
-        textFor(agent, build) {
-            if (!agent) {
-                return "";
-            }
-            const cached = frozen.get(agent.id);
-            if (cached !== undefined) {
-                return cached;
-            }
-            const text = build(agent);
-            frozen.set(agent.id, text);
-            while (frozen.size > limit) {
-                const oldest = frozen.keys().next();
-                if (oldest.done === true) {
-                    break;
-                }
-                frozen.delete(oldest.value);
-            }
-            return text;
-        },
-        size: () => frozen.size,
-        clear: () => frozen.clear(),
-    };
-}
-//# sourceMappingURL=memory-index.js.map

package/lib/memory-manifest.d.ts

@@ -1,16 +0,0 @@
-/**
- * The frozen memory manifest: a deterministic snapshot view of every live
- * memory entry the extractor may see, plus its bounded serialization and
- * manifest-scoped search. Pure functions over harness state.
- */
-import type { HarnessEntry, HarnessState } from "./types.js";
-/** One manifest row is exactly one live memory entry. */
-export type MemoryManifestEntry = HarnessEntry;
-export declare function buildMemoryManifest(state: HarnessState): MemoryManifestEntry[];
-/** Render a bounded manifest index; full bodies remain available through memory_search. */
-export declare function formatMemoryManifest(entries: readonly MemoryManifestEntry[], maxChars?: number): string;
-/** Rank frozen manifest entries with CJK-aware token overlap and stable tie-breaking. */
-export declare function searchMemoryManifest(entries: readonly MemoryManifestEntry[], query: string, maxResults?: number): MemoryManifestEntry[];
-/** Inputs for one bounded background memory extraction loop. */
-export declare function manifestResult(entry: MemoryManifestEntry): Record<string, unknown>;
-//# sourceMappingURL=memory-manifest.d.ts.map

package/lib/memory-manifest.js

@@ -1,70 +0,0 @@
-import { isArchived, isMemoryType, MEMORY_TYPE_KEY } from "./types.js";
-import { tokenize } from "./search.js";
-import { compactText } from "./render.js";
-export function buildMemoryManifest(state) {
-    return Object.values(state.entries.memory)
-        .map((entry) => ({ ...entry, metadata: { ...entry.metadata }, reference: {}, arguments: {} }))
-        .sort((a, b) => manifestOrder(a).localeCompare(manifestOrder(b), "en"));
-}
-/** Render a bounded manifest index; full bodies remain available through memory_search. */
-export function formatMemoryManifest(entries, maxChars = 8000) {
-    if (entries.length === 0)
-        return "No saved memory entries yet.";
-    const lines = [];
-    let used = 0;
-    for (const entry of entries) {
-        const type = isMemoryType(entry.metadata[MEMORY_TYPE_KEY]) ? entry.metadata[MEMORY_TYPE_KEY] : "untyped";
-        const archived = isArchived(entry) ? ", archived" : "";
-        const line = `- [${entry.scope}:${entry.id}] ${entry.title} (memoryType=${type}, path=${entry.path}${archived}): ${compactText(entry.content, 240)}`;
-        if (used + line.length + 1 > maxChars)
-            break;
-        lines.push(line);
-        used += line.length + 1;
-    }
-    const omitted = entries.length - lines.length;
-    if (omitted > 0)
-        lines.push(`- +${omitted} more entries; use memory_search with a narrower query.`);
-    return lines.join("\n");
-}
-/** Rank frozen manifest entries with CJK-aware token overlap and stable tie-breaking. */
-export function searchMemoryManifest(entries, query, maxResults = 8) {
-    const queryTokens = new Set(tokenize(query));
-    if (queryTokens.size === 0)
-        return [];
-    return entries
-        .map((entry) => {
-        const title = tokenize(entry.title);
-        const body = tokenize(`${entry.content} ${entry.path} ${String(entry.metadata[MEMORY_TYPE_KEY] ?? "")}`);
-        let score = 0;
-        for (const token of queryTokens) {
-            if (title.includes(token))
-                score += 2;
-            if (body.includes(token))
-                score += 1;
-        }
-        if (`${entry.scope}:${entry.id}`.toLowerCase() === query.trim().toLowerCase())
-            score += 100;
-        return { entry, score };
-    })
-        .filter((hit) => hit.score > 0)
-        .sort((a, b) => b.score - a.score || manifestOrder(a.entry).localeCompare(manifestOrder(b.entry), "en"))
-        .slice(0, maxResults)
-        .map((hit) => hit.entry);
-}
-/** Inputs for one bounded background memory extraction loop. */
-export function manifestResult(entry) {
-    return {
-        scope: entry.scope,
-        id: entry.id,
-        title: entry.title,
-        content: entry.content,
-        path: entry.path,
-        memoryType: entry.metadata[MEMORY_TYPE_KEY],
-        archived: isArchived(entry),
-    };
-}
-function manifestOrder(entry) {
-    const scope = entry.scope === "global" ? "0" : entry.scope === "project" ? "1" : "2";
-    return `${scope}:${entry.id}:${entry.title}`;
-}
-//# sourceMappingURL=memory-manifest.js.map

package/lib/message-source.d.ts

@@ -1,23 +0,0 @@
-/**
- * Producer declaration for every message this plugin injects.
- *
- * Harness message sources are a merge-extensible sum type: each producer
- * declares its own `kind` in its own module, and dsh 0.1.7 removed the shared
- * catch-all `kind: "plugin"`. Declaring our kind once, here, keeps every
- * injection site checked against the host vocabulary instead of repeating a
- * local literal that silently drifts when that vocabulary changes.
- */
-declare module "@deepseek-ai/dsh-llm" {
-    interface MessageSourceMap {
-        "continual-evolve": EvolveMessageSource;
-    }
-}
-/** Source tag identifying dsh-continual-evolve as the message producer. */
-export interface EvolveMessageSource {
-    kind: "continual-evolve";
-}
-/** Source value carried by every message this plugin injects. */
-export declare const EVOLVE_MESSAGE_SOURCE: {
-    readonly kind: "continual-evolve";
-};
-//# sourceMappingURL=message-source.d.ts.map

package/lib/message-source.js

@@ -1,12 +0,0 @@
-/**
- * Producer declaration for every message this plugin injects.
- *
- * Harness message sources are a merge-extensible sum type: each producer
- * declares its own `kind` in its own module, and dsh 0.1.7 removed the shared
- * catch-all `kind: "plugin"`. Declaring our kind once, here, keeps every
- * injection site checked against the host vocabulary instead of repeating a
- * local literal that silently drifts when that vocabulary changes.
- */
-/** Source value carried by every message this plugin injects. */
-export const EVOLVE_MESSAGE_SOURCE = { kind: "continual-evolve" };
-//# sourceMappingURL=message-source.js.map

package/lib/mount-command.d.ts

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

package/lib/mount-command.js

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

package/lib/mount.d.ts

@@ -1,42 +0,0 @@
-import type { Context } from "@deepseek-ai/cordis";
-import type { HarnessEntry } from "./types.js";
-export interface MountRecord {
-    id: string;
-    /** Loader entry id (the `evolve:<name>` key). */
-    entryId: string;
-    /** Absolute path of the generated plugin package. */
-    path: string;
-    /** Entry revision the mount was generated from. */
-    version: number;
-    mountedAt: string;
-}
-export interface MountLedger {
-    mounted: MountRecord[];
-}
-export declare function mountedDir(baseDir: string): string;
-export declare function ledgerPath(baseDir: string): string;
-export declare function loadLedger(baseDir: string): MountLedger;
-export declare function saveLedger(baseDir: string, ledger: MountLedger): void;
-/** Generate the plugin package files for one skill entry; returns the package dir. */
-export declare function renderMountPackage(baseDir: string, entry: HarnessEntry): string;
-/** The generated plugin source: one tool registration, no external imports. */
-export declare function renderPluginSource(toolName: string, entry: HarnessEntry): string;
-/**
- * Map a skill entry's arguments contract to the tool-parameter schema.
- * Requiredness goes in a root-level `required` array (valid JSON Schema):
- * the mounted plugin registers via raw `ctx.tools.register`, and dsh-llm
- * sends `parameters` verbatim to the API, which rejects per-property
- * `required: true` ("true is not of type array").
- */
-export declare function renderParameters(entry: HarnessEntry): Record<string, unknown>;
-/**
- * Mount one skill entry into the live loader. Requires the `loader` service
- * (resolved lazily, see FAQ #1); without it the package is still written and
- * the ledger records the entry for the next boot.
- */
-export declare function mountSkill(ctx: Context, baseDir: string, entry: HarnessEntry): Promise<MountRecord>;
-/** Unmount a skill entry: remove the loader entry and the generated package. */
-export declare function unmountSkill(ctx: Context, baseDir: string, id: string): Promise<MountRecord | undefined>;
-/** Re-mount every ledger entry at plugin boot (restart persistence). */
-export declare function restoreMounted(ctx: Context, baseDir: string): Promise<void>;
-//# sourceMappingURL=mount.d.ts.map

package/lib/mount.js

@@ -1,212 +0,0 @@
-/**
- * Hot mounting: materialize a skill-kind harness entry as a real cordis
- * plugin (v2 optional item, design.md §6) and load it into the live loader
- * tree — no process restart. The generated plugin registers a model-facing
- * tool that carries the skill's description, argument contract, and python
- * reference; the `skill` tool remains the way to actually execute it.
- *
- * Layout under `<baseDir>/evolve/mounted/`:
- *   index.json                    mount ledger (id -> path, restored at boot)
- *   <skillName>/package.json      plugin manifest (ESM, main index.js)
- *   <skillName>/index.js          generated plugin: registers one tool
- *
- * The generated plugin imports nothing outside node builtins, so the mount
- * directory needs no node_modules of its own.
- */
-import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
-import { join } from "node:path";
-import { skillNameOf } from "./skill.js";
-import { secretLeakReason } from "./promotion.js";
-export function mountedDir(baseDir) {
-    return join(baseDir, "evolve", "mounted");
-}
-export function ledgerPath(baseDir) {
-    return join(mountedDir(baseDir), "index.json");
-}
-export function loadLedger(baseDir) {
-    const path = ledgerPath(baseDir);
-    if (!existsSync(path)) {
-        return { mounted: [] };
-    }
-    try {
-        const raw = JSON.parse(readFileSync(path, "utf8"));
-        return { mounted: Array.isArray(raw.mounted) ? raw.mounted : [] };
-    }
-    catch {
-        return { mounted: [] };
-    }
-}
-export function saveLedger(baseDir, ledger) {
-    mkdirSync(mountedDir(baseDir), { recursive: true });
-    writeFileSync(ledgerPath(baseDir), `${JSON.stringify(ledger, null, 2)}\n`, "utf8");
-}
-/** Generate the plugin package files for one skill entry; returns the package dir. */
-export function renderMountPackage(baseDir, entry) {
-    // Secret-leak quarantine: the entry content AND its reference contract are
-    // embedded verbatim into the generated index.js, so a credential in either
-    // would be written to disk (and executed in-process). Block before ANY
-    // file is created (review audit 2026-08-28 B2: reference was unscreened).
-    const secret = secretLeakReason([entry.title, entry.content, JSON.stringify(entry.reference ?? {}), JSON.stringify(entry.arguments ?? {})].join("\n"));
-    if (secret) {
-        throw new Error(`mount blocked: ${secret}`);
-    }
-    const dir = join(mountedDir(baseDir), skillNameOf(entry.id));
-    mkdirSync(dir, { recursive: true });
-    const toolName = `skill_${skillNameOf(entry.id)}`;
-    writeFileSync(join(dir, "package.json"), `{\n  "name": "evolve-skill-${skillNameOf(entry.id)}",\n  "version": "1.0.0",\n  "main": "index.js",\n  "type": "module"\n}\n`, "utf8");
-    writeFileSync(join(dir, "index.js"), renderPluginSource(toolName, entry), "utf8");
-    return dir;
-}
-/** The generated plugin source: one tool registration, no external imports. */
-export function renderPluginSource(toolName, entry) {
-    const description = `${oneLine(entry.title)}. ${oneLine(entry.content)}`.slice(0, 400);
-    const parameters = renderParameters(entry);
-    const reference = JSON.stringify(entry.reference ?? {}, null, 2);
-    const entryId = JSON.stringify(entry.id);
-    const entryVersion = JSON.stringify(entry.version);
-    const entryTitle = JSON.stringify(oneLine(entry.title));
-    const skillName = JSON.stringify(skillNameOf(entry.id));
-    return `/**
- * Generated by dsh-continual-evolve mount (${entry.id} v${entry.version}).
- * Hot-mounted into the live loader tree; edit the harness entry and remount
- * to regenerate. Execute the skill through the \`skill\` tool — this plugin
- * exposes its contract to the model.
- */
-export const name = "evolve-skill-${skillNameOf(entry.id)}";
-
-// Cordis requires declared service access; without this, \`ctx.tools\` throws
-// "cannot get property \\"tools\\" without inject".
-export const inject = ["tools"];
-
-export function apply(ctx) {
-  ctx.tools.register({
-    name: ${JSON.stringify(toolName)},
-    description: ${JSON.stringify(description)},
-    parameters: ${JSON.stringify(parameters, null, 2)},
-    output: {
-      // No \`required\` on the string property: the direct-register value-schema
-      // path rejects it ("required is not supported on type string").
-      schema: { type: "object", additionalProperties: false, properties: { text: { type: "string" } } },
-      render: (_args, value) => [{ type: "text", text: value?.text ?? "" }],
-    },
-    execute: async (args) => ({
-      text: "Mounted skill " + ${entryId} + " (v" + ${entryVersion} + ").\\n" +
-        "Description: " + ${entryTitle} + "\\n" +
-        "Argument contract: " + JSON.stringify(args ?? {}) + "\\n" +
-        "Python reference: " + ${JSON.stringify(reference)} + "\\n" +
-        "Execute via the \`skill\` tool (skill name " + ${skillName} + ").",
-    }),
-  });
-}
-`;
-}
-/**
- * Map a skill entry's arguments contract to the tool-parameter schema.
- * Requiredness goes in a root-level `required` array (valid JSON Schema):
- * the mounted plugin registers via raw `ctx.tools.register`, and dsh-llm
- * sends `parameters` verbatim to the API, which rejects per-property
- * `required: true` ("true is not of type array").
- */
-export function renderParameters(entry) {
-    const contract = entry.arguments ?? {};
-    const properties = {};
-    const required = [];
-    for (const [key, spec] of Object.entries(contract)) {
-        const record = typeof spec === "object" && spec !== null && !Array.isArray(spec) ? spec : {};
-        const type = typeof record["type"] === "string" ? record["type"] : "string";
-        const description = typeof record["description"] === "string" ? record["description"] : key;
-        properties[key] = { type, description };
-        if (record["required"] === true) {
-            required.push(key);
-        }
-    }
-    return {
-        type: "object",
-        additionalProperties: false,
-        properties,
-        ...(required.length > 0 ? { required } : {}),
-    };
-}
-/**
- * Mount one skill entry into the live loader. Requires the `loader` service
- * (resolved lazily, see FAQ #1); without it the package is still written and
- * 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");
-    if (loader) {
-        try {
-            // EntryOptions: {id, name (module specifier), config, group, disabled, inject} —
-            // `name` must resolve as an ES module: Node ESM does not support
-            // directory imports, so point at the generated index.js explicitly.
-            await loader.create({ id: entryId, name: join(dir, "index.js") });
-        }
-        catch (cause) {
-            throw new Error(`hot mount failed: ${cause instanceof Error ? cause.message : String(cause)}`);
-        }
-    }
-    const record = {
-        id: entry.id,
-        entryId,
-        path: dir,
-        version: entry.version,
-        mountedAt: new Date().toISOString(),
-    };
-    const ledger = loadLedger(baseDir);
-    ledger.mounted = [...ledger.mounted.filter((m) => m.id !== entry.id), record];
-    saveLedger(baseDir, ledger);
-    return record;
-}
-/** Unmount a skill entry: remove the loader entry and the generated package. */
-export async function unmountSkill(ctx, baseDir, id) {
-    const ledger = loadLedger(baseDir);
-    const record = ledger.mounted.find((m) => m.id === id);
-    if (!record) {
-        return undefined;
-    }
-    const loader = ctx.get("loader");
-    if (loader) {
-        try {
-            await loader.remove(record.entryId);
-        }
-        catch (cause) {
-            throw new Error(`hot unmount failed: ${cause instanceof Error ? cause.message : String(cause)}`);
-        }
-    }
-    if (existsSync(record.path)) {
-        rmSync(record.path, { recursive: true, force: true });
-    }
-    ledger.mounted = ledger.mounted.filter((m) => m.id !== id);
-    saveLedger(baseDir, ledger);
-    return record;
-}
-/** Re-mount every ledger entry at plugin boot (restart persistence). */
-export async function restoreMounted(ctx, baseDir) {
-    const ledger = loadLedger(baseDir);
-    const loader = ctx.get("loader");
-    for (const record of ledger.mounted) {
-        if (!existsSync(join(record.path, "index.js"))) {
-            continue; // package was removed; ledger prunes on next unmount
-        }
-        if (!loader) {
-            continue;
-        }
-        try {
-            await loader.create({ id: record.entryId, name: join(record.path, "index.js") });
-        }
-        catch (cause) {
-            ctx.logger("continual-evolve").warn(`mount restore failed for ${record.id}: ${cause instanceof Error ? cause.message : String(cause)}`);
-        }
-    }
-}
-function oneLine(text) {
-    return text.replace(/\s+/g, " ").trim();
-}
-//# sourceMappingURL=mount.js.map