mixdog 0.9.134 → 0.9.136

package/src/runtime/channels/lib/worker-main.mjs

@@ -12,29 +12,17 @@ import { captureOriginalUserCwd, readLastSessionCwd } from "../../shared/user-cw
 import { ensurePrivateRuntimeRoot, resolveRuntimeRoot } from "../../shared/runtime-root.mjs";
 import { initProviders } from "../../agent/orchestrator/providers/registry.mjs";
 import { Scheduler } from "./scheduler.mjs";
-import { startSnapshotWriter, stopSnapshotWriter, recordFetchedMessages } from "./status-snapshot.mjs";
+import { startSnapshotWriter, stopSnapshotWriter } from "./status-snapshot.mjs";
 import { hasPending as dispatchHasPending } from "../../agent/orchestrator/dispatch-persist.mjs";
 import { setListener as setActivityBusListener } from "../../agent/orchestrator/activity-bus.mjs";
 import { stripSoftWarns } from "../../agent/orchestrator/tool-loop-guard.mjs";
 import { WebhookServer } from "./webhook.mjs";
 import { EventPipeline } from "./event-pipeline.mjs";
 import { startCliWorker } from "./cli-worker-host.mjs";
-import {
-  OutputForwarder,
-  discoverSessionBoundTranscript,
-  findLatestTranscriptByMtime,
-  sameResolvedPath
-} from "./output-forwarder.mjs";
-import { controlClaudeSession } from "./session-control.mjs";
 import { JsonStateFile, ensureDir, removeFileIfExists, writeTextFile } from "./state-file.mjs";
