copilot-tap-extension 1.1.1 → 1.1.3

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

@@ -40,7 +40,8 @@ Installs:
   extensions/tap/extension.mjs    The bundled ※ tap extension
   extensions/tap/version.json     Installed version metadata
   skills/loop/SKILL.md            The /loop skill for prompt-based loops
-  skills/provider/SKILL.md        The /provider skill for scaffolding providers
+  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
 `);
 }
@@ -174,9 +175,14 @@ function install(flags) {
       label: "skills/loop/SKILL.md"
     },
     {
-      src: path.join(distDir, "skills", "provider", "SKILL.md"),
-      dest: path.join(targetRoot, "skills", "provider", "SKILL.md"),
-      label: "skills/provider/SKILL.md"
+      src: path.join(distDir, "skills", "create-provider", "SKILL.md"),
+      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"),

package/dist/skills/{provider → create-provider}/SKILL.md

@@ -1,7 +1,7 @@
 ---
-name: provider
-description: "Scaffold a ※ tap provider — an external process that registers tools with Copilot via WebSocket. Use when the user wants to create a provider, extend tap with custom tools, or connect an external service."
-argument-hint: "<description of what the provider should do>"
+name: create-provider
+description: "Create an external tool provider that connects to ※ tap. Use when the user says 'create a provider', 'build a provider', 'scaffold a provider', 'add an external tool', 'connect a service to tap', or wants to extend Copilot with tools written in any language."
+argument-hint: "<what the provider should do>"
 user-invocable: true
 ---
 

package/dist/skills/loop/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: loop
-description: "Create a prompt-based scheduled loop with ※ tap. Use for requests like '/loop 5m check the deploy' or any ask to run a prompt on a recurring interval."
+description: "Run a prompt on a recurring schedule or when idle. Use when the user says 'loop', 'every 5 minutes', 'check periodically', 'keep watching', 'repeat this', 'run when idle', or wants any prompt to re-run automatically."
 argument-hint: "<interval|idle> <prompt>"
 user-invocable: true
 ---

package/dist/skills/monitor/SKILL.md

@@ -0,0 +1,129 @@
+---
+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: "[review-interval] <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
+
+Interpret the invocation as:
+
+1. An **optional** first argument that is the review interval for the companion (e.g. `5m`, `10m`, `1h`). Defaults to `5m` when omitted.
+2. The rest of the input is the shell command to run continuously.
+
+Example (with explicit interval):
+
+```text
+/monitor 10m tail -f /var/log/app.log
+```
+
+means:
+
+- `reviewInterval = "10m"` — companion reviews the stream every 10 minutes
+- `command = "tail -f /var/log/app.log"`
+
+Example (default interval):
+
+```text
+/monitor docker logs -f mycontainer
+```
+
+means:
+
+- `reviewInterval = "5m"` (default)
+- `command = "docker logs -f mycontainer"`
+
+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).
+- `every = <reviewInterval>` — timed schedule.
+- `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 review interval and command from the invocation.
+2. Start the CommandEmitter.
+3. Start the companion PromptEmitter using the self-contained prompt template above.
+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 review interval.
+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 review interval looks like part of the command (e.g. `/monitor tail -f …`), treat the first token as the command start and use the default interval `5m`.
+
+If only an interval is given with no command, ask for the command.

package/dist/version.json

@@ -1,3 +1,3 @@
 {
-  "version": "1.1.1"
+  "version": "1.1.3"
 }

package/package.json

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