negotium 0.2.15 → 0.2.17

package/dist/runtime/src/agents/codex-provider.ts

@@ -28,10 +28,12 @@ import {
   hostedMcpServers,
 } from "#agents/execution-host";
 import {
+  type CodexTokenTotals,
   migrateCodexRolloutNativeMultiAgentMetadata,
   readCodexPatchCallIds,
   readLatestCodexContextUsage,
   readLatestCodexPatchPreview,
+  readLatestCodexTokenTotals,
 } from "#agents/rollout/codex";
 import { buildNumberedDiffSummary } from "#agents/tool-format";
 import { extractFileEvents } from "#media/file-events";
@@ -44,6 +46,46 @@ import {
 } from "#platform/mcp-config";
 import type { AgentQueryOptions, EffortLevel, UnifiedEvent } from "#types";
 
+type CodexEventUsage = {
+  input_tokens: number;
+  output_tokens: number;
+  cached_input_tokens?: number;
+  cache_write_input_tokens?: number;
+};
+
+function sameCodexUsage(usage: CodexEventUsage, total: CodexTokenTotals): boolean {
+  return (
+    usage.input_tokens === total.inputTokens &&
+    usage.output_tokens === total.outputTokens &&
+    (usage.cached_input_tokens ?? 0) === total.cachedInputTokens &&
+    (usage.cache_write_input_tokens ?? 0) === total.cacheWriteInputTokens
+  );
+}
+
+/**
+ * Some Codex CLI builds expose the thread-lifetime counter on turn.completed
+ * despite the SDK declaring turn-local usage. Only subtract a rollout baseline
+ * when the event exactly matches the rollout's cumulative counter.
+ */
+export function normalizeCodexTurnUsage(
+  usage: CodexEventUsage,
+  baseline: CodexTokenTotals | undefined,
+  rolloutTotal: CodexTokenTotals | undefined,
+): CodexEventUsage {
+  if (!baseline || !rolloutTotal || !sameCodexUsage(usage, rolloutTotal)) return usage;
+  const delta = (current: number, previous: number) =>
+    current >= previous ? current - previous : current;
+  return {
+    input_tokens: delta(rolloutTotal.inputTokens, baseline.inputTokens),
+    output_tokens: delta(rolloutTotal.outputTokens, baseline.outputTokens),
+    cached_input_tokens: delta(rolloutTotal.cachedInputTokens, baseline.cachedInputTokens),
+    cache_write_input_tokens: delta(
+      rolloutTotal.cacheWriteInputTokens,
+      baseline.cacheWriteInputTokens,
+    ),
+  };
+}
+
 /**
  * Pass Otium's EffortLevel through to Codex's ModelReasoningEffort.
  *
@@ -696,6 +738,7 @@ export async function* codexProvider(opts: AgentQueryOptions): AsyncGenerator<Un
   };
 
   let currentSessionId = opts.sessionId;
+  let usageBaseline = currentSessionId ? readLatestCodexTokenTotals(currentSessionId) : undefined;
 
   // Codex SDK has no systemPrompt option. A resumed thread may have been
   // synthesized from a captured shell, so always refresh the current runtime
@@ -782,6 +825,7 @@ export async function* codexProvider(opts: AgentQueryOptions): AsyncGenerator<Un
           thread = codex.startThread(threadOptions);
           prompt = promptForThread(opts, true);
           currentSessionId = undefined;
+          usageBaseline = undefined;
           startResult = await startStreamedWithTracking(
             thread,
             prompt,
@@ -827,6 +871,7 @@ export async function* codexProvider(opts: AgentQueryOptions): AsyncGenerator<Un
               input_tokens: number;
               output_tokens: number;
               cached_input_tokens?: number;
+              cache_write_input_tokens?: number;
             };
             error?: { message?: string };
           };
@@ -931,9 +976,14 @@ export async function* codexProvider(opts: AgentQueryOptions): AsyncGenerator<Un
             }
 
             case "turn.completed": {
-              const usage = event.usage;
-              if (!usage) break;
+              const rawUsage = event.usage;
+              if (!rawUsage) break;
               attemptCompleted = true;
+              const usage = normalizeCodexTurnUsage(
+                rawUsage,
+                usageBaseline,
+                currentSessionId ? readLatestCodexTokenTotals(currentSessionId) : undefined,
+              );
               const contextUsage = currentSessionId
                 ? readLatestCodexContextUsage(currentSessionId)
                 : undefined;
@@ -944,6 +994,7 @@ export async function* codexProvider(opts: AgentQueryOptions): AsyncGenerator<Un
                 usage: {
                   inputTokens: usage.input_tokens,
                   outputTokens: usage.output_tokens,
+                  cacheCreationInputTokens: usage.cache_write_input_tokens,
                   cacheReadInputTokens: usage.cached_input_tokens,
                   ...contextUsage,
                 },

package/dist/runtime/src/agents/compaction-support.ts

@@ -54,7 +54,7 @@ function isCjkCodePoint(code: number): boolean {
   );
 }
 
-function estimateTextTokens(text: string): number {
+export function estimateTextTokens(text: string): number {
   let cjkChars = 0;
   let cjkUnits = 0;
   for (let index = 0; index < text.length; index++) {

package/dist/runtime/src/agents/maestro-provider.ts

@@ -256,6 +256,9 @@ export function maestroProvider(opts: AgentQueryOptions): AsyncGenerator<Unified
     ...opts,
     enableToolSearch: !opts.toolPolicy && opts.enableToolSearch !== false,
     toolResultTruncation: buildMaestroToolResultTruncation(opts),
+    // Invocation-only runtime facts stay out of the stable system prompt and
+    // the SDK's persisted session projections.
+    ephemeralSystemPrompt: opts.ephemeralSystemPrompt,
     // Resolve this after spreading caller options so untrusted runtime input
     // cannot replace a topic owner's Vault credentials with another key.
     apiKeyOverrides: resolveMaestroApiKeyOverrides(userId),

package/dist/runtime/src/agents/rollout/codex.ts

@@ -145,6 +145,13 @@ export interface CodexContextUsage {
   contextWindow: number;
 }
 
+export interface CodexTokenTotals {
+  inputTokens: number;
+  outputTokens: number;
+  cachedInputTokens: number;
+  cacheWriteInputTokens: number;
+}
+
 export interface CodexPatchChangePreview {
   path: string;
   before?: string;
@@ -389,6 +396,50 @@ export function extractLatestCodexContextUsage(jsonl: string): CodexContextUsage
   return undefined;
 }
 
+/** Latest cumulative token counter persisted in a native Codex rollout. */
+export function extractLatestCodexTokenTotals(jsonl: string): CodexTokenTotals | undefined {
+  const lines = jsonl.trimEnd().split("\n");
+  for (let index = lines.length - 1; index >= 0; index -= 1) {
+    try {
+      const entry = JSON.parse(lines[index] ?? "") as {
+        type?: string;
+        payload?: {
+          type?: string;
+          info?: {
+            total_token_usage?: {
+              input_tokens?: number;
+              output_tokens?: number;
+              cached_input_tokens?: number;
+              cache_write_input_tokens?: number;
+            };
+          };
+        };
+      };
+      if (entry.type !== "event_msg" || entry.payload?.type !== "token_count") continue;
+      const usage = entry.payload.info?.total_token_usage;
+      if (!usage) continue;
+      const values = [
+        usage.input_tokens,
+        usage.output_tokens,
+        usage.cached_input_tokens,
+        usage.cache_write_input_tokens,
+      ];
+      if (values.some((value) => value !== undefined && (!Number.isFinite(value) || value < 0))) {
+        continue;
+      }
+      return {
+        inputTokens: usage.input_tokens ?? 0,
+        outputTokens: usage.output_tokens ?? 0,
+        cachedInputTokens: usage.cached_input_tokens ?? 0,
+        cacheWriteInputTokens: usage.cache_write_input_tokens ?? 0,
+      };
+    } catch {
+      // A concurrently appended final line may be incomplete; keep scanning.
+    }
+  }
+  return undefined;
+}
+
 /** Resolve a thread's current rollout and return its latest context measurement. */
 export function readLatestCodexContextUsage(threadId: string): CodexContextUsage | undefined {
   const path = latestCodexRolloutPath(threadId);
@@ -401,6 +452,17 @@ export function readLatestCodexContextUsage(threadId: string): CodexContextUsage
   }
 }
 
