dsh-continual-evolve 0.10.6 → 0.12.0

package/lib/logfile.d.ts

@@ -1,71 +0,0 @@
-/**
- * Plugin-owned file logging: a cordis logger exporter that appends every
- * log message — from this plugin or any other — to a JSONL file under the
- * evolve store. Logging becomes a property of the plugin itself: no extra
- * component to install, and it works no matter how `dsh web` is launched
- * (foreground terminal, nohup, restart scripts, ...). The official
- * `cordis-plugin-logger-console` remains an optional add-on for live
- * terminal output; this file exporter is the baseline that always exists.
- *
- * - file: `<baseDir>/evolve/plugin.log` (0600, JSONL)
- * - rotation: when the file exceeds `logMaxBytes` it is renamed to
- *   `plugin.log.1` (replacing the previous `.1`)
- * - level: `levels.default` = logLevel (0=error, 1=info, 2=warn, 3=debug)
- * - failure containment: a write error is swallowed — logging never
- *   disturbs the agent loop
- */
-import type { Context } from "@deepseek-ai/cordis";
-/** Name of the plugin log file under `<baseDir>/evolve/`. */
-export declare const PLUGIN_LOG_FILE_NAME = "plugin.log";
-/** Default rotation threshold (5 MiB). */
-export declare const DEFAULT_LOG_MAX_BYTES: number;
-export interface FileLoggerConfig {
-    /** 0=error, 1=info, 2=warn, 3=debug. */
-    logLevel?: number;
-    /** Rotate the log when it exceeds this many bytes. */
-    logMaxBytes?: number;
-}
-/** Full path of the plugin log file. */
-export declare function pluginLogFilePath(baseDir: string): string;
-/** JSON-safe rendering of a log message's arguments. */
-export declare function renderArgs(args: readonly unknown[]): unknown[];
-/** One JSONL record as written to the log file. */
-export declare function logRecord(message: {
-    ts: number;
-    type: string;
-    name: string;
-    args: readonly unknown[];
-}): string;
-/** Human-readable rendering of one stored JSONL line (unparseable lines pass through). */
-export declare function formatLogLine(line: string): string;
-/**
- * The distinct session ids mentioned in one stored log line, drawn from the
- * rendered message and the raw args (unparseable lines fall back to a raw
- * text scan). Exact-token matching, so `session-abc` never matches
- * `session-abcd`.
- */
-export declare function sessionIdsInLine(line: string): string[];
-/**
- * Keep only the lines mentioning the given session id (exact token match).
- * An empty/whitespace session id filters everything out — the caller should
- * validate the argument before calling.
- */
-export declare function filterLogBySession(lines: readonly string[], sessionId: string): string[];
-/** Append one line, rotating the file first when it exceeds maxBytes. */
-export declare function appendOrRotate(path: string, maxBytes: number, line: string): void;
-/**
- * Register the file exporter on the context. Returns the exporter so tests
- * can drive it directly. The exporter is disposed with the plugin's scope.
- */
-export declare function registerFileLogger(ctx: Context, baseDir: string, config?: FileLoggerConfig): {
-    levels: {
-        default: number;
-    };
-    export(message: {
-        ts: number;
-        type: string;
-        name: string;
-        args: readonly unknown[];
-    }): void;
-};
-//# sourceMappingURL=logfile.d.ts.map

package/lib/logfile.js

