mixdog 0.9.11 → 0.9.13

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;
       }

package/src/workflows/default/WORKFLOW.md

@@ -17,6 +17,8 @@ Lead supervises: delegates, coordinates, judges, decides. Route by complexity:
   failed at least once.
 
 1. Plan — discuss the request with the user, form a plan, wait for approval.
+   Only an explicit go-ahead ("do it", "proceed") is approval. Agreement with
+   a diagnosis, or pointing out a problem, is NOT execution approval.
 2. Delegate — split into the maximum number of independent scopes.
    - PARALLEL across independent scopes by default (implementation, analysis,
      review, debugging alike). Spawn every scope in the SAME turn. Shared or

package/src/workflows/sequential/WORKFLOW.md

@@ -21,6 +21,8 @@ Lead supervises: delegates, coordinates, judges, decides. Route by complexity:
   failed at least once.
 
 1. Plan — discuss the request with the user, form a plan, wait for approval.
+   Only an explicit go-ahead is approval; diagnosis agreement is not. When
+   ambiguous, restate the plan and ask before executing.
 2. Delegate — split into ordered scopes and hand off ONE AT A TIME.
    - NO PARALLEL, NO FAN-OUT. Even when scopes are independent, spawn exactly
      one agent per turn; never multiple in the same turn. Wait for the current

package/src/workflows/solo/WORKFLOW.md

@@ -9,6 +9,8 @@ agents:
 
 1. Plan — Lead discusses the request with the user, forms a plan, and waits for
    approval before execution.
+   Only an explicit go-ahead is approval; diagnosis agreement is not. When
+   ambiguous, restate the plan and ask before executing.
 2. Execute — Lead performs all implementation, research, debugging, review, and
    verification work directly. Delegation to any agent is forbidden.
 3. Verify — Lead checks the result directly, fixes issues directly, and repeats