motebit 1.4.4 → 1.5.0

package/dist/index.js

@@ -980,7 +980,7 @@ var init_routing = __esm({
 function isTokenAudience(value) {
   return typeof value === "string" && ALL_TOKEN_AUDIENCES.includes(value);
 }
-var SYNC_AUDIENCE, DEVICE_AUTH_AUDIENCE, PAIR_AUDIENCE, ROTATE_KEY_AUDIENCE, PUSH_REGISTER_AUDIENCE, TASK_SUBMIT_AUDIENCE, ADMIN_QUERY_AUDIENCE, PROPOSAL_AUDIENCE, ACCOUNT_BALANCE_AUDIENCE, ACCOUNT_DEPOSIT_AUDIENCE, ACCOUNT_WITHDRAW_AUDIENCE, ACCOUNT_WITHDRAWALS_AUDIENCE, ACCOUNT_CHECKOUT_AUDIENCE, BROWSER_SANDBOX_GRANT_AUDIENCE, BROWSER_SANDBOX_AUDIENCE, ALL_TOKEN_AUDIENCES;
+var SYNC_AUDIENCE, DEVICE_AUTH_AUDIENCE, PAIR_AUDIENCE, ROTATE_KEY_AUDIENCE, PUSH_REGISTER_AUDIENCE, TASK_SUBMIT_AUDIENCE, ADMIN_QUERY_AUDIENCE, PROPOSAL_AUDIENCE, ACCOUNT_BALANCE_AUDIENCE, ACCOUNT_DEPOSIT_AUDIENCE, ACCOUNT_WITHDRAW_AUDIENCE, ACCOUNT_WITHDRAWALS_AUDIENCE, ACCOUNT_CHECKOUT_AUDIENCE, BROWSER_SANDBOX_GRANT_AUDIENCE, BROWSER_SANDBOX_AUDIENCE, RUNTIME_ATTACH_AUDIENCE, ALL_TOKEN_AUDIENCES;
 var init_audience = __esm({
   "../../packages/protocol/dist/audience.js"() {
     "use strict";
@@ -1000,6 +1000,7 @@ var init_audience = __esm({
     ACCOUNT_CHECKOUT_AUDIENCE = "account:checkout";
     BROWSER_SANDBOX_GRANT_AUDIENCE = "browser-sandbox-grant";
     BROWSER_SANDBOX_AUDIENCE = "browser-sandbox";
+    RUNTIME_ATTACH_AUDIENCE = "runtime:attach";
     ALL_TOKEN_AUDIENCES = Object.freeze([
       "sync",
       "device:auth",
@@ -1016,7 +1017,8 @@ var init_audience = __esm({
       "account:withdrawals",
       "account:checkout",
       "browser-sandbox-grant",
-      "browser-sandbox"
+      "browser-sandbox",
+      "runtime:attach"
     ]);
   }
 });
@@ -4064,6 +4066,7 @@ __export(dist_exports, {
   RESEARCH_TASK_SHAPE: () => RESEARCH_TASK_SHAPE,
   RISK_LABELS: () => RISK_LABELS,
   ROTATE_KEY_AUDIENCE: () => ROTATE_KEY_AUDIENCE,
+  RUNTIME_ATTACH_AUDIENCE: () => RUNTIME_ATTACH_AUDIENCE,
   RUNTIME_RETENTION_REGISTRY: () => RUNTIME_RETENTION_REGISTRY,
   RegulatoryRiskSemiring: () => RegulatoryRiskSemiring,
   RelationType: () => RelationType,
@@ -8738,6 +8741,8 @@ __export(dist_exports2, {
   SKILL_SIGNATURE_SUITE: () => SKILL_SIGNATURE_SUITE,
   TOOL_INVOCATION_RECEIPT_SUITE: () => TOOL_INVOCATION_RECEIPT_SUITE,
   WITNESS_OMISSION_DISPUTE_WINDOW_MS: () => WITNESS_OMISSION_DISPUTE_WINDOW_MS,
+  agentCommandAudience: () => agentCommandAudience,
+  agentCommandPayload: () => agentCommandPayload,
   base58btcDecode: () => base58btcDecode,
   base58btcEncode: () => base58btcEncode,
   bytesToHex: () => bytesToHex4,
@@ -8788,6 +8793,7 @@ __export(dist_exports2, {
   resolveTreeHashVersion: () => resolveTreeHashVersion,
   sha256: () => sha2562,
   signAdjudicatorVote: () => signAdjudicatorVote,
+  signAgentCommandEnvelope: () => signAgentCommandEnvelope,
   signApprovalDecision: () => signApprovalDecision,
   signBalanceWaiver: () => signBalanceWaiver,
   signBySuite: () => signBySuite,
@@ -8830,6 +8836,7 @@ __export(dist_exports2, {
   toBase64Url: () => toBase64Url,
   verify: () => verify,
   verifyAdjudicatorVote: () => verifyAdjudicatorVote,
+  verifyAgentCommandEnvelope: () => verifyAgentCommandEnvelope,
   verifyAgentSettlementAnchor: () => verifyAgentSettlementAnchor,
   verifyApprovalDecision: () => verifyApprovalDecision,
   verifyBalanceWaiver: () => verifyBalanceWaiver,
@@ -11747,6 +11754,9 @@ function createSWU(Point2, opts) {
   let map;
   return (scalars) => (map || (map = mapToCurveSimpleSWU(Point2.Fp, opts)))(scalars[0]);
 }
+function assertNeverSuite(suite) {
+  throw new Error(`unsupported cryptosuite: ${String(suite)}`);
+}
 async function verifyBySuite(suite, canonicalBytes, signatureBytes, publicKeyBytes) {
   switch (suite) {
     case "motebit-jcs-ed25519-b64-v1":
@@ -11759,6 +11769,8 @@ async function verifyBySuite(suite, canonicalBytes, signatureBytes, publicKeyByt
       } catch {
         return false;
       }
+    default:
+      return false;
   }
 }
 async function signBySuite(suite, canonicalBytes, privateKeyBytes) {
@@ -11769,6 +11781,8 @@ async function signBySuite(suite, canonicalBytes, privateKeyBytes) {
     case "motebit-concat-ed25519-hex-v1":
     case "eddsa-jcs-2022":
       return signAsync(canonicalBytes, privateKeyBytes);
+    default:
+      return assertNeverSuite(suite);
   }
 }
 async function ed25519Sign(message2, privateKey) {
@@ -11793,6 +11807,8 @@ async function getPublicKeyBySuite(privateKey, suite) {
     case "motebit-concat-ed25519-hex-v1":
     case "eddsa-jcs-2022":
       return getPublicKeyAsync(privateKey);
+    default:
+      return assertNeverSuite(suite);
   }
 }
 function verifyP256EcdsaSha256(publicKeyCompressedHex, messageBytes, signatureDerBytes) {
@@ -12463,9 +12479,11 @@ async function signRequestEnvelope(payload, fields, identityPrivateKey) {
 async function verifyRequestEnvelope(envelope, registeredPublicKey, options) {
   if (envelope.suite !== SIGNED_REQUEST_ENVELOPE_SUITE) return false;
   if (options?.expectedAud !== void 0 && envelope.aud !== options.expectedAud) return false;
-  if (options?.now !== void 0) {
-    const windowMs = options.windowMs ?? 3e5;
-    if (Math.abs(options.now - envelope.ts) > windowMs) return false;
+  const checkFreshness = options?.checkFreshness ?? true;
+  if (checkFreshness) {
+    const now = options?.now ?? Date.now();
+    const windowMs = options?.windowMs ?? 3e5;
+    if (Math.abs(now - envelope.ts) > windowMs) return false;
   }
   if (options?.payload !== void 0) {
     const recomputed = await canonicalSha256(options.payload);
@@ -13555,11 +13573,11 @@ async function signVerifiableCredential(unsignedVC, privateKey, publicKey) {
   );
   return { ...unsignedVC, proof };
 }
-async function verifyVerifiableCredential(vc) {
-  if (vc.validUntil) {
-    const expiresAt = new Date(vc.validUntil).getTime();
-    if (Date.now() > expiresAt) return false;
-  }
+async function verifyVerifiableCredential(vc, options) {
+  const now = options?.now ?? Date.now();
+  if (vc.validUntil && now > new Date(vc.validUntil).getTime()) return false;
+  if (vc.validFrom && now < new Date(vc.validFrom).getTime()) return false;
+  if (vc.credentialStatus && options?.isRevoked?.(vc.credentialStatus.id) === true) return false;
   return verifyDataIntegritySigning(vc, vc.proof);
 }
 async function signVerifiablePresentation(unsignedVP, privateKey, publicKey) {
@@ -14552,6 +14570,49 @@ async function verifyAlternativePeeringArtifact(artifact, cert, ctx, errors) {
   if (!ok) errors.push("peering artifact signature does not verify against cert issuer pubkey");
   return ok;
 }
+function agentCommandAudience(targetMotebitId) {
+  return `agent-command/${targetMotebitId}`;
+}
+function agentCommandPayload(command2, args) {
+  return { command: command2, args: args ?? null };
+}
+async function signAgentCommandEnvelope(opts) {
+  return signRequestEnvelope(
+    agentCommandPayload(opts.command, opts.args),
+    {
+      motebit_id: opts.motebitId,
+      ts: (opts.now ?? Date.now)(),
+      aud: agentCommandAudience(opts.motebitId),
+      ...opts.nonce !== void 0 ? { nonce: opts.nonce } : {}
+    },
+    opts.identityPrivateKey
+  );
+}
+async function verifyAgentCommandEnvelope(opts) {
+  const candidate = opts.envelope;
+  if (candidate == null || typeof candidate !== "object" || typeof candidate.signature !== "string" || typeof candidate.motebit_id !== "string") {
+    return {
+      ok: false,
+      reason: "command_request rejected: missing signed-request-envelope@1.0 (unsigned remote commands are not accepted)"
+    };
+  }
+  if (candidate.motebit_id !== opts.motebitId) {
+    return {
+      ok: false,
+      reason: "command_request rejected: envelope identity is not this agent's identity"
+    };
+  }
+  const key = typeof opts.identityPublicKey === "string" ? hexToBytes5(opts.identityPublicKey) : opts.identityPublicKey;
+  const valid = await verifyRequestEnvelope(candidate, key, {
+    payload: agentCommandPayload(opts.command, opts.args),
+    expectedAud: agentCommandAudience(opts.motebitId),
+    ...opts.now !== void 0 ? { now: opts.now } : {}
+  });
+  return valid ? { ok: true } : {
+    ok: false,
+    reason: "command_request rejected: envelope verification failed (signature, audience, freshness, or payload digest)"
+  };
+}
 function parseYamlValue(raw) {
   const trimmed = raw.trim();
   if (trimmed === "null") return null;
@@ -15436,15 +15497,24 @@ async function verifySkillEnvelopeArtifact(envelope) {
 }
 async function verifyCredential(vc, clockSkewSeconds = DEFAULT_CLOCK_SKEW_SECONDS, hardwareAttestationVerifiers) {
   const errors = [];
+  const skewMs = clockSkewSeconds * 1e3;
   let expired = false;
   if (vc.validUntil) {
     const expiresAt = new Date(vc.validUntil).getTime();
-    const skewMs = clockSkewSeconds * 1e3;
     if (Date.now() > expiresAt + skewMs) {
       expired = true;
       errors.push({ message: "Credential has expired", path: "validUntil" });
     }
   }
+  let notYetValid = false;
+  if (vc.validFrom) {
+    const activeAt = new Date(vc.validFrom).getTime();
+    if (Date.now() + skewMs < activeAt) {
+      notYetValid = true;
+      errors.push({ message: "Credential is not yet valid", path: "validFrom" });
+    }
+  }
+  const revocationUnchecked = vc.credentialStatus !== void 0;
   const proofValid = await verifyDataIntegrity(vc, vc.proof);
   if (!proofValid) {
     errors.push({ message: "Credential proof verification failed", path: "proof" });
@@ -15468,11 +15538,13 @@ async function verifyCredential(vc, clockSkewSeconds = DEFAULT_CLOCK_SKEW_SECOND
   }
   return {
     type: "credential",
-    valid: proofValid && !expired,
+    valid: proofValid && !expired && !notYetValid,
     credential: vc,
     issuer: issuerDid,
     subject: subjectId,
     expired,
+    ...notYetValid ? { not_yet_valid: true } : {},
+    ...revocationUnchecked ? { revocation_unchecked: true } : {},
     ...hardwareAttestation && { hardware_attestation: hardwareAttestation },
     ...errors.length > 0 ? { errors } : {}
   };
@@ -18975,7 +19047,7 @@ var init_config2 = __esm({
   "src/config.ts"() {
     "use strict";
     init_esm_shims();
-    VERSION = true ? "1.4.4" : "0.0.0-dev";
+    VERSION = true ? "1.5.0" : "0.0.0-dev";
     CONFIG_DIR = process.env["MOTEBIT_CONFIG_DIR"] ?? path2.join(os.homedir(), ".motebit");
     CONFIG_PATH = path2.join(CONFIG_DIR, "config.json");
     RELAY_DIR = path2.join(CONFIG_DIR, "relay");
@@ -27002,7 +27074,7 @@ function createRelayReceiptExchange(config) {
         if (closed)
           break;
         if (!response.ok) {
-          await sleep2(pollRetryDelayMs, pollAbortController.signal);
+          await sleep3(pollRetryDelayMs, pollAbortController.signal);
           continue;
         }
         const text = await response.text();
@@ -27051,13 +27123,13 @@ function createRelayReceiptExchange(config) {
           break;
         const msg = err2 instanceof Error ? err2.message : String(err2);
         if (!msg.includes("abort")) {
-          await sleep2(pollRetryDelayMs, pollAbortController.signal);
+          await sleep3(pollRetryDelayMs, pollAbortController.signal);
         }
       }
     }
     pollAbortController = null;
   }
-  async function sleep2(ms, signal) {
+  async function sleep3(ms, signal) {
     return new Promise((resolve14) => {
       const timer = setTimeout(resolve14, ms);
       signal?.addEventListener("abort", () => {
@@ -46380,6 +46452,7 @@ __export(dist_exports6, {
   SANDBOX_TOKEN_REFRESH_MARGIN_MS: () => SANDBOX_TOKEN_REFRESH_MARGIN_MS,
   SimpleToolRegistry: () => SimpleToolRegistry,
   SovereignTierRequiredError: () => SovereignTierRequiredError,
+  agentCommandAudience: () => agentCommandAudience,
   bindSlabControllerToRenderer: () => bindSlabControllerToRenderer,
   buildPrecisionContext: () => buildPrecisionContext,
   buildUserInputAuditDetail: () => buildUserInputAuditDetail,
@@ -46419,6 +46492,7 @@ __export(dist_exports6, {
   submitP2pDelegation: () => submitP2pDelegation,
   summarizeGradientHistory: () => summarizeGradientHistory,
   urlAuditDetail: () => urlAuditDetail,
+  verifyAgentCommandEnvelope: () => verifyAgentCommandEnvelope,
   verifyGrantForTurn: () => verifyGrantForTurn
 });
 var init_dist22 = __esm({
@@ -46460,6 +46534,7 @@ var init_dist22 = __esm({
     init_relay_delegation();
     init_invoke_capability();
     init_grant_verifier();
+    init_dist5();
   }
 });
 
@@ -67341,7 +67416,7 @@ var init_execution_receipt = __esm({
     DeviceIdSchema = z2.string().min(1).describe("Device identity \u2014 UUIDv7 string for the signing device. Brand-checked at the type layer; the wire shape is a non-empty string.");
     IntentOriginSchema = z2.enum(["user-tap", "ai-loop", "scheduled", "agent-to-agent"]).describe("How this task was authorized for invocation. `user-tap` = explicit affordance (surface determinism); `ai-loop` = model-mediated delegation; `scheduled` = cron; `agent-to-agent` = another motebit initiated it. Signature-bound \u2014 tampering breaks verification.");
     SuiteSchema = z2.literal("motebit-jcs-ed25519-b64-v1").describe("Cryptosuite identifier. Always `motebit-jcs-ed25519-b64-v1` for ExecutionReceipt today: JCS canonicalization (RFC 8785), Ed25519 signature, base64url-encoded signature, hex-encoded public key. See @motebit/protocol SUITE_REGISTRY.");
-    StatusSchema = z2.enum(["completed", "failed", "denied"]).describe("Terminal state of the task. `completed` = result produced and signed. `failed` = execution errored. `denied` = policy or budget gate rejected the invocation.");
+    StatusSchema = z2.enum(["completed", "failed", "denied"]).describe("Terminal state of the task. `completed` = result produced and signed. `failed` = the execution interior did not yield its outcome (crashes, timeouts, and the worker's own principled refusals all included). `denied` = the governance boundary refused: a policy or budget gate blocked the task's actions and no permitted work completed. The discriminator is who refused \u2014 the boundary (`denied`) or the interior (`failed`). See execution-ledger-v1 \xA711.1 Status semantics.");
     ExecutionReceiptSchema = z2.lazy(() => z2.object({
       task_id: z2.string().min(1).describe("Task identifier \u2014 UUID assigned at submission time; stable across retries."),
       motebit_id: MotebitIdSchema,
@@ -70572,10 +70647,177 @@ var init_goal_tools = __esm({
 });
 
 // ../../packages/tools/dist/builtins/computer.js
+var POINT_SCHEMA, TARGET_HINT_SCHEMA, MODIFIERS_SCHEMA, computerDefinition;
 var init_computer = __esm({
   "../../packages/tools/dist/builtins/computer.js"() {
     "use strict";
     init_esm_shims();
+    POINT_SCHEMA = {
+      type: "object",
+      properties: {
+        x: { type: "integer", description: "Logical pixel X." },
+        y: { type: "integer", description: "Logical pixel Y." }
+      },
+      required: ["x", "y"],
+      additionalProperties: false
+    };
+    TARGET_HINT_SCHEMA = {
+      type: "object",
+      properties: {
+        role: { type: "string", description: "Accessibility role. Examples: 'button', 'link'." },
+        label: { type: "string", description: "Accessible label or visible text." },
+        source: {
+          type: "string",
+          description: "Source: 'accessibility', 'dom', 'vision', 'user_annotation'."
+        }
+      },
+      required: ["source"],
+      additionalProperties: true
+    };
+    MODIFIERS_SCHEMA = {
+      type: "array",
+      items: { type: "string", enum: ["cmd", "ctrl", "alt", "shift"] },
+      description: "Modifier keys held during the action."
+    };
+    computerDefinition = {
+      name: "computer",
+      mode: "pixels",
+      description: "Observe or act on the user's computer \u2014 screenshot, click, type, scroll, navigate. Available on desktop (drives the user's OS via xcap+enigo) and on web (drives a cloud-browser sandbox via Playwright). On the cloud-browser surface, use `navigate` to reach a URL \u2014 there's no address bar for `key`/`type` to drive. Every observation and action emits a signed receipt and flows through the governance gate. See spec/computer-use-v1.md.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          session_id: {
+            type: "string",
+            description: "Open computer-use session identifier. Optional \u2014 if omitted, the runtime's default session for this motebit is used."
+          },
+          action: {
+            description: "Action to perform. Must be a discriminated variant with a `kind` field.",
+            oneOf: [
+              {
+                type: "object",
+                properties: {
+                  kind: { type: "string", enum: ["screenshot"] }
+                },
+                required: ["kind"],
+                additionalProperties: false,
+                description: "Capture the primary display's current frame."
+              },
+              {
+                type: "object",
+                properties: {
+                  kind: { type: "string", enum: ["cursor_position"] }
+                },
+                required: ["kind"],
+                additionalProperties: false,
+                description: "Read the current cursor coordinates."
+              },
+              {
+                type: "object",
+                properties: {
+                  kind: { type: "string", enum: ["click"] },
+                  target: POINT_SCHEMA,
+                  button: { type: "string", enum: ["left", "right", "middle"] },
+                  modifiers: MODIFIERS_SCHEMA,
+                  target_hint: TARGET_HINT_SCHEMA
+                },
+                required: ["kind", "target"],
+                additionalProperties: false,
+                description: "Single mouse click at `target`."
+              },
+              {
+                type: "object",
+                properties: {
+                  kind: { type: "string", enum: ["double_click"] },
+                  target: POINT_SCHEMA,
+                  button: { type: "string", enum: ["left", "right", "middle"] },
+                  modifiers: MODIFIERS_SCHEMA,
+                  target_hint: TARGET_HINT_SCHEMA
+                },
+                required: ["kind", "target"],
+                additionalProperties: false,
+                description: "Double click at `target`."
+              },
+              {
+                type: "object",
+                properties: {
+                  kind: { type: "string", enum: ["mouse_move"] },
+                  target: POINT_SCHEMA,
+                  target_hint: TARGET_HINT_SCHEMA
+                },
+                required: ["kind", "target"],
+                additionalProperties: false,
+                description: "Move cursor to `target` without clicking."
+              },
+              {
+                type: "object",
+                properties: {
+                  kind: { type: "string", enum: ["drag"] },
+                  from: POINT_SCHEMA,
+                  to: POINT_SCHEMA,
+                  button: { type: "string", enum: ["left", "right", "middle"] },
+                  modifiers: MODIFIERS_SCHEMA,
+                  duration_ms: { type: "integer", minimum: 0 },
+                  target_hint: TARGET_HINT_SCHEMA
+                },
+                required: ["kind", "from", "to"],
+                additionalProperties: false,
+                description: "Press at `from`, move to `to`, release."
+              },
+              {
+                type: "object",
+                properties: {
+                  kind: { type: "string", enum: ["type"] },
+                  text: { type: "string", description: "Text to type." },
+                  per_char_delay_ms: { type: "integer", minimum: 0 }
+                },
+                required: ["kind", "text"],
+                additionalProperties: false,
+                description: "Keyboard text input."
+              },
+              {
+                type: "object",
+                properties: {
+                  kind: { type: "string", enum: ["key"] },
+                  key: {
+                    type: "string",
+                    description: "Key combination. Example: 'cmd+c', 'escape'."
+                  }
+                },
+                required: ["kind", "key"],
+                additionalProperties: false,
+                description: "Keyboard combination."
+              },
+              {
+                type: "object",
+                properties: {
+                  kind: { type: "string", enum: ["scroll"] },
+                  target: POINT_SCHEMA,
+                  dx: { type: "integer", description: "Scroll wheel delta X." },
+                  dy: { type: "integer", description: "Scroll wheel delta Y." }
+                },
+                required: ["kind", "target", "dx", "dy"],
+                additionalProperties: false,
+                description: "Scroll at `target` by `(dx, dy)` wheel deltas."
+              },
+              {
+                type: "object",
+                properties: {
+                  kind: { type: "string", enum: ["navigate"] },
+                  url: {
+                    type: "string",
+                    description: "Target URL. Hostnames without a scheme (e.g. 'example.com') are normalized to 'https://example.com'."
+                  }
+                },
+                required: ["kind", "url"],
+                additionalProperties: false,
+                description: "Navigate the active browser context to a URL. Cloud-browser-only \u2014 use this when you need to reach a specific page on the cloud-browser surface (no address bar exists in the headless viewport for `key`/`type` to drive). Not available on the desktop surface (the user controls which app is focused there)."
+              }
+            ]
+          }
+        },
+        required: ["action"]
+      }
+    };
   }
 });
 
@@ -71103,8 +71345,8 @@ function buildCliSkillSelectorHook(getHardwareAttestationScore) {
     }
   };
 }
-function mapNodePlatformToSkillPlatform(nodePlatform) {
-  switch (nodePlatform) {
+function mapNodePlatformToSkillPlatform(nodePlatform2) {
+  switch (nodePlatform2) {
     case "darwin":
       return "macos";
     case "linux":
@@ -71895,6 +72137,134 @@ var init_idempotency = __esm({
   }
 });
 
+// ../../services/relay/dist/loop-supervisor.js
+function superviseInterval(supervisor, name, intervalMs, tick, opts = {}) {
+  supervisor?.register(name, intervalMs);
+  return setInterval(() => {
+    if (opts.isFrozen?.()) {
+      supervisor?.markSkip(name);
+      return;
+    }
+    if (supervisor === void 0) {
+      void Promise.resolve().then(tick).catch(() => {
+      });
+      return;
+    }
+    supervisor.markStart(name);
+    Promise.resolve().then(tick).then(() => supervisor.markOk(name)).catch((err2) => supervisor.markError(name, err2));
+  }, intervalMs);
+}
+var LoopSupervisor;
+var init_loop_supervisor = __esm({
+  "../../services/relay/dist/loop-supervisor.js"() {
+    "use strict";
+    init_esm_shims();
+    LoopSupervisor = class {
+      loops = /* @__PURE__ */ new Map();
+      now;
+      staleFactor;
+      constructor(opts = {}) {
+        this.now = opts.now ?? (() => Date.now());
+        this.staleFactor = opts.staleFactor ?? 3;
+      }
+      /** Register a loop. Idempotent — re-registering preserves existing counters. */
+      register(name, intervalMs) {
+        if (this.loops.has(name))
+          return;
+        this.loops.set(name, {
+          name,
+          intervalMs,
+          registeredAt: this.now(),
+          lastStartAt: null,
+          lastOkAt: null,
+          lastErrorAt: null,
+          lastError: null,
+          lastSkipAt: null,
+          tickCount: 0,
+          okCount: 0,
+          errorCount: 0,
+          skipCount: 0,
+          running: false
+        });
+      }
+      markStart(name) {
+        const r2 = this.loops.get(name);
+        if (!r2)
+          return;
+        r2.lastStartAt = this.now();
+        r2.tickCount += 1;
+        r2.running = true;
+      }
+      markOk(name) {
+        const r2 = this.loops.get(name);
+        if (!r2)
+          return;
+        r2.lastOkAt = this.now();
+        r2.okCount += 1;
+        r2.running = false;
+      }
+      markError(name, err2) {
+        const r2 = this.loops.get(name);
+        if (!r2)
+          return;
+        r2.lastErrorAt = this.now();
+        r2.lastError = err2 instanceof Error ? err2.message : String(err2);
+        r2.errorCount += 1;
+        r2.running = false;
+      }
+      markSkip(name) {
+        const r2 = this.loops.get(name);
+        if (!r2)
+          return;
+        r2.lastSkipAt = this.now();
+        r2.skipCount += 1;
+      }
+      /** Compute the derived status for a record at time `now`. */
+      statusOf(r2, now) {
+        const freshness = r2.intervalMs * this.staleFactor;
+        if (r2.running && r2.lastStartAt != null && now - r2.lastStartAt > freshness)
+          return "hung";
+        const lastHealthy = Math.max(r2.lastOkAt ?? 0, r2.lastSkipAt ?? 0);
+        if (lastHealthy > 0) {
+          if (now - lastHealthy <= freshness)
+            return "ok";
+          if (r2.lastErrorAt != null && r2.lastErrorAt >= lastHealthy)
+            return "erroring";
+          return "stale";
+        }
+        if (r2.lastErrorAt != null)
+          return "erroring";
+        if (now - r2.registeredAt <= freshness)
+          return "idle";
+        return "stale";
+      }
+      snapshot() {
+        const now = this.now();
+        return [...this.loops.values()].map((r2) => ({
+          name: r2.name,
+          interval_ms: r2.intervalMs,
+          registered_at: r2.registeredAt,
+          last_start_at: r2.lastStartAt,
+          last_ok_at: r2.lastOkAt,
+          last_error_at: r2.lastErrorAt,
+          last_error: r2.lastError,
+          last_skip_at: r2.lastSkipAt,
+          tick_count: r2.tickCount,
+          ok_count: r2.okCount,
+          error_count: r2.errorCount,
+          skip_count: r2.skipCount,
+          running: r2.running,
+          status: this.statusOf(r2, now)
+        })).sort((a3, b3) => a3.name.localeCompare(b3.name));
+      }
+      /** True if any registered loop is not `ok`/`idle` — the alerting signal. */
+      anyUnhealthy() {
+        return this.snapshot().some((l6) => l6.status === "stale" || l6.status === "erroring" || l6.status === "hung");
+      }
+    };
+  }
+});
+
 // ../../services/relay/dist/horizon.js
 function truncateExecutionLedgersBeforeHorizon(db, horizonTs) {
   const result = db.prepare("DELETE FROM relay_execution_ledgers WHERE created_at < ?").run(horizonTs);
@@ -72134,16 +72504,17 @@ async function advanceRevocationHorizon(db, ctx) {
   const horizonTs = Date.now() - REVOCATION_TTL_MS;
   return advanceRelayHorizon(db, "relay_revocation_events", horizonTs, ctx);
 }
-function startRevocationHorizonLoop(db, ctx, intervalMs = DEFAULT_REVOCATION_HORIZON_INTERVAL_MS, isFrozen) {
-  return setInterval(() => {
-    if (isFrozen?.())
-      return;
-    void advanceRevocationHorizon(db, ctx).catch((err2) => {
+function startRevocationHorizonLoop(db, ctx, intervalMs = DEFAULT_REVOCATION_HORIZON_INTERVAL_MS, isFrozen, supervisor) {
+  return superviseInterval(supervisor, "revocation-horizon", intervalMs, async () => {
+    try {
+      await advanceRevocationHorizon(db, ctx);
+    } catch (err2) {
       logger9.error("horizon.revocation.loop_tick_failed", {
         error: err2 instanceof Error ? err2.message : String(err2)
       });
-    });
-  }, intervalMs);
+      throw err2;
+    }
+  }, { ...isFrozen ? { isFrozen } : {} });
 }
 var logger9, HORIZON_CERT_SUITE, DEFAULT_WITNESS_SOLICITATION_TIMEOUT_MS, MAX_HORIZON_ADVANCE_ATTEMPTS, HORIZON_RETRY_BACKOFF_MS, PEER_FRESHNESS_FLOOR_MS, STORE_TRUNCATE_REGISTRY, advanceLocks, DEFAULT_REVOCATION_HORIZON_INTERVAL_MS;
 var init_horizon = __esm({
@@ -72156,6 +72527,7 @@ var init_horizon = __esm({
     init_dist30();
     init_federation();
     init_logger();
+    init_loop_supervisor();
     logger9 = createLogger({ service: "relay", module: "horizon" });
     HORIZON_CERT_SUITE = "motebit-jcs-ed25519-b64-v1";
     DEFAULT_WITNESS_SOLICITATION_TIMEOUT_MS = 1e4;
@@ -72174,134 +72546,6 @@ var init_horizon = __esm({
   }
 });
 
-// ../../services/relay/dist/loop-supervisor.js
-function superviseInterval(supervisor, name, intervalMs, tick, opts = {}) {
-  supervisor?.register(name, intervalMs);
-  return setInterval(() => {
-    if (opts.isFrozen?.()) {
-      supervisor?.markSkip(name);
-      return;
-    }
-    if (supervisor === void 0) {
-      void Promise.resolve().then(tick).catch(() => {
-      });
-      return;
-    }
-    supervisor.markStart(name);
-    Promise.resolve().then(tick).then(() => supervisor.markOk(name)).catch((err2) => supervisor.markError(name, err2));
-  }, intervalMs);
-}
-var LoopSupervisor;
-var init_loop_supervisor = __esm({
-  "../../services/relay/dist/loop-supervisor.js"() {
-    "use strict";
-    init_esm_shims();
-    LoopSupervisor = class {
-      loops = /* @__PURE__ */ new Map();
-      now;
-      staleFactor;
-      constructor(opts = {}) {
-        this.now = opts.now ?? (() => Date.now());
-        this.staleFactor = opts.staleFactor ?? 3;
-      }
-      /** Register a loop. Idempotent — re-registering preserves existing counters. */
-      register(name, intervalMs) {
-        if (this.loops.has(name))
-          return;
-        this.loops.set(name, {
-          name,
-          intervalMs,
-          registeredAt: this.now(),
-          lastStartAt: null,
-          lastOkAt: null,
-          lastErrorAt: null,
-          lastError: null,
-          lastSkipAt: null,
-          tickCount: 0,
-          okCount: 0,
-          errorCount: 0,
-          skipCount: 0,
-          running: false
-        });
-      }
-      markStart(name) {
-        const r2 = this.loops.get(name);
-        if (!r2)
-          return;
-        r2.lastStartAt = this.now();
-        r2.tickCount += 1;
-        r2.running = true;
-      }
-      markOk(name) {
-        const r2 = this.loops.get(name);
-        if (!r2)
-          return;
-        r2.lastOkAt = this.now();
-        r2.okCount += 1;
-        r2.running = false;
-      }
-      markError(name, err2) {
-        const r2 = this.loops.get(name);
-        if (!r2)
-          return;
-        r2.lastErrorAt = this.now();
-        r2.lastError = err2 instanceof Error ? err2.message : String(err2);
-        r2.errorCount += 1;
-        r2.running = false;
-      }
-      markSkip(name) {
-        const r2 = this.loops.get(name);
-        if (!r2)
-          return;
-        r2.lastSkipAt = this.now();
-        r2.skipCount += 1;
-      }
-      /** Compute the derived status for a record at time `now`. */
-      statusOf(r2, now) {
-        const freshness = r2.intervalMs * this.staleFactor;
-        if (r2.running && r2.lastStartAt != null && now - r2.lastStartAt > freshness)
-          return "hung";
-        const lastHealthy = Math.max(r2.lastOkAt ?? 0, r2.lastSkipAt ?? 0);
-        if (lastHealthy > 0) {
-          if (now - lastHealthy <= freshness)
-            return "ok";
-          if (r2.lastErrorAt != null && r2.lastErrorAt >= lastHealthy)
-            return "erroring";
-          return "stale";
-        }
-        if (r2.lastErrorAt != null)
-          return "erroring";
-        if (now - r2.registeredAt <= freshness)
-          return "idle";
-        return "stale";
-      }
-      snapshot() {
-        const now = this.now();
-        return [...this.loops.values()].map((r2) => ({
-          name: r2.name,
-          interval_ms: r2.intervalMs,
-          registered_at: r2.registeredAt,
-          last_start_at: r2.lastStartAt,
-          last_ok_at: r2.lastOkAt,
-          last_error_at: r2.lastErrorAt,
-          last_error: r2.lastError,
-          last_skip_at: r2.lastSkipAt,
-          tick_count: r2.tickCount,
-          ok_count: r2.okCount,
-          error_count: r2.errorCount,
-          skip_count: r2.skipCount,
-          running: r2.running,
-          status: this.statusOf(r2, now)
-        })).sort((a3, b3) => a3.name.localeCompare(b3.name));
-      }
-      /** True if any registered loop is not `ok`/`idle` — the alerting signal. */
-      anyUnhealthy() {
-        return this.snapshot().some((l6) => l6.status === "stale" || l6.status === "erroring" || l6.status === "hung");
-      }
-    };
-  }
-});
-
 // ../../services/relay/dist/anchoring.js
 function createAnchoringTables(db) {
   db.exec(`
@@ -72420,43 +72664,40 @@ async function submitAnchorOnChain(db, batchId, submitter) {
     return false;
   }
 }
-function startBatchAnchorLoop(db, relayIdentity, config = {}, isFrozen) {
+function startBatchAnchorLoop(db, relayIdentity, config = {}, isFrozen, supervisor) {
   const maxSize = config.batchMaxSize ?? DEFAULT_BATCH_MAX_SIZE;
   const intervalMs = config.batchIntervalMs ?? DEFAULT_BATCH_INTERVAL_MS;
   const checkIntervalMs = Math.min(6e4, intervalMs);
   const submitter = config.submitter;
-  return setInterval(() => {
-    if (isFrozen?.())
-      return;
-    void (async () => {
-      try {
-        const countRow = db.prepare("SELECT COUNT(*) as cnt FROM relay_federation_settlements WHERE anchor_batch_id IS NULL AND record_json IS NOT NULL").get();
-        if (countRow.cnt === 0)
-          return;
-        let batch = null;
-        if (countRow.cnt >= maxSize) {
+  return superviseInterval(supervisor, "federation-anchor", checkIntervalMs, async () => {
+    try {
+      const countRow = db.prepare("SELECT COUNT(*) as cnt FROM relay_federation_settlements WHERE anchor_batch_id IS NULL AND record_json IS NOT NULL").get();
+      if (countRow.cnt === 0)
+        return;
+      let batch = null;
+      if (countRow.cnt >= maxSize) {
+        batch = await cutBatch(db, relayIdentity, maxSize);
+      } else {
+        const oldest = db.prepare("SELECT MIN(settled_at) as oldest FROM relay_federation_settlements WHERE anchor_batch_id IS NULL AND record_json IS NOT NULL").get();
+        if (oldest.oldest != null && Date.now() - oldest.oldest >= intervalMs) {
           batch = await cutBatch(db, relayIdentity, maxSize);
-        } else {
-          const oldest = db.prepare("SELECT MIN(settled_at) as oldest FROM relay_federation_settlements WHERE anchor_batch_id IS NULL AND record_json IS NOT NULL").get();
-          if (oldest.oldest != null && Date.now() - oldest.oldest >= intervalMs) {
-            batch = await cutBatch(db, relayIdentity, maxSize);
-          }
-        }
-        if (batch && submitter) {
-          await submitAnchorOnChain(db, batch.batch_id, submitter);
         }
-        if (submitter) {
-          const failedBatches = db.prepare("SELECT batch_id FROM relay_anchor_batches WHERE status = 'signed' AND tx_hash IS NULL").all();
-          for (const fb of failedBatches) {
-            await submitAnchorOnChain(db, fb.batch_id, submitter);
-          }
+      }
+      if (batch && submitter) {
+        await submitAnchorOnChain(db, batch.batch_id, submitter);
+      }
+      if (submitter) {
+        const failedBatches = db.prepare("SELECT batch_id FROM relay_anchor_batches WHERE status = 'signed' AND tx_hash IS NULL").all();
+        for (const fb of failedBatches) {
+          await submitAnchorOnChain(db, fb.batch_id, submitter);
         }
-      } catch (err2) {
-        const message2 = err2 instanceof Error ? err2.message : String(err2);
-        logger10.error("anchoring.loop_error", { error: message2 });
       }
-    })();
-  }, checkIntervalMs);
+    } catch (err2) {
+      const message2 = err2 instanceof Error ? err2.message : String(err2);
+      logger10.error("anchoring.loop_error", { error: message2 });
+      throw err2;
+    }
+  }, { ...isFrozen ? { isFrozen } : {} });
 }
 async function getSettlementProof(db, settlementId) {
   const settlement = db.prepare(`SELECT settlement_id, settled_at, record_json, anchor_batch_id
@@ -72644,43 +72885,40 @@ function chainAnchorFromRow(row) {
     anchored_at: row.anchored_at
   };
 }
-function startAgentSettlementAnchorLoop(db, relayIdentity, config = {}, isFrozen) {
+function startAgentSettlementAnchorLoop(db, relayIdentity, config = {}, isFrozen, supervisor) {
   const maxSize = config.batchMaxSize ?? DEFAULT_BATCH_MAX_SIZE;
   const intervalMs = config.batchIntervalMs ?? DEFAULT_BATCH_INTERVAL_MS;
   const checkIntervalMs = Math.min(6e4, intervalMs);
   const submitter = config.submitter;
-  return setInterval(() => {
-    if (isFrozen?.())
-      return;
-    void (async () => {
-      try {
-        const countRow = db.prepare("SELECT COUNT(*) as cnt FROM relay_settlements WHERE anchor_batch_id IS NULL AND signature IS NOT NULL").get();
-        if (countRow.cnt === 0)
-          return;
-        let batch = null;
-        if (countRow.cnt >= maxSize) {
+  return superviseInterval(supervisor, "agent-settlement-anchor", checkIntervalMs, async () => {
+    try {
+      const countRow = db.prepare("SELECT COUNT(*) as cnt FROM relay_settlements WHERE anchor_batch_id IS NULL AND signature IS NOT NULL").get();
+      if (countRow.cnt === 0)
+        return;
+      let batch = null;
+      if (countRow.cnt >= maxSize) {
+        batch = await cutAgentSettlementBatch(db, relayIdentity, maxSize);
+      } else {
+        const oldest = db.prepare("SELECT MIN(settled_at) as oldest FROM relay_settlements WHERE anchor_batch_id IS NULL AND signature IS NOT NULL").get();
+        if (oldest.oldest != null && Date.now() - oldest.oldest >= intervalMs) {
           batch = await cutAgentSettlementBatch(db, relayIdentity, maxSize);
-        } else {
-          const oldest = db.prepare("SELECT MIN(settled_at) as oldest FROM relay_settlements WHERE anchor_batch_id IS NULL AND signature IS NOT NULL").get();
-          if (oldest.oldest != null && Date.now() - oldest.oldest >= intervalMs) {
-            batch = await cutAgentSettlementBatch(db, relayIdentity, maxSize);
-          }
         }
-        if (batch && submitter) {
-          await submitAgentAnchorOnChain(db, batch.batch_id, submitter);
-        }
-        if (submitter) {
-          const failedBatches = db.prepare("SELECT batch_id FROM relay_agent_anchor_batches WHERE status = 'signed' AND tx_hash IS NULL").all();
-          for (const fb of failedBatches) {
-            await submitAgentAnchorOnChain(db, fb.batch_id, submitter);
-          }
+      }
+      if (batch && submitter) {
+        await submitAgentAnchorOnChain(db, batch.batch_id, submitter);
+      }
+      if (submitter) {
+        const failedBatches = db.prepare("SELECT batch_id FROM relay_agent_anchor_batches WHERE status = 'signed' AND tx_hash IS NULL").all();
+        for (const fb of failedBatches) {
+          await submitAgentAnchorOnChain(db, fb.batch_id, submitter);
         }
-      } catch (err2) {
-        const message2 = err2 instanceof Error ? err2.message : String(err2);
-        logger10.error("anchoring.agent_loop_error", { error: message2 });
       }
-    })();
-  }, checkIntervalMs);
+    } catch (err2) {
+      const message2 = err2 instanceof Error ? err2.message : String(err2);
+      logger10.error("anchoring.agent_loop_error", { error: message2 });
+      throw err2;
+    }
+  }, { ...isFrozen ? { isFrozen } : {} });
 }
 async function getAgentSettlementProof(db, settlementId) {
   const settlement = db.prepare(`SELECT settlement_id, settled_at, record_json, anchor_batch_id
@@ -72738,6 +72976,7 @@ var init_anchoring = __esm({
     init_esm_shims();
     init_dist6();
     init_logger();
+    init_loop_supervisor();
     AGENT_SETTLEMENT_ANCHOR_SUITE2 = "motebit-jcs-ed25519-hex-v1";
     FEDERATION_SETTLEMENT_ANCHOR_SUITE2 = "motebit-jcs-ed25519-hex-v1";
     AGENT_SETTLEMENT_TREE_HASH_VERSION = "merkle-sha256-rfc6962-v2";
@@ -72868,43 +73107,40 @@ async function submitCredentialAnchorOnChain(db, batchId, submitter) {
     return false;
   }
 }
-function startCredentialAnchorLoop(db, relayIdentity, config = {}, isFrozen) {
+function startCredentialAnchorLoop(db, relayIdentity, config = {}, isFrozen, supervisor) {
   const maxSize = config.batchMaxSize ?? DEFAULT_BATCH_MAX_SIZE2;
   const intervalMs = config.batchIntervalMs ?? DEFAULT_BATCH_INTERVAL_MS2;
   const submitter = config.submitter;
   const checkIntervalMs = Math.min(6e4, intervalMs);
-  return setInterval(() => {
-    if (isFrozen?.())
-      return;
-    void (async () => {
-      try {
-        const countRow = db.prepare("SELECT COUNT(*) as cnt FROM relay_credentials WHERE anchor_batch_id IS NULL").get();
-        if (countRow.cnt === 0)
-          return;
-        let batch = null;
-        if (countRow.cnt >= maxSize) {
+  return superviseInterval(supervisor, "credential-anchor", checkIntervalMs, async () => {
+    try {
+      const countRow = db.prepare("SELECT COUNT(*) as cnt FROM relay_credentials WHERE anchor_batch_id IS NULL").get();
+      if (countRow.cnt === 0)
+        return;
+      let batch = null;
+      if (countRow.cnt >= maxSize) {
+        batch = await cutCredentialBatch(db, relayIdentity, maxSize);
+      } else {
+        const oldest = db.prepare("SELECT MIN(issued_at) as oldest FROM relay_credentials WHERE anchor_batch_id IS NULL").get();
+        if (oldest.oldest != null && Date.now() - oldest.oldest >= intervalMs) {
           batch = await cutCredentialBatch(db, relayIdentity, maxSize);
-        } else {
-          const oldest = db.prepare("SELECT MIN(issued_at) as oldest FROM relay_credentials WHERE anchor_batch_id IS NULL").get();
-          if (oldest.oldest != null && Date.now() - oldest.oldest >= intervalMs) {
-            batch = await cutCredentialBatch(db, relayIdentity, maxSize);
-          }
-        }
-        if (batch && submitter) {
-          await submitCredentialAnchorOnChain(db, batch.batch_id, submitter);
         }
-        if (submitter) {
-          const failedBatches = db.prepare("SELECT batch_id FROM relay_credential_anchor_batches WHERE status = 'signed' AND tx_hash IS NULL").all();
-          for (const fb of failedBatches) {
-            await submitCredentialAnchorOnChain(db, fb.batch_id, submitter);
-          }
+      }
+      if (batch && submitter) {
+        await submitCredentialAnchorOnChain(db, batch.batch_id, submitter);
+      }
+      if (submitter) {
+        const failedBatches = db.prepare("SELECT batch_id FROM relay_credential_anchor_batches WHERE status = 'signed' AND tx_hash IS NULL").all();
+        for (const fb of failedBatches) {
+          await submitCredentialAnchorOnChain(db, fb.batch_id, submitter);
         }
-      } catch (err2) {
-        const message2 = err2 instanceof Error ? err2.message : String(err2);
-        logger11.error("credential_anchoring.loop_error", { error: message2 });
       }
-    })();
-  }, checkIntervalMs);
+    } catch (err2) {
+      const message2 = err2 instanceof Error ? err2.message : String(err2);
+      logger11.error("credential_anchoring.loop_error", { error: message2 });
+      throw err2;
+    }
+  }, { ...isFrozen ? { isFrozen } : {} });
 }
 async function getCredentialAnchorProof(db, credentialId) {
   const credential = db.prepare(`SELECT credential_id, credential_json, issued_at, anchor_batch_id
@@ -73041,6 +73277,7 @@ var init_credential_anchoring = __esm({
     init_esm_shims();
     init_dist6();
     init_logger();
+    init_loop_supervisor();
     logger11 = createLogger({ service: "relay", module: "credential-anchoring" });
     CREDENTIAL_TREE_HASH_VERSION = "merkle-sha256-rfc6962-v2";
     DEFAULT_BATCH_MAX_SIZE2 = 50;
@@ -74043,18 +74280,19 @@ function createTaskRouter(deps) {
         return [];
       }
       try {
+        const discoverBody = await signDiscoverBody({
+          query: { capability: requiredCaps[0], limit: 20 },
+          hop_count: 0,
+          max_hops: 1,
+          // Only one hop for task routing candidates
+          visited,
+          query_id: queryId,
+          origin_relay: relayIdentity.relayMotebitId
+        }, relayIdentity);
         const resp = await fetch(`${peer.endpoint_url}/federation/v1/discover`, {
           method: "POST",
           headers: { "Content-Type": "application/json", "X-Correlation-ID": queryId },
-          body: JSON.stringify({
-            query: { capability: requiredCaps[0], limit: 20 },
-            hop_count: 0,
-            max_hops: 1,
-            // Only one hop for task routing candidates
-            visited,
-            query_id: queryId,
-            origin_relay: relayIdentity.relayMotebitId
-          }),
+          body: JSON.stringify(discoverBody),
           signal: AbortSignal.timeout(5e3)
         });
         if (!resp.ok)
@@ -74456,6 +74694,7 @@ var init_task_routing = __esm({
     init_dist34();
     init_dist5();
     init_dist6();
+    init_federation();
     init_dist35();
     init_logger();
     logger12 = createLogger({ service: "relay", module: "task-routing" });
@@ -76162,6 +76401,7 @@ __export(federation_exports, {
   registerFederationRoutes: () => registerFederationRoutes,
   sendHeartbeats: () => sendHeartbeats,
   setRevocationAnchorSubmitter: () => setRevocationAnchorSubmitter,
+  signDiscoverBody: () => signDiscoverBody,
   startHeartbeatLoop: () => startHeartbeatLoop,
   startSettlementRetryLoop: () => startSettlementRetryLoop
 });
@@ -76447,15 +76687,15 @@ async function initRelayIdentity(db, passphrase, logger39) {
     did
   };
 }
-function createFederationQueryCache() {
+function createFederationQueryCache(supervisor) {
   const cache2 = /* @__PURE__ */ new Map();
-  const pruneInterval = setInterval(() => {
+  const pruneInterval = superviseInterval(supervisor, "federation-query-cache-prune", FEDERATION_QUERY_TTL_MS, () => {
     const cutoff = Date.now() - FEDERATION_QUERY_TTL_MS;
     for (const [id, ts] of cache2) {
       if (ts < cutoff)
         cache2.delete(id);
     }
-  }, FEDERATION_QUERY_TTL_MS);
+  });
   return { cache: cache2, pruneInterval };
 }
 async function sendHeartbeats(db, relayIdentity) {
@@ -76573,21 +76813,18 @@ async function processSettlementRetries(db, relayIdentity, onRetryExhausted, ret
 function startSettlementRetryLoop(db, relayIdentity, intervalMs = 3e4, onRetryExhausted, isFrozen, retryPolicy = DEFAULT_RETRY_POLICY, supervisor) {
   return superviseInterval(supervisor, "settlement-retry", intervalMs, () => processSettlementRetries(db, relayIdentity, onRetryExhausted, retryPolicy), { isFrozen });
 }
-function startHeartbeatLoop(db, relayIdentity, intervalMs = 6e4, isFrozen) {
-  return setInterval(() => {
-    if (isFrozen?.())
-      return;
-    void sendHeartbeats(db, relayIdentity);
-  }, intervalMs);
+function startHeartbeatLoop(db, relayIdentity, intervalMs = 6e4, isFrozen, supervisor) {
+  return superviseInterval(supervisor, "federation-heartbeat", intervalMs, () => sendHeartbeats(db, relayIdentity), { ...isFrozen ? { isFrozen } : {} });
 }
 async function verifyPeerSignature(db, peerId, signatureHex, payloadBytes, allowedStates = ["active"], timestamp) {
-  if (timestamp != null) {
-    const drift = Math.abs(Date.now() - timestamp);
-    if (drift > FEDERATION_TIMESTAMP_DRIFT_MS) {
-      throw new HTTPException6(400, {
-        message: "Request timestamp outside acceptable drift (\xB15min)"
-      });
-    }
+  if (timestamp == null || !Number.isFinite(timestamp)) {
+    throw new HTTPException6(400, { message: "Federation request timestamp required" });
+  }
+  const drift = Math.abs(Date.now() - timestamp);
+  if (drift > FEDERATION_TIMESTAMP_DRIFT_MS) {
+    throw new HTTPException6(400, {
+      message: "Request timestamp outside acceptable drift (\xB15min)"
+    });
   }
   const stateList = allowedStates.map(() => "?").join(", ");
   const peer = db.prepare(`SELECT public_key FROM relay_peers WHERE peer_relay_id = ? AND state IN (${stateList})`).get(peerId, ...allowedStates);
@@ -76600,6 +76837,31 @@ async function verifyPeerSignature(db, peerId, signatureHex, payloadBytes, allow
   }
   return peer.public_key;
 }
+async function signDiscoverBody(body, relayIdentity) {
+  const signed = {
+    ...body,
+    sender_relay: relayIdentity.relayMotebitId,
+    timestamp: Date.now()
+  };
+  const sig = await ed25519Sign(new TextEncoder().encode(canonicalJson(signed)), relayIdentity.privateKey);
+  return { ...signed, signature: bytesToHex4(sig) };
+}
+async function verifyDiscoverSender(db, body, requireSignature) {
+  if (body.signature == null) {
+    if (requireSignature) {
+      throw new HTTPException6(403, { message: "Unsigned discovery request rejected" });
+    }
+    return null;
+  }
+  if (typeof body.sender_relay !== "string") {
+    throw new HTTPException6(400, { message: "Signed discovery request missing sender_relay" });
+  }
+  if (typeof body.timestamp !== "number") {
+    throw new HTTPException6(400, { message: "Signed discovery request missing timestamp" });
+  }
+  const { signature, ...payload } = body;
+  return verifyPeerSignature(db, body.sender_relay, signature, new TextEncoder().encode(canonicalJson(payload)), ["active"], body.timestamp);
+}
 function registerFederationRoutes(deps) {
   const { db, app, relayIdentity, federationConfig, federationQueryCache } = deps;
   const peerLimiter = new FixedWindowLimiter(30, 6e4);
@@ -76614,6 +76876,7 @@ function registerFederationRoutes(deps) {
   }
   const federationEnabled = federationConfig?.enabled !== void 0 ? federationConfig.enabled : federationConfig?.endpointUrl != null;
   const maxPeers = federationConfig?.maxPeers ?? 50;
+  const requireDiscoverSignature = federationConfig?.requireDiscoverSignature ?? false;
   function checkFederationEnabled() {
     if (!federationEnabled) {
       throw new HTTPException6(403, { message: "Federation is disabled on this relay" });
@@ -77029,7 +77292,14 @@ function registerFederationRoutes(deps) {
     if (!federationEnabled) {
       return c3.json({ agents: [] });
     }
-    checkPeerLimit(body.origin_relay);
+    const verifiedSender = await verifyDiscoverSender(db, body, requireDiscoverSignature);
+    if (verifiedSender == null) {
+      logger17.warn("federation.discover.unsigned", {
+        origin_relay: body.origin_relay,
+        query_id: body.query_id
+      });
+    }
+    checkPeerLimit(verifiedSender ?? body.origin_relay);
     if (federationQueryCache.has(body.query_id))
       return c3.json({ agents: [] });
     federationQueryCache.set(body.query_id, Date.now());
@@ -77052,20 +77322,21 @@ function registerFederationRoutes(deps) {
     const peers = db.prepare("SELECT peer_relay_id, endpoint_url FROM relay_peers WHERE state = 'active'").all();
     const forwardPromises = peers.filter((p5) => !visitedSet.has(p5.peer_relay_id)).map(async (peer) => {
       try {
+        const forwardBody = await signDiscoverBody({
+          query: body.query,
+          hop_count: body.hop_count + 1,
+          max_hops: body.max_hops,
+          visited,
+          query_id: body.query_id,
+          origin_relay: body.origin_relay
+        }, relayIdentity);
         const resp = await fetch(`${peer.endpoint_url}/federation/v1/discover`, {
           method: "POST",
           headers: {
             "Content-Type": "application/json",
             "X-Correlation-ID": body.query_id
           },
-          body: JSON.stringify({
-            query: body.query,
-            hop_count: body.hop_count + 1,
-            max_hops: body.max_hops,
-            visited,
-            query_id: body.query_id,
-            origin_relay: body.origin_relay
-          }),
+          body: JSON.stringify(forwardBody),
           signal: AbortSignal.timeout(5e3)
         });
         if (!resp.ok)
@@ -77201,7 +77472,7 @@ var init_federation = __esm({
     init_retry_policy();
     init_dist30();
     FEDERATION_SUITE = "motebit-concat-ed25519-hex-v1";
-    RELAY_SPEC_VERSION = "motebit/relay-federation@1.2";
+    RELAY_SPEC_VERSION = "motebit/relay-federation@1.3";
     logger17 = createLogger({ service: "relay", module: "federation" });
     REVOCATION_TTL_MS = 7 * 24 * 60 * 60 * 1e3;
     PBKDF2_ITERATIONS = 6e5;
@@ -77561,10 +77832,12 @@ function startDepositDetector(config) {
         chain: config.chain,
         error: err2 instanceof Error ? err2.message : String(err2)
       });
+      throw err2;
     }
   };
-  void tick();
-  return setInterval(() => void tick(), intervalMs);
+  void tick().catch(() => {
+  });
+  return superviseInterval(config.supervisor, "deposit-detector", intervalMs, tick);
 }
 var logger18, TRANSFER_TOPIC, USDC_CONTRACTS, DEFAULT_RPC_URLS, CONFIRMATIONS_BY_CHAIN, USDC_ONCHAIN_TO_MICRO, SqliteDepositDetectorStore;
 var init_deposit_detector = __esm({
@@ -77575,6 +77848,7 @@ var init_deposit_detector = __esm({
     init_dist38();
     init_account_store_sqlite();
     init_logger();
+    init_loop_supervisor();
     logger18 = createLogger({ service: "deposit-detector" });
     TRANSFER_TOPIC = "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef";
     USDC_CONTRACTS = {
@@ -80814,18 +81088,19 @@ async function runIdentityLogAnchorTick(db, relayIdentity, config = {}) {
     await submitIdentityLogAnchorOnChain(db, anchor.anchor_id, submitter);
   }
 }
-function startIdentityLogAnchorLoop(db, relayIdentity, config = {}, isFrozen) {
+function startIdentityLogAnchorLoop(db, relayIdentity, config = {}, isFrozen, supervisor) {
   const intervalMs = config.intervalMs ?? DEFAULT_IDENTITY_ANCHOR_INTERVAL_MS;
   const checkIntervalMs = Math.min(IDENTITY_ANCHOR_CHECK_INTERVAL_MS, intervalMs);
-  return setInterval(() => {
-    if (isFrozen?.())
-      return;
-    void runIdentityLogAnchorTick(db, relayIdentity, config).catch((err2) => {
+  return superviseInterval(supervisor, "identity-log-anchor", checkIntervalMs, async () => {
+    try {
+      await runIdentityLogAnchorTick(db, relayIdentity, config);
+    } catch (err2) {
       logger33.error("identity_log.anchor_loop_error", {
         error: err2 instanceof Error ? err2.message : String(err2)
       });
-    });
-  }, checkIntervalMs);
+      throw err2;
+    }
+  }, { ...isFrozen ? { isFrozen } : {} });
 }
 var logger33, IDENTITY_LOG_TREE_HASH_VERSION, DEFAULT_IDENTITY_ANCHOR_INTERVAL_MS, IDENTITY_ANCHOR_CHECK_INTERVAL_MS;
 var init_identity_log_anchoring = __esm({
@@ -80834,6 +81109,7 @@ var init_identity_log_anchoring = __esm({
     init_esm_shims();
     init_dist6();
     init_logger();
+    init_loop_supervisor();
     init_identity_log();
     init_identity_transparency();
     logger33 = createLogger({ service: "relay", module: "identity-log-anchoring" });
@@ -81815,13 +82091,16 @@ async function runDeferredOrchestrationCycle(deps) {
 }
 function startDeferredOrchestrationWorker(deps) {
   const intervalMs = deps.intervalMs ?? ORCHESTRATION_WORKER_INTERVAL_MS;
-  const handle = setInterval(() => {
-    void runDeferredOrchestrationCycle(deps).catch((err2) => {
+  const handle = superviseInterval(deps.supervisor, "dispute-orchestration", intervalMs, async () => {
+    try {
+      await runDeferredOrchestrationCycle(deps);
+    } catch (err2) {
       logger36.warn("dispute.orchestration.cycle_failed", {
         error: err2 instanceof Error ? err2.message : String(err2)
       });
-    });
-  }, intervalMs);
+      throw err2;
+    }
+  });
   if (typeof handle.unref === "function")
     handle.unref();
   return handle;
@@ -82359,6 +82638,7 @@ var init_disputes = __esm({
     init_dist30();
     init_accounts();
     init_logger();
+    init_loop_supervisor();
     init_dispute_orchestration();
     logger36 = createLogger({ service: "relay", module: "disputes" });
     EVIDENCE_WINDOW_MS = 48 * 60 * 60 * 1e3;
@@ -84351,6 +84631,1441 @@ async function consumeStream(stream, runtime, opts) {
   }
 }
 
+// src/runtime-host.ts
+init_esm_shims();
+
+// ../../packages/runtime-host/dist/index.js
+init_esm_shims();
+
+// ../../packages/runtime-host/dist/protocol.js
+init_esm_shims();
+var RUNTIME_HOST_PROTOCOL_VERSION = 1;
+var MAX_FRAME_BYTES = 4 * 1024 * 1024;
+function encodeFrame(message2) {
+  return `${JSON.stringify(message2)}
+`;
+}
+var JsonLineDecoder = class {
+  buffer = "";
+  // Streaming decoder: a multibyte UTF-8 character split across two
+  // socket chunks must not corrupt — `stream: true` holds the partial
+  // sequence until its continuation bytes arrive.
+  utf8 = new TextDecoder();
+  push(data) {
+    this.buffer += typeof data === "string" ? data : this.utf8.decode(data, { stream: true });
+    if (this.buffer.length > MAX_FRAME_BYTES) {
+      throw new Error(`frame exceeds ${MAX_FRAME_BYTES} bytes`);
+    }
+    const frames = [];
+    let newline = this.buffer.indexOf("\n");
+    while (newline !== -1) {
+      const line = this.buffer.slice(0, newline);
+      this.buffer = this.buffer.slice(newline + 1);
+      if (line.trim().length > 0) {
+        let parsed;
+        try {
+          parsed = JSON.parse(line);
+        } catch (err2) {
+          throw new Error(`malformed frame: ${err2 instanceof Error ? err2.message : String(err2)}`, {
+            cause: err2
+          });
+        }
+        if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
+          throw new Error("malformed frame: not a JSON object");
+        }
+        frames.push(parsed);
+      }
+      newline = this.buffer.indexOf("\n");
+    }
+    return frames;
+  }
+};
+
+// ../../packages/runtime-host/dist/paths-shared.js
+init_esm_shims();
+function isWindowsPipePath(path19) {
+  return path19.startsWith("\\\\.\\pipe\\");
+}
+
+// ../../packages/runtime-host/dist/lockfile.js
+init_esm_shims();
+async function readLockfile(platform, path19) {
+  const raw = await platform.readFile(path19);
+  if (raw === null)
+    return null;
+  try {
+    const parsed = JSON.parse(raw);
+    if (parsed === null || typeof parsed !== "object")
+      return null;
+    const record = parsed;
+    if (typeof record.pid !== "number" || typeof record.bound_at !== "number" || typeof record.protocol_version !== "number") {
+      return null;
+    }
+    return {
+      pid: record.pid,
+      bound_at: record.bound_at,
+      protocol_version: record.protocol_version
+    };
+  } catch {
+    return null;
+  }
+}
+async function writeLockfile(platform, path19, record) {
+  await platform.writeFile(path19, `${JSON.stringify(record)}
+`);
+}
+async function removeLockfile(platform, path19, pid) {
+  const current = await readLockfile(platform, path19);
+  if (current !== null && current.pid !== pid)
+    return;
+  try {
+    await platform.removeFile(path19);
+  } catch {
+  }
+}
+
+// ../../packages/runtime-host/dist/server.js
+init_esm_shims();
+init_dist5();
+init_dist();
+var CoordinatorAlreadyBoundError = class extends Error {
+  constructor(socketPath) {
+    super(`another process already binds ${socketPath}`);
+    this.name = "CoordinatorAlreadyBoundError";
+  }
+};
+function parseTokenClaims(token) {
+  const dot = token.indexOf(".");
+  if (dot <= 0)
+    return null;
+  try {
+    const payload = JSON.parse(new TextDecoder().decode(fromBase64Url(token.slice(0, dot))));
+    if (payload === null || typeof payload !== "object")
+      return null;
+    const record = payload;
+    if (typeof record.mid !== "string" || typeof record.did !== "string" || typeof record.aud !== "string") {
+      return null;
+    }
+    return { mid: record.mid, did: record.did, aud: record.aud };
+  } catch {
+    return null;
+  }
+}
+var RuntimeHostServer = class _RuntimeHostServer {
+  listener;
+  opts;
+  pid;
+  connections = /* @__PURE__ */ new Set();
+  /** capability → the connection contributing it (last registrar wins). */
+  bridged = /* @__PURE__ */ new Map();
+  bridgeInflight = /* @__PURE__ */ new Map();
+  capabilityListeners = /* @__PURE__ */ new Set();
+  bridgeCounter = 0;
+  closed = false;
+  constructor(listener, opts, pid) {
+    this.listener = listener;
+    this.opts = opts;
+    this.pid = pid;
+  }
+  /**
+   * Bind the canonical endpoint and become the coordinator. Throws
+   * `CoordinatorAlreadyBoundError` when another listener holds it —
+   * the caller attaches instead. The caller is responsible for
+   * clearing a *verified-stale* socket file first (the election does
+   * this); bind never unlinks.
+   */
+  static async bind(opts) {
+    const pid = opts.pid ?? opts.platform.pid;
+    const now = opts.now ?? (() => Date.now());
+    const bound = await opts.platform.bind(opts.socketPath);
+    if (bound === "in_use")
+      throw new CoordinatorAlreadyBoundError(opts.socketPath);
+    const host = new _RuntimeHostServer(bound, opts, pid);
+    bound.onConnection((conn) => host.onConnection(conn));
+    await writeLockfile(opts.platform, opts.lockfilePath, {
+      pid,
+      bound_at: now(),
+      protocol_version: RUNTIME_HOST_PROTOCOL_VERSION
+    });
+    return host;
+  }
+  get attachedCount() {
+    let count2 = 0;
+    for (const conn of this.connections)
+      if (conn.authenticated)
+        count2 += 1;
+    return count2;
+  }
+  /** The organs currently contributed by attached frontends. */
+  get bridgedCapabilities() {
+    return [...this.bridged.keys()];
+  }
+  /**
+   * Subscribe to changes in the bridged-organ set — fired after a
+   * frontend registers capabilities and after a contributing frontend
+   * disconnects. The listener receives the CURRENT full set (idempotent
+   * sync semantics, never deltas: last-registrar-wins and multi-frontend
+   * churn collapse to "reconcile against this"). Returns unsubscribe.
+   */
+  onBridgedCapabilitiesChanged(listener) {
+    this.capabilityListeners.add(listener);
+    return () => this.capabilityListeners.delete(listener);
+  }
+  /**
+   * Listener faults must not tear down the coordinator or the frame
+   * that triggered the change — log and keep serving.
+   */
+  notifyCapabilitiesChanged() {
+    const capabilities = this.bridgedCapabilities;
+    for (const listener of this.capabilityListeners) {
+      try {
+        listener(capabilities);
+      } catch (err2) {
+        this.opts.logger?.warn("runtime-host: bridged-capabilities listener failed", {
+          error: err2 instanceof Error ? err2.message : String(err2)
+        });
+      }
+    }
+  }
+  /** Push an event to every attached frontend subscribed to `channel`. */
+  publishEvent(channel, payload) {
+    for (const conn of this.connections) {
+      if (conn.authenticated && conn.channels.has(channel)) {
+        this.send(conn, { t: "event", channel, payload });
+      }
+    }
+  }
+  /**
+   * Invoke an organ a frontend contributed — the bridging half of the
+   * election doctrine. Streams the frontend's chunks; throws honestly
+   * when no attached frontend contributes the capability or the
+   * contributor disconnects mid-stream (fail-loud, never silent retry
+   * across the authority boundary).
+   */
+  async *invokeBridged(capability, prompt2, options) {
+    const conn = this.bridged.get(capability);
+    if (conn === void 0 || conn.conn.destroyed) {
+      throw new Error(`no attached frontend contributes capability "${capability}"`);
+    }
+    this.bridgeCounter += 1;
+    const id = `bridge-${this.bridgeCounter}`;
+    const state = { conn, queue: [], done: false, error: null, wake: null };
+    this.bridgeInflight.set(id, state);
+    conn.bridgeIds.add(id);
+    this.send(conn, { t: "bridge_invoke", id, capability, prompt: prompt2, options });
+    try {
+      for (; ; ) {
+        while (state.queue.length > 0)
+          yield state.queue.shift();
+        if (state.error !== null)
+          throw state.error;
+        if (state.done)
+          return;
+        await new Promise((resolve14) => {
+          state.wake = resolve14;
+        });
+        state.wake = null;
+      }
+    } finally {
+      this.bridgeInflight.delete(id);
+      conn.bridgeIds.delete(id);
+    }
+  }
+  /** Stop coordinating: drop connections, release the socket + lock. */
+  async close() {
+    if (this.closed)
+      return;
+    this.closed = true;
+    for (const conn of this.connections)
+      this.destroyConnection(conn);
+    await this.listener.close();
+    await this.opts.platform.removeSocketFile(this.opts.socketPath);
+    await removeLockfile(this.opts.platform, this.opts.lockfilePath, this.pid);
+  }
+  onConnection(frameConn) {
+    const conn = {
+      conn: frameConn,
+      decoder: new JsonLineDecoder(),
+      authenticated: false,
+      channels: /* @__PURE__ */ new Set(),
+      capabilities: /* @__PURE__ */ new Set(),
+      inflight: /* @__PURE__ */ new Map(),
+      bridgeIds: /* @__PURE__ */ new Set(),
+      handshakeTimer: null
+    };
+    this.connections.add(conn);
+    conn.handshakeTimer = setTimeout(() => {
+      if (!conn.authenticated)
+        this.destroyConnection(conn);
+    }, this.opts.handshakeTimeoutMs ?? 5e3);
+    frameConn.onData((data) => {
+      let frames;
+      try {
+        frames = conn.decoder.push(data);
+      } catch (err2) {
+        this.opts.logger?.warn("runtime-host: destroying connection on malformed frame", {
+          error: err2 instanceof Error ? err2.message : String(err2)
+        });
+        this.destroyConnection(conn);
+        return;
+      }
+      for (const frame of frames) {
+        void this.onMessage(conn, frame);
+      }
+    });
+    frameConn.onClose(() => this.destroyConnection(conn));
+  }
+  async onMessage(conn, message2) {
+    if (!conn.authenticated) {
+      if (message2.t !== "hello") {
+        this.destroyConnection(conn);
+        return;
+      }
+      await this.onHello(conn, message2);
+      return;
+    }
+    switch (message2.t) {
+      case "hello":
+        this.destroyConnection(conn);
+        return;
+      case "subscribe":
+        if (typeof message2.channel === "string")
+          conn.channels.add(message2.channel);
+        return;
+      case "unsubscribe":
+        if (typeof message2.channel === "string")
+          conn.channels.delete(message2.channel);
+        return;
+      case "register_capabilities": {
+        if (!Array.isArray(message2.capabilities) || message2.capabilities.some((c3) => typeof c3 !== "string")) {
+          this.destroyConnection(conn);
+          return;
+        }
+        for (const capability of conn.capabilities) {
+          if (this.bridged.get(capability) === conn)
+            this.bridged.delete(capability);
+        }
+        conn.capabilities = new Set(message2.capabilities);
+        for (const capability of conn.capabilities) {
+          this.bridged.set(capability, conn);
+        }
+        this.notifyCapabilitiesChanged();
+        return;
+      }
+      case "bridge_chunk":
+      case "bridge_end":
+      case "bridge_error": {
+        const state = this.bridgeInflight.get(message2.id);
+        if (state === void 0 || state.conn !== conn)
+          return;
+        if (message2.t === "bridge_chunk")
+          state.queue.push(message2.chunk);
+        else if (message2.t === "bridge_end")
+          state.done = true;
+        else
+          state.error = new Error(message2.message);
+        state.wake?.();
+        return;
+      }
+      case "invoke":
+        if (typeof message2.id !== "string" || typeof message2.capability !== "string" || typeof message2.prompt !== "string") {
+          this.destroyConnection(conn);
+          return;
+        }
+        await this.runStream(conn, message2.id, (ctx) => this.opts.onInvoke(message2.capability, message2.prompt, message2.options, ctx));
+        return;
+      case "chat": {
+        if (typeof message2.id !== "string" || typeof message2.text !== "string") {
+          this.destroyConnection(conn);
+          return;
+        }
+        const onChat = this.opts.onChat;
+        if (onChat === void 0) {
+          this.send(conn, {
+            t: "invoke_error",
+            id: message2.id,
+            message: "this coordinator does not proxy chat"
+          });
+          return;
+        }
+        await this.runStream(conn, message2.id, (ctx) => onChat(message2.text, message2.options, ctx));
+        return;
+      }
+      case "resolve_approval": {
+        if (typeof message2.id !== "string" || typeof message2.approved !== "boolean" || typeof message2.approver_id !== "string") {
+          this.destroyConnection(conn);
+          return;
+        }
+        const onResolveApproval = this.opts.onResolveApproval;
+        if (onResolveApproval === void 0) {
+          this.send(conn, {
+            t: "invoke_error",
+            id: message2.id,
+            message: "this coordinator does not proxy approval resolution"
+          });
+          return;
+        }
+        await this.runStream(conn, message2.id, (ctx) => onResolveApproval(message2.approved, message2.approver_id, ctx));
+        return;
+      }
+      default:
+        this.destroyConnection(conn);
+    }
+  }
+  refuse(conn, reason, detail) {
+    this.send(conn, { t: "refuse", reason, detail });
+    conn.conn.end();
+  }
+  async onHello(conn, hello) {
+    if (typeof hello.protocol_version !== "number" || typeof hello.token !== "string") {
+      this.refuse(conn, "malformed_hello", "hello requires protocol_version and token");
+      return;
+    }
+    if (hello.protocol_version !== RUNTIME_HOST_PROTOCOL_VERSION) {
+      this.refuse(conn, "version_skew", `coordinator speaks runtime-host protocol v${RUNTIME_HOST_PROTOCOL_VERSION}, attacher sent v${hello.protocol_version}`);
+      return;
+    }
+    const claims = parseTokenClaims(hello.token);
+    if (claims === null) {
+      this.refuse(conn, "auth_failed", "attach token is malformed");
+      return;
+    }
+    if (claims.aud !== RUNTIME_ATTACH_AUDIENCE) {
+      this.refuse(conn, "auth_failed", `attach token audience is "${claims.aud}", expected "${RUNTIME_ATTACH_AUDIENCE}"`);
+      return;
+    }
+    if (claims.mid !== this.opts.motebitId) {
+      this.refuse(conn, "auth_failed", "attach token is for a different motebit identity");
+      return;
+    }
+    let publicKey;
+    try {
+      publicKey = await this.opts.resolveDevicePublicKey(claims.did);
+    } catch (err2) {
+      this.opts.logger?.warn("runtime-host: device key resolution failed", {
+        error: err2 instanceof Error ? err2.message : String(err2)
+      });
+      publicKey = null;
+    }
+    if (publicKey === null) {
+      this.refuse(conn, "auth_failed", `unknown device "${claims.did}"`);
+      return;
+    }
+    const payload = await verifySignedToken(hello.token, publicKey);
+    if (payload === null) {
+      this.refuse(conn, "auth_failed", "attach token signature invalid or token expired");
+      return;
+    }
+    conn.authenticated = true;
+    if (conn.handshakeTimer !== null) {
+      clearTimeout(conn.handshakeTimer);
+      conn.handshakeTimer = null;
+    }
+    this.send(conn, {
+      t: "hello_ack",
+      protocol_version: RUNTIME_HOST_PROTOCOL_VERSION,
+      coordinator_pid: this.pid
+    });
+  }
+  /** Drive one handler stream onto the wire: chunk* then end, or invoke_error. */
+  async runStream(conn, id, start) {
+    const controller = new AbortController();
+    conn.inflight.set(id, controller);
+    try {
+      for await (const chunk of start({ signal: controller.signal })) {
+        if (controller.signal.aborted || conn.conn.destroyed)
+          return;
+        this.send(conn, { t: "chunk", id, chunk });
+      }
+      if (!conn.conn.destroyed)
+        this.send(conn, { t: "end", id });
+    } catch (err2) {
+      if (!conn.conn.destroyed) {
+        this.send(conn, {
+          t: "invoke_error",
+          id,
+          message: err2 instanceof Error ? err2.message : String(err2)
+        });
+      }
+    } finally {
+      conn.inflight.delete(id);
+    }
+  }
+  send(conn, message2) {
+    if (conn.conn.destroyed)
+      return;
+    conn.conn.send(encodeFrame(message2));
+  }
+  destroyConnection(conn) {
+    if (!this.connections.has(conn))
+      return;
+    this.connections.delete(conn);
+    if (conn.handshakeTimer !== null)
+      clearTimeout(conn.handshakeTimer);
+    for (const controller of conn.inflight.values())
+      controller.abort();
+    conn.inflight.clear();
+    for (const id of conn.bridgeIds) {
+      const state = this.bridgeInflight.get(id);
+      if (state !== void 0 && state.error === null && !state.done) {
+        state.error = new Error("bridged frontend disconnected mid-invocation");
+        state.wake?.();
+      }
+    }
+    conn.bridgeIds.clear();
+    let removedOrgans = 0;
+    for (const capability of conn.capabilities) {
+      if (this.bridged.get(capability) === conn) {
+        this.bridged.delete(capability);
+        removedOrgans += 1;
+      }
+    }
+    conn.conn.destroy();
+    if (removedOrgans > 0)
+      this.notifyCapabilitiesChanged();
+  }
+};
+
+// ../../packages/runtime-host/dist/client.js
+init_esm_shims();
+init_dist5();
+init_dist();
+var AttachRefusedError = class extends Error {
+  reason;
+  detail;
+  constructor(reason, detail) {
+    super(`attach refused (${reason}): ${detail}`);
+    this.reason = reason;
+    this.detail = detail;
+    this.name = "AttachRefusedError";
+  }
+};
+var CoordinatorUnreachableError = class extends Error {
+  constructor(socketPath, cause) {
+    super(`no coordinator reachable at ${socketPath}`, { cause });
+    this.name = "CoordinatorUnreachableError";
+  }
+};
+async function mintAttachToken(identity, privateKey, opts = {}) {
+  const now = opts.now ?? (() => Date.now());
+  const issuedAt = now();
+  return createSignedToken({
+    mid: identity.motebitId,
+    did: identity.deviceId,
+    iat: issuedAt,
+    exp: issuedAt + (opts.ttlMs ?? 3e4),
+    // Web Crypto — available in node ≥ 20 AND the desktop webview;
+    // this module must never import node:crypto.
+    jti: globalThis.crypto.randomUUID(),
+    aud: RUNTIME_ATTACH_AUDIENCE
+  }, privateKey);
+}
+var RuntimeHostClient = class _RuntimeHostClient {
+  conn;
+  coordinatorPid;
+  inflight = /* @__PURE__ */ new Map();
+  eventHandlers = /* @__PURE__ */ new Map();
+  closeHandlers = /* @__PURE__ */ new Set();
+  capabilityHandlers = /* @__PURE__ */ new Map();
+  bridgeAborts = /* @__PURE__ */ new Map();
+  requestCounter = 0;
+  closed = false;
+  constructor(conn, coordinatorPid) {
+    this.conn = conn;
+    this.coordinatorPid = coordinatorPid;
+  }
+  /**
+   * Connect + handshake. Resolves to an attached client, or throws
+   * `CoordinatorUnreachableError` (nothing listening — caller should
+   * run the election) / `AttachRefusedError` (a live coordinator said
+   * no — caller must NOT try to bind over it).
+   */
+  static async attach(opts) {
+    const conn = await opts.platform.connect(opts.socketPath, opts.connectTimeoutMs ?? 2e3);
+    if (conn === null) {
+      throw new CoordinatorUnreachableError(opts.socketPath, new Error("connect failed"));
+    }
+    conn.send(encodeFrame({
+      t: "hello",
+      protocol_version: opts.protocolVersion ?? RUNTIME_HOST_PROTOCOL_VERSION,
+      token: opts.token
+    }));
+    const decoder2 = new JsonLineDecoder();
+    const { first, rest } = await new Promise((resolve14, reject) => {
+      let settled = false;
+      const timer = setTimeout(() => {
+        settle();
+        conn.destroy();
+        reject(new CoordinatorUnreachableError(opts.socketPath, new Error("handshake timeout")));
+      }, opts.handshakeTimeoutMs ?? 3e3);
+      const settle = () => {
+        settled = true;
+        clearTimeout(timer);
+      };
+      conn.onData((data) => {
+        if (settled)
+          return;
+        let frames;
+        try {
+          frames = decoder2.push(data);
+        } catch (err2) {
+          settle();
+          conn.destroy();
+          reject(new Error(`malformed coordinator frame: ${err2 instanceof Error ? err2.message : String(err2)}`, { cause: err2 }));
+          return;
+        }
+        if (frames.length > 0) {
+          settle();
+          resolve14({
+            first: frames[0],
+            rest: frames.slice(1)
+          });
+        }
+      });
+      conn.onClose(() => {
+        if (settled)
+          return;
+        settle();
+        conn.destroy();
+        reject(new CoordinatorUnreachableError(opts.socketPath, new Error("closed during handshake")));
+      });
+    });
+    if (first.t === "refuse") {
+      conn.destroy();
+      throw new AttachRefusedError(first.reason, first.detail);
+    }
+    if (first.t !== "hello_ack") {
+      conn.destroy();
+      throw new Error(`unexpected first coordinator frame: ${first.t}`);
+    }
+    const client = new _RuntimeHostClient(conn, first.coordinator_pid);
+    client.wire(decoder2);
+    for (const frame of rest)
+      client.onMessage(frame);
+    if (opts.capabilities !== void 0)
+      client.setBridgedCapabilities(opts.capabilities);
+    return client;
+  }
+  /**
+   * Proxy a typed capability invocation to the coordinator. Yields the
+   * coordinator's streamed chunks; throws on `invoke_error` or if the
+   * coordinator goes away mid-stream (fail-loud, per doctrine).
+   */
+  async *invoke(capability, prompt2, options) {
+    yield* this.stream((id) => ({ t: "invoke", id, capability, prompt: prompt2, options }));
+  }
+  /**
+   * Proxy one conversational turn (`sendMessageStreaming`) to the
+   * coordinator. A turn that pauses on `approval_request` ends its
+   * stream; continue it with `resolveApproval`.
+   */
+  async *chat(text, options) {
+    yield* this.stream((id) => ({ t: "chat", id, text, options }));
+  }
+  /**
+   * Resolve a pending approval on the coordinator
+   * (`resolveApprovalVote`); yields the continuation turn's chunks.
+   */
+  async *resolveApproval(approved, approverId) {
+    yield* this.stream((id) => ({
+      t: "resolve_approval",
+      id,
+      approved,
+      approver_id: approverId
+    }));
+  }
+  /**
+   * Contribute this frontend's organs. Replaces the previous set, both
+   * locally and on the coordinator (idempotent).
+   */
+  setBridgedCapabilities(handlers) {
+    if (this.closed)
+      throw new Error("runtime-host client is closed");
+    this.capabilityHandlers = new Map(Object.entries(handlers));
+    this.conn.send(encodeFrame({
+      t: "register_capabilities",
+      capabilities: [...this.capabilityHandlers.keys()]
+    }));
+  }
+  /** Subscribe to a coordinator event channel. Returns the unsubscriber. */
+  subscribe(channel, handler) {
+    let handlers = this.eventHandlers.get(channel);
+    if (handlers === void 0) {
+      handlers = /* @__PURE__ */ new Set();
+      this.eventHandlers.set(channel, handlers);
+      this.conn.send(encodeFrame({ t: "subscribe", channel }));
+    }
+    handlers.add(handler);
+    return () => {
+      const current = this.eventHandlers.get(channel);
+      if (current === void 0)
+        return;
+      current.delete(handler);
+      if (current.size === 0) {
+        this.eventHandlers.delete(channel);
+        if (!this.closed)
+          this.conn.send(encodeFrame({ t: "unsubscribe", channel }));
+      }
+    };
+  }
+  /** Fires once when the coordinator connection ends — the re-elect signal. */
+  onClose(handler) {
+    this.closeHandlers.add(handler);
+    return () => this.closeHandlers.delete(handler);
+  }
+  close() {
+    this.teardown(null);
+  }
+  async *stream(buildFrame) {
+    if (this.closed)
+      throw new Error("runtime-host client is closed");
+    this.requestCounter += 1;
+    const id = `req-${this.requestCounter}-${globalThis.crypto.randomUUID().slice(0, 8)}`;
+    const state = { queue: [], done: false, error: null, wake: null };
+    this.inflight.set(id, state);
+    this.conn.send(encodeFrame(buildFrame(id)));
+    try {
+      for (; ; ) {
+        while (state.queue.length > 0)
+          yield state.queue.shift();
+        if (state.error !== null)
+          throw state.error;
+        if (state.done)
+          return;
+        await new Promise((resolve14) => {
+          state.wake = resolve14;
+        });
+        state.wake = null;
+      }
+    } finally {
+      this.inflight.delete(id);
+    }
+  }
+  wire(decoder2) {
+    this.conn.onData((data) => {
+      let frames;
+      try {
+        frames = decoder2.push(data);
+      } catch (err2) {
+        this.teardown(new Error(`malformed coordinator frame: ${err2 instanceof Error ? err2.message : String(err2)}`, { cause: err2 }));
+        return;
+      }
+      for (const frame of frames)
+        this.onMessage(frame);
+    });
+    this.conn.onClose(() => this.teardown(new Error("coordinator connection closed")));
+  }
+  onMessage(message2) {
+    switch (message2.t) {
+      case "chunk": {
+        const state = this.inflight.get(message2.id);
+        if (state !== void 0) {
+          state.queue.push(message2.chunk);
+          state.wake?.();
+        }
+        return;
+      }
+      case "end": {
+        const state = this.inflight.get(message2.id);
+        if (state !== void 0) {
+          state.done = true;
+          state.wake?.();
+        }
+        return;
+      }
+      case "invoke_error": {
+        const state = this.inflight.get(message2.id);
+        if (state !== void 0) {
+          state.error = new Error(message2.message);
+          state.wake?.();
+        }
+        return;
+      }
+      case "event": {
+        const handlers = this.eventHandlers.get(message2.channel);
+        if (handlers !== void 0) {
+          for (const handler of handlers)
+            handler(message2.payload);
+        }
+        return;
+      }
+      case "bridge_invoke": {
+        if (typeof message2.id === "string" && typeof message2.capability === "string" && typeof message2.prompt === "string") {
+          void this.runBridgedInvocation(message2.id, message2.capability, message2.prompt, message2.options);
+        }
+        return;
+      }
+      default:
+        return;
+    }
+  }
+  /** Answer a coordinator-initiated bridged invocation. */
+  async runBridgedInvocation(id, capability, prompt2, options) {
+    const handler = this.capabilityHandlers.get(capability);
+    if (handler === void 0) {
+      this.conn.send(encodeFrame({
+        t: "bridge_error",
+        id,
+        message: `capability "${capability}" is not contributed by this frontend`
+      }));
+      return;
+    }
+    const controller = new AbortController();
+    this.bridgeAborts.set(id, controller);
+    try {
+      for await (const chunk of handler(prompt2, options, { signal: controller.signal })) {
+        if (controller.signal.aborted || this.closed)
+          return;
+        this.conn.send(encodeFrame({ t: "bridge_chunk", id, chunk }));
+      }
+      if (!this.closed)
+        this.conn.send(encodeFrame({ t: "bridge_end", id }));
+    } catch (err2) {
+      if (!this.closed) {
+        this.conn.send(encodeFrame({
+          t: "bridge_error",
+          id,
+          message: err2 instanceof Error ? err2.message : String(err2)
+        }));
+      }
+    } finally {
+      this.bridgeAborts.delete(id);
+    }
+  }
+  teardown(cause) {
+    if (this.closed)
+      return;
+    this.closed = true;
+    for (const state of this.inflight.values()) {
+      if (!state.done && state.error === null) {
+        state.error = cause ?? new Error("runtime-host client closed");
+      }
+      state.wake?.();
+    }
+    for (const controller of this.bridgeAborts.values())
+      controller.abort();
+    this.bridgeAborts.clear();
+    this.conn.destroy();
+    for (const handler of this.closeHandlers)
+      handler();
+    this.closeHandlers.clear();
+  }
+};
+
+// ../../packages/runtime-host/dist/safe-options.js
+init_esm_shims();
+function pickSafeChatOptions(options) {
+  if (options === void 0)
+    return void 0;
+  const picked = {};
+  if (typeof options["delegationScope"] === "string") {
+    picked.delegationScope = options["delegationScope"];
+  }
+  if (typeof options["suppressHistory"] === "boolean") {
+    picked.suppressHistory = options["suppressHistory"];
+  }
+  return picked;
+}
+function pickSafeInvokeOptions(options) {
+  const picked = {};
+  if (options === void 0)
+    return picked;
+  if (typeof options["targetWorkerId"] === "string") {
+    picked.targetWorkerId = options["targetWorkerId"];
+  }
+  if (typeof options["acknowledgeNoHistoryRisk"] === "boolean") {
+    picked.acknowledgeNoHistoryRisk = options["acknowledgeNoHistoryRisk"];
+  }
+  return picked;
+}
+
+// ../../packages/runtime-host/dist/bridged-tools.js
+init_esm_shims();
+var AI_LOOP_EXCLUDED_ORGANS = /* @__PURE__ */ new Map([
+  [
+    "se_attestation",
+    "hardware-attestation minting is a user-initiated identity affordance (docs/doctrine/hardware-attestation.md), never a model-chosen act"
+  ]
+]);
+function isToolResultShaped(value) {
+  return typeof value === "object" && value !== null && typeof value.ok === "boolean";
+}
+function bridgedToolRegistry(server, definitions) {
+  for (const capability of Object.keys(definitions)) {
+    const exclusion = AI_LOOP_EXCLUDED_ORGANS.get(capability);
+    if (exclusion !== void 0) {
+      throw new Error(`bridged organ "${capability}" must not surface to the AI loop as a tool: ${exclusion}`);
+    }
+  }
+  const exposed = () => server.bridgedCapabilities.filter((capability) => definitions[capability] !== void 0).map((capability) => ({ capability, definition: definitions[capability] }));
+  return {
+    list() {
+      return exposed().map((e2) => e2.definition);
+    },
+    async execute(name, args) {
+      const entry = exposed().find((e2) => e2.definition.name === name);
+      if (entry === void 0) {
+        return { ok: false, error: `no attached frontend currently contributes tool "${name}"` };
+      }
+      const chunks = [];
+      try {
+        for await (const chunk of server.invokeBridged(entry.capability, "", args)) {
+          chunks.push(chunk);
+        }
+      } catch (err2) {
+        return { ok: false, error: err2 instanceof Error ? err2.message : String(err2) };
+      }
+      const data = chunks.length === 1 ? chunks[0] : chunks;
+      if (isToolResultShaped(data))
+        return data;
+      return { ok: true, data };
+    },
+    register() {
+      throw new Error("bridged tool registry is a read-only view over attached frontends' organs");
+    }
+  };
+}
+var BRIDGED_ORGAN_TOOL_SOURCE = "runtime-host:bridged-organs";
+function wireBridgedOrganTools(server, host, definitions) {
+  const registry = bridgedToolRegistry(server, definitions);
+  const sync = () => {
+    host.unregisterExternalTools(BRIDGED_ORGAN_TOOL_SOURCE);
+    host.registerExternalTools(BRIDGED_ORGAN_TOOL_SOURCE, registry);
+  };
+  const unsubscribe = server.onBridgedCapabilitiesChanged(sync);
+  sync();
+  return unsubscribe;
+}
+
+// ../../packages/runtime-host/dist/election.js
+init_esm_shims();
+var sleep = (ms) => new Promise((resolve14) => setTimeout(resolve14, ms));
+async function probeSocketLive(platform, socketPath, timeoutMs) {
+  const conn = await platform.connect(socketPath, timeoutMs);
+  if (conn === null)
+    return false;
+  conn.destroy();
+  return true;
+}
+async function acquireTakeoverMutex(platform, mutexDir, pid, probePid) {
+  for (let i3 = 0; i3 < 2; i3 += 1) {
+    if (await platform.mkdirExclusive(mutexDir) === "created") {
+      await platform.writeFile(`${mutexDir}/pid`, String(pid));
+      return true;
+    }
+    const holderRaw = await platform.readFile(`${mutexDir}/pid`);
+    if (holderRaw === null) {
+      return false;
+    }
+    const holderPid = Number(holderRaw.trim());
+    if (Number.isInteger(holderPid) && holderPid > 0 && await probePid(holderPid))
+      return false;
+    await platform.removeDir(mutexDir);
+  }
+  return false;
+}
+async function releaseTakeoverMutex(platform, mutexDir) {
+  await platform.removeDir(mutexDir);
+}
+async function electRuntimeHost(opts) {
+  const platform = opts.platform;
+  const maxAttempts = opts.maxAttempts ?? 4;
+  const retryDelayMs = opts.retryDelayMs ?? 150;
+  const probePid = opts.probePid ?? ((pid) => platform.isPidAlive(pid));
+  let lastError = null;
+  for (let attempt = 1; attempt <= maxAttempts; attempt += 1) {
+    if (await probeSocketLive(platform, opts.socketPath, retryDelayMs * 2)) {
+      let token;
+      try {
+        token = await opts.mintToken();
+      } catch (err2) {
+        throw new Error(`a coordinator is live at ${opts.socketPath} but minting the attach token failed: ${err2 instanceof Error ? err2.message : String(err2)}`, { cause: err2 });
+      }
+      try {
+        const client = await RuntimeHostClient.attach({
+          platform,
+          socketPath: opts.socketPath,
+          token,
+          handshakeTimeoutMs: opts.handshakeTimeoutMs
+        });
+        return { role: "frontend", client };
+      } catch (err2) {
+        if (err2 instanceof AttachRefusedError)
+          throw err2;
+        if (!(err2 instanceof CoordinatorUnreachableError)) {
+          throw new Error(`runtime-host attach failed: ${err2 instanceof Error ? err2.message : String(err2)}`, { cause: err2 });
+        }
+        lastError = err2;
+      }
+    }
+    const lock = await readLockfile(platform, opts.lockfilePath);
+    if (lock !== null && await probePid(lock.pid) && attempt < maxAttempts) {
+      await sleep(retryDelayMs);
+      continue;
+    }
+    const mutexDir = `${opts.lockfilePath}.takeover`;
+    const pid = opts.pid ?? platform.pid;
+    if (!await acquireTakeoverMutex(platform, mutexDir, pid, probePid)) {
+      await sleep(retryDelayMs);
+      continue;
+    }
+    try {
+      if (await probeSocketLive(platform, opts.socketPath, retryDelayMs * 2)) {
+        continue;
+      }
+      if (!isWindowsPipePath(opts.socketPath)) {
+        await platform.removeSocketFile(opts.socketPath);
+      }
+      const server = await RuntimeHostServer.bind(opts);
+      return { role: "coordinator", server };
+    } catch (err2) {
+      if (err2 instanceof CoordinatorAlreadyBoundError) {
+        lastError = err2;
+        await sleep(retryDelayMs);
+        continue;
+      }
+      throw err2;
+    } finally {
+      await releaseTakeoverMutex(platform, mutexDir);
+    }
+  }
+  throw new Error(`runtime-host election did not converge after ${maxAttempts} attempts: ${lastError instanceof Error ? lastError.message : String(lastError)}`, { cause: lastError });
+}
+
+// ../../packages/runtime-host/dist/node.js
+init_esm_shims();
+
+// ../../packages/runtime-host/dist/node-platform.js
+init_esm_shims();
+import { chmodSync, mkdirSync as mkdirSync4, readFileSync as readFileSync4, rmSync as rmSync2, writeFileSync as writeFileSync4 } from "fs";
+import { connect, createServer } from "net";
+import { dirname as dirname4 } from "path";
+function isWindowsPipe(path19) {
+  return path19.startsWith("\\\\.\\pipe\\");
+}
+function wrapSocket(socket) {
+  return {
+    send: (data) => {
+      if (!socket.destroyed)
+        socket.write(data);
+    },
+    onData: (cb) => {
+      socket.on("data", cb);
+    },
+    onClose: (cb) => {
+      socket.on("close", cb);
+      socket.on("error", () => socket.destroy());
+    },
+    end: () => socket.end(),
+    destroy: () => socket.destroy(),
+    get destroyed() {
+      return socket.destroyed;
+    }
+  };
+}
+var NodeFrameListener = class {
+  server;
+  constructor(server) {
+    this.server = server;
+  }
+  onConnection(cb) {
+    this.server.on("connection", (socket) => cb(wrapSocket(socket)));
+  }
+  close() {
+    return new Promise((resolve14) => {
+      this.server.close(() => resolve14());
+    });
+  }
+};
+function nodePlatform(overrides = {}) {
+  return {
+    pid: overrides.pid ?? process.pid,
+    connect(socketPath, timeoutMs) {
+      return new Promise((resolve14) => {
+        const socket = connect(socketPath);
+        const timer = setTimeout(() => {
+          socket.destroy();
+          resolve14(null);
+        }, timeoutMs);
+        socket.once("connect", () => {
+          clearTimeout(timer);
+          resolve14(wrapSocket(socket));
+        });
+        socket.once("error", () => {
+          clearTimeout(timer);
+          resolve14(null);
+        });
+      });
+    },
+    bind(socketPath) {
+      return new Promise((resolve14, reject) => {
+        const server = createServer();
+        const onError = (err2) => {
+          server.removeListener("listening", onListening);
+          if (err2.code === "EADDRINUSE")
+            resolve14("in_use");
+          else
+            reject(new Error(`runtime-host bind failed: ${err2.message}`, { cause: err2 }));
+        };
+        const onListening = () => {
+          server.removeListener("error", onError);
+          if (!isWindowsPipe(socketPath)) {
+            try {
+              chmodSync(socketPath, 384);
+            } catch (err2) {
+              server.close();
+              reject(new Error(`runtime-host bind failed: could not restrict socket permissions: ${err2 instanceof Error ? err2.message : String(err2)}`, { cause: err2 }));
+              return;
+            }
+          }
+          resolve14(new NodeFrameListener(server));
+        };
+        server.once("error", onError);
+        server.once("listening", onListening);
+        server.listen(socketPath);
+      });
+    },
+    // eslint-disable-next-line @typescript-eslint/require-await
+    async removeSocketFile(socketPath) {
+      if (isWindowsPipe(socketPath))
+        return;
+      try {
+        rmSync2(socketPath, { force: true });
+      } catch {
+      }
+    },
+    // eslint-disable-next-line @typescript-eslint/require-await
+    async readFile(path19) {
+      try {
+        return readFileSync4(path19, "utf8");
+      } catch {
+        return null;
+      }
+    },
+    // eslint-disable-next-line @typescript-eslint/require-await
+    async writeFile(path19, content) {
+      mkdirSync4(dirname4(path19), { recursive: true, mode: 448 });
+      writeFileSync4(path19, content, { mode: 384 });
+    },
+    // eslint-disable-next-line @typescript-eslint/require-await
+    async removeFile(path19) {
+      rmSync2(path19, { force: true });
+    },
+    // eslint-disable-next-line @typescript-eslint/require-await
+    async mkdirExclusive(path19) {
+      mkdirSync4(dirname4(path19), { recursive: true, mode: 448 });
+      try {
+        mkdirSync4(path19);
+        return "created";
+      } catch {
+        return "exists";
+      }
+    },
+    // eslint-disable-next-line @typescript-eslint/require-await
+    async removeDir(path19) {
+      try {
+        rmSync2(path19, { recursive: true, force: true });
+      } catch {
+      }
+    },
+    // eslint-disable-next-line @typescript-eslint/require-await
+    async isPidAlive(pid) {
+      if (!Number.isInteger(pid) || pid <= 0)
+        return false;
+      try {
+        process.kill(pid, 0);
+        return true;
+      } catch (err2) {
+        return err2.code === "EPERM";
+      }
+    }
+  };
+}
+
+// ../../packages/runtime-host/dist/paths.js
+init_esm_shims();
+import { createHash } from "crypto";
+import { homedir as homedir3 } from "os";
+import { join as join7 } from "path";
+function defaultRuntimeHostPaths(home = homedir3(), platform = process.platform) {
+  const dir = join7(home, ".motebit");
+  if (platform === "win32") {
+    const tag2 = createHash("sha256").update(dir).digest("hex").slice(0, 16);
+    return {
+      socketPath: `\\\\.\\pipe\\motebit-runtime-${tag2}`,
+      lockfilePath: join7(dir, "runtime.lock")
+    };
+  }
+  return {
+    socketPath: join7(dir, "runtime.sock"),
+    lockfilePath: join7(dir, "runtime.lock")
+  };
+}
+
+// ../../packages/tools/dist/web-safe.js
+init_esm_shims();
+init_web_search();
+init_read_url();
+init_recall_memories();
+init_current_time();
+init_list_events();
+init_rewrite_memory();
+init_search_conversations();
+init_self_reflect();
+init_web_search();
+init_read_url();
+init_recall_memories();
+init_current_time();
+init_recall_self();
+init_list_events();
+init_self_reflect();
+init_search_provider();
+init_brave_search();
+init_duckduckgo();
+init_proxy_search();
+init_tavily_search();
+init_biased_search();
+init_goal_tools();
+init_computer();
+init_request_control();
+init_read_page();
+init_registry4();
+
+// src/runtime-host.ts
+init_identity();
+function requireRuntime(ref) {
+  if (ref.current === null) {
+    throw new Error("coordinator runtime is still starting \u2014 retry shortly");
+  }
+  return ref.current;
+}
+async function electCliRuntimeHost(deps) {
+  const paths = deps.paths ?? defaultRuntimeHostPaths();
+  const deviceId = deps.fullConfig.device_id;
+  const devicePublicKey = deps.fullConfig.device_public_key;
+  return electRuntimeHost({
+    platform: nodePlatform(),
+    socketPath: paths.socketPath,
+    lockfilePath: paths.lockfilePath,
+    motebitId: deps.motebitId,
+    resolveDevicePublicKey: (did) => deviceId != null && did === deviceId && devicePublicKey != null && devicePublicKey !== "" ? fromHex3(devicePublicKey) : null,
+    onInvoke: (capability, prompt2, options, ctx) => requireRuntime(deps.runtimeRef).invokeCapability(capability, prompt2, {
+      ...pickSafeInvokeOptions(options),
+      signal: ctx.signal
+    }),
+    // sendMessageStreaming has no abort seam; a frontend disconnect
+    // lets the turn run to completion on the coordinator (its memory
+    // and receipts stay consistent), which is the correct authority
+    // semantics — the renderer left, the act didn't.
+    onChat: (text, options) => requireRuntime(deps.runtimeRef).sendMessageStreaming(
+      text,
+      void 0,
+      pickSafeChatOptions(options)
+    ),
+    onResolveApproval: (approved, approverId) => requireRuntime(deps.runtimeRef).resolveApprovalVote(approved, approverId),
+    mintToken: async () => {
+      if (deviceId == null || deviceId === "") {
+        throw new Error(
+          "no device_id in ~/.motebit/config.json \u2014 run `motebit` once to mint an identity"
+        );
+      }
+      return mintAttachToken({ motebitId: deps.motebitId, deviceId }, await deps.loadPrivateKey());
+    }
+  });
+}
+function wireBridgedOrgans(server, runtime) {
+  wireBridgedOrganTools(server, runtime, {
+    computer_use: { ...computerDefinition, embodimentMode: "desktop_drive" }
+  });
+}
+async function electCoordinatorRole(fullConfig, motebitId, runtimeRef) {
+  let election;
+  try {
+    election = await electCliRuntimeHost({
+      fullConfig,
+      motebitId,
+      loadPrivateKey: async () => (await loadActiveSigningKey(fullConfig, {
+        promptLabel: "Passphrase (to verify the running coordinator): "
+      })).privateKey,
+      runtimeRef
+    });
+  } catch (err2) {
+    console.error(
+      `Runtime-host election failed: ${err2 instanceof Error ? err2.message : String(err2)}`
+    );
+    console.error(
+      "A coordinator may already be running with an incompatible build or a locked signing key. Stop it and retry."
+    );
+    process.exit(1);
+  }
+  if (election.role === "frontend") {
+    const pid = election.client.coordinatorPid;
+    election.client.close();
+    console.error(`Another motebit process is already coordinating this machine (pid ${pid}).`);
+    console.error(
+      "One runtime per machine: stop that process first, or run `motebit` (no arguments) to attach a rendering REPL to it."
+    );
+    process.exit(1);
+  }
+  return election.server;
+}
+
+// src/attached-repl.ts
+init_esm_shims();
+init_colors();
+async function renderStream(stream) {
+  let pendingApproval = null;
+  try {
+    for await (const raw of stream) {
+      const chunk = raw;
+      switch (chunk.type) {
+        case "text":
+          if (typeof chunk.text === "string") writeOutput(chunk.text);
+          break;
+        case "tool_status":
+          if (chunk.status === "calling") {
+            writeOutput(`
+${meta(`[${chunk.name ?? "tool"}]`)} `);
+          }
+          break;
+        case "approval_request":
+          pendingApproval = {
+            name: chunk.name ?? "tool",
+            args: chunk.args ?? {}
+          };
+          break;
+        case "delegation_start":
+          writeOutput(`
+${dim(`[delegating \xB7 ${chunk.tool ?? ""}]`)} `);
+          break;
+        case "delegation_complete":
+          if (chunk.receipt?.task_id != null) {
+            writeOutput(
+              `
+${dim(`[receipt ${chunk.receipt.task_id.slice(0, 8)} \xB7 ${chunk.receipt.status ?? ""}]`)}
+`
+            );
+          }
+          break;
+        case "injection_warning":
+          writeOutput(`
+${warn("\u26A0")} suspicious content in ${chunk.tool_name ?? "tool"} output
+`);
+          break;
+        case "invoke_error":
+          writeOutput(
+            `
+${warn(`[invoke failed${chunk.code != null ? ` \xB7 ${chunk.code}` : ""}]`)} ${chunk.message ?? ""}
+`
+          );
+          break;
+        case "task_step_narration":
+          if (typeof chunk.text === "string") writeOutput(dim(chunk.text));
+          break;
+        default:
+          break;
+      }
+    }
+  } catch (err2) {
+    writeOutput(
+      `
+${warn("[coordinator error]")} ${err2 instanceof Error ? err2.message : String(err2)}
+`
+    );
+  }
+  return { pendingApproval };
+}
+async function renderTurn(client, motebitId, stream) {
+  let current = stream;
+  for (; ; ) {
+    const { pendingApproval } = await renderStream(current);
+    if (pendingApproval === null) return;
+    const argsPreview = JSON.stringify(pendingApproval.args).slice(0, 120);
+    const answer = await askQuestion(
+      `
+  ${warn("?")} ${pendingApproval.name}(${argsPreview})
+  Allow? (y/n) `
+    );
+    const approved = answer.trim().toLowerCase() === "y";
+    current = client.resolveApproval(approved, motebitId);
+  }
+}
+var ATTACHED_HELP = `
+  Attached mode \u2014 the coordinator process owns the runtime; this terminal renders.
+    <text>                chat with your motebit (proxied to the coordinator)
+    /invoke <cap> <text>  invoke a capability deterministically
+    /help                 this help
+    /exit                 leave (the coordinator keeps running)
+  Other slash commands need the runtime in-process: exit, stop the coordinator, and re-run \`motebit\`.
+`;
+async function runAttachedRepl(client, motebitId) {
+  writeOutput(
+    `
+  ${dim("Attached to the machine's coordinator runtime")} ${dim(`(pid ${client.coordinatorPid})`)}
+  ${dim("This terminal renders; the coordinator acts. /help for what's available.")}
+
+`
+  );
+  let closed = false;
+  client.onClose(() => {
+    closed = true;
+    writeOutput(
+      `
+${warn("Coordinator exited.")} Run \`motebit\` again to take over as coordinator.
+`
+    );
+    destroyTerminal();
+    process.exit(0);
+  });
+  for (; ; ) {
+    if (closed) return;
+    let line;
+    try {
+      line = await readInput(prompt("you>") + " ");
+    } catch {
+      break;
+    }
+    const trimmed = line.trim();
+    if (trimmed === "") continue;
+    if (trimmed === "/exit" || trimmed === "/quit" || trimmed === "exit" || trimmed === "quit") {
+      writeOutput("Goodbye! (coordinator keeps running)\n");
+      break;
+    }
+    if (trimmed === "/help") {
+      writeOutput(ATTACHED_HELP);
+      continue;
+    }
+    if (trimmed.startsWith("/invoke ")) {
+      const rest = trimmed.slice("/invoke ".length).trim();
+      const space = rest.indexOf(" ");
+      const capability = space === -1 ? rest : rest.slice(0, space);
+      const prompt2 = space === -1 ? "" : rest.slice(space + 1);
+      if (capability === "") {
+        writeOutput(`${warn("usage:")} /invoke <capability> <prompt>
+`);
+        continue;
+      }
+      writeOutput(prompt("mote>") + " ");
+      await renderTurn(client, motebitId, client.invoke(capability, prompt2));
+      writeOutput("\n");
+      continue;
+    }
+    if (trimmed.startsWith("/")) {
+      writeOutput(
+        `${dim(`${trimmed.split(" ")[0]} needs the runtime in-process \u2014 not available in attached mode.`)}
+${dim("Stop the coordinator and re-run `motebit` to use it.")}
+`
+      );
+      continue;
+    }
+    writeOutput(prompt("mote>") + " ");
+    await renderTurn(client, motebitId, client.chat(trimmed));
+    writeOutput("\n");
+  }
+  client.close();
+  destroyTerminal();
+}
+
 // src/index.ts
 init_colors();
 
@@ -84545,7 +86260,7 @@ init_dist6();
 
 // ../../packages/mcp-server/dist/bootstrap-service.js
 init_esm_shims();
-import { writeFileSync as writeFileSync5 } from "fs";
+import { writeFileSync as writeFileSync6 } from "fs";
 import { resolve as resolve6 } from "path";
 
 // ../../packages/core-identity/dist/node.js
@@ -84553,12 +86268,12 @@ init_esm_shims();
 
 // ../../packages/core-identity/dist/file-stores.js
 init_esm_shims();
-import { existsSync, readFileSync as readFileSync4, writeFileSync as writeFileSync4, renameSync as renameSync2, chmodSync } from "fs";
+import { existsSync, readFileSync as readFileSync5, writeFileSync as writeFileSync5, renameSync as renameSync2, chmodSync as chmodSync2 } from "fs";
 
 // ../../packages/core-identity/dist/bootstrap-service.js
 init_esm_shims();
-import { mkdirSync as mkdirSync4, existsSync as existsSync2 } from "fs";
-import { join as join7 } from "path";
+import { mkdirSync as mkdirSync5, existsSync as existsSync2 } from "fs";
+import { join as join8 } from "path";
 init_dist9();
 init_dist8();
 
@@ -85338,7 +87053,7 @@ var McpServerAdapter = class _McpServerAdapter {
 init_config2();
 init_dist31();
 init_node_fs();
-import { join as join8 } from "path";
+import { join as join9 } from "path";
 
 // src/utils.ts
 init_esm_shims();
@@ -87352,7 +89067,7 @@ Curiosity targets (${targets.length}):
     }
     case "skills": {
       const registry = new SkillRegistry(
-        new NodeFsSkillStorageAdapter({ root: join8(CONFIG_DIR, "skills") })
+        new NodeFsSkillStorageAdapter({ root: join9(CONFIG_DIR, "skills") })
       );
       const records = await registry.list();
       if (records.length === 0) {
@@ -87383,7 +89098,7 @@ Curiosity targets (${targets.length}):
         break;
       }
       const registry = new SkillRegistry(
-        new NodeFsSkillStorageAdapter({ root: join8(CONFIG_DIR, "skills") })
+        new NodeFsSkillStorageAdapter({ root: join9(CONFIG_DIR, "skills") })
       );
       const record = await registry.get(name);
       if (!record) {
@@ -87899,12 +89614,13 @@ init_config2();
 init_runtime_factory();
 async function handleDelegatePlan(config, motebitId, prompt2) {
   const relayUrl = getRelayUrl(config);
+  const runtimeRef = { current: null };
+  const hostServer = await electCoordinatorRole(loadFullConfig(), motebitId, runtimeRef);
   const authHeaders = await getRelayAuthHeaders(config, { aud: "task:submit", json: true });
   const { createProvider: createProvider2, buildToolRegistry: buildToolRegistry2, buildStorageAdapters: buildStorageAdapters2, deriveGovernanceForRuntime: deriveGovernanceForRuntime2 } = await Promise.resolve().then(() => (init_runtime_factory(), runtime_factory_exports));
   const { MotebitRuntime: MotebitRuntime2, NullRenderer: NullRenderer2, PLANNING_TASK_ROUTER: PLANNING_TASK_ROUTER2 } = await Promise.resolve().then(() => (init_dist22(), dist_exports6));
   const dbPath = getDbPath(config.dbPath);
   const moteDb = await openMotebitDatabase(dbPath);
-  const runtimeRef = { current: null };
   const provider = createProvider2(config);
   const registry = buildToolRegistry2(config, runtimeRef, motebitId);
   const storage = buildStorageAdapters2(moteDb);
@@ -88123,6 +89839,8 @@ Plan failed: ${chunk.reason}`);
   } finally {
     runtime.stop();
     moteDb.close();
+    await hostServer.close().catch(() => {
+    });
   }
 }
 async function handleDelegate(config) {
@@ -89459,7 +91177,7 @@ async function handleLogs(config) {
     if (config.tail !== true) return;
     let lastShown = initial.length > 0 ? initial[0].ran_at : 0;
     while (true) {
-      await sleep(POLL_INTERVAL_MS2);
+      await sleep2(POLL_INTERVAL_MS2);
       const fresh = moteDb.goalOutcomeStore.listForGoal(goal.goal_id, 50);
       const newer = [...fresh].filter((o5) => o5.ran_at > lastShown).reverse();
       for (const o5 of newer) {
@@ -89484,7 +91202,7 @@ function printOutcome(ranAt, status, summary, errMsg) {
   const body = summary ?? errMsg ?? "";
   console.log(`${prefix} ${dim(when.padStart(10))}  ${body}`);
 }
-function sleep(ms) {
+function sleep2(ms) {
   return new Promise((resolve14) => setTimeout(resolve14, ms));
 }
 
@@ -93621,6 +95339,7 @@ async function reconcileTreasury(config) {
 
 // ../../services/relay/dist/treasury-reconciliation.js
 init_logger();
+init_loop_supervisor();
 var logger19 = createLogger({ service: "treasury-reconciliation" });
 var DEFAULT_INTERVAL_MS = 15 * 6e4;
 var DEFAULT_CONFIRMATION_LAG_BUFFER_MS = 5 * 6e4;
@@ -93714,8 +95433,6 @@ function startTreasuryReconciliationLoop(config) {
     confirmationLagBufferMs
   });
   const tick = async () => {
-    if (config.isFrozen?.())
-      return;
     try {
       await reconcileTreasury({
         rpc: config.rpc,
@@ -93733,17 +95450,19 @@ function startTreasuryReconciliationLoop(config) {
         chain: config.chain,
         error: err2 instanceof Error ? err2.message : String(err2)
       });
+      throw err2;
     }
   };
-  return setInterval(() => {
-    void tick();
-  }, intervalMs);
+  return superviseInterval(config.supervisor, "treasury-reconciliation", intervalMs, tick, {
+    ...config.isFrozen ? { isFrozen: config.isFrozen } : {}
+  });
 }
 
 // ../../services/relay/dist/solana-treasury-reconciliation.js
 init_esm_shims();
 init_dist39();
 init_logger();
+init_loop_supervisor();
 import { randomUUID as randomUUID2 } from "crypto";
 var logger20 = createLogger({ service: "solana-treasury-reconciliation" });
 var DEFAULT_INTERVAL_MS2 = 15 * 6e4;
@@ -93803,8 +95522,6 @@ function startSolanaTreasuryReconciliationLoop(config) {
     confirmationLagBufferMs
   });
   const tick = async () => {
-    if (config.isFrozen?.())
-      return;
     try {
       await reconciler.reconcile({
         store,
@@ -93818,11 +95535,12 @@ function startSolanaTreasuryReconciliationLoop(config) {
         chain,
         error: err2 instanceof Error ? err2.message : String(err2)
       });
+      throw err2;
     }
   };
-  return setInterval(() => {
-    void tick();
-  }, intervalMs);
+  return superviseInterval(config.supervisor, "solana-treasury-reconciliation", intervalMs, tick, {
+    ...config.isFrozen ? { isFrozen: config.isFrozen } : {}
+  });
 }
 
 // ../../services/relay/dist/index.js
@@ -99716,6 +101434,7 @@ var TaskQueue = class {
 
 // ../../services/relay/dist/command-route.js
 init_esm_shims();
+init_dist5();
 import { HTTPException as HTTPException20 } from "hono/http-exception";
 var RELAY_SIDE_COMMANDS = /* @__PURE__ */ new Set(["balance", "deposits", "discover", "proposals"]);
 var RUNTIME_SIDE_COMMANDS = /* @__PURE__ */ new Set([
@@ -99750,6 +101469,22 @@ function registerCommandRoutes(deps) {
     }
     const command2 = body.command;
     const args = typeof body.args === "string" ? body.args : void 0;
+    const registered = db.prepare("SELECT public_key FROM agent_registry WHERE motebit_id = ?").get(motebitId);
+    if (!registered || registered.public_key === "") {
+      throw new HTTPException20(401, {
+        message: "Unknown agent identity \u2014 no registered public key to verify the command against"
+      });
+    }
+    const verdict = await verifyAgentCommandEnvelope({
+      envelope: body.envelope,
+      command: command2,
+      args,
+      motebitId,
+      identityPublicKey: registered.public_key
+    });
+    if (!verdict.ok) {
+      throw new HTTPException20(401, { message: verdict.reason });
+    }
     if (command2 in INFO_COMMANDS) {
       return c3.json({ summary: INFO_COMMANDS[command2] });
     }
@@ -99768,7 +101503,7 @@ function registerCommandRoutes(deps) {
         return c3.json({ summary: "Agent not connected." }, 404);
       }
       try {
-        const result = await forwardCommandToAgent(peers, command2, args);
+        const result = await forwardCommandToAgent(peers, command2, args, body.envelope);
         return c3.json(result);
       } catch (err2) {
         const msg = err2 instanceof Error ? err2.message : String(err2);
@@ -99795,13 +101530,14 @@ function handleCommandResponse(commandId, result) {
   pendingCommands.delete(commandId);
   pending.resolve(result);
 }
-async function forwardCommandToAgent(peers, command2, args) {
+async function forwardCommandToAgent(peers, command2, args, envelope) {
   const commandId = crypto.randomUUID();
   const payload = JSON.stringify({
     type: "command_request",
     id: commandId,
     command: command2,
-    args
+    args,
+    envelope
   });
   return new Promise((resolve14, reject) => {
     const timer = setTimeout(() => {
@@ -100380,7 +102116,7 @@ async function createSyncRelay(config) {
   const taskQueue = new TaskQueue(moteDb.db);
   const relayIdentity = await initRelayIdentity(moteDb.db, config.relayKeyPassphrase, createLogger({ service: "relay" }));
   const taskRouter = createTaskRouter({ db: moteDb.db, relayIdentity, federationConfig });
-  const { cache: federationQueryCache, pruneInterval: federationQueryPruneInterval } = createFederationQueryCache();
+  const { cache: federationQueryCache, pruneInterval: federationQueryPruneInterval } = createFederationQueryCache(loopSupervisor);
   const app = new Hono();
   const { injectWebSocket, upgradeWebSocket } = createNodeWebSocket({ app });
   const logger39 = createLogger({ service: "relay" });
@@ -100424,7 +102160,7 @@ async function createSyncRelay(config) {
   if (STALE_ALLOCATION_HORIZON_MS < 3 * TASK_TTL_MS) {
     throw new Error(`STALE_ALLOCATION_HORIZON_MS (${STALE_ALLOCATION_HORIZON_MS}ms) must be >= 3x TASK_TTL_MS (${TASK_TTL_MS}ms) \u2014 sweeping a live task's allocation opens a refund/settlement double-credit race`);
   }
-  const taskCleanupInterval = setInterval(() => {
+  const taskCleanupInterval = superviseInterval(loopSupervisor, "task-cleanup", 6e4, () => {
     const now = Date.now();
     taskQueue.cleanup(now);
     const evicted = taskQueue.evict(MAX_TASK_QUEUE_SIZE2);
@@ -100471,7 +102207,7 @@ async function createSyncRelay(config) {
       }
     } catch {
     }
-  }, 6e4);
+  });
   registerWebSocketRoutes({
     app,
     upgradeWebSocket,
@@ -100572,7 +102308,8 @@ async function createSyncRelay(config) {
   });
   const orchestrationWorkerInterval = startDeferredOrchestrationWorker2({
     db: moteDb.db,
-    relayIdentity
+    relayIdentity,
+    supervisor: loopSupervisor
   });
   logger39.info("dispute_orchestration_worker.started");
   const { registerTransparencyRoutes: registerTransparencyRoutes2 } = await Promise.resolve().then(() => (init_transparency2(), transparency_exports));
@@ -100779,8 +102516,8 @@ async function createSyncRelay(config) {
     isAgentRevoked
   });
   registerCommandRoutes({ app, db: moteDb.db, connections, logger: logger39 });
-  const heartbeatInterval = startHeartbeatLoop(moteDb.db, relayIdentity, 6e4, () => getEmergencyFreeze());
-  const revocationHorizonInterval = startRevocationHorizonLoop(moteDb.db, { relayIdentity, witnessSolicitationTimeoutMs: federationConfig?.witnessSolicitationTimeoutMs }, federationConfig?.revocationHorizonIntervalMs, () => getEmergencyFreeze());
+  const heartbeatInterval = startHeartbeatLoop(moteDb.db, relayIdentity, 6e4, () => getEmergencyFreeze(), loopSupervisor);
+  const revocationHorizonInterval = startRevocationHorizonLoop(moteDb.db, { relayIdentity, witnessSolicitationTimeoutMs: federationConfig?.witnessSolicitationTimeoutMs }, federationConfig?.revocationHorizonIntervalMs, () => getEmergencyFreeze(), loopSupervisor);
   const settlementRetryInterval = startSettlementRetryLoop(
     moteDb.db,
     relayIdentity,
@@ -100874,16 +102611,17 @@ async function createSyncRelay(config) {
       }
     })();
   }
-  const batchAnchorInterval = startBatchAnchorLoop(moteDb.db, relayIdentity, { submitter: anchorSubmitter }, () => getEmergencyFreeze());
-  const agentAnchorInterval = startAgentSettlementAnchorLoop(moteDb.db, relayIdentity, { submitter: anchorSubmitter }, () => getEmergencyFreeze());
+  const batchAnchorInterval = startBatchAnchorLoop(moteDb.db, relayIdentity, { submitter: anchorSubmitter }, () => getEmergencyFreeze(), loopSupervisor);
+  const agentAnchorInterval = startAgentSettlementAnchorLoop(moteDb.db, relayIdentity, { submitter: anchorSubmitter }, () => getEmergencyFreeze(), loopSupervisor);
   credentialAnchorConfig.submitter = anchorSubmitter;
-  const credentialAnchorInterval = startCredentialAnchorLoop(moteDb.db, relayIdentity, credentialAnchorConfig, () => getEmergencyFreeze());
+  const credentialAnchorInterval = startCredentialAnchorLoop(moteDb.db, relayIdentity, credentialAnchorConfig, () => getEmergencyFreeze(), loopSupervisor);
   const { startIdentityLogAnchorLoop: startIdentityLogAnchorLoop2 } = await Promise.resolve().then(() => (init_identity_log_anchoring(), identity_log_anchoring_exports));
-  const identityLogAnchorInterval = startIdentityLogAnchorLoop2(moteDb.db, relayIdentity, { submitter: anchorSubmitter }, () => getEmergencyFreeze());
+  const identityLogAnchorInterval = startIdentityLogAnchorLoop2(moteDb.db, relayIdentity, { submitter: anchorSubmitter }, () => getEmergencyFreeze(), loopSupervisor);
   const depositDetectorChain = x402Config.network;
   const depositDetectorInterval = startDepositDetector({
     db: moteDb.db,
-    chain: depositDetectorChain
+    chain: depositDetectorChain,
+    supervisor: loopSupervisor
   });
   let treasuryReconciliationInterval;
   {
@@ -100901,7 +102639,8 @@ async function createSyncRelay(config) {
         treasuryAddress: x402Config.payToAddress,
         usdcContractAddress,
         intervalMs,
-        isFrozen: () => getEmergencyFreeze()
+        isFrozen: () => getEmergencyFreeze(),
+        supervisor: loopSupervisor
       });
     } else {
       logger39.info("treasury-reconciliation.disabled", {
@@ -100933,7 +102672,8 @@ async function createSyncRelay(config) {
       // negative-drift on every cycle.
       ...solanaUsdcMint ? { usdcMint: solanaUsdcMint } : {},
       intervalMs: solanaReconciliationIntervalMs,
-      isFrozen: () => getEmergencyFreeze()
+      isFrozen: () => getEmergencyFreeze(),
+      supervisor: loopSupervisor
     });
   } else {
     logger39.info("solana-treasury-reconciliation.disabled", {
@@ -101855,13 +103595,13 @@ init_colors();
 import {
   appendFileSync,
   existsSync as existsSync8,
-  mkdirSync as mkdirSync9,
-  readFileSync as readFileSync9,
+  mkdirSync as mkdirSync10,
+  readFileSync as readFileSync10,
   readdirSync as readdirSync3,
   statSync as statSync4,
-  writeFileSync as writeFileSync13
+  writeFileSync as writeFileSync14
 } from "fs";
-import { isAbsolute as isAbsolute3, join as join16, resolve as resolve10 } from "path";
+import { isAbsolute as isAbsolute3, join as join17, resolve as resolve10 } from "path";
 import * as readline5 from "readline";
 var DEFAULT_RELAY_URL = "https://relay.motebit.com";
 var REGISTRY_ADDRESS_RE = /^did:key:z[1-9A-HJ-NP-Za-km-z]+\/[a-z0-9-]+@[^/]+$/;
@@ -101881,15 +103621,15 @@ function resolveRelayUrl() {
 var SKILLS_DIR_NAME = "skills";
 var AUDIT_LOG_NAME = "audit.log";
 function getSkillsRoot() {
-  return join16(CONFIG_DIR, SKILLS_DIR_NAME);
+  return join17(CONFIG_DIR, SKILLS_DIR_NAME);
 }
 function getAuditLogPath() {
-  return join16(getSkillsRoot(), AUDIT_LOG_NAME);
+  return join17(getSkillsRoot(), AUDIT_LOG_NAME);
 }
 function makeAuditSink() {
   return (event) => {
     const root = getSkillsRoot();
-    if (!existsSync8(root)) mkdirSync9(root, { recursive: true });
+    if (!existsSync8(root)) mkdirSync10(root, { recursive: true });
     appendFileSync(getAuditLogPath(), JSON.stringify(event) + "\n", "utf-8");
   };
 }
@@ -102227,7 +103967,7 @@ function parseAuditFilters(config) {
 function readAuditEvents() {
   const path19 = getAuditLogPath();
   if (!existsSync8(path19)) return [];
-  const text = readFileSync9(path19, "utf-8");
+  const text = readFileSync10(path19, "utf-8");
   const events = [];
   for (const line of text.split("\n")) {
     const trimmed = line.trim();
@@ -102386,14 +104126,14 @@ async function handleSkillsRunScript(config) {
   }
   moteDb.close();
   if (!approved) process.exit(1);
-  const { mkdtempSync, writeFileSync: writeBytes, chmodSync: chmodSync2, rmSync: rmSync2 } = await import("fs");
+  const { mkdtempSync, writeFileSync: writeBytes, chmodSync: chmodSync3, rmSync: rmSync3 } = await import("fs");
   const { tmpdir: tmpdir2 } = await import("os");
   const { spawnSync } = await import("child_process");
-  const tempDir = mkdtempSync(join16(tmpdir2(), "motebit-skill-script-"));
-  const tempPath = join16(tempDir, scriptName);
+  const tempDir = mkdtempSync(join17(tmpdir2(), "motebit-skill-script-"));
+  const tempPath = join17(tempDir, scriptName);
   try {
     writeBytes(tempPath, Buffer.from(scriptBytes));
-    chmodSync2(tempPath, 448);
+    chmodSync3(tempPath, 448);
     const interpreter = detectInterpreter(scriptBytes, scriptName);
     const spawnArgs = interpreter.useShebang ? scriptArgs : [tempPath, ...scriptArgs];
     const command2 = interpreter.useShebang ? tempPath : interpreter.command;
@@ -102408,7 +104148,7 @@ async function handleSkillsRunScript(config) {
     process.exit(result.status ?? 0);
   } finally {
     try {
-      rmSync2(tempDir, { recursive: true, force: true });
+      rmSync3(tempDir, { recursive: true, force: true });
     } catch {
     }
   }
@@ -102460,17 +104200,17 @@ function collectAuxFiles2(skillDir) {
   function walk2(current, base) {
     const entries = readdirSync3(current, { withFileTypes: true });
     for (const entry of entries) {
-      const full = join16(current, entry.name);
+      const full = join17(current, entry.name);
       if (entry.isDirectory()) {
         walk2(full, base);
       } else if (entry.isFile()) {
         const rel = full.slice(base.length + 1).split(/[\\/]+/).join("/");
-        out[rel] = readFileSync9(full);
+        out[rel] = readFileSync10(full);
       }
     }
   }
   for (const subdir of AUX_DIRS2) {
-    const subdirPath = join16(skillDir, subdir);
+    const subdirPath = join17(skillDir, subdir);
     if (existsSync8(subdirPath)) walk2(subdirPath, skillDir);
   }
   return out;
@@ -102518,12 +104258,12 @@ async function loadIdentityKey() {
   };
 }
 async function signSkillDirectory(skillDir, privateKey, publicKey) {
-  const skillMdPath = join16(skillDir, SKILL_MD_NAME);
+  const skillMdPath = join17(skillDir, SKILL_MD_NAME);
   if (!existsSync8(skillMdPath)) {
     console.error(error(`  No SKILL.md at ${skillMdPath}`));
     process.exit(1);
   }
-  const text = readFileSync9(skillMdPath, "utf-8");
+  const text = readFileSync10(skillMdPath, "utf-8");
   const parsed = parseSkillFile(text);
   const body = parsed.body;
   const motebitNoSig = { ...parsed.manifest.motebit };
@@ -102560,9 +104300,9 @@ async function signSkillDirectory(skillDir, privateKey, publicKey) {
     publicKey
   );
   const skillMdContent = serializeSkillFile(signedManifest, body);
-  writeFileSync13(skillMdPath, skillMdContent);
-  writeFileSync13(
-    join16(skillDir, SKILL_ENVELOPE_JSON_NAME),
+  writeFileSync14(skillMdPath, skillMdContent);
+  writeFileSync14(
+    join17(skillDir, SKILL_ENVELOPE_JSON_NAME),
     JSON.stringify(signedEnvelope, null, 2) + "\n"
   );
   return { envelope: signedEnvelope, manifest: signedManifest, body };
@@ -102982,7 +104722,7 @@ init_esm_shims();
 init_dist6();
 init_dist30();
 init_colors();
-import { readFileSync as readFileSync11 } from "fs";
+import { readFileSync as readFileSync12 } from "fs";
 import { resolve as resolve12 } from "path";
 var KIND_KEYWORDS = /* @__PURE__ */ new Set(["receipt", "token", "listing"]);
 function isVerifyKind(s3) {
@@ -102993,7 +104733,7 @@ async function verifyWire(kind, filePath, now = Date.now()) {
   const absPath = resolve12(filePath);
   let raw;
   try {
-    const text = readFileSync11(absPath, "utf-8");
+    const text = readFileSync12(absPath, "utf-8");
     raw = JSON.parse(text);
     checks.push({ name: "json", ok: true, detail: `parsed ${text.length} bytes` });
   } catch (err2) {
@@ -103198,7 +104938,7 @@ init_esm_shims();
 init_dist2();
 init_dist32();
 init_dist3();
-import { createHash as createHash2 } from "crypto";
+import { createHash as createHash3 } from "crypto";
 var MAX_TOOL_CALLS_PER_RUN = 50;
 var GoalScheduler = class _GoalScheduler {
   constructor(runtime, goalStore, approvalStore, goalOutcomeStore, motebitId, denyAbove, defaultTtlMs = 36e5, goalWallClockMs = 10 * 60 * 1e3) {
@@ -104000,7 +105740,7 @@ var GoalScheduler = class _GoalScheduler {
   }
 };
 function hashArgs(argsJson) {
-  return createHash2("sha256").update(argsJson).digest("hex");
+  return createHash3("sha256").update(argsJson).digest("hex");
 }
 function formatTimeAgo2(ms) {
   if (ms < 6e4) return "just now";
@@ -104106,6 +105846,7 @@ async function handleRun(config) {
   const motebitId = identity.motebit_id;
   const runtimeRef = { current: null };
   const toolRegistry = buildToolRegistry(config, runtimeRef, motebitId);
+  const runtimeHostServer = await electCoordinatorRole(fullConfig, motebitId, runtimeRef);
   const mcpServers = (fullConfig.mcp_servers ?? []).map((s3) => ({
     ...s3,
     trusted: (fullConfig.mcp_trusted_servers ?? []).includes(s3.name)
@@ -104137,6 +105878,7 @@ async function handleRun(config) {
     }
   );
   runtimeRef.current = runtime;
+  wireBridgedOrgans(runtimeHostServer, runtime);
   await runtime.init();
   runtime.setLocalCapabilities([
     DeviceCapability.StdioMcp,
@@ -104328,6 +106070,23 @@ Collaborative step ${stepId}... (proposal ${proposalId}...) ${stepStatus} by ${c
           const cmdMsg = msg;
           void (async () => {
             try {
+              const verdict = await verifyAgentCommandEnvelope({
+                envelope: cmdMsg.envelope,
+                command: cmdMsg.command,
+                args: cmdMsg.args,
+                motebitId,
+                identityPublicKey: identity.identity.public_key
+              });
+              if (!verdict.ok) {
+                wsAdapter.sendRaw(
+                  JSON.stringify({
+                    type: "command_response",
+                    id: cmdMsg.id,
+                    result: { summary: verdict.reason }
+                  })
+                );
+                return;
+              }
               const result = await executeCommand(runtime, cmdMsg.command, cmdMsg.args);
               wsAdapter.sendRaw(
                 JSON.stringify({ type: "command_response", id: cmdMsg.id, result })
@@ -104521,6 +106280,8 @@ Agent task received: ${task.task_id.slice(0, 8)}... prompt: "${task.prompt.slice
       }
       scheduler.stop();
       wsAdapter?.disconnect();
+      void runtimeHostServer.close().catch(() => {
+      });
       runtime.stop();
       moteDb.close();
       if (privKeyBytes) secureErase(privKeyBytes);
@@ -104613,6 +106374,7 @@ async function handleServe(config) {
   }
   const runtimeRef = { current: null };
   const toolRegistry = buildToolRegistry(config, runtimeRef, motebitId);
+  const runtimeHostServer = await electCoordinatorRole(loadFullConfig(), motebitId, runtimeRef);
   if (config.tools) {
     const { pathToFileURL } = await import("url");
     const resolved = path18.resolve(config.tools);
@@ -104663,6 +106425,7 @@ async function handleServe(config) {
     }
   );
   runtimeRef.current = runtime;
+  wireBridgedOrgans(runtimeHostServer, runtime);
   await runtime.init();
   const deps = {
     motebitId,
@@ -104922,6 +106685,26 @@ async function handleServe(config) {
           const cmdMsg = msg;
           void (async () => {
             try {
+              const verdict = publicKeyHex == null || publicKeyHex === "" ? {
+                ok: false,
+                reason: "command_request rejected: no registered identity public key to verify against"
+              } : await verifyAgentCommandEnvelope({
+                envelope: cmdMsg.envelope,
+                command: cmdMsg.command,
+                args: cmdMsg.args,
+                motebitId,
+                identityPublicKey: publicKeyHex
+              });
+              if (!verdict.ok) {
+                serveWsAdapter.sendRaw(
+                  JSON.stringify({
+                    type: "command_response",
+                    id: cmdMsg.id,
+                    result: { summary: verdict.reason }
+                  })
+                );
+                return;
+              }
               const result = await executeCommand(runtimeRef.current, cmdMsg.command, cmdMsg.args);
               serveWsAdapter.sendRaw(
                 JSON.stringify({ type: "command_response", id: cmdMsg.id, result })
@@ -105103,6 +106886,8 @@ async function handleServe(config) {
       }
       serveWsAdapter?.disconnect();
       await mcpServer.stop();
+      await runtimeHostServer.close().catch(() => {
+      });
       runtime.stop();
       moteDb.close();
     } catch (err2) {
@@ -105120,7 +106905,7 @@ init_esm_shims();
 import { spawn } from "child_process";
 import { mkdtemp, writeFile as writeFile3, unlink } from "fs/promises";
 import { tmpdir } from "os";
-import { join as join18 } from "path";
+import { join as join19 } from "path";
 
 // ../../packages/voice/dist/index.js
 init_esm_shims();
@@ -105396,8 +107181,8 @@ var SystemTTSProvider = class {
   }
 };
 async function writeTempMp3(buf) {
-  const dir = await mkdtemp(join18(tmpdir(), "motebit-tts-"));
-  const path19 = join18(dir, "out.mp3");
+  const dir = await mkdtemp(join19(tmpdir(), "motebit-tts-"));
+  const path19 = join19(dir, "out.mp3");
   await writeFile3(path19, buf);
   return path19;
 }
@@ -105881,6 +107666,31 @@ async function main() {
     current: null
   };
   const toolRegistry = buildToolRegistry(config, runtimeRef, motebitId);
+  let election;
+  try {
+    election = await electCliRuntimeHost({
+      fullConfig: reloadedConfig,
+      motebitId,
+      loadPrivateKey: () => privateKeyBytes !== void 0 ? Promise.resolve(privateKeyBytes) : Promise.reject(
+        new Error("signing key unavailable \u2014 cannot attach to the running coordinator")
+      ),
+      runtimeRef
+    });
+  } catch (err2) {
+    console.error(
+      `Runtime-host election failed: ${err2 instanceof Error ? err2.message : String(err2)}`
+    );
+    console.error(
+      "Another motebit process may be coordinating with an incompatible build. Stop it and retry."
+    );
+    destroyTerminal();
+    process.exit(1);
+  }
+  if (election.role === "frontend") {
+    await runAttachedRepl(election.client, motebitId);
+    return;
+  }
+  const runtimeHostServer = election.server;
   const trustedServers = fullConfig.mcp_trusted_servers ?? [];
   const mcpServers = (fullConfig.mcp_servers ?? []).map((s3) => ({
     ...s3,
@@ -106022,6 +107832,8 @@ async function main() {
   }
   const shutdown = async () => {
     destroyTerminal();
+    await runtimeHostServer.close().catch(() => {
+    });
     runtime.stop();
     await Promise.allSettled(mcpAdapters.map((a3) => a3.disconnect()));
     try {