@damian87/omp 0.4.1 → 0.6.0

package/.github/agents/researcher.md

@@ -1,6 +1,6 @@
 ---
 name: researcher
-description: Map the codebase or external docs to answer a specific question. Returns evidence, not opinions. Backed by the oh-my-copilot MCP tools (notepad / project_memory / shared_memory / trace) for note-taking across turns.
+description: Map the codebase or external docs to answer a specific question. Returns evidence, not opinions. Backed by the oh-my-copilot CLI (omp daily-log / project-memory / state) for note-taking across turns.
 ---
 
 # researcher
@@ -17,10 +17,11 @@ Find evidence and document it. Do not propose changes.
 - Open questions that need more digging (if any).
 
 ## Guidance
-- Use the MCP tools when available:
-  - `notepad_write_working` to stash interim findings between turns.
-  - `project_memory_add_note` for facts worth keeping for the whole project.
-  - `trace_timeline` if the question involves event history.
+- Use the `omp` CLI for note-taking (run as shell commands):
+  - `omp daily-log add "<text>"` to record interim findings as you go.
+  - `omp project-memory add-note "<text>"` for facts worth keeping for the whole project.
+  - `omp state write <key> <json>` / `omp state read <key>` for transient structured scratch between turns.
+  - `omp trace timeline` if the question involves event history.
 - Cite, don't paraphrase. Quote the line you found.
 - If you can't find an answer, say so plainly — don't invent one.
-- Do not modify code or files unrelated to research artifacts (notepad, project memory).
+- Do not modify code or files unrelated to research artifacts (daily log, project memory).

package/.github/copilot-instructions.md

@@ -33,3 +33,26 @@ Skip when the session was fewer than 3 turns or contained no user corrections.
 Invoke `/self-evolve` **at most once per session.** After it reports back, do not invoke it again — even if the user replies "thanks" or "done" to the report itself. Just acknowledge and end the session.
 
 The skill lives at `.github/skills/self-evolve/SKILL.md`. It is self-contained: it tells you which signals count as corrections, where to log them, and when a recurring pattern should become a draft skill.
+
+## Daily log & repo goal
+
+Keep lightweight memory in `.omp/` so the next session has context. **Be sparse** — these are
+memory aids, not a transcript. Float kills their value.
+
+- **Repo goal** (`.omp/goal.md`, via `/goal`): set/update the one-line objective when it is
+  established or genuinely shifts. Not every session.
+- **Daily log** (`.omp/memory/daily/<date>.md`, via `/daily-log`):
+  - When a heavy mode (`/ralph`, `/ralplan`, `/omp-autopilot`, `/team`, `/ultrawork`,
+    `/ultraqa`) starts, set today's goal from its objective: `omp daily-log set-goal "<text>"`.
+  - When such a mode finishes, add **one** concise summary entry — `omp daily-log add "<text>"`:
+    what changed, key decisions, next step.
+  - Otherwise add an entry only at a genuine milestone you judge worth remembering.
+- **Project memory**: `omp project-memory add-directive "<rule>"` for a must-follow rule —
+  directives are **injected at every session start** (never on-demand), so add only real,
+  lasting rules and keep them few. `omp project-memory add-note "<title>" [--body "<text>"]`
+  for durable facts; list them with `omp project-memory index` and load one with
+  `omp project-memory read <id>` — bodies stay on disk until asked, so notes never bloat context.
+- **Caps & retention:** keep directives to a handful (only the first ~12 are injected at start);
+  a few daily entries per day — decisions and outcomes, not narration; skip trivial sessions;
+  never log per skill invocation. Trim old day-files with `omp daily-log prune [--keep-days <n>]`
+  (default 30).

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

