akm-cli 0.10.261004-beta → 0.10.261006-beta

package/dist/cli.js

@@ -85,6 +85,7 @@ import { renderMigrationHelp } from "./commands/sources/migration-help.js";
 import { cloneCommand, syncCommand, upgradeCommand } from "./commands/sources/sources-cli.js";
 import { importKnowledgeCommand, indexCommand, infoCommand } from "./commands/sources/stash-cli.js";
 import { taskCommand } from "./commands/tasks/tasks-cli.js";
+import { uiCommand } from "./commands/ui/ui-cli.js";
 import { workflowCommand } from "./commands/workflow-cli.js";
 import { DEFAULT_CONFIG, loadConfig } from "./core/config/config.js";
 import { UsageError } from "./core/errors.js";
@@ -448,6 +449,7 @@ const commands = {
     index: indexCommand,
     health: healthCommand,
     metrics: metricsCommand,
+    ui: uiCommand,
     info: infoCommand,
     bundle: bundleCommand,
     upgrade: upgradeCommand,
@@ -778,6 +780,7 @@ const HELP_SECTIONS = [
             "lint",
             "health",
             "metrics",
+            "ui",
             "config",
             "models",
             "registry",

package/dist/commands/health/checks.js

@@ -902,9 +902,11 @@ export const HEALTH_CHECKS = [
             kind: "deterministic",
             status: ctx.probe.ok ? "pass" : "fail",
             confidence: "high",
-            message: ctx.probe.ok
-                ? "state.db append/read round-trip succeeded."
-                : `state.db round-trip failed: ${ctx.probe.error}`,
+            message: ctx.probe.skipped
+                ? "state.db append/read round-trip skipped: this run is read-only."
+                : ctx.probe.ok
+                    ? "state.db append/read round-trip succeeded."
+                    : `state.db round-trip failed: ${ctx.probe.error}`,
             evidence: { path: ctx.stateDbPath, durationMs: ctx.probe.durationMs },
         }),
     },

package/dist/commands/health/egress.js

@@ -8,6 +8,7 @@
  * configured, matching the `stash-git-exposure` / `binary-config-skew`
  * advisories' pattern.
  */
+import { redactCredentialPatterns } from "../../core/redaction.js";
 import { formatRegistryUrl } from "../../core/registry-url.js";
 /**
  * `egress-endpoints` (08 surfaces 3/9): the full list of remote destinations
@@ -42,6 +43,9 @@ export function collectEgressAdvisory(config) {
         endpoints.push(`embedding: ${config.embedding.endpoint}`);
     if (endpoints.length === 0)
         return undefined;
+    // A configured URL can carry a credential (`?token=…`, `user:pass@`); the list is for eyeballing destinations, so
+    // print the host and path and never the secret.
+    const safe = endpoints.map(redactCredentialPatterns);
     return {
         name: "egress-endpoints",
         kind: "deterministic",
@@ -49,6 +53,6 @@ export function collectEgressAdvisory(config) {
         confidence: "high",
         message: `${endpoints.length} remote endpoint(s) in the effective config (registries/sources/LLM/embedding) — ` +
             "review the evidence list for unexpected destinations.",
-        evidence: { endpoints },
+        evidence: { endpoints: safe },
     };
 }

package/dist/commands/health/engine-usage.js

@@ -28,9 +28,9 @@ export function engineLastUsedSince(now) {
  * `engine` field (pre-#576 rows, or a call outside any resolved engine) is
  * skipped rather than bucketed under a synthetic key.
  */
