@damian87/omp 0.8.0 → 0.10.0

package/.github/skills/create-skill/SKILL.md

@@ -25,13 +25,13 @@ Skills are modular, self-contained packages that extend agent capabilities by pr
 ### Three-Level Loading System
 
 1. **Metadata (name + description)** - Always in context (~100 words)
-2. **SKILL.md body** - When skill triggers (<200 lines, ideally <500 lines for optimal performance)
+2. **SKILL.md body** - When skill triggers (under 200 lines; split overflow into `references/`)
 3. **Bundled resources** - As needed by agent (unlimited)
 
 ### Why Progressive Disclosure Matters
 
-- 85% reduction in initial context load
-- Activation times drop from 500ms+ to under 100ms
+- Smaller initial context load
+- Faster activation — the agent loads the body only when the skill triggers
 - Agent loads only what's needed, when it's needed
 - Skills remain maintainable and focused
 

package/.github/skills/daily-log/SKILL.md

@@ -23,7 +23,7 @@ The SessionStart hook injects a one-line breadcrumb, e.g.:
 
 ```
 [DAILY LOG] Goal: <today's goal>
-N entries logged in the last 7 days — run `omp daily-log read` to load if relevant.
+N entries logged in the last 7 days — run `omp daily-log read --days 7` to load if relevant.
 ```
 
 If the breadcrumb looks relevant to what the user is asking for — same feature, an open

package/.github/skills/jira-ticket/SKILL.md

@@ -16,21 +16,24 @@ Use `/jira-ticket` when work tracking is requested.
 ## Operations
 
 ### Create
-- Build from an approved plan or implementation slice
+- Build from an approved plan or implementation slice (a plan file or markdown)
 - Include: Summary, Description, Acceptance Criteria
-- If Jira config is available, create via API; otherwise output a dry-run payload
+- Render the payload with `omp jira render <plan-file>` — this **never** writes to Jira. To create/comment/update, run `omp jira apply <plan-file-or-ticket-key>`, which defaults to **dry-run** and only writes when Jira is configured with `JIRA_MODE=live` and the user has explicitly confirmed.
 
 ### Comment
 - Add implementation evidence, verification results, or status updates
 - Format for readability (use Jira wiki markup, not Markdown)
+- Apply with `omp jira apply <ticket-key> --comment` (dry-run by default; preview before confirming)
 
 ### Safe update
 - Only update known simple fields (summary, description, labels)
+- Apply with `omp jira apply <ticket-key> --update` (dry-run by default)
 - Do not guess transitions, issue links, project keys, or secrets
 
 ## Rules
 
-- If Jira config is missing, always output a **dry-run payload** — never fail silently
+- Always preview with `omp jira render` or `omp jira apply … --dry-run` (the default) before any live write
+- If Jira config is missing, the commands stay in dry-run and print the payload — never fail silently
 - Do not guess project keys, transitions, or credentials
 - Keep acceptance criteria testable and specific
 - Include file paths and evidence when commenting with implementation details

package/.github/skills/omp-autopilot/SKILL.md

@@ -32,7 +32,7 @@ Run `/research-codebase` to understand current state. Skip if you already have f
 
 ### Phase 2 — Plan
 
-Run `/ralplan` to produce an implementation plan with acceptance criteria. If a consensus plan already exists from a prior `/ralplan`, skip this phase.
+Run `/ralplan` to produce an implementation plan with acceptance criteria. If a plan already exists from a prior `/ralplan`, skip this phase.
 
 ### Phase 3 — Execute
 

package/.github/skills/ralph/SKILL.md

@@ -21,16 +21,18 @@ Use `/ralph` when one owner should complete one clear task end-to-end.
 
 ## Input
 
-Accept a plan from `/ralplan`, a ticket, or a concrete task description. If a `/ralplan` consensus plan exists, use its acceptance criteria as your definition of done.
+Accept a plan from `/ralplan`, a ticket, or a concrete task description. If a `/ralplan` plan exists, use its acceptance criteria as your definition of done.
 
 ## Steps
 
-1. **Start** from the plan or task. State what "done" looks like before writing code.
+1. **Register the loop** — run `omp ralph start "<task>" --max-iterations 10`. This tracks the loop so `omp ralph status` and `/team` nudges can see it and the iteration cap is enforced. State what "done" looks like before writing code.
 2. **Implement** one slice at a time, in plan order.
 3. **Verify after each slice** — run tests, lint, type-check. Do not batch verification to the end.
 4. **Fix** any failures immediately before moving to the next slice.
