@damian87/omp 0.10.0 → 0.13.0

package/scripts/lib/hook-input.mjs

@@ -0,0 +1,51 @@
+function parseMaybeJson(value) {
+  if (typeof value !== "string") return value;
+  const trimmed = value.trim();
+  if (!trimmed) return value;
+  if (!trimmed.startsWith("{") && !trimmed.startsWith("[")) return value;
+  try {
+    return JSON.parse(trimmed);
+  } catch {
+    return value;
+  }
+}
+
+function normalizeResult(raw) {
+  if (!raw || typeof raw !== "object") return undefined;
+  const resultType = raw.resultType ?? raw.result_type;
+  const textResultForLlm = raw.textResultForLlm ?? raw.text_result_for_llm;
+  if (resultType == null && textResultForLlm == null) return undefined;
+  return {
+    resultType: resultType ?? "success",
+    textResultForLlm: textResultForLlm == null ? "" : String(textResultForLlm),
+  };
+}
+
+export function normalizeHookInput(data = {}, options = {}) {
+  const payload = data && typeof data === "object" ? data : {};
+  const cwd = payload.cwd ?? payload.directory ?? options.cwd ?? process.cwd();
+  const toolResult = normalizeResult(payload.toolResult ?? payload.tool_result ?? payload.toolOutput);
+  const error = payload.error?.message ?? payload.error ?? payload.message;
+  return {
+    raw: payload,
+    hookEventName: payload.hookEventName ?? payload.hook_event_name,
+    sessionId: payload.sessionId ?? payload.session_id ?? "unknown",
+    timestamp: payload.timestamp,
+    cwd,
+    directory: cwd,
+    prompt: payload.prompt ?? payload.message?.content ?? "",
+    toolName: payload.toolName ?? payload.tool_name ?? "unknown",
+    toolArgs: parseMaybeJson(payload.toolArgs ?? payload.tool_input ?? payload.toolInput),
+    toolResult,
+    error: error == null ? undefined : String(error),
+    transcriptPath: payload.transcriptPath ?? payload.transcript_path,
+    stopReason: payload.stopReason ?? payload.stop_reason,
+    trigger: payload.trigger,
+    customInstructions: payload.customInstructions ?? payload.custom_instructions,
+  };
+}
+
+export function parseHookInput(raw, options = {}) {
+  const data = raw ? JSON.parse(raw) : {};
+  return normalizeHookInput(data, options);
+}

package/scripts/lib/hook-output.mjs

@@ -4,23 +4,65 @@ import { ompRoot } from "./omp-root.mjs";
 
 // Hook scripts run under BOTH GitHub Copilot CLI (camelCase events, top-level
 // `additionalContext` / `{decision,reason}` / `{permissionDecision}`) and Claude
-// Code (`{continue, hookSpecificOutput}` / `{decision, reason}`). We dual-emit:
-// every output object carries both vocabularies, and each host ignores the keys
-// it does not recognize. See docs/plans/copilot-native-hooks.md.
+// Code (`{continue, hookSpecificOutput}` / `{decision, reason}`). The injection
+// path (`printContinue`) dual-emits: every output object carries both
+// vocabularies, and each host ignores the keys it does not recognize. See
+// docs/plans/copilot-native-hooks.md.
+//
+// The cost/minification path uses the documented Copilot builder shapes
+// (`buildContinueOutput`/`buildAdditionalContextOutput`/`buildModifiedResultOutput`/
+// `buildPermissionDecisionOutput`). An empty `{}` is a no-op "continue" for both
+// hosts, so these builders coexist with the dual-emit injection path.
 
 /** Project directory from hook input — Copilot sends `cwd`, Claude sends `directory`. */
 export function hookCwd(data) {
   return data?.cwd ?? data?.directory ?? process.cwd();
 }
 
