@askexenow/exe-os 0.9.357 → 0.9.359

package/dist/{chunk-YQ7IZPVC.js → chunk-PDRIIEFV.js}

@@ -1,6 +1,6 @@
 import {
   canonicalizeStackManifest
-} from "./chunk-JZXHLDQN.js";
+} from "./chunk-APR556TY.js";
 
 // src/lib/stack-manifest-write.ts
 import { readFileSync, writeFileSync } from "fs";

package/dist/{chunk-W3REQ37P.js → chunk-PLOEFBFW.js}

@@ -1,9 +1,9 @@
 import {
   storeBehavior
-} from "./chunk-FWJFKWYA.js";
+} from "./chunk-6LY3QSJA.js";
 import {
   getClient
-} from "./chunk-M5DPPJLS.js";
+} from "./chunk-EA5FVACM.js";
 import {
   loadConfig
 } from "./chunk-BCZF3AGJ.js";

package/dist/{chunk-X4EDW3FH.js → chunk-POZGQQEZ.js}

@@ -1,6 +1,6 @@
 import {
   getClient
-} from "./chunk-M5DPPJLS.js";
+} from "./chunk-EA5FVACM.js";
 
 // src/lib/orchestration-events.ts
 import crypto from "crypto";

package/dist/{chunk-AJGTBW3N.js → chunk-QH2XAUZ5.js}

