mixdog 0.9.38 → 0.9.40

package/src/runtime/agent/orchestrator/session/manager/delivered-completions.mjs

@@ -0,0 +1,123 @@
+// Process-local delivered-completion registry.
+//
+// Purpose: a task-completion body that was already injected into the active TUI
+// loop and ACKed (modelVisibleDelivered) must never ALSO be enqueued into — or
+// drained from — the session pending queue one turn later. The TUI ack and the
+// racing background/fallback enqueue run on different code paths within the SAME
+// process, so this in-memory registry lets an enqueue/drain site recognize "this
+// completion was already delivered" and skip it.
+//
+// Recorded keys (either one matching = already delivered):
+//   - meta.execution_id (when present)
+//   - a hash of the model-visible completion text
+//
+// Bounded + TTL'd so a long-lived process never accumulates unbounded entries.
+// Both record and a matching lookup REFRESH the entry (sliding TTL), so an
+// ACKed completion survives across long-idle turns as long as it keeps being
+// checked. Headless/API sessions never ack, so the registry stays empty for
+// them and marked in-memory completions drain exactly once (behavior unchanged).
+//
+// Residual risk: with a 6h sliding TTL the only remaining eviction path is the
+// bounded-size cap — if MORE than DELIVERED_MAX_ENTRIES distinct completions are
+// delivered before an older ACKed key is next checked, that oldest key is
+// evicted and its (now un-refreshed) completion could enqueue/drain a second
+// time. This requires >512 live completions between a delivery and its drain,
+// which is far outside normal single-process interactive use.
+import { createHash } from 'node:crypto';
+
+const DELIVERED_TTL_MS = 6 * 60 * 60 * 1000; // 6h, sliding (refreshed on record + hit)
+const DELIVERED_MAX_ENTRIES = 512;
+// key -> expiresAt (ms). Insertion order = age order (Map guarantee), so the
+// oldest key is always the first — used for bounded-size eviction.
+const _delivered = new Map();
+
+export function hashCompletionText(text) {
+    const value = String(text ?? '').trim();
+    if (!value) return null;
+    return createHash('sha1').update(value).digest('hex');
+}
+
+function execKey(executionId) {
+    const id = executionId == null ? '' : String(executionId).trim();
+    return id ? `id:${id}` : null;
+}
+
+function textKey(text) {
+    const h = hashCompletionText(text);
+    return h ? `tx:${h}` : null;
+}
+
+function pruneExpired(now) {
+    for (const [key, expiresAt] of _delivered) {
+        if (expiresAt <= now) _delivered.delete(key);
+    }
+}
+
+function enforceBound() {
+    while (_delivered.size > DELIVERED_MAX_ENTRIES) {
+        const oldest = _delivered.keys().next().value;
+        if (oldest === undefined) break;
+        _delivered.delete(oldest);
+    }
+}
+
+// Record a delivered completion under its execution_id (when present) and its
+// model-visible text hash. Both keys point at the same expiry so a later
+// enqueue/drain matching EITHER is recognized as already delivered. Re-recording
+// an existing key refreshes its expiry (sliding TTL).
+export function recordDeliveredCompletion({ executionId, text } = {}) {
+    const now = Date.now();
+    pruneExpired(now);
+    const expiresAt = now + DELIVERED_TTL_MS;
+    let recorded = false;
+    for (const key of [execKey(executionId), textKey(text)]) {
+        if (!key) continue;
+        _delivered.delete(key); // re-insert to refresh age order
+        _delivered.set(key, expiresAt);
+        recorded = true;
+    }
+    if (recorded) enforceBound();
+    return recorded;
+}
+
+export function isDeliveredCompletion({ executionId, text } = {}) {
+    const now = Date.now();
+    const keys = [execKey(executionId), textKey(text)].filter(Boolean);
+    let hit = false;
+    for (const key of keys) {
+        const expiresAt = _delivered.get(key);
+        if (expiresAt === undefined) continue;
+        if (expiresAt <= now) { _delivered.delete(key); continue; }
+        hit = true;
+    }
+    if (!hit) return false;
+    // Sliding refresh: extend every present key (and move it to the age tail) so
+    // a long-idle drain that checks it later still recognizes it as delivered.
+    const expiresAt = now + DELIVERED_TTL_MS;
+    for (const key of keys) {
+        if (!_delivered.has(key)) continue;
+        _delivered.delete(key);
+        _delivered.set(key, expiresAt);
+    }
+    return true;
+}
+
+// One diagnostic stderr line per dedup skip, naming the site
+// (mirror/fallback/notify-enqueue/drain) so the actual racing edge is
+// empirically confirmable in logs.
+export function logDuplicateSkip(site, { executionId, text } = {}) {
+    try {
+        const id = executionId == null ? '' : String(executionId).trim();
+        const h = hashCompletionText(text);
+        process.stderr.write(
+            `[completion-dedup] skip site=${site}`
+            + `${id ? ` execution_id=${id}` : ''}`
+            + `${h ? ` hash=${h.slice(0, 12)}` : ''}\n`,
+        );
+    } catch { /* ignore */ }
+}
+
+// Test-only reset hook.
+export function _clearDeliveredCompletions() {
+    _delivered.clear();
+}

