dsh-hypatia-auto-memory 2.0.0 → 2.1.1

package/README.md

@@ -101,6 +101,8 @@ collect fiber dispose ──▶ the same flush for every session still open, per
                      before the queue stops; the model call finishes at the next start
                      (a restart, a config-change restart, or a crash: the startup
                      consolidation backfill)
+explicit request ──▶ /hypatia-summarize (no model turn) | hypatia_summarize |
+                     the Memory tab button ──▶ the same consolidate task, thresholds waived
 agent/created ──▶ rules/taboos inject()
 ```
 
@@ -221,6 +223,34 @@ agent/created ──▶ rules/taboos inject()
   This is the protocol's log₁₆(n) archive: each tier compresses only material a
   previous tier already distilled.
 
+- **Consolidation can also be requested explicitly.** Three faces call one host
+  action: the slash command **`/hypatia-summarize`** (in the composer's `/` menu,
+  executed by the UI *without a model turn*), the **`hypatia_summarize`** tool
+  (the `hypatia-memory` skill's execution path, so the agent never hand-writes a
+  `sum-*` entry), and a **Summarise now** button on the Memory tab, which sits on
+  the row that reports how far behind the session is — the moment a reader wants
+  it. A request cuts the span `[lastConsolidatedSeq, min(seq, lastLoggedSeq))`
+  **at that moment** and queues the same `consolidate` task the automatic trigger
+  queues: same kind, same executor, same idempotent writer. `checkEveryTurns` and
+  `minNewTokens` are deliberately bypassed — they pace an ongoing conversation,
+  and an explicit request is the reason to cut now. Measured live, a session sat
+  151 logged events behind while the token floor had accumulated 645 of 3000, so
+  waiting for the gate is not an answer to accept. The config switches are *not*
+  bypassed, and a request is only a cut, never a freeze: events appended
+  afterwards wait for the next trigger as usual.
+
+  "Nothing left to summarise" and "this span is already queued" are reported as
+  such rather than queued again, so asking twice does not produce two summaries —
+  and because the writer is idempotent by name, even a race cannot. The button is
+  **disabled but kept in place** once the session is caught up: hiding it would
+  make the user rediscover it every time the session falls behind, which is
+  exactly when they look for it. It rides the Memory tab's own route family,
+  whose first **write** route (`POST /consolidate`) keeps all three
+  self-authentication checks the read routes use — loopback socket, loopback
+  `Host`, same-origin — and refuses anything but `POST`, so the write cannot be
+  triggered by a link or an image tag. Nothing on any of the three faces runs a
+  model call in the main session.
+
 - **Work units** are adjudicated, not guessed. Candidates come from `similar`
   (the only search that reports a distance), with the operational layer left
   out — in the query, by `--exclude-tags`, on a binary that has it (hypatia
@@ -325,7 +355,7 @@ agent/created ──▶ rules/taboos inject()
   verbatim, the reader just wrote them, and the agent is the right reader for
   them.
 
-  The data arrives over a session-scoped, read-only HTTP route this plugin
+  The data arrives over a session-scoped HTTP route family this plugin
   registers on the DSH web server, `/api/dsh-hypatia-auto-memory/session`: status
   from the in-memory state tables on every poll, the shelf content only when it
   can have changed (on open, on a session switch, on a manual refresh, and when
@@ -335,7 +365,10 @@ agent/created ──▶ rules/taboos inject()
   and 120 000 per response. JSE has no `ORDER BY`, so "newest" is decided only
   after reading every candidate; when a scan reaches its cap the counts become
   lower bounds, and the tab reports that response as truncated rather than
-  leaving a short list unexplained.
+  leaving a short list unexplained. The family's one **write** route,
+  `POST /consolidate`, is what the **Summarise now** button calls; it writes
+  nothing itself — it queues the same consolidation task the automatic trigger
+  queues (see *On-demand* above).
   Two channels were rejected on the way here. A **session projection** would be
   the best shape, but the event that would drive it cannot be written from
   outside this repository: `Session.append` offers no way to set the envelope's
@@ -650,7 +683,8 @@ dsh-hypatia-auto-memory/
 │   ├── cascade.js        # log₁₆(n) hierarchical summary archive
 │   ├── model-log.js      # bounded record of which model each attempt ran on
 │   ├── memory-status.js  # per-session fold of the two state tables (pure)
-│   ├── memory-api.js     # Memory tab + shelf listing: read-only route family
+│   ├── memory-api.js     # Memory tab + shelf listing; its one write route too
+│   ├── on-demand.js      # /hypatia-summarize + the hypatia_summarize tool
 │   ├── recall.js         # rules/taboos preload at session start
 │   ├── auto-approve.js   # approves the agent's own plain bash hypatia calls
 │   ├── skills.js         # bundled skill registration (never shadows another provider)

package/README.zh-CN.md

@@ -87,6 +87,8 @@ session/disposed ──▶ final flush + consolidation, thresholds waived (DSH
 collect fiber 拆除 ──▶ 对每个仍打开的会话做同样的收尾，并在队列停止前落盘；模型
                      调用留到下次启动完成（重启、配置变更重启，或崩溃：启动时的
                      consolidation backfill）
+显式请求 ──▶ /hypatia-summarize（不过模型）| hypatia_summarize | 记忆标签页按钮
+                     ──▶ 同一个 consolidate 任务，但跳过阈值
 agent/created ──▶ rules/taboos inject()
 ```
 
