@algosuite/vo-mcp 0.2.0-beta.49 → 0.2.0-beta.50

package/dist/runner-cli.js

@@ -1138,28 +1138,28 @@ async function assertManagedRoot(rootPath, worktreeRoot, fsApi) {
     throw new Error(`[vo-mcp runner] dependency cleanup refused outside the task root: ${rootPath}`);
   }
   if (!await pathExists(rootPath, fsApi)) return false;
-  const stat2 = await fsApi.lstat(rootPath);
-  if (stat2.isSymbolicLink()) {
+  const stat3 = await fsApi.lstat(rootPath);
+  if (stat3.isSymbolicLink()) {
     throw new Error(`[vo-mcp runner] dependency cleanup refused symbolic ownership root: ${rootPath}`);
   }
-  if (!stat2.isDirectory()) {
+  if (!stat3.isDirectory()) {
     throw new Error(`[vo-mcp runner] dependency cleanup refused non-directory ownership root: ${rootPath}`);
   }
   return true;
 }
-async function removeReparsePoint(target, stat2, fsApi) {
+async function removeReparsePoint(target, stat3, fsApi) {
   try {
-    if (stat2.isDirectory()) {
+    if (stat3.isDirectory()) {
       await fsApi.rmdir(target);
       return;
     }
     await fsApi.unlink(target);
   } catch (error) {
-    if (stat2.isDirectory() && ["ENOTDIR", "EPERM", "EISDIR", "EACCES"].includes(error?.code)) {
+    if (stat3.isDirectory() && ["ENOTDIR", "EPERM", "EISDIR", "EACCES"].includes(error?.code)) {
       await fsApi.unlink(target);
       return;
     }
-    if (!stat2.isDirectory() && ["EPERM", "EISDIR", "EACCES"].includes(error?.code)) {
+    if (!stat3.isDirectory() && ["EPERM", "EISDIR", "EACCES"].includes(error?.code)) {
       await fsApi.rmdir(target);
       return;
     }
@@ -1187,17 +1187,17 @@ async function walkManagedRoots(ownership, options, onLink) {
       for (const entry of await fsApi.readdir(current, { withFileTypes: true })) {
         if (entry.name === ".git") continue;
         const child = path.join(current, entry.name);
-        const stat2 = await fsApi.lstat(child);
+        const stat3 = await fsApi.lstat(child);
         scannedEntries += 1;
         if (scannedEntries > scanLimit) {
           throw new Error(`[vo-mcp runner] dependency cleanup scan limit exceeded inside ${rootPath}`);
         }
         await maybeYield(yieldState);
-        if (stat2.isSymbolicLink()) {
-          await onLink(child, stat2, normalized, fsApi);
+        if (stat3.isSymbolicLink()) {
+          await onLink(child, stat3, normalized, fsApi);
           continue;
         }
-        if (stat2.isDirectory()) {
+        if (stat3.isDirectory()) {
           stack.push(child);
         }
       }
@@ -1236,8 +1236,8 @@ function snapshotDependencyOwnership(ownership) {
 }
 async function detachDependencyLinks(ownership, options = {}) {
   let removedLinks = 0;
-  const result = await walkManagedRoots(ownership, options, async (target, stat2, _normalized, fsApi) => {
-    await removeReparsePoint(target, stat2, fsApi);
+  const result = await walkManagedRoots(ownership, options, async (target, stat3, _normalized, fsApi) => {
+    await removeReparsePoint(target, stat3, fsApi);
     removedLinks += 1;
   });
   return { ...result, removedLinks };
@@ -1671,8 +1671,8 @@ async function inspectCanonicalNodeModulesHealth({
   if (!await pathExists3(nodeModulesDir, fsApi)) {
     issues.push(`missing root node_modules: ${nodeModulesDir}`);
   } else {
-    const stat2 = await fsApi.lstat(nodeModulesDir);
-    if (stat2.isSymbolicLink() || !stat2.isDirectory()) {
+    const stat3 = await fsApi.lstat(nodeModulesDir);
+    if (stat3.isSymbolicLink() || !stat3.isDirectory()) {
       issues.push(`root node_modules must be a real directory: ${nodeModulesDir}`);
     }
   }
@@ -1695,8 +1695,8 @@ async function inspectCanonicalNodeModulesHealth({
       issues.push(`missing workspace node_modules: ${workspaceNodeModules}`);
       continue;
     }
-    const stat2 = await fsApi.lstat(workspaceNodeModules);
-    if (stat2.isSymbolicLink() || !stat2.isDirectory()) {
+    const stat3 = await fsApi.lstat(workspaceNodeModules);
+    if (stat3.isSymbolicLink() || !stat3.isDirectory()) {
       issues.push(`workspace node_modules must be a real directory: ${workspaceNodeModules}`);
     }
   }
@@ -1936,12 +1936,12 @@ async function copyDirRecursive(sourceDir, targetDir, fsApi, yieldState) {
 }
 async function materializeEntry(sourceEntry, targetEntry, canonicalRoot, worktreeRoot, options) {
   await options.beforeEntry?.(sourceEntry, targetEntry);
-  const stat2 = await options.fsApi.lstat(sourceEntry);
-  if (stat2.isDirectory() && !stat2.isSymbolicLink() && path4.basename(sourceEntry) === ".bin") {
+  const stat3 = await options.fsApi.lstat(sourceEntry);
+  if (stat3.isDirectory() && !stat3.isSymbolicLink() && path4.basename(sourceEntry) === ".bin") {
     await copyDirRecursive(sourceEntry, targetEntry, options.fsApi, options.yieldState);
     return;
   }
-  if (stat2.isDirectory() && !stat2.isSymbolicLink() && path4.basename(sourceEntry).startsWith("@")) {
+  if (stat3.isDirectory() && !stat3.isSymbolicLink() && path4.basename(sourceEntry).startsWith("@")) {
     await options.fsApi.mkdir(targetEntry, { recursive: true });
     for (const nested of await options.fsApi.readdir(sourceEntry, { withFileTypes: true })) {
       await maybeYield2(options.yieldState);
@@ -1955,7 +1955,7 @@ async function materializeEntry(sourceEntry, targetEntry, canonicalRoot, worktre
     }
     return;
   }
-  if (stat2.isSymbolicLink() || stat2.isDirectory()) {
+  if (stat3.isSymbolicLink() || stat3.isDirectory()) {
     const resolvedTarget = await resolveEntryTarget(sourceEntry, canonicalRoot, worktreeRoot, options.fsApi);
     await ensureLinkedDirectory(resolvedTarget, targetEntry, options.fsApi);
     return;
@@ -2660,12 +2660,12 @@ async function recoverManagedCanonicalResidue(root, options = {}) {
   const symlinks = [];
   for (const relative of paths.untracked) {
     const source = canonicalPath(root, relative);
-    const stat2 = await fsp7.lstat(source);
-    if (stat2.isSymbolicLink()) {
+    const stat3 = await fsp7.lstat(source);
+    if (stat3.isSymbolicLink()) {
       symlinks.push({ path: relative, target: await fsp7.readlink(source) });
       continue;
     }
-    if (!stat2.isFile()) {
+    if (!stat3.isFile()) {
       throw new Error(`canonical recovery refuses unsupported untracked entry: ${relative}`);
     }
     const target = canonicalPath(path8.join(quarantineDir, "untracked"), relative);
@@ -3482,6 +3482,60 @@ var init_control_plane_merge = __esm({
   }
 });
 
+// ../../scripts/virtual-office/code-runner/control-plane-weekly-tokens.mjs
+async function postWeeklyTokensRequest(taskReq, { operatorId, runnerId, tokens, claudeWeeklyPct, claudeWeeklyResetsAt }, onUnauthorized = () => {
+}) {
+  const body = {
+    operator_id: operatorId,
+    runner_id: runnerId,
+    input_tokens: tokens.input_tokens,
+    output_tokens: tokens.output_tokens,
+    cache_creation_tokens: tokens.cache_creation_tokens,
+    cache_read_tokens: tokens.cache_read_tokens
+  };
+  if (typeof claudeWeeklyPct === "number") {
+    body.claude_weekly_pct = claudeWeeklyPct;
+  }
+  if (claudeWeeklyResetsAt !== void 0) {
+    body.claude_weekly_resets_at = claudeWeeklyResetsAt;
+  }
+  const res = await taskReq("POST", "/api/v1/weekly-tokens", body);
+  if (res.status === 401) {
+    onUnauthorized();
+    throw new Error("weekly-tokens unauthorized (401)");
+  }
+  if (!res.ok) throw new Error(`weekly-tokens failed: HTTP ${res.status}`);
+  return true;
+}
+var init_control_plane_weekly_tokens = __esm({
+  "../../scripts/virtual-office/code-runner/control-plane-weekly-tokens.mjs"() {
+    "use strict";
+  }
+});
+
+// ../../scripts/virtual-office/code-runner/control-plane-telemetry-relay.mjs
+async function relayTelemetryEventsRequest(req, { events, source }, onUnauthorized = () => {
+}) {
+  const res = await req("POST", "/api/v1/telemetry/relay", { events, ...source ? { source } : {} }, {
+    timeoutMs: TELEMETRY_RELAY_TIMEOUT_MS
+  });
+  if (res.status === 401) onUnauthorized();
+  let body = null;
+  try {
+    body = await res.json();
+  } catch {
+    body = null;
+  }
+  return { status: res.status, body };
+}
+var TELEMETRY_RELAY_TIMEOUT_MS;
+var init_control_plane_telemetry_relay = __esm({
+  "../../scripts/virtual-office/code-runner/control-plane-telemetry-relay.mjs"() {
+    "use strict";
+    TELEMETRY_RELAY_TIMEOUT_MS = 3e4;
+  }
+});
+
 // ../../scripts/virtual-office/code-runner/claim-gate-notice.mjs
 function describeClaimGate(gate) {
   if (!gate || gate.allowed !== false) return null;
@@ -3739,38 +3793,21 @@ function createControlPlaneClient({
       if (!res.ok) throw new Error(`knowledge-context failed: HTTP ${res.status}`);
       return res.json();
     },
+    /** Weekly Claude token usage report — see control-plane-weekly-tokens.mjs. */
+    async postWeeklyTokens(report) {
+      return postWeeklyTokensRequest(taskReq, report, () => {
+        cachedFirebaseToken = null;
+      });
+    },
     /**
-     * Report this machine's rolling-7-day Claude Code token usage (the real
-     * weekly-capacity gauge) PLUS the operator's real Claude weekly % (when
-     * available). The daemon authenticates as admin, so the target `operatorId`
-     * is named explicitly. Best-effort; throws on a non-2xx so the caller can
-     * log + move on.
-     *
-     * `tokens` = { input_tokens, output_tokens, cache_creation_tokens, cache_read_tokens }.
-     * Optional: `claudeWeeklyPct` (number) + `claudeWeeklyResetsAt` (ISO string | null).
+     * Relay a batch of this machine's local vo-mcp events to vo-telemetry via
+     * the control plane (telemetry-forwarder.mjs). Returns { status, body };
+     * the forwarder owns backoff/disable policy. See control-plane-telemetry-relay.mjs.
      */
-    async postWeeklyTokens({ operatorId, runnerId: runnerId2, tokens, claudeWeeklyPct, claudeWeeklyResetsAt }) {
-      const body = {
-        operator_id: operatorId,
-        runner_id: runnerId2,
-        input_tokens: tokens.input_tokens,
-        output_tokens: tokens.output_tokens,
-        cache_creation_tokens: tokens.cache_creation_tokens,
-        cache_read_tokens: tokens.cache_read_tokens
-      };
-      if (typeof claudeWeeklyPct === "number") {
-        body.claude_weekly_pct = claudeWeeklyPct;
-      }
-      if (claudeWeeklyResetsAt !== void 0) {
-        body.claude_weekly_resets_at = claudeWeeklyResetsAt;
-      }
-      const res = await taskReq("POST", "/api/v1/weekly-tokens", body);
-      if (res.status === 401) {
+    async relayTelemetryEvents(batch) {
+      return relayTelemetryEventsRequest(req, batch, () => {
         cachedFirebaseToken = null;
-        throw new Error("weekly-tokens unauthorized (401)");
-      }
-      if (!res.ok) throw new Error(`weekly-tokens failed: HTTP ${res.status}`);
-      return true;
+      });
     },
     /**
      * Send a liveness heartbeat (M2). The control-plane upserts it under the
@@ -3904,6 +3941,8 @@ var init_control_plane_client = __esm({
     init_control_plane_resume();
     init_control_plane_autonomous_admission();
     init_control_plane_merge();
+    init_control_plane_weekly_tokens();
+    init_control_plane_telemetry_relay();
     init_claim_gate_notice();
     cachedFirebaseToken = null;
     ClaimAuthorityChangedError = class extends Error {
@@ -6690,8 +6729,8 @@ async function acquireLock(lockFile, { now = Date.now, sleep: sleep3 = delay } =
         stale = !alive || !Number.isFinite(created) || now() - created > LOCK_STALE_MS;
       } catch {
         try {
-          const stat2 = await fsp10.stat(lockFile);
-          stale = now() - stat2.mtimeMs > LOCK_INIT_GRACE_MS;
+          const stat3 = await fsp10.stat(lockFile);
+          stale = now() - stat3.mtimeMs > LOCK_INIT_GRACE_MS;
         } catch {
           stale = false;
         }
@@ -8740,8 +8779,8 @@ function selectDueEntries({ entries = [], now, alreadyDispatched = /* @__PURE__
       const entryAtMs = new Date(at).getTime();
       if (Number.isFinite(entryAtMs)) {
         const attemptCount = typeof attempts === "number" ? attempts : 0;
-        const backoffMs = NULL_RESUME_AFTER_BACKOFF_MS * Math.pow(2, attemptCount);
-        const dueAtMs = entryAtMs + backoffMs;
+        const backoffMs2 = NULL_RESUME_AFTER_BACKOFF_MS * Math.pow(2, attemptCount);
+        const dueAtMs = entryAtMs + backoffMs2;
         isDue = nowMs >= dueAtMs;
       }
     } else {
@@ -8905,6 +8944,303 @@ var init_rate_limit_resume_scheduler = __esm({
   }
 });
 
+// ../../scripts/virtual-office/code-runner/telemetry-forwarder.mjs
+import { homedir as homedir8 } from "node:os";
+import { dirname as dirname9, join as join13 } from "node:path";
+import { mkdir as mkdir2, open, readFile as readFile3, stat as stat2, writeFile as writeFile3 } from "node:fs/promises";
+function defaultEventsPath(env2 = process.env) {
+  const p = String(env2.VO_MCP_EVENTS_PATH || "").trim();
+  return p || join13(homedir8(), ".claude", "vo-mcp-events.jsonl");
+}
+function defaultStatePath(env2 = process.env) {
+  const p = String(env2.VO_MCP_EVENTS_FORWARD_STATE || "").trim();
+  return p || join13(homedir8(), ".claude", "vo-mcp-events-forward-state.json");
+}
+function splitCompleteLines(buf) {
+  const lines = [];
+  let start = 0;
+  let consumedBytes = 0;
+  for (; ; ) {
+    const nl = buf.indexOf(10, start);
+    if (nl === -1) break;
+    lines.push({ text: buf.subarray(start, nl).toString("utf8"), bytes: nl - start + 1 });
+    consumedBytes = nl + 1;
+    start = nl + 1;
+  }
+  return { lines, consumedBytes };
+}
+function backoffMs(streak, baseMs) {
+  if (streak <= 0) return 0;
+  return Math.min(baseMs * 2 ** Math.min(streak - 1, 20), MAX_BACKOFF_MS);
+}
+async function loadState(path22) {
+  try {
+    const parsed = JSON.parse(await readFile3(path22, "utf8"));
+    if (parsed && typeof parsed === "object" && Number.isInteger(parsed.byte_offset) && parsed.byte_offset >= 0) {
+      return { ...parsed, byte_offset: parsed.byte_offset };
+    }
+  } catch {
+  }
+  return { byte_offset: 0, last_event_id: null, forwarded_total: 0, rejected_total: 0, rejected_event_ids: [] };
+}
+async function saveState(path22, state) {
+  await mkdir2(dirname9(path22), { recursive: true });
+  await writeFile3(path22, JSON.stringify(state, null, 2), "utf8");
+}
+async function readNewBytes(path22, offset, max) {
+  const st = await stat2(path22);
+  if (st.size <= offset) return { buf: Buffer.alloc(0), size: st.size };
+  const length = Math.min(st.size - offset, max);
+  const fh = await open(path22, "r");
+  try {
+    const buf = Buffer.alloc(length);
+    const { bytesRead } = await fh.read(buf, 0, length, offset);
+    return { buf: buf.subarray(0, bytesRead), size: st.size };
+  } finally {
+    await fh.close();
+  }
+}
+function createTelemetryForwarder({
+  client,
+  cfg = {},
+  env: env2 = process.env,
+  log: log2 = () => {
+  },
+  runnerInstanceId = "",
+  now = () => Date.now(),
+  eventsPath = defaultEventsPath(env2),
+  statePath: statePath2 = defaultStatePath(env2)
+} = {}) {
+  const optedOut = env2.VO_MCP_EVENTS_FORWARD === "0";
+  const capable = typeof client?.relayTelemetryEvents === "function";
+  const intervalSec = Math.max(MIN_FORWARD_INTERVAL_SEC, Number(env2.VO_MCP_EVENTS_FORWARD_SEC) || DEFAULT_FORWARD_INTERVAL_SEC);
+  const maxPerRun = Math.max(MAX_EVENTS_PER_BATCH, Number(env2.VO_MCP_EVENTS_FORWARD_MAX_PER_MIN) || DEFAULT_MAX_EVENTS_PER_MIN);
+  const intervalMs = intervalSec * 1e3;
+  const enabled = capable && !optedOut;
+  const disabledReason = optedOut ? "VO_MCP_EVENTS_FORWARD=0" : capable ? "" : "client has no relayTelemetryEvents";
+  let running = false;
+  let nextRunAt = 0;
+  let failStreak = 0;
+  const servedOperators = Array.isArray(cfg.servedOperators) ? cfg.servedOperators.filter((v) => typeof v === "string" && v).slice(0, 100) : [];
+  const source = {
+    runner_id: cfg.runnerId || "unknown",
+    ...runnerInstanceId ? { runner_instance_id: runnerInstanceId } : {},
+    ...servedOperators.length > 0 ? { served_operator_ids: servedOperators } : {}
+  };
+  log2(enabled ? `telemetry forwarder ON \u2014 ${eventsPath} \u2192 control-plane relay every ${intervalSec}s (\u2264${maxPerRun}/run; VO_MCP_EVENTS_FORWARD=0 to disable)` : `telemetry forwarder OFF (${disabledReason})`);
+  function pauseForbidden(reason) {
+    nextRunAt = now() + FORBIDDEN_PAUSE_MS;
+    log2(`telemetry forwarder PAUSED ${Math.round(FORBIDDEN_PAUSE_MS / 36e5)}h \u2014 relay refused this runner (${reason}); enroll the operator (VO_TELEMETRY_RELAY_OPERATOR_IDS / HQ_WHITEBOARD_OPERATOR_IDS) or set VO_MCP_EVENTS_FORWARD=0`);
+  }
+  function scheduleFailure(reasonMs) {
+    failStreak += 1;
+    const delay2 = Math.max(reasonMs || 0, backoffMs(failStreak, intervalMs));
+    nextRunAt = now() + delay2;
+    return delay2;
+  }
+  async function runOnce() {
+    const receipt = { forwarded: 0, duplicate: 0, rejected: 0, malformed: 0, halted: null, batches: 0 };
+    let state = await loadState(statePath2);
+    let read;
+    try {
+      read = await readNewBytes(eventsPath, state.byte_offset, MAX_READ_BYTES_PER_RUN);
+    } catch (err) {
+      if (err && err.code === "ENOENT") {
+        nextRunAt = now() + intervalMs;
+        return { ...receipt, status: "no-file" };
+      }
+      log2(`telemetry forwarder read failed: ${err.message}`);
+      scheduleFailure();
+      return { ...receipt, status: "read-error" };
+    }
+    if (read.size < state.byte_offset) {
+      log2(`telemetry forwarder: events file rotated/truncated (size ${read.size} < cursor ${state.byte_offset}); restarting cursor at 0`);
+      state = { ...state, byte_offset: 0 };
+      await saveState(statePath2, state);
+      read = await readNewBytes(eventsPath, 0, MAX_READ_BYTES_PER_RUN).catch(() => ({ buf: Buffer.alloc(0), size: 0 }));
+    }
+    const { lines } = splitCompleteLines(read.buf);
+    if (lines.length === 0) {
+      nextRunAt = now() + intervalMs;
+      return { ...receipt, status: "idle" };
+    }
+    const pending = [];
+    let cursor = state.byte_offset;
+    let leadingConsumed = 0;
+    for (const line of lines) {
+      if (pending.length >= maxPerRun) break;
+      if (line.text.trim().length === 0) {
+        if (pending.length === 0) leadingConsumed += line.bytes;
+        else pending[pending.length - 1].bytes += line.bytes;
+        continue;
+      }
+      try {
+        pending.push({ event: JSON.parse(line.text), bytes: line.bytes });
+      } catch {
+        receipt.malformed += 1;
+        if (pending.length === 0) leadingConsumed += line.bytes;
+        else pending[pending.length - 1].bytes += line.bytes;
+      }
+    }
+    cursor += leadingConsumed;
+    if (pending.length === 0) {
+      state = { ...state, byte_offset: cursor };
+      await saveState(statePath2, state);
+      nextRunAt = now() + intervalMs;
+      return { ...receipt, status: "idle" };
+    }
+    let halted = false;
+    let batchSize = MAX_EVENTS_PER_BATCH;
+    for (let i = 0; i < pending.length && !halted; ) {
+      const batch = pending.slice(i, i + batchSize);
+      let res;
+      try {
+        res = await client.relayTelemetryEvents({ events: batch.map((p) => p.event), source });
+      } catch (err) {
+        receipt.halted = `network: ${err && err.message ? err.message : String(err)}`.slice(0, 200);
+        halted = true;
+        break;
+      }
+      receipt.batches += 1;
+      const body = res && res.body && typeof res.body === "object" ? res.body : {};
+      if (res.status === 413) {
+        if (batch.length > 1) {
+          batchSize = 1;
+          continue;
+        }
+        const item = batch[0];
+        cursor += item.bytes;
+        i += 1;
+        receipt.rejected += 1;
+        const id = typeof item.event?.event_id === "string" ? item.event.event_id : `offset:${cursor - item.bytes}`;
+        state = {
+          ...state,
+          byte_offset: cursor,
+          rejected_total: (state.rejected_total || 0) + 1,
+          rejected_event_ids: [...state.rejected_event_ids || [], `${id}:payload_too_large`].slice(-REJECTED_IDS_KEEP)
+        };
+        await saveState(statePath2, state);
+        continue;
+      }
+      i += batch.length;
+      if (res.status === 403) {
+        pauseForbidden(body.error || "HTTP 403");
+        receipt.halted = "forbidden";
+        halted = true;
+        break;
+      }
+      if (res.status === 503 && (body.error === "ingest_disabled" || body.error === "relay_unconfigured")) {
+        const retrySec = Number(body.retry_after_sec) > 0 ? Number(body.retry_after_sec) : 600;
+        receipt.halted = body.error;
+        halted = true;
+        scheduleFailure(retrySec * 1e3);
+        break;
+      }
+      if (res.status !== 200 || body.ok !== true || !Array.isArray(body.results)) {
+        receipt.halted = `HTTP ${res.status}${body.error ? ` ${body.error}` : ""}`;
+        halted = true;
+        break;
+      }
+      let applied = 0;
+      let batchForwarded = 0;
+      let batchRejected = 0;
+      for (const r of body.results) {
+        const item = batch[r.index];
+        if (!item || r.index !== applied) break;
+        if (r.status === "upstream_error") {
+          receipt.halted = `upstream_error${r.error ? ` ${r.error}` : ""}`;
+          halted = true;
+          break;
+        }
+        cursor += item.bytes;
+        applied += 1;
+        if (r.status === "written") {
+          receipt.forwarded += 1;
+          batchForwarded += 1;
+        } else if (r.status === "duplicate") receipt.duplicate += 1;
+        else if (r.status === "rejected") {
+          receipt.rejected += 1;
+          batchRejected += 1;
+          const id = typeof item.event?.event_id === "string" ? item.event.event_id : `offset:${cursor - item.bytes}`;
+          state.rejected_event_ids = [...state.rejected_event_ids || [], `${id}:${r.error || "rejected"}`].slice(-REJECTED_IDS_KEEP);
+        }
+        if (typeof r.event_id === "string") state.last_event_id = r.event_id;
+      }
+      if (body.complete !== true && !halted) {
+        receipt.halted = "incomplete-batch";
+        halted = true;
+      }
+      if (applied < batch.length && !halted) {
+        receipt.halted = "short-results";
+        halted = true;
+      }
+      state = {
+        ...state,
+        byte_offset: cursor,
+        forwarded_total: (state.forwarded_total || 0) + batchForwarded,
+        rejected_total: (state.rejected_total || 0) + batchRejected,
+        last_forward_at: new Date(now()).toISOString(),
+        last_error: receipt.halted
+      };
+      await saveState(statePath2, state);
+    }
+    if (halted) {
+      state = { ...state, byte_offset: cursor, last_error: receipt.halted, last_halt_at: new Date(now()).toISOString() };
+      await saveState(statePath2, state).catch(() => {
+      });
+    }
+    const totals = { forwarded: state.forwarded_total || 0, rejected: state.rejected_total || 0 };
+    if (halted && receipt.halted !== "forbidden" && receipt.halted !== "ingest_disabled" && receipt.halted !== "relay_unconfigured") {
+      const delay2 = scheduleFailure();
+      log2(`telemetry forwarder: halted (${receipt.halted}); cursor=${cursor}B; retry in ${Math.round(delay2 / 1e3)}s`);
+    } else if (!halted) {
+      failStreak = 0;
+      nextRunAt = now() + intervalMs;
+      log2(`telemetry forwarder: relayed ${receipt.batches} batch(es); cursor=${cursor}B; totals forwarded=${totals.forwarded} rejected=${totals.rejected}${receipt.malformed ? ` malformed=${receipt.malformed}` : ""}`);
+    } else {
+      log2(`telemetry forwarder: paused (${receipt.halted}); cursor=${cursor}B`);
+    }
+    return { ...receipt, status: halted ? "halted" : "ok", cursor, totals };
+  }
+  return {
+    get enabled() {
+      return enabled;
+    },
+    get disabledReason() {
+      return disabledReason;
+    },
+    intervalMs,
+    /** Fire-and-forget; safe to call every daemon loop iteration. */
+    tick() {
+      if (!enabled || running) return void 0;
+      const t = now();
+      if (t < nextRunAt) return void 0;
+      running = true;
+      return runOnce().catch((err) => {
+        log2(`telemetry forwarder tick failed: ${err && err.message ? err.message : String(err)}`);
+        scheduleFailure();
+      }).finally(() => {
+        running = false;
+      });
+    },
+    runOnce
+  };
+}
+var DEFAULT_FORWARD_INTERVAL_SEC, MIN_FORWARD_INTERVAL_SEC, DEFAULT_MAX_EVENTS_PER_MIN, MAX_EVENTS_PER_BATCH, MAX_READ_BYTES_PER_RUN, MAX_BACKOFF_MS, REJECTED_IDS_KEEP, FORBIDDEN_PAUSE_MS;
+var init_telemetry_forwarder = __esm({
+  "../../scripts/virtual-office/code-runner/telemetry-forwarder.mjs"() {
+    "use strict";
+    DEFAULT_FORWARD_INTERVAL_SEC = 60;
+    MIN_FORWARD_INTERVAL_SEC = 15;
+    DEFAULT_MAX_EVENTS_PER_MIN = 500;
+    MAX_EVENTS_PER_BATCH = 25;
+    MAX_READ_BYTES_PER_RUN = 4 * 1024 * 1024;
+    MAX_BACKOFF_MS = 30 * 60 * 1e3;
+    REJECTED_IDS_KEEP = 100;
+    FORBIDDEN_PAUSE_MS = 6 * 60 * 60 * 1e3;
+  }
+});
+
 // ../../scripts/virtual-office/code-runner/loop-ticks.mjs
 function makeLoopTicks({
   client,
@@ -8934,7 +9270,11 @@ function makeLoopTicks({
   getAccountUsage = () => [],
   // Injectable for tests; default to the real scheduler + wall clock.
   runResumeScheduler = runScheduler,
-  now: nowFn = () => Date.now()
+  now: nowFn = () => Date.now(),
+  // Cursor-lessons §6 (2026-08-16): forwards this machine's vo-mcp events to
+  // the control-plane telemetry relay (telemetry-forwarder.mjs). Inert when the
+  // client lacks relayTelemetryEvents (test fakes) or VO_MCP_EVENTS_FORWARD=0.
+  telemetryForwarder = createTelemetryForwarder({ client, cfg, env: env2, log: log2, runnerInstanceId, now: nowFn })
 }) {
   let lastSessionForward = 0;
   let lastHeartbeat = 0;
@@ -9046,6 +9386,7 @@ function makeLoopTicks({
         resumeRunning = false;
       });
     }
+    telemetryForwarder.tick();
     return Promise.all(heartbeatCompletions).then(() => void 0);
   };
 }
@@ -9055,6 +9396,7 @@ var init_loop_ticks = __esm({
     "use strict";
     init_session_spool_forwarder();
     init_rate_limit_resume_scheduler();
+    init_telemetry_forwarder();
     HEARTBEAT_MS = 6e4;
     DEFAULT_RESUME_SCHEDULE_SEC = 300;
   }
@@ -10051,7 +10393,7 @@ async function scheduleCoordinationRetry({
   const attemptsKey = kind === "resume" ? "resumeAttempts" : "fixAttempts";
   entry[errorsKey] = (entry[errorsKey] || 0) + 1;
   entry[attemptsKey] = Math.max(0, (entry[attemptsKey] || 1) - 1);
-  const delay2 = Math.min(MAX_BACKOFF_MS, 3e4 * 2 ** Math.min(7, entry[errorsKey] - 1));
+  const delay2 = Math.min(MAX_BACKOFF_MS2, 3e4 * 2 ** Math.min(7, entry[errorsKey] - 1));
   entry.nextRetryAt = now() + delay2;
   if (entry[errorsKey] >= 3 && !entry.coordinationEscalatedAt && typeof reportBlocker === "function") {
     try {
@@ -10066,12 +10408,12 @@ async function scheduleCoordinationRetry({
   }
   log2(`watch: pr #${prNumber} ${kind} coordination failed ${entry[errorsKey]}x; retry in ${Math.round(delay2 / 1e3)}s: ${boundedErrorMessage(error)}`);
 }
-var MAX_BACKOFF_MS, MERGE_ENQUEUE_TTL_MS, TERMINAL_RESUME_REFUSALS;
+var MAX_BACKOFF_MS2, MERGE_ENQUEUE_TTL_MS, TERMINAL_RESUME_REFUSALS;
 var init_watcher_coordination = __esm({
   "../../scripts/virtual-office/code-runner/watcher-coordination.mjs"() {
     "use strict";
     init_error_message();
-    MAX_BACKOFF_MS = 60 * 60 * 1e3;
+    MAX_BACKOFF_MS2 = 60 * 60 * 1e3;
     MERGE_ENQUEUE_TTL_MS = 2 * 60 * 60 * 1e3;
     TERMINAL_RESUME_REFUSALS = Object.freeze([
       "automatic_continuation_budget_too_small",
@@ -10089,12 +10431,12 @@ var init_watcher_coordination = __esm({
 
 // ../../scripts/virtual-office/code-runner/watcher-state.mjs
 import { randomUUID as randomUUID3 } from "node:crypto";
-import { mkdir as mkdir2, open, readFile as readFile3, rename, unlink as unlink2 } from "node:fs/promises";
-import { dirname as dirname9 } from "node:path";
+import { mkdir as mkdir3, open as open2, readFile as readFile4, rename, unlink as unlink2 } from "node:fs/promises";
+import { dirname as dirname10 } from "node:path";
 async function readWatcherState(stateFile) {
   let raw;
   try {
-    raw = await readFile3(stateFile, "utf8");
+    raw = await readFile4(stateFile, "utf8");
   } catch (error) {
     if (error?.code === "ENOENT") return {};
     throw error;
@@ -10106,12 +10448,12 @@ async function readWatcherState(stateFile) {
   return parsed;
 }
 async function writeWatcherState(stateFile, state) {
-  const directory = dirname9(stateFile);
-  await mkdir2(directory, { recursive: true });
+  const directory = dirname10(stateFile);
+  await mkdir3(directory, { recursive: true });
   const temp = `${stateFile}.${process.pid}.${randomUUID3()}.tmp`;
   let handle;
   try {
-    handle = await open(temp, "wx");
+    handle = await open2(temp, "wx");
     await handle.writeFile(JSON.stringify(state, null, 2), "utf8");
     await handle.sync();
     await handle.close();
@@ -10435,8 +10777,8 @@ var init_enqueue_autonomous_code_task = __esm({
 });
 
 // ../../scripts/virtual-office/code-runner/pr-watcher.mjs
-import { homedir as homedir8 } from "node:os";
-import { join as join13 } from "node:path";
+import { homedir as homedir9 } from "node:os";
+import { join as join14 } from "node:path";
 function parsePrCiStatus(view) {
   const state = (view && typeof view.state === "string" ? view.state : "UNKNOWN").toUpperCase();
   const rollup = view && Array.isArray(view.statusCheckRollup) ? view.statusCheckRollup : [];
@@ -10782,7 +11124,7 @@ var init_pr_watcher = __esm({
     init_watcher_state();
     init_superseded_pr_source();
     init_ci_fix_prompt();
-    DEFAULT_STATE_FILE = join13(homedir8(), ".vo", "dispatched-prs.json");
+    DEFAULT_STATE_FILE = join14(homedir9(), ".vo", "dispatched-prs.json");
     FAIL_CONCLUSIONS = /* @__PURE__ */ new Set([
       "FAILURE",
       "TIMED_OUT",
@@ -12026,8 +12368,8 @@ var init_classify_task = __esm({
 
 // ../../scripts/virtual-office/code-runner/auto-router/effort-policy.mjs
 import { readFileSync as readFileSync9 } from "node:fs";
-import { homedir as homedir9 } from "node:os";
-import { join as join14 } from "node:path";
+import { homedir as homedir10 } from "node:os";
+import { join as join15 } from "node:path";
 function difficultyToRung(difficulty, thresholds) {
   const b = thresholds.rungBounds;
   if (difficulty >= b.R5) return "R5";
@@ -12104,7 +12446,7 @@ var init_effort_policy = __esm({
     init_meta_model_catalog();
     RUNG_ORDER = ["R1", "R2", "R3", "R4", "R5"];
     rungIndex = (rung) => RUNG_ORDER.indexOf(rung);
-    DEFAULT_CODEX_MODELS_CACHE = join14(homedir9(), ".codex", "models_cache.json");
+    DEFAULT_CODEX_MODELS_CACHE = join15(homedir10(), ".codex", "models_cache.json");
   }
 });
 
@@ -12235,8 +12577,8 @@ var init_role_cost_shadow = __esm({
 
 // ../../scripts/virtual-office/code-runner/auto-router/auto-router.mjs
 import { readFileSync as readFileSync10, appendFileSync, mkdirSync as mkdirSync8 } from "node:fs";
-import { homedir as homedir10 } from "node:os";
-import { join as join15, dirname as dirname10 } from "node:path";
+import { homedir as homedir11 } from "node:os";
+import { join as join16, dirname as dirname11 } from "node:path";
 import { fileURLToPath as fileURLToPath7 } from "node:url";
 function getAutoRouterMode(env2 = process.env) {
   const raw = String(env2.VO_CODE_RUNNER_AUTO_ROUTER || "").trim().toLowerCase();
@@ -12244,8 +12586,8 @@ function getAutoRouterMode(env2 = process.env) {
 }
 function loadThresholds() {
   if (!cachedThresholds) {
-    const here = dirname10(fileURLToPath7(import.meta.url));
-    cachedThresholds = JSON.parse(readFileSync10(join15(here, "thresholds.json"), "utf8"));
+    const here = dirname11(fileURLToPath7(import.meta.url));
+    cachedThresholds = JSON.parse(readFileSync10(join16(here, "thresholds.json"), "utf8"));
   }
   return cachedThresholds;
 }
@@ -12311,9 +12653,9 @@ function formatDecisionReason(decision, maxLen = 480) {
   const s = `[${decision.routerVersion}] ${decision.taskClass} d=${decision.difficulty} c=${decision.confidence} \u2192 ${decision.rung}/${decision.tier}${decision.effort ? ` effort=${decision.effort}` : ""} turns=${decision.maxTurns} $${decision.maxBudgetUsd}${decision.flags.length ? ` [${decision.flags.join(",")}]` : ""} :: ${decision.reasons.join("; ")}`;
   return s.length > maxLen ? `${s.slice(0, maxLen - 1)}\u2026` : s;
 }
-function appendDecisionFallback(decision, { path: path22 = DECISION_FALLBACK_PATH, append = appendFileSync, mkdir: mkdir4 = mkdirSync8, task, thresholds, roleCostInputs } = {}) {
+function appendDecisionFallback(decision, { path: path22 = DECISION_FALLBACK_PATH, append = appendFileSync, mkdir: mkdir5 = mkdirSync8, task, thresholds, roleCostInputs } = {}) {
   try {
-    mkdir4(dirname10(path22), { recursive: true });
+    mkdir5(dirname11(path22), { recursive: true });
     append(path22, `${JSON.stringify(decision)}
 `, "utf8");
     if (isRouterDecision(decision)) {
@@ -12337,7 +12679,7 @@ var init_auto_router = __esm({
     init_effort_policy();
     init_role_cost_shadow();
     ROUTER_VERSION = "0.1.0";
-    DECISION_FALLBACK_PATH = join15(homedir10(), ".claude", "vo-auto-router-decisions.jsonl");
+    DECISION_FALLBACK_PATH = join16(homedir11(), ".claude", "vo-auto-router-decisions.jsonl");
     MODES = /* @__PURE__ */ new Set(["off", "shadow", "on"]);
     cachedThresholds = null;
     isRouterDecision = (d) => Boolean(d && typeof d === "object" && typeof d.taskClass === "string" && typeof d.confidence === "number");
@@ -12737,7 +13079,7 @@ function safeBaseEnv(env2 = {}) {
   }
   return result;
 }
-function buildAgentProcessEnv(env2, { agent = "agent", runnerId = "vo-runner", taskId = "task", githubReadToken = null, swarmAdmission = null } = {}) {
+function buildAgentProcessEnv(env2, { agent = "agent", runnerId = "vo-runner", taskId = "task", repo = null, githubReadToken = null, swarmAdmission = null } = {}) {
   const base = safeBaseEnv(env2);
   if (swarmAdmission) {
     for (const key of Object.keys(base)) {
@@ -12749,6 +13091,8 @@ function buildAgentProcessEnv(env2, { agent = "agent", runnerId = "vo-runner", t
     base.GH_TOKEN = githubReadToken;
     base.GITHUB_TOKEN = githubReadToken;
   }
+  if (typeof taskId === "string" && taskId && taskId !== "task") base.VO_CODE_TASK_ID = taskId;
+  if (typeof repo === "string" && /^[A-Za-z0-9_.-]+\/[A-Za-z0-9_.-]+$/u.test(repo)) base.VO_CODE_TASK_REPO = repo;
   if (String(env2?.AGENT_ID || "").trim()) return { ...base, AGENT_ID: env2.AGENT_ID };
   const generated = [
     "vo",
@@ -12818,6 +13162,12 @@ var init_agent_process_env = __esm({
       // NOT a credential and NOT an authorization input: it names a tier, it never
       // grants one, and it carries no key material (see the module's header rule).
       "VO_SWARM_TIER_BINDING",
+      // Increased-moat staging flags (2026-08-16): a fleet machine's runner env
+      // decides whether its agents' vo-mcp ALSO sends verdicts through the moat
+      // (shadow) or lets the moat win (authoritative). Per-machine, default absent.
+      "VO_CONSENSUS_MOAT_SHADOW",
+      "VO_CONSENSUS_MOAT_SHADOW_PCT",
+      "VO_CONSENSUS_MOAT_AUTHORITATIVE",
       // Where the swarm SPAWN LEDGER lives (SWARM_LEDGER_DIR_ENV in
       // packages/vo-mcp/src/swarm/spawn-ledger.ts). The ledger is the durable,
       // host-shared counter that bounds the TOTAL spawns under one swarm_id; the
@@ -14053,9 +14403,9 @@ function recoveryLedgerCandidates(repo, clonesRoot2) {
     path21.join(canonical, ".agent-worktrees", "recovery-ledger.jsonl")
   ];
 }
-async function readLedger(file, readFile5) {
+async function readLedger(file, readFile6) {
   try {
-    return String(await readFile5(file, "utf8")).split(/\r?\n/).filter(Boolean).flatMap((line) => {
+    return String(await readFile6(file, "utf8")).split(/\r?\n/).filter(Boolean).flatMap((line) => {
       try {
         return [JSON.parse(line)];
       } catch {
@@ -14068,7 +14418,7 @@ async function readLedger(file, readFile5) {
 }
 async function findPreservedRecovery(task, {
   clonesRoot: clonesRoot2 = process.env.VO_CODE_RUNNER_CLONES_ROOT || "",
-  readFile: readFile5 = fsp13.readFile,
+  readFile: readFile6 = fsp13.readFile,
   exists = fs13.existsSync,
   alreadyPublished = preservedHeadAlreadyOnBranch,
   log: log2 = () => {
@@ -14079,7 +14429,7 @@ async function findPreservedRecovery(task, {
   if (!originalTaskId) return null;
   if (task.pr_branch && !recoveryTaskId(task.prompt)) return null;
   for (const ledgerPath of recoveryLedgerCandidates(task.repo, clonesRoot2)) {
-    const entries = await readLedger(ledgerPath, readFile5);
+    const entries = await readLedger(ledgerPath, readFile6);
     const resolved = entries.some((entry) => RESOLVED_RECOVERY_TYPES.has(entry.type) && entry.taskId === originalTaskId);
     const preserved = [...entries].reverse().find((entry) => entry.taskId === originalTaskId && entry.worktreeDir);
     if (!resolved && preserved && exists(preserved.worktreeDir)) {
@@ -14420,9 +14770,9 @@ var init_cancellation_probe = __esm({
 });
 
 // ../../scripts/virtual-office/code-runner/detached-economics-spool.mjs
-import { homedir as homedir11 } from "node:os";
-import { dirname as dirname11, join as join16 } from "node:path";
-import { mkdir as mkdir3, readFile as readFile4, rename as rename2, writeFile as writeFile3 } from "node:fs/promises";
+import { homedir as homedir12 } from "node:os";
+import { dirname as dirname12, join as join17 } from "node:path";
+import { mkdir as mkdir4, readFile as readFile5, rename as rename2, writeFile as writeFile4 } from "node:fs/promises";
 function withLock(operation) {
   const result = serialized.then(operation, operation);
   serialized = result.then(() => void 0, () => void 0);
@@ -14430,7 +14780,7 @@ function withLock(operation) {
 }
 async function readEntries(file) {
   try {
-    const parsed = JSON.parse(await readFile4(file, "utf8"));
+    const parsed = JSON.parse(await readFile5(file, "utf8"));
     if (!Array.isArray(parsed)) throw new Error("detached economics spool is not an array");
     return parsed;
   } catch (error) {
@@ -14439,9 +14789,9 @@ async function readEntries(file) {
   }
 }
 async function writeEntries(file, entries) {
-  await mkdir3(dirname11(file), { recursive: true });
+  await mkdir4(dirname12(file), { recursive: true });
   const temp = `${file}.${process.pid}.tmp`;
-  await writeFile3(temp, `${JSON.stringify(entries)}
+  await writeFile4(temp, `${JSON.stringify(entries)}
 `, "utf8");
   await rename2(temp, file);
 }
@@ -14485,7 +14835,7 @@ var DEFAULT_FILE, serialized;
 var init_detached_economics_spool = __esm({
   "../../scripts/virtual-office/code-runner/detached-economics-spool.mjs"() {
     "use strict";
-    DEFAULT_FILE = join16(homedir11(), ".vo", "detached-run-economics.json");
+    DEFAULT_FILE = join17(homedir12(), ".vo", "detached-run-economics.json");
     serialized = Promise.resolve();
   }
 });
@@ -14886,7 +15236,7 @@ async function processOneTask(client, task, cfg, runnerInstanceId, swarmAdmissio
       maxBudgetUsd: sel.agent === "claude" ? effectiveMaxBudgetUsd : void 0,
       researchHarness: methodology?.shape === "research",
       // Workflow grant only for research-shaped tasks
-      env: buildAgentProcessEnv(process.env, { agent: sel.agent, runnerId: cfg.runnerId, taskId: id, githubReadToken: agentGithubReadToken, swarmAdmission }),
+      env: buildAgentProcessEnv(process.env, { agent: sel.agent, runnerId: cfg.runnerId, taskId: id, repo: task.repo, githubReadToken: agentGithubReadToken, swarmAdmission }),
       // swarmAdmission mints VO_SWARM_TIER_BINDING: ONE tier decision for this task's whole agent tree
       sandbox,
       onProgress: (text, checkpoint) => {