akm-cli 0.10.261008-beta → 0.10.261010-beta

package/dist/assets/ui/editor.js

@@ -0,0 +1,103 @@
+// Source-first creation and revision-checked editing use the existing Markdown writer.
+import { actionForm, api, assetHref, emptyState, html, mount, pageHeader, post, setUnsaved } from "./lib.js";
+import { markdown, splitFrontmatter } from "./markdown.js";
+
+export async function render(ctx) {
+  const ref = ctx.query.get("ref");
+  if (ref) return edit(ctx, ref);
+  const data = await api("/api/bundles");
+  const writable = data.bundles.filter((b) => b.enabled && b.writable && b.components.some((c) => c.adapter === "akm"));
+  ctx.after.push((root) => {
+    actionForm(root, ".create-form", (_form, values) => post("/api/knowledge/create", Object.fromEntries(values)), {
+      after: (result) => {
+        setUnsaved(false);
+        if (result.ref) location.hash = assetHref(result.ref);
+        else location.hash = "#/search";
+      },
+    });
+    const form = root.querySelector(".create-form");
+    if (form) {
+      const draw = () =>
+        mount(root.querySelector("[data-preview]"), markdown(splitFrontmatter(form.elements.content.value).body));
+      form.elements.content.addEventListener("input", draw);
+      form.addEventListener("input", () => setUnsaved(true));
+      draw();
+    }
+  });
+  return html`${pageHeader("New knowledge", "Write Markdown and optional frontmatter. Existing files are never overwritten.")}
+    <p><a href="#/search">Back to search</a></p>
+    ${
+      writable.length === 0
+        ? emptyState(
+            "No enabled writable AKM bundle is available.",
+            html`Check <a href="#/bundles">bundle settings</a>.`,
+          )
+        : html`
+    <form class="create-form form-grid">
+      <label>Bundle<select name="bundle">${writable.map((b) => html`<option value="${b.name}" ${b.name === (data.defaultWriteTarget ?? data.defaultBundle) ? html`selected` : ""}>${b.name}</option>`)}</select></label>
+      <label>Name<input name="name" required placeholder="restore-database"></label>
+      <label>Subdirectory<input name="path" placeholder="Optional, under knowledge/"></label>
+      <label>Markdown<textarea name="content" rows="16" required spellcheck="false"># New document
+
+</textarea></label>
+      <button type="submit">Create knowledge</button><div data-status></div>
+    </form>
+    <section><h2>Preview</h2><div data-preview></div></section>`
+    }`;
+}
+
+// A textarea's value has every line break as LF.
+const asTextarea = (content) => content.replace(/\r\n?/g, "\n");
+
+/** The save request for `draft`: an untouched draft sends the exact source; a uniform-CRLF source keeps CRLF. */
+function saveBody(source, draft) {
+  const usesCrlf = source.content.includes("\r\n") && !/[\r\n]/.test(source.content.replace(/\r\n/g, ""));
+  const content =
+    draft === asTextarea(source.content) ? source.content : usesCrlf ? draft.replace(/\r?\n/g, "\r\n") : draft;
+  return { ref: source.ref, revision: source.revision, content };
+}
+
+async function edit(ctx, ref) {
+  let source = await api("/api/asset/source", { ref });
+  const context = { ref: source.ref, bundle: source.ref.split("//")[0] };
+  ctx.after.push((root) => {
+    const input = root.querySelector('[name="content"]');
+    // HTML textarea parsing drops an initial LF, so initialize explicitly.
+    input.value = source.content;
+    actionForm(
+      root,
+      ".edit-form",
+      async () => {
+        try {
+          return await post("/api/asset/save", saveBody(source, input.value));
+        } catch (error) {
+          if (error?.code !== "ASSET_CONTENT_CHANGED") throw error;
+          // Take the new revision in place; the draft in the textarea stays as typed.
+          source = await api("/api/asset/source", { ref: source.ref });
+          throw new Error(
+            "The document changed on disk since you opened it. Your draft was kept; saving again will overwrite the newer version.",
+          );
+        }
+      },
+      {
+        after: () => {
+          setUnsaved(false);
+          location.hash = assetHref(source.ref);
+        },
+      },
+    );
+    const draw = () =>
+      mount(root.querySelector("[data-preview]"), markdown(splitFrontmatter(input.value).body, context));
+    input.addEventListener("input", () => {
+      setUnsaved(input.value !== asTextarea(source.content));
+      draw();
+    });
+    draw();
+  });
+  return html`${pageHeader("Edit Markdown", source.ref)}
+    <p><a href="${assetHref(source.ref)}">Back to document</a></p>
+    <p class="muted">Edit the full ${source.type} source, including frontmatter. If the file changes on disk meanwhile, the first save is refused and your draft is kept; saving again overwrites the newer version.</p>
+    <form class="edit-form form-grid"><label>Markdown<textarea name="content" rows="20" spellcheck="false">${source.content}</textarea></label>
+      <button type="submit">Save Markdown</button><div data-status></div>
+    </form><section><h2>Preview</h2><div data-preview></div></section>`;
+}

