mixdog 1.2.2 → 1.2.4

package/src/runtime/shared/tool-card-model/generic-detail.mjs

@@ -51,6 +51,34 @@ export function genericCompletedDetail({ normalizedName, label, hasResult, first
   return '';
 }
 
+const uniqueToolNames = (names) => [
+  ...new Set((Array.isArray(names) ? names : []).map((name) => String(name || '').trim()).filter(Boolean)),
+];
+
+/**
+ * What a bridge load_tool result described, missed and blocked; null for a
+ * loader result (or anything that is not a describe result).
+ */
+export function bridgeDescribeResult(resultText) {
+  let parsed;
+  try {
+    parsed = JSON.parse(String(resultText || ''));
+  } catch {
+    return null;
+  }
+  if (!Array.isArray(parsed?.entries)) return null;
+  return {
+    described: uniqueToolNames(parsed.entries.map((entry) => entry?.name)),
+    missing: uniqueToolNames(parsed.missing),
+    blocked: uniqueToolNames((Array.isArray(parsed.blocked) ? parsed.blocked : []).map((entry) => entry?.name)),
+  };
+}
+
+/** Names a bridge load_tool result described, or null for a loader result. */
+export function bridgeDescribedToolNames(resultText) {
+  return bridgeDescribeResult(resultText)?.described ?? null;
+}
+
 export function toolSearchLoadedSummary(resultText) {
   let parsed;
   try {
@@ -61,13 +89,19 @@ export function toolSearchLoadedSummary(resultText) {
     const already = /^Already active:\s*(.+)$/m.exec(text)?.[1] || '';
     return [...(loaded ? [`Loaded: ${loaded}`] : []), ...(already ? [`Already active: ${already}`] : [])].join(' · ');
   }
+  // Bridge describe result: nothing was loaded; report what was not described.
+  const describe = bridgeDescribeResult(resultText);
+  if (describe) {
+    const { missing, blocked } = describe;
+    return [
+      ...(missing.length ? [`Missing: ${missing.join(', ')}`] : []),
+      ...(blocked.length ? [`Blocked: ${blocked.join(', ')}`] : []),
+    ].join(' · ');
+  }
   const tools = parsed?.selected?.tools;
   if (!tools || typeof tools !== 'object') return '';
-  const uniqueNames = (names) => [
-    ...new Set((Array.isArray(names) ? names : []).map((name) => String(name || '').trim()).filter(Boolean)),
-  ];
-  const loaded = uniqueNames(tools.added);
-  const already = uniqueNames(tools.already);
+  const loaded = uniqueToolNames(tools.added);
+  const already = uniqueToolNames(tools.already);
   return [
     ...(loaded.length ? [`Loaded: ${loaded.join(', ')}`] : []),
     ...(already.length ? [`Already active: ${already.join(', ')}`] : []),

package/src/runtime/shared/tool-card-model.mjs

@@ -23,7 +23,7 @@
  *   tool-card-model/card-header.mjs      — header label + arg summary
  */
 import { formatToolSurface } from './tool-surface.mjs';
-import { pluralize } from './tool-primitives.mjs';
+import { pluralize, toolCallDisplayIdentity } from './tool-primitives.mjs';
 import { deriveAggregateCardModel } from './tool-card-model/aggregate-card.mjs';
 import { isShellTool } from './tool-card-model/shell-surface.mjs';
 import { SKILL_SURFACE_NAMES } from './tool-card-model/agent-surface.mjs';
@@ -77,6 +77,7 @@ export {
   resolveBackgroundTaskMeta,
 } from './tool-card-model/background-task.mjs';
 export {
+  bridgeDescribeResult,
   genericCompletedDetail,
   shouldPrefixSyncElapsed,
   toolSearchLoadedSummary,
@@ -95,7 +96,8 @@ export { pluralize as plural };
  * @param {object} options { truncate(text,width), maxResultChars }.
  */
 export function deriveToolCardModel(input = {}, options = {}) {
-  const base = readCardInput(input, options);
+  const identity = toolCallDisplayIdentity(input.name, input.args);
+  const base = readCardInput({ ...input, name: identity.name, args: identity.args }, options);
   if (base.aggregate) return deriveAggregateCardModel(base);
 
   const { label, summary, normalizedName, args: parsedArgs } = formatToolSurface(base.name, base.args);
@@ -115,6 +117,7 @@ export function deriveToolCardModel(input = {}, options = {}) {
   return {
     aggregate: false,
     ...commonCardFields(base, status.terminalStatus),
+    ...(identity.via ? { via: identity.via } : {}),
     labelText: header.labelText,
     summaryText: header.summaryText,
     headerFailureText: status.headerFailureText,

package/src/runtime/shared/tool-output-budget.mjs

@@ -0,0 +1,2 @@
+export const TOOL_OUTPUT_PAGE_BYTES = 8 * 1024;
+export const TOOL_OUTPUT_TAIL_BYTES = 12 * 1024;

package/src/runtime/shared/tool-output-limit.mjs

@@ -22,6 +22,10 @@ export const RECALL_OUTPUT_MAX_BYTES = positiveEnvInt('MIXDOG_RECALL_OUTPUT_MAX_
 // github results after field reduction; the full response stays in a raw
 // artifact. Provisional: reduced pr.list/run.list pages measured ~2k tokens.
 export const GITHUB_OUTPUT_MAX_BYTES = positiveEnvInt('MIXDOG_GITHUB_OUTPUT_MAX_BYTES', 10 * 1024);
+// setup results are compact JSON (a provider index, a 25-row model page, minimal
+// status rows). The same figure is the setup inline-offload threshold, so one
+// result can no longer sit just under the 50KB default (a 34-model catalog did).
+export const SETUP_OUTPUT_MAX_BYTES = positiveEnvInt('MIXDOG_SETUP_OUTPUT_MAX_BYTES', 20 * 1024);
 
 function _prefixByBytes(value, maxBytes) {
   const text = String(value || '');

package/src/runtime/shared/tool-primitives.mjs

@@ -133,6 +133,19 @@ export function parseToolArgs(args) {
   return { value: args };
 }
 
+/**
+ * Display identity of a tool call. A call_tool bridge request shows the tool
+ * it runs, with `via: 'call_tool'`; the transcript keeps the wire call.
+ */
+export function toolCallDisplayIdentity(name, args) {
+  if (rawToolName(name) !== 'call_tool') return { name, args };
+  const parsed = parseToolArgs(args);
+  const target = typeof parsed?.name === 'string' ? parsed.name.trim() : '';
+  if (!target) return { name, args };
+  const targetArgs = parsed.arguments && typeof parsed.arguments === 'object' ? parsed.arguments : {};
+  return { name: target, args: targetArgs, via: 'call_tool' };
+}
+
 export function displayToolPath(path) {
   const text = String(path ?? '');
   return text.replace(/\\/g, '/').split('/').filter(Boolean).at(-1) || text;

package/src/runtime/shared/tool-result-summary.mjs

@@ -640,8 +640,28 @@ function summarizeAgentResult({ text, trimmed, translate }) {
 
 const summarizeGeneric = ({ text, translate }) => summarizeGenericResult(text, translate);
 
+const summarizeAskUserResult = ({ text, translate }) => {
+  // A composer message answered: `User replied in chat: "<json>". ` then the
+  // picks sentence or only the closing one. Summarized as the reply itself.
+  const replied = /^User replied in chat: ("(?:[^"\\]|\\.)*")\. /s.exec(String(text ?? '').trim());
+  if (replied) {
+    let reply = '';
+    try {
+      reply = String(JSON.parse(replied[1]));
+    } catch {}
+    const label = translate('Answered in chat', 'Answered in chat', {});
+    return truncateSingleLine(reply ? `${label}: ${reply}` : label, AGENT_SURFACE_BRIEF_MAX);
+  }
+  const answers =
+    /^User has answered your questions:\s*(.*?)(?:\s*You can now continue with these answers in mind\.)?$/s.exec(
+      String(text ?? '').trim()
+    );
+  return truncateSingleLine(answers ? answers[1] : String(text ?? '').trim(), AGENT_SURFACE_BRIEF_MAX) || null;
+};
+
 const TOOL_RESULT_SUMMARIZERS = new Map(
   [
+    [['ask_user'], summarizeAskUserResult],
     [['read', 'view_image', 'read_mcp_resource'], summarizeReadResult],
     [['apply_patch'], summarizePatchResult],
     [['grep'], summarizeGrepResult],
@@ -662,7 +682,8 @@ const TOOL_RESULT_SUMMARIZERS = new Map(
         'update_memory',
         'request_user_input',
         'update_plan',
-        'cwd',
+        'cwd', // legacy: old transcripts
+        'session',
         'list_mcp_resources',
         'list_mcp_resource_templates',
       ],

package/src/runtime/shared/tool-status.mjs

@@ -49,9 +49,10 @@ export function isUserControlCancellation(text) {
 }
 
 // A non-zero exit the tool itself marked as a signal (search no-match, a
-// `git diff --exit-code` difference) rather than a command failure.
+// `git diff --exit-code` difference, a `git merge-tree` conflict report) rather
+// than a command failure.
 export function hasBenignExitOutcome(text) {
-  return /^\[outcome:\s*(?:no-match|no-change)\]\s*$/im.test(String(text || ''));
+  return /^\[outcome:\s*(?:no-match|no-change|conflicts)\]\s*$/im.test(String(text || ''));
 }
 
 // The status a task/bridge envelope reports in its leading block. A `<status>`

package/src/runtime/shared/tool-surface.mjs

@@ -144,11 +144,14 @@ export function displayToolName(name, args = {}) {
       return 'Visualize';
     case 'list_mcp_resources':
     case 'list_mcp_resource_templates':
-    case 'cwd':
+    case 'cwd': // legacy: old transcripts
+    case 'session':
     case 'setup':
       return 'Setup';
     case 'request_user_input':
       return 'Ask User';
+    case 'ask_user':
+      return 'Question';
     case 'update_plan':
       return 'Plan';
     case 'memory':
@@ -236,6 +239,14 @@ export function summarizeToolArgs(name, args, { max = DEFAULT_SUMMARY_MAX } = {}
       return summarizeGithub(a, max);
     case 'goal':
       return compactParts([String(a.action || ''), truncateToolText(a.objective, max)]);
+    case 'ask_user':
+      return truncateToolText(
+        (Array.isArray(a.questions) ? a.questions : [])
+          .map((q) => String(q?.header || q?.question || '').trim())
+          .filter(Boolean)
+          .join(', '),
+        max
+      );
     case 'list':
     case 'ls':
       if (Array.isArray(a.path) || Array.isArray(a.dir) || Array.isArray(a.cwd)) {
@@ -333,8 +344,12 @@ export function summarizeToolArgs(name, args, { max = DEFAULT_SUMMARY_MAX } = {}
     case 'list_mcp_resources':
     case 'list_mcp_resource_templates':
       return a.server ? `server "${truncateToolText(a.server, max)}"` : 'all servers';
-    case 'cwd':
-      return compactParts([String(a.action || a.type || ''), truncateToolText(firstText(a.path, a.cwd, a.dir), max)]);
+    case 'cwd': // legacy: old transcripts
+    case 'session':
+      return compactParts([
+        String(a.action || a.type || ''),
+        truncateToolText(firstText(a.title, a.path, a.cwd, a.dir), max),
+      ]);
     case 'setup':
       return compactParts([
         String(a.action || ''),
@@ -437,9 +452,8 @@ function summarizeGithub(a, max) {
   const id = a.number ?? a.id;
   const hasId = id != null && String(id).trim() !== '';
   const title = truncateToolText(firstText(a.title, a.workflow, a.tag), Math.min(max, 60));
-  return hasId
-    ? compactParts([`${phrase} ${String(id).trim()}`, repo, title])
-    : compactParts([repo ? `${phrase} ${repo}` : phrase, title]);
+  if (hasId) return compactParts([`${phrase} ${String(id).trim()}`, repo, title]);
+  return compactParts([repo ? `${phrase} ${repo}` : phrase, title]);
 }
 
 export function formatToolSurface(name, args, opts = {}) {

package/src/runtime/shared/tool-work-units.mjs

@@ -85,10 +85,12 @@ const TOOL_CATEGORY = new Map([
   ['visualize', 'Visualize'],
   ['list_mcp_resources', 'Setup'],
   ['list_mcp_resource_templates', 'Setup'],
-  ['cwd', 'Setup'],
+  ['cwd', 'Setup'], // legacy: old transcripts
+  ['session', 'Setup'],
   ['setup', 'Setup'],
   ['goal', 'Setup'],
   ['request_user_input', 'Setup'],
+  ['ask_user', 'Setup'],
   ['update_plan', 'Setup'],
   ['skill', 'Skill'],
   ['skill_execute', 'Skill'],
@@ -342,12 +344,18 @@ function officeUnit(a) {
 
 function visualizeUnit(a) {
   const action = String(a.action || '').toLowerCase();
-  if (action === 'capture') return unitDescriptor('Visualize', { count: 1, active: 'Capturing', done: 'Captured', noun: 'screenshot' });
-  if (action === 'export') return unitDescriptor('Visualize', { count: 1, active: 'Exporting', done: 'Exported', noun: 'file' });
-  if (action === 'annotate') return unitDescriptor('Visualize', { count: 1, active: 'Marking', done: 'Marked', noun: 'annotation' });
-  if (action === 'check') return unitDescriptor('Visualize', { count: 1, active: 'Checking', done: 'Checked', noun: 'page' });
-  if (action === 'inspect') return unitDescriptor('Visualize', { count: 1, active: 'Inspecting', done: 'Inspected', noun: 'page' });
-  if (action === 'close') return unitDescriptor('Visualize', { count: 1, active: 'Closing', done: 'Closed', noun: 'tab' });
+  if (action === 'capture')
+    return unitDescriptor('Visualize', { count: 1, active: 'Capturing', done: 'Captured', noun: 'screenshot' });
+  if (action === 'export')
+    return unitDescriptor('Visualize', { count: 1, active: 'Exporting', done: 'Exported', noun: 'file' });
+  if (action === 'annotate')
+    return unitDescriptor('Visualize', { count: 1, active: 'Marking', done: 'Marked', noun: 'annotation' });
+  if (action === 'check')
+    return unitDescriptor('Visualize', { count: 1, active: 'Checking', done: 'Checked', noun: 'page' });
+  if (action === 'inspect')
+    return unitDescriptor('Visualize', { count: 1, active: 'Inspecting', done: 'Inspected', noun: 'page' });
+  if (action === 'close')
+    return unitDescriptor('Visualize', { count: 1, active: 'Closing', done: 'Closed', noun: 'tab' });
   return unitDescriptor('Visualize', { count: 1, active: 'Showing', done: 'Showed', noun: 'artifact' });
 }
 
@@ -568,7 +576,7 @@ function gitStageUnit(a) {
 function cwdUnit(a) {
   const action = String(a.action || a.type || '').toLowerCase();
   // A bare `path` selects that Project even when action is omitted.
-  if (action === 'set' || (!action && a.path)) {
+  if (action === 'set' || action === 'set-project' || (!action && a.path)) {
     return unitDescriptor('Setup', {
       active: 'Selecting',
       done: 'Selected',
@@ -576,10 +584,43 @@ function cwdUnit(a) {
       effect: true,
     });
   }
-  if (action === 'list') {
+  if (action === 'list' || action === 'list-projects') {
     return unitDescriptor('Setup', { active: 'Listing', done: 'Listed', noun: 'project' });
   }
-  return unitDescriptor('Setup', { active: 'Checking', done: 'Checked', noun: 'working directory', pluralNoun: 'working directories' });
+  if (action === 'rename') {
+    return unitDescriptor('Setup', { active: 'Renaming', done: 'Renamed', noun: 'session', effect: true });
+  }
+  if (action === 'compact') {
+    return unitDescriptor('Setup', { active: 'Scheduling', done: 'Scheduled', noun: 'compaction', effect: true });
+  }
+  if (action === 'fork') {
+    return unitDescriptor('Setup', { active: 'Forking', done: 'Forked', noun: 'session', effect: true });
+  }
+  if (action === 'favorite' || action === 'archive') {
+    const off = a.value === false;
+    let words;
+    if (action === 'favorite') words = off ? ['Unfavoriting', 'Unfavorited'] : ['Favoriting', 'Favorited'];
+    else words = off ? ['Unarchiving', 'Unarchived'] : ['Archiving', 'Archived'];
+    const [active, done] = words;
+    return unitDescriptor('Setup', { active, done, noun: 'session', effect: true });
+  }
+  if (action.endsWith('-worktree') || action.endsWith('-worktrees')) {
+    return unitDescriptor('Setup', {
+      active: 'Managing',
+      done: 'Managed',
+      noun: 'worktree',
+      effect: !action.startsWith('list'),
+    });
+  }
+  if (action === 'status') {
+    return unitDescriptor('Setup', { active: 'Checking', done: 'Checked', noun: 'session' });
+  }
+  return unitDescriptor('Setup', {
+    active: 'Checking',
+    done: 'Checked',
+    noun: 'working directory',
+    pluralNoun: 'working directories',
+  });
 }
 
 const TOOL_UNITS = new Map([
@@ -689,13 +730,15 @@ const TOOL_UNITS = new Map([
   ['use_skill', skillUnit],
   ['code_graph', codeGraphUnit],
   ['request_user_input', () => unitDescriptor('Setup', { active: 'Asking', done: 'Asked', noun: 'user' })],
+  ['ask_user', () => unitDescriptor('Setup', { active: 'Asking', done: 'Asked', noun: 'user' })],
   ['update_plan', () => unitDescriptor('Setup', { active: 'Updating', done: 'Updated', noun: 'plan' })],
   ['list_mcp_resources', () => unitDescriptor('Setup', { active: 'Listing', done: 'Listed', noun: 'MCP resource' })],
   [
     'list_mcp_resource_templates',
     () => unitDescriptor('Setup', { active: 'Listing', done: 'Listed', noun: 'MCP resource template' }),
   ],
-  ['cwd', cwdUnit],
+  ['cwd', cwdUnit], // legacy: old transcripts
+  ['session', cwdUnit],
 ]);
 
 function mcpUnit(name, a) {

package/src/runtime/shared/transcript-metadata.mjs

@@ -21,6 +21,37 @@ export function createTranscriptRouteMetadata(session, route = {}, at = Date.now
   return { at, ...transcriptRouteMetadataFields({ modelId, model, provider, agent }) };
 }
 
+const ATTACHMENT_ID = /^[a-f0-9]{64}$/;
+const ATTACHMENT_KINDS = new Set(['image', 'file', 'text']);
+
+/**
+ * The attachments a user message carries (`meta.transcript.attachments`):
+ * `[{ id, attachmentRef, kind, name, mimeType, size }]`, the id being the
+ * content hash under which the attachment store keeps the bytes. Anything that
+ * is not a well-formed record is dropped, so a row never names an id the store
+ * could not hold. Each record repeats the hash under `attachmentRef` — the
+ * key the store's census marks as referenced.
+ */
+export function normalizeMessageAttachments(value) {
+  if (!Array.isArray(value)) return [];
+  const seen = new Set();
+  const out = [];
+  for (const raw of value) {
+    const id = typeof raw?.id === 'string' ? raw.id : '';
+    if (!ATTACHMENT_ID.test(id) || seen.has(id) || out.length >= 64) continue;
+    seen.add(id);
+    out.push({
+      id,
+      attachmentRef: id,
+      kind: ATTACHMENT_KINDS.has(raw.kind) ? raw.kind : 'file',
+      name: String(raw.name || 'attachment').slice(0, 200),
+      mimeType: String(raw.mimeType || 'application/octet-stream').slice(0, 100),
+      size: Number.isFinite(Number(raw.size)) && Number(raw.size) >= 0 ? Number(raw.size) : 0,
+    });
+  }
+  return out;
+}
+
 /** A new stable message id (`meta.transcript.messageId`). */
 export function newTranscriptMessageId() {
   return `msg_${globalThis.crypto.randomUUID().replaceAll('-', '')}`;
@@ -36,6 +67,7 @@ export function persistedUserTranscriptMetadata(value) {
   if (!value || typeof value !== 'object') return null;
   return {
     messageId: stableMessageId(value.messageId),
+    ...(typeof value.attemptId === 'string' && value.attemptId ? { attemptId: value.attemptId } : {}),
     ...(Number.isFinite(Number(value.at)) ? { at: Number(value.at) } : {}),
     ...transcriptRouteMetadataFields(value),
     ...(typeof value.sender === 'string' && value.sender ? { sender: value.sender } : {}),
@@ -44,14 +76,30 @@ export function persistedUserTranscriptMetadata(value) {
     // The turn's change-record key (the outer prompt id), so a restored user
     // row still addresses its turn's Undo/Reapply.
     ...(typeof value.checkpointId === 'string' && value.checkpointId ? { checkpointId: value.checkpointId } : {}),
+    ...attachmentsField(value.attachments),
   };
 }
 
+function attachmentsField(value) {
+  const attachments = normalizeMessageAttachments(value);
+  return attachments.length ? { attachments } : {};
+}
+
+/** The `attachments` field of a transcript row (absent when there are none). */
+export function transcriptAttachmentFields(value) {
+  return attachmentsField(value?.attachments);
+}
+
 export function persistedAssistantTranscriptMetadata(value, fallbackAt = Date.now()) {
   if (!value || typeof value !== 'object') return null;
   const candidateAt = Number(value.assistantAt);
   const assistantAt = Number.isFinite(candidateAt) && candidateAt > 0 ? candidateAt : fallbackAt;
   value.assistantAt = assistantAt;
   value.assistantMessageId = stableMessageId(value.assistantMessageId);
-  return { messageId: value.assistantMessageId, at: assistantAt, ...transcriptRouteMetadataFields(value) };
+  return {
+    messageId: value.assistantMessageId,
+    at: assistantAt,
+    ...(typeof value.attemptId === 'string' && value.attemptId ? { attemptId: value.attemptId } : {}),
+    ...transcriptRouteMetadataFields(value),
+  };
 }

package/src/runtime/shared/transcript-turn-keys.mjs

@@ -0,0 +1,33 @@
+function stableItemKey(item, index) {
+  if (item?.id !== undefined && item?.id !== null) return String(item.id);
+  return `${item?.kind || 'item'}:${item?.text || item?.label || item?.status || ''}:${index}`;
+}
+
+/** Completed attempts keep the same identity in live, full and tail projections. */
+export function transcriptTurnKeys(items) {
+  const transcript = Array.isArray(items) ? items : [];
+  const keys = [];
+  let activeTurn = null;
+  let start = 0;
+  for (let index = 0; index < transcript.length; index += 1) {
+    const item = transcript[index];
+    if (item?.kind === 'user') {
+      activeTurn = `turn:${stableItemKey(item, index)}`;
+      start = index;
+    }
+    if (!activeTurn) {
+      activeTurn = `segment:${stableItemKey(item, index)}`;
+      start = index;
+    }
+    keys.push(activeTurn);
+    if (item?.kind === 'turndone') {
+      if (typeof item.attemptId === 'string' && item.attemptId) {
+        for (let row = start; row <= index; row += 1) keys[row] = `attempt:${item.attemptId}`;
+      } else if (typeof item.checkpointId === 'string' && item.checkpointId) {
+        for (let row = start; row <= index; row += 1) keys[row] = `checkpoint:${item.checkpointId}`;
+      }
+      activeTurn = null;
+    }
+  }
+  return keys;
+}

package/src/runtime/shared/transcript-writer/purge.mjs

@@ -0,0 +1,74 @@
+/**
+ * transcript-writer/purge.mjs — removal of one deleted session's transcript.
+ *
+ * Per id, no folder scan: the paths this process's writers have used for the
+ * id, plus the paths the caller's known session cwds map to. A purged id is
+ * remembered so a still-running writer of the deleted session cannot recreate
+ * its file (session ids are never reused).
+ */
+import { unlinkSync } from 'node:fs';
+import { join, resolve } from 'node:path';
+import { discardBuffered } from '../buffered-appender.mjs';
+import { cwdToProjectSlug } from './transcript-file.mjs';
+
+const MAX_TRACKED_SESSIONS = 4096;
+const knownPaths = new Map(); // sessionId -> Set<transcriptPath>
+const purgedSessions = new Set();
+
+function boundedAdd(set, value) {
+  set.delete(value);
+  set.add(value);
+  if (set.size > MAX_TRACKED_SESSIONS) set.delete(set.values().next().value);
+}
+
+/** A writer of `sessionId` appends to `transcriptPath`. */
+export function noteSessionTranscript(sessionId, transcriptPath) {
+  let paths = knownPaths.get(sessionId);
+  if (!paths) {
+    paths = new Set();
+    knownPaths.delete(sessionId);
+    knownPaths.set(sessionId, paths);
+    if (knownPaths.size > MAX_TRACKED_SESSIONS) knownPaths.delete(knownPaths.keys().next().value);
+  }
+  paths.add(transcriptPath);
+}
+
+export function isSessionTranscriptPurged(sessionId) {
+  return purgedSessions.has(sessionId);
+}
+
+function removeFile(path) {
+  discardBuffered(path);
+  try {
+    unlinkSync(path);
+  } catch (error) {
+    if (error?.code !== 'ENOENT') throw error;
+  }
+}
+
+/**
+ * Delete `<id>.jsonl` (and its rotated `.1`) of the session. Returns every
+ * primary transcript path considered (existing or not) so the caller can drop
+ * the memory ingest offsets keyed by them. A file that cannot be removed is
+ * reported through `onError` and does not stop the others.
+ */
+export function purgeSessionTranscripts({ mixdogHome, sessionId, cwds = [], onError = () => {} }) {
+  if (!sessionId) return [];
+  boundedAdd(purgedSessions, sessionId);
+  const paths = new Set(knownPaths.get(sessionId) || []);
+  for (const cwd of cwds) {
+    if (typeof cwd !== 'string' || !cwd) continue;
+    paths.add(join(mixdogHome, 'projects', cwdToProjectSlug(resolve(cwd)), `${sessionId}.jsonl`));
+  }
+  knownPaths.delete(sessionId);
+  for (const path of paths) {
+    for (const target of [path, `${path}.1`]) {
+      try {
+        removeFile(target);
+      } catch (error) {
+        onError(target, error);
+      }
+    }
+  }
+  return [...paths];
+}

package/src/runtime/shared/transcript-writer/transcript-file.mjs

@@ -29,7 +29,15 @@ export function conversationText(content) {
     .join('\n');
 }
 
-export function createTranscriptFile({ projectDir, transcriptPath, sessionId, resolvedCwd, logOnce, rotation }) {
+export function createTranscriptFile({
+  projectDir,
+  transcriptPath,
+  sessionId,
+  resolvedCwd,
+  logOnce,
+  rotation,
+  memoryEligible = true,
+}) {
   let projectDirReady = false;
   function ensureProjectDir() {
     if (projectDirReady) return;
@@ -81,6 +89,7 @@ export function createTranscriptFile({ projectDir, transcriptPath, sessionId, re
         const text = conversationText(message?.content);
         if (!text.trim()) continue;
         const entry = { type: role, sessionId, cwd: resolvedCwd };
+        if (!memoryEligible) entry.memoryEligible = false;
         if (message?.timestamp != null) entry.timestamp = message.timestamp;
         else if (message?.ts != null) entry.ts = message.ts;
         entry.message = { content: [{ type: 'text', text }] };

package/src/runtime/shared/transcript-writer.mjs

@@ -21,6 +21,7 @@ import { formatUtcTimestamp } from './time-format.mjs';
 import { createRotationTracker } from './transcript-writer/rotation.mjs';
 import { conversationText, createTranscriptFile, cwdToProjectSlug } from './transcript-writer/transcript-file.mjs';
 import { createFailureLog, createSessionRecord } from './transcript-writer/session-record.mjs';
+import { isSessionTranscriptPurged, noteSessionTranscript } from './transcript-writer/purge.mjs';
 
 // A user prompt with pasted images arrives as a content block array; only its
 // text reaches the transcript (String(array) would store "[object Object]").
@@ -29,7 +30,7 @@ const textOrEmpty = (text) => {
   return text == null ? '' : String(text);
 };
 
-export function createTranscriptWriter({ mixdogHome, sessionId, cwd, pid } = {}) {
+export function createTranscriptWriter({ mixdogHome, sessionId, cwd, pid, memoryEligible = true } = {}) {
   if (!mixdogHome) throw new Error('transcript-writer: mixdogHome is required');
   if (!sessionId) throw new Error('transcript-writer: sessionId is required');
   if (!cwd) throw new Error('transcript-writer: cwd is required');
@@ -41,10 +42,22 @@ export function createTranscriptWriter({ mixdogHome, sessionId, cwd, pid } = {})
 
   const logOnce = createFailureLog();
   const rotation = createRotationTracker({ transcriptPath, logOnce });
-  const file = createTranscriptFile({ projectDir, transcriptPath, sessionId, resolvedCwd, logOnce, rotation });
+  const file = createTranscriptFile({
+    projectDir,
+    transcriptPath,
+    sessionId,
+    resolvedCwd,
+    logOnce,
+    rotation,
+    memoryEligible,
+  });
   const record = createSessionRecord({ sessionRecordPath, sessionId, resolvedCwd, transcriptPath, logOnce });
 
+  noteSessionTranscript(sessionId, transcriptPath);
+
   function appendLine(entry) {
+    // A deleted session's own writer must not bring its transcript back.
+    if (isSessionTranscriptPurged(sessionId)) return;
     file.ensureProjectDir();
     rotation.rotateIfNeeded();
     try {
@@ -54,6 +67,7 @@ export function createTranscriptWriter({ mixdogHome, sessionId, cwd, pid } = {})
         entry?.timestamp != null || entry?.ts != null
           ? { ...entry, cwd: resolvedCwd }
           : { ...entry, cwd: resolvedCwd, timestamp: formatUtcTimestamp() };
+      if (!memoryEligible) stampedEntry.memoryEligible = false;
       const line = `${JSON.stringify(stampedEntry)}\n`;
       appendBuffered(transcriptPath, line);
       rotation.noteAppended(Buffer.byteLength(line));
@@ -90,12 +104,16 @@ export function createTranscriptWriter({ mixdogHome, sessionId, cwd, pid } = {})
   return {
     transcriptPath,
     sessionRecordPath,
-    writeSessionRecord: record.write,
-    ensureConversationBackfill: file.ensureConversationBackfill,
-    ensureTranscriptFile: file.ensureTranscriptFile,
+    // Agent runtimes can share a PID with their parent; never replace its discovery record.
+    writeSessionRecord: memoryEligible ? record.write : () => {},
+    ensureConversationBackfill: (messages) =>
+      isSessionTranscriptPurged(sessionId) ? false : file.ensureConversationBackfill(messages),
+    ensureTranscriptFile: () => {
+      if (!isSessionTranscriptPurged(sessionId)) file.ensureTranscriptFile();
+    },
     // Refresh only the session record's updatedAt so discovery keeps ranking
     // this session as live across long-lived remote sessions.
-    refresh: record.write,
+    refresh: memoryEligible ? record.write : () => {},
     appendAssistant: (text) => appendText('assistant', text),
     // User prompt row. It exists so the memory transcript watcher ingests BOTH
     // sides of the conversation (user rows were previously never written,