mixdog 1.3.0 → 1.3.2

package/src/standalone/session-protocol.mjs

@@ -15,6 +15,7 @@ export const SESSION_READ_ACTIONS = Object.freeze([
   'getAgentAvatarImage',
   'getAgentConnectors',
   'getProjectConnectors',
+  'getAgentAlwaysAllowedTools',
   'getAgentPermissions',
   'listConnectors',
   'listConnectorTools',
@@ -45,6 +46,8 @@ export const SESSION_READ_ACTIONS = Object.freeze([
   'getQuotaHistory',
   'getRecapSettings',
   'getSessionTitleSettings',
+  'getLeadAppearance',
+  'getBotOrder',
   'getWebSearchRoute',
   'getSettingsSnapshot',
   'getSystemShell',
@@ -188,6 +191,7 @@ export const SESSION_CONFIGURE_ACTIONS = Object.freeze([
   'setAgentConnectorToolPermission',
   'setProjectConnectorEnabled',
   'setAgentPermission',
+  'recordAgentApprovalAudit',
   'saveLeadPersona',
   'saveLeadAgentBody',
   'setLeadCreated',
@@ -233,6 +237,8 @@ export const SESSION_CONFIGURE_ACTIONS = Object.freeze([
   'setProgressHint',
   'setRecapEnabled',
   'setAiSessionTitles',
+  'setLeadAppearance',
+  'setBotOrder',
   'setRoute',
   'setScheduleEnabled',
   'setWebSearchRoute',
@@ -241,6 +247,7 @@ export const SESSION_CONFIGURE_ACTIONS = Object.freeze([
   'setToolMode',
   'setWebSearchEnabled',
   'setInstructionFiles',
+  'setAutoEffortBase',
   'setWebhookConfig',
   'setWebhookEnabled',
   'setWorkflow',

package/src/standalone/session-service/agent-tree/agent-turns.mjs

@@ -4,6 +4,43 @@
 import { randomUUID } from 'node:crypto';
 import { createAgentChildFactory } from './agent-child.mjs';
 import { partialHandoffTextFromSession } from '../../../runtime/agent/orchestrator/agent-runtime/agent-progress-watchdog.mjs';
+import { attachmentsForIntake } from '../../../runtime/attachments/store.mjs';
+import { artifactLines } from '../../../runtime/shared/handoff-artifacts.mjs';
+import { collectTurnArtifacts, handoffContent, sessionRoots } from '../../../session-runtime/handoff-attachments.mjs';
+
+/** An agent turn's prompt: text, or text with forwarded attachment parts
+ *  (handoff-attachments.mjs), never any other shape. */
+export function agentTurnContent(prompt) {
+  if (!Array.isArray(prompt)) return String(prompt || '');
+  const text = prompt
+    .filter((part) => part?.type === 'text' && !part.attachmentRef)
+    .map((part) => String(part.text || ''))
+    .join('\n');
+  return handoffContent(text, prompt);
+}
+
+/** The prompt row's metadata: a Lead's message, with the files it carries. */
+export function agentTurnTranscriptMeta(content) {
+  const attachments = Array.isArray(content) ? attachmentsForIntake(content) : [];
+  return { sender: 'lead', ...(attachments.length ? { attachments } : {}) };
+}
+
+/** The artifact lines of the turn that began at `messageStart`; [] on any
+ *  failure to read it (the handoff still goes out). */
+async function turnArtifactLines(runtime, messageStart, descriptor) {
+  try {
+    const { messages } = await runtime.readModelMessages(messageStart);
+    const session = runtime.session || descriptor;
+    const { files, omitted } = collectTurnArtifacts(messages, {
+      cwd: descriptor.cwd,
+      roots: sessionRoots(session, descriptor.cwd),
+    });
+    // Text only: the caller forwards these by path (an id in text is never trusted).
+    return artifactLines(files, omitted, { ids: false });
+  } catch {
+    return [];
+  }
+}
 
 export function createAgentTurns({
   registry,
@@ -67,15 +104,16 @@ export function createAgentTurns({
     descriptor.stage = 'running';
     descriptor.updatedAt = Date.now();
     try {
+      const content = agentTurnContent(prompt);
       const options = {
         id: `agent-turn-${randomUUID()}`,
         mode: 'prompt',
         priority: 'next',
         context,
-        transcriptMeta: { sender: 'lead' },
+        transcriptMeta: agentTurnTranscriptMeta(content),
         ...(entry.runtime.isWireSafe === true || typeof onToolResult !== 'function' ? {} : { onToolResult }),
       };
-      const detail = await target.call(entry.runtime, String(prompt || ''), options);
+      const detail = await target.call(entry.runtime, content, options);
       if (detail?.status === 'failed') {
         throw new Error(String(detail.error || 'agent session turn failed'));
       }
@@ -91,7 +129,12 @@ export function createAgentTurns({
         const reason = String(detail?.reason || detail?.error || '').trim();
         throw new Error(`agent turn ${status}${reason ? `: ${reason}` : ''}`);
       }
-      const result = detail?.result || { content: '' };
+      let result = detail?.result || { content: '' };
+      // The files the turn produced reach the owner with its handoff.
+      const files = await turnArtifactLines(entry.runtime, messageStart, descriptor);
+      if (files.length) {
+        result = { ...result, content: [String(result.content || ''), files.join('\n')].join('\n\n') };
+      }
       descriptor.status = 'idle';
       descriptor.stage = 'idle';
       descriptor.lastHandoff = typeof result?.content === 'string' ? result.content : '';

package/src/standalone/session-service/agent-tree.mjs

@@ -10,7 +10,7 @@
 import { createAgentCancellation } from './agent-tree/agent-cancel.mjs';
 import { createAgentRegistry } from './agent-tree/agent-registry.mjs';
 import { createAgentRehydration, lastStoredAgentHandoff } from './agent-tree/agent-rehydrate.mjs';
-import { createAgentTurns } from './agent-tree/agent-turns.mjs';
+import { agentTurnContent, agentTurnTranscriptMeta, createAgentTurns } from './agent-tree/agent-turns.mjs';
 import { randomUUID } from 'node:crypto';
 
 export { SESSION_ID_PATTERN } from './agent-tree/agent-registry.mjs';
@@ -139,12 +139,13 @@ export function createAgentTree({
       const cancelEpoch = registry.assertAdmission(descriptor.id);
       const runtime = sessionOwner(descriptor.id)?.runtime;
       if (!runtime || !stateBusy(runtime.getState())) return null;
-      const accepted = await runtime.submitAsync(String(prompt || ''), {
+      const content = agentTurnContent(prompt);
+      const accepted = await runtime.submitAsync(content, {
         id: `agent-message-${randomUUID()}`,
         mode: 'prompt',
         priority: 'next',
         context,
-        transcriptMeta: { sender: 'lead' },
+        transcriptMeta: agentTurnTranscriptMeta(content),
       });
       if (accepted === false) throw new Error('agent follow-up was not accepted');
       registry.assertAdmission(descriptor.id, cancelEpoch);

package/src/standalone/session-service/session-calls/session-turns.mjs

@@ -12,6 +12,7 @@ import {
 import { providerNativePdf } from '../../../runtime/agent/orchestrator/providers/registry.mjs';
 import { cancelBackgroundTasks } from '../../../runtime/shared/background-tasks.mjs';
 import { isAgentModeSession } from '../../../runtime/agent/orchestrator/session/agent-mode.mjs';
+import { isAgentHomeSessionId } from '../../../runtime/agent/orchestrator/session/agent-home.mjs';
 import { recognisedAgentRoomSlash } from '../../../tui/app/slash-commands.mjs';
 import { promptContentText } from '../../../tui/session/queue-helpers.mjs';
 
@@ -38,6 +39,17 @@ function abortsAgentTurn(id, state, hasAgentSession) {
   );
 }
 
+/** A prompt the user typed: not an agent's send (`sender: 'lead'`), a hidden
+ *  wake, a routine fire or any other runtime-made turn. */
+export function isUserTurn(options = {}) {
+  return (
+    (options.mode || 'prompt') === 'prompt' &&
+    options.kickoff !== true &&
+    options.isMeta !== true &&
+    options.transcriptMeta?.sender !== 'lead'
+  );
+}
+
 export function createSessionTurnCalls(ctx) {
   const { log, readStoredGoal, listStoredActiveGoalSessionIds, hasAgentSession, sessionResult, advanceForCaller } = ctx;
   const { retainUnwatched } = ctx.retention;
@@ -88,6 +100,13 @@ export function createSessionTurnCalls(ctx) {
     const accepted = await Promise.resolve(target.call(entry.runtime, intake.prompt, submissionOptions));
     if (accepted === true) {
       entry.reservedOnly = false;
+      if (isAgentHomeSessionId(id) && isUserTurn(submissionOptions)) {
+        // The user spoke in this agent's home: its round trips with other
+        // sessions count from zero again, so a capped thread wakes again.
+        void import('../../../session-runtime/agent-home-delivery.mjs')
+          .then(({ resetAgentTaskRounds }) => resetAgentTaskRounds(id))
+          .catch((error) => log(`round reset of ${id} failed: ${error?.message || error}`));
+      }
     }
     const step = settleAction(entry, 'headless session submit');
     log(`session submit session=${id} accepted=${accepted === true}`);

package/src/standalone/session-service.mjs

@@ -23,6 +23,7 @@ import { createViewerRegistry } from './session-service/viewers.mjs';
 import { createSessionEntries } from './session-service/entries.mjs';
 import { createSessionCalls } from './session-service/session-calls.mjs';
 import { createQuotaResumeScheduler } from './session-service/quota-resume.mjs';
+import { registerDelegatedApprovalOpener } from '../runtime/shared/delegated-approval-host.mjs';
 
 const EXTERNAL_SESSION_ACTIONS = new Set([
   ...SESSION_READ_ACTION_SET,
@@ -205,6 +206,9 @@ export function createSessionService({
     retainUnwatched: retention.retainUnwatched,
     createSession: calls.createSession,
   });
+  // A sub-agent's approval shows in its top-level chat; one not loaded is
+  // brought up so the copy (and its notifications) appear there.
+  const unregisterApprovalOpener = registerDelegatedApprovalOpener((sessionId) => calls.materializeSession(sessionId));
   const quotaUsableReader = typeof readQuotaUsable === 'function' ? readQuotaUsable : async () => false;
   const quotaResume = quotaResumeStore
     ? createQuotaResumeScheduler({
@@ -219,6 +223,7 @@ export function createSessionService({
   function stop(reason = 'service stop') {
     if (stopPromise) return stopPromise;
     closed = true;
+    unregisterApprovalOpener();
     quotaResume?.stop();
     stopPromise = Promise.resolve().then(async () => {
       try {
@@ -243,6 +248,11 @@ export function createSessionService({
     return Boolean(owner) && retention.stateBusy(owner.runtime?.getState?.());
   }
 
+  /** Whether the runtime hosting `sessionId` shows an approval card waiting on the user. */
+  function liveSessionAwaitingApproval(sessionId) {
+    return Boolean(projection.sessionOwner(sessionId)?.runtime?.getState?.()?.toolApproval);
+  }
+
   /** Show a transcript notice in the hosted runtime of `sessionId` (no turn)
    *  and publish it to its views; false when no runtime hosts it. */
   function pushLiveSessionNotice(sessionId, { text, tone = 'info', ...options } = {}) {
@@ -300,6 +310,7 @@ export function createSessionService({
     methods: {
       ...calls,
       liveSessionBusy,
+      liveSessionAwaitingApproval,
       pushLiveSessionNotice,
       stop,
       startQuotaResume: () => quotaResume?.start(),

package/src/standalone/session-state-projection.mjs

@@ -1,4 +1,6 @@
 import { sanitizeForWire } from './session-wire-values.mjs';
+import { stripAgentMessageEnvelope } from '../runtime/shared/agent-message-envelope.mjs';
+import { transcriptSourceFields } from '../runtime/shared/transcript-metadata.mjs';
 
 /** Immutable source fields keep their wire identity until they actually change.
  * In particular, a live tail must not rebuild the settled transcript or resend
@@ -29,15 +31,23 @@ export function projectSessionState(entry, raw) {
     }
     let cloned;
     if (key === 'queued' && Array.isArray(value)) {
-      cloned = value.map((item) => ({
-        id: item?.id,
-        submittedAt: item?.submittedAt,
-        text: String(item?.displayText ?? item?.text ?? '').slice(0, 2_000),
-        displayText: String(item?.displayText ?? item?.text ?? '').slice(0, 2_000),
-        mode: item?.mode || 'prompt',
-        priority: item?.priority || 'next',
-        ...(Array.isArray(item?.images) && item.images.length ? { images: item.images } : {}),
-      }));
+      cloned = value.map((item) => {
+        // A queued bot message reads like its delivered row: the sender tag
+        // and the message without its envelope.
+        const source = transcriptSourceFields(item?.transcriptMeta);
+        const queuedText = String(item?.displayText ?? item?.text ?? '');
+        const text = (source.fromAgent ? stripAgentMessageEnvelope(queuedText) : queuedText).slice(0, 2_000);
+        return {
+          id: item?.id,
+          submittedAt: item?.submittedAt,
+          text,
+          displayText: text,
+          mode: item?.mode || 'prompt',
+          priority: item?.priority || 'next',
+          ...source,
+          ...(Array.isArray(item?.images) && item.images.length ? { images: item.images } : {}),
+        };
+      });
     } else if (key === 'items' && Array.isArray(value)) {
       const items = entry.itemCache;
       const nextItems = new Map();

package/src/standalone/session-tool-output.mjs

@@ -1,4 +1,6 @@
 import { encodeCatalogCursor } from '../runtime/agent/orchestrator/session/catalog-db/schema.mjs';
+import { UNTRUSTED_NOTE, sessionBotOf } from '../session-runtime/bot-status.mjs';
+import { escapeHarnessTags } from '../runtime/shared/shell-output-summary.mjs';
 import { truncateToolText } from '../runtime/shared/tool-primitives.mjs';
 import { summarizeToolResult } from '../runtime/shared/tool-result-summary.mjs';
 
@@ -6,18 +8,42 @@ import { TOOL_OUTPUT_PAGE_BYTES, TOOL_OUTPUT_TAIL_BYTES } from '../runtime/share
 
 export const SESSION_TOOL_OUTPUT_BYTES = TOOL_OUTPUT_TAIL_BYTES;
 const MESSAGE_TEXT_LIMIT = 2000;
+const LIST_PREVIEW_LIMIT = 100;
 const outputBytes = (value) => Buffer.byteLength(JSON.stringify(value), 'utf8');
 
-/** Keep catalog paging authoritative even when the output budget shortens a page. */
-export function sessionListOutput(page, limit) {
+/** Keep catalog paging authoritative even when the output budget shortens a page.
+ *  `rich` adds the owning bot, last activity, latest line and working state
+ *  (never for a background caller: bot-status.mjs scopedBot). */
+export function sessionListOutput(page, limit, { rich = true } = {}) {
   const raw = page.sessions;
-  const sessions = raw.slice(0, limit).map((row) => ({
-    id: row.id,
-    ...(row.title || row.preview ? { title: truncateToolText(row.title || row.preview, 160) } : {}),
-    ...(row.status ? { status: row.status } : {}),
-    ...(row.cwd ? { cwd: row.cwd } : {}),
-  }));
-  const result = { sessions, nextCursor: page.nextCursor ?? null };
+  const sessions = raw.slice(0, limit).map((row) => {
+    const base = {
+      id: row.id,
+      ...(row.title || row.preview
+        ? { title: escapeHarnessTags(truncateToolText(row.title || row.preview, 160)) }
+        : {}),
+      ...(row.status ? { status: row.status } : {}),
+      ...(row.cwd ? { cwd: row.cwd } : {}),
+    };
+    if (!rich) return base;
+    // The bot it belongs to: its chat, room seat or the task's creator.
+    const bot = sessionBotOf(row);
+    const lastUsedAt = Number(row.lastUsedAt) || 0;
+    const preview = String(row.lastMessagePreview || '').replace(/\s+/g, ' ');
+    return {
+      ...base,
+      ...(bot ? { bot } : {}),
+      ...(lastUsedAt ? { lastUsedAt: new Date(lastUsedAt).toISOString() } : {}),
+      // The latest user or assistant line, quoted data.
+      ...(preview.trim() ? { preview: escapeHarnessTags(truncateToolText(preview, LIST_PREVIEW_LIMIT)) } : {}),
+      ...(row.working === true || row.agentWorking === true ? { working: true } : {}),
+    };
+  });
+  const result = {
+    sessions,
+    nextCursor: page.nextCursor ?? null,
+    ...(sessions.some((row) => row.preview) ? { note: UNTRUSTED_NOTE } : {}),
+  };
   for (;;) {
     if (sessions.length < raw.length && sessions.length) {
       result.nextCursor = encodeCatalogCursor(raw[sessions.length - 1]);

package/src/tui/app/maintenance-pickers/auto-clear-picker.mjs

@@ -3,10 +3,14 @@
 // the Advanced list of provider default idle windows edited as text.
 
 // Lead BP4 messages cache TTL follows autoClear (cache-strategy.mjs
-// resolveLeadMessagesTtl): off or idle>=1h -> 1h, shorter idle -> 5m.
+// resolveLeadMessagesTtl): off or idle>=1h (incl. unlimited) -> 1h, shorter
+// idle -> 5m.
 const HOUR_MS = 60 * 60 * 1000;
+// Typed (and shown) for "never auto-clear"; the runtime stores it as 0.
+const UNLIMITED_INPUT = 'unlimited';
 
-const formatDurationInput = (ms) => {
+const formatDurationInput = (ms, unlimited = false) => {
+  if (unlimited) return UNLIMITED_INPUT;
   const value = Math.max(0, Math.round(Number(ms) || 0));
   if (value > 0 && value % HOUR_MS === 0) return `${value / HOUR_MS}h`;
   if (value > 0 && value % 60_000 === 0) return `${value / 60_000}m`;
@@ -39,7 +43,7 @@ export function createAutoClearPicker({
       label: entry.provider,
       marker: entry.provider === provider ? '✓' : '',
       markerColor: theme.success,
-      meta: `${formatDuration(entry.idleMs)}${entry.custom ? ' custom' : ''}`,
+      meta: `${entry.unlimited ? 'Unlimited' : formatDuration(entry.idleMs)}${entry.custom ? ' custom' : ''}`,
       description: `Default idle window for ${entry.provider}. Enter to edit as text.`,
       _action: 'provider-default',
       _entry: entry,
@@ -66,10 +70,10 @@ export function createAutoClearPicker({
             store.pushNotice('autoclear unavailable', 'warn');
             return;
           }
-          store.pushNotice(
-            next.enabled ? `autoclear on · idle ${formatDuration(next.idleMs)}` : 'autoclear off',
-            'info'
-          );
+          let notice = 'autoclear off';
+          if (next.enabled)
+            notice = next.unlimited ? 'autoclear on · unlimited' : `autoclear on · idle ${formatDuration(next.idleMs)}`;
+          store.pushNotice(notice, 'info');
         })
         .catch((e) => store.pushNotice(`autoclear failed: ${e?.message || e}`, 'error'))
         .finally(settled);
@@ -80,8 +84,8 @@ export function createAutoClearPicker({
       setSettingsPrompt({
         kind: 'autoclear-provider',
         label: `Auto-clear · ${entry.provider}`,
-        hint: `Type a duration like 10m, 1h, or 24h. Empty resets to built-in ${formatDurationInput(entry.builtInMs)}.`,
-        initialValue: formatDurationInput(entry.idleMs),
+        hint: `Type a duration like 10m, 1h, or 24h, or ${UNLIMITED_INPUT} to never auto-clear. Empty resets to built-in ${formatDurationInput(entry.builtInMs, entry.builtInUnlimited)}.`,
+        initialValue: formatDurationInput(entry.idleMs, entry.unlimited),
         provider: entry.provider,
         builtInMs: entry.builtInMs,
         returnTo,
@@ -109,18 +113,20 @@ export function createAutoClearPicker({
       const current = await readCurrent();
       const enabled = current?.enabled !== false;
       const idleMs = Number(current?.idleMs || HOUR_MS);
+      const unlimited = current?.unlimited === true;
       const cacheTtlLabel = !enabled || idleMs >= HOUR_MS ? '1h' : '5m';
       let sourceLabel = `${current?.provider || 'default'} default`;
       if (current?.providerCustom) sourceLabel = `${current.provider} override`;
       else if (current?.custom) sourceLabel = 'global';
+      const clearText = unlimited
+        ? `Never clear idle sessions (${sourceLabel})`
+        : `Clear idle sessions after ${formatDuration(idleMs)} (${sourceLabel})`;
       const items = [
         {
           value: 'toggle',
           label: 'Auto-clear',
           meta: enabled ? 'On' : 'Off',
-          description: enabled
-            ? `Clear idle sessions after ${formatDuration(idleMs)} (${sourceLabel}) · lead cache TTL ${cacheTtlLabel}.`
-            : 'Idle auto-clear disabled.',
+          description: enabled ? `${clearText} · lead cache TTL ${cacheTtlLabel}.` : 'Idle auto-clear disabled.',
           _action: 'toggle',
         },
         {
@@ -132,7 +138,7 @@ export function createAutoClearPicker({
       ];
       own.paint({
         title: 'Auto-clear',
-        description: `Clear idle context after ${enabled ? `${formatDuration(idleMs)} (${sourceLabel})` : 'never'} · lead cache TTL ${cacheTtlLabel}.`,
+        description: `Clear idle context after ${enabled && !unlimited ? `${formatDuration(idleMs)} (${sourceLabel})` : 'never'} · lead cache TTL ${cacheTtlLabel}.`,
         help: '↑/↓ Select · ←/→ Toggle On/Off · Enter Open/Toggle · Esc Close',
         indexMode: 'always',
         labelWidth: 10,

package/src/tui/app/settings-picker/settings-rows.mjs

@@ -139,9 +139,9 @@ export function buildSettingsItems({
     {
       value: 'autoclear',
       label: 'Auto-clear',
-      meta: autoClearEnabled ? `On (${formatDuration(autoClear.idleMs)})` : 'Off',
+      meta: autoClearEnabled ? `On (${autoClear.unlimited ? 'Unlimited' : formatDuration(autoClear.idleMs)})` : 'Off',
       description: autoClearEnabled
-        ? `Clear idle sessions after ${formatDuration(autoClear.idleMs)}${autoClearSource}. Enter for options.`
+        ? `${autoClear.unlimited ? 'Never clear idle sessions' : `Clear idle sessions after ${formatDuration(autoClear.idleMs)}`}${autoClearSource}. Enter for options.`
         : 'Idle auto-clear disabled. Enter for options.',
       _action: 'autoclear',
     },

package/src/tui/app/slash-commands.mjs

@@ -30,7 +30,7 @@ export const SLASH_COMMANDS = [
   {
     name: 'autoclear',
     usage: '/autoclear',
-    params: '[on|off|duration]',
+    params: '[on|off|duration|unlimited]',
     description: 'Reduce cache-miss cost after long idle gaps',
   },
   { name: 'resume', usage: '/resume', params: '[id]', description: 'Resume a saved chat' },

package/src/tui/app/usage-context-panels/context-model.mjs

@@ -35,8 +35,12 @@ function compactElapsed(value) {
   return `${Math.max(1, Math.ceil(n / 1000))}s`;
 }
 
+function compactionRunning(compaction) {
+  return compaction.inProgress === true || compaction.lastStage === 'compacting';
+}
+
 function compactionState(compaction) {
-  const compactRunning = compaction.inProgress === true || compaction.lastStage === 'compacting';
+  const compactRunning = compactionRunning(compaction);
   const autoClearFailed = compaction.lastStage === 'auto_clear_failed' || !!compaction.lastClearCompactError;
   const autoClearStage = compaction.lastStage === 'auto_clear' || compaction.lastClearAt;
   const compactInterrupted = compaction.lastStage === 'interrupted';
@@ -99,7 +103,9 @@ function contextMetrics({ toolsStatus, mcpStatus, skillsStatus, pluginsStatus, c
   );
   const cacheDenom = Number(usage.lastContextTokens || 0) || cachedRead + freshInput + cacheWrite;
   const compactState = compactionState(compaction);
-  const compactDuration = compactElapsed(compaction.lastDurationMs);
+  // lastDurationMs belongs to the previous, finished compaction: a running
+  // one shows no duration rather than one that reads as its elapsed time.
+  const compactDuration = compactionRunning(compaction) ? '' : compactElapsed(compaction.lastDurationMs);
   return {
     tools,
     mcp,