@kontextmind/kxm 0.7.112 → 0.7.118

package/plugins/kxm/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-plugin",
-  "version": "0.7.112",
+  "version": "0.7.118",
   "private": true,
   "type": "module",
   "engines": {

package/plugins/kxm/skills/kxm-harness-auth/SKILL.md

@@ -23,6 +23,12 @@ Issuing a token is an operator action. When kxm_* tools fail with
 `No active session token found in env or disk` for such a file even though it
 still blocks the tools.
 
+## Plugins
+
+| Command | Purpose | Options |
+|---|---|---|
+| `kxm plugin install` | Install KXM plugin for discovered or specified harnesses | `--all`, `--claude`, `--omp`, `--pi`, `--dry-run`, `--json` |
+
 ## Updates
 
 | Command | Purpose |

package/plugins/kxm/src/autocomplete.ts

@@ -8,6 +8,7 @@ const TOP_LEVEL_COMMANDS = [
   "runs",
   "tenant",
   "harness",
+  "plugin",
   "update",
   "runtime",
   "trust",
@@ -38,6 +39,7 @@ const SUBCOMMANDS: Record<string, string[]> = {
   runs: ["status", "cancel", "list"],
   tenant: ["status"],
   harness: ["list"],
+  plugin: ["install"],
   runtime: ["start", "status", "stop"],
   trust: ["diff", "check"],
   agent: ["worker"],
@@ -137,6 +139,7 @@ _kxm() {
     'run:Create a KXM workflow run'
     'runs:Inspect KXM runs'
     'harness:Detect coding-agent harnesses and auth'
+    'plugin:Install or manage KXM harness plugins'
     'update:Update kxm, harness CLIs, and model catalogs'
     'runtime:Manage the KXM Runtime supervisor'
     'trust:Permission-diff trust review'

package/plugins/kxm/src/cli/plugins.ts

@@ -0,0 +1,201 @@
+import { spawnSync } from "node:child_process";
+import { findKxmRepoRoot } from "../repo-root.ts";
+import { probeHarnesses } from "../harness.ts";
+import { print, type Runtime } from "./types.ts";
+
+export type PluginHarnessId = "pi" | "omp" | "claude";
+
+export const PLUGIN_SUPPORTED_HARNESSES: readonly PluginHarnessId[] = Object.freeze(["pi", "omp", "claude"]);
+
+export interface PluginInstallOptions {
+  all?: boolean | undefined;
+  claude?: boolean | undefined;
+  omp?: boolean | undefined;
+  pi?: boolean | undefined;
+}
+
+export interface PluginInstallHarnessResult {
+  harness: string;
+  status: "passed" | "failed" | "would" | "skipped";
+  command?: string | undefined;
+  args?: readonly string[] | undefined;
+  detail?: string | undefined;
+  error?: string | undefined;
+}
+
+export async function cmdPluginInstall(
+  runtime: Runtime,
+  options: PluginInstallOptions,
+): Promise<number> {
+  const repoRoot = findKxmRepoRoot(import.meta.url);
+  const env = runtime.env.PATH ? runtime.env : { ...process.env, ...runtime.env };
+  const inventory = probeHarnesses({ env });
+
+  const isExplicit = Boolean(options.claude || options.omp || options.pi);
+  const requestedHarnesses: PluginHarnessId[] = [];
+  if (options.pi) requestedHarnesses.push("pi");
+  if (options.omp) requestedHarnesses.push("omp");
+  if (options.claude) requestedHarnesses.push("claude");
+
+  const targetHarnesses: readonly PluginHarnessId[] = isExplicit
+    ? requestedHarnesses
+    : PLUGIN_SUPPORTED_HARNESSES;
+
+  const results: PluginInstallHarnessResult[] = [];
+
+  for (const harnessId of targetHarnesses) {
+    const status = inventory.harnesses.find((h) => h.id === harnessId);
+    const detected = Boolean(status?.detected && status?.command);
+
+    if (!detected) {
+      if (isExplicit) {
+        results.push({
+          harness: harnessId,
+          status: "failed",
+          error: "harness_not_detected",
+          detail: `${harnessId} harness is not installed or not found on PATH`,
+        });
+      }
+      continue;
+    }
+
+    const command = status!.command!;
+
+    if (harnessId === "pi") {
+      const args = ["install", repoRoot, "-a"];
+      if (runtime.dryRun) {
+        results.push({
+          harness: "pi",
+          status: "would",
+          command,
+          args,
+          detail: `would install kxm plugin into pi: ${command} ${args.join(" ")}`,
+        });
+      } else {
+        const run = runtime.io.spawnSync
+          ? runtime.io.spawnSync(command, args)
+          : spawnSync(command, args, { encoding: "utf8", windowsHide: true, env: runtime.env });
+        if (run.error || (run.status !== 0 && run.status !== null)) {
+          results.push({
+            harness: "pi",
+            status: "failed",
+            command,
+            args,
+            error: run.error?.message || "install_failed",
+            detail: (run.stderr || run.stdout || "pi install exited with error").trim(),
+          });
+        } else {
+          results.push({
+            harness: "pi",
+            status: "passed",
+            command,
+            args,
+            detail: "installed kxm plugin into pi",
+          });
+        }
+      }
+    } else if (harnessId === "omp") {
+      const args = ["plugin", "install", repoRoot];
+      if (runtime.dryRun) {
+        results.push({
+          harness: "omp",
+          status: "would",
+          command,
+          args,
+          detail: `would install kxm plugin into omp: ${command} ${args.join(" ")}`,
+        });
+      } else {
+        const run = runtime.io.spawnSync
+          ? runtime.io.spawnSync(command, args)
+          : spawnSync(command, args, { encoding: "utf8", windowsHide: true, env: runtime.env });
+        if (run.error || (run.status !== 0 && run.status !== null)) {
+          results.push({
+            harness: "omp",
+            status: "failed",
+            command,
+            args,
+            error: run.error?.message || "install_failed",
+            detail: (run.stderr || run.stdout || "omp plugin install exited with error").trim(),
+          });
+        } else {
+          results.push({
+            harness: "omp",
+            status: "passed",
+            command,
+            args,
+            detail: "installed kxm plugin into omp",
+          });
+        }
+      }
+    } else if (harnessId === "claude") {
+      const marketplaceArgs = ["plugin", "marketplace", "add", repoRoot];
+      const installArgs = ["plugin", "install", "kxm", "-y"];
+      if (runtime.dryRun) {
+        results.push({
+          harness: "claude",
+          status: "would",
+          command,
+          args: installArgs,
+          detail: `would add marketplace and install kxm plugin into claude: ${command} ${installArgs.join(" ")}`,
+        });
+      } else {
+        if (runtime.io.spawnSync) {
+          runtime.io.spawnSync(command, marketplaceArgs);
+        } else {
+          spawnSync(command, marketplaceArgs, { encoding: "utf8", windowsHide: true, env: runtime.env });
+        }
+        const run = runtime.io.spawnSync
+          ? runtime.io.spawnSync(command, installArgs)
+          : spawnSync(command, installArgs, { encoding: "utf8", windowsHide: true, env: runtime.env });
+        if (run.error || (run.status !== 0 && run.status !== null)) {
+          results.push({
+            harness: "claude",
+            status: "failed",
+            command,
+            args: installArgs,
+            error: run.error?.message || "install_failed",
+            detail: (run.stderr || run.stdout || "claude plugin install exited with error").trim(),
+          });
+        } else {
+          results.push({
+            harness: "claude",
+            status: "passed",
+            command,
+            args: installArgs,
+            detail: "installed kxm plugin into claude",
+          });
+        }
+      }
+    }
+  }
+
+  if (results.length === 0) {
+    const errorMsg = "no supported harnesses (pi, omp, claude) detected on PATH";
+    print(
+      runtime.io,
+      runtime.json,
+      { ok: false, command: "plugin install", error: "no_harnesses_detected", results: [] },
+      errorMsg,
+    );
+    return 1;
+  }
+
+  const ok = results.every((r) => r.status === "passed" || r.status === "would");
+  const summary = results
+    .map((r) => `${r.harness}: ${r.status}${r.detail ? ` (${r.detail})` : ""}`)
+    .join("\n");
+
+  print(
+    runtime.io,
+    runtime.json,
+    {
+      ok,
+      command: "plugin install",
+      ...(runtime.dryRun ? { dryRun: true } : {}),
+      results,
+    },
+    summary,
+  );
+
+  return ok ? 0 : 1;
+}

package/plugins/kxm/src/cli.ts

@@ -120,6 +120,8 @@ cmdBackup,
   cmdKxmRuntime,
 } from "./cli/project.ts";
 
+import { cmdPluginInstall } from "./cli/plugins.ts";
+
 import {
   cmdStatus,
   cmdDash,
@@ -185,6 +187,7 @@ const USAGE_ERROR_CODES = new Set([
  */
 const DRY_RUN_COMMANDS: ReadonlySet<string> = new Set([
   "init", "backup", "restore", "run", "explain", "suggest", "update", "dash", "completion", "completion install",
+  "plugin install", "plugin",
   "runs status", "runs drive", "runs receipt", "runs cancel", "runs list",
   "tenant status", "models inventory-refresh", "harness list", "auth token",
   "routes list", "routes count", "routes admit", "routes disable",
@@ -506,6 +509,17 @@ function createProgram(ctx: CliContext, result: { code: number }): Command {
   harnessCmd.helpCommand("help", "Show harness help");
   addGlobalOptions(harnessCmd.command("list").description("Show installed harnesses, auth, and native updaters")).action(bind(cmdHarnessList));
 
+  const pluginCmd = addGlobalOptions(program.command("plugin").description("Install or manage KXM harness plugins"));
+  pluginCmd.helpCommand("help", "Show plugin help");
+  addGlobalOptions(pluginCmd.command("install", { isDefault: true }).description("Install the KXM plugin into discovered or specified harnesses"))
+    .option("--all", "Install plugin for all discovered harnesses (default)")
+    .option("--claude", "Install plugin for Claude Code")
+    .option("--omp", "Install plugin for Oh My Pi (OMP)")
+    .option("--pi", "Install plugin for Pi")
+    .action(async function pluginInstallAction(this: Command, options: { all?: boolean; claude?: boolean; omp?: boolean; pi?: boolean }) {
+      result.code = await cmdPluginInstall(runtimeFrom(ctx, this), options);
+    });
+
   const authCmd = addGlobalOptions(program.command("auth").description("Manage credentials, tokens, and authorization"));
   authCmd.helpCommand("help", "Show auth help");
   addGlobalOptions(authCmd.command("token").description("Inspect, issue, or clear local disk session tokens"))

package/plugins/kxm/src/harness.ts

@@ -508,6 +508,7 @@ const READ_ONLY_ONESHOT_ARGS = Object.freeze({
   // AGENTS.md/CLAUDE.md context discovery, and an ephemeral session. `--no-tools` alone
   // is not enough: extensions and hooks can still run with their own permissions.
   pi: Object.freeze(["--no-tools", "--no-extensions", "--no-skills", "--no-prompt-templates", "--no-context-files", "--no-session"]),
+  omp: Object.freeze(["--no-tools", "--no-extensions", "--no-skills", "--no-prompt-templates", "--no-context-files", "--no-session"]),
   claude: Object.freeze(["--tools", "Read,Glob,Grep", "--restricted", "--safe-mode", "--permission-mode", "plan", "--permission-prompts", "none", "--strict-mcp-config", "--mcp-config", '{"mcpServers":{}}', "--disable-slash-commands", "--no-session-persistence"]),
   codex: Object.freeze(["--sandbox", "read-only", "--ignore-user-config", "-c", 'approval_policy="never"']),
   grok: Object.freeze(["--sandbox", "read-only", "--permission-mode", "plan", "--tools", "Read,Glob,Grep", "--no-subagents", "--disable-web-search"]),
@@ -537,6 +538,7 @@ export function oneShotReadOnlyArgs(harness: string): readonly string[] | undefi
  */
 const WRITER_ONESHOT_ARGS = Object.freeze({
   pi: Object.freeze(["-a", "--no-extensions", "--no-skills", "--no-prompt-templates", "--no-session"]),
+  omp: Object.freeze(["-a", "--no-extensions", "--no-skills", "--no-prompt-templates", "--no-session"]),
   grok: Object.freeze(["--always-approve", "--no-subagents", "--disable-web-search"]),
 });
 
@@ -568,6 +570,26 @@ export const BUILTIN_HARNESSES: readonly HarnessCatalogEntry[] = Object.freeze([
       usageParser: parsePiOneShotUsage,
     },
   },
+  {
+    id: "omp",
+    label: "Oh My Pi",
+    default: false,
+    mode: "headless",
+    commands: ["omp"],
+    versionArgs: ["--version"],
+    authArgs: ["models", "--json"],
+    update: {
+      self: ["update"],
+      extensions: ["plugin", "upgrade"],
+      models: ["models", "refresh"],
+    },
+    oneShot: {
+      argv: ["-p", ...oneShotReadOnlyArgs("omp")!, "--mode", "json"],
+      promptVia: "arg",
+      outputFormat: "json",
+      usageParser: parsePiOneShotUsage,
+    },
+  },
   {
     id: "claude",
     label: "Claude Code",
@@ -857,6 +879,16 @@ function interpretAuth(id: string, result: HarnessCommandResult): Pick<HarnessSt
     if (commandSucceeded(result) && lines.some((line) => line === GROK_LOGIN_LINE)) return { authenticated: true, issues: [] };
     return { authenticated: null, issues: ["auth_unparsed"] };
   }
+  if (id === "omp") {
+    if (commandSucceeded(result)) {
+      const payload = parseJsonObject(result.stdout);
+      if (payload && Array.isArray(payload.models) && payload.models.length > 0) {
+        return { authenticated: true, issues: [] };
+      }
+      if (commandSucceeded(result)) return { authenticated: true, issues: [] };
+    }
+    return { authenticated: null, issues: ["auth_unparsed"] };
+  }
   if (id === "agy") {
     const text = `${result.stdout}\n${result.stderr}`;
     if (!commandSucceeded(result) || !text.trim()) {
@@ -1118,7 +1150,7 @@ export function validateHarnessModelPair(
     return { valid: true };
   }
 
-  if (harnessId === "pi") {
+  if (harnessId === "pi" || harnessId === "omp") {
     if (!provider && model?.includes("/")) {
       const idx = model.indexOf("/");
       provider = model.slice(0, idx).toLowerCase();
@@ -1127,17 +1159,17 @@ export function validateHarnessModelPair(
     if (!provider) return { valid: true };
     const blocked = (message: string): HarnessModelValidation => ({ valid: false, issue: "pi_native_impersonation_blocked", message });
     if (PI_NATIVE_BRAKE_PROVIDERS.includes(provider)) {
-      return blocked(`pi must not impersonate native provider ${provider}; use the native harness`);
+      return blocked(`${harnessId} must not impersonate native provider ${provider}; use the native harness`);
     }
     if (provider === "antigravity" && model && PI_ANTIGRAVITY_MODEL_ID.test(model)) return { valid: true };
     const owned = Object.hasOwn(PI_VENDOR_OWNED_PROVIDERS, provider) ? PI_VENDOR_OWNED_PROVIDERS[provider] : undefined;
     if (owned) {
-      return blocked(`pi provider ${provider} bills native vendor ${owned} for ${model ?? "this model"}; use the native harness`);
+      return blocked(`${harnessId} provider ${provider} bills native vendor ${owned} for ${model ?? "this model"}; use the native harness`);
     }
     const segment = model?.includes("/") ? model.slice(0, model.indexOf("/")).toLowerCase() : undefined;
     const vendor = segment && Object.hasOwn(PI_VENDOR_SEGMENT_ALIASES, segment) ? PI_VENDOR_SEGMENT_ALIASES[segment] : segment;
     if (vendor && PI_NATIVE_BRAKE_PROVIDERS.includes(vendor)) {
-      return blocked(`pi must not bill native vendor ${vendor} through ${provider}; use the native harness`);
+      return blocked(`${harnessId} must not bill native vendor ${vendor} through ${provider}; use the native harness`);
     }
     return { valid: true };
   }

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

@@ -11,7 +11,7 @@ import { deliverInboxNotification } from "./inbox.ts";
 import type { HubEvent, MessageRecord } from "./protocol.ts";
 import { sessionTokenFixHint } from "./session-token-hint.ts";
 
-const VERSION = "0.7.112";
+const VERSION = "0.7.118";
 const CONFIGURE_PLUGIN = "/plugin configure kxm@kxm";
 const inbox = new Map<string, MessageRecord>();
 const notifiedInbox = new Set<string>();

package/scripts/assignment-run.d.mts

@@ -339,6 +339,13 @@ export function changeReport(request: { taskDir: string }, deps?: Record<string,
   ranking: "not-ranked";
   orchestration_usage: "unavailable";
 };
+export const ROUTING_EXPORT_SCHEMA: "kxm.assignment-routing-export.v1";
+export function exportAssignmentRoutingRecords(request: { taskDir: string }, deps?: Record<string, unknown>): {
+  schema: "kxm.assignment-routing-export.v1";
+  task_id: string;
+  records: Array<Record<string, any>>;
+  skipped: Array<{ assignment_id: string | null; reason: "acceptance_record_invalid" | "no_routing_record" | "routing_record_invalid" | "manifest_invalid" }>;
+};
 export function writeCurrentPlan(request: {
   taskDir: string; plan: string; sha256: string; baseCommit: string; expectedGeneration: number; settledDecisions?: string[];
 }, deps?: Record<string, unknown>): {

package/scripts/assignment-run.mjs

@@ -2330,7 +2330,7 @@ export async function observeAssignment(outputDir, deps = {}) {
   return appended;
 }
 
-const CLI_USAGE = "usage: assignment-run.mjs run --manifest <absolute-path> | observe --record-dir <absolute-path> | witness --record-dir <absolute-path> | accept --task-dir <absolute-path> --commit <commit> --record-dir <absolute-path> --critic <absolute-path> --critic <absolute-path> [--observed-pr <id>] [--observed-ci <id>] | attribute --task-dir <absolute-path> --record-dir <absolute-path> --class <orchestration|model|environment|unclassified> --explanation-file <absolute-path> | observe-cost --task-dir <absolute-path> --input <absolute-path> | plan-current --task-dir <absolute-path> --plan <absolute-path> --sha256 <hex64> --base-commit <commit> --expected-generation <n> | change-report --task-dir <absolute-path>";
+const CLI_USAGE = "usage: assignment-run.mjs run --manifest <absolute-path> | observe --record-dir <absolute-path> | witness --record-dir <absolute-path> | accept --task-dir <absolute-path> --commit <commit> --record-dir <absolute-path> --critic <absolute-path> --critic <absolute-path> [--observed-pr <id>] [--observed-ci <id>] | attribute --task-dir <absolute-path> --record-dir <absolute-path> --class <orchestration|model|environment|unclassified> --explanation-file <absolute-path> | observe-cost --task-dir <absolute-path> --input <absolute-path> | plan-current --task-dir <absolute-path> --plan <absolute-path> --sha256 <hex64> --base-commit <commit> --expected-generation <n> | change-report --task-dir <absolute-path> | routing-export --task-dir <absolute-path>";
 
 const WITNESS_RECEIPT_KEYS = Object.freeze([
   "schema",
@@ -4293,8 +4293,135 @@ export function writeCurrentPlan(request, deps = {}) {
   } catch (error) { throw observationFailure(error, "plan_ref_invalid"); }
 }
 
+export const ROUTING_EXPORT_SCHEMA = "kxm.assignment-routing-export.v1";
+
+function contractExportable(contract) {
+  return Boolean(contract)
+    && typeof contract === "object"
+    && !Array.isArray(contract)
+    && typeof contract.boundary === "string"
+    && Array.isArray(contract.deliverables)
+    && contract.witness
+    && typeof contract.witness === "object"
+    && !Array.isArray(contract.witness)
+    && typeof contract.witness.id === "string"
+    && Array.isArray(contract.deferred);
+}
+
+export function exportAssignmentRoutingRecords(request, deps = {}) {
+  const io = ioDeps(deps);
+  const taskDir = observationTask(request.taskDir, io);
+  const taskId = basename(taskDir);
+  const skipped = [];
+  const acceptedIds = new Set();
+  const acceptedPath = join(taskDir, ACCEPTED_FILENAME);
+  if (lstatOrNull(acceptedPath, io.lstatSync)) {
+    try {
+      const value = privateRecord(acceptedPath, io).value;
+      const valid = value.schema === ACCEPTED_SCHEMA
+        && value.task_id === taskId
+        && typeof value.writer?.assignment_id === "string"
+        && Array.isArray(value.critics);
+      if (!valid) throw new Error("acceptance invalid");
+      acceptedIds.add(value.writer.assignment_id);
+      for (const critic of value.critics) {
+        if (typeof critic?.assignment_id === "string") acceptedIds.add(critic.assignment_id);
+      }
+    } catch {
+      skipped.push({ assignment_id: null, reason: "acceptance_record_invalid" });
+    }
+  }
+  const collected = [];
+  const dirs = listDirectAssignmentDirs(taskDir, io).sort((left, right) => left.assignment_id < right.assignment_id ? -1 : left.assignment_id > right.assignment_id ? 1 : 0);
+  for (const { assignment_id, path } of dirs) {
+    const routingPath = join(path, "routing-record.json");
+    if (!lstatOrNull(routingPath, io.lstatSync)) {
+      skipped.push({ assignment_id, reason: "no_routing_record" });
+      continue;
+    }
+    let record;
+    try {
+      record = parseRoutingRecord(privateRecord(routingPath, io).value);
+      if (record.workflowRunId !== assignment_id) throw new Error("workflowRunId");
+    } catch {
+      skipped.push({ assignment_id, reason: "routing_record_invalid" });
+      continue;
+    }
+    let contract;
+    try {
+      const manifest = privateRecord(join(path, "manifest.json"), io).value;
+      contract = manifest.contract;
+      if (!contractExportable(contract)) throw new Error("contract");
+    } catch {
+      skipped.push({ assignment_id, reason: "manifest_invalid" });
+      continue;
+    }
+    collected.push({ id: assignment_id, record, contract });
+  }
+  const supersededBy = new Map();
+  for (const entry of collected) {
+    const reworkOf = entry.record.providerMetadata?.rework_of;
+    if (typeof reworkOf === "string" && !supersededBy.has(reworkOf)) supersededBy.set(reworkOf, entry.id);
+  }
+  const records = [];
+  for (const entry of collected) {
+    const kind = entry.record.stageId;
+    const role = entry.record.agentRole;
+    const askSha256 = sha256Bytes(Buffer.from(JSON.stringify(["kxm.assignment-ask.v1", kind, role])));
+    const objectiveSha256 = sha256Bytes(Buffer.from(JSON.stringify([
+      "kxm.assignment-brief.v1",
+      kind,
+      entry.contract.boundary,
+      entry.contract.deliverables,
+      entry.contract.witness.id,
+      entry.contract.deferred,
+    ])));
+    const finalOutcome = acceptedIds.has(entry.id) ? "accepted" : supersededBy.has(entry.id) ? "failed" : "pending";
+    try {
+      records.push(parseRoutingRecord({
+        ...entry.record,
+        workflowRunId: taskId,
+        finalOutcome,
+        providerMetadata: {
+          ...entry.record.providerMetadata,
+          workflowId: "assignment-runner",
+          askSha256,
+          objectiveSha256,
+          stepWrites: WRITER_KINDS.includes(kind),
+          assignmentId: entry.id,
+          ...(finalOutcome === "failed" ? { supersededBy: supersededBy.get(entry.id) } : {}),
+        },
+      }));
+    } catch {
+      skipped.push({ assignment_id: entry.id, reason: "routing_record_invalid" });
+    }
+  }
+  return { schema: ROUTING_EXPORT_SCHEMA, task_id: taskId, records, skipped };
+}
+
 export async function main(argv = process.argv, io = { stdin: process.stdin, stdout: process.stdout, stderr: process.stderr }) {
   const args = argv.slice(2).filter((arg) => arg !== "--");
+  if (args[0] === "routing-export") {
+    try {
+      const values = {};
+      for (let i = 1; i < args.length; i += 2) {
+        if (args[i] !== "--task-dir" || values[args[i]] !== undefined || args[i + 1] === undefined) throw failClosed("invalid report/plan arguments", "manifest_invalid");
+        values[args[i]] = args[i + 1];
+      }
+      if (values["--task-dir"] === undefined) throw failClosed("missing report/plan arguments", "manifest_invalid");
+      const result = exportAssignmentRoutingRecords({ taskDir: values["--task-dir"] });
+      for (const record of result.records) io.stdout.write(`${JSON.stringify(record)}\n`);
+      io.stderr.write(`${JSON.stringify({ schema: result.schema, task_id: result.task_id, records: result.records.length, skipped: result.skipped })}\n`);
+      process.exitCode = 0;
+      return result;
+    } catch (error) {
+      const failure = observationFailure(error);
+      io.stderr.write(`${failure.runnerCode}: assignment routing export refused\n`);
+      process.exitCode = 1;
+      throw failure;
+    }
+  }
+
   if (["change-report", "plan-current"].includes(args[0])) {
     try {
       const flags = args[0] === "change-report" ? ["--task-dir"] : ["--task-dir", "--plan", "--sha256", "--base-commit", "--expected-generation"];