copilot-tap-extension 2.0.7 → 2.0.8

package/README.md

@@ -289,6 +289,8 @@ PLAN.md                         # ubiquitous language and design decisions
 | [Use cases and patterns](./docs/use-cases.md) | Recipes for deploy watchers, PR monitors, log tailers, and more |
 | [Copilot SDK canvas surfaces](./docs/recipes/copilot-sdk-canvas.md) | Local SDK findings for extension-owned canvas UI surfaces |
 | [Codex Goals lessons for tap-goal](./docs/recipes/codex-goals-for-tap-goal.md) | Goal-loop contract, evidence audit, and autopilot scheduling guidance |
+| [Tap control-plane roadmap](./docs/recipes/tap-control-plane-roadmap.md) | Implemented and deferred control-plane slices from the Codex/Copilot audit |
+| [Provider integration patterns](./docs/recipes/provider-integration-patterns.md) | Jira/GitHub, CI auto-fix, code review, SAST, and browser/Detour provider recipes |
 | [Evals](./docs/evals.md) | Run or extend the automated test suite |
 | [Copilot instructions](./src/copilot-instructions.md) | Understand or customize how the agent uses this extension |
 | [Implementation plan](./PLAN.md) | Ubiquitous language and naming conventions for contributors |

package/bin/install.mjs

@@ -268,6 +268,11 @@ function buildAncillaryArtifacts(targetRoot) {
       dest: path.join(targetRoot, "skills", "tap-goal", "SKILL.md"),
       label: "skills/tap-goal/SKILL.md"
     },
+    {
+      src: path.join(distDir, "skills", "tap-orchestrate", "SKILL.md"),
+      dest: path.join(targetRoot, "skills", "tap-orchestrate", "SKILL.md"),
+      label: "skills/tap-orchestrate/SKILL.md"
+    },
     {
       src: path.join(distDir, "copilot-instructions.md"),
       dest: path.join(targetRoot, "copilot-instructions.md"),

package/dist/copilot-instructions.md

@@ -161,11 +161,21 @@ switching into wrap-up mode when the remaining iteration budget is low, posting
 structured iteration records to their EventStream with `tap_post`, and stopping
 themselves when complete or blocked. Completion requires an evidence audit
 against concrete files, tests, logs, benchmark output, or generated artifacts.
+Use `tap_verify_goal_output` and `tap_audit_claims` when the verification surface
+is a workspace file, stream entry, or already-run command result.
 If the session may stay continuously busy (for example in autopilot-heavy
 flows), use a timed PromptEmitter with a backoff schedule such as
 `everySchedule=["2m","5m","10m"]` instead of relying on idle to trigger the next
 goal step.
 
+Use `tap_get_session_state` before mode-sensitive work. It reads the current
+Copilot mode, model/reasoning effort, tasks, schedules, open canvases, and UI
+capabilities without mutating the session.
+
+For genuinely multi-role work, prefer `/tap-orchestrate`: create one coordinator
+PromptEmitter that gates role-specific sub-emitters using EventStream handoffs.
+Do not use orchestration for tasks a single `/tap-goal` loop can complete.
+
 ## Borrow from the official SDK examples
 
 When working on the extension itself, not just using its emitter tools, prefer these SDK patterns:

package/dist/extension.mjs

@@ -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) {
@@ -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");
 }
@@ -9569,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);
@@ -9586,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,
@@ -9604,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;
@@ -9618,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) {
@@ -9628,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,
@@ -9640,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;
@@ -9826,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;
   }
@@ -10367,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 {
@@ -10403,6 +10597,7 @@ function createSessionPort(initialSession = null) {
     send,
     sendAndWait,
     openCanvas,
+    getRuntimeState,
     registerTools,
     reloadExtension
   };
@@ -10683,7 +10878,8 @@ function createRuntimeSubsystems(options = {}) {
     notifications,
     sessionPort,
     emitterWorkspace,
-    persist
+    persist,
+    diagnostics: options.diagnostics
   });
   return {
     sessionContext,
@@ -10858,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;
@@ -10997,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 = {}) {
@@ -11032,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");
@@ -11074,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()
       }
     };
