opencode-matrixx-v2 0.0.0-stage → 1.0.0

package/dist/shared/data-path.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Returns the user-level data directory.
+ * Matches OpenCode's behavior via xdg-basedir:
+ * - All platforms: XDG_DATA_HOME or ~/.local/share
+ *
+ * Note: OpenCode uses xdg-basedir which returns ~/.local/share on ALL platforms
+ * including Windows, so we match that behavior exactly.
+ */
+export declare function getDataDir(): string;
+/**
+ * Returns the OpenCode storage directory path.
+ * All platforms: ~/.local/share/opencode/storage
+ */
+export declare function getOpenCodeStorageDir(): string;
+/**
+ * Returns the user-level cache directory.
+ * Matches OpenCode's behavior via xdg-basedir:
+ * - All platforms: XDG_CACHE_HOME or ~/.cache
+ */
+export declare function getCacheDir(): string;
+/**
+ * Returns the matrixx cache directory.
+ * All platforms: ~/.cache/matrixx
+ */
+export declare function getOmoOpenCodeCacheDir(): string;
+/**
+ * Returns the OpenCode cache directory (for reading OpenCode's cache).
+ * All platforms: ~/.cache/opencode
+ */
+export declare function getOpenCodeCacheDir(): string;

package/dist/shared/dcp-guidance.d.ts

@@ -0,0 +1,16 @@
+/**
+ * How DCP compression is available. "guided" = DCP auto-mode (nudges drive
+ * DCP's `compress` tool); "manual" = DCP manualMode (tool exists,
+ * trigger-only, no nudges); "none" = no `compress` tool exists.
+ */
+export type DcpCompressionMode = "guided" | "manual" | "none";
+export declare function _setDcpConfigPathForTesting(p: string | null | undefined): void;
+export declare function _resetDcpGuidanceForTesting(): void;
+/**
+ * How DCP compression is available in this environment.
+ * True model (DCP owns the only `compress` tool — the host has none):
+ * - "guided": DCP auto-mode — never bare without message IDs; proactive on closed sections with IDs + usage signals.
+ * - "manual": DCP manualMode — call `compress` only after the manual trigger; no nudges.
+ * - "none": no `compress` tool exists — never call it.
+ */
+export declare function resolveDcpCompressionMode(): DcpCompressionMode;

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

@@ -0,0 +1,19 @@
+import type { DcpConfig } from "../config/schema/dcp";
+export interface DcpSwitchProfileOptions {
+    pluginConfig?: {
+        dcp?: DcpConfig;
+    };
+}
+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.
+ * Merges shared defaults with the builtin profile, then overlays
+ * dcp.profiles[profile] (profile name as key).
+ */
+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
+ * a full inline DCP config to ~/.config/opencode/dcp.jsonc.
+ */
+export declare function switchProfile(profile: string, options?: DcpSwitchProfileOptions): string;

package/dist/shared/deep-merge.d.ts

@@ -0,0 +1,13 @@
+export declare function isPlainObject(value: unknown): value is Record<string, unknown>;
+/**
+ * Deep merges two objects, with override values taking precedence.
+ * - Objects are recursively merged
+ * - Arrays are replaced (not concatenated)
+ * - undefined values in override do not overwrite base values
+ *
+ * @example
+ * deepMerge({ a: 1, b: { c: 2, d: 3 } }, { b: { c: 10 }, e: 5 })
+ * // => { a: 1, b: { c: 10, d: 3 }, e: 5 }
+ */
+export declare function deepMerge<T extends Record<string, unknown>>(base: T, override: Partial<T>, depth?: number): T;
+export declare function deepMerge<T extends Record<string, unknown>>(base: T | undefined, override: T | undefined, depth?: number): T | undefined;

package/dist/shared/delay.d.ts

@@ -0,0 +1 @@
+export declare function delay(ms: number): Promise<void>;

package/dist/shared/disabled-tools.d.ts

