@yeaft/webchat-agent 1.0.512 → 1.0.514

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yeaft/webchat-agent",
-  "version": "1.0.512",
+  "version": "1.0.514",
   "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/conversation/persist.js

@@ -411,6 +411,8 @@ function serializeMessage(msg) {
 
   if (msg.mode) fm.push(`mode: ${msg.mode}`);
   if (msg.model) fm.push(`model: ${msg.model}`);
+  if (msg.effort) fm.push(`effort: ${msg.effort}`);
+  if (Number.isInteger(msg.llmCallCount) && msg.llmCallCount > 0) fm.push(`llmCallCount: ${msg.llmCallCount}`);
   if (msg.turnNumber != null) fm.push(`turnNumber: ${msg.turnNumber}`);
   if (msg.toolCallId) fm.push(`toolCallId: ${msg.toolCallId}`);
   if (msg.eventType) fm.push(`eventType: ${msg.eventType}`);
@@ -560,6 +562,8 @@ export function parseMessage(raw) {
       case 'time': msg.time = value; break;
       case 'mode': msg.mode = value; break;
       case 'model': msg.model = value; break;
+      case 'effort': msg.effort = value; break;
+      case 'llmCallCount': msg.llmCallCount = parseInt(value, 10); break;
       case 'turnNumber': msg.turnNumber = parseInt(value, 10); break;
       case 'toolCallId': msg.toolCallId = value; break;
       case 'eventType': msg.eventType = value; break;
@@ -823,6 +827,20 @@ class SegmentStore {
       : out.sort(compareMessagesBySeq);
   }
 
+  /**
+   * Read physical rows without applying reflection tombstones. Session cloning
+   * needs the complete durable transcript, including rows hidden by folding.
+   */
+  readAllRaw({ includeCold = false } = {}) {
+    if (!this.hasData()) return [];
+    const idx = this.loadIndex();
+    return (idx.segments || [])
+      .slice()
+      .sort((a, b) => (a.firstSeq || 0) - (b.firstSeq || 0))
+      .flatMap(segment => this.#readSegment(segment.file, { includeCold }))
+      .sort(compareMessagesBySeq);
+  }
+
   *scan({ beforeSeq = Infinity, afterSeq = -Infinity, desc = false, includeCold = false, scanStats = null } = {}) {
     if (!this.hasData()) return;
     const idx = this.loadIndex();
@@ -1611,6 +1629,81 @@ export class ConversationStore {
     return this.loadRecentBySession(sessionId, Infinity);
   }
 
+  /**
+   * Copy the complete durable transcript to a new Session identity.
+   *
+   * Unlike visible history readers, this includes cold rows, internal rows,
+   * reflections, and the rows hidden by reflection tombstones. New persisted
+   * message ids are allocated in original order. References that point to a
+   * copied persisted message are remapped; external/client/tool identities are
+   * intentionally preserved.
+   *
+   * @returns {{ copiedCount: number, idMap: Map<string, string> }}
+   */
+  copySession(sourceSessionId, targetSessionId) {
+    if (!sourceSessionId || !targetSessionId || sourceSessionId === targetSessionId) {
+      return { copiedCount: 0, idMap: new Map() };
+    }
+    const primary = this.#segmentStoreForConversationDir(this.#sessionConversationDir(sourceSessionId));
+    const segmentedRows = primary.readAllRaw({ includeCold: true });
+    const legacyRows = this.#sessionFileEntries('all', sourceSessionId)
+      .map(entry => {
+        try { return this.readMessageFile(entry.path); } catch (err) {
+          if (isPermissionError(err)) return null;
+          throw err;
+        }
+      })
+      .filter(Boolean);
+    // Migration can temporarily leave the same durable row in both the legacy
+    // markdown layout and the segment store. Preserve legacy-only rows, but let
+    // the canonical segment copy win when both contain the same persisted id.
+    const rowsById = new Map();
+    for (const row of [...legacyRows, ...segmentedRows]) {
+      if (row?.sessionId !== sourceSessionId || typeof row.id !== 'string' || !row.id) continue;
+      rowsById.set(row.id, row);
+    }
+    const rows = [...rowsById.values()].sort(compareMessagesBySeq);
+    if (rows.length === 0) return { copiedCount: 0, idMap: new Map() };
+
+    const firstSeq = this.#getNextSeq();
+    const idMap = new Map(rows.map((row, index) => [
+      row.id,
+      `m${String(firstSeq + index).padStart(4, '0')}`,
+    ]));
+    const remapId = id => idMap.get(id) || id;
+    const copies = rows.map(row => {
+      const copy = { ...row, sessionId: targetSessionId };
+      delete copy.id;
+      if (idMap.has(row.causalRootId)) copy.causalRootId = remapId(row.causalRootId);
+      if (Array.isArray(row.foldedMessageIds)) {
+        copy.foldedMessageIds = row.foldedMessageIds.map(remapId);
+      }
+      if (Array.isArray(row.sourceMessageIds)) {
+        copy.sourceMessageIds = row.sourceMessageIds.map(remapId);
+      }
+      if (row.cold === true) delete copy.cold;
+      return copy;
+    });
+    const written = this.appendBatch(copies);
+    for (let index = 0; index < written.length; index += 1) {
+      if (rows[index].cold === true) this.moveToCold(written[index].id);
+    }
+
+    // append() intentionally treats permission failures as best-effort for live
+    // chat. A Session copy cannot: reporting success with a partial transcript
+    // would make the new Session irrecoverably incomplete. Verify the target's
+    // physical rows before the higher-level CRUD operation commits the clone.
+    const target = this.#segmentStoreForConversationDir(this.#sessionConversationDir(targetSessionId));
+    const persistedIds = new Set(target.readAllRaw({ includeCold: true }).map(row => row.id));
+    const expectedIds = [...idMap.values()];
+    if (written.length !== rows.length
+        || persistedIds.size !== expectedIds.length
+        || expectedIds.some(id => !persistedIds.has(id))) {
+      throw new Error(`Session transcript copy incomplete: expected ${rows.length}, persisted ${persistedIds.size}`);
+    }
+    return { copiedCount: written.length, idMap };
+  }
+
   /**
    * VP-scoped view of Session history, used to build a pair-safe provider
    * snapshot for one VP. It operates on what the VP can actually see, not

package/yeaft/engine.js

@@ -2577,6 +2577,8 @@ export class Engine {
     let displayImageAnchorMessage = null;
     let lastPersistedAssistantMessage = null;
     let lastPersistedAssistantTextMessage = null;
+    let lastSuccessfulModel = null;
+    let lastSuccessfulEffort = null;
     // `refreshConfig()` may publish a new Session model while a stream or a
     // tool is running. Apply it only before the next provider request; the
     // current request keeps the snapshot captured below.
@@ -2834,6 +2836,12 @@ export class Engine {
         else discoveredToolNames.delete(name);
       }
       toolDefs = this.#getToolDefs(effectiveCollabToolPolicy, activeToolNames);
+      // Only a child registry supplies this policy. Budget exhaustion closes
+      // investigation, not the evidence-bearing conversation: reserve one
+      // tool-free response for a useful handoff, under the existing signal.
+      const executionPolicy = isSubAgent
+        ? this.#toolRegistry?.prepareProviderRequest?.() : null;
+      if (executionPolicy?.finalize) toolDefs = [];
       ({ resolvedSkillContent, resolvedSkills, skillResolutionError } = resolveSkillPromptState({
         skillManager: this.#skillManager,
         prompt,
@@ -2851,6 +2859,7 @@ export class Engine {
       reportedSkillNames = currentSkillNames;
       reportedSkillError = skillResolutionError;
       systemPrompt = buildCurrentSystemPrompt();
+      if (executionPolicy?.prompt) systemPrompt += `\n\n${executionPolicy.prompt}`;
 
       try {
         // Resolve effort per provider request so a saved Session effort takes
@@ -2964,6 +2973,7 @@ export class Engine {
         const requestMaxOutputTokens = Math.max(1, Math.min(
           requestConfig.maxOutputTokens || resolveMaxOutputTokens(currentModel, requestConfig),
           resolveMaxOutputTokens(currentModel, requestConfig),
+          executionPolicy?.maxOutputTokens || Infinity,
         ));
         const toolSchemaTokens = toolDefs.length > 0
           ? approxTokens(JSON.stringify(toolDefs)) : 0;
@@ -3057,7 +3067,12 @@ export class Engine {
           retryLifecycle.pendingContinuation = null;
           continuationCommitted = true;
         };
+        let childDispatchReserved = false;
         const commitDispatch = () => {
+          if (isSubAgent && !childDispatchReserved) {
+            this.#toolRegistry?.reserveProviderRequest?.({ reporting: !!executionPolicy?.finalize });
+            childDispatchReserved = true;
+          }
           if (!activeProviderRequest && typeof prepareProviderRequest === 'function') {
             activeProviderRequest = prepareProviderRequest({
               turnNumber,
@@ -3164,6 +3179,9 @@ export class Engine {
               }
               break;
             case 'tool_call':
+              // No dispatch or orphan protocol rows during the reserved report,
+              // even if an adapter ignores the absence of tool definitions.
+              if (executionPolicy?.finalize) break;
               if (toolCalls.length === 0) {
                 traceRequest('llm.first_tool_call', {
                   durationMs: perfNowMs() - requestPerfStart,
@@ -3282,6 +3300,11 @@ export class Engine {
           contextTokens: peakContextTokens,
           contextWindow: peakContextWindow,
         };
+        // This request completed normally. Preserve the actual model and the
+        // adapter-resolved effort so the visible response can identify the last
+        // successful provider call (including fallback-model switches).
+        lastSuccessfulModel = currentModel;
+        lastSuccessfulEffort = requestEffortDecision.effective || resolvedEffort || null;
         // Stream completed without throwing — reset the retry counter so
         // the next turn starts with a clean budget. In-band adapter errors
         // are converted to throws above so they share the real error path.
@@ -3402,7 +3425,7 @@ export class Engine {
         // the caller. Replaying that request would publish a duplicate call and
         // leave ambiguous execution ownership, so only pre-tool failures are
         // eligible for transparent retry or model fallback.
-        const canReplayProviderRequest = toolCalls.length === 0;
+        const canReplayProviderRequest = toolCalls.length === 0 && !executionPolicy?.finalize;
         if (earlyIsContextOverflow && canReplayProviderRequest
           && contextOverflowRecoveryAttempts < 3) {
           contextOverflowRecoveryAttempts += 1;
@@ -3801,6 +3824,14 @@ export class Engine {
       conversationMessages.push(assistantMsg);
       fullResponseText += responseText;
 
+      // The reporting allowance is exactly one provider response, not another
+      // investigation loop. Ignore unsolicited calls even from a noncompliant
+      // adapter, and never auto-continue a truncated reporting response.
+      if (executionPolicy?.finalize) {
+        yield { type: 'turn_end', turnNumber, stopReason: 'budget_report', threadId, terminal: true };
+        break;
+      }
+
       // ─── Handle max_tokens → auto-continue ────────────
       // A suppressed call leaves a synthetic reminder as the latest user
       // message. Some models answer it with an empty end_turn. Continue exactly
@@ -4974,13 +5005,15 @@ export class Engine {
       // Loop back to call adapter again with tool results
     }
 
-    // Store the final provider-call count on the response row itself. Debug
-    // events are transient; the response card must retain the count after a
-    // reload without inventing a second counter.
+    // Store final provider metadata on the response row itself. Debug events
+    // are transient; the response card must retain the last successful model,
+    // effort, and call count after a reload.
     const llmCountMessage = lastPersistedAssistantTextMessage || lastPersistedAssistantMessage;
     if (llmCountMessage && typeof this.#conversationStore?.update === 'function') {
       const updated = this.#conversationStore.update(llmCountMessage, {
         llmCallCount: turnNumber,
+        ...(lastSuccessfulModel ? { model: lastSuccessfulModel } : {}),
+        ...(lastSuccessfulEffort ? { effort: lastSuccessfulEffort } : {}),
       });
       if (updated?.id === lastPersistedAssistantTextMessage?.id) lastPersistedAssistantTextMessage = updated;
       if (updated?.id === lastPersistedAssistantMessage?.id) lastPersistedAssistantMessage = updated;
@@ -4997,6 +5030,8 @@ export class Engine {
       totalMs: Date.now() - queryStartedAt,
       totalTokens: cumulativeInputTokens + cumulativeOutputTokens,
       loopCount: turnNumber,
+      ...(lastSuccessfulModel ? { model: lastSuccessfulModel } : {}),
+      ...(lastSuccessfulEffort ? { effort: lastSuccessfulEffort } : {}),
     };
 
     // The visible response is complete at the yield above. Only when the

package/yeaft/sessions/index.js

@@ -42,6 +42,7 @@ export {
   makeSessionId,
   ensureDefaultSessionIfEmpty,
   createSessionFromSpec,
+  copySession,
   renameSession,
   archiveSession,
   deleteSession,

package/yeaft/sessions/session-crud.js

@@ -63,6 +63,7 @@ import {
 } from '../conversation/history-index-state.js';
 import { retireConversationHistoryIndex } from '../conversation/history-index.js';
 import { ensureSessionConfigFile, saveSessionConfig, loadSessionConfig } from './session-config.js';
+import { ConversationStore } from '../conversation/persist.js';
 import { repairSessionStore } from './recovery.js';
 import {
   addOrUpdateManifestSession,
@@ -529,8 +530,13 @@ export function createSessionFromSpec(yeaftDir, spec, options = {}) {
   if (!name) throw new SessionCrudError('invalid_name', null, 'group name required');
 
   const callerRoster = Array.isArray(input.roster) ? input.roster.slice() : [];
-  const fallbackVpId = callerRoster.length > 0 ? null : preferDefaultVp(scanSortedVpIds(libDir));
-  const roster = callerRoster.length > 0 ? callerRoster : (fallbackVpId ? [fallbackVpId] : []);
+  const preserveEmptyRoster = options.preserveEmptyRoster === true && Array.isArray(input.roster);
+  const fallbackVpId = callerRoster.length > 0 || preserveEmptyRoster
+    ? null
+    : preferDefaultVp(scanSortedVpIds(libDir));
+  const roster = callerRoster.length > 0 || preserveEmptyRoster
+    ? callerRoster
+    : (fallbackVpId ? [fallbackVpId] : []);
   // Validate every member up-front so we fail before touching fs.
   for (const vpId of roster) {
     if (isReservedVpId(vpId)) {
@@ -593,6 +599,62 @@ export function createSessionFromSpec(yeaftDir, spec, options = {}) {
   return meta;
 }
 
+/**
+ * Create an independent Session from an existing Session's durable state.
+ * Project membership and server-owned asset storage intentionally remain with
+ * their existing owners; message payloads and their references are preserved.
+ */
+export function copySession(yeaftDir, sourceSessionId, options = {}) {
+  const sourceYeaftDir = resolveSessionYeaftDir(yeaftDir, sourceSessionId);
+  const source = requireSession(sourceYeaftDir, sourceSessionId);
+  let sourceMeta;
+  try {
+    sourceMeta = source.getMeta();
+  } finally {
+    source.close();
+  }
+
+  const requestedName = String(options.name || '').trim();
+  const name = requestedName || `${sourceMeta.name} copy`;
+  const sourceConfig = loadSessionConfig(sourceYeaftDir, sourceSessionId);
+  const copied = createSessionFromSpec(sourceYeaftDir, {
+    name,
+    roster: Array.isArray(sourceMeta.roster) ? sourceMeta.roster : [],
+    defaultVpId: sourceMeta.defaultVpId || null,
+    workDir: sourceMeta.workDir || '',
+  }, { ...options, preserveEmptyRoster: true });
+
+  try {
+    // Unlike ordinary Session creation, cloning is transactional: silently
+    // dropping a source override would make the copy behave differently.
+    saveSessionConfig(sourceYeaftDir, copied.id, sourceConfig);
+    const target = requireSession(sourceYeaftDir, copied.id);
+    try {
+      const targetMeta = target.getMeta();
+      target.saveMeta({
+        ...targetMeta,
+        announcement: sourceMeta.announcement || '',
+        metadataUpdatedAt: new Date().toISOString(),
+      });
+    } finally {
+      target.close();
+    }
+
+    const transcript = new ConversationStore(sourceYeaftDir);
+    const { copiedCount } = transcript.copySession(sourceSessionId, copied.id);
+    return { ...requireSessionMeta(sourceYeaftDir, copied.id), copiedMessageCount: copiedCount };
+  } catch (error) {
+    // A partial clone must never appear as a successful copy.
+    deleteSession(sourceYeaftDir, copied.id, options);
+    throw error;
+  }
+}
+
+function requireSessionMeta(yeaftDir, sessionId) {
+  const handle = requireSession(yeaftDir, sessionId);
+  try { return handle.getMeta(); } finally { handle.close(); }
+}
+
 /**
  * (A.2) Rename — updates meta.name; preserves everything else.
  */

package/yeaft/sub-agent/execution-control.js

@@ -2,6 +2,22 @@
 import { createHash } from 'node:crypto';
 import { ToolRegistry, isToolErrorOutput } from '../tools/registry.js';
 
+export const BUDGET_FIELDS = ['max_tokens', 'max_turns', 'max_tool_calls', 'max_llm_calls', 'wall_time_ms'];
+
+/** Validate a partial budget. Updates use absolute lifetime ceilings, never reset usage. */
+export function validateBudget(budget) {
+  if (!budget || typeof budget !== 'object' || Array.isArray(budget)) return 'budget must be an object';
+  for (const key of Object.keys(budget)) {
+    if (!BUDGET_FIELDS.includes(key)) return `unknown budget field: ${key}`;
+    const value = budget[key];
+    if (!Number.isFinite(value) || value <= 0
+        || (key !== 'max_tokens' && !Number.isSafeInteger(value))) {
+      return `budget.${key} must be finite and positive (counts and milliseconds must be integers)`;
+    }
+  }
+  return null;
+}
+
 /** Defaults are safety ceilings, not targets; explicit positive limits override each field. */
 export function resolveSubAgentBudget(budget, persona) {
   return {
@@ -25,11 +41,10 @@ function fingerprint(value) {
  * Parent Active Tool Set checks remain independent and must not be bypassed.
  */
 export class SubAgentToolRegistry extends ToolRegistry {
-  constructor({ allows = () => true, agent = null, stopBudget = null } = {}) {
+  constructor({ allows = () => true, agent = null } = {}) {
     super();
     this.allows = allows;
     this.agent = agent;
-    this.stopBudget = stopBudget;
     this.recentFingerprints = [];
   }
 
@@ -38,9 +53,53 @@ export class SubAgentToolRegistry extends ToolRegistry {
     return this;
   }
 
+  /** Provider-boundary guidance: leave the original tool results untouched. */
+  prepareProviderRequest() {
+    const agent = this.agent;
+    if (!agent) return null;
+    const stats = agent.execution || createExecutionStats();
+    const limit = agent.budget?.max_tool_calls;
+    const llmLimit = agent.budget?.max_llm_calls;
+    const llmCalls = agent.usage?.llmCalls || 0;
+    const reason = limit && stats.toolCalls >= limit ? `max_tool_calls (${limit}) reached`
+      : llmLimit && llmCalls >= llmLimit ? `max_llm_calls (${llmLimit}) reached` : null;
+    if (reason) {
+      agent.executionBudgetReason ||= reason;
+      agent.budgetReportStarted = true;
+      return {
+        finalize: true,
+        maxOutputTokens: 4096,
+        prompt: `[Sub-agent execution limit] ${reason}; ${stats.toolCalls} tools and ${llmCalls} LLM requests used. No more tools are available. Use the evidence already in this conversation to return your final handoff now: conclusion, supported findings, actual verification, and any unexamined scope or blockers. Do not claim a complete review if checks remain unfinished. This is the single reserved reporting response; do not plan further work.`,
+      };
+    }
+    const nearLimit = (limit && stats.toolCalls >= Math.ceil(limit * 0.75))
+      || (llmLimit && llmCalls >= Math.ceil(llmLimit * 0.75));
+    const elapsedMs = Date.now() - (agent.usage?.startedAt || Date.now());
+    const nearTime = agent.budget?.wall_time_ms && elapsedMs >= agent.budget.wall_time_ms * 0.75;
+    const updated = agent.controlRevision ? `[Parent control revision ${agent.controlRevision}] Current lifetime ceilings replace the initial preamble: ${JSON.stringify(agent.budget)}. Extra tool grants: ${JSON.stringify(agent.allowTools || [])}. Use DiscoverTools if an allowed tool is not yet visible.\n` : '';
+    return nearLimit || nearTime || updated ? {
+      prompt: `${updated}[Sub-agent execution budget] ${stats.toolCalls}/${limit ?? 'unset'} tools, ${llmCalls}/${llmLimit ?? 'unset'} LLM requests used; ${Math.max(0, (agent.budget?.wall_time_ms || 0) - elapsedMs)}ms remaining. Finish the assigned result using existing evidence where possible. Investigate only essential remaining unknowns, then return a conclusion.`,
+    } : null;
+  }
+
+  /** Reserve at actual Engine dispatch (including retries), not UI turn_start. */
+  reserveProviderRequest({ reporting = false } = {}) {
+    const agent = this.agent;
+    if (!agent) return;
+    if (agent.abortController?.signal.aborted) throw new Error('Sub-agent aborted');
+    const usage = agent.usage ||= { tokens: 0, turns: 0, startedAt: Date.now() };
+    if (reporting) {
+      if (usage.reportingLlmCalls) throw new Error('Sub-agent reporting request already used');
+      usage.reportingLlmCalls = 1;
+    } else if (agent.budget?.max_llm_calls && (usage.llmCalls || 0) >= agent.budget.max_llm_calls) {
+      throw new Error(`max_llm_calls (${agent.budget.max_llm_calls}) reached before dispatch`);
+    }
+    usage.llmCalls = (usage.llmCalls || 0) + 1;
+  }
+
   async execute(name, input, ctx = {}) {
     const tool = this.get(name);
-    if (!tool) throw new Error(`Unknown or disallowed child tool: ${name}`);
+    if (!tool || !this.allows(tool)) throw new Error(`Unknown or disallowed child tool: ${name}`);
     const agent = this.agent;
     if (!agent) return super.execute(name, input, ctx);
     // Serial dispatch can resume after a tool_start yield; never start a write
@@ -50,9 +109,10 @@ export class SubAgentToolRegistry extends ToolRegistry {
     const stats = agent.execution || (agent.execution = createExecutionStats());
     const limit = agent.budget?.max_tool_calls;
     if (limit !== undefined && stats.toolCalls >= limit) {
-      const reason = `max_tool_calls (${limit}) reached; return partial evidence to the parent before extending scope`;
-      this.stopBudget?.(reason);
-      throw new Error(reason);
+      // Fence dispatch without aborting already reserved parallel calls. The
+      // next provider boundary gets one tool-free response with their evidence.
+      agent.toolBudgetReason ||= `max_tool_calls (${limit}) reached`;
+      throw new Error(`${agent.toolBudgetReason}; no further tools may execute. Return findings from the available evidence.`);
     }
     stats.toolCalls += 1;
     agent.usage ||= { tokens: 0, turns: 0, startedAt: Date.now() };

package/yeaft/sub-agent/liveness.js

@@ -135,7 +135,15 @@ export function diagnoseAgentLiveness(agent, opts = {}) {
       ...agent.execution,
       recentCalls: agent.execution.recentCalls.map(call => ({ ...call })),
       remainingToolCalls: Math.max(0, (agent.budget?.max_tool_calls || 0) - agent.execution.toolCalls),
-      limits: agent.budget,
+      limits: { ...agent.budget },
+      llmCalls: agent.usage?.llmCalls || 0,
+      reportingLlmCalls: agent.usage?.reportingLlmCalls || 0,
+      remainingLlmCalls: agent.budget?.max_llm_calls === undefined ? null
+        : Math.max(0, agent.budget.max_llm_calls - (agent.usage?.llmCalls || 0)),
+      remainingWallTimeMs: agent.budget?.wall_time_ms === undefined ? null
+        : Math.max(0, agent.budget.wall_time_ms - (now - (agent.usage?.startedAt || now))),
+      allowTools: [...(agent.allowTools || [])],
+      controlRevision: agent.controlRevision || 0,
       progressNote: 'Execution counts and repeated results are diagnostics, not proof of semantic progress or stalling.',
     } : null,
     msSinceLastEvent: liveness.msSinceLastEvent ?? msSinceActivity,

package/yeaft/sub-agent/runner.js

@@ -39,6 +39,7 @@ import { Engine } from '../engine.js';
 import { snapshotEffortDecision } from '../effort.js';
 import { SubAgentToolRegistry, resolveSubAgentBudget, createExecutionStats } from './execution-control.js';
 import { getPersona } from '../personas.js';
+import { RESTRICTED_TOOLS, createChildToolPolicy } from './tool-access.js';
 import { buildSpawnedPreamble } from './spawned-prompt.js';
 import { STATUS, isTerminalAgentStatus } from './status.js';
 import { createOutputLog } from './output-log.js';
@@ -59,19 +60,6 @@ async function loadTickAgent() {
   return _tickAgent;
 }
 
-const RESTRICTED_TOOLS = new Set([
-  'SpawnAgent',
-  'Agent',          // legacy alias
-  'PromptAgent',
-  'SendMessage',    // legacy alias
-  'WaitAgent',
-  'CloseAgent',
-  'ListAgents',
-  'RouteForward',
-  'AskUser',
-  'CreateWorkItem',
-]);
-
 /** How long an idle sub-agent may wait for a follow-up before the watchdog reaps it. */
 const IDLE_ABANDON_MS = 5 * 60 * 1000; // 5 minutes
 
@@ -85,24 +73,11 @@ const LAST_RESULT_MAX_CHARS = 8 * 1024;
  * @param {ToolRegistry|null} parentRegistry
  * @returns {ToolRegistry}
  */
-export function buildChildToolRegistry(parentRegistry, { agent = null, stopBudget = null } = {}) {
-  const preset = agent?.personaData || getPersona(agent?.persona);
-  // Implementers retain work tools; read-only roles are a structural allowlist.
-  // Resolve legacy template names (Read) to canonical FileRead before filtering.
-  const allowed = preset && preset.id !== 'implementer'
-    ? new Set([...preset.tools.map(name => parentRegistry?.get(name)?.name || (name === 'Read' ? 'FileRead' : name)), 'DiscoverTools'])
-    : null;
-  const child = new SubAgentToolRegistry({
-    agent, stopBudget,
-    allows: tool => !RESTRICTED_TOOLS.has(tool.name) && (!allowed || allowed.has(tool.name)),
-  });
-  if (!parentRegistry || typeof parentRegistry.getAllTools !== 'function') {
-    return child;
-  }
-  for (const t of parentRegistry.getAllTools()) {
-    if (RESTRICTED_TOOLS.has(t.name)) continue;
-    child.register(t);
-  }
+export function buildChildToolRegistry(parentRegistry, { agent = null } = {}) {
+  const policy = createChildToolPolicy(parentRegistry, agent);
+  const child = new SubAgentToolRegistry({ agent, allows: policy.allows });
+  policy.refresh(child);
+  if (agent) agent.refreshToolPolicy = () => policy.refresh(child);
   return child;
 }
 
@@ -164,10 +139,7 @@ export function startSubAgent(agent, deps = {}) {
     // sub-agent (matches parent VP persona memory).
     agent.budget = resolveSubAgentBudget(agent.budget, agent.persona);
     agent.execution = agent.execution || createExecutionStats();
-    const childRegistry = buildChildToolRegistry(deps.parentToolRegistry, {
-      agent,
-      stopBudget: reason => stopForBudget(agent, reason),
-    });
+    const childRegistry = buildChildToolRegistry(deps.parentToolRegistry, { agent });
     subEngine = new Engine({
       adapter: deps.adapter,
       trace: deps.trace,
@@ -214,6 +186,7 @@ export function startSubAgent(agent, deps = {}) {
       expectedOutput: agent.expected_output,
       presetPrompt: (agent.personaData || getPersona(agent.persona))?.systemPrompt,
       budget: agent.budget,
+      allowTools: agent.allowTools || [],
       language: deps.language ?? deps.config?.language ?? 'en',
     });
 
@@ -262,6 +235,7 @@ export function startSubAgent(agent, deps = {}) {
     agent.outputFile = null;
     agent.subEngine = null;
     agent.subVpPersona = null;
+    agent.refreshToolPolicy = null;
     agent.__driverStarted = false;
     throw err;
   }
@@ -307,7 +281,13 @@ function armWallTimeWatchdog(agent, deps) {
   const remainingMs = Math.max(0, startedAt + wallTimeMs - Date.now());
   const timer = setTimeout(() => {
     if (isTerminalAgentStatus(agent.status)) return;
-    const reason = `wall_time_ms (${wallTimeMs}) exceeded`;
+    // Node timers above 2^31-1 overflow to 1ms. Large explicit ceilings are
+    // chunked without changing the original deadline.
+    if (Date.now() < startedAt + agent.budget.wall_time_ms) {
+      agent.rearmWallTimeWatchdog?.();
+      return;
+    }
+    const reason = `wall_time_ms (${agent.budget.wall_time_ms}) exceeded`;
     agent.result = buildWallTimeBudgetResult(agent, reason);
     agent.partial_output = agent.result.partial_output || '';
     if (agent.abortController && !agent.abortController.signal.aborted) {
@@ -318,14 +298,19 @@ function armWallTimeWatchdog(agent, deps) {
       diagnostic: 'wall_time_watchdog',
       deps,
     });
-  }, remainingMs);
+  }, Math.min(remainingMs, 2 ** 31 - 1));
   timer.unref?.();
   return timer;
 }
 
 async function driveSubAgent(agent, subEngine, vpPersona, deps) {
   const onEvent = typeof deps.onEvent === 'function' ? deps.onEvent : null;
-  const wallTimeWatchdog = armWallTimeWatchdog(agent, deps);
+  let wallTimeWatchdog = null;
+  agent.rearmWallTimeWatchdog = () => {
+    if (wallTimeWatchdog) clearTimeout(wallTimeWatchdog);
+    wallTimeWatchdog = armWallTimeWatchdog(agent, deps);
+  };
+  agent.rearmWallTimeWatchdog();
   const idleAbandonMs = typeof deps.idleAbandonMs === 'number' && deps.idleAbandonMs > 0
     ? deps.idleAbandonMs : IDLE_ABANDON_MS;
 
@@ -456,6 +441,7 @@ async function driveSubAgent(agent, subEngine, vpPersona, deps) {
       agent.lastResult = '';
       agent.result = '';
       let assistantText = '';
+      let budgetReportText = '';
       let endedNormally = false;
       let streamError = null;
       const turnTokenStart = agent.liveness?.tokenCount || 0;
@@ -501,6 +487,7 @@ async function driveSubAgent(agent, subEngine, vpPersona, deps) {
 
           if (evt && evt.type === 'text_delta' && typeof evt.text === 'string') {
             assistantText += evt.text;
+            if (agent.budgetReportStarted) budgetReportText += evt.text;
             // Mid-stream visibility: keep lastResult fresh so a parent
             // calling WaitAgent during a long generation sees what the
             // child is currently saying, not stale text from the prior
@@ -527,7 +514,8 @@ async function driveSubAgent(agent, subEngine, vpPersona, deps) {
           }
         }
       } catch (err) {
-        if (!agent.budgetStopReason) {
+        streamError = err && err.message ? err.message : String(err);
+        if (!agent.budgetStopReason && !agent.toolBudgetReason && !agent.executionBudgetReason) {
           transitionTerminal(agent, STATUS.FAILED, {
             error: err && err.message ? err.message : String(err),
             diagnostic: 'query_error',
@@ -545,6 +533,25 @@ async function driveSubAgent(agent, subEngine, vpPersona, deps) {
         return;
       }
 
+      if (isTerminalAgentStatus(agent.status)) return;
+
+      if (agent.executionBudgetReason || agent.toolBudgetReason) {
+        // A report is evidence, not proof that the assigned review completed.
+        // Prefer its complete text over the concatenated progress preview.
+        const partial = budgetReportText.trim() || assistantText.trim();
+        agent.partial_output = partial || 'No final report was produced before the tool limit. The investigation is incomplete; inspect the execution log before retrying.';
+        const reason = agent.executionBudgetReason || agent.toolBudgetReason;
+        agent.result = buildWallTimeBudgetResult(agent, reason);
+        agent.result.reporting = { attempted: !!agent.budgetReportStarted, received: !!budgetReportText.trim() };
+        if (streamError) agent.result.reporting.error = streamError;
+        agent.usage.turns += 1;
+        agent.result.usage = { ...agent.usage };
+        transitionTerminal(agent, STATUS.COMPLETED, {
+          error: reason, diagnostic: 'execution_budget_report', deps,
+        });
+        return;
+      }
+
       if (streamError) {
         transitionTerminal(agent, STATUS.FAILED, {
           error: streamError,
@@ -624,6 +631,8 @@ async function driveSubAgent(agent, subEngine, vpPersona, deps) {
     }
   } finally {
     if (wallTimeWatchdog) clearTimeout(wallTimeWatchdog);
+    agent.rearmWallTimeWatchdog = null;
+    agent.refreshToolPolicy = null;
     // Always clean up driver-owned resources. We intentionally do NOT
     // unset agent.result / agent.lastResult / agent.liveness / agent.
     // outputFile — those are observable by the parent after termination.