oh-my-opencode-slim

clonedeps is a bundled OpenCode workflow skill designed to clone a small set of critical dependency source repositories into a local, git-ignored workspace. This allows AI agents to read library internals directly to improve code understanding and task execution.

Key Characteristics:

• Orchestrator-managed: The orchestrator handles git and filesystem operations, while delegating source discovery and URL/ref resolution to @librarian.
• Safety-first: Instead of using a brittle cross-ecosystem script, the workflow requires approval before performing cloning operations.
• Local Workspace: Cloned repositories are stored in a dedicated directory that is ignored by your project's git configuration.

oh-my-opencode-slim is an OpenCode plugin that implements a specialist-agent operating model. Its core responsibilities include:

• Defining orchestrator and specialist agent factories with permission policies.
• Loading layered plugin configuration and per-agent permissions.
• Exposing additional tools and MCP (Model Context Protocol) integrations.
• Managing background job-board orchestration and terminal multiplexer visualization.
• Injecting workflow-enforcement hooks and runtime command handlers.
• Shipping install-time skills and a bootstrap CLI.

The Codemap skill is a custom tool designed to help agents build a high-quality mental model of an unfamiliar codebase. It selects relevant files using LLM judgment, generates hierarchical codemap templates, and tracks changes over time using hashes.

Codemap is automatically installed by the oh-my-opencode-slim installer when custom skills are enabled.

The clonedeps skill allows OpenCode to clone important dependency source code into an ignored local workspace (.slim/clonedeps/repos/). This enables the agent to inspect library internals, understand SDK/framework behavior from source, and debug implementation details that are not available via standard documentation or APIs.

When to use:

• When you need to understand how a specific dependency works internally.
• When debugging library implementation details.
• When you need to see the actual source code of a framework or SDK to solve a task.

Note: Do not use this for ordinary API or documentation questions; use @librarian for those instead.

The plugin is built using several key architectural patterns to integrate with OpenCode:

• Plugin Pattern: Uses a single exported plugin function to register agents, tools, and MCPs.
• Facade Pattern: index.ts acts as a central facade composing agents, tools, MCPs, hooks, and the multiplexer.
• Observer Pattern: Uses OpenCode's event system to respond to session lifecycles, message updates, and tool executions.
• Strategy Pattern: Employs ForegroundFallbackManager for runtime model selection and fallback.
• Singleton Pattern: Uses MultiplexerSessionManager to maintain a single instance for task session management.

The multiplexer system provides a unified interface to manage terminal panes for OpenCode agent sessions across different terminal multiplexers. It supports tmux, zellij, herdr, cmux, and kitty.

Key implementations include:

• TmuxMultiplexer: Uses tmux CLI.
• ZellijMultiplexer: Uses the zellij plugin API.
• HerdrMultiplexer: Uses herdr CLI.
• KittyMultiplexer: Uses kitten @ CLI commands.
• CmuxMultiplexer: Uses the cmux CLI via UUID surface implementation.

The simplify skill provides a behavior-preserving refactoring contract designed for clarity-focused, low-risk code cleanup. It operates through an executable prompt specification defined in SKILL.md which enforces four explicit phases:

1. Pre-change understanding: Analyzing the code before any edits.
2. Simplification candidate selection: Identifying specific areas for improvement.
3. Incremental transformation and verification: Applying changes in small steps and verifying them.
4. Final review checklist: A concluding validation step.

This skill is declarative and consumed by the OpenCode skill executor; it does not require local runtime state machines or helper scripts.

The project uses a metadata-driven approach for OpenCode custom skills. Skills are defined in a central registry and categorized by their purpose and access scope.

General-purpose skills (available for broad reuse):

• codemap/: Repository mapping and codebase documentation.
• clonedeps/: Dependency source mirroring and inspection.
• simplify/: Readability and maintainability guidance.

Orchestrator-only skills (reserved for heavy or high-risk workflows):

• deepwork/: Heavy coding sessions and risky refactors.
• verification-planning/: Project-specific evidence planning.
• reflect/: Learning from repeated work.
• worktrees/: Safe Git worktree lanes for isolated work.
• oh-my-opencode-slim/: Plugin configuration and self-improvement.

The OpenCode plugin system uses a Tool Factory Pattern. Each tool is implemented as a factory function that returns a ToolDefinition record compatible with the @opencode-ai/plugin SDK.

Key characteristics:

• Encapsulation: Tool logic and dependencies are isolated.
• Composition: Tools are composed in src/tools/index.ts.
• Testability: Factories accept dependencies as parameters for easy mocking.
• Type Safety: All tool arguments are validated at runtime using Zod schemas.