@vzn/vx 0.0.32 → 0.0.33

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vzn/vx",
-  "version": "0.0.32",
+  "version": "0.0.33",
   "description": "An open, extensible monorepo task runner.",
   "type": "module",
   "exports": {
@@ -17,10 +17,10 @@
     "node": ">=18"
   },
   "optionalDependencies": {
-    "@vzn/vx-linux-x64": "0.0.32",
-    "@vzn/vx-linux-arm64": "0.0.32",
-    "@vzn/vx-darwin-x64": "0.0.32",
-    "@vzn/vx-darwin-arm64": "0.0.32"
+    "@vzn/vx-linux-x64": "0.0.33",
+    "@vzn/vx-linux-arm64": "0.0.33",
+    "@vzn/vx-darwin-x64": "0.0.33",
+    "@vzn/vx-darwin-arm64": "0.0.33"
   },
   "dependencies": {
     "@anthropic-ai/sandbox-runtime": "^0.0.76"

package/src/orchestrator/telemetry-host.ts

@@ -70,6 +70,7 @@ export async function subscribeTelemetry(
   extraSinks?: readonly TelemetrySink[],
 ): Promise<TelemetryHandle | undefined> {
   const sinks: TelemetrySink[] = extraSinks === undefined ? [] : [...extraSinks]
+  const owners = new Map<TelemetrySink, string>()
   for (const plugin of plugins) {
     if (plugin.telemetry === undefined) continue
     // A plugin's return value is user input, so it is checked here rather
@@ -100,12 +101,15 @@ export async function subscribeTelemetry(
       )
       continue
     }
+    for (const [i, sink] of accepted.entries()) {
+      owners.set(sink, accepted.length === 1 ? plugin.name : `${plugin.name} #${i + 1}`)
+    }
     sinks.push(...accepted)
   }
 
   if (sinks.length === 0) return undefined
 
-  const source = createTelemetrySource({ sinks, run, warn: (m) => ctx.warn(m) })
+  const source = createTelemetrySource({ sinks, run, warn: (m) => ctx.warn(m), owners })
   // The bus's unsubscribe is idempotent, so it is the handle's dispose as
   // is (a once-flag here survived item 654).
   const dispose = bus.subscribe(source.subscriber)

package/src/orchestrator/telemetry.ts

@@ -364,9 +364,15 @@ export function createTelemetrySource(args: {
   run: RunContextRecord
   /** Where a dropped-flush notice goes; absent = stay silent. */
   warn?: (message: string) => void
+  /** What a sink with no `name` of its own is called: its plugin's (the host's map). */
+  owners?: ReadonlyMap<TelemetrySink, string>
 }): TelemetrySource {
   const { sinks, run, warn } = args
   const runId = run.runId
+  // `name` is optional, and a nameless sink was reported as 'undefined'
+  // (item 1027): it goes by its plugin's name, else its place in the list.
+  const label = (sink: TelemetrySink): string =>
+    sink.name ?? args.owners?.get(sink) ?? `#${sinks.indexOf(sink) + 1}`
   // A sink is disabled the first time it throws — its name (or index) goes
   // here and it's skipped for the rest of the run, FLUSH INCLUDED. Flushing a
   // disabled sink would write a buffer that is incomplete by construction: it
@@ -381,7 +387,7 @@ export function createTelemetrySource(args: {
   const disable = (sink: TelemetrySink, hook: string, err: unknown): void => {
     disabled.add(sink)
     warn?.(
-      `[vx] telemetry sink '${sink.name}' threw in ${hook}; disabled for this run: ${err instanceof Error ? err.message : String(err)}`,
+      `[vx] telemetry sink '${label(sink)}' threw in ${hook}; disabled for this run: ${err instanceof Error ? err.message : String(err)}`,
     )
   }
   // Precompute which sinks want each kind, so per-event fan-out is a plain
@@ -500,7 +506,7 @@ export function createTelemetrySource(args: {
               // A flush failure can never break the run — but it still costs
               // this sink its export, so say so rather than dropping it.
               warn?.(
-                `[vx] telemetry sink '${sink.name}' failed to flush: ${err instanceof Error ? err.message : String(err)}`,
+                `[vx] telemetry sink '${label(sink)}' failed to flush: ${err instanceof Error ? err.message : String(err)}`,
               )
             }
           }),