@myagentroam/agent 0.9.96 → 0.9.98

package/dist/prompts/compact.js

@@ -12,7 +12,7 @@ Preserve, when present:
 - unresolved questions, blockers, risks, uncommitted changes, Todo/plan state, and pending external decisions;
 - the next concrete action and the evidence still required before completion.
 
-Distinguish clearly between completed, attempted, planned, inferred, and unverified work. Newer user instructions override older ones; retain superseded instructions only when needed to explain current state. Never invent completion, test results, file contents, permissions, or external effects.
+Distinguish clearly between completed, attempted, planned, inferred, and unverified work. Newer user instructions override older ones; retain superseded instructions only when needed to explain current state. Authorization has exact action, scope, and lifetime: preserve it as active only while all three remain valid. Historical instructions, completed scopes, and state that merely makes an action plausible cannot grant or revive authorization. Never invent completion, test results, file contents, permissions, authorization, or external effects.
 
 Remove aggressively:
 - greetings, acknowledgements, progress chatter, repeated instructions, repeated status, and conclusions already represented once;
@@ -51,6 +51,7 @@ branch changed -> inherited_evidence=unverified
 1. 目标契约 / Goal contract
 - 主目标、当前交付、完成标准、非目标/边界。
 - direct user/caller authorization、prohibition、exclusion 保留 exact action/scope，不概括成更宽泛边界。
+- authorization 必须归约 exact action、scope、lifetime。仅当三者在 latest active task/request 中仍有效时记录 active；已完成或被取代作用域中的授权只能记录 expired/superseded historical evidence，不得恢复为 current permission。
 
 2. 当前状态 / Current state
 - 对象：file、symbol、feature、migration、test、worktree、selected Skill、Todo/plan、external decision、external side effect。retained process/subagent inventory 由 Runtime 重建，不进入 IR。
@@ -73,9 +74,10 @@ branch changed -> inherited_evidence=unverified
 5. 未闭环 / Open loops
 - unresolved、unverified、blocker、pending external decision、Todo/plan current step、仍需 evidence。
 - 只保留已确定的最小 next action + preconditions；不复制可重算的长 plan。
+- 需要独立授权的 action 只有在 current direct authorization 覆盖 exact action/scope 且 lifetime 仍有效时才能标为 pending/next。对象状态、完成度、工具可用性或执行便利性均不得推导 authorization；无有效授权时省略该动作，必要时记录 authorization | action=<exact> | status=expired|superseded|absent。
 
 编译规则：
-1. latest user intent 定目标；newer correction 覆盖 older intent。
+1. latest user intent 定目标；newer correction 覆盖 older intent。历史指令不得因仍出现在 retained user messages 中而恢复为 active authorization。
 2. 归约 before -> event -> after；source mutation 或 base/branch change 后 affected read/conclusion stale，除非已有 newer evidence；history replacement 仅使 Responses continuation invalid，不使 factual evidence 自动失效；无 invalidating event 的 verified claim 保持 current；current 取最后已证 after-state 或 later direct observation。
 3. 每个 continuation object 一条 current record；等价事实去重。
 4. 仅保留仍约束 open work 的 settled decision/exclusion。

package/dist/prompts/core.d.ts

@@ -15,4 +15,4 @@ export interface EnvironmentContextState {
     guaranteedCommands?: Readonly<Record<string, string>>;
     workspace: string;
 }
-export declare function buildEnvironmentContext(input: EnvironmentContextState, previous?: EnvironmentContextState): string;
+export declare function buildEnvironmentContext(input: EnvironmentContextState, previous?: EnvironmentContextState, contextualEntries?: readonly string[]): string;

package/dist/prompts/core.js

