npm - @yeaft/webchat-agent - Versions diffs - 1.0.505 → 1.0.506 - Mend

@yeaft/webchat-agent 1.0.505 → 1.0.506

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (28) hide show

package/conversation.js +4 -2
package/local-runtime/server/handlers/agent-conversation.js +11 -9
package/local-runtime/server/handlers/client-conversation.js +28 -2
package/local-runtime/version.json +1 -1
package/local-runtime/web/app.bundle.js +68 -68
package/local-runtime/web/app.bundle.js.gz +0 -0
package/local-runtime/web/index.html +1 -1
package/package.json +1 -1
package/yeaft/cli.js +3 -0
package/yeaft/conversation/persist.js +15 -9
package/yeaft/conversation/search.js +2 -1
package/yeaft/effort.js +159 -6
package/yeaft/engine.js +94 -28
package/yeaft/history-window.js +60 -5
package/yeaft/llm/adapter.js +3 -2
package/yeaft/llm/anthropic.js +97 -25
package/yeaft/llm/openai-responses.js +71 -7
package/yeaft/llm/provider-state.js +242 -0
package/yeaft/llm/router.js +14 -2
package/yeaft/llm/usage-accounting.js +3 -0
package/yeaft/models.js +4 -1
package/yeaft/snapshot-filter.js +1 -0
package/yeaft/sub-agent/output-log.js +4 -0
package/yeaft/sub-agent/prompt-queue.js +3 -0
package/yeaft/sub-agent/runner.js +13 -2
package/yeaft/tools/agent.js +3 -0
package/yeaft/tools/send-message.js +2 -0
package/yeaft/web-bridge.js +5 -5

package/local-runtime/web/app.bundle.js.gz CHANGED Viewed

Binary file

package/local-runtime/web/index.html CHANGED Viewed

@@ -17,6 +17,6 @@
 </head>
 <body>
   <div id="app"></div>
-  <script type="module" src="app.bundle.js?v=38debc76"></script>
+  <script type="module" src="app.bundle.js?v=10d8663e"></script>
 </body>
 </html>

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "@yeaft/webchat-agent",
-  "version": "1.0.505",
+  "version": "1.0.506",
   "description": "Remote worker agent for Yeaft Web Code Agent — connects the native Yeaft engine, CLI providers, and workbench tools",
   "main": "index.js",
   "type": "module",

package/yeaft/cli.js CHANGED Viewed