@@ -11086,6 +11478,7 @@ function createDiagnosticsStore(options = {}) {
   return {
     log: recordLog,
     event: recordRuntimeEvent,
+    trace: recordTrace,
     attachSession,
     detachSession,
     snapshot
@@ -11125,7 +11518,10 @@ function createTapRuntimeService(options = {}) {
     configWorkspace,
     emitterWorkspace,
     persist
-  } = createRuntimeSubsystems(options);
+  } = createRuntimeSubsystems({
+    ...options,
+    diagnostics: diagnosticsStore
+  });
   const streamService = createStreamService({
     streams,
     configStore,
@@ -11138,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,
@@ -11145,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,
@@ -11157,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") {
@@ -11216,7 +11633,7 @@ function createTapRuntimeService(options = {}) {
   } = createRuntimeHooks({
     streams,
     sessionPort,
-    loadPersistentConfig,
+    loadPersistentConfig: loadPersistentConfigOnce,
     stopAllEmitters,
     stopAllEmittersAndWait,
     shutdownSession,
@@ -11279,6 +11696,7 @@ function createTapRuntimeService(options = {}) {
         input: canvasInput
       });
     },
+    getSessionRuntimeState: () => sessionPort.getRuntimeState(),
     attachSession: diagnosticsStore.attachSession,
     detachSession: diagnosticsStore.detachSession
   };
@@ -11286,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,
@@ -11300,7 +11720,7 @@ function createTapRuntimeService(options = {}) {
     appendStreamMessage,
     getSessionStartContext,
     getPromptContext,
-    loadPersistentConfig,
+    loadPersistentConfig: loadPersistentConfigOnce,
     listEmitters: emitterCapabilities.listEmitters,
     listStreams: streamCapabilities.listStreams,
     postToStream: streamCapabilities.postToStream,
@@ -11341,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
   };
@@ -11351,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>
@@ -11582,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;
     }
@@ -11754,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>
@@ -11790,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("");
@@ -11835,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 ?? []) {
@@ -11851,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));
     }
 
@@ -11874,6 +12326,7 @@ function createHtml() {
       renderMetrics(snapshot);
       renderStreams(snapshot);
       renderProviders(snapshot);
+      renderTraces(snapshot);
       renderTimeline(snapshot);
     }
 

package/dist/skills/tap-goal/SKILL.md

@@ -133,13 +133,19 @@ Continuation rules:
 - If only 1 iteration remains and the goal is not complete, do not start broad new work. Produce a budget-limited handoff instead.
 - Do not treat budget exhaustion or a lifecycle "reached run budget" message as success.
 - If this iteration makes no progress-producing tool calls beyond required status/ledger bookkeeping and does not change evidence, call `tap_post` with `channel='<goal-emitter-name>'` and a no-action handoff, then stop the emitter rather than spinning.
+- If the remaining delta is unchanged from the previous ITERATION RECORD, post a STALLED LOOP record and stop rather than spending the rest of the budget.
 
 Evidence-audit rules:
 - Before marking complete, identify the verification surface from the goal contract.
 - Check the evidence directly: test output, benchmark result, file content, diff, generated artifact, source material, or other concrete proof.
+- When the evidence is a workspace file, EventStream entry, or already-run command result, call `tap_verify_goal_output` or `tap_audit_claims` before GOAL COMPLETE.
 - Check listed constraints for regressions.
 - If the verification surface cannot be checked, treat the goal as blocked, not complete.
 - Completion requires an explicit evidence audit in the final response and in the EventStream.
+- Wrap machine-readable EventStream records with explicit markers:
+  `=== BEGIN_ITERATION_RECORD ===` / `=== END_ITERATION_RECORD ===`,
+  `=== BEGIN_GOAL_COMPLETE ===` / `=== END_GOAL_COMPLETE ===`,
+  `=== BEGIN_GOAL_BLOCKED ===` / `=== END_GOAL_BLOCKED ===`.
 
 Research/audit goal rules:
 - For research, reproduction, audit, or investigation goals, maintain a claim ledger.
@@ -148,21 +154,26 @@ Research/audit goal rules:
 
 On this iteration:
 1. Briefly assess current progress toward the goal and the remaining iteration budget.
