mixdog 1.3.0 → 1.3.2

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

@@ -1,12 +1,14 @@
 /**
- * Held requests: unattended runs never auto-approve. In a schedule, webhook or
- * group-room-member run, an approval-needing call is HELD instead of shown as
+ * Unattended runs. A schedule or webhook run never asks (its saved routine is
+ * the user's grant; human-gate/run-policy.mjs), so only group-room members
+ * still use held requests: an approval-needing call is HELD instead of shown as
  * a card: the run pauses on it, a structured held-request row lands in the
  * owning agent's home thread (agent-home-delivery.mjs queue), a phone push
  * says only "<agent>가 승인을 기다립니다" (no tool, arguments or text), and the
- * request expires after HELD_REQUEST_EXPIRY_MS into a deny, so the run goes
- * on with the denial. The user answers from the home thread through the
- * ordinary approval call with the held id (runtime/shared/held-request-host.mjs).
+ * request waits, like any approval, until the user answers it (Approve/Deny,
+ * through the ordinary approval call with the held id,
+ * runtime/shared/held-request-host.mjs) or the run is cancelled (Stop, abort,
+ * app quit), which denies it. It never expires on a timer.
  *
  * Importing this module installs the unattended port of human-gate/gate.mjs.
  * Rooms: a room member session counts as unattended by its id; a surface that
@@ -23,20 +25,13 @@ import {
 } from '../runtime/agent/orchestrator/session/human-gate/gate.mjs';
 import { normalizeHumanResponse } from '../runtime/agent/orchestrator/session/human-gate/requests.mjs';
 import { normalizeHeldRequest } from '../runtime/agent/orchestrator/session/human-gate/held-message.mjs';
+import { delegationOf } from '../runtime/agent/orchestrator/session/human-gate/delegation.mjs';
 import {
   notifyHeldRequest,
   recordRunOwner,
   registerHeldRequestResolver,
 } from '../runtime/shared/held-request-host.mjs';
 
-/** Default expiry; MIXDOG_HELD_REQUEST_EXPIRY_MS overrides it. */
-export const HELD_REQUEST_EXPIRY_MS = 5 * 60_000;
-
-function configuredExpiryMs() {
-  const value = Number(process.env.MIXDOG_HELD_REQUEST_EXPIRY_MS);
-  return Number.isFinite(value) && value > 0 ? value : HELD_REQUEST_EXPIRY_MS;
-}
-
 const runs = new Map(); // sessionId → { kind, agentId, name }
 
 /** Mark `sessionId` as an unattended schedule/webhook run of `agentId`. */
@@ -54,12 +49,28 @@ export function markUnattendedRun(sessionId, { kind, agentId, name = '' }) {
   };
 }
 
