@damian87/omp 0.13.0 → 0.15.0

package/.github/skills/schedule/SKILL.md

@@ -37,14 +37,39 @@ the `omp schedule …` commands on the user's behalf.
    ```bash
    omp schedule add --id <id> --cron "<expr>" --prompt "<text>" \
      [--allow-all-tools] [--cwd <dir>] [--model <m>] [--timeout <ms>] \
-     [--max-runs <n>] [--ttl-hours <h>] --json
+     [--max-runs <n>] [--ttl-hours <h>] \
+     [--notify-target slack:<ID>] [--notify-desktop] [--notify-open-omp] --json
    ```
    Jobs auto-expire after 72h by default (`--ttl-hours`) — set a longer TTL or a
    `--max-runs` cap as needed. Use `--dry-run` to preview the OS entry first.
+
+   **End-of-run notifications (all opt-in, default off; failures never affect the job):**
+   - `--notify-target slack:<C|G|D|U…>` — post the run summary to Slack (needs
+     `SLACK_BOT_TOKEN`; falls back to `SLACK_HOME_CHANNEL` when no target).
+   - `--notify-desktop` — fire a native desktop notification (job id + status +
+     one-line summary). Transport per OS: **macOS → `osascript`** (the only path
+     that reliably displays on Sequoia; shown under "Script Editor", **not
+     clickable**); **Linux/Windows → node-notifier** (notify-send / SnoreToast).
+   - `--notify-open-omp` — make the notification's click open an interactive `omp`
+     session in the schedule state root (the SessionStart banner then surfaces the
+     latest result). **Requires a click-capable transport**, which on macOS means a
+     system `terminal-notifier` enabled via `OMP_NOTIFY_USE_TERMINAL_NOTIFIER=1`
+     (`brew install terminal-notifier`). Note: terminal-notifier does **not**
+     display on some macOS Sequoia builds — if notifications stop appearing,
+     unset that env to fall back to osascript (display-only). Disable desktop
+     notifications entirely with `OMP_DISABLE_DESKTOP_NOTIFY=1`.
+
+   Slack and desktop are independent and can be combined on one job.
 4. **Confirm** by listing: `omp schedule list --json`.
 5. **Trigger now** to test it once: `omp schedule run-now --id <id>`.
 6. **Inspect** results: `omp schedule status --id <id> --json` (recent results
-   are also surfaced automatically at the start of future sessions).
+   are also surfaced automatically at the start of future sessions). To pull up
+   the latest run with full context by id — e.g. after seeing a desktop
+   notification titled `schedule: <id>` — run `omp schedule open <id>`, which
+   prints the latest status, summary, and the full captured output. Add `--tmux`
+   to instead drop into an interactive `omp` session (auto-wrapped in tmux) rooted
+   at the project; the SessionStart banner surfaces *recent* scheduled runs there
+   (not pinned to `<id>`) — for this id's exact output, use plain `omp schedule open <id>`.
 7. **Remove** when done: `omp schedule remove --id <id>` (fully uninstalls the OS
    entry; do NOT delete `.omp/state/schedule/` by hand).
 

package/.github/skills/verify-byok/SKILL.md

