mixdog 1.2.2 → 1.2.4

package/src/runtime/agent/orchestrator/session/side-question.mjs

@@ -0,0 +1,197 @@
+// side-question.mjs — /btw: a quick question answered while the main turn
+// keeps working. The answer comes from a cache-sharing fork of the session's
+// latest provider request (side-question-store.mjs): the same model, system
+// prompt, tools and cache-relevant options and the same message prefix, so
+// the provider's prompt cache serves the prefix. Only the reply that request
+// produced and one question are appended. One provider call, no tool loop;
+// the answer is returned to the caller and never enters the transcript.
+import { collectAssistantToolCallIds } from './context-tool-pairs.mjs';
+import { buildIntermediateAssistantMessage, buildToolCallAssistantMessage } from './loop/assistant-commit.mjs';
+import { logSessionLlmUsage } from './manager/ask-turn-commit.mjs';
+import { disposeTransportScope, forkTransportScope } from '../providers/transport-scope.mjs';
+import { isAgentOwner } from '../agent-owner.mjs';
+import { getProvider } from '../providers/registry.mjs';
+import { prepareTurnEffortConfiguration } from '../providers/effort-configuration.mjs';
+import { providerNativeToolPrefixCount } from '../runtime-core/provider-request-tools.mjs';
+import { snapshotProviderRequestTools } from '../runtime-core/tool-catalog.mjs';
+import { repairTranscriptBeforeProviderSend } from './loop/transcript-repair.mjs';
+import { buildRequestSendOptions } from './manager/ask-turn-loop-options.mjs';
+import { filterModelVisibleSessionMessages } from './manager/message-sanitize.mjs';
+import { hasUserConversationMessage } from './manager/prompt-utils.mjs';
+import { loadSession } from './store.mjs';
+import { projectSyntheticUserEnvelopes } from './synthetic-user-envelope.mjs';
+import { beginSideQuestion, sideQuestionRequest, sideQuestionRequestSnapshot } from './side-question-store.mjs';
+
+export { cancelSideQuestion } from './side-question-store.mjs';
+
+export const SIDE_QUESTION_NO_REQUEST = 'Send a message first, then try /btw.';
+export const SIDE_QUESTION_TOOL_ATTEMPT =
+  'The model tried to use a tool instead of answering. A side question cannot run tools; try asking it differently.';
+const SIDE_QUESTION_EMPTY_ANSWER = 'The model returned no answer.';
+
+// The reply's tool calls run in the main session; the fork only needs each
+// call answered so the request stays well-formed.
+const SIDE_QUESTION_TOOL_STUB =
+  'This tool call belongs to the main task and is handled there; its result is not part of this side question.';
+
+function sideQuestionPrompt(question) {
+  return [
+    '<side-question>',
+    'The user is asking you a quick side question. The main agent keeps working on the task on its own;',
+    'this exchange does not reach it and does not change that work.',
+    'Answer directly, in this one response, from what this conversation already contains.',
+    'No tools are available here: do not call any, and do not offer or promise to do anything.',
+    'If the conversation does not tell you the answer, say that you do not know.',
+    '',
+    question,
+    '</side-question>',
+  ].join('\n');
+}
+
+// The assistant turn the saved request produced, built the way the loop
+// commits it (without the turn's one-shot transcript metadata), plus a stub
+// result per tool call.
+function replyMessages(response) {
+  if (!response) return [];
+  const reply = response.toolCalls?.length
+    ? buildToolCallAssistantMessage(response, { calls: response.toolCalls, opts: {} })
+    : buildIntermediateAssistantMessage(response, {});
+  if (!reply) return [];
+  const stubs = collectAssistantToolCallIds(reply).map((id) => ({
+    role: 'tool',
+    toolCallId: id,
+    content: SIDE_QUESTION_TOOL_STUB,
+  }));
+  return [reply, ...stubs];
+}
+
+/**
+ * The fork of a saved request: its messages unchanged, then the reply and
+ * the question. The send options are the saved ones; the provider
+ * continuation state follows the reply when it is appended, exactly as the
+ * main loop's next request would carry it. `sharedCachePrefixCount` (the
+ * shared prefix's message count, which survives model-proxy serialization)
+ * keeps an Anthropic message breakpoint on the shared prefix, so the fork reads the
+ * saved request's cache entry and writes none for its suffix.
+ */
+export function buildSideQuestionRequest(request, question) {
+  const reply = replyMessages(request.response);
+  const opts = { ...request.opts };
+  if (reply.length && Object.hasOwn(request.response, 'providerState')) {
+    opts.providerState = request.response.providerState;
+  }
+  if (request.messages.length) opts.sharedCachePrefixCount = request.messages.length;
+  const messages = [
+    ...request.messages,
+    ...reply,
+    // A user interjection keeps its own turn (never folded into a preceding
+    // tool result), so the prefix's last block reaches the provider unchanged.
+    { role: 'user', content: sideQuestionPrompt(question), meta: { source: 'steering' } },
+  ];
+  return { messages, opts };
+}
+
+/**
+ * The request the main loop would send next for a session that has none saved
+ * (the runtime restarted, or the saved one was forgotten): the session's own
+ * provider, model, tools, send options and transcript, assembled by the same
+ * pieces the loop uses, without the loop's side effects (no compaction, no
+ * transcript repair in place, nothing written to the session). Null when the
+ * session has no conversation, no resolvable provider, or is an agent's.
+ */
+function nextMainRequest(sessionId) {
+  const session = sessionId ? loadSession(sessionId) : null;
+  if (!session || session.closed === true || isAgentOwner(session)) return null;
+  if (!hasUserConversationMessage(session.messages)) return null;
+  const provider = getProvider(session.provider);
+  if (!provider) return null;
+  const transcript = filterModelVisibleSessionMessages(session.messages);
+  repairTranscriptBeforeProviderSend(transcript, sessionId);
+  const opts = buildRequestSendOptions({
+    sessionId,
+    session,
+    turnEffort: session.effort || null,
+    effortConfiguration: prepareTurnEffortConfiguration(session, provider),
+    stepAutoEffort: null,
+    codexTurnId: null,
+    startedAtMs: Date.now(),
+    signal: undefined,
+  });
+  const sendTools = snapshotProviderRequestTools({
+    provider: session.provider || provider.name,
+    tools: session.tools,
+    nativeTools: opts.nativeTools,
+    messages: transcript,
+    session,
+  });
+  opts.iteration = 1;
+  opts.providerToolSnapshotAuthoritative = true;
+  opts.providerNativeToolPrefixCount = providerNativeToolPrefixCount(sendTools);
+  return sideQuestionRequestSnapshot({
+    provider,
+    model: session.model,
+    messages: projectSyntheticUserEnvelopes(transcript).messages,
+    tools: sendTools,
+    opts,
+  });
+}
+
+function answerText(response) {
+  if (response?.toolCalls?.length) return SIDE_QUESTION_TOOL_ATTEMPT;
+  const text = typeof response?.content === 'string' ? response.content.trim() : '';
+  return text || SIDE_QUESTION_EMPTY_ANSWER;
+}
+
+/**
+ * Answer `question` from the session's latest provider request. One side
+ * question runs per session: a new one aborts the previous, and
+ * cancelSideQuestion aborts it. A session without a saved request forks the
+ * request its next turn would send. Rejects when the session has no
+ * conversation or provider, with the provider's error, or with the cancel
+ * reason.
+ */
+export async function askSideQuestion(sessionId, question) {
+  const text = typeof question === 'string' ? question.trim() : '';
+  if (!text) throw new TypeError('Side question is empty.');
+  const request = sideQuestionRequest(sessionId) || nextMainRequest(sessionId);
+  if (!request) throw new Error(SIDE_QUESTION_NO_REQUEST);
+  const run = beginSideQuestion(sessionId);
+  const startedAt = Date.now();
+  // The fork keeps the session id (prompt cache routing) but runs on its own
+  // transport scope: no pooled socket, response-chain anchor, turn-state
+  // token or provider run of the main session is waited on, read or replaced.
+  const transportScope = forkTransportScope(sessionId, 'side');
+  try {
+    const { messages, opts } = buildSideQuestionRequest(request, text);
+    let response;
+    try {
+      response = await request.provider.send(
+        messages,
+        request.model,
+        request.tools.length ? request.tools : undefined,
+        {
+          ...opts,
+          transportScope,
+          admissionOwner: sessionId,
+          signal: run.signal,
+        }
+      );
+    } catch (error) {
+      throw run.signal.aborted ? run.signal.reason : error;
+    }
+    if (run.signal.aborted) throw run.signal.reason;
+    const session = request.opts.session;
+    if (response?.usage && session?.id) {
+      void logSessionLlmUsage({
+        session: { ...session, model: request.model },
+        usage: response.usage,
+        startedAt,
+        mode: 'side-question',
+      }).catch(() => {});
+    }
+    return { text: answerText(response) };
+  } finally {
+    run.end();
+    disposeTransportScope(transportScope, request.provider);
+  }
+}

