dsh-continual-evolve 0.7.5 → 0.8.0

package/lib/notify.js

@@ -40,4 +40,57 @@ export function notifyAutoReview(ctx, agent, result, turnsSinceLastReview) {
             .warn(`auto-review notice failed for ${agent.id}: ${cause instanceof Error ? cause.message : String(cause)}`);
     }
 }
+/**
+ * Compose the user-visible memory receipt from applied refinement batches
+ * (never model text): every landed memory edit with its rollback command.
+ * No-op and declined-only outcomes render one quiet line each — a foreground
+ * notice for zero landed edits would be nagging, so callers only queue
+ * follow-ups for applied outcomes.
+ */
+export function buildMemoryReceipt(receipt) {
+    const seconds = (receipt.durationMs / 1000).toFixed(1);
+    const stats = `${receipt.turns} 轮推理 / ${receipt.searches} 次检索 / ${seconds}s`;
+    if (receipt.outcome === "noop") {
+        return `🧠 记忆提取：本轮无可沉淀的持久事实（no-op，${stats}），未写入任何条目。`;
+    }
+    if (receipt.outcome === "declined" || (receipt.results ?? []).length === 0) {
+        const scopes = (receipt.declinedScopes ?? []).join("、") || "持久化作用域";
+        return `🧠 记忆提取：${scopes}的写入未获批准，已跳过（${stats}），未写入任何条目。`;
+    }
+    const results = receipt.results ?? [];
+    const applied = results.flatMap((result) => result.appliedEdits.filter((edit) => edit.applied));
+    const lines = applied.slice(0, 12).map((edit) => `- 记忆「${edit.title ?? edit.id}」（${edit.id}）`);
+    if (applied.length > 12)
+        lines.push(`- …另有 ${applied.length - 12} 条（见 /evolve history）`);
+    const declined = (receipt.declinedScopes ?? []).length > 0 ? `\n另有作用域${(receipt.declinedScopes ?? []).join("、")}未经批准（已跳过）。` : "";
+    const rollbacks = [...new Set(results.map((result) => result.id))].map((id) => `/evolve rollback ${id}`).join("；");
+    return [
+        `🧠 记忆提取：本轮沉淀 ${applied.length} 条记忆（${results.length} 个作用域批次，${stats}）：`,
+        lines.length > 0 ? lines.join("\n") : "（无条目成功应用）",
+        declined,
+        `回看：/evolve recall <关键词>；回滚：${rollbacks}`,
+        "请用一句话简短确认即可，不要调用任何工具。",
+    ]
+        .filter((part) => part !== "")
+        .join("\n");
+}
+/**
+ * Queue the memory receipt follow-up. Same containment as the gate notice:
+ * notification failure only logs. Callers gate on applied outcomes — no-op
+ * and declined-only runs stay audit-only (reviews.jsonl) and never wake
+ * the agent.
+ */
+export function notifyMemoryExtraction(ctx, agent, receipt) {
+    try {
+        agent.followup(createUserMessage({
+            content: [{ type: "text", text: buildMemoryReceipt(receipt) }],
+            source: EVOLVE_MESSAGE_SOURCE,
+        }));
+    }
+    catch (cause) {
+        ctx
+            .logger("continual-evolve")
+            .warn(`memory receipt notice failed for ${agent.id}: ${cause instanceof Error ? cause.message : String(cause)}`);
+    }
+}
 //# sourceMappingURL=notify.js.map

package/lib/projection.d.ts

@@ -0,0 +1,22 @@
+import type { HarnessState } from "./types.js";
+/** Index file name at the store root. */
+export declare const MEMORY_INDEX_FILE = "MEMORY.md";
+/** Per-fact file directory inside the store. */
+export declare const MEMORY_FACTS_DIR = "memory";
+/** Map a memory id to a flat filename (`:` is legal on disk but hostile to tools). */
+export declare function memoryFactFilename(id: string): string;
+/**
+ * Rewrite the whole projection from the post-apply state: index, one file
+ * per memory entry (including archived ones, flagged), and deletion of
+ * files whose ids no longer exist. Deterministic — the same state always
+ * produces the same files.
+ *
+ * @param stateDir The store directory holding harness_state.json.
+ * @param state The freshly persisted state (post-apply, post-rollback).
+ */
+export declare function materializeMemoryProjection(stateDir: string, state: HarnessState): void;
+/** Read back one projected fact file (round-trip helper for tests and tools). */
+export declare function readMemoryFact(factsDir: string, filename: string): string;
+/** True when the store directory carries a projection from a previous apply. */
+export declare function hasMemoryProjection(stateDir: string): boolean;
+//# sourceMappingURL=projection.d.ts.map

