@genee/omp-opsx-addon 0.4.0 → 0.6.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

@@ -48,13 +48,46 @@ export interface Painter {
     header(label: string, brandAnsi: string): string;
     /** Numeric balance text (e.g. "余额 ¥18.06"), text-colored. */
     balance(text: string): string;
-    /** Foreground-color an arbitrary span with a named color (waveform cells). */
-    fg(color: PainterColor, text: string): string;
+    /**
+     * Waveform layer paint — btop row gradient over the provider's brand hue.
+     * `brandAnsi` is the raw brand SGR ('' → accent fallback, like header).
+     * Both rows share the hue family with a fixed, theme-independent step:
+     * 'bottom' a curated 256-color bright shade of the hue (aixterm bright /
+     * bold when the code isn't a mapped 16-color SGR), 'top' the plain brand.
+     */
+    wave(brandAnsi: string, layer: 'top' | 'bottom', text: string): string;
 }
 
 const pctValue = (p: number): string => `${Math.round(p * 100)}%`;
 const pctColor = (p: number): PainterColor => (p >= 0.85 ? 'error' : p >= 0.6 ? 'warning' : 'success');
 
+/**
+ * Curated 256-color bottom-row shade per 16-color brand hue (chart only —
+ * headers keep the raw brand SGR). The 256 palette's 16–255 range renders as
+ * FIXED rgb in every terminal, so the bottom/top step is guaranteed visible
+ * regardless of the active 16-color theme. Each shade is anchored on the
+ * de-facto standard dark-theme value of that hue (TokyoNight family) and is
+ * the SAME ink one purity/brightness step up — same hue direction, no hot
+ * magenta/red jumps that would break the "one color" read.
+ */
+const WAVE_SHADES: Record<string, string> = {
+    [X]: '38;5;204', // red    #ff5f87 (TN #f7768e, denser)
+    [G]: '38;5;114', //  green  #87d787 (TN #9ece6a, denser)
+    [BLUE]: '38;5;75', // blue #5fafff (TN #7aa2f7, denser)
+    [PURPLE]: '38;5;177', // purple #d787ff (TN #bb9af7, denser)
+    [CYAN]: '38;5;81', // cyan  #5fd7ff (TN #7dcfff, denser)
+};
+
+/** Aixterm bright variant of a 16-color brand code (`\x1b[3Nm` → `\x1b[9Nm`); undefined when not derivable. */
+const brightVariant = (code: string): string | undefined => {
+    const m = code.match(/^\x1b\[3([0-7])m$/);
+    return m ? `\x1b[9${m[1]}m` : undefined;
+};
+
+/** Bottom-row shade of a raw hue: curated 256 bright shade, aixterm bright, bold as the last step. */
+const bottomShade = (hue: string): string =>
+    WAVE_SHADES[hue] ? `\x1b[${WAVE_SHADES[hue]}m` : brightVariant(hue) ?? BOLD + hue;
+
 /** Pre-refactor hardcoded ANSI — the RPC/print fallback and the test baseline. */
 export const ansiPainter: Painter = {
     pct: (p) => {
@@ -65,21 +98,7 @@ export const ansiPainter: Painter = {
     sep: ` ${D}│${R} `,
     header: (label, brandAnsi) => c(brandAnsi ? BOLD + brandAnsi : BOLD, label),
     balance: (text) => c(WHITE, text),
-    fg: (color, text) =>
-        c(
-            color === 'error'
-                ? X
-                : color === 'warning'
-                  ? Y
-                  : color === 'success'
-                    ? G
-                    : color === 'dim'
-                      ? D
-                      : color === 'accent'
-                        ? CYAN
-                        : WHITE,
-            text,
-        ),
+    wave: (brandAnsi, layer, text) => c(layer === 'bottom' ? bottomShade(brandAnsi || CYAN) : brandAnsi || CYAN, text),
 };
 
 /** Status colors via the active host theme; brand headers keep raw ANSI. */
@@ -90,7 +109,12 @@ export function themePainter(theme: PainterTheme): Painter {
         sep: ` ${theme.fg('dim', '│')} `,
         header: (label, brandAnsi) => (brandAnsi ? c(brandAnsi, label) : theme.fg('accent', label)),
         balance: (text) => theme.fg('text', text),
-        fg: (color, text) => theme.fg(color, text),
+        wave: (brandAnsi, layer, text) =>
+            brandAnsi
+                ? c(layer === 'bottom' ? bottomShade(brandAnsi) : brandAnsi, text)
+                : layer === 'bottom'
+                  ? BOLD + theme.fg('accent', text)
+                  : theme.fg('accent', text),
     };
 }
 
@@ -424,7 +448,7 @@ export function renderUsageReports(
         // placeholder strip, keeping the column height stable.
         if (consumptionTracks) {
             const track = consumptionTracks.get(c.provider);
-            if (track) c.col.push(...renderConsumptionLines(track.samples, painter, waveCols));
+            if (track) c.col.push(...renderConsumptionLines(track.samples, painter, waveCols, providerLabel(c.provider).color));
         }
         if (pad) c.col = c.col.map((l) => padRight(l, blockWidth));
     }
@@ -469,13 +493,6 @@ export function composeChar(leftRows: number, rightRows: number): string {
     return String.fromCharCode(code);
 }
 
-/** Named-color band for a stock consumption level (`1 - remaining`): remaining ≥ 50% → success, ≥ 20% → warning, else error. */
-export function consumptionColor(c: number): PainterColor {
-    if (c <= 0.5) return 'success';
-    if (c <= 0.8) return 'warning';
-    return 'error';
-}
-
 /** One provider's consumption track feeding its embedded mini chart. */
 export interface ConsumptionTrack {
     /** Per-interval consumption increments (raw values), newest last. */
@@ -498,12 +515,17 @@ export interface ConsumptionTrack {
  * window yields a blank placeholder strip, never `undefined`, so every
  * provider column keeps a stable chart area and the layout never jumps.
  *
- * Color is bound to RATE INTENSITY (image-scaling blend, not quota severity —
- * quota urgency already reads in the usage text, e.g. "5h 0%", balance). Each
- * Braille character takes the MEAN of its two half-column interpolated
- * intensities, mapped via consumptionColor (low→green, mid→yellow, high→red),
- * so consecutive chars blend smoothly and never hard-switch. The newest column
- * keeps accent.
+ * Color is a btop-style ROW gradient bound to the vertical position only —
+ * never to the data. The chart paints the provider's brand hue in two layers
+ * with a fixed step: the bottom line takes a curated 256-color bright shade
+ * of the hue (fixed rgb — visible under any 16-color theme; aixterm bright /
+ * bold when the code isn't mapped), the top line the plain brand — visibly
+ * stronger at the base, never washed out. Sliding samples reshape the
+ * envelope while every
+ * pixel's color stays put — the per-column intensity heat bands this
+ * replaces flipped green/yellow/red as the window moved, reading as flicker.
+ * Providers without a curated brand hue fall back to the theme accent.
+ * Quota urgency still reads in the usage text ("5h 0%", balance).
  *
  * Geometry unchanged: 1px per sample (half-char step), right-aligned; each
  * character merges its two half-column samples with max and renders both
@@ -514,6 +536,7 @@ export function renderConsumptionLines(
     samples: readonly number[],
     painter: Painter = ansiPainter,
     cols: number = WAVEFORM_COLS,
+    brandAnsi = '',
 ): string[] {
     const n = samples.length;
     const totalPx = cols * 2;
@@ -564,14 +587,10 @@ export function renderConsumptionLines(
         return plot[m - 1] / max;
     };
 
-    // Each half-column keeps its OWN interpolated height (two samples share one
-    // char, possibly at different heights — the pair-into-one-char geometry);
-    // only COLOR is blended (terminals can't half-tint a char, so the char
-    // takes the mean intensity of its two half-columns).
-    const accentChar = Math.floor((totalPx - 1) / 2);
     // Two-line strip: full scale = 8px (2 Braille rows × 4 dot rows). Each
-    // half-column keeps its OWN interpolated height; only COLOR is blended
-    // (terminals can't half-tint a char, so the char takes the mean intensity).
+    // half-column keeps its OWN interpolated height; COLOR is ROW-bound only
+    // (bottom = 256 bright shade of the brand hue, top = plain brand) and
+    // never varies per column.
     const rows = 2;
     const lines = new Array<string>(rows).fill('');
     for (let c = 0; c < cols; c++) {
@@ -582,12 +601,14 @@ 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);
-        const color = c === accentChar ? 'accent' : consumptionColor((l + r) / 2);
+        // 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;
         // 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)));
-        lines[1] += painter.fg(color, composeChar(Math.min(4, hL), Math.min(4, hR)));
+        lines[0] += painter.wave(brandAnsi, 'top', composeChar(Math.max(0, hL - 4), Math.max(0, hR - 4)));
+        lines[1] += painter.wave(brandAnsi, 'bottom', composeChar(Math.min(4, hL), Math.min(4, hR)));
     }
     return lines;
 }

package/package.json

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