akm-cli 0.9.16 → 0.9.17-alpha.10

package/dist/core/errors.js

@@ -11,13 +11,13 @@ const CONFIG_HINTS = {
     STASH_DIR_UNREADABLE: "Check the path exists and your user has read permission, or update the default bundle path.",
     DATA_DIR_UNREADABLE: "The data directory is not readable by the user running akm. Check its owner and mode, or point AKM_DATA_DIR / XDG_DATA_HOME somewhere this user owns.",
     INDEX_SCHEMA_INCOMPATIBLE: "Run `akm index --full` to rebuild the derived index from the currently materialized sources.",
-    EMBEDDING_NOT_CONFIGURED: 'Run `akm config set embedding \'{"endpoint":"...","model":"..."}\'` to enable embeddings.',
     LLM_NOT_CONFIGURED: 'Run `akm setup` or configure an `engines` entry with `kind: "llm"`, then select it with `defaults.llmEngine`.',
     TEST_ISOLATION_MISSING: "Under bun test, when AKM_BUNDLE_DIR is set you MUST also set XDG_DATA_HOME (or AKM_DATA_DIR) and XDG_STATE_HOME (or AKM_STATE_DIR) to temp directories so the test does not touch the developer's real ~/.local/share/akm or ~/.local/state/akm.",
     UNSAFE_STASH_DIR: "Choose a path inside your home directory (e.g. ~/akm) or another empty workspace. The bundle directory cannot be the filesystem root, your home directory itself, or a sensitive system path like /etc, /var, ~/.config, or ~/.ssh.",
     UNKNOWN_IMPROVE_STRATEGY: "Pass one of the listed strategy names to `--strategy`, or define it under `improve.strategies`. Names are case-sensitive.",
     EXECUTION_NOT_AUTHORIZED: "Change the selected tools or update the machine/user execution policy, then retry.",
     SECRET_REFERENCE_UNRESOLVED: "Check the secret exists (`akm secret list`) and the name after `secret://` matches, or run `akm secret set <name> <value>` to store it.",
+    REGISTRY_URL_INVALID: "Registry URLs must be credential-free http(s) URLs. Fix the entry with `akm registry list` / `akm registry add`, or the AKM_REGISTRY_URL / AKM_NPM_REGISTRY variable that supplied it.",
 };
 // Code-review finding: COMPOSITION_INVALID covers several unrelated causes
 // (a rejected with:, a multi-job source, a composition cycle/depth/size
