dsh-continual-evolve 0.1.0

package/lib/skill.d.ts

@@ -0,0 +1,10 @@
+import type { HarnessEntry, RefinementResult } from "./types.js";
+/** Convert a harness entry id (underscore slug) to a kebab-case skill name. */
+export declare function skillNameOf(id: string): string;
+/** Resolve and defend the skill directory for an entry id. */
+export declare function skillDir(skillsRoot: string, id: string): string;
+/** Render a harness skill entry as a discoverable SKILL.md document. */
+export declare function renderSkillMarkdown(entry: HarnessEntry): string;
+/** Apply the skill-kind edits of an applied refinement to the skills root. */
+export declare function syncSkillsFromResult(skillsRoot: string, result: RefinementResult): void;
+//# sourceMappingURL=skill.d.ts.map

package/lib/skill.js

@@ -0,0 +1,75 @@
+/**
+ * Skill materializer: syncs skill-kind harness entries to the DSH skills
+ * filesystem (`$DSH_HOME/skills/<kebab-name>/SKILL.md`) so the `skill` tool
+ * and catalog can discover and load them. Writes are atomic (tmp + rename)
+ * so the filesystem watcher never sees a partial file.
+ *
+ * Skill names must be kebab-case (the harness store ids are underscore slugs;
+ * the materialized name converts `_` → `-`).
+ */
+import { existsSync, mkdirSync, renameSync, rmSync, writeFileSync } from "node:fs";
+import { join, resolve, sep } from "node:path";
+/** Convert a harness entry id (underscore slug) to a kebab-case skill name. */
+export function skillNameOf(id) {
+    return id.toLowerCase().replace(/_/g, "-");
+}
+/** Resolve and defend the skill directory for an entry id. */
+export function skillDir(skillsRoot, id) {
+    const root = resolve(skillsRoot);
+    const dir = resolve(join(root, skillNameOf(id)));
+    if (dir !== root && !dir.startsWith(`${root}/`) && !dir.startsWith(`${root}${sep}`)) {
+        throw new Error(`skill path escapes skills root: ${dir}`);
+    }
+    return dir;
+}
+/** Render a harness skill entry as a discoverable SKILL.md document. */
+export function renderSkillMarkdown(entry) {
+    const lines = [
+        "---",
+        `name: ${skillNameOf(entry.id)}`,
+        `description: ${oneLine(entry.title)}`,
+        "---",
+        "",
+        entry.content.trim(),
+    ];
+    const reference = entry.reference;
+    if (reference && typeof reference === "object" && Object.keys(reference).length > 0) {
+        lines.push("", "## Invocation");
+        for (const [key, value] of Object.entries(reference)) {
+            lines.push(`- ${key}: ${JSON.stringify(value)}`);
+        }
+    }
+    if (Object.keys(entry.arguments).length > 0) {
+        lines.push("", "## Arguments", "```json", JSON.stringify(entry.arguments, null, 2), "```");
+    }
+    return `${lines.join("\n").trimEnd()}\n`;
+}
+/** Apply the skill-kind edits of an applied refinement to the skills root. */
+export function syncSkillsFromResult(skillsRoot, result) {
+    for (const edit of result.appliedEdits) {
+        if (edit.kind !== "skill" || !edit.applied)
+            continue;
+        if (edit.action === "delete" || !edit.after) {
+            removeSkill(skillsRoot, edit.id);
+            continue;
+        }
+        writeSkill(skillsRoot, edit.after);
+    }
+}
+function writeSkill(skillsRoot, entry) {
+    const dir = skillDir(skillsRoot, entry.id);
+    mkdirSync(dir, { recursive: true });
+    const temp = join(dir, `SKILL.md.${process.pid}.tmp`);
+    writeFileSync(temp, renderSkillMarkdown(entry), "utf8");
+    renameSync(temp, join(dir, "SKILL.md"));
+}
+function removeSkill(skillsRoot, id) {
+    const dir = skillDir(skillsRoot, id);
+    if (existsSync(dir)) {
+        rmSync(dir, { recursive: true, force: true });
+    }
+}
+function oneLine(text) {
+    return text.replace(/\s+/g, " ").trim();
+}
+//# sourceMappingURL=skill.js.map

