@myagentroam/agent 0.9.161 → 0.9.163

package/dist/agent-core/prompts/subagent.d.ts

@@ -1,2 +1,2 @@
-export declare const subagentPrompt = "# Subagents\nUse your own direct tools by default. Delegate only when a bounded task can proceed independently and parallelism has real value; do not delegate ordinary local search, a known-file read, a single verification command, a small edit, or sequential debugging. Give each child a self-contained objective, relevant paths and constraints, expected evidence, and a clear read/write boundary. Subagents cannot recurse and share the real filesystem; do not assign conflicting writes or assume isolation. Track background agent IDs, wait or cancel them, inspect their actual workspace effects, and verify every claim before incorporating it. Continue meaningful non-overlapping work after starting a background child. Wait for completion only when the next critical-path action is blocked on the final result, and then prefer one long wait measured in minutes rather than repeated short waits. Wait for a public message only when a fresh progress update would change the next decision; do not use message waits as heartbeat checks or request progress merely to confirm that a child is still running. The parent retains responsibility for the final result.";
+export declare const subagentPrompt = "# Subagents\nCall agent_start, agent_wait, agent_message and agent_cancel directly, never inside code_exec; they are absent from the cell tools namespace. Use your own direct tools by default. Delegate only when a bounded task can proceed independently and parallelism has real value; do not delegate ordinary local search, a known-file read, a single verification command, a small edit, or sequential debugging. Give each child a self-contained objective, relevant paths and constraints, expected evidence, and a clear read/write boundary. Subagents cannot recurse and share the real filesystem; do not assign conflicting writes or assume isolation. Track background agent IDs, wait or cancel them, inspect their actual workspace effects, and verify every claim before incorporating it. Continue meaningful non-overlapping work after starting a background child. Wait for completion only when the next critical-path action is blocked on the final result, and then prefer one long wait measured in minutes rather than repeated short waits. Wait for a public message only when a fresh progress update would change the next decision; do not use message waits as heartbeat checks or request progress merely to confirm that a child is still running. The parent retains responsibility for the final result.";
 export declare const childSubagentInstruction = "You are a non-recursive subagent. Work only on the delegated objective and within its stated read/write scope. Do not broaden the parent task, ask the user, start another subagent, commit, or claim parent-level completion. Inspect relevant evidence, make only authorized changes, run proportional verification, and return a concise factual handoff containing findings, exact files changed, commands/tests actually run, failures or uncertainty, and anything the parent must verify.";

package/dist/agent-core/prompts/subagent.js

@@ -1,2 +1,2 @@
-export const subagentPrompt = '# Subagents\nUse your own direct tools by default. Delegate only when a bounded task can proceed independently and parallelism has real value; do not delegate ordinary local search, a known-file read, a single verification command, a small edit, or sequential debugging. Give each child a self-contained objective, relevant paths and constraints, expected evidence, and a clear read/write boundary. Subagents cannot recurse and share the real filesystem; do not assign conflicting writes or assume isolation. Track background agent IDs, wait or cancel them, inspect their actual workspace effects, and verify every claim before incorporating it. Continue meaningful non-overlapping work after starting a background child. Wait for completion only when the next critical-path action is blocked on the final result, and then prefer one long wait measured in minutes rather than repeated short waits. Wait for a public message only when a fresh progress update would change the next decision; do not use message waits as heartbeat checks or request progress merely to confirm that a child is still running. The parent retains responsibility for the final result.';
+export const subagentPrompt = '# Subagents\nCall agent_start, agent_wait, agent_message and agent_cancel directly, never inside code_exec; they are absent from the cell tools namespace. Use your own direct tools by default. Delegate only when a bounded task can proceed independently and parallelism has real value; do not delegate ordinary local search, a known-file read, a single verification command, a small edit, or sequential debugging. Give each child a self-contained objective, relevant paths and constraints, expected evidence, and a clear read/write boundary. Subagents cannot recurse and share the real filesystem; do not assign conflicting writes or assume isolation. Track background agent IDs, wait or cancel them, inspect their actual workspace effects, and verify every claim before incorporating it. Continue meaningful non-overlapping work after starting a background child. Wait for completion only when the next critical-path action is blocked on the final result, and then prefer one long wait measured in minutes rather than repeated short waits. Wait for a public message only when a fresh progress update would change the next decision; do not use message waits as heartbeat checks or request progress merely to confirm that a child is still running. The parent retains responsibility for the final result.';
 export const childSubagentInstruction = 'You are a non-recursive subagent. Work only on the delegated objective and within its stated read/write scope. Do not broaden the parent task, ask the user, start another subagent, commit, or claim parent-level completion. Inspect relevant evidence, make only authorized changes, run proportional verification, and return a concise factual handoff containing findings, exact files changed, commands/tests actually run, failures or uncertainty, and anything the parent must verify.';

package/dist/agent-core/runtime/rollout-budget.js

