# stanp-opencode

OpenCode V2 plugin providing a `coordinate` agent and fast/good/deep worker pairs, with GPT routing or explicit custom model assignments. Your default agent and the built-in `build` agent remain unchanged.

## Install the latest release

Requires **OpenCode V2 2.0.2** (`opencode2`), **Bun 1.3.14+**, Bash, curl, jq, and `sha256sum` (Linux/WSL). The native plugin API is pinned to `@opencode/plugin@2.0.2`; use the matching stable OpenCode release.

Run the installer without sudo:

```sh
curl -fsSL https://git.krtss.de/StanPonomarev/stanp-opencode/raw/branch/main/install.sh | bash
```

From a checkout, run `bash install.sh` directly. Rerun the same script to upgrade to the latest published, non-prerelease Gitea release.

The installer downloads `stanp-opencode.tgz` and its SHA-256 checksum, verifies and extracts the self-contained archive, then activates the plugin only after importing and checking both the native V2 server and TUI exports. Download, extraction, and validation failures leave the previous active plugin untouched. The checksum detects corruption; it is not a signature independent of the release server.

Installation defaults to `~/.config/opencode` and respects `XDG_CONFIG_HOME`. Override it explicitly when needed:

```sh
OPENCODE_CONFIG_DIR=/path/to/opencode-config bash install.sh
```

The installer atomically replaces the package directory at `plugins/stanp-opencode` and adds its default GPT configuration to `opencode.json`. Existing unrelated JSON settings and `opencode.jsonc` are preserved. It does not create symlinks, install package dependencies, install OpenCode itself, or configure provider credentials.

Restart `opencode2` after installation (or `opencode2 service restart` for an existing service). Connect your provider, then select `coordinate` in the agent picker. The default configuration uses OpenAI GPT models; agents are only enabled when the required models are available.

## Install from a local checkout

To build and install the current checkout instead of downloading a release, install Bash, jq, and **Bun 1.3.14+**, then run:

```sh
bash /path/to/stanp-opencode/install-local.sh
```

The script may be invoked from any working directory. It runs `bun install --frozen-lockfile` (which may access the package registry) and `bun run build` in the checkout containing the script on every run. It validates the native V2 and TUI bundles, copies them into the same installed package layout as the release installer, and preserves existing plugin options, unrelated `opencode.json` settings, and `opencode.jsonc`. Dependency installation, build, validation, and configuration parsing failures leave the currently installed plugin and configuration untouched.

The configuration directory defaults to `~/.config/opencode`, respects `XDG_CONFIG_HOME`, and can be overridden explicitly:

```sh
OPENCODE_CONFIG_DIR=/path/to/opencode-config bash /path/to/stanp-opencode/install-local.sh
```

Restart `opencode2` after installation (or `opencode2 service restart`).

## Configure

See [GPT configuration](examples/gpt.opencode.jsonc) and [custom model assignments](examples/custom.opencode.jsonc). When using the installer, point the example's plugin package entry at the installed package directory rather than the unpublished npm package name. Configured local plugin paths must be directories; pointing at `plugins/stanp-opencode.js` causes OpenCode to reject that configured entry and auto-load the file without its options:

```jsonc
{
    "plugins": [
        {
            "package": "./plugins/stanp-opencode",
            "options": {
                "mode": "gpt",
                "provider": "openai",
                "lunaPriority": true,
            },
        },
    ],
}
```

This relative path assumes the configuration file is in the selected global config directory. Use an absolute path in project configuration. Remove any old V1 `plugin` entry when migrating; V2 uses `plugins`. `lunaPriority` requests priority service where supported and can increase cost; set it to `false` to use the provider default.

The plugin supplies session-local `todoread` and `todowrite` tools when no other plugin provides them. In OpenCode V2 2.0.2, custom tools cannot open permission prompts: an `ask` or `deny` rule blocks these todo tools rather than bypassing the rule. Explicitly allow them if you want to use them.

When an MCP server named `codegraph` is already configured, its tools are exposed directly to `coordinate` and retain the built-in `build` agent's matching allow, ask, and deny rules. The plugin does not configure or start a missing server, and no other MCP server is exposed this way.

## ChatGPT subscription quota

When OpenCode's active `openai` integration uses ChatGPT OAuth, the plugin reads the same account usage endpoint as Codex. It queries before a session's first model request (including a resumed session and child sessions), about every 60 seconds, and when session execution completes, fails, is interrupted, or becomes idle. API-key connections and other providers make no quota requests and show no quota UI.

The automatically loaded TUI plugin adds each valid window returned by OpenAI to the sidebar, including named/model-specific limits. Absent or malformed windows are hidden. OpenAI's current Codex contract does not provide a per-window "informational" or "not enforced" flag, so an explicitly returned five-hour window is shown for every plan, including Pro; silently discarding it based only on plan and duration would misrepresent the authoritative response. Each line shows the latest **remaining** account quota and the estimated **percentage points** consumed while the root session family is active. A root session and all of its subagents share one baseline, so child activity is included without counting the same account delta once per child.

The estimate is based on changes in OpenAI's account-wide percentages, not token accounting. Concurrent ChatGPT/Codex use outside the session can therefore skew it upward. If multiple independent root sessions run concurrently, the account delta is inherently indivisible and may be attributed to each active root. Polling can miss usage immediately before a reset, and OpenAI may round the source percentages. Inactive session totals stay frozen, and a resumed family refreshes before becoming active so unrelated idle-time usage is excluded. Last successful values provide the baseline through temporary request failures. Tokens and account identifiers are never exposed through plugin RPC or written to plugin storage; only quota values, session IDs, and a one-way account fingerprint are persisted.

## Uninstall

Remove `plugins/stanp-opencode` from the selected config directory and remove any explicit configuration entry for it, then restart OpenCode.