package/lib/projection.js

@@ -0,0 +1,112 @@
+/**
+ * Readable Markdown projection (P1): a ZCode-style `MEMORY.md` index plus
+ * one file per memory fact, materialized from the JSON store.
+ *
+ * The JSON harness state stays the single source of truth (versions,
+ * rollback, audit). The projection is a derived, human-trustable view:
+ * it is rewritten from the post-apply state inside the engine, so the
+ * model can never write it directly and rollback/archive stay in sync.
+ *
+ * Layout per store directory:
+ *
+ *   <stateDir>/MEMORY.md          one line per memory entry
+ *   <stateDir>/memory/<file>.md   one fact per file with frontmatter
+ */
+import { existsSync, mkdirSync, readdirSync, readFileSync, unlinkSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { isArchived, isMemoryType, MEMORY_TYPE_KEY } from "./types.js";
+/** Index file name at the store root. */
+export const MEMORY_INDEX_FILE = "MEMORY.md";
+/** Per-fact file directory inside the store. */
+export const MEMORY_FACTS_DIR = "memory";
+/** Map a memory id to a flat filename (`:` is legal on disk but hostile to tools). */
+export function memoryFactFilename(id) {
+    return `${id.replace(/:/g, "_")}.md`;
+}
+/**
+ * Rewrite the whole projection from the post-apply state: index, one file
+ * per memory entry (including archived ones, flagged), and deletion of
+ * files whose ids no longer exist. Deterministic — the same state always
+ * produces the same files.
+ *
+ * @param stateDir The store directory holding harness_state.json.
+ * @param state The freshly persisted state (post-apply, post-rollback).
+ */
+export function materializeMemoryProjection(stateDir, state) {
+    const entries = Object.values(state.entries.memory).sort((a, b) => a.id < b.id ? -1 : a.id > b.id ? 1 : 0);
+    const factsDir = join(stateDir, MEMORY_FACTS_DIR);
+    mkdirSync(factsDir, { recursive: true });
+    const expected = new Map();
+    for (const entry of entries) {
+        let filename = memoryFactFilename(entry.id);
+        let suffix = 1;
+        while (expected.has(filename)) {
+            suffix += 1;
+            filename = `${memoryFactFilename(entry.id).replace(/\.md$/, "")}~${suffix}.md`;
+        }
+        expected.set(filename, entry);
+    }
+    for (const [filename, entry] of expected) {
+        writeFileSync(join(factsDir, filename), renderMemoryFact(entry), { encoding: "utf8", mode: 0o600 });
+    }
+    // Sweep facts whose entries vanished (delete); archived entries keep
+    // their file with archived:true frontmatter.
+    let existing;
+    try {
+        existing = readdirSync(factsDir).filter((file) => file.endsWith(".md"));
+    }
+    catch {
+        existing = [];
+    }
+    for (const file of existing) {
+        if (!expected.has(file)) {
+            try {
+                unlinkSync(join(factsDir, file));
+            }
+            catch {
+                // A stale fact file must not break the apply path; the next
+                // materialization retries the sweep.
+            }
+        }
+    }
+    writeFileSync(join(stateDir, MEMORY_INDEX_FILE), renderMemoryIndex([...expected]), { encoding: "utf8", mode: 0o600 });
+}
+/** Read back one projected fact file (round-trip helper for tests and tools). */
+export function readMemoryFact(factsDir, filename) {
+    return readFileSync(join(factsDir, filename), "utf8");
+}
+/** True when the store directory carries a projection from a previous apply. */
+export function hasMemoryProjection(stateDir) {
+    return existsSync(join(stateDir, MEMORY_INDEX_FILE)) && existsSync(join(stateDir, MEMORY_FACTS_DIR));
+}
+function renderMemoryFact(entry) {
+    const type = isMemoryType(entry.metadata[MEMORY_TYPE_KEY]) ? String(entry.metadata[MEMORY_TYPE_KEY]) : "untyped";
+    const frontmatter = [
+        "---",
+        `id: ${entry.id}`,
+        `scope: ${entry.scope}`,
+        `kind: memory`,
+        `memoryType: ${type}`,
+        `version: ${entry.version}`,
+        `path: ${entry.path}`,
+        `archived: ${isArchived(entry)}`,
+        `created_at: ${entry.created_at}`,
+        `updated_at: ${entry.updated_at}`,
+        "---",
+    ].join("\n");
+    return `${frontmatter}\n\n# ${entry.title}\n\n${entry.content}\n`;
+}
+function renderMemoryIndex(files) {
+    const lines = ["# Memory Index", "", "Derived from the JSON harness state — do not edit by hand; it is rewritten on every memory apply.", ""];
+    if (files.length === 0) {
+        lines.push("(no memory entries yet)");
+        return `${lines.join("\n")}\n`;
+    }
+    for (const [file, entry] of files) {
+        const type = isMemoryType(entry.metadata[MEMORY_TYPE_KEY]) ? String(entry.metadata[MEMORY_TYPE_KEY]) : "untyped";
+        const archived = isArchived(entry) ? ", archived" : "";
+        lines.push(`- [${entry.scope}:${entry.id}] ${entry.title} (type=${type}, v${entry.version}${archived}) → ${MEMORY_FACTS_DIR}/${file}`);
+    }
+    return `${lines.join("\n")}\n`;
+}
+//# sourceMappingURL=projection.js.map

package/lib/recall.d.ts

@@ -0,0 +1,85 @@
+/**
+ * Targeted memory recall (P1): the precise-reading counterpart of the cheap
+ * directory index.
+ *
+ * The injected directory view (`inject.ts`) shows one line per entry and the
+ * full `evolve_list` dumps whole stores; neither answers "give me everything
+ * about X". Recall fills that gap: filter by query/kind/scope/memory-type,
+ * rank with the same CJK BM25 machinery as injection, and return full
+ * content plus source, version, and staleness signals. Read-only — it never
+ * mutates a store.
+ */
+import type { EvolutionEngine } from "./service.js";
+import type { HarnessScope, RefinementKind } from "./types.js";
+/** Memory recall types (the `memoryType` taxonomy, not entry kinds). */
+export declare const RECALL_MEMORY_TYPES: readonly ["user", "feedback", "project", "reference"];
+export type RecallMemoryType = (typeof RECALL_MEMORY_TYPES)[number];
+/** Default and maximum hits returned per recall call. */
+export declare const DEFAULT_RECALL_LIMIT = 10;
+export declare const MAX_RECALL_LIMIT = 50;
+export interface RecallFilters {
+    /** Free-text relevance query; empty means "most recently updated first". */
+    query?: string;
+    /** Entry kinds to search; default is memory only. */
+    kinds?: RefinementKind[];
+    /** Stores to search; default is local + project + global. */
+    scopes?: HarnessScope[];
+    /** Memory-type filter (applies to memory entries only). */
+    memoryTypes?: RecallMemoryType[];
+    /** Maximum hits; clamped to 1..50, defaults to 10. */
+    limit?: number;
+    /** Include archived entries; default false. */
+    includeArchived?: boolean;
+}
+/** One recalled entry with full content and provenance. */
+export interface RecallHit {
+    scope: HarnessScope;
+    kind: RefinementKind;
+    id: string;
+    title: string;
+    content: string;
+    path: string;
+    version: number;
+    createdAt: string;
+    updatedAt: string;
+    archived: boolean;
+    /** Memory-type hook for memory entries; undefined for other kinds. */
+    memoryType?: string;
+    /** Conflict-hint stamp left by the promotion guard, when present. */
+    staleHint?: string;
+    /** Session the entry was distilled from, when recorded. */
+    sourceSession?: string;
+    /** Source user-message seqs, when recorded. */
+    sourceSeqs?: number[];
+}
+export interface RecallResult {
+    hits: RecallHit[];
+    /** Skipped scopes with reasons (read-path honesty: never silently drop a store). */
+    notes: string[];
+    /** Candidates seen before ranking/truncation. */
+    totalCandidates: number;
+}
+export interface RecallContext {
+    /** Live session id for the local store; absent → local is skipped with a note. */
+    sessionId?: string | undefined;
+    /** Resolved project key; absent → project is skipped with a note. */
+    projectKey?: string | undefined;
+}
+/**
+ * Search the harness stores with mechanical filters and BM25 ranking.
+ *
+ * @param engine The evolution engine (read-only use).
+ * @param context Store identities for the session-scoped stores.
+ * @param filters Query/kind/scope/type/limit/archive filters.
+ * @returns Ranked hits plus a note for every scope that could not be read.
+ * @throws On an unknown kind, scope, or memory type — fail loud instead of
+ *         silently narrowing the search.
+ */
+export declare function recallMemories(engine: EvolutionEngine, context: RecallContext, filters?: RecallFilters): RecallResult;
+/**
+ * Render recall hits for a model or human reader: full content, version,
+ * source, and staleness on every hit; skipped scopes are always shown so
+ * "no results" can never hide an unread store.
+ */
+export declare function formatRecallResult(result: RecallResult, query?: string): string;
+//# sourceMappingURL=recall.d.ts.map

package/lib/recall.js

@@ -0,0 +1,142 @@
+import { buildRelevanceIndex, relevanceScore } from "./search.js";
+import { CONFLICT_HINT_KEY } from "./types.js";
+import { isArchived, isMemoryType, ARCHIVED_AT_KEY, MEMORY_TYPE_KEY, SOURCE_SEQS_KEY, SOURCE_SESSION_KEY } from "./types.js";
+/** Memory recall types (the `memoryType` taxonomy, not entry kinds). */
+export const RECALL_MEMORY_TYPES = ["user", "feedback", "project", "reference"];
+/** Entry kinds recall can filter on; memory is the default. */
+const RECALL_KINDS = ["prompt", "memory", "skill", "subagent"];
+/** Default and maximum hits returned per recall call. */
+export const DEFAULT_RECALL_LIMIT = 10;
+export const MAX_RECALL_LIMIT = 50;
+/**
+ * Search the harness stores with mechanical filters and BM25 ranking.
+ *
+ * @param engine The evolution engine (read-only use).
+ * @param context Store identities for the session-scoped stores.
+ * @param filters Query/kind/scope/type/limit/archive filters.
+ * @returns Ranked hits plus a note for every scope that could not be read.
+ * @throws On an unknown kind, scope, or memory type — fail loud instead of
+ *         silently narrowing the search.
+ */
+export function recallMemories(engine, context, filters = {}) {
+    const kinds = filters.kinds ?? ["memory"];
+    for (const kind of kinds) {
+        if (!RECALL_KINDS.includes(kind)) {
+            throw new Error(`evolve_recall: unknown kind "${kind}" (expected one of ${RECALL_KINDS.join(", ")})`);
+        }
+    }
+    const scopes = filters.scopes ?? ["local", "project", "global"];
+    for (const scope of scopes) {
+        if (scope !== "local" && scope !== "project" && scope !== "global") {
+            throw new Error(`evolve_recall: unknown scope "${scope}" (expected local, project, or global)`);
+        }
+    }
+    const memoryTypes = filters.memoryTypes ?? [];
+    for (const memoryType of memoryTypes) {
+        if (!RECALL_MEMORY_TYPES.includes(memoryType)) {
+            throw new Error(`evolve_recall: unknown memoryType "${memoryType}" (expected one of ${RECALL_MEMORY_TYPES.join(", ")})`);
+        }
+    }
+    const limit = typeof filters.limit === "number" && Number.isFinite(filters.limit) && filters.limit > 0
+        ? Math.min(Math.floor(filters.limit), MAX_RECALL_LIMIT)
+        : DEFAULT_RECALL_LIMIT;
+    const query = filters.query?.trim() ?? "";
+    const candidates = [];
+    const notes = [];
+    for (const scope of scopes) {
+        const storeId = scope === "local" ? context.sessionId : scope === "project" ? context.projectKey : undefined;
+        if (scope !== "global" && storeId === undefined) {
+            notes.push(`${scope} store skipped: ${scope === "local" ? "no live session id" : "no project key for this session"}`);
+            continue;
+        }
+        let state;
+        try {
+            state = engine.load(scope, storeId);
+        }
+        catch (cause) {
+            notes.push(`${scope} store unreadable: ${cause instanceof Error ? cause.message : String(cause)}`);
+            continue;
+        }
+        for (const kind of kinds) {
+            for (const entry of Object.values(state.entries[kind])) {
+                if (!filters.includeArchived && isArchived(entry))
+                    continue;
+                if (kind === "memory" && memoryTypes.length > 0) {
+                    const type = entry.metadata[MEMORY_TYPE_KEY];
+                    if (typeof type !== "string" || !memoryTypes.includes(type))
+                        continue;
+                }
+                candidates.push(entry);
+            }
+        }
+    }
+    const ranked = query.length > 0 ? rankByRelevance(candidates, query) : [...candidates].sort((a, b) => (a.updated_at < b.updated_at ? 1 : a.updated_at > b.updated_at ? -1 : 0));
+    return { hits: ranked.slice(0, limit).map(toRecallHit), notes, totalCandidates: candidates.length };
+}
+function rankByRelevance(candidates, query) {
+    const index = buildRelevanceIndex(candidates);
+    const normalized = query.trim().toLowerCase();
+    return candidates
+        .map((entry) => {
+        let score = relevanceScore(index, entry, query);
+        // Exact scope:id addressing wins over fuzzy relevance (the
+        // memory-agent manifest search precedent).
+        if (`${entry.scope}:${entry.id}`.toLowerCase() === normalized)
+            score += 1000;
+        return { entry, score };
+    })
+        .filter((hit) => hit.score > 0)
+        .sort((a, b) => b.score - a.score || (a.entry.updated_at < b.entry.updated_at ? 1 : -1))
+        .map((hit) => hit.entry);
+}
+function toRecallHit(entry) {
+    const memoryType = entry.kind === "memory" && isMemoryType(entry.metadata[MEMORY_TYPE_KEY])
+        ? String(entry.metadata[MEMORY_TYPE_KEY])
+        : undefined;
+    const staleHint = typeof entry.metadata[CONFLICT_HINT_KEY] === "string" && entry.metadata[CONFLICT_HINT_KEY].length > 0
+        ? String(entry.metadata[CONFLICT_HINT_KEY])
+        : undefined;
+    const sourceSession = typeof entry.metadata[SOURCE_SESSION_KEY] === "string" ? String(entry.metadata[SOURCE_SESSION_KEY]) : undefined;
+    const rawSeqs = entry.metadata[SOURCE_SEQS_KEY];
+    const sourceSeqs = Array.isArray(rawSeqs) && rawSeqs.every((seq) => typeof seq === "number") ? rawSeqs : undefined;
+    return {
+        scope: entry.scope,
+        kind: entry.kind,
+        id: entry.id,
+        title: entry.title,
+        content: entry.content,
+        path: entry.path,
+        version: entry.version,
+        createdAt: entry.created_at,
+        updatedAt: entry.updated_at,
+        archived: isArchived(entry),
+        ...(memoryType !== undefined ? { memoryType } : {}),
+        ...(staleHint !== undefined ? { staleHint } : {}),
+        ...(sourceSession !== undefined ? { sourceSession } : {}),
+        ...(sourceSeqs !== undefined ? { sourceSeqs } : {}),
+    };
+}
+/**
+ * Render recall hits for a model or human reader: full content, version,
+ * source, and staleness on every hit; skipped scopes are always shown so
+ * "no results" can never hide an unread store.
+ */
+export function formatRecallResult(result, query) {
+    const lines = [`recall: ${result.hits.length} hit(s)${query?.trim() ? ` for "${query.trim()}"` : ""} (${result.totalCandidates} candidate(s))`];
+    for (const hit of result.hits) {
+        const type = hit.memoryType !== undefined ? ` · type=${hit.memoryType}` : "";
+        const archived = hit.archived ? " · archived" : "";
+        const stale = hit.staleHint !== undefined ? ` · conflict-hint=${hit.staleHint}` : "";
+        const source = hit.sourceSession !== undefined ? ` · src=${hit.sourceSession}${hit.sourceSeqs ? `:${hit.sourceSeqs.join(",")}` : ""}` : "";
+        lines.push(`- [${hit.scope}:${hit.kind}:${hit.id}] ${hit.title} (v${hit.version}${type}${archived}${stale}${source})`);
+        lines.push(`  ${hit.content}`);
+    }
+    for (const note of result.notes) {
+        lines.push(`note: ${note}`);
+    }
+    if (result.hits.length === 0) {
+        lines.push(`(${ARCHIVED_AT_KEY} entries are hidden unless includeArchived is set)`);
+    }
+    return lines.join("\n");
+}
+//# sourceMappingURL=recall.js.map

package/lib/service.js

@@ -4,6 +4,7 @@ import { randomUUID } from "node:crypto";
 import { rollbackProposal } from "./rollback.js";
 import { loadHarnessState, saveHarnessState } from "./state.js";
 import { appendResult, loadResults, pruneJsonlFile, pruneSnapshots, resolveHistoryRetention, snapshotBefore, storePaths } from "./store.js";
+import { materializeMemoryProjection } from "./projection.js";
 import { CONFLICT_BLOCK_SCORE, CONFLICT_WARN_SCORE, buildConflictNotice, mostSimilarEntry, secretLeakReason } from "./promotion.js";
 /** A post-commit apply failure that still carries the durable applied result. */
 export class EvolutionApplyPostCommitError extends Error {
@@ -137,6 +138,19 @@ export function createEvolutionEngine(baseDir, hooks = {}, opts = {}) {
         catch {
             // ignored — the next apply retries
         }
+        // Readable Markdown projection (P1): rewritten from the post-apply
+        // state whenever a memory edit landed, so rollback and archive stay
+        // in sync through this same apply path. The model has no writer for
+        // these files — only this engine entry point materializes them.
+        if (result.appliedEdits.some((edit) => edit.applied && edit.kind === "memory")) {
+            try {
+                materializeMemoryProjection(paths.stateDir, state);
+            }
+            catch {
+                // ignored — the projection is derived (JSON stays the source
+                // of truth) and the next memory apply retries
+            }
+        }
         try {
             hooks.onApplied?.(result);
         }

package/lib/tool.js

@@ -5,6 +5,7 @@ import { formatHarnessStateForPrompt } from "./render.js";
 import { requireGlobalApproval } from "./approval.js";
 import { CONFLICT_WARN_SCORE, buildConflictNotice, mostSimilarEntry } from "./promotion.js";
 import { entrySourceOf } from "./source.js";
+import { formatRecallResult, recallMemories } from "./recall.js";
 import { getUsageCount, loadUsage } from "./usage.js";
 import { buildEvolveCompleteEvent, emitEvolveComplete } from "./evolve-event.js";
 import { DEFAULT_REVIEWS_RETAIN } from "./store.js";
@@ -115,6 +116,45 @@ export function registerEvolveTools(ctx, engine, opts) {
             return textResult(text);
         },
     }));
