opencode-matrixx-v2 0.0.0-stage → 1.1.0

package/dist/plugin/tool-policy.d.ts

@@ -0,0 +1,67 @@
+/**
+ * Native tool policy for the OpenCode v2 layer.
+ *
+ * Pure, side-effect-free predicates decide which tools register; the host
+ * applies them through singular `ctx.tool.transform` (pure rewrites) and
+ * `ctx.permission` decisions. Optional shell environment shaping goes through
+ * `ctx.shell`. Singular namespaces only by design.
+ */
+/** Directories never descended into during the bounded startup scan. */
+export declare const TOOL_GATING_SKIP_DIRS: readonly string[];
+/** Maximum directory depth visited by the startup scan. */
+export declare const TOOL_GATING_MAX_DEPTH = 4;
+/** Maximum filesystem entries visited before the scan gives up. */
+export declare const TOOL_GATING_MAX_ENTRIES = 2000;
+/** File extensions that trigger look_at registration (lowercase, with leading dot). */
+export declare const LOOK_AT_MEDIA_EXTENSIONS: readonly string[];
+/** File extension that triggers BDD tool registration. */
+export declare const BDD_FILE_EXTENSION = ".feature";
+/** File extension that triggers pdf_extract_figures registration. */
+export declare const PDF_FILE_EXTENSION = ".pdf";
+/**
+ * Bounded sync scan: true when a file with one of the given extensions exists
+ * under the directory. Skips ignored dirs, caps depth and entries, exits early
+ * on the first match. Never throws — returns false on any filesystem error.
+ */
+export declare function directoryHasMatch(directory: string | undefined, extensions: readonly string[]): boolean;
+/** True unless the construct agent is listed in disabled_agents (case-insensitive). */
+export declare function isConstructAgentEnabled(disabledAgents: readonly string[] | undefined): boolean;
+/** BDD tools: explicit override wins, otherwise auto iff a *.feature file is found. */
+export declare function shouldEnableBddTools(directory: string | undefined, override: boolean | undefined): boolean;
+/** pdf_extract_figures: explicit override wins, otherwise auto iff a *.pdf file is found. */
+export declare function shouldEnablePdfFigures(directory: string | undefined, override: boolean | undefined): boolean;
+/**
+ * look_at: explicit true forces registration (bypasses both gates), explicit
+ * false forces skip, otherwise requires construct enabled AND a media file.
+ */
+export declare function shouldEnableLookAt(directory: string | undefined, constructEnabled: boolean, override: boolean | undefined): boolean;
+/** knowledge_hub_confirm: register iff at least one knowledge hub is configured. */
+export declare function shouldEnableKnowledgeHubConfirm(hubs: readonly unknown[] | undefined): boolean;
+/** preset: opt-in only, default false. */
+export declare function shouldEnablePresetTools(override: boolean | undefined): boolean;
+/** evolution tool: register iff evolution.enabled is true (default false). */
+export declare function shouldEnableEvolutionTool(enabled: boolean | undefined): boolean;
+/** session_cleanup: opt-in only, because the tool deletes sessions. */
+export declare function shouldEnableSessionCleanup(enabled: boolean | undefined): boolean;
+export type ToolPermissionEffect = "allow" | "deny" | "ask";
+export interface ToolPermissionDecision {
+    decision: ToolPermissionEffect;
+    reason: string;
+}
+export interface ToolPolicyOptions {
+    sessionCleanupEnabled: boolean;
+    presetEnabled: boolean;
+}
+/**
+ * Pure permission decision for natively gated tools. Never throws: unknown
+ * tools default to allow so a policy miss cannot crash a turn.
+ */
+export declare function decideToolPermission(toolName: string, options: ToolPolicyOptions): ToolPermissionDecision;
+export interface ToolEditorLike {
+    remove(id: string): void;
+}
+/**
+ * Pure `ctx.tool.transform` rewrite: drop disabled tools from the editor.
+ * Replayable: same input list always yields the same removals. Never throws.
+ */
+export declare function applyDisabledToolsTransform(editor: ToolEditorLike, disabledTools: readonly string[] | undefined): void;

package/dist/plugin/unstable-agent-babysitter.d.ts

