akm-cli 0.8.0-rc.7 → 0.8.0-rc.8

package/CHANGELOG.md

@@ -6,6 +6,20 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/).
 
 ## [Unreleased]
 
+## [0.8.0] - 2026-05-28
+
+### Fixed
+
+- **Consolidation `delete_failed` on stale index entries** — when consolidation
+  successfully deleted a memory file, the index DB was not re-indexed between
+  runs. Subsequent runs loaded the stale DB entry into their memory map, the LLM
+  re-proposed the deletion, and `deleteAssetFromSource` threw "not found in
+  source" — appearing as `delete_failed` in skipReasons. Fix: `loadMemoriesForSource`
+  now filters entries whose file no longer exists on disk before building chunks,
+  so phantom memories are never sent to the LLM. A secondary catch in the delete
+  handler emits `delete_already_gone` instead of `delete_failed` when the file
+  is confirmed absent.
+
 > **CI / Docker users:** the 0.8.0 storage split moved `akm.lock`, the event
 > database, and the registry cache out of `$XDG_CONFIG_HOME/akm/` into
 > `$XDG_DATA_HOME`, `$XDG_STATE_HOME`, and `$XDG_CACHE_HOME` respectively. If
@@ -65,6 +79,8 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/).
 
 ### Changed
 
+- **Rebrand**: the full name "Agent Kit Manager" is now **Agent Knowledge Management** — `akm` stands for Agent Knowledge Management going forward. The binary name, npm package (`akm-cli`), and all APIs remain unchanged.
+
 - **Config layer rewrite** — single-source-of-truth Zod schema in
   `src/core/config-schema.ts` replaces the per-field parse switch AND
   the per-shape load-time parser. Adding a new config field is now one

package/README.md

@@ -1,6 +1,6 @@
-# akm -- Agent Kit Manager
+# akm -- Agent Knowledge Management
 
