akm-cli 0.9.0-rc.0 → 0.9.0-rc.13

package/dist/commands/improve/feedback-valence.js

@@ -26,12 +26,6 @@
 export const UTILITY_WEIGHT = 0.7;
 /** Weight on the feedback attention term in the combined eligibility score. */
 export const FEEDBACK_WEIGHT = 0.3;
-/**
- * Minimum |valence| magnitude for an item to be ROUTED to the fix / reinforce
- * lane. Below this the feedback is too weak/mixed to be a confident signal and
- * the item carries no attention lane (`null`). Pure magnitude in [0, 1].
- */
-export const STRONG_VALENCE_THRESHOLD = 0.5;
 /**
  * Compute the symmetric-valence attention score for one asset's feedback.
  *
@@ -42,13 +36,9 @@ export function computeValenceScore(counts) {
     const negative = Math.max(0, counts.negative);
     const total = positive + negative;
     if (total === 0) {
-        return { valence: 0, magnitude: 0, attention: 0, lane: null };
+        return { valence: 0, magnitude: 0, attention: 0 };
     }
     const valence = (positive - negative) / total;
     const magnitude = Math.abs(valence);
-    let lane = null;
-    if (magnitude >= STRONG_VALENCE_THRESHOLD) {
-        lane = valence < 0 ? "fix" : "reinforce";
-    }
-    return { valence, magnitude, attention: magnitude, lane };
+    return { valence, magnitude, attention: magnitude };
 }

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

@@ -3,116 +3,108 @@
 // file, You can obtain one at https://mozilla.org/MPL/2.0/.
 import path from "node:path";
 import { defineCommand } from "citty";
-import { getStringArg, parseAutoAcceptFlag, parseNonNegativeIntFlag, parsePositiveIntFlag } from "../../cli/parse-args.js";
-import { output, runWithJsonErrors } from "../../cli/shared.js";
+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 { isFullRefInput, parseRefInput } from "../../core/asset/resolve-ref.js";
 import { loadConfig } from "../../core/config/config.js";
 import { UsageError } from "../../core/errors.js";
+import { resolveMutationTarget } from "../../core/mutation-target.js";
 import { getCacheDir } from "../../core/paths.js";
-import { withStateDb } from "../../core/state-db.js";
-import { clearLogFile, setLogFile } from "../../core/warn.js";
-import { closeDatabase, openExistingDatabase } from "../../indexer/db/db.js";
-import { resolveSourceEntries } from "../../indexer/search/search-source.js";
-import { parseFlagValue } from "../../output/context.js";
-import { getActiveCanaries, queryRecentCycleMetrics } from "../../storage/repositories/canaries-repository.js";
-import { refreshCanarySet } from "./collapse-detector.js";
+import { redactSensitiveText } from "../../core/redaction.js";
+import { clearLogFile, setLogFile, warn } from "../../core/warn.js";
+import { resolveWriteTarget } from "../../core/write-source.js";
+import { collectEngineCredentialValues } from "../../integrations/agent/engine-resolution.js";
 import { akmImprove } from "./improve.js";
-import { buildImproveRunId, recordTerminatedImproveRun, relativeImproveResultPath, writeImproveResultFile, } from "./improve-result-file.js";
+import { buildImproveRunId, recordImproveRunResult, recordTerminatedImproveRun, } from "./improve-result-file.js";
 import { runImproveSession } from "./improve-session.js";
-// R5 — collapse-detector canary set inspection / explicit refresh. The
-// detector NEVER auto-refreshes the canary set (silent re-baselining is how a
-// slow collapse hides); this verb is the only refresh path.
-//
-// Dispatched from the parent improve run() on `scope === "canary"` — NOT a
-// citty subCommand: registering subCommands makes citty treat EVERY first
-// positional as a subcommand name, breaking `akm improve <type|ref>` outright
-// (citty throws "Unknown command memory"), and citty also re-runs the parent
-// run() after a matched subcommand.
-async function runCanaryInspection(refresh) {
-    const config = loadConfig();
-    const cfg = config.improve?.collapseDetector ?? {};
-    const result = withStateDb((stateDb) => {
-        let refreshOutcome;
-        if (refresh) {
-            const indexDb = openExistingDatabase();
-            try {
-                // Mint-first, deactivate-after (refreshCanarySet): an empty/unreadable
-                // index keeps the old baseline instead of destroying it.
-                refreshOutcome = refreshCanarySet(stateDb, indexDb, cfg) === null ? "kept-old-set" : "refreshed";
-            }
-            finally {
-                closeDatabase(indexDb);
-            }
-        }
-        const canaries = getActiveCanaries(stateDb);
-        const canarySetId = canaries[0]?.canary_set_id;
-        const recentCycles = canarySetId ? queryRecentCycleMetrics(stateDb, canarySetId, cfg.windowCycles ?? 5) : [];
-        return {
-            schemaVersion: 1,
-            ok: true,
-            refreshed: refreshOutcome === "refreshed",
-            ...(refreshOutcome === "kept-old-set"
-                ? { warning: "refresh skipped: no mintable learning entries in the index — existing canary set kept" }
-                : {}),
-            canarySetId: canarySetId ?? null,
-            canaries: canaries.map((c) => ({ id: c.id, anchorRef: c.anchor_ref, query: c.query })),
-            recentCycles: recentCycles.map((r) => ({
-                ts: r.ts,
-                pass: r.pass,
-                meanRecall: r.mean_recall,
-                meanNdcg: r.mean_ndcg,
-                distinctContentRatio: r.distinct_content_ratio,
-                acceptedActions: r.accepted_actions,
-                mergeFloorViolations: r.merge_floor_violations,
-                alerts: JSON.parse(r.alerts_json),
-            })),
-        };
-    });
-    output("improve-canary", result);
+import { resolveImprovePlan } from "./improve-strategies.js";
+let akmImproveForRun = akmImprove;
+/** Swap the CLI's improve work implementation in deterministic subprocess tests. */
+export function _setAkmImproveForTests(fake) {
+    akmImproveForRun = fake ?? akmImprove;
+}
+/**
+ * Handle the `--auto-accept` flag retired in 0.9.0, returning the scope the run
+ * should actually use.
+ *
+ * citty is non-strict, so the removed flag is silently absorbed rather than
+ * rejected — which is the dangerous case. The SPACE-separated spelling
+ * (`--auto-accept 90`) leaves `90` sitting in the positional slot, where it is
+ * read as the asset-type scope: the run then matches nothing and exits 0, so a
+ * 0.8-era crontab goes dark with no error at all. Warn about the flag, and drop
+ * the poisoned positional so the run behaves as an unscoped improve instead.
+ */
+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` was removed in 0.9 (moved to
+ * `scripts/refresh-canary-set.ts`). Without this check "canary" falls through
+ * to the generic scope positional, where resolveImproveScope treats any bare
+ * word as a type filter that matches zero entries — so an unmigrated caller
+ * silently acquires the improve lock and exits 0 having done nothing, instead
+ * of getting an error.
+ */
+function rejectRetiredCanaryScope(scopeArg) {
+    if (scopeArg !== "canary")
+        return;
+    throw new UsageError('"akm improve canary" was removed in 0.9. Use `bun scripts/refresh-canary-set.ts [--refresh]` instead.', "INVALID_FLAG_VALUE");
+}
+/**
+ * `--target` was renamed to `--bundle` on `improve` in 0.9 (S8). citty is
+ * non-strict, so the retired spelling is silently absorbed rather than
+ * rejected — accepted proposals then write into the default bundle instead
+ * of the one the caller named, with exit 0 and no error. Reject it
+ * explicitly instead.
+ */
+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");
 }
 export const improveCommand = defineCommand({
     meta: {
         name: "improve",
-        description: "Analyze existing AKM assets and generate improvement proposals; also consolidates memories when profiles.improve.default.processes.consolidate.enabled is true. `akm improve canary [--refresh]` inspects the collapse-detector canary set.",
+        description: "Analyze existing AKM assets and generate improvement proposals; also consolidates memories when the selected strategy enables consolidate.",
     },
+    // Raw defineCommand, so the global output flags are declared here explicitly.
+    // Without them citty treats `--format` as a boolean and its space-separated
+    // value falls through to the `scope` positional.
     args: {
+        ...GLOBAL_OUTPUT_ARGS,
         scope: {
             type: "positional",
             description: "Optional asset type or asset ref to improve",
             required: false,
         },
         task: { type: "string", description: "Add extra guidance for this improvement pass" },
-        refresh: {
-            type: "boolean",
-            description: "(canary scope only) Mint a new collapse-detector canary set and deactivate the old one; old rows and their cycle history are retained",
-            default: false,
-        },
         "dry-run": { type: "boolean", description: "Show planned actions without writing", default: false },
-        target: { type: "string", description: "Override the write target for accepted proposals" },
-        "auto-accept": {
-            type: "string",
-            description: "Auto-accept proposals at or above this confidence threshold (0-100). Default: disabled. Pass a value 0-100 to enable. 'safe' is an alias for 90. Pass 'false' to be explicit.",
-        },
+        bundle: { type: "string", description: "Override the write target for accepted proposals" },
         limit: { type: "string", description: "Maximum number of assets to process (highest utility first)" },
         "timeout-ms": {
             type: "string",
             description: "Wall-clock budget for the entire run in milliseconds (default: 7200000 = 2 hours)",
         },
-        "consolidate-recovery": {
-            type: "string",
-            description: "How to handle stale/incomplete consolidation journals: abort (default) or clean (remove stale journal artifacts)",
-        },
         "require-feedback-signal": {
             type: "boolean",
-            description: "Only process assets with recent feedback signals (disables retrieval fallback)",
+            description: "Only process assets with recent feedback signals (disables the proactive/high-salience fallback lanes)",
             default: false,
         },
-        "min-retrieval-count": {
-            type: "string",
-            description: "Minimum retrieval count for zero-feedback fallback eligibility (default: 1, set 0 to include all assets regardless of retrieval history)",
-        },
         "json-to-stdout": {
             type: "boolean",
-            description: "Emit the full JSON result on stdout (legacy behaviour). (0.8.0+: full result is recorded in the improve_runs table of state.db and stdout is empty; use this flag for the prior behaviour, e.g. `akm improve --json-to-stdout | jq`.)",
+            description: "Also emit the full persisted run result on stdout as JSON.",
             default: false,
         },
         "skip-if-locked": {
@@ -120,13 +112,13 @@ export const improveCommand = defineCommand({
             description: "If another improve run already holds the lock, skip gracefully (exit 0) instead of failing with 'already running' (exit 78). Use for high-frequency scheduled runs so they don't pile up failures while a longer run is in progress.",
             default: false,
         },
-        profile: {
+        strategy: {
             type: "string",
-            description: "Named improve profile from profiles.improve or built-in profiles (default, quick, thorough, memory-focus, graph-refresh). Controls which sub-processes run and which asset types are processed.",
+            description: "Named improve strategy from improve.strategies or built-in strategies (catchup, consolidate, default, frequent, graph-refresh, memory-focus, proactive-maintenance, quick, reflect-distill, thorough). Controls which sub-processes run and which asset types are processed.",
         },
         sync: {
             type: "boolean",
-            description: "Commit (and optionally push) the git-backed primary stash when the run finishes. Use --no-sync to disable. Default: on for git-backed stashes (per profile config).",
+            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).",
         },
         push: {
             type: "boolean",
@@ -134,39 +126,37 @@ export const improveCommand = defineCommand({
         },
     },
     async run({ args }) {
-        // "canary" is a reserved scope word (never a valid asset type, and refs
-        // contain ":"): dispatch to the detector inspection verb instead of an
-        // improve run.
-        if (args.scope === "canary") {
-            await runWithJsonErrors(() => runCanaryInspection(args.refresh));
-            return;
-        }
         await runWithJsonErrors(async () => {
-            const formatFlagValue = parseFlagValue(process.argv, "--format");
-            if (formatFlagValue !== undefined) {
-                throw new UsageError(`akm improve does not accept --format. That flag controls output formatting for other commands (search, show, etc.).\n` +
-                    `Did you mean: akm improve (no --format flag)?`, "INVALID_FLAG_VALUE");
-            }
+            rejectRetiredImproveTargetFlag();
+            // D7 — `--format` used to be rejected here outright. It is a global flag on
+            // a command that does emit an envelope through `output()` (always on
+            // `--dry-run`, otherwise with `--json-to-stdout`), so rejecting it made
+            // improve a fourth inconsistent format behaviour rather than a documented
+            // exemption. It now applies to that envelope; progress output stays on
+            // stderr regardless.
             const jsonToStdout = args["json-to-stdout"];
-            const autoAcceptRaw = args["auto-accept"];
-            const autoAccept = parseAutoAcceptFlag(autoAcceptRaw);
-            const targetArg = getStringArg(args, "target");
+            const targetArg = getStringArg(args, "bundle");
             const taskArg = getStringArg(args, "task");
             const dryRun = args["dry-run"];
             const limitRaw = parsePositiveIntFlag(args.limit ?? undefined);
             const timeoutMs = parsePositiveIntFlag(args["timeout-ms"], "--timeout-ms");
-            const consolidateRecoveryRaw = args["consolidate-recovery"];
-            const consolidateRecovery = consolidateRecoveryRaw === undefined
-                ? undefined
-                : consolidateRecoveryRaw.trim().toLowerCase();
-            if (consolidateRecovery !== undefined && consolidateRecovery !== "abort" && consolidateRecovery !== "clean") {
-                throw new UsageError(`Invalid --consolidate-recovery value: "${consolidateRecoveryRaw}". Must be one of: abort, clean.`, "INVALID_FLAG_VALUE");
-            }
-            const minRetrievalCountRaw = args["min-retrieval-count"];
-            const minRetrievalCount = parseNonNegativeIntFlag(minRetrievalCountRaw, "--min-retrieval-count");
             const requireFeedbackSignal = args["require-feedback-signal"];
             const skipIfLocked = args["skip-if-locked"];
-            const profileArg = getStringArg(args, "profile");
+            const strategyArg = getStringArg(args, "strategy");
+            const effectiveConfig = loadConfig();
+            const scopeArg = resolveScopeAfterRetiredAutoAccept(getStringArg(args, "scope"));
+            rejectRetiredCanaryScope(scopeArg);
+            const scopeRef = scopeArg && isFullRefInput(scopeArg) ? parseRefInput(scopeArg) : undefined;
+            const writeTarget = dryRun
+                ? undefined
+                : scopeRef
+                    ? resolveMutationTarget(effectiveConfig, scopeRef, targetArg).target
+                    : resolveWriteTarget(effectiveConfig, targetArg);
+            // Resolve every enabled model-backed process before logging, signal
+            // lifecycle setup, or any filesystem/database side effect.
+            const resolvedPlan = resolveImprovePlan(strategyArg, effectiveConfig);
+            const selectedStrategyName = resolvedPlan.strategy.name;
+            const sensitiveValues = collectEngineCredentialValues(effectiveConfig);
             // Only set the keys the user actually passed (citty leaves the flag
             // undefined unless `--sync`/`--no-sync` / `--push`/`--no-push` appears),
             // so the resolved profile `sync` block wins by default.
@@ -177,8 +167,10 @@ export const improveCommand = defineCommand({
                 syncOverride.enabled = syncFlag;
             if (pushFlag !== undefined)
                 syncOverride.push = pushFlag;
-            const improveLogFile = path.join(getCacheDir(), "logs", "improve", `${new Date().toISOString().replace(/[:.]/g, "-")}.log`);
-            setLogFile(improveLogFile);
+            if (!dryRun) {
+                const improveLogFile = path.join(getCacheDir(), "logs", "improve", `${new Date().toISOString().replace(/[:.]/g, "-")}.log`);
+                setLogFile(improveLogFile);
+            }
             const startedAtMs = Date.now();
             const startedAtIso = new Date(startedAtMs).toISOString();
             // Mint the run-id up front so signal handlers can persist a partial
@@ -186,14 +178,15 @@ export const improveCommand = defineCommand({
             // was minted at end-of-run, so SIGTERM'd runs (cron timeout) left no
             // row in improve_runs and effectively disappeared from `akm health`.
             const runId = buildImproveRunId();
-            const primaryStashDir = resolveSourceEntries(undefined, loadConfig())[0]?.path;
-            const scopeArg = getStringArg(args, "scope");
-            const inferredScopeMode = (scopeArg ?? "").includes(":") ? "ref" : scopeArg ? "type" : "all";
+            const primaryStashDir = writeTarget?.source.path;
+            const inferredScopeMode = scopeRef ? "ref" : scopeArg ? "type" : "all";
             // Signal handler + exception path both flow through this helper so
             // every abnormal termination produces a row with ok:false and a
             // reason in metadata.terminated.
             let runRecorded = false;
             const persistTerminated = (reason, errorMessage) => {
+                if (dryRun)
+                    return;
                 if (runRecorded)
                     return;
                 if (!primaryStashDir)
@@ -204,8 +197,9 @@ export const improveCommand = defineCommand({
                         scopeMode: inferredScopeMode,
                         scopeValue: scopeArg ?? null,
                         dryRun: Boolean(dryRun),
-                        profile: profileArg ?? null,
-                        ...(errorMessage ? { errorMessage } : {}),
+                        strategy: selectedStrategyName,
+                        ...(errorMessage ? { errorMessage: redactSensitiveText(errorMessage, sensitiveValues) } : {}),
+                        sensitiveValues,
                     });
                 }
                 catch (err) {
@@ -223,33 +217,33 @@ export const improveCommand = defineCommand({
             let improveResult;
             try {
                 improveResult = await runImproveSession({
-                    runWork: () => akmImprove({
+                    runWork: () => akmImproveForRun({
                         scope: scopeArg,
                         task: taskArg,
                         dryRun,
+                        resolvedPlan,
                         target: targetArg,
-                        autoAccept,
+                        ...(writeTarget ? { writeTarget } : {}),
                         ...(runId !== undefined ? { runId } : {}),
                         ...(limitRaw !== undefined ? { limit: limitRaw } : {}),
                         ...(timeoutMs !== undefined ? { timeoutMs } : {}),
-                        ...(minRetrievalCount !== undefined ? { minRetrievalCount } : {}),
                         ...(requireFeedbackSignal ? { requireFeedbackSignal } : {}),
                         ...(skipIfLocked ? { skipIfLocked } : {}),
-                        ...(profileArg !== undefined ? { profile: profileArg } : {}),
+                        ...(strategyArg !== undefined ? { strategy: strategyArg } : {}),
                         ...(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`),
