@vtxmacro/cli 2026.9.68 → 2026.9.69

package/bin/vtx-service-bootstrap.js

@@ -16,7 +16,7 @@ import { fileURLToPath } from "node:url";
 // agent-cli-release.json
 var agent_cli_release_default = {
   package_name: "@vtxmacro/cli",
-  package_version: "2026.9.68",
+  package_version: "2026.9.69",
   codex_package_name: "@openai/codex",
   codex_version: "0.155.0",
   copilot_sdk_package_name: "@github/copilot-sdk",

package/bin/vtx.js

@@ -77,7 +77,7 @@ var init_agent_cli_release = __esm({
   "agent-cli-release.json"() {
     agent_cli_release_default = {
       package_name: "@vtxmacro/cli",
-      package_version: "2026.9.68",
+      package_version: "2026.9.69",
       codex_package_name: "@openai/codex",
       codex_version: "0.155.0",
       copilot_sdk_package_name: "@github/copilot-sdk",
@@ -21111,6 +21111,7 @@ var init_mcp_client = __esm({
     agentDecisionTimingSchema = external_exports.strictObject({
       analysis_started_at: timestampSchema2,
       model_latency_ms: external_exports.number().int().nonnegative().nullable(),
+      analysis_duration_ms: external_exports.number().int().nonnegative().max(Number.MAX_SAFE_INTEGER).nullable().optional(),
       model_latency_source: external_exports.literal("harness_invocation").nullable()
     }).refine((timing) => timing.model_latency_ms === null === (timing.model_latency_source === null), {
       message: "Model latency and its measurement source must be supplied together."
@@ -21123,7 +21124,7 @@ var init_mcp_client = __esm({
       observed_at: timestampSchema2,
       timing: agentDecisionTimingSchema.optional(),
       provenance: jsonObjectSchema.nullable().optional()
-    }).refine((request) => !request.timing || Date.parse(request.timing.analysis_started_at) <= Date.parse(request.observed_at), {
+    }).refine((request) => !request.timing || Date.parse(request.timing.analysis_started_at) <= Date.parse(request.observed_at) && (request.timing.analysis_duration_ms == null || request.timing.analysis_duration_ms <= Date.parse(request.observed_at) - Date.parse(request.timing.analysis_started_at)), {
       message: "Analysis start must precede decision observation."
     });
     agentDecisionSubmitResultSchema = external_exports.strictObject({
@@ -21477,6 +21478,7 @@ var init_mcp_client = __esm({
       #initialized = false;
       #providerQuotaRecoverySupported = false;
       #providerCreditsSupported = false;
+      #agentAnalysisDurationSupported = false;
       #runtimeRecoveryDiagnosticsSupported = false;
       #providerHttpStatusTools = /* @__PURE__ */ new Set();
       #grokToolValidationTools = /* @__PURE__ */ new Set();
@@ -21523,6 +21525,18 @@ var init_mcp_client = __esm({
       supportsRuntimeRecoveryDiagnostics() {
         return this.#runtimeRecoveryDiagnosticsSupported;
       }
+      supportsAgentAnalysisDuration() {
+        return this.#agentAnalysisDurationSupported;
+      }
+      async refreshAgentAnalysisDurationSupport(options = {}) {
+        if (this.supportsAgentAnalysisDuration()) return true;
+        try {
+          await this.initialize(options);
+        } catch {
+          return false;
+        }
+        return this.supportsAgentAnalysisDuration();
+      }
       supportsProviderCredits() {
         return this.#providerCreditsSupported;
       }
@@ -21603,6 +21617,20 @@ var init_mcp_client = __esm({
           return Array.isArray(node.anyOf) && node.anyOf.some((branch) => advertisesCredits(branch, depth + 1));
         };
         this.#providerCreditsSupported = advertisesCredits(hostHeartbeatSchema?.properties?.provider_weekly_quota);
+        const decisionSchema = listed.tools.find(
+          (tool) => tool.name === "inference.agent.decision.submit"
+        )?.inputSchema;
+        const advertisesAnalysisDuration = (value, depth = 0) => {
+          if (depth > 4 || !value || typeof value !== "object" || Array.isArray(value)) return false;
+          const node = value;
+          if (node.properties && typeof node.properties === "object" && Object.hasOwn(node.properties, "analysis_duration_ms")) return true;
+          if (typeof node.$ref === "string" && /^#\/\$defs\/[^/]+$/u.test(node.$ref)) {
+            const definition = node.$ref.slice("#/$defs/".length).replace(/~1/gu, "/").replace(/~0/gu, "~");
+            return advertisesAnalysisDuration(decisionSchema?.$defs?.[definition], depth + 1);
+          }
+          return Array.isArray(node.anyOf) && node.anyOf.some((branch) => advertisesAnalysisDuration(branch, depth + 1));
+        };
+        this.#agentAnalysisDurationSupported = advertisesAnalysisDuration(decisionSchema?.properties?.timing);
         this.#grokToolValidationTools.clear();
         if (advertisesFields("inference.job.fail", ["grok_tool_validation"])) {
           this.#grokToolValidationTools.add("inference.job.fail");
@@ -30901,7 +30929,7 @@ async function clearInferenceAgentNextState(statePath) {
     "Agent-driven inference next recovery state"
   );
 }
-var inferenceAgentAttemptStatePath, inferenceAgentNextStatePath, assertDecisionTiming, inferenceAgentRuntimeStatePath, inferenceAgentFailureFencePath, isIsoTimestamp, assertPlainObject, hasExactKeys, assertInferenceAgentFailureFence, assertInferenceAgentRuntimeState, readCodexAgentRuntimeState, clearCodexAgentRuntimeState, foregroundAgentControlStatePath, assertRuntimeAssignment, assertForegroundAgentControlState, assertNextState, assertAttemptState;
+var inferenceAgentAttemptStatePath, inferenceAgentNextStatePath, measureAgentReviewTiming, assertDecisionTiming, inferenceAgentRuntimeStatePath, inferenceAgentFailureFencePath, isIsoTimestamp, assertPlainObject, hasExactKeys, assertInferenceAgentFailureFence, assertInferenceAgentRuntimeState, readCodexAgentRuntimeState, clearCodexAgentRuntimeState, foregroundAgentControlStatePath, assertRuntimeAssignment, assertForegroundAgentControlState, assertNextState, assertAttemptState;
 var init_agent_state = __esm({
   "lib/inference-host/agent-state.ts"() {
     "use strict";
@@ -30912,9 +30940,20 @@ var init_agent_state = __esm({
     init_external_inference_contract();
     inferenceAgentAttemptStatePath = (statePath) => `${statePath}.agent-attempt.json`;
     inferenceAgentNextStatePath = (statePath) => `${statePath}.agent-next.json`;
+    measureAgentReviewTiming = (analysisStartedAt, observedAt, measureDuration = true) => ({
+      analysis_started_at: analysisStartedAt,
+      model_latency_ms: null,
+      model_latency_source: null,
+      ...measureDuration ? { analysis_duration_ms: Date.parse(observedAt) - Date.parse(analysisStartedAt) } : {}
+    });
     assertDecisionTiming = (value, observedAt, message) => {
       const timing = assertPlainObject(value, message);
-      if (!hasExactKeys(timing, ["analysis_started_at", "model_latency_ms", "model_latency_source"]) || !isIsoTimestamp(timing.analysis_started_at) || Date.parse(timing.analysis_started_at) > Date.parse(String(observedAt)) || (timing.model_latency_ms === null ? timing.model_latency_source !== null : !Number.isSafeInteger(timing.model_latency_ms) || Number(timing.model_latency_ms) < 0 || timing.model_latency_source !== "harness_invocation")) throw new Error(message);
+      if (!hasExactKeys(timing, [
+        "analysis_started_at",
+        "model_latency_ms",
+        "model_latency_source",
+        ..."analysis_duration_ms" in timing ? ["analysis_duration_ms"] : []
+      ]) || !isIsoTimestamp(timing.analysis_started_at) || Date.parse(timing.analysis_started_at) > Date.parse(String(observedAt)) || timing.analysis_duration_ms != null && (!Number.isSafeInteger(timing.analysis_duration_ms) || Number(timing.analysis_duration_ms) < 0 || Number(timing.analysis_duration_ms) > Date.parse(String(observedAt)) - Date.parse(timing.analysis_started_at)) || (timing.model_latency_ms === null ? timing.model_latency_source !== null : !Number.isSafeInteger(timing.model_latency_ms) || Number(timing.model_latency_ms) < 0 || timing.model_latency_source !== "harness_invocation")) throw new Error(message);
     };
     inferenceAgentRuntimeStatePath = (statePath) => `${statePath}.codex-agent-runtime.json`;
     inferenceAgentFailureFencePath = (statePath) => `${statePath}.agent-failure-fence.json`;
@@ -34609,6 +34648,7 @@ var init_runner = __esm({
       }
     };
     createInferenceAgentControlClient = (mcp) => ({
+      supportsAgentAnalysisDuration: async (options = {}) => mcp.supportsAgentAnalysisDuration?.() === true || await mcp.refreshAgentAnalysisDurationSupport?.(options) === true,
       supportsProviderHttpStatusDiagnostics: async (options = {}) => mcp.supportsProviderHttpStatusDiagnostics?.("inference.agent.assignment.heartbeat") === true || await mcp.refreshProviderHttpStatusSupport?.("inference.agent.assignment.heartbeat", options) === true,
       supportsGrokResponseIdentityDiagnostics: async (options = {}) => mcp.supportsGrokResponseIdentityDiagnostics?.("inference.agent.assignment.heartbeat") === true || await mcp.refreshGrokResponseIdentitySupport?.("inference.agent.assignment.heartbeat", options) === true,
       supportsGrokToolValidationDiagnostics: async (options = {}) => mcp.supportsGrokToolValidationDiagnostics?.("inference.agent.assignment.heartbeat") === true || await mcp.refreshGrokToolValidationSupport?.("inference.agent.assignment.heartbeat", options) === true,
@@ -35028,15 +35068,19 @@ var init_runner = __esm({
                 if (state.pending_decision) {
                   return { success: false, value: { error: "decision_outcome_unresolved" } };
                 }
+                const measureDuration = state.pending_turn.decision_operation_ids.length === 0 && await this.options.controlClient.supportsAgentAnalysisDuration?.({ signal: turnAbort.signal }) === true;
+                const observedAt = nowIso();
                 const pending3 = {
                   operation_id: randomUUID(),
                   candidate,
-                  observed_at: nowIso(),
-                  timing: {
-                    analysis_started_at: state.pending_turn.started_at,
-                    model_latency_ms: null,
-                    model_latency_source: null
-                  },
+                  observed_at: observedAt,
+                  // A later decision in the same turn has no independent review
+                  // boundary. Do not report the whole turn again as its duration.
+                  timing: measureAgentReviewTiming(
+                    state.pending_turn.started_at,
+                    observedAt,
+                    measureDuration
+                  ),
                   provenance: {
                     source: "external_agent",
                     agent_run_id: liveThread.threadId,
@@ -46806,11 +46850,11 @@ Waiting for approval...
               operation_id: agentOperationId("agent-decision-submit"),
               candidate: input.candidate,
               observed_at: observedAt,
-              ...state.review ? { timing: {
-                analysis_started_at: state.review.analysis_started_at,
-                model_latency_ms: null,
-                model_latency_source: null
-              } } : {},
+              ...state.review ? { timing: measureAgentReviewTiming(
+                state.review.analysis_started_at,
+                observedAt,
+                session.client.supportsAgentAnalysisDuration?.() === true
+              ) } : {},
               provenance: input.provenance
             },
             first_transmit_at: null,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vtxmacro/cli",
-  "version": "2026.9.68",
+  "version": "2026.9.69",
   "description": "VTX Macro CLI, MCP server, and durable external inference host.",
   "type": "module",
   "license": "UNLICENSED",