mixdog 1.2.6 → 1.3.1

package/src/tui/session/tui-steering-persist.mjs

@@ -7,10 +7,10 @@ import { promptContentText } from './queue-helpers.mjs';
 // Restore window for persisted busy-input steering rows. Rows older than this
 // are leftovers of a session that ended long ago — restoring them into a fresh
 // TUI boot reads as a surprise self-injection (user report), so they are
-// discarded at drain time instead.
+// discarded when the mirror is read instead.
 const STALE_STEERING_RESTORE_TTL_MS = 30 * 60 * 1000;
 
-// Serialize this UI process's own steering writes so append→drop→drain keep
+// Serialize this UI process's own steering writes so append→drop→read keep
 // their issue order even though each now waits on the lock asynchronously.
 // Cross-process mutual exclusion still comes from the shared lock protocol;
 // this chain only orders same-process operations that were previously
@@ -59,23 +59,40 @@ function newSteeringPersistId() {
   return `ts_${Date.now().toString(36)}_${randomBytes(4).toString('hex')}`;
 }
 
-function normalizeTuiSteeringQueueEntry(entry) {
-  if (typeof entry === 'string') {
-    const text = entry.trim();
-    return text || null;
+// What the accepted input runs: its executable content (attachment
+// references), the pasted-attachment links and transcript metadata it was
+// submitted with, and its run options. Callbacks and live queue state never
+// reach the spool.
+function persistedQueuePayload(entry) {
+  const out = {};
+  if (typeof entry.content === 'string' || Array.isArray(entry.content)) out.content = entry.content;
+  for (const field of ['pastedImages', 'pastedTexts', 'transcriptMeta']) {
+    const value = entry[field];
+    if (value && typeof value === 'object' && !Array.isArray(value)) out[field] = value;
+  }
+  for (const field of ['mode', 'priority', 'context']) {
+    if (typeof entry[field] === 'string' && entry[field]) out[field] = entry[field];
   }
+  if (entry.skipSlashCommands === true) out.skipSlashCommands = true;
+  return out;
+}
+
+function normalizeTuiSteeringQueueEntry(entry) {
+  if (typeof entry === 'string') entry = { text: entry };
   if (!entry || typeof entry !== 'object') return null;
   if (typeof entry.text === 'string' && entry.text.trim()) {
     const text = entry.text.trim();
-    const id = typeof entry.id === 'string' && entry.id.trim() ? entry.id.trim() : null;
+    // A row of an older build may have no id; it gets one here, under the
+    // shard lock, so every later read and drop names the same row.
+    const id = typeof entry.id === 'string' && entry.id.trim() ? entry.id.trim() : newSteeringPersistId();
     const submissionId =
       typeof entry.submissionId === 'string' && entry.submissionId.trim() ? entry.submissionId.trim() : null;
     const submittedAt = Number(entry.submittedAt);
-    if (!id) return text;
     const at = Number(entry.at);
     return {
       id,
       text,
+      ...persistedQueuePayload(entry),
       ...(Number.isFinite(at) && at > 0 ? { at } : {}),
       ...(submissionId ? { submissionId } : {}),
       ...(Number.isFinite(submittedAt) && submittedAt > 0 ? { submittedAt } : {}),
@@ -131,24 +148,15 @@ function entryPersistText(entry) {
   return text;
 }
 
-function rowMatchesEntry(row, entry) {
-  const persistId = entry?.steeringPersistId;
-  if (persistId) {
-    return Boolean(row && typeof row === 'object' && row.id === persistId);
-  }
-  const text = entryPersistText(entry);
-  if (!text) return false;
-  return row === text;
-}
-
+// Every stored row has an id (normalize assigns one), so a row is named by it.
 function removePersistRow(q, entry) {
-  const idx = q.findIndex((row) => rowMatchesEntry(row, entry));
+  const idx = q.findIndex((row) => row.id === entry?.steeringPersistId);
   if (idx >= 0) q.splice(idx, 1);
 }
 
 // Consistency-required: a dropped append loses a user's queued steering
 // message, so we async-wait for the lock (never try-once). Returns a promise;
-// fire-and-forget at call sites is fine — _serialize keeps append/drop/drain
+// fire-and-forget at call sites is fine — _serialize keeps append/drop/read
 // in issue order and the write never blocks the render loop.
 export function appendTuiSteeringPersist(leadSessionId, entry) {
   const text = entryPersistText(entry);
@@ -158,13 +166,22 @@ export function appendTuiSteeringPersist(leadSessionId, entry) {
   if (!entry.steeringPersistId) entry.steeringPersistId = newSteeringPersistId();
   const submissionId = typeof entry.id === 'string' && entry.id.trim() ? entry.id.trim() : null;
   const submittedAt = Number(entry.submittedAt);
-  const record = {
+  const identity = {
     id: entry.steeringPersistId,
     text,
     at: Date.now(),
     ...(submissionId ? { submissionId } : {}),
     ...(Number.isFinite(submittedAt) && submittedAt > 0 ? { submittedAt } : {}),
   };
+  // A JSON snapshot taken now: the lock wait below must not let a later
+  // edit of the live entry change what was accepted. A payload JSON cannot
+  // carry still leaves the input itself durable.
+  let record;
+  try {
+    record = JSON.parse(JSON.stringify({ ...identity, ...persistedQueuePayload(entry) }));
+  } catch {
+    record = identity;
+  }
   return _serialize(key, async () => {
     try {
       await updatePendingShard(key, (raw) => {
@@ -225,30 +242,27 @@ export function _steeringPersistChainCount() {
   return _persistChains.size;
 }
 
-function drainedRowToRestore(row) {
-  if (typeof row === 'string') {
-    return { text: row, steeringPersistId: null };
-  }
-  if (row && typeof row === 'object' && typeof row.text === 'string') {
-    return {
-      text: row.text,
-      steeringPersistId: typeof row.id === 'string' ? row.id : null,
-      submissionId: typeof row.submissionId === 'string' ? row.submissionId : null,
-      submittedAt: Number.isFinite(Number(row.submittedAt)) ? Number(row.submittedAt) : null,
-    };
-  }
-  return null;
+function persistedRowToRestore(row) {
+  return {
+    ...persistedQueuePayload(row),
+    text: row.text,
+    steeringPersistId: row.id,
+    submissionId: typeof row.submissionId === 'string' ? row.submissionId : null,
+    submittedAt: Number.isFinite(Number(row.submittedAt)) ? Number(row.submittedAt) : null,
+  };
 }
 
 // Consistency-required (restores queued messages after boot/command). Async
 // lock wait, serialized on _persistChain so it never reorders against a
 // pending append/drop and never blocks the render loop. Returns a promise of
-// the drained rows; call sites await it.
-export function drainTuiSteeringPersist(leadSessionId) {
+// the stored rows; call sites await it. A read never consumes: a row stays
+// durable until the queue commits, reclaims or closes it (drop), so a
+// restart before then restores it again.
+export function readTuiSteeringPersist(leadSessionId) {
   const key = tuiSteeringSessionKey(leadSessionId);
   if (!key) return Promise.resolve([]);
   return _serialize(key, async () => {
-    let drained = [];
+    let restored = [];
     let droppedStale = 0;
     try {
       await updatePendingShard(key, (raw) => {
@@ -262,18 +276,27 @@ export function drainTuiSteeringPersist(leadSessionId) {
           if (stale) droppedStale += 1;
           return !stale;
         });
-        drained = fresh.map(drainedRowToRestore).filter(Boolean);
-        if (drained.length === 0 && droppedStale === 0) return undefined;
-        deleteSessionBucket(next, key);
+        restored = fresh.map(persistedRowToRestore);
+        // Write only to drop stale rows or to keep the ids normalize gave
+        // rows of an older build.
+        const stored = Array.isArray(raw?.sessions?.[key]) ? raw.sessions[key] : [];
+        if (droppedStale === 0 && stored.every((row) => typeof row?.id === 'string' && row.id.trim())) {
+          return undefined;
+        }
+        if (fresh.length > 0) next.sessions[key] = fresh;
+        else deleteSessionBucket(next, key);
         next.updatedAt = Date.now();
         return next;
       });
     } catch (err) {
-      writeSteeringDiagnostic(`steering-queue drain failed sessionId=${leadSessionId}: ${err?.message || err}`);
+      // An id assigned to an older row that never reached disk names nothing.
+      restored = [];
+      droppedStale = 0;
+      writeSteeringDiagnostic(`steering-queue read failed sessionId=${leadSessionId}: ${err?.message || err}`);
     }
     if (droppedStale > 0) {
       writeSteeringDiagnostic(`dropped ${droppedStale} stale steering row(s) sessionId=${leadSessionId}`);
     }
-    return drained;
+    return restored;
   });
 }

package/src/tui/session/turn-live-call.mjs

@@ -0,0 +1,64 @@
+/**
+ * src/tui/session/turn-live-call.mjs — the live decode speed of the model call
+ * that is streaming right now (`spinner.liveCall`), for the desktop composer's
+ * usage readout.
+ *
+ * Providers report a call's exact output tokens only when it ends (the usage
+ * delta), so mid-stream the count is the runtime's own token estimate of the
+ * text and reasoning streamed so far (token-estimate.mjs, measured against a
+ * real tokenizer at +6.5% aggregate bias). The clock starts when the provider
+ * request starts (markLiveCallRequestStart), the wait for the first token
+ * included, the same span as the persisted speed and the usage ledger; with no
+ * request-start mark it starts at the first visible text/reasoning token.
+ *
+ * Published at most every LIVE_CALL_PUBLISH_MS with its own sample time, so the
+ * reader divides tokens by (sample time - start) and a pause between samples
+ * never skews the figure. A tool call's arguments stream without text the
+ * runtime can count: once the call turns to one, the live figure is withdrawn
+ * until the next call rather than decaying against tokens nobody counted. The
+ * call's usage delta ends it.
+ */
+import { estimateTokens } from '../../runtime/agent/orchestrator/session/token-estimate.mjs';
+
+export const LIVE_CALL_PUBLISH_MS = 250;
+
+function publish({ getState, set }, liveCall) {
+  const spinner = getState().spinner;
+  if (spinner) set({ spinner: { ...spinner, liveCall } });
+}
+
+/** The provider request of the next call started: its clock starts here. */
+export function markLiveCallRequestStart(stream, now = Date.now()) {
+  stream.liveCallRequestAt = now;
+}
+
+/** A text or reasoning chunk of the streaming call arrived. */
+export function noteLiveCallText(stream, chunk, now = Date.now()) {
+  const text = String(chunk ?? '');
+  if (!text || stream.liveCallWithdrawn) return;
+  const call = stream.liveCall || { startedAt: stream.liveCallRequestAt ?? now, text: '', publishedAt: 0 };
+  stream.liveCall = call;
+  call.text += text;
+  if (call.publishedAt && now - call.publishedAt < LIVE_CALL_PUBLISH_MS) return;
+  call.publishedAt = now;
+  publish(stream, { startedAt: call.startedAt, outputTokens: estimateTokens(call.text), at: now });
+}
+
+/** The call turned to a tool call (withdraw until the next call) or was reset. */
+export function withdrawLiveCall(stream) {
+  stream.liveCallWithdrawn = true;
+  endLiveCall(stream);
+}
+
+/** The call ended (its usage delta landed): the next call starts fresh. */
+export function endLiveCall(stream) {
+  const had = Boolean(stream.liveCall) || Boolean(stream.getState().spinner?.liveCall);
+  stream.liveCall = null;
+  if (had) publish(stream, null);
+}
+
+export function startNextLiveCall(stream) {
+  stream.liveCallWithdrawn = false;
+  stream.liveCallRequestAt = null;
+  endLiveCall(stream);
+}

package/src/tui/session/turn.mjs

@@ -54,6 +54,13 @@ import {
   startLiveTail,
 } from './turn-tool-cards.mjs';
 import { startQuietWatch } from './turn-quiet.mjs';
+import {
+  endLiveCall,
+  markLiveCallRequestStart,
+  noteLiveCallText,
+  startNextLiveCall,
+  withdrawLiveCall,
+} from './turn-live-call.mjs';
 
 // A usage limit is exactly a spent quota, a plan-gated feature or a billing
 // refusal; overloads, rate limits and server faults recover by waiting.
@@ -203,8 +210,9 @@ function steeringItemExtras(steeringMeta) {
       ? { messageId: steeringMeta.messageId }
       : {}),
     // Queue mode + execution provenance: a task notification is rendered as
-    // a tool card, never as an injected user bubble.
-    ...(steeringMeta?.mode === 'task-notification' ? { mode: 'task-notification' } : {}),
+    // a tool card, never as an injected user bubble. Anything else is a
+    // message the model read inside its running turn (the row's read mark).
+    ...(steeringMeta?.mode === 'task-notification' ? { mode: 'task-notification' } : { steered: true }),
     ...(steeringMeta?.execution && typeof steeringMeta.execution === 'object'
       ? { execution: steeringMeta.execution }
       : {}),
@@ -336,10 +344,15 @@ export function applyCompactEvent(ctx, event) {
   set({ ...routeState(), stats: { ...getState().stats } });
 }
 
-function applyTurnUsageDelta({ turn, getState, set, syncContextStats }, delta) {
+function applyTurnUsageDelta(ctx, delta) {
+  const { turn, getState, set, syncContextStats } = ctx;
   const stats = { ...getState().stats };
   applyUsageDelta(stats, delta);
   set({ stats });
+  // The call is over: the composer's live speed gives way to the session's
+  // figure, which this delta's exact usage has just joined.
+  startNextLiveCall(ctx.stream);
+  // Publishes the session's persisted usage totals (stats.usageReadout) too.
   syncContextStats({ allowEstimated: true });
   const inputTokens = Math.max(0, getState().stats.inputTokens - turn.inputBaseline);
   const outputTokens = Math.max(0, getState().stats.outputTokens - turn.outputBaseline);
@@ -369,7 +382,6 @@ function turnHandlers(ctx) {
     },
     drainSteering: (_sessionId, drainOptions) =>
       isCurrentTurn() ? drainPendingSteering({ ...drainOptions, turnEpoch: ctx.turn.epoch }) : [],
-    onStreamDelta: () => {},
     onSteerMessage: (text, steeringMeta = {}) => {
       if (isCurrentTurn()) injectSteerMessage(ctx, text, steeringMeta);
     },
@@ -422,6 +434,9 @@ export function toolHandlers(ctx) {
 export function streamHandlers(ctx) {
   const { isCurrentTurn, stream } = ctx;
   return {
+    onProviderSendStarted: () => {
+      if (isCurrentTurn()) markLiveCallRequestStart(stream);
+    },
     onStageChange: async (stage, detail = null) => {
       if (!isCurrentTurn()) return;
       // A runtime notice (e.g. a tool the provider left out of the request)
@@ -441,8 +456,13 @@ export function streamHandlers(ctx) {
       // prompt — the runtime would rewind it while the host skipped the requeue.
       if (textChunk.trim()) ctx.markPromptCommitted();
       appendTextDelta(stream, textChunk);
+      noteLiveCallText(stream, textChunk);
+    },
+    onTextReset: (reset = {}) => {
+      if (!isCurrentTurn()) return false;
+      endLiveCall(stream);
+      return resetStreamedText(stream, reset);
     },
-    onTextReset: (reset = {}) => (isCurrentTurn() ? resetStreamedText(stream, reset) : false),
     onAssistantText: (text, detail) => {
       const full = String(text ?? '');
       if (!full.trim() || !isCurrentTurn()) return;
@@ -454,7 +474,9 @@ export function streamHandlers(ctx) {
       appendAssistantText(stream, full, { committed: detail?.committed === true });
     },
     onReasoningDelta: (chunk) => {
-      if (isCurrentTurn()) appendReasoningDelta(stream, String(chunk ?? ''));
+      if (!isCurrentTurn()) return;
+      appendReasoningDelta(stream, String(chunk ?? ''));
+      noteLiveCallText(stream, chunk);
     },
     // A provider output item started. A tool call ends the text before it
     // (a preamble settles at the call's start, not after its arguments or
@@ -462,8 +484,10 @@ export function streamHandlers(ctx) {
     // commentary or final answer.
     onStreamItemStart: (detail) => {
       if (!isCurrentTurn()) return;
-      if (detail?.kind === 'tool') settleSegmentBeforeToolCall(ctx);
-      else if (detail?.kind === 'text') noteAssistantPhase(stream, detail.phase);
+      if (detail?.kind === 'tool') {
+        withdrawLiveCall(stream);
+        settleSegmentBeforeToolCall(ctx);
+      } else if (detail?.kind === 'text') noteAssistantPhase(stream, detail.phase);
     },
   };
 }
@@ -725,6 +749,7 @@ export function createRunTurn(bag) {
     try {
       const { result, session } = await runtime.ask(userText, {
         id: turn.submittedIds[0],
+        submissionIds: turn.submittedIds,
         submittedAt: options.submittedAt,
         promptSource: options.promptSource,
         retryFailedTurn: options.retryFailedTurn === true,
@@ -732,6 +757,7 @@ export function createRunTurn(bag) {
         retryAttemptId: options.retryAttemptId,
         transcriptMeta: turn.transcriptMeta,
         context: options.context || null,
+        ...(typeof options.skillSelection === 'string' ? { skillSelection: options.skillSelection } : {}),
         ...turnHandlers(ctx),
         ...toolHandlers(ctx),
         ...streamHandlers(ctx),

package/src/session-runtime/automation-agents.mjs

@@ -1,94 +0,0 @@
-/**
- * Agent delegation for automation sessions (schedules, webhooks). They run
- * headless in the daemon, so no session runtime registers tools for them or
- * receives their agents' completions. The daemon's canonical agent control is
- * exposed under a dedicated internal-tool scope instead, and the completions of
- * the agents a run starts come back here, where the run turns them into the
- * conversation's next turn — what a Lead in a window does when one arrives.
- */
-import { setInternalToolsProvider } from '../runtime/agent/orchestrator/internal-tools.mjs';
-import { AGENT_TOOL } from './services/agent-tool/tool-def.mjs';
-
-export const AUTOMATION_TOOL_SCOPE = 'automation';
-// How long a run waits for the next result of an agent it started; past it the
-// run ends with the conversation as it stands.
-const AGENT_RESULT_WAIT_MS = 60 * 60_000;
-
-const runs = new Map(); // sessionId → { pending: Set<taskId>, ready: string[], wake }
-
-function resultText(result) {
-  return typeof result === 'string' ? result : JSON.stringify(result ?? '');
-}
-
-/** Registers the agent tool for automation sessions; returns its disposer. */
-export function registerAutomationAgentTool(executeAgentControl) {
-  return setInternalToolsProvider({
-    scopeId: AUTOMATION_TOOL_SCOPE,
-    tools: [AGENT_TOOL],
-    async executor(_name, args, callerCtx = {}) {
-      const result = await executeAgentControl(args, {
-        callerCwd: callerCtx.callerCwd,
-        invocationSource: 'model-tool',
-        callerSessionId: callerCtx.callerSessionId || null,
-        clientHostPid: process.pid,
-        signal: callerCtx.signal,
-      });
-      // A spawn/send acknowledgement ("agent task: <id>", "status: running")
-      // is a result still to come for this run.
-      const text = resultText(result);
-      const taskId = /agent task: ([\w.:-]+)/.exec(text)?.[1];
-      const run = runs.get(String(callerCtx.callerSessionId || ''));
-      if (run && taskId && /status: running/.test(text)) run.pending.add(taskId);
-      return result;
-    },
-  });
-}
-
-/** Hands an agent completion to the automation run that started the task; false when none did. */
-export function deliverAutomationCompletion(sessionId, text, meta = {}) {
-  const run = runs.get(String(sessionId || ''));
-  const taskId = String(meta?.execution_id || '');
-  if (!run?.pending.has(taskId)) return false;
-  // The header-only preview precedes the body-carrying completion.
-  if (meta?.model_visible === false) return true;
-  run.pending.delete(taskId);
-  run.ready.push(String(text || ''));
-  run.wake?.();
-  return true;
-}
-
-// Ask options for a follow-up turn fed by agent results: the runtime reporting
-// worker output, not the user — stored as a task notification and never a
-// source of explicit skill selection.
-export const AUTOMATION_RESULT_TURN_OPTS = Object.freeze({ promptSource: 'task-notification' });
-
-/**
- * Runs an automation conversation to its end: the first turn, then one more
- * turn per batch of agent results while agents it started are still out.
- * `nextTurn(text, askOpts)` receives AUTOMATION_RESULT_TURN_OPTS as the
- * results' provenance. Resolves with the last turn's result.
- */
-export async function runAutomationTurns(sessionId, firstTurn, nextTurn, { waitMs = AGENT_RESULT_WAIT_MS } = {}) {
-  const run = { pending: new Set(), ready: [], wake: null };
-  runs.set(sessionId, run);
-  try {
-    let result = await firstTurn();
-    while (run.pending.size > 0 || run.ready.length > 0) {
-      if (run.ready.length === 0) {
-        const arrived = await new Promise((resolve) => {
-          const timer = setTimeout(() => resolve(false), waitMs);
-          run.wake = () => {
-            clearTimeout(timer);
-            resolve(true);
-          };
-        });
-        run.wake = null;
-        if (!arrived) break;
-      }
-      result = await nextTurn(run.ready.splice(0).join('\n\n'), { ...AUTOMATION_RESULT_TURN_OPTS });
-    }
-    return result;
-  } finally {
-    runs.delete(sessionId);
-  }
-}

package/src/session-runtime/automation-workflow.mjs

@@ -1,59 +0,0 @@
-/**
- * Resolve a stored automation workflow id (schedule/webhook row) into
- * createSession options: the workflow summary meta plus the WORKFLOW.md
- * context block, exactly like a desktop New task session gets for the
- * active workflow. An empty/unknown id resolves to the default pack via
- * loadWorkflowPack's fallback; resolution failures degrade to no workflow
- * context (the session still runs with the base lead ruleset).
- */
-import { createWorkflowHelpers } from '../runtime/agent/orchestrator/runtime-core/workflow.mjs';
-import { STANDALONE_ROOT, STANDALONE_DATA_DIR } from './runtime-paths.mjs';
-import { readMarkdownDocument, normalizeAgentPermissionOrNone } from '../runtime/shared/markdown-frontmatter.mjs';
-import { IMPLICIT_APPROVAL_MODE } from '../runtime/agent/orchestrator/session/approval-mode.mjs';
-import { loadConfig } from '../runtime/agent/orchestrator/config.mjs';
-import { configuredOrchestrationMode } from '../runtime/shared/orchestration.mjs';
-import { AUTOMATION_TOOL_SCOPE } from './automation-agents.mjs';
-
-let _helpers = null;
-function helpers() {
-  if (!_helpers) {
-    _helpers = createWorkflowHelpers({
-      rootDir: STANDALONE_ROOT,
-      dataDir: STANDALONE_DATA_DIR,
-      readMarkdownDocument,
-      normalizeAgentPermissionOrNone,
-    });
-  }
-  return _helpers;
-}
-
-/** Non-interactive createSession opts, plus workflow context when the id resolves. */
-export function automationWorkflowOpts(workflowId) {
-  const config = loadConfig({ secrets: false });
-  // The user's orchestration setting governs an automation exactly as it does a
-  // New task: a workflow id alone never turns delegation on, and the agent
-  // tool reaches the run through the automation tool scope.
-  const baseOpts = {
-    approvalMode: IMPLICIT_APPROVAL_MODE,
-    orchestrationMode: configuredOrchestrationMode(config),
-    mcpScopeId: AUTOMATION_TOOL_SCOPE,
-  };
-  const id = String(workflowId || '').trim();
-  if (!id) return baseOpts;
-  try {
-    const h = helpers();
-    const pack = h.loadWorkflowPack(undefined, id);
-    if (!pack) return baseOpts;
-    // The whole config, so disabled agents and the orchestration mode are the
-    // user's, with only the active workflow swapped for the automation's own.
-    const resolved = h.activeWorkflowContext({ ...config, workflow: { ...config.workflow, active: id } }, undefined);
-    return {
-      ...baseOpts,
-      workflow: resolved.summary,
-      workflowContext: resolved.context,
-      orchestrationMode: resolved.orchestrationMode,
-    };
-  } catch {
-    return baseOpts;
-  }
-}