open-multi-agent-kit 0.78.1 → 0.78.3

package/dist/benchmark/shadow-mode.js

@@ -0,0 +1,96 @@
+/**
+ * Shadow Mode Engine — side-by-side router v1/v2 recording.
+ */
+import { createRuntimeRouter } from "../runtime/runtime-router.js";
+import { createRouterV2ScoringEngine, scoreRuntimes } from "../runtime/router-v2-scoring.js";
+export function createShadowModeEngine(options) {
+    const v1Router = createRuntimeRouter({ runtimes: options.runtimes });
+    const v2Engine = createRouterV2ScoringEngine();
+    function computeRegret(scores, selectedId) {
+        if (scores.length === 0)
+            return 0;
+        const best = Math.max(...scores.map((s) => s.composite));
+        const selected = scores.find((s) => s.runtimeId === selectedId)?.composite ?? 0;
+        return Math.max(0, best - selected);
+    }
+    function evaluate(taskId, nodeId, capsule) {
+        const intent = v1Router.classifyIntent(capsule);
+        let v1Decision = null;
+        let regretV1 = 0;
+        try {
+            v1Decision = v1Router.selectByIntent(capsule, options.history);
+            const v1Scores = v1Decision.scores.map((s) => ({
+                runtimeId: s.runtime,
+                composite: 0.35 * s.qualityScore +
+                    0.25 * s.evidencePassRate +
+                    0.15 * s.costScore +
+                    0.1 * s.latencyScore +
+                    0.15 * (1 - s.recentFailurePenalty),
+            }));
+            regretV1 = computeRegret(v1Scores, v1Decision.runtime.id);
+        }
+        catch {
+            v1Decision = null;
+            regretV1 = 1;
+        }
+        let v2Decision = null;
+        let regretV2 = 0;
+        try {
+            v2Decision = v2Engine.select(options.runtimes, intent, options.history);
+            const v2Scores = v2Decision.scores.map((s) => ({
+                runtimeId: s.runtimeId,
+                composite: s.composite,
+            }));
+            regretV2 = computeRegret(v2Scores, v2Decision.runtime.id);
+        }
+        catch {
+            v2Decision = null;
+            regretV2 = 1;
+        }
+        const disagreement = v1Decision?.runtime.id !== v2Decision?.runtime.id;
+        return {
+            taskId,
+            nodeId,
+            intent,
+            v1Decision,
+            v2Decision,
+            regretV1,
+            regretV2,
+            disagreement,
+            timestamp: new Date().toISOString(),
+        };
+    }
+    function toBenchmarkDecision(record) {
+        const out = [];
+        if (record.v1Decision) {
+            out.push({
+                component: "runtime-router-v1",
+                selectedRuntime: record.v1Decision.runtime.id,
+                bestAvailableRuntime: record.v2Decision?.scores[0]?.runtimeId ?? record.v1Decision.runtime.id,
+                regret: record.regretV1,
+                reason: record.v1Decision.reason,
+            });
+        }
+        if (record.v2Decision) {
+            out.push({
+                component: "runtime-router-v2",
+                selectedRuntime: record.v2Decision.runtime.id,
+                bestAvailableRuntime: record.v2Decision.scores[0]?.runtimeId ?? record.v2Decision.runtime.id,
+                regret: record.regretV2,
+                reason: record.v2Decision.reason,
+                scoresV2: record.v2Decision.scores,
+            });
+        }
+        return out;
+    }
+    return { evaluate, toBenchmarkDecision };
+}
+export function computeRouterRegret(candidates, intent, history, selectedId) {
+    const engine = createRouterV2ScoringEngine();
+    const scores = scoreRuntimes(candidates, intent, history);
+    if (scores.length === 0)
+        return 0;
+    const best = Math.max(...scores.map((s) => s.composite));
+    const selected = scores.find((s) => s.runtimeId === selectedId)?.composite ?? 0;
+    return Math.max(0, best - selected);
+}

package/dist/cli/register-spec-agent-goal-commands.js

@@ -159,6 +159,51 @@ export function registerSpecAgentGoalCommands(program) {
             throw err;
         }
     });
+    goal
+        .command("interview [input]")
+        .description("[Alpha] Run a deep interview to reduce goal uncertainty before planning")
+        .option("--goal-id <id>", "Existing goal id to refine")
+        .option("--mode <create|refine>", "Interview mode (create | refine)", "create")
+        .option("--depth <light|standard|deep>", "Interview depth (omit to auto-select by ambiguity)")
+        .option("--max-questions <n>", "Maximum number of questions")
+        .option("--answers <file>", "Answers JSON file: { \"answers\": [{ \"questionId\", \"answer\" }] }")
+        .option("--image <file>", "Attach an image file (screenshot/diagram) to the interview")
+        .option("--write-spec", "Create or update the goal spec from interview answers")
+        .option("--json", t("cmd.goalJsonOption"))
+        .action(async (input, options) => {
+        const { goalInterviewCommand } = await import("../commands/goal-interview.js");
+        try {
+            await goalInterviewCommand(input, options);
+        }
+        catch (err) {
+            if (err instanceof CliError) {
+                if (process.exitCode === undefined)
+                    process.exitCode = err.exitCode;
+                return;
+            }
+            throw err;
+        }
+    });
+    goal
+        .command("refine <goal-id>")
+        .description("[Alpha] Apply the latest interview spec delta to a goal and optionally replan")
+        .option("--from-interview <id>", "Interview session id (default: latest)", "latest")
+        .option("--plan", "Rebuild the plan after applying the interview delta")
+        .option("--json", t("cmd.goalJsonOption"))
+        .action(async (goalId, options) => {
+        const { goalRefineCommand } = await import("../commands/goal-interview.js");
+        try {
+            await goalRefineCommand(goalId, options);
+        }
+        catch (err) {
+            if (err instanceof CliError) {
+                if (process.exitCode === undefined)
+                    process.exitCode = err.exitCode;
+                return;
+            }
+            throw err;
+        }
+    });
     goal
         .command("list")
         .description(t("cmd.goalListDesc"))

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/native-root-loop.js

@@ -791,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) => {
@@ -846,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 });
@@ -855,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,
@@ -896,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/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 {};