akm-cli 0.9.16 → 0.9.17-alpha.10

package/dist/commands/proposal/propose.js

@@ -19,15 +19,16 @@ import { resolveStashDir } from "../../core/common.js";
 import { generatedContentRejection } from "../../core/content-safety.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 } 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 { buildExecution, resolveExecution } from "../../integrations/agent/execution.js";
 import { buildProposePrompt, parseAgentProposalPayload } from "../../integrations/agent/prompts.js";
+import { assertRunnerCredentials, collectDispatchSensitiveValues, runExecution, } from "../../integrations/agent/runner-dispatch.js";
 import { baseFailureFields, enoentHintMessage, isEnoentFailure } from "../agent/agent-support.js";
-import { createProposal, isProposalSkipped, resolveProposalQueueTarget, } from "./repository.js";
+import { createProposal, resolveProposalQueueTarget, } from "./repository.js";
 function failureEnvelope(result, type, name, engine, notices, fallbackReason = "non_zero_exit") {
     return {
         ...baseFailureFields(result, fallbackReason),
@@ -41,56 +42,43 @@ function failureEnvelope(result, type, name, engine, notices, fallbackReason = "
 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({
+    const prepared = resolveExecution({
         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 lowered = buildExecution(prepared.request, prepared.runner);
     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;
-    }
+    // 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.
+    assertRunnerCredentials(lowered.runner, runOptions.envSource);
+    onDispatchReady();
+    options.onDispatchReady?.();
+    const result = await runExecution(lowered, { runOptions });
+    return {
+        result,
+        engineName,
+        ...(lowered.runner.kind === "llm" ? {} : { engineBin: lowered.runner.profile.bin }),
+        notices: lowered.notices,
+        sensitiveValues: collectDispatchSensitiveValues(lowered.runner, {}, runOptions.envSource),
+        interactive,
+    };
 }
 /**
  * WI-8.5a — the fully-qualified `bundle//conceptId` item_ref for a proposal
@@ -158,153 +146,139 @@ export async function akmPropose(options) {
     // 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 {
-                    ...failureEnvelope(result, options.type, options.name, engineName, notices),
-                    error: enoentHintMessage(dispatch.engineBin ?? engineName),
-                };
-            }
-            return failureEnvelope(result, options.type, options.name, engineName, notices);
-        }
-        // 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,
+    const { result, engineName, notices, sensitiveValues } = dispatch;
+    if (!result.ok) {
+        // B3: ENOENT / not-found gives an actionable hint.
+        if (isEnoentFailure(result)) {
+            return {
+                ...failureEnvelope(result, options.type, options.name, engineName, notices),
+                error: enoentHintMessage(dispatch.engineBin ?? engineName),
             };
         }
-        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),
-                };
-            }
-        }
-        const unsafeContent = generatedContentRejection(payload.content, redactWithLoweredExecutionDispatchLease(lease, payload.content));
-        if (unsafeContent) {
+        return failureEnvelope(result, options.type, options.name, engineName, notices);
+    }
+    // 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.
+        if (dispatch.interactive && (result.stdout ?? "") === "") {
             return {
                 schemaVersion: 2,
                 ok: false,
                 reason: "parse_error",
-                error: unsafeContent,
+                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),
             };
         }
-        // 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);
+        try {
+            payload = parseAgentProposalPayload(result.stdout ?? "");
         }
-        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}`);
+        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),
+            };
         }
-        const proposal = proposalResult;
+    }
+    const unsafeContent = generatedContentRejection(payload.content, redactSensitiveText(payload.content, sensitiveValues));
+    if (unsafeContent) {
         return {
             schemaVersion: 2,
-            ok: true,
-            proposal,
-            ref: proposal.ref,
+            ok: false,
+            reason: "parse_error",
+            error: unsafeContent,
+            type: options.type,
+            name: options.name,
             engine: engineName,
-            durationMs: result.durationMs,
+            exitCode: result.exitCode,
             ...noticeFields(notices),
         };
     }
-    finally {
-        disposeLoweredExecutionDispatchLease(lease);
+    // 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);
     }
+    const createInput = {
+        ref,
+        source: "propose",
+        sourceRun: `propose-${Date.now()}`,
+        target,
+        payload: {
+            content: payload.content,
+            ...(payload.frontmatter ? { frontmatter: payload.frontmatter } : {}),
+        },
+    };
+    const proposal = createProposal(stash, createInput, options.ctx);
+    return {
+        schemaVersion: 2,
+        ok: true,
+        proposal,
+        ref: proposal.ref,
+        engine: engineName,
+        durationMs: result.durationMs,
+        ...noticeFields(notices),
+    };
 }