akm-cli 0.9.31 → 0.10.261001-beta

package/dist/core/subprocess.js

@@ -116,6 +116,51 @@ export function scheduleKillLadder(proc, opts) {
     if (typeof sigkillTimer !== "number")
         sigkillTimer.unref?.();
 }
+const liveGroupChildren = new Set();
+let signalGuardHandlers;
+function removeSignalGuard() {
+    for (const [signal, handler] of signalGuardHandlers ?? [])
+        process.off(signal, handler);
+    signalGuardHandlers = undefined;
+}
+/**
+ * A captured child runs in its own process group, so the terminal's Ctrl-C and
+ * a `kill <akm-pid>` no longer reach it: without this, SIGTERM/SIGINT to akm
+ * ended akm and left the harness CLI (and everything it started) running. Each
+ * live child is registered here and, on the first such signal, takes the same
+ * ladder as a timeout; once every child is gone the signal is re-raised so akm
+ * still ends by the signal itself.
+ *
+ * The listeners are installed only while a child is live and only when nothing
+ * else handles the signal. A command that handles it itself (`workflow run`,
+ * `improve`, task runs) unwinds through its own cleanup, which already aborts
+ * its children, and must not have its handling pre-empted by a re-raise.
+ */
+function registerLiveGroupChild(child) {
+    liveGroupChildren.add(child);
+    if (!signalGuardHandlers && process.listenerCount("SIGINT") === 0 && process.listenerCount("SIGTERM") === 0) {
+        const handlers = [];
+        for (const signal of ["SIGINT", "SIGTERM"]) {
+            const handler = () => {
+                const children = [...liveGroupChildren];
+                for (const live of children)
+                    live.terminate();
+                removeSignalGuard();
+                void Promise.allSettled(children.map((live) => live.proc.exited)).then(() => {
+                    process.kill(process.pid, signal);
+                });
+            };
+            process.once(signal, handler);
+            handlers.push([signal, handler]);
+        }
+        signalGuardHandlers = handlers;
+    }
+    return () => {
+        liveGroupChildren.delete(child);
+        if (liveGroupChildren.size === 0)
+            removeSignalGuard();
+    };
+}
 /**
  * The joined, human-readable reason ONE managed run's capture is incomplete, or
  * `undefined` when both pipes drained cleanly.
@@ -401,6 +446,8 @@ export async function runManagedSubprocess(cmd, opts) {
         else
             abortSignal.addEventListener("abort", onAbort, { once: true });
     }
+    // A termination signal to this process takes the own-group child down too.
+    const unregisterLiveChild = capture && spawnsOwnProcessGroup() ? registerLiveGroupChild({ proc, terminate: onAbort }) : () => { };
     // Stream-drain timeout: a short grace once nothing living owns the pipe any
     // more, or a one-hour safety bound when execution itself is unbounded.
     //
@@ -454,6 +501,7 @@ export async function runManagedSubprocess(cmd, opts) {
         if (timer !== undefined)
             clearTimeoutImpl(timer);
         abortSignal?.removeEventListener("abort", onAbort);
+        unregisterLiveChild();
         // Drain readers so they don't surface as unhandled rejections. The streams
         // carry their own drain timeout so this cannot block indefinitely.
         await Promise.allSettled([stdoutPromise, stderrPromise]);
@@ -470,6 +518,7 @@ export async function runManagedSubprocess(cmd, opts) {
     }
     clearTimeoutImpl(timer);
     abortSignal?.removeEventListener("abort", onAbort);
+    unregisterLiveChild();
     const [stdoutRead, stderrRead] = await Promise.all([stdoutPromise, stderrPromise]);
     return {
         exitCode,

package/dist/core/warn.js

@@ -15,6 +15,8 @@
 import fs from "node:fs";
 import path from "node:path";
 let quiet = false;
+/** Calls inside {@link withQuiet}; counted so overlapping calls cannot leave the flag flipped. */
+let quietScopes = 0;
 let verbose = false;
 let logFilePath;
 let sinkOverride;
