akm-cli 0.8.0-rc.11 → 0.8.0-rc.12

package/dist/cli.js

@@ -90,7 +90,10 @@ function resolveEventSource() {
         return "user";
     return undefined;
 }
+import { resolveImproveProfile } from "./commands/improve-profiles";
 import { akmProposalAccept, akmProposalDiff, akmProposalList, akmProposalReject, akmProposalRevert, akmProposalShow, } from "./commands/proposal";
+import { drainProposals } from "./commands/proposal-drain";
+import { resolveDrainPolicy } from "./commands/proposal-drain-policies";
 import { akmPropose } from "./commands/propose";
 import { akmSearch, parseBeliefFilterMode, parseScopeFilterFlags, parseSearchSource } from "./commands/search";
 import { checkForUpdate, performUpgrade } from "./commands/self-update";
@@ -109,6 +112,7 @@ import { clearLogFile, info, isQuiet, isVerbose, setLogFile, setQuiet, setVerbos
 import { closeDatabase, openExistingDatabase } from "./indexer/db";
 import { akmIndex } from "./indexer/indexer";
 import { resolveSourceEntries } from "./indexer/search-source";
+import { resolveTriageJudgmentRunner } from "./integrations/agent/runner";
 import { EMBEDDED_HINTS, EMBEDDED_HINTS_FULL } from "./output/cli-hints";
 import { getHyphenatedArg, getHyphenatedBoolean, getOutputMode, hasBooleanFlag, initOutputMode, parseDetailLevel, parseFlagValue, } from "./output/context";
 import { formatEventLine } from "./output/text";
@@ -3460,13 +3464,128 @@ const proposalShowCommand = defineCommand({
         });
     },
 });
+const proposalDrainCommand = defineCommand({
+    meta: {
+        name: "drain",
+        description: "Drain the standing pending proposal backlog using a deterministic triage policy",
+    },
+    args: {
+        policy: {
+            type: "string",
+            description: "Built-in preset (personal-stash|conservative|manual) or path to a policy file",
+        },
+        "dry-run": {
+            type: "boolean",
+            description: "List what would be accepted/rejected/deferred without writing.",
+            default: false,
+        },
+        yes: {
+            type: "boolean",
+            alias: "y",
+            description: "Skip confirmation prompt (required in non-interactive mode for promotion).",
+            default: false,
+        },
+        "max-accepts": {
+            type: "string",
+            description: "Hard per-run accept ceiling. Accepts beyond this are reported as skippedByCap.",
+        },
+        "max-diff-lines": {
+            type: "string",
+            description: "Defer (never promote) accepts whose proposed content exceeds this many lines.",
+        },
+        "older-than": {
+            type: "string",
+            description: "Only consider proposals created more than this many days ago.",
+        },
+        promote: {
+            type: "boolean",
+            description: "Promote (accept) matching proposals. Default is queue mode (stage only, no writes to assets).",
+            default: false,
+        },
+        judgment: {
+            type: "boolean",
+            description: "Opt into the judgment tier (llm by default; agent/sdk per config) for deferred items. No-op with a logged triage_deferred summary when no runner is configured.",
+            default: false,
+        },
+        profile: {
+            type: "string",
+            description: "Read the triage block (policy, applyMode, ceilings, judgment) from this improve profile.",
+        },
+    },
+    async run({ args }) {
+        await runWithJsonErrors(async () => {
+            const stashDir = resolveStashDir();
+            // Phase 2: read the triage block from the named improve profile. CLI flags
+            // always override config; config supplies defaults for any flag omitted.
+            const triageConfig = args.profile !== undefined
+                ? resolveImproveProfile(args.profile, loadConfig()).processes?.triage
+                : undefined;
+            const policy = resolveDrainPolicy(args.policy ?? triageConfig?.policy);
+            const dryRun = args["dry-run"] === true;
+            const applyMode = args.promote === true ? "promote" : (triageConfig?.applyMode ?? "queue");
+            const maxAccepts = parsePositiveIntFlag(args["max-accepts"], "--max-accepts") ??
+                triageConfig?.maxAcceptsPerRun ??
+                25;
+            const maxDiffLines = parsePositiveIntFlag(args["max-diff-lines"], "--max-diff-lines") ??
+                triageConfig?.maxDiffLines;
+            const rawOlderThan = parsePositiveIntFlag(args["older-than"], "--older-than");
+            const olderThanMs = rawOlderThan !== undefined ? rawOlderThan * 86_400_000 : undefined;
+            // Promotion in promote mode is destructive (commits to git, no batch revert).
+            if (applyMode === "promote" && !dryRun) {
+                const { confirmDestructive } = await import("./cli/confirm.js");
+                const confirmed = await confirmDestructive(`Drain and promote matching pending proposals under policy "${policy.name}"? Promotions commit to git and cannot be batch-reverted.`, { yes: args.yes === true });
+                if (!confirmed) {
+                    process.stderr.write("Aborted.\n");
+                    return;
+                }
+            }
+            // `--older-than` is applied here as a pre-filter on excludeIds: ids that
+            // are too fresh are excluded so the engine never touches them.
+            let excludeIds;
+            if (olderThanMs !== undefined) {
+                const { listProposals } = await import("./core/proposals");
+                const now = Date.now();
+                excludeIds = new Set(listProposals(stashDir, { status: "pending" })
+                    .filter((proposal) => now - new Date(proposal.createdAt).getTime() < olderThanMs)
+                    .map((proposal) => proposal.id));
+            }
+            // Phase 3: resolve the judgment runner when --judgment is set. Default
+            // mode is llm; falls back to defaults.llm when the triage block sets
+            // neither mode nor profile (mirrors resolveValidationRunner). null when
+            // nothing is configured → the engine leaves deferred items unresolved and
+            // emits triage_deferred.
+            const judgment = args.judgment === true ? resolveTriageJudgmentRunner(triageConfig?.judgment, loadConfig()) : null;
+            const result = await drainProposals({
+                stashDir,
+                policy,
+                applyMode,
+                maxAccepts,
+                dryRun,
+                ...(maxDiffLines !== undefined ? { maxDiffLines } : {}),
+                ...(excludeIds ? { excludeIds } : {}),
+                judgment,
+            });
+            output("proposal-drain", {
+                schemaVersion: 1,
+                ok: true,
+                policy: policy.name,
+                applyMode,
+                dryRun,
+                promoted: result.promoted,
+                rejected: result.rejected,
+                deferred: result.deferred,
+                skippedByCap: result.skippedByCap,
+            });
+        });
+    },
+});
 // ── proposal noun group (#225 / 0.8 CLI stabilization) ────────────────────────
 //
 // `akm proposal <verb>` is the canonical grammar in 0.8. The flat verbs
 // (`proposals`/`accept`/`reject`/`diff`/`revert`) remain as deprecated aliases
 // that warn to stderr and delegate to the same command bodies; they are removed
 // in 0.9.0. Bare `akm proposal` behaves as `proposal list` (mirrors `akm env`).