@@ -0,0 +1,10 @@
+import type { MatrixxConfig } from "../config";
+import type { BackgroundManager } from "../features/background-agent";
+import type { NativePluginContext } from "../shared/session-context-source";
+export declare function createUnstableAgentBabysitter(args: {
+    ctx: NativePluginContext;
+    backgroundManager: BackgroundManager;
+    pluginConfig: MatrixxConfig;
+}): {
+    event: (event: import("./context").V2Event) => Promise<void>;
+};

package/dist/plugin-config.d.ts

@@ -0,0 +1,30 @@
+import { type MatrixxConfig } from "./config";
+/** Test-only: allow the one-time websearch warning to fire again. */
+export declare function resetLegacyWebsearchWarningForTesting(): void;
+export declare function parseConfigPartially(rawConfig: Record<string, unknown>): MatrixxConfig | null;
+/**
+ * Cached view of the 5 `disabled_*` arrays on a `MatrixxConfig` as Sets.
+ * Returned by {@link getDisabledSets} so callers can do O(1) membership
+ * checks without re-constructing a Set on every read.
+ */
+interface DisabledSets {
+    disabledAgents: Set<string>;
+    disabledMcps: Set<string>;
+    disabledHooks: Set<string>;
+    disabledCommands: Set<string>;
+    disabledSkills: Set<string>;
+}
+/**
+ * Returns the cached `DisabledSets` view for `config`, constructing and
+ * caching it on first access. Callers MUST treat the returned Sets as
+ * read-only — they are shared across all readers of the same config.
+ */
+export declare function getDisabledSets(config: MatrixxConfig): DisabledSets;
+/**
+ * Test-only: drop all cached `DisabledSets`. WeakMap has no `clear()`,
+ * so we replace the map with a fresh one — the old map is GC'd.
+ */
+export declare function _resetDisabledSetsCacheForTesting(): void;
+export declare function mergeConfigs(base: MatrixxConfig, override: MatrixxConfig): MatrixxConfig;
+export declare function loadPluginConfig(directory: string, ctx: unknown): Promise<MatrixxConfig>;
+export {};

package/dist/plugin-handlers/agent-config-handler.d.ts

@@ -0,0 +1,15 @@
+import type { MatrixxConfig } from "../config";
+import { type ContextModeConfigInput } from "../shared/context-mode-enforcement";
+import type { PluginComponents } from "./plugin-components-loader";
+export declare function setAvailableToolNames(names: string[]): void;
+export declare function getAvailableToolNames(): string[];
+export declare function injectContextDiscipline(availableToolNames: string[], agents: Record<string, Record<string, unknown>>, contextMode?: ContextModeConfigInput): void;
+export declare function applyAgentConfig(params: {
+    config: Record<string, unknown>;
+    pluginConfig: MatrixxConfig;
+    ctx: {
+        directory: string;
+        client?: unknown;
+    };
+    pluginComponents: PluginComponents;
+}): Promise<Record<string, unknown>>;

package/dist/plugin-handlers/agent-priority-order.d.ts

@@ -0,0 +1 @@
+export declare function reorderAgentsByPriority(agents: Record<string, unknown>): Record<string, unknown>;

package/dist/plugin-handlers/agent-tool-allowlist.d.ts

@@ -0,0 +1,11 @@
+export declare const PILOT_TOOL_ALLOWLIST_AGENTS: readonly ["trinity", "operator", "oracle"];
+export type PilotToolAllowlistAgent = (typeof PILOT_TOOL_ALLOWLIST_AGENTS)[number];
+type ToolsMap = Record<string, boolean>;
+export declare const DEFAULT_TOOL_ALLOWLIST: Record<PilotToolAllowlistAgent, ToolsMap>;
+export declare function applyAgentToolAllowlist(params: {
+    agentResult: Record<string, unknown>;
+    pluginConfig: {
+        disabled_tools?: readonly string[];
+    };
+}): void;
+export {};

package/dist/plugin-handlers/category-config-resolver.d.ts

@@ -0,0 +1,2 @@
+import type { CategoryConfig } from "../config/schema";
+export declare function resolveCategoryConfig(categoryName: string, userCategories?: Record<string, CategoryConfig>): CategoryConfig | undefined;

package/dist/plugin-handlers/command-config-handler.d.ts

@@ -0,0 +1,10 @@
+import type { MatrixxConfig } from "../config";
+import type { PluginComponents } from "./plugin-components-loader";
+export declare function applyCommandConfig(params: {
+    config: Record<string, unknown>;
+    pluginConfig: MatrixxConfig;
+    ctx: {
+        directory: string;
+    };
+    pluginComponents: PluginComponents;
+}): Promise<void>;