@@ -0,0 +1,2 @@
+import type { MatrixxToolDefinition } from "../tools/shared/define-tool";
+export declare function filterDisabledTools(tools: Record<string, MatrixxToolDefinition>, disabledTools: readonly string[] | undefined): Record<string, MatrixxToolDefinition>;

package/dist/shared/dynamic-truncator.d.ts

@@ -0,0 +1,23 @@
+import type { MatrixxContext } from "../plugin/context";
+import type { SessionContextCarrier } from "./session-context-source";
+type MessageSource = MatrixxContext | SessionContextCarrier;
+interface TruncationResult {
+    result: string;
+    truncated: boolean;
+    removedCount?: number;
+}
+interface TruncationOptions {
+    targetMaxTokens?: number;
+    preserveHeaderLines?: number;
+    contextWindowLimit?: number;
+}
+export declare function createDynamicTruncator(ctx: MessageSource): {
+    truncate: (sessionID: string, output: string, options?: TruncationOptions) => Promise<TruncationResult>;
+    getUsage: (sessionID: string) => Promise<{
+        usedTokens: number;
+        remainingTokens: number;
+        usagePercentage: number;
+    } | null>;
+    truncateSync: (output: string, maxTokens: number, preserveHeaderLines?: number) => TruncationResult;
+};
+export {};

package/dist/shared/error-formatting.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Context for formatting an error with full debugging details.
+ * Used across all matrixx background task tools.
+ */
+export interface ErrorContext {
+    operation: string;
+    /**
+     * DelegateTaskArgs (structurally compatible — see src/tools/delegate-task/types.ts).
+     * Only the fields read by formatDetailedError are required.
+     */
+    args?: {
+        description: string;
+        category?: string;
+        subagent_type?: string;
+        run_in_background: boolean;
+        load_skills?: string[];
+        session_id?: string;
+    };
+    sessionID?: string;
+    agent?: string;
+    category?: string;
+}
+/**
+ * Format an error with detailed context for debugging.
+ * Replaces the `?? "pending"` anti-pattern across matrixx background task tools.
+ */
+export declare function formatDetailedError(error: unknown, ctx: ErrorContext): string;
+export declare function getErrorMessage(error: unknown): string;

package/dist/shared/escape-regexp.d.ts

@@ -0,0 +1 @@
+export declare function escapeRegExp(value: string): string;

package/dist/shared/external-plugin-detector.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Detects external plugins that may conflict with matrixx features.
+ * Used to prevent crashes from concurrent notification plugins.
+ */
+interface ExternalNotifierResult {
+    detected: boolean;
+    pluginName: string | null;
+    allPlugins: string[];
+}
+/**
+ * Detect if any external notification plugin is configured.
+ * Returns information about detected plugins for logging/warning.
+ */
+export declare function detectExternalNotificationPlugin(directory: string): ExternalNotifierResult;
+/**
+ * Generate a warning message for users with conflicting notification plugins.
+ */
+export declare function getNotificationConflictWarning(pluginName: string): string;
+export {};

package/dist/shared/file-reference-resolver.d.ts

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

package/dist/shared/file-utils.d.ts

@@ -0,0 +1,7 @@
+export declare function isMarkdownFile(entry: {
+    name: string;
+    isFile: () => boolean;
+}): boolean;
+export declare function isSymbolicLink(filePath: string): boolean;
+export declare function resolveSymlink(filePath: string): string;
+export declare function resolveSymlinkAsync(filePath: string): Promise<string>;

package/dist/shared/first-message-variant.d.ts

@@ -0,0 +1,11 @@
+type SessionInfo = {
+    id?: string;
+    parentID?: string;
+};
+export declare function createFirstMessageVariantGate(): {
+    markSessionCreated(info?: SessionInfo): void;
+    shouldOverride(sessionID?: string): boolean;
+    markApplied(sessionID?: string): void;
+    clear(sessionID?: string): void;
+};
+export {};

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

