akm-cli 0.9.31 → 0.10.261001-beta

package/dist/commands/improve/extract.js

@@ -53,8 +53,6 @@ const DEFAULT_MAX_SESSIONS_PER_RUN = 25;
  * but never less than 48h. The content-hash ledger makes the overlap free.
  */
 const DEFAULT_SINCE_FLOOR_MS = 48 * 60 * 60 * 1000;
-/** A per-session lock older than this belongs to a crashed holder. */
-const EXTRACT_SESSION_LOCK_STALE_MS = 5 * 60 * 1000;
 function resolveDefaultSinceMs(harnessName, now, opts) {
     const floor = now - DEFAULT_SINCE_FLOOR_MS;
     if (opts.skipTracking)
@@ -83,14 +81,14 @@ function extractSessionLockPath(harness, sessionId, stateDbPath) {
     return path.join(path.dirname(stateDbPath), "extract-locks", `extract-${safe}.lock`);
 }
 function extractSessionLockIsUnavailable(harness, sessionId, stateDbPath) {
-    const probe = probeLock(extractSessionLockPath(harness, sessionId, stateDbPath), {
-        staleAfterMs: EXTRACT_SESSION_LOCK_STALE_MS,
-    });
+    const probe = probeLock(extractSessionLockPath(harness, sessionId, stateDbPath));
     return probe.state === "held" || probe.state === "inaccessible";
 }
 /**
  * Claim a session so a concurrent extract (a session-end hook racing the
- * hourly improve run) cannot process it twice. A stale lock is reclaimed; a
+ * hourly improve run) cannot process it twice. Only a lock whose holder is
+ * dead is reclaimed (no age window: a live extraction can run for many
+ * minutes, the #872 lesson in `core/run-lock.ts`); a
  * filesystem error proceeds, so locking never blocks extraction outright.
  */
 function acquireExtractSessionLock(lockPath) {
@@ -99,7 +97,7 @@ function acquireExtractSessionLock(lockPath) {
         let ownership = tryAcquireLockSync(lockPath, createLockPayload());
         if (ownership)
             return { proceed: true, ownership };
-        const probe = probeLock(lockPath, { staleAfterMs: EXTRACT_SESSION_LOCK_STALE_MS });
+        const probe = probeLock(lockPath);
         if (probe.state === "held")
             return { proceed: false };
         if (probe.state === "stale" && !reclaimStaleLock(lockPath, probe))

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

@@ -3,16 +3,15 @@
 // file, You can obtain one at https://mozilla.org/MPL/2.0/.
 import path from "node:path";
 import { defineCommand } from "citty";
-import { getParsedInvocation } from "../../cli/invocation.js";
-import { getStringArg, parsePositiveIntFlag } from "../../cli/parse-args.js";
-import { GLOBAL_OUTPUT_ARGS, output, runWithJsonErrors } from "../../cli/shared.js";
+import { findCittyTopLevelCommandIndex, getStringArg, hasSubcommand, parsePositiveIntFlag } from "../../cli/parse-args.js";
+import { defineJsonCommand, GLOBAL_OUTPUT_ARGS, output, runWithJsonErrors } from "../../cli/shared.js";
 import { isFullRefInput, parseRefInput } from "../../core/asset/resolve-ref.js";
 import { loadConfig } from "../../core/config/config.js";
 import { ConfigError, UsageError } from "../../core/errors.js";
 import { resolveMutationTarget } from "../../core/mutation-target.js";
-import { getCacheDir } from "../../core/paths.js";
+import { getRunLogDir } from "../../core/paths.js";
 import { redactSensitiveText } from "../../core/redaction.js";
-import { clearLogFile, setLogFile, warn } from "../../core/warn.js";
+import { clearLogFile, setLogFile } from "../../core/warn.js";
 import { resolveWriteTarget } from "../../core/write-source.js";
 import { DEFAULT_LLM_TIMEOUT_MS } from "../../integrations/agent/config.js";
 import { defaultWhich } from "../../integrations/agent/detect.js";
@@ -35,37 +34,6 @@ let akmImproveForRun = akmImprove;
 export function _setAkmImproveForTests(fake) {
     akmImproveForRun = fake ?? akmImprove;
 }
-/**
- * `--auto-accept` (removed in 0.9): citty absorbs it silently, and
- * `--auto-accept 90` would leave `90` as the scope — a 0.8-era crontab would
- * match nothing and exit 0. Warn, and drop that positional.
- */
-function resolveScopeAfterRetiredAutoAccept(scopeArg) {
-    const invocation = getParsedInvocation();
-    const autoAcceptRaw = invocation.getFlagValue("--auto-accept");
-    if (autoAcceptRaw === undefined && !invocation.hasFlag("--auto-accept"))
-        return scopeArg;
-    warn("[improve] --auto-accept was removed in 0.9 and is ignored; proposals always queue for review. " +
-        "Replacement: `akm improve && akm proposal drain --promote --yes`, or a `triage` block with " +
-        'applyMode: "promote" in your strategy. It becomes a hard error in 0.10.');
-    if (scopeArg !== undefined && scopeArg === autoAcceptRaw) {
-        warn(`[improve] ignoring "${scopeArg}" as a scope — it is the removed --auto-accept flag's value.`);
-        return undefined;
-    }
-    return scopeArg;
-}
-/** `akm improve canary` (removed in 0.9) would otherwise be a type scope matching nothing, exiting 0. */
-function rejectRetiredCanaryScope(scopeArg) {
-    if (scopeArg !== "canary")
-        return;
-    throw new UsageError('"akm improve canary" was removed in 0.9; the collapse-detector canary set it managed no longer exists.', "INVALID_FLAG_VALUE");
-}
-/** `--target` (renamed `--bundle` in 0.9) would otherwise be absorbed and write to the default bundle. */
-function rejectRetiredImproveTargetFlag() {
-    if (!getParsedInvocation().hasFlag("--target"))
-        return;
-    throw new UsageError("`akm improve --target` was renamed to `--bundle` in 0.9. Use `--bundle <name>` instead.", "INVALID_FLAG_VALUE");
-}
 /**
  * `--require-engines` (#957): fail before any side effect when an enabled
  * process cannot run, naming what each is missing — a scheduled run would
@@ -194,53 +162,91 @@ async function runShowPromptCli(refArg, parsedRef, taskArg, targetArg, resolvedP
     });
 }
 /** `akm improve report` (#944): the per-run LLM usage/routing report ("report" is no asset type). */
-function runImproveReportCli(args) {
-    const runIdArg = getStringArg(args, "run");
-    const sinceArg = getStringArg(args, "since");
-    const result = runImproveReportQuery({ runId: runIdArg, since: sinceArg });
-    output("improve-report", { ok: true, ...result });
-}
-/** `--run`/`--since` belong to `improve report`; elsewhere citty would silently ignore them. */
-function rejectReportOnlyFlags(args) {
-    const flag = getStringArg(args, "run") !== undefined
-        ? "--run"
-        : getStringArg(args, "since") !== undefined
-            ? "--since"
-            : undefined;
-    if (flag === undefined)
-        return;
-    throw new UsageError(`\`${flag}\` only applies to \`akm improve report\`. Use \`akm improve report ${flag} <value>\` instead.`, "INVALID_FLAG_VALUE");
-}
+const improveReportCommand = defineJsonCommand({
+    meta: {
+        name: "report",
+        description: "Show the LLM usage/routing report for the most recent improve run, one run, or a window of runs.",
+    },
+    args: {
+        run: {
+            type: "string",
+            description: "Show the report for one specific improve_runs row instead of the most recent run. Mutually exclusive with --since.",
+        },
+        since: {
+            type: "string",
+            description: 'Aggregate the report over every real run started since <window> (a duration like "24h"/"7d", or an ISO timestamp) instead of showing one run. Mutually exclusive with --run.',
+        },
+    },
+    run({ args }) {
+        const result = runImproveReportQuery({ runId: getStringArg(args, "run"), since: getStringArg(args, "since") });
+        output("improve-report", { ok: true, ...result });
+    },
+});
 /**
  * `akm improve judge`: reflect's quality judge on one revision, read as
  * `{"source", "candidate", "feedback"}` JSON from stdin, with the engine the
  * strategy's reflect quality gate names. It writes nothing.
  */
-async function runImproveJudgeCli(strategyName) {
-    const input = process.stdin.isTTY
-        ? {}
-        : JSON.parse((await readStdin()).toString("utf8"));
-    const { source, candidate, feedback, ref } = input;
-    if (typeof source !== "string" || typeof candidate !== "string") {
-        throw new UsageError('`akm improve judge` reads {"source": "...", "candidate": "...", "feedback": "...", "ref": "..."} JSON from stdin.', "MISSING_REQUIRED_ARGUMENT");
-    }
-    const config = loadConfig();
-    const judge = resolveQualityGateJudge(config, resolveImproveStrategy(strategyName, config).config, "reflect");
-    if (!judge) {
-        throw new ConfigError("`akm improve judge` judges with the reflect quality gate's engine. Set processes.reflect.qualityGate.engine.", "INVALID_CONFIG_FILE");
-    }
-    const notes = typeof feedback === "string" && feedback.trim() !== "" ? [feedback.trim()] : [];
-    const verdict = await runReflectQualityJudge(config, candidate, source, notes, undefined, {
-        runnerSelectionFrozen: true,
-        llmRunner: judge,
-        ...(typeof ref === "string" && ref ? { ref } : {}),
-    });
-    output("improve-judge", { engine: judge.engine, ...verdict });
-}
+const improveJudgeCommand = defineJsonCommand({
+    meta: {
+        name: "judge",
+        description: "Run reflect's quality judge on one revision, read as {source, candidate, feedback, ref} JSON from stdin. Writes nothing.",
+    },
+    args: {
+        strategy: {
+            type: "string",
+            description: "Named improve strategy whose reflect quality gate names the judge engine.",
+        },
+    },
+    async run({ args }) {
+        const input = process.stdin.isTTY
+            ? {}
+            : JSON.parse((await readStdin()).toString("utf8"));
+        const { source, candidate, feedback, ref } = input;
+        if (typeof source !== "string" || typeof candidate !== "string") {
+            throw new UsageError('`akm improve judge` reads {"source": "...", "candidate": "...", "feedback": "...", "ref": "..."} JSON from stdin.', "MISSING_REQUIRED_ARGUMENT");
+        }
+        const config = loadConfig();
+        const judge = resolveQualityGateJudge(config, resolveImproveStrategy(getStringArg(args, "strategy"), config).config, "reflect");
+        if (!judge) {
+            throw new ConfigError("`akm improve judge` judges with the reflect quality gate's engine. Set processes.reflect.qualityGate.engine.", "INVALID_CONFIG_FILE");
+        }
+        const notes = typeof feedback === "string" && feedback.trim() !== "" ? [feedback.trim()] : [];
+        const verdict = await runReflectQualityJudge(config, candidate, source, notes, undefined, {
+            runnerSelectionFrozen: true,
+            llmRunner: judge,
+            ...(typeof ref === "string" && ref ? { ref } : {}),
+        });
+        output("improve-judge", { engine: judge.engine, ...verdict });
+    },
+});
+/** The subcommands `setup` withheld for this run, restored by `cleanup` (one command runs per process; in-process tests run many). */
+let subCommandsWithheld = false;
+const IMPROVE_SUBCOMMANDS = { report: improveReportCommand, judge: improveJudgeCommand };
 export const improveCommand = defineCommand({
     meta: {
         name: "improve",
-        description: "Analyze existing AKM assets and generate improvement proposals; also consolidates memories when the selected strategy enables consolidate.",
+        description: "Analyze existing AKM assets and generate improvement proposals; also consolidates memories when the selected strategy enables consolidate. `improve report` and `improve judge` are subcommands.",
+    },
+    subCommands: IMPROVE_SUBCOMMANDS,
+    // `improve` takes a scope positional (an asset type or ref), and citty reads
+    // the first positional of a command with subcommands as a subcommand name,
+    // failing with an unknown command for a scope. So the subcommands stay
+    // registered only for an invocation that names one; any other, scope or none,
+    // is the improve run itself.
+    setup(context) {
+        const index = findCittyTopLevelCommandIndex(context.rawArgs, improveCommand.args);
+        const token = index >= 0 ? context.rawArgs[index] : undefined;
+        if (token !== undefined && token in IMPROVE_SUBCOMMANDS)
+            return;
+        subCommandsWithheld = true;
+        context.cmd.subCommands = undefined;
+    },
+    cleanup(context) {
+        if (!subCommandsWithheld)
+            return;
+        context.cmd.subCommands = IMPROVE_SUBCOMMANDS;
+        subCommandsWithheld = false;
     },
     // Declared explicitly: otherwise citty takes `--format`'s value as the scope.
     args: {
@@ -252,11 +258,6 @@ export const improveCommand = defineCommand({
         },
         task: { type: "string", description: "Add extra guidance for this improvement pass" },
         "dry-run": { type: "boolean", description: "Show planned actions without writing", default: false },
-        plan: {
-            type: "boolean",
-            description: "Alias for --dry-run (#947). Sets the exact same internal flag; use it when previewing resolved process -> engine -> model routing (plan.processes) rather than checking what would write.",
-            default: false,
-        },
         bundle: {
             type: "string",
             description: "Bundle to improve and write proposals to (default: defaultWriteTarget, else the working bundle); only its assets are planned",
@@ -268,7 +269,7 @@ export const improveCommand = defineCommand({
         },
         "require-feedback-signal": {
             type: "boolean",
-            description: "Turn the proactive/high-salience fallback lanes off (they only select and score assets; a rewrite needs negative feedback)",
+            description: "Turn the proactive-maintenance lane off for this run, so only assets with recent feedback are planned",
             default: false,
         },
         "json-to-stdout": {
@@ -291,52 +292,36 @@ export const improveCommand = defineCommand({
             description: "Print the composed reflect prompt for one asset ref and exit — no lock, index write, or engine dispatch (#952). Requires a fully-qualified asset ref as the scope positional (e.g. `akm improve lessons/my-lesson --show-prompt`). JSON/yaml format carries the prompt as a `prompt` field; text format prints it directly.",
             default: false,
         },
-        run: {
-            type: "string",
-            description: 'Only with the "report" scope (`akm improve report --run <id>`): show the LLM usage/routing report for one specific improve_runs row instead of the most recent run. Mutually exclusive with --since.',
-        },
-        since: {
-            type: "string",
-            description: 'Only with the "report" scope (`akm improve report --since <window>`): aggregate the LLM usage/routing report over every real run started since <window> (a duration like "24h"/"7d", or an ISO timestamp) instead of showing one run. Mutually exclusive with --run.',
-        },
         strategy: {
             type: "string",
-            description: "Named improve strategy from improve.strategies or built-in strategies (catchup, consolidate, default, proactive-maintenance, quick, reflect-distill, thorough). Controls which sub-processes run and which asset types are processed.",
+            description: "Named improve strategy from improve.strategies or built-in strategies (consolidate, default). Controls which sub-processes run and which asset types are processed.",
         },
         sync: {
             type: "boolean",
-            description: "Commit (and optionally push) the git-backed primary bundle when the run finishes. Use --no-sync to disable. Default: on for git-backed bundles (per profile config).",
+            description: "Sync the git-backed primary bundle like `akm sync` (fetch and merge the upstream, commit, push) before the run, and commit (and optionally push) when it finishes. Use --no-sync to disable. Default: on for git-backed bundles (per profile config).",
         },
         push: {
             type: "boolean",
-            description: "Push after the end-of-run sync commit when writable + remote configured. Use --no-push to commit only. Default: per profile config (true).",
+            description: "Push after the pre-run and end-of-run sync commits when writable + remote configured. Use --no-push to commit only. Default: per profile config (true).",
         },
     },
     async run({ args }) {
         await runWithJsonErrors(async () => {
-            if (getStringArg(args, "scope") === "report") {
-                runImproveReportCli(args);
+            // citty runs this body after a subcommand it dispatched too.
+            if (hasSubcommand(args, new Set(Object.keys(IMPROVE_SUBCOMMANDS))))
                 return;
-            }
-            rejectReportOnlyFlags(args);
-            if (getStringArg(args, "scope") === "judge") {
-                await runImproveJudgeCli(getStringArg(args, "strategy"));
-                return;
-            }
-            rejectRetiredImproveTargetFlag();
             const jsonToStdout = args["json-to-stdout"];
             const targetArg = getStringArg(args, "bundle");
             const taskArg = getStringArg(args, "task");
-            // `--plan` is an alias for `--dry-run`; `--show-prompt` is read-only too.
-            const dryRun = args["dry-run"] || args.plan || args["show-prompt"];
+            // `--show-prompt` is read-only too.
+            const dryRun = args["dry-run"] || args["show-prompt"];
             const limitRaw = parsePositiveIntFlag(args.limit ?? undefined);
             const timeoutMs = parsePositiveIntFlag(args["timeout-ms"], "--timeout-ms");
             const requireFeedbackSignal = args["require-feedback-signal"];
             const skipIfLocked = args["skip-if-locked"];
             const strategyArg = getStringArg(args, "strategy");
             const effectiveConfig = loadConfig();
-            const scopeArg = resolveScopeAfterRetiredAutoAccept(getStringArg(args, "scope"));
-            rejectRetiredCanaryScope(scopeArg);
+            const scopeArg = getStringArg(args, "scope");
             const scopeRef = scopeArg && isFullRefInput(scopeArg) ? parseRefInput(scopeArg) : undefined;
             const writeTarget = dryRun
                 ? undefined
@@ -369,7 +354,7 @@ export const improveCommand = defineCommand({
             if (pushFlag !== undefined)
                 syncOverride.push = pushFlag;
             if (!dryRun) {
-                const improveLogFile = path.join(getCacheDir(), "logs", "improve", `${new Date().toISOString().replace(/[:.]/g, "-")}.log`);
+                const improveLogFile = path.join(getRunLogDir("improve"), `${new Date().toISOString().replace(/[:.]/g, "-")}.log`);
                 setLogFile(improveLogFile);
             }
             const startedAtMs = Date.now();
@@ -419,6 +404,7 @@ export const improveCommand = defineCommand({
                         ...(skipIfLocked ? { skipIfLocked } : {}),
                         ...(strategyArg !== undefined ? { strategy: strategyArg } : {}),
                         ...(engineProbe !== undefined ? { engineProbe } : {}),
+                        onBudgetHardKill: () => persistTerminated("budget_exhausted"),
                         ...(Object.keys(syncOverride).length > 0 ? { sync: syncOverride } : {}),
                     }),
                 }, {

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

@@ -1,17 +1,12 @@
 // 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 catchup from "../../assets/improve-strategies/catchup.json" with { type: "json" };
 import consolidate from "../../assets/improve-strategies/consolidate.json" with { type: "json" };
 import defaultStrategy from "../../assets/improve-strategies/default.json" with { type: "json" };
-import proactiveMaintenance from "../../assets/improve-strategies/proactive-maintenance.json" with { type: "json" };
-import quick from "../../assets/improve-strategies/quick.json" with { type: "json" };
-import reflectDistill from "../../assets/improve-strategies/reflect-distill.json" with { type: "json" };
-import thorough from "../../assets/improve-strategies/thorough.json" with { type: "json" };
 import { conceptIdFromTypeName, parseRefInput } from "../../core/asset/resolve-ref.js";
 import { ImproveProfileConfigSchema } from "../../core/config/config-schema.js";
 import { deepMergeConfig } from "../../core/config/deep-merge.js";
-import { BUILTIN_IMPROVE_STRATEGY_NAMES, IMPROVE_ENGINE_PROCESSES, IMPROVE_PROCESS_NAMES, } from "../../core/config/engine-semantics.js";
+import { BUILTIN_IMPROVE_STRATEGY_NAMES, IMPROVE_ENGINE_PROCESSES, IMPROVE_PROCESS_NAMES, REMOVED_IMPROVE_STRATEGY_NAMES, } from "../../core/config/engine-semantics.js";
 import { ConfigError } from "../../core/errors.js";
 import { describeLlmCredentialAvailability, } from "../../integrations/agent/engine-resolution.js";
 import { runnerLlmConnection } from "../../integrations/agent/runner.js";
@@ -69,12 +64,7 @@ export function isStrategyFilteredForAllPasses(ref, strategy) {
 }
 const BUILTIN_STRATEGIES = {
     default: defaultStrategy,
-    quick,
-    thorough,
     consolidate,
-    catchup,
-    "reflect-distill": reflectDistill,
-    "proactive-maintenance": proactiveMaintenance,
 };
 if (BUILTIN_IMPROVE_STRATEGY_NAMES.some((name) => !(name in BUILTIN_STRATEGIES))) {
     throw new Error("Built-in improve strategy names are out of sync with their assets");
@@ -105,6 +95,11 @@ export function resolveImproveStrategy(name, config) {
         // shape this refusal exists to reject, not a way around it.
         "Choose a different strategy. `graph-refresh` cannot be redefined under `improve.strategies` — it always refuses.");
     }
+    if (!(selectedName in BUILTIN_STRATEGIES) &&
+        !userStrategies[selectedName] &&
+        REMOVED_IMPROVE_STRATEGY_NAMES.includes(selectedName)) {
+        throw new ConfigError(`Improve strategy "${selectedName}" was removed in 0.10. Use "default" (or "consolidate"), or define "${selectedName}" under improve.strategies to keep your own version.`, "UNKNOWN_IMPROVE_STRATEGY", `Run \`akm improve --strategy default\`, or add \`improve.strategies.${selectedName}\` to your config; a block of that name is a user-defined strategy that inherits \`default\`.`);
+    }
     if (!(selectedName in BUILTIN_STRATEGIES) && !userStrategies[selectedName]) {
         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");
@@ -304,7 +299,8 @@ function buildImprovePlan(strategy, config, options) {
         });
     }
     if (engineUnavailable.length > 0 &&
-        !Object.values(processes).some((process) => process.enabled) &&
+        // proactiveMaintenance uses no engine: it is a selector, so it alone does not keep a run alive.
+        !IMPROVE_ENGINE_PROCESSES.some((name) => processes[name].enabled) &&
         (!options.allowAllDisabled || anyEngineNotConfigured)) {
         const names = engineUnavailable.map((item) => `"${item.process}"`).join(", ");
         throw new ConfigError(`No improve process can run: ${names} ${engineUnavailable.length === 1 ? "requires" : "require"} an engine that is not configured. Set defaults.llmEngine, or the per-process engine key named for each.`, "LLM_NOT_CONFIGURED");

package/dist/commands/improve/improve.js

@@ -28,7 +28,7 @@ import { resolveEntryContentDir, resolveSourceEntries } from "../../indexer/sear
 import { collectEngineCredentialValues } from "../../integrations/agent/engine-resolution.js";
 import { installLlmUsagePersistence } from "../../llm/usage-persist.js";
 import { withLlmStage } from "../../llm/usage-telemetry.js";
-import { isGitBackedStash, listGitChangedPaths, resolveWritableOverride, saveGitStash, } from "../../sources/providers/git.js";
+import { GitStashPushError, isGitBackedStash, listGitChangedPaths, resolveWritableOverride, saveGitStash, } from "../../sources/providers/git.js";
 import { closeDatabase, openExistingDatabase } from "../../storage/repositories/index-connection.js";
 import { getEntryCount } from "../../storage/repositories/index-entries-repository.js";
 import { openSqliteReadSnapshot, SqliteReadSnapshotUnavailableError } from "../../storage/sqlite-read-snapshot.js";
@@ -70,7 +70,8 @@ export function renderSyncCommitMessage(template, result, nowMs) {
 export const FIRST_ENGINE_RESPONSE_HEARTBEAT_MS = 5_000;
 /**
  * Abort the run at the budget; force-exit (0 — budget exhaustion is a normal
- * scheduled-task outcome) only if the drain overruns the grace period.
+ * scheduled-task outcome) only if the drain overruns the grace period, after
+ * `onHardKill` has persisted what the killed run left behind.
  * Returns an idempotent disposer.
  */
 export function armBudgetWatchdog(budgetMs, controller, deps) {
@@ -81,7 +82,15 @@ export function armBudgetWatchdog(budgetMs, controller, deps) {
     let hardKillTimer;
     const budgetTimer = setTimeoutFn(() => {
         controller.abort("improve budget exhausted");
-        hardKillTimer = setTimeoutFn(() => exitFn(0), hardKillGraceMs);
+        hardKillTimer = setTimeoutFn(() => {
+            try {
+                deps?.onHardKill?.();
+            }
+            catch {
+                // Best-effort: the forced exit must still happen.
+            }
+            exitFn(0);
+        }, hardKillGraceMs);
         hardKillTimer.unref?.();
     }, budgetMs);
     return () => {
@@ -101,6 +110,7 @@ export async function akmImprove(options = {}) {
     // Set by the usage sink when any engine call terminates, prepass included.
     let firstEngineResponseSeen = false;
     let initialGitPaths = new Set();
+    let preRunSync;
     // The write-provenance journal (#652) spans exactly the window this run holds the lock.
     let journal;
     const closeJournal = () => {
@@ -155,7 +165,20 @@ export async function akmImprove(options = {}) {
     });
     if (!options.dryRun) {
         const remainingBudget = budgetAbortController.signal.remainingBudgetMs;
-        clearBudgetTimer = armBudgetWatchdog(Math.max(1, remainingBudget ?? budgetMs), budgetAbortController);
+        clearBudgetTimer = armBudgetWatchdog(Math.max(1, remainingBudget ?? budgetMs), budgetAbortController, {
+            // The forced exit skips every finally and the CLI catch: leave a terminated
+            // run record and bank the files this run wrote (journal is in memory) first.
+            // Local commit only — a push to a dead remote must not hang the exit.
+            onHardKill: () => {
+                try {
+                    options.onBudgetHardKill?.();
+                }
+                catch {
+                    // best-effort
+                }
+                commitStashBatch({ scope, plannedRefs: collected?.plannedRefs ?? [], runId: options.runId }, { push: false });
+            },
+        });
     }
     try {
         if (!options.dryRun) {
@@ -174,6 +197,9 @@ export async function akmImprove(options = {}) {
             });
             exitBackstop = releaseRunLock;
             process.on("exit", exitBackstop);
+            // Pull in what another host pushed before anything reads the bundle (#1091). This also commits
+            // pending managed-path changes, as `akm sync` does, so they are not mistaken for this run's writes.
+            preRunSync = syncBeforeRun(setup, eventsCtx);
             initialGitPaths =
                 syncRepoDir && isGitBackedStash(syncRepoDir) ? new Set(listGitChangedPaths(syncRepoDir)) : new Set();
             journal = beginWriteProvenance();
@@ -246,6 +272,8 @@ export async function akmImprove(options = {}) {
         if (writtenPaths.length > 0)
             result.writtenPaths = writtenPaths;
         result.sync = commitStashBatch(result);
+        if (preRunSync)
+            result.preRunSync = preRunSync;
         return result;
     }
     catch (err) {
@@ -654,7 +682,7 @@ function buildResultExecutionPlan(run, preparation, collected, dryRun) {
             enabled: scope.mode !== "ref" && resolvedPlan.processes.triage.enabled,
             configuredMode: configuredTriage?.applyMode ?? "queue",
             mode: improveProfile.processes?.triage?.applyMode ?? "queue",
-            maxAcceptsPerRun: configuredTriage?.maxAcceptsPerRun ?? 25,
+            maxAcceptsPerRun: configuredTriage?.maxAcceptsPerRun ?? 200,
         },
     });
 }
@@ -674,7 +702,7 @@ async function runTriagePrePass(run) {
             ...(options.target ? { target: options.target } : {}),
             config: options.config,
             applyMode: triageConfig?.applyMode ?? "queue",
-            maxAccepts: triageConfig?.maxAcceptsPerRun ?? 25,
+            maxAccepts: triageConfig?.maxAcceptsPerRun ?? 200,
             dryRun: false,
             excludeIds: new Set(),
             judgment: resolvedPlan.triageJudgment,
@@ -712,60 +740,114 @@ export function resolveSyncPathSet(input) {
         unattributed: changedPaths.filter((p) => !attributed.has(p) && !initialPaths.has(p) && inScope(p)).sort(),
     };
 }
+/**
+ * One `saveGitStash` call for the run's write-target bundle, shared by the
+ * pre-run sync and the auto-sync commit: never throws, records a `stash_synced`
+ * event, and returns undefined when the bundle is not git-backed, there is no
+ * primary stash, or sync is disabled (`--no-sync` / `sync.enabled: false`).
+ * `scopePaths` runs inside the guard; leaving `paths` undefined means what
+ * `akm sync` stages (the managed paths).
+ */
+function runStashSync(run, eventsCtx, phase, input) {
+    const { writeTarget, primaryStashDir, effectiveSync, options, config, improveProfile } = run;
+    const repoDir = writeTarget?.source.repoPath ?? primaryStashDir;
+    if (!primaryStashDir || !repoDir || effectiveSync.enabled === false || !isGitBackedStash(repoDir)) {
+        return undefined;
+    }
+    const saveGitStashFn = options.saveGitStashFn ?? saveGitStash;
+    const writableOverride = writeTarget ? resolveWritable(writeTarget.config) : resolveWritableOverride(config);
+    const push = input.push ?? options.sync?.push ?? improveProfile.sync?.push ?? true;
+    const record = (metadata) => appendEvent({ eventType: "stash_synced", metadata: { phase, ...metadata } }, eventsCtx);
+    try {
+        const { paths, unattributed } = input.scopePaths({
+            repoDir,
+            assetRoot: writeTarget?.source.path ?? primaryStashDir,
+        });
+        const syncResult = saveGitStashFn(undefined, input.message, writableOverride, {
+            push,
+            repoDir,
+            ...(paths ? { paths } : {}),
+        });
+        record({
+            committed: syncResult.committed,
+            pushed: syncResult.pushed,
+            skipped: syncResult.skipped,
+            reason: syncResult.reason ?? null,
+            ...(paths ? { attributed: paths.length, unattributed: unattributed ?? 0 } : {}),
+        });
+        return {
+            committed: syncResult.committed,
+            pushed: syncResult.pushed,
+            skipped: syncResult.skipped,
+            ...(syncResult.reason !== undefined ? { reason: syncResult.reason } : {}),
+        };
+    }
+    catch (syncErr) {
+        const reason = errMessage(syncErr);
+        warn(`improve: stash sync failed (non-fatal): ${reason}`);
+        // A push that failed after the commit landed still left the commit in the repo.
+        const committed = syncErr instanceof GitStashPushError;
+        record({ committed, pushed: false, skipped: true, reason });
+        return { committed, pushed: false, skipped: true, reason };
+    }
+}
+/**
+ * The pre-run sync (#1091): the same fetch / fast-forward-or-merge / commit /
+ * push `akm sync` runs for the write-target bundle, before the index and plan
+ * stages so they see what another host pushed. A conflict or fetch failure is
+ * a warning, never an abort: the run continues on the local state.
+ */
+function syncBeforeRun(run, eventsCtx) {
+    const outcome = runStashSync(run, eventsCtx, "pre-run", {
+        message: "akm improve pre-run sync",
+        scopePaths: ({ repoDir, assetRoot }) => {
+            // A bundle whose content sits in a subdirectory of the repo stages only that subdirectory, as
+            // `akm sync` does for a content root; a root-level bundle leaves `paths` to the managed-path default.
+            const assetPrefix = path.relative(repoDir, assetRoot).replaceAll(path.sep, "/");
+            if (!assetPrefix)
+                return {};
+            return resolveSyncPathSet({
+                repoDir,
+                assetPrefix,
+                changedPaths: listGitChangedPaths(repoDir),
+                initialPaths: new Set(),
+                writtenPaths: [],
+                provenance: false,
+            });
+        },
+    });
+    if (outcome?.reason)
+        warn(`[improve] pre-run sync: ${outcome.reason}; continuing on the local state`);
+    return outcome;
+}
 /**
  * The auto-sync commit (#662), used at end of run and from the crash path:
  * idempotent and never throws. The getters read bindings reassigned after this
  * factory runs.
  */
 function makeCommitStashBatch(deps) {
-    const { writeTarget, primaryStashDir, effectiveSync, options, config, improveProfile } = deps.run;
-    return (messageContext) => {
-        const eventsCtx = deps.getEventsCtx();
+    const { effectiveSync } = deps.run;
+    return (messageContext, override) => {
         const writeJournal = deps.getWriteJournal();
-        const repoDir = writeTarget?.source.repoPath ?? primaryStashDir;
-        if (!primaryStashDir || !repoDir || effectiveSync.enabled === false || !isGitBackedStash(repoDir)) {
-            return undefined;
-        }
-        const saveGitStashFn = options.saveGitStashFn ?? saveGitStash;
-        const writableOverride = writeTarget ? resolveWritable(writeTarget.config) : resolveWritableOverride(config);
-        const push = options.sync?.push ?? improveProfile.sync?.push ?? true;
         const message = renderSyncCommitMessage(effectiveSync.message ?? "akm improve auto-sync", messageContext, Date.now());
-        const record = (metadata) => appendEvent({ eventType: "stash_synced", metadata }, eventsCtx);
-        try {
-            const assetRoot = writeTarget?.source.path ?? primaryStashDir;
-            const { paths, unattributed } = resolveSyncPathSet({
-                repoDir,
-                assetPrefix: path.relative(repoDir, assetRoot).replaceAll(path.sep, "/"),
-                changedPaths: listGitChangedPaths(repoDir),
-                initialPaths: deps.getInitialGitPaths(),
-                writtenPaths: writeJournal?.writtenPaths() ?? [],
-                provenance: writeJournal !== undefined,
-            });
-            if (unattributed.length > 0) {
-                warnVerbose(`[improve] auto-sync left ${unattributed.length} path(s) uncommitted — not written by this run: ${unattributed.join(", ")}`);
-            }
-            const syncResult = saveGitStashFn(undefined, message, writableOverride, { push, repoDir, paths });
-            record({
-                committed: syncResult.committed,
-                pushed: syncResult.pushed,
-                skipped: syncResult.skipped,
-                reason: syncResult.reason ?? null,
-                attributed: paths.length,
-                unattributed: unattributed.length,
-            });
-            return {
-                committed: syncResult.committed,
-                pushed: syncResult.pushed,
-                skipped: syncResult.skipped,
-                ...(syncResult.reason !== undefined ? { reason: syncResult.reason } : {}),
-            };
-        }
-        catch (syncErr) {
-            const reason = errMessage(syncErr);
-            warn(`improve: stash sync failed (non-fatal): ${reason}`);
-            record({ committed: false, pushed: false, skipped: true, reason });
-            return { committed: false, pushed: false, skipped: true, reason };
-        }
+        return runStashSync(deps.run, deps.getEventsCtx(), "end-of-run", {
+            message,
+            push: override?.push,
+            scopePaths: ({ repoDir, assetRoot }) => {
+                const { paths, unattributed } = resolveSyncPathSet({
+                    repoDir,
+                    assetPrefix: path.relative(repoDir, assetRoot).replaceAll(path.sep, "/"),
+                    changedPaths: listGitChangedPaths(repoDir),
+                    initialPaths: deps.getInitialGitPaths(),
+                    writtenPaths: writeJournal?.writtenPaths() ?? [],
+                    provenance: writeJournal !== undefined,
+                });
+                if (unattributed.length > 0) {
+                    warnVerbose(`[improve] auto-sync left ${unattributed.length} path(s) uncommitted — not written by this run: ${unattributed.join(", ")}`);
+                }
+                return { paths, unattributed: unattributed.length };
+            },
+        });
     };
 }
 /**