dev-memory-cli 0.22.1 → 0.23.0

package/lib/dev_memory_setup.py

@@ -6,7 +6,7 @@ lazy-inits files on first write. Setup's job is now:
 
   1. Ensure skeleton exists (idempotent).
   2. Scan unsorted.md and present each entry to the user for classification.
-  3. Route user's choices into decisions/progress/risks/glossary/shared-*.
+  3. Route user's choices into decisions/risks/glossary/shared-*.
   4. Mark manifest.setup_completed = true.
 """
 
@@ -92,7 +92,7 @@ def command_init(args):
 # plan.json format:
 # {
 #   "classifications": [
-#     {"entry": "original bullet text", "kind": "decision|progress|next|risk|glossary|source|shared-*|skip"},
+#     {"entry": "original bullet text", "kind": "decision|risk|glossary|source|shared-*|skip"},
 #     ...
 #   ],
 #   "clear_unsorted_on_done": true
@@ -138,7 +138,12 @@ def _apply_classifications(paths, classifications):
         from dev_memory_common import append_to_section
         body = "\n".join(f"- {e}" for e in entries)
         path = paths[file_key]
-        append_to_section(path, section, body)
+        append_to_section(
+            path,
+            section,
+            body,
+            max_entries=20 if file_key.startswith("repo_") else None,
+        )
         tally[f"{file_key}:{section}"] = len(entries)
     return {"applied": tally, "skipped": skipped}
 

package/lib/dev_memory_summary.py

@@ -68,16 +68,26 @@ def _extract_codex(obj):
     }
 
 
-def _iter_core_messages(transcript_path):
+def _iter_core_messages(transcript_path, since_size=0):
     if not transcript_path:
         return []
     path = Path(transcript_path).expanduser()
     if not path.exists():
         return []
     out = []
-    with path.open(encoding="utf-8") as f:
-        for line in f:
-            line = line.strip()
+    with path.open("rb") as f:
+        while True:
+            start = f.tell()
+            raw = f.readline()
+            if not raw:
+                break
+            end = f.tell()
+            if end <= since_size:
+                continue
+            try:
+                line = raw.decode("utf-8").strip()
+            except UnicodeDecodeError:
+                continue
             if not line:
                 continue
             try:
@@ -86,12 +96,16 @@ def _iter_core_messages(transcript_path):
                 continue
             msg = _extract_claude(obj) or _extract_codex(obj)
             if msg:
+                msg["start_offset"] = start
+                msg["end_offset"] = end
                 out.append(msg)
     return out
 
 
 def _truncate(text, max_chars):
     text = (text or "").strip()
+    if not max_chars or max_chars < 0:
+        return text
     if len(text) <= max_chars:
         return text
     return text[: max_chars - 3].rstrip() + "..."
@@ -142,8 +156,8 @@ def _summary_job(job):
 def extract_core_payload(
     job,
     *,
-    max_messages=40,
-    max_message_chars=2000,
+    max_messages=0,
+    max_message_chars=0,
     max_memory_chars=6000,
     since_size=0,
     include_message_metadata=False,
@@ -159,14 +173,9 @@ def extract_core_payload(
         ("repo/decisions.md", repo_dir / "repo" / "decisions.md"),
         ("repo/glossary.md", repo_dir / "repo" / "glossary.md"),
     ]
-    messages = _iter_core_messages(job.get("transcript_path"))
-    if since_size:
-        # JSONL is line-oriented but byte offsets can land mid-line. Keep this
-        # option conservative for now: expose cursor metadata and let workers
-        # use recent-tail until a precise offset reader is needed.
-        pass
+    messages = _iter_core_messages(job.get("transcript_path"), since_size=since_size)
     messages = [m for m in messages if not _is_nonsemantic_user_text(m["text"])]
-    recent = messages[-max_messages:]
+    recent = messages[-max_messages:] if max_messages and max_messages > 0 else messages
     core_messages = []
     for m in recent:
         item = {
@@ -213,10 +222,10 @@ def main():
     sub = parser.add_subparsers(dest="command", required=True)
     p = sub.add_parser("extract-core", help="Extract core transcript messages and current memory for a summary job")
     p.add_argument("job", help="Path to a session-summary pending job JSON")
-    p.add_argument("--max-messages", type=int, default=40)
-    p.add_argument("--max-message-chars", type=int, default=2000)
+    p.add_argument("--max-messages", type=int, default=0, help="0 keeps every semantic message")
+    p.add_argument("--max-message-chars", type=int, default=0, help="0 keeps complete message text")
     p.add_argument("--max-memory-chars", type=int, default=6000)
-    p.add_argument("--since-size", type=int, default=0, help="Reserved cursor hint for future byte-offset extraction")
+    p.add_argument("--since-size", type=int, default=0, help="Read JSONL records ending after this byte offset")
     p.add_argument(
         "--include-message-metadata",
         action="store_true",

package/lib/maintenance/archive.md

@@ -0,0 +1,84 @@
+# 分支记忆归档维护流程
+
+目标是把已完成分支中真正跨分支复用的知识提炼到 repo 共享层，然后归档该分支的记忆目录。归档是破坏性显式动作，必须由用户确认。
+
+## 硬规则
+
+- 始终只处理提示中指定的 repo + branch。
+- 所有命令都使用提示中给出的 CLI 路径，并显式传 `--repo`、必要时传 `--branch`。
+- 禁止跳过 dry-run 直接 apply。
+- 当前分支存在未提交改动、领先默认基线且尚未 merge，或仍在开发时，不得擅自归档；先向用户说明并确认。
+- pending-promotion 只是候选，不是必选。业务专用事实不得上提到 repo 共享层。
+- 上提决策必须保留 Why 与影响范围，并改写成脱离当前分支名称仍可理解的最终事实。
+
+## 第一阶段：pre-flight
+
+运行：
+
+```bash
+<CLI> graduate dry-run --repo <REPO> [--branch <BRANCH>]
+```
+
+检查并向用户报告：
+
+- `git_status.ahead`
+- `git_status.uncommitted`
+- 默认基线与当前分支
+- `archive_destination`
+- 主审核面 `primary_sources.pending-promotion.md`
+- 主审核面 `primary_sources.decisions.md`
+- 其他 `cross_check_sources` 中可能遗漏的跨分支经验
+
+若 pre-flight 暴露未 merge 或未提交状态，停止在确认点，不要继续生成 apply。
+
+## 第二阶段：生成 harvest 草案
+
+只提炼真正跨分支稳定成立的内容，生成：
+
+```json
+{
+  "repo_overview": [
+    {"section": "长期目标与边界", "body": "...", "mode": "append"}
+  ],
+  "repo_decisions": [
+    {"section": "跨分支通用决策", "body": "...", "mode": "append"}
+  ],
+  "repo_glossary": [
+    {"section": "长期有效背景", "body": "...", "mode": "append"},
+    {"section": "共享入口", "body": "...", "mode": "append"}
+  ],
+  "notes": "从目标分支提炼",
+  "archive": true
+}
+```
+
+提炼时：
+
+- 去掉当前需求名、临时人员分工、一次性状态和提交流水。
+- 保留通用约束、反直觉风险、长期资料入口和可复用流程。
+- 对照现有 repo 共享记忆去重；旧共享结论失效时应改成最终口径，不能制造两条冲突规则。
+- 默认 `mode=append`，除非已经确认需要更新已有 section。
+
+把 harvest 草案完整展示给用户，包括“会上提什么”和“只归档、不做上提什么”。获得明确确认之前禁止 apply。
+
+## 第三阶段：apply
+
+用户确认草案与归档目标后运行：
+
+```bash
+<CLI> graduate apply --repo <REPO> [--branch <BRANCH>] --harvest-file <HARVEST>
+```
+
+apply 会串行写入 repo 共享层，生成 `archive_summary.md`，并把分支目录移动到 `branches/_archived/<branch>__<date>/`，同时更新 `_archived/INDEX.md`。
+
+## 第四阶段：复核
+
+完成后必须：
+
+1. 读取 `archive_summary.md`。
+2. 运行 `<CLI> graduate index --repo <REPO>` 确认归档索引存在。
+3. 检查原 branch_dir 已移动、archive destination 存在。
+4. 汇总实际上提条目、归档路径和任何跳过项。
+
+如果 apply 报 branch 不存在、schema 漂移或并发归档冲突，停止并报告真实错误；不得强行移动目录或手写 INDEX 绕过 CLI。
+

package/lib/maintenance/tidy.md

@@ -0,0 +1,103 @@
+# 记忆整理维护流程
+
+目标是把未分类内容归位，并校准已经结构化但陈旧、重复、错误或残留模板的记忆。整理是显式维护任务，不在普通开发会话中自动触发。
+
+## 硬规则
+
+- 始终只处理提示中指定的单个 repo + branch。
+- 所有命令都使用提示中给出的 CLI 路径，并显式传 `--repo`、必要时传 `--branch`。
+- 未分类内容可以在用户确认分类后 merge；结构化内容的删除和改写必须先生成 HTML review，由用户审核并导出 plan，禁止直接 apply。
+- 不复制 PRD、聊天流水或 Git 历史；只保留下次开发仍有价值的决策、风险、术语、约束、入口与文件导航。
+- `progress.md` 的 `AUTO-GENERATED` 块不得删除或改写。
+
+## 第一阶段：处理 unsorted
+
+先运行：
+
+```bash
+<CLI> setup init --repo <REPO> [--branch <BRANCH>]
+```
+
+如果 `unsorted_entries` 非空：
+
+1. 把相关条目聚合后给出高置信度分类建议。
+2. 可选 kind：`decision`、`risk`、`glossary`、`source`、`shared-decision`、`shared-context`、`shared-source`、`skip`。
+3. 让用户确认或修正分类；未确认前不要 merge。
+4. 生成 `classifications` plan，并运行 `setup merge-unsorted --plan-file ...`。
+
+如果 unsorted 为空，不需要为了修改 `setup_completed` 制造额外步骤；继续结构化整理即可。
+
+## 第二阶段：扫描结构化记忆
+
+运行：
+
+```bash
+<CLI> tidy prepare --repo <REPO> [--branch <BRANCH>] --scope <SCOPE>
+```
+
+`SCOPE` 使用启动提示中的 `branch` 或 `branch+repo`。第一次 prepare 后优先读取输出中的 `annotated_md`，不要只看 stdout 的扁平 entries。它保留了：
+
+- entry id
+- block 边界
+- section 结构
+- Why/How 等 orphan paragraph
+- STALE / ORPHAN hints
+
+## 第三阶段：生成事项级 proposals
+
+把相关条目聚合成约 3～8 个 proposal，每个 proposal 必须包含 `id`、`priority`、`title`、`reason`、`actions`。优先使用粗粒度动作：
+
+1. `reset-file`
+2. `delete-section`
+3. `delete-block`
+4. `delete-entries`
+5. `edit-entries`
+
+不要把每个 entry 单独做成 proposal。同一原因、同一结果的动作应合并。删除 block 时尽量附带 prepare 输出的 `expected_content_hash`，防止用户中途修改文件后误删。
+
+priority 口径：
+
+- `P0`：继续保留会误导下一次开发
+- `P1`：强烈建议清理
+- `P2`：建议清理
+- `P3`：可选
+- `P4`：可有可无
+
+把 proposals 写入临时 JSON，再次运行：
+
+```bash
+<CLI> tidy prepare --repo <REPO> [--branch <BRANCH>] --scope <SCOPE> --proposals-file <FILE>
+```
+
+## 第四阶段：人工审核门禁
+
+把 `review_html` / `open_url` 告诉用户，引导用户逐个选择：
+
+- accept：按原方案执行
+- reject：保持不动
+- custom：给出新的处理意见
+
+用户审核后从 HTML 导出 plan.json，并把路径交回本会话。没有用户导出的 plan 文件，禁止调用 `tidy apply`。
+
+## 第五阶段：apply 与复核
+
+用户明确提供已审核 plan 后运行：
+
+```bash
+<CLI> tidy apply --repo <REPO> [--branch <BRANCH>] --plan-file <PLAN>
+```
+
+apply 会先备份，再按 reset → section → block → entry 的顺序执行。完成后必须读取生成的 `summary_*.md`，核对 accepted/rejected/custom、实际 rewritten/deleted 和 invalid actions。
+
+custom proposal 不会自动 apply。根据反馈决定是直接精确改写、解释后再确认、保持不动，还是重新生成 proposals；不要机械重复整轮 prepare。
+
+## 完成输出
+
+最终向用户说明：
+
+- unsorted 分类合并了多少条
+- HTML 审核了多少个 proposal
+- 实际改写、删除、重置的数量
+- 备份和 summary 路径
+- 因漂移校验而跳过的动作
+

package/lib/ui-app.html

@@ -75,6 +75,14 @@ button { font-family: inherit; }
 .topbar .brand { display: flex; align-items: baseline; gap: 12px; min-width: 0; }
 .topbar .title { font-weight: 600; font-size: 15px; }
 .topbar .meta { color: var(--fg-muted); font-size: 12px; overflow: hidden; text-overflow: ellipsis; white-space: nowrap; }
+.view-tabs { display: flex; gap: 4px; }
+.view-tab { padding: 6px 10px; border: 1px solid var(--border); background: var(--bg-card); color: var(--fg); border-radius: var(--radius-sm); cursor: pointer; }
+.view-tab.active { color: var(--accent-fg); background: var(--accent); border-color: var(--accent); }
+.scan-table { width: 100%; border-collapse: collapse; background: var(--bg-card); border: 1px solid var(--border); font-size: 12px; }
+.scan-table th, .scan-table td { padding: 9px 10px; text-align: left; border-bottom: 1px solid var(--border-subtle); vertical-align: top; }
+.scan-table th { color: var(--fg-muted); background: var(--bg); font-weight: 600; }
+.scan-table tr:last-child td { border-bottom: 0; }
+.scan-table .num { text-align: right; font-variant-numeric: tabular-nums; }
 
 .main { display: grid; grid-template-columns: 320px 1fr; overflow: hidden; min-height: 0; }
 
@@ -453,6 +461,10 @@ button.icon-btn:hover {
       <span class="meta" id="meta">加载中…</span>
     </div>
     <div class="actions">
+      <span class="view-tabs">
+        <button class="view-tab active" id="memoryView">记忆</button>
+        <button class="view-tab" id="scanView">会话扫描</button>
+      </span>
       <button class="icon-btn" id="reload" title="重新加载">↻ 刷新</button>
     </div>
   </div>
@@ -490,6 +502,8 @@ button.icon-btn:hover {
 
 var state = {
   tree: null,
+  scan: null,
+  view: "memory",
   selectedRepoKey: null,
   selectedBranch: null,
   fileCache: new Map(),
@@ -672,6 +686,117 @@ function stat(label, value, small) {
   );
 }
 
+function formatBytes(value) {
+  var n = Number(value || 0);
+  if (n < 1024) return n + " B";
+  if (n < 1024 * 1024) return (n / 1024).toFixed(1) + " KB";
+  if (n < 1024 * 1024 * 1024) return (n / 1024 / 1024).toFixed(1) + " MB";
+  return (n / 1024 / 1024 / 1024).toFixed(2) + " GB";
+}
+
+function renderScan() {
+  var data = state.scan;
+  var content = q("#content");
+  var sidebar = q(".sidebar");
+  sidebar.style.display = "none";
+  content.style.gridColumn = "1 / -1";
+  content.innerHTML = "";
+  if (!data || !data.exists) {
+    content.appendChild(el("div", { class: "placeholder" }, "暂无会话扫描记录"));
+    return;
+  }
+  content.appendChild(el("div", { class: "repo-header" }, el("h2", null, "会话扫描"), el("div", { class: "path mono" }, data.scanRoot)));
+  var totals = el("div", { class: "stat-row" });
+  totals.appendChild(stat("扫描运行", data.run_count));
+  totals.appendChild(stat("涉及仓库", data.repos.length));
+  totals.appendChild(stat("总结 Token", data.usage ? (data.usage.total_tokens || 0).toLocaleString() : "未上报"));
+  totals.appendChild(stat("Token 未上报调用", data.unavailable_invocations));
+  content.appendChild(totals);
+
+  content.appendChild(el("h3", { class: "section-title" }, "仓库统计"));
+  var repoTable = el("table", { class: "scan-table" });
+  repoTable.innerHTML = "<thead><tr><th>仓库 / 分支</th><th class='num'>扫描次数</th><th class='num'>会话</th><th class='num'>原始大小</th><th class='num'>新增数据</th><th class='num'>总结 Token</th><th>最近扫描</th></tr></thead>";
+  var repoBody = el("tbody");
+  data.repos.forEach(function (repo) {
+    repoBody.appendChild(el("tr", null,
+      el("td", null, el("div", { class: "mono" }, repo.repo_key), el("div", { class: "sub" }, repo.branches.join(", "))),
+      el("td", { class: "num" }, repo.scan_count),
+      el("td", { class: "num" }, repo.session_count),
+      el("td", { class: "num" }, formatBytes(repo.raw_bytes)),
+      el("td", { class: "num" }, formatBytes(repo.new_bytes)),
+      el("td", { class: "num" }, Number(repo.summary_tokens || 0).toLocaleString()),
+      el("td", null, formatDateTime(repo.last_scanned_at))
+    ));
+  });
+  repoTable.appendChild(repoBody);
+  content.appendChild(repoTable);
+
+  content.appendChild(el("h3", { class: "section-title" }, "最近运行"));
+  var runTable = el("table", { class: "scan-table" });
+  runTable.innerHTML = "<thead><tr><th>时间 / Run ID</th><th>执行器</th><th class='num'>会话</th><th class='num'>新增数据</th><th class='num'>Token</th><th>结果</th></tr></thead>";
+  var runBody = el("tbody");
+  data.runs.forEach(function (run) {
+    var usage = run.summary_usage && run.summary_usage.total_tokens;
+    runBody.appendChild(el("tr", null,
+      el("td", null, el("div", null, formatDateTime(run.started_at)), el("div", { class: "mono" }, run.run_id)),
+      el("td", null, [run.executor || "-", run.model || ""].filter(Boolean).join(" / ")),
+      el("td", { class: "num" }, run.session_count),
+      el("td", { class: "num" }, formatBytes(run.new_bytes)),
+      el("td", { class: "num" }, usage == null ? "未上报" : Number(usage).toLocaleString()),
+      el("td", null, run.status ? run.status : (run.done_count + " 完成 · " + run.failed_count + " 失败 · " + run.skipped_count + " 跳过"))
+    ));
+  });
+  runTable.appendChild(runBody);
+  content.appendChild(runTable);
+
+  var recentSessions = [];
+  data.runs.forEach(function (run) {
+    (run.sessions || []).forEach(function (session) {
+      recentSessions.push({ run_id: run.run_id, started_at: run.started_at, session: session });
+    });
+  });
+  recentSessions.sort(function (a, b) { return String(b.started_at || "").localeCompare(String(a.started_at || "")); });
+  recentSessions = recentSessions.slice(0, 200);
+  content.appendChild(el("h3", { class: "section-title" }, "最近会话"));
+  var sessionTable = el("table", { class: "scan-table" });
+  sessionTable.innerHTML = "<thead><tr><th>会话 / 仓库</th><th class='num'>原始大小</th><th class='num'>本次新增</th><th class='num'>原会话 Token</th><th class='num'>总结 Token</th><th>状态</th></tr></thead>";
+  var sessionBody = el("tbody");
+  recentSessions.forEach(function (row) {
+    var session = row.session;
+    sessionBody.appendChild(el("tr", null,
+      el("td", null,
+        el("div", { class: "mono" }, session.session_id || "-"),
+        el("div", null, [session.repo_key, session.branch].filter(Boolean).join(" / ")),
+        el("div", { class: "sub mono" }, session.path || "")
+      ),
+      el("td", { class: "num" }, formatBytes(session.raw_size)),
+      el("td", { class: "num" }, formatBytes(session.new_bytes)),
+      el("td", { class: "num" }, session.session_usage && session.session_usage.total_tokens != null ? Number(session.session_usage.total_tokens).toLocaleString() : "未上报"),
+      el("td", { class: "num" }, session.summary_usage && session.summary_usage.total_tokens != null ? Number(session.summary_usage.total_tokens).toLocaleString() : "未上报"),
+      el("td", null, session.status + (session.reason ? " · " + session.reason : ""))
+    ));
+  });
+  sessionTable.appendChild(sessionBody);
+  content.appendChild(sessionTable);
+}
+
+function setView(view) {
+  state.view = view;
+  q("#memoryView").classList.toggle("active", view === "memory");
+  q("#scanView").classList.toggle("active", view === "scan");
+  if (view === "scan") {
+    fetch("/api/session-scan").then(function (r) { return r.json(); }).then(function (data) {
+      state.scan = data;
+      q("#meta").textContent = data.run_count + " 次扫描 · " + data.repos.length + " 个仓库 · " + data.scanRoot;
+      renderScan();
+    }).catch(function (err) { q("#meta").textContent = "错误：" + err.message; });
+  } else {
+    q(".sidebar").style.display = "block";
+    q("#content").style.gridColumn = "";
+    loadTree();
+  }
+}
+
 function renderRepoList(repos, filterText) {
   var list = q("#repoList");
   list.innerHTML = "";
@@ -1068,8 +1193,10 @@ q("#search").addEventListener("input", function (e) {
 });
 q("#reload").addEventListener("click", function () {
   state.fileCache.clear();
-  loadTree();
+  setView(state.view);
 });
+q("#memoryView").addEventListener("click", function () { setView("memory"); });
+q("#scanView").addEventListener("click", function () { setView("scan"); });
 q("#modalClose").addEventListener("click", closeModal);
 q("#modalEdit").addEventListener("click", enterEditMode);
 q("#modalSave").addEventListener("click", saveModalEdit);

package/lib/ui-server.js

@@ -13,6 +13,11 @@ function getStorageRoot() {
   return process.env.DEV_ASSETS_ROOT || DEFAULT_STORAGE_ROOT;
 }
 
+function getScanRoot() {
+  return process.env.DEV_MEMORY_SCAN_ROOT
+    || path.join(path.dirname(getStorageRoot()), "jobs", "session-scan");
+}
+
 function safeReadDir(dir) {
   try {
     return fs.readdirSync(dir, { withFileTypes: true });
@@ -135,6 +140,62 @@ function buildTree() {
   return { storageRoot: root, exists: true, repos };
 }
 
+function buildSessionScanData() {
+  const root = getScanRoot();
+  const runsDir = path.join(root, "runs");
+  const runs = [];
+  for (const ent of safeReadDir(runsDir)) {
+    if (!ent.isFile() || !ent.name.endsWith(".json")) continue;
+    const value = safeReadJson(path.join(runsDir, ent.name));
+    if (value && typeof value === "object") runs.push(value);
+  }
+  runs.sort((a, b) => String(b.started_at || "").localeCompare(String(a.started_at || "")));
+  const repos = new Map();
+  const usage = {};
+  let unavailableInvocations = 0;
+  for (const run of runs) {
+    unavailableInvocations += Number(run.usage_unavailable_invocations || 0);
+    for (const [key, value] of Object.entries(run.summary_usage || {})) {
+      if (Number.isFinite(value)) usage[key] = (usage[key] || 0) + value;
+    }
+    for (const session of run.sessions || []) {
+      if (!session.repo_key) continue;
+      const row = repos.get(session.repo_key) || {
+        repo_key: session.repo_key,
+        branches: new Set(), sessions: new Set(), scan_count: 0,
+        raw_bytes: 0, new_bytes: 0, summary_tokens: 0, done: 0, failed: 0, last_scanned_at: null,
+      };
+      row.scan_count += 1;
+      row.sessions.add(session.session_id);
+      if (session.branch) row.branches.add(session.branch);
+      row.raw_bytes += Number(session.raw_size || 0);
+      row.new_bytes += Number(session.new_bytes || 0);
+      row.summary_tokens += Number((session.summary_usage || {}).total_tokens || 0);
+      if (session.status === "done") row.done += 1;
+      if (session.status === "failed") row.failed += 1;
+      if (!row.last_scanned_at || session.last_scanned_at > row.last_scanned_at) {
+        row.last_scanned_at = session.last_scanned_at;
+      }
+      repos.set(session.repo_key, row);
+    }
+  }
+  const repoRows = Array.from(repos.values()).map((row) => ({
+    ...row,
+    branches: Array.from(row.branches).sort(),
+    session_count: row.sessions.size,
+    sessions: undefined,
+  })).sort((a, b) => String(b.last_scanned_at || "").localeCompare(String(a.last_scanned_at || "")));
+  return {
+    scanRoot: root,
+    exists: !!safeStat(root),
+    run_count: runs.length,
+    usage: Object.keys(usage).length ? usage : null,
+    unavailable_invocations: unavailableInvocations,
+    repos: repoRows,
+    runs: runs.slice(0, 100),
+  };
+}
+
 function resolveSafePath(relPath) {
   const root = getStorageRoot();
   if (!relPath || typeof relPath !== "string") return null;
@@ -299,6 +360,11 @@ function start({ host = "127.0.0.1", port = 0, openBrowserFlag = true, readOnly
       res.end(JSON.stringify(tree));
       return;
     }
+    if (url.pathname === "/api/session-scan" && isRead) {
+      res.writeHead(200, { "content-type": "application/json; charset=utf-8" });
+      res.end(JSON.stringify(buildSessionScanData()));
+      return;
+    }
     if (url.pathname === "/api/injection-preview" && isRead) {
       const repoKey = url.searchParams.get("repo") || "";
       const branch = url.searchParams.get("branch") || "";
@@ -380,4 +446,4 @@ function start({ host = "127.0.0.1", port = 0, openBrowserFlag = true, readOnly
   return server;
 }
 
-module.exports = { start, buildTree, getStorageRoot };
+module.exports = { start, buildTree, buildSessionScanData, getStorageRoot, getScanRoot };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dev-memory-cli",
-  "version": "0.22.1",
+  "version": "0.23.0",
   "description": "CLI for dev-memory hooks and repo-local setup (formerly @xluos/dev-assets-cli)",
   "license": "MIT",
   "repository": {
@@ -28,6 +28,7 @@
     "hooks/*.json",
     "hooks/README.md",
     "lib/*.py",
+    "lib/maintenance/*.md",
     "lib/ui-server.js",
     "lib/ui-app.html",
     "lib/assets/*",