diff --git a/.agents/hooks/core/agentmemory-client.ts b/.agents/hooks/core/agentmemory-client.ts
index f81ecb0..50962bd 100644
--- a/.agents/hooks/core/agentmemory-client.ts
+++ b/.agents/hooks/core/agentmemory-client.ts
@@ -6,10 +6,6 @@ import https from "node:https";
 import { homedir } from "node:os";
 import { basename, join } from "node:path";
 
-// AgentMemory's published version line moved from 0.11/0.12 (original design
-// target) to 0.9.x service builds; accept 0.9.x and the 0.1x.x range.
-const SUPPORTED = /^0\.(9|1\d)\./;
-
 function endpointUrl(): string | null {
   if (process.env.OMA_NO_AGENTMEMORY === "1") return null;
   if (process.env.AGENTMEMORY_URL) return process.env.AGENTMEMORY_URL;
@@ -106,36 +102,12 @@ export async function isAgentMemoryReachable(): Promise<boolean> {
 
   try {
     const response = await requestAgentMemory(url, "/agentmemory/health");
-    if (response.statusCode < 200 || response.statusCode >= 300) {
-      reachable = false;
-      return reachable;
-    }
-    const headerVersion = response.headers["x-agentmemory-version"];
-    const version = Array.isArray(headerVersion)
-      ? headerVersion[0]
-      : headerVersion;
-    // Recent AgentMemory releases expose the version only in the health body,
-    // not the `x-agentmemory-version` header.
-    let isAgentMemory = false;
-    let bodyVersion: string | undefined;
-    try {
-      const parsed = JSON.parse(response.body) as {
-        service?: unknown;
-        status?: unknown;
-        version?: unknown;
-      };
-      isAgentMemory =
-        parsed.service === "agentmemory" ||
-        parsed.status === "healthy" ||
-        parsed.status === "ok";
-      if (typeof parsed.version === "string") bodyVersion = parsed.version;
-    } catch {
-      // Non-JSON body — fall back to the header check below.
-    }
-    const resolvedVersion = version ?? bodyVersion;
-    reachable =
-      isAgentMemory ||
-      (resolvedVersion !== undefined && SUPPORTED.test(resolvedVersion));
+    // Capability-based acceptance: any 2xx health response from the
+    // explicitly configured endpoint counts as reachable. Version pinning
+    // proved brittle (the published line already jumped from 0.11/0.12
+    // design targets to 0.9.x service builds), so payload shape and version
+    // are no longer gating.
+    reachable = response.statusCode >= 200 && response.statusCode < 300;
     return reachable;
   } catch {
     reachable = false;
diff --git a/.agents/hooks/core/hook-output.ts b/.agents/hooks/core/hook-output.ts
index 5fd76dc..306fecd 100644
--- a/.agents/hooks/core/hook-output.ts
+++ b/.agents/hooks/core/hook-output.ts
@@ -8,6 +8,11 @@ import type { Vendor } from "./types.ts";
 export function makePromptOutput(
   vendor: Vendor,
   additionalContext: string,
+  // Native hook event the context is injected for. Defaults to the prompt-submit
+  // event; the dispatch layer passes "SessionStart" for session-start injection
+  // (commandcode / cursor sessionStart) so the emitted hookSpecificOutput names
+  // the correct event. Standalone core-script callers use the default.
+  hookEventName: string = "UserPromptSubmit",
 ): string {
   switch (vendor) {
     case "antigravity":
@@ -19,33 +24,43 @@ export function makePromptOutput(
         injectSteps: [{ ephemeralMessage: additionalContext }],
       });
     case "claude":
-    case "commandcode":
+    case "commandcode": {
       // Official Claude Code docs (code.claude.com/docs/en/hooks) specify
       // `hookSpecificOutput.additionalContext` — the top-level field is kept
       // for back-compat with older builds that read it.
       // commandcode (Command Code, commandcode.ai) mirrors the Claude hook
-      // dialect, but has NO prompt event (only PreToolUse/PostToolUse/Stop),
-      // so this branch never fires for it — kept for Vendor exhaustiveness.
-      return JSON.stringify({
+      // dialect. It has no prompt-submit event, but DOES inject context on
+      // SessionStart (additionalContext) — dispatch passes hookEventName
+      // "SessionStart" for that path.
+      const hookSpecificOutput: Record<string, unknown> = {
+        hookEventName,
         additionalContext,
-        hookSpecificOutput: {
-          hookEventName: "UserPromptSubmit",
-          additionalContext,
-        },
-      });
+      };
+      // Claude Code re-scans skill/command directories after SessionStart hooks
+      // complete when the output sets `reloadSkills` (docs: SessionStart
+      // hookSpecificOutput.reloadSkills). It is Claude-only and only meaningful
+      // for SessionStart; this builder is called solely when context was
+      // actually injected, so the "only when injecting" condition is inherent.
+      if (vendor === "claude" && hookEventName === "SessionStart") {
+        hookSpecificOutput.reloadSkills = true;
+      }
+      return JSON.stringify({ additionalContext, hookSpecificOutput });
+    }
     case "codex":
       return JSON.stringify({
         hookSpecificOutput: {
-          hookEventName: "UserPromptSubmit",
+          hookEventName,
           additionalContext,
         },
       });
     case "cursor":
+      // Cursor reads the top-level `additional_context` (sessionStart) /
+      // `additionalContext`; the hookSpecificOutput block is informational.
       return JSON.stringify({
         additionalContext,
         additional_context: additionalContext,
         hookSpecificOutput: {
-          hookEventName: "UserPromptSubmit",
+          hookEventName,
           additionalContext,
         },
       });
@@ -70,7 +85,7 @@ export function makePromptOutput(
       // Qwen Code fork uses hookSpecificOutput (same as Codex)
       return JSON.stringify({
         hookSpecificOutput: {
-          hookEventName: "UserPromptSubmit",
+          hookEventName,
           additionalContext,
         },
       });
@@ -82,18 +97,27 @@ export function makeBlockOutput(vendor: Vendor, reason: string): string {
     case "claude":
     case "codex":
     case "commandcode":
-    case "cursor":
     case "kiro":
     case "qwen":
       return JSON.stringify({ decision: "block", reason });
+    case "cursor":
+      // Cursor's `stop` hook ignores Claude-style `{decision:"block"}`. It
+      // re-enters the loop via `{followup_message}`, which is auto-submitted as
+      // the next turn (capped by the entry's loop_limit). Cursor's only
+      // block-producing chain is `stop` — its sole preToolUse handler
+      // (test-filter) never blocks, only mutates — so followup_message is
+      // always the correct dialect here.
+      return JSON.stringify({ followup_message: reason });
     case "antigravity":
       // agy Stop: `decision:"continue"` re-enters the loop (= block the stop);
       // `reason` is injected as a system message. (Any other value allows stop.)
       return JSON.stringify({ decision: "continue", reason });
     case "pi":
-      // pi has no stop-blocking event (agent_end is notification-only), so
-      // persistent-mode never runs under pi. This shape mirrors pi's native
-      // tool_call block return for completeness/forward-compat.
+      // pi's bridge implements persistent-mode via agent_settled +
+      // pi.sendUserMessage: it runs the persistent-mode subprocess (which
+      // resolves to the Claude dialect `{decision:"block", reason}`) and also
+      // accepts this `{block:true, reason}` shape, re-submitting `reason` as the
+      // next turn so the workflow continues.
       return JSON.stringify({ block: true, reason });
     case "grok":
       // Grok Stop hooks are generally advisory. Emit block decision + rich
diff --git a/.agents/hooks/core/keyword-detector.ts b/.agents/hooks/core/keyword-detector.ts
index 223fcb1..e336814 100644
--- a/.agents/hooks/core/keyword-detector.ts
+++ b/.agents/hooks/core/keyword-detector.ts
@@ -25,6 +25,7 @@ import { agyConversationId, isAgyInput, readAgyPrompt } from "./agy-input.ts";
 import { UNKNOWN_SESSION_ID, VENDORS } from "./constants.ts";
 import { clearGrokContext } from "./grok-context.ts";
 import { makePromptOutput } from "./hook-output.ts";
+import { isRelayedAgentMessage, normalizePromptInput } from "./prompt-input.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).
@@ -154,6 +155,11 @@ export function isGenuineUserPrompt(input: Record<string, unknown>): boolean {
   return true;
 }
 
+// ── Guard: relayed inter-agent messages ──────────────────────
+// Shared with skill-injector — see prompt-input.ts. Re-exported here so
+// existing imports/tests keep resolving from this module.
+export { isRelayedAgentMessage };
+
 // ── Guard 3: Reinforcement suppression ───────────────────────
 
 const REINFORCEMENT_WINDOW_MS = 60_000; // 60 seconds
@@ -349,24 +355,84 @@ export function escapeRegex(s: string): string {
   return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
 
+/**
+ * Merge a language-keyed keyword/pattern bank into a single flat list:
+ * universal ("*") + English (the universal default) + the configured
+ * language's own entries (skipped when lang === "en" to avoid duplicates).
+ * Shared by buildPatterns and buildRawPatterns — both keyword banks and
+ * pattern banks use this exact `Record<string, string[]>` shape.
+ */
+export function collectLangEntries(
+  bank: Record<string, string[]>,
+  lang: string,
+): string[] {
+  return [
+    ...(bank["*"] ?? []),
+    ...(bank.en ?? []),
+    ...(lang !== "en" ? (bank[lang] ?? []) : []),
+  ];
+}
+
+/**
+ * Keyword-plus-compiled-regex pair. Kept 1:1 with the literal keyword string
+ * (as authored in triggers.json) so callers that need the ACTUAL matched
+ * keyword text — e.g. specificity ranking — don't have to re-derive it from
+ * match[0], which would require re-deriving buildPatterns' word-boundary
+ * peeling logic (fragile, and wrong for CJK where no boundary is added).
+ */
+export interface KeywordPatternEntry {
+  regex: RegExp;
+  keyword: string;
+}
+
+export function buildPatternEntries(
+  keywords: Record<string, string[]>,
+  lang: string,
+  cjkScripts: string[],
+): KeywordPatternEntry[] {
+  return collectLangEntries(keywords, lang).map((kw) => {
+    const escaped = escapeRegex(kw).replace(/\s+/g, "\\s+");
+    const regex =
+      cjkScripts.includes(lang) || /[^\p{ASCII}]/u.test(kw)
+        ? new RegExp(escaped, "i")
+        : new RegExp(`(?:^|[^\\w-])${escaped}(?:$|[^\\w-])`, "i");
+    return { regex, keyword: kw };
+  });
+}
+
 export function buildPatterns(
   keywords: Record<string, string[]>,
   lang: string,
   cjkScripts: string[],
 ): RegExp[] {
-  const allKeywords = [
-    ...(keywords["*"] ?? []),
-    ...(keywords.en ?? []),
-    ...(lang !== "en" ? (keywords[lang] ?? []) : []),
-  ];
+  return buildPatternEntries(keywords, lang, cjkScripts).map((e) => e.regex);
+}
 
-  return allKeywords.map((kw) => {
-    const escaped = escapeRegex(kw).replace(/\s+/g, "\\s+");
-    if (cjkScripts.includes(lang) || /[^\p{ASCII}]/u.test(kw)) {
-      return new RegExp(escaped, "i");
+/**
+ * Raw-pattern-plus-source pair — mirrors KeywordPatternEntry for the
+ * `patterns` (intent regex) field. `source` is the raw regex string itself:
+ * unlike keyword entries, a raw pattern has no fixed "keyword" — its
+ * specificity is however much text it actually matched (match[0]).
+ */
+export interface RawPatternEntry {
+  regex: RegExp;
+  source: string;
+}
+
+export function buildRawPatternEntries(
+  patterns: Record<string, string[]> | undefined,
+  lang: string,
+): RawPatternEntry[] {
+  if (!patterns) return [];
+  const compiled: RawPatternEntry[] = [];
+  for (const raw of collectLangEntries(patterns, lang)) {
+    try {
+      compiled.push({ regex: new RegExp(raw, "iu"), source: raw });
+    } catch {
+      // Skip invalid regex — surfaces during config edit, not at runtime
     }
-    return new RegExp(`(?:^|[^\\w-])${escaped}(?:$|[^\\w-])`, "i");
-  });
+  }
+  return compiled;
 }
 
 /**
@@ -379,21 +445,7 @@ export function buildRawPatterns(
   patterns: Record<string, string[]> | undefined,
   lang: string,
 ): RegExp[] {
-  if (!patterns) return [];
-  const all = [
-    ...(patterns["*"] ?? []),
-    ...(patterns.en ?? []),
-    ...(lang !== "en" ? (patterns[lang] ?? []) : []),
-  ];
-  const compiled: RegExp[] = [];
-  for (const raw of all) {
-    try {
-      compiled.push(new RegExp(raw, "iu"));
-    } catch {
-      // Skip invalid regex — surfaces during config edit, not at runtime
-    }
-  }
-  return compiled;
+  return buildRawPatternEntries(patterns, lang).map((e) => e.regex);
 }
 
 export function buildInformationalPatterns(config: TriggerConfig): RegExp[] {
@@ -752,6 +804,93 @@ export function deactivateAllPersistentModes(
   }
 }
 
+// ── Specificity ranking ───────────────────────────────────────
+
+/**
+ * One surviving pattern match for one workflow, carrying everything the
+ * ranking rules in `pickWinningCandidate` need. Built once per successful
+ * `pattern.exec()` across ALL workflows in `config.workflows` — the matching
+ * loop no longer returns on the first hit; it collects every candidate
+ * first and lets specificity decide the winner.
+ */
+export interface WorkflowCandidate {
+  workflow: string;
+  persistent: boolean;
+  /** Index of the match within the cleaned (stripped/normalized) text. */
+  matchIndex: number;
+  matchText: string;
+  /** Position re-located in the ORIGINAL prompt — used for tie-break #3. */
+  origIndex: number;
+  /** Length of the specific text that matched (trimmed keyword or, for a
+   * `patterns` intent-regex hit, the trimmed match[0] span) — rule #1. */
+  keywordLength: number;
+  /** Whether the specificity text contains whitespace — rule #2. */
+  isMultiWord: boolean;
+  /** Index of this workflow in triggers.json `workflows` — rule #4 (final
+   * tiebreak, preserves the pre-ranking first-declared-wins behavior). */
+  declarationIndex: number;
+  /** True if any suppression filter (RC3 technical-reference is a hard drop
+   * and never reaches this point; informational-context / pasted-content /
+   * reinforcement) applies to this specific match. */
+  suppressed: boolean;
+}
+
+/**
+ * Pick the winning candidate among all workflow matches collected for a
+ * prompt, or `null` if none survive.
+ *
+ * Ranking order (only consulted on a tie with the previous rule):
+ *   1. Longest matched keyword/phrase wins — "deepsec pr review" (18 chars)
+ *      beats "review" (6 chars) even though "review" also literally matches
+ *      as a substring of the same sentence.
+ *   2. A multi-word/compound match beats a single-word match of equal
+ *      length (defensive tiebreak; rule 1 already separates most real
+ *      cases since compound phrases are almost always longer).
+ *   3. Earliest match position in the ORIGINAL prompt wins — mirrors the
+ *      existing "keyword near the front = command position" heuristic used
+ *      elsewhere in this file (RC2 pasted-content guard).
+ *   4. Final tiebreak: declaration order in triggers.json `workflows` —
+ *      i.e. the original pre-ranking first-match-wins behavior, kept only
+ *      as a last resort when two workflows are otherwise indistinguishable.
+ *
+ * DESIGN DECISION (round-1 trigger demotion, part A): suppression is
+ * evaluated PER CANDIDATE, not globally. A candidate flagged `suppressed`
+ * (by the informational-context window, the persistent-mode pasted-content
+ * limit, or reinforcement) is simply removed from the ranking pool — it
+ * does NOT veto a *different*, unsuppressed candidate from a more generic
+ * workflow. Reasoning: every existing suppression filter in this file
+ * already operates locally, on one match at a time (a suppressed hit in one
+ * workflow's pattern loop has always fallen through to the next
+ * pattern/workflow, never blocking unrelated matches elsewhere in the same
+ * prompt) — ranking preserves that locality instead of upgrading it into a
+ * prompt-wide veto. The alternative (any suppressed specific match blocks
+ * the whole prompt from firing anything) would silence genuine, independent
+ * requests that merely share a sentence with a meta-mention of a more
+ * specific workflow. See triggers-corpus.json for a case that locks this in:
+ * a prompt that asks an informational "what is X" question about a specific
+ * workflow AND, separately, makes a genuine generic request — the generic
+ * request still fires.
+ */
+export function pickWinningCandidate(
+  candidates: WorkflowCandidate[],
+): WorkflowCandidate | null {
+  const eligible = candidates.filter((c) => !c.suppressed);
+  if (eligible.length === 0) return null;
+  eligible.sort((a, b) => {
+    if (b.keywordLength !== a.keywordLength) {
+      return b.keywordLength - a.keywordLength;
+    }
+    if (a.isMultiWord !== b.isMultiWord) {
+      return a.isMultiWord ? -1 : 1;
+    }
+    if (a.origIndex !== b.origIndex) {
+      return a.origIndex - b.origIndex;
+    }
+    return a.declarationIndex - b.declarationIndex;
+  });
+  return eligible[0] ?? null;
+}
+
 // ── Pure handler (canonical ABI) ─────────────────────────────
 
 /**
@@ -778,6 +917,9 @@ export async function run(
 
   if (!prompt.trim()) return null;
   if (startsWithSlashCommand(prompt)) return null;
+  // Relayed inter-agent messages carry another agent's text, not a user
+  // request — their content must not drive workflow keyword detection.
+  if (isRelayedAgentMessage(prompt)) return null;
 
   const config = loadConfig();
   const lang = detectLanguage(projectDir);
@@ -804,73 +946,125 @@ export async function run(
   // Skip persistent workflows entirely if the prompt is an analytical question
   const analytical = isAnalyticalQuestion(cleaned);
 
-  for (const [workflow, def] of Object.entries(config.workflows)) {
+  // shouldSkipAllWorkflows does not depend on the workflow being evaluated —
+  // hoisted out of the loop (was re-checked on every iteration pre-ranking).
+  if (shouldSkipAllWorkflows(cleaned)) return null;
+
+  // Position guard must reflect the user's ACTUAL prompt, not the
+  // content-stripped text. stripCodeBlocks/stripSystemEchoes remove quoted
+  // and code spans, which shrinks the text and pulls keywords toward the
+  // front — defeating the "deep in a long prompt = not an instruction"
+  // heuristic (a keyword genuinely at char 245 of a discussion can appear
+  // at char 179 after stripping, slipping under PERSISTENT_MATCH_LIMIT).
+  const origPrompt = normalizeForMatching(prompt);
+
+  // Collect every surviving match across every workflow first — specificity
+  // ranking (see pickWinningCandidate) decides the winner, replacing the old
+  // declaration-order first-match-wins loop.
+  const candidates: WorkflowCandidate[] = [];
+  const workflowEntries = Object.entries(config.workflows);
+
+  for (
+    let declarationIndex = 0;
+    declarationIndex < workflowEntries.length;
+    declarationIndex++
+  ) {
+    const entry = workflowEntries[declarationIndex];
+    if (!entry) continue;
+    const [workflow, def] = entry;
     if (excluded.has(workflow)) continue;
-    if (shouldSkipAllWorkflows(cleaned)) continue;
 
     const workflowPredicate = KEYWORD_SKIP_PREDICATES[workflow];
     if (workflowPredicate?.(cleaned)) continue;
 
     if (analytical && def.persistent) continue;
 
-    const patterns = [
-      ...buildPatterns(def.keywords, lang, config.cjkScripts),
-      ...buildRawPatterns(def.patterns, lang),
-    ];
+    const reinforced = isReinforcementSuppressed(kwState, workflow);
 
-    for (const pattern of patterns) {
-      const match = pattern.exec(cleaned);
-      if (!match) continue;
+    const considerMatch = (regex: RegExp, specificityText: string) => {
+      const match = regex.exec(cleaned);
+      if (!match) return;
       // RC3: compound technical tokens (ralph:verify, ralph.md,
       // workflows/ralph) reference the workflow as an artifact, not a run
-      // request.
-      if (isTechnicalReference(cleaned, match.index, match[0])) continue;
-      if (isInformationalContext(cleaned, match.index, infoPatterns)) continue;
-      // Position guard must reflect the user's ACTUAL prompt, not the
-      // content-stripped text. stripCodeBlocks/stripSystemEchoes remove quoted
-      // and code spans, which shrinks the text and pulls keywords toward the
-      // front — defeating the "deep in a long prompt = not an instruction"
-      // heuristic (a keyword genuinely at char 245 of a discussion can appear
-      // at char 179 after stripping, slipping under PERSISTENT_MATCH_LIMIT).
-      // Re-locate the matched keyword in the original prompt for the check.
-      const origPrompt = normalizeForMatching(prompt);
+      // request — dropped entirely, never becomes a candidate.
+      if (isTechnicalReference(cleaned, match.index, match[0])) return;
+
+      // Re-locate the matched keyword in the original prompt for the
+      // pasted-content position guard.
       const origIndex = origPrompt.indexOf(match[0]);
       const posIndex = origIndex >= 0 ? origIndex : match.index;
-      if (isPastedContent(posIndex, def.persistent, origPrompt.length))
-        continue;
-      if (isReinforcementSuppressed(kwState, workflow)) continue;
+      const informational = isInformationalContext(
+        cleaned,
+        match.index,
+        infoPatterns,
+      );
+      const pasted = isPastedContent(
+        posIndex,
+        def.persistent,
+        origPrompt.length,
+      );
+      const text = specificityText.trim();
+
+      candidates.push({
+        workflow,
+        persistent: def.persistent,
+        matchIndex: match.index,
+        matchText: match[0],
+        origIndex: posIndex,
+        keywordLength: text.length,
+        isMultiWord: /\s/.test(text),
+        declarationIndex,
+        suppressed: informational || pasted || reinforced,
+      });
+    };
+
+    for (const { regex, keyword } of buildPatternEntries(
+      def.keywords,
+      lang,
+      config.cjkScripts,
+    )) {
+      considerMatch(regex, keyword);
+    }
+    for (const { regex, source } of buildRawPatternEntries(
+      def.patterns,
+      lang,
+    )) {
+      considerMatch(regex, source);
+    }
+  }
 
-      if (def.persistent) {
-        activateMode(projectDir, workflow, sessionId);
-      }
-      await activateL1WorkflowSession(projectDir, workflow, vendor, sessionId);
-      const updatedState = recordKwTrigger(kwState, workflow);
-      saveKwState(projectDir, updatedState);
-
-      const contextLines = [
-        `[OMA WORKFLOW: ${workflow.toUpperCase()}]`,
-        `User intent matches the /${workflow} workflow.`,
-        `Read and follow \`.agents/workflows/${workflow}.md\` step by step.`,
-        `User request: ${prompt}`,
-        `IMPORTANT: Start the workflow IMMEDIATELY. Do not ask for confirmation.`,
-      ];
-
-      if (config.extensionRouting) {
-        const extensions = detectExtensions(prompt);
-        const agent = resolveAgentFromExtensions(
-          extensions,
-          config.extensionRouting,
-        );
-        if (agent) {
-          contextLines.push(`[OMA AGENT HINT: ${agent}]`);
-        }
-      }
+  const winner = pickWinningCandidate(candidates);
+  if (!winner) return null;
+
+  const { workflow } = winner;
+
+  if (winner.persistent) {
+    activateMode(projectDir, workflow, sessionId);
+  }
+  await activateL1WorkflowSession(projectDir, workflow, vendor, sessionId);
+  const updatedState = recordKwTrigger(kwState, workflow);
+  saveKwState(projectDir, updatedState);
+
+  const contextLines = [
+    `[OMA WORKFLOW: ${workflow.toUpperCase()}]`,
+    `User intent matches the /${workflow} workflow.`,
+    `Read and follow \`.agents/workflows/${workflow}.md\` step by step.`,
+    `User request: ${prompt}`,
+    `IMPORTANT: Start the workflow IMMEDIATELY. Do not ask for confirmation.`,
+  ];
 
-      return { type: "context", additionalContext: contextLines.join("\n") };
+  if (config.extensionRouting) {
+    const extensions = detectExtensions(prompt);
+    const agent = resolveAgentFromExtensions(
+      extensions,
+      config.extensionRouting,
+    );
+    if (agent) {
+      contextLines.push(`[OMA AGENT HINT: ${agent}]`);
     }
   }
 
-  return null;
+  return { type: "context", additionalContext: contextLines.join("\n") };
 }
 
 // ── Standalone entry (pi subprocess / direct bun invocation) ──
@@ -890,7 +1084,7 @@ async function main() {
   const vendor = detectVendor(input);
   const projectDir = getProjectDir(vendor, input);
   const sessionId = getSessionId(input);
-  let prompt = (input.prompt as string) ?? "";
+  let prompt = normalizePromptInput(input.prompt);
 
   // agy's PreInvocation stdin carries no `prompt` — recover the user request
   // from the transcript. PreInvocation fires before every model call, so only
diff --git a/.agents/hooks/core/prompt-input.ts b/.agents/hooks/core/prompt-input.ts
new file mode 100644
index 0000000..7f18580
--- /dev/null
+++ b/.agents/hooks/core/prompt-input.ts
@@ -0,0 +1,45 @@
+// Shared normalizer for the raw `prompt` field delivered on hook stdin.
+//
+// Most host CLIs deliver `prompt` as a plain string, but some (e.g. Kimi Code
+// CLI's UserPromptSubmit payload) deliver it as a ContentPart[] array such as
+// `[{ "type": "text", "text": "hello" }]`. The standalone hook scripts cast it
+// with `(input.prompt as string) ?? ""`, so on those vendors the downstream
+// string methods throw and the top-level catch swallows the error — the entire
+// prompt chain silently no-ops. Route every raw read through this helper so the
+// array shape collapses to the equivalent string.
+
+// Relayed inter-agent messages (teammate reports, task notifications, idle
+// notifications) are transported through the prompt channel but are not user
+// intent: their content routinely carries workflow keywords and skill trigger
+// words, producing false activations. Detect the transport envelopes
+// conservatively so prompt-driven handlers can skip them.
+const RELAY_ENVELOPE_PREFIXES = [
+  "<agent-message",
+  "<teammate-message",
+  "<task-notification",
+];
+
+/** True when the prompt is a relayed inter-agent envelope, not user intent. */
+export function isRelayedAgentMessage(prompt: string): boolean {
+  const trimmed = prompt.trimStart();
+  if (RELAY_ENVELOPE_PREFIXES.some((p) => trimmed.startsWith(p))) return true;
+  return trimmed.slice(0, 200).includes('"type":"idle_notification"');
+}
+
+/** Coerce a raw stdin `prompt` field to a string across vendor payload shapes. */
+export function normalizePromptInput(prompt: unknown): string {
+  if (typeof prompt === "string") return prompt;
+  if (Array.isArray(prompt)) {
+    return prompt
+      .filter(
+        (p): p is { type: string; text: string } =>
+          !!p &&
+          typeof p === "object" &&
+          (p as { type?: unknown }).type === "text" &&
+          typeof (p as { text?: unknown }).text === "string",
+      )
+      .map((p) => p.text)
+      .join(" ");
+  }
+  return "";
+}
diff --git a/.agents/hooks/core/serena-primer.ts b/.agents/hooks/core/serena-primer.ts
index 6605ac2..df2aabc 100644
--- a/.agents/hooks/core/serena-primer.ts
+++ b/.agents/hooks/core/serena-primer.ts
@@ -25,6 +25,7 @@ import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { dirname, join } from "node:path";
 import { agyConversationId, isAgyInput, readAgyPrompt } from "./agy-input.ts";
 import { makePromptOutput } from "./hook-output.ts";
+import { normalizePromptInput } from "./prompt-input.ts";
 import type { HandlerCtx, HandlerResult, HookInput, Vendor } from "./types.ts";
 import { getProjectDir, inferVendorFromScriptPath } from "./vendor-detect.ts";
 
@@ -136,7 +137,10 @@ export async function run(
   const { cwd: projectDir, sid: sessionId = "unknown" } = ctx;
 
   if (!isSerenaProject(projectDir)) return null;
-  if (!claimSession(projectDir, sessionId)) return null;
+  // Compaction keeps the session id, so the session-once claim would skip
+  // exactly the turn that just lost the primer from context — force re-inject.
+  const forced = input.source === "compact";
+  if (!claimSession(projectDir, sessionId) && !forced) return null;
 
   return { type: "context", additionalContext: primerContext() };
 }
@@ -190,7 +194,7 @@ async function main() {
   const vendor = detectVendor(input);
   const projectDir = getProjectDir(vendor, input);
   const sessionId = getSessionId(input);
-  let prompt = (input.prompt as string) ?? "";
+  let prompt = normalizePromptInput(input.prompt);
 
   // agy's PreInvocation stdin carries no `prompt`; recover it and only act on
   // the first invocation of a turn.
diff --git a/.agents/hooks/core/skill-injector.ts b/.agents/hooks/core/skill-injector.ts
index 550fbd8..66c8139 100644
--- a/.agents/hooks/core/skill-injector.ts
+++ b/.agents/hooks/core/skill-injector.ts
@@ -24,6 +24,7 @@ import { basename, dirname, join } from "node:path";
 import { agyConversationId, isAgyInput, readAgyPrompt } from "./agy-input.ts";
 import { toPosixPath } from "./fs-utils.ts";
 import { makePromptOutput } from "./hook-output.ts";
+import { isRelayedAgentMessage, normalizePromptInput } from "./prompt-input.ts";
 // triggers.json is imported statically: bundler inlines it into the oma binary;
 // standalone bun runs resolve the sibling file (pi / direct run).
 import embeddedTriggers from "./triggers.json" with { type: "json" };
@@ -463,6 +464,11 @@ export async function run(
 
   if (!prompt.trim()) return null;
 
+  // Relayed inter-agent messages (teammate reports, idle notifications) are
+  // not user intent — their content routinely contains skill trigger words
+  // and produced false skill suggestions. Same guard as keyword-detector.
+  if (isRelayedAgentMessage(prompt)) return null;
+
   // Claude-specific: slash-skill resolution must run BEFORE the slash early-exit
   // and persistent-workflow guard (same order as the original standalone path).
   if (vendor === "claude") {
@@ -514,7 +520,7 @@ async function main() {
   const vendor = detectVendor(input);
   const projectDir = getProjectDir(vendor, input);
   const sessionId = getSessionId(input);
-  let prompt = (input.prompt as string) ?? "";
+  let prompt = normalizePromptInput(input.prompt);
 
   // agy's PreInvocation stdin carries no `prompt`; recover it from the
   // transcript, and only act on the first invocation of a turn.
diff --git a/.agents/hooks/core/state-boundary.ts b/.agents/hooks/core/state-boundary.ts
index 8700b10..ddc1bd0 100644
--- a/.agents/hooks/core/state-boundary.ts
+++ b/.agents/hooks/core/state-boundary.ts
@@ -6,6 +6,7 @@ import { agyConversationId, isAgyInput } from "./agy-input.ts";
 import { syncGrokContext } from "./grok-context.ts";
 import { makePromptOutput } from "./hook-output.ts";
 import { writeInjectLog } from "./inject-log.ts";
+import { normalizePromptInput } from "./prompt-input.ts";
 import { emitEvent, type OmaEvent, readEvents } from "./state-emit.ts";
 import { getActiveSid, readIndex, setLastSession } from "./state-marker.ts";
 import type { HandlerCtx, HandlerResult, HookInput, Vendor } from "./types.ts";
@@ -98,6 +99,7 @@ export async function onBoundary(
   vendor: Vendor,
   vendorSid: string,
   promptText?: string,
+  forced = false,
 ): Promise<string | null> {
   const idx = readIndex(projectDir);
   const previous = idx.lastSession;
@@ -105,7 +107,9 @@ export async function onBoundary(
     !previous || previous.vendor !== vendor || previous.vendorSid !== vendorSid;
   const statelessTurnFlush = vendor === "kiro" && vendorSid === "unknown";
 
-  if (!boundary && !statelessTurnFlush) {
+  // `forced` = post-compaction SessionStart: the session id is unchanged (no
+  // boundary), but the snapshot was just compacted out of context — re-emit.
+  if (!boundary && !statelessTurnFlush && !forced) {
     setLastSession(projectDir, vendor, vendorSid);
     return null;
   }
@@ -122,7 +126,9 @@ export async function onBoundary(
     vendorSid,
     payload: {
       reason: !boundary
-        ? "stateless-vendor-turn"
+        ? statelessTurnFlush
+          ? "stateless-vendor-turn"
+          : "post-compact-rehydration"
         : previous
           ? "vendor-session-transition"
           : "session-created",
@@ -189,12 +195,15 @@ export async function run(
 
   const { vendor, cwd: projectDir, sid: vendorSid = "unknown" } = ctx;
   // input.kind === "prompt" is guaranteed by the guard above; the user prompt is
-  // the primary recall signal for boundary rehydration.
+  // the primary recall signal for boundary rehydration. A post-compaction
+  // SessionStart (source === "compact") forces re-emission: the session id is
+  // unchanged, but the snapshot was just compacted out of the context window.
   const rendered = await onBoundary(
     projectDir,
     vendor,
     vendorSid,
     input.prompt,
+    input.source === "compact",
   );
   if (!rendered) return null;
   return { type: "context", additionalContext: rendered };
@@ -218,7 +227,7 @@ async function main() {
   // Delegate to run() — single logic source.
   const hookInput: HookInput = {
     kind: "prompt",
-    prompt: (input.prompt as string) ?? "",
+    prompt: normalizePromptInput(input.prompt),
     cwd: projectDir,
   };
   const ctxVal: HandlerCtx = { vendor, cwd: projectDir, sid: vendorSid };
diff --git a/.agents/hooks/core/test-filter.ts b/.agents/hooks/core/test-filter.ts
index f6ee917..3034ec1 100644
--- a/.agents/hooks/core/test-filter.ts
+++ b/.agents/hooks/core/test-filter.ts
@@ -103,8 +103,16 @@ export async function run(
   const { toolName, toolInput, cwd: projectDir } = input;
   const { vendor } = ctx;
 
-  // Claude-family uses Bash; some CLIs use run_shell_command.
-  if (toolName !== "Bash" && toolName !== "run_shell_command") return null;
+  // Claude-family uses Bash; some CLIs use run_shell_command; Cursor names its
+  // terminal tool "Shell" (matches cursor.json's preToolUse matcher); Kiro's
+  // canonical shell tool is execute_bash (the agent-JSON matcher name).
+  if (
+    toolName !== "Bash" &&
+    toolName !== "run_shell_command" &&
+    toolName !== "Shell" &&
+    toolName !== "execute_bash"
+  )
+    return null;
 
   const command = toolInput.command as string | undefined;
   if (!command) return null;
@@ -115,12 +123,18 @@ export async function run(
   const isExcluded = EXCLUDE_PATTERNS.some((p) => p.test(command));
   if (isExcluded) return null;
 
-  const filterScript = join(
-    projectDir,
+  // Resolve the filter script: vendor hook dir first, then the opencode
+  // bridge dir (opencode has no core Vendor identity — its subprocess payload
+  // detects as claude, whose hook dir is absent in opencode-only installs),
+  // then the SSOT core dir as the last resort.
+  const filterScript = [
     getHookDir(vendor),
-    "filter-test-output.sh",
-  );
-  if (!existsSync(filterScript)) return null;
+    join(".opencode", "plugins", "oma"),
+    join(".agents", "hooks", "core"),
+  ]
+    .map((dir) => join(projectDir, dir, "filter-test-output.sh"))
+    .find((p) => existsSync(p));
+  if (!filterScript) return null;
 
   const filteredCmd = `set -o pipefail; (${command}) 2>&1 | bash "${filterScript}"`;
   const updatedInput: Record<string, unknown> = {
diff --git a/.agents/hooks/core/triggers.json b/.agents/hooks/core/triggers.json
index 73c6a59..6e0874d 100644
--- a/.agents/hooks/core/triggers.json
+++ b/.agents/hooks/core/triggers.json
@@ -3116,7 +3116,6 @@
       "should you",
       "could we",
       "would you",
-      "what if",
       "what about",
       "why build",
       "why create",
@@ -3127,7 +3126,10 @@
       "뭐야",
       "뭐임",
       "무엇",
-      "어떻게",
+      "어떻게 동작",
+      "어떻게 작동",
+      "어떻게 되는지",
+      "어떻게 하는지",
       "설명해",
       "알려줘",
       "키워드",
@@ -3143,13 +3145,12 @@
       "왜 만들",
       "어떻게 만들",
       "어떨까",
-      "하면 좋을",
+      "하면 좋을지",
       "한다면",
       "할까요",
       "보강할",
       "에 대해",
       "에 대한",
-      "한번 봐",
       "깊게 봐",
       "코드를 한번",
       "그 워크플로우",
diff --git a/.agents/hooks/core/types.ts b/.agents/hooks/core/types.ts
index 5ae6a74..a58ffda 100644
--- a/.agents/hooks/core/types.ts
+++ b/.agents/hooks/core/types.ts
@@ -54,7 +54,18 @@ export interface ModeState {
  * Discriminated on `kind`; produced by adapters.ts normalizeInput().
  */
 export type HookInput =
-  | { kind: "prompt"; prompt: string; cwd: string }
+  | {
+      kind: "prompt";
+      prompt: string;
+      cwd: string;
+      /**
+       * SessionStart trigger source (claude: startup|resume|clear|compact).
+       * `compact` lets session-once handlers (serena-primer, state-boundary)
+       * force re-injection: compaction keeps the session id, so their normal
+       * dedup would otherwise skip exactly the turn that lost the context.
+       */
+      source?: string;
+    }
   | {
       kind: "pre_tool";
       toolName: string;
diff --git a/.agents/hooks/variants/antigravity.json b/.agents/hooks/variants/antigravity.json
index 0c9f5d6..f233148 100644
--- a/.agents/hooks/variants/antigravity.json
+++ b/.agents/hooks/variants/antigravity.json
@@ -25,11 +25,6 @@
         "timeout": 3
       }
     ],
-    "PreToolUse": {
-      "hook": "test-filter.ts",
-      "matcher": "run_command",
-      "timeout": 5
-    },
     "Stop": {
       "hook": "persistent-mode.ts",
       "timeout": 5
diff --git a/.agents/hooks/variants/claude.json b/.agents/hooks/variants/claude.json
index b9a8a41..e319b13 100644
--- a/.agents/hooks/variants/claude.json
+++ b/.agents/hooks/variants/claude.json
@@ -6,6 +6,16 @@
   "projectDirEnv": "CLAUDE_PROJECT_DIR",
   "runtime": "bun",
   "events": {
+    "SessionStart": [
+      {
+        "hook": "serena-primer.ts",
+        "timeout": 3
+      },
+      {
+        "hook": "state-boundary.ts",
+        "timeout": 5
+      }
+    ],
     "UserPromptSubmit": [
       {
         "hook": "keyword-detector.ts",
diff --git a/.agents/hooks/variants/codex.json b/.agents/hooks/variants/codex.json
index 0609cab..4000cb5 100644
--- a/.agents/hooks/variants/codex.json
+++ b/.agents/hooks/variants/codex.json
@@ -33,12 +33,5 @@
       "hook": "persistent-mode.ts",
       "timeout": 5
     }
-  },
-  "featureFlags": {
-    "file": ".codex/config.toml",
-    "section": "features",
-    "flags": {
-      "hooks": true
-    }
   }
 }
diff --git a/.agents/hooks/variants/commandcode.json b/.agents/hooks/variants/commandcode.json
index 150f1ef..67b1819 100644
--- a/.agents/hooks/variants/commandcode.json
+++ b/.agents/hooks/variants/commandcode.json
@@ -6,6 +6,16 @@
   "projectDirEnv": null,
   "runtime": "bun",
   "events": {
+    "SessionStart": [
+      {
+        "hook": "serena-primer.ts",
+        "timeout": 3
+      },
+      {
+        "hook": "state-boundary.ts",
+        "timeout": 5
+      }
+    ],
     "Stop": {
       "hook": "persistent-mode.ts",
       "timeout": 5
diff --git a/.agents/hooks/variants/cursor.json b/.agents/hooks/variants/cursor.json
index 8feb024..390ff7b 100644
--- a/.agents/hooks/variants/cursor.json
+++ b/.agents/hooks/variants/cursor.json
@@ -24,6 +24,26 @@
         "hook": "serena-primer.ts",
         "timeout": 3
       }
+    ],
+    "preToolUse": {
+      "hook": "test-filter.ts",
+      "matcher": "Shell",
+      "timeout": 5
+    },
+    "stop": {
+      "hook": "persistent-mode.ts",
+      "timeout": 5,
+      "loopLimit": null
+    },
+    "sessionStart": [
+      {
+        "hook": "serena-primer.ts",
+        "timeout": 3
+      },
+      {
+        "hook": "state-boundary.ts",
+        "timeout": 5
+      }
     ]
   },
   "extra": {
diff --git a/.agents/hooks/variants/grok.json b/.agents/hooks/variants/grok.json
index a0ee2bf..8b19400 100644
--- a/.agents/hooks/variants/grok.json
+++ b/.agents/hooks/variants/grok.json
@@ -26,7 +26,7 @@
     ],
     "PreToolUse": {
       "hook": "test-filter.ts",
-      "matcher": "run_terminal_cmd",
+      "matcher": "Bash",
       "timeout": 5
     },
     "Stop": {
diff --git a/.agents/hooks/variants/hook-variant.schema.json b/.agents/hooks/variants/hook-variant.schema.json
index 4387c98..4ac2056 100644
--- a/.agents/hooks/variants/hook-variant.schema.json
+++ b/.agents/hooks/variants/hook-variant.schema.json
@@ -86,6 +86,11 @@
     "flatHookEntries": {
       "type": "boolean",
       "description": "When true, settings hook entries are written as flat {command, timeout[, matcher]} objects under each event key (Cursor hooks.json format) instead of nested {matcher, hooks:[...]} groups (Claude Code format)."
+    },
+    "skipSettingsMerge": {
+      "type": "boolean",
+      "description": "When true, the generic installer copies hook scripts and writes the oma-hook.sh wrapper but does NOT merge hook entries into settingsFile. Used by Kiro, whose CLI reads hooks from a dedicated agent config (.kiro/agents/oma-hooks.json via applyKiroOmaHooksAgent) — the generic .kiro/settings/cli.json merge would be dead config Kiro never reads. `extra` (statusLine/permissions) is still applied when present.",
+      "default": false
     }
   },
   "$defs": {
@@ -109,6 +114,10 @@
           "minimum": 1,
           "maximum": 30,
           "default": 5
+        },
+        "loopLimit": {
+          "type": ["integer", "null"],
+          "description": "Cursor `stop` hook only: caps how many times the hook may auto-resubmit a followup_message (Cursor's loop_limit). null = uncapped; omit for Cursor's default (5). Ignored by other vendors."
         }
       }
     },
diff --git a/.agents/hooks/variants/kiro.json b/.agents/hooks/variants/kiro.json
index 8a01e24..4b659d1 100644
--- a/.agents/hooks/variants/kiro.json
+++ b/.agents/hooks/variants/kiro.json
@@ -5,6 +5,7 @@
   "settingsFile": ".kiro/settings/cli.json",
   "projectDirEnv": null,
   "runtime": "bun",
+  "skipSettingsMerge": true,
   "events": {
     "userPromptSubmit": [
       {
diff --git a/.agents/hooks/variants/opencode/oma.ts b/.agents/hooks/variants/opencode/oma.ts
index 2e0e5c6..51060a5 100644
--- a/.agents/hooks/variants/opencode/oma.ts
+++ b/.agents/hooks/variants/opencode/oma.ts
@@ -2,34 +2,55 @@
  * oh-my-agent — opencode (Sst opencode) plugin bridge.
  *
  * SSOT source. At install time `installOpencodePlugin` copies this file to
- * `.opencode/plugins/oma/oma.ts` alongside the core hook scripts. opencode
- * auto-discovers plugins under each `.opencode/plugins` subdirectory.
+ * `.opencode/plugins/oma/oma.ts` alongside the core hook scripts, and
+ * `registerOpencodePlugin` adds it to `.opencode/opencode.jsonc` (the nested
+ * subdir is invisible to opencode's flat auto-discovery).
  *
  * Why a bridge instead of a per-vendor variants JSON entry: opencode does NOT
  * register settings-file hooks like the other vendors. It loads in-process
- * TypeScript plugins and dispatches plugin event handlers. So rather than the
- * generic `installHooksFromVariant` path (events → settings file → `bun
- * <script>` subprocess), opencode gets this thin shim that maps opencode
- * lifecycle events onto oma's existing, vendor-agnostic core scripts via
+ * TypeScript plugins whose handlers are invoked with an `(input, output)` pair
+ * and are expected to MUTATE `output` (return values are ignored). So rather
+ * than the generic `installHooksFromVariant` path (events → settings file →
+ * `bun <script>` subprocess), opencode gets this thin shim that maps opencode
+ * lifecycle handlers onto oma's existing, vendor-agnostic core scripts via
  * subprocess. All matching logic stays in the core scripts.
  *
+ * The core scripts installed under `.opencode/plugins/oma/` are not recognised
+ * as an opencode vendor (there is no `.opencode` case in the shared
+ * `inferVendorFromScriptPath`), so they resolve to the `claude` output dialect.
+ * This bridge therefore reads the claude-shaped stdout: `additionalContext`
+ * for prompt hooks, `hookSpecificOutput.updatedInput.command` for PreToolUse,
+ * and `{ decision: "block", reason }` for the Stop equivalent. Extraction is
+ * defensive (top-level OR `hookSpecificOutput`) so a dialect shift does not
+ * silently break the bridge.
+ *
  * Intentionally dependency-free (no @opencode-ai/plugin import) so this file
  * works in any user project without requiring opencode as a dev dependency.
- * The `Plugin` type is satisfied structurally via JSDoc.
+ * Handler and client shapes are satisfied structurally via inline types.
  *
  * Event mapping:
- *   chat.message        ← UserPromptSubmit  (keyword-detector + skill-injector)
- *   tool.execute.before ← PreToolUse        (test-filter for bash tools)
- *   session.idle        ← Stop              BEST-EFFORT / NON-BLOCKING
- *                         opencode's session.idle is a notification-only event
- *                         that fires when the session has no pending work. It
- *                         is the closest analog to the Claude `Stop` hook but
- *                         cannot block the session from terminating. Persistent
- *                         workflow Stop semantics are therefore DEGRADED under
- *                         opencode: the handler runs best-effort and must not
- *                         throw or block — if the underlying hook returns
- *                         non-zero or times out, the error is swallowed and
- *                         opencode proceeds normally.
+ *   chat.message                        ← UserPromptSubmit
+ *       Extracts user text from output.parts, runs keyword-detector +
+ *       skill-injector, and stashes the resulting context per session (keyed
+ *       by input.sessionID). The opencode session id is forwarded to the core
+ *       scripts so keyword-detector's persistent-mode activation writes a
+ *       session-scoped state file (an unresolved id would refuse to persist).
+ *   experimental.chat.system.transform  ← context injection
+ *       Peeks the stashed context for input.sessionID and pushes it onto
+ *       output.system. Non-consuming: the stash is refreshed (or cleared)
+ *       every chat.message, so re-injection across model calls in a turn is
+ *       harmless and a chat.message→transform ordering assumption cannot
+ *       permanently drop context.
+ *   tool.execute.before                 ← PreToolUse (bash only)
+ *       Runs test-filter on output.args.command and writes the rewritten
+ *       command back onto output.args.command.
+ *   event: "session.idle"               ← Stop (BEST-EFFORT / re-entrant)
+ *       Runs persistent-mode. If it returns a block decision, the workflow is
+ *       still active: re-enter the loop by posting the block reason as a new
+ *       prompt via client.session.prompt. Best-effort — any failure is
+ *       swallowed. persistent-mode's own reinforcement cap (5) is the primary
+ *       terminator; a per-session consecutive-idle counter is a runaway
+ *       backstop only.
  */
 
 import { spawnSync } from "node:child_process";
@@ -45,7 +66,8 @@ function corePath(script: string): string {
  * its JSON stdout. Fail-open (returns null) on any error — a broken hook must
  * never block the agent. Spawns with `cwd` = opencode's working directory so
  * the core scripts resolve the project (git) root the same way they do for
- * every other vendor.
+ * every other vendor. Non-zero exit (persistent-mode blocks with exit 2) is
+ * expected: stdout is still captured and parsed.
  */
 function runCore(
   script: string,
@@ -69,143 +91,320 @@ function runCore(
 }
 
 /**
- * Run an oma core hook script best-effort: like runCore but swallows all
- * errors and never throws. Used for session.idle (Stop equivalent) where
- * throwing would surface as an unhandled rejection inside opencode.
+ * Extract injected context from a prompt-hook (keyword-detector / skill-
+ * injector) result. The core scripts emit the `claude` dialect, which carries
+ * `additionalContext` both at the top level and under `hookSpecificOutput`;
+ * read either so a dialect change does not silently drop context.
  */
-function runCoreBestEffort(
-  script: string,
-  payload: Record<string, unknown>,
-  cwd: string,
-): void {
-  try {
-    runCore(script, payload, cwd);
-  } catch {
-    // Non-zero exit or parse error — swallow silently (Stop degraded semantics).
+function extractAdditionalContext(
+  out: Record<string, unknown> | null,
+): string | null {
+  if (!out) return null;
+  if (typeof out.additionalContext === "string" && out.additionalContext) {
+    return out.additionalContext;
+  }
+  const hso = out.hookSpecificOutput;
+  if (hso && typeof hso === "object") {
+    const nested = (hso as Record<string, unknown>).additionalContext;
+    if (typeof nested === "string" && nested) return nested;
+  }
+  return null;
+}
+
+/**
+ * Extract the rewritten command from a test-filter (PreToolUse) result. The
+ * `claude` dialect nests it under `hookSpecificOutput.updatedInput.command`;
+ * a top-level `updatedInput.command` is also accepted for dialect resilience.
+ */
+function extractUpdatedCommand(
+  out: Record<string, unknown> | null,
+): string | null {
+  if (!out) return null;
+  const readCommand = (v: unknown): string | null => {
+    if (v && typeof v === "object") {
+      const cmd = (v as Record<string, unknown>).command;
+      if (typeof cmd === "string" && cmd) return cmd;
+    }
+    return null;
+  };
+  const direct = readCommand(out.updatedInput);
+  if (direct) return direct;
+  const hso = out.hookSpecificOutput;
+  if (hso && typeof hso === "object") {
+    return readCommand((hso as Record<string, unknown>).updatedInput);
+  }
+  return null;
+}
+
+/** Join the text parts of a chat.message output into the user's prompt text. */
+function extractPromptText(output: {
+  message?: unknown;
+  parts?: Array<{ type?: string; text?: string }>;
+}): string {
+  const parts = Array.isArray(output.parts) ? output.parts : [];
+  const texts = parts
+    .filter((p) => p && p.type === "text" && typeof p.text === "string")
+    .map((p) => p.text as string);
+  if (texts.length > 0) return stripWrappingQuotes(texts.join("\n"));
+  // Defensive fallback: some builds may surface text on the message object.
+  const msg = output.message as { text?: unknown } | undefined;
+  if (msg && typeof msg.text === "string") return stripWrappingQuotes(msg.text);
+  return "";
+}
+
+/**
+ * `opencode run "<prompt>"` delivers the part text wrapped in literal double
+ * quotes (`"work: …"`), which defeats keyword detection anchored at the prompt
+ * start. A prompt that is entirely enclosed in one matching pair of quotes is
+ * that CLI artifact — unwrap exactly one pair; interior quotes are untouched.
+ */
+function stripWrappingQuotes(text: string): string {
+  const t = text.trim();
+  if (t.length >= 2 && t.startsWith('"') && t.endsWith('"')) {
+    return t.slice(1, -1);
+  }
+  return t;
+}
+
+// ── Per-session bridge state ──────────────────────────────────
+//
+// opencode plugins are loaded once per server process, so module-level maps
+// persist across a session's handler invocations. Both maps are keyed by the
+// opencode sessionID and bounded so a long-lived server cannot leak memory
+// across many sessions.
+
+const MAX_TRACKED_SESSIONS = 256;
+
+/**
+ * Context computed on chat.message, awaiting injection by the system-prompt
+ * transform. Overwrite-per-session: each chat.message replaces the entry
+ * (with `""` when nothing matched), so the transform never injects stale
+ * context and a peek does not need to consume.
+ */
+const pendingContext = new Map<string, string>();
+
+/**
+ * Consecutive session.idle re-entries per session, reset by any chat.message.
+ * A runaway backstop only — persistent-mode's reinforcement cap terminates the
+ * loop first under normal operation.
+ */
+const idleReentryCount = new Map<string, number>();
+const MAX_CONSECUTIVE_IDLE_REENTRIES = 50;
+
+/** Set a bounded map entry, evicting the oldest key when over capacity. */
+function setBounded<V>(map: Map<string, V>, key: string, value: V): void {
+  if (map.has(key)) map.delete(key);
+  map.set(key, value);
+  while (map.size > MAX_TRACKED_SESSIONS) {
+    const oldest = map.keys().next().value;
+    if (oldest === undefined) break;
+    map.delete(oldest);
   }
 }
 
+/**
+ * Minimal structural view of the opencode SDK client used for loop re-entry.
+ * Kept optional and dependency-free; the real client is a superset.
+ */
+type OmaOpencodeClient = {
+  session?: {
+    prompt?: (options: {
+      path: { id: string };
+      body: { parts: Array<{ type: "text"; text: string }> };
+    }) => Promise<unknown>;
+  };
+};
+
 /**
  * oh-my-agent opencode plugin.
  *
  * Structural shape satisfies the opencode `Plugin` contract without importing
  * @opencode-ai/plugin, keeping this bridge dependency-free in the user's
- * project.
+ * project. Handlers mutate their `output` argument (return values are ignored).
  *
  * @satisfies Plugin
  */
-export default (async ({ $ }: { $: { cwd: string } }) => {
-  const cwd = $.cwd ?? process.cwd();
+export default (async ({
+  directory,
+  client,
+}: {
+  directory?: string;
+  client?: OmaOpencodeClient;
+}) => {
+  const cwd = directory ?? process.cwd();
 
   return {
     /**
      * chat.message ← UserPromptSubmit
      *
-     * Invoked when the user submits a new message to the chat. Runs the OMA
-     * keyword-detector (workflow activation) and skill-injector (context
-     * injection) and appends any resulting context to the system prompt for
-     * this turn.
+     * Runs keyword-detector (workflow activation) and skill-injector (context
+     * injection), then stashes the concatenated context for this session so
+     * `experimental.chat.system.transform` can inject it. Forwards the opencode
+     * sessionID so persistent-workflow state is written session-scoped.
      */
-    "chat.message": async (event: {
-      message?: { content?: string };
-      session?: { systemPrompt?: string };
-    }) => {
-      const prompt = event.message?.content ?? "";
+    "chat.message": async (
+      input: { sessionID?: string },
+      output: {
+        message?: unknown;
+        parts?: Array<{ type?: string; text?: string }>;
+      },
+    ): Promise<void> => {
+      const sessionID = input.sessionID ?? "";
+      // A genuine user turn resets the runaway idle backstop.
+      if (sessionID) idleReentryCount.delete(sessionID);
+
+      const prompt = extractPromptText(output);
       const payload = {
         prompt,
         cwd,
+        sessionId: sessionID,
         hook_event_name: "UserPromptSubmit",
       };
 
       const parts: string[] = [];
+      const kd = extractAdditionalContext(
+        runCore("keyword-detector.ts", payload, cwd),
+      );
+      if (kd) parts.push(kd);
+      const si = extractAdditionalContext(
+        runCore("skill-injector.ts", payload, cwd),
+      );
+      if (si) parts.push(si);
 
-      const kd = runCore("keyword-detector.ts", payload, cwd);
-      if (kd && typeof kd.additionalContext === "string") {
-        parts.push(kd.additionalContext);
-      }
+      // Overwrite per session — even with "" — so the transform reflects this
+      // turn's detection and never re-injects a previous turn's context.
+      if (sessionID) setBounded(pendingContext, sessionID, parts.join("\n\n"));
+    },
 
-      const si = runCore("skill-injector.ts", payload, cwd);
-      if (si && typeof si.additionalContext === "string") {
-        parts.push(si.additionalContext);
+    /**
+     * experimental.chat.system.transform ← context injection
+     *
+     * Peeks (non-consuming) the context stashed by chat.message for this
+     * session and appends it to the system prompt. chat.message runs before the
+     * system transform within a turn; peeking keeps injection idempotent across
+     * multiple model calls in a turn and prevents an ordering race from
+     * permanently dropping context (the stash is refreshed every chat.message).
+     */
+    "experimental.chat.system.transform": async (
+      input: { sessionID?: string },
+      output: { system?: string[] },
+    ): Promise<void> => {
+      const sessionID = input.sessionID;
+      if (!sessionID) return;
+      const ctx = pendingContext.get(sessionID);
+      if (ctx && Array.isArray(output.system)) {
+        output.system.push(ctx);
       }
-
-      if (parts.length === 0) return undefined;
-
-      const existing = event.session?.systemPrompt ?? "";
-      return {
-        session: {
-          systemPrompt: existing
-            ? `${existing}\n\n${parts.join("\n\n")}`
-            : parts.join("\n\n"),
-        },
-      };
     },
 
     /**
-     * tool.execute.before ← PreToolUse (Bash)
+     * tool.execute.before ← PreToolUse (bash)
      *
-     * Invoked before a tool call is executed. Runs the OMA test-filter for
-     * bash/shell tools to rewrite test-runner commands so only failures reach
-     * the model. Non-bash tools are passed through unchanged.
+     * `input.tool` is a plain string and the command lives on
+     * `output.args.command`. Runs the OMA test-filter for bash commands to
+     * rewrite test-runner invocations so only failures reach the model, then
+     * writes the rewritten command back. Non-bash tools pass through unchanged.
      */
-    "tool.execute.before": async (event: {
-      tool?: { name?: string };
-      input?: { command?: string };
-    }) => {
-      const toolName = event.tool?.name ?? "";
-      if (toolName !== "bash" && toolName !== "Bash") return undefined;
-
-      const command = event.input?.command;
-      if (!command) return undefined;
-
-      const tf = runCore(
-        "test-filter.ts",
-        {
-          tool_name: "Bash",
-          tool_input: { command },
+    "tool.execute.before": async (
+      input: { tool?: string },
+      output: { args?: { command?: string } },
+    ): Promise<void> => {
+      if (input.tool !== "bash") return;
+      const command = output.args?.command;
+      if (typeof command !== "string" || !command) return;
+
+      const updated = extractUpdatedCommand(
+        runCore(
+          "test-filter.ts",
+          {
+            tool_name: "Bash",
+            tool_input: { command },
+            cwd,
+            hook_event_name: "PreToolUse",
+          },
           cwd,
-          hook_event_name: "PreToolUse",
-        },
-        cwd,
+        ),
       );
-
-      const updated = (tf?.updatedInput as { command?: string } | undefined)
-        ?.command;
-      if (updated && event.input) {
-        event.input.command = updated;
+      if (updated && output.args) {
+        output.args.command = updated;
       }
-
-      return undefined;
     },
 
     /**
-     * session.idle ← Stop (BEST-EFFORT / NON-BLOCKING)
+     * event: "session.idle" ← Stop (BEST-EFFORT / re-entrant)
      *
-     * Invoked when the session has no pending work. This is the nearest
-     * opencode analog to the Claude `Stop` hook but it CANNOT block session
-     * termination — opencode treats it as a notification-only event.
+     * opencode delivers session.idle over the event bus (it is no longer a
+     * top-level hook). Unlike the Claude `Stop` hook this cannot block
+     * termination, but the SDK client lets us re-enter the loop: run
+     * persistent-mode and, if a persistent workflow is still active (block
+     * decision), post the block reason back as a new prompt so the agent
+     * continues.
      *
-     * Persistent-workflow Stop semantics are therefore degraded: the handler
-     * runs best-effort and any non-zero hook exit or thrown error is swallowed
-     * so opencode can proceed normally. Do not rely on this handler to hold
-     * the session open; keyword-detector re-injection on the next chat.message
-     * event provides the fallback reinforcement path instead.
+     * BEST-EFFORT: every step is wrapped so a failure can never throw into
+     * opencode. persistent-mode's own reinforcement cap (5) terminates the
+     * loop under normal operation; the per-session consecutive-idle counter is
+     * a runaway backstop for pathological cases only.
      */
-    "session.idle": async (_event: unknown) => {
-      // BEST-EFFORT: errors are swallowed — must not throw or block.
-      runCoreBestEffort(
-        "keyword-detector.ts",
-        {
-          cwd,
-          hook_event_name: "Stop",
-        },
+    event: async (input: {
+      event?: { type?: string; properties?: Record<string, unknown> };
+    }): Promise<void> => {
+      const event = input.event;
+      if (!event || event.type !== "session.idle") return;
+      const sessionID = (event.properties as { sessionID?: string } | undefined)
+        ?.sessionID;
+      if (!sessionID) return;
+
+      const count = idleReentryCount.get(sessionID) ?? 0;
+      if (count >= MAX_CONSECUTIVE_IDLE_REENTRIES) return;
+
+      const pm = runCore(
+        "persistent-mode.ts",
+        { cwd, sessionId: sessionID, hook_event_name: "Stop" },
         cwd,
       );
-      return undefined;
+
+      if (!pm || pm.decision !== "block") {
+        // Workflow complete / not active — clear the backstop counter.
+        idleReentryCount.delete(sessionID);
+        return;
+      }
+
+      const reason =
+        typeof pm.reason === "string" && pm.reason
+          ? pm.reason
+          : "The active OMA workflow is not complete. Continue executing it.";
+      idleReentryCount.set(sessionID, count + 1);
+
+      try {
+        await client?.session?.prompt?.({
+          path: { id: sessionID },
+          body: { parts: [{ type: "text", text: reason }] },
+        });
+      } catch {
+        // Best-effort re-entry — never throw into opencode.
+      }
     },
   };
-}) satisfies (ctx: { $: { cwd: string } }) => Promise<{
-  "chat.message": (event: unknown) => Promise<unknown>;
-  "tool.execute.before": (event: unknown) => Promise<unknown>;
-  "session.idle": (event: unknown) => Promise<unknown>;
+}) satisfies (ctx: {
+  directory?: string;
+  client?: OmaOpencodeClient;
+}) => Promise<{
+  "chat.message": (
+    input: { sessionID?: string },
+    output: {
+      message?: unknown;
+      parts?: Array<{ type?: string; text?: string }>;
+    },
+  ) => Promise<void>;
+  "experimental.chat.system.transform": (
+    input: { sessionID?: string },
+    output: { system?: string[] },
+  ) => Promise<void>;
+  "tool.execute.before": (
+    input: { tool?: string },
+    output: { args?: { command?: string } },
+  ) => Promise<void>;
+  event: (input: {
+    event?: { type?: string; properties?: Record<string, unknown> };
+  }) => Promise<void>;
 }>;
diff --git a/.agents/hooks/variants/pi/README.md b/.agents/hooks/variants/pi/README.md
index 16c5b0c..bb090af 100644
--- a/.agents/hooks/variants/pi/README.md
+++ b/.agents/hooks/variants/pi/README.md
@@ -30,18 +30,45 @@ as subprocesses by the bridge.
 |---|---|---|---|
 | keyword-detector + skill-injector | `UserPromptSubmit` | `before_agent_start` | spawn both, append their `additionalContext` to `event.systemPrompt` |
 | test-filter | `PreToolUse` (Bash) | `tool_call` (bash) | spawn test-filter, rewrite `event.input.command` in place |
-| persistent-mode | `Stop` (block) | — | **no analog** (see below) |
+| persistent-mode | `Stop` (block) | `agent_settled` | spawn persistent-mode; on a `block` decision, re-enter via `pi.sendUserMessage(reason)` |
 | hud / status line | `statusLine` | `ctx.ui.setStatus` (RPC only) | not wired |
 
-## Known limitation: persistent workflows
+## Persistent workflows
 
-pi has no stop-blocking event. Its only post-turn hook, `agent_end`, is
-notification-only and cannot re-enter the agent loop. So the
-"block termination until the workflow finishes" behaviour of `orchestrate`,
-`ultrawork`, and `work` cannot be reproduced under pi. The persistent state is
-still written; it simply degrades to **re-injection on the next user turn** via
-`before_agent_start` (the same reinforcement path keyword-detector already
-uses), rather than forcing continuation within a single turn.
+`agent_settled` fires once a run has **fully settled** — no automatic retry,
+compaction, or queued continuation remains. That is pi's analog of a Stop hook,
+so the bridge spawns `persistent-mode.ts` there and, if a persistent workflow
+(`orchestrate`, `ultrawork`, `work`) is still active, re-enters the loop by
+re-injecting the reinforcement text through `pi.sendUserMessage(reason)` (which
+**always triggers a fresh turn**).
+
+Loop safety:
+
+- **Session-scoped state.** The bridge threads `ctx.sessionManager.getSessionId()`
+  into both the `before_agent_start` payload (so keyword-detector's `activateMode`
+  actually writes the workflow state file — it refuses to write under an unknown
+  session) and the `agent_settled` payload (so persistent-mode reads the matching
+  file). Without a session id the whole loop is inert.
+- **Primary terminator.** persistent-mode's own state file caps reinforcements
+  (5) and expires on staleness — after that it returns no `block` and the loop
+  ends. The re-injected reason begins with `[OMA PERSISTENT MODE:`; the bridge
+  detects that sentinel in `before_agent_start` and **skips** re-injection for
+  its own re-entry turns, so keyword-detector never re-activates the workflow and
+  never resets that cap.
+- **Backstop.** A hard ceiling of 50 consecutive re-entries per process (reset on
+  every genuine user turn) guards against a pathological state file.
+- **Pending input / idle.** Re-entry is skipped when `ctx.hasPendingMessages()`
+  is true, and the whole handler is best-effort (`try/catch`) so a broken hook
+  can never wedge pi.
+
+### Version compatibility
+
+`agent_settled` was added to pi **after 0.78.1**. Registration is
+capability-guarded (the `pi.on` call is wrapped in `try/catch`, and
+`pi.sendUserMessage` is feature-checked before use). On older pi builds the
+handler is simply never emitted and persistent workflows degrade to
+**re-injection on the next user turn** via `before_agent_start` — the historical
+behavior. The `before_agent_start` / `tool_call` mappings are unchanged.
 
 ## Vendor identity
 
diff --git a/.agents/hooks/variants/pi/index.ts b/.agents/hooks/variants/pi/index.ts
index 37e0ca2..aceeded 100644
--- a/.agents/hooks/variants/pi/index.ts
+++ b/.agents/hooks/variants/pi/index.ts
@@ -17,9 +17,16 @@
  * Event mapping (see README.md):
  *   before_agent_start  ← UserPromptSubmit  (keyword-detector + skill-injector)
  *   tool_call (bash)    ← PreToolUse        (test-filter)
- *   — persistent-mode has NO pi analog: pi's only post-turn event (agent_end)
- *     is notification-only and cannot re-enter the loop. Persistent workflows
- *     degrade to re-injection on the next turn via before_agent_start.
+ *   agent_settled       ← Stop              (persistent-mode + re-entry)
+ *
+ * persistent-mode: `agent_settled` fires once a run has fully settled (no
+ * pending retry / compaction / queued continuation) — the pi analog of a Stop
+ * hook. The bridge spawns `persistent-mode.ts` there; if it returns a `block`
+ * decision, the bridge re-enters the loop with the reinforcement text via
+ * `pi.sendUserMessage` (which always triggers a fresh turn). This event was
+ * added after pi 0.78.1, so its registration is capability-guarded: on older
+ * pi builds the handler is simply never emitted and persistent workflows
+ * degrade to re-injection on the next user turn (the historical behavior).
  */
 
 import { spawnSync } from "node:child_process";
@@ -66,17 +73,56 @@ function runCore(
 // extensions in-process, not as shell-wrapped subprocesses.)
 const guard = globalThis as { __OMA_PI_EXT_REGISTERED?: boolean };
 
+// Prefix that persistent-mode.ts prepends to every reinforcement reason (see
+// `.agents/hooks/core/persistent-mode.ts`). The bridge re-injects that reason
+// as a user message, so it re-enters this extension as a `before_agent_start`
+// event too — this sentinel lets the bridge tell its own re-entry turn apart
+// from a genuine user prompt.
+const REENTRY_SENTINEL = "[OMA PERSISTENT MODE:";
+
+// Runaway backstop: hard ceiling on consecutive programmatic re-entries within
+// a single pi process, reset on every genuine user turn. persistent-mode's own
+// state file (5-reinforcement + staleness cap) is the primary terminator; this
+// only defends against a pathological state file that never exhausts.
+const MAX_REENTRIES = 50;
+
+/** Read a stable per-session id from pi's context, or undefined if unavailable. */
+function sessionIdOf(ctx: unknown): string | undefined {
+  const sm = (ctx as { sessionManager?: { getSessionId?: () => string } })
+    ?.sessionManager;
+  try {
+    const sid = sm?.getSessionId?.();
+    return sid || undefined;
+  } catch {
+    return undefined;
+  }
+}
+
 export default function omaHooks(pi: ExtensionAPI): void {
   if (guard.__OMA_PI_EXT_REGISTERED) return;
   guard.__OMA_PI_EXT_REGISTERED = true;
 
+  // Consecutive programmatic re-entries since the last genuine user turn.
+  let reentryCount = 0;
+
   // before_agent_start ← UserPromptSubmit.
   // Inject workflow + skill context into the system prompt for this turn.
-  pi.on("before_agent_start", async (event) => {
+  pi.on("before_agent_start", async (event, ctx) => {
+    // A bridge-driven re-entry re-fires this event with the reinforcement text
+    // as the prompt. Skip injection for it: re-running keyword-detector would
+    // re-activate the workflow and reset persistent-mode's reinforcement cap,
+    // defeating the primary terminator. A genuine user turn resets the backstop.
+    if (event.prompt?.startsWith(REENTRY_SENTINEL)) return undefined;
+    reentryCount = 0;
+
+    const sessionId = sessionIdOf(ctx);
     const payload = {
       prompt: event.prompt ?? "",
       cwd: process.cwd(),
       hook_event_name: "UserPromptSubmit",
+      // Thread the session id so keyword-detector's activateMode persists the
+      // workflow state file (it refuses to write under an unknown session).
+      ...(sessionId ? { sessionId } : {}),
     };
 
     // Order matches the Claude chain: keyword-detector first (it may activate
@@ -117,4 +163,43 @@ export default function omaHooks(pi: ExtensionAPI): void {
     if (updated && input) input.command = updated;
     return undefined;
   });
+
+  // agent_settled ← Stop. Persistent-mode re-entry: after a run fully settles,
+  // ask persistent-mode.ts whether a workflow is still active; if so, re-enter
+  // the loop with its reinforcement text. Capability-guarded — pi builds before
+  // this event existed never emit it, so this is a no-op there (workflows then
+  // degrade to next-user-turn re-injection, the historical behavior).
+  try {
+    pi.on("agent_settled", async (_event, ctx) => {
+      try {
+        if (reentryCount >= MAX_REENTRIES) return undefined;
+        // Never re-enter while the user has queued input, and require the
+        // re-entry API (absent on very old pi builds).
+        if (ctx?.hasPendingMessages?.()) return undefined;
+        if (typeof pi.sendUserMessage !== "function") return undefined;
+
+        const sessionId = sessionIdOf(ctx);
+        const pm = runCore("persistent-mode.ts", {
+          cwd: process.cwd(),
+          hook_event_name: "Stop",
+          ...(sessionId ? { sessionId } : {}),
+        });
+
+        // persistent-mode classifies this subprocess as a generic vendor, so
+        // the decision arrives as `{ decision: "block" }`; also accept pi's
+        // native `{ block: true }` dialect for forward-compat.
+        const blocked = pm?.decision === "block" || pm?.block === true;
+        const reason = typeof pm?.reason === "string" ? pm.reason : undefined;
+        if (!blocked || !reason) return undefined;
+
+        reentryCount += 1;
+        void pi.sendUserMessage(reason);
+      } catch {
+        // Best-effort: a broken persistent-mode must never wedge pi.
+      }
+      return undefined;
+    });
+  } catch {
+    // pi build predates `agent_settled` — persistent-mode re-entry unavailable.
+  }
 }
diff --git a/.agents/hooks/variants/qwen.json b/.agents/hooks/variants/qwen.json
index c584ca0..94efc9c 100644
--- a/.agents/hooks/variants/qwen.json
+++ b/.agents/hooks/variants/qwen.json
@@ -26,7 +26,7 @@
     ],
     "PreToolUse": {
       "hook": "test-filter.ts",
-      "matcher": "Bash",
+      "matcher": "run_shell_command",
       "timeout": 5
     },
     "Stop": {
@@ -37,5 +37,10 @@
   "statusLine": {
     "hook": "hud.ts"
   },
-  "statusLineKey": "ui"
+  "statusLineKey": "ui",
+  "extra": {
+    "hooksConfig": {
+      "enabled": true
+    }
+  }
 }
diff --git a/.agents/mcp.json b/.agents/mcp.json
index 9897abf..c6258c0 100644
--- a/.agents/mcp.json
+++ b/.agents/mcp.json
@@ -17,14 +17,12 @@
     }
   },
   "memoryConfig": {
-    "provider": "serena",
-    "basePath": ".serena/memories",
+    "provider": "file",
+    "basePath": ".agents/state/memories",
     "tools": {
-      "read": "read_memory",
-      "write": "write_memory",
-      "edit": "edit_memory",
-      "list": "list_memories",
-      "delete": "delete_memory"
+      "read": "Read",
+      "write": "Write",
+      "edit": "Edit"
     }
   },
   "toolGroups": {
diff --git a/.agents/rules/market.md b/.agents/rules/market.md
index 42eaa9e..e14e7ef 100644
--- a/.agents/rules/market.md
+++ b/.agents/rules/market.md
@@ -9,12 +9,12 @@ alwaysApply: false
 ## Core Rules
 
 1. **Preflight first**: every market research task starts with `oma market detect-trap`. If it refuses, surface the reframe to the user — never bypass without `--force`.
-2. **Keyless-first**: default to sources that need no API key (reddit, hn, bluesky, mastodon, github-issues, grounding). Paid sources (x, tiktok, instagram, youtube, perplexity) auto-enable only when env keys are present.
-3. **Reuse oma-search**: all fetches go through `oma search fetch --only api`. Do not call platform APIs directly from market commands. Trust labels come from oma-search.
+2. **Keyless-first**: default to sources that need no API key (reddit, hn, bluesky, mastodon, github, grounding). youtube joins automatically when the `yt-dlp` binary is installed. Env-keyed sources (x, tiktok, instagram, perplexity) are skipped with a stderr notice when their key is absent.
+3. **Fetch inside harvest only**: all network fetches happen inside `oma market harvest` via its built-in per-source fetchers. Do not call platform APIs directly from other market stages or from the agent.
 4. **Deterministic compute**: score, fuse, cluster stages must produce byte-identical output on `OMA_MARKET_MOCK=1` fixture replay. Stage stdin/stdout is pure JSON; stderr is warn/error only.
 5. **LAW enforcement**: render output must pass the 8 LAWs (see `.agents/skills/oma-market/resources/output-laws.md`). LAW self-check is mandatory; `--no-self-check` is debug-only.
 6. **Cite or fall back**: every representative cited in the brief is `[name](url)`. If URL is missing, use plain text — never `[name]()`.
 7. **Coverage transparency**: when `sources_failed` is non-empty, render must annotate "coverage: N/M sources" in the engine footer.
 8. **Intent → framework auto-toggle**: pain/trend → SWOT only; competitor → SWOT + Porter's 5F; discovery → SWOT + PESTEL. User `--frameworks` flag overrides.
 9. **Single brief, single date**: one run = one md file at `.agents/results/market/{topic-slug}-{YYYYMMDD}.md`. Rerunning same day overwrites; previous run is responsible to git the file if needed.
-10. **Personal data refuse**: detect-trap blocks queries that target a private individual's personal data. Founders, creators, and public handles are allowed (last30days person-mode parity).
+10. **Personal data refuse**: refuse queries that target a private individual's personal data before running the pipeline. This is an agent-level gate — `detect-trap` automates demographic-shopping and overly-broad-topic refusal only. Founders, creators, and public handles are allowed (last30days person-mode parity).
diff --git a/.agents/skills/_shared/conditional/quality-score.md b/.agents/skills/_shared/conditional/quality-score.md
index fe7bb20..bdcc4f1 100644
--- a/.agents/skills/_shared/conditional/quality-score.md
+++ b/.agents/skills/_shared/conditional/quality-score.md
@@ -112,6 +112,7 @@ Record via memory protocol: `[EDIT]("experiment-ledger.md", append row)`.
 
 ## Dimension Customization (Optional)
 
+<!-- oma-docs:ignore-start -->
 Projects can override weights in `.agents/config/quality-score.yaml`:
 
 ```yaml
@@ -125,6 +126,7 @@ thresholds:
   pass: 85
   hard_fail: 60
 ```
+<!-- oma-docs:ignore-end -->
 
 If config file is absent, use the defaults defined in this document.
 
diff --git a/.agents/skills/_shared/core/api-contracts/README.md b/.agents/skills/_shared/core/api-contracts/README.md
index 61d7405..c8d7aed 100644
--- a/.agents/skills/_shared/core/api-contracts/README.md
+++ b/.agents/skills/_shared/core/api-contracts/README.md
@@ -39,8 +39,8 @@ Read contract and integrate API client exactly as specified:
 ## Tool Reference
 
 Tool names are configured in `mcp.json → memoryConfig.tools`:
-- `[READ]` → default: `read_memory`
-- `[WRITE]` → default: `write_memory`
+- `[READ]` → default: `Read` (direct file read)
+- `[WRITE]` → default: `Write` (direct file write)
 
 ## Contract Format
 
diff --git a/.agents/skills/_shared/core/context-budget.md b/.agents/skills/_shared/core/context-budget.md
index 2721775..8dc8077 100644
--- a/.agents/skills/_shared/core/context-budget.md
+++ b/.agents/skills/_shared/core/context-budget.md
@@ -146,7 +146,7 @@ When a trigger fires, the Orchestrator executes:
 
 1. **Checkpoint**: Save agent's current state
    ```
-   write_memory("checkpoint-{agent-id}", content)
+   Write(".agents/state/memories/checkpoint-{agent-id}.md", content)
    ```
    Content (assembled by Orchestrator from progress file):
    - Completed items with file paths
diff --git a/.agents/skills/_shared/core/context-loading.md b/.agents/skills/_shared/core/context-loading.md
index 863b779..b449a5b 100644
--- a/.agents/skills/_shared/core/context-loading.md
+++ b/.agents/skills/_shared/core/context-loading.md
@@ -17,7 +17,9 @@ This saves context window and prevents confusion from irrelevant information.
 ### Load Based on Difficulty
 4. **Simple**: Proceed to implementation without additional loading
 5. **Medium**: `resources/examples.md` (reference similar examples)
+<!-- oma-docs:ignore-start -->
 6. **Complex**: `resources/examples.md` + `stack/tech-stack.md` + `stack/snippets.md`
+<!-- oma-docs:ignore-end -->
 
 ### Load During Execution as Needed
 7. `resources/checklist.md`: Load at Step 4 (Verify)
@@ -144,7 +146,7 @@ Prompt composition:
 2. execution-protocol.md
 3. Resources matching task type (see tables above)
 4. error-playbook.md (always include; recovery is essential)
-5. Serena Memory Protocol (CLI mode)
+5. Memory Protocol (CLI mode)
 ```
 
 This approach avoids loading unnecessary resources, maximizing subagent context efficiency.
diff --git a/.agents/skills/_shared/core/session-metrics.md b/.agents/skills/_shared/core/session-metrics.md
index cf52d17..34b3a3d 100644
--- a/.agents/skills/_shared/core/session-metrics.md
+++ b/.agents/skills/_shared/core/session-metrics.md
@@ -46,7 +46,7 @@ Agents that frequently require re-direction consume more tokens and user time th
 
 ## Session Log Format
 
-Orchestrator maintains this log in `.serena/memories/session-metrics.md` during execution.
+Orchestrator maintains this log in `.agents/state/memories/session-metrics.md` during execution.
 
 ```markdown
 ## Session: {SESSION_ID}
@@ -172,8 +172,8 @@ This data is sourced from the Experiment Ledger at session end (see `experiment-
 
 ## Metrics Retention
 
-- **Active session**: `.serena/memories/session-metrics.md`
-- **Completed sessions**: Archived to `.serena/memories/archive/metrics-{date}.md`
+- **Active session**: `.agents/state/memories/session-metrics.md`
+- **Completed sessions**: Archived to `.agents/state/memories/archive/metrics-{date}.md`
 - **Retention**: 30 days (configurable)
 - **Aggregation**: `oma stats` command summarizes trends
 
diff --git a/.agents/skills/_shared/runtime/execution-protocols/antigravity.md b/.agents/skills/_shared/runtime/execution-protocols/antigravity.md
index acd8003..dbe37b8 100644
--- a/.agents/skills/_shared/runtime/execution-protocols/antigravity.md
+++ b/.agents/skills/_shared/runtime/execution-protocols/antigravity.md
@@ -5,19 +5,17 @@ state coordination. **In headless mode your stdout is discarded by the spawner**
 durable hand-off to the orchestrator is the result artifact written below. If you do not
 write it, the orchestrator reports your run as `crashed` even on success.
 
-## MCP Memory Tools
+## Memory Tools
 
-Tool names are configurable via `mcp_config.json → memoryConfig.tools`:
-- `[READ]` → default: `read_memory`
-- `[WRITE]` → default: `write_memory`
-- `[EDIT]` → default: `edit_memory`
-- `[LIST]` → default: `list_memories`
-- `[DELETE]` → default: `delete_memory`
+Coordination artifacts are read and written as plain files with your native file tools.
+Tool names remain configurable via `mcp_config.json → memoryConfig.tools`:
+- `[READ]` → default: `Read`
+- `[WRITE]` → default: `Write`
+- `[EDIT]` → default: `Edit`
+- `[LIST]` → default: directory listing (e.g. `ls`)
+- `[DELETE]` → default: file delete (e.g. `rm`)
 
-Memory base path is configurable via `memoryConfig.basePath` (default: `.serena/memories`).
-
-If Serena MCP memory tools are unavailable, fall back to writing the same files directly to
-`.serena/memories/` using your native file-write tool.
+Memory base path is configurable via `memoryConfig.basePath` (default: `.agents/state/memories`). Create the directory if it does not yet exist.
 
 ### Path Resolution (CRITICAL)
 
diff --git a/.agents/skills/_shared/runtime/execution-protocols/claude.md b/.agents/skills/_shared/runtime/execution-protocols/claude.md
index 655e08d..cf54959 100644
--- a/.agents/skills/_shared/runtime/execution-protocols/claude.md
+++ b/.agents/skills/_shared/runtime/execution-protocols/claude.md
@@ -5,18 +5,18 @@ When running as a CLI subagent, follow this protocol for shared state coordinati
 ## State Management
 
 Use file-based I/O for coordination. Coordination/state files (task-board, progress,
-result hand-offs) MUST be written to the **project-root memory store** `.serena/memories/`
+result hand-offs) MUST be written to the **project-root memory store** `.agents/state/memories/`
 — that is the only location the orchestrator (`oma agent:status`), `oma verify`, and the
 memory/retro tooling read. Writing them anywhere else (e.g. `.agents/results/`) leaves them
 orphaned and your run is reported as `crashed`. Human-facing deliverables (plans, bug
 reports, design docs) belong under `.agents/results/` instead.
 
-If Serena MCP is available, use `read_memory`/`write_memory`/`edit_memory` (its default
-base path is `.serena/memories`); otherwise write the same files there directly.
+Write and read these files directly at `.agents/state/memories/` using your native file
+Read/Write/Edit tools; create the directory if it does not yet exist.
 
 ### Path Resolution (CRITICAL)
 
-All result, progress, and state files MUST be written to the **project root** `.serena/memories/` directory, never to a subdirectory's `.serena/memories/`.
+All result, progress, and state files MUST be written to the **project root** `.agents/state/memories/` directory, never to a subdirectory's `.agents/state/memories/`.
 
 - **Project root** = the git repository root (where `.git` exists)
 - **Session-scoped naming**: when running under an orchestration session, append session ID as suffix:
@@ -26,8 +26,8 @@ All result, progress, and state files MUST be written to the **project root** `.
 
 ## On Start
 
-1. Read `.serena/memories/task-board.md` (or `read_memory("task-board.md")`) to confirm your assigned task
-2. Create `.serena/memories/progress-{agent-id}[-{sessionId}].md` with initial status
+1. Read `.agents/state/memories/task-board.md` to confirm your assigned task
+2. Create `.agents/state/memories/progress-{agent-id}[-{sessionId}].md` with initial status
 
 ## During Execution
 
@@ -36,7 +36,7 @@ All result, progress, and state files MUST be written to the **project root** `.
 
 ## On Completion
 
-- Create `.serena/memories/result-{agent-id}[-{sessionId}].md` with final result including:
+- Create `.agents/state/memories/result-{agent-id}[-{sessionId}].md` with final result including:
   - A status line — see **Status line format** below (REQUIRED)
   - Summary of work done
   - Files created/modified
diff --git a/.agents/skills/_shared/runtime/execution-protocols/codex.md b/.agents/skills/_shared/runtime/execution-protocols/codex.md
index 83aa0fc..7ea2007 100644
--- a/.agents/skills/_shared/runtime/execution-protocols/codex.md
+++ b/.agents/skills/_shared/runtime/execution-protocols/codex.md
@@ -5,7 +5,7 @@ When running as a CLI subagent, follow this protocol for shared state coordinati
 ## State Management
 
 Use file-based I/O for coordination. Coordination/state files (task-board, progress,
-result hand-offs) MUST be written to the **project-root memory store** `.serena/memories/`
+result hand-offs) MUST be written to the **project-root memory store** `.agents/state/memories/`
 — that is the only location the orchestrator (`oma agent:status`), `oma verify`, and the
 memory/retro tooling read. Writing them anywhere else (e.g. `.agents/results/`) leaves them
 orphaned and your run is reported as `crashed`. Human-facing deliverables (plans, bug
@@ -13,7 +13,7 @@ reports, design docs) belong under `.agents/results/` instead.
 
 ### Path Resolution (CRITICAL)
 
-All result, progress, and state files MUST be written to the **project root** `.serena/memories/` directory, never to a subdirectory's `.serena/memories/`.
+All result, progress, and state files MUST be written to the **project root** `.agents/state/memories/` directory, never to a subdirectory's `.agents/state/memories/`.
 
 - **Project root** = the git repository root (where `.git` exists)
 - **Session-scoped naming**: when running under an orchestration session, append session ID as suffix:
@@ -23,8 +23,8 @@ All result, progress, and state files MUST be written to the **project root** `.
 
 ## On Start
 
-1. Read `.serena/memories/task-board.md` to confirm your assigned task
-2. Create `.serena/memories/progress-{agent-id}[-{sessionId}].md` with initial status
+1. Read `.agents/state/memories/task-board.md` to confirm your assigned task
+2. Create `.agents/state/memories/progress-{agent-id}[-{sessionId}].md` with initial status
 
 ## During Execution
 
@@ -33,7 +33,7 @@ All result, progress, and state files MUST be written to the **project root** `.
 
 ## On Completion
 
-- Create `.serena/memories/result-{agent-id}[-{sessionId}].md` with final result including:
+- Create `.agents/state/memories/result-{agent-id}[-{sessionId}].md` with final result including:
   - A status line — see **Status line format** below (REQUIRED)
   - Summary of work done
   - Files created/modified
diff --git a/.agents/skills/_shared/runtime/execution-protocols/commandcode.md b/.agents/skills/_shared/runtime/execution-protocols/commandcode.md
index 598830b..3f19ac0 100644
--- a/.agents/skills/_shared/runtime/execution-protocols/commandcode.md
+++ b/.agents/skills/_shared/runtime/execution-protocols/commandcode.md
@@ -5,7 +5,7 @@ When running as a CLI subagent, follow this protocol for shared state coordinati
 ## State Management
 
 Use file-based I/O for coordination. Coordination/state files (task-board, progress,
-result hand-offs) MUST be written to the **project-root memory store** `.serena/memories/`
+result hand-offs) MUST be written to the **project-root memory store** `.agents/state/memories/`
 — that is the only location the orchestrator (`oma agent:status`), `oma verify`, and the
 memory/retro tooling read. Writing them anywhere else (e.g. `.agents/results/`) leaves them
 orphaned and your run is reported as `crashed`. Human-facing deliverables (plans, bug
@@ -13,7 +13,7 @@ reports, design docs) belong under `.agents/results/` instead.
 
 ### Path Resolution (CRITICAL)
 
-All result, progress, and state files MUST be written to the **project root** `.serena/memories/` directory, never to a subdirectory's `.serena/memories/`.
+All result, progress, and state files MUST be written to the **project root** `.agents/state/memories/` directory, never to a subdirectory's `.agents/state/memories/`.
 
 - **Project root** = the git repository root (where `.git` exists)
 - **Session-scoped naming**: when running under an orchestration session, append session ID as suffix:
@@ -23,8 +23,8 @@ All result, progress, and state files MUST be written to the **project root** `.
 
 ## On Start
 
-1. Read `.serena/memories/task-board.md` to confirm your assigned task
-2. Create `.serena/memories/progress-{agent-id}[-{sessionId}].md` with initial status
+1. Read `.agents/state/memories/task-board.md` to confirm your assigned task
+2. Create `.agents/state/memories/progress-{agent-id}[-{sessionId}].md` with initial status
 
 ## During Execution
 
@@ -33,7 +33,7 @@ All result, progress, and state files MUST be written to the **project root** `.
 
 ## On Completion
 
-- Create `.serena/memories/result-{agent-id}[-{sessionId}].md` with final result including:
+- Create `.agents/state/memories/result-{agent-id}[-{sessionId}].md` with final result including:
   - A status line — see **Status line format** below (REQUIRED)
   - Summary of work done
   - Files created/modified
diff --git a/.agents/skills/_shared/runtime/execution-protocols/grok.md b/.agents/skills/_shared/runtime/execution-protocols/grok.md
index 2cc8e12..f5a299a 100644
--- a/.agents/skills/_shared/runtime/execution-protocols/grok.md
+++ b/.agents/skills/_shared/runtime/execution-protocols/grok.md
@@ -5,7 +5,7 @@ When running as a Grok subagent or custom agent, follow this protocol for shared
 ## State Management
 
 Use file-based I/O for coordination. Coordination/state files (task-board, progress,
-result hand-offs) MUST be written to the **project-root memory store** `.serena/memories/`
+result hand-offs) MUST be written to the **project-root memory store** `.agents/state/memories/`
 — that is the only location the orchestrator (`oma agent:status`), `oma verify`, and the
 memory/retro tooling read. Writing them anywhere else (e.g. `.agents/results/`) leaves them
 orphaned and your run is reported as `crashed`. Human-facing deliverables (plans, bug
@@ -15,7 +15,7 @@ Grok has good native support for project files and can use terminal commands for
 
 ### Path Resolution (CRITICAL)
 
-All result, progress, and state files MUST be written to the **project root** `.serena/memories/` directory.
+All result, progress, and state files MUST be written to the **project root** `.agents/state/memories/` directory.
 
 - **Project root** = the git repository root (where `.git` exists)
 - **Session-scoped naming**: when running under an orchestration session, append session ID as suffix:
@@ -24,8 +24,8 @@ All result, progress, and state files MUST be written to the **project root** `.
 
 ## On Start
 
-1. Read the assigned task context (from orchestration or user prompt; see `.serena/memories/task-board.md` if present).
-2. Create progress tracking if needed under `.serena/memories/`.
+1. Read the assigned task context (from orchestration or user prompt; see `.agents/state/memories/task-board.md` if present).
+2. Create progress tracking if needed under `.agents/state/memories/`.
 
 ## During Execution
 
diff --git a/.agents/skills/_shared/runtime/execution-protocols/kimi.md b/.agents/skills/_shared/runtime/execution-protocols/kimi.md
index e5473f7..650f4d7 100644
--- a/.agents/skills/_shared/runtime/execution-protocols/kimi.md
+++ b/.agents/skills/_shared/runtime/execution-protocols/kimi.md
@@ -5,19 +5,18 @@ shared state coordination. **In headless mode your stdout is discarded by the sp
 the only durable hand-off to the orchestrator is the result artifact written below. If you
 do not write it, the orchestrator reports your run as `crashed` even on success.
 
-## MCP Memory Tools
-
-Kimi Code CLI supports MCP servers; when Serena MCP is configured, use its memory tools:
-- `[READ]` → `read_memory`
-- `[WRITE]` → `write_memory`
-- `[EDIT]` → `edit_memory`
-- `[LIST]` → `list_memories`
-- `[DELETE]` → `delete_memory`
-
-Memory base path defaults to `.serena/memories`.
-
-If Serena MCP memory tools are unavailable, fall back to writing the same files directly to
-`.serena/memories/` using your native file-write tool.
+## Memory Tools
+
+Coordination artifacts are read and written as plain files with your native file tools.
+Tool names remain configurable via `memoryConfig.tools`:
+- `[READ]` → default: `Read`
+- `[WRITE]` → default: `Write`
+- `[EDIT]` → default: `Edit`
+- `[LIST]` → default: directory listing (e.g. `ls`)
+- `[DELETE]` → default: file delete (e.g. `rm`)
+
+Memory base path defaults to `.agents/state/memories`. Create the directory if it does not
+yet exist.
 
 ### Path Resolution (CRITICAL)
 
diff --git a/.agents/skills/_shared/runtime/execution-protocols/kiro.md b/.agents/skills/_shared/runtime/execution-protocols/kiro.md
index a6a2d54..e369f01 100644
--- a/.agents/skills/_shared/runtime/execution-protocols/kiro.md
+++ b/.agents/skills/_shared/runtime/execution-protocols/kiro.md
@@ -5,19 +5,17 @@ shared state coordination. **In headless mode your stdout is discarded by the sp
 the only durable hand-off to the orchestrator is the result artifact written below. If you
 do not write it, the orchestrator reports your run as `crashed` even on success.
 
-## MCP Memory Tools
+## Memory Tools
 
-Tool names are configurable via `mcp_config.json → memoryConfig.tools`:
-- `[READ]` → default: `read_memory`
-- `[WRITE]` → default: `write_memory`
-- `[EDIT]` → default: `edit_memory`
-- `[LIST]` → default: `list_memories`
-- `[DELETE]` → default: `delete_memory`
+Coordination artifacts are read and written as plain files with your native file tools.
+Tool names remain configurable via `mcp_config.json → memoryConfig.tools`:
+- `[READ]` → default: `Read`
+- `[WRITE]` → default: `Write`
+- `[EDIT]` → default: `Edit`
+- `[LIST]` → default: directory listing (e.g. `ls`)
+- `[DELETE]` → default: file delete (e.g. `rm`)
 
-Memory base path is configurable via `memoryConfig.basePath` (default: `.serena/memories`).
-
-If Serena MCP memory tools are unavailable, fall back to writing the same files directly to
-`.serena/memories/` using your native file-write tool.
+Memory base path is configurable via `memoryConfig.basePath` (default: `.agents/state/memories`). Create the directory if it does not yet exist.
 
 ### Path Resolution (CRITICAL)
 
diff --git a/.agents/skills/_shared/runtime/execution-protocols/opencode.md b/.agents/skills/_shared/runtime/execution-protocols/opencode.md
index fe8f728..0d04fbb 100644
--- a/.agents/skills/_shared/runtime/execution-protocols/opencode.md
+++ b/.agents/skills/_shared/runtime/execution-protocols/opencode.md
@@ -5,15 +5,14 @@ When running as a CLI subagent (`opencode` headless mode), follow this protocol
 ## State Management
 
 Use file-based I/O for coordination. Coordination/state files (task-board, progress,
-result hand-offs) MUST be written to the **project-root memory store** `.serena/memories/`
+result hand-offs) MUST be written to the **project-root memory store** `.agents/state/memories/`
 — that is the only location the orchestrator (`oma agent:status`), `oma verify`, and the
 memory/retro tooling read. Writing them anywhere else (e.g. `.agents/results/`) leaves them
 orphaned and your run is reported as `crashed`. Human-facing deliverables (plans, bug
 reports, design docs) belong under `.agents/results/` instead.
 
-If Serena MCP is available, use `read_memory`/`write_memory`/`edit_memory` (its default
-base path is `.serena/memories`); otherwise write the same files there directly with
-opencode's file tools.
+Write and read these files directly at `.agents/state/memories/` using opencode's native
+file tools; create the directory if it does not yet exist.
 
 ### Serena MCP Timeout Recovery (OpenCode Desktop)
 
@@ -22,10 +21,9 @@ so a stuck Serena MCP stays stuck until the Desktop app is fully relaunched (the
 rarely affected). When a Serena MCP call times out or the MCP queue is clearly stuck, do
 not keep retrying MCP — fall back narrowly:
 
-1. **Memory ops** — read/write the same files directly under `.serena/memories/` (as
-   above). If a recent Serena CLI is installed (≥ 1.5, check `serena --version`),
-   `serena memories read|write|list` is an equivalent alternative; older versions
-   (e.g. 1.3.x) do not have the `memories` command.
+1. **Memory ops** — coordination artifacts are already plain files under
+   `.agents/state/memories/` written with your native file tools, so a stuck MCP does not
+   block them.
 2. **Code analysis** — fall back to native search/read tools. The Serena CLI cannot
    execute analysis tools (`serena tools` only lists/describes them).
 3. **Diagnostics** — `serena project health-check` and `serena project index` work
@@ -36,7 +34,7 @@ abandon Serena-first. A full Desktop relaunch is what actually resets the stale
 
 ### Path Resolution (CRITICAL)
 
-All result, progress, and state files MUST be written to the **project root** `.serena/memories/` directory, never to a subdirectory's `.serena/memories/`.
+All result, progress, and state files MUST be written to the **project root** `.agents/state/memories/` directory, never to a subdirectory's `.agents/state/memories/`.
 
 - **Project root** = the git repository root (where `.git` exists)
 - **Session-scoped naming**: when running under an orchestration session, append session ID as suffix:
@@ -46,8 +44,8 @@ All result, progress, and state files MUST be written to the **project root** `.
 
 ## On Start
 
-1. Read `.serena/memories/task-board.md` (or `read_memory("task-board.md")`) to confirm your assigned task when it exists.
-2. Create `.serena/memories/progress-{agent-id}[-{sessionId}].md` with initial status.
+1. Read `.agents/state/memories/task-board.md` to confirm your assigned task when it exists.
+2. Create `.agents/state/memories/progress-{agent-id}[-{sessionId}].md` with initial status.
 
 ## During Execution
 
@@ -56,7 +54,7 @@ All result, progress, and state files MUST be written to the **project root** `.
 
 ## On Completion
 
-- Create `.serena/memories/result-{agent-id}[-{sessionId}].md` with final result including:
+- Create `.agents/state/memories/result-{agent-id}[-{sessionId}].md` with final result including:
   - A status line — see **Status line format** below (REQUIRED)
   - Summary of work done
   - Files created/modified
diff --git a/.agents/skills/_shared/runtime/execution-protocols/pi.md b/.agents/skills/_shared/runtime/execution-protocols/pi.md
index 7fdcfe8..330403f 100644
--- a/.agents/skills/_shared/runtime/execution-protocols/pi.md
+++ b/.agents/skills/_shared/runtime/execution-protocols/pi.md
@@ -5,19 +5,18 @@ When running as a CLI subagent (`pi -p` headless print mode), follow this protoc
 ## State Management
 
 Use file-based I/O for coordination. Coordination/state files (task-board, progress,
-result hand-offs) MUST be written to the **project-root memory store** `.serena/memories/`
+result hand-offs) MUST be written to the **project-root memory store** `.agents/state/memories/`
 — that is the only location the orchestrator (`oma agent:status`), `oma verify`, and the
 memory/retro tooling read. Writing them anywhere else (e.g. `.agents/results/`) leaves them
 orphaned and your run is reported as `crashed`. Human-facing deliverables (plans, bug
 reports, design docs) belong under `.agents/results/` instead.
 
-If Serena MCP is available, use `read_memory`/`write_memory`/`edit_memory` (its default
-base path is `.serena/memories`); otherwise write the same files there directly with pi's
-`read`, `write`, or `edit` tools.
+Write and read these files directly at `.agents/state/memories/` using pi's native `read`,
+`write`, and `edit` tools; create the directory if it does not yet exist.
 
 ### Path Resolution (CRITICAL)
 
-All result, progress, and state files MUST be written to the **project root** `.serena/memories/` directory, never to a subdirectory's `.serena/memories/`.
+All result, progress, and state files MUST be written to the **project root** `.agents/state/memories/` directory, never to a subdirectory's `.agents/state/memories/`.
 
 - **Project root** = the git repository root (where `.git` exists)
 - **Session-scoped naming**: when running under an orchestration session, append session ID as suffix:
@@ -27,8 +26,8 @@ All result, progress, and state files MUST be written to the **project root** `.
 
 ## On Start
 
-1. Read `.serena/memories/task-board.md` (or `read_memory("task-board.md")`) to confirm your assigned task when it exists.
-2. Create `.serena/memories/progress-{agent-id}[-{sessionId}].md` with initial status.
+1. Read `.agents/state/memories/task-board.md` to confirm your assigned task when it exists.
+2. Create `.agents/state/memories/progress-{agent-id}[-{sessionId}].md` with initial status.
 
 ## During Execution
 
@@ -37,7 +36,7 @@ All result, progress, and state files MUST be written to the **project root** `.
 
 ## On Completion
 
-- Create `.serena/memories/result-{agent-id}[-{sessionId}].md` with final result including:
+- Create `.agents/state/memories/result-{agent-id}[-{sessionId}].md` with final result including:
   - A status line — see **Status line format** below (REQUIRED)
   - Summary of work done
   - Files created/modified
diff --git a/.agents/skills/_shared/runtime/execution-protocols/qwen.md b/.agents/skills/_shared/runtime/execution-protocols/qwen.md
index d329de2..bbf4d99 100644
--- a/.agents/skills/_shared/runtime/execution-protocols/qwen.md
+++ b/.agents/skills/_shared/runtime/execution-protocols/qwen.md
@@ -2,14 +2,15 @@
 
 When running as a CLI subagent, follow this protocol for shared state coordination.
 
-## MCP Memory Tools
+## Memory Tools
 
-Tool names are configurable via `mcp.json → memoryConfig.tools`:
-- `[READ]` → default: `read_memory`
-- `[WRITE]` → default: `write_memory`
-- `[EDIT]` → default: `edit_memory`
+Coordination artifacts are read and written as plain files with your native file tools.
+Tool names remain configurable via `mcp.json → memoryConfig.tools`:
+- `[READ]` → default: `Read`
+- `[WRITE]` → default: `Write`
+- `[EDIT]` → default: `Edit`
 
-Memory base path is configurable via `memoryConfig.basePath` (default: `.serena/memories`).
+Memory base path is configurable via `memoryConfig.basePath` (default: `.agents/state/memories`). Create the directory if it does not yet exist.
 
 ### Path Resolution (CRITICAL)
 
diff --git a/.agents/skills/_shared/runtime/memory-protocol.md b/.agents/skills/_shared/runtime/memory-protocol.md
index 6d85f10..2c99073 100644
--- a/.agents/skills/_shared/runtime/memory-protocol.md
+++ b/.agents/skills/_shared/runtime/memory-protocol.md
@@ -1,19 +1,20 @@
 # Memory Protocol (CLI Mode)
 
-> **Note**: This file documents the default (Serena/MCP) memory protocol. Vendor-specific execution protocols are injected automatically by `oma agent:spawn` from `execution-protocols/{vendor}.md`.
+> **Note**: This file documents the default (direct-file) memory protocol. Vendor-specific execution protocols are injected automatically by `oma agent:spawn` from `execution-protocols/{vendor}.md`.
 
 When running as a CLI subagent, follow this protocol.
 
 ## Tool Reference
 
-Tool names are configurable via `mcp.json → memoryConfig.tools`:
-- `[READ]` → default: `read_memory`
-- `[WRITE]` → default: `write_memory`
-- `[EDIT]` → default: `edit_memory`
-- `[LIST]` → default: `list_memories`
-- `[DELETE]` → default: `delete_memory`
+Coordination artifacts are read and written as plain files using your native file tools.
+Tool names remain configurable via `mcp.json → memoryConfig.tools`:
+- `[READ]` → default: `Read`
+- `[WRITE]` → default: `Write`
+- `[EDIT]` → default: `Edit`
+- `[LIST]` → default: directory listing (e.g. `ls` / `list_dir`)
+- `[DELETE]` → default: file delete (e.g. `rm`)
 
-Memory base path is configurable via `memoryConfig.basePath` (default: `.serena/memories`).
+Memory base path is configurable via `memoryConfig.basePath` (default: `.agents/state/memories`). Create the directory if it does not yet exist.
 
 ---
 
@@ -84,18 +85,18 @@ See `../conditional/experiment-ledger.md` for full format and analysis protocol.
 
 ---
 
-## Example with Default Tools (Serena)
+## Example with Default Tools (Direct File)
 
-```python
+```
 # On Start
-read_memory("task-board.md")
-write_memory("progress-backend-session-20260405-100835.md", initial_content)
+Read(".agents/state/memories/task-board.md")
+Write(".agents/state/memories/progress-backend-session-20260405-100835.md", initial_content)
 
 # During Execution
-edit_memory("progress-backend-session-20260405-100835.md", turn_update)
+Edit(".agents/state/memories/progress-backend-session-20260405-100835.md", turn_update)
 
 # On Completion
-write_memory("result-backend-session-20260405-100835.md", final_result)
+Write(".agents/state/memories/result-backend-session-20260405-100835.md", final_result)
 ```
 
 ## Example with Custom Tools
diff --git a/.agents/skills/_version.json b/.agents/skills/_version.json
index 3995806..9449f54 100644
--- a/.agents/skills/_version.json
+++ b/.agents/skills/_version.json
@@ -1,6 +1,6 @@
 {
-  "version": "10.10.0",
+  "version": "10.17.2",
   "schemaVersion": 2,
   "mode": "project",
-  "installedAt": "2026-07-06T12:39:22.805Z"
+  "installedAt": "2026-07-13T11:54:28.552Z"
 }
diff --git a/.agents/skills/oma-architecture/SKILL.md b/.agents/skills/oma-architecture/SKILL.md
index 754850d..a3f208f 100644
--- a/.agents/skills/oma-architecture/SKILL.md
+++ b/.agents/skills/oma-architecture/SKILL.md
@@ -14,6 +14,7 @@ Analyze, compare, and document software architecture decisions with explicit tra
 - User asks for architecture, system design, module/service boundaries, ADRs, or design tradeoffs.
 - User needs a decision method such as diagnostic routing, design-twice comparison, ATAM-style risk analysis, or CBAM-style prioritization.
 - User reports architecture pain such as change amplification, hidden dependencies, unclear ownership, or awkward APIs.
+- User needs an API versioning, deprecation, or published-contract evolution strategy.
 
 ### When to use
 - Choosing or reviewing system architecture
@@ -22,6 +23,7 @@ Analyze, compare, and document software architecture decisions with explicit tra
 - Investigating architectural pain: change amplification, hidden dependencies, awkward APIs
 - Prioritizing architecture investments or refactors
 - Writing architecture recommendations or ADRs
+- Deciding API versioning, deprecation windows, and published-contract evolution strategy
 
 ### When NOT to use
 - Visual design, design systems, branding, or landing pages -> use oma-design
@@ -54,6 +56,7 @@ outputs:
 - `resources/methodology-selection.md` for method choice
 - `resources/stakeholder-synthesis.md` when cross-cutting stakeholder consultation is justified
 - `resources/output-templates.md` for final artifact shapes
+- `resources/api-evolution.md` for published-contract versioning/deprecation decisions (MAP evolution patterns)
 
 ### Control-flow features
 - Branches by request clarity, decision materiality, risk level, and need for stakeholder consultation
@@ -164,6 +167,7 @@ Before submitting, run `resources/checklist.md`.
 - Method selection: `resources/methodology-selection.md`
 - Stakeholder protocol: `resources/stakeholder-synthesis.md`
 - Output templates: `resources/output-templates.md`
+- API evolution patterns (versioning, deprecation, lifecycle guarantees): `resources/api-evolution.md`
 - Context loading: `../_shared/core/context-loading.md`
 - Difficulty guide: `../_shared/core/difficulty-guide.md`
 - Reasoning templates: `../_shared/core/reasoning-templates.md`
diff --git a/.agents/skills/oma-architecture/resources/api-evolution.md b/.agents/skills/oma-architecture/resources/api-evolution.md
new file mode 100644
index 0000000..3e1d4fd
--- /dev/null
+++ b/.agents/skills/oma-architecture/resources/api-evolution.md
@@ -0,0 +1,41 @@
+# API Evolution - Versioning and Deprecation Decision Patterns
+
+> Pattern vocabulary from Microservice API Patterns (MAP - Zimmermann, Stocker, Lübke, Pautasso, Zdun; "Patterns for API Design"). Use in Recommendation or ADR mode when the decision concerns a **published API contract** with consumers the provider does not control. `oma-refactor` routes here when an expand-contract refactoring crosses a published-contract boundary.
+
+## When this file applies
+- Choosing a versioning scheme for a public, partner, or cross-team API
+- Deciding how long old versions live and how consumers migrate off them
+- Writing the ADR for a breaking change to a published contract
+- Reviewing an expand-contract plan whose "contract" phase removes something external consumers may use
+
+## Core tension
+The provider wants freedom to change; consumers want stability. Every pattern below is a **named position on that tradeoff**. An API evolution ADR must state which guarantee is being sold, to whom, and when it expires - Hyrum's Law means anything observable is part of the de-facto contract regardless of what the docs promise.
+
+## Versioning patterns
+| Pattern | Decision | Notes |
+|---------|----------|-------|
+| Version Identifier | Make the version explicit in the contract (URL path, media type, header, or payload field) | Prerequisite for every lifecycle pattern below; "no version marker" is itself a decision (forces Eternal Lifetime or breakage) |
+| Semantic Versioning | MAJOR.MINOR.PATCH signals whether a change breaks, extends, or fixes | Only MAJOR needs a migration decision; publish the compatibility rules, not just the numbers |
+
+## Lifecycle guarantee patterns
+| Pattern | Promise to consumers | Choose when |
+|---------|----------------------|-------------|
+| Experimental Preview | None - may change or vanish without notice | Pre-GA feedback gathering; keeps early adopters off your back-compat hook |
+| Aggressive Obsolescence | Old versions deprecated quickly with published sunset dates | Provider velocity dominates; few, reachable consumers |
+| Limited Lifetime Guarantee | Each version supported for a fixed window (e.g., 24 months from publication) | B2B defaults; lets consumers budget migrations |
+| Two in Production | Exactly N (typically 2) versions live concurrently; shipping version N+1 retires N-1 | Rolling migration with a bounded support burden - the workhorse for internal and partner APIs |
+| Eternal Lifetime Guarantee | Published contracts never break | Huge or unknown consumer base (public web APIs); the most expensive promise - make it deliberately or not at all |
+
+## Decision guidance
+- Internal service-to-service default: **Two in Production + Semantic Versioning + Version Identifier**. It bounds support cost while never forcing a consumer to migrate under fire.
+- Deprecation is a protocol, not an event: announce with sunset date -> run old+new concurrently (the expand phase) -> drive migration with telemetry on old-version traffic -> contract only when traffic is zero or the sunset date passes, whichever the guarantee dictates.
+- The guarantee is set at **publication time**: retrofitting a shorter lifetime onto an already-published version is itself a breaking change to the meta-contract.
+- Telemetry precondition: if you cannot measure per-version consumer traffic, you cannot safely run anything more aggressive than Eternal Lifetime - instrument first.
+- The wider MAP catalog (foundation, responsibility, structure, and quality patterns: Pagination, Wish List, Rate Limit, API Key, ...) covers API *design*; this file deliberately scopes to *evolution*, which is where refactoring and architecture meet.
+
+## ADR checklist for a published-contract change
+- What lifetime guarantee did the old version's publication imply (explicitly or by Hyrum)?
+- Who consumes it today (telemetry, not assumption), and what is migration cost per consumer class?
+- Which lifecycle pattern governs the transition, and what are the announced sunset dates and channels?
+- Can old and new run concurrently during migration (Two in Production / expand phase), and what is the rollback path?
+- How will old-version traffic be monitored to zero before the contract phase?
diff --git a/.agents/skills/oma-backend/SKILL.md b/.agents/skills/oma-backend/SKILL.md
index 6c32f3f..23f884b 100644
--- a/.agents/skills/oma-backend/SKILL.md
+++ b/.agents/skills/oma-backend/SKILL.md
@@ -39,7 +39,9 @@ Implement or review backend APIs, authentication, database integration, server-s
 ### Dependencies
 - Project stack manifests and existing backend conventions
 - `resources/execution-protocol.md`, `resources/checklist.md`, and `resources/orm-reference.md`
+<!-- oma-docs:ignore-start -->
 - Optional `stack/stack.yaml`, `stack/tech-stack.md`, snippets, and API templates
+<!-- oma-docs:ignore-end -->
 - Database, queue, cache, mail, auth, or external API resources configured through environment or secret managers
 
 ### Control-flow features
@@ -103,7 +105,9 @@ rg --files
 rg "route|router|service|repository|model|schema|migration" .
 ```
 
+<!-- oma-docs:ignore-start -->
 Then run the project's discovered verification commands, usually lint/typecheck/tests and migrations when schema changes are involved. Prefer `stack/stack.yaml` `verify:` commands when present.
+<!-- oma-docs:ignore-end -->
 
 ### Resource scope
 | Scope | Resource target |
@@ -174,10 +178,12 @@ Router (HTTP) → Service (Business Logic) → Repository (Data Access) → Mode
 
 ### Stack-Specific Reference
 
+<!-- oma-docs:ignore-start -->
 - **Stack manifest (SSOT)**: `stack/stack.yaml`: structured declaration (`language`, `framework`, `orm`) and `verify:` contract consumed by `oma verify backend`. Schema: `variants/stack.schema.json`.
 - Tech stack narrative: `stack/tech-stack.md`: human-readable reference only; `stack.yaml` wins on conflict.
 - Code snippets (copy-paste ready): `stack/snippets.md`
 - API template: `stack/api-template.*`
+<!-- oma-docs:ignore-end -->
 
 ## References
 
diff --git a/.agents/skills/oma-debug/resources/bug-report-template.md b/.agents/skills/oma-debug/resources/bug-report-template.md
index ebc9527..639bf4a 100644
--- a/.agents/skills/oma-debug/resources/bug-report-template.md
+++ b/.agents/skills/oma-debug/resources/bug-report-template.md
@@ -1,3 +1,7 @@
+---
+oma-docs: skip
+---
+
 # Bug Report Template
 
 Use this template when documenting bugs in the Knowledge Base.
diff --git a/.agents/skills/oma-deepsec/SKILL.md b/.agents/skills/oma-deepsec/SKILL.md
index 88e0817..b019ce8 100644
--- a/.agents/skills/oma-deepsec/SKILL.md
+++ b/.agents/skills/oma-deepsec/SKILL.md
@@ -211,10 +211,14 @@ Operate Vercel's `deepsec` security scanner inside a target repository safely an
 
 ### Effects and side effects
 - Creates `.deepsec/` (config, lockfile, scaffolding) and `.deepsec/data/<id>/` (gitignored) inside the target repo.
+<!-- oma-docs:ignore-start -->
 - Writes `.env.local` (never commit) and may run `vercel link` / `vercel env pull` (writes `.vercel/project.json` + token).
+<!-- oma-docs:ignore-end -->
 - Spawns long-running AI processes that **cost real money**. Single full scans range from $25 to over $1,200 per the official cost guide and can climb to tens of thousands on very large repos.
 - Reads source code; sends snippets to the configured LLM (gateway = zero retention; direct provider = subject to that provider's policy). Never exfiltrates secrets; the gateway key stays outside the worker sandbox in `sandbox` mode.
+<!-- oma-docs:ignore-start -->
 - May write `.github/workflows/deepsec.yml` (or analogue) when the user asks for a CI gate.
+<!-- oma-docs:ignore-end -->
 - Edits `deepsec.config.ts` and adds `.deepsec/matchers/*.ts` when authoring matchers.
 - Does not commit, push, or open PRs unless the user explicitly authorizes a separate commit step (route via `oma-scm`).
 
diff --git a/.agents/skills/oma-deepsec/resources/config.md b/.agents/skills/oma-deepsec/resources/config.md
index 7fe33d1..ef457e2 100644
--- a/.agents/skills/oma-deepsec/resources/config.md
+++ b/.agents/skills/oma-deepsec/resources/config.md
@@ -16,10 +16,13 @@ export default defineConfig({
 });
 ```
 
+<!-- oma-docs:ignore-start -->
 For a fully-worked example exercising every common field (`infoMarkdown`, `promptAppend`, `priorityPaths`, an inline plugin), see `samples/webapp/deepsec.config.ts` in the deepsec repo.
+<!-- oma-docs:ignore-end -->
 
 ## Top-level fields
 
+<!-- oma-docs:ignore-start -->
 | Field | Type | Purpose |
 |---|---|---|
 | `projects` | `ProjectDeclaration[]` | Codebases deepsec knows about. |
@@ -27,6 +30,7 @@ For a fully-worked example exercising every common field (`infoMarkdown`, `promp
 | `matchers` | `{ only?: string[]; exclude?: string[] }` | Filter the matcher set used by `scan`. |
 | `defaultAgent` | `"claude" | "codex"` | Default `--agent` value. |
 | `dataDir` | `string` | Override the `data/` directory. Defaults to `./data`. |
+<!-- oma-docs:ignore-end -->
 
 ## `ProjectDeclaration`
 
@@ -175,6 +179,7 @@ The Sandbox SDK reads these directly from `process.env` at `Sandbox.create()` ti
 
 ## Troubleshooting
 
+<!-- oma-docs:ignore-start -->
 | Symptom | Cause | Fix |
 |---|---|---|
 | `Missing AI credentials for --agent claude|codex` | No credential present. | Set `AI_GATEWAY_API_KEY=vck_…` in `.env.local`, or `claude login` / `codex login`. |
@@ -187,6 +192,7 @@ The Sandbox SDK reads these directly from `process.env` at `Sandbox.create()` ti
 | Sandbox spawn fails with auth error | OIDC expired or access-token vars wrong. | `vercel env pull`, or verify the three access-token vars. |
 | Findings missing cost in the log | Pricing entry missing for a non-default Codex model. | Add a line to `MODEL_PRICING_USD_PER_M_TOKENS` in `packages/processor/src/agents/codex-sdk.ts` (only matters if you are extending deepsec itself). |
 | Persistent refusal on a single file (>5 % of batches) | Hard-to-disambiguate exploit pattern. | Add to `data/<id>/config.json:ignorePaths`, or run with `--batch-size 1`. |
+<!-- oma-docs:ignore-end -->
 
 After **any** quota / credit fix, `process` and `revalidate` resume on re-run. No recovery flag, no state to reset. Files already analyzed stay analyzed; only unfinished ones get picked up. Use `--reinvestigate` (process) or `--force` (revalidate) only when you specifically want to redo finished work.
 
diff --git a/.agents/skills/oma-design/resources/getdesign-fetcher.md b/.agents/skills/oma-design/resources/getdesign-fetcher.md
index 6b0e0e1..4fb121a 100644
--- a/.agents/skills/oma-design/resources/getdesign-fetcher.md
+++ b/.agents/skills/oma-design/resources/getdesign-fetcher.md
@@ -166,12 +166,14 @@ After reading the file into the Claude session, delete the temp:
 rm -f "${TMPDIR:-/tmp}/oma-seed-<brand>-$$.md"
 ```
 
+<!-- oma-docs:ignore-start -->
 **Telemetry verification (one-time)**: the CLI source
 (`src/cli.mjs`) checks `GETDESIGN_DISABLE_TELEMETRY` for values
 `1`, `true`, `yes`. Any of those disables the POST to
 `https://getdesign.md/api/cli/downloads`. The env var must be exported
 or prefixed in the same command line; do not set it in a prior
 statement and assume persistence across sessions.
+<!-- oma-docs:ignore-end -->
 
 ## Integrity Verification
 
diff --git a/.agents/skills/oma-docs/SKILL.md b/.agents/skills/oma-docs/SKILL.md
index 244d7e0..d3c0aa6 100644
--- a/.agents/skills/oma-docs/SKILL.md
+++ b/.agents/skills/oma-docs/SKILL.md
@@ -219,7 +219,7 @@ oma docs verify --json
 7. **No direct LLM API calls from the CLI**: the CLI never imports vendor SDKs, never reads API keys, never makes outbound LLM requests. All synthesis, patch drafting, and natural-language framing is the host LLM's responsibility (mirrors `oma-scholar`'s pattern). This makes `oma-docs` vendor-agnostic: works identically under Claude Code / Codex / Gemini / Qwen / Antigravity.
 8. **Hook is warn-only in v1**: broken refs never block workflow completion; `docs.auto_verify: false` by default (explicit opt-in required).
 9. **Escape hatch respected**: `<!-- oma-docs:ignore-start -->` / `<!-- oma-docs:ignore-end -->` blocks and frontmatter `oma-docs: skip` are honored; no ref extraction from ignored regions. Use this for illustrative example paths in tutorials (hypothetical project files in inline code) that intentionally do not resolve.
-10. **Gitignored targets are generated, not broken**: a `file` ref whose target does not exist but matches the project's gitignore rules (`git check-ignore`) is classified as `skipped` (a documented runtime/generated output such as `.agents/results/result-*.md`, `.serena/memories/*`, `.agents/state/*.json`), never as `broken`. gitignore is the single source of truth for "produced at runtime" — gitignore an output path and it stops being flagged. The `skipped` count is surfaced (markdown summary + JSON `skippedCount`) so nothing is silently dropped.
+10. **Gitignored targets are generated, not broken**: a `file` ref whose target does not exist but matches the project's gitignore rules (`git check-ignore`) is classified as `skipped` (a documented runtime/generated output such as `.agents/results/result-*.md`, `.agents/state/memories/*`, `.serena/memories/*`, `.agents/state/*.json`), never as `broken`. gitignore is the single source of truth for "produced at runtime" — gitignore an output path and it stops being flagged. The `skipped` count is surfaced (markdown summary + JSON `skippedCount`) so nothing is silently dropped.
 11. **Non-prose trees excluded via `docs.exclude`**: committed-but-non-prose markdown (benchmark run artifacts, translation mirrors validated separately by `oma docs i18n`) is dropped from the scan by the `docs.exclude` globs rather than producing unactionable broken refs. An explicit single-file path argument bypasses `docs.exclude`.
 
 ### v1 scope note
diff --git a/.agents/skills/oma-frontend/SKILL.md b/.agents/skills/oma-frontend/SKILL.md
index 6250f77..5bcc17a 100644
--- a/.agents/skills/oma-frontend/SKILL.md
+++ b/.agents/skills/oma-frontend/SKILL.md
@@ -169,7 +169,9 @@ React/Next.js projects only — Angular projects use the Angular-native equivale
 
 - **Usage**: Prefer strict shadcn primitives (`Card`, `Sheet`, `Typography`, `Table`) over `div` or generic classes.
 - **Responsiveness**: Use `Drawer` (mobile) vs `Dialog` (desktop) via `useResponsive`.
+<!-- oma-docs:ignore-start -->
 - **Customization**: Treat `components/ui/*` as read-only. Create wrappers (e.g., `components/common/ProductButton.tsx`) or use `cva` composition. Never edit `components/ui/button.tsx` directly.
+<!-- oma-docs:ignore-end -->
 
 ### Sources of Truth
 
diff --git a/.agents/skills/oma-frontend/resources/checklist.md b/.agents/skills/oma-frontend/resources/checklist.md
index be3cad5..52f60a2 100644
--- a/.agents/skills/oma-frontend/resources/checklist.md
+++ b/.agents/skills/oma-frontend/resources/checklist.md
@@ -4,7 +4,9 @@ Run through every item before submitting your work.
 
 ## Next.js 16 Conventions
 - [ ] Request-proxy/auth-gate file is named `proxy.ts` (NOT `middleware.ts`) and exports `proxy` (NOT `middleware`)
+<!-- oma-docs:ignore-start -->
 - [ ] Do NOT flag `src/proxy.ts` as dead code or recommend renaming to `middleware.ts`; `proxy.ts` is the canonical Next.js 16+ convention
+<!-- oma-docs:ignore-end -->
 - [ ] Config flags use the `Proxy` form (e.g. `skipProxyUrlNormalize`), not the legacy `Middleware` form
 
 ## TypeScript
diff --git a/.agents/skills/oma-frontend/resources/error-playbook.md b/.agents/skills/oma-frontend/resources/error-playbook.md
index 4e437ec..92b0cdd 100644
--- a/.agents/skills/oma-frontend/resources/error-playbook.md
+++ b/.agents/skills/oma-frontend/resources/error-playbook.md
@@ -7,7 +7,9 @@ Do NOT stop or ask for help until you have exhausted the playbook.
 
 ## False Positive: `proxy.ts` flagged as dead code or `middleware.ts` demanded
 
+<!-- oma-docs:ignore-start -->
 **Symptoms**: Reviewer claims `src/proxy.ts` won't be picked up, demands rename to `src/middleware.ts`, or flags the auth gate as not wired.
+<!-- oma-docs:ignore-end -->
 
 1. **STOP. This is a fatal self-error.** Next.js 16+ renamed `middleware.ts` → `proxy.ts`.
 2. The canonical request-proxy / auth-gate file is `proxy.ts` (root or `src/`) exporting a `proxy` function.
diff --git a/.agents/skills/oma-frontend/resources/tech-stack.md b/.agents/skills/oma-frontend/resources/tech-stack.md
index a268537..04fc051 100644
--- a/.agents/skills/oma-frontend/resources/tech-stack.md
+++ b/.agents/skills/oma-frontend/resources/tech-stack.md
@@ -59,7 +59,9 @@ Bootstrap with `npx shadcn create` (prompts for the engine) or `npx shadcn init`
 - File: `middleware.ts` → `proxy.ts` (root or `src/`)
 - Exported function: `middleware` → `proxy`
 - Config flags: `skipMiddlewareUrlNormalize` → `skipProxyUrlNormalize`, etc.
+<!-- oma-docs:ignore-start -->
 - `src/proxy.ts` is the canonical request-proxy / auth-gate location
+<!-- oma-docs:ignore-end -->
 
 Forbidden actions (any of these is a fatal self-error; retract immediately):
 
diff --git a/.agents/skills/oma-market/SKILL.md b/.agents/skills/oma-market/SKILL.md
index 61b0d9c..f5580df 100644
--- a/.agents/skills/oma-market/SKILL.md
+++ b/.agents/skills/oma-market/SKILL.md
@@ -1,6 +1,6 @@
 ---
 name: oma-market
-description: "Market research skill for pain-point extraction, trend detection, competitor positioning, and discovery across community sources (Reddit, HN, Bluesky, Mastodon, GitHub Issues, web). Routes via oma-search transport, deterministic CLI compute, intent-auto SWOT/Porter's 5F/PESTEL frameworks. Use for market research, pain point analysis, trend detection, competitor research, user complaints, voice-of-customer, 시장조사, 사용자 페인, 트렌드, 경쟁구도."
+description: "Market research skill for pain-point extraction, trend detection, competitor positioning, and discovery across community sources (Reddit, HN, Bluesky, Mastodon, GitHub Issues, web). Built-in harvest fetchers, deterministic CLI compute, intent-auto SWOT/Porter's 5F/PESTEL frameworks. Use for market research, pain point analysis, trend detection, competitor research, user complaints, voice-of-customer, 시장조사, 사용자 페인, 트렌드, 경쟁구도."
 ---
 
 # Market Research Agent - Community Signal Intelligence
@@ -8,7 +8,7 @@ description: "Market research skill for pain-point extraction, trend detection,
 ## Scheduling
 
 ### Goal
-Classify user intent into pain / trend / competitor / discovery, fan-out to community sources via `oma search fetch`, score and cluster findings with deterministic CLI compute, auto-apply strategic frameworks, and emit a single LAW-compliant markdown brief.
+Classify user intent into pain / trend / competitor / discovery, fan-out to community sources via `oma market harvest`, score and cluster findings with deterministic CLI compute, auto-apply strategic frameworks, and emit a single LAW-compliant markdown brief.
 
 ### Intent signature
 - User asks about pain points, user complaints, or voice-of-customer signals for a product or category.
@@ -41,14 +41,13 @@ Classify user intent into pain / trend / competitor / discovery, fan-out to comm
 - No raw evidence dump; no Sources block; no em-dash; no `##` in body (framework/COMPARISON sections excepted)
 
 ### Dependencies
-- `oma-search` for all fetches (`oma search fetch --only api`); never fetches directly
-- Serena `trust-registry-cache` (read-only); Trust Registry labels inherited from oma-search
+- `oma market harvest` built-in per-source fetchers (all network I/O stays inside harvest)
 - `resources/intent-rules.md`, `resources/operator-packs/`, `resources/output-laws.md`
 
 ### Control-flow features
 - Branches by classified intent, window, source availability, and env key presence
 - detect-trap gate before harvest (exit 2 on broad/ambiguous topic, exit 4 on invalid)
-- Paid sources (X, TikTok, Instagram, YouTube, Perplexity) auto-skip when env key absent
+- Env-keyed sources (X, TikTok, Instagram, Perplexity) auto-skip when env key absent; YouTube joins when `yt-dlp` is installed
 - Framework auto-toggle by intent (see Routes table)
 
 ## Structural Flow
@@ -60,7 +59,7 @@ Classify user intent into pain / trend / competitor / discovery, fan-out to comm
 
 ### Scenes
 1. **PREPARE**: Parse topic and flags; run detect-trap; resolve intent, operator pack, window.
-2. **ACT**: Build per-source `oma search fetch` URLs with operator pack query expansion.
+2. **ACT**: Build per-source harvest queries with operator pack query expansion.
 3. **ACQUIRE**: Fan-out harvest via `oma market harvest` (parallel, per-source-limit 12, cache TTL 15m).
 4. **VERIFY**: Score, fuse, and cluster candidates; validate JSON at each pipe stage.
 5. **FINALIZE**: Render LAW-compliant markdown brief; run self-check; write to output path.
@@ -74,10 +73,10 @@ Classify user intent into pain / trend / competitor / discovery, fan-out to comm
 
 ### Failure and recovery
 - detect-trap exit 2: surface REFUSE reason and suggested reframe; do not proceed to harvest.
-- Network timeout (exit 6): report and suggest `--window` reduction or `--no-cache`.
+- Per-source timeout or fetch failure: source lands in `sources_failed`; harvest exits 2 only when all sources fail.
 - Invalid JSON from any pipe stage: exit 4 with offending line in stderr.
-- Render LAW self-check violation: strip or regenerate; exit 1 only if regeneration also fails.
-- FS permission denied at write: exit 5.
+- Render LAW self-check violation: auto-fixable LAWs are repaired in place; unfixable violations are annotated in the doc and exit 1.
+- Render error (invalid input JSON, write failure incl. FS permission denied): exit 4 with the error in stderr.
 
 ### Exit
 - Success: brief file written; first 50 lines previewed; engine footer present.
@@ -91,7 +90,7 @@ Classify user intent into pain / trend / competitor / discovery, fan-out to comm
 | Run detect-trap preflight | `VALIDATE` | Topic arg, trap pattern rules |
 | Classify intent | `SELECT` | Intent rules, user flags |
 | Select operator pack | `SELECT` | `resources/operator-packs/` |
-| Fan-out harvest | `CALL_TOOL` | `oma market harvest` -> `oma search fetch` |
+| Fan-out harvest | `CALL_TOOL` | `oma market harvest` built-in per-source fetchers |
 | Score candidates | `INFER` | Engagement weights, freshness, intent blends |
 | Fuse and deduplicate | `INFER` | URL canonicalize, RRF k=60, author cap |
 | Cluster by entity overlap | `INFER` | Overlap coefficient >= 0.4, MMR lambda=0.75 |
@@ -102,7 +101,8 @@ Classify user intent into pain / trend / competitor / discovery, fan-out to comm
 
 ### Tools and instruments
 - `oma market detect-trap` (preflight gate)
-- `oma market harvest` (delegates to `oma search fetch --only api`)
+- `oma market discover-competitors` (auto-discover peer entities for a topic; feeds `--vs` in competitor mode)
+- `oma market harvest` (fan-out via built-in per-source fetchers)
 - `oma market score` (engagement weights, log1p, intent blends)
 - `oma market fuse` (URL canonical, RRF, diversity guard)
 - `oma market cluster` (entity overlap, MMR)
@@ -113,7 +113,7 @@ Classify user intent into pain / trend / competitor / discovery, fan-out to comm
 TOPIC="VS Code pain points"
 oma market detect-trap "$TOPIC" \
   && oma market harvest "vscode (broken OR bug OR migrate OR quit OR slow)" \
-       --sources reddit,hn,bluesky,mastodon,github-issues --window 30d \
+       --sources reddit,hn,bluesky,mastodon,github --window 30d \
        --operator-pack pain \
   | oma market score --intent pain \
   | oma market fuse \
@@ -124,29 +124,27 @@ oma market detect-trap "$TOPIC" \
 ### Resource scope
 | Scope | Resource target |
 |-------|-----------------|
-| `NETWORK` | Community sources via `oma search fetch` (reddit, hn, bluesky, mastodon, github-issues, grounding) |
+| `NETWORK` | Community sources via harvest's built-in fetchers (reddit, hn, bluesky, mastodon, github, grounding; youtube via `yt-dlp`) |
 | `LOCAL_FS` | Brief output at `.agents/results/market/`; cache at `~/.cache/oma/market/` |
-| `PROCESS` | `oma market` subcommands; `oma search fetch` |
+| `PROCESS` | `oma market` subcommands |
 | `MEMORY` | Intent classification, operator pack selection, cluster summaries |
 
 ### Preconditions
 - Topic is non-empty and passes detect-trap (not demographic-shopping, not single-noun-too-broad).
-- At least one keyless source is reachable (reddit, hn, bluesky, mastodon, github-issues, or grounding).
+- At least one keyless source is reachable (reddit, hn, bluesky, mastodon, github, or grounding).
 
 ### Effects and side effects
 - Writes brief markdown to `.agents/results/market/{topic-slug}-{YYYYMMDD}.md`.
-- Populates local cache at `~/.cache/oma/market/{sha1-hash}/result.json` (TTL 15m).
-- Reads Serena `trust-registry-cache` (no write).
+- Populates local cache at `~/.cache/oma/market-research/{sha256-16hex}/result.json` (TTL 15m).
 
 ### Guardrails
 1. **detect-trap first**: never harvest without preflight; `--force` bypasses only in test mode.
-2. **Delegate all fetches**: `harvest` calls `oma search fetch --only api`; no direct platform HTTP.
-3. **Trust labels read-only**: no re-scoring; Trust Registry ownership stays with `oma-search`.
-4. **Paid sources auto-skip**: drop silently with `[INFO]` stderr if env key absent; never error.
-5. **LAW self-check mandatory**: render runs self-check before file write; `--no-self-check` for debug only.
-6. **No raw evidence dump**: cluster internals (scores, item counts) stay in JSON output; markdown body paraphrases.
-7. **Stdout pure JSON per stage**: each pipe stage (except render) emits valid JSON only; stderr for warnings.
-8. **No Serena writes in v1**: `trust-registry-cache` is read-only; write authority stays with `oma-search`.
+2. **Fetches stay inside harvest**: all network I/O happens in `oma market harvest`'s per-source fetchers; no direct platform HTTP from other stages or the agent.
+3. **Env-keyed sources auto-skip**: dropped with a `[harvest] <source> skipped:` stderr notice when the env key is absent; never a hard error. X/TikTok/Instagram/Perplexity fetchers are deferred stubs pending integration and land in `sources_failed` even when keyed.
+4. **LAW self-check mandatory**: render runs self-check before file write; `--no-self-check` for debug only.
+5. **No raw evidence dump**: cluster internals (scores, item counts) stay in JSON output; markdown body paraphrases.
+6. **Stdout pure JSON per stage**: each pipe stage (except render) emits valid JSON only; stderr for warnings.
+7. **Personal data refuse**: refuse private-individual PII queries at the agent level before harvest (detect-trap automates demographic-shopping and overly-broad-topic refusal only).
 
 ### Routes
 
@@ -154,10 +152,10 @@ oma market detect-trap "$TOPIC" \
 |--------|--------------|-----------------|-------|
 | `pain` | `resources/operator-packs/pain.md` | SWOT | Weights: engagement 0.40, freshness 0.30, quality 0.30 |
 | `trend` | none (optional: `resources/operator-packs/positive.md` for pain/positive contrast) | SWOT | Weights: freshness 0.50, engagement 0.30, quality 0.20 |
-| `competitor` | `resources/operator-packs/competitor.md` | SWOT + Porter's 5F (v1.1 stub) | Weights: relevance 0.35, engagement 0.35, quality 0.30; `--vs` enables COMPARISON template |
-| `discovery` | `resources/operator-packs/discovery.md` | SWOT + PESTEL (v1.1 stub) | Weights: relevance 0.45, engagement 0.30, quality 0.25 |
+| `competitor` | `resources/operator-packs/competitor.md` | SWOT + Porter's 5F | Weights: relevance 0.35, engagement 0.35, quality 0.30; `--vs` enables COMPARISON template; `discover-competitors` can suggest the `--vs` entity |
+| `discovery` | `resources/operator-packs/discovery.md` | SWOT + PESTEL | Weights: relevance 0.45, engagement 0.30, quality 0.25 |
 
-Porter's 5F and PESTEL: the CLI renders empty framework slots; the host LLM fills them using the analyst prompts in `resources/frameworks/porters-5f.md` and `pestel.md` (execution-protocol Step 6).
+Porter's 5F and PESTEL: the CLI renders complete labeled framework skeletons (all 5 forces / all 6 dimensions); the host LLM fills them using the analyst prompts in `resources/frameworks/porters-5f.md` and `pestel.md` (execution-protocol Step 6).
 
 ### Default Workflow
 1. **Preflight**: `oma market detect-trap` exits 0 or halts.
diff --git a/.agents/skills/oma-market/resources/error-playbook.md b/.agents/skills/oma-market/resources/error-playbook.md
index b5d5e87..acbaec4 100644
--- a/.agents/skills/oma-market/resources/error-playbook.md
+++ b/.agents/skills/oma-market/resources/error-playbook.md
@@ -5,7 +5,7 @@
 Cause: Every configured source returned 429, 403, or auth failure.
 
 Recovery steps:
-1. Check paid-source env keys if those sources were requested (X_BEARER_TOKEN, SCRAPECREATORS_API_KEY, PERPLEXITY_API_KEY; GITHUB_TOKEN raises github-issues rate limits). reddit, hn, bluesky, mastodon, and grounding are keyless.
+1. Check env keys if keyed sources were requested (X_BEARER_TOKEN, SCRAPECREATORS_API_KEY, PERPLEXITY_API_KEY; GITHUB_TOKEN raises github rate limits). reddit, hn, bluesky, mastodon, github, and grounding are keyless.
 2. Retry with `--window 90d` to widen the harvest window (more cache-eligible content).
 3. Try `--sources reddit` to isolate a single known-working source.
 4. If all sources are blocked, the run cannot proceed. Report to user:
@@ -15,9 +15,9 @@ All configured sources are currently unavailable. Check your API keys or try aga
 Use --sources to restrict to a source you know is accessible.
 ```
 
-## harvest exit 6 - Timeout
+## harvest per-source timeout
 
-Cause: One or more source adapters exceeded the per-request time limit.
+Cause: One or more source adapters exceeded the per-request time limit. Timed-out sources land in `sources_failed`; harvest still exits 0 while at least one source succeeds (exit 2 only when all fail).
 
 Recovery steps:
 1. Reduce result set with `--per-source-limit 6` (default is 12).
diff --git a/.agents/skills/oma-market/resources/output-laws.md b/.agents/skills/oma-market/resources/output-laws.md
index 63a93ff..7bcad29 100644
--- a/.agents/skills/oma-market/resources/output-laws.md
+++ b/.agents/skills/oma-market/resources/output-laws.md
@@ -10,7 +10,7 @@ LAWs apply to every QUERY_TYPE except where an explicit COMPARISON exception is
 
 Do not append `Sources:`, `References:`, `Further reading:`, `Citations:`, or any bulleted list of publication names / handles / URLs after the closing line of the brief. The engine footer is the only visible citation list. The saved raw JSON sidecar (when emitted) is the durable record.
 
-**Self-check**: scan the last 15 lines for `^Sources:`, `^References:`, `^Further reading:`, `^Citations:` (case-insensitive) followed by a bulleted list. If found, strip.
+**Self-check**: scan the last 30 lines for `^Sources:`, `^References:`, `^Further reading:`, `^Citations:` (case-insensitive) followed by a bulleted list. If found, strip.
 
 ---
 
diff --git a/.agents/skills/oma-mobile/resources/checklist.md b/.agents/skills/oma-mobile/resources/checklist.md
index c1c63c3..d77f4c9 100644
--- a/.agents/skills/oma-mobile/resources/checklist.md
+++ b/.agents/skills/oma-mobile/resources/checklist.md
@@ -39,7 +39,9 @@ Run through every item before submitting your work.
 > Applies when the project is Swift native (`Package.swift` / `.xcodeproj` present). Skip for Flutter/RN.
 - [ ] `App/Core/Features/Shared` layout respected (App = entry/DI, Core = networking/generated client, Features = view+`@Observable` VM slices, Shared = reusable UI/util)
 - [ ] API access goes through the generated `Client` from `swift-openapi-generator` — no hand-rolled `URLRequest`/`JSONDecoder` for spec-covered endpoints
+<!-- oma-docs:ignore-start -->
 - [ ] OpenAPI document present at `Core/Networking/openapi.yaml` and synced from the backend before build
+<!-- oma-docs:ignore-end -->
 - [ ] SwiftUI state via `@Observable` (Observation framework); `Task`s cancelled in `deinit` to avoid leaks
 - [ ] Loading / error (with retry) / empty / data states handled in views
 - [ ] iOS Human Interface Guidelines followed
diff --git a/.agents/skills/oma-mobile/resources/error-playbook.md b/.agents/skills/oma-mobile/resources/error-playbook.md
index 9ad93e4..4e4ae05 100644
--- a/.agents/skills/oma-mobile/resources/error-playbook.md
+++ b/.agents/skills/oma-mobile/resources/error-playbook.md
@@ -103,7 +103,9 @@ Same as the backend playbook: see `../../oma-backend/resources/error-playbook.md
 
 **Symptoms**: Build error from the `swift-openapi-generator` plugin such as `error: openapi.yaml not found` or YAML parse error; the build fails before any Swift file is compiled.
 
+<!-- oma-docs:ignore-start -->
 1. Confirm the spec exists at `Core/Networking/openapi.yaml` — this is where the build plugin looks.
+<!-- oma-docs:ignore-end -->
 2. If the file is absent: re-sync it from the backend (`curl -o Sources/Core/Networking/openapi.yaml https://<backend>/api-docs/openapi.yaml` or copy from the CI artifact). The iOS project is a **consumer** of the spec; never edit `openapi.yaml` directly.
 3. If the file is present but the error is a parse error: validate the YAML (`python3 -c "import yaml, sys; yaml.safe_load(open(sys.argv[1]))" Sources/Core/Networking/openapi.yaml`); fix the upstream spec and re-sync.
 4. After syncing, `swift build` will regenerate `Client`, `Operations`, and `Components` automatically — no manual code-gen step needed.
@@ -132,7 +134,9 @@ Same as the backend playbook: see `../../oma-backend/resources/error-playbook.md
 1. The root cause is that the OpenAPI spec does not declare that HTTP status code for the operation. The generator only emits cases for status codes listed in the spec.
 2. Do NOT add the case manually to the generated file — it will be overwritten on the next `swift build`.
 3. Ask the backend team to add the missing status code to the spec (e.g., add `409: description: Conflict` under the operation's `responses:`).
+<!-- oma-docs:ignore-start -->
 4. Re-sync `Core/Networking/openapi.yaml` once the spec is updated.
+<!-- oma-docs:ignore-end -->
 5. Run `swift build` to regenerate; the new response case will appear and the compile error will resolve.
 6. Update the Swift `switch` in the service layer to handle the new case explicitly.
 
diff --git a/.agents/skills/oma-mobile/resources/execution-protocol.md b/.agents/skills/oma-mobile/resources/execution-protocol.md
index 89e9d23..06536db 100644
--- a/.agents/skills/oma-mobile/resources/execution-protocol.md
+++ b/.agents/skills/oma-mobile/resources/execution-protocol.md
@@ -16,7 +16,9 @@ Follow these steps in order (adjust depth by difficulty).
 ## Step 1: Analyze
 - Read the task requirements carefully
 - Identify target platform: check for `Package.swift` (Swift iOS), `pubspec.yaml` (Flutter), or `package.json` + `react-native` dep (React Native)
+<!-- oma-docs:ignore-start -->
 - **If Swift (Package.swift detected)**: identify which `Features/` modules are affected; check for `Core/Networking/openapi.yaml`
+<!-- oma-docs:ignore-end -->
 - **If Flutter**: identify screens, widgets, and Riverpod/Bloc providers
 - Check existing code with Serena: `get_symbols_overview("Sources/Features")` (Swift) or `get_symbols_overview("lib/features")` (Flutter)
 - Determine platform-specific requirements (iOS HIG vs Material Design 3)
diff --git a/.agents/skills/oma-mobile/variants/react-native/tech-stack.md b/.agents/skills/oma-mobile/variants/react-native/tech-stack.md
index 8182bb1..a6ebf1e 100644
--- a/.agents/skills/oma-mobile/variants/react-native/tech-stack.md
+++ b/.agents/skills/oma-mobile/variants/react-native/tech-stack.md
@@ -23,7 +23,9 @@ Zustand stores live in `src/store/`. Keep stores small and feature-scoped — on
 
 ## HTTP Transport: Axios
 
+<!-- oma-docs:ignore-start -->
 Network calls are made through a **singleton Axios instance** configured in `src/api/client.ts`. The instance wires request interceptors for bearer-token injection and response interceptors for 401 handling / token refresh. Retry logic (exponential back-off) is attached via `axios-retry`.
+<!-- oma-docs:ignore-end -->
 
 **Transport vs. server-state distinction.** Axios is a transport concern only — it sends and receives bytes. It knows nothing about caching, stale data, or background revalidation. TanStack Query (below) owns those concerns. React components never import the Axios instance directly; they consume typed hooks built on TanStack Query.
 
@@ -62,7 +64,9 @@ Backend REST API
 2. Query keys follow the pattern `[operation, ...params]` — for example `['todos', 'list']` or `['todos', 'detail', id]`. **Never key on URLs** (they conflate transport with cache identity and break under proxy/versioning changes).
 3. Every mutation (`useMutation`) **must call `queryClient.invalidateQueries({ queryKey })`** for all affected query keys on `onSuccess`. Optimistic updates are optional but, when used, must pair a `rollback` in `onError`.
 4. Offline persistence: `@tanstack/query-persist-client-core` + a custom MMKV persister (`react-native-mmkv`) so the query cache survives app restarts. This mirrors the swift disk-cache tier.
+<!-- oma-docs:ignore-start -->
 5. The `QueryClient` is created once at app startup (`src/api/queryClient.ts`) and provided via `<QueryClientProvider>` in the root component. Never create per-component `QueryClient` instances.
+<!-- oma-docs:ignore-end -->
 6. Network calls are isolated in `src/api/` typed functions (axios). **Screens and components never call axios directly** — this is the repository seam. Components consume hooks; hooks consume the api layer.
 7. The query cache is for **transient, server-owned data**. Durable user-owned data belongs in MMKV; secrets belong in `expo-secure-store` / `react-native-keychain`. TanStack Query is never a system of record.
 
@@ -163,7 +167,9 @@ Each `features/<name>/` folder is a vertical slice owning its types, UI componen
 
 Use **`@react-navigation/native-stack`** (backed by `react-native-screens` native primitives) for push navigation — it is measurably faster than the JS-animated `@react-navigation/stack`. Tab navigation uses `@react-navigation/bottom-tabs`.
 
+<!-- oma-docs:ignore-start -->
 Route param lists are **fully typed** in `src/navigation/types.ts` with a `RootStackParamList`. Screen components receive `NativeStackScreenProps<RootStackParamList, 'ScreenName'>` as props, giving compile-time checked navigation calls.
+<!-- oma-docs:ignore-end -->
 
 ```typescript
 // src/navigation/types.ts
@@ -174,6 +180,8 @@ export type RootStackParamList = {
 };
 ```
 
+<!-- oma-docs:ignore-start -->
 Pass `<NavigationContainer>` and navigator composition to `src/navigation/RootNavigator.tsx`; never embed navigation logic inside screen components.
+<!-- oma-docs:ignore-end -->
 
 See `snippets.md §7` for the typed navigator setup and `snippets.md §6` for a screen consuming typed route params.
diff --git a/.agents/skills/oma-mobile/variants/swift-ios/tech-stack.md b/.agents/skills/oma-mobile/variants/swift-ios/tech-stack.md
index 87e36af..984b1ef 100644
--- a/.agents/skills/oma-mobile/variants/swift-ios/tech-stack.md
+++ b/.agents/skills/oma-mobile/variants/swift-ios/tech-stack.md
@@ -27,12 +27,14 @@ generated sources.
 
 `swift-openapi-generator` runs in one of two modes — **both build a real app**; the choice is
 a workflow trade-off, not a capability one. This variant is the baseline default; the
+<!-- oma-docs:ignore-start -->
 per-project `stack/stack.yaml` (seeded by `/stack-set`) pins which mode the repo uses.
 
 | Mode | Mechanics | Trade-off |
 |------|-----------|-----------|
 | **Build plugin** (Apple-recommended default) | Generator runs during the build; output is ephemeral (not committed). Declared in `Package.swift` `plugins:` for SwiftPM targets, **and works in Xcode app targets too** — Xcode requires "trust & enable" for the plugin (Xcode Cloud needs a post-clone script to bypass fingerprint validation). Spec vendored at `Core/Networking/openapi.yaml`. | Zero commit noise, always in sync; but extra Xcode/CI setup, generated diffs invisible in review, regen on every clean build. |
 | **Committed (command plugin / CLI)** | Apple's documented fallback "if the build plugin cannot be used". Run `swift package generate-code-from-openapi` (or a task: `mise` / `make` / script) → write `Core/Networking/Generated/` → **commit** it; the build sees plain checked-in source. | Generated code is reviewable and CI is simpler; but a human must remember to regenerate + commit on spec changes. |
+<!-- oma-docs:ignore-end -->
 
 ### Where the API contract comes from
 
diff --git a/.agents/skills/oma-observability/resources/incident-forensics.md b/.agents/skills/oma-observability/resources/incident-forensics.md
index 7038b68..b630d79 100644
--- a/.agents/skills/oma-observability/resources/incident-forensics.md
+++ b/.agents/skills/oma-observability/resources/incident-forensics.md
@@ -49,6 +49,7 @@ Note: for non-Kubernetes hosts use `host.id`; for Kubernetes workloads set both
 
 Error spans (those where `status.code = ERROR`) MUST additionally carry code and exception attributes to enable the Code dimension pivot.
 
+<!-- oma-docs:ignore-start -->
 | Attribute | Semconv group | Stability | Example value |
 |-----------|--------------|-----------|---------------|
 | `code.function` | `code.*` | Stable | `processPayment` |
@@ -57,6 +58,7 @@ Error spans (those where `status.code = ERROR`) MUST additionally carry code and
 | `exception.type` | `exception.*` | Stable | `TimeoutException` |
 | `exception.message` | `exception.*` | Stable | `Redis pool exhausted after 5000ms` |
 | `exception.stacktrace` | `exception.*` | Stable | full stack trace string |
+<!-- oma-docs:ignore-end -->
 
 Set these via the OTel SDK `span.recordException(e)` call, which populates all three `exception.*` attributes atomically.
 
diff --git a/.agents/skills/oma-orchestrator/SKILL.md b/.agents/skills/oma-orchestrator/SKILL.md
index b96ecf2..52a5b77 100644
--- a/.agents/skills/oma-orchestrator/SKILL.md
+++ b/.agents/skills/oma-orchestrator/SKILL.md
@@ -153,12 +153,12 @@ Memory provider and tool names are configurable via `mcp.json`:
 ```json
 {
   "memoryConfig": {
-    "provider": "serena",
-    "basePath": ".serena/memories",
+    "provider": "file",
+    "basePath": ".agents/state/memories",
     "tools": {
-      "read": "read_memory",
-      "write": "write_memory",
-      "edit": "edit_memory"
+      "read": "Read",
+      "write": "Write",
+      "edit": "Edit"
     }
   }
 }
@@ -229,7 +229,9 @@ oma verify {agent-type} --workspace {workspace} --json
 
 **[3] Cross-Review**: Spawn QA agent to review the changes:
 - QA agent reads the diff, runs checks, evaluates against acceptance criteria
+<!-- oma-docs:ignore-start -->
 - If `docs/CODE-REVIEW.md` exists, QA agent uses it as the review checklist
+<!-- oma-docs:ignore-end -->
 - QA agent outputs: PASS (with optional nits) or FAIL (with specific issues)
 - On FAIL: issues are fed back to the implementation agent for fixing
 
diff --git a/.agents/skills/oma-orchestrator/resources/memory-schema.md b/.agents/skills/oma-orchestrator/resources/memory-schema.md
index 22775cb..b37ca60 100644
--- a/.agents/skills/oma-orchestrator/resources/memory-schema.md
+++ b/.agents/skills/oma-orchestrator/resources/memory-schema.md
@@ -10,17 +10,17 @@ Memory base path and tool names are configurable via `mcp.json`:
 ```json
 {
   "memoryConfig": {
-    "basePath": ".serena/memories",
+    "basePath": ".agents/state/memories",
     "tools": {
-      "read": "read_memory",
-      "write": "write_memory",
-      "edit": "edit_memory"
+      "read": "Read",
+      "write": "Write",
+      "edit": "Edit"
     }
   }
 }
 ```
 
-Default base path: `.serena/memories`
+Default base path: `.agents/state/memories`
 
 ## File Structure
 
diff --git a/.agents/skills/oma-pm/resources/error-playbook.md b/.agents/skills/oma-pm/resources/error-playbook.md
index 29de6a6..b376239 100644
--- a/.agents/skills/oma-pm/resources/error-playbook.md
+++ b/.agents/skills/oma-pm/resources/error-playbook.md
@@ -56,7 +56,7 @@ When you encounter a failure during planning, follow these recovery steps.
 2. If greenfield: use the project's default stack (see SKILL.md tech-stack references)
 3. Default choices: refer to each domain skill's `resources/tech-stack.md` for current versions
    - Frontend: `oma-frontend/resources/tech-stack.md`
-   - Backend: `oma-backend/resources/tech-stack.md`
+   - Backend: `oma-backend/variants/{node,python,rust}/tech-stack.md`
    - Mobile: `oma-mobile/resources/tech-stack.md`
 4. Note decision rationale in plan: `tech_decision: { choice: "X", reason: "Y" }`
 
diff --git a/.agents/skills/oma-refactor/SKILL.md b/.agents/skills/oma-refactor/SKILL.md
index 1165a98..417be1e 100644
--- a/.agents/skills/oma-refactor/SKILL.md
+++ b/.agents/skills/oma-refactor/SKILL.md
@@ -50,7 +50,7 @@ outputs:
 ```
 
 ### Dependencies
-- `resources/definition.md` (invariant definition: 5 properties, boundaries, destination principle, inline evidence)
+- `resources/definition.md` (invariant definition: 5 properties, boundaries, destination principle, naming roles, inline evidence)
 - `resources/measurement.md` (4-layer measurement + git forensics commands)
 - `resources/governance.md` (org parameters: budget floor, 500-line gate, tool registry)
 - Serena MCP symbol/reference tools; project test runners per registry (vitest / pytest / flutter_test)
@@ -159,7 +159,7 @@ outputs:
 8. All metrics are proxies (Goodhart): a 499-line mechanical split, assertion-free coverage, or pattern-count gains are failures, not wins.
 
 ## References
-- Invariant definition (5 properties, boundaries, destination, contexts, D&C, inline evidence): `resources/definition.md`
+- Invariant definition (5 properties, boundaries, destination, naming roles, contexts, D&C, inline evidence): `resources/definition.md`
 - Measurement: 4 layers + git forensics commands: `resources/measurement.md`
 - Org parameters: budget floor, 500-line gate, tool registry: `resources/governance.md`
 - Context loading: `../_shared/core/context-loading.md`
diff --git a/.agents/skills/oma-refactor/resources/definition.md b/.agents/skills/oma-refactor/resources/definition.md
index b40e9fa..13618b2 100644
--- a/.agents/skills/oma-refactor/resources/definition.md
+++ b/.agents/skills/oma-refactor/resources/definition.md
@@ -66,10 +66,35 @@ Bug fixing (intentional behavior change) / performance optimization (different g
 - Convention axis: in brownfield, the coding guide and framework conventions beat "theoretically better" patterns - consistency is a component of analysability. Changing a convention is an architecture decision (ADR + lint ratchet for new code + module-wise migration), never a boy-scout edit.
 - Timing: Rule of Three - abstract after reuse evidence accumulates; speculative generality is a smell.
 
+## Naming - operationalizing the unmeasured lever
+
+Rename is the only core transformation with no metric gate; its gate is qualitative: does the new name reveal the entity's **role** and **domain meaning** to the next reader? For variables, Sajaniemi's role taxonomy makes that question checkable (11 roles cover ~99% of variables in procedural/OO code): first identify the role, then verify the name exposes it.
+
+| Role | Behavior | Naming cue |
+|------|----------|-----------|
+| Fixed value | Set once, read thereafter | `maxRetries`, `basePath` |
+| Stepper | Walks a predictable succession | `attempt`, `pageIndex` |
+| Flag | Two-state signal controlling flow | `isStale`, `hasOverflow` |
+| Walker | Traverses a data structure | `cursor`, `currentNode` |
+| Most-recent holder | Latest value seen so far | `lastError`, `currentLine` |
+| Most-wanted holder | Best value found so far | `closestMatch`, `maxSoFar` |
+| Gatherer | Accumulates across values | `total`, `mergedDiff` |
+| Container | Elements enter and leave | `pendingJobs`, `seenIds` |
+| Follower | Previous value of another variable | `prevNode` |
+| Organizer | Holds data being rearranged | `sortedCopy` |
+| Temporary | Held briefly (swap/reuse) | `tmp` - acceptable ONLY in this role |
+
+Rename discipline:
+- Generic names (`data`, `result`, `temp`, `value`) outside the temporary role fail the role check; lying names (name promises X, body does Y) outrank them as targets.
+- One variable, one role: a variable that switches roles mid-scope is a **Split Variable** trigger, not a rename target.
+- Functions are named for intent (what), not mechanism (how); command = verb, query = noun/predicate.
+- Renames are engine-executed (LSP/IDE rename), never find-replace; tests re-run regardless.
+- Goodhart applies here too: role vocabulary diagnoses; the terminal check is still "does the next reader understand this cheaper".
+
 ## Execution contexts
 - **Greenfield**: refactoring is the third beat of TDD (Red -> Green -> Refactor) - minute-scale hygiene, net already exists.
 - **Brownfield**: order inverts - find a seam (minimal mechanical change to enable testing) -> characterization tests -> restructure. Large scale: Strangler Fig, Branch by Abstraction, Sprout Method - the system stays working at every point. The classification is per code fragment (coverage map), not per project.
-- **Stateful (data/API)**: git revert does not restore data. Mechanism: **Expand-Contract (parallel change)** - expand (old+new coexist) -> dual-write + backfill -> switch reads -> contract (remove old); feature flags are the standard switch. External consumers: semver + deprecation cycles as a staged contract-transfer protocol.
+- **Stateful (data/API)**: git revert does not restore data. Mechanism: **Expand-Contract (parallel change)** - expand (old+new coexist) -> dual-write + backfill -> switch reads -> contract (remove old); feature flags are the standard switch. External consumers: semver + deprecation cycles as a staged contract-transfer protocol; the pattern vocabulary for that staging (Version Identifier, Two in Production, Aggressive Obsolescence, Limited Lifetime Guarantee - MAP evolution patterns, Zimmermann et al.) lives with `oma-architecture` (`resources/api-evolution.md`) - a published-contract change is an architecture decision, route there for the ADR.
 - **Team concurrency**: big renames collide with every open branch - another reason for "small and frequent". Announce large refactorings + short merge windows; register bulk mechanical commits in `.git-blame-ignore-revs`; LSC (monorepo-wide atomic change + owner-split review) is incrementality at org scale.
 - **Regulated environments**: even behavior-preserving changes trigger re-verification/re-certification - economics invert; batch-per-release refactoring is the one legitimate exception to "continuous flow".
 
diff --git a/.agents/skills/oma-search/resources/trust-registry.md b/.agents/skills/oma-search/resources/trust-registry.md
index 4164200..bc3fb9c 100644
--- a/.agents/skills/oma-search/resources/trust-registry.md
+++ b/.agents/skills/oma-search/resources/trust-registry.md
@@ -112,6 +112,6 @@ Cache is project-scoped and survives skill updates.
 | Source | Purpose | Cost | API |
 |--------|---------|------|-----|
 | Heuristic patterns | Domain category classification | Free | N/A (built-in rules) |
-| [Tranco List](https://tranco-list.eu/) | Domain popularity validation | Free | `siterank.redirect2.me/api/rank.json` |
+| [Tranco List](https://tranco-list.eu/) | Domain popularity validation | Free | `https://siterank.redirect2.me/api/rank.json` |
 | [redirect2me/siterank](https://github.com/redirect2me/siterank) | Self-hostable Tranco API | Free, OSS | Self-host option |
 | Serena memory | Score caching | Free | MCP memory tools |
diff --git a/.agents/skills/oma-skill-creator/SKILL.md b/.agents/skills/oma-skill-creator/SKILL.md
index 1f08699..726ad12 100644
--- a/.agents/skills/oma-skill-creator/SKILL.md
+++ b/.agents/skills/oma-skill-creator/SKILL.md
@@ -70,7 +70,7 @@ Create, revise, and validate OMA skills using the SSL-lite Markdown structure de
 2. **ACQUIRE**: Read analogous skills, existing resources, project conventions, and any user-provided source material.
 3. **REASON**: Decide what belongs inline in `SKILL.md` and what belongs in `resources/`, `config/`, `scripts/`, or `assets/`.
 4. **ACT**: Create or update the skill using the SSL-lite template.
-5. **VERIFY**: Run structural, routing, execution, resource, and formatting checks.
+5. **VERIFY**: Run structural, routing, execution, resource, utility-content, and formatting checks.
 6. **FINALIZE**: Report created/changed files, validation result, and any remaining assumptions.
 
 ### Transitions
@@ -155,6 +155,7 @@ Create, revise, and validate OMA skills using the SSL-lite Markdown structure de
 10. Put long variant-specific details in `resources/`, not in the main skill body.
 11. Do not create extra README, changelog, or installation docs inside a skill.
 12. Do not overwrite unrelated user edits.
+13. Enforce the three utility-predictive content dimensions — failure mechanism encoding, actionable specificity, high-risk action blacklist — per the Utility Content Checks in `resources/validation-checklist.md` (SkillLens, arXiv:2605.23899).
 
 ## References
 - SSL-lite template: `resources/ssl-lite-template.md`
diff --git a/.agents/skills/oma-skill-creator/resources/ssl-lite-template.md b/.agents/skills/oma-skill-creator/resources/ssl-lite-template.md
index 45cfea1..2319956 100644
--- a/.agents/skills/oma-skill-creator/resources/ssl-lite-template.md
+++ b/.agents/skills/oma-skill-creator/resources/ssl-lite-template.md
@@ -152,6 +152,18 @@ Use `### Canonical workflow path` instead when the skill is decision-heavy rathe
 | `resource_scope`, `resource_target` | `Logical Operations / Resource scope` |
 | Source-adjacent evidence | `References` |
 
+## Utility Content Rubric (SkillLens)
+
+Three content dimensions predict whether a skill measurably improves task outcomes
+(SkillLens, arXiv:2605.23899). Section structure and formatting alone do not — apply these
+while filling the template:
+
+| Dimension | Where in the template | What "good" looks like |
+|-----------|----------------------|------------------------|
+| Failure mechanism encoding | `Failure and recovery`, `Guardrails` | States *why* the agent fails in this domain with an executable remedy — not generic advice |
+| Actionable specificity | Canonical path, `Scenes` | Step-level procedure referencing concrete domain objects, tools, flags, and paths |
+| High-risk action blacklist | `Guardrails` | Explicitly forbids the domain's specific harmful action patterns, not only positive instructions |
+
 ## Inline vs Resource Rule
 
 Keep inline:
diff --git a/.agents/skills/oma-skill-creator/resources/validation-checklist.md b/.agents/skills/oma-skill-creator/resources/validation-checklist.md
index 5b0191d..ae1b53c 100644
--- a/.agents/skills/oma-skill-creator/resources/validation-checklist.md
+++ b/.agents/skills/oma-skill-creator/resources/validation-checklist.md
@@ -32,6 +32,25 @@ Use this checklist after creating or updating a skill.
 - Resolve any `FAIL` (≥ 75% similarity) pair by rewriting one description to highlight distinct triggers, domains, or boundaries.
 - `WARN` (≥ 60%) pairs are acceptable when descriptions cover genuinely related domains; document the distinction in `When NOT to use` cross-routes.
 
+## Utility Content Checks (SkillLens rubric)
+
+Three content dimensions predict whether a skill measurably improves task outcomes
+(SkillLens, arXiv:2605.23899). Section structure, formatting, and prose fluency alone do
+not — a well-written skill can still fail `oma skills eval`.
+
+- **Failure mechanism encoding**: `Failure and recovery` (and guardrails) explain *why* the
+  agent fails in this domain and give an executable remedy. Reject generic advice
+  ("be careful", "edit minimally"); encode domain-specific failure modes
+  (e.g. "formulas don't evaluate in headless runs, so precompute static values").
+- **Actionable specificity**: the canonical path is a step-level procedure referencing
+  concrete domain objects, tools, flags, and file paths. An agent should be able to act
+  without re-deriving the procedure from scratch.
+- **High-risk action blacklist**: guardrails name and forbid the domain's specific harmful
+  action patterns (e.g. "never run `terraform apply` without a reviewed plan"), not only
+  positive instructions.
+- When in doubt, verify with `oma skills eval` fixtures instead of judging by prose quality —
+  textual plausibility does not predict utility.
+
 ## Structural Checks
 
 - `Entry` states what to verify before acting.
diff --git a/.agents/skills/oma-slide/SKILL.md b/.agents/skills/oma-slide/SKILL.md
index 985dee9..b4dcdc4 100644
--- a/.agents/skills/oma-slide/SKILL.md
+++ b/.agents/skills/oma-slide/SKILL.md
@@ -47,9 +47,27 @@ exportable to PDF, PNG, and PPTX.
   (authored at 1920×1080 px)
 - Updated `meta.json` with `{ title, order[], style, density, speakerNotes }`
 - Validation pass via `oma slide validate` (or a surfaced diff if auto-fix fails after 3 iterations)
+<!-- oma-docs:ignore-start -->
 - Optional: `viewer.html`, `out/deck.html` bundle, exports
+<!-- oma-docs:ignore-end -->
 - Optional: Canva design URL (when Canva export is requested)
 
+```yaml
+outputs:
+  - name: slide-fragments
+    description: Per-slide 1920×1080 HTML fragments authored by the skill
+    artifact: ".agents/results/slides/*/slide-*.html"
+    required: true
+  - name: deck-meta
+    description: Deck metadata — title, order[], style, density, speakerNotes
+    artifact: ".agents/results/slides/*/meta.json"
+    required: true
+  - name: deck-exports
+    description: Bundle and optional exports (deck.html, deck.pdf, png/, deck.pptx)
+    artifact: ".agents/results/slides/*/out/*"
+    required: false
+```
+
 ### Dependencies
 - `oma slide` CLI (all deterministic ops — scaffold, validate, bundle, export, viewer, editor)
 - `oma-image` skill (image generation; oma-slide never calls image APIs directly)
@@ -89,7 +107,8 @@ exportable to PDF, PNG, and PPTX.
    New imagery requests → oma-image → `./assets/`. Apply `data-om-validate` on each slide.
 5. **VALIDATE** (Phase 4): Run `oma slide validate --dir --format json`. If findings exist,
    auto-fix the reported slides and re-validate. Max 3 iterations; surface diff to user on failure.
-6. **REVIEW** (Phase 5): Run `oma slide viewer --dir`. Optionally open `oma slide edit --dir`
+6. **REVIEW** (Phase 5): Run `oma slide viewer --dir` (in the viewer, press `n` to toggle the
+   on-screen speaker-notes panel). Optionally open `oma slide edit --dir`
    for bbox visual edits. Optional aesthetic review using chrome-devtools MCP screenshots (judgment,
    not the pass/fail gate).
 7. **DELIVER** (Phase 6): Run `oma slide bundle --dir "$DECK_DIR" --out out/deck.html` (`--dir` is required). Optionally export
@@ -110,7 +129,9 @@ exportable to PDF, PNG, and PPTX.
 - Image generation failure: placeholder image + TODO comment; continue deck generation.
 
 ### Exit
+<!-- oma-docs:ignore-start -->
 - Success: `out/deck.html` exists, `oma slide validate` passes, deck opens in browser.
+<!-- oma-docs:ignore-end -->
 - Partial success: generated slides present but exports skipped (missing dependencies) — explicit notice.
 
 ## Logical Operations
@@ -151,30 +172,37 @@ exportable to PDF, PNG, and PPTX.
 DECK_DIR=".agents/results/slides/<session-id>"
 
 # Scaffold
-oma slide new --dir "$DECK_DIR"
+oma slide new --dir "$DECK_DIR" [--force]
 
 # Validate (after writing slides)
-oma slide validate --dir "$DECK_DIR" --format json
+oma slide validate --dir "$DECK_DIR" --format json [--out <file>]
+oma slide validate --dir "$DECK_DIR" --slide slide-04.html   # single-slide gate (enhance mode)
 
 # Build viewer
 oma slide viewer --dir "$DECK_DIR"
 
 # Bundle to single-file
-oma slide bundle --dir "$DECK_DIR"
+oma slide bundle --dir "$DECK_DIR" [--out <file>] [--inline-fonts]
 
 # Exports (optional)
-oma slide pdf  --dir "$DECK_DIR"
-oma slide png  --dir "$DECK_DIR"
-oma slide pptx --dir "$DECK_DIR"   # experimental
+oma slide pdf  --dir "$DECK_DIR" [--out <file>] [--mode capture|print]
+oma slide png  --dir "$DECK_DIR" [--out-dir <dir>] [--resolution 720p|1080p|1440p|2160p|4k]
+oma slide pptx --dir "$DECK_DIR" [--out <file>]   # experimental
+
+# Video download
+oma slide fetch-video <url> --dir "$DECK_DIR" [--output-name <name>]
 
 # Style browsing
 oma slide styles list
-oma slide styles get <slug>
+oma slide styles preview <slug>
+oma slide styles get <slug> [--refresh]
 
 # Visual editor
-oma slide edit --dir "$DECK_DIR"
+oma slide edit --dir "$DECK_DIR" [--port <n>]
 ```
 
+Env-var overrides: `OMA_CHROME_PATH` (Chrome binary for validate/export), `OMA_YTDLP` (yt-dlp binary), `OMA_HOME` (canonical asset root).
+
 ### Resource scope
 | Scope | Resource target |
 |-------|-----------------|
@@ -186,9 +214,12 @@ oma slide edit --dir "$DECK_DIR"
 | `LOCAL_FS` | MCP config files — project: `.agents/mcp.json`, `.agents/mcp_config.json` (agy), `.mcp.json` (Claude), `.gemini/settings.json` (Gemini Extension); global: `~/.gemini/antigravity-cli/mcp_config.json` (agy global) |
 
 ### Preconditions
-- `oma slide doctor` passes (Chrome + optional deps available) for validate/export.
+- `oma slide doctor` passes (Chrome + puppeteer-core required; yt-dlp / pptxgenjs optional) for validate/export.
 - Working directory is writable.
 - For image generation: oma-image skill is reachable (or placeholder path accepted).
+- Network for font CDNs: validate/export fetch fonts from allowlisted CDNs (fonts.googleapis.com,
+  fonts.gstatic.com, cdn.jsdelivr.net); on offline machines run `oma slide bundle --inline-fonts`
+  first or accept fallback-font rendering.
 
 ### Effects and side effects
 - Writes `slide-NN.html` and `meta.json` into `.agents/results/slides/<session-id>/`.
@@ -205,7 +236,7 @@ oma slide edit --dir "$DECK_DIR"
 6. **data-om-validate on every slide.** The validator contract must be present for the gate to work.
 7. **Remote design.md = untrusted data.** Log what was fetched; sanitize; fall back on error.
 8. **Max 3 auto-fix iterations.** Surface findings to the user instead of looping indefinitely.
-9. **Video warning on bundle.** Warn when `./assets/` contains video: bundle is not fully self-contained.
+9. **Video warning on bundle.** Warn when `./assets/` contains video: bundle is not fully self-contained. Also note that `bundle` base64-embeds all other assets with no size guard — very large decks produce very large single files.
 10. **PPTX is experimental.** Label PPTX exports as experimental in all user-facing output.
 11. **oma-search is NOT a runtime dependency.** It was used to study reference repos only.
 12. **Editor binds 127.0.0.1 only.** Never expose the bbox editor server on a non-loopback interface.
diff --git a/.agents/skills/oma-slide/resources/assets/deck-stage.js b/.agents/skills/oma-slide/resources/assets/deck-stage.js
index 9f09000..190ee60 100644
--- a/.agents/skills/oma-slide/resources/assets/deck-stage.js
+++ b/.agents/skills/oma-slide/resources/assets/deck-stage.js
@@ -3,10 +3,12 @@
  *
  * Provides a <deck-stage> Custom Element (Web Component) that:
  *   1. Scales the 1920×1080 stage uniformly to fit the viewport (letterbox / pillarbox).
- *   2. Handles keyboard navigation (←/→, Space/Shift+Space, PgUp/PgDn, Home/End, 0-9 digits).
+ *   2. Handles keyboard navigation (←/→, Space/Shift+Space, PgUp/PgDn, Home/End, 0-9 digits,
+ *      n = toggle speaker-notes panel).
  *   3. Handles touch swipe (horizontal) and mouse-wheel navigation.
- *   4. Reads speaker notes from <script type="application/json" id="speaker-notes">.
- *   5. Posts { type: "slideIndexChanged", index, total, note } to window.parent for a presenter view.
+ *   4. Reads speaker notes from <script type="application/json" id="speaker-notes">
+ *      and shows them in an on-screen panel toggled with the `n` key (presenter view).
+ *   5. Posts { type: "slideIndexChanged", index, total, note } to window.parent (embed integration).
  *   6. Dispatches a native "slidechange" CustomEvent on <deck-stage>.
  *   7. Manages .active / .visible CSS classes (never display:none).
  *   8. Tags each slide with data-screen-label and data-om-validate on first connect.
@@ -86,6 +88,8 @@ class DeckStage extends HTMLElement {
   #touchStartY = 0;
   #touchStartTime = 0;
   #wheelLocked = false;
+  #notesPanel = null;
+  #notesVisible = false;
 
   /* ── Lifecycle ── */
 
@@ -241,6 +245,53 @@ class DeckStage extends HTMLElement {
         "*"
       );
     }
+
+    /* Keep the on-screen notes panel in sync */
+    this.#updateNotesPanel();
+  }
+
+  /* ── Private: speaker-notes panel (toggle with `n`) ── */
+
+  #ensureNotesPanel() {
+    if (this.#notesPanel) return this.#notesPanel;
+    const panel = document.createElement("div");
+    panel.className = "deck-notes-panel";
+    panel.setAttribute("role", "note");
+    panel.setAttribute("aria-label", "Speaker notes");
+    /* Hidden by default (display:none — never intercepts clicks when hidden). */
+    panel.style.cssText = [
+      "position: fixed",
+      "left: 16px",
+      "right: 16px",
+      "bottom: 16px",
+      "max-height: 30vh",
+      "overflow-y: auto",
+      "padding: 16px 20px",
+      "background: rgba(10, 12, 18, 0.85)",
+      "color: #f2f2f2",
+      "font: 16px/1.5 system-ui, sans-serif",
+      "border-radius: 8px",
+      "white-space: pre-wrap",
+      "z-index: 2147483647",
+      "display: none",
+    ].join("; ");
+    document.body.appendChild(panel);
+    this.#notesPanel = panel;
+    return panel;
+  }
+
+  #toggleNotesPanel() {
+    const panel = this.#ensureNotesPanel();
+    this.#notesVisible = !this.#notesVisible;
+    panel.style.display = this.#notesVisible ? "block" : "none";
+    this.#updateNotesPanel();
+  }
+
+  #updateNotesPanel() {
+    if (!this.#notesVisible || !this.#notesPanel) return;
+    const note =
+      this.#notes[String(this.#currentIndex)] ?? this.#notes[this.#currentIndex] ?? "";
+    this.#notesPanel.textContent = note || "(no speaker note for this slide)";
   }
 
   /* ── Private: scaling ── */
@@ -289,6 +340,8 @@ class DeckStage extends HTMLElement {
   }
 
   #onBeforePrint = () => {
+    /* Notes panel must not overlay printed slides */
+    if (this.#notesPanel) this.#notesPanel.style.display = "none";
     if (!this.#stageEl) return;
     this.#stageEl.style.transform = "none";
     this.#stageEl.style.left = "";
@@ -297,6 +350,9 @@ class DeckStage extends HTMLElement {
   };
 
   #onAfterPrint = () => {
+    if (this.#notesPanel && this.#notesVisible) {
+      this.#notesPanel.style.display = "block";
+    }
     this.#scaleStage();
   };
 
@@ -341,6 +397,12 @@ class DeckStage extends HTMLElement {
         this.#goTo(this.#slides.length - 1);
         break;
 
+      case "n":
+      case "N":
+        e.preventDefault();
+        this.#toggleNotesPanel();
+        break;
+
       default:
         /* Number keys 1-9 and 0 (for slide 10) */
         if (e.key >= "0" && e.key <= "9") {
diff --git a/.agents/skills/oma-slide/resources/canva-integration.md b/.agents/skills/oma-slide/resources/canva-integration.md
index 01a52ae..45b1cce 100644
--- a/.agents/skills/oma-slide/resources/canva-integration.md
+++ b/.agents/skills/oma-slide/resources/canva-integration.md
@@ -71,7 +71,7 @@ All config files use the same `{ "url": "https://mcp.canva.com/mcp" }` shape
 
 ```
 1. PROBE        → list_designs (verify Canva MCP is connected + authenticated)
-2. RENDER       → oma slide png --dir <slug> --out-dir <slug>/out/png/ --resolution 2x
+2. RENDER       → oma slide png --dir <slug> --out-dir <slug>/out/png/ --resolution 2160p
 3. UPLOAD       → upload_asset for each slide PNG → collect asset_ids[]
 4. CREATE       → create_design (type: "Presentation", assets: asset_ids[])
 5. REPORT       → include Canva design URL in delivery summary
@@ -86,7 +86,7 @@ Call `list_designs` with a minimal query. If it errors (401/403/timeout), notify
 Do NOT retry or prompt for credentials — the OAuth flow is handled externally.
 
 **Step 2 — Render PNGs:**
-Use `oma slide png --resolution 2x` to produce high-resolution per-slide images (3840×2160).
+Use `oma slide png --resolution 2160p` to produce high-resolution per-slide images (3840×2160).
 These become the raster backing for each Canva presentation page.
 
 **Step 3 — Upload Assets:**
diff --git a/.agents/skills/oma-slide/resources/checklist.md b/.agents/skills/oma-slide/resources/checklist.md
index 0b60227..06334da 100644
--- a/.agents/skills/oma-slide/resources/checklist.md
+++ b/.agents/skills/oma-slide/resources/checklist.md
@@ -19,12 +19,16 @@ Every item maps to a SKILL.md guardrail or the validator contract in `fixed-stag
 
 ## Delivery artifacts
 
+<!-- oma-docs:ignore-start -->
 - [ ] `oma slide bundle --dir "$DECK_DIR"` produced `out/deck.html` and it opens in a browser
+<!-- oma-docs:ignore-end -->
 - [ ] If `./assets/` contains video: user was warned the bundle is not fully self-contained
 - [ ] PPTX export (if requested) labeled **experimental** in user-facing output
 - [ ] Canva export (if performed): design URL included in the delivery summary
 
 ## Delivery summary (Phase 6c)
 
+<!-- oma-docs:ignore-start -->
 - [ ] Reported: workdir path, slide file list, `out/deck.html` path, export paths, validate status
+<!-- oma-docs:ignore-end -->
 - [ ] Reported: any `TODO(oma-deferred)` items (e.g., unresolved image generation placeholders)
diff --git a/.agents/skills/oma-slide/resources/design-doctrine.md b/.agents/skills/oma-slide/resources/design-doctrine.md
index d68d278..9a6788d 100644
--- a/.agents/skills/oma-slide/resources/design-doctrine.md
+++ b/.agents/skills/oma-slide/resources/design-doctrine.md
@@ -161,8 +161,10 @@ direction. The safe preset and bold template choices should stay within recogniz
 ## 5. Content-Density Modes
 
 The `density` field in `meta.json` governs how slides are laid out and how much content they carry.
+Its values are the CLI enum `sparse | balanced | dense`: a speaker-led deck maps to `sparse`, a
+reading-first deck maps to `dense`, and `balanced` (the default) sits in between.
 
-### 5a. Speaker-Led (Sparse)
+### 5a. Speaker-Led (`sparse`)
 
 The presenter is the primary content delivery vehicle. Slides are visual anchors.
 
@@ -175,7 +177,7 @@ The presenter is the primary content delivery vehicle. Slides are visual anchors
 | Slide count | Allow 1 slide per 1–2 minutes of talk time |
 | Speaker notes | Extensive notes in `meta.json.speakerNotes[]` for the presenter |
 
-### 5b. Reading-First (Dense)
+### 5b. Reading-First (`dense`)
 
 The deck is a self-contained document. Readers consume it without a presenter.
 
@@ -191,7 +193,8 @@ The deck is a self-contained document. Readers consume it without a presenter.
 ### 5c. Mixed Density
 
 Some decks mix modes (e.g., opener slides are sparse, data slides are dense). Apply the relevant
-mode rules per slide and record the overall dominant mode in `meta.json.density`.
+mode rules per slide and record the overall dominant mode in `meta.json.density`
+(`sparse`, `balanced`, or `dense`).
 
 ---
 
@@ -218,7 +221,7 @@ A well-crafted slide satisfies all of these:
 2. **Scannable hierarchy** — the largest element is the most important.
 3. **Comfortable empty space** — the canvas breathes; content does not fill edge to edge.
 4. **Consistent with the deck** — the color, font, and grid choices are the same as every other slide.
-5. **Readable at scale** — body text ≥ 28 px; the smallest legible text at 1920×1080 passes WCAG AA.
+5. **Readable at scale** — body text ≥ 28 px (doctrine floor; the validator's hard gate rejects only text below 18 px); the smallest legible text at 1920×1080 passes WCAG AA.
 6. **Accessible in motion** — any animations are wrapped in `@media (prefers-reduced-motion: no-preference)`.
 
 ---
diff --git a/.agents/skills/oma-slide/resources/fixed-stage.md b/.agents/skills/oma-slide/resources/fixed-stage.md
index 17dc31b..ed0a868 100644
--- a/.agents/skills/oma-slide/resources/fixed-stage.md
+++ b/.agents/skills/oma-slide/resources/fixed-stage.md
@@ -7,16 +7,19 @@
 
 All slides are authored at exactly **1920 × 1080 px**. This is non-negotiable:
 
-- The validator (`oma slide validate`) renders at 1920×1080 and checks geometry at that size.
+- The validator (`oma slide validate`) renders at 1920×1080 and checks geometry at that size;
+  it reports px→pt at 0.75 (1920×1080 px → 1440×810 pt at 96 dpi / 72 pt-per-inch).
 - The exporter (`oma slide pdf|png`) captures at 1920×1080 before any post-processing.
-- PPTX export converts 1920×1080 px to 720×405 pt (÷ 2.667) — pixel authoring only, no pt in HTML.
+- PPTX export places each rasterized slide full-bleed on a LAYOUT_WIDE canvas
+  (13.333 in × 7.5 in = 960×540 pt) — pixel authoring only, no pt in HTML.
 - Do **not** author in percentages, `vw/vh`, or responsive units that reflow the layout.
   Fixed `px` values only inside `.slide`.
 
 ```
 Canvas size:  1920 px wide  ×  1080 px tall
 Aspect ratio: 16:9
-PPTX output:  720 pt wide   ×  405 pt tall   (px ÷ 2.667)
+Validator pt: 1440 pt wide  ×  810 pt tall    (px × 0.75)
+PPTX layout:  13.333 in × 7.5 in (960×540 pt) — raster placed full-bleed
 ```
 
 ## 2. Stage Scaling — How It Works
@@ -79,7 +82,9 @@ output.
 </body>
 ```
 
+<!-- oma-docs:ignore-start -->
 ### Option B — Inlined (single-file bundle — `out/deck.html`)
+<!-- oma-docs:ignore-end -->
 
 `oma slide bundle` inlines both files; the structure is the same but the
 `<link>` is replaced by `<style>...</style>` and `<script src>` becomes `<script>...</script>`.
@@ -104,7 +109,7 @@ For `viewer.html`, the CLI injects:
 |---|---|
 | Slide root | `position: absolute; inset: 0; width: 1920px; height: 1080px;` |
 | Safe zones | Left/right margin ≥ 80px; top/bottom margin ≥ 60px |
-| Body text | 28–36 px minimum; heading 64–120 px |
+| Body text | 28–36 px doctrine floor; heading 64–120 px. (The validator hard-fails only below 18 px — 18–27 px passes the gate but is reserved for captions/labels.) |
 | Icon / decorative image | explicit `width`/`height` in px |
 | Background gradients | allowed (CSS); rasterized to PNG at PPTX export |
 | Clipping / overflow | `overflow: hidden` on `.slide` prevents bleed-out |
@@ -223,10 +228,17 @@ sees the true 1920×1080 px layout. `viewport-base.css` `@media print` rules:
 
 Result: one clean 1920×1080 slide per printed page.
 
-## 10. Presenter View (postMessage API)
+## 10. Presenter View (embedded notes panel + postMessage API)
 
-When `viewer.html` opens the deck inside an `<iframe>`, `deck-stage.js` posts on every
-slide change:
+The presenter view is an **embedded on-screen notes panel** — there is no separate
+presenter window. `deck-stage.js` reads speaker notes from
+`<script type="application/json" id="speaker-notes">` (a JSON object keyed by
+**0-based slide index** as a string: `"0"`, `"1"`, …). Press **`n`** to toggle a
+fixed, semi-transparent panel at the bottom of the viewport showing the current
+slide's note; it updates automatically on slide change, is hidden by default
+(never intercepts clicks when hidden), and is suppressed during print.
+
+For embedding integrations, `deck-stage.js` also posts on every slide change:
 
 ```js
 window.parent.postMessage(
@@ -235,9 +247,6 @@ window.parent.postMessage(
 );
 ```
 
-The presenter view reads speaker notes from
-`<script type="application/json" id="speaker-notes">` (a JSON object keyed by 0-based index).
-
 The parent frame can navigate the iframe by posting:
 
 ```js
diff --git a/.agents/skills/oma-slide/resources/generation-protocol.md b/.agents/skills/oma-slide/resources/generation-protocol.md
index 83fb5db..1a411c8 100644
--- a/.agents/skills/oma-slide/resources/generation-protocol.md
+++ b/.agents/skills/oma-slide/resources/generation-protocol.md
@@ -59,9 +59,10 @@ Required dimensions:
 - **Purpose** — What is the deck for? (Pitch / report / talk / explainer / internal / external)
 - **Length** — Roughly how many slides? (Or let the skill decide from content scope.)
 - **Content** — What topics, data, or story should the deck cover? Any must-include points?
-- **Density** — How will the deck be used?
-  - `speaker-led` (sparse): large statements, minimal text — speaker fills in detail verbally.
-  - `reading-first` (dense): deck is read standalone; more text and detail per slide.
+- **Density** — How will the deck be used? (`meta.json.density` takes `sparse | balanced | dense`)
+  - speaker-led deck → `sparse`: large statements, minimal text — speaker fills in detail verbally.
+  - reading-first deck → `dense`: deck is read standalone; more text and detail per slide.
+  - in between → `balanced` (the default).
 
 Example combined question:
 > "To get started: what is this deck for (pitch, internal report, talk)? Roughly how many slides? What key topics or story should it cover? And will someone be presenting it live (sparse slides) or will it be read standalone (dense slides)?"
@@ -105,7 +106,7 @@ Write three self-contained `preview-*.html` files (cover slide only, 1920×1080,
 
 Each preview must:
 - Follow the canonical structure: `<div class="deck-viewport"><div class="deck-stage"><section class="slide" …></section></div></div><script src="./deck-stage.js"></script>`
-- Include a link to `./viewport-base.css`
+- Include a link to `./assets/viewport-base.css`
 - Represent the deck's actual tone and content (use the real deck title + first key message)
 - Be readable side-by-side in a browser
 
@@ -196,7 +197,7 @@ After writing all slides, update `meta.json` in the workdir:
   "title": "<deck title>",
   "order": ["slide-01.html", "slide-02.html", "..."],
   "style": "<preset-slug or bold-template-slug>",
-  "density": "speaker-led | reading-first",
+  "density": "sparse | balanced | dense",
   "speakerNotes": {
     "0": "Notes for slide 1",
     "1": "Notes for slide 2"
@@ -206,6 +207,8 @@ After writing all slides, update `meta.json` in the workdir:
 
 `order[]` is the **source of truth** for slide sequence. Update it if slides are added/reordered.
 
+Density mapping (see `design-doctrine.md` §5): a speaker-led deck → `sparse`, a reading-first deck → `dense`; `balanced` sits in between and is the default.
+
 ---
 
 ## Phase 4 — Validate (Auto-Fix Loop)
@@ -220,6 +223,11 @@ oma slide validate --dir <deck-dir> --format json
 
 The CLI renders each slide at 1920×1080 with puppeteer-core (awaits `document.fonts.ready`), checks geometry, and outputs structured findings.
 
+> **Font CDN note:** validate and export render contexts block all network requests **except** the
+> allowlisted font CDNs (`fonts.googleapis.com`, `fonts.gstatic.com`, `cdn.jsdelivr.net`,
+> `fonts.bunny.net`, `use.typekit.net`), so geometry is measured with the real typeface. On an
+> offline machine, run `oma slide bundle --inline-fonts` first or accept fallback-font rendering.
+
 ### 4b. Interpret Findings
 
 The JSON output includes: `{ generatedAt, frame, summary, slides:[{ file, status, issues:[{ code, message, slide, selector?, rect? }] }] }`.
@@ -230,7 +238,7 @@ Failure codes and typical fixes:
 |---|---|---|
 | `no_overflowing_text` | Text overflows the slide boundary | Reduce font size, truncate, split to a new slide, or add `overflow: hidden` to a container |
 | `no_overlapping_text` | Two text elements overlap | Adjust `top/left` positions; increase z-index separation |
-| `slide_sized_text` | Text is too small to read at 1920×1080 | Increase font size to ≥ 28 px |
+| `slide_sized_text` | Text is too small to read at 1920×1080 | Raise font size to ≥ 28 px per doctrine (the validator hard-fails only below 18 px) |
 
 ### 4c. Auto-Fix Rewrite
 
@@ -258,7 +266,7 @@ Re-run `oma slide validate --dir <deck-dir> --format json` after each fix.
 oma slide viewer --dir <deck-dir>
 ```
 
-This generates `viewer.html` with navigation controls, a slide counter, and presenter view. Open it in the browser to review the full deck.
+This generates `viewer.html` with navigation controls, a slide counter, and embedded speaker notes: press `n` to toggle an on-screen notes panel that follows the current slide (there is no separate presenter window). Open it in the browser to review the full deck.
 
 ### 5b. Optional: Aesthetic Review
 
@@ -295,7 +303,7 @@ Inlines `viewport-base.css` and `deck-stage.js`; embeds all `./assets/` images a
 oma slide pdf --dir <deck-dir> [--mode capture|print]
 
 # PNG per slide
-oma slide png --dir <deck-dir> [--resolution 2x]
+oma slide png --dir <deck-dir> [--resolution 2160p]
 
 # PPTX (experimental — raster-backed, gradients rasterized to PNG)
 oma slide pptx --dir <deck-dir>
@@ -310,7 +318,9 @@ PDF and PNG use poster frames in place of video elements (video cannot be includ
 After bundle/export, report:
 - Working directory path
 - List of `slide-NN.html` files created
+<!-- oma-docs:ignore-start -->
 - Path to `out/deck.html` (and any exports)
+<!-- oma-docs:ignore-end -->
 - Canva design URL (if Canva export was performed)
 - Validate status (pass / surfaced diff)
 - Any deferred items (`TODO(oma-deferred)`) such as unresolved image generation
@@ -326,7 +336,7 @@ If the user requests Canva export ("export to Canva", "캔바로 내보내기",
    - On auth failure: notify user ("Canva MCP is not authenticated.
      Run local exports instead.") and skip.
 
-2. **Render PNGs**: Run `oma slide png --dir <deck-dir> --resolution 2x`
+2. **Render PNGs**: Run `oma slide png --dir <deck-dir> --resolution 2160p`
    to get high-resolution per-slide images.
 
 3. **Upload assets**: For each PNG, call `upload_asset` via Canva MCP.
@@ -350,19 +360,26 @@ error handling, and security considerations.
 
 ```bash
 DECK_DIR=".agents/results/slides/<session-id>"
-oma slide new --dir "$DECK_DIR"                    # scaffold workdir
+oma slide new --dir "$DECK_DIR" [--force]          # scaffold workdir (--force: overwrite non-empty dir)
 oma slide validate --dir "$DECK_DIR" --format json # geometric gate
+oma slide validate --dir "$DECK_DIR" --slide slide-04.html  # single-slide gate (enhance-mode targeted loop)
+oma slide validate --dir "$DECK_DIR" --format json --out report.json  # write JSON report to out/
 oma slide viewer --dir "$DECK_DIR"                 # build viewer.html
-oma slide bundle --dir "$DECK_DIR"
-oma slide pdf   --dir "$DECK_DIR"
-oma slide png   --dir "$DECK_DIR"
-oma slide pptx  --dir "$DECK_DIR"                  # experimental
+oma slide bundle --dir "$DECK_DIR" [--out <file>] [--inline-fonts]  # --inline-fonts: embed CDN @font-face CSS
+oma slide pdf   --dir "$DECK_DIR" [--out <file>] [--mode capture|print]
+oma slide png   --dir "$DECK_DIR" [--out-dir <dir>] [--resolution 720p|1080p|1440p|2160p|4k]
+oma slide pptx  --dir "$DECK_DIR" [--out <file>]   # experimental
+oma slide import-pptx <file.pptx> --dir "$DECK_DIR"
+oma slide fetch-video <url> --dir "$DECK_DIR" [--output-name <name>]
 oma slide styles list                              # browse style index
-oma slide styles get <slug>                        # fetch bold template design.md
-oma slide edit  --dir "$DECK_DIR"                  # bbox visual editor
-oma slide doctor                                   # check deps (Chrome, python, yt-dlp)
+oma slide styles preview <slug>                    # preview a preset in the terminal
+oma slide styles get <slug> [--refresh]            # fetch bold template design.md (--refresh: skip cache)
+oma slide edit  --dir "$DECK_DIR" [--port <n>]     # bbox visual editor (default: auto-probe from 3737)
+oma slide doctor                                   # check deps (chrome, puppeteer-core; optional: yt-dlp, pptxgenjs)
 ```
 
+Env-var overrides: `OMA_CHROME_PATH` (Chrome binary for validate/export), `OMA_YTDLP` (yt-dlp binary for fetch-video), `OMA_HOME` (root for canonical stage assets).
+
 Exit codes: `0 ok · 4 invalid-input · 6 timeout · 1 error`.
 
 ---
diff --git a/.agents/workflows/architecture.md b/.agents/workflows/architecture.md
index 148477f..9cdaccd 100644
--- a/.agents/workflows/architecture.md
+++ b/.agents/workflows/architecture.md
@@ -12,7 +12,7 @@ disable-model-invocation: true
 - **You MUST use MCP tools throughout the workflow.**
   - Use code analysis tools (`get_symbols_overview`, `find_symbol`, `find_referencing_symbols`, `search_for_pattern`) to inspect the current architecture.
   - Use memory tools (write/edit) to record architecture outputs.
-  - Memory path: configurable via `memoryConfig.basePath` (default: `.serena/memories`)
+  - Memory path: configurable via `memoryConfig.basePath` (default: `.agents/state/memories`)
   - Tool names: configurable via `memoryConfig.tools` in `.agents/mcp.json`
   - Do NOT use raw file reads or grep as substitutes when MCP tools are available.
 
diff --git a/.agents/workflows/brainstorm.md b/.agents/workflows/brainstorm.md
index 4efcbe5..6afeea1 100644
--- a/.agents/workflows/brainstorm.md
+++ b/.agents/workflows/brainstorm.md
@@ -12,7 +12,7 @@ disable-model-invocation: true
 - **You MUST use MCP tools throughout the workflow.**
   - Use code analysis tools (`get_symbols_overview`, `find_symbol`, `search_for_pattern`) to analyze the existing codebase.
   - Use memory tools (write/edit) to record design results.
-  - Memory path: configurable via `memoryConfig.basePath` (default: `.serena/memories`)
+  - Memory path: configurable via `memoryConfig.basePath` (default: `.agents/state/memories`)
   - Tool names: configurable via `memoryConfig.tools` in `.agents/mcp.json`
   - Do NOT use raw file reads or grep as substitutes.
 
diff --git a/.agents/workflows/debug.md b/.agents/workflows/debug.md
index 1de339a..809da3e 100644
--- a/.agents/workflows/debug.md
+++ b/.agents/workflows/debug.md
@@ -11,7 +11,7 @@ disable-model-invocation: true
 - **You MUST use MCP tools throughout the workflow.**
   - Use code analysis tools (`find_symbol`, `find_referencing_symbols`, `search_for_pattern`) for bug investigation, NOT raw file reads or grep.
   - Use memory write tool to record debugging results.
-  - Memory path: configurable via `memoryConfig.basePath` (default: `.serena/memories`)
+  - Memory path: configurable via `memoryConfig.basePath` (default: `.agents/state/memories`)
   - Tool names: configurable via `memoryConfig.tools` in `.agents/mcp.json`
   - MCP tools are the primary interface for all code exploration.
 
diff --git a/.agents/workflows/deepinit.md b/.agents/workflows/deepinit.md
index 6183571..983bc92 100644
--- a/.agents/workflows/deepinit.md
+++ b/.agents/workflows/deepinit.md
@@ -169,9 +169,11 @@ Folder = type. Status field = lifecycle. Filenames use a 3-digit zero-padded seq
 
 - **`designs/{NNN}-{name}.md`**: permanent design references (architecture, API specs, tradeoffs)
 - **`work/{NNN}-{name}.md`**: execution plans with progress, decision log, and `Status` header (`Active` → `Completed`)
+<!-- oma-docs:ignore-start -->
 - **`work/tech-debt-tracker.md`**: known tech debt with priority, rationale, and proposed resolution
 
 Initially: create `designs/` and `work/` subdirectories + `work/tech-debt-tracker.md` with any debt discovered in Step 1.
+<!-- oma-docs:ignore-end -->
 
 ### `docs/generated/`
 
@@ -212,7 +214,9 @@ Generate only those relevant to the project:
 | `SECURITY.md` | Has auth/data handling | Security policies, threat model, auth patterns, data handling rules |
 | `CODE-REVIEW.md` | Always | Code review standards, checklist, and review behavior configuration |
 
+<!-- oma-docs:ignore-start -->
 ### `docs/CODE-REVIEW.md`
+<!-- oma-docs:ignore-end -->
 
 **Code review standards referenced from AGENTS.md.**
 
@@ -348,7 +352,9 @@ deepinit no longer detects drift on update runs; it only generates 0→1 bootstr
 5. Root AGENTS.md is under 120 lines.
 6. ARCHITECTURE.md is under 200 lines.
 7. Each boundary AGENTS.md is under 60 lines.
+<!-- oma-docs:ignore-start -->
 8. `docs/design-docs/index.md` lists all design docs that exist.
 9. `docs/product-specs/index.md` lists all product specs that exist.
+<!-- oma-docs:ignore-end -->
 
 Report validation results to the user.
diff --git a/.agents/workflows/design.md b/.agents/workflows/design.md
index 0c8c1a1..f03b361 100644
--- a/.agents/workflows/design.md
+++ b/.agents/workflows/design.md
@@ -12,7 +12,7 @@ disable-model-invocation: true
 - **You MUST use MCP tools throughout the workflow.**
   - Use code analysis tools (`get_symbols_overview`, `find_symbol`, `search_for_pattern`) to analyze the existing codebase.
   - Use memory tools (write/edit) to record design results.
-  - Memory path: configurable via `memoryConfig.basePath` (default: `.serena/memories`)
+  - Memory path: configurable via `memoryConfig.basePath` (default: `.agents/state/memories`)
   - Tool names: configurable via `memoryConfig.tools` in `.agents/mcp.json`
   - Do NOT use raw file reads or grep as substitutes.
 
diff --git a/.agents/workflows/orchestrate.md b/.agents/workflows/orchestrate.md
index b512743..9f2f6a3 100644
--- a/.agents/workflows/orchestrate.md
+++ b/.agents/workflows/orchestrate.md
@@ -11,7 +11,7 @@ disable-model-invocation: true
 - **You MUST use MCP tools throughout the entire workflow.** This is NOT optional.
   - Use code analysis tools (`get_symbols_overview`, `find_symbol`, `find_referencing_symbols`, `search_for_pattern`) for code exploration.
   - Use memory tools (read/write/edit) for progress tracking.
-  - Memory path: configurable via `memoryConfig.basePath` (default: `.serena/memories`)
+  - Memory path: configurable via `memoryConfig.basePath` (default: `.agents/state/memories`)
   - Tool names: configurable via `memoryConfig.tools` in `.agents/mcp.json`
   - Do NOT use raw file reads or grep as substitutes. MCP tools are the primary interface.
 - **Read required documents BEFORE starting.**
diff --git a/.agents/workflows/plan.md b/.agents/workflows/plan.md
index 2329166..1b6331d 100644
--- a/.agents/workflows/plan.md
+++ b/.agents/workflows/plan.md
@@ -11,7 +11,7 @@ disable-model-invocation: true
 - **You MUST use MCP tools throughout the workflow.**
   - Use code analysis tools (`get_symbols_overview`, `find_symbol`, `search_for_pattern`) to analyze the existing codebase.
   - Use memory tools (write/edit) to record planning results.
-  - Memory path: configurable via `memoryConfig.basePath` (default: `.serena/memories`)
+  - Memory path: configurable via `memoryConfig.basePath` (default: `.agents/state/memories`)
   - Tool names: configurable via `memoryConfig.tools` in `.agents/mcp.json`
   - Do NOT use raw file reads or grep as substitutes.
 
diff --git a/.agents/workflows/ralph.md b/.agents/workflows/ralph.md
index aff9b20..998ea1e 100644
--- a/.agents/workflows/ralph.md
+++ b/.agents/workflows/ralph.md
@@ -11,7 +11,7 @@ disable-model-invocation: true
 - **You MUST use MCP tools throughout the entire workflow.** This is NOT optional.
   - Use code analysis tools (`get_symbols_overview`, `find_symbol`, `find_referencing_symbols`, `search_for_pattern`) for code exploration.
   - Use memory tools (read/write/edit) for progress tracking.
-  - Memory path: configurable via `memoryConfig.basePath` (default: `.serena/memories`)
+  - Memory path: configurable via `memoryConfig.basePath` (default: `.agents/state/memories`)
   - Tool names: configurable via `memoryConfig.tools` in `.agents/mcp.json`
   - Do NOT use raw file reads or grep as substitutes. MCP tools are the primary interface for code and memory operations.
 - **This workflow does NOT stop until all completion criteria pass or safeguards trigger.**
@@ -116,7 +116,7 @@ oma ralph:verify --json --session {sessionId} --newer-than {iteration_start_iso}
 - `--session` scopes the plan artifact to this iteration's session id; `--newer-than` (this iteration's EXEC start time, ISO-8601) excludes stale artifacts from earlier iterations. Omit either when unknown.
 - The command checks the artifact table below, prints a structured result (`ok`, `checks`, `missing`, `remediation`), and exits non-zero on failure. On failure it also appends a `gate.failed` L1 event automatically.
 - **The JSON verdict IS the gate result.** Do NOT substitute your own narration for it, and do NOT proceed on a non-zero exit.
-- **Manual fallback** (only when the `oma` CLI is unavailable): check, using memory read / file existence tools, that the just-completed iteration produced ALL of the artifacts below. Resolve `{memBase}` from `memoryConfig.basePath` (default `.serena/memories`).
+- **Manual fallback** (only when the `oma` CLI is unavailable): check, using memory read / file existence tools, that the just-completed iteration produced ALL of the artifacts below. Resolve `{memBase}` from `memoryConfig.basePath` (default `.agents/state/memories`).
 
 | # | Artifact | Proves phase ran |
 |---|----------|------------------|
diff --git a/.agents/workflows/review.md b/.agents/workflows/review.md
index a8eddf2..0e1d2f7 100644
--- a/.agents/workflows/review.md
+++ b/.agents/workflows/review.md
@@ -11,7 +11,7 @@ disable-model-invocation: true
 - **You MUST use MCP tools throughout the workflow.**
   - Use code analysis tools (`get_symbols_overview`, `find_symbol`, `find_referencing_symbols`, `search_for_pattern`) for code analysis and review.
   - Use memory write tool to record review results.
-  - Memory path: configurable via `memoryConfig.basePath` (default: `.serena/memories`)
+  - Memory path: configurable via `memoryConfig.basePath` (default: `.agents/state/memories`)
   - Tool names: configurable via `memoryConfig.tools` in `.agents/mcp.json`
   - Do NOT use raw file reads or grep as substitutes.
 
diff --git a/.agents/workflows/schedule.md b/.agents/workflows/schedule.md
index a3dc24c..d1a96ff 100644
--- a/.agents/workflows/schedule.md
+++ b/.agents/workflows/schedule.md
@@ -22,7 +22,7 @@ Ask the user for the following if not already provided in the prompt:
 | Prompt | Instruction the agent will receive | `"review the latest diff"` |
 | Interval / cron | When to run | `"every 2 hours"`, `"5m"`, `"0 9 * * *"` |
 | Workspace (optional) | Absolute path to the project directory | `/home/user/myproject` (default: cwd) |
-| Vendor (optional) | CLI vendor override (passed to `oma agent:spawn -m`) | `claude`, `codex`, `antigravity`, `cursor`, `qwen`, `grok`, `opencode` |
+| Vendor (optional) | CLI vendor override (passed to `oma agent:spawn -m`) | `claude`, `codex`, `antigravity`, `cursor`, `qwen`, `grok`, `opencode`, `pi` |
 
 If all required fields are already in the user's prompt, proceed directly to Step 2.
 
@@ -63,9 +63,9 @@ Run `oma schedule:list` to display all registered jobs and confirm the new job a
 oma schedule:list
 ```
 
-Show the output to the user. Verify the new job is listed with `drift: synced`.
+Show the output to the user. Verify the new job is listed with drift state `synced`.
 
-If `drift: missing-in-os` is shown, suggest running `oma schedule:sync`.
+If `missing-in-os` is shown, suggest running `oma schedule:sync`. If `orphan-in-os` entries appear (OS jobs with no manifest entry), suggest `oma schedule:sync --prune`.
 
 ---
 
@@ -78,3 +78,4 @@ Report to the user:
 - Workspace and vendor
 - Whether the job is recurring or one-shot (`--once`)
 - Next suggested action if the job did not sync
+- How to manage the job later: `oma schedule:remove <id>` to delete, `oma schedule:run <id>` to fire it manually once
diff --git a/.agents/workflows/stack-set.md b/.agents/workflows/stack-set.md
index a7ddc17..bd16a18 100644
--- a/.agents/workflows/stack-set.md
+++ b/.agents/workflows/stack-set.md
@@ -269,7 +269,9 @@ Generate a standalone CRUD feature (component + data service) in the detected st
 **Adapt, not copy (amendment E):** Seed from `.agents/skills/oma-mobile/variants/swift-ios/` as the baseline, then adapt every value to match the detected project. Specifically:
 
 - Replace placeholder `Features/` module names with the actual feature module names found in the project (e.g., `Features/Auth`, `Features/Home`).
+<!-- oma-docs:ignore-start -->
 - Set `api_spec` to the actual path where the OpenAPI document lives in this project (default `Core/Networking/openapi.yaml` only when no other location is found).
+<!-- oma-docs:ignore-end -->
 - Set the minimum iOS deployment target to the value detected from `Package.swift` or `.xcodeproj`; default `17.0` when not specified.
 - Populate the DI wiring in the App entry snippet with the real `Client` and service types from the project, not generic placeholders.
 
diff --git a/.agents/workflows/ultrawork.md b/.agents/workflows/ultrawork.md
index df5043f..230bfaf 100644
--- a/.agents/workflows/ultrawork.md
+++ b/.agents/workflows/ultrawork.md
@@ -11,7 +11,7 @@ disable-model-invocation: true
 - **You MUST use MCP tools throughout the entire workflow.** This is NOT optional.
   - Use code analysis tools (`get_symbols_overview`, `find_symbol`, `find_referencing_symbols`, `search_for_pattern`) for code exploration.
   - Use memory tools (read/write/edit) for progress tracking.
-  - Memory path: configurable via `memoryConfig.basePath` (default: `.serena/memories`)
+  - Memory path: configurable via `memoryConfig.basePath` (default: `.agents/state/memories`)
   - Tool names: configurable via `memoryConfig.tools` in `.agents/mcp.json`
   - Do NOT use raw file reads or grep as substitutes. MCP tools are the primary interface for code and memory operations.
 - **Read the oma-coordination skill BEFORE starting.** Read `.agents/skills/oma-coordination/SKILL.md` and follow its Core Rules.
@@ -26,6 +26,23 @@ The detected runtime vendor and each agent's target vendor determine how agents
 
 ---
 
+## Cross-Context Review (CCR) Dispatch
+
+Every review step in this workflow (the 11 reviews in `multi-review-protocol.md`) runs as a **fresh, context-isolated reviewer subagent** — never inline in the main session, and never batched with implementation or with another review. This is mandatory; see the **Cross-Context Review (CCR) Mandate** in `multi-review-protocol.md` for the rationale and the two papers behind it.
+
+**One review = one fresh reviewer subagent.** The main session is the coordinator: it dispatches each review, waits for its verdict, and aggregates verdicts into the phase's `result-*.md` and `session-ultrawork.md`. For each review:
+
+1. **Resolve the reviewer's target vendor** per the Per-Agent Dispatch rules (`.agents/oma-config.yaml`). Use the native subagent path when `target_vendor === current_runtime_vendor`; otherwise use `oma agent:spawn` for that reviewer.
+2. **Build the reviewer prompt from the isolation contract only** (`multi-review-protocol.md` → CCR Mandate): the durable artifacts under review *referenced by path* (git diff, changed files, `.agents/results/plan-{sessionId}.json`, prior `result-*.md`, test/lint output) plus that single review's guide section. Do **NOT** paste this session's conversation history, the implementation agent's reasoning, or any prior review's verdict into the prompt.
+3. **Dispatch one reviewer per review.**
+   - Claude-native: `Agent(subagent_type="qa-reviewer", prompt="CCR <review name> ONLY. Inputs (read fresh, assume no prior context): <artifact paths>. Guide: <that review's section>. Write a structured verdict to memory.", run_in_background=true)` — multiple such calls in one message run in parallel, each in its own isolated context.
+   - CLI fallback: `oma agent:spawn qa-agent "CCR <review name> ONLY. Inputs (read fresh, assume no prior context): <artifact paths>. Guide: <that review's section>. Write a structured verdict to memory." session-id`
+4. **Collect** each reviewer's structured verdict from memory and fold it into the phase's `result-*.md` and `session-ultrawork.md`.
+
+Reviewers are read-only evaluators. Implementation and refactor **actions** (Phase 2 IMPL, and the structural refactor steps in Phase 4) remain with their action agents and are dispatched as before — only the review passes are isolated.
+
+---
+
 ## Phase 0: Initialization (DO NOT SKIP)
 
 1. Read `.agents/skills/oma-coordination/SKILL.md` and confirm Core Rules.
@@ -44,28 +61,30 @@ The detected runtime vendor and each agent's target vendor determine how agents
 
 ## Phase 1: PLAN (Steps 1-4)
 
-### Step 1: Create Plan & Review
+### Step 1: Create Plan
 // turbo
-Activate PM Agent to execute Steps 1-4:
+Activate PM Agent to author the plan only (reviews are dispatched separately in Steps 2-4):
 
 1. Analyze requirements.
 2. Define API contracts.
 3. Create a prioritized task breakdown.
-4. Execute Plan Review - Completeness (Step 2).
-5. Execute Meta Review (Step 3).
-6. Execute Over-Engineering Review (Step 4).
-7. Save plan to `.agents/results/plan-{sessionId}.json`.
-8. Create `task-board.md` in memory path for dashboard compatibility.
-9. Use memory write tool to record plan completion.
+4. Save plan to `.agents/results/plan-{sessionId}.json`.
+5. Create `task-board.md` in memory path for dashboard compatibility.
+6. Use memory write tool to record plan completion.
+
+The PM Agent MUST NOT review its own plan inline — that is a same-context self-review, exactly the anchoring/sycophancy failure the CCR Mandate forbids. Steps 2-4 run in fresh isolated reviewers.
+
+### Steps 2-4: Plan Reviews (Cross-Context)
+Dispatch each of Steps 2, 3, 4 as a **separate fresh isolated reviewer subagent** per the **Cross-Context Review (CCR) Dispatch** section. Each reviewer receives ONLY the plan artifact (`.agents/results/plan-{sessionId}.json`) and the original requirements, plus its own review guide section — never the PM Agent's reasoning or this session's history. Collect the three verdicts into `session-ultrawork.md` before evaluating PLAN_GATE.
 
 ### Step 2: Plan Review (Completeness)
-- **Executed by PM Agent**: Ensure requirements are fully mapped.
+- **Executed by a fresh isolated reviewer subagent (CCR)**: Ensure requirements are fully mapped.
 
 ### Step 3: Review Verification (Meta Review)
-- **Executed by PM Agent**: Self-verify if the review was sufficient.
+- **Executed by a fresh isolated reviewer subagent (CCR)**: Verify the completeness review was sufficient. Chaining exception: this reviewer MAY receive the Step 2 verdict as input, since a meta-review's job is to audit the prior review.
 
 ### Step 4: Over-Engineering Review (Simplicity)
-- **Executed by PM Agent**: Check for unnecessary complexity (MVP focus).
+- **Executed by a fresh isolated reviewer subagent (CCR)**: Check for unnecessary complexity (MVP focus).
 
 ### PLAN_GATE
 - [ ] Plan documented
@@ -164,44 +183,48 @@ If no measurement tools: skip; gates fall back to binary checklist.
 
 ## Phase 3: VERIFY (Steps 6-8)
 
-### Step 6-8: QA Verification
+### Step 6-8: QA Verification (Cross-Context Review)
 // turbo
-Spawn QA Agent to execute Steps 6-8.
+Dispatch each of Steps 6, 7, 8 as a **separate fresh isolated reviewer subagent** per the **Cross-Context Review (CCR) Dispatch** section. Do NOT run all three in one agent, and do NOT pass this session's history or the implementation agents' reasoning into any reviewer prompt. Each reviewer reads only the durable artifacts (git diff, changed files, `.agents/results/plan-{sessionId}.json`, `result-{agent}` files, test/lint output) plus its own review guide section from `multi-review-protocol.md`.
 
 #### If Claude Code
-Use the Agent tool to spawn subagent:
-- `Agent(subagent_type="qa-reviewer", prompt="Execute Phase 3 Verification. Step 6: Alignment Review. Step 7: Security/Bug Review (npm audit, OWASP). Step 8: Improvement/Regression Review. IMPORTANT: Follow .agents/skills/_shared/core/context-loading.md rules.", run_in_background=true)`
+Use three separate Agent tool calls (one message = parallel, isolated contexts):
+- `Agent(subagent_type="qa-reviewer", prompt="CCR Step 6 Alignment Review ONLY. Inputs (read fresh, assume no prior context): <diff + changed files + plan-{sessionId}.json>. Guide: Alignment Review section. Write a structured verdict to memory.", run_in_background=true)`
+- `Agent(subagent_type="qa-reviewer", prompt="CCR Step 7 Security/Bug Review ONLY (npm audit, OWASP). Inputs (read fresh, assume no prior context): <diff + changed files + audit output>. Guide: Safety Review section. Write a structured verdict to memory.", run_in_background=true)`
+- `Agent(subagent_type="qa-reviewer", prompt="CCR Step 8 Improvement/Regression Review ONLY. Inputs (read fresh, assume no prior context): <diff + test output>. Guide: Regression Review section. Write a structured verdict to memory.", run_in_background=true)`
 
 #### If Codex CLI
-Spawn native Codex custom agents using `.codex/agents/{agent}.toml` when available for QA verification.
+Spawn one native Codex custom agent (`.codex/agents/{agent}.toml`) **per review** when available, each with only its artifacts + guide section.
 If native dispatch is not verified in the current runtime, fall back to `oma agent:spawn`.
 
 #### If Gemini CLI or Antigravity or CLI Fallback
 ```bash
-oma agent:spawn qa-agent "Execute Phase 3 Verification. Step 6: Alignment Review. Step 7: Security/Bug Review (npm audit, OWASP). Step 8: Improvement/Regression Review. IMPORTANT: Follow .agents/skills/_shared/core/context-loading.md rules." session-id
+oma agent:spawn qa-agent "CCR Step 6 Alignment Review ONLY. Inputs (read fresh): <diff + plan-{sessionId}.json>. Guide: Alignment Review section. Write a structured verdict to memory." session-id
+oma agent:spawn qa-agent "CCR Step 7 Security/Bug Review ONLY (npm audit, OWASP). Inputs (read fresh): <diff + audit output>. Guide: Safety Review section. Write a structured verdict to memory." session-id
+oma agent:spawn qa-agent "CCR Step 8 Regression Review ONLY. Inputs (read fresh): <diff + test output>. Guide: Regression Review section. Write a structured verdict to memory." session-id
 ```
 
 ---
 
-### Monitor QA Agent Progress
+### Monitor Reviewers & Aggregate
 
-**Wait for QA Agent to complete verification before proceeding.**
+**Wait for all three VERIFY reviewers to complete before proceeding.**
 
-1. Use memory read tool to poll `progress-qa-agent[-{sessionId}].md`
-2. Check for `result-qa-agent[-{sessionId}].md` to confirm completion
-   - **Claude-native path**: the Agent tool returns synchronously and the `qa-reviewer` subagent writes `result-qa[-{sessionId}].md` under `.agents/results/` — check that file instead of polling.
-3. Use memory edit tool to record QA results in `session-ultrawork.md`
+1. Use memory read tool to poll each reviewer's `progress-*` / verdict entry.
+2. Confirm each reviewer wrote its structured verdict to memory.
+   - **Claude-native path**: each `qa-reviewer` Agent call returns synchronously with its verdict.
+3. **Aggregate** the three verdicts into `result-qa-{sessionId}.md` under `.agents/results/` (this satisfies the VERIFY artifact contract) and record the combined VERIFY result in `session-ultrawork.md`.
 
-**Continue polling until QA Agent reports completion.**
+**Continue polling until all three reviewers report completion.**
 
 ### Step 6: Alignment Review
-- **Executed by QA Agent**: Compare implementation vs plan.
+- **Executed by a fresh isolated reviewer subagent (CCR)**: Compare implementation vs plan.
 
 ### Step 7: Security/Bug Review (Safety)
-- **Executed by QA Agent**: Check for vulnerabilities (Safety).
+- **Executed by a fresh isolated reviewer subagent (CCR)**: Check for vulnerabilities (Safety).
 
 ### Step 8: Improvement Review (Regression Prevention)
-- **Executed by QA Agent**: Run regression tests.
+- **Executed by a fresh isolated reviewer subagent (CCR)**: Run regression tests.
 
 ### Step 8.1: Measure Post-VERIFY Quality Score (Conditional)
 
@@ -244,48 +267,59 @@ If baseline was measured at Step 5.2:
 
 ### Step 9-13: Deep Refinement
 // turbo
-Spawn Debug Agent (or Senior Dev Agent) to execute Steps 9-13.
+REFINE mixes two kinds of work: **reviews** (Steps 10, 12), which are read-only evaluations, and **refactor actions** (Steps 9, 11, 13), which change code.
+
+**First, dispatch the two reviews as fresh isolated reviewer subagents** per the **Cross-Context Review (CCR) Dispatch** section — one reviewer for Step 10 (Reusability), one for Step 12 (Consistency). Each reads only the durable artifacts (git diff, changed files) plus its guide section; do not pass this session's history or the implementation agents' reasoning. Collect their verdicts from memory.
+
+**Then, spawn the Debug Agent** to perform the refactor actions (Steps 9, 11, 13) and apply the isolated reviewers' findings, and to write `result-debug-{sessionId}.md` (this satisfies the REFINE artifact contract).
 
 #### If Claude Code
-Use the Agent tool to spawn subagent:
-- `Agent(subagent_type="debug-investigator", prompt="Execute Phase 4 Refine. Step 9: Split large files. Step 10: Integration check. Step 11: Side Effect analysis (find_referencing_symbols). Step 12: Consistency review. Step 13: Cleanup dead code. IMPORTANT: Follow .agents/skills/_shared/core/context-loading.md rules.", run_in_background=true)`
+Reviews (two separate calls, isolated contexts):
+- `Agent(subagent_type="qa-reviewer", prompt="CCR Step 10 Reusability Review ONLY. Inputs (read fresh, assume no prior context): <diff + changed files>. Guide: Reusability Review section. Write a structured verdict to memory.", run_in_background=true)`
+- `Agent(subagent_type="qa-reviewer", prompt="CCR Step 12 Consistency Review ONLY. Inputs (read fresh, assume no prior context): <diff + changed files>. Guide: Consistency Review section. Write a structured verdict to memory.", run_in_background=true)`
+
+Refactor actions (after the review verdicts are collected):
+- `Agent(subagent_type="debug-investigator", prompt="Execute Phase 4 refactor actions. Step 9: Split large files. Step 11: Side Effect analysis (find_referencing_symbols). Step 13: Cleanup dead code. Apply the collected Reusability/Consistency verdicts. Write result-debug-{sessionId}.md. IMPORTANT: Follow .agents/skills/_shared/core/context-loading.md rules.", run_in_background=true)`
 
 #### If Codex CLI
-Spawn native Codex custom agents using `.codex/agents/{agent}.toml` when available for refinement tasks.
+Spawn one native Codex reviewer per review (`.codex/agents/{agent}.toml`) with only its artifacts + guide section, then a native refactor agent for Steps 9/11/13.
 If native dispatch is not verified in the current runtime, fall back to `oma agent:spawn`.
 
 #### If Gemini CLI or Antigravity or CLI Fallback
 ```bash
-oma agent:spawn debug-agent "Execute Phase 4 Refine. Step 9: Split large files. Step 10: Integration check. Step 11: Side Effect analysis (find_referencing_symbols). Step 12: Consistency review. Step 13: Cleanup dead code. IMPORTANT: Follow .agents/skills/_shared/core/context-loading.md rules." session-id
+oma agent:spawn qa-agent "CCR Step 10 Reusability Review ONLY. Inputs (read fresh): <diff>. Guide: Reusability Review section. Write a structured verdict to memory." session-id
+oma agent:spawn qa-agent "CCR Step 12 Consistency Review ONLY. Inputs (read fresh): <diff>. Guide: Consistency Review section. Write a structured verdict to memory." session-id
+oma agent:spawn debug-agent "Execute Phase 4 refactor actions. Step 9: Split large files. Step 11: Side Effect analysis. Step 13: Cleanup dead code. Apply the collected Reusability/Consistency verdicts. Write result-debug-{sessionId}.md. IMPORTANT: Follow .agents/skills/_shared/core/context-loading.md rules." session-id
 ```
 
 ---
 
-### Monitor Debug Agent Progress
+### Monitor Reviewers & Debug Agent Progress
 
-**Wait for Debug Agent to complete refinement before proceeding.**
+**Wait for the two reviewers and the Debug Agent to complete refinement before proceeding.**
 
-1. Use memory read tool to poll `progress-debug-agent[-{sessionId}].md`
-2. Check for `result-debug-agent[-{sessionId}].md` to confirm completion
+1. Confirm both isolated reviewers wrote their structured verdicts to memory.
+2. Use memory read tool to poll `progress-debug-agent[-{sessionId}].md`
+3. Check for `result-debug-agent[-{sessionId}].md` to confirm completion
    - **Claude-native path**: the Agent tool returns synchronously and the `debug-investigator` subagent writes `result-debug[-{sessionId}].md` under `.agents/results/` — check that file instead of polling.
-3. Use memory edit tool to record refinement results in `session-ultrawork.md`
+4. Use memory edit tool to record refinement results (reviews + actions) in `session-ultrawork.md`
 
-**Continue polling until Debug Agent reports completion.**
+**Continue polling until the reviewers and Debug Agent report completion.**
 
 ### Step 9: Split Large Files/Functions
-- **Executed by Debug Agent**: Files > 500 lines, Functions > 50 lines.
+- **Executed by Debug Agent (action)**: Files > 500 lines, Functions > 50 lines.
 
 ### Step 10: Integration/Reuse Review (Reusability)
-- **Executed by Debug Agent**: Check for duplicate logic.
+- **Executed by a fresh isolated reviewer subagent (CCR)**: Check for duplicate logic.
 
 ### Step 11: Side Effect Review (Cascade Impact)
-- **Executed by Debug Agent**: Analyze impact scope.
+- **Executed by Debug Agent (action)**: Analyze impact scope.
 
 ### Step 12: Full Change Review (Consistency)
-- **Executed by Debug Agent**: Review naming and style.
+- **Executed by a fresh isolated reviewer subagent (CCR)**: Review naming and style.
 
 ### Step 13: Clean Up Unused Code
-- **Executed by Debug Agent**: Remove newly created dead code.
+- **Executed by Debug Agent (action)**: Remove newly created dead code.
 
 ### Step 13.1: Measure Post-REFINE Quality Score (Conditional)
 
@@ -324,47 +358,52 @@ If baseline was measured at Step 5.2:
 
 ## Phase 5: SHIP (Steps 14-17)
 
-### Step 14-17: Final QA & Deployment Readiness
+### Step 14-17: Final QA & Deployment Readiness (Cross-Context Review)
 // turbo
-Spawn QA Agent to execute Steps 14-17.
+Dispatch each of Steps 14, 15, 16, 17 as a **separate fresh isolated reviewer subagent** per the **Cross-Context Review (CCR) Dispatch** section. Do NOT run them in one agent, and do NOT pass this session's history or the implementation/refine agents' reasoning into any reviewer prompt. Each reviewer reads only the durable artifacts (git diff, changed files, lint/coverage output, prior `result-*.md`) plus its own review guide section.
 
 #### If Claude Code
-Use the Agent tool to spawn subagent:
-- `Agent(subagent_type="qa-reviewer", prompt="Execute Phase 5 Ship. Step 14: Quality Review (lint/coverage). Step 15: UX Flow Verification. Step 16: Related Issues Review. Step 17: Deployment Readiness. IMPORTANT: Follow .agents/skills/_shared/core/context-loading.md rules.", run_in_background=true)`
+Use separate Agent tool calls (one message = parallel, isolated contexts):
+- `Agent(subagent_type="qa-reviewer", prompt="CCR Step 14 Code Quality Review ONLY (lint/coverage). Inputs (read fresh, assume no prior context): <diff + lint/coverage output>. Guide: Quality Review section. Write a structured verdict to memory.", run_in_background=true)`
+- `Agent(subagent_type="qa-reviewer", prompt="CCR Step 15 UX Flow Verification ONLY. Inputs (read fresh, assume no prior context): <diff + user journey/routes>. Write a structured verdict to memory.", run_in_background=true)`
+- `Agent(subagent_type="qa-reviewer", prompt="CCR Step 16 Related Issues / Cascade Impact Review ONLY. Inputs (read fresh, assume no prior context): <diff + find_referencing_symbols impact>. Guide: Cascade Impact Review section. Write a structured verdict to memory.", run_in_background=true)`
+- `Agent(subagent_type="qa-reviewer", prompt="CCR Step 17 Deployment Readiness Review ONLY. Inputs (read fresh, assume no prior context): <diff + secrets/migrations checklist>. Guide: Final Review section. Write a structured verdict to memory.", run_in_background=true)`
 
 #### If Codex CLI
-Spawn native Codex custom agents using `.codex/agents/{agent}.toml` when available for final QA and deployment readiness tasks.
+Spawn one native Codex reviewer per review (`.codex/agents/{agent}.toml`) when available, each with only its artifacts + guide section.
 If native dispatch is not verified in the current runtime, fall back to `oma agent:spawn`.
 
 #### If Gemini CLI or Antigravity or CLI Fallback
 ```bash
-oma agent:spawn qa-agent "Execute Phase 5 Ship. Step 14: Quality Review (lint/coverage). Step 15: UX Flow Verification. Step 16: Related Issues Review. Step 17: Deployment Readiness. IMPORTANT: Follow .agents/skills/_shared/core/context-loading.md rules." session-id
+oma agent:spawn qa-agent "CCR Step 14 Code Quality Review ONLY (lint/coverage). Inputs (read fresh): <diff + lint output>. Guide: Quality Review section. Write a structured verdict to memory." session-id
+oma agent:spawn qa-agent "CCR Step 15 UX Flow Verification ONLY. Inputs (read fresh): <diff + routes>. Write a structured verdict to memory." session-id
+oma agent:spawn qa-agent "CCR Step 16 Cascade Impact Review ONLY. Inputs (read fresh): <diff + impact>. Guide: Cascade Impact Review section. Write a structured verdict to memory." session-id
+oma agent:spawn qa-agent "CCR Step 17 Deployment Readiness Review ONLY. Inputs (read fresh): <diff + checklist>. Guide: Final Review section. Write a structured verdict to memory." session-id
 ```
 
 ---
 
-### Monitor Final QA Progress
+### Monitor Reviewers & Aggregate
 
-**Wait for QA Agent to complete final review before proceeding.**
+**Wait for all SHIP reviewers to complete final review before proceeding.**
 
-1. Use memory read tool to poll `progress-qa-agent[-{sessionId}].md`
-2. Check for `result-qa-agent[-{sessionId}].md` to confirm completion
-   - **Claude-native path**: the Agent tool returns synchronously and the `qa-reviewer` subagent writes `result-qa[-{sessionId}].md` under `.agents/results/` — check that file instead of polling.
-3. Use memory edit tool to record final QA results in `session-ultrawork.md`
+1. Confirm each reviewer wrote its structured verdict to memory.
+   - **Claude-native path**: each `qa-reviewer` Agent call returns synchronously with its verdict.
+2. **Aggregate** the verdicts into `result-qa-{sessionId}.md` under `.agents/results/` (this satisfies the SHIP artifact contract) and record the combined final result in `session-ultrawork.md`.
 
-**Continue polling until QA Agent reports completion.**
+**Continue polling until all SHIP reviewers report completion.**
 
 ### Step 14: Code Quality Review
-- **Executed by QA Agent**: Lint, Types, Coverage.
+- **Executed by a fresh isolated reviewer subagent (CCR)**: Lint, Types, Coverage.
 
 ### Step 15: UX Flow Verification
-- **Executed by QA Agent**: User journey check.
+- **Executed by a fresh isolated reviewer subagent (CCR)**: User journey check.
 
 ### Step 16: Related Issues Review (Cascade Impact 2nd)
-- **Executed by QA Agent**: Final impact check.
+- **Executed by a fresh isolated reviewer subagent (CCR)**: Final impact check.
 
 ### Step 17: Deployment Readiness Review (Final)
-- **Executed by QA Agent**: Secrets, Migrations, checklist.
+- **Executed by a fresh isolated reviewer subagent (CCR)**: Secrets, Migrations, checklist.
 
 ### Step 17.1: Final Quality Score & Session Summary (Conditional)
 
@@ -414,15 +453,17 @@ This hook is opt-in; the default `auto_verify: false` skips this step entirely.
 
 ## Review Steps Summary
 
-| Phase  | Steps | Agent       | Execution | Perspective                       |
-| ------ | ----- | ----------- | --------- | --------------------------------- |
-| PLAN   | 1-4   | PM Agent    | Inline    | Completeness, Meta, Simplicity    |
-| IMPL   | 5     | Dev Agents  | Spawn     | Implementation                    |
-| VERIFY | 6-8   | QA Agent    | Spawn     | Alignment, Safety, Regression     |
-| REFINE | 9-13  | Debug Agent | Spawn     | Reusability, Cascade, Consistency |
-| SHIP   | 14-17 | QA Agent    | Spawn     | Quality, UX, Cascade 2nd, Deploy  |
+| Phase  | Steps | Agent                        | Execution            | Perspective                       |
+| ------ | ----- | ---------------------------- | -------------------- | --------------------------------- |
+| PLAN   | 1-4   | PM (author) + CCR reviewers  | CCR isolated review  | Completeness, Meta, Simplicity    |
+| IMPL   | 5     | Dev Agents                   | Spawn (action)       | Implementation                    |
+| VERIFY | 6-8   | CCR reviewers                | CCR isolated review  | Alignment, Safety, Regression     |
+| REFINE | 9-13  | Debug Agent + CCR reviewers  | Action + CCR review  | Reusability, Cascade, Consistency |
+| SHIP   | 14-17 | CCR reviewers                | CCR isolated review  | Quality, UX, Cascade 2nd, Deploy  |
+
+**Total 11 review steps, each run in a fresh isolated reviewer (Cross-Context Review), + conditional Quality Score checkpoints → High quality guaranteed**
 
-**Total 11 review steps + conditional Quality Score checkpoints → High quality guaranteed**
+Every review runs in its own fresh context (never inline, never batched) per the **Cross-Context Review (CCR) Dispatch** section and the CCR Mandate in `multi-review-protocol.md`.
 
 ---
 
diff --git a/.agents/workflows/ultrawork/resources/multi-review-protocol.md b/.agents/workflows/ultrawork/resources/multi-review-protocol.md
index 4f328b7..ec9640d 100644
--- a/.agents/workflows/ultrawork/resources/multi-review-protocol.md
+++ b/.agents/workflows/ultrawork/resources/multi-review-protocol.md
@@ -5,6 +5,38 @@
 
 ---
 
+## Cross-Context Review (CCR) Mandate
+
+**Every review below runs in a fresh, context-isolated reviewer subagent — never inline in the main session, and never batched with implementation work or another review.**
+
+### Why isolation is mandatory
+- Same-session review is degraded by anchoring and sycophancy: a reviewer that shares the author's context tends to ratify the author's choices instead of independently re-deriving them. Cross-Context Review measurably outperforms repeated same-session review (F1 28.6% cross-context vs 21.7% same-session repeated) — arXiv 2603.12123, "Cross-Context Review".
+- Adding more same-session review rounds does not recover the gap and can amplify shared-context error — arXiv 2603.16244, "More Rounds, More Noise". The fix is a fresh context per review, not more passes in the same one.
+
+### Isolation contract (per review)
+Each reviewer subagent's prompt MUST contain ONLY:
+1. The **durable artifacts** under review, referenced by path so the reviewer reads them fresh: git diff, changed files, `.agents/results/plan-{sessionId}.json`, prior `result-*.md`, and test/lint output.
+2. **That single review's guide section** copied from below.
+
+Each reviewer subagent's prompt MUST NOT contain:
+- the main session's conversation history,
+- the implementation agent's reasoning or self-justification, or
+- any prior review's verdict — **unless** that review's guide explicitly requires chaining a specific prior finding (none below do by default).
+
+### Verdict output
+The reviewer writes a structured verdict to memory per `.agents/skills/_shared/runtime/memory-protocol.md`:
+
+```
+review: <name> (Step N)
+verdict: PASS | FAIL
+findings: [ { severity: CRITICAL|HIGH|MEDIUM|LOW, file:line, description, fix } ]
+evidence: <artifact paths the reviewer actually read>
+```
+
+The phase coordinator collects these verdicts and folds them into the phase's `result-*.md` and `session-ultrawork.md` records. Dispatch mechanics (native subagent vs `oma agent:spawn`) are defined once in the **Cross-Context Review (CCR) Dispatch** section of `ultrawork.md`.
+
+---
+
 ## Review Types Guide
 
 ### 1. Completeness Review (Step 2)
diff --git a/.agents/workflows/ultrawork/resources/phase-gates.md b/.agents/workflows/ultrawork/resources/phase-gates.md
index bd09f62..81d57ac 100644
--- a/.agents/workflows/ultrawork/resources/phase-gates.md
+++ b/.agents/workflows/ultrawork/resources/phase-gates.md
@@ -2,6 +2,8 @@
 
 Each phase must pass its gate before proceeding to the next.
 
+The "Owner" of each gate coordinates the phase and records the verdict; it does **not** review its own phase inline. The review-type criteria below (completeness, alignment, safety, reusability, consistency, quality, cascade, final) are assessed by fresh, context-isolated reviewer subagents per the **Cross-Context Review (CCR) Dispatch** section of `ultrawork.md` and the CCR Mandate in `multi-review-protocol.md`. On a repeated gate failure, re-review with a fresh reviewer context — adding more same-context passes does not recover the gap.
+
 ---
 
 ## PLAN_GATE
diff --git a/.agents/workflows/video.md b/.agents/workflows/video.md
index 61b4227..c0f58f1 100644
--- a/.agents/workflows/video.md
+++ b/.agents/workflows/video.md
@@ -13,7 +13,7 @@ disable-model-invocation: true
 - **Web capture: human-driven, no credential automation, masked.** For `demo --source web`, the tool only opens a headed browser and records — a **human** performs the entire on-screen flow and any login. **NEVER** script, type, or automate credentials of any kind. The `--url` and any query tokens are **masked** in logs and the manifest; credentials are never stored or printed; all outputs stay in the run dir. The skill provides only the mechanism — assume and prescribe **nothing** about what the flow is or what the recording is for, and bake in **no** platform- or policy-specific guidance.
 - **The `oma video` CLI owns the pipeline. This workflow owns the brief, the agent-authored script, the QA loop, and decision checkpoints.** Do NOT reimplement orchestration, provider selection, or rendering in the workflow.
 - **You MUST use MCP tools where the project provides them.**
-  - Use memory tools (read/write/edit) for run tracking. Memory path: configurable via `memoryConfig.basePath` (default: `.serena/memories`).
+  - Use memory tools (read/write/edit) for run tracking. Memory path: configurable via `memoryConfig.basePath` (default: `.agents/state/memories`).
   - Tool names: configurable via `memoryConfig.tools` in `.agents/mcp.json`.
 - **Read the oma-video skill BEFORE starting.** Read `.agents/skills/oma-video/SKILL.md` and follow its Core Rules and execution protocol, including `resources/execution-protocol.md`. If the skill is not installed, stop and ask the user to run `oma install` first.
 
@@ -75,7 +75,7 @@ For `demo`, also resolve the **source**: a recorded file or Cap → `--source fi
    ```bash
    oma video doctor --format json
    ```
-   This reports Node / Chromium / FFmpeg, Voicebox MCP (oma-voice), oma-image vendors, optional Pixelle-MCP, Cap, and (for `demo --source web`) Playwright web-capture readiness. If Remotion is not yet installed, doctor performs the **install-once** bootstrap — do not install during a run. For web capture, `oma video doctor --install-playwright` is the one-time install (`npm i playwright` + chromium); it reuses the project's Playwright when present.
+   This reports Node / Chromium / FFmpeg, the vendored Remotion project, the embedded Pretendard font, Voicebox MCP (oma-voice), oma-image vendors, optional Pixelle-MCP, Cap, and (for `demo --source web`) Playwright web-capture readiness. **Doctor does NOT auto-bootstrap** — plain `oma video doctor` only reports. If Remotion is not yet installed, run `oma video doctor --install` (one-time: deps + Chrome Headless Shell + Pretendard font fetch) — do not install during a run. The MPT fallback compositor needs a one-time `oma video doctor --install-mpt` (clone + venv + deps). For web capture, `oma video doctor --install-playwright` is the one-time install (`npm i playwright` + chromium); it reuses the project's Playwright when present.
 3. If doctor reports a hard blocker for the chosen mode (e.g. no compositor for `shorts`/`explainer`), report the remediation and stop. If only an optional provider is missing (Pexels, Pixelle, Cap), note it and continue on the fallback.
 4. Record run start with the memory write tool: brief summary, requested mode, doctor result.
 
@@ -108,12 +108,13 @@ The agent writes the script — this is the start of the determinism boundary. D
    - `demo`: narration + on-screen callouts over the captured footage; visual refs point at the ingested capture segments.
 4. Translate narration / on-screen text via oma-translator when `locale` differs from the source language (key-free). If oma-translator is absent, keep the source text and let the run warn.
 5. // turbo
-   Hand the agent-authored script to the CLI as a custom script and let it validate against the schema. Use `--dry-run` for the first pass so the pipeline emits `script.json` + `render-spec.json` + `manifest.json` **without rendering**:
+   Write the agent-authored script to a file and hand it to the CLI via `--script <path>` so it validates against the schema. **`--script` is mandatory for the agent-as-key path: without it the CLI builds its own skeleton script from the brief and your authored script is never used.** Use `--dry-run` for the first pass so the pipeline emits `script.json` + `render-spec.json` + `manifest.json` **without rendering**:
    ```bash
    oma video generate "<brief>" --mode <mode> --aspect <aspect> --locale <lang> \
      --captions <tiktok|lower-third|none> --visual <auto|generate|stock|aigc|slide> \
      --voice <profile|none> --music <upbeat|calm|none> --duration <sec|auto> \
-     --compositor <remotion|mpt> --seed <n> --dry-run --format json
+     --compositor <remotion|mpt> --seed <n> \
+     --script <path-to-agent-authored-script.json> --dry-run --format json
    ```
 6. Review the emitted `script.json` for scene count, durations, and narration quality. Iterate here — fixing the script is cheap; fixing a render is not.
 
@@ -124,12 +125,12 @@ The agent writes the script — this is the start of the determinism boundary. D
 The CLI orchestrator fans out the asset tracks per the asset bus. Trigger the full (non-dry) run; the orchestrator runs the tracks and writes them into the run directory. **Do not author assets by hand.**
 
 ```bash
-oma video generate "<brief>" --mode <mode> [same flags as Step 3, without --dry-run] --format json
+oma video generate "<brief>" --mode <mode> [same flags as Step 3, incl. --script <path>, without --dry-run] --format json
 ```
 
 The three tracks (per `.agents/skills/oma-video/SKILL.md` and its execution protocol):
 
-- **Voice** (oma-voice / Voicebox MCP) → `audio/narration-*.wav` + `timing.json`. Timing source preference: TTS-native → `voicebox-stt` (transcribe the generated wav) → `whisper.cpp` → `estimated`. If oma-voice is down, the run falls back to silent + estimated timing and warns — it does not hard-fail.
+- **Voice** (oma-voice / Voicebox MCP) → a **single** `audio/narration-01.wav` (all scene lines joined into one track — not per-scene files) + `timing.json`. Timing source preference: TTS-native → `voicebox-stt` (transcribe the generated wav) → `whisper.cpp` → `estimated`. If oma-voice is down, the run falls back to silent + estimated timing and warns — it does not hard-fail.
 - **Visual** (per-scene, fallback chain `oma-image → pexels → pixelle`) → `visuals/scene-NN.*`. Default is key-free oma-image stills (aspect snapped to the nearest 16-multiple; Remotion crops to exact frame). `--visual stock` engages Pexels only when `PEXELS_API_KEY` is set; `--visual aigc` engages Pixelle only after consent + cost gate. Each scene that falls back is recorded with `pathTaken: fallback`.
 - **Caption** (key-free) → `captions.srt` / `.vtt`, aligned to `timing.json`, styled `tiktok` or `lower-third`, with platform safe-area presets. Non-source locales translate via oma-translator; if absent, captions keep the source locale and warn.
 
@@ -145,7 +146,8 @@ For `demo`, the orchestrator produces the footage in place of synthetic visuals,
   2. Prompts on the terminal: the **human performs the entire on-screen flow** (whatever it is — multi-page popups / new tabs / redirects are all recorded generically) and presses **ENTER** to stop. The tool **never automates a login**; if the flow needs one, the human does it.
   3. Records to a real `capture.mp4` in the run dir, validated with ffprobe. The `--url` and any query tokens are **masked** in logs and `manifest.json`; outputs stay in the run dir.
   4. **Fallback (key-optional, non-blocking):** if Playwright is unresolvable, or there is no interactive TTY (CI / `-y` / no stdin), the orchestrator falls back to the **guided protocol** and warns — it never hangs. `--capture-stop duration:<sec>|selector:<css>` gives CI a non-interactive stop instead of the ENTER prompt.
-  5. Live capture is **outside** the determinism boundary, so the manifest records `nondeterministic: true`.
+  5. **Display caveat:** the capture launches a **headed** Chromium, which needs a display. On display-less hosts (CI / Linux without X), pass `--capture-stop …` — the driver then runs headless (`record.mjs --headless 1`) — or expect a capture error / guided fallback.
+  6. Live capture is **outside** the determinism boundary, so the manifest records `nondeterministic: true`.
 
 > **Optional fast-path (agent sessions only):** when an agent session has a Playwright/Chrome MCP available, it may drive the headed flow through that MCP as a complement. This is **not** the primary path — the CLI web-capture subprocess remains canonical, and the same rules hold (human drives any login, URL/tokens masked, run-dir-only).
 
@@ -171,7 +173,7 @@ For `demo`, the orchestrator produces the footage in place of synthetic visuals,
    - **Remotion** (default, all modes): renders the vendored `Shorts` / `Explainer` / `Demo` composition from `render-spec.json` props, with embedded Pretendard for cross-machine identical output. Long renders are SIGINT-abortable.
    - **MoneyPrinterTurbo** (`--compositor mpt`, shorts e2e alt): the agent-written script is injected in custom-script mode; provider keys are env-only and masked in logs.
    - **Demo raw vs `--polish`**: for `demo`, the **default** is the raw captured footage copied through as the output (no compositor over-processing). `--polish` overlays the Remotion `Demo` composition (intro / captions / zoom) with the captured `capture.mp4` as the full-frame background.
-2. If Remotion bootstrap fails (`CompositorBootstrapError`), the doctor remediation is the fix path — re-run `oma video doctor` to install once, then re-render. Do not attempt an ad-hoc install mid-run.
+2. If Remotion bootstrap fails (`CompositorBootstrapError`), the doctor remediation is the fix path — run `oma video doctor --install` once, then re-render. Do not attempt an ad-hoc install mid-run.
 3. // turbo
    To reproduce or re-render an existing run without regenerating assets (deterministic from the spec):
    ```bash
@@ -188,7 +190,7 @@ Review the finished video against the brief and the quality bars. Iterate by re-
 1. **Checklist** (priority order: correctness → sync → readability → polish):
    - Output plays; duration matches the script total within tolerance.
    - Narration audio is present (or intentionally silent) and aligns to scenes.
-   - Captions are synced to `timing.json`, within the safe area, and legible (greedy-wrap, Pretendard, design rule 2).
+   - Captions are synced to `timing.json`, within the safe area, and legible (static windowed cues, CSS-wrapped, Pretendard, design rule 2).
    - Visuals match each scene's intent; no placeholder leakage unless the run intentionally used the fallback.
    - Aspect / dimensions are correct for the mode; branding/music applied as requested.
 2. **Route each defect to its stage:**
@@ -212,7 +214,7 @@ Review the finished video against the brief and the quality bars. Iterate by re-
 1. Confirm the run directory is complete (mirrors `.agents/results/videos/<runId>-<mode>/`):
    ```
    script.json · timing.json · render-spec.json
-   audio/narration-*.wav
+   audio/narration-01.wav                # single narration track (all lines joined)
    visuals/scene-*.{jpg,png,mp4}        # synthetic modes
    capture.mp4                           # demo: ingested or web-captured footage
    captions.srt (+ .vtt)
diff --git a/.agents/workflows/work.md b/.agents/workflows/work.md
index 337f69d..5466ecb 100644
--- a/.agents/workflows/work.md
+++ b/.agents/workflows/work.md
@@ -11,7 +11,7 @@ disable-model-invocation: true
 - **You MUST use MCP tools throughout the entire workflow.** This is NOT optional.
   - Use code analysis tools (`get_symbols_overview`, `find_symbol`, `find_referencing_symbols`, `search_for_pattern`) for code exploration.
   - Use memory tools (read/write/edit) for progress tracking.
-  - Memory path: configurable via `memoryConfig.basePath` (default: `.serena/memories`)
+  - Memory path: configurable via `memoryConfig.basePath` (default: `.agents/state/memories`)
   - Tool names: configurable via `memoryConfig.tools` in `.agents/mcp.json`
   - Do NOT use raw file reads or grep as substitutes. MCP tools are the primary interface for code and memory operations.
 - **Read the oma-coordination skill BEFORE starting.** Read `.agents/skills/oma-coordination/SKILL.md` and follow its Core Rules.
diff --git a/.claude/rules/market.md b/.claude/rules/market.md
index 2dfc461..8fe8536 100644
--- a/.claude/rules/market.md
+++ b/.claude/rules/market.md
@@ -9,12 +9,12 @@ description: Market research standards - trap detection, keyless-first sourcing,
 ## Core Rules
 
 1. **Preflight first**: every market research task starts with `oma market detect-trap`. If it refuses, surface the reframe to the user — never bypass without `--force`.
-2. **Keyless-first**: default to sources that need no API key (reddit, hn, bluesky, mastodon, github-issues, grounding). Paid sources (x, tiktok, instagram, youtube, perplexity) auto-enable only when env keys are present.
-3. **Reuse oma-search**: all fetches go through `oma search fetch --only api`. Do not call platform APIs directly from market commands. Trust labels come from oma-search.
+2. **Keyless-first**: default to sources that need no API key (reddit, hn, bluesky, mastodon, github, grounding). youtube joins automatically when the `yt-dlp` binary is installed. Env-keyed sources (x, tiktok, instagram, perplexity) are skipped with a stderr notice when their key is absent.
+3. **Fetch inside harvest only**: all network fetches happen inside `oma market harvest` via its built-in per-source fetchers. Do not call platform APIs directly from other market stages or from the agent.
 4. **Deterministic compute**: score, fuse, cluster stages must produce byte-identical output on `OMA_MARKET_MOCK=1` fixture replay. Stage stdin/stdout is pure JSON; stderr is warn/error only.
 5. **LAW enforcement**: render output must pass the 8 LAWs (see `.agents/skills/oma-market/resources/output-laws.md`). LAW self-check is mandatory; `--no-self-check` is debug-only.
 6. **Cite or fall back**: every representative cited in the brief is `[name](url)`. If URL is missing, use plain text — never `[name]()`.
 7. **Coverage transparency**: when `sources_failed` is non-empty, render must annotate "coverage: N/M sources" in the engine footer.
 8. **Intent → framework auto-toggle**: pain/trend → SWOT only; competitor → SWOT + Porter's 5F; discovery → SWOT + PESTEL. User `--frameworks` flag overrides.
 9. **Single brief, single date**: one run = one md file at `.agents/results/market/{topic-slug}-{YYYYMMDD}.md`. Rerunning same day overwrites; previous run is responsible to git the file if needed.
-10. **Personal data refuse**: detect-trap blocks queries that target a private individual's personal data. Founders, creators, and public handles are allowed (last30days person-mode parity).
+10. **Personal data refuse**: refuse queries that target a private individual's personal data before running the pipeline. This is an agent-level gate — `detect-trap` automates demographic-shopping and overly-broad-topic refusal only. Founders, creators, and public handles are allowed (last30days person-mode parity).
diff --git a/.claude/settings.json b/.claude/settings.json
index 21b72b0..f8f85ed 100644
--- a/.claude/settings.json
+++ b/.claude/settings.json
@@ -36,6 +36,18 @@
         ],
         "matcher": "Bash"
       }
+    ],
+    "SessionStart": [
+      {
+        "hooks": [
+          {
+            "name": "oma-hook-SessionStart",
+            "type": "command",
+            "command": "\"$CLAUDE_PROJECT_DIR/.claude/hooks/oma-hook.sh\" --vendor 'claude' --event 'SessionStart'",
+            "timeout": 13
+          }
+        ]
+      }
     ]
   },
   "statusLine": {
diff --git a/.codex/config.toml b/.codex/config.toml
index 6b5cd58..6425888 100644
--- a/.codex/config.toml
+++ b/.codex/config.toml
@@ -1,6 +1,5 @@
 [features]
 goals = true
-child_agents_md = true
 hooks = true
 
 [mcp_servers.serena]
diff --git a/.cursor/hooks.json b/.cursor/hooks.json
index a3e9507..7b6549e 100644
--- a/.cursor/hooks.json
+++ b/.cursor/hooks.json
@@ -17,6 +17,26 @@
         "command": "'.cursor/hooks/oma-hook.sh' --vendor 'cursor' --event 'beforeSubmitPrompt'",
         "timeout": 21
       }
+    ],
+    "preToolUse": [
+      {
+        "command": "'.cursor/hooks/oma-hook.sh' --vendor 'cursor' --event 'preToolUse' --matcher 'Shell'",
+        "timeout": 10,
+        "matcher": "Shell"
+      }
+    ],
+    "stop": [
+      {
+        "command": "'.cursor/hooks/oma-hook.sh' --vendor 'cursor' --event 'stop'",
+        "timeout": 10,
+        "loop_limit": null
+      }
+    ],
+    "sessionStart": [
+      {
+        "command": "'.cursor/hooks/oma-hook.sh' --vendor 'cursor' --event 'sessionStart'",
+        "timeout": 13
+      }
     ]
   },
   "version": 1
diff --git a/.cursor/hooks/filter-test-output.sh b/.cursor/hooks/filter-test-output.sh
new file mode 100755
index 0000000..d114cc3
--- /dev/null
+++ b/.cursor/hooks/filter-test-output.sh
@@ -0,0 +1,52 @@
+#!/usr/bin/env bash
+# filter-test-output.sh — Strip passing test indicators, keep failures and summaries
+# Pipe usage: test_command 2>&1 | bash filter-test-output.sh
+#
+# Supported: vitest, jest, mocha, pytest, go test, cargo test, rspec,
+#            flutter/dart test, swift test, dotnet test, gradle/mvn test,
+#            mix test, phpunit
+# Bypass: OMA_TEST_FILTER=0
+
+if [[ "${OMA_TEST_FILTER:-1}" == "0" ]]; then
+  cat
+  exit 0
+fi
+
+awk '
+  # vitest/jest/mocha: remove individual passing tests
+  /^[[:space:]]*[✓√✔][[:space:]]/ { next }
+
+  # jest: remove PASS file headers
+  /^[[:space:]]*PASS[[:space:]]/ { next }
+
+  # go test: remove passing tests and ok package lines
+  /^--- PASS:/ { next }
+  /^[[:space:]]*ok[[:space:]]+[a-zA-Z]/ { next }
+
+  # pytest: remove PASSED lines
+  /PASSED[[:space:]]*$/ { next }
+
+  # cargo test: remove "test ... ok" lines
+  /^test .+ \.\.\. ok$/ { next }
+
+  # flutter/dart: remove passing tests (+N without -N, excluding summary)
+  /^[0-9][0-9]:[0-9][0-9] \+[0-9]+: / && !/\-[0-9]+/ && !/All tests/ { next }
+
+  # swift: remove passed test cases
+  /Test Case .* passed/ { next }
+
+  # dotnet: remove individual Passed lines (keep "Passed!" summary)
+  /^[[:space:]]*Passed[[:space:]]/ && !/Passed!/ { next }
+
+  # gradle/mvn: remove individual test pass indicators
+  /^[[:space:]]*Tests run:.*Failures: 0.*Errors: 0/ { next }
+
+  # phpunit: remove dots-only progress lines
+  /^[.]+$/ { next }
+
+  # rspec: remove passing example dots (single-char lines)
+  /^[.]+[[:space:]]*$/ { next }
+
+  # keep everything else
+  { print }
+'
diff --git a/.cursor/rules/market.mdc b/.cursor/rules/market.mdc
index 2787530..ab9e863 100644
--- a/.cursor/rules/market.mdc
+++ b/.cursor/rules/market.mdc
@@ -11,12 +11,12 @@ alwaysApply: false
 ## Core Rules
 
 1. **Preflight first**: every market research task starts with `oma market detect-trap`. If it refuses, surface the reframe to the user — never bypass without `--force`.
-2. **Keyless-first**: default to sources that need no API key (reddit, hn, bluesky, mastodon, github-issues, grounding). Paid sources (x, tiktok, instagram, youtube, perplexity) auto-enable only when env keys are present.
-3. **Reuse oma-search**: all fetches go through `oma search fetch --only api`. Do not call platform APIs directly from market commands. Trust labels come from oma-search.
+2. **Keyless-first**: default to sources that need no API key (reddit, hn, bluesky, mastodon, github, grounding). youtube joins automatically when the `yt-dlp` binary is installed. Env-keyed sources (x, tiktok, instagram, perplexity) are skipped with a stderr notice when their key is absent.
+3. **Fetch inside harvest only**: all network fetches happen inside `oma market harvest` via its built-in per-source fetchers. Do not call platform APIs directly from other market stages or from the agent.
 4. **Deterministic compute**: score, fuse, cluster stages must produce byte-identical output on `OMA_MARKET_MOCK=1` fixture replay. Stage stdin/stdout is pure JSON; stderr is warn/error only.
 5. **LAW enforcement**: render output must pass the 8 LAWs (see `.agents/skills/oma-market/resources/output-laws.md`). LAW self-check is mandatory; `--no-self-check` is debug-only.
 6. **Cite or fall back**: every representative cited in the brief is `[name](url)`. If URL is missing, use plain text — never `[name]()`.
 7. **Coverage transparency**: when `sources_failed` is non-empty, render must annotate "coverage: N/M sources" in the engine footer.
 8. **Intent → framework auto-toggle**: pain/trend → SWOT only; competitor → SWOT + Porter's 5F; discovery → SWOT + PESTEL. User `--frameworks` flag overrides.
 9. **Single brief, single date**: one run = one md file at `.agents/results/market/{topic-slug}-{YYYYMMDD}.md`. Rerunning same day overwrites; previous run is responsible to git the file if needed.
-10. **Personal data refuse**: detect-trap blocks queries that target a private individual's personal data. Founders, creators, and public handles are allowed (last30days person-mode parity).
+10. **Personal data refuse**: refuse queries that target a private individual's personal data before running the pipeline. This is an agent-level gate — `detect-trap` automates demographic-shopping and overly-broad-topic refusal only. Founders, creators, and public handles are allowed (last30days person-mode parity).
diff --git a/.opencode/plugins/oma/agentmemory-client.ts b/.opencode/plugins/oma/agentmemory-client.ts
index f81ecb0..50962bd 100644
--- a/.opencode/plugins/oma/agentmemory-client.ts
+++ b/.opencode/plugins/oma/agentmemory-client.ts
@@ -6,10 +6,6 @@ import https from "node:https";
 import { homedir } from "node:os";
 import { basename, join } from "node:path";
 
-// AgentMemory's published version line moved from 0.11/0.12 (original design
-// target) to 0.9.x service builds; accept 0.9.x and the 0.1x.x range.
-const SUPPORTED = /^0\.(9|1\d)\./;
-
 function endpointUrl(): string | null {
   if (process.env.OMA_NO_AGENTMEMORY === "1") return null;
   if (process.env.AGENTMEMORY_URL) return process.env.AGENTMEMORY_URL;
@@ -106,36 +102,12 @@ export async function isAgentMemoryReachable(): Promise<boolean> {
 
   try {
     const response = await requestAgentMemory(url, "/agentmemory/health");
-    if (response.statusCode < 200 || response.statusCode >= 300) {
-      reachable = false;
-      return reachable;
-    }
-    const headerVersion = response.headers["x-agentmemory-version"];
-    const version = Array.isArray(headerVersion)
-      ? headerVersion[0]
-      : headerVersion;
-    // Recent AgentMemory releases expose the version only in the health body,
-    // not the `x-agentmemory-version` header.
-    let isAgentMemory = false;
-    let bodyVersion: string | undefined;
-    try {
-      const parsed = JSON.parse(response.body) as {
-        service?: unknown;
-        status?: unknown;
-        version?: unknown;
-      };
-      isAgentMemory =
-        parsed.service === "agentmemory" ||
-        parsed.status === "healthy" ||
-        parsed.status === "ok";
-      if (typeof parsed.version === "string") bodyVersion = parsed.version;
-    } catch {
-      // Non-JSON body — fall back to the header check below.
-    }
-    const resolvedVersion = version ?? bodyVersion;
-    reachable =
-      isAgentMemory ||
-      (resolvedVersion !== undefined && SUPPORTED.test(resolvedVersion));
+    // Capability-based acceptance: any 2xx health response from the
+    // explicitly configured endpoint counts as reachable. Version pinning
+    // proved brittle (the published line already jumped from 0.11/0.12
+    // design targets to 0.9.x service builds), so payload shape and version
+    // are no longer gating.
+    reachable = response.statusCode >= 200 && response.statusCode < 300;
     return reachable;
   } catch {
     reachable = false;
diff --git a/.opencode/plugins/oma/hook-output.ts b/.opencode/plugins/oma/hook-output.ts
index 5fd76dc..306fecd 100644
--- a/.opencode/plugins/oma/hook-output.ts
+++ b/.opencode/plugins/oma/hook-output.ts
@@ -8,6 +8,11 @@ import type { Vendor } from "./types.ts";
 export function makePromptOutput(
   vendor: Vendor,
   additionalContext: string,
+  // Native hook event the context is injected for. Defaults to the prompt-submit
+  // event; the dispatch layer passes "SessionStart" for session-start injection
+  // (commandcode / cursor sessionStart) so the emitted hookSpecificOutput names
+  // the correct event. Standalone core-script callers use the default.
+  hookEventName: string = "UserPromptSubmit",
 ): string {
   switch (vendor) {
     case "antigravity":
@@ -19,33 +24,43 @@ export function makePromptOutput(
         injectSteps: [{ ephemeralMessage: additionalContext }],
       });
     case "claude":
-    case "commandcode":
+    case "commandcode": {
       // Official Claude Code docs (code.claude.com/docs/en/hooks) specify
       // `hookSpecificOutput.additionalContext` — the top-level field is kept
       // for back-compat with older builds that read it.
       // commandcode (Command Code, commandcode.ai) mirrors the Claude hook
-      // dialect, but has NO prompt event (only PreToolUse/PostToolUse/Stop),
-      // so this branch never fires for it — kept for Vendor exhaustiveness.
-      return JSON.stringify({
+      // dialect. It has no prompt-submit event, but DOES inject context on
+      // SessionStart (additionalContext) — dispatch passes hookEventName
+      // "SessionStart" for that path.
+      const hookSpecificOutput: Record<string, unknown> = {
+        hookEventName,
         additionalContext,
-        hookSpecificOutput: {
-          hookEventName: "UserPromptSubmit",
-          additionalContext,
-        },
-      });
+      };
+      // Claude Code re-scans skill/command directories after SessionStart hooks
+      // complete when the output sets `reloadSkills` (docs: SessionStart
+      // hookSpecificOutput.reloadSkills). It is Claude-only and only meaningful
+      // for SessionStart; this builder is called solely when context was
+      // actually injected, so the "only when injecting" condition is inherent.
+      if (vendor === "claude" && hookEventName === "SessionStart") {
+        hookSpecificOutput.reloadSkills = true;
+      }
+      return JSON.stringify({ additionalContext, hookSpecificOutput });
+    }
     case "codex":
       return JSON.stringify({
         hookSpecificOutput: {
-          hookEventName: "UserPromptSubmit",
+          hookEventName,
           additionalContext,
         },
       });
     case "cursor":
+      // Cursor reads the top-level `additional_context` (sessionStart) /
+      // `additionalContext`; the hookSpecificOutput block is informational.
       return JSON.stringify({
         additionalContext,
         additional_context: additionalContext,
         hookSpecificOutput: {
-          hookEventName: "UserPromptSubmit",
+          hookEventName,
           additionalContext,
         },
       });
@@ -70,7 +85,7 @@ export function makePromptOutput(
       // Qwen Code fork uses hookSpecificOutput (same as Codex)
       return JSON.stringify({
         hookSpecificOutput: {
-          hookEventName: "UserPromptSubmit",
+          hookEventName,
           additionalContext,
         },
       });
@@ -82,18 +97,27 @@ export function makeBlockOutput(vendor: Vendor, reason: string): string {
     case "claude":
     case "codex":
     case "commandcode":
-    case "cursor":
     case "kiro":
     case "qwen":
       return JSON.stringify({ decision: "block", reason });
+    case "cursor":
+      // Cursor's `stop` hook ignores Claude-style `{decision:"block"}`. It
+      // re-enters the loop via `{followup_message}`, which is auto-submitted as
+      // the next turn (capped by the entry's loop_limit). Cursor's only
+      // block-producing chain is `stop` — its sole preToolUse handler
+      // (test-filter) never blocks, only mutates — so followup_message is
+      // always the correct dialect here.
+      return JSON.stringify({ followup_message: reason });
     case "antigravity":
       // agy Stop: `decision:"continue"` re-enters the loop (= block the stop);
       // `reason` is injected as a system message. (Any other value allows stop.)
       return JSON.stringify({ decision: "continue", reason });
     case "pi":
-      // pi has no stop-blocking event (agent_end is notification-only), so
-      // persistent-mode never runs under pi. This shape mirrors pi's native
-      // tool_call block return for completeness/forward-compat.
+      // pi's bridge implements persistent-mode via agent_settled +
+      // pi.sendUserMessage: it runs the persistent-mode subprocess (which
+      // resolves to the Claude dialect `{decision:"block", reason}`) and also
+      // accepts this `{block:true, reason}` shape, re-submitting `reason` as the
+      // next turn so the workflow continues.
       return JSON.stringify({ block: true, reason });
     case "grok":
       // Grok Stop hooks are generally advisory. Emit block decision + rich
diff --git a/.opencode/plugins/oma/keyword-detector.ts b/.opencode/plugins/oma/keyword-detector.ts
index 223fcb1..e336814 100644
--- a/.opencode/plugins/oma/keyword-detector.ts
+++ b/.opencode/plugins/oma/keyword-detector.ts
@@ -25,6 +25,7 @@ import { agyConversationId, isAgyInput, readAgyPrompt } from "./agy-input.ts";
 import { UNKNOWN_SESSION_ID, VENDORS } from "./constants.ts";
 import { clearGrokContext } from "./grok-context.ts";
 import { makePromptOutput } from "./hook-output.ts";
+import { isRelayedAgentMessage, normalizePromptInput } from "./prompt-input.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).
@@ -154,6 +155,11 @@ export function isGenuineUserPrompt(input: Record<string, unknown>): boolean {
   return true;
 }
 
+// ── Guard: relayed inter-agent messages ──────────────────────
+// Shared with skill-injector — see prompt-input.ts. Re-exported here so
+// existing imports/tests keep resolving from this module.
+export { isRelayedAgentMessage };
+
 // ── Guard 3: Reinforcement suppression ───────────────────────
 
 const REINFORCEMENT_WINDOW_MS = 60_000; // 60 seconds
@@ -349,24 +355,84 @@ export function escapeRegex(s: string): string {
   return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
 
+/**
+ * Merge a language-keyed keyword/pattern bank into a single flat list:
+ * universal ("*") + English (the universal default) + the configured
+ * language's own entries (skipped when lang === "en" to avoid duplicates).
+ * Shared by buildPatterns and buildRawPatterns — both keyword banks and
+ * pattern banks use this exact `Record<string, string[]>` shape.
+ */
+export function collectLangEntries(
+  bank: Record<string, string[]>,
+  lang: string,
+): string[] {
+  return [
+    ...(bank["*"] ?? []),
+    ...(bank.en ?? []),
+    ...(lang !== "en" ? (bank[lang] ?? []) : []),
+  ];
+}
+
+/**
+ * Keyword-plus-compiled-regex pair. Kept 1:1 with the literal keyword string
+ * (as authored in triggers.json) so callers that need the ACTUAL matched
+ * keyword text — e.g. specificity ranking — don't have to re-derive it from
+ * match[0], which would require re-deriving buildPatterns' word-boundary
+ * peeling logic (fragile, and wrong for CJK where no boundary is added).
+ */
+export interface KeywordPatternEntry {
+  regex: RegExp;
+  keyword: string;
+}
+
+export function buildPatternEntries(
+  keywords: Record<string, string[]>,
+  lang: string,
+  cjkScripts: string[],
+): KeywordPatternEntry[] {
+  return collectLangEntries(keywords, lang).map((kw) => {
+    const escaped = escapeRegex(kw).replace(/\s+/g, "\\s+");
+    const regex =
+      cjkScripts.includes(lang) || /[^\p{ASCII}]/u.test(kw)
+        ? new RegExp(escaped, "i")
+        : new RegExp(`(?:^|[^\\w-])${escaped}(?:$|[^\\w-])`, "i");
+    return { regex, keyword: kw };
+  });
+}
+
 export function buildPatterns(
   keywords: Record<string, string[]>,
   lang: string,
   cjkScripts: string[],
 ): RegExp[] {
-  const allKeywords = [
-    ...(keywords["*"] ?? []),
-    ...(keywords.en ?? []),
-    ...(lang !== "en" ? (keywords[lang] ?? []) : []),
-  ];
+  return buildPatternEntries(keywords, lang, cjkScripts).map((e) => e.regex);
+}
 
-  return allKeywords.map((kw) => {
-    const escaped = escapeRegex(kw).replace(/\s+/g, "\\s+");
-    if (cjkScripts.includes(lang) || /[^\p{ASCII}]/u.test(kw)) {
-      return new RegExp(escaped, "i");
+/**
+ * Raw-pattern-plus-source pair — mirrors KeywordPatternEntry for the
+ * `patterns` (intent regex) field. `source` is the raw regex string itself:
+ * unlike keyword entries, a raw pattern has no fixed "keyword" — its
+ * specificity is however much text it actually matched (match[0]).
+ */
+export interface RawPatternEntry {
+  regex: RegExp;
+  source: string;
+}
+
+export function buildRawPatternEntries(
+  patterns: Record<string, string[]> | undefined,
+  lang: string,
+): RawPatternEntry[] {
+  if (!patterns) return [];
+  const compiled: RawPatternEntry[] = [];
+  for (const raw of collectLangEntries(patterns, lang)) {
+    try {
+      compiled.push({ regex: new RegExp(raw, "iu"), source: raw });
+    } catch {
+      // Skip invalid regex — surfaces during config edit, not at runtime
     }
-    return new RegExp(`(?:^|[^\\w-])${escaped}(?:$|[^\\w-])`, "i");
-  });
+  }
+  return compiled;
 }
 
 /**
@@ -379,21 +445,7 @@ export function buildRawPatterns(
   patterns: Record<string, string[]> | undefined,
   lang: string,
 ): RegExp[] {
-  if (!patterns) return [];
-  const all = [
-    ...(patterns["*"] ?? []),
-    ...(patterns.en ?? []),
-    ...(lang !== "en" ? (patterns[lang] ?? []) : []),
-  ];
-  const compiled: RegExp[] = [];
-  for (const raw of all) {
-    try {
-      compiled.push(new RegExp(raw, "iu"));
-    } catch {
-      // Skip invalid regex — surfaces during config edit, not at runtime
-    }
-  }
-  return compiled;
+  return buildRawPatternEntries(patterns, lang).map((e) => e.regex);
 }
 
 export function buildInformationalPatterns(config: TriggerConfig): RegExp[] {
@@ -752,6 +804,93 @@ export function deactivateAllPersistentModes(
   }
 }
 
+// ── Specificity ranking ───────────────────────────────────────
+
+/**
+ * One surviving pattern match for one workflow, carrying everything the
+ * ranking rules in `pickWinningCandidate` need. Built once per successful
+ * `pattern.exec()` across ALL workflows in `config.workflows` — the matching
+ * loop no longer returns on the first hit; it collects every candidate
+ * first and lets specificity decide the winner.
+ */
+export interface WorkflowCandidate {
+  workflow: string;
+  persistent: boolean;
+  /** Index of the match within the cleaned (stripped/normalized) text. */
+  matchIndex: number;
+  matchText: string;
+  /** Position re-located in the ORIGINAL prompt — used for tie-break #3. */
+  origIndex: number;
+  /** Length of the specific text that matched (trimmed keyword or, for a
+   * `patterns` intent-regex hit, the trimmed match[0] span) — rule #1. */
+  keywordLength: number;
+  /** Whether the specificity text contains whitespace — rule #2. */
+  isMultiWord: boolean;
+  /** Index of this workflow in triggers.json `workflows` — rule #4 (final
+   * tiebreak, preserves the pre-ranking first-declared-wins behavior). */
+  declarationIndex: number;
+  /** True if any suppression filter (RC3 technical-reference is a hard drop
+   * and never reaches this point; informational-context / pasted-content /
+   * reinforcement) applies to this specific match. */
+  suppressed: boolean;
+}
+
+/**
+ * Pick the winning candidate among all workflow matches collected for a
+ * prompt, or `null` if none survive.
+ *
+ * Ranking order (only consulted on a tie with the previous rule):
+ *   1. Longest matched keyword/phrase wins — "deepsec pr review" (18 chars)
+ *      beats "review" (6 chars) even though "review" also literally matches
+ *      as a substring of the same sentence.
+ *   2. A multi-word/compound match beats a single-word match of equal
+ *      length (defensive tiebreak; rule 1 already separates most real
+ *      cases since compound phrases are almost always longer).
+ *   3. Earliest match position in the ORIGINAL prompt wins — mirrors the
+ *      existing "keyword near the front = command position" heuristic used
+ *      elsewhere in this file (RC2 pasted-content guard).
+ *   4. Final tiebreak: declaration order in triggers.json `workflows` —
+ *      i.e. the original pre-ranking first-match-wins behavior, kept only
+ *      as a last resort when two workflows are otherwise indistinguishable.
+ *
+ * DESIGN DECISION (round-1 trigger demotion, part A): suppression is
+ * evaluated PER CANDIDATE, not globally. A candidate flagged `suppressed`
+ * (by the informational-context window, the persistent-mode pasted-content
+ * limit, or reinforcement) is simply removed from the ranking pool — it
+ * does NOT veto a *different*, unsuppressed candidate from a more generic
+ * workflow. Reasoning: every existing suppression filter in this file
+ * already operates locally, on one match at a time (a suppressed hit in one
+ * workflow's pattern loop has always fallen through to the next
+ * pattern/workflow, never blocking unrelated matches elsewhere in the same
+ * prompt) — ranking preserves that locality instead of upgrading it into a
+ * prompt-wide veto. The alternative (any suppressed specific match blocks
+ * the whole prompt from firing anything) would silence genuine, independent
+ * requests that merely share a sentence with a meta-mention of a more
+ * specific workflow. See triggers-corpus.json for a case that locks this in:
+ * a prompt that asks an informational "what is X" question about a specific
+ * workflow AND, separately, makes a genuine generic request — the generic
+ * request still fires.
+ */
+export function pickWinningCandidate(
+  candidates: WorkflowCandidate[],
+): WorkflowCandidate | null {
+  const eligible = candidates.filter((c) => !c.suppressed);
+  if (eligible.length === 0) return null;
+  eligible.sort((a, b) => {
+    if (b.keywordLength !== a.keywordLength) {
+      return b.keywordLength - a.keywordLength;
+    }
+    if (a.isMultiWord !== b.isMultiWord) {
+      return a.isMultiWord ? -1 : 1;
+    }
+    if (a.origIndex !== b.origIndex) {
+      return a.origIndex - b.origIndex;
+    }
+    return a.declarationIndex - b.declarationIndex;
+  });
+  return eligible[0] ?? null;
+}
+
 // ── Pure handler (canonical ABI) ─────────────────────────────
 
 /**
@@ -778,6 +917,9 @@ export async function run(
 
   if (!prompt.trim()) return null;
   if (startsWithSlashCommand(prompt)) return null;
+  // Relayed inter-agent messages carry another agent's text, not a user
+  // request — their content must not drive workflow keyword detection.
+  if (isRelayedAgentMessage(prompt)) return null;
 
   const config = loadConfig();
   const lang = detectLanguage(projectDir);
@@ -804,73 +946,125 @@ export async function run(
   // Skip persistent workflows entirely if the prompt is an analytical question
   const analytical = isAnalyticalQuestion(cleaned);
 
-  for (const [workflow, def] of Object.entries(config.workflows)) {
+  // shouldSkipAllWorkflows does not depend on the workflow being evaluated —
+  // hoisted out of the loop (was re-checked on every iteration pre-ranking).
+  if (shouldSkipAllWorkflows(cleaned)) return null;
+
+  // Position guard must reflect the user's ACTUAL prompt, not the
+  // content-stripped text. stripCodeBlocks/stripSystemEchoes remove quoted
+  // and code spans, which shrinks the text and pulls keywords toward the
+  // front — defeating the "deep in a long prompt = not an instruction"
+  // heuristic (a keyword genuinely at char 245 of a discussion can appear
+  // at char 179 after stripping, slipping under PERSISTENT_MATCH_LIMIT).
+  const origPrompt = normalizeForMatching(prompt);
+
+  // Collect every surviving match across every workflow first — specificity
+  // ranking (see pickWinningCandidate) decides the winner, replacing the old
+  // declaration-order first-match-wins loop.
+  const candidates: WorkflowCandidate[] = [];
+  const workflowEntries = Object.entries(config.workflows);
+
+  for (
+    let declarationIndex = 0;
+    declarationIndex < workflowEntries.length;
+    declarationIndex++
+  ) {
+    const entry = workflowEntries[declarationIndex];
+    if (!entry) continue;
+    const [workflow, def] = entry;
     if (excluded.has(workflow)) continue;
-    if (shouldSkipAllWorkflows(cleaned)) continue;
 
     const workflowPredicate = KEYWORD_SKIP_PREDICATES[workflow];
     if (workflowPredicate?.(cleaned)) continue;
 
     if (analytical && def.persistent) continue;
 
-    const patterns = [
-      ...buildPatterns(def.keywords, lang, config.cjkScripts),
-      ...buildRawPatterns(def.patterns, lang),
-    ];
+    const reinforced = isReinforcementSuppressed(kwState, workflow);
 
-    for (const pattern of patterns) {
-      const match = pattern.exec(cleaned);
-      if (!match) continue;
+    const considerMatch = (regex: RegExp, specificityText: string) => {
+      const match = regex.exec(cleaned);
+      if (!match) return;
       // RC3: compound technical tokens (ralph:verify, ralph.md,
       // workflows/ralph) reference the workflow as an artifact, not a run
-      // request.
-      if (isTechnicalReference(cleaned, match.index, match[0])) continue;
-      if (isInformationalContext(cleaned, match.index, infoPatterns)) continue;
-      // Position guard must reflect the user's ACTUAL prompt, not the
-      // content-stripped text. stripCodeBlocks/stripSystemEchoes remove quoted
-      // and code spans, which shrinks the text and pulls keywords toward the
-      // front — defeating the "deep in a long prompt = not an instruction"
-      // heuristic (a keyword genuinely at char 245 of a discussion can appear
-      // at char 179 after stripping, slipping under PERSISTENT_MATCH_LIMIT).
-      // Re-locate the matched keyword in the original prompt for the check.
-      const origPrompt = normalizeForMatching(prompt);
+      // request — dropped entirely, never becomes a candidate.
+      if (isTechnicalReference(cleaned, match.index, match[0])) return;
+
+      // Re-locate the matched keyword in the original prompt for the
+      // pasted-content position guard.
       const origIndex = origPrompt.indexOf(match[0]);
       const posIndex = origIndex >= 0 ? origIndex : match.index;
-      if (isPastedContent(posIndex, def.persistent, origPrompt.length))
-        continue;
-      if (isReinforcementSuppressed(kwState, workflow)) continue;
+      const informational = isInformationalContext(
+        cleaned,
+        match.index,
+        infoPatterns,
+      );
+      const pasted = isPastedContent(
+        posIndex,
+        def.persistent,
+        origPrompt.length,
+      );
+      const text = specificityText.trim();
+
+      candidates.push({
+        workflow,
+        persistent: def.persistent,
+        matchIndex: match.index,
+        matchText: match[0],
+        origIndex: posIndex,
+        keywordLength: text.length,
+        isMultiWord: /\s/.test(text),
+        declarationIndex,
+        suppressed: informational || pasted || reinforced,
+      });
+    };
+
+    for (const { regex, keyword } of buildPatternEntries(
+      def.keywords,
+      lang,
+      config.cjkScripts,
+    )) {
+      considerMatch(regex, keyword);
+    }
+    for (const { regex, source } of buildRawPatternEntries(
+      def.patterns,
+      lang,
+    )) {
+      considerMatch(regex, source);
+    }
+  }
 
-      if (def.persistent) {
-        activateMode(projectDir, workflow, sessionId);
-      }
-      await activateL1WorkflowSession(projectDir, workflow, vendor, sessionId);
-      const updatedState = recordKwTrigger(kwState, workflow);
-      saveKwState(projectDir, updatedState);
-
-      const contextLines = [
-        `[OMA WORKFLOW: ${workflow.toUpperCase()}]`,
-        `User intent matches the /${workflow} workflow.`,
-        `Read and follow \`.agents/workflows/${workflow}.md\` step by step.`,
-        `User request: ${prompt}`,
-        `IMPORTANT: Start the workflow IMMEDIATELY. Do not ask for confirmation.`,
-      ];
-
-      if (config.extensionRouting) {
-        const extensions = detectExtensions(prompt);
-        const agent = resolveAgentFromExtensions(
-          extensions,
-          config.extensionRouting,
-        );
-        if (agent) {
-          contextLines.push(`[OMA AGENT HINT: ${agent}]`);
-        }
-      }
+  const winner = pickWinningCandidate(candidates);
+  if (!winner) return null;
+
+  const { workflow } = winner;
+
+  if (winner.persistent) {
+    activateMode(projectDir, workflow, sessionId);
+  }
+  await activateL1WorkflowSession(projectDir, workflow, vendor, sessionId);
+  const updatedState = recordKwTrigger(kwState, workflow);
+  saveKwState(projectDir, updatedState);
+
+  const contextLines = [
+    `[OMA WORKFLOW: ${workflow.toUpperCase()}]`,
+    `User intent matches the /${workflow} workflow.`,
+    `Read and follow \`.agents/workflows/${workflow}.md\` step by step.`,
+    `User request: ${prompt}`,
+    `IMPORTANT: Start the workflow IMMEDIATELY. Do not ask for confirmation.`,
+  ];
 
-      return { type: "context", additionalContext: contextLines.join("\n") };
+  if (config.extensionRouting) {
+    const extensions = detectExtensions(prompt);
+    const agent = resolveAgentFromExtensions(
+      extensions,
+      config.extensionRouting,
+    );
+    if (agent) {
+      contextLines.push(`[OMA AGENT HINT: ${agent}]`);
     }
   }
 
-  return null;
+  return { type: "context", additionalContext: contextLines.join("\n") };
 }
 
 // ── Standalone entry (pi subprocess / direct bun invocation) ──
@@ -890,7 +1084,7 @@ async function main() {
   const vendor = detectVendor(input);
   const projectDir = getProjectDir(vendor, input);
   const sessionId = getSessionId(input);
-  let prompt = (input.prompt as string) ?? "";
+  let prompt = normalizePromptInput(input.prompt);
 
   // agy's PreInvocation stdin carries no `prompt` — recover the user request
   // from the transcript. PreInvocation fires before every model call, so only
diff --git a/.opencode/plugins/oma/oma.ts b/.opencode/plugins/oma/oma.ts
index 2e0e5c6..51060a5 100644
--- a/.opencode/plugins/oma/oma.ts
+++ b/.opencode/plugins/oma/oma.ts
@@ -2,34 +2,55 @@
  * oh-my-agent — opencode (Sst opencode) plugin bridge.
  *
  * SSOT source. At install time `installOpencodePlugin` copies this file to
- * `.opencode/plugins/oma/oma.ts` alongside the core hook scripts. opencode
- * auto-discovers plugins under each `.opencode/plugins` subdirectory.
+ * `.opencode/plugins/oma/oma.ts` alongside the core hook scripts, and
+ * `registerOpencodePlugin` adds it to `.opencode/opencode.jsonc` (the nested
+ * subdir is invisible to opencode's flat auto-discovery).
  *
  * Why a bridge instead of a per-vendor variants JSON entry: opencode does NOT
  * register settings-file hooks like the other vendors. It loads in-process
- * TypeScript plugins and dispatches plugin event handlers. So rather than the
- * generic `installHooksFromVariant` path (events → settings file → `bun
- * <script>` subprocess), opencode gets this thin shim that maps opencode
- * lifecycle events onto oma's existing, vendor-agnostic core scripts via
+ * TypeScript plugins whose handlers are invoked with an `(input, output)` pair
+ * and are expected to MUTATE `output` (return values are ignored). So rather
+ * than the generic `installHooksFromVariant` path (events → settings file →
+ * `bun <script>` subprocess), opencode gets this thin shim that maps opencode
+ * lifecycle handlers onto oma's existing, vendor-agnostic core scripts via
  * subprocess. All matching logic stays in the core scripts.
  *
+ * The core scripts installed under `.opencode/plugins/oma/` are not recognised
+ * as an opencode vendor (there is no `.opencode` case in the shared
+ * `inferVendorFromScriptPath`), so they resolve to the `claude` output dialect.
+ * This bridge therefore reads the claude-shaped stdout: `additionalContext`
+ * for prompt hooks, `hookSpecificOutput.updatedInput.command` for PreToolUse,
+ * and `{ decision: "block", reason }` for the Stop equivalent. Extraction is
+ * defensive (top-level OR `hookSpecificOutput`) so a dialect shift does not
+ * silently break the bridge.
+ *
  * Intentionally dependency-free (no @opencode-ai/plugin import) so this file
  * works in any user project without requiring opencode as a dev dependency.
- * The `Plugin` type is satisfied structurally via JSDoc.
+ * Handler and client shapes are satisfied structurally via inline types.
  *
  * Event mapping:
- *   chat.message        ← UserPromptSubmit  (keyword-detector + skill-injector)
- *   tool.execute.before ← PreToolUse        (test-filter for bash tools)
- *   session.idle        ← Stop              BEST-EFFORT / NON-BLOCKING
- *                         opencode's session.idle is a notification-only event
- *                         that fires when the session has no pending work. It
- *                         is the closest analog to the Claude `Stop` hook but
- *                         cannot block the session from terminating. Persistent
- *                         workflow Stop semantics are therefore DEGRADED under
- *                         opencode: the handler runs best-effort and must not
- *                         throw or block — if the underlying hook returns
- *                         non-zero or times out, the error is swallowed and
- *                         opencode proceeds normally.
+ *   chat.message                        ← UserPromptSubmit
+ *       Extracts user text from output.parts, runs keyword-detector +
+ *       skill-injector, and stashes the resulting context per session (keyed
+ *       by input.sessionID). The opencode session id is forwarded to the core
+ *       scripts so keyword-detector's persistent-mode activation writes a
+ *       session-scoped state file (an unresolved id would refuse to persist).
+ *   experimental.chat.system.transform  ← context injection
+ *       Peeks the stashed context for input.sessionID and pushes it onto
+ *       output.system. Non-consuming: the stash is refreshed (or cleared)
+ *       every chat.message, so re-injection across model calls in a turn is
+ *       harmless and a chat.message→transform ordering assumption cannot
+ *       permanently drop context.
+ *   tool.execute.before                 ← PreToolUse (bash only)
+ *       Runs test-filter on output.args.command and writes the rewritten
+ *       command back onto output.args.command.
+ *   event: "session.idle"               ← Stop (BEST-EFFORT / re-entrant)
+ *       Runs persistent-mode. If it returns a block decision, the workflow is
+ *       still active: re-enter the loop by posting the block reason as a new
+ *       prompt via client.session.prompt. Best-effort — any failure is
+ *       swallowed. persistent-mode's own reinforcement cap (5) is the primary
+ *       terminator; a per-session consecutive-idle counter is a runaway
+ *       backstop only.
  */
 
 import { spawnSync } from "node:child_process";
@@ -45,7 +66,8 @@ function corePath(script: string): string {
  * its JSON stdout. Fail-open (returns null) on any error — a broken hook must
  * never block the agent. Spawns with `cwd` = opencode's working directory so
  * the core scripts resolve the project (git) root the same way they do for
- * every other vendor.
+ * every other vendor. Non-zero exit (persistent-mode blocks with exit 2) is
+ * expected: stdout is still captured and parsed.
  */
 function runCore(
   script: string,
@@ -69,143 +91,320 @@ function runCore(
 }
 
 /**
- * Run an oma core hook script best-effort: like runCore but swallows all
- * errors and never throws. Used for session.idle (Stop equivalent) where
- * throwing would surface as an unhandled rejection inside opencode.
+ * Extract injected context from a prompt-hook (keyword-detector / skill-
+ * injector) result. The core scripts emit the `claude` dialect, which carries
+ * `additionalContext` both at the top level and under `hookSpecificOutput`;
+ * read either so a dialect change does not silently drop context.
  */
-function runCoreBestEffort(
-  script: string,
-  payload: Record<string, unknown>,
-  cwd: string,
-): void {
-  try {
-    runCore(script, payload, cwd);
-  } catch {
-    // Non-zero exit or parse error — swallow silently (Stop degraded semantics).
+function extractAdditionalContext(
+  out: Record<string, unknown> | null,
+): string | null {
+  if (!out) return null;
+  if (typeof out.additionalContext === "string" && out.additionalContext) {
+    return out.additionalContext;
+  }
+  const hso = out.hookSpecificOutput;
+  if (hso && typeof hso === "object") {
+    const nested = (hso as Record<string, unknown>).additionalContext;
+    if (typeof nested === "string" && nested) return nested;
+  }
+  return null;
+}
+
+/**
+ * Extract the rewritten command from a test-filter (PreToolUse) result. The
+ * `claude` dialect nests it under `hookSpecificOutput.updatedInput.command`;
+ * a top-level `updatedInput.command` is also accepted for dialect resilience.
+ */
+function extractUpdatedCommand(
+  out: Record<string, unknown> | null,
+): string | null {
+  if (!out) return null;
+  const readCommand = (v: unknown): string | null => {
+    if (v && typeof v === "object") {
+      const cmd = (v as Record<string, unknown>).command;
+      if (typeof cmd === "string" && cmd) return cmd;
+    }
+    return null;
+  };
+  const direct = readCommand(out.updatedInput);
+  if (direct) return direct;
+  const hso = out.hookSpecificOutput;
+  if (hso && typeof hso === "object") {
+    return readCommand((hso as Record<string, unknown>).updatedInput);
+  }
+  return null;
+}
+
+/** Join the text parts of a chat.message output into the user's prompt text. */
+function extractPromptText(output: {
+  message?: unknown;
+  parts?: Array<{ type?: string; text?: string }>;
+}): string {
+  const parts = Array.isArray(output.parts) ? output.parts : [];
+  const texts = parts
+    .filter((p) => p && p.type === "text" && typeof p.text === "string")
+    .map((p) => p.text as string);
+  if (texts.length > 0) return stripWrappingQuotes(texts.join("\n"));
+  // Defensive fallback: some builds may surface text on the message object.
+  const msg = output.message as { text?: unknown } | undefined;
+  if (msg && typeof msg.text === "string") return stripWrappingQuotes(msg.text);
+  return "";
+}
+
+/**
+ * `opencode run "<prompt>"` delivers the part text wrapped in literal double
+ * quotes (`"work: …"`), which defeats keyword detection anchored at the prompt
+ * start. A prompt that is entirely enclosed in one matching pair of quotes is
+ * that CLI artifact — unwrap exactly one pair; interior quotes are untouched.
+ */
+function stripWrappingQuotes(text: string): string {
+  const t = text.trim();
+  if (t.length >= 2 && t.startsWith('"') && t.endsWith('"')) {
+    return t.slice(1, -1);
+  }
+  return t;
+}
+
+// ── Per-session bridge state ──────────────────────────────────
+//
+// opencode plugins are loaded once per server process, so module-level maps
+// persist across a session's handler invocations. Both maps are keyed by the
+// opencode sessionID and bounded so a long-lived server cannot leak memory
+// across many sessions.
+
+const MAX_TRACKED_SESSIONS = 256;
+
+/**
+ * Context computed on chat.message, awaiting injection by the system-prompt
+ * transform. Overwrite-per-session: each chat.message replaces the entry
+ * (with `""` when nothing matched), so the transform never injects stale
+ * context and a peek does not need to consume.
+ */
+const pendingContext = new Map<string, string>();
+
+/**
+ * Consecutive session.idle re-entries per session, reset by any chat.message.
+ * A runaway backstop only — persistent-mode's reinforcement cap terminates the
+ * loop first under normal operation.
+ */
+const idleReentryCount = new Map<string, number>();
+const MAX_CONSECUTIVE_IDLE_REENTRIES = 50;
+
+/** Set a bounded map entry, evicting the oldest key when over capacity. */
+function setBounded<V>(map: Map<string, V>, key: string, value: V): void {
+  if (map.has(key)) map.delete(key);
+  map.set(key, value);
+  while (map.size > MAX_TRACKED_SESSIONS) {
+    const oldest = map.keys().next().value;
+    if (oldest === undefined) break;
+    map.delete(oldest);
   }
 }
 
+/**
+ * Minimal structural view of the opencode SDK client used for loop re-entry.
+ * Kept optional and dependency-free; the real client is a superset.
+ */
+type OmaOpencodeClient = {
+  session?: {
+    prompt?: (options: {
+      path: { id: string };
+      body: { parts: Array<{ type: "text"; text: string }> };
+    }) => Promise<unknown>;
+  };
+};
+
 /**
  * oh-my-agent opencode plugin.
  *
  * Structural shape satisfies the opencode `Plugin` contract without importing
  * @opencode-ai/plugin, keeping this bridge dependency-free in the user's
- * project.
+ * project. Handlers mutate their `output` argument (return values are ignored).
  *
  * @satisfies Plugin
  */
-export default (async ({ $ }: { $: { cwd: string } }) => {
-  const cwd = $.cwd ?? process.cwd();
+export default (async ({
+  directory,
+  client,
+}: {
+  directory?: string;
+  client?: OmaOpencodeClient;
+}) => {
+  const cwd = directory ?? process.cwd();
 
   return {
     /**
      * chat.message ← UserPromptSubmit
      *
-     * Invoked when the user submits a new message to the chat. Runs the OMA
-     * keyword-detector (workflow activation) and skill-injector (context
-     * injection) and appends any resulting context to the system prompt for
-     * this turn.
+     * Runs keyword-detector (workflow activation) and skill-injector (context
+     * injection), then stashes the concatenated context for this session so
+     * `experimental.chat.system.transform` can inject it. Forwards the opencode
+     * sessionID so persistent-workflow state is written session-scoped.
      */
-    "chat.message": async (event: {
-      message?: { content?: string };
-      session?: { systemPrompt?: string };
-    }) => {
-      const prompt = event.message?.content ?? "";
+    "chat.message": async (
+      input: { sessionID?: string },
+      output: {
+        message?: unknown;
+        parts?: Array<{ type?: string; text?: string }>;
+      },
+    ): Promise<void> => {
+      const sessionID = input.sessionID ?? "";
+      // A genuine user turn resets the runaway idle backstop.
+      if (sessionID) idleReentryCount.delete(sessionID);
+
+      const prompt = extractPromptText(output);
       const payload = {
         prompt,
         cwd,
+        sessionId: sessionID,
         hook_event_name: "UserPromptSubmit",
       };
 
       const parts: string[] = [];
+      const kd = extractAdditionalContext(
+        runCore("keyword-detector.ts", payload, cwd),
+      );
+      if (kd) parts.push(kd);
+      const si = extractAdditionalContext(
+        runCore("skill-injector.ts", payload, cwd),
+      );
+      if (si) parts.push(si);
 
-      const kd = runCore("keyword-detector.ts", payload, cwd);
-      if (kd && typeof kd.additionalContext === "string") {
-        parts.push(kd.additionalContext);
-      }
+      // Overwrite per session — even with "" — so the transform reflects this
+      // turn's detection and never re-injects a previous turn's context.
+      if (sessionID) setBounded(pendingContext, sessionID, parts.join("\n\n"));
+    },
 
-      const si = runCore("skill-injector.ts", payload, cwd);
-      if (si && typeof si.additionalContext === "string") {
-        parts.push(si.additionalContext);
+    /**
+     * experimental.chat.system.transform ← context injection
+     *
+     * Peeks (non-consuming) the context stashed by chat.message for this
+     * session and appends it to the system prompt. chat.message runs before the
+     * system transform within a turn; peeking keeps injection idempotent across
+     * multiple model calls in a turn and prevents an ordering race from
+     * permanently dropping context (the stash is refreshed every chat.message).
+     */
+    "experimental.chat.system.transform": async (
+      input: { sessionID?: string },
+      output: { system?: string[] },
+    ): Promise<void> => {
+      const sessionID = input.sessionID;
+      if (!sessionID) return;
+      const ctx = pendingContext.get(sessionID);
+      if (ctx && Array.isArray(output.system)) {
+        output.system.push(ctx);
       }
-
-      if (parts.length === 0) return undefined;
-
-      const existing = event.session?.systemPrompt ?? "";
-      return {
-        session: {
-          systemPrompt: existing
-            ? `${existing}\n\n${parts.join("\n\n")}`
-            : parts.join("\n\n"),
-        },
-      };
     },
 
     /**
-     * tool.execute.before ← PreToolUse (Bash)
+     * tool.execute.before ← PreToolUse (bash)
      *
-     * Invoked before a tool call is executed. Runs the OMA test-filter for
-     * bash/shell tools to rewrite test-runner commands so only failures reach
-     * the model. Non-bash tools are passed through unchanged.
+     * `input.tool` is a plain string and the command lives on
+     * `output.args.command`. Runs the OMA test-filter for bash commands to
+     * rewrite test-runner invocations so only failures reach the model, then
+     * writes the rewritten command back. Non-bash tools pass through unchanged.
      */
-    "tool.execute.before": async (event: {
-      tool?: { name?: string };
-      input?: { command?: string };
-    }) => {
-      const toolName = event.tool?.name ?? "";
-      if (toolName !== "bash" && toolName !== "Bash") return undefined;
-
-      const command = event.input?.command;
-      if (!command) return undefined;
-
-      const tf = runCore(
-        "test-filter.ts",
-        {
-          tool_name: "Bash",
-          tool_input: { command },
+    "tool.execute.before": async (
+      input: { tool?: string },
+      output: { args?: { command?: string } },
+    ): Promise<void> => {
+      if (input.tool !== "bash") return;
+      const command = output.args?.command;
+      if (typeof command !== "string" || !command) return;
+
+      const updated = extractUpdatedCommand(
+        runCore(
+          "test-filter.ts",
+          {
+            tool_name: "Bash",
+            tool_input: { command },
+            cwd,
+            hook_event_name: "PreToolUse",
+          },
           cwd,
-          hook_event_name: "PreToolUse",
-        },
-        cwd,
+        ),
       );
-
-      const updated = (tf?.updatedInput as { command?: string } | undefined)
-        ?.command;
-      if (updated && event.input) {
-        event.input.command = updated;
+      if (updated && output.args) {
+        output.args.command = updated;
       }
-
-      return undefined;
     },
 
     /**
-     * session.idle ← Stop (BEST-EFFORT / NON-BLOCKING)
+     * event: "session.idle" ← Stop (BEST-EFFORT / re-entrant)
      *
-     * Invoked when the session has no pending work. This is the nearest
-     * opencode analog to the Claude `Stop` hook but it CANNOT block session
-     * termination — opencode treats it as a notification-only event.
+     * opencode delivers session.idle over the event bus (it is no longer a
+     * top-level hook). Unlike the Claude `Stop` hook this cannot block
+     * termination, but the SDK client lets us re-enter the loop: run
+     * persistent-mode and, if a persistent workflow is still active (block
+     * decision), post the block reason back as a new prompt so the agent
+     * continues.
      *
-     * Persistent-workflow Stop semantics are therefore degraded: the handler
-     * runs best-effort and any non-zero hook exit or thrown error is swallowed
-     * so opencode can proceed normally. Do not rely on this handler to hold
-     * the session open; keyword-detector re-injection on the next chat.message
-     * event provides the fallback reinforcement path instead.
+     * BEST-EFFORT: every step is wrapped so a failure can never throw into
+     * opencode. persistent-mode's own reinforcement cap (5) terminates the
+     * loop under normal operation; the per-session consecutive-idle counter is
+     * a runaway backstop for pathological cases only.
      */
-    "session.idle": async (_event: unknown) => {
-      // BEST-EFFORT: errors are swallowed — must not throw or block.
-      runCoreBestEffort(
-        "keyword-detector.ts",
-        {
-          cwd,
-          hook_event_name: "Stop",
-        },
+    event: async (input: {
+      event?: { type?: string; properties?: Record<string, unknown> };
+    }): Promise<void> => {
+      const event = input.event;
+      if (!event || event.type !== "session.idle") return;
+      const sessionID = (event.properties as { sessionID?: string } | undefined)
+        ?.sessionID;
+      if (!sessionID) return;
+
+      const count = idleReentryCount.get(sessionID) ?? 0;
+      if (count >= MAX_CONSECUTIVE_IDLE_REENTRIES) return;
+
+      const pm = runCore(
+        "persistent-mode.ts",
+        { cwd, sessionId: sessionID, hook_event_name: "Stop" },
         cwd,
       );
-      return undefined;
+
+      if (!pm || pm.decision !== "block") {
+        // Workflow complete / not active — clear the backstop counter.
+        idleReentryCount.delete(sessionID);
+        return;
+      }
+
+      const reason =
+        typeof pm.reason === "string" && pm.reason
+          ? pm.reason
+          : "The active OMA workflow is not complete. Continue executing it.";
+      idleReentryCount.set(sessionID, count + 1);
+
+      try {
+        await client?.session?.prompt?.({
+          path: { id: sessionID },
+          body: { parts: [{ type: "text", text: reason }] },
+        });
+      } catch {
+        // Best-effort re-entry — never throw into opencode.
+      }
     },
   };
-}) satisfies (ctx: { $: { cwd: string } }) => Promise<{
-  "chat.message": (event: unknown) => Promise<unknown>;
-  "tool.execute.before": (event: unknown) => Promise<unknown>;
-  "session.idle": (event: unknown) => Promise<unknown>;
+}) satisfies (ctx: {
+  directory?: string;
+  client?: OmaOpencodeClient;
+}) => Promise<{
+  "chat.message": (
+    input: { sessionID?: string },
+    output: {
+      message?: unknown;
+      parts?: Array<{ type?: string; text?: string }>;
+    },
+  ) => Promise<void>;
+  "experimental.chat.system.transform": (
+    input: { sessionID?: string },
+    output: { system?: string[] },
+  ) => Promise<void>;
+  "tool.execute.before": (
+    input: { tool?: string },
+    output: { args?: { command?: string } },
+  ) => Promise<void>;
+  event: (input: {
+    event?: { type?: string; properties?: Record<string, unknown> };
+  }) => Promise<void>;
 }>;
diff --git a/.opencode/plugins/oma/prompt-input.ts b/.opencode/plugins/oma/prompt-input.ts
new file mode 100644
index 0000000..7f18580
--- /dev/null
+++ b/.opencode/plugins/oma/prompt-input.ts
@@ -0,0 +1,45 @@
+// Shared normalizer for the raw `prompt` field delivered on hook stdin.
+//
+// Most host CLIs deliver `prompt` as a plain string, but some (e.g. Kimi Code
+// CLI's UserPromptSubmit payload) deliver it as a ContentPart[] array such as
+// `[{ "type": "text", "text": "hello" }]`. The standalone hook scripts cast it
+// with `(input.prompt as string) ?? ""`, so on those vendors the downstream
+// string methods throw and the top-level catch swallows the error — the entire
+// prompt chain silently no-ops. Route every raw read through this helper so the
+// array shape collapses to the equivalent string.
+
+// Relayed inter-agent messages (teammate reports, task notifications, idle
+// notifications) are transported through the prompt channel but are not user
+// intent: their content routinely carries workflow keywords and skill trigger
+// words, producing false activations. Detect the transport envelopes
+// conservatively so prompt-driven handlers can skip them.
+const RELAY_ENVELOPE_PREFIXES = [
+  "<agent-message",
+  "<teammate-message",
+  "<task-notification",
+];
+
+/** True when the prompt is a relayed inter-agent envelope, not user intent. */
+export function isRelayedAgentMessage(prompt: string): boolean {
+  const trimmed = prompt.trimStart();
+  if (RELAY_ENVELOPE_PREFIXES.some((p) => trimmed.startsWith(p))) return true;
+  return trimmed.slice(0, 200).includes('"type":"idle_notification"');
+}
+
+/** Coerce a raw stdin `prompt` field to a string across vendor payload shapes. */
+export function normalizePromptInput(prompt: unknown): string {
+  if (typeof prompt === "string") return prompt;
+  if (Array.isArray(prompt)) {
+    return prompt
+      .filter(
+        (p): p is { type: string; text: string } =>
+          !!p &&
+          typeof p === "object" &&
+          (p as { type?: unknown }).type === "text" &&
+          typeof (p as { text?: unknown }).text === "string",
+      )
+      .map((p) => p.text)
+      .join(" ");
+  }
+  return "";
+}
diff --git a/.opencode/plugins/oma/serena-primer.ts b/.opencode/plugins/oma/serena-primer.ts
index 6605ac2..df2aabc 100644
--- a/.opencode/plugins/oma/serena-primer.ts
+++ b/.opencode/plugins/oma/serena-primer.ts
@@ -25,6 +25,7 @@ import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { dirname, join } from "node:path";
 import { agyConversationId, isAgyInput, readAgyPrompt } from "./agy-input.ts";
 import { makePromptOutput } from "./hook-output.ts";
+import { normalizePromptInput } from "./prompt-input.ts";
 import type { HandlerCtx, HandlerResult, HookInput, Vendor } from "./types.ts";
 import { getProjectDir, inferVendorFromScriptPath } from "./vendor-detect.ts";
 
@@ -136,7 +137,10 @@ export async function run(
   const { cwd: projectDir, sid: sessionId = "unknown" } = ctx;
 
   if (!isSerenaProject(projectDir)) return null;
-  if (!claimSession(projectDir, sessionId)) return null;
+  // Compaction keeps the session id, so the session-once claim would skip
+  // exactly the turn that just lost the primer from context — force re-inject.
+  const forced = input.source === "compact";
+  if (!claimSession(projectDir, sessionId) && !forced) return null;
 
   return { type: "context", additionalContext: primerContext() };
 }
@@ -190,7 +194,7 @@ async function main() {
   const vendor = detectVendor(input);
   const projectDir = getProjectDir(vendor, input);
   const sessionId = getSessionId(input);
-  let prompt = (input.prompt as string) ?? "";
+  let prompt = normalizePromptInput(input.prompt);
 
   // agy's PreInvocation stdin carries no `prompt`; recover it and only act on
   // the first invocation of a turn.
diff --git a/.opencode/plugins/oma/skill-injector.ts b/.opencode/plugins/oma/skill-injector.ts
index 550fbd8..66c8139 100644
--- a/.opencode/plugins/oma/skill-injector.ts
+++ b/.opencode/plugins/oma/skill-injector.ts
@@ -24,6 +24,7 @@ import { basename, dirname, join } from "node:path";
 import { agyConversationId, isAgyInput, readAgyPrompt } from "./agy-input.ts";
 import { toPosixPath } from "./fs-utils.ts";
 import { makePromptOutput } from "./hook-output.ts";
+import { isRelayedAgentMessage, normalizePromptInput } from "./prompt-input.ts";
 // triggers.json is imported statically: bundler inlines it into the oma binary;
 // standalone bun runs resolve the sibling file (pi / direct run).
 import embeddedTriggers from "./triggers.json" with { type: "json" };
@@ -463,6 +464,11 @@ export async function run(
 
   if (!prompt.trim()) return null;
 
+  // Relayed inter-agent messages (teammate reports, idle notifications) are
+  // not user intent — their content routinely contains skill trigger words
+  // and produced false skill suggestions. Same guard as keyword-detector.
+  if (isRelayedAgentMessage(prompt)) return null;
+
   // Claude-specific: slash-skill resolution must run BEFORE the slash early-exit
   // and persistent-workflow guard (same order as the original standalone path).
   if (vendor === "claude") {
@@ -514,7 +520,7 @@ async function main() {
   const vendor = detectVendor(input);
   const projectDir = getProjectDir(vendor, input);
   const sessionId = getSessionId(input);
-  let prompt = (input.prompt as string) ?? "";
+  let prompt = normalizePromptInput(input.prompt);
 
   // agy's PreInvocation stdin carries no `prompt`; recover it from the
   // transcript, and only act on the first invocation of a turn.
diff --git a/.opencode/plugins/oma/state-boundary.ts b/.opencode/plugins/oma/state-boundary.ts
index 8700b10..ddc1bd0 100644
--- a/.opencode/plugins/oma/state-boundary.ts
+++ b/.opencode/plugins/oma/state-boundary.ts
@@ -6,6 +6,7 @@ import { agyConversationId, isAgyInput } from "./agy-input.ts";
 import { syncGrokContext } from "./grok-context.ts";
 import { makePromptOutput } from "./hook-output.ts";
 import { writeInjectLog } from "./inject-log.ts";
+import { normalizePromptInput } from "./prompt-input.ts";
 import { emitEvent, type OmaEvent, readEvents } from "./state-emit.ts";
 import { getActiveSid, readIndex, setLastSession } from "./state-marker.ts";
 import type { HandlerCtx, HandlerResult, HookInput, Vendor } from "./types.ts";
@@ -98,6 +99,7 @@ export async function onBoundary(
   vendor: Vendor,
   vendorSid: string,
   promptText?: string,
+  forced = false,
 ): Promise<string | null> {
   const idx = readIndex(projectDir);
   const previous = idx.lastSession;
@@ -105,7 +107,9 @@ export async function onBoundary(
     !previous || previous.vendor !== vendor || previous.vendorSid !== vendorSid;
   const statelessTurnFlush = vendor === "kiro" && vendorSid === "unknown";
 
-  if (!boundary && !statelessTurnFlush) {
+  // `forced` = post-compaction SessionStart: the session id is unchanged (no
+  // boundary), but the snapshot was just compacted out of context — re-emit.
+  if (!boundary && !statelessTurnFlush && !forced) {
     setLastSession(projectDir, vendor, vendorSid);
     return null;
   }
@@ -122,7 +126,9 @@ export async function onBoundary(
     vendorSid,
     payload: {
       reason: !boundary
-        ? "stateless-vendor-turn"
+        ? statelessTurnFlush
+          ? "stateless-vendor-turn"
+          : "post-compact-rehydration"
         : previous
           ? "vendor-session-transition"
           : "session-created",
@@ -189,12 +195,15 @@ export async function run(
 
   const { vendor, cwd: projectDir, sid: vendorSid = "unknown" } = ctx;
   // input.kind === "prompt" is guaranteed by the guard above; the user prompt is
-  // the primary recall signal for boundary rehydration.
+  // the primary recall signal for boundary rehydration. A post-compaction
+  // SessionStart (source === "compact") forces re-emission: the session id is
+  // unchanged, but the snapshot was just compacted out of the context window.
   const rendered = await onBoundary(
     projectDir,
     vendor,
     vendorSid,
     input.prompt,
+    input.source === "compact",
   );
   if (!rendered) return null;
   return { type: "context", additionalContext: rendered };
@@ -218,7 +227,7 @@ async function main() {
   // Delegate to run() — single logic source.
   const hookInput: HookInput = {
     kind: "prompt",
-    prompt: (input.prompt as string) ?? "",
+    prompt: normalizePromptInput(input.prompt),
     cwd: projectDir,
   };
   const ctxVal: HandlerCtx = { vendor, cwd: projectDir, sid: vendorSid };
diff --git a/.opencode/plugins/oma/test-filter.ts b/.opencode/plugins/oma/test-filter.ts
index f6ee917..3034ec1 100644
--- a/.opencode/plugins/oma/test-filter.ts
+++ b/.opencode/plugins/oma/test-filter.ts
@@ -103,8 +103,16 @@ export async function run(
   const { toolName, toolInput, cwd: projectDir } = input;
   const { vendor } = ctx;
 
-  // Claude-family uses Bash; some CLIs use run_shell_command.
-  if (toolName !== "Bash" && toolName !== "run_shell_command") return null;
+  // Claude-family uses Bash; some CLIs use run_shell_command; Cursor names its
+  // terminal tool "Shell" (matches cursor.json's preToolUse matcher); Kiro's
+  // canonical shell tool is execute_bash (the agent-JSON matcher name).
+  if (
+    toolName !== "Bash" &&
+    toolName !== "run_shell_command" &&
+    toolName !== "Shell" &&
+    toolName !== "execute_bash"
+  )
+    return null;
 
   const command = toolInput.command as string | undefined;
   if (!command) return null;
@@ -115,12 +123,18 @@ export async function run(
   const isExcluded = EXCLUDE_PATTERNS.some((p) => p.test(command));
   if (isExcluded) return null;
 
-  const filterScript = join(
-    projectDir,
+  // Resolve the filter script: vendor hook dir first, then the opencode
+  // bridge dir (opencode has no core Vendor identity — its subprocess payload
+  // detects as claude, whose hook dir is absent in opencode-only installs),
+  // then the SSOT core dir as the last resort.
+  const filterScript = [
     getHookDir(vendor),
-    "filter-test-output.sh",
-  );
-  if (!existsSync(filterScript)) return null;
+    join(".opencode", "plugins", "oma"),
+    join(".agents", "hooks", "core"),
+  ]
+    .map((dir) => join(projectDir, dir, "filter-test-output.sh"))
+    .find((p) => existsSync(p));
+  if (!filterScript) return null;
 
   const filteredCmd = `set -o pipefail; (${command}) 2>&1 | bash "${filterScript}"`;
   const updatedInput: Record<string, unknown> = {
diff --git a/.opencode/plugins/oma/triggers.json b/.opencode/plugins/oma/triggers.json
index 73c6a59..6e0874d 100644
--- a/.opencode/plugins/oma/triggers.json
+++ b/.opencode/plugins/oma/triggers.json
@@ -3116,7 +3116,6 @@
       "should you",
       "could we",
       "would you",
-      "what if",
       "what about",
       "why build",
       "why create",
@@ -3127,7 +3126,10 @@
       "뭐야",
       "뭐임",
       "무엇",
-      "어떻게",
+      "어떻게 동작",
+      "어떻게 작동",
+      "어떻게 되는지",
+      "어떻게 하는지",
       "설명해",
       "알려줘",
       "키워드",
@@ -3143,13 +3145,12 @@
       "왜 만들",
       "어떻게 만들",
       "어떨까",
-      "하면 좋을",
+      "하면 좋을지",
       "한다면",
       "할까요",
       "보강할",
       "에 대해",
       "에 대한",
-      "한번 봐",
       "깊게 봐",
       "코드를 한번",
       "그 워크플로우",
diff --git a/.opencode/plugins/oma/types.ts b/.opencode/plugins/oma/types.ts
index 5ae6a74..a58ffda 100644
--- a/.opencode/plugins/oma/types.ts
+++ b/.opencode/plugins/oma/types.ts
@@ -54,7 +54,18 @@ export interface ModeState {
  * Discriminated on `kind`; produced by adapters.ts normalizeInput().
  */
 export type HookInput =
-  | { kind: "prompt"; prompt: string; cwd: string }
+  | {
+      kind: "prompt";
+      prompt: string;
+      cwd: string;
+      /**
+       * SessionStart trigger source (claude: startup|resume|clear|compact).
+       * `compact` lets session-once handlers (serena-primer, state-boundary)
+       * force re-injection: compaction keeps the session id, so their normal
+       * dedup would otherwise skip exactly the turn that lost the context.
+       */
+      source?: string;
+    }
   | {
       kind: "pre_tool";
       toolName: string;
diff --git a/.qwen/settings.json b/.qwen/settings.json
index fe2f618..f64724c 100644
--- a/.qwen/settings.json
+++ b/.qwen/settings.json
@@ -30,11 +30,11 @@
           {
             "name": "oma-hook-PreToolUse",
             "type": "command",
-            "command": "\"$QWEN_PROJECT_DIR/.qwen/hooks/oma-hook.sh\" --vendor 'qwen' --event 'PreToolUse' --matcher 'Bash'",
+            "command": "\"$QWEN_PROJECT_DIR/.qwen/hooks/oma-hook.sh\" --vendor 'qwen' --event 'PreToolUse' --matcher 'run_shell_command'",
             "timeout": 10
           }
         ],
-        "matcher": "Bash"
+        "matcher": "run_shell_command"
       }
     ]
   },
@@ -72,5 +72,8 @@
       "command": "'bun' \"$QWEN_PROJECT_DIR/.qwen/hooks/hud.ts\""
     }
   },
-  "$version": 3
+  "$version": 3,
+  "hooksConfig": {
+    "enabled": true
+  }
 }