-/** sessionStart / postToolUse style: inject `additionalContext` (or a plain continue). */
+export function buildContinueOutput() {
+  return {};
+}
+
+export function buildAdditionalContextOutput(additionalContext = "") {
+  return additionalContext ? { additionalContext } : buildContinueOutput();
+}
+
+export function buildModifiedResultOutput(textResultForLlm, additionalContext = "", resultType = "success") {
+  return {
+    modifiedResult: {
+      resultType,
+      textResultForLlm,
+    },
+    ...(additionalContext ? { additionalContext } : {}),
+  };
+}
+
+export function buildPermissionDecisionOutput(permissionDecision, permissionDecisionReason, modifiedArgs) {
+  return {
+    permissionDecision,
+    ...(permissionDecisionReason ? { permissionDecisionReason } : {}),
+    ...(modifiedArgs == null ? {} : { modifiedArgs }),
+  };
+}
+
+/**
+ * sessionStart / userPromptSubmitted injection. When there is context to inject,
+ * dual-emit it for both hosts (Copilot top-level `additionalContext` + Claude
+ * `continue`/`hookSpecificOutput`). With nothing to inject, emit an empty `{}` —
+ * a no-op "continue" understood by both hosts and the zero-cost default.
+ */
 export function printContinue(hookEventName, additionalContext = "") {
-  const output = { continue: true };
-  if (additionalContext) {
-    output.additionalContext = additionalContext; // Copilot CLI
-    output.hookSpecificOutput = { hookEventName, additionalContext }; // Claude Code
+  if (!additionalContext) {
+    console.log(JSON.stringify(buildContinueOutput()));
+    return;
   }
-  console.log(JSON.stringify(output));
+  console.log(
+    JSON.stringify({
+      continue: true,
+      additionalContext, // Copilot CLI
+      hookSpecificOutput: { hookEventName, additionalContext }, // Claude Code
+    }),
+  );
 }
 
 /** agentStop (Copilot) / Stop (Claude): both honor {decision, reason}. */
@@ -39,11 +81,11 @@ export function printPermission(permissionDecision, reason = "", modifiedArgs) {
 }
 
 export function printBlock(reason) {
-  console.log(JSON.stringify({ continue: false, reason }));
+  console.log(JSON.stringify(buildPermissionDecisionOutput("deny", reason)));
 }
 
 export function failOpen() {
-  console.log(JSON.stringify({ continue: true }));
+  console.log(JSON.stringify(buildContinueOutput()));
 }
 
 export function appendHookLog(directory, hookName, payload) {

package/scripts/lib/memory-review-trigger.mjs

@@ -0,0 +1,59 @@
+import { spawn as nodeSpawn } from "node:child_process";
+import { existsSync, readFileSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+import { dirname, join } from "node:path";
+import { ompRoot } from "./omp-root.mjs";
+
+// sessionEnd hook → end-of-session memory review. The hook must return fast
+// (5s timeout), so this only DETACHES `omp memory-review` and returns. The
+// downstream claim guard de-dupes against the wrapper fallback. Fail-open:
+// any error means "don't trigger", never throw into the hook.
+
+function readMemoryMode(cwd) {
+  const env = process.env.OMP_MEMORY_MODE;
+  if (env === "on") return "on";
+  if (env === "off") return "off";
+  try {
+    const p = join(ompRoot(cwd), ".omp", "config.json");
+    if (!existsSync(p)) return "off";
+    const raw = JSON.parse(readFileSync(p, "utf8"));
+    return raw && raw.memoryMode === "on" ? "on" : "off";
+  } catch {
+    return "off";
+  }
+}
+
+function defaultDistPath() {
+  // scripts/lib/ -> packageRoot/dist/src/cli.js (present in the npm package and
+  // dev builds, but NOT in a plugin installed from GitHub — dist is gitignored).
+  const here = dirname(fileURLToPath(import.meta.url));
+  return join(here, "..", "..", "dist", "src", "cli.js");
+}
+
+/** Decide how to invoke the omp CLI. An explicit cliPath (tests/dev) or a
+ *  bundled dist runs via `node <path>`; otherwise — the normal install, where
+ *  the plugin (from GitHub) has no dist but `omp` is installed globally via npm —
+ *  invoke `omp` from PATH. Exported for testing. */
+export function resolveMemoryReviewInvocation({ sessionId, cwd, cliPath, distPath = defaultDistPath(), exists = existsSync } = {}) {
+  const args = ["memory-review", "--session", sessionId, "--root", cwd];
+  if (cliPath) return { command: process.execPath, args: [cliPath, ...args] };
+  if (exists(distPath)) return { command: process.execPath, args: [distPath, ...args] };
+  return { command: "omp", args }; // plugin-from-GitHub: rely on the global omp CLI
+}
+
+export function triggerMemoryReview(options = {}) {
+  const { cwd, sessionId, spawn = nodeSpawn, cliPath, mode } = options;
+  const resolvedMode = mode ?? readMemoryMode(cwd);
+  if (resolvedMode !== "on") return { triggered: false, reason: "memory-mode off" };
+  if (!sessionId || sessionId === "unknown") return { triggered: false, reason: "no session id" };
+  try {
+    const { command, args } = resolveMemoryReviewInvocation({ sessionId, cwd, cliPath });
+    const child = spawn(command, args, { detached: true, stdio: "ignore" });
+    // Handle async spawn errors so they never surface as unhandled (fail-open).
+    if (child && typeof child.on === "function") child.on("error", () => {});
+    if (child && typeof child.unref === "function") child.unref();
+    return { triggered: true };
+  } catch (err) {
+    return { triggered: false, reason: String(err?.message ?? err) };
+  }
+}

package/scripts/lib/minify.mjs

@@ -0,0 +1,80 @@
+import { countTokens } from "./cost-ledger.mjs";
+
+const ANSI_RE = /\u001b\[[0-9;]*m/g;
+const DIAGNOSTIC_RE = /\b(fail(?:ed|ure)?|error|exception|assertion|traceback|expected|cannot find|no-undef|TS\d{4})\b/i;
+
+function stripAnsi(text) {
+  return text.replace(ANSI_RE, "");
+}
+
+function dedupConsecutiveLines(lines) {
+  const out = [];
+  let previous = "";
+  let repeated = 0;
+  for (const line of lines) {
+    if (line === previous) {
+      repeated += 1;
+      continue;
+    }
+    if (repeated > 0) out.push(`[omp] repeated previous line ${repeated} time${repeated === 1 ? "" : "s"}`);
+    out.push(line);
+    previous = line;
+    repeated = 0;
+  }
+  if (repeated > 0) out.push(`[omp] repeated previous line ${repeated} time${repeated === 1 ? "" : "s"}`);
+  return out;
+}
+
+export function minifyToolOutput(value, options = {}) {
+  const rawText = value == null ? "" : String(value);
+  const rawTokens = countTokens(rawText);
+  const thresholdTokens = options.thresholdTokens ?? 800;
+  if (rawTokens <= thresholdTokens) {
+    return {
+      changed: false,
+      text: rawText,
+      rawTokens,
+      modelTokens: rawTokens,
+      savedTokens: 0,
+    };
+  }
+
+  const headLines = options.headLines ?? 80;
+  const tailLines = options.tailLines ?? 40;
+  const normalized = dedupConsecutiveLines(stripAnsi(rawText).split("\n"));
+  const omitted = Math.max(0, normalized.length - headLines - tailLines);
+  const head = normalized.slice(0, headLines);
+  const tail = omitted > 0 ? normalized.slice(-tailLines) : [];
+  const tailStart = omitted > 0 ? normalized.length - tailLines : normalized.length;
+  const diagnosticLines = normalized
+    .map((line, index) => ({ line, index }))
+    .filter(({ line, index }) => index >= headLines && index < tailStart && DIAGNOSTIC_RE.test(line))
+    .slice(0, options.maxDiagnosticLines ?? 40)
+    .map(({ line }) => line);
+  const text = [
+    `[omp] output trimmed from ${rawTokens} estimated tokens; full raw output is saved on disk.`,
+    ...head,
+    ...(omitted > 0 ? [`[omp] … omitted ${omitted} middle line${omitted === 1 ? "" : "s"} …`] : []),
+    ...(diagnosticLines.length > 0 ? ["[omp] preserved diagnostic lines from omitted output:", ...diagnosticLines] : []),
+    ...tail,
+  ].join("\n");
+  const modelTokens = countTokens(text);
+
+  if (modelTokens >= rawTokens) {
+    return {
+      changed: false,
+      text: rawText,
+      rawTokens,
+      modelTokens: rawTokens,
+      savedTokens: 0,
+    };
+  }
+
+  return {
+    changed: true,
+    text,
+    rawTokens,
+    modelTokens,
+    savedTokens: rawTokens - modelTokens,
+  };
+}

package/scripts/lib/pending-directives.mjs

@@ -0,0 +1,36 @@
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { ompRoot } from "./omp-root.mjs";
+
+// Memory-review writes proposed directives to a GATED pending queue (never
+// auto-applied). Without a nudge that queue is invisible and rots, so the
+// sessionStart hook surfaces a count + how to promote. Promotion stays manual:
+// `omp project-memory add-directive "<rule>"` then remove the line.
+
+function pendingPath(cwd) {
+  return join(ompRoot(cwd), ".oh-my-copilot", "memory-review", "pending-directives.md");
+}
+
+/** Count unchecked ("- [ ]") items in the pending-directives queue. */
+export function countPendingDirectives(cwd) {
+  const p = pendingPath(cwd);
+  if (!existsSync(p)) return 0;
+  try {
+    return readFileSync(p, "utf8")
+      .split("\n")
+      .filter((line) => /^\s*-\s*\[\s*\]\s+\S/.test(line)).length;
+  } catch {
+    return 0;
+  }
+}
+
+/** SessionStart nudge string, or "" when nothing is pending. */
+export function pendingDirectivesNudge(cwd) {
+  const n = countPendingDirectives(cwd);
+  if (n === 0) return "";
+  return (
+    `[MEMORY REVIEW] ${n} proposed directive${n === 1 ? "" : "s"} await your review in ` +
+    `.oh-my-copilot/memory-review/pending-directives.md — promote the ones you want with ` +
+    "`omp project-memory add-directive \"<rule>\"`, then delete the line."
+  );
+}

package/scripts/post-tool-use-failure.mjs

@@ -0,0 +1,21 @@
+#!/usr/bin/env node
+import { readStdin } from "./lib/stdin.mjs";
+import { parseHookInput } from "./lib/hook-input.mjs";
+import { appendHookLog, failOpen } from "./lib/hook-output.mjs";
+
+const HOOK_NAME = "postToolUseFailure";
+
+(async () => {
+  try {
+    const input = parseHookInput(await readStdin());
+    appendHookLog(input.cwd, HOOK_NAME, {
+      sessionId: input.sessionId,
+      toolName: input.toolName,
+      error: input.error ?? "unknown",
+    });
+    failOpen();
+  } catch (err) {
+    console.error(`[hook ${HOOK_NAME}] failed: ${err?.message ?? err}`);
+    failOpen();
+  }
+})();

package/scripts/post-tool-use.mjs

@@ -1,31 +1,94 @@
 #!/usr/bin/env node
-import { appendFileSync, mkdirSync } from "node:fs";
+import { appendFileSync, mkdirSync, writeFileSync } from "node:fs";
 import { dirname, join } from "node:path";
 import { readStdin } from "./lib/stdin.mjs";
+import { buildModifiedResultOutput, failOpen } from "./lib/hook-output.mjs";
+import { parseHookInput } from "./lib/hook-input.mjs";
+import { appendCostRecord, countTokens } from "./lib/cost-ledger.mjs";
+import { minifyToolOutput } from "./lib/minify.mjs";
 
 const HOOK_NAME = "PostToolUse";
+const NOISY_COMMAND_RE = /\b(npm|pnpm|yarn|bun|vitest|jest|mocha|pytest|cargo|go|tsc|eslint|biome|ruff|mypy|make|gradle|mvn)\b/i;
+
+function safePathPart(value) {
+  return (
+    String(value || "unknown")
+      .replace(/[^a-zA-Z0-9._-]+/g, "-")
+      .replace(/^-+|-+$/g, "") || "unknown"
+  );
+}
+
+function shouldMinify(input) {
+  if (process.env.OMP_MINIFY === "0") return false;
+  const toolName = String(input.toolName || "").toLowerCase();
+  const command = String(input.toolArgs?.command ?? input.toolArgs?.cmd ?? "");
+  return (toolName === "bash" || toolName === "shell" || toolName === "terminal") && NOISY_COMMAND_RE.test(command);
+}
 
 (async () => {
   try {
     const raw = await readStdin();
-    const data = raw ? JSON.parse(raw) : {};
-    const sessionId = data.sessionId ?? data.session_id ?? "unknown";
-    const directory = data.cwd ?? data.directory ?? process.cwd();
-    const toolName = data.toolName ?? data.tool_name ?? "unknown";
-    const ok = data.toolOutput != null;
+    const input = parseHookInput(raw);
+    const sessionId = input.sessionId;
+    const directory = input.cwd;
+    const toolName = input.toolName;
+    const ok = input.toolResult != null;
+    const rawText = input.toolResult?.textResultForLlm ?? "";
+    const minified = !shouldMinify(input) ? {
+      changed: false,
+      text: rawText,
+      rawTokens: countTokens(rawText),
+      modelTokens: countTokens(rawText),
+      savedTokens: 0,
+    } : minifyToolOutput(rawText);
+    let rawPath;
     const logFile = join(directory, ".omp", "state", "hooks.log");
+    let canModifyResult = minified.changed;
     try {
       mkdirSync(dirname(logFile), { recursive: true });
       appendFileSync(
         logFile,
         `${JSON.stringify({ ts: new Date().toISOString(), hook: HOOK_NAME, sessionId, toolName, ok })}\n`,
       );
+      if (minified.changed) {
+        rawPath = join(
+          directory,
+          ".omp",
+          "state",
+          "cost",
+          "raw",
+          `${safePathPart(sessionId)}-${Date.now()}-${safePathPart(toolName)}.txt`,
+        );
+        mkdirSync(dirname(rawPath), { recursive: true });
+        writeFileSync(rawPath, rawText, "utf8");
+      }
+    } catch {
+      canModifyResult = false;
+    }
+    try {
+      appendCostRecord(directory, {
+        sessionId,
+        event: "postToolUse",
+        toolName,
+        inTokens: countTokens(input.toolArgs),
+        outTokens: canModifyResult ? minified.modelTokens : minified.rawTokens,
+        rawOutTokens: minified.rawTokens,
+        savedTokens: canModifyResult ? minified.savedTokens : 0,
+        rawPath,
+      });
     } catch {
       // best effort
     }
-    console.log(JSON.stringify({ continue: true }));
+    if (canModifyResult) {
+      console.log(JSON.stringify(buildModifiedResultOutput(
+        minified.text,
+        `[omp] output trimmed ${minified.rawTokens}→${minified.modelTokens} tokens; full output at ${rawPath}`,
+      )));
+      return;
+    }
+    failOpen();
   } catch (err) {
     console.error(`[hook ${HOOK_NAME}] failed: ${err?.message ?? err}`);
-    console.log(JSON.stringify({ continue: true }));
+    failOpen();
   }
 })();

package/scripts/pre-tool-use.mjs

@@ -2,16 +2,18 @@
 import { appendFileSync, mkdirSync } from "node:fs";
 import { dirname, join } from "node:path";
 import { readStdin } from "./lib/stdin.mjs";
+import { failOpen } from "./lib/hook-output.mjs";
+import { parseHookInput } from "./lib/hook-input.mjs";
 
 const HOOK_NAME = "PreToolUse";
 
 (async () => {
   try {
     const raw = await readStdin();
-    const data = raw ? JSON.parse(raw) : {};
-    const sessionId = data.sessionId ?? data.session_id ?? "unknown";
-    const directory = data.cwd ?? data.directory ?? process.cwd();
-    const toolName = data.toolName ?? data.tool_name ?? "unknown";
+    const input = parseHookInput(raw);
+    const sessionId = input.sessionId;
+    const directory = input.cwd;
+    const toolName = input.toolName;
     const logFile = join(directory, ".omp", "state", "hooks.log");
     try {
       mkdirSync(dirname(logFile), { recursive: true });
@@ -22,9 +24,9 @@ const HOOK_NAME = "PreToolUse";
     } catch {
       // best effort
     }
-    console.log(JSON.stringify({ continue: true }));
+    failOpen();
   } catch (err) {
     console.error(`[hook ${HOOK_NAME}] failed: ${err?.message ?? err}`);
-    console.log(JSON.stringify({ continue: true }));
+    failOpen();
   }
 })();

package/scripts/prompt-submit.mjs

@@ -2,9 +2,11 @@
 import { appendFileSync, existsSync, mkdirSync, readFileSync } from "node:fs";
 import { dirname, join } from "node:path";
 import { readStdin } from "./lib/stdin.mjs";
-import { hookCwd, printContinue, failOpen } from "./lib/hook-output.mjs";
+import { failOpen, printContinue } from "./lib/hook-output.mjs";
 import { recordPrompt } from "./lib/daily-log.mjs";
 import { ompRoot } from "./lib/omp-root.mjs";
+import { parseHookInput } from "./lib/hook-input.mjs";
+import { appendCostRecord, countTokens } from "./lib/cost-ledger.mjs";
 
 const HOOK_NAME = "UserPromptSubmit";
 
@@ -52,11 +54,16 @@ function appendLog(directory, payload) {
 (async () => {
   try {
     const raw = await readStdin();
-    const data = raw ? JSON.parse(raw) : {};
-    const sessionId = data.sessionId ?? data.session_id ?? "unknown";
-    const directory = hookCwd(data);
-    const prompt = data.prompt ?? data.message?.content ?? "";
+    const input = parseHookInput(raw);
+    const sessionId = input.sessionId;
+    const directory = input.cwd;
+    const prompt = input.prompt;
     appendLog(directory, { sessionId, promptBytes: String(prompt).length });
+    appendCostRecord(directory, {
+      sessionId,
+      event: "userPromptSubmitted",
+      inTokens: countTokens(prompt),
+    });
     // Count this prompt as session work (signals the SessionEnd nudge logic).
     // Injects nothing — keeps per-turn token cost at zero.
     try {

package/scripts/session-end.mjs

@@ -4,15 +4,18 @@ import { dirname, join } from "node:path";
 import { readStdin } from "./lib/stdin.mjs";
 import { endSession } from "./lib/daily-log.mjs";
 import { ompRoot } from "./lib/omp-root.mjs";
+import { failOpen } from "./lib/hook-output.mjs";
+import { parseHookInput } from "./lib/hook-input.mjs";
+import { triggerMemoryReview } from "./lib/memory-review-trigger.mjs";
 
 const HOOK_NAME = "SessionEnd";
 
 (async () => {
   try {
     const raw = await readStdin();
-    const data = raw ? JSON.parse(raw) : {};
-    const sessionId = data.sessionId ?? data.session_id ?? "unknown";
-    const directory = data.cwd ?? data.directory ?? process.cwd();
+    const input = parseHookInput(raw);
+    const sessionId = input.sessionId;
+    const directory = input.cwd;
     const logFile = join(ompRoot(directory), ".omp", "state", "hooks.log");
     try {
       mkdirSync(dirname(logFile), { recursive: true });
@@ -26,9 +29,16 @@ const HOOK_NAME = "SessionEnd";
     // Arm a daily-log nudge for the next session if this one did work but
     // logged nothing. endSession never throws.
     endSession(directory);
-    console.log(JSON.stringify({ continue: true }));
+    // Memory mode (opt-in): detach the cheap-model end-of-session review.
+    // Best-effort and non-blocking — never delays the hook return.
+    try {
+      triggerMemoryReview({ cwd: directory, sessionId });
+    } catch {
+      // never block session end on the review trigger
+    }
+    failOpen();
   } catch (err) {
     console.error(`[hook ${HOOK_NAME}] failed: ${err?.message ?? err}`);
-    console.log(JSON.stringify({ continue: true }));
+    failOpen();
   }
 })();

package/scripts/session-start.mjs

@@ -2,12 +2,14 @@
 import { appendFileSync, mkdirSync } from "node:fs";
 import { dirname, join } from "node:path";
 import { readStdin } from "./lib/stdin.mjs";
-import { hookCwd, printContinue, failOpen } from "./lib/hook-output.mjs";
+import { failOpen, printContinue } from "./lib/hook-output.mjs";
 import { checkForUpdate, formatUpdateNotice } from "./lib/version-check.mjs";
 import { scanScheduleResults } from "./lib/schedule-results.mjs";
 import { readRepoGoal, readTodayGoal, recentEntryStats, startSession } from "./lib/daily-log.mjs";
 import { readDirectives } from "./lib/project-memory.mjs";
+import { pendingDirectivesNudge } from "./lib/pending-directives.mjs";
 import { ompRoot } from "./lib/omp-root.mjs";
+import { parseHookInput } from "./lib/hook-input.mjs";
 
 const HOOK_NAME = "SessionStart";
 
@@ -31,9 +33,9 @@ function buildDailyLogBreadcrumb(directory) {
 (async () => {
   try {
     const raw = await readStdin();
-    const data = raw ? JSON.parse(raw) : {};
-    const sessionId = data.sessionId ?? data.session_id ?? "unknown";
-    const directory = hookCwd(data);
+    const input = parseHookInput(raw);
+    const sessionId = input.sessionId;
+    const directory = input.cwd;
     const stateDir = join(ompRoot(directory), ".omp", "state");
     const logFile = join(stateDir, "hooks.log");
     mkdirSync(dirname(logFile), { recursive: true });
@@ -77,6 +79,9 @@ function buildDailyLogBreadcrumb(directory) {
     }
     const repoGoal = readRepoGoal(directory);
     if (repoGoal) parts.push(`[REPO GOAL] ${repoGoal}`);
+    // Memory-review's gated directive queue is invisible without a nudge.
+    const pendingNudge = pendingDirectivesNudge(directory);
+    if (pendingNudge) parts.push(pendingNudge);
     const breadcrumb = buildDailyLogBreadcrumb(directory);
     if (breadcrumb) parts.push(breadcrumb);
     // Resets the per-session baseline and flushes a nudge when the prior session