mixdog 0.9.11 → 0.9.12

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mixdog",
-  "version": "0.9.11",
+  "version": "0.9.12",
   "private": false,
   "type": "module",
   "description": "Standalone mixdog coding-agent CLI/TUI workspace.",

package/src/mixdog-session-runtime.mjs

@@ -216,6 +216,7 @@ import {
   TOOL_SEARCH_TOOL,
   CWD_TOOL,
   SKILL_TOOL,
+  SESSION_MANAGE_TOOL,
   LEAD_DISALLOWED_TOOLS,
   applyStandaloneToolDefaults,
 } from './session-runtime/tool-defs.mjs';
@@ -480,6 +481,9 @@ export async function createMixdogSessionRuntime({
   let sessionCreatePromise = null;
   let currentCwd = cwd;
   let sessionNeedsCwdRefresh = false;
+  // session_manage tool: reset request scheduled by the model mid-turn,
+  // consumed by the TUI engine at turn end ('clear' | 'compact_clear').
+  let pendingSessionReset = null;
   let closeRequested = false;
   const warmupTimers = {
     providerSetupWarmupTimer: null,
@@ -922,6 +926,7 @@ export async function createMixdogSessionRuntime({
     TOOL_SEARCH_TOOL,
     SKILL_TOOL,
     CWD_TOOL,
+    SESSION_MANAGE_TOOL,
     EXPLORE_TOOL,
     ...(searchToolDefs?.TOOL_DEFS || []).filter((tool) => tool?.name === 'search' || tool?.name === 'web_fetch'),
     ...(memoryToolDefs?.TOOL_DEFS || []).filter((tool) => tool?.name === 'recall' || tool?.name === 'memory'),
@@ -1018,6 +1023,29 @@ export async function createMixdogSessionRuntime({
         }
         return JSON.stringify({ cwd: currentCwd, sessionId: session?.id || null }, null, 2);
       }
+      if (name === 'session_manage') {
+        // Lead/owner sessions only: an agent worker resetting its own
+        // transcript mid-task would corrupt the delegation contract, and it
+        // must never reach the owner conversation either.
+        const callerSessionId = callerCtx?.callerSessionId || null;
+        if (callerSessionId && session?.id && callerSessionId !== session.id) {
+          throw new Error('session_manage: only the lead session may reset the conversation');
+        }
+        if (!session?.id) throw new Error('session_manage: no active session');
+        const action = clean(args?.action).toLowerCase();
+        if (action !== 'clear' && action !== 'compact_clear') {
+          throw new Error(`session_manage: unknown action "${action}" (use clear | compact_clear)`);
+        }
+        // Never clear mid-turn — the loop is still reading the transcript.
+        // Schedule and let the TUI engine consume it at turn end (same
+        // boundary the idle auto-clear uses).
+        // Pin to the current session id so a resume/new-session between
+        // scheduling and consumption can never clear the wrong conversation.
+        pendingSessionReset = { action, sessionId: session.id };
+        return action === 'clear'
+          ? 'Session reset scheduled: full clear will run when this turn ends. All prior context will be gone.'
+          : 'Session reset scheduled: the conversation will be summarized (compact) and cleared when this turn ends; key context carries forward in the summary.';
+      }
       if (name === 'Skill') {
         return skillToolContent(args?.name);
       }
@@ -2518,6 +2546,16 @@ export async function createMixdogSessionRuntime({
       invalidateContextStatusCache();
       return true;
     },
+    // session_manage tool handoff: the engine polls this at turn end and, if
+    // set, runs the same clear path the idle auto-clear uses. One-shot read.
+    consumePendingSessionReset() {
+      const pending = pendingSessionReset;
+      pendingSessionReset = null;
+      if (!pending) return null;
+      // Session changed since scheduling (resume / new session) — drop it.
+      if (!session?.id || pending.sessionId !== session.id) return null;
+      return pending.action;
+    },
     async compact(options = {}) {
       if (!session?.id) return null;
       if (activeTurnCount > 0) {

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

@@ -66,6 +66,7 @@ export const DEFERRED_DEFAULT_LEAD_TOOLS = Object.freeze([
   'search',
   'web_fetch',
   'cwd',
+    'session_manage',
   'Skill',
   'tool_search',
 ]);

package/src/session-runtime/tool-defs.mjs

@@ -69,6 +69,34 @@ export const SKILL_TOOL = {
   },
 };
 
+// Owner-directed session reset tool. `clear` mirrors /clear (full wipe);
+// `compact_clear` mirrors the auto-clear path (summarize via the configured
+// compactType, then reset — context carries forward in the summary). The
+// reset is SCHEDULED: it runs when the current turn ends, never mid-turn,
+// because the live transcript is still feeding the loop. Lead-session only;
+// the runtime executor rejects agent-worker callers.
+export const SESSION_MANAGE_TOOL = {
+  name: 'session_manage',
+  title: 'Session Manage',
+  annotations: {
+    title: 'Session Manage',
+    readOnlyHint: false,
+    destructiveHint: true,
+    idempotentHint: false,
+    openWorldHint: false,
+    agentHidden: true,
+  },
+  description: 'Reset this conversation on explicit user request. action=clear wipes all context (like /clear); action=compact_clear summarizes first and carries context forward (auto-clear style). Applies when the current turn ends.',
+  inputSchema: {
+    type: 'object',
+    properties: {
+      action: { type: 'string', enum: ['clear', 'compact_clear'], description: 'clear = full wipe; compact_clear = summarize then reset.' },
+    },
+    required: ['action'],
+    additionalProperties: false,
+  },
+};
+
 export const LEAD_DISALLOWED_TOOLS = Object.freeze([]);
 export const AGENT_HIDDEN_WRAPPER_TOOLS = new Set([]);
 

package/src/tui/dist/index.mjs

@@ -23097,6 +23097,16 @@ async function createEngineSession({
           restorable: nonEditable.length === 0,
           requeueOnAbort: nonEditable
         });
+        const scheduledReset = runtime.consumePendingSessionReset?.();
+        if ((scheduledReset === "clear" || scheduledReset === "compact_clear") && turnStatus !== "cancelled" && !state.commandBusy) {
+          await performSessionClear({
+            verb: scheduledReset === "clear" ? "Clearing conversation" : "Compacting and clearing conversation",
+            doneLabel: scheduledReset === "clear" ? "Session cleared" : "Session compacted and cleared",
+            skipLabel: "Session reset skipped",
+            surface: "session-manage",
+            useCompaction: scheduledReset === "compact_clear"
+          });
+        }
         if (turnStatus === "cancelled" && pending.length === 0) break;
       }
     } finally {
@@ -23140,14 +23150,26 @@ async function createEngineSession({
       if (!activityAt) lastUserActivityAt = now;
       return false;
     }
+    return performSessionClear({
+      verb: "Auto-clearing idle conversation",
+      doneLabel: "Auto-clear complete",
+      skipLabel: "Auto-clear skipped",
+      surface: "auto-clear",
+      useCompaction: true
+    });
+  }
+  async function performSessionClear({ verb, doneLabel, skipLabel, surface, useCompaction }) {
     autoClearRunning = true;
     const startedAt2 = Date.now();
-    set({ commandStatus: { active: true, verb: "Auto-clearing idle conversation", startedAt: startedAt2, mode: "auto-clear" } });
+    set({ commandBusy: true, commandStatus: { active: true, verb, startedAt: startedAt2, mode: "auto-clear" } });
     try {
       await new Promise((resolve5) => setTimeout(resolve5, 0));
-      const compaction = runtime.getCompactionSettings();
-      const compactType = compaction.compactType || compaction.type;
-      await runtime.clear({ compactType, requireCompactSuccess: !!compactType });
+      let compactType = null;
+      if (useCompaction) {
+        const compaction = runtime.getCompactionSettings();
+        compactType = compaction.compactType || compaction.type || null;
+      }
+      await runtime.clear(compactType ? { compactType, requireCompactSuccess: true } : {});
       resetStats();
       clearUiActivityBeforeContextSync();
       syncContextStats({ allowEstimated: true });
@@ -23164,24 +23186,24 @@ async function createEngineSession({
       pushItem({
         kind: "statusdone",
         id: nextId(),
-        label: "Auto-clear complete",
+        label: doneLabel,
         detail: formatElapsedSeconds(Date.now() - startedAt2)
       });
       return true;
     } catch (error) {
-      const message = presentErrorText(error, { surface: "auto-clear" });
+      const message = presentErrorText(error, { surface });
       pushItem({
         kind: "statusdone",
         id: nextId(),
-        label: "Auto-clear skipped",
+        label: skipLabel,
         detail: `conversation kept \xB7 ${message}`
       });
-      pushNotice(`auto-clear skipped: ${message}`, "error");
+      pushNotice(`${surface} skipped: ${message}`, "error");
       return false;
     } finally {
       lastUserActivityAt = Date.now();
       autoClearRunning = false;
-      set({ commandStatus: null });
+      set({ commandBusy: false, commandStatus: null });
       void drain();
     }
   }
@@ -23278,7 +23300,7 @@ async function createEngineSession({
     },
     submit: (text, options = {}) => {
       const t = promptDisplayText(text, options).trim();
-      if (!t || state.commandBusy) return false;
+      if (!t) return false;
       const mode = options.mode || "prompt";
       const priority = options.priority;
       const queueOptions = {
@@ -23287,11 +23309,12 @@ async function createEngineSession({
         displayText: promptDisplayText(text, options),
         priority
       };
-      if (state.busy) {
+      if (autoClearRunning) {
         enqueue(text, queueOptions);
         return true;
       }
-      if (autoClearRunning) {
+      if (state.commandBusy) return false;
+      if (state.busy) {
         enqueue(text, queueOptions);
         return true;
       }

package/src/tui/engine.mjs

@@ -1624,6 +1624,24 @@ export async function createEngineSession({
           restorable: nonEditable.length === 0,
           requeueOnAbort: nonEditable,
         });
+        // session_manage tool: the model scheduled a reset during this turn.
+        // Run it now, at the turn boundary — same clear body as auto-clear.
+        // Cancelled/interrupted turns drop the reset (consume + discard): the
+        // user aborted the turn that asked for it, so the destructive clear
+        // must not fire. commandBusy guards against a concurrent session
+        // command (resume/new) racing the async clear.
+        const scheduledReset = runtime.consumePendingSessionReset?.();
+        if ((scheduledReset === 'clear' || scheduledReset === 'compact_clear')
+          && turnStatus !== 'cancelled'
+          && !state.commandBusy) {
+          await performSessionClear({
+            verb: scheduledReset === 'clear' ? 'Clearing conversation' : 'Compacting and clearing conversation',
+            doneLabel: scheduledReset === 'clear' ? 'Session cleared' : 'Session compacted and cleared',
+            skipLabel: 'Session reset skipped',
+            surface: 'session-manage',
+            useCompaction: scheduledReset === 'compact_clear',
+          });
+        }
         // If the user re-submits the reclaimed prompt while the cancelled turn
         // is still unwinding, enqueue() cannot start another drain because this
         // drain loop is still active. Continue when pending work appeared during
@@ -1682,18 +1700,40 @@ export async function createEngineSession({
       if (!activityAt) lastUserActivityAt = now;
       return false;
     }
+    return performSessionClear({
+      verb: 'Auto-clearing idle conversation',
+      doneLabel: 'Auto-clear complete',
+      skipLabel: 'Auto-clear skipped',
+      surface: 'auto-clear',
+      useCompaction: true,
+    });
+  }
+
+  // Shared clear body for idle auto-clear and the session_manage tool.
+  // useCompaction=true mirrors auto-clear (summarize via configured
+  // compactType, context carries forward); false is a plain /clear wipe.
+  async function performSessionClear({ verb, doneLabel, skipLabel, surface, useCompaction }) {
     autoClearRunning = true;
     const startedAt = Date.now();
-    set({ commandStatus: { active: true, verb: 'Auto-clearing idle conversation', startedAt, mode: 'auto-clear' } });
+    // commandBusy blocks concurrent session commands (resume/newSession/
+    // setModel) AND new submits for the duration of the async clear — the
+    // clear swaps the live session object, so racing commands could act on
+    // the wrong session.
+    set({ commandBusy: true, commandStatus: { active: true, verb, startedAt, mode: 'auto-clear' } });
     try {
       // Give Ink one event-loop turn to paint the auto-clear status before the
       // clear/compact path starts doing synchronous session/transcript work.
       // Without this, long idle clears can look like a frozen prompt followed by
       // an already-complete status row.
       await new Promise((resolve) => setTimeout(resolve, 0));
-      const compaction = runtime.getCompactionSettings();
-      const compactType = compaction.compactType || compaction.type;
-      await runtime.clear({ compactType, requireCompactSuccess: !!compactType });
+      let compactType = null;
+      if (useCompaction) {
+        const compaction = runtime.getCompactionSettings();
+        compactType = compaction.compactType || compaction.type || null;
+      }
+      await runtime.clear(compactType
+        ? { compactType, requireCompactSuccess: true }
+        : {});
       resetStats();
       clearUiActivityBeforeContextSync();
       syncContextStats({ allowEstimated: true });
@@ -1710,24 +1750,24 @@ export async function createEngineSession({
       pushItem({
         kind: 'statusdone',
         id: nextId(),
-        label: 'Auto-clear complete',
+        label: doneLabel,
         detail: formatElapsedSeconds(Date.now() - startedAt),
       });
       return true;
     } catch (error) {
-      const message = presentErrorText(error, { surface: 'auto-clear' });
+      const message = presentErrorText(error, { surface });
       pushItem({
         kind: 'statusdone',
         id: nextId(),
-        label: 'Auto-clear skipped',
+        label: skipLabel,
         detail: `conversation kept · ${message}`,
       });
-      pushNotice(`auto-clear skipped: ${message}`, 'error');
+      pushNotice(`${surface} skipped: ${message}`, 'error');
       return false;
     } finally {
       lastUserActivityAt = Date.now();
       autoClearRunning = false;
-      set({ commandStatus: null });
+      set({ commandBusy: false, commandStatus: null });
       void drain();
     }
   }
@@ -1827,7 +1867,7 @@ export async function createEngineSession({
     },
     submit: (text, options = {}) => {
       const t = promptDisplayText(text, options).trim();
-      if (!t || state.commandBusy) return false;
+      if (!t) return false;
       const mode = options.mode || 'prompt';
      // Prompt input queued while a turn is active keeps the
      // default `next` priority, so it is injected at the next tool/model
@@ -1839,11 +1879,14 @@ export async function createEngineSession({
         displayText: promptDisplayText(text, options),
         priority,
       };
-      if (state.busy) {
+      // A running clear (idle auto-clear or session_manage) sets commandBusy;
+      // queue the prompt instead of dropping it — it drains after the clear.
+      if (autoClearRunning) {
         enqueue(text, queueOptions);
         return true;
       }
-      if (autoClearRunning) {
+      if (state.commandBusy) return false;
+      if (state.busy) {
         enqueue(text, queueOptions);
         return true;
       }