@stardustlc/dsh-dream 0.8.0 → 0.9.0

package/CHANGELOG.md

@@ -4,6 +4,20 @@
 
 [历史英文记录](docs/CHANGELOG.en.md)
 
+## 0.9.0 (2026-10-05)
+
+- 安静 60 秒后整理，同项目/模型最多合并 4 轮；冷却与每日预算延后轮次，32 轮/24 小时的持久化队列支持重启恢复、取消保留和跨进程租约。
+- 每个聊天独立设置「使用记忆」与「贡献记忆」，可跟随全局或单独开启/关闭；关闭贡献清理该聊天待处理片段，保留已有经验。
+- 按项目和主题分组、勾选同范围无冲突候选，一次原子审阅最多 20 条。自动来源保留核对过的脱敏原话，方便审阅条件和例外。
+- 事实默认 30 天待复核，支持明确到期时间；取回、使用反馈不续期。过期经验在界面显示待复核，自动上下文与规则预览暂时扣下。
+- 不可变记忆快照与查询缓存按完整内容失效；同长度/同时间戳的文件中段变更、拒绝、到期及原子替换均不会继续使用旧结果。短摘要与来源目录可由事件重建。
+- 简化中英面板，详细设置默认折叠，审阅页直接展示经验。Windows、官方宿主、浏览器与真实模型的验证范围见 [0.9.0 验收](docs/validation/0.9.0.md)。
+
+## 0.8.1 (2026-10-04)
+
+- 修复真实 DeepSeek 辅助整理因深度推理耗尽 1200 token、JSON 被截断而无法保存候选的问题。通过官方模型元数据，仅对明确支持 `off` 的模型关闭这条辅助调用的推理；保留当前主任务设置及其他提供商的默认行为。
+- 模型元数据查询也受辅助整理的超时与取消约束；旧宿主或元数据不可用时保留原有调用方式。真实模型复测与限制见 [0.8.1 验收](docs/validation/0.8.1.md)。
+
 ## 0.8.0 (2026-10-04)
 
 - 对照官方 0.2.1-alpha.1 源码接入会话事件、Agent Inbox 与动态上下文：符合条件的任务收尾自动整理候选，后续相关任务自动回用已采纳、有独立来源的经验，无需记住触发词。候选始终待审阅，日记和项目规则仍是独立操作。

package/README.en.md

@@ -2,15 +2,19 @@
 
 [中文](README.md)
 
