copilot-tap-extension 2.0.6 → 2.0.8

package/dist/extension.mjs

@@ -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"]
@@ -4654,12 +4654,29 @@ 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 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,
+    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 +4701,105 @@ 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);
+      })
+    });
+  }
+  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 +4808,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 })
   ];
 }
 
@@ -8632,7 +8750,7 @@ function shouldPersistLoadedConfig(parsedConfig, normalizedConfig) {
   return !isDeepStrictEqual(parsedConfig, serializeConfigForComparison(normalizedConfig));
 }
 function createConfigStore(options = {}) {
-  const fs2 = options.fs ?? { existsSync: existsSync2, readFileSync: readFileSync2, writeFileSync: writeFileSync2 };
+  const fs3 = options.fs ?? { existsSync: existsSync2, readFileSync: readFileSync2, writeFileSync: writeFileSync2 };
   const state = {
     cwd: normalizeBaseCwd(options.cwd),
     filePath: null,
@@ -8660,7 +8778,7 @@ function createConfigStore(options = {}) {
         const exists = withConfigLoadPhase(
           "checking config path",
           "Unable to check whether the tap config file exists.",
-          () => fs2.existsSync(filePath),
+          () => fs3.existsSync(filePath),
           { filePath }
         );
         if (!exists) {
@@ -8669,7 +8787,7 @@ function createConfigStore(options = {}) {
         const rawConfig = withConfigLoadPhase(
           "reading config file",
           "Unable to read the tap config file.",
-          () => fs2.readFileSync(filePath, "utf8"),
+          () => fs3.readFileSync(filePath, "utf8"),
           { filePath }
         );
         const parsedConfig = withConfigLoadPhase(
@@ -8727,7 +8845,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)}
+    fs3.writeFileSync(state.filePath, `${JSON.stringify(payload, null, 2)}
 `, "utf8");
   }
   function findStreamIndex(name) {
@@ -9003,7 +9121,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;
 }
@@ -9158,12 +9276,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,
@@ -9231,9 +9349,39 @@ function createDefaultProcessAdapter() {
     readLines
   };
 }
+function recordScheduledTrace(emitter, context, { startedAt, endedAt = nowIso(), runIndex, result = null, error = null, consumedRun = true } = {}) {
+  try {
+    context.diagnostics?.trace?.({
+      traceId: `${stableTraceComponent(emitter.name)}-${Number(runIndex ?? emitter.runCount) || 0}-${Date.parse(startedAt ?? endedAt) || Date.now()}`,
+      emitterId: emitter.name,
+      emitterName: emitter.name,
+      runIndex: Number(runIndex ?? emitter.runCount) || null,
+      emitterType: emitter.emitterType,
+      runSchedule: emitter.runSchedule,
+      startedAt: startedAt ?? endedAt,
+      endedAt,
+      status: result?.deferred ? "deferred" : result?.ok ? "success" : "failure",
+      ok: result?.ok === true,
+      consumedRun,
+      lineCount: emitter.lineCount,
+      droppedLineCount: emitter.droppedLineCount,
+      error: error ?? result?.error ?? 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");
 }
@@ -9503,11 +9651,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
     };
   }
@@ -9568,6 +9717,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);
@@ -9585,6 +9736,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,
@@ -9603,7 +9760,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;
@@ -9617,7 +9787,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) {
@@ -9627,6 +9798,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,
@@ -9639,17 +9811,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;
@@ -9825,14 +9997,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;
   }
@@ -10366,6 +10538,29 @@ 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?.()),
+      openCanvases: await read("openCanvases", () => rpc.canvas?.listOpen?.())
+    };
+  }
   function registerTools(tools) {
     if (!session2) return;
     try {
@@ -10402,6 +10597,7 @@ function createSessionPort(initialSession = null) {
     send,
     sendAndWait,
     openCanvas,
+    getRuntimeState,
     registerTools,
     reloadExtension
   };
@@ -10682,7 +10878,8 @@ function createRuntimeSubsystems(options = {}) {
     notifications,
     sessionPort,
     emitterWorkspace,
-    persist
+    persist,
+    diagnostics: options.diagnostics
   });
   return {
     sessionContext,
@@ -10857,10 +11054,170 @@ 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/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;
@@ -10996,10 +11353,12 @@ 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 = () => {
   };
   function recordLog(source, message, options2 = {}) {
@@ -11031,6 +11390,38 @@ 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;
+    return traces.append({
+      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
+      })
+    });
+  }
   function recordSessionEvent(event) {
     sessionEventCount += 1;
     const type = String(event?.type ?? "unknown");
@@ -11073,11 +11464,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()
       }
     };