@@ -33,7 +35,22 @@ export function resetQuiet() {
     quiet = false;
 }
 export function isQuiet() {
-    return quiet;
+    return quiet || quietScopes > 0;
+}
+/**
+ * Run `fn` with stderr diagnostics suppressed (the log file sink still
+ * receives them), then restore. For in-process callers (`src/api.ts`) that
+ * must stay silent without touching the host's `--quiet` state: a depth count
+ * rather than save/restore of the flag keeps overlapping async calls correct.
+ */
+export async function withQuiet(fn) {
+    quietScopes++;
+    try {
+        return await fn();
+    }
+    finally {
+        quietScopes--;
+    }
 }
 /**
  * Set the verbose flag from a CLI flag. The `AKM_VERBOSE` env var, when set,
@@ -103,7 +120,7 @@ export function info(...args) {
         return;
     }
     appendToLogFile("INFO", args);
-    if (!quiet) {
+    if (!isQuiet()) {
         console.warn(...args);
     }
 }
@@ -118,7 +135,7 @@ export function warn(...args) {
         return;
     }
     appendToLogFile("WARN", args);
-    if (!quiet) {
+    if (!isQuiet()) {
         console.warn(...args);
     }
 }
@@ -148,7 +165,7 @@ export function error(...args) {
         return;
     }
     appendToLogFile("ERROR", args);
-    if (!quiet) {
+    if (!isQuiet()) {
         console.error(...args);
     }
 }

package/dist/core/write-source.js

@@ -7,7 +7,7 @@
  * The only module that branches on `source.kind` for writes. It does two
  * things:
  *
- *  1. Resolve the destination: `--target` → `defaultWriteTarget` → working
+ *  1. Resolve the destination: `--bundle` → `defaultWriteTarget` → working
  *     stash (`defaultBundle`). `writable` defaults to true on `filesystem` and
  *     false on `git`; `website` / `npm` are never writable (the config loader
  *     rejects `writable: true` on them).
@@ -53,7 +53,7 @@ export function isWriteCapableSourceKind(kind) {
     return kind === "filesystem" || kind === "git";
 }
 /**
- * Resolve the destination for a write: explicit `--target`, then
+ * Resolve the destination for a write: explicit `--bundle`, then
  * `defaultWriteTarget`, then the working stash (`defaultBundle`). There is no
  * fallback to the first writable source.
  */
