oh-my-githubcopilot 1.8.1-alpha.1f91ed9 → 1.8.1-alpha.4ccdcc7

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({
@@ -135,7 +135,7 @@ function deserializeHudState(raw) {
     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,
+    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
@@ -168,7 +168,7 @@ function buildHudState(snapshot, now = Date.now()) {
     skillsUsed,
     toolsTotal: 13,
     skillsTotal: 25,
-    agentsTotal: 23,
+    agentsTotal: 19,
     premiumRequests: snapshot.premium_requests ?? 0,
     premiumRequestsTotal: snapshot.premium_requests_total ?? DEFAULT_PREMIUM_REQUESTS_TOTAL,
     warningActive: snapshot.warning_active ?? false
@@ -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,7 +278,7 @@ 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");
   }
 });
@@ -339,6 +339,182 @@ var init_install = __esm({
   }
 });
 
+// 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 chunks = [];
+  for await (const chunk of process.stdin) {
+    chunks.push(String(chunk));
+  }
+  return chunks.join("");
+}
+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, {
@@ -430,17 +606,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",
@@ -541,7 +711,26 @@ 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"
     };
     KEYWORD_ENTRIES = Object.entries(KEYWORD_MAP).sort(([a], [b]) => b.length - a.length);
     CANONICAL_COMMAND_MAP = {
@@ -550,13 +739,285 @@ 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:"]
+      }
+    ];
+  }
+});
+
 // src/index.mts
 import { parseArgs } from "util";
 import { createRequire } from "module";
@@ -759,6 +1220,33 @@ async function main() {
       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;
     default:
       console.error(`Unknown subcommand: ${resolvedSubcommand}`);
       printUsage(true);
@@ -767,15 +1255,15 @@ async function main() {
 }
 function printUsage(stderr = false) {
   const output = stderr ? console.error : console.log;
-  output("Usage: omp [hud|install|version|psm|bench|hook] [--watch]");
+  output("Usage: omp [hud|install|doctor|version|psm|bench|hook|verify|cancel|help|code-review|security-review|ultraqa|ultragoal] [--watch]");
 }
 async function printHud() {
   try {
-    const { readFileSync: readFileSync3 } = await import("fs");
-    const { join: join5 } = await import("path");
-    const { homedir: homedir5 } = await import("os");
-    const hudPath = join5(homedir5(), ".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`);
@@ -795,22 +1283,88 @@ 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;
+  }
+}
 main().catch((err) => {
   console.error(err);
   process.exit(1);