package/dist/plugin-handlers/config-handler.d.ts

@@ -0,0 +1,12 @@
+import type { MatrixxConfig } from "../config";
+import type { ModelCacheState } from "../plugin-state";
+export { resolveCategoryConfig } from "./category-config-resolver";
+export interface ConfigHandlerDeps {
+    ctx: {
+        directory: string;
+        client?: unknown;
+    };
+    pluginConfig: MatrixxConfig;
+    modelCacheState: ModelCacheState;
+}
+export declare function createConfigHandler(deps: ConfigHandlerDeps): (config: Record<string, unknown>) => Promise<void>;

package/dist/plugin-handlers/formatter-config-handler.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Native formatter pipeline declaration (D2).
+ *
+ * Matrixx deleted its custom format-on-write spawner
+ * (`src/tools/hashline-edit/formatter-trigger.ts`) and the Biome spawn in
+ * the quality-gate hook. Formatting is now owned entirely by OpenCode's
+ * native `formatter` pipeline, which reads the user's `formatter` config.
+ *
+ * This handler is the single place where that delegation is declared:
+ * it MUST NOT disable the pipeline (`formatter: false`), MUST NOT add
+ * formatter entries, and MUST NOT spawn processes. User-declared
+ * `formatter` entries (including an explicit `false` opt-out) pass
+ * through untouched. Pure function: input config in, same config out.
+ */
+export declare function applyFormatterConfig(params: {
+    config: Record<string, unknown>;
+}): void;

package/dist/plugin-handlers/index.d.ts

@@ -0,0 +1,11 @@
+export * from "./agent-config-handler";
+export * from "./agent-priority-order";
+export * from "./category-config-resolver";
+export * from "./command-config-handler";
+export { type ConfigHandlerDeps, createConfigHandler } from "./config-handler";
+export * from "./formatter-config-handler";
+export * from "./mcp-config-handler";
+export * from "./oracle-agent-config-builder";
+export * from "./plugin-components-loader";
+export * from "./provider-config-handler";
+export * from "./tool-config-handler";

package/dist/plugin-handlers/mcp-config-handler.d.ts

@@ -0,0 +1,7 @@
+import type { MatrixxConfig } from "../config";
+import type { PluginComponents } from "./plugin-components-loader";
+export declare function applyMcpConfig(params: {
+    config: Record<string, unknown>;
+    pluginConfig: MatrixxConfig;
+    pluginComponents: PluginComponents;
+}): Promise<void>;

package/dist/plugin-handlers/oracle-agent-config-builder.d.ts

@@ -0,0 +1,19 @@
+import { type AgentConfig } from "../agents/agent-config";
+import type { AgentOverrideConfig } from "../agents/types";
+import type { BrowserAutomationProvider, CategoryConfig, ModelRequirements } from "../config/schema";
+export declare function buildOracleAgentConfig(params: {
+    configAgentPlan: Record<string, unknown> | undefined;
+    pluginOracleOverride: AgentOverrideConfig | undefined;
+    userCategories: Record<string, CategoryConfig> | undefined;
+    currentModel: string | undefined;
+    globalOverrideModel?: string;
+    modelRequirements?: ModelRequirements;
+    pluginConfig?: {
+        plans?: {
+            smith_max_review_rounds?: number;
+        };
+    };
+    directory?: string;
+    browserProvider?: BrowserAutomationProvider;
+    disabledSkills?: Set<string>;
+}): Promise<AgentConfig>;

package/dist/plugin-handlers/plan-model-inheritance.d.ts

@@ -0,0 +1 @@
+export declare function buildPlanDemoteConfig(oracleConfig: Record<string, unknown> | undefined, planOverride: Record<string, unknown> | undefined): Record<string, unknown>;

package/dist/plugin-handlers/plugin-components-loader.d.ts

@@ -0,0 +1,22 @@
+import type { MatrixxConfig } from "../config";
+export type PluginComponents = {
+    commands: Record<string, unknown>;
+    skills: Record<string, unknown>;
+    agents: Record<string, unknown>;
+    mcpServers: Record<string, unknown>;
+    hooksConfigs: Array<{
+        hooks?: Record<string, unknown>;
+    }>;
+    plugins: Array<{
+        name: string;
+        version: string;
+    }>;
+    errors: Array<{
+        pluginKey: string;
+        installPath: string;
+        error: string;
+    }>;
+};
+export declare function loadPluginComponents(_params: {
+    pluginConfig: MatrixxConfig;
+}): Promise<PluginComponents>;