-import {
-  buildModalRequestSpec,
-  PendingInteractionStore
-} from "./interaction-workflows.mjs";
 import {
   ensureRuntimeDirs,
   makeInstanceId,
-  getTurnEndPath,
   getStatusPath,
   getChannelOwnerPath,
   getActiveOwnerPid,
@@ -61,24 +49,13 @@ import {
   BENIGN_CRASH_STREAK_WINDOW_MS,
 } from "./crash-log.mjs";
 import { dropTrace, preview, _dtIdxFlush } from "./index-drop-trace.mjs";
-import { createVoiceTranscription } from "./voice-transcription.mjs";
 import { createParentBridge } from "./parent-bridge.mjs";
-import { createInboundRouting } from "./inbound-routing.mjs";
 import { createToolDispatch } from "./tool-dispatch.mjs";
 import { createOwnerHeartbeat } from "./owner-heartbeat.mjs";
-import { createTranscriptBinding } from "./transcript-binding.mjs";
 import { isNetworkError, retryOnNetwork } from "./network-retry.mjs";
 import { runWorkerIpc } from "./worker-ipc.mjs";
-import { createInteractionHandlers } from "./interaction-handlers.mjs";
-import { createInboundHandler } from "./inbound-handler.mjs";
 import { createOwnedRuntime } from "./owned-runtime.mjs";
 import { runWorkerBootstrap } from "./worker-bootstrap.mjs";
-const memoryClientModulePath = new URL("./memory-client.mjs", import.meta.url).href;
-const {
-  appendEntry: memoryAppendEntry,
-  ingestTranscript: memoryIngestTranscript,
-  drainBuffer: memoryDrainBuffer,
-} = await import(memoryClientModulePath);
 // Zombie-Lead repro (2026-07-02): logCrash-then-survive left a worker alive
 // after an unhandled rejection whose async state was already corrupted
 // (observed: EPERM on active-instance.json rename retry), so it spun
@@ -170,113 +147,12 @@ function writeBridgeState(active) {
 function isChannelBridgeActive() {
   return channelBridgeActive;
 }
-let typingChannelId = null;
-const pendingSetup = new PendingInteractionStore();
-function startServerTyping(channelId) {
-  if (typingChannelId && typingChannelId !== channelId) {
-    provider.stopTyping(typingChannelId);
-  }
-  typingChannelId = channelId;
-  provider.startTyping(channelId);
-}
-function stopServerTyping() {
-  if (typingChannelId) {
-    provider.stopTyping(typingChannelId);
-    typingChannelId = null;
-  }
-}
-const TURN_END_FILE = getTurnEndPath(INSTANCE_ID);
-const TURN_END_BASENAME = path.basename(TURN_END_FILE);
-const TURN_END_DIR = path.dirname(TURN_END_FILE);
-let turnEndWatcher = null;
 // Config hot-reload watcher (installed by start(); torn down by stop()).
 let _configWatcher = null;
 let _reloadDebounce = null;
-if (!_isWorkerMode) {
-  removeFileIfExists(TURN_END_FILE);
-  turnEndWatcher = fs.watch(TURN_END_DIR, async (_event, filename) => {
-    if (filename !== TURN_END_BASENAME) return;
-    try {
-      const stat = fs.statSync(TURN_END_FILE);
-      if (stat.size > 0) {
-        stopServerTyping();
-        await forwarder.forwardFinalText();
-        removeFileIfExists(TURN_END_FILE);
-      }
-    } catch {
-    }
-  });
-}
 const STATUS_FILE = getStatusPath(INSTANCE_ID);
 const statusState = new JsonStateFile(STATUS_FILE, {});
 statusState.ensure();
-const forwarder = new OutputForwarder({
-  send: async (ch, text, opts) => {
-    if (!channelBridgeActive) {
-      throw new Error("send() called while channel bridge is inactive");
-    }
-    await provider.sendMessage(ch, text, opts);
-  },
-  formatOutgoing: (text) => provider.formatOutgoing ? provider.formatOutgoing(text) : text,
-  recordAssistantTurn: async () => {
-  },
-  react: (ch, mid, emoji) => {
-    if (!channelBridgeActive) return Promise.resolve();
-    return provider.react(ch, mid, emoji);
-  },
-  removeReaction: (ch, mid, emoji) => {
-    if (!channelBridgeActive) return Promise.resolve();
-    return provider.removeReaction(ch, mid, emoji);
-  },
-  // Watchdog backstop: force the provider to tear down + rebuild a wedged
-  // client so an over-budget send fails fast and the queue releases.
-  resetProvider: async () => {
-    if (typeof provider?._resetClient === "function") await provider._resetClient();
-  }
-}, statusState);
-forwarder.setOnIdle(() => {
-  stopServerTyping();
-  void forwarder.forwardFinalText();
-});
-// Wire the forwarder ownership probe unconditionally. wireEventQueueHandlers()
-// also sets this, but that path only runs when the event pipeline starts
-// (webhook enabled or event rules present). Without an event pipeline the
-// forwarder's ownerGetter stayed null and _isOwner() failed open, letting a
-// non-owner process forward transcript output (duplicate Discord sends).
-// The closure reads bridgeRuntimeConnected at call time as a fast-path AND;
-// bridgeRuntimeConnected alone can go stale (e.g. this process lost the seat
-// but has not yet observed it), so currentOwnerState().owned is re-read at
-// probe time as the source of truth for ownership.
-forwarder.setOwnerGetter(() => bridgeRuntimeConnected && currentOwnerState().owned);
-// ── Transcript binding cluster ──────────────────────────────────────────────
-// Extracted → lib/transcript-binding.mjs. Bound to live config/identity/owner
-// getters so file-level reference semantics (runtime reloads, ownership flips)
-// are preserved.
-const {
-  sessionIdFromTranscriptPath,
-  getPersistedTranscriptPath,
-  pickUsableTranscriptPath,
-  applyTranscriptBinding,
-  cancelPendingTranscriptRearm,
-  schedulePendingTranscriptRearm,
-  rebindTranscriptContext,
-  bindPersistedTranscriptIfAny,
-} = createTranscriptBinding({
-  forwarder,
-  statusState,
-  readActiveInstance,
-  refreshActiveInstance,
-  instanceId: INSTANCE_ID,
-  memoryIngestTranscript,
-  memoryDrainBuffer,
-  dropTrace,
-  discoverSessionBoundTranscript,
-  sameResolvedPath,
-  getConfig: () => config,
-  getChannelBridgeActive: () => channelBridgeActive,
-  getBridgeRuntimeConnected: () => bridgeRuntimeConnected,
-  RUNTIME_ROOT,
-});
 const scheduler = new Scheduler(
   config.nonInteractive ?? [],
   config.interactive ?? [],
@@ -305,15 +181,6 @@ let bridgeRuntimeConnected = false;
 // in-flight start does not revive owner state after the stop already tore
 // the partial-start state down.
 const ACTIVE_OWNER_STALE_MS = 1e4;
-// Owner gating here is multi-process runtime coordination: only the active
-// bindingReady gates all send paths until the boot-time refreshBridgeOwnership
-// ({ restoreBinding: true }) call completes. Without this, scheduler/webhook
-// emissions fired within the first ~few hundred ms after restart drop because
-// the Discord provider binding has not yet been established.
-let bindingReadyStatus = "pending";
-let _bindingReadyResolve;
-const bindingReady = new Promise((r) => { _bindingReadyResolve = r; });
-dropTrace("bindingReady.create", { status: bindingReadyStatus });
 // ── Bridge ownership snapshot + owner heartbeat ─────────────────────────────
 // Extracted → lib/owner-heartbeat.mjs. Owns its own heartbeat timer + last-note
 // dedup; bound to live identity + active-instance primitives.
@@ -350,19 +217,13 @@ const {
   getChannelBridgeActive: () => channelBridgeActive,
   instanceId: INSTANCE_ID,
   TERMINAL_LEAD_PID,
-  forwarder,
   sendNotifyToParent,
   scheduler,
   statusState,
   logOwnership,
   currentOwnerState,
-  bindPersistedTranscriptIfAny,
-  cancelPendingTranscriptRearm,
-  schedulePendingTranscriptRearm,
-  stopServerTyping,
   wireWebhookHandlers,
   wireEventQueueHandlers,
-  memoryDrainBuffer,
 });
 function injectAndRecord(channelId, name, content, options) {
   // Strip soft-warn marker blocks (Tool-loop / Repeated-input / legacy
@@ -372,7 +233,7 @@ function injectAndRecord(channelId, name, content, options) {
   // intentionally prepended onto tool RESULTS upstream (tool-loop-guard.mjs
   // build*Warn) so the model
   // self-corrects, but agent roles commonly echo them and we don't want them
-  // surfacing in Discord / Lead channel push.
+  // surfacing in the Lead channel push.
   if (typeof content === 'string') content = stripSoftWarns(content);
   const ts = new Date().toISOString();
   const now = new Date();
@@ -382,39 +243,10 @@ function injectAndRecord(channelId, name, content, options) {
   if (options?.instruction) meta.instruction = options.instruction;
   if (options?.type) meta.type = options.type;
   // `silent_to_agent` — lifecycle status pings (worker/iter/started echoes)
-  // surface on Discord but should NOT land in Lead's context window. When
-  // set, skip the parent-notify hop but keep the Discord-forward + event-log
-  // record. The meta flag is also propagated downstream so consumers that
-  // still see the notification (e.g. Lead itself if emission changes later)
-  // can recognise and drop it. Default is false → legacy behaviour preserved.
-  if (options?.silent_to_agent) meta.silent_to_agent = true;
-  const silent = options?.silent_to_agent === true;
-  if (!silent) {
-    sendNotifyToParent("notifications/claude/channel", { content, meta });
-  } else {
-    forwardLifecycleToDiscord(channelId, content);
-  }
-}
-
-// Best-effort direct Discord emission for silent-to-agent lifecycle pings.
-// Only used when the parent-notify hop is skipped, so the user still sees
-// the status on Discord even though Lead will never echo it through the
-// transcript-tail forwarder. Falls back to a no-op when no channel is
-// resolvable — lifecycle pings are non-critical.
-function forwardLifecycleToDiscord(channelId, content) {
-  try {
-    // Skip rather than guess: lifecycle callers pass the channelId they own;
-    // falling back to statusState.channelId can route to a stale/unrelated
-    // channel when the caller did not supply one intentionally.
-    const target = channelId || null;
-    dropTrace("send.lifecycle.entry", { channelId: target || "(none)", bindingReadyStatus, providerPresent: !!provider?.sendMessage, preview: preview(content) });
-    if (!target || !provider?.sendMessage) return;
-    void bindingReady.then(() =>
-      provider.sendMessage(target, content)
-        .then(() => dropTrace("send.lifecycle.ok", { channelId: target }))
-        .catch((err) => dropTrace("send.lifecycle.err", { channelId: target, err: String(err) }))
-    ).catch(() => {});
-  } catch { /* best-effort */ }
+  // must NOT land in Lead's context window. The channel relay that used to
+  // surface them is retired, so silent pings are dropped entirely.
+  if (options?.silent_to_agent === true) return;
+  sendNotifyToParent("notifications/claude/channel", { content, meta });
 }
 scheduler.setInjectHandler((channelId, name, content, options) => {
   injectAndRecord(channelId, name, content, options);
@@ -423,24 +255,15 @@ scheduler.setInjectHandler((channelId, name, content, options) => {
 // actually holds the live bridge seat; otherwise the scheduler falls back to
 // the visible-session run so the fire is never lost.
 scheduler.setInjectReadyCheck(() => bridgeRuntimeConnected && currentOwnerState().owned);
-scheduler.setSendHandler(async (channelId, text) => {
-  dropTrace("send.scheduler.entry", { channelId, preview: preview(text) });
-  await bindingReady;
-  dropTrace("send.scheduler.ready", { channelId });
-  try {
-    await provider.sendMessage(channelId, text);
-    dropTrace("send.scheduler.ok", { channelId });
-  } catch (err) {
-    dropTrace("send.scheduler.err", { channelId, err: String(err) });
-    throw err;
-  }
+scheduler.setSendHandler(async () => {
+  // Channel delivery is retired: schedule results surface in the app session
+  // (parent notify / Automations row) only.
 });
 function wireWebhookHandlers() {
   if (!webhookServer) return;
   webhookServer.setEventPipeline(eventPipeline);
-  // Webhook fires run as sessions (schedules parity). Delivery mode:
-  // 'app' (default) → the Automations session row IS the surface;
-  // 'channel'/'both' → the run result also relays to the main channel.
+  // Webhook fires run as sessions (schedules parity); the Automations
+  // session row is the only surface (channel relay retired).
   webhookServer.setBridgeDispatch(async ({ prompt, model, cwd, workflow, attachments, delivery, context }) => {
     const { runWebhookSession } = await import("../../shared/webhook-session-run.mjs");
     const run = await runWebhookSession({
@@ -452,14 +275,6 @@ function wireWebhookHandlers() {
       delivery: delivery || null,
       prompt,
     });
-    const mode = String(delivery || "app");
-    if ((mode === "channel" || mode === "both") && run?.result && provider?.sendMessage) {
-      const target = scheduler.resolveChannel("");
-      if (target) {
-        void bindingReady.then(() => provider.sendMessage(target, run.result))
-          .catch((err) => dropTrace("send.webhook.err", { channelId: target, err: String(err) }));
-      }
-    }
     return run;
   });
 }
@@ -474,127 +289,37 @@ function wireEventQueueHandlers(eventQueue) {
   // bridgeRuntimeConnected is a fast-path AND; currentOwnerState().owned is
   // re-read at probe time so a stale-connected flag cannot mask a lost seat.
   eventQueue.setOwnerGetter(() => bridgeRuntimeConnected && currentOwnerState().owned);
-  forwarder.setOwnerGetter(() => bridgeRuntimeConnected && currentOwnerState().owned);
 }
-createInteractionHandlers({
-  getProvider: () => provider,
-  getBridgeRuntimeConnected: () => bridgeRuntimeConnected,
-  instanceId: INSTANCE_ID,
-  getBridgeOwnershipSnapshot,
-  refreshBridgeOwnershipSafe,
-  pendingSetup,
-  buildModalRequestSpec,
-  loadProfileConfig,
-  sendNotifyToParent,
-  scheduler,
-  controlClaudeSession,
-  writeTextFile,
-  TURN_END_FILE,
-});
-const { isVoiceAttachment, transcribeVoice } = createVoiceTranscription({
-  getConfig: () => config,
-  dataDir: DATA_DIR,
-});
+// Inbound messaging, provider interaction handlers, and channel voice-message
+// transcription are DELETED with Discord/Telegram (user decision: PWA replaces
+// channels). The headless provider emits no events, so nothing wires here.
 import { TOOL_DEFS } from '../tool-defs.mjs';
 // Tool dispatch in worker mode goes through the IPC `call` handler at the
 // bottom of this file (parent's `callWorker` → `handleToolCall`). There is no
 // orphan worker-level MCP Server: the parent (server.mjs) owns the single
 // connected transport and routes CallTool through the IPC `call` path.
-// ── Inbound routing / dedup / ownership helpers ─────────────────────────────
-// Extracted → lib/inbound-routing.mjs. Bound to live config/identity getters.
-const {
-  writeChannelOwner,
-  shouldDropDuplicateInbound,
-  resolveInboundRoute,
-} = createInboundRouting({
-  getConfig: () => config,
-  getInstanceId: () => INSTANCE_ID,
-  getChannelOwnerPath,
-});
 // ── Worker/HTTP tool-call dispatch ──────────────────────────────────────────
-// handleToolCall switch + bridge auto-connect retry wrapper. Extracted →
-// lib/tool-dispatch.mjs. The switch is entangled with ~8 runtime-lifecycle
-// functions plus mutable owner state (channelBridgeActive/bridgeRuntimeConnected)
-// and the forwarder; those are threaded as a lifecycle bag of lazy getters so
-// the module reads live file-level references at call time (original closure
-// semantics preserved). Used by the HTTP MCP CallTool path and the worker IPC
-// `call` handler at the bottom of this file.
+// Runtime lifecycle dispatch only (activate_channel_bridge / reload_config):
+// threaded as a lifecycle bag of lazy getters so the module reads live
+// file-level references at call time. Used by the HTTP MCP CallTool path and
+// the worker IPC `call` handler at the bottom of this file.
 const {
   handleToolCall,
   handleToolCallWithBridgeRetry,
 } = createToolDispatch({
-  getForwarder: () => forwarder,
   isChannelsDegraded,
   lifecycle: {
-    getBridgeRuntimeConnected: () => bridgeRuntimeConnected,
     getChannelBridgeActive: () => channelBridgeActive,
     getOwned: () => getBridgeOwnershipSnapshot().owned,
     setChannelBridgeActive: (v) => { channelBridgeActive = v; },
     writeBridgeState,
-    stopServerTyping,
     notifyRemoteAcquired,
     refreshBridgeOwnership,
-    bindPersistedTranscriptIfAny,
-    // Lead-pushed repoint: bind the exact transcript the lead just created
-    // (auto-acquire / newSession / resume / clear) instead of waiting for the
-    // next inbound parent-chain steal. Idempotent + best-effort: same binding
-    // path as the inbound steal (rebindTranscriptContext -> applyTranscriptBinding).
-    rebindCurrentTranscript: async (transcriptPath) => {
-      const cleanPath = typeof transcriptPath === "string" ? transcriptPath.trim() : "";
-      if (!cleanPath) return;
-      const channelId = statusState.read().channelId || config.channelId;
-      if (!channelId) return;
-      // Fail-closed: a malformed / not-yet-on-disk path must NEVER fall through
-      // to rebindTranscriptContext's discovery loop (which would mutate the
-      // binding onto a different session). Only an existing regular file binds;
-      // otherwise log + return so the current binding is left untouched.
-      let exists = false;
-      try { exists = fs.statSync(cleanPath).isFile(); } catch { exists = false; }
-      if (!exists) {
-        process.stderr.write(`mixdog: rebind_current_transcript: ignoring non-existent path ${cleanPath}\n`);
-        return;
-      }
-      // Idempotent: already bound to this exact transcript => no-op. In
-      // particular do NOT re-run recoverUnsyncedTail, which is only meaningful
-      // when the binding actually changes.
-      if (forwarder.hasBinding() && sameResolvedPath(forwarder.transcriptPath, cleanPath)) return;
-      // Binding changed: same path as the inbound steal's applyTranscriptBinding.
-      applyTranscriptBinding(channelId, cleanPath, {
-        persistStatus: true,
-        recoverUnsyncedTail: true,
-      });
-    },
     startChannelBridge: () => start({ messaging: true }),
     stopOwnedRuntime,
     reloadRuntimeConfig,
   },
 });
-createInboundHandler({
-  getProvider: () => provider,
-  getConfig: () => config,
-  getBridgeRuntimeConnected: () => bridgeRuntimeConnected,
-  getChannelBridgeActive: () => channelBridgeActive,
-  instanceId: INSTANCE_ID,
-  forwarder,
-  scheduler,
-  statusState,
-  getBridgeOwnershipSnapshot,
-  refreshBridgeOwnershipSafe,
-  writeChannelOwner,
-  shouldDropDuplicateInbound,
-  resolveInboundRoute,
-  isVoiceAttachment,
-  transcribeVoice,
-  getPersistedTranscriptPath,
-  sessionIdFromTranscriptPath,
-  pickUsableTranscriptPath,
-  applyTranscriptBinding,
-  rebindTranscriptContext,
-  sendNotifyToParent,
-  memoryAppendEntry,
-  startServerTyping,
-  stopServerTyping,
-});
 async function init(_sharedMcp) {
   // _sharedMcp is no longer used. Notifications now flow via IPC to the parent
   // (sendNotifyToParent above). The parameter is retained for backward
@@ -626,17 +351,11 @@ async function start(options = {}) {
   // Daemon model: this runtime is the machine-global singleton bridge owner
   // (enforced by the standalone daemon's singleton-owner lock), so there is no
   // seat to claim and no contender to make-before-break against. Just connect
-  // the owned runtime and bind the persisted transcript.
-  const _bindingReadyStart = Date.now();
+  // the owned runtime.
   try {
-    await startOwnedRuntime({ restoreBinding: true });
-    bindingReadyStatus = "resolved";
-    dropTrace("bindingReady.resolve", { elapsedMs: Date.now() - _bindingReadyStart, status: bindingReadyStatus });
-    _bindingReadyResolve(true);
-  } catch (e) {
-    bindingReadyStatus = "rejected";
-    dropTrace("bindingReady.reject", { elapsedMs: Date.now() - _bindingReadyStart, status: bindingReadyStatus, err: String(e) });
-    _bindingReadyResolve(e);
+    await startOwnedRuntime();
+  } catch {
+    // Non-fatal: owned-runtime start errors degrade to automation-only mode.
   }
   // No-op under the daemon model (kept for call-site stability): there is no
   // ownership timer — the singleton daemon guarantees exactly one owner.
@@ -668,10 +387,6 @@ async function stop() {
   clearBridgeOwnershipTimer();
   if (_reloadDebounce) { clearTimeout(_reloadDebounce); _reloadDebounce = null; }
   if (_configWatcher) { try { _configWatcher.close(); } catch {} _configWatcher = null; }
-  if (turnEndWatcher) {
-    try { turnEndWatcher.close(); } catch {}
-    turnEndWatcher = null;
-  }
 }
 // ── IPC worker mode ──────────────────────────────────────────────
 // Skipped under the machine-global host (MIXDOG_DAEMON_HOST=1): the daemon

package/src/runtime/media/renditions.mjs

@@ -14,7 +14,16 @@
  * what made the remote gallery slow.
  */
 import { spawn } from 'child_process';
-import { existsSync, mkdirSync, renameSync, statSync, unlinkSync, writeFileSync } from 'fs';
+import { randomBytes } from 'crypto';
+import {
+  existsSync,
+  mkdirSync,
+  readdirSync,
+  renameSync,
+  statSync,
+  unlinkSync,
+  writeFileSync,
+} from 'fs';
 import { dirname, join } from 'path';
 
 import { resolvePluginData } from '../shared/plugin-paths.mjs';
@@ -35,6 +44,12 @@ const POSTER_TIMEOUT_MS = 20_000;
 const MAX_POSTER_BYTES = 32 * 1024 * 1024;
 const FAILED_RENDITION_COOLDOWN_MS = 30_000;
 const MAX_CACHED_RENDITION_BYTES = 4 * 1024 * 1024;
+const DEFAULT_RENDITION_CACHE_MAX_BYTES = 512 * 1024 * 1024;
+const configuredRenditionCacheMaxBytes = Number(process.env.MIXDOG_RENDITION_CACHE_MAX_BYTES);
+export const RENDITION_CACHE_MAX_BYTES = Number.isFinite(configuredRenditionCacheMaxBytes)
+  && configuredRenditionCacheMaxBytes >= MAX_CACHED_RENDITION_BYTES
+  ? Math.floor(configuredRenditionCacheMaxBytes)
+  : DEFAULT_RENDITION_CACHE_MAX_BYTES;
 
 const MEDIA_VARIANTS = Object.keys(SPECS);
 
@@ -89,14 +104,62 @@ export function removeRenditions(cacheDir, id) {
   }
 }
 
+/** Bound the rebuildable rendition tree by evicting the oldest files first. */
+export function pruneRenditionCache(cacheDir, {
+  maxBytes = RENDITION_CACHE_MAX_BYTES,
+  protectedPath = '',
+} = {}) {
+  const budget = Math.max(0, Math.floor(Number(maxBytes) || 0));
+  const rows = [];
+  let totalBytes = 0;
+  for (const variant of MEDIA_VARIANTS) {
+    const dir = join(cacheDir, variant);
+    let names;
+    try { names = readdirSync(dir); } catch { continue; }
+    for (const name of names) {
+      if (!Object.keys(EXTENSION_MIME).some((extension) => name.endsWith(extension))) continue;
+      const path = join(dir, name);
+      try {
+        const stat = statSync(path);
+        if (!stat.isFile()) continue;
+        rows.push({ path, bytes: stat.size, mtimeMs: stat.mtimeMs });
+        totalBytes += stat.size;
+      } catch { /* raced with another writer/pruner */ }
+    }
+  }
+  rows.sort((a, b) => (a.mtimeMs - b.mtimeMs) || a.path.localeCompare(b.path));
+  for (const row of rows) {
+    if (totalBytes <= budget) break;
+    if (row.path === protectedPath) continue;
+    try {
+      unlinkSync(row.path);
+      totalBytes -= row.bytes;
+    } catch { /* another process already removed it */ }
+  }
+  return { bytes: Math.max(0, totalBytes), entries: rows.length };
+}
+
 function writeRendition(cacheDir, variant, id, extension, buffer) {
+  if (!Buffer.isBuffer(buffer) || buffer.length === 0 || buffer.length > MAX_CACHED_RENDITION_BYTES) {
+    return null;
+  }
   const path = renditionPath(cacheDir, variant, id, extension);
   mkdirSync(dirname(path), { recursive: true });
   // Stage-then-rename: a reader must never observe a half-written cache file.
-  const staging = `${path}.${process.pid}.tmp`;
+  const staging = `${path}.${process.pid}.${randomBytes(6).toString('hex')}.tmp`;
   writeFileSync(staging, buffer);
-  renameSync(staging, path);
-  return { path, mime: EXTENSION_MIME[extension], bytes: buffer.length };
+  try {
+    renameSync(staging, path);
+  } catch (error) {
+    // Another process may have won the same cache publication race.
+    if (!existsSync(path)) throw error;
+  } finally {
+    try { unlinkSync(staging); } catch { /* renamed or already removed */ }
+  }
+  let bytes = buffer.length;
+  try { bytes = statSync(path).size; } catch { /* use written size */ }
+  pruneRenditionCache(cacheDir, { protectedPath: path });
+  return { path, mime: EXTENSION_MIME[extension], bytes };
 }
 
 export function createPriorityScheduler(limit = 2) {
@@ -246,7 +309,7 @@ async function generate({ id, kind, sourcePath, variant, spec, cacheDir }) {
     const frame = await grabVideoFrame(sourcePath, spec);
     if (!frame) return null;
     const written = writeRendition(cacheDir, variant, id, '.jpg', frame.buffer);
-    return { ...written, durationSeconds: frame.durationSeconds };
+    return written ? { ...written, durationSeconds: frame.durationSeconds } : null;
   }
   const encoded = await encodeStill(sourcePath, spec);
   return encoded ? writeRendition(cacheDir, variant, id, encoded.extension, encoded.buffer) : null;

package/src/runtime/media/renditions.test.mjs

@@ -1,8 +1,18 @@
 import assert from 'node:assert/strict';
+import {
+  existsSync,
+  mkdtempSync,
+  rmSync,
+  utimesSync,
+} from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
 import { test } from 'node:test';
 
 import {
+  cacheRendition,
   createPriorityScheduler,
+  pruneRenditionCache,
   videoPosterArguments,
 } from './renditions.mjs';
 
@@ -52,3 +62,38 @@ test('rendition scheduler bounds work and prioritizes visible requests over queu
   await Promise.all([first, second, third]);
   assert.equal(peak, 2);
 });
+
+test('rendition files reject oversized entries and obey a total disk budget', () => {
+  const root = mkdtempSync(join(tmpdir(), 'mixdog-rendition-cache-'));
+  try {
+    const first = cacheRendition({
+      id: 'first',
+      variant: 'thumb',
+      mime: 'image/jpeg',
+      buffer: Buffer.alloc(10, 1),
+      cacheDir: root,
+    });
+    const second = cacheRendition({
+      id: 'second',
+      variant: 'thumb',
+      mime: 'image/jpeg',
+      buffer: Buffer.alloc(10, 2),
+      cacheDir: root,
+    });
+    assert.ok(first && second);
+    utimesSync(first.path, new Date(1_000), new Date(1_000));
+    const pruned = pruneRenditionCache(root, { maxBytes: 10 });
+    assert.equal(pruned.bytes, 10);
+    assert.equal(existsSync(first.path), false);
+    assert.equal(existsSync(second.path), true);
+    assert.equal(cacheRendition({
+      id: 'oversized',
+      variant: 'thumb',
+      mime: 'image/jpeg',
+      buffer: Buffer.alloc(4 * 1024 * 1024 + 1),
+      cacheDir: root,
+    }), null);
+  } finally {
+    rmSync(root, { recursive: true, force: true });
+  }
+});

package/src/runtime/media/store.mjs

@@ -217,6 +217,7 @@ export function saveMediaAsset({ kind, lane, model, prompt, options = {}, mime,
     for (const dropped of assets.slice(MAX_INDEX_ENTRIES)) {
       const droppedPath = storedAssetPath(dropped.file);
       try { if (droppedPath) unlinkSync(droppedPath); } catch {}
+      removeRenditions(renditionsDir(), dropped.id);
     }
     writeIndex(kept);
   });

package/src/runtime/memory/index.mjs

@@ -58,7 +58,7 @@ import { startLlmWorker, stopLlmWorker } from './lib/llm-worker-host.mjs'
 import { runCycle1, runCycle2, runCycle3, runUnifiedGate, parseInterval, syncRootEmbedding, flushRawEmbeddings, applySimpleStatus, applyUpdate, applyMerge, CYCLE2_ACTIVE_TARGET_CAP } from './lib/memory-cycle.mjs'
 import { callAgentDispatch } from './lib/agent-ipc.mjs'
 import { getInFlightCycle1 } from './lib/memory-cycle1.mjs'
-import { claimAndMarkScheduledCycle, markCycleRequest, resolveCoalesceMaxRetries, scheduleCoalescedCycleRetry } from './lib/memory-cycle-requests.mjs'
+import { cancelCoalescedCycleRetries, claimAndMarkScheduledCycle, markCycleRequest, resolveCoalesceMaxRetries, scheduleCoalescedCycleRetry } from './lib/memory-cycle-requests.mjs'
 import { searchRelevantHybrid } from './lib/memory-recall-store.mjs'
 import { fetchEntriesByIdsScoped } from './lib/memory-recall-id-patch.mjs'
 import { retrieveEntries } from './lib/memory-retrievers.mjs'
@@ -420,6 +420,7 @@ const _cycleScheduler = createCycleScheduler({
   markCycleRequest,
   resolveCoalesceMaxRetries,
   scheduleCoalescedCycleRetry,
+  cancelCoalescedCycleRetries,
   scheduledCycle1Signature,
   scheduledCycle2Signature,
   scheduledCycle3Signature,
@@ -643,8 +644,8 @@ export async function init() {
       await runtimeReady
     } catch (e) {
       // Runtime init failed AFTER we advertised the HTTP port. Leaving the
-      // listener up would answer discovery with a live 503, which
-      // memory-client treats as a delivered (non-buffered) write — silently
+      // listener up would answer discovery with a live 503, which HTTP
+      // ingest callers treat as a delivered (non-buffered) write — silently
       // dropping entries that would otherwise be buffered when no port is
       // advertised. stop() withdraws the advert (clears _currentAdvertisedPort
       // + cancels the periodic re-advertise) and closes the HTTP server, so