akm-cli 0.9.25-alpha.1 → 0.9.25-alpha.3

package/dist/commands/improve/consolidate.js

@@ -53,6 +53,10 @@ import { resolveImproveStrategy, resolveProcessEnabled } from "./improve-strateg
 import { isContentDrivenRow, isLedgerBlocked, ledgerKey, loadLedgerSnapshot, recordLedgerAttempt } from "./ledger.js";
 import { isInRetrievalScope, loadRetrievalScope } from "./retrieval-scope.js";
 import { callStage, mintProposal, noticeSet, stageRunner } from "./stage.js";
+function parsePlan(raw) {
+    const plan = parseEmbeddedJsonResponse(raw);
+    return plan && Array.isArray(plan.operations) ? { ...plan, operations: plan.operations } : undefined;
+}
 /** A plan op worth acting on. Retired advisory ops (merge/delete/contradict) are dropped, never thrown on. */
 export function isValidOp(op) {
     if (typeof op !== "object" || op === null)
@@ -570,6 +574,7 @@ async function judgeConsolidationChunks(args) {
                 ...(Object.hasOwn(llmRunner, "timeoutMs") ? { timeoutMs: llmRunner.timeoutMs } : {}),
                 signal: opts.signal,
             },
+            parse: parsePlan,
             ...(opts.onNotices ? { onNotices: opts.onNotices } : {}),
         });
         if (!outcome.ok) {
@@ -577,8 +582,8 @@ async function judgeConsolidationChunks(args) {
             continue;
         }
         warnVerbose(`[akm:consolidate] ${label} raw response (first 500 chars): ${outcome.raw.slice(0, 500)}`);
-        const parsed = parseEmbeddedJsonResponse(outcome.raw);
-        if (!parsed || !Array.isArray(parsed.operations)) {
+        const parsed = parsePlan(outcome.raw);
+        if (!parsed) {
             const hint = outcome.raw.trim() === "" ? " (empty response — if using a thinking model, disable thinking mode)" : "";
             const msg = `Chunk ${chunkIdx + 1}: invalid plan from AI — skipping.${hint}`;
             warn(msg);

package/dist/commands/improve/execution.js

@@ -2,7 +2,6 @@
 // License, v. 2.0. If a copy of the MPL was not distributed with this
 // file, You can obtain one at https://mozilla.org/MPL/2.0/.
 import { deepMergeConfig } from "../../core/config/deep-merge.js";
-import { MODEL_WORK_TOOLS } from "../../execution/source.js";
 import { buildExecution, resolveExecution } from "../../integrations/agent/execution.js";
 function own(value, key) {
     return value !== undefined && Object.hasOwn(value, key);
@@ -36,12 +35,12 @@ export function resolveImproveExecution(options) {
     if (selectedEngine === undefined || selectedEngine === null)
         return null;
     const invocationDefaults = mergeDefaults(mergeDefaults(defaultEngine ? { engine: defaultEngine } : {}, profileDefaults), indexDefaults);
-    const current = { ...mergeDefaults(processDefaults, currentDefaults), tools: MODEL_WORK_TOOLS };
     const prepared = resolveExecution({
         content: `improve ${options.processName} execution selection`,
         config: options.config,
         invocationDefaults,
-        current,
+        current: mergeDefaults(processDefaults, currentDefaults),
+        modelWork: true,
     });
     const lowered = buildExecution(prepared.request, prepared.runner);
     return Object.freeze({ runner: lowered.runner, notices: lowered.notices });

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

@@ -10,6 +10,7 @@
  *   akm proposal extract --type claude --session-id <id>
  *   akm proposal extract --type claude --since 24h
  *   akm proposal extract --type opencode --since 7d --dry-run
+ *   akm proposal extract --type codex --since 24h
  *   akm proposal extract --auto                 # iterate all available harnesses
  *   akm proposal extract --type claude --location /custom/path --session-id <id>
  *
@@ -25,12 +26,12 @@ import { akmExtract, resolveStandaloneExtractPlan } from "./extract.js";
 export const extractCommand = defineJsonCommand({
     meta: {
         name: "extract",
-        description: "Extract durable insights from native session files (claude, opencode) and queue them as proposals.",
+        description: "Extract durable insights from native session files (claude, codex, opencode) and queue them as proposals.",
     },
     args: {
         type: {
             type: "string",
-            description: "Harness name (claude, opencode). Required unless --auto.",
+            description: "Harness name (claude, codex, opencode). Required unless --auto.",
         },
         "session-id": {
             type: "string",

package/dist/commands/improve/extract.js

@@ -2,7 +2,7 @@
 // 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/.
 /**
- * `akm extract` — read native session logs (claude, opencode) through the
+ * `akm extract` — read native session logs (claude, codex, opencode) through the
  * session-log harnesses, pre-filter the noise, and ask the model for
  * memory/lesson/knowledge candidates the agent did not already save. Each
  * candidate is queued as a proposal (`source: "extract"`), never written.
@@ -741,6 +741,7 @@ function resolveExtractRun(options, config, process, activeProfile) {
                 ...(options.signal ? { signal: options.signal } : {}),
                 ...(options.chat ? { chat: options.chat } : {}),
             },
+            parse: parseSessionSummary,
             onNotices: notices.add,
         });
         return parseSessionSummary(outcome.ok ? outcome.raw : "");

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

@@ -20,13 +20,15 @@ import { collectEngineCredentialValues } from "../../integrations/agent/engine-r
 import { probeLlmReachable } from "../../llm/client.js";
 import { getOutputMode } from "../../output/context.js";
 import { deliverRendered } from "../../output/html-render.js";
+import { readStdin } from "../../runtime.js";
 import { akmImprove, IMPROVE_TARGET_FLAG, resolveImproveReadSource } from "./improve.js";
 import { runImproveReportQuery } from "./improve-report.js";
 import { buildImproveRunId, recordImproveRunResult, recordTerminatedImproveRun, } from "./improve-result-file.js";
 import { runImproveSession } from "./improve-session.js";
-import { resolveImprovePlan, } from "./improve-strategies.js";
+import { resolveImprovePlan, resolveImproveStrategy, } from "./improve-strategies.js";
 import { formatUsageReportTable } from "./improve-usage-report.js";
 import { renderReflectPromptPreview } from "./reflect.js";
+import { resolveQualityGateJudge, runReflectQualityJudge } from "./stage.js";
 let akmImproveForRun = akmImprove;
 /** Swap the CLI's improve work implementation in deterministic subprocess tests. */
 export function _setAkmImproveForTests(fake) {
@@ -188,6 +190,32 @@ function rejectReportOnlyFlags(args) {
         return;
     throw new UsageError(`\`${flag}\` only applies to \`akm improve report\`. Use \`akm improve report ${flag} <value>\` instead.`, "INVALID_FLAG_VALUE");
 }
+/**
+ * `akm improve judge`: reflect's quality judge on one revision, read as
+ * `{"source", "candidate", "feedback"}` JSON from stdin, with the engine the
+ * strategy's reflect quality gate names. It writes nothing.
+ */
+async function runImproveJudgeCli(strategyName) {
+    const input = process.stdin.isTTY
+        ? {}
+        : JSON.parse((await readStdin()).toString("utf8"));
+    const { source, candidate, feedback, ref } = input;
+    if (typeof source !== "string" || typeof candidate !== "string") {
+        throw new UsageError('`akm improve judge` reads {"source": "...", "candidate": "...", "feedback": "...", "ref": "..."} JSON from stdin.', "MISSING_REQUIRED_ARGUMENT");
+    }
+    const config = loadConfig();
+    const judge = resolveQualityGateJudge(config, resolveImproveStrategy(strategyName, config).config, "reflect");
+    if (!judge) {
+        throw new ConfigError("`akm improve judge` judges with the reflect quality gate's engine. Set processes.reflect.qualityGate.engine.", "INVALID_CONFIG_FILE");
+    }
+    const notes = typeof feedback === "string" && feedback.trim() !== "" ? [feedback.trim()] : [];
+    const verdict = await runReflectQualityJudge(config, candidate, source, notes, undefined, {
+        runnerSelectionFrozen: true,
+        llmRunner: judge,
+        ...(typeof ref === "string" && ref ? { ref } : {}),
+    });
+    output("improve-judge", { engine: judge.engine, ...verdict });
+}
 export const improveCommand = defineCommand({
     meta: {
         name: "improve",
@@ -270,6 +298,10 @@ export const improveCommand = defineCommand({
                 return;
             }
             rejectReportOnlyFlags(args);
+            if (getStringArg(args, "scope") === "judge") {
+                await runImproveJudgeCli(getStringArg(args, "strategy"));
+                return;
+            }
             rejectRetiredImproveTargetFlag();
             const jsonToStdout = args["json-to-stdout"];
             const targetArg = getStringArg(args, "bundle");

package/dist/commands/improve/loop-stages.js

@@ -149,6 +149,9 @@ async function runLoopReflectPass(planned, env, tally) {
         ...(reflectErrors.length > 0 ? { avoidPatterns: [...reflectErrors] } : {}),
         eventSource: "improve",
         lowValueFilter: improveProfile.processes?.reflect?.lowValueFilter?.enabled === true,
+        ...(improveProfile.processes?.reflect?.defectFilter
+            ? { defectFilter: improveProfile.processes.reflect.defectFilter }
+            : {}),
         ...(budgetMs > 0 ? { timeoutMs: budgetMs } : {}),
         signal: env.budgetSignal,
         eventsCtx: env.eventsCtx,

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

@@ -9,8 +9,13 @@
  * cosmetic edit through costs a review, suppressing a real fix loses work — so
  * anything uncertain is `substantive`: code (fenced or indented) compares
  * verbatim, and headings, tables and breaks never absorb the next line.
+ *
+ * `findReflectDefect` is its counterpart for an edit that is not noise but a
+ * defect no judge needs to weigh: placeholder text, talk about the edit itself,
+ * or frontmatter copied into the body.
  */
 import { parse as yamlParse } from "yaml";
+import { parseFrontmatter } from "../../core/asset/frontmatter.js";
 /**
  * `noop` (identical up to trailing whitespace) and `cosmetic` (identical after
  * normalizing frontmatter as parsed YAML and prose as unwrapped text) never
@@ -36,6 +41,126 @@ export function classifyReflectChange(sourceContent, candidateContent) {
     }
     return "substantive";
 }
+/** Not TODO, TBD or FIXME: an asset may carry those on purpose, and the owner does not want them refused. */
+const DEFAULT_PLACEHOLDERS = [
+    "please confirm",
+    "please verify",
+    "to be confirmed",
+    "to be determined",
+    "to be verified",
+];
+const DEFAULT_META_COMMENTARY = [
+    "feedback signal",
+    "feedback signals",
+    "feedback indicate",
+    "feedback indicates",
+    "feedback suggest",
+    "feedback suggests",
+    "feedback ask",
+    "feedback asks",
+    "feedback says",
+    "feedback report",
+    "feedback reports",
+    "feedback request",
+    "feedback requests",
+    "this revision",
+    "the source asset",
+    "the source note",
+    "the source memory",
+    "the original asset",
+    "the original note",
+    "the original memory",
+    "the original version of this",
+    "quality gate rejected",
+    "proposal rejected",
+];
+const DEFAULT_FRONTMATTER_KEYS = [
+    "sources",
+    "updated",
+    "inferenceProcessed",
+    "captureMode",
+    "beliefState",
+    "xrefs",
+    "contradictedBy",
+    "outcomeData",
+    "orderedActions",
+    "generated",
+    "verified",
+    "description",
+    "when_to_use",
+    "tags",
+    "searchHints",
+    "quality",
+    "salience",
+    "salienceInputs",
+    "lint_skip",
+    "type",
+];
+/**
+ * The first defect the candidate has and its source lacks, or `undefined`. Each
+ * rule counts only what the revision adds, so text the asset already carried is
+ * not held against it. On 396 labelled reflect edits (83 good, 313 bad) the
+ * default lists hit 22 bad edits and no good one, so a hit is refused unjudged.
+ */
+export function findReflectDefect(sourceContent, candidateContent, filter = {}) {
+    if (gainsPhrases(filter.placeholders ?? DEFAULT_PLACEHOLDERS, sourceContent, candidateContent)) {
+        return "placeholder_added";
+    }
+    if (gainsPhrases(filter.metaCommentary ?? DEFAULT_META_COMMENTARY, sourceContent, candidateContent)) {
+        return "meta_commentary_added";
+    }
+    if (frontmatterCopiedIntoBody(sourceContent, candidateContent, filter.frontmatterKeys ?? DEFAULT_FRONTMATTER_KEYS)) {
+        return "frontmatter_copied_into_body";
+    }
+    return undefined;
+}
+/** Frontmatter fields that name other assets; one of their values newly in the body is provenance copied over. */
+const PROVENANCE_KEYS = ["sources", "xrefs", "contradictedBy"];
+/** Shorter values (a bare name or id) say too little to find in a body. */
+const PROVENANCE_VALUE_MIN_CHARS = 12;
+function escapeRegExp(text) {
+    return text.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+/** Whether the candidate holds more of the phrases than the source: whole words, any case, any whitespace between words. */
+function gainsPhrases(phrases, source, candidate) {
+    const alternatives = phrases
+        .map((phrase) => phrase.trim().split(/\s+/).map(escapeRegExp).join("\\s+"))
+        .filter((alternative) => alternative !== "");
+    if (alternatives.length === 0)
+        return false;
+    const pattern = new RegExp(`(?<!\\w)(?:${alternatives.join("|")})(?!\\w)`, "gi");
+    return (candidate.match(pattern)?.length ?? 0) > (source.match(pattern)?.length ?? 0);
+}
+/** The body gains a line that starts with one of the frontmatter keys outside code, or a provenance value from either asset's frontmatter. */
+function frontmatterCopiedIntoBody(source, candidate, keys) {
+    if (keys.length === 0)
+        return false;
+    const keyLine = new RegExp(`^(?:${keys.map(escapeRegExp).join("|")}):(?:[ \\t].*)?$`);
+    const keyLines = (text) => parseLowValueSections(text).proseLines.filter((line) => keyLine.test(line)).length;
+    if (keyLines(candidate) > keyLines(source))
+        return true;
+    const sourceBody = lettersAndDigits(splitFrontmatter(source).body);
+    const candidateBody = lettersAndDigits(splitFrontmatter(candidate).body);
+    return [...provenanceValues(source), ...provenanceValues(candidate)].some((value) => {
+        const v = lettersAndDigits(value);
+        return v.length >= PROVENANCE_VALUE_MIN_CHARS && candidateBody.includes(v) && !sourceBody.includes(v);
+    });
+}
+/** Every string under the provenance keys of a frontmatter block: a scalar, or the items of a list. */
+function provenanceValues(content) {
+    const { data } = parseFrontmatter(content);
+    return PROVENANCE_KEYS.flatMap((key) => {
+        const value = data[key];
+        return (Array.isArray(value) ? value : [value]).filter((item) => typeof item === "string");
+    });
+}
+/** Lower-case letters and digits, each run of anything else a single space. */
+function lettersAndDigits(text) {
+    return text
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, " ")
+        .trim();
+}
 /** A `---` frontmatter block and the rest (`fmText: null` when there is none). */
 export function splitFrontmatter(raw) {
     const m = raw.match(/^---\r?\n([\s\S]*?)\r?\n---\r?\n?([\s\S]*)$/);