copilot-tap-extension 1.1.2 → 1.1.4

package/README.md

@@ -62,7 +62,7 @@ npx copilot-tap-extension
 npx copilot-tap-extension --local
 ```
 
-This installs the bundled extension, the `/loop` skill, and the agent instructions to the appropriate Copilot directory. Run `npx copilot-tap-extension --help` for all options.
+This installs the bundled extension, the `/loop` skill, the `/monitor` skill, and the agent instructions to the appropriate Copilot directory. Run `npx copilot-tap-extension --help` for all options.
 
 To update to the latest version, re-run the same command with `--force`:
 
@@ -109,6 +109,8 @@ Once inside the session, describe what you want in natural language. You can als
 
 > _"/loop 5m check for new PR review comments"_
 
+> _"/monitor tail -f /var/log/app.log"_
+
 > _"Tail the API logs, inject errors, drop health checks"_
 
 The agent translates these into emitter and filter configurations behind the scenes.
@@ -171,6 +173,17 @@ Tell Copilot to watch a log, build, or command. It creates a CommandEmitter, fil
 
 You keep coding. Twenty minutes later, Copilot interrupts: "Run 48291: deployment rollback triggered on prod."
 
+**Monitor a command with self-tuning filters**
+
+Use `/monitor` to run a shell command continuously while a companion agent periodically reads the output and updates the filter expressions to separate noise from signal automatically.
+
+```
+/monitor tail -f /var/log/app.log
+/monitor 10m docker logs -f mycontainer
+```
+
+The command stream starts with a sensible initial `notifyPattern`. Every few minutes (configurable) the companion reviews recent log lines and calls `tap_set_event_filter` if the patterns need adjustment. The filter tightens itself based on real output — no manual tuning required.
+
 **Loop a prompt on a schedule**
 
 A PromptEmitter re-runs an agent prompt at a fixed interval. Useful for PR comments, CI status, or ticket queues.
@@ -210,6 +223,7 @@ Rules can be added or changed while the emitter is running. You never need to re
 .github/
   extensions/tap/extension.mjs  # extension entry point (loads the runtime)
   skills/loop/                  # /loop skill for scheduled and idle prompts
+  skills/monitor/               # /monitor skill for self-tuning command monitors
   copilot-instructions.md       # agent guidance for using this extension
 src/
   emitter/                      # supervisor, lifecycle, spawn, line router

package/bin/install.mjs

@@ -41,6 +41,7 @@ Installs:
   extensions/tap/version.json     Installed version metadata
   skills/loop/SKILL.md            The /loop skill for prompt-based loops
   skills/create-provider/SKILL.md The /create-provider skill for scaffolding providers
+  skills/monitor/SKILL.md         The /monitor skill for self-tuning command monitors
   copilot-instructions.md         Agent instructions for using ※ tap
 `);
 }
@@ -178,6 +179,11 @@ function install(flags) {
       dest: path.join(targetRoot, "skills", "create-provider", "SKILL.md"),
       label: "skills/create-provider/SKILL.md"
     },