@@ -0,0 +1 @@
+export declare function formatBytes(bytes: number): string;

package/dist/shared/format-duration.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Format a duration between two dates as a human-readable string.
+ */
+export declare function formatDuration(start: Date, end?: Date): string;

package/dist/shared/frontmatter.d.ts

@@ -0,0 +1,8 @@
+interface FrontmatterResult<T = Record<string, unknown>> {
+    data: T;
+    body: string;
+    hadFrontmatter: boolean;
+    parseError: boolean;
+}
+export declare function parseFrontmatter<T = Record<string, unknown>>(content: string): FrontmatterResult<T>;
+export {};

package/dist/shared/git-worktree/collect-git-diff-stats.d.ts

@@ -0,0 +1,2 @@
+import type { GitFileStat } from "./types";
+export declare function collectGitDiffStats(directory: string): GitFileStat[];

package/dist/shared/git-worktree/format-file-changes.d.ts

@@ -0,0 +1,2 @@
+import type { GitFileStat } from "./types";
+export declare function formatFileChanges(stats: GitFileStat[], notepadPath?: string): string;

package/dist/shared/git-worktree/parse-diff-numstat.d.ts

@@ -0,0 +1,2 @@
+import type { GitFileStat, GitFileStatus } from "./types";
+export declare function parseGitDiffNumstat(output: string, statusMap: Map<string, GitFileStatus>): GitFileStat[];

package/dist/shared/git-worktree/parse-status-porcelain.d.ts

@@ -0,0 +1,2 @@
+import type { GitFileStatus } from "./types";
+export declare function parseGitStatusPorcelain(output: string): Map<string, GitFileStatus>;

package/dist/shared/git-worktree/types.d.ts

@@ -0,0 +1,7 @@
+export type GitFileStatus = "modified" | "added" | "deleted";
+export interface GitFileStat {
+    path: string;
+    added: number;
+    removed: number;
+    status: GitFileStatus;
+}

package/dist/shared/index.d.ts

@@ -0,0 +1,70 @@
+export * from "./agent-tool-restrictions";
+export * from "./agent-variant";
+export * from "./binary-downloader";
+export * from "./command-executor";
+export * from "./compaction-log";
+export * from "./config-errors";
+export * from "./connected-providers-cache";
+export * from "./context-mode-enforcement";
+export * from "./data-path";
+export * from "./dcp-switch-profile";
+export * from "./deep-merge";
+export * from "./delay";
+export * from "./dynamic-truncator";
+export * from "./escape-regexp";
+export * from "./external-plugin-detector";
+export * from "./file-reference-resolver";
+export * from "./file-utils";
+export * from "./format-bytes";
+export * from "./format-duration";
+export * from "./frontmatter";
+export { collectGitDiffStats } from "./git-worktree/collect-git-diff-stats";
+export { formatFileChanges } from "./git-worktree/format-file-changes";
+export { parseGitDiffNumstat } from "./git-worktree/parse-diff-numstat";
+export { parseGitStatusPorcelain } from "./git-worktree/parse-status-porcelain";
+export type { GitFileStat, GitFileStatus } from "./git-worktree/types";
+export * from "./injection-notifier";
+export * from "./is-abort-error";
+export * from "./json-safe-metadata";
+export * from "./jsonc-parser";
+export * from "./logger";
+export * from "./memory-backend-detect";
+export * from "./model-availability";
+export * from "./model-requirements";
+export { type ModelResolutionProvenance, type ModelResolutionRequest, type ModelResolutionResult, normalizeModel, resolveModelPipeline, } from "./model-resolution-pipeline";
+export * from "./model-suggestion-retry";
+export * from "./normalize-sdk-response";
+export * from "./notify";
+export * from "./opencode-config-dir";
+export * from "./opencode-http-api";
+export * from "./opencode-message-dir";
+export * from "./opencode-server-auth";
+export * from "./opencode-storage-detection";
+export * from "./opencode-storage-paths";
+export * from "./opencode-version";
+export * from "./permission-compat";
+export * from "./port-utils";
+export * from "./rtk-enforcement";
+export * from "./safe-create-hook";
+export * from "./sentinels";
+export * from "./session-context-source";
+export * from "./session-cursor";
+export * from "./session-directory-resolver";
+export * from "./session-facade";
+export * from "./session-id";
+export * from "./session-message";
+export * from "./session-utils";
+export * from "./shell-env";
+export * from "./shell-tool-name";
+export { isLinkedWorktree, MATRIX_STATE_DIR, resolveStateRoot, type StateRootCandidates, stateExists, stateRootFromPluginContext, stateRootFromToolContext, } from "./state-root";
+export * from "./status-types";
+export * from "./system-directive";
+export * from "./tmux/constants";
+export * from "./tmux/tmux-utils";
+export * from "./tmux/types";
+export * from "./token-cache";
+export * from "./transcript-path";
+export * from "./truncate-description";
+export * from "./unwrap-list";
+export * from "./with-timeout";
+export * from "./zip-extractor";