@@ -0,0 +1,50 @@
+---
+name: verify-byok
+description: Verify an omp change end-to-end — static gate (build/tsc/tests/lint/catalog) plus a live BYOK run that drives Copilot/teams on a real model and captures evidence. Use before merging any PR that touches hooks, comms, team, launch, or skills.
+argument-hint: "<branch-or-PR to verify>"
+---
+
+# verify-byok — evidence-based verification for omp changes
+
+**Invocation:** `/verify-byok <branch-or-PR>`
+
+Prove a change actually works, not just that it compiles. Two gates: a **static** gate (cheap, always) and a **live BYOK** gate (drives real Copilot CLI sessions on a Bring-Your-Own-Key model so no GitHub quota is needed). Report **real command output**, never claims. Be honest about what you did NOT test.
+
+## When to use
+Before merging any PR — especially ones touching `hooks/`, `scripts/*.mjs`, `src/comms`, `src/team`, `src/copilot/launch`, `src/copilot/trust`, or `.github/skills`. Anything whose behavior only appears at runtime (tmux submit keys, hook firing, trust dialog, model tool-calls) needs the live gate.
+
+## Prerequisites (one-time, persistent)
+- `~/.omp/.env` holds BYOK: `COPILOT_PROVIDER_BASE_URL=https://openrouter.ai/api/v1`, `COPILOT_PROVIDER_TYPE=openai`, `COPILOT_PROVIDER_API_KEY=…`, `COPILOT_MODEL=…`, `COPILOT_PROVIDER_MODEL_ID=…`. omp auto-loads it; `~/.zshrc` sourcing it makes direct `copilot` BYOK too.
+- Free model `openai/gpt-oss-120b:free` exercises plumbing but botches structured edits/`apply_patch` and narrates instead of acting — use a capable model (`anthropic/claude-sonnet-4.5` + `COPILOT_PROVIDER_MODEL_ID=claude-sonnet-4`) when verifying that real tasks complete.
+- Folder trust: a session only skips the "Do you trust this folder?" dialog if the cwd is in `~/.copilot/config.json#trustedFolders` (`--yolo` does NOT skip it). `omp` auto-adds it on launch; `/private/tmp` is pre-trusted.
+
+## Static gate (run from the branch worktree)
+```bash
+npm run build                              # tsc
+npx tsc -p tsconfig.json --noEmit          # type-clean
+npx vitest run                             # ALL must pass — note the count
+node dist/src/cli.js lint:skills --root .  # 0 issues
+node dist/src/cli.js catalog validate      # PASS
+```
+A merged-overlap PR? Confirm the test count rose (new tests survived the rebase) and old behavior's tests still pass.
+
+## Live BYOK gate
+Build the branch CLI first (`npm run build`); installed `omp` may be older. Drive Copilot inside tmux (each pane is a pty). **Submit with the `Enter` key name, never `C-m`** — Copilot ≥1.0.61 ignores `C-m`.
+
+1. **Launch + reach a model:** `tmux new-session -d -s vbyok -c <dir>` → send `omp` (or `omp --madmax` for bypass) → wait for `/ commands`. Confirm the model line shows your BYOK model and `Session: 0 AIC used` (0 AI Credits = not on GitHub quota). Send a prompt, send `Enter`, confirm a real reply.
+2. **Exercise the changed surface** — pick the user-visible behavior the change claims:
+   - hooks → tail `<cwd>/.omp/state/hooks.log` for the events firing;
+   - team → run a 2-worker team, confirm files/artifacts on disk and the script's `🎉 All N agents completed!` (read the raw stdout, not the leader's summary);
+   - cost/minify → pipe a postToolUse payload to `scripts/post-tool-use.mjs` and check `modifiedResult` + raw preserved + ledger `savedTokens` + `omp cost`.
+3. **Capture evidence**: `tmux capture-pane -p -t <session>` plus the on-disk artifact. Keep transcripts.
+
+## Reporting (mandatory)
+- PASS/FAIL table with the actual captured output (model line, reply, artifact contents, ledger numbers).
+- State the model used and that no GitHub quota was consumed.
+- **Honest limitations**: heuristics (e.g. pane-scrape completion detection), model-quality effects (free model botching edits), anything gated/conditional, and anything you did NOT exercise.
+- Never report "works" without exercising the user-visible surface — verify before asserting.
+
+## Anti-patterns
+- Trusting a subagent's "Complete." — re-run the gate yourself.
+- `C-m` to submit to Copilot (use `Enter`).
+- Concluding from a green build alone — runtime bugs (env propagation, trust dialog, submit keys) pass the build and fail live.

package/README.md

@@ -57,6 +57,83 @@ That's it.
 - **Chat bridge** — `omp gateway` runs long-lived chat connectors (Slack today, more next) so you can DM Copilot from anywhere
 - **Lifecycle hooks** — `sessionStart`, `userPromptSubmitted`, `preToolUse`, `postToolUse`, `postToolUseFailure`, `sessionEnd`, `errorOccurred`
 - **Doctor included** — `omp doctor` verifies plugin manifest, skills discovery, hooks, and the underlying `copilot` CLI in one shot
