dsh-continual-evolve 0.7.4 → 0.7.6

package/README.md

@@ -19,14 +19,14 @@ Agents accumulate reusable experience (repeated failures, durable facts, reusabl
 
 - **Three scopes** with merge semantics (global < project < local): **local** per-session staging, **project** per-workspace cross-session store, **global** cross-project — plus mechanical promotion guards so only portable, substantial, non-duplicate knowledge reaches global
 - **Typed one-fact memories**: every memory entry carries a recall type (`user | feedback | project | reference`); pitfalls (`feedback`) must include Why + How to apply
-- **Dedicated background memory agent**: after eligible successful turns, a bounded ZCode-style loop searches the frozen memory manifest and proposes memory-only edits through a closed tool set; it cannot call agents, MCP, the network, or write source files
+- **Dedicated background memory agent**: eligible successful turns feed a bounded ZCode-style loop that searches the frozen memory manifest and proposes memory-only edits through a closed tool set; it cannot call agents, MCP, the network, or write source files. The generic review/planner/fate path is not run by this listener
 - **Deterministic rollback**: inverse edits generated from applied results — no LLM re-guessing
 - **Benchmark loop**: candidate refinements are evaluated against frozen cases by a separate scorer before acceptance (rubric encrypted at rest)
 - **Store hygiene**: `/evolve consolidate` turns write-time conflict hints and zero-use staleness into one approved, fully reversible batch of archives — with `merge`, near-duplicate content folds into the surviving original
 
 ## How it works
 
-1. **Sediment** — the model creates entries via `evolve_add`, or the automatic pipeline consumes incremental snapshots captured after successful turns (plus compaction checkpoints): a dedicated memory agent runs first, then the general review/planner proposes non-memory refinements.
+1. **Sediment** — the model creates entries via `evolve_add`, or the automatic Memory Agent consumes incremental snapshots after successful turns. Generic review/planner remains manual unless separately invoked.
 2. **Capability-aware auxiliary calls** — the memory loop, review, planner, wrapup, and fate resolve exact provider/model metadata through [`src/llm-text.ts`](src/llm-text.ts), use the lowest advertised enabled reasoning effort (falling back to a closing effort only when no enabled level exists), and forward the host session id for provider routing; models without reasoning metadata use their provider default.
 3. **Guard** — code-enforced validation: edit schema, blast-radius/scope coherence, and the promotion policy (project-scoped markers, thin content, near-duplicate detection, credential screening keep the global store clean — secrets are rejected at every write sink, including mount materialization). Global creates that near-duplicate an existing entry are rejected at write time (≥0.8 similarity); moderate overlaps carry a `conflictHint` for later consolidation.
 4. **Approve** — global and project writes require explicit human approval; the dialog shows the bounded structured edit diff and conflict warnings, while malformed/lost responses remain retryable rather than counting as rejection.
@@ -79,13 +79,14 @@ Injection shape: prompt notes and delegation specs inject with content (≤6/kin
 | Key | Default | Meaning |
 |---|---|---|
 | `baseDir` | resolved DSH home | root for the `evolve/` stores |
-| `autoReview` | `false` | initial memory+review pipeline default when no runtime switch exists; the listener is always registered |
+| `autoReview` | `false` | initial Memory Agent default when no `evolve/runtime.json` exists yet; the listener is always registered, so this is not a registration gate |
+| `memoryMinUserWords` | `3` | ZCode-style minimum lexical words in one direct user text part; uses CJK-aware segmentation |
 | `reviewIntervalTurns` | `6` | legacy local-fate cadence fallback; successful-turn review no longer waits for this interval |
 | `maxReviewInputChars` | `40000` | trajectory slice handed to the gate |
 | `reviewBudgetTokens` | `4096` | output budget for the gate call |
 | `notifyOnAutoReview` | `true` | visible follow-up notice after an applied gate run |
 | `requireGlobalApproval` | `true` | global and project edits ask for explicit approval |
-| `localFate` | `true` | gate audits local entries and proposes promote/archive (consulted, never silent) |
+| `localFate` | `false` | optional local-entry promote/archive fate assessment; unreachable while the listener runs memory-only, so it only affects direct/full callers |
 | `fateIntervalTurns` | follows `reviewIntervalTurns` | minimum turns between fate assessments |
 | `goalBlockedWrapupTurns` | `3` | consecutive blocked-goal gate runs trigger one fate assessment (`0` disables) |
 | `promotionBlockPatterns` | POSIX paths, session ids, `~/.dsh` | content matching these is project-scoped and never promoted to global |
@@ -111,18 +112,25 @@ Example profile patch:
     reviewIntervalTurns: 6
 ```
 
-The listener is registered even when `autoReview` is `false`. Use `/evolve resume`
-to enable successful-turn snapshots immediately, `/evolve pause` to suppress new
-snapshots and fate/model work, and `/evolve status` to inspect the configured
-default plus the current runtime state. The runtime switch is stored in
-`evolve/runtime.json`; manual `evolve_*` tools and `/evolve` commands are not
-paused.
+The Memory Agent listener is registered even when `autoReview` is `false` —
+`autoReview` only supplies the initial default, so an install works without
+editing the profile. Use `/evolve resume` to enable successful-turn snapshots
+immediately, `/evolve pause` to suppress new snapshots and model work, and
+`/evolve status` to inspect the configured default plus the current runtime
+state. The runtime switch is stored in `evolve/runtime.json`; manual `evolve_*`
+tools and `/evolve` commands are not paused. Only the Memory Agent runs
+automatically: the generic review/planner, prompt/skill writes, and local-fate
+phases are not reachable from this listener. The memory trigger follows ZCode's
+lightweight eligibility: direct user text must contain at least
+`memoryMinUserWords` lexical words (CJK-aware segmentation), while
+empty/internal/direct-memory-write snapshots are skipped; compaction does not
+add a separate memory-only trigger.
 
 ## Development
 
 ```bash
 pnpm install && pnpm build   # deps + tsc -> lib/
-pnpm test                    # vitest (737 tests)
+pnpm test                    # vitest (742 tests)
 pnpm test:coverage           # v8 coverage, thresholds enforced in CI
 pnpm lint                    # oxlint src test
 ```

package/README.zh.md

@@ -19,14 +19,14 @@ Agent 在每个会话里积累可复用经验（重复失败、持久事实、
 
 - **三作用域**与合并语义（global < project < local）：**local** 本会话暂存、**project** 本项目跨会话库、**global** 跨项目——配合机械化晋升守卫，只有可携带、有分量、非重复的知识才能进全局
 - **类型化单条记忆**：每条 memory 带召回类型（`user | feedback | project | reference`）；踩坑（`feedback`）必须含 Why + How to apply
-- **专用后台记忆 Agent**：成功回合通过机械 eligibility 后，有界 ZCode 式 loop 检索冻结的 memory manifest，并经闭集工具提出纯 memory 编辑；不能调用 Agent、MCP、网络，也不能写源码
+- **专用后台记忆 Agent**：成功回合通过机械 eligibility 后，有界 ZCode 式 loop 检索冻结的 memory manifest，并经闭集工具提出纯 memory 编辑；不能调用 Agent、MCP、网络，也不能写源码。该 listener 不运行通用 review/planner/fate
 - **确定性回滚**：逆操作编辑由已应用结果生成——不靠 LLM 重新猜测
 - **benchmark 闭环**：候选沉淀先经冻结用例 + 独立评分者评估再接受（rubric 加密落盘）
 - **store 卫生**：`/evolve consolidate` 把写入时冲突提示与零使用陈旧条目变成一次批准、完全可逆的批量归档——加 `merge` 可将近重复内容并入幸存原条目
 
 ## 工作原理
 
-1. **沉淀**——模型经 `evolve_add` 创建条目，或自动管线消费成功回合后的增量 snapshot（以及压缩检查点）：先运行专用 memory Agent，再由通用 review/planner 提议非 memory 精炼。
+1. **沉淀**——模型经 `evolve_add` 创建条目，或由专用 Memory Agent 消费成功回合后的增量 snapshot。通用 review/planner 保持手动，除非另行显式调用。
 2. **能力感知的辅助调用**——memory loop、review、planner、wrapup、fate 通过 [`src/llm-text.ts`](src/llm-text.ts) 解析精确 provider/model 能力并使用模型公布的最低开启 reasoning effort，同时转发 host session id 供 provider 路由；只有没有开启档时才回退关闭档，没有 reasoning 元数据时使用 provider 默认行为。
 3. **守卫**——代码强制校验：编辑 schema、blast-radius 与作用域一致性、晋升政策（项目专属标记 / 过薄内容 / 近似重复检测 / 凭据筛查保持全局库干净——密钥类内容在所有写入出口被拒，含 mount 物化）。全局 create 与既有条目高度相似（≥0.8）时写入即拒；中等重叠带 `conflictHint` 供后续合并。
 4. **审批**——全局与项目写入需明确人工批准；弹窗展示有界结构化编辑 diff 与冲突提示，弹窗丢失/响应畸形会重试，不会被误记为拒绝。
@@ -79,13 +79,14 @@ dsh plugin add ZK-Andy/dsh-continual-evolve
 | 键 | 默认 | 含义 |
 |---|---|---|
 | `baseDir` | 解析后的 DSH home | `evolve/` 存储根目录 |
-| `autoReview` | `false` | 没有 runtime 开关时自动 memory+review 管线的初始默认；监听器始终注册 |
+| `autoReview` | `false` | 没有 `evolve/runtime.json` 时 Memory Agent 的初始默认；监听器始终注册，因此它不是注册门 |
+| `memoryMinUserWords` | `3` | ZCode 风格：单个直接用户文本至少包含的词数；使用 CJK 分词 |
 | `reviewIntervalTurns` | `6` | local-fate 的兼容节奏；成功回合 review 不再等待这个间隔 |
 | `maxReviewInputChars` | `40000` | 交给门禁的轨迹切片 |
 | `reviewBudgetTokens` | `4096` | 门禁调用输出预算 |
 | `notifyOnAutoReview` | `true` | 门禁应用后发可见跟进通知 |
 | `requireGlobalApproval` | `true` | 全局与项目写入需明确批准 |
-| `localFate` | `true` | 门禁审计本地条目并提议晋升/归档（先征询，绝不静默） |
+| `localFate` | `false` | 可选的本地条目晋升/归档 fate 评估；listener 以 memory-only 运行时不可达，只对直接/完整调用者生效 |
 | `fateIntervalTurns` | 跟随 `reviewIntervalTurns` | 归宿评估的最小回合间隔 |
 | `goalBlockedWrapupTurns` | `3` | 连续阻塞目标的门禁轮数触发一次归宿评估（`0` 关闭） |
 | `promotionBlockPatterns` | POSIX 路径、session id、`~/.dsh` | 内容命中即判定项目专属，永不晋升全局 |
@@ -111,13 +112,13 @@ profile patch 示例：
     reviewIntervalTurns: 6
 ```
 
-即使 `autoReview` 为 `false`，监听器也会注册。使用 `/evolve resume` 立即开启成功回合 snapshot，使用 `/evolve pause` 抑制新 snapshot、fate 和模型调用，使用 `/evolve status` 查看配置默认值与运行时状态。开关保存在 `evolve/runtime.json`；手动 `evolve_*` 工具和 `/evolve` 命令不受暂停影响。
+即使 `autoReview` 为 `false`，Memory Agent 监听器也会注册——`autoReview` 只提供初始默认值，装完即用，无需改 profile。使用 `/evolve resume` 立即开启成功回合 snapshot，使用 `/evolve pause` 抑制新 snapshot 与模型调用，使用 `/evolve status` 查看配置默认值与运行时状态。开关保存在 `evolve/runtime.json`；手动 `evolve_*` 工具和 `/evolve` 命令不受暂停影响。自动运行只有 Memory Agent：通用 review/planner、prompt/skill 写入与 local fate 都不由该 listener 触达。Memory 触发采用 ZCode 的轻量 eligibility：单个直接用户文本至少包含 `memoryMinUserWords` 个词（使用 CJK 分词）；空增量、内部 Agent、直接 memory 写入会跳过，压缩不会额外触发 memory-only 管线。
 
 ## 开发
 
 ```bash
 pnpm install && pnpm build   # 依赖 + tsc -> lib/
-pnpm test                    # vitest（737 例）
+pnpm test                    # vitest（742 例）
 pnpm test:coverage           # v8 覆盖率，CI 强制阈值
 pnpm lint                    # oxlint src test
 ```

package/lib/auto.d.ts

@@ -12,6 +12,13 @@ export interface AutoReviewConfig {
     intervalTurns: number;
     /** Initial runtime state when no runtime.json exists. */
     enabledByDefault?: boolean;
+    /** ZCode-style minimum lexical words in one direct user text part. */
+    memoryMinUserWords?: number;
+    /**
+     * Run only the dedicated memory extraction phase. The general review,
+     * planner, prompt/skill writes, and local-fate phases are never entered.
+     */
+    memoryOnly?: boolean;
     maxInputChars: number;
     budgetTokens: number;
     /** Queue a visible follow-up notice after an approved, applied gate run. */

package/lib/auto.js

@@ -1,9 +1,10 @@
 /**
- * The automatic review driver: watches agent turns and session compaction,
- * runs the cheap review gate, and — when the gate approves — runs the
- * local-scope planner and applies the result. All auxiliary work is
- * fire-and-forget with error containment: an auto-review failure never
- * disturbs the agent loop.
+ * The automatic evolution driver: watches agent turns and session compaction.
+ * In the production wiring it runs only the dedicated Memory Agent; the
+ * general review/planner and local-fate phases remain available to direct
+ * callers but are not entered by memory-only mode. All auxiliary work is
+ * fire-and-forget with error containment: an automatic failure never disturbs
+ * the agent loop.
  *
  * Every gate decision (approved / declined / failed / skipped) is appended to
  * `<dshHome>/evolve/reviews.jsonl` so auto-review activity is durably
@@ -80,7 +81,12 @@ export function registerAutoReview(ctx, engine, config) {
                 return "no-op";
             }
             try {
-                await runGate(ctx, engine, agent, config, state, snapshot, record, signal);
+                if (config.memoryOnly) {
+                    await runMemoryExtractionPhase(ctx, engine, agent, config, state, snapshot, signal);
+                }
+                else {
+                    await runGate(ctx, engine, agent, config, state, snapshot, record, signal);
+                }
                 return "success";
             }
             catch (cause) {
@@ -118,6 +124,7 @@ export function registerAutoReview(ctx, engine, config) {
                 reason,
                 ...(cursor !== undefined ? { cursor } : {}),
                 maxChars: config.maxInputChars,
+                ...(config.memoryMinUserWords !== undefined ? { minUserWords: config.memoryMinUserWords } : {}),
             });
             if (!disposedSessions.has(agent.id))
                 schedulerFor(agent, state).schedule(snapshot);
@@ -169,7 +176,7 @@ export function registerAutoReview(ctx, engine, config) {
             reason: "boot",
             turnsSinceLastReview: 0,
             outcome: "armed",
-            rationale: `auto-review gate registered (default=${defaultEnabled ? "on" : "off"}; per-success-turn snapshots; local-fate every ${config.fateIntervalTurns} turns)`,
+            rationale: `automatic evolution listener registered (mode=${config.memoryOnly ? "memory-only" : "full"}; default=${defaultEnabled ? "on" : "off"}; per-success-turn snapshots)`,
         })}\n`, "utf8");
     }
     catch (cause) {
@@ -192,6 +199,11 @@ export function registerAutoReview(ctx, engine, config) {
         perSession.delete(agent.id);
     });
     ctx.on("session/event", (session, event) => {
+        // ZCode schedules extraction from successful turns, not from compaction.
+        // Keep the legacy compaction path for direct/full callers, but do not
+        // add an extra automatic Memory Agent trigger in memory-only mode.
+        if (config.memoryOnly)
+            return;
         if (event.type !== "compaction/start")
             return;
         const agents = ctx.agents;

package/lib/command.d.ts

@@ -18,7 +18,7 @@ export interface CommandRuntimeOptions {
     /** Mechanical promotion guards for wrapup/fate (2026-08-22 policy). */
     promotionPolicy: PromotionPolicy;
     /**
-     * Initial auto-review default from plugin config. The listener is always
+     * Initial Memory Agent default from plugin config. The listener is always
      * registered; this is not a registration gate.
      */
     autoReview?: boolean;

package/lib/command.js

@@ -44,8 +44,8 @@ const USAGE = `Usage:
   /evolve goal               show the evolution goal (round-driven auto-review)
   /evolve goal <objective>   create/update the evolution goal
   /evolve goal done          complete the evolution goal
-  /evolve pause | resume     pause/resume the auto-review gate (manual tools and commands keep working)
-  /evolve status             gate state (patch flag + runtime switch) plus store entry counts
+  /evolve pause | resume     pause/resume the automatic Memory Agent (manual tools and commands keep working)
+  /evolve status             automatic Memory Agent state plus store entry counts
   /evolve usage              injection counts + exact direct-call token usage (benchmark subagents excluded)`;
 export function registerEvolveCommand(ctx, engine, opts, runtime) {
     ctx.commands.register({
@@ -377,21 +377,21 @@ async function executeEvolveCommand(ctx, engine, invocation, opts, runtime) {
             case "pause":
             case "resume": {
                 // The switch is independent of the static registration flag. A
-                // resume explicitly enables automatic snapshots; a pause leaves
-                // the enable bit intact so status explains the paused state.
+                // resume explicitly enables the Memory Agent; a pause leaves the
+                // enable bit intact so status explains the paused state.
                 const pausing = sub === "pause";
                 const defaultEnabled = runtime.autoReview ?? false;
                 const current = loadGateRuntime(engine.baseDir, defaultEnabled);
                 if (pausing && current.paused) {
-                    return success("auto-review gate is already paused (no change).");
+                    return success("automatic Memory Agent is already paused (no change).");
                 }
                 if (!pausing && current.enabled && !current.paused) {
-                    return success("auto-review gate is already running (no change).");
+                    return success("automatic Memory Agent is already running (no change).");
                 }
                 saveGateRuntime(engine.baseDir, pausing, pausing ? current.enabled : true);
                 return success(pausing
-                    ? "auto-review gate paused: no automatic snapshots, fate assessments, or gate LLM calls until /evolve resume. Manual evolve_* tools and /evolve commands keep working."
-                    : "auto-review gate resumed: successful turns will produce incremental snapshots immediately.");
+                    ? "automatic Memory Agent paused: no automatic memory extraction calls until /evolve resume. Manual evolve_* tools and /evolve commands keep working."
+                    : "automatic Memory Agent resumed: successful turns will produce incremental memory snapshots immediately.");
             }
             case "status": {
                 return success(renderGateStatus(engine, sessionId, projectKeyOf(invocation.agent), runtime));
@@ -458,14 +458,18 @@ function demoteEntry(engine, id, sessionId, projectKey) {
     return error(`entry ${id} not found in the global, project, or local store`);
 }
 /**
- * Status answers whether the always-registered listener is enabled at runtime
- * and what stores/retention it currently sees.
+ * Status answers whether the automatic listener is wired and what
+ * stores/retention it currently sees.
  */
 function renderGateStatus(engine, sessionId, projectKey, runtime) {
     const configuredDefault = runtime.autoReview === undefined ? "unknown" : runtime.autoReview ? "on" : "off";
     const current = loadGateRuntime(engine.baseDir, runtime.autoReview ?? false);
-    const effective = current.paused ? "PAUSED (resume with /evolve resume)" : current.enabled ? "running" : "off (enable with /evolve resume)";
-    const gateLine = `gate: listener registered · config default ${configuredDefault} · runtime ${effective}`;
+    const effective = current.paused
+        ? "PAUSED (resume with /evolve resume)"
+        : current.enabled
+            ? "Memory Agent running"
+            : "Memory Agent off (enable with /evolve resume)";
+    const gateLine = `gate: Memory Agent-only listener registered · config default ${configuredDefault} · runtime ${effective}`;
     const countEntries = (state) => Object.values(state.entries).reduce((n, byKind) => n + Object.keys(byKind).length, 0);
     const lines = [gateLine];
     lines.push(`stores: global ${countEntries(engine.load("global", undefined))} entries · local(${sessionId}) ${countEntries(engine.load("local", sessionId))} entries`);

package/lib/index.d.ts

@@ -10,8 +10,10 @@ export declare const Config: z<Schemastery.ObjectS<NoInfer<{
     baseDir: z<string, string, "plain">;
     /** System-prompt section order for the evolution guidance. */
     sectionOrder: z<number, number, "defined">;
-    /** Initial automatic-review default when no runtime switch exists (off by default: it costs model calls). */
+    /** Initial Memory Agent default when no `evolve/runtime.json` exists; not a registration gate. */
     autoReview: z<boolean, boolean, "defined">;
+    /** ZCode-style minimum lexical words in one direct user text part. */
+    memoryMinUserWords: z<number, number, "defined">;
     /** Legacy/local-fate cadence fallback; successful-turn review is snapshot-driven. */
     reviewIntervalTurns: z<number, number, "defined">;
     /** Trajectory slice handed to the gate, in characters. */
@@ -58,7 +60,8 @@ export declare const Config: z<Schemastery.ObjectS<NoInfer<{
     /**
      * Gate local-fate dimension (#11 P2): the gate audits the session's local
      * entries on its own cadence and proposes promote/archive — consulted
-     * first, never written silently. Only meaningful with autoReview on.
+     * first, never written silently. Only meaningful with autoReview on;
+     * disabled by default even when the automatic pipeline is explicitly enabled.
      */
     localFate: z<boolean, boolean, "defined">;
     /**
@@ -107,8 +110,10 @@ export declare const Config: z<Schemastery.ObjectS<NoInfer<{
     baseDir: z<string, string, "plain">;
     /** System-prompt section order for the evolution guidance. */
     sectionOrder: z<number, number, "defined">;
-    /** Initial automatic-review default when no runtime switch exists (off by default: it costs model calls). */
+    /** Initial Memory Agent default when no `evolve/runtime.json` exists; not a registration gate. */
     autoReview: z<boolean, boolean, "defined">;
+    /** ZCode-style minimum lexical words in one direct user text part. */
+    memoryMinUserWords: z<number, number, "defined">;
     /** Legacy/local-fate cadence fallback; successful-turn review is snapshot-driven. */
     reviewIntervalTurns: z<number, number, "defined">;
     /** Trajectory slice handed to the gate, in characters. */
@@ -155,7 +160,8 @@ export declare const Config: z<Schemastery.ObjectS<NoInfer<{
     /**
      * Gate local-fate dimension (#11 P2): the gate audits the session's local
      * entries on its own cadence and proposes promote/archive — consulted
-     * first, never written silently. Only meaningful with autoReview on.
+     * first, never written silently. Only meaningful with autoReview on;
+     * disabled by default even when the automatic pipeline is explicitly enabled.
      */
     localFate: z<boolean, boolean, "defined">;
     /**

package/lib/index.js

@@ -3,10 +3,11 @@
  *
  * Mounts the evolution engine, registers the model-facing evolve_* tools,
  * the human-facing /evolve command, the system-prompt guidance section, and
- * the automatic memory+review pipeline. The listener is always registered,
- * while its effective state is controlled by the runtime switch. Successful
- * turns feed a dedicated memory agent and general review through one
- * per-session serial scheduler.
+ * the dedicated Memory Agent listener. The listener is always registered so
+ * an install works without profile edits; `autoReview` only supplies the
+ * initial default when `evolve/runtime.json` does not exist yet, and
+ * `/evolve pause|resume` own it afterwards. Generic review/planner/fate are
+ * not reachable from this listener.
  */
 import { join } from "node:path";
 import z from "@deepseek-ai/schemastery";
@@ -30,8 +31,10 @@ export const Config = z.object({
     baseDir: z.string(),
     /** System-prompt section order for the evolution guidance. */
     sectionOrder: z.natural().default(118),
-    /** Initial automatic-review default when no runtime switch exists (off by default: it costs model calls). */
+    /** Initial Memory Agent default when no `evolve/runtime.json` exists; not a registration gate. */
     autoReview: z.boolean().default(false),
+    /** ZCode-style minimum lexical words in one direct user text part. */
+    memoryMinUserWords: z.natural().default(3),
     /** Legacy/local-fate cadence fallback; successful-turn review is snapshot-driven. */
     reviewIntervalTurns: z.natural().default(6),
     /** Trajectory slice handed to the gate, in characters. */
@@ -78,9 +81,10 @@ export const Config = z.object({
     /**
      * Gate local-fate dimension (#11 P2): the gate audits the session's local
      * entries on its own cadence and proposes promote/archive — consulted
-     * first, never written silently. Only meaningful with autoReview on.
+     * first, never written silently. Only meaningful with autoReview on;
+     * disabled by default even when the automatic pipeline is explicitly enabled.
      */
-    localFate: z.boolean().default(true),
+    localFate: z.boolean().default(false),
     /**
      * Minimum turns between local-fate assessments on the turn-interval path
      * (compaction is unconditional). Absent → follows reviewIntervalTurns.
@@ -163,7 +167,7 @@ export function apply(ctx, config) {
         autoRollbackOnReject: config.autoRollbackOnReject ?? true,
         autoCase: config.autoCase ?? true,
         promotionPolicy,
-        ...(config.autoReview !== undefined ? { autoReview: config.autoReview } : {}),
+        autoReview: config.autoReview ?? false,
     });
     // Plugin-owned file logging: every cordis log message lands in
     // <baseDir>/evolve/plugin.log regardless of how dsh web was launched —
@@ -178,16 +182,20 @@ export function apply(ctx, config) {
     void restoreMounted(ctx, baseDir).catch((cause) => {
         ctx.logger("continual-evolve").warn(`mount restore failed: ${cause instanceof Error ? cause.message : String(cause)}`);
     });
-    // The listener is always registered. `autoReview` is only the initial
-    // runtime default; `/evolve resume` can enable it without a profile edit
-    // or process restart, while manual tools and commands stay independent.
+    // The Memory Agent listener is always registered: an install must work
+    // without profile edits, so `autoReview` is only the initial default when
+    // no `evolve/runtime.json` exists yet — `/evolve pause|resume` own the
+    // switch afterwards. The general review/planner, prompt/skill writes, and
+    // local-fate phases are not reachable from this listener.
     registerAutoReview(ctx, engine, {
         intervalTurns: config.reviewIntervalTurns ?? 6,
         enabledByDefault: config.autoReview ?? false,
+        memoryOnly: true,
+        memoryMinUserWords: config.memoryMinUserWords ?? 3,
         maxInputChars: config.maxReviewInputChars ?? 40000,
         budgetTokens: config.reviewBudgetTokens ?? 4096,
         notifyOnAutoReview: config.notifyOnAutoReview ?? true,
-        localFate: config.localFate ?? true,
+        localFate: config.localFate ?? false,
         fateIntervalTurns: config.fateIntervalTurns ?? config.reviewIntervalTurns ?? 6,
         goalBlockedWrapupTurns: config.goalBlockedWrapupTurns ?? 3,
         promotionPolicy,
@@ -199,8 +207,7 @@ export function apply(ctx, config) {
         ...(config.plannerPrefixCache ? { prefixCacheMode: config.plannerPrefixCache } : {}),
         ...(config.plannerPrefixMaxChars !== undefined ? { prefixMaxChars: config.plannerPrefixMaxChars } : {}),
     });
-    const runtimeDefault = config.autoReview ?? false;
-    ctx.logger("continual-evolve").info(`continual-evolve auto-review registered (default ${runtimeDefault ? "on" : "off"}; successful-turn memory agent + general review; local-fate ${config.localFate ?? true ? "on" : "off"} every ${config.fateIntervalTurns ?? config.reviewIntervalTurns ?? 6} turns)`);
+    ctx.logger("continual-evolve").info("continual-evolve automatic listener registered (Memory Agent only; generic review/planner/fate disconnected)");
     ctx.logger("continual-evolve").info(`continual-evolve mounted (baseDir=${baseDir})`);
 }
 //# sourceMappingURL=index.js.map

package/lib/turn-snapshot.d.ts

@@ -24,6 +24,7 @@ export interface TurnSnapshot {
     readonly userText: string;
     readonly sourceSeqs: readonly number[];
     readonly maxChars: number;
+    readonly minUserWords: number;
     /** Cursor supplied by the shared scheduler before this snapshot selected events. */
     readonly capturedAfterCursor?: string;
     readonly eligible: boolean;
@@ -35,6 +36,8 @@ export interface SnapshotEligibility {
     readonly reason?: SnapshotSkipReason;
     readonly userText: string;
 }
+/** ZCode's minimum user-prose threshold, counted as lexical words. */
+export declare const MEMORY_MIN_USER_WORDS = 3;
 /**
  * Capture the current durable surface and select only rows after `cursor`.
  * A seq-bearing session uses `seq:<n>`; older/test surfaces fall back to an
@@ -45,6 +48,7 @@ export declare function captureTurnSnapshot(ctx: Context, agent: Agent, opts: {
     reason: TurnSnapshotReason;
     cursor?: string;
     maxChars: number;
+    minUserWords?: number;
 }): Promise<TurnSnapshot>;
 /**
  * Rebase one captured snapshot onto a phase-specific cursor while preserving
@@ -58,7 +62,7 @@ export declare function sliceTurnSnapshot(snapshot: TurnSnapshot, cursor: string
  * does not decide whether a fact is valuable; that remains the review model's
  * job. It only removes mechanical noise before the scheduler spends tokens.
  */
-export declare function evaluateSnapshotEligibility(events: readonly unknown[], internalAgent?: boolean): SnapshotEligibility;
+export declare function evaluateSnapshotEligibility(events: readonly unknown[], internalAgent?: boolean, minUserWords?: number): SnapshotEligibility;
 /** True when an assistant row records an explicit evolve memory mutation. */
 export declare function containsDirectMemoryWrite(events: readonly unknown[]): boolean;
 /** Serialize only user/assistant text, retaining the bounded tail. */

package/lib/turn-snapshot.js

@@ -1,5 +1,19 @@
 import { sessionEventsOf } from "./inject.js";
 import { projectKeyOf } from "./project.js";
+/** ZCode's minimum user-prose threshold, counted as lexical words. */
+export const MEMORY_MIN_USER_WORDS = 3;
+const WORD_SEGMENTER = new Intl.Segmenter("und", { granularity: "word" });
+function countUserWords(text) {
+    return [...WORD_SEGMENTER.segment(text)].filter((segment) => segment.isWordLike).length;
+}
+function containsEligibleUserProse(events, minUserWords) {
+    return events.some((event) => {
+        if (!isDirectUserEvent(event))
+            return false;
+        const row = event;
+        return countUserWords(contentText(row.data?.content)) >= minUserWords;
+    });
+}
 /**
  * Capture the current durable surface and select only rows after `cursor`.
  * A seq-bearing session uses `seq:<n>`; older/test surfaces fall back to an
@@ -9,7 +23,8 @@ export async function captureTurnSnapshot(ctx, agent, opts) {
     const allEvents = await readSurface(ctx, agent);
     const cursor = boundaryCursor(allEvents);
     const events = eventsAfterCursor(allEvents, opts.cursor);
-    const eligibility = evaluateSnapshotEligibility(events, isInternalAgent(agent));
+    const minUserWords = opts.minUserWords ?? MEMORY_MIN_USER_WORDS;
+    const eligibility = evaluateSnapshotEligibility(events, isInternalAgent(agent), minUserWords);
     const projectKey = projectKeyOf(agent);
     return {
         sessionId: agent.id,
@@ -22,6 +37,7 @@ export async function captureTurnSnapshot(ctx, agent, opts) {
         userText: eligibility.userText,
         sourceSeqs: directUserSeqs(events),
         maxChars: opts.maxChars,
+        minUserWords,
         ...(opts.cursor === undefined ? {} : { capturedAfterCursor: opts.cursor }),
         eligible: eligibility.eligible,
         ...(eligibility.reason ? { skipReason: eligibility.reason } : {}),
@@ -35,7 +51,7 @@ export async function captureTurnSnapshot(ctx, agent, opts) {
  */
 export function sliceTurnSnapshot(snapshot, cursor) {
     const events = sliceSnapshotEvents(snapshot, cursor);
-    const eligibility = evaluateSnapshotEligibility(events, false);
+    const eligibility = evaluateSnapshotEligibility(events, false, snapshot.minUserWords);
     return {
         ...snapshot,
         events,
@@ -51,7 +67,7 @@ export function sliceTurnSnapshot(snapshot, cursor) {
  * does not decide whether a fact is valuable; that remains the review model's
  * job. It only removes mechanical noise before the scheduler spends tokens.
  */
-export function evaluateSnapshotEligibility(events, internalAgent = false) {
+export function evaluateSnapshotEligibility(events, internalAgent = false, minUserWords = MEMORY_MIN_USER_WORDS) {
     if (internalAgent)
         return { eligible: false, reason: "internal-agent", userText: "" };
     if (events.length === 0)
@@ -59,7 +75,7 @@ export function evaluateSnapshotEligibility(events, internalAgent = false) {
     if (containsDirectMemoryWrite(events))
         return { eligible: false, reason: "direct-memory-write", userText: "" };
     const userText = directUserText(events);
-    if (userText.length < 3)
+    if (!containsEligibleUserProse(events, minUserWords))
         return { eligible: false, reason: "no-user-prose", userText };
     return { eligible: true, userText };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-continual-evolve",
-  "version": "0.7.4",
+  "version": "0.7.6",
   "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": {