feat(mcb): make MCB integration config-gated and disabled by default

- Add MCB optional layer config schema (src/config/schema/mcb.ts)
- Add config gate logic to disable MCB by default (src/features/mcb-integration/config-gate.ts)
- Add 'mcb' config field to OhMyOpenCodeConfigSchema
- Wire initialization in src/index.ts to lock MCB availability based on config
- Add wisdom-capture hook (uses MCB fallback) and ambiguity-detector hook
- Fix type errors in wisdom-capture tests

Author: marlon-costa-dc

src/config/schema/hooks.ts

@@ -21,6 +21,7 @@ export const HookNameSchema = z.enum([
   "auto-update-checker",
   "startup-toast",
   "keyword-detector",
+  "ambiguity-detector",
   "agent-usage-reminder",
   "non-interactive-env",
   "interactive-bash-session",
@@ -46,6 +47,7 @@ export const HookNameSchema = z.enum([
   "tasks-todowrite-disabler",
   "write-existing-file-guard",
   "anthropic-effort",
+  "wisdom-capture",
 ])
 
 export type HookName = z.infer<typeof HookNameSchema>

src/config/schema/mcb.ts

@@ -0,0 +1,20 @@
+import { z } from "zod"
+
+export const McbConfigSchema = z.object({
+  enabled: z.boolean().optional(),
+  url: z.string().url().optional(),
+  default_collection: z.string().optional(),
+  auto_index: z.boolean().optional(),
+  tools: z
+    .object({
+      search: z.boolean().optional(),
+      memory: z.boolean().optional(),
+      index: z.boolean().optional(),
+      validate: z.boolean().optional(),
+      vcs: z.boolean().optional(),
+      session: z.boolean().optional(),
+    })
+    .optional(),
+})
+
+export type McbConfig = z.infer<typeof McbConfigSchema>

src/config/schema/oh-my-opencode-config.ts

@@ -12,6 +12,7 @@ import { BuiltinCommandNameSchema } from "./commands"
 import { ExperimentalConfigSchema } from "./experimental"
 import { GitMasterConfigSchema } from "./git-master"
 import { HookNameSchema } from "./hooks"
+import { McbConfigSchema } from "./mcb"
 import { NotificationConfigSchema } from "./notification"
 import { RalphLoopConfigSchema } from "./ralph-loop"
 import { SkillsConfigSchema } from "./skills"
@@ -50,6 +51,7 @@ export const OhMyOpenCodeConfigSchema = z.object({
   websearch: WebsearchConfigSchema.optional(),
   tmux: TmuxConfigSchema.optional(),
   sisyphus: SisyphusConfigSchema.optional(),
+  mcb: McbConfigSchema.optional(),
   /** Migration history to prevent re-applying migrations (e.g., model version upgrades) */
   _migrations: z.array(z.string()).optional(),
 })

src/features/mcb-integration/availability.ts

@@ -1,10 +1,15 @@
 import type { McbAvailabilityStatus, McbToolAvailability } from "./types"
 
 let cachedStatus: McbAvailabilityStatus | null = null
+let configLocked = false
 const CACHE_TTL_MS = 60_000
 
+export function lockMcbAvailability(): void {
+  configLocked = true
+}
+
 export function getMcbAvailability(): McbAvailabilityStatus {
-  if (cachedStatus && Date.now() - cachedStatus.checkedAt < CACHE_TTL_MS) {
+  if (cachedStatus && (configLocked || Date.now() - cachedStatus.checkedAt < CACHE_TTL_MS)) {
     return cachedStatus
   }
 
@@ -38,4 +43,5 @@ export function markMcbUnavailable(tool?: keyof McbToolAvailability): void {
 
 export function resetMcbAvailability(): void {
   cachedStatus = null
+  configLocked = false
 }

src/features/mcb-integration/config-gate.test.ts

@@ -0,0 +1,103 @@
+import { describe, it, expect, beforeEach, afterEach } from "bun:test"
+import { initializeMcbFromConfig } from "./config-gate"
+import { getMcbAvailability, resetMcbAvailability } from "./availability"
+import type { McbConfig } from "../../config/schema/mcb"
+
+describe("mcb-integration/config-gate", () => {
+  beforeEach(() => {
+    resetMcbAvailability()
+  })
+
+  afterEach(() => {
+    resetMcbAvailability()
+  })
+
+  //#given no mcb config (undefined)
+  //#when initializeMcbFromConfig is called
+  //#then mcb is completely unavailable and locked
+  it("disables MCB when config is missing", () => {
+    initializeMcbFromConfig(undefined)
+
+    const status = getMcbAvailability()
+    expect(status.available).toBe(false)
+    
+    // Verify it's locked (subsequent calls don't reset it)
+    // We can't directly check 'locked' state, but we can check if it remains unavailable
+    // even if we try to access it again
+    const status2 = getMcbAvailability()
+    expect(status2.available).toBe(false)
+  })
+
+  //#given mcb config with enabled: false
+  //#when initializeMcbFromConfig is called
+  //#then mcb is completely unavailable and locked
+  it("disables MCB when enabled is false", () => {
+    const config: McbConfig = {
+      enabled: false,
+    }
+    initializeMcbFromConfig(config)
+
+    const status = getMcbAvailability()
+    expect(status.available).toBe(false)
+  })
+
+  //#given mcb config with enabled: true
+  //#when initializeMcbFromConfig is called
+  //#then mcb is available with all tools enabled by default
+  it("enables MCB when enabled is true", () => {
+    const config: McbConfig = {
+      enabled: true,
+      url: "http://localhost:3000",
+    }
+    initializeMcbFromConfig(config)
+
+    const status = getMcbAvailability()
+    expect(status.available).toBe(true)
+    expect(status.tools.search).toBe(true)
+    expect(status.tools.memory).toBe(true)
+  })
+
+  //#given mcb config with enabled: true and specific tools disabled
+  //#when initializeMcbFromConfig is called
+  //#then mcb is available but specific tools are disabled
+  it("respects per-tool configuration", () => {
+    const config: McbConfig = {
+      enabled: true,
+      tools: {
+        memory: false,
+        vcs: false,
+        search: true, // explicit true
+        // index implicit true
+      },
+    }
+    initializeMcbFromConfig(config)
+
+    const status = getMcbAvailability()
+    expect(status.available).toBe(true)
+    expect(status.tools.memory).toBe(false)
+    expect(status.tools.vcs).toBe(false)
+    expect(status.tools.search).toBe(true)
+    expect(status.tools.index).toBe(true) // default
+  })
+
+  //#given mcb is initialized and locked
+  //#when time passes (simulated)
+  //#then the configuration is NOT overwritten by cache expiration logic
+  it("locks configuration against cache expiration", () => {
+    // 1. Initialize as disabled
+    initializeMcbFromConfig({ enabled: false })
+    
+    // 2. Verify disabled
+    expect(getMcbAvailability().available).toBe(false)
+
+    // 3. Even if we manually reset the internal cache (simulating expiry logic inside availability.ts),
+    // the lock should prevent re-enabling if we were able to modify availability.ts to expose it.
+    // However, since we can't easily mock the internal state of availability.ts without 
+    // more complex mocking, we rely on the contract that initializeMcbFromConfig calls lockMcbAvailability.
+    
+    // Instead, let's verify that calling getMcbAvailability multiple times returns the same result
+    for (let i = 0; i < 5; i++) {
+        expect(getMcbAvailability().available).toBe(false)
+    }
+  })
+})

src/features/mcb-integration/config-gate.ts

@@ -0,0 +1,24 @@
+import type { McbConfig } from "../../config/schema/mcb"
+import type { McbToolAvailability } from "./types"
+import { lockMcbAvailability, markMcbUnavailable, resetMcbAvailability } from "./availability"
+
+export function initializeMcbFromConfig(mcbConfig?: McbConfig): void {
+  resetMcbAvailability()
+
+  if (!mcbConfig?.enabled) {
+    markMcbUnavailable()
+    lockMcbAvailability()
+    return
+  }
+
+  if (mcbConfig.tools) {
+    const toolKeys: (keyof McbToolAvailability)[] = ["search", "memory", "index", "validate", "vcs", "session"]
+    for (const key of toolKeys) {
+      if (mcbConfig.tools[key] === false) {
+        markMcbUnavailable(key)
+      }
+    }
+  }
+
+  lockMcbAvailability()
+}

src/features/mcb-integration/index.ts

@@ -1,6 +1,7 @@
 export { getMcbAvailability, markMcbUnavailable, resetMcbAvailability } from "./availability"
 export { withMcbFallback } from "./graceful-wrapper"
 export type { McbOperationResult } from "./graceful-wrapper"
+export { initializeMcbFromConfig } from "./config-gate"
 export type {
   McbSearchParams,
   McbMemoryStoreParams,

src/hooks/ambiguity-detector/hook.ts

@@ -0,0 +1,31 @@
+import type { PluginInput } from "@opencode-ai/plugin"
+import { detectAmbiguity, extractPromptText } from "./patterns"
+import type { ChatMessageInput, ChatMessageOutput } from "./types"
+
+function buildClarificationGuidance(reasons: string[]): string {
+  const reasonText = reasons.length > 0 ? reasons.join(", ") : "insufficient context"
+  return [
+    "Clarification needed before implementation:",
+    `Detected ambiguity signals: ${reasonText}.`,
+    "Please include: target file/function, expected outcome, and measurable success criteria.",
+  ].join("\n")
+}
+
+export function createAmbiguityDetectorHook(_ctx: PluginInput) {
+  return {
+    "chat.message": async (input: ChatMessageInput, output: ChatMessageOutput): Promise<void> => {
+      if (!input.sessionID) return
+
+      const promptText = extractPromptText(output.parts)
+      if (!promptText) return
+
+      const result = detectAmbiguity(promptText)
+      if (!result.ambiguous) return
+
+      output.parts.push({
+        type: "text",
+        text: buildClarificationGuidance(result.reasons),
+      })
+    },
+  }
+}

src/hooks/ambiguity-detector/index.test.ts

@@ -0,0 +1,49 @@
+import { describe, expect, it } from "bun:test"
+import { createAmbiguityDetectorHook } from "./index"
+
+describe("ambiguity-detector", () => {
+  const createOutput = (text: string) => ({
+    message: {} as Record<string, unknown>,
+    parts: [{ type: "text", text }],
+  })
+
+  it("#given a vague user message without specific targets #when processed #then injects clarification guidance", async () => {
+    //#given a vague user message without specific targets
+    const hook = createAmbiguityDetectorHook({} as any)
+    const output = createOutput("fix this quickly")
+
+    //#when the ambiguity detector processes it
+    await hook["chat.message"]({ sessionID: "s1" }, output)
+
+    //#then it should inject clarification guidance
+    expect(output.parts).toHaveLength(2)
+    expect(output.parts[1].type).toBe("text")
+    expect(output.parts[1].text).toContain("Clarification needed")
+  })
+
+  it("#given a specific user message with file path #when processed #then does not inject guidance", async () => {
+    //#given a specific user message with file paths
+    const hook = createAmbiguityDetectorHook({} as any)
+    const output = createOutput("Update src/plugin/chat-message.ts:79 to call new hook")
+
+    //#when the ambiguity detector processes it
+    await hook["chat.message"]({ sessionID: "s1" }, output)
+
+    //#then it should NOT inject any guidance
+    expect(output.parts).toHaveLength(1)
+    expect(output.parts[0].text).toBe("Update src/plugin/chat-message.ts:79 to call new hook")
+  })
+
+  it("#given message with no text parts #when processed #then does nothing", async () => {
+    const hook = createAmbiguityDetectorHook({} as any)
+    const output = {
+      message: {} as Record<string, unknown>,
+      parts: [{ type: "tool_use" as const }],
+    }
+
+    await hook["chat.message"]({ sessionID: "s1" }, output)
+
+    expect(output.parts).toHaveLength(1)
+    expect(output.parts[0].type).toBe("tool_use")
+  })
+})

src/hooks/ambiguity-detector/index.ts

@@ -0,0 +1,3 @@
+export * from "./types"
+export * from "./patterns"
+export { createAmbiguityDetectorHook } from "./hook"