dsh-decision-layer 0.5.6 → 0.6.1

package/README.en.md

@@ -4,7 +4,7 @@
 
 `dsh-decision-layer` adds structured, explicitly scoped decisions to the DeepSeek Harness (DSH) agent loop, backed by a pluggable adjudication backend. Dangerous-call gating, output self-check, tool narrowing, and loop prevention hook into the agent loop as automatic interventions.
 
-> **0.5.5 is a preview release.** The plugin works, but how much real value the adjudication interventions add is still being explored — every threshold is an unvalidated heuristic default. Treat it as something to observe, not a proven guarantee of impact. See [ROADMAP.md](<ROADMAP.md>) for scope and progress.
+> **0.6.1 is a preview release.** The plugin works, but how much real value the adjudication interventions add is still being explored — every threshold is an unvalidated heuristic default. Treat it as something to observe, not a proven guarantee of impact. See [ROADMAP.md](<ROADMAP.md>) for scope and progress.
 
 ## Installation
 
@@ -46,7 +46,8 @@ Restart `dsh web` and refresh after installing or updating: the host and client
 - **Decision-analysis view** — an in-session "Decision analysis" tab (`conversation.view`, alongside chat and trajectory, naturally scoped per session) that reads the persisted log read-only and shows a process profile (per-point attempts and outcome distribution, mean self-check score), a quality-trend threshold backtest, and a decision-accuracy summary, and lets you rate each decision correct / wrong / unsure. Ratings share one source with the intervention panel: a rating on either surface writes to the same log, keyed by decision id, latest wins. Read-only over logs, append-only for annotations; it changes no decision behavior.
 - **Per-feature switches** — the config page has an independent switch for the danger gate, output self-check, and tool narrowing, all on by default; turning one off drops that intervention. The loop guard is not covered by these switches.
 - **Persisted decision log** — beyond the in-memory panel, decisions are written in full per session to `~/.config/dsh-decision-layer/logs` for research. Files roll by running-instance port and date (`decisions-<port>-YYYY-MM-DD.jsonl`), are batched, and retained for 30 days. Writing is best-effort: a failed flush drops that batch and never breaks the decision path.
+- **Persisted session metrics** — the panel's live metrics (dock count, per-decision-point cards, recent decision log) no longer reset to zero after a restart. Each session's live state is mirrored, keyed by session id (not port), to `~/.config/dsh-decision-layer/state/<sessionId>.json`, written debounced and atomically on every change and retained for 30 days. A resumed session restores from that snapshot; if it has no snapshot yet but has persisted log history (a session predating this mechanism, or whose snapshot was pruned), a seed is reconstructed from the logs across all ports by session id — the one exception is "actual" gate outcomes (observed allow/deny), which are not in the log and resume from zero. Writing is likewise best-effort and never enters the decision path.
 
 ## Safety boundary and development
 
-Automatic intervention only subtracts: the gate only denies, narrowing only removes tools, and neither grants new permissions. The gate defers to native DSH approval on backend failure rather than allowing; self-check, narrowing, and loop-guard errors skip intervention. The redacted summary sent to the backend carries only tool name and command/path with secret redaction — never file content. Node.js `>=20.11`; `npm test` and `npm run build:client` run local checks. Rebuild and commit `lib/client.js` with any client change. 0.5.5 is a preview: the interventions work, but their real value and thresholds are still being explored — feedback on misjudgments and feel observed in the decision log is welcome.
+Automatic intervention only subtracts: the gate only denies, narrowing only removes tools, and neither grants new permissions. The gate defers to native DSH approval on backend failure rather than allowing; self-check, narrowing, and loop-guard errors skip intervention. The redacted summary sent to the backend carries only tool name and command/path with secret redaction — never file content. Node.js `>=20.11`; `npm test` and `npm run build:client` run local checks. Rebuild and commit `lib/client.js` with any client change. 0.6.1 is a preview: the interventions work, but their real value and thresholds are still being explored — feedback on misjudgments and feel observed in the decision log is welcome.

package/README.md

@@ -4,7 +4,7 @@
 
 DeepSeek Harness（DSH）的结构化裁决插件。它把有明确判断标准的问题交给同协议的裁决后端，供 agent 在需要时使用，并在 agent loop 上接入危险门控、产出自检、工具收窄和防循环等自动介入。
 
-> **0.5.5 是体验版。** 插件功能已可用，但裁决介入能带来多少实际价值仍在探索中——各决策点的阈值都是未经验证的启发式默认值，建议先以观察心态体验，别当成经过验证的效果保证。功能与后续进度以 [ROADMAP.md](<ROADMAP.md>) 为准。
+> **0.6.1 是体验版。** 插件功能已可用，但裁决介入能带来多少实际价值仍在探索中——各决策点的阈值都是未经验证的启发式默认值，建议先以观察心态体验，别当成经过验证的效果保证。功能与后续进度以 [ROADMAP.md](<ROADMAP.md>) 为准。
 
 ## 安装
 
@@ -46,6 +46,7 @@ dsh plugin --profile web add file:/绝对路径/dsh-decision-layer
 - **决策分析页**：会话内「决策分析」tab（`conversation.view`，与对话/轨迹平级、天然按会话隔离），基于已落盘日志做只读聚合，展示过程画像（各决策点触发数与结果分布、自检平均分）、质量趋势阈值回测、判断准确度汇总，并可对每条决策标注「判对 / 判错 / 说不准」。标注与介入面板同源：任一处标注都写入同一份日志、按决策 id 关联、取最新。只读日志、只追加标注，不改任何决策行为。
 - **决策点开关**：详情页配置里，危险门控、产出自检、工具收窄各有独立开关，默认全开；关掉某个决策点就不再对应地介入。防循环不在此范围。
 - **决策日志落盘**：决策记录在内存面板之外，还按会话全量落盘到 `~/.config/dsh-decision-layer/logs`，供研究回看。文件按运行实例端口和日期滚动切分（`decisions-<端口>-YYYY-MM-DD.jsonl`），批量写入，保留 30 天。写盘为尽力而为，失败只丢当批、不影响决策路径。
