akm-cli 0.9.0-beta.44 → 0.9.0-beta.46

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

@@ -13,6 +13,7 @@ import { resolveSourceEntries } from "../../indexer/search/search-source.js";
 import { getHyphenatedArg, getHyphenatedBoolean, parseFlagValue } from "../../output/context.js";
 import { akmImprove } from "./improve.js";
 import { buildImproveRunId, recordTerminatedImproveRun, relativeImproveResultPath, writeImproveResultFile, } from "./improve-result-file.js";
+import { runImproveSession } from "./improve-session.js";
 export const improveCommand = defineCommand({
     meta: {
         name: "improve",
@@ -144,67 +145,44 @@ export const improveCommand = defineCommand({
                     process.stderr.write(`warning: failed to persist terminated improve run ${runId}: ${err instanceof Error ? err.message : String(err)}\n`);
                 }
             };
-            // M5 (code-health round 2): signal -> {exit code, reason, ack message}
-            // as an explicit table instead of three near-identical handlers. The
-            // persist of the terminated-run row MUST complete before process.exit so
-            // a SIGTERM'd run (e.g. cron timeout) always leaves a row in
-            // improve_runs. recordTerminatedImproveRun is fully synchronous
-            // (bun:sqlite writes are sync), so the in-line call below blocks until
-            // the row is flushed before we exit.
-            const SIGNAL_TABLE = {
-                SIGTERM: { code: 143, reason: "SIGTERM", ack: true },
-                SIGINT: { code: 130, reason: "SIGINT", ack: true },
-                SIGHUP: { code: 129, reason: "SIGHUP", ack: false },
-            };
-            const makeSignalHandler = (sig) => () => {
-                const { code, reason, ack } = SIGNAL_TABLE[sig];
-                // Hard-exit fallback: if the synchronous persist ever hangs (e.g. a
-                // stuck sqlite lock under contention), the watchdog still exits with
-                // the correct code instead of leaving a zombie process. .unref() keeps
-                // the timer from holding the loop open on the normal (fast) path.
-                const watchdog = setTimeout(() => process.exit(code), 2000);
-                if (typeof watchdog.unref === "function")
-                    watchdog.unref();
-                try {
-                    persistTerminated(reason);
-                }
-                finally {
-                    clearTimeout(watchdog);
-                }
-                if (ack) {
-                    process.stderr.write(`[improve] received ${sig}; recorded terminated run ${runId}\n`);
-                }
-                process.exit(code);
-            };
-            const sigtermHandler = makeSignalHandler("SIGTERM");
-            const sigintHandler = makeSignalHandler("SIGINT");
-            const sighupHandler = makeSignalHandler("SIGHUP");
-            process.once("SIGTERM", sigtermHandler);
-            process.once("SIGINT", sigintHandler);
-            process.once("SIGHUP", sighupHandler);
+            // R8: the signal table / handlers / watchdog / persist-before-exit
+            // choreography lives in `runImproveSession`. It registers the
+            // SIGTERM/SIGINT/SIGHUP handlers (each persists the terminated-run row
+            // BEFORE process.exit so a SIGTERM'd run — e.g. cron timeout — always
+            // leaves a row in improve_runs), awaits the work, then removes the
+            // handlers on the way out. `onTerminate` persists synchronously
+            // (recordTerminatedImproveRun -> bun:sqlite writes are sync), and the
+            // 2000ms watchdog inside the session force-exits if that ever hangs.
             let improveResult;
             try {
-                improveResult = await akmImprove({
-                    scope: scopeArg,
-                    task: taskArg,
-                    dryRun,
-                    target: targetArg,
-                    autoAccept,
-                    ...(runId !== undefined ? { runId } : {}),
-                    ...(limitRaw !== undefined ? { limit: limitRaw } : {}),
-                    ...(timeoutMs !== undefined ? { timeoutMs } : {}),
-                    ...(minRetrievalCount !== undefined ? { minRetrievalCount } : {}),
-                    ...(requireFeedbackSignal ? { requireFeedbackSignal } : {}),
-                    ...(skipIfLocked ? { skipIfLocked } : {}),
-                    ...(profileArg !== undefined ? { profile: profileArg } : {}),
-                    ...(Object.keys(syncOverride).length > 0 ? { sync: syncOverride } : {}),
-                    consolidateOptions: {
-                        target: targetArg,
+                improveResult = await runImproveSession({
+                    runWork: () => akmImprove({
+                        scope: scopeArg,
+                        task: taskArg,
                         dryRun,
+                        target: targetArg,
                         autoAccept,
-                        task: taskArg,
-                        ...(consolidateRecovery !== undefined ? { recoveryMode: consolidateRecovery } : {}),
-                    },
+                        ...(runId !== undefined ? { runId } : {}),
+                        ...(limitRaw !== undefined ? { limit: limitRaw } : {}),
+                        ...(timeoutMs !== undefined ? { timeoutMs } : {}),
+                        ...(minRetrievalCount !== undefined ? { minRetrievalCount } : {}),
+                        ...(requireFeedbackSignal ? { requireFeedbackSignal } : {}),
+                        ...(skipIfLocked ? { skipIfLocked } : {}),
+                        ...(profileArg !== undefined ? { profile: profileArg } : {}),
+                        ...(Object.keys(syncOverride).length > 0 ? { sync: syncOverride } : {}),
+                        consolidateOptions: {
+                            target: targetArg,
+                            dryRun,
+                            autoAccept,
+                            task: taskArg,
+                            ...(consolidateRecovery !== undefined ? { recoveryMode: consolidateRecovery } : {}),
+                        },
+                    }),
+                }, {
+                    signalSource: process,
+                    exit: process.exit,
+                    onTerminate: (reason) => persistTerminated(reason),
+                    ack: (message) => process.stderr.write(`[improve] ${message}; recorded terminated run ${runId}\n`),
                 });
             }
             catch (err) {
@@ -216,9 +194,6 @@ export const improveCommand = defineCommand({
                 throw err;
             }
             finally {
-                process.removeListener("SIGTERM", sigtermHandler);
-                process.removeListener("SIGINT", sigintHandler);
-                process.removeListener("SIGHUP", sighupHandler);
                 clearLogFile();
             }
             const durationMs = Date.now() - startedAtMs;

package/dist/commands/improve/improve-result-file.js

@@ -27,7 +27,7 @@
  */
 import crypto from "node:crypto";
 import path from "node:path";
-import { openStateDatabase, recordImproveRun } from "../../core/state-db.js";
+import { recordImproveRun, withStateDb } from "../../core/state-db.js";
 /**
  * Build a stable run-id for a single improve invocation.
  *
@@ -74,8 +74,7 @@ export function relativeImproveResultPath(runId) {
  * `feedback_akm_dryrun_artifact_trap`).
  */
 export function writeImproveResultFile(stashDir, runId, result, startedAt) {
-    const db = openStateDatabase();
-    try {
+    withStateDb((db) => {
         const completedAt = new Date().toISOString();
         // startedAt is the ISO timestamp captured at process launch (passed from the
         // CLI entry point). If omitted, fall back to the run-id's embedded timestamp
@@ -95,15 +94,7 @@ export function writeImproveResultFile(stashDir, runId, result, startedAt) {
             ok: Boolean(result.ok),
             result,
         });
-    }
-    finally {
-        try {
-            db.close();
-        }
-        catch {
-            // best-effort
-        }
-    }
+    });
     return relativeImproveResultPath(runId);
 }
 /**
@@ -138,8 +129,7 @@ export function recordTerminatedImproveRun(stashDir, runId, startedAt, reason, c
             ...(ctx?.errorMessage ? { errorMessage: ctx.errorMessage } : {}),
         },
     };
-    const db = openStateDatabase();
-    try {
+    withStateDb((db) => {
         recordImproveRun(db, {
             id: runId,
             startedAt,
@@ -160,13 +150,5 @@ export function recordTerminatedImproveRun(stashDir, runId, startedAt, reason, c
                 },
             },
         });
-    }
-    finally {
-        try {
-            db.close();
-        }
-        catch {
-            // best-effort
-        }
-    }
+    });
 }

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

@@ -0,0 +1,58 @@
+// 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/.
+/** Signal -> {exit code, reason, ack message}. */
+export const SIGNAL_TABLE = {
+    SIGTERM: { code: 143, reason: "SIGTERM", ack: true },
+    SIGINT: { code: 130, reason: "SIGINT", ack: true },
+    SIGHUP: { code: 129, reason: "SIGHUP", ack: false },
+};
+/**
+ * Drive the improve-run lifecycle: register signal handlers, await `runWork`,
+ * and on clean completion remove the handlers and resolve with the result. The
+ * caller (improve-cli.ts) owns success-path result persistence + the final
+ * `exit(0)`; this function returns the work result so that choreography stays
+ * in the CLI exactly as before.
+ *
+ * Abnormal paths:
+ *   - A registered signal fires -> persist terminated row (watchdog-guarded) ->
+ *     optional ack -> `exit(code)`.
+ *   - `runWork` rejects -> handlers are removed and the rejection propagates so
+ *     the CLI's existing catch can persist `"exception"` and rethrow.
+ */
+export async function runImproveSession(opts, deps) {
+    const { signalSource, exit, onTerminate, ack } = deps;
+    const makeSignalHandler = (sig) => () => {
+        const { code, reason, ack: shouldAck } = SIGNAL_TABLE[sig];
+        // Hard-exit fallback: if the synchronous persist ever hangs (e.g. a stuck
+        // sqlite lock under contention), the watchdog still exits with the correct
+        // code instead of leaving a zombie process. .unref() keeps the timer from
+        // holding the loop open on the normal (fast) path.
+        const watchdog = setTimeout(() => exit(code), 2000);
+        if (typeof watchdog.unref === "function")
+            watchdog.unref();
+        try {
+            onTerminate(reason);
+        }
+        finally {
+            clearTimeout(watchdog);
+        }
+        if (shouldAck)
+            ack?.(`received ${sig}`);
+        exit(code);
+    };
+    const sigtermHandler = makeSignalHandler("SIGTERM");
+    const sigintHandler = makeSignalHandler("SIGINT");
+    const sighupHandler = makeSignalHandler("SIGHUP");
+    signalSource.once("SIGTERM", sigtermHandler);
+    signalSource.once("SIGINT", sigintHandler);
+    signalSource.once("SIGHUP", sighupHandler);
+    try {
+        return await opts.runWork();
+    }
+    finally {
+        signalSource.removeListener("SIGTERM", sigtermHandler);
+        signalSource.removeListener("SIGINT", sigintHandler);
+        signalSource.removeListener("SIGHUP", sighupHandler);
+    }
+}