open-multi-agent-kit 0.78.0 → 0.78.2

package/dist/cli/release-promotion-gate.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Phase 5 — Release Promotion Gate (Algorithm 8)
+ *
+ * Computes a release viability score R_v from ten normalized input
+ * dimensions and derives a verdict: block, pre-release, or stable.
+ */
+import { type ReleasePromotionInputs, type ReleasePromotionResult } from "../runtime/contracts/weakness-remediation.js";
+/** Gate engine contract. */
+export interface ReleasePromotionGate {
+    /** Evaluate inputs and return scored result with verdict. */
+    evaluate(inputs: ReleasePromotionInputs): ReleasePromotionResult;
+}
+/** Factory that creates the default release promotion gate. */
+export declare function createReleasePromotionGate(): ReleasePromotionGate;

package/dist/cli/release-promotion-gate.js

@@ -0,0 +1,71 @@
+/**
+ * Phase 5 — Release Promotion Gate (Algorithm 8)
+ *
+ * Computes a release viability score R_v from ten normalized input
+ * dimensions and derives a verdict: block, pre-release, or stable.
+ */
+import { RELEASE_GATE_WEIGHTS, } from "../runtime/contracts/weakness-remediation.js";
+/** Factory that creates the default release promotion gate. */
+export function createReleasePromotionGate() {
+    return {
+        evaluate(inputs) {
+            const w = RELEASE_GATE_WEIGHTS;
+            const demoRun = inputs.demoRun ?? false;
+            const maturity = inputs.maturity ?? inputs.providerMinimum ?? 0;
+            const rawScore = w.ci * inputs.ci +
+                w.build * (inputs.build ?? 0) +
+                w.types * (inputs.types ?? 0) +
+                w.tests * (inputs.tests ?? 0) +
+                w.install * inputs.freshInstallSmoke +
+                w.demo * (demoRun ? 1 : 0) +
+                w.proof * inputs.proofMedian +
+                w.maturity * maturity +
+                w.docs * inputs.docs -
+                w.regression * inputs.regressionSeverity;
+            const score = clamp01(rawScore);
+            const reasons = [];
+            const blocked = inputs.ci === 0 || inputs.freshInstallSmoke === 0 || !demoRun;
+            if (blocked) {
+                if (inputs.ci === 0) {
+                    reasons.push("CI score is 0 (blocking)");
+                }
+                if (inputs.freshInstallSmoke === 0) {
+                    reasons.push("Fresh install smoke is 0 (blocking)");
+                }
+                if (!demoRun) {
+                    reasons.push("Minimal verified demo run failed or missing (blocking)");
+                }
+            }
+            let verdict;
+            if (blocked) {
+                verdict = "block";
+            }
+            else if (score >= 0.90 && inputs.proofMedian >= 0.85 && maturity >= 0.80) {
+                verdict = "stable";
+                reasons.push(`Score ${formatScore(score)} meets stable threshold (≥0.90) with proof≥0.85 and maturity≥0.80`);
+            }
+            else if (score >= 0.75 && inputs.proofMedian >= 0.75) {
+                verdict = "pre-release";
+                reasons.push(`Score ${formatScore(score)} meets pre-release threshold (≥0.75) with proof≥0.75`);
+            }
+            else {
+                verdict = "block";
+                reasons.push(`Score ${formatScore(score)} below pre-release threshold (≥0.75) or proof below 0.75`);
+            }
+            return {
+                score,
+                verdict,
+                blocked,
+                reasons,
+            };
+        },
+    };
+}
+function clamp01(n) {
+    if (Number.isNaN(n))
+        return 0;
+    return Math.max(0, Math.min(1, n));
+}
+function formatScore(n) {
+    return n.toFixed(4);
+}

