mixdog 1.2.5 → 1.3.0

package/src/runtime/agent/orchestrator/session/manager/pending-messages.mjs

@@ -29,6 +29,12 @@ import {
   pruneEmptyPendingIdSet,
 } from './pending-claim-ledger.mjs';
 import { legacyPendingMessagesPath } from './pending-spool-path.mjs';
+import {
+  TASK_WAIT_WAKE_NOTIFICATION,
+  TASK_WAIT_WAKE_USER,
+  interruptTaskWaitForSession,
+  registerTaskWaitSteeringCheck,
+} from '../task-wait-control.mjs';
 import { pruneCleanupConfirmedLedger } from './pending-delivered-ledger.mjs';
 // The durable delivered-id ledger on the session record lives in
 // pending-delivered-ledger.mjs; re-exported so prior importers stay unchanged.
@@ -51,6 +57,8 @@ import {
   PENDING_MODE_TASK_NOTIFICATION,
   _groupPendingMessageEntries,
   _mergePendingMessageEntries,
+  completionExecutionId,
+  completionIsDelivered,
   completionWasDelivered,
   entryLifecycleToken,
   isCompletionNotificationEntry,
@@ -447,9 +455,52 @@ export function enqueuePendingMessage(sessionId, message) {
   }
   q.push(entry);
   const bufferedDepth = schedulePendingMessagePersist(sessionId, entry);
+  const wake = pendingEntryWake(entry);
+  if (wake) {
+    interruptTaskWaitForSession(
+      sessionId,
+      wake,
+      wake === TASK_WAIT_WAKE_NOTIFICATION ? completionExecutionId(entry) : null
+    );
+  }
   return Math.max(q.length, bufferedDepth || 0);
 }
 
