mixdog 1.2.1 → 1.2.3

package/src/session-runtime/services/agent-tool/lead-worker-index.mjs

@@ -15,10 +15,12 @@ import { ACTIVE_LEAD_STATUS, isActiveLeadRow } from './lead-worker-index/lead-ro
 import { createLeadIndexFile } from './lead-worker-index/index-file.mjs';
 import { createRowSettlement } from './lead-worker-index/row-settlement.mjs';
 import { createLeadReapTimers } from './lead-worker-index/reap-timers.mjs';
+import { createForgottenLeads } from './lead-worker-index/forgotten-leads.mjs';
 
 export function createLeadWorkerIndex({ dataDir, cfgMod, workerRowFromSession }) {
   const activeLeadSessions = new Set();
   const index = createLeadIndexFile({ dataDir });
+  const forgotten = createForgottenLeads(dataDir);
   const settlement = createRowSettlement({ dataDir, cfgMod });
   const reaps = createLeadReapTimers({ removeRow: (sessionId, reapAt) => removeLeadWorkerRow(sessionId, reapAt) });
 
@@ -36,8 +38,25 @@ export function createLeadWorkerIndex({ dataDir, cfgMod, workerRowFromSession })
     return true;
   }
 
+  /** A deleted Lead leaves the pool now, running or not, and never returns. A
+   *  turn still unwinding after the delete settles by upserting its idle row —
+   *  possibly through another index instance of this process — so the guard is
+   *  process-wide (forgotten-leads.mjs). */
+  function forgetLeadSession(sessionId) {
+    const id = clean(sessionId);
+    if (!id) return false;
+    forgotten.forget(id);
+    reaps.cancel(id);
+    activeLeadSessions.delete(id);
+    index.write((byKey) => {
+      byKey.delete(id);
+    });
+    return true;
+  }
+
   function upsertLeadSession(session, extra = {}) {
     if (!session?.id || typeof workerRowFromSession !== 'function') return false;
+    if (forgotten.isForgotten(session.id)) return false;
     const owner = clean(session.owner).toLowerCase();
     const agent = clean(session.agent).toLowerCase();
     if (owner === 'agent' || (agent && agent !== 'lead')) return false;
@@ -61,7 +80,15 @@ export function createLeadWorkerIndex({ dataDir, cfgMod, workerRowFromSession })
       runtimePid: process.pid,
       reapAt: reapMs == null ? null : new Date(now + reapMs).toISOString(),
     };