package/dist/cli/v2/release-commands.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Section 21 — CLI v2 Release Commands (Clipanion)
+ *
+ * `omk release check`  — Evaluate release promotion gate
+ * `omk release promote` — Promote release if gate passes (stub)
+ */
+import { Command, type Cli } from "clipanion";
+type ClipanionRegistrar = Pick<Cli, "register">;
+export declare class ReleaseCheckCommand extends Command {
+    static paths: string[][];
+    static usage: import("clipanion").Usage;
+    ci: string;
+    schema: string;
+    docs: string;
+    proof: string;
+    provider: string;
+    regression: string;
+    install: string;
+    semver: string;
+    json: boolean;
+    execute(): Promise<number>;
+}
+export declare class ReleasePromoteCommand extends Command {
+    static paths: string[][];
+    static usage: import("clipanion").Usage;
+    execute(): Promise<number>;
+}
+export declare function registerReleaseCommandsV2(cli: ClipanionRegistrar): void;
+export {};

package/dist/cli/v2/release-commands.js

@@ -0,0 +1,95 @@
+/**
+ * Section 21 — CLI v2 Release Commands (Clipanion)
+ *
+ * `omk release check`  — Evaluate release promotion gate
+ * `omk release promote` — Promote release if gate passes (stub)
+ */
+import { Command, Option } from "clipanion";
+import { createReleasePromotionGate } from "../release-promotion-gate.js";
+// ──────────────────────────────────────────────
+// Release Check
+// ──────────────────────────────────────────────
+export class ReleaseCheckCommand extends Command {
+    static paths = [["release", "check"]];
+    static usage = Command.Usage({
+        description: "Evaluate release promotion gate",
+        examples: [["Check release readiness", "omk release check"]],
+    });
+    ci = Option.String("--ci", "1", { description: "CI score (0–1)" });
+    schema = Option.String("--schema", "1", { description: "Schema score (0–1)" });
+    docs = Option.String("--docs", "1", { description: "Docs score (0–1)" });
+    proof = Option.String("--proof", "1", { description: "Proof median (0–1)" });
+    provider = Option.String("--provider", "1", { description: "Provider minimum (0–1)" });
+    regression = Option.String("--regression", "0", { description: "Regression severity (0–1)" });
+    install = Option.String("--install", "1", { description: "Fresh install smoke (0–1)" });
+    semver = Option.String("--semver", "1", { description: "Semver score (0–1)" });
+    json = Option.Boolean("--json", false, { description: "JSON output" });
+    async execute() {
+        const gate = createReleasePromotionGate();
+        const inputs = {
+            ci: Number.parseFloat(this.ci),
+            schema: Number.parseFloat(this.schema),
+            docs: Number.parseFloat(this.docs),
+            proofMedian: Number.parseFloat(this.proof),
+            providerMinimum: Number.parseFloat(this.provider),
+            regressionSeverity: Number.parseFloat(this.regression),
+            freshInstallSmoke: Number.parseFloat(this.install),
+            semver: Number.parseFloat(this.semver),
+        };
+        const result = gate.evaluate(inputs);
+        if (this.json) {
+            this.context.stdout.write(JSON.stringify(result, null, 2) + "\n");
+        }
+        else {
+            this.context.stdout.write("Release Promotion Gate\n");
+            this.context.stdout.write(`Score:   ${result.score.toFixed(4)}\n`);
+            this.context.stdout.write(`Verdict: ${result.verdict}\n`);
+            this.context.stdout.write(`Blocked: ${result.blocked}\n`);
+            if (result.reasons.length > 0) {
+                this.context.stdout.write("Reasons:\n");
+                for (const reason of result.reasons) {
+                    this.context.stdout.write(`  - ${reason}\n`);
+                }
+            }
+        }
+        return result.verdict === "block" ? 1 : 0;
+    }
+}
+// ──────────────────────────────────────────────
+// Release Promote
+// ──────────────────────────────────────────────
+export class ReleasePromoteCommand extends Command {
+    static paths = [["release", "promote"]];
+    static usage = Command.Usage({
+        description: "Promote release if gate passes",
+        examples: [["Promote release", "omk release promote"]],
+    });
+    async execute() {
+        const gate = createReleasePromotionGate();
+        const inputs = {
+            ci: Number.parseFloat(process.env.OMK_RELEASE_CI ?? "1"),
+            schema: Number.parseFloat(process.env.OMK_RELEASE_SCHEMA ?? "1"),
+            docs: Number.parseFloat(process.env.OMK_RELEASE_DOCS ?? "1"),
+            proofMedian: Number.parseFloat(process.env.OMK_RELEASE_PROOF ?? "1"),
+            providerMinimum: Number.parseFloat(process.env.OMK_RELEASE_PROVIDER ?? "1"),
+            regressionSeverity: Number.parseFloat(process.env.OMK_RELEASE_REGRESSION ?? "0"),
+            freshInstallSmoke: Number.parseFloat(process.env.OMK_RELEASE_INSTALL ?? "1"),
+            semver: Number.parseFloat(process.env.OMK_RELEASE_SEMVER ?? "1"),
+        };
+        const result = gate.evaluate(inputs);
+        this.context.stdout.write(JSON.stringify(result, null, 2) + "\n");
+        if (result.verdict === "block") {
+            this.context.stderr.write("Release promotion blocked.\n");
+            return 1;
+        }
+        this.context.stdout.write("Release promotion approved.\n");
+        return 0;
+    }
+}
+// ──────────────────────────────────────────────
+// Registration
+// ──────────────────────────────────────────────
+export function registerReleaseCommandsV2(cli) {
+    cli.register(ReleaseCheckCommand);
+    cli.register(ReleasePromoteCommand);
+}

