akm-cli 0.9.0-beta.31 → 0.9.0-beta.33

package/CHANGELOG.md

@@ -6,6 +6,48 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/).
 
 ## [Unreleased]
 
+## [0.9.0-beta.33] — 2026-06-21
+
+### Fixed
+
+- **`akm extract` decoupled from the improve-stage toggle.** `processes.extract.enabled`
+  now gates extract only as a STAGE of `akm improve` (the active improve profile, per
+  #593/#594); an explicit `akm extract` command always runs. Previously dropping extract
+  from the daily improve profile silently disabled the standalone command (and its LLM
+  calls, via the shared `session_extraction` feature gate).
+- **`extract --session-id` now respects the content-hash ledger; `--force` overrides.**
+  Explicit single-session extraction previously bypassed the #602 already-extracted skip
+  unconditionally — re-paying the LLM on every call and risking double-extraction against
+  the cron. Now a targeted `extract --session-id <id>` is idempotent (skips an unchanged,
+  already-extracted session with zero LLM calls) and only `--force` re-extracts. This
+  makes a session-end hook firing `extract --session-id <id>` precise AND idempotent.
+
+## [0.9.0-beta.32] — 2026-06-21
+
+### Added
+
+- **Recombine acceptance path — confirmed lessons now auto-accept.** Recombine
+  hypotheses that reach the confirmation threshold (promoted to `type: lesson`,
+  #625/#633) now flow to ACCEPTED by reusing the existing drain mechanism instead
+  of piling up pending forever: the `personal-stash` drain policy gains a
+  `{ generator: "recombine", requireType: "lesson", maxDiffLines: 200 }` rule, via
+  a new optional `requireType` frontmatter filter on `DrainAcceptRule`. Only
+  confirmed `type: lesson` proposals auto-accept; unconfirmed `type: hypothesis`
+  proposals stay pending; the existing proposal quality gate still applies.
+- **`processes.reflect.lowValueFilter` (opt-in, default OFF)** — deterministic
+  semantic value-floor that defers trivial reflect rewrites (#639A).
+- **`processes.extract.triage.proceduralAwareFloor` (opt-in, default OFF)** —
+  triage floor requiring markers/edits so real lessons always pass (#641).
+
+### Fixed
+
+- **Select-time proactive cooldown leak.** `selectProactiveMaintenanceRefs` plans
+  the due set BEFORE acquiring `reflect-distill.lock`, so overlapping/back-to-back
+  improve runs reused stale due-state and re-reflected the same asset repeatedly
+  (observed up to ~16× in a day). The orchestrator now re-applies the dueDays gate
+  with freshly-read timestamp maps INSIDE the lock (`filterProactiveDue`), dropping
+  refs a concurrent run already reflected.
+
 ## [0.9.0-beta.31] — 2026-06-20
 
 ### Changed

package/dist/commands/improve/extract.js

@@ -37,7 +37,7 @@ import { getAvailableHarnesses } from "../../integrations/session-logs/index.js"
 import { preFilterSession } from "../../integrations/session-logs/pre-filter.js";
 import { chatCompletion } from "../../llm/client.js";
 import { embed } from "../../llm/embedder.js";
-import { isLlmFeatureEnabled, tryLlmFeature } from "../../llm/feature-gate.js";
+import { tryLlmFeature } from "../../llm/feature-gate.js";
 import { sha256Hex } from "../../runtime.js";
 import { createProposal, isProposalSkipped } from "../proposal/validators/proposals.js";
 import { buildExtractPrompt, EXTRACT_JSON_SCHEMA, parseExtractPayload } from "./extract-prompt.js";
@@ -173,13 +173,14 @@ export function hashSessionContent(data) {
 async function processSession(harness, sessionRef, stashDir, config, llmConfig, chat, ctx, sourceRun, dryRun, timeoutMs, maxTotalChars, minContentChars, 
 // #626 — pre-LLM heuristic triage gate. Default-off (enabled:false) takes the
 // exact pre-change path (no scorer call, no new skipReason).
+// #641 — proceduralAwareFloor is opt-in, DEFAULT OFF.
 triage, sessionIndexing, schemaSimilarityCtx, 
 // #602 — already-extracted skip moved INSIDE processSession: the content hash
 // can only be computed after readSession, so the skip decision lives here. The
 // prior row + bypass flags are threaded in from the caller. Skipping here still
 // costs ZERO LLM calls (the expensive resource #602 protects); only the cheap
 // file read is incurred.
-prior, force, singleSession) {
+prior, force) {
     const warnings = [];
     let data;
     try {
@@ -200,10 +201,12 @@ prior, force, singleSession) {
     // #602 — content-hash skip. Computed on the RAW event stream immediately after
     // a successful read, BEFORE the pre-filter / minContentChars / triage gates, so
     // an unchanged session never reaches the LLM. Hash-based ⇒ clock-independent
-    // (immune to the Jun 11-12 timestamp double-extract/over-throttle bug). --force
-    // and single-session (explicit sessionId) modes bypass the skip entirely.
+    // (immune to the Jun 11-12 timestamp double-extract/over-throttle bug). The skip
+    // applies UNIFORMLY — including explicit `--session-id` targeting (so a
+    // session-end hook firing `extract --session-id <id>` is idempotent). ONLY
+    // `--force` overrides it to re-extract a previously-extracted session.
     const contentHash = hashSessionContent(data);
-    if (!force && !singleSession && shouldSkipAlreadyExtractedSession(prior, contentHash)) {
+    if (!force && shouldSkipAlreadyExtractedSession(prior, contentHash)) {
         return {
             sessionId: sessionRef.sessionId,
             harness: harness.name,
@@ -251,7 +254,9 @@ prior, force, singleSession) {
     // the configured threshold we triage it out: no chat() call, no session asset,
     // no proposals. Pure-heuristic — zero added LLM cost. Default-off → skipped.
     if (triage.enabled) {
-        const t = scoreSessionTriage(data, triage.minScore);
+        const t = scoreSessionTriage(data, triage.minScore, {
+            proceduralAwareFloor: triage.proceduralAwareFloor,
+        });
         if (!t.pass) {
             return {
                 sessionId: sessionRef.sessionId,
@@ -467,9 +472,13 @@ export async function akmExtract(options) {
     const extractProcess = activeProfile
         ? activeProfile.processes?.extract
         : config.profiles?.improve?.default?.processes?.extract;
-    const extractEnabled = activeProfile
-        ? resolveProcessEnabled("extract", activeProfile)
-        : isLlmFeatureEnabled(config, "session_extraction");
+    // The `extract.enabled` process toggle gates extract as a STAGE of `akm improve`
+    // (the activeProfile path) — consistent with #593/#594 where the active profile,
+    // not `default`, is the source of truth. An EXPLICIT `akm extract` invocation
+    // (no activeProfile) is a direct user/cron action and always runs; gating it on
+    // the default improve profile's stage toggle was a footgun — dropping extract
+    // from the daily improve profile would silently disable the standalone command.
+    const extractEnabled = activeProfile ? resolveProcessEnabled("extract", activeProfile) : true;
     // Feature-gate early so we get a clean "skipped because disabled" envelope.
     if (!extractEnabled) {
         return {
@@ -682,7 +691,7 @@ export async function akmExtract(options) {
             break;
         }
         try {
-            const result = await processSession(harness, summary, stashDir, config, llmConfig, chat, options.ctx, sourceRun, dryRun, timeoutMs, maxTotalChars, minContentChars, triage, sessionIndexing, schemaSimilarityCtx, prior, options.force === true, typeof options.sessionId === "string" && options.sessionId.length > 0);
+            const result = await processSession(harness, summary, stashDir, config, llmConfig, chat, options.ctx, sourceRun, dryRun, timeoutMs, maxTotalChars, minContentChars, triage, sessionIndexing, schemaSimilarityCtx, prior, options.force === true);
             sessions.push(result);
             // #626 — triage aggregation. A session reached the triage gate only when it
             // was NOT already preempted by an earlier skip (read_failed / too_short /

package/dist/commands/improve/improve.js

@@ -50,7 +50,7 @@ import { isProfileFilteredForAllPasses, resolveImproveProfile, resolveProcessEna
 import { detectAndWriteContradictions } from "./memory/memory-contradiction-detect.js";
 import { analyzeMemoryCleanup, applyMemoryCleanup } from "./memory/memory-improve.js";
 import { computeProxyAdequacy, getAllAssetOutcomes, getOutcomeScoresByRef, outcomeScoreToSalience, updateAssetOutcome, } from "./outcome-loop.js";
-import { DEFAULT_DUE_DAYS, DEFAULT_MAX_PER_RUN, selectProactiveMaintenanceRefs } from "./proactive-maintenance.js";
+import { DEFAULT_DUE_DAYS, DEFAULT_MAX_PER_RUN, filterProactiveDue, selectProactiveMaintenanceRefs, } from "./proactive-maintenance.js";
 import { akmProcedural } from "./procedural.js";
 import { akmRecombine } from "./recombine.js";
 import { akmReflect } from "./reflect.js";
@@ -1105,13 +1105,32 @@ export async function akmImprove(options = {}) {
             // both write proposals to state.db). Released immediately after.
             const reflectDistillLPath = processLockPath(lockBaseDir, "reflectDistill");
             const reflectDistillAcquired = tryAcquireProcessLock(reflectDistillLPath, PROCESS_LOCK_DEFS.reflectDistill.staleAfterMs, options.skipIfLocked, "reflect-distill") === "acquired";
+            // Post-lock cooldown re-filter for proactive refs (#SELECT-TIME-LEAK).
+            // Planning built `lastReflectProposalTs` BEFORE acquiring this lock, so a
+            // concurrent run's `reflect_invoked` writes are invisible to it. Now that
+            // we hold the lock, re-read fresh timestamp maps for the proactive subset
+            // and drop any ref whose cooldown has been consumed by the concurrent run.
+            const proactiveLoopRefs = preparation.loopRefs.filter((r) => r.eligibilitySource === "proactive");
+            let postLockLoopRefs = preparation.loopRefs;
+            if (proactiveLoopRefs.length > 0) {
+                const proactiveRefStrs = proactiveLoopRefs.map((r) => r.ref);
+                const freshReflectTs = buildLatestProposalTsMap(proactiveRefStrs, "reflect");
+                const freshDistillTs = buildLatestProposalTsMap(proactiveRefStrs, "distill");
+                const pmDueDays = improveProfile.processes?.proactiveMaintenance?.dueDays ?? DEFAULT_DUE_DAYS;
+                const stillDue = new Set(filterProactiveDue(proactiveLoopRefs, freshReflectTs, freshDistillTs, pmDueDays, Date.now()).map((r) => r.ref));
+                const dropped = proactiveLoopRefs.filter((r) => !stillDue.has(r.ref));
+                if (dropped.length > 0) {
+                    info(`[improve] post-lock cooldown re-filter: dropped ${dropped.length} proactive ref(s) claimed by concurrent run (${dropped.map((r) => r.ref).join(", ")})`);
+                    postLockLoopRefs = preparation.loopRefs.filter((r) => r.eligibilitySource !== "proactive" || stillDue.has(r.ref));
+                }
+            }
             const loopResult = await runImproveLoopStageImpl({
                 scope,
                 options,
                 primaryStashDir,
                 reflectFn,
                 distillFn,
-                loopRefs: preparation.loopRefs,
+                loopRefs: postLockLoopRefs,
                 actions: preparation.actions,
                 signalBearingSet: preparation.signalBearingSet,
                 distillCooledRefs: preparation.distillCooledRefs,

package/dist/commands/improve/proactive-maintenance.js

@@ -85,3 +85,31 @@ export function selectProactiveMaintenanceRefs(params) {
     const selected = ranked.slice(0, Math.max(0, maxPerRun)).map((s) => s.ref);
     return { selected, dueTotal, neverReflected, scored };
 }
+/**
+ * Post-lock re-filter for proactive refs.
+ *
+ * Called INSIDE the reflect-distill.lock window with freshly-read timestamp
+ * maps so that any `reflect_invoked` events committed by a concurrent run
+ * while this run was waiting for the lock are visible. Refs that became
+ * non-due (staleDays ≤ dueDays) since planning time are dropped before
+ * execution, closing the SELECT-time cooldown race.
+ *
+ * The logic mirrors the DUE gate in `selectProactiveMaintenanceRefs` — an
+ * asset is due only when never touched OR last touched more than `dueDays`
+ * ago. The selector and this filter must always agree on the gate predicate.
+ */
+export function filterProactiveDue(selected, lastReflectTs, lastDistillTs, dueDays, now) {
+    return selected.filter((candidate) => {
+        const ref = candidate.ref;
+        const reflectIso = lastReflectTs.get(ref);
+        const distillIso = lastDistillTs.get(ref);
+        let lastTouchMs = 0;
+        if (reflectIso)
+            lastTouchMs = Math.max(lastTouchMs, Date.parse(reflectIso) || 0);
+        if (distillIso)
+            lastTouchMs = Math.max(lastTouchMs, Date.parse(distillIso) || 0);
+        const neverReflected = lastTouchMs === 0;
+        const staleDays = neverReflected ? Number.POSITIVE_INFINITY : (now - lastTouchMs) / DAY_MS;
+        return neverReflected || staleDays > dueDays;
+    });
+}

package/dist/commands/improve/reflect.js

@@ -1170,8 +1170,18 @@ export async function akmReflect(options = {}) {
     // (new-asset proposals have nothing to diff against).
     if (assetContent !== undefined) {
         const changeKind = classifyReflectChange(assetContent, payload.content);
-        if (changeKind !== "substantive") {
-            const subreason = changeKind === "noop" ? "reflect_skipped_noop" : "reflect_skipped_cosmetic";
+        // '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;
+        const isDeferred = changeKind === "noop" || changeKind === "cosmetic" || (changeKind === "low-value" && lowValueFilterEnabled);
+        if (isDeferred) {
+            const subreason = changeKind === "noop"
+                ? "reflect_skipped_noop"
+                : changeKind === "low-value"
+                    ? "reflect_skipped_low_value"
+                    : "reflect_skipped_cosmetic";
             emitReflectFailed("no_change", subreason, options.ref, { changeKind });
             return {
                 schemaVersion: 1,
@@ -1179,7 +1189,9 @@ export async function akmReflect(options = {}) {
                 reason: "no_change",
                 error: changeKind === "noop"
                     ? `Reflect skipped: proposed content for ${payload.ref} is identical to the current asset (empty diff); no proposal created.`
-                    : `Reflect skipped: proposed content for ${payload.ref} is a cosmetic-only reformat of the current asset (whitespace/fence/YAML-folding changes); no proposal created.`,
+                    : changeKind === "low-value"
+                        ? `Reflect skipped: proposed content for ${payload.ref} is a low-value prose micro-rewrite (few changed tokens, no structural changes); no proposal created.`
+                        : `Reflect skipped: proposed content for ${payload.ref} is a cosmetic-only reformat of the current asset (whitespace/fence/YAML-folding changes); no proposal created.`,
                 ...(options.ref ? { ref: options.ref } : {}),
                 exitCode: result.exitCode,
             };

package/dist/commands/improve/triage.js

@@ -14,23 +14,7 @@ const MARKER_RE = /\b(error|failed|fix(?:ed)?|root cause|turns out|because|decid
 const EDIT_COMMIT_RE = /\b(Edit|Write|MultiEdit|git commit|diff)\b/i;
 // A substantive turn is an assistant or tool turn whose text is non-trivial.
 const SUBSTANTIVE_MIN_CHARS = 40;
-/**
- * Pure heuristic scorer. Operates only on `data.events`. Each sub-signal is
- * normalized to a small bounded contribution; `score` is their sum and
- * `pass = score >= minScore`.
- *
- * Sub-signals:
- *   - markers: presence of decision/outcome/error keywords across event text
- *     (capped, narrative-lesson signal).
- *   - toolDensity: bounded contribution from tool-use events (procedural).
- *   - editCommit: bounded contribution from edit/write/commit events (procedural).
- *   - substantiveRatio: scaled fraction of non-trivial assistant+tool turns,
- *     filtering pure short Q&A.
- *
- * The procedural sub-signals (toolDensity + editCommit) alone can clear
- * DEFAULT_TRIAGE_MIN_SCORE so high-action / no-narrative sessions are KEPT (#615).
- */
-export function scoreSessionTriage(data, minScore) {
+export function scoreSessionTriage(data, minScore, options) {
     const events = data.events;
     const total = events.length;
     // (a) markers — count word-bounded marker hits across all event text, capped.
@@ -72,7 +56,19 @@ export function scoreSessionTriage(data, minScore) {
     const substantiveRatio = Math.min(ratio, 1);
     const subscores = { markers, toolDensity, editCommit, substantiveRatio };
     const score = markers + toolDensity + editCommit + substantiveRatio;
-    const pass = score >= minScore;
+    // Base gate: score must clear the floor.
+    let pass = score >= minScore;
+    // #641 procedural-aware floor (opt-in, DEFAULT OFF).
+    // When enabled, a session that clears the score gate must ALSO have at least
+    // one narrative marker (markers >= 1) OR meaningful edit/commit signal
+    // (editCommit >= 0.5). Pure read-only Q&A sessions that pass only via
+    // toolDensity + substantiveRatio are rejected as low-signal.
+    if (pass && options?.proceduralAwareFloor === true) {
+        const hasProceduralSignal = markers >= 1 || editCommit >= 0.5;
+        if (!hasProceduralSignal) {
+            pass = false;
+        }
+    }
     return {
         pass,
         score,
@@ -91,5 +87,7 @@ export function resolveTriageConfig(extractProcess) {
     const triage = extractProcess?.triage;
     const enabled = triage?.enabled === true;
     const minScore = typeof triage?.minScore === "number" ? triage.minScore : DEFAULT_TRIAGE_MIN_SCORE;
-    return { enabled, minScore };
+    // #641: default-off — only true when explicitly set to true.
+    const proceduralAwareFloor = triage?.proceduralAwareFloor === true;
+    return { enabled, minScore, proceduralAwareFloor };
 }

package/dist/commands/proposal/drain-policies.js

@@ -45,6 +45,10 @@ export const PERSONAL_STASH = {
         { generator: "reflect", maxDiffLines: 80 },
         // Consolidate within the diff band; mid-band lands in `defer` below.
         { generator: "consolidate", maxDiffLines: 200 },
+        // Recombine: accept only confirmed type:lesson proposals (promoted by the
+        // recombine confidence gate) within the diff band. type:hypothesis proposals
+        // have no matching rule here and stay pending for manual review.
+        { generator: "recombine", requireType: "lesson", maxDiffLines: 200 },
     ],
     rejectEmpty: true,
     // Mid-band consolidate, distill duplicates, and contradiction escalations are
@@ -83,6 +87,7 @@ const DrainAcceptRuleSchema = z
     generator: GeneratorSchema,
     maxDiffLines: z.number().int().positive().optional(),
     minContentLines: z.number().int().nonnegative().optional(),
+    requireType: z.string().optional(),
 })
     .strict();
 const DrainPolicySchema = z

package/dist/commands/proposal/drain.js

@@ -80,7 +80,16 @@ export function classifyProposal(proposal, policy, maxDiffLines) {
     if (policy.rejectEmpty && isEmptyDiff(proposal)) {
         return { verdict: "reject", reason: "empty diff", gate: { reason: "empty-diff" } };
     }
-    const rule = policy.accept.find((r) => r.generator === proposal.source);
+    const rule = policy.accept.find((r) => {
+        if (r.generator !== proposal.source)
+            return false;
+        if (r.requireType !== undefined) {
+            const fm = parseFrontmatter(proposal.payload.content ?? "").data;
+            if (typeof fm.type !== "string" || fm.type !== r.requireType)
+                return false;
+        }
+        return true;
+    });
     if (rule) {
         const lines = contentLineCount(content);
         const body = contentBodyLineCount(content);

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

@@ -329,6 +329,16 @@ export const ImproveProcessConfigSchema = z
     // #615 — procedural process: asset type a compiled sequence is emitted as.
     // Reserved; v1 always emits "workflow". Only meaningful on `procedural`.
     emitAs: z.enum(["workflow", "skill"]).optional(),
+    // #639 — semantic value-floor filter for the `reflect` process. When
+    // enabled, proposals classified as "low-value" by the deterministic noise
+    // gate are deferred. DEFAULT OFF (absent / { enabled: false } = pre-#639
+    // byte-identical behaviour). Only meaningful on the `reflect` process.
+    lowValueFilter: z.object({ enabled: z.boolean().optional() }).strict().optional(),
+    // #641 — procedural-aware floor for the `extract` process triage gate.
+    // When true, a session must have markers>=1 OR editCommit>=0.5 to pass, even
+    // if score>=minScore. DEFAULT OFF (absent/false = pre-#641 byte-identical).
+    // Only meaningful on the `extract` process when triage is also enabled.
+    proceduralAwareFloor: z.boolean().optional(),
     // Triage process config (only meaningful for the `triage` process)
     applyMode: z.enum(["queue", "promote"]).optional(),
     policy: z.string().min(1).optional(),

package/dist/llm/feature-gate.js

@@ -30,10 +30,14 @@ const FEATURE_LOCATION = {
     proposal_quality_gate: (cfg) => cfg.profiles?.improve?.default?.processes?.reflect?.qualityGate?.enabled ?? false,
     // Legacy default: false
     memory_contradiction_detection: (cfg) => cfg.profiles?.improve?.default?.processes?.consolidate?.contradictionDetection?.enabled ?? false,
-    // Default: true. Session extraction replaces the akm-plugin checkpoint hook
-    // and is the primary path for capturing durable signal from real sessions.
-    // Opt out via `profiles.improve.default.processes.extract.enabled: false`.
-    session_extraction: (cfg) => cfg.profiles?.improve?.default?.processes?.extract?.enabled ?? true,
+    // Always on at the LLM-wrapper level. Enablement is decided ONCE at the
+    // extract entry point (`akmExtract`): the `extract.enabled` process toggle
+    // gates extract as a STAGE of `akm improve` (the active improve profile, per
+    // #593/#594), while an explicit `akm extract` command always runs. Gating the
+    // inner LLM calls on `default.processes.extract.enabled` here was a footgun —
+    // dropping extract from the daily improve profile silently disabled the
+    // standalone `akm extract` command. (cfg unused — kept for resolver signature.)
+    session_extraction: (_cfg) => true,
 };
 /**
  * Pure predicate: is the named feature gate enabled in `config`?

package/dist/scripts/migrate-storage.js

@@ -15920,6 +15920,8 @@ var init_config_schema = __esm(() => {
     minRecurrence: exports_external.number().int().min(2).optional(),
     maxProposalsPerRun: positiveInt.optional(),
     emitAs: exports_external.enum(["workflow", "skill"]).optional(),
+    lowValueFilter: exports_external.object({ enabled: exports_external.boolean().optional() }).strict().optional(),
+    proceduralAwareFloor: exports_external.boolean().optional(),
     applyMode: exports_external.enum(["queue", "promote"]).optional(),
     policy: exports_external.string().min(1).optional(),
     maxAcceptsPerRun: positiveInt.optional(),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "akm-cli",
-  "version": "0.9.0-beta.31",
+  "version": "0.9.0-beta.33",
   "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": [