@genee/omp-opsx-addon 0.4.0 → 0.5.0

package/index.ts

@@ -1,19 +1,18 @@
 // ── subagent usage tracking ───────────────────────────────────────────
-// The TASK_SUBAGENT_EVENT_CHANNEL is used to forward subagent events to
-// the primary session's eventBus. Subagent message_update/message_end events
-// are wrapped in SubagentEventPayload { id, event } and sent through this channel.
-// The primary session subscribes to this channel to record subagent usage into
-// the primary's recorder. This avoids the module-level singleton issue where
-// each plugin instance has its own recorder.
+// The harness forwards every task-subagent message as a SubagentEventPayload
+// { id, event } frame on the "task:subagent:event" channel, emitted to the
+// parent session's eventBus (plus the root observability bus, which is not
+// reachable from extensions). Each plugin instance subscribes its OWN session
+// bus via the official ExtensionAPI handle `pi.events` — the EventBus the
+// harness injects as ConcreteExtensionAPI's `events` field (loader.ts). The
+// root instance's bus carries depth-1 frames, a depth-1 instance's bus carries
+// depth-2 frames, and so on, so every nesting depth is covered while each
+// frame is consumed exactly once. Frames funnel into the module-level recorder
+// singleton below, attributed to the root session id.
 //
-// IMPORTANT: Plugins cannot directly subscribe to eventBus channels via the
-// official ExtensionAPI. We access the eventBus through internal properties as a
-// pragmatic workaround. The channel string is hardcoded from harness source:
+// The channel string is hardcoded from harness source:
 // src/task/types.ts:59 -> "task:subagent:event"
 //
-// NOTE: This is a hack that depends on internal harness implementation details.
-// Future harness versions may break this if internal properties change.
-//
 // Reference:
 // - emitSubagentFrame: src/task/executor.ts:1431-1432
 // - SubagentEventPayload: src/task/types.ts:82-84
@@ -23,42 +22,18 @@ const TASK_SUBAGENT_EVENT_CHANNEL = "task:subagent:event";
 // Track unsubscribers for cleanup on session_shutdown
 const subagentEventUnsubscribers = new Map<string, () => void>();
 
