akm-cli 0.9.0-rc.8 → 0.9.0

package/dist/commands/health/surfaces.js

@@ -4,11 +4,10 @@
 /**
  * The remaining `surfaces` advisory group for `akm health` (meta-review 08).
  * `stash-git-exposure` (08-F1) shipped first in ./stash-exposure.ts; this
- * module adds the other four read-only checks the adjudication approved:
+ * module adds the other three read-only checks the adjudication approved:
  *
  *   - `secret-file-perms`   — env/secret/backup files not 0600, dirs not 0700 (F4)
  *   - `binary-config-skew`  — config.json written by a NEWER akm than this binary (F3)
- *   - `orphan-stores`       — legacy config-backups dirs + 0-byte stash state.db decoy (F4/F7)
  *   - `egress-endpoints`    — the remote-destination list, for eyeball diff (surfaces 3/9)
  *
  * Every collector is a pure projection over injected paths/config (no
@@ -120,49 +119,6 @@ export function collectConfigSkewAdvisory(configPath) {
         evidence: { onDiskConfigVersion: onDisk, binaryConfigVersion: CURRENT_CONFIG_VERSION },
     };
 }
-/**
- * `orphan-stores` (08-F4/F7): stores that look load-bearing but are dead —
- * legacy `config-backups/` dirs in $DATA/$CONFIG (only `$CACHE/config-backups`
- * is written and pruned today) and a 0-byte `<stash>/.akm/state.db` decoy that
- * misleads debugging (the live state.db lives in the data dir). Read-only:
- * this advisory NAMES them; removal stays an owner-approved per-path action.
- */
-export function collectOrphanStoresAdvisory(input) {
-    const orphans = [];
-    for (const [label, dir] of [
-        ["legacy data-dir backup location", path.join(input.dataDir, "config-backups")],
-        ["legacy config-dir backup location", path.join(input.configDir, "config-backups")],
-    ]) {
-        try {
-            if (fs.statSync(dir).isDirectory())
-                orphans.push(`${dir}/ (${label}; live backups are in $CACHE/config-backups)`);
-        }
-        catch {
-            // absent — fine
-        }
-    }
-    const decoy = path.join(input.stashDir, ".akm", "state.db");
-    try {
-        const stat = fs.statSync(decoy);
-        if (stat.isFile() && stat.size === 0) {
-            orphans.push(`${decoy} (0-byte decoy; the live state.db is in the data dir)`);
-        }
-    }
-    catch {
-        // absent — fine
-    }
-    if (orphans.length === 0)
-        return undefined;
-    return {
-        name: "orphan-stores",
-        kind: "deterministic",
-        status: "warn",
-        confidence: "high",
-        message: `${orphans.length} orphan store(s) found: ${orphans.join("; ")}. ` +
-            "These are dead locations that mislead debugging/recovery — review and remove them (owner-approved, per-path).",
-        evidence: { orphans },
-    };
-}
 /**
  * `egress-endpoints` (08 surfaces 3/9): the full list of remote destinations
  * akm can talk to under the effective config — registries, remote sources,
@@ -207,14 +163,13 @@ export function collectEgressAdvisory(config) {
     };
 }
 /**
- * Aggregate the four collectors into the advisories array shape `akmHealth`
- * consumes. Order is fixed: perms → skew → orphans → egress.
+ * Aggregate the three collectors into the advisories array shape `akmHealth`
+ * consumes. Order is fixed: perms → skew → egress.
  */
 export function collectSurfacesAdvisories(input) {
     const results = [
         collectSecretPermsAdvisory({ stashDir: input.stashDir, cacheDir: input.cacheDir }, input.platform ?? process.platform),
         collectConfigSkewAdvisory(input.configPath),
-        collectOrphanStoresAdvisory({ dataDir: input.dataDir, configDir: input.configDir, stashDir: input.stashDir }),
         collectEgressAdvisory(input.config),
     ];
     return results.filter((r) => r !== undefined);

package/dist/commands/health/task-runs.js

@@ -2,57 +2,8 @@
 // License, v. 2.0. If a copy of the MPL was not distributed with this
 // file, You can obtain one at https://mozilla.org/MPL/2.0/.
 import { queryImproveRuns } from "../../storage/repositories/improve-runs-repository.js";
-import { queryCompletedTaskIntervals, queryTaskHistory } from "../../storage/repositories/task-history-repository.js";
+import { queryTaskHistory } from "../../storage/repositories/task-history-repository.js";
 import { projectImproveRunSummary } from "./improve-metrics.js";
-/**
- * Load task_history intervals for `task_id='akm-improve'` in the window.
- * Returned sorted by startMs ascending so containment lookups can use a
- * linear scan (typical N is ~24/day; not worth a tree).
- *
- * The window filter is widened by 5 minutes on each side because the cron
- * task wraps `akm improve` — the task `started_at` fires at e.g. :07:01
- * while `recordImproveRun` writes the matching `improve_runs.started_at`
- * later (after config load, planning, etc.), so the improve_runs row can
- * be inside the window even when its enclosing task_history row started
- * just before the window opened.
- */
-function loadTaskIntervals(db, since, until) {
-    const sinceMs = new Date(since).getTime();
-    const untilMs = until ? new Date(until).getTime() : Number.POSITIVE_INFINITY;
-    const widenedSince = new Date(sinceMs - 5 * 60 * 1000).toISOString();
-    const widenedUntil = Number.isFinite(untilMs) ? new Date(untilMs + 5 * 60 * 1000).toISOString() : undefined;
-    const rows = queryCompletedTaskIntervals(db, widenedSince, widenedUntil);
-    const intervals = [];
-    for (const row of rows) {
-        const startMs = new Date(row.started_at).getTime();
-        const endMs = new Date(row.completed_at).getTime();
-        if (!Number.isFinite(startMs) || !Number.isFinite(endMs) || endMs < startMs)
-            continue;
-        intervals.push({ startMs, endMs, durationMs: endMs - startMs });
-    }
-    return intervals;
-}
-/**
- * Find the task_history interval that contains the given timestamp. The
- * task wraps `akm improve`, so `improve_runs.started_at` (when
- * `recordImproveRun` writes) always falls inside the enclosing task's
- * [started_at, completed_at]. Returns undefined when no interval
- * contains the timestamp (which happens for manually-invoked improve
- * runs not driven by the `akm-improve` task).
- *
- * Linear scan because N is small. We tolerate a 1s slop on the upper
- * bound to handle clock skew between the wrapper's `completed_at` write
- * and recordImproveRun's `started_at` write.
- */
-function findContainingTaskInterval(timestampMs, intervals) {
-    const SLOP_MS = 1000;
-    for (const interval of intervals) {
-        if (timestampMs >= interval.startMs && timestampMs <= interval.endMs + SLOP_MS) {
-            return interval;
-        }
-    }
-    return undefined;
-}
 /**
  * Load `task_history` rows whose `task_id` begins `akm-improve` (the scheduled
  * improve tasks: `akm-improve-frequent`, `akm-improve-proactive-weekly`, …) in
@@ -88,7 +39,7 @@ export function matchImproveTaskId(startedAt, completedAt, taskRuns) {
     const startMs = new Date(startedAt).getTime();
     if (!Number.isFinite(startMs))
         return "manual";
-    const endMs = completedAt ? new Date(completedAt).getTime() : Number.NaN;
+    const endMs = new Date(completedAt).getTime();
     let best;
     let bestScore = Number.POSITIVE_INFINITY;
     for (const task of taskRuns) {
@@ -107,27 +58,12 @@ export function matchImproveTaskId(startedAt, completedAt, taskRuns) {
 }
 export function buildPerRunSummaries(db, since, until) {
     const rows = queryImproveRuns(db, since, until);
-    const taskIntervals = loadTaskIntervals(db, since, until);
     const improveTaskRuns = loadImproveTaskRuns(db, since, until);
     const summaries = [];
     for (const row of rows) {
         const startMs = new Date(row.started_at).getTime();
         const endMs = new Date(row.completed_at).getTime();
-        // Prefer the improve_runs row's own (completed_at - started_at) delta:
-        // recordImproveRun now persists distinct start/end timestamps, so the
-        // row's own delta is the authoritative per-run wall time even for
-        // manually-invoked `akm improve` runs with no enclosing task_history.
-        // Only fall back to the task_history containing-interval join for legacy/
-        // backfill rows where started_at == completed_at (row delta is 0).
-        const hasRowDelta = Number.isFinite(startMs) && Number.isFinite(endMs) && endMs > startMs;
-        let wallTimeMs;
-        if (hasRowDelta) {
-            wallTimeMs = endMs - startMs;
-        }
-        else {
-            const interval = Number.isFinite(startMs) ? findContainingTaskInterval(startMs, taskIntervals) : undefined;
-            wallTimeMs = interval?.durationMs ?? 0;
-        }
+        const wallTimeMs = Number.isFinite(startMs) && Number.isFinite(endMs) && endMs >= startMs ? endMs - startMs : 0;
         const taskId = matchImproveTaskId(row.started_at, row.completed_at, improveTaskRuns);
         summaries.push(projectImproveRunSummary(row, wallTimeMs, taskId));
     }

package/dist/commands/health/types-improve.js

@@ -20,3 +20,10 @@ export const ENRICHMENT_MINTED_FAIL_SHARE = 0.15;
  * source so the advisory and the rendered badge cannot drift.
  */
 export const TASK_FAIL_RATE_WARN = 0.05;
+/**
+ * Minimum task_history rows a single task_id needs in the window before its
+ * per-task fail rate feeds the `task-fail-rate` advisory's "worst single
+ * task" signal. Guards against a rarely-run task (e.g. 1 failure out of 1
+ * run) reading as a 100% fail rate off a single noisy sample.
+ */
+export const MIN_ROWS_FOR_WORST_TASK_FAIL_RATE = 5;

package/dist/commands/health.js

@@ -7,8 +7,9 @@ import { resolveStashDir } from "../core/common.js";
 import { loadConfig } from "../core/config/config.js";
 import { ConfigError, UsageError } from "../core/errors.js";
 import { readEvents } from "../core/events.js";
+import { listTxnJournalsTolerant, TXN_SWEEP_GRACE_MS } from "../core/fs-txn.js";
 import { openLogsDatabase } from "../core/logs-db.js";
-import { getCacheDir, getConfigDir, getConfigPath, getDataDir, getStateDbPathInDataDir } from "../core/paths.js";
+import { getCacheDir, getConfigPath, getDataDir, getStateDbPathInDataDir } from "../core/paths.js";
 import { listExistingTableNames, openStateDatabase } from "../core/state-db.js";
 import { DURATION_UNITS, parseDuration, parseSinceToIso } from "../core/time.js";
 import { readSemanticStatus } from "../indexer/search/semantic-status.js";
@@ -22,7 +23,7 @@ import { computeDegradationMetrics, computeDenominatorFixedCoverage, computeEnri
 import { collectStashExposureAdvisory } from "./health/stash-exposure.js";
 import { collectSurfacesAdvisories } from "./health/surfaces.js";
 import { buildPerRunSummaries } from "./health/task-runs.js";
-import { ACTIVE_RUN_WARN_MS, IMPROVE_COMPLETED_EVENT, } from "./health/types.js";
+import { ACTIVE_RUN_WARN_MS, IMPROVE_COMPLETED_EVENT, MIN_ROWS_FOR_WORST_TASK_FAIL_RATE, } from "./health/types.js";
 import { buildWindowMetrics, computeDeltas, partitionLogBackedRows, resolveWindowCompare } from "./health/windows.js";
 const DEFAULT_SINCE_MS = 24 * 60 * 60 * 1000;
 export function parseHealthSince(since) {
@@ -60,6 +61,52 @@ function validateAkmHealthOptions(options) {
         }
     }
 }
+/**
+ * Item 7: dedupe stuck-active rows by task_id (keeping the oldest/largest age
+ * per id) so the `active-runs` check can name WHICH tasks are stuck instead of
+ * just a count. No pid/liveness probing — purely a projection of the rows
+ * already read.
+ */
+function dedupeStuckActiveTasks(rows, now) {
+    const byTask = new Map();
+    for (const row of rows) {
+        const ageMs = now() - new Date(row.started_at).getTime();
+        const existing = byTask.get(row.task_id);
+        if (existing === undefined || ageMs > existing)
+            byTask.set(row.task_id, ageMs);
+    }
+    return [...byTask.entries()].map(([taskId, ageMs]) => ({ taskId, ageMs }));
+}
+/**
+ * Item 6: group task_history rows by task_id and return the one with the
+ * highest fail rate among tasks with at least MIN_ROWS_FOR_WORST_TASK_FAIL_RATE
+ * rows in the window — surfaces a consistently-failing task that a large,
+ * mostly-healthy population would otherwise hide behind the aggregate rate.
+ * `null` when no task_id meets the row-count floor. Ties break toward the
+ * task with more rows (a stronger signal), then by task_id for determinism.
+ */
+function computeWorstTaskFailRate(rows) {
+    const byTask = new Map();
+    for (const row of rows) {
+        const entry = byTask.get(row.task_id) ?? { total: 0, failed: 0 };
+        entry.total += 1;
+        if (row.status === "failed")
+            entry.failed += 1;
+        byTask.set(row.task_id, entry);
+    }
+    let worst = null;
+    for (const [taskId, { total, failed }] of byTask) {
+        if (total < MIN_ROWS_FOR_WORST_TASK_FAIL_RATE)
+            continue;
+        const rate = failed / total;
+        if (worst === null ||
+            rate > worst.rate ||
+            (rate === worst.rate && (total > worst.rows || (total === worst.rows && taskId < worst.taskId)))) {
+            worst = { taskId, rate, rows: total };
+        }
+    }
+    return worst;
+}
 /** Table presence, the state.db round-trip probe, and task_history-derived rates. */
 function gatherTaskHistoryPhase(db, logsDb, since, stateDbPath, now) {
     const tables = listExistingTableNames(db, ["events", "task_history", "proposals", "schema_migrations"]);
@@ -71,7 +118,7 @@ function gatherTaskHistoryPhase(db, logsDb, since, stateDbPath, now) {
     const { withLogs: taskRowsWithLogs, backed: existingLogRows } = partitionLogBackedRows(taskRows, logsDb);
     const failedTaskRows = taskRows.filter((row) => row.status === "failed");
     const activeRows = taskRows.filter((row) => row.status === "active" && row.completed_at === null);
-    const stuckActiveRuns = activeRows.filter((row) => now() - new Date(row.started_at).getTime() > ACTIVE_RUN_WARN_MS).length;
+    const stuckActiveRows = activeRows.filter((row) => now() - new Date(row.started_at).getTime() > ACTIVE_RUN_WARN_MS);
     const promptRows = taskRows.filter((row) => row.target_kind === "prompt");
     const promptFailures = promptRows.filter((row) => {
         const detail = parseTaskMetadata(row).detail;
@@ -87,12 +134,45 @@ function gatherTaskHistoryPhase(db, logsDb, since, stateDbPath, now) {
         taskRowCount: taskRows.length,
         taskRowsWithLogsCount: taskRowsWithLogs.length,
         existingLogRowsCount: existingLogRows.length,
-        stuckActiveRuns,
+        stuckActiveRuns: stuckActiveRows.length,
+        stuckActiveTasks: dedupeStuckActiveTasks(stuckActiveRows, now),
         logBackingRate,
         taskFailRate,
+        worstTaskFailRate: computeWorstTaskFailRate(taskRows),
         agentFailureRate,
     };
 }
+/**
+ * Item 4: leftover durable-transaction journals under `$DATA/txn` (stranded
+ * recovery state seen twice in a real 0.9 migration) had zero health
+ * visibility. Uses the tolerant scan variant so one corrupt journal.json is
+ * counted rather than aborting the whole gather; a journal younger than
+ * {@link TXN_SWEEP_GRACE_MS} is presumed to belong to a currently-running
+ * operation and is not counted as stale. Best-effort: any unexpected error
+ * (e.g. a permissions issue under `$DATA/txn`) degrades to "no signal" rather
+ * than aborting the health report.
+ */
+function gatherStaleTxnJournalsPhase(now) {
+    const dir = path.join(getDataDir(), "txn");
+    try {
+        const { matches, unreadableMtimes } = listTxnJournalsTolerant(() => true);
+        const nowMs = now();
+        const staleAges = [
+            ...matches.map((m) => nowMs - m.mtimeMs),
+            ...unreadableMtimes.map((mtimeMs) => nowMs - mtimeMs),
+        ].filter((ageMs) => ageMs >= TXN_SWEEP_GRACE_MS);
+        const staleUnreadableCount = unreadableMtimes.filter((mtimeMs) => nowMs - mtimeMs >= TXN_SWEEP_GRACE_MS).length;
+        return {
+            dir,
+            count: staleAges.length,
+            oldestAgeMs: staleAges.length > 0 ? Math.max(...staleAges) : null,
+            unreadable: staleUnreadableCount,
+        };
+    }
+    catch {
+        return { dir, count: 0, oldestAgeMs: null, unreadable: 0 };
+    }
+}
 /**
  * Semantic-search status + the config fields the embedding-endpoint and
  * surfaces advisories need. Best-effort: an unloadable config leaves the
@@ -148,8 +228,8 @@ function gatherImproveSummaryPhase(db, stateDbPath, since, now) {
 /**
  * The three best-effort advisory groups beyond the health-check registry:
  * improve advisories, the `stash-git-exposure` probe, and the 08 surfaces
- * group (secret-file-perms, binary-config-skew, orphan-stores,
- * egress-endpoints). Order matches emission order in the returned array. A
+ * group (secret-file-perms, binary-config-skew, egress-endpoints). Order
+ * matches emission order in the returned array. A
  * probe/filesystem failure in either try/catch must not abort the health
  * report — each group degrades to "no advisory" independently.
  */
@@ -175,14 +255,12 @@ function gatherAncillaryAdvisories(db, stateDbPath, since, improveSummary, optio
         // Non-fatal — a git/probe failure must not abort the health report.
     }
     // 08 surfaces: the remaining read-only advisory group (secret-file-perms,
-    // binary-config-skew, orphan-stores, egress-endpoints). Best-effort — a
+    // binary-config-skew, egress-endpoints). Best-effort — a
     // filesystem probe failure must not abort the health report.
     try {
         advisories.push(...collectSurfacesAdvisories({
             stashDir: options.stashDir ?? resolveStashDir(),
             cacheDir: getCacheDir(),
-            dataDir: getDataDir(),
-            configDir: getConfigDir(),
             configPath: getConfigPath(),
             config: egressConfigView,
         }));
@@ -209,11 +287,10 @@ function gatherSessionLogAdvisories(since, now, getExecutionLogCandidatesFn) {
 }
 /**
  * Phase 3 — window-compare mode. Resolves `--window-compare`/`--windows` into
- * per-window bundles, then folds window 0 back onto the top-level
- * improve/metrics/since fields (backward compat with the non-window-compare
- * shape) and computes deltas between the earliest and latest window.
+ * per-window bundles and computes deltas between the earliest and latest
+ * window. Top-level metrics retain the primary `--since` query.
  */
-function resolveWindowComparePhase(options, db, stateDbPath, now, logsDb, probe, improveSummary, metrics, since) {
+function resolveWindowComparePhase(options, db, stateDbPath, now, logsDb) {
     let windowSpecs;
     if (options.windowCompare) {
         windowSpecs = resolveWindowCompare(options.windowCompare, now);
@@ -223,9 +300,6 @@ function resolveWindowComparePhase(options, db, stateDbPath, now, logsDb, probe,
     }
     let windowResults;
     let deltas;
-    let topLevelImprove = improveSummary;
-    let topLevelMetrics = metrics;
-    let topLevelSince = since;
     if (windowSpecs) {
         windowResults = windowSpecs.map((spec) => {
             const winSince = parseHealthSince(spec.since);
@@ -240,13 +314,6 @@ function resolveWindowComparePhase(options, db, stateDbPath, now, logsDb, probe,
                 metrics: bundle.metrics,
             };
         });
-        // Preserve backward compat: top-level improve/metrics reflect window 0.
-        if (windowResults.length > 0) {
-            const firstWindow = windowResults[0];
-            topLevelImprove = firstWindow.improve;
-            topLevelMetrics = { ...firstWindow.metrics, probeRoundTripMs: probe.durationMs };
-            topLevelSince = firstWindow.since;
-        }
         if (windowResults.length >= 2) {
             // Deltas always read chronologically: `from` = earliest window,
             // `to` = latest. Positive pctChange on a failure metric (e.g.
@@ -259,7 +326,7 @@ function resolveWindowComparePhase(options, db, stateDbPath, now, logsDb, probe,
             deltas = computeDeltas(sorted[0], sorted[sorted.length - 1]);
         }
     }
-    return { windowResults, deltas, topLevelImprove, topLevelMetrics, topLevelSince };
+    return { windowResults, deltas };
 }
 export function akmHealth(options = {}) {
     validateAkmHealthOptions(options);
@@ -289,6 +356,7 @@ export function akmHealth(options = {}) {
     try {
         const taskHistory = gatherTaskHistoryPhase(db, logsDb, since, stateDbPath, now);
         const { tableNames, missingTables, probe } = taskHistory;
+        const staleTxnJournals = gatherStaleTxnJournalsPhase(now);
         const { semanticStatus, semanticSearchMode, embeddingEndpoint, egressConfigView } = gatherSemanticConfigPhase();
         const { improveSummary } = gatherImproveSummaryPhase(db, stateDbPath, since, now);
         advisories.push(...gatherAncillaryAdvisories(db, stateDbPath, since, improveSummary, options, egressConfigView));
@@ -309,6 +377,9 @@ export function akmHealth(options = {}) {
             existingLogRowsCount: taskHistory.existingLogRowsCount,
             logBackingRate: taskHistory.logBackingRate,
             stuckActiveRuns: taskHistory.stuckActiveRuns,
+            stuckActiveTasks: taskHistory.stuckActiveTasks,
+            worstTaskFailRate: taskHistory.worstTaskFailRate,
+            staleTxnJournals,
             semanticStatus,
             semanticSearchMode,
             embeddingEndpoint,
@@ -335,7 +406,7 @@ export function akmHealth(options = {}) {
         const deterministicWarnings = [...hardChecks, ...advisories].some((check) => check.status === "warn" && check.kind === "deterministic");
         const status = hardFailure ? "fail" : deterministicWarnings ? "warn" : "pass";
         // ── Window-compare mode (Phase 3) ─────────────────────────────────────
-        const { windowResults, deltas, topLevelImprove, topLevelMetrics, topLevelSince } = resolveWindowComparePhase(options, db, stateDbPath, now, logsDb, probe, improveSummary, metrics, since);
+        const { windowResults, deltas } = resolveWindowComparePhase(options, db, stateDbPath, now, logsDb);
         // ── Per-run mode (Phase 2) ────────────────────────────────────────────
         let runs;
         if (options.groupBy === "run") {
@@ -345,11 +416,11 @@ export function akmHealth(options = {}) {
             schemaVersion: 3,
             ok: !hardFailure,
             status,
-            since: topLevelSince,
+            since,
             hardChecks,
             advisories,
-            metrics: topLevelMetrics,
-            improve: topLevelImprove,
+            metrics,
+            improve: improveSummary,
             sessionLogAdvisories: sessionLogEntries,
             ...(runs ? { runs } : {}),
             ...(windowResults ? { windows: windowResults } : {}),

package/dist/commands/improve/anti-collapse.js

@@ -91,8 +91,8 @@ export function checkMergeInformationFloor(mergedBody, mergedSourceRefs, partici
     const required = new Set();
     for (const p of participants) {
         required.add(p.ref);
-        for (const sr of p.sourceRefs)
-            required.add(sr);
+        for (const xref of p.xrefs)
+            required.add(xref);
     }
     const after = new Set(mergedSourceRefs);
     const missing = [...required].filter((r) => !after.has(r));

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

@@ -0,0 +1,68 @@
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at https://mozilla.org/MPL/2.0/.
+import { IMPROVE_AUTONOMY_CONFIG_KEY, isImproveAutonomyEnabled, } from "../../core/config/experimental.js";
+/** The lanes `experimental.improveAutonomy` gates. */
+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)",
+    memoryCleanup: "rewrites belief-state frontmatter and moves files into the cleanup archive",
+};
+/**
+ * The lanes that bypass the strategy config and ask the gate at their own call
+ * site. They have no `processes.<name>.enabled` flag to downgrade, so
+ * {@link applyAutonomyGate} cannot see them — anything reporting the full gated
+ * set has to add these.
+ */
+export const DIRECT_AUTONOMY_LANES = ["memoryCleanup"];
+function gatedLane(lane) {
+    return { lane, configKey: IMPROVE_AUTONOMY_CONFIG_KEY, reason: LANE_REASONS[lane] };
+}
+/**
+ * Describe lanes for reporting — the warning line, the `improve_skipped` event,
+ * and `akm task doctor` all render the same {@link GatedLane} shape, so the
+ * lane name, config key, and reason cannot drift between the three surfaces.
+ */
+export function describeGatedLanes(lanes) {
+    return lanes.map(gatedLane);
+}
+/** Configured capabilities that tasks doctor reports behind the autonomy gate. */
+export function configuredDirectAutonomyLanes() {
+    return ["memoryCleanup"];
+}
+/**
+ * True when a lane may mutate. Used by the lane that bypasses the strategy
+ * config; the other three are handled by {@link applyAutonomyGate}.
+ */
+export function isAutonomyLaneAllowed(_lane, config) {
+    // Every lane shares one opt-in today. The parameter is kept so a call site
+    // names the lane it is asking about — that name is what reaches the operator
+    // in the skip event — and so a future per-lane split does not have to revisit
+    // every caller.
+    return isImproveAutonomyEnabled(config);
+}
+/**
+ * Downgrade a strategy config to review-first unless autonomy is opted into.
+ *
+ * Returns the config to actually run plus every downgrade made. With autonomy on
+ * the input is returned untouched and `gated` is empty.
+ */
+export function applyAutonomyGate(strategy, config) {
+    if (isImproveAutonomyEnabled(config))
+        return { config: strategy, gated: [] };
+    const gated = [];
+    const processes = { ...(strategy.processes ?? {}) };
+    if (processes.memoryInference?.enabled === true) {
+        processes.memoryInference = { ...processes.memoryInference, enabled: false };
+        gated.push(gatedLane("memoryInference"));
+    }
+    // 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") {
+        processes.triage = { ...processes.triage, applyMode: "queue" };
+        gated.push(gatedLane("triagePromote"));
+    }
+    return { config: { ...strategy, processes }, gated };
+}