+export function readLatestCodexTokenTotals(threadId: string): CodexTokenTotals | undefined {
+  const path = latestCodexRolloutPath(threadId);
+  if (!path) return undefined;
+  try {
+    return extractLatestCodexTokenTotals(readFileSync(path, "utf8"));
+  } catch (error) {
+    logger.debug({ error, threadId }, "codex token totals: rollout read failed");
+    return undefined;
+  }
+}
+
 /**
  * Old and metadata-free Codex rollouts resume as native multi-agent v1 even
  * when the feature flag is false. Rewrite their runtime metadata in place so

package/dist/runtime/src/index.ts

@@ -11,6 +11,7 @@ import "#platform/maestro-bootstrap-env";
 // ── Agents ──────────────────────────────────────────────────────────
 export { checkAgentAuth, checkAgentModelAuth } from "#agents/auth-check";
 export { killOwnedCodexTreesForShutdown } from "#agents/codex-tree-kill";
+export { estimateTextTokens } from "#agents/compaction-support";
 export type { ForkHandle } from "#agents/fork";
 export { cleanupAgentFork, forkAgentSession } from "#agents/fork";
 export { runAgent, SUPPORTED_AGENTS } from "#agents/index";

package/dist/runtime/src/mcp/factories/token-stats.ts

@@ -1,6 +1,6 @@
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { z } from "zod";
-import { type Bucket, calcCost, getStats } from "#storage/token-stats";
+import { type Bucket, type CurrentSessionUsage, calcCost, getStats } from "#storage/token-stats";
 
 export interface TokenStatsMcpContext {
   userId: string;
@@ -10,6 +10,8 @@ export interface TokenStatsSnapshot {
   total: Bucket;
   byHour: Record<string, Bucket>;
   bySession: Record<string, Bucket>;
+  currentSessions?: CurrentSessionUsage[];
+  ignoredLegacyRecords?: number;
   estimatedCostUsd: number;
 }
 
@@ -18,7 +20,11 @@ export interface TokenStatsMcpHost {
   calcCost(
     bucket: Pick<
       Bucket,
-      "inputTokens" | "outputTokens" | "cacheCreationInputTokens" | "cacheReadInputTokens"
+      | "inputTokens"
+      | "outputTokens"
+      | "cacheCreationInputTokens"
+      | "cacheReadInputTokens"
+      | "estimatedCostUsd"
     >,
   ): number;
   extraSummaryLines?(userId: string): readonly string[];
@@ -38,7 +44,7 @@ export function createTokenStatsMcpServer(
   server.tool(
     "get_usage_stats",
     [
-      "Claude 사용량 통계를 조회합니다. 완료된 쿼리마다 세션/시간 정보가 기록됩니다. 현재 실행 중인 turn은 완료 후 집계됩니다.",
+      "Claude/Codex/Maestro 사용량과 provider session의 최신 context 점유율을 조회합니다. 현재 실행 중인 turn은 완료 후 집계됩니다.",
       "",
       "from/to 생략 시 전체 기간. 자연어 시간 표현을 ISO 형식으로 변환해서 넘겨주세요.",
       "  예: '지난 3시간' → from = 현재 -3h",
@@ -53,22 +59,38 @@ export function createTokenStatsMcpServer(
       groupBy: z.enum(["hour", "session"]).optional().describe("집계 기준. 기본값: hour"),
     },
     async ({ from, to, groupBy = "hour" }) => {
-      const { total, byHour, bySession, estimatedCostUsd } = host.getStats(
-        context.userId,
-        from,
-        to,
-      );
+      const snapshot = host.getStats(context.userId, from, to);
+      const {
+        total,
+        byHour,
+        bySession,
+        currentSessions = [],
+        ignoredLegacyRecords = 0,
+        estimatedCostUsd,
+      } = snapshot;
       const lines: string[] = [
-        "📊 Claude 사용량",
+        "📊 Agent 사용량",
         from || to ? `기간: ${from ?? "전체"} ~ ${to ?? "현재"}` : "기간: 전체",
         "",
         `쿼리 횟수: ${total.queries.toLocaleString()}회`,
-        `입력 토큰: ${total.inputTokens.toLocaleString()}`,
+        `캐시 미적중 입력: ${total.inputTokens.toLocaleString()}`,
         `출력 토큰: ${total.outputTokens.toLocaleString()}`,
         `캐시 쓰기: ${total.cacheCreationInputTokens.toLocaleString()}`,
         `캐시 읽기: ${total.cacheReadInputTokens.toLocaleString()}`,
         `예상 비용: $${estimatedCostUsd.toFixed(4)} USD`,
       ];
+      if (ignoredLegacyRecords > 0) {
+        lines.push(`구형 레코드 제외: ${ignoredLegacyRecords.toLocaleString()}건`);
+      }
+      if (currentSessions.length > 0) {
+        lines.push("", `📐 현재 context (${currentSessions.length}개 provider session)`);
+        for (const current of currentSessions) {
+          const percent = (current.contextTokens / current.contextWindow) * 100;
+          lines.push(
+            `  ${current.topicTitle} · ${current.agent}/${current.model}  ${current.contextTokens.toLocaleString()} / ${current.contextWindow.toLocaleString()} (${percent.toFixed(1)}%)`,
+          );
+        }
+      }
       const extraSummaryLines = host.extraSummaryLines?.(context.userId) ?? [];
       if (extraSummaryLines.length > 0) lines.push("", ...extraSummaryLines);
 
@@ -79,7 +101,7 @@ export function createTokenStatsMcpServer(
         lines.push("", `🗂 세션별 사용량 (${sorted.length}개)`);
         for (const session of sorted) {
           lines.push(
-            `  ${session.name}  쿼리 ${session.queries}회  입력 ${session.inputTokens.toLocaleString()} / 출력 ${session.outputTokens.toLocaleString()}  $${session.cost.toFixed(4)}`,
+            `  ${session.name}  쿼리 ${session.queries}회  캐시 미적중 입력 ${session.inputTokens.toLocaleString()} / 캐시 읽기 ${session.cacheReadInputTokens.toLocaleString()} / 출력 ${session.outputTokens.toLocaleString()}  $${session.cost.toFixed(4)}`,
           );
         }
       } else {

package/dist/runtime/src/mcp/runtime-spec.ts

@@ -8,7 +8,7 @@
  * `mcp/runtime-server.ts` (transport-agnostic parts only).
  */
 
