mixdog 1.3.0 → 1.3.2

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

@@ -2,8 +2,10 @@
 // What a persisted session row contains and where each field comes from: the
 // compaction budget, the origin/permission/cache metadata analytics slice on,
 // the desktop classification, and the record assembled from them. Everything
-// here is field derivation — no I/O, no ownership, no prompt text.
+// here is field derivation — no ownership, no prompt text; the only read is the
+// parent's record a delegated session takes its root from.
 import { toSessionWorkflowMeta } from '../../runtime-core/workflow.mjs';
+import { delegationForNewSession } from '../human-gate/delegation.mjs';
 import { sessionOrchestrationMode } from '../../../../shared/orchestration.mjs';
 import { preserveBufferConfigFields } from './context-meta.mjs';
 import { positiveInt } from '../../../../shared/numbers.mjs';
@@ -101,9 +103,18 @@ export function sessionOriginFields(opts, { profile, presetObj, providerCacheOpt
     ownerSessionId: opts.ownerSessionId || null,
     visibility: opts.visibility || null,
     clientHostPid: opts.clientHostPid || null,
+    // A sub-agent's or a bot-created task session's root (who it works for, and
+    // how that root was acting), derived from the parent's record — the one
+    // read here — never taken from the options (human-gate/delegation.mjs).
+    ...delegationFields(opts),
   };
 }
 
