@algosuite/vo-mcp 0.2.0-beta.29 → 0.2.0-beta.33

package/dist/index.js

@@ -318,13 +318,191 @@ var init_safe_memory_file = __esm({
   }
 });
 
+// src/tools/memory/bounded-sync.ts
+function createSyncDeadline(budgetMs = SYNC_DEADLINE_MS, now = Date.now) {
+  const startedAt = now();
+  return {
+    check() {
+      const elapsed = now() - startedAt;
+      if (elapsed > budgetMs) throw new SyncDeadlineExceededError(elapsed, budgetMs);
+    },
+    remainingMs() {
+      return Math.max(0, budgetMs - (now() - startedAt));
+    }
+  };
+}
+async function withRequestTimeout(url, run, budgetMs = REQUEST_TIMEOUT_MS) {
+  let timer;
+  try {
+    return await Promise.race([
+      run(),
+      new Promise((_resolve, reject) => {
+        timer = setTimeout(() => reject(new RequestTimeoutError(url, budgetMs)), budgetMs);
+        timer.unref?.();
+      })
+    ]);
+  } finally {
+    if (timer) clearTimeout(timer);
+  }
+}
+async function mapWithConcurrency(items, limit, fn) {
+  const results = new Array(items.length);
+  const width = Math.max(1, Math.min(limit, items.length));
+  let next = 0;
+  async function worker() {
+    for (; ; ) {
+      const index = next++;
+      if (index >= items.length) return;
+      try {
+        results[index] = { ok: true, value: await fn(items[index], index) };
+      } catch (error) {
+        results[index] = { ok: false, error };
+      }
+    }
+  }
+  await Promise.all(Array.from({ length: width }, () => worker()));
+  return results;
+}
+var REQUEST_TIMEOUT_MS, SYNC_DEADLINE_MS, PUSH_CONCURRENCY, SyncDeadlineExceededError, RequestTimeoutError;
+var init_bounded_sync = __esm({
+  "src/tools/memory/bounded-sync.ts"() {
+    "use strict";
+    REQUEST_TIMEOUT_MS = 15e3;
+    SYNC_DEADLINE_MS = 12e4;
+    PUSH_CONCURRENCY = 6;
+    SyncDeadlineExceededError = class extends Error {
+      constructor(elapsedMs, budgetMs) {
+        super(
+          `memory sync exceeded its ${budgetMs}ms deadline after ${elapsedMs}ms \u2014 aborting so the lock is released instead of held indefinitely`
+        );
+        this.name = "SyncDeadlineExceededError";
+      }
+    };
+    RequestTimeoutError = class extends Error {
+      constructor(url, budgetMs) {
+        super(`memory sync request to ${url} exceeded ${budgetMs}ms`);
+        this.name = "RequestTimeoutError";
+      }
+    };
+  }
+});
+
+// src/tools/memory/memory-push-cache.ts
+import { createHash as createHash3 } from "node:crypto";
+import { readFileSync as readFileSync10, writeFileSync as writeFileSync5 } from "node:fs";
+import { join as join9 } from "node:path";
+function sha256(content) {
+  return createHash3("sha256").update(content, "utf8").digest("hex");
+}
+function statePath(memoryDir) {
+  return join9(memoryDir, MEMORY_SYNC_STATE_FILE);
+}
+function readPushCache(memoryDir, controlPlaneUrl) {
+  const empty = { controlPlaneUrl, entries: /* @__PURE__ */ new Map(), knowledgeSweptAtMs: null };
+  let raw;
+  try {
+    raw = readFileSync10(statePath(memoryDir), "utf8");
+  } catch {
+    return empty;
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    return empty;
+  }
+  if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) return empty;
+  const obj = parsed;
+  if (obj["version"] !== STATE_VERSION) return empty;
+  if (obj["controlPlaneUrl"] !== controlPlaneUrl) return empty;
+  const files = obj["entries"];
+  if (typeof files !== "object" || files === null || Array.isArray(files)) return empty;
+  const entries = /* @__PURE__ */ new Map();
+  for (const [name, value] of Object.entries(files)) {
+    if (typeof value !== "object" || value === null || Array.isArray(value)) continue;
+    const row = value;
+    const memoryHash = typeof row["memoryHash"] === "string" ? row["memoryHash"] : void 0;
+    const knowledgeHash = typeof row["knowledgeHash"] === "string" ? row["knowledgeHash"] : void 0;
+    if (memoryHash === void 0 && knowledgeHash === void 0) continue;
+    entries.set(name, {
+      ...memoryHash !== void 0 ? { memoryHash } : {},
+      ...knowledgeHash !== void 0 ? { knowledgeHash } : {}
+    });
+  }
+  const sweptAt = obj["knowledgeSweptAtMs"];
+  return {
+    controlPlaneUrl,
+    entries,
+    // An unreadable/absent sweep stamp reads as NEVER SWEPT, which forces a full
+    // sweep — the fail-closed direction (more upserts, never fewer).
+    knowledgeSweptAtMs: typeof sweptAt === "number" && Number.isFinite(sweptAt) ? sweptAt : null
+  };
+}
+function writePushCache(memoryDir, cache) {
+  const entries = {};
+  for (const [name, value] of cache.entries) entries[name] = value;
+  try {
+    writeFileSync5(
+      statePath(memoryDir),
+      `${JSON.stringify(
+        {
+          version: STATE_VERSION,
+          controlPlaneUrl: cache.controlPlaneUrl,
+          knowledgeSweptAtMs: cache.knowledgeSweptAtMs,
+          entries
+        },
+        null,
+        2
+      )}
+`,
+      "utf8"
+    );
+  } catch {
+  }
+}
+function recordMemoryPush(cache, fileName, payloadHash) {
+  cache.entries.set(fileName, { ...cache.entries.get(fileName), memoryHash: payloadHash });
+}
+function recordKnowledgePush(cache, fileName, contentHash) {
+  cache.entries.set(fileName, { ...cache.entries.get(fileName), knowledgeHash: contentHash });
+}
+function pruneMissing(cache, presentFileNames) {
+  const present = new Set(presentFileNames);
+  for (const name of [...cache.entries.keys()]) {
+    if (!present.has(name)) cache.entries.delete(name);
+  }
+}
+function needsMemoryPush(cache, fileName, payloadHash, serverHasEntry) {
+  if (!serverHasEntry) return true;
+  return cache.entries.get(fileName)?.memoryHash !== payloadHash;
+}
+function knowledgeSweepDue(cache, nowMs = Date.now()) {
+  const swept = cache.knowledgeSweptAtMs;
+  if (swept === null || !Number.isFinite(swept)) return true;
+  const age = nowMs - swept;
+  return !(age >= 0 && age < KNOWLEDGE_FULL_SWEEP_MS);
+}
+function needsKnowledgePush(cache, fileName, contentHash, sweepDue = false) {
+  if (sweepDue) return true;
+  return cache.entries.get(fileName)?.knowledgeHash !== contentHash;
+}
+var MEMORY_SYNC_STATE_FILE, STATE_VERSION, KNOWLEDGE_FULL_SWEEP_MS;
+var init_memory_push_cache = __esm({
+  "src/tools/memory/memory-push-cache.ts"() {
+    "use strict";
+    MEMORY_SYNC_STATE_FILE = ".memory-sync-state.json";
+    STATE_VERSION = 1;
+    KNOWLEDGE_FULL_SWEEP_MS = 24 * 60 * 6e4;
+  }
+});
+
 // src/tools/memory/memory-knowledge-bridge.ts
 var memory_knowledge_bridge_exports = {};
 __export(memory_knowledge_bridge_exports, {
   extractMemoryTitle: () => extractMemoryTitle,
   upsertMemoryFilesAsKnowledge: () => upsertMemoryFilesAsKnowledge
 });
