@myagentroam/node 0.9.173 → 0.9.175

package/dist/codex-app-server.js

@@ -231,6 +231,7 @@ export class CodexAppServerClient {
     startThread(cwd, configuration = {}) {
         return this.request('thread/start', {
             cwd,
+            experimentalRawEvents: true,
             ...codexThreadConfiguration(cwd, configuration)
         });
     }

package/dist/runner/claude/managed-run-controller.js

@@ -8,6 +8,7 @@ import { parseSecretEnvironment } from '../../util/secret-environment.js';
 import { safeErrorCode } from '../../util/safe-error.js';
 import { runnerErrorProjection } from '../../util/runner-error.js';
 import { ResponseLatencyTracker } from '../../service/response-latency-tracker.js';
+import { GenerationTimingTracker } from '../../service/generation-timing-tracker.js';
 export class ClaudeManagedRunController {
     runner;
     host;
@@ -164,12 +165,27 @@ export class ClaudeManagedRunController {
         try {
             const gate = new ClaudeChannelGate(sessionId);
             const responseLatency = new ResponseLatencyTracker();
+            const generationTiming = new GenerationTimingTracker();
+            const finalOutputTokens = new Map();
+            const pendingOutputTokens = new Map();
+            const completedMessages = new Set();
             let responseMessageId;
             const observeResponse = (id, incremental = false) => {
                 const latencyMs = responseLatency.response(id, incremental);
                 if (latencyMs !== undefined)
                     this.host.emit(runId, 'run.performance', { latencyMs });
             };
+            const settleGeneration = (id, observedAt) => {
+                if (id === undefined)
+                    return;
+                generationTiming.end(id, observedAt);
+                const outputTokens = finalOutputTokens.get(id);
+                if (outputTokens === undefined)
+                    return;
+                const result = generationTiming.settle(id, outputTokens, observedAt);
+                if (result !== undefined)
+                    this.host.emit(runId, 'run.performance', { tokensPerSecond: result.tokensPerSecond });
+            };
             handle = this.runner.startChannel({
                 prompt: payload.input,
                 cwd,
@@ -200,9 +216,14 @@ export class ClaudeManagedRunController {
                         }))
                     }),
                 onPermission: (toolName, toolInput, options) => {
-                    const latencyMs = responseLatency.toolStarted(options.toolUseID);
-                    if (latencyMs !== undefined)
-                        this.host.emit(runId, 'run.performance', { latencyMs });
+                    if (options.agentID === undefined) {
+                        const receiptAt = generationTiming.timestamp();
+                        if (responseMessageId !== undefined)
+                            generationTiming.pause(responseMessageId, receiptAt);
+                        const latencyMs = responseLatency.toolStarted(options.toolUseID);
+                        if (latencyMs !== undefined)
+                            this.host.emit(runId, 'run.performance', { latencyMs });
+                    }
                     return toolName === 'AskUserQuestion'
                         ? (toolKinds.set(options.toolUseID, 'user_input_request'),
                             this.host.requestUserInput(runId, toolInput, options.toolUseID))
@@ -212,6 +233,7 @@ export class ClaudeManagedRunController {
                 onMessage: (message) => {
                     if (terminal)
                         return;
+                    const receiptAt = generationTiming.timestamp();
                     const record = message;
                     const nativeSessionId = typeof record.session_id === 'string' ? record.session_id : undefined;
                     const current = this.runner.execution.runs.get(runId);
@@ -236,7 +258,8 @@ export class ClaudeManagedRunController {
                                 });
                         }
                     }
-                    if (record.type === 'stream_event') {
+                    const mainTask = record.parent_tool_use_id === undefined || record.parent_tool_use_id === null;
+                    if (record.type === 'stream_event' && mainTask) {
                         // Observe semantic timing without forwarding raw thinking or input fragments.
                         const event = record.event;
                         const block = event?.content_block;
@@ -245,14 +268,49 @@ export class ClaudeManagedRunController {
                             const message = event.message;
                             responseMessageId = typeof message?.id === 'string' ? message.id : undefined;
                         }
+                        if (event?.type === 'message_delta') {
+                            const usage = event.usage;
+                            if (responseMessageId !== undefined) {
+                                if (typeof usage?.output_tokens === 'number')
+                                    pendingOutputTokens.set(responseMessageId, usage.output_tokens);
+                                if (typeof delta?.stop_reason === 'string' && delta.stop_reason.length > 0) {
+                                    const tokens = pendingOutputTokens.get(responseMessageId);
+                                    if (tokens !== undefined)
+                                        finalOutputTokens.set(responseMessageId, tokens);
+                                    completedMessages.add(responseMessageId);
+                                    settleGeneration(responseMessageId, receiptAt);
+                                }
+                            }
+                        }
+                        if (event?.type === 'message_stop') {
+                            if (responseMessageId !== undefined) {
+                                completedMessages.add(responseMessageId);
+                                if (!finalOutputTokens.has(responseMessageId)) {
+                                    const tokens = pendingOutputTokens.get(responseMessageId);
+                                    if (tokens !== undefined)
+                                        finalOutputTokens.set(responseMessageId, tokens);
+                                }
+                            }
+                            settleGeneration(responseMessageId, receiptAt);
+                        }
                         if (event?.type === 'content_block_start' &&
-                            block?.type === 'tool_use' &&
-                            typeof block.id === 'string') {
-                            const latencyMs = responseLatency.toolStarted(block.id);
-                            if (latencyMs !== undefined)
-                                this.host.emit(runId, 'run.performance', { latencyMs });
-                            // A later full snapshot of this streamed message is not a new response.
-                            responseLatency.response(responseMessageId);
+                            (block?.type === 'tool_use' ||
+                                block?.type === 'thinking' ||
+                                block?.type === 'redacted_thinking' ||
+                                block?.type === 'encrypted_thinking' ||
+                                block?.type === 'text')) {
+                            if (responseMessageId !== undefined)
+                                generationTiming.start(responseMessageId, receiptAt);
+                            if (block?.type !== 'text' ||
+                                (typeof block.text === 'string' && block.text.length > 0)) {
+                                const latencyMs = block?.type === 'tool_use' && typeof block.id === 'string'
+                                    ? responseLatency.toolStarted(block.id)
+                                    : responseLatency.response(responseMessageId);
+                                if (latencyMs !== undefined)
+                                    this.host.emit(runId, 'run.performance', { latencyMs });
+                                if (block?.type === 'tool_use')
+                                    responseLatency.response(responseMessageId);
+                            }
                         }
                         if ((event?.type === 'content_block_start' && block?.type === 'thinking') ||
                             (event?.type === 'content_block_delta' &&
@@ -264,12 +322,27 @@ export class ClaudeManagedRunController {
                                         delta.thinking.length > 0) ||
                                     (delta?.type === 'input_json_delta' &&
                                         typeof delta.partial_json === 'string' &&
-                                        delta.partial_json.length > 0))))
+                                        delta.partial_json.length > 0)))) {
+                            if (responseMessageId !== undefined)
+                                generationTiming.start(responseMessageId, receiptAt);
                             observeResponse(responseMessageId, event?.type === 'content_block_delta');
+                        }
                     }
                     if (record.type === 'assistant') {
+                        const snapshotMessage = record.message;
+                        const snapshotId = typeof snapshotMessage?.id === 'string' ? snapshotMessage.id : undefined;
+                        const snapshotUsage = snapshotMessage?.usage;
+                        if (mainTask &&
+                            snapshotId !== undefined &&
+                            typeof snapshotUsage?.output_tokens === 'number' &&
+                            (completedMessages.has(snapshotId) ||
+                                (typeof snapshotMessage?.stop_reason === 'string' &&
+                                    snapshotMessage.stop_reason.length > 0))) {
+                            finalOutputTokens.set(snapshotId, snapshotUsage.output_tokens);
+                            settleGeneration(snapshotId, receiptAt);
+                        }
                         const text = extractClaudeText(record);
-                        if (text.length > 0 || extractClaudeThinkingSummaries(record).length > 0)
+                        if (mainTask && (text.length > 0 || extractClaudeThinkingSummaries(record).length > 0))
                             observeResponse(typeof record.message?.id === 'string'
                                 ? record.message.id
                                 : undefined);
@@ -292,7 +365,7 @@ export class ClaudeManagedRunController {
                             });
                         }
                         for (const tool of extractClaudeToolUses(record)) {
-                            const latencyMs = responseLatency.toolStarted(tool.id);
+                            const latencyMs = mainTask ? responseLatency.toolStarted(tool.id) : undefined;
                             if (latencyMs !== undefined)
                                 this.host.emit(runId, 'run.performance', { latencyMs });
                             if (tool.name === 'AskUserQuestion') {
@@ -358,7 +431,8 @@ export class ClaudeManagedRunController {
                     }
                     if (record.type === 'user') {
                         for (const result of extractClaudeToolResults(record)) {
-                            responseLatency.toolCompleted(result.toolUseId);
+                            if (mainTask)
+                                responseLatency.toolCompleted(result.toolUseId);
                             const kind = toolKinds.get(result.toolUseId) ?? 'tool_call';
                             if (kind === 'user_input_request')
                                 continue;

package/dist/runner/codex/managed-run-controller.js

@@ -4,6 +4,7 @@ import { parseSecretEnvironment } from '../../util/secret-environment.js';
 import { safeErrorCode } from '../../util/safe-error.js';
 import { runnerErrorProjection } from '../../util/runner-error.js';
 import { ResponseLatencyTracker } from '../../service/response-latency-tracker.js';
+import { GenerationTimingTracker } from '../../service/generation-timing-tracker.js';
 import { boundedConversationItemId, codexImageAttachments, codexLiveConversationItem, codexUserInputQuestions, compactRunnerText, isPlainRecord } from './conversation-parser.js';
 export function resolveCodexNotificationRun(runs, input) {
     const entries = [...runs.entries()];
@@ -137,6 +138,7 @@ export class CodexManagedRunController {
         if (run === undefined)
             return;
         const [runId, activeRun] = run;
+        const receiptAt = activeRun.generationTiming?.timestamp();
         if (notification.method === 'turn/started' && turnId !== undefined) {
             const active = this.runner.execution.runs.get(runId);
             if (active !== undefined)
@@ -144,6 +146,16 @@ export class CodexManagedRunController {
             this.host.emit(runId, 'run.running', { threadId, turnId }, 'RUNNING');
             return;
         }
+        if (notification.method === 'rawResponseItem/completed')
+            return;
+        if (notification.method === 'rawResponse/completed') {
+            this.completeRawResponse(runId, params, activeRun, receiptAt);
+            return;
+        }
+        if (notification.method === 'thread/tokenUsage/updated') {
+            this.completeStandardUsage(runId, params, activeRun, receiptAt);
+            return;
+        }
         if (notification.method === 'thread/goal/updated' &&
             activeRun.goalMcp === true &&
             turnId !== undefined &&
@@ -168,6 +180,7 @@ export class CodexManagedRunController {
         if (notification.requestId !== undefined &&
             (notification.method === 'item/commandExecution/requestApproval' ||
                 notification.method === 'item/fileChange/requestApproval')) {
+            this.pauseGeneration(runId, receiptAt);
             this.requestApproval(runId, {
                 ...notification,
                 requestId: notification.requestId
@@ -176,6 +189,7 @@ export class CodexManagedRunController {
         }
         if (notification.requestId !== undefined &&
             notification.method === 'item/tool/requestUserInput') {
+            this.pauseGeneration(runId, receiptAt);
             this.requestUserInput(runId, notification.requestId, params);
             return;
         }
@@ -200,15 +214,19 @@ export class CodexManagedRunController {
                 text: params.delta,
                 ...(itemId === undefined ? {} : { itemId })
             });
+            if (params.delta.length > 0)
+                this.beginGeneration(runId, receiptAt);
             if (params.delta.length > 0)
                 this.observeResponse(runId, itemId, true);
             return;
         }
         if (notification.method === 'item/reasoning/textDelta' && typeof params.delta === 'string') {
-            if (params.delta.length > 0)
+            if (params.delta.length > 0) {
+                this.beginGeneration(runId, receiptAt);
                 this.observeResponse(runId, typeof params.itemId === 'string'
                     ? boundedConversationItemId('codex', params.itemId)
                     : undefined, true);
+            }
             return;
         }
         if (notification.method === 'item/reasoning/summaryTextDelta' &&
@@ -225,8 +243,10 @@ export class CodexManagedRunController {
                 merge: true,
                 append: 'sections'
             });
-            if (params.delta.length > 0)
+            if (params.delta.length > 0) {
+                this.beginGeneration(runId, receiptAt);
                 this.observeResponse(runId, boundedConversationItemId('codex', params.itemId), true);
+            }
             return;
         }
         if (notification.method === 'item/commandExecution/outputDelta' &&
@@ -260,9 +280,25 @@ export class CodexManagedRunController {
             const item = codexLiveConversationItem(params.item, notification.method === 'item/completed', attachments);
             if (item !== undefined) {
                 this.host.emitItem(runId, item);
+                if (item.kind === 'context_compaction') {
+                    activeRun.generationCompacting = notification.method === 'item/started';
+                    if (activeRun.generationCompacting) {
+                        for (const key of activeRun.generationKeys ?? [])
+                            activeRun.generationTiming?.discard(key);
+                        activeRun.generationKeys = [];
+                        activeRun.currentGenerationKey = undefined;
+                    }
+                    return;
+                }
                 const tracker = activeRun.responseLatency;
                 const tool = ['tool_call', 'command_execution', 'file_change'].includes(item.kind);
                 if (tool) {
+                    if (notification.method === 'item/started') {
+                        if (codexToolGeneratesArguments(params.item))
+                            this.beginGeneration(runId, receiptAt);
+                        else
+                            this.pauseGeneration(runId, receiptAt);
+                    }
                     if (notification.method === 'item/completed')
                         tracker?.toolCompleted(item.itemId);
                     else {
@@ -273,12 +309,15 @@ export class CodexManagedRunController {
                 }
                 else if (['assistant_message', 'reasoning_summary', 'plan'].includes(item.kind)) {
                     // A started reasoning item is itself a semantic response, even before its summary.
+                    if (notification.method === 'item/started')
+                        this.beginGeneration(runId, receiptAt);
                     this.observeResponse(runId, item.itemId);
                 }
             }
             return;
         }
         if (notification.method === 'turn/completed') {
+            this.endPendingGenerations(activeRun, receiptAt);
             const status = turn?.status;
             const terminal = status === 'completed' ? 'SUCCEEDED' : status === 'interrupted' ? 'INTERRUPTED' : 'FAILED';
             if (terminal === 'FAILED')
@@ -308,6 +347,87 @@ export class CodexManagedRunController {
         if (latencyMs !== undefined)
             this.host.emit(runId, 'run.performance', { latencyMs });
     }
+    beginGeneration(runId, observedAt) {
+        const active = this.runner.execution.runs.get(runId);
+        if (active?.generationTiming === undefined || active.generationCompacting === true)
+            return;
+        let key = active.currentGenerationKey;
+        if (key === undefined) {
+            const sequence = (active.generationRequestSequence ?? 0) + 1;
+            key = `${active.turnId ?? active.threadId}:generation:${sequence}`;
+            active.generationKeys ??= [];
+            active.generationKeys.push(key);
+            active.generationRequestSequence = sequence;
+            active.currentGenerationKey = key;
+        }
+        active.generationTiming.start(key, observedAt);
+    }
+    pauseGeneration(runId, observedAt) {
+        const active = this.runner.execution.runs.get(runId);
+        const key = active?.currentGenerationKey;
+        if (active?.generationTiming === undefined || key === undefined)
+            return;
+        active.generationTiming.pause(key, observedAt);
+    }
+    endPendingGenerations(active, observedAt) {
+        if (active.generationTiming === undefined)
+            return;
+        for (const key of active.generationKeys ?? [])
+            active.generationTiming.end(key, observedAt);
+    }
+    completeRawResponse(runId, params, active, observedAt) {
+        const responseId = typeof params.responseId === 'string' ? params.responseId : undefined;
+        if (responseId === undefined || active.completedGenerationResponseIds?.has(responseId))
+            return;
+        active.completedGenerationResponseIds ??= new Set();
+        active.completedGenerationResponseIds.add(responseId);
+        if (active.generationCompacting === true)
+            return;
+        const key = active.generationResponseIds?.get(responseId) ??
+            active.currentGenerationKey ??
+            active.generationKeys?.find((candidate) => active.generationTiming?.has(candidate));
+        if (key === undefined || active.generationTiming === undefined)
+            return;
+        active.generationResponseIds ??= new Map();
+        active.generationResponseIds.set(responseId, key);
+        active.generationTiming.end(key, observedAt);
+        if (active.currentGenerationKey === key)
+            active.currentGenerationKey = undefined;
+        const outputTokens = codexOutputTokens(params.usage);
+        if (outputTokens === undefined)
+            return;
+        this.emitGenerationTps(runId, active, key, outputTokens, observedAt);
+    }
+    completeStandardUsage(runId, params, active, observedAt) {
+        if (active.generationTiming === undefined)
+            return;
+        const usage = isPlainRecord(params.tokenUsage) ? params.tokenUsage : undefined;
+        const outputTokens = codexOutputTokens(usage?.last);
+        if (outputTokens === undefined)
+            return;
+        // TokenCount also repeats the previous request's snapshot (for example after compaction).
+        // Include total counters to distinguish equal last counts from distinct model requests.
+        const snapshot = JSON.stringify([
+            codexUsageCounters(usage?.last),
+            codexUsageCounters(usage?.total)
+        ]);
+        if (active.generationUsageSnapshot === snapshot)
+            return;
+        active.generationUsageSnapshot = snapshot;
+        if (active.generationCompacting === true)
+            return;
+        const key = active.generationKeys?.find((candidate) => active.generationTiming?.has(candidate));
+        if (key !== undefined)
+            this.emitGenerationTps(runId, active, key, outputTokens, observedAt);
+    }
+    emitGenerationTps(runId, active, key, outputTokens, observedAt) {
+        const result = active.generationTiming?.settle(key, outputTokens, observedAt);
+        if (result !== undefined)
+            this.host.emit(runId, 'run.performance', { tokensPerSecond: result.tokensPerSecond });
+        active.generationKeys = active.generationKeys?.filter((candidate) => candidate !== key);
+        if (active.currentGenerationKey === key)
+            active.currentGenerationKey = undefined;
+    }
     requestApproval(runId, notification) {
         const approvalId = `codex:${runId}:${notification.requestId}`;
         const expiresAt = Date.now() + 10 * 60_000;
@@ -494,7 +614,11 @@ export class CodexManagedRunController {
                         cwd,
                         goalMcp: hasGoalMcp(payload.mcpServers),
                         scheduleMcp: hasScheduleMcp(payload.mcpServers),
-                        responseLatency: new ResponseLatencyTracker()
+                        responseLatency: new ResponseLatencyTracker(),
+                        generationTiming: new GenerationTimingTracker(),
+                        generationKeys: [],
+                        generationResponseIds: new Map(),
+                        completedGenerationResponseIds: new Set()
                     });
                     turnResult = await this.runner.startTurn(threadId, input, cwd, turnConfiguration, materializedAttachments, runId);
                     break;
@@ -560,3 +684,25 @@ function hasGoalMcp(value) {
 function hasScheduleMcp(value) {
     return isPlainRecord(value) && isPlainRecord(value.mar_schedule);
 }
+function codexOutputTokens(value) {
+    if (!isPlainRecord(value) ||
+        typeof value.outputTokens !== 'number' ||
+        !Number.isSafeInteger(value.outputTokens) ||
+        value.outputTokens < 0)
+        return undefined;
+    return value.outputTokens;
+}
+function codexToolGeneratesArguments(value) {
+    return ['functionCall', 'function_call', 'customToolCall', 'custom_tool_call'].includes(typeof value.type === 'string' ? value.type : '');
+}
+function codexUsageCounters(value) {
+    if (!isPlainRecord(value))
+        return undefined;
+    return [
+        value.inputTokens,
+        value.cachedInputTokens,
+        value.outputTokens,
+        value.reasoningOutputTokens,
+        value.totalTokens
+    ];
+}

package/dist/runner/mar-agent/compact-extensions.js

@@ -1,4 +1,5 @@
 import { buildCompactEvidence, countModelTokens, generateModelText, MarAgentError } from '@myagentroam/agent';
+import { highDensityCompactionPrompt } from './compact-prompt.js';
 import { marAgentRuntimeCompactConfigurationSchema } from '@myagentroam/protocol';
 /** Resolve optional dedicated credentials in the same factory batch without widening the SDK catalog. */
 export function compactRuntimeConfigurations(models, raw) {
@@ -59,7 +60,7 @@ export function marAgentCompactExtensionSource(state) {
 export async function generateMarAgentCompact(context, selected, signal) {
     signal.throwIfAborted();
     const startedAt = Date.now();
-    const instruction = context.getPrompt();
+    const instruction = highDensityCompactionPrompt();
     const overhead = countModelTokens(system) + countModelTokens(instruction) + 128;
     const full = buildCompactEvidence(context.messages, {
         maxTokens: Number.MAX_SAFE_INTEGER,

package/dist/runner/mar-agent/compact-prompt.js

@@ -0,0 +1,56 @@
+export function highDensityCompactionPrompt() {
+    return `Compile the visible conversation into Textual Continuation IR that lets the next agent continue correctly after the transcript is discarded. Transfer state; do not recap, address the user, call tools, advance the task, or invent facts.
+
+Optimize for continuation fidelity first and density second. Prefer sufficient continuation state over brevity; never omit information required to resume correctly.
+
+## Output contract
+Use these English section names when applicable; omit empty sections:
+1. Goal contract
+2. Current state
+3. Settled matters
+4. Necessary evidence
+5. Open loops
+
+IR grammar and vocabulary are English: headings, keys, enums, state atoms, and control terms. Natural-language values may follow the task's dominant language. Preserve exact user-designated text and established domain terms; do not translate identifiers or invent localized IR terminology.
+
+Prefer records over prose:
+<object> | <key>=<value> | <key>=<value>
+<event/condition> -> <object>.<key>=<value> | <effect>
+
+Use | for parallel facts, = for current state, and -> only for causality, invalidation, or transition. Keep enums lowercase and semantic: required, forbidden, pending; never YES/NO. Omit empty or irrelevant unknown fields. Keep pending, not run, unverified, and failed distinct. Use a sentence only when records cannot express a multi-object cause, conflict, authorization, or safety boundary unambiguously.
+
+Examples:
+src/discount.js | cause=verified | edit=pending | tests=not run
+patch(src/discount.js) -> prior_read=stale | next=re-evidence
+authorization | action=<exact> | scope=<exact> | lifetime=<exact> | status=active
+
+## Compiler
+1. Resolve intent. The latest user correction overrides older intent. Extract the primary objective, current deliverable, completion criteria, non-goals, and boundaries.
+2. Reduce time. Convert before -> event -> after into the latest evidenced state. Source mutation or base/branch change makes only affected evidence stale. History replacement invalidates Responses continuation, not factual evidence. Without an invalidating event, a verified claim remains current.
+3. Build objects. Emit one current record per file, symbol, feature, migration, test, worktree axis, selected Skill, Todo/plan item, external decision, or external side effect. Deduplicate equivalent facts.
+4. Separate status axes when needed:
+   - completion=pending|in_progress|completed|blocked
+   - epistemic=observed|verified|inferred|proposed|disproved
+   - freshness=current|stale|superseded
+   - scope=turn|worktree|base|branch|external
+5. Bind evidence to the claim it proves. Prefer a verified conclusion over raw snapshots or intermediate hypotheses.
+6. Select under budget. Protect, in order: objective, progress, boundaries and authorization, non-repeatable side effects, open loops, then necessary evidence. Remove provenance and recoverable detail only after those remain sufficient.
+
+## Retention rules
+- Preserve active caller/user instructions outside filesystem-loaded AGENTS.md, exact authorization boundaries, confirmed decisions and exclusions, completed edits and side effects, verification actually run, reproducible failures, failed approaches that constrain the next step, unresolved risks, and the smallest established next action.
+- Authorization is valid only for its exact action, scope, and lifetime in the active request. Completed or superseded scopes cannot revive it. Object state, completion, tool availability, and convenience never imply permission.
+- Preserve decisive values, or an exact artifact path/command that deterministically recovers them, when a result controls later work. Counts or schemas alone are insufficient.
+- Preserve paths, symbols, APIs, tools, models, providers, JSON keys, protocol fields, commands, arguments, error codes, commit hashes, call IDs, sequences, versions, numbers, and user-designated text verbatim.
+- Preserve selected Skill names with only continuation-critical constraints. Preserve Todo/plan revision, item/status, and current minimum step.
+- Keep observed HEAD, validated base, target commit, and current worktree as separate axes. Evidence updates only what it directly proves; cross-axis, cross-base, and cross-branch inference remains unverified.
+- If evidence conflicts, use state=conflict | candidates=<short values> | next=re-evidence. Never choose a side without evidence.
+
+## Exclusions
+Remove greetings, progress chatter, chronology that does not affect current state, duplicate facts, superseded hypotheses without remaining constraints, long logs, source bodies, verbose payloads, cheap-to-recover content, local-only integrity hashes, hidden reasoning, secrets, credentials, and unrelated content.
+
+Remove user/project/directory AGENTS.md text and constraints derived only from those files; the next Execution reloads them. Remove retained process/Subagent inventory, IDs, status, commands, cwd, and reuse instructions; Runtime reloads them.
+
+Before emitting, verify that objective, current progress, authorization/boundaries, completed versus unverified work, decisive evidence, open loops, and next action are explicit and non-contradictory.
+
+Output only compact Markdown IR.`;
+}

package/dist/runner/mar-agent/managed-run-controller.js

@@ -832,7 +832,7 @@ export class MarAgentManagedRunController {
             this.host.refreshContext?.(runId);
         if (event.type === 'model.performance')
             this.host.emit(runId, 'run.performance', {
-                latencyMs: event.latencyMs,
+                ...(event.latencyMs === undefined ? {} : { latencyMs: event.latencyMs }),
                 ...(event.tokensPerSecond === undefined ? {} : { tokensPerSecond: event.tokensPerSecond })
             });
         else if (event.type === 'message.delta')

package/dist/runner/mar-agent/runtime-model-factory.js

@@ -64,7 +64,6 @@ export class MarAgentRuntimeModelFactory {
                     defaultReasoningEffort: resolveMarAgentDefaultReasoningEffort(configuration.defaultReasoningEffort, configuration.reasoningEfforts),
                     titleGeneration: configuration.titleGeneration,
                     codeMode: configuration.codeMode,
-                    highDensityCompaction: configuration.highDensityCompaction,
                     ...(configuration.serviceTier === undefined
                         ? {}
                         : { serviceTier: configuration.serviceTier }),

package/dist/runner/opencode/managed-run-controller.js

@@ -5,6 +5,7 @@ import { boundedConversationItemId, compactRunnerText } from '../codex/conversat
 import { openCodePatchToolPayload, openCodeQuestions } from './conversation-parser.js';
 import { normalizeOpenCodeTool } from './tool-normalizer.js';
 import { ResponseLatencyTracker } from '../../service/response-latency-tracker.js';
+import { GenerationTimingTracker } from '../../service/generation-timing-tracker.js';
 export class OpenCodeManagedRunController {
     runner;
     host;
@@ -272,6 +273,7 @@ export class OpenCodeManagedRunController {
                 execution.responsePartKinds = new Map();
                 execution.responseStartedAt = Date.now();
                 execution.responseMessages = new Set();
+                execution.generationTiming = new GenerationTimingTracker();
             }
             await client.prompt({
                 directory: input.cwd,
@@ -295,6 +297,8 @@ export class OpenCodeManagedRunController {
         const event = record(value);
         const properties = record(event?.properties);
         const nested = record(properties?.part) ?? record(properties?.info);
+        const execution = this.runner.execution.get(runId);
+        const receiptAt = execution?.generationTiming?.timestamp();
         const sessionID = typeof properties?.sessionID === 'string'
             ? properties.sessionID
             : typeof nested?.sessionID === 'string'
@@ -325,8 +329,10 @@ export class OpenCodeManagedRunController {
                 if (info.role === 'assistant' &&
                     execution?.responseStartedAt !== undefined &&
                     typeof created === 'number' &&
-                    created >= execution.responseStartedAt)
+                    created >= execution.responseStartedAt) {
                     execution.responseMessages?.add(info.id);
+                    execution.currentResponseMessageId = info.id;
+                }
             }
             if (info?.role === 'assistant' &&
                 typeof info.id === 'string' &&
@@ -358,8 +364,12 @@ export class OpenCodeManagedRunController {
                 typeof properties.delta === 'string' &&
                 properties.delta.length > 0 &&
                 typeof properties.messageID === 'string' &&
-                this.currentResponseMessage(runId, properties.messageID))
+                this.currentResponseMessage(runId, properties.messageID)) {
+                const key = this.generationKey(runId, properties.messageID, properties.partID);
+                if (key !== undefined)
+                    execution?.generationTiming?.start(key, receiptAt);
                 this.observeResponse(runId, boundedConversationItemId('opencode', properties.partID), true);
+            }
             return;
         }
         if (event?.type === 'message.part.updated') {
@@ -386,36 +396,91 @@ export class OpenCodeManagedRunController {
                 return;
             if (typeof part.id === 'string' && typeof part.type === 'string')
                 this.runner.execution.get(runId)?.responsePartKinds?.set(part.id, part.type);
+            const tracker = this.currentResponseMessage(runId, part.messageID)
+                ? execution?.generationTiming
+                : undefined;
+            if (part.type === 'step-start') {
+                if (tracker !== undefined && typeof part.id === 'string')
+                    this.generationKey(runId, part.messageID, part.id, receiptAt, true);
+                return;
+            }
+            if (part.type === 'step-finish') {
+                const key = typeof part.id === 'string'
+                    ? (execution?.generationPartKeys?.get(part.id) ??
+                        execution?.generationRequestKeys?.get(part.messageID))
+                    : undefined;
+                if (tracker !== undefined && key !== undefined && typeof part.id === 'string') {
+                    execution?.generationPartKeys?.set(part.id, key);
+                    tracker.end(key, receiptAt);
+                    if (execution?.generationRequestKeys?.get(part.messageID) === key)
+                        execution.generationRequestKeys.delete(part.messageID);
+                    const outputTokens = openCodeOutputTokens(part.tokens);
+                    if (outputTokens !== undefined) {
+                        const result = tracker.settle(key, outputTokens, receiptAt);
+                        if (result !== undefined)
+                            this.host.emit(runId, 'run.performance', { tokensPerSecond: result.tokensPerSecond });
+                    }
+                }
+                return;
+            }
             const item = openCodePart(part, this.runner.execution.get(runId)?.agent === 'plan');
             if (item !== undefined)
                 this.host.emitItem(runId, item);
             if (typeof part.id === 'string') {
                 const itemId = boundedConversationItemId('opencode', part.id);
-                const tracker = this.currentResponseMessage(runId, part.messageID)
-                    ? this.runner.execution.get(runId)?.responseLatency
+                const responseLatency = this.currentResponseMessage(runId, part.messageID)
+                    ? execution?.responseLatency
+                    : undefined;
+                const generationTiming = this.currentResponseMessage(runId, part.messageID)
+                    ? execution?.generationTiming
                     : undefined;
+                const generationKey = generationTiming === undefined
+                    ? undefined
+                    : this.generationKey(runId, part.messageID, part.id);
                 if (part.type === 'tool') {
                     const state = record(part.state);
-                    if (state?.status === 'completed' || state?.status === 'error')
-                        tracker?.toolCompleted(itemId);
-                    else if (state?.status === 'pending' || state?.status === 'running') {
-                        const latencyMs = tracker?.toolStarted(itemId);
+                    if (state?.status === 'pending') {
+                        if (generationKey !== undefined)
+                            generationTiming?.start(generationKey, receiptAt);
+                        const latencyMs = responseLatency?.toolStarted(itemId);
+                        if (latencyMs !== undefined)
+                            this.host.emit(runId, 'run.performance', { latencyMs });
+                    }
+                    else if (state?.status === 'running') {
+                        if (generationKey !== undefined)
+                            generationTiming?.pause(generationKey, receiptAt);
+                        const latencyMs = responseLatency?.toolStarted(itemId);
                         if (latencyMs !== undefined)
                             this.host.emit(runId, 'run.performance', { latencyMs });
                     }
+                    else if (state?.status === 'completed' || state?.status === 'error') {
+                        if (generationKey !== undefined)
+                            generationTiming?.pause(generationKey, receiptAt);
+                        responseLatency?.toolCompleted(itemId);
+                    }
                 }
-                else if (tracker !== undefined &&
+                else if (generationTiming !== undefined &&
+                    generationKey !== undefined &&
                     (part.type === 'text' || part.type === 'reasoning') &&
-                    typeof part.text === 'string' &&
-                    part.text.length > 0)
-                    this.observeResponse(runId, itemId);
+                    typeof part.text === 'string') {
+                    if (isOpenCodeGenerationStart(part.time))
+                        generationTiming.start(generationKey, receiptAt);
+                    if (isOpenCodeGenerationEnd(part.time))
+                        generationTiming.pause(generationKey, receiptAt);
+                    if (part.text.length > 0)
+                        this.observeResponse(runId, itemId);
+                }
             }
             return;
         }
-        if (event?.type === 'permission.asked')
+        if (event?.type === 'permission.asked') {
+            this.pauseCurrentGeneration(runId, receiptAt);
             this.requestPermission(runId, properties);
-        if (event?.type === 'question.asked')
+        }
+        if (event?.type === 'question.asked') {
+            this.pauseCurrentGeneration(runId, receiptAt);
             this.requestQuestion(runId, properties);
+        }
     }
     currentResponseMessage(runId, messageId) {
         const parent = this.messageParents.get(runId)?.get(messageId);
@@ -430,6 +495,37 @@ export class OpenCodeManagedRunController {
         if (latencyMs !== undefined)
             this.host.emit(runId, 'run.performance', { latencyMs });
     }
+    pauseCurrentGeneration(runId, observedAt) {
+        const execution = this.runner.execution.get(runId);
+        const key = execution?.currentResponseMessageId === undefined
+            ? undefined
+            : execution.generationRequestKeys?.get(execution.currentResponseMessageId);
+        if (key !== undefined)
+            execution?.generationTiming?.pause(key, observedAt);
+    }
+    generationKey(runId, messageId, partId, observedAt, newRequest = false) {
+        const execution = this.runner.execution.get(runId);
+        if (execution?.generationTiming === undefined)
+            return undefined;
+        execution.generationPartKeys ??= new Map();
+        const existing = execution.generationPartKeys.get(partId);
+        if (existing !== undefined)
+            return existing;
+        execution.generationRequestKeys ??= new Map();
+        let key = execution.generationRequestKeys.get(messageId);
+        if (newRequest && key !== undefined) {
+            execution.generationTiming.end(key, observedAt);
+            key = undefined;
+        }
+        if (key === undefined) {
+            const sequence = (execution.generationRequestSequence ?? 0) + 1;
+            execution.generationRequestSequence = sequence;
+            key = `${messageId}:generation:${sequence}`;
+            execution.generationRequestKeys.set(messageId, key);
+        }
+        execution.generationPartKeys.set(partId, key);
+        return key;
+    }
     requestPermission(runId, properties) {
         const execution = this.runner.execution.get(runId);
         const requestId = typeof properties?.id === 'string' ? properties.id : undefined;
@@ -655,3 +751,21 @@ function record(value) {
         ? value
         : undefined;
 }
+function isOpenCodeGenerationStart(value) {
+    return typeof record(value)?.start === 'number';
+}
+function isOpenCodeGenerationEnd(value) {
+    return typeof record(value)?.end === 'number';
+}
+function openCodeOutputTokens(value) {
+    const tokens = record(value);
+    const output = tokens?.output;
+    const reasoning = tokens?.reasoning;
+    if (!Number.isSafeInteger(output) ||
+        !Number.isSafeInteger(reasoning) ||
+        output < 0 ||
+        reasoning < 0 ||
+        output + reasoning > Number.MAX_SAFE_INTEGER)
+        return undefined;
+    return output + reasoning;
+}

package/dist/service/generation-timing-tracker.js

@@ -0,0 +1,81 @@
+export class GenerationTimingTracker {
+    now;
+    requests = new Map();
+    constructor(now = () => performance.now()) {
+        this.now = now;
+    }
+    timestamp() {
+        return this.now();
+    }
+    start(key, observedAt) {
+        const at = observedAt ?? this.now();
+        const request = this.requests.get(key) ?? {
+            started: false,
+            durationMs: 0,
+            ended: false,
+            settled: false,
+            invalid: false
+        };
+        this.observe(request, at);
+        if (request.ended || request.settled || request.invalid || request.runningAt !== undefined)
+            return false;
+        request.started = true;
+        request.runningAt = at;
+        this.requests.set(key, request);
+        return true;
+    }
+    pause(key, observedAt) {
+        const request = this.requests.get(key);
+        if (request === undefined || request.settled)
+            return;
+        const at = observedAt ?? this.now();
+        this.observe(request, at);
+        if (request.runningAt === undefined)
+            return;
+        const duration = at - request.runningAt;
+        if (!(duration >= 0))
+            request.invalid = true;
+        else
+            request.durationMs += duration;
+        request.runningAt = undefined;
+    }
+    end(key, observedAt) {
+        const request = this.requests.get(key);
+        if (request === undefined || request.settled || request.ended)
+            return;
+        this.pause(key, observedAt);
+        request.ended = true;
+    }
+    settle(key, outputTokens, observedAt) {
+        const request = this.requests.get(key);
+        if (request === undefined ||
+            request.settled ||
+            !request.started ||
+            request.invalid ||
+            !Number.isSafeInteger(outputTokens) ||
+            outputTokens < 0)
+            return undefined;
+        this.end(key, observedAt);
+        request.settled = true;
+        if (request.invalid || request.durationMs < 1)
+            return undefined;
+        return {
+            outputTokens,
+            durationMs: request.durationMs,
+            tokensPerSecond: Math.round((outputTokens * 100_000) / request.durationMs) / 100
+        };
+    }
+    discard(key) {
+        this.requests.delete(key);
+    }
+    has(key) {
+        return this.requests.has(key);
+    }
+    observe(request, observedAt) {
+        if (!Number.isFinite(observedAt) ||
+            (request.lastAt !== undefined && observedAt < request.lastAt))
+            request.invalid = true;
+        if (Number.isFinite(observedAt))
+            request.lastAt = observedAt;
+    }
+}

package/dist/service/hosted-conversation-node-service.js

@@ -1950,7 +1950,6 @@ function modelSummary(model, index) {
         defaultReasoningEffort: resolveMarAgentDefaultReasoningEffort(model.defaultReasoningEffort, model.reasoningEfforts),
         titleGeneration: model.titleGeneration,
         codeMode: model.codeMode,
-        highDensityCompaction: model.highDensityCompaction,
         ...(model.fastMode === true ? { fastMode: true } : {}),
         hostedWebSearch: model.hostedWebSearch,
         ...(model.responsesTransport === undefined

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@myagentroam/node",
-  "version": "0.9.173",
+  "version": "0.9.175",
   "description": "MyAgentRoam Node runtime CLI.",
   "license": "Apache-2.0 AND GPL-2.0-or-later",
   "type": "module",
@@ -36,10 +36,10 @@
     "playwright": "1.62.1",
     "ws": "^8.21.3",
     "zod": "4.4.3",
-    "@myagentroam/agent": "0.9.173",
-    "@myagentroam/code-navigation": "0.9.129",
+    "@myagentroam/agent": "0.9.175",
     "@myagentroam/marctl": "0.9.123",
-    "@myagentroam/protocol": "0.9.173"
+    "@myagentroam/protocol": "0.9.175",
+    "@myagentroam/code-navigation": "0.9.129"
   },
   "devDependencies": {
     "@types/ws": "^8.18.1"