@@ -263,7 +263,7 @@ async function runRegistryProxy(options = registryProxyOptionsFromEnv()) {
   await new Promise((resolve) => server.listen(options.port, options.host, resolve));
   console.log(`exe-registry-proxy listening on ${options.host ?? "0.0.0.0"}:${options.port}`);
   console.log(`proxying /v2/${options.allowedNamespace ?? "askexe"}/* -> ${options.upstream ?? "https://ghcr.io"}`);
-  const { licenseSyncConfigFromEnv, startLicenseSyncScheduler } = await import("./license-sync-JVEXPDHN.js");
+  const { licenseSyncConfigFromEnv, startLicenseSyncScheduler } = await import("./license-sync-XFDOXL3Z.js");
   const syncConfig = licenseSyncConfigFromEnv();
   if (syncConfig) {
     startLicenseSyncScheduler(syncConfig);

package/dist/{chunk-6CZXY5BD.js → chunk-QROIFRKI.js}

@@ -1,24 +1,24 @@
 import {
   recordSessionKill
-} from "./chunk-TAR5J7WI.js";
+} from "./chunk-XVTKJEI2.js";
 import {
   sessionScopeFilter,
   verifyPaneAtCapacity,
   writeNotification
-} from "./chunk-YSUHXDQU.js";
+} from "./chunk-74R44E4S.js";
 import {
   listSessions
-} from "./chunk-PM4TIRCR.js";
+} from "./chunk-3ODATKWH.js";
 import {
   getTransport
 } from "./chunk-UXLO7VHX.js";
 import {
   recordOrchestrationEventBestEffort
-} from "./chunk-X4EDW3FH.js";
+} from "./chunk-POZGQQEZ.js";
 import {
   getClient,
   isCoordinatorName
-} from "./chunk-M5DPPJLS.js";
+} from "./chunk-EA5FVACM.js";
 
 // src/lib/capacity-monitor.ts
 var CAPACITY_PATTERNS = [

package/dist/{chunk-P2Y6S53G.js → chunk-R6LNQAUG.js}

@@ -1,6 +1,6 @@
 import {
   getGlobalProceduresBlock
-} from "./chunk-KP3PLOGC.js";
+} from "./chunk-NP2Y7P3I.js";
 
 // src/lib/employee-templates.ts
 var BASE_OPERATING_PROCEDURES = `

package/dist/{chunk-JKOEOHOD.js → chunk-R7F6HKTH.js}

@@ -1,10 +1,11 @@
+import {
+  filterTimerWakeClusterArtifacts
+} from "./chunk-YQGMSXT5.js";
+
 // src/lib/daemon-restart-report.ts
 import { existsSync, readFileSync, statSync, openSync, readSync, closeSync } from "fs";
 import path from "path";
 import os from "os";
-var SUSPEND_CLUSTER_MIN_MS = 6e4;
-var SUSPEND_CLUSTER_WINDOW_MS = 2e3;
-var SUSPEND_CLUSTER_MIN_TIMERS = 2;
 function logDir() {
   return path.join(os.homedir(), ".exe-os", "logs");
 }
@@ -84,23 +85,6 @@ function parseTsMs(ts) {
   const parsed = Date.parse(ts);
   return Number.isFinite(parsed) ? parsed : null;
 }
-function filterTimerSleepArtifacts(samples) {
-  const clockClean = samples.filter((sample) => sample.durationMs >= 0);
-  const candidates = clockClean.filter((sample) => sample.atMs !== null && sample.durationMs >= SUSPEND_CLUSTER_MIN_MS).sort((a, b) => a.atMs - b.atMs);
-  const suspendArtifacts = /* @__PURE__ */ new Set();
-  let start = 0;
-  for (let end = 0; end < candidates.length; end++) {
-    while (candidates[end].atMs - candidates[start].atMs > SUSPEND_CLUSTER_WINDOW_MS) {
-      start++;
-    }
-    const window = candidates.slice(start, end + 1);
-    const distinctTimers = new Set(window.map((sample) => sample.timer));
-    if (distinctTimers.size >= SUSPEND_CLUSTER_MIN_TIMERS) {
-      for (const sample of window) suspendArtifacts.add(sample);
-    }
-  }
-  return clockClean.filter((sample) => !suspendArtifacts.has(sample));
-}
 function maxIso(a, b) {
   if (!b) return a;
   if (!a) return b;
@@ -153,8 +137,9 @@ function buildRestartReport(opts = {}) {
     if (data.clockJump === true || sleptMs > 1e3) continue;
     rawTimerSamples.push({ timer, durationMs, atMs: parseTsMs(rec.ts) });
   }
+  const clockCleanTimerSamples = rawTimerSamples.filter((sample) => sample.durationMs >= 0);
   const timerSamples = /* @__PURE__ */ new Map();
-  for (const { timer, durationMs } of filterTimerSleepArtifacts(rawTimerSamples)) {
+  for (const { timer, durationMs } of filterTimerWakeClusterArtifacts(clockCleanTimerSamples)) {
     const arr = timerSamples.get(timer) ?? [];
     arr.push(durationMs);
     timerSamples.set(timer, arr);

package/dist/{chunk-6WAJJN5W.js → chunk-RFUTLZ2U.js}

@@ -4,10 +4,10 @@ import {
 import {
   reserveVersions,
   vectorToBlob
-} from "./chunk-WHQYVFE2.js";
+} from "./chunk-W5YV2PZE.js";
 import {
   getClient
-} from "./chunk-M5DPPJLS.js";
+} from "./chunk-EA5FVACM.js";
 
 // src/lib/documents.ts
 import crypto from "crypto";
@@ -270,7 +270,7 @@ async function ingestDocument(input) {
   await client.batch([documentStmt, ...chunkStmts], "write");
   const embedded = vectors.filter((v) => v !== null).length;
   const originalTexts = input.chunks.map((c) => c.text);
-  import("./doc-graph-extractor-NFERAJNP.js").then(
+  import("./doc-graph-extractor-FNCYPFKY.js").then(
     ({ extractAndStoreDocumentGraph }) => extractAndStoreDocumentGraph(documentId, originalTexts)
   ).catch((err) => {
     process.stderr.write(

package/dist/{chunk-CQPFNVWY.js → chunk-RJ67HG2P.js}

@@ -1,9 +1,9 @@
 import {
   fastDbInit
-} from "./chunk-QXAE6S3A.js";
+} from "./chunk-YMCIZCNK.js";
 import {
   sessionScopeFilter
-} from "./chunk-YSUHXDQU.js";
+} from "./chunk-74R44E4S.js";
 import {
   formatStatusAll,
   formatStatusDeep,
@@ -14,7 +14,7 @@ import {
   getClient,
   isCoordinatorRole,
   loadEmployees
-} from "./chunk-M5DPPJLS.js";
+} from "./chunk-EA5FVACM.js";
 import {
   isMainModule
 } from "./chunk-6Y4B3QF6.js";

package/dist/{chunk-6H4ZEU7P.js → chunk-SHEWTDPC.js}

@@ -1,13 +1,13 @@
 import {
   deactivateBehavior
-} from "./chunk-FWJFKWYA.js";
+} from "./chunk-6LY3QSJA.js";
 import {
   getActiveAgent
-} from "./chunk-YNYISUMW.js";
+} from "./chunk-WRP5AG4D.js";
 import {
   canCoordinate,
   getClient
-} from "./chunk-M5DPPJLS.js";
+} from "./chunk-EA5FVACM.js";
 
 // src/mcp/tools/deactivate-behavior.ts
 import { z } from "zod";
@@ -24,7 +24,7 @@ function registerDeactivateBehavior(server) {
     async ({ behavior_id }) => {
       const caller = getActiveAgent();
       try {
-        const { StewardGate } = await import("./steward-gate-R2XWABMV.js");
+        const { StewardGate } = await import("./steward-gate-CIOBPNX6.js");
         const steward = new StewardGate();
         const gateDecision = await steward.checkAuthority(caller.agentId || "unknown", "deactivate_behavior", behavior_id);
         if (!gateDecision.allowed) {

package/dist/{chunk-XPGUSSG7.js → chunk-SIGAQQHW.js}

@@ -119,7 +119,7 @@ function releaseBackfillLock() {
 }
 async function getTaskAwareCapacity() {
   const { getClient } = await import("./lib/database.js");
-  const { sessionScopeFilter } = await import("./task-scope-74ZIFQRH.js");
+  const { sessionScopeFilter } = await import("./task-scope-44N7XP5N.js");
   const client = getClient();
   const scope = sessionScopeFilter();
   const result = await client.execute({

package/dist/{chunk-PUNCHUEX.js → chunk-SNWV44E5.js}

@@ -4,17 +4,17 @@ import {
   resolveExeSession,
   sendIntercom,
   strictSessionScopeFilter
-} from "./chunk-YSUHXDQU.js";
+} from "./chunk-74R44E4S.js";
 import {
   parseMessage,
   serializeMessage
 } from "./chunk-4JERP7NT.js";
 import {
   recordOrchestrationEventBestEffort
-} from "./chunk-X4EDW3FH.js";
+} from "./chunk-POZGQQEZ.js";
 import {
   getClient
-} from "./chunk-M5DPPJLS.js";
+} from "./chunk-EA5FVACM.js";
 
 // src/lib/messaging.ts
 import crypto from "crypto";

package/dist/{chunk-WJIGSNJM.js → chunk-SQBNN44X.js}

@@ -1,15 +1,12 @@
 import {
   isPaneBusy
-} from "./chunk-NT4GET5B.js";
+} from "./chunk-G2KK64UB.js";
 import {
   recordSessionKill
-} from "./chunk-TAR5J7WI.js";
-import {
-  eventLoopBlockedMarkerPath
-} from "./chunk-APRVAUOR.js";
+} from "./chunk-XVTKJEI2.js";
 import {
   updateTask
-} from "./chunk-ZMVVKOOS.js";
+} from "./chunk-2EAYZ3BK.js";
 import {
   countPendingReviews,
   ensureEmployeeAsync,
@@ -25,14 +22,14 @@ import {
   sessionScopeFilter,
   strictSessionScopeFilter,
   writeNotification
-} from "./chunk-YSUHXDQU.js";
+} from "./chunk-74R44E4S.js";
 import {
   LEASE_MINUTES,
   isLeaseExpired
 } from "./chunk-E23LNUWJ.js";
 import {
   listSessions
-} from "./chunk-PM4TIRCR.js";
+} from "./chunk-3ODATKWH.js";
 import {
   getTransport
 } from "./chunk-UXLO7VHX.js";
@@ -44,7 +41,7 @@ import {
 } from "./chunk-SKGMF2SO.js";
 import {
   recordOrchestrationEventBestEffort
-} from "./chunk-X4EDW3FH.js";
+} from "./chunk-POZGQQEZ.js";
 import {
   checkDispatchStatus,
   readTerminalLauncherFailure,
@@ -62,7 +59,10 @@ import {
   getCoordinatorName,
   isCoordinatorName,
   shouldAutoInstance
-} from "./chunk-M5DPPJLS.js";
+} from "./chunk-EA5FVACM.js";
+import {
+  eventLoopBlockedMarkerPath
+} from "./chunk-JY5GAZYC.js";
 import {
   loadConfigSync
 } from "./chunk-BCZF3AGJ.js";
@@ -3194,7 +3194,7 @@ async function reapOrphanedWorktrees(deps, nowMs = Date.now()) {
 }
 async function createWorktreeReaperRealDeps() {
   const { getPaneCwdAsync } = await import("./lib/tmux-status.js");
-  const { getGitRootAsync, isWorktreeDirtyAsync } = await import("./worktree-EUYBBABA.js");
+  const { getGitRootAsync, isWorktreeDirtyAsync } = await import("./worktree-NNVXVV6A.js");
   const { statSync: statSync3 } = await import("fs");
   const { basename: basename2 } = await import("path");
   const { promisify: promisify2 } = await import("util");
@@ -3425,7 +3425,7 @@ async function gcStaleCheckpoints() {
 }
 async function pollTaskGroupBarriers() {
   try {
-    const { checkAndFireBarriers } = await import("./tasks-crud-N54JZCXU.js");
+    const { checkAndFireBarriers } = await import("./tasks-crud-IWVDREXG.js");
     const firedGroupIds = await checkAndFireBarriers();
     if (firedGroupIds.length === 0) return 0;
     const { getClient } = await import("./lib/database.js");

package/dist/{chunk-6UTP7AIH.js → chunk-STFR72YH.js}

@@ -1,7 +1,7 @@
 import {
   getIdentity,
   loadEmployeesSync
-} from "./chunk-M5DPPJLS.js";
+} from "./chunk-EA5FVACM.js";
 
 // src/lib/drift-probes.ts
 var DRIFT_THRESHOLD = 80;

package/dist/chunk-TWMWHDOY.js

@@ -0,0 +1,79 @@
+// src/internal/sync-key-store.ts
+import crypto from "crypto";
+var ALGORITHM = "aes-256-gcm";
+var IV_LENGTH = 12;
+var TAG_LENGTH = 16;
+var DEK_LENGTH = 32;
+var PK_HASH_LENGTH = 8;
+var X25519_PUB_LENGTH = 32;
+var SYNC_HKDF_INFO = "exe-mem-sync-v2";
+var SYNC_BLOB_VERSION = 1;
+var ENVELOPE_BLOB_VERSION = 2;
+var CURRENT_KEY_ID = 0;
+var VERSIONED_HEADER_LENGTH = 2;
+var RECIPIENT_SYMMETRIC = 0;
+var RECIPIENT_X25519 = 1;
+var SYM_RECIPIENT_LENGTH = 1 + IV_LENGTH + DEK_LENGTH + TAG_LENGTH;
+var X25519_RECIPIENT_LENGTH = 1 + PK_HASH_LENGTH + X25519_PUB_LENGTH + IV_LENGTH + DEK_LENGTH + TAG_LENGTH;
+var _syncKey = null;
+function initSyncKey(masterKey) {
+  if (masterKey.length !== 32) {
+    throw new Error(`Master key must be 32 bytes, got ${masterKey.length}`);
+  }
+  _syncKey = Buffer.from(crypto.hkdfSync("sha256", masterKey, "", SYNC_HKDF_INFO, 32));
+}
+function isSyncKeyInitialized() {
+  return _syncKey !== null;
+}
+function requireSyncKey() {
+  if (!_syncKey) {
+    throw new Error("Sync crypto not initialized. Call initSyncCrypto(masterKey) first.");
+  }
+  return _syncKey;
+}
+function wrapDek(dek, wrapKey, aad) {
+  const iv = crypto.randomBytes(IV_LENGTH);
+  const cipher = crypto.createCipheriv(ALGORITHM, wrapKey, iv);
+  cipher.setAAD(aad);
+  const wrapped = Buffer.concat([cipher.update(dek), cipher.final()]);
+  const tag = cipher.getAuthTag();
+  return Buffer.concat([iv, wrapped, tag]);
+}
+function unwrapDek(iv, wrapped, tag, wrapKey, aad) {
+  const decipher = crypto.createDecipheriv(ALGORITHM, wrapKey, iv);
+  decipher.setAAD(aad);
+  decipher.setAuthTag(tag);
+  return Buffer.concat([decipher.update(wrapped), decipher.final()]);
+}
+function wrapDekForCurrentDevice(dek) {
+  const sym = wrapDek(dek, requireSyncKey(), Buffer.from([RECIPIENT_SYMMETRIC]));
+  return Buffer.concat([Buffer.from([RECIPIENT_SYMMETRIC]), sym]);
+}
+function v2PayloadAad(keyId, recipientCount, recipientBytes) {
+  const digest = crypto.createHash("sha256").update(recipientBytes).digest();
+  return Buffer.concat([Buffer.from([ENVELOPE_BLOB_VERSION, keyId, recipientCount]), digest]);
+}
+
+export {
+  ALGORITHM,
+  IV_LENGTH,
+  TAG_LENGTH,
+  DEK_LENGTH,
+  PK_HASH_LENGTH,
+  X25519_PUB_LENGTH,
+  SYNC_BLOB_VERSION,
+  ENVELOPE_BLOB_VERSION,
+  CURRENT_KEY_ID,
+  VERSIONED_HEADER_LENGTH,
+  RECIPIENT_SYMMETRIC,
+  RECIPIENT_X25519,
+  SYM_RECIPIENT_LENGTH,
+  X25519_RECIPIENT_LENGTH,
+  initSyncKey,
+  isSyncKeyInitialized,
+  requireSyncKey,
+  wrapDek,
+  unwrapDek,
+  wrapDekForCurrentDevice,
+  v2PayloadAad
+};

package/dist/{chunk-RZSPCNLY.js → chunk-UZ5RJYL3.js}

@@ -1,6 +1,6 @@
 import {
   completeReminder
-} from "./chunk-VPMAC5VB.js";
+} from "./chunk-OY2PWHYR.js";
 
 // src/mcp/tools/complete-reminder.ts
 import { z } from "zod";

package/dist/chunk-V3W3SATA.js

@@ -0,0 +1,135 @@
+import {
+  eventLoopHeartbeatPath,
+  exeDir
+} from "./chunk-JY5GAZYC.js";
+
+// src/lib/mcp-health.ts
+import { existsSync, readFileSync, statSync } from "fs";
+import net from "net";
+import path from "path";
+function daemonPidPath() {
+  return process.env.EXE_DAEMON_PID ?? process.env.EXE_EMBED_PID ?? path.join(exeDir(), "exed.pid");
+}
+function daemonSockPath() {
+  return process.env.EXE_DAEMON_SOCK ?? process.env.EXE_EMBED_SOCK ?? path.join(exeDir(), "exed.sock");
+}
+var SOCKET_PING_TIMEOUT_MS = 300;
+var HEARTBEAT_FRESH_MS = 6e4;
+function isDaemonAlive() {
+  if (_isDaemonProcess) {
+    return { alive: true, pid: process.pid };
+  }
+  try {
+    const pidPath = daemonPidPath();
+    if (!existsSync(pidPath)) {
+      if (existsSync(daemonSockPath())) return { alive: true, pid: null };
+      return { alive: false, pid: null };
+    }
+    const pid = parseInt(readFileSync(pidPath, "utf8").trim(), 10);
+    if (!Number.isFinite(pid) || pid <= 0) return { alive: false, pid: null };
+    process.kill(pid, 0);
+    return { alive: true, pid };
+  } catch {
+    return { alive: false, pid: null };
+  }
+}
+function pingUnixSocket(socketPath, timeoutMs) {
+  return new Promise((resolve) => {
+    let settled = false;
+    const finish = (result) => {
+      if (settled) return;
+      settled = true;
+      try {
+        sock.destroy();
+      } catch {
+      }
+      resolve(result);
+    };
+    const sock = net.connect(socketPath);
+    sock.once("connect", () => finish("alive"));
+    sock.once("error", (err) => {
+      const code = err?.code;
+      finish(
+        code === "ECONNREFUSED" || code === "ENOENT" || code === "ENOTSOCK" || code === "ENOTDIR" ? "dead" : "indeterminate"
+      );
+    });
+    sock.setTimeout(timeoutMs, () => finish("indeterminate"));
+  });
+}
+function livePidWithFreshHeartbeat() {
+  let pidAlive = false;
+  try {
+    const pidPath = daemonPidPath();
+    if (existsSync(pidPath)) {
+      const pid = parseInt(readFileSync(pidPath, "utf8").trim(), 10);
+      if (Number.isFinite(pid) && pid > 0) {
+        try {
+          process.kill(pid, 0);
+          pidAlive = true;
+        } catch {
+          pidAlive = false;
+        }
+      }
+    }
+  } catch {
+    pidAlive = false;
+  }
+  if (!pidAlive) return false;
+  try {
+    const st = statSync(eventLoopHeartbeatPath());
+    return Date.now() - st.mtimeMs <= HEARTBEAT_FRESH_MS;
+  } catch {
+    return false;
+  }
+}
+async function isDaemonWriterAuthority() {
+  if (_isDaemonProcess) return true;
+  const socketPath = daemonSockPath();
+  const ping = await pingUnixSocket(socketPath, SOCKET_PING_TIMEOUT_MS);
+  if (ping !== "dead") return true;
+  return livePidWithFreshHeartbeat();
+}
+async function directWriterAllowed() {
+  if (process.env.VITEST) return true;
+  if (process.env.EXE_IS_DAEMON === "1" || _isDaemonProcess) return true;
+  if (process.env.EXE_DB_DIRECT === "1") return true;
+  return !await isDaemonWriterAuthority();
+}
+function isMcpHealthy(_timeoutMs = 2e3) {
+  if (_isDaemonProcess) return true;
+  const { alive } = isDaemonAlive();
+  if (!alive) return false;
+  return existsSync(daemonSockPath());
+}
+var _isDaemonProcess = false;
+function markAsDaemonProcess() {
+  _isDaemonProcess = true;
+}
+var EVENT_LOOP_DEGRADED_THRESHOLD_MS = 5e3;
+var _eventLoopLagMs = 0;
+var _eventLoopLagUpdatedAt = 0;
+function setEventLoopLagMs(lagMs) {
+  _eventLoopLagMs = lagMs;
+  _eventLoopLagUpdatedAt = Date.now();
+}
+function getEventLoopLagMs() {
+  return _eventLoopLagMs;
+}
+function getEventLoopLagUpdatedAt() {
+  return _eventLoopLagUpdatedAt;
+}
+function isEventLoopDegraded() {
+  return _eventLoopLagMs > EVENT_LOOP_DEGRADED_THRESHOLD_MS;
+}
+
+export {
+  isDaemonAlive,
+  isDaemonWriterAuthority,
+  directWriterAllowed,
+  isMcpHealthy,
+  markAsDaemonProcess,
+  setEventLoopLagMs,
+  getEventLoopLagMs,
+  getEventLoopLagUpdatedAt,
+  isEventLoopDegraded
+};

package/dist/{chunk-WL3CT5KX.js → chunk-VCCZQDCU.js}

@@ -9,10 +9,10 @@ import {
 import {
   buildClaudeHttpMcpEntry,
   buildClaudeStdioProxyMcpEntry
-} from "./chunk-34MIJGQS.js";
+} from "./chunk-6EOLGE7T.js";
 import {
   ensureAllAgentSymlinks
-} from "./chunk-X7CWCQ5S.js";
+} from "./chunk-CAEWPEBA.js";
 import {
   MCP_LEGACY_KEY,
   MCP_PRIMARY_KEY

package/dist/{chunk-VU2MZ7BP.js → chunk-VNK3MNZE.js}

@@ -7,6 +7,9 @@ import {
   isClientConnected,
   sendDaemonRequest
 } from "./chunk-W6UB2AWP.js";
+import {
+  directWriterAllowed
+} from "./chunk-V3W3SATA.js";
 
 // src/lib/db-daemon-client.ts
 function normalizeStatement(stmt) {
@@ -92,6 +95,9 @@ function createDaemonDbClient(fallbackClient) {
     return false;
   }
   const unavailableForMcp = (errMsg) => daemonMcpOpError(errMsg);
+  const daemonAliveNoWriterError = (context) => new Error(
+    `Daemon is alive but its socket was unavailable for a ${context}; refusing a direct SQLite WRITER fallback to preserve the single-writer gate (bug 4a6f8aaf). Retry \u2014 the daemon socket typically re-handshakes within a moment.`
+  );
   const client = {
     // Daemon-routed clients cannot span a transaction across requests —
     // BEGIN/COMMIT via execute() is rejected by the daemon SQL guard.
@@ -103,6 +109,10 @@ function createDaemonDbClient(fallbackClient) {
       const daemonReady = await ensureDaemonRoute();
       if (!daemonReady) {
         if (isMcpProcess()) throw unavailableForMcp();
+        const stmtSql = typeof stmt === "string" ? stmt : stmt.sql;
+        if (!isReadOnlySql(stmtSql) && !await directWriterAllowed()) {
+          throw daemonAliveNoWriterError("direct DB write");
+        }
         return fallbackClient.execute(stmt);
       }
       const { sql, args } = normalizeStatement(stmt);
@@ -146,6 +156,12 @@ function createDaemonDbClient(fallbackClient) {
       const daemonReady = await ensureDaemonRoute();
       if (!daemonReady) {
         if (isMcpProcess()) throw unavailableForMcp();
+        const readOnlyBatch = stmts.every(
+          (s) => isReadOnlySql(typeof s === "string" ? s : s.sql)
+        );
+        if (!readOnlyBatch && !await directWriterAllowed()) {
+          throw daemonAliveNoWriterError("direct DB batch write");
+        }
         return fallbackClient.batch(stmts, mode);
       }
       const statements = stmts.map(normalizeStatement);
@@ -192,16 +208,37 @@ function createDaemonDbClient(fallbackClient) {
       process.stderr.write("[db-daemon] Unexpected batch response shape, falling back to direct\n");
       return fallbackClient.batch(stmts, mode);
     },
-    // Transaction support — delegate to fallback (transactions need direct connection)
+    // Transaction support — needs a direct connection. Single-writer gate (bug
+    // 4a6f8aaf / df26c896, ADR-016): these escape hatches must NOT open a direct
+    // WRITER while the daemon holds writer authority (including the boot window —
+    // an alive-but-slow daemon), or an external CLI holding this client could
+    // corrupt FTS5 under the live daemon. Authority is the STRONG async
+    // directWriterAllowed() (isDaemonWriterAuthority), not a stale sync flag. Fail
+    // closed exactly like execute()/batch(); daemonless / EXE_DB_DIRECT keep direct
+    // access. Multi-statement writes should use batch() (atomic, daemon-side).
+    // S1 (df26c896): an MCP process is refused UNCONDITIONALLY — even during a
+    // daemon outage (directWriterAllowed() === true) — mirroring execute()/batch().
+    // Otherwise N MCP agents in an outage could each open a direct writer and race
+    // FTS5. MCP work always funnels through the daemon; it never writes directly.
     async transaction(mode) {
+      if (isMcpProcess()) throw unavailableForMcp("direct DB transaction");
+      if (!await directWriterAllowed()) throw daemonAliveNoWriterError("direct DB transaction");
       return fallbackClient.transaction(mode);
     },
-    // executeMultiple — delegate to fallback (used only for schema migrations)
+    // executeMultiple — delegate to fallback (used only for schema migrations).
+    // Same single-writer gate: DDL via a second direct writer is refused while
+    // the daemon holds writer authority. Schema is the daemon's responsibility
+    // (its own boot ensureSchema). S1: MCP refused unconditionally (see above).
     async executeMultiple(sql) {
+      if (isMcpProcess()) throw unavailableForMcp("direct DB executeMultiple");
+      if (!await directWriterAllowed()) throw daemonAliveNoWriterError("direct DB executeMultiple");
       return fallbackClient.executeMultiple(sql);
     },
-    // migrate — delegate to fallback
+    // migrate — delegate to fallback. Same single-writer gate. S1: MCP refused
+    // unconditionally (see transaction()).
     async migrate(stmts) {
+      if (isMcpProcess()) throw unavailableForMcp("direct DB migrate");
+      if (!await directWriterAllowed()) throw daemonAliveNoWriterError("direct DB migrate");
       return fallbackClient.migrate(stmts);
     },
     // Sync mode — delegate to fallback