oh-my-opencode-serverlocal 0.1.0

package/dist/config/strip-orchestrator-model.d.ts

@@ -0,0 +1,9 @@
+import type { PluginConfig, Preset } from './schema';
+export declare function stripOrchestratorModel(agents: Record<string, unknown>, enabled: boolean | undefined, preset: Preset | undefined): void;
+export declare function applyOrchestratorModelConfig(input: {
+    agents: Record<string, unknown>;
+    enabled: boolean | undefined;
+    presets: PluginConfig['presets'];
+    configPreset: string | undefined;
+    runtimePreset: string | null;
+}): void;

package/dist/config/utils.d.ts

@@ -0,0 +1,18 @@
+import type { AgentOverrideConfig, PluginConfig } from './schema';
+/**
+ * Get agent override config by name, supporting backward-compatible aliases.
+ * Checks both the current name and any legacy alias names.
+ *
+ * @param config - The plugin configuration
+ * @param name - The current agent name
+ * @returns The agent-specific override configuration if found
+ */
+export declare function getAgentOverride(config: PluginConfig | undefined, name: string): AgentOverrideConfig | undefined;
+/**
+ * Get custom agent names declared in config.agents.
+ *
+ * Custom agents are unknown keys that are neither built-in agent names nor
+ * legacy aliases.
+ */
+export declare function getCustomAgentNames(config: PluginConfig | undefined): string[];
+export declare function getAcpAgentNames(config: PluginConfig | undefined): string[];

package/dist/council/council-manager.d.ts

@@ -0,0 +1,53 @@
+/**
+ * Council Manager
+ *
+ * Orchestrates multi-LLM council sessions: launches councillors in
+ * parallel and collects their results for the council agent to synthesize.
+ */
+import type { PluginInput } from '@opencode-ai/plugin';
+import type { PluginConfig } from '../config';
+import type { CouncilResult } from '../config/council-schema';
+import type { SubagentDepthTracker } from '../utils/subagent-depth';
+export declare class CouncilManager {
+    private client;
+    private directory;
+    private config?;
+    private depthTracker?;
+    private tmuxEnabled;
+    private deprecatedFields?;
+    private legacyMasterModel?;
+    constructor(ctx: PluginInput, config?: PluginConfig, depthTracker?: SubagentDepthTracker, tmuxEnabled?: boolean);
+    /** Return deprecated config fields detected during parsing (for tool warnings). */
+    getDeprecatedFields(): string[] | undefined;
+    /** Return the legacy master.model if it was used as fallback. */
+    getLegacyMasterModel(): string | undefined;
+    /**
+     * Run a full council session.
+     *
+     * 1. Look up the preset
+     * 2. Launch all councillors in parallel
+     * 3. Collect results (respecting timeout)
+     * 4. Return formatted councillor results for synthesis
+     */
+    runCouncil(prompt: string, presetName: string | undefined, parentSessionId: string): Promise<CouncilResult>;
+    /**
+     * Inject a start notification into the parent session so the user
+     * sees immediate feedback while councillors are spinning up.
+     */
+    private sendStartNotification;
+    /**
+     * Run a single agent session: create → register → prompt → extract → cleanup.
+     */
+    private runAgentSession;
+    private runCouncillors;
+    /**
+     * Run a single councillor across its configured model chain.
+     *
+     * For each model in the chain, empty responses are retried up to
+     * `maxRetries` times (providers that silently rate-limit). Any other
+     * failure or timeout advances to the next model in the chain. The
+     * councillor only fails once every model has been exhausted; the reported
+     * `model` and `error` reflect the last model tried.
+     */
+    private runCouncillorWithRetry;
+}

package/dist/council/index.d.ts

@@ -0,0 +1 @@
+export { CouncilManager } from './council-manager';

package/dist/hooks/apply-patch/codec.d.ts

@@ -0,0 +1,7 @@
+import type { ParsedPatch } from './types';
+export declare function normalizeUnicode(text: string): string;
+export declare function stripHeredoc(input: string): string;
+export declare function normalizePatchText(patchText: string): string;
+export declare function parsePatch(patchText: string): ParsedPatch;
+export declare function parsePatchStrict(patchText: string): ParsedPatch;
+export declare function formatPatch(patch: ParsedPatch): string;

