opencode-matrixx 2.6.12 → 2.6.13

package/dist/agents/dynamic-agent-prompt-builder.d.ts

@@ -39,8 +39,8 @@ export declare function _resetDisciplineCacheForTesting(): void;
 export declare function hasGrepGlobToolNames(toolNames: readonly string[]): boolean;
 export declare function fallbackFullDiscipline(hasGrepGlob: boolean, dcpMode?: DcpCompressionMode): string;
 export declare function fallbackCompactDiscipline(hasGrepGlob: boolean, dcpMode?: DcpCompressionMode): string;
-export declare function buildContextDisciplineSection(hasContextMode?: boolean, hasGrepGlob?: boolean, dcpMode?: DcpCompressionMode): string;
-export declare function buildHeadroomSection(hasHeadroom?: boolean, dcpMode?: DcpCompressionMode): string;
-export declare function buildCompactContextDisciplineSection(hasContextMode?: boolean, hasGrepGlob?: boolean, dcpMode?: DcpCompressionMode): string;
-export declare function buildExploreDisciplineSection(hasContextMode?: boolean, hasHeadroom?: boolean, hasGrepGlob?: boolean): string;
+export declare function buildContextDisciplineSection(hasContextMode?: boolean, hasGrepGlob?: boolean, dcpMode?: DcpCompressionMode, modelID?: string): string;
+export declare function buildHeadroomSection(hasHeadroom?: boolean, dcpMode?: DcpCompressionMode, modelID?: string): string;
+export declare function buildCompactContextDisciplineSection(hasContextMode?: boolean, hasGrepGlob?: boolean, dcpMode?: DcpCompressionMode, modelID?: string): string;
+export declare function buildExploreDisciplineSection(hasContextMode?: boolean, hasHeadroom?: boolean, hasGrepGlob?: boolean, modelID?: string): string;
 export declare function buildUltraworkSection(agents: AvailableAgent[], categories: AvailableCategory[], skills: AvailableSkill[]): string;

package/dist/agents/model-directives.d.ts

@@ -0,0 +1,7 @@
+export type ModelDirective = {
+    antiEcho?: string;
+    nudgeHandling?: string;
+};
+export declare function resolveModelFamily(modelID?: string): string | undefined;
+export declare function getModelDirectives(modelID?: string): ModelDirective;
+export declare function appendModelDirective(section: string, modelID?: string): string;

package/dist/cli.js

@@ -15892,9 +15892,13 @@ var ContextModeConfigSchema = exports_external.object({
 });
 
 // src/config/schema/dcp.ts
