npm - @yeaft/webchat-agent - Versions diffs - 1.0.513 → 1.0.514 - Mend

@yeaft/webchat-agent 1.0.513 → 1.0.514

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 (22) hide show

package/connection/message-router.js +4 -1
package/local-runtime/version.json +1 -1
package/local-runtime/web/app.bundle.js +88 -86
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/conversation/persist.js +89 -0
package/yeaft/engine.js +25 -1
package/yeaft/sessions/index.js +1 -0
package/yeaft/sessions/session-crud.js +64 -2
package/yeaft/sub-agent/execution-control.js +66 -6
package/yeaft/sub-agent/liveness.js +9 -1
package/yeaft/sub-agent/runner.js +48 -39
package/yeaft/sub-agent/spawned-prompt.js +3 -2
package/yeaft/sub-agent/tool-access.js +138 -0
package/yeaft/templates/personas/reviewer.md +5 -2
package/yeaft/tools/activation.js +2 -0
package/yeaft/tools/agent.js +30 -14
package/yeaft/tools/git-read.js +266 -0
package/yeaft/tools/index.js +4 -0
package/yeaft/tools/update-agent.js +79 -0
package/yeaft/web-bridge.js +23 -0

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=2b5f864c"></script>
+  <script type="module" src="app.bundle.js?v=88c18e0b"></script>
 </body>
 </html>

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "@yeaft/webchat-agent",
-  "version": "1.0.513",
+  "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 CHANGED Viewed

@@ -827,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();
@@ -1615,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 CHANGED Viewed

@@ -2836,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,
@@ -2853,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
@@ -2966,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;
@@ -3059,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,
@@ -3166,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,
@@ -3409,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;
@@ -3808,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

package/yeaft/sessions/index.js CHANGED Viewed

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

package/yeaft/sessions/session-crud.js CHANGED Viewed

@@ -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 CHANGED Viewed

@@ -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 CHANGED Viewed

@@ -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 CHANGED Viewed

@@ -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.

package/yeaft/sub-agent/spawned-prompt.js CHANGED Viewed

@@ -25,7 +25,7 @@
  * @param {'en'|'zh'} [args.language='en']
  * @returns {string} preamble block (already ## headed, ready to concat)
  */
-export function buildSpawnedPreamble({ parentName, parentVpId, agentName, mission, expectedOutput, presetPrompt, budget, language = 'en' } = {}) {
+export function buildSpawnedPreamble({ parentName, parentVpId, agentName, mission, expectedOutput, presetPrompt, budget, allowTools = [], language = 'en' } = {}) {
   // Resolve template markers before embedding: the outer VP renderer treats
   // markers as sections of the whole soul and would drop the parent + contract.
   const locale = language === 'zh' || language === 'zh-CN' ? 'zh' : 'en';
@@ -35,8 +35,9 @@ export function buildSpawnedPreamble({ parentName, parentVpId, agentName, missio
     : presetPrompt;
   const contract = [
     rolePrompt || '',
+    `## Tool authority\nDefault persona tools plus explicit parent grants: ${JSON.stringify(allowTools)}. Parent grants override a default read-only role only within the mission's scope. Bash permits arbitrary shell/writes; it is not a sandbox. You cannot grant yourself tools or budget; report blockers to the parent. UpdateAgent is parent-only.`,
     expectedOutput ? `## expected_output\nReturn the requested structure; mark unverified facts and blockers honestly.\n${JSON.stringify(expectedOutput)}` : '',
-    budget ? `## Execution budget\n${JSON.stringify(budget)}\nLimits are ceilings, not targets. Stop once the mission is answered. Return partial findings before exhausting the budget; do not automatically restart the same work.` : '',
+    budget ? `## Execution budget\n${JSON.stringify(budget)}\nLimits are ceilings, not targets. Complete the assigned result, then stop; do not stop with a plan or promise to continue. If a tool or prerequisite is unavailable, return the evidence and blocker instead of searching for unavailable capabilities. Near the tool limit, prioritize a supported conclusion. At the limit, one tool-free report may be requested within the remaining time/token budget; do not automatically restart the work.` : '',
   ].filter(Boolean).join('\n\n');
   const m = [(mission || '').trim(), contract].filter(Boolean).join('\n\n');
   if (language === 'zh') {