mixdog 1.1.2 → 1.2.1

package/src/runtime/agent/orchestrator/session/conversation-import/convert.mjs

@@ -0,0 +1,128 @@
+/**
+ * JSONL lines of a foreign conversation → normalized plain-text turns, one
+ * line at a time: each parsed record is reduced to its kept plain text and
+ * dropped. Tolerates a BOM, CRLF line ends and individual malformed lines
+ * (reported as the `malformed` warning). Pure, no IO.
+ */
+import { createClaudeReducer } from './claude.mjs';
+import { createCodexReducer } from './codex.mjs';
+import { IMPORT_WARNING_MALFORMED, conversationTitle, normalizeTurns } from './turns.mjs';
+
+export const IMPORT_SOURCES = Object.freeze(['codex', 'claude']);
+/** A line or converted transcript beyond the import limits fails the file. */
+export const IMPORT_ERROR_TOO_LARGE = 'tooLarge';
+export const IMPORT_MAX_LINE_BYTES = 32 * 1024 * 1024;
+/** Bytes read from one source file before it fails as `tooLarge`. */
+export const IMPORT_MAX_FILE_BYTES = 256 * 1024 * 1024;
+/** Normalized transcript text (the final turns, separators and stub included). */
+export const IMPORT_MAX_TRANSCRIPT_CHARS = 4 * 1024 * 1024;
+/** Entries a reducer may retain (Claude chain links, Codex turns). */
+export const IMPORT_MAX_RETAINED_ENTRIES = 200_000;
+/** Bookkeeping a reducer retains besides kept text (ids, links, timestamps). */
+export const IMPORT_MAX_METADATA_BYTES = 16 * 1024 * 1024;
+
+export function isImportSource(value) {
+  return IMPORT_SOURCES.includes(value);
+}
+
+const transcriptChars = (turns) => turns.reduce((total, turn) => total + turn.text.length, 0);
+
+/**
+ * Incremental converter. `pushLine(line)` returns false once the conversion
+ * is over a limit (`tooLarge`): kept text over `maxTranscriptChars`, retained
+ * entries over `maxRetainedEntries` or their bookkeeping over
+ * `maxMetadataBytes`; `markTooLarge()` records a limit enforced by the reader
+ * (an over-long line or file). `result()` may be called repeatedly and also
+ * holds the normalized turns to `maxTranscriptChars`.
+ * `errorCode` is null for an importable result, else one of `empty` |
+ * `malformed` | `unsupported` | `tooLarge` (whose turns are not returned).
+ */
+export function createConversationConverter(
+  source,
+  {
+    maxTranscriptChars = IMPORT_MAX_TRANSCRIPT_CHARS,
+    maxRetainedEntries = IMPORT_MAX_RETAINED_ENTRIES,
+    maxMetadataBytes = IMPORT_MAX_METADATA_BYTES,
+  } = {}
+) {
+  if (!isImportSource(source)) throw new TypeError('source must be codex or claude.');
+  const reducer = source === 'codex' ? createCodexReducer() : createClaudeReducer();
+  let lines = 0;
+  let records = 0;
+  let malformed = 0;
+  let tooLarge = false;
+  return {
+    markTooLarge() {
+      tooLarge = true;
+    },
+    pushLine(raw) {
+      if (tooLarge) return false;
+      let line = String(raw);
+      if (lines++ === 0 && line.charCodeAt(0) === 0xfeff) line = line.slice(1);
+      if (line.endsWith('\r')) line = line.slice(0, -1);
+      if (!line.trim()) return true;
+      let value;
+      try {
+        value = JSON.parse(line);
+      } catch {
+        malformed += 1;
+        return true;
+      }
+      if (!value || typeof value !== 'object' || Array.isArray(value)) {
+        malformed += 1;
+        return true;
+      }
+      records += 1;
+      reducer.push(value);
+      if (
+        reducer.chars > maxTranscriptChars ||
+        reducer.entries > maxRetainedEntries ||
+        reducer.metadataBytes > maxMetadataBytes
+      ) {
+        tooLarge = true;
+      }
+      return !tooLarge;
+    },
+    result() {
+      const parsed = reducer.result();
+      const turns = normalizeTurns(parsed.rawTurns);
+      // Joins and the user stub add text the reducer never counted.
+      if (transcriptChars(turns) > maxTranscriptChars) tooLarge = true;
+      const warnings = new Set(parsed.warnings);
+      if (malformed) warnings.add(IMPORT_WARNING_MALFORMED);
+      let errorCode = null;
+      if (tooLarge) errorCode = IMPORT_ERROR_TOO_LARGE;
+      else if (!records) errorCode = malformed ? 'malformed' : 'empty';
+      else if (!parsed.recognized) errorCode = 'unsupported';
+      else if (!turns.length) errorCode = 'empty';
+      return {
+        source,
+        errorCode,
+        foreignSessionId: parsed.foreignSessionId,
+        cwd: parsed.cwd,
+        turns: tooLarge ? [] : turns,
+        title: conversationTitle(turns),
+        messageCount: tooLarge ? 0 : turns.length,
+        warnings: [...warnings],
+      };
+    },
+  };
+}
+
+/** Convert an in-memory JSONL body; `complete:false` drops a trailing partial line. */
+export function convertConversationText(source, text, { complete = true, ...limits } = {}) {
+  const converter = createConversationConverter(source, limits);
+  let body = String(text ?? '');
+  if (!complete) {
+    const end = body.lastIndexOf('\n');
+    body = end < 0 ? '' : body.slice(0, end);
+  }
+  let start = 0;
+  while (start < body.length) {
+    const newline = body.indexOf('\n', start);
+    const end = newline < 0 ? body.length : newline;
+    if (!converter.pushLine(body.slice(start, end))) break;
+    start = end + 1;
+  }
+  return converter.result();
+}

