@parall/claude-agent 1.58.2 → 1.60.0

package/src/dispatch.ts

@@ -4,24 +4,28 @@ import * as fs from 'node:fs';
 import * as path from 'node:path';
 import type {
   CleanupForkOpts,
+  CompactOpts,
+  CompactResult,
   DispatchAdapter,
   DispatchInputLifecycle,
   DispatchOpts,
   ForkOpts,
   GatewayLogger,
+  RuntimeActivityEvent,
+  RuntimeBusyState,
   RuntimeEvent,
 } from '@parall/agent-core';
+import { isRuntimeBusy, projectRuntimeEvent, RuntimeActivityPort } from '@parall/agent-core';
 import {
   appendPreparedLocalAttachmentRefs,
   pinLocalAttachmentPaths,
 } from '@parall/agent-core/internal/attachment-input';
+import { runClaudeCompact } from './compact.js';
+import { aggregateBusyState, DEFAULT_FOLLOW_UP_HOLD_MS } from './busy-state.js';
 import type { ClaudeAgentConfig } from './config.js';
 import { type ClaudeInputDelivery, ClaudeInputRegistry } from './input-lifecycle.js';
-import {
-  type ClaudeParsedEvent,
-  type ClaudeResultMeta,
-  parseClaudeStreamJson,
-} from './output-parser.js';
+import { parseClaudeStreamJson } from './output-parser.js';
+import { ClaudeProcessPump } from './process-pump.js';
 import type { ClaudeProcessHandle, ClaudeSessionManager } from './session-manager.js';
 import { buildSpawnEnv } from './spawn-env.js';
 import { classifyClaudeTurn } from './turn-outcome.js';
@@ -69,6 +73,14 @@ type ClaudeCodeAdapterOptions = Pick<
    * subprocess on its next shell command — no respawn needed.
    */
   capabilityBinDir?: string;
+  /**
+   * How long the bridge stays busy after a background task finishes,
+   * waiting for the follow-up turn the CLI usually runs on that
+   * notification (busy-state.ts). Default 30 s.
+   */
+  followUpHoldMs?: number;
+  /** Test port. */
+  now?: () => number;
 };
 
 const IS_WIN32 = process.platform === 'win32';