+// What one queued entry wakes a passive task wait or shell hold for, so it
+// reaches the loop now: steering (a Lead message to its agent) as user input,
+// and an undelivered task completion (agent/shell, any status). A plain
+// channel notice (scheduled or event-rule inject) waits for the turn, as it
+// does in the Lead's queue.
+function pendingEntryWake(entry) {
+  if (pendingEntryMode(entry) === PENDING_MODE_PROMPT) return TASK_WAIT_WAKE_USER;
+  if (isCompletionNotificationEntry(entry) && !completionIsDelivered(entry)) return TASK_WAIT_WAKE_NOTIFICATION;
+  return false;
+}
+
+// Anything already queued when a wait or hold begins ends it at once, exactly
+// like what arrives during it. A completion the agent already received is no
+// longer deliverable and never wakes.
+registerTaskWaitSteeringCheck((sessionId) => {
+  let wake = false;
+  for (const entry of _sessionPendingMessages.get(sessionId) || []) {
+    const found = pendingEntryWake(entry);
+    if (found === TASK_WAIT_WAKE_USER) return found;
+    wake = wake || found;
+  }
+  return wake;
+});
+
+// True when this session's queue holds task notifications and nothing else:
+// the mid-chain boundary may then take the whole queue without bypassing the
+// prompt filters that keep queued prompts for the terminal boundary.
+export function pendingQueueHoldsOnlyNotifications(sessionId) {
+  const queued = [
+    ...(_sessionPendingMessages.get(sessionId) || []),
+    ...(_hydratedPendingMessages.get(sessionId) || []),
+  ];
+  return queued.length > 0 && queued.every((entry) => pendingEntryMode(entry) === PENDING_MODE_TASK_NOTIFICATION);
+}
+
 // Drain order: enqueue time, then source (hydrated < buffered < memory), then
 // position within the source.
 function byEnqueueOrder(a, b) {
@@ -468,19 +519,13 @@ export function drainPendingMessages(sessionId) {
   // This path is deliberately memory-only: no file lock, stat, parse, or
   // atomic rename can run in the agent-completion tick.
   const buffered = takeBufferedPendingMessages(sessionId);
-  // Deferred completion/task notifications are dropped ONLY from the persisted
-  // (disk/buffer) path. Those are the entries a later session resume/restart
-  // would replay out-of-order into a future turn, once the in-memory queue is
-  // gone — discarding them there is the deliberate owner decision.
-  // Live in-memory completions (fallback/headless enqueues delivered within
-  // THIS process, e.g. the idle-resume kick that surfaces the model-visible
-  // body) are the intended payload and MUST survive the drain — filtering
-  // them here dropped the notification entirely. On a genuine resume the
-  // in-memory queue is empty, so keeping it only ever delivers live entries.
-  // Genuine user/steering messages carry no marker and are kept in order in
-  // both paths.
-  // Drain-time belt: drop MARKED in-memory completion entries whose text hash
-  // was already delivered+ACKed (TUI execution-ui) this process — those would
+  // A completion that reached the spool and was never acknowledged was never
+  // delivered to the model (delivery acknowledges and removes it), so it
+  // survives a restart: the hydrated disk entries drain like live in-memory
+  // ones. Dropping them on resume lost a finished (or failed) task's only
+  // notification.
+  // Drain-time belt: drop MARKED completion entries whose text hash was
+  // already delivered+ACKed (TUI execution-ui) this process — those would
   // double-inject next turn. Only marked completion entries are eligible;
   // genuine user/steering entries carry no marker and are always kept.
   const deliveredIds = new Set();
@@ -494,10 +539,11 @@ export function drainPendingMessages(sessionId) {
     deliveredEntries.push(entry);
     return false;
   };
+  const hydratedKept = hydrated.filter(keepUndelivered);
   const memoryKept = memory.filter(keepUndelivered);
   const bufferedKept = buffered.filter(keepUndelivered);
   const tagged = [
-    ...hydrated.map((entry, index) => ({ entry, source: 0, index })),
+    ...hydratedKept.map((entry, index) => ({ entry, source: 0, index })),
     ...bufferedKept.map((entry, index) => ({ entry, source: 1, index })),
     ...memoryKept.map((entry, index) => ({ entry, source: 2, index })),
   ];
@@ -512,14 +558,8 @@ export function drainPendingMessages(sessionId) {
     if (!prior || item.source > prior.source) byId.set(normalized.id, { ...item, entry: normalized });
   }
   const ordered = [...byId.values()].sort(byEnqueueOrder);
-  const dropped = ordered
-    .filter(({ entry, source }) => source === 0 && isCompletionNotificationEntry(entry))
-    .map(({ entry }) => entry);
-  const acknowledged = [...deliveredEntries, ...dropped];
-  if (acknowledged.length > 0) acknowledgePendingMessages(sessionId, acknowledged);
-  const visible = modelVisiblePendingMessages(
-    ordered.filter(({ entry }) => !dropped.includes(entry)).map(({ entry }) => entry)
-  );
+  if (deliveredEntries.length > 0) acknowledgePendingMessages(sessionId, deliveredEntries);
+  const visible = modelVisiblePendingMessages(ordered.map(({ entry }) => entry));
   // Epoch gate. Normalization above rebuilds every entry, but each copy
   // inherits the IMMUTABLE token the entry was accepted under. An entry from
   // an older epoch (a cross-process close/detach moved the generation while

package/src/runtime/agent/orchestrator/session/manager/prompt-utils.mjs

@@ -207,29 +207,46 @@ function bp3SliceAt(text, heading) {
 
 /**
  * Replace the workspace-scoped tail of a BP3 core (composeSystemPrompt order:
- * …, `# Core Memory`, `# Instruction Files`). The instruction-files slice is
- * always last and may itself contain separators, so it is cut by position;
- * the core-memory slice is one separator-free part. `undefined` keeps a slice,
- * an empty string drops it.
+ * …, `# Instruction Files`, `# Core Memory`). Core memory is the last,
+ * separator-free part; the instruction-files slice before it may itself
+ * contain separators, so both are cut by position. A core from before that
+ * order (memory, then instruction files) is read too and written in the
+ * current order. `undefined` keeps a slice, an empty string drops it.
  * @param {string} core
  * @param {{ coreMemoryContext?: string, instructionFilesContext?: string }} slices
  */
 export function replaceWorkspaceCoreSlices(core, { coreMemoryContext, instructionFilesContext } = {}) {
+  let { head, instructionFiles, memory } = splitWorkspaceCoreSlices(core);
+  if (coreMemoryContext !== undefined) {
+    const value = trimmedSlice(coreMemoryContext);
+    memory = value ? `${CORE_MEMORY_HEADING}${value}` : '';
+  }
+  if (instructionFilesContext !== undefined) instructionFiles = trimmedSlice(instructionFilesContext);
+  return [head, instructionFiles, memory].filter((part) => part?.trim()).join(BP3_PART_SEPARATOR);
+}
+
+/** A BP3 core's `{ head, instructionFiles, memory }` (each '' when absent). */
+function splitWorkspaceCoreSlices(core) {
   let head = String(core || '');
+  let memory = '';
+  const memoryAt = bp3SliceAt(head, CORE_MEMORY_HEADING);
+  if (memoryAt) {
+    memory = head.slice(memoryAt.start);
+    head = head.slice(0, memoryAt.cut);
+    const legacy = memory.indexOf(`${BP3_PART_SEPARATOR}${INSTRUCTION_FILES_HEADING}`);
+    if (legacy >= 0) {
+      const instructions = memory.slice(legacy + BP3_PART_SEPARATOR.length);
+      memory = memory.slice(0, legacy);
+      head = head ? `${head}${BP3_PART_SEPARATOR}${instructions}` : instructions;
+    }
+  }
   let instructionFiles = '';
   const instructionAt = bp3SliceAt(head, INSTRUCTION_FILES_HEADING);
   if (instructionAt) {
     instructionFiles = head.slice(instructionAt.start);
     head = head.slice(0, instructionAt.cut);
   }
-  let parts = head ? head.split(BP3_PART_SEPARATOR) : [];
-  if (coreMemoryContext !== undefined) {
-    parts = parts.filter((part) => !part.startsWith(CORE_MEMORY_HEADING));
-    const memory = trimmedSlice(coreMemoryContext);
-    if (memory) parts.push(`${CORE_MEMORY_HEADING}${memory}`);
-  }
-  if (instructionFilesContext !== undefined) instructionFiles = trimmedSlice(instructionFilesContext);
-  return [...parts, instructionFiles].filter((part) => part?.trim()).join(BP3_PART_SEPARATOR);
+  return { head, instructionFiles, memory };
 }
 
 /**
@@ -286,9 +303,7 @@ function textOf(message) {
  */
 function presentedWorkspace(session) {
   const core = session.bp3EnvSplit === true ? textOf(bp3SystemMessage(session)) : String(session.bp3CoreContext || '');
-  const instructionAt = bp3SliceAt(core, INSTRUCTION_FILES_HEADING);
-  const head = instructionAt ? core.slice(0, instructionAt.cut) : core;
-  const memory = (head ? head.split(BP3_PART_SEPARATOR) : []).find((part) => part.startsWith(CORE_MEMORY_HEADING));
+  const { instructionFiles, memory } = splitWorkspaceCoreSlices(core);
   const tail = typeof session.bp3EnvironmentContext === 'string' ? session.bp3EnvironmentContext : '';
   const facts = tail.split(BP3_PART_SEPARATOR)[0] || '';
   const promptText = [textOf(bpEnvSystemMessage(session)), textOf(bp3SystemMessage(session))].join('\n');
@@ -297,10 +312,23 @@ function presentedWorkspace(session) {
     cwd: cwd ? cwd.trim() : null,
     environmentContext: facts.startsWith('- ') ? facts.trim() : '',
     coreMemoryContext: memory ? memory.slice(CORE_MEMORY_HEADING.length).trim() : '',
-    instructionFilesContext: instructionAt ? core.slice(instructionAt.start).trim() : '',
+    instructionFilesContext: instructionFiles.trim(),
   };
 }
 
+/**
+ * A rebuilt BP3 core head (composed without workspace slices) followed by the
+ * instruction-files and core-memory slices the session's prompt presents now,
+ * so a rebuild of the rest of the core (a mid-conversation workflow switch)
+ * leaves what the model was told about its workspace — and any staged
+ * workspaceReroot — as it was.
+ */
+export function withPresentedWorkspaceSlices(session, nextHead) {
+  const core = session.bp3EnvSplit === true ? textOf(bp3SystemMessage(session)) : String(session.bp3CoreContext || '');
+  const { instructionFiles, memory } = splitWorkspaceCoreSlices(core);
+  return [nextHead, instructionFiles, memory].filter((part) => part?.trim()).join(BP3_PART_SEPARATOR);
+}
+
 const WORKSPACE_SLICES = ['environmentContext', 'coreMemoryContext', 'instructionFilesContext'];
 
 /**

package/src/runtime/agent/orchestrator/session/manager/rules-cache.mjs

@@ -112,20 +112,36 @@ export function _buildAgentRules(profile = 'full') {
   );
 }
 
-export function _buildLeadRules({ includeLeadBrief = true } = {}) {
+// One `part` of LEAD.md (rules-builder buildLeadRoleContent): 'common' (the
+// lines every Lead shares), 'coding' / 'agent' (the mode-variant passages),
+// 'identity' (the coding identity sentence).
+export function _buildLeadRules({ includeLeadBrief = true, part = 'common' } = {}) {
   const PLUGIN_ROOT = mixdogRoot();
   const DATA_DIR = resolvePluginData();
   const RULES_DIR = join(PLUGIN_ROOT, 'rules');
+  const variant = includeLeadBrief ? 'delegating' : 'delegation-free';
   return buildCachedRules(
     'buildLeadRoleContent',
     'lead role rules',
     [join(RULES_DIR, 'lead'), join(DATA_DIR, 'mixdog-config.json')],
-    { PLUGIN_ROOT, DATA_DIR, includeLeadBrief },
-    includeLeadBrief ? 'delegating' : 'delegation-free'
+    { PLUGIN_ROOT, DATA_DIR, includeLeadBrief, part },
+    `${variant}\n${part}`
   );
 }
 
-export function _buildLeadMetaContext() {
+// One agent-mode rule file (rules/agent-mode): 'conduct', 'mixy' or 'routine'.
+export function _buildAgentModeRules({ part = 'conduct' } = {}) {
+  const PLUGIN_ROOT = mixdogRoot();
+  return buildCachedRules(
+    'buildAgentModeContent',
+    'agent mode rules',
+    [join(PLUGIN_ROOT, 'rules', 'agent-mode')],
+    { PLUGIN_ROOT, part },
+    part
+  );
+}
+
+export function _buildLeadMetaContext({ includeOutputStyle = true } = {}) {
   const PLUGIN_ROOT = mixdogRoot();
   const DATA_DIR = resolvePluginData();
   const RULES_DIR = join(PLUGIN_ROOT, 'rules');
@@ -138,7 +154,8 @@ export function _buildLeadMetaContext() {
       join(PLUGIN_ROOT, 'output-styles'),
       join(DATA_DIR, 'output-styles'),
     ],
-    { PLUGIN_ROOT, DATA_DIR }
+    { PLUGIN_ROOT, DATA_DIR, includeOutputStyle },
+    includeOutputStyle ? 'style' : 'no-style'
   );
 }
 

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

@@ -23,6 +23,7 @@
 // }
 import { createAbortController } from '../../../../shared/abort-controller.mjs';
 import { emitSessionApprovalWaitChange } from '../../../../shared/session-approval-wait.mjs';
+import { emitSessionActivityChange } from '../../../../shared/session-activity-signal.mjs';
 import { DEFAULT_ACTIVITY_HEARTBEAT_MS } from '../../stall-policy.mjs';
 import { MODEL_THINKING_STAGE, awaitingModelResponse, lastProgressAt } from '../../../../shared/quiet-progress.mjs';
 import { finishBrowserTurn } from '../../../../browser-bridge/client.mjs';
@@ -177,12 +178,14 @@ export function markSessionAskStart(id) {
   entry.modelRequestStartedAt = null;
   entry.lastProgressAt = now;
   entry.updatedAt = now;
+  entry.taskWaits = 0;
+  emitSessionActivityChange(id);
 }
 /** The provider put the request on the wire; its response headers are
  *  pending. The turn stays `requesting` (every stage set and the watchdog
  *  clock are unchanged); the send time lets surfaces show "model thinking"
  *  until transport arrives. Not progress: lastProgressAt is untouched. */
-export function markSessionRequestSent(id) {
+function markSessionRequestSent(id) {
   if (!id) return;
   const entry = _runtimeState.get(id);
   if (!entry || entry.closed || entry.controller?.signal?.aborted || entry.stage !== 'requesting') return;
@@ -321,6 +324,23 @@ export function beginSessionApprovalWait(id) {
     emitSessionApprovalWaitChange(id, null, meta);
   };
 }
+// A turn parked on a background task (`task wait`): published as
+// `awaitingTask` so status surfaces show the session waiting, not working.
+// Counted like approval waits; never creates an entry. Returns the idempotent
+// release.
+export function beginSessionTaskWait(id) {
+  const entry = id ? _runtimeState.get(id) : null;
+  if (!entry) return () => {};
+  entry.taskWaits = (entry.taskWaits || 0) + 1;
+  if (entry.taskWaits === 1) emitSessionActivityChange(id);
+  let released = false;
+  return () => {
+    if (released) return;
+    released = true;
+    entry.taskWaits = Math.max(0, (entry.taskWaits || 0) - 1);
+    if (entry.taskWaits === 0) emitSessionActivityChange(id);
+  };
+}
 // Parent AbortSignal listeners are dropped on askSession unwind (finally /
 // terminal return) and on error/cancel/close — not in markSessionDone, which
 // also runs between queued follow-up turns within one ask.
@@ -335,6 +355,8 @@ function _settleTerminalEntry(entry, stage, lastError) {
   entry.doneAt = settledAt;
   entry.lastProgressAt = settledAt;
   entry.updatedAt = settledAt;
+  entry.taskWaits = 0;
+  emitSessionActivityChange(entry.session?.id || '');
 }
 export function markSessionDone(id, { empty = false } = {}) {
   if (!id) return;

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

@@ -3,7 +3,16 @@
 // when tombstone=false), aborts the in-flight controller, tears down
 // runtime/bash/dedup/offload/pending state, and defers the runtime-map clear.
 // abortSessionTurn cancels the current turn without tombstoning.
-import { markSessionClosed, bumpSessionGeneration, getSessionLifecycleCommitError } from '../store.mjs';
+import {
+  markSessionClosed,
+  markSessionClosedAsync,
+  markSessionClosedAttempt,
+  bumpSessionGeneration,
+  bumpSessionGenerationAttempt,
+  isLifecycleRetry,
+  getSessionLifecycleCommitError,
+} from '../store.mjs';
+import { sleep } from '../../../../shared/sleep.mjs';
 import { clearReadDedupSession } from '../read-dedup.mjs';
 import { SessionClosedError } from './session-errors.mjs';
 import { _dropPendingMessageState } from './pending-messages.mjs';
@@ -36,44 +45,79 @@ import { forgetSideQuestion } from '../side-question-store.mjs';
  * TOMBSTONE_MAX_AGE_MS (1h — vastly longer than the microsecond in-flight race).
  */
 export function closeSession(id, reason = 'manual', opts = {}) {
-  // tombstone=false: detach runtime resources (heartbeat, bash shells,
-  // controller abort, runtime-map clear) WITHOUT planting the disk
-  // tombstone. Used for non-empty sessions on /resume-away, /new, and
-  // TUI exit: a tombstone would drop the session from the Resume list
-  // immediately and let sweepTombstones() hard-delete it even though it
-  // has real conversation content worth resuming. Only truly-empty
-  // scratch sessions should still tombstone.
-  const tombstone = opts.tombstone !== false;
   if (!id) return false;
+  const tombstone = opts.tombstone !== false;
   const entry = _getRuntimeEntry(id);
-  // askSession owns the interruption tracker that can merge committed
-  // iterations, the current partial response, and observed tool results into
-  // one canonical transcript. Stage that in-memory snapshot synchronously
-  // BEFORE the lifecycle generation changes; once generation is bumped, the
-  // normal cancellation cleanup save is intentionally rejected as stale. It
-  // is only staged: a refused barrier rolls it back so the turn keeps running
-  // and checkpointing as if no close had been attempted.
-  let closeSnapshot = null;
-  try {
-    closeSnapshot = entry?.prepareCloseSnapshot?.tentative?.(reason) ?? null;
-  } catch {
-    /* best-effort */
-  }
-  // 1. Tombstone first — this wins the race against saveSession().
-  //    Skipped when tombstone=false: no closed:true marker is planted, so
-  //    the session file stays intact and resumeSession() will accept it.
-  //    We still bump the on-disk generation via bumpSessionGeneration() —
-  //    that alone is what protects the session from a late save race: any
-  //    saveSession() still in flight from this detached turn (e.g. the
-  //    cancel-cleanup save below) carries the OLD generation as its
-  //    expectedGeneration, so _shouldDrop()'s ownership-counter rule drops
-  //    it once disk generation moves past that. Without this bump the late
-  //    write could silently overwrite the session after the user resumes
-  //    it back (BL: burned-session late-save clobber).
+  const closeSnapshot = stageCloseSnapshot(entry, reason);
   const outcome = { absent: false };
   const newGen = tombstone
     ? markSessionClosed(id, reason, { outcome })
     : bumpSessionGeneration(id, reason, { outcome });
+  return finishClose({ id, reason, tombstone, entry, closeSnapshot, newGen, outcome });
+}
+
+/**
+ * closeSession that never blocks the event loop. Each barrier attempt runs
+ * synchronously exactly as closeSession's barrier does (the first one before
+ * this function first yields), but a rename the OS refuses with retries left
+ * is waited out with a timer instead of sleepSync. Between attempts the staged
+ * close snapshot is rolled back, so the turn keeps running untouched, and it
+ * is re-staged from the then-current turn right before the next attempt: the
+ * barrier that lands always carries the latest transcript. The session is
+ * torn down — and reported closed — only after its barrier is on disk.
+ */
+export async function closeSessionAsync(id, reason = 'manual', opts = {}) {
+  if (!id) return false;
+  const tombstone = opts.tombstone !== false;
+  const entry = _getRuntimeEntry(id);
+  for (let attempt = 0; ; attempt++) {
+    const closeSnapshot = stageCloseSnapshot(entry, reason);
+    const outcome = { absent: false };
+    const newGen = tombstone
+      ? markSessionClosedAttempt(id, reason, { outcome }, attempt)
+      : bumpSessionGenerationAttempt(id, reason, { outcome }, attempt);
+    if (!isLifecycleRetry(newGen)) {
+      return finishClose({ id, reason, tombstone, entry, closeSnapshot, newGen, outcome });
+    }
+    closeSnapshot?.rollback();
+    await sleep(newGen.retryInMs);
+  }
+}
+
+// askSession owns the interruption tracker that can merge committed
+// iterations, the current partial response, and observed tool results into
+// one canonical transcript. Stage that in-memory snapshot synchronously
+// BEFORE the lifecycle generation changes; once generation is bumped, the
+// normal cancellation cleanup save is intentionally rejected as stale. It
+// is only staged: a refused barrier rolls it back so the turn keeps running
+// and checkpointing as if no close had been attempted.
+function stageCloseSnapshot(entry, reason) {
+  try {
+    return entry?.prepareCloseSnapshot?.tentative?.(reason) ?? null;
+  } catch {
+    return null;
+  }
+}
+
+// tombstone=false: detach runtime resources (heartbeat, bash shells,
+// controller abort, runtime-map clear) WITHOUT planting the disk
+// tombstone. Used for non-empty sessions on /resume-away, /new, and
+// TUI exit: a tombstone would drop the session from the Resume list
+// immediately and let sweepTombstones() hard-delete it even though it
+// has real conversation content worth resuming. Only truly-empty
+// scratch sessions should still tombstone.
+//
+// The barrier (`newGen`) came first — it wins the race against saveSession().
+// tombstone=false plants no closed:true marker, so the session file stays
+// intact and resumeSession() will accept it, but the on-disk generation is
+// still bumped (bumpSessionGeneration): that alone protects the session from
+// a late save race. Any saveSession() still in flight from this detached turn
+// (e.g. the cancel-cleanup save below) carries the OLD generation as its
+// expectedGeneration, so _shouldDrop()'s ownership-counter rule drops it once
+// disk generation moves past that. Without this bump the late write could
+// silently overwrite the session after the user resumes it back (BL:
+// burned-session late-save clobber).
+function finishClose({ id, reason, tombstone, entry, closeSnapshot, newGen, outcome }) {
   // Durable lifecycle barrier check. ANY nonnumeric result means the barrier
   // is not on disk — a write failure, a liveness/ownership veto, a contended
   // commit lock, or a missing record. Only a failed write publishes a
@@ -154,7 +198,10 @@ function reportCloseBarrierFailure({ id, reason, tombstone, entry }) {
  */
 function cancelOwnedShellProcesses({ id, reason, tombstone }) {
   const record = (result) => {
-    if (tombstone && result?.confirmed === false) markSessionClosed(id, reason, { cancelStatus: 'cancel-unconfirmed' });
+    // Off the event loop's critical path: a refused rename retries on timers.
+    if (tombstone && result?.confirmed === false) {
+      markSessionClosedAsync(id, reason, { cancelStatus: 'cancel-unconfirmed' }).catch(() => {});
+    }
   };
   // A cancel that threw proved nothing either.
   const unconfirmed = () => record({ confirmed: false });

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

@@ -28,6 +28,7 @@ import { mintSessionId } from './session-id.mjs';
 import { hideCompactionArchive } from '../compaction-archive-capture.mjs';
 import { writeStderrBestEffort } from '../../../../shared/best-effort-stderr.mjs';
 import { forgetSideQuestion } from '../side-question-store.mjs';
+import { isAgentHomeSessionId } from '../agent-home.mjs';
 
 /** Force-flush session metrics to disk. */
 export async function flushSessionMetrics(sessionId) {
@@ -207,9 +208,12 @@ function clearTokenAccounting(session, messages, keep, beforeMessageTokens) {
 // Fork the outgoing transcript to a separate resumable session BEFORE the wipe,
 // so the conversation about to be discarded stays reachable via /resume under a
 // fresh id. Best-effort: any failure here must never block the clear itself.
-function forkOutgoingTranscript(session, messages, now) {
+// `archiveAs` names the fork (an agent home's "대화 새로 시작": the host
+// archives that id before the clear) and makes it durable first: the returned
+// promise settles once the copy is on disk, and the wipe waits on it.
+function forkOutgoingTranscript(session, messages, now, archiveAs = '') {
   try {
-    const forkId = mintSessionId();
+    const forkId = archiveAs || mintSessionId();
     const fork = {
       ...session,
       id: forkId,
@@ -234,6 +238,15 @@ function forkOutgoingTranscript(session, messages, now) {
       delete fork.compaction.archive;
     }
     setLiveSession(fork);
+    if (archiveAs) {
+      return saveSessionAsync(fork).then(
+        () => evictLiveSession(forkId),
+        (err) => {
+          evictLiveSession(forkId);
+          throw err;
+        }
+      );
+    }
     void saveSessionAsync(fork)
       .then(() => {
         // The fork is a cold snapshot kept for /resume. Once durable on
@@ -247,17 +260,33 @@ function forkOutgoingTranscript(session, messages, now) {
         writeStderrBestEffort(`[session] clear-fork save failed (sess=${forkId}): ${err?.message || err}\n`);
       });
   } catch (err) {
+    if (archiveAs) throw err;
     writeStderrBestEffort(`[session] clear-fork failed (sess=${session.id}): ${err?.message || err}\n`);
   }
 }
 
+const ARCHIVE_ID = /^sess_[A-Za-z0-9_-]{8,200}$/;
+
+/** The fork id a clear was asked to archive under, '' when none. */
+function clearArchiveId(value, sessionId) {
+  if (value === undefined || value === null || value === '') return '';
+  const id = String(value);
+  if (!ARCHIVE_ID.test(id) || id === sessionId || isAgentHomeSessionId(id)) {
+    throw new Error('clear: archiveAs must be a fresh session id');
+  }
+  if (loadSession(id)) throw new Error(`clear: session ${id} already exists`);
+  return id;
+}
+
 export async function clearSessionMessages(sessionId, options = {}) {
   const session = loadSession(sessionId);
   if (!session) return false;
   // Don't resurrect a closed session just to clear its messages.
   if (session.closed === true) return false;
   const clearOptions = options && typeof options === 'object' ? options : {};
-  const compact = clearOptions.compact === true;
+  const archiveAs = clearArchiveId(clearOptions.archiveAs, sessionId);
+  // An archived reset keeps the whole transcript: never compacted first.
+  const compact = clearOptions.compact === true && !archiveAs;
   const currentMessages = Array.isArray(session.messages) ? session.messages : [];
   const beforeMessageTokens = estimateMessagesTokens(currentMessages);
   const { messages, clearCompactError } = compact
@@ -275,8 +304,14 @@ export async function clearSessionMessages(sessionId, options = {}) {
   // content the live session retains via the summary, so the fork duplicated
   // it as a confusing extra Recent row ("Re-attached after compaction…" —
   // user report). Plain /clear (no summary kept) still forks.
+  // `fork: false` (a room member's reset: the room's own log keeps the
+  // conversation) skips the copy; an `archiveAs` clear always keeps one.
   const summaryCarriedForward = keep.some(isCompactSummaryMessage);
-  if (hasUserConversationMessage(messages) && !summaryCarriedForward) forkOutgoingTranscript(session, messages, now);
+  const keepCopy = clearOptions.fork !== false || Boolean(archiveAs);
+  if (keepCopy && hasUserConversationMessage(messages) && !summaryCarriedForward) {
+    const fork = forkOutgoingTranscript(session, messages, now, archiveAs);
+    if (archiveAs) await fork;
+  }
 
   session.messages = keep;
   // Clear truncates the transcript wholesale; drop the provider prefix

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

@@ -9,6 +9,7 @@ import { saveSession, saveSessionAsync, saveSessionAsyncDeferred, loadSession, s
 import { _liveSessions } from '../store/live-state.mjs';
 import { _recoverTurnCheckpointDurably } from './turn-checkpoint-recovery.mjs';
 import { isAgentOwner } from '../../agent-owner.mjs';
+import { AGENT_MODE, resolveSessionMode, sessionModeOf } from '../agent-mode.mjs';
 import { getHiddenAgent } from '../../internal-agents.mjs';
 import { loadConfig } from '../../config.mjs';
 import {
@@ -19,6 +20,7 @@ import {
 import { normalizeAutoClearConfig, resolveAutoClearIdleMs } from '../../runtime-core/config-helpers.mjs';
 import { _buildBaseRules } from './rules-cache.mjs';
 import { composeSessionSystem, seedSessionMessages } from './session-prompt-composition.mjs';
+import { agentProfileRevision, leadRosterRevision } from '../../context/role-instructions.mjs';
 import {
   _prepareResumeTools,
   delegationDisabled,
@@ -206,12 +208,22 @@ function logSessionSurface({ resolvedAgent, toolPermission, tools }) {
   }
 }
 
-export function createSession(opts) {
-  const presetObj = opts.preset && typeof opts.preset === 'object' ? opts.preset : null;
-  const resolved = resolveAgentRuntimeProfile(opts, presetObj);
+export function createSession(createOpts) {
+  const presetObj = createOpts.preset && typeof createOpts.preset === 'object' ? createOpts.preset : null;
+  const resolved = resolveAgentRuntimeProfile(createOpts, presetObj);
   const { profile } = resolved;
-  const route = resolveSessionRoute(opts, presetObj, profile);
+  const route = resolveSessionRoute(createOpts, presetObj, profile);
   const { providerName, modelName, provider, toolPreset, id } = route;
+  // Agent or coding mode (agent-mode.mjs), resolved once and persisted. An
+  // agent-mode Lead acts as its agent: a schedule/webhook run that names only
+  // its `ownerAgentId` gets that agent's role, persona and connector policy
+  // (all keyed by `session.agent`), as its home thread does.
+  const sessionMode = sessionModeOf({ ...createOpts, id });
+  const actingAgent = resolveSessionMode({ session: { ...createOpts, id } }).agentId;
+  const opts =
+    sessionMode === AGENT_MODE && !createOpts.agent && actingAgent
+      ? { ...createOpts, agent: actingAgent, sessionMode }
+      : { ...createOpts, sessionMode };
   const routeFallbacks = normalizeWorkflowRoute({
     provider: providerName,
     model: modelName,
@@ -227,7 +239,10 @@ export function createSession(opts) {
   // Scoped to explicit-breakpoint (Anthropic-family) providers only.
   const providerCacheOpts = resolved.providerCacheOpts || buildSessionProviderCacheOpts(providerName, id, opts.agent);
   const surface = resolveSessionToolSurface(opts, { profile, toolPreset, modelName });
-  const prompt = composeSessionSystem(opts, { profile, providerName, modelName, surface });
+  // The agent profile the prompt is composed from, read first: an edit landing
+  // during composition leaves the stamp behind, never ahead (refreshAgentProfile).
+  const agentProfile = surface.ownerIsAgent ? '' : agentProfileRevision(surface.resolvedAgent);
+  const prompt = composeSessionSystem(opts, { profile, providerName, modelName, surface, sessionMode });
   const messages = seedSessionMessages(prompt, opts.files);
   logSessionSurface(surface);
   const contextMeta = resolveSessionContextMeta(provider, modelName, {
@@ -246,6 +261,11 @@ export function createSession(opts) {
     origin: sessionOriginFields(opts, { profile, presetObj, providerCacheOpts, surface }),
   });
   session.providerCacheOptsOverride = Boolean(resolved.providerCacheOpts);
+  if (agentProfile) {
+    session.agentProfileRevision = agentProfile;
+    // The bot roster its prompt lists (a Lead's catalog slices).
+    session.agentRosterRevision = leadRosterRevision(opts.leadWorkflowParts);
+  }
   if (routeFallbacks?.length) session.routeFallbacks = routeFallbacks;
   // A non-native agent sends core + bridge, built from its filtered tools.
   applyAgentToolExposure(session);
@@ -532,6 +552,8 @@ export async function resumeSession(sessionId, preset, options = {}) {
   ensureCodexWireSessionId(session);
   if (!_applyDesktopResumeScope(session, options)) return null;
   if (!session.owner) session.owner = 'user';
+  // Records from before the mode existed get it resolved and stamped.
+  session.sessionMode = sessionModeOf(session);
   if (Object.hasOwn(options, 'mcpScopeId')) {
     session.mcpScopeId = String(options.mcpScopeId || '').trim() || null;
   }