akm-cli 0.10.261009-beta → 0.10.261010-beta

package/CHANGELOG.md

@@ -6,6 +6,42 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/).
 
 ## [Unreleased]
 
+## [0.10.261010] - 2026-10-21
+
+### Added
+
+- `akm ui` gains explicit write actions beside proposal decisions (#1217): edit
+  an indexed, writable knowledge or memory document's full Markdown source,
+  create knowledge, submit feedback, add, remove and update bundles, change
+  bundle settings, and view a document's Git file history. Each action reuses the
+  CLI operation and its validation, indexing and Git effects. A save is checked
+  against the source's raw-content revision and refused with `409
+  ASSET_CONTENT_CHANGED` if the file changed. Saves and creates answer `409
+  ASSET_MUTATION_LEASE_HELD` at once while another writer holds the lease, and
+  accept bodies up to 8 MiB (other writes stay at 64 KiB). Endpoints and status
+  codes are in `docs/reference/ui-api.md`.
+
+### Changed
+
+- The shared Markdown writer behind `akm import` and `akm remember` now takes the
+  asset-mutation lease, so it waits for other akm writers instead of racing them
+  (#1217). It also accepts an optional expected content hash, which the UI's
+  editor uses to refuse a stale save. CLI writes without a hash behave as before.
+
+- Curate withholds context for exact whole-message phrases such as `hello`,
+  `thanks, that worked!`, `ok sounds good, go ahead`, `yes`, and `lgtm` (#1201).
+  Matching normalizes case, whitespace and common punctuation; added task text
+  still retrieves. Use `akm search` for literal lookups that collide with the list.
+- Memory inference accepts an explicit, cached "no change" decision (#1208). A
+  tool-count or checkpoint note, or a note already adequate as written, no longer
+  needs a derived memory or a model call on every run. The decision is cached on
+  the note's body hash (cache namespace `memory-inference-v3`; older rows are a
+  disposable miss), writes no child, and does not stamp the parent
+  `inferenceProcessed`, so an edited note is considered again. It is counted in `memoryInference.noChange` in the improve
+  result, progress line and health metrics (the health runs table gains a
+  `nochange` column), never in `skippedNoFacts`. Malformed or HTML replies,
+  timeouts, aborts and endpoint failures are still not cached and are retried.
+
 ## [0.10.261009] - 2026-10-21
 
 ### Changed

package/STABILITY.md

@@ -88,7 +88,7 @@ enumeration of the whole `proposal` noun group.
 | `akm index` | Stable | |
 | `akm health` | Evolving | Exit codes are Evolving; report *content* and rendered `md`/`html` layout are Experimental — do not script against report layout. |
 | `akm metrics` | Experimental | New in 0.9.28. Report content, JSON shape and the `html` dashboard may change. |
-| `akm ui` | Experimental | New in 0.10. The command, its flags, the page and the `/api/` JSON it reads may change in any release. Read-only except that proposals can be accepted (singly or in a batch) and rejected from it. |
+| `akm ui` | Experimental | New in 0.10. The command, its flags, the page and the `/api/` JSON it reads may change in any release. Browsing is read-only; explicit actions support proposals, feedback, bundle configuration and Markdown authoring. |
 | `akm info` | Stable | |
 | `akm bundle create` | Stable | |
 | `akm bundle add` | Stable | |
@@ -401,14 +401,25 @@ for scripted use.
   step that runs another workflow and returns its last step's output) are the
   least settled part and are kept only in that simple form; `akm workflow list
   --children` goes with them.
+
+  Per-key status today, from the Outcome section of
+  `docs/plans/0.10-workflows.md`. It stands until the promote-or-remove
+  decision in [#1096](https://github.com/itlackey/akm/issues/1096); every key
+  is still Experimental until then.
+
+  | Key | Status |
+  | --- | --- |
+  | `params`, `steps`, `inputs`, `output` / `unit.output`, `defaults.engine`, `### gate` | Core: the feature set pinned by `core-feature-set.test.ts` |
+  | exec units (`unit.exec`), `budget`, `unit.retry`, `map`, `gate.max_loops` | Kept in the 0.10 trim |
+  | child workflows (`unit.workflow`, `unit.with`) | Experimental: least settled |
 - **`akm metrics`** — new in 0.9.28. What it reports, its JSON shape and the
   `--format html` dashboard may change in any release; do not script against
   them.
 - **`akm ui`** — new in 0.10. A local web UI over the same data
   `akm health`, `akm metrics`, `akm config`, `akm proposal`, `akm search` and
-  `akm show` report. It is read-only except that proposals can be accepted
-  (singly or several at once, one commit) and rejected from it, through the
-  same functions `akm proposal accept` / `reject` call. The command's flags, the page, and the `/api/` JSON the
+  `akm show` report. Browsing is read-only. Explicit feedback, bundle/configuration,
+  knowledge-creation, revision-checked knowledge/memory editing and proposal-decision actions reuse existing AKM operations.
+  Historical restore remains unavailable. The command's flags, the page, and the `/api/` JSON the
   page reads (documented in `docs/reference/ui-api.md`) may change in any
   release; do not script against the API. The CLI's JSON output remains the
   scriptable surface.

package/dist/assets/prompts/memory-infer-system.md

@@ -1 +1 @@
-You compress a developer memory into one high-signal derived memory for later retrieval. Return only valid JSON. No prose outside the JSON object. No markdown fences.
+You compress a developer memory into one high-signal derived memory for later retrieval, or decide that it needs none. Return only valid JSON. No prose outside the JSON object. No markdown fences.

package/dist/assets/prompts/memory-infer-user.md

@@ -1,4 +1,5 @@
-Compress the memory below into one derived memory. Output ONLY a JSON object with exactly these fields: title, description, tags, searchHints, and content.
-Rules: title must be specific and short; description must be one sentence; tags must contain 3-8 specific tags; searchHints must contain 3-6 useful retrieval phrases; content must be a plain string with 2-3 sentences. Avoid vague generalizations, preserve key facts (names/versions/paths/config keys verbatim), and merge related points. Never return field descriptions or placeholder values.
+Decide whether the memory below needs a derived memory, then output ONLY a JSON object with exactly these fields: noChange, title, description, tags, searchHints, and content.
+No change: set noChange to true, title, description and content to empty strings, and tags and searchHints to empty arrays, only when a derived memory would add nothing for later retrieval: the memory is a tool-call count, a checkpoint or progress marker with no durable fact, or it is already a short, specific note that a rewrite would only restate. When in doubt, or when the memory contains any decision, cause, fix, version, path, config key or other fact worth finding later, do not use noChange.
+Otherwise set noChange to false and compress the memory into one derived memory. Rules: title must be specific and short; description must be one sentence; tags must contain 3-8 specific tags; searchHints must contain 3-6 useful retrieval phrases; content must be a plain string with 2-3 sentences. Avoid vague generalizations, preserve key facts (names/versions/paths/dates/config keys verbatim), and merge related points. Never return field descriptions or placeholder values.
 
 Memory:

package/dist/assets/ui/app.js

@@ -1,7 +1,7 @@
-// akm ui client: hash router and shell. Pages are modules that fetch from the read-only JSON API and return markup
+// akm ui client: hash router and shell. Pages read the local JSON API and return markup
 // built with the escaping `html` tag; this file only mounts it.
 
-import { errorState, getMeta, html, initToken, loadingState, mount } from "./lib.js";
+import { errorState, getMeta, hasUnsaved, html, initToken, loadingState, mount, setUnsaved, showFlash } from "./lib.js";
 
 initToken();
 
@@ -18,10 +18,27 @@ const ROUTES = [
   { name: "changes", label: "Changes", load: () => import("./changes.js"), render: (m, c) => m.render(c) },
   { name: "search", label: "Search", load: () => import("./search.js"), render: (m, c) => m.render(c) },
   { name: "asset", label: "Asset", nav: "search", load: () => import("./asset.js"), render: (m, c) => m.render(c) },
+  {
+    name: "edit",
+    label: "Edit Markdown",
+    nav: "search",
+    load: () => import("./editor.js"),
+    render: (m, c) => m.render(c),
+  },
+  {
+    name: "new",
+    label: "New knowledge",
+    nav: "search",
+    load: () => import("./editor.js"),
+    render: (m, c) => m.render(c),
+  },
 ];
 
 const main = document.getElementById("app");
 let sequence = 0;
+let shownHash = location.hash;
+let pendingHash = null;
+const unsaved = document.getElementById("unsaved");
 
 function parseHash() {
   const raw = location.hash.replace(/^#/, "") || "/overview";
@@ -44,6 +61,20 @@ function markNav(active) {
 }
 
 async function route() {
+  if (hasUnsaved()) {
+    // Keep the editor's address and ask inline; "Discard changes" repeats the navigation.
+    pendingHash = location.hash;
+    if (location.hash !== shownHash) history.replaceState(null, "", location.pathname + location.search + shownHash);
+    mount(
+      unsaved,
+      html`<p>You have unsaved changes.</p><p class="btn-row"><button type="button" class="btn-danger" data-act="discard">Discard changes</button><button type="button" class="btn-secondary" data-act="keep">Keep editing</button></p>`,
+    );
+    unsaved.hidden = false;
+    unsaved.querySelector("[data-act=keep]")?.focus();
+    return;
+  }
+  unsaved.hidden = true;
+  shownHash = location.hash;
   const mine = ++sequence;
   const { name, param, query } = parseHash();
   const entry = ROUTES.find((r) => r.name === name);
@@ -64,6 +95,7 @@ async function route() {
       if (mine !== sequence) return;
       mount(main, markup);
       for (const fn of ctx.after) fn(main);
+      showFlash(main);
       window.scrollTo(0, 0);
     }
   } catch (error) {
@@ -87,5 +119,30 @@ async function showMeta() {
 }
 
 window.addEventListener("hashchange", route);
+unsaved.addEventListener("click", (event) => {
+  const act = event.target.closest("button")?.dataset.act;
+  if (!act) return;
+  unsaved.hidden = true;
+  if (act !== "discard") return;
+  setUnsaved(false);
+  const target = pendingHash;
+  pendingHash = null;
+  // A same-hash target (Refresh view) fires no hashchange, so route directly.
+  if (target === null || target === location.hash) route();
+  else location.hash = target;
+});
+window.addEventListener("beforeunload", (event) => {
+  if (!hasUnsaved()) return;
+  event.preventDefault();
+  event.returnValue = true; // Older browsers ask only when this is set.
+});
+document.addEventListener("keydown", (event) => {
+  if ((event.ctrlKey || event.metaKey) && event.key.toLowerCase() === "k") {
+    event.preventDefault();
+    if (location.hash.startsWith("#/search")) document.querySelector('input[name="q"]')?.focus();
+    else location.hash = "#/search";
+  }
+});
+document.querySelector("[data-refresh]")?.addEventListener("click", route);
 showMeta();
 route();

package/dist/assets/ui/asset.js

@@ -1,7 +1,20 @@
 // Asset view: metadata, frontmatter table, the body as safe markdown, links and feedback.
 
-import { api, assetHref, badge, definitionList, emptyState, html, pageHeader, tableWrap, when } from "./lib.js";
-import { markdown, splitFrontmatter } from "./markdown.js";
+import { diffSection } from "./diff-view.js";
+import {
+  actionForm,
+  api,
+  assetHref,
+  badge,
+  definitionList,
+  emptyState,
+  html,
+  pageHeader,
+  post,
+  tableWrap,
+  when,
+} from "./lib.js";
+import { headingId, markdown, splitFrontmatter } from "./markdown.js";
 
 function linksBlock(links) {
   const groups = Object.entries(links ?? {}).filter(([, kinds]) => kinds && typeof kinds === "object");
@@ -18,11 +31,22 @@ function linksBlock(links) {
   return html`<section><h2>Links</h2>${tableWrap(html`<table><thead><tr><th>Direction</th><th>Kind</th><th>Assets</th></tr></thead><tbody>${rows}</tbody></table>`)}</section>`;
 }
 
-function feedbackBlock(feedback) {
+function feedbackBlock(feedback, ref, requireReason) {
   const counts = feedback?.counts ?? { positive: 0, negative: 0 };
   const history = feedback?.history ?? [];
   return html`<section><h2>Feedback</h2>
     <p><span class="num big text-ok">${counts.positive ?? 0}</span> <span class="muted">positive</span> &nbsp; <span class="num big text-fail">${counts.negative ?? 0}</span> <span class="muted">negative</span></p>
+    ${
+      ref
+        ? html`<form class="feedback-form form-grid">
+      <label>Feedback <select name="signal"><option value="positive">Helpful</option><option value="negative">Incorrect or stale</option></select></label>
+      <label>Reason <textarea name="reason" rows="2" placeholder="What helped, or what is wrong and should change"></textarea></label>
+      <p class="muted small">${requireReason ? "A reason is required for negative feedback. " : ""}A note that did not fit your task is not necessarily incorrect.</p>
+      <label>Tags <input name="tags" placeholder="Optional key:value tags, comma-separated (team:platform)"></label>
+      <button type="submit">Send feedback</button><div data-status></div>
+    </form>`
+        : ""
+    }
     ${
       history.length === 0
         ? emptyState("No feedback recorded for this asset.")
@@ -47,8 +71,46 @@ export async function render(ctx) {
       <div class="notice">${data.note}</div>`;
   }
   const asset = data.asset;
-  const { fields, body } = splitFrontmatter(asset.content);
+  const { fields, body, startLine } = splitFrontmatter(asset.content);
+  const canonical = data.durableRef ?? asset.ref;
+  const headings = (data.headings ?? []).filter((h) => h.slug);
+  const historyOpen = ctx.query.get("history") === "1";
+  let history = "";
+  if (historyOpen) {
+    const versions = await api("/api/asset/history", { ref: canonical, revision: ctx.query.get("revision") });
+    const diff = versions.diff ? diffSection(versions.diff) : null;
+    if (diff?.wire) ctx.after.push(diff.wire);
+    history = html`<section><h2>Document history</h2>${
+      !versions.available
+        ? emptyState("No Git history is available for this bundle.")
+        : html`
+      ${versions.commits.length === 0 ? emptyState("No committed version of this file.") : html`<ul>${versions.commits.map((c) => html`<li><a href="${assetHref(canonical)}&history=1&revision=${c.sha}">${c.shortSha}</a> ${c.subject} <span class="muted">${when(c.time)} · ${c.author}</span></li>`)}</ul>`}
+      ${diff?.markup ?? ""}`
+    }</section>`;
+  }
+  ctx.after.push((root) => {
+    actionForm(root, ".feedback-form", (_form, values) =>
+      post("/api/feedback", {
+        ref: canonical,
+        signal: values.get("signal"),
+        reason: values.get("reason"),
+        tags: String(values.get("tags") ?? "")
+          .split(",")
+          .map((t) => t.trim())
+          .filter(Boolean),
+      }),
+    );
+    const signal = root.querySelector('[name="signal"]');
+    const reason = root.querySelector('[name="reason"]');
+    signal?.addEventListener("change", () => {
+      reason.required = data.feedbackRequireReason && signal.value === "negative";
+    });
+    const section = ctx.query.get("section");
+    // ?section= keeps the plain slug; the heading's element id is prefixed.
+    if (section) requestAnimationFrame(() => document.getElementById(headingId(section))?.scrollIntoView());
+  });
   return html`${back}${pageHeader(html`<span class="mono wrap">${asset.ref}</span>`)}
+    <p class="action-links"><a href="${assetHref(canonical)}&history=1">Document history</a> · <a href="#/new">New knowledge</a>${asset.editable && ["knowledge", "memory"].includes(asset.type) ? html` · <a href="#/edit?ref=${encodeURIComponent(canonical)}">Edit Markdown</a>` : ""}</p>
     <div class="badges">${badge(asset.type, "info")}${asset.origin ? badge(asset.origin, "neutral") : ""}${asset.editable ? badge("editable", "ok") : badge("read-only", "neutral")}</div>
     <section>${definitionList([
       ["Name", html`<span class="mono">${asset.name}</span>`],
@@ -61,7 +123,10 @@ export async function render(ctx) {
       ["Path", html`<span class="mono wrap">${asset.path}</span>`],
     ])}</section>
     ${fields.length > 0 ? html`<section><h2>Frontmatter</h2>${tableWrap(html`<table class="fm"><tbody>${fields.map(([k, v]) => html`<tr><th scope="row" class="mono">${k}</th><td class="mono wrap pre-wrap">${v}</td></tr>`)}</tbody></table>`)}</section>` : ""}
-    <section><h2>Content</h2>${body.trim() === "" ? emptyState("This asset has no body.") : markdown(body)}</section>
+    ${headings.length > 1 ? html`<details class="contents" open><summary>On this page</summary><ul>${headings.map((h) => html`<li><a href="${assetHref(canonical)}&section=${encodeURIComponent(h.slug)}">${h.text}</a></li>`)}</ul></details>` : ""}
+    <section><h2>Content</h2>${body.trim() === "" ? emptyState("This asset has no body.") : markdown(body, { ref: canonical, bundle: data.bundle, links: data.links, headings: data.headings, startLine })}</section>
+    <details><summary>Markdown source</summary><pre class="code">${asset.content ?? ""}</pre></details>
+    ${history}
     ${linksBlock(asset.links)}
-    ${feedbackBlock(data.feedback)}`;
+    ${feedbackBlock(data.feedback, data.durableRef, data.feedbackRequireReason)}`;
 }

package/dist/assets/ui/bundles.js

@@ -1,7 +1,19 @@
 // Bundles: one card per configured bundle with git status and asset counts, plus the index state.
 
 import { proportionBar } from "./charts.js";
-import { api, badge, definitionList, emptyState, fmtNum, fmtPct, html, pageHeader, when } from "./lib.js";
+import {
+  actionForm,
+  api,
+  badge,
+  definitionList,
+  emptyState,
+  fmtNum,
+  fmtPct,
+  html,
+  pageHeader,
+  post,
+  when,
+} from "./lib.js";
 
 function gitBlock(git) {
   if (!git) return html`<p class="muted">Not a git repository.</p>`;
@@ -29,8 +41,10 @@ function gitBlock(git) {
 }
 
 function card(bundle) {
+  const writableKind = ["filesystem", "git"].includes(bundle.kind);
   return html`<article class="card">
-    <header class="card-head"><h3>${bundle.name}</h3>${badge(bundle.kind, "info")}${bundle.default ? badge("default", "neutral") : ""}${bundle.writable ? badge("writable", "ok") : badge("read-only", "neutral")}${bundle.exists ? "" : badge("missing", "fail")}</header>
+    <header class="card-head"><h3>${bundle.name}</h3>${badge(bundle.kind, "info")}${bundle.default ? badge("default", "neutral") : ""}${bundle.enabled ? "" : badge("disabled", "warn")}${bundle.writable ? badge("writable", "ok") : badge("read-only", "neutral")}${bundle.exists ? "" : badge("missing", "fail")}</header>
+    <p><a href="#/search?bundle=${encodeURIComponent(bundle.name)}">Browse assets</a></p>
     ${definitionList([
       ["Path", bundle.path ? html`<span class="mono">${bundle.path}</span>` : html`<span class="muted">none</span>`],
       [
@@ -44,6 +58,21 @@ function card(bundle) {
     ])}
     ${proportionBar(bundle.byType ?? {})}
     <h4>Git</h4>${gitBlock(bundle.git)}
+    <details><summary>Bundle settings</summary>
+      <form class="bundle-settings form-grid" data-bundle="${bundle.name}">
+        <p class="muted small">Settings from ${bundle.settingsSource ?? "configuration"}. Saving creates a local override. Component settings take precedence over the bundle writable default. Choose another default before disabling the default bundle.</p>
+        <label class="check"><input type="checkbox" name="enabled" data-initial="${bundle.enabled}" ${bundle.enabled ? html`checked` : ""}> Enabled</label>
+        <label class="check"><input type="checkbox" name="writable" data-initial="${bundle.writableSetting ?? bundle.kind === "filesystem"}" ${(bundle.writableSetting ?? bundle.kind === "filesystem") ? html`checked` : ""} ${writableKind ? "" : html`disabled`}> Bundle writable default</label>
+        ${(bundle.components ?? []).map((c) => html`<label class="check"><input type="checkbox" name="component:${c.name}" data-initial="${c.writable ?? bundle.writableSetting ?? bundle.kind === "filesystem"}" ${(c.writable ?? bundle.writableSetting ?? bundle.kind === "filesystem") ? html`checked` : ""} ${writableKind && c.configured && !c.name.includes(".") ? "" : html`disabled`}> ${c.name} writable <span class="muted small">(${c.adapter}, ${c.root ?? "."}${c.writable === undefined ? ", inherits default" : ", explicit override"})</span></label>`)}
+        <button type="submit">Save settings</button><div data-status></div>
+      </form>
+    </details>
+    <form class="bundle-update" data-bundle="${bundle.name}"><p><button type="submit" class="btn-secondary">Update / reindex bundle</button></p><div data-status></div></form>
+    <details><summary>Remove bundle</summary><form class="bundle-remove form-grid" data-bundle="${bundle.name}">
+      <p>Uses <code>akm bundle remove</code>. Managed installed content may be deleted; filesystem sources remain on disk.</p>
+      <label class="check"><input type="checkbox" name="confirm" required> Remove ${bundle.name}</label>
+      <button type="submit" class="btn-danger">Remove bundle</button><div data-status></div>
+    </form></details>
   </article>`;
 }
 
@@ -72,9 +101,57 @@ function indexPanel(index) {
   </div></section>`;
 }
 
-export async function render() {
+export async function render(ctx) {
   const data = await api("/api/bundles");
+  ctx.after.push((root) => {
+    actionForm(root, ".bundle-settings", (form, values) =>
+      post("/api/bundles/settings", {
+        bundle: form.dataset.bundle,
+        ...Object.fromEntries(
+          ["enabled", "writable"]
+            .filter(
+              (key) =>
+                !form.elements[key].disabled &&
+                form.elements[key].checked !== (form.elements[key].dataset.initial === "true"),
+            )
+            .map((key) => [key, values.has(key)]),
+        ),
+        componentWritability: Object.fromEntries(
+          [...form.querySelectorAll('input[name^="component:"]:not(:disabled)')]
+            .filter((input) => input.checked !== (input.dataset.initial === "true"))
+            .map((input) => [input.name.slice(10), input.checked]),
+        ),
+      }),
+    );
+    actionForm(root, ".bundle-defaults", (form, values) =>
+      post(
+        "/api/bundles/settings",
+        Object.fromEntries([...values].filter(([key, value]) => value !== form.elements[key].dataset.initial)),
+      ),
+    );
+    actionForm(root, ".bundle-add", (_form, values) =>
+      post("/api/bundles/add", { ...Object.fromEntries(values), writable: values.has("writable") }),
+    );
+    actionForm(root, ".bundle-update", (form) => post("/api/bundles/update", { bundle: form.dataset.bundle }));
+    actionForm(root, ".bundle-remove", (form, values) =>
+      post("/api/bundles/remove", { bundle: form.dataset.bundle, confirm: values.has("confirm") }),
+    );
+  });
+  const choices = (selected) =>
+    html`<option value="">Use fallback</option>${data.bundles.map((b) => html`<option value="${b.name}" ${b.name === selected ? html`selected` : ""}>${b.name}${b.enabled ? "" : " (disabled)"}</option>`)}`;
   return html`${pageHeader("Bundles", data.defaultBundle ? html`Default bundle <span class="mono">${data.defaultBundle}</span>${data.defaultWriteTarget ? html`, writes go to <span class="mono">${data.defaultWriteTarget}</span>` : ""}.` : "")}
+    <section><h2>Defaults</h2><form class="bundle-defaults form-grid card">
+      <label>Default bundle<select name="defaultBundle" data-initial="${data.defaultBundle ?? ""}">${choices(data.defaultBundle)}</select></label>
+      <label>Default write target<select name="defaultWriteTarget" data-initial="${data.defaultWriteTarget ?? ""}">${choices(data.defaultWriteTarget)}</select></label>
+      <button type="submit">Save defaults</button><div data-status></div>
+    </form></section>
     <section><h2>Configured bundles</h2>${data.bundles.length === 0 ? emptyState("No bundles are configured.", "Run akm init, or add one with akm bundle add.") : html`<div class="cards">${data.bundles.map(card)}</div>`}</section>
+    <section><h2>Add a bundle</h2><form class="bundle-add form-grid card">
+      <label>Source<input name="source" required placeholder="Local path, Git URL, npm package, or website URL"></label>
+      <label>Name<input name="name" placeholder="Optional bundle name"></label>
+      <label class="check"><input type="checkbox" name="writable"> Allow writes to a Git source (local directories are writable by default)</label>
+      <p class="muted small">Uses the existing source detection, validation and installation audit. Adding and updating sources can access the network.</p>
+      <button type="submit">Add bundle</button><div data-status></div>
+    </form></section>
     ${indexPanel(data.index)}`;
 }

package/dist/assets/ui/diff-view.js

@@ -137,7 +137,7 @@ function toolbar(mode, model) {
 
 function aligned(model, before, after, state) {
   if (model.same) {
-    return html`<p class="muted">No line differs between the current asset and the proposal${before === after ? "" : ", only line endings or the final newline"}.</p>`;
+    return html`<p class="muted">No line differs between these versions${before === after ? "" : ", only line endings or the final newline"}.</p>`;
   }
   const body =
     state.mode === "inline"

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;
+      }
+    });
+  });
+}