mixdog 0.9.172 → 0.9.174

package/src/runtime/attachments/store.mjs

@@ -17,8 +17,8 @@ import {
   utimesSync,
   writeFileSync,
 } from 'node:fs';
-import { readdir, readFile as readFileAsync, stat, unlink } from 'node:fs/promises';
-import { join } from 'node:path';
+import { mkdir, readdir, readFile as readFileAsync, rename, stat, unlink, writeFile } from 'node:fs/promises';
+import { dirname, join } from 'node:path';
 
 import { resolvePluginData } from '../shared/plugin-paths.mjs';
 import { inspectPdfBuffer } from './pdf-extract.mjs';
@@ -37,18 +37,49 @@ const ATTACHMENT_GC_MIN_AGE_MS = Math.max(
 );
 const ATTACHMENT_GC_INTERVAL_MS = 6 * 60 * 60 * 1000;
 const ATTACHMENT_GC_START_DELAY_MS = 5_000;
+// A census that died mid-run must not hold the claim forever.
+const ATTACHMENT_GC_LOCK_STALE_MS = 60 * 60 * 1000;
 
 const bufferCache = new Map();
 let bufferCacheBytes = 0;
 let cacheHits = 0;
 let cacheMisses = 0;
 let attachmentGcTimer = null;
-let lastAttachmentGcAt = 0;
+// Referenced ids per reference file, keyed by path + full stat stamp.
+let referenceCache = null; // { root, files: Map<path, { stamp, refs }> }
 
 function attachmentsDir() {
   return join(resolvePluginData(), 'prompt-attachments', 'sha256');
 }
 