-// Helper to safely access eventBus from ctx
-function getEventBusFromCtx(ctx: ExtensionContext | ExtensionCommandContext): unknown {
-    // Try to access eventBus through various internal properties
-    // This is a hack that depends on harness implementation details
-    const sessionManager = ctx.sessionManager as Record<string, unknown>;
-    // Try common property names
-    for (const key of ['session', '_session', '__session', 'eventBus', '_eventBus']) {
-        const val = (sessionManager as Record<string, unknown>)[key];
-        if (val && typeof val === 'object') {
-            const obj = val as Record<string, unknown>;
-            if (typeof obj.eventBus !== 'undefined') {
-                return obj.eventBus;
-            }
-            if (key === 'eventBus' || key === '_eventBus') {
-                return val;
-            }
-        }
+// Official session-bus handle accessor. `ExtensionAPI` declares
+// `events: EventBus` and the harness injects the session bus as
+// ConcreteExtensionAPI's `events` field, so this is a typed read; the runtime
+// shape check only defends against older hosts whose dist predates the field.
+function getPluginEventBus(pi: ExtensionAPI): ExtensionAPI['events'] | undefined {
+    const events = pi.events;
+    if (events && typeof events === 'object' && typeof events.on === 'function') {
+        return events;
     }
     return undefined;
 }
 
-// Helper to subscribe to eventBus channel
-function subscribeToEventBusChannel(
-    eventBus: unknown,
-    channel: string,
-    handler: (data: unknown) => void,
-): () => void {
-    const bus = eventBus as Record<string, unknown>;
-    const onMethod = bus.on as ((channel: string, handler: (data: unknown) => void) => () => void) | undefined;
-    if (typeof onMethod === 'function') {
-        return onMethod.call(bus, channel, handler);
-    }
-    // Return no-op if eventBus doesn't support subscription
-    return () => {};
-}
-
 // Process subagent event payload
 function handleSubagentEvent(payload: unknown, primarySessionId: string): void {
     try {
@@ -540,19 +515,25 @@ function formatFamilyTierMarkdown(sel: SelectionContext): string {
     return rows.join('\n');
 }
 
-// ── per-plugin-instance usage recorder ─────────────────────────────
-// NOT a process-wide singleton: the harness loads a fresh plugin instance
-// for every session, including in-process task subagents (task/executor.ts),
-// so each instance builds its own recorder here. Subagent sessions therefore
-// cannot write to the primary's recorder directly. Instead their usage is
-// captured through the eventBus mechanism:
-// - task/executor.ts:1431-1432 forwards subagent events to the primary session's
-//   eventBus via TASK_SUBAGENT_EVENT_CHANNEL ("task:subagent:event")
-// - The primary plugin subscribes to this channel and records subagent usage
-//   with subagent-specific stream keys (never re-keys the recorder, so the
-//   owner's cumulative baseline survives and streams don't double-count)
-// Each session's recorder persists its own session totals into the shared
-// usage cache, which every process aggregates on read.
+// ── process-wide usage recorder singleton ──────────────────────────
+// This IS a process-wide singleton: the harness rebinds the same evaluated
+// plugin module to a fresh ExtensionAPI instance for every session, including
+// in-process task subagents (task/executor.ts), WITHOUT re-evaluating the
+// module graph — so every instance shares the recorder created here. Only the
+// owning session (has a UI, or is the first headless session) re-keys it via
+// setSessionId; rebind instances never re-key and never write usage through
+// their own message_* handlers (gated by recordsOwnUsage below). Subagent
+// consumption reaches this recorder exclusively through the bus-subscription
+// mechanism (see file header):
+// - Each instance subscribes its own session bus (pi.events) to
+//   TASK_SUBAGENT_EVENT_CHANNEL ("task:subagent:event"); depth-N frames land
+//   on the depth-(N-1) session's bus, so all depths are covered.
+// - Subscription callbacks attribute frames to the recorder's root session id
+//   with per-subagent stream keys (stream keys only — the recorder is never
+//   re-keyed, so the owner's cumulative baseline survives and streams don't
+//   double-count).
+// Session totals persist into the shared usage cache, which every process
+// aggregates on read.
 const sessionUsageRecorder: SessionUsageRecorder = createSessionUsageRecorder({
     write: writeSessionUsage,
     remove: removeSessionUsage,
@@ -697,6 +678,16 @@ export default (pi: ExtensionAPI) => {
         applyRoleModelOverrides(pi.pi?.settings, sel, warn);
     };
 
+    // Instance-level usage-record claim: true only while this instance's
+    // session owns the process-wide recorder (claimsOwnership in session_start
+    // below). Rebind instances (in-process task subagents) keep it false —
+    // their message_* handlers must not write the default stream, because that
+    // consumption is captured exactly once by the parent instance's bus
+    // subscription with a subagent stream key. Closure variable, not
+    // module-level: rebind reuses the evaluated module, so a module-level flag
+    // would be overwritten by whichever instance starts last.
+    let recordsOwnUsage = false;
+
     // ── shared usage poller + widget ──────────────────────────────
     pi.on('session_start', async (_event, ctx) => {
         try {
@@ -722,30 +713,38 @@ export default (pi: ExtensionAPI) => {
             if (claimsOwnership) {
                 sessionUsageRecorder.setSessionId(ctx.sessionManager?.getSessionId?.() ?? '');
             }
-            // Subscribe to subagent events via eventBus to capture usage
-            // Only primary sessions (with UI or no owner) should subscribe
-            if (claimsOwnership) {
-                const sessionId = ctx.sessionManager?.getSessionId?.() ?? '';
-                const eventBus = getEventBusFromCtx(ctx);
-                if (eventBus) {
-                    // Clean up any existing subscription for this session to prevent leaks
-                    const existingUnsubscribe = subagentEventUnsubscribers.get(sessionId);
-                    if (existingUnsubscribe) {
-                        try {
-                            existingUnsubscribe();
-                        } catch {
-                            // Silently ignore errors in unsubscribe
-                        }
-                    }
-                    const unsubscribe = subscribeToEventBusChannel(
-                        eventBus,
-                        TASK_SUBAGENT_EVENT_CHANNEL,
-                        (payload) => handleSubagentEvent(payload, sessionId),
-                    );
-                    if (unsubscribe) {
-                        subagentEventUnsubscribers.set(sessionId, unsubscribe);
+            recordsOwnUsage = claimsOwnership;
+            // Every instance subscribes its OWN session bus (pi.events) to the
+            // subagent channel — record ownership and subscription rights are
+            // decoupled: the root instance's bus carries depth-1 frames, a
+            // depth-1 instance's bus carries depth-2 frames, and each frame is
+            // consumed exactly once (see file header). Callbacks attribute
+            // frames to the recorder singleton's root session id (the module
+            // graph is shared across rebinds), falling back to this session's
+            // own id only before the owner has claimed.
+            const sessionId = ctx.sessionManager?.getSessionId?.() ?? '';
+            const pluginEventBus = getPluginEventBus(pi);
+            if (pluginEventBus) {
+                // Clean up any existing subscription for this session to prevent leaks
+                const existingUnsubscribe = subagentEventUnsubscribers.get(sessionId);
+                if (existingUnsubscribe) {
+                    try {
+                        existingUnsubscribe();
+                    } catch {
+                        // Silently ignore errors in unsubscribe
                     }
                 }
+                const unsubscribe = pluginEventBus.on(TASK_SUBAGENT_EVENT_CHANNEL, (payload) => {
+                    handleSubagentEvent(payload, sessionUsageRecorder.sessionId() || sessionId);
+                });
+                subagentEventUnsubscribers.set(sessionId, unsubscribe);
+                getLogger().info(
+                    `[omp-opsx-addon] subagent usage capture subscribed (sid=${sessionId}, channel=${TASK_SUBAGENT_EVENT_CHANNEL})`,
+                );
+            } else {
+                getLogger().warn(
+                    '[omp-opsx-addon] pi.events handle unavailable — subagent usage capture disabled (subagent consumption will not be recorded)',
+                );
             }
             const auth = ctx.modelRegistry?.authStorage;
             const getApiKey = ctx.modelRegistry?.getApiKeyForProvider
@@ -981,12 +980,14 @@ export default (pi: ExtensionAPI) => {
     // PRIMARY usage source, so the waveform reflects in-progress consumption
     // and stays dense (message_end alone is sparse). `record` is monotonic MAX,
     // so repeated chunk calls never double-count; the final message_end value
-    // (equal or higher) is a harmless re-record. In-process subagent sessions
-    // forward their usage through the eventBus channel (TASK_SUBAGENT_EVENT_CHANNEL)
-    // which this plugin subscribes to in session_start. Subagent consumption is
-    // recorded with subagent-specific keys and merged into the primary waveform.
+    // (equal or higher) is a harmless re-record. Only the recorder-owning
+    // instance writes here: task-subagent rebind instances skip these handlers,
+    // because their consumption reaches the recorder through the parent
+    // instance's bus subscription instead (subagent-specific stream keys,
+    // merged into the primary waveform).
     pi.on('message_update', async (event) => {
         try {
+            if (!recordsOwnUsage) return;
             const ev = event.assistantMessageEvent;
             if ('partial' in ev) {
                 const usage = assistantUsageOf(ev.partial);
@@ -1000,6 +1001,7 @@ export default (pi: ExtensionAPI) => {
     // nonzero streamed total (same monotonic MAX, no double count).
     pi.on('message_end', async (event) => {
         try {
+            if (!recordsOwnUsage) return;
             const usage = assistantUsageOf(event.message);
             if (usage) sessionUsageRecorder.record(canonicalizeProvider(usage.provider), usage.usage);
         } catch {
@@ -1033,13 +1035,15 @@ export default (pi: ExtensionAPI) => {
                 }
             }
             // Always clean up eventBus subscription, even if no usage was recorded
-            const cleanupUnsubscribe = subagentEventUnsubscribers.get(sid!);
-            if (cleanupUnsubscribe) {
-                try {
-                    cleanupUnsubscribe();
-                    subagentEventUnsubscribers.delete(sid!);
-                } catch {
-                    /* best-effort */
+            if (sid) {
+                const cleanupUnsubscribe = subagentEventUnsubscribers.get(sid);
+                if (cleanupUnsubscribe) {
+                    try {
+                        cleanupUnsubscribe();
+                        subagentEventUnsubscribers.delete(sid);
+                    } catch {
+                        /* best-effort */
+                    }
                 }
             }
         } catch {

package/lib/usage-render.ts

@@ -582,8 +582,11 @@ export function renderConsumptionLines(
             for (let li = 0; li < rows; li++) lines[li] += blank;
             continue;
         }
-        const hL = Math.round(8 * l);
-        const hR = Math.round(8 * r);
+        // Minimum visible dot: any non-zero consumption keeps ≥1px no matter
+        // how small its ratio to the window max — a low-rate second must
+        // never vanish under the dynamic scale.
+        const hL = l > 0 ? Math.max(1, Math.round(8 * l)) : 0;
+        const hR = r > 0 ? Math.max(1, Math.round(8 * r)) : 0;
         const color = c === accentChar ? 'accent' : consumptionColor((l + r) / 2);
         // Row 0 = top (px 4..8), row 1 = bottom (px 0..4) of each column.
         lines[0] += painter.fg(color, composeChar(Math.max(0, hL - 4), Math.max(0, hR - 4)));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@genee/omp-opsx-addon",
-  "version": "0.4.0",
+  "version": "0.5.0",
   "type": "module",
   "description": "Pi Extension: OpenSpec workflow orchestration - coder/reviewer/planner agents, session title & progress",
   "main": "./index.ts",