+                    ack: (message) => process.stderr.write(dryRun
+                        ? `[improve] ${message}; dry-run state was not persisted\n`
+                        : `[improve] ${message}; recorded terminated run ${runId}\n`),
                 });
             }
             catch (err) {
@@ -263,12 +257,15 @@ export const improveCommand = defineCommand({
             finally {
                 clearLogFile();
             }
-            const durationMs = Date.now() - startedAtMs;
-            if (jsonToStdout) {
-                // Legacy / escape-hatch mode: full JSON on stdout, no file write.
-                // Kept for scripts/agents that already pipe to jq.
+            if (dryRun) {
+                // A dry-run never persists its result, so stdout is its only result
+                // channel. F4: was `process.exit(0)`, which terminates synchronously
+                // and skips pending cleanup (e.g. the `finally { clearLogFile(); }`
+                // above already ran, but any citty/runWithJsonErrors-level cleanup
+                // on the way out would not). Exit code is 0 either way — `return`
+                // alone is sufficient since success is the default `process.exitCode`.
                 output("improve", improveResult);
-                process.exit(0);
+                return;
             }
             // Default mode (0.8.0+): persist the full result as a row in the
             // `improve_runs` table of state.db (migration 003) and emit NOTHING
@@ -284,24 +281,26 @@ export const improveCommand = defineCommand({
             //      ORDER BY started_at DESC LIMIT 10"
             // runId + primaryStashDir minted up-top so signal handlers can record
             // partial runs; reuse them here for the success path.
-            const resultRef = relativeImproveResultPath(runId);
             runRecorded = true; // Suppress any late signal-handler write — the success path owns the row now.
             if (primaryStashDir) {
                 try {
-                    writeImproveResultFile(primaryStashDir, runId, improveResult, startedAtIso, profileArg ?? null);
+                    recordImproveRunResult(primaryStashDir, runId, improveResult, startedAtIso, sensitiveValues);
                 }
                 catch (err) {
                     // Stderr warning on the failure path is preferable to crashing
                     // the run after all the work has completed.
-                    process.stderr.write(`warning: failed to record improve run ${resultRef}: ${err instanceof Error ? err.message : String(err)}\n`);
+                    process.stderr.write(`warning: failed to record improve run ${runId}: ${err instanceof Error ? err.message : String(err)}\n`);
                 }
             }
             else {
-                process.stderr.write(`warning: no writable stash directory resolved; improve result not persisted to state.db (use --json-to-stdout to capture)\n`);
+                process.stderr.write(`warning: no writable bundle directory resolved; improve result not persisted to state.db (use --json-to-stdout to capture)\n`);
             }
-            // durationMs reserved for future use (no console emission today).
-            void durationMs;
-            process.exit(0);
+            if (jsonToStdout)
+                output("improve", improveResult);
+            // F4: was `process.exit(0)` — the run has already been fully recorded
+            // above (recordImproveRunResult / the warning path), so nothing here
+            // depends on an immediate synchronous exit. This is the last statement
+            // in the handler, so a plain fall-through is equivalent.
         });
     },
 });

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

@@ -9,8 +9,7 @@
  *     `improve_runs` table of `state.db` (migration 003). Stdout is empty.
  *     The existing `[improve] ...` progress log lines on stderr remain the
  *     canonical console UX.
- *   - `--json-to-stdout` restores the prior behaviour: full JSON to stdout,
- *     nothing written to state.db.
+ *   - `--json-to-stdout` additionally emits the persisted result as JSON.
  *
  * v0.8.0 storage change (this module): the previous on-disk artifact at
  * `<stash>/.akm/runs/<runId>/improve-result.json` is no longer written. The
@@ -26,7 +25,8 @@
  * single-slot artefact. We mint a fresh timestamped id for each improve run.
  */
 import crypto from "node:crypto";
-import path from "node:path";
+import { decodeImproveResult } from "../../core/improve-result.js";
+import { redactSensitiveValue } from "../../core/redaction.js";
 import { withStateDb } from "../../core/state-db.js";
 import { recordImproveRun } from "../../storage/repositories/improve-runs-repository.js";
 /**
@@ -43,45 +43,19 @@ export function buildImproveRunId(now = new Date()) {
     const rand = crypto.randomBytes(4).toString("hex");
     return `${iso}-${rand}`;
 }
-/**
- * Return a stable, human-recognisable reference for a given improve run.
- *
- * Historical compatibility shim: callers used to receive a stash-relative
- * file path like `.akm/runs/<runId>/improve-result.json`. With the state.db
- * migration, no such file exists, but several callers still log "wrote to
- * <path>" style messages. Returning a `state.db//improve_runs/<runId>`
- * locator preserves the "the result is at <thing>" signature so existing
- * log lines and error messages continue to make sense without rewriting
- * every call site.
- */
-export function relativeImproveResultPath(runId) {
-    return path.join("state.db", "improve_runs", runId);
-}
 /**
  * Persist the full improve result into the `improve_runs` table of state.db.
  *
- * Backwards-compatible signature: the function name, argument list, and
- * return type all match the pre-0.8.0 file-writing helper. The returned
- * string is the `state.db//improve_runs/<runId>` locator (see
- * {@link relativeImproveResultPath}), which is intended for log messages
- * only — no caller should treat it as a filesystem path. Zero current
- * readers existed for the previous file path, so this is a pure storage
- * swap.
- *
  * The state.db row carries the scope and dry-run flag from `result.scope`
  * and `result.dryRun`, plus the full result JSON for full fidelity. The
  * dry-run column is indexed so productivity audits can filter cleanly
  * (closes the dry-run/real-run artifact-trap recorded in MEMORY.md
  * `feedback_akm_dryrun_artifact_trap`).
  *
- * @param profile - The `--profile` value passed to this invocation (e.g.
- * `quick`, `reflect-distill`), or `null`/`undefined` when no profile was
- * given. Mirrors {@link recordTerminatedImproveRun}'s `ctx.profile`
- * convention so successful and terminated runs are equally queryable by
- * profile. Previously hardcoded to `null` here, which meant only
- * abnormally-terminated runs recorded their profile in state.db.
  */
-export function writeImproveResultFile(stashDir, runId, result, startedAt, profile) {
+export function recordImproveRunResult(stashDir, runId, result, startedAt, sensitiveValues = []) {
+    const decoded = decodeImproveResult(result);
+    const persistedResult = redactSensitiveValue(result, sensitiveValues);
     withStateDb((db) => {
         const completedAt = new Date().toISOString();
         // startedAt is the ISO timestamp captured at process launch (passed from the
@@ -95,15 +69,14 @@ export function writeImproveResultFile(stashDir, runId, result, startedAt, profi
             completedAt,
             stashDir,
             dryRun: Boolean(result.dryRun),
-            profile: profile ?? null,
+            strategy: redactSensitiveValue(decoded.strategy, sensitiveValues),
             scopeMode: result.scope?.mode ?? "all",
-            scopeValue: result.scope?.value ?? null,
-            guidance: result.guidance ?? null,
+            scopeValue: persistedResult.scope?.value ?? null,
+            guidance: persistedResult.guidance ?? null,
             ok: Boolean(result.ok),
-            result,
+            result: persistedResult,
         });
     });
-    return relativeImproveResultPath(runId);
 }
 /**
  * Persist an improve_runs row for a run that did NOT complete normally.
@@ -124,37 +97,44 @@ export function writeImproveResultFile(stashDir, runId, result, startedAt, profi
  */
 export function recordTerminatedImproveRun(stashDir, runId, startedAt, reason, ctx) {
     const completedAt = new Date().toISOString();
-    const minimalResult = {
-        schemaVersion: 1,
+    const persistedReason = redactSensitiveValue(reason, ctx.sensitiveValues ?? []);
+    const persistedScopeValue = redactSensitiveValue(ctx.scopeValue, ctx.sensitiveValues ?? []);
+    const persistedStrategy = redactSensitiveValue(ctx.strategy, ctx.sensitiveValues ?? []);
+    const minimalResult = redactSensitiveValue({
+        schemaVersion: 2,
         ok: false,
-        scope: { mode: ctx?.scopeMode ?? "all", ...(ctx?.scopeValue ? { value: ctx.scopeValue } : {}) },
-        dryRun: Boolean(ctx?.dryRun),
+        strategy: persistedStrategy,
+        scope: { mode: ctx.scopeMode ?? "all", ...(persistedScopeValue ? { value: persistedScopeValue } : {}) },
+        dryRun: Boolean(ctx.dryRun),
+        memorySummary: { eligible: 0, derived: 0 },
         actions: [],
         plannedRefs: [],
         terminated: {
-            reason,
+            reason: persistedReason,
             at: completedAt,
-            ...(ctx?.errorMessage ? { errorMessage: ctx.errorMessage } : {}),
+            ...(ctx.errorMessage ? { errorMessage: ctx.errorMessage } : {}),
         },
-    };
+    }, ctx.sensitiveValues ?? []);
     withStateDb((db) => {
         recordImproveRun(db, {
             id: runId,
             startedAt,
             completedAt,
             stashDir,
-            dryRun: Boolean(ctx?.dryRun),
-            profile: ctx?.profile ?? null,
-            scopeMode: ctx?.scopeMode ?? "all",
-            scopeValue: ctx?.scopeValue ?? null,
+            dryRun: Boolean(ctx.dryRun),
+            strategy: persistedStrategy,
+            scopeMode: ctx.scopeMode ?? "all",
+            scopeValue: persistedScopeValue ?? null,
             guidance: null,
             ok: false,
             result: minimalResult,
             metadata: {
                 terminated: {
-                    reason,
+                    reason: persistedReason,
                     at: completedAt,
-                    ...(ctx?.errorMessage ? { errorMessage: ctx.errorMessage } : {}),
+                    ...(ctx.errorMessage
+                        ? { errorMessage: redactSensitiveValue(ctx.errorMessage, ctx.sensitiveValues ?? []) }
+                        : {}),
                 },
             },
         });

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

@@ -0,0 +1,4 @@
+// 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/.
+export {};