Verify each finding against the current code and only fix it if needed.

Inline comments:
In `@packages/core/src/core/client.ts`:
- Around line 964-972: The recursion in sendMessageStream forwards the original
options and causes a continuation to start a new root turn span (startTurnSpan)
even when an active turn for the same prompt_id already exists (ownsTurnSpan ===
true); update the continuation path so it reuses the existing active turn span
instead of starting a new one by either (A) guarding startTurnSpan with the
active-turn helper (check for an active turn/span for prompt_id before calling
startTurnSpan and only set ownsTurnSpan when you actually created the span), or
(B) mark the recursive continuation as a non-owning internal continuation (pass
a flag in options to indicate non-owning continuation so startTurnSpan is
skipped), and ensure ownsTurnSpan/endTurnSpan logic only runs when the span was
created by this invocation.
- Around line 477-485: Start the turn span with
startTurnSpan(this.config.getSessionId(), prompt_id) immediately before entering
the generator logic and ensure endTurnSpan() is called inside a finally block so
the turn span is always closed regardless of errors or early exits; update the
code around startTurnSpan/endTurnSpan in the generator to wrap the main body in
try { ... } finally { endTurnSpan() }. Also modify the recursive continuation
call that currently reuses the original options (the call near the recursion
around the symbol options/prompt continuation) to pass an explicit non-root type
such as { type: SendMessageType.Hook } (or another non-root SendMessageType)
instead of the original options so recursive continuations reuse the active span
instead of attempting to start a second root span for the same prompt_id.

In `@packages/core/src/core/coreToolScheduler.ts`:
- Around line 1477-1481: Record the tool duration on all non-success exit paths
by setting the same 'tool.duration_ms' attribute on the toolSpan before calling
setStatus or setAttribute for errors/cancellations; locate the span handling
code around toolSpan (where you currently call toolSpan.setStatus and
toolSpan.setAttribute('error.message', ...)) and compute the elapsed ms the same
way as the success branch, then call toolSpan.setAttribute('tool.duration_ms',
durationMs) for the cancelled, hook-blocked, and error branches (also apply
identical additions at the other occurrences around the file noted in the
review: the blocks near lines handling similar toolSpan exits at the other five
locations).

In `@packages/core/src/core/geminiContentGenerator/geminiContentGenerator.ts`:
- Around line 179-188: The code currently emits raw prompt/completion content
when logPrompts is truthy (see logPrompts, span.addEvent and
finalRequest.contents); update the implementation to require an explicit opt-in
flag (e.g., a clearly named allowTelemetryRawPrompts or
explicitTelemetryConsent) before serializing and adding span events, and ensure
the default for getTelemetryLogPromptsEnabled() is false so enabling Langfuse
does not automatically export sensitive payloads; apply the same change pattern
to the other locations referenced (lines ~196-208, ~248-257, ~303-312) so all
span.addEvent calls that include raw prompt/completion content are gated behind
the explicit opt-in flag.

In `@packages/core/src/core/openaiContentGenerator/pipeline.ts`:
- Around line 266-300: The OTel span attached to context.span in
processStreamWithLogging (used with lastResponse and completionParts) can remain
open if the consumer stops iterating early; move all span cleanup (setting final
attributes, adding events from completionParts, setting status) into a finally
block so context.span.end() is always executed regardless of normal completion,
error, or early generator termination, and ensure any existing
span.setAttributes / addEvent calls run before ending the span inside that
finally.

In `@packages/core/src/telemetry/turnSpanContext.ts`:
- Around line 21-23: The module-global mutable state activeTurnSpan and
activeTurnContext in turnSpanContext.ts causes cross-request races when
startTurnSpan() / endTurnSpan() are called concurrently; replace this
process-global singleton with per-execution storage (e.g. Node's
AsyncLocalStorage or explicit context objects threaded through calls) so each
turn gets its own Span and OTel Context; update startTurnSpan(), endTurnSpan(),
and any getters to read/write from the per-execution store (or accept/return a
context object) instead of using activeTurnSpan/activeTurnContext to prevent one
turn from stealing or ending another turn's span.