package/lib/source.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Trajectory citations: where distilled entries came from in the session
+ * log. DSH sessions are event-sourced with contiguous seq numbers, so a
+ * citation of (sessionId, seqs) expands back to the exact original
+ * conversation rows (the durable log under `<dshHome>/sessions/...`).
+ *
+ * The extraction reads the live `agent.session.events` log (duck-typed, no
+ * dsh-session dependency) and only ever selects direct human messages —
+ * injected plugin context and tool results never become citations.
+ */
+import type { EntrySource } from "./types.js";
+import type { AgentLike } from "./inject.js";
+/** At most this many source user messages are cited per entry. */
+export declare const MAX_SOURCE_MESSAGES = 3;
+/**
+ * The seqs of the agent's most recent direct user messages, in log order.
+ * Returns [] when the agent has no readable log or no qualifying messages —
+ * callers then simply omit the citation.
+ */
+export declare function recentUserSeqs(agent: AgentLike | undefined, opts?: {
+    maxMessages?: number;
+}): number[];
+/**
+ * Build the citation for an apply call: the session id plus the seqs of the
+ * most recent direct user messages. Returns undefined when neither can be
+ * determined, so callers can pass it straight through without special cases.
+ */
+export declare function entrySourceOf(agent: AgentLike | undefined, sessionId: string | undefined): EntrySource | undefined;
+//# sourceMappingURL=source.d.ts.map

package/lib/source.js

@@ -0,0 +1,42 @@
+/** At most this many source user messages are cited per entry. */
+export const MAX_SOURCE_MESSAGES = 3;
+/**
+ * The seqs of the agent's most recent direct user messages, in log order.
+ * Returns [] when the agent has no readable log or no qualifying messages —
+ * callers then simply omit the citation.
+ */
+export function recentUserSeqs(agent, opts) {
+    const events = agent?.session?.events;
+    if (!events || events.length === 0) {
+        return [];
+    }
+    const maxMessages = opts?.maxMessages ?? MAX_SOURCE_MESSAGES;
+    const seqs = [];
+    for (let i = events.length - 1; i >= 0 && seqs.length < maxMessages; i -= 1) {
+        const row = events[i];
+        if (row?.type !== "user/message") {
+            continue;
+        }
+        const source = row.data?.source;
+        if (source && source.kind !== "user") {
+            continue;
+        }
+        if (typeof row.seq === "number" && Number.isInteger(row.seq)) {
+            seqs.unshift(row.seq);
+        }
+    }
+    return seqs;
+}
+/**
+ * Build the citation for an apply call: the session id plus the seqs of the
+ * most recent direct user messages. Returns undefined when neither can be
+ * determined, so callers can pass it straight through without special cases.
+ */
+export function entrySourceOf(agent, sessionId) {
+    if (!sessionId) {
+        return undefined;
+    }
+    const seqs = recentUserSeqs(agent);
+    return seqs.length > 0 ? { sessionId, seqs } : { sessionId };
+}
+//# sourceMappingURL=source.js.map

package/lib/state.d.ts

@@ -0,0 +1,34 @@
+import type { HarnessScope, HarnessState } from "./types.js";
+/** Directory holding the cross-session (global) store. */
+export declare function globalStateDir(baseDir: string): string;
+/** Directory holding a session-scoped (local) store, if the session has one. */
+export declare function localStateDir(sessionDir: string | undefined): string | undefined;
+export declare function stateFilePath(stateDir: string): string;
+/**
+ * Load state from disk, degrading to empty on any unreadable or malformed
+ * content. Called on every system-prompt build and before every apply, so it
+ * must never throw for a bad file.
+ */
+export declare function loadHarnessState(stateDir: string, scope?: HarnessScope): HarnessState;
+/**
+ * Merge global and local state into the view the model sees. Local entries
+ * win over same-id global entries; a colliding local id is prefixed
+ * `local:` so both remain addressable.
+ */
+export declare function mergeHarnessStates(globalState: HarnessState, localState: HarnessState | undefined): HarnessState;
+/**
+ * Persist state atomically: write to a temp file, fsync-free but rename-based,
+ * preserving the mode of an existing file (defaults to 0o600 for new files).
+ */
+export declare function saveHarnessState(stateDir: string, state: HarnessState): string;
+/**
+ * Capture the state snapshot a plan was based on. At apply time the caller
+ * re-reads the file and compares; an entry that changed since planning is
+ * rejected per-edit, never silently overwritten.
+ */
+export declare function baselineOf(state: HarnessState): HarnessState;
+/** True when an entry in `current` differs from the same entry in `baseline`. */
+export declare function entryChangedSince(baseline: HarnessState, current: HarnessState, kind: keyof HarnessState["entries"], id: string): boolean;
+/** The set of keys an entry must not expose beyond the persisted shape. */
+export declare const ENTRY_KEYS: readonly ["id", "kind", "title", "content", "path", "scope", "reference", "arguments", "metadata", "source", "created_at", "updated_at", "version"];
+//# sourceMappingURL=state.d.ts.map

