negotium 0.2.3 → 0.2.5

package/dist/runtime/src/mcp/factories/session-comm.ts

@@ -22,6 +22,10 @@ export interface SessionCommMcpHost {
     context: SessionCommContext,
     profile: string,
   ): MaybePromise<SessionCommMcpResult>;
+  deleteBrowserProfile?(
+    context: SessionCommContext,
+    profile: string,
+  ): MaybePromise<SessionCommMcpResult>;
   peekSession(context: SessionCommContext): MaybePromise<SessionCommMcpResult>;
   setDescription(
     context: SessionCommContext,
@@ -90,6 +94,14 @@ export function createSessionCommMcpServer(
       async ({ profile }) => host.setBrowserProfile!(context, profile),
     );
   }
+  if (host.deleteBrowserProfile) {
+    server.tool(
+      "delete_browser_profile",
+      "Delete an unused named browser profile and its on-disk data. The default or an assigned profile cannot be deleted.",
+      { profile: z.string() },
+      async ({ profile }) => host.deleteBrowserProfile!(context, profile),
+    );
+  }
   server.tool(
     "peek_session",
     "Inspect running and idle sessions, including pending ask_session calls.",

package/dist/runtime/src/mcp/session-comm/default-host.ts

@@ -11,6 +11,7 @@ import { ACTIVE_QUERY_STALE_MS, MAX_TELL_DEPTH, USERS_LOG_DIR } from "#platform/
 import { appendJsonlEntry, readJsonFile } from "#platform/jsonl";
 import { OPTIONAL_FORUM_MCP_SERVERS, REQUIRED_FORUM_MCP_SERVERS } from "#platform/mcp-config";
 import { closeBrowserOwnerTabs } from "#platform/playwright/manager";
+import { deleteManagedBrowserProfile } from "#platform/playwright/profile-management";
 import { sessionInboxPath } from "#query/session-inbox-path";
 import { sanitizeId } from "#security/sanitize";
 import { getApiTopicConfig, setApiTopicConfig } from "#storage/api-topic-config";
@@ -199,6 +200,21 @@ export function createDefaultSessionCommMcpHost(): SessionCommMcpHost {
       }
     },
 