+// The census reads every session file, so its 6-hour cadence must hold across
+// processes: an in-memory timestamp alone re-ran it 5 s after every CLI, TUI
+// and daemon launch (a 1.9 GB census spiked the heap past 500 MB).
+function attachmentGcStampPath() {
+  return join(resolvePluginData(), 'prompt-attachments', 'gc-last-run');
+}
+
+function attachmentGcLockPath() {
+  return join(resolvePluginData(), 'prompt-attachments', 'gc-running');
+}
+
+function attachmentReferenceCachePath() {
+  return join(resolvePluginData(), 'prompt-attachments', 'gc-reference-cache.json');
+}
+
+function readAttachmentGcStamp() {
+  try {
+    return statSync(attachmentGcStampPath()).mtimeMs;
+  } catch {
+    return 0;
+  }
+}
+
+function writeAttachmentGcStamp() {
+  mkdirSync(join(resolvePluginData(), 'prompt-attachments'), { recursive: true });
+  writeFileSync(attachmentGcStampPath(), '');
+}
+
 function attachmentPath(ref) {
   const value = String(ref || '');
   if (!ATTACHMENT_REF_RE.test(value)) throw new TypeError('prompt attachment reference is invalid');
@@ -81,13 +112,19 @@ function saveBuffer(buffer) {
   }
   const attachmentRef = createHash('sha256').update(buffer).digest('hex');
   const target = attachmentPath(attachmentRef);
-  let existingValid = false;
-  if (existsSync(target)) {
+  // The file already at this content address is only usable when it really is
+  // this content; an unreadable or mismatched blob counts as absent.
+  const storedMatches = () => {
     try {
       const current = readFileSync(target);
-      existingValid =
-        current.length === buffer.length && createHash('sha256').update(current).digest('hex') === attachmentRef;
-    } catch {}
+      return current.length === buffer.length && createHash('sha256').update(current).digest('hex') === attachmentRef;
+    } catch {
+      return false;
+    }
+  };
+  let existingValid = false;
+  if (existsSync(target)) {
+    existingValid = storedMatches();
     if (!existingValid) {
       try {
         unlinkSync(target);
@@ -101,13 +138,8 @@ function saveBuffer(buffer) {
     try {
       renameSync(temp, target);
     } catch (error) {
-      let racedValid = false;
-      try {
-        const current = readFileSync(target);
-        racedValid =
-          current.length === buffer.length && createHash('sha256').update(current).digest('hex') === attachmentRef;
-      } catch {}
-      if (!racedValid) throw error;
+      // A concurrent writer may have published the same content first.
+      if (!storedMatches()) throw error;
     } finally {
       try {
         unlinkSync(temp);
@@ -162,6 +194,12 @@ export function readAttachmentBuffer(value) {
   return buffer;
 }
 
+// A referenced blob that is gone from disk (retention, manual cleanup, a
+// copied session) surfaces from readAttachmentBuffer as the stat ENOENT.
+export function isMissingAttachmentError(error) {
+  return error?.code === 'ENOENT';
+}
+
 export function readAttachmentBase64(value) {
   return readAttachmentBuffer(value).toString('base64');
 }
@@ -456,22 +494,105 @@ async function persistedAttachmentReferencePaths() {
   return paths;
 }
 
+const ATTACHMENT_REF_KEY = Buffer.from('"attachmentRef"');
+
+function isJsonSpace(byte) {
+  return byte === 0x20 || byte === 0x09 || byte === 0x0a || byte === 0x0d;
+}
+
+// Matches `"attachmentRef" : "<64 hex>"` on the raw bytes. Decoding each
+// session file to a UTF-8 string and running a regex over it dominated the
+// census CPU; the key and value are ASCII, so no decode is needed.
+function addReferencedAttachments(buffer, referenced) {
+  let at = buffer.indexOf(ATTACHMENT_REF_KEY);
+  while (at !== -1) {
+    let i = at + ATTACHMENT_REF_KEY.length;
+    while (isJsonSpace(buffer[i])) i += 1;
+    if (buffer[i] === 0x3a) {
+      i += 1;
+      while (isJsonSpace(buffer[i])) i += 1;
+      if (buffer[i] === 0x22 && buffer[i + 65] === 0x22) {
+        const ref = buffer.toString('latin1', i + 1, i + 65);
+        if (ATTACHMENT_REF_RE.test(ref)) referenced.add(ref);
+      }
+    }
+    at = buffer.indexOf(ATTACHMENT_REF_KEY, at + ATTACHMENT_REF_KEY.length);
+  }
+}
+
+function referenceFileStamp(info) {
+  return `${info.dev}:${info.ino}:${info.size}:${info.mtimeNs}:${info.ctimeNs}`;
+}
+
+// Session files are mostly idle, so a census re-reads only the files whose
+// stamp changed since the last census in any process (the cache is persisted
+// beside the run stamp). An unusable cache file only costs a full re-read.
+async function loadReferenceCache(root) {
+  if (referenceCache?.root === root) return referenceCache.files;
+  const files = new Map();
+  try {
+    const parsed = JSON.parse(await readFileAsync(attachmentReferenceCachePath(), 'utf8'));
+    if (parsed?.version === 1 && parsed.files && typeof parsed.files === 'object') {
+      for (const [path, entry] of Object.entries(parsed.files)) {
+        if (
+          typeof entry?.stamp === 'string' &&
+          Array.isArray(entry.refs) &&
+          entry.refs.every((ref) => ATTACHMENT_REF_RE.test(String(ref)))
+        ) {
+          files.set(path, { stamp: entry.stamp, refs: entry.refs });
+        }
+      }
+    }
+  } catch {}
+  referenceCache = { root, files };
+  return files;
+}
+
+async function saveReferenceCache(root, files) {
+  referenceCache = { root, files };
+  const target = attachmentReferenceCachePath();
+  const temp = `${target}.${process.pid}.${randomBytes(6).toString('hex')}.tmp`;
+  try {
+    await mkdir(dirname(target), { recursive: true });
+    await writeFile(temp, JSON.stringify({ version: 1, files: Object.fromEntries(files) }));
+    await rename(temp, target);
+  } catch {
+    try {
+      await unlink(temp);
+    } catch {}
+  }
+}
+
 export async function collectPromptAttachments({ now = Date.now(), minAgeMs = ATTACHMENT_GC_MIN_AGE_MS } = {}) {
+  const root = resolvePluginData();
+  const cached = await loadReferenceCache(root);
+  const current = new Map();
+  let reread = false;
   const referenced = new Set();
   let referenceFiles = 0;
   for (const path of await persistedAttachmentReferencePaths()) {
-    let raw;
+    let entry;
     try {
-      raw = await readFileAsync(path, 'utf8');
+      // Stat before reading: content changed after the stat gets a new stamp,
+      // so the next census re-reads it.
+      const stamp = referenceFileStamp(await stat(path, { bigint: true }));
+      entry = cached.get(path);
+      if (entry?.stamp !== stamp) {
+        const found = new Set();
+        addReferencedAttachments(await readFileAsync(path), found);
+        entry = { stamp, refs: [...found] };
+        reread = true;
+      }
     } catch (error) {
       if (error?.code === 'ENOENT') continue;
       // A partial reference census must never authorize deletion.
       return { deleted: 0, referenced: 0, fresh: 0, scanned: 0, incomplete: true };
     }
+    current.set(path, entry);
     referenceFiles += 1;
-    const regex = /"attachmentRef"\s*:\s*"([a-f0-9]{64})"/g;
-    for (let match = regex.exec(raw); match !== null; match = regex.exec(raw)) referenced.add(match[1]);
+    for (const ref of entry.refs) referenced.add(ref);
   }
+  if (reread || current.size !== cached.size) await saveReferenceCache(root, current);
 
   const cutoff = Number(now) - Math.max(0, Number(minAgeMs) || 0);
   let prefixes;
@@ -524,27 +645,79 @@ export async function collectPromptAttachments({ now = Date.now(), minAgeMs = AT
   return { deleted, referenced: referenced.size, fresh, scanned, referenceFiles };
 }
 
+// Remaining wait while a census from any process is within the interval, else 0.
+function attachmentGcFreshFor() {
+  const last = readAttachmentGcStamp();
+  return last > 0 ? Math.max(0, ATTACHMENT_GC_INTERVAL_MS - (Date.now() - last)) : 0;
+}
+
+// Exclusive per-data-dir claim so concurrent processes never run the census
+// together. Returns whether this process created the claim file, or null when
+// the claim itself is unusable (the census then runs unclaimed, as before).
+function claimAttachmentGc() {
+  const lock = attachmentGcLockPath();
+  for (let attempt = 0; attempt < 2; attempt += 1) {
+    try {
+      mkdirSync(dirname(lock), { recursive: true });
+      writeFileSync(lock, String(process.pid), { flag: 'wx' });
+      return true;
+    } catch (error) {
+      if (error?.code !== 'EEXIST') return null;
+    }
+    try {
+      if (Date.now() - statSync(lock).mtimeMs < ATTACHMENT_GC_LOCK_STALE_MS) return false;
+      unlinkSync(lock);
+    } catch {}
+  }
+  return false;
+}
+
+// Runs the census unless another process ran it within the interval or is
+// running it now; the stamp is re-read at fire time, not only when armed.
+// Resolves to the delay before the next attempt.
+async function runScheduledAttachmentGc() {
+  const freshFor = attachmentGcFreshFor();
+  if (freshFor > 0) return freshFor;
+  const claim = claimAttachmentGc();
+  if (claim === false) return ATTACHMENT_GC_INTERVAL_MS;
+  try {
+    const claimedFreshFor = attachmentGcFreshFor();
+    if (claimedFreshFor > 0) return claimedFreshFor;
+    const result = await collectPromptAttachments();
+    if (!result?.incomplete) writeAttachmentGcStamp();
+    return ATTACHMENT_GC_INTERVAL_MS;
+  } finally {
+    if (claim) {
+      try {
+        unlinkSync(attachmentGcLockPath());
+      } catch {}
+    }
+  }
+}
+
 function armAttachmentGc(delayMs) {
   if (attachmentGcTimer) return;
   attachmentGcTimer = setTimeout(
     () => {
       attachmentGcTimer = null;
-      void collectPromptAttachments()
-        .catch(() => undefined)
-        .finally(() => {
-          lastAttachmentGcAt = Date.now();
-          armAttachmentGc(ATTACHMENT_GC_INTERVAL_MS);
-        });
+      void runScheduledAttachmentGc()
+        .catch(() => ATTACHMENT_GC_INTERVAL_MS)
+        .then((nextDelayMs) => armAttachmentGc(nextDelayMs));
     },
     Math.max(ATTACHMENT_GC_START_DELAY_MS, Number(delayMs) || 0)
   );
   attachmentGcTimer.unref?.();
 }
 
+// Armed by saveBuffer and by daemon start (startAttachmentGc): the daemon
+// intake (session-service submitSession) is the sole attachment writer, and
+// blobs orphaned by deleted sessions must not wait for the next attachment.
+// Readers (TUI, provider lowering) never run it.
 function scheduleAttachmentGc() {
   if (attachmentGcTimer) return;
-  const elapsed = Date.now() - lastAttachmentGcAt;
-  armAttachmentGc(lastAttachmentGcAt === 0 ? ATTACHMENT_GC_START_DELAY_MS : ATTACHMENT_GC_INTERVAL_MS - elapsed);
+  armAttachmentGc(attachmentGcFreshFor());
 }
 
-scheduleAttachmentGc();
+export function startAttachmentGc() {
+  scheduleAttachmentGc();
+}

package/src/runtime/browser-bridge/action-schema.mjs

@@ -269,7 +269,7 @@ function sequenceStepError(step, index) {
   if (!allowed) return `${at} action must be one of ${SEQUENCE_STEP_ACTIONS.join(', ')}`;
   const unsupported = Object.keys(step).filter((name) => name !== 'action' && !allowed.includes(name));
   if (unsupported.length) return `${at} does not accept field(s): ${unsupported.join(', ')}`;
-  const present = (name) => Object.hasOwn(step, name) && step[name] !== undefined && step[name] !== null;
+  const present = (name) => hasInputValue(step, name);
   const requirements = SEQUENCE_STEP_REQUIRED[stepAction];
   if (requirements.length && !requirements.some((names) => names.every(present))) {
     return `${at} requires ${requirements.map((names) => names.join('+')).join(' or ')}`;
@@ -348,6 +348,9 @@ export function buildBrowserInputSchema(flatSchema, actions = BROWSER_ACTIONS) {
   if (scoped.format && !actions.includes('snapshot')) {
     scoped.format = { ...scoped.format, enum: ['jpeg', 'png'], description: 'Post-action screenshot format.' };
   }
+  // A tool whose actions all take optional fields names no requirement at all
+  // rather than an empty "Required: ." list.
+  const required = requiredSummary(actions);
   return {
     type: 'object',
     description: 'Choose one Browser Use action and pass only its fields in input.',
@@ -355,7 +358,7 @@ export function buildBrowserInputSchema(flatSchema, actions = BROWSER_ACTIONS) {
       action: { ...action, enum: [...actions] },
       input: {
         type: 'object',
-        description: `Fields for the selected action. Required: ${requiredSummary(actions)}. Omit input when none are needed.`,
+        description: `Fields for the selected action.${required ? ` Required: ${required}.` : ''} Omit input when none are needed.`,
         properties: scoped,
       },
     },
@@ -382,15 +385,15 @@ function resolveBrowserInput(action, args) {
   return { input };
 }
 
+const STRING_FIELD_LIMITS = Object.entries(BROWSER_INPUT_FIELDS.properties)
+  .filter(([, field]) => field.type === 'string' && field.maxLength !== undefined)
+  .map(([name, field]) => [name, field.maxLength]);
+
 // String and string-array fields stay within the schema's size limits.
 function boundedFieldsError(action, input) {
-  const stringLimits = Object.fromEntries(
-    Object.entries(BROWSER_INPUT_FIELDS.properties)
-      .filter(([, field]) => field.type === 'string' && field.maxLength !== undefined)
-      .map(([name, field]) => [name, name === 'script' && action === 'init_script' ? 20_000 : field.maxLength])
-  );
-  for (const [name, limit] of Object.entries(stringLimits)) {
+  for (const [name, maxLength] of STRING_FIELD_LIMITS) {
     if (!Object.hasOwn(input, name)) continue;
+    const limit = name === 'script' && action === 'init_script' ? 20_000 : maxLength;
     if (typeof input[name] !== 'string' || schemaStringLength(input[name]) > limit) {
       return `browser action "${action}" input.${name} must be a string of at most ${limit} characters`;
     }

package/src/runtime/browser-bridge/client.mjs

@@ -10,6 +10,7 @@
 import { BROWSER_OBSERVATION_ACTIONS, validateBrowserToolArgs } from './action-schema.mjs';
 import { bridgeDiscoveryChanged, readBridgeDiscovery, readBridgeDiscoveryDetail } from '../bridge-discovery.mjs';
 import { traceBrowserTiming } from './timing.mjs';
+import { base64ByteLength, inlineFileKind } from '../shared/inline-file-kind.mjs';
 
 const DISCOVERY_FILE = 'browser-bridge.json';
 /** Ceiling above the bridge's own per-action timeouts (navigation settle,
@@ -26,7 +27,7 @@ const browserTurns = new Map();
 
 /** Terminal lifecycle cleanup uses the exact bridge that owned this turn.
  * It is never retried after dispatch and never inherits the cancelled tool signal. */
-export async function finishBrowserTurn(sessionId, turnId) {
+export async function finishBrowserTurn(sessionId, turnId, { aborted = false } = {}) {
   const turns = browserTurns.get(sessionId);
   const discovery = turns?.get(turnId);
   if (!discovery) return;
@@ -38,6 +39,9 @@ export async function finishBrowserTurn(sessionId, turnId) {
       action: 'finish_turn',
       session_id: sessionId,
       turn_id: turnId,
+      // A turn that ended well may still be continued by the next message,
+      // so its pages stay; only an aborted run reclaims them.
+      aborted: aborted === true,
     }),
     AbortSignal.timeout(REQUEST_TIMEOUT_MS),
     { sessionId, turnId, action: 'finish_turn' }
@@ -93,6 +97,7 @@ function attachBrowserMedia(content, value) {
     if (
       !/^[a-z0-9.+-]+\/[a-z0-9.+-]+$/i.test(mimeType) ||
       filename.length > 255 ||
+      // biome-ignore lint/suspicious/noControlCharactersInRegex: rejects control characters in a bridge-supplied file name
       /[\u0000-\u001f/\\]/.test(filename) ||
       data.length > MAX_FILE_BASE64_CHARS
     ) {
@@ -103,6 +108,14 @@ function attachBrowserMedia(content, value) {
         type: 'image',
         source: { type: 'base64', media_type: mimeType, data },
       });
+    } else if (inlineFileKind(mimeType, data) === 'binary') {
+      // No provider accepts an archive or a spreadsheet as an inline block, and
+      // the listing above already names the file on disk. Point at it instead
+      // of carrying megabytes of base64 through the conversation.
+      content.push({
+        type: 'text',
+        text: `Download ${filename} (${mimeType}, ${base64ByteLength(data)} bytes) is binary and stays on disk; open it from the path listed above with read.`,
+      });
     } else {
       content.push({ type: 'file', data, mimeType, filename });
     }
@@ -178,6 +191,10 @@ export async function executeBrowserTool(args, options = {}) {
   let discovery = readDiscovery();
   if (!discovery) return browserToolError(unavailableMessage());
   rememberBrowserTurn(sessionId, payload.turn_id, discovery);
+  // An observation can be reported as a plain failure; a state-changing action
+  // that may already have run must say so instead.
+  const settleFailure = (message) =>
+    RETRYABLE_ACTIONS.has(validated.action) ? browserToolError(message) : uncertainMutation(message);
   let bridgeResult;
   for (let attempt = 0; attempt < 2; attempt += 1) {
     try {
@@ -192,15 +209,9 @@ export async function executeBrowserTool(args, options = {}) {
       break;
     } catch (error) {
       if (error?.name === 'TimeoutError') {
-        return RETRYABLE_ACTIONS.has(validated.action)
-          ? browserToolError('browser bridge timed out and cancelled the active command')
-          : uncertainMutation('browser bridge timed out and cancelled the active command');
-      }
-      if (options.signal?.aborted) {
-        return RETRYABLE_ACTIONS.has(validated.action)
-          ? browserToolError('browser command cancelled')
-          : uncertainMutation('browser command cancelled');
+        return settleFailure('browser bridge timed out and cancelled the active command');
       }
+      if (options.signal?.aborted) return settleFailure('browser command cancelled');
       const replacement = readDiscovery();
       if (attempt === 0 && bridgeDiscoveryChanged(discovery, replacement)) {
         if (RETRYABLE_ACTIONS.has(validated.action)) {

package/src/runtime/browser-bridge/tool-defs.mjs

@@ -51,6 +51,9 @@ const DEVTOOLS_FIELD_NOTES = {
   script: 'init_script add: JS that runs before every page of the tab boots.',
   reload: 'performance start: reload once recording begins.',
   resourceTypes: 'intercept add: limit the rule to these CDP resource types.',
+  query: 'emulate: filters the returned snapshot, as snapshot query does.',
+  maxChars: 'emulate: page-text cap of the returned snapshot; default 2400.',
+  fullPage: 'emulate with includeScreenshot: full-document screenshot; inspection-only.',
 };
 
 function scopedInputSchema(actions, notes) {

package/src/runtime/channels/index.mjs

@@ -1,7 +1,7 @@
 // Thin facade for the channels worker runtime. The implementation was split
 // out into ./lib/worker-main.mjs plus focused lib/ modules; this file preserves
 // the exact public API and boot side-effects by re-exporting from worker-main.
-// Kept as the worker fork entrypoint (mixdog-session-runtime CHANNEL_WORKER_ENTRY).
+// Kept as the channels worker entrypoint the daemon loads.
 export {
   TOOL_DEFS,
   handleToolCall,

package/src/runtime/channels/lib/event-pipeline.mjs

@@ -1,13 +1,16 @@
 import { EventQueue } from './event-queue.mjs';
 import { applyParser, evaluateFilter, applyTemplate } from './executor.mjs';
+/** Rule rows that are objects and not explicitly disabled. */
+function enabledRules(config) {
+  const rawRules = config?.rules;
+  return (Array.isArray(rawRules) ? rawRules : []).filter((r) => r && typeof r === 'object' && r.enabled !== false);
+}
+
 class EventPipeline {
   rules;
   queue;
   constructor(config, channelId) {
-    const rawRules = config?.rules;
-    this.rules = (Array.isArray(rawRules) ? rawRules : []).filter(
-      (r) => r && typeof r === 'object' && r.enabled !== false
-    );
+    this.rules = enabledRules(config);
     this.queue = new EventQueue(config?.queue, channelId);
   }
   getQueue() {
@@ -20,10 +23,7 @@ class EventPipeline {
     this.queue.stop();
   }
   reloadConfig(config, channelId) {
-    const rawRules = config?.rules;
-    this.rules = (Array.isArray(rawRules) ? rawRules : []).filter(
-      (r) => r && typeof r === 'object' && r.enabled !== false
-    );
+    this.rules = enabledRules(config);
     this.queue.reloadConfig(config?.queue, channelId);
   }
   // ── Source: webhook ───────────────────────────────────────────────

package/src/runtime/channels/lib/event-queue.mjs

@@ -176,16 +176,10 @@ class EventQueue {
   }
   processBatch() {
     if (!ownerTickAllowed(this, 'batch tick')) return;
-    const files = this.readQueueFiles();
-    const lowFiles = files.filter((f) => {
-      const item = this.readItem(f);
-      return item?.priority === 'low';
-    });
-    if (lowFiles.length === 0) return;
-    const groups = /* @__PURE__ */ new Map();
-    for (const file of lowFiles) {
+    const groups = new Map();
+    for (const file of this.readQueueFiles()) {
       const item = this.readItem(file);
-      if (!item) continue;
+      if (item?.priority !== 'low') continue;
       const group = groups.get(item.name) ?? { items: [], files: [] };
       group.items.push(item);
       group.files.push(file);
@@ -265,6 +259,19 @@ ${p.item.prompt}`
     const match = /^in-progress-\d+-(.+)$/.exec(claimed);
     return match ? match[1] : claimed;
   }
+  // Return one claimed handle to queue/ under its original enqueue-ordered
+  // name. A vanished handle is not an error; anything else is logged.
+  renameToQueue(claimed, original) {
+    try {
+      renameWithRetrySync(join(IN_PROGRESS_DIR, claimed), join(QUEUE_DIR, original));
+      return true;
+    } catch (err) {
+      if (err?.code && err.code !== 'ENOENT') {
+        logEvent(`queue: requeue failed for ${claimed}: ${err.message ?? err}`);
+      }
+      return false;
+    }
+  }
   // Move a single claimed in-progress/ handle back to queue/, restoring the
   // original enqueue-ordered filename. Used when inject fails after claim.
   // Retry budget: after INJECT_MAX_ATTEMPTS failures the item is dead-lettered
@@ -293,13 +300,7 @@ ${p.item.prompt}`
         writeJsonAtomicSync(join(IN_PROGRESS_DIR, claimed), { ...item, injectAttempts: fails }, { fsyncDir: true });
       } catch {}
     }
-    try {
-      renameWithRetrySync(join(IN_PROGRESS_DIR, claimed), join(QUEUE_DIR, original));
-    } catch (err) {
-      if (err?.code && err.code !== 'ENOENT') {
-        logEvent(`queue: requeue failed for ${claimed}: ${err.message ?? err}`);
-      }
-    }
+    this.renameToQueue(claimed, original);
   }
   // ── Helpers ───────────────────────────────────────────────────────
   readQueueFiles() {
@@ -374,16 +375,7 @@ ${p.item.prompt}`
     }
     let count = 0;
     for (const claimed of entries) {
-      const match = /^in-progress-\d+-(.+)$/.exec(claimed);
-      const original = match ? match[1] : claimed;
-      try {
-        renameWithRetrySync(join(IN_PROGRESS_DIR, claimed), join(QUEUE_DIR, original));
-        count++;
-      } catch (err) {
-        if (err?.code && err.code !== 'ENOENT') {
-          logEvent(`queue: requeue failed for ${claimed}: ${err.message ?? err}`);
-        }
-      }
+      if (this.renameToQueue(claimed, this.originalQueueName(claimed))) count++;
     }
     if (count > 0) logEvent(`queue: requeued ${count} stranded in-progress events`);
   }
@@ -408,9 +400,6 @@ ${p.item.prompt}`
   }
   existsSync(p) {
     try {
-      // readdirSync-free existence check via rename would be destructive —
-      // fall back to a cheap stat via readFileSync on non-content probe.
-      // Use fs.existsSync semantics without importing it twice.
       return fsExistsSync(p);
     } catch {
       return false;

package/src/runtime/channels/lib/executor.mjs

@@ -7,17 +7,20 @@ const EVENT_LOG = join(DATA_DIR, 'event.log');
 // Buffered async logger — coalesces per-line appends into batched writes.
 let _eventLogBuf = [];
 let _eventLogTimer = null;
-function _flushEventLog() {
-  _eventLogTimer = null;
-  if (_eventLogBuf.length === 0) return;
+function _drainEventLog() {
+  if (_eventLogBuf.length === 0) return '';
   const lines = _eventLogBuf.join('');
   _eventLogBuf = [];
-  _appendFileAsync(EVENT_LOG, lines, () => {});
+  return lines;
+}
+function _flushEventLog() {
+  _eventLogTimer = null;
+  const lines = _drainEventLog();
+  if (lines) _appendFileAsync(EVENT_LOG, lines, () => {});
 }
 function _flushEventLogSync() {
-  if (_eventLogBuf.length === 0) return;
-  const lines = _eventLogBuf.join('');
-  _eventLogBuf = [];
+  const lines = _drainEventLog();
+  if (!lines) return;
   try {
     appendFileSync(EVENT_LOG, lines);
   } catch {}
@@ -75,37 +78,19 @@ function applyParser(parser, body, headers) {
       return { raw: JSON.stringify(body) };
   }
 }
-function evaluateFilter(expr, data) {
-  const orParts = expr.split('||').map((s) => s.trim());
-  for (const orPart of orParts) {
-    const andParts = orPart.split('&&').map((s) => s.trim());
-    let andResult = true;
-    for (const condition of andParts) {
-      const match = condition.match(/^(\w+)\s*==\s*['"](.*)['"]$/);
-      if (!match) {
-        const neqMatch = condition.match(/^(\w+)\s*!=\s*['"](.*)['"]$/);
-        if (neqMatch) {
-          const [, field2, value2] = neqMatch;
-          if ((data[field2] ?? '') === value2) {
-            andResult = false;
-            break;
-          }
-        } else {
-          andResult = false;
-          break;
-        }
-        continue;
-      }
-      const [, field, value] = match;
-      if ((data[field] ?? '') !== value) {
-        andResult = false;
-        break;
-      }
-    }
-    if (andResult) return true;
-  }
+/** One `field == "value"` / `field != "value"` condition; anything else is false. */
+function conditionHolds(condition, data) {
+  const eq = condition.match(/^(\w+)\s*==\s*['"](.*)['"]$/);
+  if (eq) return (data[eq[1]] ?? '') === eq[2];
+  const neq = condition.match(/^(\w+)\s*!=\s*['"](.*)['"]$/);
+  if (neq) return (data[neq[1]] ?? '') !== neq[2];
   return false;
 }
+function evaluateFilter(expr, data) {
+  return expr
+    .split('||')
+    .some((orPart) => orPart.split('&&').every((condition) => conditionHolds(condition.trim(), data)));
+}
 function applyTemplate(template, data) {
   return template.replace(/\{\{(\w+)\}\}/g, (_, key) => data[key] ?? '');
 }

package/src/runtime/channels/lib/owned-runtime.mjs

@@ -43,10 +43,6 @@ export function createOwnedRuntime(deps) {
     stopOwnedRuntime,
     refreshBridgeOwnershipSafe,
   });
-  // Daemon model: no ownership timer or takeover handler. Kept as no-ops so
-  // the worker start()/teardown call sites stay unchanged.
-  const armBridgeOwnershipTimer = () => {};
-  const clearBridgeOwnershipTimer = () => {};
   return {
     startAutomationRuntime,
     startOwnedRuntime,
@@ -54,8 +50,6 @@ export function createOwnedRuntime(deps) {
     refreshBridgeOwnership,
     refreshBridgeOwnershipSafe,
     reloadRuntimeConfig,
-    armBridgeOwnershipTimer,
-    clearBridgeOwnershipTimer,
     notifyRemoteAcquired,
   };
 }