package/src/runtime/agent/orchestrator/session/manager/idle-cleanup.mjs

@@ -13,10 +13,22 @@ import { nonNegativeIntEnv } from './env-utils.mjs';
 const CLEANUP_INTERVAL_MS = nonNegativeIntEnv('MIXDOG_SESSION_CLEANUP_INTERVAL_MS', 5 * 60 * 1000); // check every 5 minutes
 const CLEANUP_INITIAL_DELAY_MS = nonNegativeIntEnv('MIXDOG_SESSION_CLEANUP_INITIAL_DELAY_MS', CLEANUP_INTERVAL_MS > 0 ? CLEANUP_INTERVAL_MS : 0);
 const CLEANUP_SLOW_LOG_MS = nonNegativeIntEnv('MIXDOG_SESSION_CLEANUP_SLOW_LOG_MS', 250);
-const TOMBSTONE_MAX_AGE_MS = 24 * 60 * 60 * 1000; // 24h — far longer than any realistic ask race window
+// Tombstone unlink TTL. The guarded resurrection race (temp-write→rename inside
+// _doSave) resolves in microseconds, so 1h is still vastly longer than any
+// realistic in-flight ask race — while short enough that matured tombstones are
+// reclaimed promptly instead of accumulating for a full day.
+const TOMBSTONE_MAX_AGE_MS = 60 * 60 * 1000; // 1h
 let _cleanupTimer = null;
 let _cleanupInitialTimer = null;
 
