@myagentroam/agent 0.9.163 → 0.9.165

package/dist/agent-core/host/local-process-executor.d.ts

@@ -4,9 +4,11 @@ export interface LocalProcessSpawnRequest {
     readonly args?: readonly string[];
     readonly cwd: string;
     readonly shell?: boolean | string;
+    /** Shell startup for exec only; native processes and workers omit this field. */
+    readonly shellLogin?: boolean;
     readonly environment: NodeJS.ProcessEnv;
     /** Explicit per-start values take precedence over execution-bound Host environment. */
-    readonly environmentOverrides?: Readonly<Record<string, string>>;
+    readonly environmentOverrides?: Readonly<Record<string, string | undefined>>;
     readonly environmentKeys?: readonly string[];
     /** Trusted, bounded read-only worker assets; never supplied by model tool input. */
     readonly runtimeDirectories?: readonly string[];

package/dist/agent-core/host/local-process-executor.js

@@ -1,7 +1,9 @@
 import { spawn } from 'node:child_process';
+import { prepareLocalShellProcess } from './local-shell.js';
 /** Preserves the direct local execution behavior used by the CLI and normal Node Workbench. */
 export const directLocalProcessExecutor = {
     async spawn(request) {
+        request = prepareLocalShellProcess(request);
         return spawn(request.command, [...(request.args ?? [])], {
             cwd: request.cwd,
             shell: request.shell ?? false,

package/dist/agent-core/host/local-session-environment.js

@@ -50,12 +50,22 @@ export class LocalSessionEnvironment {
             (this.platform !== 'win32' || request.environmentOverrides === undefined))
             return request;
         const environment = { ...request.environment };
+        const overrides = {};
         const assign = (key, value) => {
             if (this.platform === 'win32') {
                 for (const current of Object.keys(environment))
                     if (this.#key(current) === this.#key(key))
                         delete environment[current];
+                for (const current of Object.keys(overrides))
+                    if (this.#key(current) === this.#key(key))
+                        delete overrides[current];
             }
+            Object.defineProperty(overrides, key, {
+                value,
+                enumerable: true,
+                writable: true,
+                configurable: true
+            });
             if (value === undefined)
                 delete environment[key];
             else
@@ -75,6 +85,7 @@ export class LocalSessionEnvironment {
         return {
             ...request,
             environment,
+            environmentOverrides: overrides,
             ...(request.environmentKeys === undefined
                 ? {}
                 : {

package/dist/agent-core/host/local-shell.d.ts

@@ -0,0 +1,3 @@
+import type { LocalProcessSpawnRequest } from './local-process-executor.js';
+/** Resolve Shell startup in the executor, after its environment policy has been applied. */
+export declare function prepareLocalShellProcess(request: LocalProcessSpawnRequest, platform?: NodeJS.Platform): LocalProcessSpawnRequest;

package/dist/agent-core/host/local-shell.js

@@ -0,0 +1,78 @@
+import { randomUUID } from 'node:crypto';
+import { basename, win32 } from 'node:path';
+/** Resolve Shell startup in the executor, after its environment policy has been applied. */
+export function prepareLocalShellProcess(request, platform = process.platform) {
+    if (!request.shell || request.shellLogin === undefined)
+        return request;
+    const shell = typeof request.shell === 'string'
+        ? request.shell
+        : platform === 'win32'
+            ? (request.environment.ComSpec ?? request.environment.COMSPEC ?? 'cmd.exe')
+            : '/bin/sh';
+    const name = (platform === 'win32' ? win32.basename(shell) : basename(shell))
+        .replace(/\.exe$/iu, '')
+        .toLowerCase();
+    const powershell = name === 'pwsh' || name === 'powershell';
+    if (!powershell && !['bash', 'zsh', 'sh'].includes(name))
+        return request;
+    const login = request.shellLogin;
+    const environment = { ...request.environment };
+    const script = [];
+    if (login && name === 'bash') {
+        script.push('if [ -z "${BASH_ENV-}" ] && [ -n "${HOME-}" ] && [ -r "$HOME/.bashrc" ]; then', '  . "$HOME/.bashrc"', 'fi');
+    }
+    else if (login && name === 'zsh') {
+        script.push('if [[ -n "${ZDOTDIR-}" ]]; then', '  [[ ! -r "$ZDOTDIR/.zshrc" ]] || . "$ZDOTDIR/.zshrc"', 'elif [[ -n "${HOME-}" ]]; then', '  [[ ! -r "$HOME/.zshrc" ]] || . "$HOME/.zshrc"', 'fi');
+    }
+    // Keep values out of argv and tool-visible command history, including quoting-sensitive values.
+    const privatePrefix = `__MAR_SHELL_${randomUUID().replaceAll('-', '')}_`;
+    const restoration = [];
+    let index = 0;
+    for (const [key, value] of Object.entries(request.environmentOverrides ?? {})) {
+        if (!powershell && !/^[A-Za-z_][A-Za-z0-9_]*$/u.test(key))
+            continue;
+        const quotedKey = `'${key.replaceAll("'", "''")}'`;
+        if (value === undefined) {
+            restoration.push(powershell
+                ? `[Environment]::SetEnvironmentVariable(${quotedKey}, $null, 'Process')`
+                : `if [ "\${${key}+x}" = x ]; then unset ${key} || exit; fi`);
+            continue;
+        }
+        const privateKey = `${privatePrefix}${index++}`;
+        environment[privateKey] = value;
+        restoration.push(powershell
+            ? `if (-not (Test-Path Env:${privateKey})) { throw 'Shell startup removed a protected environment value.' }`
+            : `[ "\${${privateKey}+x}" = x ] || { printf '%s\\n' 'Shell startup removed a protected environment value.' >&2; exit 1; }`);
+        restoration.push(powershell
+            ? `[Environment]::SetEnvironmentVariable(${quotedKey}, $env:${privateKey}, 'Process'); Remove-Item Env:${privateKey}`
+            : `if [ "\${${key}+x}" != x ] || [ "\${${key}-}" != "\$${privateKey}" ]; then export ${key}="\$${privateKey}" || exit; else export ${key} || exit; fi; unset ${privateKey}`);
+    }
+    if (restoration.length && !powershell) {
+        const traceKey = `${privatePrefix}TRACE`;
+        // A profile may enable xtrace; do not print expanded private values during restoration.
+        script.push(`case $- in *x*) set +x; ${traceKey}=1 ;; *) ${traceKey}= ;; esac`, ...restoration, `if [ "\$${traceKey}" = 1 ]; then unset ${traceKey}; set -x; else unset ${traceKey}; fi`);
+    }
+    else {
+        script.push(...restoration);
+    }
+    script.push(request.command);
+    return {
+        ...request,
+        command: shell,
+        args: [
+            ...(powershell ? [...(login ? [] : ['-NoProfile']), '-Command'] : [login ? '-lc' : '-c']),
+            script.join('\n'),
+            ...(request.args ?? [])
+        ],
+        shell: false,
+        environment,
+        ...(request.environmentKeys === undefined
+            ? {}
+            : {
+                environmentKeys: [
+                    ...request.environmentKeys,
+                    ...Object.keys(environment).filter((key) => key.startsWith(privatePrefix))
+                ]
+            })
+    };
+}

package/dist/agent-core/runtime/context/gc.js

@@ -1,5 +1,3 @@
-import { countModelTokens } from '../token-budget.js';
-import { renderObservations } from '../../tools/code-mode/observations.js';
 import { codeCallEvidence, codeObservationEvidence, retainedCodeInputs } from '../../session/context-gc-observations.js';
 import { ContextGcCheckpointCache, contextGcBaseFromRecords, contextGcLogicalPathKey, contextGcMinimumUsageGrowth, contextGcRecordSourceHash, contextGcTargetKey, normalizeContextGcReplacements } from '../../session/context-gc-checkpoint.js';
 import { codeCellCompletionSequence, contextGcApplyPatchInputReplacement, contextGcCodeModeInputReplacement, contextGcCodeModeOutputReplacement, contextGcExecInputReplacement, contextGcExecOutputReplacement, contextGcPatchResultFromCompletedPayload, contextGcStaleReadReplacement, contextGcWebOutputReplacement, normalizeContextGcCodeModeInput, normalizeContextGcExecResult } from '../../session/context-gc-replacements.js';
@@ -30,8 +28,6 @@ const MINIMUM_CONTEXT_WINDOW_REDUCTION_RATIO = 0.05;
 const COMPACT_CREDIT_ACTIVATION_RATIO = 0.8;
 const COMPACT_THRESHOLD_RATIO = 0.9;
 const IMMINENT_COMPACT_CREDIT_DISCOUNT = 0.8;
-const LARGE_TERMINAL_OUTPUT_TOKENS = 4_096;
-const HIGH_WATER_LARGE_TERMINAL_OUTPUT_TOKENS = 2_048;
 export function evaluateContextGcEconomics(input) {
     const reclaimedTokens = Math.max(0, input.reclaimedTokens);
     const cacheReadTokens = Math.max(0, input.cacheReadTokens);
@@ -150,14 +146,15 @@ export function inspectContextGc(input) {
         return {};
     const groups = buildToolGroups(input.records, input.messages, input.messageSources);
     const existing = previous?.payload.replacements ?? [];
+    const candidateSavings = createCandidateSavingsEstimator(input, existing);
     const existingTargets = new Set(existing.flatMap((replacement) => [
         contextGcTargetKey(replacement.target),
         ...(replacement.kind === 'TOOL_CALL_INPUT'
             ? replacement.providerAliasTargets.map(contextGcTargetKey)
             : [])
     ]));
-    const stageA = collectStageACandidates(input, groups, existing, existingTargets);
-    const subagent = collectSubagentCandidates(input, groups, existingTargets);
+    const stageA = collectStageACandidates(input, groups, existing, existingTargets, candidateSavings);
+    const subagent = collectSubagentCandidates(input, groups, existingTargets, candidateSavings);
     const deterministicCandidates = [...stageA.eligible, ...subagent.eligible];
     const deterministicProtectedTokens = stageA.protectedTokens + subagent.protectedTokens;
     const stageAPlan = evaluateCandidateSet(input, existing, deterministicCandidates, {
@@ -169,9 +166,9 @@ export function inspectContextGc(input) {
         protectedCandidateTokens: deterministicProtectedTokens
     });
     if (stageAPlan?.economics.passes) {
-        const exec = collectExecCandidates(input, groups, existingTargets, usageRatio);
-        const codeMode = collectCodeModeCandidates(input, groups, existingTargets, usageRatio);
-        const web = collectWebCandidates(input, groups, existingTargets, usageRatio);
+        const exec = collectExecCandidates(input, groups, existingTargets, candidateSavings);
+        const codeMode = collectCodeModeCandidates(input, groups, existingTargets, candidateSavings);
+        const web = collectWebCandidates(input, groups, existingTargets, candidateSavings);
         const protectedCandidateTokens = deterministicProtectedTokens +
             exec.protectedTokens +
             codeMode.protectedTokens +
@@ -202,9 +199,9 @@ export function inspectContextGc(input) {
             }
             : {};
     }
-    const exec = collectExecCandidates(input, groups, existingTargets, usageRatio);
-    const codeMode = collectCodeModeCandidates(input, groups, existingTargets, usageRatio);
-    const web = collectWebCandidates(input, groups, existingTargets, usageRatio);
+    const exec = collectExecCandidates(input, groups, existingTargets, candidateSavings);
+    const codeMode = collectCodeModeCandidates(input, groups, existingTargets, candidateSavings);
+    const web = collectWebCandidates(input, groups, existingTargets, candidateSavings);
     const combined = evaluateCandidateSet(input, existing, [...deterministicCandidates, ...exec.eligible, ...codeMode.eligible, ...web.eligible], {
         stage: 'STAGE_A_AND_EXEC',
         contextUsageTokens,
@@ -230,7 +227,7 @@ export function inspectContextGc(input) {
         ? { retryAfterRollouts }
         : {};
 }
-function collectCodeModeCandidates(input, groups, existingTargets, usageRatio) {
+function collectCodeModeCandidates(input, groups, existingTargets, candidateSavings) {
     const eligible = [];
     let protectedTokens = 0;
     let retryAfterRollouts = Infinity;
@@ -251,19 +248,8 @@ function collectCodeModeCandidates(input, groups, existingTargets, usageRatio) {
             !isRecord(completedPayload) ||
             typeof completedPayload.truncated !== 'boolean')
             continue;
-        const visibleTokens = contextGcMessageTokens(input, [
-            group.call.message,
-            group.result.message,
-            ...group.aliases.map((alias) => alias.message)
-        ]);
-        const minimumVisibleTokens = usageRatio >= COMPACT_CREDIT_ACTIVATION_RATIO
-            ? HIGH_WATER_LARGE_TERMINAL_OUTPUT_TOKENS
-            : LARGE_TERMINAL_OUTPUT_TOKENS;
-        if (visibleTokens < minimumVisibleTokens)
-            continue;
         for (const observation of group.result.message.observations ?? []) {
-            if (observation.type !== 'value' ||
-                countModelTokens(observation.value) < minimumVisibleTokens)
+            if (observation.type !== 'value')
                 continue;
             const target = targetFor(group.result.record, {
                 ...group.result.message,
@@ -285,10 +271,13 @@ function collectCodeModeCandidates(input, groups, existingTargets, usageRatio) {
                 observedRollouts: successfulRolloutsAfter(input.records, Math.max(evidenceSequence, completionSequence), input.modelId, input.contextWindowTokens),
                 evidenceSequence
             };
+            const reclaimedTokens = candidateSavings(candidate);
+            if (reclaimedTokens <= 0)
+                continue;
             if (candidate.observedRollouts >= CONTEXT_GC_POLICY.largeExecProtectionRollouts)
                 eligible.push(candidate);
             else {
-                protectedTokens += candidateTokens(input, candidate);
+                protectedTokens += reclaimedTokens;
                 retryAfterRollouts = Math.min(retryAfterRollouts, CONTEXT_GC_POLICY.largeExecProtectionRollouts - candidate.observedRollouts);
             }
         }
@@ -323,10 +312,13 @@ function collectCodeModeCandidates(input, groups, existingTargets, usageRatio) {
             continue;
         const observedRollouts = successfulRolloutsAfter(input.records, Math.max(evidenceSequence, completionSequence), input.modelId, input.contextWindowTokens);
         const candidate = { replacements, observedRollouts, evidenceSequence };
+        const reclaimedTokens = candidateSavings(candidate);
+        if (reclaimedTokens <= 0)
+            continue;
         if (observedRollouts >= CONTEXT_GC_POLICY.largeExecProtectionRollouts)
             eligible.push(candidate);
         else {
-            protectedTokens += candidateTokens(input, candidate);
+            protectedTokens += reclaimedTokens;
             retryAfterRollouts = Math.min(retryAfterRollouts, CONTEXT_GC_POLICY.largeExecProtectionRollouts - observedRollouts);
         }
     }
@@ -528,7 +520,7 @@ function evaluateCandidateSet(input, existing, candidates, state) {
         eligibleCandidateCount: candidates.length
     };
 }
-function collectStageACandidates(input, groups, existingReplacements, existingTargets) {
+function collectStageACandidates(input, groups, existingReplacements, existingTargets, candidateSavings) {
     const eligible = [];
     let protectedTokens = 0;
     let retryAfterRollouts = Infinity;
@@ -555,6 +547,7 @@ function collectStageACandidates(input, groups, existingReplacements, existingTa
         const patchCall = patch.call;
         const observedRollouts = successfulRolloutsAfter(input.records, evidenceSequence, input.modelId, input.contextWindowTokens);
         const replacements = [];
+        const candidateReadItems = new Set();
         const patchTarget = targetFor(patchCall.record, patchCall.message);
         if (patchTarget && !existingTargets.has(contextGcTargetKey(patchTarget)))
             replacements.push({
@@ -578,14 +571,14 @@ function collectStageACandidates(input, groups, existingReplacements, existingTa
                 if (item.pathTruncated)
                     return [];
                 const itemKey = `${read.result.record.recordId}:${read.result.message.observationId ?? ''}:${item.index}`;
-                if (claimedReadItems.has(itemKey))
+                if (claimedReadItems.has(itemKey) || candidateReadItems.has(itemKey))
                     return [];
                 const pathKey = contextGcLogicalPathKey(item.path, input.workspace, input.platform);
                 const matched = result.files.find((file) => file.operation !== 'added' &&
                     contextGcLogicalPathKey(file.path, input.workspace, input.platform) === pathKey);
                 if (!pathKey || !matched || matched.operation === 'added')
                     return [];
-                claimedReadItems.add(itemKey);
+                candidateReadItems.add(itemKey);
                 return [
                     {
                         index: item.index,
@@ -625,16 +618,21 @@ function collectStageACandidates(input, groups, existingReplacements, existingTa
             observedRollouts,
             evidenceSequence
         };
+        const reclaimedTokens = candidateSavings(candidate);
+        if (reclaimedTokens <= 0)
+            continue;
+        for (const itemKey of candidateReadItems)
+            claimedReadItems.add(itemKey);
         if (observedRollouts >= CONTEXT_GC_POLICY.stageAProtectionRollouts)
             eligible.push(candidate);
         else {
-            protectedTokens += candidateTokens(input, candidate);
+            protectedTokens += reclaimedTokens;
             retryAfterRollouts = Math.min(retryAfterRollouts, CONTEXT_GC_POLICY.stageAProtectionRollouts - observedRollouts);
         }
     }
     return { eligible, protectedTokens, retryAfterRollouts };
 }
-function collectSubagentCandidates(input, groups, existingTargets) {
+function collectSubagentCandidates(input, groups, existingTargets, candidateSavings) {
     const eligible = [];
     let protectedTokens = 0;
     let retryAfterRollouts = Infinity;
@@ -714,16 +712,19 @@ function collectSubagentCandidates(input, groups, existingTargets) {
             observedRollouts,
             evidenceSequence
         };
+        const reclaimedTokens = candidateSavings(candidate);
+        if (reclaimedTokens <= 0)
+            continue;
         if (observedRollouts >= CONTEXT_GC_POLICY.stageAProtectionRollouts)
             eligible.push(candidate);
         else {
-            protectedTokens += candidateTokens(input, candidate);
+            protectedTokens += reclaimedTokens;
             retryAfterRollouts = Math.min(retryAfterRollouts, CONTEXT_GC_POLICY.stageAProtectionRollouts - observedRollouts);
         }
     }
     return { eligible, protectedTokens, retryAfterRollouts };
 }
-function collectExecCandidates(input, groups, existingTargets, usageRatio) {
+function collectExecCandidates(input, groups, existingTargets, candidateSavings) {
     const eligible = [];
     let protectedTokens = 0;
     let retryAfterRollouts = Infinity;
@@ -797,18 +798,6 @@ function collectExecCandidates(input, groups, existingTargets, usageRatio) {
         if (!terminal || (processId && input.activeProcessIds.has(processId)))
             continue;
         const final = lifecycle.at(-1);
-        const visibleTokens = contextGcMessageTokens(input, lifecycle
-            .filter((invocation) => !invocation.group.evidenceOnly)
-            .flatMap((invocation) => [
-            invocation.group.call.message,
-            invocation.group.result.message,
-            ...invocation.group.aliases.map((alias) => alias.message)
-        ]));
-        const minimumVisibleTokens = usageRatio >= COMPACT_CREDIT_ACTIVATION_RATIO
-            ? HIGH_WATER_LARGE_TERMINAL_OUTPUT_TOKENS
-            : LARGE_TERMINAL_OUTPUT_TOKENS;
-        if (visibleTokens < minimumVisibleTokens)
-            continue;
         const evidenceSequence = final.group.result.record.sequence;
         const observedRollouts = successfulRolloutsAfter(input.records, evidenceSequence, input.modelId, input.contextWindowTokens);
         const replacements = [];
@@ -850,22 +839,22 @@ function collectExecCandidates(input, groups, existingTargets, usageRatio) {
             observedRollouts,
             evidenceSequence
         };
+        const reclaimedTokens = candidateSavings(candidate);
+        if (reclaimedTokens <= 0)
+            continue;
         if (observedRollouts >= CONTEXT_GC_POLICY.largeExecProtectionRollouts)
             eligible.push(candidate);
         else {
-            protectedTokens += candidateTokens(input, candidate);
+            protectedTokens += reclaimedTokens;
             retryAfterRollouts = Math.min(retryAfterRollouts, CONTEXT_GC_POLICY.largeExecProtectionRollouts - observedRollouts);
         }
     }
     return { eligible, protectedTokens, retryAfterRollouts };
 }
-function collectWebCandidates(input, groups, existingTargets, usageRatio) {
+function collectWebCandidates(input, groups, existingTargets, candidateSavings) {
     const eligible = [];
     let protectedTokens = 0;
     let retryAfterRollouts = Infinity;
-    const minimumVisibleTokens = usageRatio >= COMPACT_CREDIT_ACTIVATION_RATIO
-        ? HIGH_WATER_LARGE_TERMINAL_OUTPUT_TOKENS
-        : LARGE_TERMINAL_OUTPUT_TOKENS;
     for (const group of [...groups.values()].sort((left, right) => (left.result?.record.sequence ?? Number.MAX_SAFE_INTEGER) -
         (right.result?.record.sequence ?? Number.MAX_SAFE_INTEGER))) {
         if (!isContextGcWebToolName(group.toolName) ||
@@ -885,9 +874,6 @@ function collectWebCandidates(input, groups, existingTargets, usageRatio) {
         const target = targetFor(group.result.record, group.result.message);
         if (!target || existingTargets.has(contextGcTargetKey(target)))
             continue;
-        const visibleTokens = contextGcMessageTokens(input, [group.result.message]);
-        if (visibleTokens < minimumVisibleTokens)
-            continue;
         const evidenceSequence = group.result.record.sequence;
         const observedRollouts = successfulRolloutsAfter(input.records, evidenceSequence, input.modelId, input.contextWindowTokens);
         const candidate = {
@@ -904,10 +890,13 @@ function collectWebCandidates(input, groups, existingTargets, usageRatio) {
             observedRollouts,
             evidenceSequence
         };
+        const reclaimedTokens = candidateSavings(candidate);
+        if (reclaimedTokens <= 0)
+            continue;
         if (observedRollouts >= CONTEXT_GC_POLICY.largeExecProtectionRollouts)
             eligible.push(candidate);
         else {
-            protectedTokens += candidateTokens(input, candidate);
+            protectedTokens += reclaimedTokens;
             retryAfterRollouts = Math.min(retryAfterRollouts, CONTEXT_GC_POLICY.largeExecProtectionRollouts - observedRollouts);
         }
     }
@@ -1230,23 +1219,46 @@ function firstMatchingUsageAfter(records, sequence, modelId, contextWindowTokens
     }
     return undefined;
 }
-function candidateTokens(input, candidate) {
-    const targets = new Set(candidate.replacements.flatMap((replacement) => [
-        contextGcTargetKey(replacement.target),
-        ...(replacement.kind === 'TOOL_CALL_INPUT'
-            ? replacement.providerAliasTargets.map(contextGcTargetKey)
-            : [])
-    ]));
-    return contextGcMessageTokens(input, input.messages.flatMap((message, index) => {
-        const target = targetFor(input.messageSources[index], message);
-        if (target && targets.has(contextGcTargetKey(target)))
-            return [message];
-        const selected = target &&
-            message.observations?.filter((value) => targets.has(contextGcTargetKey({ ...target, observationId: value.id })));
-        return selected?.length
-            ? [{ ...message, observations: selected, content: renderObservations(selected) }]
-            : [];
-    }));
+/** Measure only affected call families, retaining native aliases for provider lowering. */
+function createCandidateSavingsEstimator(input, existing) {
+    const byCall = new Map();
+    const byRecord = new Map();
+    for (const [index, message] of input.messages.entries()) {
+        const callId = message.role === 'provider' ? providerToolCallId(message) : message.callId;
+        if (callId) {
+            const indices = byCall.get(callId) ?? [];
+            indices.push(index);
+            byCall.set(callId, indices);
+        }
+        const recordId = input.messageSources[index].recordId;
+        const indices = byRecord.get(recordId) ?? [];
+        indices.push(index);
+        byRecord.set(recordId, indices);
+    }
+    return (candidate) => {
+        const indices = new Set();
+        for (const replacement of candidate.replacements) {
+            const targets = [
+                replacement.target,
+                ...(replacement.kind === 'TOOL_CALL_INPUT' ? replacement.providerAliasTargets : [])
+            ];
+            for (const target of targets) {
+                for (const index of byRecord.get(target.recordId) ?? [])
+                    indices.add(index);
+                if (target.callId)
+                    for (const index of byCall.get(target.callId) ?? [])
+                        indices.add(index);
+            }
+        }
+        const ordered = [...indices].sort((a, b) => a - b);
+        const messages = ordered.map((index) => input.messages[index]);
+        const sources = ordered.map((index) => input.messageSources[index]);
+        const replacements = normalizeContextGcReplacements([...existing, ...candidate.replacements]);
+        if (!replacements)
+            return 0;
+        const projected = applyContextGcReplacementsToMessages(messages, sources, replacements);
+        return contextGcReclaimedTokens(input, messages, projected.messages);
+    };
 }
 function targetFor(record, message) {
     if (record.type !== 'model.context' ||

package/dist/agent-core/runtime/context/projection.js

@@ -272,7 +272,9 @@ function targetFromMessage(record, message) {
     };
 }
 function targetMatchesReplacement(left, right) {
-    return (contextGcTargetKey(left) === contextGcTargetKey(right) && left.sourceHash === right.sourceHash);
+    return (contextGcTargetKey(left) === contextGcTargetKey(right) &&
+        left.sourceHash === right.sourceHash &&
+        (right.toolName === undefined || right.toolName === left.toolName));
 }
 function cloneMessage(message) {
     return structuredClone(message);

package/dist/agent-core/session/context-gc-checkpoint.js

@@ -58,7 +58,8 @@ export function contextGcLogicalPathKey(path, workspace, platform) {
     return resolved;
 }
 export function contextGcTargetKey(target) {
-    return `${target.sequence}:${target.recordId}:${target.role}:${target.callId ?? ''}:${target.toolName ?? ''}${target.observationId ? `:${target.observationId}` : ''}`;
+    // Tool outputs are identified by their record/call and observation, not optional tool-name metadata.
+    return `${target.sequence}:${target.recordId}:${target.role}:${target.callId ?? ''}:${target.role === 'tool' ? '' : (target.toolName ?? '')}${target.observationId ? `:${target.observationId}` : ''}`;
 }
 export function contextGcReplacementKey(replacement) {
     return contextGcTargetKey(replacement.target);

package/dist/agent-core/tools/agent/todo-read.js

@@ -2,7 +2,7 @@ export const todoReadToolDefinition = {
     name: 'todo_read',
     allowedCallers: ['direct', 'programmatic'],
     parallelSafety: 'safe',
-    description: 'Read this session’s current Todo revision and items. Use before updating when the revision may have changed. Do not read an empty or new Todo merely to decide whether straightforward bounded work needs one.',
+    description: 'Read this session’s current Todo revision and items when you need the existing list. A prior read is not required to write Todo. Do not read an empty or new Todo merely to decide whether straightforward bounded work needs one.',
     inputSchema: { type: 'object', properties: {}, additionalProperties: false }
 };
 export function executeTodoRead(context) {

package/dist/agent-core/tools/agent/todo-write.js

@@ -4,11 +4,10 @@ export const todoWriteToolDefinition = {
     name: 'todo_write',
     allowedCallers: ['direct', 'programmatic'],
     parallelSafety: 'serial',
-    description: 'Replace this session’s entire Todo list using optimistic expectedRevision. Preserve stable IDs and statuses only when extending the same objective. For a materially different objective, include only the new objective’s items. Do not retain completed items from an earlier objective; when all current items are completed, default a substantive new request to replacement unless the user explicitly asks to continue, extend, verify, or follow up. Use only after Todo has been chosen for coordination-heavy work; straightforward bounded work does not need it. Keep at most one in_progress item and update statuses after meaningful stage changes. When another substantive tool call is already ready and does not depend on the Todo result, include both in the same model response instead of spending a response only for Todo bookkeeping.',
+    description: 'Replace this session’s entire Todo list with the supplied items; no prior read is required. Preserve stable IDs and statuses only when extending the same objective. For a materially different objective, include only the new objective’s items. Do not retain completed items from an earlier objective; when all current items are completed, default a substantive new request to replacement unless the user explicitly asks to continue, extend, verify, or follow up. Use only after Todo has been chosen for coordination-heavy work; straightforward bounded work does not need it. Keep at most one in_progress item and update statuses after meaningful stage changes. When another substantive tool call is already ready and does not depend on the Todo result, include both in the same model response instead of spending a response only for Todo bookkeeping.',
     inputSchema: {
         type: 'object',
         properties: {
-            expectedRevision: { type: 'integer' },
             items: {
                 type: 'array',
                 maxItems: TOOL_EXECUTION_LIMITS.todoMaxItems,
@@ -24,7 +23,7 @@ export const todoWriteToolDefinition = {
                 }
             }
         },
-        required: ['expectedRevision', 'items'],
+        required: ['items'],
         additionalProperties: false
     }
 };
@@ -38,9 +37,7 @@ function parseTodoWriteInput(value) {
     if (!value || typeof value !== 'object' || Array.isArray(value))
         return invalid();
     const input = value;
-    if (Object.keys(input).some((key) => !['expectedRevision', 'items'].includes(key)) ||
-        !Number.isInteger(input.expectedRevision) ||
-        input.expectedRevision < 0 ||
+    if (Object.keys(input).some((key) => key !== 'items') ||
         !Array.isArray(input.items) ||
         input.items.length > TOOL_EXECUTION_LIMITS.todoMaxItems)
         return invalid();
@@ -59,7 +56,7 @@ function parseTodoWriteInput(value) {
             return invalid();
         return { id: record.id, step: record.step, status: record.status };
     });
-    return { expectedRevision: input.expectedRevision, items };
+    return { items };
 }
 function invalid() {
     throw new MarAgentError('MAR_AGENT_TOOL_INPUT_INVALID', 'Todo input is invalid.');

package/dist/agent-core/tools/agent/todo.d.ts

@@ -12,7 +12,6 @@ export declare class TodoStore {
         }[];
     };
     write(input: {
-        expectedRevision: number;
         items: readonly TodoItem[];
     }): {
         revision: number;

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

@@ -14,10 +14,6 @@ export class TodoStore {
         return { revision: this.#revision, items: this.#items.map((item) => ({ ...item })) };
     }
     write(input) {
-        if (input.expectedRevision !== this.#revision)
-            throw new MarAgentError('MAR_AGENT_TODO_CONFLICT', 'Todo revision is stale.', {
-                details: { revision: this.#revision }
-            });
         this.#items = normalizeTodoItems(input.items);
         this.#revision++;
         return this.read();
@@ -44,10 +40,7 @@ export function restoreTodoStore(snapshots) {
         const items = todoItemsFromSnapshot(snapshot);
         if (!items)
             continue;
-        todo.write({
-            expectedRevision: todo.read().revision,
-            items
-        });
+        todo.write({ items });
     }
     return todo;
 }

package/dist/agent-core/tools/local/exec.d.ts

@@ -9,6 +9,7 @@ export type ExecInput = {
     action?: 'start';
     command: string;
     cwd?: string;
+    login?: boolean;
     timeoutMs?: number;
     yieldMs?: number;
 } | {

package/dist/agent-core/tools/local/exec.js

@@ -53,6 +53,11 @@ export const execToolDefinition = {
                 type: 'string',
                 description: 'Optional relative/absolute start directory; defaults to workspace. Command-internal relative paths resolve from this directory.'
             },
+            login: {
+                type: 'boolean',
+                default: true,
+                description: 'Use the Shell login/profile initialization. Defaults to true; false skips login startup. Does not force an interactive Shell.'
+            },
             timeoutMs: {
                 type: 'integer',
                 minimum: 1,
@@ -105,7 +110,7 @@ export function execToolInput(name, value) {
         return invalidExecInput();
     const input = value;
     const allowed = name === 'exec'
-        ? ['command', 'cwd', 'timeoutMs', 'yieldMs']
+        ? ['command', 'cwd', 'login', 'timeoutMs', 'yieldMs']
         : ['processId', 'action', 'yieldMs', 'data'];
     if (Object.keys(input).some((key) => !allowed.includes(key)))
         return invalidExecInput();
@@ -174,6 +179,7 @@ export class ExecTool {
                 command: input.command,
                 cwd: cwd.physicalPath,
                 shell: this.shell ?? true,
+                shellLogin: input.login ?? true,
                 environment: this.environment,
                 displayCwd: cwd.displayPath,
                 detached: process.platform !== 'win32',
@@ -662,11 +668,14 @@ function parseExecInput(value) {
             return invalidExecInput();
         if (input.cwd !== undefined && input.cwd !== null && typeof input.cwd !== 'string')
             return invalidExecInput();
+        if (input.login !== undefined && input.login !== null && typeof input.login !== 'boolean')
+            return invalidExecInput();
         const timeoutMs = optionalBoundedInteger(input.timeoutMs, 1, TOOL_EXECUTION_LIMITS.execMaxTimeoutMs);
         return {
             ...(input.action === 'start' ? { action: 'start' } : {}),
             command: input.command,
             ...(typeof input.cwd === 'string' ? { cwd: input.cwd } : {}),
+            ...(typeof input.login === 'boolean' ? { login: input.login } : {}),
             ...(timeoutMs === undefined ? {} : { timeoutMs }),
             ...(yieldMs === undefined ? {} : { yieldMs })
         };

package/dist/sandbox/linux/bubblewrap-sandbox-executor.js

@@ -5,6 +5,7 @@ import { tmpdir } from 'node:os';
 import { isAbsolute, join, posix, relative, resolve, sep } from 'node:path';
 import { promisify } from 'node:util';
 import { MarAgentError } from '../../agent-core/error.js';
+import { prepareLocalShellProcess } from '../../agent-core/host/local-shell.js';
 import { LINUX_BUBBLEWRAP_SANDBOX_POLICY_VERSION } from './profile.js';
 const execFileAsync = promisify(execFile);
 const DEFAULT_BUBBLEWRAP_PATH = '/usr/bin/bwrap';
@@ -63,12 +64,24 @@ export class BubblewrapSandboxExecutor {
         const mounts = await this.#mounts();
         const runtimeMounts = await trustedRuntimeMounts(request.runtimeDirectories ?? [], mounts);
         const cwd = await workingDirectory(request, mounts, this.options.profile.workingDirectory);
-        const command = sandboxCommand(request, mounts);
+        // Apply the sandbox policy before creating private startup-override variables.
+        const environment = Object.fromEntries(explicitEnvironment(request));
+        const shellRequest = prepareLocalShellProcess({
+            ...request,
+            environment,
+            environmentKeys: Object.keys(environment),
+            environmentOverrides: Object.fromEntries(Object.entries(request.environmentOverrides ?? {})
+                .filter(([name, value]) => SAFE_ENVIRONMENT_NAME.test(name) &&
+                !FORBIDDEN_ENVIRONMENT_NAMES.has(name) &&
+                (value === undefined || Object.hasOwn(environment, name)))
+                .map(([name, value]) => [name, value === undefined ? undefined : environment[name]]))
+        });
+        const command = sandboxCommand(shellRequest, mounts);
         const launchDirectory = await mkdtemp(join(tmpdir(), 'mar-agent-bwrap-launch-'));
         const argumentPath = join(launchDirectory, 'arguments');
         const seccompPath = join(launchDirectory, 'seccomp.bpf');
         try {
-            const arguments_ = this.#arguments(mounts, cwd, request, runtimeMounts);
+            const arguments_ = this.#arguments(mounts, cwd, shellRequest, runtimeMounts);
             await Promise.all([
                 writeFile(argumentPath, `${arguments_.join('\0')}\0`, { mode: 0o600, flag: 'wx' }),
                 writeFile(seccompPath, seccompFilter(process.arch), { mode: 0o600, flag: 'wx' })

package/package.json

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