@@ -175,6 +177,25 @@ agent/created ──▶ rules/taboos inject()
   免费得到 FIFO 分批）。这就是协议的 log₁₆(n) 归档：每一层只压缩上一层已经蒸馏过的
   内容。
 
+- **也可以显式要求立刻整合。** 三个面对应同一个 host 侧动作：斜杠命令
+  **`/hypatia-summarize`**（在 composer 的 `/` 菜单里，由 UI 执行、**不过模型**）、工具
+  **`hypatia_summarize`**（`hypatia-memory` 技能的执行路径，Agent 因此不会自己手写
+  `sum-*` 条目），以及记忆标签页上的**「立即整理」按钮**——它就在报告「落后多少」的那
+  一行上，正是读者需要它的时刻。一次请求按**触发那一刻**的水位切出
+  `[lastConsolidatedSeq, min(seq, lastLoggedSeq))`，入队与自动触发**完全相同**的
+  `consolidate` 任务：同一种 kind、同一个执行器、同一个幂等写手。`checkEveryTurns` 与
+  `minNewTokens` 被刻意绕过——它们用来给进行中的对话定节奏，而显式请求本身就是「现在
+  就切」的理由。实测中一个会话落后 151 个事件，而门槛只累计到 3000 中的 645，所以
+  「等闸门开」不是一个应当被接受的答案。配置开关**不**绕过；而且请求只是一次切分，
+  不是冻结：之后产生的事件照旧等下一次触发。
+
+  「没有需要整理的内容」和「这个区间已经入队」会如实回报而不是再入队一次，所以问两遍
+  不会产生两条摘要——何况写手按名字幂等，即使并发也不会。结清后按钮**禁用但保留在原
+  位**：隐藏它会让用户每次落后时都要重新发现它，而那正是他们找它的时候。它走记忆标签
+  页自己的路由族，其中第一条**写**路由（`POST /consolidate`）完整保留读路由的三条自
+  认证——回环 socket、回环 `Host`、同源——并且只接受 `POST`，所以链接或 `<img>` 无法触
+  发这次写入。三个面都不会在主会话里发起模型调用。
+
 - **工作单元是裁决出来的，不是猜出来的。** 候选来自 `similar`（唯一会报告距离的
   检索），且排除操作层——在具备该能力的二进制上（hypatia #35）通过查询里的
   `--exclude-tags`；在没这个能力的二进制上，抓四倍的量再丢弃——再按距离上限过滤，
@@ -250,14 +271,16 @@ agent/created ──▶ rules/taboos inject()
   原始 `msg-*` 条目**故意不显示**：它是对话原文，读的人刚刚写过，而正确的读者是
   Agent。
 
-  数据经由本插件注册在 DSH web 服务器上的、会话作用域的只读 HTTP 路由
+  数据经由本插件注册在 DSH web 服务器上的、会话作用域的 HTTP 路由族
   `/api/dsh-hypatia-auto-memory/session` 到达浏览器：状态每次轮询都从内存中的状态表
   现算，shelf 内容只在可能变化时才读（打开时、切换会话时、手动刷新时，以及整合推进了
   该会话水位时），其间缓存 15 秒。标签页在屏幕上时每 5 秒轮询一次，响应是有界的：
   最新的 40 条摘要与 40 条工作单元，每条正文 4000 字符、整份响应 120000 字符。
   JSE 没有 `ORDER BY`，所以「最新」只能在读完所有候选之后判定；扫描触到上限时计数