In `@packages/core/src/tools/agent.ts`:
- Around line 675-680: Background agents are currently passed the request-scoped
signal (the call to subagent.execute(contextState, signal)), which causes
background work to be cancelled when the originating request aborts; instead,
create a new, independent AbortController for background jobs (e.g., const
bgController = new AbortController()) and pass bgController.signal into
subagent.execute(contextState, bgController.signal), ensuring you do not forward
the request-scoped signal. Also wire bgController.abort() to whatever
agent-level shutdown lifecycle you already have (so background tasks can be
cancelled on explicit shutdown) and ensure you clean up the controller when the
subagent finishes; update any places constructing the background job (the
run_in_background / subagent.execute call) to use this independent controller.

In `@README.md`:
- Around line 164-174: Clarify that only LANGFUSE_PUBLIC_KEY and
LANGFUSE_SECRET_KEY are required (LANGFUSE_BASE_URL is optional) and update the
code fence to specify the language; change the prose from "Set three environment
variables" to "Set the following environment variables (BASE_URL is optional)"
and add the bash language tag to the fenced block so it becomes ```bash with the
three env vars LANGFUSE_PUBLIC_KEY, LANGFUSE_SECRET_KEY, and LANGFUSE_BASE_URL
shown (noting BASE_URL is optional).

---

Nitpick comments:
In @.gitignore:
- Line 2: The .gitignore currently contains the pattern "jobs/" which matches
any directory named jobs anywhere in the repo; change this to a root-anchored
rule by replacing the pattern with "/jobs/" so it only ignores the jobs
directory at the repository root (update the existing "jobs/" entry to
"/jobs/").

In `@packages/core/src/core/openaiContentGenerator/pipeline.ts`:
- Around line 131-132: The streamed completion buffer completionParts currently
accumulates the entire response causing a second full copy in memory; limit its
growth by capping appended text to the telemetry preview/truncation limit (e.g.,
10_000 chars): before pushing/concatenating each incoming chunk in the pipeline
handler (and the similar places referenced where completionParts is appended),
check the current accumulated length and only append up to (limit -
currentLength) characters from the chunk (or skip appending if already at/above
the limit); apply the same guard to all occurrences that build completionParts
so the preview buffer never exceeds the event truncation limit.

Verify each finding against the current code and only fix it if needed.

Duplicate comments:
In `@README.md`:
- Around line 164-174: Update the README section so it correctly states that
only LANGFUSE_PUBLIC_KEY and LANGFUSE_SECRET_KEY are required while
LANGFUSE_BASE_URL is optional, change the phrase "Set three environment
variables" to reflect "Set the following environment variables (BASE_URL
optional)", and add a language tag to the fenced code block (e.g., ```bash) so
MD040 is satisfied; finally reformat the Markdown with Prettier to apply
linting/style fixes.

Verify each finding against the current code and only fix it if needed.

Duplicate comments:
In `@packages/core/src/core/openaiContentGenerator/pipeline.ts`:
- Around line 266-300: The OTel span for streaming (context.span) can be left
open if iteration is cancelled early; update processStreamWithLogging so span
finalization (setting status and calling context.span.end()) is moved into a
finally block that always runs, and only set SpanStatusCode.OK after the stream
was fully and successfully consumed (i.e., set OK in the normal completion path,
not before consumption). Concretely: wrap the streaming/iteration logic inside
try { ... } catch { set error status/attributes } finally { if (context.span &&
!context.spanEnded) { set any remaining attributes/usage from lastResponse, add
completion event if needed, and call context.span.end() } } — reference the
functions/processors processStreamWithLogging, executeWithErrorHandling, and the
context.span usages (setAttributes, setAttribute, addEvent, end) to locate where
to move the logic and guard against double-ending the span.

---

Nitpick comments:
In `@packages/core/src/core/openaiContentGenerator/pipeline.ts`:
- Around line 131-132: The streaming telemetry buffer completionParts is
unbounded; introduce a MAX_TELEMETRY_CHARS (e.g. 10_000) constant and ensure all
places that append to completionParts (the collection initialized as const
completionParts: string[] and the other append sites referenced around the same
streaming handlers at the later blocks) only accumulate up to that limit —
either stop appending once the total joined length reaches MAX_TELEMETRY_CHARS
or only append a truncated slice of the incoming chunk so the buffer never grows
beyond MAX_TELEMETRY_CHARS; apply the same cap to the other streaming
accumulation sites (the blocks noted at the subsequent locations) so emitted
telemetry is still truncated to 10k but in-memory buffering is bounded.