package/dist/shared/injection-notifier.d.ts

@@ -0,0 +1,14 @@
+import type { MatrixxContext } from "../plugin/context";
+export declare const INJECTION_NOTICE_MAX_BODY_LENGTH = 120;
+export interface NotifyInjectionOptions {
+    sessionID: string;
+    injector: string;
+    hash: string;
+    title: string;
+    message: string;
+    /** Opt-in persistent mirror via session.prompt({ noReply: true }). Default: false (toast-only). Wire to `notification.injection_notices.persistent` — callers pass the resolved flag (config-as-param convention, cf. agent-variant.ts). */
+    persistent?: boolean;
+}
+export declare function resetInjectionNotifier(): void;
+export declare function buildInjectionNotice(message: string): string;
+export declare function notifyInjection(ctx: MatrixxContext, options: NotifyInjectionOptions): Promise<void>;

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

@@ -0,0 +1 @@
+export declare function isAbortError(error: unknown): boolean;

package/dist/shared/json-safe-metadata.d.ts

@@ -0,0 +1 @@
+export declare function jsonSafeMetadata<T>(value: T): T;

package/dist/shared/jsonc-parser.d.ts

@@ -0,0 +1,16 @@
+interface JsoncParseResult<T> {
+    data: T | null;
+    errors: Array<{
+        message: string;
+        offset: number;
+        length: number;
+    }>;
+}
+export declare function parseJsonc<T = unknown>(content: string): T;
+export declare function parseJsoncSafe<T = unknown>(content: string): JsoncParseResult<T>;
+export declare function readJsoncFile<T = unknown>(filePath: string): T | null;
+export declare function detectConfigFile(basePath: string): {
+    format: "json" | "jsonc" | "none";
+    path: string;
+};
+export {};

package/dist/shared/logger.d.ts

@@ -0,0 +1,2 @@
+export declare function warn(message: string, data?: unknown): void;
+export declare function log(message: string, data?: unknown): void;

package/dist/shared/memory-backend-detect.d.ts

@@ -0,0 +1,16 @@
+import type { MemoryBackend } from "../config/schema/memory";
+export interface MemoryBackendDetection {
+    hasLcmTools: boolean;
+    hasSupermemoryTools: boolean;
+}
+export declare function detectMemoryBackendTools(names: string[]): MemoryBackendDetection;
+export declare function isMemoryBackendSatisfied(backend: MemoryBackend, detection: MemoryBackendDetection): boolean;
+export declare function getMemoryBackendMissingWarning(backend: MemoryBackend): string;
+export declare function getMemoryBackendRoutingHint(backend: MemoryBackend): string;
+interface MemoryBackendPlugins {
+    hasLcmPlugin: boolean;
+    hasSupermemoryPlugin: boolean;
+    allPlugins: string[];
+}
+export declare function detectMemoryBackendPlugins(directory: string): MemoryBackendPlugins;
+export {};

