@retaw106/mmc-oc 1.2.3 → 2.1.0

package/src/shared/historian-tool-expansions.ts

@@ -1,18 +1,75 @@
 import defaults from "./historian-tool-defaults.json";
+import previewDefaults from "./historian-tool-preview-defaults.json";
 import { renderToolTemplate, type ToolExpansionMap } from "./historian-tool-template";
 
 export { defaults as DEFAULT_TOOL_EXPANSIONS };
-export function expandToolPart(part: unknown, overrides?: ToolExpansionMap): string | null {
+
+// Room actions, private-message addresses and board lanes have multiple input
+// shapes. Derive readable labels only for built-ins; configured template overrides
+// keep the unmodified tool input.
+function builtinInput(tool: string, input: unknown): unknown {
+    if (!input || typeof input !== "object") return input;
+    const i = input as Record<string, unknown>;
+    if (tool === "peer_send") {
+        const external = i.external as Record<string, unknown> | undefined;
+        const recipient = i.reply_to_pmid
+            ? `reply to ${i.reply_to_pmid}`
+            : i.agent || i.agent_id
+              ? `to ${i.agent || i.agent_id}`
+              : external?.session_id || i.session_id
+                ? `to session ${external?.session_id || i.session_id}`
+                : "to unknown recipient";
+        return { ...i, recipient };
+    }
+    if (tool === "room") {
+        return {
+            ...i,
+            room_label: i.room_id || i.title,
+            room_detail:
+                i.action === "create" || i.action === "invite"
+                    ? `invitees: ${renderToolTemplate("${input.invitees}", i)}`
+                    : i.text,
+        };
+    }
+    if (tool === "board") {
+        return {
+            ...i,
+            board_lane: i.lane ? ` ${i.lane}` : "",
+            ops: Array.isArray(i.ops)
+                ? i.ops.map((op) =>
+                      op && typeof op === "object"
+                          ? {
+                                ...op,
+                                lane_label:
+                                    typeof op.lane === "string"
+                                        ? op.lane
+                                        : op.lane?.title || op.lane?.id,
+                            }
+                          : op,
+                  )
+                : i.ops,
+        };
+    }
+    return input;
+}
+
+export function expandToolPart(
+    part: unknown,
+    overrides?: ToolExpansionMap,
+    legacyPreview = false,
+): string | null {
     if (!part || typeof part !== "object") return null;
     const p = part as Record<string, unknown>;
     if (p.type !== "tool" || typeof p.tool !== "string") return null;
-    const template =
-        overrides && Object.hasOwn(overrides, p.tool)
-            ? overrides[p.tool]
-            : Object.hasOwn(defaults, p.tool)
-              ? defaults[p.tool as keyof typeof defaults]
-              : undefined;
+    const builtinDefaults = legacyPreview ? previewDefaults : defaults;
+    const overridden = overrides && Object.hasOwn(overrides, p.tool);
+    const template = overridden
+        ? overrides[p.tool]
+        : Object.hasOwn(builtinDefaults, p.tool)
+          ? builtinDefaults[p.tool as keyof typeof defaults]
+          : undefined;
     if (typeof template !== "string") return null;
     const state = p.state as Record<string, unknown> | undefined;
-    return renderToolTemplate(template, state?.input, state?.output ?? state?.error);
+    const input = overridden || legacyPreview ? state?.input : builtinInput(p.tool, state?.input);
+    return renderToolTemplate(template, input, state?.output ?? state?.error, legacyPreview);
 }

package/src/shared/historian-tool-preview-defaults.json

@@ -0,0 +1,13 @@
+{
+  "todowrite": "Todos (${input.todos.count}): ${input.todos.each(\"${status}: ${content}\")}",
+  "question": "Asked user: ${input.questions[*].question.join(\" / \")} → ${output}",
+  "task": "Task ${input.subagent_type}: ${input.prompt} → ${output.truncate(200)}",
+  "ask": "Asked: ${input.question.truncate(250)} [options: ${input.options.join(\" / \")}] ${input.resolution} → ${output.truncate(300)}",
+  "peer_send": "PM to ${input.agent}${input.agent_id}: ${input.message.truncate(400)}",
+  "board": "Board ${input.verb}: ${input.ops.each(\"${op} ${item}${lane.title} ${state}${lane.status}${props.text} ${lane.items[*].text}\")}",
+  "room": "Room ${input.action} ${input.room_id}: ${input.text.truncate(400)}",
+  "work": "Work ${input.action} ${input.id}: ${input.prompt_file}${input.prompt.truncate(200)}${input.notes.truncate(200)} → ${output.truncate(160)}",
+  "knowhow": "Looked up how-to: ${input.query}${input.id}",
+  "mmc_note": "Note ${input.action} ${input.note_ids}: ${input.content} → ${output.truncate(160)}",
+  "mmc_memory": "Memory ${input.action} ${input.category} ${input.ids}: ${input.content} → ${output.truncate(160)}"
+}

package/src/shared/historian-tool-template.ts

@@ -1,4 +1,4 @@
-/** A deliberately non-executable language for readable, bounded historian tool lines. */
+/** A deliberately non-executable language for readable historian tool lines. */
 export type ToolExpansionMap = Record<string, string | false>;
 type Step = { field: string } | { index: number } | { project: string };
 type Expression = {
@@ -6,7 +6,7 @@ type Expression = {
     each?: Template;
     join?: string;
     count?: boolean;
-    cap: number;
+    cap?: number;
 };
 type Template = Array<string | Expression>;
 
@@ -78,7 +78,7 @@ class Parser {
                 if (this.source[this.pos] === "(") return this.error();
             } else break;
         }
-        const expression: Expression = { steps, cap: 300 };
+        const expression: Expression = { steps };
         if (this.take(".each(")) {
             if (relative) return this.error();
             expression.each = parseTemplate(this.quoted(), true);
@@ -145,9 +145,24 @@ function compiled(source: string): Template | null {
 function oneLine(value: string): string {
     return value.replace(/[\r\n\u2028\u2029]+/g, " ");
 }
-function truncate(value: string, cap: number): string {
+function truncate(value: string, cap?: number, legacyPreview = false): string {
     const chars = Array.from(oneLine(value));
-    return chars.length > cap ? `${chars.slice(0, cap).join("")}…` : chars.join("");
+    if (cap === undefined || chars.length <= cap) return chars.join("");
+    if (legacyPreview) return `${chars.slice(0, cap).join("")}…`;
+    // Explicit caps stop after sentence-ending punctuation so a cut is not
+    // mistaken for an intact tool message. If no sentence fits, show only the marker.
+    let end = 0;
+    for (let i = 0; i < Math.min(cap, chars.length); i++) {
+        if (!".!?。！？".includes(chars[i])) continue;
+        let next = i + 1;
+        while (next < chars.length && "\"'”’)]".includes(chars[next])) next++;
+        if (
+            next <= cap &&
+            ("。！？".includes(chars[i]) || next === chars.length || /[ \t]/.test(chars[next]))
+        )
+            end = next;
+    }
+    return `${end ? `${chars.slice(0, end).join("")} ` : ""}[… ${chars.length - end} more characters]`;
 }
 function scalar(value: unknown): string {
     if (value === undefined) return "";
@@ -174,10 +189,11 @@ function field(value: unknown, key: string): unknown {
         ? (value as Record<string, unknown>)[key]
         : undefined;
 }
-function render(nodes: Template, root: unknown): string {
+function render(nodes: Template, root: unknown, legacyPreview: boolean): string {
     return nodes
         .map((node) => {
             if (typeof node === "string") return node;
+            const cap = node.cap ?? (legacyPreview ? 300 : undefined);
             let value = root;
             let list = false;
             for (const step of node.steps) {
@@ -196,18 +212,31 @@ function render(nodes: Template, root: unknown): string {
                 }
             }
             if (node.count)
-                return truncate(Array.isArray(value) ? String(value.length) : "", node.cap);
+                return truncate(
+                    Array.isArray(value) ? String(value.length) : "",
+                    cap,
+                    legacyPreview,
+                );
             if (node.each || list || node.join !== undefined) {
                 if (!Array.isArray(value)) return "";
                 const elements = value
-                    .slice(0, 10)
+                    .slice(0, legacyPreview ? 10 : undefined)
                     .map((item) =>
-                        truncate(node.each ? render(node.each, item) : scalar(item), 300),
+                        truncate(
+                            node.each ? render(node.each, item, legacyPreview) : scalar(item),
+                            legacyPreview ? 300 : undefined,
+                            legacyPreview,
+                        ),
                     );
-                if (value.length > 10) elements.push(`… +${value.length - 10} more`);
-                return truncate(elements.join(node.join ?? (node.each ? "; " : ", ")), node.cap);
+                if (legacyPreview && value.length > 10)
+                    elements.push(`… +${value.length - 10} more`);
+                return truncate(
+                    elements.join(node.join ?? (node.each ? "; " : ", ")),
+                    cap,
+                    legacyPreview,
+                );
             }
-            return truncate(scalar(value), node.cap);
+            return truncate(scalar(value), cap, legacyPreview);
         })
         .join("");
 }
@@ -216,6 +245,7 @@ export function renderToolTemplate(
     source: string,
     input: unknown,
     output?: unknown,
+    legacyPreview = false,
 ): string | null {
     const nodes = compiled(source);
     if (!nodes) return null;
@@ -241,8 +271,12 @@ export function renderToolTemplate(
         !node.each &&
         !node.count &&
         node.join === undefined
-            ? truncate(text ?? "", node.cap)
+            ? truncate(text ?? "", node.cap ?? (legacyPreview ? 300 : undefined), legacyPreview)
             : node,
     );
-    return truncate(render(bareOutputNodes, root), 1000);
+    return truncate(
+        render(bareOutputNodes, root, legacyPreview),
+        legacyPreview ? 1000 : undefined,
+        legacyPreview,
+    );
 }

package/src/shared/model-cache-ttl.test.ts

@@ -29,8 +29,8 @@ describe("known model cache TTL", () => {
         expect(resolveCacheTtl("5m", "openai/gpt-6")).toBe("30m");
         expect(resolveCacheTtl("10m", "openai/gpt-6")).toBe("10m");
     });
-    it("honors per-model entries before built-ins and built-ins before object defaults", () => {
-        expect(resolveCacheTtl({ default: "10m" }, "openai/gpt-6")).toBe("30m");
+    it("honors per-model entries and configured defaults before built-ins", () => {
+        expect(resolveCacheTtl({ default: "10m" }, "openai/gpt-6")).toBe("10m");
         expect(resolveCacheTtl({ default: "10m", "gpt-6": "5m" }, "openai/gpt-6")).toBe("5m");
         expect(resolveCacheTtl({ default: "10m", "openai/*": "never" }, "openai/gpt-6")).toBe(
             "never",

package/src/shared/model-cache-ttl.ts

@@ -28,6 +28,8 @@ const MODEL_CACHE_LIFETIMES = [
 export function resolveModelCacheTtl(
     config: CacheTtlConfig | undefined,
     modelKey: string | undefined,
+    configuredExplicitly = typeof config === "object" ||
+        (typeof config === "string" && config !== "5m"),
 ): ResolvedCacheTtl {
     if (config && typeof config !== "string") {
         const match =
@@ -37,11 +39,13 @@ export function resolveModelCacheTtl(
             modelKey !== "default"
                 ? config[modelKey]
                 : resolveModelConfigValue(config, modelKey)?.value;
-        if (match !== undefined) return { value: match, source: "config", modelKey };
+        const value = match ?? config.default;
+        if (value !== undefined && configuredExplicitly)
+            return { value, source: "config", modelKey };
     }
-    // A non-5m global string is an explicit policy. The generic 5m default is
-    // not evidence of provider eviction: documented lifetimes avoid paid rewrites.
-    if (typeof config === "string" && config !== "5m")
+    // The loader supplies provenance: an explicit 5m is policy too. Older callers
+    // without that bit still distinguish non-default strings from the schema's 5m.
+    if (typeof config === "string" && configuredExplicitly)
         return { value: config, source: "config", modelKey };
     const model =
         canonicalModelIdentity(modelKey ?? "")

package/src/shared/model-resolution.test.ts

@@ -18,8 +18,9 @@ describe("model-resolution", () => {
             const resolved = resolveHistorianAgentOverrides({
                 ...(fixture.temperature !== undefined ? { temperature: fixture.temperature } : {}),
                 maxTokens: 16_000,
-                opencode: { model: "google/flash", variant: "low" },
-                pi: { model: "pi/must-not-leak", thinking_level: "high" },
+                model: "google/flash",
+                variant: "low",
+                thinking_level: "high",
             });
             expect(resolved).toEqual({
                 maxTokens: 16_000,
@@ -61,8 +62,7 @@ describe("model-resolution", () => {
     test("keeps the flash calibration available only as an explicit override", () => {
         expect(
             resolveHistorianAgentOverrides({
-                opencode: { model: { model: "google/flash", variant: "fast" } },
-                pi: { model: "pi/ignored" },
+                model: { model: "google/flash", variant: "fast" },
                 two_pass: true,
             }),
         ).toEqual({
@@ -76,56 +76,46 @@ describe("model-resolution", () => {
         ).toMatchObject({ temperature: 0.1, maxTokens: 12_000 });
     });
 
-    test("does not inherit a block qualifier into unqualified fallbacks", () => {
+    test("does not inherit the primary qualifier into unqualified fallbacks", () => {
         const config = {
             historian: {
-                opencode: {
-                    model: "open/primary",
-                    fallback_models: ["open/fallback"],
-                    variant: "primary-only",
-                },
-                pi: {
-                    model: "pi/primary",
-                    fallback_models: ["pi/fallback"],
-                    thinking_level: "high",
-                },
+                model: "open/primary",
+                fallback_models: ["open/fallback"],
+                variant: "primary-only",
+                thinking_level: "high",
             },
         };
 
         // Inheritance is deliberately absent because a fallback model may not support the
-        // qualifier selected for the primary model.
+        // qualifier selected for the primary model. Each harness reads only its own
+        // qualifier (OpenCode variant, Pi thinking_level) from the flat entry.
         expect(resolveHistorianModel(config, "opencode")).toEqual({
             primary: { model: "open/primary", qualifier: "primary-only" },
             fallbacks: [{ model: "open/fallback" }],
         });
         expect(resolveHistorianModel(config, "pi")).toEqual({
-            primary: { model: "pi/primary", qualifier: "high" },
-            fallbacks: [{ model: "pi/fallback" }],
+            primary: { model: "open/primary", qualifier: "high" },
+            fallbacks: [{ model: "open/fallback" }],
         });
     });
 
-    test("reads historian attempts only from the requested harness", () => {
+    test("selects the requested harness's qualifier from a shared flat entry", () => {
         const config = {
             historian: {
-                model: "flat/ignored",
-                opencode: {
-                    model: { model: "open/code", variant: "oc-primary" },
-                    fallback_models: [{ model: "open/fallback", variant: "oc-fallback" }],
-                },
-                pi: {
-                    model: { model: "pi/model", thinking_level: "high" },
-                    fallback_models: [{ model: "pi/fallback", thinking_level: "max" }],
-                },
+                model: { model: "shared/model", variant: "oc-primary", thinking_level: "high" },
+                fallback_models: [
+                    { model: "shared/fallback", variant: "oc-fallback", thinking_level: "max" },
+                ],
             },
         };
 
         expect(resolveHistorianModel(config, "opencode")).toEqual({
-            primary: { model: "open/code", qualifier: "oc-primary" },
-            fallbacks: [{ model: "open/fallback", qualifier: "oc-fallback" }],
+            primary: { model: "shared/model", qualifier: "oc-primary" },
+            fallbacks: [{ model: "shared/fallback", qualifier: "oc-fallback" }],
         });
         expect(resolveHistorianModel(config, "pi")).toEqual({
-            primary: { model: "pi/model", qualifier: "high" },
-            fallbacks: [{ model: "pi/fallback", qualifier: "max" }],
+            primary: { model: "shared/model", qualifier: "high" },
+            fallbacks: [{ model: "shared/fallback", qualifier: "max" }],
         });
         expect(resolveHistorianModel({}, "pi")).toEqual({ fallbacks: [] });
     });

package/src/shared/model-resolution.ts

@@ -1,4 +1,4 @@
-export type ModelHarness = "opencode" | "pi";
+export type ModelHarness = "opencode" | "pi" | "omp";
 
 export interface ResolvedModelEntry {
     /** Canonical provider/model reference used for identity and model selection. */
@@ -23,13 +23,6 @@ function readString(value: unknown): string | undefined {
     return trimmed.length > 0 ? trimmed : undefined;
 }
 
-function resolveHarnessBlock(
-    container: ConfigRecord | undefined,
-    harness: ModelHarness,
-): ConfigRecord | undefined {
-    return asRecord(container?.[harness]);
-}
-
 /**
  * Collapses the string and object spellings of a harness model entry into the
  * same model identity. Qualifiers stay separate because they alter an attempt,
@@ -101,29 +94,31 @@ export interface ResolvedHistorianModel {
 }
 
 /**
- * Resolve historian model attempts from the selected harness block.
+ * Resolve historian model attempts from the flat historian config. The harness
+ * parameter selects which qualifier is read: OpenCode uses `variant`, Pi uses
+ * `thinking_level`. The other harness's qualifier is ignored (no cross-harness
+ * mapping).
  */
 export function resolveHistorianModel(
     config: unknown,
     harness: ModelHarness,
 ): ResolvedHistorianModel {
     const historian = asRecord(asRecord(config)?.historian);
-    const block = resolveHarnessBlock(historian, harness);
-    if (!block) return { fallbacks: [] };
+    if (!historian) return { fallbacks: [] };
 
     return {
         primary: resolvePrimaryEntry({
-            entry: block.model,
-            defaultQualifier: block[harness === "opencode" ? "variant" : "thinking_level"],
+            entry: historian.model,
+            defaultQualifier: historian[harness === "opencode" ? "variant" : "thinking_level"],
             harness,
         }),
-        fallbacks: resolveFallbackEntries(block.fallback_models, harness),
+        fallbacks: resolveFallbackEntries(historian.fallback_models, harness),
     };
 }
 
 /**
  * Keep non-model agent settings at their original level while replacing only
- * OpenCode's model-resolution fields with the executing harness's primary.
+ * OpenCode's model-resolution fields with the flat primary entry.
  */
 export function resolveOpenCodeAgentOverrides(agent: unknown): Record<string, unknown> {
     const source = asRecord(agent);
@@ -133,14 +128,14 @@ export function resolveOpenCodeAgentOverrides(agent: unknown): Record<string, un
         fallback_models: _fallbackModels,
         variant: _variant,
         thinking_level: _thinking,
-        opencode,
-        pi,
+        opencode: _opencode,
+        pi: _pi,
         tasks,
         ...rest
     } = source;
     const primary = resolvePrimaryEntry({
-        entry: asRecord(opencode)?.model,
-        defaultQualifier: asRecord(opencode)?.variant,
+        entry: source.model,
+        defaultQualifier: source.variant,
         harness: "opencode",
     });
     return {

package/src/shared/model-suggestion-retry.ts

@@ -1,5 +1,4 @@
 import type { createOpencodeClient } from "@opencode-ai/sdk";
-
 import { detectOverflow } from "../features/magic-context/overflow-detection";
 import { HiddenCompletionRefusal } from "../hooks/magic-context/compartment-runner-types";
 import { HiddenAgentStepLimit } from "../v2/hooks/hidden-child";
@@ -11,6 +10,12 @@ import {
 } from "./assistant-message-extractor";
 import { log } from "./logger";
 import type { ModelInput } from "./model-resolution";
+import {
+    ProviderOutputFailureError,
+    primaryQuotaFailure,
+    providerOutputFailureFromInvalidManifest,
+    rememberPrimaryQuota,
+} from "./provider-output-failure";
 import { sanitizeDiagnosticText } from "./redaction";
 import { parseProviderModel, toModelEntry } from "./resolve-fallbacks";
 
@@ -59,6 +64,8 @@ export interface PromptAttemptInfo {
     totalAttempts: number;
     /** Explicit model override for this attempt, when one was supplied. */
     model?: { providerID: string; modelID: string };
+    /** A run-local quota deadline prevented dispatch; not an actual model call. */
+    skipped?: boolean;
 }
 
 export interface PromptRetryOptions {
@@ -433,14 +440,25 @@ function throwWithPromptFailure(
         legacyError instanceof Error ? legacyError : new Error(extractMessage(legacyError));
     const last = failedAttempts.at(-1);
     const failureClass = last?.failureClass ?? "unknown";
+    const quota = failedAttempts.find(
+        (failure) =>
+            failure.error instanceof ProviderOutputFailureError &&
+            failure.error.quotaResetAt !== undefined,
+    )?.error as ProviderOutputFailureError | undefined;
+    if (quota && error !== quota && !error.message.includes(quota.message))
+        error.message = `${quota.message}; ${error.message}`;
     const providerError =
-        failureClass === "provider_error"
-            ? sanitizeDiagnosticText(shortErr(last?.error ?? legacyError)).slice(0, 500)
+        failureClass === "provider_error" || quota
+            ? sanitizeDiagnosticText(
+                  `${quota ? `${quota.message}; ` : ""}${shortErr(last?.error ?? legacyError)}`,
+              ).slice(0, 500)
             : null;
     promptFailureDetails.set(error, {
         failureClass,
         modelAttempted: last?.attempt.label ?? null,
-        modelsTried: failedAttempts.map((failure) => failure.attempt.label),
+        modelsTried: failedAttempts
+            .filter((failure) => !failure.attempt.skipped)
+            .map((failure) => failure.attempt.label),
         providerError,
         timeoutMs: failureClass === "provider_timeout" ? timeoutMs : null,
         childSessionId: transport ? (transport.childSessionId ?? null) : args.path.id || null,
@@ -664,6 +682,16 @@ async function attemptAndValidate<TOutput, TValidated>(
     }
 
     try {
+        // Only the structured account-pool notice bypasses caller validation.
+        // The near-zero-token heuristic remains owned by manifest callers.
+        const messages = Array.isArray(output)
+            ? output
+            : (output as { messages?: unknown } | null)?.messages;
+        const text = extractLatestAssistantText(messages);
+        if (text) {
+            const failure = providerOutputFailureFromInvalidManifest(messages, text);
+            if (failure?.quotaResetAt !== undefined) throw failure;
+        }
         if (!extractLatestAssistantText(output)) {
             const assistantFailure = extractLatestAssistantFailure(output);
             if (assistantFailure) {
@@ -718,8 +746,22 @@ export async function promptSyncWithValidatedOutputRetry<TOutput, TValidated = T
     const failedAttempts: FailedAttempt[] = [];
     let firstError: unknown = null;
     let lastError: unknown = null;
+    const cooledPrimary = primaryQuotaFailure(explicitPrimaryLabel);
 
     try {
+        if (cooledPrimary)
+            throw {
+                error: cooledPrimary,
+                failureClass: "provider_error",
+                attempt: {
+                    label: explicitPrimaryLabel,
+                    attemptIndex: 0,
+                    isFallback: false,
+                    totalAttempts,
+                    model: baseBody.model,
+                    skipped: true,
+                },
+            } satisfies FailedAttempt;
         return await attemptAndValidate(
             client,
             baseArgs,
@@ -739,6 +781,19 @@ export async function promptSyncWithValidatedOutputRetry<TOutput, TValidated = T
         const failure = caught as FailedAttempt;
         failedAttempts.push(failure);
         firstError = failure.error;
+        if (
+            failure.error instanceof ProviderOutputFailureError &&
+            failure.error.quotaResetAt !== undefined
+        )
+            failure.error.message = failure.error.message.replace(
+                /^provider quota exhausted/,
+                "primary quota exhausted",
+            );
+        const quota = !cooledPrimary && rememberPrimaryQuota(explicitPrimaryLabel, failure.error);
+        if (quota)
+            log(
+                `[${callContext}] ${quota.message}; skipping ${explicitPrimaryLabel} for this run until reset`,
+            );
         lastError = failure.error;
         if (isNonRetryable(failure.error, options.signal)) {
             throwWithPromptFailure(
@@ -760,9 +815,10 @@ export async function promptSyncWithValidatedOutputRetry<TOutput, TValidated = T
             );
         }
 
-        log(
-            `[${callContext}] primary (${explicitPrimaryLabel}) failed validation/prompt: ${shortErr(failure.error)}; trying ${fallbacks.length} fallback(s)`,
-        );
+        if (!cooledPrimary && !quota)
+            log(
+                `[${callContext}] primary (${explicitPrimaryLabel}) failed validation/prompt: ${shortErr(failure.error)}; trying ${fallbacks.length} fallback(s)`,
+            );
     }
 
     for (let i = 0; i < fallbacks.length; i += 1) {

package/src/shared/protected-tools-policy.ts

@@ -0,0 +1,25 @@
+/** Default result keep counts shared by runtime and configuration. */
+export const DEFAULT_PROTECTED_TOOLS: Readonly<Record<string, number>> = {
+    todowrite: 1,
+    // The fork's tool name; upstream's ctx_reduce alias merges onto the same key.
+    mmc_reduce: 3,
+};
+
+export function normalizeProtectedToolName(name: string | null): string {
+    const lowered = (name ?? "").toLowerCase().replace(/^mcp_/, "");
+    return lowered === "ctx_reduce" ? "mmc_reduce" : lowered;
+}
+
+/** Normalize before merging tiers so aliases cannot defeat a project override. */
+export function mergeProtectedTools(
+    ...maps: (Readonly<Record<string, number>> | undefined)[]
+): Record<string, number> {
+    return Object.fromEntries(
+        [DEFAULT_PROTECTED_TOOLS, ...maps].flatMap((map) =>
+            Object.entries(map ?? {}).map(([name, count]) => [
+                normalizeProtectedToolName(name),
+                count,
+            ]),
+        ),
+    );
+}