package/src/runtime/agent/orchestrator/session/store/lifecycle-barriers.mjs

@@ -11,7 +11,7 @@ import { join } from 'node:path';
 import { getPluginData } from '../../config.mjs';
 import { PLUGIN_LOG_MAX_BYTES, PLUGIN_LOG_KEEP_BYTES } from '../../../../../lib/mixdog-debug.cjs';
 import { createAsyncLogAppender } from '../../../../shared/async-log-appender.mjs';
-import { sessionPath, deleteHeartbeat } from './paths-heartbeat.mjs';
+import { sessionPath } from './session-paths.mjs';
 import {
   readCanonicalSessionRecord as _readCanonicalRecord,
   CANONICAL_RECORD_UNREADABLE as LIFECYCLE_AMBIGUOUS,
@@ -36,7 +36,7 @@ import {
 } from './live-state.mjs';
 import { _uncacheSessionSummary, _queueSessionSummaryUpsert } from './summary-cache.mjs';
 import { _savePending, _clearDebounce } from './pending-saves.mjs';
-import { _runtimeLivenessVeto, _heartbeatLivenessVeto, _deleteHeartbeatUnlessNewer } from './liveness-veto.mjs';
+import { _runtimeLivenessVeto } from './liveness-veto.mjs';
 import { loadSession } from './load-session.mjs';
 
 // Cancellation truth, single rule: an UNCONFIRMED stop outranks a confirmed
@@ -158,9 +158,23 @@ function _logSessionCloseMetric(id, existing, closedAt, reason) {
   }
 }
 
