mixdog 1.4.0 → 1.4.2

package/src/tui/session/goal-turn-state.mjs

@@ -1,11 +1,15 @@
 // A steering handoff cancels a turn, not its durable Goal. Record the explicit
 // abort path against its turn epoch instead of guessing intent from error text.
-export function abortGoalTurn(runtime, flags, hasPendingSteering, reason = 'user-cancel') {
+export function abortGoalTurn(runtime, flags, hasPendingSteering, reason = 'user-cancel', { timeout = false } = {}) {
   const previous = flags.goalSteeringAbortEpoch;
   const epoch = flags.leadTurnEpoch;
   flags.goalSteeringAbortEpoch = hasPendingSteering ? epoch : null;
   try {
-    const result = runtime.abort(hasPendingSteering ? 'interrupt' : reason);
+    // A steering interrupt outranks a timeout: the turn was redirected, not abandoned.
+    const result =
+      timeout && !hasPendingSteering
+        ? runtime.abort(reason, { timeout: true })
+        : runtime.abort(hasPendingSteering ? 'interrupt' : reason);
     if (result === false) flags.goalSteeringAbortEpoch = previous;
     return result;
   } catch (error) {

package/src/tui/session/session-api/controls.mjs

@@ -67,6 +67,10 @@ export function createSessionControlsApi(bag) {
     stopShellJob: async (taskId) => {
       return (await runtime.stopShellJob?.(taskId)) ?? { stopped: false, error: 'shell job control is unavailable' };
     },
+    // `/stop`: this session's background shells, and stopping all of them:
+    // { jobs } and { stopped, stopping }.
+    listStoppableShellJobs: async () => (await runtime.listStoppableShellJobs?.()) ?? { jobs: [] },
+    stopShellJobs: async () => (await runtime.stopShellJobs?.()) ?? { stopped: 0, stopping: 0 },
     // Explicit force-release of a shell whose termination is unconfirmed:
     // { released, error? }. Surfaces confirm with the user before calling.
     releaseShellJob: async (taskId) => {

package/src/tui/session/session-api/extensions.mjs

@@ -54,6 +54,14 @@ export function createSessionExtensionsApi(bag) {
       (input) => runtime.addMcpServer?.(input),
       (result, input) => [`mcp added: ${result?.name || input?.name || 'server'}`]
     ),
+    // No command lock: the runtime serializes adds per connector
+    // (oneAddAtATime), so concurrent adds each succeed with their own key.
+    addConnectorAccount: async (input) => {
+      const result = await runtime.addConnectorAccount?.(input);
+      refreshRouteStats();
+      pushNotice(`mcp account added: ${result?.account || input?.connector || 'connector'}`);
+      return result;
+    },
     saveMcpServer: lockedChange(
       (input) => runtime.saveMcpServer?.(input),
       (result, input) => [`mcp saved: ${result?.name || input?.name || 'server'}`]

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

@@ -172,7 +172,8 @@ export function createAbortAction(bag) {
       runtime,
       flags,
       hasPendingSteering,
-      keepsPrompt ? USER_CANCEL_KEEP_PROMPT_REASON : reason
+      keepsPrompt ? USER_CANCEL_KEEP_PROMPT_REASON : reason,
+      { timeout: options?.timeout === true }
     );
     if (restoreState) {
       // A user Stop consumes this input even when no draft is requested.

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

@@ -20,6 +20,7 @@ export function createSessionIntakeApi(bag) {
     patchItem,
     restoreOlderTranscript,
     restoreNewerTranscript,
+    readSpilledTranscript,
     routeState,
     restoreQueued,
     prioritizeQueued,
@@ -32,6 +33,7 @@ export function createSessionIntakeApi(bag) {
     patchItem,
     restoreOlderTranscript,
     restoreNewerTranscript,
+    ...(typeof readSpilledTranscript === 'function' ? { readSpilledTranscript } : {}),
     subscribe: (listener) => {
       listeners.add(listener);
       return () => listeners.delete(listener);

package/src/tui/session/session-api/integrations.mjs

@@ -129,8 +129,8 @@ export function createSessionIntegrationsApi(bag, { oauthFlows }) {
     getOAuthProviderLoginStatus: (flowId) => oauthFlows.status(flowId),
     completeOAuthProviderLogin: async (flowId, code) => oauthFlows.complete(flowId, code),
     cancelOAuthProviderLogin: async (flowId) => oauthFlows.cancel(flowId),
-    saveProviderApiKey: async (provider, secret) => {
-      const result = await runtime.saveProviderApiKey(provider, secret);
+    saveProviderApiKey: async (provider, secret, options) => {
+      const result = await runtime.saveProviderApiKey(provider, secret, options);
       pushNotice(`provider api key saved: ${result.provider}`, 'info');
       return true;
     },

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

@@ -43,6 +43,7 @@ export function createAgentDefinitionApi(runtime) {
     setAgentConnectorToolPermission: async (agentId, connectorId, toolName, permission, options) =>
       runtime.setAgentConnectorToolPermission?.(agentId, connectorId, toolName, permission, options) ?? null,
     getAgentAlwaysAllowedTools: (agentId) => runtime.getAgentAlwaysAllowedTools?.(agentId) ?? [],
+    getAgentConnectorTools: (agentId) => runtime.getAgentConnectorTools?.(agentId) ?? [],
     // Per-agent action-kind permissions (ask / allow / block) for the profile.
     getAgentPermissions: async (agentId) =>
       (await import('../../../runtime/agent/orchestrator/session/human-gate/store.mjs')).agentPermissions(agentId),

package/src/tui/session/session-api/settings.mjs

@@ -113,13 +113,13 @@ export function createSessionSettingsApi(bag) {
       return await runtime.setAiSessionTitles?.(enabled);
     }),
     getCacheWarmingSettings: () => {
-      return runtime.getCacheWarmingSettings?.() || { enabled: true };
+      return runtime.getCacheWarmingSettings?.() || { enabled: false };
     },
     setCacheWarmingEnabled: withCommandLock(async (enabled) => {
       return await runtime.setCacheWarmingEnabled?.(enabled);
     }),
     getHeartbeatSettings: () => {
-      return runtime.getHeartbeatSettings?.() || { heartbeat: true, intervalMinutes: 60 };
+      return runtime.getHeartbeatSettings?.() || { heartbeat: false, intervalMinutes: 60 };
     },
     setHeartbeatEnabled: withCommandLock(async (enabled) => {
       return await runtime.setHeartbeatEnabled?.(enabled);

package/src/tui/session/session-flow/queue/take-entries.mjs

@@ -87,6 +87,17 @@ export function createTakeEntriesOps({ pending, pendingNotificationKeys, removeQ
     // prompt the user already took back.
     const mirrored = queued.filter((entry) => entry.steeringPersistId);
     if (mirrored.length > 0) void dropTuiSteeringPersist(leadSessionId(), mirrored);
+    // The entries left the queue for good, so nothing later (a drain, the
+    // close of the session) can settle them: whoever submitted one is told it
+    // was cancelled, once, here. A submitter that waits on its settlement (a
+    // bot's send, which owns the work until then) is released.
+    for (const entry of queued) {
+      try {
+        entry.onSettled?.({ status: 'cancelled', reason: 'reclaimed', result: null, session: null });
+      } catch {
+        // A throwing callback must not leave the remaining entries unsettled.
+      }
+    }
     const queuedText = queued
       .map((item) => item.text)
       .filter((text) => String(text || '').trim())

package/src/tui/session/transcript-spill/spill-writer.mjs

@@ -10,6 +10,8 @@
 // Pages are self-contained files named by the owner, so a restart continues
 // the same spill directory with nothing to hand over.
 import { randomUUID } from 'node:crypto';
+import { mkdirSync } from 'node:fs';
+import { dirname } from 'node:path';
 
 const MAX_ATTEMPTS = 2;
 const SPILL_WRITER_IDLE_MS = 10_000;
@@ -67,6 +69,11 @@ export function createSpillWriter({ workerFactory, writeTimeoutMs = 5000, idleMs
     if (record.cancelled) return;
     record.attempts += 1;
     if (record.attempts <= MAX_ATTEMPTS) {
+      // The spill folder vanished (TEMP cleaned): the retry recreates it. Only
+      // the parent does this, synchronously right before it posts the retry
+      // and only for a live record, so a reset or cleanup (which cancels the
+      // record first) can never have its folder resurrected by a late write.
+      record.recreateDir = /ENOENT/.test(String(error));
       queue.unshift(record);
       return;
     }
@@ -159,6 +166,14 @@ export function createSpillWriter({ workerFactory, writeTimeoutMs = 5000, idleMs
       queueMicrotask(pump);
       return;
     }
+    if (active.recreateDir) {
+      active.recreateDir = false;
+      try {
+        mkdirSync(dirname(active.path), { recursive: true });
+      } catch {
+        /* the retry reports the failure */
+      }
+    }
     // Pages are capped at chunkSize, so the structured-clone post cost is
     // bounded; the retry payload is identical to the first attempt.
     const tempPath = `${active.path}.attempt-${active.attempts}-${randomUUID()}.tmp`;

package/src/tui/session/transcript-spill.mjs

@@ -20,6 +20,13 @@ export const tuiDebug = (msg) => {
   } catch {}
 };
 
+/** Normal-level spill warning for the daemon: its stderr is daemon.log. */
+export const spillWarningToStderr = (message) => {
+  try {
+    process.stderr.write(`[transcript-spill] ${message}\n`);
+  } catch {}
+};
+
 // Item ids outlive the process (queued-input mirror, turn change records), so
 // a restarted process never issues an id again.
 const ID_PREFIX = `it_${randomBytes(4).toString('hex')}_`;
@@ -41,6 +48,48 @@ export function sweepStaleTranscriptSpillDirsOnce() {
   cleanupStaleTranscriptSpillDirs();
 }
 
+const decodePage = (record) => record.pendingItems || JSON.parse(readFileSync(record.path, 'utf8'));
+
+/** Spilled rows `[stop - limit, stop)` of `pages` (`spilledRows` rows in all),
+ *  `stop` being `end` clamped to the spilled rows, read newest page first;
+ *  `broken` when a page cannot be read whole. */
+function readSpilledRows(pages, spilledRows, end, limit) {
+  const stop = Math.max(0, Math.min(Number(end) || 0, spilledRows));
+  const begin = Math.max(0, stop - Math.max(0, Number(limit) || 0));
+  const parts = [];
+  const result = (broken) => {
+    const items = parts.reverse().flat();
+    return { items, start: stop - items.length, broken };
+  };
+  // The page holding row `stop - 1`, by binary search over the pages' first
+  // rows: a read touches only the pages it returns rows from, at any depth.
+  let low = 0;
+  let high = pages.length - 1;
+  let last = -1;
+  while (low <= high) {
+    const middle = (low + high) >> 1;
+    if (pages[middle].start < stop) {
+      last = middle;
+      low = middle + 1;
+    } else high = middle - 1;
+  }
+  for (let index = last; index >= 0; index -= 1) {
+    const record = pages[index];
+    const pageStart = record.start;
+    const pageEnd = pageStart + record.count;
+    if (pageEnd <= begin) break;
+    let items = null;
+    try {
+      items = decodePage(record);
+    } catch {
+      items = null;
+    }
+    if (!Array.isArray(items) || items.length !== record.count) return result(true);
+    parts.push(items.slice(Math.max(begin, pageStart) - pageStart, Math.min(stop, pageEnd) - pageStart));
+  }
+  return result(false);
+}
+
 // Serialized pages deliberately release the old item object graph while
 // keeping every byte restorable. Only `items` is render-live and walkable.
 // This buffer owns the page list, the reading cursor and snapshots; the spill
@@ -65,6 +114,21 @@ export function createTranscriptSpillBuffer({
   let cursor = null;
   let spillDir = null;
   let pageSequence = 0;
+  // Spilled rows in this page list, and its epoch: it moves whenever the list
+  // is replaced (reset, restored snapshot, dispose), so an absolute row index
+  // names one row only within an epoch. Cursor-independent.
+  let spilledRows = 0;
+  let epoch = 0;
+  let spilledInfo = { rows: 0, epoch: 0 };
+  // Each page's first absolute row (`start`) within the current page list.
+  const replaced = () => {
+    spilledRows = 0;
+    for (const record of pages) {
+      record.start = spilledRows;
+      spilledRows += record.count;
+    }
+    epoch += 1;
+  };
   let warningEmitted = false;
   let spillDisabled = false;
   const snapshots = new Set();
@@ -96,6 +160,7 @@ export function createTranscriptSpillBuffer({
     const record = {
       id: pageSequence,
       path: page,
+      count: items.length,
       pendingItems: items,
       cancelled: false,
       attempts: 0,
@@ -104,11 +169,10 @@ export function createTranscriptSpillBuffer({
     writer.enqueue(record);
     return record;
   };
-  const decode = (record) => record.pendingItems || JSON.parse(readFileSync(record.path, 'utf8'));
   const restoredWithOverlap = (liveItems) => {
-    const restored = decode(pages[cursor]);
+    const restored = decodePage(pages[cursor]);
     let following = Array.isArray(liveItems) ? liveItems : [];
-    if (cursor + 1 < pages.length) following = decode(pages[cursor + 1]);
+    if (cursor + 1 < pages.length) following = decodePage(pages[cursor + 1]);
     return [...restored, ...following.slice(0, TRANSCRIPT_RESTORE_OVERLAP_ITEMS)];
   };
   return {
@@ -118,6 +182,14 @@ export function createTranscriptSpillBuffer({
     get hasNewer() {
       return cursor != null;
     },
+    /** `{ rows, epoch }`: how many rows were spilled above the live ones, in
+     *  which page list. The same object while neither changes. */
+    get spilled() {
+      if (spilledInfo.rows !== spilledRows || spilledInfo.epoch !== epoch) {
+        spilledInfo = { rows: spilledRows, epoch };
+      }
+      return spilledInfo;
+    },
     reset() {
       const retained = [...snapshots].some((snapshot) => snapshot.spillDir === spillDir);
       const oldPages = pages.splice(0);
@@ -127,6 +199,7 @@ export function createTranscriptSpillBuffer({
       pageSequence = 0;
       spillDisabled = false;
       warningEmitted = false;
+      replaced();
       if (!retained) cleanupRecords(oldPages, oldDir);
     },
     snapshot() {
@@ -155,6 +228,7 @@ export function createTranscriptSpillBuffer({
       pageSequence = snapshot.pageSequence;
       spillDisabled = snapshot.spillDisabled === true;
       warningEmitted = snapshot.warningEmitted === true;
+      replaced();
       snapshots.delete(snapshot);
       return true;
     },
@@ -169,6 +243,7 @@ export function createTranscriptSpillBuffer({
         if (snapshot.spillDir !== spillDir) cleanupRecords(snapshot.pages, snapshot.spillDir);
       }
       pages.length = 0;
+      replaced();
       snapshots.clear();
       cursor = null;
       spillDir = null;
@@ -191,11 +266,24 @@ export function createTranscriptSpillBuffer({
       let live = Array.isArray(items) ? items : [];
       if (spillDisabled) return live;
       while (live.length > cap) {
-        pages.push(encode(live.slice(0, chunkSize)));
+        const record = encode(live.slice(0, chunkSize));
+        record.start = spilledRows;
+        pages.push(record);
+        spilledRows += chunkSize;
         live = live.slice(chunkSize);
       }
       return live;
     },
+    /** Spilled rows `[start, end)` by absolute index (0 = the first row ever
+     *  spilled in this `epoch`), at most `limit` ending at `end`, exactly as
+     *  they were spilled. Reads pages in order without moving the reading
+     *  cursor. Null for another epoch. A page that cannot be read whole (gone,
+     *  not JSON, not an array of its recorded length) ends the spilled
+     *  history there: `broken`, with only the rows below it. */
+    readSpilled({ epoch: wanted, end = spilledRows, limit = 0 } = {}) {
+      if (wanted !== epoch) return null;
+      return readSpilledRows(pages, spilledRows, end, limit);
+    },
     restoreOlder(liveItems) {
       const nextCursor = cursor == null ? pages.length - 1 : cursor - 1;
       if (nextCursor < 0) return null;

package/src/tui/session/transcript-store.mjs

@@ -21,6 +21,8 @@ export function createTranscriptStore({ draft, store, flags, transcriptSpill, it
   const transcriptHistoryFlags = () => ({
     transcriptHistoryBefore: transcriptSpill.hasOlder,
     transcriptHistoryAfter: transcriptSpill.hasNewer,
+    // Paged views read spilled rows by this, never by the TUI reading cursor.
+    transcriptSpilled: transcriptSpill.spilled,
   });
   const restoreOlderTranscript = () => {
     const transcriptViewItems = transcriptSpill.restoreOlder(draft.state.items);

package/src/ui/statusline-agents.mjs

@@ -13,9 +13,7 @@ import { positiveInt } from '../runtime/shared/numbers.mjs';
 
 // One table owns both halves of a maintenance agent: which agents are hidden
 // from the worker list by default, and the short label they render as.
-const MAINTENANCE_AGENT_LABELS = new Map([
-  ['cycle1-agent', 'cycle1'],
-]);
+const MAINTENANCE_AGENT_LABELS = new Map([['cycle1-agent', 'cycle1']]);
 const DEFAULT_HIDDEN_STATUSLINE_AGENTS = Object.freeze([...MAINTENANCE_AGENT_LABELS.keys()]);
 const TERMINAL_AGENT_STATUS = /idle|done|complete|success|closed|error|fail|cancel|killed|timeout/i;
 const ACTIVE_AGENT_STATUS = /^(?:connecting|requesting|streaming|tool[-_\s]?running|running|queued|pending|starting)$/i;

package/src/defaults/skills/skill-creator/references/source-review.md

@@ -1,94 +0,0 @@
-# Reviewing public skills
-
-Use this reference to decide whether a public skill should be used as-is,
-reimplemented, or rejected.
-
-## Research order
-
-Look for evidence in this order:
-
-1. current first-party documentation;
-2. the maintainer's source repository;
-3. maintained community implementations;
-4. indexes and lists for discovery only.
-
-Stop when the decision has enough evidence. Popularity and search position do
-not prove quality or compatibility.
-
-## Candidate record
-
-For each viable candidate, capture:
-
-- the exact capability and trigger boundary;
-- source URL plus release or commit when available;
-- target agent and supported platforms;
-- license and redistribution conditions;
-- last meaningful maintenance;
-- file layout and runtime assumptions;
-- scripts, dependencies, network calls, secret access, and side effects;
-- tests or examples that demonstrate behavior.
-
-Compare candidates against the user's required outcome, not against each
-other's feature count.
-
-## Integration decision
-
-### Reimplement the behavior
-
-Prefer a local implementation when the useful part is a small set of ideas or
-requirements. Write a new structure and new language from Mixdog constraints
-and local evidence. Do not translate or lightly rearrange upstream text.
-
-This path avoids carrying incompatible conventions and usually produces a
-smaller skill. It does not permit copying protected prose or code without
-following its license.
-
-### Import third-party material
-
-Use exact upstream material only when its implementation is necessary and its
-license is acceptable. Preserve required notices, identify modifications, and
-test the imported behavior in Mixdog. Upstream test results do not validate a
-local adaptation.
-
-### Reject the candidate
-
-Reject it when:
-
-- no usable license is present;
-- executable behavior is unexplained or excessive;
-- it depends on unavailable tools or private infrastructure;
-- its trigger overlaps a stronger local owner;
-- adapting it would cost more than a focused local design;
-- maintenance or security evidence is insufficient.
-
-## Executable-content audit
-
-Read scripts rather than trusting their documentation. Look for:
-
-- vendor-specific subprocesses;
-- writes into hidden product directories;
-- downloads, telemetry, or remote execution;
-- environment and credential collection;
-- package installation or privilege elevation;
-- deletion, overwrite, publishing, deployment, or recurring scheduling;
-- unbounded concurrency, retries, waits, or external spend;
-- hard-coded local paths and platform-specific shell commands.
-
-Removing an unnecessary executable is often safer than wrapping it in warnings.
-When it is necessary, make its dependency and side effects visible in the main
-skill.
-
-## Extracting useful ideas safely
-
-Record abstract lessons such as:
-
-- a decision the workflow should make;
-- a failure mode worth detecting;
-- a completion condition;
-- a useful separation of responsibilities;
-- a test category or compatibility concern.
-
-Then design the local workflow from those requirements without consulting the
-source phrasing while drafting. Review the result for accidental product names,
-foreign paths, commands, metadata, or structural assumptions.
-