package/dist/shared/merge-categories.d.ts

@@ -0,0 +1,6 @@
+import type { CategoriesConfig, CategoryConfig } from "../config/schema";
+/**
+ * Merge default and user categories, filtering out disabled ones.
+ * Single source of truth for category merging across the codebase.
+ */
+export declare function mergeCategories(userCategories?: CategoriesConfig): Record<string, CategoryConfig>;

package/dist/shared/migration/hook-names.d.ts

@@ -0,0 +1,7 @@
+export declare const LEGACY_HOOK_NAME_MAP: Record<string, string>;
+export declare const HOOK_NAME_MAP: Record<string, string | null>;
+export declare function migrateHookNames(hooks: string[]): {
+    migrated: string[];
+    changed: boolean;
+    removed: string[];
+};

package/dist/shared/model-availability.d.ts

@@ -0,0 +1,34 @@
+export declare function fuzzyMatchModel(target: string, available: Set<string>, providers?: string[]): string | null;
+/**
+ * Check if a target model is available (fuzzy match by model name, no provider filtering)
+ *
+ * @param targetModel - Model name to check (e.g., "gpt-5.3-codex")
+ * @param availableModels - Set of available models in "provider/model" format
+ * @returns true if model is available, false otherwise
+ */
+export declare function isModelAvailable(targetModel: string, availableModels: Set<string>): boolean;
+export declare function getConnectedProviders(client: {
+    provider?: {
+        list?: () => Promise<unknown>;
+    };
+    model?: {
+        list?: () => Promise<unknown>;
+    };
+}): Promise<string[]>;
+export declare function fetchAvailableModels(client?: {
+    provider?: {
+        list?: () => Promise<unknown>;
+    };
+    model?: {
+        list?: () => Promise<unknown>;
+    };
+}, options?: {
+    connectedProviders?: string[] | null;
+}): Promise<Set<string>>;
+export declare function isAnyFallbackModelAvailable(fallbackChain: Array<{
+    providers: string[];
+    model: string;
+}>, availableModels: Set<string>): boolean;
+export declare function isAnyProviderConnected(providers: string[], availableModels: Set<string>): boolean;
+export declare function __resetModelCache(): void;
+export declare function isModelCacheAvailable(): boolean;

package/dist/shared/model-requirements.d.ts

@@ -0,0 +1,23 @@
+import { type ModelRequirements } from "../config/schema/model-config";
+export type FallbackEntry = {
+    providers: string[];
+    model: string;
+    variant?: string;
+};
+export type ModelRequirement = {
+    fallbackChain: FallbackEntry[];
+    variant?: string;
+    requiresModel?: string;
+    requiresAnyModel?: boolean;
+    requiresProvider?: string[];
+};
+export declare const DEFAULT_AGENT_MODEL_REQUIREMENTS: Record<string, ModelRequirement>;
+export declare const DEFAULT_CATEGORY_MODEL_REQUIREMENTS: Record<string, ModelRequirement>;
+export declare const AGENT_MODEL_REQUIREMENTS: Record<string, ModelRequirement>;
+export declare const CATEGORY_MODEL_REQUIREMENTS: Record<string, ModelRequirement>;
+export declare function getAgentModelRequirements(config?: {
+    modelRequirements?: ModelRequirements;
+} | null): Record<string, ModelRequirement>;
+export declare function getCategoryModelRequirements(config?: {
+    modelRequirements?: ModelRequirements;
+} | null): Record<string, ModelRequirement>;

package/dist/shared/model-resolution-pipeline.d.ts

