akm-cli 0.9.4 → 0.9.6

package/dist/commands/improve/distill.js

@@ -73,7 +73,7 @@ import { stripFrontmatterBody as stripBodyForFidelity } from "./content-hash.js"
 import { autoRepairLessonFrontmatter, autoSwapDescriptionWhenToUse, collectLessonQualityFindings, repairLessonDescriptionTruncation, } from "./distill/content-repair.js";
 import { memoryKnowledgePromotionRequiresDispatch, planMemoryKnowledgePromotion, promoteMemoryToKnowledge, } from "./distill/promote-memory.js";
 import { fetchTopSimilarLessons, persistOutputEncodingSalience, runLessonQualityJudge, writeQualityRejection, } from "./distill/quality-gate.js";
-import { buildClsContext, checkDistillFidelity } from "./distill-guards.js";
+import { buildClsContext, checkDistillFidelity, DEFAULT_CLS_ADJACENT_COUNT } from "./distill-guards.js";
 import { deriveKnowledgeRef } from "./distill-promotion-policy.js";
 import { buildRefVocabulary, scoreEncodingSalience } from "./encoding-salience.js";
 import { resolveImproveLlmExecution } from "./execution.js";
@@ -1239,7 +1239,7 @@ async function buildDistillMessages(args) {
     let clsContext = "";
     if (clsConfig.enabled) {
         try {
-            const adjacentCount = clsConfig.adjacentCount ?? 3;
+            const adjacentCount = clsConfig.adjacentCount ?? DEFAULT_CLS_ADJACENT_COUNT;
             // Use the asset content or input ref as the query for adjacent retrieval.
             const clsQuery = assetContent ? assetContent.slice(0, 500) : inputRef;
             const adjacentItems = await fetchSimilarLessonsFn(clsQuery, adjacentCount);

package/dist/commands/improve/extract.js

@@ -44,6 +44,7 @@ import { indexWrittenAssets } from "../../indexer/index-written-assets.js";
 import { disposeLoweredExecutionDispatchLease, } from "../../integrations/agent/execution-lowering.js";
 import { getAvailableHarnesses } from "../../integrations/session-logs/index.js";
 import { preFilterSession } from "../../integrations/session-logs/pre-filter.js";
+import { isJsonSchemaKnownUnsupported } from "../../llm/client.js";
 import { callStructured, preflightStructuredLlmRunner } from "../../llm/structured-call.js";
 import { sha256Hex } from "../../runtime.js";
 import { getExtractedSessionsMap, getLastExtractRunAt, shouldSkipAlreadyExtractedSession, upsertExtractedSession, } from "../../storage/repositories/extract-sessions-repository.js";
@@ -563,7 +564,13 @@ async function runSessionExtractionLlmCall(args) {
                 return payload.parseFailure ? undefined : payload;
             },
             validate: (payload) => ({ ok: true, value: payload }),
-            maxAttempts: llmRunner.connection.supportsJsonSchema === true ? 1 : 2,
+            // One attempt when structured output is expected to work (not explicitly
+            // disabled, and this connection hasn't already proven otherwise this
+            // process — see `isJsonSchemaKnownUnsupported`); two when it's known
+            // unsupported and extraction is relying on looser prompt-contract JSON.
+            maxAttempts: llmRunner.connection.supportsJsonSchema !== false && !isJsonSchemaKnownUnsupported(llmRunner.connection)
+                ? 1
+                : 2,
             buildFeedback: () => "Your previous response did not contain a valid extraction payload. Respond with ONLY a JSON object matching the requested schema, with a candidates array and no prose or code fences.",
         });
         if (result.ok)

package/dist/commands/improve/improve.js

@@ -35,7 +35,7 @@ import { akmDistill } from "./distill.js";
 import { buildLatestProposalTsMap, collectEligibleRefs, collectEligibleRefsReadOnly, memoryCleanupParentRef, resolveImproveScope, shouldAnalyzeMemoryCleanup, } from "./eligibility.js";
 import { countEvalCases } from "./eval-cases.js";
 import { resolveImprovePlan, resolveImproveStrategy } from "./improve-strategies.js";
-import { improveLockPath, MIN_IMPROVE_LOCK_STALE_MS, releaseImproveLock, tryAcquireImproveLock } from "./locks.js";
+import { improveLockPath, releaseImproveLock, tryAcquireImproveLock } from "./locks.js";
 // The cycle loop / post-loop / maintenance stages live in ./loop-stages.
 import { runImproveLoopStage, runImprovePostLoopStage } from "./loop-stages.js";
 import { analyzeMemoryCleanup } from "./memory/memory-improve.js";
@@ -115,7 +115,7 @@ function createRunWriteJournal() {
 export async function akmImprove(options = {}) {
     const setup = resolveImproveRunSetup(options);
     options = setup.options;
-    const { budgetMs, budgetAbortController, scope, selectedStrategy, syncRepoDir, resolvedStateDbPath, resolvedLockPath, lockStaleAfterMs, } = setup;
+    const { budgetMs, budgetAbortController, scope, selectedStrategy, syncRepoDir, resolvedStateDbPath, resolvedLockPath, } = setup;
     let clearBudgetTimer = () => { };
     let initialGitPaths = new Set();
     const runJournal = createRunWriteJournal();
@@ -164,7 +164,7 @@ export async function akmImprove(options = {}) {
     }
     try {
         if (!options.dryRun) {
-            const acquisition = tryAcquireImproveLock(resolvedLockPath, lockStaleAfterMs, options.skipIfLocked, {
+            const acquisition = tryAcquireImproveLock(resolvedLockPath, options.skipIfLocked, {
                 // R25: C2 boundary-pinned path — the long-lived handle doesn't exist yet.
                 dbPath: resolvedStateDbPath,
             });
@@ -484,7 +484,6 @@ function resolveImproveRunSetup(options) {
     // triage, indexing, proposal work, maintenance, and final stash sync.
     const lockBaseDir = primaryStashDir ? path.join(primaryStashDir, ".akm") : path.join(options.stashDir ?? ".", ".akm");
     const resolvedLockPath = improveLockPath(lockBaseDir);
-    const lockStaleAfterMs = Math.max(MIN_IMPROVE_LOCK_STALE_MS, budgetMs + 10 * 60 * 1000);
     const effectiveSync = { ...improveProfile.sync, ...options.sync };
     return {
         startMs,
@@ -514,7 +513,6 @@ function resolveImproveRunSetup(options) {
         syncRepoDir,
         resolvedStateDbPath,
         resolvedLockPath,
-        lockStaleAfterMs,
         effectiveSync,
     };
 }

package/dist/commands/improve/locks.js

@@ -9,13 +9,12 @@ import { createLockPayload, probeLock, reclaimStaleLock, releaseLock, tryAcquire
 import { tryWithMaintenanceStartBarrier, withMaintenanceStartBarrier } from "../../core/maintenance-barrier.js";
 import { describeInaccessiblePath } from "../../core/path-access.js";
 import { warn } from "../../core/warn.js";
-export const MIN_IMPROVE_LOCK_STALE_MS = 4 * 60 * 60 * 1000;
 export function improveLockPath(lockBaseDir) {
     return path.join(lockBaseDir, "improve.lock");
 }
-export function tryAcquireImproveLock(lockPath, staleAfterMs, skipIfLocked, eventsCtx) {
+export function tryAcquireImproveLock(lockPath, skipIfLocked, eventsCtx) {
     let recoveryEvent;
-    const acquire = () => tryAcquireImproveLockUnlocked(lockPath, staleAfterMs, skipIfLocked, (event) => {
+    const acquire = () => tryAcquireImproveLockUnlocked(lockPath, skipIfLocked, (event) => {
         recoveryEvent = event;
     });
     const result = skipIfLocked ? tryWithMaintenanceStartBarrier(acquire) : withMaintenanceStartBarrier(acquire);
@@ -37,14 +36,23 @@ export function tryAcquireImproveLock(lockPath, staleAfterMs, skipIfLocked, even
     }
     return result;
 }
-function tryAcquireImproveLockUnlocked(lockPath, staleAfterMs, skipIfLocked, onRecovered) {
+function tryAcquireImproveLockUnlocked(lockPath, skipIfLocked, onRecovered) {
     fs.mkdirSync(path.dirname(lockPath), { recursive: true });
     const lockPayload = () => createLockPayload({ startedAt: new Date().toISOString() });
     let ownership = tryAcquireLockSync(lockPath, lockPayload());
     if (ownership) {
         return { state: "acquired", ownership };
     }
-    const probe = probeLock(lockPath, { staleAfterMs });
+    // No `staleAfterMs`: only a verifiably dead holder is ever reclaimed. A
+    // wedged-but-alive `akm improve` (SQLite WAL + busy_timeout + BEGIN
+    // IMMEDIATE already serialize concurrent writes to state.db at the
+    // correctness layer, so this lock only avoids duplicate LOGICAL work) must
+    // not have its lease silently taken away purely because a clock elapsed —
+    // that was the #872-shaped hazard here: a live holder passed the
+    // PID-liveness check forever, so only a multi-hour age window could ever
+    // free it, stranding every `akm improve --skip-if-locked` invocation for
+    // up to that long while reporting success.
+    const probe = probeLock(lockPath);
     // Race: the holder released the lock between our failed `tryAcquireLockSync`
     // and this probe, so the probe sees no file (`absent`). Retry acquisition once
     // rather than falling through to the contended skip/throw below — otherwise we

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

@@ -13,7 +13,6 @@ import { getDbPath } from "../../core/paths.js";
 import { withStateDb } from "../../core/state-db.js";
 import { info } from "../../core/warn.js";
 import { DEFAULT_GRAPH_EXTRACTION_INCLUDE_TYPES, runGraphExtractionPass, } from "../../indexer/graph/graph-extraction.js";
-import { withIndexWriterLease } from "../../indexer/index-writer-lock.js";
 import { deriveWritableBundleIds } from "../../indexer/installations.js";
 import { collectPendingMemories, runMemoryInferencePass, } from "../../indexer/passes/memory-inference.js";
 import { resolveSourceEntries } from "../../indexer/search/search-source.js";
@@ -679,13 +678,13 @@ export async function runImproveMaintenancePasses(args) {
         graphExtractionFn,
         reindexWithIndexDbReleased,
     };
-    const collected = await withIndexWriterLease({ purpose: "improve-maintenance", signal: budgetSignal }, () => runMaintenancePassesUnderLease(ctx, dbCell, {
+    const collected = await runMaintenancePassesUnderLease(ctx, dbCell, {
         actionableRefs: args.actionableRefs,
         memoryRefsForInference,
         consolidationRan: args.consolidationRan,
         allWarnings,
         openIndexDb,
-    }));
+    });
     return {
         ...(collected.memoryInference ? { memoryInference: collected.memoryInference } : {}),
         ...(collected.graphExtraction ? { graphExtraction: collected.graphExtraction } : {}),
@@ -697,12 +696,12 @@ export async function runImproveMaintenancePasses(args) {
     };
 }
 /**
- * The maintenance sequence run under the index-writer lease (formerly the
- * ~389-line anonymous `withIndexWriterLease` callback): memory inference →
- * reindex-after-inference → graph extraction → proposal hygiene (orphan purge,
- * expiration) → retention purges. Each pass returns its results and warnings;
- * this orchestrator folds warnings into the caller's `allWarnings` sink at the
- * same points the inline code pushed them.
+ * The maintenance sequence (formerly the ~389-line anonymous
+ * `withIndexWriterLease` callback, before #872 removed the index-rebuild
+ * lease): memory inference → reindex-after-inference → graph extraction →
+ * proposal hygiene (orphan purge, expiration) → retention purges. Each pass
+ * returns its results and warnings; this orchestrator folds warnings into the
+ * caller's `allWarnings` sink at the same points the inline code pushed them.
  */
 async function runMaintenancePassesUnderLease(ctx, dbCell, args) {
     const { allWarnings } = args;

package/dist/commands/improve/memory/memory-contradiction-detect.js

@@ -14,7 +14,7 @@
  * # Algorithm
  *
  *   1. Collect all derived memories grouped by `parentRef` family.
- *   2. For each family, enumerate candidate pairs (limited to MAX_FAMILY_SIZE).
+ *   2. For each family, enumerate candidate pairs.
  *   3. For each pair, call the LLM to judge whether the two memories are in
  *      direct factual conflict.
  *   4. For confirmed contradictions, write `contradictedBy` edges directly to
@@ -43,16 +43,6 @@ import { callStructured, preflightStructuredLlmRunner } from "../../../llm/struc
 import { resolveImproveLlmExecution } from "../execution.js";
 import { isDerivedMemory, memoryIdentityRef, resolveParentRef } from "./derived-ref.js";
 // ── Constants ────────────────────────────────────────────────────────────────
-/**
- * Maximum family size for pairwise contradiction checking. Families larger
- * than this are skipped to bound the LLM call count (O(n²) pairs).
- */
-const MAX_FAMILY_SIZE = 8;
-/**
- * Maximum number of contradiction pairs to check per improve run, across all
- * families. Prevents runaway LLM usage on stashes with many memories.
- */
-const MAX_PAIRS_PER_RUN = 20;
 /**
  * Minimum confidence required to write a contradiction edge. Below this
  * threshold the LLM may be flagging topic-overlap rather than genuine logical
@@ -218,15 +208,9 @@ export async function detectAndWriteContradictions(stashDir, config, chat, strat
     for (const [, family] of byParent) {
         if (family.length < 2)
             continue;
-        if (family.length > MAX_FAMILY_SIZE) {
-            result.warnings.push(`Skipping contradiction check for family of ${family.length} members (exceeds MAX_FAMILY_SIZE=${MAX_FAMILY_SIZE})`);
-            continue;
-        }
         result.familiesExamined++;
         for (let i = 0; i < family.length - 1; i++) {
             for (let j = i + 1; j < family.length; j++) {
-                if (candidatePairs.length >= MAX_PAIRS_PER_RUN)
-                    break;
                 const a = family[i];
                 const b = family[j];
                 if (!a || !b)
@@ -245,8 +229,6 @@ export async function detectAndWriteContradictions(stashDir, config, chat, strat
                     continue;
                 candidatePairs.push({ a, b, loser, winnerRef });
             }
-            if (candidatePairs.length >= MAX_PAIRS_PER_RUN)
-                break;
         }
     }
     if (candidatePairs.length === 0) {

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

@@ -9,12 +9,6 @@ import { getAllAssetOutcomes, getAssetOutcome, getOutcomeScoresByRef, upsertAsse
  * At α = 0.3 the window is ≈ 3 cycles.
  */
 export const OUTCOME_EMA_ALPHA = 0.3;
-/**
- * Maximum K improve cycles for the eligibility-trace window. Retrievals older
- * than K cycles contribute via the EMA decay naturally (they are already baked
- * into `expected_retrieval_rate`).
- */
-export const OUTCOME_TRACE_CYCLES = 5;
 /**
  * Warm-start cap: the maximum `outcome_score` a brand-new row can be seeded with
  * (from the utility EMA). Prevents a `[0,1]`-range utility value from generating

package/dist/commands/improve/reflect.js

@@ -44,7 +44,7 @@ import { prepareInlineExecution, prepareInlineExecutionWithRunner } from "../../
 import { buildReflectOutputRepairPrompt, buildReflectPrompt, extractDraftConfidence, parseAgentProposalPayload, } from "../../integrations/agent/prompts.js";
 import { runnerIsLlm, runnerSupportsFileWrite } from "../../integrations/agent/runner.js";
 import { collectDispatchSensitiveValues } from "../../integrations/agent/runner-dispatch.js";
-import { LlmCallError } from "../../llm/client.js";
+import { isJsonSchemaKnownUnsupported, LlmCallError } from "../../llm/client.js";
 import { callStructured } from "../../llm/structured-call.js";
 import { baseFailureFields, enoentHintMessage, isEnoentFailure } from "../agent/agent-support.js";
 import { isProposalSkipped, listProposalsReadOnly, proposalContent, } from "../proposal/repository.js";
@@ -578,8 +578,9 @@ export function sanitizeReflectPayload(payload, sourceContent, targetRef) {
 }
 /**
  * JSON Schema for structured reflect output. Passed to `chatCompletion` when
- * the connection has `supportsJsonSchema: true` so the model returns a strict
- * JSON object containing only the target-scoped fields AKM cannot derive.
+ * {@link wantsJsonSchemaOutput} selects `outputMode: "json_schema"`, so the
+ * model returns a strict JSON object containing only the target-scoped
+ * fields AKM cannot derive.
  */
 const REFLECT_FRONTMATTER_PATCH_JSON_SCHEMA = {
     type: "object",
@@ -626,6 +627,17 @@ const REFLECT_UNSCOPED_JSON_SCHEMA = {
         frontmatterPatch: REFLECT_FRONTMATTER_PATCH_JSON_SCHEMA,
     },
 };
+/**
+ * Whether to frame the reflect prompt for structured JSON output on this
+ * connection. Optimistic by default — `chatCompletion` attempts
+ * `response_format: json_schema` fresh on every call and falls back once on
+ * a 4xx, so there is no persisted verdict to consult here. `false` only when
+ * a human/workflow explicitly disabled it, or a real call already proved
+ * this connection rejects it earlier in the same process.
+ */
+function wantsJsonSchemaOutput(connection) {
+    return connection.supportsJsonSchema !== false && !isJsonSchemaKnownUnsupported(connection);
+}
 /** Critique prompt injected between prior draft and refinement request (Self-Refine loop). */
 const REFLECT_CRITIQUE_PROMPT = "Your previous proposal is shown above. Review it critically and provide an improved version that is more specific, actionable, and avoids any issues with the previous attempt. Return only the improved response using the output contract from the original prompt.";
 /**
@@ -1354,21 +1366,20 @@ async function resolveReflectSource(options, stash, emitReflectFailed) {
 }
 /**
  * Run the agent with the optional Self-Refine loop (R-1 / #372): up to
- * MAX_REFINE_ITERS invocations, each injecting the prior draft as self-critique
+ * `maxRefineIters` invocations, each injecting the prior draft as self-critique
  * context and exiting early on a no-op refinement. Synthesizes per-iteration
  * draft paths into `draftPathsToCleanup` (mutated) and returns the final agent
  * result + last draft path. Extracted verbatim from `akmReflect`.
  */
 async function runReflectRefineIterations(args) {
     const { options, parsedRef, assetContent, feedback, schemaHints, relatedLessons, rejectedProposals, standardsContext, runnerSpec, lease, agentEnv, draftPathsToCleanup, onNotices, } = args;
-    const MAX_REFINE_ITERS = 3;
-    const maxRefineIters = Math.min(Math.max(1, options.maxRefineIters ?? 1), MAX_REFINE_ITERS);
+    const maxRefineIters = Math.max(1, options.maxRefineIters ?? 1);
     // Determine whether this dispatch can honour the file-write contract.
     // Agent CLI + OpenCode SDK runners both have filesystem access; the direct
     // LLM HTTP runner does NOT.
     const canRunnerWriteFile = runnerSupportsFileWrite(runnerSpec);
     const outputMode = runnerIsLlm(runnerSpec)
-        ? runnerSpec.connection.supportsJsonSchema
+        ? wantsJsonSchemaOutput(runnerSpec.connection)
             ? "json_schema"
             : "framed_markdown"
         : undefined;
@@ -1421,10 +1432,10 @@ async function runReflectRefineIterations(args) {
                 ...(options.signal ? { signal: options.signal } : {}),
                 priorDraft,
                 iteration: iter,
-                ...(runnerSpec.connection.supportsJsonSchema
+                ...(outputMode === "json_schema"
                     ? { responseSchema: options.ref ? REFLECT_JSON_SCHEMA : REFLECT_UNSCOPED_JSON_SCHEMA }
                     : {}),
-                outputMode: runnerSpec.connection.supportsJsonSchema ? "json_schema" : "framed_markdown",
+                outputMode: outputMode ?? "framed_markdown",
                 ...(options.ref ? { targetRef: options.ref } : {}),
                 allowRepair: repairAttempts === 0,
                 ...(options.chat ? { chat: options.chat } : {}),

package/dist/commands/lint/index.js

@@ -92,7 +92,7 @@ function collectWorkflowFiles(dir) {
             continue;
         const full = path.join(dir, entry.name);
         if (entry.isDirectory()) {
-            if (entry.name === ".cache" || entry.name === "registry")
+            if (isAkmRegistryCachePath(full))
                 continue;
             results.push(...collectWorkflowFiles(full));
             continue;
@@ -185,11 +185,9 @@ function collectAdapterFiles(root, extensions) {
                 walk(full);
             }
             else if (entry.isFile() && matchesAdapterExtension(entry.name, extensions)) {
-                // Compare PATH SEGMENTS, not raw substrings: `path.join` yields `\` on
-                // Windows so a `"/.cache/"` substring test never matches there, and a
-                // substring test would also skip a legitimately-named `registry` file.
-                const segments = path.relative(root, full).split(/[\\/]/);
-                if (segments.includes(".cache") || segments.includes("registry"))
+                // Skip akm's OWN resolved registry-cache copies, not any user
+                // directory that happens to be named ".cache" or "registry".
+                if (isAkmRegistryCachePath(full))
                     continue;
                 results.push(full);
             }

package/dist/commands/proposal/validators/proposal-quality-validators.js

@@ -196,13 +196,6 @@ export function hasHotCaptureMode(frontmatter) {
  * with 80-90% overlap legitimately compress to well under 50% of the larger.
  */
 export const MERGE_SHRINK_RATIO_MIN = 0.3;
-/**
- * Absolute floor (chars) for merged body.  When sources are short (<~333 chars),
- * `MERGE_SHRINK_RATIO_MIN × largerBodyLen` falls below this and the absolute
- * floor dominates — prevents false positives on very terse memory pairs.
- * Matches the existing `promote_source_too_small` floor of 100 chars.
- */
-export const MERGE_ABSOLUTE_FLOOR_CHARS = 100;
 // ── Reflect size gate ────────────────────────────────────────────────────────
 /** Ratio lower-bound: proposed body must be at least this fraction of source. */
 export const REFLECT_SHRINK_RATIO_MIN = 0.5;

package/dist/commands/proposal/validators/proposal-validators.js

@@ -67,6 +67,18 @@ const canonicalProposalValidators = {
         const content = proposalContent(proposal);
         if (!content.trim())
             return [];
+        // #859: proposedTarget is absent on legacy archived rows, but this
+        // validator only ever runs on a proposal about to be minted or promoted
+        // (both always carry proposedTarget — see the Proposal.proposedTarget
+        // doc comment) — so hitting this is a genuine defect, not a legacy gap.
+        if (!proposal.proposedTarget) {
+            return [
+                {
+                    kind: "invalid-workflow-structure",
+                    message: `Workflow proposal ${proposal.id} (${proposal.ref}) is missing proposedTarget and cannot be validated.`,
+                },
+            ];
+        }
         const sourcePath = proposal.changes[0]?.path || proposal.ref;
         const result = compileWorkflowSource(content, {
             path: sourcePath,

package/dist/commands/read/search.js

@@ -14,13 +14,10 @@
 import { getSources, loadConfig } from "../../core/config/config.js";
 import { rethrowIfTestIsolationError, UsageError } from "../../core/errors.js";
 import { appendEvent } from "../../core/events.js";
-import { isTransientStashPath } from "../../core/paths.js";
 import { resolveReadSources } from "../../indexer/read-preflight.js";
 import { searchLocal } from "../../indexer/search/db-search.js";
 import { getSearchHitAttribution, usageEventAttributionMetadata, } from "../../indexer/search/search-attribution.js";
 import { getEntryIdByFilePath, getItemRefById } from "../../storage/repositories/index-entries-repository.js";
-import { bumpUtilityScoresBatch } from "../../storage/repositories/index-utility-repository.js";
-import { getCurrentWorkflowScopeKey } from "../../workflows/authoring/scope-key.js";
 // Eagerly import source providers to trigger self-registration before the
 // indexer or path-resolution code runs.
 import "../../sources/providers/index.js";
@@ -188,7 +185,7 @@ function usageSearchMode(mode) {
 function maybeLogSearchEvent(input, query, response, mode) {
     if (input.skipLogging)
         return;
-    logSearchEvent(query, response, mode, input.eventSource, input.disableScopedUtility === true, input.attributionProjection);
+    logSearchEvent(query, response, mode, input.eventSource, input.attributionProjection);
 }
 /**
  * Resolve entry IDs by file_path lookup (exact match, not LIKE).
@@ -229,7 +226,7 @@ function resolveEntryIds(db, hits) {
  * Per-entry events are recorded only for stash hits because registry hits
  * have no local entry_id to reference.
  */
-function logSearchEvent(query, response, mode = "keyword", eventSource = "user", disableScopedUtility = false, attributionProjection = "full") {
+function logSearchEvent(query, response, mode = "keyword", eventSource = "user", attributionProjection = "full") {
     // Emit a structured event to events.jsonl so workflow-trace consumers
     // detect akm search invocations without relying on stdout scraping.
     const stashHits = response.hits.filter((h) => h.type !== "registry");
@@ -276,25 +273,18 @@ function logSearchEvent(query, response, mode = "keyword", eventSource = "user",
                     source: eventSource,
                 });
             }, TELEMETRY_BUSY_TIMEOUT_MS);
-            // Bump utility scores for all resolved entries (MemRL retrieval signal).
-            // The indexer overwrites these at next reindex; bumps are temporary hints.
-            // Gated to user-sourced events: pipeline searches (improve probes, task
-            // runner) must not feed the utility signal (meta-review 05 DRIFT-6 —
-            // the bump previously fired unconditionally, so even correctly-tagged
-            // machine traffic inflated utility). utility_scores stays in index.db.
-            const resolvedIds = eventSource === "user" ? resolved.map((r) => r.entryId).filter((id) => id !== undefined) : [];
-            if (resolvedIds.length > 0) {
-                let scopeKey;
-                try {
-                    const stashPath = response.bundleDir;
-                    const disabled = disableScopedUtility || (stashPath && isTransientStashPath(stashPath));
-                    scopeKey = disabled ? undefined : getCurrentWorkflowScopeKey();
-                }
-                catch {
-                    // Non-fatal — fall back to global-only bumps on any error.
-                }
-                bumpUtilityScoresBatch(db, resolvedIds, 1.0, 0.1, scopeKey);
-            }
+            // No live utility_scores/utility_scores_scoped write here (#862): a
+            // search result is an impression, not a signal that the asset was
+            // useful. Rewarding every returned hit created a feedback loop where
+            // merely appearing in results inflated future ranking — assets
+            // surfaced because they'd surfaced before, not because a user acted
+            // on them. Retrieval counts are still recorded above via
+            // insertUsageEvent (search_count) and rolled into utility_scores by
+            // the offline `recomputeUtilityScores` pass (`akm index`), which uses
+            // the show/search *select rate* — a ratio that requires an actual
+            // `show`/select event, not raw impressions. Explicit signal comes
+            // from `akm feedback` (applyFeedbackToUtilityScore) and from
+            // selection (recordShowUsage / the `select` event derived from it).
         }, { busyTimeoutMs: TELEMETRY_BUSY_TIMEOUT_MS });
     }
     catch (err) {

package/dist/commands/sources/bundle-config-ops.js

@@ -13,20 +13,25 @@
  * keying rules across call sites.
  */
 import path from "node:path";
-import { primaryBundlePath } from "../../core/config/config.js";
+import { bundleKeyForContentRoot, primaryBundlePath } from "../../core/config/config.js";
 import { deriveBundleId } from "../../indexer/installations.js";
 export { primaryBundlePath };
 /**
  * Upsert the primary filesystem bundle (`{ path, writable: true }`) and point
  * `defaultBundle` at it. Reuses the current default key when it already names a
- * filesystem bundle (so re-pointing the primary keeps a stable id); otherwise
- * derives a fresh slug-legal key from the path.
+ * filesystem bundle (so re-pointing the primary keeps a stable id). Otherwise,
+ * reuses whichever configured bundle ALREADY resolves to `stashDir`'s content
+ * root (issue #870 — `AKM_BUNDLE_DIR`/`--dir` pointed at a directory already
+ * configured under a different id must not mint a second bundle for it); only
+ * when no bundle owns that root yet is a fresh slug-legal key derived.
  */
 export function withPrimaryBundle(config, stashDir) {
     const bundles = { ...(config.bundles ?? {}) };
     let key = config.defaultBundle;
     if (!key || !(key in bundles) || typeof bundles[key]?.path !== "string") {
-        key = deriveBundleId(undefined, stashDir, new Set(Object.keys(bundles)));
+        key =
+            bundleKeyForContentRoot(config, path.resolve(stashDir)) ??
+                deriveBundleId(undefined, stashDir, new Set(Object.keys(bundles)));
     }
     bundles[key] = {
         ...bundles[key],

package/dist/commands/sources/info.js

@@ -8,7 +8,6 @@ import { classifyPathAccess, describeInaccessiblePath } from "../../core/path-ac
 import { getDbPath } from "../../core/paths.js";
 import { formatRegistryUrl } from "../../core/registry-url.js";
 import { error } from "../../core/warn.js";
-import { getEffectiveSemanticStatus, readSemanticStatus } from "../../indexer/search/semantic-status.js";
 import { closeDatabase, openExistingDatabase } from "../../storage/repositories/index-connection.js";
 import { getEntryCount, getEntryCountByType } from "../../storage/repositories/index-entries-repository.js";
 import { getMeta } from "../../storage/repositories/index-meta-repository.js";
@@ -29,13 +28,6 @@ export function assembleInfo(options) {
     const defaultBundle = config.defaultBundle ?? null;
     // Asset types (copy into a mutable array — `placementTypes()` returns readonly)
     const assetTypes = [...placementTypes()];
-    const semanticRuntime = readSemanticStatus();
-    const semanticStatus = getEffectiveSemanticStatus(config, semanticRuntime);
-    // Search modes
-    const searchModes = ["fts"];
-    if (semanticStatus === "ready-js" || semanticStatus === "ready-vec") {
-        searchModes.push("semantic", "hybrid");
-    }
     // Registries (strip sensitive fields like apiKey from options)
     const registries = (config.registries ?? []).map((r) => ({
         url: formatRegistryUrl(r.url),
@@ -58,6 +50,20 @@ export function assembleInfo(options) {
     // health and search use, so info reads the same database they do.
     const resolvedDbPath = options?.dbPath ?? getDbPath();
     const indexStats = readIndexStats(resolvedDbPath);
+    // Semantic status is read live from the index's own state, not a cached
+    // verdict — a failed embed attempt at search time falls back to FTS and
+    // reports that in the search response, it never disables the mode here.
+    const semanticStatus = config.semanticSearchMode === "off"
+        ? "disabled"
+        : !indexStats.hasEmbeddings
+            ? "pending"
+            : indexStats.vecAvailable
+                ? "ready-vec"
+                : "ready-js";
+    const searchModes = ["fts"];
+    if (semanticStatus === "ready-js" || semanticStatus === "ready-vec") {
+        searchModes.push("semantic", "hybrid");
+    }
     return {
         schemaVersion: 1,
         version: pkgVersion,
@@ -68,8 +74,6 @@ export function assembleInfo(options) {
         semanticSearch: {
             mode: config.semanticSearchMode,
             status: semanticStatus,
-            ...(semanticRuntime?.reason ? { reason: semanticRuntime.reason } : {}),
-            ...(semanticRuntime?.message ? { message: semanticRuntime.message } : {}),
         },
         registries,
         sourceProviders,

package/dist/commands/tasks/tasks-cli.js

@@ -31,7 +31,7 @@ import { defineGroupCommand, defineJsonCommand, EXIT_CODES, GLOBAL_OUTPUT_ARGS,
 import { UsageError } from "../../core/errors.js";
 import { TASK_RUN_BOOLEAN_FLAGS, TASK_RUN_VALUE_FLAGS } from "../../tasks/task-run-reserved-flags.js";
 import { akmTaskExplain } from "./explain.js";
-import { akmTasksAdd, akmTasksDoctor, akmTasksHistory, akmTasksRun, akmTasksSync, akmTasksSyncPlan } from "./tasks.js";
+import { akmTasksAdd, akmTasksDoctor, akmTasksHistory, akmTasksPrune, akmTasksRun, akmTasksSync, akmTasksSyncPlan, } from "./tasks.js";
 /** Shared `--bundle <bundle>` arg wired onto every task subcommand. */
 const bundleArg = {
     bundle: {
@@ -307,10 +307,13 @@ const tasksHistoryCommand = defineJsonCommand({
  * #849: `task sync --dry-run`'s exit-code contract, "non-zero when the plan
  * contains removals" — factored out as a pure function (rather than left
  * inline in the command's `run()`) so it's directly unit-testable without
- * driving the whole CLI through a real scheduler backend.
+ * driving the whole CLI through a real scheduler backend. #867: also
+ * non-zero when any source failed to parse/prepare — sync degrades (still
+ * reconciles the tasks/workflows that DID parse) rather than rejecting the
+ * whole set, but a dropped source must still surface as a failing exit.
  */
 export function taskSyncDryRunExitCode(preview) {
-    return preview.hasRemovals ? EXIT_CODES.GENERAL : undefined;
+    return preview.hasRemovals || (preview.failures?.length ?? 0) > 0 ? EXIT_CODES.GENERAL : undefined;
 }
 const tasksSyncCommand = defineJsonCommand({
     meta: {
@@ -345,6 +348,12 @@ const tasksSyncCommand = defineJsonCommand({
         }
         const result = await akmTasksSync({}, args.bundle, { rebind });
         output("task-sync", result);
+        // #867: sync degrades — sources that failed to parse/prepare are
+        // excluded from reconciliation and reported in `result.failed` rather
+        // than poisoning the whole sync, but their presence must still fail
+        // the command's exit code so the breakage stays visible.
+        if (result.failed.length > 0)
+            process.exitCode = EXIT_CODES.GENERAL;
     },
 });
 // ── `akm task explain` — read-only introspection (P2b Lane B, spec
@@ -389,6 +398,49 @@ const tasksDoctorCommand = defineJsonCommand({
         output("task-doctor", result);
     },
 });
+/**
+ * #851: `akm task prune`'s exit-code contract mirrors `task sync --dry-run`'s
+ * (`taskSyncDryRunExitCode` above) — non-zero whenever the preview lists
+ * removals the invocation didn't (or couldn't, without `--yes`) execute, so
+ * `akm task prune` is usable as a CI/health check the same way `sync
+ * --dry-run` is.
+ */
+export function taskPruneExitCode(result) {
+    return result.dryRun && result.preview.hasRemovals ? EXIT_CODES.GENERAL : undefined;
+}
+const tasksPruneCommand = defineJsonCommand({
+    meta: {
+        name: "prune",
+        description: "Remove installed scheduler entries `sync` can never reclaim because their own descriptor no longer " +
+            "resolves to a live bundle (corrupt/missing --scheduler-context, or the owning bundle directory is " +
+            "gone). Defaults to a dry-run preview — zero scheduler writes. Requires --yes to remove anything; " +
+            "--id narrows removal to specific binding ids (comma-separated).",
+    },
+    args: {
+        yes: {
+            type: "boolean",
+            description: "Execute removal of every currently-computed orphan (the plan is still printed first)",
+            default: false,
+        },
+        id: {
+            type: "string",
+            description: "Comma-separated scheduler binding id(s) to limit pruning to (must already be orphan candidates)",
+        },
+    },
+    async run({ args }) {
+        const id = args.id
+            ? args.id
+                .split(",")
+                .map((value) => value.trim())
+                .filter(Boolean)
+            : undefined;
+        const result = await akmTasksPrune({}, { yes: args.yes === true, id });
+        output("task-prune", result);
+        const exitCode = taskPruneExitCode(result);
+        if (exitCode !== undefined)
+            process.exitCode = exitCode;
+    },
+});
 export const taskCommand = defineGroupCommand({
     meta: {
         name: "task",
@@ -400,6 +452,7 @@ export const taskCommand = defineGroupCommand({
         explain: tasksExplainCommand,
         history: tasksHistoryCommand,
         sync: tasksSyncCommand,
+        prune: tasksPruneCommand,
         doctor: tasksDoctorCommand,
     },
     // Bare `akm task` reports scheduler diagnostics. Inspection of individual