+- **Self-update** — when a newer release is published, `omp` (and `omp --version`) offers to update in a TTY; `omp update` self-updates the CLI and refreshes the Copilot plugin so both stay in lockstep. Never prompts in CI / `--json` / non-TTY; opt out with `OMP_NO_UPDATE_CHECK=1`
+
+---
+
+## Architecture
+
+oh-my-copilot is two things working together: a **shell CLI** (`omp`) that wraps and scripts the GitHub Copilot CLI, and a **Copilot plugin** that ships in-session slash skills, custom agents, and native lifecycle hooks. Both feed the same orchestration modes, the same file-based memory, and the same `.omp` state — so whether you drive from the shell, an in-session `/skill`, Slack, or cron, you hit one coherent system.
+
+```mermaid
+flowchart TB
+  subgraph Surfaces["① Where you drive it"]
+    SH["Shell CLI<br/><code>omp</code> / <code>omp --madmax</code>"]
+    IDE["In-session <code>/skills</code><br/>(Copilot plugin)"]
+    GW["Gateway<br/>Slack / messaging"]
+    CRON["Cron<br/><code>omp schedule</code>"]
+  end
+
+  subgraph Copilot["② GitHub Copilot CLI (wrapped)"]
+    CP["copilot session"]
+    HK["Lifecycle hooks<br/>sessionStart · sessionEnd · agentStop<br/>pre/postToolUse · userPromptSubmitted"]
+    PS["Plugin skills + agents<br/>ralph · ralplan · team · council<br/>code-review · tdd · research · …"]
+  end
+
+  subgraph Orchestration["③ Orchestration modes"]
+    direction LR
+    RALPH["ralph<br/>PRD verify/fix loop"]
+    UW["ultrawork<br/>parallel fan-out"]
+    UQA["ultraqa<br/>QA cycles"]
+    AP["autopilot"]
+    TEAM["team<br/>tmux multi-agent"]
+    COUNCIL["council<br/>weighted consensus"]
+  end
+
+  subgraph Learning["④ Memory & learning loop"]
+    direction LR
+    MR["memory-review<br/>cheap model, end-of-session"]
+    PM["project-memory<br/>directives + notes"]
+    SE["self-evolve<br/>skill drafts"]
+    DL["daily-log"]
+    IM["instructions-memory<br/>→ copilot-instructions.md"]
+  end
+
+  subgraph Store["⑤ Config & state"]
+    direction LR
+    G["~/.omp<br/>global config + .env"]
+    P[".omp/<br/>project config · memory<br/>cost · trace · mode-state"]
+    SST["~/.copilot/session-state<br/>events.jsonl transcripts"]
+  end
+
+  SH --> CP
+  GW --> CP
+  CRON --> CP
+  IDE --> PS
+  CP --> HK
+  PS --> Orchestration
+  SH --> Orchestration
+  HK -- "agentStop drives the loop" --> Orchestration
+  Orchestration --> P
+
+  HK -- "sessionEnd (detached)" --> MR
+  SH -- "wrapper fallback (headless -p)" --> MR
+  MR -- reads transcript --> SST
+  MR -- "facts" --> PM
+  MR -- "procedures" --> SE
+  MR -- "rules (gated)" --> PM
+  PM --> IM
+  DL --> IM
+  IM -- "injected next session" --> CP
+
+  G -. config .-> MR
+  P -. config .-> MR
+  Orchestration -. cost/trace .-> P
+```
+
+**The flow:** you launch a Copilot session from any surface ①. It runs through the wrapped Copilot CLI ②, where plugin hooks and skills can spin up orchestration modes ③ (ralph/ultrawork/ultraqa/team/council). When the session ends, the **learning loop** ④ fires — a cheap model reviews the transcript and writes durable **notes**, gated **directives**, and **skill drafts**, which `instructions-memory` injects into the *next* session so it starts smarter. Everything persists in layered config/state ⑤: global `~/.omp`, per-project `.omp/`, and Copilot's own session transcripts.
+
+> The learning loop is **opt-in** (`omp config set memory-mode on`) and runs on a cheap model (`gpt-5-mini` by default) — the expensive reasoning already happened in your main session. See [docs/memory-mode.md](docs/memory-mode.md).
 
 ---
 
@@ -182,7 +259,8 @@ Notes:
 
 ```bash
 omp --help
-omp version
+omp version                                 # prints version; in a TTY, offers to self-update if one is available
+omp update                                  # self-update the CLI (npm) + refresh the Copilot plugin
 omp doctor                                  # verify install + copilot binary
 omp list                                    # show discovered skills and agents
 omp setup [--dry-run] [--scope project|user]
@@ -205,9 +283,10 @@ omp gateway notify --text "<msg>" [--target slack:C…|G…|D…|U… [:thread_t
 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] [--notify-target slack:U0123ABCD] [--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] [--notify-desktop] [--notify-open-omp] [--dry-run]
 omp schedule list                           # registered jobs + OS-install status
 omp schedule status <id>                    # last run + result summary
+omp schedule open <id> [--tmux]             # print this id's latest status + full output (--tmux: open an omp session)
 omp schedule run-now <id>                   # trigger one run immediately
 omp schedule remove <id>                    # uninstall the OS entry + delete the job
 omp goal set "<objective>" | read [--json]
@@ -227,6 +306,8 @@ Environment overrides:
 - `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)
+- `OMP_DISABLE_DESKTOP_NOTIFY` — when set, suppress all `--notify-desktop` notifications
+- `OMP_NOTIFY_USE_TERMINAL_NOTIFIER` — when set (+ a system `terminal-notifier` on PATH), use it for desktop notifications so the click can open omp; otherwise macOS uses `osascript` (display-only)
 
 **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
@@ -234,8 +315,13 @@ invokes `omp schedule run --id <id>` on the cron schedule. Each tick spawns a fr
 session; overlapping runs are locked out and every run is killed at its `--timeout`
 (default 5 min). Jobs default to **read-only** (`--allow-all-tools` is opt-in and prints a
 warning) and auto-expire after 72h unless `--ttl-hours`/`--max-runs` say otherwise. Recent