package/src/runtime/agent/orchestrator/session/conversation-import/imported-session.mjs

@@ -0,0 +1,127 @@
+/**
+ * Materialize an imported conversation as an ordinary Lead session: the normal
+ * createSession initialization (route, tools, context limits, cache config,
+ * system messages, BP3 fields) followed by the converted plain-text turns,
+ * with `importOrigin` provenance. Persisted durably before returning, then
+ * dropped from the same-process live cache.
+ */
+import { createSession } from '../manager/session-lifecycle.mjs';
+import { deleteSession, evictLiveSession, saveSessionAsync } from '../store.mjs';
+import { newTranscriptMessageId } from '../../../../shared/transcript-metadata.mjs';
+import { writeStderrBestEffort } from '../../../../shared/best-effort-stderr.mjs';
+import { IMPORTED_MESSAGE_SOURCE } from '../imported-message.mjs';
+import { ingestSessionTurn } from '../../../../session-search/session-search-ingest.mjs';
+
+export const IMPORT_ORIGIN_VERSION = 1;
+
+/** Dedupe identity: the foreign session id, else the canonical source path. */
+export function importOriginKey(source, foreignSessionId, canonicalPath) {
+  return foreignSessionId ? `${source}:${foreignSessionId}` : `${source}:path:${canonicalPath}`;
+}
+
+export function buildImportOrigin({ source, sourcePath, foreignSessionId = null, sourceCwd = null, importedAt }) {
+  return {
+    version: IMPORT_ORIGIN_VERSION,
+    source,
+    sourcePath,
+    foreignSessionId: foreignSessionId || null,
+    sourceCwd: sourceCwd || null,
+    importedAt,
+    key: importOriginKey(source, foreignSessionId, sourcePath),
+  };
+}
+
+// Lead identity every imported session carries (what a normal Lead session has).
+const LEAD_FIELDS = Object.freeze({ owner: 'cli', agent: 'lead', lane: 'cli', sourceType: 'lead', sourceName: 'main' });
+// Ownership, live binding and placement the importing runtime must not lend.
+const NOT_INHERITED = [
+  'id',
+  'parentSessionId',
+  'ownerSessionId',
+  'visibility',
+  'agentTag',
+  'taskType',
+  'permission',
+  'permissionMode',
+  'clientHostPid',
+  'mcpScopeId',
+  'approvalMode',
+  'scopeKey',
+  'cwd',
+  'desktopSession',
+];
+
+/** Lead createSession options → options of a fresh, unbound imported session. */
+export function importedSessionOptions(leadOptions, { cwd = null, desktopSession }) {
+  const options = { ...leadOptions };
+  for (const key of NOT_INHERITED) delete options[key];
+  Object.assign(options, LEAD_FIELDS);
+  if (cwd) options.cwd = cwd;
+  options.desktopSession = desktopSession;
+  return options;
+}
+
+/** Normalized turns → plain user/assistant transcript messages. `meta.source`
+ *  marks them imported prose: restore and the model wire never read their text
+ *  as runtime control content (reminders, task envelopes, summaries). */
+export function importedTranscriptMessages(turns, importedAt) {
+  return turns.map((turn) => ({
+    role: turn.role,
+    content: turn.text,
+    meta: {
+      source: IMPORTED_MESSAGE_SOURCE,
+      transcript: { messageId: newTranscriptMessageId(), at: turn.at || importedAt },
+    },
+  }));
+}
+
+const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+
+// createSession's own debounced save keeps the id pinned until it settles.
+async function evictWhenSettled(id, timeoutMs) {
+  const deadline = Date.now() + timeoutMs;
+  while (!evictLiveSession(id)) {
+    if (Date.now() >= deadline) return false;
+    await sleep(25);
+  }
+  return true;
+}
+
+/**
+ * Create, fill and persist one imported session. Save failures reject (the
+ * half-made record is removed); once saved it is handed to content-search
+ * ingestion (the same fire-and-forget ingest a finished turn gets) so it is
+ * searchable right away. The live-cache eviction afterwards is bookkeeping only.
+ */
+export async function createImportedSession({
+  leadOptions,
+  conversation,
+  origin,
+  cwd = null,
+  desktopSession,
+  createSessionFn = createSession,
+  ingestFn = ingestSessionTurn,
+  evictTimeoutMs = 5_000,
+}) {
+  const session = createSessionFn(importedSessionOptions(leadOptions, { cwd, desktopSession }));
+  try {
+    // Append after the system layer createSession seeded; never replace it.
+    session.messages.push(...importedTranscriptMessages(conversation.turns, origin.importedAt));
+    session.importOrigin = origin;
+    if (conversation.title) session.title = conversation.title;
+    session.updatedAt = Date.now();
+    await saveSessionAsync(session);
+  } catch (error) {
+    try {
+      deleteSession(session.id);
+    } catch (cleanupError) {
+      writeStderrBestEffort(
+        `[conversation-import] cleanup of ${session.id} failed: ${cleanupError?.message || cleanupError}\n`
+      );
+    }
+    throw error;
+  }
+  ingestFn(session);
+  await evictWhenSettled(session.id, evictTimeoutMs);
+  return session;
+}

