@damian87/omp 0.5.0 → 0.7.0

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

@@ -0,0 +1,71 @@
+---
+name: schedule
+description: Register a durable local cron job that re-runs a prompt on a schedule (e.g. "check the PR every 15 min"). Use with /schedule when you want a fresh agent session to fire unattended on an interval and survive reboot.
+---
+
+# Schedule
+
+Use `/schedule` to register, inspect, or remove **durable local cron jobs**. Each
+job spawns a fresh non-interactive agent session at its interval, survives
+machine restart (via the OS scheduler — launchd / systemd / crontab), and writes
+results back to the project so the next session sees them.
+
+This is the in-session front-end to the `omp schedule` CLI. You (the agent) run
+the `omp schedule …` commands on the user's behalf.
+
+## When to use
+
+- The user wants something to run on a repeat: "check the PR every 15 minutes",
+  "run the tests nightly", "poll the deployment hourly".
+- The work should keep happening after the terminal closes and across reboots.
+
+## Do not use when
+
+- The user wants a one-shot task now — just do it.
+- The user wants to keep iterating within this session — use `/ralph` or `/loop`.
+
+## Steps
+
+1. **Clarify** the prompt to run and the cadence (turn natural language into a
+   5-field cron expression, local time). E.g. "every 15 min" → `*/15 * * * *`;
+   "weekdays at 9am" → `0 9 * * 1-5`.
+2. **Decide tool access.** By default jobs run WITHOUT `--allow-all-tools`, so the
+   unattended agent is limited to read-only/allowlisted tools. If the job must
+   act (edit files, run commands, push), add `--allow-all-tools` and confirm with
+   the user first — it runs unattended with full access.
+3. **Register** the job:
+   ```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
+   ```
+   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.
+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).
+7. **Remove** when done: `omp schedule remove --id <id>` (fully uninstalls the OS
+   entry; do NOT delete `.omp/state/schedule/` by hand).
+
+## Safety
+
+- Scheduled runs are unattended. Keep prompts specific and bounded.
+- `--allow-all-tools` grants full tool access with no human in the loop — opt in
+  deliberately, scope the `--cwd`, and prefer a `--max-runs`/`--ttl-hours` cap.
+- Overlapping runs are prevented automatically (one run per job at a time), and
+  every run is killed at its `--timeout` (default 5 min).
+
+## Examples
+
+```bash
+# Babysit a PR every 15 minutes, read-only, for 24 hours
+omp schedule add --id pr-watch --cron "*/15 * * * *" \
+  --prompt "Check open PRs on this repo and summarize any new review comments." \
+  --ttl-hours 24
+
+# Nightly test run that may fix things (full access), capped at 7 runs
+omp schedule add --id nightly-tests --cron "0 2 * * *" \
+  --prompt "Run the test suite; if anything fails, open an issue with the log." \
+  --allow-all-tools --max-runs 7
+```

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

@@ -1,102 +1,127 @@
 ---
 name: team
-description: Split an approved plan into parallel tmux panes, each running an independent Copilot CLI agent. Use when work has independent lanes and you want visual parallel execution in split terminals. Use when user says /team, team, or wants parallel agent execution.
-argument-hint: "<number of lanes or plan reference>"
+description: Split an approved plan into parallel tmux panes in the current window so the user can watch agents work. Prefer this visual flow by default; use `omp team` only when the user explicitly wants background execution or runtime messaging/status APIs.
+argument-hint: "<number of workers> <task description>"
 ---
 
 # Team — tmux-based parallel agent execution
 
-`/team` splits work into parallel tmux panes in the **current window**, each running an independent interactive agent session. You see all agents working side-by-side immediately.
+`/team` launches independent Copilot CLI agents in parallel tmux panes.
+
+**Default behavior:** use the **split-window** flow so the user sees agents working in the current tmux window.
+
+Use **runtime mode** (`omp team`) only when the user explicitly asks for background execution, detached monitoring, or runtime APIs like status, nudging, or worker messaging.
+
+Two modes available:
+
+| Mode | Command | Panes visible in | Best for |
+|------|---------|-------------------|----------|
+| **Split** | `team-launch.sh` | Current window | **Default**. Visual demo, watching agents work |
+| **Runtime** | `omp team N:copilot "task"` | Separate tmux session | Explicit background jobs, task tracking, nudging, messaging |
 
 ## When to use
 
 - Work has **independent lanes** (no shared files, no ordering constraints)