package/dist/hooks/apply-patch/errors.d.ts

@@ -0,0 +1,25 @@
+import type { ApplyPatchErrorCode, ApplyPatchErrorKind } from './types';
+export declare class ApplyPatchError extends Error {
+    readonly kind: ApplyPatchErrorKind;
+    readonly code: ApplyPatchErrorCode;
+    readonly cause?: unknown;
+    constructor(kind: ApplyPatchErrorKind, code: ApplyPatchErrorCode, message: string, options?: {
+        cause?: unknown;
+    });
+}
+export declare function getErrorMessage(error: unknown): string;
+export declare function createApplyPatchBlockedError(message: string, cause?: unknown): ApplyPatchError;
+export declare function createApplyPatchValidationError(message: string, cause?: unknown): ApplyPatchError;
+export declare function createApplyPatchVerificationError(message: string, cause?: unknown): ApplyPatchError;
+export declare function createApplyPatchInternalError(message: string, cause?: unknown): ApplyPatchError;
+export declare function isApplyPatchError(error: unknown): error is ApplyPatchError;
+export declare function isApplyPatchBlockedError(error: unknown): boolean;
+export declare function isApplyPatchValidationError(error: unknown): boolean;
+export declare function isApplyPatchVerificationError(error: unknown): boolean;
+export declare function isApplyPatchInternalError(error: unknown): boolean;
+export declare function getApplyPatchErrorDetails(error: unknown): {
+    kind: ApplyPatchErrorKind;
+    code: ApplyPatchErrorCode;
+    message: string;
+} | undefined;
+export declare function ensureApplyPatchError(error: unknown, context: string): ApplyPatchError;

package/dist/hooks/apply-patch/execution-context.d.ts

@@ -0,0 +1,27 @@
+import { resolveUpdateChunksFromText } from './resolution';
+import type { ApplyPatchRuntimeOptions, PatchHunk, UpdatePatchHunk } from './types';
+export type PreparedFileState = {
+    exists: false;
+    derived: boolean;
+} | {
+    exists: true;
+    text: string;
+    mode?: number;
+    derived: boolean;
+};
+export type PatchExecutionContext = {
+    hunks: PatchHunk[];
+    pathsNormalized: boolean;
+    staged: Map<string, PreparedFileState>;
+    getPreparedFileState: (filePath: string, verb: 'update' | 'delete') => Promise<PreparedFileState>;
+    assertPreparedPathMissing: (filePath: string, verb: 'add' | 'move') => Promise<void>;
+};
+export type ResolvedPreparedUpdate = {
+    resolved: Awaited<ReturnType<typeof resolveUpdateChunksFromText>>['resolved'];
+    nextText: string;
+};
+export declare function isMissingPathError(error: unknown): boolean;
+export declare function parseValidatedPatch(patchText: string): PatchHunk[];
+export declare function createPatchExecutionContext(root: string, patchText: string, worktree?: string): Promise<PatchExecutionContext>;
+export declare function resolvePreparedUpdate(filePath: string, currentText: string, hunk: UpdatePatchHunk, cfg: ApplyPatchRuntimeOptions): ResolvedPreparedUpdate;
+export declare function stageAddedText(contents: string): string;

package/dist/hooks/apply-patch/index.d.ts

@@ -0,0 +1,15 @@
+import type { PluginInput } from '@opencode-ai/plugin';
+interface ToolExecuteBeforeInput {
+    tool: string;
+    directory?: string;
+}
+interface ToolExecuteBeforeOutput {
+    args?: {
+        patchText?: unknown;
+        [key: string]: unknown;
+    };
+}
+export declare function createApplyPatchHook(ctx: PluginInput): {
+    'tool.execute.before': (input: ToolExecuteBeforeInput, output: ToolExecuteBeforeOutput) => Promise<void>;
+};
+export {};

