opencode-swarm 6.14.11 → 6.14.12

package/dist/config/schema.d.ts

@@ -99,6 +99,7 @@ export declare const ContextBudgetConfigSchema: z.ZodObject<{
     critical_threshold: z.ZodDefault<z.ZodNumber>;
     model_limits: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodNumber>>;
     max_injection_tokens: z.ZodDefault<z.ZodNumber>;
+    tracked_agents: z.ZodDefault<z.ZodArray<z.ZodString>>;
     scoring: z.ZodOptional<z.ZodObject<{
         enabled: z.ZodDefault<z.ZodBoolean>;
         max_candidates: z.ZodDefault<z.ZodNumber>;
@@ -126,6 +127,12 @@ export declare const ContextBudgetConfigSchema: z.ZodObject<{
             json: z.ZodDefault<z.ZodNumber>;
         }, z.core.$strip>>;
     }, z.core.$strip>>;
+    enforce: z.ZodDefault<z.ZodBoolean>;
+    prune_target: z.ZodDefault<z.ZodNumber>;
+    preserve_last_n_turns: z.ZodDefault<z.ZodNumber>;
+    recent_window: z.ZodDefault<z.ZodNumber>;
+    enforce_on_agent_switch: z.ZodDefault<z.ZodBoolean>;
+    tool_output_mask_threshold: z.ZodDefault<z.ZodNumber>;
 }, z.core.$strip>;
 export type ContextBudgetConfig = z.infer<typeof ContextBudgetConfigSchema>;
 export declare const EvidenceConfigSchema: z.ZodObject<{
@@ -451,6 +458,7 @@ export declare const PluginConfigSchema: z.ZodObject<{
         critical_threshold: z.ZodDefault<z.ZodNumber>;
         model_limits: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodNumber>>;
         max_injection_tokens: z.ZodDefault<z.ZodNumber>;
+        tracked_agents: z.ZodDefault<z.ZodArray<z.ZodString>>;
         scoring: z.ZodOptional<z.ZodObject<{
             enabled: z.ZodDefault<z.ZodBoolean>;
             max_candidates: z.ZodDefault<z.ZodNumber>;
@@ -478,6 +486,12 @@ export declare const PluginConfigSchema: z.ZodObject<{
                 json: z.ZodDefault<z.ZodNumber>;
             }, z.core.$strip>>;
         }, z.core.$strip>>;
+        enforce: z.ZodDefault<z.ZodBoolean>;
+        prune_target: z.ZodDefault<z.ZodNumber>;
+        preserve_last_n_turns: z.ZodDefault<z.ZodNumber>;
+        recent_window: z.ZodDefault<z.ZodNumber>;
+        enforce_on_agent_switch: z.ZodDefault<z.ZodBoolean>;
+        tool_output_mask_threshold: z.ZodDefault<z.ZodNumber>;
     }, z.core.$strip>>;
     guardrails: z.ZodOptional<z.ZodObject<{
         enabled: z.ZodDefault<z.ZodBoolean>;

package/dist/hooks/context-budget.d.ts

@@ -10,6 +10,9 @@ interface MessageInfo {
     role: string;
     agent?: string;
     sessionID?: string;
+    modelID?: string;
+    providerID?: string;
+    [key: string]: unknown;
 }
 interface MessagePart {
     type: string;

package/dist/hooks/index.d.ts

@@ -5,7 +5,9 @@ export { createDelegationGateHook } from './delegation-gate';
 export { createDelegationTrackerHook } from './delegation-tracker';
 export { extractCurrentPhase, extractCurrentPhaseFromPlan, extractCurrentTask, extractCurrentTaskFromPlan, extractDecisions, extractIncompleteTasks, extractIncompleteTasksFromPlan, extractPatterns, } from './extractors';
 export { createGuardrailsHooks } from './guardrails';
+export { classifyMessage, classifyMessages, containsPlanContent, isDuplicateToolRead, isStaleError, isToolResult, MessagePriority, type MessagePriorityType, type MessageWithParts, } from './message-priority';
 export { consolidateSystemMessages } from './messages-transform';
+export { extractModelInfo, NATIVE_MODEL_LIMITS, PROVIDER_CAPS, resolveModelLimit, } from './model-limits';
 export { createPhaseMonitorHook } from './phase-monitor';
 export { createPipelineTrackerHook } from './pipeline-tracker';
 export { createSystemEnhancerHook } from './system-enhancer';

package/dist/hooks/message-priority.d.ts

@@ -0,0 +1,105 @@
+/**
+ * Message Priority Classifier Hook
+ *
+ * Provides zero-cost message priority classification to enable intelligent
+ * context pruning. Messages are tagged with priority tiers (0-4) so that
+ * low-priority messages are removed first during context budget pressure.
+ *
+ * Priority tiers:
+ * - CRITICAL (0): System prompt, plan state, active instructions
+ * - HIGH (1): User messages, current task context, tool definitions
+ * - MEDIUM (2): Recent assistant responses, recent tool results
+ * - LOW (3): Old assistant responses, old tool results, confirmations
+ * - DISPOSABLE (4): Duplicate reads, superseded writes, stale errors
+ */
+/**
+ * Message priority tiers for context pruning decisions.
+ * Lower values = higher priority (kept longer during pruning).
+ */
+export declare const MessagePriority: {
+    /** System prompt, plan state, active instructions - never prune */
+    readonly CRITICAL: 0;
+    /** User messages, current task context, tool definitions */
+    readonly HIGH: 1;
+    /** Recent assistant responses, recent tool results (within recentWindowSize) */
+    readonly MEDIUM: 2;
+    /** Old assistant responses, old tool results */
+    readonly LOW: 3;
+    /** Duplicate reads, superseded writes, stale errors - prune first */
+    readonly DISPOSABLE: 4;
+};
+export type MessagePriorityType = (typeof MessagePriority)[keyof typeof MessagePriority];
+/** Message structure matching the format from context-budget.ts */
+interface MessageInfo {
+    role?: string;
+    agent?: string;
+    sessionID?: string;
+    modelID?: string;
+    providerID?: string;
+    toolName?: string;
+    toolArgs?: unknown;
+    [key: string]: unknown;
+}
+interface MessagePart {
+    type?: string;
+    text?: string;
+    [key: string]: unknown;
+}
+export interface MessageWithParts {
+    info?: MessageInfo;
+    parts?: MessagePart[];
+}
+/**
+ * Checks if text contains .swarm/plan or .swarm/context references
+ * indicating swarm state that should be preserved.
+ *
+ * @param text - The text content to check
+ * @returns true if the text contains plan/context references
+ */
+export declare function containsPlanContent(text: string): boolean;
+/**
+ * Checks if a message is a tool result (assistant message with tool call).
+ *
+ * @param message - The message to check
+ * @returns true if the message appears to be a tool result
+ */
+export declare function isToolResult(message: MessageWithParts): boolean;
+/**
+ * Checks if two consecutive tool read calls are duplicates
+ * (same tool with same first argument).
+ *
+ * @param current - The current message
+ * @param previous - The previous message
+ * @returns true if this is a duplicate tool read
+ */
+export declare function isDuplicateToolRead(current: MessageWithParts, previous: MessageWithParts): boolean;
+/**
+ * Checks if a message contains an error pattern and is stale
+ * (more than the specified number of turns old).
+ *
+ * @param text - The message text to check
+ * @param turnsAgo - How many turns ago the message was sent
+ * @returns true if the message is a stale error
+ */
+export declare function isStaleError(text: string, turnsAgo: number): boolean;
+/**
+ * Classifies a message by priority tier for intelligent pruning.
+ *
+ * @param message - The message to classify
+ * @param index - Position in messages array (0-indexed)
+ * @param totalMessages - Total number of messages
+ * @param recentWindowSize - Number of recent messages to consider MEDIUM (default 10)
+ * @returns Priority tier (0=CRITICAL, 1=HIGH, 2=MEDIUM, 3=LOW, 4=DISPOSABLE)
+ */
+export declare function classifyMessage(message: MessageWithParts, index: number, totalMessages: number, recentWindowSize?: number): MessagePriorityType;
+/**
+ * Classifies a batch of messages with duplicate detection.
+ * This function should be called in order (oldest to newest) to properly
+ * detect consecutive duplicate tool reads.
+ *
+ * @param messages - Array of messages to classify
+ * @param recentWindowSize - Number of recent messages to consider MEDIUM (default 10)
+ * @returns Array of priority classifications matching message order
+ */
+export declare function classifyMessages(messages: MessageWithParts[], recentWindowSize?: number): MessagePriorityType[];
+export {};

package/dist/hooks/model-limits.d.ts

@@ -0,0 +1,96 @@
+/**
+ * Provider-Aware Model Limit Resolution
+ *
+ * Resolves context window limits based on the model and provider platform.
+ * The same model has different context limits depending on the provider:
+ * - Claude Sonnet 4.6: 200k native, 128k on Copilot
+ * - GPT-5: 400k native, 128k on Copilot
+ * - Copilot caps ALL models at 128k prompt, regardless of native limit
+ */
+/**
+ * Native model context limits (in tokens) when used on their native platform.
+ */
+export declare const NATIVE_MODEL_LIMITS: Record<string, number>;
+/**
+ * Provider-specific context caps that override native limits.
+ * These are typically lower than native limits (e.g., Copilot caps at 128k).
+ */
+export declare const PROVIDER_CAPS: Record<string, number>;
+/**
+ * Message structure from experimental.chat.messages.transform hook.
+ */
+interface MessageInfo {
+    role: string;
+    agent?: string;
+    sessionID?: string;
+    modelID?: string;
+    providerID?: string;
+    [key: string]: unknown;
+}
+interface MessagePart {
+    type: string;
+    text?: string;
+    [key: string]: unknown;
+}
+interface MessageWithParts {
+    info: MessageInfo;
+    parts: MessagePart[];
+}
+/**
+ * Extracts modelID and providerID from the most recent assistant message.
+ *
+ * @param messages - Array of messages from experimental.chat.messages.transform hook
+ * @returns Object containing modelID and/or providerID if found
+ *
+ * @example
+ * const info = extractModelInfo(messages);
+ * // Returns: { modelID: 'claude-sonnet-4-6', providerID: 'anthropic' }
+ * // Or: {} if no assistant messages or fields not found
+ */
+export declare function extractModelInfo(messages: MessageWithParts[]): {
+    modelID?: string;
+    providerID?: string;
+};
+/**
+ * Resolves the context limit for a given model/provider combination.
+ *
+ * Resolution order (first match wins):
+ * 1. Check configOverrides["provider/model"] (e.g., "copilot/claude-sonnet-4-6": 200000)
+ * 2. Check configOverrides[modelID] (e.g., "claude-sonnet-4-6": 200000)
+ * 3. Check PROVIDER_CAPS[providerID] (e.g., copilot → 128000)
+ * 4. Check NATIVE_MODEL_LIMITS with prefix matching (e.g., "claude-sonnet-4" matches "claude-sonnet-4-6-20260301")
+ * 5. Check configOverrides.default
+ * 6. Fall back to 128000
+ *
+ * @param modelID - The model identifier (e.g., "claude-sonnet-4-6", "gpt-5")
+ * @param providerID - The provider identifier (e.g., "copilot", "anthropic")
+ * @param configOverrides - User configuration overrides
+ * @returns The resolved context limit in tokens
+ *
+ * @example
+ * // Provider cap (copilot)
+ * resolveModelLimit("claude-sonnet-4-6", "copilot", {})
+ * // Returns: 128000
+ *
+ * @example
+ * // Native limit (anthropic)
+ * resolveModelLimit("claude-sonnet-4-6", "anthropic", {})
+ * // Returns: 200000
+ *
+ * @example
+ * // Override beats cap
+ * resolveModelLimit("gpt-5", "copilot", { "copilot/gpt-5": 200000 })
+ * // Returns: 200000
+ *
+ * @example
+ * // Prefix match for model variants
+ * resolveModelLimit("claude-sonnet-4-6-20260301", "anthropic", {})
+ * // Returns: 200000
+ *
+ * @example
+ * // Full fallback
+ * resolveModelLimit(undefined, undefined, {})
+ * // Returns: 128000
+ */
+export declare function resolveModelLimit(modelID?: string, providerID?: string, configOverrides?: Record<string, number>): number;
+export {};

package/dist/index.js

@@ -14341,6 +14341,12 @@ function validateSwarmPath(directory, filename) {
   if (/\.\.[/\\]/.test(filename)) {
     throw new Error("Invalid filename: path traversal detected");
   }
+  if (/^[A-Za-z]:[\\/]/.test(filename)) {
+    throw new Error("Invalid filename: path escapes .swarm directory");
+  }
+  if (filename.startsWith("/")) {
+    throw new Error("Invalid filename: path escapes .swarm directory");
+  }
   const baseDir = path2.normalize(path2.resolve(directory, ".swarm"));
   const resolved = path2.normalize(path2.resolve(baseDir, filename));
   if (process.platform === "win32") {
@@ -31794,7 +31800,14 @@ var ContextBudgetConfigSchema = exports_external.object({
   critical_threshold: exports_external.number().min(0).max(1).default(0.9),
   model_limits: exports_external.record(exports_external.string(), exports_external.number().min(1000)).default({ default: 128000 }),
   max_injection_tokens: exports_external.number().min(100).max(50000).default(4000),
-  scoring: ScoringConfigSchema.optional()
+  tracked_agents: exports_external.array(exports_external.string()).default(["architect"]),
+  scoring: ScoringConfigSchema.optional(),
+  enforce: exports_external.boolean().default(true),
+  prune_target: exports_external.number().min(0).max(1).default(0.7),
+  preserve_last_n_turns: exports_external.number().min(0).max(100).default(4),
+  recent_window: exports_external.number().min(1).max(100).default(10),
+  enforce_on_agent_switch: exports_external.boolean().default(true),
+  tool_output_mask_threshold: exports_external.number().min(100).max(1e5).default(2000)
 });
 var EvidenceConfigSchema = exports_external.object({
   enabled: exports_external.boolean().default(true),
@@ -36698,8 +36711,232 @@ function createCompactionCustomizerHook(config3, directory) {
     })
   };
 }
+// src/hooks/context-budget.ts
+init_utils();
+
+// src/hooks/message-priority.ts
+var MessagePriority = {
+  CRITICAL: 0,
+  HIGH: 1,
+  MEDIUM: 2,
+  LOW: 3,
+  DISPOSABLE: 4
+};
+function containsPlanContent(text) {
+  if (!text)
+    return false;
+  const lowerText = text.toLowerCase();
+  return lowerText.includes(".swarm/plan") || lowerText.includes(".swarm/context") || lowerText.includes("swarm/plan.md") || lowerText.includes("swarm/context.md");
+}
+function isToolResult(message) {
+  if (!message?.info)
+    return false;
+  const role = message.info.role;
+  const toolName = message.info.toolName;
+  return role === "assistant" && !!toolName;
+}
+function isDuplicateToolRead(current, previous) {
+  if (!current?.info || !previous?.info)
+    return false;
+  const currentTool = current.info.toolName;
+  const previousTool = previous.info.toolName;
+  if (currentTool !== previousTool)
+    return false;
+  const isReadTool = currentTool?.toLowerCase().includes("read") && previousTool?.toLowerCase().includes("read");
+  if (!isReadTool)
+    return false;
+  const currentArgs = current.info.toolArgs;
+  const previousArgs = previous.info.toolArgs;
+  if (!currentArgs || !previousArgs)
+    return false;
+  const currentKeys = Object.keys(currentArgs);
+  const previousKeys = Object.keys(previousArgs);
+  if (currentKeys.length === 0 || previousKeys.length === 0)
+    return false;
+  const firstKey = currentKeys[0];
+  return currentArgs[firstKey] === previousArgs[firstKey];
+}
+function isStaleError(text, turnsAgo) {
+  if (!text)
+    return false;
+  if (turnsAgo <= 6)
+    return false;
+  const lowerText = text.toLowerCase();
+  const errorPatterns = [
+    "error:",
+    "failed to",
+    "could not",
+    "unable to",
+    "exception",
+    "errno",
+    "cannot read",
+    "not found",
+    "access denied",
+    "timeout"
+  ];
+  return errorPatterns.some((pattern) => lowerText.includes(pattern));
+}
+function extractMessageText(message) {
+  if (!message?.parts || message.parts.length === 0)
+    return "";
+  return message.parts.map((part) => part?.text || "").join("");
+}
+function classifyMessage(message, index, totalMessages, recentWindowSize = 10) {
+  const role = message?.info?.role;
+  const text = extractMessageText(message);
+  if (containsPlanContent(text)) {
+    return MessagePriority.CRITICAL;
+  }
+  if (role === "system") {
+    return MessagePriority.CRITICAL;
+  }
+  if (role === "user") {
+    return MessagePriority.HIGH;
+  }
+  if (isToolResult(message)) {
+    const positionFromEnd = totalMessages - 1 - index;
+    if (positionFromEnd < recentWindowSize) {
+      return MessagePriority.MEDIUM;
+    }
+    if (isStaleError(text, positionFromEnd)) {
+      return MessagePriority.DISPOSABLE;
+    }
+    return MessagePriority.LOW;
+  }
+  if (role === "assistant") {
+    const positionFromEnd = totalMessages - 1 - index;
+    if (positionFromEnd < recentWindowSize) {
+      return MessagePriority.MEDIUM;
+    }
+    if (isStaleError(text, positionFromEnd)) {
+      return MessagePriority.DISPOSABLE;
+    }
+    return MessagePriority.LOW;
+  }
+  return MessagePriority.LOW;
+}
+function classifyMessages(messages, recentWindowSize = 10) {
+  const results = [];
+  const totalMessages = messages.length;
+  for (let i2 = 0;i2 < messages.length; i2++) {
+    const message = messages[i2];
+    const priority = classifyMessage(message, i2, totalMessages, recentWindowSize);
+    if (i2 > 0) {
+      const current = messages[i2];
+      const previous = messages[i2 - 1];
+      if (isDuplicateToolRead(current, previous)) {
+        if (results[i2 - 1] >= MessagePriority.MEDIUM) {
+          results[i2 - 1] = MessagePriority.DISPOSABLE;
+        }
+      }
+    }
+    results.push(priority);
+  }
+  return results;
+}
+
+// src/hooks/model-limits.ts
+init_utils();
+var NATIVE_MODEL_LIMITS = {
+  "claude-sonnet-4": 200000,
+  "claude-opus-4": 200000,
+  "claude-haiku-4": 200000,
+  "gpt-5": 400000,
+  "gpt-5.1-codex": 400000,
+  "gpt-5.1": 264000,
+  "gpt-4.1": 1047576,
+  "gemini-2.5-pro": 1048576,
+  "gemini-2.5-flash": 1048576,
+  o3: 200000,
+  "o4-mini": 200000,
+  "deepseek-r1": 163840,
+  "deepseek-chat": 163840,
+  "qwen3.5": 131072
+};
+var PROVIDER_CAPS = {
+  copilot: 128000,
+  "github-copilot": 128000
+};
+function extractModelInfo(messages) {
+  if (!messages || messages.length === 0) {
+    return {};
+  }
+  for (let i2 = messages.length - 1;i2 >= 0; i2--) {
+    const message = messages[i2];
+    if (!message?.info)
+      continue;
+    if (message.info.role === "assistant") {
+      const modelID = message.info.modelID;
+      const providerID = message.info.providerID;
+      if (modelID || providerID) {
+        return {
+          ...modelID ? { modelID } : {},
+          ...providerID ? { providerID } : {}
+        };
+      }
+    }
+  }
+  return {};
+}
+var loggedFirstCalls = new Set;
+function resolveModelLimit(modelID, providerID, configOverrides = {}) {
+  const normalizedModelID = modelID ?? "";
+  const normalizedProviderID = providerID ?? "";
+  if (normalizedProviderID && normalizedModelID) {
+    const providerModelKey = `${normalizedProviderID}/${normalizedModelID}`;
+    if (configOverrides[providerModelKey] !== undefined) {
+      logFirstCall(normalizedModelID, normalizedProviderID, "override(provider/model)", configOverrides[providerModelKey]);
+      return configOverrides[providerModelKey];
+    }
+  }
+  if (normalizedModelID && configOverrides[normalizedModelID] !== undefined) {
+    logFirstCall(normalizedModelID, normalizedProviderID, "override(model)", configOverrides[normalizedModelID]);
+    return configOverrides[normalizedModelID];
+  }
+  if (normalizedProviderID && PROVIDER_CAPS[normalizedProviderID] !== undefined) {
+    const cap = PROVIDER_CAPS[normalizedProviderID];
+    logFirstCall(normalizedModelID, normalizedProviderID, "provider_cap", cap);
+    return cap;
+  }
+  if (normalizedModelID) {
+    const matchedLimit = findNativeLimit(normalizedModelID);
+    if (matchedLimit !== undefined) {
+      logFirstCall(normalizedModelID, normalizedProviderID, "native", matchedLimit);
+      return matchedLimit;
+    }
+  }
+  if (configOverrides.default !== undefined) {
+    logFirstCall(normalizedModelID, normalizedProviderID, "default_override", configOverrides.default);
+    return configOverrides.default;
+  }
+  logFirstCall(normalizedModelID, normalizedProviderID, "fallback", 128000);
+  return 128000;
+}
+function findNativeLimit(modelID) {
+  if (NATIVE_MODEL_LIMITS[modelID] !== undefined) {
+    return NATIVE_MODEL_LIMITS[modelID];
+  }
+  let bestMatch;
+  for (const key of Object.keys(NATIVE_MODEL_LIMITS)) {
+    if (modelID.startsWith(key)) {
+      if (!bestMatch || key.length > bestMatch.length) {
+        bestMatch = key;
+      }
+    }
+  }
+  return bestMatch ? NATIVE_MODEL_LIMITS[bestMatch] : undefined;
+}
+function logFirstCall(modelID, providerID, source, limit) {
+  const key = `${modelID || "unknown"}::${providerID || "unknown"}`;
+  if (!loggedFirstCalls.has(key)) {
+    loggedFirstCalls.add(key);
+    warn(`[model-limits] Resolved limit for ${modelID || "(no model)"}@${providerID || "(no provider)"}: ${limit} (source: ${source})`);
+  }
+}
+
 // src/hooks/context-budget.ts
 init_utils2();
+var lastSeenAgent;
 function createContextBudgetHandler(config3) {
   const enabled = config3.context_budget?.enabled !== false;
   if (!enabled) {
@@ -36707,14 +36944,19 @@ function createContextBudgetHandler(config3) {
   }
   const warnThreshold = config3.context_budget?.warn_threshold ?? 0.7;
   const criticalThreshold = config3.context_budget?.critical_threshold ?? 0.9;
-  const modelLimits = config3.context_budget?.model_limits ?? {
-    default: 128000
-  };
-  const modelLimit = modelLimits.default ?? 128000;
-  return async (_input, output) => {
+  const modelLimitsConfig = config3.context_budget?.model_limits ?? {};
+  const loggedLimits = new Set;
+  const handler = async (_input, output) => {
     const messages = output?.messages;
     if (!messages || messages.length === 0)
       return;
+    const { modelID, providerID } = extractModelInfo(messages);
+    const modelLimit = resolveModelLimit(modelID, providerID, modelLimitsConfig);
+    const cacheKey = `${modelID || "unknown"}::${providerID || "unknown"}`;
+    if (!loggedLimits.has(cacheKey)) {
+      loggedLimits.add(cacheKey);
+      warn(`[swarm] Context budget: model=${modelID || "unknown"} provider=${providerID || "unknown"} limit=${modelLimit}`);
+    }
     let totalTokens = 0;
     for (const message of messages) {
       if (!message?.parts)
@@ -36726,6 +36968,79 @@ function createContextBudgetHandler(config3) {
       }
     }
     const usagePercent = totalTokens / modelLimit;
+    let baseAgent;
+    for (let i2 = messages.length - 1;i2 >= 0; i2--) {
+      const msg = messages[i2];
+      if (msg?.info?.role === "user" && msg?.info?.agent) {
+        baseAgent = stripKnownSwarmPrefix(msg.info.agent);
+        break;
+      }
+    }
+    let ratio = usagePercent;
+    if (lastSeenAgent !== undefined && baseAgent !== undefined && baseAgent !== lastSeenAgent) {
+      const enforceOnSwitch = config3.context_budget?.enforce_on_agent_switch ?? true;
+      if (enforceOnSwitch && usagePercent > (config3.context_budget?.warn_threshold ?? 0.7)) {
+        warn(`[swarm] Agent switch detected: ${lastSeenAgent} \u2192 ${baseAgent}, enforcing context budget`, {
+          from: lastSeenAgent,
+          to: baseAgent
+        });
+        ratio = 1;
+      }
+    }
+    lastSeenAgent = baseAgent;
+    if (ratio >= criticalThreshold) {
+      const enforce = config3.context_budget?.enforce ?? true;
+      if (enforce) {
+        const targetTokens = modelLimit * (config3.context_budget?.prune_target ?? 0.7);
+        const recentWindow = config3.context_budget?.recent_window ?? 10;
+        const priorities = classifyMessages(output.messages || [], recentWindow);
+        const toolMaskThreshold = config3.context_budget?.tool_output_mask_threshold ?? 2000;
+        let toolMaskFreedTokens = 0;
+        const maskedIndices = new Set;
+        for (let i2 = 0;i2 < (output.messages || []).length; i2++) {
+          const msg = (output.messages || [])[i2];
+          if (shouldMaskToolOutput(msg, i2, (output.messages || []).length, recentWindow, toolMaskThreshold)) {
+            toolMaskFreedTokens += maskToolOutput(msg, toolMaskThreshold);
+            maskedIndices.add(i2);
+          }
+        }
+        if (toolMaskFreedTokens > 0) {
+          totalTokens -= toolMaskFreedTokens;
+          warn(`[swarm] Tool output masking: masked ${maskedIndices.size} tool results, freed ~${toolMaskFreedTokens} tokens`, {
+            maskedCount: maskedIndices.size,
+            freedTokens: toolMaskFreedTokens
+          });
+        }
+        const preserveLastNTurns = config3.context_budget?.preserve_last_n_turns ?? 4;
+        const removableMessages = identifyRemovableMessages(output.messages || [], priorities, preserveLastNTurns);
+        let freedTokens = 0;
+        const toRemove = new Set;
+        for (const idx of removableMessages) {
+          if (totalTokens - freedTokens <= targetTokens)
+            break;
+          toRemove.add(idx);
+          freedTokens += estimateTokens(extractMessageText2(output.messages[idx]));
+        }
+        const beforeTokens = totalTokens;
+        if (toRemove.size > 0) {
+          const actualFreedTokens = applyObservationMasking(output.messages || [], toRemove);
+          totalTokens -= actualFreedTokens;
+          warn(`[swarm] Context enforcement: pruned ${toRemove.size} messages, freed ${actualFreedTokens} tokens (${beforeTokens}\u2192${totalTokens} of ${modelLimit})`, {
+            pruned: toRemove.size,
+            freedTokens: actualFreedTokens,
+            before: beforeTokens,
+            after: totalTokens,
+            limit: modelLimit
+          });
+        } else if (removableMessages.length === 0 && totalTokens > targetTokens) {
+          warn(`[swarm] Context enforcement: no removable messages found but still ${totalTokens} tokens (target: ${targetTokens})`, {
+            currentTokens: totalTokens,
+            targetTokens,
+            limit: modelLimit
+          });
+        }
+      }
+    }
     let lastUserMessageIndex = -1;
     for (let i2 = messages.length - 1;i2 >= 0; i2--) {
       if (messages[i2]?.info?.role === "user") {
@@ -36738,8 +37053,10 @@ function createContextBudgetHandler(config3) {
     const lastUserMessage = messages[lastUserMessageIndex];
     if (!lastUserMessage?.parts)
       return;
-    const agent = lastUserMessage.info?.agent;
-    if (agent && agent !== "architect")
+    const trackedAgents = config3.context_budget?.tracked_agents ?? [
+      "architect"
+    ];
+    if (baseAgent && !trackedAgents.includes(baseAgent))
       return;
     const textPartIndex = lastUserMessage.parts.findIndex((p) => p?.type === "text" && p.text !== undefined);
     if (textPartIndex === -1)
@@ -36760,6 +37077,110 @@ function createContextBudgetHandler(config3) {
       lastUserMessage.parts[textPartIndex].text = `${warningText}${originalText}`;
     }
   };
+  return handler;
+}
+function identifyRemovableMessages(messages, priorities, preserveLastNTurns) {
+  let turnCount = 0;
+  const protectedIndices = new Set;
+  for (let i2 = messages.length - 1;i2 >= 0 && turnCount < preserveLastNTurns * 2; i2--) {
+    const role = messages[i2]?.info?.role;
+    if (role === "user" || role === "assistant") {
+      protectedIndices.add(i2);
+      if (role === "user")
+        turnCount++;
+    }
+  }
+  let lastUserIdx = -1;
+  let lastAssistantIdx = -1;
+  for (let i2 = messages.length - 1;i2 >= 0; i2--) {
+    const role = messages[i2]?.info?.role;
+    if (role === "user" && lastUserIdx === -1) {
+      lastUserIdx = i2;
+    }
+    if (role === "assistant" && lastAssistantIdx === -1) {
+      lastAssistantIdx = i2;
+    }
+    if (lastUserIdx !== -1 && lastAssistantIdx !== -1)
+      break;
+  }
+  if (lastUserIdx !== -1)
+    protectedIndices.add(lastUserIdx);
+  if (lastAssistantIdx !== -1)
+    protectedIndices.add(lastAssistantIdx);
+  const HIGH = MessagePriority.HIGH;
+  const MEDIUM = MessagePriority.MEDIUM;
+  const LOW = MessagePriority.LOW;
+  const DISPOSABLE = MessagePriority.DISPOSABLE;
+  const byPriority = [[], [], [], [], []];
+  for (let i2 = 0;i2 < priorities.length; i2++) {
+    const priority = priorities[i2];
+    if (!protectedIndices.has(i2) && priority > HIGH) {
+      byPriority[priority].push(i2);
+    }
+  }
+  return [...byPriority[DISPOSABLE], ...byPriority[LOW], ...byPriority[MEDIUM]];
+}
+function applyObservationMasking(messages, toRemove) {
+  let actualFreedTokens = 0;
+  for (const idx of toRemove) {
+    const msg = messages[idx];
+    if (msg?.parts) {
+      for (const part of msg.parts) {
+        if (part.type === "text" && part.text) {
+          const originalTokens = estimateTokens(part.text);
+          const placeholder = `[Context pruned \u2014 message from turn ${idx}, ~${originalTokens} tokens freed. Use retrieve_summary if needed.]`;
+          const maskedTokens = estimateTokens(placeholder);
+          part.text = placeholder;
+          actualFreedTokens += originalTokens - maskedTokens;
+        }
+      }
+    }
+  }
+  return actualFreedTokens;
+}
+function extractMessageText2(msg) {
+  if (!msg?.parts)
+    return "";
+  return msg.parts.filter((p) => p.type === "text" && p.text).map((p) => p.text).join(`
+`);
+}
+function extractToolName(text) {
+  const match = text.match(/^(read_file|write|edit|apply_patch|task|bun|npm|git|bash|glob|grep|mkdir|cp|mv|rm)\b/i);
+  return match?.[1];
+}
+function shouldMaskToolOutput(msg, index, totalMessages, recentWindowSize, threshold) {
+  if (!isToolResult(msg))
+    return false;
+  const text = extractMessageText2(msg);
+  if (text.includes("[Tool output masked") || text.includes("[Context pruned")) {
+    return false;
+  }
+  const toolName = extractToolName(text);
+  if (toolName && ["retrieve_summary", "task"].includes(toolName.toLowerCase())) {
+    return false;
+  }
+  const age = totalMessages - 1 - index;
+  return age > recentWindowSize || text.length > threshold;
+}
+function maskToolOutput(msg, threshold) {
+  if (!msg?.parts)
+    return 0;
+  let freedTokens = 0;
+  for (const part of msg.parts) {
+    if (part.type === "text" && part.text) {
+      if (part.text.includes("[Tool output masked") || part.text.includes("[Context pruned")) {
+        continue;
+      }
+      const originalTokens = estimateTokens(part.text);
+      const toolName = extractToolName(part.text) || "unknown";
+      const excerpt = part.text.substring(0, 200).replace(/\n/g, " ");
+      const placeholder = `[Tool output masked \u2014 ${toolName} returned ~${originalTokens} tokens. First 200 chars: "${excerpt}..." Use retrieve_summary if needed.]`;
+      const maskedTokens = estimateTokens(placeholder);
+      part.text = placeholder;
+      freedTokens += originalTokens - maskedTokens;
+    }
+  }
+  return freedTokens;
 }
 // src/hooks/delegation-gate.ts
 function extractTaskLine(text) {
@@ -36988,6 +37409,12 @@ function isSourceCodePath(filePath) {
   ];
   return !nonSourcePatterns.some((pattern) => pattern.test(normalized));
 }
+function hasTraversalSegments(filePath) {
+  if (!filePath)
+    return false;
+  const normalized = filePath.replace(/\\/g, "/");
+  return normalized.startsWith("..") || normalized.includes("/../") || normalized.endsWith("/..");
+}
 function isGateTool(toolName) {
   const normalized = toolName.replace(/^[^:]+[:.]/, "");
   const gateTools = [
@@ -37030,10 +37457,43 @@ function createGuardrailsHooks(config3) {
   const inputArgsByCallID = new Map;
   return {
     toolBefore: async (input, output) => {
-      if (isArchitect(input.sessionID) && isWriteTool(input.tool)) {
+      const currentSession = swarmState.agentSessions.get(input.sessionID);
+      if (currentSession?.delegationActive) {} else if (isArchitect(input.sessionID) && isWriteTool(input.tool)) {
         const args2 = output.args;
         const targetPath = args2?.filePath ?? args2?.path ?? args2?.file ?? args2?.target;
-        if (typeof targetPath === "string" && isOutsideSwarmDir(targetPath) && isSourceCodePath(targetPath)) {
+        if (!targetPath && (input.tool === "apply_patch" || input.tool === "patch")) {
+          const patchText = args2?.input ?? args2?.patch ?? (Array.isArray(args2?.cmd) ? args2.cmd[1] : undefined);
+          if (typeof patchText === "string") {
+            const patchPathPattern = /\*\*\*\s+(?:Update|Add|Delete)\s+File:\s*(.+)/gi;
+            const diffPathPattern = /\+\+\+\s+b\/(.+)/gm;
+            const paths = new Set;
+            let match;
+            while ((match = patchPathPattern.exec(patchText)) !== null) {
+              paths.add(match[1].trim());
+            }
+            while ((match = diffPathPattern.exec(patchText)) !== null) {
+              const p = match[1].trim();
+              if (p !== "/dev/null")
+                paths.add(p);
+            }
+            for (const p of paths) {
+              if (isOutsideSwarmDir(p) && (isSourceCodePath(p) || hasTraversalSegments(p))) {
+                const session2 = swarmState.agentSessions.get(input.sessionID);
+                if (session2) {
+                  session2.architectWriteCount++;
+                  warn("Architect direct code edit detected via apply_patch", {
+                    tool: input.tool,
+                    sessionID: input.sessionID,
+                    targetPath: p,
+                    writeCount: session2.architectWriteCount
+                  });
+                }
+                break;
+              }
+            }
+          }
+        }
+        if (typeof targetPath === "string" && isOutsideSwarmDir(targetPath) && (isSourceCodePath(targetPath) || hasTraversalSegments(targetPath))) {
           const session2 = swarmState.agentSessions.get(input.sessionID);
           if (session2) {
             session2.architectWriteCount++;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "opencode-swarm",
-	"version": "6.14.11",
+	"version": "6.14.12",
 	"description": "Architect-centric agentic swarm plugin for OpenCode - hub-and-spoke orchestration with SME consultation, code generation, and QA review",
 	"main": "dist/index.js",
 	"types": "dist/index.d.ts",