+/**
+ * A barrier that found no record at all — nothing on disk and no live or
+ * pending copy in memory — fenced nothing because there is nothing to fence:
+ * its pending writes were already cancelled under the commit lock. It still
+ * returns null (no generation exists), but a caller passing `options.outcome`
+ * learns that the record was legitimately gone rather than vetoed, contended
+ * or failed.
+ */
+function _recordAbsent(options) {
+  if (options?.outcome && typeof options.outcome === 'object') options.outcome.absent = true;
+  return null;
+}
+
 /**
  * Atomically mark a session closed on disk with a bumped generation.
  * Returns the new generation, or null if the session file doesn't exist.
+ * `options.outcome` (an object) gets `absent: true` when no record existed.
  * Used by closeSession() to plant a tombstone that races against in-flight
  * saveSession() calls.
  */
@@ -171,15 +185,11 @@ export function markSessionClosed(id, reason = 'manual', options = {}) {
   // Caller-provided probes may re-enter the store, so evaluate them before
   // taking the non-reentrant Atomics commit lock. A veto must also precede
   // pending-save cancellation so debounce durability remains intact.
-  if (_runtimeLivenessVeto(id, options) || _heartbeatLivenessVeto(id, options)) return null;
+  if (_runtimeLivenessVeto(id, options)) return null;
   const closeGuard = _guardedSaveOptions(id);
   const commitControl = _acquireWriteCommit(closeGuard);
   if (commitControl === false) return null;
   try {
-    // Cross-process heartbeat revival after full-TTL silence is accepted as a
-    // best-effort race: the tombstone resurrection guard is the authoritative
-    // post-race arbiter. Re-stat here, but never invoke caller code under lock.
-    if (_heartbeatLivenessVeto(id, options)) return null;
     const authority = _readLifecycleAuthority(id, reason, 'close');
     if (authority === LIFECYCLE_AMBIGUOUS) return null;
     // Only a committed close may disrupt pending persistence.
@@ -187,7 +197,7 @@ export function markSessionClosed(id, reason = 'manual', options = {}) {
     _cancelSessionWrites(id);
     _uncacheSessionSummary(id);
     const existing = loadSession(id);
-    if (!existing) return null;
+    if (!existing) return _recordAbsent(options);
     // Re-close idempotence: a session that is ALREADY tombstoned keeps its
     // ORIGINAL close time (updatedAt) and generation. The old code refreshed
     // updatedAt=Date.now() on every call, so the 5-min idle sweep re-closing a
@@ -216,7 +226,7 @@ export function markSessionClosed(id, reason = 'manual', options = {}) {
     const tombstone = {
       ...base,
       closed: true,
-      closedReason: alreadyClosed ? base.closedReason || reason : reason,
+      closedReason: alreadyClosed && reason !== 'desktop-session-delete' ? base.closedReason || reason : reason,
       status: 'closed',
       generation: newGen,
       updatedAt: closeTime,
@@ -226,8 +236,6 @@ export function markSessionClosed(id, reason = 'manual', options = {}) {
     _savePending.delete(id);
     clearSessionSaveError(id);
     _clearLiveSession(id);
-    // Preserve a sidecar published strictly after the sweep's scan snapshot.
-    _deleteHeartbeatUnlessNewer(id, options);
     _queueSessionSummaryUpsert(tombstone);
     _droppedSaveIds.delete(id);
     // Emit the close metric only on the FIRST close — a re-close of an
@@ -243,7 +251,7 @@ export function markSessionClosed(id, reason = 'manual', options = {}) {
 /**
  * Bump a session's generation WITHOUT planting a closed:true tombstone.
  * Used by closeSession(id, reason, { tombstone: false }) — the runtime side
- * (heartbeat, bash shells, controller, in-memory entry) is detached, but the
+ * (bash shells, controller, in-memory entry) is detached, but the
  * session file itself stays valid/resumable. The generation bump alone is
  * what protects it from a late save race: any saveSession() still in flight
  * from the detached turn was issued with the OLD generation as its
@@ -253,7 +261,7 @@ export function markSessionClosed(id, reason = 'manual', options = {}) {
  * of clobbering whatever the resumed session writes next.
  * Returns the new generation, or null if the session file doesn't exist.
  */
-export function bumpSessionGeneration(id, reason = 'detach') {
+export function bumpSessionGeneration(id, reason = 'detach', options = {}) {
   clearSessionLifecycleCommitError(id);
   // The detach barrier is a canonical write and MUST take the same commit
   // lock as markSessionClosed. Cancellation alone is not a barrier: a writer
@@ -278,14 +286,13 @@ export function bumpSessionGeneration(id, reason = 'detach') {
     _cancelSessionWrites(id);
     _uncacheSessionSummary(id);
     const existing = loadSession(id);
-    if (!existing) return null;
+    if (!existing) return _recordAbsent(options);
     const newGen = (typeof existing.generation === 'number' ? existing.generation : 0) + 1;
     const detached = { ...existing, generation: newGen, updatedAt: Date.now(), detachedReason: reason };
     if (!_writeLifecycleRecord(id, detached, existing, reason)) return null;
     _savePending.delete(id);
     clearSessionSaveError(id);
     _clearLiveSession(id);
-    deleteHeartbeat(id);
     _queueSessionSummaryUpsert(detached);
     _droppedSaveIds.delete(id);
     return newGen;

package/src/runtime/agent/orchestrator/session/store/lifecycle-read.mjs

@@ -6,7 +6,7 @@
  * path and of the in-memory snapshot caches.
  */
 import { readCanonicalSessionRecord, CANONICAL_RECORD_UNREADABLE } from './canonical-reader.mjs';
-import { sessionPath } from './paths-heartbeat.mjs';
+import { sessionPath } from './session-paths.mjs';
 
 /**
  * Cheap authoritative lifecycle read straight from disk (no live/pending

package/src/runtime/agent/orchestrator/session/store/listing.mjs

@@ -5,7 +5,7 @@
 import { readFileSync, readdirSync } from 'node:fs';
 import { Worker } from 'node:worker_threads';
 import { getPluginData } from '../../config.mjs';
-import { getStoreDir } from './paths-heartbeat.mjs';
+import { getStoreDir } from './session-paths.mjs';
 import { probePath, PROBE_PRESENT, PROBE_ABSENT } from './fs-probe.mjs';
 import { isCancelledWrite as _isCancelledWrite } from './write-guards.mjs';
 import {
@@ -29,7 +29,6 @@ import {
 import { _saveAsyncQueued, _saveWorkerPending } from './save-worker.mjs';
 import { STORED_SESSION_UNREADABLE, _ensureLifecycleFields, _storedSessionFromFile } from './serialize.mjs';
 import { _savePending } from './pending-saves.mjs';
-import { isOrdinarySession } from '../store-summary-visibility.mjs';
 import { closeSessionCatalogDb } from '../catalog-db/index.mjs';
 
 // Disk mtime of the summary index when the in-memory cache was last refreshed
@@ -63,10 +62,7 @@ export function listStoredSessions(options = {}) {
     options.includeLive === true
       ? _withUnpersistedSessions(stored, invalidStorageIds)
       : stored.sort((a, b) => b.updatedAt - a.updatedAt);
-  // This full-record API is the ordinary catalog boundary. Agent discovery
-  // uses the durable summary/worker indexes instead; callers that explicitly
-  // own an Agent surface can request the unfiltered internal rows.
-  return options.includeAgentOnly === true ? listed : listed.filter(isOrdinarySession);
+  return listed;
 }
 
 function _withUnpersistedSessions(stored, invalidStorageIds = new Set()) {

package/src/runtime/agent/orchestrator/session/store/live-cache-eviction.mjs

@@ -13,7 +13,7 @@ import {
 } from './live-state.mjs';
 import { _summaryCacheVersions } from './summary-cache.mjs';
 import { probePath, PROBE_PRESENT } from './fs-probe.mjs';
-import { sessionPath } from './paths-heartbeat.mjs';
+import { sessionPath } from './session-paths.mjs';
 import { _hasPendingPersistence } from './pending-saves.mjs';
 import { forgetSessionLoadCache } from './load-cache.mjs';
 

package/src/runtime/agent/orchestrator/session/store/live-state.mjs

@@ -124,6 +124,29 @@ export function _retireSessionIncarnation(id) {
   if (id) _sessionIncarnations.delete(id);
 }
 
+// ── Delete fence ────────────────────────────────────────────────────────────
+// An explicitly deleted session may still own a running turn whose later saves
+// carry a brand-new write guard and incarnation, so neither the cancellation
+// counter nor the retired incarnation stops them: an absent file reads as
+// "creatable". The fence is the id-level refusal every write-admission check
+// consults. Only explicit user deletes fence (ids are never reused); the cap
+// only ever forgets the oldest, long-settled entries.
+const SESSION_DELETE_FENCE_MAX = 4096;
+const _deleteFence = new Set();
+
+export function fenceSessionWrites(id) {
+  if (!id) return;
+  _deleteFence.delete(id);
+  _deleteFence.add(id);
+  if (_deleteFence.size > SESSION_DELETE_FENCE_MAX) {
+    _deleteFence.delete(_deleteFence.values().next().value);
+  }
+}
+
+export function isSessionWriteFenced(id) {
+  return _deleteFence.has(id);
+}
+
 /** Clear every save marker for an id (successful hard delete). */
 export function _clearSessionSaveState(id) {
   if (!id) return;

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

@@ -1,53 +1,62 @@
 /**
- * Runtime-liveness evidence for the destructive paths (close, detach,
- * delete): the freshness of a session's `.hb` sidecar, the veto rules derived
- * from it and the caller-supplied `isSessionLive` probe.
+ * Runtime-liveness veto for the destructive paths (close, delete): the
+ * caller-supplied `isSessionLive` probe over the daemon's in-memory runtime
+ * state, plus — for the sweep (`legacyOwnerVeto`) — the legacy `.hb` / `.own`
+ * markers an OLDER Mixdog process still running beside this one (mid-upgrade)
+ * keeps publishing. No current build writes those markers; they are only ever
+ * READ here, never refreshed.
  *
  * Separate from the write pipeline on purpose — a veto is a pure READ taken
  * before any commit lock is held, and markSessionClosed / deleteSession must
- * apply exactly the same rules.
+ * apply exactly the same rule.
  */
-import { existsSync, statSync } from 'node:fs';
 import { join } from 'node:path';
-import { getStoreDir, deleteHeartbeat } from './paths-heartbeat.mjs';
+import { getStoreDir } from './session-paths.mjs';
+import { probePath, readTextFile, PROBE_PRESENT } from './fs-probe.mjs';
 
-function _heartbeatMtime(id) {
+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;
+
+function processAlive(pid) {
   try {
-    const path = join(getStoreDir(), `${id}.hb`);
-    return existsSync(path) ? statSync(path).mtimeMs || 0 : 0;
-  } catch {
-    return 0;
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    // ESRCH: no such process. EPERM means the pid exists.
+    return error?.code === 'EPERM';
   }
 }
 
-/**
- * Freshness of a session's `.hb` heartbeat sidecar (0 when absent). Used by
- * the fork-on-resume guard: a fresh heartbeat published by another process
- * means the session is actively being driven there RIGHT NOW.
- */
-export function readSessionHeartbeatMtime(id) {
-  if (!id) return 0;
-  return _heartbeatMtime(id);
-}
-
-export function _runtimeLivenessVeto(id, options = {}) {
-  return typeof options.isSessionLive === 'function' && options.isSessionLive(id);
+/** A legacy marker's evidence, or null when it is not there to judge. The
+ *  marker holds `<msTimestamp>\n<pid>\n`; a pid-less (pre-pid) marker names
+ *  no owner, so it is neither live nor dead. */
+export function readLegacyMarker(path, now = Date.now()) {
+  const probe = probePath(path);
+  if (probe.state !== PROBE_PRESENT) return null;
+  const read = readTextFile(path);
+  const pid = read.state === PROBE_PRESENT ? Number(read.text.split('\n')[1]) || 0 : 0;
+  const alive = pid > 0 && processAlive(pid);
+  return {
+    fresh: now - (probe.mtimeMs || 0) <= LEGACY_MARKER_FRESH_MS,
+    ownerAlive: alive,
+    ownerDead: pid > 0 && !alive,
+  };
 }
 
-export function _heartbeatLivenessVeto(id, options = {}) {
-  const heartbeatMtime = _heartbeatMtime(id);
-  if (!(heartbeatMtime > 0)) return false;
-  const hasHeartbeatSnapshot = Object.hasOwn(options, 'heartbeatSnapshotMtime');
-  const snapshotMtime = Number(options.heartbeatSnapshotMtime) || 0;
-  if (hasHeartbeatSnapshot && heartbeatMtime > snapshotMtime) return true;
-  const freshMs = Number(options.heartbeatFreshMs);
-  return Number.isFinite(freshMs) && freshMs > 0 && Date.now() - heartbeatMtime <= freshMs;
+/** 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()) {
+  if (typeof id !== 'string' || !/^[A-Za-z0-9_-]+$/.test(id)) return false;
+  const dir = getStoreDir();
+  return LEGACY_MARKER_SUFFIXES.some((suffix) => {
+    const marker = readLegacyMarker(join(dir, `${id}${suffix}`), now);
+    return Boolean(marker?.fresh && marker.ownerAlive);
+  });
 }
 
-export function _deleteHeartbeatUnlessNewer(id, options = {}) {
-  const hasHeartbeatSnapshot = Object.hasOwn(options, 'heartbeatSnapshotMtime');
-  const snapshotMtime = Number(options.heartbeatSnapshotMtime) || 0;
-  if (!hasHeartbeatSnapshot || _heartbeatMtime(id) <= snapshotMtime) {
-    deleteHeartbeat(id);
-  }
+export function _runtimeLivenessVeto(id, options = {}) {
+  if (typeof options.isSessionLive === 'function' && options.isSessionLive(id)) return true;
+  return options.legacyOwnerVeto === true && _legacyOwnerLivenessVeto(id);
 }

package/src/runtime/agent/orchestrator/session/store/load-cache.mjs

@@ -8,7 +8,7 @@ import {
   readCanonicalSessionRecord,
   acceptStrictSessionRecords,
 } from './canonical-reader.mjs';
-import { sessionPath } from './paths-heartbeat.mjs';
+import { sessionPath } from './session-paths.mjs';
 import { noteMemoryRelease } from '../../../../shared/idle-gc.mjs';
 
 // Recent full-session reads are much hotter than writes while a user hops

package/src/runtime/agent/orchestrator/session/store/load-session.mjs

@@ -4,7 +4,7 @@
  * snapshot, or the evidence-backed failed-save snapshot. Nothing here writes;
  * the precedence rules are the whole responsibility.
  */
-import { sessionPath } from './paths-heartbeat.mjs';
+import { sessionPath } from './session-paths.mjs';
 import { _savePending } from './pending-saves.mjs';
 import { _liveSessions, _droppedSaveIds, getFailedSaveSnapshot } from './live-state.mjs';
 import { _readStoredSessionCached } from './load-cache.mjs';

package/src/runtime/agent/orchestrator/session/store/session-delete.mjs

@@ -4,11 +4,12 @@
  * edge plus the full local-state purge that must happen under the same lock
  * (incarnation retirement, pending slots, purge hooks, markers, summary row).
  */
-import { readFileSync, readdirSync, unlinkSync } from 'node:fs';
-import { join } from 'node:path';
+import { unlinkSync } from 'node:fs';
 import { isAgentOwner } from '../../agent-owner.mjs';
-import { readTopLevelLifecycleRecord, isLifecycleUnreadable } from '../lifecycle-scan.mjs';
-import { getStoreDir, sessionPath, deleteSessionPresence } from './paths-heartbeat.mjs';
+import { listStoredAgentWorkerLinks } from '../store-agent-worker-rows.mjs';
+import { listStoredSessionSummaries } from './listing.mjs';
+import { STORED_SESSION_UNREADABLE, _storedSessionFromFile } from './serialize.mjs';
+import { getStoreDir, sessionPath } from './session-paths.mjs';
 import {
   readCanonicalSessionRecord as _readCanonicalRecord,
   CANONICAL_RECORD_UNREADABLE as LIFECYCLE_AMBIGUOUS,
@@ -22,60 +23,66 @@ import {
 } from './write-guards.mjs';
 import {
   _clearLiveSession,
+  _liveSessions,
   _retireSessionIncarnation,
   _clearSessionSaveState,
   clearSessionLifecycleCommitError,
+  fenceSessionWrites,
 } from './live-state.mjs';
 import { purgeSessionSaveBookkeeping as _purgeSessionSaveBookkeeping } from './save-worker.mjs';
-import { _uncacheSessionSummary, _queueSessionSummaryRemoval } from './summary-cache.mjs';
+import { _uncacheSessionSummary, _queueSessionSummaryRemoval, _cachedSummaryRows } from './summary-cache.mjs';
 import { _savePending, _clearDebounce, _releasePendingSlot } from './pending-saves.mjs';
-import { _runtimeLivenessVeto, _heartbeatLivenessVeto, _deleteHeartbeatUnlessNewer } from './liveness-veto.mjs';
+import { _runtimeLivenessVeto } from './liveness-veto.mjs';
 import { _runSessionPurgeHooks } from './session-observers.mjs';
 import { deleteCompactionArchive } from '../compaction-archive.mjs';
 
-/** Strictly enumerate child-agent session files linked to one visible parent.
- * Used only by explicit parent deletion; ordinary close/context switches keep
- * the relationship intact. */
+/** Child-agent session ids linked to one visible parent. Candidates come from
+ * metadata only (the summary rows and the agent-worker links — no folder
+ * scan); each candidate's own file is then read strictly and must still be an
+ * agent-owned record linked to this parent, so a stale/foreign metadata row
+ * can never name a deletion target. Parent deletion no longer removes these
+ * children; they outlive the parent as independent sessions. */
 export function listOwnedAgentSessionIds(ownerSessionId) {
   const ownerId = String(ownerSessionId || '').trim();
   if (!/^[A-Za-z0-9_-]+$/.test(ownerId)) return [];
-  const dir = getStoreDir();
-  if (probePath(dir).state !== PROBE_PRESENT) return [];
-  let files;
-  try {
-    files = readdirSync(dir).filter((file) => file.endsWith('.json'));
-  } catch {
-    return [];
+  const linksTo = (row) => row?.ownerSessionId === ownerId || row?.parentSessionId === ownerId;
+  const candidates = new Set();
+  for (const row of [...listStoredSessionSummaries(), ...listStoredAgentWorkerLinks()]) {
+    const candidateId = String(row?.id || row?.sessionId || '').trim();
+    if (linksTo(row) && candidateId !== ownerId && /^[A-Za-z0-9_-]+$/.test(candidateId)) {
+      candidates.add(candidateId);
+    }
   }
+  const dir = getStoreDir();
   const ids = [];
-  for (const file of files) {
-    const candidateId = file.slice(0, -5);
-    if (!candidateId || candidateId === ownerId || !/^[A-Za-z0-9_-]+$/.test(candidateId)) continue;
-    try {
-      const record = readTopLevelLifecycleRecord(readFileSync(join(dir, file), 'utf8'));
-      if (isLifecycleUnreadable(record) || record.id !== candidateId) continue;
-      const session = record.doc;
-      if (!isAgentOwner(session)) continue;
-      const linkedOwner = String(session.ownerSessionId || session.parentSessionId || '').trim();
-      if (linkedOwner === ownerId) ids.push(candidateId);
-    } catch {
-      /* unreadable/vanished records are never deletion targets */
-    }
+  for (const candidateId of candidates) {
+    const session = _storedSessionFromFile(dir, `${candidateId}.json`, false);
+    // Unreadable, vanished, corrupt or foreign records are never deletion targets.
+    if (!session || session === STORED_SESSION_UNREADABLE || !isAgentOwner(session)) continue;
+    const linkedOwner = String(session.ownerSessionId || session.parentSessionId || '').trim();
+    if (linkedOwner === ownerId) ids.push(candidateId);
   }
   return ids;
 }
 
+/** Working folders the session is known to have used (its cached summary row
+ *  and live snapshot — no file read, no scan); the purge hooks derive
+ *  per-folder artifacts such as the transcript path from them. */
+function knownSessionCwds(id) {
+  const row = _cachedSummaryRows()?.find((candidate) => candidate.id === id);
+  const live = _liveSessions.get(id);
+  const cwds = [row?.cwd, row?.workspace?.cwd, row?.workspace?.projectPath, live?.cwd];
+  return [...new Set(cwds.filter((cwd) => typeof cwd === 'string' && cwd))];
+}
+
 export function deleteSession(id, options = {}) {
   // Keep caller probes and all vetoes ahead of the non-reentrant lock and
   // ahead of pending-save disruption, matching markSessionClosed().
-  if (_runtimeLivenessVeto(id, options) || _heartbeatLivenessVeto(id, options)) return false;
+  if (_runtimeLivenessVeto(id, options)) return false;
   const deleteGuard = _guardedSaveOptions(id);
   const commitControl = _acquireWriteCommit(deleteGuard);
   if (commitControl === false) return false;
   try {
-    // Cross-process revival after full-TTL silence remains best-effort; the
-    // tombstone resurrection guard is authoritative. Only re-stat .hb here.
-    if (_heartbeatLivenessVeto(id, options)) return false;
     // ── 1. unlink FIRST, still holding the commit lock ─────────────────────
     // A failed unlink is NOT a delete: the canonical bytes are still there, so
     // nothing may be purged, cancelled or closed — every pending write, parked
@@ -122,15 +129,15 @@ export function deleteSession(id, options = {}) {
     // its settlement moves no marker and touches no bookkeeping — and a
     // re-created id gets a brand new incarnation of its own.
     _retireSessionIncarnation(id);
+    // An explicit user delete also fences the id: a still-running turn's later
+    // saves get fresh guards/incarnations and would otherwise recreate the file.
+    if (options.fenceWrites === true) fenceSessionWrites(id);
     _cancelSessionWrites(id);
     _clearDebounce(id);
     _releasePendingSlot(_savePending.get(id));
     _savePending.delete(id);
     _purgeSessionSaveBookkeeping(id);
-    _runSessionPurgeHooks(id);
-    // Preserve a sidecar published strictly after the sweep's scan snapshot.
-    _deleteHeartbeatUnlessNewer(id, options);
-    deleteSessionPresence(id);
+    _runSessionPurgeHooks(id, { cwds: knownSessionCwds(id) });
     // The display-only compaction archive has no meaning without its session.
     deleteCompactionArchive(getStoreDir(), id);
     _clearLiveSession(id);