package/src/runtime/agent/orchestrator/session/conversation-import/turns.mjs

@@ -0,0 +1,101 @@
+/**
+ * Shared shape of an imported conversation: plain-text user/assistant turns,
+ * the markers that stand in for dropped content, and the title rule. Codex and
+ * Claude Code parsers both emit raw turns `{ role, parts: [{ text, note }], at }`
+ * and normalize them here. Pure, leaf, no IO.
+ */
+
+/** Language-neutral warning codes attached to an imported conversation. */
+export const IMPORT_WARNING_IMAGE_OMITTED = 'imageOmitted';
+export const IMPORT_WARNING_MALFORMED = 'malformed';
+export const IMPORT_WARNING_CWD_MISSING = 'cwdMissing';
+
+/** Stands in for an image the importer does not carry over. */
+export const IMAGE_OMITTED_TEXT = '[image omitted]';
+/** Leads a conversation whose first kept turn is the assistant's. */
+export const IMPORTED_USER_STUB_TEXT = '[Imported conversation continues from an earlier assistant reply.]';
+
+const TITLE_MAX_CHARS = 100;
+
+/** Plain-text note for a tool call: its name only, never its arguments. */
+export function toolNote(name) {
+  const clean = String(name || '')
+    .replace(/\s+/g, ' ')
+    .trim();
+  return { text: `[ran tool: ${clean || 'unknown'}]`, note: true };
+}
+
+export function textPart(text) {
+  return { text: String(text), note: false };
+}
+
+/** Whole-text match of one XML-style envelope element (`<tag>…</tag>`). */
+export function isWholeElement(text, tags) {
+  const trimmed = String(text || '').trim();
+  return tags.some(
+    (tag) => (trimmed.startsWith(`<${tag}>`) || trimmed.startsWith(`<${tag} `)) && trimmed.endsWith(`</${tag}>`)
+  );
+}
+
+export function timestampMs(value) {
+  const ms = typeof value === 'number' ? value : Date.parse(String(value || ''));
+  return Number.isFinite(ms) && ms > 0 ? ms : null;
+}
+
+// Consecutive tool notes stay one per line; every other boundary is a blank line.
+function joinParts(parts) {
+  let text = '';
+  let previous = null;
+  for (const part of parts) {
+    const piece = String(part.text || '').trim();
+    if (!piece) continue;
+    if (previous) text += previous.note && part.note ? '\n' : '\n\n';
+    text += piece;
+    previous = part;
+  }
+  return { text, last: previous };
+}
+
+/**
+ * Raw turns → normalized turns `{ role, text, at, stub? }`: empty turns dropped,
+ * consecutive same-role turns merged, and a short user stub inserted when the
+ * conversation would otherwise begin with the assistant.
+ */
+export function normalizeTurns(rawTurns) {
+  const merged = [];
+  for (const raw of rawTurns) {
+    if (raw?.role !== 'user' && raw?.role !== 'assistant') continue;
+    const parts = (Array.isArray(raw.parts) ? raw.parts : []).filter((part) => String(part?.text || '').trim());
+    if (!parts.length) continue;
+    const previous = merged[merged.length - 1];
+    if (previous && previous.role === raw.role) previous.parts.push(...parts);
+    else merged.push({ role: raw.role, parts: [...parts], at: timestampMs(raw.at) });
+  }
+  const turns = merged.map(({ role, parts, at }) => {
+    const turn = { role, text: joinParts(parts).text, at };
+    // A carried-over compaction summary never names the conversation.
+    if (parts.some((part) => part.summary)) turn.titleText = joinParts(parts.filter((part) => !part.summary)).text;
+    return turn;
+  });
+  if (turns[0]?.role === 'assistant') {
+    turns.unshift({ role: 'user', text: IMPORTED_USER_STUB_TEXT, at: turns[0].at, stub: true });
+  }
+  return turns;
+}
+
+const titleLines = (turn) =>
+  (turn.titleText ?? turn.text)
+    .split('\n')
+    .map((value) => value.replace(/\s+/g, ' ').trim())
+    .filter(Boolean);
+
+/** First line of the first genuine user turn, whitespace-normalized, ≤100 chars
+ *  (an image marker only when the turn has no text line). */
+export function conversationTitle(turns) {
+  const first = turns.find((turn) => turn.role === 'user' && !turn.stub && titleLines(turn).length);
+  if (!first) return null;
+  const lines = titleLines(first);
+  const line = lines.find((value) => value !== IMAGE_OMITTED_TEXT) || lines[0];
+  if (!line) return null;
+  return Array.from(line).slice(0, TITLE_MAX_CHARS).join('').trim() || null;
+}

