akm-cli 0.8.0 → 0.8.2

package/CHANGELOG.md

@@ -4,6 +4,124 @@ All notable changes to this project will be documented in this file.
 
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/).
 
+## [0.8.2] - 2026-06-05
+
+### Added
+
+- **LM Studio auto-detection in setup wizard** — `akm setup` now probes
+  `localhost:1234/v1/models` at startup and, when the server is running, pre-fills
+  the LLM backend with the active model list, mirroring the existing Ollama detection
+  flow (#522).
+- **Agent harness config import** — `akm setup` detects installed AI coding harnesses
+  (currently Claude Code and OpenCode) and pre-populates LLM provider, model, and
+  base-URL fields from the harness configuration. The importer registry
+  (`HARNESS_CONFIG_IMPORTERS`) makes adding future harnesses a single append (#523).
+  API key *values* are never read or stored — only the environment variable name is
+  imported.
+- **Registry-driven stash selection** — the "Add Sources" step now fetches available
+  stashes from the official AKM registry at startup. `DEFAULT_SELECTED_STASH_IDS`
+  in `src/setup/registry-stash-loader.ts` is the single edit point for changing
+  which stashes are pre-checked. Falls back to a hardcoded list on network error (#520).
+- **`improve.autoAccept.{promoted,validationFailed}` health metrics** — auto-accepted
+  proposals that pass the confidence threshold but fail validation (truncated
+  description, invalid frontmatter) are now counted as `gateAutoAcceptFailedCount`
+  in the improve result envelope and surfaced as `improve.autoAccept.validationFailed`
+  in `akm health` reports.
+- **`auto-accept-validation` health advisory** — heuristic advisory that warns when
+  `validationFailed > 0` so malformed proposals are visible before they pile up in
+  the queue.
+
+### Fixed
+
+- **`akm-improve` tasks recorded as failed on budget exhaustion** — the budget
+  exhaustion timer called `process.exit(1)`, causing every budget-limited run to be
+  recorded as a task failure. Changed to `process.exit(0)`; budget exhaustion is a
+  normal exit condition.
+- **`improve_runs.started_at` always equal to `completed_at`** — `writeImproveResultFile`
+  was called at end-of-run, so `new Date()` captured the completion time and both
+  columns held the same value (649/661 real runs affected, regressed ~May 26).
+  `started_at` now uses the timestamp captured at process launch, passed in from the
+  CLI entry point. A regex-based fallback decodes the timestamp embedded in the run ID
+  for any call site that does not supply an explicit value (#524).
+- **`akm-health-report` task fails on transient DNS errors** — the Discord webhook
+  script caught `HTTPError` but not the parent `URLError`, so DNS blips caused the
+  task runner to record the health report as failed. `URLError` is now caught and
+  logged as a warning with a clean exit.
+
+### Added
+
+- **Stash `.meta/` convention** — a stash may carry an optional, human-authored
+  `.meta/` directory at its root for orientation: purpose, key assets, conventions,
+  and maintainer info. Surface it on demand with `akm show meta` (the working
+  stash's `.meta/index.md`), `akm show meta:<name>` (e.g. `.meta/about.md`), or
+  scope it to a specific stash with `akm show <origin>//meta[:<name>]`. Because
+  `.meta/` is a dot-directory, the indexer already skips it, so these docs never
+  pollute search results — they are direct-read on demand. Owners extend the
+  convention by dropping new files (`.meta/about.md`, `.meta/conventions.md`,
+  `.meta/license`) with no code changes. `akm init` scaffolds a `.meta/index.md`
+  template into newly created stashes.
+- **Default stash skeleton** — `akm init` (and `akm setup`) now copies
+  `src/assets/stash-skeleton/` into every newly created stash. Currently ships
+  a `README.md` covering what the stash contains and how agents use `akm` to
+  access assets. Existing files are never overwritten. Add files to
+  `src/assets/stash-skeleton/` to extend what ships with a fresh install.
+
+### Improved
+
+- **Setup wizard pre-populates from existing config** — on re-run, `akm setup`
+  initialises every prompt default from the current saved configuration so users
+  only need to change what has actually changed (#519).
+- **Config backup before every setup write** — `backupExistingConfig()` is now called
+  before each `saveConfig` in the setup wizard, ensuring the previous config is always
+  recoverable if a wizard run is interrupted (#521).
+
+## [0.8.1] - 2026-06-05
+
+### Added
+
+- **`graph-refresh` improve profile** — new built-in profile that runs a full-corpus
+  graph extraction pass across all stash files (all other improve processes disabled).
+  Use `akm improve --profile graph-refresh` for a weekly relationship rebuild.
+  Pairs with the new `graph-refresh-weekly` task template (`akm tasks add --template graph-refresh-weekly`).
+- **`session-extraction` health advisory** — new heuristic advisory backed by real
+  `akmExtract` outcomes: warns when the session-extraction process ran but produced
+  zero proposals across ≥ 5 sessions, or recorded warnings. Replaces the vestigial
+  `session-log-failures` warn signal.
+- **`improve.sessionExtraction` health metrics** — `sessionsScanned`, `sessionsExtracted`,
+  `sessionsSkipped`, `proposalsCreated`, `warnings`, `durationMs` now tracked and
+  visible in `akm health` reports.
+
+### Fixed
+
+- **`akm info` indexStats** — `readIndexStats` errors are now surfaced and the resolved
+  DB path is passed correctly; `entryCount`, `hasEmbeddings`, and related fields are
+  no longer silently empty (#510).
+- **Indexer timing fields** — `embedMs` and `ftsMs` in timing output had their
+  operands swapped, producing negative durations. Fixed (#516).
+- **Incremental consolidation gate** — the `volumeTriggered` path bypassed the
+  incremental gate introduced in 0.8.0, causing consolidation to run on chunks it
+  had already processed in the same run. Fixed.
+- **Improve budget exhaustion** — `improve.lock` was not released after budget
+  exhaustion, blocking subsequent runs until the lock TTL expired.
+- **Consolidation chunk retry** — failed chunks are now retried once with a 2 s
+  backoff before being recorded as lost, reducing transient LLM errors from
+  propagating to `chunksFailed`.
+- **`yieldRate` health metric** — `skippedAborted` refs were incorrectly counted in
+  `freshAttempts`, inflating the denominator and underreporting yield rate.
+- **`session-log-failures` advisory** — demoted from `warn` to always `pass`
+  (informational only); the advisory was a raw regex counter with no LLM signal,
+  producing false positives on normal session content.
+
+### Refactored
+
+- All runtime assets consolidated under `src/assets/` with `dist/assets/` mirroring
+  the layout exactly. Built-in improve profiles moved from in-source object literals
+  to embedded JSON files (`src/assets/profiles/*.json`). The `copy-assets.ts` build
+  step now uses a precise `src/assets/**/*` glob instead of a broad catch-all.
+- Vestigial Phase 0 (`getExecutionLogCandidates` / `ERROR_PATTERNS`) removed from
+  the improve pipeline. This regex scan collected a metric count but never fed an
+  LLM; `akmExtract` (Phase 0.4) is the real session extraction pipeline.
+
 ## [0.8.0] - 2026-05-28
 
 ### Performance

package/dist/assets/profiles/default.json

@@ -0,0 +1,15 @@
+{
+  "description": "Standard improve pass — all sub-processes, markdown asset types.",
+  "processes": {
+    "reflect": {
+      "enabled": true,
+      "allowedTypes": ["agent", "command", "knowledge", "lesson", "memory", "skill", "wiki", "workflow"]
+    },
+    "distill": { "enabled": true, "allowedTypes": ["memory"] },
+    "consolidate": { "enabled": true, "allowedTypes": ["memory"] },
+    "memoryInference": { "enabled": true },
+    "graphExtraction": { "enabled": true },
+    "triage": { "enabled": false, "applyMode": "queue", "policy": "personal-stash" }
+  },
+  "sync": { "enabled": true, "push": true }
+}

package/dist/assets/profiles/graph-refresh.json

@@ -0,0 +1,13 @@
+{
+  "description": "Full-corpus graph extraction pass — rebuilds graph relationships across all stash files. Disables all other sub-processes. Use via `akm improve --profile graph-refresh` or the embedded `graph-refresh-weekly` task.",
+  "processes": {
+    "reflect": { "enabled": false },
+    "distill": { "enabled": false },
+    "consolidate": { "enabled": false },
+    "memoryInference": { "enabled": false },
+    "graphExtraction": { "enabled": true, "fullScan": true },
+    "extract": { "enabled": false },
+    "triage": { "enabled": false }
+  },
+  "sync": { "enabled": true, "push": true }
+}

package/dist/assets/profiles/memory-focus.json

@@ -0,0 +1,12 @@
+{
+  "description": "Memory and lesson improvement only — no distill, consolidate, or graphExtraction.",
+  "processes": {
+    "reflect": { "enabled": true, "allowedTypes": ["memory", "lesson"] },
+    "distill": { "enabled": false },
+    "consolidate": { "enabled": false },
+    "memoryInference": { "enabled": true },
+    "graphExtraction": { "enabled": false },
+    "triage": { "enabled": false }
+  },
+  "sync": { "enabled": false }
+}

package/dist/assets/profiles/quick.json

@@ -0,0 +1,15 @@
+{
+  "description": "Reflect-only pass — no distill, consolidate, memoryInference, or graphExtraction.",
+  "processes": {
+    "reflect": {
+      "enabled": true,
+      "allowedTypes": ["agent", "command", "knowledge", "lesson", "memory", "skill", "wiki", "workflow"]
+    },
+    "distill": { "enabled": false },
+    "consolidate": { "enabled": false },
+    "memoryInference": { "enabled": false },
+    "graphExtraction": { "enabled": false },
+    "triage": { "enabled": false }
+  },
+  "sync": { "enabled": false }
+}

package/dist/assets/profiles/thorough.json

@@ -0,0 +1,15 @@
+{
+  "description": "All sub-processes enabled (currently identical to default; reserved for future divergence).",
+  "processes": {
+    "reflect": {
+      "enabled": true,
+      "allowedTypes": ["agent", "command", "knowledge", "lesson", "memory", "skill", "wiki", "workflow"]
+    },
+    "distill": { "enabled": true, "allowedTypes": ["memory"] },
+    "consolidate": { "enabled": true, "allowedTypes": ["memory"] },
+    "memoryInference": { "enabled": true },
+    "graphExtraction": { "enabled": true },
+    "triage": { "enabled": true, "applyMode": "queue" }
+  },
+  "sync": { "enabled": true, "push": true }
+}

package/dist/assets/stash-skeleton/README.md

@@ -0,0 +1,76 @@
+# AKM Stash
+
+This is an **AKM stash** — a structured knowledge repository that stores reusable
+assets for you and your AI agents. AKM (Agent Knowledge Management) indexes, ranks,
+and surfaces these assets at the right moment during coding sessions, improving
+consistency and reducing repeated context-setting.
+
+## What this stash contains
+
+| Directory | Asset type | Purpose |
+|-----------|-----------|---------|
+| `skills/` | Skills | Step-by-step instructions agents follow for specific tasks |
+| `knowledge/` | Knowledge | Reference documents, guides, architecture notes |
+| `memories/` | Memories | Persistent facts and preferences learned over time |
+| `commands/` | Commands | Parameterised prompt templates for common workflows |
+| `agents/` | Agents | Agent definitions with system prompts and tool policies |
+| `workflows/` | Workflows | Multi-step orchestration sequences |
+| `tasks/` | Tasks | Scheduled or on-demand automation tasks |
+| `lessons/` | Lessons | Durable lessons extracted from past sessions |
+
+Add your own assets to any of these directories. AKM will index them automatically
+on the next `akm index` run (or when the background improve pipeline picks them up).
+
+## For agents: how to access this stash
+
+All assets in this stash are searchable via the `akm` CLI. Use these commands to
+find and read assets during a session:
+
+```sh
+# Find assets relevant to your current task (recommended first step)
+akm curate "<task description including project name>"
+
+# Full-text + semantic search
+akm search "<query>"
+akm search "<query>" --type skill
+akm search "<query>" --type knowledge
+
+# Show a specific asset by ref
+akm show skill:<name>
+akm show knowledge:<name>
+akm show memory:<name>
+akm show command:<name>
+
+# List available assets by type
+akm list --type skill
+akm list --type knowledge
+```
+
+### Recording feedback and new knowledge
+
+```sh
+# Mark an asset as helpful (improves future rankings)
+akm feedback <ref> --positive
+
+# Capture a durable lesson or memory from the current session
+akm remember "<fact or lesson>"
+```
+
+### Improving and maintaining the stash
+
+```sh
+# Run the self-improvement pipeline (extract, reflect, consolidate)
+akm improve
+
+# Check stash health and pipeline metrics
+akm health
+
+# Review pending improvement proposals
+akm proposal list
+akm proposal show <id>
+akm proposal accept <id>
+```
+
+---
+
+*Created by `akm init`. See `akm --help` for full command reference.*

package/dist/assets/tasks/graph-refresh-weekly.yml

@@ -0,0 +1,10 @@
+id: graph-refresh-weekly
+description: >
+  Weekly full-corpus graph extraction pass. Rebuilds entity and relation
+  indexes across all stash files using the graph-refresh improve profile.
+  Complements the per-run improve pipeline which only extracts graph data
+  for files touched by actionable refs.
+command: akm improve --profile graph-refresh
+schedule: "0 3 * * 0"
+enabled: false
+timeout: 3600000

package/dist/cli.js

@@ -92,8 +92,8 @@ function resolveEventSource() {
 }
 import { resolveImproveProfile } from "./commands/improve-profiles";
 import { akmProposalAccept, akmProposalDiff, akmProposalList, akmProposalReject, akmProposalRevert, akmProposalShow, } from "./commands/proposal";
-import { drainProposals } from "./commands/proposal-drain";
-import { resolveDrainPolicy } from "./commands/proposal-drain-policies";
+import { drainProposals } from "./commands/proposal/drain";
+import { resolveDrainPolicy } from "./commands/proposal/drain-policies";
 import { akmPropose } from "./commands/propose";
 import { akmSearch, parseBeliefFilterMode, parseScopeFilterFlags, parseSearchSource } from "./commands/search";
 import { checkForUpdate, performUpgrade } from "./commands/self-update";
@@ -107,6 +107,7 @@ import { DEFAULT_CONFIG, loadConfig, loadUserConfig, resolveConfiguredSources, s
 import { ConfigError, NotFoundError, UsageError } from "./core/errors";
 import { appendEvent } from "./core/events";
 import { getCacheDir, getConfigPath, getDbPath, getDefaultStashDir } from "./core/paths";
+import { parseMetaRef } from "./core/stash-meta";
 import { plainize } from "./core/tty";
 import { clearLogFile, info, isQuiet, isVerbose, setLogFile, setQuiet, setVerbose, warn } from "./core/warn";
 import { closeDatabase, openExistingDatabase } from "./indexer/db";
@@ -872,7 +873,11 @@ const showCommand = defineCommand({
                 output("proposal-show", result);
                 return;
             }
-            parseAssetRef(args.ref);
+            // `[origin//]meta[:name]` targets the stash `.meta/` convention, which is
+            // not a typed asset ref — skip ref validation and let akmShowUnified
+            // direct-read it. (`parseAssetRef` would reject the non-type `meta`.)
+            if (!parseMetaRef(args.ref))
+                parseAssetRef(args.ref);
             // The knowledge-view positional syntax (`akm show knowledge:foo section "Auth"`)
             // is rewritten to `--akmView` / `--akmHeading` / `--akmStart` / `--akmEnd`
             // by `normalizeShowArgv` before citty parses argv. We read those values

package/dist/commands/consolidate.js

@@ -170,7 +170,7 @@ export function isHotCapturedMemory(filePath) {
         return false;
     }
 }
-export function consolidateGuardStatus(filePath) {
+function consolidateGuardStatus(filePath) {
     if (!fs.existsSync(filePath))
         return "missing";
     let content;
@@ -395,7 +395,7 @@ export function buildChunkPrompt(sourceName, memories, chunkIndex, totalChunks,
  * trimmed). Empty set on any read/parse error — fail-safe to "annotate
  * nothing" so the LLM still proposes, just slightly more wastefully.
  */
-export function loadPendingConsolidateProposalHashes(stashDir) {
+function loadPendingConsolidateProposalHashes(stashDir) {
     const hashes = new Set();
     try {
         const pending = listProposals(stashDir, { status: "pending" }).filter((p) => p.source === "consolidate");
@@ -965,7 +965,7 @@ export async function akmConsolidate(opts = {}) {
         }
         warn(`[consolidate] chunk ${chunkIdx + 1}/${chunks.length} (${chunk.length} memories) …`);
         const userPrompt = buildChunkPrompt(sourceName, chunk, chunkIdx, chunks.length, bodyTruncation, pendingProposalBodyHashes);
-        const raw = await tryLlmFeature("memory_consolidation", config, async () => {
+        let raw = await tryLlmFeature("memory_consolidation", config, async () => {
             if (!llmConfig)
                 return { ok: false, error: "No LLM configured for consolidation" };
             try {
@@ -985,16 +985,37 @@ export async function akmConsolidate(opts = {}) {
             }
         }, { ok: false, error: `chunk ${chunkIdx + 1} failed` });
         if (!raw.ok) {
-            warn(raw.error ?? `chunk ${chunkIdx + 1} failed`);
-            warnings.push(raw.error ?? `chunk ${chunkIdx + 1} failed`);
-            totalChunksProcessed++;
-            totalChunksFailed++;
-            // Account for the chunk's memories under the failed-chunk bucket.
-            // judgedNoAction does NOT run on this path (it's after the success
-            // guards) so without this the accounting invariant breaks on every
-            // chunk-level transport/parse failure.
-            failedChunkMemories += chunk.length;
-            continue;
+            // Single retry with 2s backoff before recording chunk as lost.
+            // Recovers transient Shredder LM Studio timeouts without significantly
+            // extending run time. Only marks failed if both attempts fail.
+            await new Promise((r) => setTimeout(r, 2_000));
+            const retry = await tryLlmFeature("memory_consolidation", config, async () => {
+                if (!llmConfig)
+                    return { ok: false, error: "No LLM configured for consolidation" };
+                try {
+                    const content = await chatCompletion(llmConfig, [
+                        { role: "system", content: CONSOLIDATE_SYSTEM_PROMPT },
+                        { role: "user", content: userPrompt },
+                    ], { responseSchema: CONSOLIDATE_PLAN_JSON_SCHEMA, enableThinking: false });
+                    return { ok: true, content };
+                }
+                catch (e) {
+                    return { ok: false, error: String(e) };
+                }
+            }, { ok: false, error: `chunk ${chunkIdx + 1} retry failed` });
+            if (!retry.ok) {
+                warn(retry.error ?? `chunk ${chunkIdx + 1} failed after retry`);
+                warnings.push(retry.error ?? `chunk ${chunkIdx + 1} failed after retry`);
+                totalChunksProcessed++;
+                totalChunksFailed++;
+                // Account for the chunk's memories under the failed-chunk bucket.
+                // judgedNoAction does NOT run on this path (it's after the success
+                // guards) so without this the accounting invariant breaks on every
+                // chunk-level transport/parse failure.
+                failedChunkMemories += chunk.length;
+                continue;
+            }
+            raw = retry;
         }
         if (process.env.AKM_DEBUG_LLM) {
             const preview = (raw.content ?? "").slice(0, 500);
@@ -1903,7 +1924,7 @@ export function normalizeUpdatedField(fm) {
  * Two slugs that normalise to the same string are considered the same asset
  * for dedup purposes even if they don't share an exact ref.
  */
-export function normalizeSlugForDedup(ref) {
+function normalizeSlugForDedup(ref) {
     const slug = ref.replace(/^[^:]+:/, "");
     const monthRe = /(?:jan|feb|mar|apr|may|jun|jul|aug|sep|oct|nov|dec)/i;
     const tokens = slug
@@ -1941,7 +1962,7 @@ export function normalizeSlugForDedup(ref) {
  * improve invocation — a different concern from the cross-run content-hash
  * dedup, and cheap (no embeddings, no DB query).
  */
-export async function checkPreEmitDedup(opts) {
+async function checkPreEmitDedup(opts) {
     const normCandidate = normalizeSlugForDedup(opts.candidateRef);
     // Pending consolidate proposals (slug match) — within the same improve run.
     const pendingConsolidate = listProposals(opts.stashDir, { status: "pending" }).filter((p) => p.source === "consolidate");

package/dist/commands/extract-prompt.js

@@ -1,7 +1,20 @@
 // This Source Code Form is subject to the terms of the Mozilla Public
 // License, v. 2.0. If a copy of the MPL was not distributed with this
 // file, You can obtain one at https://mozilla.org/MPL/2.0/.
-import promptTemplate from "../llm/prompts/extract-session.md" with { type: "text" };
+/**
+ * Prompt + schema for `akm extract <session>`.
+ *
+ * Mirrors the REFLECT_JSON_SCHEMA pattern: a strict JSON Schema describing
+ * the LLM output, plus a {@link buildExtractPrompt} helper that interpolates
+ * session data into the markdown template loaded from
+ * `src/assets/prompts/extract-session.md`.
+ *
+ * The schema is intentionally strict — providers with `supportsJsonSchema:
+ * true` enforce shape upstream, so the parser only has to handle the
+ * happy path. `additionalProperties: false` means any hallucinated keys
+ * the model emits get dropped before we parse.
+ */
+import promptTemplate from "../assets/prompts/extract-session.md" with { type: "text" };
 /**
  * JSON Schema for the structured extract output. Passed to `chatCompletion`
  * when the configured LLM connection has `supportsJsonSchema: true`.

package/dist/commands/health.js

@@ -71,9 +71,9 @@ function createUnknownImproveMetrics() {
             graphExtraction: 0,
             error: 0,
         },
+        autoAccept: { promoted: 0, validationFailed: 0 },
         reflectsWithErrorContext: 0,
         coverageGapCount: 0,
-        executionLogCandidateCount: 0,
         evalCasesWritten: 0,
         deadUrlCount: 0,
         memorySummary: { eligible: 0, derived: 0 },
@@ -130,6 +130,15 @@ function createUnknownImproveMetrics() {
             failures: 0,
             durationMs: 0,
         },
+        sessionExtraction: {
+            ran: false,
+            sessionsScanned: 0,
+            sessionsExtracted: 0,
+            sessionsSkipped: 0,
+            proposalsCreated: 0,
+            warnings: 0,
+            durationMs: 0,
+        },
         wallTime: {
             count: 0,
             medianMs: 0,
@@ -285,11 +294,11 @@ function projectRunMetrics(result) {
             }
         }
     }
+    metrics.autoAccept.promoted += toFiniteNumber(result.gateAutoAcceptedCount);
+    metrics.autoAccept.validationFailed += toFiniteNumber(result.gateAutoAcceptFailedCount);
     metrics.reflectsWithErrorContext += toFiniteNumber(result.reflectsWithErrorContext);
     if (Array.isArray(result.coverageGaps))
         metrics.coverageGapCount += result.coverageGaps.length;
-    if (Array.isArray(result.executionLogCandidates))
-        metrics.executionLogCandidateCount += result.executionLogCandidates.length;
     metrics.evalCasesWritten += toFiniteNumber(result.evalCasesWritten);
     if (Array.isArray(result.deadUrls))
         metrics.deadUrlCount += result.deadUrls.length;
@@ -385,6 +394,18 @@ function projectRunMetrics(result) {
         }
     }
     metrics.graphExtraction.durationMs += toFiniteNumber(result.graphExtractionDurationMs);
+    if (Array.isArray(result.extract)) {
+        for (const e of result.extract) {
+            metrics.sessionExtraction.sessionsScanned += toFiniteNumber(e.sessionsProcessed);
+            metrics.sessionExtraction.sessionsSkipped += toFiniteNumber(e.sessionsSkipped);
+            if (Array.isArray(e.sessions)) {
+                metrics.sessionExtraction.sessionsExtracted += e.sessions.filter((s) => Array.isArray(s.proposalIds) && s.proposalIds.length > 0).length;
+            }
+            metrics.sessionExtraction.proposalsCreated += Array.isArray(e.proposals) ? e.proposals.length : 0;
+            metrics.sessionExtraction.warnings += Array.isArray(e.warnings) ? e.warnings.length : 0;
+            metrics.sessionExtraction.durationMs += toFiniteNumber(e.durationMs);
+        }
+    }
     return metrics;
 }
 /**
@@ -412,7 +433,9 @@ function finalizeImproveMetrics(metrics) {
     // `considered`/`written` for totals but are excluded from the rate so
     // they cannot drag it down. See ImproveHealthMetrics.memoryInference
     // jsdoc for the rationale.
-    metrics.memoryInference.freshAttempts = Math.max(0, metrics.memoryInference.yieldEligibleConsidered - metrics.memoryInference.cacheHits);
+    metrics.memoryInference.freshAttempts = Math.max(0, metrics.memoryInference.yieldEligibleConsidered -
+        metrics.memoryInference.cacheHits -
+        metrics.memoryInference.skippedAborted);
     metrics.memoryInference.yieldRate =
         metrics.memoryInference.freshAttempts > 0
             ? roundRate(metrics.memoryInference.yieldEligibleWritten / metrics.memoryInference.freshAttempts)
@@ -423,6 +446,10 @@ function finalizeImproveMetrics(metrics) {
             metrics.graphExtraction.durationMs > 0;
     const cacheTotal = metrics.graphExtraction.cacheHits + metrics.graphExtraction.cacheMisses;
     metrics.graphExtraction.cacheHitRate = cacheTotal > 0 ? roundRate(metrics.graphExtraction.cacheHits / cacheTotal) : 0;
+    metrics.sessionExtraction.ran =
+        metrics.sessionExtraction.sessionsScanned > 0 ||
+            metrics.sessionExtraction.proposalsCreated > 0 ||
+            metrics.sessionExtraction.durationMs > 0;
 }
 /**
  * Merge per-row metrics from `src` into accumulator `dst`. All numeric fields
@@ -457,9 +484,10 @@ function mergeImproveMetrics(dst, src) {
     dst.actions.memoryInference += src.actions.memoryInference;
     dst.actions.graphExtraction += src.actions.graphExtraction;
     dst.actions.error += src.actions.error;
+    dst.autoAccept.promoted += src.autoAccept.promoted;
+    dst.autoAccept.validationFailed += src.autoAccept.validationFailed;
     dst.reflectsWithErrorContext += src.reflectsWithErrorContext;
     dst.coverageGapCount += src.coverageGapCount;
-    dst.executionLogCandidateCount += src.executionLogCandidateCount;
     dst.evalCasesWritten += src.evalCasesWritten;
     dst.deadUrlCount += src.deadUrlCount;
     dst.memorySummary.eligible += src.memorySummary.eligible;
@@ -504,6 +532,12 @@ function mergeImproveMetrics(dst, src) {
     dst.graphExtraction.truncations += src.graphExtraction.truncations;
     dst.graphExtraction.failures += src.graphExtraction.failures;
     dst.graphExtraction.durationMs += src.graphExtraction.durationMs;
+    dst.sessionExtraction.sessionsScanned += src.sessionExtraction.sessionsScanned;
+    dst.sessionExtraction.sessionsExtracted += src.sessionExtraction.sessionsExtracted;
+    dst.sessionExtraction.sessionsSkipped += src.sessionExtraction.sessionsSkipped;
+    dst.sessionExtraction.proposalsCreated += src.sessionExtraction.proposalsCreated;
+    dst.sessionExtraction.warnings += src.sessionExtraction.warnings;
+    dst.sessionExtraction.durationMs += src.sessionExtraction.durationMs;
 }
 function loadImproveRunRows(db, since, until) {
     const sql = until
@@ -892,6 +926,10 @@ const INTERESTING_DELTA_PATHS = [
     "improve.memoryInference.skippedNoFacts",
     "improve.graphExtraction.cacheHitRate",
     "improve.graphExtraction.failures",
+    "improve.sessionExtraction.sessionsScanned",
+    "improve.sessionExtraction.proposalsCreated",
+    "improve.autoAccept.promoted",
+    "improve.autoAccept.validationFailed",
     "improve.wallTime.medianMs",
     "improve.wallTime.p95Ms",
 ];
@@ -1112,16 +1150,59 @@ export function akmHealth(options = {}) {
         catch {
             sessionLogEntries = [];
         }
+        // session-log-failures: demoted to informational — the ERROR_PATTERNS regex
+        // scans pre-LLM session text and produces false positives on diagnostic
+        // conversation. It does not gate the real extraction pipeline (akmExtract).
+        // Never triggers warn; kept for backward-compat visibility only.
         advisories.push({
             name: "session-log-failures",
             kind: "heuristic",
-            status: sessionLogEntries.length === 0 ? "pass" : "warn",
-            confidence: sessionLogEntries.length === 0 ? "low" : "medium",
+            status: "pass",
+            confidence: "low",
             message: sessionLogEntries.length === 0
                 ? "No repeated external session-log failure patterns were detected."
-                : `${sessionLogEntries.length} repeated external session-log failure pattern(s) detected.`,
+                : `${sessionLogEntries.length} raw session-log keyword match(es) detected (pre-LLM, informational only).`,
             evidence: { candidates: sessionLogEntries.slice(0, 5) },
         });
+        const sx = improveSummary.sessionExtraction;
+        const sxWarnReasons = [];
+        if (sx.warnings > 0)
+            sxWarnReasons.push(`${sx.warnings} harness error(s)`);
+        if (sx.ran && sx.sessionsScanned >= 5 && sx.proposalsCreated === 0)
+            sxWarnReasons.push("no proposals generated across scanned sessions");
+        advisories.push({
+            name: "session-extraction",
+            kind: "heuristic",
+            status: sxWarnReasons.length > 0 ? "warn" : "pass",
+            confidence: sx.ran ? "medium" : "low",
+            message: sx.ran
+                ? sxWarnReasons.length > 0
+                    ? `Session extraction degraded: ${sxWarnReasons.join("; ")}.`
+                    : `Session extraction healthy: ${sx.sessionsScanned} scanned, ${sx.sessionsExtracted} extracted, ${sx.proposalsCreated} proposal(s) created.`
+                : "Session extraction not active (feature disabled or no harness available).",
+            evidence: {
+                ran: sx.ran,
+                sessionsScanned: sx.sessionsScanned,
+                sessionsExtracted: sx.sessionsExtracted,
+                sessionsSkipped: sx.sessionsSkipped,
+                proposalsCreated: sx.proposalsCreated,
+                warnings: sx.warnings,
+                durationMs: sx.durationMs,
+            },
+        });
+        const aa = improveSummary.autoAccept;
+        advisories.push({
+            name: "auto-accept-validation",
+            kind: "heuristic",
+            status: aa.validationFailed > 0 ? "warn" : "pass",
+            confidence: aa.promoted + aa.validationFailed > 0 ? "high" : "low",
+            message: aa.validationFailed > 0
+                ? `${aa.validationFailed} proposal(s) passed confidence threshold but failed auto-accept validation (truncated description, invalid frontmatter, etc.) — they remain in the queue for manual review.`
+                : aa.promoted > 0
+                    ? `Auto-accept healthy: ${aa.promoted} proposal(s) promoted, 0 validation failures.`
+                    : "Auto-accept gate did not run (disabled or no proposals above threshold).",
+            evidence: { promoted: aa.promoted, validationFailed: aa.validationFailed },
+        });
         const metrics = {
             taskFailRate: roundRate(taskFailRate),
             agentFailureRate: roundRate(agentFailureRate),

package/dist/commands/improve-cli.js

@@ -56,7 +56,7 @@ export const improveCommand = defineCommand({
         },
         profile: {
             type: "string",
-            description: "Named improve profile from profiles.improve or built-in profiles (default, quick, thorough, memory-focus). Controls which sub-processes run and which asset types are processed.",
+            description: "Named improve profile from profiles.improve or built-in profiles (default, quick, thorough, memory-focus, graph-refresh). Controls which sub-processes run and which asset types are processed.",
         },
         sync: {
             type: "boolean",
@@ -217,7 +217,7 @@ export const improveCommand = defineCommand({
             runRecorded = true; // Suppress any late signal-handler write — the success path owns the row now.
             if (primaryStashDir) {
                 try {
-                    writeImproveResultFile(primaryStashDir, runId, improveResult);
+                    writeImproveResultFile(primaryStashDir, runId, improveResult, startedAtIso);
                 }
                 catch (err) {
                     // Stderr warning on the failure path is preferable to crashing