mixdog 1.4.1 → 1.4.3

package/src/runtime/agent/orchestrator/session/manager/turn-durability.mjs

@@ -0,0 +1,144 @@
+// manager/turn-durability.mjs
+// One unsettled turn per session. A finished (or failed) turn stays
+// unsettled — its checkpoint kept — until a landed save of its session
+// carries the turn's coverage token (store/transcript-durability.mjs); only
+// that acknowledgement deletes the checkpoint. The next turn of the session
+// waits for it before it opens its own checkpoint or touches the session, and
+// a save that cannot land blocks that turn with a TurnPersistenceError
+// instead of releasing it. A settled promise, an idle queue or a coalesced,
+// cancelled or dropped write is never an acknowledgement. Sessions are
+// independent: nothing here waits on another session's saves.
+import { readSessionLifecycleFromDisk, saveSessionAsync } from '../store.mjs';
+import { landedTranscript, landedTranscriptMatches, mintTranscriptEpoch } from '../store/transcript-durability.mjs';
+import { clearTurnCheckpoint } from './turn-checkpoint.mjs';
+
+const _unsettled = new Map(); // sessionId → { session, turnToken, generation, ack, error }
+
+export class TurnPersistenceError extends Error {
+  constructor(sessionId, message, cause = null) {
+    super(`Session ${sessionId}: ${message}${cause ? ` (${cause.message || cause})` : ''}`);
+    this.name = 'TurnPersistenceError';
+    this.code = 'ETURNNOTDURABLE';
+    this.sessionId = sessionId;
+    if (cause) this.cause = cause;
+  }
+}
+
+// Split-brain re-adoption: another surface (e.g. desktop click-through
+// of a session still actively owned by this process) may have
+// resumed-and-detached this session, bumping the ON-DISK generation
+// while the conversation kept going here. Every save from this process
+// would then be silently dropped by _shouldDrop's ownership rule and
+// the on-disk transcript would freeze at the last landed save. A new
+// ask on a NON-closed session is an explicit ownership claim: adopt
+// the disk generation so this turn's commits land and heal the file.
+export function adoptDiskGeneration(session, sessionId) {
+  const diskLifecycle = readSessionLifecycleFromDisk(sessionId);
+  if (
+    diskLifecycle &&
+    diskLifecycle.closed !== true &&
+    diskLifecycle.generation > (typeof session.generation === 'number' ? session.generation : 0)
+  ) {
+    session.generation = diskLifecycle.generation;
+  }
+}
+
+/** Whether a landed save of `session` carries `turnToken`'s coverage. */
+export function turnCoveredOnDisk(session, turnToken) {
+  return landedTranscript(session)?.coverage === turnToken;
+}
+
+function release(sessionId, entry) {
+  if (_unsettled.get(sessionId) !== entry) return;
+  _unsettled.delete(sessionId);
+  clearTurnCheckpoint(sessionId, entry.turnToken);
+}
+
+/** Keep `turnToken` (already the session's `turnCoverage`) unsettled until a
+ *  landed save covers it; `save` is the save expected to. Resolves whether
+ *  it did. */
+export function holdTurnUntilDurable({ sessionId, session, turnToken, generation, save }) {
+  const entry = { session, turnToken, generation, error: null, ack: null };
+  _unsettled.set(sessionId, entry);
+  entry.ack = Promise.resolve(save)
+    .then(
+      () => turnCoveredOnDisk(session, turnToken),
+      (error) => {
+        entry.error = error;
+        return false;
+      }
+    )
+    .then((covered) => {
+      if (covered) release(sessionId, entry);
+      return covered;
+    });
+  return entry.ack;
+}
+
+/** Whether this process holds a turn of `sessionId` not yet durable. */
+export function hasUnsettledTurn(sessionId) {
+  return _unsettled.has(sessionId);
+}
+
+/** A closed or deleted session: nothing will open on it again. */
+export function forgetUnsettledTurn(sessionId) {
+  _unsettled.delete(sessionId);
+}
+
+/** Resolves once the previous turn of `sessionId` is durably covered (its
+ *  checkpoint then deleted). When its own save did not land it, one fresh
+ *  save of the finalized transcript is attempted; if that does not land
+ *  either, throws TurnPersistenceError and the checkpoint stays. A save the
+ *  ownership guard refused because another surface moved the disk generation
+ *  is retried under that generation: this ask is the ownership claim that
+ *  adoptDiskGeneration describes, and the retry stays guarded by it, so a
+ *  closed session or a further handoff still refuses it. */
+export async function awaitPreviousTurnDurable(sessionId) {
+  const entry = _unsettled.get(sessionId);
+  if (!entry || (await entry.ack)) return;
+  adoptDiskGeneration(entry.session, sessionId);
+  entry.generation = Math.max(entry.generation, entry.session.generation);
+  try {
+    await saveSessionAsync(entry.session, { expectedGeneration: entry.generation });
+  } catch (error) {
+    entry.error = error;
+  }
+  if (!turnCoveredOnDisk(entry.session, entry.turnToken)) {
+    throw new TurnPersistenceError(
+      sessionId,
+      'the previous turn is not saved to disk, so the next turn cannot start',
+      entry.error
+    );
+  }
+  release(sessionId, entry);
+}
+
+/** Make `session`'s current transcript durable, so a turn opening on it
+ *  names a base that is on disk. A transcript that is not a pure extension
+ *  of the last landed one (an unsaved rewrite) starts a new epoch first. */
+export async function ensureDurableTranscript(session) {
+  if (landedTranscriptMatches(session)) return;
+  const landed = landedTranscript(session);
+  const messages = Array.isArray(session.messages) ? session.messages : [];
+  const extendsLanded =
+    landed &&
+    landed.epoch === session.transcriptEpoch &&
+    landed.refs.length <= messages.length &&
+    landed.refs.every((message, index) => message === messages[index]);
+  if (typeof session.transcriptEpoch !== 'string' || (landed && !extendsLanded)) {
+    session.transcriptEpoch = mintTranscriptEpoch();
+  }
+  let failure = null;
+  try {
+    await saveSessionAsync(session, { expectedGeneration: session.generation });
+  } catch (error) {
+    failure = error;
+  }
+  if (!landedTranscriptMatches(session)) {
+    throw new TurnPersistenceError(
+      session.id,
+      'the conversation is not saved to disk, so the next turn cannot start',
+      failure
+    );
+  }
+}

