akm-cli 0.10.261008-beta → 0.10.261010-beta

package/CHANGELOG.md

@@ -6,6 +6,103 @@ 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
+
+- Search and curate default to `--belief current`, retaining unflagged reference
+  knowledge and active/asserted assets while excluding historical beliefs (#1199).
+  Use `--belief all` for broad investigation or `--belief historical` for old
+  evidence. Curate accepts search's repeatable `--filter` scope controls, and the
+  public `akm-cli/api` options add `source`, normalized `filters`, and `belief`.
+  The same eligibility follows derived surfaces, linked support and packed
+  content; historical results are labelled. Belief labels do not establish factual
+  truth. No migration or reindex is required; direct show remains available. The default
+  also applies to `akm ui` search, `akm remember --show-similar` and the related assets
+  distill reads.
+
+### Fixed
+
+- Search applies eligibility filters (scope, source, type, belief state, proposed quality)
+  before each channel's candidate limit instead of after it (#1198). An eligible asset ranked
+  below many ineligible ones in the keyword or semantic channel is no longer dropped before
+  filtering. The vector channel checks eligibility in similarity order, so unfiltered searches
+  load only the top candidates. No index migration or reindex is needed.
+
+- Extraction proposals retain captured `evidence`, optional guidance and known session sources
+  in the Markdown actually published by acceptance (#1196). Reindexing and full/agent `show` preserve
+  the support; compact discovery continues to provide refs for follow-up. Earlier pending
+  proposals require explicit review/repair of their separate evidence payload; existing accepted
+  notes are not backfilled. Run `akm index --full` to project evidence already present in old files.
+- Invalid health comparison windows are rejected before runtime probes can prepend an unrelated
+  installed-agent advisory to the JSON usage error.
+
+- OKF and LLM Wiki indexing no longer records relationships from links inside code spans,
+  fenced or indented code, including code nested in lists and blockquotes (#1200). Links are
+  read with the `marked` tokenizer (new runtime dependency) instead of raw regex scans; the
+  indexed link syntax is otherwise unchanged. Run `akm index --full` once to drop false
+  relationships stored by earlier builds; incremental indexing keeps unchanged files' old links.
+
+- Consolidation preserves the existing `scope_user`, `scope_agent`, `scope_run`, and
+  `scope_channel` tuple (#1197). Pairing requires exact normalized equality before
+  consuming an eligible neighbor slot. Retirement acceptance, including resume, checks
+  live scopes against the judged tuple; promotion refuses incompatible source/output
+  scopes and preserves differently scoped derived twins. Older retirements without a
+  recorded judged tuple remain readable but require rejection/reassessment before
+  acceptance. Staged stale decisions use the existing stale-target rejection/retry
+  path. No database migration is needed; review pending work before unattended drain.
+
+- Consolidation assesses complete note bodies in both retirement checks instead of silently
+  cutting each at 12,000 characters. Requests exceeding the selected engine's context window fail conservatively;
+  failed second checks leave proposals pending and unstaged. Before unattended proposal drain,
+  review and reject/reassess pending or staged retirements produced by older builds when either
+  body exceeded the former cutoff. An upgrade does not revalidate those decisions. No storage
+  migration is needed; accepted retirements remain recoverable with `akm proposal revert <id>`.
+
+### Changed
+
+- The consolidation pair judge reports claim differences; AKM derives `duplicate`, `subsumed`,
+  or `overlap` and the redundant side from those lists. It no longer asks the model to repeat
+  that decision in relation/pointer fields. Replacement retirements use `subsumed`; historical
+  queued labels remain readable. Lexical attention hints accompany complete bodies and never
+  substitute for assessing their meaning.
+
 ## [0.10.261008] - 2026-10-20
 
 ### Fixed

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.
@@ -471,10 +482,16 @@ lane (#1143): the `default` strategy runs it without the opt-in, bounded by
 `akm proposal drain --promote`. Only a promote that turns the judgment tier on
 needs `experimental.improveAutonomy`.
 
-Consolidation remains enabled with autonomy off: both its passes (promotion,
-and the pair pass's duplicate/subsumed/supersedes judging) only ever emit a
-reviewable proposal, and a pair-pass `retire` proposal is never auto-accepted
-by `triage` `applyMode: "promote"` regardless of this gate.
+Consolidation remains enabled with autonomy off. Both passes emit proposals;
+the pair pass stages a retirement when its claim checks pass and there is no
+continuity risk. `triage` with `applyMode: "promote"` can accept that staged
+retirement unattended; an unstaged retirement stays pending. Both retirement
+checks receive complete note bodies with lexical attention hints, so the selected
+engine must accommodate them. The pair judge supplies distinct-claim lists; AKM
+derives duplicate/subsumed/overlap outcomes and retirement direction from those
+lists. Historical queued retirement labels remain readable. Before unattended drain after an upgrade, review pending/staged
+retirements produced by older builds from notes over 12,000 body characters:
+upgrading does not revalidate their evidence (#1195).
 
 Because the gate is applied before the LLM preflight, a review-first workspace
 also needs fewer engines configured: a strategy whose only model-backed process

package/dist/api.d.ts

@@ -10,6 +10,12 @@ export interface CurateOptions {
   limit?: number;
   /** Asset type filter, same as `--type`. */
   type?: string;
+  /** Named bundle or local|registry|all, same as --from. */
+  source?: string;
+  /** AND-joined exact scope values, same as repeated --filter. */
+  filters?: { user?: string; agent?: string; run?: string; channel?: string };
+  /** Default current; labels do not establish factual truth. */
+  belief?: "all" | "current" | "historical";
   /** Output format, same as `--format`. Default `"json"`, as in the CLI. */
   format?: "text" | "json";
 }

package/dist/api.js

@@ -35,7 +35,18 @@ export async function curate(query, options = {}) {
         const mode = resolveOutputMode(["--detail", "agent", "--format", format], loadConfig().output ?? {});
         const disposeLlmUsageSink = installLlmUsagePersistenceIfAbsent();
         try {
-            const curated = await runCurate({ query, type: options.type, limit: options.limit === undefined ? undefined : String(options.limit) }, mode);
+            const curated = await runCurate({
+                query,
+                type: options.type,
+                limit: options.limit === undefined ? undefined : String(options.limit),
+                from: options.source,
+                belief: options.belief,
+                filters: options.filters === undefined
+                    ? undefined
+                    : Object.entries(options.filters)
+                        .filter(([, value]) => value !== undefined)
+                        .map(([key, value]) => `${key}=${value}`),
+            }, mode);
             return stdoutText(renderOutput("curate", curated, { ...mode, format }));
         }
         finally {

package/dist/assets/prompts/consolidate-pair-check.md

@@ -2,4 +2,6 @@ You check whether deleting note X from one person's agent-memory library would l
 
 A durable claim is a fact, decision, value, command, flag, path, file name, URL, number, version, name, error message, condition or rule someone would act on. Ignore wording, headings, dates of writing, tags and boilerplate. A claim is stated when Y says it in any wording or format, or replaces it with a newer value. It is not stated when Y is vaguer (a config file instead of the specific path) or drops a number, command, step or condition. Read X's description as part of X. Write each item as a short phrase that quotes its identifier. Use [] when Y states everything.
 
+Check the complete X, including its ending, one claim at a time against Y. A missing claim must actually be stated by X and absent from Y in meaning, not just in wording. Extra detail stated only by Y does not belong in missing. Repetition adds no claim. Before answering, remove any item that Y already states or replaces for the same named thing.
+
 Answer ONLY with JSON: {"missing": ["..."]}

package/dist/assets/prompts/consolidate-pair-same-age.md

@@ -0,0 +1 @@
+The two notes have the same creation date: neither is newer, so the chronological replacement rule does not apply. Different values for the same named thing conflict unless the text explicitly says one replaces the other. Treat an unresolved conflicting value as a distinct claim. A note's position in this prompt does not establish which value is current.

package/dist/assets/prompts/consolidate-pair-terms.md

@@ -0,0 +1,6 @@
+Lexical attention hints from the complete notes above:
+{{DIFFERENCES}}
+
+Check these terms in their original context. They are not claim lists: different tokens can express the same claim or a replaced value, and equal token sets do not prove equal claims. Assess the complete notes, including claims that these hints do not distinguish.
+
+Before leaving a side's claim list empty, check the source sentence of every exclusive term. Commands, flags, paths, URLs, numbers, versions and conditions must keep their specific meaning: a shared generic word does not preserve an omitted command or rule. Verify that every claim you list is absent from the other complete note in meaning.

package/dist/assets/prompts/consolidate-pair.md

@@ -1,6 +1,6 @@
-You compare two assets from one person's agent-memory library (memories and knowledge notes an AI coding agent reads). Asset A is the OLDER one and asset B the NEWER one, by the dates shown, unless both carry the same date and are labelled "same age". akm deletes one of them only when the other keeps every claim a reader would need, so your two lists decide what is safe to delete.
+You compare the complete claims of two assets from one person's agent-memory library. Use the supplied dates: when both dates are equal, neither note is newer. A note can be deleted only when the other preserves every claim it states.
 
-First list what each asset has that the other lacks:
+Compare the complete meaning of both assets before answering. Claims are equivalent when they give a reader the same facts, conditions and action, even with different wording. For example, "the build runs `make test`" and "`make test` is the build test command" are the same claim; `make test-fast` is a different command. First give a concise account of what distinguishes the claims of the two notes, including whether a value is explicitly replaced. There may be no safe deletion. Then list only claims that the other asset genuinely lacks:
 - "onlyInA": every durable claim of A that B does not state or replace.
 - "onlyInB": every durable claim of B that A does not state or replace.
 
@@ -8,14 +8,6 @@ A durable claim is a fact, decision, value, command, flag, path, file name, URL,
 
 B replaces a claim of A only when both are about the same named thing (the same service, integration, partner, component, region or file) and B gives a new value for it that is current: B says so (now, instead of, since, renamed, corrected, no longer) or B is created later than A. Notes about different named things never replace each other, whatever their dates: list each one's own name, value and path as its claims. A different value for the same thing with neither sign is a conflict, not a replacement: list A's value in "onlyInA" and B's value in "onlyInB".
 
-Then classify the relation as exactly one of:
-- "duplicate": both lists are empty.
-- "subsumed": exactly one list is empty. The asset with the empty list is redundant.
-- "supersedes": B replaces a claim in A as defined above (a newer version, a changed decision, a fixed bug, a new value), and onlyInA is empty.
-- "contradicts": they make logically exclusive claims about the same thing and nothing shows which one is current: B does not say it replaces the claim and was not created later.
-- "overlap": same subject, and both lists have items.
-- "unrelated": different subjects, or different named things written to one layout (two services, partners or regions), or different facts that happen to share words.
+Before answering, check the final claim lists against the complete notes, including their endings. Every item in onlyInA must be stated by A and neither stated in other wording nor replaced by B; check onlyInB symmetrically. Remove equivalent or replaced claims. The reason must agree with the final lists.
 
-Set "redundant" to the asset that could be deleted with no loss: "A" for "duplicate", the asset with the empty list for "subsumed", "A" for "supersedes"; else null. Set "stale" to "A" when the relation is "supersedes", else null.
-
-Answer ONLY with JSON: {"onlyInA": ["..."], "onlyInB": ["..."], "relation": "...", "redundant": "A"|"B"|null, "stale": "A"|null, "confidence": 0.0-1.0, "reason": "<at most 25 words: name the asset that can be deleted and what the other asset still holds; for supersedes, quote the words of B that replace the claim or say B is created later>"}
+Answer ONLY with JSON: {"reason": "<at most 25 words: the distinct claims of each side, or that their claims are equivalent; quote any explicit replacement>", "onlyInA": ["..."], "onlyInB": ["..."], "confidence": 0.0-1.0}

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"