@askexenow/exe-os 0.9.105 → 0.9.106

package/dist/bin/exe-heartbeat.js

@@ -1860,7 +1860,15 @@ function getClient() {
   if (!_resilientClient) {
     return _adapterClient;
   }
-  return _resilientClient;
+  if (process.env.EXE_DB_READONLY === "1") {
+    return _resilientClient;
+  }
+  process.stderr.write(
+    "[database] ERROR: Daemon is not running \u2014 refusing direct SQLite write access.\n[database] Direct writes bypass the single-writer gate and corrupt FTS5 indexes.\n[database] Restart the daemon: kill $(cat ~/.exe-os/exed.pid) && exe-os update\n[database] Or set EXE_DB_READONLY=1 if you only need read access.\n"
+  );
+  throw new Error(
+    "Daemon not running. Direct SQLite writes are blocked to prevent FTS5 corruption. Restart daemon or set EXE_DB_READONLY=1 for read-only access."
+  );
 }
 async function initDaemonClient() {
   if (process.env.DATABASE_URL && process.env.EXE_USE_POSTGRES === "1") return;
@@ -4548,12 +4556,6 @@ var init_platform_procedures = __esm({
         priority: "p0",
         content: "When you dispatch work, you OWN the review. Check list_tasks(status='needs_review') on EVERY prompt \u2014 don't wait for intercom nudges (they're unreliable). When a task shows needs_review: (1) read the deliverable (git diff in worktree, exe/output/ files, or task result summary), (2) verify it works (tsc, build, run), (3) close_task if good or create a fix task if not. Reviews sitting >30 minutes is a pipeline stall. The whole chain: worker calls update_task(done) \u2192 system flags needs_review \u2192 manager pulls and verifies \u2192 close_task \u2192 COO reviews manager's work \u2192 merge to main. Every level actively pulls \u2014 nobody waits."
       },
-      {
-        title: "Bug fix lifecycle \u2014 triage upstream after every verified fix so customers see the status",
-        domain: "workflow",
-        priority: "p0",
-        content: "When a bug from support(action='list_bugs') is fixed and verified, the reviewer MUST triage it upstream: support(action='triage_bug', id='<bug-id>', notes='<what was fixed>', fixed_version='<version>', linked_commit='<hash>'). This closes the bug in the customer's view \u2014 their COO checks list_my_bugs and sees status change from open \u2192 closed with the fix version. Without triage, customers see 'open' forever even after the fix ships. Same for feature requests: support(action='triage_feature', ..., shipped_version='<version>'). Triage is part of the review gate \u2014 a fix is not done until the upstream report is closed."
-      },
       {
         title: "Intercom is a speedup, not delivery \u2014 DB is the source of truth",
         domain: "architecture",

package/dist/bin/exe-kill.js

@@ -1821,7 +1821,15 @@ function getClient() {
   if (!_resilientClient) {
     return _adapterClient;
   }
-  return _resilientClient;
+  if (process.env.EXE_DB_READONLY === "1") {
+    return _resilientClient;
+  }
+  process.stderr.write(
+    "[database] ERROR: Daemon is not running \u2014 refusing direct SQLite write access.\n[database] Direct writes bypass the single-writer gate and corrupt FTS5 indexes.\n[database] Restart the daemon: kill $(cat ~/.exe-os/exed.pid) && exe-os update\n[database] Or set EXE_DB_READONLY=1 if you only need read access.\n"
+  );
+  throw new Error(
+    "Daemon not running. Direct SQLite writes are blocked to prevent FTS5 corruption. Restart daemon or set EXE_DB_READONLY=1 for read-only access."
+  );
 }
 async function initDaemonClient() {
   if (process.env.DATABASE_URL && process.env.EXE_USE_POSTGRES === "1") return;
@@ -4509,12 +4517,6 @@ var init_platform_procedures = __esm({
         priority: "p0",
         content: "When you dispatch work, you OWN the review. Check list_tasks(status='needs_review') on EVERY prompt \u2014 don't wait for intercom nudges (they're unreliable). When a task shows needs_review: (1) read the deliverable (git diff in worktree, exe/output/ files, or task result summary), (2) verify it works (tsc, build, run), (3) close_task if good or create a fix task if not. Reviews sitting >30 minutes is a pipeline stall. The whole chain: worker calls update_task(done) \u2192 system flags needs_review \u2192 manager pulls and verifies \u2192 close_task \u2192 COO reviews manager's work \u2192 merge to main. Every level actively pulls \u2014 nobody waits."
       },
-      {
-        title: "Bug fix lifecycle \u2014 triage upstream after every verified fix so customers see the status",
-        domain: "workflow",
-        priority: "p0",
-        content: "When a bug from support(action='list_bugs') is fixed and verified, the reviewer MUST triage it upstream: support(action='triage_bug', id='<bug-id>', notes='<what was fixed>', fixed_version='<version>', linked_commit='<hash>'). This closes the bug in the customer's view \u2014 their COO checks list_my_bugs and sees status change from open \u2192 closed with the fix version. Without triage, customers see 'open' forever even after the fix ships. Same for feature requests: support(action='triage_feature', ..., shipped_version='<version>'). Triage is part of the review gate \u2014 a fix is not done until the upstream report is closed."
-      },
       {
         title: "Intercom is a speedup, not delivery \u2014 DB is the source of truth",
         domain: "architecture",

package/dist/bin/exe-launch-agent.js

@@ -1919,7 +1919,15 @@ function getClient() {
   if (!_resilientClient) {
     return _adapterClient;
   }
-  return _resilientClient;
+  if (process.env.EXE_DB_READONLY === "1") {
+    return _resilientClient;
+  }
+  process.stderr.write(
+    "[database] ERROR: Daemon is not running \u2014 refusing direct SQLite write access.\n[database] Direct writes bypass the single-writer gate and corrupt FTS5 indexes.\n[database] Restart the daemon: kill $(cat ~/.exe-os/exed.pid) && exe-os update\n[database] Or set EXE_DB_READONLY=1 if you only need read access.\n"
+  );
+  throw new Error(
+    "Daemon not running. Direct SQLite writes are blocked to prevent FTS5 corruption. Restart daemon or set EXE_DB_READONLY=1 for read-only access."
+  );
 }
 async function initDaemonClient() {
   if (process.env.DATABASE_URL && process.env.EXE_USE_POSTGRES === "1") return;
@@ -4607,12 +4615,6 @@ var init_platform_procedures = __esm({
         priority: "p0",
         content: "When you dispatch work, you OWN the review. Check list_tasks(status='needs_review') on EVERY prompt \u2014 don't wait for intercom nudges (they're unreliable). When a task shows needs_review: (1) read the deliverable (git diff in worktree, exe/output/ files, or task result summary), (2) verify it works (tsc, build, run), (3) close_task if good or create a fix task if not. Reviews sitting >30 minutes is a pipeline stall. The whole chain: worker calls update_task(done) \u2192 system flags needs_review \u2192 manager pulls and verifies \u2192 close_task \u2192 COO reviews manager's work \u2192 merge to main. Every level actively pulls \u2014 nobody waits."
       },
-      {
-        title: "Bug fix lifecycle \u2014 triage upstream after every verified fix so customers see the status",
-        domain: "workflow",
-        priority: "p0",
-        content: "When a bug from support(action='list_bugs') is fixed and verified, the reviewer MUST triage it upstream: support(action='triage_bug', id='<bug-id>', notes='<what was fixed>', fixed_version='<version>', linked_commit='<hash>'). This closes the bug in the customer's view \u2014 their COO checks list_my_bugs and sees status change from open \u2192 closed with the fix version. Without triage, customers see 'open' forever even after the fix ships. Same for feature requests: support(action='triage_feature', ..., shipped_version='<version>'). Triage is part of the review gate \u2014 a fix is not done until the upstream report is closed."
-      },
       {
         title: "Intercom is a speedup, not delivery \u2014 DB is the source of truth",
         domain: "architecture",

package/dist/bin/exe-new-employee.js

@@ -470,7 +470,15 @@ function getClient() {
   if (!_resilientClient) {
     return _adapterClient;
   }
-  return _resilientClient;
+  if (process.env.EXE_DB_READONLY === "1") {
+    return _resilientClient;
+  }
+  process.stderr.write(
+    "[database] ERROR: Daemon is not running \u2014 refusing direct SQLite write access.\n[database] Direct writes bypass the single-writer gate and corrupt FTS5 indexes.\n[database] Restart the daemon: kill $(cat ~/.exe-os/exed.pid) && exe-os update\n[database] Or set EXE_DB_READONLY=1 if you only need read access.\n"
+  );
+  throw new Error(
+    "Daemon not running. Direct SQLite writes are blocked to prevent FTS5 corruption. Restart daemon or set EXE_DB_READONLY=1 for read-only access."
+  );
 }
 var _debugDb, _resilientClient, _daemonClient, _adapterClient, DB_LOCK_PATH;
 var init_database = __esm({
@@ -2824,12 +2832,6 @@ var PLATFORM_PROCEDURES = [
     priority: "p0",
     content: "When you dispatch work, you OWN the review. Check list_tasks(status='needs_review') on EVERY prompt \u2014 don't wait for intercom nudges (they're unreliable). When a task shows needs_review: (1) read the deliverable (git diff in worktree, exe/output/ files, or task result summary), (2) verify it works (tsc, build, run), (3) close_task if good or create a fix task if not. Reviews sitting >30 minutes is a pipeline stall. The whole chain: worker calls update_task(done) \u2192 system flags needs_review \u2192 manager pulls and verifies \u2192 close_task \u2192 COO reviews manager's work \u2192 merge to main. Every level actively pulls \u2014 nobody waits."
   },
-  {
-    title: "Bug fix lifecycle \u2014 triage upstream after every verified fix so customers see the status",
-    domain: "workflow",
-    priority: "p0",
-    content: "When a bug from support(action='list_bugs') is fixed and verified, the reviewer MUST triage it upstream: support(action='triage_bug', id='<bug-id>', notes='<what was fixed>', fixed_version='<version>', linked_commit='<hash>'). This closes the bug in the customer's view \u2014 their COO checks list_my_bugs and sees status change from open \u2192 closed with the fix version. Without triage, customers see 'open' forever even after the fix ships. Same for feature requests: support(action='triage_feature', ..., shipped_version='<version>'). Triage is part of the review gate \u2014 a fix is not done until the upstream report is closed."
-  },
   {
     title: "Intercom is a speedup, not delivery \u2014 DB is the source of truth",
     domain: "architecture",

package/dist/bin/exe-pending-messages.js

@@ -1831,7 +1831,15 @@ function getClient() {
   if (!_resilientClient) {
     return _adapterClient;
   }
-  return _resilientClient;
+  if (process.env.EXE_DB_READONLY === "1") {
+    return _resilientClient;
+  }
+  process.stderr.write(
+    "[database] ERROR: Daemon is not running \u2014 refusing direct SQLite write access.\n[database] Direct writes bypass the single-writer gate and corrupt FTS5 indexes.\n[database] Restart the daemon: kill $(cat ~/.exe-os/exed.pid) && exe-os update\n[database] Or set EXE_DB_READONLY=1 if you only need read access.\n"
+  );
+  throw new Error(
+    "Daemon not running. Direct SQLite writes are blocked to prevent FTS5 corruption. Restart daemon or set EXE_DB_READONLY=1 for read-only access."
+  );
 }
 async function initDaemonClient() {
   if (process.env.DATABASE_URL && process.env.EXE_USE_POSTGRES === "1") return;
@@ -4990,12 +4998,6 @@ var init_platform_procedures = __esm({
         priority: "p0",
         content: "When you dispatch work, you OWN the review. Check list_tasks(status='needs_review') on EVERY prompt \u2014 don't wait for intercom nudges (they're unreliable). When a task shows needs_review: (1) read the deliverable (git diff in worktree, exe/output/ files, or task result summary), (2) verify it works (tsc, build, run), (3) close_task if good or create a fix task if not. Reviews sitting >30 minutes is a pipeline stall. The whole chain: worker calls update_task(done) \u2192 system flags needs_review \u2192 manager pulls and verifies \u2192 close_task \u2192 COO reviews manager's work \u2192 merge to main. Every level actively pulls \u2014 nobody waits."
       },
-      {
-        title: "Bug fix lifecycle \u2014 triage upstream after every verified fix so customers see the status",
-        domain: "workflow",
-        priority: "p0",
-        content: "When a bug from support(action='list_bugs') is fixed and verified, the reviewer MUST triage it upstream: support(action='triage_bug', id='<bug-id>', notes='<what was fixed>', fixed_version='<version>', linked_commit='<hash>'). This closes the bug in the customer's view \u2014 their COO checks list_my_bugs and sees status change from open \u2192 closed with the fix version. Without triage, customers see 'open' forever even after the fix ships. Same for feature requests: support(action='triage_feature', ..., shipped_version='<version>'). Triage is part of the review gate \u2014 a fix is not done until the upstream report is closed."
-      },
       {
         title: "Intercom is a speedup, not delivery \u2014 DB is the source of truth",
         domain: "architecture",

package/dist/bin/exe-pending-notifications.js

@@ -1832,7 +1832,15 @@ function getClient() {
   if (!_resilientClient) {
     return _adapterClient;
   }
-  return _resilientClient;
+  if (process.env.EXE_DB_READONLY === "1") {
+    return _resilientClient;
+  }
+  process.stderr.write(
+    "[database] ERROR: Daemon is not running \u2014 refusing direct SQLite write access.\n[database] Direct writes bypass the single-writer gate and corrupt FTS5 indexes.\n[database] Restart the daemon: kill $(cat ~/.exe-os/exed.pid) && exe-os update\n[database] Or set EXE_DB_READONLY=1 if you only need read access.\n"
+  );
+  throw new Error(
+    "Daemon not running. Direct SQLite writes are blocked to prevent FTS5 corruption. Restart daemon or set EXE_DB_READONLY=1 for read-only access."
+  );
 }
 async function initDaemonClient() {
   if (process.env.DATABASE_URL && process.env.EXE_USE_POSTGRES === "1") return;
@@ -5056,12 +5064,6 @@ var init_platform_procedures = __esm({
         priority: "p0",
         content: "When you dispatch work, you OWN the review. Check list_tasks(status='needs_review') on EVERY prompt \u2014 don't wait for intercom nudges (they're unreliable). When a task shows needs_review: (1) read the deliverable (git diff in worktree, exe/output/ files, or task result summary), (2) verify it works (tsc, build, run), (3) close_task if good or create a fix task if not. Reviews sitting >30 minutes is a pipeline stall. The whole chain: worker calls update_task(done) \u2192 system flags needs_review \u2192 manager pulls and verifies \u2192 close_task \u2192 COO reviews manager's work \u2192 merge to main. Every level actively pulls \u2014 nobody waits."
       },
-      {
-        title: "Bug fix lifecycle \u2014 triage upstream after every verified fix so customers see the status",
-        domain: "workflow",
-        priority: "p0",
-        content: "When a bug from support(action='list_bugs') is fixed and verified, the reviewer MUST triage it upstream: support(action='triage_bug', id='<bug-id>', notes='<what was fixed>', fixed_version='<version>', linked_commit='<hash>'). This closes the bug in the customer's view \u2014 their COO checks list_my_bugs and sees status change from open \u2192 closed with the fix version. Without triage, customers see 'open' forever even after the fix ships. Same for feature requests: support(action='triage_feature', ..., shipped_version='<version>'). Triage is part of the review gate \u2014 a fix is not done until the upstream report is closed."
-      },
       {
         title: "Intercom is a speedup, not delivery \u2014 DB is the source of truth",
         domain: "architecture",

package/dist/bin/exe-pending-reviews.js

@@ -1832,7 +1832,15 @@ function getClient() {
   if (!_resilientClient) {
     return _adapterClient;
   }
-  return _resilientClient;
+  if (process.env.EXE_DB_READONLY === "1") {
+    return _resilientClient;
+  }
+  process.stderr.write(
+    "[database] ERROR: Daemon is not running \u2014 refusing direct SQLite write access.\n[database] Direct writes bypass the single-writer gate and corrupt FTS5 indexes.\n[database] Restart the daemon: kill $(cat ~/.exe-os/exed.pid) && exe-os update\n[database] Or set EXE_DB_READONLY=1 if you only need read access.\n"
+  );
+  throw new Error(
+    "Daemon not running. Direct SQLite writes are blocked to prevent FTS5 corruption. Restart daemon or set EXE_DB_READONLY=1 for read-only access."
+  );
 }
 async function initDaemonClient() {
   if (process.env.DATABASE_URL && process.env.EXE_USE_POSTGRES === "1") return;
@@ -5095,12 +5103,6 @@ var init_platform_procedures = __esm({
         priority: "p0",
         content: "When you dispatch work, you OWN the review. Check list_tasks(status='needs_review') on EVERY prompt \u2014 don't wait for intercom nudges (they're unreliable). When a task shows needs_review: (1) read the deliverable (git diff in worktree, exe/output/ files, or task result summary), (2) verify it works (tsc, build, run), (3) close_task if good or create a fix task if not. Reviews sitting >30 minutes is a pipeline stall. The whole chain: worker calls update_task(done) \u2192 system flags needs_review \u2192 manager pulls and verifies \u2192 close_task \u2192 COO reviews manager's work \u2192 merge to main. Every level actively pulls \u2014 nobody waits."
       },
-      {
-        title: "Bug fix lifecycle \u2014 triage upstream after every verified fix so customers see the status",
-        domain: "workflow",
-        priority: "p0",
-        content: "When a bug from support(action='list_bugs') is fixed and verified, the reviewer MUST triage it upstream: support(action='triage_bug', id='<bug-id>', notes='<what was fixed>', fixed_version='<version>', linked_commit='<hash>'). This closes the bug in the customer's view \u2014 their COO checks list_my_bugs and sees status change from open \u2192 closed with the fix version. Without triage, customers see 'open' forever even after the fix ships. Same for feature requests: support(action='triage_feature', ..., shipped_version='<version>'). Triage is part of the review gate \u2014 a fix is not done until the upstream report is closed."
-      },
       {
         title: "Intercom is a speedup, not delivery \u2014 DB is the source of truth",
         domain: "architecture",

package/dist/bin/exe-rename.js

@@ -1676,7 +1676,15 @@ function getClient() {
   if (!_resilientClient) {
     return _adapterClient;
   }
-  return _resilientClient;
+  if (process.env.EXE_DB_READONLY === "1") {
+    return _resilientClient;
+  }
+  process.stderr.write(
+    "[database] ERROR: Daemon is not running \u2014 refusing direct SQLite write access.\n[database] Direct writes bypass the single-writer gate and corrupt FTS5 indexes.\n[database] Restart the daemon: kill $(cat ~/.exe-os/exed.pid) && exe-os update\n[database] Or set EXE_DB_READONLY=1 if you only need read access.\n"
+  );
+  throw new Error(
+    "Daemon not running. Direct SQLite writes are blocked to prevent FTS5 corruption. Restart daemon or set EXE_DB_READONLY=1 for read-only access."
+  );
 }
 async function initDaemonClient() {
   if (process.env.DATABASE_URL && process.env.EXE_USE_POSTGRES === "1") return;
@@ -3343,12 +3351,6 @@ var init_platform_procedures = __esm({
         priority: "p0",
         content: "When you dispatch work, you OWN the review. Check list_tasks(status='needs_review') on EVERY prompt \u2014 don't wait for intercom nudges (they're unreliable). When a task shows needs_review: (1) read the deliverable (git diff in worktree, exe/output/ files, or task result summary), (2) verify it works (tsc, build, run), (3) close_task if good or create a fix task if not. Reviews sitting >30 minutes is a pipeline stall. The whole chain: worker calls update_task(done) \u2192 system flags needs_review \u2192 manager pulls and verifies \u2192 close_task \u2192 COO reviews manager's work \u2192 merge to main. Every level actively pulls \u2014 nobody waits."
       },
-      {
-        title: "Bug fix lifecycle \u2014 triage upstream after every verified fix so customers see the status",
-        domain: "workflow",
-        priority: "p0",
-        content: "When a bug from support(action='list_bugs') is fixed and verified, the reviewer MUST triage it upstream: support(action='triage_bug', id='<bug-id>', notes='<what was fixed>', fixed_version='<version>', linked_commit='<hash>'). This closes the bug in the customer's view \u2014 their COO checks list_my_bugs and sees status change from open \u2192 closed with the fix version. Without triage, customers see 'open' forever even after the fix ships. Same for feature requests: support(action='triage_feature', ..., shipped_version='<version>'). Triage is part of the review gate \u2014 a fix is not done until the upstream report is closed."
-      },
       {
         title: "Intercom is a speedup, not delivery \u2014 DB is the source of truth",
         domain: "architecture",

package/dist/bin/exe-review.js

@@ -1835,7 +1835,15 @@ function getClient() {
   if (!_resilientClient) {
     return _adapterClient;
   }
-  return _resilientClient;
+  if (process.env.EXE_DB_READONLY === "1") {
+    return _resilientClient;
+  }
+  process.stderr.write(
+    "[database] ERROR: Daemon is not running \u2014 refusing direct SQLite write access.\n[database] Direct writes bypass the single-writer gate and corrupt FTS5 indexes.\n[database] Restart the daemon: kill $(cat ~/.exe-os/exed.pid) && exe-os update\n[database] Or set EXE_DB_READONLY=1 if you only need read access.\n"
+  );
+  throw new Error(
+    "Daemon not running. Direct SQLite writes are blocked to prevent FTS5 corruption. Restart daemon or set EXE_DB_READONLY=1 for read-only access."
+  );
 }
 async function initDaemonClient() {
   if (process.env.DATABASE_URL && process.env.EXE_USE_POSTGRES === "1") return;
@@ -4523,12 +4531,6 @@ var init_platform_procedures = __esm({
         priority: "p0",
         content: "When you dispatch work, you OWN the review. Check list_tasks(status='needs_review') on EVERY prompt \u2014 don't wait for intercom nudges (they're unreliable). When a task shows needs_review: (1) read the deliverable (git diff in worktree, exe/output/ files, or task result summary), (2) verify it works (tsc, build, run), (3) close_task if good or create a fix task if not. Reviews sitting >30 minutes is a pipeline stall. The whole chain: worker calls update_task(done) \u2192 system flags needs_review \u2192 manager pulls and verifies \u2192 close_task \u2192 COO reviews manager's work \u2192 merge to main. Every level actively pulls \u2014 nobody waits."
       },
-      {
-        title: "Bug fix lifecycle \u2014 triage upstream after every verified fix so customers see the status",
-        domain: "workflow",
-        priority: "p0",
-        content: "When a bug from support(action='list_bugs') is fixed and verified, the reviewer MUST triage it upstream: support(action='triage_bug', id='<bug-id>', notes='<what was fixed>', fixed_version='<version>', linked_commit='<hash>'). This closes the bug in the customer's view \u2014 their COO checks list_my_bugs and sees status change from open \u2192 closed with the fix version. Without triage, customers see 'open' forever even after the fix ships. Same for feature requests: support(action='triage_feature', ..., shipped_version='<version>'). Triage is part of the review gate \u2014 a fix is not done until the upstream report is closed."
-      },
       {
         title: "Intercom is a speedup, not delivery \u2014 DB is the source of truth",
         domain: "architecture",

package/dist/bin/exe-search.js

@@ -1820,7 +1820,15 @@ function getClient() {
   if (!_resilientClient) {
     return _adapterClient;
   }
-  return _resilientClient;
+  if (process.env.EXE_DB_READONLY === "1") {
+    return _resilientClient;
+  }
+  process.stderr.write(
+    "[database] ERROR: Daemon is not running \u2014 refusing direct SQLite write access.\n[database] Direct writes bypass the single-writer gate and corrupt FTS5 indexes.\n[database] Restart the daemon: kill $(cat ~/.exe-os/exed.pid) && exe-os update\n[database] Or set EXE_DB_READONLY=1 if you only need read access.\n"
+  );
+  throw new Error(
+    "Daemon not running. Direct SQLite writes are blocked to prevent FTS5 corruption. Restart daemon or set EXE_DB_READONLY=1 for read-only access."
+  );
 }
 async function initDaemonClient() {
   if (process.env.DATABASE_URL && process.env.EXE_USE_POSTGRES === "1") return;
@@ -4508,12 +4516,6 @@ var init_platform_procedures = __esm({
         priority: "p0",
         content: "When you dispatch work, you OWN the review. Check list_tasks(status='needs_review') on EVERY prompt \u2014 don't wait for intercom nudges (they're unreliable). When a task shows needs_review: (1) read the deliverable (git diff in worktree, exe/output/ files, or task result summary), (2) verify it works (tsc, build, run), (3) close_task if good or create a fix task if not. Reviews sitting >30 minutes is a pipeline stall. The whole chain: worker calls update_task(done) \u2192 system flags needs_review \u2192 manager pulls and verifies \u2192 close_task \u2192 COO reviews manager's work \u2192 merge to main. Every level actively pulls \u2014 nobody waits."
       },
-      {
-        title: "Bug fix lifecycle \u2014 triage upstream after every verified fix so customers see the status",
-        domain: "workflow",
-        priority: "p0",
-        content: "When a bug from support(action='list_bugs') is fixed and verified, the reviewer MUST triage it upstream: support(action='triage_bug', id='<bug-id>', notes='<what was fixed>', fixed_version='<version>', linked_commit='<hash>'). This closes the bug in the customer's view \u2014 their COO checks list_my_bugs and sees status change from open \u2192 closed with the fix version. Without triage, customers see 'open' forever even after the fix ships. Same for feature requests: support(action='triage_feature', ..., shipped_version='<version>'). Triage is part of the review gate \u2014 a fix is not done until the upstream report is closed."
-      },
       {
         title: "Intercom is a speedup, not delivery \u2014 DB is the source of truth",
         domain: "architecture",
@@ -7303,7 +7305,32 @@ async function ftsQuery(client, matchExpr, agentId, options, limit) {
   sql = appendMemoryTypeFilter(sql, args, "m.memory_type", options);
   sql += ` ORDER BY rank LIMIT ?`;
   args.push(limit);
-  const result = await client.execute({ sql, args });
+  let result;
+  try {
+    result = await client.execute({ sql, args });
+  } catch (ftsErr) {
+    const msg = ftsErr instanceof Error ? ftsErr.message : String(ftsErr);
+    if (msg.includes("fts5") || msg.includes("FTS") || msg.includes("database disk image is malformed")) {
+      process.stderr.write(
+        `[hybrid-search] FTS5 corruption detected during query: ${msg}
+[hybrid-search] Attempting auto-rebuild of memories_fts index...
+`
+      );
+      try {
+        await client.execute("INSERT INTO memories_fts(memories_fts) VALUES('rebuild')");
+        process.stderr.write("[hybrid-search] FTS5 index rebuilt successfully \u2014 retrying query.\n");
+        result = await client.execute({ sql, args });
+      } catch (rebuildErr) {
+        process.stderr.write(
+          `[hybrid-search] FTS5 rebuild failed: ${rebuildErr instanceof Error ? rebuildErr.message : String(rebuildErr)}
+`
+        );
+        return [];
+      }
+    } else {
+      throw ftsErr;
+    }
+  }
   return result.rows.map((row) => ({
     id: row.id,
     agent_id: row.agent_id,

package/dist/bin/exe-session-cleanup.js

@@ -1864,7 +1864,15 @@ function getClient() {
   if (!_resilientClient) {
     return _adapterClient;
   }
-  return _resilientClient;
+  if (process.env.EXE_DB_READONLY === "1") {
+    return _resilientClient;
+  }
+  process.stderr.write(
+    "[database] ERROR: Daemon is not running \u2014 refusing direct SQLite write access.\n[database] Direct writes bypass the single-writer gate and corrupt FTS5 indexes.\n[database] Restart the daemon: kill $(cat ~/.exe-os/exed.pid) && exe-os update\n[database] Or set EXE_DB_READONLY=1 if you only need read access.\n"
+  );
+  throw new Error(
+    "Daemon not running. Direct SQLite writes are blocked to prevent FTS5 corruption. Restart daemon or set EXE_DB_READONLY=1 for read-only access."
+  );
 }
 async function initDaemonClient() {
   if (process.env.DATABASE_URL && process.env.EXE_USE_POSTGRES === "1") return;
@@ -4552,12 +4560,6 @@ var init_platform_procedures = __esm({
         priority: "p0",
         content: "When you dispatch work, you OWN the review. Check list_tasks(status='needs_review') on EVERY prompt \u2014 don't wait for intercom nudges (they're unreliable). When a task shows needs_review: (1) read the deliverable (git diff in worktree, exe/output/ files, or task result summary), (2) verify it works (tsc, build, run), (3) close_task if good or create a fix task if not. Reviews sitting >30 minutes is a pipeline stall. The whole chain: worker calls update_task(done) \u2192 system flags needs_review \u2192 manager pulls and verifies \u2192 close_task \u2192 COO reviews manager's work \u2192 merge to main. Every level actively pulls \u2014 nobody waits."
       },
-      {
-        title: "Bug fix lifecycle \u2014 triage upstream after every verified fix so customers see the status",
-        domain: "workflow",
-        priority: "p0",
-        content: "When a bug from support(action='list_bugs') is fixed and verified, the reviewer MUST triage it upstream: support(action='triage_bug', id='<bug-id>', notes='<what was fixed>', fixed_version='<version>', linked_commit='<hash>'). This closes the bug in the customer's view \u2014 their COO checks list_my_bugs and sees status change from open \u2192 closed with the fix version. Without triage, customers see 'open' forever even after the fix ships. Same for feature requests: support(action='triage_feature', ..., shipped_version='<version>'). Triage is part of the review gate \u2014 a fix is not done until the upstream report is closed."
-      },
       {
         title: "Intercom is a speedup, not delivery \u2014 DB is the source of truth",
         domain: "architecture",

package/dist/bin/exe-start-codex.js

@@ -1693,7 +1693,15 @@ function getClient() {
   if (!_resilientClient) {
     return _adapterClient;
   }
-  return _resilientClient;
+  if (process.env.EXE_DB_READONLY === "1") {
+    return _resilientClient;
+  }
+  process.stderr.write(
+    "[database] ERROR: Daemon is not running \u2014 refusing direct SQLite write access.\n[database] Direct writes bypass the single-writer gate and corrupt FTS5 indexes.\n[database] Restart the daemon: kill $(cat ~/.exe-os/exed.pid) && exe-os update\n[database] Or set EXE_DB_READONLY=1 if you only need read access.\n"
+  );
+  throw new Error(
+    "Daemon not running. Direct SQLite writes are blocked to prevent FTS5 corruption. Restart daemon or set EXE_DB_READONLY=1 for read-only access."
+  );
 }
 async function initDaemonClient() {
   if (process.env.DATABASE_URL && process.env.EXE_USE_POSTGRES === "1") return;
@@ -3824,12 +3832,6 @@ var init_platform_procedures = __esm({
         priority: "p0",
         content: "When you dispatch work, you OWN the review. Check list_tasks(status='needs_review') on EVERY prompt \u2014 don't wait for intercom nudges (they're unreliable). When a task shows needs_review: (1) read the deliverable (git diff in worktree, exe/output/ files, or task result summary), (2) verify it works (tsc, build, run), (3) close_task if good or create a fix task if not. Reviews sitting >30 minutes is a pipeline stall. The whole chain: worker calls update_task(done) \u2192 system flags needs_review \u2192 manager pulls and verifies \u2192 close_task \u2192 COO reviews manager's work \u2192 merge to main. Every level actively pulls \u2014 nobody waits."
       },
-      {
-        title: "Bug fix lifecycle \u2014 triage upstream after every verified fix so customers see the status",
-        domain: "workflow",
-        priority: "p0",
-        content: "When a bug from support(action='list_bugs') is fixed and verified, the reviewer MUST triage it upstream: support(action='triage_bug', id='<bug-id>', notes='<what was fixed>', fixed_version='<version>', linked_commit='<hash>'). This closes the bug in the customer's view \u2014 their COO checks list_my_bugs and sees status change from open \u2192 closed with the fix version. Without triage, customers see 'open' forever even after the fix ships. Same for feature requests: support(action='triage_feature', ..., shipped_version='<version>'). Triage is part of the review gate \u2014 a fix is not done until the upstream report is closed."
-      },
       {
         title: "Intercom is a speedup, not delivery \u2014 DB is the source of truth",
         domain: "architecture",

package/dist/bin/exe-start-opencode.js

@@ -1693,7 +1693,15 @@ function getClient() {
   if (!_resilientClient) {
     return _adapterClient;
   }
-  return _resilientClient;
+  if (process.env.EXE_DB_READONLY === "1") {
+    return _resilientClient;
+  }
+  process.stderr.write(
+    "[database] ERROR: Daemon is not running \u2014 refusing direct SQLite write access.\n[database] Direct writes bypass the single-writer gate and corrupt FTS5 indexes.\n[database] Restart the daemon: kill $(cat ~/.exe-os/exed.pid) && exe-os update\n[database] Or set EXE_DB_READONLY=1 if you only need read access.\n"
+  );
+  throw new Error(
+    "Daemon not running. Direct SQLite writes are blocked to prevent FTS5 corruption. Restart daemon or set EXE_DB_READONLY=1 for read-only access."
+  );
 }
 async function initDaemonClient() {
   if (process.env.DATABASE_URL && process.env.EXE_USE_POSTGRES === "1") return;
@@ -3824,12 +3832,6 @@ var init_platform_procedures = __esm({
         priority: "p0",
         content: "When you dispatch work, you OWN the review. Check list_tasks(status='needs_review') on EVERY prompt \u2014 don't wait for intercom nudges (they're unreliable). When a task shows needs_review: (1) read the deliverable (git diff in worktree, exe/output/ files, or task result summary), (2) verify it works (tsc, build, run), (3) close_task if good or create a fix task if not. Reviews sitting >30 minutes is a pipeline stall. The whole chain: worker calls update_task(done) \u2192 system flags needs_review \u2192 manager pulls and verifies \u2192 close_task \u2192 COO reviews manager's work \u2192 merge to main. Every level actively pulls \u2014 nobody waits."
       },
-      {
-        title: "Bug fix lifecycle \u2014 triage upstream after every verified fix so customers see the status",
-        domain: "workflow",
-        priority: "p0",
-        content: "When a bug from support(action='list_bugs') is fixed and verified, the reviewer MUST triage it upstream: support(action='triage_bug', id='<bug-id>', notes='<what was fixed>', fixed_version='<version>', linked_commit='<hash>'). This closes the bug in the customer's view \u2014 their COO checks list_my_bugs and sees status change from open \u2192 closed with the fix version. Without triage, customers see 'open' forever even after the fix ships. Same for feature requests: support(action='triage_feature', ..., shipped_version='<version>'). Triage is part of the review gate \u2014 a fix is not done until the upstream report is closed."
-      },
       {
         title: "Intercom is a speedup, not delivery \u2014 DB is the source of truth",
         domain: "architecture",

package/dist/bin/exe-status.js

@@ -1843,7 +1843,15 @@ function getClient() {
   if (!_resilientClient) {
     return _adapterClient;
   }
-  return _resilientClient;
+  if (process.env.EXE_DB_READONLY === "1") {
+    return _resilientClient;
+  }
+  process.stderr.write(
+    "[database] ERROR: Daemon is not running \u2014 refusing direct SQLite write access.\n[database] Direct writes bypass the single-writer gate and corrupt FTS5 indexes.\n[database] Restart the daemon: kill $(cat ~/.exe-os/exed.pid) && exe-os update\n[database] Or set EXE_DB_READONLY=1 if you only need read access.\n"
+  );
+  throw new Error(
+    "Daemon not running. Direct SQLite writes are blocked to prevent FTS5 corruption. Restart daemon or set EXE_DB_READONLY=1 for read-only access."
+  );
 }
 async function initDaemonClient() {
   if (process.env.DATABASE_URL && process.env.EXE_USE_POSTGRES === "1") return;
@@ -4531,12 +4539,6 @@ var init_platform_procedures = __esm({
         priority: "p0",
         content: "When you dispatch work, you OWN the review. Check list_tasks(status='needs_review') on EVERY prompt \u2014 don't wait for intercom nudges (they're unreliable). When a task shows needs_review: (1) read the deliverable (git diff in worktree, exe/output/ files, or task result summary), (2) verify it works (tsc, build, run), (3) close_task if good or create a fix task if not. Reviews sitting >30 minutes is a pipeline stall. The whole chain: worker calls update_task(done) \u2192 system flags needs_review \u2192 manager pulls and verifies \u2192 close_task \u2192 COO reviews manager's work \u2192 merge to main. Every level actively pulls \u2014 nobody waits."
       },
-      {
-        title: "Bug fix lifecycle \u2014 triage upstream after every verified fix so customers see the status",
-        domain: "workflow",
-        priority: "p0",
-        content: "When a bug from support(action='list_bugs') is fixed and verified, the reviewer MUST triage it upstream: support(action='triage_bug', id='<bug-id>', notes='<what was fixed>', fixed_version='<version>', linked_commit='<hash>'). This closes the bug in the customer's view \u2014 their COO checks list_my_bugs and sees status change from open \u2192 closed with the fix version. Without triage, customers see 'open' forever even after the fix ships. Same for feature requests: support(action='triage_feature', ..., shipped_version='<version>'). Triage is part of the review gate \u2014 a fix is not done until the upstream report is closed."
-      },
       {
         title: "Intercom is a speedup, not delivery \u2014 DB is the source of truth",
         domain: "architecture",

package/dist/bin/exe-team.js

@@ -1832,7 +1832,15 @@ function getClient() {
   if (!_resilientClient) {
     return _adapterClient;
   }
-  return _resilientClient;
+  if (process.env.EXE_DB_READONLY === "1") {
+    return _resilientClient;
+  }
+  process.stderr.write(
+    "[database] ERROR: Daemon is not running \u2014 refusing direct SQLite write access.\n[database] Direct writes bypass the single-writer gate and corrupt FTS5 indexes.\n[database] Restart the daemon: kill $(cat ~/.exe-os/exed.pid) && exe-os update\n[database] Or set EXE_DB_READONLY=1 if you only need read access.\n"
+  );
+  throw new Error(
+    "Daemon not running. Direct SQLite writes are blocked to prevent FTS5 corruption. Restart daemon or set EXE_DB_READONLY=1 for read-only access."
+  );
 }
 async function initDaemonClient() {
   if (process.env.DATABASE_URL && process.env.EXE_USE_POSTGRES === "1") return;
@@ -4520,12 +4528,6 @@ var init_platform_procedures = __esm({
         priority: "p0",
         content: "When you dispatch work, you OWN the review. Check list_tasks(status='needs_review') on EVERY prompt \u2014 don't wait for intercom nudges (they're unreliable). When a task shows needs_review: (1) read the deliverable (git diff in worktree, exe/output/ files, or task result summary), (2) verify it works (tsc, build, run), (3) close_task if good or create a fix task if not. Reviews sitting >30 minutes is a pipeline stall. The whole chain: worker calls update_task(done) \u2192 system flags needs_review \u2192 manager pulls and verifies \u2192 close_task \u2192 COO reviews manager's work \u2192 merge to main. Every level actively pulls \u2014 nobody waits."
       },
-      {
-        title: "Bug fix lifecycle \u2014 triage upstream after every verified fix so customers see the status",
-        domain: "workflow",
-        priority: "p0",
-        content: "When a bug from support(action='list_bugs') is fixed and verified, the reviewer MUST triage it upstream: support(action='triage_bug', id='<bug-id>', notes='<what was fixed>', fixed_version='<version>', linked_commit='<hash>'). This closes the bug in the customer's view \u2014 their COO checks list_my_bugs and sees status change from open \u2192 closed with the fix version. Without triage, customers see 'open' forever even after the fix ships. Same for feature requests: support(action='triage_feature', ..., shipped_version='<version>'). Triage is part of the review gate \u2014 a fix is not done until the upstream report is closed."
-      },
       {
         title: "Intercom is a speedup, not delivery \u2014 DB is the source of truth",
         domain: "architecture",

package/dist/bin/git-sweep.js

@@ -2344,7 +2344,15 @@ function getClient() {
   if (!_resilientClient) {
     return _adapterClient;
   }
-  return _resilientClient;
+  if (process.env.EXE_DB_READONLY === "1") {
+    return _resilientClient;
+  }
+  process.stderr.write(
+    "[database] ERROR: Daemon is not running \u2014 refusing direct SQLite write access.\n[database] Direct writes bypass the single-writer gate and corrupt FTS5 indexes.\n[database] Restart the daemon: kill $(cat ~/.exe-os/exed.pid) && exe-os update\n[database] Or set EXE_DB_READONLY=1 if you only need read access.\n"
+  );
+  throw new Error(
+    "Daemon not running. Direct SQLite writes are blocked to prevent FTS5 corruption. Restart daemon or set EXE_DB_READONLY=1 for read-only access."
+  );
 }
 async function initDaemonClient() {
   if (process.env.DATABASE_URL && process.env.EXE_USE_POSTGRES === "1") return;
@@ -8279,12 +8287,6 @@ var init_platform_procedures = __esm({
         priority: "p0",
         content: "When you dispatch work, you OWN the review. Check list_tasks(status='needs_review') on EVERY prompt \u2014 don't wait for intercom nudges (they're unreliable). When a task shows needs_review: (1) read the deliverable (git diff in worktree, exe/output/ files, or task result summary), (2) verify it works (tsc, build, run), (3) close_task if good or create a fix task if not. Reviews sitting >30 minutes is a pipeline stall. The whole chain: worker calls update_task(done) \u2192 system flags needs_review \u2192 manager pulls and verifies \u2192 close_task \u2192 COO reviews manager's work \u2192 merge to main. Every level actively pulls \u2014 nobody waits."
       },
-      {
-        title: "Bug fix lifecycle \u2014 triage upstream after every verified fix so customers see the status",
-        domain: "workflow",
-        priority: "p0",
-        content: "When a bug from support(action='list_bugs') is fixed and verified, the reviewer MUST triage it upstream: support(action='triage_bug', id='<bug-id>', notes='<what was fixed>', fixed_version='<version>', linked_commit='<hash>'). This closes the bug in the customer's view \u2014 their COO checks list_my_bugs and sees status change from open \u2192 closed with the fix version. Without triage, customers see 'open' forever even after the fix ships. Same for feature requests: support(action='triage_feature', ..., shipped_version='<version>'). Triage is part of the review gate \u2014 a fix is not done until the upstream report is closed."
-      },
       {
         title: "Intercom is a speedup, not delivery \u2014 DB is the source of truth",
         domain: "architecture",

package/dist/bin/graph-backfill.js

@@ -1606,7 +1606,15 @@ function getClient() {
   if (!_resilientClient) {
     return _adapterClient;
   }
-  return _resilientClient;
+  if (process.env.EXE_DB_READONLY === "1") {
+    return _resilientClient;
+  }
+  process.stderr.write(
+    "[database] ERROR: Daemon is not running \u2014 refusing direct SQLite write access.\n[database] Direct writes bypass the single-writer gate and corrupt FTS5 indexes.\n[database] Restart the daemon: kill $(cat ~/.exe-os/exed.pid) && exe-os update\n[database] Or set EXE_DB_READONLY=1 if you only need read access.\n"
+  );
+  throw new Error(
+    "Daemon not running. Direct SQLite writes are blocked to prevent FTS5 corruption. Restart daemon or set EXE_DB_READONLY=1 for read-only access."
+  );
 }
 async function initDaemonClient() {
   if (process.env.DATABASE_URL && process.env.EXE_USE_POSTGRES === "1") return;
@@ -3737,12 +3745,6 @@ var init_platform_procedures = __esm({
         priority: "p0",
         content: "When you dispatch work, you OWN the review. Check list_tasks(status='needs_review') on EVERY prompt \u2014 don't wait for intercom nudges (they're unreliable). When a task shows needs_review: (1) read the deliverable (git diff in worktree, exe/output/ files, or task result summary), (2) verify it works (tsc, build, run), (3) close_task if good or create a fix task if not. Reviews sitting >30 minutes is a pipeline stall. The whole chain: worker calls update_task(done) \u2192 system flags needs_review \u2192 manager pulls and verifies \u2192 close_task \u2192 COO reviews manager's work \u2192 merge to main. Every level actively pulls \u2014 nobody waits."
       },
-      {
-        title: "Bug fix lifecycle \u2014 triage upstream after every verified fix so customers see the status",
-        domain: "workflow",
-        priority: "p0",
-        content: "When a bug from support(action='list_bugs') is fixed and verified, the reviewer MUST triage it upstream: support(action='triage_bug', id='<bug-id>', notes='<what was fixed>', fixed_version='<version>', linked_commit='<hash>'). This closes the bug in the customer's view \u2014 their COO checks list_my_bugs and sees status change from open \u2192 closed with the fix version. Without triage, customers see 'open' forever even after the fix ships. Same for feature requests: support(action='triage_feature', ..., shipped_version='<version>'). Triage is part of the review gate \u2014 a fix is not done until the upstream report is closed."
-      },
       {
         title: "Intercom is a speedup, not delivery \u2014 DB is the source of truth",
         domain: "architecture",

package/dist/bin/graph-export.js

@@ -1821,7 +1821,15 @@ function getClient() {
   if (!_resilientClient) {
     return _adapterClient;
   }
-  return _resilientClient;
+  if (process.env.EXE_DB_READONLY === "1") {
+    return _resilientClient;
+  }
+  process.stderr.write(
+    "[database] ERROR: Daemon is not running \u2014 refusing direct SQLite write access.\n[database] Direct writes bypass the single-writer gate and corrupt FTS5 indexes.\n[database] Restart the daemon: kill $(cat ~/.exe-os/exed.pid) && exe-os update\n[database] Or set EXE_DB_READONLY=1 if you only need read access.\n"
+  );
+  throw new Error(
+    "Daemon not running. Direct SQLite writes are blocked to prevent FTS5 corruption. Restart daemon or set EXE_DB_READONLY=1 for read-only access."
+  );
 }
 async function initDaemonClient() {
   if (process.env.DATABASE_URL && process.env.EXE_USE_POSTGRES === "1") return;
@@ -4509,12 +4517,6 @@ var init_platform_procedures = __esm({
         priority: "p0",
         content: "When you dispatch work, you OWN the review. Check list_tasks(status='needs_review') on EVERY prompt \u2014 don't wait for intercom nudges (they're unreliable). When a task shows needs_review: (1) read the deliverable (git diff in worktree, exe/output/ files, or task result summary), (2) verify it works (tsc, build, run), (3) close_task if good or create a fix task if not. Reviews sitting >30 minutes is a pipeline stall. The whole chain: worker calls update_task(done) \u2192 system flags needs_review \u2192 manager pulls and verifies \u2192 close_task \u2192 COO reviews manager's work \u2192 merge to main. Every level actively pulls \u2014 nobody waits."
       },
-      {
-        title: "Bug fix lifecycle \u2014 triage upstream after every verified fix so customers see the status",
-        domain: "workflow",
-        priority: "p0",
-        content: "When a bug from support(action='list_bugs') is fixed and verified, the reviewer MUST triage it upstream: support(action='triage_bug', id='<bug-id>', notes='<what was fixed>', fixed_version='<version>', linked_commit='<hash>'). This closes the bug in the customer's view \u2014 their COO checks list_my_bugs and sees status change from open \u2192 closed with the fix version. Without triage, customers see 'open' forever even after the fix ships. Same for feature requests: support(action='triage_feature', ..., shipped_version='<version>'). Triage is part of the review gate \u2014 a fix is not done until the upstream report is closed."
-      },
       {
         title: "Intercom is a speedup, not delivery \u2014 DB is the source of truth",
         domain: "architecture",