akm-cli 0.8.0-rc1 → 0.8.0

package/dist/commands/proposal.js

@@ -1,3 +1,6 @@
+// This Source Code Form is subject to the terms of the Mozilla Public
+// 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 proposal {list,show,accept,reject,diff}` — review surface for the
  * proposal substrate (#225).
@@ -12,7 +15,7 @@ import { resolveStashDir } from "../core/common";
 import { loadConfig } from "../core/config";
 import { UsageError } from "../core/errors";
 import { appendEvent } from "../core/events";
-import { archiveProposal, createProposal, diffProposal, getProposal, listProposals, promoteProposal, resolveProposalId, validateProposal, } from "../core/proposals";
+import { archiveProposal, createProposal, diffProposal, getProposal, isProposalSkipped, listProposals, promoteProposal, resolveProposalId, revertProposal, validateProposal, } from "../core/proposals";
 // ── Shared helpers ──────────────────────────────────────────────────────────
 function resolveStash(stashDir) {
     if (stashDir)
@@ -21,13 +24,17 @@ function resolveStash(stashDir) {
 }
 export function akmProposalList(options = {}) {
     const stash = resolveStash(options.stashDir);
-    // `--status accepted|rejected` implies archive-inclusion since the live
-    // queue only ever contains pending entries.
-    const includeArchive = options.includeArchive === true || options.status === "accepted" || options.status === "rejected";
+    // `--status accepted|rejected|reverted` implies archive-inclusion since the
+    // live queue only ever contains pending entries.
+    const includeArchive = options.includeArchive === true ||
+        options.status === "accepted" ||
+        options.status === "rejected" ||
+        options.status === "reverted";
     const proposals = listProposals(stash, {
         includeArchive,
         status: options.status,
         ref: options.ref,
+        type: options.type,
     });
     return { schemaVersion: 1, totalCount: proposals.length, proposals };
 }
@@ -110,11 +117,58 @@ export function akmProposalDiff(options) {
 }
 export function akmProposalCreate(options) {
     const stash = resolveStash(options.stashDir);
-    const proposal = createProposal(stash, {
+    // Manual proposal creation (via `akm proposal create`) always bypasses
+    // dedup/cooldown guards — the operator is explicitly requesting a proposal.
+    const result = createProposal(stash, {
         ref: options.ref,
         source: options.source,
         ...(options.sourceRun !== undefined ? { sourceRun: options.sourceRun } : {}),
         payload: options.payload,
+        force: true,
     }, options.ctx);
-    return { schemaVersion: 1, ok: true, proposal };
+    if (isProposalSkipped(result)) {
+        // Should never happen with force:true — defensive only.
+        throw new Error(`Unexpected proposal skip: ${result.message}`);
+    }
+    return { schemaVersion: 1, ok: true, proposal: result };
+}
+/**
+ * Restore an accepted proposal's prior content from the backup captured at
+ * promotion time (Advantage D6c / Phase 6C).
+ *
+ * Failure modes (all surface as typed errors so the CLI can map exit codes):
+ *   - Proposal id does not resolve → `NotFoundError("FILE_NOT_FOUND")`
+ *     (raised by `resolveProposalId` / `getProposal`).
+ *   - Proposal is not `status === "accepted"` → `UsageError("INVALID_FLAG_VALUE")`
+ *     with message `"only accepted proposals can be reverted ..."`.
+ *   - No `backup` field, or the backup file is missing on disk →
+ *     `UsageError` with message `"no backup available for this proposal ..."`.
+ *
+ * On success, emits a `proposal_reverted` event for observability, mirroring
+ * how `akmProposalAccept` emits `promoted` and `akmProposalReject` emits
+ * `rejected`.
+ */
+export async function akmProposalRevert(options) {
+    const stash = resolveStash(options.stashDir);
+    const config = options.config ?? loadConfig();
+    const resolvedId = resolveProposalId(stash, options.id).id;
+    const result = await revertProposal(stash, config, resolvedId, { target: options.target }, options.ctx);
+    appendEvent({
+        eventType: "proposal_reverted",
+        ref: result.ref,
+        metadata: {
+            proposalId: result.proposal.id,
+            source: result.proposal.source,
+            ...(result.proposal.sourceRun !== undefined ? { sourceRun: result.proposal.sourceRun } : {}),
+            assetPath: result.assetPath,
+        },
+    });
+    return {
+        schemaVersion: 1,
+        ok: true,
+        id: result.proposal.id,
+        ref: result.ref,
+        assetPath: result.assetPath,
+        proposal: result.proposal,
+    };
 }

package/dist/commands/propose.js

@@ -1,3 +1,6 @@
+// This Source Code Form is subject to the terms of the Mozilla Public
+// 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 propose <type> <name> --task ...` — proposal-producing agent
  * command (#226).
@@ -9,16 +12,17 @@
  * Failures use the same {@link AgentFailureReason} discriminants as
  * `akm reflect`. `propose_invoked` is emitted at command entry.
  */
+import fs from "node:fs";
 import { parseAssetRef } from "../core/asset-ref";
 import { TYPE_DIRS } from "../core/asset-spec";
 import { resolveStashDir } from "../core/common";
 import { ConfigError, UsageError } from "../core/errors";
 import { appendEvent } from "../core/events";
-import { createProposal } from "../core/proposals";
+import { createProposal, isProposalSkipped, } from "../core/proposals";
 import { runAgent, } from "../integrations/agent";
 import { resolveProcessAgentProfile } from "../integrations/agent/config";
-import { runProposalAgentPipeline } from "../integrations/agent/pipeline";
 import { buildProposePrompt, parseAgentProposalPayload } from "../integrations/agent/prompts";
+import { runAgentSdk } from "../integrations/agent/sdk-runner";
 import { baseFailureFields, enoentHintMessage, isEnoentFailure, loadAgentConfigFromDisk, resolveAgentProfile, } from "./agent-support";
 function failureEnvelope(result, type, name, fallbackReason = "non_zero_exit") {
     return {
@@ -112,22 +116,15 @@ export async function akmPropose(options) {
         result = await runAgent(profile, prompt, runOptions);
     }
     else {
-        // Production path: route through runProposalAgentPipeline (shared logic).
-        const pipelineResult = await runProposalAgentPipeline({
-            profile,
-            prompt,
-            draftFilePath: resolvedDraftPath,
-            timeoutMs: resolvedTimeoutMs,
-        });
-        result = {
-            ok: pipelineResult.ok,
-            exitCode: pipelineResult.exitCode,
-            stdout: pipelineResult.stdout,
-            stderr: pipelineResult.stderr,
-            durationMs: pipelineResult.durationMs,
-            error: pipelineResult.error,
-            reason: pipelineResult.reason,
+        // Production path: dispatch directly to the appropriate runner.
+        const runOptions = {
+            stdio: resolvedDraftPath ? "interactive" : "captured",
+            parseOutput: "text",
+            ...(resolvedTimeoutMs !== undefined ? { timeoutMs: resolvedTimeoutMs } : {}),
         };
+        result = profile.sdkMode
+            ? await runAgentSdk(profile, prompt ?? "", runOptions)
+            : await runAgent(profile, prompt, runOptions);
     }
     if (!result.ok) {
         // B3: ENOENT / not-found gives an actionable hint.
@@ -139,7 +136,6 @@ export async function akmPropose(options) {
     // 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.
-    const fs = await import("node:fs");
     let payload;
     if (fs.existsSync(resolvedDraftPath)) {
         const draftContent = fs.readFileSync(resolvedDraftPath, "utf8");
@@ -224,12 +220,21 @@ export async function akmPropose(options) {
         ref,
         source: "propose",
         sourceRun: `propose-${Date.now()}`,
+        // 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 proposal = createProposal(stash, createInput, options.ctx);
+    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}`);
+    }
+    const proposal = proposalResult;
     return {
         schemaVersion: 1,
         ok: true,