package/dist/hooks/apply-patch/matching.d.ts

@@ -0,0 +1,26 @@
+import type { LineComparator, MatchComparatorName, RescueResult, SeekHit } from './types';
+export type PreparedAutoRescueTarget = {
+    exact: string;
+    unicode: string;
+    trimEnd: string;
+    unicodeTrimEnd: string;
+};
+export declare function equalExact(a: string, b: string): boolean;
+export declare function equalUnicodeExact(a: string, b: string): boolean;
+export declare function equalTrimEnd(a: string, b: string): boolean;
+export declare function equalUnicodeTrimEnd(a: string, b: string): boolean;
+export declare function equalTrim(a: string, b: string): boolean;
+export declare function equalUnicodeTrim(a: string, b: string): boolean;
+export declare const autoRescueComparators: LineComparator[];
+export declare function prepareAutoRescueTarget(target: string): PreparedAutoRescueTarget;
+export declare function matchPreparedAutoRescueComparator(candidate: string, target: PreparedAutoRescueTarget): MatchComparatorName | undefined;
+export declare const permissiveComparators: LineComparator[];
+export declare function seekMatch(lines: string[], pattern: string[], start: number, eof?: boolean): SeekHit | undefined;
+export declare function seek(lines: string[], pattern: string[], start: number, eof?: boolean): number;
+export declare function list(lines: string[], pattern: string[], start: number, same: LineComparator): number[];
+export declare function sameRescueLine(a: string, b: string): boolean;
+export declare function prefix(old_lines: string[], new_lines: string[]): number;
+export declare function suffix(old_lines: string[], new_lines: string[], prefixLength: number): number;
+export declare function rescueByPrefixSuffix(lines: string[], old_lines: string[], new_lines: string[], start: number): RescueResult;
+export declare function score(a: string[], b: string[]): number;
+export declare function rescueByLcs(lines: string[], old_lines: string[], new_lines: string[], start: number): RescueResult;

package/dist/hooks/apply-patch/operations.d.ts

@@ -0,0 +1,3 @@
+export { parseValidatedPatch } from './execution-context';
+export { applyPreparedChanges, preparePatchChanges } from './prepared-changes';
+export { rewritePatch, rewritePatchText } from './rewrite';

package/dist/hooks/apply-patch/prepared-changes.d.ts

@@ -0,0 +1,17 @@
+import type { ApplyPatchRuntimeOptions, PreparedChange } from './types';
+export declare function preparePatchChanges(root: string, patchText: string, cfg: ApplyPatchRuntimeOptions, worktree?: string): Promise<PreparedChange[]>;
+/**
+ * Internal best-effort helper that applies the output of
+ * `preparePatchChanges()`: it snapshots all touched paths first and uses
+ * temp + rename for writes to regular files. It is not a universal multi-file
+ * transaction and is not perfect against concurrent external interference,
+ * but it avoids leaving silent partial states on normal apply failures.
+ *
+ * Contract: although it is exported for local tests/helpers, its expected
+ * input is the already prepared output of `preparePatchChanges()`. If it
+ * receives manual arrays, it revalidates the basic shape
+ * (types/text/normalized absolute paths) and filesystem invariants: it
+ * rejects updates/deletes/moves whose source does not exist, and add/move
+ * operations whose destination is already occupied.
+ */
+export declare function applyPreparedChanges(changes: PreparedChange[]): Promise<void>;

package/dist/hooks/apply-patch/resolution.d.ts