+function delegationFields(opts) {
+  const delegation = delegationForNewSession(opts);
+  return delegation ? { delegation } : {};
+}
+
 // The persisted session record.
 export function buildSessionRecord({ opts, route, presetObj, surface, prompt, messages, contextMeta, origin }) {
   const {

package/src/runtime/agent/orchestrator/session/manager/turn-checkpoint-journal.mjs

@@ -35,10 +35,9 @@
 // keeps the durable prefix.
 import { appendFileSync, existsSync, mkdirSync, readFileSync, unlinkSync, writeFileSync } from 'node:fs';
 import { appendFile, unlink, writeFile } from 'node:fs/promises';
-import { randomBytes } from 'node:crypto';
 import { join } from 'node:path';
 import { getPluginData } from '../../config.mjs';
-import { renameWithRetrySync } from '../../../../shared/atomic-file.mjs';
+import { writeFileAtomicSync } from '../../../../shared/atomic-file.mjs';
 import { sanitizeContentForStoredHistory } from '../../providers/media-normalization.mjs';
 import { promptContentText } from './prompt-utils.mjs';
 
@@ -145,19 +144,11 @@ export function writeCheckpointHeader(checkpoint) {
     contextState: checkpoint.contextState ?? null,
     updatedAt: Date.now(),
   };
-  const temp = `${target}.${randomBytes(6).toString('hex')}.tmp`;
-  try {
-    writeFileSync(temp, JSON.stringify(payload), 'utf8');
-    renameWithRetrySync(temp, target);
-    return true;
-  } catch (error) {
-    try {
-      unlinkSync(temp);
-    } catch {
-      /* best-effort */
-    }
-    throw error;
-  }
+  // Durable (fsynced through its handle, then renamed): a crash must not
+  // publish a header whose bytes never landed. A damaged header already reads
+  // as "no checkpoint" (parseTurnCheckpointHeader) and the next turn rewrites it.
+  writeFileAtomicSync(target, JSON.stringify(payload));
+  return true;
 }
 
 export function readTurnCheckpointHeader(sessionId) {

package/src/runtime/agent/orchestrator/session/manager/turn-checkpoint.mjs

@@ -18,6 +18,7 @@ import {
   writeCheckpointHeader,
 } from './turn-checkpoint-journal.mjs';
 import { captureTurnCheckpointContextState, restoreTurnCheckpointContextState } from './turn-checkpoint-context.mjs';
+import { stripProviderReplayMessages } from './provider-replay.mjs';
 
 export { turnCheckpointPath, turnMessagesForCheckpoint };
 export { captureTurnCheckpointContextState, restoreTurnCheckpointContextState };
@@ -198,7 +199,12 @@ export function recoverTurnCheckpoint(session) {
   const current = Array.isArray(session.messages) ? session.messages : [];
   const start = findTurnStart(current, checkpoint.currentUserContent);
   const kept = start >= 0 ? current.slice(0, start) : current;
-  session.messages = checkpoint.fullTranscript === true ? finalized.messages : [...kept, ...finalized.messages];
+  // The route switched models mid-turn (the marker says so) and the journal
+  // may predate the switch: its turn still carries the previous provider's
+  // native replay state, which the saved route's provider must not receive.
+  const turnMessages =
+    marker?.routeChanged === true ? stripProviderReplayMessages(finalized.messages) : finalized.messages;
+  session.messages = checkpoint.fullTranscript === true ? turnMessages : [...kept, ...turnMessages];
   // Re-anchor provider usage / post-compact replacement state to the exact
   // canonical checkpoint representation. If a legacy or corrupted checkpoint
   // cannot prove alignment, retain the last provider reading for display but

package/src/runtime/agent/orchestrator/session/manager/turn-interruption.mjs

@@ -20,7 +20,15 @@ const INTERRUPTED_TOOL_RESULT = 'Cancelled';
 // PRESERVE the just-sent user turn: nothing restores the prompt there, and
 // rewinding erases the user's message from the persisted transcript (the
 // exact loss seen when the desktop app quits mid-turn).
-const USER_CANCEL_ABORT_REASONS = new Set(['cli-abort', 'user-cancel', 'turn-abort']);
+//
+// A user cancel the host will NOT answer with the prompt back in the input box
+// (the desktop Stop button, a prompt carrying attachments cancelled from
+// another device) names `USER_CANCEL_KEEP_PROMPT_REASON`: it is still a user
+// cancel, but the unanswered prompt stays in the stored transcript. Rewinding
+// it left a first message with zero stored messages — a session every catalog
+// hides — and its text nowhere.
+export const USER_CANCEL_KEEP_PROMPT_REASON = 'user-cancel-keep-prompt';
+const USER_CANCEL_ABORT_REASONS = new Set(['cli-abort', 'user-cancel', 'turn-abort', USER_CANCEL_KEEP_PROMPT_REASON]);
 
 function provisionalUserTurnIndex(messages, currentUserContent) {
   const currentText = promptContentText(currentUserContent);
@@ -78,7 +86,17 @@ function finalizeInterruptedTurn({
   // turn and its side effects from history.
   const preserveResponse = responseStarted && (producedOutput || !userCancelled);
   if (!preserveResponse) {
-    if (!userCancelled) {
+    if (!userCancelled || abortReason === USER_CANCEL_KEEP_PROMPT_REASON) {
+      // A kept prompt gets the generic interruption row (rendered as the
+      // Cancelled status, unlike the hidden by-user control row): without it a
+      // rebuilt transcript shows the stopped prompt as if it were still
+      // awaiting an answer, directly above the next one.
+      if (
+        abortReason === USER_CANCEL_KEEP_PROMPT_REASON &&
+        provisionalUserTurnIndex(messages, currentUserContent) >= 0
+      ) {
+        messages.push({ role: 'user', content: SESSION_INTERRUPT_MESSAGE });
+      }
       return {
         messages,
         responsePreserved: false,
@@ -145,18 +163,16 @@ function appendObservedTurnOutput(
     if (!result?.toolCallId || representedToolResultIds.has(result.toolCallId)) continue;
     messages.push({
       role: 'tool',
-      content: result.content == null ? '' : result.content,
+      content: result.content ?? '',
       toolCallId: result.toolCallId,
       ...(result.toolKind ? { toolKind: result.toolKind } : {}),
     });
     representedToolResultIds.add(result.toolCallId);
   }
 
-  const allToolCallIds = [];
+  const allToolCallIds = new Set();
   for (const message of messages) {
-    for (const id of assistantToolCallIds(message)) {
-      if (!allToolCallIds.includes(id)) allToolCallIds.push(id);
-    }
+    for (const id of assistantToolCallIds(message)) allToolCallIds.add(id);
   }
   for (const callId of allToolCallIds) {
     if (representedToolResultIds.has(callId)) continue;
@@ -283,7 +299,7 @@ export function createTurnInterruptionTracker() {
       if (message.__earlyNotify === true) {
         state.observedToolResults.set(callId, {
           role: 'tool',
-          content: message.content == null ? '' : message.content,
+          content: message.content ?? '',
           toolCallId: callId,
           toolKind: message.toolKind || (message.isError ? 'error' : null),
         });

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

@@ -558,7 +558,7 @@ export async function persistIterationMetrics(delta) {
     // per model call of this session (every tool-loop iteration), replaced
     // immutably so a consumer can tell by identity that it changed. Sessions
     // saved before this field began at their first call after it.
-    session.usageReadout = foldUsageReadout(session.usageReadout, delta, delta.generationMs);
+    session.usageReadout = foldUsageReadout(session.usageReadout, delta, delta.requestMs);
     recordLastContextTokens(session, iterationContext(delta));
   }
   session.lastIterationIndex = iterationIndex;

package/src/runtime/agent/orchestrator/session/manager/workflow-switch-notice.mjs

@@ -1,20 +1,97 @@
 // manager/workflow-switch-notice.mjs
 // A mid-conversation workflow switch (session-runtime/tool-policy-refresh.mjs
-// switchSessionWorkflow) rebuilds the session's prompt and tool surface and
-// stages `session.workflowSwitch`, the one-time notice the next user turn
-// carries in its reminder block. Lifecycle mirrors the working-folder notice
-// (prompt-utils snapshotPendingWorkspaceNotice): snapshot when the turn is
-// built, acknowledge once the provider accepted it, so a failed turn re-sends
-// it. The state object is replaced, never mutated:
-//   from — the workflow the model was last told about (kept across switches
-//          made before a notice reached it);
-//   to   — the workflow the prompt carries now.
+// switchSessionWorkflow) leaves the request prefix — system blocks and tool
+// schemas — byte-identical, so the provider cache survives. The switch lives
+// in two pieces of session state:
+//   session.workflowOverlay — while the session's workflow differs from the
+//     one its system prompt carries: the prompt's workflow (`prompt`, and the
+//     orchestration mode its tool surface was built with), the new workflow,
+//     its tools that are refused at call time (`deniedTools`), the tools it
+//     allows that this session cannot reach (`unavailableTools`) and the
+//     self-contained reminder (`content`) with the new workflow's rules,
+//     orchestration and agents. It is folded into the prompt (and dropped) at
+//     the next point where the cache is cold anyway (tool-policy-refresh.mjs).
+//   session.workflowSwitch — the notice the next user turn carries in its
+//     reminder block. Lifecycle mirrors the working-folder notice
+//     (prompt-utils snapshotPendingWorkspaceNotice): snapshot when the turn is
+//     built, acknowledge once the provider accepted it, so a failed turn
+//     re-sends it. Delivered, it stays in the conversation. Replaced, never
+//     mutated:
+//       from — the workflow the model was last told about (kept across
+//              switches made before a notice reached it);
+//       to   — the session's workflow now.
+// Every notice says it replaces the earlier ones, so the latest one wins.
 
 function workflowRef(workflow) {
   const id = String(workflow?.id || '').trim();
   return id ? { id, name: String(workflow?.name || id).trim() } : null;
 }
 
+/** The workflow the session's system prompt and tool surface were built with. */
+export function promptWorkflowOf(session) {
+  return session?.workflowOverlay?.prompt || session?.workflow || null;
+}
+
+const lower = (name) => String(name || '').toLowerCase();
+
+/** The refusal of a call to a tool the session's current workflow denies
+ *  while its schema (built for the prompt's workflow) still carries it; null
+ *  for any other call. */
+export function workflowOverlayDenial(session, name) {
+  const overlay = session?.workflowOverlay;
+  if (!overlay?.deniedTools?.some((denied) => lower(denied) === lower(name))) return null;
+  return `Error: tool "${name}" is not available in workflow ${overlay.workflow.name}: this conversation switched to it. Do the work without it.`;
+}
+
+const listed = (names) => names.map((name) => `\`${name}\``).join(', ');
+
+/** The reminder that makes the Lead follow `workflow` while its system prompt
+ *  still carries `promptName`'s: self-contained (rules, orchestration, agents,
+ *  tool changes) and superseding every earlier one. */
+export function workflowOverlayContent({
+  promptName,
+  workflow,
+  instructions,
+  deniedTools = [],
+  loadableTools = [],
+  unavailableTools = [],
+}) {
+  const name = workflow.name;
+  return [
+    '<system-reminder>',
+    '# Workflow Changed',
+    `This conversation now runs the ${name} workflow. The system prompt's Active Workflow, orchestration mode and available agents are still ${promptName}'s: they no longer apply; follow ${name}'s below instead. This replaces every earlier Workflow Changed reminder in this conversation.`,
+    ...(deniedTools.length ? [`Not available in ${name} (calls are refused): ${listed(deniedTools)}.`] : []),
+    ...(loadableTools.length
+      ? [
+          `${name} adds ${listed(loadableTools)}: not among your directly defined tools yet; load ${loadableTools.length === 1 ? 'it' : 'them'} with \`load_tool\` before the first call.`,
+        ]
+      : []),
+    ...(unavailableTools.length
+      ? [`${name} allows ${listed(unavailableTools)}, but this session cannot use them; a new session can.`]
+      : []),
+    `Agents already started under ${promptName} keep running with their own instructions; new delegation follows ${name}.`,
+    '',
+    instructions,
+    '</system-reminder>',
+  ].join('\n');
+}
+
+function messageText(message) {
+  if (typeof message?.content === 'string') return message.content;
+  if (!Array.isArray(message?.content)) return '';
+  return message.content.map((part) => (typeof part === 'string' ? part : part?.text || '')).join('');
+}
+
+/** The conversation still holds `content` (a delivered reminder); false once
+ *  a compaction or a clear dropped it. */
+export function conversationHolds(session, content) {
+  if (!content) return false;
+  return (Array.isArray(session?.messages) ? session.messages : []).some(
+    (message) => message?.role !== 'system' && messageText(message).includes(content)
+  );
+}
+
 /** Stage the notice of a switch from `from` to `to`; a switch back to what the
  *  model was last told drops it. Returns the staged state or null. */
 export function stageWorkflowSwitchNotice(session, from, to) {
@@ -29,13 +106,14 @@ export function stageWorkflowSwitchNotice(session, from, to) {
   return session.workflowSwitch;
 }
 
-function workflowNoticeContent({ from, to }) {
+// The prompt itself carries `to` (a switch back to it, or the overlay folded in).
+function promptWorkflowNoticeContent({ from, to }) {
   const before = from?.name || 'the previous workflow';
   return [
     '<system-reminder>',
     '# Workflow Changed',
-    `The workflow changed from ${before} to ${to.name}. Earlier turns of this conversation ran under ${before}; the system prompt was updated in place, so its Active Workflow rules, delegation instructions, available agents and tools are now those of ${to.name}. Follow them from this turn on.`,
-    `Agents already started under ${before} keep running with their own instructions; new delegation uses the current tools and agents.`,
+    `This conversation now runs the ${to.name} workflow, the one the system prompt carries: its Active Workflow, orchestration mode, available agents and tools apply. This replaces every earlier Workflow Changed reminder in this conversation.`,
+    `Agents already started under ${before} keep running with their own instructions; new delegation follows ${to.name}.`,
     '</system-reminder>',
   ].join('\n');
 }
@@ -47,7 +125,10 @@ function workflowNoticeContent({ from, to }) {
 export function snapshotPendingWorkflowNotice(session) {
   const pending = session?.workflowSwitch;
   if (!pending?.to?.id) return null;
-  return { revision: pending.revision, content: workflowNoticeContent(pending) };
+  const overlay = session.workflowOverlay;
+  const content =
+    overlay?.workflow?.id === pending.to.id && overlay.content ? overlay.content : promptWorkflowNoticeContent(pending);
+  return { revision: pending.revision, content };
 }
 
 /** The notice of `revision` reached the model: nothing is due any more. */

package/src/runtime/agent/orchestrator/session/mixy-name.mjs

@@ -4,8 +4,9 @@
 // use so a rename applies at once. Text shared across agents (tool schemas,
 // other agents' shared prompt block) says "the representative agent" instead,
 // so a rename never changes cached bytes.
-import { join } from 'node:path';
+import { dirname, join } from 'node:path';
 import { mixdogGlobalDir, readSafe } from '../context/skill-catalog.mjs';
+import { mixyIdentityDir } from '../../../shared/agent-store.mjs';
 
 export const DEFAULT_MIXY_NAME = 'Mixy';
 
@@ -17,7 +18,9 @@ export function mixyNameOf(manifest) {
 
 export function mixyDisplayName() {
   try {
-    return mixyNameOf(JSON.parse(readSafe(join(mixdogGlobalDir('agents'), 'lead', 'agent.json')) || '{}'));
+    // bots/mixy once Mixy is its own bot, agents/lead before (agent-store.mjs).
+    const dir = mixyIdentityDir(dirname(mixdogGlobalDir('agents')));
+    return mixyNameOf(JSON.parse(readSafe(join(dir, 'agent.json')) || '{}'));
   } catch {
     return DEFAULT_MIXY_NAME;
   }

package/src/runtime/agent/orchestrator/session/pre-send-compact.mjs

@@ -19,6 +19,7 @@ import {
 import { previewFreshContextCompaction, runFreshContextCompact } from './loop/fresh-context.mjs';
 import { estimateMessagesTokensSafe } from './loop/compact-debug.mjs';
 import { textPdfAllowanceDiscount } from './context-utils.mjs';
+import { referenceOversizedAttachments } from './attachment-preflight.mjs';
 import { providerNativePdf } from '../providers/registry.mjs';
 import { messagesArrayChanged } from './loop/tool-helpers.mjs';
 import { normalizeUsage, addUsage } from './loop/usage.mjs';
@@ -274,6 +275,9 @@ async function compactTranscript(ctx, run) {
     goalReminderText: run.inlineGoalReminder?.content || '',
     activeTurn: true,
     requireReduction: decision.requireReduction,
+    // The provider refused this request as too long: whatever the estimate
+    // said, the latest request's attachments now travel by reference.
+    referenceLatestAttachments: decision.compactTrigger === 'reactive',
   });
   const freshMessages = Array.isArray(run.freshContextResult?.messages) ? run.freshContextResult.messages : null;
   if (!freshMessages) throw new Error('fresh-context compact produced no messages');
@@ -290,6 +294,9 @@ function acknowledgeGoalReminder(sessionRef, run) {
   }
 }
 
+// Detection is narrow on purpose — signal.aborted or a true AbortError — so
+// the recall pipeline's SYNTHETIC "…aborted: memory … ; head preserved"
+// failure (a real compact failure, message text aside) still escalates.
 function isCompactAbort(signal, err) {
   return signal?.aborted === true || err?.name === 'AbortError' || err?.code === 'ABORT_ERR' || err?.code === 'ABORT';
 }
@@ -326,16 +333,6 @@ function reportCompactFailure(ctx, run, compactErr) {
   });
 }
 
-// A failed compact pass ends the send. A genuine cancellation/abort surfaced
-// from the compact pipeline is NOT a context overflow: the fresh-context
-// pipeline deliberately rethrows the original abort error unchanged so the
-// session records a clean cancellation — and the manual/auto-clear runner
-// (manager/compaction-runner.mjs) likewise never fabricates an
-// AGENT_CONTEXT_OVERFLOW for an aborted compact. Mirror that here: preserve
-// the real error (code/name/cause intact) instead of masking it as overflow.
-// Detection is narrow on purpose — signal.aborted or a true AbortError — so
-// the recall pipeline's SYNTHETIC "…aborted: memory … ; head preserved"
-// failure (a real compact failure, message text aside) still escalates.
 function isGenuineCompactOverflow(compactErr) {
   return (
     compactErr?.code === 'AGENT_CONTEXT_OVERFLOW' ||
@@ -362,6 +359,13 @@ function retryCompactQuietly(ctx, run, compactErr) {
   return true;
 }
 
+// A failed compact pass ends the send. A genuine cancellation/abort surfaced
+// from the compact pipeline is NOT a context overflow: the fresh-context
+// pipeline deliberately rethrows the original abort error unchanged so the
+// session records a clean cancellation — and the manual/auto-clear runner
+// (manager/compaction-runner.mjs) likewise never fabricates an
+// AGENT_CONTEXT_OVERFLOW for an aborted compact. Mirror that here: preserve
+// the real error (code/name/cause intact) instead of masking it as overflow.
 function throwCompactFailure(ctx, run, compactErr) {
   const { state, compactPolicy, decision } = ctx;
   const { sessionRef, sessionId, signal, model } = state;
@@ -555,6 +559,33 @@ async function compactBeforeSend(ctx) {
   await runCompactHook(ctx, 'postCompactHook');
 }
 
+// Attachments that would crowd the window travel by reference from this send
+// on (session/attachment-preflight.mjs). Runs whether or not auto-compaction
+// is on: it is what keeps an oversized attachment message from ever reaching
+// the provider. A rewrite changes the transcript the provider chain was built
+// on, so the continuation is dropped and the send is tagged exactly like an
+// automatic compaction: the prefix guard accepts that boundary, whereas a
+// transcript-repair tag would refuse the rewritten earlier message.
+function preflightAttachments(ctx, compactPolicy) {
+  const { state } = ctx;
+  const contextWindow = compactPolicy?.contextWindow || state.sessionRef?.contextWindow;
+  const outcome = referenceOversizedAttachments(state.messages, {
+    contextWindow,
+    nativePdf: providerNativePdf(state.sessionRef?.provider),
+  });
+  if (!outcome.changed) return;
+  ctx.providerState = undefined;
+  ctx.providerStateCleared = true;
+  ctx.compactChanged = true;
+  if (state.opts && !String(state.opts.cacheBreakIntent || '').endsWith('_compaction')) {
+    state.opts.cacheBreakIntent = 'automatic_compaction';
+  }
+  writeStderrBestEffort(
+    `[loop] attachments sent by reference (sess=${state.sessionId || 'unknown'}): ` +
+      `${outcome.referencedMessages} message(s), inline estimate ${outcome.inlineTokensBefore} > budget ${outcome.budgetTokens}\n`
+  );
+}
+
 export async function runPreSendCompactPass(state) {
   const ctx = {
     state,
@@ -567,6 +598,7 @@ export async function runPreSendCompactPass(state) {
     compactChanged: false,
   };
   const compactPolicy = resolveWorkerCompactPolicy(state.sessionRef, state.requestTools);
+  preflightAttachments(ctx, compactPolicy);
   if (compactPolicy?.auto) {
     ctx.compactPolicy = compactPolicy;
     ctx.decision = preSendCompactDecision(state, compactPolicy);

package/src/runtime/agent/orchestrator/session/provider-prefix-guard.mjs

@@ -1,5 +1,6 @@
 import { createHash } from 'node:crypto';
 import { hasPlainPrototype } from '../../../shared/object.mjs';
+import { withoutMessageIdsReplacer } from './message-ids.mjs';
 
 const COMPACTION_INTENTS = new Set([
   'automatic_compaction',
@@ -8,8 +9,8 @@ const COMPACTION_INTENTS = new Set([
   'post_turn_compaction',
 ]);
 
-function digest(value) {
-  const encoded = JSON.stringify(value);
+function digest(value, replacer) {
+  const encoded = JSON.stringify(value, replacer);
   if (typeof encoded !== 'string') {
     throw new TypeError('provider prefix value is not serializable');
   }
@@ -82,11 +83,28 @@ function matchShape(value, tokens, cursor) {
   return count === tokens[cursor + 1] ? next : -1;
 }
 
+// A message's digest covers what the provider can see of it. The stable
+// message id (`meta.transcript.messageId`, message-ids.mjs) is display
+// bookkeeping that is stamped onto live messages in place — a compaction pass
+// stamps every unstamped message before it runs, whatever it then decides —
+// and no provider request builder reads or sends it (the rest of `meta` is
+// not bookkeeping: `meta.source` and `meta.effortConfiguration` steer the
+// wire and stay in the digest). Hashing it would make a pass that changes
+// nothing look like a rewritten prefix on the next send.
+//
+// Only the message root's own `meta` is projected: a `meta` nested in content
+// (e.g. a structured tool result) is provider-visible and stays in the digest.
+function rootMessageIdsReplacer(message) {
+  return function replacer(key, value) {
+    return this === message ? withoutMessageIdsReplacer(key, value) : value;
+  };
+}
+
 function messageDigest(message) {
   if (message === null || typeof message !== 'object') return digest(message);
   const memo = messageDigestMemo.get(message);
   if (memo && matchShape(message, memo.tokens, 0) === memo.tokens.length) return memo.hash;
-  const hash = digest(message);
+  const hash = digest(message, rootMessageIdsReplacer(message));
   const tokens = [];
   if (recordShape(message, tokens)) messageDigestMemo.set(message, { hash, tokens });
   else messageDigestMemo.delete(message);

package/src/runtime/agent/orchestrator/session/routine-result.d.mts

@@ -8,8 +8,10 @@ export interface RoutineProvenance {
 
 export interface RoutineMessageMeta {
   source: string;
-  routine: Record<string, unknown>;
-  transcript: { at: number; messageId?: string };
+  /** A task report into a bot's home chat of a bot-to-bot send names the
+   *  answering bot in `agentId` (the target's home session owner). */
+  routine: Record<string, unknown> & { agentId?: string };
+  transcript: { at: number; messageId?: string; attachments?: unknown[] };
 }
 export interface RoutineMessage {
   role: 'user';
@@ -19,14 +21,26 @@ export interface RoutineMessage {
 export interface RoutineNotice {
   text: string;
   tone: 'info' | 'warn';
-  routine: Record<string, unknown>;
+  routine: Record<string, unknown> & { agentId?: string };
   /** Live run notices only (routineRunNotice). */
   messageId?: string;
+  /** A task report's stored files (handoff-artifacts.mjs). */
+  attachments?: Array<{
+    id: string;
+    attachmentRef: string;
+    kind: string;
+    name: string;
+    mimeType: string;
+    size: number;
+  }>;
 }
 
 export const ROUTINE_RESULT_SOURCE: 'schedule-result';
 export const TASK_LOOP_CAP: number;
 export function routineSummary(text: unknown): string;
+export const REPLY_LIMIT: number;
+export function boundedReply(text: unknown): { text: string; chars: number };
+export const WAKE_TEXT_BUDGET: number;
 export function routineResultMessage(options: {
   kind?: 'schedule' | 'webhook';
   name: string;
@@ -40,16 +54,33 @@ export function routineResultMessage(options: {
   messageId?: string;
 }): RoutineMessage;
 export function routineOmittedMessage(options: { count: number; at?: number; messageId?: string }): RoutineMessage;
+export function agentTaskRelayFailedMessage(options: {
+  count: number;
+  tries: number;
+  at?: number;
+  messageId?: string;
+}): RoutineMessage;
 export function agentTaskMessage(options: {
   title: string;
   status: string;
   text?: unknown;
+  /** Length of the whole reply when `text` is already a bounded part of it. */
+  textChars?: number;
+  /** The row's one-line summary, when made from the whole reply before `text` was bounded. */
+  summary?: string;
   taskSessionId: string;
+  /** 'session': any session other than a task session the agent created. */
+  target?: 'task' | 'session';
   round?: number;
+  /** false: the report was posted without waking the agent (round-trip cap). */
+  woken?: boolean;
+  /** The files the turn produced (handoff-artifacts.mjs). */
+  files?: ReadonlyArray<{ name: string; path: string; mimeType?: string; size?: number; kind?: string; id?: string }>;
+  omitted?: number;
   at?: number;
   messageId?: string;
 }): RoutineMessage;
-export function agentTaskWakePrompt(messages: ReadonlyArray<{ content: string }>): string;
+export function agentTaskWakePrompt(messages: ReadonlyArray<{ content: string }>, options?: { more?: number }): string;
 export function isRoutineResultMessage(message: unknown): boolean;
 export function normalizeRoutineProvenance(value: unknown): RoutineProvenance | null;
 export function routineProvenance(message: unknown): RoutineProvenance | null;