akm-cli 0.8.0 → 0.8.1

package/CHANGELOG.md

@@ -4,6 +4,53 @@ 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.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/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/commands/consolidate.js

@@ -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);

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

@@ -73,7 +73,6 @@ function createUnknownImproveMetrics() {
         },
         reflectsWithErrorContext: 0,
         coverageGapCount: 0,
-        executionLogCandidateCount: 0,
         evalCasesWritten: 0,
         deadUrlCount: 0,
         memorySummary: { eligible: 0, derived: 0 },
@@ -130,6 +129,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,
@@ -288,8 +296,6 @@ function projectRunMetrics(result) {
     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 +391,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 +430,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 +443,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
@@ -459,7 +483,6 @@ function mergeImproveMetrics(dst, src) {
     dst.actions.error += src.actions.error;
     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 +527,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 +921,8 @@ const INTERESTING_DELTA_PATHS = [
     "improve.memoryInference.skippedNoFacts",
     "improve.graphExtraction.cacheHitRate",
     "improve.graphExtraction.failures",
+    "improve.sessionExtraction.sessionsScanned",
+    "improve.sessionExtraction.proposalsCreated",
     "improve.wallTime.medianMs",
     "improve.wallTime.p95Ms",
 ];
@@ -1112,16 +1143,46 @@ 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 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",

package/dist/commands/improve-profiles.js

@@ -1,6 +1,11 @@
 // 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 profileDefault from "../assets/profiles/default.json" with { type: "json" };
+import profileGraphRefresh from "../assets/profiles/graph-refresh.json" with { type: "json" };
+import profileMemoryFocus from "../assets/profiles/memory-focus.json" with { type: "json" };
+import profileQuick from "../assets/profiles/quick.json" with { type: "json" };
+import profileThorough from "../assets/profiles/thorough.json" with { type: "json" };
 import { parseAssetRef } from "../core/asset-ref";
 import { warn } from "../core/warn";
 /** Profile name used as the final fallback when nothing else resolves. */
@@ -11,66 +16,15 @@ export const DEFAULT_ALLOWED_TYPES = {
     distill: ["memory"],
     consolidate: ["memory"],
 };
+// Built-in profiles are loaded from embedded JSON files in src/assets/profiles/.
+// To add a new profile: create a new .json file there, import it above, and add
+// it to this map. No code change needed beyond those two steps.
 const BUILTIN_PROFILES = {
-    default: {
-        description: "Standard improve pass — all sub-processes, markdown asset types.",
-        processes: {
-            reflect: { enabled: true, allowedTypes: DEFAULT_ALLOWED_TYPES.reflect },
-            distill: { enabled: true, allowedTypes: DEFAULT_ALLOWED_TYPES.distill },
-            consolidate: { enabled: true, allowedTypes: DEFAULT_ALLOWED_TYPES.consolidate },
-            memoryInference: { enabled: true },
-            graphExtraction: { enabled: true },
-            // validation: deliberately undefined — third-tier classifier is opt-in.
-            triage: { enabled: false, applyMode: "queue", policy: "personal-stash" },
-        },
-        sync: { enabled: true, push: true },
-    },
-    quick: {
-        description: "Reflect-only pass — no distill, consolidate, memoryInference, or graphExtraction.",
-        processes: {
-            reflect: { enabled: true, allowedTypes: DEFAULT_ALLOWED_TYPES.reflect },
-            distill: { enabled: false },
-            consolidate: { enabled: false },
-            memoryInference: { enabled: false },
-            graphExtraction: { enabled: false },
-            triage: { enabled: false },
-        },
-        // Lightweight passes opt out of end-of-run sync: a reflect-only `quick`
-        // run should not auto-commit/push the git-backed stash to its remote.
-        // (The auto-sync gate in improve.ts treats an absent sync block as
-        // ENABLED + push, so we set this explicitly to avoid a surprise push.)
-        sync: { enabled: false },
-    },
-    thorough: {
-        // Reserved for future divergence; for now behaviorally identical to
-        // `default`. Documented here so callers picking `--profile thorough` do
-        // not expect a different code path until we wire stricter limits in.
-        description: "All sub-processes enabled (currently identical to default; reserved for future divergence).",
-        processes: {
-            reflect: { enabled: true, allowedTypes: DEFAULT_ALLOWED_TYPES.reflect },
-            distill: { enabled: true, allowedTypes: DEFAULT_ALLOWED_TYPES.distill },
-            consolidate: { enabled: true, allowedTypes: DEFAULT_ALLOWED_TYPES.consolidate },
-            memoryInference: { enabled: true },
-            graphExtraction: { enabled: true },
-            triage: { enabled: true, applyMode: "queue" },
-        },
-        sync: { enabled: true, push: true },
-    },
-    "memory-focus": {
-        description: "Memory and lesson improvement only — no distill or consolidate.",
-        processes: {
-            reflect: { enabled: true, allowedTypes: ["memory", "lesson"] },
-            distill: { enabled: false },
-            consolidate: { enabled: false },
-            memoryInference: { enabled: true },
-            graphExtraction: { enabled: false },
-            triage: { enabled: false },
-        },
-        // Limited pass opts out of end-of-run sync for the same reason as `quick`:
-        // a memory/lesson-only run should not auto-commit/push the stash. Explicit
-        // here because improve.ts treats an absent sync block as ENABLED + push.
-        sync: { enabled: false },
-    },
+    default: profileDefault,
+    quick: profileQuick,
+    thorough: profileThorough,
+    "memory-focus": profileMemoryFocus,
+    "graph-refresh": profileGraphRefresh,
 };
 /**
  * Default enabled-state for known improve processes when neither the user

package/dist/commands/improve.js

@@ -25,7 +25,7 @@ import { resolveAssetPath } from "../indexer/path-resolver";
 import { getWritableStashDirs, resolveSourceEntries } from "../indexer/search-source";
 import { runStalenessDetectionPass } from "../indexer/staleness-detect";
 import { resolveImproveProcessRunnerFromProfile, resolveTriageJudgmentRunner } from "../integrations/agent/runner";
-import { getAvailableHarnesses, getExecutionLogCandidates } from "../integrations/session-logs";
+import { getAvailableHarnesses } from "../integrations/session-logs";
 import { isLlmFeatureEnabled, isProcessEnabled } from "../llm/feature-gate";
 import { isGitBackedStash, resolveWritableOverride, saveGitStash } from "../sources/providers/git";
 import { akmConsolidate } from "./consolidate";
@@ -674,7 +674,12 @@ export async function akmImprove(options = {}) {
     // lives in the outer scope. It is always assigned at the top of the try.
     let eventsCtx = {};
     try {
-        const budgetTimer = setTimeout(() => budgetAbortController.abort("improve budget exhausted"), budgetMs);
+        const budgetTimer = setTimeout(() => {
+            budgetAbortController.abort("improve budget exhausted");
+            // Grace period: let finally run to release improve.lock, then hard-exit
+            // to prevent the process outliving the task timeout window (lock-cascade fix).
+            setTimeout(() => process.exit(1), 5_000);
+        }, budgetMs);
         // Clear the timer when the run ends to avoid keeping the event loop alive.
         clearBudgetTimer = () => clearTimeout(budgetTimer);
         try {
@@ -798,9 +803,6 @@ export async function akmImprove(options = {}) {
             ...(preparation.lintSummary !== undefined ? { lintSummary: preparation.lintSummary } : {}),
             ...(preparation.memoryIndexHealth !== undefined ? { memoryIndexHealth: preparation.memoryIndexHealth } : {}),
             ...(preparation.coverageGaps.length > 0 ? { coverageGaps: preparation.coverageGaps } : {}),
-            ...(preparation.executionLogCandidates.length > 0
-                ? { executionLogCandidates: preparation.executionLogCandidates }
-                : {}),
             ...(preparation.extract && preparation.extract.length > 0 ? { extract: preparation.extract } : {}),
             ...(primaryStashDir !== undefined ? { evalCasesWritten: countEvalCases(primaryStashDir) } : {}),
             ...(deadUrls !== undefined && deadUrls.length > 0 ? { deadUrls } : {}),
@@ -990,7 +992,6 @@ function emitImproveCompletedEvent(result, durations, eventsCtx) {
             reflectSkippedActions: actionCounts.reflectSkipped,
             reflectsWithErrorContext: result.reflectsWithErrorContext ?? 0,
             coverageGapCount: result.coverageGaps?.length ?? 0,
-            executionLogCandidateCount: result.executionLogCandidates?.length ?? 0,
             evalCasesWritten: result.evalCasesWritten ?? 0,
             deadUrlCount: result.deadUrls?.length ?? 0,
             memoryEligible: result.memorySummary.eligible,
@@ -1047,15 +1048,6 @@ async function runImprovePreparationStage(args) {
             }
         }
     }
-    // Phase 0 — execution log synthesis
-    let executionLogCandidates = [];
-    try {
-        const logEntries = getExecutionLogCandidates(7);
-        executionLogCandidates = logEntries.filter((e) => e.isFailurePattern).map((e) => e.topic);
-    }
-    catch {
-        // best-effort
-    }
     // Phase 0.4 — session-extract pass.
     //
     // Reads native session files (claude-code JSONL, opencode storage tree)
@@ -1539,7 +1531,6 @@ async function runImprovePreparationStage(args) {
         cleanupWarnings,
         appliedCleanup,
         memoryIndexHealth,
-        executionLogCandidates,
         extract: extractResults,
         actionableRefs,
         signalBearingSet,
@@ -2111,13 +2102,16 @@ async function runImprovePostLoopStage(args) {
             // Tie consolidate proposals back to this improve invocation so
             // accept-rate-per-run aggregation works. Mirrors reflect/propose/extract.
             sourceRun: `consolidate-${Date.now()}`,
-            // Incremental consolidation: in steady state (not bootstrap, not volume-
-            // triggered) pass the last-consolidation timestamp so akmConsolidate skips
-            // chunks with no memory changed since then. Converts consolidation cost
-            // from O(pool) to O(changed clusters) — the fix for the rising p95 tail
-            // where full-pool re-judging produced 5–10 min runs that promoted ~0.
-            // undefined → full pass (bootstrap, or volume-triggered large-pool sweep).
-            incrementalSince: volumeTriggered ? undefined : lastConsolidateTs,
+            // Incremental consolidation: pass the last-consolidation timestamp so
+            // akmConsolidate skips chunks with no memory changed since then. Converts
+            // consolidation cost from O(pool) to O(changed clusters) — the fix for
+            // the rising p95 tail where full-pool re-judging produced 5–10 min runs
+            // that promoted ~0. undefined → full pass on first-ever run (bootstrap).
+            // volumeTriggered correctly forces the run past cooldown but must NOT
+            // override incrementalSince — the stash has ~1400 eligible memories so
+            // volumeTriggered=true on every run, permanently forcing full 12-chunk
+            // scans (~264s) instead of the intended 1-2 chunk incremental path (~44s).
+            incrementalSince: lastConsolidateTs,
             maxChunkSize: improveProfile?.processes?.consolidate?.maxChunkSize,
             // Honor profile.autoAccept (already merged into options.autoAccept at the
             // top of akmImprove). The CLI parser always supplies 90 when --auto-accept
@@ -2287,25 +2281,25 @@ async function runImproveMaintenancePasses(args) {
         }
         const graphEnabled = isProcessEnabled("index", "graph_extraction", config);
         const graphExtractionDisabledByProfile = improveProfile?.processes?.graphExtraction?.enabled === false;
+        const graphExtractionFullScan = improveProfile?.processes?.graphExtraction?.fullScan === true;
         // Build the set of refs actually touched this run.
         const touchedRefs = new Set();
         for (const r of args.actionableRefs)
             touchedRefs.add(r.ref);
         for (const r of memoryRefsForInference)
             touchedRefs.add(r);
-        // INVARIANT: graph extraction must never run on the full corpus from the
-        // improve post-loop. Full-corpus scans belong in `akm index`. We enforce
-        // this by ALWAYS passing `candidatePaths` (possibly an empty Set) to the
-        // extractor — never `undefined`. With an empty Set, the extractor's
-        // filter (graph-extraction.ts ~L452) rejects every file and returns the
-        // empty result without scanning. The pass is still invoked so that the
-        // action is recorded, the D9 post-consolidation reindex still fires, and
-        // mock injection (graphExtractionFn) used by tests stays exercised.
+        // INVARIANT: graph extraction normally runs only on files touched by
+        // actionable refs (candidatePaths). Full-corpus scans are opt-in via
+        // profile.processes.graphExtraction.fullScan = true (used by the
+        // `graph-refresh` built-in profile and its weekly scheduled task).
+        // The empty-Set fallback is intentional when no refs were touched —
+        // the extractor's filter rejects every file and returns empty, keeping
+        // the pass invoked so the action is recorded and tests stay exercised.
         if (graphExtractionDisabledByProfile) {
             info("[improve] graph extraction skipped (disabled by improve profile)");
         }
         else if (sources.length > 0 && graphEnabled) {
-            info("[improve] graph extraction starting");
+            info(`[improve] graph extraction starting${graphExtractionFullScan ? " (full-corpus scan)" : ""}`);
             const extractionStart = Date.now();
             try {
                 // D9: if consolidation ran but memory inference did not reindex, force a reindex
@@ -2325,15 +2319,18 @@ async function runImproveMaintenancePasses(args) {
                     closeDatabase(db);
                     db = openDatabase(getDbPath(), config.embedding?.dimension ? { embeddingDim: config.embedding.dimension } : undefined);
                 }
-                // Resolve touched refs to absolute file paths. Empty Set is intentional
-                // when no refs were touched — see INVARIANT above.
-                const candidatePaths = new Set();
-                if (primaryStashDir && touchedRefs.size > 0) {
-                    const writableDirSet = new Set(getWritableStashDirs(primaryStashDir).map((d) => path.resolve(d)));
-                    const resolved = await Promise.all([...touchedRefs].map((ref) => findAssetFilePath(ref, primaryStashDir, writableDirSet).catch(() => null)));
-                    for (const p of resolved) {
-                        if (typeof p === "string" && p.length > 0)
-                            candidatePaths.add(p);
+                // Resolve touched refs to absolute file paths. Skipped for fullScan
+                // (candidatePaths stays undefined → extractor processes all files).
+                let candidatePaths;
+                if (!graphExtractionFullScan) {
+                    candidatePaths = new Set();
+                    if (primaryStashDir && touchedRefs.size > 0) {
+                        const writableDirSet = new Set(getWritableStashDirs(primaryStashDir).map((d) => path.resolve(d)));
+                        const resolved = await Promise.all([...touchedRefs].map((ref) => findAssetFilePath(ref, primaryStashDir, writableDirSet).catch(() => null)));
+                        for (const p of resolved) {
+                            if (typeof p === "string" && p.length > 0)
+                                candidatePaths.add(p);
+                        }
                     }
                 }
                 const progressHandler = (event) => {

package/dist/commands/info.js

@@ -46,8 +46,11 @@ export function assembleInfo(options) {
         ...(s.url ? { url: s.url } : {}),
         ...(s.enabled !== undefined ? { enabled: s.enabled } : {}),
     }));
-    // Index stats
-    const indexStats = readIndexStats(options?.dbPath);
+    // Index stats — resolve the DB path from config so info reads the same
+    // database that health and search use, rather than a bare getDbPath() call
+    // that ignores XDG_DATA_HOME or per-config overrides.
+    const resolvedDbPath = options?.dbPath ?? getDbPath();
+    const indexStats = readIndexStats(resolvedDbPath);
     return {
         schemaVersion: 1,
         version: pkgVersion,
@@ -64,38 +67,30 @@ export function assembleInfo(options) {
         indexStats,
     };
 }
-function readIndexStats(dbPath) {
-    const resolvedPath = dbPath ?? getDbPath();
-    // If no index file exists, return zeros
-    if (!fs.existsSync(resolvedPath)) {
-        return {
-            entryCount: 0,
-            lastBuiltAt: null,
-            hasEmbeddings: false,
-            vecAvailable: false,
-        };
-    }
+function readIndexStats(resolvedPath) {
+    const EMPTY = {
+        entryCount: 0,
+        lastBuiltAt: null,
+        hasEmbeddings: false,
+        vecAvailable: false,
+    };
+    if (!fs.existsSync(resolvedPath))
+        return EMPTY;
     let db;
     try {
         db = openExistingDatabase(resolvedPath);
-        const entryCount = getEntryCount(db);
-        const lastBuiltAt = getMeta(db, "builtAt") ?? null;
-        const vecAvailable = isVecAvailable(db);
-        const hasEmbeddings = getMeta(db, "hasEmbeddings") === "1";
         return {
-            entryCount,
-            lastBuiltAt,
-            hasEmbeddings,
-            vecAvailable,
+            entryCount: getEntryCount(db),
+            lastBuiltAt: getMeta(db, "builtAt") ?? null,
+            hasEmbeddings: getMeta(db, "hasEmbeddings") === "1",
+            vecAvailable: isVecAvailable(db),
         };
     }
-    catch {
-        return {
-            entryCount: 0,
-            lastBuiltAt: null,
-            hasEmbeddings: false,
-            vecAvailable: false,
-        };
+    catch (err) {
+        // Surface the error so operators can diagnose mismatches between
+        // `akm info` and `akm health` rather than silently returning zeros.
+        process.stderr.write(`[akm info] failed to read index stats from ${resolvedPath}: ${String(err)}\n`);
+        return EMPTY;
     }
     finally {
         if (db) {

package/dist/indexer/indexer.js

@@ -322,8 +322,8 @@ export async function akmIndex(options) {
                 totalMs: Date.now() - timing.t0,
                 walkMs: timing.tWalkEnd - timing.tWalkStart,
                 llmMs: timing.tLlmEnd - timing.tWalkEnd,
-                embedMs: timing.tEmbedEnd - timing.tFtsEnd,
-                ftsMs: timing.tFtsEnd - timing.tLlmEnd,
+                embedMs: timing.tEmbedEnd - timing.tLlmEnd,
+                ftsMs: timing.tFtsEnd - timing.tEmbedEnd,
             },
             ...(cleanResult !== undefined ? { clean: cleanResult } : {}),
         };

package/dist/llm/graph-extract.js

@@ -20,11 +20,11 @@
  * the connection via `resolveIndexPassLLM("graph", config)` and pass it
  * straight through.
  */
+import userPromptTemplate from "../assets/prompts/graph-extract-user-prompt.md" with { type: "text" };
 import { toErrorMessage } from "../core/common";
 import { warn, warnVerbose } from "../core/warn";
 import { chatCompletion, parseEmbeddedJsonResponse } from "./client";
 import { tryLlmFeature } from "./feature-gate";
-import userPromptTemplate from "./prompts/graph-extract-user-prompt.md" with { type: "text" };
 /**
  * Separator token used between assets in a batch prompt.
  * Chosen to be visually clear and unlikely to appear verbatim in asset bodies.

package/dist/output/cli-hints.js

@@ -10,6 +10,6 @@
  * `EMBEDDED_HINTS` (`--detail brief`, short reference, ~40 lines) and
  * `EMBEDDED_HINTS_FULL` (`--detail normal|full`, ~250 lines).
  */
-import EMBEDDED_HINTS_FULL from "./cli-hints-full.md" with { type: "text" };
-import EMBEDDED_HINTS from "./cli-hints-short.md" with { type: "text" };
+import EMBEDDED_HINTS_FULL from "../assets/hints/cli-hints-full.md" with { type: "text" };
+import EMBEDDED_HINTS from "../assets/hints/cli-hints-short.md" with { type: "text" };
 export { EMBEDDED_HINTS, EMBEDDED_HINTS_FULL };

package/dist/tasks/backends/launchd.js

@@ -24,12 +24,12 @@
 import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
+import launchdTemplate from "../../assets/backends/launchd-template.xml" with { type: "text" };
 import { ConfigError } from "../../core/errors";
 import { getTaskLogDir } from "../../core/paths";
 import { resolveAkmInvocation } from "../resolveAkmBin";
 import { parseSchedule, translateToLaunchd } from "../schedule";
 import { escapeXml, spawnCommand } from "./exec-utils";
-import launchdTemplate from "./launchd-template.xml" with { type: "text" };
 export const LAUNCHD_LABEL_PREFIX = "com.akm.task.";
 export function LAUNCHD_BACKEND(options = {}) {
     const exec = options.exec ?? defaultLaunchdExec();

package/dist/tasks/backends/schtasks.js

@@ -32,12 +32,12 @@
 import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
+import schtasksTemplate from "../../assets/backends/schtasks-template.xml" with { type: "text" };
 import { ConfigError } from "../../core/errors";
 import { getTaskLogDir } from "../../core/paths";
 import { resolveAkmInvocation } from "../resolveAkmBin";
 import { parseSchedule, translateToSchtasks } from "../schedule";
 import { escapeXml, spawnCommand } from "./exec-utils";
-import schtasksTemplate from "./schtasks-template.xml" with { type: "text" };
 export const DEFAULT_FOLDER_PREFIX = "\\akm\\";
 export function SCHTASKS_BACKEND(options = {}) {
     const exec = options.exec ?? defaultSchtasksExec();

package/dist/wiki/wiki-templates.js

@@ -1,9 +1,9 @@
 // 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 indexTemplate from "./index-template.md" with { type: "text" };
-import logTemplate from "./log-template.md" with { type: "text" };
-import schemaTemplate from "./schema-template.md" with { type: "text" };
+import indexTemplate from "../assets/wiki/index-template.md" with { type: "text" };
+import logTemplate from "../assets/wiki/log-template.md" with { type: "text" };
+import schemaTemplate from "../assets/wiki/schema-template.md" with { type: "text" };
 export function buildSchemaMd(wikiName) {
     return schemaTemplate.replaceAll("{{WIKI_NAME}}", wikiName);
 }

package/dist/wiki/wiki.js

@@ -44,13 +44,13 @@
 import fs from "node:fs";
 import path from "node:path";
 import { parse as yamlParse } from "yaml";
+import ingestWorkflowTemplate from "../assets/wiki/ingest-workflow-template.md" with { type: "text" };
 import { akmSearch } from "../commands/search";
 import { isWithin, todayIso } from "../core/common";
 import { getSources, loadUserConfig, saveConfig } from "../core/config";
 import { NotFoundError, UsageError } from "../core/errors";
 import { parseFrontmatter, parseFrontmatterBlock } from "../core/frontmatter";
 import { resolveSourceEntries } from "../indexer/search-source";
-import ingestWorkflowTemplate from "./ingest-workflow-template.md" with { type: "text" };
 import { buildIndexMd, buildLogMd, buildSchemaMd } from "./wiki-templates";
 // ── Constants ───────────────────────────────────────────────────────────────
 export const WIKIS_SUBDIR = "wikis";

package/dist/workflows/authoring.js

@@ -3,12 +3,12 @@
 // file, You can obtain one at https://mozilla.org/MPL/2.0/.
 import fs from "node:fs";
 import path from "node:path";
+import workflowTemplate from "../assets/workflows/workflow-template.md" with { type: "text" };
 import { resolveAssetPathFromName } from "../core/asset-spec";
 import { isWithin, resolveStashDir } from "../core/common";
 import { UsageError } from "../core/errors";
 import { warn } from "../core/warn";
 import { parseWorkflow } from "./parser";
-import workflowTemplate from "./workflow-template.md" with { type: "text" };
 const DEFAULT_WORKFLOW_TEMPLATE = renderWorkflowTemplate({
     title: "Example Workflow",
     firstStepTitle: "First Step",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "akm-cli",
-  "version": "0.8.0",
+  "version": "0.8.1",
   "type": "module",
   "description": "akm (Agent Knowledge Management) — A package manager for AI agent skills, commands, tools, and knowledge. Works with Claude Code, OpenCode, Cursor, and any AI coding assistant.",
   "keywords": [