akm-cli 0.9.0-beta.34 → 0.9.0-beta.35

package/CHANGELOG.md

@@ -6,6 +6,34 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/).
 
 ## [Unreleased]
 
+## [0.9.0-beta.35] — 2026-06-21
+
+### Fixed
+
+- **Default extract discovery window is now "since the last run" (floored at 48h),
+  not a fixed 24h.** An intermittently-online host that was off for longer than
+  the old 24h window could permanently miss sessions that ended during the gap.
+  Discovery now looks back to the last recorded extract run for the harness, never
+  less than 48h. Widening is free of redundant LLM cost — the content-hash ledger
+  skips unchanged sessions with zero LLM calls. An explicit `--since`/`defaultSince`
+  still wins.
+- **Per-session lock prevents concurrent double-extraction.** A session-end hook
+  firing `extract --session-id` while the periodic `akm improve` extract pass runs
+  discovery could both LLM-process the SAME session (duplicate spend + near-dup
+  proposals). A per-(harness, session) advisory lock (co-located with state.db,
+  PID + age staleness recovery) now makes the second run skip without any LLM call.
+- **`minNewSessions` is read from the ACTIVE improve profile, not always `default`.**
+  A non-default profile (e.g. `frequent`) setting `minNewSessions` was silently
+  ignored because the gate (and its candidate-count discovery window) read
+  `profiles.improve.default`. They now read the resolved active profile, matching
+  how `extract.enabled` already resolves.
+
+### Docs
+
+- Documented that `processes.extract.indexSessions` (default on) makes a second
+  LLM call per processed session (the session summary); set it to `false` to halve
+  per-session extract cost. Unchanged/skipped sessions still cost zero.
+
 ## [0.9.0-beta.34] — 2026-06-21
 
 ### Fixed

package/dist/commands/improve/extract.js

@@ -23,12 +23,15 @@
  *     descriptionQualityValidator passes — same pattern as the
  *     consolidate-writer fix.
  */
+import fs from "node:fs";
+import path from "node:path";
 import { assembleAsset } from "../../core/asset/asset-serialize.js";
 import { resolveStashDir, timestampForFilename } from "../../core/common.js";
 import { getDefaultLlmConfig, loadConfig } from "../../core/config/config.js";
 import { ConfigError, UsageError } from "../../core/errors.js";
 import { appendEvent } from "../../core/events.js";
-import { getExtractedSessionsMap, openStateDatabase, shouldSkipAlreadyExtractedSession, upsertExtractedSession, } from "../../core/state-db.js";
+import { probeLock, releaseLock, tryAcquireLockSync } from "../../core/file-lock.js";
+import { getExtractedSessionsMap, getLastExtractRunAt, getStateDbPath, openStateDatabase, shouldSkipAlreadyExtractedSession, upsertExtractedSession, } from "../../core/state-db.js";
 import { repairTruncatedDescription } from "../../core/text-truncation.js";
 import { warn } from "../../core/warn.js";
 import { resolveImproveProcessRunnerFromProfile, runnerIsLlm } from "../../integrations/agent/runner.js";
@@ -63,6 +66,88 @@ const DEFAULT_MIN_CONTENT_CHARS = 10;
  * processed by subsequent runs, so coverage is preserved — just spread out.
  */
 const DEFAULT_MAX_SESSIONS_PER_RUN = 25;