-export function readLastEngineUsage(stateDbPath, now) {
+export function readLastEngineUsage(stateDbPath, now, readOnly = false) {
     const since = engineLastUsedSince(now);
-    const events = readEvents({ since, type: LLM_USAGE_EVENT }, { dbPath: stateDbPath }).events;
+    const events = readEvents({ since, type: LLM_USAGE_EVENT }, { dbPath: stateDbPath, readOnly }).events;
     const lastUsed = new Map();
     for (const event of events) {
         const record = decodeLlmUsageRecord(event.metadata);

package/dist/commands/health/llm-usage.js

@@ -59,8 +59,8 @@ export function summarizeLlmUsage(events) {
     }
     return aggregate;
 }
-export function readLlmUsageAggregate(stateDbPath, since, until) {
-    const events = readEvents({ since, type: LLM_USAGE_EVENT }, { dbPath: stateDbPath }).events.filter((event) => {
+export function readLlmUsageAggregate(stateDbPath, since, until, readOnly = false) {
+    const events = readEvents({ since, type: LLM_USAGE_EVENT }, { dbPath: stateDbPath, readOnly }).events.filter((event) => {
         if (until === undefined)
             return true;
         return new Date(event.ts ?? since).getTime() < new Date(until).getTime();

package/dist/commands/health/windows.js

@@ -151,9 +151,9 @@ export function computeTaskWindowRates(taskRows, now) {
  * stats from the same per-run rows, and accepted-proposal coverage, all over
  * one `[since, until)`.
  */
-export function buildImproveWindowSummary(db, stateDbPath, since, until) {
+export function buildImproveWindowSummary(db, stateDbPath, since, until, readOnly = false) {
     const untilMs = new Date(until).getTime();
-    const eventsBeforeUntil = (type) => readEvents({ since, type }, { dbPath: stateDbPath }).events.filter((event) => new Date(event.ts ?? since).getTime() < untilMs);
+    const eventsBeforeUntil = (type) => readEvents({ since, type }, { dbPath: stateDbPath, readOnly }).events.filter((event) => new Date(event.ts ?? since).getTime() < untilMs);
     const { metrics: improve, runCount } = summarizeImproveRuns(db, since, until);
     improve.invoked = eventsBeforeUntil("improve_invoked").length;
     improve.completed = eventsBeforeUntil(IMPROVE_COMPLETED_EVENT).length;
@@ -167,20 +167,20 @@ export function buildImproveWindowSummary(db, stateDbPath, since, until) {
     improve.coverage = computeWindowProposalCoverage(db, since, until);
     return { improve, runCount, perRunSummaries };
 }
-export function buildWindowMetrics(db, stateDbPath, since, until, now = () => Date.now()) {
+export function buildWindowMetrics(db, stateDbPath, since, until, now = () => Date.now(), readOnly = false) {
     const untilMs = new Date(until).getTime();
     const taskRows = queryTaskHistory(db, { since }).filter((row) => {
         const startMs = new Date(row.started_at).getTime();
         return !Number.isFinite(untilMs) || startMs < untilMs;
     });
     const rates = computeTaskWindowRates(taskRows, now);
-    const { improve, runCount } = buildImproveWindowSummary(db, stateDbPath, since, until);
+    const { improve, runCount } = buildImproveWindowSummary(db, stateDbPath, since, until, readOnly);
     const metrics = {
         taskFailRate: roundRate(rates.taskFailRate),
         agentFailureRate: roundRate(rates.agentFailureRate),
         agentFailureReasonCounts: rates.agentFailureReasonCounts,
         stuckActiveRuns: rates.stuckActiveRuns,
-        llmUsage: readLlmUsageAggregate(stateDbPath, since, until),
+        llmUsage: readLlmUsageAggregate(stateDbPath, since, until, readOnly),
     };
     return { improve, metrics, runs: runCount };
 }

package/dist/commands/health.js

@@ -11,12 +11,14 @@ import { getConfigPath, getDataDir, getDbPath, getStateDbPathInDataDir } from ".
 import { listExistingTableNames, listPendingStateMigrations, openStateDatabaseWithReport, withStateDb, } from "../core/state-db.js";
 import { DURATION_UNITS, parseDuration, parseSinceToIso } from "../core/time.js";
 import { probeLlmEndpoint } from "../llm/client.js";
+import { openDatabase } from "../storage/database.js";
 import { insertEvent } from "../storage/repositories/events-repository.js";
 import { getExtractOutcomeCountsSince } from "../storage/repositories/extract-sessions-repository.js";
 import { countImproveRunsSince } from "../storage/repositories/improve-runs-repository.js";
 import { closeDatabase, openReadonlyExistingDatabase } from "../storage/repositories/index-connection.js";
 import { getAllEntries } from "../storage/repositories/index-entries-repository.js";
 import { queryTaskHistory } from "../storage/repositories/task-history-repository.js";
+import { applyReadonlyPragmas } from "../storage/sqlite-pragmas.js";
 import { getStateDbFreelistInfo, runStateDbIntegrityCheck } from "../storage/state-db-integrity.js";
 import { pkgVersion } from "../version.js";
 import { collectArchiveUsageAdvisory } from "./health/archive-usage.js";
@@ -176,12 +178,12 @@ function computeWorstTaskFailRate(rows) {
     return worst;
 }
 /** Table presence, the state.db round-trip probe, and task_history-derived rates. */
-function gatherTaskHistoryPhase(db, since, stateDbPath, now) {
+function gatherTaskHistoryPhase(db, since, stateDbPath, now, readOnly) {
     const tables = listExistingTableNames(db, ["events", "task_history", "proposals", "schema_migrations"]);
     const tableNames = tables.map((row) => row.name).sort();
     const requiredTables = ["events", "proposals", "schema_migrations", "task_history"];
     const missingTables = requiredTables.filter((name) => !tableNames.includes(name));
-    const probe = probeStateDbRoundTrip(stateDbPath);
+    const probe = readOnly ? { ok: true, durationMs: null, skipped: true } : probeStateDbRoundTrip(stateDbPath);
     // R0: read-only, independent of the round-trip probe above — integrity_check
     // catches corruption a successful append/read cannot (out-of-order rowids,
     // bad index entry counts), and the freelist reading is purely informational.
@@ -440,7 +442,7 @@ function resolveWindowComparePhase(options, db, stateDbPath, now) {
         windowResults = windowSpecs.map((spec) => {
             const winSince = parseHealthSince(spec.since);
             const winUntil = spec.until ? parseHealthSince(spec.until) : new Date(now()).toISOString();
-            const bundle = buildWindowMetrics(db, stateDbPath, winSince, winUntil, now);
+            const bundle = buildWindowMetrics(db, stateDbPath, winSince, winUntil, now, options.readOnly === true);
             return {
                 name: spec.name,
                 since: winSince,
@@ -508,6 +510,25 @@ function unreadableStateDbCheck(detail) {
         evidence: { detail },
     };
 }
+/**
+ * Why a read-only health run cannot use `stateDbPath`, as the failing check to
+ * report: the file is missing, or it is behind on migrations (a read-only open
+ * must not apply them). `undefined` when it can be read as it is.
+ */
+function readOnlyStateDbUnavailable(stateDbPath) {
+    if (!fs.existsSync(stateDbPath)) {
+        return {
+            name: "state-db-readable",
+            kind: "deterministic",
+            status: "fail",
+            confidence: "high",
+            message: `state.db does not exist at ${stateDbPath}; a read-only health run does not create it. Run any akm command that records state, such as \`akm health\`.`,
+            evidence: { path: stateDbPath },
+        };
+    }
+    const pending = runPendingStateMigrationsCheck(stateDbPath, { listPendingStateMigrations });
+    return pending.status === "fail" ? pending : undefined;
+}
 export async function akmHealth(options = {}) {
     validateAkmHealthOptions(options);
     const now = options.now ?? (() => Date.now());
@@ -521,9 +542,20 @@ export async function akmHealth(options = {}) {
     // to find out why everything else is behaving oddly. Report it as a finding
     // instead of dying before any check runs. The open itself applies every
     // pending migration; `state-db-migrations` reports what it applied.
+    const readOnly = options.readOnly === true;
     let opened;
     try {
-        opened = openStateDatabaseWithReport(stateDbPath);
+        if (readOnly) {
+            const unavailable = readOnlyStateDbUnavailable(stateDbPath);
+            if (unavailable)
+                return degradedStateDbReport(unavailable, options);
+            const db = openDatabase(stateDbPath, { readonly: true, create: false });
+            applyReadonlyPragmas(db);
+            opened = { db, applied: [] };
+        }
+        else {
+            opened = openStateDatabaseWithReport(stateDbPath);
+        }
     }
     catch (error) {
         const { access, code } = classifyPathAccess(stateDbPath);
@@ -561,14 +593,14 @@ export async function akmHealth(options = {}) {
             cliVersion: pkgVersion,
         });
         schedulerBinaryDriftPromise.catch(() => undefined);
-        const taskHistory = gatherTaskHistoryPhase(db, since, stateDbPath, now);
+        const taskHistory = gatherTaskHistoryPhase(db, since, stateDbPath, now, readOnly);
         const { tableNames, missingTables, probe } = taskHistory;
         const { egressConfigView, thinkingOffEngines } = gatherEgressConfigPhase();
         // Same window bundle `--window-compare` builds per-window (windows.ts) —
         // reused here for the main `--since` window's improve summary and for
         // `--group-by run`, so neither re-reads `improve_runs`.
         const until = new Date(now()).toISOString();
-        const { improve: improveSummary, perRunSummaries } = buildImproveWindowSummary(db, stateDbPath, since, until);
+        const { improve: improveSummary, perRunSummaries } = buildImproveWindowSummary(db, stateDbPath, since, until, readOnly);
         advisories.push(...gatherAncillaryAdvisories(db, options, egressConfigView));
         const sessionExtractionLedger = gatherSessionExtractionLedgerPhase(db, now);
         // #950: computed once (no IO beyond config/env, same as gatherEgressConfigPhase)
@@ -578,14 +610,14 @@ export async function akmHealth(options = {}) {
         // #950: `engine-last-used` reads a fixed lookback window independent of
         // `--since` (mirrors sessionExtractionLedger's independent window above).
         const engineLastUsedSinceIso = engineLastUsedSince(now);
-        const engineLastUsed = readLastEngineUsage(stateDbPath, now);
+        const engineLastUsed = readLastEngineUsage(stateDbPath, now, readOnly);
         const improveRunsInLookbackWindow = countImproveRunsSince(db, engineLastUsedSinceIso);
         const engineProbes = await engineProbesPromise;
         const versionDrift = await versionDriftPromise;
         const schedulerBinaryDrift = await schedulerBinaryDriftPromise;
         // Read once, shared by the `thinking-control` check (#949) and the
         // `metrics.llmUsage` report field below — same window, same aggregate.
-        const llmUsage = readLlmUsageAggregate(stateDbPath, since);
+        const llmUsage = readLlmUsageAggregate(stateDbPath, since, undefined, readOnly);
         // Run the ordered health-check registry. Each check projects the shared
         // context computed above into one HealthCheckResult; `channel` routes it to
         // hardChecks or advisories. Declaration order in HEALTH_CHECKS is the

package/dist/commands/improve/improve.js

@@ -34,6 +34,7 @@ import { getEntryCount } from "../../storage/repositories/index-entries-reposito
 import { openSqliteReadSnapshot, SqliteReadSnapshotUnavailableError } from "../../storage/sqlite-read-snapshot.js";
 import { summarizeLlmUsageRecordsCrossTab } from "../health/llm-usage.js";
 import { drainProposals } from "../proposal/drain.js";
+import { commitCollectedAccepts } from "../proposal/repository.js";
 import { describeGatedLanes, isAutonomyLaneAllowed } from "./autonomy-gate.js";
 import { akmDistill } from "./distill.js";
 import { collectEligibleRefs, collectEligibleRefsReadOnly, memoryCleanupParentRef, resolveImproveScope, shouldAnalyzeMemoryCleanup, } from "./eligibility.js";
@@ -695,9 +696,13 @@ async function runTriagePrePass(run) {
         warn("[improve] triage pre-pass skipped (single-ref scope never drains the whole queue)");
         return undefined;
     }
+    // Triage accepts are journaled, so the end-of-run batch commit covers them; the drain does not commit
+    // them one by one (#1185). Without that batch (--no-sync, no git repository) they are committed here.
+    const commitCollector = [];
     try {
         const triageConfig = improveProfile.processes?.triage;
         return await withLlmStage("triage", () => run.drainProposalsFn({
+            commitCollector,
             stashDir: primaryStashDir,
             ...(options.target ? { target: options.target } : {}),
             config: options.config,
@@ -712,6 +717,10 @@ async function runTriagePrePass(run) {
         warn(`[improve] triage pre-pass failed (non-fatal): ${errMessage(err)}`);
         return undefined;
     }
+    finally {
+        if (!syncsStash(run))
+            commitCollectedAccepts(commitCollector, "akm improve triage");
+    }
 }
 /**
  * The exact repo-relative paths the auto-sync commit stages (#652): the paths
@@ -740,6 +749,11 @@ export function resolveSyncPathSet(input) {
         unattributed: changedPaths.filter((p) => !attributed.has(p) && !initialPaths.has(p) && inScope(p)).sort(),
     };
 }
+/** True when the run's end-of-run sync will commit what it wrote: sync is on and the write target is a git repository. */
+function syncsStash(run) {
+    const repoDir = run.writeTarget?.source.repoPath ?? run.primaryStashDir;
+    return Boolean(run.primaryStashDir && repoDir && run.effectiveSync.enabled !== false && isGitBackedStash(repoDir));
+}
 /**
  * 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`
@@ -749,11 +763,10 @@ export function resolveSyncPathSet(input) {
  * `akm sync` stages (the managed paths).
  */
 function runStashSync(run, eventsCtx, phase, input) {
-    const { writeTarget, primaryStashDir, effectiveSync, options, config, improveProfile } = run;
+    const { writeTarget, primaryStashDir, options, config, improveProfile } = run;
     const repoDir = writeTarget?.source.repoPath ?? primaryStashDir;
-    if (!primaryStashDir || !repoDir || effectiveSync.enabled === false || !isGitBackedStash(repoDir)) {
+    if (!primaryStashDir || !repoDir || !syncsStash(run))
         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;
@@ -786,7 +799,7 @@ function runStashSync(run, eventsCtx, phase, input) {
         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;
+        const committed = syncErr instanceof GitStashPushError && syncErr.committedNow;
         record({ committed, pushed: false, skipped: true, reason });
         return { committed, pushed: false, skipped: true, reason };
     }

package/dist/commands/improve/reflect-noise.js

@@ -158,6 +158,10 @@ export function splitFrontmatter(raw) {
     const m = raw.match(/^---\r?\n([\s\S]*?)\r?\n---\r?\n?([\s\S]*)$/);
     return m ? { fmText: m[1] ?? "", body: m[2] ?? "" } : { fmText: null, body: raw };
 }
+/** A level-1 heading line (`# text`) anywhere in a body: what reflect's title adds only when none is there. */
+export function bodyHasH1(body) {
+    return /^#[ \t]+\S/m.test(body);
+}
 /** Frontmatter text, fenced code blocks, and prose lines (an unclosed fence counts as prose). */
 function parseSections(text) {
     const { fmText, body } = splitFrontmatter(normalizeTrailingWhitespace(text));

package/dist/commands/improve/reflect.js

@@ -44,7 +44,7 @@ import { contentHash } from "./content-hash.js";
 import { findAssetFilePath } from "./eligibility.js";
 import { resolveImproveExecution } from "./execution.js";
 import { recordLedgerAttempt } from "./ledger.js";
-import { classifyReflectChange, findReflectDefect, splitFrontmatter } from "./reflect-noise.js";
+import { bodyHasH1, classifyReflectChange, findReflectDefect, splitFrontmatter, } from "./reflect-noise.js";
 import { callStageOnce, errMessage, mintProposal, noticeSet, rejectedProposalContext, resolveQualityGateJudge, runReflectQualityJudge, } from "./stage.js";
 const MAX_FEEDBACK_LINES = 10;
 const MAX_GLOBAL_FEEDBACK_LINES = 20;
@@ -151,10 +151,17 @@ function firstProseSentence(body) {
     }
     return "";
 }
+/** The body with `# title` and one blank line inserted at its first non-blank line; the rest is untouched. */
+function withH1(body, title) {
+    const eol = body.match(/\r?\n/)?.[0] ?? "\n";
+    const leading = body.match(/^(?:\r?\n)*/)?.[0] ?? "";
+    return `${leading}# ${title}${eol}${eol}${body.slice(leading.length)}`;
+}
 /**
  * The asset with the patch applied, or `undefined` when the patch changes
  * nothing (or there is no asset to patch). The body is the source's own, byte
- * for byte; the one thing akm adds to it is a `# title` heading it lacks. A
+ * for byte; the one thing akm adds to it is a `# title` heading it lacks, with
+ * one blank line after it (#1183). A
  * required description that neither the source nor the patch has is derived
  * from the asset's own text (#636). Only the changed keys' frontmatter lines are
  * rewritten: every other line is kept as it is, so a source whose YAML the
@@ -170,8 +177,10 @@ export function applyReflectPatch(patch, sourceContent, targetRef) {
         return undefined;
     const sourceFm = fmText !== null ? parseFrontmatter(sourceContent).data : {};
     const { title, ...changes } = patch;
-    const addTitle = title !== undefined && !/^#[ \t]+\S/m.test(sourceBody);
-    const body = addTitle ? `# ${title}\n\n${sourceBody.replace(/^(\r?\n)+/, "")}` : sourceBody;
+    const addTitle = title !== undefined && !bodyHasH1(sourceBody);
+    // The heading and one blank line go in at the body's first non-blank line, in
+    // the body's own line ending; every other byte of the body stays where it was.
+    const body = addTitle ? withH1(sourceBody, title) : sourceBody;
     // Only a source that already has frontmatter but no description gets one:
     // injecting a whole block, or overwriting an authored one, is out of scope.
     const refType = lenientRefType(targetRef);
@@ -198,7 +207,7 @@ export function applyReflectPatch(patch, sourceContent, targetRef) {
         const content = `---\n${serializeFrontmatter(changes)}\n---\n\n${body}`;
         return { content, frontmatter: parseFrontmatter(content).data };
     }
-    const content = `---\n${patchFrontmatterLines(fmText, changes)}\n---\n${addTitle ? "\n" : ""}${body}`;
+    const content = `---\n${patchFrontmatterLines(fmText, changes)}\n---\n${body}`;
     return { content, frontmatter: parseFrontmatter(content).data };
 }
 /** The frontmatter text with each changed key's lines (the key line and its indented continuation) replaced, or appended. */

package/dist/commands/proposal/drain.js

@@ -41,7 +41,7 @@ import { NEIGHBOUR_EXCERPT_CHARS, NEIGHBOUR_NOTE_COUNT, nearestKnowledgeNotes, s
 import { errMessage, noticeSet } from "../improve/stage.js";
 import { akmProposalAccept, akmProposalReject } from "./proposal.js";
 import { isRetireProposal, PAIR_PASS_GATE, STALE_TARGET_GATE_REASON } from "./proposal-types.js";
-import { listProposals, listProposalsReadOnly, preflightProposalPromotion, proposalContent, proposalContentHash, readFreshProposalTarget, recordGateDecision, } from "./repository.js";
+import { commitCollectedAccepts, listProposals, listProposalsReadOnly, preflightProposalPromotion, proposalContent, proposalContentHash, readFreshProposalTarget, recordGateDecision, } from "./repository.js";
 /** The gate label on every decision the drain records. */
 const DRAIN_GATE = "triage";
 /** A consolidate promotion: a memory proposed as a new knowledge note. The only kind the judgment tier may accept. */
@@ -89,6 +89,7 @@ async function acceptProposal(opts, proposal, id, reason, promoteFn, rejectFn, j
                 id,
                 ...(opts.target ? { target: opts.target } : {}),
                 ...(opts.config ? { config: opts.config } : {}),
+                ...(opts.commitCollector ? { commitCollector: opts.commitCollector } : {}),
                 gateDecision,
             });
         }
@@ -416,6 +417,17 @@ function readLiveAssetContent(stashDir, ref) {
  * test seams.
  */
 export async function drainProposals(opts, promoteFn = akmProposalAccept, rejectFn = akmProposalReject, judgmentSeams = {}) {
+    if (opts.commitCollector)
+        return drainPending(opts, promoteFn, rejectFn, judgmentSeams);
+    const commitCollector = [];
+    try {
+        return await drainPending({ ...opts, commitCollector }, promoteFn, rejectFn, judgmentSeams);
+    }
+    finally {
+        commitCollectedAccepts(commitCollector, "akm proposal drain");
+    }
+}
+async function drainPending(opts, promoteFn, rejectFn, judgmentSeams) {
     const exclude = opts.excludeIds ?? new Set();
     // A judgment runner's credentials are validated before any live state
     // connection, so its classification reads an isolated snapshot.

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

@@ -14,7 +14,7 @@
  * registration remains for either spelling.
  */
 import { parsePositiveIntFlag } from "../../cli/parse-args.js";
-import { defineGroupCommand, defineJsonCommand, output } from "../../cli/shared.js";
+import { defineGroupCommand, defineJsonCommand, EXIT_CODES, output } from "../../cli/shared.js";
 import { resolveStashDir } from "../../core/common.js";
 import { loadConfig } from "../../core/config/config.js";
 import { UsageError } from "../../core/errors.js";
@@ -24,7 +24,7 @@ import { resolveImproveExecution } from "../improve/execution.js";
 import { extractCommand } from "../improve/extract-cli.js";
 import { resolveImproveStrategy } from "../improve/improve-strategies.js";
 import { drainProposals } from "./drain.js";
-import { akmProposalAccept, akmProposalDiff, akmProposalList, akmProposalReject, akmProposalReopen, akmProposalRevert, akmProposalShow, bulkAdjudicateProposals, } from "./proposal.js";
+import { akmProposalAccept, akmProposalAcceptMany, akmProposalDiff, akmProposalList, akmProposalReject, akmProposalReopen, akmProposalRevert, akmProposalShow, bulkAdjudicateProposals, } from "./proposal.js";
 import { proposalWaitingSince } from "./proposal-types.js";
 import { proposeCommand } from "./propose-cli.js";
 export function mergeProposalDrainNotices(resolutionNotices, dispatchNotices) {
@@ -94,11 +94,14 @@ const proposalListCommand = defineJsonCommand({
     },
 });
 const proposalAcceptCommand = defineJsonCommand({
-    meta: { name: "accept", description: "Accept a proposal and promote it into the bundle" },
+    meta: {
+        name: "accept",
+        description: "Accept proposals and promote them into the bundle. Several ids are accepted in one process and committed once.",
+    },
     args: {
         id: {
             type: "positional",
-            description: "Proposal id (uuid / prefix) or asset ref (e.g. skills/akm-dream). Optional when --generator is provided.",
+            description: "Proposal id (uuid / prefix) or asset ref (e.g. skills/akm-dream); repeat it to accept several at once. Optional when --generator is provided.",
             required: false,
         },
         queue: { type: "string", description: "Select the proposal queue by source name" },
@@ -161,10 +164,24 @@ const proposalAcceptCommand = defineJsonCommand({
             return;
         }
         if (!args.id) {
-            throw new UsageError("Usage: akm proposal accept <id>  OR  akm proposal accept --generator <generator>", "MISSING_REQUIRED_ARGUMENT");
+            throw new UsageError("Usage: akm proposal accept <id> [<id> ...]  OR  akm proposal accept --generator <generator>", "MISSING_REQUIRED_ARGUMENT");
+        }
+        // citty keeps every positional token in `_`, though it declares only `id`.
+        const ids = (Array.isArray(args._) && args._.length > 0 ? args._ : [args.id]).map(String);
+        if (ids.length > 1) {
+            const results = await akmProposalAcceptMany({
+                ids,
+                queue: args.queue,
+                target: args.bundle,
+            });
+            const failed = results.filter((result) => !result.ok).length;
+            output("proposal-accept-batch", { accepted: results.length - failed, failed, results });
+            if (failed > 0)
+                process.exitCode = EXIT_CODES.GENERAL;
+            return;
         }
         const result = await akmProposalAccept({
-            id: args.id,
+            id: ids[0],
             queue: args.queue,
             target: args.bundle,
         });

package/dist/commands/proposal/proposal.js

@@ -17,7 +17,7 @@ import { NotFoundError } from "../../core/errors.js";
 import { resolveWriteTarget } from "../../core/write-source.js";
 import { withAssetMutationLease } from "../../indexer/index-writer-lock.js";
 import { isRetireProposal, proposalWaitingSince } from "./proposal-types.js";
-import { diffProposal, listProposals, preflightProposalPromotion, promoteProposal, proposalContent, rejectProposalDurably, reopenProposals, resolveProposalId, revertProposal, } from "./repository.js";
+import { commitCollectedAccepts, diffProposal, listProposals, preflightProposalPromotion, promoteProposal, proposalContent, rejectProposalDurably, reopenProposals, resolveProposalId, revertProposal, } from "./repository.js";
 import { validateProposal } from "./validators/proposals.js";
 // ── Shared helpers ──────────────────────────────────────────────────────────
 function resolveStash(stashDir) {
@@ -95,7 +95,12 @@ export async function akmProposalAccept(options) {
     const queue = resolveProposalQueue(options.stashDir, options.queue, config);
     const stash = queue.stashDir;
     const resolvedId = resolveProposalId(stash, options.id).id;
-    const result = await promoteProposal(stash, config, resolvedId, { target: options.target, queueTarget: queue.target, gateDecision: options.gateDecision }, options.ctx);
+    const result = await promoteProposal(stash, config, resolvedId, {
+        target: options.target,
+        queueTarget: queue.target,
+        gateDecision: options.gateDecision,
+        ...(options.commitCollector ? { commitCollector: options.commitCollector } : {}),
+    }, options.ctx);
     return {
         schemaVersion: 1,
         ok: true,
@@ -105,6 +110,35 @@ export async function akmProposalAccept(options) {
         proposal: result.proposal,
     };
 }
+/**
+ * Accept several proposals in one process and commit them once. An id that
+ * fails is reported and the rest carry on; what was accepted is committed
+ * either way.
+ */
+export async function akmProposalAcceptMany(options) {
+    const { ids, ...rest } = options;
+    const commitCollector = [];
+    const results = [];
+    try {
+        for (const id of ids) {
+            try {
+                results.push(await akmProposalAccept({ ...rest, id, commitCollector }));
+            }
+            catch (error) {
+                results.push({
+                    schemaVersion: 1,
+                    ok: false,
+                    id,
+                    error: error instanceof Error ? error.message : String(error),
+                });
+            }
+        }
+    }
+    finally {
+        commitCollectedAccepts(commitCollector, "akm proposal accept");
+    }
+    return results;
+}
 export async function akmProposalReject(options) {
     return withAssetMutationLease("proposal-reject", async () => {
         const config = options.config ?? loadConfig();
@@ -273,16 +307,29 @@ export async function bulkAdjudicateProposals(options) {
     const skippedForContinuityRisk = matched.filter(isContinuityExcluded).length;
     const pending = matched.filter((p) => !isContinuityExcluded(p));
     const results = [];
-    for (const proposal of pending) {
-        if (options.dryRun) {
-            results.push({ id: proposal.id, ref: proposal.ref, source: proposal.source, dryRun: true });
-        }
-        else if (options.action === "accept") {
-            results.push(await akmProposalAccept({ stashDir, id: proposal.id, queue: options.queue, target: options.target, config }));
-        }
-        else {
-            results.push(await akmProposalReject({ stashDir, id: proposal.id, queue: options.queue, reason: options.reason, config }));
+    const commitCollector = [];
+    try {
+        for (const proposal of pending) {
+            if (options.dryRun) {
+                results.push({ id: proposal.id, ref: proposal.ref, source: proposal.source, dryRun: true });
+            }
+            else if (options.action === "accept") {
+                results.push(await akmProposalAccept({
+                    stashDir,
+                    id: proposal.id,
+                    queue: options.queue,
+                    target: options.target,
+                    config,
+                    commitCollector,
+                }));
+            }
+            else {
+                results.push(await akmProposalReject({ stashDir, id: proposal.id, queue: options.queue, reason: options.reason, config }));
+            }
         }
     }
+    finally {
+        commitCollectedAccepts(commitCollector, "akm proposal accept");
+    }
     return { count: results.length, results, skippedForContinuityRisk };
 }