akm-cli 0.9.0-beta.49 → 0.9.0-beta.50

package/dist/assets/profiles/default.json

@@ -1,15 +1,20 @@
 {
-  "description": "Standard improve pass — all sub-processes, markdown asset types.",
+  "description": "Standard improve pass — all sub-processes + sustaining proactive lane.",
   "processes": {
     "reflect": {
       "enabled": true,
+      "limit": 25,
       "allowedTypes": ["agent", "command", "knowledge", "lesson", "memory", "skill", "wiki", "workflow"]
     },
-    "distill": { "enabled": true, "allowedTypes": ["memory"] },
-    "consolidate": { "enabled": true, "allowedTypes": ["memory"] },
+    "distill": { "enabled": true, "allowedTypes": ["memory"], "requirePlannedRefs": true },
+    "consolidate": { "enabled": true, "allowedTypes": ["memory"], "minPoolSize": 500 },
     "memoryInference": { "enabled": true },
     "graphExtraction": { "enabled": true },
-    "triage": { "enabled": false, "applyMode": "queue", "policy": "personal-stash" }
+    "extract": { "enabled": true, "triage": { "enabled": true, "minScore": 2 } },
+    "proactiveMaintenance": { "enabled": true, "dueDays": 30, "maxPerRun": 15 },
+    "triage": { "enabled": false, "applyMode": "queue", "policy": "personal-stash" },
+    "recombine": { "enabled": false },
+    "procedural": { "enabled": false }
   },
   "sync": { "enabled": true, "push": true }
 }

package/dist/assets/profiles/frequent.json

@@ -6,7 +6,7 @@
     "consolidate": { "enabled": false },
     "memoryInference": { "enabled": true },
     "graphExtraction": { "enabled": true },
-    "extract": { "enabled": true, "minNewSessions": 3 },
+    "extract": { "enabled": true, "minNewSessions": 3, "triage": { "enabled": true, "minScore": 2 } },
     "triage": { "enabled": false }
   },
   "sync": { "enabled": true, "push": true }

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

@@ -8,5 +8,5 @@
     "graphExtraction": { "enabled": false },
     "triage": { "enabled": false }
   },
-  "sync": { "enabled": false }
+  "sync": { "enabled": true, "push": true }
 }

package/dist/assets/profiles/quick.json

@@ -12,5 +12,5 @@
     "graphExtraction": { "enabled": false },
     "triage": { "enabled": false }
   },
-  "sync": { "enabled": false }
+  "sync": { "enabled": true, "push": true }
 }

package/dist/assets/profiles/synthesize.json

@@ -0,0 +1,15 @@
+{
+  "description": "Synthesis-only — cross-episodic recombination (#609). Opt-in periodic pass; all generative/extract passes off. (Procedural compilation (#615) is held OFF until cross-project scoping lands — it over-fits one-off sequences, 0% accept.)",
+  "processes": {
+    "reflect": { "enabled": false },
+    "distill": { "enabled": false },
+    "consolidate": { "enabled": false },
+    "memoryInference": { "enabled": false },
+    "graphExtraction": { "enabled": false },
+    "extract": { "enabled": false },
+    "triage": { "enabled": false },
+    "recombine": { "enabled": true },
+    "procedural": { "enabled": false }
+  },
+  "sync": { "enabled": true, "push": true }
+}

package/dist/assets/profiles/thorough.json

