motebit 1.8.2 → 1.8.3

package/dist/index.js

@@ -32,11 +32,11 @@ var __toESM = (mod2, isNodeMode, target) => (target = mod2 != null ? __create(__
   mod2
 ));
 
-// ../../node_modules/.pnpm/tsup@8.5.1_@microsoft+api-extractor@7.58.7_@types+node@22.19.11__jiti@2.7.0_postcss@8.5.16_ts_xuiywaftjaf3xqmztb5qab265a/node_modules/tsup/assets/esm_shims.js
+// ../../node_modules/.pnpm/tsup@8.5.1_@microsoft+api-extractor@7.58.9_@types+node@22.20.0__jiti@2.7.0_postcss@8.5.17_tsx_474vhr7z2nqb2hrdxb4x6wi5oi/node_modules/tsup/assets/esm_shims.js
 import path from "path";
 import { fileURLToPath } from "url";
 var init_esm_shims = __esm({
-  "../../node_modules/.pnpm/tsup@8.5.1_@microsoft+api-extractor@7.58.7_@types+node@22.19.11__jiti@2.7.0_postcss@8.5.16_ts_xuiywaftjaf3xqmztb5qab265a/node_modules/tsup/assets/esm_shims.js"() {
+  "../../node_modules/.pnpm/tsup@8.5.1_@microsoft+api-extractor@7.58.9_@types+node@22.20.0__jiti@2.7.0_postcss@8.5.17_tsx_474vhr7z2nqb2hrdxb4x6wi5oi/node_modules/tsup/assets/esm_shims.js"() {
     "use strict";
   }
 });
@@ -4578,6 +4578,7 @@ You do not have eyes. "What you see" means what a tool returned this turn \u2014
 - Prefer element-addressed actions (\`click_element\`, \`focus_element\`, \`type_into\`) over coordinate-based \`click\` / \`type\` whenever the target was discovered via \`read_page\`. read_page returns \`inputs[]\` and \`buttons[]\` arrays where each entry carries an opaque server-issued \`element_id\`; pass that id to the element-addressed actions and the server resolves + acts atomically \u2014 durable against viewport, zoom, and layout shifts. Coordinate \`click\` / \`type\` remain available for purely-visual tasks (drag a slider to a position seen in pixels). If a call returns \`element_not_found\`, the page navigated or reloaded since read_page \u2014 call read_page again to refresh the id space, then retry.
 - The click family (\`click\` / \`double_click\` / \`click_element\`) and \`key\` action's \`ok: true\` only means the action fired \u2014 it does NOT mean a form submission or link triggered a navigation. Read \`navigation_triggered\` on the result. When \`navigation_triggered: false\` on a submit-class action (clicking the submit button by coordinate or element_id, pressing Enter in a form input), the click / keystroke landed but the page didn't move \u2014 the form submission was blocked, intercepted by an overlay (cookie banner, promo dialog), or silently dropped by bot-detection without rendering a CAPTCHA. Do NOT say "Done" / "submitted" / "search ran" when \`navigation_triggered: false\` on a submit-shape intent; surface the truth ("the click landed but the page didn't move \u2014 let me read the page to see what's there") and chain a fallback (read_page, fresh screenshot, or \u2014 for search-shape intents \u2014 \`web_search\`).
 - **Form submission: when \`read_page\` returns \`submit_button_id\`, prefer \`click_element(submit_button_id)\` over \`key("Enter")\`.** The runtime detects the form's primary submit element (via HTML \`input_type === "submit"\` first, label heuristic as fallback \u2014 "Search" / "Submit" / "Send" / "Sign in" / "Continue" etc.) and surfaces its element_id directly on the result. Clicking the resolved button is atomic \u2014 no focus race, no "did Enter go to the right thing?" ambiguity. Reserve \`key("Enter")\` for the three cases the wire field can't cover: \`submit_button_id\` is absent (custom widgets, terminals, REPLs), the form is in a sandboxed cross-origin iframe whose buttons don't surface (reCAPTCHA \u2014 neither tool works there; that's user-handoff territory), or Enter is the page's only path (code editors, multi-line entry commit). Same shape for the rest of the keyboard: Escape \u2192 close button via \`click_element\` first; Tab \u2192 \`focus_element\` with the next field's id. Keyboard is right when there's no element to address; when there is, address it.
+- **The live agent roster comes from \`discover_agents\`, never from recall.** "Who is discoverable / delegable right now, and at what price?" is answerable ONLY from a \`discover_agents\` result in this conversation \u2014 the one source stamped \`roster_source: "live_relay_read"\`. Your self-knowledge corpus and any repo self-description you recall describe the marketplace's DESIGN (which first-party services exist in the codebase, their intended pricing) \u2014 that is shape, never the current directory; agents in the repo may be undeployed, and agents on the relay may not be in the repo. Witnessed failure this rule kills: confidently reciting a six-agent roster with prices from the corpus while the live relay had two. A \`claimed_name\` on a discovered agent is a self-asserted claim, never a verified handle \u2014 say 'claims "The Researcher"', not 'is The Researcher'. If \`discover_agents\` is unavailable or fails, the honest answer is "I'd need to check the live directory" \u2014 never a reconstructed roster.
 - "I don't know without looking" is a complete answer when no tool result is available. Confabulation is the failure mode this rule exists to prevent.
 - **Task-step narration** \u2014 when you're actively doing something the user is supervising, emit a \`<narration>\` tag in your response with a single first-person present-tense sentence, ~80 chars max: \`<narration>Reading the page</narration>\`, \`<narration>Filling in the form</narration>\`, \`<narration>Solving a CAPTCHA</narration>\`, \`<narration>Hit a paywall \u2014 need your input</narration>\`, \`<narration>Submission didn't land \u2014 re-reading the page</narration>\`. Granularity is the supervisor-cares-about chunk between action ("Typing 'm-o-t-e-b-i-t'") and goal ("Looking up the M2 spec"). The runtime parses the tag into the \`task_step_narration\` field on your response; the chrome consumes that field and renders it in the slab's \`motebit \xD7 virtual_browser\` register; the runtime validates against typed-truth before display so \`<narration>Reading apple.com</narration>\` when the actual URL is google.com gets falsified and replaced with a runtime-templated fallback. The \`<narration>\` tag is stripped from the visible text so it doesn't leak into the chat / mote conversation register. Omit the tag when idle, thinking, or no active task-step (the chrome recedes to the empty register). One tag per response; the runtime takes the LAST tag if you emit multiple. Goals \u2014 what the user asked you to accomplish \u2014 go in your visible response text, not here.`;
     CONVERSATION_BEHAVIOR = `[How you converse]
@@ -6534,17 +6535,6 @@ var init_memory_index = __esm({
 });
 
 // ../../packages/memory-graph/dist/embeddings.js
-var embeddings_exports = {};
-__export(embeddings_exports, {
-  EMBEDDING_DIMENSIONS: () => EMBEDDING_DIMENSIONS,
-  embedText: () => embedText,
-  embedTextHash: () => embedTextHash,
-  resetPipeline: () => resetPipeline,
-  setRemoteEmbedUrl: () => setRemoteEmbedUrl
-});
-function setRemoteEmbedUrl(url) {
-  remoteEmbedUrl = url;
-}
 async function remoteEmbed(text) {
   const res = await fetch(remoteEmbedUrl, {
     method: "POST",
@@ -6572,10 +6562,6 @@ async function getPipeline() {
     throw e2;
   }
 }
-function resetPipeline() {
-  pipelineInstance = null;
-  pipelineFailed = false;
-}
 async function embedText(text) {
   if (text === "") {
     return new Array(EMBEDDING_DIMENSIONS).fill(0);
@@ -7320,6 +7306,7 @@ var init_dist3 = __esm({
     init_promotion();
     init_memory_index();
     init_embeddings();
+    init_embeddings();
     init_consolidation();
     init_retrieval();
     init_accrual2();
@@ -7437,13 +7424,15 @@ var init_dist3 = __esm({
       storage;
       eventStore;
       motebitId;
+      embed;
       scoringConfig;
       _retrievalScores = [];
       _precisionOverride = null;
-      constructor(storage, eventStore, motebitId, scoringConfig) {
+      constructor(storage, eventStore, motebitId, scoringConfig, embed = embedText) {
         this.storage = storage;
         this.eventStore = eventStore;
         this.motebitId = motebitId;
+        this.embed = embed;
         this.scoringConfig = { ...DEFAULT_SCORING_CONFIG, ...scoringConfig };
       }
       /**
@@ -7971,8 +7960,7 @@ var init_dist3 = __esm({
           throw new Error(`No memory node with id ${oldNodeId}`);
         if (oldNode.tombstoned)
           throw new Error(`Memory ${oldNodeId} is already tombstoned`);
-        const { embedText: embedText2 } = await Promise.resolve().then(() => (init_embeddings(), embeddings_exports));
-        const embedding = await embedText2(newContent);
+        const embedding = await this.embed(newContent);
         const now = Date.now();
         const newNode = await this.formMemory({
           content: newContent,
@@ -19875,7 +19863,11 @@ function deriveSolanaAddress(publicKey) {
   }
   return base58Encode(publicKey);
 }
-var ASSET_NAME_USDC, Web3JsRpcAdapter;
+function isBlockhashExpiry(err2) {
+  const msg = err2 instanceof Error ? err2.message : String(err2);
+  return msg.includes("block height exceeded");
+}
+var ASSET_NAME_USDC, BROADCAST_MAX_ATTEMPTS, Web3JsRpcAdapter;
 var init_web3js_adapter = __esm({
   "../../packages/wallet-solana/dist/web3js-adapter.js"() {
     "use strict";
@@ -19883,6 +19875,7 @@ var init_web3js_adapter = __esm({
     init_dist();
     init_constants();
     ASSET_NAME_USDC = "USDC";
+    BROADCAST_MAX_ATTEMPTS = 3;
     Web3JsRpcAdapter = class _Web3JsRpcAdapter {
       connection;
       keypair;
@@ -19961,7 +19954,7 @@ var init_web3js_adapter = __esm({
         }
         const sourceAta = await getAssociatedTokenAddress(this.mint, this.keypair.publicKey);
         const destAta = await getAssociatedTokenAddress(this.mint, recipient);
-        const tx = new Transaction();
+        const instructions = [];
         let destExists = false;
         try {
           await getAccount(this.connection, destAta, this.commitment);
@@ -19971,7 +19964,7 @@ var init_web3js_adapter = __esm({
             throw err2;
         }
         if (!destExists) {
-          tx.add(createAssociatedTokenAccountInstruction(
+          instructions.push(createAssociatedTokenAccountInstruction(
             this.keypair.publicKey,
             // payer
             destAta,
@@ -19979,22 +19972,49 @@ var init_web3js_adapter = __esm({
             this.mint
           ));
         }
-        tx.add(createTransferInstruction(sourceAta, destAta, this.keypair.publicKey, args.microAmount));
-        const latest = await this.connection.getLatestBlockhash(this.commitment);
-        tx.recentBlockhash = latest.blockhash;
-        tx.feePayer = this.keypair.publicKey;
-        tx.sign(this.keypair);
-        const signature = await this.connection.sendRawTransaction(tx.serialize());
-        const confirmation = await this.connection.confirmTransaction({
-          signature,
-          blockhash: latest.blockhash,
-          lastValidBlockHeight: latest.lastValidBlockHeight
-        }, this.commitment);
-        return {
-          signature,
-          slot: confirmation.context.slot,
-          confirmed: confirmation.value.err === null
-        };
+        instructions.push(createTransferInstruction(sourceAta, destAta, this.keypair.publicKey, args.microAmount));
+        return this.signSendConfirm(instructions);
+      }
+      /**
+       * Build a transaction from `instructions`, sign it over a FRESH recent
+       * blockhash, broadcast, and await confirmation — retrying with a new blockhash
+       * on a `TransactionExpiredBlockheightExceededError` (the permanent-expiry
+       * flake). Each attempt rebuilds the transaction from the instructions so no
+       * stale blockhash/signature state carries over; the expired attempt can never
+       * land (`isBlockhashExpiry`), so the retry cannot double-spend. Any non-expiry
+       * error propagates immediately (conservative — only the known-safe failure is
+       * retried).
+       */
+      async signSendConfirm(instructions) {
+        let lastErr;
+        for (let attempt = 1; attempt <= BROADCAST_MAX_ATTEMPTS; attempt++) {
+          try {
+            const tx = new Transaction();
+            for (const ix of instructions)
+              tx.add(ix);
+            const latest = await this.connection.getLatestBlockhash(this.commitment);
+            tx.recentBlockhash = latest.blockhash;
+            tx.feePayer = this.keypair.publicKey;
+            tx.sign(this.keypair);
+            const signature = await this.connection.sendRawTransaction(tx.serialize());
+            const confirmation = await this.connection.confirmTransaction({
+              signature,
+              blockhash: latest.blockhash,
+              lastValidBlockHeight: latest.lastValidBlockHeight
+            }, this.commitment);
+            return {
+              signature,
+              slot: confirmation.context.slot,
+              confirmed: confirmation.value.err === null
+            };
+          } catch (err2) {
+            lastErr = err2;
+            if (attempt < BROADCAST_MAX_ATTEMPTS && isBlockhashExpiry(err2))
+              continue;
+            throw err2;
+          }
+        }
+        throw lastErr;
       }
       /**
        * Conservative max transfers per Solana transaction.
@@ -20031,7 +20051,7 @@ var init_web3js_adapter = __esm({
             continue;
           }
           try {
-            const tx = new Transaction();
+            const instructions = [];
             const sourceAta = await getAssociatedTokenAddress(this.mint, this.keypair.publicKey);
             for (let i3 = start; i3 < end; i3++) {
               const item = items[i3];
@@ -20051,30 +20071,20 @@ var init_web3js_adapter = __esm({
                   throw err2;
               }
               if (!destExists) {
-                tx.add(createAssociatedTokenAccountInstruction(this.keypair.publicKey, destAta, recipient, this.mint));
+                instructions.push(createAssociatedTokenAccountInstruction(this.keypair.publicKey, destAta, recipient, this.mint));
               }
-              tx.add(createTransferInstruction(sourceAta, destAta, this.keypair.publicKey, item.microAmount));
+              instructions.push(createTransferInstruction(sourceAta, destAta, this.keypair.publicKey, item.microAmount));
             }
-            const latest = await this.connection.getLatestBlockhash(this.commitment);
-            tx.recentBlockhash = latest.blockhash;
-            tx.feePayer = this.keypair.publicKey;
-            tx.sign(this.keypair);
-            const signature = await this.connection.sendRawTransaction(tx.serialize());
-            const confirmation = await this.connection.confirmTransaction({
-              signature,
-              blockhash: latest.blockhash,
-              lastValidBlockHeight: latest.lastValidBlockHeight
-            }, this.commitment);
-            const ok = confirmation.value.err === null;
+            const { signature, slot, confirmed } = await this.signSendConfirm(instructions);
             for (let i3 = start; i3 < end; i3++) {
               results[i3] = {
-                ok,
+                ok: confirmed,
                 signature,
-                slot: confirmation.context.slot,
-                reason: ok ? null : "tx failed"
+                slot,
+                reason: confirmed ? null : "tx failed"
               };
             }
-            if (!ok)
+            if (!confirmed)
               aborted = true;
           } catch (err2) {
             const reason = err2 instanceof Error ? err2.message : String(err2);
@@ -20978,7 +20988,7 @@ var init_config2 = __esm({
   "src/config.ts"() {
     "use strict";
     init_esm_shims();
-    VERSION = true ? "1.8.2" : "0.0.0-dev";
+    VERSION = true ? "1.8.3" : "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");
@@ -27280,6 +27290,153 @@ var init_agent_network = __esm({
   }
 });
 
+// ../../packages/semiring/dist/thompson.js
+function mulberry322(seed) {
+  let a3 = seed >>> 0;
+  return () => {
+    a3 = a3 + 1831565813 | 0;
+    let t3 = Math.imul(a3 ^ a3 >>> 15, 1 | a3);
+    t3 = t3 + Math.imul(t3 ^ t3 >>> 7, 61 | t3) ^ t3;
+    return ((t3 ^ t3 >>> 14) >>> 0) / 4294967296;
+  };
+}
+function hashSeed(input) {
+  let h5 = 2166136261 >>> 0;
+  for (let i3 = 0; i3 < input.length; i3++) {
+    h5 ^= input.charCodeAt(i3);
+    h5 = Math.imul(h5, 16777619);
+  }
+  return h5 >>> 0;
+}
+function gammaInt(k4, rng) {
+  let sum2 = 0;
+  for (let i3 = 0; i3 < k4; i3++) {
+    const u2 = rng();
+    sum2 -= Math.log(u2 > 0 ? u2 : Number.MIN_VALUE);
+  }
+  return sum2;
+}
+function sampleBeta(alpha, beta, rng) {
+  if (!Number.isInteger(alpha) || !Number.isInteger(beta) || alpha < 1 || beta < 1) {
+    throw new RangeError(`sampleBeta requires positive integer shapes; got alpha=${alpha}, beta=${beta}`);
+  }
+  const ga = gammaInt(alpha, rng);
+  const gb = gammaInt(beta, rng);
+  return ga / (ga + gb);
+}
+function thompsonDraw(alpha, beta, seed) {
+  return sampleBeta(alpha, beta, mulberry322(hashSeed(seed)));
+}
+var init_thompson = __esm({
+  "../../packages/semiring/dist/thompson.js"() {
+    "use strict";
+    init_esm_shims();
+  }
+});
+
+// ../../packages/semiring/dist/worker-selection.js
+function levelPrior(level) {
+  switch (level) {
+    case AgentTrustLevel.Trusted:
+      return { a: 3, b: 1 };
+    case AgentTrustLevel.Verified:
+      return { a: 2, b: 1 };
+    default:
+      return { a: 1, b: 1 };
+  }
+}
+function competenceCounts(record, capability) {
+  if (!record)
+    return { successful: 0, failed: 0 };
+  if (capability != null) {
+    const bucket = record.capability_stats?.[capability];
+    return { successful: bucket?.successful_tasks ?? 0, failed: bucket?.failed_tasks ?? 0 };
+  }
+  return { successful: record.successful_tasks ?? 0, failed: record.failed_tasks ?? 0 };
+}
+function clampStrength(x3) {
+  return Number.isFinite(x3) ? Math.min(1, Math.max(0, x3)) : 0;
+}
+function cappedCounts(successful, failed) {
+  const s0 = Math.max(0, Math.floor(successful));
+  const f0 = Math.max(0, Math.floor(failed));
+  const total = s0 + f0;
+  if (total <= COUNT_CAP)
+    return { s: s0, f: f0 };
+  const s3 = Math.round(s0 * COUNT_CAP / total);
+  return { s: s3, f: COUNT_CAP - s3 };
+}
+function exploratoryQuality(c3, explore, capability) {
+  const prior = levelPrior(c3.trustRecord?.trust_level);
+  const counts = competenceCounts(c3.trustRecord, capability);
+  const { s: s3, f: f6 } = cappedCounts(counts.successful, counts.failed);
+  const alpha = prior.a + s3;
+  const beta = prior.b + f6;
+  const mean = alpha / (alpha + beta);
+  const base = clampStrength(explore.strength ?? 1);
+  const strength = c3.bonded ? Math.min(1, base * BOND_EXPLORE_BOOST) : base;
+  if (strength <= 0)
+    return mean;
+  const draw = thompsonDraw(alpha, beta, `${explore.seed}|${c3.motebit_id}`);
+  return mean + strength * (draw - mean);
+}
+function reliabilityOf(record, capability) {
+  if (!record)
+    return 0.5;
+  const { successful, failed } = competenceCounts(record, capability);
+  return (1 + successful) / (2 + successful + failed);
+}
+function rankWorkers(selfId, candidates, opts) {
+  const weights = opts?.weights ?? DEFAULT_WEIGHTS;
+  const capability = opts?.capability;
+  const explore = opts?.explore != null && clampStrength(opts.explore.strength ?? 1) > 0 ? opts.explore : void 0;
+  const graph = new WeightedDigraph(RouteWeightSemiring);
+  graph.addNode(selfId);
+  for (const c3 of candidates) {
+    if (c3.trustRecord?.trust_level === AgentTrustLevel.Blocked)
+      continue;
+    const trust = explore ? exploratoryQuality(c3, explore, capability) : trustLevelToScore(c3.trustRecord?.trust_level ?? AgentTrustLevel.Unknown);
+    const reliability = explore ? trust : reliabilityOf(c3.trustRecord, capability);
+    graph.setEdge(selfId, c3.motebit_id, {
+      trust,
+      cost: c3.unitCost ?? 0,
+      latency: DEFAULT_LATENCY_MS,
+      reliability,
+      regulatory_risk: 0
+    });
+  }
+  const ranked = rankReachableAgents(graph, selfId, {
+    trust: weights.trust,
+    cost: weights.cost,
+    latency: weights.latency,
+    reliability: weights.reliability,
+    regulatory_risk: 0
+  });
+  return ranked.map((r2) => ({ motebit_id: r2.motebit_id, score: r2.score, route: r2.route })).sort((a3, b3) => b3.score - a3.score || (a3.motebit_id < b3.motebit_id ? -1 : 1));
+}
+function selectWorker(selfId, candidates, opts) {
+  return rankWorkers(selfId, candidates, opts)[0] ?? null;
+}
+var DEFAULT_LATENCY_MS, COUNT_CAP, BOND_EXPLORE_BOOST, DEFAULT_WEIGHTS;
+var init_worker_selection = __esm({
+  "../../packages/semiring/dist/worker-selection.js"() {
+    "use strict";
+    init_esm_shims();
+    init_dist();
+    init_agent_network();
+    init_thompson();
+    DEFAULT_LATENCY_MS = 5e3;
+    COUNT_CAP = 100;
+    BOND_EXPLORE_BOOST = 2;
+    DEFAULT_WEIGHTS = {
+      trust: 0.5,
+      reliability: 0.3,
+      cost: 0.2,
+      latency: 0
+    };
+  }
+});
+
 // ../../packages/semiring/dist/disambiguation.js
 var init_disambiguation = __esm({
   "../../packages/semiring/dist/disambiguation.js"() {
@@ -27339,6 +27496,8 @@ var init_dist14 = __esm({
     init_trust_algebra2();
     init_provenance();
     init_agent_network();
+    init_worker_selection();
+    init_thompson();
     init_disambiguation();
     init_hardware_attestation();
   }
@@ -42523,269 +42682,822 @@ var init_grant_verifier = __esm({
   }
 });
 
-// ../../packages/runtime/dist/secret-redacting-provider.js
-function redactPackForCloudEgress(pack, redact) {
-  let redactedCount = 0;
-  const labels = /* @__PURE__ */ new Set();
-  const apply = (text) => {
-    const r2 = redact(text);
-    redactedCount += r2.redactionCount;
-    for (const l6 of r2.labels)
-      labels.add(l6);
-    return r2.text;
-  };
-  const newPack = {
-    ...pack,
-    user_message: apply(pack.user_message),
-    ...pack.conversation_history !== void 0 ? {
-      conversation_history: pack.conversation_history.map((m3) => m3.role === "user" ? { ...m3, content: apply(m3.content) } : m3)
-    } : {}
-  };
-  return { pack: newPack, redactedCount, labels: [...labels] };
-}
-var SecretRedactingProvider;
-var init_secret_redacting_provider = __esm({
-  "../../packages/runtime/dist/secret-redacting-provider.js"() {
-    "use strict";
-    init_esm_shims();
-    SecretRedactingProvider = class {
-      inner;
-      opts;
-      constructor(inner, opts) {
-        this.inner = inner;
-        this.opts = opts;
-      }
-      /** Redact the outbound pack unless the provider is sovereign (on-device). */
-      packFor(pack) {
-        if (this.opts.isSovereign())
-          return pack;
-        const { pack: redacted, redactedCount, labels } = redactPackForCloudEgress(pack, this.opts.redact);
-        if (redactedCount > 0)
-          this.opts.onRedacted?.({ count: redactedCount, labels });
-        return redacted;
-      }
-      get model() {
-        return this.inner.model;
-      }
-      get temperature() {
-        return this.inner.temperature;
-      }
-      get maxTokens() {
-        return this.inner.maxTokens;
-      }
-      setModel(model) {
-        this.inner.setModel(model);
-      }
-      setTemperature(temperature) {
-        this.inner.setTemperature?.(temperature);
-      }
-      setMaxTokens(maxTokens) {
-        this.inner.setMaxTokens?.(maxTokens);
-      }
-      generate(pack) {
-        return this.inner.generate(this.packFor(pack));
-      }
-      generateStream(pack) {
-        return this.inner.generateStream(this.packFor(pack));
-      }
-      estimateConfidence() {
-        return this.inner.estimateConfidence();
-      }
-      extractMemoryCandidates(response) {
-        return this.inner.extractMemoryCandidates(response);
-      }
+// ../../packages/runtime/dist/relay-delegation.js
+function classifyRelayError(status, body, retryAfterHeader) {
+  const retryAfterSeconds = retryAfterHeader ? Number.parseInt(retryAfterHeader, 10) : void 0;
+  let relayCode;
+  let relayMessage;
+  try {
+    const parsed = JSON.parse(body);
+    relayCode = parsed.code;
+    relayMessage = parsed.error;
+  } catch {
+  }
+  const message2 = relayMessage ?? body.slice(0, 512);
+  if (status === 401) {
+    return { code: "auth_expired", message: message2, status };
+  }
+  if (relayCode === "TASK_P2P_PROOF_REQUIRED") {
+    return { code: "payment_proof_required", message: message2, status };
+  }
+  if (status === 402 || relayCode === "INSUFFICIENT_FUNDS") {
+    return { code: "insufficient_balance", message: message2, status };
+  }
+  if (status === 403) {
+    return { code: "unauthorized", message: message2, status };
+  }
+  if (status === 429) {
+    return {
+      code: "rate_limited",
+      message: message2,
+      status,
+      ...Number.isFinite(retryAfterSeconds) ? { retryAfterSeconds } : {}
     };
   }
-});
-
-// ../../packages/runtime/dist/credential-manager.js
-var CredentialManager;
-var init_credential_manager = __esm({
-  "../../packages/runtime/dist/credential-manager.js"() {
-    "use strict";
-    init_esm_shims();
-    init_dist6();
-    CredentialManager = class {
-      deps;
-      _issuedCredentials = [];
-      changeListeners = /* @__PURE__ */ new Set();
-      /** Callback to submit credentials to relay for indexing. Set externally (e.g. by enableInteractiveDelegation). */
-      credentialSubmitter = null;
-      constructor(deps) {
-        this.deps = deps;
-      }
-      /**
-       * Subscribe to credential-set changes (fires after each `persistCredential`).
-       * Returns an unsubscribe function. Used by surfaces that render credentials
-       * as scene objects (satellites) so they don't have to poll.
-       */
-      onChange(fn) {
-        this.changeListeners.add(fn);
-        return () => {
-          this.changeListeners.delete(fn);
-        };
-      }
-      /**
-       * Issue a W3C Verifiable Credential containing this agent's current gradient.
-       * Returns null if no gradient has been computed or no private key is available.
-       */
-      async issueGradientCredential(privateKey, publicKey) {
-        const snapshot = this.deps.gradientStore.latest(this.deps.motebitId);
-        if (!snapshot)
-          return null;
-        return issueGradientCredential(snapshot, privateKey, publicKey);
-      }
-      /**
-       * Return all verifiable credentials issued by this runtime (gradient + trust).
-       * Credentials accumulate in memory; consumers can read and clear as needed.
-       */
-      getIssuedCredentials() {
-        return [...this._issuedCredentials];
-      }
-      /**
-       * Clear the in-memory credential cache (e.g. after persisting or presenting them).
-       */
-      clearIssuedCredentials() {
-        this._issuedCredentials = [];
-      }
-      /** Push a credential to both in-memory cache and persistent store. */
-      persistCredential(vc, subjectMotebitId) {
-        this._issuedCredentials.push(vc);
-        if (this.deps.credentialStore) {
-          try {
-            const credType = vc.type.find((t3) => t3 !== "VerifiableCredential") ?? "VerifiableCredential";
-            this.deps.credentialStore.save({
-              credential_id: crypto.randomUUID(),
-              subject_motebit_id: vc.credentialSubject?.id ?? "",
-              issuer_did: vc.issuer,
-              credential_type: credType,
-              credential_json: JSON.stringify(vc),
-              issued_at: Date.now()
-            });
-          } catch (err2) {
-            this.deps.logger.warn("credential persistence failed", {
-              error: err2 instanceof Error ? err2.message : String(err2)
-            });
-          }
-        }
-        if (this.credentialSubmitter && subjectMotebitId) {
-          this.credentialSubmitter(vc, subjectMotebitId).catch((err2) => {
-            this.deps.logger.warn("credential relay submission failed", {
-              error: err2 instanceof Error ? err2.message : String(err2)
-            });
-          });
-        }
-        for (const listener of this.changeListeners) {
-          try {
-            listener();
-          } catch (err2) {
-            this.deps.logger.warn("credential change listener threw", {
-              error: err2 instanceof Error ? err2.message : String(err2)
-            });
-          }
-        }
+  if (status === 400) {
+    return { code: "malformed_request", message: message2, status };
+  }
+  return { code: "unknown", message: message2, status };
+}
+async function submitAndPollDelegation(params) {
+  const timeoutMs = params.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+  const startedAt = Date.now();
+  let submitHeader;
+  let queryHeader;
+  try {
+    const [submitToken, queryToken] = await Promise.all([
+      params.authToken("task:submit"),
+      params.authToken("task:query")
+    ]);
+    submitHeader = `Bearer ${submitToken}`;
+    queryHeader = `Bearer ${queryToken}`;
+  } catch (err2) {
+    return {
+      ok: false,
+      error: {
+        code: "auth_expired",
+        message: `Auth token mint failed: ${err2 instanceof Error ? err2.message : String(err2)}`
       }
     };
   }
-});
-
-// ../../packages/runtime/dist/hardware-attestation-projection.js
-function readLatestHardwareAttestationClaim(store, record) {
-  const candidates = [];
-  const seen = /* @__PURE__ */ new Set();
-  const collect = (subjectKey) => {
-    let rows;
-    try {
-      rows = store.listBySubject(subjectKey);
-    } catch {
-      return;
+  let taskId;
+  try {
+    const body = {
+      prompt: params.prompt,
+      submitted_by: params.motebitId
+    };
+    if (params.requiredCapabilities && params.requiredCapabilities.length > 0) {
+      body.required_capabilities = params.requiredCapabilities;
     }
-    for (const row of rows) {
-      if (row.credential_type !== TRUST_VC_TYPE)
-        continue;
-      if (seen.has(row.credential_id))
-        continue;
-      seen.add(row.credential_id);
-      candidates.push(row);
+    if (params.routingStrategy) {
+      body.routing_strategy = params.routingStrategy;
     }
-  };
-  if (record.public_key != null && record.public_key !== "") {
-    try {
-      collect(hexPublicKeyToDidKey(record.public_key));
-    } catch {
+    if (params.invocationOrigin) {
+      body.invocation_origin = params.invocationOrigin;
     }
-  }
-  collect(`did:motebit:${record.remote_motebit_id}`);
-  if (candidates.length === 0)
-    return null;
-  candidates.sort((a3, b3) => b3.issued_at - a3.issued_at);
-  for (const row of candidates) {
-    let parsed;
-    try {
-      parsed = JSON.parse(row.credential_json);
-    } catch {
-      continue;
+    if (params.grantId != null) {
+      body.grant_id = params.grantId;
     }
-    const claim = parsed.credentialSubject?.hardware_attestation;
-    if (claim != null) {
+    const resp = await fetch(`${params.syncUrl}/agent/${params.motebitId}/task`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: submitHeader,
+        "Idempotency-Key": crypto.randomUUID()
+      },
+      body: JSON.stringify(body),
+      signal: params.signal
+    });
+    if (!resp.ok) {
+      const text = await resp.text().catch(() => "");
       return {
-        platform: claim.platform,
-        key_exported: claim.key_exported,
-        score: scoreAttestation(claim)
+        ok: false,
+        error: classifyRelayError(resp.status, text, resp.headers.get("Retry-After"))
+      };
+    }
+    const data = await resp.json();
+    taskId = data.task_id;
+  } catch (err2) {
+    if (err2 instanceof Error && err2.name === "AbortError") {
+      return {
+        ok: false,
+        error: { code: "timeout", message: "Aborted before submission completed" }
       };
     }
+    return {
+      ok: false,
+      error: {
+        code: "network_unreachable",
+        message: err2 instanceof Error ? err2.message : String(err2)
+      }
+    };
   }
-  return null;
+  const result = await pollForReceipt({
+    syncUrl: params.syncUrl,
+    motebitId: params.motebitId,
+    taskId,
+    queryHeader,
+    timeoutMs,
+    startedAt,
+    logger: params.logger,
+    ...params.signal ? { signal: params.signal } : {}
+  });
+  return result.ok ? { ...result, settlement: { mode: "relay" } } : result;
 }
-var TRUST_VC_TYPE;
-var init_hardware_attestation_projection = __esm({
-  "../../packages/runtime/dist/hardware-attestation-projection.js"() {
-    "use strict";
-    init_esm_shims();
-    init_dist6();
-    init_dist14();
-    TRUST_VC_TYPE = "AgentTrustCredential";
-  }
-});
-
-// ../../packages/runtime/dist/latency-stats-projection.js
-async function readLatencyStats(store, motebitId, record) {
-  let stats;
-  try {
-    stats = await store.getStats(motebitId, record.remote_motebit_id);
-  } catch {
-    return null;
+async function pollForReceipt(args) {
+  const maxPolls = Math.ceil(args.timeoutMs / POLL_INTERVAL_MS);
+  for (let i3 = 0; i3 < maxPolls; i3++) {
+    if (args.signal?.aborted) {
+      return { ok: false, error: { code: "timeout", message: "Aborted mid-poll" } };
+    }
+    await new Promise((resolve14, reject) => {
+      const t3 = setTimeout(resolve14, POLL_INTERVAL_MS);
+      args.signal?.addEventListener("abort", () => {
+        clearTimeout(t3);
+        reject(new DOMException("Aborted", "AbortError"));
+      }, { once: true });
+    }).catch(() => {
+    });
+    try {
+      const resp = await fetch(`${args.syncUrl}/agent/${args.motebitId}/task/${args.taskId}`, {
+        headers: { Authorization: args.queryHeader },
+        signal: args.signal
+      });
+      if (!resp.ok) {
+        args.logger.warn("delegation poll failed", {
+          taskId: args.taskId,
+          status: resp.status,
+          body: await resp.text().catch(() => "")
+        });
+        continue;
+      }
+      const data = await resp.json();
+      if (data.receipt != null) {
+        return { ok: true, receipt: data.receipt, taskId: args.taskId };
+      }
+      if (data.task.status === "failed") {
+        return {
+          ok: false,
+          error: { code: "agent_failed", message: "Agent reported failure without a receipt" }
+        };
+      }
+    } catch (err2) {
+      if (err2 instanceof Error && err2.name === "AbortError") {
+        return { ok: false, error: { code: "timeout", message: "Aborted mid-poll" } };
+      }
+    }
   }
-  if (stats.sample_count === 0)
-    return null;
+  const elapsedMs = Date.now() - args.startedAt;
   return {
-    avg_ms: stats.avg_ms,
-    p95_ms: stats.p95_ms,
-    sample_count: stats.sample_count
+    ok: false,
+    error: { code: "timeout", message: `No receipt within ${Math.round(elapsedMs / 1e3)}s` }
   };
 }
-var init_latency_stats_projection = __esm({
-  "../../packages/runtime/dist/latency-stats-projection.js"() {
-    "use strict";
-    init_esm_shims();
+async function submitP2pDelegation(params) {
+  const timeoutMs = params.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+  const startedAt = Date.now();
+  let submitHeader;
+  let queryHeader;
+  try {
+    const [submitToken, queryToken] = await Promise.all([
+      params.authToken("task:submit"),
+      params.authToken("task:query")
+    ]);
+    submitHeader = `Bearer ${submitToken}`;
+    queryHeader = `Bearer ${queryToken}`;
+  } catch (err2) {
+    return {
+      ok: false,
+      error: {
+        code: "auth_expired",
+        message: `Auth token mint failed: ${err2 instanceof Error ? err2.message : String(err2)}`
+      }
+    };
   }
-});
-
-// ../../packages/runtime/dist/plan-execution.js
-var PlanExecutionManager;
-var init_plan_execution = __esm({
-  "../../packages/runtime/dist/plan-execution.js"() {
-    "use strict";
-    init_esm_shims();
-    init_dist2();
-    init_dist6();
-    init_execution_ledger();
-    PlanExecutionManager = class {
-      deps;
-      _lastExecutionManifest = null;
-      _stepStates = /* @__PURE__ */ new Map();
-      /**
-       * Per-step delegation `task_id`, remembered on `step_delegated` so the
+  let taskId;
+  try {
+    const body = {
+      prompt: params.prompt,
+      submitted_by: params.motebitId,
+      target_agent: params.targetWorkerId,
+      settlement_mode: "p2p",
+      // The relay's task-submission handler reads the proof under `payment_proof`
+      // (services/relay/src/tasks.ts) — NOT `p2p_payment_proof` (that's only the
+      // relay's internal TaskQueue field name). Sending the wrong key made the
+      // relay see no proof and reject every paid cross-agent delegation with 402
+      // TASK_P2P_PROOF_REQUIRED. The federation-e2e client↔relay integration test
+      // locks this wire key (the seam that mocked-fetch unit tests can't catch).
+      payment_proof: params.paymentProof
+    };
+    if (params.requiredCapabilities && params.requiredCapabilities.length > 0) {
+      body.required_capabilities = params.requiredCapabilities;
+    }
+    if (params.acknowledgeNoHistoryRisk === true) {
+      body.delegator_acknowledges_no_history_risk = true;
+    }
+    if (params.invocationOrigin) {
+      body.invocation_origin = params.invocationOrigin;
+    }
+    if (params.grantId != null) {
+      body.grant_id = params.grantId;
+    }
+    const resp = await fetch(`${params.syncUrl}/agent/${params.motebitId}/task`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: submitHeader,
+        // Stable across retries of the SAME logical delegation so a re-submit
+        // of the already-paid proof dedupes byte-identically rather than
+        // racing a second task. Keyed on the onchain tx_hash, which uniquely
+        // identifies this payment.
+        "Idempotency-Key": params.paymentProof.tx_hash
+      },
+      body: JSON.stringify(body),
+      signal: params.signal
+    });
+    if (!resp.ok) {
+      const text = await resp.text().catch(() => "");
+      return {
+        ok: false,
+        error: classifyRelayError(resp.status, text, resp.headers.get("Retry-After"))
+      };
+    }
+    const data = await resp.json();
+    taskId = data.task_id;
+  } catch (err2) {
+    if (err2 instanceof Error && err2.name === "AbortError") {
+      return {
+        ok: false,
+        error: { code: "timeout", message: "Aborted before submission completed" }
+      };
+    }
+    return {
+      ok: false,
+      error: {
+        code: "network_unreachable",
+        message: err2 instanceof Error ? err2.message : String(err2)
+      }
+    };
+  }
+  const result = await pollForReceipt({
+    syncUrl: params.syncUrl,
+    motebitId: params.motebitId,
+    taskId,
+    queryHeader,
+    timeoutMs,
+    startedAt,
+    logger: params.logger,
+    ...params.signal ? { signal: params.signal } : {}
+  });
+  if (result.ok) {
+    const proof = params.paymentProof;
+    return {
+      ...result,
+      settlement: {
+        mode: "p2p",
+        txHash: proof.tx_hash,
+        paidMicro: proof.amount_micro,
+        feeMicro: proof.fee_amount_micro + (proof.b_fee_amount_micro ?? 0)
+      }
+    };
+  }
+  return result;
+}
+function hexToBytes7(hex) {
+  const clean2 = hex.startsWith("0x") ? hex.slice(2) : hex;
+  if (clean2.length === 0 || clean2.length % 2 !== 0 || /[^0-9a-fA-F]/.test(clean2)) {
+    throw new Error(`invalid hex: ${hex.slice(0, 16)}\u2026`);
+  }
+  const out = new Uint8Array(clean2.length / 2);
+  for (let i3 = 0; i3 < out.length; i3++) {
+    out[i3] = Number.parseInt(clean2.slice(i3 * 2, i3 * 2 + 2), 16);
+  }
+  return out;
+}
+async function resolveP2pPaymentRequest(params) {
+  const { syncUrl, capability, motebitId } = params;
+  let treasuryAddress;
+  try {
+    treasuryAddress = base58Encode(hexToBytes7(params.relayPublicKeyHex));
+  } catch (err2) {
+    return fail("malformed_request", `Invalid pinned relay public key: ${err2 instanceof Error ? err2.message : String(err2)}`);
+  }
+  let worker;
+  try {
+    const resp = await fetch(`${syncUrl}/api/v1/agents/discover?capability=${encodeURIComponent(capability)}`, { signal: params.signal });
+    if (!resp.ok) {
+      const text = await resp.text().catch(() => "");
+      return {
+        ok: false,
+        error: classifyRelayError(resp.status, text, resp.headers.get("Retry-After"))
+      };
+    }
+    const data = await resp.json();
+    const admissible = (data.agents ?? []).filter((a3) => {
+      if (a3.motebit_id === motebitId || a3.settlement_address == null)
+        return false;
+      if (params.targetWorkerId != null && a3.motebit_id !== params.targetWorkerId)
+        return false;
+      const modes = Array.isArray(a3.settlement_modes) ? a3.settlement_modes : String(a3.settlement_modes ?? "").split(",");
+      return modes.includes("p2p");
+    });
+    let candidate = admissible[0];
+    if (params.targetWorkerId == null && params.selectWorker != null && admissible.length > 1) {
+      const priceFor3 = (a3) => (a3.pricing ?? []).find((p5) => p5.capability === capability)?.unit_cost ?? (a3.pricing ?? [])[0]?.unit_cost ?? void 0;
+      const chosenId = await params.selectWorker(admissible.map((a3) => {
+        const unitCost = priceFor3(a3);
+        return { motebit_id: a3.motebit_id, ...unitCost != null ? { unitCost } : {} };
+      }));
+      if (chosenId != null) {
+        const chosen = admissible.find((a3) => a3.motebit_id === chosenId);
+        if (chosen != null)
+          candidate = chosen;
+      }
+    }
+    if (candidate?.settlement_address == null) {
+      return fail("no_routing", params.targetWorkerId != null ? `Pinned worker "${params.targetWorkerId}" is not P2P-eligible for "${capability}".` : `No P2P-capable worker advertises "${capability}".`);
+    }
+    worker = {
+      motebit_id: candidate.motebit_id,
+      settlement_address: candidate.settlement_address,
+      ...candidate.source_relay_public_key != null ? { sourceRelayPublicKey: candidate.source_relay_public_key } : {},
+      pricing: candidate.pricing ?? null
+    };
+  } catch (err2) {
+    if (err2 instanceof Error && err2.name === "AbortError") {
+      return fail("timeout", "Aborted during discovery");
+    }
+    return fail("network_unreachable", err2 instanceof Error ? err2.message : String(err2));
+  }
+  let paymentRequest;
+  if (worker.sourceRelayPublicKey != null) {
+    let executorTreasuryAddress;
+    try {
+      executorTreasuryAddress = base58Encode(hexToBytes7(worker.sourceRelayPublicKey));
+    } catch (err2) {
+      return fail("malformed_request", `Invalid peer relay public key in discovery: ${err2 instanceof Error ? err2.message : String(err2)}`);
+    }
+    const priced = (worker.pricing ?? []).find((p5) => p5.capability === capability) ?? (worker.pricing ?? [])[0];
+    if (priced?.unit_cost == null || priced.unit_cost <= 0) {
+      return fail("worker_not_payable", `Remote worker has no positive price for "${capability}".`);
+    }
+    const budgetMicro = toMicro(priced.unit_cost);
+    const split2 = computeFederatedFeeSplit(budgetMicro, PLATFORM_FEE_RATE);
+    paymentRequest = {
+      workerAddress: worker.settlement_address,
+      amountMicro: split2.workerNetMicro,
+      treasuryAddress,
+      feeAmountMicro: split2.originFeeMicro,
+      executorTreasuryAddress,
+      executorFeeAmountMicro: split2.executorFeeMicro
+    };
+  } else {
+    let preflightAllowed = false;
+    try {
+      const eligToken = await params.authToken("market:listing");
+      const ackQuery = params.acknowledgeNoHistoryRisk === true ? "?acknowledge_no_history_risk=true" : "";
+      const resp = await fetch(`${syncUrl}/api/v1/agents/${worker.motebit_id}/p2p-eligibility${ackQuery}`, { headers: { Authorization: `Bearer ${eligToken}` }, signal: params.signal });
+      if (resp.ok) {
+        const data = await resp.json();
+        if (data.allowed !== true) {
+          return fail("p2p_ineligible", data.reason ?? "Not P2P-eligible for this worker");
+        }
+        preflightAllowed = true;
+      }
+    } catch (err2) {
+      if (err2 instanceof Error && err2.name === "AbortError") {
+        return fail("timeout", "Aborted during eligibility pre-flight");
+      }
+    }
+    if (!preflightAllowed) {
+      return fail("p2p_ineligible", "P2P eligibility could not be confirmed (pre-flight unavailable) \u2014 refusing to broadcast an unconfirmed payment.");
+    }
+    let unitCost;
+    try {
+      const listingToken = await params.authToken("market:listing");
+      const resp = await fetch(`${syncUrl}/api/v1/agents/${worker.motebit_id}/listing`, {
+        headers: { Authorization: `Bearer ${listingToken}` },
+        signal: params.signal
+      });
+      if (resp.status === 404) {
+        return fail("worker_not_payable", "Worker has no service listing.");
+      }
+      if (!resp.ok) {
+        const text = await resp.text().catch(() => "");
+        return {
+          ok: false,
+          error: classifyRelayError(resp.status, text, resp.headers.get("Retry-After"))
+        };
+      }
+      const data = await resp.json();
+      const entry = (data.pricing ?? []).find((p5) => p5.capability === capability) ?? (data.pricing ?? [])[0];
+      if (entry?.unit_cost == null || entry.unit_cost <= 0) {
+        return fail("worker_not_payable", `Worker has no positive price for "${capability}".`);
+      }
+      unitCost = entry.unit_cost;
+    } catch (err2) {
+      if (err2 instanceof Error && err2.name === "AbortError") {
+        return fail("timeout", "Aborted during pricing");
+      }
+      return fail("network_unreachable", err2 instanceof Error ? err2.message : String(err2));
+    }
+    const amountMicro = toMicro(unitCost);
+    paymentRequest = {
+      workerAddress: worker.settlement_address,
+      amountMicro,
+      treasuryAddress,
+      feeAmountMicro: computeP2pFeeMicro(amountMicro, PLATFORM_FEE_RATE)
+    };
+  }
+  return {
+    ok: true,
+    paymentRequest,
+    workerMotebitId: worker.motebit_id,
+    workerAddress: worker.settlement_address
+  };
+}
+async function resolveAndSubmitP2pDelegation(params) {
+  if (params.buildP2pPayment == null) {
+    return fail("no_sovereign_rail", "Paid direct delegation needs a sovereign wallet rail that can build an atomic payment.");
+  }
+  const resolved = await resolveP2pPaymentRequest({
+    motebitId: params.motebitId,
+    syncUrl: params.syncUrl,
+    authToken: params.authToken,
+    capability: params.capability,
+    relayPublicKeyHex: params.relayPublicKeyHex,
+    ...params.targetWorkerId != null ? { targetWorkerId: params.targetWorkerId } : {},
+    ...params.selectWorker != null ? { selectWorker: params.selectWorker } : {},
+    ...params.acknowledgeNoHistoryRisk === true ? { acknowledgeNoHistoryRisk: true } : {},
+    ...params.signal ? { signal: params.signal } : {}
+  });
+  if (!resolved.ok)
+    return { ok: false, error: resolved.error };
+  let proof;
+  try {
+    proof = await params.buildP2pPayment(resolved.paymentRequest);
+  } catch (err2) {
+    if (err2 instanceof Error && err2.name === "MoneyMeterDeniedError") {
+      const denial = err2.denial;
+      return {
+        ok: false,
+        error: {
+          code: "money_meter_denied",
+          message: err2.message,
+          ...denial != null ? { denial } : {}
+        }
+      };
+    }
+    if (err2 instanceof Error && err2.name === "InsufficientUsdcBalanceError") {
+      return fail("insufficient_balance", err2.message);
+    }
+    return fail("payment_broadcast_failed", `P2P payment failed to broadcast: ${err2 instanceof Error ? err2.message : String(err2)}`);
+  }
+  return submitP2pDelegation({
+    motebitId: params.motebitId,
+    syncUrl: params.syncUrl,
+    authToken: params.authToken,
+    prompt: params.prompt,
+    targetWorkerId: resolved.workerMotebitId,
+    // The relay needs the capability to locate + price a federated worker on its
+    // operator; pinned via the same capability used for discovery.
+    requiredCapabilities: [params.capability],
+    ...params.acknowledgeNoHistoryRisk === true ? { acknowledgeNoHistoryRisk: true } : {},
+    paymentProof: proof,
+    ...params.invocationOrigin ? { invocationOrigin: params.invocationOrigin } : {},
+    ...params.grantId != null ? { grantId: params.grantId } : {},
+    ...params.timeoutMs != null ? { timeoutMs: params.timeoutMs } : {},
+    logger: params.logger,
+    ...params.signal ? { signal: params.signal } : {}
+  });
+}
+async function selectAndRunDelegation(params) {
+  const capability = params.requiredCapabilities?.[0];
+  if (params.targetWorkerId != null) {
+    if (capability == null) {
+      return fail("malformed_request", "A pinned hire requires a capability to discover the worker by.");
+    }
+    if (params.buildP2pPayment == null || params.relayPublicKey == null) {
+      return fail("no_sovereign_rail", "Hiring a specific agent settles peer-to-peer and needs a configured sovereign wallet rail.");
+    }
+  }
+  if (params.buildP2pPayment != null && params.relayPublicKey != null && capability != null) {
+    const p2p = await resolveAndSubmitP2pDelegation({
+      motebitId: params.motebitId,
+      syncUrl: params.syncUrl,
+      authToken: params.authToken,
+      prompt: params.prompt,
+      capability,
+      ...params.targetWorkerId != null ? { targetWorkerId: params.targetWorkerId } : {},
+      relayPublicKeyHex: params.relayPublicKey,
+      buildP2pPayment: params.buildP2pPayment,
+      ...params.acknowledgeNoHistoryRisk === true ? { acknowledgeNoHistoryRisk: true } : {},
+      ...params.invocationOrigin ? { invocationOrigin: params.invocationOrigin } : {},
+      ...params.grantId != null ? { grantId: params.grantId } : {},
+      ...params.timeoutMs != null ? { timeoutMs: params.timeoutMs } : {},
+      logger: params.logger,
+      ...params.signal ? { signal: params.signal } : {}
+    });
+    if (p2p.ok)
+      return p2p;
+    if (params.targetWorkerId != null)
+      return p2p;
+    if (p2p.error.code !== "no_routing" && p2p.error.code !== "worker_not_payable" && p2p.error.code !== "p2p_ineligible") {
+      return p2p;
+    }
+  }
+  return submitAndPollDelegation({
+    motebitId: params.motebitId,
+    syncUrl: params.syncUrl,
+    authToken: params.authToken,
+    prompt: params.prompt,
+    ...params.requiredCapabilities ? { requiredCapabilities: params.requiredCapabilities } : {},
+    ...params.routingStrategy ? { routingStrategy: params.routingStrategy } : {},
+    ...params.invocationOrigin ? { invocationOrigin: params.invocationOrigin } : {},
+    ...params.grantId != null ? { grantId: params.grantId } : {},
+    ...params.timeoutMs != null ? { timeoutMs: params.timeoutMs } : {},
+    logger: params.logger,
+    ...params.signal ? { signal: params.signal } : {}
+  });
+}
+var DEFAULT_TIMEOUT_MS, POLL_INTERVAL_MS, fail;
+var init_relay_delegation = __esm({
+  "../../packages/runtime/dist/relay-delegation.js"() {
+    "use strict";
+    init_esm_shims();
+    init_dist();
+    DEFAULT_TIMEOUT_MS = 12e4;
+    POLL_INTERVAL_MS = 2e3;
+    fail = (code2, message2, status) => ({
+      ok: false,
+      error: status != null ? { code: code2, message: message2, status } : { code: code2, message: message2 }
+    });
+  }
+});
+
+// ../../packages/runtime/dist/secret-redacting-provider.js
+function redactPackForCloudEgress(pack, redact) {
+  let redactedCount = 0;
+  const labels = /* @__PURE__ */ new Set();
+  const apply = (text) => {
+    const r2 = redact(text);
+    redactedCount += r2.redactionCount;
+    for (const l6 of r2.labels)
+      labels.add(l6);
+    return r2.text;
+  };
+  const newPack = {
+    ...pack,
+    user_message: apply(pack.user_message),
+    ...pack.conversation_history !== void 0 ? {
+      conversation_history: pack.conversation_history.map((m3) => m3.role === "user" ? { ...m3, content: apply(m3.content) } : m3)
+    } : {}
+  };
+  return { pack: newPack, redactedCount, labels: [...labels] };
+}
+var SecretRedactingProvider;
+var init_secret_redacting_provider = __esm({
+  "../../packages/runtime/dist/secret-redacting-provider.js"() {
+    "use strict";
+    init_esm_shims();
+    SecretRedactingProvider = class {
+      inner;
+      opts;
+      constructor(inner, opts) {
+        this.inner = inner;
+        this.opts = opts;
+      }
+      /** Redact the outbound pack unless the provider is sovereign (on-device). */
+      packFor(pack) {
+        if (this.opts.isSovereign())
+          return pack;
+        const { pack: redacted, redactedCount, labels } = redactPackForCloudEgress(pack, this.opts.redact);
+        if (redactedCount > 0)
+          this.opts.onRedacted?.({ count: redactedCount, labels });
+        return redacted;
+      }
+      get model() {
+        return this.inner.model;
+      }
+      get temperature() {
+        return this.inner.temperature;
+      }
+      get maxTokens() {
+        return this.inner.maxTokens;
+      }
+      setModel(model) {
+        this.inner.setModel(model);
+      }
+      setTemperature(temperature) {
+        this.inner.setTemperature?.(temperature);
+      }
+      setMaxTokens(maxTokens) {
+        this.inner.setMaxTokens?.(maxTokens);
+      }
+      generate(pack) {
+        return this.inner.generate(this.packFor(pack));
+      }
+      generateStream(pack) {
+        return this.inner.generateStream(this.packFor(pack));
+      }
+      estimateConfidence() {
+        return this.inner.estimateConfidence();
+      }
+      extractMemoryCandidates(response) {
+        return this.inner.extractMemoryCandidates(response);
+      }
+    };
+  }
+});
+
+// ../../packages/runtime/dist/credential-manager.js
+var CredentialManager;
+var init_credential_manager = __esm({
+  "../../packages/runtime/dist/credential-manager.js"() {
+    "use strict";
+    init_esm_shims();
+    init_dist6();
+    CredentialManager = class {
+      deps;
+      _issuedCredentials = [];
+      changeListeners = /* @__PURE__ */ new Set();
+      /** Callback to submit credentials to relay for indexing. Set externally (e.g. by enableInteractiveDelegation). */
+      credentialSubmitter = null;
+      constructor(deps) {
+        this.deps = deps;
+      }
+      /**
+       * Subscribe to credential-set changes (fires after each `persistCredential`).
+       * Returns an unsubscribe function. Used by surfaces that render credentials
+       * as scene objects (satellites) so they don't have to poll.
+       */
+      onChange(fn) {
+        this.changeListeners.add(fn);
+        return () => {
+          this.changeListeners.delete(fn);
+        };
+      }
+      /**
+       * Issue a W3C Verifiable Credential containing this agent's current gradient.
+       * Returns null if no gradient has been computed or no private key is available.
+       */
+      async issueGradientCredential(privateKey, publicKey) {
+        const snapshot = this.deps.gradientStore.latest(this.deps.motebitId);
+        if (!snapshot)
+          return null;
+        return issueGradientCredential(snapshot, privateKey, publicKey);
+      }
+      /**
+       * Return all verifiable credentials issued by this runtime (gradient + trust).
+       * Credentials accumulate in memory; consumers can read and clear as needed.
+       */
+      getIssuedCredentials() {
+        return [...this._issuedCredentials];
+      }
+      /**
+       * Clear the in-memory credential cache (e.g. after persisting or presenting them).
+       */
+      clearIssuedCredentials() {
+        this._issuedCredentials = [];
+      }
+      /** Push a credential to both in-memory cache and persistent store. */
+      persistCredential(vc, subjectMotebitId) {
+        this._issuedCredentials.push(vc);
+        if (this.deps.credentialStore) {
+          try {
+            const credType = vc.type.find((t3) => t3 !== "VerifiableCredential") ?? "VerifiableCredential";
+            this.deps.credentialStore.save({
+              credential_id: crypto.randomUUID(),
+              subject_motebit_id: vc.credentialSubject?.id ?? "",
+              issuer_did: vc.issuer,
+              credential_type: credType,
+              credential_json: JSON.stringify(vc),
+              issued_at: Date.now()
+            });
+          } catch (err2) {
+            this.deps.logger.warn("credential persistence failed", {
+              error: err2 instanceof Error ? err2.message : String(err2)
+            });
+          }
+        }
+        if (this.credentialSubmitter && subjectMotebitId) {
+          this.credentialSubmitter(vc, subjectMotebitId).catch((err2) => {
+            this.deps.logger.warn("credential relay submission failed", {
+              error: err2 instanceof Error ? err2.message : String(err2)
+            });
+          });
+        }
+        for (const listener of this.changeListeners) {
+          try {
+            listener();
+          } catch (err2) {
+            this.deps.logger.warn("credential change listener threw", {
+              error: err2 instanceof Error ? err2.message : String(err2)
+            });
+          }
+        }
+      }
+    };
+  }
+});
+
+// ../../packages/runtime/dist/hardware-attestation-projection.js
+function readLatestHardwareAttestationClaim(store, record) {
+  const candidates = [];
+  const seen = /* @__PURE__ */ new Set();
+  const collect = (subjectKey) => {
+    let rows;
+    try {
+      rows = store.listBySubject(subjectKey);
+    } catch {
+      return;
+    }
+    for (const row of rows) {
+      if (row.credential_type !== TRUST_VC_TYPE)
+        continue;
+      if (seen.has(row.credential_id))
+        continue;
+      seen.add(row.credential_id);
+      candidates.push(row);
+    }
+  };
+  if (record.public_key != null && record.public_key !== "") {
+    try {
+      collect(hexPublicKeyToDidKey(record.public_key));
+    } catch {
+    }
+  }
+  collect(`did:motebit:${record.remote_motebit_id}`);
+  if (candidates.length === 0)
+    return null;
+  candidates.sort((a3, b3) => b3.issued_at - a3.issued_at);
+  for (const row of candidates) {
+    let parsed;
+    try {
+      parsed = JSON.parse(row.credential_json);
+    } catch {
+      continue;
+    }
+    const claim = parsed.credentialSubject?.hardware_attestation;
+    if (claim != null) {
+      return {
+        platform: claim.platform,
+        key_exported: claim.key_exported,
+        score: scoreAttestation(claim)
+      };
+    }
+  }
+  return null;
+}
+var TRUST_VC_TYPE;
+var init_hardware_attestation_projection = __esm({
+  "../../packages/runtime/dist/hardware-attestation-projection.js"() {
+    "use strict";
+    init_esm_shims();
+    init_dist6();
+    init_dist14();
+    TRUST_VC_TYPE = "AgentTrustCredential";
+  }
+});
+
+// ../../packages/runtime/dist/latency-stats-projection.js
+async function readLatencyStats(store, motebitId, record) {
+  let stats;
+  try {
+    stats = await store.getStats(motebitId, record.remote_motebit_id);
+  } catch {
+    return null;
+  }
+  if (stats.sample_count === 0)
+    return null;
+  return {
+    avg_ms: stats.avg_ms,
+    p95_ms: stats.p95_ms,
+    sample_count: stats.sample_count
+  };
+}
+var init_latency_stats_projection = __esm({
+  "../../packages/runtime/dist/latency-stats-projection.js"() {
+    "use strict";
+    init_esm_shims();
+  }
+});
+
+// ../../packages/runtime/dist/plan-execution.js
+var PlanExecutionManager;
+var init_plan_execution = __esm({
+  "../../packages/runtime/dist/plan-execution.js"() {
+    "use strict";
+    init_esm_shims();
+    init_dist2();
+    init_dist6();
+    init_execution_ledger();
+    PlanExecutionManager = class {
+      deps;
+      _lastExecutionManifest = null;
+      _stepStates = /* @__PURE__ */ new Map();
+      /**
+       * Per-step delegation `task_id`, remembered on `step_delegated` so the
        * subsequent terminal event can include it in its payload (spec §3.7).
        * Receivers join the delegation chain payload-directly instead of
        * reconstructing it by scanning sibling events.
@@ -43342,7 +44054,28 @@ var init_operator = __esm({
 });
 
 // ../../packages/runtime/dist/agent-trust.js
-async function bumpTrustFromReceipt(deps, receipt, verified) {
+function resolveTaskCapability(explicit, receipt) {
+  if (explicit != null && explicit !== "" && explicit !== "*")
+    return explicit;
+  const scope = receipt.delegated_scope;
+  if (scope == null || scope === "" || scope === "*")
+    return void 0;
+  const parts = scope.split(",").map((s3) => s3.trim()).filter(Boolean);
+  return parts.length === 1 ? parts[0] : void 0;
+}
+function bumpCapabilityStats(existing, capability, effectiveSuccess, effectiveFailure) {
+  if (capability == null)
+    return existing;
+  const prev = existing?.[capability] ?? { successful_tasks: 0, failed_tasks: 0 };
+  return {
+    ...existing ?? {},
+    [capability]: {
+      successful_tasks: prev.successful_tasks + (effectiveSuccess ? 1 : 0),
+      failed_tasks: prev.failed_tasks + (effectiveFailure ? 1 : 0)
+    }
+  };
+}
+async function bumpTrustFromReceipt(deps, receipt, verified, capability) {
   const { motebitId, agentTrustStore, events, agentGraph, signingKeys, onCredentialIssued, getRemoteHardwareAttestations, hardwareAttestationVerifiers } = deps;
   if (agentTrustStore == null)
     return;
@@ -43364,10 +44097,12 @@ async function bumpTrustFromReceipt(deps, receipt, verified) {
   }
   const effectiveSuccess = taskSucceeded && resultQuality >= 0.2;
   const effectiveFailure = taskFailed || taskSucceeded && resultQuality < 0.2;
+  const taskCapability = resolveTaskCapability(capability, receipt);
   if (existing != null) {
     const alpha = 0.3;
     const prevQuality = existing.avg_quality ?? 1;
     const newQuality = alpha * resultQuality + (1 - alpha) * prevQuality;
+    const nextCapabilityStats = bumpCapabilityStats(existing.capability_stats, taskCapability, effectiveSuccess, effectiveFailure);
     const updated = {
       ...existing,
       last_seen_at: now,
@@ -43375,7 +44110,8 @@ async function bumpTrustFromReceipt(deps, receipt, verified) {
       successful_tasks: (existing.successful_tasks ?? 0) + (effectiveSuccess ? 1 : 0),
       failed_tasks: (existing.failed_tasks ?? 0) + (effectiveFailure ? 1 : 0),
       avg_quality: newQuality,
-      quality_sample_count: (existing.quality_sample_count ?? 0) + 1
+      quality_sample_count: (existing.quality_sample_count ?? 0) + 1,
+      ...nextCapabilityStats != null ? { capability_stats: nextCapabilityStats } : {}
     };
     const newLevel = evaluateTrustTransition(updated);
     if (newLevel != null) {
@@ -43483,6 +44219,7 @@ async function bumpTrustFromReceipt(deps, receipt, verified) {
       }
     }
   } else {
+    const firstCapabilityStats = bumpCapabilityStats(void 0, taskCapability, effectiveSuccess, effectiveFailure);
     const record = {
       motebit_id: motebitId,
       remote_motebit_id: remoteMotebitId,
@@ -43493,7 +44230,8 @@ async function bumpTrustFromReceipt(deps, receipt, verified) {
       successful_tasks: effectiveSuccess ? 1 : 0,
       failed_tasks: effectiveFailure ? 1 : 0,
       avg_quality: resultQuality,
-      quality_sample_count: 1
+      quality_sample_count: 1,
+      ...firstCapabilityStats != null ? { capability_stats: firstCapabilityStats } : {}
     };
     await agentTrustStore.setAgentTrust(record);
     agentGraph.invalidate();
@@ -52745,910 +53483,402 @@ ${snippet}`;
       // --- Layer-3 conversation search ---
       /**
        * BM25 search over every persisted message for this motebit. Used by
-       * the `search_conversations` tool — the Layer-3 transcript retrieval
-       * that complements Layer-1 (memory index) and Layer-2
-       * (`recall_memories` embedding search). Returns ranked hits with
-       * conversation id, timestamp, and a short snippet around the first
-       * matching token.
-       *
-       * Uses only the sync ConversationStoreAdapter surface, so callers
-       * with IDB-backed stores MUST preload message caches (e.g.
-       * `preloadAllMessages` on web) before invoking. The default for
-       * CLI/desktop/mobile with SQLite is sync all the way down and needs
-       * no preload.
-       */
-      searchHistory(query, limit = 5) {
-        const { store } = this.deps;
-        if (store == null)
-          return [];
-        const convos = store.listConversations(this.deps.motebitId);
-        const messages = [];
-        for (const c3 of convos) {
-          const msgs = store.loadMessages(c3.conversationId);
-          for (const m3 of msgs) {
-            if (m3.role !== "user" && m3.role !== "assistant")
-              continue;
-            messages.push({
-              conversationId: c3.conversationId,
-              role: m3.role,
-              content: m3.content,
-              createdAt: m3.createdAt
-            });
-          }
-        }
-        return searchConversationMessages(messages, query, { limit });
-      }
-      /**
-       * Heuristic-title every stored conversation whose title is currently
-       * null or empty. Idempotent: conversations with existing titles are
-       * skipped. Uses only the synchronous store API, so the caller is
-       * responsible for preloading message caches if the adapter is
-       * IDB-backed (web/mobile). Returns the count of conversations
-       * titled.
-       *
-       * Shipped to close out the prior autoTitle regression: conversations
-       * created before the AI-path hang was fixed carry `title: null`
-       * forever. This pass gives them a legible heuristic title on next
-       * app start without round-tripping the AI.
-       */
-      backfillMissingTitles() {
-        const { store } = this.deps;
-        if (store == null)
-          return 0;
-        const convos = store.listConversations(this.deps.motebitId);
-        let fixed = 0;
-        for (const c3 of convos) {
-          if (c3.title != null && c3.title !== "")
-            continue;
-          const messages = store.loadMessages(c3.conversationId);
-          const history = [];
-          for (const m3 of messages) {
-            if (m3.role === "user" || m3.role === "assistant") {
-              history.push({ role: m3.role, content: m3.content });
-            }
-          }
-          const title = deriveHeuristicTitle(history);
-          if (title != null) {
-            store.updateTitle(c3.conversationId, title);
-            fixed += 1;
-          }
-        }
-        return fixed;
-      }
-      // --- Task isolation ---
-      /** Save conversation state for isolated task execution. */
-      saveContext() {
-        return { history: [...this.history], id: this.currentId };
-      }
-      /** Restore conversation state after isolated task execution. */
-      restoreContext(ctx) {
-        this.history = ctx.history;
-        this.currentId = ctx.id;
-      }
-      /** Clear conversation for isolated execution (task context). */
-      clearForTask() {
-        this.history = [];
-        this.currentId = null;
-      }
-      // --- Agentic loop support ---
-      /**
-       * Inject intermediate messages into the live history (e.g. tool call/result
-       * pairs during the agentic loop). These are part of the context window for
-       * continuation turns but are not individually persisted as conversation
-       * messages — only the final user/assistant exchange is persisted via
-       * pushExchange().
-       */
-      injectIntermediateMessages(...messages) {
-        this.history.push(...messages);
-      }
-      /** Return the raw live history reference for continuation turns. */
-      get liveHistory() {
-        return this.history;
-      }
-      // --- Internal helpers ---
-      /** Get stored summary for the current conversation. */
-      getStoredSummary() {
-        const { store } = this.deps;
-        if (this.currentId == null || this.currentId === "" || store == null)
-          return null;
-        return store.getActiveConversation(this.deps.motebitId)?.summary ?? null;
-      }
-      async runSummarization() {
-        const provider = this.deps.getProvider();
-        const { store } = this.deps;
-        if (provider == null || store == null || this.currentId == null || this.currentId === "")
-          return;
-        try {
-          const existingSummary = this.getStoredSummary();
-          const clearedProvider = projectProviderClearance(this.deps.assertSensitivityPermitsAiCall("summarizeConversation"));
-          const summary = await summarizeConversation(this.history, existingSummary, clearedProvider, this.deps.getTaskRouter() ?? void 0);
-          if (summary && this.currentId) {
-            store.updateSummary(this.currentId, summary);
-          }
-        } catch {
-        }
-      }
-    };
-  }
-});
-
-// ../../packages/runtime/dist/gradient-manager.js
-var GradientManager;
-var init_gradient_manager = __esm({
-  "../../packages/runtime/dist/gradient-manager.js"() {
-    "use strict";
-    init_esm_shims();
-    init_dist2();
-    init_gradient();
-    GradientManager = class {
-      deps;
-      _behavioralStats = {
-        turnCount: 0,
-        totalIterations: 0,
-        toolCallsSucceeded: 0,
-        toolCallsBlocked: 0,
-        toolCallsFailed: 0
-      };
-      _precision;
-      _curiosityTargets = [];
-      _lastReflection = null;
-      constructor(deps) {
-        this.deps = deps;
-        this._precision = NEUTRAL_PRECISION;
-      }
-      // --- Bootstrap ---
-      /** Apply accumulated intelligence baseline on startup. */
-      applyStartupBaseline() {
-        const latest = this.deps.gradientStore.latest(this.deps.motebitId);
-        if (latest) {
-          this._precision = computePrecision(latest);
-          this.deps.state.pushUpdate(computeStateBaseline(latest, this._precision));
-        }
-      }
-      // --- Accessors ---
-      /** Get the latest gradient snapshot, or null if none computed yet. */
-      getGradient() {
-        return this.deps.gradientStore.latest(this.deps.motebitId);
-      }
-      /** Get current active inference precision weights. */
-      getPrecision() {
-        return this._precision;
-      }
-      /** Get gradient history (most recent first). */
-      getGradientHistory(limit) {
-        return this.deps.gradientStore.list(this.deps.motebitId, limit);
-      }
-      /** Get gradient-informed market config for delegation routing. */
-      getMarketConfig() {
-        const snapshot = this.deps.gradientStore.latest(this.deps.motebitId);
-        if (!snapshot)
-          return void 0;
-        return gradientToMarketConfig(snapshot);
-      }
-      /** Self-model: the agent narrates its own trajectory from gradient history. */
-      getGradientSummary(limit = 20) {
-        const history = this.deps.gradientStore.list(this.deps.motebitId, limit);
-        return summarizeGradientHistory(history);
-      }
-      /** Return accumulated behavioral stats and reset the accumulator. */
-      getAndResetBehavioralStats() {
-        const stats = { ...this._behavioralStats };
-        this._behavioralStats = {
-          turnCount: 0,
-          totalIterations: 0,
-          toolCallsSucceeded: 0,
-          toolCallsBlocked: 0,
-          toolCallsFailed: 0
-        };
-        return stats;
-      }
-      /** Return the cached reflection from the last session (or null if none). */
-      getLastReflection() {
-        return this._lastReflection;
-      }
-      /** Set the last reflection result (called by reflection lifecycle). */
-      setLastReflection(result) {
-        this._lastReflection = result;
-      }
-      /** Get curiosity targets computed during last housekeeping cycle. */
-      getCuriosityTargets() {
-        return this._curiosityTargets;
-      }
-      /** Set curiosity targets (called from housekeeping). */
-      setCuriosityTargets(targets) {
-        this._curiosityTargets = targets;
-      }
-      /** Reference to the behavioral stats for direct mutation by callers. */
-      get behavioralStats() {
-        return this._behavioralStats;
-      }
-      // --- Computation ---
-      /** Force a gradient computation right now (useful for CLI/debug). */
-      async computeGradientNow() {
-        const { nodes } = await this.deps.memory.exportAll();
-        return this.computeAndStoreGradient(nodes);
-      }
-      async computeAndStoreGradient(allNodes) {
-        const exported = await this.deps.memory.exportAll();
-        const edges = exported.edges;
-        const sevenDaysAgo = Date.now() - 7 * 24 * 60 * 60 * 1e3;
-        const consolidationEvents = await this.deps.events.query({
-          motebit_id: this.deps.motebitId,
-          event_types: [EventType.MemoryConsolidated],
-          after_timestamp: sevenDaysAgo
-        });
-        const previous = this.deps.gradientStore.latest(this.deps.motebitId);
-        const previousGradient = previous ? previous.gradient : null;
-        const retrievalStats = this.deps.memory.getAndResetRetrievalStats();
-        let behavioralStats;
-        if (this.deps.toolAuditSink) {
-          const sinceTs = previous ? previous.timestamp : 0;
-          const auditStats = this.deps.toolAuditSink.queryStatsSince(sinceTs);
-          behavioralStats = {
-            turnCount: auditStats.distinctTurns,
-            // Approximate: each tool call ≈ 1 loop iteration
-            totalIterations: auditStats.totalToolCalls,
-            toolCallsSucceeded: auditStats.succeeded,
-            toolCallsBlocked: auditStats.blocked,
-            toolCallsFailed: auditStats.failed
-          };
-        } else {
-          behavioralStats = this.getAndResetBehavioralStats();
-        }
-        let curiosityPressure;
-        if (this._curiosityTargets.length > 0) {
-          const totalScore = this._curiosityTargets.reduce((sum2, t3) => sum2 + t3.curiosityScore, 0);
-          curiosityPressure = {
-            avgScore: totalScore / this._curiosityTargets.length,
-            count: this._curiosityTargets.length
-          };
-        }
-        const snapshot = computeGradient(this.deps.motebitId, allNodes, edges, consolidationEvents, previousGradient, void 0, retrievalStats, behavioralStats, curiosityPressure);
-        this.deps.gradientStore.save(snapshot);
-        const signingKeys = this.deps.getSigningKeys();
-        if (signingKeys) {
-          try {
-            const vc = await this.deps.issueGradientCredential(signingKeys.privateKey, signingKeys.publicKey);
-            if (vc != null)
-              this.deps.persistCredential(vc);
-          } catch (err2) {
-            this.deps.logger.warn("gradient credential issuance failed", {
-              error: err2 instanceof Error ? err2.message : String(err2)
-            });
-          }
-        }
-        this._precision = computePrecision(snapshot);
-        this.deps.state.pushUpdate(computeStateBaseline(snapshot, this._precision));
-        this.deps.memory.setPrecisionWeights(this._precision.retrievalPrecision);
-        return snapshot;
-      }
-      /**
-       * Lightweight precision refresh from behavioral stats alone.
-       * Patches the latest gradient snapshot's ie/te metrics with current
-       * session stats, recomputes precision, and feeds back into subsystems.
-       * No memory graph I/O — runs synchronously after each turn.
-       */
-      recomputePrecisionFromStats() {
-        const latest = this.deps.gradientStore.latest(this.deps.motebitId);
-        if (!latest)
-          return;
-        const stats = this._behavioralStats;
-        if (stats.turnCount === 0)
-          return;
-        const avgIterations = stats.totalIterations / stats.turnCount;
-        const ie2 = Math.max(0, Math.min(1, 1 - (avgIterations - 1) / 9));
-        const totalToolCalls = stats.toolCallsSucceeded + stats.toolCallsBlocked + stats.toolCallsFailed;
-        const te2 = totalToolCalls > 0 ? stats.toolCallsSucceeded / totalToolCalls : 0.5;
-        const patched = {
-          ...latest,
-          interaction_efficiency: ie2,
-          tool_efficiency: te2,
-          gradient: latest.gradient - 0.12 * latest.interaction_efficiency - 0.1 * latest.tool_efficiency + 0.12 * ie2 + 0.1 * te2
-        };
-        patched.delta = patched.gradient - latest.gradient;
-        this._precision = computePrecision(patched);
-        this.deps.state.pushUpdate(computeStateBaseline(patched, this._precision));
-        this.deps.memory.setPrecisionWeights(this._precision.retrievalPrecision);
-      }
-      // --- Self-Awareness Context ---
-      /** Convert curiosity targets to lightweight hints for the context pack. */
-      buildCuriosityHints() {
-        if (this._curiosityTargets.length === 0)
-          return void 0;
-        const DAY = 864e5;
-        const now = Date.now();
-        return this._curiosityTargets.slice(0, 2).map((t3) => ({
-          content: t3.node.content,
-          daysSinceDiscussed: Math.round((now - t3.node.last_accessed) / DAY)
-        }));
-      }
-      /**
-       * Build self-awareness context: precision posture + self-model narration.
-       *
-       * The precision context tells the creature how to behave (cautious/confident).
-       * The self-model tells the creature what it knows about itself — trajectory,
-       * strengths, weaknesses, memory stats.
-       */
-      buildSelfAwareness() {
-        const parts = [];
-        const posture = buildPrecisionContext(this._precision);
-        if (posture)
-          parts.push(posture);
-        const summary = this.getGradientSummary(10);
-        if (summary.snapshotCount > 0) {
-          const lines = [];
-          lines.push("[Self-Model \u2014 INTERNAL REFERENCE, never discuss mechanics with the user]");
-          lines.push(summary.trajectory);
-          lines.push(summary.overall);
-          if (summary.strengths.length > 0) {
-            lines.push(`Strengths: ${summary.strengths.join("; ")}.`);
-          }
-          if (summary.weaknesses.length > 0) {
-            lines.push(`Weaknesses: ${summary.weaknesses.join("; ")}.`);
-          }
-          const latest = this.deps.gradientStore.latest(this.deps.motebitId);
-          if (latest?.stats) {
-            const s3 = latest.stats;
-            lines.push(`Memory: ${s3.live_nodes} memories (${s3.semantic_count} semantic, ${s3.episodic_count} episodic, ${s3.pinned_count} pinned), ${s3.live_edges} connections.`);
-          }
-          parts.push(lines.join("\n"));
-        }
-        if (this._lastReflection) {
-          const rLines = [];
-          rLines.push("[Last Reflection \u2014 INTERNAL REFERENCE, never discuss mechanics with the user]");
-          if (this._lastReflection.planAdjustments.length > 0) {
-            rLines.push(`Behavioral adjustments: ${this._lastReflection.planAdjustments.join("; ")}.`);
-          }
-          if (this._lastReflection.insights.length > 0) {
-            rLines.push(`Insights: ${this._lastReflection.insights.join("; ")}.`);
-          }
-          if (this._lastReflection.patterns.length > 0) {
-            rLines.push(`Recurring patterns: ${this._lastReflection.patterns.join("; ")}.`);
-          }
-          if (this._lastReflection.selfAssessment) {
-            rLines.push(`Self-assessment: ${this._lastReflection.selfAssessment}`);
+       * the `search_conversations` tool — the Layer-3 transcript retrieval
+       * that complements Layer-1 (memory index) and Layer-2
+       * (`recall_memories` embedding search). Returns ranked hits with
+       * conversation id, timestamp, and a short snippet around the first
+       * matching token.
+       *
+       * Uses only the sync ConversationStoreAdapter surface, so callers
+       * with IDB-backed stores MUST preload message caches (e.g.
+       * `preloadAllMessages` on web) before invoking. The default for
+       * CLI/desktop/mobile with SQLite is sync all the way down and needs
+       * no preload.
+       */
+      searchHistory(query, limit = 5) {
+        const { store } = this.deps;
+        if (store == null)
+          return [];
+        const convos = store.listConversations(this.deps.motebitId);
+        const messages = [];
+        for (const c3 of convos) {
+          const msgs = store.loadMessages(c3.conversationId);
+          for (const m3 of msgs) {
+            if (m3.role !== "user" && m3.role !== "assistant")
+              continue;
+            messages.push({
+              conversationId: c3.conversationId,
+              role: m3.role,
+              content: m3.content,
+              createdAt: m3.createdAt
+            });
           }
-          parts.push(rLines.join("\n"));
         }
-        return parts.join("\n\n");
+        return searchConversationMessages(messages, query, { limit });
       }
-      // --- Reflection state ---
-      /** Restore the last reflection from the event log. */
-      async restoreLastReflection() {
-        try {
-          const events = await this.deps.events.query({
-            motebit_id: this.deps.motebitId,
-            event_types: [EventType.ReflectionCompleted],
-            limit: 1
-          });
-          if (events.length === 0)
-            return;
-          const payload = events[0].payload;
-          const insights = payload.insights;
-          const adjustments = payload.plan_adjustments;
-          const patterns = payload.patterns;
-          const assessment = payload.self_assessment;
-          if (insights || adjustments || patterns || assessment) {
-            this._lastReflection = {
-              insights: insights ?? [],
-              planAdjustments: adjustments ?? [],
-              patterns: patterns ?? [],
-              selfAssessment: assessment ?? ""
-            };
+      /**
+       * Heuristic-title every stored conversation whose title is currently
+       * null or empty. Idempotent: conversations with existing titles are
+       * skipped. Uses only the synchronous store API, so the caller is
+       * responsible for preloading message caches if the adapter is
+       * IDB-backed (web/mobile). Returns the count of conversations
+       * titled.
+       *
+       * Shipped to close out the prior autoTitle regression: conversations
+       * created before the AI-path hang was fixed carry `title: null`
+       * forever. This pass gives them a legible heuristic title on next
+       * app start without round-tripping the AI.
+       */
+      backfillMissingTitles() {
+        const { store } = this.deps;
+        if (store == null)
+          return 0;
+        const convos = store.listConversations(this.deps.motebitId);
+        let fixed = 0;
+        for (const c3 of convos) {
+          if (c3.title != null && c3.title !== "")
+            continue;
+          const messages = store.loadMessages(c3.conversationId);
+          const history = [];
+          for (const m3 of messages) {
+            if (m3.role === "user" || m3.role === "assistant") {
+              history.push({ role: m3.role, content: m3.content });
+            }
+          }
+          const title = deriveHeuristicTitle(history);
+          if (title != null) {
+            store.updateTitle(c3.conversationId, title);
+            fixed += 1;
           }
-        } catch {
         }
+        return fixed;
       }
-    };
-  }
-});
-
-// ../../packages/runtime/dist/relay-delegation.js
-function classifyRelayError(status, body, retryAfterHeader) {
-  const retryAfterSeconds = retryAfterHeader ? Number.parseInt(retryAfterHeader, 10) : void 0;
-  let relayCode;
-  let relayMessage;
-  try {
-    const parsed = JSON.parse(body);
-    relayCode = parsed.code;
-    relayMessage = parsed.error;
-  } catch {
-  }
-  const message2 = relayMessage ?? body.slice(0, 512);
-  if (status === 401) {
-    return { code: "auth_expired", message: message2, status };
-  }
-  if (relayCode === "TASK_P2P_PROOF_REQUIRED") {
-    return { code: "payment_proof_required", message: message2, status };
-  }
-  if (status === 402 || relayCode === "INSUFFICIENT_FUNDS") {
-    return { code: "insufficient_balance", message: message2, status };
-  }
-  if (status === 403) {
-    return { code: "unauthorized", message: message2, status };
-  }
-  if (status === 429) {
-    return {
-      code: "rate_limited",
-      message: message2,
-      status,
-      ...Number.isFinite(retryAfterSeconds) ? { retryAfterSeconds } : {}
-    };
-  }
-  if (status === 400) {
-    return { code: "malformed_request", message: message2, status };
-  }
-  return { code: "unknown", message: message2, status };
-}
-async function submitAndPollDelegation(params) {
-  const timeoutMs = params.timeoutMs ?? DEFAULT_TIMEOUT_MS;
-  const startedAt = Date.now();
-  let submitHeader;
-  let queryHeader;
-  try {
-    const [submitToken, queryToken] = await Promise.all([
-      params.authToken("task:submit"),
-      params.authToken("task:query")
-    ]);
-    submitHeader = `Bearer ${submitToken}`;
-    queryHeader = `Bearer ${queryToken}`;
-  } catch (err2) {
-    return {
-      ok: false,
-      error: {
-        code: "auth_expired",
-        message: `Auth token mint failed: ${err2 instanceof Error ? err2.message : String(err2)}`
-      }
-    };
-  }
-  let taskId;
-  try {
-    const body = {
-      prompt: params.prompt,
-      submitted_by: params.motebitId
-    };
-    if (params.requiredCapabilities && params.requiredCapabilities.length > 0) {
-      body.required_capabilities = params.requiredCapabilities;
-    }
-    if (params.routingStrategy) {
-      body.routing_strategy = params.routingStrategy;
-    }
-    if (params.invocationOrigin) {
-      body.invocation_origin = params.invocationOrigin;
-    }
-    if (params.grantId != null) {
-      body.grant_id = params.grantId;
-    }
-    const resp = await fetch(`${params.syncUrl}/agent/${params.motebitId}/task`, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        Authorization: submitHeader,
-        "Idempotency-Key": crypto.randomUUID()
-      },
-      body: JSON.stringify(body),
-      signal: params.signal
-    });
-    if (!resp.ok) {
-      const text = await resp.text().catch(() => "");
-      return {
-        ok: false,
-        error: classifyRelayError(resp.status, text, resp.headers.get("Retry-After"))
-      };
-    }
-    const data = await resp.json();
-    taskId = data.task_id;
-  } catch (err2) {
-    if (err2 instanceof Error && err2.name === "AbortError") {
-      return {
-        ok: false,
-        error: { code: "timeout", message: "Aborted before submission completed" }
-      };
-    }
-    return {
-      ok: false,
-      error: {
-        code: "network_unreachable",
-        message: err2 instanceof Error ? err2.message : String(err2)
-      }
-    };
-  }
-  const result = await pollForReceipt({
-    syncUrl: params.syncUrl,
-    motebitId: params.motebitId,
-    taskId,
-    queryHeader,
-    timeoutMs,
-    startedAt,
-    logger: params.logger,
-    ...params.signal ? { signal: params.signal } : {}
-  });
-  return result.ok ? { ...result, settlement: { mode: "relay" } } : result;
-}
-async function pollForReceipt(args) {
-  const maxPolls = Math.ceil(args.timeoutMs / POLL_INTERVAL_MS);
-  for (let i3 = 0; i3 < maxPolls; i3++) {
-    if (args.signal?.aborted) {
-      return { ok: false, error: { code: "timeout", message: "Aborted mid-poll" } };
-    }
-    await new Promise((resolve14, reject) => {
-      const t3 = setTimeout(resolve14, POLL_INTERVAL_MS);
-      args.signal?.addEventListener("abort", () => {
-        clearTimeout(t3);
-        reject(new DOMException("Aborted", "AbortError"));
-      }, { once: true });
-    }).catch(() => {
-    });
-    try {
-      const resp = await fetch(`${args.syncUrl}/agent/${args.motebitId}/task/${args.taskId}`, {
-        headers: { Authorization: args.queryHeader },
-        signal: args.signal
-      });
-      if (!resp.ok) {
-        args.logger.warn("delegation poll failed", {
-          taskId: args.taskId,
-          status: resp.status,
-          body: await resp.text().catch(() => "")
-        });
-        continue;
+      // --- Task isolation ---
+      /** Save conversation state for isolated task execution. */
+      saveContext() {
+        return { history: [...this.history], id: this.currentId };
       }
-      const data = await resp.json();
-      if (data.receipt != null) {
-        return { ok: true, receipt: data.receipt, taskId: args.taskId };
+      /** Restore conversation state after isolated task execution. */
+      restoreContext(ctx) {
+        this.history = ctx.history;
+        this.currentId = ctx.id;
       }
-      if (data.task.status === "failed") {
-        return {
-          ok: false,
-          error: { code: "agent_failed", message: "Agent reported failure without a receipt" }
-        };
+      /** Clear conversation for isolated execution (task context). */
+      clearForTask() {
+        this.history = [];
+        this.currentId = null;
       }
-    } catch (err2) {
-      if (err2 instanceof Error && err2.name === "AbortError") {
-        return { ok: false, error: { code: "timeout", message: "Aborted mid-poll" } };
+      // --- Agentic loop support ---
+      /**
+       * Inject intermediate messages into the live history (e.g. tool call/result
+       * pairs during the agentic loop). These are part of the context window for
+       * continuation turns but are not individually persisted as conversation
+       * messages — only the final user/assistant exchange is persisted via
+       * pushExchange().
+       */
+      injectIntermediateMessages(...messages) {
+        this.history.push(...messages);
       }
-    }
-  }
-  const elapsedMs = Date.now() - args.startedAt;
-  return {
-    ok: false,
-    error: { code: "timeout", message: `No receipt within ${Math.round(elapsedMs / 1e3)}s` }
-  };
-}
-async function submitP2pDelegation(params) {
-  const timeoutMs = params.timeoutMs ?? DEFAULT_TIMEOUT_MS;
-  const startedAt = Date.now();
-  let submitHeader;
-  let queryHeader;
-  try {
-    const [submitToken, queryToken] = await Promise.all([
-      params.authToken("task:submit"),
-      params.authToken("task:query")
-    ]);
-    submitHeader = `Bearer ${submitToken}`;
-    queryHeader = `Bearer ${queryToken}`;
-  } catch (err2) {
-    return {
-      ok: false,
-      error: {
-        code: "auth_expired",
-        message: `Auth token mint failed: ${err2 instanceof Error ? err2.message : String(err2)}`
+      /** Return the raw live history reference for continuation turns. */
+      get liveHistory() {
+        return this.history;
       }
-    };
-  }
-  let taskId;
-  try {
-    const body = {
-      prompt: params.prompt,
-      submitted_by: params.motebitId,
-      target_agent: params.targetWorkerId,
-      settlement_mode: "p2p",
-      // The relay's task-submission handler reads the proof under `payment_proof`
-      // (services/relay/src/tasks.ts) — NOT `p2p_payment_proof` (that's only the
-      // relay's internal TaskQueue field name). Sending the wrong key made the
-      // relay see no proof and reject every paid cross-agent delegation with 402
-      // TASK_P2P_PROOF_REQUIRED. The federation-e2e client↔relay integration test
-      // locks this wire key (the seam that mocked-fetch unit tests can't catch).
-      payment_proof: params.paymentProof
-    };
-    if (params.requiredCapabilities && params.requiredCapabilities.length > 0) {
-      body.required_capabilities = params.requiredCapabilities;
-    }
-    if (params.acknowledgeNoHistoryRisk === true) {
-      body.delegator_acknowledges_no_history_risk = true;
-    }
-    if (params.invocationOrigin) {
-      body.invocation_origin = params.invocationOrigin;
-    }
-    if (params.grantId != null) {
-      body.grant_id = params.grantId;
-    }
-    const resp = await fetch(`${params.syncUrl}/agent/${params.motebitId}/task`, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        Authorization: submitHeader,
-        // Stable across retries of the SAME logical delegation so a re-submit
-        // of the already-paid proof dedupes byte-identically rather than
-        // racing a second task. Keyed on the onchain tx_hash, which uniquely
-        // identifies this payment.
-        "Idempotency-Key": params.paymentProof.tx_hash
-      },
-      body: JSON.stringify(body),
-      signal: params.signal
-    });
-    if (!resp.ok) {
-      const text = await resp.text().catch(() => "");
-      return {
-        ok: false,
-        error: classifyRelayError(resp.status, text, resp.headers.get("Retry-After"))
-      };
-    }
-    const data = await resp.json();
-    taskId = data.task_id;
-  } catch (err2) {
-    if (err2 instanceof Error && err2.name === "AbortError") {
-      return {
-        ok: false,
-        error: { code: "timeout", message: "Aborted before submission completed" }
-      };
-    }
-    return {
-      ok: false,
-      error: {
-        code: "network_unreachable",
-        message: err2 instanceof Error ? err2.message : String(err2)
+      // --- Internal helpers ---
+      /** Get stored summary for the current conversation. */
+      getStoredSummary() {
+        const { store } = this.deps;
+        if (this.currentId == null || this.currentId === "" || store == null)
+          return null;
+        return store.getActiveConversation(this.deps.motebitId)?.summary ?? null;
       }
-    };
-  }
-  const result = await pollForReceipt({
-    syncUrl: params.syncUrl,
-    motebitId: params.motebitId,
-    taskId,
-    queryHeader,
-    timeoutMs,
-    startedAt,
-    logger: params.logger,
-    ...params.signal ? { signal: params.signal } : {}
-  });
-  if (result.ok) {
-    const proof = params.paymentProof;
-    return {
-      ...result,
-      settlement: {
-        mode: "p2p",
-        txHash: proof.tx_hash,
-        paidMicro: proof.amount_micro,
-        feeMicro: proof.fee_amount_micro + (proof.b_fee_amount_micro ?? 0)
+      async runSummarization() {
+        const provider = this.deps.getProvider();
+        const { store } = this.deps;
+        if (provider == null || store == null || this.currentId == null || this.currentId === "")
+          return;
+        try {
+          const existingSummary = this.getStoredSummary();
+          const clearedProvider = projectProviderClearance(this.deps.assertSensitivityPermitsAiCall("summarizeConversation"));
+          const summary = await summarizeConversation(this.history, existingSummary, clearedProvider, this.deps.getTaskRouter() ?? void 0);
+          if (summary && this.currentId) {
+            store.updateSummary(this.currentId, summary);
+          }
+        } catch {
+        }
       }
     };
   }
-  return result;
-}
-function hexToBytes7(hex) {
-  const clean2 = hex.startsWith("0x") ? hex.slice(2) : hex;
-  if (clean2.length === 0 || clean2.length % 2 !== 0 || /[^0-9a-fA-F]/.test(clean2)) {
-    throw new Error(`invalid hex: ${hex.slice(0, 16)}\u2026`);
-  }
-  const out = new Uint8Array(clean2.length / 2);
-  for (let i3 = 0; i3 < out.length; i3++) {
-    out[i3] = Number.parseInt(clean2.slice(i3 * 2, i3 * 2 + 2), 16);
-  }
-  return out;
-}
-async function resolveAndSubmitP2pDelegation(params) {
-  const { syncUrl, capability, motebitId } = params;
-  if (params.buildP2pPayment == null) {
-    return fail("no_sovereign_rail", "Paid direct delegation needs a sovereign wallet rail that can build an atomic payment.");
-  }
-  let treasuryAddress;
-  try {
-    treasuryAddress = base58Encode(hexToBytes7(params.relayPublicKeyHex));
-  } catch (err2) {
-    return fail("malformed_request", `Invalid pinned relay public key: ${err2 instanceof Error ? err2.message : String(err2)}`);
-  }
-  let worker;
-  try {
-    const resp = await fetch(`${syncUrl}/api/v1/agents/discover?capability=${encodeURIComponent(capability)}`, { signal: params.signal });
-    if (!resp.ok) {
-      const text = await resp.text().catch(() => "");
-      return {
-        ok: false,
-        error: classifyRelayError(resp.status, text, resp.headers.get("Retry-After"))
-      };
-    }
-    const data = await resp.json();
-    const candidate = (data.agents ?? []).find((a3) => {
-      if (a3.motebit_id === motebitId || a3.settlement_address == null)
-        return false;
-      if (params.targetWorkerId != null && a3.motebit_id !== params.targetWorkerId)
-        return false;
-      const modes = Array.isArray(a3.settlement_modes) ? a3.settlement_modes : String(a3.settlement_modes ?? "").split(",");
-      return modes.includes("p2p");
-    });
-    if (candidate?.settlement_address == null) {
-      return fail("no_routing", params.targetWorkerId != null ? `Pinned worker "${params.targetWorkerId}" is not P2P-eligible for "${capability}".` : `No P2P-capable worker advertises "${capability}".`);
-    }
-    worker = {
-      motebit_id: candidate.motebit_id,
-      settlement_address: candidate.settlement_address,
-      ...candidate.source_relay_public_key != null ? { sourceRelayPublicKey: candidate.source_relay_public_key } : {},
-      pricing: candidate.pricing ?? null
-    };
-  } catch (err2) {
-    if (err2 instanceof Error && err2.name === "AbortError") {
-      return fail("timeout", "Aborted during discovery");
-    }
-    return fail("network_unreachable", err2 instanceof Error ? err2.message : String(err2));
-  }
-  let paymentRequest;
-  if (worker.sourceRelayPublicKey != null) {
-    let executorTreasuryAddress;
-    try {
-      executorTreasuryAddress = base58Encode(hexToBytes7(worker.sourceRelayPublicKey));
-    } catch (err2) {
-      return fail("malformed_request", `Invalid peer relay public key in discovery: ${err2 instanceof Error ? err2.message : String(err2)}`);
-    }
-    const priced = (worker.pricing ?? []).find((p5) => p5.capability === capability) ?? (worker.pricing ?? [])[0];
-    if (priced?.unit_cost == null || priced.unit_cost <= 0) {
-      return fail("worker_not_payable", `Remote worker has no positive price for "${capability}".`);
-    }
-    const budgetMicro = toMicro(priced.unit_cost);
-    const split2 = computeFederatedFeeSplit(budgetMicro, PLATFORM_FEE_RATE);
-    paymentRequest = {
-      workerAddress: worker.settlement_address,
-      amountMicro: split2.workerNetMicro,
-      treasuryAddress,
-      feeAmountMicro: split2.originFeeMicro,
-      executorTreasuryAddress,
-      executorFeeAmountMicro: split2.executorFeeMicro
-    };
-  } else {
-    let preflightAllowed = false;
-    try {
-      const eligToken = await params.authToken("market:listing");
-      const ackQuery = params.acknowledgeNoHistoryRisk === true ? "?acknowledge_no_history_risk=true" : "";
-      const resp = await fetch(`${syncUrl}/api/v1/agents/${worker.motebit_id}/p2p-eligibility${ackQuery}`, { headers: { Authorization: `Bearer ${eligToken}` }, signal: params.signal });
-      if (resp.ok) {
-        const data = await resp.json();
-        if (data.allowed !== true) {
-          return fail("p2p_ineligible", data.reason ?? "Not P2P-eligible for this worker");
+});
+
+// ../../packages/runtime/dist/gradient-manager.js
+var GradientManager;
+var init_gradient_manager = __esm({
+  "../../packages/runtime/dist/gradient-manager.js"() {
+    "use strict";
+    init_esm_shims();
+    init_dist2();
+    init_gradient();
+    GradientManager = class {
+      deps;
+      _behavioralStats = {
+        turnCount: 0,
+        totalIterations: 0,
+        toolCallsSucceeded: 0,
+        toolCallsBlocked: 0,
+        toolCallsFailed: 0
+      };
+      _precision;
+      _curiosityTargets = [];
+      _lastReflection = null;
+      constructor(deps) {
+        this.deps = deps;
+        this._precision = NEUTRAL_PRECISION;
+      }
+      // --- Bootstrap ---
+      /** Apply accumulated intelligence baseline on startup. */
+      applyStartupBaseline() {
+        const latest = this.deps.gradientStore.latest(this.deps.motebitId);
+        if (latest) {
+          this._precision = computePrecision(latest);
+          this.deps.state.pushUpdate(computeStateBaseline(latest, this._precision));
         }
-        preflightAllowed = true;
       }
-    } catch (err2) {
-      if (err2 instanceof Error && err2.name === "AbortError") {
-        return fail("timeout", "Aborted during eligibility pre-flight");
+      // --- Accessors ---
+      /** Get the latest gradient snapshot, or null if none computed yet. */
+      getGradient() {
+        return this.deps.gradientStore.latest(this.deps.motebitId);
       }
-    }
-    if (!preflightAllowed) {
-      return fail("p2p_ineligible", "P2P eligibility could not be confirmed (pre-flight unavailable) \u2014 refusing to broadcast an unconfirmed payment.");
-    }
-    let unitCost;
-    try {
-      const listingToken = await params.authToken("market:listing");
-      const resp = await fetch(`${syncUrl}/api/v1/agents/${worker.motebit_id}/listing`, {
-        headers: { Authorization: `Bearer ${listingToken}` },
-        signal: params.signal
-      });
-      if (resp.status === 404) {
-        return fail("worker_not_payable", "Worker has no service listing.");
+      /** Get current active inference precision weights. */
+      getPrecision() {
+        return this._precision;
       }
-      if (!resp.ok) {
-        const text = await resp.text().catch(() => "");
-        return {
-          ok: false,
-          error: classifyRelayError(resp.status, text, resp.headers.get("Retry-After"))
+      /** Get gradient history (most recent first). */
+      getGradientHistory(limit) {
+        return this.deps.gradientStore.list(this.deps.motebitId, limit);
+      }
+      /** Get gradient-informed market config for delegation routing. */
+      getMarketConfig() {
+        const snapshot = this.deps.gradientStore.latest(this.deps.motebitId);
+        if (!snapshot)
+          return void 0;
+        return gradientToMarketConfig(snapshot);
+      }
+      /** Self-model: the agent narrates its own trajectory from gradient history. */
+      getGradientSummary(limit = 20) {
+        const history = this.deps.gradientStore.list(this.deps.motebitId, limit);
+        return summarizeGradientHistory(history);
+      }
+      /** Return accumulated behavioral stats and reset the accumulator. */
+      getAndResetBehavioralStats() {
+        const stats = { ...this._behavioralStats };
+        this._behavioralStats = {
+          turnCount: 0,
+          totalIterations: 0,
+          toolCallsSucceeded: 0,
+          toolCallsBlocked: 0,
+          toolCallsFailed: 0
         };
+        return stats;
       }
-      const data = await resp.json();
-      const entry = (data.pricing ?? []).find((p5) => p5.capability === capability) ?? (data.pricing ?? [])[0];
-      if (entry?.unit_cost == null || entry.unit_cost <= 0) {
-        return fail("worker_not_payable", `Worker has no positive price for "${capability}".`);
+      /** Return the cached reflection from the last session (or null if none). */
+      getLastReflection() {
+        return this._lastReflection;
       }
-      unitCost = entry.unit_cost;
-    } catch (err2) {
-      if (err2 instanceof Error && err2.name === "AbortError") {
-        return fail("timeout", "Aborted during pricing");
+      /** Set the last reflection result (called by reflection lifecycle). */
+      setLastReflection(result) {
+        this._lastReflection = result;
+      }
+      /** Get curiosity targets computed during last housekeeping cycle. */
+      getCuriosityTargets() {
+        return this._curiosityTargets;
+      }
+      /** Set curiosity targets (called from housekeeping). */
+      setCuriosityTargets(targets) {
+        this._curiosityTargets = targets;
+      }
+      /** Reference to the behavioral stats for direct mutation by callers. */
+      get behavioralStats() {
+        return this._behavioralStats;
+      }
+      // --- Computation ---
+      /** Force a gradient computation right now (useful for CLI/debug). */
+      async computeGradientNow() {
+        const { nodes } = await this.deps.memory.exportAll();
+        return this.computeAndStoreGradient(nodes);
+      }
+      async computeAndStoreGradient(allNodes) {
+        const exported = await this.deps.memory.exportAll();
+        const edges = exported.edges;
+        const sevenDaysAgo = Date.now() - 7 * 24 * 60 * 60 * 1e3;
+        const consolidationEvents = await this.deps.events.query({
+          motebit_id: this.deps.motebitId,
+          event_types: [EventType.MemoryConsolidated],
+          after_timestamp: sevenDaysAgo
+        });
+        const previous = this.deps.gradientStore.latest(this.deps.motebitId);
+        const previousGradient = previous ? previous.gradient : null;
+        const retrievalStats = this.deps.memory.getAndResetRetrievalStats();
+        let behavioralStats;
+        if (this.deps.toolAuditSink) {
+          const sinceTs = previous ? previous.timestamp : 0;
+          const auditStats = this.deps.toolAuditSink.queryStatsSince(sinceTs);
+          behavioralStats = {
+            turnCount: auditStats.distinctTurns,
+            // Approximate: each tool call ≈ 1 loop iteration
+            totalIterations: auditStats.totalToolCalls,
+            toolCallsSucceeded: auditStats.succeeded,
+            toolCallsBlocked: auditStats.blocked,
+            toolCallsFailed: auditStats.failed
+          };
+        } else {
+          behavioralStats = this.getAndResetBehavioralStats();
+        }
+        let curiosityPressure;
+        if (this._curiosityTargets.length > 0) {
+          const totalScore = this._curiosityTargets.reduce((sum2, t3) => sum2 + t3.curiosityScore, 0);
+          curiosityPressure = {
+            avgScore: totalScore / this._curiosityTargets.length,
+            count: this._curiosityTargets.length
+          };
+        }
+        const snapshot = computeGradient(this.deps.motebitId, allNodes, edges, consolidationEvents, previousGradient, void 0, retrievalStats, behavioralStats, curiosityPressure);
+        this.deps.gradientStore.save(snapshot);
+        const signingKeys = this.deps.getSigningKeys();
+        if (signingKeys) {
+          try {
+            const vc = await this.deps.issueGradientCredential(signingKeys.privateKey, signingKeys.publicKey);
+            if (vc != null)
+              this.deps.persistCredential(vc);
+          } catch (err2) {
+            this.deps.logger.warn("gradient credential issuance failed", {
+              error: err2 instanceof Error ? err2.message : String(err2)
+            });
+          }
+        }
+        this._precision = computePrecision(snapshot);
+        this.deps.state.pushUpdate(computeStateBaseline(snapshot, this._precision));
+        this.deps.memory.setPrecisionWeights(this._precision.retrievalPrecision);
+        return snapshot;
+      }
+      /**
+       * Lightweight precision refresh from behavioral stats alone.
+       * Patches the latest gradient snapshot's ie/te metrics with current
+       * session stats, recomputes precision, and feeds back into subsystems.
+       * No memory graph I/O — runs synchronously after each turn.
+       */
+      recomputePrecisionFromStats() {
+        const latest = this.deps.gradientStore.latest(this.deps.motebitId);
+        if (!latest)
+          return;
+        const stats = this._behavioralStats;
+        if (stats.turnCount === 0)
+          return;
+        const avgIterations = stats.totalIterations / stats.turnCount;
+        const ie2 = Math.max(0, Math.min(1, 1 - (avgIterations - 1) / 9));
+        const totalToolCalls = stats.toolCallsSucceeded + stats.toolCallsBlocked + stats.toolCallsFailed;
+        const te2 = totalToolCalls > 0 ? stats.toolCallsSucceeded / totalToolCalls : 0.5;
+        const patched = {
+          ...latest,
+          interaction_efficiency: ie2,
+          tool_efficiency: te2,
+          gradient: latest.gradient - 0.12 * latest.interaction_efficiency - 0.1 * latest.tool_efficiency + 0.12 * ie2 + 0.1 * te2
+        };
+        patched.delta = patched.gradient - latest.gradient;
+        this._precision = computePrecision(patched);
+        this.deps.state.pushUpdate(computeStateBaseline(patched, this._precision));
+        this.deps.memory.setPrecisionWeights(this._precision.retrievalPrecision);
+      }
+      // --- Self-Awareness Context ---
+      /** Convert curiosity targets to lightweight hints for the context pack. */
+      buildCuriosityHints() {
+        if (this._curiosityTargets.length === 0)
+          return void 0;
+        const DAY = 864e5;
+        const now = Date.now();
+        return this._curiosityTargets.slice(0, 2).map((t3) => ({
+          content: t3.node.content,
+          daysSinceDiscussed: Math.round((now - t3.node.last_accessed) / DAY)
+        }));
+      }
+      /**
+       * Build self-awareness context: precision posture + self-model narration.
+       *
+       * The precision context tells the creature how to behave (cautious/confident).
+       * The self-model tells the creature what it knows about itself — trajectory,
+       * strengths, weaknesses, memory stats.
+       */
+      buildSelfAwareness() {
+        const parts = [];
+        const posture = buildPrecisionContext(this._precision);
+        if (posture)
+          parts.push(posture);
+        const summary = this.getGradientSummary(10);
+        if (summary.snapshotCount > 0) {
+          const lines = [];
+          lines.push("[Self-Model \u2014 INTERNAL REFERENCE, never discuss mechanics with the user]");
+          lines.push(summary.trajectory);
+          lines.push(summary.overall);
+          if (summary.strengths.length > 0) {
+            lines.push(`Strengths: ${summary.strengths.join("; ")}.`);
+          }
+          if (summary.weaknesses.length > 0) {
+            lines.push(`Weaknesses: ${summary.weaknesses.join("; ")}.`);
+          }
+          const latest = this.deps.gradientStore.latest(this.deps.motebitId);
+          if (latest?.stats) {
+            const s3 = latest.stats;
+            lines.push(`Memory: ${s3.live_nodes} memories (${s3.semantic_count} semantic, ${s3.episodic_count} episodic, ${s3.pinned_count} pinned), ${s3.live_edges} connections.`);
+          }
+          parts.push(lines.join("\n"));
+        }
+        if (this._lastReflection) {
+          const rLines = [];
+          rLines.push("[Last Reflection \u2014 INTERNAL REFERENCE, never discuss mechanics with the user]");
+          if (this._lastReflection.planAdjustments.length > 0) {
+            rLines.push(`Behavioral adjustments: ${this._lastReflection.planAdjustments.join("; ")}.`);
+          }
+          if (this._lastReflection.insights.length > 0) {
+            rLines.push(`Insights: ${this._lastReflection.insights.join("; ")}.`);
+          }
+          if (this._lastReflection.patterns.length > 0) {
+            rLines.push(`Recurring patterns: ${this._lastReflection.patterns.join("; ")}.`);
+          }
+          if (this._lastReflection.selfAssessment) {
+            rLines.push(`Self-assessment: ${this._lastReflection.selfAssessment}`);
+          }
+          parts.push(rLines.join("\n"));
+        }
+        return parts.join("\n\n");
+      }
+      // --- Reflection state ---
+      /** Restore the last reflection from the event log. */
+      async restoreLastReflection() {
+        try {
+          const events = await this.deps.events.query({
+            motebit_id: this.deps.motebitId,
+            event_types: [EventType.ReflectionCompleted],
+            limit: 1
+          });
+          if (events.length === 0)
+            return;
+          const payload = events[0].payload;
+          const insights = payload.insights;
+          const adjustments = payload.plan_adjustments;
+          const patterns = payload.patterns;
+          const assessment = payload.self_assessment;
+          if (insights || adjustments || patterns || assessment) {
+            this._lastReflection = {
+              insights: insights ?? [],
+              planAdjustments: adjustments ?? [],
+              patterns: patterns ?? [],
+              selfAssessment: assessment ?? ""
+            };
+          }
+        } catch {
+        }
       }
-      return fail("network_unreachable", err2 instanceof Error ? err2.message : String(err2));
-    }
-    const amountMicro = toMicro(unitCost);
-    paymentRequest = {
-      workerAddress: worker.settlement_address,
-      amountMicro,
-      treasuryAddress,
-      feeAmountMicro: computeP2pFeeMicro(amountMicro, PLATFORM_FEE_RATE)
     };
   }
-  let proof;
-  try {
-    proof = await params.buildP2pPayment(paymentRequest);
-  } catch (err2) {
-    if (err2 instanceof Error && err2.name === "InsufficientUsdcBalanceError") {
-      return fail("insufficient_balance", err2.message);
-    }
-    return fail("payment_broadcast_failed", `P2P payment failed to broadcast: ${err2 instanceof Error ? err2.message : String(err2)}`);
-  }
-  return submitP2pDelegation({
-    motebitId,
-    syncUrl,
-    authToken: params.authToken,
-    prompt: params.prompt,
-    targetWorkerId: worker.motebit_id,
-    // The relay needs the capability to locate + price a federated worker on its
-    // operator; pinned via the same capability used for discovery.
-    requiredCapabilities: [capability],
-    ...params.acknowledgeNoHistoryRisk === true ? { acknowledgeNoHistoryRisk: true } : {},
-    paymentProof: proof,
-    ...params.invocationOrigin ? { invocationOrigin: params.invocationOrigin } : {},
-    ...params.grantId != null ? { grantId: params.grantId } : {},
-    ...params.timeoutMs != null ? { timeoutMs: params.timeoutMs } : {},
-    logger: params.logger,
-    ...params.signal ? { signal: params.signal } : {}
-  });
-}
-async function selectAndRunDelegation(params) {
-  const capability = params.requiredCapabilities?.[0];
-  if (params.targetWorkerId != null) {
-    if (capability == null) {
-      return fail("malformed_request", "A pinned hire requires a capability to discover the worker by.");
-    }
-    if (params.buildP2pPayment == null || params.relayPublicKey == null) {
-      return fail("no_sovereign_rail", "Hiring a specific agent settles peer-to-peer and needs a configured sovereign wallet rail.");
-    }
-  }
-  if (params.buildP2pPayment != null && params.relayPublicKey != null && capability != null) {
-    const p2p = await resolveAndSubmitP2pDelegation({
-      motebitId: params.motebitId,
-      syncUrl: params.syncUrl,
-      authToken: params.authToken,
-      prompt: params.prompt,
-      capability,
-      ...params.targetWorkerId != null ? { targetWorkerId: params.targetWorkerId } : {},
-      relayPublicKeyHex: params.relayPublicKey,
-      buildP2pPayment: params.buildP2pPayment,
-      ...params.acknowledgeNoHistoryRisk === true ? { acknowledgeNoHistoryRisk: true } : {},
-      ...params.invocationOrigin ? { invocationOrigin: params.invocationOrigin } : {},
-      ...params.grantId != null ? { grantId: params.grantId } : {},
-      ...params.timeoutMs != null ? { timeoutMs: params.timeoutMs } : {},
-      logger: params.logger,
-      ...params.signal ? { signal: params.signal } : {}
-    });
-    if (p2p.ok)
-      return p2p;
-    if (params.targetWorkerId != null)
-      return p2p;
-    if (p2p.error.code !== "no_routing" && p2p.error.code !== "worker_not_payable" && p2p.error.code !== "p2p_ineligible") {
-      return p2p;
-    }
-  }
-  return submitAndPollDelegation({
-    motebitId: params.motebitId,
-    syncUrl: params.syncUrl,
-    authToken: params.authToken,
-    prompt: params.prompt,
-    ...params.requiredCapabilities ? { requiredCapabilities: params.requiredCapabilities } : {},
-    ...params.routingStrategy ? { routingStrategy: params.routingStrategy } : {},
-    ...params.invocationOrigin ? { invocationOrigin: params.invocationOrigin } : {},
-    ...params.grantId != null ? { grantId: params.grantId } : {},
-    ...params.timeoutMs != null ? { timeoutMs: params.timeoutMs } : {},
-    logger: params.logger,
-    ...params.signal ? { signal: params.signal } : {}
-  });
-}
-var DEFAULT_TIMEOUT_MS, POLL_INTERVAL_MS, fail;
-var init_relay_delegation = __esm({
-  "../../packages/runtime/dist/relay-delegation.js"() {
-    "use strict";
-    init_esm_shims();
-    init_dist();
-    DEFAULT_TIMEOUT_MS = 12e4;
-    POLL_INTERVAL_MS = 2e3;
-    fail = (code2, message2, status) => ({
-      ok: false,
-      error: status != null ? { code: code2, message: message2, status } : { code: code2, message: message2 }
-    });
-  }
 });
 
 // ../../packages/runtime/dist/interactive-delegation.js
@@ -53756,6 +53986,11 @@ var init_interactive_delegation = __esm({
           // medical/financial/secret AND the configured provider is not
           // sovereign.
           outbound: true,
+          // api-tier per the hybrid-engine structural preference. Inline
+          // registration escapes check-tool-modes' literal scan (it only
+          // sweeps exported Definition consts) — tagged here so the registry
+          // sort still prefers it over pixel-tier fallbacks.
+          mode: "api",
           // Risk classification is explicit, never inferred: with a
           // payment rail configured, a paid delegation settles real money
           // onchain (R4_MONEY, irreversible) — the name/description
@@ -53804,13 +54039,78 @@ var init_interactive_delegation = __esm({
           stashReceipt(result.receipt);
           const workerResult = result.receipt.result ?? "Task completed (no result text)";
           const settlementNote = formatSettlementNote(result.settlement);
+          const workerNote = `[delegated_to: ${result.receipt.motebit_id}]`;
+          const footnotes = [workerNote, ...settlementNote ? [settlementNote] : []].join("\n");
           return {
             ok: true,
-            data: settlementNote ? `${workerResult}
+            data: `${workerResult}
 
-${settlementNote}` : workerResult
+${footnotes}`
           };
         });
+        const DISCOVER_TOOL = "discover_agents";
+        if (!this.deps.toolRegistry.has(DISCOVER_TOOL)) {
+          this.deps.toolRegistry.register({
+            name: DISCOVER_TOOL,
+            description: "List the agents discoverable on the connected relay RIGHT NOW \u2014 the live directory read. Use whenever the user asks who is available, what agents exist, what delegation costs, or before choosing a delegation target. Names are self-asserted claims, never verified handles. This is the ONLY source for the current roster; never answer roster questions from memory or self-description.",
+            inputSchema: {
+              type: "object",
+              properties: {
+                capability: {
+                  type: "string",
+                  description: "Optional capability filter (e.g. 'research'). Omit for the full roster."
+                }
+              },
+              required: []
+            },
+            // Same outbound boundary as web_search — a network read that
+            // reveals the question being asked, nothing more. Read-class.
+            outbound: true,
+            mode: "api",
+            riskHint: { risk: RiskLevel.R0_READ, sideEffect: SideEffect.NONE }
+          }, async (args) => {
+            const capability = typeof args.capability === "string" ? args.capability : void 0;
+            try {
+              const token = await config.authToken();
+              const url = new URL(`${config.syncUrl}/api/v1/agents/discover`);
+              if (capability != null && capability.length > 0) {
+                url.searchParams.set("capability", capability);
+              }
+              const resp = await fetch(url.toString(), {
+                headers: { Authorization: `Bearer ${token}` }
+              });
+              if (!resp.ok) {
+                return { ok: false, error: `discover read failed: HTTP ${resp.status}` };
+              }
+              const body = await resp.json();
+              const agents = (body.agents ?? []).map((a3) => ({
+                motebit_id: a3.motebit_id,
+                // A self-asserted CLAIM (agents-as-first-person-trust-graph §3)
+                // — surfaced under that name so the model inherits the framing.
+                ...a3.display_name != null && a3.display_name.length > 0 ? { claimed_name: a3.display_name } : {},
+                ...a3.description != null && a3.description.length > 0 ? { description: a3.description } : {},
+                capabilities: a3.capabilities,
+                ...a3.pricing != null && a3.pricing.length > 0 ? { pricing: a3.pricing } : {},
+                ...a3.freshness != null ? { freshness: a3.freshness } : {},
+                ...a3.trust_level != null ? { trust_level: a3.trust_level } : {},
+                ...a3.settlement_modes != null ? { settlement_modes: a3.settlement_modes } : {}
+              }));
+              return {
+                ok: true,
+                data: JSON.stringify({
+                  roster_source: "live_relay_read",
+                  relay: config.syncUrl,
+                  as_of_ms: Date.now(),
+                  agent_count: agents.length,
+                  agents
+                })
+              };
+            } catch (err2) {
+              const msg = err2 instanceof Error ? err2.message : String(err2);
+              return { ok: false, error: `discover read failed: ${msg}` };
+            }
+          });
+        }
         this.deps.wireLoopDeps();
       }
       /**
@@ -55946,7 +56246,14 @@ var init_agent_task_handler = __esm({
 function slabTurnIdForRun(runId) {
   return `slab-turn-${runId}`;
 }
-var SovereignTierRequiredError, DropTargetGovernanceRequiredError, CONSOLIDATION_TREE_HASH_VERSION, TENDING_ALLOWED_TOOLS, DEFAULT_PROACTIVE_CATCH_UP_MAX_AGE_MS, MotebitRuntime;
+function explorationStrengthForStakes(costUsd) {
+  if (!(costUsd > EXPLORE_STAKES_FLOOR_USD))
+    return 1;
+  if (costUsd >= EXPLORE_STAKES_CEIL_USD)
+    return 0;
+  return 1 - (costUsd - EXPLORE_STAKES_FLOOR_USD) / (EXPLORE_STAKES_CEIL_USD - EXPLORE_STAKES_FLOOR_USD);
+}
+var SovereignTierRequiredError, DropTargetGovernanceRequiredError, CONSOLIDATION_TREE_HASH_VERSION, TENDING_ALLOWED_TOOLS, DEFAULT_PROACTIVE_CATCH_UP_MAX_AGE_MS, EXPLORE_STAKES_FLOOR_USD, EXPLORE_STAKES_CEIL_USD, MotebitRuntime;
 var init_motebit_runtime = __esm({
   "../../packages/runtime/dist/motebit-runtime.js"() {
     "use strict";
@@ -55971,6 +56278,7 @@ var init_motebit_runtime = __esm({
     init_dist11();
     init_money_meter();
     init_grant_verifier();
+    init_relay_delegation();
     init_dist();
     init_dist6();
     init_gradient();
@@ -56048,6 +56356,8 @@ var init_motebit_runtime = __esm({
       "search_conversations"
     ]);
     DEFAULT_PROACTIVE_CATCH_UP_MAX_AGE_MS = 60 * 60 * 1e3;
+    EXPLORE_STAKES_FLOOR_USD = 0.1;
+    EXPLORE_STAKES_CEIL_USD = 1;
     MotebitRuntime = class _MotebitRuntime {
       motebitId;
       state;
@@ -56219,6 +56529,15 @@ var init_motebit_runtime = __esm({
        * `getSolanaAddress`, `getSolanaBalance`, and `sendUsdc`.
        */
       _solanaWallet = null;
+      /**
+       * Relay coordinates for the deterministic granted-spend path
+       * (`executeGrantedDelegation`), stashed when `enableInteractiveDelegation`
+       * is called with a pinned relay key. Null until then — a granted spend with
+       * no coordinates fails closed (`sync_not_enabled`). The pinned hex key is the
+       * treasury trust root; the auth-token minter is the same audience-scoped
+       * minter the AI-loop delegation path uses.
+       */
+      _grantedSpendCoords = null;
       /**
        * Sovereign receipt exchange transport. Null when no transport is
        * configured — in that state, the runtime can still send USDC via
@@ -59019,8 +59338,8 @@ var init_motebit_runtime = __esm({
           hardwareAttestationVerifiers: this._hardwareAttestationVerifiers
         };
       }
-      async bumpTrustFromReceipt(receipt, verified) {
-        return bumpTrustFromReceipt(this.trustDeps, receipt, verified);
+      async bumpTrustFromReceipt(receipt, verified, capability) {
+        return bumpTrustFromReceipt(this.trustDeps, receipt, verified, capability);
       }
       async recordAgentInteraction(remoteMotebitId, publicKey, motebitType) {
         return recordAgentInteraction(this.trustDeps, remoteMotebitId, publicKey, motebitType);
@@ -59338,6 +59657,175 @@ var init_motebit_runtime = __esm({
           ...buildP2pPayment ? { buildP2pPayment } : {},
           getActiveGrantId: () => this._activeTurnGrant?.grant_id ?? null
         });
+        if (config.relayPublicKey != null) {
+          this._grantedSpendCoords = {
+            syncUrl: config.syncUrl,
+            authToken: config.authToken,
+            relayPublicKeyHex: config.relayPublicKey,
+            ...config.acknowledgeNoHistoryRisk != null ? { acknowledgeNoHistoryRisk: config.acknowledgeNoHistoryRisk } : {}
+          };
+        }
+      }
+      /**
+       * Execute a paid sub-delegation autonomously under a signed standing grant —
+       * the DETERMINISTIC (human-absent) money path that a first-party spending
+       * molecule (the Clerk archetype) drives. Unlike the AI loop (whose R4 spend
+       * is authorized by a live human approval or a grant-carrying turn) and
+       * `invokeCapability` (a user tap IS the human authorizer, so it uses the RAW
+       * builder), this path has no human — so it re-composes the FULL R4 AND the
+       * loop enforces, fail-CLOSED:
+       *
+       *   1. serialize under `_isProcessing` — the rail seam trusts `_activeTurnGrant`
+       *      only because turns are single-by-construction;
+       *   2. verify the grant via the SOLE producer `verifyGrantForTurn` — a null
+       *      result (absent / expired / revoked / malformed) REFUSES, no broadcast
+       *      (the exact inverse of the loop's fail-OPEN-to-no-grant, safe there only
+       *      because a live human backstops that path);
+       *   3. re-run the policy gate's scope check (`this.policy.validate` with the
+       *      grant's SIGNED scope) — the meter enforces the ceiling but never scope;
+       *   4. route the broadcast through the meter-wrapped builder
+       *      (`wrapP2pPaymentWithMeter`), NEVER the raw wallet method.
+       *
+       * `dryRun` exercises 1–3 and the blast-radius meter (over-ceiling / replay
+       * refuse with the `BlastRadiusDenial` code) against a THROWAWAY in-memory
+       * store, then stops before any broadcast or submit — so a fake spend cannot
+       * poison the live lifetime ceiling and no funds move (no wallet required).
+       * Refusals carry only the denial CODE; the `spend_overage_micro` residual is
+       * owner-facing and never relayed. Adds zero new authority surface; locked by
+       * the `check-money-authority` deterministic-path assertion.
+       */
+      async executeGrantedDelegation(params) {
+        const coords = this._grantedSpendCoords;
+        if (coords == null)
+          return { ok: false, code: "sync_not_enabled" };
+        const delegateToolDef = this.toolRegistry.get("delegate_to_agent");
+        if (delegateToolDef == null)
+          return { ok: false, code: "sync_not_enabled" };
+        if (this._isProcessing)
+          throw new Error("Already processing a message");
+        this._isProcessing = true;
+        try {
+          const presentedGrant = await verifyGrantForTurn(params.delegation.token, params.delegation.grant, params.delegation.revocations ?? []);
+          if (presentedGrant == null)
+            return { ok: false, code: "requires_verified_grant" };
+          const decision = this.policy.validate(delegateToolDef, { prompt: params.prompt, required_capabilities: [params.capability] }, {
+            ...this.policy.createTurnContext(),
+            verifiedGrant: presentedGrant,
+            delegationScope: params.delegation.grant.scope
+          });
+          if (!decision.allowed)
+            return { ok: false, code: "missing_scope" };
+          this._activeTurnGrant = presentedGrant;
+          const ack = typeof coords.acknowledgeNoHistoryRisk === "function" ? coords.acknowledgeNoHistoryRisk() : coords.acknowledgeNoHistoryRisk;
+          const exploreSeed = params.delegation.token.signature;
+          const selectWorker2 = params.targetWorkerId != null ? void 0 : async (candidates) => {
+            const rankable = await Promise.all(candidates.map(async (c3) => ({
+              motebit_id: c3.motebit_id,
+              trustRecord: await this.getAgentTrust(c3.motebit_id),
+              ...c3.unitCost != null ? { unitCost: c3.unitCost } : {}
+            })));
+            const repCostUsd = Math.min(...rankable.map((r2) => r2.unitCost ?? 0));
+            const strength = explorationStrengthForStakes(repCostUsd);
+            const capability = params.capability;
+            const exploitTop = selectWorker(this.motebitId, rankable, { capability });
+            const winner = selectWorker(this.motebitId, rankable, {
+              capability,
+              explore: { seed: exploreSeed, strength }
+            });
+            if (winner != null) {
+              this._logger.warn("routing.worker_selected", {
+                selected: winner.motebit_id,
+                capability,
+                candidates: rankable.length,
+                strength: Number(strength.toFixed(3)),
+                explored: exploitTop != null && winner.motebit_id !== exploitTop.motebit_id,
+                quality: Number(winner.route.trust.toFixed(3))
+              });
+            }
+            return winner?.motebit_id ?? null;
+          };
+          if (params.dryRun === true) {
+            const resolved = await resolveP2pPaymentRequest({
+              motebitId: this.motebitId,
+              syncUrl: coords.syncUrl,
+              authToken: coords.authToken,
+              capability: params.capability,
+              relayPublicKeyHex: coords.relayPublicKeyHex,
+              ...params.targetWorkerId != null ? { targetWorkerId: params.targetWorkerId } : {},
+              ...selectWorker2 != null ? { selectWorker: selectWorker2 } : {},
+              ...ack === true ? { acknowledgeNoHistoryRisk: true } : {}
+            });
+            if (!resolved.ok)
+              return { ok: false, code: resolved.error.code };
+            const req = resolved.paymentRequest;
+            const totalOutflowMicro = req.amountMicro + req.feeAmountMicro + (req.executorFeeAmountMicro ?? 0);
+            const dryMeter = createMoneyMeter(new InMemoryGrantSpendStore());
+            const verdict = await dryMeter(presentedGrant, "p2p_payment", {
+              amount_micro: totalOutflowMicro,
+              counterparty: resolved.workerAddress
+            });
+            if (!verdict.allowed)
+              return { ok: false, code: verdict.denial ?? "money_meter_denied" };
+            return {
+              ok: true,
+              dryRun: true,
+              settlement: {
+                mode: "p2p",
+                paidMicro: req.amountMicro,
+                feeMicro: req.feeAmountMicro + (req.executorFeeAmountMicro ?? 0)
+              }
+            };
+          }
+          const rawBuild = this._solanaWallet?.buildP2pPayment?.bind(this._solanaWallet);
+          if (rawBuild == null)
+            return { ok: false, code: "no_sovereign_rail" };
+          const buildP2pPayment = wrapP2pPaymentWithMeter(rawBuild, () => this._activeTurnGrant, this.moneyMeter);
+          const result = await resolveAndSubmitP2pDelegation({
+            motebitId: this.motebitId,
+            syncUrl: coords.syncUrl,
+            authToken: coords.authToken,
+            relayPublicKeyHex: coords.relayPublicKeyHex,
+            prompt: params.prompt,
+            capability: params.capability,
+            buildP2pPayment,
+            grantId: presentedGrant.grant_id,
+            invocationOrigin: "agent-to-agent",
+            ...params.targetWorkerId != null ? { targetWorkerId: params.targetWorkerId } : {},
+            ...selectWorker2 != null ? { selectWorker: selectWorker2 } : {},
+            ...ack === true ? { acknowledgeNoHistoryRisk: true } : {},
+            logger: this._logger
+          });
+          if (!result.ok) {
+            const code2 = result.error.code === "money_meter_denied" ? result.error.denial ?? "money_meter_denied" : result.error.code;
+            this._logger.warn("delegation.paid_failed", {
+              code: code2,
+              capability: params.capability,
+              ...result.error.code !== "money_meter_denied" && "message" in result.error ? { message: result.error.message } : {}
+            });
+            return { ok: false, code: code2 };
+          }
+          try {
+            const workerReceipt = result.receipt;
+            if (workerReceipt.public_key != null && workerReceipt.public_key !== "") {
+              const valid = await verifyExecutionReceipt(workerReceipt, hexToBytes5(workerReceipt.public_key));
+              if (valid)
+                await this.bumpTrustFromReceipt(workerReceipt, true, params.capability);
+            }
+          } catch (err2) {
+            this._logger.warn("routing.trust_bump_skipped", {
+              reason: err2 instanceof Error ? err2.message : String(err2)
+            });
+          }
+          return {
+            ok: true,
+            dryRun: false,
+            receipt: result.receipt,
+            ...result.settlement ? { settlement: result.settlement } : {}
+          };
+        } finally {
+          this._activeTurnGrant = null;
+          this._isProcessing = false;
+        }
       }
       /**
        * Drain interactive delegation receipts (used by handleAgentTask to include
@@ -59671,6 +60159,7 @@ __export(dist_exports7, {
   resolveAndSubmitP2pDelegation: () => resolveAndSubmitP2pDelegation,
   resolveAttachedAct: () => resolveAttachedAct,
   resolveAttachedRead: () => resolveAttachedRead,
+  resolveP2pPaymentRequest: () => resolveP2pPaymentRequest,
   resolveProactiveAnchor: () => resolveProactiveAnchor,
   selectAndRunDelegation: () => selectAndRunDelegation,
   slabTurnIdForRun: () => slabTurnIdForRun,
@@ -78657,6 +79146,21 @@ var init_migrations_registry = __esm({
         high_water_nonce INTEGER NOT NULL
       )`
         ]
+      },
+      {
+        version: 42,
+        description: "agent_trust.capability_stats \u2014 per-capability competence counts",
+        statements: [
+          // AgentTrustRecord gained an optional `capability_stats` map: per-capability
+          // successful/failed counts so first-person routing scopes competence to the
+          // capability being hired (docs/doctrine/first-person-worker-routing.md).
+          // The pairwise trust_level (a relationship) stays capability-agnostic; only
+          // the success/fail counts split by capability. Additive nullable JSON column
+          // ({capability: {successful_tasks, failed_tasks}}); NULL ⇒ no per-capability
+          // history yet. Local private state — never on the wire (the .strict()
+          // TrustCredentialSubject carries only the aggregate counts).
+          "ALTER TABLE agent_trust ADD COLUMN capability_stats TEXT"
+        ]
       }
     ];
   }
@@ -79189,7 +79693,30 @@ function rowToGradientSnapshot(row) {
     stats: JSON.parse(row.stats)
   };
 }
+function parseCapabilityStats(raw) {
+  if (raw == null || raw === "")
+    return void 0;
+  try {
+    const parsed = JSON.parse(raw);
+    if (parsed == null || typeof parsed !== "object")
+      return void 0;
+    const out = {};
+    for (const [cap, v2] of Object.entries(parsed)) {
+      if (v2 == null || typeof v2 !== "object")
+        continue;
+      const s3 = v2.successful_tasks;
+      const f6 = v2.failed_tasks;
+      if (typeof s3 === "number" && typeof f6 === "number") {
+        out[cap] = { successful_tasks: s3, failed_tasks: f6 };
+      }
+    }
+    return Object.keys(out).length > 0 ? out : void 0;
+  } catch {
+    return void 0;
+  }
+}
 function rowToAgentTrust(row) {
+  const capabilityStats = parseCapabilityStats(row.capability_stats);
   return {
     motebit_id: row.motebit_id,
     remote_motebit_id: row.remote_motebit_id,
@@ -79201,7 +79728,8 @@ function rowToAgentTrust(row) {
     successful_tasks: row.successful_tasks ?? 0,
     failed_tasks: row.failed_tasks ?? 0,
     notes: row.notes ?? void 0,
-    petname: row.petname ?? void 0
+    petname: row.petname ?? void 0,
+    ...capabilityStats != null ? { capability_stats: capabilityStats } : {}
   };
 }
 function rowToServiceListing(row) {
@@ -80426,8 +80954,8 @@ CREATE INDEX IF NOT EXISTS idx_agent_trust_motebit ON agent_trust (motebit_id);
       constructor(db) {
         this.stmtGet = db.prepare(`SELECT * FROM agent_trust WHERE motebit_id = ? AND remote_motebit_id = ?`);
         this.stmtSet = db.prepare(`INSERT OR REPLACE INTO agent_trust
-       (motebit_id, remote_motebit_id, trust_level, public_key, first_seen_at, last_seen_at, interaction_count, successful_tasks, failed_tasks, notes, petname)
-       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`);
+       (motebit_id, remote_motebit_id, trust_level, public_key, first_seen_at, last_seen_at, interaction_count, successful_tasks, failed_tasks, notes, petname, capability_stats)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`);
         this.stmtList = db.prepare(`SELECT * FROM agent_trust WHERE motebit_id = ? ORDER BY last_seen_at DESC`);
         this.stmtUpdateLevel = db.prepare(`UPDATE agent_trust SET trust_level = ?, last_seen_at = ? WHERE motebit_id = ? AND remote_motebit_id = ?`);
       }
@@ -80438,7 +80966,7 @@ CREATE INDEX IF NOT EXISTS idx_agent_trust_motebit ON agent_trust (motebit_id);
         return rowToAgentTrust(row);
       }
       async setAgentTrust(record) {
-        this.stmtSet.run(record.motebit_id, record.remote_motebit_id, record.trust_level, record.public_key ?? null, record.first_seen_at, record.last_seen_at, record.interaction_count, record.successful_tasks ?? 0, record.failed_tasks ?? 0, record.notes ?? null, record.petname ?? null);
+        this.stmtSet.run(record.motebit_id, record.remote_motebit_id, record.trust_level, record.public_key ?? null, record.first_seen_at, record.last_seen_at, record.interaction_count, record.successful_tasks ?? 0, record.failed_tasks ?? 0, record.notes ?? null, record.petname ?? null, record.capability_stats != null && Object.keys(record.capability_stats).length > 0 ? JSON.stringify(record.capability_stats) : null);
       }
       async listAgentTrust(motebitId) {
         const rows = this.stmtList.all(motebitId);
@@ -84102,7 +84630,10 @@ function createRecallSelfHandler(searchFn) {
       }
       const formatted = hits.map((h5, i3) => `${i3 + 1}. [${h5.source} \xB7 ${h5.title} \xB7 score=${h5.score.toFixed(2)}]
 ${h5.content}`).join("\n\n---\n\n");
-      return { ok: true, data: formatted };
+      const banner = "[SELF_DESCRIPTION \u2014 committed repo corpus: design + intent, not live state. For the current agent roster use discover_agents; for runtime state read the [Now] block.]";
+      return { ok: true, data: `${banner}
+
+${formatted}` };
     } catch (err2) {
       const msg = err2 instanceof Error ? err2.message : String(err2);
       return { ok: false, error: `Interior recall error: ${msg}` };
@@ -87195,7 +87726,7 @@ function finalizeScores(scores, maxCandidates, explorationWeight) {
   }
 }
 function graphRankCandidates(selfId, candidates, requirements, config) {
-  const weights = { ...DEFAULT_WEIGHTS, ...config?.weights };
+  const weights = { ...DEFAULT_WEIGHTS2, ...config?.weights };
   const maxCandidates = config?.maxCandidates ?? 10;
   const explorationWeight = config?.explorationWeight ?? 0;
   const compositeFn = config?.compositeFunction;
@@ -87240,7 +87771,7 @@ function findTrustedRoute(selfId, targetId, candidates, peerEdges) {
   return { trust: result.value, path: result.path };
 }
 function explainedRankCandidates(selfId, candidates, requirements, config) {
-  const weights = { ...DEFAULT_WEIGHTS, ...config?.weights };
+  const weights = { ...DEFAULT_WEIGHTS2, ...config?.weights };
   const maxCandidates = config?.maxCandidates ?? 10;
   const explorationWeight = config?.explorationWeight ?? 0;
   const compositeFn = config?.compositeFunction;
@@ -87328,7 +87859,7 @@ function computePriceEfficiency(candidate, requirements) {
     return 0.7;
   return Math.max(0, 1 - totalCost / requirements.max_budget);
 }
-var DEFAULT_WEIGHTS, weightedSumComposite, lexicographicComposite, ORGANIZATIONAL_TRUST_BASELINE, HARDWARE_ATTESTATION_BOOST, TrustAttestationSemiring;
+var DEFAULT_WEIGHTS2, weightedSumComposite, lexicographicComposite, ORGANIZATIONAL_TRUST_BASELINE, HARDWARE_ATTESTATION_BOOST, TrustAttestationSemiring;
 var init_graph_routing = __esm({
   "../../packages/market/dist/graph-routing.js"() {
     "use strict";
@@ -87337,7 +87868,7 @@ var init_graph_routing = __esm({
     init_dist14();
     init_dist14();
     init_credential_weight();
-    DEFAULT_WEIGHTS = {
+    DEFAULT_WEIGHTS2 = {
       trust: 0.3,
       cost: 0.2,
       latency: 0.15,
@@ -87345,7 +87876,7 @@ var init_graph_routing = __esm({
       regulatory_risk: 0.2
     };
     weightedSumComposite = (_route, scores) => {
-      return scores.trust * DEFAULT_WEIGHTS.trust + scores.costScore * DEFAULT_WEIGHTS.cost + scores.latencyNorm * DEFAULT_WEIGHTS.latency + scores.reliability * DEFAULT_WEIGHTS.reliability + scores.riskScore * DEFAULT_WEIGHTS.regulatory_risk;
+      return scores.trust * DEFAULT_WEIGHTS2.trust + scores.costScore * DEFAULT_WEIGHTS2.cost + scores.latencyNorm * DEFAULT_WEIGHTS2.latency + scores.reliability * DEFAULT_WEIGHTS2.reliability + scores.riskScore * DEFAULT_WEIGHTS2.regulatory_risk;
     };
     lexicographicComposite = (_route, scores) => {
       return scores.trust * 1e6 + scores.reliability * 1e3 + scores.costScore;
@@ -88295,6 +88826,18 @@ async function forwardTaskViaMcp(endpointUrl, taskId, prompt2, agentId, taskQueu
       // the MCP server is ready. 10s was too tight for cold start + TLS + init.
       signal: AbortSignal.timeout(3e4)
     });
+    if (!initResp.ok) {
+      const detail = await initResp.text().catch(() => "");
+      logger43.warn("task.mcp_forward_failed", {
+        correlationId: taskId,
+        agent: agentId,
+        endpoint: mcpEndpoint,
+        step: "initialize",
+        status: initResp.status,
+        detail: detail.slice(0, 200)
+      });
+      return;
+    }
     const sessionId = initResp.headers.get("mcp-session-id");
     if (sessionId)
       mcpHeaders["Mcp-Session-Id"] = sessionId;
@@ -88315,6 +88858,18 @@ async function forwardTaskViaMcp(endpointUrl, taskId, prompt2, agentId, taskQueu
       }),
       signal: AbortSignal.timeout(12e4)
     });
+    if (!taskResp.ok) {
+      const detail = await taskResp.text().catch(() => "");
+      logger43.warn("task.mcp_forward_failed", {
+        correlationId: taskId,
+        agent: agentId,
+        endpoint: mcpEndpoint,
+        step: "tools/call",
+        status: taskResp.status,
+        detail: detail.slice(0, 200)
+      });
+      return;
+    }
     const mcpResult = await parseMcpResponse(taskResp, 2);
     if (mcpResult?.result?.content) {
       const textContent = mcpResult.result.content.find((c3) => c3.type === "text");
@@ -108053,7 +108608,7 @@ function parseTokenPayloadUnsafe(token) {
     return null;
   }
 }
-async function verifySignedTokenForDevice(token, motebitId, identityManager, expectedAudience, blacklistCheck, agentRevokedCheck) {
+async function verifySignedTokenForDevice(token, motebitId, identityManager, expectedAudience, blacklistCheck, agentRevokedCheck, agentKeyLookup) {
   const claims = parseTokenPayloadUnsafe(token);
   if (!claims || claims.mid !== motebitId || !claims.did)
     return false;
@@ -108062,9 +108617,13 @@ async function verifySignedTokenForDevice(token, motebitId, identityManager, exp
   if (blacklistCheck && claims.jti && blacklistCheck(claims.jti, motebitId))
     return false;
   const device = await identityManager.loadDeviceById(claims.did, motebitId);
-  if (!device || !device.public_key)
+  let pubKeyHex = device?.public_key ?? null;
+  if (pubKeyHex === null && agentKeyLookup) {
+    pubKeyHex = agentKeyLookup(motebitId);
+  }
+  if (pubKeyHex === null)
     return false;
-  const pubKeyBytes = hexToBytes5(device.public_key);
+  const pubKeyBytes = hexToBytes5(pubKeyHex);
   const payload = await verifySignedToken(token, pubKeyBytes);
   if (payload === null || payload.mid !== motebitId)
     return false;
@@ -114141,12 +114700,15 @@ function extractMotebitIdFromPath(path19) {
   const match = path19.match(/\/agent\/([^/]+)\/task/);
   return match ? match[1] : null;
 }
-function getListingUnitCost(moteDb, agentId) {
+function getListingUnitCost(moteDb, agentId, capability) {
   const row = moteDb.db.prepare("SELECT pricing FROM relay_service_listings WHERE motebit_id = ? ORDER BY updated_at DESC LIMIT 1").get(agentId);
   if (!row)
     return 0;
   try {
     const pricing = JSON.parse(row.pricing);
+    if (capability != null) {
+      return pricing.find((p5) => p5.capability === capability)?.unit_cost ?? 0;
+    }
     return pricing.reduce((sum2, p5) => sum2 + (p5.unit_cost ?? 0), 0);
   } catch {
     return 0;
@@ -114423,6 +114985,52 @@ async function handleReceiptIngestion(receipt, taskId, motebitId, entry, deps) {
           }
           return;
         }
+        if (subEntry.settlement_mode === "p2p") {
+          const subP2pProof = subEntry.p2p_payment_proof;
+          const subWorkerAmount = subP2pProof?.amount_micro ?? 0;
+          const subIsFederatedExecutor = subEntry.origin_relay != null;
+          const subFeeAmount = subIsFederatedExecutor ? subP2pProof?.b_fee_amount_micro ?? 0 : subP2pProof?.fee_amount_micro ?? 0;
+          const subP2pGross = subWorkerAmount + subFeeAmount;
+          const subP2pFeeRate = subP2pGross > 0 ? Math.round(subFeeAmount / subP2pGross * 1e4) / 1e4 : 0;
+          const subP2pSettlementId = crypto.randomUUID();
+          const subP2pSettledAt = Date.now();
+          const signedSubP2p = await signSettlement({
+            settlement_id: subP2pSettlementId,
+            allocation_id: `p2p-${subRelayTaskId}`,
+            // Payee = the sub-agent that executed and was paid onchain.
+            motebit_id: sub.motebit_id,
+            receipt_hash: sub.result_hash ?? "",
+            ledger_hash: null,
+            amount_settled: subWorkerAmount,
+            platform_fee: subFeeAmount,
+            platform_fee_rate: subP2pFeeRate,
+            // Lane in the signed body — the relay's custody posture is
+            // committed-to, not derivable.
+            settlement_mode: "p2p",
+            status: "completed",
+            settled_at: subP2pSettledAt,
+            issuer_relay_id: relayIdentity.relayMotebitId
+          }, relayIdentity.privateKey);
+          moteDb.db.prepare(`INSERT OR IGNORE INTO relay_settlements
+               (settlement_id, allocation_id, task_id, motebit_id, receipt_hash,
+                amount_settled, platform_fee, platform_fee_rate, status, settled_at,
+                settlement_mode, p2p_tx_hash, payment_verification_status, delegator_id,
+                issuer_relay_id, suite, signature, record_json)
+               VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(subP2pSettlementId, `p2p-${subRelayTaskId}`, subRelayTaskId, sub.motebit_id, sub.result_hash ?? "", subWorkerAmount, subFeeAmount, subP2pFeeRate, "completed", subP2pSettledAt, "p2p", subP2pProof?.tx_hash ?? null, "pending", subEntry.submitted_by ?? null, signedSubP2p.issuer_relay_id, signedSubP2p.suite, signedSubP2p.signature, canonicalJson(signedSubP2p));
+          logger33.info("multihop.settlement.p2p_recorded", {
+            correlationId: parentTaskId,
+            subTaskId: subRelayTaskId,
+            subAgent: sub.motebit_id,
+            net: subWorkerAmount,
+            fee: subFeeAmount,
+            depth
+          });
+          const nestedReceipts2 = sub.delegation_receipts ?? [];
+          for (const nested of nestedReceipts2) {
+            await settleSubReceipt(nested, parentTaskId, depth + 1);
+          }
+          return;
+        }
         logger33.error("multihop.settlement.relay_residual_fired", {
           correlationId: parentTaskId,
           subTaskId: subRelayTaskId,
@@ -115041,7 +115649,10 @@ async function registerTaskRoutes(deps) {
     };
     const callerMotebitId = c3.get("callerMotebitId");
     const submittedBy = callerMotebitId ?? body.submitted_by;
-    const unitCostAtSubmission = getListingUnitCost(moteDb, motebitId);
+    const isP2pProofSubmission = typeof body.target_agent === "string" && body.target_agent.length > 0;
+    const pricingAgent = isP2pProofSubmission ? body.target_agent : motebitId;
+    const pricingCapability = isP2pProofSubmission && Array.isArray(body.required_capabilities) && body.required_capabilities.length === 1 ? String(body.required_capabilities[0]) : void 0;
+    const unitCostAtSubmission = getListingUnitCost(moteDb, pricingAgent, pricingCapability);
     const priceSnapshot = unitCostAtSubmission > 0 ? toMicro(computeGrossAmount(unitCostAtSubmission, platformFeeRate)) : void 0;
     const x402TxHash = lastSettleTxHash;
     const x402Net = lastSettleNetwork;
@@ -115100,7 +115711,14 @@ async function registerTaskRoutes(deps) {
         }
         const unitCostMicro = unitCostAtSubmission > 0 ? toMicro(unitCostAtSubmission) : void 0;
         if (unitCostMicro != null && proof.amount_micro !== unitCostMicro) {
-          throw new TaskError("TASK_P2P_AMOUNT_MISMATCH", `Payment amount ${proof.amount_micro} does not match expected ${priceSnapshot}`, 400);
+          throw new TaskError(
+            "TASK_P2P_AMOUNT_MISMATCH",
+            // Report the NET worker-leg amount the check actually compares against
+            // (`unitCostMicro`), not the gross `priceSnapshot` — the earlier
+            // message showed the gross and misled the diagnosis.
+            `Payment worker-leg amount ${proof.amount_micro} does not match expected ${unitCostMicro} for capability "${pricingCapability ?? "?"}"`,
+            400
+          );
         }
         if (unitCostMicro != null && platformFeeRate > 0) {
           const expectedFeeMicro = computeP2pFeeMicro(unitCostMicro, platformFeeRate);
@@ -115247,7 +115865,54 @@ async function registerTaskRoutes(deps) {
     let routed = false;
     let federationAttempted = false;
     let routingChoice;
-    if (requiredCaps.length > 0) {
+    let pinnedLocalHandled = false;
+    if (settlementMode === "p2p" && body.target_agent != null && !federatedP2pIntent) {
+      pinnedLocalHandled = true;
+      const pinnedId = body.target_agent;
+      routingChoice = {
+        selected_agent: pinnedId,
+        composite_score: 1,
+        sub_scores: { pinned: 1 },
+        routing_paths: [[pinnedId]],
+        alternatives_considered: 0
+      };
+      const pinnedPeers = connections.get(pinnedId);
+      if (pinnedPeers && pinnedPeers.length > 0) {
+        for (const peer of pinnedPeers) {
+          peer.ws.send(payload);
+        }
+        routed = true;
+        logger33.info("task.p2p_pinned_dispatched", {
+          correlationId: taskId,
+          worker: pinnedId,
+          via: "websocket"
+        });
+      } else {
+        const pinnedReg = moteDb.db.prepare("SELECT endpoint_url FROM agent_registry WHERE motebit_id = ? AND expires_at > ?").get(pinnedId, Date.now());
+        if (pinnedReg?.endpoint_url?.trim()) {
+          void forwardTaskViaMcp(pinnedReg.endpoint_url, taskId, body.prompt, pinnedId, taskQueue, logger33, apiToken, async (receiptCandidate) => {
+            const mcpEntry = taskQueue.get(taskId);
+            if (!mcpEntry || mcpEntry.settled)
+              return;
+            await handleReceiptIngestion(receiptCandidate, taskId, mcpEntry.task.motebit_id, mcpEntry, ingestionDeps);
+          });
+          routed = true;
+          logger33.info("task.p2p_pinned_dispatched", {
+            correlationId: taskId,
+            worker: pinnedId,
+            via: "mcp",
+            endpoint: pinnedReg.endpoint_url
+          });
+        } else {
+          logger33.error("task.p2p_pinned_unroutable", {
+            correlationId: taskId,
+            worker: pinnedId,
+            reason: "no WebSocket connection and no registered endpoint_url"
+          });
+        }
+      }
+    }
+    if (!pinnedLocalHandled && requiredCaps.length > 0) {
       try {
         const { profiles, requirements } = taskRouter.buildCandidateProfiles(requiredCaps[0], void 0, 20, callerMotebitId);
         const multiCapProfiles = requiredCaps.length > 1 ? profiles.filter((p5) => requiredCaps.every((cap) => p5.listing?.capabilities.includes(cap))) : profiles;
@@ -115485,6 +116150,12 @@ async function registerTaskRoutes(deps) {
                     });
                   } else {
                     taskRouter.recordPeerForwardResult(peerEndpoint, false);
+                    logger33.warn("task.forward_rejected", {
+                      correlationId: taskId,
+                      peerRelay: peerEndpoint,
+                      targetAgent: selId,
+                      status: resp.status
+                    });
                   }
                 } catch (fwdErr) {
                   taskRouter.recordPeerForwardResult(peerEndpoint, false);
@@ -115523,7 +116194,7 @@ async function registerTaskRoutes(deps) {
           throw err2;
       }
     }
-    if (!routed && !federationAttempted) {
+    if (!pinnedLocalHandled && !routed && !federationAttempted) {
       const peers = connections.get(motebitId);
       if (peers) {
         for (const peer of peers) {
@@ -115537,7 +116208,7 @@ async function registerTaskRoutes(deps) {
         }
       }
     }
-    if (!routed && !federationAttempted && requiredCaps.length > 0) {
+    if (!pinnedLocalHandled && !routed && !federationAttempted && requiredCaps.length > 0) {
       const now2 = Date.now();
       const capFilter = requiredCaps[0];
       const httpCandidate = moteDb.db.prepare(`SELECT r.motebit_id, r.endpoint_url FROM agent_registry r
@@ -115554,7 +116225,7 @@ async function registerTaskRoutes(deps) {
         routed = true;
       }
     }
-    if (!routed && !federationAttempted && pushAdapter) {
+    if (!pinnedLocalHandled && !routed && !federationAttempted && pushAdapter) {
       void attemptPushWake(motebitId, { pushAdapter, db: moteDb.db });
     }
     const responseBody = {
@@ -116592,6 +117263,11 @@ async function createSyncRelay(config) {
       return acc;
     }, {})
   });
+  const agentRegistryKeyLookup = (mid) => {
+    const row = moteDb.db.prepare("SELECT public_key FROM agent_registry WHERE motebit_id = ?").get(mid);
+    return row?.public_key ?? null;
+  };
+  const verifySignedTokenForDeviceWithFallback = (token, mid, im, aud, blacklistCheck, agentRevokedCheck, agentKeyLookup) => verifySignedTokenForDevice(token, mid, im, aud, blacklistCheck, agentRevokedCheck, agentKeyLookup ?? agentRegistryKeyLookup);
   const { allLimiters, wsLimiter } = registerMiddleware({
     app,
     apiToken,
@@ -116602,7 +117278,7 @@ async function createSyncRelay(config) {
     getFreezeReason,
     isTokenBlacklisted,
     isAgentRevoked,
-    verifySignedTokenForDevice,
+    verifySignedTokenForDevice: verifySignedTokenForDeviceWithFallback,
     parseTokenPayloadUnsafe,
     getShuttingDown: config.getShuttingDown,
     getConnectionCount: () => getConnectionCount(),
@@ -116685,7 +117361,7 @@ async function createSyncRelay(config) {
     wsLimiter,
     isTokenBlacklisted,
     isAgentRevoked,
-    verifySignedTokenForDevice,
+    verifySignedTokenForDevice: verifySignedTokenForDeviceWithFallback,
     parseTokenPayloadUnsafe,
     logger: logger43,
     onCommandResponse: handleCommandResponse,
@@ -116696,7 +117372,7 @@ async function createSyncRelay(config) {
     apiToken,
     identityManager,
     parseTokenPayloadUnsafe,
-    verifySignedTokenForDevice,
+    verifySignedTokenForDevice: verifySignedTokenForDeviceWithFallback,
     isTokenBlacklisted,
     isAgentRevoked
   });
@@ -116712,7 +117388,7 @@ async function createSyncRelay(config) {
     getFreezeReason,
     isTokenBlacklisted,
     isAgentRevoked,
-    verifySignedTokenForDevice,
+    verifySignedTokenForDevice: verifySignedTokenForDeviceWithFallback,
     parseTokenPayloadUnsafe
   });
   const federationCallbacks = createFederationCallbacks({
@@ -116920,7 +117596,7 @@ async function createSyncRelay(config) {
     apiToken,
     identityManager,
     parseTokenPayloadUnsafe,
-    verifySignedTokenForDevice,
+    verifySignedTokenForDevice: verifySignedTokenForDeviceWithFallback,
     isTokenBlacklisted,
     isAgentRevoked
   });
@@ -116984,7 +117660,7 @@ async function createSyncRelay(config) {
     federationConfig,
     federationQueryCache,
     parseTokenPayloadUnsafe,
-    verifySignedTokenForDevice,
+    verifySignedTokenForDevice: verifySignedTokenForDeviceWithFallback,
     isTokenBlacklisted,
     isAgentRevoked
   });
@@ -117182,7 +117858,7 @@ async function createSyncRelay(config) {
     maxTasksPerSubmitter: MAX_TASKS_PER_SUBMITTER,
     x402Config,
     parseTokenPayloadUnsafe,
-    verifySignedTokenForDevice,
+    verifySignedTokenForDevice: verifySignedTokenForDeviceWithFallback,
     isTokenBlacklisted,
     isAgentRevoked,
     platformFeeRate,