+    ctx.tools.register(defineTool({
+        name: "evolve_recall",
+        description: "Targeted recall over the harness stores: filter memories (or other kinds) by query, kind, scope, and memory type, and read back full content with version, source, and staleness signals. Read-only — it never mutates a store. Prefer this over evolve_list when looking for something specific.",
+        parameters: {
+            query: { type: "string", description: "Free-text relevance query. Empty means most-recently-updated first." },
+            kinds: {
+                type: "array",
+                items: { type: "string" },
+                description: "Entry kinds to search (default memory only).",
+            },
+            scopes: {
+                type: "array",
+                items: { type: "string" },
+                description: "Stores to search (default local, project, and global).",
+            },
+            memoryTypes: {
+                type: "array",
+                items: { type: "string" },
+                description: "Memory-type filter: user, feedback, project, reference (memory entries only).",
+            },
+            limit: { type: "number", description: "Maximum hits (default 10, at most 50)." },
+            includeArchived: { type: "boolean", description: "Include archived entries (default false)." },
+        },
+        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 result = recallMemories(engine, { sessionId: sessionIdOf(exec), projectKey: projectKeyOf(exec.agent) ?? undefined }, {
+                ...(typeof args.query === "string" ? { query: args.query } : {}),
+                ...(Array.isArray(args.kinds) ? { kinds: args.kinds } : {}),
+                ...(Array.isArray(args.scopes) ? { scopes: args.scopes } : {}),
+                ...(Array.isArray(args.memoryTypes) ? { memoryTypes: args.memoryTypes } : {}),
+                ...(typeof args.limit === "number" ? { limit: args.limit } : {}),
+                ...(typeof args.includeArchived === "boolean" ? { includeArchived: args.includeArchived } : {}),
+            });
+            return textResult(formatRecallResult(result, typeof args.query === "string" ? args.query : undefined));
+        },
+    }));
     ctx.tools.register(defineTool({
         name: "evolve_add",
         description: "Create one harness entry (prompt/memory/skill/subagent). Executable skills require reference {type:python, import, callable} and an arguments contract; guidance skills (skill_kind=guidance) are SKILL.md documents — recurring multi-step workflows — and must NOT carry a reference. Snapshot, version, and history are handled automatically.",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-continual-evolve",
-  "version": "0.7.5",
+  "version": "0.8.0",
   "description": "Continual self-evolution plugin for DeepSeek Harness: versioned, auditable, rollback-safe harness state (prompt notes, memories, skills, subagent specs) refined from session trajectories.",
   "license": "MIT",
   "repository": {