-5. **Repeat** until all slices complete with evidence, or a blocker is hit.
-6. **Final verification** — run the full test suite one last time after all slices.
+5. **Tick the loop** — run `omp ralph tick` after each slice. If it reports the iteration cap is reached, stop and report.
+6. **Repeat** until all slices complete with evidence, or a blocker is hit.
+7. **Final verification** — run the full test suite one last time after all slices.
+8. **End the loop** — run `omp ralph cancel` once done or blocked, so the tracked state is cleared.
 
 ## Circuit breaker
 

package/.github/skills/research-codebase/SKILL.md

@@ -22,7 +22,7 @@ Respond: "I'm ready to research the codebase. What area or question should I inv
 
 ### 1. Read mentioned files
 
-If the user references specific files, read them with `view` in the **main context** before anything else.
+If the user references specific files, read them directly in the **main context** before anything else.
 
 ### 2. Scope the tech stack
 
@@ -32,14 +32,14 @@ Detect from `package.json`, config files, directory structure, and project conve
 
 | Tier | When | Agent strategy |
 |------|------|----------------|
-| **Small** | Single file/component, narrow question | Main agent reads directly. No subagents. |
-| **Medium** | Cross-file, single area (e.g. "how does auth work") | 1–2 `explore` agents for locate + analyse |
-| **Large** | Cross-cutting, multi-area (e.g. "map the entire API layer") | Parallel locator → analyser → pattern-finder (see `reference/agent-prompts.md`) |
+| **Small** | Single file/component, narrow question | Read and search directly (glob/grep/read). No delegation. |
+| **Medium** | Cross-file, single area (e.g. "how does auth work") | Locate with glob/grep, then read and analyse the hits directly. |
+| **Large** | Cross-cutting, multi-area (e.g. "map the entire API layer") | Sweep area-by-area (locate → analyse → find patterns), or delegate areas to parallel `omp team` workers (see `reference/agent-prompts.md`). |
 
 ### 4. Research
 
-- Track subtasks via SQL `todos` table
-- For medium/large: read `reference/agent-prompts.md` for subagent prompt templates
+- Track subtasks in a markdown checklist as you go
+- For large: read `reference/agent-prompts.md` for `omp team` worker prompt templates
 - **MUST GATE**: Before writing findings, show file:line evidence for every claim
 
 ### 5. Synthesise & write document

package/.github/skills/research-codebase/reference/agent-prompts.md

@@ -1,8 +1,8 @@
-# Subagent Prompt Templates
+# Worker Prompt Templates
 
-Use these templates when spawning `explore` agents via the `task` tool. Only used for **medium** and **large** research tasks.
+Use these templates when delegating research areas to parallel `omp team` workers. Only needed for **large** research tasks; for small/medium, run these roles directly in the main agent with glob/grep/read.
 
-## Agent roles
+## Worker roles
 
 ### Locator — find WHERE files and components live
 
@@ -31,8 +31,8 @@ Do not evaluate consistency or suggest changes — only document occurrences.
 
 ## Guidelines
 
-- Each agent is stateless — provide complete context in the prompt
-- Remind every agent: "You are documenting, not evaluating"
-- Run independent explorations in parallel
-- For web research (only if user explicitly asks), use a `research` agent instead of `explore`
-- **Wait for ALL agents to complete before synthesising**
+- Each worker is stateless — provide complete context in the prompt
+- Remind every worker: "You are documenting, not evaluating"
+- Run independent explorations in parallel across team panes
+- For web research (only if user explicitly asks), do it in the main agent
+- **Collect all worker outputs before synthesising**

package/.github/skills/slack/SKILL.md