@@ -93,31 +105,38 @@ function killWin32Tree(pid: number): boolean {
 /**
  * Per-sessionKey long-lived process state. The process stays alive across
  * dispatches; each dispatch writes one NDJSON user message to stdin and
- * drains stdout until `turn_end`. Between dispatches the process is idle —
- * gateway's `drainMainBuffer` serializes dispatch calls so no concurrent
- * access to the same process occurs.
+ * drains the envelopes the stdout pump routes to that delivery until its
+ * lifecycle terminal. The pump (process-pump.ts) is the ONLY stdout reader:
+ * between dispatches it keeps reading, so turns the CLI starts on its own
+ * (background-task follow-ups) are observed instead of piling up in the
+ * pipe. Gateway's `drainMainBuffer` serializes dispatch calls per
+ * sessionKey, so no two drains compete for the same delivery.
  */
-type ProcessState = {
+export type ProcessState = {
   handle: ClaudeProcessHandle;
-  parser: AsyncGenerator<ClaudeParsedEvent>;
+  pump: ClaudeProcessPump;
   done: boolean;
   needsRestart: boolean;
-  capabilities?: Set<string>;
   inputs: ClaudeInputRegistry;
+  log?: GatewayLogger;
 };
 
 export class ClaudeCodeAdapter implements DispatchAdapter {
   readonly inputLifecycleMode = 'explicit' as const;
   private readonly processes = new Map<string, ProcessState>();
+  /** Retired by abortDispatch while the CLI still had its own work: busy until idle, then terminated. */
+  private readonly retiring = new Set<ProcessState>();
   private capabilityProbe?: Promise<void>;
   private capabilityProbeHandle?: ClaudeProcessHandle;
   private shuttingDown = false;
+  private readonly activity: RuntimeActivityPort;
   private _model: string | undefined;
   private _effortLevel: string | undefined;
   private _contextWindow: number | undefined;
   private _maxTokens: number | undefined;
 
   constructor(private readonly opts: ClaudeCodeAdapterOptions) {
+    this.activity = new RuntimeActivityPort('ClaudeCodeAdapter');
     this._model = opts.model;
     this._contextWindow = opts.contextWindow;
     this._maxTokens = opts.maxTokens;
@@ -161,6 +180,26 @@ export class ClaudeCodeAdapter implements DispatchAdapter {
     }
   }
 
+  // --- runtime-initiated work -------------------------------------------------
+
+  subscribeRuntimeActivity(handler: (event: RuntimeActivityEvent) => void): () => void {
+    return this.activity.subscribe(handler);
+  }
+
+  busyState(now = this.now()): RuntimeBusyState {
+    const states: RuntimeBusyState[] = [];
+    for (const state of this.processes.values()) {
+      if (state.done) continue;
+      states.push(state.pump.busyState(now));
+    }
+    for (const state of this.retiring) states.push(state.pump.busyState(now));
+    return aggregateBusyState(states);
+  }
+
+  isBusy(now = this.now()): boolean {
+    return isRuntimeBusy(this.busyState(now), now);
+  }
+
   enqueueDuringDispatch(
     sessionKey: string,
     body: string,
@@ -174,7 +213,7 @@ export class ClaudeCodeAdapter implements DispatchAdapter {
     if (!state || state.done) return false;
     // A throwaway process already proved the CLI capability before any
     // business process started. The real process revalidates its own init.
-    if (!state.capabilities?.has('msg_lifecycle_v1')) return false;
+    if (!state.pump.capabilities.has('msg_lifecycle_v1')) return false;
     const { proc } = state.handle;
     if (proc.exitCode !== null || proc.signalCode !== null || proc.stdin.destroyed) return false;
     try {
@@ -195,15 +234,22 @@ export class ClaudeCodeAdapter implements DispatchAdapter {
   abortDispatch(sessionKey: string): void {
     const state = this.processes.get(sessionKey);
     if (!state || state.done) return;
-    for (const delivery of state.inputs.values()) {
-      if (!delivery.terminal) void state.inputs.failBestEffort(delivery);
-    }
+    state.pump.abortDeliveries('dispatch aborted');
     state.done = true;
-    try {
-      state.handle.proc.stdin.end();
-    } catch {
-      /* best-effort */
+    if (state.pump.hasOwnWork()) {
+      // The CLI has (or is about to start) a runtime-initiated turn: retire
+      // the process instead of ending stdin under it. Out of `processes` and
+      // the session manager so the next dispatch's fresh process does not
+      // SIGTERM it as replaced; terminated once the pump reports idle.
+      this.processes.delete(sessionKey);
+      this.opts.sessionManager.clearProcess(sessionKey, state.handle);
+      this.retiring.add(state);
+      state.pump.whenIdle(() => {
+        if (this.retiring.delete(state)) this.terminateHandle(state.handle);
+      });
+      return;
     }
+    this.endStdin(state.handle);
   }
 
   hasPendingInjections(sessionKey: string): boolean {
@@ -212,6 +258,23 @@ export class ClaudeCodeAdapter implements DispatchAdapter {
     return state.inputs.hasPendingInjections();
   }
 
+  hasUnsettledInjections(sessionKey: string): boolean {
+    const state = this.processes.get(sessionKey);
+    if (!state) return false;
+    return state.inputs.hasUnsettledInjections();
+  }
+
+  acknowledgeDiscardedInjection(sessionKey: string, deliveryKey: string): void {
+    const state = this.processes.get(sessionKey);
+    if (!state) return;
+    state.inputs.discardBookkeeping(deliveryKey);
+    // The discarded copy may have been the last thing a lazy restart was
+    // waiting on. Unlike the consume path's tail, the discarded delivery may
+    // still be RUNNING (non-terminal): killing the process now would fail a
+    // live input, so the restart also waits for every injection to settle.
+    this.maybeApplyRestart(sessionKey, state);
+  }
+
   async *dispatch({
     event,
     bodyForAgent,
@@ -232,19 +295,11 @@ export class ClaudeCodeAdapter implements DispatchAdapter {
         injected.drained = true;
         context.log?.info?.(`consuming steer input ${injected.commandUuid}`);
         try {
-          yield* this.consumeDelivery(
-            sessionKey,
-            existingState,
-            injected,
-            context.log,
-            noteActivity,
-          );
+          yield* this.consumeDelivery(sessionKey, existingState, injected, noteActivity);
         } finally {
           existingState.inputs.remove(injected);
         }
-        if (existingState.needsRestart && !existingState.inputs.hasPendingInjections()) {
-          this.killProcess(sessionKey, existingState);
-        }
+        this.maybeApplyRestart(sessionKey, existingState);
         return;
       }
     }
@@ -319,6 +374,12 @@ export class ClaudeCodeAdapter implements DispatchAdapter {
       this.killProcess(sessionKey, state);
     }
     this.processes.clear();
+    const retired = [...this.retiring];
+    this.retiring.clear();
+    for (const state of retired) {
+      state.pump.close('killed', 'Claude process terminated by the bridge');
+      this.terminateHandle(state.handle);
+    }
   }
 
   async shutdown(): Promise<void> {
@@ -331,6 +392,10 @@ export class ClaudeCodeAdapter implements DispatchAdapter {
     await this.opts.sessionManager.shutdownAll();
   }
 
+  private now(): number {
+    return (this.opts.now ?? Date.now)();
+  }
+
   private async *runTurn(
     sessionKey: string,
     promptBody: string,
@@ -352,7 +417,9 @@ export class ClaudeCodeAdapter implements DispatchAdapter {
       yield { type: 'error', message: `Claude spawn failed: ${String(err)}` };
       return;
     }
-    const delivery = state.inputs.register(deliveryKey, lifecycle, false);
+    // Registered BEFORE the stdin write: the pump may route this command's
+    // queued/started frames before the drain below starts.
+    const delivery = state.inputs.register(deliveryKey, lifecycle, false, noteActivity, log);
     try {
       this.writeUserMessage(state.handle, promptBody, delivery.commandUuid);
     } catch (err) {
@@ -364,12 +431,26 @@ export class ClaudeCodeAdapter implements DispatchAdapter {
     }
 
     try {
-      yield* this.consumeDelivery(sessionKey, state, delivery, log, noteActivity);
+      yield* this.consumeDelivery(sessionKey, state, delivery, noteActivity);
     } finally {
       state.inputs.remove(delivery);
     }
   }
 
+  /** Idle auto-compact (compact.ts): a `/compact` frame into the long-lived process. */
+  compact(opts: CompactOpts): Promise<CompactResult> {
+    return runClaudeCompact(
+      {
+        ensureRuntimeCapability: (log) => this.ensureRuntimeCapability(log),
+        ensureProcess: (sessionKey, log) => this.ensureProcess(sessionKey, log),
+        killProcess: (sessionKey, state) => this.killProcess(sessionKey, state),
+        writeUserMessage: (handle, text, uuid) => this.writeUserMessage(handle, text, uuid),
+        applyPendingRestart: (sessionKey, state) => this.maybeApplyRestart(sessionKey, state),
+      },
+      opts,
+    );
+  }
+
   private ensureRuntimeCapability(log: GatewayLogger | undefined): Promise<void> {
     if (!this.capabilityProbe) {
       const probe = this.probeRuntimeCapability(log);
@@ -430,197 +511,80 @@ export class ClaudeCodeAdapter implements DispatchAdapter {
   }
 
   /**
-   * Drain the shared stdout stream until the exact UUID written for target
-   * reaches a terminal lifecycle state. Other injected inputs may start and
-   * finish while this drain is active; their callbacks advance independently
-   * and their later bookkeeping dispatch becomes a no-op.
+   * Drain the envelopes the pump routed to `target` until its exact stdin
+   * UUID reaches a terminal lifecycle state. Other injected inputs may start
+   * and finish while this drain is active; their callbacks advance in the
+   * pump independently and their later bookkeeping dispatch becomes a no-op.
    */
   private async *consumeDelivery(
     sessionKey: string,
     state: ProcessState,
     target: ClaudeInputDelivery,
-    log: GatewayLogger | undefined,
     noteActivity: (() => void) | undefined,
   ): AsyncGenerator<RuntimeEvent> {
     if (target.terminal) return;
     const groupKey = randomUUID();
-    let sawError = false;
-    // Turn-outcome evidence for this dispatch (agent-turn-outcome-design
-    // §4.1). Lifecycle terminals — not turn_end — bound consumption, so the
-    // result frame for the turn that carried this delivery is the LAST
-    // non-poison turn_end observed before the terminal. Poison frames
-    // (num_turns: 0 startup artifacts) never overwrite evidence. At most one
-    // turn_outcome is emitted per dispatch, right before the generator
-    // returns; with no evidence and no crash, nothing is emitted and the
-    // legacy boolean error path stands (refine-only, never guess).
-    let lastResultMeta: ClaudeResultMeta | undefined;
-    const noticeTexts: string[] = [];
-    // usage_limit settles via the lane-level deferred complete; a failed-input
-    // report would race it with an immediate redrive into the choked LLM.
-    const settledAsLimit = () =>
-      classifyClaudeTurn(lastResultMeta, noticeTexts).outcome === 'usage_limit';
-
-    while (!target.terminal) {
-      const next = await state.parser.next();
-
-      if (next.done) {
-        state.done = true;
-        this.processes.delete(sessionKey);
-        const detail = state.handle.stderrChunks.join('').trim();
-        const exit = await state.handle.exitPromise.catch(
-          () => ({ code: null, signal: null }) as const,
-        );
-        if (detail) {
-          log?.warn?.(`subprocess stderr: ${detail}`);
-        }
-        if (settledAsLimit()) target.suppressFailReport = true;
-        await state.inputs.failBestEffort(target, log);
-        if (!sawError) {
-          yield {
-            type: 'error',
-            message:
-              detail ||
-              `Claude exited with code ${exit.code ?? 'unknown'}${exit.signal ? ` (${exit.signal})` : ''}`,
-          };
-        }
-        // No evidence at all classifies as runtime_crash (the process died
-        // before any result frame); with evidence, classify what we saw.
-        yield classifyClaudeTurn(lastResultMeta, noticeTexts);
-        return;
-      }
-
-      const parsed = next.value;
-      // Count every parser-observed CLI progress frame as activity, including
-      // command lifecycle, turn boundaries, and explicit activity markers
-      // for nested subagent frames that must not become RuntimeEvents.
-      noteActivity?.();
-
-      if (parsed.type === 'runtime_activity') continue;
-
-      if (parsed.type === 'runtime_init') {
-        state.capabilities = new Set(parsed.capabilities);
-        if (parsed.sessionId) {
-          this.opts.sessionManager.recordSessionId(sessionKey, parsed.sessionId);
-          yield {
-            type: 'runtime_session',
-            runtimeSessionId: parsed.sessionId,
-            runtimeLaneKey: sessionKey,
-          };
-        }
-        if (!state.capabilities.has('msg_lifecycle_v1')) {
-          await state.inputs.failBestEffort(target, log);
-          yield {
-            type: 'error',
-            message:
-              'Claude runtime lacks required msg_lifecycle_v1 capability; refusing heuristic input coverage',
-          };
-          this.killProcess(sessionKey, state);
-          return;
-        }
-        continue;
-      }
-
-      if (parsed.type === 'command_lifecycle') {
-        if (!state.capabilities?.has('msg_lifecycle_v1')) {
-          await state.inputs.failBestEffort(target, log);
-          yield {
-            type: 'error',
-            message: 'Claude emitted command lifecycle before advertising msg_lifecycle_v1',
-          };
-          this.killProcess(sessionKey, state);
-          return;
-        }
-        const delivery = state.inputs.getByCommand(parsed.commandUuid);
-        if (!delivery) {
-          log?.warn?.(`ignoring lifecycle for unknown Claude command ${parsed.commandUuid}`);
+    state.pump.setActiveDrain(target, noteActivity);
+    try {
+      while (true) {
+        const next = await target.sink.next();
+        if (next.done) return;
+        const envelope = next.value;
+        if (envelope.kind === 'runtime') {
+          yield projectRuntimeEvent(envelope.event, groupKey);
           continue;
         }
-        try {
-          await state.inputs.apply(delivery, parsed.state);
-        } catch (err) {
-          await state.inputs.failBestEffort(delivery, log);
+        if (envelope.kind === 'terminal') break;
+        // The process is gone (eof / killed), the dispatch was aborted, or
+        // the pump ended this owner's window: surface the error unless the
+        // stream already carried one, then classify what was observed (no
+        // evidence at all is a runtime_crash).
+        if (envelope.reason !== 'error_result' && !target.evidence.sawError) {
           yield {
             type: 'error',
-            message: `Claude input lifecycle update failed: ${String(err)}`,
+            message: envelope.message ?? `Claude turn ${envelope.reason}`,
           };
-          this.killProcess(sessionKey, state);
-          return;
-        }
-        continue;
-      }
-
-      if (parsed.type === 'turn_end') {
-        // Evidence capture: the poison startup frame (numTurns === 0) is a
-        // resume artifact, not a turn boundary — never let it overwrite real
-        // evidence.
-        if (parsed.numTurns !== 0) {
-          lastResultMeta = parsed.resultMeta;
         }
-        if (parsed.isError) {
-          const limitSettled = settledAsLimit();
-          const failedDelivery = parsed.userMessageUuid
-            ? state.inputs.getByCommand(parsed.userMessageUuid)
-            : undefined;
-          if (!failedDelivery) {
-            if (limitSettled) {
-              for (const delivery of state.inputs.values()) {
-                delivery.suppressFailReport = true;
-              }
-            }
-            await state.inputs.failAllBestEffort(log);
-            yield classifyClaudeTurn(lastResultMeta, noticeTexts);
-            this.killProcess(sessionKey, state);
-            return;
-          }
-          failedDelivery.resultFailed = true;
-          if (limitSettled) failedDelivery.suppressFailReport = true;
-        }
-        // result adjacency is not a consumption boundary: the matching
-        // command_lifecycle(completed) may follow it or interleave with a
-        // different queued/injected command.
-        continue;
-      }
-
-      if (parsed.type === 'assistant_error') {
-        noticeTexts.push(parsed.message);
-        continue;
-      }
-
-      if (parsed.type === 'error') {
-        sawError = true;
-        yield parsed;
-        continue;
-      }
-
-      if (parsed.type === 'text') {
-        yield { ...parsed, project: false, groupKey };
-        continue;
-      }
-
-      if (parsed.type === 'runtime_session') {
-        yield parsed;
-        continue;
+        yield classifyClaudeTurn(target.evidence.lastResultMeta, target.evidence.noticeTexts);
+        return;
       }
 
-      if (parsed.type === 'turn_outcome') {
-        // (never produced by the parser — type guard only)
-        continue;
+      // Delivery reached a lifecycle terminal. Classify only when a result
+      // frame was observed in this owner's window: a delivery whose frames
+      // were drained by a sibling consumption window has no evidence here,
+      // and guessing would mislabel the turn (refine-only rule, §4.3).
+      if (target.evidence.lastResultMeta) {
+        yield classifyClaudeTurn(target.evidence.lastResultMeta, target.evidence.noticeTexts);
       }
-
-      yield { ...parsed, groupKey };
+    } finally {
+      state.pump.clearActiveDrain(target);
+      this.maybeApplyRestart(sessionKey, state);
     }
+  }
 
-    // Delivery reached a lifecycle terminal. Classify only when a result
-    // frame was observed during this drain: a delivery whose frames were
-    // drained by a sibling consumption window has no evidence here, and
-    // guessing would mislabel the turn (refine-only rule, §4.3).
-    if (lastResultMeta) {
-      yield classifyClaudeTurn(lastResultMeta, noticeTexts);
+  /**
+   * Lazy restart: kill the process so the next dispatch respawns it (the
+   * session survives via --resume). Waits for every injection to settle, for
+   * an open runtime-initiated turn and for a follow-up hold — but NOT for
+   * outstanding background tasks (a `make dev` would defer a config change
+   * forever); those die with the process, logged.
+   */
+  private maybeApplyRestart(sessionKey: string, state: ProcessState): void {
+    if (!state.needsRestart || state.done) return;
+    if (state.inputs.hasPendingInjections() || state.inputs.hasUnsettledInjections()) return;
+    // A dispatch queued behind a runtime-initiated turn is registered but
+    // not started yet; killing now would fail it before the CLI runs it.
+    for (const delivery of state.inputs.values()) {
+      if (!delivery.terminal) return;
     }
-
-    if (state.needsRestart && !state.inputs.hasPendingInjections()) {
-      this.killProcess(sessionKey, state);
+    if (state.pump.hasOwnWork()) return;
+    const outstanding = state.pump.busy.outstanding();
+    if (outstanding.total > 0) {
+      state.log?.warn?.(
+        `restarting ${sessionKey} with ${outstanding.total} live background task(s); they die with the process`,
+      );
     }
+    this.killProcess(sessionKey, state);
   }
 
   private ensureProcess(sessionKey: string, log: GatewayLogger | undefined): ProcessState {
@@ -631,9 +595,16 @@ export class ClaudeCodeAdapter implements DispatchAdapter {
     const existing = this.processes.get(sessionKey);
     if (existing && !existing.done) {
       const { proc } = existing.handle;
-      if (existing.needsRestart) {
+      const alive = proc.exitCode === null && proc.signalCode === null && !proc.stdin.destroyed;
+      if (existing.needsRestart && alive) {
+        if (existing.pump.hasOwnWork()) {
+          log?.info?.(
+            `deferring lazy restart of ${sessionKey}: runtime-initiated turn in progress`,
+          );
+          return existing;
+        }
         this.killProcess(sessionKey, existing);
-      } else if (proc.exitCode === null && proc.signalCode === null && !proc.stdin.destroyed) {
+      } else if (alive) {
         return existing;
       } else {
         this.processes.delete(sessionKey);
@@ -642,19 +613,51 @@ export class ClaudeCodeAdapter implements DispatchAdapter {
 
     const handle = this.spawnProcess(sessionKey, log);
     const parser = parseClaudeStreamJson(handle.proc.stdout!);
+    const inputs = new ClaudeInputRegistry();
     const state: ProcessState = {
       handle,
-      parser,
+      pump: new ClaudeProcessPump({
+        sessionKey,
+        parser,
+        handle,
+        inputs,
+        log,
+        followUpHoldMs: this.opts.followUpHoldMs ?? DEFAULT_FOLLOW_UP_HOLD_MS,
+        now: () => this.now(),
+        hooks: {
+          onRuntimeInit: (init) => {
+            if (init.sessionId) {
+              this.opts.sessionManager.recordSessionId(sessionKey, init.sessionId);
+            }
+            if (!init.capabilities.includes('msg_lifecycle_v1')) {
+              return 'Claude runtime lacks required msg_lifecycle_v1 capability; refusing heuristic input coverage';
+            }
+            return undefined;
+          },
+          onFatal: () => {
+            const current = this.processes.get(sessionKey);
+            if (current === state) this.killProcess(sessionKey, state);
+          },
+          onEof: () => {
+            state.done = true;
+            if (this.processes.get(sessionKey) === state) this.processes.delete(sessionKey);
+            this.retiring.delete(state);
+          },
+          // Main-session turns go to the gateway (steps + session activity);
+          // fork-session turns only count as busy (fork-scope invariant).
+          onRuntimeTurnOpened: (turn) =>
+            this.activity.surfaceTurn(turn, this.opts.sessionManager.isMain(sessionKey), log),
+          onRuntimeTurnClosed: () => this.maybeApplyRestart(sessionKey, state),
+        },
+      }),
       done: false,
       needsRestart: false,
-      // A throwaway process already proved the current CLI advertises this
-      // capability. Real 2.1.220 sends queued/started before its own init,
-      // so pre-seed the gate and still verify the real init when it arrives.
-      capabilities: new Set(['msg_lifecycle_v1']),
-      inputs: new ClaudeInputRegistry(),
+      inputs,
+      log,
     };
     this.processes.set(sessionKey, state);
     this.opts.sessionManager.registerProcess(sessionKey, handle);
+    state.pump.start();
     return state;
   }
 
@@ -729,15 +732,20 @@ export class ClaudeCodeAdapter implements DispatchAdapter {
     if (current === state) {
       this.processes.delete(sessionKey);
     }
+    state.pump.close('killed', 'Claude process terminated by the bridge');
     this.terminateHandle(state.handle);
   }
 
-  private terminateHandle(handle: ClaudeProcessHandle): void {
+  private endStdin(handle: ClaudeProcessHandle): void {
     try {
       handle.proc.stdin.end();
     } catch {
       /* best-effort */
     }
+  }
+
+  private terminateHandle(handle: ClaudeProcessHandle): void {
+    this.endStdin(handle);
     if (handle.proc.exitCode === null && handle.proc.signalCode === null) {
       try {
         if (!IS_WIN32 || !handle.proc.pid || !killWin32Tree(handle.proc.pid)) {

package/src/index.ts

@@ -13,6 +13,7 @@ import {
   identityFromMe,
   initAgentTelemetry,
   llmSource,
+  resolveServiceVersion,
   materializeChannelCapabilities,
   ParallAgentGateway,
   parseDispatchDeadlineMs,
@@ -76,7 +77,11 @@ function resolveProviderEnv(): string {
 async function main() {
   // Before any fetch: long-lived HTTP connections for every bridge→api call.
   configureHttpKeepAlive();
-  const telemetry = await initAgentTelemetry('parall-claude-agent', 'claude-code');
+  const telemetry = await initAgentTelemetry('parall-claude-agent', 'claude-code', {
+    apiUrl: process.env.PRLL_API_URL,
+    apiKey: process.env.PRLL_API_KEY,
+    serviceVersion: resolveServiceVersion(import.meta.url),
+  });
   activeLog = createOtelLogger('agent', 'claude-agent');
   try {
     const activeLLMSource = resolveProviderEnv();