package/dist/commands/chat/core.js

@@ -245,6 +245,11 @@ export async function chatCommand(options) {
         catch {
             // Update prompts are advisory and must not block chat startup.
         }
+        // NOTE: the star/update prompts above use @inquirer/prompts (raw mode + their
+        // own readline) and can leave interactive stdin paused. The native root loop
+        // re-validates and resumes a paused TTY via resumeInteractiveInput() right
+        // before it builds its readline (see runNativeOmkRootLoop), so the first run
+        // after `omk init` does not exit immediately with "Session ended".
     }
     // ── tmux cockpit layout: keep prompt pane clean; move cockpit/HUD telemetry to the side pane ──
     const explicitTmux = layout === "tmux";

package/dist/commands/chat/native-root-loop.js

@@ -2,6 +2,9 @@ import { style } from "../../util/theme.js";
 import { runShell } from "../../util/shell.js";
 import { createDag } from "../../orchestration/dag.js";
 import { applyCapabilityInjectionToRouting, buildCapabilityInjection, } from "../../runtime/capability-injection.js";
+import { capabilityScopesFromRouting } from "../../orchestration/capability-routing.js";
+import { decideToolAuthority, } from "../../safety/tool-authority-gate.js";
+import { resolveToolAuthorityEnforcement } from "../../runtime/tool-dispatch-contracts.js";
 import { compileBloatToNlp, } from "../../runtime/debloat-nlp.js";
 import { buildPromptEnvelope, renderPromptEnvelope, } from "../../runtime/prompt-envelope.js";
 import { buildTaskRunContext } from "../../runtime/worker-manifest.js";
@@ -10,6 +13,7 @@ import { persistInputEnvelope } from "../../input/input-artifacts.js";
 import { buildDagCompileResult } from "../../orchestration/dag-compiler.js";
 import { persistDagCompileArtifacts } from "../../orchestration/dag-artifacts.js";
 import { TerminalOwner } from "../../util/terminal-owner.js";
+import { resumeInteractiveInput } from "../../util/terminal-input.js";
 import { executeHarnessRun } from "../../harness/execute-harness-run.js";
 import { normalizeProviderId, readProviderRegistry } from "../../providers/model-registry.js";
 import { renderProviderModelTable } from "../../providers/model-table.js";
@@ -192,6 +196,53 @@ function bootstrapProviderPolicy(bootstrap) {
             return "auto";
     }
 }
