@wix/pathgrade 1.0.9 → 1.0.11

package/dist/agents/claude/sdk-message-projector.d.ts

@@ -19,9 +19,12 @@ import type { SDKMessage } from '@anthropic-ai/claude-agent-sdk';
 import type { AgentTurnResult } from '../../types.js';
 import type { AskUserAnswerStore } from './ask-user-answer-store.js';
 import type { ClaudeDeniedMcpEventStore } from './denied-mcp-event-store.js';
+import { type ClaudeSdkMessageTiming } from './tool-results.js';
 export interface ProjectTurnInput {
     /** Buffered typed-message stream from one `query()` call. */
     messages: SDKMessage[];
+    /** Local receive timing captured while consuming each corresponding SDK message. */
+    messageTimings?: readonly (ClaudeSdkMessageTiming | undefined)[];
     /** Forwarded onto `ToolEvent.turnNumber`; optional for projector unit use. */
     turnNumber?: number;
     /** First user message of the turn — used for slash-command skill detection. */
@@ -39,6 +42,8 @@ export interface ProjectTurnInput {
     mcpServerNames?: readonly string[];
     /** Policy-denied MCP events recorded by the per-turn permission bridge. */
     deniedMcpEvents?: ClaudeDeniedMcpEventStore;
+    /** Exact runtime credential values to redact before tool results become trace data. */
+    sensitiveValues?: readonly string[];
 }
 export interface ProjectedTurn {
     result: AgentTurnResult;

package/dist/agents/claude/sdk-message-projector.js

@@ -23,6 +23,7 @@ const SDK_ERROR_SUBTYPES = [
 ];
 import { TOOL_NAME_MAP, buildSummary, enrichSkillEvents } from '../../tool-events.js';
 import { parseClaudeSdkMcpToolName } from './mcp-tool-name.js';
+import { applyObservedToolResult, extractObservedToolResults, } from './tool-results.js';
 export function projectSdkMessages(input) {
     let sessionId;
     let initSkills;
@@ -37,7 +38,9 @@ export function projectSdkMessages(input) {
     let costUsd;
     let errorSubtype;
     const toolEvents = [];
-    for (const msg of input.messages) {
+    const pendingTools = new Map();
+    for (const [messageIndex, msg] of input.messages.entries()) {
+        const timing = input.messageTimings?.[messageIndex];
         switch (msg.type) {
             case 'system': {
                 const sid = msg.session_id;
@@ -60,13 +63,30 @@ export function projectSdkMessages(input) {
                         continue;
                     }
                     if (block.type === 'tool_use') {
-                        const event = buildToolEvent(block, input.turnNumber, input.answerStore, input.mcpServerNames ?? [], input.deniedMcpEvents);
-                        if (event)
+                        const event = buildToolEvent(block, input.turnNumber, input.answerStore, input.mcpServerNames ?? [], input.deniedMcpEvents, timing);
+                        if (event) {
                             toolEvents.push(event);
+                            if (event.toolUseId) {
+                                pendingTools.set(event.toolUseId, {
+                                    event,
+                                    startedMonotonicMs: timing?.receivedMonotonicMs,
+                                });
+                            }
+                        }
                     }
                 }
                 break;
             }
+            case 'user': {
+                for (const observed of extractObservedToolResults(msg, timing)) {
+                    const pending = pendingTools.get(observed.toolUseId);
+                    if (!pending)
+                        continue;
+                    applyObservedToolResult(pending.event, observed, pending.startedMonotonicMs, input.sensitiveValues);
+                    pendingTools.delete(observed.toolUseId);
+                }
+                break;
+            }
             case 'result': {
                 const r = msg;
                 if (r.session_id)
@@ -167,7 +187,7 @@ function prependSlashCommandSkillEvent(events, firstMessage, initSkills) {
         ...events,
     ];
 }
-function buildToolEvent(block, turnNumber, answerStore, mcpServerNames, deniedMcpEvents) {
+function buildToolEvent(block, turnNumber, answerStore, mcpServerNames, deniedMcpEvents, timing) {
     const providerToolName = String(block.name || 'unknown');
     const rawInput = block.input ?? undefined;
     const toolUseId = typeof block.id === 'string' ? block.id : undefined;
@@ -180,15 +200,18 @@ function buildToolEvent(block, turnNumber, answerStore, mcpServerNames, deniedMc
             ...(rawInput ?? {}),
             server: mcpTool.server,
             tool: mcpTool.tool,
-            status: 'completed',
+            status: 'incomplete',
         };
         return {
             action: 'mcp_tool_call',
             provider: 'claude',
             providerToolName: normalizedProviderToolName,
+            ...(toolUseId ? { toolUseId } : {}),
             turnNumber,
             arguments: args,
-            summary: `MCP tool ${normalizedProviderToolName} completed`,
+            status: 'incomplete',
+            ...(timing ? { startedAt: timing.receivedAt } : {}),
+            summary: `MCP tool ${normalizedProviderToolName}`,
             confidence: 'high',
             rawSnippet: JSON.stringify(block).slice(0, 200),
         };
@@ -203,8 +226,11 @@ function buildToolEvent(block, turnNumber, answerStore, mcpServerNames, deniedMc
         action,
         provider: 'claude',
         providerToolName,
+        ...(toolUseId ? { toolUseId } : {}),
         turnNumber,
         arguments: args,
+        status: 'incomplete',
+        ...(timing ? { startedAt: timing.receivedAt } : {}),
         summary,
         confidence: 'high',
         rawSnippet,

package/dist/agents/claude/tool-results.d.ts

@@ -0,0 +1,19 @@
+import type { SDKMessage } from '@anthropic-ai/claude-agent-sdk';
+import type { ToolEvent } from '../../tool-events.js';
+export declare const TOOL_RESULT_MAX_CHARS: number;
+export interface ClaudeSdkMessageTiming {
+    receivedAt: string;
+    receivedMonotonicMs: number;
+}
+export interface ObservedToolResult {
+    toolUseId: string;
+    isError: boolean;
+    structuredResult?: Record<string, unknown>;
+    content?: string;
+    completedAt?: string;
+    completedMonotonicMs?: number;
+}
+export declare function hasToolLifecycleBoundary(message: SDKMessage): boolean;
+export declare function extractObservedToolResults(message: SDKMessage, timing?: ClaudeSdkMessageTiming): ObservedToolResult[];
+export declare function applyObservedToolResult(event: ToolEvent, observed: ObservedToolResult, startedMonotonicMs?: number, sensitiveValues?: readonly string[]): void;
+export declare function collectSensitiveEnvValues(env: Readonly<Record<string, string>>): string[];

package/dist/agents/claude/tool-results.js

@@ -0,0 +1,117 @@
+export const TOOL_RESULT_MAX_CHARS = 64 * 1024;
+const SECRET_ENV_KEY_PATTERN = /(^|[_-])(api[_-]?key|token|secret|password|authorization|auth|bearer)([_-]|$)/i;
+export function hasToolLifecycleBoundary(message) {
+    if (message.type !== 'assistant' && message.type !== 'user')
+        return false;
+    const content = message.message?.content;
+    return Array.isArray(content) && content.some((block) => isRecord(block) && (block.type === 'tool_use' || block.type === 'tool_result'));
+}
+export function extractObservedToolResults(message, timing) {
+    if (message.type !== 'user')
+        return [];
+    const user = message;
+    const content = user.message?.content;
+    if (!Array.isArray(content))
+        return [];
+    const blocks = content.filter(isToolResultBlock);
+    const structuredResult = blocks.length === 1 && isRecord(user.tool_use_result)
+        ? user.tool_use_result
+        : undefined;
+    return blocks.flatMap((block) => {
+        if (typeof block.tool_use_id !== 'string')
+            return [];
+        const text = extractTextContent(block.content);
+        return [{
+                toolUseId: block.tool_use_id,
+                isError: block.is_error === true,
+                ...(structuredResult ? { structuredResult } : {}),
+                ...(text === undefined ? {} : { content: text }),
+                ...(timing ? {
+                    completedAt: timing.receivedAt,
+                    completedMonotonicMs: timing.receivedMonotonicMs,
+                } : {}),
+            }];
+    });
+}
+export function applyObservedToolResult(event, observed, startedMonotonicMs, sensitiveValues = []) {
+    const remainsBackgrounded = event.arguments?.run_in_background === true;
+    const result = buildBoundedToolResult(observed, sensitiveValues);
+    const failedExit = result.exitCode !== undefined && result.exitCode !== 0;
+    const failed = observed.isError || failedExit;
+    event.status = failed ? 'error' : (remainsBackgrounded ? 'incomplete' : 'completed');
+    if (!remainsBackgrounded || failed) {
+        if (observed.completedAt)
+            event.completedAt = observed.completedAt;
+        if (startedMonotonicMs !== undefined && observed.completedMonotonicMs !== undefined) {
+            event.durationMs = Math.max(0, observed.completedMonotonicMs - startedMonotonicMs);
+        }
+    }
+    if (Object.keys(result).length > 0)
+        event.result = result;
+    if (event.action === 'mcp_tool_call' && event.arguments) {
+        event.arguments.status = event.status;
+    }
+}
+export function collectSensitiveEnvValues(env) {
+    return [...new Set(Object.entries(env)
+            .filter(([key, value]) => SECRET_ENV_KEY_PATTERN.test(key) && value.length > 0)
+            .map(([, value]) => value))]
+        .sort((a, b) => b.length - a.length);
+}
+function buildBoundedToolResult(observed, sensitiveValues) {
+    const raw = observed.structuredResult;
+    const result = {};
+    let truncated = false;
+    const addBounded = (key, value) => {
+        if (typeof value !== 'string')
+            return;
+        const bounded = boundText(redactSensitiveValues(value, sensitiveValues));
+        result[key] = bounded.value;
+        truncated ||= bounded.truncated;
+    };
+    addBounded('stdout', raw?.stdout);
+    addBounded('stderr', raw?.stderr);
+    if (observed.content !== raw?.stdout)
+        addBounded('content', observed.content);
+    const exitCode = raw?.exitCode ?? raw?.exit_code;
+    if (typeof exitCode === 'number' && Number.isFinite(exitCode))
+        result.exitCode = exitCode;
+    if (truncated)
+        result.truncated = true;
+    return result;
+}
+function redactSensitiveValues(value, sensitiveValues) {
+    let redacted = value;
+    for (const secret of sensitiveValues) {
+        if (secret.length > 0)
+            redacted = redacted.split(secret).join('<redacted>');
+    }
+    return redacted;
+}
+function boundText(value) {
+    if (value.length <= TOOL_RESULT_MAX_CHARS)
+        return { value, truncated: false };
+    const marker = '\n[truncated by PathGrade]';
+    return {
+        value: `${value.slice(0, TOOL_RESULT_MAX_CHARS - marker.length)}${marker}`,
+        truncated: true,
+    };
+}
+function extractTextContent(content) {
+    if (typeof content === 'string')
+        return content;
+    if (!Array.isArray(content))
+        return undefined;
+    const text = content
+        .filter(isRecord)
+        .filter((block) => block.type === 'text' && typeof block.text === 'string')
+        .map((block) => block.text)
+        .join('');
+    return text || undefined;
+}
+function isToolResultBlock(value) {
+    return isRecord(value) && value.type === 'tool_result';
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}

package/dist/agents/claude.d.ts

@@ -39,6 +39,10 @@ export interface ClaudeAgentDeps {
     envExecutable?: string;
     /** Optional macOS sandbox-exec profile. None today; preserves the seam. */
     sandboxProfile?: string;
+    /** Local wall-clock seam for deterministic tool lifecycle tests. */
+    now?: () => Date;
+    /** Monotonic clock seam for deterministic tool duration tests. */
+    monotonicNow?: () => number;
 }
 export interface ClaudeAgentOptions {
     /**

package/dist/agents/claude.js

@@ -22,11 +22,13 @@
  *                                   parser wholesale.
  */
 import { query as sdkQuery, } from '@anthropic-ai/claude-agent-sdk';
+import { performance } from 'node:perf_hooks';
 import { BaseAgent, getRuntimeEnv, getWorkspacePath, } from '../types.js';
 import { createSandboxedClaudeSpawn } from '../providers/sandboxed-claude-spawn.js';
 import { assertClaudeLiveMcpSafetyPreflight, assertStdioMcpServersStartForClaudeSdk, mountMcpForClaudeSdk, } from '../providers/mcp-runtime-mounting.js';
 import { buildClaudeSdkOptions, resolveClaudeCodeExecutable, } from './claude/sdk-options.js';
 import { projectSdkMessages } from './claude/sdk-message-projector.js';
+import { collectSensitiveEnvValues, hasToolLifecycleBoundary, } from './claude/tool-results.js';
 import { createAskUserAnswerStore } from './claude/ask-user-answer-store.js';
 import { createClaudeToolPermissionBridge } from './claude/tool-permission-bridge.js';
 import { createClaudeDeniedMcpEventStore } from './claude/denied-mcp-event-store.js';
@@ -63,6 +65,8 @@ export class ClaudeAgent extends BaseAgent {
         const platform = this.deps.platform ?? process.platform;
         const hostEnv = this.deps.hostEnv ?? process.env;
         const envExecutable = this.deps.envExecutable ?? process.env.PATHGRADE_CLAUDE_CODE_EXECUTABLE;
+        const runtimeEnv = getRuntimeEnv(runtime);
+        const sensitiveValues = collectSensitiveEnvValues(runtimeEnv);
         const sandboxedSpawn = createSandboxedClaudeSpawn({
             platform,
             hostEnv,
@@ -75,7 +79,7 @@ export class ClaudeAgent extends BaseAgent {
         const mcpMountOptions = {
             workspacePath,
             mcpConfigPath: sessionOptions?.mcpConfigPath,
-            runtimeEnv: getRuntimeEnv(runtime),
+            runtimeEnv,
         };
         await assertClaudeLiveMcpSafetyPreflight({
             ...mcpMountOptions,
@@ -117,7 +121,7 @@ export class ClaudeAgent extends BaseAgent {
                 workspacePath,
                 spawnClaudeCodeProcess: sandboxedSpawn,
                 canUseTool: bridge,
-                runtimeEnv: getRuntimeEnv(runtime),
+                runtimeEnv,
                 model: sessionOptions?.model,
                 claudeCodeExecutable,
                 resume: priorSessionId,
@@ -125,9 +129,18 @@ export class ClaudeAgent extends BaseAgent {
                 abortController: createLinkedAbortController(getTurnAbortSignal(sessionOptions)),
             });
             const messages = [];
+            const messageTimings = [];
+            const now = this.deps.now ?? (() => new Date());
+            const monotonicNow = this.deps.monotonicNow ?? (() => performance.now());
             const stream = queryFn({ prompt: message, options: sdkOptions });
             for await (const msg of stream) {
                 messages.push(msg);
+                messageTimings.push(hasToolLifecycleBoundary(msg)
+                    ? {
+                        receivedAt: now().toISOString(),
+                        receivedMonotonicMs: monotonicNow(),
+                    }
+                    : undefined);
             }
             // The legacy NDJSON parser only synthesized the slash-command
             // `use_skill` event from the *opening* user message. The Claude
@@ -140,11 +153,13 @@ export class ClaudeAgent extends BaseAgent {
             const projectorFirstMessage = turnNumber === 1 ? message : undefined;
             const projected = projectSdkMessages({
                 messages,
+                messageTimings,
                 turnNumber,
                 firstMessage: projectorFirstMessage,
                 answerStore,
                 mcpServerNames: mcpServers ? Object.keys(mcpServers) : [],
                 deniedMcpEvents,
+                sensitiveValues,
             });
             // Capture the SDK-reported session id BEFORE checking for a bus
             // rejection so the next turn's `Options.resume` points at this

package/dist/agents/{opencode-contract.d.ts → opencode/contract.d.ts}

@@ -1,5 +1,5 @@
-import type { MockMcpServerDescriptor } from '../core/mcp-mock.types.js';
-import type { AgentName, AgentOptions } from '../sdk/types.js';
+import type { MockMcpServerDescriptor } from '../../core/mcp-mock.types.js';
+import type { AgentName, AgentOptions } from '../../sdk/types.js';
 export declare const OPENCODE_MODEL = "anthropic/claude-sonnet-5";
 export declare const OPENCODE_VERSION = "1.18.18";
 export interface OpenCodeRuntimeLockEntry {

package/dist/agents/opencode/process-groups.d.ts

@@ -0,0 +1,3 @@
+export declare function killOpenCodeProcessGroup(pid: number, signal: NodeJS.Signals): void;
+export declare function registerOpenCodeProcessGroup(pid: number): void;
+export declare function unregisterOpenCodeProcessGroup(pid: number): void;

package/dist/agents/opencode/process-groups.js

@@ -0,0 +1,47 @@
+/** Process-wide ownership of detached OpenCode child process groups. */
+const activeProcessGroups = new Set();
+let processCleanupInstalled = false;
+export function killOpenCodeProcessGroup(pid, signal) {
+    try {
+        process.kill(-pid, signal);
+    }
+    catch {
+        // The process group may already have exited.
+    }
+}
+function killAllProcessGroups() {
+    for (const pid of activeProcessGroups) {
+        killOpenCodeProcessGroup(pid, 'SIGKILL');
+    }
+    activeProcessGroups.clear();
+}
+function uninstallProcessCleanup() {
+    if (!processCleanupInstalled)
+        return;
+    processCleanupInstalled = false;
+    process.removeListener('exit', onProcessExit);
+    process.removeListener('SIGINT', onProcessSignal);
+    process.removeListener('SIGTERM', onProcessSignal);
+}
+function onProcessExit() {
+    killAllProcessGroups();
+}
+function onProcessSignal(signal) {
+    killAllProcessGroups();
+    uninstallProcessCleanup();
+    process.kill(process.pid, signal);
+}
+export function registerOpenCodeProcessGroup(pid) {
+    activeProcessGroups.add(pid);
+    if (processCleanupInstalled)
+        return;
+    processCleanupInstalled = true;
+    process.once('exit', onProcessExit);
+    process.once('SIGINT', onProcessSignal);
+    process.once('SIGTERM', onProcessSignal);
+}
+export function unregisterOpenCodeProcessGroup(pid) {
+    activeProcessGroups.delete(pid);
+    if (activeProcessGroups.size === 0)
+        uninstallProcessCleanup();
+}

package/dist/agents/opencode.js

@@ -7,7 +7,8 @@ import fs from 'fs-extra';
 import { BaseAgent, getRuntimeEnv, getWorkspacePath, } from '../types.js';
 import { buildSummary, enrichSkillEvents } from '../tool-events.js';
 import { readStagedMcpServers } from '../providers/mcp-config.js';
-import { currentOpenCodePlatformKey, OPENCODE_MODEL, OPENCODE_RUNTIME_LOCK, } from './opencode-contract.js';
+import { currentOpenCodePlatformKey, OPENCODE_MODEL, OPENCODE_RUNTIME_LOCK, } from './opencode/contract.js';
+import { killOpenCodeProcessGroup, registerOpenCodeProcessGroup, unregisterOpenCodeProcessGroup, } from './opencode/process-groups.js';
 const OUTPUT_CAP_BYTES = 16 * 1024 * 1024;
 const FIXED_OPENCODE_ENV = {
     OPENCODE_CLIENT: 'pathgrade',
@@ -68,6 +69,7 @@ export function spawnOpenCode(executable, args, options) {
         let aborted = false;
         let killTimer;
         let settled = false;
+        let terminating = false;
         const child = spawn(executable, args, {
             cwd: options.cwd,
             env: options.env,
@@ -75,22 +77,22 @@ export function spawnOpenCode(executable, args, options) {
             detached: true,
             stdio: ['pipe', 'pipe', 'pipe'],
         });
+        if (child.pid)
+            registerOpenCodeProcessGroup(child.pid);
         const killGroup = (signal) => {
             if (!child.pid)
                 return;
-            try {
-                process.kill(-child.pid, signal);
-            }
-            catch {
-                // The process may have exited between the state check and kill.
-            }
+            killOpenCodeProcessGroup(child.pid, signal);
         };
         const terminate = () => {
+            terminating = true;
             killGroup('SIGTERM');
             killTimer ??= setTimeout(() => killGroup('SIGKILL'), 250);
             killTimer.unref();
         };
         const onAbort = () => {
+            if (aborted)
+                return;
             aborted = true;
             terminate();
         };
@@ -98,9 +100,6 @@ export function spawnOpenCode(executable, args, options) {
             overflow = true;
             terminate();
         };
-        options.signal?.addEventListener('abort', onAbort, { once: true });
-        if (options.signal?.aborted)
-            onAbort();
         child.stdout.on('data', (chunk) => {
             stdoutBytes += chunk.length;
             if (stdoutBytes <= cap)
@@ -114,16 +113,23 @@ export function spawnOpenCode(executable, args, options) {
                 onOverflow();
         });
         child.stdin.on('error', () => undefined);
+        child.once('error', (error) => finish(undefined, undefined, error));
+        child.once('close', (code, signal) => finish(code, signal));
+        options.signal?.addEventListener('abort', onAbort, { once: true });
+        if (options.signal?.aborted)
+            onAbort();
         if (!aborted)
             child.stdin.end(options.stdin);
         else
             child.stdin.destroy();
-        child.once('error', (error) => finish(undefined, undefined, error));
-        child.once('close', (code, signal) => finish(code, signal));
         function finish(code, signal, error) {
             if (settled)
                 return;
             settled = true;
+            if (child.pid && terminating)
+                killOpenCodeProcessGroup(child.pid, 'SIGKILL');
+            if (child.pid)
+                unregisterOpenCodeProcessGroup(child.pid);
             options.signal?.removeEventListener('abort', onAbort);
             if (killTimer)
                 clearTimeout(killTimer);
@@ -377,6 +383,7 @@ class OpenCodeSession {
     disposed = false;
     sessionId;
     inFlight;
+    disposeController = new AbortController();
     constructor(runtime, options) {
         this.workspacePath = getWorkspacePath(runtime);
         this.runtimeEnv = getRuntimeEnv(runtime);
@@ -432,11 +439,15 @@ class OpenCodeSession {
                 '--model', OPENCODE_MODEL, '--agent', 'build',
                 ...(this.sessionId ? ['--session', this.sessionId] : []),
             ];
+            const turnSignal = this.getAbortSignal();
+            const signal = turnSignal
+                ? AbortSignal.any([turnSignal, this.disposeController.signal])
+                : this.disposeController.signal;
             const processResult = await spawnOpenCode(this.resolvedExecutable, args, {
                 cwd: this.workspacePath,
                 env,
                 stdin: message,
-                signal: this.getAbortSignal(),
+                signal,
             });
             const parsed = parseOpenCodeOutput(processResult.stdout, processResult, this.mcpToolNames);
             if (this.sessionId && parsed.sessionId !== this.sessionId) {
@@ -494,6 +505,7 @@ class OpenCodeSession {
         if (this.disposed)
             return;
         this.disposed = true;
+        this.disposeController.abort();
         await this.inFlight?.catch(() => undefined);
         await this.cleanupState();
     }

package/dist/sdk/agent.js

@@ -9,13 +9,14 @@ import { createManagedSession } from './managed-session.js';
 import { createAgentLLM } from '../utils/llm.js';
 import { buildRunSnapshot } from './snapshots.js';
 import { buildModelAgentResultLogEntry } from './agent-result-log.js';
+import { buildToolEventLogEntry } from './tool-event-log.js';
 import { getVisibleAssistantMessage } from './visible-turn.js';
 import { getCurrentCaseContext } from './case-context.js';
 import { createVerboseEmitter } from '../reporters/verbose-emitter.js';
 import fs from 'fs-extra';
 import * as path from 'path';
 import { cleanDebugRuns, DEFAULT_DEBUG_RETAIN_RUNS, prepareManagedDebugRun, } from '../providers/debug-runs.js';
-import { collectOpenCodeMcpToolNames, validateOpenCodeDeclaration } from '../agents/opencode-contract.js';
+import { collectOpenCodeMcpToolNames, validateOpenCodeDeclaration } from '../agents/opencode/contract.js';
 /**
  * Test-only injection point: override the sink used by the next emitter
  * built inside `createAgent`. Pass `null` to restore the default (stderr).
@@ -140,21 +141,18 @@ class AgentImpl {
         this.accumulateTurnUsage(turnResult);
         const response = getVisibleAssistantMessage(turnResult);
         const durationMs = Date.now() - turnStart;
+        const turnCompletedAt = timestamp();
+        for (const toolEvent of turnResult.toolEvents) {
+            this._log.push(buildToolEventLogEntry(toolEvent, turnCompletedAt));
+            this.verbose.toolEvent({ action: toolEvent.action, summary: toolEvent.summary });
+        }
         this._log.push(buildModelAgentResultLogEntry({
-            timestamp: timestamp(),
+            timestamp: turnCompletedAt,
             turnNumber,
             durationMs,
             turnResult,
             assistantMessage: response,
         }));
-        for (const toolEvent of turnResult.toolEvents) {
-            this._log.push({
-                type: 'tool_event',
-                timestamp: timestamp(),
-                tool_event: toolEvent,
-            });
-            this.verbose.toolEvent({ action: toolEvent.action, summary: toolEvent.summary });
-        }
         this._messages.push({ role: 'agent', content: response });
         this.verbose.turnEnd({
             turn: turnNumber,
@@ -234,11 +232,7 @@ class AgentImpl {
             // it undefined, in which case this is a no-op.
             this.accumulateTurnUsage(turnResult);
             for (const toolEvent of turnResult.toolEvents) {
-                this._log.push({
-                    type: 'tool_event',
-                    timestamp: new Date().toISOString(),
-                    tool_event: toolEvent,
-                });
+                this._log.push(buildToolEventLogEntry(toolEvent, new Date().toISOString()));
             }
             // Exit-code failures are no longer thrown here. The runConversation
             // loop projects the partial-turn through `pushModelAgentMessage`

package/dist/sdk/chat.js

@@ -1,5 +1,6 @@
 import { buildModelAgentResultLogEntry } from './agent-result-log.js';
 import { getVisibleAssistantMessage } from './visible-turn.js';
+import { buildToolEventLogEntry } from './tool-event-log.js';
 export class ChatSessionImpl {
     _turn;
     _done = false;
@@ -51,24 +52,21 @@ export class ChatSessionImpl {
         }
         const response = getVisibleAssistantMessage(turnResult);
         const durationMs = Date.now() - turnStart;
-        this.deps.log.push(buildModelAgentResultLogEntry({
-            timestamp: timestamp(),
-            turnNumber,
-            durationMs,
-            turnResult,
-            assistantMessage: response,
-        }));
+        const turnCompletedAt = timestamp();
         for (const toolEvent of turnResult.toolEvents) {
-            this.deps.log.push({
-                type: 'tool_event',
-                timestamp: timestamp(),
-                tool_event: toolEvent,
-            });
+            this.deps.log.push(buildToolEventLogEntry(toolEvent, turnCompletedAt));
             this.deps.verbose?.toolEvent({
                 action: toolEvent.action,
                 summary: toolEvent.summary,
             });
         }
+        this.deps.log.push(buildModelAgentResultLogEntry({
+            timestamp: turnCompletedAt,
+            turnNumber,
+            durationMs,
+            turnResult,
+            assistantMessage: response,
+        }));
         this.deps.messages.push({ role: 'agent', content: response });
         this.deps.verbose?.turnEnd({
             turn: turnNumber,

package/dist/sdk/judge-tool-session.js

@@ -35,13 +35,14 @@ export async function runJudgeSession(input, options = {}) {
         { role: 'user', content: user },
     ];
     let rounds = 0;
+    let scoreRepairAttempted = false;
     while (rounds < maxRounds) {
         rounds++;
         let response;
         try {
             response = await llm.callWithTools(messages, {
                 system,
-                tools: toolSchemas,
+                tools: scoreRepairAttempted ? [] : toolSchemas,
                 model: scorer.model,
                 cacheControl: scorer.cacheControl,
             });
@@ -63,6 +64,22 @@ export async function runJudgeSession(input, options = {}) {
             }
             const parsed = parseFinalScore(response.text);
             if (!parsed.ok) {
+                if (parsed.message.startsWith('JSON parse failed:')
+                    && !scoreRepairAttempted
+                    && rounds < maxRounds) {
+                    scoreRepairAttempted = true;
+                    messages.push({ role: 'assistant', content: response.text });
+                    messages.push({
+                        role: 'user',
+                        content: [
+                            `Your final answer was not valid JSON: ${parsed.message}.`,
+                            'Return ONLY a valid JSON object with double-quoted keys in this exact shape:',
+                            '{"score": <number 0..1>, "details": "<brief explanation>"}',
+                            'Do not call more tools or include Markdown fences.',
+                        ].join('\n'),
+                    });
+                    continue;
+                }
                 return makeOutcome(tokenUsage, toolCalls, logEntries, rounds, {
                     code: 'invalid_score',
                     details: parsed.message,

package/dist/sdk/judge-tools.js

@@ -206,7 +206,28 @@ export async function getToolEvents(events, actionFilter) {
     const filtered = actionFilter
         ? events.filter((e) => e.action.includes(actionFilter))
         : events;
-    return JSON.stringify(filtered);
+    const serialized = JSON.stringify(filtered);
+    const maxChars = 200 * 1024;
+    if (serialized.length <= maxChars)
+        return serialized;
+    const included = [];
+    for (const event of filtered) {
+        const candidate = JSON.stringify({
+            events: [...included, event],
+            truncated: true,
+            totalEvents: filtered.length,
+            includedEvents: included.length + 1,
+        });
+        if (candidate.length > maxChars)
+            break;
+        included.push(event);
+    }
+    return JSON.stringify({
+        events: included,
+        truncated: true,
+        totalEvents: filtered.length,
+        includedEvents: included.length,
+    });
 }
 export const DEFAULT_TOOL_REGISTRY = new Map([
     ['readFile', {
@@ -269,7 +290,7 @@ export const DEFAULT_TOOL_REGISTRY = new Map([
     ['getToolEvents', {
             schema: {
                 name: 'getToolEvents',
-                description: 'Retrieve the agent session tool events as JSON. Optional actionFilter substring-matches against event.action.',
+                description: 'Retrieve the agent session tool events as JSON. Optional actionFilter substring-matches against event.action. Oversized responses use a valid { events, truncated, totalEvents, includedEvents } JSON envelope.',
                 input_schema: {
                     type: 'object',
                     properties: { actionFilter: { type: 'string' } },

package/dist/sdk/managed-session.js

@@ -2,6 +2,7 @@ import { createAgentSession } from '../types.js';
 import { createAgentEnvironment } from '../agents/registry.js';
 import { withAbortTimeout } from '../utils/timeout.js';
 import { buildModelAgentResultLogEntry } from './agent-result-log.js';
+import { buildToolEventLogEntry } from './tool-event-log.js';
 import { planRuntimePolicies } from './runtime-policy.js';
 import { getVisibleAssistantMessage } from './visible-turn.js';
 import { createAskBus } from './ask-bus/bus.js';
@@ -84,14 +85,15 @@ export function createManagedSession(deps) {
             messages.push({ role: 'user', content: message });
             const turnResult = await executeTurn(message);
             const response = getVisibleAssistantMessage(turnResult);
+            const turnCompletedAt = new Date().toISOString();
+            for (const toolEvent of turnResult.toolEvents) {
+                log.push(buildToolEventLogEntry(toolEvent, turnCompletedAt));
+            }
             log.push(buildModelAgentResultLogEntry({
-                timestamp: new Date().toISOString(),
+                timestamp: turnCompletedAt,
                 turnResult,
                 assistantMessage: response,
             }));
-            for (const toolEvent of turnResult.toolEvents) {
-                log.push({ type: 'tool_event', timestamp: new Date().toISOString(), tool_event: toolEvent });
-            }
             messages.push({ role: 'agent', content: response });
             if (turnResult.exitCode !== 0) {
                 if (turnResult.timedOut)

package/dist/sdk/tool-event-log.d.ts

@@ -0,0 +1,3 @@
+import type { ToolEvent } from '../tool-events.js';
+import type { LogEntry } from '../types.js';
+export declare function buildToolEventLogEntry(toolEvent: ToolEvent, fallbackTimestamp: string): LogEntry;

package/dist/sdk/tool-event-log.js

@@ -0,0 +1,7 @@
+export function buildToolEventLogEntry(toolEvent, fallbackTimestamp) {
+    return {
+        type: 'tool_event',
+        timestamp: toolEvent.startedAt ?? fallbackTimestamp,
+        tool_event: toolEvent,
+    };
+}

package/dist/tool-events.d.ts

@@ -3,13 +3,32 @@ export interface ToolEvent {
     action: ToolAction;
     provider: 'claude' | 'codex' | 'cursor' | 'opencode';
     providerToolName: string;
+    /** Provider correlation identifier joining a tool invocation to its result. */
+    toolUseId?: string;
     turnNumber?: number;
     arguments?: Record<string, unknown>;
+    /** Lifecycle state observed by PathGrade. Absent on legacy provider events. */
+    status?: 'completed' | 'error' | 'incomplete';
+    /** Local wall-clock receive time for the invocation boundary. */
+    startedAt?: string;
+    /** Local wall-clock receive time for the matching result boundary. */
+    completedAt?: string;
+    /** Monotonic receive-time delta between invocation and result. */
+    durationMs?: number;
+    /** Bounded provider result data. Fields remain absent when unavailable. */
+    result?: ToolEventResult;
     summary: string;
     confidence: 'high' | 'medium' | 'low';
     rawSnippet: string;
     skillName?: string;
 }
+export interface ToolEventResult {
+    content?: string;
+    stdout?: string;
+    stderr?: string;
+    exitCode?: number;
+    truncated?: boolean;
+}
 export declare function summarizeToolEvents(events: ToolEvent[]): string;
 /**
  * Map from provider-specific tool names to normalized Pathgrade actions.

package/dist/utils/llm-providers/anthropic.js

@@ -11,6 +11,11 @@ function resolveBaseUrl(env) {
         || process.env.APP_ANTHROPIC_BASE_URL
         || 'https://api.anthropic.com';
 }
+function resolveMessagesUrl(env) {
+    const baseUrl = resolveBaseUrl(env).replace(/\/+$/, '');
+    const apiRoot = baseUrl.endsWith('/v1') ? baseUrl : `${baseUrl}/v1`;
+    return `${apiRoot}/messages`;
+}
 function buildHeaders(apiKey, useCache) {
     const headers = {
         'Content-Type': 'application/json',
@@ -57,7 +62,7 @@ function resolveTemperature(model, config, temperature) {
     return temperature ?? 0;
 }
 async function postAnthropic(apiKey, useCache, body, env) {
-    const response = await fetch(`${resolveBaseUrl(env)}/v1/messages`, {
+    const response = await fetch(resolveMessagesUrl(env), {
         method: 'POST',
         headers: buildHeaders(apiKey, useCache),
         body: JSON.stringify(body),

package/dist/utils/llm.js

@@ -199,6 +199,7 @@ export function createAgentLLM(agentName, agentEnv) {
     const adapters = agentEnv && Object.keys(agentEnv).length > 0
         ? baseAdapters.map((a) => ({
             ...a,
+            isAvailable: (env) => a.isAvailable({ ...agentEnv, ...env }),
             call: (prompt, opts) => a.call(prompt, { ...opts, env: { ...agentEnv, ...opts.env } }),
             ...(a.callWithTools
                 ? { callWithTools: (messages, opts) => a.callWithTools(messages, { ...opts, env: { ...agentEnv, ...opts.env } }) }

package/dist/viewer.html

@@ -1127,10 +1127,10 @@
             + (e.value?.toFixed(2) || '0.00') + '</span>'
             + (e.output ? '<div class="scorer-details" style="margin-top:0.25rem">' + esc(e.output) + '</div>' : '');
           break;
-        case 'tool_event':
-          body = '<span class="badge badge-type">' + esc(e.tool_event?.action || 'unknown') + '</span> '
-            + '<span class="scorer-details">' + esc(e.tool_event?.summary || '') + '</span>';
-          break;
+        case 'tool_event': {
+          const tool = e.tool_event || {}; const toolResult = tool.result || {}; const resultText = toolResult.content || toolResult.stdout || ''; const stderrText = toolResult.stderr || ''; const duration = typeof tool.durationMs === 'number' ? `${Math.round(tool.durationMs)}ms` : ''; const exit = typeof toolResult.exitCode === 'number' ? `exit ${toolResult.exitCode}` : ''; const meta = [tool.status || 'unknown', duration, exit].filter(Boolean).join(' · '); const output = resultText || stderrText ? '<div class="log-command-output"><pre class="code-block">' + esc(resultText) + (stderrText ? '<span class="stderr-text">' + esc(stderrText) + '</span>' : '') + '</pre></div>' : '';
+          body = '<details class="log-command-details"><summary class="log-command-summary"><span class="badge badge-type">' + esc(tool.action || 'unknown') + '</span> <span class="scorer-details">' + esc(tool.summary || '') + '</span><span class="log-command-meta">' + esc(meta) + '</span></summary>' + output + '</details>'; break;
+        }
         case 'judge_tool_call': {
           const tc = e.judge_tool_call || {};
           const okBadge = tc.ok

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wix/pathgrade",
-  "version": "1.0.9",
+  "version": "1.0.11",
   "packageManager": "yarn@4.12.0",
   "description": "Evaluate whether AI agents discover and use your skills correctly",
   "exports": {
@@ -132,5 +132,5 @@
     "typescript": "^5.9.3",
     "zod": "4.3.6"
   },
-  "falconPackageHash": "130e5449f0131fe2bba40bf0237a7620315714dfe492f7e5e9d7cc14"
+  "falconPackageHash": "0bfcf787a0b4fe0c48683c6aa662dd0e3c9679800fdcc9811414571d"
 }