copilot-tap-extension 2.0.8 → 2.0.9

package/dist/extension.mjs

@@ -4659,6 +4659,7 @@ function summarizeRuntimeState(state) {
   const model = state?.model?.ok ? state.model.value : null;
   const taskCount = state?.tasks?.ok ? state.tasks.value?.tasks?.length ?? 0 : null;
   const scheduleCount = state?.schedules?.ok ? state.schedules.value?.entries?.length ?? 0 : null;
+  const permissionCount = state?.permissions?.ok ? state.permissions.value?.items?.length ?? 0 : null;
   const canvasCount = state?.openCanvases?.ok ? state.openCanvases.value?.openCanvases?.length ?? 0 : null;
   return [
     `sessionId=${state?.sessionId ?? "(none)"}`,
@@ -4666,6 +4667,7 @@ function summarizeRuntimeState(state) {
     model ? `model=${model.modelId ?? "unknown"} reasoning=${model.reasoningEffort ?? "default"} context=${model.contextTier ?? "default"}` : null,
     taskCount !== null ? `tasks=${taskCount}` : null,
     scheduleCount !== null ? `schedules=${scheduleCount}` : null,
+    permissionCount !== null ? `pendingPermissions=${permissionCount}` : null,
     canvasCount !== null ? `openCanvases=${canvasCount}` : null,
     `elicitation=${state?.capabilities?.ui?.elicitation === true ? "available" : "unavailable"}`,
     `canvases=${state?.capabilities?.ui?.canvases === true ? "available" : "host-gated"}`
@@ -4714,6 +4716,64 @@ function createDiagnosticsTools(deps) {
         return summarizeRuntimeState(state);
       })
     });
+    if (typeof diagnostics2.setSessionMode === "function") {
+      tools.push({
+        name: "tap_set_session_mode",
+        description: "Guarded Copilot mode switch for tap workflows. Requires explicit confirmation text and is intended for interactive/plan/autopilot transitions only.",
+        parameters: {
+          type: "object",
+          properties: {
+            mode: {
+              type: "string",
+              enum: ["interactive", "plan", "autopilot"],
+              description: "Target Copilot session mode."
+            },
+            reason: {
+              type: "string",
+              description: "Why this mode switch is needed."
+            },
+            confirm: {
+              type: "string",
+              description: "Must be exactly 'set-session-mode' to confirm this user-visible mode change."
+            }
+          },
+          required: ["mode", "reason", "confirm"]
+        },
+        handler: wrapToolHandler("tap_set_session_mode", (args) => ({ mode: args.mode }), async (args) => {
+          if (args.confirm !== "set-session-mode") {
+            throw new Error("Refusing to change session mode without confirm='set-session-mode'.");
+          }
+          const nextMode = await diagnostics2.setSessionMode(args.mode);
+          return `Session mode set to ${nextMode}. reason=${args.reason}`;
+        })
+      });
+    }
+  }
+  if (typeof diagnostics2.queryRecords === "function") {
+    tools.push({
+      name: "tap_query_records",
+      description: "Reads structured tap records persisted in the session workspace, such as traces and stream-posts.",
+      parameters: {
+        type: "object",
+        properties: {
+          collection: {
+            type: "string",
+            description: "Record collection name, for example 'traces' or 'stream-posts'."
+          },
+          limit: {
+            type: "integer",
+            minimum: 1,
+            maximum: 500,
+            description: "Maximum recent records to return."
+          }
+        },
+        required: ["collection"]
+      },
+      handler: wrapToolHandler("tap_query_records", (args) => ({ collection: args.collection }), async (args) => {
+        const result = diagnostics2.queryRecords(args.collection, { limit: args.limit });
+        return JSON.stringify(result, null, 2);
+      })
+    });
   }
   return tools;
 }
@@ -6919,6 +6979,10 @@ function createProviderGateway(options = {}, adapters = {}) {
   };
 }
 