+    async deleteBrowserProfile(context, profile) {
+      const topic = currentTopic(context);
+      if (!topic) return error("Error: No current API topic.");
+      if (!isTopicBrowserProfileOwner(topic.id, context.userId)) {
+        return error("Error: Only the topic owner can delete its browser profiles.");
+      }
+      try {
+        const ownerId = getBrowserProfileOwner(topic.id, context.userId);
+        const result = await deleteManagedBrowserProfile(ownerId, profile);
+        return ok(JSON.stringify(result, null, 2));
+      } catch (err) {
+        return error(`Error: ${err instanceof Error ? err.message : String(err)}`);
+      }
+    },
+
     peekSession(context) {
       const targets = targetCatalog(context).listTargets();
       const running: string[] = [];

package/dist/runtime/src/mcp/session-comm/server.ts

@@ -12,6 +12,7 @@ import {
   REQUIRED_FORUM_MCP_SERVERS,
 } from "#platform/mcp-config";
 import { closeBrowserOwnerTabs } from "#platform/playwright/manager";
+import { deleteManagedBrowserProfile } from "#platform/playwright/profile-management";
 import { sanitizeId } from "#security/sanitize";
 import { getTopic } from "#storage/api-topics";
 import {
@@ -318,6 +319,30 @@ server.tool(
   },
 );
 
+server.tool(
+  "delete_browser_profile",
+  "Delete an unused named browser profile and its on-disk data. The default or an assigned profile cannot be deleted.",
+  {
+    profile: z
+      .string()
+      .describe("Unused named profile to delete; the default profile cannot be deleted"),
+  },
+  async ({ profile }) => {
+    const topicId = currentApiTopicId();
+    if (!topicId || !userId) return mcpError("Error: No current API topic.");
+    if (!isTopicBrowserProfileOwner(topicId, userId)) {
+      return mcpError("Error: Only the topic owner can delete its browser profiles.");
+    }
+    try {
+      const ownerId = getBrowserProfileOwner(topicId, userId);
+      const result = await deleteManagedBrowserProfile(ownerId, profile);
+      return mcpOk(JSON.stringify(result, null, 2));
+    } catch (err) {
+      return mcpError(`Error: ${errMsg(err)}`);
+    }
+  },
+);
+
 // --- always-available session inspection / self-config ---
 
 server.tool(

package/dist/runtime/src/mcp/wiki-server.ts

@@ -439,23 +439,28 @@ function wikiLastConversation(args: Record<string, unknown>): CallToolResult {
 
   const name = slugify(topicNameFrom(rawTopic));
 
-  // Try per-topic archive dir first, then flat file
+  // Try per-topic archive dir first, then flat file. This is a read path —
+  // it must never create directories on lookup (that previously left an
+  // empty `wiki/archive/<topic>/` behind for every topic name ever queried,
+  // even when nothing was ever archived under the per-topic layout).
   const archiveDir = resolve(runtime().archiveDir, name);
-  ensureDir(archiveDir);
 
   try {
     // List archive files sorted by name (which should be date-sorted)
-    let files = readdirSync(archiveDir)
-      .filter((f) => f.endsWith(".jsonl"))
-      .sort()
-      .reverse();
+    let files = existsSync(archiveDir)
+      ? readdirSync(archiveDir)
+          .filter((f) => f.endsWith(".jsonl"))
+          .sort()
+          .reverse()
+      : [];
     if (files.length === 0) {
       // Try flat archive
-      ensureDir(runtime().archiveDir);
-      files = readdirSync(runtime().archiveDir)
-        .filter((f) => f.startsWith(name) && f.endsWith(".jsonl"))
-        .sort()
-        .reverse();
+      files = existsSync(runtime().archiveDir)
+        ? readdirSync(runtime().archiveDir)
+            .filter((f) => f.startsWith(name) && f.endsWith(".jsonl"))
+            .sort()
+            .reverse()
+        : [];
     }
     if (files.length === 0) {
       return {
@@ -467,7 +472,9 @@ function wikiLastConversation(args: Record<string, unknown>): CallToolResult {
     const actualPath = files[0].includes("/")
       ? files[0]
       : resolve(
-          readdirSync(archiveDir).includes(files[0]) ? archiveDir : runtime().archiveDir,
+          existsSync(archiveDir) && readdirSync(archiveDir).includes(files[0])
+            ? archiveDir
+            : runtime().archiveDir,
           files[0],
         );
 

package/dist/runtime/src/platform/config.ts

@@ -75,7 +75,6 @@ export const BROWSER_PROFILES_DIR = resolve(BROWSER_DIR, "profiles");
 export const BINARIES_DIR = resolve(STATE_DIR, "binaries");
 export const SECRETS_DIR = resolve(STATE_DIR, "secrets");
 // Legacy names remain public, but their durable contents now live under data.
-export const CONTEXTS_DIR = resolve(STATE_DIR, "data", "contexts");
 export const DM_WORKSPACE_DIR = resolve(STATE_DIR, "data", "dm");
 export const SESSION_WORKSPACE_DIR = resolve(STATE_DIR, "data", "sessions");
 // The Claude Agent SDK ships a platform-matched Claude Code binary. Keep that
@@ -364,7 +363,6 @@ mkdirSync(WORKSPACE_DIR, { recursive: true });
 mkdirSync(TOPIC_WORKSPACE_DIR, { recursive: true });
 mkdirSync(SHARED_WIKI_DIR, { recursive: true });
 mkdirSync(CRON_WORKSPACE_DIR, { recursive: true });
-mkdirSync(CONTEXTS_DIR, { recursive: true });
 mkdirSync(DM_WORKSPACE_DIR, { recursive: true });
 mkdirSync(SESSION_WORKSPACE_DIR, { recursive: true });
 mkdirSync(BROWSER_DIR, { recursive: true });
@@ -453,7 +451,10 @@ export const MAX_TELL_DEPTH =
 /** Codex CLI auth file. 호출 시점에 env를 읽는다 — 테스트가 런타임에
  *  NEGOTIUM_CODEX_AUTH_FILE을 바꾸므로 모듈 로드 상수로 만들면 안 된다. */
 export function codexAuthFilePath(): string {
-  return process.env.NEGOTIUM_CODEX_AUTH_FILE || join(homedir(), ".codex", "auth.json");
+  return (
+    process.env.NEGOTIUM_CODEX_AUTH_FILE ||
+    join(process.env.CODEX_HOME || join(homedir(), ".codex"), "auth.json")
+  );
 }
 
 // System defaults moved to per-agent registries

package/dist/runtime/src/platform/log-rotation.ts

@@ -0,0 +1,45 @@
+/**
+ * Size-based rotation for daemon stderr logs.
+ *
+ * Negotium adapters (`negotium-terminal`, `negotium-telegram`, `negotium-otium`)
+ * each spawn the node daemon with its stderr redirected straight to
+ * `<LOG_DIR>/node-daemon.log`. That file is opened once at spawn time and
+ * accumulates for the daemon's whole lifetime with no cap, so long-running
+ * hosts eventually carry an unbounded log file.
+ *
+ * True in-place rotation (SIGHUP-style reopen) would require the daemon to
+ * cooperate by reopening its own stderr fd, which Bun does not expose. The
+ * practical fix instead rotates *before* spawn: every time a CLI is about to
+ * start the daemon, check the previous log's size and, if it crossed the
+ * threshold, rename it aside with a timestamp so the new spawn starts a
+ * fresh, empty file.
+ */
+
+import { existsSync, renameSync, statSync } from "node:fs";
+import { join } from "node:path";
+
+/** Rotate once the log exceeds this size (bytes) at the next daemon start. */
+export const DEFAULT_DAEMON_LOG_ROTATE_BYTES = 20 * 1024 * 1024; // 20MB
+
+/**
+ * If `logPath` exists and is at least `maxBytes`, rename it aside with an
+ * ISO-ish timestamp suffix so a fresh file can be created at `logPath`.
+ * No-op (and never throws) when the file is missing, under the threshold, or
+ * the rename fails for any reason — log rotation must never block startup.
+ */
+export function rotateOversizedLog(
+  logPath: string,
+  maxBytes: number = DEFAULT_DAEMON_LOG_ROTATE_BYTES,
+): void {
+  try {
+    if (!existsSync(logPath)) return;
+    const { size } = statSync(logPath);
+    if (size < maxBytes) return;
+    const stamp = new Date().toISOString().replace(/[:.]/g, "-");
+    const dir = join(logPath, "..");
+    const base = logPath.slice(dir.length + 1);
+    renameSync(logPath, join(dir, `${base}.${stamp}`));
+  } catch {
+    // Best-effort: a failed rotation should never prevent the daemon from starting.
+  }
+}

package/dist/runtime/src/platform/mcp-config.ts

@@ -207,6 +207,8 @@ export function consumePlaywrightUnavailable(userId: string, topic: string | und
 
 export interface RuntimeMcpBuildContext {
   userId: string;
+  /** Vault namespace when credentials belong to a different principal. */
+  vaultUserId?: string;
   /** "dm" for DM scope, topic/session name for forum/fork. */
   session: string;
   /** REST/WS topic id when known. Prefer for authorization/scope checks. */
@@ -527,13 +529,13 @@ const MCP_CATALOG: Record<string, RuntimeMcpCatalogEntry> = {
   vault: {
     ...commonRuntimeMcpPolicy("vault"),
     build(ctx) {
-      const { userId, agent } = ctx;
+      const { userId, vaultUserId, agent } = ctx;
       // Normal turns use {{KEY}} directly in tool inputs. Keep the Vault MCP
       // surface focused on key discovery; broker tools remain available from
       // the public factory for compatibility but are no longer the default UX.
-      const args = [`--user-id=${userId}`];
+      const args = [`--user-id=${vaultUserId ?? userId}`];
       if (agent !== "codex") args.push("--list-only=true");
-      return buildBuiltinMcpServer("vault", ctx, () =>
+      return buildBuiltinMcpServer("vault", { ...ctx, userId: vaultUserId ?? userId }, () =>
         buildStdioMcpServer(agent, VAULT_SERVER, args),
       );
     },
@@ -767,6 +769,7 @@ export function getManagerMcpServers(opts: {
  */
 export function getForumMcpServers(opts: {
   userId: string;
+  vaultUserId?: string;
   session: string;
   topicId?: string;
   subagentParentTopicId?: string;
@@ -790,6 +793,7 @@ export function getForumMcpServers(opts: {
 }) {
   const {
     userId,
+    vaultUserId,
     session,
     topicId,
     subagentParentTopicId,
@@ -824,6 +828,7 @@ export function getForumMcpServers(opts: {
     "forum",
     {
       userId,
+      vaultUserId,
       session,
       topicId,
       subagentParentTopicId,
@@ -945,6 +950,7 @@ export function getMcpServersForQuery(opts: AgentQueryOptions): Record<string, u
   }
   return getForumMcpServers({
     userId: opts.userId || "local",
+    vaultUserId: opts.vaultUserId,
     session: opts.session || "default",
     topicId: opts.topicId,
     subagentParentTopicId: opts.subagentParentTopicId,

package/dist/runtime/src/platform/playwright/manager.ts

@@ -84,10 +84,23 @@ export interface PlaywrightManagerHost {
   ) => NodeJS.ProcessEnv;
   /** Reap an orphan that owns this exact host-managed data directory. */
   readonly cleanupBrowserProcessesForDataDir: (userDataDir: string) => void;
+  /** Remove an exact host-managed profile directory, rejecting paths outside the host's root. */
+  readonly removeProfileDataDir?: (userDataDir: string) => boolean;
   /** Reap host-managed browsers that are not represented by the supplied live directories. */
   readonly reapOrphanBrowsers: (liveUserDataDirs: Iterable<string>) => void;
 }
 
+function removeDefaultProfileDataDir(userDataDir: string): boolean {
+  const root = resolve(BROWSER_PROFILES_DIR);
+  const target = resolve(userDataDir);
+  if (dirname(target) !== root) {
+    throw new Error(`Refusing to delete browser profile outside managed root: ${target}`);
+  }
+  const existed = existsSync(target);
+  rmSync(target, { recursive: true, force: true });
+  return existed;
+}
+
 export {
   cleanupZombiePlaywright,
   isBrowserJanitorOwner,
@@ -210,6 +223,7 @@ const defaultManagerHost: Readonly<PlaywrightManagerHost> = Object.freeze({
   },
   createChildEnvironment: defaultChildEnvironment,
   cleanupBrowserProcessesForDataDir: killBrowserProcsForUserDataDir,
+  removeProfileDataDir: removeDefaultProfileDataDir,
   reapOrphanBrowsers,
 });
 
@@ -239,10 +253,12 @@ export function configurePlaywrightManagerHost(
     next.resolveInstanceDataDir !== defaultManagerHost.resolveInstanceDataDir &&
     (next.cleanupBrowserProcessesForDataDir ===
       defaultManagerHost.cleanupBrowserProcessesForDataDir ||
+      !next.removeProfileDataDir ||
+      next.removeProfileDataDir === defaultManagerHost.removeProfileDataDir ||
       next.reapOrphanBrowsers === defaultManagerHost.reapOrphanBrowsers)
   ) {
     throw new Error(
-      "custom Playwright profile paths require host crash cleanup and orphan sweep hooks",
+      "custom Playwright profile paths require host crash cleanup, profile removal, and orphan sweep hooks",
     );
   }
   managerHost = Object.freeze(next);
@@ -293,6 +309,7 @@ function deletePortFile(instanceKey: string) {
   try {
     unlinkSync(join(managerHost.portsDir, portFileName(instanceKey)));
   } catch (e) {
+    if ((e as NodeJS.ErrnoException).code === "ENOENT") return;
     logger.warn({ err: e, instanceKey }, "Failed to delete playwright port file");
   }
 }
@@ -433,6 +450,45 @@ export function stopPlaywrightProfile(ownerId: string, rawProfile: string): Prom
   );
 }
 
+export interface RemovePlaywrightProfileDataResult {
+  dataDir: string;
+  processStopped: boolean;
+  dataRemoved: boolean;
+}
+
+export interface RemovePlaywrightProfileDataOptions {
+  /** Revalidate external ownership immediately before the synchronous removal. */
+  beforeRemove?: () => void;
+  /** Commit external metadata before releasing the profile lifecycle barrier. */
+  afterRemove?: () => void;
+}
+
+/** Stop all exact-profile processes and remove its data through the configured host boundary. */
+export function removePlaywrightProfileData(
+  ownerId: string,
+  rawProfile: string,
+  options: RemovePlaywrightProfileDataOptions = {},
+): Promise<RemovePlaywrightProfileDataResult> {
+  return withPlaywrightProfileMaintenance(
+    ownerId,
+    rawProfile,
+    async (binding, { stopInstance }) => {
+      const dataDir = resolveUserDataDir(binding.instanceKey);
+      const processStopped = await stopInstance(binding.instanceKey);
+      managerHost.cleanupBrowserProcessesForDataDir(dataDir);
+      deletePortFile(binding.instanceKey);
+      options.beforeRemove?.();
+      const removeProfileDataDir = managerHost.removeProfileDataDir;
+      if (!removeProfileDataDir) {
+        throw new Error("Browser profile deletion is not configured for this host.");
+      }
+      const dataRemoved = removeProfileDataDir(dataDir);
+      options.afterRemove?.();
+      return { dataDir, processStopped, dataRemoved };
+    },
+  );
+}
+
 // A shared profile may have several concurrent turns. Reference counts keep an
 // idle sweep from evicting the process until every borrower has finished.
 const pinnedInstances = new Map<string, number>();

package/dist/runtime/src/platform/playwright/profile-management.ts

@@ -0,0 +1,33 @@
+import { removePlaywrightProfileData } from "#platform/playwright/manager";
+import { assertBrowserProfileDeletable, deleteBrowserProfile } from "#storage/browser-profiles";
+
+export interface DeleteManagedBrowserProfileResult {
+  profile: string;
+  metadataRemoved: boolean;
+  dataRemoved: boolean;
+  processStopped: boolean;
+}
+
+/** Delete an unused named profile while serialized against browser startup. */
+export async function deleteManagedBrowserProfile(
+  ownerId: string,
+  rawProfile: string,
+): Promise<DeleteManagedBrowserProfileResult> {
+  const profile = assertBrowserProfileDeletable(ownerId, rawProfile);
+  let metadataRemoved = false;
+  const removed = await removePlaywrightProfileData(ownerId, profile, {
+    beforeRemove: () => {
+      assertBrowserProfileDeletable(ownerId, profile);
+    },
+    afterRemove: () => {
+      metadataRemoved = deleteBrowserProfile(ownerId, profile);
+    },
+  });
+
+  return {
+    profile,
+    metadataRemoved,
+    dataRemoved: removed.dataRemoved,
+    processStopped: removed.processStopped,
+  };
+}

package/dist/runtime/src/platform/playwright/public-runtime.ts

@@ -20,6 +20,7 @@ export {
   type PlaywrightProfileBinding,
   pinPlaywrightInstance,
   reapPlaywrightOrphans,
+  removePlaywrightProfileData,
   resetPlaywrightManagerHost,
   resolvePlaywrightCapabilityOwner,
   resolvePlaywrightProfileBinding,
@@ -39,6 +40,10 @@ export {
   waitForChildProcessExit,
   waitForChildProcessSpawnError,
 } from "./manager-utils";
+export {
+  type DeleteManagedBrowserProfileResult,
+  deleteManagedBrowserProfile,
+} from "./profile-management";
 export {
   probeMcpTransport,
   probePlaywrightMcpTransports,

package/dist/runtime/src/platform/playwright/vault-broker.ts

@@ -3,7 +3,7 @@ import { chmodSync } from "node:fs";
 import { createServer, type Server, type Socket } from "node:net";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
-import { normalizeVaultKey, redactVaultSecrets, vaultListWithValues } from "#storage/vault-public";
+import { redactVaultSecrets, vaultGetValue, vaultSubstituteDetailed } from "#storage/vault-public";
 
 const MAX_REQUEST_BYTES = 16 * 1024 * 1024;
 const DEFAULT_OUTPUT_LIMIT = 100_000;
@@ -158,16 +158,15 @@ export async function createBrowserVaultBroker(userId: string): Promise<BrowserV
       if (leases.size >= MAX_ACTIVE_LEASES) {
         return { id, ok: false, error: "too many active leases" };
       }
-      const entries = new Map(vaultListWithValues(userId).map((entry) => [entry.key, entry.value]));
-      const substituted = deepMapStrings(request.value, (text) =>
-        text.replace(/\{\{([^}]+)\}\}/g, (match, rawKey: string) => {
-          const key = normalizeVaultKey(rawKey);
-          const secret = entries.get(key);
-          if (secret === undefined) return match;
+      const substituted = deepMapStrings(request.value, (text) => {
+        const result = vaultSubstituteDetailed(userId, text);
+        for (const key of result.usedKeys) {
+          const secret = vaultGetValue(userId, key);
+          if (secret === undefined) continue;
           for (const form of encodedSecretForms(secret)) retainedForms.set(form, key);
-          return secret;
-        }),
-      );
+        }
+        return result.text;
+      });
       const prepared = prepareInput(request.tool, substituted);
       const lease = randomBytes(24).toString("hex");
       leases.set(lease, { boundary: prepared.boundary, createdAt: Date.now() });

package/dist/runtime/src/query/active-rooms.ts

@@ -42,6 +42,8 @@ export interface DeferredInject {
   /** Topic execution epoch captured when this work was accepted. */
   runtimeEpoch?: number;
   userId: string;
+  /** Credential namespace when the executor and Vault owner differ. */
+  vaultUserId?: string;
   prompt: string;
   /** Inject source — the topic name/id this inject came from (never "user"). */
   origin: string;
@@ -120,8 +122,12 @@ export interface RoomQueryControl {
   durableRequestIds?: string[];
   /** Attachment ids currently being processed. User-turn preemption carries them forward. */
   attachments?: string[];
-  /** Provider session id this turn resumed from. Superseding user turns restart from this base. */
+  /** Latest provider session id observed for this turn. */
   sessionId?: string | null;
+  /** True once the provider has published the native session backing this turn. */
+  providerSessionObserved?: boolean;
+  /** True once provider output proves that this turn's prompt reached the native session. */
+  providerTurnContentObserved?: boolean;
   abortController: AbortController;
   abortReason: AbortReason;
   /** Specific failure surfaced when infrastructure aborts the turn. */

package/dist/runtime/src/runtime/errors.ts

@@ -64,6 +64,7 @@ export function isSessionExpiredError(message: string): boolean {
   return (
     message.includes(SESSION_EXPIRED_MSG) ||
     /session was recorded with model .+ but is resuming with/i.test(message) ||
+    /failed to resolve rollout path .+file does not exist/i.test(message) ||
     /session.*not found|session.*expired|unknown conversation/i.test(message)
   );
 }

package/dist/runtime/src/runtime/turn-event-stream.ts

@@ -64,6 +64,10 @@ import {
   updateApiMessageUsage,
 } from "#storage/api-messages";
 import { getTopic, setTopicSessionId } from "#storage/api-topics";
+import {
+  getRuntimeUserTurnRequest,
+  markRuntimeUserTurnProviderSessionObserved,
+} from "#storage/runtime-turn-requests";
 import { recordUsage } from "#storage/token-stats";
 import type { AgentKind, EffortLevel, PeerRuntimeBridgeContext, UnifiedEvent } from "#types";
 import type { MessageDto } from "#types/api";
@@ -267,6 +271,30 @@ export async function runTurnEventStream(
     for await (const event of events) {
       if (abortController.signal.aborted) break;
 
+      // A provider may publish its session id before it appends the user
+      // prompt to the native rollout. Only semantic provider output proves
+      // that the prompt made it into that session. This distinction matters
+      // when a second user message preempts the turn in that short window:
+      // the replacement must replay both messages instead of dropping the
+      // first one merely because a session event was seen.
+      if (
+        !control.providerTurnContentObserved &&
+        (event.type === "text_delta" ||
+          event.type === "text" ||
+          event.type === "reasoning" ||
+          event.type === "tool_use" ||
+          event.type === "tool_result" ||
+          event.type === "file" ||
+          event.type === "result")
+      ) {
+        control.providerTurnContentObserved = true;
+        if (control.sessionId) {
+          for (const requestId of control.durableRequestIds ?? []) {
+            markRuntimeUserTurnProviderSessionObserved(topicId, requestId, control.sessionId);
+          }
+        }
+      }
+
       switch (event.type) {
         case "text_delta": {
           pendingSawDelta = true;
@@ -672,6 +700,16 @@ export async function runTurnEventStream(
           }
           break;
         case "session":
+          // Keep the control synchronized with the provider, not merely the
+          // topic row. A superseding user message can then resume the partial
+          // native rollout after this process has fully unwound.
+          control.sessionId = event.sessionId;
+          control.providerSessionObserved = true;
+          if (control.providerTurnContentObserved) {
+            for (const requestId of control.durableRequestIds ?? []) {
+              markRuntimeUserTurnProviderSessionObserved(topicId, requestId, event.sessionId);
+            }
+          }
           // Persist visible topic turns only. Silent ask_session forks use
           // temporary session ids and must not clobber the topic's durable
           // session; visible tell/reply injects do belong to the main topic
@@ -788,7 +826,14 @@ export async function runTurnEventStream(
     // Drain one deferred session-inject if the room is now idle. If a
     // replacement turn already occupies the slot, leave it queued — that
     // turn's finally will drain it when it completes.
-    if (roomId === topicId && outcome.kind !== "session-expired" && !getRoomQuery(topicId)) {
+    const queuedUserTurn = roomId === topicId ? getRuntimeUserTurnRequest(topicId) : null;
+    const hasReplacementUserTurn = queuedUserTurn !== null && queuedUserTurn.requestId !== queryId;
+    if (
+      roomId === topicId &&
+      outcome.kind !== "session-expired" &&
+      !getRoomQuery(topicId) &&
+      !hasReplacementUserTurn
+    ) {
       const next = takeDeferredInject(topicId);
       if (next) redispatchInject(next);
     }