package/lib/state.js

@@ -0,0 +1,154 @@
+/**
+ * Persistence layer for harness state: atomic writes, corrupt-file degrade,
+ * scope merge, and optimistic-concurrency primitives.
+ *
+ * Safety properties (code-enforced, not prompt-enforced):
+ * - writes are atomic (temp file + rename) and preserve the file mode;
+ * - an unreadable or non-object state file degrades to empty state so a
+ *   broken file can never take a session down; the next save rewrites it
+ *   cleanly;
+ * - every entry read from disk is shape-normalized (scope, reference,
+ *   arguments, metadata) so a hand-edited file cannot smuggle garbage into
+ *   the system prompt renderer.
+ */
+import { existsSync, mkdirSync, renameSync, statSync, unlinkSync, writeFileSync } from "node:fs";
+import { readFileSync } from "node:fs";
+import { randomUUID } from "node:crypto";
+import { join } from "node:path";
+import { emptyHarnessState } from "./types.js";
+/** Directory holding the cross-session (global) store. */
+export function globalStateDir(baseDir) {
+    return join(baseDir, "evolve");
+}
+/** Directory holding a session-scoped (local) store, if the session has one. */
+export function localStateDir(sessionDir) {
+    return sessionDir ? join(sessionDir, "evolve") : undefined;
+}
+export function stateFilePath(stateDir) {
+    return join(stateDir, "harness_state.json");
+}
+function normalizeScope(value, fallback) {
+    return value === "global" || value === "local" ? value : fallback;
+}
+function objectRecord(value) {
+    if (typeof value !== "object" || value === null || Array.isArray(value)) {
+        return undefined;
+    }
+    return value;
+}
+/**
+ * Load state from disk, degrading to empty on any unreadable or malformed
+ * content. Called on every system-prompt build and before every apply, so it
+ * must never throw for a bad file.
+ */
+export function loadHarnessState(stateDir, scope = "global") {
+    const path = stateFilePath(stateDir);
+    if (!existsSync(path)) {
+        return emptyHarnessState();
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(readFileSync(path, "utf8"));
+    }
+    catch {
+        return emptyHarnessState();
+    }
+    const root = objectRecord(parsed);
+    if (!root) {
+        return emptyHarnessState();
+    }
+    const state = emptyHarnessState();
+    if (typeof root["schema"] === "number") {
+        state.schema = root["schema"];
+    }
+    const entries = objectRecord(root["entries"]);
+    if (entries) {
+        for (const kind of Object.keys(state.entries)) {
+            const records = objectRecord(entries[kind]);
+            if (!records)
+                continue;
+            for (const [id, raw] of Object.entries(records)) {
+                const entry = objectRecord(raw);
+                if (!entry)
+                    continue;
+                state.entries[kind][id] = {
+                    id: typeof entry["id"] === "string" ? entry["id"] : id,
+                    kind,
+                    title: typeof entry["title"] === "string" ? entry["title"] : id,
+                    content: typeof entry["content"] === "string" ? entry["content"] : "",
+                    path: typeof entry["path"] === "string" ? entry["path"] : "general",
+                    scope: normalizeScope(entry["scope"], scope),
+                    reference: objectRecord(entry["reference"]) ?? {},
+                    arguments: objectRecord(entry["arguments"]) ?? {},
+                    metadata: objectRecord(entry["metadata"]) ?? {},
+                    source: entry["source"] === "evolve" ? "evolve" : "evolve",
+                    created_at: typeof entry["created_at"] === "string" ? entry["created_at"] : new Date(0).toISOString(),
+                    updated_at: typeof entry["updated_at"] === "string" ? entry["updated_at"] : new Date(0).toISOString(),
+                    version: typeof entry["version"] === "number" ? entry["version"] : 1,
+                };
+            }
+        }
+    }
+    if (Array.isArray(root["refinements"])) {
+        state.refinements = root["refinements"];
+    }
+    return state;
+}
+/**
+ * Merge global and local state into the view the model sees. Local entries
+ * win over same-id global entries; a colliding local id is prefixed
+ * `local:` so both remain addressable.
+ */
+export function mergeHarnessStates(globalState, localState) {
+    const merged = emptyHarnessState();
+    merged.schema = Math.max(globalState.schema, localState?.schema ?? 1);
+    for (const kind of Object.keys(merged.entries)) {
+        for (const [id, entry] of Object.entries(globalState.entries[kind])) {
+            merged.entries[kind][id] = { ...entry, scope: "global" };
+        }
+        for (const [id, entry] of Object.entries(localState?.entries[kind] ?? {})) {
+            const scoped = { ...entry, scope: "local" };
+            const mergedId = merged.entries[kind][id] ? `local:${id}` : id;
+            merged.entries[kind][mergedId] = scoped;
+        }
+    }
+    merged.refinements = [...globalState.refinements, ...(localState?.refinements ?? [])];
+    return merged;
+}
+/**
+ * Persist state atomically: write to a temp file, fsync-free but rename-based,
+ * preserving the mode of an existing file (defaults to 0o600 for new files).
+ */
+export function saveHarnessState(stateDir, state) {
+    const path = stateFilePath(stateDir);
+    const tempPath = `${path}.${process.pid}.${randomUUID()}.tmp`;
+    mkdirSync(stateDir, { recursive: true });
+    try {
+        const mode = existsSync(path) ? statSync(path).mode & 0o777 : 0o600;
+        writeFileSync(tempPath, `${JSON.stringify(state, null, 2)}\n`, { encoding: "utf8", mode });
+        renameSync(tempPath, path);
+    }
+    finally {
+        if (existsSync(tempPath)) {
+            unlinkSync(tempPath);
+        }
+    }
+    return path;
+}
+/**
+ * Capture the state snapshot a plan was based on. At apply time the caller
+ * re-reads the file and compares; an entry that changed since planning is
+ * rejected per-edit, never silently overwritten.
+ */
+export function baselineOf(state) {
+    return JSON.parse(JSON.stringify(state));
+}
+/** True when an entry in `current` differs from the same entry in `baseline`. */
+export function entryChangedSince(baseline, current, kind, id) {
+    const before = baseline.entries[kind][id];
+    const after = current.entries[kind][id];
+    return JSON.stringify(before ?? null) !== JSON.stringify(after ?? null);
+}
+/** The set of keys an entry must not expose beyond the persisted shape. */
+export const ENTRY_KEYS = ["id", "kind", "title", "content", "path", "scope", "reference", "arguments", "metadata", "source", "created_at", "updated_at", "version"];
+//# sourceMappingURL=state.js.map

