@kontextmind/kxm 0.7.72 → 0.7.74

package/plugins/kxm/dist/runtime-supervisor.js

@@ -2987,7 +2987,7 @@ var require_compile = __commonJS({
       const schOrFunc = root.refs[ref];
       if (schOrFunc)
         return schOrFunc;
-      let _sch = resolve6.call(this, root, ref);
+      let _sch = resolve8.call(this, root, ref);
       if (_sch === void 0) {
         const schema = (_a = root.localRefs) === null || _a === void 0 ? void 0 : _a[ref];
         const { schemaId } = this.opts;
@@ -3014,7 +3014,7 @@ var require_compile = __commonJS({
     function sameSchemaEnv(s1, s2) {
       return s1.schema === s2.schema && s1.root === s2.root && s1.baseId === s2.baseId;
     }
-    function resolve6(root, ref) {
+    function resolve8(root, ref) {
       let sch;
       while (typeof (sch = this.refs[ref]) == "string")
         ref = sch;
@@ -3839,7 +3839,7 @@ var require_fast_uri = __commonJS({
       }
       return uri;
     }
-    function resolve6(baseURI, relativeURI, options) {
+    function resolve8(baseURI, relativeURI, options) {
       const schemelessOptions = options ? Object.assign({ scheme: "null" }, options) : { scheme: "null" };
       const {
         parsed: baseParsed,
@@ -4201,7 +4201,7 @@ var require_fast_uri = __commonJS({
     var fastUri = {
       SCHEMES,
       normalize,
-      resolve: resolve6,
+      resolve: resolve8,
       resolveComponent,
       equal,
       serialize,
@@ -14780,10 +14780,10 @@ var require_dist = __commonJS({
 
 // plugins/kxm/src/runtime-supervisor.ts
 import { spawn as spawn3 } from "node:child_process";
-import { createHash as createHash11, createHmac, randomBytes as randomBytes2, timingSafeEqual as timingSafeEqual2 } from "node:crypto";
-import { chmodSync as chmodSync2, existsSync as existsSync10, lstatSync as lstatSync5, mkdirSync as mkdirSync4, readFileSync as readFileSync8, renameSync, rmSync, writeFileSync as writeFileSync4 } from "node:fs";
+import { createHash as createHash12, createHmac, randomBytes as randomBytes2, timingSafeEqual as timingSafeEqual2 } from "node:crypto";
+import { chmodSync as chmodSync2, existsSync as existsSync12, lstatSync as lstatSync5, mkdirSync as mkdirSync6, readFileSync as readFileSync11, renameSync as renameSync3, rmSync as rmSync3, writeFileSync as writeFileSync6 } from "node:fs";
 import { createServer } from "node:http";
-import { dirname as dirname6, isAbsolute as isAbsolute4, join as join13 } from "node:path";
+import { dirname as dirname8, isAbsolute as isAbsolute6, join as join16 } from "node:path";
 
 // plugins/kxm/src/repo-root.ts
 import { existsSync } from "node:fs";
@@ -15163,7 +15163,7 @@ function defaultSpawn(command, args, options) {
   if (options.signal?.aborted) {
     return Promise.resolve({ stdout: "", stderr: "", code: null, started: false, observedChildExit: false, error: new Error("process_aborted") });
   }
-  return new Promise((resolve6) => {
+  return new Promise((resolve8) => {
     const stdout = [];
     const stderr = [];
     let outputBytes = 0;
@@ -15194,7 +15194,7 @@ function defaultSpawn(command, args, options) {
       const started = Boolean(child?.pid);
       if (started && !observedChildExit) error ??= new Error("process_exit_unobserved");
       const unverifiedDescendants = stopping || started && !observedChildExit;
-      resolve6({
+      resolve8({
         stdout: Buffer.concat(stdout).toString("utf8"),
         stderr: Buffer.concat(stderr).toString("utf8"),
         code,
@@ -16303,6 +16303,7 @@ var KxmSchemaRegistry = class {
   driveReceiptValidator;
   coordinatorValidator;
   intakeMessageValidator;
+  syncEventValidator;
   constructor(schemasDir = DEFAULT_SCHEMA_DIR) {
     this.schemasDir = resolve(schemasDir);
     this.ajv = new import__.Ajv2020({ allErrors: true, strict: true, strictRequired: false });
@@ -16319,6 +16320,7 @@ var KxmSchemaRegistry = class {
     const driveReceiptFile = "drive-receipt.schema.json";
     const coordinatorFile = "coordinator.schema.json";
     const intakeMessageFile = "intake-message.schema.json";
+    const syncEventFile = "sync-event.schema.json";
     this.ajv.addSchema(readJsonObject(join2(this.schemasDir, localBindingsFile)));
     this.ajv.addSchema(readJsonObject(join2(this.schemasDir, templateProvenanceFile)));
     this.ajv.addSchema(readJsonObject(join2(this.schemasDir, initOperationFile)));
@@ -16327,6 +16329,7 @@ var KxmSchemaRegistry = class {
     this.ajv.addSchema(readJsonObject(join2(this.schemasDir, driveReceiptFile)));
     this.ajv.addSchema(readJsonObject(join2(this.schemasDir, coordinatorFile)));
     this.ajv.addSchema(readJsonObject(join2(this.schemasDir, intakeMessageFile)));
+    this.ajv.addSchema(readJsonObject(join2(this.schemasDir, syncEventFile)));
     for (const [kind, definition] of Object.entries(RESOURCE_SCHEMA)) {
       const validator = this.ajv.getSchema(`https://schemas.kxm.dev/${definition.file}`);
       if (!validator) throw new Error(`schema did not compile: ${definition.file}`);
@@ -16340,6 +16343,7 @@ var KxmSchemaRegistry = class {
     const driveReceiptValidator = this.ajv.getSchema(`https://schemas.kxm.dev/${driveReceiptFile}`);
     const coordinatorValidator = this.ajv.getSchema(`https://schemas.kxm.dev/${coordinatorFile}`);
     const intakeMessageValidator = this.ajv.getSchema(`https://schemas.kxm.dev/${intakeMessageFile}`);
+    const syncEventValidator = this.ajv.getSchema(`https://schemas.kxm.dev/${syncEventFile}`);
     if (!localBindingsValidator) throw new Error(`schema did not compile: ${localBindingsFile}`);
     if (!templateProvenanceValidator) throw new Error(`schema did not compile: ${templateProvenanceFile}`);
     if (!initOperationValidator) throw new Error(`schema did not compile: ${initOperationFile}`);
@@ -16348,6 +16352,7 @@ var KxmSchemaRegistry = class {
     if (!driveReceiptValidator) throw new Error(`schema did not compile: ${driveReceiptFile}`);
     if (!coordinatorValidator) throw new Error(`schema did not compile: ${coordinatorFile}`);
     if (!intakeMessageValidator) throw new Error(`schema did not compile: ${intakeMessageFile}`);
+    if (!syncEventValidator) throw new Error(`schema did not compile: ${syncEventFile}`);
     this.localBindingsValidator = localBindingsValidator;
     this.templateProvenanceValidator = templateProvenanceValidator;
     this.initOperationValidator = initOperationValidator;
@@ -16356,6 +16361,7 @@ var KxmSchemaRegistry = class {
     this.driveReceiptValidator = driveReceiptValidator;
     this.coordinatorValidator = coordinatorValidator;
     this.intakeMessageValidator = intakeMessageValidator;
+    this.syncEventValidator = syncEventValidator;
   }
   validate(kind, value, file) {
     const definition = RESOURCE_SCHEMA[kind];
@@ -16402,6 +16408,11 @@ function validateRunEvent(value, file) {
     )]);
   }
 }
+function syncEventSchemaErrors(value) {
+  const registry = cachedRunEventRegistry ??= new KxmSchemaRegistry();
+  if (registry.syncEventValidator(value)) return void 0;
+  return registry.ajv.errorsText(registry.syncEventValidator.errors, { separator: "; " });
+}
 function validateDriveReceipt(value, file) {
   const registry = cachedRunEventRegistry ??= new KxmSchemaRegistry();
   if (!value || typeof value !== "object" || Array.isArray(value) || value.schema !== "kxm.drive-receipt.v1") {
@@ -16908,8 +16919,8 @@ function validateWorkflow(workflow, agents, models, repositories, gates, issues)
       const writable = Object.values(objectValue(step.repositories) ?? {}).filter((access) => access === "write").length;
       if (maxWriteRepositories > writable) issues.push(issue2("semantic", "write_repository_bound_invalid", file, `${stepId} maxWriteRepositories exceeds writable repository scope`));
     }
-    const join14 = objectValue(step.join);
-    const minimumPassed = join14 && typeof join14.minimumPassed === "number" ? join14.minimumPassed : void 0;
+    const join17 = objectValue(step.join);
+    const minimumPassed = join17 && typeof join17.minimumPassed === "number" ? join17.minimumPassed : void 0;
     if (minimumPassed !== void 0 && minimumPassed > maximum) issues.push(issue2("semantic", "join_impossible", file, `${stepId} minimumPassed exceeds assignment maximum`));
     const distinctBy = names(assignment?.distinctBy);
     if (distinctBy.length > 0) {
@@ -17382,7 +17393,7 @@ function legacyConfigFilesAt(root) {
 }
 
 // plugins/kxm/src/runtime-store.ts
-import { createHash as createHash3, randomUUID } from "node:crypto";
+import { createHash as createHash4, randomUUID } from "node:crypto";
 import { existsSync as existsSync5, lstatSync as lstatSync3, mkdirSync as mkdirSync2, readFileSync as readFileSync3, realpathSync as realpathSync2, writeFileSync as writeFileSync2 } from "node:fs";
 import { dirname as dirname5, join as join5, resolve as resolve4 } from "node:path";
 
@@ -17458,6 +17469,337 @@ function kxmUserStateRoot(options = {}) {
   return resolve2(base, "kxm");
 }
 
+// plugins/kxm/src/sync-transform.ts
+import { createHash as createHash3 } from "node:crypto";
+
+// plugins/kxm/src/redact.ts
+var SECRET_PATTERNS = [
+  /\bsk-[A-Za-z0-9_-]{8,}\b/g,
+  /\bsk-ant-[A-Za-z0-9_-]{8,}\b/g,
+  /\bghp_[A-Za-z0-9_]{20,}\b/g,
+  /\bgithub_pat_[A-Za-z0-9_]{20,}\b/g,
+  /\bxox[baprs]-[A-Za-z0-9-]{10,}\b/gi,
+  /\bBearer\s+[A-Za-z0-9._~+/=-]+\b/gi,
+  /\bya29\.[A-Za-z0-9._~+/-]+=*/g,
+  /\b1\/\/[A-Za-z0-9_-]+/g,
+  /\b1\/[A-Za-z0-9_-]{20,}/g,
+  /("?(?:access_token|refresh_token|id_token|sessionKey|session_key|claude_oauth_token|anthropicApiKey)"?\s*[:=]\s*")[^"]*(")/gi,
+  /\bKXM_[A-Z0-9_]*(TOKEN|SECRET|KEY)[A-Z0-9_]*=\S+/gi,
+  /\b(GITHUB_TOKEN|GH_TOKEN|KXM_AUTH_TOKEN|KXM_WORKFLOW_SIGNAL_SECRET|ANTHROPIC_API_KEY|ANTHROPIC_AUTH_TOKEN|CLAUDE_API_KEY)=\S+/gi,
+  /\b[A-Fa-f0-9]{64}\b/g
+];
+function redactSecrets(value) {
+  let result = value;
+  for (const pattern of SECRET_PATTERNS) {
+    result = result.replace(pattern, "[redacted]");
+  }
+  return result;
+}
+
+// plugins/kxm/src/sync-transform.ts
+var KXM_SYNC_EVENT_SCHEMA = "kxm.sync-event.v1";
+var KXM_SYNC_REDACTOR_VERSION = "redactor-v1";
+var KXM_DEFAULT_SYNC_POLICY = Object.freeze({
+  prompts: "title-only",
+  results: "bounded-summary",
+  evidence: "references",
+  artifacts: "metadata",
+  fileChanges: "paths-only",
+  rawLogs: false,
+  diffs: false,
+  environmentValues: false
+});
+var KXM_DEFAULT_SYNC_POLICY_REVISION = `sha256:${createHash3("sha256").update(kxmCanonicalJson(KXM_DEFAULT_SYNC_POLICY), "utf8").digest("hex")}`;
+var MIN_REGISTERED_SECRET_CHARS = 4;
+var REDACTED = "[redacted]";
+var PATH_REDACTED = "[path]";
+var CREDENTIAL_SHAPES = [
+  /-----BEGIN [A-Z ]*PRIVATE KEY-----[\s\S]*?(?:-----END [A-Z ]*PRIVATE KEY-----|$)/g,
+  /\bssh-(?:rsa|ed25519|dss|ecdsa-[a-z0-9-]+) AAAA[0-9A-Za-z+/=]+/g,
+  /\bAKIA[0-9A-Z]{16}\b/g,
+  /\bgh[opsu]_[A-Za-z0-9]{20,}\b/g,
+  /\b(?:api[_-]?key|token|secret|password|passwd)\s*[:=]\s*\S+/gi
+];
+var URL_USERINFO = /\b([a-z][a-z0-9+.-]*:\/\/)[^\s/@]+@/gi;
+var ABSOLUTE_PATHS = [
+  /\\\\[^\s\\"'`]+\\[^\s"'`]*/g,
+  // UNC
+  /\b[A-Za-z]:[\\/][^\s"'`]*/g,
+  // Windows drive
+  /(?<![\w.~:/-])~[\\/][^\s"'`]*/g,
+  // home
+  /(?<![\w.~:/-])\/(?:[\w.@%+-]+\/)*[\w.@%+-]+\/?/g
+  // POSIX
+];
+var CONTROL_CHARACTERS = /[\u0000-\u001F\u007F]/g;
+var KxmSyncRedactor = class {
+  values = /* @__PURE__ */ new Set();
+  register(value) {
+    const trimmed = value.trim();
+    if (trimmed.length >= MIN_REGISTERED_SECRET_CHARS) this.values.add(trimmed);
+  }
+  get size() {
+    return this.values.size;
+  }
+  /** Scrub one free-text value; `replaced` counts every substitution. */
+  scrub(input) {
+    let replaced = 0;
+    let text = input;
+    for (const secret of [...this.values].sort((left, right) => right.length - left.length)) {
+      const parts = text.split(secret);
+      if (parts.length > 1) {
+        replaced += parts.length - 1;
+        text = parts.join(REDACTED);
+      }
+    }
+    const substitute = (pattern, replacement) => {
+      text = text.replace(pattern, (...args) => {
+        replaced += 1;
+        return typeof replacement === "string" ? replacement : replacement(...args);
+      });
+    };
+    for (const pattern of CREDENTIAL_SHAPES) substitute(pattern, REDACTED);
+    substitute(URL_USERINFO, (_match, scheme) => `${scheme}${REDACTED}@`);
+    const shaped = redactSecrets(text);
+    if (shaped !== text) {
+      replaced += shaped.split(REDACTED).length - text.split(REDACTED).length;
+      text = shaped;
+    }
+    for (const pattern of ABSOLUTE_PATHS) substitute(pattern, PATH_REDACTED);
+    text = text.replace(CONTROL_CHARACTERS, " ").replace(/\s+/g, " ").trim();
+    return { text, replaced };
+  }
+};
+function isRecord(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function pickScalars(source, keys, redactor) {
+  if (!isRecord(source)) return void 0;
+  const result = {};
+  for (const key of keys) {
+    const value = source[key];
+    if (typeof value === "number" || typeof value === "boolean") {
+      result[key] = value;
+    } else if (typeof value === "string") {
+      if (redactor) {
+        const scrubbed = redactor.scrub(value);
+        if (scrubbed.text.length > 0) result[key] = scrubbed.text.slice(0, 200);
+      } else {
+        result[key] = value;
+      }
+    }
+  }
+  return Object.keys(result).length > 0 ? result : void 0;
+}
+var SyncPayloadBuilder = class {
+  payload = {};
+  omitted = /* @__PURE__ */ new Set();
+  replaced = 0;
+  redactor;
+  constructor(redactor) {
+    this.redactor = redactor;
+  }
+  /** Bounded, scrubbed free text; empty after scrubbing means absent. */
+  text(value, max) {
+    if (typeof value !== "string") return void 0;
+    const { text, replaced } = this.redactor.scrub(value);
+    this.replaced += replaced;
+    if (text.length === 0) return void 0;
+    return text.length > max ? `${text.slice(0, max - 1)}\u2026` : text;
+  }
+  /** A nested record rebuilt key by key, with the named keys scrubbed as text. */
+  record(source, keys, textKeys = {}) {
+    const scalars = pickScalars(source, keys.filter((key) => !(key in textKeys)));
+    const result = { ...scalars ?? {} };
+    if (isRecord(source)) {
+      for (const [key, max] of Object.entries(textKeys)) {
+        const value = this.text(source[key], max);
+        if (value !== void 0) result[key] = value;
+      }
+    }
+    return Object.keys(result).length > 0 ? result : void 0;
+  }
+  set(key, value) {
+    if (value !== void 0) this.payload[key] = value;
+  }
+};
+var SCALAR_FIELDS = [
+  "workflowId",
+  "promptHash",
+  "status",
+  "previousStatus",
+  "outcome",
+  "stepId",
+  "stepAttempt",
+  "fromStepId",
+  "toStepId",
+  "assignmentId",
+  "attemptId",
+  "agentId",
+  "instanceNo",
+  "scopeEpoch",
+  "resolutionAction"
+];
+var REF_KEYS = ["id", "kind", "hash", "status", "producerId"];
+var ARTIFACT_KEYS = ["id", "kind", "hash", "size", "classification", "availability"];
+var LEASE_KEYS = ["id", "fencingToken", "acquiredAt", "expiresAt", "operation"];
+var MAX_REFS = 64;
+var CARRIED_FIELDS = /* @__PURE__ */ new Set([
+  ...SCALAR_FIELDS,
+  "displayTitle",
+  "summary",
+  "reason",
+  "executor",
+  "model",
+  "timing",
+  "usage",
+  "evidenceRefs",
+  "artifacts",
+  "receipt",
+  "error",
+  "effect",
+  "lease",
+  "actor",
+  "resolvedBy",
+  "suppliedRefs",
+  "counts"
+]);
+var CONTROL_FIELDS = ["effect", "lease", "actor", "resolvedBy", "resolutionAction", "reason", "suppliedRefs", "outcome"];
+function buildPayload(source, builder) {
+  for (const key of SCALAR_FIELDS) {
+    const value = source[key];
+    if (typeof value === "string" || typeof value === "number") builder.set(key, value);
+  }
+  builder.set("displayTitle", builder.text(source.displayTitle, 200));
+  builder.set("summary", builder.text(source.summary, 1e3));
+  if (source.reason !== void 0) {
+    builder.set("reason", builder.text(source.reason, 1e3) ?? REDACTED);
+  }
+  builder.set("executor", builder.record(source.executor, ["id", "kind", "harness"], {
+    executorVersion: 128,
+    harnessVersion: 128,
+    helperGeneration: 256
+  }));
+  const model = builder.record(source.model, ["profile", "provider"], { model: 200, thinking: 64 });
+  if (model && isRecord(source.model) && Array.isArray(source.model.tags)) {
+    model.tags = source.model.tags.filter((tag) => typeof tag === "string").slice(0, 32);
+  }
+  builder.set("model", model);
+  builder.set("timing", builder.record(source.timing, ["startedAt", "finishedAt", "durationMs", "queueMs", "agentMs"]));
+  builder.set("usage", builder.record(source.usage, [
+    "inputTokens",
+    "outputTokens",
+    "cacheReadTokens",
+    "cacheWriteTokens",
+    "cost",
+    "currency",
+    "costKind"
+  ]));
+  const refs = (value, keys) => Array.isArray(value) ? value.slice(0, MAX_REFS).map((entry) => pickScalars(entry, keys)).filter((entry) => entry !== void 0) : void 0;
+  builder.set("evidenceRefs", refs(source.evidenceRefs, REF_KEYS));
+  builder.set("suppliedRefs", refs(source.suppliedRefs, REF_KEYS));
+  builder.set("artifacts", refs(source.artifacts, ARTIFACT_KEYS));
+  if (isRecord(source.receipt)) {
+    const receipt = builder.record(source.receipt, ["provider", "kind", "hash", "observedAt"], { id: 512 });
+    if (receipt) builder.set("receipts", [receipt]);
+    if (source.receipt.url !== void 0) builder.omitted.add("receipt.url");
+  }
+  builder.set("error", builder.record(source.error, ["class", "retryable"], { component: 128 }));
+  if (isRecord(source.effect)) {
+    const effect = pickScalars(source.effect, ["id", "idempotencyKeyHash"], builder.redactor) ?? {};
+    const policy = pickScalars(source.effect.policy, ["class", "sharedMutable", "idempotencyKey", "receiptQuery"], builder.redactor);
+    if (policy) effect.policy = policy;
+    builder.set("effect", effect);
+  }
+  builder.set("lease", pickScalars(source.lease, LEASE_KEYS, builder.redactor));
+  builder.set("actor", builder.record(source.actor, ["kind"], { id: 200 }));
+  builder.set("resolvedBy", builder.record(source.resolvedBy, ["kind"], { id: 200 }));
+  if (isRecord(source.counts)) {
+    const counts = Object.fromEntries(Object.entries(source.counts).filter((entry) => Number.isInteger(entry[1]) && entry[1] >= 0).slice(0, 32));
+    builder.set("counts", counts);
+  }
+}
+function envelope(event, policyRevision, payload, fieldsOmitted, valuesReplaced) {
+  return {
+    schema: KXM_SYNC_EVENT_SCHEMA,
+    sourceEventId: event.eventId,
+    eventType: event.eventType,
+    projectId: event.projectId,
+    runId: event.runId,
+    homeRuntimeId: event.homeRuntimeId,
+    sequence: event.sequence,
+    occurredAt: event.occurredAt,
+    configRevision: event.configRevision,
+    memoryRevision: event.memoryRevision,
+    executorPolicyRevision: event.executorPolicyRevision,
+    toolPolicyRevision: event.toolPolicyRevision,
+    syncPolicyRevision: policyRevision,
+    redaction: {
+      version: KXM_SYNC_REDACTOR_VERSION,
+      fieldsOmitted: [...new Set(fieldsOmitted)].sort().slice(0, 128),
+      valuesReplaced: Math.min(valuesReplaced, 1e5)
+    },
+    payload
+  };
+}
+function deriveKxmSyncEvent(event, options = {}) {
+  const redactor = options.redactor ?? new KxmSyncRedactor();
+  const policyRevision = options.policyRevision ?? KXM_DEFAULT_SYNC_POLICY_REVISION;
+  const source = isRecord(event.payload) ? event.payload : {};
+  const builder = new SyncPayloadBuilder(redactor);
+  buildPayload(source, builder);
+  const omitted = new Set(builder.omitted);
+  for (const key of Object.keys(source)) if (!CARRIED_FIELDS.has(key)) omitted.add(key);
+  if (event.protectedPayload !== void 0) omitted.add("protectedPayload");
+  const payload = Object.keys(builder.payload).length > 0 ? builder.payload : { counts: {} };
+  const full = envelope(event, policyRevision, payload, omitted, builder.replaced);
+  if (syncEventSchemaErrors(full) === void 0) return full;
+  const degradedPayload = { degraded: true };
+  for (const key of CONTROL_FIELDS) {
+    const value = builder.payload[key];
+    const restoreNested = (built, orig) => {
+      if (!isRecord(orig)) return built !== void 0 ? built : "[redacted]";
+      const result = {};
+      const builtRecord = isRecord(built) ? built : {};
+      for (const [k, v] of Object.entries(orig)) {
+        const builtValue = builtRecord[k];
+        if (builtValue === void 0 || typeof builtValue === "string" && builtValue.trim().length === 0) {
+          result[k] = isRecord(v) ? restoreNested(void 0, v) : "[redacted]";
+        } else {
+          result[k] = builtValue;
+        }
+      }
+      return result;
+    };
+    if (value === void 0) {
+      const sourceValue = source[key];
+      if (sourceValue !== void 0) {
+        degradedPayload[key] = restoreNested(void 0, sourceValue);
+      }
+    } else if (typeof value === "string" && value.trim().length === 0) {
+      degradedPayload[key] = "[redacted]";
+    } else if (isRecord(value)) {
+      degradedPayload[key] = restoreNested(value, source[key]);
+    } else {
+      degradedPayload[key] = value;
+    }
+  }
+  const degradedOmitted = new Set(omitted);
+  for (const key of Object.keys(builder.payload)) if (!(key in degradedPayload)) degradedOmitted.add(key);
+  const degraded = envelope(event, policyRevision, degradedPayload, degradedOmitted, builder.replaced);
+  const errors = syncEventSchemaErrors(degraded);
+  if (errors === void 0) return degraded;
+  throw new KxmConfigError([{
+    phase: "schema",
+    code: "sync_event_invalid",
+    file: `${event.runId}#${event.sequence}`,
+    message: `event cannot be derived into kxm.sync-event.v1: ${errors}`
+  }]);
+}
+function kxmSyncEventBytes(event) {
+  return kxmCanonicalJson(event);
+}
+
 // plugins/kxm/src/database.ts
 import {
   chmodSync,
@@ -17708,7 +18050,7 @@ function projectRuntimeKey(projectRoot) {
     canonical = resolve4(projectRoot);
   }
   const folded = process.platform === "win32" ? canonical.toLocaleLowerCase("en-US") : canonical;
-  return createHash3("sha256").update(folded, "utf8").digest("hex").slice(0, 24);
+  return createHash4("sha256").update(folded, "utf8").digest("hex").slice(0, 24);
 }
 var KXM_REGISTRY_SCHEMA_VERSION = 1;
 var REGISTRY_TABLES = {
@@ -17828,6 +18170,15 @@ var KxmRuntimeRegistry = class {
     return this.readSupervisorRow();
   }
   /** Register or revalidate a project's home binding. Home Runtime is immutable. */
+  /** All projects registered to this Runtime, for restart recovery: the
+   * supervisor needs to reopen their contexts so pending outbox rows resume
+   * syncing and presence keeps beating. */
+  projectsForRuntime(homeRuntimeId) {
+    const rows = this.database.prepare(
+      "SELECT project_root, project_id FROM projects WHERE home_runtime_id = ? ORDER BY registered_at"
+    ).all(homeRuntimeId);
+    return rows.map((row) => ({ projectRoot: row.project_root, projectId: row.project_id }));
+  }
   registerProject(registration) {
     const projectRoot = resolve4(registration.projectRoot);
     const projectKey = projectRuntimeKey(projectRoot);
@@ -17904,7 +18255,7 @@ var KxmRuntimeRegistry = class {
 var KXM_RUN_EVENT_SCHEMA = "kxm.run-event.v1";
 function hashKxmDriveLog(events) {
   const body = events.map((event) => `${event.eventId}:${event.sequence}`).join("\n");
-  return `sha256:${createHash3("sha256").update(body, "utf8").digest("hex")}`;
+  return `sha256:${createHash4("sha256").update(body, "utf8").digest("hex")}`;
 }
 function verifyKxmDriveReceipt(receipt, events, foldedStatus, binding) {
   const reasons = [];
@@ -17929,7 +18280,7 @@ function verifyKxmDriveReceipt(receipt, events, foldedStatus, binding) {
   if (reasons.length === 0) return { verified: true };
   return { verified: false, divergence: reasons.join("; ") };
 }
-var KXM_EVENT_STORE_SCHEMA_VERSION = 5;
+var KXM_EVENT_STORE_SCHEMA_VERSION = 6;
 var KXM_DRIVE_RECEIPT_SCHEMA = "kxm.drive-receipt.v1";
 var DRIVE_RECEIPT_MAX_BYTES = 8 * 1024;
 var EVENT_STORE_TABLES = {
@@ -18034,7 +18385,8 @@ var EVENT_STORE_TABLES = {
     "schema",
     "record"
   ],
-  project_controls: ["project_id", "paused", "reason", "updated_at", "actor", "schema", "record"]
+  project_controls: ["project_id", "paused", "reason", "updated_at", "actor", "schema", "record"],
+  outbox: ["seq", "run_id", "sequence", "sync_event", "attempted_at", "acked_at"]
 };
 var KXM_EVENT_STORE_TABLE_NAMES = Object.keys(EVENT_STORE_TABLES).sort();
 var EVENT_STORE_SCHEMA = `
@@ -18222,9 +18574,22 @@ CREATE TABLE project_controls (
   schema TEXT NOT NULL,
   record TEXT NOT NULL
 ) STRICT;
+CREATE TABLE IF NOT EXISTS outbox (
+  seq INTEGER PRIMARY KEY AUTOINCREMENT,
+  run_id TEXT NOT NULL,
+  sequence INTEGER NOT NULL,
+  sync_event TEXT NOT NULL,
+  attempted_at TEXT,
+  acked_at TEXT,
+  UNIQUE (run_id, sequence)
+) STRICT;
+CREATE INDEX outbox_pending ON outbox(seq) WHERE acked_at IS NULL;
 `;
 var KxmRunEventStore = class {
   path;
+  /** Secret values registered here are replaced in every sync object this
+   * store derives. In memory only: they are never written anywhere. */
+  syncRedactor = new KxmSyncRedactor();
   database;
   constructor(path) {
     this.path = resolve4(path);
@@ -18307,6 +18672,15 @@ var KxmRunEventStore = class {
     `).get(runId);
     return row ? runFromRow(row) : void 0;
   }
+  /** All projects registered to this Runtime, for restart recovery: the
+   * supervisor needs to reopen their contexts so pending outbox rows resume
+   * syncing and presence keeps beating. */
+  projectsForRuntime(homeRuntimeId) {
+    const rows = this.database.prepare(
+      "SELECT project_root, project_id FROM projects WHERE home_runtime_id = ? ORDER BY registered_at"
+    ).all(homeRuntimeId);
+    return rows.map((row) => ({ projectRoot: row.project_root, projectId: row.project_id }));
+  }
   runsForProject(projectId, limit = 50) {
     const rows = this.database.prepare(`
       SELECT run_id, project_id, home_runtime_id, workflow_id, prompt_sha256, status, config_revision, memory_revision, executor_policy_revision, tool_policy_revision, created_at, updated_at
@@ -18346,6 +18720,39 @@ var KxmRunEventStore = class {
       event.schema,
       event.homeRuntimeId
     );
+    const syncEvent = deriveKxmSyncEvent(event, { redactor: this.syncRedactor });
+    this.database.prepare("INSERT INTO outbox (run_id, sequence, sync_event) VALUES (?, ?, ?)").run(event.runId, event.sequence, kxmSyncEventBytes(syncEvent));
+  }
+  /** Unacknowledged outbox rows after `afterSeq`, in outbox order, oldest first. */
+  pendingOutbox(limit = 100, afterSeq = 0) {
+    const rows = this.database.prepare(`
+      SELECT seq, run_id, sequence, sync_event, attempted_at, acked_at
+      FROM outbox WHERE acked_at IS NULL AND seq > ? ORDER BY seq ASC LIMIT ?
+    `).all(afterSeq, limit);
+    return rows.map(outboxFromRow);
+  }
+  /** Every outbox row of one run, acknowledged or not, in sequence order. */
+  outboxForRun(runId) {
+    const rows = this.database.prepare(`
+      SELECT seq, run_id, sequence, sync_event, attempted_at, acked_at
+      FROM outbox WHERE run_id = ? ORDER BY sequence ASC
+    `).all(runId);
+    return rows.map(outboxFromRow);
+  }
+  markOutboxAttempted(seqs, at) {
+    const statement = this.database.prepare("UPDATE outbox SET attempted_at = ? WHERE seq = ? AND acked_at IS NULL");
+    this.transaction(() => {
+      for (const seq of seqs) statement.run(at, seq);
+    });
+  }
+  /** Advance the cursor: the hub holds these rows now. Returns rows newly acked. */
+  ackOutbox(seqs, at) {
+    const statement = this.database.prepare("UPDATE outbox SET acked_at = ? WHERE seq = ? AND acked_at IS NULL");
+    return this.transaction(() => {
+      let changed = 0;
+      for (const seq of seqs) changed += Number(statement.run(at, seq).changes);
+      return changed;
+    });
   }
   events(runId, afterSequence = 0, limit = 200) {
     const rows = this.database.prepare(`
@@ -18862,6 +19269,16 @@ function parseDriveReceipt(raw) {
   validateDriveReceipt(parsed, "drive-receipt");
   return parsed;
 }
+function outboxFromRow(row) {
+  return {
+    seq: row.seq,
+    runId: row.run_id,
+    sequence: row.sequence,
+    syncEvent: row.sync_event,
+    ...row.attempted_at !== null ? { attemptedAt: row.attempted_at } : {},
+    ...row.acked_at !== null ? { ackedAt: row.acked_at } : {}
+  };
+}
 function runFromRow(row) {
   if (typeof row.memory_revision !== "string" || row.memory_revision.length === 0) {
     throw runtimeError("runtime_schema_shape_invalid", row.run_id, "memory_revision is required");
@@ -18984,7 +19401,7 @@ function gateRowContentHash(table, row) {
   const copy = { ...row };
   delete copy.contentHash;
   void table;
-  return `sha256:${createHash3("sha256").update(kxmCanonicalJson(copy), "utf8").digest("hex")}`;
+  return `sha256:${createHash4("sha256").update(kxmCanonicalJson(copy), "utf8").digest("hex")}`;
 }
 function assertClosedGateObservation(kind, row, id = "observation") {
   if (row.completeness === "incomplete") return;
@@ -19214,7 +19631,7 @@ function capabilityFromRow(row) {
 }
 
 // plugins/kxm/src/runtime-service.ts
-import { createHash as createHash5 } from "node:crypto";
+import { createHash as createHash6 } from "node:crypto";
 import { existsSync as existsSync6, readdirSync as readdirSync3, readFileSync as readFileSync4 } from "node:fs";
 import { join as join6 } from "node:path";
 
@@ -20420,7 +20837,7 @@ function isTerminalRunStatus(status) {
 }
 
 // plugins/kxm/src/engine-plan.ts
-import { createHash as createHash4 } from "node:crypto";
+import { createHash as createHash5 } from "node:crypto";
 
 // plugins/kxm/src/engine-compile.ts
 var KXM_COMPILED_WORKFLOW_SCHEMA = "kxm.compiled-workflow.v1";
@@ -20570,7 +20987,7 @@ function compileStep(step, index, stepIndex, requirePlanHash, sink) {
   const maxAttempts = compileCountField(step.maxAttempts, 1, `${id}.maxAttempts`, id, sink);
   const timeoutMs = compileOptionalDuration(step.timeoutMs, `${id}.timeoutMs`, id, sink);
   const assignments = compileAssignments(step, id, agent, sink);
-  const join14 = compileJoin(step, id, sink);
+  const join17 = compileJoin(step, id, sink);
   const requiredEvidence = compileEvidence(step, id, sink);
   const transitions = compileTransitions(step, id, index, stepIndex, sink);
   const outcomes = Object.keys(transitions).sort(compareCodeUnits4);
@@ -20598,7 +21015,7 @@ function compileStep(step, index, stepIndex, requirePlanHash, sink) {
     transitions: orderedTransitions,
     requiresPlanHash: requirePlanHash.includes(id),
     assignments,
-    join: join14
+    join: join17
   };
   if (kind === "agent" || kind === "moa") {
     if (!agent) return void 0;
@@ -20648,15 +21065,15 @@ function compileAssignments(step, stepId, primaryAgentId, sink) {
   };
 }
 function compileJoin(step, stepId, sink) {
-  const join14 = objectValue2(step.join);
-  if (!join14) return { strategy: "all" };
-  const declared = stringValue2(join14.strategy);
+  const join17 = objectValue2(step.join);
+  if (!join17) return { strategy: "all" };
+  const declared = stringValue2(join17.strategy);
   const strategy = declared && JOIN_STRATEGIES.has(declared) ? declared : "all";
-  const minimumPassed = compileOptionalCount(join14.minimumPassed, `${stepId}.join.minimumPassed`, stepId, sink);
+  const minimumPassed = compileOptionalCount(join17.minimumPassed, `${stepId}.join.minimumPassed`, stepId, sink);
   const compiled = {
     strategy,
     ...minimumPassed !== void 0 ? { minimumPassed } : {},
-    ...typeof join14.cancelRemaining === "boolean" ? { cancelRemaining: join14.cancelRemaining } : {}
+    ...typeof join17.cancelRemaining === "boolean" ? { cancelRemaining: join17.cancelRemaining } : {}
   };
   return compiled;
 }
@@ -20967,10 +21384,10 @@ var JOIN_OPTIONAL = ["minimumPassed", "cancelRemaining"];
 var EVIDENCE_REQUIRED = ["key", "kind", "minimum", "reusableAcrossAttempts"];
 var EVIDENCE_OPTIONAL = ["producerPolicy"];
 function kxmSha256(input) {
-  return `sha256:${createHash4("sha256").update(input, "utf8").digest("hex")}`;
+  return `sha256:${createHash5("sha256").update(input, "utf8").digest("hex")}`;
 }
-function hashKxmRunPlanEnvelope(envelope) {
-  return kxmSha256(kxmCanonicalJson(envelope));
+function hashKxmRunPlanEnvelope(envelope2) {
+  return kxmSha256(kxmCanonicalJson(envelope2));
 }
 function freezeKxmCompiledPlan(plan) {
   const steps = /* @__PURE__ */ Object.create(null);
@@ -21017,12 +21434,12 @@ function parseKxmRunPlanEnvelope(raw, run, expectedHash) {
   } catch {
     throw runtimeError("run_plan_corrupt", run.runId, "run plan envelope is not JSON");
   }
-  const envelope = parseEnvelope(parsed, run);
-  const hash = hashKxmRunPlanEnvelope(envelope);
+  const envelope2 = parseEnvelope(parsed, run);
+  const hash = hashKxmRunPlanEnvelope(envelope2);
   if (hash !== expectedHash) {
     throw runtimeError("run_plan_corrupt", run.runId, "run plan envelope hash does not match");
   }
-  return envelope;
+  return envelope2;
 }
 function rehydrateKxmCompiledPlanFromStore(store, run) {
   return loadPinnedEnvelope(store, run).plan;
@@ -21532,7 +21949,7 @@ function gateRegistryHash(registryValue) {
 }
 
 // plugins/kxm/src/engine-evidence.ts
-function verifyKxmGateEvidence(store, run, envelope, events, state) {
+function verifyKxmGateEvidence(store, run, envelope2, events, state) {
   const attempts = store.gateAttemptsForRun(run.runId);
   const observations = store.gateObservationsForRun(run.runId);
   const evidence = store.gateEvidenceForRun(run.runId);
@@ -21550,7 +21967,7 @@ function verifyKxmGateEvidence(store, run, envelope, events, state) {
     const attemptId = stringField(event, "attemptId");
     const row = attemptById.get(attemptId);
     if (!row) throw runtimeError("gate_attempt_pin_mismatch", run.runId, `effect.intent_recorded ${event.eventId} has no gate_attempts row`);
-    assertAttemptMatchesEvent(run, envelope, state, event, row);
+    assertAttemptMatchesEvent(run, envelope2, state, event, row);
   }
   for (const event of observedEvents) {
     const attemptId = stringField(event, "attemptId");
@@ -21613,7 +22030,7 @@ function verifyKxmGateEvidence(store, run, envelope, events, state) {
       if (row.outcome !== recomputed || event.payload.outcome !== recomputed) {
         throw runtimeError("gate_evidence_hash_mismatch", run.runId, "evidence outcome does not match the observation and expect");
       }
-      const step = envelope.plan.steps[row.stepId];
+      const step = envelope2.plan.steps[row.stepId];
       const required = step?.requiredEvidence.filter((item) => item.kind === "gate") ?? [];
       const expectedKey = required.length === 1 ? required[0].key : null;
       if (row.evidenceKey !== expectedKey) {
@@ -21709,7 +22126,7 @@ function lastEffectByAttempt(events) {
   }
   return last;
 }
-function assertAttemptMatchesEvent(run, envelope, state, event, row) {
+function assertAttemptMatchesEvent(run, envelope2, state, event, row) {
   const effectId = event.payload.effect?.id;
   if (row.effectId !== effectId || row.intentEventId !== event.eventId) {
     throw runtimeError("gate_attempt_pin_mismatch", run.runId, "intent event does not match the gate attempt");
@@ -21720,14 +22137,14 @@ function assertAttemptMatchesEvent(run, envelope, state, event, row) {
   if (row.stepId !== event.payload.stepId || row.stepAttempt !== event.payload.stepAttempt || row.assignmentId !== event.payload.assignmentId || row.attemptId !== event.payload.attemptId) {
     throw runtimeError("gate_attempt_pin_mismatch", run.runId, "gate attempt identity does not match the intent payload");
   }
-  const step = envelope.plan.steps[row.stepId];
+  const step = envelope2.plan.steps[row.stepId];
   if (!step || step.kind !== "gate") {
     throw runtimeError("gate_attempt_pin_mismatch", run.runId, "gate attempt step is not a gate");
   }
   if (row.gateId !== step.gate || row.expect !== step.expect) {
     throw runtimeError("gate_attempt_pin_mismatch", run.runId, "gate attempt gate/expect do not match the plan");
   }
-  const definition = envelope.gates.definitions[step.gate];
+  const definition = envelope2.gates.definitions[step.gate];
   if (!definition || definition.kind !== row.gateKind) {
     throw runtimeError("gate_attempt_pin_mismatch", run.runId, "gate attempt kind does not match the pinned definition");
   }
@@ -21735,14 +22152,14 @@ function assertAttemptMatchesEvent(run, envelope, state, event, row) {
   if (row.gateDefinitionHash !== expectedDefinitionHash) {
     throw runtimeError("gate_attempt_pin_mismatch", run.runId, "gate_definition_hash does not match the pinned definition");
   }
-  if (!envelope.gates.registry || row.registryHash !== envelope.gates.registry.hash) {
+  if (!envelope2.gates.registry || row.registryHash !== envelope2.gates.registry.hash) {
     throw runtimeError("gate_attempt_pin_mismatch", run.runId, "registry_hash does not match the pinned registry");
   }
-  const planRowHash = envelope && state.runPlanHash;
+  const planRowHash = envelope2 && state.runPlanHash;
   if (row.runPlanHash !== planRowHash) {
     throw runtimeError("gate_attempt_pin_mismatch", run.runId, "run_plan_hash does not match the pinned plan");
   }
-  if (row.controlProjectKey !== envelope.gates.controlRoot.projectKey) {
+  if (row.controlProjectKey !== envelope2.gates.controlRoot.projectKey) {
     throw runtimeError("gate_attempt_pin_mismatch", run.runId, "control_project_key does not match the envelope");
   }
 }
@@ -21980,12 +22397,12 @@ function enqueueKxmScheduledRun(storePath, runId, configRevision, bound, start)
   if (owner.admitted.has(runId) || owner.queue.some((item) => item.runId === runId)) {
     return Promise.reject(runtimeError("run_busy", runId, `run ${runId} is already admitted or queued`));
   }
-  return new Promise((resolve6, reject) => {
+  return new Promise((resolve8, reject) => {
     owner.queue.push({
       runId,
       configRevision,
       bound,
-      start: (token) => start(token).then(resolve6, reject),
+      start: (token) => start(token).then(resolve8, reject),
       fail: (error) => reject(error)
     });
     pump(storePath, owner);
@@ -22014,7 +22431,7 @@ function compareCodeUnits5(left, right) {
   return left < right ? -1 : left > right ? 1 : 0;
 }
 function sha256Of(input) {
-  return `sha256:${createHash5("sha256").update(input, "utf8").digest("hex")}`;
+  return `sha256:${createHash6("sha256").update(input, "utf8").digest("hex")}`;
 }
 function objectValue3(value) {
   return value !== null && typeof value === "object" && !Array.isArray(value) ? value : void 0;
@@ -22062,7 +22479,7 @@ function collectMemoryFiles(dir, baseDir, ignoreSubdirs = /* @__PURE__ */ new Se
   return results;
 }
 function computeKxmMemoryRevision(bundle, options = {}) {
-  const hash = createHash5("sha256");
+  const hash = createHash6("sha256");
   const memoryDir = options.memoryDir ?? join6(bundle.projectRoot, ".kxm", "memory");
   const memoryFiles = collectMemoryFiles(memoryDir, memoryDir, /* @__PURE__ */ new Set(["candidates"])).sort((left, right) => compareCodeUnits5(left.relPath, right.relPath));
   for (const file of memoryFiles) {
@@ -22213,7 +22630,7 @@ function acceptKxmRun(context, bundle, request, options = {}) {
   }
   const revisions = kxmPolicyRevisions(bundle, options);
   const memoryRevision = options.memoryRevision ?? revisions.memoryRevision;
-  const promptSha256 = `sha256:${createHash5("sha256").update(request.prompt, "utf8").digest("hex")}`;
+  const promptSha256 = `sha256:${createHash6("sha256").update(request.prompt, "utf8").digest("hex")}`;
   return context.eventStore.transaction(() => {
     const prior = context.eventStore.command(commandId);
     if (prior) {
@@ -22288,21 +22705,21 @@ function foldStoredKxmRun(context, run) {
   if (!planRow && events.some((event) => event.eventType.startsWith("step.") || event.eventType.startsWith("effect.") || event.payload.status === "preparing" || event.payload.status === "running" || event.payload.status === "cancelling")) {
     throw runtimeError("run_plan_missing", run.runId, "run reached preparing or later without a pinned plan");
   }
-  const envelope = planRow ? loadKxmRunPlanEnvelope(context.eventStore, run) : void 0;
-  const state = foldKxmRunState(run, envelope?.plan, events, envelope ? {
+  const envelope2 = planRow ? loadKxmRunPlanEnvelope(context.eventStore, run) : void 0;
+  const state = foldKxmRunState(run, envelope2?.plan, events, envelope2 ? {
     observationLookup: (attemptId, observationId) => {
       const row = context.eventStore.gateObservationForAttempt(attemptId);
       if (!row || row.observationId !== observationId) return void 0;
       return { completeness: row.completeness };
     },
     gateKind: (stepId) => {
-      const step = envelope.plan.steps[stepId];
+      const step = envelope2.plan.steps[stepId];
       if (!step || step.kind !== "gate") return void 0;
-      return envelope.gates.definitions[step.gate]?.kind;
+      return envelope2.gates.definitions[step.gate]?.kind;
     },
-    projectLimits: envelope.projectLimits
+    projectLimits: envelope2.projectLimits
   } : {});
-  if (envelope) verifyKxmGateEvidence(context.eventStore, run, envelope, events, state);
+  if (envelope2) verifyKxmGateEvidence(context.eventStore, run, envelope2, events, state);
   assertStoredProjection(context, run);
   return state;
 }
@@ -22458,7 +22875,7 @@ function cancelKxmRun(context, runId, options = {}) {
 import { join as join12 } from "node:path";
 
 // plugins/kxm/src/oneshot-evidence.ts
-import { createHash as createHash6, randomUUID as randomUUID3 } from "node:crypto";
+import { createHash as createHash7, randomUUID as randomUUID3 } from "node:crypto";
 import { lstat, mkdir, open, rename } from "node:fs/promises";
 import { join as join7 } from "node:path";
 var ONESHOT_EVIDENCE_SCHEMA = "kxm.oneshot-evidence.v2";
@@ -22466,7 +22883,7 @@ var RETIRED_ONESHOT_EVIDENCE_SCHEMAS = /* @__PURE__ */ new Set(["kxm.oneshot-evi
 var TEXT_LIMIT = 4 * 1024 * 1024;
 var ARGV_LIMIT = 64 * 1024;
 var RECORD_LIMIT = 16 * 1024 * 1024;
-var digest = (value) => `sha256:${createHash6("sha256").update(value).digest("hex")}`;
+var digest = (value) => `sha256:${createHash7("sha256").update(value).digest("hex")}`;
 function parseOneShotEvidenceRecord(bytes) {
   let parsed;
   try {
@@ -22576,7 +22993,7 @@ async function beginOneShotEvidence(root, intent, sensitive) {
 
 // plugins/kxm/src/prices.ts
 var import_yaml3 = __toESM(require_dist(), 1);
-import { createHash as createHash7 } from "node:crypto";
+import { createHash as createHash8 } from "node:crypto";
 import { existsSync as existsSync7, readFileSync as readFileSync5, statSync } from "node:fs";
 import { join as join8 } from "node:path";
 
@@ -22639,7 +23056,7 @@ function hashPriceCatalog(catalog) {
       }))
     })).sort((a, b) => a.id.localeCompare(b.id))
   };
-  return createHash7("sha256").update(JSON.stringify(canonical), "utf8").digest("hex");
+  return createHash8("sha256").update(JSON.stringify(canonical), "utf8").digest("hex");
 }
 function parsePriceCatalog(text) {
   const parsed = (0, import_yaml3.parse)(text);
@@ -22740,7 +23157,7 @@ function loadPriceCatalog(rootOrPath) {
 
 // plugins/kxm/src/engine.ts
 var import_yaml5 = __toESM(require_dist(), 1);
-import { createHash as createHash10, randomBytes, timingSafeEqual } from "node:crypto";
+import { createHash as createHash11, randomBytes, timingSafeEqual } from "node:crypto";
 import { existsSync as existsSync9, readFileSync as readFileSync7 } from "node:fs";
 import { join as join11 } from "node:path";
 
@@ -23122,7 +23539,7 @@ function evaluateArtifactsGate(context, definition) {
 
 // plugins/kxm/src/engine-command.ts
 import { spawn as spawn2 } from "node:child_process";
-import { createHash as createHash8 } from "node:crypto";
+import { createHash as createHash9 } from "node:crypto";
 
 // plugins/kxm/src/safety-integrity.ts
 var DESTRUCTIVE_COMMAND_PATTERNS = Object.freeze([
@@ -23159,7 +23576,7 @@ function createCommandObserver(input) {
   return new CommandObserver(input);
 }
 var StreamDigest = class {
-  hash = createHash8("sha256");
+  hash = createHash9("sha256");
   bytes = 0;
   complete = 0;
   digest() {
@@ -23234,8 +23651,8 @@ var CommandObserver = class {
     this.requestStop("error", "lost-close");
   }
   run() {
-    return new Promise((resolve6) => {
-      this.resolveOutcome = resolve6;
+    return new Promise((resolve8) => {
+      this.resolveOutcome = resolve8;
       try {
         this.start();
       } catch (error) {
@@ -23579,9 +23996,9 @@ function schedule(ms, fn) {
 }
 
 // plugins/kxm/src/engine-gate-records.ts
-function recordGateIntentInTransaction(context, run, envelope, stepId) {
-  const step = requireGateStep(envelope, stepId, run.runId);
-  const definition = envelope.gates.definitions[step.gate];
+function recordGateIntentInTransaction(context, run, envelope2, stepId) {
+  const step = requireGateStep(envelope2, stepId, run.runId);
+  const definition = envelope2.gates.definitions[step.gate];
   if (!definition || definition.kind === "reserved") {
     throw runtimeError("gate_row_invalid", run.runId, "reserved gates cannot record intent in this slice");
   }
@@ -23634,9 +24051,9 @@ function recordGateIntentInTransaction(context, run, envelope, stepId) {
     gateKind: definition.kind,
     expect: step.expect,
     gateDefinitionHash: gateDefinitionHash(step.gate, definition),
-    registryHash: envelope.gates.registry.hash,
-    runPlanHash: envelope && folded.runPlanHash ? folded.runPlanHash : hashFromStore(context, run.runId),
-    controlProjectKey: envelope.gates.controlRoot.projectKey,
+    registryHash: envelope2.gates.registry.hash,
+    runPlanHash: envelope2 && folded.runPlanHash ? folded.runPlanHash : hashFromStore(context, run.runId),
+    controlProjectKey: envelope2.gates.controlRoot.projectKey,
     producerId: "kxm-gate",
     intentEventId: intent.eventId,
     contentHash: ""
@@ -23646,8 +24063,8 @@ function recordGateIntentInTransaction(context, run, envelope, stepId) {
   context.eventStore.insertGateAttempt(withHash);
   return persist(context, run, now, seq.events.at(-1).sequence);
 }
-function recordGateSpawnedInTransaction(context, run, envelope, stepId) {
-  const ids = requireIntent(context, run, envelope, stepId);
+function recordGateSpawnedInTransaction(context, run, envelope2, stepId) {
+  const ids = requireIntent(context, run, envelope2, stepId);
   if (ids.gateKind !== "command") throw runtimeError("gate_row_invalid", run.runId, "effect.dispatched is command-only");
   const now = (/* @__PURE__ */ new Date()).toISOString();
   const seq = sequencer(context, run, now);
@@ -23663,8 +24080,8 @@ function recordGateSpawnedInTransaction(context, run, envelope, stepId) {
   for (const event of seq.events) context.eventStore.appendEvent(event);
   return persist(context, run, now, seq.events.at(-1).sequence);
 }
-function recordGateSettlementInTransaction(context, run, envelope, stepId, observation) {
-  const ids = requireIntent(context, run, envelope, stepId);
+function recordGateSettlementInTransaction(context, run, envelope2, stepId, observation) {
+  const ids = requireIntent(context, run, envelope2, stepId);
   assertClosedGateObservation(ids.gateKind, observation);
   const outcome = computeGateEvidenceOutcome(ids.gateKind, ids.expect, observation);
   const now = (/* @__PURE__ */ new Date()).toISOString();
@@ -23704,7 +24121,7 @@ function recordGateSettlementInTransaction(context, run, envelope, stepId, obser
     stepAttempt: ids.stepAttempt,
     assignmentId: ids.assignmentId,
     effectId: ids.effectId,
-    evidenceKey: evidenceKeyFor(envelope, stepId),
+    evidenceKey: evidenceKeyFor(envelope2, stepId),
     kind: "gate",
     expect: ids.expect,
     outcome,
@@ -23723,15 +24140,15 @@ function recordGateSettlementInTransaction(context, run, envelope, stepId, obser
   evidenceDraft.settledEventId = settled.eventId;
   evidenceDraft.contentHash = gateRowContentHash("gate_evidence", { ...evidenceDraft, contentHash: "" });
   settled.payload.evidenceRefs[0].hash = evidenceDraft.contentHash;
-  appendEvaluatedTail(seq, envelope, ids, stepId, outcome);
+  appendEvaluatedTail(seq, envelope2, ids, stepId, outcome);
   for (const event of seq.events) context.eventStore.appendEvent(event);
   context.eventStore.insertGateObservation(observationRow);
   context.eventStore.insertGateEvidence(evidenceDraft);
   context.eventStore.settleCapability(ids.attemptId, "settled");
   return persist(context, run, now, seq.events.at(-1).sequence);
 }
-function recordGateNoStartInTransaction(context, run, envelope, stepId, observation) {
-  const ids = requireIntent(context, run, envelope, stepId);
+function recordGateNoStartInTransaction(context, run, envelope2, stepId, observation) {
+  const ids = requireIntent(context, run, envelope2, stepId);
   assertClosedGateObservation(ids.gateKind, observation);
   if (observation.completeness !== "no-start") {
     throw runtimeError("gate_row_invalid", run.runId, "no-start proof requires spawned 0 and completeness no-start");
@@ -23784,8 +24201,8 @@ function recordGateNoStartInTransaction(context, run, envelope, stepId, observat
   context.eventStore.settleCapability(ids.attemptId, "settled");
   return persist(context, run, now, seq.events.at(-1).sequence);
 }
-function recordGateUncertainInTransaction(context, run, envelope, stepId, reason, observation) {
-  const ids = requireIntent(context, run, envelope, stepId);
+function recordGateUncertainInTransaction(context, run, envelope2, stepId, reason, observation) {
+  const ids = requireIntent(context, run, envelope2, stepId);
   if (observation.completeness !== "incomplete") {
     throw runtimeError("gate_row_invalid", run.runId, "uncertainty observation must be incomplete");
   }
@@ -23814,8 +24231,8 @@ function recordGateUncertainInTransaction(context, run, envelope, stepId, reason
   context.eventStore.insertGateObservation(observationRow);
   return persist(context, run, now, seq.events.at(-1).sequence);
 }
-function recordGateCancelObservedInTransaction(context, run, envelope, stepId, observation) {
-  const ids = requireIntent(context, run, envelope, stepId);
+function recordGateCancelObservedInTransaction(context, run, envelope2, stepId, observation) {
+  const ids = requireIntent(context, run, envelope2, stepId);
   assertClosedGateObservation(ids.gateKind, observation);
   if (observation.completeness !== "complete") {
     throw runtimeError("gate_row_invalid", run.runId, "cancel-after-observation requires a complete observation");
@@ -23874,19 +24291,19 @@ function recordGateCancelObservedInTransaction(context, run, envelope, stepId, o
   context.eventStore.settleCapability(ids.attemptId, "settled");
   return persist(context, run, now, seq.events.at(-1).sequence);
 }
-function appendEvaluatedTail(seq, envelope, ids, stepId, outcome) {
+function appendEvaluatedTail(seq, envelope2, ids, stepId, outcome) {
   const mapped = outcome === "passed" ? "passed" : outcome === "repro-missing" ? "failed" : "failed";
   seq.push("assignment.result_recorded", { assignmentId: ids.assignmentId, resultClass: "outcome", outcome, status: "result_recorded" });
   seq.push("attempt.status_changed", { attemptId: ids.attemptId, status: "terminal" });
   seq.push("assignment.terminal", { assignmentId: ids.assignmentId, outcome, status: "terminal" });
   seq.push("step.outcome_recorded", { stepId, stepAttempt: ids.stepAttempt, outcome });
   seq.push("step.status_changed", { stepId, status: mapped, previousStatus: "running" });
-  const selected = envelope.plan.steps[stepId].transitions[outcome];
+  const selected = envelope2.plan.steps[stepId].transitions[outcome];
   if (!selected) {
     seq.push("run.status_changed", { status: "failed", reason: "outcome_unknown", stepId, outcome });
     return;
   }
-  const budget = kxmTransitionBudgetFailure(envelope.plan, ids.state, stepId, outcome);
+  const budget = kxmTransitionBudgetFailure(envelope2.plan, ids.state, stepId, outcome);
   if (budget) {
     seq.push("run.status_changed", { status: "failed", reason: budget, stepId, outcome });
     return;
@@ -23898,8 +24315,8 @@ function appendEvaluatedTail(seq, envelope, ids, stepId, outcome) {
     seq.push("run.status_changed", { status: selected.terminalStatus });
   }
 }
-function evidenceKeyFor(envelope, stepId) {
-  const required = envelope.plan.steps[stepId]?.requiredEvidence.filter((item) => item.kind === "gate") ?? [];
+function evidenceKeyFor(envelope2, stepId) {
+  const required = envelope2.plan.steps[stepId]?.requiredEvidence.filter((item) => item.kind === "gate") ?? [];
   return required.length === 1 ? required[0].key : null;
 }
 function placeholderReceipt(observationId, kind, now) {
@@ -23932,13 +24349,13 @@ function buildObservation(ids, observation, observationId, recordedEventId) {
   };
   return { ...row, contentHash: gateRowContentHash("gate_observations", { ...row, contentHash: "" }) };
 }
-function requireGateStep(envelope, stepId, runId) {
-  const step = envelope.plan.steps[stepId];
+function requireGateStep(envelope2, stepId, runId) {
+  const step = envelope2.plan.steps[stepId];
   if (!step || step.kind !== "gate") throw runtimeError("run_events_illegal", runId, `step ${stepId} is not a gate`);
   return step;
 }
-function requireIntent(context, run, envelope, stepId) {
-  const step = requireGateStep(envelope, stepId, run.runId);
+function requireIntent(context, run, envelope2, stepId) {
+  const step = requireGateStep(envelope2, stepId, run.runId);
   const folded = foldStoredKxmRun(context, run);
   const attemptId = folded.currentStep?.attemptId;
   if (!attemptId || folded.currentStep?.stepId !== stepId) {
@@ -24006,7 +24423,7 @@ function hashFromStore(context, runId) {
 }
 
 // plugins/kxm/src/routing.ts
-import { createHash as createHash9 } from "node:crypto";
+import { createHash as createHash10 } from "node:crypto";
 var ROUTING_RECORD_V2_SCHEMA = "kxm.routing-record.v2";
 var BEHAVIORAL_HASH_VERSION = 1;
 var MAX_PROVIDER_METADATA_FIELDS = 32;
@@ -24029,7 +24446,7 @@ function behavioralConfigHash(input) {
     workflowDefinitionSha256: input.workflowDefinitionSha256?.trim() ?? null,
     verifierConfigSha256: input.verifierConfigSha256?.trim() ?? null
   };
-  return createHash9("sha256").update(JSON.stringify(canonical), "utf8").digest("hex");
+  return createHash10("sha256").update(JSON.stringify(canonical), "utf8").digest("hex");
 }
 function boundedInt(value, field) {
   if (value === void 0 || value === null) return void 0;
@@ -24198,7 +24615,7 @@ function requireTrustedProducer(producer) {
   }
 }
 function hashCapabilitySecret(secret) {
-  return `sha256:${createHash10("sha256").update(`${CAPABILITY_PREFIX}${secret}`, "utf8").digest("hex")}`;
+  return `sha256:${createHash11("sha256").update(`${CAPABILITY_PREFIX}${secret}`, "utf8").digest("hex")}`;
 }
 function mintKxmCapabilitySecret() {
   const secret = `kxmcap_${randomBytes(32).toString("base64url")}`;
@@ -24227,7 +24644,7 @@ function pinKxmCompiledPlan(context, bundle, runId, options) {
       value: workflow.value,
       ...workflow.logicalPath !== void 0 ? { logicalPath: workflow.logicalPath } : {}
     }));
-    const envelope = {
+    const envelope2 = {
       schema: KXM_RUN_PLAN_SCHEMA,
       runId: run.runId,
       projectId: run.projectId,
@@ -24243,7 +24660,7 @@ function pinKxmCompiledPlan(context, bundle, runId, options) {
       plan: compiled,
       gates: pinnedGatesForCompiledPlan(compiled, bundle, context.projectRoot)
     };
-    const runPlanHash = hashKxmRunPlanEnvelope(envelope);
+    const runPlanHash = hashKxmRunPlanEnvelope(envelope2);
     const existing = context.eventStore.runPlan(runId);
     if (existing) {
       if (existing.runPlanHash !== runPlanHash) {
@@ -24266,7 +24683,7 @@ function pinKxmCompiledPlan(context, bundle, runId, options) {
     context.eventStore.insertRunPlan({
       runId,
       runPlanHash,
-      envelope: kxmCanonicalJson(envelope),
+      envelope: kxmCanonicalJson(envelope2),
       pinnedSequence: sequence
     });
     context.eventStore.appendEvent(event);
@@ -24279,8 +24696,8 @@ function pinKxmCompiledPlan(context, bundle, runId, options) {
 function startKxmRun(context, runId, options = {}) {
   return context.eventStore.transaction(() => {
     const run = requireRun(context, runId);
-    const envelope = loadKxmRunPlanEnvelope(context.eventStore, run);
-    const unsupported = options.allowLimits ? void 0 : unsupportedLimit(envelope);
+    const envelope2 = loadKxmRunPlanEnvelope(context.eventStore, run);
+    const unsupported = options.allowLimits ? void 0 : unsupportedLimit(envelope2);
     const state = foldStoredKxmRun(context, run);
     if (unsupported) {
       return { state, handoff: unsupported };
@@ -24327,7 +24744,7 @@ async function driveAdmitted(context, runId, producer, token, options = {}) {
   return latest;
 }
 function newDriveId(runId, token, runtimeId, monotonicNs) {
-  return `drv_${createHash10("sha256").update(`${runId}\0${token}\0${runtimeId}\0${monotonicNs}`, "utf8").digest("hex").slice(0, 24)}`;
+  return `drv_${createHash11("sha256").update(`${runId}\0${token}\0${runtimeId}\0${monotonicNs}`, "utf8").digest("hex").slice(0, 24)}`;
 }
 function driveErrorSummary(error) {
   const raw = error instanceof KxmConfigError ? error.issues[0]?.code : void 0;
@@ -24519,12 +24936,12 @@ var KxmRunScheduler = class _KxmRunScheduler {
     }
     try {
       const run = requireRun(this.context, runId);
-      const envelope = loadKxmRunPlanEnvelope(this.context.eventStore, run);
+      const envelope2 = loadKxmRunPlanEnvelope(this.context.eventStore, run);
       return enqueueKxmScheduledRun(
         this.context.eventStore.path,
         runId,
-        envelope.revisions.config,
-        envelope.projectLimits.maxConcurrentRuns,
+        envelope2.revisions.config,
+        envelope2.projectLimits.maxConcurrentRuns,
         (token) => driveAdmitted(this.context, runId, producer, token, options)
       );
     } catch (error) {
@@ -24554,8 +24971,8 @@ var KxmRunScheduler = class _KxmRunScheduler {
       resolve: (_value) => void 0,
       reject: (_error) => void 0
     };
-    const settled = new Promise((resolve6, reject) => {
-      pending.resolve = resolve6;
+    const settled = new Promise((resolve8, reject) => {
+      pending.resolve = resolve8;
       pending.reject = reject;
     });
     void settled.then(void 0, () => void 0);
@@ -25094,10 +25511,10 @@ function prepareDispatch(context, runId, producerId) {
     return { kind: "return", ...failBudget(context, run, plan, state, "budget_unmetered_attempts", stepId) };
   }
   if (step.kind === "gate") {
-    const envelope = loadKxmRunPlanEnvelope(context.eventStore, run);
-    const unsupported2 = unsupportedGateStep(plan, step, envelope, context);
+    const envelope2 = loadKxmRunPlanEnvelope(context.eventStore, run);
+    const unsupported2 = unsupportedGateStep(plan, step, envelope2, context);
     if (unsupported2) return { kind: "return", state, handoff: { ...unsupported2, stepId } };
-    const definition = envelope.gates.definitions[step.gate];
+    const definition = envelope2.gates.definitions[step.gate];
     if (definition?.kind === "command") {
       const preflightResult = gateRecoveryPreflight(context);
       const firstBlocking = preflightResult.blocking[0];
@@ -25113,7 +25530,7 @@ function prepareDispatch(context, runId, producerId) {
         };
       }
     }
-    const result = recordGateIntentInTransaction(context, run, envelope, stepId);
+    const result = recordGateIntentInTransaction(context, run, envelope2, stepId);
     const current = result.state.currentStep;
     const attemptId = current?.attemptId;
     const assignmentId = current?.assignmentId;
@@ -25124,7 +25541,7 @@ function prepareDispatch(context, runId, producerId) {
     return {
       kind: "gate",
       run,
-      envelope,
+      envelope: envelope2,
       stepId,
       stepAttempt: current.stepAttempt,
       assignmentId,
@@ -25230,7 +25647,7 @@ function birthMember(context, input) {
   if (promptText === void 0) {
     throw runtimeError("run_prompt_mismatch", run.runId, "prompt text missing from accepted run prompt store");
   }
-  const promptHash = createHash10("sha256").update(promptText, "utf8").digest("hex");
+  const promptHash = createHash11("sha256").update(promptText, "utf8").digest("hex");
   const expectedHash = run.promptSha256.replace(/^sha256:/, "");
   if (promptHash !== expectedHash) {
     throw runtimeError("run_prompt_mismatch", run.runId, "prompt text does not match accepted promptSha256");
@@ -25608,12 +26025,12 @@ function producerRoutingRecord(context, dispatch, result, now) {
   if (result.costBasis === "metered" && (typeof result.costUsd !== "number" || !Number.isFinite(result.costUsd) || result.costUsd < 0)) {
     throw runtimeError("settle_invalid_cost", run.runId, "attempt settlement rejected: metered costBasis requires non-negative finite costUsd");
   }
-  const envelope = loadKxmRunPlanEnvelope(context.eventStore, run);
+  const envelope2 = loadKxmRunPlanEnvelope(context.eventStore, run);
   const rawHash = result.behavioralSha256 ?? behavioralConfigHash({
     requestedModel: result.requestedModel ?? "simulated",
     effectiveModel: result.effectiveModel ?? result.requestedModel ?? "simulated",
     agentRole: dispatch.step.kind === "agent" || dispatch.step.kind === "moa" ? dispatch.step.agent : void 0,
-    toolPolicyVersion: envelope.revisions.toolPolicy
+    toolPolicyVersion: envelope2.revisions.toolPolicy
   });
   const record2 = {
     schema: ROUTING_RECORD_V2_SCHEMA,
@@ -25674,12 +26091,12 @@ function settleMember(context, dispatch, result, produceError, produceErrorCode)
     push("attempt.status_changed", { attemptId: dispatch.attemptId, status: "terminal" });
     push("assignment.terminal", { assignmentId: dispatch.assignmentId, outcome: "cancelled", status: "terminal" });
   } else if (produceError) {
-    const envelope = loadKxmRunPlanEnvelope(context.eventStore, run);
+    const envelope2 = loadKxmRunPlanEnvelope(context.eventStore, run);
     const rawHash = result?.behavioralSha256 ?? behavioralConfigHash({
       requestedModel: result?.requestedModel ?? "simulated",
       effectiveModel: result?.effectiveModel ?? result?.requestedModel ?? "simulated",
       agentRole: dispatch.step.kind === "agent" || dispatch.step.kind === "moa" ? dispatch.step.agent : void 0,
-      toolPolicyVersion: envelope.revisions.toolPolicy
+      toolPolicyVersion: envelope2.revisions.toolPolicy
     });
     const behavioralSha256 = rawHash.startsWith("sha256:") ? rawHash : `sha256:${rawHash}`;
     const routingRecord = {
@@ -25894,8 +26311,8 @@ function declaredRunDurationBudget(context, runId) {
   const run = context.eventStore.run(runId);
   if (!run) return void 0;
   try {
-    const envelope = loadKxmRunPlanEnvelope(context.eventStore, run);
-    return effectiveRunDurationBudget(envelope.plan.limits, envelope.projectLimits);
+    const envelope2 = loadKxmRunPlanEnvelope(context.eventStore, run);
+    return effectiveRunDurationBudget(envelope2.plan.limits, envelope2.projectLimits);
   } catch {
     return void 0;
   }
@@ -26001,11 +26418,11 @@ function armRunDurationBudgetTimer(context, runId) {
     unhook();
   };
 }
-function unsupportedLimit(envelope) {
-  if (envelope.plan.limits.maxAgentTimeMs !== void 0) {
+function unsupportedLimit(envelope2) {
+  if (envelope2.plan.limits.maxAgentTimeMs !== void 0) {
     return { reason: "limit_unsupported", field: "limits.maxAgentTimeMs", detail: "agent-time budget enforcement is not available in this slice" };
   }
-  if (envelope.projectLimits.maxAgentTimeMs !== void 0) {
+  if (envelope2.projectLimits.maxAgentTimeMs !== void 0) {
     return { reason: "limit_unsupported", field: "project.limits.maxAgentTimeMs", detail: "agent-time budget enforcement is not available in this slice" };
   }
   return void 0;
@@ -26058,12 +26475,12 @@ function unsupportedStep(plan, step, producerId) {
   }
   return void 0;
 }
-function unsupportedGateStep(plan, step, envelope, context) {
+function unsupportedGateStep(plan, step, envelope2, context) {
   if (!step.gate) return { reason: "step_unsupported", field: "gate", detail: "gate step is missing gate id" };
-  if (envelope.gates.registry === null) {
+  if (envelope2.gates.registry === null) {
     return { reason: "step_unsupported", field: "gate", detail: `step ${step.id} refers to a gate but registry is null` };
   }
-  const definition = envelope.gates.definitions[step.gate];
+  const definition = envelope2.gates.definitions[step.gate];
   if (!definition) {
     return { reason: "step_unsupported", field: "gate", detail: `gate definition ${step.gate} not found in registry` };
   }
@@ -26169,7 +26586,7 @@ function unsupportedGateStep(plan, step, envelope, context) {
       return { reason: "gate_outcome_undeclared", field: "outcomes", detail: "step expects fail but missing required failure outcome; declare implementation-failure or failed" };
     }
   }
-  if (context && projectRuntimeKey(context.projectRoot) !== envelope.gates.controlRoot.projectKey) {
+  if (context && projectRuntimeKey(context.projectRoot) !== envelope2.gates.controlRoot.projectKey) {
     throw runtimeError("run_owner_mismatch", plan.workflowId, `gate control root does not match project`);
   }
   if (definition.kind === "artifacts-exist" && step.expect === "fail") {
@@ -26808,28 +27225,290 @@ Return a final JSON object with an "outcome" field chosen from ${JSON.stringify(
   return producer;
 }
 
+// plugins/kxm/src/client.ts
+import { hostname } from "node:os";
+
+// plugins/kxm/src/protocol.ts
+var DEFAULT_MESSAGE_TTL_MS = 24 * 60 * 6e4;
+var MAX_MESSAGE_TTL_MS = 7 * 24 * 60 * 6e4;
+var DEFAULT_MESSAGE_RETENTION_MS = 7 * 24 * 60 * 6e4;
+var MAX_BODY_BYTES = 256 * 1024;
+var MAX_AGENT_HOST_CHARS = 64;
+var MAX_LEASE_TTL_MS = 10 * 6e4;
+var DEFAULT_LEASE_TTL_MS = 5 * 6e4;
+
+// plugins/kxm/src/client.ts
+function defaultHostLabel() {
+  try {
+    return hostname().trim().slice(0, MAX_AGENT_HOST_CHARS) || void 0;
+  } catch {
+    return void 0;
+  }
+}
+var HubHttpError = class extends Error {
+  statusCode;
+  code;
+  requestId;
+  extras;
+  constructor(statusCode, message, code, requestId, extras) {
+    super(message);
+    this.name = "HubHttpError";
+    this.statusCode = statusCode;
+    if (code) this.code = code;
+    if (requestId) this.requestId = requestId;
+    if (extras) this.extras = extras;
+  }
+};
+async function hubJsonRequest(options, path, init, headers) {
+  const requestTimeoutMs = options.requestTimeoutMs ?? 15e3;
+  const timeoutSignal = AbortSignal.timeout(requestTimeoutMs);
+  const signal = init.signal ? AbortSignal.any([init.signal, timeoutSignal]) : timeoutSignal;
+  let response;
+  try {
+    response = await (options.fetchImpl ?? fetch)(`${options.serverUrl.replace(/\/$/, "")}${path}`, {
+      ...init,
+      signal,
+      headers: { ...headers, ...init.headers ?? {} }
+    });
+  } catch (error) {
+    if (timeoutSignal.aborted) throw new Error(`request timed out after ${requestTimeoutMs}ms`);
+    throw error;
+  }
+  const text = await response.text();
+  let body = {};
+  if (text) {
+    try {
+      body = JSON.parse(text);
+    } catch {
+      throw new Error(`hub returned invalid JSON with HTTP ${response.status}`);
+    }
+  }
+  if (!response.ok) {
+    const extras = {};
+    for (const key of ["operation", "nextAction", "assignedCoordinatorName"]) {
+      if (typeof body[key] === "string") extras[key] = body[key];
+    }
+    if (body.lease && typeof body.lease === "object") extras.lease = body.lease;
+    throw new HubHttpError(
+      response.status,
+      String(body.error ?? `HTTP ${response.status}`),
+      typeof body.code === "string" ? body.code : void 0,
+      response.headers.get("x-request-id") ?? void 0,
+      Object.keys(extras).length > 0 ? extras : void 0
+    );
+  }
+  return body;
+}
+var RuntimeHubClient = class {
+  options;
+  constructor(options) {
+    this.options = options;
+  }
+  async heartbeat() {
+    const result = await this.request("/v1/runtime/presence", {
+      project: this.options.project,
+      runtimeId: this.options.runtimeId,
+      host: this.options.host ?? defaultHostLabel()
+    });
+    return result.presence;
+  }
+  /** Push already-derived `kxm.sync-event.v1` objects, in outbox order. */
+  async pushSyncEvents(events) {
+    return await this.request("/v1/sync/events", {
+      project: this.options.project,
+      runtimeId: this.options.runtimeId,
+      events
+    });
+  }
+  async request(path, body) {
+    const headers = { "content-type": "application/json" };
+    if (this.options.authToken) headers.authorization = `Bearer ${this.options.authToken}`;
+    return await hubJsonRequest(this.options, path, { method: "POST", body: JSON.stringify(body) }, headers);
+  }
+};
+
+// plugins/kxm/src/hub-binding.ts
+import { existsSync as existsSync10, mkdirSync as mkdirSync4, readFileSync as readFileSync8, renameSync, rmSync, writeFileSync as writeFileSync4 } from "node:fs";
+import { homedir as homedir2 } from "node:os";
+import { dirname as dirname6, isAbsolute as isAbsolute4, join as join13, resolve as resolve6 } from "node:path";
+var HUB_BINDING_SCHEMA = "kxm.hub-binding.v1";
+var HubBindingError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "HubBindingError";
+  }
+};
+function resolveUserStateRoot(env) {
+  const explicit = env.KXM_STATE_HOME?.trim();
+  if (explicit) {
+    if (!isAbsolute4(explicit)) throw new HubBindingError("local_state_root_not_absolute");
+    return resolve6(explicit);
+  }
+  if (process.platform === "win32") {
+    const localAppData = env.LOCALAPPDATA?.trim();
+    const base2 = localAppData && isAbsolute4(localAppData) ? localAppData : join13(homedir2(), "AppData", "Local");
+    return resolve6(base2, "KXM");
+  }
+  if (process.platform === "darwin") return resolve6(homedir2(), "Library", "Application Support", "KXM");
+  const xdgState = env.XDG_STATE_HOME?.trim();
+  const base = xdgState && isAbsolute4(xdgState) ? xdgState : join13(homedir2(), ".local", "state");
+  return resolve6(base, "kxm");
+}
+function hubBindingFile(env = process.env) {
+  return join13(resolveUserStateRoot(env), "hub-binding.json");
+}
+function validateHubUrl(raw) {
+  let parsed;
+  try {
+    parsed = new URL(raw);
+  } catch {
+    throw new HubBindingError("hub_url_invalid");
+  }
+  if (parsed.protocol !== "http:" && parsed.protocol !== "https:" || parsed.username !== "" || parsed.password !== "" || parsed.search !== "" || parsed.hash !== "" || raw.includes("?") || raw.includes("#")) {
+    throw new HubBindingError("hub_url_invalid");
+  }
+  return parsed.href.replace(/\/$/, "");
+}
+function isIsoTimestamp(value) {
+  if (Number.isNaN(Date.parse(value))) return false;
+  return value === new Date(value).toISOString();
+}
+function readHubBinding(env = process.env) {
+  const file = hubBindingFile(env);
+  if (!existsSync10(file)) return void 0;
+  let parsed;
+  try {
+    parsed = JSON.parse(readFileSync8(file, "utf8"));
+  } catch {
+    throw new HubBindingError(`malformed hub binding at ${file}`);
+  }
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+    throw new HubBindingError(`malformed hub binding at ${file}`);
+  }
+  const row = parsed;
+  const keys = Object.keys(row);
+  if (keys.length !== 3 || row.schema !== HUB_BINDING_SCHEMA || typeof row.url !== "string" || typeof row.boundAt !== "string" || !isIsoTimestamp(row.boundAt)) {
+    throw new HubBindingError(`malformed hub binding at ${file}`);
+  }
+  let url;
+  try {
+    url = validateHubUrl(row.url);
+  } catch {
+    throw new HubBindingError(`malformed hub binding at ${file}`);
+  }
+  return { schema: HUB_BINDING_SCHEMA, url, boundAt: row.boundAt };
+}
+
+// plugins/kxm/src/hub-env.ts
+import { existsSync as existsSync11, mkdirSync as mkdirSync5, readFileSync as readFileSync9, renameSync as renameSync2, rmSync as rmSync2, writeFileSync as writeFileSync5 } from "node:fs";
+import { homedir as homedir3 } from "node:os";
+import { dirname as dirname7, isAbsolute as isAbsolute5, join as join14, resolve as resolve7 } from "node:path";
+var HUB_ENV_SCHEMA = "kxm.hub-env.v1";
+var HubEnvError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "HubEnvError";
+  }
+};
+function resolveUserStateRoot2(env) {
+  const explicit = env.KXM_STATE_HOME?.trim();
+  if (explicit) {
+    if (!isAbsolute5(explicit)) throw new HubEnvError("local_state_root_not_absolute");
+    return resolve7(explicit);
+  }
+  if (process.platform === "win32") {
+    const localAppData = env.LOCALAPPDATA?.trim();
+    const base2 = localAppData && isAbsolute5(localAppData) ? localAppData : join14(homedir3(), "AppData", "Local");
+    return resolve7(base2, "KXM");
+  }
+  if (process.platform === "darwin") return resolve7(homedir3(), "Library", "Application Support", "KXM");
+  const xdgState = env.XDG_STATE_HOME?.trim();
+  const base = xdgState && isAbsolute5(xdgState) ? xdgState : join14(homedir3(), ".local", "state");
+  return resolve7(base, "kxm");
+}
+function hubEnvFile(env = process.env) {
+  return join14(resolveUserStateRoot2(env), "hub-env.json");
+}
+function readHubEnvRecord(env = process.env) {
+  const file = hubEnvFile(env);
+  if (!existsSync11(file)) return void 0;
+  let parsed;
+  try {
+    parsed = JSON.parse(readFileSync9(file, "utf8"));
+  } catch (error) {
+    throw new HubEnvError(`hub env file is malformed at ${file}: ${error instanceof Error ? error.message : String(error)}`);
+  }
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+    throw new HubEnvError(`hub env file is malformed at ${file}: expected a JSON object`);
+  }
+  const record2 = parsed;
+  if (record2.schema !== HUB_ENV_SCHEMA) {
+    throw new HubEnvError(`hub env file at ${file} has unsupported schema ${String(record2.schema)}`);
+  }
+  if (record2.authToken !== void 0 && (typeof record2.authToken !== "string" || record2.authToken.trim().length === 0)) {
+    throw new HubEnvError(`hub env file at ${file} has an invalid authToken`);
+  }
+  if (record2.projectTokens !== void 0) {
+    const tokens = record2.projectTokens;
+    if (!tokens || typeof tokens !== "object" || Array.isArray(tokens)) {
+      throw new HubEnvError(`hub env file at ${file} has invalid projectTokens`);
+    }
+    for (const [project, token] of Object.entries(tokens)) {
+      if (!project.trim() || typeof token !== "string" || !token.trim()) {
+        throw new HubEnvError(`hub env file at ${file} has an empty project name or token`);
+      }
+    }
+  }
+  return {
+    schema: HUB_ENV_SCHEMA,
+    createdAt: typeof record2.createdAt === "string" ? record2.createdAt : "",
+    ...record2.authToken !== void 0 ? { authToken: record2.authToken } : {},
+    ...record2.projectTokens !== void 0 ? { projectTokens: record2.projectTokens } : {}
+  };
+}
+function resolveClientHubAuthToken(env, project) {
+  const envToken = env.KXM_AUTH_TOKEN?.trim();
+  if (envToken) return envToken;
+  const record2 = readHubEnvRecord(env);
+  return record2?.projectTokens?.[project]?.trim() || record2?.authToken?.trim() || void 0;
+}
+
+// plugins/kxm/src/project-name.ts
+import { readFileSync as readFileSync10 } from "node:fs";
+import { basename as basename3, join as join15 } from "node:path";
+function defaultProjectName(cwd, env = process.env) {
+  const fromEnv = env.KXM_PROJECT?.trim();
+  if (fromEnv) return fromEnv;
+  try {
+    const pkg = JSON.parse(readFileSync10(join15(cwd, "package.json"), "utf8"));
+    if (typeof pkg.name === "string" && pkg.name.trim().length > 0) return pkg.name.trim();
+  } catch {
+  }
+  return basename3(cwd);
+}
+
 // plugins/kxm/src/runtime-supervisor.ts
 function kxmSupervisorTokenFile(paths) {
-  return join13(paths.runtimeDir, "supervisor.token");
+  return join16(paths.runtimeDir, "supervisor.token");
 }
 function publishKxmSupervisorToken(paths, token) {
   const file = kxmSupervisorTokenFile(paths);
-  mkdirSync4(dirname6(file), { recursive: true, mode: 448 });
+  mkdirSync6(dirname8(file), { recursive: true, mode: 448 });
   const temp = `${file}.${process.pid}.tmp`;
-  writeFileSync4(temp, `${token}
+  writeFileSync6(temp, `${token}
 `, { encoding: "utf8", mode: 384 });
   try {
     chmodSync2(temp, 384);
   } catch {
   }
-  renameSync(temp, file);
+  renameSync3(temp, file);
   try {
     chmodSync2(file, 384);
   } catch {
   }
 }
 function hashKxmSupervisorToken(token) {
-  return `sha256:${createHash11("sha256").update(`kxm-runtime-supervisor\0${token}`, "utf8").digest("hex")}`;
+  return `sha256:${createHash12("sha256").update(`kxm-runtime-supervisor\0${token}`, "utf8").digest("hex")}`;
 }
 function readKxmSupervisorToken(paths) {
   const file = kxmSupervisorTokenFile(paths);
@@ -26838,7 +27517,7 @@ function readKxmSupervisorToken(paths) {
   if (stat.isSymbolicLink() || !stat.isFile()) {
     throw runtimeError("runtime_path_invalid", file, "supervisor token file must be a regular file, not a link");
   }
-  const token = readFileSync8(file, "utf8").trim();
+  const token = readFileSync11(file, "utf8").trim();
   return token.length >= 32 ? token : void 0;
 }
 function processAlive(pid) {
@@ -26852,16 +27531,16 @@ function processAlive(pid) {
 var HEARTBEAT_STALE_MS = 15e3;
 var SUPERVISOR_ERROR_MAX_AGE_MS = 3e4;
 function supervisorErrorFile(paths) {
-  return join13(paths.runtimeDir, "supervisor.error");
+  return join16(paths.runtimeDir, "supervisor.error");
 }
 function clearSupervisorError(paths) {
   const file = supervisorErrorFile(paths);
-  if (existsSync10(file)) rmSync(file, { force: true });
+  if (existsSync12(file)) rmSync3(file, { force: true });
 }
 function recordSupervisorError(paths, message) {
   try {
-    mkdirSync4(paths.runtimeDir, { recursive: true, mode: 448 });
-    writeFileSync4(supervisorErrorFile(paths), `${message}
+    mkdirSync6(paths.runtimeDir, { recursive: true, mode: 448 });
+    writeFileSync6(supervisorErrorFile(paths), `${message}
 `, { encoding: "utf8", mode: 384 });
   } catch {
   }
@@ -26873,13 +27552,13 @@ function readRecentSupervisorError(paths) {
   const ageMs = Date.now() - stat.mtimeMs;
   if (ageMs > SUPERVISOR_ERROR_MAX_AGE_MS) return void 0;
   try {
-    return readFileSync8(file, "utf8").trim();
+    return readFileSync11(file, "utf8").trim();
   } catch {
     return void 0;
   }
 }
 function kxmSupervisorStatus(paths) {
-  if (!existsSync10(paths.registryDb)) return { running: false };
+  if (!existsSync12(paths.registryDb)) return { running: false };
   const registry = new KxmRuntimeRegistry(paths.registryDb);
   try {
     const record2 = registry.supervisor();
@@ -26949,7 +27628,7 @@ async function ensureKxmSupervisor(options = {}) {
     throw runtimeError("runtime_supervisor_unreachable", paths.registryDb, `runtime supervisor pid ${status.pid} is registered as running but cannot be probed`);
   }
   clearSupervisorError(paths);
-  const scriptPath = join13(findKxmRepoRoot(import.meta.url), "scripts", "kxm-runtime-supervisor.mjs");
+  const scriptPath = join16(findKxmRepoRoot(import.meta.url), "scripts", "kxm-runtime-supervisor.mjs");
   const spawnImpl = options.spawnImpl ?? ((script, env) => {
     const child = spawn3(process.execPath, [script], {
       detached: true,
@@ -27034,8 +27713,8 @@ async function waitForDriveSessions(settled, graceMs) {
   try {
     await Promise.race([
       Promise.allSettled(settled),
-      new Promise((resolve6) => {
-        timeout = setTimeout(resolve6, graceMs);
+      new Promise((resolve8) => {
+        timeout = setTimeout(resolve8, graceMs);
         timeout.unref?.();
       })
     ]);
@@ -27056,6 +27735,63 @@ async function driveSessionStillPending(settled) {
   await Promise.resolve();
   return pending;
 }
+var DEFAULT_RUNTIME_SYNC_INTERVAL_MS = 1e4;
+var MIN_RUNTIME_SYNC_INTERVAL_MS = 250;
+var MAX_RUNTIME_SYNC_INTERVAL_MS = 6e4;
+var OUTBOX_PUSH_BATCH = 32;
+function runtimeSyncIntervalMs(env = process.env) {
+  const raw = env.KXM_RUNTIME_SYNC_INTERVAL_MS?.trim();
+  if (!raw) return DEFAULT_RUNTIME_SYNC_INTERVAL_MS;
+  const parsed = Number(raw);
+  if (!Number.isInteger(parsed)) return DEFAULT_RUNTIME_SYNC_INTERVAL_MS;
+  return Math.min(MAX_RUNTIME_SYNC_INTERVAL_MS, Math.max(MIN_RUNTIME_SYNC_INTERVAL_MS, parsed));
+}
+async function syncKxmOutbox(eventStore, client, options = {}) {
+  const now = options.now ?? (() => (/* @__PURE__ */ new Date()).toISOString());
+  const batchSize = options.batchSize ?? OUTBOX_PUSH_BATCH;
+  const result = { pushed: 0, acked: 0, conflicts: 0, rejected: 0 };
+  let afterSeq = 0;
+  for (; ; ) {
+    const rows = eventStore.pendingOutbox(batchSize, afterSeq);
+    if (rows.length === 0) return result;
+    const MAX_BATCH_BYTES = 2e5;
+    let byteBudget = MAX_BATCH_BYTES;
+    let sendCount = 0;
+    for (const row of rows) {
+      const rowBytes = Buffer.byteLength(row.syncEvent, "utf8") + 64;
+      if (sendCount > 0 && byteBudget - rowBytes < 0) break;
+      byteBudget -= rowBytes;
+      sendCount += 1;
+    }
+    const batch = rows.slice(0, sendCount);
+    if (batch.length === 0) batch.push(rows[0]);
+    afterSeq = batch[batch.length - 1].seq;
+    eventStore.markOutboxAttempted(batch.map((row) => row.seq), now());
+    const response = await client.pushSyncEvents(batch.map((row) => JSON.parse(row.syncEvent)));
+    result.pushed += batch.length;
+    const outcomes = new Map(response.results.map((entry) => [`${entry.runId}\0${entry.sequence}`, entry.outcome]));
+    const acked = [];
+    for (const row of batch) {
+      const outcome = outcomes.get(`${row.runId}\0${row.sequence}`);
+      if (outcome === "accepted" || outcome === "duplicate") acked.push(row.seq);
+      else if (outcome === "conflict") result.conflicts += 1;
+      else result.rejected += 1;
+    }
+    result.acked += eventStore.ackOutbox(acked, now());
+  }
+}
+function runtimeHubClientFor(context, env) {
+  const serverUrl = env.KXM_SERVER_URL?.trim() || readHubBinding(env)?.url;
+  if (!serverUrl) return void 0;
+  const project = defaultProjectName(context.projectRoot, env);
+  const authToken = resolveClientHubAuthToken(env, project);
+  return new RuntimeHubClient({
+    serverUrl,
+    project,
+    runtimeId: context.homeRuntimeId,
+    ...authToken ? { authToken } : {}
+  });
+}
 async function startKxmRuntimeSupervisor(options = {}) {
   const now = options.now ?? (() => (/* @__PURE__ */ new Date()).toISOString());
   const paths = kxmRuntimePaths(options.stateRoot !== void 0 ? { stateRoot: options.stateRoot } : {});
@@ -27069,23 +27805,34 @@ async function startKxmRuntimeSupervisor(options = {}) {
   }
 }
 async function startKxmRuntimeSupervisorInner(paths, requestedPortOption, now) {
-  mkdirSync4(paths.runtimeDir, { recursive: true, mode: 448 });
-  mkdirSync4(paths.projectsDir, { recursive: true, mode: 448 });
+  mkdirSync6(paths.runtimeDir, { recursive: true, mode: 448 });
+  mkdirSync6(paths.projectsDir, { recursive: true, mode: 448 });
   const token = randomBytes2(32).toString("hex");
   const tokenHash = hashKxmSupervisorToken(token);
   const registry = new KxmRuntimeRegistry(paths.registryDb);
-  const runtimeId = `rtm_${createHash11("sha256").update(`${paths.stateRoot}\0${process.pid}\0${now()}\0${randomBytes2(16).toString("hex")}`, "utf8").digest("hex").slice(0, 24)}`;
+  const runtimeId = `rtm_${createHash12("sha256").update(`${paths.stateRoot}\0${process.pid}\0${now()}\0${randomBytes2(16).toString("hex")}`, "utf8").digest("hex").slice(0, 24)}`;
   const requestedPort = requestedPortOption ?? 0;
   let activeRuntimeId = runtimeId;
   const contexts = /* @__PURE__ */ new Map();
+  const registerSyncCredentials = (context) => {
+    const hubToken = resolveClientHubAuthToken(process.env, defaultProjectName(context.projectRoot, process.env));
+    if (hubToken) context.eventStore.syncRedactor.register(hubToken);
+    for (const key of Object.keys(process.env)) {
+      if (key.startsWith("KXM_") && (key.endsWith("_TOKEN") || key.endsWith("_KEY")) || key.endsWith("_API_KEY") || key.endsWith("_SECRET")) {
+        const value = process.env[key]?.trim();
+        if (value) context.eventStore.syncRedactor.register(value);
+      }
+    }
+  };
   const contextFor = (projectRoot) => {
-    if (!isAbsolute4(projectRoot)) {
+    if (!isAbsolute6(projectRoot)) {
       throw runtimeError("runtime_request_invalid", "projectRoot", "projectRoot must be an absolute path");
     }
     const key = projectRuntimeKey(projectRoot);
     const existing = contexts.get(key);
     if (existing) return existing;
     const context = openKxmRuntimeContext(projectRoot, { homeRuntimeId: activeRuntimeId, stateRoot: paths.stateRoot });
+    registerSyncCredentials(context);
     contexts.set(key, context);
     return context;
   };
@@ -27417,11 +28164,37 @@ async function startKxmRuntimeSupervisorInner(paths, requestedPortOption, now) {
     }
   }, 1e3);
   heartbeat.unref();
+  for (const reg of registry.projectsForRuntime(activeRuntimeId)) {
+    try {
+      contextFor(reg.projectRoot);
+    } catch {
+    }
+  }
+  let syncing = false;
+  const syncTimer = setInterval(() => {
+    if (syncing || stopping) return;
+    syncing = true;
+    void (async () => {
+      for (const context of [...contexts.values()]) {
+        try {
+          const client = runtimeHubClientFor(context, process.env);
+          if (!client) continue;
+          await client.heartbeat();
+          await syncKxmOutbox(context.eventStore, client, { now });
+        } catch {
+        }
+      }
+    })().finally(() => {
+      syncing = false;
+    });
+  }, runtimeSyncIntervalMs());
+  syncTimer.unref();
   let stopping = false;
   const stop = async () => {
     if (stopping) return;
     stopping = true;
     clearInterval(heartbeat);
+    clearInterval(syncTimer);
     try {
       registry.markStopping(process.pid, now());
     } catch {
@@ -27485,6 +28258,7 @@ async function kxmRuntimeRequest(handle, method, path, body) {
 }
 export {
   DEFAULT_RUNTIME_STOP_GRACE_MS,
+  DEFAULT_RUNTIME_SYNC_INTERVAL_MS,
   MAX_RUNTIME_STOP_GRACE_MS,
   attachKxmSupervisor,
   ensureKxmSupervisor,
@@ -27495,5 +28269,7 @@ export {
   kxmSupervisorTokenFile,
   readKxmSupervisorToken,
   runtimeStopGraceMs,
-  startKxmRuntimeSupervisor
+  runtimeSyncIntervalMs,
+  startKxmRuntimeSupervisor,
+  syncKxmOutbox
 };