akm-cli 0.9.0-beta.2 → 0.9.0-beta.26

package/CHANGELOG.md

@@ -6,6 +6,459 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/).
 
 ## [Unreleased]
 
+## [0.9.0-beta.26] — 2026-06-20
+
+### Added
+
+- **#628 — configurable SQLite journal mode (`AKM_SQLITE_JOURNAL_MODE`) for network
+  filesystems.** AKM previously opened every database with `PRAGMA journal_mode = WAL`
+  unconditionally, which cannot run on a network filesystem (NFS/SMB/Azure Files) —
+  WAL's `-shm` shared-memory wal-index can't be `mmap`'d over a network mount. You can
+  now set `AKM_SQLITE_JOURNAL_MODE` to `WAL` (default), `DELETE`, or `TRUNCATE`, applied
+  at **all five** db openers (`state.db`, `index.db` ×2 paths, `workflow.db`, `logs.db`).
+  At the `WAL` default AKM auto-detects a network mount for the data dir and transparently
+  falls back to `DELETE` (rollback journal + `synchronous = FULL`) with a one-line warning;
+  invalid values warn once and fall back to `WAL`. **Default behavior is byte-identical.**
+  This lets the AKM database subtree live on a shared volume (e.g. Azure Files under
+  Azure Container Apps). New docs section "Hosting AKM databases on a network share
+  (NFS/SMB)" in `docs/configuration.md`.
+
+## [0.9.0-beta.25] — 2026-06-19
+
+Completes the recombine / extract-efficiency / graph thread. All new improve
+passes are **opt-in (default off)**, so default behavior is unchanged.
+
+### Added
+
+- **#606 — event-driven extract (`akm extract --watch`).** Opt-in watch mode: an
+  injectable, debounced watcher triggers extraction shortly after a session file
+  appears, with a clean `stop()` handle. The `8,28,48` cron remains the fallback;
+  no daemon is auto-launched.
+- **#625 — recombine second pass (hypothesis → lesson).** The opt-in `recombine`
+  process (#609) now consumes `confirmThreshold` (default 2): a generalization
+  re-induced that many consecutive runs is promoted from a `type: hypothesis`
+  proposal to a `type: lesson` proposal through the normal queue + quality gate
+  (never a direct stash write). Hypotheses that stop recurring decay. Backed by a
+  new `recombine_hypotheses` table in `state.db`.
+
+### Changed
+
+- **#624 (P1) — graph storage decoupled from `entries.id`.** `graph_files` is
+  re-keyed on `(stash_root, file_path, body_hash)`, so extracted graph data now
+  **survives a reindex** of unchanged files instead of being cascade-wiped. The
+  upgrade is migrated in a **targeted, graph-only path** that preserves existing
+  graph data and leaves the entry index, embeddings, FTS, and LLM-enrichment cache
+  untouched — **no full index rebuild and no re-embed** on upgrade. (P2 priority-
+  ranked extraction and P3 lazy/on-demand extraction remain deferred.)
+
+### Fixed
+
+- Graph re-key migration no longer triggers a destructive full-index rebuild: it
+  is a graph-scoped table migration (no `DB_VERSION` bump), and it **copies** the
+  existing graph rows into the new schema rather than dropping them.
+- Test-suite `/tmp` hygiene: sandbox teardown now fires on `SIGINT`/`SIGTERM`/
+  `SIGHUP` (not just clean exit), and a `sweep:tmp` step reclaims stale `akm-*`
+  sandbox dirs left by force-killed workers — eliminating the tmpfs accumulation
+  that caused intermittent `EEXIST: epoll_ctl` test flakes.
+
+## [0.9.0-beta.20] — 2026-06-18
+
+### Fixed
+
+- **`akm update --all` no longer fails for writable `github:` entries stored as `source:"git"`**. `updateRegistryEntry` was using `synced.source` (re-derived from the ref scheme as `"github"`) instead of the existing `entry.source`, causing the config validator to reject `writable:true` on every update cycle.
+
+## [0.9.0-beta.19] — 2026-06-17
+
+### Fixed
+
+- **`akm feedback` now completes in ~0.3s** (was 3+ minutes). Root cause: the command was calling `ensureIndex` with `mode: "blocking"` inside `withIndexWriterLease`, triggering a full reindex on every feedback call. Fix: removed the `ensureIndex` call entirely (feedback only needs the index to exist, not be current — a stale index is fine for ref lookup); removed the application-level writer lock (SQLite WAL + `busy_timeout=30s` handles concurrent access with `akm improve`); added a fast DB-exists guard with a clear error for first-time users.
+- **`akm health --format html` now completes in ~11s** (was ~18s). Root cause: `akmHealth()` was called twice — once for the main result and once to get `deltas`. Fix: merged into a single call passing both `groupBy: "run"` and `windowCompare` together.
+
+## [0.9.0-beta.18] — 2026-06-17
+
+### Changed
+
+- **Health report: Recent Runs table now shows all filtered runs in descending order** (newest first) instead of capping at the last 10.
+- **Health report: Removed "Command Set Used" section.**
+- **Health report: All timestamps now display in the viewer's local timezone** (chart axis labels, runs table, freshness line, executive summary, footer). Server-rendered ISO strings are wrapped in `<time data-iso>` elements and converted to local time by client-side JS on page load.
+
+### Changed (migration required)
+
+- **WS-2 outcome loop (#613) — default-off weight change (state.db migration 010).**
+  Every `akm improve` run now writes an `asset_outcome` row per processed asset
+  (state.db migration `010`) and computes a differential usefulness signal
+  (`outcome_score`) per ref. The outcome signal is persisted and visible in the
+  health report, but the **weight change is gated behind a config flag** (see
+  below). Ranking is unchanged from WS-1 by default.
+
+  **Opt-in weight change.** The WS-2 projection weights (`w_e=0.25, w_o=0.15,
+  w_r=0.60`) affect ranking only when you explicitly set
+  `improve.salience.outcomeWeightEnabled: true` in your `akm.yaml`. The default
+  (`false`) keeps WS-1 parity weights (`w_e=0.30, w_r=0.70`, `w_o=0`), so
+  existing users see no ranking change on upgrade.
+
+  **Part-V measurement gate.** Before enabling the weight change, run the Part-V
+  T0 baseline (`scripts/akm-eval` + `akm health`; confirm proactive accept
+  ≥ 0.9× reactive; reversion ≤ 0.15; retrieval-delta ≥ 0; coverage not
+  regressed). That gate requires a running production stash and cannot be
+  exercised in CI. Once confirmed, set
+  `improve.salience.outcomeWeightEnabled: true` to activate the three-way split.
+
+  **Outcome loop mechanics.** `outcome_score` is a differential prediction-error
+  signal: `(retrieval_delta − expected_delta) − PENALTY × retrieval_delta × (1 −
+  accepted_change_rate) + valence`, tracked via an EMA (α=0.3). New rows are
+  warm-started from the utility EMA score (clipped to 0.3) so the signal is
+  non-zero from launch. A stash-wide diversity floor (10% of the max score) prevents
+  rare-but-correct assets from being permanently outcompeted. An inverted-proxy
+  tripwire (`corr(outcome_score, accepted_change_rate) < −0.3`) emits an
+  `outcome_proxy_inverted` health event when the signal degrades.
+
+  `review_pressure` is computed and persisted per asset but is **not yet wired into
+  the admission policy** — that is deferred to a later work stream per plan §Part-VI
+  #613. The column is present and populated; routing it into the consolidation-
+  selection filter is the next step.
+
+- **WS-1 salience vector (#618) — default-on ranking change.** The eligibility sort
+  for all `akm improve` runs (whole-stash, type, and ref scope) has changed from
+  `combinedEligibilityScore = utility·0.7 + negativeOnlyRatio·0.3` to
+  `rankScore = (0.3·encodingSalience + 0.7·retrievalSalience) × sizePenalty`
+  (feedback valence and utility EMA dropped from ordering until WS-2 re-introduces
+  outcome salience). Assets are now ranked by retrieval frequency × recency × type
+  importance rather than by feedback magnitude. Because the old
+  `combinedEligibilityScore` ordering was never persisted, a forgetting comparison is
+  not possible on the first run; instead a one-time `improve_salience_first_run` marker
+  event is emitted to record the transition. On every subsequent run a stash-wide
+  `improve_salience_rank_change` drift report (including `stashSize`) is emitted so
+  rank movement under the new scoring can be tracked over time.
+  The Part-V measurement protocol (T0 baseline via `scripts/akm-eval` + health report,
+  throughput/quality gate) is deferred to the WS-2 milestone, when outcome salience
+  re-joins the projection and re-tuning is triggered.
+
+## [0.9.0-beta.12] - 2026-06-15
+
+Improve-tuning work streams (all **default-off / parity-preserving** — no behavior
+change until explicitly enabled).
+
+### Added
+
+- **#617 — deterministic near-duplicate memory dedup** (`processes.consolidate.dedup`,
+  default off). A cheap no-LLM pre-pass in front of consolidation collapses obvious
+  duplicates — `.derived`+origin pairs and content twins (normalized content-hash
+  equality, or embedding cosine ≥ `cosineThreshold`, default 0.97). Each dropped
+  variant is archived + backed up before deletion; hot memories are never
+  collapsed; distinct-but-related memories fall through to the LLM.
+- **#581 — judged-state cache for consolidation** (`processes.consolidate.judgedCache`,
+  default off). New state.db table (`consolidation_judged`) records each memory's
+  content hash + outcome when the LLM judges it; subsequent runs skip
+  judged-unchanged memories, converting coverage from O(time-window) to
+  O(changed/new) so a run can sweep the full corpus. Fails open; failed chunks
+  and dry-runs never poison the cache. (state.db migration `007`.)
+- **#612 — auto-accept gate calibration** (`improve.calibration`, auto-tune default
+  off). Joins predicted gate confidence to realized accept/reject outcomes into a
+  reliability table + calibration gap, surfaced in `akm health` (+ summary rows in
+  the HTML report). Opt-in bounded threshold auto-tune nudges the accept threshold
+  within a configured band toward a target accept rate, logged via a
+  `calibration_autotune` event. (Replay-prioritization from prediction error is
+  deferred — it depends on the #610 replay budget, a 0.10 item.)
+
+### Fixed
+
+- **#614 — symmetric valence weighting** (`profiles.improve.*.symmetricValence`,
+  default off). The eligibility sort weighted feedback negative-only; when enabled
+  it uses a symmetric `|valence|` magnitude so strong positive and strong negative
+  feedback both drive attention (utility stays the dominant factor), routing
+  high-negative → fix and high-positive → reinforce lanes.
+
+## [0.9.0-beta.11] - 2026-06-15
+
+### Added
+
+- **`extract.maxSessionsPerRun`** (default 25) — caps the NEW sessions the
+  extract pass LLM-processes in a single run so a backlog (e.g. after downtime)
+  can't push one run past its scheduled-task timeout. Overflow sessions stay
+  unseen and are picked up by later runs, so coverage is preserved. `0` disables.
+
+### Fixed
+
+- **Auto-accept validation failures are no longer a blind leak.** When a
+  confidence-passing proposal fails promotion validation, the gate now captures
+  the reason (the `validateProposal` finding kind, e.g. `validation:description-quality`),
+  records it on the proposal (`akm proposal show` explains the rejection), logs
+  it, and exposes `failedByReason` on the gate result — so the ~5% leak is
+  diagnosable instead of silently warned-and-dropped.
+- **Inflated skip-reason aggregates in `akm health`.** `no_new_signal` /
+  `profile_filtered_all_passes` are per-run snapshots of a stable set; the
+  window aggregator summed their per-run counts (≈2.7M / 3M). It now uses the
+  most recent run's count for these aggregated-snapshot reasons while still
+  summing genuine per-occurrence skips.
+
+## [0.9.0-beta.10] - 2026-06-15
+
+### Added
+
+- **#603** — `akm health` pool-saturation advisory. Instead of alerting on the
+  raw `sessionsScanned` count (which false-alarmed on normal cadence changes),
+  a new `pool-saturation` advisory reports the ratio of new (unseen) sessions
+  to the total session pool: informational below 10% (expected steady state),
+  warning below 2% (possible discovery/dedup bug). Heuristic, never gates
+  overall status.
+- **#576** — the `akm health` HTML report now renders the real per-stage LLM
+  token/time aggregate (a "🧠 LLM Work" KPI card + LLM token/call/wall-time
+  summary rows) from the captured `llm_usage` events, replacing the GPU-time
+  proxy.
+- **Built-in `akm health --format html` report overhaul** — the report is now a
+  strict superset of (and supersedes) the external `akm-health-report` stash
+  skill. Restored the interactive filter bar (time-slice 1d–21d, task, status)
+  with client-side chart/table re-render and the Last-10 "Task" column;
+  reordered sections to a decision-first flow (verdict → action items → KPIs →
+  table → charts); added a synthesized one-sentence **Verdict** (status + 2–3
+  drivers) and a freshness line; merged the duplicate Advisories / What-to-Watch
+  into one prioritized, de-duplicated **Action Items** list (P1/P2/P3 +
+  remediation command); added a per-stage **LLM token** stacked-bar chart and
+  `dataZoom` sliders on dense charts; fixed the failed-run scatter x-alignment
+  (now shape-encoded); KPI-card colors are now health signals (not decoration);
+  added metric-glossary tooltips, chart `aria-label`s, contrast fixes, and
+  empty-state overlays. Deterministic output preserved.
+
+### Fixed
+
+- **Health report accuracy** (follow-ups to the overhaul): the per-run **Task**
+  column/filter now show the real scheduled task (`akm-improve-frequent`, …) via
+  a ±5min `task_history` join instead of the run's scope (which is `all` for
+  every scheduled run); the time-**slice** filter options are now derived from
+  the report's `--since` window (e.g. All/3d/1d/12h/6h for a 7d report) and
+  default to "All" — replacing the hard-coded 1d–21d list that didn't match the
+  window; and the trend **deltas** now default their compare window to `--since`
+  (like-for-like, e.g. last 7d vs prior 7d) instead of a fixed 24h, which had
+  produced nonsensical period-over-period percentages on multi-day reports.
+- **Inflated stash-snapshot metrics in `akm health`.** `memorySummary`
+  (derived/eligible) and `profileFilteredRefs` are whole-stash snapshots recorded
+  on every run, but the window aggregator was **summing** them across all runs —
+  e.g. "915,258 of 1,226,025 eligible" and a 2.4M filtered-ref count. They now
+  take the most recent run's snapshot (the current state). Per-run *work* metrics
+  (promoted, MI written, graph entities, …) remain genuine window sums.
+- **Health report polish:** the akm version is stamped in the header (under the
+  AKM logo) and footer; the steady-state `no new signal since last proposal`
+  distill reason is excluded from the skip-reason chart (it drowned out the
+  actionable reasons); and the Consolidation Output chart now draws Promoted as a
+  line on a secondary right-hand axis (it dwarfs merged/deleted) with merged and
+  deleted as bars on the left axis.
+
+- **#598** — process-level tuning fields (`consolidate.incrementalSince`,
+  `minPoolSize`, `neighborsPerChanged`, `extract.minContentChars`, per-process
+  `enabled` flags) now survive an `akm config` rewrite. They are first-class
+  typed `ImproveProcessConfigSchema` fields, so the load→save round trip no
+  longer silently drops them. Unknown process sub-keys hard-error at load
+  (`ConfigError`) rather than being silently discarded — the deliberate,
+  documented resolution. Regression-guarded by
+  `tests/config-process-roundtrip.test.ts`.
+
+## [0.9.0-beta.9] - 2026-06-14
+
+Restore and instrument `akm improve` steady-state output. The reflect/distill
+self-improvement lanes had been near-zero in steady state because the
+signal-delta eligibility gate was the only lane (cache "no-access = no-work"
+pathology) and the high-retrieval fallback was structurally dead. This release
+revives proactive improvement, adds attribution + a measurement/kill-criterion
+system so the lane must prove its value, and right-sizes reflect budgets to
+their task timeouts.
+
+### Added
+
+- **Proactive maintenance selector** (`proactiveMaintenance` improve process):
+  due-gated, composite-priority (`importance × log(1+retrievalFreq) ×
+  recencyDecay / log(size)`), bounded rotating top-N reflect/distill over
+  stale/never-reflected assets. **Disabled by default**; enable per profile.
+- **Eligibility attribution**: every reflect/distill proposal is stamped
+  `eligibilitySource ∈ {signal-delta, high-retrieval, proactive, scope,
+  unknown}` on `reflect_invoked`/`distill_invoked`/`promoted` events and the
+  proposal record, so outcomes are sliceable by lane.
+- **Measurement system** under `scripts/akm-eval/`: a real-query retrieval suite
+  generated from `usage_events`, and `akm-eval-proactive-verdict` — a read-only
+  kill-criterion runner comparing the proactive lane (treatment) vs due-but-
+  untouched assets (control). Emits PASS/FAIL/INCONCLUSIVE and recommends
+  disabling the lane on FAIL. New `proactive_selected` event +
+  `proactiveSelected`/`proactiveDueTotal`/`proactiveNeverReflected` fields on
+  `improve_completed`.
+
+### Fixed
+
+- Revived the P0-A high-retrieval fallback: genuinely zero-feedback assets were
+  routed to the fully-skipped branch one phase before the fallback could see
+  them, so frequently-retrieved-but-never-rated assets were never improved.
+- `getRetrievalCounts` now normalizes bare vs `origin//`-prefixed refs (it was
+  dropping ~half the retrieval signal) and counts `curate` events
+  (`akm curate` now records per-item `entry_ref`).
+- The fully-skipped `no_new_signal` branch emitted one `improve_skipped` event
+  per ref (~11K writes/run, ~400K rows/day) — a contributor to 900s improve
+  timeouts and state.db bloat. Collapsed into one aggregated counted event.
+
+## [0.9.0-beta.8] - 2026-06-13
+
+Fix multi-process SQLite contention in `index.db` and harden concurrent proposal
+queue mutations.
+
+### Changed
+
+- Added a global `index.db` writer lease used by foreground indexing,
+  background auto-index, improve maintenance index writers, graph updates, and
+  feedback writes.
+- Replaced the racy background index PID-file dedup flow with lease-based
+  coordination and explicit handoff to the spawned worker.
+- `akm feedback` now uses blocking index preparation and writes under the same
+  `index.db` lease, avoiding self-inflicted `database is locked` failures.
+- Proposal queue create/archive/gate-decision mutations now run under
+  `BEGIN IMMEDIATE` state.db transactions so concurrent processes serialize on
+  live queue state.
+
+## [0.9.0-beta.7] - 2026-06-13
+
+Fix the `akm improve` regression introduced by background `ensureIndex`.
+
+### Changed
+
+- Added an explicit `ensureIndex` mode so callers choose `background` or
+  `blocking` behavior directly instead of relying on hidden environment state.
+- `akm improve` now uses blocking index preparation before collecting eligible
+  refs, restoring the post-upgrade empty-index recovery path.
+- Removed the `AKM_INDEX_INLINE` test-only override so tests exercise the same
+  index behavior model as production.
+
+## [0.9.0-beta.6] - 2026-06-12
+
+Pipeline optimization: new per-process config fields wire up the consolidation
+and improve pipeline knobs exposed by the optimization report — incremental
+consolidation, pool caps, distill gating, and memory inference throttling.
+
+### Added
+
+- **`consolidate.incrementalSince`** — profile config field that narrows the
+  consolidation candidate pool to memories modified within the given window
+  (e.g. `"1h"`, `"4h"`) plus their graph neighbours. Enables frequent
+  consolidation passes (e.g. `quick-shredder` every 15 min) without full-pool
+  sweeps. Absent = full-pool sweep (correct for nightly runs).
+- **`consolidate.limit`** — hard cap on memories processed per consolidation
+  pass, applied after incremental narrowing. Prevents runaway full-pool sweeps
+  in the nightly default profile.
+- **`consolidate.neighborsPerChanged`** — configurable graph-neighbour count
+  per changed memory during incremental consolidation (was hardcoded to 5).
+  `quick-shredder` sets this to 3 for a 40% candidate reduction per burst.
+- **`distill.requirePlannedRefs`** — when `true`, the distill process is
+  skipped entirely for distill-only refs when the reflect phase produced zero
+  planned refs. Eliminates hundreds of `distill-skipped` events on quiet passes
+  where all refs are on reflect cooldown.
+- **`memoryInference.minPendingCount`** — minimum pending split-parent memory
+  count below which the inference pass is skipped entirely (zero LLM calls).
+  Prevents lock acquisition on passes where there is nothing to infer.
+- **`reflect.limit`** — per-process ref limit for the reflect/distill loop,
+  applied as the improve run limit when no CLI `--limit` is given.
+- **New `reflect-distill` improve profile** — dedicated reflect + distill + 
+  memoryInference + triage profile for the every-4h `akm-improve-frequent`
+  task. `reflect.limit: 25` bounds LLM cost per pass.
+
+### Changed
+
+- **`quick-shredder` profile tuned**: `incrementalSince` `4h` → `1h`,
+  `maxChunkSize` 25 → 35, added `minPoolSize: 10`, `neighborsPerChanged: 3`,
+  `memoryInference.minPendingCount: 5`. All `profile: "qwen-9b-shredder"`
+  process references removed — falls back to default LLM.
+- **`default` improve profile** (nightly): extract disabled (dedicated
+  `akm-extract` task runs at 01:48), consolidate gets `limit: 500`,
+  reflect gets `limit: 100` and `allowedTypes`, distill gets
+  `requirePlannedRefs: true`, triage enabled at 50 accepts/run,
+  graphExtraction explicitly enabled.
+- **Cron schedule optimised**: extract reverted to `8,28,48 * * * *` (3×/hr),
+  quick-shredder shifted to `4,19,34,49` (4-min extract gap), health-report
+  shifted to `:03` (avoids `:00` collision), `akm-improve-frequent` re-enabled
+  at `45 */4` with `reflect-distill` profile.
+
+## [0.9.0-beta.3] - 2026-06-12
+
+Stabilization batch closing the remaining 0.9.0 milestone: DB-locking and
+improve-pipeline perf backports, extract/reflect gate fixes, SQLite-first
+proposal and log storage, `--format html` output, and per-stage LLM telemetry.
+
+### Added
+
+- **`--format html` output with per-command templates** (#582). `akm health
+  --format html` renders the full interactive health report (ECharts inlined by
+  default, or via CDN with `AKM_ECHARTS=cdn`); every other command falls back to
+  a dark-mode default template that pretty-prints its JSON. A global `--output
+  <path>` flag writes the rendered HTML to a file instead of stdout. Token
+  replacement only — no template engine. The standalone health-report skill is
+  now folded into core.
+- **Per-stage LLM telemetry** (#576). Every `chatCompletion` call now records
+  tokens (prompt/completion/total/reasoning), wall-time, model, and
+  finish_reason as an `llm_usage` event, attributed to the pipeline stage via an
+  ambient `AsyncLocalStorage` context (`withLlmStage`) set once per phase — no
+  `stage` parameter threaded through call sites. `akm health` exposes per-stage
+  token and time aggregates. Telemetry is best-effort and can never fail a run;
+  capture is forward-only.
+- **Per-proposal gate decision + confidence** (#577). When a proposal passes
+  through the auto-accept/triage gate, its outcome (`auto-accepted` /
+  `deferred` / `auto-rejected`), reason, confidence, measured value, and the
+  thresholds in effect are persisted on the proposal (in the SQLite metadata).
+  `akm proposal show`/`list` surface them with reconstructable comparisons
+  (e.g. `0.72 < 0.90`), so tooling can explain *why* each proposal is pending
+  instead of relying on a run-level aggregate. Forward-only; legacy proposals
+  render `unknown`.
+
+### Fixed
+
+- **`SQLITE_BUSY` / "database is locked" under concurrent runs** (#584, #585,
+  #589). `busy_timeout` raised from 5 s to 30 s on every SQLite open path
+  (index.db and state.db); the improve maintenance pass now closes its index.db
+  handle before each reindex (which opens its own writer to the same WAL file);
+  and the post-loop purge reuses the long-lived events connection instead of
+  opening a second state.db writer. Together these eliminate all observed
+  lock failures from overlapping cron improve runs. (Backports of 0.8.8.)
+- **Extract gate ignored the active profile's `extract.enabled: false`** (#593,
+  #594). The session-extraction gate hardcoded the `default` profile, so a
+  non-default profile (e.g. a quick pass) ran extract anyway — 300–600 s of
+  redundant work per run when a dedicated extract task also exists. The gate
+  now resolves `extract` against the active improve profile. (Backport of
+  0.8.11.)
+- **Memory inference burned LLM calls on already-derived parents** (#588). The
+  primary pass now checks for the `<parent>.derived.md` child on disk *before*
+  the LLM/cache call, and opportunistically marks the parent processed so it
+  never re-pends. Previously ~55 % of the inference budget was spent
+  rediscovering children that already existed.
+- **Reflect no longer queues empty-diff or cosmetic-only proposals** (#580).
+  A deterministic, LLM-free noise gate diffs each candidate against the current
+  asset; byte-identical edits are dropped and changes that are pure formatting
+  (whitespace reflow, hard-wrap changes, code-fence language hints, YAML scalar
+  re-folding) are suppressed, each recorded via summary events so suppression
+  rates are visible in `akm health`.
+
+### Added
+
+- **`minContentChars` pre-LLM extract gate** (#595, #596). Sessions whose raw
+  size is below `profiles.improve.<name>.processes.extract.minContentChars`
+  (default 10 — only truly empty sessions/journal files) skip the extract LLM
+  call entirely. Gates on raw input size, not post-noise-filter size.
+  (Backports of 0.8.12–0.8.14.)
+- **Structured logs database** (#579). Task and run log lines now land in a
+  dedicated `logs.db` (WAL, 30 s busy_timeout) keyed by task, run, stream, and
+  time, with retention/purge wired into the existing purge pass and `ATTACH`
+  support for joining log lines to `state.db` rows (e.g. a failed
+  `task_history` row to its log output). The scattered-log audit and per-source
+  keep/move/drop decisions are documented in `docs/technical/logs-audit.md`.
+
+### Changed
+
+- **Proposals are now stored canonically in SQLite** (#578). The previously
+  bypassed `proposals` table in state.db is the single source of truth; all
+  proposal commands (`list`/`show`/`diff`/`accept`/`reject`/`revert`/`drain`),
+  the improve auto-accept gate, and health metrics read and write it through
+  one storage layer. Pending file-based proposals are imported on first read;
+  `akm proposal *` UX is unchanged. Design and migration notes live in
+  `docs/technical/proposal-storage.md`.
+- **Improve planning no longer does per-ref DB lookups or per-ref skip events**
+  (#591, #592). Eligible refs carry a pre-resolved `filePath`, removing a
+  serial async lookup per ref (~500 s on 9 k-ref stashes), and the
+  profile-filtered skip loop emits one summary event with a count instead of
+  thousands of rows. (Backports of 0.8.9–0.8.10.)
+
 ## [0.9.0-beta.2] - 2026-06-09
 
 ### Fixed
@@ -254,6 +707,167 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/).
   `migrate-storage` change is pinned by a sha256 + file-mode fixture-stash
   differential test.
 
+## [0.8.14] - 2026-06-11
+
+### Fixed
+
+- **`akm extract` minContentChars default lowered from 500 to 10.** The 500-char
+  threshold used inputCount (raw session size) but analysis showed 209 of 218
+  candidate-producing sessions had inputCount < 500 — tiny agent sessions (22–368
+  chars) regularly yield 1–5 candidates. The only reliably skippable sessions are
+  empty ones (0 chars, journal files). Default lowered to 10 to catch only
+  truly empty sessions while preserving all signal-bearing content. Closes #597.
+
+## [0.8.13] - 2026-06-11
+
+### Fixed
+
+- **`akm extract` minContentChars gate filtered all sessions.** The threshold was
+  checked against `filtered.stats.outputCount` (post-noise-filter chars), but the
+  pre-filter strips so much boilerplate that even signal-bearing sessions end up
+  below 500 chars of output. All 75 sessions in the first post-deploy run were
+  filtered, dropping candidates from 4–13 to 0. Fix: gate on `inputCount` (raw
+  session size) instead — a session with < 500 raw chars has nothing worth
+  extracting regardless of what the pre-filter produces. Closes #596.
+
+## [0.8.12] - 2026-06-11
+
+### Fixed
+
+- **`akm extract` calling the LLM for noise sessions that never yield candidates.**
+  96% of processed sessions (72/75 measured) produced zero candidates, consuming
+  ~330 s of LLM time per run. The pre-filter had no minimum content threshold —
+  sessions as short as 50 chars were sent to the LLM regardless. A new
+  `minContentChars` gate (default 500) skips the LLM call when post-filter
+  content falls below threshold, cutting extract LLM calls by ~95% on typical
+  stashes. Configurable via `profiles.improve.<name>.processes.extract.minContentChars`.
+  Closes #595.
+
+## [0.8.11] - 2026-06-11
+
+### Fixed
+
+- **`akm improve --profile <name>` ignored profile's `extract.enabled: false` setting.**
+  The session-extraction gate in the preparation stage called
+  `isLlmFeatureEnabled(config, "session_extraction")`, which hardcodes a lookup
+  against `profiles.improve.default.processes.extract.enabled`. Any non-default
+  profile that set `extract.enabled: false` (e.g. `quick-shredder`) was silently
+  ignored, causing the extract pass to run regardless. The fix adds a
+  `resolveProcessEnabled("extract", improveProfile)` check so the active
+  resolved profile gates the pass correctly. Closes #593.
+
+## [0.8.10] - 2026-06-11
+
+### Fixed
+
+- **`akm improve` taking 8–10 minutes per run due to O(n) DB writes for
+  profile-filtered refs.** When a profile disables reflect and distill for
+  certain asset types, `collectEligibleRefs` marks those refs as
+  `profile_filtered_all_passes`. The caller then emitted one `improve_skipped`
+  event per ref — a sequential DB write for each. On a ~9 000-ref stash this
+  was ~500 s of SQLite writes before any consolidation or memory inference
+  began. The fix collapses the per-ref loop into a single summary event
+  carrying a `count` field, eliminating ~9 000 sequential writes per run.
+  Closes #590.
+
+## [0.8.9] - 2026-06-11
+
+### Fixed
+
+- **`akm improve` validation pass was O(n) in stash size, causing ~510 s overhead
+  on large stashes.** For every indexed ref, the preparation phase called
+  `findAssetFilePath()` — an async round-trip to the index DB followed by a
+  filesystem probe — serially inside a `for…await` loop. With ~9 000 indexed
+  refs at ~55 ms each, this loop consumed the entire 600–900 s run budget before
+  any reflect, triage, or memory-inference work began. The fix threads
+  `filePath` from the planning stage (`collectEligibleRefs`) through
+  `ImproveEligibleRef` so the validation pass and the disk-existence guard can
+  use the pre-resolved path directly. The async lookup is retained only as a
+  fallback for refs that enter via a narrow scope (e.g. `--scope ref:foo`).
+  Closes #587.
+
+## [0.8.8] - 2026-06-11
+
+### Fixed
+
+- **SQLite `SQLITE_BUSY` errors under concurrent improve runs.** `busy_timeout`
+  was set to 5 000 ms in all three database open paths (`openDatabase`,
+  `openExistingDatabase`, `openStateDatabase`). Under a busy cron schedule — or
+  when a reindex triggered by memory inference ran concurrently with an event
+  write — the 5 s window was routinely exhausted, producing "database is locked"
+  failures. Raised to 30 000 ms across all three paths so transient lock
+  contention is retried for up to 30 s before surfacing as an error.
+
+## [0.8.7] - 2026-06-09
+
+### Fixed
+
+- **`incrementalSince` duration strings were silently ignored.** Values like
+  `"30m"`, `"24h"`, `"7d"` were passed raw to `narrowToIncrementalCandidates`,
+  which compared them against ISO timestamps via string sort. All `2026-...`
+  timestamps are lexicographically less than `"30m"` (`'2' < '3'`) and `"24h"`
+  (`"20" < "24"`), so `isChanged()` always returned `false` and the candidate
+  pool was silently emptied rather than filtered to the window. The fix adds
+  `parseSinceToIso()`, which resolves human duration strings to absolute ISO
+  timestamps before comparison. Values that already look like ISO timestamps
+  are passed through unchanged.
+
+## [0.8.6] - 2026-06-09
+
+### Added
+
+- **`consolidate.incrementalSince` profile config field.** Setting
+  `incrementalSince: "7d"` (or any duration string) in the `consolidate` block
+  of an improve profile narrows the candidate pool to memories modified within
+  that window plus their top-5 graph neighbours, keeping each pass focused on
+  recent changes. This makes it practical to run consolidation more often than
+  once per day (e.g. via `akm-improve-consolidate` every 4 h) without
+  re-scanning the full pool every time. The nightly default profile leaves this
+  unset (full-pool sweep, same as before). The `incrementalSince` option already
+  existed in `akmConsolidate()` but was hardcoded off at the call site; the
+  field is now surfaced in the config schema and read from the profile.
+
+## [0.8.5] - 2026-06-09
+
+### Fixed
+
+- **Consolidation starved merge recall; the memory pool grew unbounded.** Commit
+  `633ece41` made the `incrementalSince` narrowing unconditional, so every
+  consolidation run only judged memories changed since the last run plus their
+  immediate vector-neighbors. Stale-but-unmerged duplicate clusters were never
+  re-examined, so the eligible pool grew monotonically and never shrank, and
+  contradiction detection (which rides on the consolidation pass) went dark.
+  Consolidation only runs on the nightly default-profile pass (`quick`/`frequent`
+  disable it), so a full-pool sweep is correct and affordable; the override is
+  removed. `lastConsolidateTs` still gates whether the pass runs.
+
+## [0.8.4] - 2026-06-08
+
+### Fixed
+
+- **`akm tasks sync` ignored schedule changes.** Sync classified any task already
+  present in the OS scheduler as "unchanged" without comparing its installed
+  entry, so editing a task's `schedule:` in the `.yml` never reached the crontab —
+  the only way to apply a new schedule was to `remove` and re-`add` the task. The
+  same gap affected `tasks enable`/`disable`, which merely toggled the existing
+  cron line's comment and so re-enabled a stale schedule. Sync now compares the
+  backend's installed signature against the signature the current definition would
+  produce and reinstalls on drift (reported in a new `updated[]` field);
+  `enable`/`disable` reinstall from the current `.yml` instead of toggling in
+  place. Backends that can't cheaply read their installed form fall back to an
+  idempotent reinstall, so the fix is correct on launchd/schtasks too. The cron
+  backend gains `expectedSignature()` and a signature on each `list()` entry.
+
+### Added
+
+- **`akm improve --skip-if-locked`.** When another improve run already holds the
+  lock, the run logs and exits 0 with a no-op result (`skipped.reason:
+  "lock-held"`) instead of failing with the "already running" config error
+  (exit 78). Intended for high-frequency scheduled runs (e.g. an every-30-min
+  `quick` pass) that would otherwise pile up exit-78 failures whenever a longer
+  run overlaps them. Default off — the hard error is preserved for interactive
+  use. The result is still recorded so the skip is auditable.
+
 ## [0.8.3] - 2026-06-08
 
 ### Fixed

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

@@ -0,0 +1,23 @@
+You are the akm consolidate assistant analyzing memory assets.
+
+Rules:
+1. MERGE: Two or more memories are substantially duplicated or closely related → propose merging. Return the primary ref to keep and secondary refs to delete. Do NOT include mergedContent — the merge will be executed in a separate step.
+2. DELETE: Memory is clearly outdated, contradicted, or redundant → propose deletion. NEVER propose delete for memories annotated `(captureMode: hot)` — they are user-explicit and only the user can retire them. The downstream guard will refuse these regardless, so proposing them just wastes tokens.
+3. PROMOTE: Memory expresses a stable, reusable fact suitable as a `knowledge:` asset → propose promotion. Do NOT delete the source memory. NEVER propose promote / merge / contradict for memories annotated `(already queued)` — they have a pending proposal whose body matches; a duplicate will be deterministically dropped, so proposing them just wastes tokens.
+4. CONTRADICT: Two memories assert logically exclusive facts such that following BOTH simultaneously is impossible — not merely related or overlapping. You MUST cite the exact sentence from Memory A and the exact sentence from Memory B that are in direct conflict. If you cannot cite specific opposing sentences, use KEEP instead. Sharing a topic, tool, domain, or workflow stage is NOT sufficient. Only direct factual opposites qualify: opposing recommended commands, opposing boolean flags, opposing version numbers, or mutually exclusive instructions. Use confidence ≥ 0.92 only; omit the op entirely if below that threshold.
+5. KEEP: Memory is unique and current → omit from output.
+
+Return ONLY JSON (no prose, no code fences):
+{
+  "operations": [
+    { "op": "merge", "primary": "memory:<name>", "secondaries": ["memory:<name>", ...], "mergeStrategy": "synthesize", "confidence": 0.95 },
+    { "op": "delete", "ref": "memory:<name>", "reason": "<brief reason>", "confidence": 0.90 },
+    { "op": "promote", "ref": "memory:<name>", "knowledgeRef": "knowledge:<suggested-slug>", "reason": "<brief reason>", "description": "<one sentence describing the new knowledge asset>", "confidence": 0.92 },
+    { "op": "contradict", "ref": "memory:<name>", "contradictedByRef": "memory:<name>", "reason": "<brief reason>", "confidence": 0.88 }
+  ],
+  "warnings": ["<optional concerns>"]
+}
+
+For every operation, emit a `confidence` field in [0, 1] expressing your certainty that the operation is correct and safe. Use 0.95+ only when evidence is unambiguous. Omit the field rather than guessing if you are uncertain.
+
+When the merged content includes an `updated` frontmatter field, the value MUST be a real ISO date string (e.g. `updated: 2026-05-20`). NEVER emit `updated: today`, `updated: {today}`, `updated: {today: null}`, `updated: now`, or any other literal placeholder/template-variable. If you do not have a real source-of-truth date, OMIT the `updated` field entirely — the post-processor will not invent one for you.