-/** The unattended run `sessionId` belongs to, or null for an attended session. */
+/** The unattended run `sessionId` belongs to, or null for an attended session.
+ *  Work delegated from a run or a room (a sub-agent at any depth, a task
+ *  session the bot created) belongs to it by the origin recorded on its own
+ *  session record when it was created (human-gate/delegation.mjs) — however
+ *  long ago that run ended, across restarts: its approvals are held like the
+ *  run's own. */
 export function unattendedRunOf(sessionId) {
   const run = runs.get(sessionId);
   if (run) return run;
   const member = roomMemberOfSession(sessionId);
-  return member ? { kind: 'room', agentId: member.agentId, name: member.roomId } : null;
+  if (member) return { kind: 'room', agentId: member.agentId, name: member.roomId };
+  const delegation = delegationOf(sessionId);
+  if (delegation.state !== 'resolved') return null;
+  if (delegation.via === 'run') {
+    return {
+      kind: delegation.run.kind === 'webhook' ? 'webhook' : 'schedule',
+      agentId: delegation.rootAgentId,
+      name: String(delegation.run.name || ''),
+    };
+  }
+  const root = delegation.via === 'room' ? roomMemberOfSession(delegation.rootSessionId) : null;
+  return root ? { kind: 'room', agentId: root.agentId, name: root.roomId } : null;
 }
 
 /**
@@ -98,9 +109,7 @@ export function createHeldRequests({
   push = notifyHeldRequest,
   record = recordHumanDecision,
   agentName = defaultAgentName,
-  expiryMs = configuredExpiryMs,
   runOf = unattendedRunOf,
-  now = Date.now,
   log = (line) => process.stderr.write(`mixdog held-requests: ${line}\n`),
 }) {
   const pending = new Map();
@@ -113,7 +122,6 @@ export function createHeldRequests({
     const entry = pending.get(id);
     if (!entry) return false;
     pending.delete(id);
-    clearTimeout(entry.timer);
     entry.release();
     void post(entry.agentId, { ...entry.held, status, ...(approval.device ? { device: approval.device } : {}) });
     void Promise.resolve()
@@ -123,11 +131,10 @@ export function createHeldRequests({
     return true;
   }
 
-  /** Hold `request` (the approval hook's payload) until answered or expired. */
+  /** Hold `request` (the approval hook's payload) until answered or the run is cancelled. */
   function hold(request = {}, { signal } = {}) {
     const run = runOf(request.sessionId) || { kind: 'schedule', agentId: MIXY_AGENT_ID, name: '' };
     const id = `held_${randomUUID()}`;
-    const ms = typeof expiryMs === 'function' ? expiryMs() : expiryMs;
     const held = normalizeHeldRequest({
       id,
       status: 'pending',
@@ -145,12 +152,13 @@ export function createHeldRequests({
             details: request.outbound?.details,
           }
         : {}),
-      remember: request.remember || ['once'],
+      // An unattended run never remembers: its held row offers once only.
+      remember: ['once'],
       run: { kind: run.kind, name: run.name, sessionId: request.sessionId },
-      expiresAt: now() + ms,
     });
-    const shape = { kind: held.kind, outbound: request.outbound, remember: request.remember || ['once'] };
+    const shape = { kind: held.kind, outbound: request.outbound, remember: ['once'] };
     const gate = {
+      remember: ['once'],
       agentId: run.agentId,
       kind: held.kind,
       ...(held.action ? { action: held.action } : {}),
@@ -167,17 +175,7 @@ export function createHeldRequests({
         agentId: run.agentId,
         resolve,
         release: () => signal?.removeEventListener?.('abort', onAbort),
-        timer: setTimeout(
-          () =>
-            settle(
-              id,
-              { ...normalizeHumanResponse(shape, false), reason: 'held request expired', timedOut: true },
-              'expired'
-            ),
-          ms
-        ),
       };
-      entry.timer.unref?.();
       pending.set(id, entry);
       void post(run.agentId, held);
       try {
@@ -219,6 +217,11 @@ function heldRequests() {
   return processHeld;
 }
 
+/** The held requests still waiting for an answer (session bots reads them). */
+export function pendingHeldRequests() {
+  return processHeld ? processHeld.pending() : [];
+}
+
 /** Hold one request for its session's agent (rooms call this from their own hook). */
 export function holdApprovalRequest(request, options) {
   return heldRequests().hold(request, options);

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

@@ -6,6 +6,8 @@ import { executeTerminalTool } from '../../runtime/terminal-bridge/client.mjs';
 import { executeVisualizeTool } from '../../runtime/visualize-bridge/client.mjs';
 import { featureEnvOverride, moduleEnabled } from '../../runtime/agent/orchestrator/runtime-core/config-helpers.mjs';
 import { createCallerContextResolvers } from './caller-context.mjs';
+import { unattendedApprovalPort } from '../../runtime/agent/orchestrator/session/human-gate/unattended-port.mjs';
+import { isGrantedRun } from '../../runtime/agent/orchestrator/session/human-gate/run-policy.mjs';
 
 export function createBridgeToolHandlers({ rt }) {
   const { sessionIdFor, signalFor } = createCallerContextResolvers(rt);
@@ -19,9 +21,16 @@ export function createBridgeToolHandlers({ rt }) {
     if (environmentDisabled(callerCtx, 'MIXDOG_FEATURE_BROWSER')) {
       throw new Error('the browser tool is disabled in this environment');
     }
+    const sessionId = sessionIdFor(callerCtx);
+    const run = unattendedApprovalPort()?.runOf?.(sessionId);
     return await executeBrowserTool(args, {
       tool: name,
-      sessionId: sessionIdFor(callerCtx),
+      sessionId,
+      // A schedule/webhook run never asks for form submits, posts or uploads;
+      // the bot that owns the run comes from the run's record, so its `block`
+      // applies whatever the display metadata says.
+      unattendedRun: isGrantedRun(run),
+      unattendedAgent: run?.agentId || '',
       turnId: callerCtx?.turnId || rt.session?.usageMetricsTurnId,
       signal: signalFor(callerCtx),
     });

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

@@ -1,6 +1,6 @@
 // Optional feature tools gated by settings for model-initiated calls: office,
 // media and tidy (each loaded on first use), and the setup tool.
-import { STANDALONE_DATA_DIR } from '../runtime-paths.mjs';
+import { standaloneDataDir } from '../runtime-paths.mjs';
 import { createCallerContextResolvers } from './caller-context.mjs';
 
 export function createFeatureToolHandlers({ rt, setupTool, officeToolsEnabled, mediaToolEnabled, tidyToolEnabled }) {
@@ -17,7 +17,7 @@ export function createFeatureToolHandlers({ rt, setupTool, officeToolsEnabled, m
       const { executeOfficeTool } = await import('../../runtime/office/index.mjs');
       return await executeOfficeTool(args, {
         cwd: callerCwd,
-        dataDir: STANDALONE_DATA_DIR,
+        dataDir: standaloneDataDir(),
         requestApproval: callerCtx?.toolApprovalHook,
         sessionId: callerCtx?.sessionId,
         toolCallId: callerCtx?.toolCallId,

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

@@ -7,17 +7,31 @@ import { applySessionSidebarChange } from '../../runtime/shared/session-sidebar-
 import { clean } from '../../runtime/agent/orchestrator/runtime-core/session-text.mjs';
 import { AGENT_MODE, resolveSessionMode } from '../../runtime/agent/orchestrator/session/agent-mode.mjs';
 import { agentIdOfHomeSession } from '../../runtime/agent/orchestrator/session/agent-home.mjs';
+import { turnHopOf } from '../../runtime/shared/bot-hops.mjs';
 import { scheduleCallerScope } from '../services/schedule-access.mjs';
+import { resolveHandoffAttachments, sessionRoots } from '../handoff-attachments.mjs';
 
 const USER_TITLE_ERROR = 'session: the user already titled this session; the title was not changed';
 
-/** The agent an attended agent conversation (an agent's home thread) acts as;
+/** The agent an attended agent conversation (an agent's home thread, or its
+ *  member session in a group room, where the user is present too) acts as;
  *  '' for every other caller: delegated workers, coding sessions (task
  *  sessions included) and unattended schedule/webhook runs. */
 function attendedAgentOf(session) {
   const { mode, agentId } = resolveSessionMode({ session });
   const { kind } = scheduleCallerScope(session);
-  return mode === AGENT_MODE && (kind === 'human' || kind === 'agent') ? agentId : '';
+  return mode === AGENT_MODE && (kind === 'human' || kind === 'agent' || kind === 'room-member') ? agentId : '';
+}
+
+/** The caller's `attachments` as stored prompt parts, resolved against its own
+ *  conversation and folders (handoff-attachments.mjs). */
+function callerAttachmentParts(rt, args, callerCwd, surface) {
+  return resolveHandoffAttachments(args?.attachments, {
+    messages: rt.session?.messages,
+    roots: sessionRoots(rt.session, callerCwd),
+    cwd: callerCwd,
+    surface,
+  }).parts;
 }
 
 export function createWorkspaceToolHandlers({
@@ -77,12 +91,15 @@ export function createWorkspaceToolHandlers({
   const session = async (args, { callerCtx, callerCwd }) => {
     const action = clean(args?.action || (args?.path ? 'set-project' : 'status')).toLowerCase();
     const target = clean(args?.session_id);
-    if (['list', 'read', 'send', 'cancel', 'delete', 'create'].includes(action) || (action === 'status' && target)) {
+    if (
+      ['list', 'bots', 'read', 'send', 'cancel', 'delete', 'create'].includes(action) ||
+      (action === 'status' && target)
+    ) {
       const callerSessionId = assertLead(action, callerCtx);
       const callerAgentId = attendedAgentOf(rt.session);
       if (action === 'create' && !callerAgentId) {
         throw new Error(
-          'session: create belongs to an agent conversation; delegated workers, coding task sessions and schedule/webhook runs cannot create task sessions'
+          'session: create belongs to a bot conversation; delegated workers, agent task sessions and schedule/webhook runs cannot create agent task sessions'
         );
       }
       // A task session reaches its agent only through its reported result.
@@ -97,8 +114,24 @@ export function createWorkspaceToolHandlers({
       if (typeof executeSessionControl !== 'function') {
         throw new Error('session: cross-session control is unavailable in this runtime');
       }
+      const { attachments, ...rest } = args || {};
+      if (attachments !== undefined && action !== 'send' && action !== 'create') {
+        throw new Error(`session: attachments apply to send and create, not action=${action}`);
+      }
+      const attachmentParts = callerAttachmentParts(rt, args, callerCwd, 'session');
       return JSON.stringify(
-        await executeSessionControl({ ...args, action }, { callerSessionId, callerAgentId, callerCwd })
+        await executeSessionControl(
+          { ...rest, action },
+          {
+            callerSessionId,
+            callerAgentId,
+            callerCwd,
+            ...(action === 'send' || action === 'create' ? { callerHop: turnHopOf(rt.session) } : {}),
+            // Which bots and sessions it may see (bot-status.mjs).
+            ...(action === 'bots' || action === 'list' ? { callerScope: scheduleCallerScope(rt.session) } : {}),
+            ...(attachmentParts.length ? { attachmentParts } : {}),
+          }
+        )
       );
     }
     if (target && target !== assertLead(action, callerCtx)) {
@@ -221,13 +254,19 @@ export function createWorkspaceToolHandlers({
       }),
     agent: async (args, { callerCtx, callerCwd }) => {
       const callerSessionId = callerCtx?.callerSessionId || rt.session?.id || null;
-      return await agentTool.execute(args, {
+      // `attachmentParts` is never the model's to set: only the resolved
+      // `attachments` reach the agent's turn.
+      const { attachments, attachmentParts: _ignored, ...rest } = args || {};
+      const attachmentParts = callerAttachmentParts(rt, { attachments }, callerCwd, 'agent');
+      return await agentTool.execute(attachmentParts.length ? { ...rest, attachmentParts } : rest, {
         callerCwd,
         invocationSource: 'model-tool',
         callerSessionId,
         clientHostPid: callerCtx?.clientHostPid || rt.session?.clientHostPid || process.pid,
         signal: callerCtx?.signal,
         notifyFn: notifyFnForSession(callerSessionId),
+        // The jobs this call starts are recorded under it (agent-task-starts.mjs).
+        ...(callerCtx?.toolCallId ? { toolCallId: callerCtx.toolCallId } : {}),
       });
     },
   };

package/src/session-runtime/lifecycle/session-catalog.mjs

@@ -16,6 +16,10 @@ import {
   clean,
 } from '../../runtime/agent/orchestrator/runtime-core/session-text.mjs';
 
+import {
+  incomingTailOf,
+  wantsIncomingTail,
+} from '../../runtime/agent/orchestrator/session/store-summary-last-message.mjs';
 import { isRealTurnMessage } from '../../runtime/agent/orchestrator/session/compact/user-message-kind.mjs';
 import { realTurnCount as realTurnCountOf } from '../../runtime/agent/orchestrator/session/store-summary-fields.mjs';
 
@@ -44,6 +48,7 @@ function previewOf(s) {
   let preview = isSessionPreviewNoise(rawPreview) ? '' : cleanSessionPreview(rawPreview);
   let messageCount = Math.max(0, Number(s.messageCount) || 0);
   let realTurnCount = realTurnCountOf(s);
+  let incomingTail = Array.isArray(s.incomingTail) ? s.incomingTail : null;
   if (!preview && Array.isArray(s.messages)) {
     realTurnCount = s.messages.filter(isRealTurnMessage).length;
     const msgs = s.messages;
@@ -55,8 +60,9 @@ function previewOf(s) {
       .filter(Boolean);
     preview = userPreviews[0] || '';
     messageCount = msgs.filter((m) => m && (m.role === 'user' || m.role === 'assistant')).length;
+    if (wantsIncomingTail(s.id)) incomingTail = incomingTailOf(msgs);
   }
-  return { preview, messageCount, realTurnCount };
+  return { preview, messageCount, realTurnCount, incomingTail };
 }
 
 /** `working`: this session's turn is running in the daemon right now. */
@@ -70,7 +76,7 @@ export function leadSessionRow(s, working = false) {
   // One-shot `mixdog exec` runs are never resumable conversations.
   if (sourceType === 'exec') return null;
   if (!agentSession && !isLeadShaped(s, owner, sourceType)) return null;
-  const { preview, messageCount, realTurnCount } = previewOf(s);
+  const { preview, messageCount, realTurnCount, incomingTail } = previewOf(s);
   if (!preview && messageCount === 0) return null;
   const lastMessageRoutine = normalizeRoutineProvenance(s.lastMessageRoutine);
   return {
@@ -95,6 +101,10 @@ export function leadSessionRow(s, working = false) {
     model: s.model,
     provider: s.provider,
     messageCount,
+    // Where the messages that arrived (not the user's own, not tool calls)
+    // sit among the counted ones: a bot row's unread pill counts those past
+    // the read cursor. Absent when unknown; clients then show one.
+    ...(incomingTail ? { incomingTail } : {}),
     title: cleanSessionPreview(s.title || '', 100),
     preview,
     // The latest user or assistant line (an agent contact's row shows it).

package/src/session-runtime/lifecycle/teardown.mjs

@@ -8,6 +8,7 @@
 import { SessionClosedError } from '../../runtime/agent/orchestrator/session/manager/session-errors.mjs';
 import { forgetSessionSaveBaseline } from '../../runtime/agent/orchestrator/session/store/save-worker.mjs';
 import { flushAllIndexWrites } from '../services/agent-tool/index-write-queue.mjs';
+import { PROCESS_RESTART_FAILURE } from '../services/agent-tool/worker-index/row-liveness.mjs';
 import { unregisterLiveSession } from '../../runtime/shared/staged-update.mjs';
 import { abortRuntime, closeCanonicalSession, closeOwnSession, dispatchSessionEnd } from './teardown/session-close.mjs';
 import { settleAll, settleDetached, startRuntimeStops, startWorkStops } from './teardown/runtime-stops.mjs';
@@ -111,11 +112,14 @@ export function createTeardown(deps, { ingestSessionIntoMemory, closeSurfaceSess
   function reapWork(reason, scope) {
     if (!scope.teardownReapsWork) return;
     try {
-      // A task that dies for a reason its owner never asked for must still be reported.
+      // A task that dies for a reason its owner never asked for must still be
+      // reported: now for a scoped close; for a process exit (its owner is
+      // closing too) by the next process, which tells the owner of each agent
+      // turn the exit cut off (agent-tool restart-notify).
       cancelBackgroundTasks(
         scope.scopedTeardown
           ? { reason, notify: true, executionSessionId: scope.closingSessionId }
-          : { reason, notify: false }
+          : { reason, notify: false, terminalReason: PROCESS_RESTART_FAILURE }
       );
     } catch {}
   }
@@ -204,7 +208,11 @@ export function createTeardown(deps, { ingestSessionIntoMemory, closeSurfaceSess
       const settled = () => {
         outstandingCloses.delete(closing);
       };
-      closing = new Promise((resolve) => resolve(agentTool.closeAll(reason, {}))).then(settled, settled);
+      // processExit: the workers close, their rows stay for the next process.
+      closing = new Promise((resolve) => resolve(agentTool.closeAll(reason, { processExit: true }))).then(
+        settled,
+        settled
+      );
       outstandingCloses.add(closing);
       try {
         await withTeardownDeadline(closing, CLOSE_ALL_DEADLINE_MS, false);