-  变成下界，标签页会把该次响应标为已截断，而不是让短列表无从解释。路上否掉了两条
-  通道。**session projection** 形态最
+  变成下界，标签页会把该次响应标为已截断，而不是让短列表无从解释。这个路由族里唯一的
+  **写**路由 `POST /consolidate` 就是「立即整理」按钮调用的那个；它自己不写任何东西
+  ——它入队的是与自动触发完全相同的整合任务（见上文「也可以显式要求立刻整合」）。
+  路上否掉了两条通道。**session projection** 形态最
   合适，但驱动它的事件在本仓库之外写不出来：`Session.append` 没有任何途径设置信封的
   `ignorable` 标记，而持久化读取路径会拒绝一个带着未知事件类型、又没有该标记的会话
   日志——所以自定义事件会破坏会话重载。**设置命名空间**即便在还存在时也是根作用域的：
@@ -513,7 +536,8 @@ dsh-hypatia-auto-memory/
 │   ├── cascade.js        # log₁₆(n) 分层摘要归档
 │   ├── model-log.js      # 每次尝试实际用了哪个模型的有界记录
 │   ├── memory-status.js  # 两张状态表按会话折叠（纯函数）
-│   ├── memory-api.js     # 记忆标签页与 shelf 清单：只读路由族 + JSE 读取
+│   ├── memory-api.js     # 记忆标签页与 shelf 清单；含唯一的写路由
+│   ├── on-demand.js      # /hypatia-summarize 与 hypatia_summarize 工具
 │   ├── recall.js         # 会话启动时的 rules/taboos 预载
 │   ├── auto-approve.js   # 批准 Agent 自己的纯 bash hypatia 调用
 │   ├── skills.js         # 随包技能注册（从不遮蔽其它提供者）

package/lib/client.js

