@warmdrift/kgauto-compiler 2.0.0-alpha.25 → 2.0.0-alpha.27

package/dist/{chunk-7MTHFSNY.mjs → chunk-JQGRWJZO.mjs}

@@ -829,12 +829,23 @@ var PROFILES_RAW = [
   // Each entry's pricing/context/cliffs/lowering reflects the template, NOT
   // provider docs. Verify before promoting status to 'current' (L-049/L-081).
   {
+    // s37 (2026-05-21): UNVERIFIED-AUTO-ONBOARD → verified against
+    // ai.google.dev/gemini-api/docs/models/gemini-3-flash-preview +
+    // ai.google.dev/gemini-api/docs/pricing. L-081 catches:
+    //   maxOutputTokens 65_535 → 65_536 (off-by-one)
+    //   costInputPer1m  0.30 → 0.50  (template-cloned from 2.5-flash; actual is 1.67× more expensive)
+    //   costOutputPer1m 2.50 → 3.00  (template-cloned; actual 1.2× more expensive)
+    //   cache discount  default 0.25 → 0.10 (10× discount, $0.05/$0.50 per docs)
+    // Cliffs inherited from 2.5-flash conservatively. The 8K-context-quality
+    // cliff was a 2.5-Flash observation — Google positions Gemini 3 as
+    // sustained-frontier-on-long-context; brain evidence will validate/relax.
+    // Kept as guard for now.
     id: "gemini-3-flash-preview",
-    verifiedAgainstDocs: "UNVERIFIED-AUTO-ONBOARD",
+    verifiedAgainstDocs: "2026-05-21",
     provider: "google",
     status: "preview",
     maxContextTokens: 1048576,
-    maxOutputTokens: 65535,
+    maxOutputTokens: 65536,
     maxTools: 128,
     parallelToolCalls: true,
     structuredOutput: "native",
@@ -845,13 +856,13 @@ var PROFILES_RAW = [
         metric: "input_tokens",
         threshold: 8e3,
         action: "downgrade_quality_warning",
-        reason: "Quality degrades significantly above ~8K context tokens"
+        reason: "Inherited from 2.5-flash guard; brain evidence on Gemini 3 long-context quality will validate/relax"
       },
       {
         metric: "tool_count",
         threshold: 20,
         action: "drop_to_top_relevant",
-        reason: "Tool reliability drops above ~20 tools (despite 128 hard limit)"
+        reason: "Tool reliability drops above ~20 tools (despite 128 hard limit) \u2014 inherited from Flash family"
       },
       {
         metric: "thinking_with_short_output",
@@ -860,24 +871,22 @@ var PROFILES_RAW = [
         reason: "Thinking tokens consume maxOutputTokens \u2014 empty response if drained"
       },
       {
-        // s11 trust artifact (2026-05-02): brain showed 5/5 empty rate on
-        // tt-intelligence/summarize/gemini-2.5-flash with tools offered.
-        // v1's disable_thinking_for_short_output already fired and didn't
-        // help — disabling thinking is necessary but not sufficient. Tools
-        // present + summarize intent confuses Flash into a no-output state
-        // (likely tool-decision purgatory). Strip tools entirely for this
-        // archetype on this model.
+        // Inherited from gemini-2.5-flash s11 trust artifact. Family-likely
+        // failure mode for Flash architecture. Keep preemptively until brain
+        // evidence on Gemini 3 specifically.
         metric: "tool_count",
         threshold: 1,
         whenIntent: "summarize",
         action: "strip_tools",
-        reason: "Gemini Flash returns empty when summarize intent has tools offered (5/5 empty rate observed in v1 prod 2026-04-19, replayed into v2 brain 2026-04-29)"
+        reason: "Inherited from 2.5-flash s11 cliff: summarize+tools \u2192 empty response. Preemptive guard until brain evidence on 3-flash-preview specifically."
       }
     ],
-    costInputPer1m: 0.3,
-    costOutputPer1m: 2.5,
+    costInputPer1m: 0.5,
+    costOutputPer1m: 3,
     lowering: {
       ...GOOGLE_LOWERING_BASE,
+      // 10× cache discount per Google pricing: $0.05/M cached vs $0.50/M input.
+      cache: { ...GOOGLE_LOWERING_BASE.cache, discount: 0.1 },
       thinking: { field: "generationConfig.thinkingConfig.thinkingBudget", default: "auto" }
     },
     recovery: [
@@ -903,40 +912,45 @@ var PROFILES_RAW = [
     ],
     strengths: ["speed", "volume", "classification", "1m_context", "cost"],
     weaknesses: ["complex_schemas", "large_tool_sets", "high_context_quality"],
-    notes: "AUTO-ONBOARDED 2026-05-16 from `gemini-2.5-flash`. Pricing, context, cliffs are template-cloned and UNVERIFIED \u2014 confirm against provider docs before promoting status to 'current'.",
-    // Master plan §6.2 anchor. Tier 0 for hunt (parallel tool throughput
-    // 15-75 calls/step beats Sonnet — L-040), summarize, classify.
+    notes: "Verified s37 (2026-05-21) against Google docs. Step-change positioning vs 2.5-flash on agentic loops per Google's release notes (Dec 2025). Pricing 1.67\xD7/1.2\xD7 higher than 2.5-flash; cache discount 10\xD7 (vs 4\xD7 for 2.5). Status=preview until brain evidence accumulates.",
+    // Anchored to 2.5-flash archetypePerf as starter, with judgment adjustments
+    // for Google's "step-change on agentic" positioning. Brain evidence (zero
+    // rows today) will replace these starter values.
     archetypePerf: {
       hunt: 9,
-      // L-040: parallel tool throughput 15-75/step
+      // Inherits 2.5-flash L-040 parallel-tool tier; Google positions 3 as agentic-loop upgrade
       classify: 7,
-      // brain-validated, 218 rows
+      // Inherits 2.5-flash brain-validated tier (218 rows on 2.5)
       summarize: 7,
-      // brain-validated; cliff strips tools when present
+      // Inherits 2.5-flash; cliff strips tools when present
       transform: 7,
-      ask: 7,
-      generate: 6,
-      plan: 5,
+      ask: 8,
+      // +1 vs 2.5-flash — sustained-frontier positioning
+      generate: 7,
+      // +1 vs 2.5-flash — agentic coding upgrade per Google
+      plan: 6,
+      // +1 vs 2.5-flash — complex iterations per positioning
       extract: 6,
-      // alpha.8 MAX_TOKENS history on structured output
-      critique: 4
-      // reasoning shallower than Sonnet/Opus
+      critique: 5
+      // +1 vs 2.5-flash — but still below Sonnet/Opus reasoning floor
     }
   },
   {
-    // ── Gemini 2.5 Flash-Lite ──
-    // Onboarded 2026-05-13 (s22) after the model-release watcher surfaced
-    // it as a UNREGISTERED + NEW candidate. Released by Google July 2025,
-    // stable. Positioned BELOW Flash on the cost/perf frontier:
-    //   input  $0.10/M (Flash $0.30/M)   — 3× cheaper
-    //   output $0.40/M (Flash $2.50/M)   — 6× cheaper
-    //   cache  $0.01/M                    — 1/10 of input (vs Flash 0.25 discount)
-    // Cliffs are HYPOTHESIZED from Flash's known failure modes — Flash-Lite
-    // is a smaller sibling, so we inherit Flash's cliffs at equal-or-tighter
-    // thresholds. The brain will validate/relax these as evidence accumulates
-    // per (archetype, model) tuple. Currently ZERO brain rows for this model.
+    // ── Gemini 3.1 Flash-Lite ──
+    // Onboarded 2026-05-16 by auto-onboarder; s37 (2026-05-21) verified
+    // against ai.google.dev/gemini-api/docs/pricing.
+    //
+    // L-081 CATCHES (template clone from 2.5-flash-lite was 2.5-3.75× too cheap):
+    //   costInputPer1m  0.10 → 0.25 (template clone undervalued by 2.5×)
+    //   costOutputPer1m 0.40 → 1.50 (template clone undervalued by 3.75×)
+    //
+    // Real 3.1-flash-lite is NOT a cost-equivalent successor to 2.5-flash-lite —
+    // it sits between 2.5-flash-lite ($0.10/$0.40) and 2.5-flash ($0.30/$2.50).
+    // Cache discount 10× verified ($0.025/M cached vs $0.25/M input).
+    //
+    // Cliffs are HYPOTHESIZED from 2.5-flash family; brain evidence pending.
     id: "gemini-3.1-flash-lite",
-    verifiedAgainstDocs: "UNVERIFIED-AUTO-ONBOARD",
+    verifiedAgainstDocs: "2026-05-21",
     provider: "google",
     status: "preview",
     maxContextTokens: 1048576,
@@ -977,12 +991,12 @@ var PROFILES_RAW = [
         reason: "Inherited from Flash s11 cliff: summarize+tools \u2192 empty response. Preemptive guard until brain evidence on Flash-Lite specifically."
       }
     ],
-    costInputPer1m: 0.1,
-    costOutputPer1m: 0.4,
+    costInputPer1m: 0.25,
+    costOutputPer1m: 1.5,
     lowering: {
       ...GOOGLE_LOWERING_BASE,
-      // Cache discount 10× (vs Flash 4×) — Google's spec is $0.01/M cache vs
-      // $0.10/M input. Material for repeat-prompt workloads (classify shape).
+      // Cache discount 10× (vs Flash 4×) — Google docs s37: $0.025/M cached vs
+      // $0.25/M input. Material for repeat-prompt workloads (classify shape).
       cache: { ...GOOGLE_LOWERING_BASE.cache, discount: 0.1 },
       thinking: { field: "generationConfig.thinkingConfig.thinkingBudget", default: "auto" }
     },
@@ -1007,13 +1021,13 @@ var PROFILES_RAW = [
         reason: "MALFORMED_FUNCTION_CALL maps to stop \u2014 escalate to next target."
       }
     ],
-    strengths: ["lowest_cost", "speed", "volume", "classification", "summarize", "1m_context", "cache_friendly"],
+    strengths: ["low_cost", "speed", "volume", "classification", "summarize", "1m_context", "cache_friendly"],
     weaknesses: ["complex_reasoning", "large_tool_sets", "complex_schemas", "structured_output_unproven", "long_context_quality"],
-    notes: "AUTO-ONBOARDED 2026-05-16 from `gemini-2.5-flash-lite`. Pricing, context, cliffs are template-cloned and UNVERIFIED \u2014 confirm against provider docs before promoting status to 'current'.",
-    // Tier 3 emergency floor for summarize/classify chains. ZERO brain
-    // rows — all values are starter hypotheses anchored to "smaller
-    // sibling of Flash, at-or-below Flash perf on every archetype." The
-    // first 50 brain rows per archetype will validate or relax these.
+    notes: "Verified s37 (2026-05-21) against Google docs. Sits between 2.5-flash-lite (cheaper) and 2.5-flash (more expensive) on cost frontier; 2.5\xD7 more expensive than initial template-clone. Cliffs hypothesized from Flash family \u2014 brain evidence pending.",
+    // Tier 2-3 floor for summarize/classify chains at the new (verified) price
+    // point. ZERO brain rows — values are starter hypotheses anchored to
+    // "smaller sibling of Flash at higher cost than 2.5-flash-lite." The first
+    // 50 brain rows per archetype will validate or relax these.
     archetypePerf: {
       classify: 6,
       // starter hypothesis — verify (Flash is 7, lite likely ≤)
@@ -1028,6 +1042,125 @@ var PROFILES_RAW = [
       plan: 3,
       critique: 3
     }
+  },
+  // ─────────────────────────────────────────────────────────────────────────
+  // Gemini 3.5 Flash — hand-onboarded s37 (2026-05-21)
+  //
+  // Google positioning ("Most intelligent for sustained frontier performance
+  // on agentic and coding tasks" / "particularly effective for rapid agentic
+  // loops involving complex coding cycles and iterations") suggests this is
+  // the Flash-family upgrade specifically aimed at hunt-shape workloads.
+  // Pricing 5× input / 3.6× output vs 2.5-flash — material cost premium.
+  // archetypePerf adjusted +1 vs 2.5-flash on ask/generate/plan/critique
+  // (sustained-frontier positioning); hunt held at 9 inherited from L-040
+  // family parallel-tool tier; brain evidence will validate within 50 rows.
+  //
+  // Cliffs inherited conservatively from 2.5-flash. Google's "sustained
+  // frontier on long-context" positioning suggests the 8K cliff may not
+  // apply to 3.5 — keep as guard until brain evidence shows otherwise.
+  //
+  // Specs verified against:
+  //   ai.google.dev/gemini-api/docs/models/gemini-3.5-flash
+  //   ai.google.dev/gemini-api/docs/pricing (Standard tier)
+  // ─────────────────────────────────────────────────────────────────────────
+  {
+    id: "gemini-3.5-flash",
+    verifiedAgainstDocs: "2026-05-21",
+    provider: "google",
+    status: "current",
+    maxContextTokens: 1048576,
+    maxOutputTokens: 65536,
+    maxTools: 128,
+    parallelToolCalls: true,
+    structuredOutput: "native",
+    systemPromptMode: "separate",
+    streaming: true,
+    cliffs: [
+      {
+        metric: "input_tokens",
+        threshold: 8e3,
+        action: "downgrade_quality_warning",
+        reason: "Inherited from 2.5-flash guard; Google positions 3.5 as sustained-frontier-on-long-context but brain evidence pending"
+      },
+      {
+        metric: "tool_count",
+        threshold: 20,
+        action: "drop_to_top_relevant",
+        reason: "Inherited from Flash family: tool reliability drops above ~20 (despite 128 hard limit). Validate per (archetype, model) after n\u226520."
+      },
+      {
+        metric: "thinking_with_short_output",
+        threshold: 1,
+        action: "force_thinking_budget_zero",
+        reason: "Thinking mode supported per Google docs; same drain risk as 2.5-flash \u2014 thinking tokens consume maxOutputTokens"
+      },
+      {
+        // Inherited from 2.5-flash s11 trust artifact (5/5 empty rate on
+        // tt-intelligence/summarize/gemini-2.5-flash with tools offered).
+        // Family-likely failure mode for Flash architecture across versions.
+        // Keep preemptively until brain evidence on 3.5-flash specifically.
+        metric: "tool_count",
+        threshold: 1,
+        whenIntent: "summarize",
+        action: "strip_tools",
+        reason: "Inherited from 2.5-flash s11 cliff (kgauto commit 3872832): summarize+tools \u2192 empty response. Preemptive guard until brain evidence on 3.5-flash specifically."
+      }
+    ],
+    costInputPer1m: 1.5,
+    costOutputPer1m: 9,
+    lowering: {
+      ...GOOGLE_LOWERING_BASE,
+      // 10× cache discount per Google pricing: $0.15/M cached vs $1.50/M input.
+      cache: { ...GOOGLE_LOWERING_BASE.cache, discount: 0.1 },
+      thinking: { field: "generationConfig.thinkingConfig.thinkingBudget", default: "auto" }
+    },
+    recovery: [
+      {
+        signal: "empty_response_after_tool",
+        action: "retry_with_params",
+        retryParams: { "generationConfig.thinkingConfig.thinkingBudget": 0 },
+        maxRetries: 1,
+        reason: "Inherited Flash-family pattern: empty after tool result \u2014 retry with thinking off"
+      },
+      {
+        signal: "empty_response",
+        action: "retry_with_params",
+        retryParams: { "generationConfig.thinkingConfig.thinkingBudget": 0 },
+        maxRetries: 1,
+        reason: "Empty response \u2014 try with thinking off"
+      },
+      {
+        signal: "malformed_function_call",
+        action: "escalate",
+        reason: "MALFORMED_FUNCTION_CALL maps to stop \u2014 escalate to next target"
+      }
+    ],
+    strengths: ["agentic_loops", "coding", "1m_context", "parallel_tools", "thinking_mode", "sustained_frontier"],
+    weaknesses: ["cost_vs_2_5_flash", "no_brain_evidence_yet"],
+    notes: "Hand-onboarded s37 (2026-05-21) verified against Google docs. Stable status; positioned as Flash-family upgrade for agentic loops and coding. 5\xD7/3.6\xD7 more expensive than 2.5-flash but Google claims step-change on sustained frontier work. archetypePerf adjustments are judgment-grounded starter hypotheses \u2014 brain evidence will validate within ~50 rows per archetype.",
+    // Starter hypothesis: anchored to 2.5-flash archetypePerf with +1
+    // adjustments where Google's positioning explicitly supports
+    // (agentic/coding/sustained). Hunt held at 9 inherited from L-040 family
+    // parallel-tool tier. Brain evidence will replace.
+    archetypePerf: {
+      hunt: 9,
+      // Inherited from 2.5-flash L-040 parallel-tool tier; Google positions 3.5 as agentic-loop champion
+      classify: 7,
+      // Inherited from 2.5-flash brain-validated tier (218 rows on 2.5)
+      summarize: 7,
+      // Inherited from 2.5-flash; cliff strips tools when present
+      transform: 7,
+      ask: 8,
+      // +1 vs 2.5-flash — sustained-frontier positioning
+      generate: 8,
+      // +1 vs 2.5-flash (6→8) — Google: "complex coding cycles and iterations"
+      plan: 7,
+      // +1 vs 2.5-flash (5→7) — "complex iterations" positioning
+      extract: 7,
+      // +1 vs 2.5-flash — sustained-frontier on structured tasks
+      critique: 5
+      // +1 vs 2.5-flash — but still below Sonnet/Opus reasoning floor
+    }
   }
 ];
 var ALIASES = {

package/dist/{chunk-NUTC7NUC.mjs → chunk-NBO4R5PC.mjs}

@@ -1,92 +1,6 @@
 // src/glassbox/types.ts
 var GLASSBOX_STREAM_TTL_MS = 6e4;
 
-// src/glassbox/pubsub-memory.ts
-var MemoryPubSub = class {
-  subscribers = /* @__PURE__ */ new Map();
-  async publish(traceId, event) {
-    const subs = this.subscribers.get(traceId);
-    if (!subs || subs.size === 0) return;
-    for (const sub of subs) {
-      if (sub.closed) continue;
-      try {
-        sub.controller.enqueue(event);
-      } catch {
-        sub.closed = true;
-        continue;
-      }
-      this.refreshTtl(traceId, sub);
-    }
-  }
-  subscribe(traceId) {
-    const self = this;
-    let sub;
-    return new ReadableStream({
-      start(controller) {
-        sub = {
-          controller,
-          ttlTimer: setTimeout(() => {
-            self.closeSubscriber(traceId, sub);
-          }, GLASSBOX_STREAM_TTL_MS),
-          closed: false
-        };
-        let set = self.subscribers.get(traceId);
-        if (!set) {
-          set = /* @__PURE__ */ new Set();
-          self.subscribers.set(traceId, set);
-        }
-        set.add(sub);
-      },
-      cancel() {
-        if (sub) self.removeSubscriber(traceId, sub);
-      }
-    });
-  }
-  /**
-   * Refresh the rolling TTL for a subscriber after an event lands. Replaces
-   * the existing timer with a fresh 60s one.
-   */
-  refreshTtl(traceId, sub) {
-    clearTimeout(sub.ttlTimer);
-    sub.ttlTimer = setTimeout(() => {
-      this.closeSubscriber(traceId, sub);
-    }, GLASSBOX_STREAM_TTL_MS);
-  }
-  /**
-   * Close the subscriber's stream cleanly and remove from the fan-out set.
-   * Idempotent — safe to call multiple times.
-   */
-  closeSubscriber(traceId, sub) {
-    if (sub.closed) return;
-    sub.closed = true;
-    clearTimeout(sub.ttlTimer);
-    try {
-      sub.controller.close();
-    } catch {
-    }
-    this.removeSubscriber(traceId, sub);
-  }
-  removeSubscriber(traceId, sub) {
-    clearTimeout(sub.ttlTimer);
-    const set = this.subscribers.get(traceId);
-    if (!set) return;
-    set.delete(sub);
-    if (set.size === 0) this.subscribers.delete(traceId);
-  }
-  /**
-   * Test-only reset. Tears down all subscribers, clears all state. Calling
-   * outside of tests is harmless but cancels every active stream.
-   */
-  _reset() {
-    for (const [, set] of this.subscribers) {
-      for (const sub of set) {
-        this.closeSubscriber("", sub);
-      }
-    }
-    this.subscribers.clear();
-  }
-};
-
 // src/glassbox/pubsub-upstash.ts
 var UpstashPubSub = class {
   url;
@@ -101,8 +15,8 @@ var UpstashPubSub = class {
     this.blockMs = cfg.blockMs ?? 100;
     this.maxLen = cfg.maxLen ?? 100;
   }
-  async publish(traceId, event) {
-    const key = streamKey(traceId);
+  async publish(channelKey, event) {
+    const key = channelKey;
     const payload = JSON.stringify(event);
     await this.cmd([
       "XADD",
@@ -116,8 +30,8 @@ var UpstashPubSub = class {
     ]);
     await this.cmd(["EXPIRE", key, String(Math.ceil(GLASSBOX_STREAM_TTL_MS / 1e3))]);
   }
-  subscribe(traceId) {
-    const key = streamKey(traceId);
+  subscribe(channelKey) {
+    const key = channelKey;
     const self = this;
     let cursor = "$";
     let cancelled = false;
@@ -191,9 +105,12 @@ var UpstashPubSub = class {
     return json;
   }
 };
-function streamKey(traceId) {
+function traceChannel(traceId) {
   return `glassbox:trace:${traceId}`;
 }
+function appChannel(appId) {
+  return `glassbox:app:${appId}`;
+}
 function decodeEvent(fields) {
   const raw = fields["event"];
   if (!raw) return void 0;
@@ -231,6 +148,92 @@ function parseXReadResult(raw) {
   return { entries };
 }
 
+// src/glassbox/pubsub-memory.ts
+var MemoryPubSub = class {
+  subscribers = /* @__PURE__ */ new Map();
+  async publish(channelKey, event) {
+    const subs = this.subscribers.get(channelKey);
+    if (!subs || subs.size === 0) return;
+    for (const sub of subs) {
+      if (sub.closed) continue;
+      try {
+        sub.controller.enqueue(event);
+      } catch {
+        sub.closed = true;
+        continue;
+      }
+      this.refreshTtl(channelKey, sub);
+    }
+  }
+  subscribe(channelKey) {
+    const self = this;
+    let sub;
+    return new ReadableStream({
+      start(controller) {
+        sub = {
+          controller,
+          ttlTimer: setTimeout(() => {
+            self.closeSubscriber(channelKey, sub);
+          }, GLASSBOX_STREAM_TTL_MS),
+          closed: false
+        };
+        let set = self.subscribers.get(channelKey);
+        if (!set) {
+          set = /* @__PURE__ */ new Set();
+          self.subscribers.set(channelKey, set);
+        }
+        set.add(sub);
+      },
+      cancel() {
+        if (sub) self.removeSubscriber(channelKey, sub);
+      }
+    });
+  }
+  /**
+   * Refresh the rolling TTL for a subscriber after an event lands. Replaces
+   * the existing timer with a fresh 60s one.
+   */
+  refreshTtl(channelKey, sub) {
+    clearTimeout(sub.ttlTimer);
+    sub.ttlTimer = setTimeout(() => {
+      this.closeSubscriber(channelKey, sub);
+    }, GLASSBOX_STREAM_TTL_MS);
+  }
+  /**
+   * Close the subscriber's stream cleanly and remove from the fan-out set.
+   * Idempotent — safe to call multiple times.
+   */
+  closeSubscriber(channelKey, sub) {
+    if (sub.closed) return;
+    sub.closed = true;
+    clearTimeout(sub.ttlTimer);
+    try {
+      sub.controller.close();
+    } catch {
+    }
+    this.removeSubscriber(channelKey, sub);
+  }
+  removeSubscriber(channelKey, sub) {
+    clearTimeout(sub.ttlTimer);
+    const set = this.subscribers.get(channelKey);
+    if (!set) return;
+    set.delete(sub);
+    if (set.size === 0) this.subscribers.delete(channelKey);
+  }
+  /**
+   * Test-only reset. Tears down all subscribers, clears all state. Calling
+   * outside of tests is harmless but cancels every active stream.
+   */
+  _reset() {
+    for (const [, set] of this.subscribers) {
+      for (const sub of set) {
+        this.closeSubscriber("", sub);
+      }
+    }
+    this.subscribers.clear();
+  }
+};
+
 // src/glassbox/emit.ts
 var activePubSub;
 function getPubSub() {
@@ -254,40 +257,52 @@ function readEnv(key) {
   }
   return void 0;
 }
-function emitGlassboxEvent(traceId, kind, data) {
+function emitGlassboxEvent(traceId, appId, kind, data) {
   if (!traceId) return;
   const event = { kind, at: Date.now(), data };
   const ps = getPubSub();
   try {
-    const p = ps.publish(traceId, event);
-    if (p && typeof p.then === "function") {
-      p.catch(() => {
+    const p1 = ps.publish(traceChannel(traceId), event);
+    if (p1 && typeof p1.then === "function") {
+      p1.catch(() => {
       });
     }
   } catch {
   }
+  if (appId) {
+    try {
+      const p2 = ps.publish(appChannel(appId), event);
+      if (p2 && typeof p2.then === "function") {
+        p2.catch(() => {
+        });
+      }
+    } catch {
+    }
+  }
 }
-function emitCompileStart(traceId, data) {
-  emitGlassboxEvent(traceId, "compile.start", data);
+function emitCompileStart(traceId, appId, data) {
+  emitGlassboxEvent(traceId, appId, "compile.start", data);
 }
-function emitCompileDone(traceId, data) {
-  emitGlassboxEvent(traceId, "compile.done", data);
+function emitCompileDone(traceId, appId, data) {
+  emitGlassboxEvent(traceId, appId, "compile.done", data);
 }
-function emitExecuteAttempt(traceId, data) {
-  emitGlassboxEvent(traceId, "execute.attempt", data);
+function emitExecuteAttempt(traceId, appId, data) {
+  emitGlassboxEvent(traceId, appId, "execute.attempt", data);
 }
-function emitExecuteSuccess(traceId, data) {
-  emitGlassboxEvent(traceId, "execute.success", data);
+function emitExecuteSuccess(traceId, appId, data) {
+  emitGlassboxEvent(traceId, appId, "execute.success", data);
 }
-function emitAdvisoryFired(traceId, data) {
-  emitGlassboxEvent(traceId, "advisory.fired", data);
+function emitAdvisoryFired(traceId, appId, data) {
+  emitGlassboxEvent(traceId, appId, "advisory.fired", data);
 }
-function emitFallbackWalked(traceId, data) {
-  emitGlassboxEvent(traceId, "fallback.walked", data);
+function emitFallbackWalked(traceId, appId, data) {
+  emitGlassboxEvent(traceId, appId, "fallback.walked", data);
 }
 
 export {
   GLASSBOX_STREAM_TTL_MS,
+  traceChannel,
+  appChannel,
   getPubSub,
   emitCompileStart,
   emitCompileDone,

package/dist/chunk-RO22VFIF.mjs

@@ -0,0 +1,29 @@
+import {
+  appChannel,
+  getPubSub,
+  traceChannel
+} from "./chunk-NBO4R5PC.mjs";
+
+// src/glassbox/subscribe.ts
+function emptyStream() {
+  return new ReadableStream({
+    start(controller) {
+      controller.close();
+    }
+  });
+}
+function subscribe(traceId) {
+  if (!traceId) return emptyStream();
+  return getPubSub().subscribe(traceChannel(traceId));
+}
+function subscribeApp({
+  appId
+}) {
+  if (!appId) return emptyStream();
+  return getPubSub().subscribe(appChannel(appId));
+}
+
+export {
+  subscribe,
+  subscribeApp
+};

package/dist/glassbox/index.d.mts

@@ -1,5 +1,5 @@
-import { G as GlassboxEvent } from '../types-D9WndxeD.mjs';
-export { A as AdvisoryFiredData, C as CompileDoneData, a as CompileStartData, E as ExecuteAttemptData, b as ExecuteSuccessData, F as FallbackWalkedData, c as GLASSBOX_STREAM_TTL_MS, d as GlassboxEventKind, e as GlassboxPubSub } from '../types-D9WndxeD.mjs';
+import { G as GlassboxEvent } from '../types-o9etg93a.mjs';
+export { A as AdvisoryFiredData, C as CompileDoneData, a as CompileStartData, E as ExecuteAttemptData, b as ExecuteSuccessData, F as FallbackWalkedData, c as GLASSBOX_STREAM_TTL_MS, d as GlassboxEventKind, e as GlassboxPubSub } from '../types-o9etg93a.mjs';
 import '../ir-B9zqlwjH.mjs';
 import '../dialect.mjs';
 
@@ -38,5 +38,22 @@ import '../dialect.mjs';
  * down the subscription cleanly via the underlying adapter.
  */
 declare function subscribe(traceId: string): ReadableStream<GlassboxEvent>;
+/**
+ * Subscribe to Glass-Box events for ALL traces under an appId — the
+ * "tail-all" surface (alpha.26). Backs the extension's default Live mode:
+ * rather than needing a specific traceId ahead of time, the panel sees
+ * every event for the configured consumer as calls happen.
+ *
+ * Per-app routing fires only when emit call-sites pass `appId` (the typed
+ * builders thread `ir.appId` automatically). Per-trace channel continues to
+ * fire for `subscribe(traceId)` callers — both arms are independent.
+ *
+ * Cross-tenant isolation: the consumer's `/api/glassbox/stream` uses the
+ * factory's configured appId — no caller-supplied `?appId=` URL parameter,
+ * so a consumer cannot subscribe to another consumer's stream.
+ */
+declare function subscribeApp({ appId, }: {
+    appId: string;
+}): ReadableStream<GlassboxEvent>;
 
-export { GlassboxEvent, subscribe };
+export { GlassboxEvent, subscribe, subscribeApp };