akm-cli 0.9.0-beta.5 → 0.9.0-beta.51

package/dist/commands/lint/workflow-linter.js

@@ -2,6 +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/.
 import fs from "node:fs";
+import { parseWorkflow } from "../../workflows/parser.js";
 import { BaseLinter } from "./base-linter.js";
 const PLACEHOLDER_STRINGS = ["Describe what this workflow accomplishes", "Example Workflow"];
 /**
@@ -32,7 +33,7 @@ export class WorkflowLinter extends BaseLinter {
                         file: ctx.relPath,
                         issue: "placeholder-stub",
                         detail: `could not delete: ${e instanceof Error ? e.message : String(e)}`,
-                        fixed: false,
+                        fixed: "failed",
                     });
                 }
                 return issues;
@@ -44,6 +45,30 @@ export class WorkflowLinter extends BaseLinter {
                 fixed: false,
             });
         }
+        const isReadOnly = ctx.filePath.includes("/.cache/") || ctx.filePath.includes("/registry/");
+        if (!isReadOnly) {
+            try {
+                const result = parseWorkflow(ctx.raw, { path: ctx.filePath });
+                if (!result.ok) {
+                    for (const err of result.errors ?? []) {
+                        issues.push({
+                            file: ctx.relPath,
+                            issue: "invalid-workflow-structure",
+                            detail: err.message ?? String(err),
+                            fixed: false,
+                        });
+                    }
+                }
+            }
+            catch (e) {
+                issues.push({
+                    file: ctx.relPath,
+                    issue: "invalid-workflow-structure",
+                    detail: `workflow parser error: ${e instanceof Error ? e.message : String(e)}`,
+                    fixed: false,
+                });
+            }
+        }
         return issues;
     }
     #checkPlaceholderStub(body) {

package/dist/commands/proposal/drain-policies.js

@@ -45,6 +45,10 @@ export const PERSONAL_STASH = {
         { generator: "reflect", maxDiffLines: 80 },
         // Consolidate within the diff band; mid-band lands in `defer` below.
         { generator: "consolidate", maxDiffLines: 200 },
+        // Recombine: accept only confirmed type:lesson proposals (promoted by the
+        // recombine confidence gate) within the diff band. type:hypothesis proposals
+        // have no matching rule here and stay pending for manual review.
+        { generator: "recombine", requireType: "lesson", maxDiffLines: 200 },
     ],
     rejectEmpty: true,
     // Mid-band consolidate, distill duplicates, and contradiction escalations are
@@ -83,6 +87,7 @@ const DrainAcceptRuleSchema = z
     generator: GeneratorSchema,
     maxDiffLines: z.number().int().positive().optional(),
     minContentLines: z.number().int().nonnegative().optional(),
+    requireType: z.string().optional(),
 })
     .strict();
 const DrainPolicySchema = z

package/dist/commands/proposal/drain.js

@@ -9,7 +9,7 @@
  * the engine behind `akm proposal drain` and (later) the `triage` improve
  * pre-pass.
  *
- * Design (see docs/technical/proposal-triage-implementation-plan.md):
+ * Design (see docs/archive/proposal-triage-implementation-plan.md):
  *   - Reuses `listProposals` (no source filter — generator filtering is
  *     in-memory) and the `akmProposalAccept` / `akmProposalReject` wrappers from
  *     `proposal.ts` so the standard `promoted` / `rejected` events are emitted.
@@ -36,14 +36,12 @@
  */
 import fs from "node:fs";
 import path from "node:path";
-import { assertNever } from "../../core/assert.js";
 import { parseAssetRef } from "../../core/asset/asset-ref.js";
 import { resolveAssetPathFromName, TYPE_DIRS } from "../../core/asset/asset-spec.js";
 import { parseFrontmatter } from "../../core/asset/frontmatter.js";
 import { appendEvent } from "../../core/events.js";
 import { info, warn } from "../../core/warn.js";
-import { runAgent } from "../../integrations/agent/index.js";
-import { runOpencodeSdk } from "../../integrations/harnesses/opencode-sdk/index.js";
+import { executeRunner } from "../../integrations/agent/runner-dispatch.js";
 import { chatCompletion, stripJsonFences } from "../../llm/client.js";
 import { akmProposalAccept, akmProposalReject } from "./proposal.js";
 import { listProposals, recordGateDecision } from "./validators/proposals.js";