+![dsh-dream whale girl plugin cover](https://raw.githubusercontent.com/STARDUSTLC666/dsh-dream/master/assets/cover-whale-girl.png)
+
 Collect candidate lessons from completed tasks, review them and reuse relevant memories. Manual reflections remain available.
 
-[![npm](https://img.shields.io/npm/v/@stardustlc/dsh-dream)](https://www.npmjs.com/package/@stardustlc/dsh-dream) [![downloads](https://img.shields.io/npm/dm/@stardustlc/dsh-dream)](https://www.npmjs.com/package/@stardustlc/dsh-dream)
+[![npm](https://img.shields.io/npm/v/@stardustlc/dsh-dream)](https://www.npmjs.com/package/@stardustlc/dsh-dream) [![downloads](https://raw.githubusercontent.com/STARDUSTLC666/dsh-suite/npm-downloads/assets/dsh-dream-downloads.svg)](https://www.npmjs.com/package/@stardustlc/dsh-dream)
 
 ## What it does
 
 - Browse journals, retrieve lessons and inspect their sources.
 - Collect candidates after tasks and retrieve accepted memories for relevant tasks, with separate switches.
+- Consolidate after quiet time, retain turns during cooldown or quota limits, and control use and contribution per chat.
 - Review lessons, resolve conflicts and record separate usage feedback.
+- Review candidates by project/topic; pause expired facts until they are reviewed again.
 - Preview AGENTS.md changes before applying them, with rollback support.
 
 ## Install
@@ -27,7 +31,9 @@ For the web version, replace `desktop` with `web`. Restart DSH after installatio
 
 Use DSH normally. A completed turn qualifies when it contains an explicit preference/correction or at least two non-Dream tool calls. Within the configured budget, Dream creates candidates. Open Settings → Dream Journal to inspect their sources and accept them; relevant later tasks retrieve accepted memories automatically. You can still ask for a separate reflection and journal entry.
 
-Automatic collection uses the current session's model and quota: up to four auxiliary calls per day, ten minutes apart, with 1200 output tokens per call by default. Ordinary chat is skipped; new input cancels collection. Only sourced project candidates are saved. Acceptance and project-rule changes remain separate actions. UI language follows DSH; journal and lesson content stays original.
+Automatic collection uses the current session's model and quota. By default, it waits for 60 quiet seconds, merges up to four turns in the same project, and allows four calls per day at least ten minutes apart, with 1200 output tokens per call. Cooldown and quota limits defer turns; new input stops auxiliary work and retains unfinished excerpts. The bounded queue keeps up to 32 turns for 24 hours and survives restart. Ordinary chat is skipped.
+
+New memories await review: inspect the source quote, conditions and exceptions before accepting them. Facts require review after 30 days by default; stable preferences have no default expiry. Retrieval is reference exposure, not renewed verification. Acceptance and project-rule changes remain separate actions. UI language follows DSH; journal and lesson content stays original.
 
 ## Requirements and configuration
 

package/README.md

@@ -2,15 +2,19 @@
 
 [English](README.en.md)
 
+![dsh-dream 鲸鱼娘插件封面](https://raw.githubusercontent.com/STARDUSTLC666/dsh-dream/master/assets/cover-whale-girl.png)
+
 自动整理任务中的候选经验，审阅后在相关任务中回用；也可手动复盘并保存梦境日记。
 
-[![npm](https://img.shields.io/npm/v/@stardustlc/dsh-dream)](https://www.npmjs.com/package/@stardustlc/dsh-dream) [![downloads](https://img.shields.io/npm/dm/@stardustlc/dsh-dream)](https://www.npmjs.com/package/@stardustlc/dsh-dream)
+[![npm](https://img.shields.io/npm/v/@stardustlc/dsh-dream)](https://www.npmjs.com/package/@stardustlc/dsh-dream) [![downloads](https://raw.githubusercontent.com/STARDUSTLC666/dsh-suite/npm-downloads/assets/dsh-dream-downloads.svg)](https://www.npmjs.com/package/@stardustlc/dsh-dream)
 
 ## 功能
 
 - 浏览梦境日记、检索经验并查看关联来源。
 - 完成任务后自动提取候选，相关新任务自动取回已采纳经验；两个开关独立控制。
+- 安静后合并整理，冷却和额度不足时保留待处理轮次；可分别控制每个聊天的使用与贡献。
 - 直接审阅、处理冲突，记录独立的使用反馈。
+- 按项目和主题批量审阅，事实到期暂停回用，复核后恢复。
 - 预览规则差异后写入 AGENTS.md，并支持回滚。
 
 ## 安装
@@ -27,7 +31,9 @@ dsh plugin --profile desktop add @stardustlc/dsh-dream
 
 正常使用 DSH 即可：完成的一轮任务出现明确偏好、纠正，或至少两次非 Dream 工具调用时，会在预算内整理候选。在「设置 → 梦境日记」查看待审阅提示，核对来源后采纳；后续相关任务自动回用。也可说：“回顾最近的任务，记录值得保留的经验。”单独生成日记。
 
-自动整理使用当前会话的模型和额度，默认每天最多 4 次、间隔 10 分钟，单次最多 1200 输出 token；普通闲聊跳过，新输入到来取消整理。它只保存有来源的项目候选，不自动采纳，也不写项目规则。规则写入仍需预览和应用。中英文界面跟随 DSH 语言，日记与经验正文保留原文。
+自动整理使用当前会话的模型和额度，默认安静 60 秒后开始，同项目最多合并 4 轮，每天最多 4 次、间隔 10 分钟，单次最多 1200 输出 token。冷却和额度不足时轮次进入等待队列；新输入会暂停整理并保留未完成片段。队列最多保留 32 轮、24 小时，重启后可继续。普通闲聊跳过。
+
+新经验始终先待审阅：展开核对原话、条件与例外，再采纳。事实默认 30 天后待复核；稳定偏好没有默认到期时间。取回只表示提供参考，不会冒充重新核验。它不自动采纳，也不写项目规则；规则写入仍需预览和应用。中英文界面跟随 DSH 语言，日记与经验正文保留原文。
 
 ## 依赖与配置
 

package/docs/USAGE.en.md

@@ -17,13 +17,19 @@ Restart the web service afterwards. The dream journal lives at `~/.dsh/.dsh-drea
 
 Use DSH normally: a completed human root turn qualifies after an explicit preference/correction or at least two non-Dream tool calls with a visible assistant summary. Dream observes new events only; it does not scan old history, subagents or unsuccessful turns.
 
-Settings → Dream Journal has independent collection and retrieval switches, today's call count, the latest result/skip reason and a link to the review queue. Inspect candidate sources and accept them there. Settings persist under `journalDir/automatic/state.json`; page switches override configured defaults.
+Settings → Dream Journal → Journal shows collection/retrieval defaults, today's count, the latest reason and a review link. Expand “Chat controls and consolidation limits” to independently override use and contribution for an observed chat. Disabling contribution removes that chat's pending excerpts, preserving existing lessons. Overrides take priority over global defaults and persist in `journalDir/automatic/state.json`.
+
+From 0.9.0, collection waits for 60 quiet seconds and combines up to four turns with the same project/provider/model. Cooldown and quota limits defer inputs in a persistent queue (32 turns, 24 hours). Overflow removes the oldest unleased turn; expiry and overflow are visible. New input pauses auxiliary work and retains unfinished inputs. Manual consolidation skips quiet time but respects active tasks, cooldown and daily quota. Restart waits for fresh quiet time before resuming.
+
+Filter candidate lessons by project/topic, expand original masked quotes, conditions and exceptions, then select up to 20 conflict-free candidates for atomic acceptance/rejection. All selected lessons must share scope and topic; any changed revision prevents the whole write. Resolve conflicts and review stale lessons individually.
+
+Facts pause after 30 days since review/validation by default; explicit `reviewAfter` dates are supported. Stable preferences have no default expiry. Due lessons are held from automatic context and rule previews until reviewed again. Retrieval and feedback record exposure/use, never renewed verification or a later deadline.
 
 Defaults: four auxiliary calls per day, ten minutes apart, 12000 total system-plus-JSON characters, 1200 output tokens, a 30-second timeout and at most three candidates per call. The request uses the current session's provider/model and quota and can incur charges. Only limited masked visible messages are sent; reasoning, system prompts and tool arguments/results are excluded. New input, disabling collection or unloading cancels active collection. Attempts consume budget even on failure, with no Dream-level retry; host adapter retry policy is unchanged.
 
 Automatic retrieval makes no auxiliary model call. It supplies at most three accepted, independently sourced, task/project/platform-matching lessons in 3000 characters of dynamic context, preserving conditions and exceptions. Candidates, stale, disputed and rejected lessons are excluded. Version-bound lessons remain held because dependency versions are unknown here; use explicit `dream_context` with an actually verified package/version. Automatic features do not save journals, accept candidates or edit AGENTS.md. Verified on official 0.2.0-rc.2 and 0.2.1-alpha.1; hosts missing these interfaces keep manual tools and skills.
 
-Configuration keys are `autoCollect`, `autoRetrieve`, `autoMaxCallsPerDay` (1–20), `autoCooldownMs` (1000–3600000), `autoMinToolCalls` (1–50), `autoMaxInputChars` (1000–20000), `autoMaxOutputTokens` (200–2000) and `autoTimeoutMs` (1000–60000). Add them under the `dream` row's `config` in your profile's `cordis.patch.yml`.
+Configuration keys are `autoCollect`, `autoRetrieve`, `autoMaxCallsPerDay` (1–20), `autoCooldownMs` (1000–3600000), `autoIdleMs` (0–3600000, default 60000), `autoMinToolCalls` (1–50), `autoMaxInputChars` (1000–20000), `autoMaxOutputTokens` (200–2000) and `autoTimeoutMs` (1000–60000). Add them under the `dream` row's `config` in your profile's `cordis.patch.yml`. Automatic state stores bounded masked pending excerpts for up to 24 hours, along with settings, budgets and reference counts. Verified source quotes remain plaintext evidence with the lesson; hidden reasoning and tool bodies are excluded.
 
 ## Journal and lesson panel
 

package/docs/USAGE.md

@@ -24,7 +24,13 @@ dsh plugin --profile web remove @stardustlc/dsh-dream
 
 安装后正常完成任务即可，不需要记住「做梦」触发词。仅观察新产生的真人主会话事件：完成轮次出现明确偏好/纠正，或至少两次非 Dream 工具调用且有可见助手总结时，才会在预算内调用当前会话模型整理。它不扫描旧会话、子代理或失败轮次。
 
-「设置 → 梦境日记」顶部提供「自动整理候选经验」与「自动取回已采纳经验」两个开关。显示今日次数、最近检查原因和待审阅数量。点击待审阅提示进入经验页，核对来源后采纳；候选不会自动生效。控制值保存在 `journalDir/automatic/state.json`，重启后继续保留，页面开关覆盖配置中的缺省值。
+「设置 → 梦境日记 → 日记」提供自动整理、自动取回的默认开关、今日次数、最近原因和待审阅入口。展开「聊天设置与整理预算」，可针对已观察到的聊天分别控制「使用记忆」与「贡献记忆」；独立设置优先于全局默认。关闭贡献清理该聊天尚未整理的片段，已有经验仍保留。控制值保存在 `journalDir/automatic/state.json`，重启后继续保留。
+
+0.9.0 起默认等待 60 秒安静时间，同项目、提供商和模型最多合并 4 轮进行一次整理。冷却和当日预算用完时保留轮次等待恢复，队列最多 32 轮、24 小时；容量不足先移除最早未被处理的轮次，过期片段清理并显示计数。新输入暂停辅助调用并保留未完成轮次。可以点「现在整理待处理轮次」跳过安静时间，但不能绕过主任务优先、冷却或每日预算。重启后会等待新的安静时间再继续，不扫描旧会话历史。
+
+「经验」页按项目与主题筛选待核实记录。展开来源核对脱敏原话、适用条件及例外，再勾选无冲突候选进行批量采纳/驳回，最多 20 条；必须同项目、范围和主题，任一版本已变化会整体拒绝写入。冲突和待复核经验请逐条处理。
+
+事实默认在最近审阅/核验 30 天后暂停回用；明确的 `reviewAfter` 也可指定期限。稳定偏好没有默认期限。到期显示「已到复核时间」，不会注入或用于规则预览；核对当前事实后重新采纳才续期。「最近取回」只记录提供参考的时间，使用反馈和反复检索都不延长有效期。
 
 默认每天最多 4 次辅助调用、间隔 10 分钟、输入总长最多 12000 字符、输出最多 1200 token、30 秒超时，每次最多 3 条候选。输入仅包含脱敏后的有限可见消息；不包含隐藏推理、系统提示或工具参数/结果。该请求使用 DSH 当前模型和额度，可能产生费用；新输入、关闭整理或卸载会取消进行中的请求。尝试前扣预算，失败不返还，也不自动重试；宿主 adapter 的重试策略保持原样。
 
@@ -118,6 +124,7 @@ dream_review { action: "accept", lessonId: "lesson-…", expectedRevision: 1 }
     autoRetrieve: true         # 自动取回已采纳经验；页面开关可覆盖
     autoMaxCallsPerDay: 4       # 辅助调用次数（1-20），跨宿主共享此日记目录预算
     autoCooldownMs: 600000     # 两次尝试的间隔（1000-3600000）
+    autoIdleMs: 60000          # 安静时间（0-3600000）；0 仅建议隔离验证使用
     autoMinToolCalls: 2         # 非 Dream 工具次数门槛（1-50）；明确偏好/纠正可无需工具
     autoMaxInputChars: 12000   # 辅助请求 system + JSON 字符预算（1000-20000）
     autoMaxOutputTokens: 1200  # 输出预算（200-2000）
@@ -128,7 +135,7 @@ dream_review { action: "accept", lessonId: "lesson-…", expectedRevision: 1 }
 
 梦原料入梦前自动脱敏：sk 密钥、GitHub/Groq/Slack 令牌、AWS 密钥、JWT、`password/token/api_key` 赋值、超长高熵串都会被打成 `[已脱敏·类型]`。M1 的经验 / 证据 / 错误 / 桥接写盘路径在 `maskSecrets` 开启时同样先过 `mask.ts`，面板只读路由返回的文本也会再做一次脱敏。不需要时可在配置里设 `maskSecrets: false`。
 
-自动整理和自动取回始终脱敏，不受 `maskSecrets: false` 影响。脱敏不能保证识别所有个人信息；敏感项目可关闭自动整理。自动状态只保存预算、哈希化会话游标和结果原因，不保存会话正文。
+自动整理和自动取回始终脱敏，不受 `maskSecrets: false` 影响。脱敏不能保证识别所有个人信息；敏感项目可关闭自动整理或只关闭该聊天的贡献。自动状态保留预算、哈希化会话游标、开关、取回次数以及最多 24 小时的有限脱敏待处理片段；不会保存隐藏推理或工具正文。已核对的来源原话随经验作为明文证据保存。关闭贡献不删除已有经验。
 
 ## 权限与数据
 

package/docs/VALIDATION.md

@@ -1,6 +1,6 @@
 # dsh-dream 验证记录
 
-[0.8.0 自动整理与回用验收](validation/0.8.0.md) · [0.7.1 中英文界面验收](validation-language-2026-10-03.md)。
+[0.9.0 队列与记忆审阅验收](validation/0.9.0.md) · [0.8.1 真实模型验收](validation/0.8.1.md) · [0.8.0 自动整理与回用验收](validation/0.8.0.md)。
 
 本页整理原 README 的历史验证说明，保留当时的版本、日期与范围。自动测试、启动检查、浏览器操作和真实服务验收分别记录，不能相互替代。更详细的版本验收文件仍保留在仓库中。
 

package/docs/validation/0.8.1.md

@@ -0,0 +1,18 @@
+# Dream 0.8.1 acceptance / 验收
+
+## Observed failure
+
+With the official 0.2.1-alpha.1 DeepSeek adapter and `deepseek-flash`, a short invented CSV preference with an encoding exception consumed all 1200 output tokens. The adapter returned `max-tokens` after reasoning and incomplete JSON. Dream correctly discarded it, but the useful candidate was lost.
+
+## Change
+
+The auxiliary extraction checks the official `llm.resolveModelInfo(provider, model, signal)` capability. If this exact model advertises the `off` reasoning effort, only the auxiliary call requests it. Unknown models, unavailable metadata and legacy hosts retain their provider default. Metadata resolution and streaming share the existing timeout and abort signal. No retries, larger budgets or main-agent settings were added.
+
+## Validation
+
+- Windows: 304 tests, 303 passed, one optional stress test skipped. Regression cases cover complete extraction within the short budget, unsupported/missing metadata, and metadata calls that ignore abort.
+- Real official SDK/provider with the local existing API credential: the invented CSV preference was saved as one unreviewed, project-scoped candidate with its exact source and UTF-8 exception; a second case without reusable information saved nothing. Both finished with `stop`; project AGENTS.md and the credential file remained unchanged.
+- The quality check uses invented session events, not a claim that those events were emitted by a human's live session. The previous 0.8.0 acceptance separately exercised complete official RC2 and Alpha AgentLoops using a scripted adapter.
+- The user's native Desktop process and one main window were observed. The window was minimized, so it was not restored while the user watched a video. Native visual/interaction acceptance remains untested.
+
+Local receipts: `E:/deepseek/.harness-validation/dream-auto-20261003/real-model-before-081.json`, `real-model-verification.json`, `automatic-081-tests.log`.

package/docs/validation/0.9.0.md

@@ -0,0 +1,11 @@
+# 0.9.0 验收（2026-10-05）
+
+- Windows / Node 24：320 项测试，319 通过，1 项可选并发压力测试默认跳过。覆盖队列合并、额度延后、取消与重启、跨进程预算/死租约恢复、过期清理、聊天独立开关、原子审阅、幂等重试及来源映射。
+- 快照：完整内容哈希；固定文件大小与时间戳的中段修改、事件损坏、原子替换、拒绝与反馈均重新计算。不可变缓存不能被调用方修改。时钟到期无需文件变化即可暂停事实取回。
+- 官方 DSH 0.2.1-alpha.1 隔离 Web 宿主：正常任务在队列中等待、安静后产生候选；浏览器展开条件/例外/来源、勾选两条候选、原子采纳成功。后续实际官方 AgentLoop 收到已采纳记忆；每个聊天的使用/贡献独立保存。
+- 浏览器：中文/英文切换，新控制文案跟随语言且原文不翻译；390×844 窄屏没有页面横向溢出，实际点击待复核成功；预算与聊天详细设置默认折叠，经验页不被自动设置遮挡。
+- 真实模型：官方 DeepSeek SDK / deepseek-flash，限定输入输出、支持时关闭辅助推理；有条件的 CSV 偏好保存候选，无长期结论的输入返回空列表。另一次真实官方 AgentLoop 正常生成两条待审阅候选。测试输入均为人工构造演示，不使用个人会话；本地密钥未复制到磁盘，项目规则保持原样。
+
+测试产物保存在本地 `.harness-validation/dream-memory-20261005/`。安装与发布单独检查包内容、完整性和官方 profile 加载；GitHub CI 负责 Linux 构建与测试。
+
+Web 操作验收覆盖共享客户端和官方宿主接口，不等同于原生桌面窗口操作。本轮没有切换或重启用户正在使用的桌面窗口。网络/model 故障仍可能使整理失败；失败消耗本次预算，Dream 不无限重试。队列到期或超出容量会清理待处理片段并显示计数。

package/lib/automatic-queue.d.ts

@@ -0,0 +1,29 @@
+import type { ResolvedDreamConfig } from './config.js';
+import { type PendingMemory } from './automatic-state.js';
+/** One event-driven timer, persistent bounded inputs, cross-process call leases. */
+export declare class MemoryQueue {
+    private timer?;
+    private work;
+    private running;
+    private closed;
+    private quietUntil;
+    private controller?;
+    private cfg;
+    private now;
+    private canRun;
+    private generate;
+    private onProblem;
+    constructor(cfg: ResolvedDreamConfig, now: () => number, canRun: () => boolean, generate: (rows: PendingMemory[], signal: AbortSignal) => Promise<{
+        reason: string;
+        saved: number;
+    }>, onProblem?: (reason: string) => void);
+    touch(): void;
+    cancel(): void;
+    stop(): void;
+    whenIdle(): Promise<void>;
+    enqueue(row: PendingMemory): void;
+    flush(): void;
+    kick(): void;
+    private enabled;
+    private drain;
+}

package/lib/automatic-queue.js

@@ -0,0 +1,184 @@
+import { createHash, randomUUID } from 'node:crypto';
+import { budgetDay, readAutomaticState, updateAutomaticState } from './automatic-state.js';
+const TTL = 86400000;
+function alive(pid) { try {
+    process.kill(pid, 0);
+    return true;
+}
+catch (e) {
+    return e.code !== 'ESRCH';
+} }
+/** One event-driven timer, persistent bounded inputs, cross-process call leases. */
+export class MemoryQueue {
+    timer;
+    work = Promise.resolve();
+    running = false;
+    closed = false;
+    quietUntil;
+    controller;
+    cfg;
+    now;
+    canRun;
+    generate;
+    onProblem;
+    constructor(cfg, now, canRun, generate, onProblem = () => { }) {
+        this.cfg = cfg;
+        this.now = now;
+        this.canRun = canRun;
+        this.generate = generate;
+        this.onProblem = onProblem;
+        this.quietUntil = now() + cfg.autoIdleMs;
+    }
+    touch() { this.quietUntil = this.now() + this.cfg.autoIdleMs; this.controller?.abort(); this.kick(); }
+    cancel() { this.controller?.abort(); this.kick(); }
+    stop() { this.closed = true; clearTimeout(this.timer); this.controller?.abort(); }
+    async whenIdle() { await this.work; }
+    enqueue(row) {
+        updateAutomaticState(this.cfg, state => {
+            const cursor = createHash('sha256').update(row.sessionId).digest('hex').slice(0, 24);
+            if ((state.cursors[cursor] ?? -1) >= row.endSeq)
+                return;
+            if (Object.keys(state.cursors).length >= 128 && state.cursors[cursor] === undefined)
+                delete state.cursors[Object.keys(state.cursors)[0]];
+            state.cursors[cursor] = row.endSeq;
+            state.pending ??= [];
+            if (state.pending.some(p => p.key === row.key))
+                return;
+            if (state.pending.length >= 32) {
+                const replace = state.pending.findIndex(p => !p.lease);
+                state.overflow = (state.overflow ?? 0) + 1;
+                if (replace < 0)
+                    return;
+                state.pending.splice(replace, 1);
+            }
+            state.pending.push(row);
+            const reason = state.day === budgetDay(this.now()) && state.calls >= this.cfg.autoMaxCallsPerDay ? 'daily-budget'
+                : state.lastAttemptAt !== undefined && this.now() < state.lastAttemptAt + this.cfg.autoCooldownMs ? 'cooldown' : 'queued';
+            if (state.last?.reason !== 'recording')
+                state.last = { at: this.now(), reason, saved: 0 };
+        }, this.now());
+        this.kick();
+    }
+    flush() {
+        this.quietUntil = 0;
+        updateAutomaticState(this.cfg, s => { for (const p of s.pending ?? [])
+            p.readyAt = this.now(); }, this.now());
+        this.kick();
+    }
+    kick() {
+        clearTimeout(this.timer);
+        if (this.closed || this.running)
+            return;
+        try {
+            let state = readAutomaticState(this.cfg, this.now());
+            const now = this.now();
+            if (state.pending?.some(p => now - p.createdAt >= TTL)) {
+                updateAutomaticState(this.cfg, s => {
+                    const expired = (s.pending ?? []).filter(p => now - p.createdAt >= TTL);
+                    s.expired = (s.expired ?? 0) + expired.length;
+                    s.pending = (s.pending ?? []).filter(p => now - p.createdAt < TTL);
+                }, now);
+                state = readAutomaticState(this.cfg, now);
+            }
+            if (!state.pending?.length)
+                return;
+            const expiresAt = Math.min(...state.pending.map(p => p.createdAt + TTL));
+            const eligible = state.pending.filter(p => this.enabled(p, state));
+            const paused = !eligible.length || !this.canRun();
+            let at = paused ? expiresAt : Math.min(...eligible.map(p => Math.max(p.readyAt, p.lease && alive(p.lease.pid) ? p.lease.until : 0)));
+            at = Math.max(at, this.quietUntil, (state.lastAttemptAt ?? 0) + this.cfg.autoCooldownMs);
+            if (state.day === budgetDay(now) && state.calls >= this.cfg.autoMaxCallsPerDay) {
+                const next = new Date(now);
+                next.setHours(24, 0, 0, 0);
+                at = Math.max(at, next.getTime());
+            }
+            if (!paused && at <= now) {
+                this.running = true;
+                this.work = this.work.then(() => this.drain()).catch(e => this.onProblem(e.message === 'automatic-storage-busy' ? e.message : 'automatic-storage-error')).finally(() => { this.running = false; this.kick(); });
+            }
+            else {
+                this.timer = setTimeout(() => { this.kick(); }, Math.max(1, Math.min(at - now, expiresAt - now, 2147483647)));
+                this.timer.unref?.();
+            }
+        }
+        catch (error) {
+            this.onProblem(error.message === 'automatic-storage-busy' ? error.message : 'automatic-state-invalid');
+            if (error.message === 'automatic-storage-busy') {
+                this.timer = setTimeout(() => this.kick(), 1000);
+                this.timer.unref?.();
+            }
+        }
+    }
+    enabled(row, state) {
+        const key = createHash('sha256').update(row.sessionId).digest('hex').slice(0, 24);
+        return state.policies?.[key]?.contribute ?? state.enabled ?? this.cfg.autoCollect;
+    }
+    async drain() {
+        if (this.closed || !this.canRun())
+            return;
+        const now = this.now(), job = randomUUID();
+        const rows = updateAutomaticState(this.cfg, state => {
+            const all = state.pending ?? [];
+            state.expired = (state.expired ?? 0) + all.filter(p => now - p.createdAt >= TTL).length;
+            state.pending = all.filter(p => now - p.createdAt < TTL);
+            if (state.day !== budgetDay(now)) {
+                state.day = budgetDay(now);
+                state.calls = 0;
+            }
+            if (state.calls >= this.cfg.autoMaxCallsPerDay || now < (state.lastAttemptAt ?? 0) + this.cfg.autoCooldownMs || now < this.quietUntil)
+                return [];
+            const due = state.pending.filter(p => this.enabled(p, state) && p.readyAt <= now && (!p.lease || p.lease.until <= now || !alive(p.lease.pid)));
+            const first = due[0];
+            if (!first)
+                return [];
+            const selected = [];
+            let chars = 0;
+            for (const p of due.filter(p => p.cwd === first.cwd && p.provider === first.provider && p.model === first.model)) {
+                const size = JSON.stringify(p.sources.map(({ seq, role, text }) => ({ seq, role, text }))).length;
+                if (selected.length && chars + size > this.cfg.autoMaxInputChars - 1000)
+                    continue;
+                selected.push(p);
+                chars += size;
+                if (selected.length === 4)
+                    break;
+            }
+            for (const p of selected)
+                p.lease = { job, pid: process.pid, until: now + this.cfg.autoTimeoutMs + 5000 };
+            state.calls++;
+            state.lastAttemptAt = now;
+            state.last = { at: now, reason: 'recording', saved: 0, job };
+            return selected;
+        }, now);
+        if (!rows.length)
+            return;
+        const controller = new AbortController();
+        this.controller = controller;
+        const timer = setTimeout(() => controller.abort(new Error('automatic-timeout')), this.cfg.autoTimeoutMs);
+        timer.unref?.();
+        let result = { reason: 'model-error', saved: 0 };
+        try {
+            result = await this.generate(rows, controller.signal);
+        }
+        catch {
+            result.reason = controller.signal.aborted ? (controller.signal.reason?.message === 'automatic-timeout' ? 'timeout' : 'cancelled') : 'model-error';
+        }
+        finally {
+            clearTimeout(timer);
+            this.controller = undefined;
+            updateAutomaticState(this.cfg, state => {
+                state.pending = (state.pending ?? []).filter(p => {
+                    if (p.lease?.job !== job)
+                        return true;
+                    if (result.reason === 'cancelled') {
+                        delete p.lease;
+                        p.readyAt = this.now() + this.cfg.autoIdleMs;
+                        return true;
+                    }
+                    return false;
+                });
+                if (state.last?.job === job)
+                    state.last = { at: this.now(), ...result, job };
+            }, this.now());
+        }
+    }
+}

package/lib/automatic-state.d.ts

@@ -1,4 +1,31 @@
 import type { ResolvedDreamConfig } from './config.js';
+export interface PendingMemory {
+    key: string;
+    sessionId: string;
+    cwd: string;
+    endSeq: number;
+    createdAt: number;
+    readyAt: number;
+    provider: string;
+    model: string;
+    sources: Array<{
+        seq: number;
+        role: 'user' | 'assistant';
+        text: string;
+        hash: string;
+    }>;
+    lease?: {
+        job: string;
+        pid: number;
+        until: number;
+    };
+}
+export interface ChatMemoryPolicy {
+    sessionId: string;
+    cwd?: string;
+    use?: boolean;
+    contribute?: boolean;
+}
 export interface AutomaticState {
     version: 1;
     day: string;
@@ -7,6 +34,14 @@ export interface AutomaticState {
     retrievalEnabled?: boolean;
     lastAttemptAt?: number;
     cursors: Record<string, number>;
+    pending?: PendingMemory[];
+    policies?: Record<string, ChatMemoryPolicy>;
+    expired?: number;
+    overflow?: number;
+    retrieved?: Record<string, {
+        at: number;
+        count: number;
+    }>;
     last?: {
         at: number;
         reason: string;

package/lib/automatic-state.js

@@ -10,7 +10,7 @@ export function readAutomaticState(cfg, now = Date.now()) {
     const file = join(cfg.journalDir, 'automatic', 'state.json');
     if (!existsSync(file))
         return { version: 1, day: budgetDay(now), calls: 0, cursors: {} };
-    if (statSync(file).size > 128 * 1024)
+    if (statSync(file).size > 2 * 1024 * 1024)
         throw new Error('automatic-state-invalid');
     const raw = JSON.parse(readFileSync(file, 'utf8'));
     if (raw?.version !== 1 || typeof raw.day !== 'string' || !/^\d{4}-\d{2}-\d{2}$/.test(raw.day)
@@ -24,6 +24,19 @@ export function readAutomaticState(cfg, now = Date.now()) {
         || (raw.last !== undefined && (!Number.isSafeInteger(raw.last.at) || typeof raw.last.reason !== 'string' || raw.last.reason.length > 80 || !Number.isSafeInteger(raw.last.saved) || raw.last.saved < 0 || (raw.last.job !== undefined && typeof raw.last.job !== 'string')))) {
         throw new Error('automatic-state-invalid');
     }
+    const text = (v, max) => typeof v === 'string' && v.length > 0 && v.length <= max;
+    const integer = (v) => Number.isSafeInteger(v) && Number(v) >= 0;
+    if ((raw.pending !== undefined && (!Array.isArray(raw.pending) || raw.pending.length > 32 || raw.pending.some((p) => !p || !text(p.key, 64) || !text(p.sessionId, 200) || !text(p.cwd, 2000) || !integer(p.endSeq)
+        || !integer(p.createdAt) || !integer(p.readyAt) || !text(p.provider, 200) || !text(p.model, 200)
+        || !Array.isArray(p.sources) || p.sources.length < 1 || p.sources.length > 6 || p.sources.some((s) => !s || !integer(s.seq) || !['user', 'assistant'].includes(s.role) || !text(s.text, 1800) || !/^[a-f0-9]{64}$/.test(s.hash))
+        || (p.lease !== undefined && (!text(p.lease.job, 64) || !integer(p.lease.pid) || p.lease.pid < 1 || !integer(p.lease.until))))))
+        || (raw.policies !== undefined && (!raw.policies || Array.isArray(raw.policies) || typeof raw.policies !== 'object'
+            || Object.keys(raw.policies).length > 128 || Object.entries(raw.policies).some(([key, p]) => !/^[a-f0-9]{24}$/.test(key) || !p || !text(p.sessionId, 200) || (p.cwd !== undefined && !text(p.cwd, 2000))
+            || ['use', 'contribute'].some(k => p[k] !== undefined && typeof p[k] !== 'boolean'))))
+        || ['expired', 'overflow'].some(k => raw[k] !== undefined && !integer(raw[k]))
+        || (raw.retrieved !== undefined && (!raw.retrieved || Array.isArray(raw.retrieved) || typeof raw.retrieved !== 'object'
+            || Object.keys(raw.retrieved).length > 2000 || Object.entries(raw.retrieved).some(([key, v]) => !text(key, 200) || !v || !integer(v.at) || !integer(v.count)))))
+        throw new Error('automatic-state-invalid');
     return raw;
 }
 /** No waiting on a live lock: observing a turn must never stall its owner. */

package/lib/automatic.d.ts

@@ -8,7 +8,11 @@ export declare class AutomaticDream {
     private queries;
     private queue;
     private pending;
-    private active?;
+    private scheduler?;
+    private active;
+    private sessions;
+    private contextCache;
+    private retrievalStamp;
     private closed;
     private ready;
     private host;
@@ -27,8 +31,14 @@ export declare class AutomaticDream {
         enabled?: boolean;
         retrievalEnabled?: boolean;
     }): void;
+    controlSession(id: string, changes: {
+        use?: boolean | null;
+        contribute?: boolean | null;
+    }): void;
+    flush(): void;
     observe(session: any, event: any): void;
     private process;
+    private generateBatch;
     private generate;
     private parse;
     context(agent: any): string;