+var dcpLimitValue = exports_external.union([exports_external.number(), exports_external.string().regex(/^\d+%$/)]);
+var dcpModelLimitKey = exports_external.string().regex(/^[^/]+\/[^/]+$/);
 var DcpCompressOverrideSchema = exports_external.object({
   maxContextLimit: exports_external.union([exports_external.number(), exports_external.string().regex(/^\d+%$/)]).optional(),
   minContextLimit: exports_external.union([exports_external.number(), exports_external.string().regex(/^\d+%$/)]).optional(),
+  modelMaxLimits: exports_external.record(dcpModelLimitKey, dcpLimitValue).optional(),
+  modelMinLimits: exports_external.record(dcpModelLimitKey, dcpLimitValue).optional(),
   nudgeFrequency: exports_external.number().int().min(1).optional(),
   iterationNudgeThreshold: exports_external.number().int().min(1).optional(),
   nudgeForce: exports_external.enum(["strong", "soft"]).optional(),
@@ -16171,12 +16175,13 @@ var HookNameEnum = exports_external.enum([
   "evolution-compressor",
   "evolution-hitl",
   "context-mode-enforcer",
-  "context-mode-enforcer",
   "task-edit-guard",
   "document-reader-guard",
   "knowledge-hub-guard",
   "knowledge-hub-injector",
-  "knowledge-hub-search-nudge"
+  "knowledge-hub-search-nudge",
+  "dcp-nudge-sanitizer",
+  "nudge-loop-breaker"
 ]);
 var HookNameSchema = exports_external.union([
   HookNameEnum,

package/dist/config/schema/dcp.d.ts

@@ -1,15 +1,9 @@
 import { z } from "zod";
-/**
- * DCP (Dynamic Context Pruning) configuration.
- *
- * Selects between predefined DCP profile tiers
- * (economy/balanced/performance/ultimate) via `dcp.default_profile`.
- *
- * DCP must be installed as a plugin: `~/.config/opencode/node_modules/@tarquinen/opencode-dcp`
- */
 export declare const DcpCompressOverrideSchema: z.ZodObject<{
     maxContextLimit: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>>;
     minContextLimit: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>>;
+    modelMaxLimits: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>>>;
+    modelMinLimits: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>>>;
     nudgeFrequency: z.ZodOptional<z.ZodNumber>;
     iterationNudgeThreshold: z.ZodOptional<z.ZodNumber>;
     nudgeForce: z.ZodOptional<z.ZodEnum<{
@@ -45,6 +39,8 @@ export declare const DcpProfileDefinitionSchema: z.ZodObject<{
     compress: z.ZodOptional<z.ZodObject<{
         maxContextLimit: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>>;
         minContextLimit: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>>;
+        modelMaxLimits: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>>>;
+        modelMinLimits: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>>>;
         nudgeFrequency: z.ZodOptional<z.ZodNumber>;
         iterationNudgeThreshold: z.ZodOptional<z.ZodNumber>;
         nudgeForce: z.ZodOptional<z.ZodEnum<{
@@ -163,9 +159,15 @@ export declare const BUILTIN_DCP_PROFILES: {
         readonly compress: {
             readonly maxContextLimit: "20%";
             readonly minContextLimit: "10%";
-            readonly nudgeFrequency: 1;
-            readonly nudgeForce: "strong";
-            readonly iterationNudgeThreshold: 1;
+            readonly nudgeFrequency: 3;
+            readonly nudgeForce: "soft";
+            readonly iterationNudgeThreshold: 6;
+            readonly modelMaxLimits: {
+                readonly "deepseek/deepseek-v4.1-flash": "95%";
+            };
+            readonly modelMinLimits: {
+                readonly "deepseek/deepseek-v4.1-flash": "90%";
+            };
         };
         readonly turnProtection: {
             readonly enabled: false;
@@ -207,6 +209,8 @@ export declare const DcpConfigSchema: z.ZodObject<{
         compress: z.ZodOptional<z.ZodObject<{
             maxContextLimit: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>>;
             minContextLimit: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>>;
+            modelMaxLimits: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>>>;
+            modelMinLimits: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>>>;
             nudgeFrequency: z.ZodOptional<z.ZodNumber>;
             iterationNudgeThreshold: z.ZodOptional<z.ZodNumber>;
             nudgeForce: z.ZodOptional<z.ZodEnum<{

package/dist/config/schema/hooks.d.ts

@@ -64,5 +64,7 @@ export declare const HookNameSchema: z.ZodUnion<readonly [z.ZodEnum<{
     "knowledge-hub-guard": "knowledge-hub-guard";
     "knowledge-hub-injector": "knowledge-hub-injector";
     "knowledge-hub-search-nudge": "knowledge-hub-search-nudge";
+    "dcp-nudge-sanitizer": "dcp-nudge-sanitizer";
+    "nudge-loop-breaker": "nudge-loop-breaker";
 }>, z.ZodPipe<z.ZodLiteral<"anthropic-context-window-limit-recovery">, z.ZodTransform<"context-window-limit-recovery", "anthropic-context-window-limit-recovery">>]>;
 export type HookName = z.infer<typeof HookNameSchema>;

package/dist/config/schema/matrixx-config.d.ts

@@ -137,6 +137,8 @@ export declare const MatrixxConfigSchema: z.ZodObject<{
         "knowledge-hub-guard": "knowledge-hub-guard";
         "knowledge-hub-injector": "knowledge-hub-injector";
         "knowledge-hub-search-nudge": "knowledge-hub-search-nudge";
+        "dcp-nudge-sanitizer": "dcp-nudge-sanitizer";
+        "nudge-loop-breaker": "nudge-loop-breaker";
     }>, z.ZodPipe<z.ZodLiteral<"anthropic-context-window-limit-recovery">, z.ZodTransform<"context-window-limit-recovery", "anthropic-context-window-limit-recovery">>]>>>;
     disabled_commands: z.ZodOptional<z.ZodArray<z.ZodEnum<{
         "init-deep": "init-deep";
@@ -1581,6 +1583,8 @@ export declare const MatrixxConfigSchema: z.ZodObject<{
             compress: z.ZodOptional<z.ZodObject<{
                 maxContextLimit: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>>;
                 minContextLimit: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>>;
+                modelMaxLimits: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>>>;
+                modelMinLimits: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>>>;
                 nudgeFrequency: z.ZodOptional<z.ZodNumber>;
                 iterationNudgeThreshold: z.ZodOptional<z.ZodNumber>;
                 nudgeForce: z.ZodOptional<z.ZodEnum<{

package/dist/create-hooks.d.ts

@@ -21,6 +21,7 @@ export declare function createHooks(args: {
     todoContinuationEnforcer: ReturnType<typeof import("./hooks").createTodoContinuationEnforcer> | null;
     taskContinuationEnforcer: ReturnType<typeof import("./hooks").createTaskContinuationEnforcer> | null;
     unstableAgentBabysitter: ReturnType<typeof import("./plugin/unstable-agent-babysitter").createUnstableAgentBabysitter> | null;
+    nudgeLoopBreaker: ReturnType<typeof import("./hooks").createNudgeLoopBreakerHook> | null;
     backgroundNotificationHook: ReturnType<typeof import("./hooks").createBackgroundNotificationHook> | null;
     architectHook: ReturnType<typeof import("./hooks").createArchitectHook> | null;
     planPersister: ReturnType<typeof import("./hooks").createPlanPersister> | null;
@@ -32,6 +33,7 @@ export declare function createHooks(args: {
     knowledgeHubInjector: ReturnType<typeof import("./hooks").createKnowledgeHubInjectorHook> | null;
     envContextInjector: ReturnType<typeof import("./hooks").createEnvContextInjectorHook> | null;
     thinkingBlockValidator: ReturnType<typeof import("./hooks").createThinkingBlockValidatorHook> | null;
+    dcpNudgeSanitizer: ReturnType<typeof import("./hooks").createDcpNudgeSanitizerHook> | null;
     toolPairValidator: ReturnType<typeof import("./hooks").createToolPairValidatorHook> | null;
     designIntentPreserver: ReturnType<typeof import("./hooks").createDesignIntentPreserverHook> | null;
     backgroundTaskBlocker: ReturnType<typeof import("./hooks").createBackgroundTaskBlockerHook> | null;

package/dist/features/session-state/state.d.ts

@@ -28,3 +28,6 @@ export declare function setSessionAgent(sessionID: string, agent: string): void;
 export declare function updateSessionAgent(sessionID: string, agent: string): void;
 export declare function getSessionAgent(sessionID: string): string | undefined;
 export declare function clearSessionAgent(sessionID: string): void;
+export declare function setSessionModel(sessionID: string, model: string): void;
+export declare function getSessionModel(sessionID: string): string | undefined;
+export declare function clearSessionModel(sessionID: string): void;

package/dist/hooks/dcp-nudge-sanitizer/constants.d.ts

@@ -0,0 +1,2 @@
+export declare const NUDGE_MARKERS: RegExp[];
+export declare function normalizeNudgeText(text: string): string;

package/dist/hooks/dcp-nudge-sanitizer/hook.d.ts

@@ -0,0 +1,25 @@
+/**
+ * DCP Sticky-Nudge Sanitizer Hook
+ *
+ * Ordering constraint (do not "fix" by assuming otherwise):
+ * Matrixx registers `experimental.chat.messages.transform` BEFORE DCP (plugin
+ * index 0 vs 1), so this sanitizer runs before DCP injects this cycle's nudge.
+ * It therefore cleans PRIOR-cycle sticky nudge parts and caps accumulation at
+ * ~1 per cycle. It CANNOT suppress the nudge DCP injects later in the SAME
+ * cycle. Full same-cycle suppression requires the optional deploy step that
+ * reorders the `plugin` array so Matrixx runs after DCP.
+ */
+import type { Part } from "@opencode-ai/sdk";
+import type { PluginContext } from "../../plugin/types";
+interface MessageWithParts {
+    info: unknown;
+    parts: Part[];
+}
+type MessagesTransformHook = {
+    "experimental.chat.messages.transform"?: (input: Record<string, never>, output: {
+        messages: MessageWithParts[];
+    }) => Promise<void>;
+};
+export declare function sanitizeNudgeParts(messages: MessageWithParts[]): void;
+export declare function createDcpNudgeSanitizerHook(_ctx: PluginContext): MessagesTransformHook;
+export {};

package/dist/hooks/dcp-nudge-sanitizer/index.d.ts

@@ -0,0 +1 @@
+export { createDcpNudgeSanitizerHook } from "./hook";

package/dist/hooks/index.d.ts

@@ -12,6 +12,7 @@ export { createCompactionTodoPreserverHook } from "./compaction-todo-preserver";
 export { createContextModeEnforcerHook } from "./context-mode-enforcer";
 export { type ContextWindowLimitRecoveryOptions, type ContextWindowLimitRecoveryOptions as AnthropicContextWindowLimitRecoveryOptions, createContextWindowLimitRecoveryHook, createContextWindowLimitRecoveryHook as createAnthropicContextWindowLimitRecoveryHook } from "./context-window-limit-recovery";
 export { createContextWindowMonitorHook } from "./context-window-monitor";
+export { createDcpNudgeSanitizerHook } from "./dcp-nudge-sanitizer";
 export { createDelegateTaskRetryHook } from "./delegate-task-retry";
 export { createDesignIntentPreserverHook } from "./design-intent-preserver";
 export { createDirectoryAgentsInjectorHook } from "./directory-agents-injector";
@@ -35,6 +36,7 @@ export { createKnowledgeHubSearchNudgeHook } from "./knowledge-hub-search-nudge"
 export { createMatrixLoopHook, type MatrixLoopHook } from "./matrix-loop";
 export { createMouseNotepadHook } from "./mouse-notepad";
 export { createNonInteractiveEnvHook } from "./non-interactive-env";
+export { createNudgeLoopBreakerHook } from "./nudge-loop-breaker";
 export { createOracleMdOnlyHook } from "./oracle-md-only";
 export { createPlanPersister } from "./plan-persister";
 export { createPostReadInjectorHook } from "./post-read-injector";

package/dist/hooks/nudge-loop-breaker/constants.d.ts

@@ -0,0 +1,9 @@
+export declare const DEFAULT_LOOP_THRESHOLD = 3;
+export declare const DEFAULT_COOLDOWN_MS = 1000;
+export declare const MAX_BACKOFF_EXPONENT = 5;
+export declare const DSML_PATTERNS: RegExp[];
+export declare const SESSION_ID_KEYS: readonly ["sessionID", "sessionId", "session"];
+export declare const TEXT_KEYS: readonly ["text", "content", "message", "assistantText", "snapshot", "assistantMessageID"];
+export declare const TOOL_KEYS: readonly ["tool", "toolName", "name"];
+export declare const RESET_TOOL_NAMES: Set<string>;
+export declare const DETECT_EVENT_TYPES: Set<string>;

package/dist/hooks/nudge-loop-breaker/hook.d.ts

@@ -0,0 +1,18 @@
+import type { PluginContext } from "../../plugin/types";
+export interface NudgeLoopBreakerOptions {
+    threshold?: number;
+    cooldownMs?: number;
+    now?: () => number;
+    onCorrective?: (sessionID: string, backoff: number) => void;
+}
+type EventInput = {
+    event: {
+        type: string;
+        properties?: unknown;
+    };
+};
+export type NudgeLoopBreakerHook = {
+    event: (input: EventInput) => Promise<void>;
+};
+export declare function createNudgeLoopBreakerHook(ctx: PluginContext, options?: NudgeLoopBreakerOptions): NudgeLoopBreakerHook;
+export {};

package/dist/hooks/nudge-loop-breaker/index.d.ts

@@ -0,0 +1 @@
+export { createNudgeLoopBreakerHook } from "./hook";

package/dist/hooks/nudge-loop-breaker/session-state.d.ts

@@ -0,0 +1,11 @@
+export interface NudgeLoopState {
+    count: number;
+    lastHash: string | null;
+    lastAt: number;
+    lastEmitAt: number;
+    correctiveSent: boolean;
+}
+export declare function createNudgeLoopState(): NudgeLoopState;
+export declare function computeBackoffDelay(count: number, threshold?: number): number;
+export declare function hashText(text: string): string;
+export declare function normalizeNudgeText(text: string): string;

package/dist/index.js

@@ -45073,9 +45073,13 @@ import { homedir as homedir3 } from "os";
 import { join as join6 } from "path";
 
 // src/config/schema/dcp.ts
+var dcpLimitValue = exports_external.union([exports_external.number(), exports_external.string().regex(/^\d+%$/)]);
+var dcpModelLimitKey = exports_external.string().regex(/^[^/]+\/[^/]+$/);
 var DcpCompressOverrideSchema = exports_external.object({
   maxContextLimit: exports_external.union([exports_external.number(), exports_external.string().regex(/^\d+%$/)]).optional(),
   minContextLimit: exports_external.union([exports_external.number(), exports_external.string().regex(/^\d+%$/)]).optional(),
+  modelMaxLimits: exports_external.record(dcpModelLimitKey, dcpLimitValue).optional(),
+  modelMinLimits: exports_external.record(dcpModelLimitKey, dcpLimitValue).optional(),
   nudgeFrequency: exports_external.number().int().min(1).optional(),
   iterationNudgeThreshold: exports_external.number().int().min(1).optional(),
   nudgeForce: exports_external.enum(["strong", "soft"]).optional(),
@@ -45161,9 +45165,11 @@ var BUILTIN_DCP_PROFILES = {
     compress: {
       maxContextLimit: "20%",
       minContextLimit: "10%",
-      nudgeFrequency: 1,
-      nudgeForce: "strong",
-      iterationNudgeThreshold: 1
+      nudgeFrequency: 3,
+      nudgeForce: "soft",
+      iterationNudgeThreshold: 6,
+      modelMaxLimits: { "deepseek/deepseek-v4.1-flash": "95%" },
+      modelMinLimits: { "deepseek/deepseek-v4.1-flash": "90%" }
     },
     turnProtection: { enabled: false },
     experimental: { allowSubAgents: false },
@@ -45342,7 +45348,9 @@ function buildInlineConfig(profile, options) {
       nudgeForce: profileCompress.nudgeForce ?? compressBase.nudgeForce ?? "strong",
       protectedTools: profileCompress.protectedTools ?? compressBase.protectedTools ?? [],
       protectTags: profileCompress.protectTags ?? false,
-      protectUserMessages: profileCompress.protectUserMessages ?? compressBase.protectUserMessages ?? false
+      protectUserMessages: profileCompress.protectUserMessages ?? compressBase.protectUserMessages ?? false,
+      modelMaxLimits: profileCompress.modelMaxLimits ?? compressBase.modelMaxLimits,
+      modelMinLimits: profileCompress.modelMinLimits ?? compressBase.modelMinLimits
     },
     turnProtection: {
       enabled: profileTurn.enabled ?? true,
@@ -49226,6 +49234,7 @@ function isMainSessionCandidate(sessionInfo) {
   });
 }
 var sessionAgentMap = new Map;
+var sessionModelMap = new Map;
 function setSessionAgent(sessionID, agent) {
   if (!sessionAgentMap.has(sessionID)) {
     sessionAgentMap.set(sessionID, agent);
@@ -49240,6 +49249,9 @@ function getSessionAgent(sessionID) {
 function clearSessionAgent(sessionID) {
   sessionAgentMap.delete(sessionID);
 }
+function setSessionModel(sessionID, model) {
+  sessionModelMap.set(sessionID, model);
+}
 // src/hooks/architect/event-handler.ts
 init_logger();
 
@@ -55293,6 +55305,55 @@ ${CONTEXT_REMINDER}
     event: eventHandler
   };
 }
+// src/hooks/dcp-nudge-sanitizer/constants.ts
+var NUDGE_MARKERS = [
+  /<instruction\s+name=iteration_nudge>/i,
+  /compressed block context:/i,
+  /\(b\d+\)/
+];
+function normalizeNudgeText(text) {
+  return text.replace(/\s+/g, " ").trim();
+}
+
+// src/hooks/dcp-nudge-sanitizer/hook.ts
+function getTextPart(part) {
+  const candidate = part;
+  if (candidate.type === "text" && typeof candidate.text === "string") {
+    return { text: candidate.text };
+  }
+  return null;
+}
+function isNudgeText(text) {
+  return NUDGE_MARKERS.some((marker) => marker.test(text));
+}
+function sanitizeNudgeParts(messages) {
+  let keptNudge = false;
+  for (const message of messages) {
+    if (!Array.isArray(message.parts))
+      continue;
+    for (let i = 0;i < message.parts.length; ) {
+      const textPart = getTextPart(message.parts[i]);
+      if (!textPart || !isNudgeText(textPart.text)) {
+        i++;
+        continue;
+      }
+      if (keptNudge) {
+        message.parts.splice(i, 1);
+        continue;
+      }
+      keptNudge = true;
+      message.parts[i].text = normalizeNudgeText(textPart.text);
+      i++;
+    }
+  }
+}
+function createDcpNudgeSanitizerHook(_ctx) {
+  return {
+    "experimental.chat.messages.transform": async (_input, output) => {
+      sanitizeNudgeParts(output.messages);
+    }
+  };
+}
 // src/hooks/delegate-task-retry/patterns.ts
 var DELEGATE_TASK_ERROR_PATTERNS = [
   {
@@ -61998,6 +62059,146 @@ function createNonInteractiveEnvHook(_ctx) {
     }
   };
 }
+// src/hooks/nudge-loop-breaker/hook.ts
+init_logger();
+
+// src/hooks/nudge-loop-breaker/constants.ts
+var DEFAULT_LOOP_THRESHOLD = 3;
+var DEFAULT_COOLDOWN_MS = 1000;
+var MAX_BACKOFF_EXPONENT = 5;
+var DSML_PATTERNS = [/\uFF5C/g];
+var SESSION_ID_KEYS = ["sessionID", "sessionId", "session"];
+var TEXT_KEYS = [
+  "text",
+  "content",
+  "message",
+  "assistantText",
+  "snapshot",
+  "assistantMessageID"
+];
+var TOOL_KEYS = ["tool", "toolName", "name"];
+var RESET_TOOL_NAMES = new Set(["compress"]);
+var DETECT_EVENT_TYPES = new Set(["session.next.step.ended", "session.next.step.failed"]);
+
+// src/hooks/nudge-loop-breaker/session-state.ts
+function createNudgeLoopState() {
+  return { count: 0, lastHash: null, lastAt: 0, lastEmitAt: 0, correctiveSent: false };
+}
+function computeBackoffDelay(count, threshold = DEFAULT_LOOP_THRESHOLD) {
+  if (count < threshold)
+    return 0;
+  return 2 ** Math.min(count - threshold, MAX_BACKOFF_EXPONENT);
+}
+function hashText(text) {
+  let hash2 = 2166136261;
+  for (let i = 0;i < text.length; i++) {
+    hash2 ^= text.charCodeAt(i);
+    hash2 = Math.imul(hash2, 16777619);
+  }
+  return (hash2 >>> 0).toString(16);
+}
+function normalizeNudgeText2(text) {
+  let normalized = text;
+  for (const pattern of DSML_PATTERNS) {
+    normalized = normalized.replace(pattern, "");
+  }
+  return normalized.replace(/\s+/g, " ").trim();
+}
+
+// src/hooks/nudge-loop-breaker/hook.ts
+function asRecord(value) {
+  if (typeof value === "object" && value !== null && !Array.isArray(value)) {
+    return value;
+  }
+  return {};
+}
+function readString(props, keys) {
+  for (const key of keys) {
+    const value = props[key];
+    if (typeof value === "string" && value.length > 0)
+      return value;
+  }
+  return;
+}
+function isResetEvent(type, props) {
+  if (type === "message.updated" || type === "session.message.updated") {
+    return asRecord(props.info).role === "user";
+  }
+  if (type === "session.next.step.started") {
+    return props.role === "user";
+  }
+  if (type === "session.next.tool.success") {
+    const tool = readString(props, TOOL_KEYS);
+    return tool !== undefined && RESET_TOOL_NAMES.has(tool);
+  }
+  return false;
+}
+function createNudgeLoopBreakerHook(ctx, options = {}) {
+  const threshold = options.threshold ?? DEFAULT_LOOP_THRESHOLD;
+  const cooldownMs = options.cooldownMs ?? DEFAULT_COOLDOWN_MS;
+  const now = options.now ?? (() => Date.now());
+  const onCorrective = options.onCorrective;
+  const sessions = new Map;
+  const sendCorrective = (sessionID, state3, backoff) => {
+    log("[nudge-loop-breaker] Repeated nudge detected", { sessionID, backoff });
+    onCorrective?.(sessionID, backoff);
+    if (state3.correctiveSent || sessionID === "unknown")
+      return;
+    const prompt = ctx.client?.session?.prompt;
+    if (typeof prompt !== "function")
+      return;
+    state3.correctiveSent = true;
+    prompt({
+      path: { id: sessionID },
+      body: {
+        parts: [
+          {
+            type: "text",
+            text: "Repetition detected: stop echoing the prune/compress nudge. Continue the task or run the compress tool with real message IDs."
+          }
+        ]
+      },
+      query: { directory: ctx.directory }
+    }).catch((error51) => {
+      log("[nudge-loop-breaker] corrective prompt failed", { error: error51 });
+    });
+  };
+  return {
+    event: async ({ event }) => {
+      const props = asRecord(event.properties);
+      const sessionID = readString(props, SESSION_ID_KEYS) ?? "unknown";
+      const state3 = sessions.get(sessionID) ?? createNudgeLoopState();
+      sessions.set(sessionID, state3);
+      if (isResetEvent(event.type, props)) {
+        state3.count = 0;
+        state3.lastHash = null;
+        state3.lastAt = 0;
+        state3.lastEmitAt = 0;
+        state3.correctiveSent = false;
+        return;
+      }
+      if (!DETECT_EVENT_TYPES.has(event.type))
+        return;
+      const text = readString(props, TEXT_KEYS);
+      if (!text)
+        return;
+      const hash2 = hashText(normalizeNudgeText2(text));
+      if (hash2 === state3.lastHash) {
+        state3.count += 1;
+      } else {
+        state3.count = 1;
+        state3.lastHash = hash2;
+      }
+      state3.lastAt = now();
+      if (state3.count < threshold)
+        return;
+      if (now() - state3.lastEmitAt < cooldownMs)
+        return;
+      state3.lastEmitAt = now();
+      sendCorrective(sessionID, state3, computeBackoffDelay(state3.count, threshold));
+    }
+  };
+}
 // src/hooks/oracle-md-only/constants.ts
 var HOOK_NAME12 = "oracle-md-only";
 var ORACLE_AGENT = "oracle";
@@ -63630,7 +63831,7 @@ async function resizeImage(base64DataUrl, mimeType, target, deps = {}) {
 // src/hooks/read-image-resizer/hook.ts
 var SUPPORTED_IMAGE_MIMES = new Set(["image/png", "image/jpeg", "image/gif", "image/webp"]);
 var TOKEN_DIVISOR = 750;
-function asRecord(value) {
+function asRecord2(value) {
   if (!value || typeof value !== "object" || Array.isArray(value)) {
     return null;
   }
@@ -63647,7 +63848,7 @@ function extractImageAttachments(output) {
   }
   const attachments = [];
   for (const attachmentValue of attachmentsValue) {
-    const attachmentRecord = asRecord(attachmentValue);
+    const attachmentRecord = asRecord2(attachmentValue);
     if (!attachmentRecord) {
       continue;
     }
@@ -69227,6 +69428,7 @@ function createContinuationHooks(args) {
     return enforcer;
   }) : null;
   const unstableAgentBabysitter = isHookEnabled("unstable-agent-babysitter") ? safeHook("unstable-agent-babysitter", () => createUnstableAgentBabysitter({ ctx, backgroundManager, pluginConfig })) : null;
+  const nudgeLoopBreaker = isHookEnabled("nudge-loop-breaker") ? safeHook("nudge-loop-breaker", () => createNudgeLoopBreakerHook(ctx)) : null;
   if (sessionRecovery) {
     const onAbortCallbacks = [];
     const onRecoveryCompleteCallbacks = [];
@@ -69268,6 +69470,7 @@ function createContinuationHooks(args) {
     todoContinuationEnforcer,
     taskContinuationEnforcer,
     unstableAgentBabysitter,
+    nudgeLoopBreaker,
     backgroundNotificationHook,
     architectHook,
     planPersister,
@@ -95983,6 +96186,7 @@ function createTransformHooks(args) {
   const envContextInjector = isHookEnabled("env-context-injector") ? safeCreateHook("env-context-injector", () => createEnvContextInjectorHook(), { enabled: safeHookEnabled }) : null;
   const thinkingBlockValidator = isHookEnabled("thinking-block-validator") ? safeCreateHook("thinking-block-validator", () => createThinkingBlockValidatorHook(), { enabled: safeHookEnabled }) : null;
   const toolPairValidator = isHookEnabled("tool-pair-validator") ? safeCreateHook("tool-pair-validator", () => createToolPairValidatorHook(), { enabled: safeHookEnabled }) : null;
+  const dcpNudgeSanitizer = isHookEnabled("dcp-nudge-sanitizer") ? safeCreateHook("dcp-nudge-sanitizer", () => createDcpNudgeSanitizerHook(ctx), { enabled: safeHookEnabled }) : null;
   const designIntentPreserver = isHookEnabled("design-intent-preserver") ? safeCreateHook("design-intent-preserver", () => createDesignIntentPreserverHook(ctx), { enabled: safeHookEnabled }) : null;
   return {
     inputSecretGuard,
@@ -95991,6 +96195,7 @@ function createTransformHooks(args) {
     knowledgeHubInjector,
     envContextInjector,
     thinkingBlockValidator,
+    dcpNudgeSanitizer,
     toolPairValidator,
     designIntentPreserver
   };
@@ -99538,6 +99743,36 @@ function resolveDcpCompressionMode() {
 
 // src/agents/dynamic-agent-prompt-builder.ts
 init_logger();
+
+// src/agents/model-directives.ts
+var FAMILY_DIRECTIVES = {
+  deepseek: {
+    antiEcho: "Never echo injected instruction blocks verbatim. Never emit DSML/tool-call closing tags as plain text.",
+    nudgeHandling: "If a context-compression nudge appears, call the compress tool once instead of restating the nudge."
+  }
+};
+function resolveModelFamily(modelID) {
+  if (!modelID)
+    return;
+  if (isDeepSeekModel(modelID))
+    return "deepseek";
+  return;
+}
+function getModelDirectives(modelID) {
+  const family = resolveModelFamily(modelID);
+  return family ? FAMILY_DIRECTIVES[family] ?? {} : {};
+}
+function appendModelDirective(section2, modelID) {
+  const directives = getModelDirectives(modelID);
+  const text = [directives.antiEcho, directives.nudgeHandling].filter(Boolean).join(" ");
+  if (!text)
+    return section2;
+  return `${section2}
+
+${text}`;
+}
+
+// src/agents/dynamic-agent-prompt-builder.ts
 function categorizeTools(toolNames) {
   return toolNames.map((name) => {
     let category = "other";
@@ -99954,40 +100189,40 @@ function readDisciplineFile() {
 <!-- discipline v${version4} Elastic-2.0 -->`;
   return { text, version: version4, path: p };
 }
-function loadDiscipline(kind, hasGrepGlob = true, dcpMode = resolveDcpCompressionMode()) {
+function loadDiscipline(kind, hasGrepGlob = true, dcpMode = resolveDcpCompressionMode(), modelID) {
   const fallbackKey = `${hasGrepGlob ? "1" : "0"}:${dcpMode}`;
   const runtimeCache = kind === "full" ? cachedRuntimeFull : cachedRuntimeCompact;
   const fallbackCache = kind === "full" ? cachedFallbackFull : cachedFallbackCompact;
   const label = kind === "full" ? "context-discipline" : "compact-discipline";
   if (runtimeCache[fallbackKey])
-    return runtimeCache[fallbackKey];
+    return appendModelDirective(runtimeCache[fallbackKey], modelID);
   if (fallbackCache[fallbackKey])
-    return fallbackCache[fallbackKey];
+    return appendModelDirective(fallbackCache[fallbackKey], modelID);
   try {
     const { text, version: version4, path: path27 } = readDisciplineFile();
     runtimeCache[fallbackKey] = text;
     log(`${label} loaded`, { path: path27, version: version4 });
-    return text;
+    return appendModelDirective(text, modelID);
   } catch (e) {
     log(`${label} fallback`, { error: String(e) });
     const fallback = kind === "full" ? fallbackFullDiscipline(hasGrepGlob, dcpMode) : fallbackCompactDiscipline(hasGrepGlob, dcpMode);
     fallbackCache[fallbackKey] = fallback;
-    return fallback;
+    return appendModelDirective(fallback, modelID);
   }
 }
-function loadContextModeDiscipline(hasGrepGlob = true, dcpMode = resolveDcpCompressionMode()) {
-  return loadDiscipline("full", hasGrepGlob, dcpMode);
+function loadContextModeDiscipline(hasGrepGlob = true, dcpMode = resolveDcpCompressionMode(), modelID) {
+  return loadDiscipline("full", hasGrepGlob, dcpMode, modelID);
 }
-function buildContextDisciplineSection(hasContextMode = false, hasGrepGlob = true, dcpMode = resolveDcpCompressionMode()) {
+function buildContextDisciplineSection(hasContextMode = false, hasGrepGlob = true, dcpMode = resolveDcpCompressionMode(), modelID) {
   if (!hasContextMode)
     return "";
-  return loadContextModeDiscipline(hasGrepGlob, dcpMode);
+  return loadContextModeDiscipline(hasGrepGlob, dcpMode, modelID);
 }
-function buildHeadroomSection(hasHeadroom = false, dcpMode = resolveDcpCompressionMode()) {
+function buildHeadroomSection(hasHeadroom = false, dcpMode = resolveDcpCompressionMode(), modelID) {
   if (!hasHeadroom)
     return "";
   const dcpClause = headroomDcpClause(dcpMode);
-  return `### Headroom Proxy Discipline (ALWAYS when headroom_* tools present)
+  return appendModelDirective(`### Headroom Proxy Discipline (ALWAYS when headroom_* tools present)
 
 | Scenario | Tool / Action |
 |----------|----------------|
@@ -99995,17 +100230,17 @@ function buildHeadroomSection(hasHeadroom = false, dcpMode = resolveDcpCompressi
 | Stats / diagnostics | headroom_stats or headroom dashboard |
 | Proxy not running | headroom doctor / check http://127.0.0.1:8787 (HEADROOM_PROXY_URL) |
 
-**Headroom L4 is transport-level (CacheAligner->ContentRouter->CCR). It complements L1 RTK, L2 context-mode, L3 DCP \u2014 do not duplicate their discipline. Compression ownership: the \`compress\` tool is DCP's \u2014 never call it bare without message IDs or invoke /dcp-compress; proactive on closed sections with IDs + headroom/ctx_stats signals.${dcpClause}**`;
+**Headroom L4 is transport-level (CacheAligner->ContentRouter->CCR). It complements L1 RTK, L2 context-mode, L3 DCP \u2014 do not duplicate their discipline. Compression ownership: the \`compress\` tool is DCP's \u2014 never call it bare without message IDs or invoke /dcp-compress; proactive on closed sections with IDs + headroom/ctx_stats signals.${dcpClause}**`, modelID);
 }
-function loadCompactContextDiscipline(hasGrepGlob = true, dcpMode = resolveDcpCompressionMode()) {
-  return loadDiscipline("compact", hasGrepGlob, dcpMode);
+function loadCompactContextDiscipline(hasGrepGlob = true, dcpMode = resolveDcpCompressionMode(), modelID) {
+  return loadDiscipline("compact", hasGrepGlob, dcpMode, modelID);
 }
-function buildCompactContextDisciplineSection(hasContextMode = false, hasGrepGlob = true, dcpMode = resolveDcpCompressionMode()) {
+function buildCompactContextDisciplineSection(hasContextMode = false, hasGrepGlob = true, dcpMode = resolveDcpCompressionMode(), modelID) {
   if (!hasContextMode)
     return "";
-  return loadCompactContextDiscipline(hasGrepGlob, dcpMode);
+  return loadCompactContextDiscipline(hasGrepGlob, dcpMode, modelID);
 }
-function buildExploreDisciplineSection(hasContextMode = false, hasHeadroom = false, hasGrepGlob = true) {
+function buildExploreDisciplineSection(hasContextMode = false, hasHeadroom = false, hasGrepGlob = true, modelID) {
   if (!hasContextMode && !hasHeadroom)
     return "";
   const parts = [];
@@ -100015,9 +100250,9 @@ function buildExploreDisciplineSection(hasContextMode = false, hasHeadroom = fal
   if (hasHeadroom) {
     parts.push("Use headroom_retrieve / headroom_search for compressed history \u2014 NEVER re-read full history.");
   }
-  return `### Context Discipline (when available)
+  return appendModelDirective(`### Context Discipline (when available)
 
-${parts.join(" ")}`;
+${parts.join(" ")}`, modelID);
 }
 
 // src/agents/architect/default.ts
@@ -101429,7 +101664,7 @@ function buildTodoDisciplineSection(useTaskSystem) {
 
 **NO TODOS ON MULTI-STEP WORK = INCOMPLETE WORK.**`;
 }
-function buildKeymakerPrompt(availableAgents = [], availableTools = [], availableSkills = [], availableCategories = [], useTaskSystem = false) {
+function buildKeymakerPrompt(availableAgents = [], availableTools = [], availableSkills = [], availableCategories = [], useTaskSystem = false, modelID) {
   const keyTriggers = buildKeyTriggersSection(availableAgents, availableSkills);
   const toolSelection = buildToolSelectionTable(availableAgents, availableTools, availableSkills);
   const exploreSection = buildExploreSection(availableAgents);
@@ -101441,9 +101676,9 @@ function buildKeymakerPrompt(availableAgents = [], availableTools = [], availabl
   const antiPatterns = buildAntiPatternsSection();
   const hasContextMode = availableTools.some((t) => t.name.startsWith("ctx_"));
   const hasGrepGlob = resolveGrepGlobUsable(availableTools.map((t) => t.name));
-  const contextDiscipline = buildContextDisciplineSection(hasContextMode, hasGrepGlob);
+  const contextDiscipline = buildContextDisciplineSection(hasContextMode, hasGrepGlob, undefined, modelID);
   const hasHeadroom = availableTools.some((t) => t.name.startsWith("headroom_"));
-  const headroomDiscipline = buildHeadroomSection(hasHeadroom);
+  const headroomDiscipline = buildHeadroomSection(hasHeadroom, undefined, modelID);
   const todoDiscipline = buildTodoDisciplineSection(useTaskSystem);
   return `You are Keymaker, an autonomous deep worker for software engineering.
 
@@ -101929,7 +102164,7 @@ function createKeymakerAgent(model, availableAgents, availableToolNames, availab
   const tools = availableToolNames ? categorizeTools(availableToolNames) : [];
   const skills = availableSkills ?? [];
   const categories = availableCategories ?? [];
-  const prompt = availableAgents ? buildKeymakerPrompt(availableAgents, tools, skills, categories, useTaskSystem) : buildKeymakerPrompt([], tools, skills, categories, useTaskSystem);
+  const prompt = availableAgents ? buildKeymakerPrompt(availableAgents, tools, skills, categories, useTaskSystem, model) : buildKeymakerPrompt([], tools, skills, categories, useTaskSystem, model);
   return {
     description: "Autonomous Deep Worker - goal-oriented execution with GPT 5.2 Codex. Explores thoroughly before acting, uses explore/librarian agents for comprehensive context, completes tasks end-to-end. Inspired by AmpCode deep mode. (Keymaker - Matrixx)",
     mode: MODE3,
@@ -102113,7 +102348,7 @@ Should I proceed with [recommendation], or would you prefer differently?
 \`\`\`
 </Task_Management>`;
 }
-function buildDynamicMorpheusPrompt(availableAgents, availableTools = [], availableSkills = [], availableCategories = [], useTaskSystem = false) {
+function buildDynamicMorpheusPrompt(availableAgents, availableTools = [], availableSkills = [], availableCategories = [], useTaskSystem = false, modelID) {
   const keyTriggers = buildKeyTriggersSection(availableAgents, availableSkills);
   const toolSelection = buildToolSelectionTable(availableAgents, availableTools, availableSkills);
   const exploreSection = buildExploreSection(availableAgents);
@@ -102126,9 +102361,9 @@ function buildDynamicMorpheusPrompt(availableAgents, availableTools = [], availa
   const antiPatterns = buildAntiPatternsSection();
   const hasContextMode = availableTools.some((t) => t.name.startsWith("ctx_"));
   const hasGrepGlob = resolveGrepGlobUsable(availableTools.map((t) => t.name));
-  const contextDiscipline = buildContextDisciplineSection(hasContextMode, hasGrepGlob);
+  const contextDiscipline = buildContextDisciplineSection(hasContextMode, hasGrepGlob, undefined, modelID);
   const hasHeadroom = availableTools.some((t) => t.name.startsWith("headroom_"));
-  const headroomDiscipline = buildHeadroomSection(hasHeadroom);
+  const headroomDiscipline = buildHeadroomSection(hasHeadroom, undefined, modelID);
   const taskManagementSection = buildTaskManagementSection(useTaskSystem);
   const todoHookNote = useTaskSystem ? "YOUR TASK CREATION WOULD BE TRACKED BY HOOK([SYSTEM REMINDER - TASK CONTINUATION])" : "YOUR TODO CREATION WOULD BE TRACKED BY HOOK([SYSTEM REMINDER - TODO CONTINUATION])";
   return `<Role>
@@ -102492,7 +102727,7 @@ function createMorpheusAgent(model, availableAgents, availableToolNames, availab
   const tools = availableToolNames ? categorizeTools(availableToolNames) : [];
   const skills = availableSkills ?? [];
   const categories = availableCategories ?? [];
-  const prompt = availableAgents ? buildDynamicMorpheusPrompt(availableAgents, tools, skills, categories, useTaskSystem) : buildDynamicMorpheusPrompt([], tools, skills, categories, useTaskSystem);
+  const prompt = availableAgents ? buildDynamicMorpheusPrompt(availableAgents, tools, skills, categories, useTaskSystem, model) : buildDynamicMorpheusPrompt([], tools, skills, categories, useTaskSystem, model);
   const permission = { question: "allow" };
   const base = {
     description: "Powerful AI orchestrator. Plans obsessively with todos, assesses search complexity before exploration, delegates strategically via category+skills combinations. Uses explore for internal code (parallel-friendly), librarian for external docs. (Morpheus - Matrixx)",
@@ -106120,12 +106355,13 @@ function injectContextDiscipline(availableToolNames, agents, contextMode) {
     if (cfg.prompt.includes("Context Discipline") || cfg.prompt.includes("context-mode \u2014 MANDATORY routing rules"))
       continue;
     const normalized = name.toLowerCase();
+    const modelID = typeof cfg.model === "string" ? cfg.model : undefined;
     let discipline = "";
     if (exploreAgents.has(normalized) || normalized === "oracle") {
-      discipline = buildExploreDisciplineSection(hasContextMode, hasHeadroom, hasGrepGlob);
+      discipline = buildExploreDisciplineSection(hasContextMode, hasHeadroom, hasGrepGlob, modelID);
     } else {
-      const compact = buildCompactContextDisciplineSection(hasContextMode, hasGrepGlob);
-      const headroom = buildHeadroomSection(hasHeadroom);
+      const compact = buildCompactContextDisciplineSection(hasContextMode, hasGrepGlob, undefined, modelID);
+      const headroom = buildHeadroomSection(hasHeadroom, undefined, modelID);
       discipline = [compact, headroom].filter(Boolean).join(`
 
 `);
@@ -107295,12 +107531,13 @@ var HookNameEnum = exports_external.enum([
   "evolution-compressor",
   "evolution-hitl",
   "context-mode-enforcer",
-  "context-mode-enforcer",
   "task-edit-guard",
   "document-reader-guard",
   "knowledge-hub-guard",
   "knowledge-hub-injector",
-  "knowledge-hub-search-nudge"
+  "knowledge-hub-search-nudge",
+  "dcp-nudge-sanitizer",
+  "nudge-loop-breaker"
 ]);
 var HookNameSchema = exports_external.union([
   HookNameEnum,
@@ -107847,6 +108084,9 @@ function createChatMessageHandler2(args) {
     if (input.agent) {
       setSessionAgent(input.sessionID, input.agent);
     }
+    if (input.model) {
+      setSessionModel(input.sessionID, `${input.model.providerID}/${input.model.modelID}`);
+    }
     const message = output.message;
     if (firstMessageVariantGate.shouldOverride(input.sessionID)) {
       if (message.variant === undefined) {
@@ -107963,6 +108203,7 @@ function createChatParamsHandler(args) {
       return;
     if (!isChatParamsOutput(output))
       return;
+    setSessionModel(normalizedInput.sessionID, `${normalizedInput.model.providerID}/${normalizedInput.model.modelID}`);
     await args.anthropicEffort?.["chat.params"]?.(normalizedInput, output);
     const categoryTemp = getSessionTemperature(normalizedInput.sessionID);
     if (categoryTemp !== undefined) {
@@ -108021,6 +108262,7 @@ function createEventHandler2(args) {
     await Promise.resolve(hooks2.todoContinuationEnforcer?.handler?.(input));
     await Promise.resolve(hooks2.taskContinuationEnforcer?.handler?.(input));
     await Promise.resolve(hooks2.unstableAgentBabysitter?.event?.(input));
+    await Promise.resolve(hooks2.nudgeLoopBreaker?.event?.(input));
     await Promise.resolve(hooks2.contextWindowMonitor?.event?.(input));
     await Promise.resolve(hooks2.directoryAgentsInjector?.event?.(input));
     await Promise.resolve(hooks2.rulesInjector?.event?.(input));
@@ -108138,6 +108380,7 @@ function createMessagesTransformHandler(args) {
     await args.hooks.envContextInjector?.["experimental.chat.messages.transform"]?.(input, output);
     await args.hooks.thinkingBlockValidator?.["experimental.chat.messages.transform"]?.(input, output);
     await args.hooks.evolutionHitl?.["experimental.chat.messages.transform"]?.(input, output);
+    await args.hooks.dcpNudgeSanitizer?.["experimental.chat.messages.transform"]?.(input, output);
     await args.hooks.toolPairValidator?.["experimental.chat.messages.transform"]?.(input, output);
   };
 }

package/dist/matrixx.schema.json

@@ -222,7 +222,9 @@
               "document-reader-guard",
               "knowledge-hub-guard",
               "knowledge-hub-injector",
-              "knowledge-hub-search-nudge"
+              "knowledge-hub-search-nudge",
+              "dcp-nudge-sanitizer",
+              "nudge-loop-breaker"
             ]
           },
           {}
@@ -4013,6 +4015,42 @@
                       }
                     ]
                   },
+                  "modelMaxLimits": {
+                    "type": "object",
+                    "propertyNames": {
+                      "type": "string",
+                      "pattern": "^[^/]+\\/[^/]+$"
+                    },
+                    "additionalProperties": {
+                      "anyOf": [
+                        {
+                          "type": "number"
+                        },
+                        {
+                          "type": "string",
+                          "pattern": "^\\d+%$"
+                        }
+                      ]
+                    }
+                  },
+                  "modelMinLimits": {
+                    "type": "object",
+                    "propertyNames": {
+                      "type": "string",
+                      "pattern": "^[^/]+\\/[^/]+$"
+                    },
+                    "additionalProperties": {
+                      "anyOf": [
+                        {
+                          "type": "number"
+                        },
+                        {
+                          "type": "string",
+                          "pattern": "^\\d+%$"
+                        }
+                      ]
+                    }
+                  },
                   "nudgeFrequency": {
                     "type": "integer",
                     "minimum": 1,

package/dist/plugin/hooks/create-continuation-hooks.d.ts

@@ -1,6 +1,6 @@
 import type { HookName, MatrixxConfig } from "../../config";
 import type { BackgroundManager } from "../../features/background-agent";
-import { createArchitectHook, createBackgroundNotificationHook, createCompactionContextInjector, createCompactionTodoPreserverHook, createEvolutionCompressorHook, createEvolutionHitlHook, createPlanPersister, createStopContinuationGuardHook, createTaskContinuationEnforcer, createTodoContinuationEnforcer } from "../../hooks";
+import { createArchitectHook, createBackgroundNotificationHook, createCompactionContextInjector, createCompactionTodoPreserverHook, createEvolutionCompressorHook, createEvolutionHitlHook, createNudgeLoopBreakerHook, createPlanPersister, createStopContinuationGuardHook, createTaskContinuationEnforcer, createTodoContinuationEnforcer } from "../../hooks";
 import type { PluginContext } from "../types";
 import { createUnstableAgentBabysitter } from "../unstable-agent-babysitter";
 export type ContinuationHooks = {
@@ -10,6 +10,7 @@ export type ContinuationHooks = {
     todoContinuationEnforcer: ReturnType<typeof createTodoContinuationEnforcer> | null;
     taskContinuationEnforcer: ReturnType<typeof createTaskContinuationEnforcer> | null;
     unstableAgentBabysitter: ReturnType<typeof createUnstableAgentBabysitter> | null;
+    nudgeLoopBreaker: ReturnType<typeof createNudgeLoopBreakerHook> | null;
     backgroundNotificationHook: ReturnType<typeof createBackgroundNotificationHook> | null;
     architectHook: ReturnType<typeof createArchitectHook> | null;
     planPersister: ReturnType<typeof createPlanPersister> | null;

package/dist/plugin/hooks/create-core-hooks.d.ts

@@ -12,6 +12,7 @@ export declare function createCoreHooks(args: {
     knowledgeHubInjector: ReturnType<typeof import("../../hooks").createKnowledgeHubInjectorHook> | null;
     envContextInjector: ReturnType<typeof import("../../hooks").createEnvContextInjectorHook> | null;
     thinkingBlockValidator: ReturnType<typeof import("../../hooks").createThinkingBlockValidatorHook> | null;
+    dcpNudgeSanitizer: ReturnType<typeof import("../../hooks").createDcpNudgeSanitizerHook> | null;
     toolPairValidator: ReturnType<typeof import("../../hooks").createToolPairValidatorHook> | null;
     designIntentPreserver: ReturnType<typeof import("../../hooks").createDesignIntentPreserverHook> | null;
     backgroundTaskBlocker: ReturnType<typeof import("../../hooks").createBackgroundTaskBlockerHook> | null;

package/dist/plugin/hooks/create-transform-hooks.d.ts

@@ -1,6 +1,7 @@
 import type { MatrixxConfig } from "../../config";
 import { createContextInjectorMessagesTransformHook } from "../../features/context-injector";
 import { createDesignIntentPreserverHook, createEnvContextInjectorHook, createKeywordDetectorHook, createKnowledgeHubInjectorHook, createThinkingBlockValidatorHook, createToolPairValidatorHook } from "../../hooks";
+import { createDcpNudgeSanitizerHook } from "../../hooks/dcp-nudge-sanitizer";
 import { createInputSecretGuardHook } from "../../hooks/input-secret-guard";
 import type { PluginContext } from "../types";
 export type TransformHooks = {
@@ -10,6 +11,7 @@ export type TransformHooks = {
     knowledgeHubInjector: ReturnType<typeof createKnowledgeHubInjectorHook> | null;
     envContextInjector: ReturnType<typeof createEnvContextInjectorHook> | null;
     thinkingBlockValidator: ReturnType<typeof createThinkingBlockValidatorHook> | null;
+    dcpNudgeSanitizer: ReturnType<typeof createDcpNudgeSanitizerHook> | null;
     toolPairValidator: ReturnType<typeof createToolPairValidatorHook> | null;
     designIntentPreserver: ReturnType<typeof createDesignIntentPreserverHook> | null;
 };

package/dist/shared/dcp-switch-profile.d.ts

@@ -5,6 +5,18 @@ export interface DcpSwitchProfileOptions {
     };
 }
 export declare function deepMergeProfile(builtin: Record<string, unknown>, override: Record<string, unknown>): Record<string, unknown>;
+/**
+ * Build a full inline DCP PluginConfig object for the given profile.
+ * Starts with base values from dcpConfig.base, overlays profile-specific
+ * values from dcpConfig.profiles[profile], and falls back to built-in
+ * profile definitions when no Matrixx config is provided.
+ *
+ * NOTE: DCP also supports per-model context limits via modelMaxLimits
+ * and modelMinLimits in the compress section. These allow fine-grained
+ * control per LLM provider/model (e.g., {"anthropic/claude-sonnet-4-20250514": "80%"}).
+ * Exposed via DcpCompressOverrideSchema and propagated below.
+ */
+export declare function buildInlineConfig(profile: string, options?: DcpSwitchProfileOptions): Record<string, unknown>;
 /**
  * Switch the active DCP profile.
  * Reads profile parameters from the Matrixx plugin configuration and writes

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-matrixx",
-  "version": "2.6.12",
+  "version": "2.6.13",
   "description": "The Best AI Agent Harness - Batteries-Included OpenCode Plugin with Multi-Model Orchestration, Parallel Background Agents, and Crafted LSP/AST Tools",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/dist/cli/setup/config-writer.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/cli/setup/deps.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/cli/setup/index.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/cli/setup/opencode-sync.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/cli/setup/prompts.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/features/background-agent/handle-index.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/features/background-agent/manager-handles.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/features/knowledge-hub/loader.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/features/knowledge-hub/resolver.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/features/mission-state/plan-storage.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/features/mission-state/reconcile.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/features/session-state/state.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/hooks/input-secret-guard/detector.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/hooks/input-secret-guard/hook.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/hooks/input-secret-guard/redactor.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/hooks/input-secret-guard/session-allow-cache.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/hooks/interactive-bash-session/hook.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/hooks/knowledge-hub-guard/hook.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/hooks/knowledge-hub-injector/hook.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/hooks/knowledge-hub-search-nudge/hook.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/hooks/plan-persister/task-sync.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/hooks/rtk-bash-rewriter/hook.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/hooks/stop-continuation-guard/repro.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/hooks/task-continuation-enforcer/awaiting-user.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/hooks/task-continuation-enforcer/continuation-injection.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/hooks/task-continuation-enforcer/countdown.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/hooks/task-continuation-enforcer/idle-event.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/hooks/task-continuation-enforcer/staleness.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/hooks/task-continuation-enforcer/todo.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/hooks/task-continuation-enforcer/ulw-bootstrap.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/hooks/todo-continuation-enforcer/awaiting-user.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/hooks/todo-continuation-enforcer/countdown.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/hooks/todo-continuation-enforcer/idle-event.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/shared/format-bytes.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/shared/is-abort-error.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/shared/task-system-gating.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/shared/with-timeout.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/tools/delegate-task/poll-timeout-outcome.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/tools/delegate-task/prompt-builder.tdd.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/tools/delegate-task/sync-task.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/tools/delegate-task/tdd-enforcement.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/tools/delegate-task/timing.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/tools/evolution/query-actions.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/tools/evolution/tools.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/tools/github-search/result-formatter.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/tools/knowledge-hub-confirm/tools.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/tools/task/task-cleanup.test.d.ts

@@ -1 +0,0 @@
-export {};