@@ -80,7 +78,16 @@ export function classifyProposal(proposal, policy, maxDiffLines) {
     if (policy.rejectEmpty && isEmptyDiff(proposal)) {
         return { verdict: "reject", reason: "empty diff", gate: { reason: "empty-diff" } };
     }
-    const rule = policy.accept.find((r) => r.generator === proposal.source);
+    const rule = policy.accept.find((r) => {
+        if (r.generator !== proposal.source)
+            return false;
+        if (r.requireType !== undefined) {
+            const fm = parseFrontmatter(proposal.payload.content ?? "").data;
+            if (typeof fm.type !== "string" || fm.type !== r.requireType)
+                return false;
+        }
+        return true;
+    });
     if (rule) {
         const lines = contentLineCount(content);
         const body = contentBodyLineCount(content);
@@ -200,59 +207,38 @@ export function parseJudgmentVerdict(raw) {
     return { decision, reason: typeof reason === "string" ? reason : "" };
 }
 /**
- * Dispatch a single judgment prompt to the resolved runner. The switch mirrors
- * the canonical consumer at `reflect.ts:1060-1090`: llm → `chatCompletion`
- * (no filesystem), agent → `runAgent`, sdk → `runOpencodeSdk`.
+ * Dispatch a single judgment prompt to the resolved runner via the unified
+ * {@link executeRunner} seam (X3). The `llm` arm is drain-specific (wraps
+ * `chatCompletion` — no filesystem) so it is supplied as the `llm` handler; the
+ * byte-identical `agent` / `sdk` arms route to the default profile runners (or
+ * the injected {@link JudgmentSeams} test fakes). A failed spawn warns and
+ * yields `null`, matching the prior per-arm behavior.
  */
 async function dispatchJudgment(runner, prompt, seams) {
-    let raw;
-    switch (runner.kind) {
-        case "llm": {
-            const messages = [{ role: "user", content: prompt }];
-            raw = seams.chat
-                ? await seams.chat(runner, messages)
-                : await chatCompletion(runner.connection, messages, {
-                    ...(runner.timeoutMs !== undefined ? { timeoutMs: runner.timeoutMs } : {}),
-                });
-            break;
-        }
-        case "agent": {
-            const stdout = await runProfileJudgment(seams.runAgentFn ?? runAgent, runner.profile, prompt, "agent", runner.timeoutMs);
-            if (stdout === null)
-                return null;
-            raw = stdout;
-            break;
-        }
-        case "sdk": {
-            const stdout = await runProfileJudgment(seams.runSdkFn ?? runOpencodeSdk, runner.profile, prompt, "sdk", runner.timeoutMs);
-            if (stdout === null)
-                return null;
-            raw = stdout;
-            break;
-        }
-        default:
-            // Exhaustiveness arm (H1): a 4th RunnerSpec kind becomes a compile error
-            // here instead of leaving `raw` undefined at runtime.
-            return assertNever(runner);
-    }
-    return parseJudgmentVerdict(raw);
-}
-/**
- * Shared spawn-runner dispatch for the byte-identical `agent` / `sdk` arms: run
- * the profile-based runner, log a labelled warning on failure, and return the
- * captured stdout (or `null` on failure). `label` only changes the warn prefix.
- */
-async function runProfileJudgment(run, profile, prompt, label, timeoutMs) {
-    const result = await run(profile, prompt, {
+    const runOptions = {
         stdio: "captured",
         parseOutput: "text",
-        ...(timeoutMs !== undefined ? { timeoutMs } : {}),
+        ...(runner.timeoutMs !== undefined ? { timeoutMs: runner.timeoutMs } : {}),
+    };
+    const result = await executeRunner(runner, prompt, runOptions, {
+        llm: async (spec, p) => {
+            const messages = [{ role: "user", content: p }];
+            const raw = seams.chat
+                ? await seams.chat(spec, messages)
+                : await chatCompletion(spec.connection, messages, {
+                    ...(spec.timeoutMs !== undefined ? { timeoutMs: spec.timeoutMs } : {}),
+                });
+            // chatCompletion has no failure envelope — a returned string is success.
+            return { ok: true, exitCode: 0, stdout: raw, stderr: "", durationMs: 0 };
+        },
+        ...(seams.runAgentFn ? { runAgent: seams.runAgentFn } : {}),
+        ...(seams.runSdkFn ? { runSdk: seams.runSdkFn } : {}),
     });
     if (!result.ok) {
-        warn(`[triage] judgment ${label} failed: ${result.error ?? result.reason ?? "unknown error"}`);
+        warn(`[triage] judgment ${runner.kind} failed: ${result.error ?? result.reason ?? "unknown error"}`);
         return null;
     }
-    return result.stdout;
+    return parseJudgmentVerdict(result.stdout);
 }
 /**
  * Run the judgment tier over the deferred items. The runner only *judges*; the
@@ -361,6 +347,13 @@ export async function drainProposals(opts, promoteFn = akmProposalAccept, reject
     // — these are re-stamped `no-judge-configured` when no runner resolves them.
     const needsJudge = new Set();
     for (const proposal of pending) {
+        // Do NOT reclassify a proposal that was already conclusively stamped
+        // `auto-rejected` by a prior gate run (e.g. the improve confidence gate).
+        // Overwriting an authoritative rejection with `auto-accepted` would corrupt
+        // the audit trail and silently promote content the gate explicitly rejected.
+        // Such proposals remain pending for manual review (or TTL expiry).
+        if (proposal.gateDecision?.outcome === "auto-rejected")
+            continue;
         const decision = classifyProposal(proposal, opts.policy, opts.maxDiffLines);
         if (decision === null)
             continue;

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

@@ -9,9 +9,8 @@
  * and emits the same JSON envelope (stdout/stderr/exit-code) as the inline
  * `runWithJsonErrors` form it replaces.
  */
-import { defineCommand } from "citty";
-import { hasSubcommand, parsePositiveIntFlag } from "../../cli/parse-args.js";
-import { defineJsonCommand, output, runWithJsonErrors } from "../../cli/shared.js";
+import { parsePositiveIntFlag } from "../../cli/parse-args.js";
+import { defineGroupCommand, defineJsonCommand, output } from "../../cli/shared.js";
 import { resolveStashDir } from "../../core/common.js";
 import { loadConfig } from "../../core/config/config.js";
 import { UsageError } from "../../core/errors.js";
@@ -448,19 +447,7 @@ const proposalDrainCommand = defineJsonCommand({
 // (`proposals`/`accept`/`reject`/`diff`/`revert`) remain as deprecated aliases
 // that warn to stderr and delegate to the same command bodies; they are removed
 // in 0.9.0. Bare `akm proposal` behaves as `proposal list` (mirrors `akm env`).
-// Single source of truth: the routing set is derived from the subCommands keys
-// (M10) so adding a subcommand can never silently desync from `hasSubcommand`.
-const proposalSubCommands = {
-    list: proposalListCommand,
-    show: proposalShowCommand,
-    diff: proposalDiffCommand,
-    accept: proposalAcceptCommand,
-    reject: proposalRejectCommand,
-    revert: proposalRevertCommand,
-    drain: proposalDrainCommand,
-};
-const PROPOSAL_SUBCOMMAND_SET = new Set(Object.keys(proposalSubCommands));
-export const proposalCommand = defineCommand({
+export const proposalCommand = defineGroupCommand({
     meta: { name: "proposal", description: "Manage the proposal queue: list, show, diff, accept, reject, revert" },
     args: {
         status: {
@@ -470,21 +457,24 @@ export const proposalCommand = defineCommand({
         ref: { type: "string", description: "Filter by asset ref (type:name)" },
         type: { type: "string", description: "Filter by asset type" },
     },
-    subCommands: proposalSubCommands,
-    run({ args }) {
-        return runWithJsonErrors(() => {
-            // citty runs the group body even after a subcommand; short-circuit so the
-            // default-to-list body only fires for bare `akm proposal [--status …]`.
-            if (hasSubcommand(args, PROPOSAL_SUBCOMMAND_SET))
-                return;
-            const status = parseProposalStatus(args.status);
-            const result = akmProposalList({
-                status,
-                ref: args.ref,
-                type: args.type,
-                includeArchive: status === "accepted" || status === "rejected" || status === "reverted",
-            });
-            output("proposal-list", result);
+    subCommands: {
+        list: proposalListCommand,
+        show: proposalShowCommand,
+        diff: proposalDiffCommand,
+        accept: proposalAcceptCommand,
+        reject: proposalRejectCommand,
+        revert: proposalRevertCommand,
+        drain: proposalDrainCommand,
+    },
+    // Default body fires only for bare `akm proposal [--status …]`.
+    defaultRun({ args }) {
+        const status = parseProposalStatus(args.status);
+        const result = akmProposalList({
+            status,
+            ref: args.ref,
+            type: args.type,
+            includeArchive: status === "accepted" || status === "rejected" || status === "reverted",
         });
+        output("proposal-list", result);
     },
 });

package/dist/commands/proposal/proposal.js

@@ -75,6 +75,11 @@ export async function akmProposalAccept(options) {
             source: result.proposal.source,
             ...(result.proposal.sourceRun !== undefined ? { sourceRun: result.proposal.sourceRun } : {}),
             assetPath: result.assetPath,
+            // Attribution tagging: carry the eligibility lane from the proposal record
+            // onto the promoted event so accept outcomes can be sliced by lane.
+            ...(result.proposal.eligibilitySource !== undefined
+                ? { eligibilitySource: result.proposal.eligibilitySource }
+                : {}),
         },
     });
     return {

package/dist/commands/proposal/propose.js

@@ -18,10 +18,11 @@ 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 { resolveStandardsContext } from "../../core/standards/resolve-standards-context.js";
 import { runAgent, } from "../../integrations/agent/index.js";
 import { resolveProcessAgentProfile } from "../../integrations/agent/config.js";
 import { buildProposePrompt, parseAgentProposalPayload } from "../../integrations/agent/prompts.js";
-import { runAgentSdk } from "../../integrations/harnesses/opencode-sdk/index.js";
+import { runOpencodeSdk } from "../../integrations/harnesses/opencode-sdk/index.js";
 import { baseFailureFields, enoentHintMessage, isEnoentFailure, loadAgentConfigFromDisk, resolveAgentProfile, } from "../agent/agent-support.js";
 import { createProposal, isProposalSkipped, } from "./validators/proposals.js";
 function failureEnvelope(result, type, name, fallbackReason = "non_zero_exit") {
@@ -93,10 +94,14 @@ export async function akmPropose(options) {
     // 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`)));
     const resolvedDraftPath = await draftFilePath;
+    // Standards "rulebook" for this target — wiki schema (wiki page) or stash
+    // convention/meta facts (non-wiki asset); empty when neither fires.
+    const standardsContext = resolveStandardsContext(`${options.type}:${options.name}`, stash);
     const prompt = buildProposePrompt({
         type: options.type,
         name: options.name,
         task: options.task,
+        ...(standardsContext.trim() ? { standardsContext } : {}),
         draftFilePath: resolvedDraftPath,
     });
     // 4. Spawn the agent.
@@ -123,7 +128,7 @@ export async function akmPropose(options) {
             ...(resolvedTimeoutMs !== undefined ? { timeoutMs: resolvedTimeoutMs } : {}),
         };
         result = profile.sdkMode
-            ? await runAgentSdk(profile, prompt ?? "", runOptions)
+            ? await runOpencodeSdk(profile, prompt ?? "", runOptions)
             : await runAgent(profile, prompt, runOptions);
     }
     if (!result.ok) {

package/dist/commands/proposal/validators/proposal-quality-validators.js

@@ -59,6 +59,7 @@
  */
 // ── Reflect-size guard ───────────────────────────────────────────────────────
 import { parseFrontmatter } from "../../../core/asset/frontmatter.js";
+import { DESCRIPTION_MAX_CHARS, DESCRIPTION_MIN_CHARS, WHEN_TO_USE_MAX_CHARS, WHEN_TO_USE_MIN_CHARS, } from "../../../core/authoring-rules.js";
 import { detectTruncatedDescription, TRUNCATION_TRAILING_WORDS } from "../../../core/text-truncation.js";
 // ── Description / when_to_use shape ─────────────────────────────────────────
 export const HEADING_FRAGMENT_PATTERNS = [
@@ -80,10 +81,10 @@ export function isValidDescription(value, inputRef, options = {}) {
     const v = value.trim();
     if (!v)
         return { ok: false, reason: "description is empty" };
-    if (v.length < 20)
-        return { ok: false, reason: `description is too short (${v.length} chars; need ≥20)` };
-    if (v.length > 400)
-        return { ok: false, reason: `description is too long (${v.length} chars; max 400)` };
+    if (v.length < DESCRIPTION_MIN_CHARS)
+        return { ok: false, reason: `description is too short (${v.length} chars; need ≥${DESCRIPTION_MIN_CHARS})` };
+    if (v.length > DESCRIPTION_MAX_CHARS)
+        return { ok: false, reason: `description is too long (${v.length} chars; max ${DESCRIPTION_MAX_CHARS})` };
     if (/^\s*[\d#*\->`]/.test(v))
         return { ok: false, reason: "description starts with a digit or markdown marker" };
     const last = v.slice(-1);
@@ -133,10 +134,10 @@ export function isValidWhenToUse(value, inputRef) {
     const v = value.trim();
     if (!v)
         return { ok: false, reason: "when_to_use is empty" };
-    if (v.length < 15)
-        return { ok: false, reason: `when_to_use is too short (${v.length} chars; need ≥15)` };
-    if (v.length > 400)
-        return { ok: false, reason: `when_to_use is too long (${v.length} chars; max 400)` };
+    if (v.length < WHEN_TO_USE_MIN_CHARS)
+        return { ok: false, reason: `when_to_use is too short (${v.length} chars; need ≥${WHEN_TO_USE_MIN_CHARS})` };
+    if (v.length > WHEN_TO_USE_MAX_CHARS)
+        return { ok: false, reason: `when_to_use is too long (${v.length} chars; max ${WHEN_TO_USE_MAX_CHARS})` };
     if (/^when working with\b/i.test(v))
         return { ok: false, reason: "when_to_use is the circular 'When working with ...' fallback" };
     const refTail = inputRef.split(":").pop()?.toLowerCase() ?? "";