akm-cli 0.9.1 → 0.9.2-alpha.1

package/dist/commands/proposal/proposal.js

@@ -15,7 +15,7 @@ import { resolveStashDir } from "../../core/common.js";
 import { loadConfig } from "../../core/config/config.js";
 import { resolveWriteTarget } from "../../core/write-source.js";
 import { withAssetMutationLease } from "../../indexer/index-writer-lock.js";
-import { createProposal, diffProposal, isProposalSkipped, listProposals, preflightProposalPromotion, promoteProposal, proposalContent, recoverProposalTransactionsForStash, rejectProposalDurably, resolveProposalId, resolveProposalIdForReject, revertProposal, } from "./repository.js";
+import { createProposal, diffProposal, isProposalSkipped, listProposals, preflightProposalPromotion, promoteProposal, proposalContent, recoverProposalTransactionsForStash, rejectProposalDurably, resolveProposalId, revertProposal, } from "./repository.js";
 import { validateProposal } from "./validators/proposals.js";
 // ── Shared helpers ──────────────────────────────────────────────────────────
 function resolveStash(stashDir) {
@@ -103,10 +103,7 @@ export async function akmProposalReject(options) {
     return withAssetMutationLease("proposal-reject", async () => {
         const config = options.config ?? loadConfig();
         const { stashDir: stash } = resolveProposalQueue(options.stashDir, options.queue, config);
-        // resolveProposalIdForReject tolerates a legacy row whose metadata fails
-        // strict decoding — resolveProposalId's exact-UUID match would otherwise
-        // throw here, before the terminal-status machinery even runs.
-        const proposalId = resolveProposalIdForReject(stash, options.id, options.ctx);
+        const proposalId = resolveProposalId(stash, options.id, options.ctx).id;
         await recoverProposalTransactionsForStash(stash, config, options.ctx, proposalId);
         const updated = rejectProposalDurably(stash, proposalId, options.reason, options.ctx, options.gateDecision);
         return {

package/dist/commands/proposal/propose.js

@@ -16,27 +16,81 @@ import fs from "node:fs";
 import { placementTypes, stashDirFor } from "../../core/asset/asset-placement.js";
 import { parseRefInput } from "../../core/asset/resolve-ref.js";
 import { resolveStashDir } from "../../core/common.js";
-import { ConfigError, UsageError } from "../../core/errors.js";
+import { 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 { warn } from "../../core/warn.js";
 import { deriveEntryProvenance } from "../../indexer/installations.js";
-import { fallbackAnnouncement, NO_ENGINE_MESSAGE_SUFFIX, NO_ENGINE_REMEDY, withEngineFallback, } from "../../integrations/agent/engine-fallback.js";
-import { resolveEngine } from "../../integrations/agent/engine-resolution.js";
+import { fallbackAnnouncement } from "../../integrations/agent/engine-fallback.js";
+import { acquireLoweredExecutionDispatchLease, dispatchLoweredExecutionRequest, disposeLoweredExecutionDispatchLease, lowerResolvedExecutionRequest, redactWithLoweredExecutionDispatchLease, } from "../../integrations/agent/execution-lowering.js";
+import { prepareInlineExecution } from "../../integrations/agent/inline-execution.js";
 import { buildProposePrompt, parseAgentProposalPayload } from "../../integrations/agent/prompts.js";
-import { collectDispatchSensitiveValues, executeRunner } from "../../integrations/agent/runner-dispatch.js";
 import { baseFailureFields, enoentHintMessage, isEnoentFailure } from "../agent/agent-support.js";
 import { createProposal, isProposalSkipped, resolveProposalQueueTarget, } from "./repository.js";
-function failureEnvelope(result, type, name, engine, fallbackReason = "non_zero_exit") {
+function failureEnvelope(result, type, name, engine, notices, fallbackReason = "non_zero_exit") {
     return {
         ...baseFailureFields(result, fallbackReason),
         schemaVersion: 2,
         type,
         name,
         engine,
+        ...(notices.length > 0 ? { notices } : {}),
     };
 }
+function noticeFields(notices) {
+    return notices.length > 0 ? { notices } : {};
+}
+/** Materialize required credentials through the real runner boundary, without provider I/O. */
+async function preflightProposalDispatch(lowered, runOptions) {
+    return acquireLoweredExecutionDispatchLease(lowered, {
+        ...(runOptions.envSource ? { envSource: runOptions.envSource } : {}),
+    });
+}
+/** Resolve, lower, and dispatch the already-rendered proposal prompt. */
+async function dispatchProposalPrompt(prompt, config, options, onDispatchReady) {
+    const current = {
+        ...(options.engine !== undefined ? { engine: options.engine } : {}),
+        ...(options.timeoutMs !== undefined ? { timeout: options.timeoutMs } : {}),
+    };
+    const prepared = prepareInlineExecution({
+        content: prompt,
+        config,
+        invocationKind: "direct",
+        ...(Object.keys(current).length > 0 ? { current } : {}),
+    });
+    const engineName = prepared.request.engine.name;
+    const announcement = fallbackAnnouncement(prepared.fallbackEngineName, engineName);
+    if (announcement)
+        warn(announcement);
+    const lowered = lowerResolvedExecutionRequest(prepared.request, prepared.config);
+    const interactive = !options.runAgentOptions?.spawn;
+    const runOptions = {
+        stdio: interactive ? "interactive" : "captured",
+        parseOutput: "text",
+        ...(options.runAgentOptions ?? {}),
+    };
+    const lease = await preflightProposalDispatch(lowered, runOptions);
+    // Materialize/validate every required symbolic credential before the entry
+    // event opens durable state. Provider/runtime failures still occur after the
+    // event, preserving the command-attempt observability contract.
+    try {
+        onDispatchReady();
+        options.onDispatchReady?.();
+        const result = await dispatchLoweredExecutionRequest(lowered, { runOptions, lease });
+        return {
+            result,
+            engineName,
+            ...(lowered.runner.kind === "llm" ? {} : { engineBin: lowered.runner.profile.bin }),
+            notices: lowered.notices,
+            lease,
+            interactive,
+        };
+    }
+    catch (error) {
+        disposeLoweredExecutionDispatchLease(lease);
+        throw error;
+    }
+}
 /**
  * WI-8.5a — the fully-qualified `bundle//conceptId` item_ref for a proposal
  * target in `stashDir`. The conceptId is BUILT from the D-R2 static table
@@ -80,23 +134,11 @@ export async function akmPropose(options) {
         throw new UsageError(`propose: unknown asset type "${options.type}". Known types: ${[...placementTypes()].sort().join(", ")}.`, "INVALID_FLAG_VALUE");
     }
     const stash = options.stashDir ?? resolveStashDir();
-    // 1. Resolve the selected engine and write target exactly once.
-    // the LLM arm uses the caller-specific plain-chat handler below.
+    // 1. Resolve the write target. Engine/model/inference resolution happens
+    // exactly once below through the shared execution cascade.
     const config = options.agentConfig ?? (await import("../../core/config/config.js")).loadConfig();
     const target = resolveProposalQueueTarget(stash, config);
-    emitProposeInvoked(target.source, options);
-    const { config: engineConfig, fallbackEngineName } = withEngineFallback(config);
-    const engineName = options.engine ?? engineConfig.defaults?.engine;
-    // Announced, never silent: `options.engine` outranks the default, so the
-    // fallback is only reportable when it is the engine actually selected.
-    const engineAnnouncement = fallbackAnnouncement(fallbackEngineName, engineName);
-    if (engineAnnouncement)
-        warn(engineAnnouncement);
-    if (!engineName)
-        throw new ConfigError(`propose ${NO_ENGINE_MESSAGE_SUFFIX} ${NO_ENGINE_REMEDY}`, "INVALID_CONFIG_FILE");
-    const runner = resolveEngine(engineName, engineConfig);
-    const profile = runner.kind === "llm" ? undefined : runner.profile;
-    // 3. Build prompt.
+    // 2. Build terminal user content.
     // Synthesize a temp draft path so opencode can write the asset content
     // directly using its file tools rather than returning JSON via stdout.
     const draftFilePath = import("node:os").then((os) => import("node:path").then((path) => path.join(os.tmpdir(), `akm-propose-${options.type}-${options.name.replace(/[^a-z0-9_-]/gi, "_")}-${Date.now()}.md`)));
@@ -111,166 +153,144 @@ export async function akmPropose(options) {
         ...(standardsContext.trim() ? { standardsContext } : {}),
         draftFilePath: resolvedDraftPath,
     });
-    // 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.
-    // All kinds cross the unified RunnerSpec dispatch boundary.
-    const useCustomSpawn = Boolean(options.runAgentOptions?.spawn);
-    let result;
-    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) {
+    // 3. Preserve the fully-authored prompt as the terminal user content;
+    // no synthetic persona, conversation turn, schema, or tool selection is
+    // introduced while it crosses the shared resolved/lowered boundary.
+    const dispatch = await dispatchProposalPrompt(prompt, config, options, () => emitProposeInvoked(target.source, options));
+    const { result, engineName, notices, lease } = dispatch;
+    try {
+        if (!result.ok) {
+            // B3: ENOENT / not-found gives an actionable hint.
+            if (isEnoentFailure(result)) {
                 return {
-                    ok: false,
-                    exitCode: null,
-                    stdout: "",
-                    stderr: "",
-                    durationMs: Date.now() - started,
-                    error: String(error),
-                    reason: "spawn_failed",
+                    ...failureEnvelope(result, options.type, options.name, engineName, notices),
+                    error: enoentHintMessage(dispatch.engineBin ?? engineName),
                 };
             }
-        },
-    });
-    if (!result.ok) {
-        // B3: ENOENT / not-found gives an actionable hint.
-        if (isEnoentFailure(result)) {
-            return {
-                ...failureEnvelope(result, options.type, options.name, engineName),
-                error: enoentHintMessage(profile?.bin ?? engineName),
-            };
+            return failureEnvelope(result, options.type, options.name, engineName, notices);
         }
-        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).
-    // Path B: fallback to stdout JSON parse for non-file-writing agents.
-    let payload;
-    if (fs.existsSync(resolvedDraftPath)) {
-        const draftContent = fs.readFileSync(resolvedDraftPath, "utf8");
-        fs.unlinkSync(resolvedDraftPath);
-        payload = {
-            ref: proposeItemRef(target.source, options.type, options.name),
-            content: draftContent,
-        };
-    }
-    else {
-        // B1: When interactive mode was used and stdout is empty, the agent did not
-        // write the draft file and stdout was not captured — surface an actionable error.
-        const stdioWasInteractive = !useCustomSpawn;
-        if (stdioWasInteractive && (result.stdout ?? "") === "") {
-            return {
-                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 } : {}),
+        // 5. Resolve the proposal content.
+        // Path A: opencode wrote the draft file — read it directly (no stdout parse).
+        // Path B: fallback to stdout JSON parse for non-file-writing agents.
+        let payload;
+        if (fs.existsSync(resolvedDraftPath)) {
+            const draftContent = fs.readFileSync(resolvedDraftPath, "utf8");
+            fs.unlinkSync(resolvedDraftPath);
+            payload = {
+                ref: proposeItemRef(target.source, options.type, options.name),
+                content: draftContent,
             };
         }
-        try {
-            payload = parseAgentProposalPayload(result.stdout ?? "");
-        }
-        catch (err) {
-            return {
-                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.
-    const expectedRef = proposeItemRef(target.source, options.type, options.name);
-    let ref = expectedRef;
-    if (payload.ref) {
-        let parsedRef;
-        try {
-            parsedRef = parseRefInput(payload.ref);
+        else {
+            // B1: When interactive mode was used and stdout is empty, the agent did not
+            // write the draft file and stdout was not captured — surface an actionable error.
+            if (dispatch.interactive && (result.stdout ?? "") === "") {
+                return {
+                    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 } : {}),
+                    ...noticeFields(notices),
+                };
+            }
+            try {
+                payload = parseAgentProposalPayload(result.stdout ?? "");
+            }
+            catch (err) {
+                return {
+                    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 } : {}),
+                    ...noticeFields(notices),
+                };
+            }
         }
-        catch (err) {
-            return {
-                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: redactWithLoweredExecutionDispatchLease(lease, payload.content) };
+        // 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.
+        const expectedRef = proposeItemRef(target.source, options.type, options.name);
+        let ref = expectedRef;
+        if (payload.ref) {
+            let parsedRef;
+            try {
+                parsedRef = parseRefInput(payload.ref);
+            }
+            catch (err) {
+                return {
+                    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 } : {}),
+                    ...noticeFields(notices),
+                };
+            }
+            if (parsedRef.type !== options.type) {
+                return {
+                    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 } : {}),
+                    ...noticeFields(notices),
+                };
+            }
+            ref = proposeItemRef(target.source, parsedRef.type, parsedRef.name);
         }
-        if (parsedRef.type !== options.type) {
-            return {
-                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 } : {}),
-            };
+        const createInput = {
+            ref,
+            source: "propose",
+            sourceRun: `propose-${Date.now()}`,
+            target,
+            // User-initiated proposals always bypass dedup/cooldown guards — the
+            // operator is explicitly asking for a new proposal.
+            force: true,
+            payload: {
+                content: payload.content,
+                ...(payload.frontmatter ? { frontmatter: payload.frontmatter } : {}),
+            },
+        };
+        const proposalResult = createProposal(stash, createInput, options.ctx);
+        // With force:true, the result is always a Proposal (never skipped).
+        if (isProposalSkipped(proposalResult)) {
+            // Should never happen when force:true, but be defensive.
+            throw new Error(`Unexpected skip in propose command: ${proposalResult.message}`);
         }
-        ref = proposeItemRef(target.source, parsedRef.type, parsedRef.name);
+        const proposal = proposalResult;
+        return {
+            schemaVersion: 2,
+            ok: true,
+            proposal,
+            ref: proposal.ref,
+            engine: engineName,
+            durationMs: result.durationMs,
+            ...noticeFields(notices),
+        };
     }
-    const createInput = {
-        ref,
-        source: "propose",
-        sourceRun: `propose-${Date.now()}`,
-        target,
-        // User-initiated proposals always bypass dedup/cooldown guards — the
-        // operator is explicitly asking for a new proposal.
-        force: true,
-        payload: {
-            content: payload.content,
-            ...(payload.frontmatter ? { frontmatter: payload.frontmatter } : {}),
-        },
-    };
-    const proposalResult = createProposal(stash, createInput, options.ctx);
-    // With force:true, the result is always a Proposal (never skipped).
-    if (isProposalSkipped(proposalResult)) {
-        // Should never happen when force:true, but be defensive.
-        throw new Error(`Unexpected skip in propose command: ${proposalResult.message}`);
+    finally {
+        disposeLoweredExecutionDispatchLease(lease);
     }
-    const proposal = proposalResult;
-    return {
-        schemaVersion: 2,
-        ok: true,
-        proposal,
-        ref: proposal.ref,
-        engine: engineName,
-        durationMs: result.durationMs,
-    };
 }