@@ -56,7 +56,7 @@ const USAGE_HINTS = {
     //
     // Code-review finding: this default is reached ONLY by with:-rejection
     // throw sites (the ones above, plus task.ts's noDeclaredInputsError and
-    // resolve-steps.ts's rejectNonTaskBindingWith) — every other
+    // freeze.ts's resolveStep) — every other
     // COMPOSITION_INVALID throw site (multi-job source, composition
     // cycle/depth/size, invalid child-output reference, an env: on a
     // composing step) passes its own explicit constructor hint instead of
@@ -72,19 +72,17 @@ const USAGE_HINTS = {
     WORKFLOW_SOURCE_INVALID: "Run `akm lint` to see the failing source location, or `akm workflow plan <ref>` to compile it without writing.",
     INPUT_BINDING_INVALID: "Check the step's with: keys against the target's declared inputs.",
     TASK_TARGET_UNSUPPORTED: "Task definitions support command, script, workflow, and shell (run:) targets; akm/command is layered by callers.",
-    // P3a (docs/plans/specs/p3a-plan-v5-child-freeze.md §3.2, A-N2): the
-    // complete-or-abandon policy for a stored pre-irVersion-5 run.
-    WORKFLOW_IR_VERSION_UNSUPPORTED: "Abandon the run with `akm workflow abandon <id>`, then start it again from the workflow source — a frozen plan this akm cannot execute is not re-executable in place.",
-    // P3b (docs/plans/specs/p3b-child-executor.md §4.3).
-    WORKFLOW_OUTPUT_INVALID: "Check each `outputs:` entry's `from:` against the step artifact it names, and its `schema:` against the value that step actually promotes.",
 };
 /** Default hint for each TransientErrorCode. */
 const TRANSIENT_HINTS = {
-    RUN_LEASE_HELD: "Wait for the named engine invocation to finish or for the lease to expire, then retry. `akm workflow status <id>` shows the current lease.",
+    RUN_LEASE_HELD: "Wait for the akm process driving this run (the named pid) to finish, then retry.",
     STATE_DB_CONTENDED: "Another akm process is writing state.db right now. Wait a few seconds and retry; commands that support --skip-if-locked can skip instead of failing.",
     INDEX_DB_CONTENDED: "Another akm process is writing index.db; retry shortly, or pass --skip-if-locked on scheduled runs.",
-    MAINTENANCE_BARRIER_BUSY: "Another akm process is registering a lock or lease right now. Retry shortly, or pass --skip-if-locked on scheduled index/improve/workflow runs.",
     IMPROVE_LOCK_HELD: "Another akm improve run holds the whole-run lock right now. Wait for it to finish and retry, or pass --skip-if-locked on scheduled runs.",
+    LOCKFILE_CONTENDED: "Another akm process is updating its bundle lockfile right now. Wait a few seconds and retry.",
+    ASSET_MUTATION_LEASE_HELD: "Another akm process is writing bundle content right now. Wait for it to finish and retry.",
+    SCHEDULER_LOCK_HELD: "Another `akm task sync`, `add`, `enable`, `disable` or `prune` is writing the scheduler right now. Wait for it to finish and retry.",
+    REGISTRY_UNREACHABLE: "The registry did not answer in time. Check the network and the registry URL (`akm registry list`), then retry.",
 };
 /** Default hint for each NotFoundError code. */
 const NOT_FOUND_HINTS = {
@@ -97,6 +95,7 @@ const NOT_FOUND_HINTS = {
     PROPOSAL_NOT_FOUND: "Run `akm proposal list` to see pending proposals and their ids.",
     FILE_NOT_FOUND: "Check the path exists and is readable.",
     IMPROVE_RUN_NOT_FOUND: "Run `akm improve` first, or `akm improve report --since 30d` to see recent run ids in `runIds`.",
+    REGISTRY_NOT_FOUND: "Check the ref's spelling and version; `akm search <query> --from registry` lists installable refs.",
 };
 /**
  * Base class for all akm-thrown, classified errors. Carries the `kind`

package/dist/core/file-change.js

@@ -4,13 +4,21 @@
 /**
  * The content of a proposal's PRIMARY change (WI-6.2 envelope read path).
  *
- * By construction `changes[0].after === payload.content`; consumers read
- * through this accessor so the single-content assumption lives in ONE place
- * once multi-file proposals (consolidate ops) ride the envelope. Typed
- * structurally (not against `Proposal`) so this module stays dependency-free.
+ * By construction `changes[0].after === payload.content` for a `create` or
+ * `update` change; consumers read through this accessor so the
+ * single-content assumption lives in ONE place. A `delete` primary change (a
+ * consolidate retire proposal, alpha.9) writes no content by definition, so
+ * it reads as `""` here rather than throwing — every generic proposal scan
+ * (dedup-by-body-hash, the triage drain's diff-size filter, the quality
+ * validators) can call this on ANY pending proposal, retire included,
+ * without special-casing the op first. Typed structurally (not against
+ * `Proposal`) so this module stays dependency-free.
  */
 export function proposalContent(p) {
-    const content = p.changes[0]?.after;
+    const primary = p.changes[0];
+    if (primary?.op === "delete")
+        return "";
+    const content = primary?.after;
     if (content === undefined)
         throw new Error("Proposal primary change has no content.");
     return content;

package/dist/core/file-lock.js

@@ -1,11 +1,20 @@
 // This Source Code Form is subject to the terms of the Mozilla Public
 // License, v. 2.0. If a copy of the MPL was not distributed with this
 // file, You can obtain one at https://mozilla.org/MPL/2.0/.
+/**
+ * PID-stamped exclusive lock files.
+ *
+ * A lock is one file created with `O_EXCL` (`wx`), which the filesystem
+ * makes atomic: exactly one creator wins, so no further mutex or barrier is
+ * needed around acquisition. The payload records the holder's PID (and the
+ * launcher PID under a scheduler) so a probe can tell a live holder from a
+ * dead one; only a verifiably dead holder — or, when the caller opts in via
+ * `staleAfterMs`, an over-age one — is ever reclaimed. Reclaim moves the
+ * stale file aside, re-verifies it is the very file that was probed, and only
+ * then unlinks it, so two reclaimers cannot both "win" the same stale lock.
+ */
 import { randomUUID } from "node:crypto";
 import fs from "node:fs";
-import path from "node:path";
-import { sleepSync } from "../runtime.js";
-import { openDatabase } from "../storage/database.js";
 import { isProcessAlive, MAX_LOCK_METADATA_BYTES, readTextFileDescriptorWithLimit } from "./common.js";
 function readLockSnapshot(lockPath) {
     let fd;
@@ -32,51 +41,16 @@ function readLockSnapshot(lockPath) {
 function sameIdentity(left, right) {
     return left.dev === right.dev && left.ino === right.ino && left.size === right.size && left.mtimeMs === right.mtimeMs;
 }
-function operationMutexPath(lockPath) {
-    // `.sensitive` is an established non-asset suffix across stash walkers. The
-    // mutex may sit beside a secret/env lock and must never surface as an asset.
-    return path.join(path.dirname(lockPath), `.${path.basename(lockPath)}.operations.sensitive`);
-}
-/**
- * Serialize every mutation of one canonical lock path. SQLite's write lock is
- * released by the OS when a process dies, so this mutex needs no stale-owner
- * deletion protocol (which would reproduce the same check/rename race it is
- * meant to prevent).
- */
-function withLockOperationMutex(lockPath, run) {
-    const db = openDatabase(operationMutexPath(lockPath));
-    let began = false;
+function releaseLockRaw(lockPath) {
     try {
-        db.exec("PRAGMA busy_timeout = 30000");
-        for (let attempt = 0; attempt < 5 && !began; attempt += 1) {
-            db.exec("BEGIN IMMEDIATE");
-            began = db.inTransaction;
-            if (!began)
-                sleepSync(2 ** attempt);
-        }
-        if (!began)
-            throw new Error(`Could not acquire lock operation mutex for ${lockPath}.`);
-        const result = run();
-        db.exec("COMMIT");
-        began = false;
-        return result;
-    }
-    catch (error) {
-        if (began && db.inTransaction) {
-            try {
-                db.exec("ROLLBACK");
-            }
-            catch {
-                // Preserve the operation failure.
-            }
-        }
-        throw error;
+        fs.unlinkSync(lockPath);
     }
-    finally {
-        db.close();
+    catch {
+        // Already gone.
     }
 }
-function tryAcquireLockRaw(lockPath, payload) {
+/** Create the lock file atomically; `undefined` when another holder already has it. */
+export function tryAcquireLockSync(lockPath, payload) {
     try {
         fs.writeFileSync(lockPath, payload, { flag: "wx" });
     }
@@ -99,35 +73,6 @@ function tryAcquireLockRaw(lockPath, payload) {
     }
     return { lockPath, ...snapshot };
 }
-function releaseLockRaw(lockPath) {
-    try {
-        fs.unlinkSync(lockPath);
-    }
-    catch {
-        // Sentinel already gone — fine.
-    }
-}
-/**
- * Atomically create a sentinel at `lockPath` with `payload` as the body.
- * Returns an exact ownership handle if we now own the lock, or undefined if a sentinel already
- * exists (EEXIST). Throws any other error (permissions, missing parent
- * dir, etc.) — callers must ensure the parent directory exists.
- *
- * `payload` is typically `String(process.pid)` for the simple cases or
- * a small JSON envelope for callers that want richer metadata
- * (improve.ts records pid + startedAt so audit can correlate runs).
- */
-export function tryAcquireLockSync(lockPath, payload) {
-    return withLockOperationMutex(lockPath, () => tryAcquireLockRaw(lockPath, payload));
-}
-/**
- * Best-effort launcher pid from `AKM_LAUNCHER_PID` (set by
- * `scripts/node-runtime/akm`/`akm-migrate`, #956) — undefined when unset,
- * empty, or not a positive integer (never trust an ambient env var blindly
- * into a lock message). Also the gate the parent-death watchdog
- * (`core/parent-watchdog.ts`) uses to stay inert outside a launcher-managed
- * run.
- */
 export function launcherPidFromEnv() {
     const raw = process.env.AKM_LAUNCHER_PID;
     if (!raw)
@@ -135,13 +80,6 @@ export function launcherPidFromEnv() {
     const pid = Number.parseInt(raw, 10);
     return Number.isInteger(pid) && pid > 0 ? pid : undefined;
 }
-/**
- * Build a PID-bearing payload with a unique token for one acquisition attempt.
- * Adds `launcherPid` (#956) whenever this process is running under the
- * published launcher, so a lock's holder can be identified by the pid every
- * process listing and task log actually shows (the launcher's) as well as
- * the pid that holds the lock (the bun/node child).
- */
 export function createLockPayload(metadata = {}) {
     const launcherPid = launcherPidFromEnv();
     return JSON.stringify({
@@ -151,26 +89,12 @@ export function createLockPayload(metadata = {}) {
         lockId: randomUUID(),
     });
 }
-/**
- * Inspect an existing sentinel at `lockPath` without modifying it.
- * Returns:
- *   - `absent` if the file does not exist.
- *   - `stale` if the file is present but should be reclaimed (the holding
- *     PID is dead, the content is unparseable, or the lock has exceeded
- *     `staleAfterMs`). Includes the failure reason so callers can log it.
- *   - `held` if the lock has a live holder and is not yet age-expired.
- *
- * Does NOT remove the file. Callers decide recovery policy.
- */
 export function probeLock(lockPath, opts) {
     let snapshot;
     try {
         snapshot = readLockSnapshot(lockPath);
     }
     catch (error) {
-        // A permission error means the lock may be genuinely HELD by someone we
-        // cannot see. Reporting it as stale would invite a caller to steal a live
-        // lease (#791) — `unreadable` stays for the corrupt/undecodable case.
         const code = error?.code;
         if (code === "EACCES" || code === "EPERM")
             return { state: "inaccessible", code };
@@ -193,102 +117,81 @@ export function probeLock(lockPath, opts) {
     return { state: "held", holderPid, launcherPid, ageMs, rawContent, identity };
 }
 /**
- * Revalidate and quarantine the probed sentinel while holding the same operation
- * mutex used by acquisitions. A newer owner therefore cannot be renamed in the
- * check/quarantine window, and a third contender cannot acquire until cleanup
- * has completed.
+ * Remove a lock that `probeLock` reported stale. Returns `false` when the file
+ * changed since the probe (someone else reclaimed or re-acquired it) so the
+ * caller re-probes instead of assuming the path is free.
  */
 export function reclaimStaleLock(lockPath, probe, options) {
     if (probe.rawContent === undefined || probe.identity === undefined)
         return false;
     const expectedContent = probe.rawContent;
     const expectedIdentity = probe.identity;
-    return withLockOperationMutex(lockPath, () => {
-        let current;
-        try {
-            current = readLockSnapshot(lockPath);
-        }
-        catch {
-            return false;
-        }
-        if (!current || current.rawContent !== expectedContent || !sameIdentity(current.identity, expectedIdentity)) {
+    let current;
+    try {
+        current = readLockSnapshot(lockPath);
+    }
+    catch {
+        return false;
+    }
+    if (!current || current.rawContent !== expectedContent || !sameIdentity(current.identity, expectedIdentity)) {
+        return false;
+    }
+    const quarantinePath = `${lockPath}.stale-${process.pid}-${randomUUID()}`;
+    try {
+        fs.renameSync(lockPath, quarantinePath);
+    }
+    catch (err) {
+        if (err.code === "ENOENT")
             return false;
-        }
-        const quarantinePath = `${lockPath}.stale-${process.pid}-${randomUUID()}`;
+        throw err;
+    }
+    let quarantined;
+    try {
+        quarantined = readLockSnapshot(quarantinePath);
+    }
+    catch {
+        quarantined = undefined;
+    }
+    if (!quarantined ||
+        quarantined.rawContent !== expectedContent ||
+        !sameIdentity(quarantined.identity, expectedIdentity)) {
+        // The file we moved aside is not the one we probed: a fresh holder took
+        // the path in between. Put it back and report no reclaim.
         try {
-            fs.renameSync(lockPath, quarantinePath);
+            fs.linkSync(quarantinePath, lockPath);
         }
         catch (err) {
-            if (err.code === "ENOENT")
-                return false;
-            throw err;
+            if (err.code !== "EEXIST")
+                throw err;
         }
-        let quarantined;
-        try {
-            quarantined = readLockSnapshot(quarantinePath);
-        }
-        catch {
-            quarantined = undefined;
-        }
-        if (!quarantined ||
-            quarantined.rawContent !== expectedContent ||
-            !sameIdentity(quarantined.identity, expectedIdentity)) {
-            try {
-                // Restore without replacing a non-cooperating lock installed after quarantine.
-                fs.linkSync(quarantinePath, lockPath);
-            }
-            catch (err) {
-                if (err.code !== "EEXIST")
-                    throw err;
-            }
-            releaseLockRaw(quarantinePath);
+        releaseLockRaw(quarantinePath);
+        return false;
+    }
+    options?.afterQuarantineVerified?.();
+    try {
+        fs.unlinkSync(quarantinePath);
+        return true;
+    }
+    catch (err) {
+        if (err.code === "ENOENT")
             return false;
-        }
-        options?.afterQuarantineVerified?.();
-        try {
-            fs.unlinkSync(quarantinePath);
-            return true;
-        }
-        catch (err) {
-            if (err.code === "ENOENT")
-                return false;
-            throw err;
-        }
-    });
+        throw err;
+    }
 }
-/**
- * Release only the exact sentinel returned by `tryAcquireLockSync`. Content and
- * file identity are revalidated while holding the acquisition operation mutex,
- * so a stale holder cannot remove a successor. Synchronous and idempotent so it
- * is safe in both `finally` blocks and process exit handlers.
- */
+/** Unlink the lock only while it is still the exact file this owner created. */
 export function releaseLock(ownership) {
     const { lockPath } = ownership;
-    if (!fs.existsSync(lockPath) && !fs.existsSync(operationMutexPath(lockPath)))
+    let current;
+    try {
+        current = readLockSnapshot(lockPath);
+    }
+    catch {
         return;
-    withLockOperationMutex(lockPath, () => {
-        let current;
-        try {
-            current = readLockSnapshot(lockPath);
-        }
-        catch {
-            // Absent or unreadable — nothing of ours to release.
-            return;
-        }
-        if (current && current.rawContent === ownership.rawContent && sameIdentity(current.identity, ownership.identity)) {
-            releaseLockRaw(lockPath);
-        }
-    });
+    }
+    if (current && current.rawContent === ownership.rawContent && sameIdentity(current.identity, ownership.identity)) {
+        releaseLockRaw(lockPath);
+    }
 }
-/**
- * Extract a holder pid, and (#956) a launcher pid when the payload recorded
- * one, from a sentinel body. Accepts the two shapes used across the
- * codebase: a bare numeric string (config-io, vault, lockfile — never
- * carries a `launcherPid`) and a JSON object with `pid`/`launcherPid` fields
- * (`createLockPayload`). `holderPid` is undefined when the body is
- * unparseable or yields a non-positive integer; `launcherPid` is undefined
- * whenever the payload has none, independent of whether `holderPid` parsed.
- */
 function extractLockIdentity(content) {
     const trimmed = content.trim();
     if (!trimmed)

package/dist/core/improve-result.js

@@ -19,6 +19,7 @@ const COMMON_FIELDS = [
     "plan",
     "actions",
     "skippedProcesses",
+    "engineProbe",
     "distillSkipped",
     "validationFailures",
     "schemaRepairs",
@@ -27,14 +28,22 @@ const COMMON_FIELDS = [
     "lintSummary",
     "memoryIndexHealth",
     "coverageGaps",
+    // R10: no longer written (the write-only eval-cases path was removed),
+    // but kept in the allow-list so `decodeImproveResult` still reads
+    // improve-result envelopes a prior release wrote with this field —
+    // AGENTS.md "Reading persisted data".
     "evalCasesWritten",
     "deadUrls",
     "deadUrlCoverage",
     "reflectsWithErrorContext",
     "memoryInference",
+    // 0.9.17-alpha.9: no longer written (the LLM entity-graph extraction that
+    // wrote these was retired), kept readable for the same reason as
+    // `evalCasesWritten` above.
     "graphExtraction",
     "memoryInferenceDurationMs",
     "graphExtractionDurationMs",
+    "ensureIndexDurationMs",
     "orphansPurged",
     "proposalsExpired",
     "reflectCooldownActions",
@@ -113,7 +122,7 @@ function validateConsolidationPlan(value) {
     ]));
     if (!isRecord(value.configured))
         fail("plan.consolidation.configured must be an object");
-    requireExactFields(value.configured, new Set(["enabled", "minPoolSize", "limit", "maxChunkSize", "incrementalSince"]));
+    requireExactFields(value.configured, new Set(["enabled", "minPoolSize", "limit", "maxChunkSize"]));
     if (value.configured.enabled !== undefined && typeof value.configured.enabled !== "boolean") {
         fail("plan.consolidation.configured.enabled must be a boolean");
     }
@@ -122,9 +131,6 @@ function validateConsolidationPlan(value) {
             fail(`plan.consolidation.configured.${field} must be a number`);
         }
     }
-    if (value.configured.incrementalSince !== undefined && typeof value.configured.incrementalSince !== "string") {
-        fail("plan.consolidation.configured.incrementalSince must be a string");
-    }
     if (!isRecord(value.effective))
         fail("plan.consolidation.effective must be an object");
     requireExactFields(value.effective, new Set(["enabled", "minPoolSize", "limit", "chunkSize"]));
@@ -194,7 +200,15 @@ function validateProcessRoutingRows(value) {
             fail("plan.processes entries must be objects");
         requireExactFields(row, new Set(["process", "enabled", "engine", "model", "engineKind", "notices", "unavailable", "eligibleRefs"]));
         if (typeof row.process !== "string" ||
-            !(canonicalNames.includes(row.process) || row.process === "triage.judgment")) {
+            !(canonicalNames.includes(row.process) ||
+                row.process === "triage.judgment" ||
+                // 0.9.17-alpha.9: "graphExtraction" is no longer a process a fresh
+                // plan can route (the LLM entity-graph extraction it named was
+                // retired), but every pre-alpha.9 run recorded one here — kept
+                // readable, same as `stageNames`' "graph-extraction" above and
+                // `graphExtraction` in COMMON_FIELDS, so a historical run still
+                // decodes for `akm health` instead of failing this row outright.
+                row.process === "graphExtraction")) {
             fail("plan.processes.process is invalid");
         }
         if (seen.has(row.process))
@@ -300,6 +314,8 @@ function validateImprovePlan(value, dryRun, plannedRefNames) {
         fail("plan.limits.totalCeiling must equal plan.limits.effective + plan.limits.additiveReplayAllowance");
     }
     const gateNames = new Set(["profile", "cleanup", "validation", "signal", "disk", "limit"]);
+    // Plans stored before 0.9.17-alpha.7 (#986) have no retrieval gate.
+    const optionalGateNames = new Set(["retrieval"]);
     if (!Array.isArray(value.gates))
         fail("plan.gates must be an array");
     const gateRemovedByName = new Map();
@@ -307,8 +323,9 @@ function validateImprovePlan(value, dryRun, plannedRefNames) {
         if (!isRecord(gate))
             fail("plan.gates entries must be objects");
         requireExactFields(gate, new Set(["name", "removed", "reason"]));
-        if (typeof gate.name !== "string" || !gateNames.has(gate.name))
+        if (typeof gate.name !== "string" || !(gateNames.has(gate.name) || optionalGateNames.has(gate.name))) {
             fail("plan.gates.name is invalid");
+        }
         requireCount(gate, "removed", "plan.gates entry");
         if (typeof gate.reason !== "string")
             fail("plan.gates.reason must be a string");
@@ -376,10 +393,18 @@ function validateImprovePlan(value, dryRun, plannedRefNames) {
     if (value.limits.totalCeiling !== undefined && value.effectiveRefs.length > value.limits.totalCeiling) {
         fail("plan.effectiveRefs cannot exceed plan.limits.totalCeiling");
     }
-    validateProcessRoutingRows(value.processes);
+    // #947 added plan.processes (2026-09-09T09:03:19Z); every run recorded
+    // before it legitimately stored `plan` with no `processes` key at all —
+    // validate the rows only when present, same as `proactive` below, so a
+    // pre-#947 envelope still decodes (AGENTS.md "Reading persisted data").
+    if (value.processes !== undefined)
+        validateProcessRoutingRows(value.processes);
     if (value.proactive !== undefined)
         validateProactivePlan(value.proactive);
     validateConsolidationPlan(value.consolidation);
+    // "graph-extraction" is no longer a stage a fresh plan can name — retired
+    // 0.9.17-alpha.9 — but stays here so a historical envelope that captured a
+    // dry-run plan before the retirement still decodes.
     const stageNames = new Set(["consolidation", "extract", "graph-extraction", "memory-inference"]);
     if (!Array.isArray(value.stages))
         fail("plan.stages must be an array");
@@ -442,6 +467,7 @@ function validateCommon(value) {
     for (const field of [
         "actions",
         "skippedProcesses",
+        "engineProbe",
         "validationFailures",
         "schemaRepairs",
         "extract",
@@ -457,10 +483,12 @@ function validateCommon(value) {
     }
     for (const field of [
         "cyclesRun",
+        // R10: retired write, kept readable — see the COMMON_FIELDS comment above.
         "evalCasesWritten",
         "reflectsWithErrorContext",
         "memoryInferenceDurationMs",
         "graphExtractionDurationMs",
+        "ensureIndexDurationMs",
         "orphansPurged",
         "proposalsExpired",
         "reflectCooldownActions",

package/dist/core/improve-types.js

@@ -32,7 +32,6 @@ export function classifyImproveAction(mode) {
         case "reflect":
         case "distill":
         case "memory-inference":
-        case "graph-extraction":
             return "accepted";
         case "reflect-cooldown":
         case "reflect-skipped":

package/dist/core/logs-db.js

@@ -33,13 +33,13 @@
  * ## Schema evolution
  *
  * Same migration-safety contract as state.db: append-only `MIGRATIONS` applied
- * through the shared runner in src/storage/engines/sqlite-migrations.ts.
+ * through the shared runner in src/storage/sqlite-migrations.ts.
  *
  * @module logs-db
  */
 import path from "node:path";
-import { assertMigrationRegistry, runMigrations as runSqliteMigrations, } from "../storage/engines/sqlite-migrations.js";
 import { openManagedDatabase } from "../storage/managed-db.js";
+import { assertMigrationRegistry, runMigrations as runSqliteMigrations, } from "../storage/sqlite-migrations.js";
 import { getDataDir } from "./paths.js";
 // ── Path helper ──────────────────────────────────────────────────────────────
 /**

package/dist/core/loopback.js

@@ -20,10 +20,11 @@
  *
  * The ONE local-vs-remote answer for concurrency defaults — the workflow
  * engine's frozen engine concurrency (`workflows/concurrency-policy.ts`) and
- * the indexer's LLM pool (`indexer/indexer.ts` `getDefaultLlmConcurrency`)
- * both classify through here. NOT shared with the website snapshot fetcher's
- * SSRF policy (`sources/snapshot-fetchers/host-guard.ts`), which deliberately
- * draws different lines for a different threat model.
+ * the embedding pool (`resolveEmbeddingConcurrency`,
+ * `src/llm/embedders/remote.ts`) both classify through here. NOT shared with
+ * the website snapshot fetcher's SSRF policy
+ * (`sources/snapshot-fetchers/host-guard.ts`), which deliberately draws
+ * different lines for a different threat model.
  *
  * @module core/loopback
  */
@@ -92,14 +93,8 @@ export function isLoopbackEndpoint(endpoint) {
  * endpoint: 1 for a loopback endpoint (a local model server serves one
  * inference at a time; concurrent requests thrash it — reload thrash, HTTP
  * 500 "Model reloaded"), 2 for a remote one (enough to overlap request
- * latency without hammering a rate-limited API). A leaf helper so both
- * callers — the indexer's LLM enrichment pool (`getDefaultLlmConcurrency`,
- * `src/indexer/indexer.ts`) and the embedding pool
- * (`resolveEmbeddingConcurrency`, `src/llm/embedders/remote.ts`) — share one
- * definition instead of mirroring it; `src/llm/embedders/remote.ts` cannot
- * import `getDefaultLlmConcurrency` directly (`src/indexer/indexer.ts`
- * already depends on this module transitively through
- * materialize-embeddings.ts).
+ * latency without hammering a rate-limited API). Used by the embedding pool
+ * (`resolveEmbeddingConcurrency`, `src/llm/embedders/remote.ts`).
  */
 export function defaultConcurrencyForEndpoint(endpoint) {
     return isLoopbackEndpoint(endpoint) ? 1 : 2;

package/dist/core/non-task-input.js

@@ -0,0 +1,20 @@
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at https://mozilla.org/MPL/2.0/.
+/** The line of `src/assets/stash-skeleton/README.md` that reaches curate verbatim as a query. */
+const STASH_README_LINE = "This is an **AKM stash** — a structured knowledge repository that stores reusable";
+/**
+ * What the (trimmed) curate input is when it is not a task, else undefined.
+ * Harness and tool envelopes (`<task-notification>…`, `<system-reminder>…`,
+ * `<cross-session-message …>…`) start with a tag and close one, and the stash
+ * README line arrives verbatim; on the retrieval suite neither shape occurs in
+ * a real query. Length is not a signal: prompts over 2,000 characters found
+ * relevant assets at about the rate of shorter long prompts.
+ */
+export function nonTaskInput(query) {
+    if (query.startsWith("<") && query.includes("</"))
+        return "a harness or tool envelope";
+    if (query === STASH_README_LINE)
+        return "the akm stash README boilerplate";
+    return undefined;
+}