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

package/dist/output/shapes/passthrough.js

@@ -21,6 +21,7 @@ function makeStampHandler(command) {
 const PASSTHROUGH_COMMANDS = [
     "add",
     "agent-result",
+    "backup",
     "clone",
     "config",
     "disable",
@@ -50,6 +51,7 @@ const PASSTHROUGH_COMMANDS = [
     "init",
     "lint",
     "list",
+    "mv",
     "proposal-accept-batch",
     "proposal-drain",
     "proposal-reject-batch",
@@ -87,15 +89,19 @@ const PASSTHROUGH_COMMANDS = [
     "wiki-show",
     "wiki-stash",
     "workflow-abandon",
+    "workflow-brief",
     "workflow-complete",
     "workflow-complete-rejected",
     "workflow-create",
     "workflow-list",
     "workflow-next",
+    "workflow-report",
     "workflow-resume",
+    "workflow-run",
     "workflow-start",
     "workflow-status",
     "workflow-validate",
+    "workflow-watch",
 ];
 export const passthroughShapes = PASSTHROUGH_COMMANDS.map((command) => ({
     command,

package/dist/output/text/helpers.js

@@ -194,7 +194,18 @@ export function formatWorkflowValidatePlain(r) {
         return `workflow validate: failed (${pathValue})`;
     const title = typeof r.title === "string" ? r.title : "";
     const stepCount = typeof r.stepCount === "number" ? r.stepCount : 0;
-    return `workflow validate: ok — ${title || pathValue} (${stepCount} step(s))`;
+    const lines = [`workflow validate: ok — ${title || pathValue} (${stepCount} step(s))`];
+    // Non-fatal advisories: clearly marked, printed after the ok line so `ok`
+    // is never in doubt. Absent/empty for markdown and fully-typed programs.
+    const warnings = Array.isArray(r.warnings) ? r.warnings : [];
+    if (warnings.length > 0) {
+        lines.push(`  ${warnings.length} warning(s):`);
+        for (const w of warnings) {
+            const line = typeof w.line === "number" ? w.line : "?";
+            lines.push(`    warning: ${pathValue}:${line} — ${String(w.message ?? "")}`);
+        }
+    }
+    return lines.join("\n");
 }
 /**
  * Plain-text rendering for a step-completion that was rejected by the
@@ -390,13 +401,15 @@ export function formatProposalDrainPlain(r) {
     const rejected = Array.isArray(r.rejected) ? r.rejected : [];
     const deferred = Array.isArray(r.deferred) ? r.deferred : [];
     const skippedByCap = Array.isArray(r.skippedByCap) ? r.skippedByCap : [];
+    const staged = Array.isArray(r.staged) ? r.staged : [];
     const prefix = r.dryRun === true ? "[dry-run] " : "";
     const lines = [
-        `${prefix}Drained proposal queue (policy=${policy}, applyMode=${applyMode})`,
+        `${prefix}Drained proposal queue (strategy=${String(r.strategy ?? "?")}, policy=${policy}, applyMode=${applyMode})`,
         `  promoted: ${promoted.length}`,
         `  rejected: ${rejected.length}`,
         `  deferred: ${deferred.length}`,
         `  skippedByCap: ${skippedByCap.length}`,
+        `  staged: ${staged.length}`,
     ];
     for (const d of deferred) {
         lines.push(`    - ${String(d.id ?? "?")} (${String(d.reason ?? "?")})`);
@@ -722,8 +735,59 @@ export function formatWorkflowStatusPlain(result) {
             }
         }
     }
+    // `workflow status --units` (#22): the honest per-unit diagnostic surface —
+    // failure_reason plus any journaled result/error text. Diagnostics only; the
+    // deterministic step evidence above is unaffected.
+    const units = Array.isArray(result.units) ? result.units : undefined;
+    if (units) {
+        lines.push("");
+        lines.push(units.length > 0 ? "units:" : "units: (none journaled)");
+        for (const unit of units) {
+            const id = typeof unit.unitId === "string" ? unit.unitId : "unknown";
+            const status = typeof unit.status === "string" ? unit.status : "unknown";
+            const node = typeof unit.nodeId === "string" ? unit.nodeId : "";
+            const attempts = typeof unit.attempts === "number" ? unit.attempts : undefined;
+            const suffix = attempts !== undefined && attempts > 1 ? `, attempt ${attempts}` : "";
+            lines.push(`  - ${id} [${node}] (${status}${suffix})`);
+            // Codex round-3 finding B: a `running` claim gone silent past the check-in
+            // window — the driver likely died. Surface it (with the claim holder) so a
+            // human can reclaim/re-run the unit, matching what `brief` reports.
+            if (unit.stale === true) {
+                const holder = typeof unit.claimHolder === "string" && unit.claimHolder.trim() ? ` claimed by ${unit.claimHolder}` : "";
+                lines.push(`    stale: claim went silent past the check-in window${holder} — its driver may have died`);
+            }
+            if (typeof unit.failureReason === "string" && unit.failureReason.trim()) {
+                lines.push(`    failure_reason: ${unit.failureReason}`);
+            }
+            if (typeof unit.diagnostic === "string" && unit.diagnostic.trim()) {
+                const diagLines = unit.diagnostic.split("\n");
+                lines.push(`    diagnostic: ${diagLines[0]}`);
+                for (const diagLine of diagLines.slice(1))
+                    lines.push(`      ${diagLine}`);
+            }
+        }
+    }
+    // Review C2: the check-in `continue` directive must survive plain-text
+    // rendering — JSON consumers saw `checkin` but the text path dropped it.
+    const checkinLine = formatWorkflowCheckinLine(result);
+    if (checkinLine) {
+        lines.push("");
+        lines.push(checkinLine);
+    }
     return lines.join("\n");
 }
+/**
+ * Render the stalled-run check-in directive (#506) when present on a
+ * workflow-next/status result. Returns null when the run is healthy.
+ */
+function formatWorkflowCheckinLine(result) {
+    const checkin = typeof result.checkin === "object" && result.checkin !== null
+        ? result.checkin
+        : undefined;
+    if (!checkin || typeof checkin.directive !== "string" || !checkin.directive.trim())
+        return null;
+    return checkin.directive.trim();
+}
 export function formatWorkflowNextPlain(result) {
     const base = formatWorkflowStatusPlain(result);
     const step = typeof result.step === "object" && result.step !== null ? result.step : undefined;
@@ -765,6 +829,155 @@ export function formatWorkflowNextPlain(result) {
     }
     return lines.join("\n");
 }
+export function formatWorkflowRunPlain(result) {
+    const run = typeof result.run === "object" && result.run !== null ? result.run : undefined;
+    if (!run)
+        return null;
+    const lines = [`run: ${String(run.id ?? "unknown")}`, `status: ${String(run.status ?? "unknown")}`];
+    const executed = Array.isArray(result.executed) ? result.executed : [];
+    if (executed.length === 0) {
+        lines.push("executed: (no steps — run was already done or blocked)");
+    }
+    else {
+        lines.push("executed:");
+        for (const step of executed) {
+            const marker = step.ok === true ? "ok" : "FAILED";
+            lines.push(`  - ${String(step.stepId ?? "?")} [${marker}] units: ${String(step.unitCount ?? 0)}` +
+                (Number(step.failedUnits ?? 0) > 0 ? ` (${String(step.failedUnits)} failed)` : ""));
+            if (typeof step.summary === "string" && step.summary.trim()) {
+                lines.push(`    ${step.summary}`);
+            }
+        }
+    }
+    const gate = typeof result.gateRejection === "object" && result.gateRejection !== null
+        ? result.gateRejection
+        : undefined;
+    if (gate) {
+        lines.push(`gate rejected step ${String(gate.stepId ?? "?")}: ${String(gate.feedback ?? "")}`);
+        const missing = Array.isArray(gate.missing) ? gate.missing : [];
+        for (const item of missing)
+            lines.push(`  missing: ${String(item)}`);
+    }
+    if (result.done === true)
+        lines.push("workflow completed.");
+    return lines.join("\n");
+}
+export function formatWorkflowBriefPlain(result) {
+    const run = typeof result.run === "object" && result.run !== null ? result.run : undefined;
+    if (!run)
+        return null;
+    const lines = [];
+    lines.push(`# Workflow brief: ${String(run.id ?? "unknown")}`);
+    lines.push(`workflow: ${String(run.workflowRef ?? "?")}  (${String(run.workflowTitle ?? "")})`);
+    lines.push(`status: ${String(run.status ?? "?")}`);
+    if (typeof result.message === "string")
+        lines.push(result.message);
+    const lease = typeof result.engineLease === "object" && result.engineLease !== null
+        ? result.engineLease
+        : undefined;
+    if (lease) {
+        const live = lease.live === true ? "LIVE" : "expired";
+        lines.push(`engine lease: ${String(lease.holder ?? "?")} (until ${String(lease.until ?? "?")}) [${live}]`);
+    }
+    const warnings = Array.isArray(result.warnings) ? result.warnings : [];
+    for (const w of warnings)
+        lines.push(`! ${String(w)}`);
+    if (result.done === true) {
+        lines.push("");
+        lines.push("This run is completed — no work remains.");
+        return lines.join("\n");
+    }
+    const step = typeof result.step === "object" && result.step !== null ? result.step : undefined;
+    if (!step) {
+        return lines.join("\n");
+    }
+    const gate = typeof step.gate === "object" && step.gate !== null ? step.gate : undefined;
+    lines.push("");
+    lines.push(`## Active step: ${String(step.stepId ?? "?")} — ${String(step.title ?? "")}  [${String(step.kind ?? "execute")}]`);
+    if (gate) {
+        const criteria = Array.isArray(gate.criteria) ? gate.criteria : [];
+        lines.push(`gate: loop ${String(gate.currentLoop ?? 1)} of max ${String(gate.maxLoops ?? 1)}` +
+            (criteria.length > 0 ? `; criteria: ${criteria.map(String).join("; ")}` : "; no completion criteria") +
+            (gate.judgesArtifact === true ? " (artifact-judged)" : ""));
+    }
+    if (step.outputSchema !== undefined)
+        lines.push("outputSchema: declared (see JSON output)");
+    const feedback = typeof result.gateFeedback === "object" && result.gateFeedback !== null
+        ? result.gateFeedback
+        : undefined;
+    if (feedback) {
+        lines.push(`gate feedback (previous loop rejected): ${String(feedback.feedback ?? "")}`);
+        const missing = Array.isArray(feedback.missing) ? feedback.missing : [];
+        for (const m of missing)
+            lines.push(`  - missing: ${String(m)}`);
+    }
+    const route = typeof result.route === "object" && result.route !== null ? result.route : undefined;
+    if (route) {
+        lines.push("");
+        lines.push(`## Route contract on ${String(route.input ?? "?")}`);
+        const when = typeof route.when === "object" && route.when !== null ? route.when : {};
+        for (const [value, target] of Object.entries(when))
+            lines.push(`  when "${value}" → ${String(target)}`);
+        if (route.defaultStepId !== undefined)
+            lines.push(`  default → ${String(route.defaultStepId)}`);
+        const decision = typeof route.decision === "object" && route.decision !== null
+            ? route.decision
+            : undefined;
+        if (decision)
+            lines.push(`  decision NOW: value "${String(decision.value)}" → ${String(decision.selected)}`);
+        else if (typeof route.decisionError === "string")
+            lines.push(`  decision error: ${route.decisionError}`);
+        else
+            lines.push("  decision: pending this step's output (evaluated after units complete)");
+    }
+    const workList = typeof result.workList === "object" && result.workList !== null
+        ? result.workList
+        : undefined;
+    const units = workList && Array.isArray(workList.units) ? workList.units : [];
+    if (workList?.error) {
+        lines.push("");
+        lines.push(`work-list error: ${String(workList.error)}`);
+    }
+    else if (units.length > 0) {
+        lines.push("");
+        lines.push(`## Units (${units.length})`);
+        for (const u of units) {
+            const model = u.model ? ` model=${String(u.model)}` : "";
+            const journaled = typeof u.journaled === "object" && u.journaled !== null ? u.journaled : undefined;
+            const jstatus = journaled ? ` [journaled: ${String(journaled.status)}]` : "";
+            lines.push(`- ${String(u.unitId)}  (runner=${String(u.runner)}${model})${jstatus}`);
+            const env = Array.isArray(u.env) ? u.env : [];
+            if (env.length > 0)
+                lines.push(`    env (names): ${env.map(String).join(", ")}`);
+            if (u.outputSchema !== undefined)
+                lines.push("    outputSchema: declared (see JSON output)");
+            const resolved = typeof u.resolved === "object" && u.resolved !== null ? u.resolved : undefined;
+            if (resolved && resolved.ok === false)
+                lines.push(`    RESOLUTION ERROR: ${String(resolved.error)}`);
+            if (typeof u.report === "string")
+                lines.push(`    report: ${u.report}`);
+        }
+    }
+    // Finding D: a non-dispatching step (route-only / empty / all-unresolvable)
+    // advances via the `--settle` verb, surfaced so a driver can advance the spine.
+    if (typeof result.settleCommand === "string") {
+        lines.push("");
+        lines.push("## Advance (no reportable units)");
+        lines.push(`settle: ${result.settleCommand}`);
+    }
+    const guidance = typeof result.reportGuidance === "object" && result.reportGuidance !== null
+        ? result.reportGuidance
+        : undefined;
+    if (guidance) {
+        lines.push("");
+        lines.push("## Reporting");
+        if (typeof guidance.checkin === "string")
+            lines.push(`heartbeat: ${guidance.checkin}`);
+        if (typeof guidance.failure === "string")
+            lines.push(`on failure: ${guidance.failure}`);
+    }
+    return lines.join("\n");
+}
 export function formatSearchPlain(r, detail) {
     const hits = r.hits ?? [];
     const registryHits = r.registryHits ?? [];

package/dist/output/text/workflow.js

@@ -2,7 +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/.
 // Output text formatters for all `akm workflow *` commands.
-import { formatWorkflowCompleteRejectedPlain, formatWorkflowCreatePlain, formatWorkflowListPlain, formatWorkflowNextPlain, formatWorkflowResumePlain, formatWorkflowStatusPlain, formatWorkflowValidatePlain, } from "./helpers.js";
+import { formatWorkflowBriefPlain, formatWorkflowCompleteRejectedPlain, formatWorkflowCreatePlain, formatWorkflowListPlain, formatWorkflowNextPlain, formatWorkflowResumePlain, formatWorkflowRunPlain, formatWorkflowStatusPlain, formatWorkflowValidatePlain, } from "./helpers.js";
 export const workflowFormatters = [
     { command: "workflow-start", handler: (r) => formatWorkflowStatusPlain(r) },
     { command: "workflow-status", handler: (r) => formatWorkflowStatusPlain(r) },
@@ -14,4 +14,6 @@ export const workflowFormatters = [
     { command: "workflow-validate", handler: (r) => formatWorkflowValidatePlain(r) },
     { command: "workflow-resume", handler: (r) => formatWorkflowResumePlain(r) },
     { command: "workflow-abandon", handler: (r) => formatWorkflowStatusPlain(r) },
+    { command: "workflow-run", handler: (r) => formatWorkflowRunPlain(r) },
+    { command: "workflow-brief", handler: (r) => formatWorkflowBriefPlain(r) },
 ];