mixdog 0.9.11 → 0.9.13

package/src/runtime/channels/lib/memory-client.mjs

@@ -31,7 +31,7 @@ async function getMemoryPort() {
   }
 }
 
-async function memoryFetch(method, endpoint, body = null, timeoutMs = 10_000) {
+async function memoryFetch(method, endpoint, body = null, timeoutMs = 10_000, { throwOnError = false } = {}) {
   const port = await getMemoryPort()
   return new Promise((resolve, reject) => {
     if (!port) { reject(new Error('active-instance.json missing memory_port')); return }
@@ -49,8 +49,20 @@ async function memoryFetch(method, endpoint, body = null, timeoutMs = 10_000) {
       let data = ''
       res.on('data', chunk => { data += chunk })
       res.on('end', () => {
-        try { resolve(JSON.parse(data)) }
-        catch { resolve({ raw: data }) }
+        const status = res.statusCode || 0
+        let parsed
+        try { parsed = JSON.parse(data) }
+        catch { parsed = { raw: data } }
+        // Live callers keep lenient semantics (resolve on any response).
+        // Drain replay passes throwOnError so a non-2xx status or an
+        // {error} body is treated as a FAILED replay — the buffer file is
+        // then kept for retry instead of being unlinked (data-loss guard).
+        if (throwOnError && (status < 200 || status >= 300 || (parsed && parsed.error != null))) {
+          const detail = parsed && parsed.error != null ? String(parsed.error) : `HTTP ${status}`
+          reject(new Error(`memory replay rejected: ${detail}`))
+          return
+        }
+        resolve(parsed)
       })
     })
     req.on('error', reject)
@@ -61,6 +73,10 @@ async function memoryFetch(method, endpoint, body = null, timeoutMs = 10_000) {
 }
 
 const BUFFER_DIR = path.join(RUNTIME_ROOT, 'memory-buffer')
+const DEAD_DIR = path.join(BUFFER_DIR, 'dead')
+const MAX_DRAIN_ATTEMPTS = 5
+const MAX_BUFFER_FILES = 500
+let _draining = false
 
 function normalizeTs(ts) {
   if (typeof ts === 'number' && Number.isFinite(ts)) {
@@ -87,16 +103,8 @@ export async function appendEntry(data) {
     return await memoryFetch('POST', '/entry', payload, 3_000)
   } catch (e) {
     process.stderr.write(`[memory-client] appendEntry failed (${e.message}) — buffering\n`)
-    try {
-      fs.mkdirSync(BUFFER_DIR, { recursive: true })
-      const random = Math.random().toString(36).slice(2, 10)
-      const bufferPath = path.join(BUFFER_DIR, `entry-${Date.now()}-${random}.json`)
-      fs.writeFileSync(bufferPath, JSON.stringify(payload, null, 2))
-      return { ok: false, buffered: true, path: bufferPath }
-    } catch (bufErr) {
-      process.stderr.write(`[memory-client] Failed to buffer entry: ${bufErr.message}\n`)
-      return { ok: false }
-    }
+    const bufferPath = bufferToDisk('entry', payload)
+    return bufferPath ? { ok: false, buffered: true, path: bufferPath } : { ok: false }
   }
 }
 
@@ -104,8 +112,185 @@ export async function ingestTranscript(filePath, { cwd } = {}) {
   try {
     return await memoryFetch('POST', '/ingest-transcript', { filePath, ...(cwd ? { cwd } : {}) })
   } catch (e) {
-    process.stderr.write(`[memory-client] ingestTranscript failed: ${e.message}\n`)
-    return { ok: false }
+    process.stderr.write(`[memory-client] ingestTranscript failed (${e.message}) — buffering\n`)
+    // Dedupe by transcriptPath: replace any already-buffered ingest for the
+    // same file so a re-ingest storm cannot fan out to N buffer files.
+    const bufferPath = bufferToDisk('ingest', { filePath, ...(cwd ? { cwd } : {}) }, { dedupeKey: filePath })
+    return bufferPath ? { ok: false, buffered: true, path: bufferPath } : { ok: false }
+  }
+}
+
+// Persist a failed request so the drainer can replay it once the memory
+// service publishes its port. `kind` selects the replay endpoint on drain.
+// dedupeKey (ingest): if an existing kind-* file already carries the same
+// key, overwrite it in place instead of writing a new file — one buffered
+// ingest per transcriptPath. Enforces MAX_BUFFER_FILES (drop-oldest+warn).
+// Atomic write: stage to a unique tmp file in the SAME dir, then rename over
+// the target. rename() is atomic on a single filesystem, so a concurrent
+// reader/drainer never observes a half-written buffer file.
+function atomicWrite(targetPath, contents) {
+  const tmp = `${targetPath}.tmp-${process.pid}-${Math.random().toString(36).slice(2, 8)}`
+  fs.writeFileSync(tmp, contents)
+  try { fs.renameSync(tmp, targetPath) }
+  catch (e) { try { fs.unlinkSync(tmp) } catch {}; throw e }
+}
+
+function bufferToDisk(kind, payload, { dedupeKey = null } = {}) {
+  try {
+    fs.mkdirSync(BUFFER_DIR, { recursive: true })
+    if (dedupeKey != null) {
+      let existing = []
+      try { existing = fs.readdirSync(BUFFER_DIR) } catch {}
+      for (const name of existing) {
+        if (!name.startsWith(`${kind}-`) || !name.endsWith('.json')) continue
+        const full = path.join(BUFFER_DIR, name)
+        try {
+          const prev = JSON.parse(fs.readFileSync(full, 'utf8'))
+          if (prev && prev.filePath === dedupeKey) {
+            // Atomic overwrite (tmp+rename); preserves the original (oldest)
+            // ordering slot without exposing a half-written file to a drainer.
+            atomicWrite(full, JSON.stringify(payload, null, 2))
+            return full
+          }
+        } catch {}
+      }
+    }
+    enforceBufferCap()
+    const random = Math.random().toString(36).slice(2, 10)
+    // Prefix carries the replay kind; timestamp prefix keeps oldest-first
+    // ordering under a lexicographic sort.
+    const bufferPath = path.join(BUFFER_DIR, `${kind}-${Date.now()}-${random}.json`)
+    atomicWrite(bufferPath, JSON.stringify(payload, null, 2))
+    return bufferPath
+  } catch (bufErr) {
+    process.stderr.write(`[memory-client] Failed to buffer ${kind}: ${bufErr.message}\n`)
+    return null
+  }
+}
+
+// Move a buffer file to memory-buffer/dead/ (quarantine, never silent-drop).
+// Returns true on success. On failure NEVER unlinks (no silent payload loss):
+// leaves the file in place and returns false so the caller skips it this pass.
+function moveToDead(name, reason) {
+  process.stderr.write(`[memory-client] quarantining ${name} to dead/ (${reason})\n`)
+  try {
+    fs.mkdirSync(DEAD_DIR, { recursive: true })
+    fs.renameSync(path.join(BUFFER_DIR, name), path.join(DEAD_DIR, name))
+    return true
+  } catch (e) {
+    process.stderr.write(`[memory-client] quarantine of ${name} failed (${e.message}) — leaving in place\n`)
+    return false
+  }
+}
+
+// Cap the buffer directory: when at/over MAX_BUFFER_FILES, quarantine oldest
+// files (lexicographic = ts-prefixed = oldest-first) to dead/ — never silently
+// destroy data (MED: cap must preserve for triage, same as poison path).
+function enforceBufferCap() {
+  let files
+  try {
+    files = fs.readdirSync(BUFFER_DIR)
+      .filter(f => (f.startsWith('entry-') || f.startsWith('ingest-')) && f.endsWith('.json'))
+      .sort()
+  } catch { return }
+  let over = files.length - (MAX_BUFFER_FILES - 1)
+  for (let i = 0; i < files.length && over > 0; i++, over--) {
+    moveToDead(files[i], `buffer cap ${MAX_BUFFER_FILES} exceeded — oldest`)
+  }
+}
+
+// Replay buffered entry-*/ingest-* files once the memory port is live.
+// Oldest-first (filename carries a ms timestamp), dedupe-safe (each file is
+// deleted only after a 2xx replay — memoryFetch(throwOnError) rejects on
+// non-2xx/{error}, so a rejected replay keeps the file for retry, no data
+// loss). Retry count is PERSISTED in the filename suffix (`.rN`) so process
+// restarts don't reset the poison cap; after MAX_DRAIN_ATTEMPTS the file is
+// MOVED to memory-buffer/dead/ (not deleted, not left blocking the queue).
+// Reentrancy-guarded.
+//
+// Attempt count lives in the name: `<kind>-<ts>-<rnd>.json` (attempt 0) or
+// `<kind>-<ts>-<rnd>.rN.json` (N prior failures). Parsed/rewritten via rename.
+function parseRetry(name) {
+  const m = name.match(/\.r(\d+)\.json$/)
+  return m ? Number(m[1]) : 0
+}
+function retryName(name, n) {
+  const base = name.replace(/\.r\d+\.json$/, '.json').replace(/\.json$/, '')
+  return `${base}.r${n}.json`
+}
+export async function drainBuffer() {
+  if (_draining) return { ok: true, skipped: 'in-progress' }
+  const port = await getMemoryPort()
+  if (!port) return { ok: false, reason: 'no-port' }
+  _draining = true
+  let drained = 0
+  let failed = 0
+  // Files that could not be advanced this pass (rename lock/EPERM). Skipped so
+  // an un-rewritable file can't wedge the oldest-first queue forever; retried
+  // on the next drain (their on-disk .rN is unchanged, so the cap still holds).
+  const skipThisPass = new Set()
+  try {
+    let files
+    try {
+      files = fs.readdirSync(BUFFER_DIR)
+    } catch { return { ok: true, drained: 0 } }
+    files = files
+      .filter(f => (f.startsWith('entry-') || f.startsWith('ingest-')) && f.endsWith('.json'))
+      .sort() // ts-prefixed name => oldest-first
+    for (const name of files) {
+      if (skipThisPass.has(name)) continue
+      const bufferPath = path.join(BUFFER_DIR, name)
+      let payload
+      try {
+        payload = JSON.parse(fs.readFileSync(bufferPath, 'utf8'))
+      } catch {
+        // Unparseable/corrupt buffer file — a partial write may be in flight,
+        // or it may be genuinely corrupt. Do NOT unlink (silent data loss):
+        // quarantine to dead/ for triage and move on. If the quarantine move
+        // itself fails, skip it for this pass so it can't block oldest-first.
+        if (!moveToDead(name, 'unparseable buffer file')) skipThisPass.add(name)
+        continue
+      }
+      const endpoint = name.startsWith('ingest-') ? '/ingest-transcript' : '/entry'
+      try {
+        // throwOnError: non-2xx status or an {error} body REJECTS, so the
+        // file is kept/aged for retry instead of unlinked (HIGH: data loss).
+        await memoryFetch('POST', endpoint, payload, 10_000, { throwOnError: true })
+        try { fs.unlinkSync(bufferPath) } catch {}
+        drained++
+      } catch (e) {
+        const attempts = parseRetry(name) + 1
+        failed++
+        if (attempts >= MAX_DRAIN_ATTEMPTS) {
+          // Quarantine, don't drop: move to dead/ so a poison record neither
+          // wedges the queue nor silently vanishes (recoverable for triage).
+          moveToDead(name, `${attempts} failed replays: ${e.message}`)
+        } else {
+          // Persist the incremented attempt count in the filename so a
+          // restart resumes the poison cap instead of resetting it. If the
+          // rename fails (EPERM/lock), leave the file as-is but skip it for
+          // THIS pass so it can't block the oldest-first queue forever — the
+          // next drain re-reads its (unchanged) .rN and retries.
+          try {
+            fs.renameSync(bufferPath, path.join(BUFFER_DIR, retryName(name, attempts)))
+          } catch {
+            // Rename lock/EPERM: don't break the whole pass on a file we
+            // couldn't even age — skip it and CONTINUE so later buffered
+            // files still drain. (Strict oldest-first yields to progress
+            // ONLY in this rename-failure case; a normal replay failure
+            // below still breaks, since the service is likely down.)
+            skipThisPass.add(name)
+            continue
+          }
+        }
+        // Stop the pass on first failure: the service is likely still down,
+        // so hammering the rest wastes timeouts. Next drain retries in order.
+        break
+      }
+    }
+  } finally {
+    _draining = false
   }
+  return { ok: failed === 0, drained, failed }
 }
 

package/src/runtime/memory/index.mjs

@@ -152,6 +152,17 @@ function touchDaemonIdleTimer(reason = 'activity') {
 function advertiseMemoryPort(boundPort, attempt = 0) {
   if (!Number.isFinite(boundPort) || boundPort <= 0) return
   _currentAdvertisedPort = boundPort
+  if (!_periodicAdvertiseInstalled) {
+    _periodicAdvertiseInstalled = true
+    _periodicAdvertiseTimer = setInterval(() => {
+      try {
+        if (_currentAdvertisedPort != null) {
+          advertiseMemoryPort(_currentAdvertisedPort)
+        }
+      } catch {}
+    }, 30_000)
+    _periodicAdvertiseTimer.unref?.()
+  }
   const dir = RUNTIME_ROOT
   const file = path.join(dir, 'active-instance.json')
   try {
@@ -177,17 +188,6 @@ function advertiseMemoryPort(boundPort, attempt = 0) {
       }
       return next
     }, { compact: true, fsyncDir: true, renameFallback: 'truncate' })
-    if (!_periodicAdvertiseInstalled) {
-      _periodicAdvertiseInstalled = true
-      _periodicAdvertiseTimer = setInterval(() => {
-        try {
-          if (_currentAdvertisedPort != null) {
-            advertiseMemoryPort(_currentAdvertisedPort)
-          }
-        } catch {}
-      }, 30_000)
-      _periodicAdvertiseTimer.unref?.()
-    }
   } catch (e) {
     const transient = e?.code === 'EPERM' || e?.code === 'EBUSY' || e?.code === 'EACCES'
     if (transient && attempt < 3) {

package/src/runtime/memory/lib/cycle-scheduler.mjs

@@ -324,15 +324,17 @@ export function createCycleScheduler(deps) {
       log('[cycle2] skipped: in flight\n')
       return
     }
-    if (result.ok) {
+    const gateFailed = result?.gate_failed === true
+    if (result.ok && !gateFailed) {
       await setCycleLastRun('cycle2', Date.now())
       await setCycleLastRun('cycle2_last_error', '')
       log('[cycle2] completed\n')
       markCycleDone('cycle2', true)
     } else {
-      await setCycleLastRun('cycle2_last_error', result.error || 'unknown error')
-      log(`[cycle2] failed: ${result.error}\n`)
-      markCycleDone('cycle2', false, result.error || 'unknown error')
+      const err = gateFailed ? 'gate_failed' : (result.error || 'unknown error')
+      await setCycleLastRun('cycle2_last_error', err)
+      log(`[cycle2] failed: ${err}\n`)
+      markCycleDone('cycle2', false, err)
     }
   }
 

package/src/runtime/memory/lib/memory-cycle2-gate.mjs

@@ -48,8 +48,8 @@ function formatEntriesForPromotePrompt(rows, pidMap, opts = {}) {
   const map = pidMap ?? buildPidMap([rows])
   // When numbered, prefix each row with its 1-based prompt-order ordinal so the
   // gate LLM can echo a row number it can see, instead of inventing one. The
-  // ordinal domain (1..N) and the 5-digit batch-id domain must stay disjoint —
-  // see the ordinalToId invariant in runUnifiedGate.
+  // ordinal domain (1..N) vs batch ids that share those integers on a *different*
+  // row — see batchOrdinalIdCollides in runUnifiedGate.
   const numbered = opts.numbered === true
   const lines = rows.map((r, i) => {
     const tag = r.project_id ? (map.get(r.project_id) ?? 'C') : 'C'
@@ -78,6 +78,17 @@ function formatUserCoreForPrompt(rows, pidMap) {
 // Parse pipe-format unified verdicts. Each line: <id>|<verb> [|...].
 // Verbs validated against the row's current status via STATUS_ALLOWED_VERBS.
 // Returns { actions, rejected } or null when no parseable lines.
+// True when some entry id K in 1..N is also the row-ordinal label for a different
+// entry (token K is ambiguous between id K and "row K").
+export function batchOrdinalIdCollides(statusById, ordinalToId, rowCount) {
+  const n = Math.max(0, Number(rowCount) || 0)
+  for (let k = 1; k <= n; k++) {
+    if (!statusById.has(k)) continue
+    if (ordinalToId.get(k) !== k) return k
+  }
+  return null
+}
+
 function parseUnifiedFormat(raw, statusById, ordinalToId = null) {
   if (raw == null) return null
   const text = String(raw).trim()
@@ -88,10 +99,9 @@ function parseUnifiedFormat(raw, statusById, ordinalToId = null) {
   const support = new Map()
   let sawValid = false
   // Resolve a first-field/merge token to a real batch id. The gate may echo
-  // either the exact 5-digit batch id OR the 1-based row ordinal shown in the
-  // numbered Entries block. The two domains are disjoint (asserted in
-  // runUnifiedGate), so an exact-id hit always wins and an unmatched value
-  // falls back to ordinal lookup; anything else is NaN (line treated invalid).
+  // either the exact batch id OR the 1-based row ordinal shown in the numbered
+  // Entries block. When batchOrdinalIdCollides is false, an exact-id hit wins
+  // and an unmatched value falls back to ordinal lookup; anything else is NaN.
   const resolveId = (tok) => {
     const n = Number(String(tok ?? '').trim())
     if (!Number.isFinite(n)) return NaN
@@ -333,18 +343,13 @@ export async function runUnifiedGate(db, rows, activeContext, config = {}, optio
 
   const statusById = new Map(rows.map(r => [Number(r.id), String(r.status)]))
   // Ordinal → batch-id map, keyed by 1-based prompt order (the same order the
-  // numbered Entries block uses). The gate may echo either the real 5-digit
-  // batch id or the row ordinal 1..N; the parser resolves both. The two domains
-  // MUST be disjoint or an ordinal could shadow a real id (ids are 5-digit,
-  // ordinals are <= rows.length, so disjointness always holds in practice).
-  // On a violation a row-number line is indistinguishable from an exact-id
-  // line, so no safe interpretation exists — skip this batch (gate failure)
-  // rather than risk applying a verdict to the wrong entry. The cycle itself
-  // proceeds; the batch re-queues for a later run.
+  // numbered Entries block uses). The gate may echo either the real batch id
+  // or the row ordinal 1..N; the parser resolves both when no integer token is
+  // ambiguous (id K present in batch but row K points at a different entry).
   const ordinalToId = new Map(rows.map((r, i) => [i + 1, Number(r.id)]))
-  const minBatchId = Math.min(...[...statusById.keys()])
-  if (Number.isFinite(minBatchId) && minBatchId <= rows.length) {
-    __mixdogMemoryLog(`[cycle2] batch id ${minBatchId} collides with ordinal range 1..${rows.length} — skipping batch (no safe id resolution)\n`)
+  const collideToken = batchOrdinalIdCollides(statusById, ordinalToId, rows.length)
+  if (collideToken != null) {
+    __mixdogMemoryLog(`[cycle2] batch id ${collideToken} collides with row ordinal ${collideToken} (id ${ordinalToId.get(collideToken)}) — skipping batch (no safe id resolution)\n`)
     return { actions: null, rejected: new Set(), parseOk: false }
   }
 

package/src/runtime/memory/lib/memory-embed.mjs

@@ -430,7 +430,41 @@ async function syncBatchEmbeddings(db, ids, options = {}) {
   throwIfAborted(signal)
   const writtenIds = (res.rows || []).map(r => Number(r.id))
   if (writtenIds.length < updates.length) {
-    __mixdogMemoryLog(`[embed-sync] ${updates.length - writtenIds.length} stale-write(s) skipped — text changed since read\n`)
+    const writtenSet = new Set(writtenIds)
+    const missed = updates.filter((u) => !writtenSet.has(u.id))
+    const missedIds = missed.map((u) => u.id)
+    const curRows = missedIds.length
+      ? (await db.query(
+          `SELECT id, embedding IS NOT NULL AS has_embedding, element, summary
+           FROM memory.entries WHERE id = ANY($1::bigint[]) AND is_root = 1`,
+          [missedIds],
+        )).rows
+      : []
+    const curById = new Map(curRows.map((r) => [Number(r.id), r]))
+    let staleSkips = 0
+    let concurrentSkips = 0
+    for (const u of missed) {
+      const cur = curById.get(u.id)
+      if (!cur) continue
+      const textUnchanged =
+        (cur.element === u.element || (cur.element == null && u.element == null)) &&
+        (cur.summary === u.summary || (cur.summary == null && u.summary == null))
+      if (!textUnchanged) {
+        staleSkips++
+        continue
+      }
+      if (cur.has_embedding) {
+        concurrentSkips++
+        continue
+      }
+      staleSkips++
+    }
+    if (staleSkips > 0) {
+      __mixdogMemoryLog(`[embed-sync] ${staleSkips} stale-write(s) skipped — text changed since read\n`)
+    }
+    if (concurrentSkips > 0 && process.env.MIXDOG_DEBUG_EMBED) {
+      __mixdogMemoryLog(`[embed-sync] ${concurrentSkips} concurrent embed write(s) skipped — already embedded\n`)
+    }
   }
   return writtenIds
 }

package/src/session-runtime/tool-catalog.mjs

@@ -66,6 +66,7 @@ export const DEFERRED_DEFAULT_LEAD_TOOLS = Object.freeze([
   'search',
   'web_fetch',
   'cwd',
+    'session_manage',
   'Skill',
   'tool_search',
 ]);

package/src/session-runtime/tool-defs.mjs

@@ -69,6 +69,34 @@ export const SKILL_TOOL = {
   },
 };
 
+// Owner-directed session reset tool. `clear` mirrors /clear (full wipe);
+// `compact_clear` mirrors the auto-clear path (summarize via the configured
+// compactType, then reset — context carries forward in the summary). The
+// reset is SCHEDULED: it runs when the current turn ends, never mid-turn,
+// because the live transcript is still feeding the loop. Lead-session only;
+// the runtime executor rejects agent-worker callers.
+export const SESSION_MANAGE_TOOL = {
+  name: 'session_manage',
+  title: 'Session Manage',
+  annotations: {
+    title: 'Session Manage',
+    readOnlyHint: false,
+    destructiveHint: true,
+    idempotentHint: false,
+    openWorldHint: false,
+    agentHidden: true,
+  },
+  description: 'Reset this conversation on explicit user request. action=clear wipes all context (like /clear); action=compact_clear summarizes first and carries context forward (auto-clear style). Applies when the current turn ends.',
+  inputSchema: {
+    type: 'object',
+    properties: {
+      action: { type: 'string', enum: ['clear', 'compact_clear'], description: 'clear = full wipe; compact_clear = summarize then reset.' },
+    },
+    required: ['action'],
+    additionalProperties: false,
+  },
+};
+
 export const LEAD_DISALLOWED_TOOLS = Object.freeze([]);
 export const AGENT_HIDDEN_WRAPPER_TOOLS = new Set([]);
 

package/src/standalone/agent-tool.mjs

@@ -16,9 +16,13 @@ import { updateJsonAtomicSync } from '../runtime/shared/atomic-file.mjs';
 import { normalizeAgentPermission } from '../runtime/shared/markdown-frontmatter.mjs';
 import { prepareAgentSession } from '../runtime/agent/orchestrator/agent-runtime/session-builder.mjs';
 import {
+  abortAgentProgressWatchdog,
   agentWatchdogPolicyActive,
   evaluateAgentWatchdogAbort,
   resolveAgentWatchdogPolicy,
+  resolveHandoffMessageStartIndex,
+  watchdogPartialHandoffFromError,
+  AgentStallAbortError,
 } from '../runtime/agent/orchestrator/agent-runtime/agent-progress-watchdog.mjs';
 import { buildAgentTaskProgressFields } from './agent-task-status.mjs';
 import { AGENT_OWNER } from '../runtime/agent/orchestrator/agent-owner.mjs';
@@ -962,13 +966,15 @@ export function createStandaloneAgent({ cfgMod, reg, mgr, dataDir, cwd: defaultC
     }, notifyContext);
   }
 
-  function startProgressIdleWatchdog(sessionId, watchdogPolicy) {
+  function startProgressIdleWatchdog(sessionId, watchdogPolicy, agent = null) {
     if (!sessionId || !agentWatchdogPolicyActive(watchdogPolicy)) return null;
     if (typeof mgr.getSessionProgressSnapshot !== 'function' && typeof mgr.getSessionLastProgressAt !== 'function') return null;
     if (typeof mgr.linkParentSignalToSession !== 'function') return null;
     const controller = new AbortController();
+    const anchorTs = Date.now();
     try { mgr.linkParentSignalToSession(sessionId, controller.signal); } catch { return null; }
     const timer = setInterval(() => {
+      if (controller.signal?.aborted) return;
       const now = Date.now();
       const snapshot = typeof mgr.getSessionProgressSnapshot === 'function'
         ? mgr.getSessionProgressSnapshot(sessionId)
@@ -976,15 +982,36 @@ export function createStandaloneAgent({ cfgMod, reg, mgr, dataDir, cwd: defaultC
       const abortErr = snapshot
         ? evaluateAgentWatchdogAbort(snapshot, now, watchdogPolicy)
         : null;
+      const sess = typeof mgr.getSession === 'function' ? mgr.getSession(sessionId) : null;
+      const iteration = typeof sess?.lastIterationIndex === 'number' ? sess.lastIterationIndex : null;
       if (!abortErr && !snapshot) {
-        const last = mgr.getSessionLastProgressAt(sessionId);
-        if (watchdogPolicy.idleStaleMs > 0 && last && now - last > watchdogPolicy.idleStaleMs) {
-          try { controller.abort(new Error(`agent task stale (${watchdogPolicy.idleStaleMs}ms without progress)`)); } catch {}
+        const reported = mgr.getSessionLastProgressAt(sessionId);
+        const last = reported || anchorTs;
+        if (watchdogPolicy.idleStaleMs > 0 && now - last > watchdogPolicy.idleStaleMs) {
+          abortAgentProgressWatchdog(controller, {
+            sessionId,
+            agent,
+            error: new AgentStallAbortError(`agent task stale (${watchdogPolicy.idleStaleMs}ms without progress)`),
+            policy: watchdogPolicy,
+            now,
+            anchorTs,
+            lastProgressAt: reported,
+            iteration,
+          });
         }
         return;
       }
       if (abortErr) {
-        try { controller.abort(abortErr); } catch {}
+        abortAgentProgressWatchdog(controller, {
+          sessionId,
+          agent,
+          error: abortErr,
+          snapshot,
+          policy: watchdogPolicy,
+          now,
+          anchorTs,
+          iteration,
+        });
       }
     }, 1000);
     timer.unref?.();
@@ -1072,7 +1099,7 @@ export function createStandaloneAgent({ cfgMod, reg, mgr, dataDir, cwd: defaultC
 
   async function runSpawn(prepared, notifyContext = null, job = null) {
     const { args, tag, session, agent, preset, presetName, workerCwd, prompt, watchdogPolicy } = prepared;
-    const watchdog = startProgressIdleWatchdog(session.id, watchdogPolicy);
+    const watchdog = startProgressIdleWatchdog(session.id, watchdogPolicy, agent);
     let finalStatus = 'idle';
     // SubagentStart: a worker session is about to run its first turn.
     emitSubagentEvent('start', agent, { session_id: session.id, tag });
@@ -1086,6 +1113,7 @@ export function createStandaloneAgent({ cfgMod, reg, mgr, dataDir, cwd: defaultC
       status: 'running',
       stage: 'running',
     });
+    let handoffMsgStart = 0;
     try {
       const completionValue = (result) => {
         // Promote an abnormal finish (iteration cap, truncation, or a public
@@ -1107,6 +1135,7 @@ export function createStandaloneAgent({ cfgMod, reg, mgr, dataDir, cwd: defaultC
           ...(abnormalError ? { error: abnormalError } : {}),
         };
       };
+      handoffMsgStart = resolveHandoffMessageStartIndex(mgr.getSession(session.id));
       const result = await mgr.askSession(session.id, prompt, args.context || null, null, workerCwd, null, {
         notifyFn: workerNotifyFn(session.id, notifyContext || {}),
         ...(job ? {
@@ -1155,6 +1184,33 @@ export function createStandaloneAgent({ cfgMod, reg, mgr, dataDir, cwd: defaultC
       }
       return finalValue;
     } catch (error) {
+      const partial = watchdogPartialHandoffFromError(error, mgr.getSession(session.id), handoffMsgStart);
+      if (partial) {
+        finalStatus = 'idle';
+        const value = {
+          tag,
+          sessionId: session.id,
+          agent,
+          preset: presetKey(preset) || presetName,
+          provider: preset.provider,
+          model: preset.model,
+          effort: preset.effort || null,
+          fast: preset.fast === true,
+          content: partial,
+          stallAbort: true,
+        };
+        if (job) job._terminalResultValue = value;
+        if (job?.taskId) {
+          try {
+            reconcileBackgroundTask(job.taskId, {
+              status: 'completed',
+              result: value,
+              terminalReason: 'agent-watchdog-partial',
+            });
+          } catch {}
+        }
+        return value;
+      }
       finalStatus = 'error';
       // Part C: a mid-stream stall (StreamStalledError / ESTREAMSTALL) throws
       // here WITHOUT a terminal result, so the finally reconcile below (gated on
@@ -1229,10 +1285,11 @@ export function createStandaloneAgent({ cfgMod, reg, mgr, dataDir, cwd: defaultC
   async function runSend(prepared, notifyContext = null, job = null) {
     const { args, session, sessionId, prompt } = prepared;
     const sendAgent = session.agent || normalizeAgentName(args.agent);
-    const watchdog = startProgressIdleWatchdog(sessionId, resolveAgentWatchdogPolicy(sendAgent));
+    const watchdog = startProgressIdleWatchdog(sessionId, resolveAgentWatchdogPolicy(sendAgent), sendAgent);
     const tag = tagForSession(sessionId);
     let finalStatus = 'idle';
     upsertWorkerSessionDeferred(session, tag, { status: 'running', stage: 'running' });
+    let handoffMsgStart = 0;
     try {
       const completionValue = (result) => {
         // Same abnormal-empty → error promotion as runSpawn: a reused/`send`
@@ -1249,6 +1306,7 @@ export function createStandaloneAgent({ cfgMod, reg, mgr, dataDir, cwd: defaultC
           ...(abnormalError ? { error: abnormalError } : {}),
         };
       };
+      handoffMsgStart = resolveHandoffMessageStartIndex(mgr.getSession(sessionId));
       const result = await mgr.askSession(sessionId, prompt, args.context || null, null, session.cwd || defaultCwd, null, {
         notifyFn: workerNotifyFn(sessionId, notifyContext || {}),
         ...(job ? {
@@ -1287,6 +1345,30 @@ export function createStandaloneAgent({ cfgMod, reg, mgr, dataDir, cwd: defaultC
       }
       return finalValue;
     } catch (error) {
+      const partial = watchdogPartialHandoffFromError(error, mgr.getSession(sessionId), handoffMsgStart);
+      if (partial) {
+        finalStatus = 'idle';
+        const value = {
+          tag,
+          sessionId,
+          agent: session.agent || null,
+          provider: session.provider,
+          model: session.model,
+          content: partial,
+          stallAbort: true,
+        };
+        if (job) job._terminalResultValue = value;
+        if (job?.taskId) {
+          try {
+            reconcileBackgroundTask(job.taskId, {
+              status: 'completed',
+              result: value,
+              terminalReason: 'agent-watchdog-partial',
+            });
+          } catch {}
+        }
+        return value;
+      }
       finalStatus = 'error';
       // Part C (send path mirror): a mid-stream stall throws with no terminal
       // result — reconcile to `failed` so the owner is notified rather than the