package/dist/plugin-handlers/provider-config-handler.d.ts

@@ -0,0 +1,5 @@
+import type { ModelCacheState } from "../plugin-state";
+export declare function applyProviderConfig(params: {
+    config: Record<string, unknown>;
+    modelCacheState: ModelCacheState;
+}): void;

package/dist/plugin-handlers/task-permissions.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Task-store permission grants.
+ *
+ * The task store (`.matrixx/tasks/`) is a separate write channel from the
+ * codebase. An agent whose prompt tells it to track work with tasks must be
+ * able to reach it, no matter which agent happens to hold delegation rights.
+ *
+ * OpenCode 2.x expresses gating as an ordered `{action, resource, effect}`
+ * ruleset where the last matching rule wins, so grants are appended after the
+ * agent's own rules.
+ */
+import { type PermissionRule } from "../shared/permission-compat";
+/** The legacy todo tools are denied for every task-capable agent. */
+export declare const denyTodoPermissions: PermissionRule[];
+/**
+ * Tracking only: the agent may read and write its own task-store records but
+ * may not delegate. Granted to every primary-capable agent.
+ */
+export declare const taskStorePermissions: PermissionRule[];
+/** Tracking plus outgoing delegation via the task tool. */
+export declare const fullTaskPermissions: PermissionRule[];
+type AgentLike = {
+    mode?: string;
+    permissions?: PermissionRule[];
+};
+/**
+ * An agent that can be driven as a top-level session is expected to track its
+ * own work in the task store. Derived from the declared mode, never from a
+ * hardcoded name list — a name list is exactly what let the original drift go
+ * unnoticed.
+ */
+export declare function isTaskStorePrimary(agent: AgentLike): boolean;
+/**
+ * A read-only agent declares a `task` deny for itself. OpenCode 2.x keeps the
+ * built-in subagent tool (`subagent`) and matrixx's own delegation tool
+ * (`task`) as separate actions, so a read-only agent denies both.
+ */
+export declare function deniesDelegation(agent: AgentLike): boolean;
+/** The permission grants a primary-capable agent is missing. */
+export declare function deriveTaskPermissions(agent: AgentLike): PermissionRule[];
+export {};

package/dist/plugin-handlers/tool-config-handler.d.ts

@@ -0,0 +1,6 @@
+import type { MatrixxConfig } from "../config";
+export declare function applyToolConfig(params: {
+    config: Record<string, unknown>;
+    pluginConfig: MatrixxConfig;
+    agentResult: Record<string, unknown>;
+}): void;

package/dist/plugin-state.d.ts

@@ -0,0 +1,5 @@
+export interface ModelCacheState {
+    modelContextLimitsCache: Map<string, number>;
+    anthropicContext1MEnabled: boolean;
+}
+export declare function createModelCacheState(): ModelCacheState;

package/dist/shared/agent-display-names.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Agent config keys to display names mapping.
+ * Config keys are lowercase (e.g., "morpheus", "niobe").
+ * Display names include suffixes for UI/logs (e.g., "Morpheus (Ultraworker)").
+ */
+export declare const AGENT_DISPLAY_NAMES: Record<string, string>;
+/**
+ * Get display name for an agent config key.
+ * Uses case-insensitive lookup for backward compatibility.
+ * Returns original key if not found.
+ */
+export declare function getAgentDisplayName(configKey: string): string;
+/**
+ * Reverse lookup: given a display name or config key, return the config key.
+ * Useful for comparing agent identities regardless of display name format.
+ */
+export declare function getAgentConfigKey(displayNameOrKey: string): string;

package/dist/shared/agent-label.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Shared agent label formatting for user-visible task titles.
+ * Single source of truth so session titles, tool metadata titles, and toasts
+ * all render the same `Agent[category]` label. Pure functions, no dependencies.
+ */
+/**
+ * Format an agent identity label: `Mouse[source]`, `Oracle`, `Trinity`.
+ * Falls back to `Agent` when no usable name is provided.
+ */
+export declare function formatAgentLabel(agent: unknown, category?: unknown): string;
+export interface LabeledTitleInput {
+    description?: unknown;
+    agent?: unknown;
+    category?: unknown;
+    background: boolean;
+}
+/**
+ * Build a user-visible task title: `[BG] Mouse[source] — Do the thing`
+ * for background launches, `Mouse[source] — Do the thing` for sync ones.
+ */
+export declare function buildLabeledTitle(input: LabeledTitleInput): string;

