mixdog 1.3.2 → 1.3.3

package/src/tui/session/session-api/intake/rewind.mjs

@@ -1,13 +1,17 @@
 // Message selector ("jump back to a previous message"): rewind the
 // conversation to just before a user prompt and hand its text back for
 // editing. Idle-only — a live turn must be interrupted first.
+import { restorableAttachmentsFromPrompt } from '../../../../runtime/attachments/prompt-restore.mjs';
 import { promptHistoryWithout } from '../../prompt-history.mjs';
+import { hydrateTolerantly } from './abort.mjs';
 
 export function createRewindAction(bag) {
   const { runtime, getState, set, flushEmitImmediate, replaceItems, syncContextStats } = bag;
 
   return {
-    rewindToItem: async (itemId) => {
+    // `restoreFiles: false` is a composer that cannot hold PDF/Office file
+    // parts (the terminal one): a prompt carrying any is refused untouched.
+    rewindToItem: async (itemId, { restoreFiles = true } = {}) => {
       const target = String(itemId ?? '').trim();
       if (!target) return null;
       if (getState().busy || getState().commandBusy) return null;
@@ -19,8 +23,31 @@ export function createRewindAction(bag) {
       if (!text) return null;
       set({ commandBusy: true });
       try {
-        const rewound = await runtime.rewindMessages?.({ text });
-        if (!rewound) return null;
+        // Matched by the row's stable message id (the stored prompt is the
+        // expanded text); rows without one fall back to the text.
+        const messageId = String(items[index]?.messageId || '');
+        const rewindOptions = { text, ...(messageId ? { messageId } : {}) };
+        // Resolve the prompt and build the whole restore payload BEFORE any
+        // history changes: a refusal or an attachment read error then leaves the
+        // model history and the transcript both untouched.
+        const preview = await runtime.rewindMessages?.({ ...rewindOptions, dryRun: true });
+        if (!preview) return null;
+        // The stored prompt's attachment references become the restore payload
+        // the abort/queue restores use (pastedTexts / pastedImages / file parts).
+        const content = preview.message?.content;
+        if (!restoreFiles && Array.isArray(content) && content.some((part) => part?.type === 'file')) {
+          throw new Error(
+            'this message has PDF/Office attachments the terminal composer cannot restore; edit it in the desktop app'
+          );
+        }
+        const refs = restorableAttachmentsFromPrompt(content, text);
+        const attachments = hydrateTolerantly(refs.pastedImages, refs.pastedTexts, content);
+        // Refused when the history changed since the preview.
+        const rewound = await runtime.rewindMessages?.({
+          ...rewindOptions,
+          ...(preview.historyMarker ? { expectedHistoryMarker: preview.historyMarker } : {}),
+        });
+        if (!rewound) throw new Error('the conversation changed; select the message again');
         set({
           items: replaceItems(items.slice(0, index), {
             preserveSpill: true,
@@ -36,7 +63,15 @@ export function createRewindAction(bag) {
         syncContextStats({ allowEstimated: true });
         set({ stats: { ...getState().stats } });
         flushEmitImmediate?.();
-        return { text, removed: items.length - index, messages: rewound.removed };
+        return {
+          text,
+          removed: items.length - index,
+          messages: rewound.removed,
+          ...(attachments.pastedImages ? { pastedImages: attachments.pastedImages } : {}),
+          ...(attachments.pastedTexts ? { pastedTexts: attachments.pastedTexts } : {}),
+          ...(attachments.content ? { content: attachments.content } : {}),
+          ...(attachments.notice ? { notice: attachments.notice } : {}),
+        };
       } finally {
         set({ commandBusy: false });
       }

package/src/tui/session/session-api/routes-agent-definitions.mjs

@@ -55,6 +55,7 @@ export function createAgentDefinitionApi(runtime) {
     saveLeadAgentBody: async (text) => runtime.saveLeadAgentBody?.(text) ?? '',
     getLeadStatus: () =>
       runtime.getLeadStatus?.() ?? { created: null, name: '', avatar: null, homeChatted: false, route: null },
+    getLeadHomeRoute: () => runtime.getLeadHomeRoute?.() ?? null,
     saveLeadIdentity: async (payload) => runtime.saveLeadIdentity?.(payload) ?? null,
     setLeadCreated: async (created, description) => runtime.setLeadCreated?.(created, description) ?? null,
     saveAgentDefinition: async (payload, options) => runtime.saveAgentDefinition?.(payload, options) ?? null,

package/src/tui/session/tool-approval.mjs

@@ -96,17 +96,14 @@ export function createToolApproval({ getState, set, nextId, getDisposed, timeout
   // Settle one entry: drop its timeout, then hand the waiter its answer. The
   // resolve stays guarded — a waiter whose caller already went away must never
   // take the rest of the queue down with it.
-  function settleToolApproval(entry, approved, reason, answers, reply, extra, device = '', forwarded = false) {
+  function settleToolApproval(entry, approved, reason, answers, reply, extra, device = '') {
     if (entry?.timer) clearTimeout(entry.timer);
     const result = { approved, reason };
     if (answers !== undefined) result.answers = answers;
     if (reply !== undefined) result.reply = reply;
-    // A human-kind request answers with its canonical response (never a value),
-    // judged against what the answering place offered: this queue's own view,
-    // or — answered on its copy — the full request the copy already narrowed.
-    const answered = forwarded ? entry?.full || entry?.request : entry?.request;
-    if (answered?.remember) {
-      Object.assign(result, normalizeHumanResponse(answered, approved, extra));
+    // A human-kind request answers with its canonical response (never a value).
+    if (entry?.request?.remember) {
+      Object.assign(result, normalizeHumanResponse(entry.request, approved, extra));
       if (device) result.device = device;
     }
     if (extra?.timedOut === true) result.timedOut = true;
@@ -120,28 +117,15 @@ export function createToolApproval({ getState, set, nextId, getDisposed, timeout
    *  owner had already settled it. */
   function forwardToOwner(entry, approved, reason, device, answers, reply, extra) {
     try {
-      return entry.mirror.answer(approved, reason, device, answers, reply, onlyOffered(entry.request, extra)) === true;
+      return entry.mirror.answer(approved, reason, device, answers, reply, extra) === true;
     } catch {
       return false;
     }
   }
-  /** `request` as this session shows it: a remembering scope is offered only
-   *  in the one session the request names for it (`rememberAt`, the bot's own
-   *  chat); everywhere else — and when it names none — it asks once. */
-  function viewFor(request) {
-    if (!Array.isArray(request?.remember) || request.remember.length <= 1) return request;
-    const here = ownSessionId();
-    return here && request.rememberAt === here ? request : { ...request, remember: ['once'] };
-  }
-  /** `extra` without a remember scope `view` did not offer. */
-  function onlyOffered(view, extra) {
-    if (!extra || extra.remember === undefined) return extra;
-    return (view?.remember || ['once']).includes(extra.remember) ? extra : { ...extra, remember: 'once' };
-  }
   function offerDelegatedApproval(delegated) {
     if (getDisposed() || delegated.sessionId !== ownSessionId()) return;
     if (activeToolApproval?.id === delegated.id || toolApprovalQueue.some((entry) => entry.id === delegated.id)) return;
-    toolApprovalQueue.push({ id: delegated.id, request: viewFor(delegated.request), mirror: delegated, timer: null });
+    toolApprovalQueue.push({ id: delegated.id, request: delegated.request, mirror: delegated, timer: null });
     presentNextToolApproval();
   }
   function withdrawDelegatedCopy(id, result) {
@@ -183,8 +167,7 @@ export function createToolApproval({ getState, set, nextId, getDisposed, timeout
     device = '',
     answers = undefined,
     reply = undefined,
-    extra = undefined,
-    { forwarded = false } = {}
+    extra = undefined
   ) {
     const targetId = String(id || '');
     if (activeToolApproval && activeToolApproval.id === targetId) {
@@ -200,16 +183,7 @@ export function createToolApproval({ getState, set, nextId, getDisposed, timeout
       if (entry.mirror) {
         accepted = forwardToOwner(entry, approved, reason, device, answers, reply, extra);
       } else {
-        settleToolApproval(
-          entry,
-          approved === true,
-          String(reason || ''),
-          answers,
-          reply,
-          extra,
-          String(device || ''),
-          forwarded
-        );
+        settleToolApproval(entry, approved === true, String(reason || ''), answers, reply, extra, String(device || ''));
       }
       presentNextToolApproval();
       return accepted;
@@ -218,16 +192,7 @@ export function createToolApproval({ getState, set, nextId, getDisposed, timeout
     if (index >= 0) {
       const [entry] = toolApprovalQueue.splice(index, 1);
       if (entry.mirror) return forwardToOwner(entry, approved, reason, device, answers, reply, extra);
-      settleToolApproval(
-        entry,
-        approved === true,
-        String(reason || ''),
-        answers,
-        reply,
-        extra,
-        String(device || ''),
-        forwarded
-      );
+      settleToolApproval(entry, approved === true, String(reason || ''), answers, reply, extra, String(device || ''));
       return true;
     }
     return false;
@@ -265,9 +230,7 @@ export function createToolApproval({ getState, set, nextId, getDisposed, timeout
         full.chain = surface.chain;
         full.surfaceSessionId = surface.sessionId;
       }
-      // `request` is what this session shows (and accepts answers against);
-      // `full` what the copy in the top-level chat is made from.
-      const entry = { id, request: viewFor(full), full, resolve, timer: null, delegated: Boolean(surface) };
+      const entry = { id, request: full, resolve, timer: null, delegated: Boolean(surface) };
       toolApprovalQueue.push(entry);
       armToolApprovalTimeout(entry);
       presentNextToolApproval();
@@ -277,7 +240,7 @@ export function createToolApproval({ getState, set, nextId, getDisposed, timeout
           sessionId: surface.sessionId,
           request: full,
           answer: (approved, reason, device, answers, reply, extra) =>
-            finishToolApproval(id, approved, reason, device, answers, reply, extra, { forwarded: true }),
+            finishToolApproval(id, approved, reason, device, answers, reply, extra),
         });
       }
     });

package/src/session-runtime/room-member-gate.mjs

@@ -1,61 +0,0 @@
-// A group-room member's tool calls (session/agent-room.mjs). Reads run freely;
-// anything that can change files or state asks the user through the ordinary
-// approval flow, whatever the agent's own permission or hook rules say — even
-// an agent that normally runs auto-approved. A hook's deny still wins.
-// Opening a task session (`session create`) runs as freely as in the agent's
-// home thread: it changes nothing itself, and the task session is the user's
-// own coding Lead, whose every side effect follows its usual approval rules.
-import { analyzeShellCommandEffects } from '../runtime/agent/orchestrator/tools/builtin/shell-analysis.mjs';
-
-const READ_ONLY_TOOLS = new Set([
-  'read',
-  'grep',
-  'glob',
-  'find',
-  'list',
-  'code_graph',
-  'load_tool',
-  'skill',
-  'Skill',
-  'recall',
-  'search_memories',
-  'web_search',
-  'web_fetch',
-  'local_fetch',
-  'image_fetch',
-  'ask_user',
-]);
-
-export const ROOM_APPROVAL_REASON = 'Group-room members need your approval before changing anything.';
-
-/** Whether `name(args)` only reads: a read-only tool, or a shell command whose
- *  every stage the shell analysis classifies as non-mutating. */
-export async function isReadOnlyRoomCall({ name, args, cwd }, analyze = analyzeShellCommandEffects) {
-  if (READ_ONLY_TOOLS.has(name)) return true;
-  if (name !== 'shell' || typeof args?.command !== 'string') return false;
-  try {
-    return (await analyze(args.command, cwd))?.mutationMode === 'none';
-  } catch {
-    return false;
-  }
-}
-
-/** Whether `name(args)` opens a task session (session create). */
-export function isTaskSessionCreate({ name, args }) {
-  return (
-    name === 'session' &&
-    String(args?.action ?? '')
-      .trim()
-      .toLowerCase() === 'create'
-  );
-}
-
-/** The PreToolUse decision for a room member's call: the hook's own `decision`
- *  when it denies, the call only reads, or it opens a task session; otherwise
- *  an approval ask that keeps any rewrite the hook made. */
-export async function roomMemberToolDecision(call, decision, analyze) {
-  const action = String(decision?.action || decision?.decision || '').toLowerCase();
-  if (action === 'deny' || action === 'block') return decision;
-  if (isTaskSessionCreate(call) || (await isReadOnlyRoomCall(call, analyze))) return decision;
-  return { ...(decision && typeof decision === 'object' ? decision : {}), action: 'ask', reason: ROOM_APPROVAL_REASON };
-}