@@ -0,0 +1,64 @@
+---
+name: daily-log
+description: Keep a simple per-project daily memory log under the project's daily-memory directory. Review it at session start when relevant, set today's goal, append milestones, and summarize before wrapping up. Use when the user says /daily-log, asks to record/recall what was done, or at end of session.
+---
+
+# Daily Log
+
+A lightweight, human-readable journal stored **per project** at `.omp/memory/daily/<YYYY-MM-DD>.md`.
+Each day has a `## Goal` and a timestamped `## Log`. It is written and read through the `omp`
+CLI (run these as shell commands):
+
+- `omp daily-log set-goal "<text>"` — set/replace today's goal (the day's intent).
+- `omp daily-log add "<text>"` — append a timestamped bullet to today's log.
+- `omp daily-log read [--days N]` — read today + the previous N days (default 1).
+
+The command writes under the current project's `.omp/`, so every project keeps its own log
+automatically.
+
+## When to use each
+
+### At session start (review)
+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.
+```
+
+If the breadcrumb looks relevant to what the user is asking for — same feature, an open
+goal, or continuation of yesterday's work — run `omp daily-log read` to pull the full recent
+log. If the new request is clearly unrelated, **skip it**; loading is optional.
+
+### When intent is established
+Once you and the user agree on what today is about, run `omp daily-log set-goal "<text>"` with a
+short one-line goal (e.g. "Ship the daily-log feature").
+
+### At milestones
+After a meaningful step — a decision made, a feature landed, a blocker hit — run
+`omp daily-log add "<text>"` with a concise note. Record *what changed and why*, not narration.
+Good: "Chose breadcrumb+lazy-load over always-inject to keep start message small."
+Avoid: "Ran the build."
+
+### Resume nudge (start of the next session)
+There is no per-turn nudge. Instead, if a session did real work but wrote nothing,
+the **next** SessionStart injects a one-line reminder:
+
+```
+[DAILY LOG] Your last session made progress but recorded nothing ...
+```
+
+Treat it as a prompt to capture what changed before moving on — or, better, summarize
+into the log *before ending* the session (below), so the nudge never needs to fire.
+
+### Before wrapping up (the real end-of-session write)
+When the user signals they're done, **summarize the session into the log** with one or two
+`omp daily-log add "<text>"` commands: what was accomplished, key decisions, and the next step
+for tomorrow. The SessionEnd hook cannot reach the model, so this end-of-session summary happens here.
+
+## Notes
+- Keep entries short; the log is a memory aid, not a transcript.
+- The file is safe to hand-edit: the CLI preserves your lines in the Goal and Log
+  sections verbatim (only blank spacer lines between entries are dropped on rewrite).
+- Do not put secrets in the log — it is a plain file committed nowhere by this skill but
+  readable by anyone with repo access.

package/.github/skills/goal/SKILL.md

@@ -0,0 +1,33 @@
+---
+name: goal
+description: Set or show the repo's durable objective — what we want to achieve in this repo — stored per project at .omp/goal.md. Use when the user says /goal, states the repo's north-star, or asks "what are we trying to achieve here".
+---
+
+# Goal
+
+The repo's **durable objective** — the north-star for this project — stored per project at
+`.omp/goal.md`. It is distinct from a daily log's per-day goal: this is the long-lived "what
+we want to achieve in this repo", set rarely and updated only when the objective changes.
+
+It is read and written through the `omp` CLI (run these as shell commands):
+
+- `omp goal set "<objective>"` — set/replace the repo objective (one concise line).
+- `omp goal read` — print the current repo objective.
+
+The command writes under the current project's `.omp/`, so every repo keeps its own goal
+automatically.
+
+## When to use
+
+- **`/goal <text>`** — the user states the objective; run `omp goal set "<one concise line>"`.
+- **`/goal`** (no text) — run `omp goal read` and show the current objective. If none is set,
+  offer to set one.
+- The SessionStart hook surfaces the goal as a `[REPO GOAL] …` line, so it is already in
+  context at the start of each session — only run `omp goal read` when the user asks explicitly.
+
+## Notes
+
+- Keep it to a single north-star sentence; it is not a task list. Use the daily log
+  (`/daily-log`) for day-to-day progress toward this goal.
+- Update it when the objective genuinely shifts — not every session.
+- Do not put secrets in it; `.omp/goal.md` is a plain file readable by anyone with repo access.

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/README.md

@@ -113,6 +113,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"`   |
 
 ---
 