package/lib/store.d.ts

@@ -0,0 +1,20 @@
+import type { HarnessScope, HarnessState, RefinementResult } from "./types.js";
+export declare const EVOLVE_DIR = "evolve";
+export interface StorePaths {
+    /** Directory holding harness_state.json. */
+    stateDir: string;
+    /** Directory holding snapshots for this store. */
+    snapshotsDir: string;
+    /** JSONL path for applied refinement results. */
+    resultsPath: string;
+}
+export declare function storePaths(baseDir: string, scope: HarnessScope, sessionId?: string): StorePaths;
+/** Snapshot the current state file before a mutation, if one exists. */
+export declare function snapshotBefore(paths: StorePaths, refinementId: string): void;
+/** Append an applied result to the store's JSONL history. */
+export declare function appendResult(paths: StorePaths, result: RefinementResult): void;
+/** Read the applied results history; malformed lines are skipped, never fatal. */
+export declare function loadResults(paths: StorePaths): RefinementResult[];
+/** Load a state file into memory, returning empty state when absent. */
+export declare function loadStateFile(paths: StorePaths): HarnessState;
+//# sourceMappingURL=store.d.ts.map

package/lib/store.js

@@ -0,0 +1,74 @@
+/**
+ * Store layout and snapshot discipline for the evolution plugin.
+ *
+ * Layout (self-contained under the DSH home; no dependency on session
+ * persistence internals):
+ *
+ *   <dshHome>/evolve/global/harness_state.json    cross-session store
+ *   <dshHome>/evolve/global/refinements.jsonl     applied results (rollback source)
+ *   <dshHome>/evolve/local/<sessionId>/...        per-session store
+ *
+ * Snapshot discipline is code-enforced: before any mutating apply, the
+ * pre-apply state is copied to `snapshots/<refinementId>.json`. The model has
+ * no way to skip it — it runs inside the service, not in a prompt.
+ */
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { emptyHarnessState } from "./types.js";
+import { stateFilePath } from "./state.js";
+export const EVOLVE_DIR = "evolve";
+export function storePaths(baseDir, scope, sessionId) {
+    const scopeDir = scope === "global" ? "global" : join("local", sessionId ?? "anonymous");
+    const stateDir = join(baseDir, EVOLVE_DIR, scopeDir);
+    return {
+        stateDir,
+        snapshotsDir: join(stateDir, "snapshots"),
+        resultsPath: join(stateDir, "refinements.jsonl"),
+    };
+}
+/** Snapshot the current state file before a mutation, if one exists. */
+export function snapshotBefore(paths, refinementId) {
+    const statePath = stateFilePath(paths.stateDir);
+    if (!existsSync(statePath)) {
+        return;
+    }
+    mkdirSync(paths.snapshotsDir, { recursive: true });
+    writeFileSync(join(paths.snapshotsDir, `${refinementId}.json`), readFileSync(statePath, "utf8"), "utf8");
+}
+/** Append an applied result to the store's JSONL history. */
+export function appendResult(paths, result) {
+    mkdirSync(paths.stateDir, { recursive: true });
+    writeFileSync(paths.resultsPath, `${JSON.stringify(result)}\n`, { encoding: "utf8", flag: "a" });
+}
+/** Read the applied results history; malformed lines are skipped, never fatal. */
+export function loadResults(paths) {
+    if (!existsSync(paths.resultsPath)) {
+        return [];
+    }
+    const results = [];
+    for (const line of readFileSync(paths.resultsPath, "utf8").split("\n")) {
+        const trimmed = line.trim();
+        if (!trimmed)
+            continue;
+        try {
+            const parsed = JSON.parse(trimmed);
+            if (isResult(parsed)) {
+                results.push(parsed);
+            }
+        }
+        catch {
+            // skip malformed line
+        }
+    }
+    return results;
+}
+function isResult(data) {
+    return typeof data === "object" && data !== null && "id" in data && "appliedEdits" in data;
+}
+/** Load a state file into memory, returning empty state when absent. */
+export function loadStateFile(paths) {
+    return existsSync(stateFilePath(paths.stateDir))
+        ? JSON.parse(readFileSync(stateFilePath(paths.stateDir), "utf8"))
+        : emptyHarnessState();
+}
+//# sourceMappingURL=store.js.map