package/src/runtime/agent/orchestrator/session/explicit-skills.mjs

@@ -1,6 +1,10 @@
 import { randomUUID } from 'node:crypto';
 import { selectedSkillName } from '../../../shared/skill-selection.mjs';
+import { mentionedSkillNames, skillMentionCandidates } from '../../../shared/skill-mentions.mjs';
+import { isAttachmentReference } from '../../../attachments/store.mjs';
+import { collectPromptSkillsCached } from '../context/collect.mjs';
 import { executeTool } from './loop/tool-exec.mjs';
+import { preDispatchDenyForSession } from './loop/pre-dispatch-deny.mjs';
 import { parseNativeToolSearchPayload } from './loop/tool-helpers.mjs';
 import { normalizeToolEnvelope } from './tool-envelope.mjs';
 import { throwIfAborted } from '../../../shared/abort-race.mjs';
@@ -20,19 +24,91 @@ function nativeDefinitionsPresent(native, messages) {
   );
 }
 
+// At most this many skills are prepared for one user turn; further selections
+// stay prose.
+const MAX_EXPLICIT_SKILLS = 5;
+const LOADED_SKILL_RE = /^Loaded (?:built-in )?skill: /;
+
+// The user's own typed text: plain strings and text parts, never attachment
+// references (file contents the user attached, not words they typed).
+function userPromptText(prompt) {
+  if (typeof prompt === 'string') return prompt;
+  if (!Array.isArray(prompt)) return '';
+  return prompt
+    .map((part) => {
+      if (typeof part === 'string') return part;
+      if (part?.type === 'text' && typeof part.text === 'string' && !isAttachmentReference(part)) return part.text;
+      return '';
+    })
+    .join('\n');
+}
+
+/** The skills a prompt explicitly selects: the leading `Skill: "name"` header,
+ *  then every inline `$name`, each only when it names a skill enabled and in
+ *  scope for `cwd`, in first-mention order, deduplicated and capped. */
+export function explicitSkillNames(prompt, cwd) {
+  const header = selectedSkillName(prompt);
+  const text = userPromptText(prompt);
+  if (!header && !skillMentionCandidates(text).length) return [];
+  const available = new Set(collectPromptSkillsCached(cwd).map((skill) => skill.name));
+  const isSkill = (name) => available.has(name);
+  const names = header && isSkill(header) ? [header] : [];
+  for (const name of mentionedSkillNames(text, isSkill)) {
+    if (!names.includes(name)) names.push(name);
+  }
+  return names.slice(0, MAX_EXPLICIT_SKILLS);
+}
+
+/** Stamps the skills a user turn actually loaded on its transcript metadata,
+ *  where the live row, the persisted transcript and restore all read it.
+ *  The stamped message REPLACES `message` in `messages` (returned): the
+ *  session store ships reference-identical messages as an append-only delta,
+ *  so an in-place edit of a user message an earlier save already sent would
+ *  never reach disk. */
+export function recordAppliedSkills(messages, message, names) {
+  if (!message || !Array.isArray(names) || !names.length) return message;
+  const meta = message.meta && typeof message.meta === 'object' ? message.meta : {};
+  const transcript = meta.transcript && typeof meta.transcript === 'object' ? meta.transcript : {};
+  const stamped = { ...message, meta: { ...meta, transcript: { ...transcript, appliedSkills: [...names] } } };
+  const index = Array.isArray(messages) ? messages.indexOf(message) : -1;
+  if (index >= 0) messages[index] = stamped;
+  return stamped;
+}
+
+/** Tells the host which skills a user turn loaded; a host callback failure
+ *  never fails the turn. */
+export function notifySkillsApplied(onSkillsApplied, applied, message) {
+  if (!applied.length) return;
+  try {
+    onSkillsApplied?.(applied, { messageId: message?.meta?.transcript?.messageId || null });
+  } catch {
+    /* best-effort host callback */
+  }
+}
+
 // Called before the first model request for a real user turn. This performs the
 // same policy-checked Skill operation, without asking the model to request it.
 // Native schemas still travel as a properly paired loader execution, never as