@@ -0,0 +1,27 @@
+import type { FallbackEntry } from "./model-requirements";
+export type ModelResolutionRequest = {
+    intent?: {
+        globalOverrideModel?: string;
+        uiSelectedModel?: string;
+        userModel?: string;
+        categoryDefaultModel?: string;
+    };
+    constraints: {
+        availableModels: Set<string>;
+        connectedProviders?: string[];
+    };
+    policy?: {
+        fallbackChain?: FallbackEntry[];
+        systemDefaultModel?: string;
+    };
+};
+export type ModelResolutionProvenance = "override" | "category-default" | "provider-fallback" | "system-default";
+export type ModelResolutionResult = {
+    model: string;
+    provenance: ModelResolutionProvenance;
+    variant?: string;
+    attempted?: string[];
+    reason?: string;
+};
+export declare function normalizeModel(model?: string): string | undefined;
+export declare function resolveModelPipeline(request: ModelResolutionRequest): ModelResolutionResult | undefined;

package/dist/shared/model-sanitizer.d.ts

@@ -0,0 +1,3 @@
+type CommandSource = "other" | "opencode";
+export declare function sanitizeModelField(model: unknown, source?: CommandSource): string | undefined;
+export {};

package/dist/shared/model-suggestion-retry.d.ts

@@ -0,0 +1,43 @@
+import type { SessionDomainLike } from "./session-facade";
+export interface RetrySessionClient {
+    session: {
+        promptAsync(args: unknown): Promise<unknown>;
+        prompt(args: unknown): Promise<unknown>;
+    };
+}
+type Client = RetrySessionClient;
+interface ModelSuggestionInfo {
+    providerID: string;
+    modelID: string;
+    suggestion: string;
+}
+export declare function parseModelSuggestion(error: unknown): ModelSuggestionInfo | null;
+interface PromptBody {
+    model?: {
+        providerID: string;
+        modelID: string;
+    };
+    [key: string]: unknown;
+}
+interface PromptArgs {
+    path: {
+        id: string;
+    };
+    body: PromptBody;
+    [key: string]: unknown;
+}
+export declare function promptWithModelSuggestionRetry(client: Client, args: PromptArgs): Promise<void>;
+/**
+ * Synchronous variant of promptWithModelSuggestionRetry.
+ *
+ * Uses `session.prompt` (blocking HTTP call that waits for the LLM response)
+ * instead of `promptAsync` (fire-and-forget HTTP 204).
+ *
+ * Required by callers that need the response to be available immediately after
+ * the call returns — e.g. look_at, which reads session messages right away.
+ */
+export declare function promptSyncWithModelSuggestionRetry(client: Client, args: PromptArgs): Promise<void>;
+export declare function promptNativeWithModelSuggestionRetry(session: SessionDomainLike, args: {
+    sessionID: string;
+} & PromptBody): Promise<void>;
+export {};

package/dist/shared/normalize-sdk-response.d.ts

@@ -0,0 +1 @@
+export declare function normalizeSDKResponse<TData>(response: unknown, fallback: TData): TData;

package/dist/shared/notify.d.ts

@@ -0,0 +1,5 @@
+export type NotifyLevel = "info" | "warn" | "success" | "error";
+export type NotifySink = (level: NotifyLevel, message: string, data?: unknown) => void;
+export declare function setNotifySink(next: NotifySink): void;
+export declare function resetNotifySink(): void;
+export declare function notify(level: NotifyLevel, message: string, data?: unknown): void;

package/dist/shared/opencode-config-dir.d.ts

@@ -0,0 +1,18 @@
+export type OpenCodeBinaryType = "opencode" | "opencode-desktop";
+export type OpenCodeConfigDirOptions = {
+    binary: OpenCodeBinaryType;
+    version?: string | null;
+    checkExisting?: boolean;
+};
+export type OpenCodeConfigPaths = {
+    configDir: string;
+    configJson: string;
+    configJsonc: string;
+    packageJson: string;
+    matrixxConfig: string;
+};
+export declare const TAURI_APP_IDENTIFIER = "ai.opencode.desktop";
+export declare const TAURI_APP_IDENTIFIER_DEV = "ai.opencode.desktop.dev";
+export declare function isDevBuild(version: string | null | undefined): boolean;
+export declare function getOpenCodeConfigDir(options: OpenCodeConfigDirOptions): string;
+export declare function getOpenCodeConfigPaths(options: OpenCodeConfigDirOptions): OpenCodeConfigPaths;