@@ -1,5 +1,5 @@
 {
-  "description": "All sub-processes enabled (currently identical to default; reserved for future divergence).",
+  "description": "Like default, plus the triage process (drains the pending-proposal backlog).",
   "processes": {
     "reflect": {
       "enabled": true,

package/dist/assets/prompts/graph-extract-user-prompt.md

@@ -2,7 +2,7 @@ Extract entities and relations from the asset body below.
 
 Rules:
 - Output ONLY a JSON object: {"entities": ["Entity One", ...], "relations": [{"from": "A", "to": "B", "type": "uses"}, ...]}.
-- Entities are short, canonical noun phrases (project names, services, tools, people, file/dir names, technical concepts).
+- Entities are short, canonical noun phrases (project names, services, tools, people, technical concepts). Do NOT emit file or directory paths (anything containing "/" or "\") — they are dropped downstream.
 - Relations connect two entities that both appear in the entities array.
 - "type" is a short verb phrase (e.g. "uses", "depends on", "owns", "documents"). Optional; omit when unsure.
 - Drop pleasantries, meta-commentary, and timestamps.

package/dist/commands/improve/consolidate/eligibility.js

@@ -9,6 +9,23 @@ import { hasHotCaptureMode } from "../../proposal/validators/proposal-quality-va
 export function isConsolidationEligibleMemoryName(name) {
     return !name.endsWith(".derived");
 }
+/**
+ * #632 — AKM session-capture telemetry memories: auto-generated session-end
+ * checkpoints named `<harness>-session-<YYYYMMDD>-<id>` or
+ * `<harness>-checkpoint-<YYYYMMDD…>-<id>`, carrying an embedded
+ * `akm_memory_kind: session_checkpoint` metadata block. Their bodies are
+ * pipeline bookkeeping, not durable knowledge, so the improve passes exclude
+ * them from their pools (recombine, consolidate). The `\d{8}` datestamp anchor
+ * is what distinguishes a capture name from a durable memory that merely
+ * MENTIONS session/checkpoint (e.g. `akm-plugins-session-end-extract-hook`,
+ * `session-checkpoint-lint-skips`), which stay in the pool.
+ *
+ * Lives here (the eligibility module) rather than in recombine so both
+ * recombine and consolidate can reuse it without a circular import.
+ */
+export function isSessionCaptureMemoryName(name) {
+    return /-(session|checkpoint)-\d{8}/.test(name);
+}
 /**
  * Returns true when the memory file has `captureMode: hot` in its frontmatter.
  *

package/dist/commands/improve/consolidate.js

@@ -41,8 +41,8 @@ import { normalizeUpdatedField, sanitizeMergedContent } from "./consolidate/sani
 export { normalizeUpdatedField, sanitizeMergedContent, stripOuterCodeFence } from "./consolidate/sanitize.js";
 // Eligibility / safety predicates live in ./consolidate/eligibility. Imported
 // for internal guard use; the two public predicates are re-exported.
-import { consolidateGuardStatus, isConsolidationEligibleMemoryName, isHotCapturedMemory, } from "./consolidate/eligibility.js";
-export { isConsolidationEligibleMemoryName, isHotCapturedMemory } from "./consolidate/eligibility.js";
+import { consolidateGuardStatus, isConsolidationEligibleMemoryName, isHotCapturedMemory, isSessionCaptureMemoryName, } from "./consolidate/eligibility.js";
+export { isConsolidationEligibleMemoryName, isHotCapturedMemory, isSessionCaptureMemoryName, } from "./consolidate/eligibility.js";
 // Plan parsing / merging (pure op-reconciliation algebra) lives in
 // ./consolidate/merge. Imported for internal use; mergePlans re-exported.
 import { isValidOp, mergePlans } from "./consolidate/merge.js";
@@ -2036,6 +2036,10 @@ function loadMemoriesForSource(source, stashDir, warnings) {
             return path.resolve(e.stashDir) === path.resolve(source);
         })
             .filter((e) => isConsolidationEligibleMemoryName(e.entry.name))
+            // #632 — exclude session-capture telemetry (checkpoints) from the
+            // consolidation pool, mirroring recombine. Their bodies are pipeline
+            // bookkeeping, so consolidating them burns LLM calls on pure noise.
+            .filter((e) => !isSessionCaptureMemoryName(e.entry.name))
             // Skip stale DB entries whose file was deleted by a prior run but not yet
             // re-indexed. Without this guard the deleted file's ref appears in chunks
             // sent to the LLM, which then proposes a second delete → delete_failed
@@ -2069,6 +2073,8 @@ function loadMemoriesForSource(source, stashDir, warnings) {
                 const name = fname.replace(/\.md$/, "");
                 if (!isConsolidationEligibleMemoryName(name))
                     continue;
+                if (isSessionCaptureMemoryName(name))
+                    continue; // #632 — skip telemetry checkpoints
                 memories.push({ name, filePath, description: "", tags: [], stashDir: fsStashDir });
             }
         }

package/dist/commands/improve/improve-profiles.js

@@ -8,6 +8,7 @@ import profileFrequent from "../../assets/profiles/frequent.json" with { type: "
 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 profileSynthesize from "../../assets/profiles/synthesize.json" with { type: "json" };
 import profileThorough from "../../assets/profiles/thorough.json" with { type: "json" };
 import { parseAssetRef } from "../../core/asset/asset-ref.js";
 import { warn } from "../../core/warn.js";
@@ -31,6 +32,7 @@ const BUILTIN_PROFILES = {
     frequent: profileFrequent,
     consolidate: profileConsolidate,
     catchup: profileCatchup,
+    synthesize: profileSynthesize,
 };
 /**
  * Default enabled-state for known improve processes when neither the user

package/dist/commands/improve/improve.js

@@ -869,7 +869,7 @@ function emitImproveCompletedEvent(result, durations, eventsCtx) {
     // Coarse audit buckets, derived from the SAME classifyImproveAction the
     // persisted metrics_json uses (state-db.ts#computeImproveRunMetrics) so the
     // emitted event and the stored row can never disagree.
-    const classCounts = { accepted: 0, rejected: 0, error: 0, noop: 0 };
+    const classCounts = { accepted: 0, rejected: 0, skipped: 0, error: 0, noop: 0 };
     for (const action of result.actions ?? []) {
         classCounts[classifyImproveAction(action.mode)] += 1;
         // Per-variant counters for the event metadata. The default arm makes any
@@ -936,6 +936,7 @@ function emitImproveCompletedEvent(result, durations, eventsCtx) {
             reflectGuardRejectedActions: actionCounts.reflectGuardRejected,
             acceptedActions: classCounts.accepted,
             rejectedActions: classCounts.rejected,
+            skippedActions: classCounts.skipped,
             noopActions: classCounts.noop,
             reflectsWithErrorContext: result.reflectsWithErrorContext ?? 0,
             coverageGapCount: result.coverageGaps?.length ?? 0,

package/dist/commands/improve/loop-stages.js

@@ -214,6 +214,10 @@ export async function runImproveLoopStage(args) {
                         ...(reflectErrors.length > 0 ? { avoidPatterns: [...reflectErrors] } : {}),
                         agentProcess: options.agentProcess ?? "reflect",
                         eventSource: "improve",
+                        // #639 — resolve the low-value filter from the ACTIVE improve profile
+                        // (default off when unset), so the running profile decides instead of
+                        // a hardcoded profiles.improve.default path.
+                        lowValueFilter: improveProfile.processes?.reflect?.lowValueFilter?.enabled === true,
                         ...(reflectBudgetMs > 0 ? { timeoutMs: reflectBudgetMs } : {}),
                         ...(reflectProfileRunner ? { runner: reflectProfileRunner } : {}),
                         // Attribution: carry the eligibility lane so reflect stamps it on

package/dist/commands/improve/preparation.js

@@ -19,7 +19,7 @@ import { akmLint } from "../lint/index.js";
 import { getProposal, listProposals } from "../proposal/validators/proposals.js";
 import { runSchemaRepairPass } from "../sources/schema-repair.js";
 import { computeThresholdAutoTune, gateDecisionsToSamples, summarizeCalibration, } from "./calibration.js";
-import { akmConsolidate } from "./consolidate.js";
+import { akmConsolidate, isSessionCaptureMemoryName } from "./consolidate.js";
 // Eligibility / candidate-selection predicates live in ./eligibility.
 import { buildLatestFeedbackTsMap, buildLatestProposalTsMap, buildUtilityMap, dedupeRefs, findAssetFilePath, isDistillCandidateRef, isLessonCandidate, isSignalDeltaEligible, } from "./eligibility.js";
 import { akmExtract, countNewExtractCandidates } from "./extract.js";
@@ -1139,7 +1139,10 @@ export async function runImprovePreparationStage(args) {
         withStateDb((dbForHighSalience) => {
             const effectiveLimit = options.limit ?? 10;
             const highSalienceCap = Math.max(1, Math.floor(effectiveLimit * 0.1));
-            const candidates = noFeedbackCandidates.filter((r) => !proactiveAndRetrievalSet.has(r.ref));
+            // #632/#4 — session-capture telemetry (checkpoints) must never consume
+            // the scarce high-salience budget. Even with a content-scored row, these
+            // are pipeline bookkeeping, not assets worth reflecting/rewriting.
+            const candidates = noFeedbackCandidates.filter((r) => !proactiveAndRetrievalSet.has(r.ref) && !isSessionCaptureMemoryName(parseAssetRef(r.ref).name));
             for (const r of candidates) {
                 if (highSalienceRefs.length >= highSalienceCap)
                     break;
@@ -1465,7 +1468,7 @@ export async function runImprovePreparationStage(args) {
     //    stash-wide), but it is the most faithful comparison possible at cutover and
     //    allows the top-200→below-500 forgetting guard to fire if the formula change
     //    dramatically reorders the candidate pool.
-    //    See docs/design/improve-reconciliation-plan.md §WS-1 step 7 — the stash-wide
+    //    See docs/archive/improve-reconciliation-plan.md §WS-1 step 7 — the stash-wide
     //    ordering was unreconstructable (no prior state.db snapshot), so this candidate-
     //    pool partial reconstruction is the documented resolution for the first-run case.
     //    Emit `improve_salience_first_run` to mark the cutover moment and include the
@@ -1507,7 +1510,7 @@ export async function runImprovePreparationStage(args) {
                 // Limitation: this covers only the current-run candidate pool, not the full
                 // stash. The stash-wide ordering was never persisted (asset_salience is a new
                 // WS-1 table), so this is the most faithful comparison possible at cutover.
-                // See docs/design/improve-reconciliation-plan.md §WS-1 step 7.
+                // See docs/archive/improve-reconciliation-plan.md §WS-1 step 7.
                 const reconstructedOldScores = new Map();
                 for (const ref of salienceMap.keys()) {
                     const utility = utilityMap.get(ref) ?? 0;

package/dist/commands/improve/recombine.js

@@ -53,7 +53,7 @@ import { resolveImproveProcessRunnerFromProfile, runnerIsLlm } from "../../integ
 import { chatCompletion } from "../../llm/client.js";
 import { validateProposalFrontmatter } from "../proposal/validators/proposal-quality-validators.js";
 import { archiveProposal, createProposal, isProposalSkipped, listProposals } from "../proposal/validators/proposals.js";
-import { isConsolidationEligibleMemoryName } from "./consolidate.js";
+import { isConsolidationEligibleMemoryName, isSessionCaptureMemoryName } from "./consolidate.js";
 const RECOMBINE_SYSTEM_PROMPT = recombineSystemPrompt;
 const DEFAULT_MIN_CLUSTER_SIZE = 3;
 const DEFAULT_MAX_CLUSTERS_PER_RUN = 5;
@@ -174,24 +174,10 @@ const JUNK_ENTITY_NORMS = new Set([
     "metadata",
     "status",
 ]);
-/**
- * #632 — AKM session-capture telemetry memories: auto-generated session-end
- * checkpoints named `<harness>-session-<YYYYMMDD>-<id>` or
- * `<harness>-checkpoint-<YYYYMMDD…>-<id>`, carrying an embedded
- * `akm_memory_kind: session_checkpoint` metadata block. Their bodies are
- * pipeline bookkeeping, so the graph extracts their metadata FIELDS
- * (`session_checkpoint`, `harness`, `buffered observations`, `tool_*_observed`,
- * …) as ENTITIES — which then dominate entity clustering as bland, stash-wide
- * mega-buckets (the #632 symptom, just under an `entity:` signature). They are
- * session telemetry, not durable knowledge to generalize, so recombine excludes
- * them from its pool. The `\d{8}` datestamp anchor is what distinguishes a
- * capture name from a durable memory that merely MENTIONS session/checkpoint
- * (e.g. `akm-plugins-session-end-extract-hook`, `session-checkpoint-lint-skips`),
- * which stay in the pool.
- */
-export function isSessionCaptureMemoryName(name) {
-    return /-(session|checkpoint)-\d{8}/.test(name);
-}
+// #632 — `isSessionCaptureMemoryName` now lives in ./consolidate/eligibility so
+// both recombine and consolidate can reuse it without a circular import. It is
+// re-exported here for back-compat (existing importers + tests).
+export { isSessionCaptureMemoryName };
 /**
  * #632 — an entity carries no clustering signal (and must be skipped) when it is
  * a generic extraction artefact (session / structured-log bookkeeping), a raw
@@ -602,6 +588,34 @@ export async function akmRecombine(opts) {
                 break;
             }
             clustersFormed += 1;
+            // #9 — promotion is terminal. If this cluster Jaccard-matches a
+            // hypothesis that was ALREADY promoted, generating again can at best
+            // re-queue a redundant `type: hypothesis` for a settled ref (promotion
+            // gates on !alreadyPromoted below), so the LLM output is wasted. Skip the
+            // per-cluster call entirely. The decay sweep still spares the row — it
+            // matches a present cluster via `presentClusters` (independent of
+            // `seenThisRun`), so the promotion record is preserved.
+            if (stateDb) {
+                const promotedMatch = findMatchingRecombineHypothesis(stateDb, {
+                    signature: cluster.signature,
+                    memberKey: recombineMemberKey(cluster),
+                    minOverlap: DEFAULT_RECOMBINE_OVERLAP,
+                });
+                if (promotedMatch?.hypothesis_ref &&
+                    getRecombineHypothesis(stateDb, promotedMatch.hypothesis_ref)?.promoted_at != null) {
+                    appendEvent({
+                        eventType: "recombine_invoked",
+                        ref: promotedMatch.hypothesis_ref,
+                        metadata: {
+                            signal: cluster.signature,
+                            memberCount: cluster.members.length,
+                            outcome: "skipped_promoted",
+                            sourceRun,
+                        },
+                    }, opts.ctx);
+                    continue;
+                }
+            }
             const prompt = buildClusterPrompt(cluster, standardsContext);
             const raw = await llmFn(prompt);
             const generalization = parseGeneralization(raw);

package/dist/commands/improve/reflect.js

@@ -1275,11 +1275,12 @@ export async function akmReflect(options = {}) {
     // (new-asset proposals have nothing to diff against).
     if (assetContent !== undefined) {
         const changeKind = classifyReflectChange(assetContent, payload.content);
-        // 'low-value' is config-gated (#639): only defer when
-        // profiles.improve.default.processes.reflect.lowValueFilter.enabled is
-        // explicitly true. DEFAULT OFF — absent flag = byte-identical pre-#639
-        // behaviour (low-value treated the same as substantive).
-        const lowValueFilterEnabled = runtimeConfig?.profiles?.improve?.default?.processes?.reflect?.lowValueFilter?.enabled === true;
+        // 'low-value' is config-gated (#639). DEFAULT OFF — absent = byte-identical
+        // pre-#639 behaviour (low-value treated the same as substantive). Resolved
+        // by the caller from the ACTIVE improve profile's
+        // `processes.reflect.lowValueFilter.enabled` and passed via options, so the
+        // running profile (not a hardcoded `profiles.improve.default`) decides.
+        const lowValueFilterEnabled = options.lowValueFilter === true;
         const isDeferred = changeKind === "noop" || changeKind === "cosmetic" || (changeKind === "low-value" && lowValueFilterEnabled);
         if (isDeferred) {
             const subreason = changeKind === "noop"

package/dist/commands/proposal/drain.js

@@ -9,7 +9,7 @@
  * the engine behind `akm proposal drain` and (later) the `triage` improve
  * pre-pass.
  *
- * Design (see docs/technical/proposal-triage-implementation-plan.md):
+ * Design (see docs/archive/proposal-triage-implementation-plan.md):
  *   - Reuses `listProposals` (no source filter — generator filtering is
  *     in-memory) and the `akmProposalAccept` / `akmProposalReject` wrappers from
  *     `proposal.ts` so the standard `promoted` / `rejected` events are emitted.

package/dist/core/config/config-schema.js

@@ -125,6 +125,10 @@ export const AgentProfileConfigSchema = z
     args: z.array(z.string()).optional(),
     workspace: z.string().min(1).optional(),
     model: z.string().min(1).optional(),
+    // Per-call timeout (ms) used when a command does not pass an explicit
+    // timeout (e.g. `akm wiki ingest` without `--timeout-ms`). null = no
+    // timeout. Honored by resolveAgentProfile (integrations/agent/config.ts).
+    timeoutMs: z.union([positiveInt, z.null()]).optional(),
 })
     .passthrough();
 // ── Improve profile / process ──────────────────────────────────────────────
@@ -201,6 +205,23 @@ export const ImproveProcessConfigSchema = z
     // high-signal-first sweep). Unset = process all eligible (current
     // behavior). Only meaningful on `graphExtraction`.
     topN: positiveInt.optional(),
+    // graphExtraction process: full-corpus scan. When true, graph extraction
+    // runs on ALL stash files instead of only files touched by actionable refs
+    // in the current run. Used by the `graph-refresh` built-in profile / a
+    // scheduled weekly task. Only meaningful on `graphExtraction`.
+    fullScan: z.boolean().optional(),
+    // #626 — extract process: pre-LLM heuristic triage gate. When enabled, a
+    // deterministic scorer decides BEFORE the extraction LLM call whether a
+    // session carries enough signal to be worth extracting; low-signal sessions
+    // are skipped at zero LLM cost. Default OFF. Only meaningful on `extract`.
+    // `minScore` is the minimum total heuristic score to PASS (default 2).
+    triage: z
+        .object({
+        enabled: z.boolean().optional(),
+        minScore: z.number().min(0).optional(),
+    })
+        .passthrough()
+        .optional(),
     // MemoryInference process: minimum pending memory count to run the pass.
     minPendingCount: z.number().int().min(0).optional(),
     // Extract process: minimum number of new (unseen, in-window) candidate
@@ -377,6 +398,7 @@ const ImproveProfileProcessesSchema = z
     consolidate: ImproveProcessConfigSchema.optional(),
     memoryInference: ImproveProcessConfigSchema.optional(),
     graphExtraction: ImproveProcessConfigSchema.optional(),
+    extract: ImproveProcessConfigSchema.optional(),
     validation: ImproveProcessConfigSchema.optional(),
     triage: ImproveProcessConfigSchema.optional(),
     proactiveMaintenance: ImproveProcessConfigSchema.optional(),

package/dist/core/config/config.js

@@ -284,9 +284,14 @@ export function saveConfig(config) {
     const dir = path.dirname(configPath);
     fs.mkdirSync(dir, { recursive: true });
     const sanitized = sanitizeConfigForWrite(config);
-    // Final validation gate before bytes hit disk. Catches schema violations
-    // (unknown keys in registries[] / sources[] / profiles.*; out-of-range
-    // numbers; etc. — closes #462) before we corrupt the user's config.
+    // Final validation gate before bytes hit disk. Runs the FULL schema —
+    // including the cross-field superRefine guards (removed `feedbackDistillation`
+    // process key, `defaultWriteTarget` resolution, writable npm/website sources)
+    // and all type/enum/range checks — so an `akm config set` (leaf OR object
+    // form) cannot persist a guard-violating or mistyped value. NOTE: unknown
+    // keys are intentionally NOT rejected here — object schemas are `.passthrough()`
+    // so cross-version skew round-trips (see config-schema.ts header); the lenient
+    // tolerance is by design, not an oversight.
     const parseResult = AkmConfigSchema.safeParse(sanitized);
     if (!parseResult.success) {
         const lines = parseResult.error.issues.map((i) => `  - ${i.path.join(".") || "(root)"}: ${i.message}`).join("\n");

package/dist/core/improve-types.js

@@ -11,16 +11,18 @@ import { assertNever } from "./assert.js";
  *
  * Buckets:
  * - `accepted` — a write/content-authoring action succeeded.
- * - `rejected` — the action was deliberately not applied (cooldown, skip,
- *   distill-skip, or a content-policy guard rejection). NOTE: as of the
- *   round-2 health pass `reflect-guard-rejected` is bucketed here. Previously
- *   the `state-db.ts` switch omitted it entirely (no case, no default), so a
- *   guard rejection silently vanished from accepted/rejected/error totals — a
- *   data-integrity miscount. It is a deliberate non-application of the action,
- *   so it belongs with the other "rejected" outcomes.
+ * - `skipped` — the ref was GATED OUT before any content was produced: a
+ *   cooldown, a signal-delta/eligibility skip, or a distill pool-delta skip.
+ *   These are NOT rejections of produced content — they are the run declining
+ *   to act on a ref it had no new reason to touch, and they scale with the
+ *   whole indexed-ref pool (~13k/run), so folding them into `rejected` made the
+ *   "accept rate" meaningless (deep-tuning analysis 2026-06-29, finding #1).
+ * - `rejected` — the run PRODUCED a change and a content-policy guard then
+ *   rejected it (`reflect-guard-rejected`). This is the genuine value-rejection
+ *   signal; it is small and meaningful, no longer drowned by gated skips.
  * - `error` — the action failed (LLM/runtime error).
  * - `noop` — bookkeeping that is neither a write nor a rejection (memory-prune);
- *   intentionally counted in none of the three numeric buckets.
+ *   intentionally counted in none of the numeric buckets.
  *
  * The `default: assertNever(mode)` arm makes any future union variant a
  * compile-time error here, forcing an explicit bucket choice.
@@ -35,6 +37,7 @@ export function classifyImproveAction(mode) {
         case "reflect-cooldown":
         case "reflect-skipped":
         case "distill-skipped":
+            return "skipped";
         case "reflect-guard-rejected":
             return "rejected";
         case "reflect-failed":

package/dist/core/state-db.js

@@ -485,7 +485,10 @@ function isRetryableBeginError(err) {
     const msg = (err instanceof Error ? err.message : String(err)).toLowerCase();
     return (msg.includes("within a transaction") ||
         msg.includes("database is locked") ||
-        msg.includes("database table is locked"));
+        msg.includes("database table is locked") ||
+        // Phantom BEGIN (see below) — synthesized when BEGIN IMMEDIATE returns
+        // without opening a transaction. Safe to retry: fn() has not run.
+        msg.includes("did not open a transaction"));
 }
 const WITH_IMMEDIATE_TX_MAX_ATTEMPTS = 5;
 /** Portable synchronous sleep (works under both Bun and Node). */
@@ -499,6 +502,15 @@ export function withImmediateTransaction(db, fn) {
     for (let attempt = 1; attempt <= WITH_IMMEDIATE_TX_MAX_ATTEMPTS; attempt++) {
         try {
             db.exec("BEGIN IMMEDIATE");
+            // bun:sqlite can return from BEGIN IMMEDIATE under writer contention WITHOUT
+            // actually opening a transaction (no throw). That phantom state otherwise
+            // surfaces as "cannot commit - no transaction is active" at COMMIT — AFTER
+            // fn() has already run in autocommit, so its writes escaped the intended
+            // serialization (the concurrent proposal-queue race). Detect it here, before
+            // fn(), and route it through the same retry path as a contended BEGIN.
+            if (!db.inTransaction) {
+                throw new Error("BEGIN IMMEDIATE did not open a transaction (phantom contention state)");
+            }
         }
         catch (err) {
             lastBeginErr = err;
@@ -740,15 +752,16 @@ export function computeImproveRunMetrics(result) {
     const actionsCount = actions.length;
     let acceptedCount = 0;
     let rejectedCount = 0;
+    let skippedCount = 0;
     let autoAcceptedCount = 0;
     let errorCount = 0;
     for (const action of actions) {
         // Bucketing delegated to the shared classifyImproveAction so this aggregate
         // and the improve_completed event in improve.ts can never disagree, and so a
-        // new union variant is a compile error rather than a silent drop. Note:
-        // `reflect-guard-rejected` now counts as "rejected" (previously this switch
-        // omitted it entirely — a data-integrity miscount). "noop" (memory-prune) is
-        // intentionally counted in none of the three numeric buckets.
+        // new union variant is a compile error rather than a silent drop. Gated skips
+        // (cooldown / signal-delta / distill pool-delta) bucket to "skipped", NOT
+        // "rejected" — only a guard-rejected produced change is a true rejection.
+        // "noop" (memory-prune) is intentionally counted in none of the buckets.
         switch (classifyImproveAction(action.mode)) {
             case "accepted":
                 acceptedCount++;
@@ -756,6 +769,9 @@ export function computeImproveRunMetrics(result) {
             case "rejected":
                 rejectedCount++;
                 break;
+            case "skipped":
+                skippedCount++;
+                break;
             case "error":
                 errorCount++;
                 break;
@@ -769,7 +785,7 @@ export function computeImproveRunMetrics(result) {
     }
     // Add gate-promoted count from the unified PostPhaseAutoAcceptGate (all phases).
     autoAcceptedCount += result.gateAutoAcceptedCount ?? 0;
-    return { plannedCount, actionsCount, acceptedCount, rejectedCount, autoAcceptedCount, errorCount };
+    return { plannedCount, actionsCount, acceptedCount, rejectedCount, skippedCount, autoAcceptedCount, errorCount };
 }
 /**
  * Insert a single improve-run row into `improve_runs`. Uses parameterised SQL.

package/dist/indexer/graph/graph-extraction.js

@@ -837,10 +837,14 @@ export function rankCandidatesByUtility(db, candidates, _stashRoot) {
  *
  * Inferred-child memories (frontmatter `inferred: true`) are skipped — they
  * are already derived summaries, with no additional internal graph structure worth
- * extracting.
+ * extracting. Session-capture telemetry checkpoints are skipped too (see below).
  *
  * Exported for direct unit testing.
  */
+// #632 — canonical session-capture name shape, mirrored from
+// isSessionCaptureMemoryName (src/commands/improve/consolidate/eligibility.ts).
+// Inlined to avoid an improve-layer import from the indexer layer.
+const SESSION_CAPTURE_NAME_RE = /-(session|checkpoint)-\d{8}/;
 export function collectEligibleFiles(stashRoot, includeTypes = [...DEFAULT_GRAPH_EXTRACTION_INCLUDE_TYPES]) {
     const out = [];
     for (const rawType of includeTypes) {
@@ -866,6 +870,14 @@ export function collectEligibleFiles(stashRoot, includeTypes = [...DEFAULT_GRAPH
             // graph to extract from a single-fact body.
             if (type === "memory" && parsed.data.inferred === true)
                 continue;
+            // #632 — skip session-capture telemetry checkpoints (named
+            // `<harness>-(session|checkpoint)-<YYYYMMDD>-<id>`). Their bodies are
+            // pipeline bookkeeping; graph-extracting them lifts metadata fields as
+            // entities that then dominate clustering as bland stash-wide buckets.
+            // Mirrors isSessionCaptureMemoryName (consolidate/eligibility.ts); inlined
+            // here to keep the indexer layer free of an improve-layer import.
+            if (type === "memory" && SESSION_CAPTURE_NAME_RE.test(path.basename(filePath, ".md")))
+                continue;
             const body = parsed.content.trim();
             if (!body)
                 continue;

package/dist/llm/graph-extract.js

@@ -314,7 +314,13 @@ function parseGraphExtraction(raw) {
             if (!normalized)
                 continue;
             const normalizedKey = normalized.toLowerCase();
-            if (!/[a-z0-9]/i.test(normalized) || GENERIC_ENTITIES.has(normalizedKey)) {
+            // Drop generic/empty entities AND raw file/dir paths (anything with a
+            // path separator) — the prompt no longer asks for them and isJunkEntity
+            // discards them downstream, so emitting them is pure waste/junk (#632).
+            if (!/[a-z0-9]/i.test(normalized) ||
+                GENERIC_ENTITIES.has(normalizedKey) ||
+                normalized.includes("/") ||
+                normalized.includes("\\")) {
                 filteredGenericEntities += 1;
                 continue;
             }

package/dist/scripts/migrate-storage.js

@@ -8986,6 +8986,7 @@ function classifyImproveAction(mode) {
     case "reflect-cooldown":
     case "reflect-skipped":
     case "distill-skipped":
+      return "skipped";
     case "reflect-guard-rejected":
       return "rejected";
     case "reflect-failed":
@@ -9701,7 +9702,7 @@ function insertProposalIfAbsent(db, proposal, stashDir) {
 }
 function isRetryableBeginError(err) {
   const msg = (err instanceof Error ? err.message : String(err)).toLowerCase();
-  return msg.includes("within a transaction") || msg.includes("database is locked") || msg.includes("database table is locked");
+  return msg.includes("within a transaction") || msg.includes("database is locked") || msg.includes("database table is locked") || msg.includes("did not open a transaction");
 }
 function sleepSyncMs(ms) {
   if (ms <= 0)
@@ -9713,6 +9714,9 @@ function withImmediateTransaction(db, fn) {
   for (let attempt = 1;attempt <= WITH_IMMEDIATE_TX_MAX_ATTEMPTS; attempt++) {
     try {
       db.exec("BEGIN IMMEDIATE");
+      if (!db.inTransaction) {
+        throw new Error("BEGIN IMMEDIATE did not open a transaction (phantom contention state)");
+      }
     } catch (err) {
       lastBeginErr = err;
       if (isRetryableBeginError(err) && attempt < WITH_IMMEDIATE_TX_MAX_ATTEMPTS) {
@@ -9846,6 +9850,7 @@ function computeImproveRunMetrics(result) {
   const actionsCount = actions.length;
   let acceptedCount = 0;
   let rejectedCount = 0;
+  let skippedCount = 0;
   let autoAcceptedCount = 0;
   let errorCount = 0;
   for (const action of actions) {
@@ -9856,6 +9861,9 @@ function computeImproveRunMetrics(result) {
       case "rejected":
         rejectedCount++;
         break;
+      case "skipped":
+        skippedCount++;
+        break;
       case "error":
         errorCount++;
         break;
@@ -9867,7 +9875,7 @@ function computeImproveRunMetrics(result) {
       autoAcceptedCount++;
   }
   autoAcceptedCount += result.gateAutoAcceptedCount ?? 0;
-  return { plannedCount, actionsCount, acceptedCount, rejectedCount, autoAcceptedCount, errorCount };
+  return { plannedCount, actionsCount, acceptedCount, rejectedCount, skippedCount, autoAcceptedCount, errorCount };
 }
 function recordImproveRun(db, input) {
   const metricsObj = input.metrics ?? computeImproveRunMetrics(input.result);
@@ -15850,7 +15858,8 @@ var init_config_schema = __esm(() => {
     bin: exports_external.string().min(1).optional(),
     args: exports_external.array(exports_external.string()).optional(),
     workspace: exports_external.string().min(1).optional(),
-    model: exports_external.string().min(1).optional()
+    model: exports_external.string().min(1).optional(),
+    timeoutMs: exports_external.union([positiveInt, exports_external.null()]).optional()
   }).passthrough();
   ImproveProcessConfigSchema = exports_external.object({
     enabled: exports_external.boolean().optional(),
@@ -15878,6 +15887,11 @@ var init_config_schema = __esm(() => {
     dueDays: exports_external.number().int().min(0).optional(),
     maxPerRun: positiveInt.optional(),
     topN: positiveInt.optional(),
+    fullScan: exports_external.boolean().optional(),
+    triage: exports_external.object({
+      enabled: exports_external.boolean().optional(),
+      minScore: exports_external.number().min(0).optional()
+    }).passthrough().optional(),
     minPendingCount: exports_external.number().int().min(0).optional(),
     minNewSessions: exports_external.number().int().min(0).optional(),
     maxSessionsPerRun: exports_external.number().int().min(0).optional(),
@@ -15939,6 +15953,7 @@ var init_config_schema = __esm(() => {
     consolidate: ImproveProcessConfigSchema.optional(),
     memoryInference: ImproveProcessConfigSchema.optional(),
     graphExtraction: ImproveProcessConfigSchema.optional(),
+    extract: ImproveProcessConfigSchema.optional(),
     validation: ImproveProcessConfigSchema.optional(),
     triage: ImproveProcessConfigSchema.optional(),
     proactiveMaintenance: ImproveProcessConfigSchema.optional(),

package/dist/scripts/migrations/import-fs-improve-runs-to-db.js

@@ -8713,6 +8713,7 @@ function classifyImproveAction(mode) {
     case "reflect-cooldown":
     case "reflect-skipped":
     case "distill-skipped":
+      return "skipped";
     case "reflect-guard-rejected":
       return "rejected";
     case "reflect-failed":
@@ -9160,6 +9161,7 @@ function computeImproveRunMetrics(result) {
   const actionsCount = actions.length;
   let acceptedCount = 0;
   let rejectedCount = 0;
+  let skippedCount = 0;
   let autoAcceptedCount = 0;
   let errorCount = 0;
   for (const action of actions) {
@@ -9170,6 +9172,9 @@ function computeImproveRunMetrics(result) {
       case "rejected":
         rejectedCount++;
         break;
+      case "skipped":
+        skippedCount++;
+        break;
       case "error":
         errorCount++;
         break;
@@ -9181,7 +9186,7 @@ function computeImproveRunMetrics(result) {
       autoAcceptedCount++;
   }
   autoAcceptedCount += result.gateAutoAcceptedCount ?? 0;
-  return { plannedCount, actionsCount, acceptedCount, rejectedCount, autoAcceptedCount, errorCount };
+  return { plannedCount, actionsCount, acceptedCount, rejectedCount, skippedCount, autoAcceptedCount, errorCount };
 }
 function recordImproveRun(db, input) {
   const metricsObj = input.metrics ?? computeImproveRunMetrics(input.result);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "akm-cli",
-  "version": "0.9.0-beta.49",
+  "version": "0.9.0-beta.50",
   "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": [
@@ -69,7 +69,7 @@
     "lint:devto-posts:fix": "bun scripts/lint-devto-posts.ts --fix",
     "publish:devto": "npx -y @sinedied/devto-cli push \"docs/posts/**/*.md\" --token \"$DEVTO_TOKEN\" --repo \"$GITHUB_REPOSITORY\" --branch \"${GITHUB_REF_NAME:-main}\" --reconcile",
     "release:check": "./tests/release-check.sh",
-    "lint": "bunx biome check src/ tests/ && bun scripts/lint-tests-isolation.ts && bun scripts/lint-license-headers.ts && bun scripts/lint-runtime-boundary.ts && bun scripts/lint-repository-sql.ts",
+    "lint": "bunx biome check src/ tests/ && bun scripts/lint-tests-isolation.ts && bun scripts/lint-license-headers.ts && bun scripts/lint-runtime-boundary.ts && bun scripts/lint-repository-sql.ts && bun scripts/gen-config-schema.ts --check",
     "lint:runtime-boundary": "bun scripts/lint-runtime-boundary.ts",
     "lint:tests-isolation": "bun scripts/lint-tests-isolation.ts",
     "lint:fix": "bunx biome check --write src/ tests/",