akm-cli 0.9.0-rc.2 → 0.9.0-rc.3

package/dist/commands/improve/extract.js

@@ -33,6 +33,7 @@ import { appendEvent } from "../../core/events.js";
 import { createLockPayload, probeLock, reclaimStaleLock, releaseLock, tryAcquireLockSync, } from "../../core/file-lock.js";
 import { tryAcquireMaintenanceBarrier } from "../../core/maintenance-barrier.js";
 import { resolveStashStandards } from "../../core/standards/resolve-stash-standards.js";
+import { resolveTypeConventions, typeConventionRef } from "../../core/standards/resolve-type-conventions.js";
 import { getStateDbPath, openStateDatabase, withStateDb } from "../../core/state-db.js";
 import { repairTruncatedDescription } from "../../core/text-truncation.js";
 import { warn } from "../../core/warn.js";
@@ -244,15 +245,15 @@ function resolveHarness(type, harnesses) {
  * so the accept-time descriptionQualityValidator passes — same pattern as
  * the consolidate-writer fix at consolidate.ts.
  */
-function buildCandidateProposal(candidate, sourceRef) {
-    const ref = `${candidate.type}:${candidate.name}`;
+function buildCandidateProposal(candidate, sourceRef, sessionAssetRef) {
+    const ref = deriveExtractCandidateRef(candidate, sourceRef);
     // Post-generation repair pass (#556): deterministically complete a
     // description the LLM sliced mid-sentence before it reaches the
     // auto-accept validators. No-op (byte-identical) for valid descriptions.
     const description = repairTruncatedDescription(candidate.description, candidate.body);
     const fm = {
         description,
-        sources: [`session:${sourceRef.harness}:${sourceRef.sessionId}`],
+        ...(sessionAssetRef ? { xrefs: [sessionAssetRef] } : {}),
     };
     if (candidate.type === "lesson" && candidate.when_to_use) {
         fm.when_to_use = candidate.when_to_use;
@@ -269,6 +270,36 @@ function buildCandidateProposal(candidate, sourceRef) {
     const content = assembleAsset(fm, candidate.body);
     return { ref, content, description };
 }
+function canonicalSegment(value) {
+    return value
+        .trim()
+        .toLowerCase()
+        .replace(/[^a-z0-9-]+/g, "-")
+        .replace(/-+/g, "-")
+        .replace(/^-|-$/g, "");
+}
+export function deriveExtractCandidateRef(candidate, sourceRef) {
+    const candidateParts = candidate.name.split("/").map(canonicalSegment).filter(Boolean);
+    const leaf = candidateParts.at(-1) ?? "extracted-insight";
+    if (candidate.type === "memory" || candidate.type === "lesson") {
+        const projectName = sourceRef.projectHint?.split(/[\\/]/).filter(Boolean).at(-1);
+        const scope = projectName ? canonicalSegment(projectName) : "";
+        return `${candidate.type}:${scope ? `${scope}/` : ""}${leaf}`;
+    }
+    return `knowledge:${leaf}`;
+}
+function resolveExtractStandards(stashDir) {
+    const sections = [];
+    const general = resolveStashStandards(stashDir);
+    if (general)
+        sections.push(general);
+    for (const type of ["memory", "lesson", "knowledge"]) {
+        const body = resolveTypeConventions(stashDir, type);
+        if (body)
+            sections.push(`# ${typeConventionRef(type)} (soft per-type conventions — guidance, not enforced)\n${body}`);
+    }
+    return sections.join("\n\n");
+}
 /**
  * Canonicalize a session's content into a single deterministic string for
  * hashing (#602). Each event is rendered `<role>\n<text>` and events are joined
@@ -473,10 +504,12 @@ standardsContext) {
     }
     const payload = parseExtractPayload(llmRaw);
     const proposalIds = [];
+    // Provenance refs are added only after the cited session asset exists.
+    const sessionAsset = await maybeWriteSessionAsset();
     if (payload.candidates.length === 0) {
         appendEvent({
             eventType: "extract_invoked",
-            ref: `session:${harness.name}:${sessionRef.sessionId}`,
+            ...(sessionAsset.sessionAssetRef ? { ref: sessionAsset.sessionAssetRef } : {}),
             metadata: {
                 outcome: "no_candidates",
                 sessionId: sessionRef.sessionId,
@@ -487,7 +520,6 @@ standardsContext) {
                 preFilterOutput: filtered.stats.outputCount,
             },
         }, ctx);
-        const sessionAsset = await maybeWriteSessionAsset();
         return {
             sessionId: sessionRef.sessionId,
             harness: harness.name,
@@ -510,8 +542,9 @@ standardsContext) {
     // dedup+quality pass promotes them. Default OFF.
     // The invocation boundary resolves this from the frozen extract process.
     for (const candidate of payload.candidates) {
+        const built = buildCandidateProposal(candidate, data.ref, sessionAsset.sessionAssetRef);
         if (dryRun) {
-            proposalIds.push(`dry-run:${candidate.type}:${candidate.name}`);
+            proposalIds.push(`dry-run:${built.ref}`);
             continue;
         }
         try {
@@ -527,7 +560,7 @@ standardsContext) {
             const effectiveConfidence = gateResult.effectiveConfidence;
             if (gateResult.warning)
                 warn(gateResult.warning);
-            const { ref, content, description } = buildCandidateProposal(candidate, sessionRef);
+            const { ref, content, description } = built;
             const result = createProposal(stashDir, {
                 ref,
                 source: "extract",
@@ -538,7 +571,7 @@ standardsContext) {
                         description,
                         ...(candidate.when_to_use ? { when_to_use: candidate.when_to_use } : {}),
                         ...(effectiveConfidence !== undefined ? { confidence: effectiveConfidence } : {}),
-                        sources: [`session:${sessionRef.harness}:${sessionRef.sessionId}`],
+                        ...(sessionAsset.sessionAssetRef ? { xrefs: [sessionAsset.sessionAssetRef] } : {}),
                         evidence: candidate.evidence,
                         // #615 WS-0: mirror ordered-action + outcome data in the proposal
                         // frontmatter record so downstream tooling can read it without
@@ -569,7 +602,7 @@ standardsContext) {
     }
     appendEvent({
         eventType: "extract_invoked",
-        ref: `session:${harness.name}:${sessionRef.sessionId}`,
+        ...(sessionAsset.sessionAssetRef ? { ref: sessionAsset.sessionAssetRef } : {}),
         metadata: {
             outcome: "candidates_queued",
             sessionId: sessionRef.sessionId,
@@ -581,7 +614,6 @@ standardsContext) {
             preFilterOutput: filtered.stats.outputCount,
         },
     }, ctx);
-    const sessionAsset = await maybeWriteSessionAsset();
     return {
         sessionId: sessionRef.sessionId,
         harness: harness.name,
@@ -827,7 +859,7 @@ export async function akmExtract(options) {
     // Stash authoring standards (convention/meta fact bodies) for non-wiki
     // extract output. Resolved ONCE per run and threaded into each session's
     // prompt so facts are not re-read per session.
-    const extractStandardsContext = resolveStashStandards(stashDir);
+    const extractStandardsContext = resolveExtractStandards(stashDir);
     for (const summary of candidates) {
         // #602 — the already-extracted skip moved INTO processSession (the content
         // hash needs the session body, only available after readSession). The prior

package/dist/commands/improve/improve-auto-accept.js

@@ -3,7 +3,6 @@
 // file, You can obtain one at https://mozilla.org/MPL/2.0/.
 import { loadConfig } from "../../core/config/config.js";
 import { UsageError } from "../../core/errors.js";
-import { appendEvent } from "../../core/events.js";
 import { withStateDb } from "../../core/state-db.js";
 import { info, warn } from "../../core/warn.js";
 import { getPhaseThreshold } from "../../storage/repositories/improve-runs-repository.js";
@@ -119,42 +118,29 @@ export async function runAutoAcceptGate(candidates, cfg, promoteFn = promoteProp
             continue;
         }
         try {
-            const promotion = await promoteFn(cfg.stashDir, resolvedConfig, proposalId, {}, undefined);
-            stamp(promotion.proposal.id, {
-                outcome: "auto-accepted",
-                reason: promoteReason,
-                confidence,
-                thresholds: { autoAccept: effectiveThreshold },
-                ...(currentContentHash !== undefined ? { contentHash: currentContentHash } : {}),
-                gate: gateLabel,
-            });
-            // Resolve the eligibilitySource: exploration-promoted proposals get
-            // eligibilitySource="exploration" (WS-4); normal auto-accepts carry
-            // whatever the proposal was tagged with at selection time.
+            const target = resolvedConfig.defaultWriteTarget;
             const resolvedEligibilitySource = isExploration
                 ? "exploration"
-                : promotion.proposal.eligibilitySource;
-            appendEvent({
-                eventType: "promoted",
-                ref: promotion.ref,
-                metadata: {
-                    proposalId: promotion.proposal.id,
-                    source: promotion.proposal.source,
-                    ...(promotion.proposal.sourceRun !== undefined ? { sourceRun: promotion.proposal.sourceRun } : {}),
-                    assetPath: promotion.assetPath,
+                : currentProposal?.eligibilitySource;
+            const promotion = await promoteFn(cfg.stashDir, resolvedConfig, proposalId, {
+                ...(target ? { target } : {}),
+                eventMetadata: {
                     autoAccept: true,
                     confidence,
                     threshold: effectiveThreshold,
                     phase: cfg.phase,
-                    // Attribution tagging: carry the eligibility lane from the proposal
-                    // record onto the auto-accept promoted event so the lane survives to
-                    // accept time even when promotion happens in a later run.
                     ...(resolvedEligibilitySource !== undefined ? { eligibilitySource: resolvedEligibilitySource } : {}),
-                    // WS-4: mark exploration promotions so health/telemetry can
-                    // distinguish them from calibration-signal promotions.
                     ...(isExploration ? { explorationBudget: true } : {}),
                 },
-            }, cfg.eventsCtx ?? {});
+            }, undefined);
+            stamp(promotion.proposal.id, {
+                outcome: "auto-accepted",
+                reason: promoteReason,
+                confidence,
+                thresholds: { autoAccept: effectiveThreshold },
+                ...(currentContentHash !== undefined ? { contentHash: currentContentHash } : {}),
+                gate: gateLabel,
+            });
             if (isExploration) {
                 info(`[improve] exploration-accepted ${promotion.ref} (${cfg.phase}; confidence=${confidence.toFixed(2)}; budgetRemaining=${explorationRemaining})`);
             }

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

@@ -11,8 +11,8 @@ import { getCacheDir } from "../../core/paths.js";
 import { redactSensitiveText } from "../../core/redaction.js";
 import { withStateDb } from "../../core/state-db.js";
 import { clearLogFile, setLogFile } from "../../core/warn.js";
+import { resolveWriteTarget } from "../../core/write-source.js";
 import { closeDatabase, openExistingDatabase } from "../../indexer/db/db.js";
-import { resolveSourceEntries } from "../../indexer/search/search-source.js";
 import { collectEngineCredentialValues } from "../../integrations/agent/engine-resolution.js";
 import { parseFlagValue } from "../../output/context.js";
 import { getActiveCanaries, queryRecentCycleMetrics } from "../../storage/repositories/canaries-repository.js";
@@ -176,6 +176,7 @@ export const improveCommand = defineCommand({
             const skipIfLocked = args["skip-if-locked"];
             const strategyArg = getStringArg(args, "strategy");
             const effectiveConfig = loadConfig();
+            const writeTarget = resolveWriteTarget(effectiveConfig, targetArg, { requireWritable: !dryRun });
             // Resolve every enabled model-backed process before logging, signal
             // lifecycle setup, or any filesystem/database side effect.
             const resolvedPlan = resolveImprovePlan(strategyArg, effectiveConfig);
@@ -202,7 +203,7 @@ export const improveCommand = defineCommand({
             // was minted at end-of-run, so SIGTERM'd runs (cron timeout) left no
             // row in improve_runs and effectively disappeared from `akm health`.
             const runId = buildImproveRunId();
-            const primaryStashDir = resolveSourceEntries(undefined, effectiveConfig)[0]?.path;
+            const primaryStashDir = writeTarget.source.path;
             const scopeArg = getStringArg(args, "scope");
             const inferredScopeMode = (scopeArg ?? "").includes(":") ? "ref" : scopeArg ? "type" : "all";
             // Signal handler + exception path both flow through this helper so
@@ -248,6 +249,7 @@ export const improveCommand = defineCommand({
                         dryRun,
                         resolvedPlan,
                         target: targetArg,
+                        writeTarget,
                         autoAccept,
                         ...(runId !== undefined ? { runId } : {}),
                         ...(limitRaw !== undefined ? { limit: limitRaw } : {}),

package/dist/commands/improve/improve-strategies.js

@@ -67,7 +67,8 @@ export function resolveImproveStrategy(name, config) {
         const valid = [...new Set([...Object.keys(BUILTIN_STRATEGIES), ...Object.keys(userStrategies)])].sort();
         throw new ConfigError(`Improve strategy "${selectedName}" not found. Valid strategies: ${valid.join(", ")}.`, "UNKNOWN_IMPROVE_STRATEGY");
     }
-    const baseStrategy = BUILTIN_STRATEGIES[selectedName] ?? BUILTIN_STRATEGIES.default;
+    const selectedStrategy = BUILTIN_STRATEGIES[selectedName] ?? {};
+    const baseStrategy = deepMergeConfig(BUILTIN_STRATEGIES.default, selectedStrategy);
     const resolved = deepMergeConfig(baseStrategy, (userStrategies[selectedName] ?? {}));
     return { name: selectedName, config: resolved };
 }

package/dist/commands/improve/improve.js

@@ -13,6 +13,7 @@ import { getDbPath, getStateDbPathInDataDir } from "../../core/paths.js";
 import { redactSensitiveText } from "../../core/redaction.js";
 import { openStateDatabase } from "../../core/state-db.js";
 import { info, warn } from "../../core/warn.js";
+import { resolveWritable, resolveWriteTarget } from "../../core/write-source.js";
 import { closeDatabase, getEntryCount, openExistingDatabase } from "../../indexer/db/db.js";
 import { ensureIndex } from "../../indexer/ensure-index.js";
 import { akmIndex } from "../../indexer/indexer.js";
@@ -21,7 +22,7 @@ import { collectEngineCredentialValues } from "../../integrations/agent/engine-r
 import { materializeLlmRunnerConnection } from "../../integrations/agent/runner.js";
 import { installLlmUsagePersistence } from "../../llm/usage-persist.js";
 import { withLlmStage } from "../../llm/usage-telemetry.js";
-import { isGitBackedStash, resolveWritableOverride, saveGitStash } from "../../sources/providers/git.js";
+import { isGitBackedStash, listGitChangedPaths, resolveWritableOverride, saveGitStash, } from "../../sources/providers/git.js";
 import { drainProposals } from "../proposal/drain.js";
 import { resolveDrainPolicy } from "../proposal/drain-policies.js";
 import { akmDistill } from "./distill.js";
@@ -41,6 +42,7 @@ import { runImprovePreparationStage } from "./preparation.js";
 import { DEFAULT_DUE_DAYS, filterProactiveDue } from "./proactive-maintenance.js";
 import { akmReflect } from "./reflect.js";
 import { errMessage } from "./shared.js";
+import { shouldReadLegacyBareImproveState } from "./source-identity.js";
 export { resetHeldProcessLocks } from "./locks.js";
 // Re-exported from ./loop-stages for test importers (improve-db-locking).
 export { runImproveMaintenancePasses } from "./loop-stages.js";
@@ -99,7 +101,14 @@ export async function akmImprove(options = {}) {
     const runImprovePostLoopStageImpl = options.runImprovePostLoopStageFn ?? runImprovePostLoopStage;
     // Resolve the improve profile for this run. Profile drives type filtering,
     // process gating, and default autoAccept/limit values.
-    const _earlyConfig = options.config ?? loadConfig();
+    let _earlyConfig = options.config ?? loadConfig();
+    const writeTarget = options.writeTarget ??
+        (options.target
+            ? resolveWriteTarget(_earlyConfig, options.target, { requireWritable: !options.dryRun })
+            : undefined);
+    if (writeTarget && options.target) {
+        _earlyConfig = { ..._earlyConfig, defaultWriteTarget: writeTarget.source.name };
+    }
     const resolvedPlan = options.resolvedPlan ??
         resolveImprovePlan(options.strategy, _earlyConfig, {
             repairValidationFailures: options.repairValidationFailures,
@@ -115,6 +124,20 @@ export async function akmImprove(options = {}) {
         // Pin nested calls and quality gates to the same config snapshot as the
         // invocation plan. They must never reload a changed config mid-run.
         config: _earlyConfig,
+        ...(writeTarget
+            ? {
+                target: writeTarget.source.name,
+                writeTarget,
+                stashDir: writeTarget.source.path,
+                consolidateOptions: {
+                    ...options.consolidateOptions,
+                    target: writeTarget.source.name,
+                    writeTarget,
+                },
+            }
+            : {}),
+        legacyBareState: options.legacyBareState ??
+            shouldReadLegacyBareImproveState(writeTarget?.source.name, writeTarget?.source.path, _earlyConfig),
         autoAccept: options.autoAccept ?? improveProfile.autoAccept,
         // Profile-level limit, then process-level reflect.limit as fallback.
         // CLI --limit takes precedence over both.
@@ -130,6 +153,8 @@ export async function akmImprove(options = {}) {
     catch {
         primaryStashDir = undefined;
     }
+    const syncRepoDir = writeTarget?.source.repoPath ?? primaryStashDir;
+    const initialGitPaths = syncRepoDir && isGitBackedStash(syncRepoDir) ? new Set(listGitChangedPaths(syncRepoDir)) : new Set();
     // C2 (#553/#554/#499): resolve the state.db path ONCE, synchronously, at the
     // command boundary — before the first `await` below. Every state.db open in
     // this run (`openStateDatabase`, every default-path `appendEvent`) is pinned
@@ -310,6 +335,8 @@ export async function akmImprove(options = {}) {
                             const maxAccepts = triageConfig?.maxAcceptsPerRun ?? 25;
                             triageDrain = await drainProposalsFn({
                                 stashDir: primaryStashDir,
+                                ...(options.target ? { target: options.target } : {}),
+                                config: options.config,
                                 policy,
                                 applyMode,
                                 maxAccepts,
@@ -412,15 +439,29 @@ export async function akmImprove(options = {}) {
     // after the db-backed context is installed inside the try use the live handle.
     const effectiveSync = { ...improveProfile.sync, ...options.sync };
     const commitStashBatch = (messageContext) => {
-        if (!primaryStashDir || effectiveSync.enabled === false || !isGitBackedStash(primaryStashDir)) {
+        const repoDir = writeTarget?.source.repoPath ?? primaryStashDir;
+        if (!primaryStashDir || !repoDir || effectiveSync.enabled === false || !isGitBackedStash(repoDir)) {
             return undefined;
         }
         const saveGitStashFn = options.saveGitStashFn ?? saveGitStash;
-        const writableOverride = resolveWritableOverride(_earlyConfig);
-        const push = effectiveSync.push !== false;
+        const writableOverride = writeTarget ? resolveWritable(writeTarget.config) : resolveWritableOverride(_earlyConfig);
+        const push = options.sync?.push ?? writeTarget?.config.options?.pushOnCommit ?? improveProfile.sync?.push ?? true;
         const message = renderSyncCommitMessage(effectiveSync.message ?? "akm improve auto-sync", messageContext, Date.now());
         try {
-            const syncResult = saveGitStashFn(undefined, message, writableOverride, { push, repoDir: primaryStashDir });
+            const assetRoot = writeTarget?.source.path ?? primaryStashDir;
+            const assetPrefix = assetRoot ? path.relative(repoDir, assetRoot).replaceAll(path.sep, "/") : "";
+            const paths = listGitChangedPaths(repoDir).filter((changedPath) => {
+                if (initialGitPaths.has(changedPath))
+                    return false;
+                if (path.basename(changedPath).includes(".lock"))
+                    return false;
+                return !assetPrefix || changedPath === assetPrefix || changedPath.startsWith(`${assetPrefix}/`);
+            });
+            const syncResult = saveGitStashFn(undefined, message, writableOverride, {
+                push,
+                repoDir,
+                paths,
+            });
             appendEvent({
                 eventType: "stash_synced",
                 metadata: {
@@ -621,8 +662,8 @@ export async function akmImprove(options = {}) {
                 let postLockLoopRefs = preparation.loopRefs;
                 if (proactiveLoopRefs.length > 0) {
                     const proactiveRefStrs = proactiveLoopRefs.map((r) => r.ref);
-                    const freshReflectTs = buildLatestProposalTsMap(proactiveRefStrs, "reflect");
-                    const freshDistillTs = buildLatestProposalTsMap(proactiveRefStrs, "distill");
+                    const freshReflectTs = buildLatestProposalTsMap(proactiveRefStrs, "reflect", options.target, options.legacyBareState);
+                    const freshDistillTs = buildLatestProposalTsMap(proactiveRefStrs, "distill", options.target, options.legacyBareState);
                     const pmDueDays = improveProfile.processes?.proactiveMaintenance?.dueDays ?? DEFAULT_DUE_DAYS;
                     const stillDue = new Set(filterProactiveDue(proactiveLoopRefs, freshReflectTs, freshDistillTs, pmDueDays, Date.now()).map((r) => r.ref));
                     const dropped = proactiveLoopRefs.filter((r) => !stillDue.has(r.ref));

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

@@ -38,6 +38,7 @@ import { akmProcedural } from "./procedural.js";
 import { akmRecombine } from "./recombine.js";
 import { recordNoOp, resetConsecutiveNoOps } from "./salience.js";
 import { errMessage, refSlug } from "./shared.js";
+import { durableImproveRef } from "./source-identity.js";
 // ── improve loop / post-loop / maintenance stages ───────────────────
 // The cycle stages run by akmImprove, extracted from improve.ts.
 export async function runImproveLoopStage(args) {
@@ -210,11 +211,13 @@ export async function runImproveLoopStage(args) {
                     const reflectProfileRunner = resolvedPlan.processes.reflect.runner;
                     const reflectCallArgs = {
                         ref: planned.ref,
+                        ...(options.target ? { sourceName: options.target } : {}),
+                        ...(options.legacyBareState ? { legacyBareState: true } : {}),
                         task: options.task,
                         // Active strategy supplies non-engine process tuning.
                         ...(improveProfile ? { improveProfile } : {}),
                         config: options.config,
-                        ...(options.stashDir ? { stashDir: options.stashDir } : {}),
+                        ...(primaryStashDir ? { stashDir: primaryStashDir } : {}),
                         ...(reflectErrors.length > 0 ? { avoidPatterns: [...reflectErrors] } : {}),
                         eventSource: "improve",
                         // #639 — resolve the low-value filter from the ACTIVE improve profile
@@ -347,7 +350,7 @@ export async function runImproveLoopStage(args) {
                     // the asset changed; reset the counter so the dampener lifts.
                     if (isNoChange && eventsCtx?.db) {
                         try {
-                            recordNoOp(eventsCtx.db, planned.ref);
+                            recordNoOp(eventsCtx.db, durableImproveRef(planned.ref, options.target));
                         }
                         catch {
                             // best-effort: plasticity counter failure never blocks the run
@@ -355,7 +358,7 @@ export async function runImproveLoopStage(args) {
                     }
                     else if (reflectResult.ok && eventsCtx?.db) {
                         try {
-                            resetConsecutiveNoOps(eventsCtx.db, planned.ref);
+                            resetConsecutiveNoOps(eventsCtx.db, durableImproveRef(planned.ref, options.target));
                         }
                         catch {
                             // best-effort
@@ -482,8 +485,10 @@ export async function runImproveLoopStage(args) {
                 }
                 const distillResult = await withLlmStage("distill", () => distillFn({
                     ref: planned.ref,
+                    ...(options.target ? { sourceName: options.target } : {}),
+                    ...(options.legacyBareState ? { legacyBareState: true } : {}),
                     ...(parsedPlannedRef.type === "memory" ? { proposalKind: "auto" } : {}),
-                    ...(options.stashDir ? { stashDir: options.stashDir } : {}),
+                    ...(primaryStashDir ? { stashDir: primaryStashDir } : {}),
                     // Active profile so distill's per-process reads honor `--profile`.
                     ...(improveProfile ? { improveProfile } : {}),
                     config: options.config,
@@ -512,10 +517,10 @@ export async function runImproveLoopStage(args) {
                 if (eventsCtx?.db) {
                     try {
                         if (distillResult.outcome === "quality_rejected" || distillResult.outcome === "skipped") {
-                            recordNoOp(eventsCtx.db, planned.ref);
+                            recordNoOp(eventsCtx.db, durableImproveRef(planned.ref, options.target));
                         }
                         else if (distillResult.outcome === "queued") {
-                            resetConsecutiveNoOps(eventsCtx.db, planned.ref);
+                            resetConsecutiveNoOps(eventsCtx.db, durableImproveRef(planned.ref, options.target));
                         }
                     }
                     catch {

package/dist/commands/improve/preparation.js

@@ -31,7 +31,19 @@ import { makeGateConfig, resolveExtractConfidence, runAutoAcceptGate } from "./i
 import { applyMemoryCleanup } from "./memory/memory-improve.js";
 import { computeProxyAdequacy, getAllAssetOutcomes, getOutcomeScoresByRef, OUTCOME_SCORE_MAX, outcomeScoreToSalience, updateAssetOutcome, } from "./outcome-loop.js";
 import { DEFAULT_DUE_DAYS, DEFAULT_MAX_PER_RUN, selectProactiveMaintenanceRefs } from "./proactive-maintenance.js";
-import { buildRankChangeReport, computeSalience, getAllRankScores, getAssetSalience, getConsecutiveNoOps, getLastUseMsByRef, isContentEncodingRow, SALIENCE_NO_OP_DAMPEN_FACTOR, SALIENCE_NO_OP_DAMPEN_THRESHOLD, upsertAssetSalience, } from "./salience.js";
+import { buildRankChangeReport, computeSalience, getAllRankScores, getAssetSalience, getLastUseMsByRef, isContentEncodingRow, SALIENCE_NO_OP_DAMPEN_FACTOR, SALIENCE_NO_OP_DAMPEN_THRESHOLD, upsertAssetSalience, } from "./salience.js";
+import { bareImproveRef, durableImproveRef, improveStateReadRefs } from "./source-identity.js";
+function readAssetSalienceForImproveRef(db, ref, sourceName, includeLegacyBare = false) {
+    for (const key of improveStateReadRefs(ref, sourceName, includeLegacyBare)) {
+        const row = getAssetSalience(db, key);
+        if (row)
+            return row;
+    }
+    return undefined;
+}
+function readConsecutiveNoOpsForImproveRef(db, ref, sourceName, includeLegacyBare = false) {
+    return readAssetSalienceForImproveRef(db, ref, sourceName, includeLegacyBare)?.consecutive_no_ops ?? 0;
+}
 // ── improve preparation stage ───────────────────────
 // The pre-loop preparation pipeline (consolidation, session-extract, validation/
 // repair, eligibility partitioning, selectors) extracted from improve.ts.
@@ -814,9 +826,9 @@ export async function runImprovePreparationStage(args) {
     // Per-ref queries would be N+1 and the planner is already the hottest path
     // in `akm improve`.
     const candidateRefs = postCleanupRefs.filter((r) => !validationFailureRefs.has(r.ref)).map((r) => r.ref);
-    const latestFeedbackTs = buildLatestFeedbackTsMap(candidateRefs, feedbackSinceCutoff);
-    const lastReflectProposalTs = buildLatestProposalTsMap(candidateRefs, "reflect");
-    const lastDistillProposalTs = buildLatestProposalTsMap(candidateRefs, "distill");
+    const latestFeedbackTs = buildLatestFeedbackTsMap(candidateRefs, feedbackSinceCutoff, options.target, options.legacyBareState);
+    const lastReflectProposalTs = buildLatestProposalTsMap(candidateRefs, "reflect", options.target, options.legacyBareState);
+    const lastDistillProposalTs = buildLatestProposalTsMap(candidateRefs, "distill", options.target, options.legacyBareState);
     // Refs the distill signal-delta gate rejected at planning time. The main
     // loop reads this to skip distill for these refs without re-checking
     // eligibility per iteration.
@@ -951,15 +963,17 @@ export async function runImprovePreparationStage(args) {
     // to feedbackSinceCutoff (same as the old inline `(e.ts ?? "") >= cutoff` guard).
     const feedbackSummary = new Map();
     {
-        const feedbackCandidateSet = new Set([...processableRefs, ...noFeedbackPool].map((r) => r.ref));
+        const feedbackCandidateRefs = [...processableRefs, ...noFeedbackPool].map((r) => r.ref);
+        const feedbackCandidateSet = new Set(feedbackCandidateRefs);
+        const feedbackRefByDurableKey = new Map(feedbackCandidateRefs.flatMap((ref) => improveStateReadRefs(ref, options.target, options.legacyBareState).map((key) => [key, ref])));
         if (feedbackCandidateSet.size > 0) {
             // Fetch ALL feedback events in one query (no ref filter, no since filter =
             // single full table scan). Filtering per-ref in memory avoids N sequential
             // state.db opens — the dominant FD-leak path on large stashes.
             const { events: allFeedbackEvents } = readEvents({ type: "feedback" }, eventsCtx);
             for (const e of allFeedbackEvents) {
-                const ref = e.ref;
-                if (!ref || !feedbackCandidateSet.has(ref))
+                const ref = e.ref ? feedbackRefByDurableKey.get(e.ref) : undefined;
+                if (!ref)
                     continue;
                 const entry = feedbackSummary.get(ref) ?? { hasSignal: false, positive: 0, negative: 0 };
                 const meta = e.metadata;
@@ -1021,8 +1035,12 @@ export async function runImprovePreparationStage(args) {
         // heavily-retrieved, one never-touched — would receive identical rankScores.
         // Fix (WS-1 blocker 3): union the feedback pool into the lookup.
         const allCandidateRefs = [...new Set([...signalFiltered, ...noFeedbackCandidates].map((r) => r.ref))];
-        retrievalCounts = getRetrievalCounts(dbForRetrieval, allCandidateRefs);
-        lastUseMsForProactive = getLastUseMsByRef(dbForRetrieval, noFeedbackCandidates.map((r) => r.ref));
+        retrievalCounts = getRetrievalCounts(dbForRetrieval, allCandidateRefs, {
+            sourceName: options.target,
+            stashDir: primaryStashDir,
+            includeLegacyBare: options.legacyBareState || !options.target,
+        });
+        lastUseMsForProactive = getLastUseMsByRef(dbForRetrieval, noFeedbackCandidates.map((r) => r.ref), primaryStashDir);
         // High-retrieval signal-delta (simplified rule, 0.8.0): a no-feedback
         // ref qualifies exactly once — when it has actually been retrieved
         // (retrievalCount ≥ 1) AND retrievalCount ≥ threshold AND no prior reflect
@@ -1160,7 +1178,7 @@ export async function runImprovePreparationStage(args) {
             // found later in the scan lost its slot to an earlier lower-scoring one.
             const qualifying = [];
             for (const r of candidates) {
-                const row = getAssetSalience(dbForHighSalience, r.ref);
+                const row = readAssetSalienceForImproveRef(dbForHighSalience, r.ref, options.target, options.legacyBareState);
                 if (row &&
                     isContentEncodingRow(row, parseAssetRef(r.ref).type) &&
                     row.encoding_salience >= salienceThreshold &&
@@ -1283,7 +1301,7 @@ export async function runImprovePreparationStage(args) {
     let dbForSalience;
     try {
         dbForSalience = openExistingDatabase();
-        lastUseMsByRef = getLastUseMsByRef(dbForSalience, mergedRefs.map((r) => r.ref));
+        lastUseMsByRef = getLastUseMsByRef(dbForSalience, mergedRefs.map((r) => r.ref), primaryStashDir);
     }
     catch (err) {
         rethrowIfTestIsolationError(err);
@@ -1439,7 +1457,7 @@ export async function runImprovePreparationStage(args) {
         withStateDb((dbForStoredEncoding) => {
             for (const r of mergedRefs) {
                 const type = r.ref.includes(":") ? r.ref.slice(0, r.ref.indexOf(":")) : "";
-                const row = getAssetSalience(dbForStoredEncoding, r.ref);
+                const row = readAssetSalienceForImproveRef(dbForStoredEncoding, r.ref, options.target, options.legacyBareState);
                 if (row && isContentEncodingRow(row, type)) {
                     storedEncodingByRef.set(r.ref, row.encoding_salience);
                 }
@@ -1532,7 +1550,15 @@ export async function runImprovePreparationStage(args) {
             // Step 7: stash-wide rank-change report BEFORE overwriting the table.
             //
             // Load ALL existing rows so rank positions are stash-relative, not pool-relative.
-            const existingAllScores = getAllRankScores(stateDb);
+            const allStoredScores = getAllRankScores(stateDb);
+            const existingAllScores = options.target
+                ? new Map([...allStoredScores].flatMap(([ref, score]) => {
+                    const parsed = parseAssetRef(ref);
+                    return parsed.origin === options.target || (options.legacyBareState && !parsed.origin)
+                        ? [[bareImproveRef(ref), score]]
+                        : [];
+                }))
+                : allStoredScores;
             if (existingAllScores.size === 0) {
                 // Scenario A: first WS-1 run — table empty.
                 //
@@ -1629,7 +1655,7 @@ export async function runImprovePreparationStage(args) {
                 }, eventsCtx);
             }
             for (const [ref, vector] of salienceMap) {
-                upsertAssetSalience(stateDb, ref, vector, nowForSalience);
+                upsertAssetSalience(stateDb, durableImproveRef(ref, options.target), vector, nowForSalience);
             }
         }, { path: eventsCtx?.dbPath });
     }
@@ -1715,7 +1741,15 @@ export async function runImprovePreparationStage(args) {
         try {
             withStateDb((replayDb) => {
                 const alreadyInPool = new Set(mergedRefs.map((r) => r.ref));
-                const allRankScores = getAllRankScores(replayDb);
+                const storedRankScores = getAllRankScores(replayDb);
+                const allRankScores = options.target
+                    ? new Map([...storedRankScores].flatMap(([ref, score]) => {
+                        const parsed = parseAssetRef(ref);
+                        return parsed.origin === options.target || (options.legacyBareState && !parsed.origin)
+                            ? [[bareImproveRef(ref), score]]
+                            : [];
+                    }))
+                    : storedRankScores;
                 // Candidate universe = every salience row NOT already in the pool, ordered by
                 // rank_score desc with a deterministic ref-string tie-break (mirrors the main
                 // sort). Converged refs (consecutive_no_ops >= dampener threshold) are fully
@@ -1725,7 +1759,7 @@ export async function runImprovePreparationStage(args) {
                 for (const [ref, rankScore] of allRankScores) {
                     if (alreadyInPool.has(ref))
                         continue;
-                    const noOps = getConsecutiveNoOps(replayDb, ref);
+                    const noOps = readConsecutiveNoOpsForImproveRef(replayDb, ref, options.target, options.legacyBareState);
                     if (noOps >= SALIENCE_NO_OP_DAMPEN_THRESHOLD) {
                         convergedSkipped++;
                         continue;
@@ -1802,7 +1836,7 @@ export async function runImprovePreparationStage(args) {
             const ownsNoOpDb = !eventsCtx?.db;
             try {
                 for (const r of mergedRefs) {
-                    noOpMap.set(r.ref, getConsecutiveNoOps(noOpDb, r.ref));
+                    noOpMap.set(r.ref, readConsecutiveNoOpsForImproveRef(noOpDb, r.ref, options.target, options.legacyBareState));
                 }
             }
             finally {