mixdog 1.4.0 → 1.4.2

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

@@ -12,6 +12,7 @@ import {
   textByteLength,
 } from './text-utils.mjs';
 import {
+  callArguments,
   contextAckMessage,
   isCompactConversationRow,
   isProtectedContextAckMessage,
@@ -25,6 +26,7 @@ import { activeTurnContinuationMessage } from './continuation.mjs';
 import { EXECUTION_RECOVERY_SOURCE, buildExecutionTail } from './execution-tail.mjs';
 import { latestSkillBodies, skillMessageText } from '../../context/skill-state.mjs';
 import { effectiveBudget } from './budget.mjs';
+import { parseMcpToolName } from '../../../../shared/tool-primitives.mjs';
 import { stripRuntimeUserContext, withRuntimeUserContext } from '../runtime-user-context.mjs';
 import { carryMessageId, messageIdOf } from '../message-ids.mjs';
 import { normalizeIngestRole, shouldExcludeIngestMessage } from '../../../../memory/lib/session-ingest.mjs';
@@ -70,12 +72,23 @@ function splitFreshSource(messages) {
       break;
     }
   }
+  // Where the previous Compact's skill-use window opens: `live` index after
+  // the history it kept (see SKILL_WINDOW_SOURCE). Without a marker the whole
+  // transcript is the window.
+  const isKept = (message) => !isSummaryMessage(message) && message?.meta?.source !== SKILL_WINDOW_SOURCE;
+  const markerAt = conversation.findLastIndex((message) => message?.meta?.source === SKILL_WINDOW_SOURCE);
+  const span = conversation[markerAt]?.meta?.span;
+  const skillWindowStart =
+    markerAt >= 0 && Number.isInteger(span) && span >= 0
+      ? conversation.slice(0, markerAt).filter(isKept).length + span
+      : 0;
   const latestUserIndex = latestActualUserInstructionIndex(conversation);
   return {
     protectedPrefix,
     previousSummary: previousSummaryMessage?.content || null,
     previousSummaryMessage,
     previousAck,
+    skillWindowStart,
     // Budgeting, AI input and rule-only retention use this same projection.
     // Keep current-turn reminders; remove only proven runtime additions from
     // older requests. Unmarked legacy text remains part of the summary budget.
@@ -86,7 +99,7 @@ function splitFreshSource(messages) {
       .map((message, index) =>
         index === latestUserIndex ? message : referenceMessageMedia(stripRuntimeUserContext(message))
       )
-      .filter((message) => !isSummaryMessage(message)),
+      .filter(isKept),
     sanitized,
   };
 }
@@ -135,9 +148,11 @@ function toolCallSummaryLine(call, result) {
   // 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.
+  // An ask_user or handoff_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);
+    call.name === 'ask_user' || call.name === 'handoff_user'
+      ? outcome
+      : boundedSummaryText(outcome.replace(/\s+/g, ' '), SUMMARY_TOOL_OUTCOME_CHARS);
   return `[tool call] ${call.name}(${args}) → ${result ? shown || '(empty result)' : '(no result)'}`;
 }
 
@@ -564,44 +579,128 @@ function currentSkillBodyMessage(message, current) {
 
 const SKILL_RELOAD_SOURCE = 'compact-skill-reload';
 
-function skillReloadReminder(name) {
+// How many Compacts in a row a skill may go unused before even its reload
+// line is dropped: a skill untouched that long belongs to finished work, and
+// the model can still load it by name from the skill manifest.
+export const SKILL_RELOAD_MAX_IDLE = 3;
+
+const SKILL_TOOL_NAMES = new Set(['Skill', 'skill_view']);
+
+function skillReloadReminder(name, idle = 0) {
   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 },
+    content: `[mixdog-runtime] Skill "${name}" was active earlier, but Compact did not keep its instructions. Reload it with the Skill tool before relying on them.`,
+    meta: { source: SKILL_RELOAD_SOURCE, synthetic: true, skill: name, idle },
   };
 }
 