@@ -0,0 +1,19 @@
+import type { ApplyPatchRuntimeOptions, MatchHit, PatchChunk, ResolvedChunk } from './types';
+export declare function readFileLines(file: string): Promise<string[]>;
+export declare function resolveChunkStart(lines: string[], chunk: PatchChunk, start: number): number;
+export declare function locateChunk(lines: string[], file: string, chunk: PatchChunk, start: number, cfg: ApplyPatchRuntimeOptions): ResolvedChunk;
+export declare function applyHits(lines: string[], hits: MatchHit[], eol?: '\n' | '\r\n', hasFinalNewline?: boolean): string;
+export declare function resolveUpdateChunks(file: string, chunks: PatchChunk[], cfg: ApplyPatchRuntimeOptions): Promise<{
+    lines: string[];
+    resolved: ResolvedChunk[];
+    eol: '\n' | '\r\n';
+    hasFinalNewline: boolean;
+}>;
+export declare function deriveNewContentFromText(file: string, text: string, chunks: PatchChunk[], cfg: ApplyPatchRuntimeOptions): string;
+export declare function resolveUpdateChunksFromText(file: string, text: string, chunks: PatchChunk[], cfg: ApplyPatchRuntimeOptions): {
+    lines: string[];
+    resolved: ResolvedChunk[];
+    eol: '\n' | '\r\n';
+    hasFinalNewline: boolean;
+};
+export declare function deriveNewContent(file: string, chunks: PatchChunk[], cfg: ApplyPatchRuntimeOptions): Promise<string>;

package/dist/hooks/apply-patch/rewrite.d.ts

@@ -0,0 +1,7 @@
+import type { ApplyPatchRuntimeOptions } from './types';
+export type RewritePatchResult = {
+    patchText: string;
+    changed: boolean;
+};
+export declare function rewritePatch(root: string, patchText: string, cfg: ApplyPatchRuntimeOptions, worktree?: string): Promise<RewritePatchResult>;
+export declare function rewritePatchText(root: string, patchText: string, cfg: ApplyPatchRuntimeOptions, worktree?: string): Promise<string>;

package/dist/hooks/apply-patch/test-helpers.d.ts

@@ -0,0 +1,6 @@
+import type { ApplyPatchRuntimeOptions } from './types';
+export declare const DEFAULT_OPTIONS: ApplyPatchRuntimeOptions;
+export declare function createTempDir(prefix?: string): Promise<string>;
+export declare function writeFixture(root: string, relativePath: string, contents: string): Promise<void>;
+export declare function readText(root: string, relativePath: string): Promise<string>;
+export declare function applyPatch(root: string, patchText: string, cfg?: ApplyPatchRuntimeOptions): Promise<void>;

package/dist/hooks/apply-patch/types.d.ts

@@ -0,0 +1,80 @@
+export type ApplyPatchRuntimeOptions = {
+    prefixSuffix: boolean;
+    lcsRescue: boolean;
+};
+export type ApplyPatchErrorKind = 'blocked' | 'validation' | 'verification' | 'internal';
+export type ApplyPatchErrorCode = 'malformed_patch' | 'outside_workspace' | 'verification_failed' | 'internal_unexpected';
+export type ApplyPatchRescueStrategy = 'prefix/suffix' | 'lcs' | 'anchor';
+export type MatchComparatorName = 'exact' | 'unicode' | 'trim-end' | 'unicode-trim-end' | 'trim' | 'unicode-trim';
+export type PatchChunk = {
+    old_lines: string[];
+    new_lines: string[];
+    change_context?: string;
+    is_end_of_file?: boolean;
+};
+export type AddPatchHunk = {
+    type: 'add';
+    path: string;
+    contents: string;
+};
+export type DeletePatchHunk = {
+    type: 'delete';
+    path: string;
+};
+export type UpdatePatchHunk = {
+    type: 'update';
+    path: string;
+    move_path?: string;
+    chunks: PatchChunk[];
+};
+export type PatchHunk = AddPatchHunk | DeletePatchHunk | UpdatePatchHunk;
+export type ParsedPatch = {
+    hunks: PatchHunk[];
+};
+export type AddPreparedChange = {
+    type: 'add';
+    file: string;
+    text: string;
+};
+export type DeletePreparedChange = {
+    type: 'delete';
+    file: string;
+};
+export type UpdatePreparedChange = {
+    type: 'update';
+    file: string;
+    move?: string;
+    text: string;
+};
+export type PreparedChange = AddPreparedChange | DeletePreparedChange | UpdatePreparedChange;
+export type MatchHit = {
+    start: number;
+    del: number;
+    add: string[];
+};
+export type SeekHit = {
+    index: number;
+    comparator: MatchComparatorName;
+    exact: boolean;
+};
+export type ResolvedChunk = {
+    hit: MatchHit;
+    old_lines: string[];
+    canonical_old_lines: string[];
+    canonical_new_lines: string[];
+    canonical_change_context?: string;
+    resolved_is_end_of_file: boolean;
+    rewritten: boolean;
+    strategy?: ApplyPatchRescueStrategy;
+    matchComparator?: MatchComparatorName;
+};
+export type RescueResult = {
+    kind: 'miss';
+} | {
+    kind: 'ambiguous';
+    phase: 'prefix_suffix' | 'lcs';
+} | {
+    kind: 'match';
+    hit: MatchHit;
+};
+export type LineComparator = (a: string, b: string) => boolean;

