Merge pull request #48 from first-fluke/chore/update-oh-my-agent

chore(deps): update oh-my-agent skills

Author: gracefullight

.agents/eval/oma-scholar/_rollouts/69cf97a7b7bfbc2f.json

@@ -134,6 +134,88 @@ export async function isAgentMemoryReachable(): Promise<boolean> {
   }
 }
 
+export interface RecalledFact {
+  text: string;
+  source?: string;
+  score?: number;
+}
+
+interface SearchResult {
+  score?: number;
+  observation?: {
+    narrative?: unknown;
+    facts?: unknown;
+    title?: unknown;
+    type?: unknown;
+  };
+}
+
+function parseSearchResults(body: string, k: number): RecalledFact[] {
+  let parsed: { results?: unknown };
+  try {
+    parsed = JSON.parse(body) as { results?: unknown };
+  } catch {
+    return [];
+  }
+  if (!Array.isArray(parsed.results)) return [];
+
+  const minScore = (() => {
+    const raw = Number(process.env.OMA_RECALL_MIN_SCORE);
+    return Number.isFinite(raw) ? raw : 1;
+  })();
+
+  const facts: RecalledFact[] = [];
+  for (const entry of parsed.results as SearchResult[]) {
+    const score = typeof entry.score === "number" ? entry.score : 0;
+    // Raw `/observe` envelopes score near-zero (~0.006); enriched facts score
+    // in the single digits. Drop the noise floor so the snapshot stays useful.
+    if (score < minScore) continue;
+    const obs = entry.observation ?? {};
+    const narrative =
+      typeof obs.narrative === "string" && obs.narrative.trim()
+        ? obs.narrative.trim()
+        : "";
+    const factsText = Array.isArray(obs.facts)
+      ? obs.facts.filter((f): f is string => typeof f === "string").join("; ")
+      : "";
+    const title = typeof obs.title === "string" ? obs.title.trim() : "";
+    const text = narrative || factsText || title;
+    if (!text) continue;
+    const source = typeof obs.type === "string" ? obs.type : undefined;
+    facts.push({ text, source, score });
+    if (facts.length >= k) break;
+  }
+  return facts;
+}
+
+/**
+ * Recall enriched facts from AgentMemory for boundary rehydration. Best-effort:
+ * returns [] when the daemon is unreachable, on timeout (recall budget 2s per
+ * design D34), or on any parse/transport error — never throws, never blocks L1.
+ */
+export async function recallFacts(
+  query: string,
+  k = 5,
+): Promise<RecalledFact[]> {
+  if (!query.trim()) return [];
+  if (!(await isAgentMemoryReachable())) return [];
+  const url = endpointUrl();
+  if (!url) return [];
+
+  try {
+    const response = await requestAgentMemory(url, "/agentmemory/search", {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify({ query, limit: k }),
+      timeoutMs: 2000,
+    });
+    if (response.statusCode < 200 || response.statusCode >= 300) return [];
+    return parseSearchResults(response.body, k);
+  } catch {
+    return [];
+  }
+}
+
 export async function observeWithTimeout(payload: {
   sessionId: string;
   content: string;

.agents/hooks/core/agentmemory-client.ts

@@ -31,7 +31,17 @@ import { VENDORS } from "./constants.ts";
 import { resolveGitRoot } from "./fs-utils.ts";
 import { clearGrokContext } from "./grok-context.ts";
 import { makePromptOutput } from "./hook-output.ts";
-import type { ModeState, Vendor } from "./types.ts";
+// triggers.json is imported statically: the bundler inlines it into the oma
+// binary (bundled `oma hook` path needs no file on disk), while a standalone
+// bun run resolves the sibling file next to this module (pi / direct run).
+import embeddedTriggers from "./triggers.json" with { type: "json" };
+import type {
+  HandlerCtx,
+  HandlerResult,
+  HookInput,
+  ModeState,
+  Vendor,
+} from "./types.ts";
 
 // ── Unicode normalization ─────────────────────────────────────
 
@@ -377,9 +387,9 @@ interface TriggerConfig {
   extensionRouting?: Record<string, string[]>;
 }
 
+/** Load the triggers config from the embedded (bundler-inlined / sibling-resolved) JSON. */
 function loadConfig(): TriggerConfig {
-  const configPath = join(import.meta.dirname, "triggers.json");
-  return JSON.parse(readFileSync(configPath, "utf-8"));
+  return structuredClone(embeddedTriggers) as TriggerConfig;
 }
 
 function detectLanguage(projectDir: string): string {
@@ -742,37 +752,32 @@ export function deactivateAllPersistentModes(
   }
 }
 
-// ── Main ──────────────────────────────────────────────────────
+// ── Pure handler (canonical ABI) ─────────────────────────────
 
-async function main() {
-  const raw = readFileSync(0, "utf-8");
-  let input: Record<string, unknown>;
-  try {
-    input = JSON.parse(raw);
-  } catch {
-    process.exit(0);
-  }
-
-  // Guard 1: Only process genuine user prompts — skip agent-generated content
-  if (!isGenuineUserPrompt(input)) process.exit(0);
-
-  const vendor = detectVendor(input);
-  const projectDir = getProjectDir(vendor, input);
-  const sessionId = getSessionId(input);
-  let prompt = (input.prompt as string) ?? "";
+/**
+ * Pure decision function — the single logic source for keyword detection.
+ *
+ * Called in-process by `oma hook` dispatch (Task 3+) and by the standalone
+ * `main()` entry below (pi subprocess path). Both paths share exactly this
+ * code; no business logic is duplicated.
+ *
+ * Returns a `context` HandlerResult when a workflow keyword matches, or
+ * `null` when no match / early-exit condition (no stdout side-effect here).
+ *
+ * NOTE: `ctx.cwd` is expected to be the resolved git-root project directory,
+ * as computed by `getProjectDir()` in the standalone path.
+ */
+export async function run(
+  input: HookInput,
+  ctx: HandlerCtx,
+): Promise<HandlerResult | null> {
+  if (input.kind !== "prompt") return null;
 
-  // agy's PreInvocation stdin carries no `prompt` — recover the user request
-  // from the transcript. PreInvocation fires before every model call, so only
-  // act on the first invocation of a turn (invocationNum) to avoid re-running
-  // keyword detection mid-turn.
-  if (vendor === "antigravity" && !prompt) {
-    const invocationNum = input.invocationNum;
-    if (typeof invocationNum === "number" && invocationNum > 1) process.exit(0);
-    prompt = readAgyPrompt(input.transcriptPath);
-  }
+  const { prompt } = input;
+  const { vendor, cwd: projectDir, sid: sessionId = "unknown" } = ctx;
 
-  if (!prompt.trim()) process.exit(0);
-  if (startsWithSlashCommand(prompt)) process.exit(0);
+  if (!prompt.trim()) return null;
+  if (startsWithSlashCommand(prompt)) return null;
 
   const config = loadConfig();
   const lang = detectLanguage(projectDir);
@@ -782,14 +787,12 @@ async function main() {
     deactivateAllPersistentModes(projectDir, sessionId);
     // Grok's resume context lives in a session-start file, not L1 stdout — clear it.
     if (vendor === "grok") clearGrokContext(projectDir);
-    process.exit(0);
+    return null;
   }
+
   const infoPatterns = buildInformationalPatterns(config, lang);
   // Guard 2: Strip code blocks, inline code, and pasted system-echo blocks
-  // before scanning for keywords. System echo stripping prevents oma's own
-  // hook outputs (when pasted back into the prompt) from re-triggering.
-  // NFKC normalization collapses fullwidth Latin from CJK IMEs onto ASCII
-  // so keyword regexes cannot be silently bypassed by ｐａｒａｌｌｅｌ-style input.
+  // before scanning for keywords. NFKC normalization collapses fullwidth Latin.
   const cleaned = normalizeForMatching(
     stripSystemEchoes(stripCodeBlocks(prompt)),
   );
@@ -803,18 +806,11 @@ async function main() {
 
   for (const [workflow, def] of Object.entries(config.workflows)) {
     if (excluded.has(workflow)) continue;
-
-    // Global CLI-invocation guard: prompts that start with a CLI invocation
-    // of `oma` or a `VENDORS` entry are tool invocations, not natural-language
-    // workflow requests. Skip silently to avoid false-positive matches.
     if (shouldSkipAllWorkflows(cleaned)) continue;
 
-    // Per-workflow override: if a predicate is registered for this specific
-    // workflow, evaluate it and skip just this workflow when it returns true.
     const workflowPredicate = KEYWORD_SKIP_PREDICATES[workflow];
     if (workflowPredicate?.(cleaned)) continue;
 
-    // Analytical questions should never trigger persistent workflows
     if (analytical && def.persistent) continue;
 
     const patterns = [
@@ -826,18 +822,14 @@ async function main() {
       const match = pattern.exec(cleaned);
       if (!match) continue;
       if (isInformationalContext(cleaned, match.index, infoPatterns)) continue;
-      // Keywords deep in long prompts are likely pasted content, not user intent
       if (isPastedContent(match.index, def.persistent, cleaned.length))
         continue;
-
-      // Guard 3: Suppress if same workflow triggered too many times in 60s
       if (isReinforcementSuppressed(kwState, workflow)) continue;
 
       if (def.persistent) {
         activateMode(projectDir, workflow, sessionId);
       }
       await activateL1WorkflowSession(projectDir, workflow, vendor, sessionId);
-      // Record this trigger for reinforcement tracking
       const updatedState = recordKwTrigger(kwState, workflow);
       saveKwState(projectDir, updatedState);
 
@@ -860,13 +852,50 @@ async function main() {
         }
       }
 
-      const context = contextLines.join("\n");
-
-      process.stdout.write(makePromptOutput(vendor, context));
-      process.exit(0);
+      return { type: "context", additionalContext: contextLines.join("\n") };
     }
   }
 
+  return null;
+}
+
+// ── Standalone entry (pi subprocess / direct bun invocation) ──
+
+async function main() {
+  const raw = readFileSync(0, "utf-8");
+  let input: Record<string, unknown>;
+  try {
+    input = JSON.parse(raw);
+  } catch {
+    process.exit(0);
+  }
+
+  // Guard 1: Only process genuine user prompts — skip agent-generated content
+  if (!isGenuineUserPrompt(input)) process.exit(0);
+
+  const vendor = detectVendor(input);
+  const projectDir = getProjectDir(vendor, input);
+  const sessionId = getSessionId(input);
+  let prompt = (input.prompt as string) ?? "";
+
+  // agy's PreInvocation stdin carries no `prompt` — recover the user request
+  // from the transcript. PreInvocation fires before every model call, so only
+  // act on the first invocation of a turn (invocationNum) to avoid re-running
+  // keyword detection mid-turn.
+  if (vendor === "antigravity" && !prompt) {
+    const invocationNum = input.invocationNum;
+    if (typeof invocationNum === "number" && invocationNum > 1) process.exit(0);
+    prompt = readAgyPrompt(input.transcriptPath);
+  }
+
+  // Build canonical inputs and delegate to run() — single logic source.
+  const hookInput: HookInput = { kind: "prompt", prompt, cwd: projectDir };
+  const ctx: HandlerCtx = { vendor, cwd: projectDir, sid: sessionId };
+
+  const result = await run(hookInput, ctx);
+  if (result && result.type === "context") {
+    process.stdout.write(makePromptOutput(vendor, result.additionalContext));
+  }
   process.exit(0);
 }