-2. If the goal is already achieved, first call `tap_post` with `channel='<goal-emitter-name>'` and a GOAL COMPLETE evidence audit in `message`, then call tap_stop_emitter for '<goal-emitter-name>' with scope='temporary', report that the goal is complete, and stop.
+2. If the goal is already achieved, first call `tap_verify_goal_output` or `tap_audit_claims` against the verification surface. If verification passes, call `tap_post` with `channel='<goal-emitter-name>'` and a marked GOAL COMPLETE evidence audit in `message`, then call tap_stop_emitter for '<goal-emitter-name>' with scope='temporary', report that the goal is complete, and stop.
 3. If the goal is blocked by missing information, permissions, failing external systems, or an unsafe action, first call `tap_post` with `channel='<goal-emitter-name>'` and a GOAL BLOCKED report in `message`, then call tap_stop_emitter for '<goal-emitter-name>' with scope='temporary', report the blocker, and stop.
-4. If this is the final iteration and the goal is not complete, do not start substantive new work. Call `tap_post` with `channel='<goal-emitter-name>'` and a BUDGET LIMITED summary in `message`: progress, evidence gathered, remaining work, and recommended next goal or budget. Then leave a concise handoff.
+4. If this is the final iteration and the goal is not complete, do not start substantive new work. Call `tap_post` with `channel='<goal-emitter-name>'` and a BUDGET LIMITED summary in `message`: progress, evidence gathered, remaining work, recommended next `/tap-goal ...` invocation, and suggested fresh budget. Then leave a concise handoff.
 5. Otherwise, choose the next smallest useful action toward the goal that fits the remaining budget and perform it.
 6. Validate the action using the repository's existing checks when relevant.
 7. End by calling `tap_post` with `channel='<goal-emitter-name>'` and an ITERATION RECORD in `message` containing:
    - iteration and budget used
    - action taken
    - evidence checked and result
+   - claim ledger entries when this is a research/audit goal
+   - remaining_delta or unchanged_delta status
    - current status: progressing, complete, blocked, or budget-limited
    - next best action
+   - branch, commit SHA, PR URL, run URL, or issue key when relevant
 8. End the user-visible response with the same concise progress update, what remains, and the next best step if the loop stops before completion.
 
 Safety rules:
 - Do not make unrelated changes.
+- Do not modify this goal emitter's own `every`, `everySchedule`, `maxRuns`, event filter, or goal contract while it is running unless the user explicitly asks.
+- Do not spawn additional emitters from this goal unless orchestration is explicitly part of the goal contract.
 - Do not mark the goal complete unless the objective is actually achieved and no required work remains.
 - Do not treat reaching the iteration budget as success.
 - Do not continue if the next step requires explicit user approval.

package/dist/skills/tap-loop/SKILL.md

@@ -7,6 +7,12 @@ user-invocable: true
 
 Create a timed or idle PromptEmitter with `tap_start_emitter`.
 
+If the request includes a completion condition such as "until", "keep going
+until", "stop when", "work until done", or "iterate until complete", do not
+create a plain loop. Redirect to `/tap-goal` semantics instead, because the
+user is asking for a completion contract with evidence, budget, and stop
+conditions rather than a recurring prompt.
+
 ## Expected input
 
 Interpret the invocation as:

package/dist/skills/tap-monitor/SKILL.md

@@ -63,9 +63,25 @@ Steps:
    - Lines that indicate important events (errors, warnings, state changes) → candidates for `{ "match": "...", "outcome": "inject" }`.
    - Lines that are never relevant at all → candidates for tighter keep/drop rules.
 4. Compare what you see against the current filter patterns for emitter '<command-emitter-name>'.