package/dist/shared/agent-tool-restrictions.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Agent tool restrictions for session.prompt calls.
+ * OpenCode SDK's session.prompt `tools` parameter expects boolean values.
+ * true = tool allowed, false = tool denied.
+ */
+export declare function getAgentToolRestrictions(agentName: string): Record<string, boolean>;

package/dist/shared/agent-variant.d.ts

@@ -0,0 +1,9 @@
+import type { MatrixxConfig } from "../config";
+export declare function resolveAgentVariant(config: MatrixxConfig, agentName?: string): string | undefined;
+export declare function resolveVariantForModel(config: MatrixxConfig, agentName: string, currentModel: {
+    providerID: string;
+    modelID: string;
+}): string | undefined;
+export declare function applyAgentVariant(config: MatrixxConfig, agentName: string | undefined, message: {
+    variant?: string;
+}): void;

package/dist/shared/awaiting-user.d.ts

@@ -0,0 +1,12 @@
+export declare const AWAITING_USER_SUPPRESS_MS: number;
+export interface AwaitingUserState {
+    awaitingUser?: boolean;
+    awaitingUserSince?: number;
+}
+export declare function isAwaitingUserState(state: unknown): boolean;
+export declare function markAwaitingUser(state: unknown, now?: number): void;
+export declare function clearAwaitingUser(state: unknown): void;
+export declare function hasPendingQuestionMessage(messages: Array<unknown>): boolean;
+export declare function isAwaitingUser(state: unknown, messages?: Array<unknown>): boolean;
+export declare function getToolName(properties: Record<string, unknown> | undefined): string | undefined;
+export declare function isQuestionTool(properties: Record<string, unknown> | undefined): boolean;

package/dist/shared/binary-downloader.d.ts

@@ -0,0 +1,10 @@
+export declare function getCachedBinaryPath(cacheDir: string, binaryName: string): string | null;
+export declare function ensureCacheDir(cacheDir: string): void;
+export declare function downloadArchive(downloadUrl: string, archivePath: string): Promise<void>;
+export declare function extractTarGz(archivePath: string, destDir: string, options?: {
+    args?: string[];
+    cwd?: string;
+}): Promise<void>;
+export declare function extractZipArchive(archivePath: string, destDir: string): Promise<void>;
+export declare function cleanupArchive(archivePath: string): void;
+export declare function ensureExecutable(binaryPath: string): void;

package/dist/shared/code-patterns.d.ts

@@ -0,0 +1,2 @@
+export declare const CODE_BLOCK_PATTERN: RegExp;
+export declare const INLINE_CODE_PATTERN: RegExp;

package/dist/shared/command-executor/embedded-commands.d.ts

@@ -0,0 +1,8 @@
+interface CommandMatch {
+    fullMatch: string;
+    command: string;
+    start: number;
+    end: number;
+}
+export declare function findEmbeddedCommands(text: string): CommandMatch[];
+export {};

package/dist/shared/command-executor/execute-command.d.ts

@@ -0,0 +1 @@
+export declare function executeCommand(command: string, timeoutMs?: number): Promise<string>;

package/dist/shared/command-executor/resolve-commands-in-text.d.ts

@@ -0,0 +1 @@
+export declare function resolveCommandsInText(text: string, depth?: number, maxDepth?: number): Promise<string>;

package/dist/shared/command-executor.d.ts

@@ -0,0 +1,2 @@
+export { executeCommand } from "./command-executor/execute-command";
+export { resolveCommandsInText } from "./command-executor/resolve-commands-in-text";

package/dist/shared/compaction-log.d.ts

@@ -0,0 +1,11 @@
+export interface CompactionSourceBytes {
+    injector: number;
+    plan: number;
+}
+export interface CompactionAppendSummary {
+    addedBytes: number;
+    sources: CompactionSourceBytes;
+}
+export declare function utf8ByteLength(fragment: string | undefined | null): number;
+export declare function summarizeCompactionAppend(sources: CompactionSourceBytes): CompactionAppendSummary;
+export declare function formatCompactionAppendLog(sessionID: string, sources: CompactionSourceBytes): string;