-// Restore the skills active in the transcript, each as the Skill tool would
-// deliver it now. `currentSkill(name)` (the caller's resolver) answers
-// `{ body, native, summary }` for a skill that still loads in the session, or null for
-// one switched off, outside its scope or removed: such a skill is restored
-// neither as a body nor as a reload reminder, since its instructions are no
-// longer in force. Without a resolver the transcript copies are kept.
+// Every Compact leaves this marker just ahead of the skills it restores, with
+// `span`: how many messages follow it (restored skills and retained tail).
+// All of them happened before that Compact, so the next one reads the skill
+// use window from after them, whether or not a summary exists. The marker is
+// not conversation: the next Compact removes it and writes a new one.
+const SKILL_WINDOW_SOURCE = 'compact-skill-window';
+
+function skillWindowMarker(span = 0) {
+  return {
+    role: 'user',
+    content: '[mixdog-runtime] Compact boundary.',
+    meta: { source: SKILL_WINDOW_SOURCE, synthetic: true, span },
+  };
+}
+
+// Restore the skills the session used since the previous Compact, each as the
+// Skill tool would deliver it now. A skill is used when it was loaded or one of
+// its linked tools ran in that window (`windowStart` onward); its linked
+// tools are the native tool references of its loader pair and, when the
+// resolver gives them, `tools`. `currentSkill(name)` (the caller's resolver)
+// answers `{ body, native, summary, tools? }` for a skill that still loads in
+// the session, or null for one switched off, outside its scope or removed:
+// such a skill is restored neither as a body nor as a reload line, since its
+// instructions are no longer in force. Without a resolver the transcript
+// copies are kept.
 // Never summarize/truncate operating instructions or displace the handoff