@@ -307,6 +307,17 @@ window.__ModuleLoader__.load({
 			memoryConsolidated: "摘要整合",
 			memoryCaughtUp: "已结清",
 			memoryBehind: "较记录落后 {behind} 条",
+			memorySummarize: "立即整理",
+			memorySummarizing: "整理中…",
+			memorySummarizeHint: "不等阈值，立刻把这段尚未摘要的对话交给后台整合。已结清时按钮禁用但保留在原位，下次落后时不必重新找它。",
+			memorySummarizeQueued: "已入队：将整理第 {from} – {to} 条事件；摘要在后台由插件的专用模型路由写入，不会占用本会话的上下文。",
+			memorySummarizeEmpty: "已结清，没有需要整理的内容。",
+			memorySummarizeBusy: "同样的区间已有一次整合在队列中，无需重复触发。",
+			memorySummarizeDisabled: "整合功能已在设置中关闭。",
+			memorySummarizeUnavailable: "整合不可用：当前组合没有挂载模型路由。",
+			memorySummarizeUnknown: "这个会话已经不在内存中，无法整理。",
+			memorySummarizeUnknownReason: "未能整理：{reason}",
+			memorySummarizeFailed: "无法触发整理：{message}",
 			memoryPending: "待整合内容",
 			memoryPendingValue: "约 {tokens} token",
 			memorySessionNode: "会话节点",
@@ -407,6 +418,17 @@ window.__ModuleLoader__.load({
 			memoryConsolidated: "Summarisation",
 			memoryCaughtUp: "caught up",
 			memoryBehind: "{behind} events behind the log",
+			memorySummarize: "Summarise now",
+			memorySummarizing: "Summarising…",
+			memorySummarizeHint: "Consolidate the part of this conversation that has not been summarised yet, without waiting for the thresholds. Once caught up the button is disabled but stays in place, so it need not be rediscovered the next time the session falls behind.",
+			memorySummarizeQueued: "Queued: events {from}–{to} will be summarised. The summary is written in the background on the plugin's own model route and costs this session no context.",
+			memorySummarizeEmpty: "Nothing to summarise: the log is already consolidated.",
+			memorySummarizeBusy: "A consolidation covering the same span is already queued.",
+			memorySummarizeDisabled: "Consolidation is turned off in the settings.",
+			memorySummarizeUnavailable: "Consolidation is unavailable: this composition mounted no model route for it.",
+			memorySummarizeUnknown: "That session is no longer in memory, so it cannot be consolidated.",
+			memorySummarizeUnknownReason: "Could not consolidate: {reason}",
+			memorySummarizeFailed: "Could not start consolidation: {message}",
 			memoryPending: "Waiting to summarise",
 			memoryPendingValue: "~{tokens} tokens",
 			memorySessionNode: "Session node",
@@ -1341,6 +1363,22 @@ window.__ModuleLoader__.load({
 		/** Route prefix the Host claims; the tab appends `/session`. */
 		const MEMORY_API_PREFIX = "/api/dsh-hypatia-auto-memory";
 		/**
+		* Why an explicit consolidation request queued nothing, matching the Host's
+		* `SUMMARIZE_REASON` vocabulary (src/consolidator.js). Kept as named constants
+		* so the view's switch and the Host's answers cannot drift apart on a typo.
+		*/
+		const SUMMARIZE_REASON = {
+			disabled: "disabled",
+			empty: "empty",
+			busy: "busy",
+			unknownSession: "unknown-session",
+			unavailable: "unavailable"
+		};
+		/** Whether "summarise now" has work to do for this session. */
+		function canSummarize(session) {
+			return session.known && !session.caughtUp;
+		}
+		/**
 		* The URL one refresh reads.
 		* @param sessionId - the session the tab is bound to.
 		* @param content - whether to ask the Host to read the shelf as well.
@@ -1368,6 +1406,59 @@ window.__ModuleLoader__.load({
 			return payload;
 		};
 		/**
+		* The URL one explicit consolidation request POSTs to.
+		* @param sessionId - the session to consolidate.
+		* @returns a same-origin path with its query.
+		*/
+		function summarizeUrl(sessionId) {
+			const query = new URLSearchParams({ session: sessionId });
+			return `${MEMORY_API_PREFIX}/consolidate?${query.toString()}`;
+		}
+		/**
+		* Ask the Host to consolidate one session now.
+		*
+		* `POST`, never `GET`: a write must not be reachable from a link or an image
+		* tag. The Host keeps the same self-authentication on this route as on the read
+		* ones (loopback socket, loopback `Host`, same-origin), and the body is empty —
+		* everything the request means is in the URL.
+		*/
+		const summarizeMemory = async (sessionId) => {
+			const response = await fetch(summarizeUrl(sessionId), {
+				method: "POST",
+				credentials: "same-origin",
+				headers: { accept: "application/json" }
+			});
+			const body = await response.json().catch(() => void 0);
+			if (!response.ok) {
+				const message = isRecord(body) && typeof body.error === "string" ? body.error : `HTTP ${String(response.status)}`;
+				throw new Error(message);
+			}
+			const result = parseSummarizeResult(body, sessionId);
+			if (result === void 0) throw new Error("the Host returned an unreadable consolidation answer");
+			return result;
+		};
+		/**
+		* Read the Host's consolidation answer, defensively.
+		*
+		* A body without a boolean `queued` is unreadable rather than "not queued": the
+		* whole point of the answer is to distinguish "accepted" from "nothing to do",
+		* and guessing would put a wrong sentence in front of the user.
+		*
+		* @param value - the parsed response body.
+		* @param sessionId - the session that was asked for.
+		* @returns the result, or undefined when the body is not one.
+		*/
+		function parseSummarizeResult(value, sessionId) {
+			if (!isRecord(value) || typeof value.queued !== "boolean") return void 0;
+			return {
+				sessionId: str(value.sessionId) || sessionId,
+				queued: value.queued,
+				reason: str(value.reason),
+				fromSeq: num(value.fromSeq),
+				toSeq: num(value.toSeq)
+			};
+		}
+		/**
 		* Fetch the shelf listing for the settings card.
 		*
 		* Rides the same self-authenticating route family as the Memory tab — the
@@ -1531,7 +1622,7 @@ window.__ModuleLoader__.load({
 		}
 		//#endregion
 		//#region \0dsh-hypatia-css:/home/runner/work/dsh-hypatia-auto-memory/dsh-hypatia-auto-memory/src/client/MemoryView.module.css.mjs
-		const css = ".LBuOzG_panel{box-sizing:border-box;width:100%;height:100%;min-height:0;padding:16px;padding-bottom:calc(var(--dsh-composer-height,152px) + 16px);color:var(--dsw-alias-label-primary);background:var(--dsw-alias-bg-layer-1);flex-direction:column;align-items:center;display:flex;overflow-y:auto}.LBuOzG_column{flex-direction:column;gap:20px;width:100%;min-width:0;max-width:880px;display:flex}.LBuOzG_head{justify-content:space-between;align-items:baseline;gap:12px;display:flex}.LBuOzG_title{color:var(--dsw-alias-label-primary);margin:0;font-size:15px;font-weight:600;line-height:1.4}.LBuOzG_headMeta{align-items:center;gap:10px;display:flex}.LBuOzG_updated{color:var(--dsw-alias-label-tertiary);font-size:12px}.LBuOzG_refresh{appearance:none;border:.5px solid var(--dsw-alias-border-l4);color:var(--dsw-alias-label-secondary);cursor:pointer;font:inherit;background:0 0;border-radius:8px;padding:2px 8px;font-size:12px}.LBuOzG_refresh:hover{border-color:var(--dsw-alias-label-dimmed);color:var(--dsw-alias-label-primary)}.LBuOzG_refresh:focus-visible{outline:2px solid var(--dsw-alias-brand-primary);outline-offset:1px}.LBuOzG_status,.LBuOzG_hint,.LBuOzG_error{margin:0;font-size:12px;line-height:1.6}.LBuOzG_status,.LBuOzG_hint{color:var(--dsw-alias-label-tertiary)}.LBuOzG_error{color:var(--dsw-alias-label-error)}.LBuOzG_group{border-top:.5px solid var(--dsw-alias-border-l2);flex-direction:column;gap:10px;padding-top:16px;display:flex}.LBuOzG_groupTitle{color:var(--dsw-alias-label-primary);align-items:baseline;gap:8px;margin:0;font-size:13px;font-weight:600;display:flex}.LBuOzG_count{color:var(--dsw-alias-label-tertiary);font-variant-numeric:tabular-nums;font-size:11px;font-weight:400}.LBuOzG_rows{grid-template-columns:max-content minmax(0,1fr);align-items:baseline;gap:7px 20px;margin:0;display:grid}.LBuOzG_row{display:contents}.LBuOzG_label{color:var(--dsw-alias-label-tertiary);white-space:nowrap;font-size:12px}.LBuOzG_value{min-width:0;color:var(--dsw-alias-label-primary);font-variant-numeric:tabular-nums;align-items:baseline;gap:8px;margin:0;font-size:12px;display:flex}.LBuOzG_calm,.LBuOzG_busy{white-space:nowrap;border-radius:6px;padding:1px 6px;font-size:11px}.LBuOzG_calm{color:var(--dsw-alias-label-tertiary);background:var(--dsw-alias-bg-layer-2)}.LBuOzG_busy{color:var(--dsw-alias-label-primary);border:.5px solid var(--dsw-alias-border-l4);background:var(--dsw-alias-bg-layer-3)}.LBuOzG_failures{gap:6px;margin:0;padding:0;list-style:none;display:grid}.LBuOzG_failure{background:var(--dsw-alias-bg-layer-2);border-radius:8px;gap:2px;padding:8px 10px;display:grid}.LBuOzG_failureKind{color:var(--dsw-alias-label-primary);font-size:12px}.LBuOzG_failureError{color:var(--dsw-alias-label-tertiary);overflow-wrap:anywhere;font-size:11px;line-height:1.5}.LBuOzG_entries{flex-direction:column;gap:8px;margin:0;padding:0;list-style:none;display:flex}.LBuOzG_entry{border:.5px solid var(--dsw-alias-border-l2);background:var(--dsw-alias-bg-layer-2);border-radius:10px;overflow:hidden}.LBuOzG_entryHead{appearance:none;width:100%;color:inherit;cursor:pointer;font:inherit;text-align:left;background:0 0;border:0;justify-content:space-between;align-items:baseline;gap:12px;padding:8px 12px;display:flex}.LBuOzG_entryHead:hover{background:var(--dsw-alias-bg-layer-3)}.LBuOzG_entryHead:focus-visible{outline:2px solid var(--dsw-alias-brand-primary);outline-offset:-2px}.LBuOzG_entryName{min-width:0;color:var(--dsw-alias-label-secondary);font-family:var(--dsw-font-family-mono,ui-monospace, SFMono-Regular, Menlo, monospace);text-overflow:ellipsis;white-space:nowrap;font-size:11px;overflow:hidden}.LBuOzG_entryMeta{flex:none;align-items:baseline;gap:8px;display:flex}.LBuOzG_badge{background:var(--dsw-alias-bg-layer-1);color:var(--dsw-alias-label-tertiary);white-space:nowrap;border-radius:6px;padding:1px 6px;font-size:11px}.LBuOzG_entryTime{color:var(--dsw-alias-label-quaternary);font-variant-numeric:tabular-nums;white-space:nowrap;font-size:11px}.LBuOzG_entryToggle{color:var(--dsw-alias-label-tertiary);white-space:nowrap;font-size:11px}.LBuOzG_entryBody{border-top:.5px solid var(--dsw-alias-border-l2);overflow-wrap:anywhere;padding:10px 12px;font-size:13px;line-height:1.65}.LBuOzG_entryPreview{color:var(--dsw-alias-label-tertiary);text-overflow:ellipsis;white-space:nowrap;margin:0;padding:0 12px 10px;font-size:12px;line-height:1.5;overflow:hidden}.LBuOzG_hint{border-top:.5px solid var(--dsw-alias-border-l2);padding-top:12px}";
+		const css = ".LBuOzG_panel{box-sizing:border-box;width:100%;height:100%;min-height:0;padding:16px;padding-bottom:calc(var(--dsh-composer-height,152px) + 16px);color:var(--dsw-alias-label-primary);background:var(--dsw-alias-bg-layer-1);flex-direction:column;align-items:center;display:flex;overflow-y:auto}.LBuOzG_column{flex-direction:column;gap:20px;width:100%;min-width:0;max-width:880px;display:flex}.LBuOzG_head{justify-content:space-between;align-items:baseline;gap:12px;display:flex}.LBuOzG_title{color:var(--dsw-alias-label-primary);margin:0;font-size:15px;font-weight:600;line-height:1.4}.LBuOzG_headMeta{align-items:center;gap:10px;display:flex}.LBuOzG_updated{color:var(--dsw-alias-label-tertiary);font-size:12px}.LBuOzG_refresh{appearance:none;border:.5px solid var(--dsw-alias-border-l4);color:var(--dsw-alias-label-secondary);cursor:pointer;font:inherit;background:0 0;border-radius:8px;padding:2px 8px;font-size:12px}.LBuOzG_refresh:hover{border-color:var(--dsw-alias-label-dimmed);color:var(--dsw-alias-label-primary)}.LBuOzG_refresh:focus-visible{outline:2px solid var(--dsw-alias-brand-primary);outline-offset:1px}.LBuOzG_status,.LBuOzG_hint,.LBuOzG_error,.LBuOzG_notice{margin:0;font-size:12px;line-height:1.6}.LBuOzG_status,.LBuOzG_hint{color:var(--dsw-alias-label-tertiary)}.LBuOzG_error{color:var(--dsw-alias-label-error)}.LBuOzG_notice{color:var(--dsw-alias-label-secondary)}.LBuOzG_group{border-top:.5px solid var(--dsw-alias-border-l2);flex-direction:column;gap:10px;padding-top:16px;display:flex}.LBuOzG_groupTitle{color:var(--dsw-alias-label-primary);align-items:baseline;gap:8px;margin:0;font-size:13px;font-weight:600;display:flex}.LBuOzG_count{color:var(--dsw-alias-label-tertiary);font-variant-numeric:tabular-nums;font-size:11px;font-weight:400}.LBuOzG_rows{grid-template-columns:max-content minmax(0,1fr);align-items:baseline;gap:7px 20px;margin:0;display:grid}.LBuOzG_row{display:contents}.LBuOzG_label{color:var(--dsw-alias-label-tertiary);white-space:nowrap;font-size:12px}.LBuOzG_value{min-width:0;color:var(--dsw-alias-label-primary);font-variant-numeric:tabular-nums;align-items:baseline;gap:8px;margin:0;font-size:12px;display:flex}.LBuOzG_calm,.LBuOzG_busy{white-space:nowrap;border-radius:6px;padding:1px 6px;font-size:11px}.LBuOzG_calm{color:var(--dsw-alias-label-tertiary);background:var(--dsw-alias-bg-layer-2)}.LBuOzG_busy{color:var(--dsw-alias-label-primary);border:.5px solid var(--dsw-alias-border-l4);background:var(--dsw-alias-bg-layer-3)}.LBuOzG_summarize{appearance:none;border:.5px solid var(--dsw-alias-border-l4);color:var(--dsw-alias-label-secondary);cursor:pointer;font:inherit;white-space:nowrap;background:0 0;border-radius:6px;padding:1px 8px;font-size:11px}.LBuOzG_summarize:hover:enabled{border-color:var(--dsw-alias-label-dimmed);color:var(--dsw-alias-label-primary)}.LBuOzG_summarize:focus-visible{outline:2px solid var(--dsw-alias-brand-primary);outline-offset:1px}.LBuOzG_summarize:disabled{border-color:var(--dsw-alias-border-l2);color:var(--dsw-alias-label-dimmed);cursor:default}.LBuOzG_failures{gap:6px;margin:0;padding:0;list-style:none;display:grid}.LBuOzG_failure{background:var(--dsw-alias-bg-layer-2);border-radius:8px;gap:2px;padding:8px 10px;display:grid}.LBuOzG_failureKind{color:var(--dsw-alias-label-primary);font-size:12px}.LBuOzG_failureError{color:var(--dsw-alias-label-tertiary);overflow-wrap:anywhere;font-size:11px;line-height:1.5}.LBuOzG_entries{flex-direction:column;gap:8px;margin:0;padding:0;list-style:none;display:flex}.LBuOzG_entry{border:.5px solid var(--dsw-alias-border-l2);background:var(--dsw-alias-bg-layer-2);border-radius:10px;overflow:hidden}.LBuOzG_entryHead{appearance:none;width:100%;color:inherit;cursor:pointer;font:inherit;text-align:left;background:0 0;border:0;justify-content:space-between;align-items:baseline;gap:12px;padding:8px 12px;display:flex}.LBuOzG_entryHead:hover{background:var(--dsw-alias-bg-layer-3)}.LBuOzG_entryHead:focus-visible{outline:2px solid var(--dsw-alias-brand-primary);outline-offset:-2px}.LBuOzG_entryName{min-width:0;color:var(--dsw-alias-label-secondary);font-family:var(--dsw-font-family-mono,ui-monospace, SFMono-Regular, Menlo, monospace);text-overflow:ellipsis;white-space:nowrap;font-size:11px;overflow:hidden}.LBuOzG_entryMeta{flex:none;align-items:baseline;gap:8px;display:flex}.LBuOzG_badge{background:var(--dsw-alias-bg-layer-1);color:var(--dsw-alias-label-tertiary);white-space:nowrap;border-radius:6px;padding:1px 6px;font-size:11px}.LBuOzG_entryTime{color:var(--dsw-alias-label-quaternary);font-variant-numeric:tabular-nums;white-space:nowrap;font-size:11px}.LBuOzG_entryToggle{color:var(--dsw-alias-label-tertiary);white-space:nowrap;font-size:11px}.LBuOzG_entryBody{border-top:.5px solid var(--dsw-alias-border-l2);overflow-wrap:anywhere;padding:10px 12px;font-size:13px;line-height:1.65}.LBuOzG_entryPreview{color:var(--dsw-alias-label-tertiary);text-overflow:ellipsis;white-space:nowrap;margin:0;padding:0 12px 10px;font-size:12px;line-height:1.5;overflow:hidden}.LBuOzG_hint{border-top:.5px solid var(--dsw-alias-border-l2);padding-top:12px}";
 		const tagId = "dsh-hypatia-auto-memory/MemoryView.module.css";
 		if (typeof document !== "undefined" && document.querySelector("style[data-plugin-css=" + JSON.stringify(tagId) + "]") === null) {
 			const tag = document.createElement("style");
@@ -1566,11 +1657,13 @@ window.__ModuleLoader__.load({
 			"headMeta": "LBuOzG_headMeta",
 			"hint": "LBuOzG_hint",
 			"label": "LBuOzG_label",
+			"notice": "LBuOzG_notice",
 			"panel": "LBuOzG_panel",
 			"refresh": "LBuOzG_refresh",
 			"row": "LBuOzG_row",
 			"rows": "LBuOzG_rows",
 			"status": "LBuOzG_status",
+			"summarize": "LBuOzG_summarize",
 			"title": "LBuOzG_title",
 			"updated": "LBuOzG_updated",
 			"value": "LBuOzG_value"
@@ -1598,6 +1691,48 @@ window.__ModuleLoader__.load({
 		*/
 		/** How often the tab re-reads the status half while it is on screen. */
 		const POLL_MS = 5e3;
+		/**
+		* Render the Host's answer to one request.
+		*
+		* "Nothing to do" and "already queued" are not failures and do not read as one:
+		* the request was answered truthfully. Only a refusal — the feature is off, the
+		* route is missing, the session is gone — is shown as an error.
+		*/
+		function noticeFor(result, t) {
+			if (result.queued) return {
+				kind: "ok",
+				text: t("memorySummarizeQueued", {
+					from: String(result.fromSeq),
+					to: String(result.toSeq)
+				})
+			};
+			switch (result.reason) {
+				case SUMMARIZE_REASON.empty: return {
+					kind: "ok",
+					text: t("memorySummarizeEmpty")
+				};
+				case SUMMARIZE_REASON.busy: return {
+					kind: "ok",
+					text: t("memorySummarizeBusy")
+				};
+				case SUMMARIZE_REASON.disabled: return {
+					kind: "error",
+					text: t("memorySummarizeDisabled")
+				};
+				case SUMMARIZE_REASON.unavailable: return {
+					kind: "error",
+					text: t("memorySummarizeUnavailable")
+				};
+				case SUMMARIZE_REASON.unknownSession: return {
+					kind: "error",
+					text: t("memorySummarizeUnknown")
+				};
+				default: return {
+					kind: "error",
+					text: t("memorySummarizeUnknownReason", { reason: result.reason })
+				};
+			}
+		}
 		/** Local wall-clock stamp for the freshness line. */
 		function formatTime(epochMs) {
 			if (!Number.isFinite(epochMs) || epochMs <= 0) return "—";
@@ -1664,10 +1799,14 @@ window.__ModuleLoader__.load({
 				})]
 			});
 		}
-		function MemoryView({ sessionId, fetch, t }) {
+		function MemoryView({ sessionId, fetch, summarize, t }) {
 			const [payload, setPayload] = (0, react.useState)(void 0);
 			const [loading, setLoading] = (0, react.useState)(true);
 			const [error, setError] = (0, react.useState)("");
+			/** True while the Host is being asked to queue a consolidation. */
+			const [summarizing, setSummarizing] = (0, react.useState)(false);
+			/** The last explicit request's answer, cleared when the session switches. */
+			const [notice, setNotice] = (0, react.useState)(void 0);
 			/**
 			* The entries the reader opened, by name. Absent means closed, which is the
 			* default: a toggle survives the poll that replaces the payload, and an entry
@@ -1716,6 +1855,7 @@ window.__ModuleLoader__.load({
 				setPayload(void 0);
 				setOverrides({});
 				setContentAt(void 0);
+				setNotice(void 0);
 				setLoading(true);
 				load(true);
 			}, [load, sessionId]);
@@ -1741,6 +1881,39 @@ window.__ModuleLoader__.load({
 					[name]: !open
 				}));
 			}, []);
+			/**
+			* Ask the Host to consolidate this session now.
+			*
+			* Only queues: the summary is written in the background, so the answer says
+			* what was accepted rather than what was written. A queued request refreshes
+			* the status so the "behind" figure catches up with the next poll; the
+			* watermark watch above then re-reads the shelf when consolidation lands.
+			*/
+			const onSummarize = (0, react.useCallback)(() => {
+				setSummarizing(true);
+				setNotice(void 0);
+				(async () => {
+					try {
+						const result = await summarize(sessionId);
+						if (activeSession.current !== sessionId) return;
+						setNotice(noticeFor(result, t));
+						if (result.queued) load(false);
+					} catch (failure) {
+						if (activeSession.current !== sessionId) return;
+						setNotice({
+							kind: "error",
+							text: t("memorySummarizeFailed", { message: failure instanceof Error ? failure.message : String(failure) })
+						});
+					} finally {
+						if (activeSession.current === sessionId) setSummarizing(false);
+					}
+				})();
+			}, [
+				load,
+				sessionId,
+				summarize,
+				t
+			]);
 			const session = payload?.session;
 			const content = payload?.content;
 			const summaries = content?.summaries ?? [];
@@ -1790,6 +1963,11 @@ window.__ModuleLoader__.load({
 							role: "status",
 							children: t("memoryLoadFailed", { message: error })
 						}) : null,
+						notice !== void 0 ? /* @__PURE__ */ (0, react_jsx_runtime.jsx)("p", {
+							className: notice.kind === "ok" ? MemoryView_module_css_default.notice : MemoryView_module_css_default.error,
+							role: "status",
+							children: notice.text
+						}) : null,
 						loading && payload === void 0 ? /* @__PURE__ */ (0, react_jsx_runtime.jsx)("p", {
 							className: MemoryView_module_css_default.status,
 							children: t("memoryLoading")
@@ -1822,10 +2000,21 @@ window.__ModuleLoader__.load({
 											children: t("memoryConsolidated")
 										}), /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("dd", {
 											className: MemoryView_module_css_default.value,
-											children: [t("memorySeqValue", { seq: String(session.consolidatedSeq) }), /* @__PURE__ */ (0, react_jsx_runtime.jsx)("span", {
-												className: session.caughtUp ? MemoryView_module_css_default.calm : MemoryView_module_css_default.busy,
-												children: session.caughtUp ? t("memoryCaughtUp") : t("memoryBehind", { behind: String(consolidationGap(session)) })
-											})]
+											children: [
+												t("memorySeqValue", { seq: String(session.consolidatedSeq) }),
+												/* @__PURE__ */ (0, react_jsx_runtime.jsx)("span", {
+													className: session.caughtUp ? MemoryView_module_css_default.calm : MemoryView_module_css_default.busy,
+													children: session.caughtUp ? t("memoryCaughtUp") : t("memoryBehind", { behind: String(consolidationGap(session)) })
+												}),
+												/* @__PURE__ */ (0, react_jsx_runtime.jsx)("button", {
+													type: "button",
+													className: MemoryView_module_css_default.summarize,
+													disabled: summarizing || !canSummarize(session),
+													title: t("memorySummarizeHint"),
+													onClick: onSummarize,
+													children: summarizing ? t("memorySummarizing") : t("memorySummarize")
+												})
+											]
 										})]
 									}),
 									/* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
@@ -2146,7 +2335,10 @@ window.__ModuleLoader__.load({
 				order: 20,
 				locale: NS,
 				label: () => t("viewMemory"),
-				inject: () => ({ fetch: fetchMemory })
+				inject: () => ({
+					fetch: fetchMemory,
+					summarize: summarizeMemory
+				})
 			}, MemoryView));
 			ctx.effect(() => () => {
 				unregister();