-- You want visual, demo-friendly parallel execution in split terminals
+- You want parallel execution in split terminals
 
-## Agent execution steps (FOLLOW EXACTLY)
+## Default mode — Split window (`team-launch.sh`)
 
-When `/team` is invoked, you MUST execute these steps in order:
+Use this unless the user asks for background execution.
 
-### Step 1 — Identify lanes
+### When to choose it
 
-Collect independent work lanes from the conversation context. Each lane needs:
-- `id`: short kebab-case identifier (e.g. `lane-a`, `fix-auth`)
-- `name`: human-readable name (e.g. `Upgrade dependencies`)
-- `prompt`: complete task prompt — must be self-contained with all context the agent needs (files to change, what to do, commit message)
+- The user wants to **see** the agents working
+- You want panes in the **current tmux window**
+- You are demoing or smoke-testing the skill
 
-If no plan or lanes exist yet, ask the user what work to split.
+### Step 1 — Write lanes JSON
 
-### Step 2 — Write lanes JSON
-
-Write a temporary lanes file at `/tmp/team-lanes-<timestamp>.json`:
+Write a temporary file at `/tmp/team-lanes-<timestamp>.json`:
 
 ```json
 [
-  {
-    "id": "lane-a",
-    "name": "Short descriptive name",
-    "prompt": "Complete self-contained task prompt for the agent..."
-  },
-  {
-    "id": "lane-b",
-    "name": "Another lane name",
-    "prompt": "Another complete task prompt..."
-  }
+  { "id": "lane-a", "name": "Short name", "prompt": "Complete self-contained task prompt..." },
+  { "id": "lane-b", "name": "Another lane", "prompt": "Another task prompt..." }
 ]
 ```
 
-### Step 3 — Launch the team
-
-Run the launch script, passing the session name and lanes file path:
+### Step 2 — Launch
 
+```bash
+bash ~/.copilot/installed-plugins/oh-my-copilot/oh-my-copilot/.github/skills/team/scripts/team-launch.sh \
+  --session "team-<name>" --lanes <lanes-file>
 ```
-.github/skills/team/scripts/team-launch.sh --session "team-<name>" --lanes <lanes-file>
+
+The script:
+1. Splits the **current window** into panes
+2. Launches `omp --madmax` in each
+3. Auto-accepts folder trust prompts
+4. Waits for readiness, sends prompts
+5. Monitors completion and prints a results summary
+
+### Step 3 — Report
+
+The script blocks and prints all results. Relay the output to the user.
+
+## Optional mode — Runtime (`omp team`)
+
+Choose this only when the user explicitly wants the team to run in the background or needs runtime features.
+
+### When to choose it
+
+- The user asked for a **background** team
+- You need `omp team status`, shutdown, or runtime task APIs
+- You do **not** need the panes in the current tmux window
+
+### Launch
+
+```bash
+omp team <N>:copilot "<task description>"
 ```
 
-This will:
-- Split the **current tmux window** into panes (leader keeps its pane)
-- Launch `omp --madmax` interactively in each pane, then send the prompt
-- Arrange panes in a tiled grid layout
-- Print pane IDs and navigation commands
+The runtime automatically:
+1. Creates a tmux session with split panes
+2. Launches `copilot --allow-all-tools` in each pane
+3. Auto-accepts folder trust prompts
+4. Waits for readiness, then sends the task prompt
+5. Tracks task state, heartbeats, and supports idle-nudging
 
-### Step 4 — Report to user
+### Monitor and cleanup
 
-Show the user:
-- Which panes were created and what each is working on
-- Navigation: `Ctrl-b + arrow keys` to move between panes
-- How to check output: `tmux capture-pane -t <pane-id> -p -S -50`
-- How to kill panes when done
+```bash
+omp team status <team-name>       # check progress
+tmux attach -t omp-team-<name>    # watch panes live
+omp team shutdown <team-name>     # kill when done
+```
 
 ## Prerequisites
 
