mixdog 1.2.0 → 1.2.1

package/src/tui/session/queue-helpers.mjs

@@ -175,7 +175,9 @@ export function mergePastedImages(entries) {
 
 // Byte-free image metadata for the user transcript item. Prompt content carries
 // only a content-addressed attachment ref after daemon intake; transcript items
-// and desktop snapshots carry just name/mime/size.
+// and desktop snapshots carry name/mime/size plus, for attachment-reference
+// parts, the `attachmentRef` so the desktop can rebuild thumbnails from the
+// stored original.
 export function promptContentImageMeta(content, pastedImages) {
   const parts = Array.isArray(content) ? content.filter((part) => part?.type === 'image') : [];
   if (parts.length === 0) return null;
@@ -190,6 +192,7 @@ export function promptContentImageMeta(content, pastedImages) {
       name: String(meta?.filename || `Image ${index + 1}`),
       mimeType: String(part.mimeType || part.mediaType || meta?.mediaType || 'image/png'),
       bytes: Number(part.sizeBytes) || data.length,
+      ...(isAttachmentReference(part) ? { attachmentRef: part.attachmentRef } : {}),
     };
   });
 }
@@ -202,6 +205,8 @@ export function callCommitCallbacks(entries) {
   for (const entry of entries || []) {
     try {
       entry?.onCommitted?.();
-    } catch {}
+    } catch {
+      // A throwing commit callback must not block the remaining entries.
+    }
   }
 }

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

@@ -83,8 +83,10 @@ export function createSessionExtensionsApi(bag) {
       }
       return await runtime.setExtensionScope(kind, name, projects);
     },