@@ -0,0 +1,83 @@
+---
+name: slack
+description: Post an outbound Slack notification — ONLY when the user types the explicit `/slack` slash command. Never auto-trigger from natural-language phrases like "tell Slack" or "notify me on Slack"; those go to the regular chat. One-way (publish only); the v0.8.0 gateway bridge still handles bidirectional DM chat.
+argument-hint: "<message> [--target slack:C…|D…|G…|U…]"
+---
+
+# /slack — outbound Slack notification
+
+Post a single message to Slack and exit. **No conversation; no listener.** The
+v0.8.0 chat bridge (`omp gateway serve` + `@omp-copilot` DM) handles bidirectional
+chat; this skill is for one-shot publishes.
+
+## Activation rules (read first)
+
+- **Activate ONLY** when the user typed the literal slash command `/slack` (with or
+  without arguments). Never auto-activate from natural-language phrases like "tell
+  Slack X", "ping me on Slack", "notify me on Slack" — those are conversational.
+- **Confirm the destination before posting**, every time:
+  - If `--target` is present, echo it back: "Sending to `slack:<ID>` — confirm? (y/N)"
+  - If `--target` is absent AND `SLACK_HOME_CHANNEL` is a channel (`C…`/`G…`):
+    treat as a potential broadcast. Ask: "Post to default channel `<id>` (a channel,
+    not a DM)? (y/N)" — only proceed on explicit `y`.
+  - If `SLACK_HOME_CHANNEL` is a user (`U…`) or DM (`D…`), proceed without
+    confirmation — the user already configured a personal default.
+- If the user types just `/slack` with no message, ask: *"What should I send and where?"*.
+
+## Contract
+
+- Default target = `SLACK_HOME_CHANNEL` from `~/.omp/.env` (set via `omp env init`).
+- Explicit target = `--target slack:<ID>` (ID = `C…`/`G…`/`D…`/`U…`).
+- `U…` targets are auto-resolved to a DM channel (`conversations.open`) before posting.
+- Stateless: each invocation is a fresh REST call to `chat.postMessage`. No daemon. No socket.
+
+## When invoked
+
+Follow the **Activation rules** above. After confirmation passes, post the message.
+
+## How
+
+Run via the omp CLI:
+
+```
+omp gateway notify --text "<message>" [--target slack:<ID>] [--thread-ts <ts>]
+```
+
+That's the only command this skill drives. The flags map 1:1 to user intent:
+
+- No flags after `--text`: post to `SLACK_HOME_CHANNEL`.
+- `--target slack:C0BOQV5434G`: explicit channel.
+- `--target slack:U0123ABCD`: explicit user (auto-DM).
+- `--target slack:C0…:1700.000123` or `--thread-ts 1700.000123`: pin to a thread.
+
+## Output handling
+
+The CLI returns a structured result:
+
+- Success: `posted to <channel> (ts=<ts>[, opened IM])` — relay that.
+- Failure: `notify failed [<CODE>]: <reason>` — surface the code + reason so the user
+  can act. Common codes:
+  - `MISSING_TEXT` — the message body was empty; pass a non-empty `--text`.
+  - `MISSING_TOKEN` — run `omp env init` to set `SLACK_BOT_TOKEN`.
+  - `MISSING_TARGET` — pass `--target` or run `omp env init` to set `SLACK_HOME_CHANNEL`.
+  - `BAD_TARGET` / `BAD_HOME_CHANNEL` — the ID is malformed; show the user the expected shape.
+  - `OPEN_FAILED` (user-id targets) — bot can't DM that user (likely missing `im:write` scope or user outside workspace).
+  - `POST_FAILED` — Slack returned `ok: false`; the reason field has Slack's own error name (`channel_not_found`, `not_in_channel`, etc.).
+  - `RATE_LIMITED` / `TIMEOUT` / `NETWORK_ERROR` — transient; try again.
+
+## Boundaries
+
+- This skill **never** waits for a reply. For interactive chat, the user opens Slack and DMs `@omp-copilot` (handled by `omp gateway serve`).
+- This skill **never** stores state. There is no routing table, no per-session registration.
+- This skill **does not** start the v0.8.0 inbound bridge. Daemons stay out of scope.
+
+## Example exchanges
+
+User: `/slack the migration just finished cleanly`
+Tool call: `omp gateway notify --text "the migration just finished cleanly"`
+
+User: `/slack tell #releases the build is green --target slack:C0RELEASE9`
+Tool call: `omp gateway notify --text "the build is green" --target slack:C0RELEASE9`
+
+User: `/slack ping U0123ABCD with "deploy needs review"`
+Tool call: `omp gateway notify --text "deploy needs review" --target slack:U0123ABCD`

package/.github/skills/team/SKILL.md

@@ -48,6 +48,8 @@ Write a temporary file at `/tmp/team-lanes-<timestamp>.json`:
 ### Step 2 — Launch
 
 ```bash
+# Installed-plugin path (in a dev checkout the script is at the repo-relative
+# .github/skills/team/scripts/team-launch.sh instead):
 bash ~/.copilot/installed-plugins/oh-my-copilot/oh-my-copilot/.github/skills/team/scripts/team-launch.sh \
   --session "team-<name>" --lanes <lanes-file>
 ```