-- `tmux` installed and running inside a tmux session
-- `omp` (oh-my-copilot) on PATH — preferred, launches with `omp --madmax`
-- Falls back to `copilot` if `omp` is not available
-- `jq` for JSON parsing
+- `tmux` installed and session running
+- `omp` on PATH
+- `jq` for JSON parsing (split mode only)
 
-## Prompt guidelines
+## Task / prompt guidelines
 
-Each lane prompt must be **self-contained**. The agent in that pane has no context from this session. Include:
+Each task must be **self-contained**. The agent has no context from this session. Include:
 - Exact files or directories to work in
-- What to do (fix, upgrade, accept, etc.)
-- How to verify (run tests, npm audit, etc.)
+- What to do (fix, upgrade, etc.)
+- How to verify (run tests, etc.)
 - Commit message to use
 
-### Good prompt example
+### Good example
 
-> You are working in /Users/me/project. In src/auth/login.ts, replace the bcrypt password check with argon2. Update the import, change the verify call, and run `npm test -- --grep auth` to confirm. Commit with message "refactor: switch password hashing to argon2".
+> In src/auth/login.ts, replace bcrypt with argon2. Update the import, change the verify call, run `npm test -- --grep auth`. Commit: "refactor: switch to argon2".
 
-### Bad prompt example
+### Bad example
 
-> Fix the auth module. (Too vague — which file? What fix? How to verify?)
+> Fix the auth module. (Too vague)
 
 ## Composition
 
-Use `/ralplan` before `/team` to produce the plan that defines lanes. Use `/verify` after all panes complete to confirm combined results don't conflict.
+Use `/ralplan` before `/team` to produce the plan. Use `/verify` after completion.
 
 ## Limitations
 
-- Each pane is an independent agent session — no shared state or messaging
-- Agents cannot communicate with each other — if tasks depend on each other, use `/ralph` instead
-- Leader (you) must manually verify results after all panes complete
-- Best for independent, non-conflicting work streams
+- Each pane is an independent session — no shared state
+- Workers can message each other via `omp team api send-message` (runtime mode only)
+- If tasks depend on each other, use `/ralph` instead

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

@@ -7,9 +7,11 @@ set -euo pipefail
 # Usage:
 #   team-launch.sh --session <name> --lanes <lanes.json>
 #
-# Each pane launches an interactive `omp --madmax` (or `copilot`) session,
-# then sends the lane prompt via tmux send-keys so the agent stays alive
-# for follow-up interaction.
+# Flow:
+#   1. Split panes and launch agent CLI in each
+#   2. Wait for each agent to be ready (auto-accept folder trust prompts)
+#   3. Send lane prompts via send-keys
+#   4. Monitor until all agents finish, then print summary
 
 SESSION=""
 LANES_FILE=""
@@ -33,13 +35,11 @@ if [[ ! -f "$LANES_FILE" ]]; then
 fi
 
 if ! command -v tmux &>/dev/null; then
-  echo "tmux not found" >&2
-  exit 1
+  echo "tmux not found" >&2; exit 1
 fi
 
 if [[ -z "${TMUX:-}" ]]; then
-  echo "Not inside a tmux session. Run this from within tmux." >&2
-  exit 1
+  echo "Not inside a tmux session. Run this from within tmux." >&2; exit 1
 fi
 
 if command -v omp &>/dev/null; then
@@ -47,31 +47,60 @@ if command -v omp &>/dev/null; then
 elif command -v copilot &>/dev/null; then
   AGENT_CMD="copilot"
 else
-  echo "Neither omp nor copilot CLI found" >&2
-  exit 1
+  echo "Neither omp nor copilot CLI found" >&2; exit 1
 fi
 
 LANE_COUNT=$(jq length "$LANES_FILE")
 if [[ "$LANE_COUNT" -lt 1 ]]; then
-  echo "No lanes defined in $LANES_FILE" >&2
-  exit 1
+  echo "No lanes defined in $LANES_FILE" >&2; exit 1
 fi
 
 CWD=$(pwd)
