copilot-tap-extension 2.0.7 → 2.0.9

package/dist/extension.mjs

@@ -4654,12 +4654,31 @@ function renderCanvasOpenResult(result) {
     result?.availability ? `availability=${result.availability}` : null
   ].filter(Boolean).join("\n");
 }
+function summarizeRuntimeState(state) {
+  const mode = state?.mode?.ok ? state.mode.value : `unavailable (${state?.mode?.error ?? "unknown"})`;
+  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)"}`,
+    `mode=${typeof mode === "string" ? mode : JSON.stringify(mode)}`,
+    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"}`
+  ].filter(Boolean).join("\n");
+}
 function createDiagnosticsTools(deps) {
   const diagnostics2 = deps.diagnostics ?? deps.runtime;
   if (!diagnostics2 || typeof diagnostics2.openCanvas !== "function") {
     return [];
   }
-  return [
+  const tools = [
     {
       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.",
@@ -4684,6 +4703,163 @@ function createDiagnosticsTools(deps) {
       })
     }
   ];
+  if (typeof diagnostics2.getSessionRuntimeState === "function") {
+    tools.push({
+      name: "tap_get_session_state",
+      description: "Reads current Copilot session runtime state for mode-aware tap workflows: mode, model, tasks, schedules, open canvases, and UI capabilities. This is read-only.",
+      parameters: {
+        type: "object",
+        properties: {}
+      },
+      handler: wrapToolHandler("tap_get_session_state", {}, async () => {
+        const state = await diagnostics2.getSessionRuntimeState();
+        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;
+}
+
+// src/tools/goal-verification.mjs
+function renderVerification(prefix, result) {
+  const lines = [
+    `${prefix}: ${result.passed ? "passed" : "failed"}`,
+    ...result.results.map((item) => {
+      const label = item.description ?? item.claim ?? item.path ?? item.channel ?? item.label ?? `check ${item.index}`;
+      return `- ${item.passed ? "PASS" : "FAIL"} ${label}${item.error ? ` \u2014 ${item.error}` : ""}`;
+    })
+  ];
+  return lines.join("\n");
+}
+var CHECK_SCHEMA = {
+  type: "object",
+  properties: {
+    type: {
+      type: "string",
+      description: "Check type: 'file', 'stream', or 'command_evidence'."
+    },
+    description: { type: "string" },
+    path: { type: "string", description: "Workspace-relative file path for file checks." },
+    nonEmpty: { type: "boolean", description: "For file checks, require a non-empty file." },
+    channel: { type: "string", description: "EventStream name for stream checks." },
+    limit: { type: "integer", description: "Recent stream entries to inspect." },
+    minEntries: { type: "integer", description: "Minimum retained entries required." },
+    contains: { type: "string", description: "Literal text that must be present." },
+    pattern: { type: "string", description: "Regex pattern that must match." },
+    label: { type: "string", description: "Human label for command evidence." },
+    exitCode: { type: "integer", description: "Exit code from an already-run command." },
+    success: { type: "boolean", description: "Whether already-run command evidence succeeded." }
+  }
+};
+function createGoalVerificationTools(deps) {
+  const verification = deps.verification ?? deps.runtime;
+  if (!verification || typeof verification.verifyGoalOutput !== "function") {
+    return [];
+  }
+  return [
+    {
+      name: "tap_verify_goal_output",
+      description: "Verifies goal completion evidence without executing commands. Checks workspace files, EventStream history, or caller-supplied command evidence.",
+      parameters: {
+        type: "object",
+        properties: {
+          checks: {
+            type: "array",
+            items: CHECK_SCHEMA,
+            description: "Evidence checks to perform. Command checks must use already-run command evidence; this tool does not execute shell commands."
+          }
+        },
+        required: ["checks"]
+      },
+      handler: wrapToolHandler("tap_verify_goal_output", {}, async (args) => {
+        const result = verification.verifyGoalOutput(args ?? {});
+        return renderVerification("Goal output verification", result);
+      })
+    },
+    {
+      name: "tap_audit_claims",
+      description: "Audits machine-readable goal claims against file, stream, or command-evidence surfaces before marking a goal complete.",
+      parameters: {
+        type: "object",
+        properties: {
+          claims: {
+            type: "array",
+            items: {
+              type: "object",
+              properties: {
+                claim: { type: "string" },
+                evidence: CHECK_SCHEMA
+              },
+              required: ["claim", "evidence"]
+            }
+          }
+        },
+        required: ["claims"]
+      },
+      handler: wrapToolHandler("tap_audit_claims", {}, async (args) => {
+        const result = verification.auditClaims(args ?? {});
+        return renderVerification("Claim audit", result);
+      })
+    }
+  ];
 }
 
 // src/tools/index.mjs
@@ -4692,10 +4868,12 @@ function createTools(deps) {
   const streams = deps?.streams ?? source.streams ?? deps?.runtime;
   const emitters = deps?.emitters ?? source.emitters ?? deps?.runtime;
   const diagnostics2 = deps?.diagnostics ?? source.diagnostics ?? deps?.runtime;
+  const verification = deps?.verification ?? source.verification ?? deps?.runtime;
   return [
     ...createStreamTools({ streams }),
     ...createEmitterTools({ emitters }),
-    ...createDiagnosticsTools({ diagnostics: diagnostics2 })
+    ...createDiagnosticsTools({ diagnostics: diagnostics2 }),
+    ...createGoalVerificationTools({ verification })
   ];
 }
 
@@ -6801,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",
@@ -8632,7 +8814,7 @@ function shouldPersistLoadedConfig(parsedConfig, normalizedConfig) {
   return !isDeepStrictEqual(parsedConfig, serializeConfigForComparison(normalizedConfig));
 }
 function createConfigStore(options = {}) {
-  const fs2 = 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,
@@ -8660,7 +8842,7 @@ function createConfigStore(options = {}) {
         const exists = withConfigLoadPhase(
           "checking config path",
           "Unable to check whether the tap config file exists.",
-          () => fs2.existsSync(filePath),
+          () => fs5.existsSync(filePath),
           { filePath }
         );
         if (!exists) {
@@ -8669,7 +8851,7 @@ function createConfigStore(options = {}) {
         const rawConfig = withConfigLoadPhase(
           "reading config file",
           "Unable to read the tap config file.",
-          () => fs2.readFileSync(filePath, "utf8"),
+          () => fs5.readFileSync(filePath, "utf8"),
           { filePath }
         );
         const parsedConfig = withConfigLoadPhase(
@@ -8727,7 +8909,7 @@ function createConfigStore(options = {}) {
       state.filePath = defaultConfigPath(state.cwd);
     }
     const payload = serializeConfig(state.config, LATEST_CONFIG_VERSION);
-    fs2.writeFileSync(state.filePath, `${JSON.stringify(payload, null, 2)}
+    fs5.writeFileSync(state.filePath, `${JSON.stringify(payload, null, 2)}
 `, "utf8");
   }
   function findStreamIndex(name) {
@@ -9231,9 +9413,64 @@ function createDefaultProcessAdapter() {
     readLines
   };
 }
+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(start) || Date.now()}`,
+      emitterId: emitter.name,
+      emitterName: emitter.name,
+      runIndex: Number(runIndex ?? emitter.runCount) || null,
+      emitterType: emitter.emitterType,
+      runSchedule: emitter.runSchedule,
+      startedAt: start,
+      endedAt,
+      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,
+        maxRuns: emitter.maxRuns ?? null,
+        stopRequested: emitter.stopRequested === true
+      }
+    });
+  } catch {
+  }
+}
 var SESSION_ATTACH_RETRY_MS = 100;
 var DEFAULT_STOP_WAIT_TIMEOUT_MS = 1e4;
 var STOP_WAIT_POLL_MS = 50;
+function stableTraceComponent(value) {
+  return String(value ?? "unknown").trim().toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "") || "unknown";
+}
 function errorMessage(error) {
   return error?.message ?? String(error ?? "unknown error");
 }
@@ -9569,6 +9806,8 @@ async function runScheduledIteration(emitter, context) {
   emitter.status = EMITTER_STATUS.RUNNING;
   emitter.runCount += 1;
   emitter.lastRunAt = nowIso();
+  const traceStartedAt = emitter.lastRunAt;
+  const traceRunIndex = emitter.runCount;
   let result;
   try {
     result = emitter.emitterType === EMITTER_TYPE.PROMPT ? await runPromptIteration(emitter, context) : await runCommandLoopIteration(emitter, context);
@@ -9586,6 +9825,12 @@ async function runScheduledIteration(emitter, context) {
     if (result?.consumeRun === false) {
       emitter.runCount = previousRunCount;
       emitter.lastRunAt = previousLastRunAt;
+      recordScheduledTrace(emitter, context, {
+        startedAt: traceStartedAt,
+        runIndex: traceRunIndex,
+        result,
+        consumedRun: false
+      });
       if (emitter.stopRequested) {
         applyLifecycleTransition(emitter, {
           type: LIFECYCLE_EVENT.ITERATION_RESULT,
@@ -9604,7 +9849,20 @@ async function runScheduledIteration(emitter, context) {
       result,
       timestamp: nowIso()
     }, context);
+    recordScheduledTrace(emitter, context, {
+      startedAt: traceStartedAt,
+      runIndex: traceRunIndex,
+      result,
+      consumedRun: true
+    });
   } catch (error) {
+    recordScheduledTrace(emitter, context, {
+      startedAt: traceStartedAt,
+      runIndex: traceRunIndex,
+      result: { ok: false, error: errorMessage(error) },
+      error: errorMessage(error),
+      consumedRun: true
+    });
     recordScheduledTransitionFailure(emitter, error, context);
   } finally {
     emitter.inFlight = false;
@@ -9618,7 +9876,8 @@ function createLifecycle({
   sessionPort,
   timerAdapter = createDefaultTimerAdapter(),
   processAdapter = createDefaultProcessAdapter(),
-  loggerAdapter = createDefaultLoggerAdapter(sessionPort)
+  loggerAdapter = createDefaultLoggerAdapter(sessionPort),
+  diagnostics: diagnostics2 = null
 }) {
   function start(emitter) {
     if (emitter.runSchedule === RUN_SCHEDULE.CONTINUOUS) {
@@ -9628,6 +9887,7 @@ function createLifecycle({
     contextStartScheduled(emitter);
   }
   function contextStartScheduled(emitter) {
+    const context = { lineRouter, timerAdapter, processAdapter, loggerAdapter, sessionPort, diagnostics: diagnostics2 };
     const scheduleLabel2 = emitter.runSchedule === RUN_SCHEDULE.TIMED ? emitter.everySchedule ? `backoff [${emitter.everySchedule.join(", ")}]` : `every ${emitter.every}` : emitter.runSchedule === RUN_SCHEDULE.IDLE ? "when idle" : RUN_SCHEDULE.ONE_TIME;
     lineRouter.appendSystemMessage(
       emitter,
@@ -9640,17 +9900,17 @@ function createLifecycle({
     );
     if (emitter.runSchedule === RUN_SCHEDULE.IDLE) {
       if (sessionPort.isIdle()) {
-        scheduleIteration(emitter, { lineRouter, timerAdapter, processAdapter, loggerAdapter, sessionPort }, IDLE_PROMPT_DELAY_MS);
+        scheduleIteration(emitter, context, IDLE_PROMPT_DELAY_MS);
       }
       return;
     }
-    scheduleIteration(emitter, { lineRouter, timerAdapter, processAdapter, loggerAdapter, sessionPort }, 0);
+    scheduleIteration(emitter, context, 0);
   }
   async function stop(emitter) {
     applyLifecycleTransition(
       emitter,
       { type: LIFECYCLE_EVENT.STOP, timestamp: nowIso() },
-      { lineRouter, timerAdapter, processAdapter, loggerAdapter, sessionPort }
+      { lineRouter, timerAdapter, processAdapter, loggerAdapter, sessionPort, diagnostics: diagnostics2 }
     );
     if (isTerminalEmitterStatus(emitter.status)) {
       return;
@@ -9826,14 +10086,14 @@ function restorePersistentStreamConfigBestEffort(configStore, snapshot) {
 
 // src/emitter/supervisor.mjs
 var ROLLBACK_STOP_WAIT_TIMEOUT_MS = 1e4;
-function createEmitterSupervisor({ streams, configStore, notifications, sessionPort, emitterWorkspace, persist, lifecycle: lifecycleOverride }) {
+function createEmitterSupervisor({ streams, configStore, notifications, sessionPort, emitterWorkspace, persist, lifecycle: lifecycleOverride, diagnostics: diagnostics2 = null }) {
   const emitters = /* @__PURE__ */ new Map();
   const lineRouter = createLineRouter({
     streams,
     notifications,
     surface: (message, options) => sessionPort.log(message, options)
   });
-  const lifecycle = lifecycleOverride ?? createLifecycle({ lineRouter, sessionPort });
+  const lifecycle = lifecycleOverride ?? createLifecycle({ lineRouter, sessionPort, diagnostics: diagnostics2 });
   function hasExplicitPolicyValue(value) {
     return value !== void 0 && value !== null;
   }
@@ -10367,6 +10627,41 @@ function createSessionPort(initialSession = null) {
     }
     return canvasApi.open(params);
   }
+  async function getRuntimeState() {
+    if (!session2) {
+      throw new LifecycleError("Session is not attached; cannot inspect runtime state.");
+    }
+    const rpc = session2.rpc ?? {};
+    const read = async (label, fn) => {
+      try {
+        return { ok: true, value: await fn() };
+      } catch (error) {
+        return { ok: false, error: error?.message ?? String(error ?? "unknown error") };
+      }
+    };
+    return {
+      sessionId: session2.sessionId ?? null,
+      capabilities: session2.capabilities ?? null,
+      mode: await read("mode", () => rpc.mode?.get?.()),
+      model: await read("model", () => rpc.model?.getCurrent?.()),
+      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 {
@@ -10403,6 +10698,8 @@ function createSessionPort(initialSession = null) {
     send,
     sendAndWait,
     openCanvas,
+    getRuntimeState,
+    setMode,
     registerTools,
     reloadExtension
   };
@@ -10683,7 +10980,8 @@ function createRuntimeSubsystems(options = {}) {
     notifications,
     sessionPort,
     emitterWorkspace,
-    persist
+    persist,
+    diagnostics: options.diagnostics
   });
   return {
     sessionContext,
@@ -10772,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",
@@ -10816,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) };
   }
@@ -10858,10 +11167,256 @@ function createStreamService(deps) {
   };
 }
 
+// src/services/goal-verification-service.mjs
+import fs2 from "node:fs";
+import path7 from "node:path";
+function normalizeText(value) {
+  return String(value ?? "").trim();
+}
+function safeRegex(pattern) {
+  try {
+    return new RegExp(String(pattern));
+  } catch {
+    return null;
+  }
+}
+function resolveWithinBase(baseCwd, requestedPath) {
+  const raw = normalizeText(requestedPath);
+  if (!raw) {
+    return { ok: false, error: "path is required" };
+  }
+  const base = path7.resolve(baseCwd || process.cwd());
+  const resolved = path7.isAbsolute(raw) ? path7.resolve(raw) : path7.resolve(base, raw);
+  const relative = path7.relative(base, resolved);
+  if (relative.startsWith("..") || path7.isAbsolute(relative)) {
+    return { ok: false, error: `path '${raw}' is outside the session workspace` };
+  }
+  return { ok: true, path: resolved, displayPath: relative || "." };
+}
+function textMatches(text, check = {}) {
+  const contains = normalizeText(check.contains);
+  if (contains && !String(text).includes(contains)) {
+    return { ok: false, error: `expected text to contain '${contains}'` };
+  }
+  const pattern = normalizeText(check.pattern);
+  if (pattern) {
+    const regex = safeRegex(pattern);
+    if (!regex) {
+      return { ok: false, error: `invalid regex '${pattern}'` };
+    }
+    if (!regex.test(String(text))) {
+      return { ok: false, error: `expected text to match /${pattern}/` };
+    }
+  }
+  return { ok: true };
+}
+function verifyFile(check, { baseCwd }) {
+  const resolved = resolveWithinBase(baseCwd, check.path);
+  if (!resolved.ok) {
+    return { ...resolved, passed: false };
+  }
+  if (!fs2.existsSync(resolved.path)) {
+    return { passed: false, path: resolved.displayPath, error: "file does not exist" };
+  }
+  const stat = fs2.statSync(resolved.path);
+  if (!stat.isFile()) {
+    return { passed: false, path: resolved.displayPath, error: "path is not a file" };
+  }
+  if (check.nonEmpty === true && stat.size === 0) {
+    return { passed: false, path: resolved.displayPath, error: "file is empty" };
+  }
+  if (check.contains || check.pattern) {
+    const content = fs2.readFileSync(resolved.path, "utf8");
+    const match = textMatches(content, check);
+    if (!match.ok) {
+      return { passed: false, path: resolved.displayPath, error: match.error };
+    }
+  }
+  return { passed: true, path: resolved.displayPath, size: stat.size };
+}
+function verifyStream(check, { getStreamHistory }) {
+  const channel = normalizeText(check.channel);
+  if (!channel) {
+    return { passed: false, error: "channel is required" };
+  }
+  let stream;
+  try {
+    stream = getStreamHistory(channel, check.limit)?.stream;
+  } catch (error) {
+    return { passed: false, channel, error: error?.message ?? String(error) };
+  }
+  const entries = Array.isArray(stream?.entries) ? stream.entries : [];
+  if (check.minEntries !== void 0 && entries.length < Number(check.minEntries)) {
+    return { passed: false, channel, entries: entries.length, error: `expected at least ${check.minEntries} entries` };
+  }
+  const text = entries.map((entry) => entry.text ?? "").join("\n");
+  const match = textMatches(text, check);
+  if (!match.ok) {
+    return { passed: false, channel, entries: entries.length, error: match.error };
+  }
+  return { passed: true, channel, entries: entries.length };
+}
+function verifyCommandEvidence(check) {
+  const label = normalizeText(check.label ?? check.command ?? "command evidence");
+  if (check.exitCode === void 0 && check.success !== true) {
+    return { passed: false, label, error: "provide exitCode or success=true from an already-run command" };
+  }
+  const passed = check.success === true || Number(check.exitCode) === 0;
+  return {
+    passed,
+    label,
+    exitCode: check.exitCode ?? null,
+    error: passed ? null : `command evidence did not indicate success`
+  };
+}
+function verifyCheck(check = {}, context) {
+  const type = normalizeText(check.type || check.kind);
+  if (type === "file" || type === "file_exists") {
+    return verifyFile(check, context);
+  }
+  if (type === "stream" || type === "stream_contains" || type === "channel") {
+    return verifyStream(check, context);
+  }
+  if (type === "command" || type === "command_evidence") {
+    return verifyCommandEvidence(check);
+  }
+  return { passed: false, error: `unsupported check type '${type || "<missing>"}'` };
+}
+function createGoalVerificationService({ getBaseCwd, getStreamHistory } = {}) {
+  function context() {
+    return {
+      baseCwd: typeof getBaseCwd === "function" ? getBaseCwd() : process.cwd(),
+      getStreamHistory
+    };
+  }
+  function verifyGoalOutput(input = {}) {
+    const checks = Array.isArray(input.checks) ? input.checks : [];
+    const results = checks.map((check, index) => ({
+      index,
+      description: check.description ?? check.claim ?? null,
+      type: check.type ?? check.kind ?? null,
+      ...verifyCheck(check, context())
+    }));
+    return {
+      passed: results.length > 0 && results.every((result) => result.passed === true),
+      results
+    };
+  }
+  function auditClaims(input = {}) {
+    const claims = Array.isArray(input.claims) ? input.claims : [];
+    const results = claims.map((claim, index) => {
+      const evidence = claim.evidence && typeof claim.evidence === "object" ? claim.evidence : {};
+      const verification = verifyCheck({
+        ...evidence,
+        description: evidence.description ?? claim.claim,
+        claim: claim.claim
+      }, context());
+      return {
+        index,
+        claim: claim.claim ?? null,
+        status: verification.passed ? "confirmed" : "blocked",
+        ...verification
+      };
+    });
+    return {
+      passed: results.length > 0 && results.every((result) => result.passed === true),
+      results
+    };
+  }
+  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;
 var DEFAULT_MAX_RUNTIME_EVENTS = 300;
+var DEFAULT_MAX_TRACES = 300;
 var MAX_STRING_LENGTH = 1200;
 var MAX_COLLECTION_ITEMS = 40;
 var MAX_DEPTH = 4;
@@ -10997,12 +11552,15 @@ 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 traces = createRingBuffer(options.maxTraces ?? DEFAULT_MAX_TRACES);
   const sessionEventCounts = /* @__PURE__ */ new Map();
   let logCount = 0;
   let runtimeEventCount = 0;
   let sessionEventCount = 0;
+  let traceCount = 0;
   let cleanupSessionListener = () => {
   };
+  let recordSink = typeof options.recordSink === "function" ? options.recordSink : null;
   function recordLog(source, message, options2 = {}) {
     logCount += 1;
     return logs.append({
@@ -11032,6 +11590,49 @@ function createDiagnosticsStore(options = {}) {
       })
     });
   }
+  function recordTrace(trace = {}) {
+    traceCount += 1;
+    const startedAt = trace.startedAt ?? trace.timestamp ?? nowIso();
+    const endedAt = trace.endedAt ?? nowIso();
+    const startMs = Date.parse(startedAt);
+    const endMs = Date.parse(endedAt);
+    const durationMs = Number.isFinite(startMs) && Number.isFinite(endMs) ? Math.max(0, endMs - startMs) : null;
+    const entry = {
+      id: createId("trace", traceCount),
+      traceId: String(trace.traceId ?? `trace-${traceCount.toString(36)}`),
+      timestamp: endedAt,
+      startedAt,
+      endedAt,
+      durationMs,
+      emitterId: trace.emitterId ?? trace.emitterName ?? null,
+      emitterName: trace.emitterName ?? trace.emitterId ?? null,
+      runIndex: Number.isFinite(Number(trace.runIndex)) ? Number(trace.runIndex) : null,
+      emitterType: trace.emitterType ?? null,
+      runSchedule: trace.runSchedule ?? null,
+      status: trace.status ?? "unknown",
+      ok: trace.ok === true,
+      consumedRun: trace.consumedRun !== false,
+      lineCount: Number.isFinite(Number(trace.lineCount)) ? Number(trace.lineCount) : null,
+      droppedLineCount: Number.isFinite(Number(trace.droppedLineCount)) ? Number(trace.droppedLineCount) : null,
+      error: trace.error ? truncateString(trace.error, MAX_STRING_LENGTH) : null,
+      metadata: safeClone(trace.metadata ?? null, {
+        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;
     const type = String(event?.type ?? "unknown");
@@ -11074,11 +11675,13 @@ function createDiagnosticsStore(options = {}) {
       generatedAt: nowIso(),
       logs: logs.snapshot(options2.logLimit ?? 140),
       runtimeEvents: runtimeEvents.snapshot(options2.runtimeEventLimit ?? 140),
+      traces: traces.snapshot(options2.traceLimit ?? 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(),
+        traces: traces.stats(),
         sessionEvents: sessionEvents.stats()
       }
     };
@@ -11086,6 +11689,10 @@ function createDiagnosticsStore(options = {}) {
   return {
     log: recordLog,
     event: recordRuntimeEvent,
+    trace: recordTrace,
+    setRecordSink: (nextSink) => {
+      recordSink = typeof nextSink === "function" ? nextSink : null;
+    },
     attachSession,
     detachSession,
     snapshot
@@ -11113,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 {
@@ -11125,12 +11759,18 @@ function createTapRuntimeService(options = {}) {
     configWorkspace,
     emitterWorkspace,
     persist
-  } = createRuntimeSubsystems(options);
+  } = createRuntimeSubsystems({
+    ...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,
@@ -11138,6 +11778,10 @@ function createTapRuntimeService(options = {}) {
     supervisor,
     emitterWorkspace
   });
+  const goalVerificationService = createGoalVerificationService({
+    getBaseCwd: sessionContext.getBaseCwd,
+    getStreamHistory: (channel, limit) => streamService.getStreamHistory(channel, limit)
+  });
   const configBootstrapService = createConfigBootstrapService({
     streams,
     configStore,
@@ -11145,7 +11789,8 @@ function createTapRuntimeService(options = {}) {
     sessionPort,
     configWorkspace
   });
-  const { loadPersistentConfig } = configBootstrapService;
+  const { loadPersistentConfig: loadPersistentConfigRaw } = configBootstrapService;
+  let persistentConfigLoadPromise = null;
   const sessionActivityBridge = createSessionActivityBridge({ sessionPort, supervisor });
   const providerPushService = createProviderPushService({
     streams,
@@ -11157,11 +11802,27 @@ function createTapRuntimeService(options = {}) {
     const session2 = sessionPort.current();
     return sessionContext.getSessionInfo(session2);
   }
+  function loadPersistentConfigOnce(inputCwd) {
+    if (persistentConfigLoadPromise) {
+      return persistentConfigLoadPromise;
+    }
+    persistentConfigLoadPromise = Promise.resolve().then(() => loadPersistentConfigRaw(inputCwd)).catch((error) => {
+      persistentConfigLoadPromise = null;
+      throw error;
+    });
+    return persistentConfigLoadPromise;
+  }
   function attachSession(session2) {
     sessionContext.attachSession(session2);
     sessionPort.attach(session2);
     sessionActivityBridge.attach(session2);
     diagnosticsStore.attachSession(session2);
+    void loadPersistentConfigOnce(sessionContext.getBaseCwd()).then((summary) => {
+      void sessionPort.log(summary);
+    }).catch((error) => {
+      const message = error?.message ?? String(error ?? "unknown error");
+      void sessionPort.log(`Config load failed during extension attach: ${message}`, { level: "warning" });
+    });
   }
   function clearNotificationsForLifecycle(options2 = {}) {
     if (options2.clearNotifications === true && typeof notifications.clear === "function") {
@@ -11216,7 +11877,7 @@ function createTapRuntimeService(options = {}) {
   } = createRuntimeHooks({
     streams,
     sessionPort,
-    loadPersistentConfig,
+    loadPersistentConfig: loadPersistentConfigOnce,
     stopAllEmitters,
     stopAllEmittersAndWait,
     shutdownSession,
@@ -11245,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(),
@@ -11260,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)
     };
   }
@@ -11279,6 +11950,10 @@ function createTapRuntimeService(options = {}) {
         input: canvasInput
       });
     },
+    getSessionRuntimeState: () => sessionPort.getRuntimeState(),
+    setSessionMode: (mode) => sessionPort.setMode(mode),
+    queryRecords: (collection, options2 = {}) => recordStore.listRecords(collection, options2),
+    getRecordRoot: () => recordStore.getRoot(),
     attachSession: diagnosticsStore.attachSession,
     detachSession: diagnosticsStore.detachSession
   };
@@ -11286,12 +11961,14 @@ function createTapRuntimeService(options = {}) {
     tools: {
       streams: streamCapabilities,
       emitters: emitterCapabilities,
-      diagnostics: diagnosticsCapabilities
+      diagnostics: diagnosticsCapabilities,
+      verification: goalVerificationService
     },
     hooks: hookCapabilities,
     session: sessionCapabilities,
     provider: providerCapabilities,
     diagnostics: diagnosticsCapabilities,
+    verification: goalVerificationService,
     getBaseCwd: sessionContext.getBaseCwd,
     getSessionInfo,
     attachSession,
@@ -11300,7 +11977,7 @@ function createTapRuntimeService(options = {}) {
     appendStreamMessage,
     getSessionStartContext,
     getPromptContext,
-    loadPersistentConfig,
+    loadPersistentConfig: loadPersistentConfigOnce,
     listEmitters: emitterCapabilities.listEmitters,
     listStreams: streamCapabilities.listStreams,
     postToStream: streamCapabilities.postToStream,
@@ -11341,6 +12018,7 @@ function sanitizeSnapshotOptions(input = {}) {
   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,
+    traceLimit: 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
   };
@@ -11351,8 +12029,9 @@ function summarizeSnapshot(snapshot) {
   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 traces = snapshot?.diagnostics?.stats?.traces?.retained ?? 0;
   const sessionEvents = snapshot?.diagnostics?.stats?.sessionEvents?.retained ?? 0;
-  return { streams, runningEmitters, configuredEmitters, providers, logs, sessionEvents };
+  return { streams, runningEmitters, configuredEmitters, providers, logs, traces, sessionEvents };
 }
 function createHtml() {
   return `<!doctype html>
@@ -11582,7 +12261,7 @@ function createHtml() {
       overflow: auto;
     }
 
-    .stream-grid, .emitter-grid, .provider-grid {
+    .stream-grid, .emitter-grid, .provider-grid, .trace-grid, .session-grid {
       display: grid;
       gap: 12px;
     }
@@ -11754,6 +12433,36 @@ function createHtml() {
         </div>
       </section>
 
+      <section class="panel">
+        <div class="panel-head">
+          <h2>Goals and traces</h2>
+          <small id="trace-count">0 traces</small>
+        </div>
+        <div class="panel-body">
+          <div class="trace-grid" id="traces"></div>
+        </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>
@@ -11790,12 +12499,18 @@ function createHtml() {
       const streams = snapshot.streams?.length ?? 0;
       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),
         metric("running emitters", running),
         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("");
@@ -11835,6 +12550,72 @@ 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-"));
+      el("trace-count").textContent = traces.length + " traces";
+      const traceRows = traces.slice(-12).reverse().map((trace) => {
+        const tone = trace.ok ? "ready" : trace.status === "deferred" ? "warning" : "error";
+        return '<div class="record"><strong>' + escapeHtml(trace.emitterName ?? trace.emitterId ?? "unknown") + ' <span class="badge ' + tone + '">' + escapeHtml(trace.status ?? "unknown") + '</span></strong><div class="meta">run=' + escapeHtml(trace.runIndex ?? "?") + ' duration=' + escapeHtml(trace.durationMs ?? "?") + 'ms | trace=' + escapeHtml(trace.traceId ?? "?") + '</div>' + (trace.error ? '<div class="details">' + escapeHtml(trace.error) + '</div>' : '') + '</div>';
+      }).join("");
+      const goalRows = goalStreams.map((stream) => {
+        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("");
+      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) {
       const items = [];
       for (const stream of snapshot.streams ?? []) {
@@ -11851,6 +12632,9 @@ function createHtml() {
       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) });
       }
+      for (const trace of snapshot.diagnostics?.traces ?? []) {
+        items.push({ group: "runtime", timestamp: trace.endedAt ?? trace.timestamp, source: "trace/" + (trace.emitterName ?? trace.emitterId ?? "unknown"), level: trace.ok ? "info" : "warning", message: "emitter run " + (trace.status ?? "unknown"), detail: compactJson({ traceId: trace.traceId, runIndex: trace.runIndex, durationMs: trace.durationMs, error: trace.error }) });
+      }
       return items.sort((a, b) => new Date(b.timestamp) - new Date(a.timestamp));
     }
 
@@ -11874,6 +12658,9 @@ function createHtml() {
       renderMetrics(snapshot);
       renderStreams(snapshot);
       renderProviders(snapshot);
+      renderTraces(snapshot);
+      renderSessionControl(snapshot);
+      renderEvals(snapshot);
       renderTimeline(snapshot);
     }
 
@@ -11922,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 = {}) {
@@ -11936,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") {
@@ -11947,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);
@@ -12001,7 +12795,7 @@ data: ${JSON.stringify(snapshot())}
         },
         handler: async ({ input }) => ({
           ok: true,
-          summary: summarizeSnapshot(snapshot(input))
+          summary: summarizeSnapshot(await snapshot(input))
         })
       },
       {
@@ -12077,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