package/dist/shared/opencode-http-api.d.ts

@@ -0,0 +1,3 @@
+export declare function getServerBaseUrl(client: unknown): string | null;
+export declare function patchPart(client: unknown, sessionID: string, messageID: string, partID: string, body: Record<string, unknown>): Promise<boolean>;
+export declare function deletePart(client: unknown, sessionID: string, messageID: string, partID: string): Promise<boolean>;

package/dist/shared/opencode-message-dir.d.ts

@@ -0,0 +1 @@
+export declare function getMessageDir(sessionID: string): string | null;

package/dist/shared/opencode-server-auth.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Builds HTTP Basic Auth header from environment variables.
+ *
+ * @returns Basic Auth header string, or undefined if OPENCODE_SERVER_PASSWORD is not set
+ */
+export declare function getServerBasicAuthHeader(): string | undefined;

package/dist/shared/opencode-storage-detection.d.ts

@@ -0,0 +1,2 @@
+export declare function isSqliteBackend(): boolean;
+export declare function resetSqliteBackendCache(): void;

package/dist/shared/opencode-storage-paths.d.ts

@@ -0,0 +1,4 @@
+export declare const OPENCODE_STORAGE: string;
+export declare const MESSAGE_STORAGE: string;
+export declare const PART_STORAGE: string;
+export declare const SESSION_STORAGE: string;

package/dist/shared/opencode-version.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Minimum OpenCode version required for this plugin.
+ * This plugin only supports OpenCode 1.1.1+ which uses the permission system.
+ */
+export declare const MINIMUM_OPENCODE_VERSION = "1.1.1";
+/**
+ * OpenCode version that introduced native AGENTS.md injection.
+ * PR #10678 merged on Jan 26, 2026 - OpenCode now dynamically resolves
+ * AGENTS.md files from subdirectories as the agent explores them.
+ * When this version is detected, the directory-agents-injector hook
+ * is auto-disabled to prevent duplicate AGENTS.md loading.
+ */
+export declare const OPENCODE_NATIVE_AGENTS_INJECTION_VERSION = "1.1.37";
+/**
+ * OpenCode version that introduced SQLite backend for storage.
+ * When this version is detected AND opencode.db exists, SQLite backend is used.
+ */
+export declare const OPENCODE_SQLITE_VERSION = "1.1.53";
+export declare function parseVersion(version: string): number[];
+export declare function compareVersions(a: string, b: string): -1 | 0 | 1;
+export declare function getOpenCodeVersion(): string | null;
+export declare function isOpenCodeVersionAtLeast(version: string): boolean;
+export declare function resetVersionCache(): void;
+export declare function setVersionCache(version: string | null): void;

package/dist/shared/permission-compat.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Permission primitives for the V2 agent ruleset.
+ *
+ * OpenCode 2.x gates capabilities with ordered `{action, resource, effect}`
+ * rules, not a `{tool: value}` map, so restrictions are expressed as rules.
+ */
+export type PermissionEffect = "allow" | "deny" | "ask";
+export interface PermissionRule {
+    action: string;
+    resource: string;
+    effect: PermissionEffect;
+}
+export declare function rule(action: string, effect?: PermissionEffect, resource?: string): PermissionRule;
+export declare function denyActions(actions: string[]): PermissionRule[];
+/**
+ * A leading wildcard deny makes every action fall through to `deny`; evaluation
+ * is last-match-wins, so the allows must follow it.
+ */
+export declare function allowActionsOnly(actions: string[]): PermissionRule[];