package/dist/hooks/auto-update-checker/cache.d.ts

@@ -0,0 +1,11 @@
+interface AutoUpdateInstallContext {
+    installDir: string;
+    packageJsonPath: string;
+}
+export declare function resolveInstallContext(runtimePackageJsonPath?: string | null): AutoUpdateInstallContext | null;
+/**
+ * Prepares the current install root for a clean re-install of the target version.
+ * Returns the install directory to run `bun install` in.
+ */
+export declare function preparePackageUpdate(version: string, packageName?: string, runtimePackageJsonPath?: string | null): string | null;
+export {};

package/dist/hooks/auto-update-checker/checker.d.ts

@@ -0,0 +1,38 @@
+import type { CompatibleVersionResult, PluginEntryInfo } from './types';
+/**
+ * Extracts the update channel (latest, alpha, beta, etc.) from a version string.
+ * @param version The version or tag to analyze.
+ * @returns The channel name.
+ */
+export declare function extractChannel(version: string | null): string;
+/**
+ * Resolves the version of the plugin when running in local development mode.
+ */
+export declare function getLocalDevVersion(directory: string): string | null;
+/**
+ * Resolves the package.json for the currently running plugin bundle.
+ */
+export declare function getCurrentRuntimePackageJsonPath(currentModuleUrl?: string): string | null;
+/**
+ * Searches across all config locations to find the current installation entry for this plugin.
+ */
+export declare function findPluginEntry(directory: string): PluginEntryInfo | null;
+/**
+ * Resolves the installed version from node_modules, with memoization.
+ */
+export declare function getCachedVersion(): string | null;
+/**
+ * Safely updates a pinned version in the configuration file.
+ * It attempts to replace the exact plugin string to preserve comments and formatting.
+ */
+export declare function updatePinnedVersion(configPath: string, oldEntry: string, newVersion: string): boolean;
+/**
+ * Fetches the latest version for a specific channel from the NPM registry.
+ */
+export declare function getLatestVersion(channel?: string): Promise<string | null>;
+/**
+ * Resolves the newest version that is safe for the current install to use.
+ * Auto-update never crosses major versions; newer majors are surfaced as a
+ * manual migration notification instead.
+ */
+export declare function getLatestCompatibleVersion(currentVersion: string, channel?: string): Promise<CompatibleVersionResult>;

package/dist/hooks/auto-update-checker/constants.d.ts

@@ -0,0 +1,12 @@
+export declare const PACKAGE_NAME = "oh-my-opencode-serverlocal";
+export declare const NPM_REGISTRY_URL = "https://registry.npmjs.org/-/package/oh-my-opencode-serverlocal/dist-tags";
+export declare const NPM_PACKAGE_URL = "https://registry.npmjs.org/oh-my-opencode-serverlocal";
+export declare const NPM_FETCH_TIMEOUT = 5000;
+/** The directory used by OpenCode to cache node_modules for plugins. */
+export declare const CACHE_DIR: string;
+/** Path to this plugin's package.json within the OpenCode cache. */
+export declare const INSTALLED_PACKAGE_JSON: string;
+/** Primary OpenCode configuration file path (standard JSON). */
+export declare const USER_OPENCODE_CONFIG: string;
+/** Alternative OpenCode configuration file path (JSON with Comments). */
+export declare const USER_OPENCODE_CONFIG_JSONC: string;