+function nativeTurnRiskToToolOp(risk) {
+    switch (risk) {
+        case "merge":
+            return "merge";
+        case "shell":
+            return "shell";
+        case "write":
+            return "write";
+        default:
+            return "read";
+    }
+}
+/**
+ * Shadow-only tool-authority observability at the live turn dispatch
+ * checkpoint. The kimi runner executes tools inside a spawned CLI, so per-tool
+ * enforcement lives in dispatchToolCallsByContract; here we only compute and
+ * record the turn-level verdict for the trace. Default output is byte-identical
+ * (emitted only under OMK_DEBUG / OMK_TOOL_AUTHORITY_TRACE); this path never
+ * blocks dispatch.
+ */
+function recordNativeTurnToolAuthority(input) {
+    const traceEnabled = input.env.OMK_DEBUG === "1" ||
+        /^(1|true|yes|on)$/i.test(input.env.OMK_TOOL_AUTHORITY_TRACE ?? "");
+    if (!traceEnabled)
+        return;
+    const routing = input.node.routing;
+    const scopes = capabilityScopesFromRouting(routing);
+    const op = nativeTurnRiskToToolOp(routing?.risk);
+    const enforce = resolveToolAuthorityEnforcement(input.env);
+    const decision = decideToolAuthority({
+        op,
+        writeAuthority: scopes.writeAuthority,
+        shellAuthority: scopes.shellAuthority,
+        approvalPolicy: nativeApprovalPolicy(routing?.approvalPolicy ?? routing?.executionPrompt),
+        sandboxMode: routing?.sandboxMode === "read-only" ? "read-only" : "workspace-write",
+        tty: Boolean(process.stdout.isTTY),
+    });
+    const line = `  tool-authority(${enforce ? "enforce" : "shadow"}): node=${input.node.id} ` +
+        `op=${op} decision=${decision} write=${scopes.writeAuthority} ` +
+        `shell=${scopes.shellAuthority} sandbox=${routing?.sandboxMode ?? "auto"}\n`;
+    if (input.renderer) {
+        input.renderer.emit({ type: "control:output", text: style.phosphorDim(line) });
+    }
+    else {
+        process.stderr.write(style.phosphorDim(line));
+    }
+}
 function emitNativeTurnRoute(input) {
     if (!input.heartbeatEnabled)
         return;
@@ -463,6 +514,7 @@ async function executeNativeRootTurn(input) {
     const routing = input.node.routing;
     const activity = describeNativeTurnActivity(input.node);
     emitNativeTurnRoute(input);
+    recordNativeTurnToolAuthority({ node: input.node, env: input.env, renderer: input.renderer });
     let heartbeatPrinted = false;
     let heartbeatLineClosed = false;
     const heartbeat = input.heartbeatEnabled
@@ -598,6 +650,7 @@ async function executeNativeRootHarnessTurn(input) {
                 skillNames: node.routing?.skills ?? input.skillNames,
                 hookNames: node.routing?.hooks ?? input.hookNames,
             });
+            recordNativeTurnToolAuthority({ node, env: input.env, renderer: input.renderer });
         },
         onNodeComplete: (node, result) => {
             completed.push({ node, result });
@@ -666,6 +719,13 @@ export async function runNativeOmkRootLoop(input) {
         else
             process.stdout.write(`${text}\n`);
     };
+    // Defensive stdin re-validation before the chat readline takes ownership.
+    // The first-run GitHub-star / update prompts (@inquirer/prompts) can take
+    // over raw mode and leave the shared interactive stdin paused; a paused TTY
+    // makes the readline below see an immediate EOF/'close' and exit the loop
+    // with "Session ended". This only resumes an explicitly-paused TTY and never
+    // touches non-TTY stdin (its EOF/exit behavior must stay unchanged).
+    resumeInteractiveInput(process.stdin);
     const { createInterface } = await import("readline");
     const rl = createInterface({
         input: process.stdin,
@@ -731,6 +791,7 @@ export async function runNativeOmkRootLoop(input) {
     let running = true;
     let readlineClosed = false;
     let activeTurnAbort;
+    let pendingPastedImageLine;
     const queuedLines = [];
     let pendingLineResolve;
     const resolveNextLine = (value) => {
@@ -786,7 +847,7 @@ export async function runNativeOmkRootLoop(input) {
         const userInput = await readPromptLine();
         if (userInput === undefined)
             break;
-        const line = userInput.trim();
+        let line = userInput.trim();
         if (!line)
             continue;
         renderer?.emit({ type: "input:submitted", text: line });
@@ -795,6 +856,10 @@ export async function runNativeOmkRootLoop(input) {
             break;
         }
         const parsedSlash = parseSlashInput(line);
+        if (!parsedSlash && pendingPastedImageLine) {
+            line = `${pendingPastedImageLine}\n${line}`;
+            pendingPastedImageLine = undefined;
+        }
         const inputEnvelope = buildNativeInputEnvelope({
             loopInput: input,
             state,
@@ -836,6 +901,14 @@ export async function runNativeOmkRootLoop(input) {
                 try {
                     await terminalOwner.withChildProcess(rl, async () => {
                         const result = await runSlashHandler(handler, parsedSlash, slashContext);
+                        if (parsedSlash.command === "/paste" && result.ok) {
+                            const pasteLine = result.text?.trim();
+                            if (pasteLine) {
+                                pendingPastedImageLine = pendingPastedImageLine
+                                    ? `${pendingPastedImageLine}\n${pasteLine}`
+                                    : pasteLine;
+                            }
+                        }
                         if (result.exit)
                             running = false;
                     });

package/dist/commands/chat/slash/commands/session.js

@@ -1,7 +1,7 @@
 import { style } from "../../../../util/theme.js";
 import { readTodos } from "../../../../util/todo-sync.js";
 import { commandLine, formatScopedNames, section } from "../format.js";
-import { okSlashResult } from "../result.js";
+import { errorSlashResult, okSlashResult } from "../result.js";
 export function buildSessionSlashCommands() {
     return [
         {
@@ -22,6 +22,23 @@ export function buildSessionSlashCommands() {
             examples: ["/help"],
             handler: () => okSlashResult({ text: renderSlashHelp() }),
         },
+        {
+            name: "/paste",
+            aliases: [],
+            group: "session",
+            summary: "Paste image from clipboard",
+            usage: "/paste",
+            examples: ["/paste"],
+            handler: async (ctx) => {
+                const { pasteClipboardImage } = await import("../../../../util/clipboard-image.js");
+                const result = pasteClipboardImage(ctx.input.root);
+                if (!result.ok)
+                    return errorSlashResult(result.error ?? "No image in clipboard");
+                if (!result.relativePath)
+                    return errorSlashResult("Clipboard image saved without a relative path");
+                return okSlashResult({ text: `Image file: ${result.relativePath}` });
+            },
+        },
         {
             name: "/status",
             aliases: ["/s"],
@@ -76,6 +93,7 @@ function renderSlashHelp() {
         commandLine("/theme", "<system24|green-rain|neon-grid|rust-forge|plain|high-contrast>", "Set session theme"),
         commandLine("/view", "<summary|graph|evidence|tool-plane|events>", "Set control-plane view"),
         commandLine("/animation", "<off|low|auto|full>", "Set animation policy"),
+        commandLine("/paste", "", "Paste image from clipboard"),
         commandLine("/status", "", "Session status"),
         commandLine("/clear", "/cls", "Clear screen"),
         commandLine("/runs", "", "Recent run history"),

package/dist/commands/dag-from-spec.d.ts

@@ -27,4 +27,5 @@ export declare function dagFromSpecCommand(specDir: string, options?: {
     parallel?: boolean;
     runId?: string;
     run?: string;
+    json?: boolean;
 }): Promise<Dag>;

package/dist/commands/dag-from-spec.js

@@ -3,7 +3,9 @@ import { join } from "path";
 import { writeFile, mkdir } from "fs/promises";
 import { getProjectRoot, pathExists, getRunPath, getRunsDir } from "../util/fs.js";
 import { header, label } from "../util/theme.js";
-import { createDag } from "../orchestration/dag.js";
+import { createDag, getExecutionWaves } from "../orchestration/dag.js";
+import { createOmkJsonEnvelope } from "../util/json-envelope.js";
+import { emitJson } from "../util/cli-contract.js";
 function inferRole(description, explicitRole) {
     if (explicitRole)
         return explicitRole;
@@ -243,6 +245,61 @@ export async function loadSpecDag(specDir, options = {}) {
     }
     return tasksToDag(tasks, { parallel: options.parallel });
 }
+/**
+ * Project the in-memory DAG artifact into the envelope `data` shape. The inner
+ * dag artifact (nodes) is preserved verbatim; edges/batches/stats are derived
+ * from the existing dependsOn graph (no new data sources).
+ */
+function buildDagJsonData(inputId, dag) {
+    const edges = dag.nodes.flatMap((node) => node.dependsOn.map((from) => ({ from, to: node.id })));
+    const batches = getExecutionWaves(dag).map((wave) => wave.map((node) => node.id));
+    return {
+        inputId,
+        nodes: dag.nodes,
+        edges,
+        batches,
+        stats: { nodes: dag.nodes.length, edges: edges.length, batches: batches.length },
+    };
+}
+/**
+ * JSON path for `omk dag from-spec --json`.
+ * Emits EXACTLY ONE omk.contract.v1 envelope to stdout (no banner, no ANSI) and
+ * never throws on a missing/empty tasks.md, so JSON stdout stays one envelope.
+ */
+async function emitDagFromSpecJson(targetDir, options) {
+    const started = Date.now();
+    let dag;
+    try {
+        dag = await loadSpecDag(targetDir, { parallel: options.parallel });
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        const empty = { nodes: [] };
+        emitJson(createOmkJsonEnvelope({
+            command: "dag",
+            status: "not-applicable",
+            ok: false,
+            data: buildDagJsonData(targetDir, empty),
+            warnings: [
+                { code: "RUN_ARTIFACT_MISSING", message, recoverable: true, severity: "warning" },
+            ],
+            durationMs: Date.now() - started,
+        }));
+        return empty;
+    }
+    if (options.output) {
+        await mkdir(getRunsDir(getProjectRoot()), { recursive: true });
+        await writeFile(options.output, JSON.stringify(dag, null, 2));
+    }
+    emitJson(createOmkJsonEnvelope({
+        command: "dag",
+        status: "passed",
+        ok: true,
+        data: buildDagJsonData(targetDir, dag),
+        durationMs: Date.now() - started,
+    }));
+    return dag;
+}
 export async function dagFromSpecCommand(specDir, options = {}) {
     const root = getProjectRoot();
     let targetDir = specDir;
@@ -266,6 +323,9 @@ export async function dagFromSpecCommand(specDir, options = {}) {
             targetDir = getRunPath(options.run, undefined, root);
         }
     }
+    if (options.json === true || process.argv.includes("--json")) {
+        return emitDagFromSpecJson(targetDir, { output: options.output, parallel: options.parallel });
+    }
     const dag = await loadSpecDag(targetDir, { parallel: options.parallel });
     const dagJson = JSON.stringify(dag, null, 2);
     if (options.output) {

package/dist/commands/goal-interview.d.ts

@@ -0,0 +1,18 @@
+interface GoalInterviewOptions {
+    goalId?: string;
+    mode?: string;
+    depth?: string;
+    maxQuestions?: string;
+    answers?: string;
+    image?: string;
+    writeSpec?: boolean;
+    json?: boolean;
+}
+interface GoalRefineOptions {
+    fromInterview?: string;
+    plan?: boolean;
+    json?: boolean;
+}
+export declare function goalInterviewCommand(input: string | undefined, options: GoalInterviewOptions): Promise<void>;
+export declare function goalRefineCommand(goalId: string, options: GoalRefineOptions): Promise<void>;
+export {};