-import { createHmac, timingSafeEqual } from "node:crypto";
+import { createHash, createHmac, timingSafeEqual } from "node:crypto";
 import { NEGOTIUM_PORT, RUNTIME_MCP_SECRET } from "#platform/config";
 import { type AgentKind, isAgentKind, type PeerRuntimeBridgeContext } from "#types";
 
@@ -233,9 +233,57 @@ export function buildRuntimeMcpSpec(
     type: "sse" as const,
     url: `${base}/sse?${query}`,
     timeout: CLAUDE_MCP_TOOL_TIMEOUT_MS,
+    ...(agent === "maestro" ? { lifecycle: "turn" as const } : {}),
   };
 }
 
+function hostedMcpCacheIdentity(surface: HostedMcpSurface, ctx: HostedMcpContext): string {
+  let semanticContext: unknown;
+  switch (surface) {
+    case "system-health":
+      semanticContext = {};
+      break;
+    case "token-stats":
+    case "agent-health":
+      semanticContext = { userId: ctx.userId };
+      break;
+    case "task":
+      semanticContext = {
+        userId: ctx.userId,
+        topicTitle: ctx.topicTitle,
+        topicId: ctx.topicId ?? null,
+      };
+      break;
+    case "wiki":
+    case "skills":
+      semanticContext = {
+        userId: ctx.userId,
+        topicId: ctx.wikiTopicId ?? ctx.topicId ?? null,
+      };
+      break;
+    case "vault":
+      semanticContext = { userId: ctx.userId, cwd: ctx.cwd, agent: ctx.agent };
+      break;
+    case "session-comm":
+      semanticContext = {
+        userId: ctx.userId,
+        topicTitle: ctx.topicTitle,
+        topicId: ctx.topicId ?? null,
+        subagentParentTopicId: ctx.subagentParentTopicId ?? null,
+        depth: ctx.depth ?? 0,
+        silent: ctx.silent ?? false,
+        agent: ctx.agent,
+        peerBridge: ctx.peerBridge ?? null,
+      };
+      break;
+  }
+  const digest = createHash("sha256")
+    .update(JSON.stringify([surface, semanticContext]))
+    .digest("hex")
+    .slice(0, 24);
+  return `hosted:${surface}:${digest}`;
+}
+
 /** Build an agent transport spec for one logical MCP surface on the shared runtime process. */
 export function buildHostedMcpSpec(
   agent: AgentKind,
@@ -246,9 +294,18 @@ export function buildHostedMcpSpec(
   const base = `http://127.0.0.1:${runtimePort}${RUNTIME_MCP_BASE_PATH}/${surface}`;
   const query = `token=${encodeURIComponent(token)}`;
   if (agent === "codex") return { url: `${base}/mcp?${query}` };
+  const queryBound =
+    surface === "session-comm" && (ctx.silent === true || ctx.peerBridge !== undefined);
+  const lifecycle = queryBound ? "turn" : surface === "session-comm" ? "session" : "process";
   return {
     type: "sse" as const,
     url: `${base}/sse?${query}`,
     timeout: CLAUDE_MCP_TOOL_TIMEOUT_MS,
+    ...(agent === "maestro"
+      ? {
+          lifecycle,
+          cacheKey: hostedMcpCacheIdentity(surface, ctx),
+        }
+      : {}),
   };
 }

package/dist/runtime/src/node-host.ts

@@ -74,6 +74,7 @@ export {
   listRuntimeEventsAfter,
 } from "#storage/runtime-events";
 export { acquireRuntimeProcessLease } from "#storage/runtime-process-leases";
+export { getTopicStats } from "#storage/token-stats";
 export {
   getVisibleTopics,
   isParticipant,

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

@@ -1,6 +1,7 @@
 import { randomUUID } from "node:crypto";
 import { realpathSync, statSync } from "node:fs";
 import { isAbsolute, resolve } from "node:path";
+import { estimateTextTokens } from "#agents/compaction-support";
 import { cleanupAgentFork } from "#agents/fork";
 import { scheduleIdleArchiveForTopic } from "#agents/idle-archiver";
 import { cancelPendingAskUserQuestions } from "#agents/mcp-tools/ask-user";
@@ -69,7 +70,13 @@ import {
   markRuntimeUserTurnProviderSessionObserved,
 } from "#storage/runtime-turn-requests";
 import { recordUsage } from "#storage/token-stats";
-import type { AgentKind, EffortLevel, PeerRuntimeBridgeContext, UnifiedEvent } from "#types";
+import type {
+  AgentKind,
+  EffortLevel,
+  PeerRuntimeBridgeContext,
+  TokenUsage,
+  UnifiedEvent,
+} from "#types";
 import type { MessageDto } from "#types/api";
 
 export type StreamAgentOutcome =
@@ -139,6 +146,9 @@ export async function runTurnEventStream(
   let pendingSawDelta = false;
   let accumulatedText = "";
   let pendingText = "";
+  let assistantContextTokens = 0;
+  let toolContextTokens = 0;
+  let lastContextProgressAt = 0;
   let lastVisibleMessageId: string | null = null;
   const visibleMessageIds: string[] = [];
   let lastTaskPanelText: string | null = null;
@@ -149,6 +159,26 @@ export async function runTurnEventStream(
   const toolSummaryOptions = {
     cwd: control.injectParams?.cwd ?? workspaceCwdFor(topicId),
   };
+  const recordEventUsage = (usage: TokenUsage): void => {
+    recordUsage(userId, topicTitle, usage, {
+      topicId,
+      ...(control.sessionId ? { providerSessionId: control.sessionId } : {}),
+      agent: agentType,
+      model,
+    });
+  };
+  const broadcastContextProgress = (force = false): void => {
+    if (silent) return;
+    const now = Date.now();
+    if (!force && lastContextProgressAt > 0 && now - lastContextProgressAt < 250) return;
+    lastContextProgressAt = now;
+    hub.broadcastAiStatus(topicId, {
+      kind: "context_progress",
+      queryId,
+      assistantTokens: assistantContextTokens,
+      toolTokens: toolContextTokens,
+    });
+  };
   const nextSyntheticToolUseId = () => `tool-${queryId}-${++syntheticToolCounter}`;
   const bindToolUseId = (providerToolUseId?: string, fallback?: string): string => {
     const providerId = normalizeToolUseId(providerToolUseId);
@@ -301,6 +331,8 @@ export async function runTurnEventStream(
           const incoming = event.content;
           accumulatedText += incoming;
           pendingText += incoming;
+          assistantContextTokens = estimateTextTokens(accumulatedText);
+          broadcastContextProgress();
           break;
         }
         case "text":
@@ -308,6 +340,8 @@ export async function runTurnEventStream(
             const incoming = event.content;
             accumulatedText += incoming;
             pendingText += incoming;
+            assistantContextTokens = estimateTextTokens(accumulatedText);
+            broadcastContextProgress();
           }
           break;
         case "tool_use":
@@ -316,6 +350,10 @@ export async function runTurnEventStream(
           // original assistant → tool → assistant ordering instead of a block
           // of tools followed by one consolidated answer at turn completion.
           emitPendingAssistantMessage();
+          toolContextTokens += estimateTextTokens(
+            `${event.name}\n${JSON.stringify(event.input ?? {})}`,
+          );
+          broadcastContextProgress(true);
           // Match both the bare name (Codex reports MCP server/tool separately)
           // and each provider's public MCP-name form.
           if (isVisualsShowHtmlTool(event.name)) {
@@ -529,6 +567,8 @@ export async function runTurnEventStream(
           }
           break;
         case "tool_result":
+          toolContextTokens += estimateTextTokens(event.content);
+          broadcastContextProgress(true);
           if (isVisualToolResultHandled(event.toolUseId)) break;
           if (!silent) {
             hub.broadcastToolOutput(
@@ -578,7 +618,7 @@ export async function runTurnEventStream(
           }
           break;
         case "result":
-          if (event.usage) recordUsage(userId, topicTitle, event.usage);
+          if (event.usage) recordEventUsage(event.usage);
           {
             const usage: MessageDto["usage"] = event.usage
               ? {
@@ -648,6 +688,7 @@ export async function runTurnEventStream(
 
           break;
         case "error":
+          if (event.usage) recordEventUsage(event.usage);
           logger.warn(
             { topicId, queryId, agentType, model, silent, error: event.content },
             "ai: provider returned error",

package/dist/runtime/src/runtime/turn-runner.ts

@@ -139,6 +139,17 @@ export function withDefaultPlaywright(configuredMcp: string[], isManager: boolea
   return [...enabled];
 }
 
+export function buildTurnReminderQuery(
+  agent: AgentKind,
+  prompt: string,
+  reminders: string[],
+): { prompt: string; ephemeralSystemPrompt?: string } {
+  const reminderPrompt = reminders.join("\n\n");
+  if (!reminderPrompt) return { prompt };
+  if (agent === "maestro") return { prompt, ephemeralSystemPrompt: reminderPrompt };
+  return { prompt: `${prompt}\n\n${reminderPrompt}` };
+}
+
 // dequeueAll() is the merge primitive; this short gate makes the first reply
 // to an idle caller wait long enough for sibling ask replies to join it.
 const askReplyInjectBatcher = new DeferredInjectBatcher({
@@ -1424,8 +1435,7 @@ export function startAiTurn(params: StartAiTurnParams): string | null {
   }
 
   /**
-   * Per-turn `<system-reminder>` blocks, appended to the *user* prompt rather
-   * than the system prompt.
+   * Per-turn `<system-reminder>` blocks kept out of the stable system prompt.
    *
    * These facts flip between turns on the same model — whether the browser MCP
    * came up, whether this turn is an auto-resume. A prompt cache invalidates
@@ -1433,8 +1443,9 @@ export function startAiTurn(params: StartAiTurnParams): string | null {
    * every flip re-reads the entire prompt: measured against the live DeepSeek
    * API, one flip at turn 15 of a 20-turn conversation cost 17,852 uncached
    * tokens (hit=0) versus 1,215 with the reminder on the user turn — 40% more
-   * uncached tokens across the run. On the user turn the divergence lands at
-   * the tail, where the text is new anyway.
+   * uncached tokens across the run. Claude/Codex receive them at the user prompt
+   * tail. Maestro projects them onto its invocation-start user wire message via
+   * `ephemeralSystemPrompt`, fixed across that invocation's tool iterations.
    *
    * Applied after the conversation log is written, so a reminder never becomes
    * part of the recorded user message (it would then persist into synthesized
@@ -1574,15 +1585,15 @@ export function startAiTurn(params: StartAiTurnParams): string | null {
         "<system-reminder>Playwright browser tools are UNAVAILABLE this turn. The `mcp__playwright__*` tools have been removed from this turn's catalog because the long-lived browser MCP could not be prepared. Do not attempt to call browser tools. If browser interaction is required, ask the user to retry shortly or use a non-browser alternative.</system-reminder>",
       );
     }
-    // The system prompt is now byte-identical across turns of a topic, so the
-    // provider's prefix cache survives; per-turn facts ride the prompt tail.
-    const effectivePrompt =
-      turnReminders.length > 0 ? `${agentPrompt}\n\n${turnReminders.join("\n\n")}` : agentPrompt;
+    // Build this after conversation recording: transient runtime facts must be
+    // supplied again by the host on a later external turn, never resumed from
+    // Negotium's canonical conversation state.
+    const reminderQuery = buildTurnReminderQuery(agentKind, agentPrompt, turnReminders);
 
     try {
       yield* runAgent({
         agent: agentKind,
-        prompt: effectivePrompt,
+        ...reminderQuery,
         attachments: promptAttachments,
         cwd: workspaceCwd,
         systemPrompt,