-    index.write((byKey) => byKey.set(session.id, normalized));
+    // Re-run against the locked fresh document at persist time: a delete that
+    // lands (here or in another instance) between this call and the write must
+    // still win over the queued row.
+    index.write(
+      (byKey) => {
+        if (!forgotten.isForgotten(session.id)) byKey.set(session.id, normalized);
+      },
+      { rerun: true }
+    );
     if (ACTIVE_LEAD_STATUS.test(status) || ACTIVE_LEAD_STATUS.test(stage)) {
       activeLeadSessions.add(session.id);
       reaps.cancel(session.id);
@@ -95,6 +122,7 @@ export function createLeadWorkerIndex({ dataDir, cfgMod, workerRowFromSession })
     const now = Date.now();
     index.write((byKey) => {
       for (const id of ids) {
+        if (forgotten.isForgotten(id)) continue;
         const current = byKey.get(id);
         if (!current || !isActiveLeadRow(current)) continue;
         byKey.set(id, settlement.idleLeadRow(current, now, true));
@@ -133,29 +161,66 @@ export function createLeadWorkerIndex({ dataDir, cfgMod, workerRowFromSession })
   recoverStaleLeadRows();
   function flushLeadIndexOnExit() {
     flushActiveLeadRows();
-    // Writes are persisted by an async queue; the loop is gone at exit.
+    // Writes are persisted by an async queue; the loop is gone at exit. This
+    // is the best-effort last resort: a persist still running is left alone
+    // (the graceful shutdown path drains before exit).
     index.flushSync();
   }
   const unregisterExitFlush = registerExitFlush(flushLeadIndexOnExit);
   let disposed = false;
+  let disposePromise = null;
+
+  function teardown() {
+    reaps.cancelAll();
+    unregisterExitFlush();
+  }
+
+  async function drainThenTeardown() {
+    await index.flush();
+    teardown();
+  }
 
   /** Persist queued rows, drop owned reap timers, unregister. `settle` (a real
    *  teardown) also idles this runtime's own active Lead rows; a dispose that
-   *  keeps background work (idle eviction) leaves them for the next owner. */
+   *  keeps background work (idle eviction) leaves them for the next owner.
+   *  If the sync flush cannot run (our async writer holds the lock), the exit
+   *  hook stays until the async drain settles. */
   function dispose({ settle = false } = {}) {
     if (disposed) return;
     disposed = true;
+    let flushed = false;
     try {
       if (settle) flushActiveLeadRows();
-      index.flushSync();
-    } finally {
-      reaps.cancelAll();
-      unregisterExitFlush();
+      flushed = index.flushSync();
+    } catch {}
+    if (flushed) {
+      teardown();
+      return;
+    }
+    disposePromise = drainThenTeardown().catch(reopenAfterFailedDrain);
+  }
+
+  /** A failed drain tears nothing down; allow a later dispose to retry it. */
+  function reopenAfterFailedDrain() {
+    disposed = false;
+    disposePromise = null;
+  }
+
+  function disposeAsync({ settle = false } = {}) {
+    if (!disposePromise) {
+      disposed = true;
+      if (settle) flushActiveLeadRows();
+      disposePromise = drainThenTeardown().catch((error) => {
+        reopenAfterFailedDrain();
+        throw error;
+      });
     }
+    return disposePromise;
   }
 
   return {
     dispose,
+    disposeAsync,
     leadWorkerIndexPath: index.path,
     readLeadWorkerRows: index.read,
     /** Resolves once every queued Lead index write is on disk. */
@@ -163,6 +228,7 @@ export function createLeadWorkerIndex({ dataDir, cfgMod, workerRowFromSession })
     upsertLeadSession,
     updateLeadWorkerCwd,
     removeLeadWorkerRow,
+    forgetLeadSession,
     flushActiveLeadRows,
     recoverStaleLeadRows,
   };

package/src/session-runtime/services/agent-tool/send-flow.mjs

@@ -1,12 +1,14 @@
 import {
   resolveAgentWatchdogPolicy,
   resolveHandoffMessageStartIndex,
+  turnPartialHandoff,
   watchdogPartialHandoffFromError,
   watchdogStoppedHandoff,
 } from '../../../runtime/agent/orchestrator/agent-runtime/agent-progress-watchdog.mjs';
 import { clean, normalizeAgentName, resolvePrompt } from './helpers.mjs';
 import { abnormalEmptyFinishError, renderResult } from './render.mjs';
 import {
+  reconcileJobCancelled,
   reconcileJobFinally,
   reconcileJobStreamStalled,
   reconcileJobWatchdogPartial,
@@ -93,6 +95,18 @@ export function createSendFlow({ mgr, defaultCwd, sessionSurface, canUseSessionS
       turnStartedAt: new Date().toISOString(),
     });
     let handoffMsgStart = 0;
+    // A cancelled turn reports the output it produced before it stopped.
+    const settleCancelled = (error, result = null) => {
+      finalStatus = 'cancelled';
+      reconcileJobCancelled(job, {
+        tag,
+        sessionId,
+        agent: session.agent || null,
+        provider: session.provider,
+        model: session.model,
+        content: turnPartialHandoff(error, mgr.getSession(sessionId), handoffMsgStart) || result?.content || '',
+      });
+    };
     try {
       handoffMsgStart = resolveHandoffMessageStartIndex(mgr.getSession(sessionId));
       const turnHooks = buildTurnHooks({ sessionId, notifyContext, job, turnReview, completionValue });
@@ -100,6 +114,10 @@ export function createSendFlow({ mgr, defaultCwd, sessionSurface, canUseSessionS
       // Early preview no longer suppresses the canonical body notification;
       // notifyTaskCompletion fires once with output via resolve/reconcile.
       const finalValue = completionValue(result);
+      if (job?.status === 'cancelled') {
+        settleCancelled(null, result);
+        return finalValue;
+      }
       if (finalValue.error) {
         finalStatus = 'error';
         if (job) job._terminalResultValue = finalValue;
@@ -107,6 +125,10 @@ export function createSendFlow({ mgr, defaultCwd, sessionSurface, canUseSessionS
       }
       return finalValue;
     } catch (error) {
+      if (job?.status === 'cancelled') {
+        settleCancelled(error);
+        throw error;
+      }
       const partial = watchdogPartialHandoffFromError(error, mgr.getSession(sessionId), handoffMsgStart);
       if (partial) {
         finalStatus = 'idle';
@@ -123,10 +145,6 @@ export function createSendFlow({ mgr, defaultCwd, sessionSurface, canUseSessionS
         reconcileJobWatchdogPartial(job, value);
         return value;
       }
-      if (job?.status === 'cancelled') {
-        finalStatus = 'cancelled';
-        throw error;
-      }
       finalStatus = 'error';
       reconcileJobStreamStalled(job, error);
       throw error;

package/src/session-runtime/services/agent-tool/spawn-flow/job-start.mjs

@@ -44,6 +44,8 @@ export function createJobStarter({ mgr, notifyStatusChange, notifySessionComplet
       meta: jobMeta,
       resultType: 'agent_task_result',
       renderResult: (result) => renderResult(result),
+      // Cancellation reaches the owner once, with the worker's partial output.
+      notifyOnCancel: true,
       cancel: () => {
         try {
           admissionController.abort(new Error('agent task cancelled before resource admission'));

package/src/session-runtime/services/agent-tool/spawn-flow/spawn-run.mjs

@@ -6,6 +6,7 @@
  */
 import { createNotify } from '../notify.mjs';
 import {
+  reconcileJobCancelled,
   reconcileJobFinally,
   reconcileJobStreamStalled,
   reconcileJobWatchdogPartial,
@@ -15,11 +16,13 @@ import { abnormalEmptyFinishError } from '../render.mjs';
 import { createProgressWatchdogRegistry } from '../../agent-watchdog-registry.mjs';
 import {
   resolveHandoffMessageStartIndex,
+  turnPartialHandoff,
   watchdogPartialHandoffFromError,
   watchdogStoppedHandoff,
 } from '../../../../runtime/agent/orchestrator/agent-runtime/agent-progress-watchdog.mjs';
 import { saveSessionAsync } from '../../../../runtime/agent/orchestrator/session/store.mjs';
 import { presetDescriptor } from './spawn-prep.mjs';
+import { workerStageForStatus } from '../worker-rows.mjs';
 
 // Mid-turn worker persistence cadence. The watchdog sweep runs every second;
 // a transcript save is far more expensive than a bookkeeping stamp, so the
@@ -68,7 +71,7 @@ export function createSpawnRunner({
       const messages = Number(progress?.messages) || 0;
       upsertWorkerSessionDeferred(session, tag, {
         status: 'running',
-        stage: progress.stage || 'running',
+        stage: workerStageForStatus('running', progress.stage),
         ...(messages > 0 ? { messages } : {}),
       });
       // The canonical runtime owns persistence; this session is only its descriptor.
@@ -135,6 +138,16 @@ export function createSpawnRunner({
     });
     notifyStatusChange();
     let handoffMsgStart = 0;
+    // A cancelled turn reports the output it produced before it stopped.
+    const settleCancelled = (error, result = null) => {
+      finalStatus = 'cancelled';
+      reconcileJobCancelled(job, {
+        tag,
+        sessionId: session.id,
+        ...presetDescriptor(agent, preset, presetName),
+        content: turnPartialHandoff(error, mgr.getSession(session.id), handoffMsgStart) || result?.content || '',
+      });
+    };
     try {
       handoffMsgStart = resolveHandoffMessageStartIndex(mgr.getSession(session.id));
       const turnHooks = {
@@ -157,6 +170,10 @@ export function createSpawnRunner({
       // notifyTaskCompletion is left to fire exactly once with output via the
       // resolve/reconcile/finally path.
       const finalValue = completionValue(result);
+      if (job?.status === 'cancelled') {
+        settleCancelled(null, result);
+        return finalValue;
+      }
       // Non-job return path (or job path where the terminal-result reconcile
       // already ran): if the finish was abnormal-empty, surface it as a thrown
       // error so finalStatus becomes 'error' and the caller's error path (and
@@ -168,6 +185,10 @@ export function createSpawnRunner({
       }
       return finalValue;
     } catch (error) {
+      if (job?.status === 'cancelled') {
+        settleCancelled(error);
+        throw error;
+      }
       const partial = watchdogPartialHandoffFromError(error, mgr.getSession(session.id), handoffMsgStart);
       if (partial) {
         finalStatus = 'idle';
@@ -182,10 +203,6 @@ export function createSpawnRunner({
         reconcileJobWatchdogPartial(job, value);
         return value;
       }
-      if (job?.status === 'cancelled') {
-        finalStatus = 'cancelled';
-        throw error;
-      }
       finalStatus = 'error';
       reconcileJobStreamStalled(job, error);
       throw error;

package/src/session-runtime/services/agent-tool/tag-registry.mjs

@@ -29,7 +29,7 @@ export function createTagRegistry({ dataDir, cfgMod, mgr }) {
     workerRowFromSession: index.workerRowFromSession,
   });
 
-  const { upsertLeadSession, updateLeadWorkerCwd } = leadIndex;
+  const { upsertLeadSession, updateLeadWorkerCwd, forgetLeadSession } = leadIndex;
 
   function dispose(options) {
     try {
@@ -39,6 +39,17 @@ export function createTagRegistry({ dataDir, cfgMod, mgr }) {
     }
   }
 
+  /** Drain every queued index write (batches included) without disposing. */
+  async function flushIndexWrites() {
+    await Promise.all([index.flushWorkerIndexWrites(), leadIndex.flushLeadWorkerIndexWrites()]);
+  }
+
+  async function disposeAsync(options) {
+    const results = await Promise.allSettled([index.disposeAsync(), leadIndex.disposeAsync(options)]);
+    const failed = results.find((result) => result.status === 'rejected');
+    if (failed) throw failed.reason;
+  }
+
   function getLiveSession(sessionId) {
     if (!sessionId) return null;
     const session = mgr.getSession(sessionId);
@@ -95,6 +106,8 @@ export function createTagRegistry({ dataDir, cfgMod, mgr }) {
 
   return {
     dispose,
+    disposeAsync,
+    flushIndexWrites,
     readAllTagTombstones: index.readAllTagTombstones,
     readTagTombstones: index.readTagTombstones,
     readWorkerRows,
@@ -104,6 +117,7 @@ export function createTagRegistry({ dataDir, cfgMod, mgr }) {
     upsertWorkerSessionDeferred,
     upsertLeadSession,
     updateLeadWorkerCwd,
+    forgetLeadSession,
     removeWorkerRow,
     refreshTagsFromIndex,
     tags,

package/src/session-runtime/services/agent-tool/worker-index/row-liveness.mjs

@@ -11,8 +11,15 @@ const ACTIVE_WORKER_STATUS =
   /^(?:connecting|requesting|streaming|tool[-_\s]?running|running|queued|pending|starting|cancelling)$/i;
 const WORKER_POOL_FRESH_MS = 2 * 60 * 1000;
 
+const CANCELLED_WORKER_STATUS = /^(?:cancelled|canceled|killed|cancel[-_\s]?(?:unconfirmed|pending))$/i;
+
+/** `status` decides; `stage` is the runtime phase copied in by the progress
+ *  sweep and only decides for a row with no status. A cancel in either field
+ *  is not work (bare `cancelling` still is). */
 export const isActiveWorkerRow = (row) =>
-  ACTIVE_WORKER_STATUS.test(clean(row?.status)) || ACTIVE_WORKER_STATUS.test(clean(row?.stage));
+  !CANCELLED_WORKER_STATUS.test(clean(row?.status)) &&
+  !CANCELLED_WORKER_STATUS.test(clean(row?.stage)) &&
+  ACTIVE_WORKER_STATUS.test(clean(row?.status) || clean(row?.stage));
 
 /** A persisted approval wait whose runtime is gone: the in-memory wait died
  *  with that process (daemon restart), so the flag must not stick. */

package/src/session-runtime/services/agent-tool/worker-index/row-shape.mjs

@@ -2,7 +2,7 @@
 // The one row shape of the worker index: coercing whatever a stored file or a
 // caller hands in, and projecting a live session into a row.
 import { agentTagOf, clean, positiveInt } from '../helpers.mjs';
-import { isLeadPoolAgent } from '../worker-rows.mjs';
+import { isLeadPoolAgent, workerStageForStatus } from '../worker-rows.mjs';
 
 /** An explicit boolean wins; otherwise the session's own fast flag (true) or unknown. */
 function fastFlag(explicit, sessionFast) {
@@ -72,7 +72,7 @@ export function workerRowFromSession(session, fallbackTag = '', extra = {}, getS
   if (!tag || !sessionId) return null;
   const runtime = getSessionRuntime(sessionId);
   const status = clean(extra.status) || (session?.closed === true ? 'closed' : clean(session?.status) || 'idle');
-  const stage = clean(extra.stage) || clean(runtime?.stage) || status;
+  const stage = clean(extra.stage) || workerStageForStatus(status, runtime?.stage);
   const nowIso = new Date().toISOString();
   return {
     tag,

package/src/session-runtime/services/agent-tool/worker-index/row-store.mjs

@@ -157,6 +157,7 @@ export function createWorkerRowStore(file) {
     flush: queue.flush,
     /** Exit path: persist what is still queued, synchronously. */
     flushSync: queue.flushSync,
+    hasUnpersisted: queue.hasUnpersisted,
     invalidate: () => {
       dirty = true;
     },
@@ -183,7 +184,15 @@ export function acquireWorkerRowStore(file) {
       if (released) return;
       released = true;
       entry.refs -= 1;
-      if (entry.refs === 0 && sharedStores.get(key) === entry) sharedStores.delete(key);
+      const dropIfIdle = () => {
+        if (entry.refs === 0 && !entry.store.hasUnpersisted() && sharedStores.get(key) === entry) {
+          sharedStores.delete(key);
+        }
+      };
+      // A store still holding unpersisted writes stays shared (a new holder
+      // must see them) until its queue drains.
+      if (entry.refs === 0 && entry.store.hasUnpersisted()) entry.store.flush().then(dropIfIdle, () => {});
+      else dropIfIdle();
     },
   };
 }

package/src/session-runtime/services/agent-tool/worker-index.mjs

@@ -173,7 +173,9 @@ export function createWorkerIndex({ dataDir, cfgMod, mgr, tags, tagAgents, tagCw
   function flushWorkerIndexOnExit() {
     batch.flush();
     flushActiveWorkerRows();
-    // Writes are persisted by an async queue; the loop is gone at exit.
+    // Writes are persisted by an async queue; the loop is gone at exit. This
+    // is the best-effort last resort: a persist still running is left alone
+    // (the graceful shutdown path drains before exit).
     store.flushSync();
   }
 
@@ -181,25 +183,62 @@ export function createWorkerIndex({ dataDir, cfgMod, mgr, tags, tagAgents, tagCw
   const unregisterExitFlush = registerExitFlush(flushWorkerIndexOnExit);
   const unregisterApprovalWaits = registerApprovalWaitWriter(file, setAwaitingUser);
   let disposed = false;
+  let disposePromise = null;
+
+  function teardown() {
+    unregisterExitFlush();
+    unregisterApprovalWaits();
+    releaseStore();
+  }
+
+  async function drainThenTeardown() {
+    batch.flush();
+    await store.flush();
+    teardown();
+  }
 
   /** Persist queued rows, then release the exit registration. Active rows are
    *  NOT settled: they are keyed by process pid, which every inline runtime in
-   *  the daemon shares, so settling here would idle other runtimes' workers. */
+   *  the daemon shares, so settling here would idle other runtimes' workers.
+   *  When the sync flush cannot run (this process's async writer holds the
+   *  lock) the exit hook and store ref stay until the async drain settles. */
   function dispose() {
     if (disposed) return;
     disposed = true;
+    let flushed = false;
     try {
       batch.flush();
-      store.flushSync();
-    } finally {
-      unregisterExitFlush();
-      unregisterApprovalWaits();
-      releaseStore();
+      flushed = store.flushSync();
+    } catch {}
+    if (flushed) {
+      teardown();
+      return;
+    }
+    disposePromise = drainThenTeardown().catch(reopenAfterFailedDrain);
+  }
+
+  /** A failed drain tears nothing down; allow a later dispose to retry it. */
+  function reopenAfterFailedDrain() {
+    disposed = false;
+    disposePromise = null;
+  }
+
+  /** Awaitable dispose: drain everything, then tear down. A failed drain
+   *  rejects and leaves the registrations in place. */
+  function disposeAsync() {
+    if (!disposePromise) {
+      disposed = true;
+      disposePromise = drainThenTeardown().catch((error) => {
+        reopenAfterFailedDrain();
+        throw error;
+      });
     }
+    return disposePromise;
   }
 
   return {
     dispose,
+    disposeAsync,
     workerIndexPath: () => file,
     invalidateWorkerRowsCache: store.invalidate,
     readAllWorkerRows: store.readAll,

package/src/session-runtime/services/agent-tool/worker-rows.mjs

@@ -1,4 +1,5 @@
 import { agentTagOf, clean, positiveInt, stampMs } from './helpers.mjs';
+import { ACTIVE_STAGES } from './tool-def.mjs';
 
 import { TAG_TOMBSTONE_TTL_MS, tagTombstoneKey } from '../../../runtime/shared/agent-reap-state.mjs';
 export { TAG_TOMBSTONE_TTL_MS, tagTombstoneKey };
@@ -27,6 +28,22 @@ export function isTerminalWorkerStatus(status) {
   );
 }
 
+const WORKING_WORKER_STATUS =
+  /^(?:connecting|requesting|streaming|tool[-_\s]?running|running|queued|pending|starting|cancelling)$/i;
+const WORKING_WORKER_STAGES = new Set([...ACTIVE_STAGES, 'resource_wait']);
+
+/** The `stage` to store beside a worker `status`, from a stage read off the
+ *  live runtime. That stage is the runtime's own phase, so mid-work it can say
+ *  `idle`/`done`/`error` (a fresh or just-settled runtime entry) while the
+ *  worker is still running. Stored next to a working status it made a mixed
+ *  row that readers classified as finished, so a working status keeps a
+ *  working stage and falls back to the status itself. */
+export function workerStageForStatus(status, runtimeStage) {
+  const stage = clean(runtimeStage);
+  if (!WORKING_WORKER_STATUS.test(clean(status))) return stage || clean(status);
+  return WORKING_WORKER_STAGES.has(stage.toLowerCase()) ? stage : clean(status);
+}
+
 export function recoverTagTombstoneOwner(row, sessions) {
   if (clean(row.parentSessionId || row.ownerSessionId)) return row;
   const pid = positiveInt(row.clientHostPid);

package/src/session-runtime/services/agent-tool.mjs

@@ -147,7 +147,10 @@ export function createStandaloneAgent({
     recoverWorkers,
     upsertLeadSession: registry.upsertLeadSession,
     updateLeadWorkerCwd: registry.updateLeadWorkerCwd,
+    forgetLeadSession: registry.forgetLeadSession,
     closeAll: closeFlow.closeAll,
     dispose: (options) => registry.dispose(options),
+    disposeAsync: (options) => registry.disposeAsync(options),
+    flushIndexWrites: () => registry.flushIndexWrites(),
   };
 }

package/src/session-runtime/services/channel-admin.mjs

@@ -26,6 +26,8 @@ import { normalizeAutomationAttachments } from '../../runtime/shared/automation-
 import { migrateCodexModelRef } from '../../runtime/agent/orchestrator/providers/openai-oauth-catalog-store.mjs';
 import { hasEnabledAutomation } from '../../runtime/shared/automation-presence.mjs';
 import { resolveScheduleTimezone, validateScheduleCron } from '../../runtime/shared/schedule-time.mjs';
+import { pgClusterExists } from '../../runtime/memory/lib/pg/adapter.mjs';
+import { resolvePluginData } from '../../runtime/shared/plugin-paths.mjs';
 import { readHookPublicBase } from '../../runtime/channels/lib/webhook/relay-tunnel.mjs';
 import { WEBHOOK_TEST_FIELD, WEBHOOK_TEST_HEADER } from '../../runtime/channels/lib/webhook/request-handler.mjs';
 
@@ -463,10 +465,20 @@ export async function testWebhook(name) {
 // and webhooks run sessions, so they must not require Discord/Telegram
 // tokens or an explicit remote toggle.
 async function checkActiveAutomation() {
-  const [schedules, webhooks] = await Promise.all([listSchedules(), listWebhooks()]);
+  const { schedules, webhooks } = await readAutomationRows();
   return hasEnabledAutomation({ schedules, webhooks });
 }
 
+// Read-only views (channel setup, the automation probe) never bring
+// PostgreSQL up for the first time: before initdb ran no schedule or webhook
+// can exist, and that first start — runtime download/extract plus initdb — is
+// seconds of work no catalog read should wait on. Writes still start it.
+async function readAutomationRows() {
+  if (!pgClusterExists(resolvePluginData())) return { schedules: [], webhooks: [] };
+  const [schedules, webhooks] = await Promise.all([listSchedules(), listWebhooks()]);
+  return { schedules, webhooks };
+}
+
 // Every session runtime in the process asks this at boot. Concurrent callers
 // join one in-flight check and a settled answer is reused for ttlMs, so N
 // runtimes booting together cost one PG query (and at most one PG boot)
@@ -519,8 +531,12 @@ export function hasActiveAutomation() {
   return automationProbe.probe();
 }
 
+// The daemon opens both stores in the background once ready (it settles
+// hasActiveAutomation), so on an existing cluster this read joins a
+// PostgreSQL start already under way instead of being the one that starts it.
 export async function channelSetup(config = null) {
   const cfg = normalizeChannelsConfig(config || readSection('channels'));
+  const { schedules, webhooks } = await readAutomationRows();
   return {
     webhook: {
       ...(cfg.webhook || {}),
@@ -528,7 +544,7 @@ export async function channelSetup(config = null) {
       // connects and mints its hook identity).
       publicUrl: readHookPublicBase(),
     },
-    schedules: await listSchedules(),
-    webhooks: await listWebhooks(),
+    schedules,
+    webhooks,
   };
 }

package/src/session-runtime/services/memory-runtime-proxy/calls.mjs

@@ -41,6 +41,9 @@ export function createMemoryCalls({ state, cwd, start, discovery, registry }) {
       ...(transcriptCwd ? { cwd: transcriptCwd } : {}),
     });
   }
+  async function forgetTranscripts(filePaths = []) {
+    return await requestMemoryPath('/transcript/forget', { filePaths }, { timeoutMs: 10_000 });
+  }
   async function recordTraceEvents(events = []) {
     return await requestMemoryPath('/admin/trace-record', { events }, { timeoutMs: 5_000 });
   }
@@ -120,6 +123,7 @@ export function createMemoryCalls({ state, cwd, start, discovery, registry }) {
     retain,
     appendEntry,
     ingestTranscript,
+    forgetTranscripts,
     recordTraceEvents,
     handleToolCall,
     buildSessionCoreMemoryPayload,

package/src/session-runtime/services/memory-runtime-proxy.mjs

@@ -91,6 +91,7 @@ function createStandaloneMemoryRuntime({ entry, dataDir, cwd = process.cwd() } =
     warmupEmbedding: calls.warmupEmbedding,
     appendEntry: calls.appendEntry,
     ingestTranscript: calls.ingestTranscript,
+    forgetTranscripts: calls.forgetTranscripts,
     recordTraceEvents: calls.recordTraceEvents,
     moduleUrl: pathToFileURL(entry).href,
   };