package/dist/assets/ui/index.html

@@ -20,8 +20,10 @@
         <li><a data-route="changes" href="#/changes">Changes</a></li>
         <li><a data-route="search" href="#/search">Search</a></li>
       </ul>
+      <button type="button" data-refresh>Refresh view</button>
       <div class="nav-meta" id="nav-meta"></div>
     </nav>
+    <div id="unsaved" class="notice notice-warn" role="alert" hidden></div>
     <main id="app" aria-live="polite">
       <noscript><p>akm ui needs JavaScript. It makes no network requests beyond its own local server.</p></noscript>
     </main>

package/dist/assets/ui/lib.js

@@ -102,7 +102,7 @@ export function api(path, query = {}) {
   return request(url, { headers: { "X-Akm-Ui-Token": token ?? "" }, cache: "no-store" });
 }
 
-/** POST `body` as JSON to `path`. Only the proposal accept/reject routes take one; the token goes in the header, never the URL. */
+/** POST `body` as JSON to an explicit action. The token goes in the header, never the URL. */
 export function post(path, body = {}) {
   return request(path, {
     method: "POST",
@@ -236,3 +236,53 @@ export function pretty(value) {
 export function percent(part, total) {
   return total > 0 ? Math.round((part / total) * 1000) / 10 : 0;
 }
+
+// ---- unsaved drafts and one-shot status ------------------------------------
+
+let unsaved = false;
+/** The editor marks a draft that leaving the page would lose; the router asks before discarding it. */
+export function setUnsaved(value) {
+  unsaved = value;
+}
+export function hasUnsaved() {
+  return unsaved;
+}
+
+let flash = null;
+/** Show the status a form left before its page re-rendered, once. Called by the router after each render. */
+export function showFlash(root) {
+  const pending = flash;
+  flash = null;
+  const status = pending && root.querySelectorAll(pending.selector)[pending.index]?.querySelector("[data-status]");
+  if (status) mount(status, html`<p role="status" class="text-ok">${pending.message}</p>`);
+}
+
+/** Bind an explicit form action; errors stay beside the user's inputs. */
+export function actionForm(root, selector, action, { after } = {}) {
+  root.querySelectorAll(selector).forEach((form, index) => {
+    form.addEventListener("submit", async (event) => {
+      event.preventDefault();
+      const status = form.querySelector("[data-status]");
+      const button = event.submitter;
+      let locked = false;
+      if (button) button.disabled = true;
+      if (status) mount(status, html`<p role="status">Working…</p>`);
+      try {
+        const result = await action(form, new FormData(form));
+        const message = result?.saved === false ? "No changes." : "Saved.";
+        if (status) mount(status, html`<p role="status" class="text-ok">${message}</p>`);
+        if (after) after(result);
+        else {
+          flash = { selector, index, message };
+          window.dispatchEvent(new HashChangeEvent("hashchange"));
+        }
+      } catch (error) {
+        // The action may already have happened; the server asks not to repeat it without a reload.
+        locked = error?.code === "INVALID_COMMAND_RESPONSE";
+        if (status) mount(status, html`<p role="alert" class="text-fail">${error.message}</p>`);
+      } finally {
+        if (button && !locked) button.disabled = false;
+      }
+    });
+  });
+}

package/dist/assets/ui/markdown.js

@@ -1,12 +1,35 @@
-// A deliberately tiny markdown renderer: headings, lists, fenced code, inline code, bold, links and [[wikilinks]].
+// Safe document rendering: headings, lists, tables, task items, fenced code, inline code, bold, links and
+// [[wikilinks]]. Link targets and heading selectors come from AKM's indexed reads.
 // It never touches raw text except through `html`, which escapes every interpolated value.
-
 import { assetHref, html } from "./lib.js";
 
 const SAFE_URL = /^(https?:\/\/|mailto:|#)/i;
 const INLINE = /`([^`]+)`|\[\[([^\]]+)\]\]|\[([^\]]+)\]\(([^)\s]+)\)|\*\*([^*]+)\*\*/g;
+// The same fence rule as the server's parseMarkdownToc (CommonMark), so both agree on which headings exist:
+// a fence opens with 3+ backticks or tildes indented at most 3 spaces (a backtick fence's info string has
+// no backtick) and closes only on a line of the same character, at least as long, then only whitespace.
+const FENCE = /^ {0,3}(`{3,}|~{3,})(.*)$/;
+const opensFence = (line) => {
+  const m = FENCE.exec(line);
+  return m && !(m[1][0] === "`" && m[2].includes("`")) ? m[1] : null;
+};
+const closesFence = (line, open) => {
+  const m = FENCE.exec(line);
+  return m !== null && m[1][0] === open[0] && m[1].length >= open.length && !m[2].trim();
+};
+const TABLE_DELIMITER = /^\s*\|?\s*:?-{3,}:?\s*(?:\|\s*:?-{3,}:?\s*)*\|?\s*$/;
+
+/** DOM id of a heading: prefixed so a slug like "app" never collides with the page's own ids. */
+export const headingId = (slug) => `h-${slug}`;
 
-function link(text, url) {
+function link(text, url, context) {
+  if (context.links && Object.hasOwn(context.links, url))
+    return html`<a href="${assetHref(context.links[url])}">${text}</a>`;
+  if (url.startsWith("#")) {
+    // A bare "#x" would be read by the hash router as a page; without an asset to anchor to, show text.
+    if (!context.ref) return html`${text}`;
+    return html`<a href="${assetHref(context.ref)}&section=${encodeURIComponent(url.slice(1))}">${text}</a>`;
+  }
   if (!SAFE_URL.test(url)) return html`${text}`;
   const external = /^(https?:|mailto:)/i.test(url);
   return external
@@ -14,16 +37,18 @@ function link(text, url) {
     : html`<a href="${url}">${text}</a>`;
 }
 
-/** Inline spans of one line of text. */
-export function inline(text) {
+/** Inline spans of one line of text. `context` is the same as for {@link markdown}. */
+export function inline(text, context = {}) {
   const out = [];
   let last = 0;
   for (const m of text.matchAll(INLINE)) {
     out.push(text.slice(last, m.index));
     if (m[1] !== undefined) out.push(html`<code>${m[1]}</code>`);
-    else if (m[2] !== undefined)
-      out.push(html`<a href="${assetHref(m[2].split("|")[0].trim())}"><code>${m[2]}</code></a>`);
-    else if (m[3] !== undefined) out.push(link(m[3], m[4]));
+    else if (m[2] !== undefined) {
+      const [ref, label] = m[2].split("|");
+      const target = context.bundle && !ref.includes("//") ? `${context.bundle}//${ref.trim()}` : ref.trim();
+      out.push(html`<a href="${assetHref(target)}"><code>${label ?? ref}</code></a>`);
+    } else if (m[3] !== undefined) out.push(link(m[3], m[4], context));
     else out.push(html`<strong>${m[5]}</strong>`);
     last = m.index + m[0].length;
   }
@@ -31,16 +56,31 @@ export function inline(text) {
   return html`${out}`;
 }
 
-/** Render markdown text to safe HTML. */
-export function markdown(source) {
+const cells = (line) =>
+  line
+    .trim()
+    .replace(/^\|/, "")
+    .replace(/\|$/, "")
+    .split("|")
+    .map((cell) => cell.trim());
+
+/**
+ * Render markdown text to safe HTML. `context` is optional: `ref` and `bundle` anchor `#section` links and
+ * bare [[wikilinks]] to the asset, `links` maps raw link targets to indexed refs, and `headings` is the
+ * server's heading list ({line, slug}), matched by `line` against `startLine`, the source line of the
+ * text's first line (after frontmatter).
+ */
+export function markdown(source, context = {}) {
   const lines = String(source ?? "")
     .replace(/\r\n?/g, "\n")
     .split("\n");
   const blocks = [];
   let paragraph = [];
   let list = null;
+  const slugByLine = new Map((context.headings ?? []).map((h) => [h.line, h.slug]));
+  const firstLine = context.startLine ?? 1;
   const flushParagraph = () => {
-    if (paragraph.length > 0) blocks.push(html`<p>${inline(paragraph.join(" "))}</p>`);
+    if (paragraph.length > 0) blocks.push(html`<p>${inline(paragraph.join(" "), context)}</p>`);
     paragraph = [];
   };
   const flushList = () => {
@@ -49,21 +89,40 @@ export function markdown(source) {
   };
   for (let i = 0; i < lines.length; i++) {
     const line = lines[i];
-    const fence = /^```\s*(\S*)/.exec(line);
+    const fence = opensFence(line);
     if (fence) {
       flushParagraph();
       flushList();
       const code = [];
-      for (i++; i < lines.length && !/^```/.test(lines[i]); i++) code.push(lines[i]);
+      for (i++; i < lines.length && !closesFence(lines[i], fence); i++) code.push(lines[i]);
       blocks.push(html`<pre class="code"><code>${code.join("\n")}</code></pre>`);
       continue;
     }
-    const heading = /^(#{1,6})\s+(.*)$/.exec(line);
+    const heading = /^(#{1,6})\s+(.+)$/.exec(line);
     if (heading) {
       flushParagraph();
       flushList();
       const level = Math.min(heading[1].length + 1, 6);
-      blocks.push(html`<h${level}>${inline(heading[2])}</h${level}>`);
+      const slug = slugByLine.get(firstLine + i);
+      blocks.push(
+        html`<h${level}${slug ? html` id="${headingId(slug)}"` : ""}>${inline(heading[2].replace(/\s+#+\s*$/, ""), context)}</h${level}>`,
+      );
+      continue;
+    }
+    if (line.includes("|") && lines[i + 1]?.includes("|") && TABLE_DELIMITER.test(lines[i + 1])) {
+      flushParagraph();
+      flushList();
+      const headers = cells(line);
+      i += 2;
+      const rows = [];
+      while (i < lines.length && lines[i].includes("|") && lines[i].trim()) {
+        rows.push(html`<tr>${cells(lines[i]).map((cell) => html`<td>${inline(cell, context)}</td>`)}</tr>`);
+        i++;
+      }
+      i--;
+      blocks.push(
+        html`<div class="table-wrap"><table><thead><tr>${headers.map((cell) => html`<th>${inline(cell, context)}</th>`)}</tr></thead><tbody>${rows}</tbody></table></div>`,
+      );
       continue;
     }
     const item = /^\s*(?:([-*+])|(\d+)[.)])\s+(.*)$/.exec(line);
@@ -72,7 +131,12 @@ export function markdown(source) {
       const ordered = item[2] !== undefined;
       if (list && list.ordered !== ordered) flushList();
       list ??= { ordered, items: [] };
-      list.items.push(html`<li>${inline(item[3])}</li>`);
+      const task = /^\[([ xX])\]\s+(.*)$/.exec(item[3]);
+      list.items.push(
+        task
+          ? html`<li class="task-item"><input type="checkbox" disabled ${task[1].toLowerCase() === "x" ? html`checked` : ""} aria-label="${task[2]}">${inline(task[2], context)}</li>`
+          : html`<li>${inline(item[3], context)}</li>`,
+      );
       continue;
     }
     if (line.trim() === "") {
@@ -88,16 +152,19 @@ export function markdown(source) {
   return html`<div class="md">${blocks}</div>`;
 }
 
-/** Split leading `---` frontmatter from `content`: { fields: [[key, value]], body }. */
+/**
+ * Split leading `---` frontmatter from `content`: { fields: [[key, value]], body, startLine }, where
+ * `startLine` is the 1-based source line the body starts on (pass it to {@link markdown}).
+ */
 export function splitFrontmatter(content) {
   const text = String(content ?? "").replace(/\r\n?/g, "\n");
   const m = /^---\n([\s\S]*?)\n---[ \t]*(?:\n|$)/.exec(text);
-  if (!m) return { fields: [], body: text };
+  if (!m) return { fields: [], body: text, startLine: 1 };
   const fields = [];
   for (const line of m[1].split("\n")) {
     const kv = /^([A-Za-z0-9_.-]+):\s*(.*)$/.exec(line);
     if (kv) fields.push([kv[1], kv[2]]);
     else if (fields.length > 0 && line.trim() !== "") fields[fields.length - 1][1] += `\n${line}`;
   }
-  return { fields, body: text.slice(m[0].length) };
+  return { fields, body: text.slice(m[0].length), startLine: m[0].split("\n").length };
 }

package/dist/assets/ui/search.js

@@ -4,8 +4,13 @@ import { api, assetHref, badge, emptyState, html, pageHeader } from "./lib.js";
 
 const RESULT_LIMIT = 50;
 
+/** Exactly `values` as options, with `selected` chosen. */
+function choices(values, selected) {
+  return values.map((v) => html`<option value="${v}" ${v === selected ? html`selected` : ""}>${v}</option>`);
+}
+
 function options(values, selected, allLabel) {
-  return html`<option value="">${allLabel}</option>${values.map((v) => html`<option value="${v}" ${v === selected ? html`selected` : ""}>${v}</option>`)}`;
+  return html`<option value="">${allLabel}</option>${choices(values, selected)}`;
 }
 
 function hit(h) {
@@ -21,8 +26,13 @@ export async function render(ctx) {
   const q = ctx.query.get("q") ?? "";
   const type = ctx.query.get("type") ?? "";
   const bundle = ctx.query.get("bundle") ?? "";
+  const belief = ctx.query.get("belief") || "current";
+  const limit = ctx.query.get("limit") || String(RESULT_LIMIT);
+  const scope = Object.fromEntries(
+    ["user", "agent", "run", "channel"].map((key) => [`scope_${key}`, ctx.query.get(`scope_${key}`) ?? ""]),
+  );
   const [result, bundles] = await Promise.all([
-    api("/api/search", { q, type, bundle, limit: RESULT_LIMIT }),
+    api("/api/search", { q, type, bundle, belief, ...scope, limit }),
     api("/api/bundles").catch(() => null),
   ]);
   const types = new Set(Object.keys(bundles?.index?.byType ?? {}));
@@ -46,17 +56,27 @@ export async function render(ctx) {
     for (const select of form.querySelectorAll("select")) select.addEventListener("change", go);
   });
 
-  return html`${pageHeader("Search", "Search your bundles. Browsing here is not counted as usage.")}
+  const groups = new Map();
+  for (const h of result.hits) {
+    const group = h.ref.slice(0, h.ref.lastIndexOf("/")) || h.type;
+    if (!groups.has(group)) groups.set(group, []);
+    groups.get(group).push(h);
+  }
+  return html`${pageHeader("Search", "Search or browse your indexed assets. Browsing is not counted as usage.")}
+    <p class="action-links"><a href="#/new">New knowledge</a> <span class="muted small">· Ctrl/Cmd+K opens search</span></p>
     <form class="search-form" role="search">
-      <input type="search" name="q" value="${q}" placeholder="Search assets (empty lists everything)" aria-label="Query" autofocus>
+      <input type="search" name="q" value="${q}" placeholder="Search assets (empty browses the index)" aria-label="Query" autofocus>
       <select name="type" aria-label="Type">${options([...types].sort(), type, "All types")}</select>
       <select name="bundle" aria-label="Bundle">${options(bundleNames, bundle, "All bundles")}</select>
+      <select name="belief" aria-label="Belief state">${choices(["current", "all", "historical"], belief)}</select>
+      <select name="limit" aria-label="Result limit">${choices(["50", "100", "200"], limit)}</select>
+      <details class="scope-controls"><summary>Scope filters</summary><div class="form-grid">${Object.entries(scope).map(([key, value]) => html`<label>${key.slice(6)}<input name="${key}" value="${value}" placeholder="Any"></label>`)}</div></details>
       <button type="submit">Search</button>
     </form>
     ${(result.warnings ?? []).map((w) => html`<div class="notice notice-warn">${w}</div>`)}
     ${
       result.hits.length === 0
         ? emptyState(q ? `No assets match "${q}".` : "No assets found.", result.tip ?? "")
-        : html`<p class="muted">${result.hits.length} ${result.hits.length === 1 ? "result" : "results"}${result.hits.length === RESULT_LIMIT ? ` (the first ${RESULT_LIMIT})` : ""}, ${result.searchMode ?? "search"} mode${result.timing ? `, ${result.timing.totalMs} ms` : ""}.</p><ul class="hits">${result.hits.map(hit)}</ul>`
+        : html`<p class="muted">${result.hits.length} ${result.hits.length === 1 ? "result" : "results"}${result.hits.length === Number(limit) ? ` (first ${limit}; narrow the query or filters for more specific results)` : ""}, ${result.searchMode ?? "search"} mode${result.timing ? `, ${result.timing.totalMs} ms` : ""}.</p>${q ? html`<ul class="hits">${result.hits.map(hit)}</ul>` : html`<div class="asset-inventory">${[...groups].sort(([a], [b]) => a.localeCompare(b)).map(([name, hits]) => html`<details open><summary>${name} <span class="muted">(${hits.length})</span></summary><ul class="hits">${hits.sort((a, b) => a.ref.localeCompare(b.ref)).map(hit)}</ul></details>`)}</div>`}`
     }`;
 }

package/dist/assets/ui/styles.css

@@ -372,6 +372,21 @@ p {
   padding-left: 20px;
 }
 
+/* Unsaved-draft guard: floats over the page so the editor underneath stays mounted. */
+#unsaved {
+  position: fixed;
+  top: 16px;
+  right: 16px;
+  z-index: 10;
+  max-width: min(420px, calc(100vw - 32px));
+  margin: 0;
+  box-shadow: 0 4px 16px rgb(0 0 0 / 0.2);
+}
+
+#unsaved p {
+  margin: 0 0 8px;
+}
+
 /* ---- badges ---- */
 .badge {
   display: inline-block;
@@ -1017,6 +1032,8 @@ pre.diff {
 }
 
 input[type="search"],
+input:not([type]),
+textarea,
 select,
 button {
   font: inherit;
@@ -1027,6 +1044,59 @@ button {
   padding: 8px 12px;
 }
 
+.form-grid {
+  display: grid;
+  gap: 12px;
+  margin: 16px 0;
+}
+
+.form-grid label:not(.check) {
+  display: grid;
+  gap: 4px;
+}
+
+.form-grid input:not([type="checkbox"]),
+.form-grid textarea {
+  width: 100%;
+  min-width: 0;
+}
+
+.form-grid textarea {
+  resize: vertical;
+  font-family: var(--mono);
+}
+
+.form-grid button {
+  justify-self: start;
+}
+
+.check {
+  display: flex;
+  gap: 8px;
+  align-items: baseline;
+  flex-wrap: wrap;
+}
+
+.scope-controls {
+  flex-basis: 100%;
+}
+
+.asset-inventory > details {
+  margin-top: 16px;
+}
+
+.md [id] {
+  scroll-margin-top: 20px;
+}
+
+.task-item {
+  list-style: none;
+}
+
+.task-item input {
+  margin-right: 8px;
+}
+
 input[type="search"] {
   flex: 1 1 260px;
   min-width: 0;

package/dist/commands/health/improve-metrics.js

@@ -108,7 +108,15 @@ export function emptyImproveMetrics() {
             totalChunks: 0,
             durationMs: 0,
         },
-        memoryInference: { considered: 0, freshAttempts: 0, written: 0, skippedNoFacts: 0, yieldRate: 0, durationMs: 0 },
+        memoryInference: {
+            considered: 0,
+            freshAttempts: 0,
+            written: 0,
+            noChange: 0,
+            skippedNoFacts: 0,
+            yieldRate: 0,
+            durationMs: 0,
+        },
         wallTime: { medianMs: 0, p95Ms: 0 },
         coverage: { acceptedProposals: 0, distinctRefs: 0 },
     };
@@ -220,6 +228,7 @@ function projectRunMetrics(result) {
         // them keeps the yield rate a statement about real inference attempts.
         mi.freshAttempts += Math.max(0, considered - toFiniteNumber(memoryInference.cacheHits) - toFiniteNumber(memoryInference.skippedAborted));
         mi.written += toFiniteNumber(memoryInference.writtenFacts);
+        mi.noChange += toFiniteNumber(memoryInference.noChange);
         mi.skippedNoFacts += toFiniteNumber(memoryInference.skippedNoFacts);
     }
     metrics.memoryInference.durationMs += toFiniteNumber(result.memoryInferenceDurationMs);
@@ -267,6 +276,7 @@ function mergeImproveMetrics(dst, src) {
     dst.memoryInference.considered += src.memoryInference.considered;
     dst.memoryInference.freshAttempts += src.memoryInference.freshAttempts;
     dst.memoryInference.written += src.memoryInference.written;
+    dst.memoryInference.noChange += src.memoryInference.noChange;
     dst.memoryInference.skippedNoFacts += src.memoryInference.skippedNoFacts;
     dst.memoryInference.durationMs += src.memoryInference.durationMs;
 }

package/dist/commands/health/md-report.js

@@ -20,7 +20,7 @@ function renderTable(headers, rows) {
  *
  * Columns: ts | ok | actions | refl_ok/fail/cd/skip |
  *   distill_q/llm-fail/qrej/cfg/skip | cons_proc/promo/merge/del |
- *   mem_cons/written/skip | orphans | lint_f/fl
+ *   mem_cons/written/nochange/skip | orphans | lint_f/fl
  */
 export function renderRunsDetailMd(runs) {
     const headers = [
@@ -31,7 +31,7 @@ export function renderRunsDetailMd(runs) {
         "refl_ok/fail/cd/skip",
         "distill_q/llm-fail/judge/validator/cfg/skip",
         "cons_proc/promo/merge/del",
-        "mem_cons/written/skip",
+        "mem_cons/written/nochange/skip",
         "orphans",
         "lint_f/fl",
         "result_status",
@@ -58,7 +58,7 @@ export function renderRunsDetailMd(runs) {
             `${r.actions.reflect.ok}/${r.actions.reflect.failed}/${r.actions.reflect.cooldown}/${r.actions.reflect.skipped}`,
             `${r.actions.distill.queued}/${r.actions.distill.llmFailed}/${r.actions.distill.judgeRejected}/${r.actions.distill.validatorRejected}/${r.actions.distill.configDisabled}/${r.actions.distill.skipped}`,
             `${r.consolidation.processed}/${r.consolidation.promoted}/${r.consolidation.merged}/${r.consolidation.deleted}`,
-            `${r.memoryInference.considered}/${r.memoryInference.written}/${r.memoryInference.skippedNoFacts}`,
+            `${r.memoryInference.considered}/${r.memoryInference.written}/${r.memoryInference.noChange}/${r.memoryInference.skippedNoFacts}`,
             String(r.orphansPurged),
             `${r.lintFixed}/${r.lintFlagged}`,
             r.resultStatus ?? "valid",

package/dist/commands/health.js

@@ -580,6 +580,7 @@ export async function akmHealth(options = {}) {
     }
     const { db } = opened;
     try {
+        const { windowResults, deltas } = resolveWindowComparePhase(options, db, stateDbPath, now);
         // Network probes overlap the local database phases below; awaited where consumed.
         const engineProbesPromise = runHealthEngineProbes({ probeReachable: options.probe ? probeLlmEndpoint : undefined });
         engineProbesPromise.catch(() => undefined);
@@ -666,8 +667,6 @@ export async function akmHealth(options = {}) {
         const hardFailure = hardChecks.some((check) => check.status === "fail");
         const deterministicWarnings = [...hardChecks, ...advisories].some((check) => check.status === "warn" && check.kind === "deterministic");
         const status = hardFailure ? "fail" : deterministicWarnings ? "warn" : "pass";
-        // ── Window-compare mode (Phase 3) ─────────────────────────────────────
-        const { windowResults, deltas } = resolveWindowComparePhase(options, db, stateDbPath, now);
         // ── Per-run mode (Phase 2) ────────────────────────────────────────────
         const runs = options.groupBy === "run" ? perRunSummaries : undefined;
         return {