@@ -11085,6 +11478,7 @@ function createDiagnosticsStore(options = {}) {
   return {
     log: recordLog,
     event: recordRuntimeEvent,
+    trace: recordTrace,
     attachSession,
     detachSession,
     snapshot
@@ -11124,7 +11518,10 @@ function createTapRuntimeService(options = {}) {
     configWorkspace,
     emitterWorkspace,
     persist
-  } = createRuntimeSubsystems(options);
+  } = createRuntimeSubsystems({
+    ...options,
+    diagnostics: diagnosticsStore
+  });
   const streamService = createStreamService({
     streams,
     configStore,
@@ -11137,6 +11534,10 @@ function createTapRuntimeService(options = {}) {
     supervisor,
     emitterWorkspace
   });
+  const goalVerificationService = createGoalVerificationService({
+    getBaseCwd: sessionContext.getBaseCwd,
+    getStreamHistory: (channel, limit) => streamService.getStreamHistory(channel, limit)
+  });
   const configBootstrapService = createConfigBootstrapService({
     streams,
     configStore,
@@ -11144,7 +11545,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,
@@ -11156,11 +11558,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") {
@@ -11215,7 +11633,7 @@ function createTapRuntimeService(options = {}) {
   } = createRuntimeHooks({
     streams,
     sessionPort,
-    loadPersistentConfig,
+    loadPersistentConfig: loadPersistentConfigOnce,
     stopAllEmitters,
     stopAllEmittersAndWait,
     shutdownSession,
@@ -11278,6 +11696,7 @@ function createTapRuntimeService(options = {}) {
         input: canvasInput
       });
     },
+    getSessionRuntimeState: () => sessionPort.getRuntimeState(),
     attachSession: diagnosticsStore.attachSession,
     detachSession: diagnosticsStore.detachSession
   };
@@ -11285,12 +11704,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,
@@ -11299,7 +11720,7 @@ function createTapRuntimeService(options = {}) {
     appendStreamMessage,
     getSessionStartContext,
     getPromptContext,
-    loadPersistentConfig,
+    loadPersistentConfig: loadPersistentConfigOnce,
     listEmitters: emitterCapabilities.listEmitters,
     listStreams: streamCapabilities.listStreams,
     postToStream: streamCapabilities.postToStream,
@@ -11340,6 +11761,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
   };
@@ -11350,8 +11772,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>
@@ -11581,7 +12004,7 @@ function createHtml() {
       overflow: auto;
     }
 
-    .stream-grid, .emitter-grid, .provider-grid {
+    .stream-grid, .emitter-grid, .provider-grid, .trace-grid {
       display: grid;
       gap: 12px;
     }
@@ -11753,6 +12176,16 @@ 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 timeline-panel">
         <div class="panel-head">
           <h2>Evidence timeline</h2>
@@ -11789,12 +12222,14 @@ 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 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("configured emitters", configured),
         metric("session events", sessionEvents)
       ].join("");
@@ -11834,6 +12269,21 @@ function createHtml() {
       el("providers").innerHTML = gatewayRecord + rows;
     }
 
+    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("");
+      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 : "");
+    }
+
     function collectTimeline(snapshot) {
       const items = [];
       for (const stream of snapshot.streams ?? []) {
@@ -11850,6 +12300,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));
     }
 
@@ -11873,6 +12326,7 @@ function createHtml() {
       renderMetrics(snapshot);
       renderStreams(snapshot);
       renderProviders(snapshot);
+      renderTraces(snapshot);
       renderTimeline(snapshot);
     }