@zhijiewang/openharness 2.29.0 → 2.30.1

package/dist/query/index.js

@@ -41,6 +41,11 @@ export async function* query(userMessage, config, existingMessages = []) {
     const maxTurns = config.maxTurns ?? DEFAULT_MAX_TURNS;
     const routerCfg = readOhConfig()?.modelRouter ?? {};
     const router = new ModelRouter(routerCfg, config.model ?? "");
+    const querySpanId = config.tracer?.startSpan("query", {
+        model: config.model,
+        permissionMode: config.permissionMode,
+        toolCount: config.tools.length,
+    });
     const toolContext = {
         workingDir: config.workingDir ?? process.cwd(),
         abortSignal: config.abortSignal,
@@ -51,6 +56,8 @@ export async function* query(userMessage, config, existingMessages = []) {
         permissionMode: config.permissionMode,
         askUserQuestion: config.askUserQuestion,
         gitCommitPerTool: config.gitCommitPerTool,
+        tracer: config.tracer,
+        parentSpanId: querySpanId,
     };
     const estimateTokens = makeTokenEstimator(config.provider);
     const contextManager = new ContextManager(undefined, config.model);
@@ -99,224 +106,230 @@ export async function* query(userMessage, config, existingMessages = []) {
         consecutiveErrors: 0,
     };
     // ── Main loop ──
-    while (state.turn < maxTurns) {
-        state.turn++;
-        if (config.abortSignal?.aborted) {
-            yield { type: "turn_complete", reason: "aborted" };
-            return;
-        }
-        if (config.maxCost && config.maxCost > 0 && state.totalCost >= config.maxCost) {
-            yield { type: "error", message: `Budget exceeded: $${state.totalCost.toFixed(4)}` };
-            yield { type: "turn_complete", reason: "budget_exceeded" };
-            return;
-        }
-        // Context window management
-        // ── Context window management with circuit breaker ──
-        const contextWindow = getContextWindow(config.model);
-        const estimatedTokens = estimateMessagesTokens(state.messages, estimateTokens);
-        const MAX_COMPRESSION_FAILURES = 3;
-        if (estimatedTokens > contextWindow * 0.8 && (state.compressionFailures ?? 0) < MAX_COMPRESSION_FAILURES) {
-            const tokensBefore = estimatedTokens;
-            let strategy = "basic";
-            state.messages = compressMessages(state.messages, Math.floor(contextWindow * 0.6));
-            const afterBasic = estimateMessagesTokens(state.messages, estimateTokens);
-            if (afterBasic > contextWindow * 0.7 && state.messages.length > 4) {
-                try {
-                    state.messages = await summarizeConversation(config.provider, state.messages, config.model, Math.floor(contextWindow * 0.5));
-                    strategy = "llm-summarization";
-                    state.compressionFailures = 0; // Reset on success
+    try {
+        while (state.turn < maxTurns) {
+            state.turn++;
+            if (config.abortSignal?.aborted) {
+                yield { type: "turn_complete", reason: "aborted" };
+                return;
+            }
+            if (config.maxCost && config.maxCost > 0 && state.totalCost >= config.maxCost) {
+                yield { type: "error", message: `Budget exceeded: $${state.totalCost.toFixed(4)}` };
+                yield { type: "turn_complete", reason: "budget_exceeded" };
+                return;
+            }
+            // Context window management
+            // ── Context window management with circuit breaker ──
+            const contextWindow = getContextWindow(config.model);
+            const estimatedTokens = estimateMessagesTokens(state.messages, estimateTokens);
+            const MAX_COMPRESSION_FAILURES = 3;
+            if (estimatedTokens > contextWindow * 0.8 && (state.compressionFailures ?? 0) < MAX_COMPRESSION_FAILURES) {
+                const tokensBefore = estimatedTokens;
+                let strategy = "basic";
+                state.messages = compressMessages(state.messages, Math.floor(contextWindow * 0.6));
+                const afterBasic = estimateMessagesTokens(state.messages, estimateTokens);
+                if (afterBasic > contextWindow * 0.7 && state.messages.length > 4) {
+                    try {
+                        state.messages = await summarizeConversation(config.provider, state.messages, config.model, Math.floor(contextWindow * 0.5));
+                        strategy = "llm-summarization";
+                        state.compressionFailures = 0; // Reset on success
+                    }
+                    catch {
+                        state.compressionFailures = (state.compressionFailures ?? 0) + 1;
+                        strategy = "basic-only (llm failed)";
+                    }
                 }
-                catch {
-                    state.compressionFailures = (state.compressionFailures ?? 0) + 1;
-                    strategy = "basic-only (llm failed)";
+                const tokensAfter = estimateMessagesTokens(state.messages, estimateTokens);
+                yield {
+                    type: "error",
+                    message: `Context compressed (${strategy}): ${tokensBefore} → ${tokensAfter} tokens. Re-read any files you need.`,
+                };
+            }
+            else if (estimatedTokens > contextWindow * 0.8) {
+                yield {
+                    type: "error",
+                    message: "Context compression disabled (3 consecutive failures). Consider starting a new session.",
+                };
+            }
+            // ── Dynamic prompt: refresh memories if changed, inject warnings ──
+            try {
+                const { memoryVersion, loadActiveMemories, memoriesToPrompt } = await import("../harness/memory.js");
+                const currentVer = memoryVersion();
+                if (currentVer > lastMemoryVer) {
+                    const fresh = memoriesToPrompt(loadActiveMemories());
+                    // Replace or append memory section in fullSystemPrompt
+                    if (fullSystemPrompt.includes("# Remembered Context")) {
+                        fullSystemPrompt = fullSystemPrompt.replace(/# Remembered Context[\s\S]*?(?=\n# |$)/, fresh);
+                    }
+                    else if (fresh) {
+                        fullSystemPrompt += `\n\n${fresh}`;
+                    }
+                    lastMemoryVer = currentVer;
                 }
             }
-            const tokensAfter = estimateMessagesTokens(state.messages, estimateTokens);
-            yield {
-                type: "error",
-                message: `Context compressed (${strategy}): ${tokensBefore} → ${tokensAfter} tokens. Re-read any files you need.`,
-            };
-        }
-        else if (estimatedTokens > contextWindow * 0.8) {
-            yield {
-                type: "error",
-                message: "Context compression disabled (3 consecutive failures). Consider starting a new session.",
-            };
-        }
-        // ── Dynamic prompt: refresh memories if changed, inject warnings ──
-        try {
-            const { memoryVersion, loadActiveMemories, memoriesToPrompt } = await import("../harness/memory.js");
-            const currentVer = memoryVersion();
-            if (currentVer > lastMemoryVer) {
-                const fresh = memoriesToPrompt(loadActiveMemories());
-                // Replace or append memory section in fullSystemPrompt
-                if (fullSystemPrompt.includes("# Remembered Context")) {
-                    fullSystemPrompt = fullSystemPrompt.replace(/# Remembered Context[\s\S]*?(?=\n# |$)/, fresh);
+            catch {
+                /* memory refresh optional */
+            }
+            let turnPrompt = fullSystemPrompt;
+            if (config.maxCost && config.maxCost > 0) {
+                const pct = state.totalCost / config.maxCost;
+                if (pct >= 0.9) {
+                    turnPrompt += `\n\n⚠️ BUDGET CRITICAL: Only $${(config.maxCost - state.totalCost).toFixed(4)} remaining. Provide final response NOW.`;
                 }
-                else if (fresh) {
-                    fullSystemPrompt += `\n\n${fresh}`;
+                else if (pct >= 0.7) {
+                    turnPrompt += `\n\n⚠️ BUDGET WARNING: ${Math.round((1 - pct) * 100)}% budget remaining. Start consolidating.`;
                 }
-                lastMemoryVer = currentVer;
             }
-        }
-        catch {
-            /* memory refresh optional */
-        }
-        let turnPrompt = fullSystemPrompt;
-        if (config.maxCost && config.maxCost > 0) {
-            const pct = state.totalCost / config.maxCost;
-            if (pct >= 0.9) {
-                turnPrompt += `\n\n⚠️ BUDGET CRITICAL: Only $${(config.maxCost - state.totalCost).toFixed(4)} remaining. Provide final response NOW.`;
+            if (state.turn >= maxTurns * 0.9 && maxTurns > 1) {
+                turnPrompt += `\n\n⚠️ TURN LIMIT: ${maxTurns - state.turn} turn(s) remaining. Wrap up.`;
             }
-            else if (pct >= 0.7) {
-                turnPrompt += `\n\n⚠️ BUDGET WARNING: ${Math.round((1 - pct) * 100)}% budget remaining. Start consolidating.`;
-            }
-        }
-        if (state.turn >= maxTurns * 0.9 && maxTurns > 1) {
-            turnPrompt += `\n\n⚠️ TURN LIMIT: ${maxTurns - state.turn} turn(s) remaining. Wrap up.`;
-        }
-        // ── LLM call with streaming ──
-        let assistantContent = "";
-        const toolCalls = [];
-        let streamError = null;
-        const streamingExecutor = new StreamingToolExecutor(config.tools, toolContext, config.permissionMode, config.askUser, config.abortSignal);
-        try {
-            const ctxUsage = estimateRouteContextUsage(state.messages, config.provider, config.model ?? "");
-            const selection = router.select({
-                turn: state.turn,
-                hadToolCalls: state.lastTurnHadTools ?? false,
-                toolCallCount: state.lastTurnToolCount ?? 0,
-                contextUsage: ctxUsage,
-                isFinalResponse: (state.lastTurnHadTools === false || state.lastTurnHadTools === undefined) && state.turn > 1,
-                role: config.role,
-            });
-            for await (const event of config.provider.stream(state.messages, turnPrompt, apiTools, selection.model)) {
-                if (config.abortSignal?.aborted)
-                    break;
-                switch (event.type) {
-                    case "text_delta":
-                        assistantContent += event.content;
-                        yield event;
-                        break;
-                    case "tool_call_start":
-                        toolCalls.push({ id: event.callId, toolName: event.toolName, arguments: {} });
-                        yield event;
+            // ── LLM call with streaming ──
+            let assistantContent = "";
+            const toolCalls = [];
+            let streamError = null;
+            const streamingExecutor = new StreamingToolExecutor(config.tools, toolContext, config.permissionMode, config.askUser, config.abortSignal);
+            try {
+                const ctxUsage = estimateRouteContextUsage(state.messages, config.provider, config.model ?? "");
+                const selection = router.select({
+                    turn: state.turn,
+                    hadToolCalls: state.lastTurnHadTools ?? false,
+                    toolCallCount: state.lastTurnToolCount ?? 0,
+                    contextUsage: ctxUsage,
+                    isFinalResponse: (state.lastTurnHadTools === false || state.lastTurnHadTools === undefined) && state.turn > 1,
+                    role: config.role,
+                });
+                for await (const event of config.provider.stream(state.messages, turnPrompt, apiTools, selection.model)) {
+                    if (config.abortSignal?.aborted)
                         break;
-                    case "tool_call_complete": {
-                        const tc = toolCalls.find((t) => t.id === event.callId);
-                        if (tc) {
-                            const idx = toolCalls.indexOf(tc);
-                            toolCalls[idx] = { ...tc, arguments: event.arguments };
+                    switch (event.type) {
+                        case "text_delta":
+                            assistantContent += event.content;
+                            yield event;
+                            break;
+                        case "tool_call_start":
+                            toolCalls.push({ id: event.callId, toolName: event.toolName, arguments: {} });
+                            yield event;
+                            break;
+                        case "tool_call_complete": {
+                            const tc = toolCalls.find((t) => t.id === event.callId);
+                            if (tc) {
+                                const idx = toolCalls.indexOf(tc);
+                                toolCalls[idx] = { ...tc, arguments: event.arguments };
+                            }
+                            if (streamingExecutor) {
+                                streamingExecutor.addTool({ id: event.callId, toolName: event.toolName, arguments: event.arguments });
+                            }
+                            break;
                         }
-                        if (streamingExecutor) {
-                            streamingExecutor.addTool({ id: event.callId, toolName: event.toolName, arguments: event.arguments });
-                        }
-                        break;
+                        case "cost_update":
+                            state.totalCost += event.cost;
+                            state.totalInputTokens += event.inputTokens;
+                            state.totalOutputTokens += event.outputTokens;
+                            yield event;
+                            break;
+                        case "error":
+                            yield event;
+                            break;
                     }
-                    case "cost_update":
-                        state.totalCost += event.cost;
-                        state.totalInputTokens += event.inputTokens;
-                        state.totalOutputTokens += event.outputTokens;
-                        yield event;
-                        break;
-                    case "error":
-                        yield event;
-                        break;
                 }
+                state.consecutiveErrors = 0;
             }
-            state.consecutiveErrors = 0;
-        }
-        catch (err) {
-            streamError = err instanceof Error ? err : new Error(String(err));
-            state.consecutiveErrors++;
-            // Circuit breaker
-            if (state.consecutiveErrors >= MAX_CONSECUTIVE_ERRORS) {
-                yield {
-                    type: "error",
-                    message: `Too many consecutive errors (${state.consecutiveErrors}): ${streamError.message}`,
-                };
+            catch (err) {
+                streamError = err instanceof Error ? err : new Error(String(err));
+                state.consecutiveErrors++;
+                // Circuit breaker
+                if (state.consecutiveErrors >= MAX_CONSECUTIVE_ERRORS) {
+                    yield {
+                        type: "error",
+                        message: `Too many consecutive errors (${state.consecutiveErrors}): ${streamError.message}`,
+                    };
+                    yield { type: "turn_complete", reason: "error" };
+                    return;
+                }
+                // Error recovery cascade
+                if (isRateLimitError(streamError) || isOverloadError(streamError)) {
+                    const attempt = state.consecutiveErrors;
+                    const isOverload = isOverloadError(streamError);
+                    if (attempt <= MAX_RATE_LIMIT_RETRIES) {
+                        const baseRetry = 2 ** attempt * (isOverload ? 2 : 1);
+                        const retryIn = baseRetry * (0.5 + Math.random());
+                        yield { type: "rate_limited", retryIn: Math.round(retryIn), attempt };
+                        await new Promise((r) => setTimeout(r, retryIn * 1000));
+                        continue;
+                    }
+                    yield {
+                        type: "error",
+                        message: `${isOverload ? "Server overloaded" : "Rate limit exceeded"} after ${MAX_RATE_LIMIT_RETRIES} retries.`,
+                    };
+                    yield { type: "turn_complete", reason: "error" };
+                    return;
+                }
+                if (isPromptTooLongError(streamError)) {
+                    state.promptTooLongRetries = (state.promptTooLongRetries ?? 0) + 1;
+                    if (state.promptTooLongRetries > 2) {
+                        yield { type: "error", message: "Context still too long after 2 compression attempts." };
+                        yield { type: "turn_complete", reason: "error" };
+                        return;
+                    }
+                    state.messages = compressMessages(state.messages, Math.floor(contextWindow * 0.5));
+                    state.transition = "retry_prompt_too_long";
+                    yield { type: "error", message: "Context too long, compressing history..." };
+                    continue;
+                }
+                if (isNetworkError(streamError)) {
+                    state.transition = "retry_network";
+                    const delay = 1000 * 2 ** (state.consecutiveErrors - 1);
+                    yield { type: "error", message: `Network error, retrying in ${delay / 1000}s...` };
+                    await new Promise((r) => setTimeout(r, delay));
+                    continue;
+                }
+                yield { type: "error", message: streamError.message };
                 yield { type: "turn_complete", reason: "error" };
                 return;
             }
-            // Error recovery cascade
-            if (isRateLimitError(streamError) || isOverloadError(streamError)) {
-                const attempt = state.consecutiveErrors;
-                const isOverload = isOverloadError(streamError);
-                if (attempt <= MAX_RATE_LIMIT_RETRIES) {
-                    const baseRetry = 2 ** attempt * (isOverload ? 2 : 1);
-                    const retryIn = baseRetry * (0.5 + Math.random());
-                    yield { type: "rate_limited", retryIn: Math.round(retryIn), attempt };
-                    await new Promise((r) => setTimeout(r, retryIn * 1000));
-                    continue;
-                }
+            if (config.abortSignal?.aborted) {
+                yield { type: "turn_complete", reason: "aborted" };
+                return;
+            }
+            if (assistantContent === "" && toolCalls.length === 0) {
                 yield {
                     type: "error",
-                    message: `${isOverload ? "Server overloaded" : "Rate limit exceeded"} after ${MAX_RATE_LIMIT_RETRIES} retries.`,
+                    message: "No response received. Check that your model server is running and the model name is correct.",
                 };
-                yield { type: "turn_complete", reason: "error" };
                 return;
             }
-            if (isPromptTooLongError(streamError)) {
-                state.promptTooLongRetries = (state.promptTooLongRetries ?? 0) + 1;
-                if (state.promptTooLongRetries > 2) {
-                    yield { type: "error", message: "Context still too long after 2 compression attempts." };
-                    yield { type: "turn_complete", reason: "error" };
-                    return;
-                }
-                state.messages = compressMessages(state.messages, Math.floor(contextWindow * 0.5));
-                state.transition = "retry_prompt_too_long";
-                yield { type: "error", message: "Context too long, compressing history..." };
-                continue;
+            state.messages.push(createAssistantMessage(assistantContent, toolCalls.length > 0 ? toolCalls : undefined));
+            if (toolCalls.length === 0) {
+                yield { type: "turn_complete", reason: "completed" };
+                return;
             }
-            if (isNetworkError(streamError)) {
-                state.transition = "retry_network";
-                const delay = 1000 * 2 ** (state.consecutiveErrors - 1);
-                yield { type: "error", message: `Network error, retrying in ${delay / 1000}s...` };
-                await new Promise((r) => setTimeout(r, delay));
-                continue;
+            // Collect streaming tool results
+            await streamingExecutor.waitForAll();
+            const completedResults = [...streamingExecutor.getCompletedResults()];
+            const executedIds = new Set(completedResults.map((r) => r.toolCall.id));
+            for (const { callId, chunk } of streamingExecutor.outputChunks) {
+                yield { type: "tool_output_delta", callId, chunk };
             }
-            yield { type: "error", message: streamError.message };
-            yield { type: "turn_complete", reason: "error" };
-            return;
-        }
-        if (config.abortSignal?.aborted) {
-            yield { type: "turn_complete", reason: "aborted" };
-            return;
-        }
-        if (assistantContent === "" && toolCalls.length === 0) {
-            yield {
-                type: "error",
-                message: "No response received. Check that your model server is running and the model name is correct.",
-            };
-            return;
-        }
-        state.messages.push(createAssistantMessage(assistantContent, toolCalls.length > 0 ? toolCalls : undefined));
-        if (toolCalls.length === 0) {
-            yield { type: "turn_complete", reason: "completed" };
-            return;
-        }
-        // Collect streaming tool results
-        await streamingExecutor.waitForAll();
-        const completedResults = [...streamingExecutor.getCompletedResults()];
-        const executedIds = new Set(completedResults.map((r) => r.toolCall.id));
-        for (const { callId, chunk } of streamingExecutor.outputChunks) {
-            yield { type: "tool_output_delta", callId, chunk };
-        }
-        for (const { toolCall: tc, result } of completedResults) {
-            yield { type: "tool_call_end", callId: tc.id, output: result.output, isError: result.isError };
-            // Apply context budget to tool output
-            const budgetedOutput = contextManager.enforceToolBudget(tc.toolName, result.output);
-            state.messages.push(createToolResultMessage({ callId: tc.id, output: budgetedOutput, isError: result.isError }));
-        }
-        // Execute remaining tools not started during streaming
-        const remaining = toolCalls.filter((tc) => !executedIds.has(tc.id));
-        if (remaining.length > 0) {
-            yield* executeToolCalls(remaining, config.tools, toolContext, config.permissionMode, config.askUser, state, config.permissionPromptTool);
+            for (const { toolCall: tc, result } of completedResults) {
+                yield { type: "tool_call_end", callId: tc.id, output: result.output, isError: result.isError };
+                // Apply context budget to tool output
+                const budgetedOutput = contextManager.enforceToolBudget(tc.toolName, result.output);
+                state.messages.push(createToolResultMessage({ callId: tc.id, output: budgetedOutput, isError: result.isError }));
+            }
+            // Execute remaining tools not started during streaming
+            const remaining = toolCalls.filter((tc) => !executedIds.has(tc.id));
+            if (remaining.length > 0) {
+                yield* executeToolCalls(remaining, config.tools, toolContext, config.permissionMode, config.askUser, state, config.permissionPromptTool);
+            }
+            state.lastTurnHadTools = toolCalls.length > 0;
+            state.lastTurnToolCount = toolCalls.length;
+            state.transition = "next_turn";
         }
-        state.lastTurnHadTools = toolCalls.length > 0;
-        state.lastTurnToolCount = toolCalls.length;
-        state.transition = "next_turn";
+        yield { type: "turn_complete", reason: "max_turns" };
+    }
+    finally {
+        if (querySpanId)
+            config.tracer?.endSpan(querySpanId, "ok", { turns: state.turn });
     }
-    yield { type: "turn_complete", reason: "max_turns" };
 }
 //# sourceMappingURL=index.js.map

package/dist/query/tools.js

@@ -216,6 +216,7 @@ export async function executeSingleTool(toolCall, tools, context, permissionMode
         return { output: "Blocked by preToolUse hook.", isError: true };
     }
     // Execute with timeout and result budgeting
+    const toolSpanId = context.tracer?.startSpan(`tool:${tool.name}`, { riskLevel: tool.riskLevel }, context.parentSpanId);
     try {
         const toolAbort = AbortSignal.timeout(TOOL_TIMEOUT_MS);
         const contextWithTimeout = { ...context, abortSignal: context.abortSignal ?? toolAbort };
@@ -225,6 +226,8 @@ export async function executeSingleTool(toolCall, tools, context, permissionMode
                 toolAbort.addEventListener("abort", () => reject(new Error(`Tool '${tool.name}' timed out after ${TOOL_TIMEOUT_MS / 1000}s`)));
             }),
         ]);
+        if (toolSpanId)
+            context.tracer?.endSpan(toolSpanId, result.isError ? "error" : "ok");
         // Hook: postToolUse / postToolUseFailure (mutually exclusive — strict CC parity)
         if (result.isError) {
             emitHook("postToolUseFailure", {
@@ -300,6 +303,8 @@ export async function executeSingleTool(toolCall, tools, context, permissionMode
     catch (err) {
         const errMsg = err instanceof Error ? err.message : String(err);
         const errName = err instanceof Error ? err.name : "ExecutionError";
+        if (toolSpanId)
+            context.tracer?.endSpan(toolSpanId, "error", { error: errMsg });
         emitHook("postToolUseFailure", {
             toolName: tool.name,
             toolArgs: JSON.stringify(toolCall.arguments).slice(0, 1000),

package/dist/query/types.d.ts

@@ -1,6 +1,7 @@
 /**
  * Shared types for the query loop sub-modules.
  */
+import type { SessionTracer } from "../harness/traces.js";
 import type { Provider } from "../providers/base.js";
 import type { Tools } from "../Tool.js";
 import type { Message } from "../types/message.js";
@@ -32,6 +33,8 @@ export type QueryConfig = {
      * the tool is missing, throws, or returns malformed JSON.
      */
     permissionPromptTool?: string;
+    /** Optional session tracer. When set, query() emits `query` and `tool:<Name>` spans. */
+    tracer?: SessionTracer;
 };
 export type TransitionReason = "next_turn" | "retry_network" | "retry_prompt_too_long" | "retry_max_output_tokens";
 export type QueryLoopState = {

package/dist/repl.js

@@ -2,6 +2,7 @@
  * Imperative REPL — extracted business logic from React REPL.tsx.
  * Uses TerminalRenderer for display instead of Ink.
  */
+import { readdirSync, statSync } from "node:fs";
 import { homedir } from "node:os";
 import { getCommandEntries } from "./commands/index.js";
 import { roll } from "./cybergotchi/bones.js";
@@ -64,6 +65,26 @@ export async function startREPL(config) {
     // Initialize checkpoints for file rewind
     const { initCheckpoints } = await import("./harness/checkpoints.js");
     initCheckpoints(session.id);
+    // Optional session-wide tracer. Opt-in via OH_TRACE=1 env var.
+    // Persists OTel-style spans to ~/.oh/traces/<sessionId>.jsonl.
+    // When OH_OTLP_ENDPOINT is also set, ships each ended span via fire-and-forget
+    // HTTP POST to the configured collector (Jaeger, Honeycomb, Grafana Tempo, etc.).
+    // OH_OTLP_HEADERS is a JSON-encoded headers object, e.g. '{"Authorization":"Bearer ..."}'.
+    let tracer;
+    if (process.env.OH_TRACE === "1") {
+        const { SessionTracer } = await import("./harness/traces.js");
+        const otlpEndpoint = process.env.OH_OTLP_ENDPOINT;
+        let otlpHeaders;
+        if (process.env.OH_OTLP_HEADERS) {
+            try {
+                otlpHeaders = JSON.parse(process.env.OH_OTLP_HEADERS);
+            }
+            catch {
+                /* malformed JSON in env — skip headers, ship without auth */
+            }
+        }
+        tracer = new SessionTracer(session.id, otlpEndpoint ? { endpoint: otlpEndpoint, headers: otlpHeaders } : undefined);
+    }
     // Start background cron executor
     const { CronExecutor } = await import("./services/CronExecutor.js");
     const cronExecutor = new CronExecutor(config.provider, config.tools, config.systemPrompt, config.permissionMode, config.model);
@@ -165,7 +186,6 @@ export async function startREPL(config) {
                 const dir = lastSep >= 0 ? expanded.slice(0, lastSep + 1) : ".";
                 const prefix = lastSep >= 0 ? expanded.slice(lastSep + 1) : expanded;
                 try {
-                    const { readdirSync, statSync } = require("node:fs");
                     const entries = readdirSync(dir)
                         .filter((name) => name.toLowerCase().startsWith(prefix.toLowerCase()))
                         .slice(0, 10);
@@ -900,6 +920,7 @@ export async function startREPL(config) {
             askUserQuestion,
             model: currentModel || undefined,
             abortSignal: abortController.signal,
+            tracer,
         };
         try {
             for await (const event of query(prompt, queryConfig, messages)) {

package/dist/services/AgentDispatcher.js

@@ -161,6 +161,13 @@ export class AgentDispatcher {
                 if (filtered.length > 0)
                     taskTools = filtered;
             }
+            // Plumb cwd through config.workingDir so parallel runTask calls don't
+            // race on the global process.cwd(). The query loop seeds ToolContext
+            // with this value; built-in tools (FileRead, Glob, Bash, …) honor it.
+            // Previously this method called `process.chdir(worktreePath)` and a
+            // matching `process.chdir(originalCwd)` in `finally` — but since
+            // `process.cwd()` is process-wide, two concurrent tasks would clobber
+            // each other's directory mid-execution.
             const config = {
                 provider: this.provider,
                 tools: taskTools,
@@ -169,6 +176,7 @@ export class AgentDispatcher {
                 model: this.model,
                 maxTurns: 20,
                 abortSignal: this.abortSignal,
+                workingDir: worktreePath ?? cwd,
             };
             // Inject blocker results as context
             let promptWithContext = task.prompt;
@@ -184,37 +192,16 @@ export class AgentDispatcher {
                     promptWithContext = `${blockerContext}\n\n---\n\n${task.prompt}`;
                 }
             }
-            const originalCwd = process.cwd();
-            if (worktreePath) {
-                try {
-                    process.chdir(worktreePath);
-                }
-                catch {
-                    /* ignore */
-                }
-            }
             let output = "";
             let errorMessage = null;
-            try {
-                for await (const event of query(promptWithContext, config)) {
-                    if (event.type === "text_delta")
-                        output += event.content;
-                    if (event.type === "error") {
-                        errorMessage = event.message;
-                        break;
-                    }
-                    forwardChildEvent(event, taskCallId, this.emitChildEvent);
-                }
-            }
-            finally {
-                if (worktreePath) {
-                    try {
-                        process.chdir(originalCwd);
-                    }
-                    catch {
-                        /* ignore */
-                    }
+            for await (const event of query(promptWithContext, config)) {
+                if (event.type === "text_delta")
+                    output += event.content;
+                if (event.type === "error") {
+                    errorMessage = event.message;
+                    break;
                 }
+                forwardChildEvent(event, taskCallId, this.emitChildEvent);
             }
             if (errorMessage !== null) {
                 result = { id: task.id, output: `Error: ${errorMessage}`, isError: true, durationMs: Date.now() - start };