+- **会话指标持久化**：面板的实时指标（dock 计数、各决策点卡片、最近决策日志）在重启后不再归零。每个会话的实时状态按会话 id（非端口）另存一份快照到 `~/.config/dsh-decision-layer/state/<会话id>.json`，每次计数变化防抖写盘、原子落盘，保留 30 天。同一会话恢复时优先读该快照续算；若尚无快照但有历史决策日志（如早于本机制、或快照已被清理的会话），则跨全部端口按会话 id 从日志重建种子续算——唯一例外是「实际结果」（gate 观测到的放行 / 拒绝）无法从日志重建，重启后从零重新累计。写盘同为尽力而为，失败绝不进入决策路径。
 
 ## 安全边界
 
@@ -53,4 +54,4 @@ dsh plugin --profile web add file:/绝对路径/dsh-decision-layer
 
 ## 开发
 
-服务端使用 Node.js `>=20.11`（`.mjs`，无需构建）；客户端用 TypeScript + esbuild 构建。`npm test` 跑本地测试，`npm run build:client` 生成 `lib/client.js`。改动客户端后需重建并连同 `lib/client.js` 一起提交，否则 GitHub 安装拿到的是旧 bundle。0.5.5 为体验版：介入能力已可用，但实际价值与阈值仍在探索，欢迎反馈决策日志观察到的误判与体感。
+服务端使用 Node.js `>=20.11`（`.mjs`，无需构建）；客户端用 TypeScript + esbuild 构建。`npm test` 跑本地测试，`npm run build:client` 生成 `lib/client.js`。改动客户端后需重建并连同 `lib/client.js` 一起提交，否则 GitHub 安装拿到的是旧 bundle。0.6.1 为体验版：介入能力已可用，但实际价值与阈值仍在探索，欢迎反馈决策日志观察到的误判与体感。

package/lib/client.js

@@ -183,7 +183,10 @@ var dictionaries = {
     analysisAccuracy: "\u5224\u65AD\u51C6\u786E\u5EA6",
     analysisAccuracyEmpty: "\u5C1A\u672A\u6807\u6CE8\u4EFB\u4F55\u51B3\u7B56\u3002\u5728\u4E0B\u65B9\u51B3\u7B56\u5217\u8868\u9010\u6761\u6807\u6CE8\u300C\u5224\u5BF9 / \u5224\u9519 / \u8BF4\u4E0D\u51C6\u300D\u540E\uFF0C\u8FD9\u91CC\u7ED9\u51FA\u6C47\u603B\u3002",
     analysisLogNote: "\u6807\u6CE8\u5728\u6B64\u4E0E\u4ECB\u5165\u9762\u677F\u540C\u6E90\uFF1A\u4EFB\u4E00\u5904\u6807\u6CE8\u90FD\u5199\u5165\u540C\u4E00\u4EFD\u65E5\u5FD7\u3001\u6309\u51B3\u7B56 id \u5173\u8054\u3001\u53D6\u6700\u65B0\u3002",
-    analysisLogTruncated: "\u672C\u4F1A\u8BDD\u6682\u65E0\u53EF\u5C55\u793A\u7684\u51B3\u7B56\u8BB0\u5F55\uFF08\u5185\u5B58\u65E5\u5FD7\u53EF\u80FD\u5DF2\u6EDA\u52A8\u6E05\u7406\uFF09\u3002"
+    analysisLogTruncated: "\u672C\u4F1A\u8BDD\u6682\u65E0\u53EF\u5C55\u793A\u7684\u51B3\u7B56\u8BB0\u5F55\u3002",
+    pagerPrev: "\u4E0A\u4E00\u9875",
+    pagerNext: "\u4E0B\u4E00\u9875",
+    pagerStatus: "\u7B2C {page}/{pages} \u9875 \xB7 \u5171 {total} \u6761"
   },
   en: {
     summary: "A danger-call gate, output self-check, and loop guard driven by a pluggable adjudication model.",
@@ -335,7 +338,10 @@ var dictionaries = {
     analysisAccuracy: "Decision accuracy",
     analysisAccuracyEmpty: "No decisions rated yet. Rate rows below as correct / wrong / unsure and a summary appears here.",
     analysisLogNote: "Ratings here share one source with the intervention panel: a rating on either surface writes to the same log, keyed by decision id, latest wins.",
-    analysisLogTruncated: "No decision rows to show for this session (the in-memory log may have rolled over)."
+    analysisLogTruncated: "No decision rows to show for this session.",
+    pagerPrev: "Prev",
+    pagerNext: "Next",
+    pagerStatus: "Page {page}/{pages} \xB7 {total} total"
   }
 };
 
