dsh-continual-evolve 0.15.13 → 0.15.15

package/README.md

@@ -7,7 +7,7 @@ English | [中文](README.zh.md)
 [![CI](https://github.com/ZK-Andy/dsh-continual-evolve/actions/workflows/ci.yml/badge.svg)](https://github.com/ZK-Andy/dsh-continual-evolve/actions/workflows/ci.yml)
 [![License: MIT](https://img.shields.io/badge/license-MIT-blue.svg)](LICENSE)
 [![Node](https://img.shields.io/badge/node-%5E22.19%20%7C%7C%20%3E%3D24-339933)](package.json)
-[![Tests](https://img.shields.io/badge/tests-395%20passing-brightgreen)]()
+[![Tests](https://img.shields.io/badge/tests-409%20passing-brightgreen)]()
 [![Coverage · statements](https://img.shields.io/badge/coverage_statements-96%25-brightgreen)]()
 [![Coverage · branches](https://img.shields.io/badge/coverage_branches-90%25-green)]()
 [![Coverage · functions](https://img.shields.io/badge/coverage_functions-100%25-brightgreen)]()
@@ -24,7 +24,7 @@ Reusable experience gathered in one session (user preferences, pitfalls, project
 2. **Four tools, one writer** — `memory_write` (create/update/delete) is the explicit path for "remember …" / "forget …": every proposal passes the code gates (id shape, type enum, the feedback Why/How contract, secret screening carried over from v1, 64KB body cap, optional `corrects` links to the same-workspace active memory being superseded) inside one transaction. `memory_read` fetches bodies by id and searches by keyword — whitespace-separated terms are AND-combined, with literal substring matching for short terms and whenever the trigram index misses; the injected index carries hooks only. Each memory body served by id increments that memory's view counter (views + last viewed, the same presence heartbeat as skills). `skill_write` (create/update/delete in the project, plus an explicit move-to-global) sediments reusable procedures through the same discipline (kebab ids, secret screening, 64KB cap, no duplicate ids or bodies across scopes); every applied skill is materialized by the plugin as `<workspace>/.agents/skills/<id>/SKILL.md` — the database is the source of truth, the files are a read-only projection patrol restores on drift. `skill_read` fetches skill bodies by id and searches project plus global skills (the project shadows a same-named global); each body served by id increments that skill's view counter (views + last viewed), which the card shows as a presence heartbeat — viewed, not applied, so long-unviewed rows are removal candidates while pruning itself stays human. On hosts without the tools service the plugin degrades to "tell the user" phrasing and stays functional.
 3. **Proposal-based extraction** — the trajectory-to-memory automation, audited in the `extraction_log`: every `agent/turn-stopping` schedules that session's boundary, with state kept **per session** (a run in flight keeps only its newest boundary — coalescing, not queueing; `compaction/start` and session close drain it) and **no idle timer**. A run reads the session increment since its cursor, feeds FTS-similar existing memories to one LLM call, and the model's structured proposal lands through the same gates; failures and rejections never advance the cursor. A cheap pre-gate (increment head + ownership triple-test, tiny verdict) runs first: refusals consume the increment as a model skip without the full call, and an unclear gate fails open to the full call — worst case degrades to the old single-call behavior, never to a stall. Full and gate usages ledger in separate `usage` / `cheap_usage` columns, and a gate that dies keeps its error head in the same row's `cheap_error` — a dead gate stays tellable from a gate that never existed. Internal agents, empty increments, turns without real user prose, and turns that already carried an explicit `memory_write` are mechanically skipped — and every skip is ledgered, consecutive quiet turns of one session as a single row carrying how many wake-ups it stands for.
 4. **Autonomous content-quality loop** — the second background automation, independent from extraction by construction (own prompts, own daily budget, own `review_log` ledger, no cursor; only the store's write gates are shared): a cheap gate model call decides whether a memory/skill entry deserves a close look, and only approvals run the evolve pass that judges content quality (memories on home-ownership plus accuracy/usability/reusability/duplication/freshness, skills on home-ownership plus trigger precision/executability/duplication, where reuse is scope-aware: a project-partition skill is judged inside its project (in-project reuse) and the cross-project test applies to global-scope skills only — a repo-bound row in the global partition is the mis-homed case) and proposes the rewrite. Each of the four review jobs (memory and skill, gate and evolve) loads its own rubric from one subagent table — a single prompt cannot serve both, since a memory must survive having its repo name stripped while a project skill is supposed to be repo-bound. The same three home tests (user/environment vs repo-version subject, name-stripped sentence, repo facts live in ADR/docs) guard the extraction prompt, so repo-version specifics never enter as memories in the first place. Gate/leg failures ledger the error text instead of a bare code, along with the model they ran on and the tokens the failed call had already burned, and the output budget comes from the model's own advertised cap instead of a fixed number, so a thinking model is not cut off mid-verdict: a verdict that completed before a cut still counts, while a call that produced no verdict at all (route fault, budget cut) leaves the item queued instead of marking it reviewed. New writes are reviewed as they land, the existing stock drains through a bounded backlog queue, and untouched entries requeue after 30 days. Two hard guarantees bound the autonomy: delete never lands automatically (rewrite or quarantine only — quarantine hides, never deletes) and oversized rewrites degrade to quarantine. A daily cap (default 100 items, new > corrects-linked > stale > spot-check priority, the tail drops instead of rolling over) bounds the token spend, and every terminal path lands one `item-review` verdict row plus one daily rollup row (budget vs reviewed vs backlog vs dropped, tokens split by cheap/evolve purpose) for later replay. Ships in trial mode (`review.dryRun`, default on): verdicts ledgered, nothing applied — and a declined rewrite now rides the row's `proposed` column, because a trial has to show what it would write, not just why.
-5. **Rollback is a ledger, not a mechanism** — every mutation lands an `extraction_log` row with full before/after snapshots; undo means rewriting the `before` values. Skill mutations land the same way in `skill_log`, review verdicts in `review_log`. A hygiene pass rides on every applied run: orphan FTS rows are dropped and secret-bearing rows are quarantined (hidden, never deleted; a quarantined skill's materialized file is removed so it stops loading). The read-only card surfaces quarantine anomalies.
+5. **Rollback is a ledger, not a mechanism** — every mutation lands an `extraction_log` row with full before/after snapshots; undo means rewriting the `before` values. Skill mutations land the same way in `skill_log`, review verdicts in `review_log`. A hygiene pass rides on every applied run: orphan FTS rows are dropped and secret-bearing rows are quarantined (hidden, never deleted; a quarantined skill's materialized file is removed so it stops loading). The read-only card surfaces quarantine anomalies. Plugin diagnostics have a durable home of their own: a stock host attaches no exporter to its logger, so `plugin_log` is the only home — the host logger is not mirrored. All four ledgers rotate on one 30-day window, pruned by a day-throttled check that rides store readiness, log writes and the post-extraction hygiene pass.
 6. **Read-only card** — mounted on the plugin's page in the official plugin manager (the `plugins.bundle.config` slot; hosts without it silently degrade to no card), shaped like the market's own settings card and aligned with ZCode's Settings → Memory viewer: a dropdown scope selector over the store's workspace partitions (opening on the host's current workspace), a search box, per-entry relative updated times, click-to-preview bodies (5 MiB cap), patrol warnings, and a skills section listing the workspace's project skills plus visible global skills (global rows badged, project shadowing global) with the same preview, each row showing its view count. Localized through the host's `locale/*.json` metadata channel; host theme tokens, the `Button` primitive, and zh/en copy that tracks the DSH language. The card is a request-time projection of the database and has no edit path.
 
 Memory types follow the ZCode taxonomy: `user` (profile and environment facts), `feedback` (corrected or confirmed practices — bodies must carry **Why:** and **How to apply:** lines), `reference` (resource pointers). The extraction boundary is person- and environment-scoped knowledge only: decisions and trade-offs are repo-scoped by nature and belong to the repo's ADR route, never to memory.
@@ -95,9 +95,12 @@ Layout:
 │   ├── store.ts            # central SQLite store: DDL/WAL/FTS, reads, ledger, patrol, cursors
 │   ├── store-apply.ts      # the sole write gate: validate all, apply atomically, ledger
 │   ├── token-usage.ts      # single accounting entry: normalize provider usage, pure sums
+│   ├── plugin-log.ts       # the plugin's own log table (the host logger has no sink to write to)
+│   ├── retention.ts        # ledger retention: one 30-day window, day-throttled prune trigger
 │   ├── llm-call.ts         # the only transport: route, reasoning effort, output budget, failure facts
 │   ├── subagent.ts         # the loader every LLM call goes through (assemble → call → parse → account)
 │   ├── subagent-defs.ts    # every subagent job in one table: prompt, budget fallback, answer parser
+│   ├── prompt-date.ts      # the clock prompts judge dates by: the run's day + its instruction line
 │   ├── chain.ts            # responsibility chain: one step per link, order assembled by the caller
 │   ├── review-candidates.ts # its queue: what is due (new > corrects-linked > stale)
 │   ├── review.ts           # autonomous quality loop: batch, budget, rollup, scheduler
@@ -120,7 +123,7 @@ Layout:
 ├── client/
 │   └── client.js          # hand-written client bundle: read-only card in the plugin manager
 ├── locale/                # host package metadata: localized display name + description (zh/en)
-├── test/                  # vitest suite (28 files)
+├── test/                  # vitest suite (29 files)
 ├── lib/                   # build output (tsc)
 ├── docs/                  # design.md (design) · FAQ.md (real-world pitfalls)
 └── .agents/               # AI collaboration layer (AGENTS.md, skills, ADR notes)

package/README.zh.md

@@ -7,7 +7,7 @@
 [![CI](https://github.com/ZK-Andy/dsh-continual-evolve/actions/workflows/ci.yml/badge.svg)](https://github.com/ZK-Andy/dsh-continual-evolve/actions/workflows/ci.yml)
 [![License: MIT](https://img.shields.io/badge/license-MIT-blue.svg)](LICENSE)
 [![Node](https://img.shields.io/badge/node-%5E22.19%20%7C%7C%20%3E%3D24-339933)](package.json)
-[![Tests](https://img.shields.io/badge/tests-395%20passing-brightgreen)]()
+[![Tests](https://img.shields.io/badge/tests-409%20passing-brightgreen)]()
 [![Coverage · statements](https://img.shields.io/badge/coverage_statements-96%25-brightgreen)]()
 [![Coverage · branches](https://img.shields.io/badge/coverage_branches-90%25-green)]()
 [![Coverage · functions](https://img.shields.io/badge/coverage_functions-100%25-brightgreen)]()
@@ -24,7 +24,7 @@ Agent 每个会话积累的可复用经验（用户偏好、踩坑教训、项
 2. **四个工具，一个写者** —— `memory_write`（create/update/delete）承接显式的记住/忘掉：每条提案过代码门禁（id 规范、type 枚举、feedback 的 Why/How 契约、v1 移植的 secret 筛查、64KB 正文上限、可选 `corrects` 指向被替代的同工作区 active 记忆）后在一个事务内落盘。`memory_read` 按 id 取正文、按关键词检索——空格分隔的关键词取 AND，短词与 trigram 未命中时回退字面子串匹配；注入索引只有钩子。按 id 取到的每份记忆正文计一次查阅（与技能同纪律的存在心跳）。`skill_write`（项目内 create/update/delete + 显式搬到全局）沉淀可复用的操作规程，走同一套纪律（短横线 id、secret 筛查、64KB 上限、跨范围禁重名重文）；每条落地的技能由插件代码物化为 `<workspace>/.agents/skills/<id>/SKILL.md`——库是唯一真相，文件是只读投影，漂移由巡检按库还原。`skill_read` 按 id 取技能正文、检索项目与全局技能（同名时项目遮蔽全局）；按 id 取到的每份正文计一次查阅（查阅次数 + 上次查阅，卡片展示）。这是存在心跳——只证明被翻过，不证明有用：长期零查阅是删除候选，剪枝拍板仍需人工。宿主没有工具服务时降级为告诉用户措辞，注入不受影响。
 3. **提案制提取** —— 轨迹到记忆的自动化，全程 `extraction_log` 可对账：每个 `agent/turn-stopping` 调度**该会话自己**的边界，状态按会话隔离（运行中只保留最新边界——合并而非排队；`compaction/start` 与会话收尾触发 drain），**没有空闲计时器**。一次运行读取该会话游标之后的轨迹增量，用 FTS 取相似既有记忆喂给一次 LLM 调用，模型的结构化提案过同一套门禁落盘；失败与被拒不推游标，下次触发重试。贵调用之前先过一道便宜预检门（增量前 4KB + 归属三测，小 verdict）：拒了直接按 model-skip 消费游标，不烧全量 prompt；门不清不楚就透传给贵调用——最差退化成老单调用，永不 stall。贵用量与门用量分 `usage` / `cheap_usage` 两列记账；门自己挂了按 fail-open 透传，错误原文留在同一行的 `cheap_error`——门死了与门不存在可区分。内部 agent、空增量、无真实用户文本的轮次、当轮已有显式 `memory_write` 的轮次机械跳过——每次跳过都记账，同一会话连续的空转轮次合成一行并累计唤醒次数。
 4. **内容质量自进化环** —— 第二条后台自动化，与提取在结构上独立（自有提示词、自有日预算、自有 `review_log` 账本、无游标；只共享库的写门）：便宜门模型先判某条记忆/技能值不值得细看，批了才跑贵改写，按内容质量打分（记忆：归属 + 准确/可用/可复用/不重复/不过时五维；技能：归属 + 触发精度/可执行完备/不重复三维，其中「可复用」按分区判——项目分区技能只按该项目内跨任务可用判，跨项目可用只对全局分区技能判，绑定本仓库路径/门禁的项目技能不算缺陷）并给出改写提案。四个评审岗位（记忆/技能 × 门/昂贵门）从同一张子代理定义表各装自己的说明书——一份提示词服务不了两者：记忆要求抹掉仓库名仍成立，项目技能本来就该绑仓库。同一套归属三测（主语是用户/环境还是某仓库的某版机制、去名后还成立吗、仓库事实住 ADR/docs）也守在提取 prompt 门口，版本细节从源头就不进记忆；评审调用失败记错误原文，不记秃码，并连同它跑在哪个模型、已烧掉多少 token 一并落账；门自身预算取自模型自己广告的输出上限而非固定值——截断前已完成解析的 verdict 仍算数，而一条 verdict 都没产出的调用（路由故障、预算截断）不让条目记为已评审，而是留队重试。新写即审、存量走有界积压队列排空、长期未动 30 天回炉。两条硬保证框住自动化：删除永不自动落盘（只有改写与隔离——隔离隐藏不删），超幅改写自动转隔离。日上限默认 100 条（新写 > 被纠正牵连 > 陈旧 > 抽查，尾部丢弃不滚雪球）框住 token 开销；每条终态落一行 `item-review` verdict 行、每天合一行日 rollup（预算 vs 实审 vs 积压 vs 丢弃，token 按便宜/贵分账），方便以后复盘。默认试运行（`review.dryRun` 开）：只记 verdict 不落盘，且未落盘的拟改稿全文随行进 `proposed` 列——试运行要看的是「改成什么样」，不只是「为什么改」。
-5. **回滚靠账本，不靠机制** —— 每次变更落一条带 before/after 全文快照的 `extraction_log` 行；undo 就是取 before 重写。技能变更同样落 `skill_log`，评审 verdict 落 `review_log`。每次应用后随跑一次巡检：孤儿 FTS 行清除、含密钥条目隔离（隐藏，不物理删除；被隔离技能的物化文件一并撤下，使其不再被加载）。只读卡片显形巡检异常。
+5. **回滚靠账本，不靠机制** —— 每次变更落一条带 before/after 全文快照的 `extraction_log` 行；undo 就是取 before 重写。技能变更同样落 `skill_log`，评审 verdict 落 `review_log`。每次应用后随跑一次巡检：孤儿 FTS 行清除、含密钥条目隔离（隐藏，不物理删除；被隔离技能的物化文件一并撤下，使其不再被加载）。只读卡片显形巡检异常。插件诊断另有自己的 durable 家：宿主 logger 开箱没有 exporter，因此诊断只落 `plugin_log`，不再镜像宿主 logger；四张账本共用一个 30 天窗口裁剪，触发点是 store 就绪、写日志与提取后的巡检，按 UTC 日节流。
 6. **只读卡片** —— 挂在官方插件管理的本 bundle 页面（`plugins.bundle.config` slot，老宿主自动降级为无卡片）：形态对齐市场自家设置卡，内容对齐 ZCode 设置的记忆选项卡——下拉作用域选择器列出库里的工作区分区（默认选中宿主当前工作区）、搜索框、每条记忆的相对更新时间、点击行内展开正文预览（5 MiB 上限）、巡检异常警告，以及技能区（本工作区技能 + 可见的全局技能，全局行打标记，同名时项目遮蔽全局），预览同记忆，每行显示查阅次数。显示名与描述走宿主 `locale/*.json` 通道双语；宿主主题 token、`Button` 原语、中英文案跟随 DSH 语言。卡片是数据库的请求时投影，没有编辑路径。
 
 记忆类型沿 ZCode 分类法：`user`（画像与环境事实）、`feedback`（被纠正/确认的做法——正文必带 **Why:** 与 **How to apply:**）、`reference`（资源指针）。提取边界只收"跟人与环境走的知识"：决策与取舍天然属于仓库，走仓库的 ADR 路线，不进记忆库。
@@ -95,9 +95,12 @@ pnpm check:pack              # 发布产物一致性（prepack 也会跑）
 │   ├── store.ts            # 中央 SQLite 库：DDL/WAL/FTS、读面、账本、巡检、游标
 │   ├── store-apply.ts      # 唯一写门：全量校验、事务原子应用、账本
 │   ├── token-usage.ts      # 统一记账口：归一各家用量、纯累加
+│   ├── plugin-log.ts       # 插件自有日志：只写库表（宿主 logger 无承接方）
+│   ├── retention.ts        # 账本保留期：30 天窗口 + 按日节流的裁剪触发
 │   ├── llm-call.ts         # 唯一传输层：路由、推理档位、输出预算、失败事实
 │   ├── subagent.ts         # 所有 LLM 调用经过的装载器（装配 → 调用 → 解析 → 记账）
 │   ├── subagent-defs.ts    # 子代理定义表：提示词、预算兜底、应答解析器，一处声明
+│   ├── prompt-date.ts      # 提示词的时钟：本轮基准日 + 那行「今天」指令
 │   ├── chain.ts            # 责任链：一环节一步，顺序由环境类组装
 │   ├── review-candidates.ts # 评审队列：什么该审（新写 > 被纠正牵连 > 陈旧）
 │   ├── review.ts           # 内容质量自进化：批量、预算、日 rollup、调度
@@ -120,7 +123,7 @@ pnpm check:pack              # 发布产物一致性（prepack 也会跑）
 ├── client/
 │   └── client.js          # 手写 client bundle：官方插件管理内只读卡片
 ├── locale/                # 宿主包元数据：显示名 + 描述双语（zh/en）
-├── test/                  # vitest 测试（28 个文件）
+├── test/                  # vitest 测试（29 个文件）
 ├── lib/                   # 构建产物（tsc）
 ├── docs/                  # design.md（设计）· FAQ.md（踩坑）
 └── .agents/               # AI 协作层（AGENTS.md、技能、ADR 笔记）

package/lib/extraction-ring.js

@@ -12,6 +12,8 @@ import { runChain } from "./chain.js";
 import { observedUsageOf } from "./llm-call.js";
 import { boundaryCursorOf, eventsAfterCursor, evaluateSlice, seqOfCursor, serializeIncrement } from "./extraction-surface.js";
 import { CHEAP_INCREMENT_MAX, cheapPrompt, extractionPrompt, manifestLineOf } from "./extraction-prompt.js";
+import { todayUtc } from "./prompt-date.js";
+import { pruneIfDue } from "./retention.js";
 import { extractionGate, extractionMain } from "./subagent-defs.js";
 import { cutFailureOf, subagentLoaderFor } from "./subagent.js";
 /** Head length of a failed run's raw answer kept in the ledger `files` column. */
@@ -58,7 +60,7 @@ export async function runExtractionInner(deps, target, opts) {
     // Narrowed once, here: the loader takes one concrete route and session.
     const workspaceId = target.workspaceId;
     const route = { provider: target.provider, model: target.model };
-    const call = { llm: deps.llm, route, sessionId: target.sessionId };
+    const call = { llm: deps.llm, route, sessionId: target.sessionId, today: opts.today ?? todayUtc() };
     const cursor = store.cursor(workspaceId, target.sessionId);
     let all;
     try {
@@ -272,6 +274,10 @@ function proposeLink() {
             // leakage quarantined — never a separate scheduler.
             const patrol = store.patrol();
             void patrol;
+            // Retention rides the same run: the ledgers only grow, and an
+            // applied extraction is what writes most of their rows. Day-throttled
+            // inside, so this is one state read on all but the day's first run.
+            pruneIfDue(store);
             item.result = { status: "applied", applied: outcomes.filter((outcome) => outcome.ok).length, cursor: item.boundarySeq };
             return "handled";
         },

package/lib/extraction.d.ts

@@ -1,6 +1,7 @@
 import { type SkipReason, type SurfaceReader } from "./extraction-surface.js";
 import type { LedgerEntry, MemoryStore } from "./store.js";
 import { type LlmRuntime, type RouteResolver } from "./llm-call.js";
+import type { PluginLog } from "./plugin-log.js";
 export type { LlmStream, LlmRuntime, RouteResolver } from "./llm-call.js";
 /** Everything a run needs: the store, the session reader, and the LLM. */
 export interface ExtractionDeps {
@@ -36,6 +37,8 @@ export interface RunOptions {
     trigger: LedgerEntry["trigger"];
     /** Character ceiling for the serialized increment (default 40000). */
     incrementMaxChars?: number;
+    /** Baseline day `YYYY-MM-DD` (UTC) the prompts judge dates by; defaults to the run's wall clock. */
+    today?: string | undefined;
 }
 /**
  * Run one extraction pass for a target. Never throws unless the ledger
@@ -48,10 +51,8 @@ export declare function runExtraction(deps: ExtractionDeps, target: ExtractionTa
 /** The event wiring surface (duck-typed cordis context). */
 export interface SchedulerHost {
     on(event: string, handler: (...args: never[]) => void): unknown;
-    logger(name: string): {
-        info(message: string): void;
-        warn(message: string): void;
-    };
+    /** The plugin's own log face: durable in the store, mirrored live. */
+    log: PluginLog;
 }
 /**
  * Wire the extraction triggers onto the host context. Returns a disposer

package/lib/extraction.js

@@ -127,7 +127,7 @@ export function createExtractionScheduler(host, deps) {
             catch {
                 // The ledger is down — the warn below is the last resort.
             }
-            host.logger("continual-evolve").warn(`extraction run failed unexpectedly: ${message}`);
+            host.log.warn("extraction-unexpected", `run failed unexpectedly: ${message}`, { sessionId });
         }).finally(() => {
             slot.running = false;
             if (slot.pending !== null) {
@@ -186,7 +186,7 @@ export function createExtractionScheduler(host, deps) {
         // its own reference and simply finds nothing left to drain.
         slots.delete(id);
     }));
-    host.logger("continual-evolve").info("extraction scheduler armed (per-session slots, turn-level, single-flight per session)");
+    host.log.info("extraction-armed", "scheduler armed (per-session slots, turn-level, single-flight per session)");
     return () => {
         slots.clear();
         for (const listener of listeners) {

package/lib/index.d.ts

@@ -43,10 +43,6 @@ interface HostContext {
             text: string | ((context: SectionContext) => string);
         }): void;
     };
-    logger(name: string): {
-        info(message: string): void;
-        warn(message: string): void;
-    };
 }
 export declare const Config: z<Schemastery.ObjectS<NoInfer<{
     /**

package/lib/index.js

@@ -38,6 +38,8 @@ import { registerMemoryTools } from "./memory-tools.js";
 import { registerSkillTools } from "./skill-tools.js";
 import { importWorkspaceMd } from "./import-md.js";
 import { openMemoryStore } from "./store.js";
+import { createPluginLog } from "./plugin-log.js";
+import { pruneIfDue } from "./retention.js";
 import { newestRegistryPath } from "./workspace-hint.js";
 export const name = "continual-evolve";
 export const inject = ["systemPrompt"];
@@ -117,23 +119,23 @@ function registerSchedulerDisposer(scoped, dispose) {
     }
 }
 /** Register the memory tools through a nested inject (see memory-tools.ts). */
-function mountToolsWhenAvailable(host, store, state) {
+function mountToolsWhenAvailable(host, store, state, log) {
     const nested = host;
     if (typeof nested.inject !== "function") {
-        host.logger("continual-evolve").warn("host context exposes no inject — memory tools not registered (injection unaffected; explicit memory management falls back to telling the user)");
+        log.warn("tools-not-mounted", "host context exposes no inject — memory tools not registered (injection unaffected; explicit memory management falls back to telling the user)");
         return;
     }
     nested.inject(["tools"], (scoped) => {
         const tools = scoped.tools;
         if (tools === undefined || typeof tools.register !== "function") {
-            host.logger("continual-evolve").warn("tools service present but empty — memory tools not registered (injection unaffected)");
+            log.warn("tools-empty", "tools service present but empty — memory tools not registered (injection unaffected)");
             return;
         }
         registerMemoryTools(tools, store);
         registerSkillTools(tools, store);
         state.toolsAvailable = true;
-        host.logger("continual-evolve").info("memory_write and memory_read registered");
-        host.logger("continual-evolve").info("skill_write and skill_read registered");
+        log.info("memory-tools-registered", "memory_write and memory_read registered");
+        log.info("skill-tools-registered", "skill_write and skill_read registered");
     });
 }
 /**
@@ -143,28 +145,29 @@ function mountToolsWhenAvailable(host, store, state) {
  * without either service (or without `.on`) simply never arms — injection
  * and the explicit tools remain functional.
  */
-function mountExtractionWhenAvailable(host, store, config) {
-    const log = host.logger("continual-evolve");
+function mountExtractionWhenAvailable(host, store, config, log) {
     if (config.memoryIndex?.extraction === false) {
-        log.info("extraction disabled by config — injection and memory_write remain active");
+        log.info("extraction-disabled", "extraction disabled by config — injection and memory_write remain active");
         return;
     }
     const nested = host;
     const events = host;
-    if (typeof nested.inject !== "function" || typeof events.on !== "function") {
-        log.warn("host context exposes no inject/on — extraction not armed (injection and tools unaffected)");
+    const on = events.on;
+    if (typeof nested.inject !== "function" || typeof on !== "function") {
+        log.warn("extraction-not-armed", "host context exposes no inject/on — extraction not armed (injection and tools unaffected)");
         return;
     }
+    const schedulerHost = { on: (event, handler) => on.call(events, event, handler), log };
     nested.inject(["sessionQuery", "llm"], (scoped) => {
         const context = scoped;
         const surface = context.sessionQuery;
         const llm = (context.llm ?? context.get?.("llm"));
         if (surface === undefined || typeof surface.readSurface !== "function") {
-            log.warn("sessionQuery service present but empty — extraction not armed (injection and tools unaffected)");
+            log.warn("extraction-no-surface", "sessionQuery service present but empty — extraction not armed (injection and tools unaffected)");
             return;
         }
         const resolveRoute = routeResolverOf(scoped, context.get);
-        registerSchedulerDisposer(scoped, createExtractionScheduler(events, {
+        registerSchedulerDisposer(scoped, createExtractionScheduler(schedulerHost, {
             store, surface, llm,
             ...(resolveRoute === undefined ? {} : { resolveRoute }),
         }));
@@ -176,23 +179,24 @@ function mountExtractionWhenAvailable(host, store, config) {
  * increments), so it mounts independently from extraction. Own prompts, own
  * budget, own ledger; the store's write gates are the only shared surface.
  */
-function mountReviewWhenAvailable(host, store, config) {
-    const log = host.logger("continual-evolve");
+function mountReviewWhenAvailable(host, store, config, log) {
     if (config.review?.enabled?.get() === false) {
-        log.info("review disabled by config — extraction and tools unaffected");
+        log.info("review-disabled", "review disabled by config — extraction and tools unaffected");
         return;
     }
     const nested = host;
     const events = host;
-    if (typeof nested.inject !== "function" || typeof events.on !== "function") {
-        log.warn("host context exposes no inject/on — review not armed (injection and tools unaffected)");
+    const on = events.on;
+    if (typeof nested.inject !== "function" || typeof on !== "function") {
+        log.warn("review-not-armed", "host context exposes no inject/on — review not armed (injection and tools unaffected)");
         return;
     }
+    const schedulerHost = { on: (event, handler) => on.call(events, event, handler), log };
     nested.inject(["llm"], (scoped) => {
         const context = scoped;
         const llm = (context.llm ?? context.get?.("llm"));
         const resolveRoute = routeResolverOf(scoped, context.get);
-        registerSchedulerDisposer(scoped, createReviewScheduler(events, {
+        registerSchedulerDisposer(scoped, createReviewScheduler(schedulerHost, {
             store, llm,
             ...(resolveRoute === undefined ? {} : { resolveRoute }),
         }, {
@@ -216,17 +220,17 @@ function mountReviewWhenAvailable(host, store, config) {
  * `ctx.get` on every request (the FAQ #2 sibling-service rule — the service is
  * optional, so it must not join the inject list, which would gate the mount).
  */
-function mountCardWhenAvailable(host, store) {
+function mountCardWhenAvailable(host, store, log) {
     const nested = host;
     if (typeof nested.inject !== "function") {
-        host.logger("continual-evolve").warn("host context exposes no inject — memory card routes not mounted (memory section unaffected)");
+        log.warn("card-not-mounted", "host context exposes no inject — memory card routes not mounted (memory section unaffected)");
         return;
     }
     nested.inject(["webServer"], (scoped) => {
         const context = scoped;
         const webServer = context.webServer;
         if (webServer === undefined) {
-            host.logger("continual-evolve").warn("webServer service present but empty — memory card routes not mounted (memory section unaffected)");
+            log.warn("card-empty-server", "webServer service present but empty — memory card routes not mounted (memory section unaffected)");
             return;
         }
         mountCardRoutes(webServer, store, {
@@ -238,20 +242,32 @@ export function apply(host, config) {
     if (config.memoryIndex?.enabled === false) {
         return;
     }
-    const log = host.logger("continual-evolve");
     const state = { store: undefined, toolsAvailable: false };
+    // One log face for the whole plugin, writing to the store once it is open.
+    // Created before the store exists: the early mounts and the failure path
+    // below call it, and lines written before readiness are dropped.
+    const log = createPluginLog(() => state.store);
     void openMemoryStore().then((store) => {
         state.store = store;
-        mountToolsWhenAvailable(host, store, state);
-        mountExtractionWhenAvailable(host, store, config);
-        mountReviewWhenAvailable(host, store, config);
+        // Retention has no scheduler: the day-throttled check rides mount and
+        // every log write, so the ledgers stay bounded in a long-lived process.
+        try {
+            pruneIfDue(store);
+        }
+        catch (error) {
+            log.warn("prune-failed", `ledger retention skipped: ${error instanceof Error ? error.message : String(error)}`);
+        }
+        mountToolsWhenAvailable(host, store, state, log);
+        mountExtractionWhenAvailable(host, store, config, log);
+        mountReviewWhenAvailable(host, store, config, log);
         if (config.memoryCard?.enabled !== false) {
-            mountCardWhenAvailable(host, store);
+            mountCardWhenAvailable(host, store, log);
         }
-    }, (error) => {
-        // node:sqlite missing (old runtime) or the database unusable:
-        // degrade to a no-op plugin, never take the host down.
-        log.warn(`memory store unavailable — injection and tools disabled: ${error instanceof Error ? error.message : String(error)}`);
+    }, (_error) => {
+        // node:sqlite missing (old runtime) or the database unusable: degrade
+        // to a no-op plugin, never take the host down. Nothing is logged: the
+        // store is this plugin's only log home, and it is the thing that just
+        // failed — the host's logger has no sink to fall back on.
     });
     const frozen = createFrozenMemorySection();
     host.systemPrompt.section({
@@ -272,7 +288,7 @@ export function apply(host, config) {
                     importWorkspaceMd(store, cwd);
                 }
                 catch (error) {
-                    log.warn(`legacy memory import failed for ${cwd}: ${error instanceof Error ? error.message : String(error)}`);
+                    log.warn("md-import-failed", `legacy memory import failed for ${cwd}: ${error instanceof Error ? error.message : String(error)}`, { workspaceId: cwd });
                 }
             }
             return frozen.textFor(context.agent, (agent) => memorySectionText(agent, {
@@ -283,6 +299,6 @@ export function apply(host, config) {
             }));
         },
     });
-    log.info("continual-evolve memory section registered (central SQLite store, sole-writer gates)");
+    log.info("section-registered", "continual-evolve memory section registered (central SQLite store, sole-writer gates)");
 }
 //# sourceMappingURL=index.js.map

package/lib/plugin-log.d.ts

@@ -0,0 +1,21 @@
+import type { MemoryStore } from "./store.js";
+/** The partition a line belongs to, when the call site knows one. */
+export interface LogWhere {
+    workspaceId?: string | undefined;
+    sessionId?: string | undefined;
+}
+/** The log face feature code holds: durable in the store, nothing else. */
+export interface PluginLog {
+    info(event: string, message: string, where?: LogWhere): void;
+    warn(event: string, message: string, where?: LogWhere): void;
+    error(event: string, message: string, where?: LogWhere): void;
+}
+/**
+ * Bind a log face to one store accessor.
+ *
+ * @param storeOf - Reads the store each call: the sink outlives store startup,
+ *   and a host whose store never opened has nowhere to write.
+ * @returns The log face feature code calls.
+ */
+export declare function createPluginLog(storeOf: () => MemoryStore | undefined): PluginLog;
+//# sourceMappingURL=plugin-log.d.ts.map

package/lib/plugin-log.js

@@ -0,0 +1,42 @@
+/**
+ * The plugin's log face: one call writes one durable row.
+ *
+ * The host's logger is not a channel this plugin uses. A stock host attaches no
+ * exporter to it (docs/FAQ.md #4), so it can never be the home of a fact worth
+ * re-reading — and the sink belongs to the user's environment, which the plugin
+ * does not control. The store is the only home, which also means a diagnostic
+ * written while the store is unavailable is dropped: this face never throws,
+ * because a log line that can take a session down costs more than a lost line.
+ */
+import { pruneIfDue } from "./retention.js";
+/**
+ * Bind a log face to one store accessor.
+ *
+ * @param storeOf - Reads the store each call: the sink outlives store startup,
+ *   and a host whose store never opened has nowhere to write.
+ * @returns The log face feature code calls.
+ */
+export function createPluginLog(storeOf) {
+    const write = (level, event, message, where) => {
+        const store = storeOf();
+        if (store === undefined) {
+            return;
+        }
+        try {
+            store.logPlugin({ level, event, message, ...where });
+            // Retention rides the writes: the log is the one table written
+            // without a scheduler of its own, so it prunes itself.
+            pruneIfDue(store);
+        }
+        catch {
+            // Swallowed by design: the durable write and its prune are
+            // best-effort, and there is no second channel to fall back to.
+        }
+    };
+    return {
+        info: (event, message, where) => write("info", event, message, where),
+        warn: (event, message, where) => write("warn", event, message, where),
+        error: (event, message, where) => write("error", event, message, where),
+    };
+}
+//# sourceMappingURL=plugin-log.js.map

package/lib/prompt-date.d.ts

@@ -0,0 +1,33 @@
+/**
+ * The clock every prompt is anchored to: the run's baseline day and the line
+ * that hands it to the model.
+ *
+ * The model has no clock of its own. A direct LLM call carries an instruction
+ * and a user prompt and nothing else — no runtime context, no timestamps — so
+ * "is this date in the future?" is answered from the model's own prior unless
+ * the caller says otherwise. A run resolves its day once at the boundary and
+ * carries it as data, so a replay and a live run see the same prompts.
+ */
+/**
+ * The current UTC day `YYYY-MM-DD`.
+ *
+ * UTC is the plugin's unit: the review account's day uses the same value, so
+ * one run cannot straddle two dates.
+ *
+ * @returns Today's date in UTC.
+ */
+export declare function todayUtc(): string;
+/**
+ * The date-baseline line appended to the instruction of a job that makes
+ * time-relative judgments.
+ *
+ * It names the day *and* says which side of it is a defect, because the rule
+ * being protected is "no future dates", not "never touch dates": the 2026-10-14
+ * trial produced 8 of 13 rewrite verdicts that stripped correct past dates as
+ * if they were future ones.
+ *
+ * @param today - The run's baseline day `YYYY-MM-DD` (UTC).
+ * @returns The instruction line to append to a system prompt.
+ */
+export declare function dateBaseline(today: string): string;
+//# sourceMappingURL=prompt-date.d.ts.map

package/lib/prompt-date.js

@@ -0,0 +1,37 @@
+/**
+ * The clock every prompt is anchored to: the run's baseline day and the line
+ * that hands it to the model.
+ *
+ * The model has no clock of its own. A direct LLM call carries an instruction
+ * and a user prompt and nothing else — no runtime context, no timestamps — so
+ * "is this date in the future?" is answered from the model's own prior unless
+ * the caller says otherwise. A run resolves its day once at the boundary and
+ * carries it as data, so a replay and a live run see the same prompts.
+ */
+/**
+ * The current UTC day `YYYY-MM-DD`.
+ *
+ * UTC is the plugin's unit: the review account's day uses the same value, so
+ * one run cannot straddle two dates.
+ *
+ * @returns Today's date in UTC.
+ */
+export function todayUtc() {
+    return new Date().toISOString().slice(0, 10);
+}
+/**
+ * The date-baseline line appended to the instruction of a job that makes
+ * time-relative judgments.
+ *
+ * It names the day *and* says which side of it is a defect, because the rule
+ * being protected is "no future dates", not "never touch dates": the 2026-10-14
+ * trial produced 8 of 13 rewrite verdicts that stripped correct past dates as
+ * if they were future ones.
+ *
+ * @param today - The run's baseline day `YYYY-MM-DD` (UTC).
+ * @returns The instruction line to append to a system prompt.
+ */
+export function dateBaseline(today) {
+    return `时间基准：今天是 ${today}（UTC）。正文里早于或等于今天的日期是按期发生的过去事实，不是缺陷、不要据此改写；只有晚于今天的日期才算「未来日期」错误。把相对日期（如"周四"）折算成绝对日期时，以今天为参照。`;
+}
+//# sourceMappingURL=prompt-date.js.map

package/lib/retention.d.ts

@@ -0,0 +1,23 @@
+/**
+ * How long the plugin keeps its own ledgers, and when it prunes them.
+ *
+ * `MemoryStore.pruneLedger` shipped with no production caller, so "the ledgers
+ * are pruned" was true of the API and false of the machine (2026-10-14 real
+ * store: 547 extraction rows in 9 days, 115 review rows in 3). Retention is a
+ * policy with a trigger, and the trigger is the part that was missing.
+ *
+ * The check is day-throttled and idempotent, so every writer can call it
+ * cheaply and a long-running process prunes without a scheduler of its own.
+ */
+import { type MemoryStore } from "./store.js";
+/** Rows older than this many days are pruned. */
+export declare const LEDGER_RETENTION_DAYS = 30;
+/**
+ * Prune the ledgers and the plugin log when this UTC day has not been pruned.
+ *
+ * @param store - The store to prune.
+ * @param now - The instant to judge by (defaults to the wall clock; tests pass one).
+ * @returns Rows removed, or 0 when today's prune already ran.
+ */
+export declare function pruneIfDue(store: MemoryStore, now?: Date): number;
+//# sourceMappingURL=retention.d.ts.map

package/lib/retention.js

@@ -0,0 +1,34 @@
+/**
+ * How long the plugin keeps its own ledgers, and when it prunes them.
+ *
+ * `MemoryStore.pruneLedger` shipped with no production caller, so "the ledgers
+ * are pruned" was true of the API and false of the machine (2026-10-14 real
+ * store: 547 extraction rows in 9 days, 115 review rows in 3). Retention is a
+ * policy with a trigger, and the trigger is the part that was missing.
+ *
+ * The check is day-throttled and idempotent, so every writer can call it
+ * cheaply and a long-running process prunes without a scheduler of its own.
+ */
+import { GLOBAL_WORKSPACE } from "./store.js";
+/** Rows older than this many days are pruned. */
+export const LEDGER_RETENTION_DAYS = 30;
+/** The state key holding the UTC day of the last prune. */
+const PRUNE_STATE_KEY = "prune:last";
+/**
+ * Prune the ledgers and the plugin log when this UTC day has not been pruned.
+ *
+ * @param store - The store to prune.
+ * @param now - The instant to judge by (defaults to the wall clock; tests pass one).
+ * @returns Rows removed, or 0 when today's prune already ran.
+ */
+export function pruneIfDue(store, now = new Date()) {
+    const day = now.toISOString().slice(0, 10);
+    if (store.state(GLOBAL_WORKSPACE, PRUNE_STATE_KEY) === day) {
+        return 0;
+    }
+    const cutoff = new Date(now.getTime() - LEDGER_RETENTION_DAYS * 24 * 60 * 60 * 1000).toISOString();
+    const removed = store.pruneLedger(cutoff);
+    store.setState(GLOBAL_WORKSPACE, PRUNE_STATE_KEY, day);
+    return removed;
+}
+//# sourceMappingURL=retention.js.map

package/lib/review.d.ts

@@ -1,4 +1,5 @@
 import { type LlmRuntime, type RouteResolver } from "./llm-call.js";
+import type { PluginLog } from "./plugin-log.js";
 import type { MemoryStore } from "./store.js";
 /** The LLM face review calls, aliased so each scheduler can name its own. */
 export type ReviewLlm = LlmRuntime;
@@ -27,7 +28,7 @@ export interface ReviewCandidate {
     scope?: "project" | "global" | undefined;
 }
 export interface ReviewRunOptions {
-    /** UTC day `YYYY-MM-DD` the hard cap accounts against. */
+    /** UTC day `YYYY-MM-DD` the hard cap accounts against — also the clock the prompts judge dates by. */
     day: string;
     /** Hard cap for the day (100). Candidates past it count as dropped. */
     budget: number;
@@ -64,15 +65,11 @@ export declare const REVIEW_DEFAULT_STALE_DAYS = 30;
  * run keeps going), exactly like extraction's fail-ledgered discipline.
  */
 export declare function runReviewBatch(deps: ReviewDeps, candidates: readonly ReviewCandidate[], opts: ReviewRunOptions): Promise<ReviewRunSummary>;
-/** Current UTC day `YYYY-MM-DD` for the hard-cap account. */
-export declare function todayUtc(): string;
 /** The event wiring surface (duck-typed cordis context, mirrors extraction). */
 export interface ReviewSchedulerHost {
     on(event: string, handler: (...args: never[]) => void): unknown;
-    logger(name: string): {
-        info(message: string): void;
-        warn(message: string): void;
-    };
+    /** The plugin's own log face: durable in the store, mirrored live. */
+    log: PluginLog;
 }
 /** The editable review settings, re-read on every drain. */
 export interface ReviewSettings {

package/lib/review.js

@@ -20,8 +20,9 @@
 import { runChain } from "./chain.js";
 import { resolveCallRoute } from "./llm-call.js";
 import { cwdOf } from "./memory-section.js";
+import { todayUtc } from "./prompt-date.js";
 import { collectCandidates } from "./review-candidates.js";
-import { reviewChain } from "./review-ring.js";
+import { failureHead, reviewChain } from "./review-ring.js";
 import { subagentLoaderFor } from "./subagent.js";
 import { zeroUsage } from "./token-usage.js";
 /** Defaults for the review settings the host may override — and edit live. */
@@ -49,59 +50,85 @@ export async function runReviewBatch(deps, candidates, opts) {
     const llm = deps.llm;
     // The environment class: one loader and one chain for the whole run, in the
     // order the ring declares. Without a route there is no ring to walk.
-    const ring = route === undefined || llm === undefined ? undefined : assembleRing({ llm, route, sessionId: opts.sessionId });
+    const ring = route === undefined || llm === undefined ? undefined : assembleRing({ llm, route, sessionId: opts.sessionId, today: opts.day });
     let position = 0;
-    for (const candidate of batch) {
-        const remaining = deps.store.consumeReviewBudget(opts.day, opts.budget);
-        if (remaining < 0) {
-            // Hard cap hit: this item and everything after it drops (low
-            // priority never rolls over — it simply waits for a future run).
-            summary.dropped += batch.length - position;
-            for (const item of batch.slice(position)) {
+    // The run's account is written whatever happens to the loop: a fault that
+    // escapes one item (or the loop itself) is rethrown *after* the rollup is
+    // merged, so a dead run can never leave `reviewed` incremented with every
+    // other counter at zero and nothing saying why (2026-10-14 incident).
+    let escaped;
+    let failed = false;
+    try {
+        for (const candidate of batch) {
+            try {
+                const remaining = deps.store.consumeReviewBudget(opts.day, opts.budget);
+                if (remaining < 0) {
+                    // Hard cap hit: this item and everything after it drops (low
+                    // priority never rolls over — it simply waits for a future run).
+                    summary.dropped += batch.length - position;
+                    for (const item of batch.slice(position)) {
+                        deps.store.logReview({
+                            runId, workspaceId: item.workspaceId, itemKind: item.kind, itemId: item.id,
+                            verdict: "skip", reason: "budget-exhausted", applied: 0,
+                        });
+                    }
+                    skipReasons.push("budget-exhausted");
+                    break;
+                }
+                summary.reviewed += 1;
+                if (candidate.priority === 0) {
+                    newItems += 1;
+                }
+                else {
+                    requeued += 1;
+                }
+                if (route === undefined || ring === undefined) {
+                    deps.store.logReview({
+                        runId, workspaceId: candidate.workspaceId, itemKind: candidate.kind, itemId: candidate.id,
+                        verdict: "skip", reason: "no-route", applied: 0,
+                    });
+                    skipReasons.push("no-route");
+                    position += 1;
+                    continue;
+                }
+                const item = {
+                    deps, loader: ring.loader, route, runId, candidate, opts, summary, skipReasons,
+                    gate: { usage: zeroUsage(), raw: undefined },
+                };
+                await runChain(ring.links, item);
+            }
+            catch (error) {
+                // A fault escaping the chain (a store write, a wiring bug) gets its
+                // own row carrying the error text and costs the batch only this
+                // item — the model-facing failures already degrade inside the ring.
                 deps.store.logReview({
-                    runId, workspaceId: item.workspaceId, itemKind: item.kind, itemId: item.id,
-                    verdict: "skip", reason: "budget-exhausted", applied: 0,
+                    runId, workspaceId: candidate.workspaceId, itemKind: candidate.kind, itemId: candidate.id,
+                    verdict: "skip", reason: `review-failed: ${failureHead(error)}`,
+                    model: route?.model, applied: 0,
                 });
+                skipReasons.push("review-failed");
             }
-            skipReasons.push("budget-exhausted");
-            break;
-        }
-        summary.reviewed += 1;
-        if (candidate.priority === 0) {
-            newItems += 1;
-        }
-        else {
-            requeued += 1;
-        }
-        if (route === undefined || ring === undefined) {
-            deps.store.logReview({
-                runId, workspaceId: candidate.workspaceId, itemKind: candidate.kind, itemId: candidate.id,
-                verdict: "skip", reason: "no-route", applied: 0,
-            });
-            skipReasons.push("no-route");
             position += 1;
-            continue;
         }
-        const item = {
-            deps, loader: ring.loader, route, runId, candidate, opts, summary, skipReasons,
-            gate: { usage: zeroUsage(), raw: undefined },
-        };
-        await runChain(ring.links, item);
-        position += 1;
     }
-    summary.backlog = Math.max(0, candidates.length - summary.reviewed - summary.dropped);
-    deps.store.mergeDaily(opts.day, opts.budget, {
-        newItems, requeued, approved: summary.approved, applied: summary.applied,
-        cheapToken: summary.cheapToken, evolveToken: summary.evolveToken,
-        backlog: summary.backlog, dropped: summary.dropped,
-        skipReasons: skipReasons.length > 0 ? skipReasons : undefined,
-    });
+    catch (error) {
+        failed = true;
+        escaped = error;
+    }
+    finally {
+        summary.backlog = Math.max(0, candidates.length - summary.reviewed - summary.dropped);
+        deps.store.mergeDaily(opts.day, opts.budget, {
+            newItems, requeued, approved: summary.approved, applied: summary.applied,
+            cheapToken: summary.cheapToken, evolveToken: summary.evolveToken,
+            backlog: summary.backlog, dropped: summary.dropped,
+            skipReasons: skipReasons.length > 0 ? skipReasons : undefined,
+        });
+    }
+    if (failed) {
+        throw escaped;
+    }
     return summary;
 }
-/** Current UTC day `YYYY-MM-DD` for the hard-cap account. */
-export function todayUtc() {
-    return new Date().toISOString().slice(0, 10);
-}
 /** Assemble one run's ring (simple factory: one context, one bound loader, one chain). */
 function assembleRing(call) {
     const loader = subagentLoaderFor(call);
@@ -140,26 +167,39 @@ export function createReviewScheduler(host, deps, config) {
         const workspace = triggerWorkspace ?? pendingWorkspace;
         pendingWorkspace = undefined;
         void (async () => {
+            const settings = config.read();
+            const day = todayUtc();
             try {
-                const settings = config.read();
-                const day = todayUtc();
                 const daily = deps.store.getDaily(day);
                 const remaining = settings.dailyBudget - (daily?.reviewed ?? 0);
                 if (remaining <= 0) {
+                    host.log.info("review-budget-spent", `drain skipped: daily budget spent (${daily?.reviewed ?? 0}/${settings.dailyBudget})`, { workspaceId: workspace });
                     return;
                 }
                 const candidates = collectCandidates(deps.store, { staleDays: settings.staleDays, limit: settings.batchSize * 2 });
                 const ordered = workspace === undefined
                     ? candidates
                     : [...candidates.filter((c) => c.workspaceId === workspace), ...candidates.filter((c) => c.workspaceId !== workspace)];
-                await runReviewBatch(deps, ordered.slice(0, settings.batchSize), {
+                const summary = await runReviewBatch(deps, ordered.slice(0, settings.batchSize), {
                     day, budget: settings.dailyBudget, dryRun: settings.dryRun,
                     batchSize: settings.batchSize, staleDays: settings.staleDays,
                     provider: lastRoute?.provider, model: lastRoute?.model, sessionId: lastRoute?.sessionId,
                 });
+                host.log.info("review-drain", `reviewed ${summary.reviewed}, approved ${summary.approved}, ` +
+                    `applied ${summary.applied}, dropped ${summary.dropped}, backlog ${summary.backlog}`, { workspaceId: workspace, sessionId: lastRoute?.sessionId });
             }
             catch (error) {
-                host.logger("continual-evolve").warn(`review drain failed: ${error instanceof Error ? error.message : String(error)}`);
+                const head = failureHead(error);
+                host.log.warn("review-drain-failed", head, { workspaceId: workspace, sessionId: lastRoute?.sessionId });
+                // Two records on purpose: the log is the live channel, the day's
+                // rollup is the durable one every later reading sees. A drain that
+                // died must leave a trace in the ledger, not only in a log row.
+                try {
+                    deps.store.mergeDaily(day, settings.dailyBudget, { skipReasons: [`drain-failed: ${head}`] });
+                }
+                catch (recordError) {
+                    host.log.warn("review-drain-unledgered", failureHead(recordError), { workspaceId: workspace });
+                }
             }
             finally {
                 running = false;
@@ -189,7 +229,7 @@ export function createReviewScheduler(host, deps, config) {
         drain(cwdOf(agent));
     }));
     const armed = config.read();
-    host.logger("continual-evolve").info(`review scheduler armed (daily cap ${armed.dailyBudget}, dry-run ${armed.dryRun ? "on" : "off"})`);
+    host.log.info("review-armed", `scheduler armed (daily cap ${armed.dailyBudget}, dry-run ${armed.dryRun ? "on" : "off"})`);
     return () => {
         pendingWorkspace = undefined;
         for (const listener of listeners) {

package/lib/store.d.ts

@@ -153,6 +153,21 @@ export interface LedgerEntry {
     /** Applied/attempted mutations: `{id, action, before?, after?, sourceSeqs}`; a parse-failed run instead carries the raw answer's head. */
     files?: unknown;
 }
+/** One plugin-log line: the level, a stable event slug, and the message. */
+export interface PluginLogEntry {
+    level: "info" | "warn" | "error";
+    /**
+     * The event's stable name (`drain-failed`, `card-no-webserver` …), so the
+     * table can be counted and grepped instead of read line by line.
+     */
+    event: string;
+    message: string;
+    /** The partition the line belongs to, when the call site knows one. */
+    workspaceId?: string | undefined;
+    sessionId?: string | undefined;
+}
+/** Longest message kept; a runaway error string must not become a table row. */
+export declare const PLUGIN_LOG_MESSAGE_MAX = 2000;
 /** Workspace rows the card's selector lists. */
 export interface WorkspaceSummary {
     workspaceId: string;
@@ -219,7 +234,12 @@ export interface MemoryStore {
     mostRecentlyActiveWorkspace(): string | undefined;
     /** Hygiene pass: orphan FTS cleanup + secret quarantine. */
     patrol(): PatrolResult;
-    /** Ledger rows older than the cutoff, removed (the one unbounded table). */
+    /**
+     * Append one plugin-log line — the durable home for plugin diagnostics,
+     * because the host's logger has no exporter on a stock install.
+     */
+    logPlugin(entry: PluginLogEntry): void;
+    /** Ledger and log rows older than the cutoff, removed (the unbounded tables). */
     pruneLedger(beforeIso: string): number;
     close(): void;
     /** One active skill row from a partition, undefined when absent. */

package/lib/store.js

@@ -162,7 +162,22 @@ CREATE TABLE IF NOT EXISTS review_daily (
   skip_top TEXT,
   skip_counts TEXT
 ) STRICT;
+-- The plugin's own log. A stock host attaches no exporter to its logger, so a
+-- ctx.logger call leaves no trace anywhere (docs/FAQ.md #4) — diagnostics that
+-- have no domain ledger row of their own land here instead. Pruned with the
+-- ledgers; the event column is a stable slug, so runs can be counted and grepped.
+CREATE TABLE IF NOT EXISTS plugin_log (
+  ts TEXT NOT NULL,
+  level TEXT NOT NULL CHECK (level IN ('info','warn','error')),
+  event TEXT NOT NULL,
+  message TEXT NOT NULL,
+  workspace_id TEXT,
+  session_id TEXT
+) STRICT;
+CREATE INDEX IF NOT EXISTS idx_plugin_log_ts ON plugin_log(ts);
 `;
+/** Longest message kept; a runaway error string must not become a table row. */
+export const PLUGIN_LOG_MESSAGE_MAX = 2000;
 /** Default database location: `$DSH_HOME/evolve/memory.db`, else `~/.dsh/…`. */
 export function defaultStorePath() {
     const home = process.env.DSH_HOME?.trim();
@@ -375,6 +390,8 @@ export async function openMemoryStore(explicitPath) {
         reviewLast: database.prepare(`SELECT ts, applied FROM review_log WHERE workspace_id IS ? AND item_kind = ? AND item_id = ? AND NOT ${INCOMPLETE_REVIEW_SQL} ORDER BY rowid DESC LIMIT 1`),
         reviewEvolved: database.prepare("SELECT COUNT(*) AS n FROM review_log WHERE workspace_id IS ? AND item_kind = ? AND item_id = ? AND applied = 1"),
         reviewPrune: database.prepare("DELETE FROM review_log WHERE ts < ?"),
+        pluginLog: database.prepare("INSERT INTO plugin_log (ts, level, event, message, workspace_id, session_id) VALUES (?, ?, ?, ?, ?, ?)"),
+        pluginLogPrune: database.prepare("DELETE FROM plugin_log WHERE ts < ?"),
         dailyGet: database.prepare("SELECT * FROM review_daily WHERE day = ?"),
         dailyUpsert: database.prepare("INSERT INTO review_daily (day, budget, reviewed, new_items, requeued, approved, applied, cheap_token, evolve_token, backlog, dropped, skip_top, skip_counts) " +
             "VALUES (?, ?, 0, 0, 0, 0, 0, 0, 0, 0, 0, NULL, NULL) " +
@@ -794,11 +811,15 @@ export async function openMemoryStore(explicitPath) {
             stmts.stateSet.run(GLOBAL_WORKSPACE, PATROL_STATE_KEY, JSON.stringify(result));
             return result;
         },
+        logPlugin(entry) {
+            stmts.pluginLog.run(new Date().toISOString(), entry.level, entry.event, entry.message.slice(0, PLUGIN_LOG_MESSAGE_MAX), entry.workspaceId ?? null, entry.sessionId ?? null);
+        },
         pruneLedger(beforeIso) {
             const memory = Number(stmts.prune.run(beforeIso).changes);
             const skills = Number(stmts.skillPrune.run(beforeIso).changes);
             const reviews = Number(stmts.reviewPrune.run(beforeIso).changes);
-            return memory + skills + reviews;
+            const logs = Number(stmts.pluginLogPrune.run(beforeIso).changes);
+            return memory + skills + reviews + logs;
         },
         close() {
             database.close();

package/lib/subagent-defs.js

@@ -12,6 +12,7 @@
  */
 import { EXTRACTION_CHEAP_SYSTEM_PROMPT, EXTRACTION_SYSTEM_PROMPT, parseCheapAnswer, parseExtractionAnswer, } from "./extraction-prompt.js";
 import { parseEvolveAnswer, parseGateAnswer, REVIEW_MEMORY_CHEAP_SYSTEM_PROMPT, REVIEW_MEMORY_SYSTEM_PROMPT, REVIEW_SKILL_CHEAP_SYSTEM_PROMPT, REVIEW_SKILL_SYSTEM_PROMPT, } from "./review-prompt.js";
+import { dateBaseline } from "./prompt-date.js";
 /**
  * Output-budget fallbacks, used only for adapters that advertise no
  * per-request cap of their own. A gate verdict is one JSON object plus the
@@ -21,45 +22,53 @@ import { parseEvolveAnswer, parseGateAnswer, REVIEW_MEMORY_CHEAP_SYSTEM_PROMPT,
 export const GATE_MAX_TOKENS = 1024;
 export const EVOLVE_MAX_TOKENS = 4096;
 export const EXTRACTION_MAX_TOKENS = 4096;
+/**
+ * Bind one instruction to the run's clock.
+ *
+ * Every job here reads item text that can name dates, and a direct call
+ * carries no clock of its own — so "today" is instruction, not data, and it
+ * arrives as the same appended line for every job in the ring.
+ */
+const withDateBaseline = (instruction) => (context) => `${instruction}\n\n${dateBaseline(context.today)}`;
 /** The memory cheap gate: is this entry worth a close look at all? */
 export const reviewGateMemory = {
     id: "review-gate-memory",
-    system: REVIEW_MEMORY_CHEAP_SYSTEM_PROMPT,
+    system: withDateBaseline(REVIEW_MEMORY_CHEAP_SYSTEM_PROMPT),
     maxTokens: GATE_MAX_TOKENS,
     parse: (text) => parseGateAnswer(text),
 };
 /** The skill cheap gate: same question, scope-relative home rules. */
 export const reviewGateSkill = {
     id: "review-gate-skill",
-    system: REVIEW_SKILL_CHEAP_SYSTEM_PROMPT,
+    system: withDateBaseline(REVIEW_SKILL_CHEAP_SYSTEM_PROMPT),
     maxTokens: GATE_MAX_TOKENS,
     parse: (text) => parseGateAnswer(text),
 };
 /** The memory evolve pass: five-dimension judgment plus the proposed rewrite. */
 export const reviewEvolveMemory = {
     id: "review-evolve-memory",
-    system: REVIEW_MEMORY_SYSTEM_PROMPT,
+    system: withDateBaseline(REVIEW_MEMORY_SYSTEM_PROMPT),
     maxTokens: EVOLVE_MAX_TOKENS,
     parse: (text) => parseEvolveAnswer(text),
 };
 /** The skill evolve pass: scope-relative reuse, executability, duplication. */
 export const reviewEvolveSkill = {
     id: "review-evolve-skill",
-    system: REVIEW_SKILL_SYSTEM_PROMPT,
+    system: withDateBaseline(REVIEW_SKILL_SYSTEM_PROMPT),
     maxTokens: EVOLVE_MAX_TOKENS,
     parse: (text) => parseEvolveAnswer(text),
 };
 /** The extraction pre-gate: does this increment hold anything worth proposing? */
 export const extractionGate = {
     id: "extraction-gate",
-    system: EXTRACTION_CHEAP_SYSTEM_PROMPT,
+    system: withDateBaseline(EXTRACTION_CHEAP_SYSTEM_PROMPT),
     maxTokens: GATE_MAX_TOKENS,
     parse: (text) => parseCheapAnswer(text),
 };
 /** The extraction proposal call: the run's one expensive call. */
 export const extractionMain = {
     id: "extraction-main",
-    system: EXTRACTION_SYSTEM_PROMPT,
+    system: withDateBaseline(EXTRACTION_SYSTEM_PROMPT),
     maxTokens: EXTRACTION_MAX_TOKENS,
     parse: (text) => parseExtractionAnswer(text),
 };

package/lib/subagent.d.ts

@@ -15,12 +15,22 @@
  * across call sites, and a job that has no definition cannot be called.
  */
 import { SubagentCallError, type LlmRuntime, type ModelSelection } from "./llm-call.js";
+/** The per-call facts a definition's instruction may be built from. */
+export interface SubagentContext {
+    /** The run's baseline day `YYYY-MM-DD` (UTC) — the clock time-relative judgments use. */
+    readonly today: string;
+}
 /** One subagent definition: everything that distinguishes one job from another. */
 export interface SubagentDefinition<Answer> {
     /** The job's name, for diagnostics; unique across the registry (asserted by test). */
     readonly id: string;
-    /** The job's entire instruction, sent as the system prompt — nothing is appended at the call site. */
-    readonly system: string;
+    /**
+     * The job's entire instruction, sent as the system prompt — nothing is
+     * appended at the call site. The builder form is for jobs whose
+     * instruction depends on a per-call fact (the clock a rubric judges dates
+     * against); the loader resolves it once per call.
+     */
+    readonly system: string | ((context: SubagentContext) => string);
     /** Output budget fallback; the exact model's advertised cap wins when it has one. */
     readonly maxTokens: number;
     /**
@@ -30,11 +40,13 @@ export interface SubagentDefinition<Answer> {
      */
     readonly parse: (text: string) => Answer;
 }
-/** What one call is bound to: the LLM service, the exact route, the session identity. */
+/** What one call is bound to: the LLM service, the exact route, the session identity, the day. */
 export interface SubagentCall {
     llm: LlmRuntime | undefined;
     route: ModelSelection;
     sessionId: string | undefined;
+    /** The run's baseline day `YYYY-MM-DD` (UTC): the clock every instruction is anchored to. */
+    today: string;
 }
 /** One finished call: the parsed answer, the raw text, and the observed call facts. */
 export interface SubagentAnswer<Answer> {
@@ -61,7 +73,7 @@ export interface SubagentLoader {
  * Build the loader for one call context — the simple factory: the context
  * produces the bound runner, the definitions table produces the strategies.
  *
- * @param call - The LLM service, the exact route, and the session identity to send.
+ * @param call - The LLM service, the exact route, the session identity, and the baseline day to send.
  * @returns A loader whose `run` is the only LLM entry point a feature needs.
  */
 export declare function subagentLoaderFor(call: SubagentCall): SubagentLoader;

package/lib/subagent.js

@@ -19,13 +19,14 @@ import { SubagentCallError, streamOnce } from "./llm-call.js";
  * Build the loader for one call context — the simple factory: the context
  * produces the bound runner, the definitions table produces the strategies.
  *
- * @param call - The LLM service, the exact route, and the session identity to send.
+ * @param call - The LLM service, the exact route, the session identity, and the baseline day to send.
  * @returns A loader whose `run` is the only LLM entry point a feature needs.
  */
 export function subagentLoaderFor(call) {
     return {
         async run(definition, prompt) {
-            const result = await streamOnce(call.llm, call.route, call.sessionId, definition.system, prompt, definition.maxTokens);
+            const system = typeof definition.system === "function" ? definition.system({ today: call.today }) : definition.system;
+            const result = await streamOnce(call.llm, call.route, call.sessionId, system, prompt, definition.maxTokens);
             return { answer: definition.parse(result.text), text: result.text, usage: result.usage, finish: result.finish };
         },
     };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-continual-evolve",
-  "version": "0.15.13",
+  "version": "0.15.15",
   "description": "ZCode-style workspace memory for DeepSeek Harness: one central SQLite store partitioned by workspace, index injection, and sole-writer gated writes.",
   "license": "MIT",
   "repository": {