mixdog 1.3.1 → 1.3.3

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

@@ -1,12 +1,15 @@
 /**
- * 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
+ * Held requests. A schedule or webhook run never asks and never holds (its
+ * saved routine is the user's grant; human-gate/run-policy.mjs), so only group
+ * room members use held requests: with no
+ * approval UI attached, 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
@@ -22,6 +25,7 @@ import {
   setUnattendedApprovalPort,
 } from '../runtime/agent/orchestrator/session/human-gate/gate.mjs';
 import { normalizeHumanResponse } from '../runtime/agent/orchestrator/session/human-gate/requests.mjs';
+import { runStampOf } from '../runtime/agent/orchestrator/session/human-gate/delegation.mjs';
 import { normalizeHeldRequest } from '../runtime/agent/orchestrator/session/human-gate/held-message.mjs';
 import {
   notifyHeldRequest,
@@ -29,14 +33,6 @@ import {
   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 +50,21 @@ export function markUnattendedRun(sessionId, { kind, agentId, name = '' }) {
   };
 }
 
-/** The unattended run `sessionId` belongs to, or null for an attended session. */
+/** The unattended run `sessionId` is, or null for an attended session: a
+ *  marked schedule/webhook run, a room member's own session, or work a
+ *  schedule/webhook run started (a sub-agent at any depth, a task session) by
+ *  the `run` stamped on its own record when it was created
+ *  (human-gate/delegation.mjs) — however long ago that run ended, across
+ *  restarts. Work a bot's attended chat or a room member started is no run. */
 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 stamped = runStampOf(sessionId);
+  return stamped && (stamped.kind === 'schedule' || stamped.kind === 'webhook') && stamped.agentId
+    ? { kind: stamped.kind, agentId: String(stamped.agentId), name: String(stamped.name || '') }
+    : null;
 }
 
 /**
@@ -98,9 +103,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 +116,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 +125,12 @@ 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: '' };
+    // The scopes the gate offered (gate.mjs): the bot's own grant, or once.
+    const remember = Array.isArray(request.remember) && request.remember.length ? request.remember : ['once'];
     const id = `held_${randomUUID()}`;
-    const ms = typeof expiryMs === 'function' ? expiryMs() : expiryMs;
     const held = normalizeHeldRequest({
       id,
       status: 'pending',
@@ -145,12 +148,12 @@ export function createHeldRequests({
             details: request.outbound?.details,
           }
         : {}),
-      remember: request.remember || ['once'],
+      remember,
       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 };
     const gate = {
+      remember,
       agentId: run.agentId,
       kind: held.kind,
       ...(held.action ? { action: held.action } : {}),
@@ -167,17 +170,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 +212,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,18 +7,21 @@ 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 { worktreeCallerScope } from '../services/worktree-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
@@ -42,9 +45,6 @@ export function createWorkspaceToolHandlers({
   getLifecycleApi = () => null,
   executeSessionControl = null,
 }) {
-  // The Lead's own worktree, on the user's request: the same authority the
-  // branch chip menu drives, tolerating the calling turn but nothing else
-  // running (workers, background shells).
   const assertLead = (action, callerCtx) => {
     const callerSessionId = callerCtx?.callerSessionId || rt.session?.id || null;
     if (!rt.session?.id || callerSessionId !== rt.session.id) {
@@ -53,24 +53,6 @@ export function createWorkspaceToolHandlers({
     return rt.session.id;
   };
 
-  const worktreeAction = async (action, args, callerCtx) => {
-    const workspace = getWorkspaceApi();
-    if (!workspace) throw new Error(`session: ${action} is unavailable in this runtime`);
-    assertLead(action, callerCtx);
-    let result;
-    if (action === 'merge-worktree') {
-      result = await workspace.mergeWorkspace({ confirmed: true }, { ownTurn: true });
-    } else if (action === 'remove-worktree') {
-      result = await workspace.removeWorktree({ force: args?.force === true }, { ownTurn: true });
-    } else if (action === 'list-worktrees') {
-      result = await workspace.listWorktrees();
-    } else {
-      result = await workspace.pruneWorktrees();
-    }
-    return JSON.stringify({ action, cwd: rt.currentCwd, result }, null, 2);
-  };
-
-  const WORKTREE_ACTIONS = new Set(['merge-worktree', 'remove-worktree', 'list-worktrees', 'prune-worktrees']);
   const SIDEBAR_ACTIONS = new Set(['favorite', 'archive']);
 
   // Sidebar flags only (the desktop's favorite/archive metadata).
@@ -89,7 +71,10 @@ 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) {
@@ -117,14 +102,23 @@ export function createWorkspaceToolHandlers({
       return JSON.stringify(
         await executeSessionControl(
           { ...rest, action },
-          { callerSessionId, callerAgentId, callerCwd, ...(attachmentParts.length ? { attachmentParts } : {}) }
+          {
+            callerSessionId,
+            callerAgentId,
+            callerCwd,
+            ...(action === 'send' || action === 'create' ? { callerHop: turnHopOf(rt.session) } : {}),
+            // Whether a create may provision a worktree (worktree-access.mjs).
+            ...(action === 'create' ? { callerScope: worktreeCallerScope(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)) {
       throw new Error(`session: action=${action} only applies to the current session`);
     }
-    if (WORKTREE_ACTIONS.has(action)) return worktreeAction(action, args, callerCtx);
     if (SIDEBAR_ACTIONS.has(action)) return sidebarAction(action, args, callerCtx);
     let currentCwd = callerCwd;
     if (action === 'status' || action === 'list-projects' || action === 'set-project') assertLead(action, callerCtx);
@@ -252,6 +246,10 @@ export function createWorkspaceToolHandlers({
         clientHostPid: callerCtx?.clientHostPid || rt.session?.clientHostPid || process.pid,
         signal: callerCtx?.signal,
         notifyFn: notifyFnForSession(callerSessionId),
+        // The jobs it starts report back at this turn's bot-chain hop (bot-hops.mjs).
+        ...(turnHopOf(rt.session) > 0 ? { hop: turnHopOf(rt.session) } : {}),
+        // 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);