@damian87/omp 0.4.0 → 0.5.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/weighted-consensus/SKILL.md

@@ -26,9 +26,10 @@ synthesizer model reasons over their answers — using each member's weight as a
 3. **Synthesis** — a low-context synthesizer model merges survivors into a final
    `verdict`, `confidence`, `rationale`, and `minority_report`. Evidence quality
    can override weight.
-4. **Graceful degradation** — timed-out, errored, unavailable, or unparseable
-   members are dropped; the council still synthesizes from the rest, and only
-   fails if fewer than `min-survivors` (default 2) remain.
+4. **Graceful degradation** — errored, unavailable, or unparseable members are
+   dropped; timed-out members that produced valid JSON are recovered as
+   survivors. The council synthesizes from all survivors and only fails if fewer
+   than `min-survivors` (default 2) remain.
 
 ## Agent execution steps (FOLLOW EXACTLY)
 
@@ -48,7 +49,7 @@ degradation, and synthesis for you — do NOT try to call models yourself:
 ```
 omp council "<question>" [--models a,b,c | model:role:weight,...] \
   [--context <text|@file>] [--rubric <text|@file>] \
-  [--synth <model>] [--probe] [--timeout <ms>] \
+  [--synth <model>] [--probe] [--timeout <ms>] [--synth-timeout <ms>] \
   [--min-survivors <n>] [--max-concurrency <n>] [--tmp-dir <dir>] [--json]
 ```
 
@@ -62,6 +63,12 @@ omp council "<question>" [--models a,b,c | model:role:weight,...] \
   default; the normal run already reports unavailable models inline).
 - `--json` — emit the full structured result for programmatic use; omit it for a
   readable verdict + dropped-member summary.
+- `--synth-timeout <ms>` — synthesizer timeout (default: 2× `--timeout`). The
+  synth processes all member outputs so may need longer than individual members.
+  The synth prompt does NOT include the shared context (members already digested
+  it), so this is mainly needed for councils with many members or long rationale.
+- Timed-out members that produced valid JSON before the kill signal are
+  automatically recovered as survivors — they are not dropped.
 
 If `omp council` is not found (the published `omp` predates this feature), fall
 back to the local build from the repo root: `node dist/src/cli.js council "<question>" ...`
@@ -94,6 +101,7 @@ default roster is used.
     "synthesizer": "gpt-4.1",
     "minSurvivors": 2,
     "maxConcurrency": 4,
+    "synthTimeoutMs": 240000,
     "probe": false,
     "members": [
       { "model": "gpt-5-mini", "role": "critic", "weight": 0.4 },

package/README.md

@@ -284,3 +284,19 @@ To unlink and revert to the published package:
 npm unlink -g @damian87/omp
 npm i -g @damian87/omp
 ```
+
+## Releasing (maintainers)
+
+One command runs the whole flow — quality gates → version bump → tag → push →
+GitHub release → `npm publish`. It's a maintainer script (`tools/release.sh`),
+**not** a published plugin skill, so it never ships in the package or appears in
+the in-session skill catalog. npm 2FA is on, so pass an authenticator code via `--otp`.
+
+```bash
+npm run release -- minor --otp 123456     # bump 0.x.0, tag, push, GH release, publish
+npm run release -- patch --dry-run        # validate everything, change nothing
+npm run release:publish-only -- --otp 123456   # build + publish the CURRENT version (recover a half-done release)
+```
+
+The script refuses to run unless you're on a clean, up-to-date `main` and the
+gates (`test`, `lint:skills`, `check:catalog`, `build`) pass.

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>] [--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  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,195 @@ export async function runCli(argv = process.argv.slice(2)) {
     if (group === "ultraqa") {
         return await handleModeCommand("ultraqa", 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();
@@ -328,10 +509,12 @@ async function handleCouncilCommand(argv, json) {
     const context = await readFlagOrFile(flagValue(argv, "--context"));
     const rubric = await readFlagOrFile(flagValue(argv, "--rubric"));
     let perMemberTimeoutMs;
+    let synthTimeoutMs;
     let minSurvivors;
     let maxConcurrency;
     try {
         perMemberTimeoutMs = parsePositiveIntFlag(flagValue(argv, "--timeout"), "--timeout");
+        synthTimeoutMs = parsePositiveIntFlag(flagValue(argv, "--synth-timeout"), "--synth-timeout");
         minSurvivors = parsePositiveIntFlag(flagValue(argv, "--min-survivors"), "--min-survivors");
         maxConcurrency = parsePositiveIntFlag(flagValue(argv, "--max-concurrency"), "--max-concurrency");
     }
@@ -351,10 +534,15 @@ async function handleCouncilCommand(argv, json) {
         synthesizerModel: flagValue(argv, "--synth"),
         probe,
         perMemberTimeoutMs,
+        synthTimeoutMs,
         minSurvivors,
         maxConcurrency,
         tmpDir: flagValue(argv, "--tmp-dir"),
-    }, { cwd: flagValue(argv, "--root") ?? process.cwd(), bin: flagValue(argv, "--bin") });
+    }, {
+        cwd: flagValue(argv, "--root") ?? process.cwd(),
+        bin: flagValue(argv, "--bin"),
+        onProgress: json ? undefined : (msg) => process.stderr.write(`${msg}\n`),
+    });
     if (json) {
         return { ok: result.ok, exitCode: result.ok ? 0 : 1, output: result };
     }