mixdog 1.3.2 → 1.3.4

package/src/runtime/agent/orchestrator/session/compact/execution-tail.mjs

@@ -3,9 +3,12 @@ import { estimateMessagesTokens } from '../context-utils.mjs';
 import { estimateTokens } from '../token-estimate.mjs';
 import { persistToolResultArtifactSync, previewToolResultArtifact } from '../tool-result-offload.mjs';
 import {
+  EXECUTION_TEXT_SOURCE,
   isActualUserInstructionMessage,
+  isCompactConversationRow,
   isProtectedContextAckMessage,
   latestActualUserInstructionIndex,
+  pendingTaskNotificationIndexes,
 } from './messages.mjs';
 import { staleObservations, supersedeObservation } from './observation-supersession.mjs';
 import { carryMessageId, withoutMessageIdsReplacer } from '../message-ids.mjs';
@@ -168,9 +171,10 @@ function shrinkGroup(group, archive, level) {
   });
 }
 
-// Walk from the anchor: kept groups verbatim, user instructions, and the
-// conversational assistant text the mode allows.
-function assembleTail(messages, kept, { anchor, firstKept, preserveConversation }) {
+// Walk from the anchor: kept groups verbatim, user instructions, unanswered
+// task notifications, and the conversation the mode allows (rule-only:
+// assistant text and runtime conversation rows).
+function assembleTail(messages, kept, { anchor, firstKept, preserveConversation, pending }) {
   const tail = [];
   for (let i = Math.max(0, anchor); i < messages.length; i += 1) {
     const group = kept.get(i);
@@ -184,8 +188,16 @@ function assembleTail(messages, kept, { anchor, firstKept, preserveConversation
       // Omitted execution stays in the archive; its conversational text
       // remains verbatim without replaying an orphaned call or reasoning.
       if (message.toolCalls?.length) {
-        // The text-only copy is this message's rewrite: it keeps its id.
-        if (message.content) tail.push(carryMessageId({ role: 'assistant', content: message.content }, message));
+        // The text-only copy is this message's rewrite: it keeps its id, and
+        // its marker keeps it from reading as a final reply.
+        if (message.content) {
+          tail.push(
+            carryMessageId(
+              { role: 'assistant', content: message.content, meta: { source: EXECUTION_TEXT_SOURCE } },
+              message
+            )
+          );
+        }
       } else {
         tail.push(message);
       }
@@ -193,6 +205,8 @@ function assembleTail(messages, kept, { anchor, firstKept, preserveConversation
     }
     if (
       isActualUserInstructionMessage(message) ||
+      pending.has(i) ||
+      (preserveConversation && isCompactConversationRow(message)) ||
       (i >= firstKept && message?.role === 'assistant' && !message.toolCalls?.length)
     ) {
       tail.push(message);
@@ -297,13 +311,22 @@ export function buildExecutionTail(
     throw new Error('compact: latest execution group cannot fit the tool-history budget; original context preserved');
   }
   const latest = latestActualUserInstructionIndex(messages);
+  const pendingIndexes = pendingTaskNotificationIndexes(messages);
+  const pending = new Set(pendingIndexes);
   const firstKept = kept.size ? Math.min(...kept.keys()) : messages.length;
   const latestKept = latest < 0 ? firstKept : latest;
-  const anchor = preserveConversation ? 0 : requestStart(messages, Math.min(firstKept, latestKept));
-  const tail = assembleTail(messages, kept, { anchor, firstKept, preserveConversation });
+  const anchor = preserveConversation
+    ? 0
+    : Math.min(requestStart(messages, Math.min(firstKept, latestKept)), ...pendingIndexes);
+  const tail = assembleTail(messages, kept, { anchor, firstKept, preserveConversation, pending });
   // With no execution to retain, keep the existing latest-request contract.
   if (!preserveConversation && !groups.length && !previousRecovery.length) {
-    return { messages: latest < 0 ? [] : [messages[latest]], toolTokens: 0, toolBudget: budget, retainedGroups: 0 };
+    return {
+      messages: messages.filter((_message, index) => index === latest || pending.has(index)),
+      toolTokens: 0,
+      toolBudget: budget,
+      retainedGroups: 0,
+    };
   }
   return {
     messages: [...recovery, ...tail],

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

@@ -10,6 +10,7 @@ import {
   isProtectedContextUserMessage,
   isSummaryMessage,
 } from './user-message-kind.mjs';
+import { CONTROL_MARKER_RE } from '../../../../shared/tool-execution-contract.mjs';
 
 export function compactHeader(oldHistory) {
   // Stable display ids are bookkeeping, not conversation: the header names
@@ -53,6 +54,49 @@ export function isProtectedContextAckMessage(m) {
   );
 }
 
+// The text-only copy rule-only Compact keeps of an omitted tool-call turn.
+// It is execution, not a final reply, though it no longer carries its calls.
+export const EXECUTION_TEXT_SOURCE = 'compact-execution-text';
+
+// Delivered task notifications (a background agent's or task's completion,
+// stored as a role:'user' turn with source 'task-notification') the model has
+// not answered yet: every one after the latest final assistant reply. They
+// are turn input but neither a user instruction nor summarized conversation,
+// so a Compact must carry them verbatim or the report is lost.
+export function pendingTaskNotificationIndexes(messages) {
+  const list = Array.isArray(messages) ? messages : [];
+  const pending = [];
+  for (let index = list.length - 1; index >= 0; index -= 1) {
+    const message = list[index];
+    if (
+      message?.role === 'assistant' &&
+      !message.toolCalls?.length &&
+      !isProtectedContextAckMessage(message) &&
+      message.meta?.source !== EXECUTION_TEXT_SOURCE
+    ) {
+      break;
+    }
+    if (message?.role === 'user' && message.meta?.source === 'task-notification') pending.unshift(index);
+  }
+  return pending;
+}
+
+// Runtime rows that are conversation, not instructions: task and channel
+// notifications (answered or not), routine and task results posted into a
+// home thread, and turn interruption markers. Rule-only Compact keeps them
+// with the dialogue; the summary reads them as data.
+const CONVERSATION_RUNTIME_SOURCES = new Set(['task-notification', 'schedule-result']);
+
+export function isCompactConversationRow(message) {
+  if (message?.role !== 'user') return false;
+  if (CONVERSATION_RUNTIME_SOURCES.has(String(message.meta?.source || ''))) return true;
+  return (
+    typeof message.content === 'string' &&
+    CONTROL_MARKER_RE.test(message.content.trim()) &&
+    !isActualUserInstructionMessage(message)
+  );
+}
+
 function referenceFilesManifestMessage(message) {
   if (message?.role !== 'user' || typeof message.content !== 'string') return null;
   const text = message.content.trimStart();

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

@@ -5,16 +5,19 @@ import { estimateMessagesTokens, reconcileDedupStubs, sanitizeToolPairs } from '
 import { HANDOFF_TIMEOUT_MAX_MS, SUMMARY_OUTPUT_TOKENS, compactDebugLog } from './constants.mjs';
 import {
   contentText,
+  redactRawSecretString,
   redactToolCallSecretsInMessages,
   safeEstimateMessagesTokens,
   textByteLength,
 } from './text-utils.mjs';
 import {
   contextAckMessage,
+  isCompactConversationRow,
   isProtectedContextAckMessage,
   isSummaryMessage,
   latestActualUserInstructionIndex,
   latestActualUserInstructionMessage,
+  pendingTaskNotificationIndexes,
   splitProtectedContext,
 } from './messages.mjs';
 import { activeTurnContinuationMessage } from './continuation.mjs';
@@ -102,28 +105,76 @@ function chunkConversationMessage(role, content, source = {}) {
   return out;
 }
 
-function pureConversationForHandoff(messages) {
+// What the summary reads of runtime conversation rows and tool calls. The
+// rows stay whole in rule-only Compact; the calls stay in the execution tail
+// and archive.
+const SUMMARY_RUNTIME_ROW_CHARS = 4_000;
+const SUMMARY_TOOL_ARGS_CHARS = 200;
+const SUMMARY_TOOL_OUTCOME_CHARS = 300;
+
+function boundedSummaryText(text, limit) {
+  return text.length > limit ? `${text.slice(0, limit)}… [${text.length - limit} more chars]` : text;
+}
+
+function toolCallSummaryLine(call, result) {
+  const rawArgs = typeof call.arguments === 'string' ? call.arguments : JSON.stringify(call.arguments ?? {});
+  const args = boundedSummaryText(rawArgs.replace(/\s+/g, ' '), SUMMARY_TOOL_ARGS_CHARS);
+  // Arguments arrive redacted (splitFreshSource); the outcome is redacted
+  // here, before any cut can split a secret from its key.
+  const outcome = redactRawSecretString(contentText(result?.content)).trim();
+  // An ask_user result is the user's own answer: never cut.
+  const shown =
+    call.name === 'ask_user' ? outcome : boundedSummaryText(outcome.replace(/\s+/g, ' '), SUMMARY_TOOL_OUTCOME_CHARS);
+  return `[tool call] ${call.name}(${args}) → ${result ? shown || '(empty result)' : '(no result)'}`;
+}
+
+// The conversation Compact measures and summarizes: user and assistant text
+// (the memory-ingest projection) plus runtime conversation rows. `summary`
+// bounds those rows and adds one line per tool call with its outcome.
+function compactionConversationRows(messages, { summary = false } = {}) {
+  const list = messages || [];
+  const results = new Map(list.filter((m) => m?.role === 'tool').map((m) => [m.toolCallId, m]));
   const out = [];
-  for (const message of messages || []) {
+  for (const message of list) {
     if (!message || typeof message !== 'object') continue;
-    const role = normalizeIngestRole(message.role);
-    if (!role || shouldExcludeIngestMessage(message)) continue;
     const content = contentText(message.content).trim();
-    if (!content) continue;
-    out.push(...chunkConversationMessage(role, content, message));
+    if (isCompactConversationRow(message)) {
+      // A notification can carry a background command's output: the summary
+      // reads it redacted like a tool outcome.
+      const text = summary ? boundedSummaryText(redactRawSecretString(content), SUMMARY_RUNTIME_ROW_CHARS) : content;
+      if (text) out.push(...chunkConversationMessage('user', text, message));
+      continue;
+    }
+    const role = normalizeIngestRole(message.role);
+    if (role && content && !shouldExcludeIngestMessage(message)) {
+      out.push(...chunkConversationMessage(role, content, message));
+    }
+    if (summary && message.role === 'assistant' && message.toolCalls?.length) {
+      const lines = message.toolCalls.map((call) => toolCallSummaryLine(call, results.get(call.id)));
+      out.push(...chunkConversationMessage('assistant', lines.join('\n'), message));
+    }
   }
   return out;
 }
 
-export function conversationCompactionInput(messages) {
+/** The conversation Compact measures against its summary threshold, or with
+ *  `summary`, the input the summary is written from. */
+export function conversationCompactionInput(messages, { summary = false } = {}) {
   const source = splitFreshSource(messages);
-  const latest = latestActualUserInstructionIndex(source.live);
+  // The turn input (the latest actual request and unanswered notifications)
+  // is mandatory and must never be replaced by a summary. Skills and runtime
+  // injections are excluded by the same conversation projection used by
+  // summary generation.
+  const turnInput = new Set([
+    latestActualUserInstructionIndex(source.live),
+    ...pendingTaskNotificationIndexes(source.live),
+  ]);
   return [
     ...(source.previousSummaryMessage ? [source.previousSummaryMessage] : []),
-    // The latest actual request is mandatory and must never be replaced by
-    // a summary. Tool outputs, skills and runtime injections are excluded
-    // by the same conversation projection used by summary generation.
-    ...pureConversationForHandoff(source.live.filter((_, index) => index !== latest)),
+    ...compactionConversationRows(
+      source.live.filter((_, index) => !turnInput.has(index)),
+      { summary }
+    ),
   ];
 }
 
@@ -229,7 +280,8 @@ export async function generateFreshHandoffSummary(provider, messages, model, bud
   const startedAt = Date.now();
   const budget = effectiveBudget(budgetTokens, opts);
   const source = splitFreshSource(messages);
-  let head = opts.filterOldHistoryForIngest === true ? pureConversationForHandoff(source.live) : source.live;
+  let head =
+    opts.filterOldHistoryForIngest === true ? compactionConversationRows(source.live, { summary: true }) : source.live;
   if (head.length === 0 && !source.previousSummary) {
     throw new Error('generateFreshHandoffSummary: no compactable session history');
   }
@@ -341,7 +393,12 @@ function prependLatestUserContext(message, prefix) {
   if (replacesGoalState) {
     suffix = suffix.replace(/<system-reminder>\s*<goal_state>[\s\S]*?<\/goal_state>\s*<\/system-reminder>\s*/gi, '');
   }
-  return withRuntimeUserContext(bare, { prefix: `${text}\n\n`, suffix });
+  // The kept suffix still carries the turn's agent list reminder: it stays told.
+  const told = bare !== message && message.meta.agentListing ? { agentListing: message.meta.agentListing } : null;
+  return withRuntimeUserContext(told ? { ...bare, meta: { ...bare.meta, ...told } } : bare, {
+    prefix: `${text}\n\n`,
+    suffix,
+  });
 }
 
 // The retained execution tail plus the current-turn messages that must
@@ -360,8 +417,11 @@ function freshContextTail(source, budgetTokens, preserveConversation, opts) {
   const retainedTail = execution.messages.map((message, index) =>
     index === latestIndex ? prependLatestUserContext(message, opts.latestUserPrefix) : message
   );
+  // The turn's input: the latest real request or an unanswered notification
+  // (a bot home thread may hold no human request at all).
+  const turnInput = !!latestUser || pendingTaskNotificationIndexes(source.live).length > 0;
   const activeTurnContinuation =
-    latestUser && opts.activeTurn === true ? activeTurnContinuationMessage(source.live) : null;
+    turnInput && opts.activeTurn === true ? activeTurnContinuationMessage(source.live) : null;
   // Older compacted sessions may have only synthetic Goal turns left.
   // Preserve the current snapshot without inventing a human instruction
   // to attach it to or resurrecting every historical Goal reminder.
@@ -376,6 +436,7 @@ function freshContextTail(source, budgetTokens, preserveConversation, opts) {
   return {
     execution,
     latestUser,
+    turnInput,
     retainedTail,
     activeTurnContinuation,
     volatileTail: [
@@ -408,20 +469,57 @@ function skillLoaderPair(live, bodyIndex, name, retainedCallIds) {
   return [];
 }
 
+const SKILL_RELOAD_SOURCE = 'compact-skill-reload';
+
+function skillReloadReminder(name) {
+  return {
+    role: 'user',
+    content: `[mixdog-runtime] Skill "${name}" was active, but its instructions did not fit after Compact. Reload it with the Skill tool before relying on them.`,
+    meta: { source: SKILL_RELOAD_SOURCE, synthetic: true, skill: name },
+  };
+}
+
 // Preserve complete, most-recent skill bodies from the durable transcript.
 // Never summarize/truncate operating instructions or displace the handoff
-// and current task. An omitted body remains eligible for a normal reload.
+// and current task. An omitted body leaves a one-line reload reminder, which
+// stands through later Compacts until the skill is loaded again. Reminders
+// are charged to the same budget: every skill's reminder is reserved before
+// any body is restored, and restoring a body releases its own reminder.
 function restoreSkillBodies(live, skillBudget, retainedTail) {
   const retainedCallIds = new Set(retainedTail.filter((m) => m?.role === 'tool').map((m) => m.toolCallId));
+  const bodies = latestSkillBodies(live);
+  const loaded = new Set(bodies.map((body) => body.name));
+  const reload = live
+    .filter((m) => m?.meta?.source === SKILL_RELOAD_SOURCE && !loaded.has(m.meta.skill))
+    .map((m) => m.meta.skill);
+  const reminderCost = (name) => estimateMessagesTokens([skillReloadReminder(name)]);
+  let reserved = [...new Set([...reload, ...loaded])].reduce((sum, name) => sum + reminderCost(name), 0);
+  const dropped = [];
   const restoredSkills = [];
   let skillTokens = 0;
-  for (const { name, message } of latestSkillBodies(live).reverse()) {
+  for (const { name, message } of bodies.reverse()) {
     const restored = [...skillLoaderPair(live, live.lastIndexOf(message), name, retainedCallIds), message];
     const cost = estimateMessagesTokens(restored);
-    if (skillTokens + cost > skillBudget) continue;
+    const own = reminderCost(name);
+    if (skillTokens + cost + reserved - own > skillBudget) {
+      dropped.unshift(name);
+      continue;
+    }
     restoredSkills.unshift(...restored);
     skillTokens += cost;
+    reserved -= own;
+  }
+  // Newest skill first; only a budget too small for the reminders themselves
+  // leaves one out.
+  const pending = [...new Set([...reload, ...dropped])];
+  const reminded = new Set();
+  for (const name of pending.toReversed()) {
+    const cost = reminderCost(name);
+    if (skillTokens + cost > skillBudget) continue;
+    reminded.add(name);
+    skillTokens += cost;
   }
+  restoredSkills.push(...pending.filter((name) => reminded.has(name)).map(skillReloadReminder));
   return { restoredSkills, skillTokens };
 }
 
@@ -548,7 +646,7 @@ function freshContextLayout(source, budgetTokens, opts) {
     ? fitFreshContextSummaryMessage(source.live, handoffText, Number.MAX_SAFE_INTEGER)
     : source.previousSummaryMessage;
   const tail = freshContextTail(source, budgetTokens, !replaceConversation, opts);
-  const stableAck = tail.latestUser && summaryMessage ? stableAckMessage(source.previousAck, tail.volatileTail) : null;
+  const stableAck = tail.turnInput && summaryMessage ? stableAckMessage(source.previousAck, tail.volatileTail) : null;
   const stableHead = [
     ...source.protectedPrefix,
     ...(summaryMessage ? [summaryMessage] : []),

package/src/runtime/agent/orchestrator/session/compact/text-utils.mjs

@@ -48,7 +48,7 @@ const SENSITIVE_RAW_KEY_RES = [
 // string. Consumes the WHOLE value after the key — spaces, `Bearer `/`Basic `
 // scheme words, quoted values with internal spaces, and `;`-separated cookie
 // pairs — so no secret fragment survives.
-function redactRawSecretString(text) {
+export function redactRawSecretString(text) {
   let value = String(text ?? '');
   if (!value) return value;
   for (const keyRe of SENSITIVE_RAW_KEY_RES) {

package/src/runtime/agent/orchestrator/session/compact/user-message-kind.mjs

@@ -87,6 +87,9 @@ export function isContextAckMessage(message, previous = null) {
 const SYNTHETIC_USER_SOURCES = new Set([
   // A schedule's output posted into its owner's home thread: untrusted data.
   'schedule-result',
+  // A delivered task or channel notification: turn input, never the human's
+  // request, whatever its text looks like.
+  'task-notification',
   'goal-continuation',
   'goal-closeout',
   'compact-context',