@@ -189,6 +190,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 +205,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 +235,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/dist/src/cli.js

@@ -22,7 +22,7 @@ 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]\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  mcp                                           (run MCP server over stdio)\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  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  list [--json]\n  setup [--dry-run] [--scope project|user] [--plugin-root <dir>] [--json]\n  doctor [--json] [--copilot-bin <path>] [--skip-copilot]\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  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] [--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  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>" [--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");
@@ -117,14 +117,6 @@ export async function runCli(argv = process.argv.slice(2)) {
     if (group === "council") {
         return await handleCouncilCommand(argv, json);
     }
-    if (group === "mcp") {
-        const { runMcpServer } = await import("./mcp/server.js");
-        const { allTools } = await import("./mcp/tools/index.js");
-        const { filterToolsByEnv } = await import("./mcp/server.js");
-        const tools = filterToolsByEnv(allTools);
-        await runMcpServer({ name: "oh-my-copilot", version: "0.1.0", tools });
-        return { ok: true, message: "mcp server exited" };
-    }
     if (group === "ralph") {
         return await handleModeCommand("ralph", argv, json);
     }
@@ -134,6 +126,198 @@ export async function runCli(argv = process.argv.slice(2)) {
     if (group === "ultraqa") {
         return await handleModeCommand("ultraqa", argv, json);
     }
+    if (group === "schedule") {
+        return await handleScheduleCommand(argv, json);
+    }
+    if (group === "goal") {
+        const { readRepoGoal, writeRepoGoal } = await import("./goal.js");
+        const { syncInstructionsMemory } = await import("./instructions-memory.js");
+        const cwd = flagValue(argv, "--root") ?? process.cwd();
+        if (command === "set") {
+            if (!value || !value.trim() || value.startsWith("-")) {
+                return { ok: false, exitCode: 1, message: 'usage: omp goal set "<objective>"' };
+            }
+            const goal = writeRepoGoal(cwd, value);
+            syncInstructionsMemory(cwd); // refresh the managed block Copilot reads
+            return json ? { ok: true, output: { ok: true, goal } } : { ok: true, message: `repo goal set: ${goal}` };
+        }
+        if (command === "read" || command === undefined) {
+            const goal = readRepoGoal(cwd);
+            return json ? { ok: true, output: { goal } } : { ok: true, message: goal || "(no repo goal set)" };
+        }
+        return { ok: false, exitCode: 1, message: 'Unknown goal subcommand. Try: goal set "<text>" | goal read' };
+    }
+    if (group === "memory") {
+        const { syncInstructionsMemory } = await import("./instructions-memory.js");
+        const cwd = flagValue(argv, "--root") ?? process.cwd();
+        if (command === "sync" || command === undefined) {
+            const r = syncInstructionsMemory(cwd);
+            return json
+                ? { ok: r.wrote, output: r }
+                : { ok: r.wrote, message: r.wrote ? `memory synced to ${r.path}` : `could not write ${r.path}` };
+        }
+        return { ok: false, exitCode: 1, message: "Unknown memory subcommand. Try: memory sync" };
+    }
+    if (group === "daily-log") {
+        const { setDailyGoal, addLogEntry, readDailyLog, pruneDailyLog } = await import("./daily-log.js");
+        const cwd = flagValue(argv, "--root") ?? process.cwd();
+        if (command === "set-goal") {
+            if (!value || !value.trim() || value.startsWith("-")) {
+                return { ok: false, exitCode: 1, message: 'usage: omp daily-log set-goal "<text>"' };
+            }
+            const res = setDailyGoal(cwd, value);
+            return json ? { ok: true, output: { ok: true, ...res } } : { ok: true, message: `daily goal set (${res.date}): ${res.goal}` };
+        }
+        if (command === "add") {
+            if (!value || !value.trim() || value.startsWith("-")) {
+                return { ok: false, exitCode: 1, message: 'usage: omp daily-log add "<text>"' };
+            }
+            const res = addLogEntry(cwd, value);
+            return json ? { ok: true, output: { ok: true, ...res } } : { ok: true, message: `logged (${res.date}); ${res.count} entr${res.count === 1 ? "y" : "ies"} today` };
+        }
+        if (command === "read" || command === undefined) {
+            const daysRaw = flagValue(argv, "--days");
+            const days = daysRaw !== undefined && Number.isFinite(Number(daysRaw)) ? Number(daysRaw) : 1;
+            const text = readDailyLog(cwd, days);
+            return json ? { ok: true, output: { log: text } } : { ok: true, message: text || "(no daily log entries)" };
+        }
+        if (command === "prune") {
+            const keepRaw = flagValue(argv, "--keep-days");
+            const keepDays = keepRaw !== undefined && Number.isFinite(Number(keepRaw)) ? Number(keepRaw) : 30;
+            const removed = pruneDailyLog(cwd, keepDays);
+            return json
+                ? { ok: true, output: { removed } }
+                : { ok: true, message: `pruned ${removed.length} day-file(s) older than ${keepDays}d` };
+        }
+        return {
+            ok: false,
+            exitCode: 1,
+            message: 'Unknown daily-log subcommand. Try: daily-log set-goal "<text>" | add "<text>" | read [--days N] | prune [--keep-days N]',
+        };
+    }
+    if (group === "state") {
+        const s = await import("./state.js");
+        const cwd = flagValue(argv, "--root") ?? process.cwd();
+        if (command === "read" && value) {
+            return { ok: true, output: s.stateRead(cwd, value) };
+        }
+        if (command === "write" && value) {
+            const raw = argv[3];
+            if (raw === undefined)
+                return { ok: false, exitCode: 1, message: "usage: omp state write <key> <json-or-string> [--ttl <sec>]" };
+            let parsed;
+            try {
+                parsed = JSON.parse(raw);
+            }
+            catch {
+                parsed = raw;
+            }
+            const ttlRaw = flagValue(argv, "--ttl");
+            const ttl = ttlRaw !== undefined && Number.isFinite(Number(ttlRaw)) ? Number(ttlRaw) : undefined;
+            const expiresAt = s.stateWrite(cwd, value, parsed, ttl);
+            return json ? { ok: true, output: { ok: true, expiresAt } } : { ok: true, message: `wrote ${value}${expiresAt ? ` (expires ${expiresAt})` : ""}` };
+        }
+        if (command === "delete" && value) {
+            s.stateDelete(cwd, value);
+            return { ok: true, message: `deleted ${value}` };
+        }
+        if (command === "list") {
+            return { ok: true, output: { keys: s.stateList(cwd) } };
+        }
+        if (command === "cleanup") {
+            const deleted = s.stateCleanup(cwd);
+            return json ? { ok: true, output: { deleted } } : { ok: true, message: `cleaned ${deleted} expired` };
+        }
+        if (command === "status" && value) {
+            return { ok: true, output: s.stateStatus(cwd, value) };
+        }
+        return { ok: false, exitCode: 1, message: "Unknown state subcommand. Try: state read <key> | write <key> <val> [--ttl s] | delete <key> | list | cleanup | status <key>" };
+    }
+    if (group === "project-memory") {
+        const pm = await import("./project-memory.js");
+        const { syncInstructionsMemory } = await import("./instructions-memory.js");
+        const cwd = flagValue(argv, "--root") ?? process.cwd();
+        if (command === "add-note") {
+            // Accept a --title flag or a positional title; reject a flag-like value in
+            // either slot, so `add-note --title --body x` doesn't store "--body".
+            const titleFlag = flagValue(argv, "--title");
+            const title = titleFlag && !titleFlag.startsWith("-")
+                ? titleFlag
+                : value && !value.startsWith("-")
+                    ? value
+                    : undefined;
+            if (!title || !title.trim()) {
+                return { ok: false, exitCode: 1, message: 'usage: omp project-memory add-note "<title>" [--body "<text>"]' };
+            }
+            const id = pm.addNote(cwd, title, flagValue(argv, "--body"));
+            syncInstructionsMemory(cwd); // refresh the managed block Copilot reads
+            return json ? { ok: true, output: { ok: true, id } } : { ok: true, message: `note added: ${id}` };
+        }
+        if (command === "add-directive") {
+            const directiveFlag = flagValue(argv, "--directive");
+            const directive = directiveFlag && !directiveFlag.startsWith("-")
+                ? directiveFlag
+                : value && !value.startsWith("-")
+                    ? value
+                    : undefined;
+            if (!directive || !directive.trim()) {
+                return { ok: false, exitCode: 1, message: 'usage: omp project-memory add-directive "<rule>"' };
+            }
+            const count = pm.addDirective(cwd, directive);
+            syncInstructionsMemory(cwd); // refresh the managed block Copilot reads
+            return json ? { ok: true, output: { ok: true, count } } : { ok: true, message: `directive added (${count} total)` };
+        }
+        if (command === "index") {
+            return { ok: true, output: { notes: pm.noteIndex(cwd) } };
+        }
+        if (command === "read" || command === undefined) {
+            // `read <id>` loads one note's body on demand; bare `read` returns the
+            // bounded summary (directives + note index — never note bodies).
+            if (value && !value.startsWith("-")) {
+                const note = pm.readNote(cwd, value);
+                if (note === null)
+                    return { ok: false, exitCode: 1, message: `no note with id: ${value}` };
+                return { ok: true, message: note };
+            }
+            return { ok: true, output: { directives: pm.readDirectives(cwd), notes: pm.noteIndex(cwd) } };
+        }
+        return {
+            ok: false,
+            exitCode: 1,
+            message: 'Unknown project-memory subcommand. Try: project-memory read [<id>] | index | add-note "<title>" [--body "<text>"] | add-directive "<rule>"',
+        };
+    }
+    if (group === "trace") {
+        const tr = await import("./trace.js");
+        const cwd = flagValue(argv, "--root") ?? process.cwd();
+        const sid = value && !value.startsWith("-") ? value : undefined;
+        if (command === "timeline" || command === undefined) {
+            const limitRaw = flagValue(argv, "--limit");
+            const limit = limitRaw !== undefined && Number.isFinite(Number(limitRaw)) ? Number(limitRaw) : 50;
+            return { ok: true, output: tr.traceTimeline(cwd, sid, limit) };
+        }
+        if (command === "summary") {
+            return { ok: true, output: tr.traceSummary(cwd, sid) };
+        }
+        if (command === "add" && sid) {
+            const event = argv[3];
+            if (!event)
+                return { ok: false, exitCode: 1, message: "usage: omp trace add <sessionId> <event> [json-payload]" };
+            const payloadRaw = argv[4];
+            let payload;
+            if (payloadRaw !== undefined) {
+                try {
+                    payload = JSON.parse(payloadRaw);
+                }
+                catch {
+                    payload = payloadRaw;
+                }
+            }
+            tr.appendTraceEntry(cwd, sid, { event, payload });
+            return { ok: true, message: `trace appended to ${sid}` };
+        }
+        return { ok: false, exitCode: 1, message: "Unknown trace subcommand. Try: trace timeline [sessionId] [--limit N] | summary [sessionId] | add <sessionId> <event> [json]" };
+    }
     if (group === "catalog") {
         if (command === "list") {
             const bundle = loadCatalogBundle();
@@ -605,6 +789,85 @@ async function handleModeCommand(mode, argv, json) {
         message: `Unknown ${mode} subcommand. Try: ${mode} start "<task>" | status | cancel${mode === "ralph" ? " | tick" : ""}${mode === "ultraqa" ? " | cycle pass|fail|pending" : ""}`,
     };
 }
+async function handleScheduleCommand(argv, json) {
+    const [, command, value] = argv;
+    const cwd = flagValue(argv, "--root") ?? process.cwd();
+    // The OS scheduler invokes `omp schedule run --id <id> --root <dir>`, so prefer
+    // the --id flag; fall back to the positional form for human-typed commands.
+    const targetId = flagValue(argv, "--id") ?? (value && !value.startsWith("--") ? value : undefined);
+    const mod = await import("./schedule/commands.js");
+    if (command === "add") {
+        const id = flagValue(argv, "--id");
+        const cron = flagValue(argv, "--cron");
+        const prompt = flagValue(argv, "--prompt");
+        if (!id || !cron || !prompt) {
+            return { ok: false, exitCode: 1, message: 'schedule add requires --id, --cron, and --prompt' };
+        }
+        let timeoutMs;
+        let maxRuns;
+        let ttlHours;
+        try {
+            timeoutMs = parsePositiveIntFlag(flagValue(argv, "--timeout"), "--timeout");
+            maxRuns = parsePositiveIntFlag(flagValue(argv, "--max-runs"), "--max-runs");
+            ttlHours = parsePositiveIntFlag(flagValue(argv, "--ttl-hours"), "--ttl-hours");
+        }
+        catch (err) {
+            return { ok: false, exitCode: 1, message: String(err instanceof Error ? err.message : err) };
+        }
+        const result = mod.addScheduleJob(cwd, {
+            id,
+            cron,
+            prompt,
+            bin: flagValue(argv, "--bin"),
+            model: flagValue(argv, "--model"),
+            cwd: flagValue(argv, "--cwd"),
+            timeoutMs,
+            maxRuns,
+            ttlHours,
+            allowAllTools: hasFlag(argv, "--allow-all-tools"),
+            dryRun: hasFlag(argv, "--dry-run"),
+        });
+        return json
+            ? { ok: result.ok, exitCode: result.ok ? 0 : 1, output: result }
+            : { ok: result.ok, exitCode: result.ok ? 0 : 1, message: result.ok ? result.messages.join("\n") : (result.error ?? "schedule add failed") };
+    }
+    if (command === "list") {
+        const jobs = mod.listScheduleJobs(cwd);
+        return json
+            ? { ok: true, output: jobs }
+            : {
+                ok: true,
+                message: jobs.length
+                    ? jobs.map((j) => `${j.id}\t${j.cron}\t${j.backend}\tinstalled=${j.osInstalled}\tlast=${j.lastStatus ?? "-"}`).join("\n")
+                    : "(no scheduled jobs)",
+            };
+    }
+    if (command === "status" && targetId) {
+        const st = mod.getScheduleStatus(cwd, targetId);
+        if (!st.job)
+            return { ok: false, exitCode: 1, output: json ? st : undefined, message: `no schedule job "${targetId}"` };
+        return json
+            ? { ok: true, output: st }
+            : { ok: true, message: `${st.job.id} cron=${st.job.cron} backend=${st.job.backend} installed=${st.osInstalled} runs=${st.job.runCount} last=${st.job.lastStatus ?? "-"}` };
+    }
+    if (command === "remove" && targetId) {
+        const result = mod.removeScheduleJob(cwd, targetId);
+        return json
+            ? { ok: result.removed, exitCode: result.removed ? 0 : 1, output: result }
+            : { ok: result.removed, exitCode: result.removed ? 0 : 1, message: result.removed ? `removed "${targetId}"` : `no schedule job "${targetId}"` };
+    }
+    if ((command === "run" || command === "run-now") && targetId) {
+        const result = await mod.runScheduleById(cwd, targetId);
+        return json
+            ? { ok: result.ok, exitCode: result.ok ? 0 : 1, output: result }
+            : { ok: result.ok, exitCode: result.ok ? 0 : 1, message: result.message };
+    }
+    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>',
+    };
+}
 function isEntrypoint() {
     const argv1 = process.argv[1];
     if (!argv1)