@@ -76,7 +78,7 @@ Choose this only when the user explicitly wants the team to run in the backgroun
 ### Launch
 
 ```bash
-omp team <N>:copilot "<task description>"
+omp team <N>:copilot "<task description>" --name <name>
 ```
 
 The runtime automatically:
@@ -89,9 +91,9 @@ The runtime automatically:
 ### Monitor and cleanup
 
 ```bash
-omp team status <team-name>       # check progress
+omp team status <name>            # check progress (same <name> passed to --name)
 tmux attach -t omp-team-<name>    # watch panes live
-omp team shutdown <team-name>     # kill when done
+omp team shutdown <name>          # kill when done
 ```
 
 ## Prerequisites

package/.github/skills/team/scripts/team-launch.sh

@@ -45,7 +45,9 @@ fi
 if command -v omp &>/dev/null; then
   AGENT_CMD="omp --madmax"
 elif command -v copilot &>/dev/null; then
-  AGENT_CMD="copilot"
+  # --yolo = all permissions (tools+paths+urls) so worker panes never block on a
+  # trust/permission dialog. Matches the bypass `omp --madmax` grants.
+  AGENT_CMD="copilot --yolo"
 else
   echo "Neither omp nor copilot CLI found" >&2; exit 1
 fi
@@ -78,9 +80,11 @@ wait_for_ready() {
       return 0
     fi
 
-    # Auto-accept folder trust dialog
+    # Auto-accept folder trust dialog. Use the `Enter` key NAME, not C-m:
+    # Copilot CLI >=1.0.61 ignores a literal carriage return (C-m) for TUI
+    # selection/submit, so C-m left the trust dialog open and the agent hung.
     if (( accepted == 0 )) && echo "$txt" | grep -q 'Do you trust'; then
-      tmux send-keys -t "$pane" C-m
+      tmux send-keys -t "$pane" Enter
       accepted=1
       echo "    ↳ Auto-accepted folder trust for $pane"
     fi
@@ -142,10 +146,12 @@ for i in $(seq 0 $((LANE_COUNT - 1))); do
   LANE_NAME=$(jq -r ".[$i].name" "$LANES_FILE")
   PANE_ID="${PANE_IDS[$i]}"
 
-  # -l = literal (no key interpretation), then C-m = Enter as a separate call
+  # -l = literal (no key interpretation), then submit. Use the `Enter` key NAME,
+  # not C-m: Copilot CLI >=1.0.61 ignores a literal carriage return, so C-m left
+  # the prompt sitting unsent in the input buffer and the agent never started.
   tmux send-keys -t "$PANE_ID" -l "$LANE_PROMPT"
   sleep 0.3
-  tmux send-keys -t "$PANE_ID" C-m
+  tmux send-keys -t "$PANE_ID" Enter
 
   echo "  📨 Sent to $PANE_ID ($LANE_NAME)"
 done

package/.github/skills/ultraqa/SKILL.md

@@ -20,6 +20,8 @@ Use `/ultraqa` after implementation when shallow checks are not enough.
 
 ## Steps
 
+Register the QA run first: `omp ultraqa start "<goal>" --max-cycles 5`. This tracks the cycle count and enforces the cap, and lets `omp ultraqa status`/`cancel` see the run.
+
 ### Cycle 1 (and each subsequent cycle)
 
 Number every cycle explicitly: "Cycle 1", "Cycle 2", etc.
@@ -33,13 +35,14 @@ Number every cycle explicitly: "Cycle 1", "Cycle 2", etc.
 
 ### After each cycle
 
+- Record the outcome: `omp ultraqa cycle fail` (issues found) or `omp ultraqa cycle pass` (clean). This increments the counter and reports when the cap is reached.
 - If issues found → fix and start next cycle
-- If clean → report PASS and stop
+- If clean → report PASS and run `omp ultraqa cancel` to clear the run
 - Track which issues were found and fixed per cycle
 
 ## Early exit conditions
 
-- **5 cycles reached** — stop, report remaining issues as known gaps
+- **5 cycles reached** (enforced by `omp ultraqa cycle`) — stop, report remaining issues as known gaps
 - **Same failure 3 consecutive cycles** — stop, this is a design issue not a bug. Report it for `/ralplan`
 - **Critical regression found** — stop immediately, report before fixing anything else
 

package/.github/skills/ultrawork/SKILL.md

@@ -21,17 +21,17 @@ Use `/ultrawork` when there are many independent, low-conflict work items that c
 
 ## Composition
 
-Ultrawork is the **parallelism primitive** in the skill stack:
+Ultrawork is the **batch-execution** branch of `/omp-autopilot` Phase 3 — a sibling of `/ralph` (single linear task) and `/team` (parallel panes), not nested inside them:
 ```
-/omp-autopilot → /ralph (persistence) → /ultrawork (parallelism)
+/omp-autopilot → /ralph  OR  /team  OR  /ultrawork
 ```
-Ralph wraps ultrawork when a persistent verify loop is needed around batched work.
+Pick `/ultrawork` when the work is many independent mechanical items. It can also be invoked directly.
 
 ## Steps
 
 ### 1. Inventory
 
-List all tasks. For each, note the files it touches. Flag any collisions.
+Register the batch so the run is tracked and `/team` nudges can see it: `omp ultrawork start "<objective>" --task-count <n>`. Then list all tasks. For each, note the files it touches. Flag any collisions.
 
 ### 2. Dependency check
 
@@ -51,7 +51,7 @@ Process each wave. For each task in the wave:
 
 ### 4. Report
 
-Summarise: completed, failed, blocked.
+Summarise: completed, failed, blocked. Then clear the tracked state with `omp ultrawork cancel`.
 
 ## Stop conditions
 

package/.github/skills/weighted-consensus/SKILL.md

@@ -70,9 +70,10 @@ omp council "<question>" [--models a,b,c | model:role:weight,...] \
 - Timed-out members that produced valid JSON before the kill signal are
   automatically recovered as survivors — they are not dropped.
 
-If `omp council` is not found (the published `omp` predates this feature), fall
-back to the local build from the repo root: `node dist/src/cli.js council "<question>" ...`
-(run `npm run build` first if `dist/` is stale).
+If `omp council` is not found (the published `omp` predates this feature),
+update the global CLI: `npm i -g @damian87/omp@latest`, then re-run `omp council`.
+(The `node dist/src/cli.js council` build only resolves from inside the
+oh-my-copilot repo, so it is not a portable fallback for an arbitrary project.)
 
 ### Step 3 — Present the result
 

package/README.md

@@ -53,7 +53,8 @@ That's it.
 - **Team-first orchestration** — parallel tmux panes, each running an independent agent session
 - **Bare-flag bypass** — `omp --madmax` injects `--yolo` so non-interactive runs never block on a permission prompt
 - **Persistent execution** — Ralph, UltraQA, and Ultrawork keep going until the goal is verified
-- **MCP-powered shared state** — workers swap typed messages over an outbox/inbox cursor instead of summarising each other's summaries
+- **File-state coordination** — workers swap typed messages over an outbox/inbox cursor with atomic `O_EXCL` task locks; no broker or daemon to babysit
+- **Chat bridge** — `omp gateway` runs long-lived chat connectors (Slack today, more next) so you can DM Copilot from anywhere
 - **Lifecycle hooks** — `SessionStart`, `UserPromptSubmit`, `PreToolUse`, `PostToolUse`, `SessionEnd`, `Error`
 - **Doctor included** — `omp doctor` verifies plugin manifest, skills discovery, hooks, and the underlying `copilot` CLI in one shot
 
@@ -76,14 +77,14 @@ That's it.
 ### Intelligent Orchestration
 
 - **7 specialized agents** — planner, architect, executor, verifier, code-reviewer, designer, researcher (all `--agent <name>` compatible with Copilot CLI)
-- **19 in-session skills** auto-discovered from `.github/skills/`
+- **22 in-session skills** auto-discovered from `.github/skills/`
 - **Smart pipeline routing** — `/research-codebase` → `/ralplan` → `/team` / `/ralph` / `/ultrawork` → `/code-review` → `/ultraqa`
 
 ### Developer Experience
 
-- **MCP server** ships with `notepad`, `project-memory`, `shared-memory`, `state`, and `trace` tools out of the box
+- **Context & history as CLI subcommands** — `omp state` (key-value with TTL), `omp project-memory` (notes + directives), `omp trace` (per-session timeline + summary), `omp goal` / `omp memory sync` (managed repo context), `omp daily-log`
 - **Lightweight Copilot context** — managed instructions keep only the repo goal plus on-demand memory commands; set `OMP_DISABLE_INSTRUCTIONS_MEMORY=1` to skip writing the managed block entirely
-- **File-state coordination** — outbox JSONL + byte cursor, atomic `O_EXCL` task locks, optimistic CAS on claim
+- **File-state worker coordination** — outbox JSONL + byte cursor, atomic `O_EXCL` task locks, optimistic CAS on claim
 - **Idle nudge** — content-based pane idle detection that pokes stuck workers
 - **Mode-state loops** — single source of truth per loop (Ralph/Ultrawork/UltraQA state files)
 
@@ -115,6 +116,8 @@ These run **inside a Copilot CLI session** after the plugin is installed.
 | `/caveman`              | Ultra-compressed communication mode                       | `/caveman`                                           |
 | `/worktree`             | Git worktree-based parallel branch work                   | `/worktree`                                          |
 | `/schedule`             | Durable local cron job — re-runs a prompt on a schedule, survives reboot | `/schedule "check the PR every 15 min"`   |
+| `/goal`                 | Set/read the repo-level goal injected into the managed Copilot context | `/goal "ship v1.0 of the billing flow"` |
+| `/daily-log`            | Per-day goal + work log surfaced at the start of new sessions | `/daily-log "ratelimit refactor landed"`        |
 
 ---
 
@@ -195,15 +198,22 @@ omp council "<question>" [--models a,b,c] [--context @file] [--json]   # multi-m
 omp comms status | send | recv | ask        # drive a running copilot tmux session
 omp gateway serve [--only slack]            # run chat connectors (today: slack)
 omp gateway status [--json]                 # per-connector readiness (no sockets)
+omp gateway notify --text "<msg>" [--target slack:C…|G…|D…|U… [:thread_ts]] [--thread-ts <ts>] [--json]
+                                            # one-shot outbound Slack post; falls back to SLACK_HOME_CHANNEL
 omp slack serve                             # deprecated alias of `gateway serve --only slack`
 omp slack doctor [--json]                   # deprecated alias of `gateway status --only slack`
 omp env init [--force]                      # write ~/.omp/.env (interactive Slack token setup)
-omp schedule add --id <id> --cron "*/15 * * * *" --prompt "<text>" [--allow-all-tools] [--cwd <dir>] [--model <m>] [--timeout <ms>] [--max-runs N] [--ttl-hours H] [--dry-run]
+omp schedule add --id <id> --cron "*/15 * * * *" --prompt "<text>" [--allow-all-tools] [--cwd <dir>] [--model <m>] [--timeout <ms>] [--max-runs N] [--ttl-hours H] [--notify-target slack:U0123ABCD] [--dry-run]
 omp schedule list                           # registered jobs + OS-install status
 omp schedule status <id>                    # last run + result summary
 omp schedule run-now <id>                   # trigger one run immediately
 omp schedule remove <id>                    # uninstall the OS entry + delete the job
-omp mcp                                     # MCP server over stdio
+omp goal set "<objective>" | read [--json]
+omp memory sync [--json]                    # render goal + directives into copilot-instructions.md
+omp daily-log set-goal "<text>" | add "<text>" | read [--days N] | prune [--keep-days N] [--json]
+omp state write <key> <val> [--ttl <s>] | read | delete | status <key> | list | cleanup [--json]
+omp project-memory read [<id>] | index | add-note "<title>" [--body "<text>"] | add-directive "<rule>" [--json]
+omp trace timeline [<sessionId>] [--limit N] | summary [<sessionId>] | add <sessionId> <event> [<json>] [--json]
 omp catalog list | validate | capability <id>
 omp jira render <plan-file>
 omp jira apply <key-or-plan> --comment|--update|--transition|--link
@@ -214,6 +224,7 @@ Environment overrides:
 - `OMP_PLUGIN_ROOT` — path to the plugin checkout (with `OMC_PLUGIN_ROOT` accepted for back-compat)
 - `OMP_COPILOT_BIN` — alternate `copilot` binary
 - `OMP_BIN` — absolute path to the `omp` wrapper written into OS-scheduler entries (overrides `which omp`)
+- `OMP_SKIP_USER_ENV` — when `1`, skip auto-loading `~/.omp/.env` (useful for hermetic CI runs)
 
 **Scheduled jobs** register a durable per-job entry with the OS scheduler (macOS launchd,
 Linux systemd-user timers, or a managed `crontab` block as a cross-platform fallback) that
@@ -252,43 +263,29 @@ Full Slack-app setup (manifest + scopes) lives in [`docs/slack-setup.md`](docs/s
 
 ## Roadmap
 
-omp is intentionally small today and growing in vertical slices.
+omp grows in vertical slices. Items aren't pinned to specific semver versions — they land when they're ready.
 
-### v0.2 — Notification gateways
+### Already shipped
 
-Telegram, Discord, Slack, and generic webhook integration so long-running modes can ping you when they finish, fail, or stall. Tag with `--telegram` / `--discord` / `--slack` per invocation; configure once with `omp notify add`.
+- **Scheduled tasks** (v0.6.0) — durable local cron: `omp schedule add --id pr-watch --cron "*/15 * * * *" --prompt "…"` plus `/schedule` in-session. Each job registers an OS-scheduler entry (launchd / systemd-user / crontab fallback) that fires a fresh agent session, survives reboot, locks out overlap, and surfaces results at the next session start.
+- **Chat bridge — Slack inbound** (v0.8.0) — `omp gateway` runs long-lived chat connectors that forward messages into a running Copilot tmux session and post replies back. Slack is the first connector (Socket Mode, no public URL). `omp env init` walks you through one-time token setup; tokens live in `~/.omp/.env` (auto-loaded on every invocation). See [`docs/slack-setup.md`](docs/slack-setup.md).
+- **Slack outbound — `omp gateway notify`** — stateless REST `chat.postMessage` from any process (cron `--notify-target`, in-session `/slack <message>`, ad-hoc `omp gateway notify --text "..."`). Default destination from `SLACK_HOME_CHANNEL`; explicit `--target slack:C…/G…/D…/U…` overrides; `U…` auto-resolves to a DM via `conversations.open`.
+- **Weighted-consensus council** — multi-model council with role weights + minority report. Via `omp council` or `/weighted-consensus`.
+- **Suggest** — `omp suggest "<task>"` recommends a slash-skill workflow without launching one.
 
-### v0.3 — Checkpoints + rollback
+### Up next
 
-Auto-snapshot the working tree before any tool-driven file edit. `omp rollback [id]` to revert a checkpoint. A safety net for autonomous loops that go wide before they go right.
+- **More chat connectors** — Telegram, Discord, generic webhook on the same `omp gateway` runtime. One file per connector.
+- **Outbound notifications** — long-running modes ping you when they finish, fail, or stall (`omp notify add` + per-invocation `--telegram`/`--discord`/`--slack` tags).
+- **Checkpoints + rollback** — auto-snapshot the working tree before any tool-driven file edit; `omp rollback [id]` reverts a checkpoint. Safety net for autonomous loops.
+- **Browser tool** — web search / page extraction / full automation (navigate, click, type, screenshot) for research skills that need fresh data instead of training-cutoff guesses.
 
-### v0.4 — Provider advisor (`omp ask`)
+### Later
 
-One command to consult an alternate provider CLI (`claude`, `codex`, `gemini`) and save the response as a markdown artifact under `.omp/artifacts/ask/`. Same surface in-session via `/ask`.
-
-### v0.5 — Scheduled tasks ✅ (shipped)
-
-Durable local cron: `omp schedule add --id pr-watch --cron "*/15 * * * *" --prompt "…"` plus `/schedule` in-session. Each job registers an OS-scheduler entry (launchd / systemd-user / crontab fallback) that fires a fresh agent session, survives reboot, locks out overlap, and surfaces results at the next session start. Follow-ups: natural-language cron parsing, notification-gateway delivery, pause/resume/edit, and an orphan-sweep (`omp schedule gc`).
-
-### v0.6 — Browser tool (MCP)
-
-A first-class browser MCP tool: web search, page extraction, full automation (navigate, click, type, screenshot). For research skills that need fresh data instead of training-cutoff guesses.
-
-### v0.7 — HUD-lite statusline
-
-Live orchestration metrics in the terminal: active mode, current task, worker count, tokens, cache hit rate, last error.
-
-### v0.8 — Provider routing
-
-Fine-grained per-task provider selection — sorting, whitelists, priority ordering, cost-aware fallback. For mixed pipelines that want Opus for planning and Haiku for grunt work without manual model switching.
-
-### v0.9 — Skill learning
-
-Extract repeating patterns from session transcripts into reusable skill files with strict quality gates. Auto-injects into context when relevant triggers fire.
-
-### v1.0 — Pre-built agent templates
-
-One-shot deployable templates for common workflows: research, security audit, design-system migration, content automation. `omp template add <name>` drops a curated skill + agent pair into your project.
+- **HUD-lite statusline** — live orchestration metrics in the terminal: active mode, current task, worker count, tokens, cache hit rate, last error.
+- **Provider routing** — fine-grained per-task provider selection: sorting, whitelists, priority ordering, cost-aware fallback. For mixed pipelines that want Opus for planning and Haiku for grunt work without manual model switching.
+- **Skill learning** — extract repeating patterns from session transcripts into reusable skill files with strict quality gates. Auto-injects into context when relevant triggers fire.
+- **Pre-built agent templates** — one-shot deployable templates for common workflows (research, security audit, design-system migration, content automation). `omp template add <name>` drops a curated skill + agent pair into your project.
 
 ---
 
@@ -298,6 +295,7 @@ One-shot deployable templates for common workflows: research, security audit, de
 - [Copilot distribution](docs/copilot-distribution.md) — project/user skill installs and the case against GitHub App Extensions
 - [Jira adapter](docs/jira.md) — configuration discovery, safe operations, dry-runs, fallback payloads
 - [Self-evolve](docs/self-evolve.md) — extracting reusable skills from session transcripts
+- [Slack setup](docs/slack-setup.md) — Slack app manifest, scopes, Socket-Mode token, `omp gateway serve`
 
 ## Layout
 
@@ -306,7 +304,7 @@ One-shot deployable templates for common workflows: research, security audit, de
 .github/skills/<name>/SKILL.md    # in-session slash skills
 hooks/hooks.json                  # lifecycle hook manifest
 scripts/*.mjs                     # hook implementations
-src/                              # omp CLI, MCP server, team runtime, mode-state loops
+src/                              # omp CLI, team runtime, gateway/comms, schedule, mode-state loops
 ```
 
 Skills follow the [Copilot agent-skills docs](https://docs.github.com/en/copilot) — project skills live in `.github/skills/` and are invoked with `/skill-name`.

package/catalog/capabilities.json

@@ -862,6 +862,52 @@
           "notes": "Use /weighted-consensus from .github/skills/weighted-consensus/SKILL.md."
         }
       }
+    },
+    {
+      "id": "slack",
+      "name": "slack",
+      "title": "Slack Notification",
+      "category": "notify",
+      "summary": "Post an outbound Slack notification from inside a Copilot session.",
+      "notes": "Thin in-session wrapper over `omp gateway notify`. Stateless REST call. v0.8.0 inbound chat bridge unchanged.",
+      "defaultCommand": "slack",
+      "phase1": true,
+      "sourceSkill": "slack",
+      "providers": {
+        "copilot": "supported"
+      },
+      "support": {
+        "copilot": "native"
+      },
+      "providerSupport": {
+        "copilot": {
+          "state": "native",
+          "notes": "Use /slack from .github/skills/slack/SKILL.md."
+        }
+      }
+    },
+    {
+      "id": "notify.slack",
+      "name": "notify.slack",
+      "title": "Slack Notification",
+      "category": "notify",
+      "summary": "Alias capability id for `slack`.",
+      "notes": "Same skill as `slack`.",
+      "defaultCommand": "slack",
+      "phase1": true,
+      "sourceSkill": "slack",
+      "providers": {
+        "copilot": "supported"
+      },
+      "support": {
+        "copilot": "native"
+      },
+      "providerSupport": {
+        "copilot": {
+          "state": "native",
+          "notes": "Use /slack from .github/skills/slack/SKILL.md."
+        }
+      }
     }
   ]
 }

package/catalog/skills-general.json

@@ -502,6 +502,32 @@
       },
       "projection": "project-skill",
       "phase1": true
+    },
+    {
+      "name": "slack",
+      "capabilityId": "slack",
+      "capabilityIds": [
+        "slack",
+        "notify.slack"
+      ],
+      "source": ".github/skills/slack/SKILL.md",
+      "sourcePath": ".github/skills/slack/SKILL.md",
+      "canonicalPath": ".github/skills/slack/SKILL.md",
+      "description": "Post an outbound Slack notification from inside a Copilot session.",
+      "summary": "Post an outbound Slack notification from inside a Copilot session.",
+      "support": "project-skill",
+      "aliases": [],
+      "slashCommands": [
+        "slack"
+      ],
+      "projections": {
+        "copilot": {
+          "command": "/slack",
+          "state": "supported"
+        }
+      },
+      "projection": "project-skill",
+      "phase1": true
     }
   ]
 }