-WAIT_SECS="${TEAM_AGENT_WAIT:-5}"
+POLL="${TEAM_POLL_INTERVAL:-2}"
+MAX_READY="${TEAM_MAX_READY_WAIT:-60}"
+MAX_DONE="${TEAM_MAX_COMPLETION_WAIT:-300}"
+
+# ── helpers ──────────────────────────────────────────────────────────
+
+# Capture visible pane content (last N lines)
+pane_text() { tmux capture-pane -t "$1" -p -S "-${2:-20}" 2>/dev/null || true; }
+
+# Wait until the agent CLI is fully ready ('/ commands' status bar visible).
+# Auto-accepts the folder-trust dialog if it appears.
+wait_for_ready() {
+  local pane="$1" elapsed=0 accepted=0
+  while (( elapsed < MAX_READY )); do
+    local txt
+    txt=$(pane_text "$pane" 25)
+
+    # Ready: the '/ commands' status bar means the CLI input prompt is active
+    if echo "$txt" | grep -q '/ commands'; then
+      return 0
+    fi
+
+    # Auto-accept folder trust dialog
+    if (( accepted == 0 )) && echo "$txt" | grep -q 'Do you trust'; then
+      tmux send-keys -t "$pane" C-m
+      accepted=1
+      echo "    ↳ Auto-accepted folder trust for $pane"
+    fi
+
+    sleep "$POLL"
+    elapsed=$((elapsed + POLL))
+  done
+  return 1
+}
+
+# ── step 1: create panes ─────────────────────────────────────────────
 
 echo "🚀 Splitting current window into $LANE_COUNT panes ($SESSION)"
 echo ""
 
-# Collect pane IDs as we create them
 PANE_IDS=()
-
 for i in $(seq 0 $((LANE_COUNT - 1))); do
   LANE_NAME=$(jq -r ".[$i].name" "$LANES_FILE")
-  LANE_PROMPT=$(jq -r ".[$i].prompt" "$LANES_FILE")
   LANE_ID=$(jq -r ".[$i].id" "$LANES_FILE")
 
-  # Split: alternate horizontal/vertical for a grid
   if (( i == 0 )); then
     PANE_ID=$(tmux split-window -h -c "$CWD" -P -F '#{pane_id}')
   elif (( i % 2 == 1 )); then
@@ -79,54 +108,123 @@ for i in $(seq 0 $((LANE_COUNT - 1))); do
   else
     PANE_ID=$(tmux split-window -v -t "${PANE_IDS[$((i-2))]}" -c "$CWD" -P -F '#{pane_id}')
   fi
-
   PANE_IDS+=("$PANE_ID")
 
-  # Set pane title
   tmux select-pane -t "$PANE_ID" -T "$LANE_ID: $LANE_NAME"
+  tmux send-keys -t "$PANE_ID" "$AGENT_CMD" C-m
 
-  # Launch interactive agent session (NOT with -p)
-  tmux send-keys -t "$PANE_ID" "echo '═══ $LANE_NAME ═══' && $AGENT_CMD" C-m
-
-  echo "  ✅ Pane $PANE_ID → $LANE_NAME (launching agent...)"
+  echo "  ✅ Pane $PANE_ID → $LANE_NAME"
 done
 
-# Rebalance layout
 tmux select-layout tiled
 
-# Wait for agents to start up before sending prompts
+# ── step 2: wait for readiness ───────────────────────────────────────
+
 echo ""
-echo "⏳ Waiting ${WAIT_SECS}s for agents to initialise..."
-sleep "$WAIT_SECS"
+echo "⏳ Waiting for agents to initialise (up to ${MAX_READY}s)..."
 
-# Now send prompts to each interactive session
+for i in $(seq 0 $((LANE_COUNT - 1))); do
+  PANE_ID="${PANE_IDS[$i]}"
+  LANE_NAME=$(jq -r ".[$i].name" "$LANES_FILE")
+  if wait_for_ready "$PANE_ID"; then
+    echo "  ✅ $PANE_ID ($LANE_NAME) ready"
+  else
+    echo "  ⚠️  $PANE_ID ($LANE_NAME) not ready after ${MAX_READY}s — sending anyway"
+  fi
+done
+
+# ── step 3: send prompts (literal text + Enter separately) ───────────
+
+echo ""
+echo "📨 Sending prompts..."
 for i in $(seq 0 $((LANE_COUNT - 1))); do
   LANE_PROMPT=$(jq -r ".[$i].prompt" "$LANES_FILE")
   LANE_NAME=$(jq -r ".[$i].name" "$LANES_FILE")
   PANE_ID="${PANE_IDS[$i]}"
 