@@ -61,7 +61,7 @@ export function resolveWriteTarget(akmConfig, explicitTarget, options = {}) {
     const allConfiguredSources = resolveConfiguredSources(akmConfig);
     const configuredSources = resolveActiveConfiguredSources(akmConfig);
     const requireWritable = options.requireWritable !== false;
-    const flag = options.flag ?? "--target";
+    const flag = options.flag ?? "--bundle";
     if (explicitTarget) {
         const match = configuredSources.find((s) => s.name === explicitTarget);
         if (!match) {

package/dist/execution/target-ref.js

@@ -22,8 +22,7 @@
  *
  * Explicit non-goals (binding, spec §4.1): no GitHub locator grammar, no
  * `akm/command` builtin special case, no resolution, no filesystem access, no
- * guessing. Callers layer builtin detection on top (see
- * `classifyWorkflowStepUses` in src/workflows/source-semantics.ts).
+ * guessing.
  */
 import { bundleRefToString, parseBundleRef } from "../core/asset/asset-ref.js";
 import { UsageError } from "../core/errors.js";

package/dist/indexer/indexer.js

@@ -1291,7 +1291,10 @@ export async function lookup(ref) {
 }
 // ── Utility score recomputation ──────────────────────────────────────────────
 /**
- * Recompute utility scores for all entries based on usage_events data.
+ * Recompute utility scores based on usage_events data: every entry by default,
+ * or just `onlyEntryId` (what `akm feedback` passes so the value it stores is
+ * the one `akm index` would compute, not a second formula). A one-entry call
+ * leaves the retention purge and the `last_utility_computed_at` watermark alone.
  *
  * For each entry:
  *   - Count search appearances (event_type = 'search')
@@ -1306,11 +1309,13 @@ export async function lookup(ref) {
  *
  * Called during `akm index` after FTS rebuild.
  */
-export function recomputeUtilityScores(db, stateDb) {
+export function recomputeUtilityScores(db, stateDb, onlyEntryId) {
     const EMA_DECAY = 0.7;
+    const scoped = onlyEntryId !== undefined;
     // Purge stale usage events (90-day retention). usage_events lives in state.db
     // (Chunk-8 WI-8.3); its table is created by state migration 020.
-    purgeOldUsageEvents(stateDb, USAGE_EVENT_RETENTION_DAYS);
+    if (!scoped)
+        purgeOldUsageEvents(stateDb, USAGE_EVENT_RETENTION_DAYS);
     // Time-proportional decay: apply one round of EMA per elapsed day so
     // indexing frequency doesn't affect how fast scores decay.
     const lastComputedAt = getMeta(db, "last_utility_computed_at");
@@ -1344,14 +1349,17 @@ export function recomputeUtilityScores(db, stateDb) {
       FROM usage_events u
       WHERE u.entry_id IS NOT NULL
         AND u.source = 'user'
+        ${scoped ? "AND u.entry_id = ?" : ""}
       GROUP BY u.entry_id
     `)
-        .all();
+        .all(...(scoped ? [onlyEntryId] : []));
     const entryExists = db.prepare("SELECT 1 FROM entries WHERE id = ?");
     const usageByEntry = new Map(aggregatedRows.filter((row) => entryExists.get(row.entry_id) != null).map((row) => [row.entry_id, row]));
     // Batch-load existing utility scores
     const existingScores = new Map();
-    const scoreRows = db.prepare("SELECT entry_id, utility, last_used_at FROM utility_scores").all();
+    const scoreRows = db
+        .prepare(`SELECT entry_id, utility, last_used_at FROM utility_scores${scoped ? " WHERE entry_id = ?" : ""}`)
+        .all(...(scoped ? [onlyEntryId] : []));
     for (const row of scoreRows) {
         existingScores.set(row.entry_id, { utility: row.utility, lastUsedAt: row.last_used_at ?? undefined });
     }
@@ -1391,5 +1399,6 @@ export function recomputeUtilityScores(db, stateDb) {
             lastUsedAt,
         });
     }
-    setMeta(db, "last_utility_computed_at", new Date().toISOString());
+    if (!scoped)
+        setMeta(db, "last_utility_computed_at", new Date().toISOString());
 }

package/dist/indexer/passes/memory-inference.js

@@ -247,12 +247,19 @@ async function runMemoryInferencePassBody(ctx, provenance) {
     const featureConfig = invocationOwnsRunner
         ? { ...config, index: { ...config.index, memory: { ...config.index?.memory, enabled: true } } }
         : config;
-    // The pass only writes to the primary (working) stash. Read-only caches
-    // (git, npm, website) are deliberately untouched — writing inferred
-    // children there would be clobbered by the next sync().
-    const primary = sources[0];
-    if (!primary || (primary.adapterId ?? detectAdapterId(primary.path)) !== "akm")
+    // The pass only writes to the default (working) stash, found by its
+    // `isDefault` flag and never by array position. Read-only caches (git, npm,
+    // website) are deliberately untouched — writing inferred children there
+    // would be clobbered by the next sync().
+    const primary = sources.find((source) => source.isDefault === true);
+    if (!primary) {
+        warn("memory inference: skipped — no default bundle among the sources, so there is no write target");
         return completeResult();
+    }
+    if ((primary.adapterId ?? detectAdapterId(primary.path)) !== "akm") {
+        warn(`memory inference: skipped — the default bundle at ${primary.path} is not an akm bundle`);
+        return completeResult();
+    }
     const pending = collectPendingMemories(primary.path).filter((record) => !options.candidateRefs || options.candidateRefs.has(record.ref));
     result.considered = pending.length;
     if (pending.length === 0)
@@ -511,7 +518,9 @@ function markParentProcessed(parent) {
         warn(`memory inference: skipping markParentProcessed for ${parent.filePath} — could not parse frontmatter block`);
         return;
     }
-    const updatedFm = { ...parent.data, [FM_INFERENCE_PROCESSED]: true };
+    // Stamp the frontmatter as it is now: `parent.data` was parsed before the model
+    // call, and writing it back would revert any edit made to the file since.
+    const updatedFm = { ...parseFrontmatter(raw).data, [FM_INFERENCE_PROCESSED]: true };
     const next = assembleAsset(updatedFm, block.content);
     try {
         fs.writeFileSync(parent.filePath, next, "utf8");

package/dist/indexer/search/db-search.js

@@ -6,15 +6,16 @@
  *
  * Ranking is two candidate channels fused by reciprocal rank (`ranking.ts`):
  * BM25 over whole documents matching any query word, and the nearest document
- * vectors to the query embedding. Filters narrow the fused list; nothing else
+ * vectors to the query embedding. The fused score is then scaled by the
+ * asset's recorded user feedback. Filters narrow the list; nothing else
  * reorders it.
  */
 import path from "node:path";
-import { stashDirFor } from "../../core/asset/asset-placement.js";
 import { displayRef } from "../../core/asset/resolve-ref.js";
 import { compareCodePoints } from "../../core/common.js";
 import { classifyPathAccess } from "../../core/path-access.js";
 import { getDbPath } from "../../core/paths.js";
+import { withStateDbTelemetry } from "../../core/state-db.js";
 import { systemErrorCode } from "../../core/system-error.js";
 import { presentationFor } from "../../core/type-presentation.js";
 import { embed } from "../../llm/embedder.js";
@@ -27,8 +28,9 @@ import { getMeta } from "../../storage/repositories/index-meta-repository.js";
 import { getEmbeddingCount, searchVec } from "../../storage/repositories/index-vec-repository.js";
 import { ensureIndex } from "../ensure-index.js";
 import { isProposedQuality } from "../passes/metadata.js";
-import { ftsQueryTokens, parseRefPrefixQuery, parseRetiredTypePrefixQuery } from "./fts-query.js";
-import { reciprocalRankFusion } from "./ranking.js";
+import { countFeedbackSignalsByRef } from "../usage/usage-events.js";
+import { ftsQueryTokens, parseRefPrefixQuery } from "./fts-query.js";
+import { applyFeedback, reciprocalRankFusion, } from "./ranking.js";
 import { attachSearchHitAttribution } from "./search-attribution.js";
 import { enrichSearchHit } from "./search-hit-enrichers.js";
 import { buildEditHint, findSourceForPath, isEditable } from "./search-source.js";
@@ -81,30 +83,31 @@ function resolveSearchHitRef(entry, provenance, defaultBundleId) {
 }
 // ── Main search entrypoint ───────────────────────────────────────────────────
 /**
- * Whether an embedding provider is actually configured.
+ * Whether `auto` has a usable embedding provider.
  *
- * A remote provider needs BOTH endpoint and model. A LOCAL provider needs
- * neither — `embedding.localModel` selects a transformers model that runs in
- * process. Checking only the remote pair told every local-provider user that
- * "no embedding provider is configured" and pointed them at
- * `akm config set embedding '{"endpoint":...}'`, which is the wrong remedy and
- * hid the real diagnostic recorded in the semantic status.
+ * `auto` with no (or no remote) embedding settings falls back to the built-in
+ * local model (`DEFAULT_LOCAL_MODEL`, or `embedding.localModel`), so semantic
+ * search works without any configuration. The only config that can never
+ * succeed is a remote `endpoint` without a `model` — `RemoteEmbedder` throws on
+ * construction. Treating "no endpoint+model pair" as unconfigured warned every
+ * default install that semantic search had no provider while it worked.
  */
 function hasConfiguredEmbeddingProvider(config) {
-    if (config.embedding?.localModel)
+    const embedding = config.embedding;
+    if (!embedding?.endpoint)
         return true;
-    return Boolean(config.embedding?.endpoint && config.embedding?.model);
+    return Boolean(embedding.model);
 }
 export async function searchLocal(input) {
-    const { query, stashDir, config } = input;
+    const { stashDir, config } = input;
     const warnings = [];
     // Semantic search is attempted fresh on every query (see `startVectorChannel`);
     // there is no cached readiness verdict to consult here. The only thing
     // worth flagging ahead of the attempt is a config that can never succeed.
     if (config.semanticSearchMode === "auto" && !hasConfiguredEmbeddingProvider(config)) {
-        warnings.push("Semantic search is enabled (semanticSearchMode='auto') but no embedding provider is configured. " +
-            'Either: (a) `akm config set embedding \'{"endpoint":"...","model":"..."}\'`, or ' +
-            "(b) `akm config set semanticSearchMode off` to use keyword-only search.");
+        warnings.push("Semantic search is enabled (semanticSearchMode='auto') but embedding.endpoint is set without embedding.model. " +
+            "Either: (a) set embedding.model, or (b) remove embedding.endpoint to use the built-in local model, or " +
+            "(c) `akm config set semanticSearchMode off` to use keyword-only search.");
     }
     // Bootstrap-only: builds the index inline when it cannot serve this stash.
     // Content freshness is the writers' job (indexWrittenAssets + full runs);
@@ -138,12 +141,14 @@ export async function searchLocal(input) {
         const staleHint = buildStaleIndexHint(db);
         if (staleHint)
             warnings.push(staleHint);
-        const { hits, embedMs, rankMs, mode, semanticWarning } = await searchDatabase(db, input);
+        const { hits, embedMs, rankMs, mode, semanticWarning, feedbackWarning } = await searchDatabase(db, input);
         if (semanticWarning)
             warnings.push(semanticWarning);
+        if (feedbackWarning)
+            warnings.push(feedbackWarning);
         return {
             hits,
-            tip: hits.length === 0 ? emptyResultTip(query) : undefined,
+            tip: hits.length === 0 ? EMPTY_RESULT_TIP : undefined,
             warnings: warnings.length > 0 ? warnings : undefined,
             embedMs,
             rankMs,
@@ -218,7 +223,9 @@ async function searchDatabase(db, input) {
     const embedMs = Date.now() - startedAt;
     const tRank0 = Date.now();
     const vectorCandidates = vector.neighbors ? keepAllowedTypes(db, vector.neighbors, typeFilter, defaultExcludes) : [];
-    const fused = reciprocalRankFusion([lexical, vectorCandidates]);
+    const rrf = reciprocalRankFusion([lexical, vectorCandidates]);
+    const feedback = readFeedback(rrf);
+    const fused = applyFeedback(rrf, feedback.counts);
     const selected = selectFusedEntries(db, fused, limit, filterOptions);
     const rankMs = Date.now() - tRank0;
     const hits = await Promise.all(selected.map(({ candidate, row }) => buildDbHit({
@@ -235,7 +242,27 @@ async function searchDatabase(db, input) {
         db,
     })));
     const mode = vector.warning ? "fts-fallback" : vector.neighbors ? "semantic" : "keyword";
-    return { embedMs, rankMs, hits, mode, semanticWarning: vector.warning };
+    return { embedMs, rankMs, hits, mode, semanticWarning: vector.warning, feedbackWarning: feedback.warning };
+}
+/**
+ * User feedback counts of the fused candidates, from state.db in one query.
+ * A search never creates state.db, and one that cannot read it ranks without
+ * feedback and says so.
+ */
+function readFeedback(fused) {
+    let counts = new Map();
+    try {
+        withStateDbTelemetry((stateDb) => {
+            counts = countFeedbackSignalsByRef(stateDb, fused.map((candidate) => candidate.itemRef));
+        });
+    }
+    catch (error) {
+        return {
+            counts: new Map(),
+            warning: `Feedback was not applied to the ranking: ${error instanceof Error ? error.message : String(error)}`,
+        };
+    }
+    return { counts };
 }
 /**
  * Walk the fused list in order, loading entries a batch at a time, and keep
@@ -294,21 +321,7 @@ function describeRanks(candidate) {
         ...(vectorRank !== undefined ? [`vector rank ${vectorRank}`] : []),
     ];
 }
-/**
- * The no-hits tip. A query in the retired `<type>:` / `<type>:<prefix>/` browse
- * grammar gets the conceptId spelling that replaces it: without this it comes
- * back empty and silent, which is the failure D4 removed the grammar to avoid.
- */
-function emptyResultTip(query) {
-    const generic = "No matching stash assets were found. Try a different query or run 'akm index' to rebuild.";
-    const retired = parseRetiredTypePrefixQuery(query);
-    if (!retired)
-        return generic;
-    const root = stashDirFor(retired.type);
-    if (!root)
-        return generic;
-    return `No matching stash assets were found. The '<type>:' browse grammar was removed in 0.9.0 — use the conceptId spelling: 'akm search "${root}/${retired.rest}"'.`;
-}
+const EMPTY_RESULT_TIP = "No matching stash assets were found. Try a different query or run 'akm index' to rebuild.";
 // ── Enumeration (browse) path ────────────────────────────────────────────────
 /**
  * Enumerate index entries without FTS scoring — the browse path shared by

package/dist/indexer/search/fts-query.js

@@ -78,22 +78,3 @@ export function parseRefPrefixQuery(query) {
         return { bundle, conceptIdPrefix: rest };
     return null;
 }
-/**
- * Recognize the retired `<type>:` / `<type>:<prefix>/` browse grammar so the
- * caller can name the replacement spelling rather than letting the query
- * degrade silently into a keyword search — the exact silent failure D4 removes.
- * Shape recognition only; mapping the type to its conceptId root belongs to the
- * caller, which keeps this module dependency-free.
- */
-export function parseRetiredTypePrefixQuery(query) {
-    const trimmed = query.trim();
-    if (trimmed.length === 0 || /\s/.test(trimmed) || trimmed.includes("//"))
-        return null;
-    const colon = trimmed.indexOf(":");
-    if (colon <= 0)
-        return null;
-    const rest = trimmed.slice(colon + 1);
-    if (rest !== "" && !rest.endsWith("/"))
-        return null;
-    return { type: trimmed.slice(0, colon), rest };
-}

package/dist/indexer/search/ranking.js

@@ -3,7 +3,8 @@
 // file, You can obtain one at https://mozilla.org/MPL/2.0/.
 /**
  * Reciprocal rank fusion (Cormack, Clarke and Büttcher, SIGIR 2009) of the
- * lexical and vector candidate lists — the whole of search ranking.
+ * lexical and vector candidate lists, then one feedback factor on the fused
+ * score — the whole of search ranking.
  *
  * Fusing ranks rather than scores needs no calibration between BM25 and cosine
  * similarity, so it holds for every embedding model. On the retrieval suite,
@@ -35,3 +36,30 @@ export function reciprocalRankFusion(channels) {
     });
     return [...fused.values()].sort((a, b) => b.score - a.score || compareCodePoints(a.itemRef, b.itemRef));
 }
+/**
+ * Weight of one log-count of feedback on the fused score. A factor of
+ * 1 + w·(ln(1+pos) − ln(1+neg)) moves a score by about 2% / 3% / 5% / 9% for
+ * 1 / 2 / 5 / 20 positives at 0.03. Measured on the retrieval suite's fused
+ * lists, 5 positives lift a hit from rank 10 by a median of 3 places (from rank 5,
+ * by 2) and 20 by 4 to 5, so a voted hit passes its near neighbours and a clearly
+ * better match stays ahead. At 0.05 the same votes lift it 4 to 5 and 6 to 7
+ * places, and two wrong votes cost about 1.6 times the nDCG@10 they cost at 0.03.
+ */
+export const FEEDBACK_WEIGHT = 0.03;
+/**
+ * The multiplier on a hit's fused score for its feedback: the same for every
+ * asset, rising with the number of positives and falling with the number of
+ * negatives, each by a logarithm so a heavily voted asset gains less per vote.
+ */
+export function feedbackFactor({ pos, neg }) {
+    return 1 + FEEDBACK_WEIGHT * (Math.log1p(pos) - Math.log1p(neg));
+}
+/** Scale fused scores by the feedback of each asset (keyed by `itemRef`) and reorder, with the same tie-break as fusion. */
+export function applyFeedback(fused, feedback) {
+    return fused
+        .map((candidate) => {
+        const counts = feedback.get(candidate.itemRef);
+        return counts ? { ...candidate, score: candidate.score * feedbackFactor(counts) } : candidate;
+    })
+        .sort((a, b) => b.score - a.score || compareCodePoints(a.itemRef, b.itemRef));
+}

package/dist/indexer/usage/usage-events.js

@@ -8,6 +8,7 @@
  *   id, event_type, query, entry_id (nullable), entry_ref, signal, metadata, source, created_at
  */
 import { rethrowIfTestIsolationError } from "../../core/errors.js";
+import { SQLITE_CHUNK_SIZE } from "../../storage/repositories/index-sql.js";
 const USAGE_EVENT_SOURCES = new Set(["user", "improve", "task", "audit", "unknown"]);
 /**
  * Resolve subprocess provenance without treating an invalid value as user
@@ -64,22 +65,26 @@ export function insertUsageEvent(db, event) {
 }
 // ── Query ────────────────────────────────────────────────────────────────────
 /**
- * Aggregate positive/negative feedback counts for a single entry.
- *
- * Lifted verbatim from `akm feedback` (feedback-cli.ts) where the same
- * SUM(CASE …) query was hand-rolled inline. Returns plain numbers (NULL SUMs
- * over an empty set are coalesced to 0) so the result fully materialises before
- * any owning connection closes.
+ * User feedback counts for many assets at once, keyed by durable `entry_ref`.
+ * Refs with no user feedback are absent from the map. Read in one query per
+ * chunk of refs.
  */
-export function countFeedbackSignals(db, entryId) {
-    const counts = db
-        .prepare(`SELECT
-         SUM(CASE WHEN signal = 'positive' THEN 1 ELSE 0 END) AS pos,
-         SUM(CASE WHEN signal = 'negative' THEN 1 ELSE 0 END) AS neg
-       FROM usage_events
-       WHERE event_type = 'feedback' AND entry_id = ? AND source = 'user'`)
-        .get(entryId);
-    return { pos: counts?.pos ?? 0, neg: counts?.neg ?? 0 };
+export function countFeedbackSignalsByRef(db, refs) {
+    const counts = new Map();
+    for (let i = 0; i < refs.length; i += SQLITE_CHUNK_SIZE) {
+        const chunk = refs.slice(i, i + SQLITE_CHUNK_SIZE);
+        const rows = db
+            .prepare(`SELECT entry_ref,
+           SUM(CASE WHEN signal = 'positive' THEN 1 ELSE 0 END) AS pos,
+           SUM(CASE WHEN signal = 'negative' THEN 1 ELSE 0 END) AS neg
+         FROM usage_events
+         WHERE event_type = 'feedback' AND source = 'user' AND entry_ref IN (${chunk.map(() => "?").join(",")})
+         GROUP BY entry_ref`)
+            .all(...chunk);
+        for (const row of rows)
+            counts.set(row.entry_ref, { pos: row.pos, neg: row.neg });
+    }
+    return counts;
 }
 /**
  * Count usage events of a given `event_type`.
@@ -95,7 +100,7 @@ export function countUsageEventsByType(db, eventType) {
 /**
  * Durable refs a user-attributed `search`, `curate` or `show` returned, or a
  * user `feedback` named, at or after `sinceIso`. Machine traffic (`improve`,
- * `task`, `audit`, `unknown`) is not demand, as in {@link countFeedbackSignals}.
+ * `task`, `audit`, `unknown`) is not demand, as in {@link countFeedbackSignalsByRef}.
  */
 export function listUsedEntryRefs(db, sinceIso) {
     const rows = db

package/dist/integrations/agent/engine-resolution.js

@@ -12,8 +12,9 @@ import { formatExtraParamsIssue, validateExtraParams } from "../../core/extra-pa
 import { collectSensitiveValues } from "../../core/redaction.js";
 import { resolveSecretFromStore } from "../../sources/snapshot-fetchers/secret-seam.js";
 import { getHarness } from "../harnesses/index.js";
+import { resolveOpencodeBin } from "../harnesses/opencode/version.js";
 import { DEFAULT_LLM_TIMEOUT_MS } from "./config.js";
-import { getBuiltinAgentProfile, OPENCODE_SDK_SERVER_BIN } from "./profiles.js";
+import { getBuiltinAgentProfile } from "./profiles.js";
 const LLM_CONNECTION_FIELDS = [
     "provider",
     "endpoint",
@@ -273,11 +274,13 @@ function lowerAgentEngine(name, engine, config) {
     const platform = harness.id;
     const sdk = platform === "opencode-sdk";
     const builtin = getBuiltinAgentProfile(platform);
+    // An OpenCode engine without its own `bin` runs the newest OpenCode on PATH.
+    const opencodeFamily = platform === "opencode" || sdk;
     const profile = {
         name,
         platform,
         personaChannel: sdk ? "native" : (harness.agentBuilder?.personaChannel ?? "prompt"),
-        bin: engine.bin ?? builtin?.bin ?? (sdk ? OPENCODE_SDK_SERVER_BIN : platform),
+        bin: opencodeFamily ? resolveOpencodeBin(engine.bin) : (engine.bin ?? builtin?.bin ?? platform),
         args: engine.args ?? builtin?.args ?? [],
         stdio: "captured",
         ...(builtin?.env ? { env: builtin.env } : {}),

package/dist/integrations/agent/index.js

@@ -3,5 +3,5 @@
 // file, You can obtain one at https://mozilla.org/MPL/2.0/.
 export { DEFAULT_AGENT_TIMEOUT_MS } from "./config.js";
 export { _setAgentDetectForTests, defaultWhich, detectAgentCliProfiles, pickDefaultAgentProfile } from "./detect.js";
-export { BUILTIN_AGENT_PROFILE_NAMES, getBuiltinAgentProfile, listBuiltinAgentProfiles, } from "./profiles.js";
+export { getBuiltinAgentProfile, listBuiltinAgentProfiles, } from "./profiles.js";
 export { buildProposePrompt, buildReflectPrompt, parseAgentProposalPayload } from "./prompts.js";