copilot-tap-extension 2.0.5 → 2.0.7

package/dist/extension.mjs

@@ -2284,7 +2284,7 @@ var require_websocket = __commonJS({
     var tls = __require("tls");
     var { randomBytes: randomBytes3, createHash } = __require("crypto");
     var { Duplex, Readable } = __require("stream");
-    var { URL } = __require("url");
+    var { URL: URL2 } = __require("url");
     var PerMessageDeflate2 = require_permessage_deflate();
     var Receiver2 = require_receiver();
     var Sender2 = require_sender();
@@ -2785,11 +2785,11 @@ var require_websocket = __commonJS({
         );
       }
       let parsedUrl;
-      if (address instanceof URL) {
+      if (address instanceof URL2) {
         parsedUrl = address;
       } else {
         try {
-          parsedUrl = new URL(address);
+          parsedUrl = new URL2(address);
         } catch {
           throw new SyntaxError(`Invalid URL: ${address}`);
         }
@@ -2926,7 +2926,7 @@ var require_websocket = __commonJS({
           req.abort();
           let addr;
           try {
-            addr = new URL(location, address);
+            addr = new URL2(location, address);
           } catch (e) {
             const err = new SyntaxError(`Invalid URL: ${location}`);
             emitErrorAndClose(websocket, err);
@@ -4568,12 +4568,12 @@ function createEmitterTools(deps) {
         properties: {
           name: { type: "string", description: "Unique emitter name." },
           command: { type: "string", description: "Shell command to run (creates a CommandEmitter). Output goes through EventFilter rules to determine whether lines are kept, surfaced, or injected. Use for log tailing, process monitoring, or any external command with stdout." },
-          prompt: { type: "string", description: "Prompt to send to the agent (creates a PromptEmitter). Always injects \u2014 bypasses EventFilter entirely. Use for repeated agent tasks, status checks, or simple messages." },
+          prompt: { type: "string", description: "Prompt to send to the agent (creates a PromptEmitter). Always injects \u2014 bypasses EventFilter entirely. Use for repeated agent tasks, status checks, simple messages, or autonomous goal loops." },
           description: { type: "string", description: "Short summary." },
           channel: { type: "string", description: "EventStream to receive accepted events." },
           cwd: { type: "string", description: "Optional subdirectory relative to the session cwd. Absolute paths and paths that escape the session cwd are rejected." },
-          every: { type: "string", description: "Optional repeat interval like 30s, 5m, 2h, or 1d (maximum about 24 days). Use 'idle' for prompts that re-run whenever the session is idle. When omitted, commands run continuously and prompts run once." },
-          everySchedule: { type: "array", minItems: 1, items: { type: "string" }, description: "Optional backoff schedule \u2014 an ordered non-empty list of interval strings (e.g. ['10s','20s','30s','1m','2m','5m','10m']; each maximum about 24 days). The emitter uses each interval in sequence, then repeats the last one forever. Overrides 'every' when provided. Cannot be 'idle' entries." },
+          every: { type: "string", description: "Optional repeat interval like 30s, 5m, 2h, or 1d (maximum about 24 days). Use 'idle' for conservative prompt loops that re-run only when the session is idle. When omitted, commands run continuously and prompts run once." },
+          everySchedule: { type: "array", minItems: 1, items: { type: "string" }, description: "Optional backoff schedule \u2014 an ordered non-empty list of interval strings (e.g. ['10s','20s','30s','1m','2m','5m','10m']; each maximum about 24 days). The emitter uses each interval in sequence, then repeats the last one forever. Overrides 'every' when provided. Cannot be 'idle' entries. Prefer this for autopilot-compatible goal loops that may need timed nudges while the session stays busy." },
           lifespan: policyLifespanParameter(),
           ownership: policyOwnershipParameter(),
           scope: policyScopeParameter(),
@@ -4583,7 +4583,7 @@ function createEmitterTools(deps) {
           eventFilter: EVENT_FILTER_PARAMETER_SCHEMA,
           subscribe: { type: "boolean", description: "Whether to attach a session injector to the stream as part of emitter creation." },
           delivery: { type: "string", description: "Session injector delivery mode. 'important'/'inject' only send inject-outcome lines, 'surface' surfaces surface outcomes and sends inject outcomes, 'all' surfaces all accepted lines while inject outcomes still push into the conversation, and 'keep'/'drop' store without proactive delivery." },
-          maxRuns: { type: "integer", description: "Maximum number of iterations before the emitter auto-completes. Useful for idle and timed loops." },
+          maxRuns: { type: "integer", description: "Maximum number of real iterations before the emitter stops. Useful for idle and timed loops. For goal loops this is a budget limit, not proof that the objective is complete." },
           force: policyForceParameter("emitter")
         },
         required: ["name"]
@@ -4643,14 +4643,59 @@ function createEmitterTools(deps) {
   ];
 }
 
+// src/tools/diagnostics.mjs
+function renderCanvasOpenResult(result) {
+  return [
+    "Opened tap diagnostics canvas.",
+    result?.title ? `title=${result.title}` : null,
+    result?.status ? `status=${result.status}` : null,
+    result?.url ? `url=${result.url}` : null,
+    result?.instanceId ? `instanceId=${result.instanceId}` : null,
+    result?.availability ? `availability=${result.availability}` : null
+  ].filter(Boolean).join("\n");
+}
+function createDiagnosticsTools(deps) {
+  const diagnostics2 = deps.diagnostics ?? deps.runtime;
+  if (!diagnostics2 || typeof diagnostics2.openCanvas !== "function") {
+    return [];
+  }
+  return [
+    {
+      name: "tap_open_diagnostics_canvas",
+      description: "Opens or focuses the Tap diagnostics canvas, a live flight recorder for streams, emitters, providers, logs, injection queues, and session events.",
+      parameters: {
+        type: "object",
+        properties: {
+          instanceId: {
+            type: "string",
+            description: "Stable canvas instance id. Reusing the same id focuses the existing diagnostics canvas."
+          },
+          limit: {
+            type: "integer",
+            minimum: 10,
+            maximum: 300,
+            description: "Maximum retained rows to show per diagnostics section."
+          }
+        }
+      },
+      handler: wrapToolHandler("tap_open_diagnostics_canvas", {}, async (args) => {
+        const result = await diagnostics2.openCanvas(args ?? {});
+        return renderCanvasOpenResult(result);
+      })
+    }
+  ];
+}
+
 // src/tools/index.mjs
 function createTools(deps) {
   const source = deps?.tools ?? deps?.runtime?.tools ?? {};
   const streams = deps?.streams ?? source.streams ?? deps?.runtime;
   const emitters = deps?.emitters ?? source.emitters ?? deps?.runtime;
+  const diagnostics2 = deps?.diagnostics ?? source.diagnostics ?? deps?.runtime;
   return [
     ...createStreamTools({ streams }),
-    ...createEmitterTools({ emitters })
+    ...createEmitterTools({ emitters }),
+    ...createDiagnosticsTools({ diagnostics: diagnostics2 })
   ];
 }
 
@@ -6199,6 +6244,9 @@ function createProviderConnection(ws, options, adapters = {}) {
     get tools() {
       return tools;
     },
+    get pendingCallCount() {
+      return pendingCalls.size;
+    },
     sendToolCall: sendToolCallMsg,
     sendToolCancel: sendToolCancelMsg,
     sendLifecycle,
@@ -6300,6 +6348,20 @@ function createDefaultPathAdapter() {
     join: (...parts) => path2.join(...parts)
   };
 }
+function formatGatewayBindMessage(err, { host, port }) {
+  const message = String(err?.message ?? err ?? "unknown error");
+  const code = String(err?.code ?? "");
+  const isPortInUse = code === "EADDRINUSE" || /\bEADDRINUSE\b|address already in use/i.test(message);
+  if (!isPortInUse) {
+    return `Provider gateway could not start on ${host}:${port}: ${message}`;
+  }
+  return [
+    `Provider gateway mesh already has an owner at ${host}:${port}; this tap session is joining without binding another listener.`,
+    "Core tap tools remain available.",
+    "External providers should keep using the existing gateway.",
+    "No action is needed unless provider tools are missing."
+  ].join(" ");
+}
 function createProviderGateway(options = {}, adapters = {}) {
   const {
     tapTools,
@@ -6592,7 +6654,7 @@ function createProviderGateway(options = {}, adapters = {}) {
     }
   }
   function resetFailedStart(server, err) {
-    log(`Failed to start provider gateway on port ${GATEWAY_PORT}: ${err.message}`);
+    log(formatGatewayBindMessage(err, { host, port: GATEWAY_PORT }));
     starting = false;
     if (wss === server) {
       wss = null;
@@ -6660,6 +6722,41 @@ function createProviderGateway(options = {}, adapters = {}) {
     const tap = currentTapTools || (typeof tapTools === "function" ? tapTools() : []);
     return registry.buildSessionTools(tap, dispatchToolCall);
   }
+  function projectProviderTool(tool) {
+    return {
+      name: tool.name,
+      description: tool.description ?? "",
+      timeout: tool.timeout ?? null
+    };
+  }
+  function getDiagnosticState() {
+    const connections = [...connectionsByProviderId.values()];
+    return {
+      running,
+      starting,
+      host,
+      port: GATEWAY_PORT,
+      reloadPending,
+      reloadTimerActive: Boolean(reloadTimer),
+      tokenPresent: Boolean(token),
+      providerTokenFilePath: providerTokenFilePath ? "[redacted]" : null,
+      gracefulShutdownActive,
+      connectionCount: connectionsByWs.size,
+      boundConnectionCount: connections.filter((conn) => conn.state === CONNECTION_STATE.BOUND).length,
+      providers: registry.listProviders().map((provider) => {
+        const conn = connectionsByProviderId.get(provider.id);
+        return {
+          id: provider.id,
+          name: provider.name,
+          sessionId: provider.sessionId,
+          state: conn?.state ?? "unknown",
+          pendingCallCount: conn?.pendingCallCount ?? 0,
+          toolCount: provider.tools.length,
+          tools: provider.tools.map(projectProviderTool)
+        };
+      })
+    };
+  }
   function dispatchToolCall(providerId, toolName, callId, args) {
     const conn = connectionsByProviderId.get(providerId);
     if (!conn || conn.state === CONNECTION_STATE.DISCONNECTED) {
@@ -6696,6 +6793,7 @@ function createProviderGateway(options = {}, adapters = {}) {
     getToken,
     getRegistry,
     getAllTools,
+    getDiagnosticState,
     dispatchToolCall,
     broadcastLifecycle,
     onToolsChanged,
@@ -8905,7 +9003,7 @@ function buildCompleteMessage(state) {
     return `Emitter '${state.name}' completed one run of ${state.emitterType} work.`;
   }
   if (state.maxRuns && state.runCount >= state.maxRuns) {
-    return `Emitter '${state.name}' completed ${state.runCount} of ${state.maxRuns} runs.`;
+    return `Emitter '${state.name}' reached its run budget (${state.runCount} of ${state.maxRuns} runs). This stops the emitter; goal-style loops must use their final evidence summary to decide whether the objective is complete.`;
   }
   return null;
 }
@@ -9060,12 +9158,12 @@ function computeDeferredIterationTransition(currentState, state) {
   };
 }
 function computeFailedIterationTransition(currentState, state, event, result) {
-  if (isRunBudgetExhausted(state)) {
-    return computeRunBudgetExhaustedTransition(currentState, state, event, result);
-  }
   if (result.deferred) {
     return computeDeferredIterationTransition(currentState, state);
   }
+  if (isRunBudgetExhausted(state)) {
+    return computeRunBudgetExhaustedTransition(currentState, state, event, result);
+  }
   if (state.runSchedule === RUN_SCHEDULE.ONE_TIME) {
     return {
       currentState,
@@ -9405,11 +9503,12 @@ async function runPromptIteration(emitter, context) {
   } catch (error) {
     const message = error?.message ?? String(error ?? "unknown error");
     const sessionNotAttached = isSessionNotAttachedMessage(message);
+    const deferred = sessionNotAttached || (emitter.runSchedule === RUN_SCHEDULE.TIMED || emitter.runSchedule === RUN_SCHEDULE.IDLE) && /\bsession\.idle\b/i.test(message);
     return {
       ok: false,
       error: message,
-      deferred: sessionNotAttached || (emitter.runSchedule === RUN_SCHEDULE.TIMED || emitter.runSchedule === RUN_SCHEDULE.IDLE) && /\bsession\.idle\b/i.test(message),
-      consumeRun: sessionNotAttached ? false : true,
+      deferred,
+      consumeRun: deferred ? false : true,
       deferredReason: sessionNotAttached ? "session-not-attached" : null
     };
   }
@@ -10258,6 +10357,16 @@ function createSessionPort(initialSession = null) {
     }
     return session2.sendAndWait({ prompt });
   }
+  async function openCanvas(params) {
+    if (!session2) {
+      throw new LifecycleError("Session is not attached; cannot open canvas.");
+    }
+    const canvasApi = session2.rpc?.canvas;
+    if (!canvasApi || typeof canvasApi.open !== "function") {
+      throw new LifecycleError("Canvas renderer API is not available in this Copilot session.");
+    }
+    return canvasApi.open(params);
+  }
   function registerTools(tools) {
     if (!session2) return;
     try {
@@ -10293,6 +10402,7 @@ function createSessionPort(initialSession = null) {
     log,
     send,
     sendAndWait,
+    openCanvas,
     registerTools,
     reloadExtension
   };
@@ -10536,7 +10646,23 @@ function createNotificationDispatcher({
     }
     return { cleared, generation };
   }
-  return { enqueue, clear, dispose: clear };
+  function snapshot(options = {}) {
+    const limit = Math.max(0, Math.min(Number(options.limit ?? 20) || 20, queueLimit));
+    return {
+      queueSize: queue.length,
+      maxQueueSize: queueLimit,
+      inFlight,
+      retryScheduled: retryTimer !== null,
+      generation,
+      queued: queue.slice(0, limit).map((entry) => ({
+        channel: entry.channel,
+        monitorName: entry.monitorName,
+        stream: entry.stream,
+        text: String(entry.text ?? "").slice(0, 500)
+      }))
+    };
+  }
+  return { enqueue, clear, dispose: clear, snapshot };
 }
 
 // src/services/runtime-subsystems.mjs
@@ -10732,8 +10858,263 @@ function createStreamService(deps) {
   };
 }
 
+// src/diagnostics/store.mjs
+var DEFAULT_MAX_LOGS = 300;
+var DEFAULT_MAX_EVENTS = 300;
+var DEFAULT_MAX_RUNTIME_EVENTS = 300;
+var MAX_STRING_LENGTH = 1200;
+var MAX_COLLECTION_ITEMS = 40;
+var MAX_DEPTH = 4;
+var SECRET_KEY_PATTERN = /(?:token|secret|password|credential|authorization|api[-_]?key|reconnectToken|expectedToken)/i;
+function normalizePositiveInteger(value, fallback) {
+  const number = Number(value);
+  if (!Number.isFinite(number)) {
+    return fallback;
+  }
+  return Math.max(0, Math.floor(number));
+}
+function createRingBuffer(maxEntries) {
+  const entries = [];
+  const limit = normalizePositiveInteger(maxEntries, 0);
+  let total = 0;
+  let dropped = 0;
+  function append(entry) {
+    total += 1;
+    if (limit === 0) {
+      dropped += 1;
+      return null;
+    }
+    entries.push(entry);
+    if (entries.length > limit) {
+      const overflow = entries.length - limit;
+      entries.splice(0, overflow);
+      dropped += overflow;
+    }
+    return entry;
+  }
+  function snapshot(limitOverride) {
+    const requested = normalizePositiveInteger(limitOverride, entries.length);
+    return entries.slice(Math.max(0, entries.length - requested)).map((entry) => safeClone(entry));
+  }
+  function stats() {
+    return {
+      retained: entries.length,
+      total,
+      dropped,
+      capacity: limit
+    };
+  }
+  return { append, snapshot, stats };
+}
+function truncateString(value, maxLength = MAX_STRING_LENGTH) {
+  const text = String(value ?? "");
+  if (text.length <= maxLength) {
+    return text;
+  }
+  return `${text.slice(0, maxLength)}... (${text.length - maxLength} chars truncated)`;
+}
+function safeClone(value, options = {}, depth = 0, seen = /* @__PURE__ */ new WeakSet()) {
+  const maxDepth = normalizePositiveInteger(options.maxDepth, MAX_DEPTH);
+  const maxStringLength = normalizePositiveInteger(options.maxStringLength, MAX_STRING_LENGTH);
+  const maxCollectionItems = normalizePositiveInteger(options.maxCollectionItems, MAX_COLLECTION_ITEMS);
+  if (value === null || value === void 0) {
+    return value ?? null;
+  }
+  if (typeof value === "string") {
+    return truncateString(value, maxStringLength);
+  }
+  if (typeof value === "number" || typeof value === "boolean") {
+    return value;
+  }
+  if (typeof value === "bigint") {
+    return String(value);
+  }
+  if (typeof value === "function" || typeof value === "symbol") {
+    return `[${typeof value}]`;
+  }
+  if (value instanceof Error) {
+    return {
+      name: value.name,
+      message: truncateString(value.message, maxStringLength),
+      stack: truncateString(value.stack ?? "", maxStringLength)
+    };
+  }
+  if (depth >= maxDepth) {
+    return Array.isArray(value) ? `[Array(${value.length})]` : "[Object]";
+  }
+  if (typeof value !== "object") {
+    return String(value);
+  }
+  if (seen.has(value)) {
+    return "[Circular]";
+  }
+  seen.add(value);
+  if (Array.isArray(value)) {
+    const slice = value.slice(0, maxCollectionItems).map((item) => safeClone(item, options, depth + 1, seen));
+    if (value.length > maxCollectionItems) {
+      slice.push(`... ${value.length - maxCollectionItems} more items`);
+    }
+    return slice;
+  }
+  const output = {};
+  const entries = Object.entries(value).slice(0, maxCollectionItems);
+  for (const [key, item] of entries) {
+    output[key] = SECRET_KEY_PATTERN.test(key) ? "[redacted]" : safeClone(item, options, depth + 1, seen);
+  }
+  const remaining = Object.keys(value).length - entries.length;
+  if (remaining > 0) {
+    output.__truncatedKeys = remaining;
+  }
+  return output;
+}
+function normalizeLevel(value) {
+  const level = String(value ?? "info").trim().toLowerCase();
+  if (level === "warning" || level === "warn") return "warning";
+  if (level === "error") return "error";
+  if (level === "debug") return "debug";
+  return "info";
+}
+function createId(prefix, count) {
+  return `${prefix}-${count.toString(36)}`;
+}
+function summarizeSessionEvent(event) {
+  const data = event?.data && typeof event.data === "object" ? event.data : {};
+  return {
+    id: event?.id ?? null,
+    timestamp: event?.timestamp ?? nowIso(),
+    type: String(event?.type ?? "unknown"),
+    ephemeral: event?.ephemeral === true,
+    agentId: event?.agentId ?? null,
+    dataKeys: Object.keys(data),
+    data: safeClone(data, {
+      maxDepth: 3,
+      maxStringLength: 700,
+      maxCollectionItems: 24
+    })
+  };
+}
+function createDiagnosticsStore(options = {}) {
+  const logs = createRingBuffer(options.maxLogs ?? DEFAULT_MAX_LOGS);
+  const sessionEvents = createRingBuffer(options.maxSessionEvents ?? DEFAULT_MAX_EVENTS);
+  const runtimeEvents = createRingBuffer(options.maxRuntimeEvents ?? DEFAULT_MAX_RUNTIME_EVENTS);
+  const sessionEventCounts = /* @__PURE__ */ new Map();
+  let logCount = 0;
+  let runtimeEventCount = 0;
+  let sessionEventCount = 0;
+  let cleanupSessionListener = () => {
+  };
+  function recordLog(source, message, options2 = {}) {
+    logCount += 1;
+    return logs.append({
+      id: createId("log", logCount),
+      timestamp: nowIso(),
+      source: String(source ?? "tap"),
+      level: normalizeLevel(options2.level),
+      message: truncateString(message, options2.maxStringLength ?? MAX_STRING_LENGTH),
+      metadata: safeClone(options2.metadata ?? null, {
+        maxDepth: 3,
+        maxStringLength: 700,
+        maxCollectionItems: 20
+      })
+    });
+  }
+  function recordRuntimeEvent(type, message, metadata = {}) {
+    runtimeEventCount += 1;
+    return runtimeEvents.append({
+      id: createId("evt", runtimeEventCount),
+      timestamp: nowIso(),
+      type: String(type ?? "runtime"),
+      message: truncateString(message, MAX_STRING_LENGTH),
+      metadata: safeClone(metadata, {
+        maxDepth: 3,
+        maxStringLength: 700,
+        maxCollectionItems: 20
+      })
+    });
+  }
+  function recordSessionEvent(event) {
+    sessionEventCount += 1;
+    const type = String(event?.type ?? "unknown");
+    sessionEventCounts.set(type, (sessionEventCounts.get(type) ?? 0) + 1);
+    return sessionEvents.append({
+      sequence: sessionEventCount,
+      ...summarizeSessionEvent(event)
+    });
+  }
+  function detachSession() {
+    try {
+      cleanupSessionListener();
+    } catch {
+    }
+    cleanupSessionListener = () => {
+    };
+  }
+  function attachSession(session2) {
+    detachSession();
+    if (!session2 || typeof session2.on !== "function") {
+      recordRuntimeEvent("session-events", "Session event capture unavailable; no session listener attached.");
+      return;
+    }
+    try {
+      const unsubscribe = session2.on((event) => {
+        recordSessionEvent(event);
+      });
+      cleanupSessionListener = typeof unsubscribe === "function" ? unsubscribe : () => {
+      };
+      recordRuntimeEvent("session-events", "Session event capture attached.");
+    } catch (error) {
+      recordLog("diagnostics", "Failed to attach session event capture.", {
+        level: "warning",
+        metadata: { error }
+      });
+    }
+  }
+  function snapshot(options2 = {}) {
+    return {
+      generatedAt: nowIso(),
+      logs: logs.snapshot(options2.logLimit ?? 140),
+      runtimeEvents: runtimeEvents.snapshot(options2.runtimeEventLimit ?? 140),
+      sessionEvents: sessionEvents.snapshot(options2.sessionEventLimit ?? 140),
+      sessionEventCounts: Object.fromEntries([...sessionEventCounts.entries()].sort(([left], [right]) => left.localeCompare(right))),
+      stats: {
+        logs: logs.stats(),
+        runtimeEvents: runtimeEvents.stats(),
+        sessionEvents: sessionEvents.stats()
+      }
+    };
+  }
+  return {
+    log: recordLog,
+    event: recordRuntimeEvent,
+    attachSession,
+    detachSession,
+    snapshot
+  };
+}
+
+// src/canvas/consts.mjs
+var TAP_DIAGNOSTICS_CANVAS_ID = "tap-diagnostics";
+
 // src/services/tap-runtime-service.mjs
+function trimStreamEntries(stream, limit) {
+  const entryLimit = Math.max(0, Math.floor(Number(limit ?? 80) || 80));
+  return {
+    ...stream,
+    entries: Array.isArray(stream.entries) ? stream.entries.slice(Math.max(0, stream.entries.length - entryLimit)) : []
+  };
+}
+function projectToolForDiagnostics(tool) {
+  return {
+    name: tool.name,
+    description: tool.description ?? "",
+    providerId: tool.providerId ?? null,
+    providerName: tool.providerName ?? null,
+    skipPermission: tool.skipPermission === true,
+    overridesBuiltInTool: tool.overridesBuiltInTool === true
+  };
+}
 function createTapRuntimeService(options = {}) {
+  const diagnosticsStore = options.diagnostics ?? createDiagnosticsStore();
   const {
     streams,
     configStore,
@@ -10780,6 +11161,7 @@ function createTapRuntimeService(options = {}) {
     sessionContext.attachSession(session2);
     sessionPort.attach(session2);
     sessionActivityBridge.attach(session2);
+    diagnosticsStore.attachSession(session2);
   }
   function clearNotificationsForLifecycle(options2 = {}) {
     if (options2.clearNotifications === true && typeof notifications.clear === "function") {
@@ -10852,6 +11234,7 @@ function createTapRuntimeService(options = {}) {
   const providerCapabilities = {
     getSessionInfo,
     log: (msg) => {
+      diagnosticsStore.log("gateway", msg);
       process.stderr.write(`[tap-gateway] ${msg}
 `);
       void sessionPort.log(msg);
@@ -10862,14 +11245,53 @@ function createTapRuntimeService(options = {}) {
       void sessionPort.reloadExtension();
     }
   };
+  function getDiagnosticsSnapshot(options2 = {}, extra = {}) {
+    const allTools = Array.isArray(extra.tools) ? extra.tools.map(projectToolForDiagnostics) : [];
+    return {
+      generatedAt: nowIso(),
+      session: getSessionInfo(),
+      baseCwd: sessionContext.getBaseCwd(),
+      process: {
+        pid: process.pid,
+        platform: process.platform,
+        uptimeSeconds: Math.round(process.uptime())
+      },
+      streams: streamCapabilities.listStreams().map((stream) => trimStreamEntries(stream, options2.streamEntryLimit)),
+      emitters: emitterCapabilities.listEmitters(),
+      gateway: extra.gateway ?? null,
+      tools: allTools,
+      notifications: typeof notifications.snapshot === "function" ? notifications.snapshot({ limit: options2.notificationLimit ?? 20 }) : null,
+      diagnostics: diagnosticsStore.snapshot(options2)
+    };
+  }
+  const diagnosticsCapabilities = {
+    log: (source, message, options2 = {}) => diagnosticsStore.log(source, message, options2),
+    event: (type, message, metadata = {}) => diagnosticsStore.event(type, message, metadata),
+    snapshot: getDiagnosticsSnapshot,
+    openCanvas: async (input = {}) => {
+      const instanceId = String(input.instanceId ?? TAP_DIAGNOSTICS_CANVAS_ID).trim() || TAP_DIAGNOSTICS_CANVAS_ID;
+      const limit = Number(input.limit);
+      const canvasInput = Number.isFinite(limit) ? { limit: Math.max(10, Math.min(300, Math.floor(limit))) } : {};
+      diagnosticsStore.event("canvas.open.requested", "Opening tap diagnostics canvas.", { instanceId, canvasInput });
+      return sessionPort.openCanvas({
+        canvasId: TAP_DIAGNOSTICS_CANVAS_ID,
+        instanceId,
+        input: canvasInput
+      });
+    },
+    attachSession: diagnosticsStore.attachSession,
+    detachSession: diagnosticsStore.detachSession
+  };
   return {
     tools: {
       streams: streamCapabilities,
-      emitters: emitterCapabilities
+      emitters: emitterCapabilities,
+      diagnostics: diagnosticsCapabilities
     },
     hooks: hookCapabilities,
     session: sessionCapabilities,
     provider: providerCapabilities,
+    diagnostics: diagnosticsCapabilities,
     getBaseCwd: sessionContext.getBaseCwd,
     getSessionInfo,
     attachSession,
@@ -10892,6 +11314,725 @@ function createTapRuntimeService(options = {}) {
   };
 }
 
+// src/canvas/diagnostics-canvas.mjs
+import { createServer } from "node:http";
+import { createCanvas } from "@github/copilot-sdk/extension";
+var DEFAULT_REFRESH_MS = 1200;
+function jsonResponse(res, status, data) {
+  const body = JSON.stringify(data, null, 2);
+  res.writeHead(status, {
+    "Content-Type": "application/json; charset=utf-8",
+    "Cache-Control": "no-store",
+    "X-Content-Type-Options": "nosniff"
+  });
+  res.end(body);
+}
+function textResponse(res, status, body, contentType = "text/plain; charset=utf-8") {
+  res.writeHead(status, {
+    "Content-Type": contentType,
+    "Cache-Control": "no-store",
+    "X-Content-Type-Options": "nosniff"
+  });
+  res.end(body);
+}
+function sanitizeSnapshotOptions(input = {}) {
+  const source = input && typeof input === "object" ? input : {};
+  const limit = Number(source.limit);
+  return {
+    streamEntryLimit: Number.isFinite(limit) ? Math.max(10, Math.min(200, Math.floor(limit))) : 80,
+    logLimit: Number.isFinite(limit) ? Math.max(20, Math.min(300, Math.floor(limit))) : 160,
+    sessionEventLimit: Number.isFinite(limit) ? Math.max(20, Math.min(300, Math.floor(limit))) : 160,
+    runtimeEventLimit: Number.isFinite(limit) ? Math.max(20, Math.min(300, Math.floor(limit))) : 160
+  };
+}
+function summarizeSnapshot(snapshot) {
+  const runningEmitters = Array.isArray(snapshot?.emitters?.running) ? snapshot.emitters.running.length : 0;
+  const configuredEmitters = Array.isArray(snapshot?.emitters?.configured) ? snapshot.emitters.configured.length : 0;
+  const streams = Array.isArray(snapshot?.streams) ? snapshot.streams.length : 0;
+  const providers = Array.isArray(snapshot?.gateway?.providers) ? snapshot.gateway.providers.length : 0;
+  const logs = snapshot?.diagnostics?.stats?.logs?.retained ?? 0;
+  const sessionEvents = snapshot?.diagnostics?.stats?.sessionEvents?.retained ?? 0;
+  return { streams, runningEmitters, configuredEmitters, providers, logs, sessionEvents };
+}
+function createHtml() {
+  return `<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8" />
+  <meta name="viewport" content="width=device-width, initial-scale=1, viewport-fit=cover" />
+  <title>tap diagnostics</title>
+  <style>
+    :root {
+      color-scheme: light;
+      --paper: oklch(96% 0.018 86);
+      --paper-2: oklch(91% 0.025 82);
+      --ink: oklch(18% 0.026 70);
+      --muted: oklch(43% 0.04 73);
+      --line: oklch(72% 0.052 76);
+      --amber: oklch(70% 0.15 72);
+      --amber-dark: oklch(42% 0.12 67);
+      --red: oklch(55% 0.18 30);
+      --green: oklch(55% 0.13 145);
+      --blue: oklch(48% 0.1 245);
+      --surface: oklch(99% 0.012 88);
+      --shadow: 0 24px 80px oklch(28% 0.04 70 / 0.14);
+      --font-display: "Bahnschrift", "Aptos Display", "Segoe UI Variable Display", sans-serif;
+      --font-body: "Aptos", "Segoe UI Variable Text", sans-serif;
+      --font-mono: "Cascadia Code", "Consolas", monospace;
+    }
+
+    * { box-sizing: border-box; }
+    html { min-height: 100%; background: var(--paper); color: var(--ink); }
+    body {
+      margin: 0;
+      min-height: 100vh;
+      font-family: var(--font-body);
+      background:
+        linear-gradient(90deg, oklch(34% 0.08 68 / 0.08) 1px, transparent 1px) 0 0 / 42px 42px,
+        linear-gradient(0deg, oklch(34% 0.08 68 / 0.055) 1px, transparent 1px) 0 0 / 42px 42px,
+        radial-gradient(circle at 8% 12%, oklch(76% 0.13 74 / 0.35), transparent 28rem),
+        var(--paper);
+    }
+
+    button, input { font: inherit; }
+    button:focus-visible, input:focus-visible {
+      outline: 3px solid var(--amber-dark);
+      outline-offset: 3px;
+    }
+
+    .shell {
+      width: min(1540px, calc(100vw - clamp(18px, 4vw, 64px)));
+      margin: 0 auto;
+      padding: clamp(22px, 4vw, 54px) 0;
+    }
+
+    .masthead {
+      display: grid;
+      grid-template-columns: minmax(0, 1fr);
+      gap: 22px;
+      align-items: end;
+      border-bottom: 3px solid var(--ink);
+      padding-bottom: clamp(18px, 3vw, 34px);
+    }
+
+    .mark {
+      width: 72px;
+      aspect-ratio: 1;
+      display: grid;
+      place-items: center;
+      border: 3px solid var(--ink);
+      background: var(--amber);
+      box-shadow: 8px 8px 0 var(--ink);
+      font-family: var(--font-display);
+      font-size: 44px;
+      line-height: 1;
+    }
+
+    .title-wrap {
+      display: grid;
+      grid-template-columns: auto minmax(0, 1fr);
+      gap: clamp(16px, 3vw, 28px);
+      align-items: center;
+    }
+
+    h1 {
+      margin: 0;
+      font-family: var(--font-display);
+      font-size: clamp(2.4rem, 7vw, 6.8rem);
+      line-height: 0.82;
+      letter-spacing: -0.08em;
+      text-transform: uppercase;
+      max-width: 11ch;
+    }
+
+    .dek {
+      margin: 12px 0 0;
+      max-width: 78ch;
+      color: var(--muted);
+      font-size: clamp(0.98rem, 1.8vw, 1.18rem);
+      line-height: 1.45;
+    }
+
+    .controls {
+      display: flex;
+      flex-wrap: wrap;
+      gap: 10px;
+      align-items: center;
+      justify-content: space-between;
+    }
+
+    .filter-row {
+      display: flex;
+      gap: 8px;
+      flex-wrap: wrap;
+    }
+
+    .chip, .button {
+      border: 2px solid var(--ink);
+      background: var(--surface);
+      color: var(--ink);
+      min-height: 40px;
+      padding: 8px 13px;
+      box-shadow: 3px 3px 0 var(--ink);
+      cursor: pointer;
+      transition: transform 140ms ease, box-shadow 140ms ease, background 140ms ease;
+    }
+
+    .chip[aria-pressed="true"], .button.primary {
+      background: var(--ink);
+      color: var(--paper);
+    }
+
+    @media (hover: hover) {
+      .chip:hover, .button:hover { transform: translate(-1px, -1px); box-shadow: 5px 5px 0 var(--ink); }
+    }
+
+    .search {
+      display: flex;
+      align-items: center;
+      gap: 10px;
+      min-width: min(100%, 380px);
+      border: 2px solid var(--ink);
+      background: var(--surface);
+      box-shadow: 3px 3px 0 var(--ink);
+      padding: 8px 12px;
+    }
+
+    .search input {
+      width: 100%;
+      border: 0;
+      background: transparent;
+      color: var(--ink);
+      outline: 0;
+    }
+
+    .dashboard {
+      display: grid;
+      grid-template-columns: minmax(0, 1fr);
+      gap: clamp(18px, 3vw, 34px);
+      margin-top: clamp(22px, 4vw, 48px);
+    }
+
+    .metrics {
+      display: grid;
+      grid-template-columns: repeat(2, minmax(0, 1fr));
+      gap: 12px;
+    }
+
+    .metric {
+      min-height: 118px;
+      border: 2px solid var(--ink);
+      background: var(--surface);
+      box-shadow: var(--shadow);
+      padding: 16px;
+      display: flex;
+      flex-direction: column;
+      justify-content: space-between;
+    }
+
+    .metric b {
+      font-family: var(--font-display);
+      font-size: clamp(2rem, 5vw, 4.2rem);
+      line-height: 0.9;
+      letter-spacing: -0.05em;
+    }
+
+    .metric span {
+      color: var(--muted);
+      text-transform: uppercase;
+      font-size: 0.72rem;
+      letter-spacing: 0.14em;
+      font-weight: 800;
+    }
+
+    .panel {
+      border: 2px solid var(--ink);
+      background: oklch(98% 0.014 88 / 0.96);
+      box-shadow: 8px 8px 0 oklch(18% 0.026 70 / 0.22);
+      min-width: 0;
+    }
+
+    .panel-head {
+      display: flex;
+      align-items: baseline;
+      justify-content: space-between;
+      gap: 12px;
+      padding: 14px 16px;
+      border-bottom: 2px solid var(--ink);
+      background: var(--paper-2);
+    }
+
+    .panel-head h2 {
+      margin: 0;
+      font-family: var(--font-display);
+      font-size: clamp(1.2rem, 2vw, 1.7rem);
+      letter-spacing: -0.03em;
+      text-transform: uppercase;
+    }
+
+    .panel-head small {
+      color: var(--muted);
+      font-family: var(--font-mono);
+      font-size: 0.75rem;
+    }
+
+    .panel-body {
+      padding: 14px;
+      max-height: min(62vh, 720px);
+      overflow: auto;
+    }
+
+    .stream-grid, .emitter-grid, .provider-grid {
+      display: grid;
+      gap: 12px;
+    }
+
+    .record {
+      border-left: 4px solid var(--line);
+      background: color-mix(in oklch, var(--surface), var(--paper) 24%);
+      padding: 11px 12px;
+    }
+
+    .record strong {
+      display: inline-flex;
+      gap: 8px;
+      align-items: baseline;
+      font-family: var(--font-display);
+      letter-spacing: -0.01em;
+    }
+
+    .meta {
+      color: var(--muted);
+      font-family: var(--font-mono);
+      font-size: 0.72rem;
+      overflow-wrap: anywhere;
+    }
+
+    .entry {
+      margin-top: 8px;
+      padding-top: 8px;
+      border-top: 1px dashed var(--line);
+      font-family: var(--font-mono);
+      font-size: 0.78rem;
+      line-height: 1.45;
+      white-space: pre-wrap;
+      overflow-wrap: anywhere;
+    }
+
+    .timeline {
+      display: grid;
+      gap: 9px;
+    }
+
+    .tick {
+      display: grid;
+      grid-template-columns: 90px minmax(0, 1fr);
+      gap: 12px;
+      border-bottom: 1px dashed var(--line);
+      padding: 9px 0;
+    }
+
+    .tick time {
+      color: var(--muted);
+      font-family: var(--font-mono);
+      font-size: 0.72rem;
+    }
+
+    .badge {
+      display: inline-flex;
+      align-items: center;
+      gap: 6px;
+      padding: 2px 7px;
+      border: 1px solid var(--ink);
+      background: var(--paper);
+      font-family: var(--font-mono);
+      font-size: 0.68rem;
+      text-transform: uppercase;
+      letter-spacing: 0.08em;
+    }
+
+    .badge.error { background: color-mix(in oklch, var(--red), var(--paper) 72%); }
+    .badge.warning { background: color-mix(in oklch, var(--amber), var(--paper) 54%); }
+    .badge.ready, .badge.running, .badge.success { background: color-mix(in oklch, var(--green), var(--paper) 70%); }
+    .badge.info, .badge.debug { background: color-mix(in oklch, var(--blue), var(--paper) 76%); }
+
+    .details {
+      margin-top: 6px;
+      color: var(--ink);
+      font-family: var(--font-mono);
+      font-size: 0.78rem;
+      white-space: pre-wrap;
+      overflow-wrap: anywhere;
+    }
+
+    .empty {
+      border: 2px dashed var(--line);
+      padding: 18px;
+      color: var(--muted);
+      background: color-mix(in oklch, var(--surface), var(--paper) 45%);
+    }
+
+    .footer {
+      margin-top: 24px;
+      color: var(--muted);
+      font-size: 0.86rem;
+    }
+
+    @media (min-width: 780px) {
+      .masthead { grid-template-columns: minmax(0, 1fr) auto; }
+      .dashboard { grid-template-columns: minmax(280px, 0.62fr) minmax(0, 1fr); align-items: start; }
+      .metrics { grid-template-columns: repeat(2, minmax(0, 1fr)); }
+      .timeline-panel { grid-column: 1 / -1; }
+    }
+
+    @media (min-width: 1180px) {
+      .dashboard { grid-template-columns: 360px minmax(0, 1fr) 420px; }
+      .timeline-panel { grid-column: auto; }
+      .metrics { grid-template-columns: 1fr; }
+    }
+
+    @media (prefers-reduced-motion: reduce) {
+      *, *::before, *::after {
+        animation-duration: 0.01ms !important;
+        animation-iteration-count: 1 !important;
+        scroll-behavior: auto !important;
+        transition-duration: 0.01ms !important;
+      }
+    }
+  </style>
+</head>
+<body>
+  <main class="shell">
+    <header class="masthead">
+      <div class="title-wrap">
+        <div class="mark" aria-hidden="true">\u203B</div>
+        <div>
+          <h1>Tap flight recorder</h1>
+          <p class="dek">A live canvas for streams, emitters, provider gateway state, injection queues, session events, and tap diagnostics. Bounded, redacted, and built for incident-speed inspection.</p>
+        </div>
+      </div>
+      <div class="controls" aria-label="Diagnostics controls">
+        <div class="filter-row" role="group" aria-label="Timeline filter">
+          <button class="chip" data-filter="all" aria-pressed="true">All</button>
+          <button class="chip" data-filter="streams" aria-pressed="false">Streams</button>
+          <button class="chip" data-filter="logs" aria-pressed="false">Logs</button>
+          <button class="chip" data-filter="session" aria-pressed="false">Session</button>
+          <button class="chip" data-filter="runtime" aria-pressed="false">Runtime</button>
+        </div>
+        <label class="search">
+          <span aria-hidden="true">\u2315</span>
+          <input id="search" type="search" placeholder="Filter evidence..." autocomplete="off" />
+        </label>
+        <button id="pause" class="button" type="button">Pause</button>
+        <button id="refresh" class="button primary" type="button">Refresh</button>
+      </div>
+    </header>
+
+    <section class="dashboard" aria-live="polite">
+      <aside>
+        <div class="metrics" id="metrics"></div>
+        <p class="footer" id="heartbeat">Waiting for first snapshot...</p>
+      </aside>
+
+      <section class="panel">
+        <div class="panel-head">
+          <h2>Streams and emitters</h2>
+          <small id="stream-count">0 streams</small>
+        </div>
+        <div class="panel-body">
+          <div class="stream-grid" id="streams"></div>
+        </div>
+      </section>
+
+      <section class="panel">
+        <div class="panel-head">
+          <h2>Providers</h2>
+          <small id="provider-count">0 providers</small>
+        </div>
+        <div class="panel-body">
+          <div class="provider-grid" id="providers"></div>
+        </div>
+      </section>
+
+      <section class="panel timeline-panel">
+        <div class="panel-head">
+          <h2>Evidence timeline</h2>
+          <small id="timeline-count">0 events</small>
+        </div>
+        <div class="panel-body">
+          <div class="timeline" id="timeline"></div>
+        </div>
+      </section>
+    </section>
+  </main>
+
+  <script>
+    const state = { snapshot: null, paused: false, filter: "all", query: "" };
+    const el = (id) => document.getElementById(id);
+    const escapeHtml = (value) => String(value ?? "").replace(/[&<>"']/g, (ch) => ({ "&": "&amp;", "<": "&lt;", ">": "&gt;", '"': "&quot;", "'": "&#39;" }[ch]));
+    const timeOnly = (value) => {
+      const date = new Date(value);
+      return Number.isNaN(date.getTime()) ? "" : date.toLocaleTimeString([], { hour12: false });
+    };
+    const compactJson = (value) => {
+      if (value === null || value === undefined) return "";
+      if (typeof value === "string") return value;
+      try { return JSON.stringify(value, null, 2); } catch { return String(value); }
+    };
+
+    function metric(label, value, tone = "") {
+      return '<article class="metric ' + tone + '"><span>' + escapeHtml(label) + '</span><b>' + escapeHtml(value) + '</b></article>';
+    }
+
+    function renderMetrics(snapshot) {
+      const running = snapshot.emitters?.running?.length ?? 0;
+      const configured = snapshot.emitters?.configured?.length ?? 0;
+      const streams = snapshot.streams?.length ?? 0;
+      const providers = snapshot.gateway?.providers?.length ?? 0;
+      const queue = snapshot.notifications?.queueSize ?? 0;
+      const sessionEvents = snapshot.diagnostics?.stats?.sessionEvents?.retained ?? 0;
+      el("metrics").innerHTML = [
+        metric("streams", streams),
+        metric("running emitters", running),
+        metric("providers", providers),
+        metric("queued injections", queue),
+        metric("configured emitters", configured),
+        metric("session events", sessionEvents)
+      ].join("");
+      el("heartbeat").textContent = "Snapshot " + timeOnly(snapshot.generatedAt) + " | pid " + (snapshot.process?.pid ?? "?") + " | gateway " + (snapshot.gateway?.running ? "ready" : "stopped");
+    }
+
+    function renderStreams(snapshot) {
+      const streams = snapshot.streams ?? [];
+      el("stream-count").textContent = streams.length + " streams";
+      if (streams.length === 0) {
+        el("streams").innerHTML = '<div class="empty">No streams are currently retained.</div>';
+        return;
+      }
+      const emitterRows = [...(snapshot.emitters?.running ?? []), ...(snapshot.emitters?.configured ?? [])]
+        .map((emitter) => '<div class="record"><strong>' + escapeHtml(emitter.name) + ' <span class="badge ' + escapeHtml(emitter.status) + '">' + escapeHtml(emitter.status) + '</span></strong><div class="meta">' + escapeHtml(emitter.emitterType) + ' | ' + escapeHtml(emitter.runSchedule) + ' | stream=' + escapeHtml(emitter.stream) + '</div><div class="meta">lines=' + escapeHtml(emitter.lineCount ?? 0) + ' dropped=' + escapeHtml(emitter.droppedLineCount ?? 0) + '</div></div>')
+        .join("");
+      const streamRows = streams.map((stream) => {
+        const latest = (stream.entries ?? []).slice(-3).reverse().map((entry) => '<div class="entry"><span class="meta">' + escapeHtml(timeOnly(entry.timestamp)) + ' ' + escapeHtml(entry.source) + (entry.monitorName ? ' / ' + escapeHtml(entry.monitorName) : '') + '</span>\\n' + escapeHtml(entry.text) + '</div>').join("");
+        return '<div class="record"><strong>' + escapeHtml(stream.name) + ' <span class="badge ' + (stream.sessionInjector?.enabled ? 'ready' : 'info') + '">' + (stream.sessionInjector?.enabled ? 'injector on' : 'kept') + '</span></strong><div class="meta">' + escapeHtml(stream.entries?.length ?? 0) + ' retained entries | delivery=' + escapeHtml(stream.sessionInjector?.delivery ?? 'surface') + '</div>' + (latest || '<div class="entry">No entries retained for this stream.</div>') + '</div>';
+      }).join("");
+      el("streams").innerHTML = streamRows + (emitterRows ? '<div class="panel-head" style="margin:14px -14px 12px"><h2>Emitter roll call</h2><small>' + ((snapshot.emitters?.running?.length ?? 0) + (snapshot.emitters?.configured?.length ?? 0)) + ' emitters</small></div><div class="emitter-grid">' + emitterRows + '</div>' : "");
+    }
+
+    function renderProviders(snapshot) {
+      const gateway = snapshot.gateway ?? {};
+      const providers = gateway.providers ?? [];
+      el("provider-count").textContent = providers.length + " providers";
+      const gatewayRecord = '<div class="record"><strong>gateway <span class="badge ' + (gateway.running ? 'ready' : 'error') + '">' + (gateway.running ? 'running' : 'stopped') + '</span></strong><div class="meta">port=' + escapeHtml(gateway.port ?? "?") + ' connections=' + escapeHtml(gateway.connectionCount ?? 0) + ' reloadPending=' + escapeHtml(gateway.reloadPending ?? false) + ' token=' + (gateway.tokenPresent ? 'present' : 'absent') + '</div></div>';
+      if (providers.length === 0) {
+        el("providers").innerHTML = gatewayRecord + '<div class="empty">No external providers are bound. The canvas still shows tap-native streams and emitters.</div>';
+        return;
+      }
+      const rows = providers.map((provider) => {
+        const tools = (provider.tools ?? []).map((tool) => tool.name).join(", ") || "no tools";
+        return '<div class="record"><strong>' + escapeHtml(provider.name) + ' <span class="badge ready">' + escapeHtml(provider.id) + '</span></strong><div class="meta">session=' + escapeHtml(provider.sessionId ?? "none") + ' | tools=' + escapeHtml(provider.toolCount ?? 0) + '</div><div class="details">' + escapeHtml(tools) + '</div></div>';
+      }).join("");
+      el("providers").innerHTML = gatewayRecord + rows;
+    }
+
+    function collectTimeline(snapshot) {
+      const items = [];
+      for (const stream of snapshot.streams ?? []) {
+        for (const entry of stream.entries ?? []) {
+          items.push({ group: "streams", timestamp: entry.timestamp, source: "stream/" + stream.name, level: "info", message: entry.text, detail: entry.monitorName ? entry.monitorName + " " + (entry.stream ?? "") : entry.source });
+        }
+      }
+      for (const log of snapshot.diagnostics?.logs ?? []) {
+        items.push({ group: "logs", timestamp: log.timestamp, source: log.source, level: log.level, message: log.message, detail: compactJson(log.metadata) });
+      }
+      for (const event of snapshot.diagnostics?.sessionEvents ?? []) {
+        items.push({ group: "session", timestamp: event.timestamp, source: "session", level: "debug", message: event.type, detail: compactJson(event.data) });
+      }
+      for (const event of snapshot.diagnostics?.runtimeEvents ?? []) {
+        items.push({ group: "runtime", timestamp: event.timestamp, source: event.type, level: "info", message: event.message, detail: compactJson(event.metadata) });
+      }
+      return items.sort((a, b) => new Date(b.timestamp) - new Date(a.timestamp));
+    }
+
+    function renderTimeline(snapshot) {
+      const query = state.query.trim().toLowerCase();
+      const items = collectTimeline(snapshot).filter((item) => {
+        if (state.filter !== "all" && item.group !== state.filter) return false;
+        if (!query) return true;
+        return [item.source, item.level, item.message, item.detail].join(" ").toLowerCase().includes(query);
+      }).slice(0, 260);
+      el("timeline-count").textContent = items.length + " visible";
+      if (items.length === 0) {
+        el("timeline").innerHTML = '<div class="empty">No evidence matches the current filter.</div>';
+        return;
+      }
+      el("timeline").innerHTML = items.map((item) => '<div class="tick"><time>' + escapeHtml(timeOnly(item.timestamp)) + '</time><div><span class="badge ' + escapeHtml(item.level) + '">' + escapeHtml(item.group) + '</span> <span class="meta">' + escapeHtml(item.source) + '</span><div><strong>' + escapeHtml(item.message) + '</strong></div>' + (item.detail ? '<div class="details">' + escapeHtml(item.detail) + '</div>' : '') + '</div></div>').join("");
+    }
+
+    function render(snapshot) {
+      state.snapshot = snapshot;
+      renderMetrics(snapshot);
+      renderStreams(snapshot);
+      renderProviders(snapshot);
+      renderTimeline(snapshot);
+    }
+
+    async function refresh() {
+      if (state.paused) return;
+      const response = await fetch("/api/snapshot", { cache: "no-store" });
+      if (response.ok) render(await response.json());
+    }
+
+    function connectEvents() {
+      if (!("EventSource" in window)) {
+        setInterval(refresh, 1800);
+        refresh();
+        return;
+      }
+      const source = new EventSource("/events");
+      source.addEventListener("snapshot", (event) => {
+        if (!state.paused) render(JSON.parse(event.data));
+      });
+      source.onerror = () => {
+        setTimeout(refresh, 2000);
+      };
+    }
+
+    document.querySelectorAll("[data-filter]").forEach((button) => {
+      button.addEventListener("click", () => {
+        state.filter = button.dataset.filter;
+        document.querySelectorAll("[data-filter]").forEach((item) => item.setAttribute("aria-pressed", String(item === button)));
+        if (state.snapshot) renderTimeline(state.snapshot);
+      });
+    });
+    el("search").addEventListener("input", (event) => {
+      state.query = event.target.value;
+      if (state.snapshot) renderTimeline(state.snapshot);
+    });
+    el("pause").addEventListener("click", () => {
+      state.paused = !state.paused;
+      el("pause").textContent = state.paused ? "Resume" : "Pause";
+      if (!state.paused) refresh();
+    });
+    el("refresh").addEventListener("click", () => refresh());
+    connectEvents();
+  </script>
+</body>
+</html>`;
+}
+function createTapDiagnosticsCanvas({ getSnapshot, diagnostics: diagnostics2 } = {}) {
+  const instances = /* @__PURE__ */ new Map();
+  function snapshot(options = {}) {
+    return typeof getSnapshot === "function" ? getSnapshot(sanitizeSnapshotOptions(options)) : { generatedAt: (/* @__PURE__ */ new Date()).toISOString(), error: "No diagnostics snapshot provider configured." };
+  }
+  function log(message, level = "info", metadata = {}) {
+    diagnostics2?.log?.("canvas", message, { level, metadata });
+  }
+  async function startServer(instanceId) {
+    const server = createServer((req, res) => {
+      const url = new URL(req.url ?? "/", "http://127.0.0.1");
+      if (url.pathname === "/") {
+        textResponse(res, 200, createHtml(), "text/html; charset=utf-8");
+        return;
+      }
+      if (url.pathname === "/api/snapshot") {
+        jsonResponse(res, 200, snapshot({ limit: url.searchParams.get("limit") }));
+        return;
+      }
+      if (url.pathname === "/events") {
+        res.writeHead(200, {
+          "Content-Type": "text/event-stream; charset=utf-8",
+          "Cache-Control": "no-store",
+          "Connection": "keep-alive",
+          "X-Accel-Buffering": "no"
+        });
+        const send = () => {
+          res.write(`event: snapshot
+data: ${JSON.stringify(snapshot())}
+
+`);
+        };
+        send();
+        const interval = setInterval(send, DEFAULT_REFRESH_MS);
+        req.on("close", () => clearInterval(interval));
+        return;
+      }
+      jsonResponse(res, 404, { error: "not_found" });
+    });
+    await new Promise((resolve, reject) => {
+      server.once("error", reject);
+      server.listen(0, "127.0.0.1", resolve);
+    });
+    const address = server.address();
+    const port = typeof address === "object" && address ? address.port : 0;
+    const entry = { server, url: `http://127.0.0.1:${port}/` };
+    instances.set(instanceId, entry);
+    log(`Diagnostics canvas server started for instance '${instanceId}'.`, "info", { url: entry.url });
+    return entry;
+  }
+  async function stopServer(instanceId) {
+    const entry = instances.get(instanceId);
+    if (!entry) {
+      return;
+    }
+    instances.delete(instanceId);
+    await new Promise((resolve) => entry.server.close(() => resolve()));
+    log(`Diagnostics canvas server stopped for instance '${instanceId}'.`);
+  }
+  return createCanvas({
+    id: TAP_DIAGNOSTICS_CANVAS_ID,
+    displayName: "Tap diagnostics",
+    description: "Live tap flight recorder for streams, emitters, provider gateway state, logs, and session events.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        limit: { type: "integer", minimum: 10, maximum: 300, description: "Maximum retained rows to show per diagnostics section." }
+      }
+    },
+    actions: [
+      {
+        name: "refresh_snapshot",
+        description: "Return a fresh summary of the tap diagnostics canvas data.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            limit: { type: "integer", minimum: 10, maximum: 300 }
+          }
+        },
+        handler: async ({ input }) => ({
+          ok: true,
+          summary: summarizeSnapshot(snapshot(input))
+        })
+      },
+      {
+        name: "export_snapshot",
+        description: "Return the current tap diagnostics snapshot as structured JSON.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            limit: { type: "integer", minimum: 10, maximum: 300 }
+          }
+        },
+        handler: async ({ input }) => snapshot(input)
+      }
+    ],
+    open: async (ctx) => {
+      let entry = instances.get(ctx.instanceId);
+      if (!entry) {
+        entry = await startServer(ctx.instanceId);
+      }
+      return {
+        title: "Tap diagnostics",
+        status: "live flight recorder",
+        url: entry.url
+      };
+    },
+    onClose: async (ctx) => {
+      await stopServer(ctx.instanceId);
+    }
+  });
+}
+
 // src/tap-runtime/runtime-factory.mjs
 var PROVIDER_SHUTDOWN_DEADLINE_MS = 1e4;
 var EMITTER_SHUTDOWN_WAIT_TIMEOUT_MS = 1e4;
@@ -10917,10 +12058,15 @@ function createCopilotChannelsRuntime(options = {}) {
     ...options.runtimeServiceOptions ?? {},
     cwd: options.cwd,
     session: options.session,
+    diagnostics: options.diagnostics,
     shutdownSession: () => handleSessionShutdown(activeSession)
   });
-  process.stderr.write(`[tap-runtime] init \u2014 cwd=${runtimeService.session.getBaseCwd()}
+  function logRuntime(message, options2 = {}) {
+    runtimeService.diagnostics?.log?.("runtime", message, options2);
+    process.stderr.write(`[tap-runtime] ${message}
 `);
+  }
+  logRuntime(`init \u2014 cwd=${runtimeService.session.getBaseCwd()}`);
   const tools = createTools({ tools: runtimeService.tools });
   const hooks = createHooks({ runtime: runtimeService.hooks });
   const tapToolsFn = () => tools;
@@ -10930,8 +12076,19 @@ function createCopilotChannelsRuntime(options = {}) {
     deliverPush: runtimeService.provider.deliverPush,
     log: runtimeService.provider.log
   });
-  process.stderr.write(`[tap-runtime] gateway created
-`);
+  logRuntime("gateway created");
+  function getDiagnosticSnapshot(options2 = {}) {
+    return runtimeService.diagnostics.snapshot(options2, {
+      gateway: typeof gateway.getDiagnosticState === "function" ? gateway.getDiagnosticState() : null,
+      tools: gateway.isRunning() ? gateway.getAllTools(tools) : tools
+    });
+  }
+  const canvases = [
+    createTapDiagnosticsCanvas({
+      getSnapshot: getDiagnosticSnapshot,
+      diagnostics: runtimeService.diagnostics
+    })
+  ];
   gateway.onToolsChanged(runtimeService.provider.replaceSessionTools);
   let cleanupShutdownListener = () => {
   };
@@ -10958,7 +12115,7 @@ function createCopilotChannelsRuntime(options = {}) {
         return;
       }
       handled = true;
-      process.stderr.write("[tap-runtime] session.shutdown received \u2014 stopping runtime\n");
+      logRuntime("session.shutdown received \u2014 stopping runtime");
       void handleSessionShutdown(session2).catch((error) => {
         logShutdownFailure(session2, error);
       });
@@ -11027,19 +12184,15 @@ function createCopilotChannelsRuntime(options = {}) {
       return;
     }
     try {
-      process.stderr.write(`[tap-runtime] starting gateway\u2026
-`);
+      logRuntime("starting gateway...");
       gateway.start();
-      process.stderr.write(`[tap-runtime] gateway started
-`);
+      logRuntime("gateway start requested");
     } catch (err) {
-      process.stderr.write(`[tap-runtime] gateway start failed: ${err?.message ?? err}
-`);
+      logRuntime(`gateway start request failed: ${err?.message ?? err}`, { level: "warning" });
     }
   }
   function attachSession(nextSession) {
-    process.stderr.write(`[tap-runtime] attachSession \u2014 id=${nextSession?.id ?? "(none)"}
-`);
+    logRuntime(`attachSession \u2014 id=${nextSession?.id ?? "(none)"}`);
     activeSession = nextSession ?? null;
     if (shutdownRecord?.settled) {
       shutdownRecord = null;
@@ -11052,18 +12205,22 @@ function createCopilotChannelsRuntime(options = {}) {
     attachSession,
     tools,
     hooks,
+    canvases,
     stopAllEmitters,
     stopAllEmittersAndWait,
     handleSessionShutdown,
     appendStreamMessage: runtimeService.session.appendStreamMessage,
     getTools: () => gateway.isRunning() ? gateway.getAllTools(tools) : tools,
+    getCanvases: () => canvases,
     DEFAULT_STREAM
   };
 }
 
 // src/extension.mjs
+var diagnostics = globalThis.__tapDiagnostics ??= createDiagnosticsStore();
 function tapLog(msg) {
   const ts = (/* @__PURE__ */ new Date()).toISOString();
+  diagnostics.log("extension", msg);
   process.stderr.write(`[tap ${ts}] ${msg}
 `);
 }
@@ -11071,7 +12228,8 @@ tapLog(`extension.mjs loading \u2014 pid=${process.pid} cwd=${process.cwd()} SES
 var isResume = Boolean(globalThis.__tapRuntime);
 tapLog(`runtime ${isResume ? "resuming (cached)" : "creating (fresh)"}`);
 var runtime = globalThis.__tapRuntime ??= createCopilotChannelsRuntime({
-  cwd: process.cwd()
+  cwd: process.cwd(),
+  diagnostics
 });
 tapLog("runtime ready");
 tapLog("calling joinSession\u2026");
@@ -11079,6 +12237,7 @@ var session;
 try {
   session = await joinSession({
     tools: runtime.getTools(),
+    canvases: runtime.getCanvases(),
     hooks: runtime.hooks
   });
   tapLog(`joinSession OK \u2014 session.id=${session.id ?? "(none)"}`);