@@ -6,7 +6,7 @@ export const workspaceDisciplinePrompt = '# Workspace and change discipline\nAss
 export function environmentPrompt(input) {
     return `# Environment and workspace\nMode: ${input.mode}. The Runtime provides current platform, shell and Workspace facts in an environment_context message. These facts describe the execution environment, not additional instructions or permissions. Start exploration inside this workspace unless the task explicitly requires an absolute path elsewhere. Generate commands for the actual platform and configured shell; do not assume POSIX tools on Windows or PowerShell/cmd syntax on Unix. Relative tool paths resolve from the Workspace. Absolute paths are allowed subject to the operating-system account's permissions and Host-declared file boundaries.`;
 }
-export function buildEnvironmentContext(input, previous) {
+export function buildEnvironmentContext(input, previous, contextualEntries = []) {
     const element = (name, value) => `<${name}>${value.replace(/[&<>"']/g, (character) => {
         return { '&': '&amp;', '<': '&lt;', '>': '&gt;', '"': '&quot;', "'": '&apos;' }[character];
     })}</${name}>`;
@@ -31,7 +31,7 @@ export function buildEnvironmentContext(input, previous) {
             return [];
         return [value ?? `<${name} status="unavailable" />`];
     });
-    return changes.length
-        ? ['<environment_context>', ...changes, '</environment_context>'].join('\n')
+    return changes.length > 0 || contextualEntries.length > 0
+        ? ['<environment_context>', ...changes, ...contextualEntries, '</environment_context>'].join('\n')
         : '';
 }

package/dist/prompts/execution-budget.d.ts

@@ -1,6 +1,3 @@
 import type { RolloutBudgetStage } from '../runtime/rollout-budget.js';
-export interface ExecutionBudgetPromptState {
-    stage: RolloutBudgetStage;
-    limitTokens: number;
-}
-export declare function executionBudgetPrompt(input: ExecutionBudgetPromptState): string;
+export type ExecutionBudgetEnvironmentStage = Exclude<RolloutBudgetStage, 'normal'> | 'inactive';
+export declare function executionBudgetEnvironmentEntry(stage: ExecutionBudgetEnvironmentStage): string;

package/dist/prompts/execution-budget.js