package/dist/shared/config-errors.d.ts

@@ -0,0 +1,10 @@
+export type ConfigLoadError = {
+    path: string;
+    error: string;
+};
+export declare class ConfigError extends Error {
+    constructor(message: string);
+}
+export declare function getConfigLoadErrors(): ConfigLoadError[];
+export declare function clearConfigLoadErrors(): void;
+export declare function addConfigLoadError(error: ConfigLoadError): void;

package/dist/shared/connected-providers-cache.d.ts

@@ -0,0 +1,55 @@
+interface ModelMetadata {
+    id: string;
+    provider?: string;
+    context?: number;
+    output?: number;
+    name?: string;
+}
+interface ProviderModelsCache {
+    models: Record<string, string[] | ModelMetadata[]>;
+    connected: string[];
+    updatedAt: string;
+}
+/**
+ * Read the connected providers cache.
+ * Returns the list of connected provider IDs, or null if cache doesn't exist.
+ */
+export declare function readConnectedProvidersCache(): string[] | null;
+/**
+ * Check if connected providers cache exists.
+ */
+export declare function hasConnectedProvidersCache(): boolean;
+/**
+ * Read the provider-models cache.
+ * Returns the cache data, or null if cache doesn't exist.
+ */
+export declare function readProviderModelsCache(): ProviderModelsCache | null;
+/**
+ * Check if provider-models cache exists.
+ */
+export declare function hasProviderModelsCache(): boolean;
+/**
+ * Write the provider-models cache.
+ */
+export declare function writeProviderModelsCache(data: {
+    models: Record<string, string[]>;
+    connected: string[];
+}): void;
+/**
+ * Update the connected providers cache by fetching from the client.
+ * Also updates the provider-models cache with model lists per provider.
+ */
+export declare function updateConnectedProvidersCache(client?: {
+    provider?: {
+        list?: () => Promise<{
+            data?: {
+                connected?: string[];
+                all?: Array<{
+                    id: string;
+                    models?: Record<string, unknown>;
+                }>;
+            };
+        }>;
+    };
+}): Promise<void>;
+export {};

package/dist/shared/context-limit-resolver.d.ts

@@ -0,0 +1,6 @@
+export type ContextLimitModelCacheState = {
+    anthropicContext1MEnabled: boolean;
+    modelContextLimitsCache?: Map<string, number>;
+};
+export declare function isAnthropicProvider(providerID: string): boolean;
+export declare function resolveActualContextLimit(providerID: string, modelID: string, modelCacheState?: ContextLimitModelCacheState): number | null;

package/dist/shared/context-limits.d.ts

@@ -0,0 +1,36 @@
+import type { ExperimentalConfig } from "../config/schema/experimental";
+import type { ContextLimitModelCacheState } from "./context-limit-resolver";
+import { isAnthropicProvider, resolveActualContextLimit } from "./context-limit-resolver";
+/**
+ * Single source for context window thresholds and limit defaults.
+ * Boundary: monitor 70% warn (read-only) → single compaction hook → recovery (reactive, error-parse only). Proactive compression belongs to DCP (/dcp-compress).
+ * Shared constants consumed via context-limits.ts + token-cache.ts.
+ *
+ * Thresholds:
+ * - CONTEXT_WARNING_THRESHOLD (0.70) — read-only monitor warning, Anthropic only.
+ * - PREEMPTIVE_COMPACTION_THRESHOLD (0.78) — proactive compaction trigger.
+ * Limits:
+ * - ANTHROPIC_DISPLAY_LIMIT (1_000_000) — UI display cap for Anthropic 1M context.
+ * - DEFAULT_ANTHROPIC_ACTUAL_LIMIT (200_000) — fallback when 1M not enabled.
+ * - DEFAULT_NON_ANTHROPIC_FALLBACK_LIMIT (128_000) — generic LLM fallback.
+ *
+ * Re-exports isAnthropicProvider + resolveActualContextLimit from resolver for single import surface.
+ */
+/** Warn threshold for monitor (read-only, does not trigger compaction). */
+export declare const CONTEXT_WARNING_THRESHOLD: 0.7;
+/** Proactive compaction threshold (preemptive-compaction trigger). */
+export declare const PREEMPTIVE_COMPACTION_THRESHOLD: 0.78;
+/** Default actual limit for Anthropic without 1M enabled. */
+export declare const DEFAULT_ANTHROPIC_ACTUAL_LIMIT: 200000;
+/** Generic fallback for non-Anthropic providers. */
+export declare const DEFAULT_NON_ANTHROPIC_FALLBACK_LIMIT: 128000;
+/** Display limit for Anthropic 1M UI. */
+export declare const ANTHROPIC_DISPLAY_LIMIT: 1000000;
+export type { ContextLimitModelCacheState };
+export { isAnthropicProvider, resolveActualContextLimit };
+/** Wrapper around resolveActualContextLimit for display vs actual semantics. */
+export declare function getActualLimit(providerID: string, modelID: string, modelCacheState?: ContextLimitModelCacheState): number | null;
+/** Display limit is fixed 1M for Anthropic UI; actual may be smaller. */
+export declare function getDisplayLimit(): number;
+export declare function resolveWarningThreshold(experimental?: ExperimentalConfig): number;
+export declare function resolvePreemptiveThreshold(experimental?: ExperimentalConfig): number;

