akm-cli 0.9.30 → 0.10.261001-beta

package/dist/commands/feedback-cli.js

@@ -21,15 +21,17 @@ import { getDbPath } from "../core/paths.js";
 import { withStateDb } from "../core/state-db.js";
 import { warn } from "../core/warn.js";
 import { withWriteTargetMutation } from "../core/write-source.js";
+import { recomputeUtilityScores } from "../indexer/indexer.js";
 import { resolveSourceEntries } from "../indexer/search/search-source.js";
-import { countFeedbackSignals, insertUsageEvent, resolveUsageEventSource } from "../indexer/usage/usage-events.js";
+import { insertUsageEvent, resolveUsageEventSource } from "../indexer/usage/usage-events.js";
 import { resolveSourcesForOrigin } from "../registry/origin-resolve.js";
 import { closeDatabase, openExistingDatabase } from "../storage/repositories/index-connection.js";
 import { findEntryIdByRef, getEntryFilePathById, getItemRefById, } from "../storage/repositories/index-entries-repository.js";
-import { applyFeedbackToUtilityScore } from "../storage/repositories/index-utility-repository.js";
+import { getUtilityScore } from "../storage/repositories/index-utility-repository.js";
 import { contentHash } from "./improve/content-hash.js";
 import { readEdgeList } from "./improve/memory/memory-belief.js";