-> **akm** (Agent Kit Manager) -- A package manager for AI agent skills, commands, tools, and knowledge.
+> **akm** (Agent Knowledge Management) -- A package manager for AI agent skills, commands, tools, and knowledge.
 
 [![npm version](https://img.shields.io/npm/v/akm-cli)](https://www.npmjs.com/package/akm-cli)
 [![npm downloads](https://img.shields.io/npm/dm/akm-cli)](https://www.npmjs.com/package/akm-cli)

package/dist/cli.js

@@ -3175,7 +3175,7 @@ const main = defineCommand({
     meta: {
         name: "akm",
         version: pkgVersion,
-        description: "Agent Kit Manager — search, show, and manage assets from your stash.",
+        description: "Agent Knowledge Management — search, show, and manage assets from your stash.",
     },
     args: {
         format: { type: "string", description: "Output format (json|jsonl|text|yaml)", default: "json" },

package/dist/commands/consolidate.js

@@ -452,7 +452,11 @@ export function mergePlans(chunks) {
                 mergeOps.set(op.primary, op);
             }
             else if (op.op === "delete") {
-                if (!mergeOps.has(op.ref)) {
+                // merge and promote both win over delete. A promote is non-destructive
+                // (creates a proposal) but the source memory is counted in `promoted`;
+                // if a delete also fires, the ref lands in both `promoted` and
+                // `skipReasons`, breaking the invariant by +1.
+                if (!mergeOps.has(op.ref) && !promoteOps.has(op.ref)) {
                     deleteOps.set(op.ref, op);
                 }
             }
@@ -475,6 +479,44 @@ export function mergePlans(chunks) {
             }
         }
     }
+    // Second pass: enforce merge-wins-over-delete and deduplicate secondaries.
+    //
+    // 1. Delete/secondary ordering bug: the per-chunk loop removes delete ops
+    //    for secondaries that were already in deleteOps, but misses the case
+    //    where the delete chunk came first. A full sweep here fixes both orders.
+    //
+    // 2. Cross-merge secondary dedup: if ref A is a secondary in two merge ops,
+    //    only the first (insertion-order) retains it. Without this, a successful
+    //    merge credits A to mergedSecondaries and a later merge's emitMerge-
+    //    FailureSkips also charges A to skipReasons — double-counting A while
+    //    processed has it only once.
+    //
+    // 3. Primary-as-secondary dedup: if ref A is a primary in one merge op and
+    //    a secondary in another, remove A from the secondary list. Both merges
+    //    would otherwise claim A (merged++ for A, then mergedSecondaries++ for A)
+    //    breaking the invariant the same way.
+    // Also remove delete ops for any ref claimed by a promote op (handles the
+    // case where the delete chunk appeared before the promote chunk).
+    for (const ref of promoteOps.keys()) {
+        deleteOps.delete(ref);
+    }
+    const claimedSecondaries = new Set();
+    for (const mergeOp of mergeOps.values()) {
+        deleteOps.delete(mergeOp.primary);
+        mergeOp.secondaries = mergeOp.secondaries.filter((sec) => {
+            if (mergeOps.has(sec)) {
+                warnings.push(`Merge: secondary ${sec} is also a merge primary — removing from secondary list to avoid double-count.`);
+                return false;
+            }
+            if (claimedSecondaries.has(sec)) {
+                warnings.push(`Merge: secondary ${sec} appears in multiple merge ops — retaining in first op only.`);
+                return false;
+            }
+            claimedSecondaries.add(sec);
+            deleteOps.delete(sec);
+            return true;
+        });
+    }
     // C-2 / #381: promote ops are ordered BEFORE merge ops so that the
     // human-gated proposal queue entry is created before any destructive merge.
     // Phase B processes ops in array order, so promote executes first.
@@ -773,6 +815,11 @@ export async function akmConsolidate(opts = {}) {
     // health rollup can aggregate without regex-parsing English warning
     // strings. See `/tmp/akm-health-investigations/tuning-reasons-investigation.md` §Q2.
     const skipReasons = [];
+    // Tracks refs already emitted to skipReasons. A ref can only occupy one
+    // accounting bucket; subsequent skip ops for the same ref are recorded as
+    // warnings but must not push a second skipReasons entry (that would inflate
+    // Σ(skipReasons) and break the invariant by +1 per duplicate).
+    const skipReasonEmittedRefs = new Set();
     const pushSkipReason = (op, ref, reason) => {
         // 2026-05-27 cross-chunk double-count fix: if `ref` already contributed
         // to judgedNoAction in its own chunk (a different chunk proposed an op
@@ -782,6 +829,13 @@ export async function akmConsolidate(opts = {}) {
         // Σ(skipReasons) + failedChunkMemories.
         if (judgedNoActionRefs.delete(ref))
             judgedNoAction--;
+        if (skipReasonEmittedRefs.has(ref)) {
+            // Already counted once. Record the extra skip for observability but
+            // don't push to skipReasons — that would break the accounting invariant.
+            warnings.push(`Skip: ${ref} already in skipReasons (${reason} via ${op}); not re-counted.`);
+            return;
+        }
+        skipReasonEmittedRefs.add(ref);
         skipReasons.push({ op, ref, reason });
     };
     // judgedNoAction tracks memories the LLM saw inside a chunk but proposed
@@ -1173,12 +1227,10 @@ export async function akmConsolidate(opts = {}) {
             const entry = memoryByRef.get(op.ref);
             if (!entry) {
                 warnings.push(`Delete: ${op.ref} not found in loaded memories — skipping.`);
-                // Accounting impact only if op.ref happens to be a real in-chunk
-                // memory; for phantom refs (the typical case) the chunk's targetRefs
-                // gained the ref but no chunk member matched it, so judgedNoAction
-                // is unaffected and this skipReason is a no-op for the invariant.
-                // Emit unconditionally for visibility.
-                pushSkipReason("delete", op.ref, "delete_ref_missing");
+                // Phantom ref: not in the batch so not in processed. Pushing to
+                // skipReasons would inflate Σ(skipReasons) without a matching processed
+                // entry, breaking the accounting invariant. Visibility is preserved via
+                // the warnings array above.
                 continue;
             }
             // captureMode:hot guard — refuse to delete user-captured memories OR
@@ -1205,15 +1257,26 @@ export async function akmConsolidate(opts = {}) {
                 deleted++;
             }
             catch (e) {
-                warnings.push(`Delete: failed for ${op.ref}: ${String(e)}`);
-                pushSkipReason("delete", op.ref, "delete_failed");
+                // Distinguish "file already absent" from genuine failures. A prior run
+                // may have deleted the file but the DB was not yet re-indexed, so the
+                // ref still appeared in memoryByRef. The delete goal is already met.
+                const msg = e instanceof Error ? e.message : String(e);
+                if (msg.includes("not found in source")) {
+                    warnings.push(`Delete: ${op.ref} — file already absent (stale DB entry); skipping.`);
+                    pushSkipReason("delete", op.ref, "delete_already_gone");
+                }
+                else {
+                    warnings.push(`Delete: failed for ${op.ref}: ${String(e)}`);
+                    pushSkipReason("delete", op.ref, "delete_failed");
+                }
             }
         }
         else if (op.op === "promote") {
             const entry = memoryByRef.get(op.ref);
             if (!entry) {
                 warnings.push(`Promote: ${op.ref} not found in loaded memories — skipping.`);
-                pushSkipReason("promote", op.ref, "promote_ref_missing");
+                // Phantom ref: not in processed, so no skipReason (same rationale as
+                // delete_ref_missing above).
                 continue;
             }
             // Within-run source-ref dedup: skip if this source memory was already
@@ -1396,11 +1459,14 @@ export async function akmConsolidate(opts = {}) {
             const contradictorEntry = memoryByRef.get(op.contradictedByRef);
             if (!entry) {
                 warnings.push(`Contradict: ${op.ref} not found in loaded memories — skipping.`);
-                pushSkipReason("contradict", op.ref, "contradict_ref_missing");
+                // Phantom ref: not in processed, so no skipReason (same rationale as
+                // delete_ref_missing).
                 continue;
             }
             if (!contradictorEntry) {
                 warnings.push(`Contradict: ${op.contradictedByRef} not found — skipping.`);
+                // op.ref IS in the batch (entry found above) so the skipReason is
+                // correctly charged against a real processed memory.
                 pushSkipReason("contradict", op.ref, "contradict_target_missing");
                 continue;
             }
@@ -1769,6 +1835,12 @@ function loadMemoriesForSource(source, stashDir, warnings) {
             return path.resolve(e.stashDir) === path.resolve(source);
         })
             .filter((e) => isConsolidationEligibleMemoryName(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
+            // because the file is already gone. Re-indexing runs on a cron cadence so
+            // several successful deletes can accumulate before the DB catches up.
+            .filter((e) => fs.existsSync(e.filePath))
             .map((e) => ({
             name: e.entry.name,
             filePath: e.filePath,

package/dist/commands/health.js

@@ -704,6 +704,14 @@ function computeWallTimeStats(durationsMs, byPhase) {
         byPhase: phase,
     };
 }
+/**
+ * NOTE: this reads from task_history, which can produce a count that differs
+ * by ±1 from improve_runs (the source for wallTime.byPhase). The discrepancy
+ * occurs when a task_history row has no matching improve_runs record (task
+ * crashed before recordImproveRun wrote) or vice versa (manual run). The
+ * count mismatch is cosmetic — it does not affect median/p95 materially.
+ * A full fix requires joining against improve_runs; tracked as a follow-up.
+ */
 function collectImproveWallTimes(db, since, until) {
     const sql = until
         ? "SELECT started_at, completed_at FROM task_history WHERE task_id = 'akm-improve' AND started_at >= ? AND started_at < ? AND completed_at IS NOT NULL"

package/dist/core/config-schema.js

@@ -127,6 +127,9 @@ export const ImproveProcessConfigSchema = z
     allowedTypes: z.array(z.string().min(1)).optional(),
     qualityGate: z.object({ enabled: z.boolean().optional() }).strict().optional(),
     contradictionDetection: z.object({ enabled: z.boolean().optional() }).strict().optional(),
+    // Extract process config (only meaningful for extract process)
+    defaultSince: z.string().min(1).optional(),
+    maxTotalChars: positiveInt.optional(),
 })
     .strict();
 const ImproveProfileProcessesSchema = z

package/dist/core/state-db.js

@@ -1033,7 +1033,7 @@ export function shouldSkipAlreadyExtractedSession(prior, liveSessionEndedAtMs) {
  * created with CREATE TABLE IF NOT EXISTS so it is safe to call inside
  * ensureSchema() or as a standalone migration.
  *
- * Purpose: caches the result of resolving and fetching remote registry kit
+ * Purpose: caches the result of resolving and fetching remote registry stash
  * indexes so `akm search` does not hit the network on every invocation.
  *
  * Indexed (query) columns:

package/dist/registry/factory.js

@@ -7,7 +7,7 @@
  * Maps registry provider type identifiers (e.g. "static-index", "skills-sh")
  * to factory functions that create RegistryProvider instances.
  *
- * "Registry" here refers to the kit discovery registries (static index files,
+ * "Registry" here refers to the stash discovery registries (static index files,
  * skills.sh API) — not to be confused with the source provider factory map in
  * `sources/provider-factory.ts` or the installed-source operations in
  * `installed-stashes.ts`.

package/dist/registry/providers/skills-sh.js

@@ -64,7 +64,7 @@ class SkillsShProvider {
     /**
      * skills.sh has no `getKit` API — every entry corresponds to a GitHub
      * repository whose metadata we already include in the search result. We
-     * synthesize a manifest from the search hit when the caller knows the kit
+     * synthesize a manifest from the search hit when the caller knows the stash
      * id; if not present in the most recent results, return null.
      */
     async getKit(id) {

package/dist/scripts/migrate-storage.js

@@ -14436,7 +14436,9 @@ var init_config_schema = __esm(() => {
     timeoutMs: exports_external.union([positiveInt, exports_external.null()]).optional(),
     allowedTypes: exports_external.array(exports_external.string().min(1)).optional(),
     qualityGate: exports_external.object({ enabled: exports_external.boolean().optional() }).strict().optional(),
-    contradictionDetection: exports_external.object({ enabled: exports_external.boolean().optional() }).strict().optional()
+    contradictionDetection: exports_external.object({ enabled: exports_external.boolean().optional() }).strict().optional(),
+    defaultSince: exports_external.string().min(1).optional(),
+    maxTotalChars: positiveInt.optional()
   }).strict();
   ImproveProfileProcessesSchema = exports_external.object({
     reflect: ImproveProcessConfigSchema.optional(),

package/dist/sources/providers/git.js

@@ -18,6 +18,13 @@ import { applyAkmIncludeConfig, buildInstallCacheDir, copyDirectoryContents, det
 const CACHE_TTL_MS = 12 * 60 * 60 * 1000;
 /** Maximum stale age allowed when refresh fails (7 days). */
 const CACHE_STALE_MS = 7 * 24 * 60 * 60 * 1000;
+function runGit(args, options) {
+    return spawnSync("git", args, {
+        encoding: "utf8",
+        ...options,
+        env: { ...process.env, ...options?.env, GIT_TERMINAL_PROMPT: "0" },
+    });
+}
 /**
  * Git source provider — clones (and re-pulls) a remote repo into a local
  * cache directory. Implements the v1 {@link SourceProvider} interface (spec
@@ -221,7 +228,7 @@ async function doSyncGit(parsed, options) {
             cloneArgs.push("--branch", parsed.requestedRef);
         }
         cloneArgs.push(parsed.url, cloneDir);
-        const cloneResult = spawnSync("git", cloneArgs, { encoding: "utf8", timeout: 120_000 });
+        const cloneResult = runGit(cloneArgs, { timeout: 120_000 });
         if (cloneResult.status !== 0) {
             throw new Error(classifyCloneFailure(parsed.url, cloneResult.stderr, cloneResult.error));
         }
@@ -268,7 +275,7 @@ export function cloneRepo(cloneUrl, ref, destDir, writable = false) {
     if (ref)
         args.push("--branch", ref);
     args.push(cloneUrl, tmpDir);
-    const result = spawnSync("git", args, { encoding: "utf8", timeout: 120_000 });
+    const result = runGit(args, { timeout: 120_000 });
     if (result.status !== 0) {
         // Clean up the (possibly partial) temp dir but leave destDir untouched.
         fs.rmSync(tmpDir, { recursive: true, force: true });
@@ -293,8 +300,7 @@ export function cloneRepo(cloneUrl, ref, destDir, writable = false) {
     }
 }
 function pullRepo(repoDir) {
-    const result = spawnSync("git", ["-C", repoDir, "pull", "--ff-only"], {
-        encoding: "utf8",
+    const result = runGit(["-C", repoDir, "pull", "--ff-only"], {
         timeout: 120_000,
     });
     if (result.status !== 0) {
@@ -431,7 +437,7 @@ export function saveGitStash(name, message, writableOverride) {
         return { committed: false, pushed: false, skipped: true, reason: "not a git repository", output: "" };
     }
     // Nothing to commit?
-    const statusResult = spawnSync("git", ["-C", repoDir, "status", "--porcelain"], { encoding: "utf8" });
+    const statusResult = runGit(["-C", repoDir, "status", "--porcelain"]);
     if (statusResult.error || statusResult.status !== 0) {
         throw new Error(`git status failed: ${statusResult.error?.message || statusResult.stderr?.trim() || "unknown error"}`);
     }
@@ -456,16 +462,26 @@ export function saveGitStash(name, message, writableOverride) {
     // Stage and commit — supply fallback identity so fresh environments without
     // user.name/user.email configured can always commit to the default stash.
     // `add -A` is safe here because nonAkmDirty was just verified empty.
-    const addResult = spawnSync("git", ["-C", repoDir, "add", "-A"], { encoding: "utf8" });
+    const addResult = runGit(["-C", repoDir, "add", "-A"]);
     if (addResult.status !== 0) {
         throw new Error(`git add failed: ${addResult.stderr?.trim() || "unknown error"}`);
     }
-    const commitResult = spawnSync("git", ["-C", repoDir, "-c", "user.name=akm", "-c", "user.email=akm@local", "commit", "-m", commitMessage], { encoding: "utf8" });
+    const commitResult = runGit([
+        "-C",
+        repoDir,
+        "-c",
+        "user.name=akm",
+        "-c",
+        "user.email=akm@local",
+        "commit",
+        "-m",
+        commitMessage,
+    ]);
     if (commitResult.status !== 0) {
         throw new Error(`git commit failed: ${commitResult.stderr?.trim() || "unknown error"}`);
     }
     // Push only when there is a remote AND the stash is marked writable
-    const remoteResult = spawnSync("git", ["-C", repoDir, "remote"], { encoding: "utf8" });
+    const remoteResult = runGit(["-C", repoDir, "remote"]);
     if (remoteResult.status !== 0) {
         throw new Error(`git remote failed: ${remoteResult.stderr?.trim() || "unknown error"}`);
     }
@@ -473,7 +489,7 @@ export function saveGitStash(name, message, writableOverride) {
     if (!hasRemote || !writable) {
         return { committed: true, pushed: false, skipped: false, output: commitResult.stdout.trim() };
     }
-    const pushResult = spawnSync("git", ["-C", repoDir, "push"], { encoding: "utf8", timeout: 120_000 });
+    const pushResult = runGit(["-C", repoDir, "push"], { timeout: 120_000 });
     if (pushResult.status !== 0) {
         throw new Error(`git push failed: ${pushResult.stderr?.trim() || "unknown error"}`);
     }

package/package.json

@@ -1,10 +1,11 @@
 {
   "name": "akm-cli",
-  "version": "0.8.0-rc.7",
+  "version": "0.8.0-rc.8",
   "type": "module",
-  "description": "akm (Agent Kit Manager) — A package manager for AI agent skills, commands, tools, and knowledge. Works with Claude Code, OpenCode, Cursor, and any AI coding assistant.",
+  "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": [
     "akm",
+    "agent-knowledge-management",
     "agent-kit-manager",
     "akm-cli",
     "ai-agent",
@@ -53,9 +54,9 @@
     "build": "rm -rf dist && bun run tsc --project ./tsconfig.build.json && bun scripts/copy-assets.ts",
     "check": "bun run lint && bunx tsc --noEmit && bun run test:unit && bun run test:integration",
     "check:changed": "bun test tests/output-baseline.test.ts tests/integration/e2e.test.ts tests/stash-search.test.ts && bun run lint && bunx tsc --noEmit",
-    "test": "bun test --parallel=12 --timeout=15000 ./tests",
-    "test:unit": "bun test --parallel=12 --timeout=15000 ./tests --path-ignore-patterns=tests/integration",
-    "test:integration": "bun test --parallel=12 --timeout=15000 ./tests/integration ./tests/commands ./tests/workflows",
+    "test": "bun test --parallel=12 --timeout=30000 ./tests",
+    "test:unit": "bun test --parallel=12 --timeout=30000 ./tests --path-ignore-patterns=tests/integration",
+    "test:integration": "bun test --parallel=12 --timeout=30000 ./tests/integration ./tests/commands ./tests/workflows",
     "test:sharded": "bun test ./tests --shard=1/4 & bun test ./tests --shard=2/4 & bun test ./tests --shard=3/4 & bun test ./tests --shard=4/4 & wait",
     "test:time": "bun scripts/test-timing-report.ts",
     "lint:isolation": "bun scripts/lint-tests-isolation.ts",