package/dist/hooks/auto-update-checker/index.d.ts

@@ -0,0 +1,18 @@
+import type { PluginInput } from '@opencode-ai/plugin';
+import type { AutoUpdateCheckerOptions } from './types';
+/**
+ * Creates an OpenCode hook that checks for plugin updates when a new session is created.
+ * @param ctx The plugin input context.
+ * @param options Configuration options for the update checker.
+ * @returns A hook object for the session.created event.
+ */
+export declare function createAutoUpdateCheckerHook(ctx: PluginInput, options?: AutoUpdateCheckerOptions): {
+    event: ({ event }: {
+        event: {
+            type: string;
+            properties?: unknown;
+        };
+    }) => void;
+};
+export declare function getAutoUpdateInstallDir(): string;
+export type { AutoUpdateCheckerOptions } from './types';

package/dist/hooks/auto-update-checker/skill-sync.d.ts

@@ -0,0 +1,67 @@
+export interface SkillSyncResult {
+    installed: string[];
+    skippedExisting: string[];
+    failed: string[];
+    staged: string[];
+    adopted: string[];
+    customized: string[];
+}
+export interface SkillManifestEntry {
+    status: 'managed' | 'customized' | 'deleted' | 'conflict';
+    packageVersion: string;
+    sourceHash: string;
+    lastManagedHash: string;
+    lastSeenHash: string;
+    stagedPath?: string;
+    updatedAt: string;
+}
+export interface SkillsManifest {
+    schemaVersion: number;
+    updatedAt: string;
+    skills: Record<string, SkillManifestEntry>;
+}
+interface ManagedSkillSource {
+    name: string;
+    sourcePath: string;
+}
+interface SkillSyncOptions {
+    skills?: ManagedSkillSource[];
+}
+/**
+ * Hashes of historically managed versions of skills.
+ * When a release changes skill content, this table must be populated
+ * from the published npm package tarballs to allow upgrading existing users.
+ *
+ * How to populate:
+ * 1. Download previous releases of the npm package: `npm pack oh-my-opencode-slim@<version>`
+ * 2. Compute directory hash for each legacy skill directory inside the unpacked tarball:
+ *    `import { computeDirectoryHash } from './skill-sync';`
+ *    `const hash = computeDirectoryHash('path/to/extracted/package/src/skills/<skill-name>');`
+ * 3. Append the hash to the skill's string array below:
+ *    ```typescript
+ *    export const LEGACY_MANAGED_SKILL_HASHES: Record<string, string[]> = {
+ *      'simplify': ['hash1', 'hash2'],
+ *      'codemap': ['hash3']
+ *    };
+ *    ```
+ */
+export declare const LEGACY_MANAGED_SKILL_HASHES: Record<string, string[]>;
+/**
+ * Computes a deterministic SHA-256 hash of a directory's files.
+ */
+export declare function computeDirectoryHash(dirPath: string): string;
+/**
+ * Acquires a simple lock under .oh-my-opencode-slim.
+ * Avoids stealing active locks purely by time; writes owner metadata
+ * and only steals dead same-host pid if detectable.
+ */
+export declare function acquireLock(lockDir: string): boolean;
+/**
+ * Releases the lock.
+ */
+export declare function releaseLock(lockDir: string): void;
+/**
+ * Synchronizes bundled skills from the newly installed package root to OpenCode config skills directory.
+ */
+export declare function syncBundledSkillsFromPackage(packageRoot: string, options?: SkillSyncOptions): SkillSyncResult;
+export {};

package/dist/hooks/auto-update-checker/types.d.ts

