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

package/dist/commands/improve/locks.js

@@ -6,37 +6,22 @@ import path from "node:path";
 import { ConfigError } from "../../core/errors.js";
 import { appendEvent } from "../../core/events.js";
 import { createLockPayload, probeLock, reclaimStaleLock, releaseLock, tryAcquireLockSync, } from "../../core/file-lock.js";
-import { withMaintenanceStartBarrier } from "../../core/maintenance-barrier.js";
+import { tryWithMaintenanceStartBarrier, withMaintenanceStartBarrier } from "../../core/maintenance-barrier.js";
 import { warn } from "../../core/warn.js";
-// #607 Lock Decomposition: fine-grained per-process locks replace the single
-// `improve.lock`. Three independent locks allow concurrent improve runs when
-// they touch different subsystems (e.g. quick-shredder consolidate can run
-// alongside daily reflect+distill).
-//
-//   consolidate.lock   — protects consolidate + memoryInference (both write index.db)
-//   reflect-distill.lock — protects reflect + distill (both write state.db proposals)
-//   triage.lock         — protects triage (writes proposal promotions)
-//
-// Stale timeouts are per-lock, tuned to the expected runtime of the protected
-// processes: consolidate is disk-bound (1h), reflect+distill is GPU-bound (2h),
-// triage is fast (30min).
-export const PROCESS_LOCK_DEFS = {
-    consolidate: { fileName: "consolidate.lock", staleAfterMs: 60 * 60 * 1000 },
-    reflectDistill: { fileName: "reflect-distill.lock", staleAfterMs: 2 * 60 * 60 * 1000 },
-    triage: { fileName: "triage.lock", staleAfterMs: 30 * 60 * 1000 },
-};
-const heldProcessLocks = new Set();
-export function resetHeldProcessLocks() {
-    heldProcessLocks.clear();
+export const MIN_IMPROVE_LOCK_STALE_MS = 4 * 60 * 60 * 1000;
+export function improveLockPath(lockBaseDir) {
+    return path.join(lockBaseDir, "improve.lock");
 }
-export function processLockPath(lockBaseDir, lockName) {
-    return path.join(lockBaseDir, PROCESS_LOCK_DEFS[lockName].fileName);
-}
-export function tryAcquireProcessLock(lockPath, staleAfterMs, skipIfLocked, lockLabel) {
+export function tryAcquireImproveLock(lockPath, staleAfterMs, skipIfLocked) {
     let recoveryEvent;
-    const result = withMaintenanceStartBarrier(() => tryAcquireProcessLockUnlocked(lockPath, staleAfterMs, skipIfLocked, lockLabel, (event) => {
+    const acquire = () => tryAcquireImproveLockUnlocked(lockPath, staleAfterMs, skipIfLocked, (event) => {
         recoveryEvent = event;
-    }));
+    });
+    const result = skipIfLocked ? tryWithMaintenanceStartBarrier(acquire) : withMaintenanceStartBarrier(acquire);
+    if (!result) {
+        warn("[improve] maintenance barrier held; skipping (--skip-if-locked)");
+        return { state: "skipped" };
+    }
     if (recoveryEvent) {
         try {
             appendEvent(recoveryEvent);
@@ -47,12 +32,11 @@ export function tryAcquireProcessLock(lockPath, staleAfterMs, skipIfLocked, lock
     }
     return result;
 }
-function tryAcquireProcessLockUnlocked(lockPath, staleAfterMs, skipIfLocked, lockLabel, onRecovered) {
+function tryAcquireImproveLockUnlocked(lockPath, staleAfterMs, skipIfLocked, onRecovered) {
     fs.mkdirSync(path.dirname(lockPath), { recursive: true });
     const lockPayload = () => createLockPayload({ startedAt: new Date().toISOString() });
     let ownership = tryAcquireLockSync(lockPath, lockPayload());
     if (ownership) {
-        heldProcessLocks.add(ownership);
         return { state: "acquired", ownership };
     }
     const probe = probeLock(lockPath, { staleAfterMs });
@@ -64,7 +48,6 @@ function tryAcquireProcessLockUnlocked(lockPath, staleAfterMs, skipIfLocked, loc
     if (probe.state === "absent") {
         ownership = tryAcquireLockSync(lockPath, lockPayload());
         if (ownership) {
-            heldProcessLocks.add(ownership);
             return { state: "acquired", ownership };
         }
         // Re-grabbed by another racer in the window — fall through and treat as held.
@@ -83,15 +66,15 @@ function tryAcquireProcessLockUnlocked(lockPath, staleAfterMs, skipIfLocked, loc
     if (probe.state === "stale") {
         if (!reclaimStaleLock(lockPath, probe)) {
             if (skipIfLocked) {
-                warn(`[improve] ${lockLabel} lock changed ownership during stale recovery; skipping (--skip-if-locked)`);
+                warn("[improve] lock changed ownership during stale recovery; skipping (--skip-if-locked)");
                 return { state: "skipped" };
             }
-            throw new ConfigError(`akm improve ${lockLabel} is already running. Delete ${lockPath} to force.`, "INVALID_CONFIG_FILE");
+            throw new ConfigError(`akm improve is already running. Delete ${lockPath} to force.`, "INVALID_CONFIG_FILE");
         }
         onRecovered({
             eventType: "improve_lock_recovered",
             metadata: {
-                lockName: lockLabel,
+                lockName: "improve",
                 stalePid: lock?.pid ?? null,
                 lockedAt: lock?.startedAt ?? null,
                 recoveredAt: new Date().toISOString(),
@@ -101,75 +84,20 @@ function tryAcquireProcessLockUnlocked(lockPath, staleAfterMs, skipIfLocked, loc
         });
         ownership = tryAcquireLockSync(lockPath, lockPayload());
         if (ownership) {
-            heldProcessLocks.add(ownership);
             return { state: "acquired", ownership };
         }
         if (skipIfLocked) {
-            warn(`[improve] ${lockLabel} lock acquired by another run during stale recovery; skipping (--skip-if-locked)`);
+            warn("[improve] lock acquired by another run during stale recovery; skipping (--skip-if-locked)");
             return { state: "skipped" };
         }
-        throw new ConfigError(`akm improve ${lockLabel} is already running. Delete ${lockPath} to force.`, "INVALID_CONFIG_FILE");
+        throw new ConfigError(`akm improve is already running. Delete ${lockPath} to force.`, "INVALID_CONFIG_FILE");
     }
     if (skipIfLocked) {
-        warn(`[improve] ${lockLabel} lock held by another run (PID ${lock?.pid}, started ${lock?.startedAt}); skipping (--skip-if-locked)`);
+        warn(`[improve] another improve run holds the lock (PID ${lock?.pid}, started ${lock?.startedAt}); skipping (--skip-if-locked)`);
         return { state: "skipped" };
     }
-    throw new ConfigError(`akm improve ${lockLabel} is already running (PID ${lock?.pid}, started ${lock?.startedAt}). Delete ${lockPath} to force.`, "INVALID_CONFIG_FILE");
-}
-export function releaseProcessLock(ownership) {
-    if (!heldProcessLocks.has(ownership))
-        return;
-    try {
-        releaseLock(ownership);
-    }
-    finally {
-        heldProcessLocks.delete(ownership);
-    }
-}
-export function releaseAllProcessLocks() {
-    for (const ownership of heldProcessLocks) {
-        try {
-            releaseLock(ownership);
-        }
-        catch {
-            // ignore
-        }
-    }
-    heldProcessLocks.clear();
+    throw new ConfigError(`akm improve is already running (PID ${lock?.pid}, started ${lock?.startedAt}). Delete ${lockPath} to force.`, "INVALID_CONFIG_FILE");
 }
-/**
- * Ownership-safe release of every currently-held lock, for the `process.on("exit")`
- * backstop (signal handler / budget watchdog paths that skip the normal finally).
- * Uses exact ownership handles so a lock legitimately re-acquired after stale
- * recovery is never deleted. Does NOT clear the Set (the process is exiting).
- */
-export function releaseHeldLocksIfOwned() {
-    for (const ownership of heldProcessLocks) {
-        releaseLock(ownership);
-    }
-}
-/**
- * RAII for the "best-effort stage" lock pattern: acquire the lock if available,
- * run `body` REGARDLESS of acquisition, and release the lock in a `finally` iff
- * we acquired it (on both the normal and the throw path). This makes
- * release-on-throw LOCAL instead of relying on a distant outer catch.
- *
- * Behaviour matches the hand-rolled `acquired = tryAcquire(...) === "acquired";
- * …run stage…; if (acquired) release` idiom it replaces:
- *   - When the lock is held and `skipIfLocked` is set, `tryAcquireProcessLock`
- *     returns `state: "skipped"` → the stage still runs (unlocked), nothing to release.
- *   - When the lock is held and `skipIfLocked` is NOT set, `tryAcquireProcessLock`
- *     throws (propagated here before `body` runs; nothing acquired, nothing released).
- *   - The process-exit backstop (`releaseHeldLocksIfOwned`) still covers a
- *     `process.exit` that skips this `finally`.
- */
-export async function withOptionalProcessLock(opts, body) {
-    const acquisition = tryAcquireProcessLock(opts.lockPath, opts.staleAfterMs, opts.skipIfLocked, opts.label);
-    try {
-        return await body();
-    }
-    finally {
-        if (acquisition.state === "acquired")
-            releaseProcessLock(acquisition.ownership);
-    }
+export function releaseImproveLock(ownership) {
+    releaseLock(ownership);
 }

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

@@ -42,7 +42,7 @@ 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) {
-    const { scope, options, primaryStashDir, reflectFn, distillFn, loopRefs, actions, signalBearingSet, distillCooledRefs, distillOnlyRefs, recentErrors, rejectedProposalsByRef, utilityMap, startMs, budgetMs, eventsCtx, improveProfile, resolvedPlan, } = args;
+    const { scope, options, primaryStashDir, reflectFn, distillFn, loopRefs, actions, signalBearingSet, distillCooledRefs, distillOnlyRefs, recentErrors, rejectedProposalsByRef, utilityMap, startMs, budgetMs, eventsCtx, improveProfile, resolvedPlan, budgetSignal, } = args;
     // O-1 (#364): compute remaining budget at call time so each sub-call
     // receives only its fair share of the wall-clock budget.
     const remainingBudgetMs = () => Math.max(0, budgetMs - (Date.now() - startMs));
@@ -136,6 +136,7 @@ export async function runImproveLoopStage(args) {
         stashDir: primaryStashDir,
         config: options.config ?? loadConfig(),
         eventsCtx,
+        targetSelector: options.target,
         stateDbPath: eventsCtx?.dbPath,
         // candidateCount drives the exploration budget. loopRefs is the per-phase
         // set for reflect/distill; pass it so exploration budget is proportional.
@@ -147,6 +148,7 @@ export async function runImproveLoopStage(args) {
         stashDir: primaryStashDir,
         config: options.config ?? loadConfig(),
         eventsCtx,
+        targetSelector: options.target,
         stateDbPath: eventsCtx?.dbPath,
         candidateCount: loopRefs.length,
     });
@@ -211,7 +213,7 @@ export async function runImproveLoopStage(args) {
                     const reflectProfileRunner = resolvedPlan.processes.reflect.runner;
                     const reflectCallArgs = {
                         ref: planned.ref,
-                        ...(options.target ? { sourceName: options.target } : {}),
+                        ...(options.sourceName ? { sourceName: options.sourceName } : {}),
                         ...(options.legacyBareState ? { legacyBareState: true } : {}),
                         task: options.task,
                         // Active strategy supplies non-engine process tuning.
@@ -224,6 +226,7 @@ export async function runImproveLoopStage(args) {
                         // (default off when unset), so the running strategy decides.
                         lowValueFilter: improveProfile.processes?.reflect?.lowValueFilter?.enabled === true,
                         ...(reflectBudgetMs > 0 ? { timeoutMs: reflectBudgetMs } : {}),
+                        signal: budgetSignal,
                         runner: reflectProfileRunner ?? null,
                         // Attribution: carry the eligibility lane so reflect stamps it on
                         // the reflect_invoked event and the persisted proposal.
@@ -350,7 +353,7 @@ export async function runImproveLoopStage(args) {
                     // the asset changed; reset the counter so the dampener lifts.
                     if (isNoChange && eventsCtx?.db) {
                         try {
-                            recordNoOp(eventsCtx.db, durableImproveRef(planned.ref, options.target));
+                            recordNoOp(eventsCtx.db, durableImproveRef(planned.ref, options.sourceName));
                         }
                         catch {
                             // best-effort: plasticity counter failure never blocks the run
@@ -358,7 +361,7 @@ export async function runImproveLoopStage(args) {
                     }
                     else if (reflectResult.ok && eventsCtx?.db) {
                         try {
-                            resetConsecutiveNoOps(eventsCtx.db, durableImproveRef(planned.ref, options.target));
+                            resetConsecutiveNoOps(eventsCtx.db, durableImproveRef(planned.ref, options.sourceName));
                         }
                         catch {
                             // best-effort
@@ -485,7 +488,7 @@ export async function runImproveLoopStage(args) {
                 }
                 const distillResult = await withLlmStage("distill", () => distillFn({
                     ref: planned.ref,
-                    ...(options.target ? { sourceName: options.target } : {}),
+                    ...(options.sourceName ? { sourceName: options.sourceName } : {}),
                     ...(options.legacyBareState ? { legacyBareState: true } : {}),
                     ...(parsedPlannedRef.type === "memory" ? { proposalKind: "auto" } : {}),
                     ...(primaryStashDir ? { stashDir: primaryStashDir } : {}),
@@ -495,6 +498,7 @@ export async function runImproveLoopStage(args) {
                     llmConfig: resolvedPlan.processes.distill.runner
                         ? materializeLlmRunnerConnection(resolvedPlan.processes.distill.runner)
                         : null,
+                    signal: budgetSignal,
                     // Attribution: carry the eligibility lane so distill stamps it on the
                     // distill_invoked event and the persisted proposal.
                     ...(planned.eligibilitySource ? { eligibilitySource: planned.eligibilitySource } : {}),
@@ -517,10 +521,10 @@ export async function runImproveLoopStage(args) {
                 if (eventsCtx?.db) {
                     try {
                         if (distillResult.outcome === "quality_rejected" || distillResult.outcome === "skipped") {
-                            recordNoOp(eventsCtx.db, durableImproveRef(planned.ref, options.target));
+                            recordNoOp(eventsCtx.db, durableImproveRef(planned.ref, options.sourceName));
                         }
                         else if (distillResult.outcome === "queued") {
-                            resetConsecutiveNoOps(eventsCtx.db, durableImproveRef(planned.ref, options.target));
+                            resetConsecutiveNoOps(eventsCtx.db, durableImproveRef(planned.ref, options.sourceName));
                         }
                     }
                     catch {
@@ -652,8 +656,7 @@ export async function runImprovePostLoopStage(args) {
         }
     }
     // #609 — recombine / synthesize pass. Whole-corpus cross-episodic
-    // generalization. Runs in the post-loop stage under consolidate.lock (it
-    // reads the consolidated corpus and writes proposals). Opt-in: gated on the
+    // generalization. Runs in the post-loop stage under the whole-run lock. Opt-in: gated on the
     // `recombine` process being enabled, whole-stash / type scope (never `ref`),
     // and not a dry run. Mirrors the proactiveMaintenance opt-in wiring.
     let recombination;
@@ -773,6 +776,8 @@ export async function runImproveMaintenancePasses(args) {
     const { options, primaryStashDir, memoryRefsForInference, allWarnings, reindexFn, consolidationRan, budgetSignal, eventsCtx, improveProfile, resolvedPlan, } = args;
     if (!primaryStashDir)
         return { memoryInferenceDurationMs: 0, graphExtractionDurationMs: 0 };
+    if (budgetSignal?.aborted)
+        return { memoryInferenceDurationMs: 0, graphExtractionDurationMs: 0 };
     const config = options.config ?? loadConfig();
     const sources = resolveSourceEntries(options.stashDir, config);
     const memoryInferenceFn = options.memoryInferenceFn ?? runMemoryInferencePass;
@@ -799,7 +804,7 @@ export async function runImproveMaintenancePasses(args) {
             db = undefined;
         }
         try {
-            await reindexFn({ stashDir });
+            await reindexFn({ stashDir, signal: budgetSignal });
         }
         finally {
             db = openIndexDb();

package/dist/commands/improve/preparation.js

@@ -283,6 +283,7 @@ export async function runConsolidationPass(args) {
         stashDir: primaryStashDir,
         config: consolidationConfig,
         eventsCtx,
+        targetSelector: options.target,
         stateDbPath: eventsCtx?.dbPath,
     }, { minimumThreshold: 95 });
     if (consolidateDisabledByProfile) {
@@ -413,7 +414,7 @@ export async function runConsolidationPass(args) {
  * consolidation pass and accumulated here.
  */
 async function runSessionExtractPass(args) {
-    const { options, primaryStashDir, improveProfile, resolvedPlan, eventsCtx, seedGateAccepted, seedGateFailed } = args;
+    const { options, primaryStashDir, improveProfile, resolvedPlan, eventsCtx, budgetSignal, seedGateAccepted, seedGateFailed, } = args;
     const warnings = [];
     // Phase 0.4 — session-extract pass.
     //
@@ -446,6 +447,7 @@ async function runSessionExtractPass(args) {
         stashDir: primaryStashDir,
         config: extractConfig,
         eventsCtx,
+        targetSelector: options.target,
         stateDbPath: eventsCtx?.dbPath,
     });
     // #554 minNewSessions gate: skip the entire extract pass (ensureIndex was
@@ -525,6 +527,7 @@ async function runSessionExtractPass(args) {
                         config: extractConfig,
                         resolvedPlan: extractPlan,
                         dryRun: options.dryRun ?? false,
+                        signal: budgetSignal,
                         ...(options.extractHarnesses ? { harnesses: options.extractHarnesses } : {}),
                         // C2: pin extract's skip-tracking state.db open to the boundary path.
                         ...(eventsCtx?.dbPath ? { stateDbPath: eventsCtx.dbPath } : {}),
@@ -699,6 +702,7 @@ export async function runImprovePreparationStage(args) {
         improveProfile,
         resolvedPlan,
         eventsCtx,
+        budgetSignal,
         seedGateAccepted: consolidationPass.gateAutoAcceptedCount,
         seedGateFailed: consolidationPass.gateAutoAcceptFailedCount,
     });
@@ -746,7 +750,7 @@ export async function runImprovePreparationStage(args) {
         }
         if ((appliedCleanup.archived.length > 0 || appliedCleanup.beliefStateTransitions.length > 0) && primaryStashDir) {
             try {
-                await reindexFn({ stashDir: primaryStashDir });
+                await reindexFn({ stashDir: primaryStashDir, signal: budgetSignal });
             }
             catch (err) {
                 cleanupWarnings.push(`reindex after cleanup failed: ${err instanceof Error ? err.message : String(err)}`);
@@ -826,9 +830,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, options.target, options.legacyBareState);
-    const lastReflectProposalTs = buildLatestProposalTsMap(candidateRefs, "reflect", options.target, options.legacyBareState);
-    const lastDistillProposalTs = buildLatestProposalTsMap(candidateRefs, "distill", options.target, options.legacyBareState);
+    const latestFeedbackTs = buildLatestFeedbackTsMap(candidateRefs, feedbackSinceCutoff, options.sourceName, options.legacyBareState);
+    const lastReflectProposalTs = buildLatestProposalTsMap(candidateRefs, "reflect", options.sourceName, options.legacyBareState);
+    const lastDistillProposalTs = buildLatestProposalTsMap(candidateRefs, "distill", options.sourceName, 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.
@@ -965,7 +969,7 @@ export async function runImprovePreparationStage(args) {
     {
         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])));
+        const feedbackRefByDurableKey = new Map(feedbackCandidateRefs.flatMap((ref) => improveStateReadRefs(ref, options.sourceName, 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
@@ -1036,9 +1040,9 @@ export async function runImprovePreparationStage(args) {
         // 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, {
-            sourceName: options.target,
+            sourceName: options.sourceName,
             stashDir: primaryStashDir,
-            includeLegacyBare: options.legacyBareState || !options.target,
+            includeLegacyBare: options.legacyBareState,
         });
         lastUseMsForProactive = getLastUseMsByRef(dbForRetrieval, noFeedbackCandidates.map((r) => r.ref), primaryStashDir);
         // High-retrieval signal-delta (simplified rule, 0.8.0): a no-feedback
@@ -1178,7 +1182,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 = readAssetSalienceForImproveRef(dbForHighSalience, r.ref, options.target, options.legacyBareState);
+                const row = readAssetSalienceForImproveRef(dbForHighSalience, r.ref, options.sourceName, options.legacyBareState);
                 if (row &&
                     isContentEncodingRow(row, parseAssetRef(r.ref).type) &&
                     row.encoding_salience >= salienceThreshold &&
@@ -1457,7 +1461,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 = readAssetSalienceForImproveRef(dbForStoredEncoding, r.ref, options.target, options.legacyBareState);
+                const row = readAssetSalienceForImproveRef(dbForStoredEncoding, r.ref, options.sourceName, options.legacyBareState);
                 if (row && isContentEncodingRow(row, type)) {
                     storedEncodingByRef.set(r.ref, row.encoding_salience);
                 }
@@ -1551,10 +1555,10 @@ export async function runImprovePreparationStage(args) {
             //
             // Load ALL existing rows so rank positions are stash-relative, not pool-relative.
             const allStoredScores = getAllRankScores(stateDb);
-            const existingAllScores = options.target
+            const existingAllScores = options.sourceName
                 ? new Map([...allStoredScores].flatMap(([ref, score]) => {
                     const parsed = parseAssetRef(ref);
-                    return parsed.origin === options.target || (options.legacyBareState && !parsed.origin)
+                    return parsed.origin === options.sourceName || (options.legacyBareState && !parsed.origin)
                         ? [[bareImproveRef(ref), score]]
                         : [];
                 }))
@@ -1655,7 +1659,7 @@ export async function runImprovePreparationStage(args) {
                 }, eventsCtx);
             }
             for (const [ref, vector] of salienceMap) {
-                upsertAssetSalience(stateDb, durableImproveRef(ref, options.target), vector, nowForSalience);
+                upsertAssetSalience(stateDb, durableImproveRef(ref, options.sourceName), vector, nowForSalience);
             }
         }, { path: eventsCtx?.dbPath });
     }
@@ -1742,10 +1746,10 @@ export async function runImprovePreparationStage(args) {
             withStateDb((replayDb) => {
                 const alreadyInPool = new Set(mergedRefs.map((r) => r.ref));
                 const storedRankScores = getAllRankScores(replayDb);
-                const allRankScores = options.target
+                const allRankScores = options.sourceName
                     ? new Map([...storedRankScores].flatMap(([ref, score]) => {
                         const parsed = parseAssetRef(ref);
-                        return parsed.origin === options.target || (options.legacyBareState && !parsed.origin)
+                        return parsed.origin === options.sourceName || (options.legacyBareState && !parsed.origin)
                             ? [[bareImproveRef(ref), score]]
                             : [];
                     }))
@@ -1759,7 +1763,7 @@ export async function runImprovePreparationStage(args) {
                 for (const [ref, rankScore] of allRankScores) {
                     if (alreadyInPool.has(ref))
                         continue;
-                    const noOps = readConsecutiveNoOpsForImproveRef(replayDb, ref, options.target, options.legacyBareState);
+                    const noOps = readConsecutiveNoOpsForImproveRef(replayDb, ref, options.sourceName, options.legacyBareState);
                     if (noOps >= SALIENCE_NO_OP_DAMPEN_THRESHOLD) {
                         convergedSkipped++;
                         continue;
@@ -1836,7 +1840,7 @@ export async function runImprovePreparationStage(args) {
             const ownsNoOpDb = !eventsCtx?.db;
             try {
                 for (const r of mergedRefs) {
-                    noOpMap.set(r.ref, readConsecutiveNoOpsForImproveRef(noOpDb, r.ref, options.target, options.legacyBareState));
+                    noOpMap.set(r.ref, readConsecutiveNoOpsForImproveRef(noOpDb, r.ref, options.sourceName, options.legacyBareState));
                 }
             }
             finally {

package/dist/commands/improve/proactive-maintenance.js

@@ -86,13 +86,11 @@ export function selectProactiveMaintenanceRefs(params) {
     return { selected, dueTotal, neverReflected, scored };
 }
 /**
- * Post-lock re-filter for proactive refs.
+ * Pre-execution re-filter for proactive refs.
  *
- * Called INSIDE the reflect-distill.lock window with freshly-read timestamp
- * maps so that any `reflect_invoked` events committed by a concurrent run
- * while this run was waiting for the lock are visible. Refs that became
- * non-due (staleDays ≤ dueDays) since planning time are dropped before
- * execution, closing the SELECT-time cooldown race.
+ * Called under the whole-run lock with freshly-read timestamp maps. Refs that
+ * became non-due before this run acquired the lock are dropped before execution,
+ * closing the SELECT-time cooldown race.
  *
  * The logic mirrors the DUE gate in `selectProactiveMaintenanceRefs` — an
  * asset is due only when never touched OR last touched more than `dueDays`

package/dist/commands/improve/reflect.js

@@ -45,7 +45,8 @@ import { chatCompletion } from "../../llm/client.js";
 import { baseFailureFields, enoentHintMessage, isEnoentFailure } from "../agent/agent-support.js";
 import { createProposal, isProposalSkipped, listProposals, } from "../proposal/repository.js";
 import { checkReflectSize, isValidDescription } from "../proposal/validators/proposal-quality-validators.js";
-import { deriveLessonRef, runLessonQualityJudge } from "./distill.js";
+import { deriveLessonRef } from "./distill.js";
+import { runReflectQualityJudge } from "./distill/quality-gate.js";
 import { findAssetFilePath } from "./eligibility.js";
 import { classifyReflectChange } from "./reflect-noise.js";
 import { bareImproveRef, durableImproveRef } from "./source-identity.js";
@@ -663,8 +664,12 @@ export async function runReflectViaLlm(opts) {
     try {
         const stdout = await (opts.chat ?? chatCompletion)(opts.connection, messages, {
             ...(Object.hasOwn(opts, "timeoutMs") ? { timeoutMs: opts.timeoutMs } : {}),
+            ...(opts.signal ? { signal: opts.signal } : {}),
             ...(opts.responseSchema !== undefined ? { responseSchema: opts.responseSchema } : {}),
             ...(opts.maxTokens !== undefined ? { maxTokens: opts.maxTokens } : {}),
+            // Reflect requires a machine-readable payload. Visible chain-of-thought
+            // can consume the output cap before the model reaches the JSON object.
+            enableThinking: false,
         });
         return {
             ok: true,
@@ -931,6 +936,7 @@ export async function akmReflect(options = {}) {
                     prompt,
                     connection: spec.connection,
                     ...(Object.hasOwn(opts, "timeoutMs") ? { timeoutMs: opts.timeoutMs } : {}),
+                    ...(options.signal ? { signal: options.signal } : {}),
                     priorDraft,
                     iteration: iter,
                     responseSchema: REFLECT_JSON_SCHEMA,
@@ -1100,72 +1106,7 @@ export async function akmReflect(options = {}) {
             // caught downstream by createProposal; allow it to surface naturally.
         }
     }
-    // 7. R-5 / #374: Apply the proposal quality gate when enabled.
-    // Mirrors the lesson quality gate on distill proposals. The gate uses
-    // `runLessonQualityJudge` from distill.ts and is gated behind either
-    // `processes.reflect.qualityGate.enabled` or
-    // `processes.distill.qualityGate.enabled` on the selected strategy.
-    // Fail-CLOSED (07 P0-2): a judge error / no-LLM /
-    // parse failure rejects the proposal rather than passing it through.
-    // G-Eval (arXiv:2303.16634) — quality judgment before admission.
-    const runtimeConfig = options.config ??
-        (() => {
-            try {
-                return loadConfig();
-            }
-            catch {
-                return undefined;
-            }
-        })();
-    const chatFn = options.chat ?? chatCompletion;
-    const qualityGateEnabled = (activeStrategy?.processes?.reflect?.qualityGate?.enabled ?? false) ||
-        (activeStrategy?.processes?.distill?.qualityGate?.enabled ?? true);
-    if (qualityGateEnabled && runtimeConfig) {
-        const assetContent = (() => {
-            if (!options.ref)
-                return null;
-            try {
-                const refParsed = parseAssetRef(options.ref);
-                const candidates = [
-                    path.join(stash, `${refParsed.type}s`, `${refParsed.name}.md`),
-                    path.join(stash, `${refParsed.type}s`, refParsed.name, "index.md"),
-                ];
-                for (const p of candidates) {
-                    if (fs.existsSync(p))
-                        return fs.readFileSync(p, "utf8");
-                }
-                return null;
-            }
-            catch {
-                return null;
-            }
-        })();
-        const judgeResult = await runLessonQualityJudge(runtimeConfig, payload.content, assetContent ?? "", chatFn, undefined, runnerIsLlm(runnerSpec) ? materializeLlmRunnerConnection(runnerSpec) : undefined);
-        if (!judgeResult.pass) {
-            // Quality gate rejected the proposal — surface as parse_error so the
-            // improve orchestrator can log it and move on without crashing.
-            appendEvent({
-                eventType: "reflect_completed",
-                ref: payload.ref,
-                metadata: {
-                    source: "reflect",
-                    qualityRejected: true,
-                    qualityScore: judgeResult.score,
-                    qualityReason: judgeResult.reason,
-                },
-            });
-            return {
-                schemaVersion: 2,
-                ok: false,
-                reason: "parse_error",
-                error: `Reflect proposal quality gate rejected: score=${judgeResult.score}, reason="${judgeResult.reason}"`,
-                ...(options.ref ? { ref: options.ref } : {}),
-                engine: engineName,
-                exitCode: result.exitCode,
-            };
-        }
-    }
-    // 7b. Reflect content-preservation rails:
+    // 7. Reflect content-preservation rails:
     //     - Restore source frontmatter so reflect can never strip indexable
     //       fields (`description`, `when_to_use`, `tags`, ...).
     //     - Reset protected identity fields (`name`, `ref`, `id`, `slug`,
@@ -1241,6 +1182,38 @@ export async function akmReflect(options = {}) {
             };
         }
     }
+    // 7c. Judge the exact sanitized content that can be persisted. Fail closed
+    // on cancellation, transport failure, malformed output, or an invalid score.
+    const qualityGateEnabled = (activeStrategy?.processes?.reflect?.qualityGate?.enabled ?? false) ||
+        (activeStrategy?.processes?.distill?.qualityGate?.enabled ?? true);
+    if (qualityGateEnabled) {
+        const judgeResult = await runReflectQualityJudge(config, payload.content, assetContent ?? "", feedback, options.chat ?? chatCompletion, {
+            ...(runnerIsLlm(runnerSpec) ? { llmConfig: materializeLlmRunnerConnection(runnerSpec) } : {}),
+            ...(Object.hasOwn(options, "timeoutMs") ? { timeoutMs: options.timeoutMs } : {}),
+            ...(options.signal ? { signal: options.signal } : {}),
+        });
+        if (!judgeResult.pass) {
+            appendEvent({
+                eventType: "reflect_completed",
+                ref: payload.ref,
+                metadata: {
+                    source: "reflect",
+                    qualityRejected: true,
+                    qualityScore: judgeResult.score,
+                    qualityReason: judgeResult.reason,
+                },
+            });
+            return {
+                schemaVersion: 2,
+                ok: false,
+                reason: "parse_error",
+                error: `Reflect proposal quality gate rejected: score=${judgeResult.score}, reason="${judgeResult.reason}"`,
+                ...(options.ref ? { ref: options.ref } : {}),
+                engine: engineName,
+                exitCode: result.exitCode,
+            };
+        }
+    }
     // 8. Create the proposal. The proposal queue is the ONLY thing reflect
     // writes — promotion to a real asset is gated by `akm proposal accept`.
     //

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

@@ -67,12 +67,12 @@ export const DEFAULT_IMPROVE_TASKS = [
     },
 ];
 /**
- * A schedule for the manual catch-up task. The scheduler requires a valid
- * cron expression even when the task is registered disabled, so we give the
- * unscheduled task a nominal far-future-ish cadence and leave it disabled —
- * the documented entry point is `akm tasks run akm-improve-catchup`.
+ * A schedule for the manual catch-up task. The scheduler requires a portable
+ * expression even when the task is registered disabled, so we give it a
+ * nominal daily cadence and leave it disabled. The documented entry point is
+ * `akm tasks run akm-improve-catchup`.
  */
-const MANUAL_TASK_NOMINAL_SCHEDULE = "0 4 1 1 *"; // 04:00 on Jan 1 — never effectively fires
+const MANUAL_TASK_NOMINAL_SCHEDULE = "0 4 * * *";
 const DEFAULT_DEPS = {
     list: akmTasksList,
     add: akmTasksAdd,

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

@@ -136,11 +136,15 @@ const tasksRunCommand = defineCommand({
         name: "run",
         description: "Execute a task now (this is what cron / launchd / schtasks invoke at the scheduled time)",
     },
-    args: { id: { type: "positional", description: "Task id", required: true } },
+    args: {
+        id: { type: "positional", description: "Task id", required: true },
+        scheduled: { type: "boolean", description: "Internal marker for scheduler-generated runs", default: false },
+    },
     async run({ args }) {
         await runWithJsonErrors(async () => {
-            const { id } = parseTaskRef(args.id);
-            const envelope = await akmTasksRun(id);
+            const envelope = await akmTasksRun(args.id, {
+                scheduled: args.scheduled === true,
+            });
             output("tasks-run", envelope);
             if (envelope.exitCode !== 0)
                 process.exit(envelope.exitCode);