@@ -388,6 +388,7 @@ async function runREPL(config, args) {
     content: m.content,
     ...(m.toolCallId && { toolCallId: m.toolCallId }),
     ...(m.toolCalls && { toolCalls: m.toolCalls }),
+    ...(m.providerState && { providerState: m.providerState }),
     ...(Array.isArray(m.thinkingBlocks) && m.thinkingBlocks.length > 0
       ? { thinkingBlocks: m.thinkingBlocks.map(block => ({ ...block })) }
       : {}),
@@ -908,6 +909,7 @@ async function runStreamJson(config, args) {
     content: message.content,
     ...(message.toolCallId && { toolCallId: message.toolCallId }),
     ...(message.toolCalls && { toolCalls: message.toolCalls }),
+    ...(message.providerState && { providerState: message.providerState }),
     ...(Array.isArray(message.thinkingBlocks) && message.thinkingBlocks.length > 0
       ? { thinkingBlocks: message.thinkingBlocks.map(block => ({ ...block })) }
       : {}),
@@ -1263,6 +1265,7 @@ async function runOnce(config, args) {
       content: m.content,
       ...(m.toolCallId && { toolCallId: m.toolCallId }),
       ...(m.toolCalls && { toolCalls: m.toolCalls }),
+      ...(m.providerState && { providerState: m.providerState }),
       ...(Array.isArray(m.thinkingBlocks) && m.thinkingBlocks.length > 0
         ? { thinkingBlocks: m.thinkingBlocks.map(block => ({ ...block })) }
         : {}),

package/yeaft/conversation/persist.js CHANGED Viewed

@@ -351,8 +351,10 @@ export function projectVisibleSessionMessages(messages) {
   }
   const visible = [];
-  for (const row of rows) {
-    if (!row || (row.role !== 'user' && row.role !== 'assistant')) continue;
+  for (const sourceRow of rows) {
+    if (!sourceRow || (sourceRow.role !== 'user' && sourceRow.role !== 'assistant')) continue;
+    // Public history never owns provider-private continuation payloads.
+    const { providerState, thinkingBlocks, ...row } = sourceRow;
     if (!isVisibleConversationRow(row)) continue;
     if (row.role !== 'assistant' || !Array.isArray(row.toolCalls) || row.toolCalls.length === 0) {
       if (row.role === 'assistant' && !row.content && !row.attachments && !row.images
@@ -502,19 +504,18 @@ function serializeMessage(msg) {
   // bytes that don't need to be human-readable. Without this round-trip
   // the next Anthropic request 400s with "content[].thinking in the
   // thinking mode must be passed back to the API".
-  if (msg.thinkingBlocks && msg.thinkingBlocks.length > 0) {
+  if (msg.providerState) fm.push(`providerStateB64: ${Buffer.from(JSON.stringify(msg.providerState)).toString('base64')}`);
+  if (!msg.providerState && msg.thinkingBlocks && msg.thinkingBlocks.length > 0) {
     fm.push(`thinkingBlocks:`);
     for (const tb of msg.thinkingBlocks) {
-      if (!tb || typeof tb.signature !== 'string' || !tb.signature) continue;
+      if (!tb) continue;
       if (tb.redacted) {
         if (typeof tb.data !== 'string') continue;
         const dataB64 = Buffer.from(tb.data, 'utf8').toString('base64');
-        const signatureB64 = Buffer.from(tb.signature, 'utf8').toString('base64');
         fm.push(`  - redacted: true`);
         fm.push(`    dataB64: ${dataB64}`);
-        fm.push(`    signatureB64: ${signatureB64}`);
       } else {
-        if (typeof tb.thinking !== 'string') continue;
+        if (typeof tb.thinking !== 'string' || typeof tb.signature !== 'string' || !tb.signature) continue;
         const thinkingB64 = Buffer.from(tb.thinking, 'utf8').toString('base64');
         const signatureB64 = Buffer.from(tb.signature, 'utf8').toString('base64');
         fm.push(`  - thinkingB64: ${thinkingB64}`);
@@ -646,7 +647,11 @@ export function parseMessage(raw) {
   }
   // task-327d: parse thinkingBlocks (mirror of toolCalls parser above)
-  if (frontmatter.includes('thinkingBlocks:')) {
+  const stateMatch = frontmatter.match(/^providerStateB64: (.+)$/m);
+  if (stateMatch) {
+    try { msg.providerState = JSON.parse(Buffer.from(stateMatch[1], 'base64').toString('utf8')); } catch { /* legacy invalid row */ }
+  }
+  if (!msg.providerState && frontmatter.includes('thinkingBlocks:')) {
     const thinkingBlocks = [];
     const tbMatch = frontmatter.match(/thinkingBlocks:\n((?:\s+-\s+[\s\S]*?)(?=\n\w|$))/);
     if (tbMatch) {
@@ -672,7 +677,7 @@ export function parseMessage(raw) {
         }
         // Both fields required — an unsigned block would 400 on replay.
         if (tb.redacted) {
-          if (typeof tb.data === 'string' && typeof tb.signature === 'string' && tb.signature) {
+          if (typeof tb.data === 'string') {
             thinkingBlocks.push(tb);
           }
         } else if (typeof tb.thinking === 'string' && typeof tb.signature === 'string' && tb.signature) {
@@ -1621,6 +1626,7 @@ export class ConversationStore {
           const copy = { ...m };
           delete copy.toolCalls;
           delete copy.thinkingBlocks;
+          delete copy.providerState;
           out.push(copy);
         }
         continue;

package/yeaft/conversation/search.js CHANGED Viewed

@@ -54,8 +54,9 @@ function recordMessageScan(telemetry) {
 }
 function withSource(msg, source) {
+  const { providerState, thinkingBlocks, ...publicMessage } = msg;
   return {
-    ...msg,
+    ...publicMessage,
     content: searchableContent(msg),
     sessionId: msg.sessionId || source.sessionId || null,
     historySource: source.kind,

package/yeaft/effort.js CHANGED Viewed

@@ -14,14 +14,15 @@
  *
  * Red lines:
  *   • Never error on unknown scenario — default to 'max'.
- *   • Feature flag YEAFT_THINKING_V1 is enforced at the adapter/router
- *     layer; this module just computes the intended value. If the flag
- *     is off, adapters drop it anyway.
- *   • Unsupported models silently drop effort at the router — this
- *     module does NOT consult the capability matrix.
+ *   • The ordinary picker preserves existing scenario defaults. Child effort
+ *     is separately constrained by the capability-aware final payload helpers.
+ *   • Child ceilings cannot be disabled by YEAFT_THINKING_V1, user overrides,
+ *     routing, nesting, or extraBody. Unsupported models omit effort fields.
  */
-import { normalizeEffort } from './models.js';
+import {
+  normalizeEffort, getThinkingCapability, getModelEffortOptions, thinkingBudgetForEffort,
+} from './models.js';
 /**
  * Number of tool-loop turns past which a query is considered "complex"
@@ -116,3 +117,155 @@ export function parseEffortPrefix(prompt) {
   const cleanedPrompt = prompt.slice(m[0].length);
   return { effort, cleanedPrompt };
 }
+// Ordinal levels, not lexical sorting or cross-model token-budget equivalence.
+export const EFFORT_LEVELS = Object.freeze(['minimal', 'low', 'medium', 'high', 'xhigh', 'max', 'ultra']);
+const effortRank = value => EFFORT_LEVELS.indexOf(normalizeEffort(value));
+const atMost = (value, ceiling) => effortRank(value) >= 0 && effortRank(value) <= effortRank(ceiling);
+/** Copy only durable decision fields; never retain a mutable request/config object. */
+export function snapshotEffortDecision(decision = null) {
+  return Object.freeze({
+    requested: normalizeEffort(decision?.requested),
+    effective: normalizeEffort(decision?.effective),
+    source: typeof decision?.source === 'string' ? decision.source : 'unknown',
+    model: typeof decision?.model === 'string' ? decision.model : null,
+    wireMode: typeof decision?.wireMode === 'string' ? decision.wireMode : 'omitted',
+    thinkingEnabled: decision?.thinkingEnabled === true,
+    cap: normalizeEffort(decision?.cap),
+    ...(Number.isFinite(decision?.budgetTokens) ? { budgetTokens: decision.budgetTokens } : {}),
+  });
+}
+/** Capture the decision belonging to the provider response that generated a tool call. */
+export function captureParentEffortDecision(ctx = {}) {
+  return snapshotEffortDecision(ctx.effortDecision ?? ctx.parentEngineDeps?.effortDecision);
+}
+function effortError(model, target, detail = '') {
+  const error = new Error(`Sub-agent model "${model}" cannot express effort <= ${target}${detail ? ` (${detail})` : ''}. Select a compatible child model.`);
+  error.code = 'SUB_AGENT_EFFORT_UNREPRESENTABLE';
+  return error;
+}
+function capabilityContext(protocol, effortContext) {
+  return { ...effortContext, protocol: protocol || effortContext?.protocol };
+}
+/**
+ * Resolve the non-disableable child ceiling using the actual model's capabilities.
+ * Unknown/omitted parent wire defaults are conservative medium, never chat/max.
+ */
+export function resolveSubAgentEffort({ parentDecision = null, model, effortContext = {}, protocol } = {}) {
+  const parent = snapshotEffortDecision(parentDecision);
+  // An unsupported intermediate model has no wire effort, but must not erase
+  // an inherited lower ceiling when it delegates again.
+  let parentTarget = parent.effective || 'medium';
+  if (parent.cap && atMost(parent.cap, parentTarget)) parentTarget = parent.cap;
+  const target = atMost(parentTarget, 'high') ? parentTarget : 'high';
+  const context = capabilityContext(protocol, effortContext);
+  const capability = getThinkingCapability(model, context);
+  const base = {
+    requested: parentTarget, source: parent.effective ? 'inherited' : 'fallback',
+    model, cap: target, thinkingEnabled: false,
+  };
+  if (!capability.supportsThinking || capability.thinkingProtocol === 'none') {
+    return snapshotEffortDecision({ ...base, effective: null, wireMode: 'unsupported' });
+  }
+  const supported = getModelEffortOptions(model, context).filter(value => atMost(value, target));
+  const effective = EFFORT_LEVELS.filter(value => supported.includes(value)).at(-1);
+  if (!effective) throw effortError(model, target);
+  const wireMode = protocol === 'openai-responses' || capability.thinkingProtocol === 'openai-reasoning'
+    ? 'reasoning-effort'
+    : capability.thinkingProtocol === 'anthropic-adaptive' ? 'adaptive' : 'manual';
+  return snapshotEffortDecision({ ...base, effective, wireMode, thinkingEnabled: true });
+}
+function manualEffortForBudget(model, budget) {
+  if (!Number.isFinite(budget) || budget <= 0) return null;
+  // Round upward: a nonstandard budget must never masquerade as a lower tier.
+  return ['low', 'medium', 'high', 'max'].find(level => budget <= thinkingBudgetForEffort(model, level)) || 'ultra';
+}
+/**
+ * Read the FINAL wire payload. requested is observability only, not effective.
+ * Call after all extraBody/feature-flag/mapping changes, before serialization.
+ */
+export function captureEffortDecision({ body = {}, model, protocol, effortContext = {}, requested = null, source = 'scenario' } = {}) {
+  const context = capabilityContext(protocol, effortContext);
+  const capability = getThinkingCapability(model, context);
+  const base = { requested, source, model, cap: null, thinkingEnabled: false };
+  if (!capability.supportsThinking || capability.thinkingProtocol === 'none') {
+    return snapshotEffortDecision({ ...base, effective: null, wireMode: 'unsupported' });
+  }
+  if (protocol === 'openai-responses') {
+    const effective = normalizeEffort(body.reasoning?.effort);
+    if (effective) return snapshotEffortDecision({ ...base, effective, wireMode: 'reasoning-effort', thinkingEnabled: true });
+  } else if (body.thinking?.type === 'enabled') {
+    const budgetTokens = body.thinking.budget_tokens;
+    return snapshotEffortDecision({ ...base, effective: manualEffortForBudget(model, budgetTokens), wireMode: 'manual', thinkingEnabled: true, budgetTokens });
+  } else if (body.thinking?.type === 'adaptive') {
+    const effective = normalizeEffort(body.output_config?.effort);
+    if (effective) return snapshotEffortDecision({ ...base, effective, wireMode: 'adaptive', thinkingEnabled: true });
+  }
+  const modelDefault = body.thinking?.type === 'disabled' ? null : normalizeEffort(capability.defaultEffort);
+  return snapshotEffortDecision({ ...base, effective: modelDefault, source: modelDefault ? 'model-default' : source, wireMode: 'omitted' });
+}
+function removeEffortField(body, key) {
+  if (!body[key] || typeof body[key] !== 'object' || Array.isArray(body[key])) {
+    delete body[key];
+    return;
+  }
+  const { effort: _effort, ...rest } = body[key];
+  if (Object.keys(rest).length) body[key] = rest;
+  else delete body[key];
+}
+/**
+ * Mutate the FINAL provider body in place and return its immutable child decision.
+ * The router must preserve effortConstraint even when YEAFT_THINKING_V1 is off.
+ * All adapter stream/call paths invoke this AFTER extraBody, BEFORE fetch, and
+ * must not subsequently rewrite reasoning/thinking/output_config/max_tokens.
+ * @param {object} body Final body owned by the adapter (never caller config).
+ * @param {{ model: string, protocol: string, effortContext?: object,
+ *   effortConstraint: { parentDecision: object|null } }} options
+ */
+export function enforceSubAgentEffortPayload(body, { model, protocol, effortContext = {}, effortConstraint } = {}) {
+  if (!effortConstraint) return captureEffortDecision({ body, model, protocol, effortContext });
+  const decision = resolveSubAgentEffort({ parentDecision: effortConstraint.parentDecision, model, protocol, effortContext });
+  if (decision.wireMode === 'unsupported') {
+    removeEffortField(body, 'reasoning');
+    removeEffortField(body, 'output_config');
+    delete body.thinking;
+    return decision;
+  }
+  const context = capabilityContext(protocol, effortContext);
+  const options = getModelEffortOptions(model, context);
+  const wireEffort = protocol === 'openai-responses' ? body.reasoning?.effort : body.output_config?.effort;
+  const effective = options.includes(wireEffort) && atMost(wireEffort, decision.effective)
+    ? wireEffort : decision.effective;
+  if (protocol === 'openai-responses') {
+    body.reasoning = { ...(body.reasoning && typeof body.reasoning === 'object' && !Array.isArray(body.reasoning) ? body.reasoning : {}), effort: effective };
+    delete body.thinking;
+    removeEffortField(body, 'output_config');
+  } else if (decision.wireMode === 'adaptive') {
+    body.thinking = { type: 'adaptive' };
+    body.output_config = { ...(body.output_config && typeof body.output_config === 'object' && !Array.isArray(body.output_config) ? body.output_config : {}), effort: effective };
+    removeEffortField(body, 'reasoning');
+  } else {
+    const capability = getThinkingCapability(model, context);
+    let budget = thinkingBudgetForEffort(model, effective);
+    if (!budget) throw effortError(model, decision.cap, 'no manual thinking budget');
+    if (Number.isFinite(capability.maxBudgetTokens)) budget = Math.min(budget, capability.maxBudgetTokens);
+    const supplied = body.thinking?.type === 'enabled' ? body.thinking.budget_tokens : null;
+    if (Number.isInteger(supplied) && supplied >= 1024) budget = Math.min(budget, supplied);
+    if (Number.isFinite(body.max_tokens)) budget = Math.min(budget, Math.floor(body.max_tokens) - 1);
+    if (budget < 1024) throw effortError(model, decision.cap, 'max_tokens must allow at least 1024 thinking tokens');
+    body.thinking = { type: 'enabled', budget_tokens: budget };
+    removeEffortField(body, 'output_config');
+    removeEffortField(body, 'reasoning');
+    return snapshotEffortDecision({ ...decision, effective: manualEffortForBudget(model, budget), budgetTokens: budget });
+  }
+  return snapshotEffortDecision({ ...decision, effective });
+}

package/yeaft/engine.js CHANGED Viewed

@@ -44,7 +44,8 @@ import { perfNowMs, recordAgentPerfTrace } from './perf-trace.js';
 // Default thread marker for legacy / non-group flows. Group VP runtime may
 // pass a real threadId per (sessionId, vpId, threadId) engine instance.
 const MAIN_THREAD_ID = 'main';
-import { pickEffort, parseEffortPrefix } from './effort.js';
+import { pickEffort, parseEffortPrefix, snapshotEffortDecision } from './effort.js';
+import { bindProviderState } from './llm/provider-state.js';
 import { DEFAULT_CONTEXT_WINDOW, normalizeEffort, resolveContextWindow, resolveModel } from './models.js';
 import { lookupModelLimitSync } from './llm/models-dev.js';
 import { attachRouterPlan, extractPriorPlan, stripMetaForWire } from './router/continuity.js';
@@ -92,7 +93,8 @@ const MAX_CONTINUE_TURNS = 3;
  * network, or subprocess reads. Only tools whose metadata explicitly declares
  * both read-only and concurrency-safe execution enter this lane.
  */
-const MAX_CONCURRENT_READ_ONLY_TOOLS = 4;
+// Safe shared tools run together within the finite provider batch. Unsafe tools
+// form exclusive barriers; resource-specific limits belong to the owning tool.
 /** Maximum silence while a visible turn waits for a result-producing task. */
 const DEFAULT_ASYNC_TASK_WAIT_TIMEOUT_MS = 120_000;
@@ -1392,6 +1394,8 @@ export class Engine {
   #buildToolContext(signal, vpCtx) {
     return {
       signal,
+      effortDecision: snapshotEffortDecision(vpCtx?.effortDecision),
+      requestIdentity: vpCtx?.requestIdentity,
       yeaftDir: this.#yeaftDir,
       managedCliReady: this.#managedCliReady,
       runtimePlatform: getRuntimePlatformInfo(),
@@ -1591,6 +1595,7 @@ export class Engine {
     if (message.toolCallId) record.toolCallId = message.toolCallId;
     if (Array.isArray(message.toolCalls) && message.toolCalls.length > 0) record.toolCalls = message.toolCalls;
     if (Array.isArray(message.thinkingBlocks) && message.thinkingBlocks.length > 0) record.thinkingBlocks = message.thinkingBlocks;
+    if (message.providerState) record.providerState = message.providerState;
     if (message.isError) record.isError = true;
     if (message.imageAssetAnchor) record.imageAssetAnchor = true;
     if (message._reflection) record._reflection = true;
@@ -1625,7 +1630,7 @@ export class Engine {
       : message.content != null;
     const hasToolCalls = Array.isArray(message.toolCalls) && message.toolCalls.length > 0;
     const hasThinking = Array.isArray(message.thinkingBlocks) && message.thinkingBlocks.length > 0;
-    if (!hasContent && !hasToolCalls && !hasThinking && message.role !== 'tool') return null;
+    if (!hasContent && !hasToolCalls && !hasThinking && !message.providerState && message.role !== 'tool') return null;
     return this.#conversationStore.append(this.#conversationRecord(message, context));
   }
@@ -1877,7 +1882,7 @@ export class Engine {
     }
   }
-  async *#queryLifecycle({ prompt, promptParts = null, messages = [], signal, userEffort = null, scenario = 'chat', vpPersona, router, senderVpId, inboundEnvelope, taskId, taskMembers, sessionId, sessionMembers, projectSessionIds = null, projectInstruction = '', projectLabel = '', vpPlan, sessionAnnouncement, workCenterInstructions, workDir, userAlreadyPersisted = false, currentUserMessage = null, causalRootId = null, getCurrentTodos = null, setCurrentTodos = null, askUser = null, threadId = MAIN_THREAD_ID, vpTurnId = null, drainPendingUserMessages = null, prepareProviderRequest = null, startProviderRequest = null, finishProviderRequest = null, failProviderRequest = null, closePendingUserInput = null, collabToolPolicy = null } = {}) {
+  async *#queryLifecycle({ prompt, promptParts = null, messages = [], signal, userEffort = null, scenario = 'chat', isSubAgent = false, parentEffortDecision = null, vpPersona, router, senderVpId, inboundEnvelope, taskId, taskMembers, sessionId, sessionMembers, projectSessionIds = null, projectInstruction = '', projectLabel = '', vpPlan, sessionAnnouncement, workCenterInstructions, workDir, userAlreadyPersisted = false, currentUserMessage = null, causalRootId = null, getCurrentTodos = null, setCurrentTodos = null, askUser = null, threadId = MAIN_THREAD_ID, vpTurnId = null, drainPendingUserMessages = null, prepareProviderRequest = null, startProviderRequest = null, finishProviderRequest = null, failProviderRequest = null, closePendingUserInput = null, collabToolPolicy = null } = {}) {
     if (!prompt || typeof prompt !== 'string' || !prompt.trim()) {
       const error = new Error('prompt is required and must be a non-empty string');
       yield {
@@ -1969,7 +1974,7 @@ export class Engine {
     try {
       this.#currentThreadId = threadId || MAIN_THREAD_ID;
       this.#currentCausalRootId = effectiveCausalRootId;
-      yield* this.#runQuery({ prompt: effectivePrompt, promptParts: effectivePromptParts, messages, signal: runSignal, userEffort: explicitUserEffort, scenario, vpPersona, router, senderVpId, inboundEnvelope, taskId, taskMembers, sessionId, sessionMembers, projectSessionIds, projectInstruction, projectLabel, vpPlan, sessionAnnouncement, workCenterInstructions, workDir, userAlreadyPersisted, currentUserMessage, causalRootId: effectiveCausalRootId, getCurrentTodos, setCurrentTodos, askUser, threadId: this.#currentThreadId, vpTurnId, drainPendingUserMessages, prepareProviderRequest, startProviderRequest, finishProviderRequest, failProviderRequest, closePendingUserInput, collabToolPolicy: effectiveCollabToolPolicy, explicitSkillName: parsedSkill.skillName, retryLifecycle });
+      yield* this.#runQuery({ prompt: effectivePrompt, promptParts: effectivePromptParts, messages, signal: runSignal, userEffort: explicitUserEffort, scenario, isSubAgent, parentEffortDecision, vpPersona, router, senderVpId, inboundEnvelope, taskId, taskMembers, sessionId, sessionMembers, projectSessionIds, projectInstruction, projectLabel, vpPlan, sessionAnnouncement, workCenterInstructions, workDir, userAlreadyPersisted, currentUserMessage, causalRootId: effectiveCausalRootId, getCurrentTodos, setCurrentTodos, askUser, threadId: this.#currentThreadId, vpTurnId, drainPendingUserMessages, prepareProviderRequest, startProviderRequest, finishProviderRequest, failProviderRequest, closePendingUserInput, collabToolPolicy: effectiveCollabToolPolicy, explicitSkillName: parsedSkill.skillName, retryLifecycle });
     } finally {
       // Closing the async generator at a visible retry boundary means the
       // continuation never reached a provider. Keep it out of history and
@@ -2024,7 +2029,7 @@ export class Engine {
    * in a try/finally without indenting the whole loop.
    * @private
    */
-  async *#runQuery({ prompt, promptParts = null, messages, signal, userEffort = null, scenario = 'chat', vpPersona, router, senderVpId, inboundEnvelope, taskId, taskMembers, sessionId, sessionMembers, projectSessionIds = null, projectInstruction = '', projectLabel = '', vpPlan, sessionAnnouncement, workCenterInstructions, workDir, userAlreadyPersisted = false, currentUserMessage = null, causalRootId = null, getCurrentTodos = null, setCurrentTodos = null, askUser = null, threadId = MAIN_THREAD_ID, vpTurnId = null, drainPendingUserMessages = null, prepareProviderRequest = null, startProviderRequest = null, finishProviderRequest = null, failProviderRequest = null, closePendingUserInput = null, collabToolPolicy = null, explicitSkillName = null, retryLifecycle }) {
+  async *#runQuery({ prompt, promptParts = null, messages, signal, userEffort = null, scenario = 'chat', isSubAgent = false, parentEffortDecision = null, vpPersona, router, senderVpId, inboundEnvelope, taskId, taskMembers, sessionId, sessionMembers, projectSessionIds = null, projectInstruction = '', projectLabel = '', vpPlan, sessionAnnouncement, workCenterInstructions, workDir, userAlreadyPersisted = false, currentUserMessage = null, causalRootId = null, getCurrentTodos = null, setCurrentTodos = null, askUser = null, threadId = MAIN_THREAD_ID, vpTurnId = null, drainPendingUserMessages = null, prepareProviderRequest = null, startProviderRequest = null, finishProviderRequest = null, failProviderRequest = null, closePendingUserInput = null, collabToolPolicy = null, explicitSkillName = null, retryLifecycle }) {
     const effectiveCollabToolPolicy = collabToolPolicy === COLLAB_TOOL_POLICY.SINGLE_VP || collabToolPolicy === COLLAB_TOOL_POLICY.MULTI_VP
       ? collabToolPolicy
@@ -2049,6 +2054,15 @@ export class Engine {
     // standalone/CLI callers pass it per query.
     this.#sessionId = runtimeSessionId || null;
     this.#currentThreadId = runtimeThreadId;
+    const requestIdentity = Object.freeze({
+      instanceScope: this.#yeaftDir || '',
+      ownerScope: this.#yeaftDir ? 'instance-local-owner' : '',
+      sessionId: runtimeSessionId || this.#chatId || '',
+      vpId: this.#vpId || senderVpId || vpPersona?.vpId || 'default',
+      threadId: runtimeThreadId,
+    });
+    const effortConstraint = isSubAgent || scenario === 'sub_agent' || vpPersona?.subAgent
+      ? Object.freeze({ parentDecision: snapshotEffortDecision(parentEffortDecision) }) : null;
     const queryStartedAt = Date.now();
     const userQuestionPreview = String(prompt || '').slice(0, 200);
     const queryVpId = vpPersona && typeof vpPersona === 'object'
@@ -2276,7 +2290,7 @@ export class Engine {
       envelope: inboundEnvelope || null,
     };
-    const projectDocSource = this.#getProjectDocBlock(workDir);
+    let projectDocSource = this.#getProjectDocBlock(workDir);
     let projectDocLoadedPathHints = [];
     let projectDocContext = selectProjectDocContext(projectDocSource, {
       prompt,
@@ -2675,7 +2689,9 @@ export class Engine {
         });
       };
       const toolCalls = [];
-      const thinkingBlocks = []; // task-327d: collected from adapter for round-trip
+      const thinkingBlocks = []; // Legacy adapter compatibility only.
+      let providerState = null;
+      let requestEffortDecision = snapshotEffortDecision();
       let stopReason = 'end_turn';
       const totalUsage = { inputTokens: 0, outputTokens: 0, cacheReadTokens: 0, cacheWriteTokens: 0, cacheInputDeltaTokens: 0 };
       // Raw provider exchange is diagnostic source data, not model context or
@@ -2796,7 +2812,7 @@ export class Engine {
         // routerPlan, the VP's role default, and the global config all
         // outrank the scenario picker for `'high'|'max'`. UI/userEffort
         // is already honoured by pickEffort (highest precedence).
-        if (vpPersona && vpPersona.vpId) {
+        if (!requestUserEffort && vpPersona && vpPersona.vpId) {
           const priorPlan = extractPriorPlan(conversationMessages, vpPersona.vpId);
           const thinkingCfg = (this.#config && this.#config.thinking) || {};
           // PR-I: live routerPlan.thinking — when the dispatcher passes
@@ -2969,6 +2985,10 @@ export class Engine {
           tools: toolDefs.length > 0 ? toolDefs : undefined,
           maxTokens: requestConfig.maxOutputTokens || 16384,
           effort: resolvedEffort,
+          effortConstraint,
+          requestIdentity,
+          onEffortDecision: decision => { requestEffortDecision = snapshotEffortDecision(decision); },
+          onProviderDiagnostics: info => traceRequest('llm.capabilities', { detail: info }),
           effortSource: requestUserEffort ? 'user' : 'auto',
           signal,
           onRawExchange: captureRawExchange,
@@ -3029,6 +3049,9 @@ export class Engine {
               responseText += event.text;
               yield event;
               break;
+            case 'provider_state':
+              providerState = event.providerState;
+              break;
             case 'thinking_delta':
               yield event;
               break;
@@ -3066,6 +3089,9 @@ export class Engine {
               const cacheInputDeltaTokens = event.cacheTokensAreIncludedInInput ? 0 : cacheReadTokens + cacheWriteTokens;
               totalUsage.inputTokens += inputTokens;
               totalUsage.outputTokens += outputTokens;
+              if (Number.isFinite(event.reasoningTokens) && event.reasoningTokens >= 0) {
+                totalUsage.reasoningTokens = (totalUsage.reasoningTokens || 0) + event.reasoningTokens;
+              }
               totalUsage.cacheReadTokens += cacheReadTokens;
               totalUsage.cacheWriteTokens += cacheWriteTokens;
               totalUsage.cacheInputDeltaTokens += cacheInputDeltaTokens;
@@ -3162,6 +3188,7 @@ export class Engine {
             usage: {
               inputTokens: totalUsage.inputTokens || 0,
               outputTokens: totalUsage.outputTokens || 0,
+              ...(totalUsage.reasoningTokens !== undefined ? { reasoningTokens: totalUsage.reasoningTokens } : {}),
               cacheReadTokens: totalUsage.cacheReadTokens || 0,
               cacheWriteTokens: totalUsage.cacheWriteTokens || 0,
               totalInputTokens: (totalUsage.inputTokens || 0) + (totalUsage.cacheInputDeltaTokens || 0),
@@ -3408,6 +3435,7 @@ export class Engine {
           usage: {
             inputTokens: totalUsage.inputTokens || 0,
             outputTokens: totalUsage.outputTokens || 0,
+            ...(totalUsage.reasoningTokens !== undefined ? { reasoningTokens: totalUsage.reasoningTokens } : {}),
             cacheReadTokens: totalUsage.cacheReadTokens || 0,
             cacheWriteTokens: totalUsage.cacheWriteTokens || 0,
             totalInputTokens: (totalUsage.inputTokens || 0) + (totalUsage.cacheInputDeltaTokens || 0),
@@ -3434,6 +3462,7 @@ export class Engine {
           usage: {
             inputTokens: totalUsage.inputTokens || 0,
             outputTokens: errLoopOutputTokens,
+            ...(totalUsage.reasoningTokens !== undefined ? { reasoningTokens: totalUsage.reasoningTokens } : {}),
             cacheReadTokens: totalUsage.cacheReadTokens || 0,
             cacheWriteTokens: totalUsage.cacheWriteTokens || 0,
             totalInputTokens: errLoopInputTokens,
@@ -3511,6 +3540,7 @@ export class Engine {
         usage: {
           inputTokens: totalUsage.inputTokens || 0,
           outputTokens: totalUsage.outputTokens || 0,
+          ...(totalUsage.reasoningTokens !== undefined ? { reasoningTokens: totalUsage.reasoningTokens } : {}),
           cacheReadTokens: totalUsage.cacheReadTokens || 0,
           cacheWriteTokens: totalUsage.cacheWriteTokens || 0,
           totalInputTokens: turnInputTokens,
@@ -3533,13 +3563,10 @@ export class Engine {
           input: tc.input,
         }));
       }
-      if (thinkingBlocks.length > 0) {
-        assistantMsg.thinkingBlocks = thinkingBlocks.map(tb => (
-          tb.redacted
-            ? { redacted: true, data: tb.data, signature: tb.signature }
-            : { thinking: tb.thinking, signature: tb.signature }
-        ));
-      }
+      const boundProviderState = bindProviderState(providerState, assistantMsg);
+      if (boundProviderState) assistantMsg.providerState = boundProviderState;
+      // New private reasoning is persisted only with verified provider ownership;
+      // never downgrade it to the origin-free legacy thinkingBlocks format.
       if (vpPersona && vpPersona.vpId) {
         const planForThisVp = (vpPlan && typeof vpPlan === 'object'
           && typeof vpPlan.vpId === 'string' && vpPlan.vpId === vpPersona.vpId)
@@ -3609,6 +3636,7 @@ export class Engine {
         usage: {
           inputTokens: totalUsage.inputTokens || 0,
           outputTokens: loopOutputTokens,
+          ...(totalUsage.reasoningTokens !== undefined ? { reasoningTokens: totalUsage.reasoningTokens } : {}),
           cacheReadTokens: totalUsage.cacheReadTokens || 0,
           cacheWriteTokens: totalUsage.cacheWriteTokens || 0,
           totalInputTokens: loopInputTokens,
@@ -3914,6 +3942,8 @@ export class Engine {
       // We re-create the closure each iteration because endTurnRequested
       // is a per-query local (reset implicitly at the top of #runQuery).
       const toolCtx = this.#buildToolContext(signal, {
+        effortDecision: snapshotEffortDecision(requestEffortDecision),
+        requestIdentity,
         router,
         senderVpId,
         sessionId: runtimeSessionId,
@@ -4094,9 +4124,8 @@ export class Engine {
             && duplicatePolicyForCall(tc) !== 'suppress'
             && !mayMutateWorkspaceAfterReturn(this, tc.name, tc.input)) {
           const parallelCalls = [];
-          const segmentCacheKeys = new Set();
           for (let candidateIndex = toolCallIndex;
-            candidateIndex < toolCalls.length && parallelCalls.length < MAX_CONCURRENT_READ_ONLY_TOOLS;
+            candidateIndex < toolCalls.length;
             candidateIndex += 1) {
             const candidate = toolCalls[candidateIndex];
             if (!toolAllowedForRequest(candidate)
@@ -4105,21 +4134,27 @@ export class Engine {
                 || mayMutateWorkspaceAfterReturn(this, candidate.name, candidate.input)) break;
             const candidateKey = `${candidate.name}\u001f${argsHashOf(candidate.input)}`;
             const candidateCacheable = isCacheableTool(this, candidate.name, candidate.input);
-            // Keep identical cacheable reads on the serial commit path so the
-            // second call reuses the first result instead of duplicating I/O.
-            if (candidateCacheable
-                && (readOnlyToolResults.has(candidateKey) || segmentCacheKeys.has(candidateKey))) break;
+            // Already committed reads reuse their result on the commit path.
+            if (!readOnlyToolReuseDisabled && candidateCacheable
+                && readOnlyToolResults.has(candidateKey)) break;
             parallelCalls.push(candidate);
-            if (candidateCacheable) segmentCacheKeys.add(candidateKey);
           }
           if (parallelCalls.length > 1) {
             const executions = [];
+            const inFlightReads = new Map();
             for (const call of parallelCalls) {
-              if (signal?.aborted) {
-                abortedDuringTools = true;
+              if (signal?.aborted || toolBatchBarrier) {
+                if (signal?.aborted) abortedDuringTools = true;
                 break;
               }
+              const cacheKey = `${call.name}\u001f${argsHashOf(call.input)}`;
+              const cacheable = !readOnlyToolReuseDisabled && isCacheableTool(this, call.name, call.input);
+              const sharedExecution = cacheable ? inFlightReads.get(cacheKey) : null;
+              if (sharedExecution) {
+                executions.push(sharedExecution.then(result => ({ ...result, call, shared: true })));
+                continue;
+              }
               announcedParallelToolCalls.add(call.id);
               yield {
                 type: 'tool_start',
@@ -4132,7 +4167,8 @@ export class Engine {
                 abortedDuringTools = true;
                 break;
               }
-              executions.push((async () => {
+              if (toolBatchBarrier) break;
+              const execution = (async () => {
                 const startedAt = Date.now();
                 const callContext = toolContextForCall(call);
                 const toolErrorOutput = this.#toolRegistry
@@ -4146,7 +4182,9 @@ export class Engine {
                 } catch (error) {
                   return { call, startedAt, durationMs: Date.now() - startedAt, error, toolErrorOutput };
                 }
-              })());
+              })();
+              executions.push(execution);
+              if (cacheable) inFlightReads.set(cacheKey, execution);
             }
             const completed = await Promise.all(executions);
             for (const execution of completed) {
@@ -4203,7 +4241,12 @@ export class Engine {
         const missingProjectDocScopes = hasTool && !readOnlyTool
           ? projectDocWriteScopesNeedingReload(projectDocContext, toolProjectDocPathHints)
           : new Set();
-        const needsProjectDocReload = missingProjectDocScopes.size > 0;
+        // A changed rule source was not present in the request that generated
+        // this write, even when its scope label is unchanged. Never replay it.
+        const freshProjectDocSource = hasTool && !readOnlyTool
+          ? this.#getProjectDocBlock(workDir) : projectDocSource;
+        const projectDocSourceChanged = freshProjectDocSource !== projectDocSource;
+        const needsProjectDocReload = missingProjectDocScopes.size > 0 || projectDocSourceChanged;
         if (abortSkipped) {
           output = `Skipped ${tc.name} because the turn was aborted before this tool started.`;
@@ -4246,6 +4289,7 @@ export class Engine {
           isError = true;
           yield { type: 'tool_end', id: tc.id, name: tc.name, output, isError: true, threadId: this.currentThreadId };
         } else if (needsProjectDocReload) {
+          projectDocSource = freshProjectDocSource;
           projectDocLoadedPathHints = [...new Set([
             ...projectDocLoadedPathHints,
             ...toolProjectDocPathHints,
@@ -4392,6 +4436,15 @@ export class Engine {
         currentToolCallForAsyncTask = null;
+        // Record concrete inputs, never tool/file prose. Apply only after the
+        // whole batch: a read cannot authorize a same-response write whose
+        // model has not yet received the newly selected rules.
+        if (hasTool && readOnlyTool && !skipped && !isError) {
+          projectDocLoadedPathHints = [...new Set([
+            ...projectDocLoadedPathHints, ...toolProjectDocPathHints,
+          ])].slice(-128);
+        }
         if (!skipped && !duplicateCallSuppressed && !isError && !reusedReadOnlyResult
             && duplicateCallPolicy !== 'allow') {
           const nextDuplicateCount = successfulDuplicateCount + 1;
@@ -4519,6 +4572,19 @@ export class Engine {
         if (fatalToolError) throw fatalToolError;
       }
+      // Preload rules for observed read paths before the next provider input.
+      // No tool from the just-completed response can benefit retroactively.
+      projectDocSource = this.#getProjectDocBlock(workDir);
+      const nextProjectDocContext = selectProjectDocContext(projectDocSource, {
+        prompt, messages, pathHints: projectDocLoadedPathHints,
+        forcedScopes: [...projectDocContext.selectedScopes],
+        language: this.#config.language || 'en',
+      });
+      if (nextProjectDocContext.text !== projectDocContext.text) {
+        projectDocContext = nextProjectDocContext;
+        systemPrompt = buildCurrentSystemPrompt();
+      }
       // PR-L: flush any duplicate-call reminders queued during the batch.
       // Pushed AFTER the for-loop so the tool_use → tool_result pairing
       // is intact; the next adapter.stream() will see the reminder as a