+// src/services/tap-runtime-service.mjs
+import fs4 from "node:fs";
+import path9 from "node:path";
+
 // src/session/listeners.mjs
 var SESSION_ACTIVITY_EVENTS = [
   "session.start",
@@ -8750,7 +8814,7 @@ function shouldPersistLoadedConfig(parsedConfig, normalizedConfig) {
   return !isDeepStrictEqual(parsedConfig, serializeConfigForComparison(normalizedConfig));
 }
 function createConfigStore(options = {}) {
-  const fs3 = options.fs ?? { existsSync: existsSync2, readFileSync: readFileSync2, writeFileSync: writeFileSync2 };
+  const fs5 = options.fs ?? { existsSync: existsSync2, readFileSync: readFileSync2, writeFileSync: writeFileSync2 };
   const state = {
     cwd: normalizeBaseCwd(options.cwd),
     filePath: null,
@@ -8778,7 +8842,7 @@ function createConfigStore(options = {}) {
         const exists = withConfigLoadPhase(
           "checking config path",
           "Unable to check whether the tap config file exists.",
-          () => fs3.existsSync(filePath),
+          () => fs5.existsSync(filePath),
           { filePath }
         );
         if (!exists) {
@@ -8787,7 +8851,7 @@ function createConfigStore(options = {}) {
         const rawConfig = withConfigLoadPhase(
           "reading config file",
           "Unable to read the tap config file.",
-          () => fs3.readFileSync(filePath, "utf8"),
+          () => fs5.readFileSync(filePath, "utf8"),
           { filePath }
         );
         const parsedConfig = withConfigLoadPhase(
@@ -8845,7 +8909,7 @@ function createConfigStore(options = {}) {
       state.filePath = defaultConfigPath(state.cwd);
     }
     const payload = serializeConfig(state.config, LATEST_CONFIG_VERSION);
-    fs3.writeFileSync(state.filePath, `${JSON.stringify(payload, null, 2)}
+    fs5.writeFileSync(state.filePath, `${JSON.stringify(payload, null, 2)}
 `, "utf8");
   }
   function findStreamIndex(name) {
@@ -9351,21 +9415,46 @@ function createDefaultProcessAdapter() {
 }
 function recordScheduledTrace(emitter, context, { startedAt, endedAt = nowIso(), runIndex, result = null, error = null, consumedRun = true } = {}) {
   try {
+    const start = startedAt ?? endedAt;
+    const status = result?.deferred ? "deferred" : result?.ok ? "success" : "failure";
     context.diagnostics?.trace?.({
-      traceId: `${stableTraceComponent(emitter.name)}-${Number(runIndex ?? emitter.runCount) || 0}-${Date.parse(startedAt ?? endedAt) || Date.now()}`,
+      traceId: `${stableTraceComponent(emitter.name)}-${Number(runIndex ?? emitter.runCount) || 0}-${Date.parse(start) || Date.now()}`,
       emitterId: emitter.name,
       emitterName: emitter.name,
       runIndex: Number(runIndex ?? emitter.runCount) || null,
       emitterType: emitter.emitterType,
       runSchedule: emitter.runSchedule,
-      startedAt: startedAt ?? endedAt,
+      startedAt: start,
       endedAt,
-      status: result?.deferred ? "deferred" : result?.ok ? "success" : "failure",
+      status,
       ok: result?.ok === true,
       consumedRun,
       lineCount: emitter.lineCount,
       droppedLineCount: emitter.droppedLineCount,
       error: error ?? result?.error ?? null,
+      spans: [
+        {
+          spanId: "emitter-run",
+          kind: "emitter.run",
+          name: emitter.name,
+          startedAt: start,
+          endedAt,
+          status
+        },
+        {
+          spanId: emitter.emitterType === EMITTER_TYPE.PROMPT ? "prompt-dispatch" : "command-process",
+          parentSpanId: "emitter-run",
+          kind: emitter.emitterType === EMITTER_TYPE.PROMPT ? "prompt.dispatch" : "command.process",
+          name: emitter.emitterType,
+          startedAt: start,
+          endedAt,
+          status,
+          metadata: {
+            stream: emitter.stream,
+            cwd: emitter.cwd ?? null
+          }
+        }
+      ],
       metadata: {
         every: emitter.every ?? null,
         everySchedule: emitter.everySchedule ?? null,
@@ -10558,9 +10647,21 @@ function createSessionPort(initialSession = null) {
       tasks: await read("tasks", () => rpc.tasks?.list?.()),
       schedules: await read("schedules", () => rpc.schedule?.list?.()),
       skills: await read("skills", () => rpc.skills?.list?.()),
+      permissions: await read("permissions", () => rpc.permissions?.pendingRequests?.()),
       openCanvases: await read("openCanvases", () => rpc.canvas?.listOpen?.())
     };
   }
+  async function setMode(mode) {
+    if (!session2) {
+      throw new LifecycleError("Session is not attached; cannot set mode.");
+    }
+    const modeApi = session2.rpc?.mode;
+    if (!modeApi || typeof modeApi.set !== "function") {
+      throw new LifecycleError("Session mode API is not available in this Copilot session.");
+    }
+    await modeApi.set({ mode });
+    return modeApi.get();
+  }
   function registerTools(tools) {
     if (!session2) return;
     try {
@@ -10598,6 +10699,7 @@ function createSessionPort(initialSession = null) {
     sendAndWait,
     openCanvas,
     getRuntimeState,
+    setMode,
     registerTools,
     reloadExtension
   };
@@ -10968,7 +11070,7 @@ function projectStream(stream) {
 
 // src/services/stream-service.mjs
 function createStreamService(deps) {
-  const { streams, configStore, sessionPort, persist } = deps;
+  const { streams, configStore, sessionPort, persist, recordStore = null } = deps;
   function requireStreamChannel(channel, operation) {
     return requireNormalizedName(channel, {
       label: "Stream channel",
@@ -11012,6 +11114,17 @@ function createStreamService(deps) {
         context: { channel: stream.name }
       });
     }
+    try {
+      recordStore?.appendRecord?.("stream-posts", {
+        channel: stream.name,
+        source,
+        text,
+        timestamp: appended.timestamp,
+        monitorName: appended.monitorName ?? null,
+        metadata: appended.metadata ?? null
+      });
+    } catch {
+    }
     void sessionPort.log(`Posted message to stream '${stream.name}'.`);
     return { stream: projectStream(stream) };
   }
@@ -11213,6 +11326,92 @@ function createGoalVerificationService({ getBaseCwd, getStreamHistory } = {}) {
   return { verifyGoalOutput, auditClaims };
 }
 
+// src/services/structured-record-store.mjs
+import fs3 from "node:fs";
+import path8 from "node:path";
+var DEFAULT_COLLECTION_LIMIT = 500;
+var COLLECTION_NAME_PATTERN = /^[a-z][a-z0-9-]{0,63}$/;
+function safeCollectionName(value) {
+  const name = String(value ?? "").trim().toLowerCase();
+  return COLLECTION_NAME_PATTERN.test(name) ? name : null;
+}
+function sessionWorkspacePath(sessionPort) {
+  const session2 = typeof sessionPort?.current === "function" ? sessionPort.current() : null;
+  return session2?.workspacePath ?? null;
+}
+function recordRoot(sessionPort) {
+  const workspace = sessionWorkspacePath(sessionPort);
+  if (!workspace) {
+    return null;
+  }
+  return path8.join(workspace, "files", "tap-records");
+}
+function collectionPath(root, collection) {
+  return path8.join(root, `${collection}.jsonl`);
+}
+function trimJsonlFile(filePath, maxRecords = DEFAULT_COLLECTION_LIMIT) {
+  try {
+    const lines = fs3.readFileSync(filePath, "utf8").split(/\r?\n/).filter(Boolean);
+    if (lines.length <= maxRecords) {
+      return;
+    }
+    fs3.writeFileSync(filePath, `${lines.slice(-maxRecords).join("\n")}
+`, "utf8");
+  } catch {
+  }
+}
+function createStructuredRecordStore({ sessionPort, maxRecords = DEFAULT_COLLECTION_LIMIT } = {}) {
+  function appendRecord(collectionInput, record) {
+    const collection = safeCollectionName(collectionInput);
+    const root = recordRoot(sessionPort);
+    if (!collection || !root) {
+      return { stored: false, reason: !collection ? "invalid-collection" : "no-session-workspace" };
+    }
+    try {
+      fs3.mkdirSync(root, { recursive: true });
+      const filePath = collectionPath(root, collection);
+      fs3.appendFileSync(filePath, `${JSON.stringify({ ...record, storedAt: (/* @__PURE__ */ new Date()).toISOString() })}
+`, "utf8");
+      trimJsonlFile(filePath, maxRecords);
+      return { stored: true, collection, path: filePath };
+    } catch (error) {
+      return { stored: false, collection, reason: error?.message ?? String(error ?? "unknown error") };
+    }
+  }
+  function listRecords(collectionInput, options = {}) {
+    const collection = safeCollectionName(collectionInput);
+    const root = recordRoot(sessionPort);
+    if (!collection || !root) {
+      return { collection: collectionInput, records: [], available: false };
+    }
+    const limit = Math.max(1, Math.min(500, Math.floor(Number(options.limit ?? 50) || 50)));
+    const filePath = collectionPath(root, collection);
+    try {
+      const records = fs3.readFileSync(filePath, "utf8").split(/\r?\n/).filter(Boolean).slice(-limit).map((line) => {
+        try {
+          return JSON.parse(line);
+        } catch {
+          return { parseError: true, raw: line };
+        }
+      });
+      return { collection, path: filePath, available: true, records };
+    } catch (error) {
+      if (error?.code === "ENOENT") {
+        return { collection, path: filePath, available: true, records: [] };
+      }
+      return { collection, path: filePath, available: false, records: [], error: error?.message ?? String(error) };
+    }
+  }
+  function getRoot() {
+    return recordRoot(sessionPort);
+  }
+  return {
+    appendRecord,
+    listRecords,
+    getRoot
+  };
+}
+
 // src/diagnostics/store.mjs
 var DEFAULT_MAX_LOGS = 300;
 var DEFAULT_MAX_EVENTS = 300;
@@ -11361,6 +11560,7 @@ function createDiagnosticsStore(options = {}) {
   let traceCount = 0;
   let cleanupSessionListener = () => {
   };
+  let recordSink = typeof options.recordSink === "function" ? options.recordSink : null;
   function recordLog(source, message, options2 = {}) {
     logCount += 1;
     return logs.append({
@@ -11397,7 +11597,7 @@ function createDiagnosticsStore(options = {}) {
     const startMs = Date.parse(startedAt);
     const endMs = Date.parse(endedAt);
     const durationMs = Number.isFinite(startMs) && Number.isFinite(endMs) ? Math.max(0, endMs - startMs) : null;
-    return traces.append({
+    const entry = {
       id: createId("trace", traceCount),
       traceId: String(trace.traceId ?? `trace-${traceCount.toString(36)}`),
       timestamp: endedAt,
@@ -11419,8 +11619,19 @@ function createDiagnosticsStore(options = {}) {
         maxDepth: 3,
         maxStringLength: 700,
         maxCollectionItems: 20
+      }),
+      spans: safeClone(Array.isArray(trace.spans) ? trace.spans : [], {
+        maxDepth: 4,
+        maxStringLength: 700,
+        maxCollectionItems: 30
       })
-    });
+    };
+    const appended = traces.append(entry);
+    try {
+      recordSink?.("traces", entry);
+    } catch {
+    }
+    return appended;
   }
   function recordSessionEvent(event) {
     sessionEventCount += 1;
@@ -11479,6 +11690,9 @@ function createDiagnosticsStore(options = {}) {
     log: recordLog,
     event: recordRuntimeEvent,
     trace: recordTrace,
+    setRecordSink: (nextSink) => {
+      recordSink = typeof nextSink === "function" ? nextSink : null;
+    },
     attachSession,
     detachSession,
     snapshot
@@ -11506,6 +11720,33 @@ function projectToolForDiagnostics(tool) {
     overridesBuiltInTool: tool.overridesBuiltInTool === true
   };
 }
+function collectEvalSummaries(baseCwd, limit = 20) {
+  const root = path9.join(baseCwd, "evals", "results");
+  const summaries = [];
+  function walk(dir) {
+    let entries = [];
+    try {
+      entries = fs4.readdirSync(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      const fullPath = path9.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        walk(fullPath);
+      } else if (entry.name === "summary.json") {
+        try {
+          const stat = fs4.statSync(fullPath);
+          const parsed = JSON.parse(fs4.readFileSync(fullPath, "utf8"));
+          summaries.push({ path: path9.relative(baseCwd, fullPath), modifiedAt: stat.mtime.toISOString(), summary: parsed });
+        } catch {
+        }
+      }
+    }
+  }
+  walk(root);
+  return summaries.sort((left, right) => new Date(right.modifiedAt) - new Date(left.modifiedAt)).slice(0, limit);
+}
 function createTapRuntimeService(options = {}) {
   const diagnosticsStore = options.diagnostics ?? createDiagnosticsStore();
   const {
@@ -11522,11 +11763,14 @@ function createTapRuntimeService(options = {}) {
     ...options,
     diagnostics: diagnosticsStore
   });
+  const recordStore = createStructuredRecordStore({ sessionPort });
+  diagnosticsStore.setRecordSink?.((collection, record) => recordStore.appendRecord(collection, record));
   const streamService = createStreamService({
     streams,
     configStore,
     sessionPort,
-    persist
+    persist,
+    recordStore
   });
   const emitterService = createEmitterService({
     streams,
@@ -11662,8 +11906,16 @@ function createTapRuntimeService(options = {}) {
       void sessionPort.reloadExtension();
     }
   };
-  function getDiagnosticsSnapshot(options2 = {}, extra = {}) {
+  async function getDiagnosticsSnapshot(options2 = {}, extra = {}) {
     const allTools = Array.isArray(extra.tools) ? extra.tools.map(projectToolForDiagnostics) : [];
+    let sessionRuntime = null;
+    try {
+      sessionRuntime = await sessionPort.getRuntimeState();
+    } catch (error) {
+      sessionRuntime = {
+        error: error?.message ?? String(error ?? "unknown error")
+      };
+    }
     return {
       generatedAt: nowIso(),
       session: getSessionInfo(),
@@ -11677,7 +11929,9 @@ function createTapRuntimeService(options = {}) {
       emitters: emitterCapabilities.listEmitters(),
       gateway: extra.gateway ?? null,
       tools: allTools,
+      evals: collectEvalSummaries(sessionContext.getBaseCwd(), options2.evalLimit ?? 20),
       notifications: typeof notifications.snapshot === "function" ? notifications.snapshot({ limit: options2.notificationLimit ?? 20 }) : null,
+      sessionRuntime,
       diagnostics: diagnosticsStore.snapshot(options2)
     };
   }
@@ -11697,6 +11951,9 @@ function createTapRuntimeService(options = {}) {
       });
     },
     getSessionRuntimeState: () => sessionPort.getRuntimeState(),
+    setSessionMode: (mode) => sessionPort.setMode(mode),
+    queryRecords: (collection, options2 = {}) => recordStore.listRecords(collection, options2),
+    getRecordRoot: () => recordStore.getRoot(),
     attachSession: diagnosticsStore.attachSession,
     detachSession: diagnosticsStore.detachSession
   };
@@ -12004,7 +12261,7 @@ function createHtml() {
       overflow: auto;
     }
 
-    .stream-grid, .emitter-grid, .provider-grid, .trace-grid {
+    .stream-grid, .emitter-grid, .provider-grid, .trace-grid, .session-grid {
       display: grid;
       gap: 12px;
     }
@@ -12186,6 +12443,26 @@ function createHtml() {
         </div>
       </section>
 
+      <section class="panel">
+        <div class="panel-head">
+          <h2>Session control</h2>
+          <small id="session-state">unknown</small>
+        </div>
+        <div class="panel-body">
+          <div class="session-grid" id="session-control"></div>
+        </div>
+      </section>
+
+      <section class="panel">
+        <div class="panel-head">
+          <h2>Eval gate</h2>
+          <small id="eval-count">0 summaries</small>
+        </div>
+        <div class="panel-body">
+          <div class="session-grid" id="evals"></div>
+        </div>
+      </section>
+
       <section class="panel timeline-panel">
         <div class="panel-head">
           <h2>Evidence timeline</h2>
@@ -12223,6 +12500,8 @@ function createHtml() {
       const providers = snapshot.gateway?.providers?.length ?? 0;
       const queue = snapshot.notifications?.queueSize ?? 0;
       const traces = snapshot.diagnostics?.stats?.traces?.retained ?? 0;
+      const tasks = snapshot.sessionRuntime?.tasks?.ok ? (snapshot.sessionRuntime.tasks.value?.tasks?.length ?? 0) : 0;
+      const evals = snapshot.evals?.length ?? 0;
       const sessionEvents = snapshot.diagnostics?.stats?.sessionEvents?.retained ?? 0;
       el("metrics").innerHTML = [
         metric("streams", streams),
@@ -12230,6 +12509,8 @@ function createHtml() {
         metric("providers", providers),
         metric("queued injections", queue),
         metric("traces", traces),
+        metric("tasks", tasks),
+        metric("eval summaries", evals),
         metric("configured emitters", configured),
         metric("session events", sessionEvents)
       ].join("");
@@ -12269,6 +12550,28 @@ function createHtml() {
       el("providers").innerHTML = gatewayRecord + rows;
     }
 
+    function extractMarkedJson(text, marker) {
+      const raw = String(text ?? "");
+      const start = "=== BEGIN_" + marker + " ===";
+      const end = "=== END_" + marker + " ===";
+      const startIndex = raw.indexOf(start);
+      const endIndex = raw.indexOf(end);
+      if (startIndex < 0 || endIndex < 0 || endIndex <= startIndex) return null;
+      const body = raw.slice(startIndex + start.length, endIndex).trim();
+      try { return JSON.parse(body); } catch { return null; }
+    }
+
+    function collectReviewRecords(snapshot) {
+      const records = [];
+      for (const stream of snapshot.streams ?? []) {
+        for (const entry of stream.entries ?? []) {
+          const parsed = extractMarkedJson(entry.text, "REVIEW_RECORD");
+          if (parsed) records.push({ stream: stream.name, timestamp: entry.timestamp, ...parsed });
+        }
+      }
+      return records.sort((a, b) => new Date(b.timestamp) - new Date(a.timestamp));
+    }
+
     function renderTraces(snapshot) {
       const traces = snapshot.diagnostics?.traces ?? [];
       const goalStreams = (snapshot.streams ?? []).filter((stream) => String(stream.name ?? "").startsWith("goal-"));
@@ -12281,7 +12584,36 @@ function createHtml() {
         const latest = (stream.entries ?? []).slice(-2).reverse().map((entry) => '<div class="entry"><span class="meta">' + escapeHtml(timeOnly(entry.timestamp)) + '</span>\\n' + escapeHtml(entry.text) + '</div>').join("");
         return '<div class="record"><strong>' + escapeHtml(stream.name) + ' <span class="badge info">goal stream</span></strong><div class="meta">' + escapeHtml(stream.entries?.length ?? 0) + ' retained entries</div>' + (latest || '<div class="entry">No goal ledger entries retained.</div>') + '</div>';
       }).join("");
-      el("traces").innerHTML = (traceRows || '<div class="empty">No emitter-run traces retained yet.</div>') + (goalRows ? '<div class="panel-head" style="margin:14px -14px 12px"><h2>Goal ledgers</h2><small>' + goalStreams.length + ' streams</small></div>' + goalRows : "");
+      const reviewRecords = collectReviewRecords(snapshot).slice(0, 8).map((record) => '<div class="record"><strong>' + escapeHtml(record.stream) + ' <span class="badge info">' + escapeHtml(record.issue_type ?? "review") + '</span></strong><div class="meta">entries=' + escapeHtml(record.entries_examined ?? "?") + ' | reviewed=' + escapeHtml(timeOnly(record.reviewed_at ?? record.timestamp)) + '</div><div class="details">' + escapeHtml(compactJson({ patterns_changed: record.patterns_changed ?? [], remaining_noise_delta: record.remaining_noise_delta ?? [] })) + '</div></div>').join("");
+      el("traces").innerHTML = (traceRows || '<div class="empty">No emitter-run traces retained yet.</div>') + (goalRows ? '<div class="panel-head" style="margin:14px -14px 12px"><h2>Goal ledgers</h2><small>' + goalStreams.length + ' streams</small></div>' + goalRows : "") + (reviewRecords ? '<div class="panel-head" style="margin:14px -14px 12px"><h2>Monitor reviews</h2><small>' + collectReviewRecords(snapshot).length + ' records</small></div>' + reviewRecords : "");
+    }
+
+    function renderSessionControl(snapshot) {
+      const runtime = snapshot.sessionRuntime ?? {};
+      const mode = runtime.mode?.ok ? runtime.mode.value : "unknown";
+      const model = runtime.model?.ok ? runtime.model.value : null;
+      const tasks = runtime.tasks?.ok ? (runtime.tasks.value?.tasks ?? []) : [];
+      const schedules = runtime.schedules?.ok ? (runtime.schedules.value?.entries ?? []) : [];
+      el("session-state").textContent = String(mode);
+      const stateRecord = '<div class="record"><strong>session <span class="badge info">' + escapeHtml(mode) + '</span></strong><div class="meta">model=' + escapeHtml(model?.modelId ?? "unknown") + ' | reasoning=' + escapeHtml(model?.reasoningEffort ?? "default") + ' | schedules=' + escapeHtml(schedules.length) + '</div></div>';
+      const taskRows = tasks.slice(0, 10).map((task) => '<div class="record"><strong>' + escapeHtml(task.description ?? task.id ?? "task") + ' <span class="badge ' + escapeHtml(task.status ?? "info") + '">' + escapeHtml(task.status ?? "?") + '</span></strong><div class="meta">' + escapeHtml(task.type ?? "task") + ' | id=' + escapeHtml(task.id ?? "?") + ' | mode=' + escapeHtml(task.executionMode ?? "?") + '</div></div>').join("");
+      el("session-control").innerHTML = stateRecord + (taskRows || '<div class="empty">No native Copilot tasks are currently tracked.</div>');
+    }
+
+    function renderEvals(snapshot) {
+      const evals = snapshot.evals ?? [];
+      el("eval-count").textContent = evals.length + " summaries";
+      if (evals.length === 0) {
+        el("evals").innerHTML = '<div class="empty">No eval summaries found under evals/results.</div>';
+        return;
+      }
+      el("evals").innerHTML = evals.slice(0, 12).map((item) => {
+        const summary = item.summary ?? {};
+        const caseId = summary.caseId ?? summary.mode ?? "run";
+        const verdict = summary.verdict?.verdict ?? (Array.isArray(summary) ? "batch" : "unknown");
+        const tone = verdict === "pass" || summary.extensionToolAvailable === true ? "ready" : verdict === "fail" ? "error" : "info";
+        return '<div class="record"><strong>' + escapeHtml(caseId) + ' <span class="badge ' + tone + '">' + escapeHtml(verdict) + '</span></strong><div class="meta">' + escapeHtml(item.path) + ' | ' + escapeHtml(timeOnly(item.modifiedAt)) + '</div><div class="details">' + escapeHtml(summary.verdict?.summary ?? summary.detail ?? "") + '</div></div>';
+      }).join("");
     }
 
     function collectTimeline(snapshot) {
@@ -12327,6 +12659,8 @@ function createHtml() {
       renderStreams(snapshot);
       renderProviders(snapshot);
       renderTraces(snapshot);
+      renderSessionControl(snapshot);
+      renderEvals(snapshot);
       renderTimeline(snapshot);
     }
 
@@ -12375,7 +12709,7 @@ function createHtml() {
 }
 function createTapDiagnosticsCanvas({ getSnapshot, diagnostics: diagnostics2 } = {}) {
   const instances = /* @__PURE__ */ new Map();
-  function snapshot(options = {}) {
+  async 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 = {}) {
@@ -12389,7 +12723,7 @@ function createTapDiagnosticsCanvas({ getSnapshot, diagnostics: diagnostics2 } =
         return;
       }
       if (url.pathname === "/api/snapshot") {
-        jsonResponse(res, 200, snapshot({ limit: url.searchParams.get("limit") }));
+        void snapshot({ limit: url.searchParams.get("limit") }).then((data) => jsonResponse(res, 200, data));
         return;
       }
       if (url.pathname === "/events") {
@@ -12400,10 +12734,17 @@ function createTapDiagnosticsCanvas({ getSnapshot, diagnostics: diagnostics2 } =
           "X-Accel-Buffering": "no"
         });
         const send = () => {
-          res.write(`event: snapshot
-data: ${JSON.stringify(snapshot())}
+          void snapshot().then((data) => {
+            res.write(`event: snapshot
+data: ${JSON.stringify(data)}
+
+`);
+          }).catch((error) => {
+            res.write(`event: snapshot
+data: ${JSON.stringify({ error: error?.message ?? String(error) })}
 
 `);
+          });
         };
         send();
         const interval = setInterval(send, DEFAULT_REFRESH_MS);
@@ -12454,7 +12795,7 @@ data: ${JSON.stringify(snapshot())}
         },
         handler: async ({ input }) => ({
           ok: true,
-          summary: summarizeSnapshot(snapshot(input))
+          summary: summarizeSnapshot(await snapshot(input))
         })
       },
       {
@@ -12530,7 +12871,7 @@ function createCopilotChannelsRuntime(options = {}) {
     log: runtimeService.provider.log
   });
   logRuntime("gateway created");
-  function getDiagnosticSnapshot(options2 = {}) {
+  async function getDiagnosticSnapshot(options2 = {}) {
     return runtimeService.diagnostics.snapshot(options2, {
       gateway: typeof gateway.getDiagnosticState === "function" ? gateway.getDiagnosticState() : null,
       tools: gateway.isRunning() ? gateway.getAllTools(tools) : tools

package/dist/version.json

@@ -1,3 +1,3 @@
 {
-  "version": "2.0.8"
+  "version": "2.0.9"
 }

package/docs/adr/0001-persistent-config-default-ownership.md

@@ -0,0 +1,33 @@
+# ADR 0001: Persistent config emitters default to user ownership
+
+## Status
+
+Accepted
+
+## Context
+
+No `docs/adr/0000-template.md` existed when this ADR was written, so this file uses the standard ADR sections.
+
+The project documentation treats on-disk emitter definitions as persistent workflows and recommends `userOwned` ownership for persistent, recurring, or policy-bearing emitters. Existing normalization code defaulted missing persisted emitter ownership and lifespan to `modelOwned` and `temporary`, even though configured emitters are restored from disk and listed as persistent definitions.
+
+That mismatch can weaken the protection model for manually edited config files: an emitter with no explicit ownership may be treated as model-owned during normalization even though it came from persistent user config.
+
+## Decision
+
+Persisted/on-disk emitter definitions default to:
+
+- `ownership: "userOwned"`
+- `lifespan: "persistent"`
+
+Normalization still honors explicit compatibility fields:
+
+- `ownership` or legacy `managedBy`, including explicit `modelOwned`
+- `lifespan` or legacy `scope`, including explicit `temporary`
+
+Runtime-created temporary/model-owned emitters keep their explicit normalized fields when serialized, so this default only applies when persisted config omits ownership/lifespan signals.
+
+## Consequences
+
+- Manually authored config aligns with the documented safety default for persistent workflows.
+- Legacy config with explicit `modelOwned` or `temporary` remains compatible.
+- Future changes that alter config ownership/lifespan defaults should update or supersede this ADR.