copilot-tap-extension 0.2.0

package/dist/extension.mjs

@@ -0,0 +1,1682 @@
+// ※ tap — copilot-tap-extension (bundled)
+// https://github.com/amitse/copilot-tap-extension
+
+
+// .github/extensions/tap/extension.mjs
+import { joinSession } from "@github/copilot-sdk/extension";
+
+// src/consts.mjs
+import path from "node:path";
+var GITHUB_DIR = ".github";
+var CONFIG_FILENAME = "tap.config.json";
+var CONFIG_LOCATIONS = [
+  CONFIG_FILENAME,
+  `${GITHUB_DIR}${path.sep}${CONFIG_FILENAME}`
+];
+var COPILOT_INSTRUCTIONS_PATH = `${GITHUB_DIR}/copilot-instructions.md`;
+var MAX_STREAM_ENTRIES = 200;
+var DEFAULT_STREAM = "main";
+var DEFAULT_STREAM_DESCRIPTION = "Extension events";
+var RUN_INTERVAL_PATTERN = /^\s*(?:every\s+)?(\d+)\s*(s|sec|secs|second|seconds|m|min|mins|minute|minutes|h|hr|hrs|hour|hours|d|day|days)\s*$/i;
+var NOTIFICATION_BATCH_SIZE = 4;
+var BRAND = "\u203B tap";
+var LOG_PREFIX = `${BRAND}:`;
+var LIFESPAN = Object.freeze({
+  TEMPORARY: "temporary",
+  PERSISTENT: "persistent"
+});
+var OWNERSHIP = Object.freeze({
+  USER_OWNED: "userOwned",
+  MODEL_OWNED: "modelOwned"
+});
+var EVENT_OUTCOME = Object.freeze({
+  DROP: "drop",
+  KEEP: "keep",
+  SURFACE: "surface",
+  INJECT: "inject"
+});
+var EMITTER_TYPE = Object.freeze({
+  COMMAND: "command",
+  PROMPT: "prompt"
+});
+var RUN_SCHEDULE = Object.freeze({
+  CONTINUOUS: "continuous",
+  TIMED: "timed",
+  ONE_TIME: "oneTime",
+  IDLE: "idle"
+});
+var IDLE_PROMPT_DELAY_MS = 2e3;
+var IDLE_PROMPT_BACKOFF_MS = 5e3;
+var EMITTER_STATUS = Object.freeze({
+  QUEUED: "queued",
+  WAITING: "waiting",
+  RUNNING: "running",
+  STOPPING: "stopping",
+  STOPPED: "stopped",
+  EXITED: "exited",
+  COMPLETED: "completed",
+  ERROR: "error"
+});
+var RUN_STATUS = Object.freeze({
+  SUCCESS: "success",
+  FAILURE: "failure"
+});
+var EMITTER_OPERATION_STATUS = Object.freeze({
+  REMOVED_FROM_CONFIG: "removed-from-config",
+  CONFIGURED: "configured"
+});
+var TERMINAL_EMITTER_STATUSES = Object.freeze([
+  EMITTER_STATUS.STOPPED,
+  EMITTER_STATUS.EXITED,
+  EMITTER_STATUS.COMPLETED,
+  EMITTER_STATUS.ERROR
+]);
+var STREAM = Object.freeze({
+  STDOUT: "stdout",
+  STDERR: "stderr",
+  PROMPT: "prompt",
+  SYSTEM: "system"
+});
+var SOURCE = Object.freeze({
+  SYSTEM: "system",
+  TOOL: "tool",
+  EMITTER: "emitter",
+  EMITTER_STDERR: "emitter:stderr",
+  EMITTER_PROMPT: "emitter:prompt"
+});
+
+// src/session/port.mjs
+function createSessionPort(initialSession = null) {
+  let session2 = initialSession;
+  function attach(nextSession) {
+    session2 = nextSession ?? null;
+    return session2;
+  }
+  function current() {
+    return session2;
+  }
+  async function safeLog(message, options) {
+    if (!session2) {
+      return;
+    }
+    try {
+      await session2.log(message, options);
+    } catch {
+    }
+  }
+  async function log(message, options = {}) {
+    await safeLog(`${LOG_PREFIX} ${message}`, {
+      ephemeral: true,
+      ...options
+    });
+  }
+  async function send(prompt) {
+    if (!session2) {
+      throw new Error("Session is not attached; cannot send prompt.");
+    }
+    return session2.send({ prompt });
+  }
+  async function sendAndWait(prompt) {
+    if (!session2) {
+      throw new Error("Session is not attached; cannot send prompt.");
+    }
+    return session2.sendAndWait({ prompt });
+  }
+  return {
+    attach,
+    current,
+    log,
+    send,
+    sendAndWait
+  };
+}
+
+// src/util/normalize.mjs
+function normalizeName(value, fallback = "") {
+  const normalized = String(value ?? "").trim().toLowerCase().replace(/[^a-z0-9._-]+/g, "-").replace(/^-+|-+$/g, "");
+  return normalized || fallback;
+}
+function normalizeLifespan(value, fallback = LIFESPAN.TEMPORARY) {
+  return String(value ?? fallback).trim().toLowerCase() === LIFESPAN.PERSISTENT ? LIFESPAN.PERSISTENT : LIFESPAN.TEMPORARY;
+}
+function normalizeOwnership(value, fallback = OWNERSHIP.MODEL_OWNED) {
+  return String(value ?? fallback).trim().toLowerCase() === OWNERSHIP.USER_OWNED ? OWNERSHIP.USER_OWNED : OWNERSHIP.MODEL_OWNED;
+}
+function normalizeOutcome(value, fallback = EVENT_OUTCOME.SURFACE) {
+  return String(value ?? fallback).trim().toLowerCase() === EVENT_OUTCOME.DROP ? EVENT_OUTCOME.DROP : fallback;
+}
+
+// src/util/text.mjs
+function toText(value) {
+  if (typeof value === "string") {
+    return value;
+  }
+  if (Array.isArray(value)) {
+    return value.map((item) => toText(item)).filter(Boolean).join("\n");
+  }
+  if (value && typeof value === "object") {
+    if (typeof value.text === "string") {
+      return value.text;
+    }
+    if (typeof value.content === "string") {
+      return value.content;
+    }
+    return JSON.stringify(value, null, 2);
+  }
+  return String(value ?? "");
+}
+function previewText(value, maxLength = 120) {
+  const text = String(value ?? "").trim();
+  if (text.length <= maxLength) {
+    return text;
+  }
+  return `${text.slice(0, Math.max(maxLength - 3, 1))}...`;
+}
+function splitTextLines(value) {
+  return toText(value).split(/\r?\n/).map((line) => line.trim()).filter(Boolean);
+}
+function clampLimit(value, fallback = 20) {
+  const parsed = Number.parseInt(String(value ?? fallback), 10);
+  if (Number.isNaN(parsed)) {
+    return fallback;
+  }
+  return Math.min(Math.max(parsed, 1), 100);
+}
+
+// src/util/time.mjs
+function nowIso() {
+  return (/* @__PURE__ */ new Date()).toISOString();
+}
+function parseLoopInterval(value) {
+  if (value === void 0 || value === null || String(value).trim() === "") {
+    return null;
+  }
+  const trimmed = String(value).trim().toLowerCase();
+  if (trimmed === "idle") {
+    return { text: "idle", ms: 0, idle: true };
+  }
+  const match = String(value).trim().match(RUN_INTERVAL_PATTERN);
+  if (!match) {
+    throw new Error(`Invalid every interval '${value}'. Use values like 30s, 5m, 2h, or 1d.`);
+  }
+  const amount = Number.parseInt(match[1], 10);
+  if (Number.isNaN(amount) || amount < 1) {
+    throw new Error(`Invalid every interval '${value}'. The number must be 1 or greater.`);
+  }
+  const unitToken = match[2].toLowerCase();
+  let unit = "m";
+  let multiplier = 60 * 1e3;
+  if (unitToken.startsWith("s")) {
+    unit = "s";
+    multiplier = 1e3;
+  } else if (unitToken.startsWith("h")) {
+    unit = "h";
+    multiplier = 60 * 60 * 1e3;
+  } else if (unitToken.startsWith("d")) {
+    unit = "d";
+    multiplier = 24 * 60 * 60 * 1e3;
+  }
+  return {
+    text: `${amount}${unit}`,
+    ms: amount * multiplier
+  };
+}
+
+// src/util/policy.mjs
+function assertMutable(ownership, force, label) {
+  if (normalizeOwnership(ownership, OWNERSHIP.MODEL_OWNED) === OWNERSHIP.USER_OWNED && !force) {
+    throw new Error(`${label} is user-controlled. Pass force=true only when the user explicitly wants to override it.`);
+  }
+}
+function isTerminalEmitterStatus(status) {
+  return TERMINAL_EMITTER_STATUSES.includes(status);
+}
+
+// src/streams/store.mjs
+function createSessionInjector(overrides = {}) {
+  return {
+    enabled: Boolean(overrides.enabled),
+    delivery: normalizeOutcome(overrides.delivery, EVENT_OUTCOME.SURFACE),
+    lifespan: normalizeLifespan(overrides.scope ?? overrides.lifespan, LIFESPAN.TEMPORARY),
+    ownership: normalizeOwnership(overrides.managedBy ?? overrides.ownership, OWNERSHIP.MODEL_OWNED)
+  };
+}
+function createStreamStore() {
+  const streams = /* @__PURE__ */ new Map();
+  function ensure(rawName, description = "") {
+    const name = normalizeName(rawName, DEFAULT_STREAM);
+    let stream = streams.get(name);
+    if (!stream) {
+      stream = {
+        name,
+        description: String(description ?? "").trim(),
+        createdAt: nowIso(),
+        entries: [],
+        sessionInjector: createSessionInjector()
+      };
+      streams.set(name, stream);
+    } else if (description && !stream.description) {
+      stream.description = String(description).trim();
+    }
+    return stream;
+  }
+  function append(rawStream, entry) {
+    const stream = ensure(rawStream);
+    const normalizedEntry = {
+      timestamp: entry.timestamp ?? nowIso(),
+      source: entry.source ?? SOURCE.SYSTEM,
+      text: toText(entry.text).trim(),
+      monitorName: entry.monitorName ?? null,
+      stream: entry.stream ?? null
+    };
+    if (!normalizedEntry.text) {
+      return null;
+    }
+    stream.entries.push(normalizedEntry);
+    if (stream.entries.length > MAX_STREAM_ENTRIES) {
+      stream.entries.splice(0, stream.entries.length - MAX_STREAM_ENTRIES);
+    }
+    return normalizedEntry;
+  }
+  function get(rawName) {
+    return streams.get(normalizeName(rawName));
+  }
+  function list() {
+    return [...streams.values()].sort((left, right) => left.name.localeCompare(right.name));
+  }
+  function size() {
+    return streams.size;
+  }
+  function configureSessionInjector(rawName, options = {}) {
+    const stream = ensure(rawName, options.description ?? "");
+    assertMutable(stream.sessionInjector.ownership, options.force, `Session injector for stream '${stream.name}'`);
+    stream.sessionInjector = createSessionInjector({
+      enabled: options.enabled,
+      delivery: options.delivery ?? stream.sessionInjector.delivery,
+      lifespan: options.scope ?? stream.sessionInjector.lifespan,
+      ownership: options.managedBy ?? stream.sessionInjector.ownership
+    });
+    return stream;
+  }
+  function applyPersistentStream(entry) {
+    const stream = ensure(entry.name, entry.description ?? "");
+    const configInjector = entry.sessionInjector ?? entry.subscription ?? {};
+    stream.sessionInjector = createSessionInjector({
+      enabled: configInjector.enabled === true,
+      delivery: configInjector.delivery ?? EVENT_OUTCOME.SURFACE,
+      lifespan: LIFESPAN.PERSISTENT,
+      ownership: configInjector.ownership ?? configInjector.managedBy ?? OWNERSHIP.USER_OWNED
+    });
+    return stream;
+  }
+  return {
+    ensure,
+    append,
+    get,
+    list,
+    size,
+    configureSessionInjector,
+    applyPersistentStream
+  };
+}
+
+// src/streams/notifications.mjs
+function buildNotificationPrompt(batch) {
+  return [
+    `${BRAND} \u2014 background event stream update:`,
+    ...batch.map((item) => {
+      const streamLabel = item.stream ? `/${item.stream}` : "";
+      return `- stream=${item.channel} emitter=${item.monitorName}${streamLabel}: ${item.text}`;
+    }),
+    "Only react if the update matters to the current task."
+  ].join("\n");
+}
+function createNotificationDispatcher({ sessionPort }) {
+  const queue = [];
+  let inFlight = false;
+  async function flush() {
+    if (inFlight || queue.length === 0) {
+      return;
+    }
+    inFlight = true;
+    const batch = queue.splice(0, NOTIFICATION_BATCH_SIZE);
+    try {
+      await sessionPort.send(buildNotificationPrompt(batch));
+    } catch (error) {
+      await sessionPort.log(`Failed to dispatch monitor update: ${error.message}`, { level: "warning" });
+    } finally {
+      inFlight = false;
+      if (queue.length > 0) {
+        void flush();
+      }
+    }
+  }
+  function enqueue(notification) {
+    queue.push(notification);
+    void flush();
+  }
+  return { enqueue };
+}
+
+// src/config/store.mjs
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import path2 from "node:path";
+function emptyConfig() {
+  return { streams: [], emitters: [] };
+}
+function ensureShape(config) {
+  if (!config || typeof config !== "object") {
+    return emptyConfig();
+  }
+  if (!Array.isArray(config.streams)) {
+    config.streams = [];
+  }
+  if (!Array.isArray(config.emitters)) {
+    config.emitters = [];
+  }
+  return config;
+}
+function serializeStream(stream) {
+  const entry = { name: stream.name };
+  if (stream.description) {
+    entry.description = stream.description;
+  }
+  if (stream.sessionInjector.lifespan === LIFESPAN.PERSISTENT || stream.sessionInjector.enabled) {
+    entry.sessionInjector = {
+      enabled: stream.sessionInjector.enabled,
+      delivery: stream.sessionInjector.delivery,
+      ownership: stream.sessionInjector.ownership
+    };
+  }
+  return entry;
+}
+function serializeEmitter(emitter) {
+  const entry = {
+    name: emitter.name,
+    stream: emitter.channel,
+    autoStart: emitter.autoStart,
+    includeStderr: emitter.includeStderr,
+    ownership: emitter.managedBy
+  };
+  if (emitter.command) {
+    entry.command = emitter.command;
+  }
+  if (emitter.prompt) {
+    entry.prompt = emitter.prompt;
+  }
+  if (emitter.every) {
+    entry.every = emitter.every;
+  }
+  if (emitter.description) {
+    entry.description = emitter.description;
+  }
+  if (emitter.requestedCwd) {
+    entry.cwd = emitter.requestedCwd;
+  }
+  entry.eventFilter = {};
+  if (emitter.classifier.includePattern) {
+    entry.eventFilter.includePattern = emitter.classifier.includePattern;
+  }
+  if (emitter.classifier.excludePattern) {
+    entry.eventFilter.excludePattern = emitter.classifier.excludePattern;
+  }
+  if (emitter.classifier.notifyPattern) {
+    entry.eventFilter.notifyPattern = emitter.classifier.notifyPattern;
+  }
+  if (emitter.classifier.managedBy !== emitter.managedBy) {
+    entry.eventFilter.ownership = emitter.classifier.managedBy;
+  }
+  if (Object.keys(entry.eventFilter).length === 0) {
+    delete entry.eventFilter;
+  }
+  return entry;
+}
+function createConfigStore(options = {}) {
+  const fs = options.fs ?? { existsSync, readFileSync, writeFileSync };
+  const state = {
+    cwd: options.cwd ?? process.cwd(),
+    filePath: null,
+    config: emptyConfig()
+  };
+  function defaultPath(baseCwd) {
+    return path2.join(baseCwd, CONFIG_FILENAME);
+  }
+  function load(baseCwd) {
+    state.cwd = baseCwd;
+    state.filePath = defaultPath(baseCwd);
+    state.config = emptyConfig();
+    for (const relativePath of CONFIG_LOCATIONS) {
+      const filePath = path2.join(baseCwd, relativePath);
+      if (!fs.existsSync(filePath)) {
+        continue;
+      }
+      state.filePath = filePath;
+      state.config = ensureShape(JSON.parse(fs.readFileSync(filePath, "utf8")));
+      return { found: true, filePath };
+    }
+    ensureShape(state.config);
+    return { found: false, filePath: state.filePath };
+  }
+  function save() {
+    ensureShape(state.config);
+    if (!state.filePath) {
+      state.filePath = defaultPath(state.cwd);
+    }
+    const payload = {
+      streams: [...state.config.streams].sort(
+        (left, right) => normalizeName(left.name).localeCompare(normalizeName(right.name))
+      ),
+      emitters: [...state.config.emitters].sort(
+        (left, right) => normalizeName(left.name).localeCompare(normalizeName(right.name))
+      )
+    };
+    fs.writeFileSync(state.filePath, `${JSON.stringify(payload, null, 2)}
+`, "utf8");
+  }
+  function findStreamIndex(name) {
+    return state.config.streams.findIndex((stream) => normalizeName(stream.name) === name);
+  }
+  function findEmitterIndex(name) {
+    return state.config.emitters.findIndex((emitter) => normalizeName(emitter.name) === name);
+  }
+  function upsertStream(stream) {
+    ensureShape(state.config);
+    const entry = serializeStream(stream);
+    const index = findStreamIndex(stream.name);
+    if (index === -1) {
+      state.config.streams.push(entry);
+    } else {
+      state.config.streams[index] = entry;
+    }
+  }
+  function upsertEmitter(emitter) {
+    ensureShape(state.config);
+    const entry = serializeEmitter(emitter);
+    const index = findEmitterIndex(emitter.name);
+    if (index === -1) {
+      state.config.emitters.push(entry);
+    } else {
+      state.config.emitters[index] = entry;
+    }
+  }
+  function removeEmitter(name, force = false) {
+    const normalized = normalizeName(name);
+    const index = findEmitterIndex(normalized);
+    if (index === -1) {
+      return false;
+    }
+    const entry = state.config.emitters[index];
+    assertMutable(normalizeOwnership(entry.ownership, OWNERSHIP.USER_OWNED), force, `Emitter '${normalized}'`);
+    state.config.emitters.splice(index, 1);
+    return true;
+  }
+  function getStreams() {
+    ensureShape(state.config);
+    return state.config.streams;
+  }
+  function getEmitters() {
+    ensureShape(state.config);
+    return state.config.emitters;
+  }
+  function findEmitter(name) {
+    const index = findEmitterIndex(normalizeName(name));
+    return index === -1 ? null : state.config.emitters[index];
+  }
+  function getPath() {
+    return state.filePath;
+  }
+  function getCwd() {
+    return state.cwd;
+  }
+  return {
+    load,
+    save,
+    upsertStream,
+    upsertEmitter,
+    removeEmitter,
+    getStreams,
+    getEmitters,
+    findEmitter,
+    getPath,
+    getCwd
+  };
+}
+
+// src/util/regex.mjs
+function compileRegex(pattern, label) {
+  if (pattern === void 0 || pattern === null || pattern === "") {
+    return null;
+  }
+  try {
+    return new RegExp(String(pattern), "i");
+  } catch (error) {
+    throw new Error(`Invalid ${label} regex '${pattern}': ${error.message}`);
+  }
+}
+
+// src/format/event-filter.mjs
+function legacyToRules(source) {
+  const rules = [];
+  if (source.excludePattern) {
+    rules.push({ match: String(source.excludePattern), outcome: EVENT_OUTCOME.DROP });
+  }
+  if (source.notifyPattern) {
+    rules.push({ match: String(source.notifyPattern), outcome: EVENT_OUTCOME.INJECT });
+  }
+  if (source.includePattern) {
+    rules.push({ match: String(source.includePattern), outcome: EVENT_OUTCOME.KEEP });
+    rules.push({ match: ".*", outcome: EVENT_OUTCOME.DROP });
+  }
+  return rules;
+}
+function compileRules(rules) {
+  return rules.map((r) => ({
+    match: r.match,
+    regex: compileRegex(r.match, "rule.match"),
+    outcome: r.outcome
+  }));
+}
+function createEventFilter(source = {}, fallbackOwnership = OWNERSHIP.MODEL_OWNED, fallbackLifespan = LIFESPAN.TEMPORARY) {
+  const rawRules = Array.isArray(source.rules) ? source.rules : legacyToRules(source);
+  return {
+    rules: compileRules(rawRules),
+    ownership: normalizeOwnership(source.ownership ?? source.managedBy, fallbackOwnership),
+    lifespan: normalizeLifespan(source.lifespan ?? source.scope, fallbackLifespan)
+  };
+}
+function evaluateEventFilter(filter, text) {
+  if (!filter || !filter.rules) {
+    return EVENT_OUTCOME.KEEP;
+  }
+  for (const rule of filter.rules) {
+    if (rule.regex && rule.regex.test(text)) {
+      return rule.outcome;
+    }
+  }
+  return EVENT_OUTCOME.KEEP;
+}
+function getEventFilterInput(source = {}) {
+  if (source.eventFilter && typeof source.eventFilter === "object") {
+    return source.eventFilter;
+  }
+  if (source.classifier && typeof source.classifier === "object") {
+    return source.classifier;
+  }
+  return {
+    rules: source.rules,
+    includePattern: source.includePattern,
+    excludePattern: source.excludePattern,
+    notifyPattern: source.notifyPattern,
+    ownership: source.filterOwnership ?? source.classifierManagedBy ?? source.ownership ?? source.managedBy,
+    lifespan: source.lifespan ?? source.scope
+  };
+}
+function formatEventFilter(filter) {
+  if (!filter || !filter.rules || filter.rules.length === 0) {
+    return `rules=<none> lifespan=${filter?.lifespan ?? "?"} ownership=${filter?.ownership ?? "?"}`;
+  }
+  const rulesSummary = filter.rules.map((r) => `${r.outcome}:${JSON.stringify(r.match)}`).join(", ");
+  return `rules=[${rulesSummary}] lifespan=${filter.lifespan} ownership=${filter.ownership}`;
+}
+
+// src/util/path.mjs
+import path3 from "node:path";
+function resolveRequestedCwd(baseCwd, requestedCwd) {
+  if (!requestedCwd) {
+    return baseCwd;
+  }
+  return path3.resolve(baseCwd, requestedCwd);
+}
+
+// src/emitter/state.mjs
+function buildEmitterState(spec, baseCwd, defaults = {}) {
+  const name = normalizeName(spec.name);
+  if (!name) {
+    throw new Error("Emitter name is required.");
+  }
+  const command = String(spec.command ?? "").trim();
+  const prompt = String(spec.prompt ?? "").trim();
+  if (!command && !prompt) {
+    throw new Error(`Emitter '${name}' must define either a command or a prompt.`);
+  }
+  if (command && prompt) {
+    throw new Error(`Emitter '${name}' cannot define both command and prompt. Choose one emitter type.`);
+  }
+  const interval = parseLoopInterval(spec.every);
+  const lifespan = normalizeLifespan(spec.scope, defaults.scope ?? LIFESPAN.TEMPORARY);
+  const ownership = normalizeOwnership(spec.managedBy, defaults.managedBy ?? OWNERSHIP.MODEL_OWNED);
+  const eventFilter = createEventFilter(
+    getEventFilterInput(spec),
+    spec.classifier?.managedBy ?? ownership,
+    lifespan
+  );
+  const emitterType = prompt ? EMITTER_TYPE.PROMPT : EMITTER_TYPE.COMMAND;
+  let runSchedule;
+  if (interval?.idle) {
+    if (!prompt) {
+      throw new Error(`Emitter '${name}': every='idle' is only valid for prompt emitters, not command emitters.`);
+    }
+    runSchedule = RUN_SCHEDULE.IDLE;
+  } else if (interval) {
+    runSchedule = RUN_SCHEDULE.TIMED;
+  } else if (prompt) {
+    runSchedule = RUN_SCHEDULE.ONE_TIME;
+  } else {
+    runSchedule = RUN_SCHEDULE.CONTINUOUS;
+  }
+  const maxRuns = spec.maxRuns != null ? Math.max(1, Math.floor(Number(spec.maxRuns))) : null;
+  return {
+    name,
+    description: String(spec.description ?? "").trim(),
+    command: command || null,
+    prompt: prompt || null,
+    emitterType,
+    runSchedule,
+    every: interval?.text ?? null,
+    everyMs: interval?.ms ?? null,
+    requestedCwd: spec.cwd ?? null,
+    cwd: resolveRequestedCwd(baseCwd, spec.cwd),
+    stream: normalizeName(spec.channel, name),
+    autoStart: spec.autoStart !== false,
+    includeStderr: spec.includeStderr !== false,
+    lifespan,
+    ownership,
+    eventFilter,
+    maxRuns,
+    startedAt: nowIso(),
+    stoppedAt: null,
+    lineCount: 0,
+    droppedLineCount: 0,
+    status: runSchedule === RUN_SCHEDULE.CONTINUOUS ? EMITTER_STATUS.RUNNING : EMITTER_STATUS.QUEUED,
+    stopRequested: false,
+    timer: null,
+    inFlight: false,
+    runCount: 0,
+    lastRunAt: null,
+    lastRunStatus: null,
+    process: null,
+    stdoutReader: null,
+    stderrReader: null,
+    exitCode: null
+  };
+}
+
+// src/emitter/line-router.mjs
+function createLineRouter({ streams, notifications, sessionPort }) {
+  function appendSystemMessage(emitter, text, notify = false) {
+    streams.append(emitter.stream, {
+      source: SOURCE.SYSTEM,
+      text,
+      monitorName: emitter.name
+    });
+    if (notify && streams.ensure(emitter.stream).sessionInjector.enabled) {
+      notifications.enqueue({
+        channel: emitter.stream,
+        monitorName: emitter.name,
+        stream: STREAM.SYSTEM,
+        text
+      });
+    }
+  }
+  function handleLine(emitter, rawText, stream, source) {
+    const text = String(rawText ?? "").trim();
+    if (!text) {
+      return;
+    }
+    const outcome = evaluateEventFilter(emitter.eventFilter, text);
+    if (outcome === EVENT_OUTCOME.DROP) {
+      emitter.droppedLineCount += 1;
+      return;
+    }
+    emitter.lineCount += 1;
+    streams.append(emitter.stream, {
+      source,
+      text,
+      monitorName: emitter.name,
+      stream
+    });
+    if (outcome === EVENT_OUTCOME.SURFACE) {
+      if (sessionPort && sessionPort.log) {
+        sessionPort.log(`${BRAND} ${emitter.name}: ${text}`);
+      }
+    } else if (outcome === EVENT_OUTCOME.INJECT) {
+      notifications.enqueue({
+        channel: emitter.stream,
+        monitorName: emitter.name,
+        stream,
+        text
+      });
+    }
+  }
+  function handleTextBlock(emitter, value, stream, source) {
+    for (const line of splitTextLines(value)) {
+      handleLine(emitter, line, stream, source);
+    }
+  }
+  function handlePromptResult(emitter, value) {
+    for (const line of splitTextLines(value)) {
+      const text = String(line ?? "").trim();
+      if (!text) {
+        continue;
+      }
+      emitter.lineCount += 1;
+      streams.append(emitter.stream, {
+        source: SOURCE.EMITTER_PROMPT,
+        text,
+        monitorName: emitter.name,
+        stream: STREAM.PROMPT
+      });
+      notifications.enqueue({
+        channel: emitter.stream,
+        monitorName: emitter.name,
+        stream: STREAM.PROMPT,
+        text
+      });
+    }
+  }
+  return { handleLine, handleTextBlock, handlePromptResult, appendSystemMessage };
+}
+
+// src/format/emitter.mjs
+function describeEmitterWork(emitter) {
+  if (emitter.command) {
+    return `command=${emitter.command}`;
+  }
+  return `prompt=${JSON.stringify(previewText(emitter.prompt, 90))}`;
+}
+function formatRunningEmitter(emitter, stream) {
+  return [
+    `- ${emitter.name}:`,
+    `  status=${emitter.status}`,
+    `  scope=${emitter.scope}`,
+    `  managedBy=${emitter.managedBy}`,
+    `  emitterType=${emitter.emitterType}`,
+    `  runSchedule=${emitter.runSchedule}`,
+    `  stream=${emitter.channel}`,
+    `  sessionInjector=${stream?.sessionInjector?.enabled ? "on" : "off"}`,
+    `  cwd=${emitter.cwd}`,
+    `  ${describeEmitterWork(emitter)}`,
+    emitter.every ? `  every=${emitter.every}` : null,
+    emitter.maxRuns ? `  maxRuns=${emitter.maxRuns}` : null,
+    `  autoStart=${emitter.autoStart}`,
+    `  includeStderr=${emitter.includeStderr}`,
+    `  runs=${emitter.runCount}`,
+    `  acceptedLines=${emitter.lineCount}`,
+    `  droppedLines=${emitter.droppedLineCount}`,
+    `  eventFilter=${formatEventFilter(emitter.eventFilter)}`,
+    emitter.description ? `  description=${emitter.description}` : null,
+    emitter.lastRunAt ? `  lastRunAt=${emitter.lastRunAt}` : null,
+    emitter.lastRunStatus ? `  lastRunStatus=${emitter.lastRunStatus}` : null,
+    emitter.exitCode !== null && emitter.exitCode !== void 0 ? `  exitCode=${emitter.exitCode}` : null
+  ].filter(Boolean).join("\n");
+}
+function formatConfiguredEmitter(entry) {
+  const eventFilter = createEventFilter(
+    getEventFilterInput(entry),
+    entry.eventFilter?.managedBy ?? entry.classifier?.managedBy ?? entry.managedBy ?? OWNERSHIP.USER_OWNED,
+    LIFESPAN.PERSISTENT
+  );
+  const prompt = entry.prompt ? `  prompt=${JSON.stringify(previewText(entry.prompt, 90))}` : null;
+  const command = entry.command ? `  command=${entry.command}` : null;
+  const every = entry.every ? `  every=${entry.every}` : null;
+  const emitterType = entry.prompt ? EMITTER_TYPE.PROMPT : EMITTER_TYPE.COMMAND;
+  const runSchedule = entry.every ? entry.every === "idle" && entry.prompt ? RUN_SCHEDULE.IDLE : RUN_SCHEDULE.TIMED : entry.prompt ? RUN_SCHEDULE.ONE_TIME : RUN_SCHEDULE.CONTINUOUS;
+  return [
+    `- ${normalizeName(entry.name)}:`,
+    "  status=configured",
+    `  scope=${LIFESPAN.PERSISTENT}`,
+    `  managedBy=${normalizeOwnership(entry.managedBy, OWNERSHIP.USER_OWNED)}`,
+    `  emitterType=${emitterType}`,
+    `  runSchedule=${runSchedule}`,
+    `  stream=${normalizeName(entry.channel, normalizeName(entry.name))}`,
+    `  autoStart=${entry.autoStart !== false}`,
+    `  includeStderr=${entry.includeStderr !== false}`,
+    entry.cwd ? `  cwd=${entry.cwd}` : null,
+    command,
+    prompt,
+    every,
+    `  eventFilter=${formatEventFilter(eventFilter)}`,
+    entry.description ? `  description=${entry.description}` : null
+  ].filter(Boolean).join("\n");
+}
+
+// src/emitter/spawn.mjs
+import { spawn } from "node:child_process";
+import readline from "node:readline";
+function spawnEmitterProcess(command, cwd) {
+  if (process.platform === "win32") {
+    return spawn("powershell.exe", ["-NoLogo", "-NoProfile", "-Command", command], {
+      cwd,
+      env: process.env,
+      windowsHide: true
+    });
+  }
+  return spawn("bash", ["-lc", command], {
+    cwd,
+    env: process.env
+  });
+}
+function readLines(input, onLine) {
+  const reader = readline.createInterface({ input });
+  reader.on("line", onLine);
+  return reader;
+}
+
+// src/emitter/lifecycle.mjs
+function createLifecycle({ lineRouter, sessionPort }) {
+  function wireStreams(emitter) {
+    const child = emitter.process;
+    emitter.stdoutReader = readLines(child.stdout, (line) => {
+      lineRouter.handleLine(emitter, line, STREAM.STDOUT, SOURCE.EMITTER);
+    });
+    emitter.stderrReader = readLines(child.stderr, (line) => {
+      lineRouter.handleLine(emitter, line, STREAM.STDERR, SOURCE.EMITTER_STDERR);
+    });
+  }
+  function closeStreams(emitter) {
+    if (emitter.stdoutReader) {
+      emitter.stdoutReader.close();
+      emitter.stdoutReader = null;
+    }
+    if (emitter.stderrReader) {
+      emitter.stderrReader.close();
+      emitter.stderrReader = null;
+    }
+  }
+  function startContinuousProcess(emitter) {
+    let child;
+    try {
+      child = spawnEmitterProcess(emitter.command, emitter.cwd);
+    } catch (error) {
+      throw new Error(`Failed to start emitter '${emitter.name}': ${error.message}`);
+    }
+    emitter.process = child;
+    emitter.status = EMITTER_STATUS.RUNNING;
+    wireStreams(emitter);
+    child.on("error", (error) => {
+      emitter.status = EMITTER_STATUS.ERROR;
+      emitter.process = null;
+      lineRouter.appendSystemMessage(emitter, `Emitter '${emitter.name}' failed: ${error.message}`, true);
+      void sessionPort.log(`Emitter '${emitter.name}' failed: ${error.message}`, { level: "warning" });
+    });
+    child.on("exit", (code, signal) => {
+      emitter.status = emitter.stopRequested ? EMITTER_STATUS.STOPPED : EMITTER_STATUS.EXITED;
+      emitter.exitCode = code;
+      emitter.stoppedAt = nowIso();
+      emitter.process = null;
+      emitter.stdoutReader = null;
+      emitter.stderrReader = null;
+      const exitMessage = emitter.stopRequested ? `Emitter '${emitter.name}' stopped.` : `Emitter '${emitter.name}' exited with code ${code ?? "null"}${signal ? ` (${signal})` : ""}.`;
+      lineRouter.appendSystemMessage(emitter, exitMessage, !emitter.stopRequested);
+      void sessionPort.log(exitMessage);
+    });
+    lineRouter.appendSystemMessage(
+      emitter,
+      `Emitter '${emitter.name}' started with ${describeEmitterWork(emitter)}.`
+    );
+  }
+  async function runCommandLoopIteration(emitter) {
+    let child;
+    try {
+      child = spawnEmitterProcess(emitter.command, emitter.cwd);
+    } catch (error) {
+      return { ok: false, error: error.message };
+    }
+    emitter.process = child;
+    wireStreams(emitter);
+    return await new Promise((resolve) => {
+      let settled = false;
+      const finish = (result) => {
+        if (settled) {
+          return;
+        }
+        settled = true;
+        closeStreams(emitter);
+        emitter.process = null;
+        emitter.exitCode = result.code ?? emitter.exitCode;
+        resolve(result);
+      };
+      child.on("error", (error) => {
+        finish({ ok: false, error: error.message });
+      });
+      child.on("exit", (code, signal) => {
+        finish({
+          ok: (code ?? 0) === 0 || emitter.stopRequested,
+          code,
+          signal,
+          error: (code ?? 0) === 0 || emitter.stopRequested ? null : `Command iteration exited with code ${code ?? "null"}${signal ? ` (${signal})` : ""}`
+        });
+      });
+    });
+  }
+  async function runPromptIteration(emitter) {
+    try {
+      const response = await sessionPort.sendAndWait(emitter.prompt);
+      if (emitter.stopRequested) {
+        return { ok: true };
+      }
+      const responseText = toText(response?.data?.content ?? response?.data ?? response);
+      if (responseText.trim()) {
+        lineRouter.handlePromptResult(emitter, responseText);
+      } else {
+        lineRouter.appendSystemMessage(
+          emitter,
+          `Emitter '${emitter.name}' received an empty response from prompt work.`
+        );
+      }
+      return { ok: true };
+    } catch (error) {
+      return {
+        ok: false,
+        error: error.message,
+        deferred: (emitter.runSchedule === RUN_SCHEDULE.TIMED || emitter.runSchedule === RUN_SCHEDULE.IDLE) && /\bsession\.idle\b/i.test(String(error?.message ?? ""))
+      };
+    }
+  }
+  function scheduleIteration(emitter, delayMs = 0) {
+    if (emitter.stopRequested) {
+      return;
+    }
+    if (emitter.timer) {
+      clearTimeout(emitter.timer);
+    }
+    emitter.status = delayMs > 0 ? EMITTER_STATUS.WAITING : EMITTER_STATUS.QUEUED;
+    emitter.timer = setTimeout(() => {
+      emitter.timer = null;
+      void runScheduledIteration(emitter);
+    }, delayMs);
+  }
+  async function runScheduledIteration(emitter) {
+    if (emitter.stopRequested || emitter.inFlight) {
+      return;
+    }
+    emitter.inFlight = true;
+    emitter.status = EMITTER_STATUS.RUNNING;
+    emitter.runCount += 1;
+    emitter.lastRunAt = nowIso();
+    const result = emitter.emitterType === EMITTER_TYPE.PROMPT ? await runPromptIteration(emitter) : await runCommandLoopIteration(emitter);
+    emitter.inFlight = false;
+    if (emitter.stopRequested) {
+      emitter.status = EMITTER_STATUS.STOPPED;
+      emitter.stoppedAt = nowIso();
+      lineRouter.appendSystemMessage(emitter, `Emitter '${emitter.name}' stopped.`);
+      return;
+    }
+    if (result.ok) {
+      emitter.lastRunStatus = RUN_STATUS.SUCCESS;
+      if (emitter.runSchedule === RUN_SCHEDULE.ONE_TIME) {
+        emitter.status = EMITTER_STATUS.COMPLETED;
+        emitter.stoppedAt = nowIso();
+        lineRouter.appendSystemMessage(
+          emitter,
+          `Emitter '${emitter.name}' completed one run of ${emitter.emitterType} work.`
+        );
+        return;
+      }
+      if (emitter.maxRuns && emitter.runCount >= emitter.maxRuns) {
+        emitter.status = EMITTER_STATUS.COMPLETED;
+        emitter.stoppedAt = nowIso();
+        lineRouter.appendSystemMessage(
+          emitter,
+          `Emitter '${emitter.name}' completed ${emitter.runCount} of ${emitter.maxRuns} runs.`
+        );
+        return;
+      }
+      emitter.status = EMITTER_STATUS.WAITING;
+      const delay = emitter.runSchedule === RUN_SCHEDULE.IDLE ? IDLE_PROMPT_DELAY_MS : emitter.everyMs;
+      scheduleIteration(emitter, delay);
+      return;
+    }
+    if (result.deferred) {
+      emitter.status = EMITTER_STATUS.WAITING;
+      const retryDelay = emitter.runSchedule === RUN_SCHEDULE.IDLE ? IDLE_PROMPT_BACKOFF_MS : emitter.everyMs;
+      if (emitter.runSchedule !== RUN_SCHEDULE.IDLE) {
+        lineRouter.appendSystemMessage(
+          emitter,
+          `Emitter '${emitter.name}' deferred this prompt run because the session was still busy. Next attempt in ${emitter.every}.`
+        );
+      }
+      scheduleIteration(emitter, retryDelay);
+      return;
+    }
+    emitter.lastRunStatus = RUN_STATUS.FAILURE;
+    lineRouter.appendSystemMessage(
+      emitter,
+      `Emitter '${emitter.name}' iteration failed: ${result.error ?? "unknown error"}.`,
+      true
+    );
+    void sessionPort.log(
+      `Emitter '${emitter.name}' iteration failed: ${result.error ?? "unknown error"}.`,
+      { level: "warning" }
+    );
+    if (emitter.runSchedule === RUN_SCHEDULE.ONE_TIME) {
+      emitter.status = EMITTER_STATUS.ERROR;
+      emitter.stoppedAt = nowIso();
+      return;
+    }
+    emitter.status = EMITTER_STATUS.WAITING;
+    const failRetryDelay = emitter.runSchedule === RUN_SCHEDULE.IDLE ? IDLE_PROMPT_BACKOFF_MS : emitter.everyMs;
+    scheduleIteration(emitter, failRetryDelay);
+  }
+  function startScheduled(emitter) {
+    const scheduleLabel = emitter.runSchedule === RUN_SCHEDULE.TIMED ? `every ${emitter.every}` : emitter.runSchedule === RUN_SCHEDULE.IDLE ? "when idle" : RUN_SCHEDULE.ONE_TIME;
+    const initialDelayMs = 0;
+    const firstRunLabel = "";
+    lineRouter.appendSystemMessage(
+      emitter,
+      `Emitter '${emitter.name}' queued ${emitter.emitterType} work (${scheduleLabel}) with ${describeEmitterWork(emitter)}.${firstRunLabel}`
+    );
+    scheduleIteration(emitter, initialDelayMs);
+  }
+  function start(emitter) {
+    if (emitter.runSchedule === RUN_SCHEDULE.CONTINUOUS) {
+      startContinuousProcess(emitter);
+    } else {
+      startScheduled(emitter);
+    }
+  }
+  async function stop(emitter) {
+    if (isTerminalEmitterStatus(emitter.status)) {
+      return;
+    }
+    emitter.stopRequested = true;
+    void sessionPort.log(`Stop requested for emitter '${emitter.name}'.`);
+    if (emitter.timer) {
+      clearTimeout(emitter.timer);
+      emitter.timer = null;
+    }
+    if (!emitter.process && !emitter.inFlight) {
+      emitter.status = EMITTER_STATUS.STOPPED;
+      emitter.stoppedAt = nowIso();
+      lineRouter.appendSystemMessage(emitter, `Emitter '${emitter.name}' stopped.`);
+      void sessionPort.log(`Emitter '${emitter.name}' stopped.`);
+      return;
+    }
+    emitter.status = EMITTER_STATUS.STOPPING;
+    closeStreams(emitter);
+    if (emitter.process) {
+      emitter.process.kill();
+    }
+  }
+  return { start, stop };
+}
+
+// src/emitter/supervisor.mjs
+function createEmitterSupervisor({ streams, configStore, notifications, sessionPort, getBaseCwd, persist }) {
+  const emitters = /* @__PURE__ */ new Map();
+  const lineRouter = createLineRouter({ streams, notifications });
+  const lifecycle = createLifecycle({ lineRouter, sessionPort });
+  async function start(spec, options = {}) {
+    const baseCwd = options.baseCwd ?? getBaseCwd();
+    const emitter = buildEmitterState(spec, baseCwd, options);
+    const existing = emitters.get(emitter.name);
+    if (existing && !isTerminalEmitterStatus(existing.status)) {
+      throw new Error(`Emitter '${emitter.name}' is already active.`);
+    }
+    if (existing) {
+      assertMutable(existing.ownership, options.force, `Emitter '${emitter.name}'`);
+    }
+    streams.ensure(emitter.stream, emitter.description || `Events for ${emitter.name}`);
+    emitters.set(emitter.name, emitter);
+    try {
+      lifecycle.start(emitter);
+    } catch (error) {
+      emitters.delete(emitter.name);
+      throw error;
+    }
+    if (options.subscribe === true) {
+      const stream = streams.configureSessionInjector(emitter.stream, {
+        enabled: true,
+        delivery: options.delivery ?? EVENT_OUTCOME.SURFACE,
+        scope: options.scope ?? emitter.lifespan,
+        managedBy: options.managedBy ?? emitter.ownership,
+        description: spec.channelDescription ?? emitter.description,
+        force: options.force
+      });
+      void sessionPort.log(
+        `${stream.sessionInjector.enabled ? "Subscribed" : "Unsubscribed"} stream '${stream.name}' with delivery=${stream.sessionInjector.delivery} lifespan=${stream.sessionInjector.lifespan} ownership=${stream.sessionInjector.ownership}.`
+      );
+      if (stream.sessionInjector.lifespan === LIFESPAN.PERSISTENT) {
+        configStore.upsertStream(stream);
+      }
+    }
+    if (emitter.lifespan === LIFESPAN.PERSISTENT) {
+      configStore.upsertEmitter(emitter);
+      persist();
+    } else if (options.subscribe === true && streams.ensure(emitter.stream).sessionInjector.lifespan === LIFESPAN.PERSISTENT) {
+      persist();
+    }
+    await sessionPort.log(
+      `Started emitter '${emitter.name}' (${emitter.emitterType}, ${emitter.runSchedule}) on stream '${emitter.stream}' in ${emitter.cwd}.`
+    );
+    return emitter;
+  }
+  async function stop(name, options = {}) {
+    const normalized = normalizeName(name);
+    const lifespan = normalizeLifespan(options.scope, LIFESPAN.TEMPORARY);
+    const emitter = emitters.get(normalized);
+    if (emitter) {
+      assertMutable(emitter.ownership, options.force, `Emitter '${normalized}'`);
+      await lifecycle.stop(emitter);
+    }
+    if (lifespan === LIFESPAN.PERSISTENT) {
+      const removed = configStore.removeEmitter(normalized, options.force);
+      if (removed) {
+        persist();
+        void sessionPort.log(`Removed persistent emitter '${normalized}' from config.`);
+      }
+      if (!emitter && !removed) {
+        throw new Error(`Emitter '${normalized}' was not found in the session or persistent config.`);
+      }
+      return {
+        name: normalized,
+        status: removed ? EMITTER_OPERATION_STATUS.REMOVED_FROM_CONFIG : emitter?.status ?? EMITTER_STATUS.STOPPED
+      };
+    }
+    if (!emitter) {
+      throw new Error(`Emitter '${normalized}' is not running in this session.`);
+    }
+    return emitter;
+  }
+  function updateEventFilter(name, input, options = {}) {
+    const normalized = normalizeName(name);
+    const lifespan = normalizeLifespan(options.scope, LIFESPAN.TEMPORARY);
+    const ownership = normalizeOwnership(options.managedBy, OWNERSHIP.MODEL_OWNED);
+    const emitter = emitters.get(normalized);
+    const configEntry = configStore.findEmitter(normalized);
+    if (emitter) {
+      assertMutable(emitter.eventFilter.managedBy, options.force, `Event filter for emitter '${normalized}'`);
+      emitter.eventFilter = createEventFilter(
+        {
+          includePattern: input.includePattern ?? emitter.eventFilter.includePattern,
+          excludePattern: input.excludePattern ?? emitter.eventFilter.excludePattern,
+          notifyPattern: input.notifyPattern ?? emitter.eventFilter.notifyPattern,
+          managedBy: options.managedBy ?? emitter.eventFilter.managedBy,
+          scope: lifespan
+        },
+        ownership,
+        lifespan
+      );
+      if (lifespan === LIFESPAN.PERSISTENT) {
+        emitter.lifespan = LIFESPAN.PERSISTENT;
+        configStore.upsertEmitter(emitter);
+        persist();
+      }
+      void sessionPort.log(`Updated event filter for emitter '${normalized}': ${formatEventFilter(emitter.eventFilter)}`);
+      return emitter;
+    }
+    if (lifespan !== LIFESPAN.PERSISTENT || !configEntry) {
+      throw new Error(`Emitter '${normalized}' is not running, so only a persistent event filter update is possible when it exists in config.`);
+    }
+    assertMutable(
+      normalizeOwnership(configEntry.eventFilter?.managedBy ?? configEntry.classifier?.managedBy ?? configEntry.managedBy, OWNERSHIP.USER_OWNED),
+      options.force,
+      `Event filter for emitter '${normalized}'`
+    );
+    configEntry.eventFilter = {
+      includePattern: input.includePattern ?? configEntry.eventFilter?.includePattern ?? configEntry.classifier?.includePattern,
+      excludePattern: input.excludePattern ?? configEntry.eventFilter?.excludePattern ?? configEntry.classifier?.excludePattern,
+      notifyPattern: input.notifyPattern ?? configEntry.eventFilter?.notifyPattern ?? configEntry.classifier?.notifyPattern,
+      managedBy: ownership
+    };
+    persist();
+    void sessionPort.log(`Updated persistent event filter for emitter '${normalized}': ${formatEventFilter(configEntry.eventFilter)}`);
+    return {
+      name: normalized,
+      status: EMITTER_OPERATION_STATUS.CONFIGURED,
+      eventFilter: createEventFilter(configEntry.eventFilter, ownership, LIFESPAN.PERSISTENT)
+    };
+  }
+  async function stopAll() {
+    const active = [...emitters.values()].filter((emitter) => !isTerminalEmitterStatus(emitter.status));
+    await Promise.allSettled(active.map((emitter) => lifecycle.stop(emitter)));
+  }
+  function list() {
+    return [...emitters.values()].sort((left, right) => left.name.localeCompare(right.name));
+  }
+  function has(name) {
+    return emitters.has(normalizeName(name));
+  }
+  function get(name) {
+    return emitters.get(normalizeName(name));
+  }
+  return {
+    start,
+    stop,
+    stopAll,
+    updateEventFilter,
+    list,
+    has,
+    get
+  };
+}
+
+// src/format/stream.mjs
+function formatSessionInjector(stream) {
+  const sessionInjector = stream.sessionInjector;
+  const state = sessionInjector.enabled ? "on" : "off";
+  return `sessionInjector=${state} delivery=${sessionInjector.delivery} lifespan=${sessionInjector.lifespan} ownership=${sessionInjector.ownership}`;
+}
+function formatStream(stream) {
+  const latest = stream.entries[stream.entries.length - 1];
+  const latestSummary = latest ? ` latest=${JSON.stringify(latest.text.slice(0, 80))}` : "";
+  const description = stream.description ? ` description=${JSON.stringify(stream.description)}` : "";
+  return `- ${stream.name}: messages=${stream.entries.length}${description} ${formatSessionInjector(stream)}${latestSummary}`;
+}
+function formatStreamHistory(stream, limit) {
+  const entries = stream.entries.slice(-limit);
+  if (entries.length === 0) {
+    return `Stream '${stream.name}' is empty.`;
+  }
+  return [
+    `Stream '${stream.name}' (${entries.length} of ${stream.entries.length} entries):`,
+    ...entries.map((entry) => {
+      const emitterLabel = entry.monitorName ? ` emitter=${entry.monitorName}` : "";
+      const streamLabel = entry.stream ? ` stream=${entry.stream}` : "";
+      return `[${entry.timestamp}] source=${entry.source}${emitterLabel}${streamLabel} ${entry.text}`;
+    })
+  ].join("\n");
+}
+
+// src/tools/channels.mjs
+function applySessionInjector({ streams, configStore, sessionPort, persist }, rawName, options) {
+  const stream = streams.configureSessionInjector(rawName, options);
+  void sessionPort.log(
+    `${stream.sessionInjector.enabled ? "Subscribed" : "Unsubscribed"} stream '${stream.name}' with delivery=${stream.sessionInjector.delivery} lifespan=${stream.sessionInjector.lifespan} ownership=${stream.sessionInjector.ownership}.`
+  );
+  if (stream.sessionInjector.lifespan === LIFESPAN.PERSISTENT) {
+    configStore.upsertStream(stream);
+    persist();
+  }
+  return stream;
+}
+function renderStreamList(streams) {
+  streams.ensure(DEFAULT_STREAM, DEFAULT_STREAM_DESCRIPTION);
+  const values = streams.list();
+  return [
+    `Streams (${values.length}):`,
+    ...values.map((stream) => formatStream(stream))
+  ].join("\n");
+}
+function createStreamTools(deps) {
+  const { streams, sessionPort } = deps;
+  return [
+    {
+      name: "tap_list_streams",
+      description: "Lists event streams, session injector state, and recent metadata.",
+      handler: async () => renderStreamList(streams)
+    },
+    {
+      name: "tap_post",
+      description: "Posts a note into a named event stream for later retrieval.",
+      parameters: {
+        type: "object",
+        properties: {
+          channel: { type: "string", description: "EventStream name." },
+          message: { type: "string", description: "Text to append." },
+          source: { type: "string", description: "Optional source label." },
+          description: { type: "string", description: "Optional stream description when creating it." }
+        },
+        required: ["channel", "message"]
+      },
+      handler: async (args) => {
+        const stream = streams.ensure(args.channel, args.description ?? "");
+        streams.append(stream.name, {
+          source: args.source || SOURCE.TOOL,
+          text: args.message
+        });
+        void sessionPort.log(`Posted message to stream '${stream.name}'.`);
+        return `Posted to stream '${stream.name}'.`;
+      }
+    },
+    {
+      name: "tap_stream_history",
+      description: "Returns recent entries from a named event stream.",
+      parameters: {
+        type: "object",
+        properties: {
+          channel: { type: "string", description: "EventStream name to inspect." },
+          limit: { type: "number", description: "How many recent entries to return." }
+        },
+        required: ["channel"]
+      },
+      handler: async (args) => {
+        const streamName = normalizeName(args.channel);
+        const stream = streams.get(streamName);
+        if (!stream) {
+          throw new Error(`Stream '${streamName}' does not exist.`);
+        }
+        return formatStreamHistory(stream, clampLimit(args.limit, 20));
+      }
+    },
+    {
+      name: "tap_enable_injector",
+      description: "Attaches a session injector to an event stream for this session or persistently.",
+      parameters: {
+        type: "object",
+        properties: {
+          channel: { type: "string", description: "EventStream name." },
+          description: { type: "string", description: "Optional stream description." },
+          delivery: { type: "string", description: "Event outcome mode: 'important' or 'all'." },
+          scope: { type: "string", description: "Use 'temporary' for session-only or 'persistent' to write config." },
+          managedBy: { type: "string", description: "Ownership label: 'userOwned' or 'modelOwned'." },
+          force: { type: "boolean", description: "Required only when transferring ownership of a protected session injector." }
+        },
+        required: ["channel"]
+      },
+      handler: async (args) => {
+        const stream = applySessionInjector(deps, args.channel, {
+          enabled: true,
+          delivery: args.delivery ?? EVENT_OUTCOME.SURFACE,
+          scope: args.scope ?? LIFESPAN.TEMPORARY,
+          managedBy: args.managedBy ?? OWNERSHIP.MODEL_OWNED,
+          description: args.description ?? "",
+          force: args.force === true
+        });
+        return `Attached session injector to stream '${stream.name}' with delivery=${stream.sessionInjector.delivery} lifespan=${stream.sessionInjector.lifespan} ownership=${stream.sessionInjector.ownership}.`;
+      }
+    },
+    {
+      name: "tap_disable_injector",
+      description: "Disables the session injector for an event stream.",
+      parameters: {
+        type: "object",
+        properties: {
+          channel: { type: "string", description: "EventStream name." },
+          scope: { type: "string", description: "Use 'temporary' or 'persistent'." },
+          managedBy: { type: "string", description: "Ownership label after the update: 'userOwned' or 'modelOwned'." },
+          force: { type: "boolean", description: "Required only when transferring ownership of a protected session injector." }
+        },
+        required: ["channel"]
+      },
+      handler: async (args) => {
+        const stream = applySessionInjector(deps, args.channel, {
+          enabled: false,
+          delivery: args.delivery ?? EVENT_OUTCOME.SURFACE,
+          scope: args.scope ?? LIFESPAN.TEMPORARY,
+          managedBy: args.managedBy ?? OWNERSHIP.MODEL_OWNED,
+          force: args.force === true
+        });
+        return `Disabled session injector for stream '${stream.name}' with lifespan=${stream.sessionInjector.lifespan} ownership=${stream.sessionInjector.ownership}.`;
+      }
+    }
+  ];
+}
+
+// src/tools/monitors.mjs
+function renderEmitterList(streams, configStore, supervisor) {
+  const running = supervisor.list();
+  const configured = configStore.getEmitters().filter((entry) => !supervisor.has(entry.name)).sort((left, right) => normalizeName(left.name).localeCompare(normalizeName(right.name)));
+  if (running.length === 0 && configured.length === 0) {
+    return "No emitters have been defined for this session.";
+  }
+  return [
+    `Session emitters (${running.length}):`,
+    ...running.length > 0 ? running.map((emitter) => formatRunningEmitter(emitter, streams.ensure(emitter.stream))) : ["- <none>"],
+    "",
+    `Persistent emitter definitions (${configured.length}):`,
+    ...configured.length > 0 ? configured.map((entry) => formatConfiguredEmitter(entry)) : ["- <none>"]
+  ].join("\n");
+}
+function createEmitterTools({ streams, configStore, supervisor, getBaseCwd }) {
+  return [
+    {
+      name: "tap_list_emitters",
+      description: "Lists session event emitters, their run schedules, and persistent definitions.",
+      handler: async () => renderEmitterList(streams, configStore, supervisor)
+    },
+    {
+      name: "tap_start_emitter",
+      description: "Starts a command emitter, prompt emitter, or timed work item with event filter rules and optional session injector.",
+      parameters: {
+        type: "object",
+        properties: {
+          name: { type: "string", description: "Unique emitter name." },
+          command: { type: "string", description: "Shell command to run. Optional when prompt is provided." },
+          prompt: { type: "string", description: "Prompt to send to the agent. Optional when command is provided." },
+          description: { type: "string", description: "Short summary." },
+          channel: { type: "string", description: "EventStream to receive accepted events." },
+          cwd: { type: "string", description: "Optional working directory relative to the session cwd." },
+          every: { type: "string", description: "Optional repeat interval like 30s, 5m, 2h, or 1d. Use 'idle' for prompts that re-run whenever the session is idle. When omitted, commands run continuously and prompts run once." },
+          scope: { type: "string", description: "Use 'temporary' for session-only or 'persistent' to write config." },
+          managedBy: { type: "string", description: "Ownership label: 'userOwned' or 'modelOwned'." },
+          autoStart: { type: "boolean", description: "When persistent, whether the emitter should auto-start next session." },
+          includeStderr: { type: "boolean", description: "Whether stderr lines are eligible for event outcome evaluation." },
+          includePattern: { type: "string", description: "Only matching lines are admitted into the stream. (Legacy: prefer eventFilter rules.)" },
+          excludePattern: { type: "string", description: "Matching lines are dropped before they reach the stream. (Legacy: prefer eventFilter rules.)" },
+          notifyPattern: { type: "string", description: "Matching lines trigger session injection when delivery='important'. (Legacy: prefer eventFilter rules.)" },
+          subscribe: { type: "boolean", description: "Whether to attach a session injector to the stream as part of emitter creation." },
+          delivery: { type: "string", description: "Session injector event outcome mode: 'important' or 'all'." },
+          maxRuns: { type: "integer", description: "Maximum number of iterations before the emitter auto-completes. Useful for idle and timed loops." },
+          force: { type: "boolean", description: "Required only when transferring ownership of a protected emitter." }
+        },
+        required: ["name"]
+      },
+      handler: async (args) => {
+        const lifespan = args.scope ?? LIFESPAN.TEMPORARY;
+        const ownership = args.managedBy ?? OWNERSHIP.MODEL_OWNED;
+        const emitter = await supervisor.start(
+          { ...args, scope: lifespan, managedBy: ownership },
+          {
+            baseCwd: getBaseCwd(),
+            scope: lifespan,
+            managedBy: ownership,
+            subscribe: args.subscribe !== false,
+            delivery: args.delivery ?? EVENT_OUTCOME.SURFACE,
+            force: args.force === true
+          }
+        );
+        return [
+          `Started emitter '${emitter.name}'.`,
+          `lifespan=${emitter.lifespan}`,
+          `ownership=${emitter.ownership}`,
+          `emitterType=${emitter.emitterType}`,
+          `runSchedule=${emitter.runSchedule}`,
+          emitter.every ? `every=${emitter.every}` : null,
+          emitter.maxRuns ? `maxRuns=${emitter.maxRuns}` : null,
+          `stream=${emitter.stream}`,
+          `sessionInjector=${streams.ensure(emitter.stream).sessionInjector.enabled ? "on" : "off"}`,
+          `eventFilter=${formatEventFilter(emitter.eventFilter)}`
+        ].filter(Boolean).join("\n");
+      }
+    },
+    {
+      name: "tap_set_event_filter",
+      description: "Updates the event filter rules that determine event outcomes (drop, keep, surface, inject) for an emitter.",
+      parameters: {
+        type: "object",
+        properties: {
+          name: { type: "string", description: "Emitter name." },
+          includePattern: { type: "string", description: "Only matching lines are admitted into the stream." },
+          excludePattern: { type: "string", description: "Matching lines are removed from the stream." },
+          notifyPattern: { type: "string", description: "Matching lines trigger session injection when delivery='important'." },
+          scope: { type: "string", description: "Use 'temporary' for session-only or 'persistent' to write config." },
+          managedBy: { type: "string", description: "Ownership label: 'userOwned' or 'modelOwned'." },
+          force: { type: "boolean", description: "Required only when transferring ownership of a protected emitter." }
+        },
+        required: ["name"]
+      },
+      handler: async (args) => {
+        const result = supervisor.updateEventFilter(args.name, args, {
+          scope: args.scope ?? LIFESPAN.TEMPORARY,
+          managedBy: args.managedBy ?? OWNERSHIP.MODEL_OWNED,
+          force: args.force === true
+        });
+        const eventFilter = result.eventFilter ?? supervisor.get(args.name)?.eventFilter;
+        return `Updated event filter for emitter '${normalizeName(args.name)}': ${formatEventFilter(eventFilter)}`;
+      }
+    },
+    {
+      name: "tap_stop_emitter",
+      description: "Stops a running event emitter. With lifespan='persistent', also removes the stored definition from config.",
+      parameters: {
+        type: "object",
+        properties: {
+          name: { type: "string", description: "Emitter name." },
+          scope: { type: "string", description: "Use 'temporary' or 'persistent'." },
+          force: { type: "boolean", description: "Required only when transferring ownership of a protected emitter." }
+        },
+        required: ["name"]
+      },
+      handler: async (args) => {
+        const result = await supervisor.stop(args.name, {
+          scope: args.scope ?? LIFESPAN.TEMPORARY,
+          force: args.force === true
+        });
+        return `Stop requested for emitter '${normalizeName(args.name)}' (status=${result.status}).`;
+      }
+    }
+  ];
+}
+
+// src/tools/index.mjs
+function createTools(deps) {
+  return [
+    ...createStreamTools(deps),
+    ...createEmitterTools(deps)
+  ];
+}
+
+// src/hooks.mjs
+function sessionInjectorSummary(streams) {
+  const subscribed = streams.list().filter((stream) => stream.sessionInjector.enabled);
+  if (subscribed.length === 0) {
+    return "";
+  }
+  return [
+    "Session injectors:",
+    ...subscribed.map(
+      (stream) => `- ${stream.name} delivery=${stream.sessionInjector.delivery} lifespan=${stream.sessionInjector.lifespan} ownership=${stream.sessionInjector.ownership}`
+    )
+  ].join("\n");
+}
+async function applyPersistentConfig({ baseCwd, streams, configStore, supervisor, sessionPort, setBaseCwd }) {
+  setBaseCwd(baseCwd);
+  const configLoad = configStore.load(baseCwd);
+  for (const entry of configStore.getStreams()) {
+    streams.applyPersistentStream(entry);
+  }
+  let started = 0;
+  for (const entry of configStore.getEmitters()) {
+    if (entry.autoStart === false) {
+      continue;
+    }
+    try {
+      await supervisor.start(
+        {
+          ...entry,
+          scope: LIFESPAN.PERSISTENT,
+          managedBy: entry.ownership ?? OWNERSHIP.USER_OWNED
+        },
+        {
+          baseCwd,
+          scope: LIFESPAN.PERSISTENT,
+          managedBy: entry.ownership ?? OWNERSHIP.USER_OWNED,
+          subscribe: false,
+          force: true
+        }
+      );
+      started += 1;
+    } catch (error) {
+      await sessionPort.log(`Failed to auto-start emitter '${entry.name}': ${error.message}`, {
+        level: "warning"
+      });
+    }
+  }
+  return configLoad.found ? `Loaded ${configStore.getStreams().length} event streams and ${configStore.getEmitters().length} persistent emitter definitions from ${configLoad.filePath}. Auto-started ${started}.` : "No copilot-channels config file found.";
+}
+function createHooks({ streams, configStore, supervisor, sessionPort, setBaseCwd }) {
+  return {
+    onSessionStart: async (input) => {
+      streams.ensure(DEFAULT_STREAM, DEFAULT_STREAM_DESCRIPTION);
+      let configSummary = "No config loaded.";
+      try {
+        configSummary = await applyPersistentConfig({
+          baseCwd: input.cwd,
+          streams,
+          configStore,
+          supervisor,
+          sessionPort,
+          setBaseCwd
+        });
+        await sessionPort.log(configSummary);
+      } catch (error) {
+        configSummary = `Config load failed: ${error.message}`;
+        await sessionPort.log(configSummary, { level: "warning" });
+      }
+      return {
+        additionalContext: [
+          `${BRAND} is active.`,
+          "Use event emitters to run background commands or prompts; use event filters to control which events are kept, surfaced, or injected; use session injectors when you want events surfaced or injected into the session.",
+          "Session injector updates are sent immediately from emitter output and do not wait for transcript events.",
+          `Repo guidance is available at ${COPILOT_INSTRUCTIONS_PATH} if you want to read the project-specific instructions.`,
+          configSummary,
+          sessionInjectorSummary(streams)
+        ].filter(Boolean).join("\n")
+      };
+    },
+    onUserPromptSubmitted: async () => {
+      const summary = sessionInjectorSummary(streams);
+      if (!summary) {
+        return void 0;
+      }
+      return { additionalContext: summary };
+    },
+    onSessionEnd: async () => {
+      await supervisor.stopAll();
+      return {
+        sessionSummary: `${BRAND} tracked ${streams.size()} event streams and ${configStore.getEmitters().length} persistent emitter definitions.`,
+        cleanupActions: [`Stopped session emitters managed by ${BRAND}.`]
+      };
+    }
+  };
+}
+
+// src/tap-runtime.mjs
+function createCopilotChannelsRuntime(options = {}) {
+  let baseCwd = options.cwd ?? process.cwd();
+  const getBaseCwd = () => baseCwd;
+  const setBaseCwd = (next) => {
+    baseCwd = next;
+  };
+  const sessionPort = createSessionPort(options.session ?? null);
+  const streams = createStreamStore();
+  const configStore = createConfigStore({ cwd: baseCwd });
+  const notifications = createNotificationDispatcher({ sessionPort });
+  const persist = () => configStore.save();
+  const supervisor = createEmitterSupervisor({
+    streams,
+    configStore,
+    notifications,
+    sessionPort,
+    getBaseCwd,
+    persist
+  });
+  const tools = createTools({ streams, configStore, supervisor, sessionPort, getBaseCwd, persist });
+  const hooks = createHooks({ streams, configStore, supervisor, sessionPort, setBaseCwd });
+  return {
+    attachSession: (nextSession) => sessionPort.attach(nextSession),
+    tools,
+    hooks,
+    stopAllEmitters: () => supervisor.stopAll(),
+    appendStreamMessage: (name, entry) => streams.append(name, entry),
+    DEFAULT_STREAM
+  };
+}
+
+// .github/extensions/tap/extension.mjs
+var runtime = createCopilotChannelsRuntime({
+  cwd: process.cwd()
+});
+var session = await joinSession({
+  tools: runtime.tools,
+  hooks: runtime.hooks
+});
+runtime.attachSession(session);
+runtime.appendStreamMessage(runtime.DEFAULT_STREAM, {
+  source: "system",
+  text: "\u203B tap loaded."
+});
+session.on("session.shutdown", () => {
+  void runtime.stopAllEmitters();
+});