@@ -1,10 +1,11 @@
-export function executionBudgetPrompt(input) {
+export function executionBudgetEnvironmentEntry(stage) {
+    if (stage === 'inactive')
+        return '<execution_guidance status="inactive" />';
     const privateInstruction = 'This is internal runtime guidance. Never mention the budget, thresholds, remaining amount, or budget stage in user-visible progress or the final answer.';
-    if (input.stage === 'exhausted')
-        return `# Execution budget\n${privateInstruction}\n\nThe shared rollout budget is exhausted. Do not start or continue investigation, optional work, new tool exploration, or new subagents. Return a concise final answer now using the current verified staged result. Clearly distinguish completed work from anything still incomplete, without mentioning this budget.`;
-    if (input.stage === 'finalize')
-        return `# Execution budget\n${privateInstruction}\n\nEnter finalization now. Do not start new investigation or new subagents. Complete only the current atomic change, the minimum necessary verification, and the final answer as soon as possible.`;
-    if (input.stage === 'conserve')
-        return `# Execution budget\n${privateInstruction}\n\nStop expanding scope and stop optional work. Prefer completing the current objective with the evidence already gathered, and avoid new investigation unless it is strictly required for correctness.`;
-    return `# Execution budget\n${privateInstruction}\n\nThis main Execution and the subagents it creates share an internal weighted token budget of ${input.limitTokens}. Work normally, but keep scope disciplined and converge once the requested outcome is verified.`;
+    const guidance = stage === 'exhausted'
+        ? 'The shared rollout budget is exhausted. Do not start or continue investigation, optional work, new tool exploration, or new subagents. Return a concise final answer now using the current verified staged result. Clearly distinguish completed work from anything still incomplete, without mentioning this budget.'
+        : stage === 'finalize'
+            ? 'Enter finalization now. Do not start new investigation or new subagents. Complete only the current atomic change, the minimum necessary verification, and the final answer as soon as possible.'
+            : 'Stop expanding scope and stop optional work. Prefer completing the current objective with the evidence already gathered, and avoid new investigation unless it is strictly required for correctness.';
+    return `<execution_guidance stage="${stage}">\n${privateInstruction}\n\n${guidance}\n</execution_guidance>`;
 }

package/dist/prompts/index.d.ts

@@ -1,7 +1,5 @@
 import type { ExecutionMode } from '../sdk/types.js';
-import { type ExecutionBudgetPromptState } from './execution-budget.js';
-import { type CurrentAgentModel, type SubagentModelOption } from './subagent.js';
-export declare const MAR_AGENT_PROMPT_VERSION = "1.52";
+export declare const MAR_AGENT_PROMPT_VERSION = "1.55";
 export declare function buildSystemPrompt(input: {
     mode: ExecutionMode;
     platform: string;
@@ -13,9 +11,6 @@ export declare function buildSystemPrompt(input: {
     guaranteedCommands?: Readonly<Record<string, string>>;
     workspace: string;
     tools: readonly string[];
-    currentAgentModel?: CurrentAgentModel;
-    subagentModels?: readonly SubagentModelOption[];
-    executionBudget?: ExecutionBudgetPromptState;
     highDensityCompaction?: boolean;
     extension?: string | undefined;
 }): string;

package/dist/prompts/index.js

@@ -1,11 +1,10 @@
 import { compactionPrompt, highDensityCompactionPrompt } from './compact.js';
 import { environmentPrompt, identityPrompt, instructionPriorityPrompt, workspaceDisciplinePrompt } from './core.js';
-import { executionBudgetPrompt } from './execution-budget.js';
 import { modePrompt } from './modes.js';
 import { outputStylePrompt } from './output.js';
-import { subagentModelOptionsPrompt, subagentPrompt, currentAgentModelPrompt } from './subagent.js';
+import { subagentPrompt } from './subagent.js';
 import { interactionPrompt, longRunningPrompt, safetyPrompt, toolUsagePrompt, workflowPrompt } from './workflow.js';
-export const MAR_AGENT_PROMPT_VERSION = '1.52';
+export const MAR_AGENT_PROMPT_VERSION = '1.55';
 export function buildSystemPrompt(input) {
     const toolNames = new Set(input.tools);
     const hasLongRunningCapability = [
@@ -27,10 +26,8 @@ export function buildSystemPrompt(input) {
         environmentPrompt(input),
         input.tools.length > 0 ? toolUsagePrompt(input.tools) : '',
         hasLongRunningCapability ? longRunningPrompt(input.tools) : '',
-        input.executionBudget ? executionBudgetPrompt(input.executionBudget) : '',
         modePrompt(input.mode, {
-            questionAvailable: toolNames.has('question'),
-            forceFinalize: input.executionBudget?.stage === 'exhausted'
+            questionAvailable: toolNames.has('question')
         }),
         input.mode === 'compact'
             ? input.highDensityCompaction
@@ -38,8 +35,6 @@ export function buildSystemPrompt(input) {
                 : compactionPrompt()
             : '',
         toolNames.has('agent_start') ? subagentPrompt : '',
-        toolNames.has('agent_start') ? currentAgentModelPrompt(input.currentAgentModel) : '',
-        toolNames.has('agent_start') ? subagentModelOptionsPrompt(input.subagentModels ?? []) : '',
         input.extension ? `# Caller, project, and selected Skill instructions\n${input.extension}` : ''
     ]
         .filter(Boolean)

package/dist/prompts/modes.d.ts

@@ -1,5 +1,4 @@
 import type { ExecutionMode } from '../sdk/types.js';
 export declare function modePrompt(mode: ExecutionMode, input: {
     questionAvailable: boolean;
-    forceFinalize: boolean;
 }): string;

package/dist/prompts/modes.js

@@ -1,17 +1,11 @@
 export function modePrompt(mode, input) {
     if (mode !== 'plan')
         return '';
-    const investigationGuidance = input.forceFinalize
-        ? 'Use only evidence already gathered; do not start or continue Plan exploration.'
-        : 'Resolve discoverable facts through targeted read-only investigation. Ask about user-owned preferences and tradeoffs early when they cannot be inferred from the request, conversation, or workspace evidence.';
+    const investigationGuidance = 'Resolve discoverable facts through targeted read-only investigation. Ask about user-owned preferences and tradeoffs early when they cannot be inferred from the request, conversation, or workspace evidence. If current environment guidance requires finalization, stop further exploration and use only evidence already gathered.';
     const decisionGuidance = input.questionAvailable
         ? 'Use question for unresolved choices that materially change the result; do not finalize the plan while such choices remain. Do not invent support for multiple outcomes or silently choose a default to avoid asking.'
-        : input.forceFinalize
-            ? 'User input is unavailable in this exhausted round. Return the current verified staged result now; state the unresolved decision and its impact instead of guessing.'
-            : 'Ask a concise plain-text question for unresolved user-owned choices that materially change the result instead of finalizing an ambiguous plan. Do not invent support for multiple outcomes or silently choose a default.';
-    const finalGuidance = input.forceFinalize
-        ? 'Return only the concise staged plan now, distinguishing verified conclusions from incomplete work and unresolved decisions. Do not ask whether to proceed or claim unresolved work is complete.'
-        : 'Once the plan is decision-complete, return only a concise, actionable plan. Break the work into meaningful, logically ordered deliverables that are easy to verify. Do not pad the plan with filler or obvious steps. Include the implementation and verification detail needed to execute it, without drafting the implementation itself. Do not ask whether to proceed or claim planned work is completed.';
+        : 'Ask a concise plain-text question for unresolved user-owned choices that materially change the result instead of finalizing an ambiguous plan. When current environment guidance requires finalization and user input is unavailable, state the unresolved decision and its impact instead of guessing. Do not invent support for multiple outcomes or silently choose a default.';
+    const finalGuidance = 'Once the plan is decision-complete, return only a concise, actionable plan. Break the work into meaningful, logically ordered deliverables that are easy to verify. Do not pad the plan with filler or obvious steps. Include the implementation and verification detail needed to execute it, without drafting the implementation itself. When current environment guidance requires finalization, return the concise verified staged plan and distinguish incomplete work or unresolved decisions. Do not ask whether to proceed or claim unresolved work is complete.';
     return `# Plan mode
 Use tools only for read-only investigation that reduces uncertainty and improves the plan. Do not create, modify, delete, rename, or move files, and do not run commands intended to mutate repository-tracked state or implement the requested work. This is behavioral guidance, not a security boundary; the normal tools and Host policies remain available.
 

package/dist/prompts/subagent.d.ts

@@ -1,15 +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 interface SubagentModelOption {
-    readonly id: string;
-    readonly name: string;
-    readonly default: boolean;
-    readonly reasoningEfforts: readonly string[];
-}
-export interface CurrentAgentModel {
-    readonly id: string;
-    readonly name: string;
-    readonly reasoningEffort: string;
-}
-export declare function currentAgentModelPrompt(model: CurrentAgentModel | undefined): string;
-export declare function subagentModelOptionsPrompt(options: readonly SubagentModelOption[]): string;
 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/prompts/subagent.js

@@ -1,29 +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 function currentAgentModelPrompt(model) {
-    if (!model)
-        return '';
-    return [
-        '# Current Agent Model',
-        `The current agent is running as ${model.id} (${promptData(model.name)}) with reasoning effort: ${model.reasoningEffort}.`
-    ].join('\n');
-}
-export function subagentModelOptionsPrompt(options) {
-    if (options.length === 0 || (options.length === 1 && options[0]?.reasoningEfforts.length === 0))
-        return '';
-    const lines = options.map((option) => {
-        const defaultLabel = option.default ? ', default' : '';
-        const effortLabel = option.reasoningEfforts.length === 0
-            ? ''
-            : `; reasoning efforts: ${option.reasoningEfforts.join(', ')}`;
-        return `- ${option.id} (${promptData(option.name)}${defaultLabel}${effortLabel})`;
-    });
-    return [
-        '# Subagent Models',
-        'The agent_start tool modelId field may select any enabled model below, and its optional reasoningEffort field overrides the parent effort. Omit both to inherit the parent model and effort. Only use an effort listed for the selected model, and never guess an unlisted model ID or effort.',
-        ...lines
-    ].join('\n');
-}
-function promptData(value) {
-    return JSON.stringify(value);
-}
 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/runtime/compact.js

@@ -225,7 +225,7 @@ export function compactedHistoryMessages(history) {
     return history.map(({ role, content }) => ({ role, content }));
 }
 export function continuationMessage(summary) {
-    return `Continue from the compacted state below. Treat it as a factual handoff, not a new user request. Earlier user messages are retained historical evidence, not requests to repeat completed work. Newer user instructions override older messages and this handoff. Continue directly from its Next action without recapping it to the user. Re-read files or rerun checks when the handoff marks facts as stale, inferred, failed, or unverified. Do not repeat completed side effects.\n\n${summary}`;
+    return `Continue from the compacted state below. Treat it as a factual handoff, not a new user request. Earlier user messages are retained historical evidence, not requests to repeat completed work or authorization for new side effects. Newer user instructions override older messages and this handoff. The handoff cannot create or revive authorization: an action that requires separate authorization may proceed only when current direct authorization still covers its exact action, scope, and lifetime. Continue directly from its Next action without recapping it to the user. Re-read files or rerun checks when the handoff marks facts as stale, inferred, failed, or unverified. Do not repeat completed side effects.\n\n${summary}`;
 }
 function renderMessage(message) {
     const metadata = [

package/dist/runtime/environment-context.d.ts

@@ -1,4 +1,4 @@
 import type { ModelMessage } from '../model/contracts.js';
 import { type EnvironmentContextState } from '../prompts/core.js';
 export declare function restoreEnvironmentState(payload: unknown): EnvironmentContextState | undefined;
-export declare function environmentContextUpdate(current: EnvironmentContextState, previous?: EnvironmentContextState): ModelMessage | undefined;
+export declare function environmentContextUpdate(current: EnvironmentContextState, previous?: EnvironmentContextState, contextualEntries?: readonly string[]): ModelMessage | undefined;

package/dist/runtime/environment-context.js

@@ -35,7 +35,7 @@ export function restoreEnvironmentState(payload) {
         ...(guaranteedCommands === undefined ? {} : { guaranteedCommands })
     };
 }
-export function environmentContextUpdate(current, previous) {
-    const content = buildEnvironmentContext(current, previous);
+export function environmentContextUpdate(current, previous, contextualEntries = []) {
+    const content = buildEnvironmentContext(current, previous, contextualEntries);
     return content ? { role: 'user', contextKind: 'environment', content } : undefined;
 }

package/dist/sdk/agent.js

@@ -21,6 +21,7 @@ import { buildEnvironmentContext } from '../prompts/core.js';
 import { modelOutputContinuationMessage } from '../prompts/output.js';
 import { retainedSessionResourcesSnapshot, retainedSessionResourcesUpdate } from '../prompts/resources.js';
 import { environmentContextUpdate, restoreEnvironmentState } from '../runtime/environment-context.js';
+import { executionBudgetEnvironmentEntry } from '../prompts/execution-budget.js';
 import { childSubagentInstruction } from '../prompts/subagent.js';
 import { sessionTitlePrompt } from '../prompts/title.js';
 import { loadAgentInstructions, renderAgentInstructions } from '../runtime/instructions.js';
@@ -28,6 +29,7 @@ import { normalizeMessagesForModel } from '../runtime/normalize.js';
 import { compactSummaryFromCheckpoint, replacementHistoryFromCheckpoint, JsonlSessionStore } from '../session/jsonl-store.js';
 import { TodoStore } from '../tools/todo.js';
 import { BUILTIN_TOOL_DEFINITIONS } from '../tools/registry.js';
+import { agentStartToolDefinitionWithModels } from '../tools/agent-start.js';
 import { executeRegisteredTool } from '../tools/runtime.js';
 import { scheduleToolCallBatch } from '../tools/scheduler.js';
 import { withCodeModeResultTypes } from '../tools/code-mode.js';
@@ -278,6 +280,20 @@ export async function createMarAgent(options) {
                         includeImages: mode !== 'compact'
                     });
                     const messages = restored.messages;
+                    let projectedExecutionBudgetStage;
+                    const appendExecutionBudgetEnvironment = () => {
+                        const currentStage = rolloutBudget?.active ? rolloutBudget.stage : 'inactive';
+                        if (currentStage === projectedExecutionBudgetStage)
+                            return;
+                        const previousStage = projectedExecutionBudgetStage;
+                        projectedExecutionBudgetStage = currentStage;
+                        if ((previousStage === undefined &&
+                            (currentStage === 'normal' || currentStage === 'inactive')) ||
+                            (currentStage === 'inactive' && previousStage === 'normal'))
+                            return;
+                        const entry = executionBudgetEnvironmentEntry(currentStage === 'normal' ? 'inactive' : currentStage);
+                        messages.push(environmentContextUpdate(currentEnvironment, currentEnvironment, [entry]));
+                    };
                     const appendMailboxMessages = async () => {
                         let appended = false;
                         while (mailbox.length > 0) {
@@ -440,7 +456,14 @@ export async function createMarAgent(options) {
                             : { claimExecutionScope: true })
                     })) ?? [];
                     const selectedModelForTools = executionModels.get(input.modelId ?? executionDefaultModelId);
-                    const availableTools = [...BUILTIN_TOOL_DEFINITIONS, ...mcpTools].filter((tool) => {
+                    const builtinTools = BUILTIN_TOOL_DEFINITIONS.map((tool) => tool.name === 'agent_start'
+                        ? agentStartToolDefinitionWithModels([...executionModels.values()].map((configuration) => ({
+                            id: configuration.id,
+                            name: configuration.name,
+                            reasoningEfforts: configuration.reasoningEfforts
+                        })))
+                        : tool);
+                    const availableTools = [...builtinTools, ...mcpTools].filter((tool) => {
                         if (sessionSource.type === 'subagent' && tool.agentScope === 'ROOT_ONLY')
                             return false;
                         if (sessionSource.type === 'subagent' &&
@@ -518,32 +541,7 @@ export async function createMarAgent(options) {
                             : {}),
                         workspace: logicalWorkspace,
                         tools: availableTools.map((tool) => tool.name),
-                        ...(sessionSource.type === 'user'
-                            ? {
-                                currentAgentModel: {
-                                    id: selectedModel.id,
-                                    name: selectedModel.name,
-                                    reasoningEffort
-                                }
-                            }
-                            : {}),
-                        subagentModels: sessionSource.type === 'user'
-                            ? [...executionModels.values()].map((configuration) => ({
-                                id: configuration.id,
-                                name: configuration.name,
-                                default: configuration.id === executionDefaultModelId,
-                                reasoningEfforts: configuration.reasoningEfforts
-                            }))
-                            : [],
                         highDensityCompaction: selectedModel.highDensityCompaction,
-                        ...(rolloutBudget?.active
-                            ? {
-                                executionBudget: {
-                                    stage: rolloutBudget.stage,
-                                    limitTokens: rolloutBudget.limitTokens
-                                }
-                            }
-                            : {}),
                         extension: [
                             options.systemInstruction,
                             instructionContext?.skillCatalog,
@@ -610,7 +608,7 @@ export async function createMarAgent(options) {
                         const current = messages.at(-1);
                         if (!current || messages.length < 2)
                             return false;
-                        const retainCurrent = current.role === 'user';
+                        const retainCurrent = current.role === 'user' && current.contextKind !== 'environment';
                         let compactSummary = '';
                         const compactSystemPrompt = buildExecutionSystemPrompt(executionTools, 'run');
                         const compactHistory = retainCurrent ? messages.slice(0, -1) : messages;
@@ -701,6 +699,7 @@ export async function createMarAgent(options) {
                         });
                         contextGc.reset();
                         messages.splice(0, messages.length, environmentContextUpdate(currentEnvironment), ...compactedHistoryMessages(replacementHistory));
+                        projectedExecutionBudgetStage = undefined;
                         compactionUserMessages = replacementHistory
                             .filter((message) => message.kind === 'user_input')
                             .map((message) => message.content);
@@ -735,6 +734,7 @@ export async function createMarAgent(options) {
                     const modelRetryState = { attempts: 0 };
                     while (true) {
                         await appendMailboxMessages();
+                        appendExecutionBudgetEnvironment();
                         let stop;
                         let sawTool = false;
                         let latestUsage;
@@ -742,6 +742,7 @@ export async function createMarAgent(options) {
                         const pendingTools = [];
                         let incompleteToolCall = false;
                         await ensureContextBudget();
+                        appendExecutionBudgetEnvironment();
                         const toolsAllowed = mode !== 'compact' && (!rolloutBudget?.active || rolloutBudget.stage !== 'exhausted');
                         const roundTools = mode === 'compact' ? executionTools : toolsAllowed ? executionTools : [];
                         const systemPrompt = mode === 'compact'
@@ -1158,6 +1159,7 @@ export async function createMarAgent(options) {
                                     projection: committed.projection
                                 });
                                 messages.splice(0, messages.length, ...refreshed.messages);
+                                projectedExecutionBudgetStage = undefined;
                                 compactionUserMessages = [...refreshed.userMessages];
                                 agentInstructionInsertIndex =
                                     refreshed.currentTurnUserIndex ?? Math.max(0, messages.length - 1);
@@ -1791,7 +1793,8 @@ function appendOnlyUsageDelta(usage, historyMessages) {
     const toolCallIds = new Set(usage.historyMessages
         .filter((message) => message.role === 'tool_call')
         .map((message) => message.callId));
-    return appended.every((message) => message.role === 'tool' && toolCallIds.has(message.callId))
+    return appended.every((message) => (message.role === 'tool' && toolCallIds.has(message.callId)) ||
+        (message.role === 'user' && message.contextKind === 'environment'))
         ? appended
         : undefined;
 }

package/dist/tools/agent-start.d.ts

@@ -1,6 +1,11 @@
 import type { ClientToolDefinition } from '../model/contracts.js';
 import type { ToolRuntimeContext } from './runtime-context.js';
 export declare const agentStartToolDefinition: ClientToolDefinition;
+export declare function agentStartToolDefinitionWithModels(models: readonly {
+    readonly id: string;
+    readonly name: string;
+    readonly reasoningEfforts: readonly string[];
+}[]): ClientToolDefinition;
 export declare function executeAgentStart(arguments_: unknown, context: ToolRuntimeContext): Promise<{
     content: string;
     data: import("../subagent/scheduler.js").SubagentTaskSnapshot;

package/dist/tools/agent-start.js

@@ -27,6 +27,25 @@ export const agentStartToolDefinition = {
         additionalProperties: false
     }
 };
+export function agentStartToolDefinitionWithModels(models) {
+    if (models.length === 0)
+        return agentStartToolDefinition;
+    const modelLines = models.map((model) => {
+        const efforts = model.reasoningEfforts.length === 0
+            ? ''
+            : `; reasoning efforts: ${model.reasoningEfforts.join(', ')}`;
+        return `- ${JSON.stringify(model.id)} (${JSON.stringify(model.name)}${efforts})`;
+    });
+    return {
+        ...agentStartToolDefinition,
+        description: [
+            agentStartToolDefinition.description,
+            'The optional modelId may select an enabled model below. Omit modelId to use the current agent model. Only use a listed reasoning effort for the selected model.',
+            'Enabled subagent models:',
+            ...modelLines
+        ].join('\n')
+    };
+}
 export async function executeAgentStart(arguments_, context) {
     const value = parseAgentStartInput(arguments_);
     if (!context.subagents)

package/package.json

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