@@ -0,0 +1,34 @@
+import type { CompanionConfig } from '../../config/schema';
+export interface NpmDistTags {
+    latest: string;
+    [key: string]: string;
+}
+export interface NpmPackageMetadata {
+    'dist-tags'?: NpmDistTags;
+    versions?: Record<string, unknown>;
+}
+export interface CompatibleVersionResult {
+    latestVersion: string | null;
+    latestMajorVersion: string | null;
+    blockedByMajor: boolean;
+    unsafeReason?: 'unparseable-current-version';
+}
+export interface OpencodeConfig {
+    plugin?: unknown[];
+    [key: string]: unknown;
+}
+export interface PackageJson {
+    version: string;
+    name?: string;
+    [key: string]: unknown;
+}
+export interface AutoUpdateCheckerOptions {
+    autoUpdate?: boolean;
+    companion?: CompanionConfig;
+}
+export interface PluginEntryInfo {
+    entry: string;
+    isPinned: boolean;
+    pinnedVersion: string | null;
+    configPath: string;
+}

package/dist/hooks/chat-headers.d.ts

@@ -0,0 +1,16 @@
+import type { PluginInput, ProviderContext } from '@opencode-ai/plugin';
+import type { Model, UserMessage } from '@opencode-ai/sdk';
+interface ChatHeadersInput {
+    sessionID: string;
+    model: Model;
+    provider: ProviderContext;
+    message: UserMessage;
+}
+interface ChatHeadersOutput {
+    headers: Record<string, string>;
+}
+export declare function __resetInternalMarkerCacheForTesting(): void;
+export declare function createChatHeadersHook(ctx: PluginInput): {
+    'chat.headers': (input: ChatHeadersInput, output: ChatHeadersOutput) => Promise<void>;
+};
+export {};

package/dist/hooks/command-hook-utils.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Register a command hook in the OpenCode config if it doesn't already exist.
+ * Returns true if the command was registered, false if it already existed.
+ */
+export declare function registerCommandHook(opencodeConfig: Record<string, unknown>, commandName: string, template: string, description: string): boolean;

package/dist/hooks/deepwork/index.d.ts

@@ -0,0 +1,13 @@
+export declare function createDeepworkCommandHook(): {
+    registerCommand: (config: Record<string, unknown>) => void;
+    handleCommandExecuteBefore: (input: {
+        command: string;
+        sessionID: string;
+        arguments: string;
+    }, output: {
+        parts: Array<{
+            type: string;
+            text?: string;
+        }>;
+    }) => Promise<void>;
+};

package/dist/hooks/delegate-task-retry/hook.d.ts

@@ -0,0 +1,8 @@
+import type { PluginInput } from '@opencode-ai/plugin';
+export declare function createDelegateTaskRetryHook(_ctx: PluginInput): {
+    'tool.execute.after': (input: {
+        tool: string;
+    }, output: {
+        output: unknown;
+    }) => Promise<void>;
+};

package/dist/hooks/delegate-task-retry/patterns.d.ts

@@ -0,0 +1,11 @@
+export interface DelegateTaskErrorPattern {
+    pattern: string;
+    errorType: string;
+    fixHint: string;
+}
+export declare const DELEGATE_TASK_ERROR_PATTERNS: DelegateTaskErrorPattern[];
+export interface DetectedError {
+    errorType: string;
+    originalOutput: string;
+}
+export declare function detectDelegateTaskError(output: string): DetectedError | null;

package/dist/hooks/filter-available-skills/index.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Filter available_skills block based on the current agent's permission.skill rules.
+ * OpenCode core injects `<available_skills>` globally, so this hook rewrites that
+ * block before the prompt is sent.
+ */
+import type { PluginInput } from '@opencode-ai/plugin';
+import { type PluginConfig } from '../../config';
+type SkillRule = 'allow' | 'ask' | 'deny';
+declare function filterAvailableSkillsText(text: string, permissionRules: Record<string, SkillRule>): string;
+/**
+ * Creates the experimental.chat.messages.transform hook for filtering available skills.
+ * This hook runs right before sending to API, so it doesn't affect UI display.
+ */
+export declare function createFilterAvailableSkillsHook(_ctx: PluginInput, config: PluginConfig): {
+    'experimental.chat.messages.transform': (_input: Record<string, never>, output: {
+        messages?: unknown;
+    }) => Promise<void>;
+};
+export { filterAvailableSkillsText };