+    {
+      src: path.join(distDir, "skills", "monitor", "SKILL.md"),
+      dest: path.join(targetRoot, "skills", "monitor", "SKILL.md"),
+      label: "skills/monitor/SKILL.md"
+    },
     {
       src: path.join(distDir, "copilot-instructions.md"),
       dest: path.join(targetRoot, "copilot-instructions.md"),

package/dist/extension.mjs

@@ -3851,6 +3851,20 @@ function clampLimit(value, fallback = 20) {
 function nowIso() {
   return (/* @__PURE__ */ new Date()).toISOString();
 }
+function parseIntervalSchedule(value) {
+  if (!Array.isArray(value) || value.length === 0) {
+    return null;
+  }
+  return value.map((item, index) => {
+    const parsed = parseLoopInterval(item);
+    if (parsed === null || parsed.idle === true || !Number.isFinite(parsed.ms) || parsed.ms <= 0) {
+      throw new Error(
+        `Invalid interval schedule entry at index ${index}: '${item}'. Schedule entries must be non-blank intervals greater than 0 and cannot be 'idle'.`
+      );
+    }
+    return parsed;
+  });
+}
 function parseLoopInterval(value) {
   if (value === void 0 || value === null || String(value).trim() === "") {
     return null;
@@ -4306,7 +4320,11 @@ function buildEmitterState(spec, baseCwd, defaults = {}) {
   if (command && prompt) {
     throw new Error(`Emitter '${name}' cannot define both command and prompt. Choose one emitter type.`);
   }
-  const interval = parseLoopInterval(spec.every);
+  const schedule = parseIntervalSchedule(spec.everySchedule);
+  if (schedule && spec.every != null && String(spec.every).trim() !== "") {
+    throw new Error(`Emitter '${name}': 'every' and 'everySchedule' are mutually exclusive. Use one or the other.`);
+  }
+  const interval = schedule ? null : 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(
@@ -4321,7 +4339,7 @@ function buildEmitterState(spec, baseCwd, defaults = {}) {
       throw new Error(`Emitter '${name}': every='idle' is only valid for prompt emitters, not command emitters.`);
     }
     runSchedule = RUN_SCHEDULE.IDLE;
-  } else if (interval) {
+  } else if (interval || schedule) {
     runSchedule = RUN_SCHEDULE.TIMED;
   } else if (prompt) {
     runSchedule = RUN_SCHEDULE.ONE_TIME;
@@ -4336,8 +4354,10 @@ function buildEmitterState(spec, baseCwd, defaults = {}) {
     prompt: prompt || null,
     emitterType,
     runSchedule,
-    every: interval?.text ?? null,
-    everyMs: interval?.ms ?? null,
+    every: interval?.text ?? (schedule ? schedule[0].text : null),
+    everyMs: interval?.ms ?? (schedule ? schedule[0].ms : null),
+    everySchedule: schedule ? schedule.map((s) => s.text) : null,
+    everyScheduleMs: schedule ? schedule.map((s) => s.ms) : null,
     requestedCwd: spec.cwd ?? null,
     cwd: resolveRequestedCwd(baseCwd, spec.cwd),
     stream: normalizeName(spec.channel, name),
@@ -4446,15 +4466,16 @@ function formatRunningEmitter(emitter, stream) {
   return [
     `- ${emitter.name}:`,
     `  status=${emitter.status}`,
-    `  scope=${emitter.scope}`,
-    `  managedBy=${emitter.managedBy}`,
+    `  scope=${emitter.lifespan}`,
+    `  managedBy=${emitter.ownership}`,
     `  emitterType=${emitter.emitterType}`,
     `  runSchedule=${emitter.runSchedule}`,
-    `  stream=${emitter.channel}`,
+    `  stream=${emitter.stream}`,
     `  sessionInjector=${stream?.sessionInjector?.enabled ? "on" : "off"}`,
     `  cwd=${emitter.cwd}`,
     `  ${describeEmitterWork(emitter)}`,
-    emitter.every ? `  every=${emitter.every}` : null,
+    emitter.everySchedule ? `  everySchedule=[${emitter.everySchedule.join(", ")}]` : null,
+    emitter.every && !emitter.everySchedule ? `  every=${emitter.every}` : null,
     emitter.maxRuns ? `  maxRuns=${emitter.maxRuns}` : null,
     `  autoStart=${emitter.autoStart}`,
     `  includeStderr=${emitter.includeStderr}`,
@@ -4636,6 +4657,16 @@ function createLifecycle({ lineRouter, sessionPort }) {
       void runScheduledIteration(emitter);
     }, delayMs);
   }
+  function nextDelay(emitter) {
+    if (emitter.runSchedule === RUN_SCHEDULE.IDLE) {
+      return IDLE_PROMPT_DELAY_MS;
+    }
+    if (emitter.everyScheduleMs) {
+      const idx = Math.min(Math.max(0, emitter.runCount - 1), emitter.everyScheduleMs.length - 1);
+      return emitter.everyScheduleMs[idx];
+    }
+    return emitter.everyMs;
+  }
   async function runScheduledIteration(emitter) {
     if (emitter.stopRequested || emitter.inFlight) {
       return;
@@ -4673,13 +4704,12 @@ function createLifecycle({ lineRouter, sessionPort }) {
         return;
       }
       emitter.status = EMITTER_STATUS.WAITING;
-      const delay = emitter.runSchedule === RUN_SCHEDULE.IDLE ? IDLE_PROMPT_DELAY_MS : emitter.everyMs;
-      scheduleIteration(emitter, delay);
+      scheduleIteration(emitter, nextDelay(emitter));
       return;
     }
     if (result.deferred) {
       emitter.status = EMITTER_STATUS.WAITING;
-      const retryDelay = emitter.runSchedule === RUN_SCHEDULE.IDLE ? IDLE_PROMPT_BACKOFF_MS : emitter.everyMs;
+      const retryDelay = emitter.runSchedule === RUN_SCHEDULE.IDLE ? IDLE_PROMPT_BACKOFF_MS : nextDelay(emitter);
       if (emitter.runSchedule !== RUN_SCHEDULE.IDLE) {
         lineRouter.appendSystemMessage(
           emitter,
@@ -4705,11 +4735,11 @@ function createLifecycle({ lineRouter, sessionPort }) {
       return;
     }
     emitter.status = EMITTER_STATUS.WAITING;
-    const failRetryDelay = emitter.runSchedule === RUN_SCHEDULE.IDLE ? IDLE_PROMPT_BACKOFF_MS : emitter.everyMs;
+    const failRetryDelay = emitter.runSchedule === RUN_SCHEDULE.IDLE ? IDLE_PROMPT_BACKOFF_MS : nextDelay(emitter);
     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 scheduleLabel = 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;
     const initialDelayMs = 0;
     const firstRunLabel = "";
     lineRouter.appendSystemMessage(
@@ -5088,6 +5118,7 @@ function createEmitterTools({ streams, configStore, supervisor, getBaseCwd }) {
           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." },
+          everySchedule: { type: "array", minItems: 1, items: { type: "string" }, description: "Optional backoff schedule \u2014 an ordered non-empty list of interval strings (e.g. ['10s','20s','30s','1m','2m','5m','10m']). The emitter uses each interval in sequence, then repeats the last one forever. Overrides 'every' when provided. Cannot be 'idle' entries." },
           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." },
@@ -5122,7 +5153,8 @@ function createEmitterTools({ streams, configStore, supervisor, getBaseCwd }) {
           `ownership=${emitter.ownership}`,
           `emitterType=${emitter.emitterType}`,
           `runSchedule=${emitter.runSchedule}`,
-          emitter.every ? `every=${emitter.every}` : null,
+          emitter.everySchedule ? `everySchedule=[${emitter.everySchedule.join(", ")}]` : null,
+          emitter.every && !emitter.everySchedule ? `every=${emitter.every}` : null,
           emitter.maxRuns ? `maxRuns=${emitter.maxRuns}` : null,
           `stream=${emitter.stream}`,
           `sessionInjector=${streams.ensure(emitter.stream).sessionInjector.enabled ? "on" : "off"}`,

package/dist/skills/monitor/SKILL.md

@@ -0,0 +1,112 @@
+---
+name: monitor
+description: "Start a self-tuning command monitor. Use when the user says 'monitor', 'watch', 'tail', 'track', 'keep an eye on', or wants a shell command to run continuously while Copilot automatically reviews and tunes the output filters over time."
+argument-hint: "<shell-command>"
+user-invocable: true
+---
+
+Start a CommandEmitter for the given shell command paired with a companion PromptEmitter that periodically reads the stream and dynamically updates the filter expressions with `tap_set_event_filter`.
+
+## Expected input
+
+The entire invocation is the shell command to run continuously.
+
+Example:
+
+```text
+/monitor tail -f /var/log/app.log
+```
+
+means:
+
+- `command = "tail -f /var/log/app.log"`
+
+If the command is missing, ask the user for it instead of guessing.
+
+## What to create
+
+### 1. CommandEmitter — the live command stream
+
+Use `tap_start_emitter` to start the CommandEmitter:
+
+- `command` — the user's shell command.
+- No `every` field — commands default to continuous (always running).
+- Initial `notifyPattern` — derive a sensible starting pattern from the command context (e.g. `error|warn|fail|exception` for log tailing, or omit entirely and let the companion tune it on first review).
+- `subscribe = true`, `delivery = "important"` — injected lines reach the session.
+- `scope = "temporary"`, `managedBy = "modelOwned"` (unless the user asked for persistence).
+- Name the emitter concisely after the command (e.g. `app-logs`, `docker-mycontainer`).
+- The EventStream is created automatically with the same name.
+
+### 2. Companion PromptEmitter — the periodic filter reviewer
+
+Use `tap_start_emitter` to start a second emitter immediately after the command emitter:
+
+- `prompt` — a **fully self-contained** instruction (see template below).
+- `everySchedule: ["10s", "20s", "30s", "1m", "2m", "5m", "10m"]` — backoff schedule: reviews start very frequent to validate the monitor quickly, then space out as it stabilises.
+- `scope = "temporary"`, `managedBy = "modelOwned"`.
+- Name it `<command-emitter-name>-review`.
+- `subscribe = false` — review is internal housekeeping, not user-facing.
+- `maxRuns` is optional. Only set it if the user explicitly requests a limit.
+
+### Companion prompt template
+
+Write the companion prompt so it stands alone — it must reference the command emitter and stream by their exact names, because the companion runs independently with no surrounding context. Use this structure:
+
+```
+Review the event stream for the '<command-emitter-name>' monitor and update its filters if needed.
+
+Steps:
+1. Call tap_stream_history for stream '<stream-name>' (limit 50).
+2. If there are fewer than 5 entries, stop — not enough data to judge patterns yet.
+3. Scan the recent lines for recurring patterns:
+   - Lines that are always noise (timestamps-only, heartbeats, blank pings) → candidates for excludePattern.
+   - Lines that indicate important events (errors, warnings, state changes) → candidates for notifyPattern.
+   - Lines that are never relevant at all → candidates for tighter includePattern.
+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.
+```
+
+Substitute the real emitter name and stream name into the prompt before passing it to `tap_start_emitter`.
+
+## Required behavior
+
+When this skill is invoked:
+
+1. Parse the command from the invocation.
+2. Start the CommandEmitter.
+3. Start the companion PromptEmitter using the self-contained prompt template and the hardcoded backoff schedule.
+4. Confirm to the user:
+   - Command emitter name and stream.
+   - Initial filter patterns (or "none set — companion will tune on first review").
+   - Companion reviewer name and its review schedule (first check in 10s, backing off to 10m).
+5. Stop there — do not immediately inspect stream history or simulate a review.
+
+## Stopping the monitor
+
+To stop monitoring, both emitters must be stopped:
+
+```
+tap_stop_emitter '<command-emitter-name>'
+tap_stop_emitter '<command-emitter-name>-review'
+```
+
+If the user asks to stop monitoring, stop both in a single response.
+
+## Persistence
+
+If the user explicitly asks to keep the monitor across sessions, set `scope = "persistent"` on **both** emitters. Say that both will be restored from config on the next session start.
+
+## Conservative filter updates
+
+Remind the companion (via the prompt) to be conservative:
+
+- Update only when there is clear evidence from at least 5 recent entries (the same minimum checked inside the companion prompt).
+- Prefer broadening `notifyPattern` over narrowing it — missing a real event is worse than an extra notification.
+- Never remove `notifyPattern` entirely unless the stream is provably silent.
+- Do not change `includePattern` or `excludePattern` on every review cycle — only when a pattern is clearly wrong.
+
+## If the input is incomplete
+
+If the invocation contains no recognisable shell command, ask the user for it.

package/dist/version.json

@@ -1,3 +1,3 @@
 {
-  "version": "1.1.2"
+  "version": "1.1.4"
 }

package/package.json

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