+/**
+ * Floor for the default discovery window (48h). When no explicit `--since` /
+ * `defaultSince` is configured, discovery looks back to the LAST recorded
+ * extract run for the harness (so an intermittently-online host that was off for
+ * days still rediscovers sessions that ended during the gap), but never LESS
+ * than this — looking back less than the prior window could drop a session that
+ * a previous run deferred via `maxSessionsPerRun`. Widening is free of redundant
+ * LLM cost: the content-hash ledger skips unchanged sessions with zero LLM calls.
+ */
+const DEFAULT_SINCE_FLOOR_MS = 48 * 60 * 60 * 1000;
+/**
+ * Staleness window for the per-session extract lock. A single session's
+ * processing is bounded by the per-session LLM timeout (default 60s) plus the
+ * session-summary call, so a lock older than this must belong to a crashed
+ * holder and is safe to reclaim.
+ */
+const EXTRACT_SESSION_LOCK_STALE_MS = 5 * 60 * 1000;
+/**
+ * Resolve the discovery `sinceMs` cutoff when no explicit `since`/`defaultSince`
+ * is set: the later of (last recorded extract run for this harness) and
+ * (now − 48h). See {@link DEFAULT_SINCE_FLOOR_MS}. Best-effort — any state.db
+ * error falls back to the 48h floor.
+ */
+function resolveDefaultSinceMs(harnessName, now, opts) {
+    const floor = now - DEFAULT_SINCE_FLOOR_MS;
+    if (opts.skipTracking)
+        return floor;
+    let db = opts.stateDb;
+    let opened = false;
+    try {
+        if (!db) {
+            db = openStateDatabase(opts.stateDbPath);
+            opened = true;
+        }
+        const lastRun = getLastExtractRunAt(db, harnessName);
+        return lastRun != null ? Math.min(lastRun, floor) : floor;
+    }
+    catch {
+        return floor;
+    }
+    finally {
+        if (opened && db) {
+            try {
+                db.close();
+            }
+            catch {
+                // best-effort close
+            }
+        }
+    }
+}
+/** Filesystem-safe per-session lock path, co-located with the state.db. */
+function getExtractSessionLockPath(harness, sessionId, stateDbPath) {
+    const safe = `${harness}-${sessionId}`.replace(/[^A-Za-z0-9._-]/g, "_");
+    return path.join(path.dirname(stateDbPath), "extract-locks", `extract-${safe}.lock`);
+}
+/**
+ * Try to claim the per-session extract lock so a concurrent extract (e.g. a
+ * session-end hook firing `--session-id` while the hourly improve pass runs
+ * discovery) cannot double-process the SAME session — duplicate LLM spend and
+ * near-duplicate proposals. Reclaims a stale lock (dead holder PID or age past
+ * {@link EXTRACT_SESSION_LOCK_STALE_MS}). Returns false when another LIVE run
+ * holds it — the caller then skips the session without any LLM call. Best-effort:
+ * any filesystem error resolves to `true` (proceed) so locking never blocks
+ * extraction outright.
+ */
+function acquireExtractSessionLock(lockPath) {
+    try {
+        fs.mkdirSync(path.dirname(lockPath), { recursive: true });
+        if (tryAcquireLockSync(lockPath, String(process.pid)))
+            return true;
+        const probe = probeLock(lockPath, { staleAfterMs: EXTRACT_SESSION_LOCK_STALE_MS });
+        if (probe.state === "held")
+            return false;
+        // absent (released between attempt + probe) or stale → reclaim and retry once.
+        releaseLock(lockPath);
+        return tryAcquireLockSync(lockPath, String(process.pid));
+    }
+    catch {
+        return true;
+    }
+}
 // ── Helpers ──────────────────────────────────────────────────────────────────
 /**
  * Parse a since-string into an absolute ms-epoch cutoff. Accepts:
@@ -625,7 +710,16 @@ export async function akmExtract(options) {
         candidates = [target];
     }
     else {
-        const sinceMs = parseSinceArg(effectiveSince);
+        // No explicit `--since`/`defaultSince` → default to "since the last run"
+        // (floored at 48h) so an intermittently-online host doesn't lose sessions
+        // that ended while it was off. See {@link resolveDefaultSinceMs}.
+        const sinceMs = effectiveSince
+            ? parseSinceArg(effectiveSince)
+            : resolveDefaultSinceMs(harness.name, startMs, {
+                ...(options.stateDb ? { stateDb: options.stateDb } : {}),
+                ...(options.stateDbPath ? { stateDbPath: options.stateDbPath } : {}),
+                ...(options.skipTracking ? { skipTracking: options.skipTracking } : {}),
+            });
         candidates = harness.listSessions({
             sinceMs,
             ...(options.location ? { location: options.location } : {}),
@@ -690,6 +784,31 @@ export async function akmExtract(options) {
             topLevelWarnings.push(`Reached maxSessionsPerRun=${maxSessionsPerRun}; ${candidates.length - processedCount - skippedCount} session(s) deferred to a later run.`);
             break;
         }
+        // Q5 — per-session lock so two concurrent extracts (e.g. a session-end hook
+        // firing `--session-id` while the hourly improve discovery pass runs) can't
+        // both LLM-process the SAME session. The holder records the outcome; a
+        // second run skips without any LLM call. Engaged only for real cross-process
+        // runs (those that open their own state.db): dry-run is read-only, an
+        // injected `stateDb` handle is an in-process/test scenario with no cross-
+        // process race, and skip-tracking-off opts out entirely.
+        let sessionLockPath;
+        if (trackingEnabled && !dryRun && !options.stateDb) {
+            sessionLockPath = getExtractSessionLockPath(harness.name, summary.sessionId, options.stateDbPath ?? getStateDbPath());
+            if (!acquireExtractSessionLock(sessionLockPath)) {
+                sessions.push({
+                    sessionId: summary.sessionId,
+                    harness: harness.name,
+                    candidateCount: 0,
+                    proposalIds: [],
+                    preFilter: { inputCount: 0, outputCount: 0, truncatedCount: 0 },
+                    warnings: ["concurrent extract holds this session's lock — skipped (handled by the other run)"],
+                    skipped: true,
+                    skipReason: "locked_concurrent",
+                });
+                skippedCount += 1;
+                continue;
+            }
+        }
         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);
             sessions.push(result);
@@ -779,6 +898,10 @@ export async function akmExtract(options) {
             });
             skippedCount += 1;
         }
+        finally {
+            if (sessionLockPath)
+                releaseLock(sessionLockPath);
+        }
     }
     // Close the state.db connection we opened. Callers that injected stateDb
     // via the test seam own its lifecycle.
@@ -838,13 +961,21 @@ export async function akmExtract(options) {
 export function countNewExtractCandidates(config, options = {}) {
     const extractProcess = config.profiles?.improve?.default?.processes?.extract;
     const effectiveSince = options.since ?? extractProcess?.defaultSince;
-    const sinceMs = parseSinceArg(effectiveSince);
+    // Mirror akmExtract: when no explicit window is set, default per-harness to
+    // "since the last run" (floored at 48h) instead of a fixed 24h. Keeps this
+    // gate's discovery window identical to what akmExtract will actually scan.
+    const explicitSinceMs = effectiveSince ? parseSinceArg(effectiveSince) : undefined;
     const harnesses = (options.harnesses ?? getAvailableHarnesses()).filter((h) => h.isAvailable());
     let stateDb = options.stateDb;
     let openedStateDb = false;
     let total = 0;
     try {
         for (const harness of harnesses) {
+            const sinceMs = explicitSinceMs ??
+                resolveDefaultSinceMs(harness.name, Date.now(), {
+                    ...(options.stateDb ? { stateDb: options.stateDb } : {}),
+                    ...(options.stateDbPath ? { stateDbPath: options.stateDbPath } : {}),
+                });
             const candidates = harness.listSessions({ sinceMs });
             if (candidates.length === 0)
                 continue;

package/dist/commands/improve/improve.js

@@ -1887,7 +1887,10 @@ async function runImprovePreparationStage(args) {
     // memory mtimes, so a skipped extract never flags work for the NEXT run's
     // consolidation mtime-gate (the downstream trigger #554 asks us to suppress).
     const EXTRACT_DEFAULT_MIN_NEW_SESSIONS = 0;
-    const configuredMinNewSessions = extractConfig.profiles?.improve?.default?.processes?.extract?.minNewSessions;
+    // Read from the ACTIVE resolved profile (not always `default`), matching how
+    // `extract.enabled` resolves — otherwise a non-default profile (e.g.
+    // `frequent`) setting `minNewSessions` was silently ignored.
+    const configuredMinNewSessions = improveProfile.processes?.extract?.minNewSessions;
     const minNewSessions = typeof configuredMinNewSessions === "number" ? configuredMinNewSessions : EXTRACT_DEFAULT_MIN_NEW_SESSIONS;
     // #593/#594: the ACTIVE resolved improve profile is the single source of
     // truth for whether extract runs. (Previously this also ANDed in the legacy
@@ -1904,6 +1907,11 @@ async function runImprovePreparationStage(args) {
             const countFn = options.extractCandidateCountFn ?? countNewExtractCandidates;
             const newCandidateCount = countFn(extractConfig, {
                 ...(options.extractHarnesses ? { harnesses: options.extractHarnesses } : {}),
+                // Use the ACTIVE profile's discovery window so the gate counts over the
+                // same window akmExtract will scan (not always `default`).
+                ...(improveProfile.processes?.extract?.defaultSince
+                    ? { since: improveProfile.processes.extract.defaultSince }
+                    : {}),
                 // C2: pin the candidate-count state.db open to the boundary-resolved path.
                 ...(eventsCtx?.dbPath ? { stateDbPath: eventsCtx.dbPath } : {}),
             });

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

@@ -208,6 +208,11 @@ export const ImproveProcessConfigSchema = z
     maxSessionsPerRun: z.number().int().min(0).optional(),
     // #561 — index agent sessions as a searchable `session` asset (extract
     // process). Absent = on-when-an-LLM-is-available (fail-open when offline).
+    // COST: when on, each processed session makes a SECOND LLM call (the session
+    // summary) on top of the extraction call — i.e. ~2 LLM calls/session. Set to
+    // false to halve per-session extract cost at the price of unsearchable
+    // sessions. (Unchanged/skip sessions still cost zero — the content-hash
+    // ledger gates both calls upstream.)
     indexSessions: z.boolean().optional(),
     // #561 — minimum session duration in minutes for session indexing. 0
     // disables the gate. Absent = default 5. Only meaningful on `extract`.

package/dist/core/state-db.js

@@ -1520,6 +1520,23 @@ export function getExtractedSessionsMap(db, harness, sessionIds) {
     }
     return out;
 }
+/**
+ * The most recent extract-run time for a harness — `MAX(processed_at)` across
+ * its ledger rows, as ms epoch — or `null` when the harness has never been
+ * extracted. Used to default the discovery window to "since the last run" so an
+ * intermittently-online host that was off for days still rediscovers sessions
+ * that ended during the gap (the content-hash ledger keeps the widened window
+ * free of redundant LLM cost).
+ */
+export function getLastExtractRunAt(db, harness) {
+    const row = db
+        .prepare("SELECT MAX(processed_at) AS last FROM extract_sessions_seen WHERE harness = ?")
+        .get(harness);
+    if (!row?.last)
+        return null;
+    const ms = Date.parse(row.last);
+    return Number.isFinite(ms) ? ms : null;
+}
 /**
  * Decide whether a session should be skipped because the extractor has already
  * processed BYTE-IDENTICAL content (#602). The skip authority is the content

package/dist/scripts/migrate-storage.js

@@ -8998,6 +8998,7 @@ __export(exports_state_db, {
   getStateDbPath: () => getStateDbPath,
   getRecombineHypothesis: () => getRecombineHypothesis,
   getPhaseThreshold: () => getPhaseThreshold,
+  getLastExtractRunAt: () => getLastExtractRunAt,
   getExtractedSessionsMap: () => getExtractedSessionsMap,
   getExtractedSession: () => getExtractedSession,
   getConsolidationJudgedMap: () => getConsolidationJudgedMap,
@@ -9437,6 +9438,13 @@ function getExtractedSessionsMap(db, harness, sessionIds) {
   }
   return out;
 }
+function getLastExtractRunAt(db, harness) {
+  const row = db.prepare("SELECT MAX(processed_at) AS last FROM extract_sessions_seen WHERE harness = ?").get(harness);
+  if (!row?.last)
+    return null;
+  const ms = Date.parse(row.last);
+  return Number.isFinite(ms) ? ms : null;
+}
 function shouldSkipAlreadyExtractedSession(prior, currentContentHash) {
   if (!prior)
     return false;

package/package.json

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