@kontextmind/kxm 0.7.37 → 0.7.39

package/.claude-plugin/marketplace.json

@@ -11,7 +11,7 @@
       "name": "kxm",
       "source": "./plugins/kxm",
       "description": "Durable workflows, peer agents, and kxm tui",
-      "version": "0.7.37",
+      "version": "0.7.39",
       "category": "development",
       "tags": ["kxm", "multi-agent", "workflows", "mcp"]
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kontextmind/kxm",
-  "version": "0.7.37",
+  "version": "0.7.39",
   "description": "KXM local-first multi-agent orchestration and operator dashboard",
   "type": "module",
   "author": "KontextMind",

package/plugins/kxm/.claude-plugin/plugin.json

@@ -2,7 +2,7 @@
   "$schema": "https://json.schemastore.org/claude-code-plugin-manifest.json",
   "name": "kxm",
   "displayName": "KXM",
-  "version": "0.7.37",
+  "version": "0.7.39",
   "description": "Headless multi-agent orchestration, durable workflows, and a live operator dashboard for Pi and Claude Code",
   "author": {
     "name": "KontextMind",

package/plugins/kxm/dist/mcp-server.js

@@ -17121,7 +17121,7 @@ async function deliverInboxNotification(messageId, delivered, notify) {
 }
 
 // plugins/kxm/src/mcp-server.ts
-var VERSION = "0.7.37";
+var VERSION = "0.7.39";
 var inbox = /* @__PURE__ */ new Map();
 var notifiedInbox = /* @__PURE__ */ new Set();
 var meshClient;

package/plugins/kxm/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kxm-claude-plugin",
-  "version": "0.7.37",
+  "version": "0.7.39",
   "private": true,
   "type": "module",
   "engines": {

package/plugins/kxm/src/mcp-server.ts

@@ -8,7 +8,7 @@ import { AGENT_COMMANDS_MAP, enforceToolPolicy, getMcpTools, reconcileInbox } fr
 import { deliverInboxNotification } from "./inbox.ts";
 import type { HubEvent, MessageRecord } from "./protocol.ts";
 
-const VERSION = "0.7.37";
+const VERSION = "0.7.39";
 const inbox = new Map<string, MessageRecord>();
 const notifiedInbox = new Set<string>();
 let meshClient: HubClient | undefined;

package/plugins/kxm/src/vision-gate.ts

@@ -0,0 +1,94 @@
+import { execFileSync } from "node:child_process";
+import { existsSync, statSync } from "node:fs";
+import { isRouteAdmitted } from "./routes.ts";
+
+/** Deterministic vision gate: judge a UI screenshot through an admitted
+ * vision route with a bounded prompt and a strict structured verdict. The
+ * gate never free-form chats and never fabricates — an unreadable image, an
+ * unadmitted route, or an unparsable verdict returns `verdict: null` with a
+ * `divergence` reason. Transport is injectable so tests run without
+ * network. */
+
+export const VISION_GATE_DEFAULT_ROUTE = "zai-coding-cn/glm-5.3-flash";
+const QUESTION_MAX_CHARS = 500;
+const RAW_MAX_CHARS = 2000;
+
+export interface VisionGateOptions {
+  projectRoot?: string | undefined;
+  /** Absolute or project-relative path to the screenshot. */
+  imagePath: string;
+  /** What to assert about the screenshot, phrased as a yes/no question. */
+  question: string;
+  /** Producer id as admitted in routes.yaml. Defaults to the verified
+   * vision route. */
+  route?: string | undefined;
+  timeoutMs?: number | undefined;
+  /** Injectable transport: receives the composed prompt, returns CLI stdout. */
+  transport?: ((prompt: string) => Promise<string>) | undefined;
+}
+
+export interface VisionGateResult {
+  /** true/false when the verdict parsed; null = fail closed. */
+  verdict: boolean | null;
+  route: string;
+  /** Bounded raw output for audit. */
+  raw: string;
+  divergence?: string | undefined;
+}
+
+export function visionGatePrompt(question: string, imagePath?: string | undefined): string {
+  const bounded = question.trim().slice(0, QUESTION_MAX_CHARS);
+  const reference = imagePath ? `Look at the image @${imagePath}.` : "Look at the image attached to this prompt.";
+  return [
+    "You are judging a UI screenshot for an automated verification gate.",
+    reference,
+    bounded,
+    'Reply with exactly one JSON object and nothing else: {"verdict": true} or {"verdict": false}',
+  ].join(" ");
+}
+
+export function parseVisionVerdict(raw: string): boolean | null {
+  const match = /"verdict"\s*:\s*(true|false)/i.exec(raw);
+  return match ? match[1] === "true" : null;
+}
+
+function defaultTransport(prompt: string, timeoutMs: number): string {
+  return execFileSync(
+    "pi",
+    ["--provider", "zai-coding-cn", "--model", "glm-5.3-flash", "-p", "--no-session", prompt],
+    { encoding: "utf8", timeout: timeoutMs, windowsHide: true },
+  );
+}
+
+export async function runVisionGate(options: VisionGateOptions): Promise<VisionGateResult> {
+  const projectRoot = options.projectRoot ?? process.cwd();
+  const route = options.route ?? VISION_GATE_DEFAULT_ROUTE;
+  const timeoutMs = options.timeoutMs ?? 90_000;
+  const base: VisionGateResult = { verdict: null, route, raw: "" };
+
+  if (!Number.isInteger(timeoutMs) || timeoutMs < 5_000 || timeoutMs > 300_000) {
+    return { ...base, divergence: "timeout_out_of_bounds" };
+  }
+  if (!options.imagePath || !existsSync(options.imagePath) || !statSync(options.imagePath).isFile()) {
+    return { ...base, divergence: "image unreadable" };
+  }
+  if (!isRouteAdmitted(projectRoot, route)) {
+    return { ...base, divergence: "route_not_admitted" };
+  }
+  const prompt = visionGatePrompt(options.question, options.imagePath);
+
+  let raw: string;
+  try {
+    raw = options.transport
+      ? await options.transport(prompt)
+      : defaultTransport(prompt, timeoutMs);
+  } catch (error) {
+    return { ...base, divergence: `transport failed: ${String((error as Error)?.message ?? error).slice(0, 200)}` };
+  }
+  const boundedRaw = raw.slice(0, RAW_MAX_CHARS);
+  const verdict = parseVisionVerdict(boundedRaw);
+  if (verdict === null) {
+    return { ...base, raw: boundedRaw, divergence: "verdict unreadable" };
+  }
+  return { ...base, verdict, raw: boundedRaw };
+}

package/scripts/roster-policy.mjs

@@ -97,9 +97,11 @@ export function validateRosterDocument(policy, readBlob) {
     text(model, 'origin model'); keys(origin, ['vendor', 'evidence'], 'origin');
     text(origin.vendor, 'origin vendor');
     if (PI_ALLOWED_PROVIDERS.includes(canonical(origin.vendor.toLowerCase()))) refuse('origin/vendor must name the model vendor, not billing provider');
-    keys(origin.evidence, ['source', 'sha256'], 'origin evidence'); digest(origin.evidence.sha256);
+    const evidenceKeys = origin.evidence.commit === undefined ? ['source', 'sha256'] : ['source', 'commit', 'sha256'];
+    keys(origin.evidence, evidenceKeys, 'origin evidence'); digest(origin.evidence.sha256);
     sourcePath(origin.evidence.source);
-    const bytes = readBlob(origin.evidence.source);
+    if (origin.evidence.commit !== undefined) objectId(origin.evidence.commit, 'origin evidence commit');
+    const bytes = readBlob(origin.evidence.source, origin.evidence.commit);
     if (bytes == null || sha256(bytes) !== origin.evidence.sha256) refuse('origin evidence hash mismatch');
   }
   for (const [id, route] of Object.entries(policy.routes)) {
@@ -160,17 +162,24 @@ export function validateRosterDocument(policy, readBlob) {
   }
   return policy;
 }
-function validate(bytes, commit) {
+function validate(bytes, commit, trusted) {
   let policy;
   try { policy = YAML.parse(bytes.toString('utf8')); } catch { refuse('invalid policy YAML'); }
   if (policy === undefined || policy === null || typeof policy !== 'object' || Array.isArray(policy)) refuse('invalid policy YAML');
-  return validateRosterDocument(policy, source => blobAt(commit, source).bytes);
+  const readBlob = (source, pinnedCommit) => {
+    if (pinnedCommit === undefined) return blobAt(commit, source).bytes;
+    // A pinned evidence commit decouples the digest from later edits to the
+    // evidence file; the pinned commit itself must be part of trusted history.
+    git('merge-base', '--is-ancestor', pinnedCommit, trusted);
+    return blobAt(pinnedCommit, source).bytes;
+  };
+  return validateRosterDocument(policy, readBlob);
 }
 export function loadTrustedRosterPolicy() {
   const snapshot = control();
   const { blob, bytes } = blobAt(snapshot.head, POLICY);
   if (!workingBytes(POLICY).equals(bytes)) refuse('working policy differs from committed bytes');
-  const policy = validate(bytes, snapshot.head);
+  const policy = validate(bytes, snapshot.head, trusted);
   unchanged(snapshot);
   return frozen({ identity: { commit: snapshot.head, blob, sha256: sha256(bytes) }, policy });
 }
@@ -181,7 +190,7 @@ export function resolveBoundPolicy(identity) {
   git('merge-base', '--is-ancestor', identity.commit, snapshot.trusted);
   const { blob, bytes } = blobAt(identity.commit, POLICY);
   if (blob !== identity.blob || sha256(bytes) !== identity.sha256) refuse('bound identity mismatch');
-  const policy = validate(bytes, identity.commit);
+  const policy = validate(bytes, identity.commit, snapshot.trusted);
   unchanged(snapshot);
   return frozen({ identity: { ...identity }, policy });
 }