-import { createProposal } from "./proposal/repository.js";
+import { akmProposalAccept } from "./proposal/proposal.js";
+import { createProposal, recordGateDecision, rejectProposalDurably } from "./proposal/repository.js";
 // ── Tag validation ────────────────────────────────────────────────────────────
 const TAG_KEY_RE = /^[a-z_][a-z0-9_]*$/;
 function validateFeedbackTags(raw) {
@@ -144,26 +146,25 @@ function buildLessonStrengthUpdate(rawBytes, feedbackRef) {
     const nextBytes = Buffer.from(next);
     return rawBytes.equals(nextBytes) ? { strength: strengthList.length } : { strength: strengthList.length, nextBytes };
 }
+/** Utility at or above this is "high"; falling below it after feedback emits `improve_review_needed`. */
+const UTILITY_REVIEW_THRESHOLD = 0.5;
 /**
- * Persist the feedback usage-event (state.db) and immediately fold it into the
- * entry's MemRL utility score (index.db). Chunk-8 WI-8.3: usage_events lives in
- * state.db; entries + utility_scores stay in `indexDb`. BOTH positive and
- * negative signals apply the EMA utility update unconditionally and
- * immediately when the source is user-attributed — no `akm index` run is
- * required for either signal to affect search ranking. Uses the bounded-step
- * EMA policy (F-5 / #386, arXiv:2601.03192).
- *
- * The update is intentionally SKIPPED for non-`user` event sources (`improve`,
- * `task`, `audit`, `unknown`) — an anti-self-reinforcement guard that stops an
- * agent or automated pipeline from boosting its own picks. This is by design
- * and must not be removed; R-034 only asks that the skip be surfaced to the
- * caller rather than passing silently. Best-effort: a utility-update failure
- * never fails the feedback record.
+ * Persist the feedback usage-event (state.db) and, for a user-attributed event,
+ * recompute the entry's utility score (index.db) with the same function the
+ * `akm index` finalize pass uses, scoped to this one entry, so there is one
+ * formula and the stored value is what the next index would compute. Chunk-8
+ * WI-8.3: usage_events lives in state.db; entries + utility_scores stay in `indexDb`.
+ * Search ranking does not read the utility score: it counts the recorded
+ * `source='user'` feedback events itself, so a user-attributed event affects
+ * ranking at once and an `improve`/`task`/`audit`/`unknown` one never does — an
+ * anti-self-reinforcement guard that stops an agent or automated pipeline from
+ * boosting its own picks. This is by design and must not be removed. The
+ * utility score is read by improve and metrics only; its update is best-effort
+ * and its failure never fails the feedback record or changes the ranking effect.
  */
 function recordFeedbackUsage(indexDb, entryId, durableEntryRef, signal, metadataStr) {
     let utilityResult;
-    let rankingUpdateApplied = false;
-    let rankingUpdateSkippedReason;
+    let rankingSkippedReason;
     const eventSource = resolveUsageEventSource();
     withStateDb((stateDb) => {
         insertUsageEvent(stateDb, {
@@ -175,22 +176,22 @@ function recordFeedbackUsage(indexDb, entryId, durableEntryRef, signal, metadata
             source: eventSource,
         });
         if (eventSource !== "user") {
-            rankingUpdateSkippedReason =
-                `feedback source is "${eventSource}", not "user" — ranking updates only apply to user-attributed ` +
-                    "feedback (anti-self-reinforcement guard; set AKM_EVENT_SOURCE=user to record as user demand).";
+            rankingSkippedReason =
+                `feedback source is "${eventSource}", not "user" — it does not count toward search ranking, which counts ` +
+                    "user-attributed feedback only (anti-self-reinforcement guard; set AKM_EVENT_SOURCE=user to record as user demand).";
             return;
         }
         try {
-            const { pos, neg } = countFeedbackSignals(stateDb, entryId);
-            utilityResult = applyFeedbackToUtilityScore(indexDb, entryId, pos, neg);
-            rankingUpdateApplied = true;
+            const previousUtility = getUtilityScore(indexDb, entryId)?.utility ?? 0;
+            recomputeUtilityScores(indexDb, stateDb, entryId);
+            utilityResult = { previousUtility, nextUtility: getUtilityScore(indexDb, entryId)?.utility ?? previousUtility };
         }
         catch (err) {
-            // best-effort — feedback recording succeeds even if utility update fails
-            rankingUpdateSkippedReason = `utility update failed: ${err instanceof Error ? err.message : String(err)}`;
+            // best-effort — the event is recorded (and ranked) even if the utility update fails
+            warn(`[feedback] utility update failed: ${err instanceof Error ? err.message : String(err)}`);
         }
     });
-    return { utilityResult, rankingUpdateApplied, rankingUpdateSkippedReason };
+    return { utilityResult, countsTowardRanking: eventSource === "user", rankingSkippedReason };
 }
 // ── Judged text ──────────────────────────────────────────────────────────────
 /**
@@ -416,15 +417,20 @@ export const feedbackCommand = defineJsonCommand({
             'the exact fix: --replace "<exact current text>" --with "<corrected text>" --source "<URL,\n' +
             'command or file that shows it>" (repeat --replace/--with for several edits; use --with=...\n' +
             "for a value that starts with -). akm checks that each --replace text appears exactly once\n" +
-            "and queues the edit as a proposal for review. To mark the asset's history instead, add\n" +
+            "and applies the edit at once, with no review (`akm proposal revert` undoes it). To mark\n" +
+            "the asset's history instead, add\n" +
             "--superseded-by <ref> (the asset that replaces it) or --outdated (it describes a past\n" +
-            "state and nothing replaces it), with --reason and --source: the same proposal sets its\n" +
+            "state and nothing replaces it), with --reason and --source: the same edit sets its\n" +
             "beliefState and, for --superseded-by, adds the ref to supersededBy. `--positive` records\n" +
             "that an asset helped (it raises its ranking) and does not trigger a rewrite.\n\n" +
-            "Both signals adjust the asset's usefulness score right away, in the same\n" +
-            "process: positive feedback raises it, negative lowers it, and recent\n" +
-            "feedback counts for more than old feedback. No reindex is needed — the new\n" +
-            "score affects ranking starting with the very next `akm search`.",
+            "Feedback changes `akm search` and `akm curate` ranking starting with the very\n" +
+            "next search; no reindex is needed. Each recorded positive raises the asset's\n" +
+            "score and each negative lowers it, the same way for every asset: the more\n" +
+            "positives, the higher it ranks (5 outrank 2), and each further vote counts\n" +
+            "for a little less. The effect is small, so it reorders close matches and\n" +
+            "does not override relevance. Only feedback recorded as the user counts, not\n" +
+            "feedback from improve, task or audit runs. Feedback also moves the utility\n" +
+            "score that improve and `akm metrics` read.",
     },
     args: {
         // Optional in citty so run() is invoked even when omitted; we re-validate
@@ -565,8 +571,8 @@ export const feedbackCommand = defineJsonCommand({
         // background reindex it spawned — now that ensureIndex is removed, holding
         // the lock only causes feedback to block for the full improve run duration.
         let utilityResult;
-        let rankingUpdateApplied = false;
-        let rankingUpdateSkippedReason;
+        let countsTowardRanking = false;
+        let rankingSkippedReason;
         let durableRef = ref;
         let fix;
         const db = openExistingDatabase();
@@ -586,10 +592,10 @@ export const feedbackCommand = defineJsonCommand({
                 throw new NotFoundError(`Ref "${ref}" is not in the index. ` +
                     "Run 'akm search' to verify the asset exists, then 'akm index' if it was recently added.", "ASSET_NOT_FOUND");
             }
-            // Persist the feedback signal into usage_events. Both positive and
-            // negative signals apply the EMA utility update immediately — no
-            // `akm index` run is required for either signal to affect ranking in
-            // search results (see recordFeedbackUsage / applyFeedbackToUtilityScore).
+            // Persist the feedback signal into usage_events. A user-attributed signal
+            // also recomputes the entry's utility at once (see recordFeedbackUsage).
+            // Search ranking reads the recorded events directly, so no `akm index`
+            // run is needed.
             // WI-8.5b: the `feedback` / `improve_review_needed` events key on the
             // resolved entry's fully-qualified item_ref — the SAME durable key the
             // usage_events row carries and the SAME spelling the signal-delta
@@ -645,8 +651,8 @@ export const feedbackCommand = defineJsonCommand({
             const metadataStr = Object.keys(metadataObj).length > 1 ? JSON.stringify(metadataObj) : undefined;
             const recordResult = recordFeedbackUsage(db, entryId, itemRef, signal, metadataStr);
             utilityResult = recordResult.utilityResult;
-            rankingUpdateApplied = recordResult.rankingUpdateApplied;
-            rankingUpdateSkippedReason = recordResult.rankingUpdateSkippedReason;
+            countsTowardRanking = recordResult.countsTowardRanking;
+            rankingSkippedReason = recordResult.rankingSkippedReason;
         }
         finally {
             closeDatabase(db);
@@ -656,16 +662,34 @@ export const feedbackCommand = defineJsonCommand({
             ref: durableRef,
             metadata: metadataObj,
         });
-        const fixProposal = fix && reason?.trim() && fixSource
-            ? createProposal(resolveStashDir(), {
+        // A person typed the fix, so it is applied now: the proposal is minted for the audit trail, `akm proposal
+        // revert` and reflect's "already acted on" rule, then accepted through the ordinary accept path (the same
+        // checks and git commit). If that refuses, the proposal is rejected and the command fails.
+        let fixProposal;
+        if (fix && reason?.trim() && fixSource) {
+            const stashDir = resolveStashDir();
+            const minted = createProposal(stashDir, {
                 ref: durableRef,
                 itemRef: durableRef,
                 target: fix.target,
                 source: "feedback",
                 payload: { content: fix.content },
                 feedback: { reason: reason.trim(), source: fixSource },
-            })
-            : undefined;
+            });
+            try {
+                recordGateDecision(stashDir, minted.id, { outcome: "auto-accepted", reason: "manual-fix", gate: "feedback" });
+                fixProposal = (await akmProposalAccept({ stashDir, id: minted.id })).proposal;
+            }
+            catch (err) {
+                try {
+                    rejectProposalDurably(stashDir, minted.id, `manual fix not applied: ${err instanceof Error ? err.message : String(err)}`);
+                }
+                catch (rejectErr) {
+                    warn(`[feedback] could not reject proposal ${minted.id}: ${rejectErr instanceof Error ? rejectErr.message : String(rejectErr)}`);
+                }
+                throw err;
+            }
+        }
         // F-5 / #386: When a high-utility asset crosses below the review threshold,
         // auto-create a review-needed escalation proposal so a human can confirm
         // whether the negative feedback is valid before the asset falls out of
@@ -674,7 +698,9 @@ export const feedbackCommand = defineJsonCommand({
         // Emit a structured event rather than a proposal so the review-needed
         // signal doesn't risk an accidental asset overwrite if the proposal is
         // accepted.
-        if (utilityResult?.crossedReviewThreshold) {
+        if (utilityResult &&
+            utilityResult.previousUtility >= UTILITY_REVIEW_THRESHOLD &&
+            utilityResult.nextUtility < UTILITY_REVIEW_THRESHOLD) {
             try {
                 appendEvent({
                     eventType: "improve_review_needed",
@@ -729,9 +755,9 @@ export const feedbackCommand = defineJsonCommand({
             signal,
             reason: reason?.trim() ?? null,
             tags: validatedTags,
-            rankingUpdate: rankingUpdateApplied
+            rankingUpdate: countsTowardRanking
                 ? { applied: true }
-                : { applied: false, reason: rankingUpdateSkippedReason ?? "unknown" },
+                : { applied: false, reason: rankingSkippedReason ?? "unknown" },
             ...(fixProposal
                 ? {
                     fix: {

package/dist/commands/health/checks.js

@@ -11,6 +11,8 @@ import { withEngineFallback } from "../../integrations/agent/engine-fallback.js"
 import { isLlmCredentialAvailable, resolveEngine, } from "../../integrations/agent/engine-resolution.js";
 import { executionEngineDefinitionsFromConfig } from "../../integrations/agent/execution.js";
 import { loadModelMap, mergeModelMapLayers, parseModelMapLayer, readInstalledModelMapText, resolveModelMapAlias, userModelMapPath, } from "../../integrations/agent/model-map.js";
+import { detectOpencodeMajor, resolveOpencodeBin, } from "../../integrations/harnesses/opencode/version.js";
+import { OPENCODE_CLIENT_PACKAGE } from "../../integrations/harnesses/opencode-sdk/wire.js";
 import { probeEndpointOnce } from "../../llm/client.js";
 import { STATE_DB_FREELIST_WARN_RATIO, } from "../../storage/state-db-integrity.js";
 import { listKeys } from "../env/env.js";
@@ -116,20 +118,15 @@ async function runConfiguredEngineProbe(checkName, engineName, config, deps, rea
     const env = deps.env ?? process.env;
     const configuredEngine = config.engines?.[engineName];
     if (configuredEngine?.kind === "agent" && configuredEngine.platform === "opencode-sdk") {
-        let packageAvailable = false;
+        const binary = resolveOpencodeBin(configuredEngine.bin);
+        let detected;
         try {
-            const resolvePackage = deps.resolvePackage ?? ((name) => import.meta.resolve(name));
-            resolvePackage("@opencode-ai/sdk");
-            packageAvailable = true;
-        }
-        catch {
-            packageAvailable = false;
-        }
-        const binary = configuredEngine.bin ?? "opencode";
-        let binaryAvailable;
-        try {
-            const version = (deps.spawnSync ?? spawnSync)(binary, ["--version"], { encoding: "utf8", timeout: 5_000 });
-            binaryAvailable = (version.status ?? 1) === 0;
+            detected = detectOpencodeMajor(binary, {
+                probe: (bin) => {
+                    const run = (deps.spawnSync ?? spawnSync)(bin, ["--version"], { encoding: "utf8", timeout: 5_000 });
+                    return (run.status ?? 1) === 0 ? String(run.stdout ?? "").trim() : undefined;
+                },
+            });
         }
         catch {
             return {
@@ -141,6 +138,18 @@ async function runConfiguredEngineProbe(checkName, engineName, config, deps, rea
                 evidence: { engine: engineName, runtimeKind: "sdk", binaryAvailable: false },
             };
         }
+        const binaryAvailable = detected.runnable;
+        // The client package of the OpenCode major the binary reports; never the other major's.
+        const clientPackage = OPENCODE_CLIENT_PACKAGE[detected.major];
+        let packageAvailable = false;
+        try {
+            const resolvePackage = deps.resolvePackage ?? ((name) => import.meta.resolve(name));
+            resolvePackage(clientPackage);
+            packageAvailable = true;
+        }
+        catch {
+            packageAvailable = false;
+        }
         const fallbackEngine = configuredEngine.llmEngine;
         let fallback;
         let fallbackCredential;
@@ -183,7 +192,7 @@ async function runConfiguredEngineProbe(checkName, engineName, config, deps, rea
             ? findSuppliedByEnvAsset(fallbackCredential, deps)
             : null;
         const missing = [
-            !packageAvailable ? "@opencode-ai/sdk package" : undefined,
+            !packageAvailable ? `${clientPackage} package` : undefined,
             !binaryAvailable ? `${binary} binary` : undefined,
             fallbackEngine && !fallback ? "configured fallback LLM connection" : undefined,
             !fallbackCredentialAvailable
@@ -198,7 +207,9 @@ async function runConfiguredEngineProbe(checkName, engineName, config, deps, rea
             runtimeKind: "sdk",
             binary,
             binaryAvailable,
-            package: "@opencode-ai/sdk",
+            package: clientPackage,
+            detectedVersion: detected.version || null,
+            detectedMajor: detected.major,
             packageAvailable,
             model: effectiveModel ?? null,
             configuredModel: configuredModel ?? null,
@@ -533,7 +544,21 @@ export function probeActiveImproveStrategy(deps = {}) {
         const requiredModelProcessNames = modelProcessNames.filter((name) => plan.processes[name].enabled || plan.engineUnavailable.some((item) => item.process === name));
         const availableModelProcessNames = modelProcessNames.filter((name) => plan.processes[name].enabled);
         const allRequiredUnavailable = requiredModelProcessNames.length > 0 && availableModelProcessNames.length === 0;
-        const status = unavailableProcesses.length === 0 ? "pass" : allRequiredUnavailable ? "fail" : "warn";
+        // No engine configured at all (no unavailable item carries a resolved engine)
+        // is "not set up yet", not a broken credential: it keeps the unknown/warn
+        // result it had when the plan threw for it. Engine-free deterministic triage
+        // (#1143) now lets such a plan resolve, so this has to be explicit.
+        const noEngineConfigured = plan.engineUnavailable.length > 0 && plan.engineUnavailable.every((i) => !i.engine);
+        const explicitlyConfigured = config.defaults?.improveStrategy !== undefined || Object.keys(config.improve?.strategies ?? {}).length > 0;
+        const status = unavailableProcesses.length === 0
+            ? "pass"
+            : allRequiredUnavailable
+                ? noEngineConfigured
+                    ? explicitlyConfigured
+                        ? "warn"
+                        : "unknown"
+                    : "fail"
+                : "warn";
         return {
             check: {
                 name: "active-improve-strategy",

package/dist/commands/health/plugin-staleness.js

@@ -52,6 +52,7 @@ import { spawnSync } from "node:child_process";
 import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
+import { OPENCODE_V1, OPENCODE_V2, readPackageVersion, } from "../../integrations/harnesses/opencode/plugin-layout.js";
 import { isExactSemver, isSemverRange, maxSatisfying, satisfiesRange } from "../../registry/semver.js";
 /**
  * Root directory holding Claude Code's plugin cache + marketplace clones.
@@ -66,41 +67,69 @@ function claudePluginsDir() {
 /**
  * Root of OpenCode's package cache, same override pattern as
  * {@link claudePluginsDir} (`AKM_OPENCODE_CACHE_DIR` for tests).
- * The OpenCode plugin (`akm-opencode`) bundles its own `akm-cli` under
- * `packages/akm-opencode/node_modules/akm-cli` and runs it in-process,
+ * The OpenCode plugins (`akm-opencode`, and `akm-opencode-v2` for OpenCode 2) bundle their own `akm-cli`
+ * (layout: `integrations/harnesses/opencode/plugin-layout.ts`) and run it in-process,
  * sharing the host's databases with every other akm install — its version
  * lag matters the same way a stale Claude plugin's does.
  */
 function opencodeCacheDir() {
     return process.env.AKM_OPENCODE_CACHE_DIR ?? path.join(os.homedir(), ".cache", "opencode");
 }
+const OPENCODE_PLUGIN_LOCATIONS = [
+    {
+        // OpenCode 1: <cache>/packages/akm-opencode/node_modules/akm-cli (the folder read since this check began).
+        flavor: OPENCODE_V1,
+        advisory: "opencode-plugin-version",
+        label: "OpenCode's",
+        remedy: "update the OpenCode plugin",
+        folders: (cacheRoot) => [{ folder: path.join(cacheRoot, OPENCODE_V1.cacheFolder(OPENCODE_V1.pkg)) }],
+    },
+    {
+        // OpenCode 2: <cache>/npm/akm-opencode-v2@<spec>/<epoch-ms>/node_modules/akm-cli, newest build per spec.
+        flavor: OPENCODE_V2,
+        advisory: "opencode-v2-plugin-version",
+        label: "OpenCode 2's akm-opencode-v2",
+        remedy: "update the akm-opencode-v2 plugin",
+        folders: (cacheRoot) => {
+            const npmDir = path.join(cacheRoot, OPENCODE_V2.cacheFolder(""));
+            let specs;
+            try {
+                specs = fs.readdirSync(npmDir).filter((name) => name.startsWith(`${OPENCODE_V2.pkg}@`));
+            }
+            catch {
+                return [];
+            }
+            return specs.sort().map((spec) => ({ spec, folder: path.join(npmDir, spec) }));
+        },
+    },
+];
 /**
- * Read the OpenCode plugin's bundled `akm-cli` version from its
- * `package.json` — never executed, just parsed, mirroring
- * {@link detectInstalledPlugins}'s manifest read. `undefined` when the
- * OpenCode plugin, or its bundled akm-cli, is not installed.
+ * The bundled `akm-cli` of each cached copy of `plugin`: its `package.json` is read, never executed,
+ * mirroring {@link detectInstalledPlugins}'s manifest read. Copies with no bundled akm-cli are skipped.
  */
-function detectOpencodeBundledAkmVersion(cacheRoot) {
-    const pkgPath = path.join(cacheRoot, "packages", "akm-opencode", "node_modules", "akm-cli", "package.json");
-    try {
-        const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf8"));
-        return typeof pkg.version === "string" ? pkg.version : undefined;
-    }
-    catch {
-        return undefined;
+function findBundledAkm(plugin, cacheRoot) {
+    const found = [];
+    for (const { spec, folder } of plugin.folders(cacheRoot)) {
+        const nodeModules = plugin.flavor.nodeModulesDir(folder);
+        const version = nodeModules && readPackageVersion(path.join(nodeModules, "akm-cli", "package.json"));
+        if (version !== undefined)
+            found.push(spec ? { spec, version } : { version });
     }
+    return found;
 }
-function buildOpencodeBundledAdvisory(bundledVersion, cliVersion) {
+function buildOpencodeBundledAdvisory(plugin, bundled, cliVersion) {
+    const bundledVersion = bundled.version;
     const stale = bundledVersion !== cliVersion;
+    const where = bundled.spec ? ` (${bundled.spec})` : "";
     return {
-        name: "opencode-plugin-version",
+        name: plugin.advisory,
         kind: "deterministic",
         status: stale ? "warn" : "pass",
         confidence: "high",
         message: stale
-            ? `OpenCode's bundled akm-cli is v${bundledVersion}, but the running CLI is v${cliVersion} — it shares the same databases in-process; update the OpenCode plugin.`
-            : `OpenCode's bundled akm-cli matches the running v${cliVersion}.`,
-        evidence: { bundledVersion, cliVersion },
+            ? `${plugin.label} bundled akm-cli${where} is v${bundledVersion}, but the running CLI is v${cliVersion} — it shares the same databases in-process; ${plugin.remedy}.`
+            : `${plugin.label} bundled akm-cli${where} matches the running v${cliVersion}.`,
+        evidence: bundled.spec ? { bundledVersion, cliVersion, spec: bundled.spec } : { bundledVersion, cliVersion },
     };
 }
 /**
@@ -218,9 +247,10 @@ export function collectPluginStalenessAdvisories(options) {
     const plugins = detectInstalledPlugins(pluginsRoot);
     const results = plugins.map((plugin) => buildAdvisory(plugin, options.cliVersion, pluginsRoot, listRemoteTags));
     const opencodeCacheRoot = options.opencodeCacheRoot ?? opencodeCacheDir();
-    const bundledVersion = detectOpencodeBundledAkmVersion(opencodeCacheRoot);
-    if (bundledVersion !== undefined) {
-        results.push(buildOpencodeBundledAdvisory(bundledVersion, options.cliVersion));
+    for (const plugin of OPENCODE_PLUGIN_LOCATIONS) {
+        for (const bundled of findBundledAkm(plugin, opencodeCacheRoot)) {
+            results.push(buildOpencodeBundledAdvisory(plugin, bundled, options.cliVersion));
+        }
     }
     return results;
 }

package/dist/commands/improve/autonomy-gate.js

@@ -6,7 +6,7 @@ import { IMPROVE_AUTONOMY_CONFIG_KEY, isImproveAutonomyEnabled, } from "../../co
 export const AUTONOMY_LANES = ["memoryInference", "triagePromote", "memoryCleanup"];
 const LANE_REASONS = {
     memoryInference: "writes derived memory children and rewrites parent frontmatter",
-    triagePromote: "auto-accepts queued proposals into the stash (downgraded to queue)",
+    triagePromote: "auto-accepts queued proposals the triage judgment tier approves (downgraded to queue)",
     memoryCleanup: "rewrites belief-state frontmatter and moves files into the cleanup archive",
 };
 /**
@@ -59,8 +59,10 @@ export function applyAutonomyGate(strategy, config) {
     }
     // Triage stays ENABLED — queued proposals are still triaged, they just are not
     // auto-accepted. Disabling it would remove review work the user asked for,
-    // which is the opposite of what a review-first default should do.
-    if (processes.triage?.applyMode === "promote") {
+    // which is the opposite of what a review-first default should do. Only a
+    // promote that runs the judgment tier is gated (#1143); a deterministic-only
+    // promote is the default and needs no opt-in.
+    if (processes.triage?.applyMode === "promote" && processes.triage.judgment?.enabled === true) {
         processes.triage = { ...processes.triage, applyMode: "queue" };
         gated.push(gatedLane("triagePromote"));
     }

package/dist/commands/improve/consolidate/chunking.js

@@ -3,7 +3,6 @@
 // file, You can obtain one at https://mozilla.org/MPL/2.0/.
 /** Consolidate's chunk sizing and per-chunk prompt (pure token math and text). */
 import fs from "node:fs";
-import { parseFrontmatter } from "../../../core/asset/frontmatter.js";
 import { contentHash, stripFrontmatterBody } from "../content-hash.js";
 /** A conservative chars-per-token estimate, shared by every context-length budget. */
 export const CHARS_PER_TOKEN = 3;
@@ -24,9 +23,8 @@ export function computeSafeChunkSize(contextLength, bodyTruncation, maxChunkSize
 /**
  * One chunk's user prompt. Each memory shows its body only (frontmatter can
  * outrun the truncation and leave the model judging metadata), marked
- * `captureMode: hot` when the user captured it explicitly and `already queued`
- * when a pending consolidate proposal carries its body hash — the system
- * prompt forbids promoting those.
+ * `already queued` when a pending consolidate proposal carries its body hash —
+ * the system prompt forbids promoting those.
  */
 export function buildChunkPrompt(sourceName, memories, chunkIndex, totalChunks, bodyTruncation, pendingProposalBodyHashes = new Set()) {
     const lines = [
@@ -42,12 +40,7 @@ export function buildChunkPrompt(sourceName, memories, chunkIndex, totalChunks,
         catch {
             body = "(unreadable)";
         }
-        const annotations = [];
-        if (parseFrontmatter(body).data.captureMode === "hot")
-            annotations.push("captureMode: hot");
-        if (pendingProposalBodyHashes.has(contentHash(body, "body")))
-            annotations.push("already queued");
-        const annotationSuffix = annotations.length > 0 ? ` (${annotations.join("; ")})` : "";
+        const annotationSuffix = pendingProposalBodyHashes.has(contentHash(body, "body")) ? " (already queued)" : "";
         lines.push(`[${i + 1}] memories/${m.name}${annotationSuffix}`, `Description: ${m.description || "(none)"}`, `Tags: ${m.tags.length > 0 ? m.tags.join(", ") : "(none)"}`, "---", stripFrontmatterBody(body).slice(0, bodyTruncation), "");
     });
     return lines.join("\n");

package/dist/commands/improve/consolidate/continuity-check.js

@@ -4,7 +4,7 @@
 import { searchLocal } from "../../../indexer/search/db-search.js";
 import { stripFrontmatterBody } from "../content-hash.js";
 import { stripBundle } from "../ledger.js";
-import { loadRetrievalQueries } from "../retrieval-gate.js";
+import { loadRetrievalQueries } from "../retrieval-queries.js";
 /** At most this many of the retired asset's most recent queries are replayed (plan §5.4, §7). */
 export const CONTINUITY_MAX_QUERIES = 5;
 /** "Top 10" per the plan's rule — both the pass/fail cutoff and the search `limit`. */
@@ -63,8 +63,8 @@ function normalizedBody(raw) {
  *
  * S3: two fixes against false flags measured on a real night-1 admission
  * (300 pairs, 6 flags, half spurious):
- *  - queries are the SAME cleaned set `loadRetrievalQueries` replays for the
- *    retrieval regression gate (`../retrieval-gate.ts`) — stash-README
+ *  - queries are the cleaned set `loadRetrievalQueries` returns
+ *    (`../retrieval-queries.ts`) — stash-README
  *    boilerplate, harness/tool envelopes, pastes over 2,000 characters, and
  *    duplicates are dropped before replay, not just capped at 5 raw entries;
  *  - when the retired and successor bodies normalize identical, the check
@@ -92,7 +92,7 @@ export async function checkRetirementContinuity(args) {
     // no real risk here to check for.
     if (normalizedBody(args.retiredRaw) === normalizedBody(args.successorRaw))
         return undefined;
-    // S3a: the SAME cleaned queries the retrieval regression gate replays —
+    // S3a: the cleaned queries from `loadRetrievalQueries` —
     // boilerplate, envelopes, pastes and duplicates dropped before replay.
     const queries = loadRetrievalQueries(args.ledgerAccess, args.retiredRef).slice(0, CONTINUITY_MAX_QUERIES);
     if (queries.length === 0)

package/dist/commands/improve/consolidate/pair-pass.js

@@ -42,10 +42,9 @@ import { assertRunnerCredentials } from "../../../integrations/agent/runner-disp
 import { runGit } from "../../../sources/providers/git-install.js";
 import { closeDatabase, openExistingDatabase, openReadonlyExistingDatabase, } from "../../../storage/repositories/index-connection.js";
 import { getAllEntries, getEntryById } from "../../../storage/repositories/index-entries-repository.js";
-import { getNeighborsByEntryId } from "../../../storage/repositories/index-vec-repository.js";
-import { isRetireProposal, PAIR_PASS_GATE, } from "../../proposal/proposal-types.js";
+import { getNeighborsByEntryId, hasStoredEmbedding } from "../../../storage/repositories/index-vec-repository.js";
+import { EXPIRED_GATE_REASON, isRetireProposal, PAIR_PASS_GATE, STALE_TARGET_GATE_REASON, } from "../../proposal/proposal-types.js";
 import { createRetireProposal, listProposalsReadOnly, proposalContentHash, recordGateDecision, } from "../../proposal/repository.js";
-import { isHotCapturedMemory } from "../consolidate.js";
 import { contentHash, stripFrontmatterBody } from "../content-hash.js";
 import { loadLedgerSnapshot, PAIR_PASS_LEDGER_SOURCE, recordLedgerAttempt, stripBundle } from "../ledger.js";
 import { isInRetrievalScope, loadRetrievalScope } from "../retrieval-scope.js";
@@ -313,6 +312,10 @@ export function loadRejectedPairKeys(stashDir, proposalsCtx) {
             for (const p of listProposalsReadOnly(stashDir, { status, includeArchive: true }, proposalsCtx)) {
                 if (!isRetireProposal(p) || !p.retirement)
                     continue;
+                // Expiry and a stale target are procedural, not a person saying no: the pair may be judged again.
+                const autoReason = p.gateDecision?.outcome === "auto-rejected" ? p.gateDecision.reason : undefined;
+                if (autoReason === EXPIRED_GATE_REASON || autoReason === STALE_TARGET_GATE_REASON)
+                    continue;
                 keys.add(rejectedPairKey(p.retirement.retiredRef, p.retirement.successorRef, p.retirement.retiredContentHash, p.retirement.successorContentHash));
             }
         }
@@ -364,12 +367,18 @@ export function selectInitiators(pool, opts, stashDir, gitFirstAdded) {
  * apart from a fully-judged one). S2: fetches `PAIR_NEIGHBOR_FETCH_K` (20)
  * raw neighbours and keeps the first `PAIR_NEIGHBOR_K` (5) that clear every
  * filter, so a few self/twin/bundle/tier misses in the raw top-5 no longer
- * starve an initiator down to zero real candidates.
+ * starve an initiator down to zero real candidates. An initiator with no
+ * stored vector (embeddings off, or not embedded yet) cannot be queried at
+ * all; its ref is added to `unvectored` so the caller does not settle it.
  */
-export function selectCandidates(db, initiators, bundleId) {
+export function selectCandidates(db, initiators, bundleId, unvectored) {
     const candidates = [];
     const seenPairs = new Set();
     for (const initiator of initiators) {
+        if (!hasStoredEmbedding(db, initiator.entryId)) {
+            unvectored?.add(initiator.ref);
+            continue;
+        }
         // S1: a changed-content or new-material initiator judges at T_PAIR; the
         // rest of the backlog (no row, not recently git-added) needs the higher
         // BACKFILL_FLOOR.
@@ -465,7 +474,13 @@ function orderByAge(x, y) {
 }
 /** The user message: dates decide "A (older)" / "B (newer)" (plan Appendix A), matching the calibration sample's own ordering. */
 export function buildPairUserPrompt(older, newer) {
-    return [...sideSection("A (older)", older), ...sideSection("B (newer)", newer)].join("\n");
+    // Equal dates (a batch added in one commit, notes from one file time) make neither side newer: say so, or the judge
+    // reads "B (newer)" as proof that B replaces A (#1134).
+    const tied = Date.parse(older.createdIso) === Date.parse(newer.createdIso);
+    return [
+        ...sideSection(tied ? "A (same age as B)" : "A (older)", older),
+        ...sideSection(tied ? "B (same age as A)" : "B (newer)", newer),
+    ].join("\n");
 }
 /** The tombstone-vocabulary reason a judge label maps to (`supersedes` -> `superseded`; the rest unchanged). */
 export function tombstoneReason(label) {
@@ -591,9 +606,6 @@ async function judgeOne(ctx, candidate) {
         [retired, successor] = [successor, retired];
     }
     // Guards (plan §5.2 step 4 / brief §A "Guards").
-    if (retired.asset.type === "memory" && isHotCapturedMemory(retired.asset.filePath)) {
-        return { failed: false }; // never propose retiring a captureMode: hot memory — leave the pair alone
-    }
     if (retired.asset.type === "memory" && retired.asset.name.endsWith(DERIVED_SUFFIX)) {
         // S3: derive the parent path from the FULL file path, not from name +
         // dirname — for a subfolder memory (e.g. memories/sub/foo.derived) the
@@ -730,6 +742,7 @@ seams = {}) {
     let candidates;
     let gitFirstAdded;
     let db;
+    const unvectored = new Set();
     try {
         db = opts.dryRun ? openReadonlyExistingDatabase(undefined, { isolatedSnapshot: true }) : openExistingDatabase();
         if (!db)
@@ -737,7 +750,7 @@ seams = {}) {
         gitFirstAdded = loadGitFirstAddedMap(stashDir);
         const pool = loadPairPassPool(db, bundleId);
         initiators = selectInitiators(pool, opts, stashDir, gitFirstAdded).initiators;
-        candidates = selectCandidates(db, initiators, bundleId);
+        candidates = selectCandidates(db, initiators, bundleId, unvectored);
     }
     catch (error) {
         warnings.push(`Pair pass: index unavailable — skipped (${error instanceof Error ? error.message : String(error)}).`);
@@ -748,6 +761,9 @@ seams = {}) {
             closeDatabase(db);
     }
     const initiatorsBacklog = initiators.filter((i) => i.backlog).length;
+    if (unvectored.size > 0) {
+        warnings.push(`Pair pass: ${unvectored.size} asset(s) have no stored embedding, so their neighbours cannot be found and they were not judged. The pair pass needs stored embeddings (set semanticSearchMode to "auto" in the config, then run akm index).`);
+    }
     // Never judge a pair when either side already has a pending retire
     // proposal, as the retired ref OR its successor (B2 widens this from the
     // retired ref alone): an asset spoken for by one pending decision cannot
@@ -861,6 +877,9 @@ seams = {}) {
         const admittedRefs = new Set(judgeable.map((c) => c.initiator.ref));
         const ledgerInputs = initiators
             .filter((i) => {
+            // No stored vector: the neighbour query never ran, so nothing was judged. Leave it unsettled.
+            if (unvectored.has(i.ref))
+                return false;
             const hasCandidates = byInitiator.has(i.ref);
             if (!hasCandidates)
                 return true;