-// 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, currentSkill = null) {
+// and current task. Every other active skill, and a used one whose body does
+// not fit, is left as a one-line reload line. The line counts the Compacts
+// the skill went unused (`meta.idle`) and is dropped past SKILL_RELOAD_MAX_IDLE.
+// Reload lines are charged to the same budget: every possible line is
+// reserved before any body is restored, and restoring a body releases its own.
+function restoreSkillBodies(live, skillBudget, retainedTail, currentSkill = null, windowStart = 0) {
   const retainedCallIds = new Set(retainedTail.filter((m) => m?.role === 'tool').map((m) => m.toolCallId));
   const current = (name) => (currentSkill ? currentSkill(name) : undefined);
   const loads = (name) => current(name) !== null;
   const transcriptBodies = latestSkillBodies(live);
   const loaded = new Set(transcriptBodies.map((body) => body.name));
   const bodies = transcriptBodies.filter((body) => loads(body.name));
-  const reload = live
-    .filter((m) => m?.meta?.source === SKILL_RELOAD_SOURCE && !loaded.has(m.meta.skill) && loads(m.meta.skill))
-    .map((m) => m.meta.skill);
-  const reminderCost = (name) => estimateMessagesTokens([skillReloadReminder(name)]);
-  let reserved = [...new Set([...reload, ...bodies.map((body) => body.name)])].reduce(
-    (sum, name) => sum + reminderCost(name),
-    0
-  );
-  const dropped = [];
+  // Reload lines from earlier Compacts: skill -> Compacts it went unused.
+  const earlier = new Map();
+  for (const m of live) {
+    if (m?.meta?.source !== SKILL_RELOAD_SOURCE || loaded.has(m.meta.skill) || !loads(m.meta.skill)) continue;
+    earlier.delete(m.meta.skill);
+    earlier.set(m.meta.skill, Number.isFinite(m.meta.idle) ? m.meta.idle : 0);
+  }
+
+  // A loader pair can sit anywhere in the transcript (a restored body stays
+  // ahead of the retained tail's pair), so read them all.
+  const results = new Map(live.filter((m) => m?.role === 'tool').map((m) => [m.toolCallId, m]));
+  const loaderTools = new Map();
+  for (const message of live) {
+    for (const call of message?.role === 'assistant' ? message.toolCalls || [] : []) {
+      const references = results.get(call.id)?.nativeToolSearch?.toolReferences;
+      if (call.name !== 'Skill' || !references) continue;
+      const name = String(callArguments(call).name || '').trim();
+      loaderTools.set(name, [...(loaderTools.get(name) || []), ...references]);
+    }
+  }
+  const skillsOfTool = new Map();
+  for (const name of new Set([...earlier.keys(), ...bodies.map((body) => body.name)])) {
+    const skill = current(name);
+    const tools = [...(skill?.native?.toolReferences || []), ...(skill?.tools || []), ...(loaderTools.get(name) || [])];
+    for (const tool of tools) skillsOfTool.set(tool, (skillsOfTool.get(tool) || new Set()).add(name));
+  }
+  // Use since the previous Compact (from `windowStart`): the newest transcript
+  // position of a load or of a linked tool's call.
+  const lastUse = new Map();
+  const noteUse = (name, index) => lastUse.set(name, Math.max(lastUse.get(name) ?? -1, index));
+  live.forEach((message, index) => {
+    if (index < windowStart || message?.role !== 'assistant') return;
+    for (const call of message.toolCalls || []) {
+      const args = callArguments(call);
+      if (SKILL_TOOL_NAMES.has(call.name)) noteUse(String(args.name || '').trim(), index);
+      else {
+        const tool = call.name === 'call_tool' ? args.name : call.name;
+        const mcpServer = `mcp:${parseMcpToolName(tool)?.server}`;
+        for (const name of [...(skillsOfTool.get(tool) || []), ...(skillsOfTool.get(mcpServer) || [])]) {
+          noteUse(name, index);
+        }
+      }
+    }
+  });
+  for (const { name, message } of bodies) {
+    const index = live.lastIndexOf(message);
+    if (index >= windowStart) noteUse(name, index);
+  }
+
+  // Every active skill without a body ends as a reload line: an unused one
+  // ages by a Compact and goes once past the bound; one used (or whose body
+  // did not fit) starts over.
+  const reminders = new Map();
+  for (const [name, idle] of earlier) {
+    if (lastUse.has(name)) reminders.set(name, 0);
+    else if (idle < SKILL_RELOAD_MAX_IDLE) reminders.set(name, idle + 1);
+  }
+  const used = bodies.filter(({ name }) => lastUse.has(name)).sort((a, b) => lastUse.get(b.name) - lastUse.get(a.name));
+  const unused = bodies.filter(({ name }) => !lastUse.has(name));
+
+  const reminderCost = (name, idle = 0) => estimateMessagesTokens([skillReloadReminder(name, idle)]);
+  let reserved =
+    [...reminders].reduce((sum, [name, idle]) => sum + reminderCost(name, idle), 0) +
+    unused.reduce((sum, { name }) => sum + reminderCost(name, 1), 0) +
+    used.reduce((sum, { name }) => sum + reminderCost(name), 0);
+  const dropped = new Set();
   const restoredSkills = [];
   let skillTokens = 0;
-  for (const { name, message } of bodies.reverse()) {
+  for (const { name, message } of used) {
     const skill = current(name);
     const restored = [
       ...skillLoaderPair(live, live.lastIndexOf(message), name, retainedCallIds, skill),
@@ -610,24 +709,31 @@ function restoreSkillBodies(live, skillBudget, retainedTail, currentSkill = null
     const cost = estimateMessagesTokens(restored);
     const own = reminderCost(name);
     if (skillTokens + cost + reserved - own > skillBudget) {
-      dropped.unshift(name);
+      dropped.add(name);
       continue;
     }
     restoredSkills.unshift(...restored);
     skillTokens += cost;
     reserved -= own;
   }
-  // Newest skill first; only a budget too small for the reminders themselves
+  // In transcript order, after the lines of earlier Compacts.
+  for (const { name } of bodies) {
+    if (!lastUse.has(name)) reminders.set(name, 1);
+    else if (dropped.has(name)) reminders.set(name, 0);
+  }
+  // Newest skill first; only a budget too small for the lines themselves
   // leaves one out.
-  const pending = [...new Set([...reload, ...dropped])];
+  const pending = [...reminders];
   const reminded = new Set();
-  for (const name of pending.toReversed()) {
-    const cost = reminderCost(name);
+  for (const [name, idle] of pending.toReversed()) {
+    const cost = reminderCost(name, idle);
     if (skillTokens + cost > skillBudget) continue;
     reminded.add(name);
     skillTokens += cost;
   }
-  restoredSkills.push(...pending.filter((name) => reminded.has(name)).map(skillReloadReminder));
+  restoredSkills.push(
+    ...pending.filter(([name]) => reminded.has(name)).map(([name, idle]) => skillReloadReminder(name, idle))
+  );
   return { restoredSkills, skillTokens };
 }
 
@@ -864,15 +970,33 @@ export function freshContextCompactMessages(messages, budgetTokens, options = {}
   const summaryContent = String(summaryMessage?.content || '');
   assertHandoffFits(summaryMessage, handoff.room);
   const skillBudget = freshSkillBudget(targetBudget, budget, [...stableHead, ...tail.volatileTail]);
+  // Restored skills carry the window marker, which is charged to their budget.
+  const markerCost = estimateMessagesTokens([skillWindowMarker()]);
   const skills = {
-    ...restoreSkillBodies(source.live, skillBudget, tail.volatileTail, opts.currentSkill),
+    ...restoreSkillBodies(
+      source.live,
+      Math.max(0, skillBudget - markerCost),
+      tail.volatileTail,
+      opts.currentSkill,
+      source.skillWindowStart
+    ),
     skillBudget,
   };
-  const stablePrefixMessages = [...stableHead, ...skills.restoredSkills];
-  const result = rebaseCompactedEffortConfiguration(
+  // A session with no skill state has no use to window: no marker.
+  const marker = skills.restoredSkills.length ? [skillWindowMarker()] : [];
+  const stablePrefixMessages = [...stableHead, ...marker, ...skills.restoredSkills];
+  const compacted = rebaseCompactedEffortConfiguration(
     baseSanitized,
     reconcileDedupStubs(sanitizeToolPairs([...stablePrefixMessages, ...tail.volatileTail]))
   );
+  // The next Compact reads everything after the marker as history, not as use.
+  const markerAt = compacted.findLastIndex((message) => message?.meta?.source === SKILL_WINDOW_SOURCE);
+  const result =
+    markerAt < 0
+      ? compacted
+      : compacted.map((message, index) =>
+          index === markerAt ? skillWindowMarker(compacted.length - markerAt - 1) : message
+        );
   const finalTokens = estimateMessagesTokens(result);
   if (finalTokens > budget) {
     throw new Error(`freshContextCompactMessages: compacted result exceeds budget=${budget} (result=${finalTokens})`);

package/src/runtime/agent/orchestrator/session/context-utils.mjs

@@ -581,8 +581,20 @@ function reasoningBreakdown(message, fullTextTokens) {
       };
     }
   }
+  // Price each reasoning item that is actually sent (a non-empty replay
+  // replaces content) at its own cost; the whole-minus-visible difference only
+  // caps the sum so the rows never exceed the total.
+  const sent = message.providerReplay?.items?.length ? message.providerReplay.items.filter(isReasoningBlock) : blocks;
   return {
-    tokens: blocks.length ? Math.max(0, fullTextTokens() - messageTextTokens(visible)) : 0,
+    tokens: blocks.length
+      ? Math.max(
+          0,
+          Math.min(
+            sent.reduce((sum, block) => sum + estimateTokens(nativeBlocksEstimateText(block)), 0),
+            fullTextTokens() - messageTextTokens(visible)
+          )
+        )
+      : 0,
     blocks,
     message: visible,
   };

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

@@ -3,12 +3,22 @@
  * import turns. The active branch is followed from the last main-chain entry
  * back through `parentUuid` (and `logicalParentUuid` across a compaction), so
  * replayed or abandoned branches never duplicate. Kept: text blocks and
- * `tool_use` as `[ran tool: <name>]` notes; images become an omission marker;
- * a compaction summary only when the history it replaced is no longer linked.
- * Dropped: sidechains, meta entries, tool results, thinking, signatures and
- * Claude Code's own command/notification envelopes.
+ * `tool_use` as tool notes; images become an omission marker; a compaction
+ * summary (as an assistant recap) only when the history it replaced is gone;
+ * a slash command as `/name args` unless the app answered it locally; pasted
+ * text without the app's paste envelope. Dropped: sidechains, meta entries,
+ * tool results, thinking, signatures and Claude Code's own
+ * command-output/notification envelopes.
  */
-import { IMAGE_OMITTED_TEXT, IMPORT_WARNING_IMAGE_OMITTED, isWholeElement, textPart, toolNote } from './turns.mjs';
+import {
+  IMAGE_OMITTED_TEXT,
+  IMPORT_WARNING_IMAGE_OMITTED,
+  isWholeElement,
+  stringOrNull,
+  textPart,
+  titleFromText,
+  toolNote,
+} from './turns.mjs';
 
 const CLAUDE_ENVELOPE_TAGS = [
   'local-command-stdout',
@@ -20,11 +30,54 @@ const CLAUDE_ENVELOPE_TAGS = [
   'bash-input',
   'bash-stdout',
   'bash-stderr',
+  // The app's own instructions behind its "create PR" action.
+  'create-pr-command',
 ];
-const SLASH_COMMAND_RE = /^(?:\s*<(command-name|command-message|command-args)>[\s\S]*?<\/\1>)+\s*$/;
+const LOCAL_OUTPUT_TAGS = ['local-command-stdout', 'local-command-stderr'];
+const SLASH_COMMAND_RE = /^(?:\s*<(command-name|command-message|command-args|skill-format)>[\s\S]*?<\/\1>)+\s*$/;
 const INTERRUPTED_RE = /^\[Request interrupted by user[^\]\n]*\]$/;
 // Claude Code's text annotation that accompanies a pasted image block.
 const IMAGE_ANNOTATION_RE = /^\[Image\b[^\n]*\]$/;
+// The desktop app's paste envelope: `<pasted_content id="hhhh">\n` body
+// `\n</pasted_content id="hhhh">`, one four-hex id on both tags.
+const PASTE_OPEN = '<pasted_content id="';
+const PASTE_ID_RE = /^[0-9a-f]{4}$/;
+
+/**
+ * Text with the app's paste envelopes unwrapped the way the app displays it:
+ * each paste body in place, the text around it trimmed toward it, pieces on
+ * their own lines. Only a complete envelope with a matching id is unwrapped; any
+ * other `<pasted_content…>` is the user's own text and stays as typed.
+ */
+export function unwrapClaudePastes(text) {
+  const pieces = [];
+  let cursor = 0;
+  let search = 0;
+  for (;;) {
+    const open = text.indexOf(PASTE_OPEN, search);
+    if (open < 0) break;
+    const idStart = open + PASTE_OPEN.length;
+    const id = text.slice(idStart, idStart + 4);
+    const bodyStart = idStart + 7; // past `hhhh">\n`
+    if (!PASTE_ID_RE.test(id) || text.slice(idStart + 4, bodyStart) !== '">\n') {
+      search = idStart;
+      continue;
+    }
+    const closeTag = `\n</pasted_content id="${id}">`;
+    // The line feed ending the open tag may also start the close tag (an empty paste).
+    const close = text.indexOf(closeTag, bodyStart - 1);
+    if (close < 0) break;
+    // Trimmed only toward a paste: the first fragment keeps its leading text.
+    const before = text.slice(cursor, open);
+    pieces.push(cursor ? before.trim() : before.trimEnd(), text.slice(bodyStart, Math.max(close, bodyStart)));
+    cursor = close + closeTag.length;
+    search = cursor;
+  }
+  if (!pieces.length) return text;
+  pieces.push(text.slice(cursor).trimStart());
+  const unwrapped = pieces.filter((piece, index) => index % 2 === 1 || piece).join('\n');
+  return unwrapped.trim() ? unwrapped : text;
+}
 
 export function isClaudeEnvelopeText(text) {
   const trimmed = String(text || '').trim();
@@ -37,8 +90,18 @@ export function isClaudeEnvelopeText(text) {
   );
 }
 
+const tagValue = (text, tag) => new RegExp(`<${tag}>([\\s\\S]*?)</${tag}>`).exec(text)?.[1].trim() || '';
+
+/** A slash-command envelope as Claude Code shows it (`/name args`), else null. */
+function claudeCommandText(text) {
+  const trimmed = String(text || '').trim();
+  if (!SLASH_COMMAND_RE.test(trimmed)) return null;
+  const name = (tagValue(trimmed, 'command-name') || tagValue(trimmed, 'command-message')).replace(/^\//, '');
+  if (!name) return null;
+  return [`/${name}`, tagValue(trimmed, 'command-args')].filter(Boolean).join(' ');
+}
+
 const isMessageEntry = (record) => record?.type === 'user' || record?.type === 'assistant';
-const stringOrNull = (value) => (typeof value === 'string' && value.trim() ? value.trim() : null);
 const uuidOrNull = (value) => (typeof value === 'string' ? value : null);
 const timestampOrNull = (value) => (typeof value === 'string' || typeof value === 'number' ? value : null);
 // Rough fixed cost of one retained entry object, so tiny entries still count.
@@ -49,42 +112,69 @@ const metadataLength = (entry) =>
   (entry.logicalParentUuid?.length || 0) +
   (typeof entry.at === 'string' ? entry.at.length : 0);
 
+// The main-chain message written last before file position `seq`: the leaf of
+// the history a compaction boundary replaced.
+function precedingMain(entries, seq) {
+  for (let index = seq - 1; index >= 0; index--) {
+    if (entries[index].main && entries[index].uuid !== null) return entries[index];
+  }
+  return null;
+}
+
 /**
  * The active branch, root first: walked back from the last main-chain entry.
- * `crossedCompaction` tells whether a compaction boundary led back into the
- * history it replaced (Claude Code often no longer keeps that history).
+ * A compaction boundary links back to the history it replaced through its
+ * logical parent, or, when Claude Code never wrote that message, to the last
+ * message before the boundary. `replaced` holds the compaction summaries whose
+ * history the walk crossed into (that history is imported instead).
  */
 function activeChain(entries) {
   const main = entries.filter((entry) => entry.main);
   const leaf = main[main.length - 1];
-  if (!leaf || leaf.uuid === null) return { chain: main, crossedCompaction: false };
+  if (!leaf || leaf.uuid === null) return { chain: main, replaced: new Set() };
   const byUuid = new Map();
   for (const entry of entries) {
     if (entry.uuid !== null) byUuid.set(entry.uuid, entry);
   }
   const chain = [];
   const seen = new Set();
-  let crossedCompaction = false;
+  const replaced = new Set();
+  let summary = null;
   let current = leaf;
   while (current && !seen.has(current.uuid)) {
     seen.add(current.uuid);
     chain.push(current);
+    if (current.summary) summary = current;
     const parent = current.parentUuid !== null ? byUuid.get(current.parentUuid) : null;
-    const logical = !parent && current.logicalParentUuid !== null ? byUuid.get(current.logicalParentUuid) : null;
-    if (logical) crossedCompaction = true;
+    const logical =
+      !parent && current.logicalParentUuid !== null
+        ? byUuid.get(current.logicalParentUuid) || precedingMain(entries, current.seq)
+        : null;
+    if (logical && summary) {
+      replaced.add(summary);
+      summary = null;
+    }
     current = parent || logical;
   }
-  return { chain: chain.reverse().filter((entry) => entry.main), crossedCompaction };
+  return { chain: chain.reverse().filter((entry) => entry.main), replaced };
 }
 
-function entryParts(role, content, warnings) {
+/** Kept parts of a message; a slash command is a `command` part, a local command's output marks `localOutput`. */
+function entryParts(role, content, warnings, marks) {
   const blocks = typeof content === 'string' ? [{ type: 'text', text: content }] : content;
   if (!Array.isArray(blocks)) return [];
   const parts = [];
   for (const block of blocks) {
     if (!block || typeof block !== 'object') continue;
     if (block.type === 'text' && typeof block.text === 'string') {
-      if (role === 'user' && isClaudeEnvelopeText(block.text)) continue;
+      if (role === 'user') {
+        const command = claudeCommandText(block.text);
+        if (command) parts.push({ ...textPart(command), command: true });
+        if (isWholeElement(block.text, LOCAL_OUTPUT_TAGS)) marks.localOutput = true;
+        if (isClaudeEnvelopeText(block.text)) continue;
+        parts.push(textPart(unwrapClaudePastes(block.text)));
+        continue;
+      }
       parts.push(textPart(block.text));
     } else if (block.type === 'image') {
       warnings.add(IMPORT_WARNING_IMAGE_OMITTED);
@@ -96,6 +186,31 @@ function entryParts(role, content, warnings) {
   return parts;
 }
 
+/**
+ * The title Claude Code's resume list shows from the records it appends to a
+ * transcript: the last `custom-title` (a `/rename`), else the last `ai-title`,
+ * then the last `summary`, then the last `last-prompt`. A blank custom title
+ * (a cleared rename) ends the name tier without falling back to the AI title.
+ * Other record types, such as `task-summary` or `agent-name`, never name it.
+ */
+function createClaudeTitleScan() {
+  let custom;
+  let ai;
+  let summary;
+  let lastPrompt;
+  return {
+    push(record) {
+      if (record.type === 'custom-title' && typeof record.customTitle === 'string') custom = record.customTitle;
+      else if (record.type === 'ai-title' && typeof record.aiTitle === 'string') ai = record.aiTitle;
+      else if (record.type === 'summary' && typeof record.summary === 'string') summary = record.summary;
+      else if (record.type === 'last-prompt' && typeof record.lastPrompt === 'string') lastPrompt = record.lastPrompt;
+    },
+    title() {
+      return titleFromText(custom ?? ai) || titleFromText(summary) || titleFromText(lastPrompt);
+    },
+  };
+}
+
 function skippedEntry(record) {
   // Claude Code flags its compaction summary transcript-only as well.
   if (record.isCompactSummary === true) return false;
@@ -111,9 +226,12 @@ function skippedEntry(record) {
  */
 export function createClaudeReducer() {
   const entries = [];
+  const titleScan = createClaudeTitleScan();
   let recognized = false;
   let foreignSessionId = null;
   let cwd = null;
+  let sidechainSeen = false;
+  let mainSeen = false;
   let chars = 0;
   let metadataBytes = 0;
   return {
@@ -126,10 +244,23 @@ export function createClaudeReducer() {
     get metadataBytes() {
       return metadataBytes;
     },
+    /** Cheap running check: messages seen so far are all sidechain (a verdict only at the end of the file). */
+    get sidechainOnly() {
+      return sidechainSeen && !mainSeen;
+    },
+    /** Feed a record for its stored title only (a transcript's tail window). */
+    pushTitle(record) {
+      titleScan.push(record);
+    },
     push(record) {
+      titleScan.push(record);
       const message = isMessageEntry(record);
       if (message) recognized = true;
       const main = message && record.isSidechain !== true;
+      if (message) {
+        if (main) mainSeen = true;
+        else sidechainSeen = true;
+      }
       if (main) {
         foreignSessionId ||= stringOrNull(record.sessionId);
         cwd ||= stringOrNull(record.cwd);
@@ -145,13 +276,14 @@ export function createClaudeReducer() {
         parts: null,
         warnings: null,
         at: timestampOrNull(record.timestamp),
+        seq: entries.length,
       };
       metadataBytes += ENTRY_OVERHEAD_BYTES + metadataLength(entry);
       if (main && !skippedEntry(record)) {
         const body = record.message && typeof record.message === 'object' ? record.message : null;
         entry.role = body?.role === 'user' || body?.role === 'assistant' ? body.role : record.type;
         const warnings = new Set();
-        entry.parts = entryParts(entry.role, body ? body.content : null, warnings);
+        entry.parts = entryParts(entry.role, body ? body.content : null, warnings, entry);
         if (record.isCompactSummary === true) {
           entry.summary = true;
           entry.parts = entry.parts.map((part) => ({ ...part, summary: true }));
@@ -164,15 +296,24 @@ export function createClaudeReducer() {
     result() {
       const warnings = new Set();
       const rawTurns = [];
-      const { chain, crossedCompaction } = activeChain(entries);
-      for (const entry of chain) {
+      const { chain, replaced } = activeChain(entries);
+      for (const [index, entry] of chain.entries()) {
         if (!entry.parts?.length) continue;
-        // The summary stands in for history only when that history is gone.
-        if (entry.summary && crossedCompaction) continue;
-        rawTurns.push({ role: entry.role, parts: entry.parts, at: entry.at });
+        // The summary stands in for history only when that history is gone,
+        // and then as the model's recap, never as something the user wrote.
+        if (entry.summary && replaced.has(entry)) continue;
+        const role = entry.summary ? 'assistant' : entry.role;
+        // A local command (`/model`, `/rename`…) answered by the app itself is not part of the conversation.
+        const local =
+          entry.parts.some((part) => part.command) &&
+          chain.slice(index + 1).find((next) => next.parts?.length || next.localOutput)?.localOutput;
+        const parts = local ? entry.parts.filter((part) => !part.command) : entry.parts;
+        rawTurns.push({ role, parts, at: entry.at });
         for (const code of entry.warnings || []) warnings.add(code);
       }
-      return { recognized, foreignSessionId, cwd, rawTurns, warnings };
+      // A transcript whose every message is a sidechain is a subagent's own, not a conversation.
+      const internalKind = this.sidechainOnly ? 'subagent' : null;
+      return { recognized, foreignSessionId, cwd, internalKind, rawTurns, warnings, storedTitle: titleScan.title() };
     },
   };
 }