package/dist/shared/context-mode-enforcement.d.ts

@@ -0,0 +1,59 @@
+/** Canonical default — hook, constants, and schema must all agree on this. */
+export declare const CONTEXT_MODE_DEFAULT_BLOCKED_TOOLS: readonly ["grep", "glob", "webfetch"];
+export interface ContextModeEnforcement {
+    enabled: boolean;
+    enforce: boolean;
+    blockedTools: string[];
+}
+export interface ContextModeConfigInput {
+    enabled?: boolean;
+    enforce?: boolean;
+    blocked_tools?: string[];
+}
+/**
+ * Single source of truth for context-mode enforcement state.
+ * Both the context-mode-enforcer hook (block decision) and the agent prompt
+ * builders (guidance text) derive from this — prompt and hook can never
+ * disagree because they read the same resolved flags.
+ */
+export declare function resolveContextModeEnforcement(contextMode: ContextModeConfigInput | undefined): ContextModeEnforcement;
+/** Exact tool-name match for the raw search tools (mirrors the hook's check). */
+export declare function hasGrepGlobToolNames(toolNames: readonly string[]): boolean;
+/**
+ * Whether agent prompts may advertise a grep/glob fallback.
+ * Usable = registered AND not blocked. Under enforce:true the hook throws on
+ * grep/glob, so the prompt must never offer them — it must name the working
+ * substitute (ctx_batch / ctx_execute running `rg`) instead.
+ */
+export declare function resolveGrepGlobUsable(toolNames: readonly string[], contextMode?: ContextModeConfigInput): boolean;
+export declare function _setDisciplinePathForTesting(p: string | null | undefined): void;
+export declare function _setCtxToolsForTesting(present: boolean | null): void;
+export declare function setContextModeForPrompts(contextMode: ContextModeConfigInput | undefined): void;
+export declare function getContextModeForPrompts(): ContextModeConfigInput | undefined;
+export declare function _resetContextModeEnforcementForTesting(): void;
+export declare function willBlockGrepGlob(contextMode: ContextModeConfigInput | undefined): boolean;
+export declare function resolveContextModeDisciplinePath(): string | null;
+/**
+ * Walk up from a resolved file inside the context-mode package until a
+ * directory containing a package.json with `"name": "context-mode"` is
+ * found. Returns that directory, or null when no matching root exists.
+ * Pure and unit-testable - every filesystem failure returns null (fail-open).
+ */
+export declare function deriveContextModeRootFromFile(resolvedFilePath: string): string | null;
+export declare function resolveContextModeDisciplineInfo(): {
+    path: string | null;
+    version: string | null;
+};
+export declare function hasWorkingSubstitute(): boolean;
+/**
+ * SINGLE-OWNER predicate for ctx-tool presence.
+ * Fail-open (locked Phase-2 decision, honoring the committed
+ * ctx-absent-blocked RED suite): available only when the discipline path
+ * resolves AND a context_mode config is present and enabled; every other
+ * state defaults to false so the hook's warn-only fallback path stays
+ * reachable exactly as today. Tests force either outcome via
+ * `_setCtxToolsForTesting`.
+ */
+export declare function isCtxToolsAvailable(): boolean;
+/** Alias kept for prompt-builder readability — same single owner. */
+export declare function hasCtxToolsForPrompts(): boolean;