-const PROPOSAL_SUBCOMMAND_SET = new Set(["list", "show", "diff", "accept", "reject", "revert"]);
+const PROPOSAL_SUBCOMMAND_SET = new Set(["list", "show", "diff", "accept", "reject", "revert", "drain"]);
 function emitProposalVerbDeprecation(oldVerb, canonical) {
     if (isQuiet())
         return;
@@ -3489,6 +3608,7 @@ const proposalCommand = defineCommand({
         accept: proposalAcceptCommand,
         reject: proposalRejectCommand,
         revert: proposalRevertCommand,
+        drain: proposalDrainCommand,
     },
     run({ args }) {
         return runWithJsonErrors(() => {

package/dist/commands/consolidate.js

@@ -1148,6 +1148,27 @@ export async function akmConsolidate(opts = {}) {
                 emitMergeFailureSkips("merge_no_valid_secondaries");
                 continue;
             }
+            // Pre-flight hot guard — skip the LLM call entirely if any participant
+            // is hot or unparseable. Without this, mixed chunks still send hot merges
+            // to the planner which proposes them; generateMergedContent() is then
+            // called, produces output without `description`, and the skip is
+            // misattributed to merge_missing_description instead of the real cause.
+            const preflightParticipants = [op.primary, ...op.secondaries];
+            const preflightBlocked = preflightParticipants.flatMap((ref) => {
+                const e = memoryByRef.get(ref);
+                if (!e)
+                    return [];
+                const verdict = consolidateGuardStatus(e.filePath);
+                if (verdict === "hot" || verdict === "unparseable")
+                    return [{ ref, verdict }];
+                return [];
+            });
+            if (preflightBlocked.length > 0) {
+                const detail = preflightBlocked.map((p) => `${p.ref} (${p.verdict})`).join(", ");
+                warnings.push(`Merge: refused for ${op.primary} — ${preflightBlocked.length} participant(s) blocked by hot/unparseable frontmatter guard (pre-flight): ${detail}`);
+                emitMergeFailureSkips("merge_participant_blocked");
+                continue;
+            }
             let primaryBody = "";
             try {
                 primaryBody = fs.readFileSync(primaryEntry.filePath, "utf8");
@@ -2003,6 +2024,7 @@ async function generateMergedContent(config, primaryRef, primaryBody, secondaryR
         "",
         "## FRONTMATTER RULES (MANDATORY)",
         "- The `updated:` field, if present, MUST be a real ISO date (e.g. `updated: 2026-05-20`). NEVER emit `updated: today`, `updated: now`, or `updated: {today: null}`. If you don't have a real date, OMIT the field — the post-processor will not invent one.",
+        "- REQUIRED: The merged frontmatter MUST include a `description` field with a concise one-sentence summary of the merged asset's content. If neither source has a `description` field, synthesize one from the content.",
         requiredFmKeys.length > 0
             ? `- CRITICAL: The merged frontmatter MUST include ALL of these keys from both source memories: ${requiredFmKeys.join(", ")}. Do NOT drop any of them.`
             : null,

package/dist/commands/improve-cli.js

@@ -58,6 +58,14 @@ export const improveCommand = defineCommand({
             type: "string",
             description: "Named improve profile from profiles.improve or built-in profiles (default, quick, thorough, memory-focus). 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).",
+        },
+        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).",
+        },
     },
     async run({ args }) {
         await runWithJsonErrors(async () => {
@@ -85,6 +93,16 @@ export const improveCommand = defineCommand({
             const minRetrievalCount = parseNonNegativeIntFlag(minRetrievalCountRaw, "--min-retrieval-count");
             const requireFeedbackSignal = getHyphenatedBoolean(args, "require-feedback-signal");
             const profileArg = getStringArg(args, "profile");
+            // 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.
+            const syncFlag = getHyphenatedArg(args, "sync");
+            const pushFlag = getHyphenatedArg(args, "push");
+            const syncOverride = {};
+            if (syncFlag !== undefined)
+                syncOverride.enabled = syncFlag;
+            if (pushFlag !== undefined)
+                syncOverride.push = pushFlag;
             const improveLogFile = path.join(getCacheDir(), "logs", "improve", `${new Date().toISOString().replace(/[:.]/g, "-")}.log`);
             setLogFile(improveLogFile);
             const startedAtMs = Date.now();
@@ -150,6 +168,7 @@ export const improveCommand = defineCommand({
                     ...(minRetrievalCount !== undefined ? { minRetrievalCount } : {}),
                     ...(requireFeedbackSignal ? { requireFeedbackSignal } : {}),
                     ...(profileArg !== undefined ? { profile: profileArg } : {}),
+                    ...(Object.keys(syncOverride).length > 0 ? { sync: syncOverride } : {}),
                     consolidateOptions: {
                         target: targetArg,
                         dryRun,

package/dist/commands/improve-profiles.js

@@ -21,7 +21,9 @@ const BUILTIN_PROFILES = {
             memoryInference: { enabled: true },
             graphExtraction: { enabled: true },
             // validation: deliberately undefined — third-tier classifier is opt-in.
+            triage: { enabled: false, applyMode: "queue", policy: "personal-stash" },
         },
+        sync: { enabled: true, push: true },
     },
     quick: {
         description: "Reflect-only pass — no distill, consolidate, memoryInference, or graphExtraction.",
@@ -31,6 +33,7 @@ const BUILTIN_PROFILES = {
             consolidate: { enabled: false },
             memoryInference: { enabled: false },
             graphExtraction: { enabled: false },
+            triage: { enabled: false },
         },
     },
     thorough: {
@@ -44,7 +47,9 @@ const BUILTIN_PROFILES = {
             consolidate: { enabled: true, allowedTypes: DEFAULT_ALLOWED_TYPES.consolidate },
             memoryInference: { enabled: true },
             graphExtraction: { enabled: true },
+            triage: { enabled: true, applyMode: "queue" },
         },
+        sync: { enabled: true, push: true },
     },
     "memory-focus": {
         description: "Memory and lesson improvement only — no distill or consolidate.",
@@ -54,6 +59,7 @@ const BUILTIN_PROFILES = {
             consolidate: { enabled: false },
             memoryInference: { enabled: true },
             graphExtraction: { enabled: false },
+            triage: { enabled: false },
         },
     },
 };
@@ -76,6 +82,9 @@ const IMPROVE_PROCESS_DEFAULTS = {
     // and queues durable-insight proposals. Default on — opt out via
     // profiles.improve.default.processes.extract.enabled: false.
     extract: true,
+    // proposal-queue triage drains the standing backlog. Opt-in (default off),
+    // like `validation` — needs an explicit `enabled: true`.
+    triage: false,
 };
 /**
  * Compute the effective enabled-state for a named improve process.