-// new eager definitions or an orphan tool_search_output.
+// new eager definitions or an orphan tool_search_output. Returns the names of
+// the skills that loaded successfully, in selection order.
+// `selection`, when given (even empty), is the turn's TRUSTED selection input
+// and the only text skills are selected from: a host whose model-visible
+// prompt carries external data (webhook payloads) passes just the
+// operator-authored part, so nothing inside the data can load a skill.
 export async function prepareExplicitSkills(
   prompt,
   messages,
   session,
-  { cwd = session?.cwd, signal, execute = executeTool } = {}
+  { cwd = session?.cwd, signal, execute = executeTool, selection } = {}
 ) {
   throwIfAborted(signal);
-  const name = selectedSkillName(prompt);
-  if (name) {
+  const applied = [];
+  // A session that cannot call Skill (schema allowlist, denied tools, read-only
+  // surface — the dispatcher's own gate) has nothing to select: preparing would
+  // only push a refused-tool reminder into history on every matching turn.
+  if (preDispatchDenyForSession(session, { name: 'Skill' })) return applied;
+  const source = selection === undefined || selection === null ? prompt : selection;
+  for (const name of explicitSkillNames(source, cwd)) {
     const id = `skill-selection-${randomUUID()}`;
     const args = { name };
     const raw = await execute('Skill', args, cwd, session?.id, session, { signal, toolCallId: id });
@@ -55,6 +131,8 @@ export async function prepareExplicitSkills(
       });
     }
     messages.push(...envelope.newMessages);
+    if (LOADED_SKILL_RE.test(String(summary))) applied.push(name);
+    throwIfAborted(signal);
   }
