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

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

@@ -17,7 +17,7 @@ import { UsageError } from "../../core/errors.js";
 import { resolveTriageJudgmentRunner } from "../../integrations/agent/runner.js";
 import { installLlmUsagePersistenceIfAbsent } from "../../llm/usage-persist.js";
 import { withLlmStage } from "../../llm/usage-telemetry.js";
-import { resolveImproveProfile } from "../improve/improve-profiles.js";
+import { resolveImproveStrategy } from "../improve/improve-strategies.js";
 import { drainProposals } from "./drain.js";
 import { resolveDrainPolicy } from "./drain-policies.js";
 import { akmProposalAccept, akmProposalDiff, akmProposalList, akmProposalReject, akmProposalRevert, akmProposalShow, } from "./proposal.js";
@@ -353,17 +353,21 @@ const proposalDrainCommand = defineJsonCommand({
             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: {
+        strategy: {
             type: "string",
-            description: "Read the triage block (policy, applyMode, ceilings, judgment) from this improve profile.",
+            description: "Read the triage block (policy, applyMode, ceilings, judgment) from this improve strategy.",
         },
     },
-    async run({ args }) {
+    async run({ args, rawArgs }) {
+        if (rawArgs.some((arg) => arg === "--profile" || arg.startsWith("--profile="))) {
+            throw new UsageError("proposal drain: --profile is retired; use --strategy.", "INVALID_FLAG_VALUE");
+        }
         const stashDir = resolveStashDir();
         const cfg = loadConfig();
-        // Phase 2: read the triage block from the named improve profile. CLI flags
+        // Phase 2: read the triage block from the named improve strategy. CLI flags
         // always override config; config supplies defaults for any flag omitted.
-        const triageConfig = args.profile !== undefined ? resolveImproveProfile(args.profile, cfg).processes?.triage : undefined;
+        const selectedStrategy = resolveImproveStrategy(args.strategy, cfg);
+        const triageConfig = selectedStrategy.config.processes?.triage;
         const policy = resolveDrainPolicy(args.policy ?? triageConfig?.policy);
         const dryRun = args["dry-run"] === true;
         const applyMode = args.promote === true ? "promote" : (triageConfig?.applyMode ?? "queue");
@@ -404,10 +408,12 @@ const proposalDrainCommand = defineJsonCommand({
         }
         // 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
+        // no explicit engine selection. null when
         // nothing is configured → the engine leaves deferred items unresolved and
         // emits triage_deferred.
-        const judgment = args.judgment === true ? resolveTriageJudgmentRunner(triageConfig?.judgment, cfg) : null;
+        const judgment = args.judgment === true
+            ? resolveTriageJudgmentRunner(triageConfig?.judgment, cfg, triageConfig, selectedStrategy.config)
+            : null;
         // #576: persist + attribute per-call LLM usage for the standalone drain
         // path. `IfAbsent` keeps an enclosing `akm improve` sink in charge when
         // drain runs as a sub-step; the disposer clears only a sink we installed.
@@ -434,10 +440,14 @@ const proposalDrainCommand = defineJsonCommand({
             policy: policy.name,
             applyMode,
             dryRun,
+            strategy: selectedStrategy.name,
+            judgmentEngine: judgment?.engine ?? null,
+            judgmentKind: judgment?.kind ?? null,
             promoted: result.promoted,
             rejected: result.rejected,
             deferred: result.deferred,
             skippedByCap: result.skippedByCap,
+            staged: result.staged,
         });
     },
 });

package/dist/commands/proposal/propose.js

@@ -18,18 +18,20 @@ import { TYPE_DIRS } from "../../core/asset/asset-spec.js";
 import { resolveStashDir } from "../../core/common.js";
 import { ConfigError, UsageError } from "../../core/errors.js";
 import { appendEvent } from "../../core/events.js";
+import { redactSensitiveText } from "../../core/redaction.js";
 import { resolveStandardsContext } from "../../core/standards/resolve-standards-context.js";
-import { runAgent, } from "../../integrations/agent/index.js";
-import { resolveProcessAgentProfile } from "../../integrations/agent/config.js";
+import { resolveEngine } from "../../integrations/agent/engine-resolution.js";
 import { buildProposePrompt, parseAgentProposalPayload } from "../../integrations/agent/prompts.js";
-import { runOpencodeSdk } from "../../integrations/harnesses/opencode-sdk/index.js";
-import { baseFailureFields, enoentHintMessage, isEnoentFailure, loadAgentConfigFromDisk, resolveAgentProfile, } from "../agent/agent-support.js";
+import { collectDispatchSensitiveValues, executeRunner } from "../../integrations/agent/runner-dispatch.js";
+import { baseFailureFields, enoentHintMessage, isEnoentFailure } from "../agent/agent-support.js";
 import { createProposal, isProposalSkipped, } from "./repository.js";
-function failureEnvelope(result, type, name, fallbackReason = "non_zero_exit") {
+function failureEnvelope(result, type, name, engine, fallbackReason = "non_zero_exit") {
     return {
         ...baseFailureFields(result, fallbackReason),
+        schemaVersion: 2,
         type,
         name,
+        engine,
     };
 }
 export async function akmPropose(options) {
@@ -54,41 +56,17 @@ export async function akmPropose(options) {
             type: options.type,
             name: options.name,
             task: options.task,
-            ...(options.profile ? { profile: options.profile } : {}),
+            ...(options.engine ? { engine: options.engine } : {}),
         },
     });
-    // 2. Resolve profile.
-    // When an explicit --profile flag is given, honour it directly (existing
-    // behaviour). Otherwise use resolveProcessAgentProfile so that per-process
-    // agent config (agent.processes["propose"]) is picked up automatically.
-    let profile;
-    let resolvedTimeoutMs = options.timeoutMs;
-    try {
-        if (options.agentProfile) {
-            // Test seam: injected profile bypasses all config.
-            profile = options.agentProfile;
-        }
-        else if (options.profile) {
-            // Explicit --profile flag wins over process config.
-            profile = resolveAgentProfile(options);
-        }
-        else {
-            // Use per-process config resolution (falls back to agent.default).
-            const agent = options.agentConfig ?? loadAgentConfigFromDisk();
-            const processName = options.agentProcess ?? "propose";
-            const resolved = resolveProcessAgentProfile(processName, agent);
-            profile = resolved.profile;
-            // Only apply process-resolved timeoutMs when caller didn't supply one.
-            if (resolvedTimeoutMs === undefined) {
-                resolvedTimeoutMs = resolved.timeoutMs;
-            }
-        }
-    }
-    catch (err) {
-        if (err instanceof ConfigError || err instanceof UsageError)
-            throw err;
-        throw err;
-    }
+    // 2. Resolve the selected engine exactly once. Propose accepts either kind;
+    // the LLM arm uses the caller-specific plain-chat handler below.
+    const config = options.agentConfig ?? (await import("../../core/config/config.js")).loadConfig();
+    const engineName = options.engine ?? config.defaults?.engine;
+    if (!engineName)
+        throw new ConfigError("propose requires --engine or defaults.engine.", "INVALID_CONFIG_FILE");
+    const runner = resolveEngine(engineName, config);
+    const profile = runner.kind === "llm" ? undefined : runner.profile;
     // 3. Build prompt.
     // Synthesize a temp draft path so opencode can write the asset content
     // directly using its file tools rather than returning JSON via stdout.
@@ -104,39 +82,51 @@ export async function akmPropose(options) {
         ...(standardsContext.trim() ? { standardsContext } : {}),
         draftFilePath: resolvedDraftPath,
     });
-    // 4. Spawn the agent.
+    // 4. Dispatch the selected engine.
     // Real agent runs use interactive mode so file tools can write the draft.
     // Injected/custom spawns still need captured stdout for JSON payload tests.
-    // Use callAi for the unified AI dispatch path (agent CLI preferred, LLM HTTP fallback).
+    // All kinds cross the unified RunnerSpec dispatch boundary.
     const useCustomSpawn = Boolean(options.runAgentOptions?.spawn);
     let result;
-    if (useCustomSpawn) {
-        // Test seam: use raw runAgent with injected spawn so tests remain deterministic.
-        const runOptions = {
-            stdio: "captured",
-            parseOutput: "text",
-            ...(resolvedTimeoutMs !== undefined ? { timeoutMs: resolvedTimeoutMs } : {}),
-            ...(options.runAgentOptions ?? {}),
-        };
-        result = await runAgent(profile, prompt, runOptions);
-    }
-    else {
-        // Production path: dispatch directly to the appropriate runner.
-        const runOptions = {
-            stdio: resolvedDraftPath ? "interactive" : "captured",
-            parseOutput: "text",
-            ...(resolvedTimeoutMs !== undefined ? { timeoutMs: resolvedTimeoutMs } : {}),
-        };
-        result = profile.sdkMode
-            ? await runOpencodeSdk(profile, prompt ?? "", runOptions)
-            : await runAgent(profile, prompt, runOptions);
-    }
+    const runOptions = {
+        stdio: useCustomSpawn ? "captured" : "interactive",
+        parseOutput: "text",
+        ...(options.timeoutMs !== undefined ? { timeoutMs: options.timeoutMs } : {}),
+        ...(options.runAgentOptions ?? {}),
+    };
+    const sensitiveValues = collectDispatchSensitiveValues(runner, runOptions);
+    result = await executeRunner(runner, prompt, runOptions, {
+        llm: async (spec, llmPrompt, opts) => {
+            const { chatCompletion } = await import("../../llm/client.js");
+            const started = Date.now();
+            try {
+                const stdout = await chatCompletion(spec.connection, [{ role: "user", content: llmPrompt }], {
+                    ...(Object.hasOwn(opts, "timeoutMs") ? { timeoutMs: opts.timeoutMs } : {}),
+                });
+                return { ok: true, exitCode: 0, stdout, stderr: "", durationMs: Date.now() - started };
+            }
+            catch (error) {
+                return {
+                    ok: false,
+                    exitCode: null,
+                    stdout: "",
+                    stderr: "",
+                    durationMs: Date.now() - started,
+                    error: String(error),
+                    reason: "spawn_failed",
+                };
+            }
+        },
+    });
     if (!result.ok) {
         // B3: ENOENT / not-found gives an actionable hint.
         if (isEnoentFailure(result)) {
-            return { ...failureEnvelope(result, options.type, options.name), error: enoentHintMessage(profile.bin) };
+            return {
+                ...failureEnvelope(result, options.type, options.name, engineName),
+                error: enoentHintMessage(profile?.bin ?? engineName),
+            };
         }
-        return failureEnvelope(result, options.type, options.name);
+        return failureEnvelope(result, options.type, options.name, engineName);
     }
     // 5. Resolve the proposal content.
     // Path A: opencode wrote the draft file — read it directly (no stdout parse).
@@ -156,12 +146,13 @@ export async function akmPropose(options) {
         const stdioWasInteractive = !useCustomSpawn;
         if (stdioWasInteractive && (result.stdout ?? "") === "") {
             return {
-                schemaVersion: 1,
+                schemaVersion: 2,
                 ok: false,
                 reason: "parse_error",
                 error: "Agent did not write draft file and stdout was not captured (interactive mode). Check that the agent CLI understood the file-write instruction, or configure a headless profile with stdio: 'captured'.",
                 type: options.type,
                 name: options.name,
+                engine: engineName,
                 exitCode: result.exitCode,
                 ...(result.stderr ? { stderr: result.stderr } : {}),
             };
@@ -171,18 +162,20 @@ export async function akmPropose(options) {
         }
         catch (err) {
             return {
-                schemaVersion: 1,
+                schemaVersion: 2,
                 ok: false,
                 reason: "parse_error",
                 error: err instanceof Error ? err.message : String(err),
                 type: options.type,
                 name: options.name,
+                engine: engineName,
                 exitCode: result.exitCode,
                 stdout: result.stdout,
                 ...(result.stderr ? { stderr: result.stderr } : {}),
             };
         }
     }
+    payload = { ...payload, content: redactSensitiveText(payload.content, sensitiveValues) };
     // 6. Insert the proposal. Note: we allow the agent's `ref` to normalise the
     // asset name (e.g. path-cleanup), but only after validating that the ref is
     // well-formed and the type still matches the requested type.
@@ -195,12 +188,13 @@ export async function akmPropose(options) {
         }
         catch (err) {
             return {
-                schemaVersion: 1,
+                schemaVersion: 2,
                 ok: false,
                 reason: "parse_error",
                 error: err instanceof Error ? err.message : String(err),
                 type: options.type,
                 name: options.name,
+                engine: engineName,
                 exitCode: result.exitCode,
                 stdout: result.stdout,
                 ...(result.stderr ? { stderr: result.stderr } : {}),
@@ -208,12 +202,13 @@ export async function akmPropose(options) {
         }
         if (parsedRef.type !== options.type) {
             return {
-                schemaVersion: 1,
+                schemaVersion: 2,
                 ok: false,
                 reason: "parse_error",
                 error: `Agent returned ref type ${parsedRef.type} but expected ${options.type}`,
                 type: options.type,
                 name: options.name,
+                engine: engineName,
                 exitCode: result.exitCode,
                 stdout: result.stdout,
                 ...(result.stderr ? { stderr: result.stderr } : {}),
@@ -241,11 +236,11 @@ export async function akmPropose(options) {
     }
     const proposal = proposalResult;
     return {
-        schemaVersion: 1,
+        schemaVersion: 2,
         ok: true,
         proposal,
         ref: proposal.ref,
-        agentProfile: profile.name,
+        engine: engineName,
         durationMs: result.durationMs,
     };
 }