@myagentroam/agent 0.9.95 → 0.9.97

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,6 @@
 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.53";
 export declare function buildSystemPrompt(input: {
     mode: ExecutionMode;
     platform: string;
@@ -15,7 +14,6 @@ export declare function buildSystemPrompt(input: {
     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 { interactionPrompt, longRunningPrompt, safetyPrompt, toolUsagePrompt, workflowPrompt } from './workflow.js';
-export const MAR_AGENT_PROMPT_VERSION = '1.52';
+export const MAR_AGENT_PROMPT_VERSION = '1.53';
 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

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/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';
@@ -278,6 +279,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) {
@@ -536,14 +551,6 @@ export async function createMarAgent(options) {
                             }))
                             : [],
                         highDensityCompaction: selectedModel.highDensityCompaction,
-                        ...(rolloutBudget?.active
-                            ? {
-                                executionBudget: {
-                                    stage: rolloutBudget.stage,
-                                    limitTokens: rolloutBudget.limitTokens
-                                }
-                            }
-                            : {}),
                         extension: [
                             options.systemInstruction,
                             instructionContext?.skillCatalog,
@@ -576,8 +583,7 @@ export async function createMarAgent(options) {
                             estimatedRequestTokens: estimatedRequestTokens(compactSystemPrompt, nativeMessages, executionTools),
                             contextWindowTokens: selectedModel.contextWindowTokens,
                             latestUsage: lastServerUsage,
-                            usageMatchesHistory: lastServerUsage?.historyMessageCount === undefined ||
-                                lastServerUsage.historyMessageCount === compactHistory.length,
+                            historyMessages: compactHistory,
                             appendedMessages: nativeMessages.slice(projectedHistory.length)
                         });
                         messages.splice(0, messages.length, ...(useNative ? nativeMessages : fallbackMessages()));
@@ -611,7 +617,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;
@@ -627,8 +633,7 @@ export async function createMarAgent(options) {
                             estimatedRequestTokens: estimatedRequestTokens(compactSystemPrompt, nativeCompactMessages, executionTools),
                             contextWindowTokens: selectedModel.contextWindowTokens,
                             latestUsage: lastServerUsage,
-                            usageMatchesHistory: lastServerUsage?.historyMessageCount === undefined ||
-                                lastServerUsage.historyMessageCount === compactHistory.length,
+                            historyMessages: compactHistory,
                             appendedMessages: nativeCompactMessages.slice(projectedHistory.length)
                         });
                         const fallbackMessages = () => buildCompactionMessages(buildCompactionInput(compactHistory, {
@@ -703,6 +708,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);
@@ -737,12 +743,15 @@ export async function createMarAgent(options) {
                     const modelRetryState = { attempts: 0 };
                     while (true) {
                         await appendMailboxMessages();
+                        appendExecutionBudgetEnvironment();
                         let stop;
                         let sawTool = false;
                         let latestUsage;
+                        let roundServerUsage;
                         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'
@@ -885,14 +894,13 @@ export async function createMarAgent(options) {
                                         Number.isSafeInteger(reportedContext) &&
                                         reportedContext >= 0) {
                                         lastServerContextTokens = reportedContext;
-                                        lastServerUsage = {
+                                        roundServerUsage = {
                                             contextInputTokens: reportedContext,
                                             outputTokens: typeof event.usage.outputTokens === 'number' &&
                                                 Number.isSafeInteger(event.usage.outputTokens) &&
                                                 event.usage.outputTokens >= 0
                                                 ? event.usage.outputTokens
-                                                : undefined,
-                                            historyMessageCount: messages.length
+                                                : undefined
                                         };
                                     }
                                     await emit({ type: 'usage.updated', ...publicModelUsage(event.usage) });
@@ -973,6 +981,11 @@ export async function createMarAgent(options) {
                                 throw error;
                         }
                         recoveringFromContextOverflow = false;
+                        if (roundServerUsage !== undefined)
+                            lastServerUsage = {
+                                ...roundServerUsage,
+                                historyMessages: [...messages]
+                            };
                         if (pendingTools.length === 0 && mailbox.length > 0) {
                             await appendMailboxMessages();
                             finalAnswer = '';
@@ -1155,6 +1168,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);
@@ -1705,22 +1719,50 @@ function currentExecutionImages(modelInputImages, toolImages) {
 }
 function latestModelUsage(records, selectedModelId) {
     let usage;
+    const toolCallIds = new Set();
     // readContext starts at compact.completed, whose execution header is before the boundary.
     let activeModelId = selectedModelId;
     for (const record of records) {
         const payload = record.payload;
         if (compactSummaryFromCheckpoint(record) !== undefined) {
             usage = undefined;
+            toolCallIds.clear();
             activeModelId = modelIdFromPayload(payload);
             continue;
         }
         if (record.type === 'execution.header') {
             activeModelId = modelIdFromPayload(payload);
             usage = undefined;
+            toolCallIds.clear();
             continue;
         }
-        if (usage !== undefined && invalidatesUsageCalibration(record.type, payload.type))
-            usage = undefined;
+        if (record.type === 'model.context' && payload.role === 'tool_call') {
+            if (typeof payload.callId === 'string' && payload.callId.length > 0)
+                toolCallIds.add(payload.callId);
+            else
+                usage = undefined;
+        }
+        if (usage !== undefined) {
+            if (record.type === 'model.context') {
+                const role = payload.role;
+                if (role === 'tool') {
+                    if (typeof payload.callId !== 'string' || !toolCallIds.has(payload.callId))
+                        usage = undefined;
+                    else
+                        usage = {
+                            ...usage,
+                            appendedMessages: [
+                                ...(usage.appendedMessages ?? []),
+                                payload
+                            ]
+                        };
+                }
+                else if (role !== 'tool_call' && role !== 'assistant' && role !== 'provider')
+                    usage = undefined;
+            }
+            else if (invalidatesUsageCalibration(record.type, payload.type))
+                usage = undefined;
+        }
         if (payload.type === 'usage.updated' && activeModelId === selectedModelId) {
             const value = payload.contextInputTokens ?? payload.inputTokens;
             if (typeof value === 'number' && Number.isSafeInteger(value) && value >= 0)
@@ -1739,20 +1781,38 @@ function latestModelUsage(records, selectedModelId) {
 function shouldUseNativeCompaction(input) {
     if (input.estimatedRequestTokens <= input.contextWindowTokens)
         return true;
-    if (input.latestUsage === undefined ||
-        input.latestUsage.outputTokens === undefined ||
-        !input.usageMatchesHistory)
+    if (input.latestUsage === undefined || input.latestUsage.outputTokens === undefined)
+        return false;
+    const historyDelta = appendOnlyUsageDelta(input.latestUsage, input.historyMessages);
+    if (historyDelta === undefined)
         return false;
-    const appendedTokens = countModelTokens(stableJson(input.appendedMessages));
+    const appendedTokens = countModelTokens(stableJson([...historyDelta, ...input.appendedMessages]));
     return (input.latestUsage.contextInputTokens + input.latestUsage.outputTokens + appendedTokens <=
         input.contextWindowTokens);
 }
+function appendOnlyUsageDelta(usage, historyMessages) {
+    if (usage.historyMessages === undefined)
+        return usage.appendedMessages ?? [];
+    if (historyMessages.length < usage.historyMessages.length)
+        return undefined;
+    for (let index = 0; index < usage.historyMessages.length; index++)
+        if (!isDeepStrictEqual(usage.historyMessages[index], historyMessages[index]))
+            return undefined;
+    const appended = historyMessages.slice(usage.historyMessages.length);
+    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)) ||
+        (message.role === 'user' && message.contextKind === 'environment'))
+        ? appended
+        : undefined;
+}
 function invalidatesUsageCalibration(recordType, payloadType) {
-    if (recordType === 'turn.user' || recordType === 'context.environment')
+    if (recordType === 'turn.user' ||
+        recordType === 'context.environment' ||
+        recordType === 'context.gc.completed')
         return true;
-    return (payloadType === 'message.completed' ||
-        payloadType === 'tool.completed' ||
-        payloadType === 'tool.failed');
+    return payloadType === 'message.completed';
 }
 const PROVIDER_CONTEXT_OVERFLOW_CODES = new Set([
     'mar_agent_context_limit',

package/package.json

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