@@ -931,9 +937,11 @@ function SessionPanel({ sessionId, t }) {
 // src/client/analysis-view.tsx
 var import_react3 = require("react");
 var import_jsx_runtime4 = require("react/jsx-runtime");
+var LOG_PAGE_SIZE = 100;
 function AnalysisView({ sessionId, t }) {
   const [analysis, setAnalysis] = (0, import_react3.useState)(null);
-  const [log, setLog] = (0, import_react3.useState)([]);
+  const [rows, setRows] = (0, import_react3.useState)(null);
+  const [logPage, setLogPage] = (0, import_react3.useState)(1);
   const [loaded, setLoaded] = (0, import_react3.useState)(false);
   const [message, setMessage] = (0, import_react3.useState)("");
   const { ratings, seed, annotate } = useAnnotations(sessionId, () => setMessage(t("annotateFailed")));
@@ -941,23 +949,31 @@ function AnalysisView({ sessionId, t }) {
     let alive = true;
     setMessage("");
     setLoaded(false);
-    void Promise.allSettled([
-      request(`logs?sessionId=${encodeURIComponent(sessionId)}`).then((value) => {
-        if (alive) {
-          setAnalysis(value);
-          seed(value);
-        }
-      }),
-      request(`log?sessionId=${encodeURIComponent(sessionId)}`).then((value) => {
-        if (alive) setLog(value.entries);
-      })
-    ]).finally(() => {
+    setLogPage(1);
+    setRows(null);
+    void request(`logs?sessionId=${encodeURIComponent(sessionId)}`).then((value) => {
+      if (alive) {
+        setAnalysis(value);
+        seed(value);
+      }
+    }).catch(() => {
+    }).finally(() => {
       if (alive) setLoaded(true);
     });
     return () => {
       alive = false;
     };
   }, [sessionId, seed]);
+  (0, import_react3.useEffect)(() => {
+    let alive = true;
+    void request(`logrows?sessionId=${encodeURIComponent(sessionId)}&page=${logPage}&pageSize=${LOG_PAGE_SIZE}`).then((value) => {
+      if (alive) setRows(value);
+    }).catch(() => {
+    });
+    return () => {
+      alive = false;
+    };
+  }, [sessionId, logPage]);
   const profile = analysis?.profile;
   const backtest = analysis?.trendBacktest;
   const annotations = analysis?.annotations;
@@ -1021,8 +1037,13 @@ function AnalysisView({ sessionId, t }) {
       ] }),
       /* @__PURE__ */ (0, import_jsx_runtime4.jsxs)("section", { className: "decision-analysis-section", children: [
         /* @__PURE__ */ (0, import_jsx_runtime4.jsx)("h3", { children: t("log") }),
-        log.length === 0 ? /* @__PURE__ */ (0, import_jsx_runtime4.jsx)("p", { className: "decision-empty", role: "status", children: t("analysisLogTruncated") }) : /* @__PURE__ */ (0, import_jsx_runtime4.jsxs)(import_jsx_runtime4.Fragment, { children: [
-          /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(DecisionLogList, { entries: log, ratings, onRate: (id, rating) => void annotate(id, rating), t }),
+        !rows || rows.total === 0 ? /* @__PURE__ */ (0, import_jsx_runtime4.jsx)("p", { className: "decision-empty", role: "status", children: t("analysisLogTruncated") }) : /* @__PURE__ */ (0, import_jsx_runtime4.jsxs)(import_jsx_runtime4.Fragment, { children: [
+          /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(DecisionLogList, { entries: rows.entries, ratings, onRate: (id, rating) => void annotate(id, rating), t, newestFirst: false }),
+          rows.pages > 1 && /* @__PURE__ */ (0, import_jsx_runtime4.jsxs)("nav", { className: "decision-pager", "aria-label": t("log"), children: [
+            /* @__PURE__ */ (0, import_jsx_runtime4.jsx)("button", { type: "button", disabled: rows.page <= 1, onClick: () => setLogPage((page) => Math.max(1, page - 1)), children: t("pagerPrev") }),
+            /* @__PURE__ */ (0, import_jsx_runtime4.jsx)("span", { className: "decision-pager-status", children: t("pagerStatus", { page: rows.page, pages: rows.pages, total: rows.total }) }),
+            /* @__PURE__ */ (0, import_jsx_runtime4.jsx)("button", { type: "button", disabled: rows.page >= rows.pages, onClick: () => setLogPage((page) => page + 1), children: t("pagerNext") })
+          ] }),
           /* @__PURE__ */ (0, import_jsx_runtime4.jsx)("p", { className: "decision-muted decision-analysis-note", children: t("analysisLogNote") })
         ] })
       ] })
@@ -1566,13 +1587,13 @@ var css = `
 .decision-dot-deny{background:#c0392b}
 .decision-card-foot{display:flex;justify-content:space-between;gap:1rem;margin-top:.7rem;padding-top:.6rem;border-top:1px solid var(--dsw-alias-border-l2,#eef1f3);font-size:.76rem;color:var(--dsw-alias-label-secondary,#59636e)}
 .decision-card-foot b{color:var(--dsw-alias-label-primary,#202124);font-variant-numeric:tabular-nums;margin-left:.3rem}
-.decision-card-stats{display:flex;gap:.6rem}
-.decision-stat{flex:1 1 0;display:flex;flex-direction:column;align-items:center;gap:.2rem;padding:.5rem .3rem;border-radius:10px;background:var(--dsw-alias-bg-layer-1,#f6f8fa)}
-.decision-stat-num{font-size:1.35rem;font-weight:700;line-height:1;font-variant-numeric:tabular-nums;color:var(--dsw-alias-label-primary,#202124)}
+.decision-card-stats{display:grid;grid-auto-flow:column;grid-auto-columns:1fr;gap:.6rem;align-items:stretch}
+.decision-stat{min-width:0;display:flex;flex-direction:column;align-items:center;justify-content:space-between;gap:.2rem;padding:.5rem .3rem;border-radius:10px;background:var(--dsw-alias-bg-layer-1,#f6f8fa)}
+.decision-stat-num{font-size:1.35rem;font-weight:700;line-height:1;white-space:nowrap;font-variant-numeric:tabular-nums;color:var(--dsw-alias-label-primary,#202124)}
 .decision-stat-pct{font-size:.74rem;font-weight:600;line-height:1;color:var(--dsw-alias-label-tertiary,#77818b);font-variant-numeric:tabular-nums}
 .decision-stat-warn{color:#c98a1e}
 .decision-stat-muted{color:var(--dsw-alias-label-tertiary,#9aa5b1)}
-.decision-stat-label{font-size:.72rem;color:var(--dsw-alias-label-secondary,#59636e)}
+.decision-stat-label{font-size:.72rem;line-height:1.25;text-align:center;color:var(--dsw-alias-label-secondary,#59636e)}
 .decision-log{list-style:none;margin:0;padding:0;display:grid;gap:.5rem;max-height:13rem;overflow:auto}
 .decision-log-item{display:flex;align-items:baseline;gap:.6rem;font-size:.8rem;padding-left:.6rem;border-left:2px solid var(--dsw-alias-border-l2,#dce1e6);line-height:1.5}
 .decision-log-item.decision-log-deny{border-left-color:#c0392b}
@@ -1693,9 +1714,16 @@ var css = `
 .decision-analysis-section{border-top:1px solid var(--dsw-alias-border-l2,#eceff1);margin-top:1.1rem;padding-top:1rem}
 .decision-analysis-section>h3{font-size:.92rem;margin:0 0 .6rem}
 .decision-analysis-cards{display:grid;grid-template-columns:repeat(auto-fit,minmax(13rem,1fr));gap:.7rem}
-.decision-analysis-cards .decision-card-stats{flex-wrap:wrap}
 .decision-analysis-trend{max-width:26rem}
 .decision-analysis-note{margin:.5rem 0 0}
+/* The analysis tab's decision log shares the page scroll (no inner scrollbar);
+   the modal panel's .decision-log keeps its own capped scroll via the base rule. */
+.decision-analysis .decision-log{max-height:none;overflow:visible}
+.decision-pager{display:flex;align-items:center;justify-content:center;gap:.8rem;margin-top:.8rem}
+.decision-pager button{border:1px solid var(--dsw-alias-border-l2,#ccd3da);border-radius:7px;background:transparent;color:var(--dsw-alias-label-secondary,#59636e);padding:.3rem .85rem;font:inherit;font-size:.8rem;cursor:pointer}
+.decision-pager button:hover:not(:disabled){background:var(--dsw-alias-bg-layer-1,#f2f4f6);color:var(--dsw-alias-label-primary,#202124)}
+.decision-pager button:disabled{opacity:.45;cursor:default}
+.decision-pager-status{font-size:.8rem;color:var(--dsw-alias-label-secondary,#59636e);font-variant-numeric:tabular-nums}
 @media (prefers-color-scheme:dark){
   .decision-analysis{color:var(--dsw-alias-label-primary,#e6eaee)}
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-decision-layer",
-  "version": "0.5.6",
+  "version": "0.6.1",
   "description": "A structured decision layer for the DeepSeek Harness agent loop: a danger-call gate, output self-check, tool narrowing, and loop guard backed by a pluggable adjudication model.",
   "keywords": [
     "dsh",

package/service/dsh.mjs

@@ -10,7 +10,8 @@ import { createNarrowing } from './narrowing.mjs';
 import { createTaskCompletion } from './task-completion.mjs';
 import { createLoopGuard } from './loop-guard.mjs';
 import { createLogStore } from './log-store.mjs';
-import { analyzeSessionLogs } from './log-analyze.mjs';
+import { createStateStore } from './state-store.mjs';
+import { analyzeSessionLogs, reconstructSessionSeed, listSessionDecisions } from './log-analyze.mjs';
 
 export const name = 'dsh-decision-layer';
 export const inject = ['tools', 'skills'];
@@ -100,7 +101,23 @@ export async function apply(ctx, options = {}) {
   // The research log sink is attached once the web server reveals the instance
   // port (used in the file name); until then decision logs stay in memory only.
   let logStore;
-  const sessions = createSessionState({ onLog: entry => logStore?.append(entry) });
+  // Durable per-session mirror of the live decision counters/log, keyed by
+  // session id (not port), so a resumed session's panel survives an instance
+  // restart instead of resetting to zero. Independent of the JSONL research log.
+  const stateStore = createStateStore();
+  const sessions = createSessionState({
+    onLog: entry => logStore?.append(entry),
+    // Restore a resumed session from its durable snapshot; if it has none yet but
+    // has persisted JSONL decision history (e.g. a session that predates this
+    // persistence, or whose snapshot was pruned), reconstruct a seed from the
+    // logs instead. Logs are read across all ports and filtered by the globally
+    // unique session id, so a changed instance port never orphans the history.
+    loadState: async id => (await stateStore.load(id)) ?? reconstructSessionSeed(id, {
+      trendConfig: (await resolveConfig({ path })).checkSettings,
+    }).catch(() => undefined),
+    persistState: (id, state) => stateStore.save(id, state),
+  });
+  if (typeof ctx.effect === 'function') ctx.effect(() => () => { void stateStore.dispose(); });
   const gate = createDangerGate({
     evaluate: (input, request) => backend.evaluate(input, request),
     sessions,
@@ -185,6 +202,10 @@ export async function apply(ctx, options = {}) {
       const agent = payload?.agent;
       const id = agent?.session?.id;
       const turn = payload?.turn;
+      // Rehydrate this session's persisted counters/log on its first step this
+      // process, before any gate/check/narrow/complete event mutates them, so a
+      // resumed session continues from its saved totals instead of from zero.
+      if (typeof id === 'string') await sessions.ensureLoaded(id);
       if (typeof id === 'string' && Number.isInteger(turn) && await featureOn('narrow')) {
         const state = narrowedTurns.get(id);
         if (!state || state.turn !== turn) {
@@ -240,7 +261,8 @@ export async function apply(ctx, options = {}) {
       port,
       trendConfig: (await resolveConfig({ path })).checkSettings,
     });
-    const unregister = createManagerRoutes({ path, sessions, backend, logStore, analyze, bindHost: web.webServer.host }).map(route => web.webServer.register(route));
+    const listRows = (sessionId, { page, pageSize } = {}) => listSessionDecisions(sessionId, { port, page, pageSize });
+    const unregister = createManagerRoutes({ path, sessions, backend, logStore, analyze, listRows, bindHost: web.webServer.host }).map(route => web.webServer.register(route));
     return () => { unregister.forEach(dispose => dispose()); const store = logStore; logStore = undefined; void store?.dispose(); };
   });
 }

package/service/log-analyze.mjs

@@ -1,4 +1,5 @@
 import { createReadableStream } from './log-read.mjs';
+import { advanceRun, severityOf } from './quality-trend.mjs';
 
 // Offline analysis over the persisted decision JSONL logs. Pure aggregation:
 // given a stream of records (decision events + annotation events) for one
@@ -153,3 +154,103 @@ export async function analyzeSessionLogs(sessionId, { dir, port, trendConfig, re
   }
   return analyzeSession(records, trendConfig);
 }
+
+// Reconstruct a live session-state seed (the counter shape session-state keeps,
+// plus the recent decision log) from this session's folded decisions. Used to
+// bridge a restart for a session that has persisted JSONL history but no state
+// snapshot yet, so its panel resumes from its real totals instead of from zero.
+//
+// Faithful for every counter because each feature logs exactly one record per
+// record*() call with the same outcome — with one documented exception:
+// gate.actual (observed tool outcomes) is never logged, so it starts at zero and
+// resumes as new tool results arrive. The check trend run/severity is replayed
+// with the same advanceRun/severityOf semantics the live path uses.
+export function buildSeed(decisions, { maxLog = 50, trendConfig = {} } = {}) {
+  const ordered = [...decisions.values()].filter(record => DECISION_KINDS.has(record.kind)).sort((a, b) => (a.at ?? 0) - (b.at ?? 0));
+  const seed = {
+    attempts: 0, failures: 0,
+    gate: { attempts: 0, failures: 0, ask: 0, deny: 0, allow: 0, actual: { allow: 0, deny: 0, error: 0 } },
+    check: { attempts: 0, failures: 0, low: 0, run: 0, severity: 'normal' },
+    narrow: { attempts: 0, failures: 0, applied: 0, dropped: 0 },
+    complete: { attempts: 0, failures: 0, unsatisfied: 0, satisfied: 0, insufficient: 0, steered: 0 },
+    log: [],
+  };
+  const minConfidence = typeof trendConfig.trendMinConfidence === 'number' ? trendConfig.trendMinConfidence : 0.6;
+  const thresholds = { trendRun: trendConfig.trendRun ?? 3, trendSevereRun: trendConfig.trendSevereRun ?? 5 };
+  let run = 0;
+  for (const record of ordered) {
+    const bucket = seed[record.kind];
+    seed.attempts++;
+    bucket.attempts++;
+    const isError = record.outcome === 'error';
+    if (isError) { seed.failures++; bucket.failures++; }
+    if (record.kind === 'gate') {
+      if (['allow', 'ask', 'deny'].includes(record.outcome)) bucket[record.outcome]++;
+    } else if (record.kind === 'check') {
+      if (!isError) {
+        if (record.outcome === 'low') bucket.low++;
+        // Replay the trend run exactly as recordCheck does: lowScore keys off the
+        // 'low' outcome, confident off the logged confidence vs the threshold.
+        const confident = typeof record.confidence === 'number' && Number.isFinite(record.confidence) && record.confidence >= minConfidence;
+        run = advanceRun(run, { lowScore: record.outcome === 'low', confident });
+      }
+    } else if (record.kind === 'narrow') {
+      if (record.outcome === 'applied') {
+        bucket.applied++;
+        if (Number.isSafeInteger(record.dropped) && record.dropped > 0) bucket.dropped += record.dropped;
+      }
+    } else if (record.kind === 'complete') {
+      if (!isError) {
+        if (Number.isSafeInteger(record.satisfied)) bucket.satisfied += record.satisfied;
+        if (Number.isSafeInteger(record.unsatisfied)) bucket.unsatisfied += record.unsatisfied;
+        if (Number.isSafeInteger(record.insufficient)) bucket.insufficient += record.insufficient;
+        if (record.steered === true) bucket.steered++;
+      }
+    }
+  }
+  seed.check.run = run;
+  seed.check.severity = severityOf(run, thresholds);
+  // The recent-log list: the newest decisions, as plain records (drop sessionId,
+  // which the live log does not carry). Already in the panel-record shape.
+  seed.log = ordered.slice(-maxLog).map(record => { const { sessionId, ...rest } = record; return rest; });
+  return seed;
+}
+
+// Read one session's persisted JSONL and reconstruct its live state seed, or
+// undefined when it has no decision history. Streams files like analyzeSessionLogs.
+export async function reconstructSessionSeed(sessionId, { dir, port, trendConfig, maxLog, readStream = createReadableStream } = {}) {
+  if (typeof sessionId !== 'string' || !sessionId.trim()) return undefined;
+  const records = [];
+  for await (const record of readStream({ dir, port })) {
+    if (!isObject(record)) continue;
+    if (record.sessionId === sessionId) records.push(record);
+  }
+  if (records.length === 0) return undefined;
+  const { decisions } = foldSession(records);
+  if (decisions.size === 0) return undefined;
+  return buildSeed(decisions, { maxLog, trendConfig });
+}
+
+// Read one session's persisted decision rows and return a single newest-first
+// page. Backs the analysis tab's full decision log (the dock panel still shows
+// only the in-memory recent rows). Decisions are folded by id (latest wins) so a
+// re-logged id is not double-counted. Rows carry only the panel fields — tool
+// name, outcome, counts — never gate command/path, which is never logged. The
+// internal sessionId tag is stripped before the row leaves the server.
+export async function listSessionDecisions(sessionId, { dir, port, page = 1, pageSize = 100, readStream = createReadableStream } = {}) {
+  if (typeof sessionId !== 'string' || !sessionId.trim()) throw new Error('Invalid session id');
+  const size = Number.isSafeInteger(pageSize) && pageSize > 0 && pageSize <= 500 ? pageSize : 100;
+  const records = [];
+  for await (const record of readStream({ dir, port })) {
+    if (!isObject(record)) continue;
+    if (record.sessionId === sessionId) records.push(record);
+  }
+  const { decisions } = foldSession(records);
+  const rows = [...decisions.values()].sort((a, b) => (b.at ?? 0) - (a.at ?? 0)); // newest first
+  const total = rows.length;
+  const pages = Math.max(1, Math.ceil(total / size));
+  const current = Math.min(Math.max(1, Number.isSafeInteger(page) ? page : 1), pages);
+  const start = (current - 1) * size;
+  const entries = rows.slice(start, start + size).map(({ sessionId: _sessionId, ...rest }) => rest);
+  return { entries, total, page: current, pageSize: size, pages };
+}

package/service/manager-api.mjs

@@ -37,7 +37,7 @@ async function readBody(req) {
   return value;
 }
 
-export function createManagerRoutes({ path, sessions, backend, logStore, analyze, env = process.env, bindHost = '127.0.0.1' }) {
+export function createManagerRoutes({ path, sessions, backend, logStore, analyze, listRows, env = process.env, bindHost = '127.0.0.1' }) {
   const route = (suffix, methods) => ({ kind: 'exact', path: `${API_PREFIX}/${suffix}`, handler: async (req, res) => {
     if (bindHost !== '127.0.0.1' || !authorizedBrowser(req)) return respond(res, 403, { ok: false, error: 'Local same-origin browser request required' });
     if (!Object.hasOwn(methods, req.method)) return respond(res, 405, { ok: false, error: 'Method not allowed' });
@@ -77,8 +77,8 @@ export function createManagerRoutes({ path, sessions, backend, logStore, analyze
         } catch { return { connected: false, reason: 'unavailable', effectiveUrl }; }
       },
     }),
-    route('metrics', { GET: req => sessions.snapshot(sessionId(req)) }),
-    route('log', { GET: req => ({ entries: sessions.snapshot(sessionId(req)).log ?? [] }) }),
+    route('metrics', { GET: async req => { const id = sessionId(req); await sessions.ensureLoaded?.(id); return sessions.snapshot(id); } }),
+    route('log', { GET: async req => { const id = sessionId(req); await sessions.ensureLoaded?.(id); return { entries: sessions.snapshot(id).log ?? [] }; } }),
     // Read-only analysis over the persisted decision logs for one session. Returns
     // only aggregates and annotation counts — never raw log rows — so gate command
     // / path fragments are not echoed back to the browser.
@@ -90,6 +90,21 @@ export function createManagerRoutes({ path, sessions, backend, logStore, analyze
         catch (error) { if (error?.code === 'BAD_REQUEST') throw error; const wrapped = new Error('analysis failed'); wrapped.code = 'INTERNAL'; throw wrapped; }
       },
     }),
+    // One newest-first page of this session's full persisted decision rows, for
+    // the analysis tab's paginated log. Rows carry only panel fields (tool name,
+    // outcome, counts) — never gate command/path, which is never logged — so this
+    // exposes nothing the recent-rows /log route does not already.
+    route('logrows', {
+      GET: async req => {
+        if (typeof listRows !== 'function') { const error = new Error('log rows unavailable'); error.code = 'BAD_REQUEST'; throw error; }
+        const id = sessionId(req);
+        const params = new URL(req.url ?? '/', 'http://localhost').searchParams;
+        const page = Number.parseInt(params.get('page') ?? '1', 10);
+        const pageSize = Number.parseInt(params.get('pageSize') ?? '100', 10);
+        try { return await listRows(id, { page: Number.isNaN(page) ? 1 : page, pageSize: Number.isNaN(pageSize) ? 100 : pageSize }); }
+        catch (error) { if (error?.code === 'BAD_REQUEST') throw error; const wrapped = new Error('log rows failed'); wrapped.code = 'INTERNAL'; throw wrapped; }
+      },
+    }),
     // Append one annotation event for a decision. Explicit user intent: validated
     // and written immediately; a write failure surfaces as an error, not silence.
     route('annotate', {
@@ -110,9 +125,10 @@ export function createManagerRoutes({ path, sessions, backend, logStore, analyze
       },
     }),
     route('session', {
-      GET: req => sessions.snapshot(sessionId(req)),
+      GET: async req => { const id = sessionId(req); await sessions.ensureLoaded?.(id); return sessions.snapshot(id); },
       PUT: async req => {
         const body = await readBody(req);
+        await sessions.ensureLoaded?.(body.sessionId);
         sessions.setEnabled(body.sessionId, body.enabled);
         return sessions.snapshot(body.sessionId);
       },

package/service/session-state.mjs

@@ -18,11 +18,65 @@ function safeTool(value) {
   return typeof value === 'string' && value.trim() ? value.trim().slice(0, 128) : undefined;
 }
 
-export function createSessionState({ maxSessions = 1024, maxLogEntries = 50, onLog } = {}) {
+const toCount = value => (Number.isSafeInteger(value) && value >= 0 ? value : 0);
+
+// Rebuild a trusted in-memory state from a persisted (untrusted) snapshot. Every
+// counter is coerced into the emptyState() shape with a non-negative-integer
+// guard and the trend severity into its enum, so a stale or tampered file can
+// never inject an out-of-shape value into the live counters. The recent log is
+// kept as plain records (newest-last); callers trim it to the log cap.
+function coerceState(raw) {
+  const state = emptyState();
+  if (!raw || typeof raw !== 'object') return state;
+  if (typeof raw.enabled === 'boolean') state.enabled = raw.enabled;
+  state.attempts = toCount(raw.attempts);
+  state.failures = toCount(raw.failures);
+  const g = raw.gate;
+  if (g && typeof g === 'object') {
+    state.gate.attempts = toCount(g.attempts); state.gate.failures = toCount(g.failures);
+    state.gate.ask = toCount(g.ask); state.gate.deny = toCount(g.deny); state.gate.allow = toCount(g.allow);
+    const a = g.actual;
+    if (a && typeof a === 'object') { state.gate.actual.allow = toCount(a.allow); state.gate.actual.deny = toCount(a.deny); state.gate.actual.error = toCount(a.error); }
+  }
+  const c = raw.check;
+  if (c && typeof c === 'object') {
+    state.check.attempts = toCount(c.attempts); state.check.failures = toCount(c.failures); state.check.low = toCount(c.low);
+    state.check.run = toCount(c.run);
+    state.check.severity = ['normal', 'warn', 'severe'].includes(c.severity) ? c.severity : 'normal';
+  }
+  const n = raw.narrow;
+  if (n && typeof n === 'object') {
+    state.narrow.attempts = toCount(n.attempts); state.narrow.failures = toCount(n.failures);
+    state.narrow.applied = toCount(n.applied); state.narrow.dropped = toCount(n.dropped);
+  }
+  const k = raw.complete;
+  if (k && typeof k === 'object') {
+    state.complete.attempts = toCount(k.attempts); state.complete.failures = toCount(k.failures);
+    state.complete.unsatisfied = toCount(k.unsatisfied); state.complete.satisfied = toCount(k.satisfied);
+    state.complete.insufficient = toCount(k.insufficient); state.complete.steered = toCount(k.steered);
+  }
+  if (Array.isArray(raw.log)) {
+    state.log = raw.log
+      .filter(entry => entry && typeof entry === 'object' && !Array.isArray(entry) && typeof entry.kind === 'string')
+      .map(entry => ({ ...entry }));
+  }
+  return state;
+}
+
+export function createSessionState({ maxSessions = 1024, maxLogEntries = 50, onLog, loadState, persistState } = {}) {
   if (!Number.isSafeInteger(maxSessions) || maxSessions < 1) throw new Error('Invalid session limit');
   if (!Number.isSafeInteger(maxLogEntries) || maxLogEntries < 1) throw new Error('Invalid log limit');
   const sessions = new Map();
   const sink = typeof onLog === 'function' ? onLog : undefined;
+  const load = typeof loadState === 'function' ? loadState : undefined;
+  const persist = typeof persistState === 'function' ? persistState : undefined;
+  // Memoize rehydration per id so a session is seeded from disk at most once per
+  // process. Bounded like `sessions`; dropping a memo entry only risks a
+  // redundant disk read that no-ops (ensureLoaded never clobbers live state).
+  const loaded = new Map();
+  // Mirror the latest live state to the durable store after every mutation.
+  // Best-effort: a persistence fault must never surface in the decision path.
+  const bump = (key, state) => { if (persist) { try { persist(key, state); } catch { /* best effort */ } } };
   // FIFO eviction: when the map is full, drop the oldest-inserted session before
   // admitting a new one (Map preserves insertion order, so the first key is the
   // oldest). This mirrors loop-guard / narrowing and means the store never
@@ -40,9 +94,38 @@ export function createSessionState({ maxSessions = 1024, maxLogEntries = 50, onL
     return state;
   };
   return {
+    // Rehydrate a session's live counters/log from the durable store the first
+    // time it is touched this process, before any new event mutates it — so disk
+    // history and in-process events never double-count. Memoized per id; a no-op
+    // when no loadState was given or the session already has live state. Callers
+    // should await this before the first snapshot/record of a resumed session
+    // (the plugin does so at the turn's first step and in the panel routes).
+    async ensureLoaded(id) {
+      if (!load) return;
+      let key;
+      try { key = sessionKey(id); } catch { return; }
+      const existing = loaded.get(key);
+      if (existing) return existing;
+      const promise = (async () => {
+        if (sessions.has(key)) return; // live events already created state; keep it
+        let raw;
+        try { raw = await load(key); } catch { raw = undefined; }
+        if (!raw) return;
+        if (sessions.has(key)) return; // a concurrent mutation won the race; do not clobber
+        const state = coerceState(raw);
+        if (state.log.length > maxLogEntries) state.log.splice(0, state.log.length - maxLogEntries);
+        if (sessions.size >= maxSessions) sessions.delete(sessions.keys().next().value);
+        sessions.set(key, state);
+      })();
+      if (loaded.size >= maxSessions) loaded.delete(loaded.keys().next().value);
+      loaded.set(key, promise);
+      return promise;
+    },
     setEnabled(id, enabled) {
       if (typeof enabled !== 'boolean') throw new Error('Invalid enabled value');
-      writable(id).enabled = enabled;
+      const state = writable(id);
+      state.enabled = enabled;
+      bump(sessionKey(id), state);
     },
     snapshot(id) {
       const stored = sessions.get(sessionKey(id));
@@ -62,26 +145,32 @@ export function createSessionState({ maxSessions = 1024, maxLogEntries = 50, onL
       state.gate.attempts++;
       if (outcome === 'error') { state.failures++; state.gate.failures++; }
       else state.gate[outcome]++;
+      bump(sessionKey(id), state);
     },
     recordActual(id, outcome) {
       if (!['allow', 'deny', 'error'].includes(outcome)) throw new Error('Invalid actual decision');
-      writable(id).gate.actual[outcome]++;
+      const state = writable(id);
+      state.gate.actual[outcome]++;
+      bump(sessionKey(id), state);
     },
     recordCheck(id, outcome, trend) {
       if (!['ok', 'low', 'error'].includes(outcome)) throw new Error('Invalid self-check outcome');
       const state = writable(id);
       state.attempts++;
       state.check.attempts++;
-      if (outcome === 'error') { state.failures++; state.check.failures++; return; }
-      if (outcome === 'low') state.check.low++;
-      // Advance the quality-trend run over this evaluated score. A good score
-      // resets the run; a high-confidence low score grows it; a low-confidence
-      // low score neither resets nor grows. `trend` carries the per-sample flags
-      // and the configured thresholds; absent trend leaves the run unchanged.
-      if (trend && typeof trend === 'object') {
-        state.check.run = advanceRun(state.check.run, { lowScore: outcome === 'low', confident: trend.confident === true });
-        state.check.severity = severityOf(state.check.run, { trendRun: trend.trendRun, trendSevereRun: trend.trendSevereRun });
+      if (outcome === 'error') { state.failures++; state.check.failures++; }
+      else {
+        if (outcome === 'low') state.check.low++;
+        // Advance the quality-trend run over this evaluated score. A good score
+        // resets the run; a high-confidence low score grows it; a low-confidence
+        // low score neither resets nor grows. `trend` carries the per-sample flags
+        // and the configured thresholds; absent trend leaves the run unchanged.
+        if (trend && typeof trend === 'object') {
+          state.check.run = advanceRun(state.check.run, { lowScore: outcome === 'low', confident: trend.confident === true });
+          state.check.severity = severityOf(state.check.run, { trendRun: trend.trendRun, trendSevereRun: trend.trendSevereRun });
+        }
       }
+      bump(sessionKey(id), state);
     },
     recordNarrow(id, outcome, dropped = 0) {
       if (!['ok', 'applied', 'error'].includes(outcome)) throw new Error('Invalid narrowing outcome');
@@ -93,6 +182,7 @@ export function createSessionState({ maxSessions = 1024, maxLogEntries = 50, onL
         state.narrow.applied++;
         if (Number.isSafeInteger(dropped) && dropped > 0) state.narrow.dropped += dropped;
       }
+      bump(sessionKey(id), state);
     },
     // Task-completion checking. `ok`/`unsatisfied` are real evaluations; `error`
     // is an unevaluated failure counted as a failure, never as "unsatisfied".
@@ -102,11 +192,14 @@ export function createSessionState({ maxSessions = 1024, maxLogEntries = 50, onL
       const state = writable(id);
       state.attempts++;
       state.complete.attempts++;
-      if (outcome === 'error') { state.failures++; state.complete.failures++; return; }
-      if (Number.isSafeInteger(detail.satisfied) && detail.satisfied > 0) state.complete.satisfied += detail.satisfied;
-      if (Number.isSafeInteger(detail.unsatisfied) && detail.unsatisfied > 0) state.complete.unsatisfied += detail.unsatisfied;
-      if (Number.isSafeInteger(detail.insufficient) && detail.insufficient > 0) state.complete.insufficient += detail.insufficient;
-      if (detail.steered === true) state.complete.steered++;
+      if (outcome === 'error') { state.failures++; state.complete.failures++; }
+      else {
+        if (Number.isSafeInteger(detail.satisfied) && detail.satisfied > 0) state.complete.satisfied += detail.satisfied;
+        if (Number.isSafeInteger(detail.unsatisfied) && detail.unsatisfied > 0) state.complete.unsatisfied += detail.unsatisfied;
+        if (Number.isSafeInteger(detail.insufficient) && detail.insufficient > 0) state.complete.insufficient += detail.insufficient;
+        if (detail.steered === true) state.complete.steered++;
+      }
+      bump(sessionKey(id), state);
     },
     log(id, entry) {
       if (entry === null || typeof entry !== 'object' || Array.isArray(entry)) throw new Error('Invalid log entry');
@@ -149,6 +242,7 @@ export function createSessionState({ maxSessions = 1024, maxLogEntries = 50, onL
         }
         try { sink(full); } catch { /* persistence is best effort */ }
       }
+      bump(sessionKey(id), state);
     },
   };
 }

package/service/state-store.mjs

@@ -0,0 +1,100 @@
+import { mkdir, readFile, readdir, rename, rm, stat, writeFile } from 'node:fs/promises';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { randomUUID } from 'node:crypto';
+
+export function stateDir() {
+  return join(homedir(), '.config', 'dsh-decision-layer', 'state');
+}
+
+// A session id is persisted only when it is safe as a single path segment, so a
+// crafted id can never escape the state directory. dsh session ids are
+// `session-<uuid>`, which pass; anything with separators, leading dot, `..`, or
+// an unreasonable length is skipped (that session simply stays in-memory only).
+const SAFE_ID = /^[A-Za-z0-9][A-Za-z0-9._-]{0,199}$/;
+export function safeStateId(id) {
+  return typeof id === 'string' && SAFE_ID.test(id) && !id.includes('..') ? id : undefined;
+}
+
+// Durable per-session mirror of the live decision counters + recent log. One
+// small JSON file per session id (`<id>.json`), written debounced and atomically
+// (unique tmp + rename), pruned by age on an occasional flush. This is separate
+// from the JSONL research log: it exists only so a resumed session's live panel
+// (dock count, metric cards, recent log) survives an instance restart instead of
+// resetting to zero. All IO is best-effort — a failure never throws into the
+// decision path; at worst the panel loses the last few seconds of counters.
+export function createStateStore({ dir = stateDir(), flushIntervalMs = 2000,
+  retentionDays = 30, now = () => Date.now() } = {}) {
+  const pending = new Map(); // id -> latest live state reference awaiting a flush
+  let timer;
+  let flushing = false;
+  let lastPrune = 0;
+
+  const fileFor = id => join(dir, `${id}.json`);
+
+  const writeOne = async (id, state) => {
+    const temporary = join(dir, `${id}.${randomUUID()}.tmp`);
+    try {
+      await writeFile(temporary, `${JSON.stringify({ v: 1, at: now(), state })}\n`, { mode: 0o600, flag: 'wx' });
+      await rename(temporary, fileFor(id));
+    } finally {
+      await rm(temporary, { force: true }).catch(() => {});
+    }
+  };
+
+  const prune = async () => {
+    let names;
+    try { names = await readdir(dir); } catch { return; }
+    const cutoff = now() - retentionDays * 24 * 60 * 60 * 1000;
+    await Promise.all(names.map(async name => {
+      if (!name.endsWith('.json')) return;
+      try {
+        const info = await stat(join(dir, name));
+        if (info.mtimeMs < cutoff) await rm(join(dir, name), { force: true }).catch(() => {});
+      } catch { /* a file vanishing under us is fine */ }
+    }));
+  };
+
+  const flush = async () => {
+    if (flushing || pending.size === 0) return;
+    flushing = true;
+    // Snapshot ids now; each state is JSON.stringify'd at write time so the file
+    // reflects the latest counters, which is exactly what we want.
+    const batch = [...pending.entries()];
+    pending.clear();
+    try {
+      await mkdir(dir, { recursive: true, mode: 0o700 });
+      for (const [id, state] of batch) await writeOne(id, state).catch(() => {});
+      // Prune at most about once per hour of activity, not on every flush.
+      if (now() - lastPrune > 60 * 60 * 1000) { lastPrune = now(); await prune(); }
+    } catch { /* best effort; a dropped flush must never break the decision path */ }
+    finally { flushing = false; }
+  };
+
+  return {
+    // Read a session's persisted state, or undefined when there is no usable file.
+    async load(id) {
+      const safe = safeStateId(id);
+      if (!safe) return undefined;
+      try {
+        const parsed = JSON.parse(await readFile(fileFor(safe), 'utf8'));
+        if (parsed && typeof parsed === 'object' && parsed.state && typeof parsed.state === 'object' && !Array.isArray(parsed.state)) {
+          return parsed.state;
+        }
+      } catch { /* missing or malformed: no seed, start empty */ }
+      return undefined;
+    },
+    // Register the latest live state for a session and schedule a debounced flush.
+    save(id, state) {
+      const safe = safeStateId(id);
+      if (!safe || state === null || typeof state !== 'object') return;
+      pending.set(safe, state);
+      if (!timer) timer = setTimeout(() => { timer = undefined; void flush(); }, flushIntervalMs);
+    },
+    flush,
+    dispose() {
+      if (timer) { clearTimeout(timer); timer = undefined; }
+      return flush();
+    },
+  };
+}