mixdog 1.4.0 → 1.4.2

package/src/session-runtime/conversation-import/service.mjs

@@ -14,20 +14,26 @@
  */
 import { randomUUID } from 'node:crypto';
 import { access, stat } from 'node:fs/promises';
+import { basename } from 'node:path';
 import {
   buildImportOrigin,
   createImportedSession,
   importOriginKey,
 } from '../../runtime/agent/orchestrator/session/conversation-import/imported-session.mjs';
-import { IMPORT_WARNING_CWD_MISSING } from '../../runtime/agent/orchestrator/session/conversation-import/turns.mjs';
+import {
+  IMPORT_ERROR_NEEDS_NEWER_NODE,
+  IMPORT_WARNING_CWD_MISSING,
+} from '../../runtime/agent/orchestrator/session/conversation-import/turns.mjs';
 import { sessionPath } from '../../runtime/agent/orchestrator/session/store/session-paths.mjs';
 import {
   cachedMeta,
   convertCandidateFile,
+  displayTitle,
   getCandidate,
   importError,
   importedKeyMap,
   listConversations,
+  loadStoredTitles,
   recordConversion,
   registerFile,
   resolveSourceCwd,
@@ -131,6 +137,17 @@ function touch(job, patch = {}) {
 
 const COUNTER = { imported: 'imported', alreadyImported: 'skippedAlreadyImported', failed: 'failed' };
 
+const titlesFor = (candidate, context) => (candidate.source === 'codex' ? context.titles : null);
+
+/** Which record a result is about: its title and source file name, for the failure report. */
+function describeCandidate(candidateId, context) {
+  const candidate = getCandidate(candidateId);
+  return {
+    title: candidate ? displayTitle(cachedMeta(candidate), titlesFor(candidate, context)) : null,
+    sourceName: candidate ? basename(candidate.path) : null,
+  };
+}
+
 function record(job, { projectPath = null, ...result }) {
   const counter = COUNTER[result.status];
   job[counter] += 1;
@@ -162,6 +179,7 @@ async function importOne(candidateId, context) {
   if (!candidate) return failed(candidateId, 'unknownCandidate');
   // The chat keeps the title the user picked it by: a long file's listing
   // title comes from its prefix and can differ from the converted branch.
+  // Codex's own stored title, when it has one, names the chat first.
   const listedTitle = cachedMeta(candidate)?.title ?? null;
   let conversion;
   try {
@@ -170,10 +188,17 @@ async function importOne(candidateId, context) {
     candidate.size = info.size;
     candidate.mtimeMs = info.mtimeMs;
     conversion = await convertCandidateFile(candidate, context.limits);
-  } catch {
-    return failed(candidateId, 'unreadable');
+  } catch (error) {
+    return failed(
+      candidateId,
+      error?.code === IMPORT_ERROR_NEEDS_NEWER_NODE ? IMPORT_ERROR_NEEDS_NEWER_NODE : 'unreadable'
+    );
   }
-  if (listedTitle) conversion = { ...conversion, title: listedTitle };
+  const title = displayTitle(
+    { foreignSessionId: conversion.foreignSessionId, title: listedTitle || conversion.title },
+    titlesFor(candidate, context)
+  );
+  if (title) conversion = { ...conversion, title };
   recordConversion(candidate, conversion);
   const cwdInfo = await resolveSourceCwd(conversion.cwd);
   const projectPath = cwdInfo.exists ? cwdInfo.path : null;
@@ -221,6 +246,7 @@ async function runJob(job, candidateIds, context) {
   try {
     // One catalog read per batch; later commits are seen through committedKeys.
     context.imported = await context.importedLookup();
+    context.titles = await context.loadTitles();
     for (const candidateId of candidateIds) {
       if (job.cancelRequested) break;
       let result;
@@ -228,8 +254,7 @@ async function runJob(job, candidateIds, context) {
         result = await admit(async () => {
           // A cancel that arrived while queued behind other jobs wins here.
           if (job.cancelRequested) return null;
-          const candidate = getCandidate(candidateId);
-          touch(job, { current: { candidateId, title: (candidate && cachedMeta(candidate)?.title) ?? null } });
+          touch(job, { current: { candidateId, title: describeCandidate(candidateId, context).title } });
           try {
             return await importOne(candidateId, context);
           } finally {
@@ -241,7 +266,7 @@ async function runJob(job, candidateIds, context) {
         result = failed(candidateId, 'importFailed');
       }
       if (result === null) break;
-      record(job, result);
+      record(job, { ...result, ...describeCandidate(candidateId, context) });
     }
     touch(job, { state: job.cancelRequested ? 'stopped' : 'completed' });
   } catch (error) {
@@ -296,7 +321,7 @@ export function createConversationImportApi({
       return listConversations(requireParams(params), { imported: await imported(), env });
     },
     async registerConversationImportFile(params) {
-      return registerFile(requireParams(params), { imported: await imported(), limits });
+      return registerFile(requireParams(params), { imported: await imported(), limits, env });
     },
     getConversationImportJobs(params = {}) {
       const { jobId } = requireParams(params ?? {});
@@ -334,6 +359,8 @@ export function createConversationImportApi({
           void runJob(job, candidateIds, {
             importedLookup: imported,
             imported: null,
+            titles: null,
+            loadTitles: () => loadStoredTitles('codex', env),
             sessionExists,
             limits,
             prepareLeadOptions,

package/src/session-runtime/handoff-attachments.mjs

@@ -453,8 +453,9 @@ function callArgs(call) {
   return args && typeof args === 'object' ? args : {};
 }
 
-/** The paths one tool call wrote or produced. */
-function toolCallOutputs(call) {
+/** The paths one tool call wrote or produced; `written`: only those it
+ *  actually created or modified (opening a file in visualize does neither). */
+function toolCallOutputs(call, written) {
   const name = String(call?.function?.name || call?.name || '');
   const args = callArgs(call);
   const text = (value) => (typeof value === 'string' && value.trim() ? [value.trim()] : []);
@@ -464,7 +465,7 @@ function toolCallOutputs(call) {
   if (name === 'office') return OFFICE_WRITE_ACTIONS.has(args.action) ? [...text(args.output), ...text(args.path)] : [];
   if (name === 'visualize') {
     const input = args.input && typeof args.input === 'object' ? args.input : {};
-    const targets = args.action === 'open' && Array.isArray(input.targets) ? input.targets : [];
+    const targets = !written && args.action === 'open' && Array.isArray(input.targets) ? input.targets : [];
     return [
       ...text(input.output),
       ...targets.filter((target) => typeof target === 'string' && !/^[a-z][a-z0-9+.-]*:\/\//i.test(target)),
@@ -520,8 +521,9 @@ export function turnSlice(messages, { runId = '', since = 0 } = {}) {
 
 /** The candidate artifact paths of a turn's messages, most relevant first:
  *  what its final reply names, then media/office/visualize outputs, then the
- *  files it edited. */
-export function turnArtifactCandidates(messages) {
+ *  files it edited. `written`: only the files it created or modified (no
+ *  reply paths, no visualize open targets). */
+function turnArtifactCandidates(messages, { written = false } = {}) {
   const list = Array.isArray(messages) ? messages : [];
   const reply = list.findLast((message) => message?.role === 'assistant' && textOf(message.content).trim());
   const produced = [];
@@ -535,10 +537,10 @@ export function turnArtifactCandidates(messages) {
         : [];
     for (const call of calls) {
       const name = String(call?.function?.name || call?.name || '');
-      (name === 'edit' || name === 'apply_patch' ? edited : produced).push(...toolCallOutputs(call));
+      (name === 'edit' || name === 'apply_patch' ? edited : produced).push(...toolCallOutputs(call, written));
     }
   }
-  return [...(reply ? replyPaths(textOf(reply.content)) : []), ...produced, ...edited];
+  return [...(!written && reply ? replyPaths(textOf(reply.content)) : []), ...produced, ...edited];
 }
 
 /**
@@ -549,38 +551,16 @@ export function turnArtifactCandidates(messages) {
  * the roots are left out silently; at most HANDOFF_LIMITS.count are kept.
  */
 export function collectTurnArtifacts(messages, { cwd = '', roots = [] } = {}) {
-  const seen = new Set();
   const files = [];
   let omitted = 0;
   const budget = createBudget();
-  for (const candidate of turnArtifactCandidates(messages)) {
-    // A candidate is a lexical path; its canonical form dedupes after the read.
-    const lexical = samePlatformPath(
-      isAbsolute(candidate) ? resolve(candidate) : resolve(cwd || process.cwd(), candidate)
-    );
-    if (seen.has(lexical)) continue;
-    seen.add(lexical);
-    let file;
-    try {
-      file = readContained(candidate, { cwd, roots, surface: 'artifact' });
-    } catch {
-      continue;
-    }
-    const key = samePlatformPath(file.path);
-    if (key !== lexical && seen.has(key)) continue;
-    seen.add(key);
+  for (const { file } of readableCandidates(turnArtifactCandidates(messages), { cwd, roots })) {
     if (files.length >= HANDOFF_LIMITS.count) {
       omitted += 1;
       continue;
     }
     const { type, bytes } = file;
-    const entry = {
-      path: file.path,
-      name: file.name,
-      kind: type?.kind || 'file',
-      mimeType: type?.mimeType || 'application/octet-stream',
-      size: file.size,
-    };
+    const entry = pathEntry(file);
     const storable = bytes && (type.kind !== 'image' || SUPPORTED_IMAGE_MIME_TYPES.has(type.mimeType));
     if (storable && budget.take(type.kind, bytes.length)) {
       try {
@@ -591,3 +571,74 @@ export function collectTurnArtifacts(messages, { cwd = '', roots = [] } = {}) {
   }
   return { files, omitted };
 }
+
+/**
+ * The files `messages` (one turn) created or modified, inside `roots`, that
+ * `report` (the text handed to the Lead) does not name: `{ files, omitted }`
+ * as path-only entries, which the Lead forwards by path. Nothing is stored.
+ */
+export function collectUnreportedWrites(messages, { cwd = '', roots = [], report }) {
+  const found = [...readableCandidates(turnArtifactCandidates(messages, { written: true }), { cwd, roots })];
+  const unnamed = found.filter((item) => !reportNames(report, item, found, cwd));
+  return {
+    files: unnamed.slice(0, HANDOFF_LIMITS.count).map(({ file }) => pathEntry(file)),
+    omitted: Math.max(0, unnamed.length - HANDOFF_LIMITS.count),
+  };
+}
+
+const lexicalKey = (path, cwd) => samePlatformPath(resolve(cwd || process.cwd(), path));
+
+const pathEntry = (file) => ({
+  path: file.path,
+  name: file.name,
+  kind: file.type?.kind || 'file',
+  mimeType: file.type?.mimeType || 'application/octet-stream',
+  size: file.size,
+});
+
+/** The distinct files among `candidates` that can be read inside `roots`, with
+ *  their lexical and canonical keys. A candidate is a lexical path; its
+ *  canonical form dedupes after the read. */
+function* readableCandidates(candidates, { cwd, roots }) {
+  const seen = new Set();
+  for (const candidate of candidates) {
+    const lexical = lexicalKey(candidate, cwd);
+    if (seen.has(lexical)) continue;
+    seen.add(lexical);
+    let file;
+    try {
+      file = readContained(candidate, { cwd, roots, surface: 'artifact' });
+    } catch {
+      continue;
+    }
+    const key = samePlatformPath(file.path);
+    if (key !== lexical && seen.has(key)) continue;
+    seen.add(key);
+    yield { file, lexical, key };
+  }
+}
+
+/** Whether `report` names the produced file `item` among `found`: by its full
+ *  path or a cwd-relative path resolving to it exactly, or by its bare file name
+ *  when no other produced file shares that name. */
+function reportNames(report, { file, lexical, key }, found, cwd) {
+  const flat = (value) => String(value).replaceAll('\\', '/');
+  const filePath = flat(file.path);
+  if (flat(report).includes(filePath)) return true;
+  const plain = report
+    .split(/[\s`"'<>()[\],;|]+/)
+    .map((token) => token.replace(/:\d+(?::\d+)?$/, '').replace(/[.:!?]+$/, ''))
+    .filter((token) => /\.[A-Za-z0-9]{1,8}$/.test(token) && !/^[a-z][a-z0-9+.-]*:\/\//i.test(token));
+  const refs = new Set([...replyPaths(report), ...plain]);
+  const unique = found.filter((other) => other.file.name === file.name).length === 1;
+  for (const ref of refs) {
+    const normalized = flat(ref).replace(/^(?:\.\/)+/, '');
+    if (!normalized.includes('/')) {
+      if (unique && normalized === file.name) return true;
+      continue;
+    }
+    const refKey = lexicalKey(ref, cwd);
+    if (refKey === lexical || refKey === key) return true;
+  }
+  return false;
+}

package/src/session-runtime/held-requests.mjs

@@ -139,11 +139,13 @@ export function createHeldRequests({
       tool: request.name,
       target: request.outbound?.target || '',
       reason: request.reason || '',
+      // The connector account the call is bound to (tool-exec.mjs).
+      account: request.account,
       ...(request.kind === 'outbound'
         ? {
             payload: request.outbound?.payload || '',
             action: request.outbound?.category,
-            account: request.outbound?.account,
+            account: request.outbound?.account || request.account,
             editable: request.outbound?.editable,
             details: request.outbound?.details,
           }

package/src/session-runtime/internal-tool-executor/ask-user-tool.mjs

@@ -1,8 +1,9 @@
 // ask_user: put 1-4 multiple-choice questions to the user through the session's
 // tool-approval hook (kind: 'question') and report the answers to the model.
+// handoff_user (the secret / takeover handoff) shares this module's human-gate code.
 import { randomUUID } from 'node:crypto';
 import {
-  validateAskUserHandoff,
+  validateUserHandoff,
   validateAskUserQuestions,
   ASK_USER_MAX_TEXT,
 } from '../../runtime/agent/orchestrator/runtime-core/ask-user-tool-defs.mjs';
@@ -78,7 +79,7 @@ export async function runAskUserHandoff(handoff, { hook, sessionId, toolCallId,
   const gate = {
     agentId: agentIdForSession(sessionId),
     kind: handoff.kind,
-    tool: `ask_user:${handoff.surface}`,
+    tool: `handoff_user:${handoff.surface}`,
     target: handoff.target || handoff.field || '',
   };
   // A schedule or webhook run has nobody to take over: the step ends it now,
@@ -133,7 +134,7 @@ export async function runAskUserHandoff(handoff, { hook, sessionId, toolCallId,
     }
     const result = await runAbortable(signal, () =>
       hook({
-        name: 'ask_user',
+        name: 'handoff_user',
         kind: 'secret',
         secret: { requestId, surface: handoff.surface, target: handoff.target, field: handoff.field, ...bound },
         reason: '',
@@ -171,7 +172,7 @@ export async function runAskUserHandoff(handoff, { hook, sessionId, toolCallId,
     : null;
   const result = await runAbortable(signal, () =>
     hook({
-      name: 'ask_user',
+      name: 'handoff_user',
       kind: 'takeover',
       takeover: {
         surface: handoff.surface,
@@ -278,16 +279,14 @@ function formatAskUserResult(questions, answers, reply) {
 export function createAskUserToolHandlers({ rt }) {
   const { sessionIdFor, signalFor } = createCallerContextResolvers(rt);
   return {
+    handoff_user: async (args, { callerCtx }) =>
+      runAskUserHandoff(validateUserHandoff(args), {
+        hook: callerCtx?.toolApprovalHook,
+        sessionId: sessionIdFor(callerCtx),
+        toolCallId: callerCtx?.toolCallId || null,
+        signal: signalFor(callerCtx),
+      }),
     ask_user: async (args, { callerCtx }) => {
-      const handoff = validateAskUserHandoff(args);
-      if (handoff) {
-        return runAskUserHandoff(handoff, {
-          hook: callerCtx?.toolApprovalHook,
-          sessionId: sessionIdFor(callerCtx),
-          toolCallId: callerCtx?.toolCallId || null,
-          signal: signalFor(callerCtx),
-        });
-      }
       const questions = validateAskUserQuestions(args);
       const hook = callerCtx?.toolApprovalHook;
       if (typeof hook !== 'function') return NO_USER;

package/src/session-runtime/internal-tool-executor/bridge-tools.mjs

@@ -83,6 +83,7 @@ export function createBridgeToolHandlers({ rt }) {
     }
     return await executeVisualizeTool(args, {
       sessionId: sessionIdFor(callerCtx),
+      callId: callerCtx?.toolCallId,
       cwd: callerCwd,
       signal: signalFor(callerCtx),
     });

package/src/session-runtime/internal-tool-executor/feature-tools.mjs

@@ -50,6 +50,8 @@ export function createFeatureToolHandlers({ rt, setupTool, officeToolsEnabled, m
       await setupTool.execute(args || {}, {
         signal: signalFor(callerCtx),
         callerSessionId: callerCtx?.callerSessionId || null,
+        requestApproval: callerCtx?.toolApprovalHook || null,
+        toolCallId: callerCtx?.toolCallId || null,
       }),
   };
 }

package/src/session-runtime/internal-tool-executor/knowledge-tools.mjs

@@ -88,6 +88,14 @@ export function createKnowledgeToolHandlers({
       if (!codeGraphMod?.executeCodeGraphTool) throw new Error('code_graph runtime is not available');
       return await codeGraphMod.executeCodeGraphTool(name, args || {}, args?.cwd || callerCwd);
     },
+    explore: async (args, { callerCtx, callerCwd }) => {
+      const { runExplore } = await import('../../runtime/explore/tool.mjs');
+      return await runExplore(args || {}, {
+        cwd: callerCwd,
+        signal: signalFor(callerCtx),
+        callerSessionId: callerCtx?.callerSessionId || callerCtx?.sessionId || rt.session?.id || null,
+      });
+    },
     load_tool: toolSearch,
     Skill: (args) => skillToolContent(args?.name, activeToolSurface(), rt.mode),
   };

package/src/session-runtime/internal-tool-executor/reaction-tool.mjs

@@ -4,7 +4,10 @@
 // the message is the user's row in the room's log. Never a coding session, a
 // delegated worker, or a run nobody attends.
 import { isAgentOwner } from '../../runtime/agent/orchestrator/agent-owner.mjs';
-import { noteReactionTarget, validateReactionArgs } from '../../runtime/agent/orchestrator/runtime-core/reaction-tool-defs.mjs';
+import {
+  noteReactionTarget,
+  validateReactionArgs,
+} from '../../runtime/agent/orchestrator/runtime-core/reaction-tool-defs.mjs';
 import { agentIdOfHomeSession } from '../../runtime/agent/orchestrator/session/agent-home.mjs';
 import { roomMemberOfSession, roomSessionId } from '../../runtime/agent/orchestrator/session/agent-room.mjs';
 import { reactInSession } from '../../runtime/agent/orchestrator/session/message-reactions.mjs';