@@ -1,159 +0,0 @@
-import { Logger } from "@deepseek-ai/cordis";
-import { appendFileSync, existsSync, mkdirSync, renameSync, statSync, writeFileSync } from "node:fs";
-import { dirname, join } from "node:path";
-/** Name of the plugin log file under `<baseDir>/evolve/`. */
-export const PLUGIN_LOG_FILE_NAME = "plugin.log";
-/** Default rotation threshold (5 MiB). */
-export const DEFAULT_LOG_MAX_BYTES = 5 * 1024 * 1024;
-/** Full path of the plugin log file. */
-export function pluginLogFilePath(baseDir) {
-    return join(baseDir, "evolve", PLUGIN_LOG_FILE_NAME);
-}
-/** JSON-safe rendering of a log message's arguments. */
-export function renderArgs(args) {
-    return args.map((arg) => {
-        if (arg instanceof Error) {
-            return { name: arg.name, message: arg.message, stack: arg.stack };
-        }
-        if (typeof arg === "object" && arg !== null) {
-            try {
-                return JSON.parse(JSON.stringify(arg));
-            }
-            catch {
-                return String(arg);
-            }
-        }
-        return arg;
-    });
-}
-/** One JSONL record as written to the log file. */
-export function logRecord(message) {
-    // `message` is the printf-rendered text (cordis handles %s/%o/...), so
-    // humans and machines both get a usable line; `args` keeps the raw
-    // payload for tooling. Errors render as their stack (JSON.stringify of
-    // an Error is just {}).
-    const rendered = Logger.format({
-        formatters: {
-            o: (value) => (value instanceof Error ? value.stack ?? value.message : JSON.stringify(value)),
-        },
-        maxLength: 10240,
-        export: () => { },
-    }, {
-        sn: 0,
-        ts: message.ts,
-        name: message.name,
-        type: message.type,
-        level: 0,
-        args: message.args,
-    });
-    return JSON.stringify({
-        ts: new Date(message.ts).toISOString(),
-        type: message.type,
-        name: message.name,
-        args: renderArgs(message.args),
-        message: rendered,
-    });
-}
-/** Human-readable rendering of one stored JSONL line (unparseable lines pass through). */
-export function formatLogLine(line) {
-    try {
-        const record = JSON.parse(line);
-        const ts = record.ts ?? "";
-        const type = record.type ? `[${record.type[0]?.toUpperCase() ?? "?"}]` : "[?]";
-        const name = record.name ?? "";
-        const body = typeof record.message === "string" && record.message.length > 0 ? record.message : "";
-        const args = body
-            ? ""
-            : Array.isArray(record.args)
-                ? record.args.map((arg) => (typeof arg === "object" && arg !== null ? JSON.stringify(arg) : String(arg))).join(" ")
-                : "";
-        return `${ts} ${type} ${name} ${body || args}`.trimEnd();
-    }
-    catch {
-        return line;
-    }
-}
-/** A session id as it appears in log text (dsh `session-<hex-uuid>` ids). */
-const SESSION_TOKEN_RE = /\bsession-[0-9a-fA-F-]+\b/g;
-/**
- * The distinct session ids mentioned in one stored log line, drawn from the
- * rendered message and the raw args (unparseable lines fall back to a raw
- * text scan). Exact-token matching, so `session-abc` never matches
- * `session-abcd`.
- */
-export function sessionIdsInLine(line) {
-    const ids = [];
-    const collect = (text) => {
-        for (const match of text.matchAll(SESSION_TOKEN_RE)) {
-            ids.push(match[0]);
-        }
-    };
-    try {
-        const record = JSON.parse(line);
-        if (typeof record.message === "string")
-            collect(record.message);
-        if (Array.isArray(record.args)) {
-            for (const arg of record.args) {
-                collect(typeof arg === "object" && arg !== null ? JSON.stringify(arg) : String(arg));
-            }
-        }
-    }
-    catch {
-        collect(line);
-    }
-    return [...new Set(ids)];
-}
-/**
- * Keep only the lines mentioning the given session id (exact token match).
- * An empty/whitespace session id filters everything out — the caller should
- * validate the argument before calling.
- */
-export function filterLogBySession(lines, sessionId) {
-    const needle = sessionId.trim();
-    if (!needle) {
-        return [];
-    }
-    return lines.filter((line) => sessionIdsInLine(line).includes(needle));
-}
-/** Append one line, rotating the file first when it exceeds maxBytes. */
-export function appendOrRotate(path, maxBytes, line) {
-    const dir = dirname(path);
-    if (!existsSync(path)) {
-        mkdirSync(dir, { recursive: true });
-        // 0600: the log can carry session context and must not be world-readable
-        writeFileSync(path, "", { encoding: "utf8", mode: 0o600 });
-    }
-    if (maxBytes > 0) {
-        try {
-            if (statSync(path).size > maxBytes) {
-                renameSync(path, `${path}.1`);
-            }
-        }
-        catch {
-            // stat/rename failures fall through to the append attempt
-        }
-    }
-    appendFileSync(path, `${line}\n`, "utf8");
-}
-/**
- * Register the file exporter on the context. Returns the exporter so tests
- * can drive it directly. The exporter is disposed with the plugin's scope.
- */
-export function registerFileLogger(ctx, baseDir, config = {}) {
-    const path = pluginLogFilePath(baseDir);
-    const maxBytes = config.logMaxBytes ?? DEFAULT_LOG_MAX_BYTES;
-    const exporter = {
-        levels: { default: config.logLevel ?? 1 },
-        export(message) {
-            try {
-                appendOrRotate(path, maxBytes, logRecord(message));
-            }
-            catch {
-                // logging must never disturb the agent loop
-            }
-        },
-    };
-    ctx.logger.exporter(exporter);
-    return exporter;
-}
-//# sourceMappingURL=logfile.js.map