-    skillsStatus: () => {
-      return runtime.skillsStatus?.() || { cwd: getState().cwd, count: 0, skills: [] };
+    // `options.cwd`: list and scope skills for that folder instead of this
+    // session's (the desktop resolves a new-task draft's Project to it).
+    skillsStatus: (options) => {
+      return runtime.skillsStatus?.(options) || { cwd: getState().cwd, count: 0, skills: [] };
     },
     skillContent: (name) => {
       return runtime.skillContent?.(name);

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

@@ -154,6 +154,13 @@ export function createSessionSettingsApi(bag) {
     inspectHuggingFaceModel: (options) => runtime.inspectHuggingFaceModel(options),
     registerHuggingFaceModel: (previewId, licenseAccepted) =>
       runtime.registerHuggingFaceModel(previewId, licenseAccepted),
+    // Conversation import (advertised session actions; one object argument).
+    // Background jobs, so never behind commandBusy.
+    listImportableConversations: (params) => runtime.listImportableConversations(params),
+    getConversationImportJobs: (params) => runtime.getConversationImportJobs(params),
+    registerConversationImportFile: (params) => runtime.registerConversationImportFile(params),
+    startConversationImport: (params) => runtime.startConversationImport(params),
+    cancelConversationImport: (params) => runtime.cancelConversationImport(params),
     getChannelSettings: (options = {}) => {
       return (
         runtime.getChannelSettings?.(options) || {

package/src/tui/session/session-flow/drain.mjs

@@ -65,7 +65,19 @@ function renderBatchItems(batch, pushUserOrSyntheticItem) {
   }
 }
 
-function turnOptionsForBatch(batch, steering) {
+const COMPLETION_WAKE_MODES = new Set(['task-notification', 'pending-resume']);
+
+// Trusted provenance of a drained batch: Goal turns keep their own source; a
+// batch made only of completion wakes (task notifications, pending resumes)
+// is the runtime reporting, carried as a task notification so the runtime
+// stores it as one and never treats its text as a user skill selection.
+function batchPromptSource(batch) {
+  if (isGoalQueuedEntry(batch[0])) return batch[0].mode;
+  if (batch.length > 0 && batch.every((entry) => COMPLETION_WAKE_MODES.has(entry?.mode))) return 'task-notification';
+  return undefined;
+}
+
+export function turnOptionsForBatch(batch, steering) {
   const nonEditable = batch.filter((entry) => !isQueuedEntryEditable(entry));
   // A completion resume is owned by the completion that woke it. Esc
   // consumes that ownership; unlike ordinary notifications it must never
@@ -75,7 +87,7 @@ function turnOptionsForBatch(batch, steering) {
     (entry) => entry?.abortDiscardOnAbort === true || entry?.mode === 'pending-resume'
   );
   return {
-    promptSource: isGoalQueuedEntry(batch[0]) ? batch[0].mode : undefined,
+    promptSource: batchPromptSource(batch),
     retryFailedTurn: batch[0]?.retryFailedTurn === true,
     displayText: batch
       .map((entry) => entry.text)
@@ -114,8 +126,6 @@ function turnOptionsForBatch(batch, steering) {
   };
 }
 
-const COMPLETION_WAKE_MODES = new Set(['task-notification', 'pending-resume']);
-
 export function createDrainLoop(
   bag,
   { queue, steering, submissions, flushDeferredClearedSessionUi, autoClearBeforeWake }

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

@@ -15,11 +15,19 @@ const STALE_STEERING_RESTORE_TTL_MS = 30 * 60 * 1000;
 // Cross-process mutual exclusion still comes from the shared lock protocol;
 // this chain only orders same-process operations that were previously
 // naturally ordered by the synchronous call site.
-let _persistChain = Promise.resolve();
-function _serialize(task) {
-  const run = _persistChain.then(task, task);
+// One chain per session key so a slow write for one session never delays
+// another; an entry is removed once its chain is idle.
+const _persistChains = new Map();
+function _serialize(key, task) {
+  const prev = _persistChains.get(key) || Promise.resolve();
+  const run = prev.then(task, task);
   // Never let a rejection poison the chain; each op logs its own error.
-  _persistChain = run.catch(() => {});
+  const tail = run
+    .catch(() => {})
+    .then(() => {
+      if (_persistChains.get(key) === tail) _persistChains.delete(key);
+    });
+  _persistChains.set(key, tail);
   return run;
 }
 
@@ -159,7 +167,7 @@ export function appendTuiSteeringPersist(leadSessionId, entry) {
     ...(submissionId ? { submissionId } : {}),
     ...(Number.isFinite(submittedAt) && submittedAt > 0 ? { submittedAt } : {}),
   };
-  return _serialize(async () => {
+  return _serialize(key, async () => {
     try {
       await updatePendingShard(key, (raw) => {
         const next = normalizePendingStore(raw);
@@ -184,7 +192,7 @@ export function dropTuiSteeringPersist(leadSessionId, entries) {
   if (!key) return Promise.resolve();
   const batch = Array.isArray(entries) ? entries : [];
   if (batch.length === 0) return Promise.resolve();
-  return _serialize(async () => {
+  return _serialize(key, async () => {
     try {
       await updatePendingShard(key, (raw) => {
         const next = normalizePendingStore(raw);
@@ -207,8 +215,16 @@ export function dropTuiSteeringPersist(leadSessionId, entries) {
   });
 }
 
-export function flushTuiSteeringPersist() {
-  return _persistChain.catch(() => {});
+export async function flushTuiSteeringPersist() {
+  // Loop: chains started while waiting are awaited too.
+  while (_persistChains.size > 0) {
+    await Promise.all([..._persistChains.values()]);
+  }
+}
+
+// Test hook: number of live per-key chains.
+export function _steeringPersistChainCount() {
+  return _persistChains.size;
 }
 
 function drainedRowToRestore(row) {
@@ -233,7 +249,7 @@ function drainedRowToRestore(row) {
 export function drainTuiSteeringPersist(leadSessionId) {
   const key = tuiSteeringSessionKey(leadSessionId);
   if (!key) return Promise.resolve([]);
-  return _serialize(async () => {
+  return _serialize(key, async () => {
     let drained = [];
     let droppedStale = 0;
     try {

package/src/tui/session/turn.mjs

@@ -322,9 +322,26 @@ function applyTurnUsageDelta({ turn, getState, set, syncContextStats }, delta) {
   set({ stats: { ...getState().stats }, ...(spinner ? { spinner: { ...spinner, inputTokens, outputTokens } } : {}) });
 }
 
+// The runtime reports the skills a user turn actually loaded (`Skill:` header
+// or inline `$name`); the prompt row carries them as `appliedSkills`, the same
+// field a restored row reads from the persisted transcript metadata.
+function applySkillsToPromptRow({ turn, getState, patchItem }, names, detail = {}) {
+  const appliedSkills = (Array.isArray(names) ? names : []).filter((name) => typeof name === 'string' && name);
+  if (!appliedSkills.length) return;
+  const messageId = typeof detail?.messageId === 'string' ? detail.messageId : '';
+  const submitted = turn.submittedIds[0];
+  const row = getState().items.findLast(
+    (item) => item?.kind === 'user' && (messageId ? item.messageId === messageId : item.id === submitted)
+  );
+  if (row) patchItem(row.id, { appliedSkills });
+}
+
 function turnHandlers(ctx) {
   const { isCurrentTurn, drainPendingSteering } = ctx;
   return {
+    onSkillsApplied: (names, detail) => {
+      if (isCurrentTurn()) applySkillsToPromptRow(ctx, names, detail);
+    },
     drainSteering: (_sessionId, drainOptions) =>
       isCurrentTurn() ? drainPendingSteering({ ...drainOptions, turnEpoch: ctx.turn.epoch }) : [],
     onStreamDelta: () => {},

package/src/runtime/effort-judge/previous-human-request.mjs

@@ -1,162 +0,0 @@
-// Pure pre-turn extraction of the previous human request and the assistant
-// text around it, from the session history as it stands BEFORE the current
-// turn is committed (the boundary resolveTurnAutoEffort runs at). Nothing here
-// reads the current prompt's outcome; nothing is mutated; no text is matched
-// against word lists. Ownership comes only from typed provenance that the
-// runtime already writes (meta.runtimeUserContext, meta.synthetic, meta.source,
-// the compaction/skill/reminder predicates in compact/messages.mjs).
-//
-// Result of previousHumanContext(messages, { retryPrompt }):
-//   {
-//     version: 1,
-//     boundary: number,          // messages[0..boundary) were considered
-//     retryTrimmedIndex: number, // index of the unanswered resubmitted prompt
-//                                // dropped from the view, or -1
-//     prevHuman: { text, index, source, runtimeContext } | null,
-//         // latest actual human message before the boundary. `text` is the
-//         // runtime-context-stripped, trimmed text (untruncated). `source` is
-//         // meta.source or null ('steering' = a human interjection).
-//         // `runtimeContext` is 'stripped' | 'none'.
-//     prevHumanMissing: 'empty-history' | 'no-human-request' | null,
-//     canonicalReply: { text, index } | null,
-//         // exactly what the shipped rp `prev` is: the latest non-empty
-//         // assistant message before the boundary, whatever turn it is from.
-//     pairedReply: { text, index } | null,
-//         // latest non-empty assistant text inside prevHuman's own turn span
-//         // (after prevHuman up to the next human message / boundary). Never
-//         // falls back to another turn: a tool-only or unanswered turn gives
-//         // null with pairedMissing set.
-//     pairedMissing: 'no-human-request' | 'no-assistant-text-in-turn' | null,
-//     replyIsPaired: boolean,    // canonicalReply and pairedReply are the same message
-//     skipped: [{ index, role, reason }], // user messages passed over after
-//         // prevHuman's search began (newest first); reasons: 'summary',
-//         // 'protected-context', 'skill-body', 'synthetic-flag',
-//         // 'typed-source', 'runtime-owned', 'empty'.
-//   }
-//
-// Policy decisions (PREVIOUS_HUMAN_POLICY):
-//   synthetic    meta.synthetic === true, or a source the runtime stores as
-//                "not the user speaking" (task-notification, skill-context),
-//                or anything isActualUserInstructionMessage rejects
-//                (goal-continuation/closeout, compact-*, *-recovery, control
-//                lines), is skipped, not treated as a request.
-//   steering     meta.source === 'steering' is a human interjection (the
-//                provider layer keeps it as its own user turn for that
-//                reason) and counts as a human request.
-//   retry        when retryPrompt repeats the trailing unanswered user prompt
-//                (trailingUnansweredPromptIndex), that stale copy is excluded
-//                so the prompt is never its own "previous request".
-//   summary      compact summaries are skipped; nothing before them is
-//                recovered, so history truncated by compaction yields
-//                'no-human-request' rather than a guess.
-// Limitation: user messages stored without meta (old transcripts) cannot be
-// told apart from the human when a runtime wrapper was never recorded; they
-// are accepted as human, and a wrapper with stale provenance stays unstripped.
-import { stripRuntimeUserContext } from '../agent/orchestrator/session/runtime-user-context.mjs';
-import {
-  isActualUserInstructionMessage,
-  isInjectedSkillBodyMessage,
-  isProtectedContextUserMessage,
-  isSummaryMessage,
-} from '../agent/orchestrator/session/compact/messages.mjs';
-import { trailingUnansweredPromptIndex } from '../agent/orchestrator/session/manager/failed-turn-rewind.mjs';
-import { promptContentText } from '../agent/orchestrator/session/manager/prompt-utils.mjs';
-
-export const PREVIOUS_HUMAN_POLICY = Object.freeze({
-  synthetic: 'skip',
-  steering: 'human',
-  retry: 'exclude-trailing-unanswered-copy',
-  summary: 'skip-no-recovery',
-});
-
-const TYPED_NON_HUMAN_SOURCES = new Set(['task-notification', 'skill-context']);
-
-const textOf = (message) => promptContentText(message?.content).trim();
-
-/** { human, reason?, message } for a user message; null for other roles. */
-function classify(message) {
-  if (message?.role !== 'user') return null;
-  const stripped = stripRuntimeUserContext(message);
-  const meta = stripped.meta && typeof stripped.meta === 'object' ? stripped.meta : {};
-  const no = (reason) => ({ human: false, reason, message: stripped });
-  if (isSummaryMessage(stripped)) return no('summary');
-  if (isProtectedContextUserMessage(stripped)) return no('protected-context');
-  if (isInjectedSkillBodyMessage(stripped)) return no('skill-body');
-  if (meta.synthetic === true) return no('synthetic-flag');
-  if (TYPED_NON_HUMAN_SOURCES.has(String(meta.source || ''))) return no('typed-source');
-  if (!isActualUserInstructionMessage(stripped)) return no('runtime-owned');
-  if (!textOf(stripped)) return no('empty');
-  return { human: true, message: stripped, stripped: stripped !== message };
-}
-
-function latestAssistant(messages, from, to) {
-  for (let index = to - 1; index >= from; index -= 1) {
-    if (messages[index]?.role !== 'assistant') continue;
-    const text = textOf(messages[index]);
-    if (text) return { text, index };
-  }
-  return null;
-}
-
-export function previousHumanContext(messages, { retryPrompt } = {}) {
-  const list = Array.isArray(messages) ? messages : [];
-  const retryTrimmedIndex = retryPrompt == null ? -1 : trailingUnansweredPromptIndex(list, retryPrompt);
-  const boundary = retryTrimmedIndex >= 0 ? retryTrimmedIndex : list.length;
-  const verdicts = [];
-  for (let index = 0; index < boundary; index += 1) verdicts.push(classify(list[index]));
-
-  const skipped = [];
-  let humanIndex = -1;
-  for (let index = boundary - 1; index >= 0; index -= 1) {
-    const verdict = verdicts[index];
-    if (!verdict) continue;
-    if (verdict.human) {
-      humanIndex = index;
-      break;
-    }
-    skipped.push({ index, role: 'user', reason: verdict.reason });
-    // A summary replaces earlier conversational context; do not recover a
-    // request from an older retained fragment behind that boundary.
-    if (verdict.reason === 'summary') break;
-  }
-
-  const canonicalReply = latestAssistant(list, 0, boundary);
-  let prevHuman = null;
-  let pairedReply = null;
-  let pairedMissing = 'no-human-request';
-  if (humanIndex >= 0) {
-    const verdict = verdicts[humanIndex];
-    const source = verdict.message.meta?.source;
-    prevHuman = {
-      text: textOf(verdict.message),
-      index: humanIndex,
-      source: typeof source === 'string' && source ? source : null,
-      runtimeContext: verdict.stripped ? 'stripped' : 'none',
-    };
-    let end = boundary;
-    for (let index = humanIndex + 1; index < boundary; index += 1) {
-      if (verdicts[index]?.human) {
-        end = index;
-        break;
-      }
-    }
-    pairedReply = latestAssistant(list, humanIndex + 1, end);
-    pairedMissing = pairedReply ? null : 'no-assistant-text-in-turn';
-  }
-
-  let prevHumanMissing = null;
-  if (!prevHuman) prevHumanMissing = boundary === 0 ? 'empty-history' : 'no-human-request';
-
-  return {
-    version: 1,
-    boundary,
-    retryTrimmedIndex,
-    prevHuman,
-    prevHumanMissing,
-    canonicalReply,
-    pairedReply,
-    pairedMissing,
-    replyIsPaired: Boolean(pairedReply && canonicalReply && pairedReply.index === canonicalReply.index),
-    skipped,
-  };
-}

package/src/runtime/effort-judge/verified-context-input.mjs

@@ -1,10 +0,0 @@
-// Experimental input only. An unavailable verified request preserves rp exactly.
-// Ownership and pairing are established by the caller, never inferred here.
-export function verifiedContextText({ request, prev, prevRequestVerified } = {}) {
-  const current = String(request || '').slice(0, 1500);
-  const reply = String(prev || '').slice(-1000);
-  const prior = Array.from(String(prevRequestVerified || ''))
-    .slice(0, 300)
-    .join('');
-  return `request: ${current}${prior ? `\nprevious request: ${prior}` : ''}\nprevious reply: ${reply}`;
-}