mixdog 1.1.2 → 1.2.1

package/src/runtime/agent/orchestrator/session/store-summary-fields.mjs

@@ -19,6 +19,42 @@ export function cleanValue(value) {
   return String(value || '').trim();
 }
 
+const textOrNull = (value) => cleanValue(typeof value === 'string' ? value : '') || null;
+const TRANSITION_STATES = new Set(['idle', 'provisioning', 'switching', 'removing', 'recovery']);
+
+/** Catalog view of a session workspace record (the SessionWorkspace shape of
+ *  runtime/shared/worktrees/contract.mjs): where it executes (`cwd`, `branch`,
+ *  `worktreeId`) under which registered Project (`projectPath`), at which
+ *  `revision`. Null when the record is absent or lacks either path, so
+ *  consumers group by `projectPath` and never mistake a worktree `cwd` for
+ *  the project. */
+export function workspaceSummary(value) {
+  if (!value || typeof value !== 'object') return null;
+  const projectPath = cleanValue(typeof value.projectPath === 'string' ? value.projectPath : '');
+  const cwd = cleanValue(typeof value.cwd === 'string' ? value.cwd : '');
+  if (!projectPath || !cwd || projectPath.includes('\0') || cwd.includes('\0')) return null;
+  const state = TRANSITION_STATES.has(value.transition?.state) ? value.transition.state : 'idle';
+  const txId = state === 'idle' ? null : textOrNull(value.transition?.txId);
+  return {
+    projectPath,
+    repoCommonDir: textOrNull(value.repoCommonDir),
+    cwd,
+    worktreeId: textOrNull(value.worktreeId),
+    branch: textOrNull(value.branch),
+    baseCommit: textOrNull(value.baseCommit),
+    mergeTarget: textOrNull(value.mergeTarget),
+    revision: Number.isSafeInteger(value.revision) && value.revision >= 0 ? value.revision : 0,
+    transition: txId ? { state, txId } : { state: 'idle', txId: null },
+  };
+}
+
+/** Dedupe key of an imported conversation: a session's `importOrigin.key`,
+ *  or a summary row's projected `importKey`; null for ordinary sessions. */
+export function importKey(value) {
+  const key = typeof value?.importKey === 'string' ? value.importKey : value?.importOrigin?.key;
+  return typeof key === 'string' && key.trim() ? key : null;
+}
+
 export function desktopSession(value, cwd = '') {
   if (!value || typeof value !== 'object') return null;
   if (value.classification === 'task') return { classification: 'task', projectPath: null };

package/src/runtime/agent/orchestrator/session/store-summary-index.mjs

@@ -15,18 +15,15 @@ import {
   writeJsonAtomicAsync,
   writeJsonAtomicSync,
 } from '../../../shared/atomic-file.mjs';
-import {
-  applySummaryLogText,
-  encodeSummaryOps,
-  summaryLogPath,
-} from './store-summary-log.mjs';
-import {
-  cleanSessionPreview,
-  isSessionPreviewNoise,
-  sessionMessageText,
-} from '../runtime-core/session-text.mjs';
+import { applySummaryLogText, encodeSummaryOps, summaryLogPath } from './store-summary-log.mjs';
+import { cleanSessionPreview, isSessionPreviewNoise, sessionMessageText } from '../runtime-core/session-text.mjs';
 import { sessionVisibility } from './store-summary-visibility.mjs';
-import { isStoredSessionId, positiveNumber as _positiveNumber } from './store-summary-fields.mjs';
+import {
+  importKey,
+  isStoredSessionId,
+  positiveNumber as _positiveNumber,
+  workspaceSummary,
+} from './store-summary-fields.mjs';
 
 export const SESSION_SUMMARY_INDEX_VERSION = 2;
 
@@ -182,11 +179,13 @@ export function _sessionSummary(session) {
     clientHostPid: _positiveNumber(session.clientHostPid, 0) || null,
     cwd: session.cwd || '',
     desktopSession: _desktopSessionSummary(session.desktopSession, session.cwd),
+    ...(workspaceSummary(session.workspace) ? { workspace: workspaceSummary(session.workspace) } : {}),
     provider: session.provider || null,
     model: session.model || null,
     presetName: session.presetName || session.profileId || null,
     effort: session.effort || null,
     fast: session.fast === true,
+    ...(session.autoEffort === false ? { autoEffort: false } : {}),
     modelParameters:
       session.modelParameters && typeof session.modelParameters === 'object' ? { ...session.modelParameters } : null,
     agentTag: session.agentTag || null,
@@ -207,6 +206,9 @@ export function _sessionSummary(session) {
     // Lifecycle provenance for catalog filters: resume-machinery scratch
     // forks (detachedReason='cli-resume') must never surface in Recent.
     detachedReason: session.detachedReason || null,
+    // Imported-conversation identity, so "already imported" is answered
+    // from summaries without loading sessions.
+    importKey: importKey(session),
   };
 }
 
@@ -231,11 +233,13 @@ function _normalizeSummaryRow(row) {
     clientHostPid: _positiveNumber(row.clientHostPid, 0) || null,
     cwd: row.cwd || '',
     desktopSession: _desktopSessionSummary(row.desktopSession, row.cwd),
+    ...(workspaceSummary(row.workspace) ? { workspace: workspaceSummary(row.workspace) } : {}),
     provider: row.provider || null,
     model: row.model || null,
     presetName: row.presetName || row.profileId || null,
     effort: row.effort || null,
     fast: row.fast === true,
+    ...(row.autoEffort === false ? { autoEffort: false } : {}),
     modelParameters: row.modelParameters && typeof row.modelParameters === 'object' ? { ...row.modelParameters } : null,
     agentTag: row.agentTag || null,
     task_id: row.task_id || null,
@@ -253,6 +257,7 @@ function _normalizeSummaryRow(row) {
     storageMtimeMs: _positiveNumber(row.storageMtimeMs, 0),
     storageSize: _positiveNumber(row.storageSize, 0),
     detachedReason: row.detachedReason || null,
+    importKey: importKey(row),
   };
 }
 
@@ -350,7 +355,9 @@ function _scheduleSummaryRetry() {
 // Defer the flush off the caller's stack: file I/O has no business on the
 // keystroke/session-save path.
 function _scheduleSummaryFlush() {
-  if (_summaryFlushScheduled) return;
+  // A scheduled retry will write whatever is pending; a flush in flight
+  // schedules one follow-up when it settles. Either way, don't start another.
+  if (_summaryFlushScheduled || _summaryRetryTimer || _summaryFlushInflight > 0) return;
   _summaryFlushScheduled = true;
   setImmediate(() => {
     _summaryFlushScheduled = false;
@@ -361,6 +368,9 @@ function _scheduleSummaryFlush() {
 
 export function _flushPendingSummaryOps({ sync = false } = {}) {
   if (_pendingUpserts.size === 0 && _pendingRemovals.size === 0) return;
+  // One async flush in flight per process; ops queued meanwhile stay pending
+  // and are drained by the follow-up flush scheduled when it settles.
+  if (!sync && _summaryFlushInflight > 0) return;
   // Snapshot + clear first: ops queued by other callers DURING the flush
   // must not be lost, and a failed flush re-queues only what it took
   // (without clobbering anything newer queued meanwhile).
@@ -416,6 +426,7 @@ export function _flushPendingSummaryOps({ sync = false } = {}) {
     .catch(requeue)
     .finally(() => {
       _summaryFlushInflight--;
+      if (_pendingUpserts.size > 0 || _pendingRemovals.size > 0) _scheduleSummaryFlush();
       _notifySummarySettled();
     });
 }

package/src/runtime/agent/orchestrator/session/store-summary-reader-catalog-fixture.mjs

@@ -0,0 +1,158 @@
+// Shared fixture of the ordinary-catalog tests: a scratch data dir, the
+// writers that touch it (index-updating, rename-only, in-place) and a spy on
+// the filesystem work the cold reader does.
+import assert from 'node:assert/strict';
+import fs, {
+  appendFileSync,
+  mkdirSync,
+  mkdtempSync,
+  renameSync,
+  rmSync,
+  statSync,
+  unlinkSync,
+  writeFileSync,
+} from 'node:fs';
+import fsp from 'node:fs/promises';
+import { syncBuiltinESMExports } from 'node:module';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import test from 'node:test';
+
+import { encodeSummaryOps } from './store-summary-log.mjs';
+import { listStoredSessionSummaries } from './store-summary-reader.mjs';
+
+const roots = [];
+let root = '';
+test.after(() => {
+  for (const dir of roots) rmSync(dir, { recursive: true, force: true, maxRetries: 10, retryDelay: 50 });
+});
+
+/** Point the reader at a fresh data dir with an empty sessions directory. */
+export function useDataDir(prefix) {
+  root = mkdtempSync(join(tmpdir(), prefix));
+  roots.push(root);
+  mkdirSync(join(root, 'sessions'));
+  process.env.MIXDOG_DATA_DIR = root;
+}
+
+export const sessionsDir = () => join(root, 'sessions');
+export const fileOf = (id) => join(sessionsDir(), `${id}.json`);
+export const indexPath = () => join(root, 'session-summaries.json');
+export const logPath = () => join(root, 'session-summaries.log');
+
+const record = (id, text) =>
+  JSON.stringify({
+    id,
+    owner: 'user',
+    agent: 'lead',
+    closed: false,
+    generation: 1,
+    updatedAt: 1,
+    messages: [{ role: 'user', content: text }],
+  });
+
+/** The store's writers replace a record by temp file + rename. */
+export function replace(id, text) {
+  writeFileSync(`${fileOf(id)}.tmp`, record(id, text));
+  renameSync(`${fileOf(id)}.tmp`, fileOf(id));
+}
+
+/** A writer outside the store that rewrites the record in place. */
+export const rewriteInPlace = (id, text) => writeFileSync(fileOf(id), record(id, text));
+
+/** What the summary index records for the file as it is now; the `indexed:`
+ *  title tells an index row from a row parsed from the file. */
+export const indexRow = (id, text, fingerprint = statSync(fileOf(id))) => ({
+  id,
+  owner: 'user',
+  agent: 'lead',
+  status: 'idle',
+  messageCount: 1,
+  title: `indexed:${text}`,
+  preview: text,
+  updatedAt: 1,
+  storageMtimeMs: fingerprint.mtimeMs,
+  storageSize: fingerprint.size,
+});
+
+export function writeBase(rows) {
+  writeFileSync(`${indexPath()}.tmp`, JSON.stringify({ version: 2, rows }));
+  renameSync(`${indexPath()}.tmp`, indexPath());
+}
+
+export const appendLog = (upserts, removals = []) => appendFileSync(logPath(), encodeSummaryOps(upserts, removals));
+
+/** An index-updating writer: the record, then its summary row. */
+export function saveIndexed(id, text) {
+  replace(id, text);
+  appendLog([indexRow(id, text)]);
+}
+
+/** A namespace change that touches no session. */
+export function touchDirectory() {
+  writeFileSync(join(sessionsDir(), 'unrelated.tmp'), '');
+  unlinkSync(join(sessionsDir(), 'unrelated.tmp'));
+}
+
+export const list = () => listStoredSessionSummaries();
+export const view = (rows = list()) => Object.fromEntries(rows.map((row) => [row.id, `${row.title}|${row.preview}`]));
+
+/** The authoritative refresh parses every file, so it agrees with the
+ *  ordinary catalog on which sessions exist and what they show, not on
+ *  index-only titles. */
+export function assertMatchesStorage() {
+  const previews = (rows) => Object.fromEntries(rows.map((row) => [row.id, row.preview]));
+  assert.deepEqual(previews(list()), previews(listStoredSessionSummaries({ refreshFromStorage: true })));
+}
+
+/** A directory stamp younger than the racy window is never trusted; wait it
+ *  out so the following calls exercise the stamp-keyed path. */
+export const settle = () => new Promise((resolve) => setTimeout(resolve, 2_100));
+
+/** Counts the filesystem work the reader does; `failing` paths throw EACCES
+ *  on every call, `failingReads` paths on reads only (a stat still works). */
+export function spyFs(t, failing = new Set(), failingReads = new Set()) {
+  const counts = { stats: 0, sessionFileStats: new Set(), readdirs: 0, reads: 0, asyncStats: 0 };
+  const original = {
+    statSync: fs.statSync,
+    readdirSync: fs.readdirSync,
+    readFileSync: fs.readFileSync,
+    stat: fsp.stat,
+  };
+  const denied = (path) => {
+    if (!failing.has(String(path))) return;
+    throw Object.assign(new Error(`EACCES: ${path}`), { code: 'EACCES' });
+  };
+  fs.statSync = function (path, ...rest) {
+    counts.stats++;
+    if (String(path).endsWith('.json') && String(path).startsWith(sessionsDir())) {
+      counts.sessionFileStats.add(String(path));
+    }
+    denied(path);
+    return original.statSync.call(this, path, ...rest);
+  };
+  fs.readdirSync = function (...args) {
+    counts.readdirs++;
+    return original.readdirSync.apply(this, args);
+  };
+  fs.readFileSync = function (path, ...rest) {
+    counts.reads++;
+    denied(path);
+    if (failingReads.has(String(path))) throw Object.assign(new Error(`EIO: ${path}`), { code: 'EIO' });
+    return original.readFileSync.call(this, path, ...rest);
+  };
+  fsp.stat = async function (path, ...rest) {
+    counts.asyncStats++;
+    denied(path);
+    return original.stat.call(this, path, ...rest);
+  };
+  syncBuiltinESMExports();
+  t.after(() => {
+    fs.statSync = original.statSync;
+    fs.readdirSync = original.readdirSync;
+    fs.readFileSync = original.readFileSync;
+    fsp.stat = original.stat;
+    syncBuiltinESMExports();
+  });
+  return counts;
+}