+// A session is "live" when it still owns a non-closed runtime entry. Passed to
+// the retention cap so the active/current and any in-flight session is never
+// pruned by the open-session max-age/max-count bounds.
+function _isSessionLive(id) {
+    const entry = _getRuntimeEntry(id);
+    return !!(entry && entry.closed !== true);
+}
+
 function _previewIds(items, limit = 5) {
     const ids = (items || []).slice(0, limit).map((item) => item.id).filter(Boolean);
     if (ids.length === 0) return '';
@@ -29,6 +41,7 @@ function sweepIdleSessions({ includeTombstones = true } = {}) {
     try {
         const result = sweepStaleSessions({
             tombstoneMaxAgeMs: includeTombstones ? TOMBSTONE_MAX_AGE_MS : 0,
+            isSessionLive: _isSessionLive,
         });
         const {
             cleaned,
@@ -81,7 +94,7 @@ function sweepIdleSessions({ includeTombstones = true } = {}) {
  * Rationale: closeSession() leaves the tombstone on disk as the authoritative
  * resurrection-blocker for racing saveSession() calls. That race resolves in
  * microseconds (the window inside _doSave between temp write and rename), so
- * 24h is vastly safe. After the TTL expires we reclaim the disk slot.
+ * 1h is vastly safe. After the TTL expires we reclaim the disk slot.
  *
  * Uses `getStoredSessionsRaw()` rather than `listStoredSessions()` because the
  * latter's inline 30-min idle cleanup would race-unlink tombstones before we

package/src/runtime/agent/orchestrator/session/manager/pending-messages.mjs

@@ -1,10 +1,12 @@
 // Steering / pending-message queue with sync buffered + atomic-file persistence.
 // Extracted verbatim from manager.mjs (behavior-preserving).
 import { join } from 'path';
+import { readFileSync } from 'fs';
 import { resolvePluginData } from '../../../../shared/plugin-paths.mjs';
 import { updateJsonAtomicSync, updateJsonAtomic } from '../../../../shared/atomic-file.mjs';
 import { promptContentText, isInternalRuntimeNotificationText } from './prompt-utils.mjs';
 import { loadSession } from '../store.mjs';
+import { isDeliveredCompletion, logDuplicateSkip } from './delivered-completions.mjs';
 
 const _sessionPendingMessages = new Map();
 const PENDING_MESSAGES_FILE = 'session-pending-messages.json';
@@ -24,6 +26,31 @@ function isCompletionNotificationEntry(entry) {
         && entry.notificationKind === COMPLETION_NOTIFICATION_KIND;
 }
 
+// Pre-marker completion notifications were persisted as plain strings,
+// indistinguishable from genuine user/steering messages except by their
+// model-visible wrapper shape. Such stale strings must never replay into a
+// resumed session, but they carry no notificationKind marker, so the marker
+// check alone leaves them behind. Because this is a SILENT-drop path, the
+// shared lenient wrapper detector is too broad (a user message quoting a
+// completion card could be dropped), so this uses its OWN strict recognizer:
+// the string must be a verbatim full-card paste and nothing else —
+//   (1) start with the exact instruction preamble + "\n\nResult:\n",
+//   (2) have EVERY non-empty body line quoted with "> " (100%),
+//   (3) carry no extra leading/trailing prose (whitespace-trim only).
+// Conservative by design: a false negative just keeps a legacy string, but a
+// false positive on genuine user text would silently drop a real message.
+const LEGACY_COMPLETION_CARD_PREAMBLE_RE = /^The async \S+ task \S+ has finished \([^)]*\) - review this result in your next step\.\n\nResult:\n/;
+function isLegacyUnmarkedCompletionNotification(entry) {
+    if (typeof entry !== 'string') return false;
+    const value = entry.trim();
+    const match = LEGACY_COMPLETION_CARD_PREAMBLE_RE.exec(value);
+    if (!match) return false;
+    const body = value.slice(match[0].length);
+    const lines = body.split(/\r?\n/).filter((line) => line.length > 0);
+    if (lines.length === 0) return false;
+    return lines.every((line) => line.startsWith('> '));
+}
+
 // Canonical completion-enqueue tagger. Every deferred tool/agent completion
 // notification MUST be enqueued through this so drain can discard it on resume
 // (never replay out-of-order). Pass the model-visible completion text (or an
@@ -393,8 +420,21 @@ export function drainPendingMessages(sessionId) {
     // in-memory queue is empty, so keeping it only ever delivers live entries.
     // Genuine user/steering messages carry no marker and are kept in order in
     // both paths.
-    const memoryKept = memory;
-    const persistedKept = persisted.filter((m) => !isCompletionNotificationEntry(m));
+    // Drain-time belt: drop MARKED in-memory completion entries whose text hash
+    // was already delivered+ACKed (TUI execution-ui) this process — those would
+    // double-inject next turn. Only marked completion entries are eligible;
+    // genuine user/steering entries carry no marker and are always kept.
+    const memoryKept = memory.filter((m) => {
+        if (!isCompletionNotificationEntry(m)) return true;
+        const text = pendingMessageText(m);
+        if (text && isDeliveredCompletion({ text })) {
+            logDuplicateSkip('drain', { text });
+            return false;
+        }
+        return true;
+    });
+    const persistedKept = persisted.filter((m) => !isCompletionNotificationEntry(m)
+        && !isLegacyUnmarkedCompletionNotification(m));
     const memoryVisible = modelVisiblePendingMessages(memoryKept);
     const persistedVisible = modelVisiblePendingMessages(persistedKept);
     if (memoryVisible.length === 0) return persistedVisible;
@@ -419,6 +459,31 @@ export function drainPendingMessages(sessionId) {
     return out;
 }
 
+// Snapshot queued entries without draining them. Compaction uses this to keep
+// sidecars referenced by a message that is waiting for the next turn, whether
+// it is still in memory, buffered for persistence, or already on disk.
+export function _getPendingMessagesForSession(sessionId) {
+    if (!isValidPendingSessionId(sessionId)) return [];
+    const queued = [
+        ...(_sessionPendingMessages.get(sessionId) || []),
+        ...(_pendingPersistBuffers.get(sessionId) || []),
+    ];
+    let raw;
+    try {
+        raw = readFileSync(pendingMessagesPath(), 'utf8');
+    } catch (err) {
+        if (err?.code === 'ENOENT') return queued;
+        throw err;
+    }
+    try {
+        const persisted = normalizePendingStore(JSON.parse(raw)).sessions[sessionId];
+        if (Array.isArray(persisted)) queued.push(...persisted);
+    } catch (err) {
+        throw err;
+    }
+    return queued;
+}
+
 // Cleanup hook for closeSession — drop the in-memory queue and buffered-persist
 // entry so both Maps do not accumulate one entry per closed session.
 export function _dropPendingMessageState(id, { clearPersisted = true } = {}) {

package/src/runtime/agent/orchestrator/session/manager/session-close.mjs

@@ -24,7 +24,7 @@ import { _closeBashSessionLazy } from './runtime-loaders.mjs';
  * and recreates the session in its pre-close state.
  *
  * Long-term cleanup: `sweepTombstones()` below unlinks tombstones older than
- * TOMBSTONE_MAX_AGE_MS (24h — vastly longer than any realistic in-flight race).
+ * TOMBSTONE_MAX_AGE_MS (1h — vastly longer than the microsecond in-flight race).
  */
 export function closeSession(id, reason = 'manual', opts = {}) {
     // tombstone=false: detach runtime resources (heartbeat, bash shells,

package/src/runtime/agent/orchestrator/session/manager/usage-metrics.mjs

@@ -163,6 +163,8 @@ export function bumpUsageMetricsTurnId(session) {
     if (!session || typeof session !== 'object') return 0;
     const next = (Number(session.usageMetricsTurnId) || 0) + 1;
     session.usageMetricsTurnId = next;
+    const seen = _metricSeenIter.get(session.id);
+    if (seen) seen.clear();
     return next;
 }