package/lib/memory-agent.d.ts

@@ -1,129 +0,0 @@
-/**
- * Dedicated background memory extraction agent.
- *
- * This is the DSH counterpart of ZCode's project-memory agent loop. It keeps
- * an independent request history, exposes only a frozen memory manifest and a
- * structured proposal tool, and never writes state itself. Every accepted edit
- * is handed to EvolutionEngine so scope approval, snapshots, versioning,
- * rollback, and audit remain mandatory.
- */
-import type { Context } from "@deepseek-ai/cordis";
-import type { Agent } from "@deepseek-ai/dsh-agent";
-import { type ToolSchema } from "@deepseek-ai/dsh-llm";
-import { type ScopeApprovalDecision } from "./approval.js";
-import { type LlmSessionId } from "./llm-text.js";
-import { type PrefixCacheOptions } from "./prefix-cache.js";
-import { type EvolutionEngine } from "./service.js";
-import { type TokenUsageTarget } from "./token-usage.js";
-import { type RecordLanguage, type RecordLanguagePreference } from "./record-language.js";
-import type { EntrySource, HarnessEntry, HarnessScope, HarnessState, RefinementEdit, RefinementProposal, RefinementResult } from "./types.js";
-/** ZCode parity: the extractor may inspect memory and propose at most five times. */
-export declare const MEMORY_AGENT_MAX_TURNS = 5;
-/** Bound one proposal so approval text and engine compensation stay reviewable. */
-export declare const MEMORY_AGENT_MAX_EDITS = 20;
-/**
- * System-prompt size budget (chars): the prompt ships on EVERY extractor
- * turn (up to five per snapshot), so each added line is recurring token
- * spend, not one-off text. Raise this cap only in the same commit that
- * justifies the added lines (regression pressure beats silent bloat).
- */
-export declare const MEMORY_AGENT_SYSTEM_PROMPT_BUDGET_CHARS = 3000;
-/** The complete tool-name allowlist exposed by the memory agent. */
-export declare const MEMORY_AGENT_TOOL_NAMES: readonly ["memory_search", "memory_propose"];
-export type MemoryAgentToolName = (typeof MEMORY_AGENT_TOOL_NAMES)[number];
-/** One frozen memory entry visible to the extractor for the whole run. */
-export type MemoryManifestEntry = HarnessEntry;
-/** A memory-only edit with an explicit persistence target. */
-export type ScopedMemoryEdit = RefinementEdit & {
-    kind: "memory";
-    targetScope: HarnessScope;
-};
-/** Structured result returned by `memory_propose`. */
-export interface MemoryExtractionProposal extends Omit<RefinementProposal, "edits"> {
-    edits: ScopedMemoryEdit[];
-}
-/** Baseline states captured before the first extractor model turn. */
-export interface MemoryScopeBaselines {
-    local: HarnessState;
-    project?: HarnessState;
-    global: HarnessState;
-}
-/** Result of one bounded extractor loop. */
-export interface MemoryAgentRun {
-    proposal: MemoryExtractionProposal;
-    turns: number;
-    searches: number;
-}
-/** Scoped results after the proposal crosses the governed engine boundary. */
-export interface MemoryApplicationResult {
-    results: RefinementResult[];
-    declinedScopes: HarnessScope[];
-}
-/** Provider-facing schemas for the closed memory-only tool set. */
-export declare const MEMORY_AGENT_TOOL_SCHEMAS: readonly ToolSchema[];
-/** Instructions for the dedicated loop; model text is always untrusted. */
-export declare const MEMORY_AGENT_SYSTEM_PROMPT = "You are the dedicated background memory extraction agent for a continual-evolution harness.\n\nYou receive only an incremental conversation checkpoint and a frozen manifest of existing memory entries. Your entire job is to decide whether this checkpoint contains a durable fact worth remembering. Never propose prompt notes, skills, subagent specs, code changes, or general conversation summaries.\n\nRules:\n- Use memory_search before creating when the manifest may already cover the topic. Update an existing entry instead of creating a near-duplicate.\n- Every memory entry contains exactly one fact. Classify it with metadata.memoryType = user | feedback | project | reference.\n- feedback and project memories must state the fact, Why it matters, and How to apply it next time.\n- Never invent a user preference. Ground every proposal in the supplied conversation evidence and existing memory.\n- Every edit must have kind=memory, an explicit targetScope, and a coherent blastRadius.\n- targetScope=local is session staging. project persists within the current repository. global persists across projects. project/global require human approval before application.\n- update/delete/archive must name an existing id from the same targetScope. Prefer archive over delete when the fact is obsolete but should remain restorable.\n- Do not remember: code structure or file paths re-readable from the repository; git history, diffs, commit hashes, or CI logs; content already written in project instruction files; temporary session state, one-off debugging trails, or current task progress; model-only speculation without conversation evidence; an already-applied troubleshooting fix with no recurrence evidence (the fixed state on disk is its own record).\n- Be specific enough to act on: prefer a fact that tells the next session what to DO over a summary of what happened. If the fact is obvious from the conversation itself with no future action attached, skip it.\n- Save only what is surprising or non-obvious: routine chatter, restated context, and facts with no bearing on future work are no-ops, not memories.\n- Granularity examples (vague \u2192 reject; sharp \u2192 save):\n  - \"user communicates in Chinese\" \u2192 \"user reads English with effort \u2014 write memory and handoff content in Chinese prose\".\n  - \"user works on the desktop project\" \u2192 \"desktop profile loads npm-installed plugin copies \u2014 source edits need a release before they take effect\".\n  - \"fixed fcitx5 by setting GTK_IM_MODULE tonight\" \u2192 reject (one-off applied fix, already on disk, no recurrence evidence).\n- You cannot read or write source files, call agents, use MCP, use the network, or mutate the harness directly. memory_propose is the only finish tool and never writes state itself.\n- If no durable memory is justified, call memory_propose with edits=[].\n- Always finish by calling memory_propose. Do not return unproposed prose.";
-/** Build the frozen memory manifest from a merged harness view. */
-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 interface MemoryAgentOptions {
-    provider: string;
-    model: string;
-    sessionId?: LlmSessionId;
-    manifest: readonly MemoryManifestEntry[];
-    trajectory: string;
-    trajectoryEvents?: readonly unknown[];
-    prefixCache?: PrefixCacheOptions;
-    maxOutputTokens?: number;
-    signal?: AbortSignal;
-    tokenUsage?: TokenUsageTarget;
-    /**
-     * Authoring language for the proposal. Absent → resolved per call
-     * (explicit config upstream, else durable client preference, else
-     * trajectory detection, else `en`).
-     */
-    language?: RecordLanguage;
-}
-/**
- * Run the dedicated loop against a frozen manifest.
- *
- * @throws On provider failure, abort, malformed tool arguments, policy denial,
- * a non-memory proposal, or exhaustion of the bounded internal turn budget.
- */
-export declare function runMemoryAgent(ctx: Context, options: MemoryAgentOptions): Promise<MemoryAgentRun>;
-/** Strictly parse and policy-check the structured `memory_propose` payload. */
-export declare function parseMemoryExtractionProposal(value: unknown, manifest: readonly MemoryManifestEntry[]): MemoryExtractionProposal;
-export interface ApplyMemoryProposalOptions {
-    agent: Agent;
-    baselines: MemoryScopeBaselines;
-    projectKey?: string;
-    requireApproval: boolean;
-    source?: EntrySource;
-    signal?: AbortSignal;
-    /** Outer cursor used to scope reusable approval decisions. */
-    decisionCursor?: string;
-    /** Prior decisions for the same cursor and exact scoped proposal. */
-    scopeDecisions?: Readonly<Record<string, ScopeApprovalDecision>>;
-    /** Persist each decision before a later scope can fail. */
-    onScopeDecision?: (key: string, decision: ScopeApprovalDecision) => void;
-    /** Plugin `recordLanguage` preference for the approval dialog copy. */
-    recordLanguage?: RecordLanguagePreference;
-}
-/**
- * Render the authoritative persistent-scope diff shown to the human. Model
- * prose is retained only as an explicitly untrusted summary; actions, targets,
- * content previews, memory types, and conflict warnings come from code.
- */
-export declare function renderMemoryApprovalDetails(proposal: MemoryExtractionProposal, scope: "project" | "global", state: HarnessState, maxChars?: number): string;
-/**
- * Apply one accepted proposal through the only mutation engine. All persistent
- * approvals are resolved before the first write, so an unavailable approval
- * boundary cannot leave a partially applied batch. Explicit rejection is a
- * no-op for that scope; service/question failures remain retryable errors.
- */
-export declare function applyMemoryExtractionProposal(ctx: Context, engine: EvolutionEngine, proposal: MemoryExtractionProposal, options: ApplyMemoryProposalOptions): Promise<MemoryApplicationResult>;
-//# sourceMappingURL=memory-agent.d.ts.map