-run results are surfaced automatically at the start of new Copilot sessions. Always use
-`omp schedule remove`, never delete `.omp/state/schedule/` by hand, so the OS entry is
+run results are surfaced automatically at the start of new Copilot sessions, and
+`omp schedule open <id>` prints any job's latest status + full captured output on demand.
+Opt into end-of-run **notifications** (default off; failures never affect the job): `--notify-target slack:…`
+posts to Slack, and `--notify-desktop` fires a native notification (job id + status + one-line
+summary) — on macOS via `osascript` (display-only; for a clickable notification that opens omp,
+set `OMP_NOTIFY_USE_TERMINAL_NOTIFIER=1` with a system `terminal-notifier` and add `--notify-open-omp`).
+Always use `omp schedule remove`, never delete `.omp/state/schedule/` by hand, so the OS entry is
 uninstalled cleanly.
 
 ### Chat bridge: drive Copilot from Slack
@@ -269,7 +355,7 @@ omp grows in vertical slices. Items aren't pinned to specific semver versions
 
 ### Already shipped
 
-- **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.
+- **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. Opt-in end-of-run notifications (`--notify-target` Slack, `--notify-desktop` native) and `omp schedule open <id>` to pull up a run's full output by id.
 - **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`.

package/catalog/capabilities.json

@@ -908,6 +908,29 @@
           "notes": "Use /slack from .github/skills/slack/SKILL.md."
         }
       }
+    },
+    {
+      "id": "verify-byok",
+      "name": "verify-byok",
+      "title": "BYOK verification",
+      "category": "verification",
+      "summary": "Static + live BYOK verification of omp changes with evidence capture.",
+      "notes": "Maintainer verification skill: static gate plus a live Copilot/team run on a BYOK model.",
+      "defaultCommand": "verify-byok",
+      "phase1": true,
+      "sourceSkill": "verify-byok",
+      "providers": {
+        "copilot": "supported"
+      },
+      "support": {
+        "copilot": "native"
+      },
+      "providerSupport": {
+        "copilot": {
+          "state": "native",
+          "notes": "Use /verify-byok from .github/skills/verify-byok/SKILL.md."
+        }
+      }
     }
   ]
 }

package/catalog/skills-general.json

@@ -528,6 +528,31 @@
       },
       "projection": "project-skill",
       "phase1": true
+    },
+    {
+      "name": "verify-byok",
+      "capabilityId": "verify-byok",
+      "capabilityIds": [
+        "verify-byok"
+      ],
+      "source": ".github/skills/verify-byok/SKILL.md",
+      "sourcePath": ".github/skills/verify-byok/SKILL.md",
+      "canonicalPath": ".github/skills/verify-byok/SKILL.md",
+      "description": "Verify an omp change with a static gate plus a live BYOK run.",
+      "summary": "Verify an omp change with a static gate plus a live BYOK run.",
+      "support": "project-skill",
+      "aliases": [],
+      "slashCommands": [
+        "verify-byok"
+      ],
+      "projections": {
+        "copilot": {
+          "command": "/verify-byok",
+          "state": "supported"
+        }
+      },
+      "projection": "project-skill",
+      "phase1": true
     }
   ]
 }

package/dist/src/cli.js

@@ -16,6 +16,72 @@ function flagValue(args, flag) {
         return undefined;
     return args[index + 1];
 }
+/**
+ * Interactive only when both streams are TTYs, we're not emitting JSON, and
+ * we're not in CI (which may allocate a pseudo-TTY but must never block on a
+ * prompt). Honors the same no-block contract as update-prompt.ts.
+ */
+function isInteractive(json) {
+    if (process.env.CI?.trim())
+        return false;
+    return Boolean(process.stdout.isTTY && process.stdin.isTTY) && !json;
+}
+/**
+ * Provide an UpdatePromptIO backed by readline. The interface is created lazily
+ * on the first `ask` (so no-update launches never touch the TTY) and always
+ * closed before we return, freeing stdin for a subsequent copilot launch.
+ */
+async function withUpdateIO(fn) {
+    let rl;
+    const io = {
+        print: (line) => console.log(line),
+        ask: async (prompt) => {
+            if (!rl) {
+                const readline = await import("node:readline/promises");
+                rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+            }
+            const answer = await rl.question(prompt);
+            // Release stdin immediately so the update/plugin child processes that
+            // follow (stdio: "inherit") never contend with an open readline.
+            rl.close();
+            rl = undefined;
+            return answer;
+        },
+    };
+    try {
+        return await fn(io);
+    }
+    finally {
+        rl?.close();
+    }
+}
+/**
+ * Re-exec the freshly-installed omp after a self-update so the launch runs the
+ * new version. `npm i -g` overwrote the entrypoint at `process.argv[1]` in
+ * place, so re-running it with the same node executes the new code. The child
+ * inherits stdio (so copilot's TUI works) and gets `OMP_NO_UPDATE_CHECK=1` to
+ * guarantee it can't loop back into the update prompt. Returns null when the
+ * entrypoint can't be resolved, so the caller falls back to a normal launch.
+ */
+async function reexecAfterUpdate(argv) {
+    const entry = process.argv[1];
+    if (!entry)
+        return undefined;
+    const { spawn } = await import("node:child_process");
+    return await new Promise((resolve) => {
+        const child = spawn(process.execPath, [entry, ...argv], {
+            stdio: "inherit",
+            env: { ...process.env, OMP_NO_UPDATE_CHECK: "1" },
+        });
+        child.on("error", () => resolve({ ok: false, exitCode: 127, message: "re-exec failed" }));
+        child.on("close", (code) => {
+            // Match launchCopilot's convention: a signal-terminated child yields a
+            // null code — treat that as a non-zero exit, not success.
+            const exitCode = typeof code === "number" ? code : 1;
+            resolve({ ok: exitCode === 0, exitCode, message: `relaunched omp exit=${exitCode}` });
+        });
+    });
+}
 function printResult(result, json) {
     if (json || typeof result.output === "object") {
         console.log(JSON.stringify(result.output ?? { ok: result.ok, message: result.message }, null, 2));
@@ -26,7 +92,8 @@ function printResult(result, json) {
     }
 }
 function help() {
-    return `oh-my-copilot\n\nRun \`omp\` with no arguments to launch copilot (permissions bypass OFF).\nUse \`omp help\` to show this list.\n\nCommands:\n  (no args)                                     launch copilot (bypass OFF by default)\n  version [--json]\n  list [--json]\n  setup [--dry-run] [--scope project|user] [--plugin-root <dir>] [--json]\n  doctor [--json] [--copilot-bin <path>] [--skip-copilot] [--hooks]\n  cost [--json] [--session <id>] [--days <n>]\n  launch -- <args...>\n  --madmax [args...]                          (bare-flag launch with permissions bypass; alias of --yolo)\n  team <N:role> "<task>" [--name <name>] [--json]\n  team status <name> [--json]\n  team shutdown <name> [--json]\n  team api claim-task --input '<json>' [--json]\n  team api transition-task-status --input '<json>' [--json]\n  team api send-message --input '<json>' [--json]\n  team api broadcast --input '<json>' [--json]\n  team api mailbox-list --input '<json>' [--json]\n  team api mailbox-mark-delivered --input '<json>' [--json]\n  council "<question>" [--models a,b,c|m:role:weight] [--context <text|@file>] [--rubric <text|@file>] [--synth <model>] [--probe] [--timeout <ms>] [--synth-timeout <ms>] [--min-survivors <n>] [--max-concurrency <n>] [--tmp-dir <dir>] [--json]\n  comms status [--session <name>] [--json]      (is copilot on + online? auto-discovers session)\n  comms send --text "<prompt>" [--force] [--session <name>] [--json]\n  comms recv [--wait] [--lines <n>] [--timeout <ms>] [--session <name>] [--json]\n  comms ask --text "<prompt>" [--force] [--lines <n>] [--timeout <ms>] [--session <name>] [--json]\n  gateway serve [--only <name>[,<name>]]        (run all configured connectors; today: slack)\n  gateway status [--json] [--only <name>[,...]] (per-connector readiness; no sockets opened)\n  gateway doctor [--json] [--only <name>[,...]] (alias for 'gateway status')\n  gateway notify --text "<msg>" [--target slack:C\\|D\\|G\\|U... [:thread_ts]] [--thread-ts <ts>] [--json]\n                                                (one-shot outbound Slack post; falls back to SLACK_HOME_CHANNEL)\n  slack serve                                   (deprecated alias for 'gateway serve --only slack')\n  slack doctor [--json]                         (deprecated alias for 'gateway status --only slack')\n  env init [--force]                            (interactive: write ~/.omp/.env with Slack tokens + optional SLACK_HOME_CHANNEL)\n                                                non-interactive: set OMP_INIT_BOT_TOKEN/OMP_INIT_APP_TOKEN/OMP_INIT_HOME_CHANNEL\n                                                (env vars preferred over --bot-token/--app-token/--home-channel flags)\n  (--session is optional when exactly one omp-<digits> tmux session is running)\n${registeredCommandHelpLines().join("\n")}\n  ralph start "<task>" [--max-iterations <n>] [--session-id <id>] [--json]\n  ralph status [--json]\n  ralph tick [--json]\n  ralph cancel [--json]\n  ultrawork start "<objective>" [--task-count <n>] [--summary <s>] [--json]\n  ultrawork status [--json]\n  ultrawork cancel [--json]\n  ultraqa start "<goal>" [--max-cycles <n>] [--json]\n  ultraqa cycle pass|fail|pending [--json]\n  ultraqa status [--json]\n  ultraqa cancel [--json]\n  schedule add --id <id> --cron "<expr>" --prompt "<text>" [--bin copilot] [--model <m>] [--cwd <dir>] [--timeout <ms>] [--max-runs <n>] [--ttl-hours <h>] [--allow-all-tools] [--notify-target slack:<ID>] [--dry-run] [--json]\n  schedule list [--json]\n  schedule status <id> [--json]\n  schedule run-now <id> [--json]\n  schedule remove <id> [--json]\n  goal set "<objective>" [--json]\n  goal read [--json]\n  memory sync [--json]                          (render goal+directives into copilot-instructions.md)\n  config get [--json] | config set memory-mode on|off | config set memory-review-model <slug> | config set memory-review-min-messages <n> [--global]\n                                                (--global writes ~/.omp/config.json; applies to every project. project .omp/config.json overrides it)\n  memory-review --session <uuid|latest> [--model <slug>] [--json]   (cheap-model end-of-session review; opt-in via memory-mode)\n  daily-log set-goal "<text>" [--json]\n  daily-log add "<text>" [--json]\n  daily-log read [--days <n>] [--json]\n  daily-log prune [--keep-days <n>] [--json]\n  state write <key> <val> [--ttl <s>] | read|delete|status <key> | list | cleanup [--json]\n  project-memory read [<id>] | index | add-note "<title>" [--body "<text>"] | add-directive "<rule>" | prune-notes --keep <n>|--older-than <days> [--json]\n  trace timeline [<sessionId>] [--limit <n>] | summary [<sessionId>] | add <sessionId> <event> [<json>] [--json]\n  catalog list [--json]\n  catalog validate [--json]\n  catalog capability <id> [--json]\n  project inspect [--json]\n  skill install <skill-dir> [--root <repo>] [--scope project|user] [--dry-run] [--json]\n  lint:skills [--root <repo>]\n  sync:dry-run [--root <repo>]\n  jira:dry-run [--root <repo>]\n  jira render <plan-file> [--root <repo>] [--json]\n  jira apply <ticket-key-or-plan-file> --comment|--update|--transition|--link [--dry-run] [--json]\n`;
+    return `oh-my-copilot\n\nRun \`omp\` with no arguments to launch copilot (permissions bypass OFF).\nUse \`omp help\` to show this list.\n\nCommands:\n  (no args)                                     launch copilot (bypass OFF by default)\n  version [--json]\n  update                                        (self-update: npm i -g @damian87/omp@latest)\n  list [--json]\n  setup [--dry-run] [--scope project|user] [--plugin-root <dir>] [--json]\n  doctor [--json] [--copilot-bin <path>] [--skip-copilot] [--hooks]\n  cost [--json] [--session <id>] [--days <n>]\n  launch -- <args...>\n  --madmax [args...]                          (bare-flag launch with permissions bypass; alias of --yolo)\n  team <N:role> "<task>" [--name <name>] [--json]\n  team status <name> [--json]\n  team shutdown <name> [--json]\n  team api claim-task --input '<json>' [--json]\n  team api transition-task-status --input '<json>' [--json]\n  team api send-message --input '<json>' [--json]\n  team api broadcast --input '<json>' [--json]\n  team api mailbox-list --input '<json>' [--json]\n  team api mailbox-mark-delivered --input '<json>' [--json]\n  council "<question>" [--models a,b,c|m:role:weight] [--context <text|@file>] [--rubric <text|@file>] [--synth <model>] [--probe] [--timeout <ms>] [--synth-timeout <ms>] [--min-survivors <n>] [--max-concurrency <n>] [--tmp-dir <dir>] [--json]\n  comms status [--session <name>] [--json]      (is copilot on + online? auto-discovers session)\n  comms send --text "<prompt>" [--force] [--session <name>] [--json]\n  comms recv [--wait] [--lines <n>] [--timeout <ms>] [--session <name>] [--json]\n  comms ask --text "<prompt>" [--force] [--lines <n>] [--timeout <ms>] [--session <name>] [--json]\n  gateway serve [--only <name>[,<name>]]        (run all configured connectors; today: slack)\n  gateway status [--json] [--only <name>[,...]] (per-connector readiness; no sockets opened)\n  gateway doctor [--json] [--only <name>[,...]] (alias for 'gateway status')\n  gateway notify --text "<msg>" [--target slack:C\\|D\\|G\\|U... [:thread_ts]] [--thread-ts <ts>] [--json]\n                                                (one-shot outbound Slack post; falls back to SLACK_HOME_CHANNEL)\n  slack serve                                   (deprecated alias for 'gateway serve --only slack')\n  slack doctor [--json]                         (deprecated alias for 'gateway status --only slack')\n  env init [--force]                            (interactive: write ~/.omp/.env with Slack tokens + optional SLACK_HOME_CHANNEL)\n                                                non-interactive: set OMP_INIT_BOT_TOKEN/OMP_INIT_APP_TOKEN/OMP_INIT_HOME_CHANNEL\n                                                (env vars preferred over --bot-token/--app-token/--home-channel flags)\n  (--session is optional when exactly one omp-<digits> tmux session is running)\n${registeredCommandHelpLines().join("\n")}\n  ralph start "<task>" [--max-iterations <n>] [--session-id <id>] [--json]\n  ralph status [--json]\n  ralph tick [--json]\n  ralph cancel [--json]\n  ultrawork start "<objective>" [--task-count <n>] [--summary <s>] [--json]\n  ultrawork status [--json]\n  ultrawork cancel [--json]\n  ultraqa start "<goal>" [--max-cycles <n>] [--json]\n  ultraqa cycle pass|fail|pending [--json]\n  ultraqa status [--json]\n  ultraqa cancel [--json]\n  schedule add --id <id> --cron "<expr>" --prompt "<text>" [--bin copilot] [--model <m>] [--cwd <dir>] [--timeout <ms>] [--max-runs <n>] [--ttl-hours <h>] [--allow-all-tools] [--notify-target slack:<ID>] [--notify-desktop] [--notify-open-omp] [--dry-run] [--json]
+                                                (--notify-desktop: native OS notification on completion [macOS uses osascript]; --notify-open-omp: click opens an omp session in the state root — needs OMP_NOTIFY_USE_TERMINAL_NOTIFIER=1 + terminal-notifier on macOS)\n  schedule list [--json]\n  schedule status <id> [--json]\n  schedule open <id> [--tmux] [--json]          (show this id's latest status + full output; --tmux instead opens an interactive omp session in the project — recent runs show via the startup banner)\n  schedule run-now <id> [--json]\n  schedule remove <id> [--json]\n  goal set "<objective>" [--json]\n  goal read [--json]\n  memory sync [--json]                          (render goal+directives into copilot-instructions.md)\n  config get [--json] | config set memory-mode on|off | config set memory-review-model <slug> | config set memory-review-min-messages <n> [--global]\n                                                (--global writes ~/.omp/config.json; applies to every project. project .omp/config.json overrides it)\n  memory-review --session <uuid|latest> [--model <slug>] [--json]   (cheap-model end-of-session review; opt-in via memory-mode)\n  daily-log set-goal "<text>" [--json]\n  daily-log add "<text>" [--json]\n  daily-log read [--days <n>] [--json]\n  daily-log prune [--keep-days <n>] [--json]\n  state write <key> <val> [--ttl <s>] | read|delete|status <key> | list | cleanup [--json]\n  project-memory read [<id>] | index | add-note "<title>" [--body "<text>"] | add-directive "<rule>" | prune-notes --keep <n>|--older-than <days> [--json]\n  trace timeline [<sessionId>] [--limit <n>] | summary [<sessionId>] | add <sessionId> <event> [<json>] [--json]\n  catalog list [--json]\n  catalog validate [--json]\n  catalog capability <id> [--json]\n  project inspect [--json]\n  skill install <skill-dir> [--root <repo>] [--scope project|user] [--dry-run] [--json]\n  lint:skills [--root <repo>]\n  sync:dry-run [--root <repo>]\n  jira:dry-run [--root <repo>]\n  jira render <plan-file> [--root <repo>] [--json]\n  jira apply <ticket-key-or-plan-file> --comment|--update|--transition|--link [--dry-run] [--json]\n`;
 }
 async function resolveExistingInputPath(value) {
     const { existsSync } = await import("node:fs");
@@ -79,15 +146,40 @@ export async function runCli(argv = process.argv.slice(2)) {
         const versionCheckUrl = pathToFileURL(join(packageRootFromImportMeta(import.meta.url), "scripts", "lib", "version-check.mjs")).href;
         const { checkForUpdate, formatUpdateNotice } = (await import(versionCheckUrl));
         const cwd = flagValue(argv, "--root") ?? process.cwd();
-        const update = await checkForUpdate({ stateDir: join(ompRoot(cwd), ".omp", "state") });
+        const stateDir = join(ompRoot(cwd), ".omp", "state");
+        const skipCheck = Boolean(process.env.OMP_NO_UPDATE_CHECK?.trim());
         if (json) {
+            const update = skipCheck ? null : await checkForUpdate({ stateDir });
             return { ok: true, output: { ...info, update } };
         }
+        // Interactive TTY: print the version, then offer to self-update.
+        if (isInteractive(json)) {
+            console.log(formatVersionInfo(info));
+            const { maybePromptUpdate } = await import("./copilot/update-prompt.js");
+            await withUpdateIO((io) => maybePromptUpdate({ cwd, io, interactive: true, importMetaUrl: import.meta.url }));
+            return { ok: true };
+        }
+        // Non-interactive: keep the passive notice behavior (honoring the opt-out).
+        const update = skipCheck ? null : await checkForUpdate({ stateDir });
         const message = update
             ? `${formatVersionInfo(info)}\n\n${formatUpdateNotice(update.current, update.latest)}`
             : formatVersionInfo(info);
         return { ok: true, message };
     }
+    if (group === "update") {
+        const { runSelfUpdate, updateCopilotPlugin } = await import("./copilot/update-prompt.js");
+        const ok = await runSelfUpdate();
+        if (!ok) {
+            return { ok: false, message: "Update failed; run manually: npm i -g @damian87/omp@latest" };
+        }
+        const plugin = await updateCopilotPlugin();
+        const pluginMsg = plugin === "updated"
+            ? "Copilot plugin updated."
+            : plugin === "failed"
+                ? "Copilot plugin update failed; run: copilot plugin update oh-my-copilot"
+                : "Copilot plugin: skipped (copilot CLI not found).";
+        return { ok: true, message: `omp CLI updated.\n${pluginMsg}\nre-run \`omp\`.` };
+    }
     // Auto-load ~/.omp/.env so subcommands that read process.env (slack tokens,
     // OMP_*, COPILOT_TMUX_SESSION, etc.) work from any cwd without `source .env`.
     // Shell exports take precedence — see src/env/dotenv.ts.
@@ -98,6 +190,27 @@ export async function runCli(argv = process.argv.slice(2)) {
     if (!group || BARE_LAUNCH_FLAGS.has(group)) {
         const { launchCopilot } = await import("./copilot/launch.js");
         const launchCwd = flagValue(argv, "--root") ?? process.cwd();
+        // Truly-bare `omp` in a TTY: offer to self-update, then show the
+        // first-run hint, before handing the terminal to copilot. `--madmax`/
+        // `--yolo` and any non-TTY launch are never blocked.
+        if (!group && isInteractive(json)) {
+            const { maybePromptUpdate, maybeWelcome } = await import("./copilot/update-prompt.js");
+            const outcome = await withUpdateIO((io) => maybePromptUpdate({ cwd: launchCwd, io, interactive: true, importMetaUrl: import.meta.url }));
+            // The running process still holds the OLD code in memory. After a
+            // successful self-update, re-exec the freshly-installed omp so this
+            // launch uses the new version instead of stale wrapper logic.
+            if (outcome.updated) {
+                const reexec = await reexecAfterUpdate(argv);
+                if (reexec)
+                    return reexec;
+                // Fall through to a normal launch if re-exec wasn't possible.
+            }
+            maybeWelcome({
+                cwd: launchCwd,
+                io: { print: (line) => console.log(line), ask: async () => undefined },
+                interactive: true,
+            });
+        }
         const beforeSessions = await snapshotSessionsForReview();
         const result = await launchCopilot({
             args: argv,
@@ -1363,6 +1476,8 @@ async function handleScheduleCommand(argv, json) {
             allowAllTools: hasFlag(argv, "--allow-all-tools"),
             dryRun: hasFlag(argv, "--dry-run"),
             notifyTarget,
+            notifyDesktop: hasFlag(argv, "--notify-desktop"),
+            notifyOpenOmp: hasFlag(argv, "--notify-open-omp"),
         });
         return json
             ? { ok: result.ok, exitCode: result.ok ? 0 : 1, output: result }
@@ -1399,10 +1514,39 @@ async function handleScheduleCommand(argv, json) {
             ? { ok: result.ok, exitCode: result.ok ? 0 : 1, output: result }
             : { ok: result.ok, exitCode: result.ok ? 0 : 1, message: result.message };
     }
+    if (command === "open" && targetId) {
+        const r = mod.openScheduleResult(cwd, targetId);
+        if (!r.ok)
+            return { ok: false, exitCode: 1, output: json ? r : undefined, message: r.error };
+        // --tmux: drop into an interactive omp session (auto-wrapped in tmux by
+        // launchCopilot) rooted at the project. The SessionStart [SCHEDULE RESULTS]
+        // banner surfaces RECENT unseen results across all jobs (not pinned to <id>,
+        // and cursor-gated) — for this id's exact output use `schedule open <id>`
+        // without --tmux. We resolve <id> first only to fail fast on a bad id.
+        if (hasFlag(argv, "--tmux")) {
+            const { launchCopilot } = await import("./copilot/launch.js");
+            const result = await launchCopilot({ args: [], cwd, env: { ...process.env, OMP_FORCE_TMUX_WRAP: "1" } });
+            return {
+                ok: result.ok,
+                exitCode: result.exitCode,
+                message: result.ok ? undefined : `failed to launch omp in tmux (exit ${result.exitCode})`,
+            };
+        }
+        if (json)
+            return { ok: true, output: r };
+        const j = r.job;
+        const header = `${j.id} — ${j.lastStatus ?? "(never run)"} @ ${j.lastRunAt ?? "-"}\n${j.lastSummary ?? ""}`.trim();
+        const body = r.logContent
+            ? `\n\n--- full output (${j.lastLogPath}) ---\n${r.logContent}`
+            : j.lastRunAt
+                ? `\n(log not found: ${j.lastLogPath ?? "n/a"})`
+                : "\n(no run recorded yet)";
+        return { ok: true, message: header + body };
+    }
     return {
         ok: false,
         exitCode: 1,
-        message: 'Unknown schedule subcommand. Try: schedule add --id <id> --cron "<expr>" --prompt "<text>" | list | status <id> | remove <id> | run-now <id>',
+        message: 'Unknown schedule subcommand. Try: schedule add --id <id> --cron "<expr>" --prompt "<text>" | list | status <id> | open <id> | remove <id> | run-now <id>',
     };
 }
 function isEntrypoint() {