@@ -50,7 +50,7 @@ export class RolloutBudget {
     }
     assertAvailable() {
         if (this.stage === 'exhausted')
-            throw new MarAgentError('MAR_AGENT_ROLLOUT_BUDGET_EXCEEDED', 'The shared execution token budget has been exhausted.');
+            throw new MarAgentError('MAR_AGENT_ROLLOUT_BUDGET_EXCEEDED', 'The execution token budget has been exhausted.');
     }
 }
 export function resolveRolloutBudgetOptions(options) {

package/dist/agent-core/sdk/session.d.ts

@@ -9,7 +9,7 @@ import type { CoreAgentsBackend } from '../extensions/agents.js';
 import type { HostDescription, MarAgentHost } from '../host/contracts.js';
 import { type MarAgentReasoningEffort } from '../model/configuration.js';
 import type { ModelAdapter, ModelMessage } from '../model/contracts.js';
-import { RolloutBudget, resolveRolloutBudgetOptions } from '../runtime/rollout-budget.js';
+import { resolveRolloutBudgetOptions } from '../runtime/rollout-budget.js';
 import { JsonlSessionStore } from '../session/jsonl-store.js';
 import { SubagentSessionController, type SubagentMailboxMessage, type SubagentMessageDelivery, type SubagentTurnHandle } from '../subagent/session-controller.js';
 import { createSessionToolScheduler } from '../tools/scheduler.js';
@@ -50,7 +50,6 @@ interface InternalMarAgentSession extends MarAgentSession {
         readonly initialMailbox: readonly SubagentMailboxMessage[];
         readonly turnId: string;
         readonly delivery?: SubagentMessageDelivery;
-        readonly sharedRolloutBudget?: RolloutBudget;
         readonly mcpExecutionScopeId?: string;
         readonly origin?: CoreOperationContext;
     }): SubagentTurnHandle;

package/dist/agent-core/sdk/session.js

@@ -328,9 +328,9 @@ export function createSessionOpener(services) {
                 let finalAnswer = '';
                 let executionLoop;
                 let manualCompaction;
-                const rolloutBudget = internal.sharedRolloutBudget ??
-                    (rolloutBudgetOptions ? new RolloutBudget(rolloutBudgetOptions) : undefined);
-                const ownsRolloutBudget = rolloutBudget !== undefined && internal.sharedRolloutBudget === undefined;
+                const rolloutBudget = sessionSource.type === 'user' && rolloutBudgetOptions
+                    ? new RolloutBudget(rolloutBudgetOptions)
+                    : undefined;
                 let releaseSession;
                 let executionToolSources;
                 let selectedTurn;
@@ -583,8 +583,7 @@ export function createSessionOpener(services) {
                                     turnId: turn.turnId,
                                     ...(turn.origin === undefined ? {} : { origin: turn.origin }),
                                     mcpExecutionScopeId: executionId,
-                                    ...(turn.delivery ? { delivery: turn.delivery } : {}),
-                                    ...(rolloutBudget === undefined ? {} : { sharedRolloutBudget: rolloutBudget })
+                                    ...(turn.delivery ? { delivery: turn.delivery } : {})
                                 });
                             }
                         });
@@ -1466,8 +1465,7 @@ export function createSessionOpener(services) {
                     if (sessionRuntime.toolSources === executionToolSources)
                         delete sessionRuntime.toolSources;
                     internal.signal?.removeEventListener('abort', abortSource);
-                    if (ownsRolloutBudget)
-                        rolloutBudget.discard();
+                    rolloutBudget?.discard();
                     await manualCompaction?.dispose();
                     await selectedTurn?.close().catch(() => undefined);
                     try {
@@ -1778,10 +1776,7 @@ export function createSessionOpener(services) {
                 ...(turn.mcpExecutionScopeId === undefined
                     ? {}
                     : { mcpExecutionScopeId: turn.mcpExecutionScopeId }),
-                ...(turn.delivery ? { delivery: turn.delivery } : {}),
-                ...(turn.sharedRolloutBudget === undefined
-                    ? {}
-                    : { sharedRolloutBudget: turn.sharedRolloutBudget })
+                ...(turn.delivery ? { delivery: turn.delivery } : {})
             })
         };
     };

package/dist/agent-core/tools/agent/agent-cancel.js