package/src/runtime/agent/orchestrator/session/manager/turn-interruption.mjs

@@ -195,8 +195,8 @@ function appendObservedTurnOutput(
   }
 }
 
-export function createTurnInterruptionTracker() {
-  const state = {
+function newInterruptionState() {
+  return {
     responseStarted: false,
     partialAssistantContent: '',
     tombstonedAssistantContent: '',
@@ -213,7 +213,10 @@ export function createTurnInterruptionTracker() {
     tombEpoch: 0,
     callsEpoch: 0,
   };
+}
 
+/** Streamed assistant text, including the tombstone of a retracted attempt. */
+function textBufferMethods(state) {
   return {
     recordTextDelta(chunk) {
       const value = String(chunk ?? '');
@@ -222,7 +225,7 @@ export function createTurnInterruptionTracker() {
       // The replayed attempt has started producing its OWN text, so the
       // retracted tail it replaces is no longer what the user is looking
       // at. Dropping it here keeps exactly one copy of the opening
-      // instead of one per retry (a 3-retry stall used to persist four
+      // instead of one per retry (a 3-retry stall would persist four
       // copies of the same first sentence). Reference agents never
       // commit a replayed attempt's discarded stream at all; the
       // tombstone exists only for the window between a retraction and
@@ -263,33 +266,12 @@ export function createTurnInterruptionTracker() {
       state.tombEpoch += 1;
       return true;
     },
-    hasResponseStarted() {
-      return state.responseStarted;
-    },
-    recordReasoningDelta(chunk) {
-      const value = String(chunk ?? '');
-      if (!value) return;
-      state.responseStarted = true;
-      state.partialReasoningContent += value;
-    },
-    recordAssistantText(text) {
-      const value = String(text ?? '');
-      if (!value.trim()) return;
-      state.responseStarted = true;
-      // Buffered providers report the whole segment here; streaming
-      // providers already accumulated the same segment via text deltas.
-      if (!state.partialAssistantContent.trim()) state.partialAssistantContent += value;
-    },
-    markAssistantMessageCommitted() {
-      state.partialAssistantContent = '';
-      state.tombstonedAssistantContent = '';
-      state.partialReasoningContent = '';
-      state.observedToolCalls.clear();
-      state.textEpoch += 1;
-      state.reasoningEpoch += 1;
-      state.tombEpoch += 1;
-      state.callsEpoch += 1;
-    },
+  };
+}
+
+/** Tool calls and early-notified results observed during the turn. */
+function toolObservationMethods(state) {
+  return {
     recordToolCalls(calls, { eagerStarted = false } = {}) {
       for (const call of Array.isArray(calls) ? calls : []) {
         if (!call?.id) continue;
@@ -317,6 +299,42 @@ export function createTurnInterruptionTracker() {
         state.observedToolResults.delete(callId);
       }
     },
+  };
+}
+
+export function createTurnInterruptionTracker() {
+  const state = newInterruptionState();
+
+  return {
+    ...textBufferMethods(state),
+    ...toolObservationMethods(state),
+    hasResponseStarted() {
+      return state.responseStarted;
+    },
+    recordReasoningDelta(chunk) {
+      const value = String(chunk ?? '');
+      if (!value) return;
+      state.responseStarted = true;
+      state.partialReasoningContent += value;
+    },
+    recordAssistantText(text) {
+      const value = String(text ?? '');
+      if (!value.trim()) return;
+      state.responseStarted = true;
+      // Buffered providers report the whole segment here; streaming
+      // providers already accumulated the same segment via text deltas.
+      if (!state.partialAssistantContent.trim()) state.partialAssistantContent += value;
+    },
+    markAssistantMessageCommitted() {
+      state.partialAssistantContent = '';
+      state.tombstonedAssistantContent = '';
+      state.partialReasoningContent = '';
+      state.observedToolCalls.clear();
+      state.textEpoch += 1;
+      state.reasoningEpoch += 1;
+      state.tombEpoch += 1;
+      state.callsEpoch += 1;
+    },
     markProviderSendStarted() {
       state.phase = 'streaming';
     },

package/src/runtime/agent/orchestrator/session/manager/turn-reap.mjs

@@ -0,0 +1,125 @@
+// manager/turn-reap.mjs
+// A turn abandoned by a timeout or stall stops the background shell work that
+// turn started — a job auto-promoted during it, and the survivors its commands
+// left running. Only those: a user cancel, a steering interrupt, a normal
+// finish, and jobs from earlier turns keep their jobs. Only the entry's own
+// turn start is armed, and a new turn clears it, so a reap that runs late
+// never touches a newer turn's work.
+import { cancelBackgroundTasks, getBackgroundTask } from '../../../../shared/background-tasks.mjs';
+import { runtimeState } from './runtime-state.mjs';
+
+// Timeout ownership is explicit and turn-scoped: the code that makes a timeout
+// WIN (the watchdog's own abort, the provider's terminal error) arms the reap
+// itself, and only while nothing else has stopped the turn. An abort that
+// arrives first stays a cancel; an error chain is never read afterwards.
+
+// Codes of the runtime's own timeout/stall errors (stall-policy's
+// streamStalledError / providerTimeoutError, the Gemini stream timeout).
+const PROVIDER_TIMEOUT_CODES = new Set(['ESTREAMSTALL', 'EPROVIDERTIMEOUT', 'EGEMINITIMEOUT']);
+
+/** A timeout is the first thing to stop this session's turn: arm its reap now,
+ *  before the abort propagates. No-op when the turn's controller is already
+ *  aborted (a cancel, interrupt or close won) or no turn runs. */
+export function armTurnTimeout(id) {
+  const entry = runtimeState.get(id);
+  if (!entry || entry.controller?.signal.aborted) return;
+  armTurnShellReap(id, entry);
+}
+
+/** The turn ended with a provider timeout/stall error that no retry recovered
+ *  from: arm only while the turn's own signal is un-aborted and the error
+ *  itself carries a timeout code or the producer's own `streamStalled` flag. */
+export function armTurnTimeoutOnProviderError(id, entry, turnSignal, err) {
+  if (turnSignal?.aborted) return;
+  if (!PROVIDER_TIMEOUT_CODES.has(err?.code) && err?.streamStalled !== true) return;
+  armTurnShellReap(id, entry);
+}
+
+// session id -> jobs stopped by a timeout reap, until the owner's handoff
+// reports them (or the session's next turn starts).
+const stoppedJobs = new Map();
+
+// What the cancel path already produces, read without waiting: a task whose
+// own cancel hook kills (survivors of a finished command) answers with its
+// kill outcome; a promoted job is over once its process tree is no longer
+// tracked.
+function trackStoppedJob(taskId) {
+  const job = { taskId, outcome: null, terminated: false };
+  const kill = getBackgroundTask(taskId)?.cancelOutcome;
+  if (kill) {
+    job.outcome = kill;
+    Promise.resolve(kill).then(
+      (result) => {
+        job.terminated = result?.terminated === true;
+      },
+      () => {}
+    );
+  }
+  return job;
+}
+
+// shell-jobs depends on the session manager, which loads this module, so it is
+// loaded at the first reap. The classification awaits only this module load,
+// never a process; a probe that cannot be loaded leaves a job "still stopping".
+let shellJobProbe = null;
+function loadShellJobProbe() {
+  shellJobProbe ??= import('../../tools/builtin/shell-jobs.mjs').then(
+    (shellJobs) => shellJobs.isShellJobRunning,
+    () => null
+  );
+  return shellJobProbe;
+}
+
+// Confirmed by the runtime's own state, never assumed: a task whose cancel hook
+// kills is confirmed by that kill's `terminated`; a promoted job once neither
+// its native task nor its process-tree tracker is live. Without the probe
+// (shell-jobs not loaded) nothing is confirmed.
+function isConfirmedGone(job, isRunning) {
+  if (job.outcome) return job.terminated;
+  return Boolean(isRunning) && !isRunning(job.taskId);
+}
+
+function reap(id, entry) {
+  loadShellJobProbe();
+  const { taskIds } = cancelBackgroundTasks({
+    surface: 'shell',
+    executionSessionId: id,
+    startedSinceMs: entry.shellReapSince,
+    reason: 'turn-timeout',
+    notify: false,
+  });
+  if (taskIds.length > 0) stoppedJobs.set(id, [...(stoppedJobs.get(id) || []), ...taskIds.map(trackStoppedJob)]);
+}
+
+/** The turn is being abandoned by a timeout: remember when it started and stop
+ *  what it has started so far. A settled (idle) entry has no turn to reap. */
+export function armTurnShellReap(id, entry) {
+  if (!(entry?.askStartedAt > 0) || entry.closed) return;
+  entry.shellReapSince = entry.askStartedAt;
+  reap(id, entry);
+}
+
+/** The abandoned turn has unwound: sweep what it registered while stopping
+ *  (survivors of its aborted commands). No-op unless this turn was armed. */
+export function reapTurnShellJobs(id, entry) {
+  if (entry?.shellReapSince > 0 && !entry.closed && runtimeState.get(id) === entry) reap(id, entry);
+}
+
+/** A new turn owns the session: nothing earlier may be reaped on its account. */
+export function resetTurnShellReap(id, entry) {
+  entry.shellReapSince = null;
+  stoppedJobs.delete(id);
+}
+
+/** The jobs the reap stopped, split by what is known now: `stopped` are
+ *  confirmed gone, `stopping` were killed but their processes are not yet
+ *  confirmed gone (they keep being terminated). */
+export async function takeStoppedShellJobs(id) {
+  const jobs = stoppedJobs.get(id) || [];
+  stoppedJobs.delete(id);
+  if (jobs.length === 0) return { stopped: [], stopping: [] };
+  const isRunning = await loadShellJobProbe();
+  const taskIds = (confirmed) =>
+    jobs.filter((job) => isConfirmedGone(job, isRunning) === confirmed).map((job) => job.taskId);
+  return { stopped: taskIds(true), stopping: taskIds(false) };
+}

package/src/runtime/agent/orchestrator/session/manager/usage-metrics.mjs

@@ -8,6 +8,7 @@
 import { providerInputExcludesCache } from '../../providers/registry.mjs';
 import { reasoningUsage, combineReasoningUsage } from '../../../../shared/llm/reasoning-usage.mjs';
 import { foldUsageReadout } from '../../../../shared/usage-readout-totals.mjs';
+import { emitSessionActivityChange } from '../../../../shared/session-activity-signal.mjs';
 import {
   loadSession,
   saveSessionAsync,
@@ -560,6 +561,9 @@ export async function persistIterationMetrics(delta) {
     // saved before this field began at their first call after it.
     session.usageReadout = foldUsageReadout(session.usageReadout, delta, delta.requestMs);
     recordLastContextTokens(session, iterationContext(delta));
+    // The Agents pool shows each agent's running totals from this live
+    // counter: it re-reads on this pulse instead of the next throttled save.
+    emitSessionActivityChange(sessionId);
   }
   session.lastIterationIndex = iterationIndex;
   session.updatedAt = ts || Date.now();

package/src/runtime/agent/orchestrator/session/manager.mjs

@@ -65,7 +65,12 @@ export {
   settlePendingMessageWrites,
   markCompletionEntry,
   COMPLETION_NOTIFICATION_KIND,
+  hasPendingMessages,
 } from './manager/pending-messages.mjs';
+// The per-session ask mutex every turn holds, tried without waiting, and the
+// unsettled-turn check: the idle-only delete (session-delete.mjs) acts under them.
+export { tryAcquireSessionLock, sessionLockContended } from './manager/session-lock.mjs';
+export { hasUnsettledTurn } from './manager/turn-durability.mjs';
 
 // ── Usage-metrics surface — re-exported unchanged so loop.mjs / smoke scripts
 //    keep resolving these through the facade. ────────────────────────────────
@@ -96,6 +101,7 @@ export { prewarmAgentLoop } from './manager/runtime-loaders.mjs';
 export {
   createSession,
   updateSessionRoute,
+  holdSessionRoute,
   prefetchSession,
   prepareSessionProjection,
   resumeSession,

package/src/runtime/agent/orchestrator/session/mixy-name.mjs

@@ -3,15 +3,19 @@
 // Every model- or user-facing string that names it reads this, re-read on each
 // use so a rename applies at once. Text shared across agents (tool schemas,
 // other agents' shared prompt block) says "the representative agent" instead,
-// so a rename never changes cached bytes.
-import { dirname, join } from 'node:path';
-import { mixdogGlobalDir, readSafe } from '../context/skill-catalog.mjs';
+// so a rename never changes those cached bytes. Each other bot's own contact
+// catalog (workflow/context.mjs) names her, so a request naming her finds her.
+// Light imports only: the prompt's contact catalog (workflow/context.mjs) reads
+// the name too, and must not pull the skill catalog and config in with it.
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { resolvePluginData } from '../../../shared/plugin-paths.mjs';
 import { mixyIdentityDir } from '../../../shared/agent-store.mjs';
 
 export const DEFAULT_MIXY_NAME = 'Mixy';
 
 /** The display name in a lead manifest (agent.json), else Mixy. */
-export function mixyNameOf(manifest) {
+function mixyNameOf(manifest) {
   const name = typeof manifest?.name === 'string' ? manifest.name.replace(/\s+/g, ' ').trim() : '';
   return name || DEFAULT_MIXY_NAME;
 }
@@ -19,9 +23,11 @@ export function mixyNameOf(manifest) {
 export function mixyDisplayName() {
   try {
     // bots/mixy once Mixy is its own bot, agents/lead before (agent-store.mjs).
-    const dir = mixyIdentityDir(dirname(mixdogGlobalDir('agents')));
-    return mixyNameOf(JSON.parse(readSafe(join(dir, 'agent.json')) || '{}'));
+    const dir = mixyIdentityDir(resolvePluginData());
+    return mixyNameOf(JSON.parse(readFileSync(join(dir, 'agent.json'), 'utf8')));
   } catch {
+    // Never throws: prompt composition calls this unguarded, and the name only labels Mixy.
+    // A missing, empty, unreadable or malformed agent.json is the unrenamed default.
     return DEFAULT_MIXY_NAME;
   }
 }

package/src/runtime/agent/orchestrator/session/pre-send-compact.mjs

@@ -41,6 +41,7 @@ import {
   snapshotPendingGoalReminder,
 } from '../runtime-core/goal-reminder.mjs';
 import { rearmLateDeferredTools } from '../runtime-core/tool-catalog.mjs';
+import { rearmPromptSettingsNotice } from './manager/prompt-settings.mjs';
 
 async function setStage(opts, stage) {
   try {
@@ -437,7 +438,12 @@ function adoptCompactedTranscript(ctx, run) {
   // The system prompt is rebuilt from current sources outside a running turn
   // (session-runtime agent-profile-fold.mjs): the next cold point folds it in
   // instead of adding a break to the turn that is already warm again.
-  if (sessionRef) sessionRef.promptFoldPending = true;
+  // The fold runs at the next turn start (compactionFoldPending): it lists the
+  // late tools and the settings this compaction dropped the notices of.
+  if (sessionRef) {
+    sessionRef.promptFoldPending = true;
+    sessionRef.compactionFoldPending = true;
+  }
   resetReadStateAfterCompaction(sessionId);
   // Cross-turn receipts reference tool results that compaction just removed
   // from context; a stub for them would point at nothing. Clear in place so
@@ -573,6 +579,7 @@ async function compactBeforeSend(ctx) {
     // The adopted compaction strips late MCP tool announcements from older turns.
     try {
       rearmLateDeferredTools(sessionRef);
+      rearmPromptSettingsNotice(sessionRef);
     } catch {
       /* best-effort, like the Goal reminder: a tool reminder never fails the compaction */
     }

package/src/runtime/agent/orchestrator/session/restart-prefix-parity.fixture.mjs

@@ -1,4 +1,4 @@
-// Child process of restart-prefix-parity.test.mjs: one phase of a scripted
+// Child process of restart-prefix-parity.slow.test.mjs: one phase of a scripted
 // anthropic-oauth session in its own process, so a "restart" is a real new
 // process reading the data dir the previous one left. The fake provider
 // records the request body the real OAuth builder makes for every main-loop

package/src/runtime/agent/orchestrator/session/save-session-worker.mjs

@@ -60,9 +60,13 @@ parentPort.on('message', (message) => {
     }
     return;
   }
-  const { session, delta, id, opts, reqId } = message || {};
+  const { session, delta, id, opts, reqId, dataDir } = message || {};
   let full = session;
   try {
+    // This realm's env was copied when the worker spawned; the parent's data
+    // dir may have moved since (save-worker.mjs _postAsyncWrite), and every
+    // path below resolves it from the env at call time.
+    if (dataDir) process.env.MIXDOG_DATA_DIR = dataDir;
     const sessionId = id ?? session?.id;
     if (!full && delta) {
       const base = _baseMessages.get(sessionId);

package/src/runtime/agent/orchestrator/session/store/canonical-reader.mjs

@@ -190,7 +190,7 @@ export function withdrawPendingOwnCommit(target, scratchStamp) {
 }
 
 /** Read-only lifecycle verdict of a pending peer commit whose identity `stamp` carries. */
-export function pendingOwnCommittedLifecycle(target, stamp) {
+function pendingOwnCommittedLifecycle(target, stamp) {
   _absorbPeerCommits();
   const pending = _pendingOwnCommits.get(target);
   return pending && _sameScratchIdentity(pending.stamp, stamp) ? pending.value : null;

package/src/runtime/agent/orchestrator/session/store/liveness-veto.mjs

@@ -17,7 +17,7 @@ import { probePath, readTextFile, PROBE_PRESENT } from './fs-probe.mjs';
 export const LEGACY_MARKER_SUFFIXES = ['.hb', '.own'];
 // An older live owner rewrote `.hb` every ≤5s mid-turn and `.own` every ~20s
 // while holding the session open; one untouched this long holds nothing.
-export const LEGACY_MARKER_FRESH_MS = 2 * 60 * 1000;
+const LEGACY_MARKER_FRESH_MS = 2 * 60 * 1000;
 
 function processAlive(pid) {
   try {
@@ -47,7 +47,7 @@ export function readLegacyMarker(path, now = Date.now()) {
 
 /** Whether a legacy marker of the session names a live owner pid with a
  *  fresh heartbeat: that session is driven by another live process. */
-export function _legacyOwnerLivenessVeto(id, now = Date.now()) {
+function _legacyOwnerLivenessVeto(id, now = Date.now()) {
   if (typeof id !== 'string' || !/^[A-Za-z0-9_-]+$/.test(id)) return false;
   const dir = getStoreDir();
   return LEGACY_MARKER_SUFFIXES.some((suffix) => {

package/src/runtime/agent/orchestrator/session/store/save-worker.mjs

@@ -18,6 +18,8 @@ import {
   _acquireSessionIncarnation,
   _releaseSessionIncarnation,
   _isCurrentSessionIncarnation,
+  SAVE_OUTCOME_SAVED,
+  SAVE_OUTCOME_DROPPED,
   SAVE_OUTCOME_STALE,
 } from './live-state.mjs';
 import {
@@ -33,6 +35,8 @@ import {
   _sessionStoreTestMode,
 } from './save-fault.mjs';
 import { connectOwnCommitPeer } from './canonical-reader.mjs';
+import { getPluginData } from '../../config.mjs';
+import { captureTranscriptSnapshot, recordLandedTranscript } from './transcript-durability.mjs';
 
 // ── Worker-thread async save ──────────────────────────────────────────────────
 // Single long-lived Worker serializes all saveSessionAsync calls.
@@ -278,6 +282,7 @@ function _settleLandedWrite(
     // built — never a row re-derived from the live session, which
     // may already carry a newer (unwritten, possibly failing) turn.
     _queueSessionSummaryUpsertRow(summaryRow, summaryVersion);
+    recordLandedTranscript(p.session, p.transcript, epoch);
     // ONLY a landed write proves durability, so this is the only
     // place the save-failure flag may be cleared — and only when
     // THIS payload is at least as new as the newest failed/dropped
@@ -304,7 +309,14 @@ function _settleLandedWrite(
     _rollbackCachedSessionSummary(id, summaryVersion);
     _recordSaveDrop(id, epoch);
   }
-  for (const w of waiters) w.resolve();
+  // Callers that act only on a durable write (e.g. a migration deleting its
+  // source) read this outcome; every other resolution leaves it undefined.
+  const settled = saved
+    ? SAVE_OUTCOME_SAVED
+    : outcome === SAVE_OUTCOME_STALE
+      ? SAVE_OUTCOME_STALE
+      : SAVE_OUTCOME_DROPPED;
+  for (const w of waiters) w.resolve(settled);
 }
 
 /**
@@ -531,6 +543,9 @@ function _postAsyncWrite(
   { forceFull = false, retriedFull = false } = {}
 ) {
   const reqId = ++_saveWorkerReqId;
+  // Before the bytes are built: what this write will prove durable once it
+  // lands (store/transcript-durability.mjs).
+  const transcript = captureTranscriptSnapshot(session);
   // The wire payload is built at POST time from the live session: N calls
   // coalesced behind one in-flight write project ONCE (newest state), and a
   // pure-append turn ships only the tail (see _buildWirePayload).
@@ -548,6 +563,7 @@ function _postAsyncWrite(
   _saveWorkerPending.set(reqId, {
     id,
     session,
+    transcript,
     attempt,
     opts,
     summaryVersion,
@@ -567,7 +583,12 @@ function _postAsyncWrite(
     // Cheap key compare; posts only when the fault config/env moved.
     _syncFaultToWorker(w);
     const { attempt: _attempt, ...wireForPost } = wire;
-    w.postMessage({ ...wireForPost, id, opts, reqId });
+    // The worker's process.env is a copy taken at spawn, so a data dir that
+    // moved since (a pristine headless run per page) would otherwise keep
+    // receiving writes in the first run's removed directory. The dir current
+    // at POST time travels with the write: a write still queued in the worker
+    // when the env flips lands where its own session lives.
+    w.postMessage({ ...wireForPost, id, opts, reqId, dataDir: getPluginData() });
     // Ref AFTER successful postMessage so a queue/throw failure path does
     // not leave the worker held alive with no pending message. Paired with
     // the unref in the message handler when count hits 0.

package/src/runtime/agent/orchestrator/session/store/sweep/sub-agent-retention.mjs

@@ -16,12 +16,12 @@ import { deleteSession } from '../session-delete.mjs';
 import { readSweepRecord } from './sweep-record.mjs';
 
 const DAY_MS = 24 * 60 * 60 * 1000;
-export const SUB_AGENT_ARCHIVE_AFTER_MS = 3 * DAY_MS;
-export const SUB_AGENT_DELETE_AFTER_MS = 30 * DAY_MS;
+const SUB_AGENT_ARCHIVE_AFTER_MS = 3 * DAY_MS;
+const SUB_AGENT_DELETE_AFTER_MS = 30 * DAY_MS;
 const PERMANENT_ID = /^sess_(?:home|room|rmem)_/;
 // The desktop change an automatic archive applies: that one session, no
 // cascade (an explicit archive of a parent takes its sub-agents along).
-export const SUB_AGENT_AUTO_ARCHIVE = Object.freeze({ archived: true, cascade: false });
+const SUB_AGENT_AUTO_ARCHIVE = Object.freeze({ archived: true, cascade: false });
 
 const positive = (value) => (Number(value) > 0 ? Number(value) : 0);