mixdog 0.9.158 → 0.9.159

package/src/runtime/agent/orchestrator/session/compact/constants.mjs

@@ -1,6 +1,4 @@
-// Shared compaction constants and compact-type helpers. Extracted verbatim
-// from compact.mjs (behavior-preserving). compact.mjs re-exports the public
-// members from here so the external surface is unchanged.
+// Shared Compact constants. compact.mjs re-exports this small public surface.
 import {
     DEFAULT_COMPACTION_BUFFER_TOKENS,
     DEFAULT_COMPACTION_BUFFER_RATIO,
@@ -19,20 +17,20 @@ export {
     compactionBufferTokensForBoundary,
 };
 
-export const SUMMARY_PREFIX = 'A previous model worked on this task and produced the compacted handoff summary below. Build on the work already done and avoid duplicating it; treat the summary as authoritative context for continuing the task. You also retain the preserved recent turns that follow.';
+export const SUMMARY_PREFIX_ANCHOR = 'A previous model worked on this task and produced the compacted handoff summary below.';
+export const SUMMARY_PREFIX = `${SUMMARY_PREFIX_ANCHOR} Build on the work already done and avoid duplicating it; treat the summary as authoritative context for continuing the task. The summary covers the full session; only the latest real user instruction is attached after it.`;
 export const SUMMARY_OUTPUT_TOKENS = 4_096;
 // Unified context-share rule: every derived "how much of the model context
-// may this budget take" ratio uses ONE number — 10%. Consumers:
+// may this budget take" ratio uses ONE number — 50%. Consumers:
 //   - compact target budget (loop/compact-policy.mjs COMPACT_TARGET_RATIO)
-//   - recall-fasttrack injection cap (loop.mjs recallTokenCap)
+//   - fresh-context handoff injection cap
 // Keep them in lockstep; do not fork per-consumer ratios without a decision.
-export const CONTEXT_SHARE_RATIO = 0.10;
+export const CONTEXT_SHARE_RATIO = 0.50;
 export const DEFAULT_EFFECTIVE_CONTEXT_WINDOW_PERCENT = 90;
 export const COMPACT_TARGET_MIN_TOKENS = 4_000;
 export const COMPACT_SAFETY_PERCENT = 1.00;
-// Floor for the recall-injection cap so small-context models still get a
-// usable recall slice (cap = max(floor, contextWindow * CONTEXT_SHARE_RATIO)).
-export const RECALL_TOKEN_CAP_FLOOR_TOKENS = 2_048;
+// Floor for the handoff cap so small-context models still get a usable slice.
+export const HANDOFF_TOKEN_CAP_FLOOR_TOKENS = 2_048;
 // Minimum room the generated summary needs after the mandatory (system +
 // preserved tail) cost is accounted for. When the configured target budget is
 // smaller than the mandatory cost (e.g. the preserved recent turn carries a
@@ -42,40 +40,6 @@ export const RECALL_TOKEN_CAP_FLOOR_TOKENS = 2_048;
 // compact failures. Floor the working budget to mandatory + this room instead.
 export const COMPACT_SUMMARY_MIN_ROOM_TOKENS = 4_000;
 
-export const COMPACT_TYPE_SEMANTIC = 'semantic';
-export const COMPACT_TYPE_RECALL_FASTTRACK = 'recall-fasttrack';
-export const DEFAULT_COMPACT_TYPE = COMPACT_TYPE_SEMANTIC;
-export const COMPACT_TYPES = Object.freeze([
-    COMPACT_TYPE_SEMANTIC,
-    COMPACT_TYPE_RECALL_FASTTRACK,
-]);
-
-export function normalizeCompactType(value, fallback = DEFAULT_COMPACT_TYPE) {
-    const raw = String(value ?? '').trim().toLowerCase().replace(/_/g, '-');
-    if (!raw) return fallback;
-    if (raw === '1' || raw === 'type1' || raw === 'type-1' || raw === 'bench1' || raw === 'bench-1' || raw === 'semantic' || raw === 'summary') {
-        return COMPACT_TYPE_SEMANTIC;
-    }
-    // Recall fast-track aliases. `replace(/_/g,'-')` above already folds
-    // snake_case (fast_track -> fast-track), but list both dash/no-dash forms
-    // explicitly so callers passing either spelling resolve deterministically.
-    if (raw === '2' || raw === 'type2' || raw === 'type-2' || raw === 'recall' || raw === 'recall-fast' || raw === 'recall-fasttrack' || raw === 'recall-fast-track' || raw === 'fasttrack' || raw === 'fast-track') {
-        return COMPACT_TYPE_RECALL_FASTTRACK;
-    }
-    // Unknown / unrecognized value: fall back to the caller-provided default
-    // (semantic by default). Callers that need to detect an unknown value
-    // should compare the input against COMPACT_TYPES before normalizing.
-    return fallback;
-}
-
-export function compactTypeIsSemantic(value) {
-    return normalizeCompactType(value) === COMPACT_TYPE_SEMANTIC;
-}
-
-export function compactTypeIsRecallFastTrack(value) {
-    return normalizeCompactType(value) === COMPACT_TYPE_RECALL_FASTTRACK;
-}
-
 export function compactDebugEnabled() {
     return String(process.env.MIXDOG_COMPACT_DEBUG || '').trim() === '1';
 }

package/src/runtime/agent/orchestrator/session/compact/continuation.mjs

@@ -0,0 +1,55 @@
+import {
+    isProtectedContextAckMessage,
+    latestActualUserInstructionIndex,
+} from './messages.mjs';
+
+export const ACTIVE_TURN_CONTINUATION_SOURCE = 'compact-active-turn-continuation';
+export const ACTIVE_TURN_CONTINUATION_ANCHOR = '<active-turn-continuation>';
+
+function isExistingContinuation(message) {
+    return message?.role === 'user'
+        && (
+            String(message?.meta?.source || '') === ACTIVE_TURN_CONTINUATION_SOURCE
+            || (
+                typeof message.content === 'string'
+                && message.content.includes(ACTIVE_TURN_CONTINUATION_ANCHOR)
+            )
+        );
+}
+
+function isExecutionActivity(message) {
+    if (message?.role === 'tool') return true;
+    return message?.role === 'assistant' && !isProtectedContextAckMessage(message);
+}
+
+function makeActiveTurnContinuationMessage() {
+    return {
+        role: 'user',
+        content: [
+            '<system-reminder>',
+            ACTIVE_TURN_CONTINUATION_ANCHOR,
+            'The latest real user request was already in progress when Compact ran.',
+            'The compacted handoff above records the assistant progress and tool outcomes completed so far.',
+            'Continue from that state without repeating progress messages or completed tool calls.',
+            'Use tools only for work that the handoff leaves incomplete or failed.',
+            '</active-turn-continuation>',
+            '</system-reminder>',
+        ].join('\n'),
+        meta: {
+            source: ACTIVE_TURN_CONTINUATION_SOURCE,
+            synthetic: true,
+        },
+    };
+}
+
+export function activeTurnContinuationMessage(messages) {
+    const list = Array.isArray(messages) ? messages : [];
+    const latestUserIndex = latestActualUserInstructionIndex(list);
+    if (latestUserIndex < 0) return null;
+    const afterLatestUser = list.slice(latestUserIndex + 1);
+    if (!afterLatestUser.some(isExistingContinuation)
+        && !afterLatestUser.some(isExecutionActivity)) {
+        return null;
+    }
+    return makeActiveTurnContinuationMessage();
+}

package/src/runtime/agent/orchestrator/session/compact/messages.mjs

@@ -1,8 +1,12 @@
 // Message classification, protected-context splitting, and summary-message
 // construction helpers. Extracted verbatim from compact.mjs
 // (behavior-preserving).
-import { SUMMARY_PREFIX } from './constants.mjs';
+import { SUMMARY_PREFIX, SUMMARY_PREFIX_ANCHOR } from './constants.mjs';
 import { sha16, roleCounts } from './text-utils.mjs';
+import {
+    isInternalRuntimeNotificationText,
+    isModelVisibleToolCompletionWrapper,
+} from '../../../../shared/tool-execution-contract.mjs';
 
 export function compactHeader(oldHistory) {
     const encoded = JSON.stringify(oldHistory ?? []);
@@ -13,7 +17,7 @@ export function compactHeader(oldHistory) {
 }
 
 export function makeSummaryMessage(content) {
-    return { role: 'user', content };
+    return { role: 'user', content, meta: { source: 'compact-summary' } };
 }
 
 // A compact summary message is a synthetic role:'user' message carrying the
@@ -23,8 +27,14 @@ export function makeSummaryMessage(content) {
 // duplicate, or fail to merge across repeated compaction.
 export function isSummaryMessage(m) {
     return m?.role === 'user'
-        && typeof m.content === 'string'
-        && m.content.startsWith(SUMMARY_PREFIX);
+        && (
+            String(m?.meta?.source || '') === 'compact-summary'
+            || (
+                typeof m.content === 'string'
+                && m.content.startsWith(SUMMARY_PREFIX_ANCHOR)
+                && /\nmessages=\d+\s+(?:sha256=|compact_type=)/.test(m.content)
+            )
+        );
 }
 
 export function isProtectedContextUserMessage(m) {
@@ -51,6 +61,52 @@ export function isInjectedSkillBodyMessage(m) {
     return typeof m.content === 'string' && m.content.trimStart().startsWith('<skill>');
 }
 
+const SYNTHETIC_USER_SOURCES = new Set([
+    'compact-active-turn-continuation',
+    'max-output-recovery',
+    'refusal-recovery',
+]);
+const SYNTHETIC_USER_CONTROL_RE =
+    /^(?:\[mixdog-runtime\]|\[request interrupted(?: by user(?: for tool use)?| by process restart)?\])(?:\s|$)/i;
+
+function userMessageText(message) {
+    if (typeof message?.content === 'string') return message.content;
+    if (!Array.isArray(message?.content)) return '';
+    return message.content
+        .map((block) => (typeof block === 'string' ? block : block?.text || ''))
+        .join('');
+}
+
+export function isActualUserInstructionMessage(message) {
+    if (message?.role !== 'user'
+        || isSummaryMessage(message)
+        || isProtectedContextUserMessage(message)
+        || isInjectedSkillBodyMessage(message)) {
+        return false;
+    }
+    const text = userMessageText(message);
+    if (/^Reference files:\s*/i.test(text.trimStart())) return false;
+    if (SYNTHETIC_USER_CONTROL_RE.test(text.trimStart())
+        || isInternalRuntimeNotificationText(text)
+        || isModelVisibleToolCompletionWrapper(text)
+        || SYNTHETIC_USER_SOURCES.has(String(message?.meta?.source || ''))) {
+        return false;
+    }
+    return text.trim().length > 0 || (Array.isArray(message.content) && message.content.length > 0);
+}
+
+export function latestActualUserInstructionIndex(messages) {
+    for (let index = (Array.isArray(messages) ? messages.length : 0) - 1; index >= 0; index -= 1) {
+        if (isActualUserInstructionMessage(messages[index])) return index;
+    }
+    return -1;
+}
+
+export function latestActualUserInstructionMessage(messages) {
+    const index = latestActualUserInstructionIndex(messages);
+    return index >= 0 ? { ...messages[index] } : null;
+}
+
 export function isProtectedContextAckMessage(m) {
     return m?.role === 'assistant'
         && typeof m.content === 'string'
@@ -58,6 +114,27 @@ export function isProtectedContextAckMessage(m) {
         && !Array.isArray(m.toolCalls);
 }
 
+export function referenceFilesManifestMessage(message) {
+    if (message?.role !== 'user' || typeof message.content !== 'string') return null;
+    const text = message.content.trimStart();
+    if (!/^Reference files:\s*/i.test(text)) return null;
+    const paths = [...text.matchAll(/^###\s+(.+?)\s*$/gm)]
+        .map((match) => String(match[1] || '').trim())
+        .filter(Boolean);
+    if (paths.length === 0) return null;
+    const uniquePaths = [...new Set(paths)];
+    return {
+        role: 'user',
+        content: [
+            '<system-reminder>',
+            '# Reference files',
+            'These files were attached when the session started. Re-read a path when its current contents are needed; the original bodies are not re-injected after Compact.',
+            ...uniquePaths.map((path) => `- ${path}`),
+            '</system-reminder>',
+        ].join('\n'),
+    };
+}
+
 export function splitProtectedContext(messages) {
     const protectedPrefix = [];
     const conversation = [];
@@ -74,6 +151,14 @@ export function splitProtectedContext(messages) {
             previousWasProtectedContext = true;
             continue;
         }
+        if (prefixMode) {
+            const manifest = referenceFilesManifestMessage(m);
+            if (manifest) {
+                protectedPrefix.push(manifest);
+                previousWasProtectedContext = true;
+                continue;
+            }
+        }
         if (prefixMode && previousWasProtectedContext && isProtectedContextAckMessage(m)) {
             protectedPrefix.push(m);
             previousWasProtectedContext = false;