-  throwIfAborted(signal);
+  return applied;
 }

package/src/runtime/agent/orchestrator/session/imported-message.mjs

@@ -0,0 +1,11 @@
+/**
+ * Provenance of messages carried over from another app's conversation
+ * (conversation-import). Their text is prose someone wrote elsewhere: it may
+ * look like a runtime reminder, a task envelope or a compaction summary, but
+ * restore and the model wire treat it as plain user/assistant text. Leaf, no IO.
+ */
+export const IMPORTED_MESSAGE_SOURCE = 'import';
+
+export function isImportedMessage(message) {
+  return message?.meta?.source === IMPORTED_MESSAGE_SOURCE;
+}

package/src/runtime/agent/orchestrator/session/loop/completion-guards.mjs

@@ -2,6 +2,7 @@
 // (signature + stub) and the edit-progress classification.
 // Pure string/signature helpers; the loop body only wires state + messages.
 // No provider/manager coupling.
+import { knownMcpToolIdentity } from '../../../../shared/tool-primitives.mjs';
 
 // Deterministic, key-sorted stringify for cross-turn call signatures (recursive,
 // unlike tool-classify's top-level-only _canonicalArgs).
@@ -43,7 +44,7 @@ const NON_PROGRESS_TOOLS = new Set(['Skill', 'recall', 'agent', 'task', 'cwd', '
 // not in the meta/non-progress set. apply_patch and shell/bash always count.
 export function isEditProgressTool(name, isEager) {
   if (isEager) return false;
-  const bare = name?.startsWith('mcp__') ? name.split('__').pop() : name;
+  const bare = name?.startsWith('mcp__') ? knownMcpToolIdentity(name)?.tool || name.split('__').pop() : name;
   if (bare === 'apply_patch' || bare === 'shell' || bare === 'bash' || bare === 'bash_session') return true;
   return !NON_PROGRESS_TOOLS.has(bare);
 }

package/src/runtime/agent/orchestrator/session/loop/loop-state.mjs

@@ -146,7 +146,7 @@ export function createLoopState({ provider, messages, model, tools, cwd, sendOpt
     messages,
     opts,
     sessionId,
-    onSkillPrompt: (content) => state.pendingSkillPrompts.push(content),
+    onSkillPrompt: (content, message) => state.pendingSkillPrompts.push({ content, message }),
   });
   // Bounded recovery for provider turns that returned no client tool calls
   // (max-output ladder, refusal retry, provider continuation, empty-turn

package/src/runtime/agent/orchestrator/session/loop/no-tool-turn/continuation.mjs

@@ -34,7 +34,7 @@ export function resumeContinuation(
     return false;
   }
   if (!segments.commitIntermediate(response)) return false;
-  if (hasContent) segments.record(response.content);
+  if (hasContent) segments.record(response.content, { committed: true });
   state.providerContinuationCount += 1;
   state.continuationsSinceToolBatch += 1;
   state.emptyNudgeStreak = 0;

package/src/runtime/agent/orchestrator/session/loop/no-tool-turn/diagnostic.mjs

@@ -1,8 +1,2 @@
 // stderr diagnostics for the no-tool recovery ladders; never throws.
-export function writeLoopDiagnostic(line) {
-  try {
-    process.stderr.write(line);
-  } catch {
-    /* diagnostics only */
-  }
-}
+export { writeStderrBestEffort as writeLoopDiagnostic } from '../../../../../shared/best-effort-stderr.mjs';

package/src/runtime/agent/orchestrator/session/loop/no-tool-turn/refusal.mjs

@@ -15,7 +15,7 @@ export function resolveRefusal(response, hasContent, { state, segments, messages
   // A provider may emit harmless narration before its safety classifier
   // terminates the turn. Preserve that partial turn and its stop reason,
   // but never mistake the non-empty text for a successful completion.
-  if (hasContent && segments.commitIntermediate(response)) segments.record(response.content);
+  if (hasContent && segments.commitIntermediate(response)) segments.record(response.content, { committed: true });
   messages.push({
     role: 'user',
     content: REFUSAL_RECOVERY_PROMPT,

package/src/runtime/agent/orchestrator/session/loop/no-tool-turn/segments.mjs

@@ -21,14 +21,15 @@ export function createTurnSegments({ messages, opts, suppressMidTurnText }) {
     // live. A suppressed sub-agent session neither surfaces nor accumulates
     // text — except on the max-output ladder, whose parts must still rebuild
     // the complete answer the caller receives (keepWhenSuppressed).
-    record(text, { keepWhenSuppressed = false } = {}) {
+    // `committed: true` marks text that is the just-committed message's own.
+    record(text, { keepWhenSuppressed = false, committed = false } = {}) {
       if (suppressMidTurnText) {
         if (keepWhenSuppressed) parts.push(text);
         return;
       }
       parts.push(text);
       try {
-        opts.onAssistantText?.(text);
+        opts.onAssistantText?.(text, { committed });
       } catch {
         /* best-effort */
       }

package/src/runtime/agent/orchestrator/session/loop/no-tool-turn.mjs

@@ -34,8 +34,9 @@ export function createNoToolTurnResolver({
     refusalRetryUsed: false,
     emptyNudgeStreak: 0,
     // Structured provider continuation signals honored this turn. Diagnostic
-    // only; the hard iteration cap remains the sole bound on how long a
-    // provider may keep declaring "not done" inside one user turn.
+    // only: the loop has no iteration cap, so this count bounds nothing. A
+    // text-only continuation runaway is bounded by continuationsSinceToolBatch
+    // below; continuations interleaved with tool batches are not limited.
     providerContinuationCount: 0,
     // Continuations since the last executed tool batch — bounds the text-only
     // continuation runaway (see PROVIDER_CONTINUATION_NO_TOOL_LIMIT).
@@ -108,7 +109,8 @@ export function createNoToolTurnResolver({
         drainSteering('terminal', {
           maxPriority: 'next',
           beforeAppend: () => {
-            if (segments.commitIntermediate(response) && hasContent) segments.record(response.content);
+            if (segments.commitIntermediate(response) && hasContent)
+              segments.record(response.content, { committed: true });
           },
         })
       ) {

package/src/runtime/agent/orchestrator/session/loop/send-phase.mjs

@@ -5,7 +5,7 @@
  */
 import { traceCacheBreak } from '../../cache-break-trace.mjs';
 import { resolveLiveToolCwd } from './tool-exec.mjs';
-import { prepareExplicitSkills } from '../explicit-skills.mjs';
+import { notifySkillsApplied, prepareExplicitSkills, recordAppliedSkills } from '../explicit-skills.mjs';
 import { addUsage, usageDeltaEvent } from './usage.mjs';
 import { prepareProviderRequest } from './request-boundary.mjs';
 import { projectProviderRequest } from './request-projection.mjs';
@@ -44,10 +44,13 @@ export async function beginIteration(state) {
   // policy-checked selection before the next provider snapshot instead of
   // starting detached work from a drain callback.
   while (state.pendingSkillPrompts.length) {
-    await prepareExplicitSkills(state.pendingSkillPrompts.shift(), messages, sessionRef, {
+    const { content, message: queued } = state.pendingSkillPrompts.shift();
+    const applied = await prepareExplicitSkills(content, messages, sessionRef, {
       cwd: state.cwd,
       signal: opts.signal,
     });
+    const message = recordAppliedSkills(messages, queued, applied);
+    notifySkillsApplied(opts.onSkillsApplied, applied, message);
   }
   const boundary = await prepareProviderRequest({
     provider,
@@ -263,8 +266,7 @@ function traceActualCacheMiss(state, sent, response, { previousGuardState, previ
   const ttlMs = MESSAGES_CACHE_TTL_MS[sessionRef.providerCacheOpts?.cacheStrategy?.messages];
   const idleMs = sent.sendStartedAt - previousSendAt;
   const requestPrefixChanged =
-    !!previousGuardState &&
-    previousGuardState.requestPrefixHash !== sent.prefixGuardCandidate?.requestPrefixHash;
+    !!previousGuardState && previousGuardState.requestPrefixHash !== sent.prefixGuardCandidate?.requestPrefixHash;
   if (
     baseline > 0 &&
     ttlMs &&
@@ -375,6 +377,7 @@ export function settleSendResult(state, round, sent) {
             model: response.model || model,
             usage: reportedUsage,
             sendTools: round.sendTools,
+            toolCalls: response.toolCalls?.length || 0,
           })
         )
       );