package/lib/tool.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Model-facing evolve_* tools. The model supplies content; every guarantee
+ * (validation, snapshot, versioning, history, rollback) is code-enforced in
+ * the engine. `global: true` is required explicitly for cross-session edits.
+ */
+import type { Context } from "@deepseek-ai/cordis";
+import type { HarnessScope } from "./types.js";
+import type { EvolutionEngine } from "./service.js";
+/** Accept both the boolean tool parameter (`global: true`) and the string form. */
+export declare function scopeOf(value: unknown, fallback: HarnessScope): HarnessScope;
+export interface ToolGateOptions {
+    requireGlobalApproval: boolean;
+}
+export declare function registerEvolveTools(ctx: Context, engine: EvolutionEngine, opts: ToolGateOptions): void;
+//# sourceMappingURL=tool.d.ts.map

package/lib/tool.js

@@ -0,0 +1,163 @@
+import { defineTool } from "@deepseek-ai/dsh-tools";
+import { formatHarnessStateForPrompt } from "./render.js";
+import { requireGlobalApproval } from "./approval.js";
+import { entrySourceOf } from "./source.js";
+const SCOPES = ["local", "global"];
+/** Accept both the boolean tool parameter (`global: true`) and the string form. */
+export function scopeOf(value, fallback) {
+    return value === "global" || value === true ? "global" : fallback;
+}
+/** The calling agent's session id; tools always run inside an agent scope. */
+function sessionIdOf(exec) {
+    return exec.agent?.id;
+}
+function textResult(text) {
+    return { text };
+}
+export function registerEvolveTools(ctx, engine, opts) {
+    ctx.tools.register(defineTool({
+        name: "evolve_list",
+        description: "List the continual harness state (prompt notes, memories, skills, subagent specs) for the current session (local) or across sessions (global).",
+        parameters: {
+            scope: {
+                type: "string",
+                enum: SCOPES,
+                description: "Which store to list: 'local' (default) or 'global'.",
+            },
+        },
+        output: {
+            schema: { type: "object", additionalProperties: false, properties: { text: { type: "string", required: true } } },
+            render: (_args, value) => [{ type: "text", text: value.text ?? "" }],
+        },
+        execute: async (args, exec) => {
+            const scope = scopeOf(args.scope, "local");
+            const state = engine.load(scope, sessionIdOf(exec));
+            return textResult(formatHarnessStateForPrompt(state));
+        },
+    }));
+    ctx.tools.register(defineTool({
+        name: "evolve_add",
+        description: "Create one harness entry (prompt/memory/skill/subagent). Skills require reference {type:python, import, callable} and an arguments contract. Snapshot, version, and history are handled automatically.",
+        parameters: {
+            kind: { type: "string", enum: ["prompt", "memory", "skill", "subagent"], required: true, description: "Entry kind." },
+            title: { type: "string", required: true, description: "Stable title." },
+            content: { type: "string", required: true, description: "Entry body." },
+            path: { type: "string", description: "Optional grouping path." },
+            reference: { type: "object", additionalProperties: true, description: "For skills: {type:'python', import, callable}." },
+            arguments: { type: "object", additionalProperties: true, description: "For skills: accepted input contract." },
+            global: { type: "boolean", description: "Set true to write the cross-session store (requires human approval; only for durable, reusable lessons)." },
+        },
+        output: {
+            schema: { type: "object", additionalProperties: false, properties: { text: { type: "string", required: true } } },
+            render: (_args, value) => [{ type: "text", text: value.text ?? "" }],
+        },
+        execute: async (args, exec) => {
+            const scope = scopeOf(args.global, "local");
+            if (scope === "global" && opts.requireGlobalApproval) {
+                await requireGlobalApproval(ctx, exec.agent, exec.signal, `evolve_add ${args.kind} "${args.title}" → 跨会话全局 store`);
+            }
+            const edit = {
+                action: "create",
+                kind: args.kind,
+                title: args.title,
+                content: args.content,
+            };
+            if (args.path !== undefined)
+                edit.path = args.path;
+            if (args.reference !== undefined)
+                edit.reference = args.reference;
+            if (args.arguments !== undefined)
+                edit.arguments = args.arguments;
+            return textResult(applyEditsText(engine, scope, sessionIdOf(exec), [edit], exec.agent));
+        },
+    }));
+    ctx.tools.register(defineTool({
+        name: "evolve_update",
+        description: "Update one harness entry by id. Pass only the fields that change.",
+        parameters: {
+            kind: { type: "string", enum: ["prompt", "memory", "skill", "subagent"], required: true },
+            id: { type: "string", required: true, description: "Existing entry id." },
+            title: { type: "string" },
+            content: { type: "string" },
+            global: { type: "boolean", description: "Set true to edit the cross-session store (requires human approval)." },
+        },
+        output: {
+            schema: { type: "object", additionalProperties: false, properties: { text: { type: "string", required: true } } },
+            render: (_args, value) => [{ type: "text", text: value.text ?? "" }],
+        },
+        execute: async (args, exec) => {
+            const scope = scopeOf(args.global, "local");
+            if (scope === "global" && opts.requireGlobalApproval) {
+                await requireGlobalApproval(ctx, exec.agent, exec.signal, `evolve_update ${args.kind}:${args.id} → 跨会话全局 store`);
+            }
+            const edit = { action: "update", kind: args.kind, id: args.id };
+            if (args.title !== undefined)
+                edit.title = args.title;
+            if (args.content !== undefined)
+                edit.content = args.content;
+            return textResult(applyEditsText(engine, scope, sessionIdOf(exec), [edit], exec.agent));
+        },
+    }));
+    ctx.tools.register(defineTool({
+        name: "evolve_delete",
+        description: "Delete one harness entry by id.",
+        parameters: {
+            kind: { type: "string", enum: ["prompt", "memory", "skill", "subagent"], required: true },
+            id: { type: "string", required: true },
+            global: { type: "boolean", description: "Set true to edit the cross-session store (requires human approval)." },
+        },
+        output: {
+            schema: { type: "object", additionalProperties: false, properties: { text: { type: "string", required: true } } },
+            render: (_args, value) => [{ type: "text", text: value.text ?? "" }],
+        },
+        execute: async (args, exec) => {
+            const scope = scopeOf(args.global, "local");
+            if (scope === "global" && opts.requireGlobalApproval) {
+                await requireGlobalApproval(ctx, exec.agent, exec.signal, `evolve_delete ${args.kind}:${args.id} → 跨会话全局 store`);
+            }
+            const edit = { action: "delete", kind: args.kind, id: args.id };
+            return textResult(applyEditsText(engine, scope, sessionIdOf(exec), [edit], exec.agent));
+        },
+    }));
+    ctx.tools.register(defineTool({
+        name: "evolve_rollback",
+        description: "Deterministically revert a previous refinement by its id (from evolve_list history or the /evolve command).",
+        parameters: {
+            refinementId: { type: "string", required: true, description: "The refinement id to roll back." },
+            global: { type: "boolean", description: "Set true to roll back a cross-session refinement." },
+        },
+        output: {
+            schema: { type: "object", additionalProperties: false, properties: { text: { type: "string", required: true } } },
+            render: (_args, value) => [{ type: "text", text: value.text ?? "" }],
+        },
+        execute: async (args, exec) => {
+            const scope = scopeOf(args.global, "local");
+            const result = engine.rollback(scope, sessionIdOf(exec), args.refinementId);
+            return textResult(`Rolled back ${result.rollbackOf ?? result.id}: ${result.appliedEdits.filter((e) => e.applied).length} edit(s) reverted.`);
+        },
+    }));
+}
+function applyEditsText(engine, scope, sessionId, edits, agent) {
+    const result = engine.apply(scope, sessionId, {
+        summary: "Direct tool edit",
+        rationale: "Model-invoked single edit via evolve_* tool.",
+        expectedOutcome: "Entry is created, updated, or deleted as requested.",
+        edits,
+    }, agent
+        ? {
+            scope,
+            ...(entrySourceOf(agent, sessionId) ? { source: entrySourceOf(agent, sessionId) } : {}),
+        }
+        : { scope });
+    const applied = result.appliedEdits.filter((e) => e.applied);
+    const failed = result.appliedEdits.filter((e) => !e.applied);
+    const lines = [`refinement ${result.id}: ${applied.length} applied, ${failed.length} failed`];
+    for (const e of applied) {
+        lines.push(`- ${e.action} ${e.kind}:${e.id} (v${(e.after?.version ?? e.before?.version) ?? "?"})`);
+    }
+    for (const e of failed) {
+        lines.push(`- failed ${e.action} ${e.kind}:${e.id ?? "(computed)"} — ${e.error ?? "unknown error"}`);
+    }
+    return lines.join("\n");
+}
+//# sourceMappingURL=tool.js.map