oh-my-githubcopilot 1.8.1 → 2.0.0-alpha.1cd01f4

package/bin/omp.mjs

@@ -44,7 +44,7 @@ function renderAnsi(state) {
   const modeStr = mode === "-" ? "-" : `\x1B[36m${mode}${reset()}`;
   const reqWarning = state.warningActive ? " !!" : "";
   const reqStr = `req:${state.premiumRequests ?? 0}/${state.premiumRequestsTotal ?? 1500}${reqWarning}`;
-  return `[OMP v${state.version}] ${modeStr} | ${model} | ${ctxStr} | ${tokenStr} | ${reqStr} | ${age} | tools:${state.toolsUsed?.size || 0}/${state.toolsTotal ?? 13} | skills:${state.skillsUsed?.size || 0}/${state.skillsTotal ?? 25} | agents:${state.cumulativeAgentsUsed}/${state.agentsTotal ?? 23} | ${icon} ${state.status}`;
+  return `[OMP v${state.version}] ${modeStr} | ${model} | ${ctxStr} | ${tokenStr} | ${reqStr} | ${age} | tools:${state.toolsUsed?.size || 0}/${state.toolsTotal ?? 13} | skills:${state.skillsUsed?.size || 0}/${state.skillsTotal ?? 25} | agents:${state.cumulativeAgentsUsed}/${state.agentsTotal ?? 19} | ${icon} ${state.status}`;
 }
 function renderPlain(state) {
   const age = formatAge(state.startedAt);
@@ -54,7 +54,7 @@ function renderPlain(state) {
   const model = state.activeModel || "sonnet";
   const reqWarningPlain = state.warningActive ? " !!" : "";
   const reqStrPlain = `req:${state.premiumRequests ?? 0}/${state.premiumRequestsTotal ?? 1500}${reqWarningPlain}`;
-  return `[OMP v${state.version}] ${mode} | ${model} | ctx:${ctx}% | tok:~${tokens}/${state.tokensTotal} | ${reqStrPlain} | ${age} | tools:${state.toolsUsed?.size || 0}/${state.toolsTotal ?? 13} | skills:${state.skillsUsed?.size || 0}/${state.skillsTotal ?? 25} | agents:${state.cumulativeAgentsUsed}/${state.agentsTotal ?? 23} | ${state.status}`;
+  return `[OMP v${state.version}] ${mode} | ${model} | ctx:${ctx}% | tok:~${tokens}/${state.tokensTotal} | ${reqStrPlain} | ${age} | tools:${state.toolsUsed?.size || 0}/${state.toolsTotal ?? 13} | skills:${state.skillsUsed?.size || 0}/${state.skillsTotal ?? 25} | agents:${state.cumulativeAgentsUsed}/${state.agentsTotal ?? 19} | ${state.status}`;
 }
 var STATUS_ICONS;
 var init_renderer = __esm({
@@ -134,8 +134,8 @@ function deserializeHudState(raw) {
     toolsUsed,
     skillsUsed,
     toolsTotal: typeof value.toolsTotal === "number" ? value.toolsTotal : 13,
-    skillsTotal: typeof value.skillsTotal === "number" ? value.skillsTotal : 25,
-    agentsTotal: typeof value.agentsTotal === "number" ? value.agentsTotal : 23,
+    skillsTotal: typeof value.skillsTotal === "number" ? value.skillsTotal : 59,
+    agentsTotal: typeof value.agentsTotal === "number" ? value.agentsTotal : 19,
     premiumRequests: typeof value.premiumRequests === "number" ? value.premiumRequests : 0,
     premiumRequestsTotal: typeof value.premiumRequestsTotal === "number" ? value.premiumRequestsTotal : DEFAULT_PREMIUM_REQUESTS_TOTAL,
     warningActive: typeof value.warningActive === "boolean" ? value.warningActive : false
@@ -167,8 +167,8 @@ function buildHudState(snapshot, now = Date.now()) {
     toolsUsed,
     skillsUsed,
     toolsTotal: 13,
-    skillsTotal: 25,
-    agentsTotal: 23,
+    skillsTotal: 59,
+    agentsTotal: 19,
     premiumRequests: snapshot.premium_requests ?? 0,
     premiumRequestsTotal: snapshot.premium_requests_total ?? DEFAULT_PREMIUM_REQUESTS_TOTAL,
     warningActive: snapshot.warning_active ?? false
@@ -189,17 +189,17 @@ function writeHudArtifacts(snapshot, paths = getStatuslinePaths()) {
   return { line, state, paths };
 }
 function readStatusline(paths = getStatuslinePaths()) {
-  try {
-    const line = readFileSync(paths.displayPath, "utf-8").trim();
-    if (line) return line;
-  } catch {
-  }
   try {
     const parsed = JSON.parse(readFileSync(paths.statusJsonPath, "utf-8"));
     const state = deserializeHudState(parsed);
     if (state) return renderPlain(state);
   } catch {
   }
+  try {
+    const line = readFileSync(paths.displayPath, "utf-8").trim();
+    if (line) return line;
+  } catch {
+  }
   try {
     const line = readFileSync(paths.legacyLinePath, "utf-8").trim();
     if (line) return line;
@@ -216,7 +216,7 @@ var init_statusline = __esm({
     DEFAULT_STATUSLINE = "OMP | hud: no active session";
     DEFAULT_TOKEN_BUDGET = 2e5;
     DEFAULT_PREMIUM_REQUESTS_TOTAL = 1500;
-    if (process.argv[1] === fileURLToPath(import.meta.url)) {
+    if (process.argv[1] === fileURLToPath(import.meta.url) && (process.argv[1].endsWith("omp-statusline.mjs") || process.argv[1].endsWith("statusline.mts"))) {
       console.log(readStatusline());
     }
   }
@@ -250,7 +250,7 @@ function tick(paths = getStatuslinePaths()) {
 function runHudWatch() {
   const intervalMs = Math.max(
     500,
-    parseInt(process.env["OMP_HUD_INTERVAL"] ?? "", 10) || DEFAULT_INTERVAL_MS
+    parseInt(process.env["OMP_HUD_POLL_MS"] ?? "", 10) || parseInt(process.env["OMP_HUD_INTERVAL"] ?? "", 10) || DEFAULT_INTERVAL_MS
   );
   const paths = getStatuslinePaths();
   process.stdout.write("\x1B[?25l");
@@ -278,11 +278,252 @@ var init_watch = __esm({
     "use strict";
     init_statusline();
     init_renderer();
-    DEFAULT_INTERVAL_MS = 2e3;
+    DEFAULT_INTERVAL_MS = 1e3;
     STATE_PATH = join3(homedir3(), ".omp", "state", "session.json");
   }
 });
 
+// src/cli/install.mts
+var install_exports = {};
+__export(install_exports, {
+  runInstall: () => runInstall
+});
+import { mkdir as mkdir2, readFile as readFile2, rename, writeFile as writeFile2 } from "fs/promises";
+import { homedir as homedir4 } from "os";
+import { dirname as dirname3, join as join4 } from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
+async function runInstall(settingsPath = join4(homedir4(), ".copilot", "settings.json")) {
+  const pkgRoot = join4(dirname3(fileURLToPath2(import.meta.url)), "..");
+  const statusLineCommand = join4(pkgRoot, "bin", "omp-statusline.sh");
+  const marketplacePath = pkgRoot;
+  let existing = {};
+  try {
+    const raw = await readFile2(settingsPath, "utf-8");
+    const parsed = JSON.parse(raw);
+    if (parsed !== null && typeof parsed === "object" && !Array.isArray(parsed)) {
+      existing = parsed;
+    }
+  } catch {
+  }
+  const existingPlugins = typeof existing.enabledPlugins === "object" && existing.enabledPlugins !== null && !Array.isArray(existing.enabledPlugins) ? existing.enabledPlugins : {};
+  const existingMarketplaces = typeof existing.extraKnownMarketplaces === "object" && existing.extraKnownMarketplaces !== null && !Array.isArray(existing.extraKnownMarketplaces) ? existing.extraKnownMarketplaces : {};
+  const merged = {
+    ...existing,
+    enabledPlugins: {
+      ...existingPlugins,
+      "oh-my-githubcopilot@oh-my-githubcopilot": true
+    },
+    experimental: true,
+    statusLine: { type: "command", command: statusLineCommand },
+    extraKnownMarketplaces: {
+      ...existingMarketplaces,
+      "oh-my-githubcopilot": {
+        source: { source: "directory", path: marketplacePath }
+      }
+    }
+  };
+  const tmp = `${settingsPath}.tmp`;
+  await mkdir2(dirname3(settingsPath), { recursive: true });
+  await writeFile2(tmp, JSON.stringify(merged, null, 2) + "\n", "utf-8");
+  await rename(tmp, settingsPath);
+  console.log(`omp install: wrote ${settingsPath}`);
+  console.log(`  statusLine.command: ${statusLineCommand}`);
+  console.log(`  marketplace path:   ${marketplacePath}`);
+  console.log(`  plugin:             oh-my-githubcopilot@oh-my-githubcopilot`);
+  console.log(`
+Restart Copilot CLI to activate OMP.`);
+}
+var init_install = __esm({
+  "src/cli/install.mts"() {
+    "use strict";
+  }
+});
+
+// src/cli/doctor.mts
+var doctor_exports = {};
+__export(doctor_exports, {
+  AGENT_MIGRATIONS: () => AGENT_MIGRATIONS,
+  runDoctor: () => runDoctor,
+  scanProjectForStaleAgents: () => scanProjectForStaleAgents,
+  scanTextForStaleAgents: () => scanTextForStaleAgents
+});
+import { existsSync, readFileSync as readFileSync3, readdirSync, statSync } from "fs";
+import { join as join5, relative } from "path";
+function scanTextForStaleAgents(text, file) {
+  const warnings = [];
+  const lines = text.split("\n");
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    for (const match of line.matchAll(STALE_AGENT_PATTERN)) {
+      const staleId = match[1];
+      warnings.push({
+        file,
+        line: i + 1,
+        staleId: `@${staleId}`,
+        replacement: AGENT_MIGRATIONS[staleId],
+        text: line.trim()
+      });
+    }
+  }
+  return warnings;
+}
+function collectDirFiles(dir, depth) {
+  if (depth > MAX_SCAN_DEPTH) return [];
+  const files = [];
+  let entries;
+  try {
+    entries = readdirSync(dir);
+  } catch {
+    return [];
+  }
+  for (const entry of entries) {
+    const fullPath = join5(dir, entry);
+    try {
+      const stats = statSync(fullPath);
+      if (stats.isDirectory()) {
+        files.push(...collectDirFiles(fullPath, depth + 1));
+      } else if (SCANNABLE_EXTENSIONS.some((ext) => entry.endsWith(ext))) {
+        files.push(fullPath);
+      }
+    } catch {
+    }
+  }
+  return files;
+}
+function scanProjectForStaleAgents(cwd) {
+  const targets = [];
+  for (const file of SCAN_FILES) {
+    const fullPath = join5(cwd, file);
+    if (existsSync(fullPath)) targets.push(fullPath);
+  }
+  for (const dir of SCAN_DIRS) {
+    const fullPath = join5(cwd, dir);
+    if (existsSync(fullPath)) targets.push(...collectDirFiles(fullPath, 0));
+  }
+  const warnings = [];
+  for (const target of targets) {
+    try {
+      const text = readFileSync3(target, "utf-8");
+      warnings.push(...scanTextForStaleAgents(text, relative(cwd, target)));
+    } catch {
+    }
+  }
+  return warnings;
+}
+function runDoctor(cwd = process.cwd()) {
+  console.log("OMP Doctor \u2014 agent migration check (2.0)");
+  console.log("");
+  const warnings = scanProjectForStaleAgents(cwd);
+  if (warnings.length === 0) {
+    console.log("OK: no stale agent references found.");
+    return 0;
+  }
+  console.log(`WARN: found ${warnings.length} stale agent reference(s):`);
+  console.log("");
+  for (const warning of warnings) {
+    console.log(`  ${warning.file}:${warning.line} \u2014 ${warning.staleId} \u2192 ${warning.replacement}`);
+    console.log(`    ${warning.text}`);
+  }
+  console.log("");
+  console.log("Suggested replacements (OMP 2.0 agent parity):");
+  for (const [staleId, replacement] of Object.entries(AGENT_MIGRATIONS)) {
+    console.log(`  @${staleId} \u2192 ${replacement}`);
+  }
+  return warnings.length;
+}
+var AGENT_MIGRATIONS, STALE_AGENT_PATTERN, SCAN_FILES, SCAN_DIRS, SCANNABLE_EXTENSIONS, MAX_SCAN_DEPTH;
+var init_doctor = __esm({
+  "src/cli/doctor.mts"() {
+    "use strict";
+    AGENT_MIGRATIONS = {
+      explorer: "explore",
+      simplifier: "code-simplifier",
+      researcher: "document-specialist",
+      reviewer: "code-reviewer",
+      tester: "test-engineer",
+      orchestrator: "top-level orchestration role (no longer a delegatable agent)"
+    };
+    STALE_AGENT_PATTERN = /(?<![\w-])@(explorer|simplifier|researcher|reviewer|tester|orchestrator)(?![\w-])/g;
+    SCAN_FILES = [
+      ".github/copilot-instructions.md",
+      ".copilot/copilot-instructions.md",
+      "AGENTS.md"
+    ];
+    SCAN_DIRS = [".omg", ".omp"];
+    SCANNABLE_EXTENSIONS = [".md", ".json", ".yml", ".yaml", ".txt"];
+    MAX_SCAN_DEPTH = 3;
+  }
+});
+
+// src/hooks/runner.mts
+var runner_exports = {};
+__export(runner_exports, {
+  readStdin: () => readStdin,
+  runHookMain: () => runHookMain
+});
+import { appendFileSync, mkdirSync as mkdirSync2 } from "fs";
+import { homedir as homedir5 } from "os";
+import { join as join6 } from "path";
+async function readStdin() {
+  const readStdinActual = async () => {
+    const chunks = [];
+    for await (const chunk of process.stdin) {
+      chunks.push(String(chunk));
+    }
+    return chunks.join("");
+  };
+  const stdinTimeout = new Promise(
+    (resolve) => setTimeout(
+      () => resolve(""),
+      parseInt(process.env.OMP_HOOK_STDIN_TIMEOUT_MS ?? "500") || 500
+    )
+  );
+  return Promise.race([readStdinActual(), stdinTimeout]);
+}
+function logHookFailure(hook, reason) {
+  try {
+    process.stderr.write(`[omp hook fail-open] ${hook}: ${reason}
+`);
+  } catch {
+  }
+  try {
+    const logsDir = join6(homedir5(), ".omp", "logs");
+    mkdirSync2(logsDir, { recursive: true });
+    const record = JSON.stringify({ ts: (/* @__PURE__ */ new Date()).toISOString(), hook, reason });
+    appendFileSync(join6(logsDir, "hook-failures.jsonl"), record + "\n", "utf-8");
+  } catch {
+  }
+}
+async function runHookMain(processHook2, options = {}) {
+  let outputJson;
+  try {
+    const input = JSON.parse(await readStdin());
+    const serialized = JSON.stringify(processHook2(input));
+    if (typeof serialized !== "string") {
+      throw new Error("hook produced no serializable output");
+    }
+    outputJson = serialized;
+  } catch (err) {
+    const reason = err instanceof Error ? err.message : String(err);
+    logHookFailure(options.hookName ?? "unknown", reason);
+    const failOpen = {
+      ...options.failOpenDecision ? { decision: "allow" } : {},
+      status: "error",
+      latencyMs: 0,
+      mutations: [],
+      log: [`fail-open: ${reason}`]
+    };
+    outputJson = JSON.stringify(failOpen);
+  }
+  console.log(outputJson);
+  process.exitCode = 0;
+}
+var init_runner = __esm({
+  "src/hooks/runner.mts"() {
+    "use strict";
+  }
+});
+
 // src/hooks/keyword-detector.mts
 var keyword_detector_exports = {};
 __export(keyword_detector_exports, {
@@ -374,17 +615,11 @@ function processHook(input) {
     };
   }
 }
-async function readStdin() {
-  const chunks = [];
-  for await (const chunk of process.stdin) {
-    chunks.push(chunk);
-  }
-  return chunks.join("");
-}
 var KEYWORD_MAP, KEYWORD_ENTRIES, CANONICAL_COMMAND_MAP;
 var init_keyword_detector = __esm({
   async "src/hooks/keyword-detector.mts"() {
     "use strict";
+    init_runner();
     KEYWORD_MAP = {
       "autopilot:": "autopilot",
       "/autopilot": "autopilot",
@@ -485,7 +720,63 @@ var init_keyword_detector = __esm({
       "/omp:notifications": "notifications",
       "session:": "session",
       "/session": "session",
-      "/omp:session": "session"
+      "/omp:session": "session",
+      "verify:": "verify",
+      "/verify": "verify",
+      "/omp:verify": "verify",
+      "cancel:": "cancel",
+      "/omp:cancel": "cancel",
+      "help:": "help",
+      "/omp:help": "help",
+      "code-review:": "code-review",
+      "/code-review": "code-review",
+      "/omp:code-review": "code-review",
+      "security-review:": "security-review",
+      "/security-review": "security-review",
+      "/omp:security-review": "security-review",
+      "ultraqa:": "ultraqa",
+      "/ultraqa": "ultraqa",
+      "/omp:ultraqa": "ultraqa",
+      "ultragoal:": "ultragoal",
+      "/ultragoal": "ultragoal",
+      "/omp:ultragoal": "ultragoal",
+      "deep-dive:": "deep-dive",
+      "/deep-dive": "deep-dive",
+      "/omp:deep-dive": "deep-dive",
+      "external-context:": "external-context",
+      "/external-context": "external-context",
+      "/omp:external-context": "external-context",
+      "deepsearch:": "deepsearch",
+      "/deepsearch": "deepsearch",
+      "/omp:deepsearch": "deepsearch",
+      "sciomc:": "sciomc",
+      "/sciomc": "sciomc",
+      "/omp:sciomc": "sciomc",
+      "remember:": "remember",
+      "/omp:remember": "remember",
+      "writer-memory:": "writer-memory",
+      "/writer-memory": "writer-memory",
+      "/omp:writer-memory": "writer-memory",
+      "deepinit:": "deepinit",
+      "/deepinit": "deepinit",
+      "/omp:deepinit": "deepinit",
+      "self-improve:": "self-improve",
+      "/self-improve": "self-improve",
+      "/omp:self-improve": "self-improve",
+      "visual-verdict:": "visual-verdict",
+      "/visual-verdict": "visual-verdict",
+      "/omp:visual-verdict": "visual-verdict",
+      "ccg:": "ccg",
+      "/ccg": "ccg",
+      "/omp:ccg": "ccg",
+      "build-fix:": "build-fix",
+      "/build-fix": "build-fix",
+      "/omp:build-fix": "build-fix",
+      "design:": "design",
+      "/omp:design": "design",
+      "web-clone:": "web-clone",
+      "/web-clone": "web-clone",
+      "/omp:web-clone": "web-clone"
     };
     KEYWORD_ENTRIES = Object.entries(KEYWORD_MAP).sort(([a], [b]) => b.length - a.length);
     CANONICAL_COMMAND_MAP = {
@@ -494,13 +785,350 @@ var init_keyword_detector = __esm({
       "mcp-setup": "/mcp"
     };
     if (process.argv[1]?.endsWith("keyword-detector.mjs") || process.argv[1]?.endsWith("keyword-detector.mts")) {
-      const input = JSON.parse(await readStdin());
-      const output = processHook(input);
-      console.log(JSON.stringify(output));
+      await runHookMain(processHook, { failOpenDecision: true, hookName: "keyword-detector" });
     }
   }
 });
 
+// src/extension/commands.mts
+function buildActivationInstruction(skillId, args) {
+  const trimmed = args.trim();
+  return `Activate the OMP skill "${skillId}" with args: ${trimmed.length > 0 ? trimmed : "(none)"}`;
+}
+function buildCommands(registry) {
+  const commands = [];
+  for (const entry of registry) {
+    commands.push({
+      name: entry.id,
+      description: entry.description,
+      handler: (args) => buildActivationInstruction(entry.id, args)
+    });
+    for (const alias of entry.aliases ?? []) {
+      commands.push({
+        name: alias,
+        description: `Alias for /${entry.id} \u2014 ${entry.description}`,
+        handler: (args) => buildActivationInstruction(entry.id, args)
+      });
+    }
+  }
+  return commands;
+}
+var init_commands = __esm({
+  "src/extension/commands.mts"() {
+    "use strict";
+  }
+});
+
+// src/extension/registry.mts
+var registry_exports = {};
+__export(registry_exports, {
+  SKILL_REGISTRY: () => SKILL_REGISTRY,
+  getCommandDefinitions: () => getCommandDefinitions
+});
+function getCommandDefinitions() {
+  return buildCommands(SKILL_REGISTRY);
+}
+var SKILL_REGISTRY;
+var init_registry = __esm({
+  "src/extension/registry.mts"() {
+    "use strict";
+    init_commands();
+    SKILL_REGISTRY = [
+      {
+        id: "autopilot",
+        description: "Autonomous end-to-end execution from idea to working code",
+        keywords: ["autopilot:"]
+      },
+      {
+        id: "ralph",
+        description: "Persistence loop with architect verification gate",
+        keywords: ["ralph:"]
+      },
+      {
+        id: "ultrawork",
+        description: "Parallel multi-agent high-throughput implementation",
+        aliases: ["ulw"],
+        keywords: ["ulw:", "ultrawork:"]
+      },
+      {
+        id: "team",
+        description: "Coordinated N-agent team with staged pipeline",
+        keywords: ["team:"]
+      },
+      {
+        id: "ecomode",
+        description: "Cost-optimized execution with low-cost model tier",
+        aliases: ["eco"],
+        keywords: ["eco:", "ecomode:"]
+      },
+      {
+        id: "swarm",
+        description: "Parallel agent swarm for independent subtasks",
+        keywords: ["swarm:"]
+      },
+      {
+        id: "pipeline",
+        description: "Sequential stage-based execution pipeline",
+        keywords: ["pipeline:"]
+      },
+      {
+        id: "deep-interview",
+        description: "Socratic deep requirements interview with ambiguity gating",
+        aliases: ["di"],
+        keywords: ["deep interview:"]
+      },
+      {
+        id: "omp-plan",
+        description: "Strategic planning with interview, direct, consensus, and review modes",
+        aliases: ["plan"],
+        keywords: ["plan:"]
+      },
+      {
+        id: "omp-setup",
+        description: "OMP onboarding and configuration wizard",
+        keywords: ["setup:"]
+      },
+      {
+        id: "hud",
+        description: "Display current HUD session state",
+        keywords: ["hud:"]
+      },
+      {
+        id: "wiki",
+        description: "Project wiki operations and management",
+        keywords: ["wiki:"]
+      },
+      {
+        id: "learner",
+        description: "Structured learning and knowledge sessions",
+        keywords: ["learner:"]
+      },
+      {
+        id: "note",
+        description: "Session notes and context management",
+        keywords: ["note:"]
+      },
+      {
+        id: "trace",
+        description: "Execution tracing and debugging",
+        keywords: ["trace:"]
+      },
+      {
+        id: "release",
+        description: "Guided release workflow and automation",
+        keywords: ["release:"]
+      },
+      {
+        id: "configure-notifications",
+        description: "Configure session notification settings",
+        keywords: ["configure-notifications:"]
+      },
+      {
+        id: "psm",
+        description: "Plugin State Manager operations",
+        keywords: ["psm:"]
+      },
+      {
+        id: "swe-bench",
+        description: "SWE-bench evaluation harness runner",
+        keywords: ["swe-bench:"]
+      },
+      {
+        id: "mcp-setup",
+        description: "MCP server configuration wizard",
+        keywords: ["mcp:", "mcp-setup:"]
+      },
+      {
+        id: "setup",
+        description: "OMP setup and onboarding wizard"
+      },
+      {
+        id: "graphify",
+        description: "Convert any input to a knowledge graph",
+        keywords: ["graphify:"]
+      },
+      {
+        id: "graphwiki",
+        description: "GraphWiki CLI operations: query, lint, build",
+        keywords: ["graphwiki:"]
+      },
+      {
+        id: "graph-provider",
+        description: "Manage and configure the active graph provider",
+        keywords: ["graph:"]
+      },
+      {
+        id: "spending",
+        description: "Track and reset premium request usage",
+        keywords: ["spending:"]
+      },
+      {
+        id: "ralplan",
+        description: "Consensus planning gate for vague ralph/autopilot/team requests"
+      },
+      {
+        id: "research",
+        description: "Research and investigation workflows (investigate, deep dive)",
+        keywords: ["autoresearch:"]
+      },
+      {
+        id: "omp-doctor",
+        description: "Diagnose and fix oh-my-githubcopilot installation issues"
+      },
+      {
+        id: "omp-reference",
+        description: "OMP agent catalog, tools, routing, commit protocol, and skills registry"
+      },
+      {
+        id: "ai-slop-cleaner",
+        description: "Clean AI-generated code slop with a regression-safe, deletion-first workflow",
+        keywords: ["deslop", "anti-slop"]
+      },
+      {
+        id: "tdd",
+        description: "Test-Driven Development with Red-Green-Refactor cycle",
+        keywords: ["tdd:"]
+      },
+      {
+        id: "improve-codebase-architecture",
+        description: "Deep exploration and architectural improvement via friction detection"
+      },
+      {
+        id: "skillify",
+        description: "Turn a repeatable session workflow into a reusable OMP skill draft"
+      },
+      {
+        id: "interview",
+        description: "Socratic interview and ambiguity scoring",
+        keywords: ["interview:"]
+      },
+      {
+        id: "graph-context",
+        description: "Load codebase context from the knowledge graph instead of raw files"
+      },
+      {
+        id: "interactive-menu",
+        description: "Numbered-choice selection pattern for OMP's conversational TUI"
+      },
+      {
+        id: "notifications",
+        description: "Send and manage runtime notifications (Telegram, Discord, Slack, Email)",
+        keywords: ["notifications:"]
+      },
+      {
+        id: "doctor",
+        description: "Diagnose and fix common issues",
+        keywords: ["doctor:"]
+      },
+      {
+        id: "session",
+        description: "Worktree and tmux session management",
+        keywords: ["session:"]
+      },
+      {
+        id: "verify",
+        description: "Evidence-based completion check via verifier agent",
+        keywords: ["verify:"]
+      },
+      {
+        id: "cancel",
+        description: "Ends active execution modes and clears .omp/state/",
+        keywords: ["cancel:"]
+      },
+      {
+        id: "help",
+        description: "Command and skill discovery; prints the full skill catalog",
+        keywords: ["help:"]
+      },
+      {
+        id: "code-review",
+        description: "Trigger the code-reviewer agent lane for structured code review",
+        keywords: ["code-review:"]
+      },
+      {
+        id: "security-review",
+        description: "Trigger the security-reviewer agent lane for security analysis",
+        keywords: ["security-review:"]
+      },
+      {
+        id: "ultraqa",
+        description: "QA cycle loop with qa-tester agent; runs until all checks pass",
+        keywords: ["ultraqa:"]
+      },
+      {
+        id: "ultragoal",
+        description: "Durable goal ledger in .omp/ultragoal/ with fail-closed checkpoints",
+        keywords: ["ultragoal:"]
+      },
+      {
+        id: "deep-dive",
+        description: "Trace\u2192deep-interview pipeline for deep investigation",
+        keywords: ["deep-dive:"]
+      },
+      {
+        id: "external-context",
+        description: "Load external docs/URLs into session context",
+        keywords: ["external-context:"]
+      },
+      {
+        id: "deepsearch",
+        description: "Multi-source deep search across codebase and web",
+        keywords: ["deepsearch:"]
+      },
+      {
+        id: "sciomc",
+        description: "Scientific/analytical reasoning workflow \u2014 hypothesis\u2192experiment\u2192conclusion",
+        keywords: ["sciomc:"]
+      },
+      {
+        id: "remember",
+        description: "Persist key facts/decisions to .omp/memory/",
+        keywords: ["remember:"]
+      },
+      {
+        id: "writer-memory",
+        description: "Writing style memory \u2014 stores voice/tone preferences",
+        keywords: ["writer-memory:"]
+      },
+      {
+        id: "deepinit",
+        description: "Deep project initialization \u2014 full codebase onboarding",
+        keywords: ["deepinit:"]
+      },
+      {
+        id: "self-improve",
+        description: "OMP self-improvement \u2014 analyse own skills/agents and propose improvements",
+        keywords: ["self-improve:"]
+      },
+      {
+        id: "visual-verdict",
+        description: "Visual diff/screenshot comparison verdict",
+        keywords: ["visual-verdict:"]
+      },
+      {
+        id: "ccg",
+        description: "Concurrent code generation via multi-model picker",
+        keywords: ["ccg:"]
+      },
+      {
+        id: "build-fix",
+        description: "Diagnose and fix build/CI failures automatically",
+        keywords: ["build-fix:"]
+      },
+      {
+        id: "design",
+        description: "UI/UX design and frontend component generation",
+        keywords: ["design:"]
+      },
+      {
+        id: "web-clone",
+        description: "Clone and adapt a web page/design to the codebase",
+        keywords: ["web-clone:"]
+      }
+    ];
+  }
+});
+
 // src/index.mts
 import { parseArgs } from "util";
 import { createRequire } from "module";
@@ -698,6 +1326,77 @@ async function main() {
     case "hook":
       await runHook(positionals.slice(1));
       break;
+    case "install": {
+      const { runInstall: runInstall2 } = await Promise.resolve().then(() => (init_install(), install_exports));
+      await runInstall2();
+      break;
+    }
+    case "doctor": {
+      const { runDoctor: runDoctor2 } = await Promise.resolve().then(() => (init_doctor(), doctor_exports));
+      const warnings = runDoctor2(process.cwd());
+      process.exitCode = warnings > 0 ? 1 : 0;
+      break;
+    }
+    case "verify":
+      console.log("OMP verify: use /verify or /oh-my-githubcopilot:verify in GitHub Copilot CLI to trigger @verifier evidence-based completion check.");
+      break;
+    case "cancel":
+      await runCancel();
+      break;
+    case "help":
+      await runHelp();
+      break;
+    case "code-review":
+      console.log("OMP code-review: use /code-review or /oh-my-githubcopilot:code-review in GitHub Copilot CLI to trigger @code-reviewer agent.");
+      break;
+    case "security-review":
+      console.log("OMP security-review: use /security-review or /oh-my-githubcopilot:security-review in GitHub Copilot CLI to trigger @security-reviewer agent.");
+      break;
+    case "ultraqa":
+      console.log("OMP ultraqa: use /ultraqa or /oh-my-githubcopilot:ultraqa in GitHub Copilot CLI to start a QA cycle with @qa-tester agent.");
+      break;
+    case "ultragoal":
+      await runUltragoal(positionals.slice(1));
+      break;
+    case "deep-dive":
+      console.log("OMP deep-dive: use /deep-dive or /oh-my-githubcopilot:deep-dive in GitHub Copilot CLI to run the trace\u2192deep-interview investigation pipeline.");
+      break;
+    case "external-context":
+      await runExternalContext(positionals.slice(1));
+      break;
+    case "deepsearch":
+      console.log("OMP deepsearch: use /deepsearch or /oh-my-githubcopilot:deepsearch in GitHub Copilot CLI to run multi-source deep search.");
+      break;
+    case "sciomc":
+      console.log("OMP sciomc: use /sciomc or /oh-my-githubcopilot:sciomc in GitHub Copilot CLI to run the scientific hypothesis\u2192experiment\u2192conclusion reasoning workflow.");
+      break;
+    case "remember":
+      await runRemember(positionals.slice(1));
+      break;
+    case "writer-memory":
+      await runWriterMemory(positionals.slice(1));
+      break;
+    case "deepinit":
+      console.log("OMP deepinit: use /deepinit or /oh-my-githubcopilot:deepinit in GitHub Copilot CLI to run deep project initialization.");
+      break;
+    case "self-improve":
+      console.log("OMP self-improve: use /self-improve in Copilot CLI to analyse OMP skills/agents and propose improvements.");
+      break;
+    case "visual-verdict":
+      console.log("OMP visual-verdict: use /visual-verdict in Copilot CLI to compare visual diffs or screenshots.");
+      break;
+    case "ccg":
+      console.log("OMP ccg: use /ccg in Copilot CLI to run concurrent code generation via multi-model picker.");
+      break;
+    case "build-fix":
+      console.log("OMP build-fix: use /build-fix in Copilot CLI to diagnose and fix build/CI failures automatically.");
+      break;
+    case "design":
+      console.log("OMP design: use /omp:design in Copilot CLI to generate UI/UX designs and frontend components.");
+      break;
+    case "web-clone":
+      console.log("OMP web-clone: use /web-clone in Copilot CLI to clone and adapt a web page/design to your codebase.");
+      break;
     default:
       console.error(`Unknown subcommand: ${resolvedSubcommand}`);
       printUsage(true);
@@ -706,15 +1405,15 @@ async function main() {
 }
 function printUsage(stderr = false) {
   const output = stderr ? console.error : console.log;
-  output("Usage: omp [hud|version|psm|bench|hook] [--watch]");
+  output("Usage: omp [hud|install|doctor|version|psm|bench|hook|verify|cancel|help|code-review|security-review|ultraqa|ultragoal|deep-dive|external-context|deepsearch|sciomc|remember|writer-memory|deepinit|self-improve|visual-verdict|ccg|build-fix|design|web-clone] [--watch]");
 }
 async function printHud() {
   try {
-    const { readFileSync: readFileSync3 } = await import("fs");
-    const { join: join4 } = await import("path");
-    const { homedir: homedir4 } = await import("os");
-    const hudPath = join4(homedir4(), ".omp", "hud.line");
-    const line = readFileSync3(hudPath, "utf-8").trim();
+    const { readFileSync: readFileSync4 } = await import("fs");
+    const { join: join7 } = await import("path");
+    const { homedir: homedir6 } = await import("os");
+    const hudPath = join7(homedir6(), ".omp", "hud.line");
+    const line = readFileSync4(hudPath, "utf-8").trim();
     console.log(line);
   } catch {
     console.log(`OMP v${PKG_VERSION} | hud: no active session`);
@@ -734,22 +1433,166 @@ async function runHook(args) {
     process.exit(1);
   }
   const { processHook: processHook2 } = await init_keyword_detector().then(() => keyword_detector_exports);
-  const inputText = await readStdin2();
-  const input = JSON.parse(inputText || "{}");
-  const output = processHook2(input);
-  console.log(JSON.stringify(output));
-}
-async function readStdin2() {
-  const chunks = [];
-  for await (const chunk of process.stdin) {
-    chunks.push(String(chunk));
-  }
-  return chunks.join("");
+  const { runHookMain: runHookMain2 } = await Promise.resolve().then(() => (init_runner(), runner_exports));
+  await runHookMain2(processHook2, { failOpenDecision: true, hookName: "keyword-detector" });
 }
 async function runBench(_args) {
   console.log("SWE-bench requires Node.js subprocess with Python evaluation harness.");
   console.log("Usage: /omp:swe-bench --suite lite --compare baseline");
 }
+async function runCancel() {
+  try {
+    const { rmSync, existsSync: existsSync2 } = await import("fs");
+    const { join: join7 } = await import("path");
+    const statePath = join7(process.cwd(), ".omp", "state");
+    if (existsSync2(statePath)) {
+      rmSync(statePath, { recursive: true, force: true });
+      console.log("OMP: active session cancelled. .omp/state/ cleared.");
+    } else {
+      console.log("OMP: no active session state found. Nothing to cancel.");
+    }
+  } catch (err) {
+    console.error("OMP cancel failed:", err);
+    process.exitCode = 1;
+  }
+}
+async function runHelp() {
+  try {
+    const { SKILL_REGISTRY: SKILL_REGISTRY2 } = await Promise.resolve().then(() => (init_registry(), registry_exports));
+    console.log("OMP Skills Catalog\n");
+    console.log("  ID                           Description");
+    console.log("  " + "-".repeat(70));
+    for (const skill of SKILL_REGISTRY2) {
+      const id = skill.id.padEnd(30);
+      console.log(`  ${id} ${skill.description}`);
+    }
+    console.log(`
+Total: ${SKILL_REGISTRY2.length} skills`);
+    console.log("\nUsage: /omp:<skill-id> [args]");
+  } catch (err) {
+    console.error("OMP help failed:", err);
+    process.exitCode = 1;
+  }
+}
+async function runUltragoal(args) {
+  try {
+    const { mkdirSync: mkdirSync3, readFileSync: readFileSync4, writeFileSync: writeFileSync2, existsSync: existsSync2 } = await import("fs");
+    const { join: join7 } = await import("path");
+    const goalDir = join7(process.cwd(), ".omp", "ultragoal");
+    const goalsPath = join7(goalDir, "goals.json");
+    mkdirSync3(goalDir, { recursive: true });
+    let goals = [];
+    if (existsSync2(goalsPath)) {
+      const parsed = JSON.parse(readFileSync4(goalsPath, "utf-8"));
+      if (Array.isArray(parsed)) {
+        goals = parsed;
+      } else {
+        console.error("OMP UltraGoal: goals.json is corrupted (not an array). Resetting to empty.");
+        goals = [];
+      }
+    }
+    if (args.length > 0) {
+      const nextId = goals.length === 0 ? 1 : Math.max(...goals.map((g) => g.id)) + 1;
+      const newGoal = { id: nextId, goal: args.join(" "), status: "active", createdAt: (/* @__PURE__ */ new Date()).toISOString() };
+      goals.push(newGoal);
+      const tmpPath = goalsPath + ".tmp";
+      writeFileSync2(tmpPath, JSON.stringify(goals, null, 2));
+      const { renameSync: renameSync2 } = await import("fs");
+      renameSync2(tmpPath, goalsPath);
+      console.log(`OMP UltraGoal: added goal #${newGoal.id}: "${newGoal.goal}"`);
+    } else {
+      if (goals.length === 0) {
+        console.log("OMP UltraGoal: no goals set. Use: omp ultragoal <goal description>");
+      } else {
+        console.log("OMP UltraGoal \u2014 Current Goals:\n");
+        for (const g of goals) {
+          console.log(`  #${g.id} [${g.status}] ${g.goal}`);
+        }
+      }
+    }
+  } catch (err) {
+    console.error("OMP ultragoal failed:", err);
+    process.exitCode = 1;
+  }
+}
+async function runExternalContext(args) {
+  if (args.length === 0) {
+    console.log("OMP external-context: use /external-context <url-or-path> or /oh-my-githubcopilot:external-context in GitHub Copilot CLI to load external docs into session context.");
+    return;
+  }
+  const target = args.join(" ");
+  console.log(`External context loaded: ${target}. Use /external-context ${target} in Copilot CLI to load into session.`);
+}
+async function runRemember(args) {
+  try {
+    const { mkdirSync: mkdirSync3, readdirSync: readdirSync2, writeFileSync: writeFileSync2, existsSync: existsSync2 } = await import("fs");
+    const { join: join7 } = await import("path");
+    const memoryDir = join7(process.cwd(), ".omp", "memory");
+    mkdirSync3(memoryDir, { recursive: true });
+    if (args.length === 0) {
+      if (!existsSync2(memoryDir)) {
+        console.log("OMP Remember: no memories found. Use: omp remember <text>");
+        return;
+      }
+      const files = readdirSync2(memoryDir).filter((f) => f.endsWith(".md")).sort();
+      if (files.length === 0) {
+        console.log("OMP Remember: no memories found. Use: omp remember <text>");
+      } else {
+        console.log("OMP Remember \u2014 Stored Memories:\n");
+        for (const file of files) {
+          console.log(`  ${file}`);
+        }
+        console.log(`
+Total: ${files.length} memor${files.length === 1 ? "y" : "ies"}`);
+      }
+      return;
+    }
+    const text = args.join(" ");
+    const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
+    const fileName = `${timestamp}.md`;
+    const filePath = join7(memoryDir, fileName);
+    const tmpPath = filePath + ".tmp";
+    const content = `# Memory: ${(/* @__PURE__ */ new Date()).toISOString()}
+
+${text}
+`;
+    writeFileSync2(tmpPath, content, "utf-8");
+    const { renameSync: renameSync2 } = await import("fs");
+    renameSync2(tmpPath, filePath);
+    console.log(`OMP Remember: saved memory to .omp/memory/${fileName}`);
+  } catch (err) {
+    console.error("OMP remember failed:", err);
+    process.exitCode = 1;
+  }
+}
+async function runWriterMemory(args) {
+  try {
+    const { mkdirSync: mkdirSync3, readFileSync: readFileSync4, appendFileSync: appendFileSync2, existsSync: existsSync2 } = await import("fs");
+    const { join: join7, dirname: dirname4 } = await import("path");
+    const filePath = join7(process.cwd(), ".omp", "writer-memory.md");
+    mkdirSync3(dirname4(filePath), { recursive: true });
+    if (args.length === 0) {
+      if (!existsSync2(filePath)) {
+        console.log("OMP Writer Memory: no style notes found. Use: omp writer-memory <style-note>");
+        return;
+      }
+      const content = readFileSync4(filePath, "utf-8");
+      console.log(content);
+      return;
+    }
+    const note = args.join(" ");
+    const entry = `
+## ${(/* @__PURE__ */ new Date()).toISOString()}
+
+${note}
+`;
+    appendFileSync2(filePath, entry, "utf-8");
+    console.log(`OMP Writer Memory: appended style note to .omp/writer-memory.md`);
+  } catch (err) {
+    console.error("OMP writer-memory failed:", err);
+    process.exitCode = 1;
+  }
+}
 main().catch((err) => {
   console.error(err);
   process.exit(1);