@@ -1,9 +1,9 @@
 import { MarAgentError } from '../../error.js';
 export const agentCancelToolDefinition = {
     name: 'agent_cancel',
-    allowedCallers: ['direct', 'programmatic'],
+    allowedCallers: ['direct'],
     parallelSafety: 'serial',
-    description: 'Idempotently cancel a child agent using the agentId returned by agent_start. For an exec processId, use exec with action:"cancel" instead. Waits for a running task to reach cancelled and returns its agentId and description.',
+    description: 'Idempotently cancel a child agent using the agentId returned by agent_start. For an exec processId, use exec_wait with action:"cancel" instead (tools.exec_wait in Code Mode). Waits for a running task to reach cancelled and returns its agentId and description.',
     inputSchema: {
         type: 'object',
         properties: { agentId: { type: 'string' } },

package/dist/agent-core/tools/agent/agent-message.js

@@ -2,7 +2,7 @@ import { MarAgentError } from '../../error.js';
 import { TOOL_EXECUTION_LIMITS } from '../execution-limits.js';
 export const agentMessageToolDefinition = {
     name: 'agent_message',
-    allowedCallers: ['direct', 'programmatic'],
+    allowedCallers: ['direct'],
     parallelSafety: 'serial',
     description: 'Send a real user message to an existing child agent. Default delivery=append inserts guidance into a running child turn at the next safe boundary after the current model response or complete tool batch. Explicit delivery=replace immediately requests cancellation, waits for the old turn to close, then starts a new turn in the same Session. When idle, either mode starts a new turn using persisted history. Returns messageId, turnId, deliveryStatus, current status, and model metadata without repeating the child’s previous latestMessage, latestActivity, summary, or verification evidence. accepted means queued in memory; applied means persisted in model context, not that the guidance has been executed. Use agent_wait for subsequent progress or completion. Does not wait for the new task to complete or roll back existing side effects.',
     inputSchema: {

package/dist/agent-core/tools/agent/agent-start.js

@@ -3,7 +3,7 @@ import { marAgentReasoningEffortSchema } from '../../model/configuration.js';
 import { TOOL_EXECUTION_LIMITS } from '../execution-limits.js';
 export const agentStartToolDefinition = {
     name: 'agent_start',
-    allowedCallers: ['direct', 'programmatic'],
+    allowedCallers: ['direct'],
     parallelSafety: 'serial',
     description: 'Start one bounded, non-recursive child agent with self-contained context. Use when an independent investigation would consume substantial main-context space or when safe parallel work has real value; keep small or tightly coupled work in the main context. All agents share the filesystem, so avoid conflicting writes. The optional reasoningEffort overrides the parent effort and must be supported by the selected model; omit it to inherit. Returns agentId for agent_wait, agent_message, or agent_cancel, description, queued/running/completed/failed/cancelled status, bounded summary, changedFiles, verification, and read evidence; background returns immediately while foreground waits for a terminal result.',
     inputSchema: {

package/dist/agent-core/tools/agent/agent-wait.js

@@ -2,7 +2,7 @@ import { MarAgentError } from '../../error.js';
 import { TOOL_EXECUTION_LIMITS } from '../execution-limits.js';
 export const agentWaitToolDefinition = {
     name: 'agent_wait',
-    allowedCallers: ['direct', 'programmatic'],
+    allowedCallers: ['direct'],
     parallelSafety: 'serial',
     description: 'Read or wait a bounded time for a child agent result. waitFor defaults to "completion"; use "message" only when a fresh public commentary/final message would change the next decision. Omit agentId to wait for whichever live child returns first, matching Codex-style untargeted waiting and avoiding UUID transcription; provide the exact agentId returned by agent_start only when observing a specific child. If no child is live, untargeted waiting reads the most recently created child. For an exec processId, use exec_wait instead (tools.exec_wait in Code Mode). Omitting waitMs waits up to 30 seconds by default; waitMs=0 returns the current snapshot immediately. Positive waits range up to 5 minutes, and positive values below 10 seconds are raised to 10 seconds. When blocked on a live child result, prefer one 300000 ms completion wait rather than repeated short waits. Every result includes waitOutcome as snapshot, message, completion, or timeout plus the real agentId and description. A message, timeout with unread progress, or first terminal completion result includes the newly observed latest public commentary/final message; snapshots and repeated observations omit previously observed message text. latestActivity can still identify a public message or bounded tool started/completed/failed status. A queued or running result is not completion. A message wait consumes only the latest unread public message in the current Session runtime; tool activity does not wake it, and parent cancellation preserves unread progress for a later Execution. Do not use message waits as heartbeat checks or request progress merely to confirm that a child is still running. First terminal results include bounded summary, changedFiles, verification, and read evidence with path/line ranges; use that evidence to avoid repeating the full exploration, while independently checking consequential edits and claims.',
     inputSchema: {

package/dist/agent-core/tools/callers.js

@@ -13,7 +13,17 @@ export function toolCallers(tool) {
 export function allowsToolCaller(tool, caller) {
     // Control tools cannot be widened by a Host override or historical definition.
     if (caller === 'programmatic' &&
-        ['code_exec', 'code_exec_wait', 'tool_search', 'question', 'skill'].includes(tool.name))
+        [
+            'code_exec',
+            'code_exec_wait',
+            'tool_search',
+            'question',
+            'skill',
+            'agent_start',
+            'agent_wait',
+            'agent_message',
+            'agent_cancel'
+        ].includes(tool.name))
         return false;
     return toolCallers(tool).includes(caller);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@myagentroam/agent",
-  "version": "0.9.161",
+  "version": "0.9.163",
   "description": "Embeddable MAR coding agent SDK and CLI.",
   "license": "Apache-2.0",
   "type": "module",