-  # Write prompt to temp file and use tmux load-buffer + paste for reliable delivery
-  PROMPT_FILE="/tmp/team-prompt-${SESSION}-${i}.txt"
-  printf '%s' "$LANE_PROMPT" > "$PROMPT_FILE"
-
-  # Send via tmux send-keys -l (literal) then Enter
-  tmux send-keys -t "$PANE_ID" -l "$(cat "$PROMPT_FILE")"
+  # -l = literal (no key interpretation), then C-m = Enter as a separate call
+  tmux send-keys -t "$PANE_ID" -l "$LANE_PROMPT"
+  sleep 0.3
   tmux send-keys -t "$PANE_ID" C-m
 
-  echo "  📨 Sent prompt to $PANE_ID ($LANE_NAME)"
+  echo "  📨 Sent to $PANE_ID ($LANE_NAME)"
 done
 
-# Switch focus back to the original (leader) pane
 tmux select-pane -t '{left}'
 
+# ── step 4: monitor completion ───────────────────────────────────────
+
 echo ""
-echo "✅ $LANE_COUNT interactive agent sessions running in split panes"
+echo "⏳ Monitoring agents for completion (up to ${MAX_DONE}s)..."
+
+# Brief pause so agents start processing before we poll
+sleep 5
+
+# State per lane: 0=waiting-for-busy, 1=busy, 2=done
+LANE_STATE=()
+for i in $(seq 0 $((LANE_COUNT - 1))); do LANE_STATE[$i]=0; done
+
+COMPLETED=0
+ELAPSED=0
+while (( COMPLETED < LANE_COUNT && ELAPSED < MAX_DONE )); do
+  sleep "$POLL"
+  ELAPSED=$((ELAPSED + POLL))
+
+  for i in $(seq 0 $((LANE_COUNT - 1))); do
+    [[ "${LANE_STATE[$i]}" == "2" ]] && continue
+
+    PANE_ID="${PANE_IDS[$i]}"
+    LANE_NAME=$(jq -r ".[$i].name" "$LANES_FILE")
+
+    # Pane died?
+    if ! tmux list-panes -a -F '#{pane_id}' 2>/dev/null | grep -q "^${PANE_ID}$"; then
+      echo "  ❌ $PANE_ID ($LANE_NAME) — pane died"
+      LANE_STATE[$i]=2; COMPLETED=$((COMPLETED + 1)); continue
+    fi
+
+    local_capture=$(pane_text "$PANE_ID" 15)
+
+    # State 0→1: agent started working (response marker ● appears)
+    if [[ "${LANE_STATE[$i]}" == "0" ]]; then
+      if echo "$local_capture" | grep -q '●'; then
+        LANE_STATE[$i]=1
+      fi
+      continue
+    fi
+
+    # State 1→2: agent finished (back to idle — '/ commands' in last 5 lines)
+    if echo "$local_capture" | tail -5 | grep -q '/ commands'; then
+      echo "  ✅ $PANE_ID ($LANE_NAME) — agent finished"
+      LANE_STATE[$i]=2; COMPLETED=$((COMPLETED + 1))
+    fi
+  done
+done
+
 echo ""
-echo "Pane IDs: ${PANE_IDS[*]}"
+if (( COMPLETED == LANE_COUNT )); then
+  echo "🎉 All $LANE_COUNT agents completed!"
+else
+  echo "⏰ Timeout — $((LANE_COUNT - COMPLETED)) agent(s) still running"
+fi
+
+# ── summary ──────────────────────────────────────────────────────────
+
 echo ""
-echo "Commands:"
-echo "  tmux select-layout tiled              # rebalance layout"
-echo "  tmux capture-pane -t <pane-id> -p -S -50  # read pane output"
-echo "  Ctrl-b + arrow keys                   # navigate between panes"
+echo "═══ Results Summary ═══"
+for i in $(seq 0 $((LANE_COUNT - 1))); do
+  PANE_ID="${PANE_IDS[$i]}"
+  LANE_NAME=$(jq -r ".[$i].name" "$LANES_FILE")
+  LANE_ID=$(jq -r ".[$i].id" "$LANES_FILE")
+  echo ""
+  echo "── $LANE_ID: $LANE_NAME ($PANE_ID) ──"
+  if tmux list-panes -a -F '#{pane_id}' 2>/dev/null | grep -q "^${PANE_ID}$"; then
+    pane_text "$PANE_ID" 40 | grep -E '●|✅|❌|⚠|error|Error|FAIL|PASS|done|Done' | tail -10 || echo "  (no notable output captured)"
+  else
+    echo "  (pane no longer exists)"
+  fi
+done
+
 echo ""
