dsh-continual-evolve 0.10.6 → 0.12.0

package/lib/memory-benchmark.js

@@ -1,170 +0,0 @@
-/**
- * Memory-specific extraction benchmark (P1): deterministic scoring of one
- * memory proposal against a labeled reference.
- *
- * Unlike the harness benchmark (which runs subagents against rubrics), this
- * module scores a proposal's SHAPE without any model call: precision and
- * recall over reference facts, duplicate creates (update-first violations),
- * stale operations (re-proposing outdated facts, or removing live ones), and
- * noise (unmatched or exclusion-list material). Suite authors hand-build
- * small references plus transcripts; the extraction loop under test produces
- * the proposal, this module grades it.
- *
- * Matching is phrase-substring based (case-insensitive): a reference fact
- * lists must-contain phrases, and a proposed edit matches when its title
- * plus content carry every phrase. Deliberately mechanical — the benchmark
- * measures extraction coverage, not paraphrase quality.
- */
-import { CONFLICT_BLOCK_SCORE, mostSimilarEntry } from "./promotion.js";
-import { isArchived } from "./types.js";
-/** Strict-by-default gate: duplicates and stale operations never pass unnoticed. */
-export const DEFAULT_MEMORY_GRADE_THRESHOLDS = {
-    minPrecision: 0.7,
-    minRecall: 0.7,
-    maxDuplicate: 0,
-    maxStale: 0,
-    maxNoise: 0,
-};
-/**
- * v1 exclusion heuristics for noise ("不该记什么" in mechanical form):
- * git history, repo paths re-readable from disk, stack traces, and
- * explicitly temporary session state. Keep this list short and documented —
- * every pattern here is a precision/recall tradeoff, not ground truth.
- */
-export const MEMORY_NOISE_PATTERNS = [
-    /\bgit\s+(log|show|commit|diff)\b/i,
-    /\bcommit\s+[0-9a-f]{5,40}\b/i,
-    /\b[0-9a-f]{40}\b/,
-    /(?:^|[\s("'])((?:src|lib|test|tests|docs|scripts)\/[A-Za-z0-9_./-]+\.[a-z]+)/,
-    /\bat\s+[\w$.]+\s*\(.*:\d+:\d+\)/,
-    /\b(temporary|one-off debugging|current task progress|in this session only)\b/i,
-];
-/** Content shorter than this is too thin to be a durable fact. */
-export const MEMORY_MIN_FACT_CHARS = 30;
-/**
- * Score one proposal against the reference and the pre-extraction manifest.
- *
- * @param reference Labeled facts (live + outdated).
- * @param edits The proposal's memory edits.
- * @param manifest Memory entries visible before extraction (duplicate source).
- * @returns Per-dimension counts plus a per-edit breakdown.
- */
-export function scoreMemoryExtraction(reference, edits, manifest) {
-    const live = reference.facts.filter((fact) => !fact.outdated);
-    const outdated = reference.facts.filter((fact) => fact.outdated);
-    const liveMatched = new Set();
-    const outdatedHandled = new Set();
-    const scored = [];
-    let duplicate = 0;
-    let stale = 0;
-    let noise = 0;
-    for (const edit of edits) {
-        const text = `${edit.title ?? ""}\n${edit.content ?? ""}`;
-        const liveHits = live.filter((fact) => matchesFact(text, fact));
-        const outdatedHits = outdated.filter((fact) => matchesFact(text, fact));
-        const entry = { action: edit.action, matchedFactIds: [] };
-        if (edit.action === "create" || edit.action === "update") {
-            if (outdatedHits.length > 0) {
-                stale += 1;
-                entry.staleReason = `re-proposes outdated fact(s): ${outdatedHits.map((fact) => fact.id).join(",")}`;
-            }
-            else if (edit.action === "create") {
-                const hit = mostSimilarEntry(manifest.filter((candidate) => candidate.kind === "memory"), edit.title ?? "", edit.content ?? "", CONFLICT_BLOCK_SCORE);
-                if (hit) {
-                    duplicate += 1;
-                    entry.duplicateOf = hit.id;
-                }
-                else if (liveHits.length > 0) {
-                    for (const fact of liveHits) {
-                        liveMatched.add(fact.id);
-                        entry.matchedFactIds.push(fact.id);
-                    }
-                }
-                else {
-                    noise += 1;
-                    entry.noisyReason = noiseReason(text);
-                }
-            }
-            else if (liveHits.length > 0) {
-                for (const fact of liveHits) {
-                    liveMatched.add(fact.id);
-                    entry.matchedFactIds.push(fact.id);
-                }
-            }
-            else {
-                noise += 1;
-                entry.noisyReason = noiseReason(text);
-            }
-        }
-        else {
-            // delete/archive: correct only against outdated facts.
-            const targetHits = [...liveHits, ...outdatedHits];
-            const targetOutdated = outdatedHits.length > 0;
-            const targetEntry = edit.id !== undefined ? manifest.find((candidate) => candidate.id === edit.id) : undefined;
-            if (targetOutdated) {
-                for (const fact of outdatedHits) {
-                    outdatedHandled.add(fact.id);
-                    entry.matchedFactIds.push(fact.id);
-                }
-            }
-            else if (targetEntry !== undefined && isArchived(targetEntry)) {
-                // Re-archiving an already archived entry is harmless housekeeping.
-                entry.matchedFactIds.push(`archived:${targetEntry.id}`);
-            }
-            else if (targetHits.length > 0 || (targetEntry !== undefined && !isArchived(targetEntry))) {
-                stale += 1;
-                entry.staleReason = `removes live fact(s): ${targetHits.map((fact) => fact.id).join(",") || targetEntry?.id || "(unknown target)"}`;
-            }
-            else {
-                noise += 1;
-                entry.noisyReason = "removal matches no reference fact";
-            }
-        }
-        scored.push(entry);
-    }
-    const total = edits.length;
-    const preciseEdits = scored.filter((entry) => entry.matchedFactIds.length > 0).length;
-    const precision = total === 0 ? 1 : preciseEdits / total;
-    const recall = live.length === 0 ? 1 : liveMatched.size / live.length;
-    return {
-        totalEdits: total,
-        matchedFacts: liveMatched.size + outdatedHandled.size,
-        precision,
-        recall,
-        duplicate,
-        stale,
-        noise,
-        uncoveredFactIds: live.filter((fact) => !liveMatched.has(fact.id)).map((fact) => fact.id),
-        edits: scored,
-    };
-}
-/**
- * Grade a score against explicit thresholds.
- *
- * @returns pass plus one failure line per violated dimension (empty when passing).
- */
-export function gradeMemoryScore(score, thresholds = DEFAULT_MEMORY_GRADE_THRESHOLDS) {
-    const failures = [];
-    if (score.precision < thresholds.minPrecision)
-        failures.push(`precision ${score.precision.toFixed(2)} < ${thresholds.minPrecision}`);
-    if (score.recall < thresholds.minRecall)
-        failures.push(`recall ${score.recall.toFixed(2)} < ${thresholds.minRecall}`);
-    if (score.duplicate > thresholds.maxDuplicate)
-        failures.push(`duplicate ${score.duplicate} > ${thresholds.maxDuplicate}`);
-    if (score.stale > thresholds.maxStale)
-        failures.push(`stale ${score.stale} > ${thresholds.maxStale}`);
-    if (score.noise > thresholds.maxNoise)
-        failures.push(`noise ${score.noise} > ${thresholds.maxNoise}`);
-    return { pass: failures.length === 0, failures };
-}
-function matchesFact(text, fact) {
-    const lowered = text.toLowerCase();
-    return fact.mustContain.every((phrase) => lowered.includes(phrase.toLowerCase()));
-}
-function noiseReason(text) {
-    if (text.trim().length < MEMORY_MIN_FACT_CHARS)
-        return `thin content (<${MEMORY_MIN_FACT_CHARS} chars)`;
-    const hit = MEMORY_NOISE_PATTERNS.findIndex((pattern) => pattern.test(text));
-    return hit >= 0 ? `matches exclusion pattern #${hit + 1}` : "matches no reference fact";
-}
-//# sourceMappingURL=memory-benchmark.js.map

package/lib/memory-index.d.ts

@@ -1,114 +0,0 @@
-/**
- * evolve v2 — the passive read path: the `evolve:memory-index` system-prompt
- * section that puts memory CONTENT in front of the model at session start.
- *
- * Why not just hand out a path: the memory store lives in `<dshHome>/evolve/`,
- * outside the workspace sandbox, so the model's read tool cannot open it.
- * The section therefore carries the entries themselves — full body while the
- * character budget allows, then one-line index rows, then a `evolve_recall`
- * pointer for the rest. Budget is hard: a bounded prompt beats an unbounded one.
- *
- * Session-freeze contract (the prompt-cache guard): the section is computed
- * once per session and reused byte-for-byte afterwards, so the system prompt
- * stays stable within a session and cache reads keep hitting. A memory written
- * mid-session becomes visible in the NEXT session; `evolve_recall` covers the
- * immediate need. See `.agents/notes/proposed/feature/2026-10-01-evolve-v2-passive-read-write.md`.
- */
-import type { HarnessEntry } from "./types.js";
-import { type MemoryRecallType } from "./types.js";
-import type { EvolutionEngine } from "./service.js";
-import { type AgentLike } from "./inject.js";
-/** Hard character budget for the `<memories>` block. */
-export declare const DEFAULT_MEMORY_INDEX_MAX_CHARS = 6000;
-/** Prompt-section order of the memory index (empty 1–499 slot, see ADR). */
-export declare const DEFAULT_MEMORY_SECTION_ORDER = 400;
-/** Sessions whose frozen section text is kept before LRU eviction. */
-export declare const DEFAULT_FROZEN_SESSIONS = 32;
-/** Name of the injected section (unique — duplicate names throw upstream). */
-export declare 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 declare const MEMORY_TYPE_PRIORITY: Record<MemoryRecallType, number>;
-/** The entry's recall type, or undefined when the metadata key is absent/invalid. */
-export declare function memoryTypeOf(entry: HarnessEntry): MemoryRecallType | undefined;
-/**
- * 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 declare function rankMemories(entries: readonly HarnessEntry[], now?: number): HarnessEntry[];
-/** One memory rendered in full, as a list item with the body indented. */
-export declare function memoryFullLine(entry: HarnessEntry): string;
-/** What a budget-bounded memory block shows. */
-export interface MemorySelection {
-    /** Entries rendered with their full body, in display order. */
-    full: HarnessEntry[];
-    /** Entries degraded to a one-line index row (`id` + title hook). */
-    indexed: HarnessEntry[];
-    /** Entries that fit neither and are only counted. */
-    dropped: number;
-    /** Entries actually shown (full + indexed), in display order. */
-    shown: HarnessEntry[];
-}
-/**
- * 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 declare function selectMemoryInjection(entries: readonly HarnessEntry[], maxChars?: number): MemorySelection;
-/** The `evolve_recall` pointer appended when rows had to be degraded or dropped. */
-export declare const MEMORY_OVERFLOW_HINT = "- \u66F4\u591A\u8BB0\u5FC6\u53EF\u7528 evolve_recall \u6309\u9700\u8BFB\u53D6";
-/**
- * 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 declare function renderMemorySelection(selection: MemorySelection): string;
-/** {@link renderMemorySelection} over a fresh selection (convenience). */
-export declare function formatMemoriesBlock(entries: readonly HarnessEntry[], maxChars?: number): string;
-/** Options for {@link memoryIndexSectionText}. */
-export interface MemoryIndexOptions {
-    /** Hard budget for the memories block (default 6000). */
-    maxChars?: number;
-    /** Include the when_to_save guide (default true). */
-    guide?: boolean;
-    /** Pin the project layer explicitly (tests/tools); otherwise derived from cwd. */
-    projectKey?: string;
-}
-/**
- * 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 declare function memoryIndexSectionText(engine: EvolutionEngine, agent: AgentLike | undefined, opts?: MemoryIndexOptions): string;
-/** A per-session frozen view of the memory section text. */
-export interface FrozenMemorySection {
-    /**
-     * The section text for this agent: built on first use per `agent.id` and
-     * reused byte-for-byte afterwards. `undefined` agent → "" (unbuilt).
-     */
-    textFor(agent: AgentLike | undefined, build: (agent: AgentLike) => string): string;
-    /** Sessions currently frozen (test/observability hook). */
-    size(): number;
-    /** Drop every frozen session (tests; a restart rebuilds naturally). */
-    clear(): void;
-}
-/**
- * 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 declare function createFrozenMemorySection(maxSessions?: number): FrozenMemorySection;
-//# sourceMappingURL=memory-index.d.ts.map

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/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.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