-5. Only update if the evidence clearly justifies a change (signal-to-noise is poor or a pattern is clearly wrong).
-6. If an update is needed, call tap_set_event_filter with the revised patterns for emitter '<command-emitter-name>'.
-7. Do not report your findings to the user unless you made a change. If you made a change, send one short message describing what you updated and why.
+5. Use this shared contract when judging the stream:
+   - stream_purpose: <why the user wanted this monitor>
+   - signal_vocabulary: errors, warnings, failures, state changes, explicit success/failure markers
+   - noise_vocabulary: timestamps-only, heartbeat-only, repeated unchanged status, empty pings
+6. Only update if the evidence clearly justifies a change (signal-to-noise is poor or a pattern is clearly wrong).
+7. If an update is needed, call tap_set_event_filter with the revised patterns for emitter '<command-emitter-name>'.
+8. Always call tap_post with channel '<stream-name>' and a REVIEW RECORD wrapped in markers:
+   === BEGIN_REVIEW_RECORD ===
+   {
+     "reviewed_at": "<ISO timestamp>",
+     "entries_examined": <number>,
+     "issue_type": "noise_pattern|missed_signal|over_filtering|duplicate_inject|no_change",
+     "patterns_changed": ["short label for each change"],
+     "remaining_noise_delta": ["what still looks noisy or uncertain"],
+     "signal_vocabulary": ["terms treated as signal"],
+     "noise_vocabulary": ["terms treated as noise"]
+   }
+   === END_REVIEW_RECORD ===
+9. Do not report your findings to the user unless you made a change. If you made a change, send one short message describing what you updated and why.
 ```
 
 Substitute the real emitter name and stream name into the prompt before passing it to `tap_start_emitter`.

package/dist/skills/tap-orchestrate/SKILL.md

@@ -0,0 +1,81 @@
+---
+name: tap-orchestrate
+description: "Create a coordinator PromptEmitter for multi-agent tap workflows with role-specific sub-emitters, gated handoffs, and evidence records. Use when the user asks to orchestrate multiple agents, roles, workstreams, or parallel implementation/review/test phases."
+argument-hint: "<objective and roles>"
+user-invocable: true
+---
+
+Create a coordinator PromptEmitter that manages a multi-agent workflow using tap
+emitters and EventStreams.
+
+Use this for work that naturally decomposes into roles such as planner,
+implementer, reviewer, tester, documenter, provider-builder, or release
+coordinator. Do not use it for a single straightforward task.
+
+## What to create
+
+Use `tap_start_emitter` to create a **coordinator PromptEmitter**:
+
+- Name: `orchestrate-<objective-slug>`.
+- Prompt: a self-contained orchestration contract.
+- Schedule: `everySchedule = ["2m", "5m", "10m"]`.
+- `lifespan = "temporary"` unless the user explicitly asks for persistence.
+- `ownership = "modelOwned"`.
+- `subscribe = false`.
+- `maxRuns = 50` unless the user gives a budget.
+
+The coordinator may create role-specific PromptEmitters only when the role has a
+clear deliverable and verification surface. Each role emitter should write its
+handoff to an EventStream with a stable name:
+
+```text
+orchestrate-<objective>-<role>
+```
+
+## Coordinator prompt contract
+
+The coordinator prompt must include:
+
+```text
+Objective: <user objective>
+Roles: <role list, deliverables, and verification surface>
+Gate policy:
+- Do not hand off to the next role until required artifacts or EventStream notes exist.
+- Read role EventStreams with tap_stream_history before deciding a gate is satisfied.
+- If parallel work is safe, create independent role emitters in the same iteration.
+- If a role blocks, post ORCHESTRATION BLOCKED and stop the coordinator.
+Audit trail:
+- After every decision, call tap_post to the coordinator stream with ORCHESTRATION RECORD:
+  role, gate, evidence checked, decision, next handoff.
+Safety:
+- Do not spawn duplicate role emitters.
+- Do not mutate another role's scope unless the coordinator evidence supports it.
+- Stop all role emitters when the orchestration completes or blocks.
+```
+
+## Required behavior
+
+1. Parse the objective and any requested roles.
+2. If roles are missing, infer a minimal role set from the objective:
+   planner, implementer, reviewer, validator.
+3. Create the coordinator PromptEmitter only; do not immediately create role
+   emitters in the setup turn. The coordinator will create them when it runs.
+4. Confirm:
+   - coordinator emitter name and stream
+   - roles
+   - gate policy
+   - max iteration budget
+
+## Good role patterns
+
+- **planner**: produce plan and boundaries; verification is a plan note.
+- **implementer**: make code/doc changes; verification is diff + focused checks.
+- **reviewer**: inspect changes; verification is review note with findings.
+- **validator**: run tests/build/evals; verification is command evidence.
+- **release**: bump/push/publish only after validator passes.
+
+## When not to use
+
+Do not create orchestration for a normal `/tap-goal` objective that one agent can
+complete directly. Orchestration adds coordination cost and should only be used
+when parallel roles or gated handoffs are genuinely useful.

package/dist/version.json

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "copilot-tap-extension",
-  "version": "2.0.7",
+  "version": "2.0.8",
   "description": "Copilot CLI extension for background event emitters, event streams, and session injection.",
   "type": "module",
   "license": "MIT",