-import { existsSync as existsSync5, readdirSync as readdirSync4, readFileSync as readFileSync8 } from "node:fs";
+import { existsSync as existsSync7, readdirSync as readdirSync5, readFileSync as readFileSync13 } from "node:fs";
 function extractMemoryTitle(fileName, content) {
   const frontmatter = content.match(/^---\r?\n([\s\S]*?)\r?\n---/);
   if (frontmatter) {
@@ -336,13 +514,13 @@ function extractMemoryTitle(fileName, content) {
   return fileName;
 }
 async function upsertMemoryFilesAsKnowledge(options) {
-  const { controlPlaneUrl, token, memoryDir, fetchFn } = options;
+  const { controlPlaneUrl, token, memoryDir, fetchFn, cache, deadline } = options;
   let files;
   try {
-    if (!existsSync5(memoryDir)) {
-      return { attempted: 0, upserted: 0, failed: 0, failures: [] };
+    if (!existsSync7(memoryDir)) {
+      return { attempted: 0, upserted: 0, failed: 0, skipped: 0, failures: [] };
     }
-    files = readdirSync4(memoryDir).filter(
+    files = readdirSync5(memoryDir).filter(
       (f) => f.endsWith(".md") && f.toUpperCase() !== "MEMORY.MD"
     );
   } catch (err) {
@@ -350,54 +528,81 @@ async function upsertMemoryFilesAsKnowledge(options) {
       attempted: 0,
       upserted: 0,
       failed: 1,
+      skipped: 0,
       failures: [`memory dir scan: ${err instanceof Error ? err.message : String(err)}`]
     };
   }
-  let upserted = 0;
+  const sweepDue = cache ? knowledgeSweepDue(cache) : true;
+  const candidates = [];
   const failures = [];
+  let skipped = 0;
   for (const fileName of files) {
     try {
-      const content = readFileSync8(resolveMemoryFilePath(memoryDir, fileName), "utf8");
+      const content = readFileSync13(resolveMemoryFilePath(memoryDir, fileName), "utf8");
       if (content.length > CONTENT_HARD_LIMIT) {
         failures.push(`${fileName}: ${content.length} chars exceeds the ${CONTENT_HARD_LIMIT} server limit \u2014 split the memory file`);
         continue;
       }
-      const title = extractMemoryTitle(fileName, content);
-      const base = {
-        knowledge_class: "memory",
-        source_path: `memory/${fileName}`,
-        title,
-        content
-      };
-      const post = (body) => fetchFn(`${controlPlaneUrl}/api/v1/knowledge/private`, {
-        method: "POST",
-        headers: {
-          authorization: `Bearer ${token}`,
-          "content-type": "application/json"
-        },
-        body: JSON.stringify(body)
-      });
-      let response = await post({
-        ...base,
-        provenance: { written_by: "memory-bridge", source_kind: "operator_memory" }
-      });
-      if (response.status === 400) {
-        response = await post(base);
-      }
-      if (response.status >= 200 && response.status < 300) {
-        upserted += 1;
-      } else {
-        const text = await response.text();
-        failures.push(`${fileName}: HTTP ${response.status} ${text.slice(0, 80)}`);
+      const hash = sha256(content);
+      if (cache && !needsKnowledgePush(cache, fileName, hash, sweepDue)) {
+        skipped += 1;
+        continue;
       }
+      candidates.push({ fileName, content, hash });
     } catch (err) {
       failures.push(`${fileName}: ${err instanceof Error ? err.message : String(err)}`);
     }
   }
+  const url = `${controlPlaneUrl}/api/v1/knowledge/private`;
+  const outcomes = await mapWithConcurrency(candidates, options.concurrency ?? PUSH_CONCURRENCY, async (candidate) => {
+    deadline?.check();
+    const base = {
+      knowledge_class: "memory",
+      source_path: `memory/${candidate.fileName}`,
+      title: extractMemoryTitle(candidate.fileName, candidate.content),
+      content: candidate.content
+    };
+    const post = (body) => withRequestTimeout(url, () => fetchFn(url, {
+      method: "POST",
+      headers: {
+        authorization: `Bearer ${token}`,
+        "content-type": "application/json"
+      },
+      body: JSON.stringify(body)
+    }));
+    let response = await post({
+      ...base,
+      provenance: { written_by: "memory-bridge", source_kind: "operator_memory" }
+    });
+    if (response.status === 400) {
+      response = await post(base);
+    }
+    if (response.status >= 200 && response.status < 300) return true;
+    const text = await response.text();
+    throw new Error(`HTTP ${response.status} ${text.slice(0, 80)}`);
+  });
+  let upserted = 0;
+  for (let i = 0; i < outcomes.length; i++) {
+    const outcome = outcomes[i];
+    const candidate = candidates[i];
+    if (outcome.ok) {
+      upserted += 1;
+      if (cache) recordKnowledgePush(cache, candidate.fileName, candidate.hash);
+    } else {
+      const error = outcome.error;
+      failures.push(`${candidate.fileName}: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+  if (cache && sweepDue && failures.length === 0) {
+    cache.knowledgeSweptAtMs = Date.now();
+  }
   return {
+    // Every memory file this run considered. `attempted === upserted + skipped
+    // + failed` holds, so a caller can tell "nothing to do" from "nothing ran".
     attempted: files.length,
     upserted,
     failed: failures.length,
+    skipped,
     failures: failures.slice(0, 5)
   };
 }
@@ -406,12 +611,14 @@ var init_memory_knowledge_bridge = __esm({
   "src/tools/memory/memory-knowledge-bridge.ts"() {
     "use strict";
     init_safe_memory_file();
+    init_bounded_sync();
+    init_memory_push_cache();
     CONTENT_HARD_LIMIT = 5e5;
   }
 });
 
 // src/server.ts
-import { randomUUID as randomUUID2 } from "node:crypto";
+import { randomUUID as randomUUID3 } from "node:crypto";
 import { Server } from "@modelcontextprotocol/sdk/server/index.js";
 import {
   CallToolRequestSchema,
@@ -1339,6 +1546,42 @@ function toEventPerModelVerdicts(src) {
     };
   });
 }
+function aggregateEventTokenUsage(src, engineUsage) {
+  if (engineUsage !== void 0) {
+    const hasIn = Object.keys(engineUsage.per_model_tokens_in).length > 0;
+    const hasOut = Object.keys(engineUsage.per_model_tokens_out).length > 0;
+    return {
+      per_model_tokens_in: hasIn ? engineUsage.per_model_tokens_in : null,
+      per_model_tokens_out: hasOut ? engineUsage.per_model_tokens_out : null,
+      total_cost_usd: engineUsage.cost_micro_usd === null ? null : engineUsage.cost_micro_usd / 1e6
+    };
+  }
+  const tokensIn = {};
+  const tokensOut = {};
+  let anyTokensIn = false;
+  let anyTokensOut = false;
+  let costMicroUsd = 0;
+  let anyCost = false;
+  for (const v of src) {
+    if (typeof v.input_tokens === "number") {
+      tokensIn[v.model] = (tokensIn[v.model] ?? 0) + v.input_tokens;
+      anyTokensIn = true;
+    }
+    if (typeof v.output_tokens === "number") {
+      tokensOut[v.model] = (tokensOut[v.model] ?? 0) + v.output_tokens;
+      anyTokensOut = true;
+    }
+    if (typeof v.cost_micro_usd === "number") {
+      costMicroUsd += v.cost_micro_usd;
+      anyCost = true;
+    }
+  }
+  return {
+    per_model_tokens_in: anyTokensIn ? tokensIn : null,
+    per_model_tokens_out: anyTokensOut ? tokensOut : null,
+    total_cost_usd: anyCost ? costMicroUsd / 1e6 : null
+  };
+}
 function toEventSynthesizedVerdict(src) {
   return {
     verdict: src.verdict,
@@ -1710,7 +1953,8 @@ async function handleCheckHollowTest(deps, rawInput, signal) {
     synthesized_verdict: synthForEvent,
     consensus_confidence: engineResult.synthesized_verdict.confidence,
     duration_ms: engineResult.duration_ms,
-    consensus_engine_version: engineResult.engine_version
+    consensus_engine_version: engineResult.engine_version,
+    ...aggregateEventTokenUsage(engineResult.per_model_verdicts, engineResult.token_usage)
   };
   const payload = {
     verdict: engineResult.synthesized_verdict.verdict,
@@ -1892,7 +2136,8 @@ async function handleVerifyAnswer(deps, rawInput, signal) {
     synthesized_verdict: synthForEvent,
     consensus_confidence: engineResult.synthesized_verdict.confidence,
     duration_ms: engineResult.duration_ms,
-    consensus_engine_version: engineResult.engine_version
+    consensus_engine_version: engineResult.engine_version,
+    ...aggregateEventTokenUsage(engineResult.per_model_verdicts, engineResult.token_usage)
   };
   const payload = {
     verdict: engineResult.synthesized_verdict.verdict,
@@ -1901,6 +2146,7 @@ async function handleVerifyAnswer(deps, rawInput, signal) {
     synthesized_verdict: synthForEvent,
     engine_version: engineResult.engine_version,
     degraded: engineResult.degraded,
+    ...engineResult.quorum_failed === true ? { quorum_failed: true } : {},
     gate_type: gateType,
     ...kbResult.error !== null ? { kb_unavailable: true } : {},
     ...kbTruncated > 0 ? { kb_rules_truncated: kbTruncated } : {}
@@ -2154,7 +2400,8 @@ async function handleConsensusJudgment(deps, rawInput, signal) {
     duration_ms: engineResult.duration_ms,
     consensus_engine_version: engineResult.engine_version,
     per_model_verdicts: perModelForEvent,
-    synthesized_verdict: synthForEvent
+    synthesized_verdict: synthForEvent,
+    ...aggregateEventTokenUsage(engineResult.per_model_verdicts, engineResult.token_usage)
   };
   const payload = {
     verdict: engineResult.synthesized_verdict.verdict,
@@ -2163,6 +2410,7 @@ async function handleConsensusJudgment(deps, rawInput, signal) {
     synthesized_verdict: synthForEvent,
     engine_version: engineResult.engine_version,
     degraded: engineResult.degraded,
+    ...engineResult.quorum_failed === true ? { quorum_failed: true } : {},
     gate_type: gateType,
     // ─── Consensus-engine feature outputs (additive; 2026-06-13) ─────────────
     // Feature 2 (calibrated-confidence) — ON by default; the engine attaches
@@ -2361,7 +2609,8 @@ async function handleArchitectureReview(deps, rawInput, signal) {
     synthesized_verdict: synthForEvent,
     consensus_confidence: engineResult.synthesized_verdict.confidence,
     duration_ms: engineResult.duration_ms,
-    consensus_engine_version: engineResult.engine_version
+    consensus_engine_version: engineResult.engine_version,
+    ...aggregateEventTokenUsage(engineResult.per_model_verdicts, engineResult.token_usage)
   };
   const escalationRequired = engineResult.escalation_required === true || engineResult.escalation_required === void 0 && engineResult.synthesized_verdict.dissent_summary !== null;
   const escalationReason = engineResult.escalation_reason ?? engineResult.synthesized_verdict.dissent_summary ?? "";
@@ -3846,7 +4095,8 @@ Produce the JSON dispatch plan now.`;
     duration_ms: engineResult.duration_ms,
     consensus_engine_version: engineResult.engine_version,
     per_model_verdicts: toEventPerModelVerdicts(engineResult.per_model_verdicts),
-    synthesized_verdict: toEventSynthesizedVerdict(engineResult.synthesized_verdict)
+    synthesized_verdict: toEventSynthesizedVerdict(engineResult.synthesized_verdict),
+    ...aggregateEventTokenUsage(engineResult.per_model_verdicts, engineResult.token_usage)
   };
   deps.events.append(enrichedEvent);
   return jsonContent(envelope);
@@ -4588,7 +4838,8 @@ async function handleReviewMerge(deps, rawInput, signal) {
     duration_ms: result.duration_ms,
     consensus_engine_version: result.engine_version,
     per_model_verdicts: perModel,
-    synthesized_verdict: synth
+    synthesized_verdict: synth,
+    ...aggregateEventTokenUsage(result.per_model_verdicts, result.token_usage)
   });
 }
 
@@ -5492,50 +5743,294 @@ async function handleConciergeDispatch(deps, rawInput, _signal) {
 }
 
 // src/tools/memory/sync-config.ts
-import { homedir as homedir6 } from "node:os";
-import { join as join8 } from "node:path";
-import { existsSync as existsSync6, mkdirSync as mkdirSync5, readFileSync as readFileSync9, writeFileSync as writeFileSync4, readdirSync as readdirSync5 } from "node:fs";
+import { existsSync as existsSync8 } from "node:fs";
+import { homedir as homedir7 } from "node:os";
+import { join as join11 } from "node:path";
+
+// src/tools/memory/memory-sync-http.ts
 init_safe_memory_file();
-var TOOL_NAME22 = "vo_sync_config";
-var inputSchema22 = {
-  type: "object",
-  properties: {
-    action: {
-      type: "string",
-      enum: ["pull", "push"],
-      description: "pull: download cloud memory to local files. push: upload local files to cloud."
-    },
-    cwd: {
-      type: "string",
-      description: "Working directory to derive project slug from (default: process.cwd())."
+import { existsSync as existsSync5, mkdirSync as mkdirSync6, readFileSync as readFileSync11, writeFileSync as writeFileSync6, readdirSync as readdirSync4 } from "node:fs";
+
+// src/tools/memory/sync-lock.ts
+import { closeSync as closeSync2, mkdirSync as mkdirSync5, openSync as openSync3, readFileSync as readFileSync9, unlinkSync as unlinkSync2, writeFileSync as writeFileSync4 } from "node:fs";
+import { hostname } from "node:os";
+import { join as join8 } from "node:path";
+import { randomUUID as randomUUID2 } from "node:crypto";
+
+// src/tools/memory/sync-lock-liveness.ts
+import { statSync as statSync4, readFileSync as readFileSync8 } from "node:fs";
+function defaultIsProcessAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (err) {
+    return err.code === "EPERM";
+  }
+}
+function toPayload(parsed) {
+  if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) return null;
+  const record = parsed;
+  const token = record["token"];
+  const host = record["hostname"];
+  if (typeof token !== "string" || token.length === 0) return null;
+  const pid = record["pid"];
+  const acquiredAtMs = record["acquiredAtMs"];
+  return {
+    pid: typeof pid === "number" && Number.isInteger(pid) && pid > 0 ? pid : 0,
+    hostname: typeof host === "string" ? host : "",
+    sessionId: typeof record["sessionId"] === "string" ? record["sessionId"] : null,
+    token,
+    acquiredAt: typeof record["acquiredAt"] === "string" ? record["acquiredAt"] : "",
+    acquiredAtMs: typeof acquiredAtMs === "number" && Number.isFinite(acquiredAtMs) ? acquiredAtMs : Number.NaN
+  };
+}
+function readLockRecord(path3) {
+  let raw;
+  try {
+    raw = readFileSync8(path3, "utf8");
+  } catch {
+    return null;
+  }
+  try {
+    return { raw, payload: toPayload(JSON.parse(raw)) };
+  } catch {
+    return { raw, payload: null };
+  }
+}
+function lockAgeMs(record, path3, nowMs) {
+  let startedMs = Number.NaN;
+  if (record.payload) {
+    if (Number.isFinite(record.payload.acquiredAtMs)) {
+      startedMs = record.payload.acquiredAtMs;
+    } else if (record.payload.acquiredAt) {
+      startedMs = Date.parse(record.payload.acquiredAt);
     }
-  },
-  required: ["action"],
-  additionalProperties: false
-};
-var description22 = "Syncs memory entries between local ~/.claude/projects/<slug>/memory/ and cloud control-plane /api/v1/agent-config/memory/me. Requires operator auth (vo-mcp login). Actions: pull (cloud\u2192local), push (local\u2192cloud). Idempotent; push creates/updates as needed.";
-function isToolInput22(v) {
-  if (typeof v !== "object" || v === null) return false;
-  const o = v;
-  if (o["action"] !== "pull" && o["action"] !== "push") return false;
-  if (o["cwd"] !== void 0 && typeof o["cwd"] !== "string") return false;
-  return true;
+  }
+  if (!Number.isFinite(startedMs)) {
+    try {
+      startedMs = statSync4(path3).mtimeMs;
+    } catch {
+      return null;
+    }
+  }
+  const age = nowMs - startedMs;
+  return Number.isFinite(age) && age >= 0 ? age : null;
 }
-function deriveProjectSlug(cwd) {
-  return cwd.replace(/([^:\\/])[\\/]+$/, "$1").replace(/\\/g, "/").replace(/^([a-zA-Z]):/, (_m, drive) => `${drive.toUpperCase()}:`).replace(/[^a-zA-Z0-9]/g, "-");
+function classifyHolderLiveness(record, isProcessAlive, thisHost) {
+  const payload = record.payload;
+  if (payload === null) return "unknown";
+  if (payload.pid <= 0) return "unknown";
+  if (thisHost.length === 0) return "unknown";
+  if (payload.hostname !== thisHost) return "unknown";
+  return isProcessAlive(payload.pid) ? "alive" : "dead";
 }
-function getMemoryDir(cwd) {
-  const slug = deriveProjectSlug(cwd);
-  return join8(homedir6(), ".claude", "projects", slug, "memory");
+function isLockAbandoned(record, ageMs, ttlMs, isProcessAlive, thisHost) {
+  const liveness = classifyHolderLiveness(record, isProcessAlive, thisHost);
+  if (liveness === "alive") return false;
+  if (liveness === "dead") return true;
+  return ageMs !== null && ageMs > ttlMs;
 }
+
+// src/tools/memory/sync-lock.ts
+var MEMORY_SYNC_LOCK_FILE = ".memory-sync.lock";
+var DEFAULT_LOCK_TTL_MS = 15 * 6e4;
+var DEFAULT_LOCK_WAIT_MS = 1e4;
+var INITIAL_BACKOFF_MS = 25;
+var MAX_BACKOFF_MS = 500;
+var BACKOFF_FACTOR = 1.6;
+function positiveOr(value, fallback) {
+  return typeof value === "number" && Number.isFinite(value) && value >= 0 ? value : fallback;
+}
+function createExclusive2(path3, contents) {
+  let fd;
+  try {
+    fd = openSync3(path3, "wx");
+  } catch (err) {
+    const code = err.code;
+    return { ok: false, exists: code === "EEXIST", message: err instanceof Error ? err.message : String(err) };
+  }
+  try {
+    writeFileSync4(fd, contents, "utf8");
+  } catch (err) {
+    closeSync2(fd);
+    try {
+      unlinkSync2(path3);
+    } catch {
+    }
+    return { ok: false, exists: false, message: err instanceof Error ? err.message : String(err) };
+  }
+  closeSync2(fd);
+  return { ok: true };
+}
+function removeAbandoned(path3, expectedRaw) {
+  let current;
+  try {
+    current = readFileSync9(path3, "utf8");
+  } catch {
+    return;
+  }
+  if (current !== expectedRaw) return;
+  try {
+    unlinkSync2(path3);
+  } catch {
+  }
+}
+function makeRelease(path3, token) {
+  let released = false;
+  return () => {
+    if (released) return;
+    released = true;
+    let raw;
+    try {
+      raw = readFileSync9(path3, "utf8");
+    } catch {
+      return;
+    }
+    let stillOurs;
+    try {
+      stillOurs = toPayload(JSON.parse(raw))?.token === token;
+    } catch {
+      stillOurs = false;
+    }
+    if (!stillOurs) return;
+    try {
+      unlinkSync2(path3);
+    } catch {
+    }
+  };
+}
+function describeHolder(record) {
+  const payload = record?.payload;
+  if (!payload) return "an unreadable lock file";
+  return `pid ${payload.pid} on ${payload.hostname || "(unknown host)"} (session ${payload.sessionId ?? "unknown"}, held since ${payload.acquiredAt || "unknown"})`;
+}
+async function acquireMemorySyncLock(options) {
+  const waitMs = positiveOr(options.waitMs, DEFAULT_LOCK_WAIT_MS);
+  const ttlMs = positiveOr(options.ttlMs, DEFAULT_LOCK_TTL_MS);
+  const now = options.now ?? Date.now;
+  const sleep = options.sleep ?? ((ms) => new Promise((resolve3) => {
+    setTimeout(resolve3, ms);
+  }));
+  const isProcessAlive = options.isProcessAlive ?? defaultIsProcessAlive;
+  const thisHost = hostname();
+  const path3 = join8(options.memoryDir, MEMORY_SYNC_LOCK_FILE);
+  if (options.createDir === true) mkdirSync5(options.memoryDir, { recursive: true });
+  const deadline = now() + waitMs;
+  let backoffMs = INITIAL_BACKOFF_MS;
+  let tookOverFrom = null;
+  let holderDescription = "another session";
+  for (; ; ) {
+    const acquiredAtMs = now();
+    const payload = {
+      pid: process.pid,
+      hostname: thisHost,
+      sessionId: options.sessionId ?? null,
+      token: randomUUID2(),
+      acquiredAt: new Date(acquiredAtMs).toISOString(),
+      acquiredAtMs
+    };
+    const created = createExclusive2(path3, `${JSON.stringify(payload, null, 2)}
+`);
+    if (created.ok) {
+      return { path: path3, payload, tookOverFrom, release: makeRelease(path3, payload.token) };
+    }
+    if (!created.exists) {
+      throw new Error(
+        `memory sync lock ${path3} could not be created (${created.message}) \u2014 refusing to sync without exclusion`
+      );
+    }
+    const record = readLockRecord(path3);
+    let reclaimed = false;
+    if (record) {
+      holderDescription = describeHolder(record);
+      const age = lockAgeMs(record, path3, now());
+      if (isLockAbandoned(record, age, ttlMs, isProcessAlive, thisHost)) {
+        tookOverFrom = record.payload;
+        removeAbandoned(path3, record.raw);
+        reclaimed = true;
+      }
+    }
+    if (now() >= deadline) {
+      throw new Error(
+        `memory sync lock ${path3} is held by ${holderDescription}; waited ${waitMs}ms \u2014 refusing to sync unlocked (concurrent memory writes corrupt the shared index). If that holder is provably gone, delete the lock file.`
+      );
+    }
+    if (reclaimed) backoffMs = INITIAL_BACKOFF_MS;
+    await sleep(Math.max(1, Math.min(backoffMs, deadline - now())));
+    if (!reclaimed) backoffMs = Math.min(MAX_BACKOFF_MS, Math.ceil(backoffMs * BACKOFF_FACTOR));
+  }
+}
+async function withMemorySyncLock(options, fn) {
+  const handle = await acquireMemorySyncLock(options);
+  try {
+    return await fn(handle);
+  } finally {
+    handle.release();
+  }
+}
+
+// src/tools/memory/memory-index-merge.ts
+var MEMORY_INDEX_FILE = "MEMORY.md";
+function isMemoryIndexFile(fileName) {
+  return fileName.toUpperCase() === MEMORY_INDEX_FILE.toUpperCase();
+}
+var INDEX_ROW_RE = /^\s*[-*]\s+\[[^\]]*\]\(([^)]+)\)/;
+function indexRowKey(line) {
+  const match = INDEX_ROW_RE.exec(line);
+  if (!match) return null;
+  let target = match[1].trim();
+  if (target.startsWith("<") && target.endsWith(">")) target = target.slice(1, -1).trim();
+  target = target.replace(/\s+(["'])[\s\S]*\1$/, "").trim();
+  if (!/^[a-z][a-z0-9+.-]*:\/\//i.test(target)) {
+    target = target.replace(/\\/g, "/").replace(/\/{2,}/g, "/");
+    target = target.replace(/^(?:\.\/)+/, "");
+  }
+  return target.length > 0 ? target.toLowerCase() : null;
+}
+function mergeMemoryIndex(localContent, cloudContent) {
+  if (typeof cloudContent !== "string" || cloudContent.trim().length === 0) {
+    return { content: localContent, addedFromCloud: [] };
+  }
+  const eol = localContent.includes("\r\n") ? "\r\n" : "\n";
+  const localLines = localContent.split(/\r?\n/);
+  const localKeys = /* @__PURE__ */ new Set();
+  let lastLocalRowIndex = -1;
+  for (let i = 0; i < localLines.length; i++) {
+    const key = indexRowKey(localLines[i]);
+    if (key === null) continue;
+    localKeys.add(key);
+    lastLocalRowIndex = i;
+  }
+  const addedFromCloud = [];
+  const seenCloudKeys = /* @__PURE__ */ new Set();
+  for (const rawLine of cloudContent.split(/\r?\n/)) {
+    const key = indexRowKey(rawLine);
+    if (key === null) continue;
+    if (localKeys.has(key) || seenCloudKeys.has(key)) continue;
+    seenCloudKeys.add(key);
+    addedFromCloud.push(rawLine.replace(/\r$/, ""));
+  }
+  if (addedFromCloud.length === 0) {
+    return { content: localContent, addedFromCloud: [] };
+  }
+  const merged = lastLocalRowIndex >= 0 ? [...localLines.slice(0, lastLocalRowIndex + 1), ...addedFromCloud, ...localLines.slice(lastLocalRowIndex + 1)] : [...localLines, ...addedFromCloud];
+  return { content: merged.join(eol), addedFromCloud };
+}
+
+// src/tools/memory/memory-sync-http.ts
+init_bounded_sync();
+init_memory_push_cache();
 async function pullMemory(controlPlaneUrl, token, memoryDir, fetchFn) {
   const url = `${controlPlaneUrl}/api/v1/agent-config/memory/me`;
-  const response = await fetchFn(url, {
-    method: "GET",
-    headers: {
-      authorization: `Bearer ${token}`
-    }
-  });
+  const response = await withRequestTimeout(
+    url,
+    () => fetchFn(url, {
+      method: "GET",
+      headers: {
+        authorization: `Bearer ${token}`
+      }
+    })
+  );
   if (response.status !== 200) {
     const text = await response.text();
     throw new Error(`GET /api/v1/agent-config/memory/me returned HTTP ${response.status}: ${text.slice(0, 200)}`);
@@ -5548,103 +6043,246 @@ async function pullMemory(controlPlaneUrl, token, memoryDir, fetchFn) {
     entry,
     filePath: resolveMemoryFilePath(memoryDir, entry.file_name)
   }));
-  mkdirSync5(memoryDir, { recursive: true });
+  mkdirSync6(memoryDir, { recursive: true });
   const files = [];
   for (const { entry, filePath } of writes) {
-    writeFileSync4(filePath, entry.content, "utf8");
+    writeFileSync6(filePath, entry.content, "utf8");
     files.push(entry.file_name);
   }
   return { pulled: data.entries.length, files };
 }
-async function pushMemory(controlPlaneUrl, token, memoryDir, sessionId, fetchFn) {
-  if (!existsSync6(memoryDir)) {
-    return { pushed: 0, created: 0, updated: 0 };
+function listPushableFiles(memoryDir) {
+  return readdirSync4(memoryDir).filter((f) => f.endsWith(".md") && f !== MEMORY_SYNC_LOCK_FILE);
+}
+async function uploadOne(item, controlPlaneUrl, token, sessionId, fetchFn, deadline) {
+  deadline.check();
+  if (item.memoryId !== null) {
+    const updateUrl = `${controlPlaneUrl}/api/v1/agent-config/memory/${item.memoryId}`;
+    const updateBody = { content: item.content, session_id: sessionId };
+    const updateResponse = await withRequestTimeout(
+      updateUrl,
+      () => fetchFn(updateUrl, {
+        method: "PUT",
+        headers: { authorization: `Bearer ${token}`, "content-type": "application/json" },
+        body: JSON.stringify(updateBody)
+      })
+    );
+    if (updateResponse.status !== 200) {
+      const text = await updateResponse.text();
+      throw new Error(
+        `PUT /api/v1/agent-config/memory/${item.memoryId} returned HTTP ${updateResponse.status}: ${text.slice(0, 200)}`
+      );
+    }
+    const updateData = JSON.parse(await updateResponse.text());
+    if (!updateData.ok) throw new Error(`PUT /api/v1/agent-config/memory/${item.memoryId} returned ok=false`);
+    return "updated";
+  }
+  const createUrl = `${controlPlaneUrl}/api/v1/agent-config/memory/me`;
+  const createBody = {
+    entry_type: item.entryType,
+    file_name: item.fileName,
+    content: item.content,
+    session_id: sessionId
+  };
+  const createResponse = await withRequestTimeout(
+    createUrl,
+    () => fetchFn(createUrl, {
+      method: "POST",
+      headers: { authorization: `Bearer ${token}`, "content-type": "application/json" },
+      body: JSON.stringify(createBody)
+    })
+  );
+  if (createResponse.status !== 200 && createResponse.status !== 201) {
+    const text = await createResponse.text();
+    throw new Error(
+      `POST /api/v1/agent-config/memory/me returned HTTP ${createResponse.status}: ${text.slice(0, 200)}`
+    );
+  }
+  const createData = JSON.parse(await createResponse.text());
+  if (!createData.ok) throw new Error("POST /api/v1/agent-config/memory/me returned ok=false");
+  return "created";
+}
+async function pushMemory(controlPlaneUrl, token, memoryDir, sessionId, fetchFn, options = {}) {
+  const empty = { pushed: 0, created: 0, updated: 0, skipped: 0, indexRowsPreserved: 0 };
+  if (!existsSync5(memoryDir)) {
+    return empty;
   }
-  const localFiles = readdirSync5(memoryDir).filter((f) => f.endsWith(".md")).map((f) => ({
+  const localFiles = listPushableFiles(memoryDir).map((f) => ({
     file_name: f,
-    content: readFileSync9(resolveMemoryFilePath(memoryDir, f), "utf8"),
-    entry_type: f === "MEMORY.md" ? "index" : "topic"
+    content: readFileSync11(resolveMemoryFilePath(memoryDir, f), "utf8"),
+    entry_type: isMemoryIndexFile(f) ? "index" : "topic"
   }));
   if (localFiles.length === 0) {
-    return { pushed: 0, created: 0, updated: 0 };
+    return empty;
   }
+  const deadline = options.deadline ?? createSyncDeadline();
+  const cache = options.cache ?? readPushCache(memoryDir, controlPlaneUrl);
+  deadline.check();
   const getUrl = `${controlPlaneUrl}/api/v1/agent-config/memory/me`;
-  const getResponse = await fetchFn(getUrl, {
-    method: "GET",
-    headers: {
-      authorization: `Bearer ${token}`
-    }
-  });
+  const getResponse = await withRequestTimeout(
+    getUrl,
+    () => fetchFn(getUrl, { method: "GET", headers: { authorization: `Bearer ${token}` } })
+  );
   const existingMap = /* @__PURE__ */ new Map();
   if (getResponse.status === 200) {
     const getData = JSON.parse(await getResponse.text());
     if (getData.ok && Array.isArray(getData.entries)) {
       for (const entry of getData.entries) {
-        existingMap.set(entry.file_name, entry.memory_id);
+        existingMap.set(entry.file_name, {
+          memoryId: entry.memory_id,
+          content: typeof entry.content === "string" ? entry.content : ""
+        });
       }
     }
   }
+  const toUpload = [];
+  let skipped = 0;
+  for (const localFile of localFiles) {
+    const existing = existingMap.get(localFile.file_name);
+    let content = localFile.content;
+    let rowsPreserved = 0;
+    if (localFile.entry_type === "index") {
+      const merged = mergeMemoryIndex(localFile.content, existing?.content);
+      content = merged.content;
+      rowsPreserved = merged.addedFromCloud.length;
+    }
+    const payloadHash = sha256(content);
+    if (!needsMemoryPush(cache, localFile.file_name, payloadHash, existing !== void 0)) {
+      skipped++;
+      continue;
+    }
+    toUpload.push({
+      fileName: localFile.file_name,
+      entryType: localFile.entry_type,
+      content,
+      payloadHash,
+      memoryId: existing?.memoryId ?? null,
+      rowsPreserved
+    });
+  }
+  const outcomes = await mapWithConcurrency(
+    toUpload,
+    options.concurrency ?? PUSH_CONCURRENCY,
+    (item) => uploadOne(item, controlPlaneUrl, token, sessionId, fetchFn, deadline)
+  );
   let created = 0;
   let updated = 0;
-  for (const localFile of localFiles) {
-    const memoryId = existingMap.get(localFile.file_name);
-    if (memoryId) {
-      const updateUrl = `${controlPlaneUrl}/api/v1/agent-config/memory/${memoryId}`;
-      const updateBody = {
-        content: localFile.content,
-        session_id: sessionId
-      };
-      const updateResponse = await fetchFn(updateUrl, {
-        method: "PUT",
-        headers: {
-          authorization: `Bearer ${token}`,
-          "content-type": "application/json"
-        },
-        body: JSON.stringify(updateBody)
-      });
-      if (updateResponse.status !== 200) {
-        const text = await updateResponse.text();
-        throw new Error(
-          `PUT /api/v1/agent-config/memory/${memoryId} returned HTTP ${updateResponse.status}: ${text.slice(0, 200)}`
-        );
-      }
-      const updateData = JSON.parse(await updateResponse.text());
-      if (!updateData.ok) {
-        throw new Error(`PUT /api/v1/agent-config/memory/${memoryId} returned ok=false`);
-      }
-      updated++;
-    } else {
-      const createUrl = `${controlPlaneUrl}/api/v1/agent-config/memory/me`;
-      const createBody = {
-        entry_type: localFile.entry_type,
-        file_name: localFile.file_name,
-        content: localFile.content,
-        session_id: sessionId
-      };
-      const createResponse = await fetchFn(createUrl, {
-        method: "POST",
-        headers: {
-          authorization: `Bearer ${token}`,
-          "content-type": "application/json"
-        },
-        body: JSON.stringify(createBody)
-      });
-      if (createResponse.status !== 200 && createResponse.status !== 201) {
-        const text = await createResponse.text();
-        throw new Error(
-          `POST /api/v1/agent-config/memory/me returned HTTP ${createResponse.status}: ${text.slice(0, 200)}`
-        );
-      }
-      const createData = JSON.parse(await createResponse.text());
-      if (!createData.ok) {
-        throw new Error("POST /api/v1/agent-config/memory/me returned ok=false");
-      }
-      created++;
+  let indexRowsPreserved = 0;
+  let firstError;
+  for (let i = 0; i < outcomes.length; i++) {
+    const outcome = outcomes[i];
+    const item = toUpload[i];
+    if (outcome.ok) {
+      if (outcome.value === "created") created++;
+      else updated++;
+      indexRowsPreserved += item.rowsPreserved;
+      recordMemoryPush(cache, item.fileName, item.payloadHash);
+    } else if (firstError === void 0) {
+      firstError = outcome.error;
+    }
+  }
+  pruneMissing(cache, localFiles.map((f) => f.file_name));
+  if (options.persistCache ?? options.cache === void 0) writePushCache(memoryDir, cache);
+  if (firstError !== void 0) throw firstError;
+  return { pushed: created + updated, created, updated, skipped, indexRowsPreserved };
+}
+
+// src/tools/memory/sync-config.ts
+init_bounded_sync();
+init_memory_push_cache();
+
+// src/tools/memory/sync-kill-switch.ts
+import { existsSync as existsSync6, readFileSync as readFileSync12 } from "node:fs";
+import { homedir as homedir6 } from "node:os";
+import { join as join10 } from "node:path";
+var MEMORY_SYNC_DISABLE_ENV = "VO_MCP_DISABLE_MEMORY_SYNC";
+var MEMORY_SYNC_DISABLE_SENTINEL = "vo-memory-sync-disabled";
+var NEGATIONS = /* @__PURE__ */ new Set(["0", "false", "no"]);
+var MAX_LOGGED_VALUE = 32;
+function memorySyncSentinelPath(home) {
+  return join10(home, ".claude", MEMORY_SYNC_DISABLE_SENTINEL);
+}
+function isKillSwitchValueOn(raw) {
+  if (raw === void 0 || raw === null) return false;
+  const v = raw.trim().toLowerCase();
+  if (v === "") return false;
+  return !NEGATIONS.has(v);
+}
+function clip(raw) {
+  const v = raw.trim();
+  return v.length > MAX_LOGGED_VALUE ? `${v.slice(0, MAX_LOGGED_VALUE)}\u2026` : v;
+}
+function evaluateMemorySyncKillSwitch(deps = {}) {
+  const env = deps.env ?? process.env;
+  const home = deps.home ?? homedir6();
+  const fileExists = deps.fileExists ?? existsSync6;
+  const readFile3 = deps.readFile ?? ((p) => readFileSync12(p, "utf8"));
+  const fired = [];
+  const rawEnv = env[MEMORY_SYNC_DISABLE_ENV];
+  if (isKillSwitchValueOn(rawEnv)) {
+    fired.push(`env ${MEMORY_SYNC_DISABLE_ENV}=${clip(rawEnv)}`);
+  }
+  const sentinel = memorySyncSentinelPath(home);
+  let sentinelPresent;
+  try {
+    sentinelPresent = fileExists(sentinel);
+  } catch {
+    sentinelPresent = false;
+  }
+  if (sentinelPresent) {
+    let contents = "";
+    let readable = true;
+    try {
+      contents = readFile3(sentinel);
+    } catch {
+      readable = false;
+    }
+    if (!readable || isKillSwitchValueOn(contents) || contents.trim() === "") {
+      fired.push(`sentinel file ${sentinel}`);
     }
   }
-  return { pushed: localFiles.length, created, updated };
+  if (fired.length === 0) return { disabled: false, reason: null };
+  return { disabled: true, reason: `memory sync DISABLED by ${fired.join(" + ")}` };
 }
-async function runMemorySync(action, cwd, sessionId, fetchFn = globalThis.fetch) {
+
+// src/tools/memory/sync-config.ts
+var TOOL_NAME22 = "vo_sync_config";
+var inputSchema22 = {
+  type: "object",
+  properties: {
+    action: {
+      type: "string",
+      enum: ["pull", "push"],
+      description: "pull: download cloud memory to local files. push: upload local files to cloud."
+    },
+    cwd: {
+      type: "string",
+      description: "Working directory to derive project slug from (default: process.cwd())."
+    }
+  },
+  required: ["action"],
+  additionalProperties: false
+};
+var description22 = "Syncs memory entries between local ~/.claude/projects/<slug>/memory/ and cloud control-plane /api/v1/agent-config/memory/me. Requires operator auth (vo-mcp login). Actions: pull (cloud\u2192local), push (local\u2192cloud). Idempotent; push creates/updates as needed. Serialized across concurrent sessions by an exclusive lock in the memory dir.";
+function isToolInput22(v) {
+  if (typeof v !== "object" || v === null) return false;
+  const o = v;
+  if (o["action"] !== "pull" && o["action"] !== "push") return false;
+  if (o["cwd"] !== void 0 && typeof o["cwd"] !== "string") return false;
+  return true;
+}
+function deriveProjectSlug(cwd) {
+  return cwd.replace(/([^:\\/])[\\/]+$/, "$1").replace(/\\/g, "/").replace(/^([a-zA-Z]):/, (_m, drive) => `${drive.toUpperCase()}:`).replace(/[^a-zA-Z0-9]/g, "-");
+}
+function getMemoryDir(cwd) {
+  const slug = deriveProjectSlug(cwd);
+  return join11(homedir7(), ".claude", "projects", slug, "memory");
+}
+async function runMemorySync(action, cwd, sessionId, fetchFn = globalThis.fetch, lockOptions = {}) {
+  const killSwitch = evaluateMemorySyncKillSwitch();
+  if (killSwitch.disabled) {
+    return { synced: false, reason: killSwitch.reason };
+  }
   const controlPlaneUrl = process.env["VO_CONTROL_PLANE_URL"];
   if (!controlPlaneUrl) {
     return { synced: false, reason: "VO_CONTROL_PLANE_URL not set \u2014 cloud mode disabled" };
@@ -5661,39 +6299,79 @@ async function runMemorySync(action, cwd, sessionId, fetchFn = globalThis.fetch)
   }
   const memoryDir = getMemoryDir(cwd);
   const baseUrl = controlPlaneUrl.replace(/\/+$/, "");
-  try {
-    if (action === "pull") {
-      const result2 = await pullMemory(baseUrl, token, memoryDir, fetchFn);
-      return { synced: true, action: "pull", pulled: result2.pulled, files: result2.files, memory_dir: memoryDir };
-    }
-    const result = await pushMemory(baseUrl, token, memoryDir, sessionId, fetchFn);
-    let bridge = { upserted: 0, failed: 0, failures: [] };
-    try {
-      const { upsertMemoryFilesAsKnowledge: upsertMemoryFilesAsKnowledge2 } = await Promise.resolve().then(() => (init_memory_knowledge_bridge(), memory_knowledge_bridge_exports));
-      bridge = await upsertMemoryFilesAsKnowledge2({
-        controlPlaneUrl: baseUrl,
-        token,
-        memoryDir,
-        fetchFn
-      });
-    } catch (err) {
-      bridge = {
-        upserted: 0,
-        failed: 1,
-        failures: [`bridge unavailable: ${err instanceof Error ? err.message : String(err)}`]
-      };
-    }
+  if (action === "push" && !existsSync8(memoryDir)) {
     return {
       synced: true,
       action: "push",
-      pushed: result.pushed,
-      created: result.created,
-      updated: result.updated,
-      memory_dir: memoryDir,
-      knowledge_upserted: bridge.upserted,
-      knowledge_failed: bridge.failed,
-      ...bridge.failed > 0 ? { knowledge_failures: bridge.failures } : {}
+      pushed: 0,
+      created: 0,
+      updated: 0,
+      skipped: 0,
+      index_rows_preserved: 0,
+      knowledge_upserted: 0,
+      knowledge_failed: 0,
+      memory_dir: memoryDir
     };
+  }
+  try {
+    return await withMemorySyncLock({ ...lockOptions, memoryDir, sessionId, createDir: action === "pull" }, async (lock) => {
+      const takeover = lock.tookOverFrom ? { lock_taken_over_from_pid: lock.tookOverFrom.pid } : {};
+      if (action === "pull") {
+        const result2 = await pullMemory(baseUrl, token, memoryDir, fetchFn);
+        return {
+          synced: true,
+          action: "pull",
+          pulled: result2.pulled,
+          files: result2.files,
+          memory_dir: memoryDir,
+          ...takeover
+        };
+      }
+      const deadline = createSyncDeadline();
+      const cache = readPushCache(memoryDir, baseUrl);
+      let result;
+      try {
+        result = await pushMemory(baseUrl, token, memoryDir, sessionId, fetchFn, { cache, deadline });
+      } catch (err) {
+        writePushCache(memoryDir, cache);
+        throw err;
+      }
+      let bridge;
+      try {
+        const { upsertMemoryFilesAsKnowledge: upsertMemoryFilesAsKnowledge2 } = await Promise.resolve().then(() => (init_memory_knowledge_bridge(), memory_knowledge_bridge_exports));
+        bridge = await upsertMemoryFilesAsKnowledge2({
+          controlPlaneUrl: baseUrl,
+          token,
+          memoryDir,
+          fetchFn,
+          cache,
+          deadline
+        });
+      } catch (err) {
+        bridge = {
+          upserted: 0,
+          failed: 1,
+          skipped: 0,
+          failures: [`bridge unavailable: ${err instanceof Error ? err.message : String(err)}`]
+        };
+      }
+      writePushCache(memoryDir, cache);
+      return {
+        synced: true,
+        action: "push",
+        pushed: result.pushed,
+        created: result.created,
+        updated: result.updated,
+        skipped: result.skipped,
+        index_rows_preserved: result.indexRowsPreserved,
+        memory_dir: memoryDir,
+        knowledge_upserted: bridge.upserted,
+        knowledge_failed: bridge.failed,
+        knowledge_skipped: bridge.skipped,
+        ...bridge.failed > 0 ? { knowledge_failures: bridge.failures } : {},
+        ...takeover
+      };
+    });
   } catch (err) {
     const message = err instanceof Error ? err.message : String(err);
     return { synced: false, reason: `Sync failed: ${message}` };
@@ -5980,12 +6658,12 @@ async function handleHqWhiteboardRead(_deps, rawInput, signal) {
 }
 
 // src/tools/skills/skill-corpus.ts
-import { existsSync as existsSync7, statSync as statSync5 } from "node:fs";
-import { dirname as dirname5, isAbsolute, join as join10, resolve as resolve2 } from "node:path";
+import { existsSync as existsSync9, statSync as statSync6 } from "node:fs";
+import { dirname as dirname5, isAbsolute, join as join13, resolve as resolve2 } from "node:path";
 
 // ../skill-registry/src/loader.ts
-import { readdirSync as readdirSync6, readFileSync as readFileSync10, statSync as statSync4 } from "node:fs";
-import { join as join9 } from "node:path";
+import { readdirSync as readdirSync6, readFileSync as readFileSync14, statSync as statSync5 } from "node:fs";
+import { join as join12 } from "node:path";
 var InvalidSkillFrontmatterError = class extends Error {
   constructor(skillFile, reason) {
     super(`Invalid frontmatter in ${skillFile}: ${reason}`);
@@ -6038,18 +6716,18 @@ function loadSkillsFromDir(skillsDir) {
   const entries = readdirSync6(skillsDir);
   const skills = [];
   for (const entry of entries) {
-    const entryPath = join9(skillsDir, entry);
+    const entryPath = join12(skillsDir, entry);
     let stat;
     try {
-      stat = statSync4(entryPath);
+      stat = statSync5(entryPath);
     } catch {
       continue;
     }
     if (!stat.isDirectory()) continue;
-    const skillFile = join9(entryPath, "SKILL.md");
+    const skillFile = join12(entryPath, "SKILL.md");
     let raw;
     try {
-      raw = readFileSync10(skillFile, "utf8");
+      raw = readFileSync14(skillFile, "utf8");
     } catch {
       continue;
     }
@@ -6090,12 +6768,12 @@ function resolveSkillsDir(env = process.env, startDir = process.cwd()) {
   const override = env.VO_SKILLS_DIR;
   if (typeof override === "string" && override.length > 0) {
     const abs = isAbsolute(override) ? override : resolve2(startDir, override);
-    return existsSync7(abs) && statSync5(abs).isDirectory() ? abs : null;
+    return existsSync9(abs) && statSync6(abs).isDirectory() ? abs : null;
   }
   let dir = resolve2(startDir);
   for (let i = 0; i < MAX_WALK_UP_LEVELS; i += 1) {
-    const candidate = join10(dir, ".claude", "skills");
-    if (existsSync7(candidate) && statSync5(candidate).isDirectory()) return candidate;
+    const candidate = join13(dir, ".claude", "skills");
+    if (existsSync9(candidate) && statSync6(candidate).isDirectory()) return candidate;
     const parent = dirname5(dir);
     if (parent === dir) break;
     dir = parent;
@@ -6406,7 +7084,7 @@ function buildToolRegistry() {
   };
 }
 function createServer(options) {
-  const sessionId = options.sessionId ?? randomUUID2();
+  const sessionId = options.sessionId ?? randomUUID3();
   const mode = createLocalMode();
   const now = options.now ?? (() => /* @__PURE__ */ new Date());
   const server = new Server(
@@ -6458,8 +7136,8 @@ function listToolNames() {
 }
 
 // src/cache/sqlite-cache.ts
-import { createHash as createHash3 } from "node:crypto";
-import { chmodSync as chmodSync3, mkdirSync as mkdirSync6 } from "node:fs";
+import { createHash as createHash4 } from "node:crypto";
+import { chmodSync as chmodSync3, mkdirSync as mkdirSync7 } from "node:fs";
 import { dirname as dirname6 } from "node:path";
 import { DatabaseSync } from "node:sqlite";
 
@@ -6505,7 +7183,7 @@ function normalizeString(s) {
 function createSqliteCache(options) {
   const fileBacked = options.dbPath !== ":memory:";
   if (fileBacked) {
-    mkdirSync6(dirname6(options.dbPath), { recursive: true, mode: 448 });
+    mkdirSync7(dirname6(options.dbPath), { recursive: true, mode: 448 });
   }
   const versionNamespace = options.cacheVersionNamespace ?? "";
   const db = new DatabaseSync(options.dbPath);
@@ -6536,7 +7214,7 @@ function createSqliteCache(options) {
   return {
     keyFor(toolName, input, opts) {
       const canonical = canonicalize(input, opts);
-      const hash = createHash3("sha256");
+      const hash = createHash4("sha256");
       if (versionNamespace.length > 0) {
         hash.update(versionNamespace);
         hash.update("|");
@@ -6628,7 +7306,7 @@ function createStubRatchetClient() {
         let m;
         while ((m = pat.regex.exec(req.source)) !== null) {
           findings.push({
-            line_excerpt: clip(m[0], 80),
+            line_excerpt: clip2(m[0], 80),
             severity: pat.severity,
             code: pat.code,
             message: pat.message
@@ -6660,7 +7338,7 @@ function createStubRatchetClient() {
     }
   };
 }
-function clip(s, n) {
+function clip2(s, n) {
   return s.length <= n ? s : s.slice(0, n) + "\u2026";
 }
 function buildSummary2(args) {
@@ -6689,7 +7367,7 @@ function createNullConsensusEngineClient(reason = NULL_CLIENT_DEFAULT_REASON) {
 }
 
 // src/consensus/engine-client.ts
-import { randomUUID as randomUUID3 } from "node:crypto";
+import { randomUUID as randomUUID4 } from "node:crypto";
 
 // src/consensus/meta-model-caller.ts
 var META_CONSENSUS_MODEL = "muse-spark-1.1";
@@ -6798,6 +7476,14 @@ function shadowEnabled(env) {
   const norm = raw.trim().toLowerCase();
   return !(norm === "0" || norm === "false" || norm === "no" || norm === "off" || norm === "");
 }
+var MIN_RESPONDERS_ENV_VAR = "VO_CONSENSUS_MIN_RESPONDERS";
+function resolveMinResponders(env) {
+  const raw = (env ?? {})[MIN_RESPONDERS_ENV_VAR];
+  if (raw === void 0 || raw.trim() === "") return 2;
+  const parsed = Number.parseInt(raw.trim(), 10);
+  if (!Number.isFinite(parsed) || parsed <= 0) return void 0;
+  return parsed;
+}
 function mapShadowSynthesis(s) {
   if (s === void 0) return void 0;
   return {
@@ -6947,9 +7633,11 @@ function createEngineConsensusClient(options) {
           ...options.agreement_gate_enabled !== void 0 ? { configEnabled: options.agreement_gate_enabled } : {},
           ...options.env !== void 0 ? { env: options.env } : {}
         });
+        const minResponders = resolveMinResponders(options.env);
         const engineOptions = {
           panel,
           ...options.per_model_timeout_ms !== void 0 ? { per_model_timeout_ms: options.per_model_timeout_ms } : {},
+          ...minResponders !== void 0 ? { min_responders: minResponders } : {},
           ...agreementGate !== void 0 ? { agreement_gate: agreementGate } : {},
           // Stage A7-shadow: run the adaptive verdict alongside the live one for grading.
           // Cheap (pure log-odds over already-fetched verdicts; no extra model calls),
@@ -7002,8 +7690,13 @@ function createEngineConsensusClient(options) {
           synthesized_verdict: response.synthesized_verdict,
           per_model_verdicts: response.per_model_verdicts,
           degraded: response.degraded,
+          ...response.quorum_failed === true ? { quorum_failed: true } : {},
           duration_ms: response.duration_ms,
           engine_version: response.engine_version,
+          // Cumulative cross-round inference usage (B44-3). Absent when no panel
+          // member reported usage; forwarded verbatim — the aggregator prefers it
+          // over summing final-round verdicts (which under-reports deliberation).
+          ...response.token_usage !== void 0 ? { token_usage: response.token_usage } : {},
           // Phase 2 Lane D-1 — forward escalation signal when present. The
           // source-grounded layer's own escalation (from the citation grade)
           // takes precedence when set, else the synthesizer's.