-echo "💡 Agents are interactive — you can send follow-up prompts to any pane"
+echo "Pane IDs: ${PANE_IDS[*]}"
+echo "Navigate: Ctrl-b + arrow keys"
+echo "💡 Agents are interactive — send follow-up prompts to any pane"

package/README.md

@@ -82,6 +82,7 @@ That's it.
 ### Developer Experience
 
 - **MCP server** ships with `notepad`, `project-memory`, `shared-memory`, `state`, and `trace` tools out of the box
+- **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
 - **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)
@@ -113,6 +114,7 @@ These run **inside a Copilot CLI session** after the plugin is installed.
 | `/grill-me`             | Stress-test a plan with Socratic questions                | `/grill-me`                                          |
 | `/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"`   |
 
 ---
 
@@ -182,6 +184,7 @@ omp list                                    # show discovered skills and agents
 omp setup [--dry-run] [--scope project|user]
 omp launch -- [copilot flags…]              # forward arbitrary args to copilot
 omp --madmax -p "edit src/foo.ts"           # bare-flag, maps to copilot --yolo
+omp suggest "fix flaky tests"               # recommend a slash-skill workflow
 omp team 3:executor "fix all type errors"   # spawn tmux workers
 omp team status <name>
 omp team shutdown <name>
@@ -189,6 +192,11 @@ omp ralph start "<task>" [--max-iterations N]
 omp ultrawork start "<objective>" [--task-count N]
 omp ultraqa start "<goal>" [--max-cycles N]
 omp council "<question>" [--models a,b,c] [--context @file] [--json]   # multi-model council
+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 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 catalog list | validate | capability <id>
 omp jira render <plan-file>
@@ -199,6 +207,17 @@ 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`)
+
+**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
+invokes `omp schedule run --id <id>` on the cron schedule. Each tick spawns a fresh agent
+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
+uninstalled cleanly.
 
 ---
 
@@ -218,9 +237,9 @@ Auto-snapshot the working tree before any tool-driven file edit. `omp rollback [
 
 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
+### v0.5 — Scheduled tasks ✅ (shipped)
 
-Natural-language cron: `omp schedule "every weekday 9am run /code-review on main"`. Jobs can attach skills, deliver results to a notification gateway, and support pause/resume/edit. Built on the same mode-state primitives Ralph and UltraQA use.
+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)
 

package/catalog/skills-general.json

@@ -91,8 +91,8 @@
       "source": ".github/skills/team/SKILL.md",
       "sourcePath": ".github/skills/team/SKILL.md",
       "canonicalPath": ".github/skills/team/SKILL.md",
-      "description": "Split approved plans into parallel lanes.",
-      "summary": "Split approved plans into parallel lanes.",
+      "description": "Split approved plans into visible tmux lanes in the current window by default.",
+      "summary": "Split approved plans into visible tmux lanes by default.",
       "support": "project-skill",
       "aliases": [],
       "slashCommands": [

package/dist/src/cli.d.ts

@@ -1,10 +1,5 @@
 #!/usr/bin/env node
-interface CliResult {
-    ok: boolean;
-    exitCode?: number;
-    output?: unknown;
-    message?: string;
-}
+import type { CliResult } from "./commands/types.js";
 export declare function runCli(argv?: string[]): Promise<CliResult>;
 /** Parse a --models value: comma-separated `model` or `model:role:weight` tokens. */
 export declare function parseModelsFlag(value: string): {
@@ -14,4 +9,3 @@ export declare function parseModelsFlag(value: string): {
 }[];
 /** Parse a numeric flag as a finite positive integer; throw on malformed input. */
 export declare function parsePositiveIntFlag(value: string | undefined, flag: string): number | undefined;
-export {};