opencode-muse 0.0.0-stage → 0.1.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Pau Garcia Quiles
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,122 @@
-# Temporary Holding Version
+# opencode-muse
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+An [OpenCode](https://opencode.ai) plugin that lets OpenCode (and therefore
+[OpenChamber](https://openchamber.dev/)) use a Muse Code subscription with
+auth and inference staying entirely inside the official Muse Code CLI
+(`muse serve`, via `@muse-code/sdk`).
+
+No subscription credential is ever extracted, cached, or injected into
+OpenCode.
+
+## Installation
+
+Add the published package to your project-level `opencode.jsonc` (or
+`opencode.json`):
+
+```jsonc
+{
+  "$schema": "https://opencode.ai/config.json",
+  "plugins": ["opencode-muse@0.1.1"],
+}
+```
+
+OpenCode downloads and manages the public package, so users do not need to run
+`npm install` or create an npm account. Sign in with `muse login` (see below),
+restart OpenCode or OpenChamber if it was already running, and choose a Muse
+model.
+
+**Compatibility fallback:** Current OpenCode V2 documentation supports package
+entries in `plugins`, but our earlier probes did not observe config-array
+loading on OpenCode 2.1.3; the embedded OpenCode 2.0.32 flow was verified with a
+project-local plugin file. If your OpenCode version ignores the package entry,
+install the package locally and add this file under `.opencode/plugins/`:
+
+```sh
+npm install opencode-muse
+mkdir -p .opencode/plugins
+cat > .opencode/plugins/opencode-muse.js <<'EOF'
+export { default } from "opencode-muse";
+EOF
+```
+
+The locally packed package passed provider discovery and a text-turn smoke
+test. Muse models and a text turn were also confirmed in OpenChamber after
+restarting it. The verified Muse CLI and SDK version is 1.4.12.
+
+## Authentication
+
+Sign in through the official Muse Code CLI before using the provider:
+
+```sh
+muse login
+```
+
+OpenChamber's current provider UI does not expose OpenCode plugin `command`
+authentication methods, so this plugin does not promise a sign-in button. It
+uses the Muse CLI's existing account/configuration through `muse serve`; it
+never reads Muse credential files, exports tokens, or changes subscription
+mode. If the CLI has no usable model catalog, the provider remains a disabled
+setup placeholder rather than advertising a model that will fail on use.
+
+## Features
+
+- Use Muse Code models from OpenCode or OpenChamber after adding the package to
+  your OpenCode plugin configuration.
+- Keep Muse sign-in and inference inside the official Muse CLI; the plugin
+  never copies or stores your subscription credentials.
+- Continue text conversations in a mapped Muse session, including resuming
+  supported sessions and replaying available session updates after reconnects.
+- Attach supported images (PNG, JPEG, GIF, WebP) and videos (MP4, MOV) to a
+  Muse turn.
+- Let Muse run its own agent and tools, while the plugin prevents overlapping
+  writes to the same workspace.
+
+## Current limitations
+
+- **Approvals and questions:** OpenCode/OpenChamber cannot yet show Muse's exact
+  approval choices or all structured questions. If Muse asks for one, the
+  plugin stops safely rather than guessing or approving on your behalf. See
+  [#6](https://github.com/pgquiles/opencode-muse/issues/6) and
+  [#22](https://github.com/pgquiles/opencode-muse/issues/22).
+- **Files and response formats:** The bridge accepts text, PNG/JPEG/GIF/WebP
+  images, and MP4/MOV video. Audio and PDF attachments are not supported.
+  Strict JSON output and some OpenCode generation settings (such as
+  temperature and token limits) are not supported; requests that require a
+  specific OpenCode tool are rejected. Muse's separate CLI transcription and
+  JSON-output commands are not exposed as OpenCode features.
+- **Tools and agent instructions:** Muse runs its own agent and tools; OpenCode
+  tools are not executed for a Muse turn. Recognized custom-agent instructions
+  may be forwarded, but Muse otherwise follows its own workspace rules.
+- **Rewind and session names:** Rewind/fork is unavailable on the currently
+  tested Linux Muse runtime, and custom session names may not work. Start a new
+  session after rewinding or editing the OpenCode conversation. Rewinding does
+  not undo files Muse changed. See
+  [#20](https://github.com/pgquiles/opencode-muse/issues/20).
+- **Recovery after missed events:** Basic session resume and cursor replay have
+  been tested, but recovery from a real Muse event gap has only been tested
+  with a simulated gap. See
+  [#23](https://github.com/pgquiles/opencode-muse/issues/23).
+- **Muse CLI compatibility:** The plugin is pinned and verified with Muse CLI
+  and SDK 1.4.12. A protocol/schema mismatch fails closed rather than risking
+  an incompatible session; broader version-compatibility policy is tracked in
+  [#21](https://github.com/pgquiles/opencode-muse/issues/21).
+- **Billing and simultaneous work:** Pay-as-you-go behavior has not yet been
+  tested. The plugin also allows only one active writer per workspace, so a
+  new turn may be reported as busy while another is still finishing.
+
+## Credits and references
+
+- [opencode-claude](https://github.com/openchamber/opencode-claude) — a
+  reference for OpenCode v2 plugin setup, model/session hooks, bridge
+  lifecycle, and the local-proxy fallback. This plugin uses Muse-native tools;
+  auth and inference stay in the Muse CLI.
+- [muse-code-sdk](https://github.com/meta-models/muse-code-sdk) — official
+  Muse Code SDK and the Muse Session Protocol used by this plugin.
+- [Paseo's Muse Code integration](https://paseo.sh/docs/muse-code) — a
+  protocol-level reference implementation.
+
+## Related projects
+
+- [opencode-muse-auth](https://github.com/TheStreamCode/opencode-muse-auth) is another credential-extraction/direct-API approach; see its [issue #12](https://github.com/TheStreamCode/opencode-muse-auth/issues/12) for its discussion of subscription-term concerns.
+- [opencode-muse-code](https://github.com/swalker326/opencode-muse-code) is an unofficial direct-API alternative. It reads the Muse CLI login, requests an API key from Meta, and sends model requests to Meta's API from OpenCode instead of routing inference through `muse serve` and MSP. Its subscription eligibility is separate from this plugin's CLI-mediated approach and has not been established by this project.
+- [Official Muse Code documentation](https://dev.meta.ai/docs/quickstart#agent-setup) describes using Muse models in OpenCode through the Meta API.

package/dist/catalog.d.ts

@@ -0,0 +1,47 @@
+import type { Model } from "@opencode/plugin";
+import type { MuseModelSelection } from "./types.js";
+export declare const MUSE_PROVIDER_ID = "muse";
+export interface MuseCatalogRow {
+    providerId: string;
+    profileId: string | null;
+    modelId: string;
+    displayLabel: string;
+    contextLimit: number | null;
+    outputLimit: number | null;
+    releaseDate: string | null;
+    isActive: boolean;
+    isDefault: boolean;
+    defaultReasoningEffort?: string;
+    variants?: string[] | "unknown";
+    reasoningEffortVariants?: Array<{
+        tier: string;
+        description?: string;
+    }>;
+    cost: {
+        cached: string;
+        currency: string | null;
+        input: string;
+        output: string;
+    } | null;
+}
+export interface MuseCatalogSnapshot {
+    providerId: string;
+    profileId: string | null;
+    source: string;
+    models: MuseCatalogRow[];
+}
+export declare const fallbackCatalog: Model.Info[];
+export declare function openCodeModelId(profileId: string | null, modelId: string): string;
+export declare function buildOpenCodeCatalog(museCatalog: MuseCatalogSnapshot | undefined, fallback?: readonly Model.Info[]): Model.Info[];
+export declare function buildMuseModelIndex(museCatalog: MuseCatalogSnapshot): Map<string, MuseModelSelection>;
+export declare class CatalogCache {
+    private readonly fallback;
+    private currentModels;
+    private currentSelectionIndex;
+    private live;
+    constructor(fallback?: readonly Model.Info[]);
+    get models(): Model.Info[];
+    get selectionIndex(): ReadonlyMap<string, MuseModelSelection>;
+    get hasLiveCatalog(): boolean;
+    refresh(fetchCatalog: () => Promise<MuseCatalogSnapshot>, reload: () => Promise<void>): Promise<boolean>;
+}

package/dist/catalog.js

@@ -0,0 +1,159 @@
+export const MUSE_PROVIDER_ID = "muse";
+const FALLBACK_ID = "setup-required";
+export const fallbackCatalog = [
+    {
+        id: FALLBACK_ID,
+        modelID: FALLBACK_ID,
+        providerID: MUSE_PROVIDER_ID,
+        name: "Muse setup required — run muse login, then refresh providers",
+        capabilities: { tools: false, input: ["text"], output: ["text"] },
+        variants: [],
+        time: { released: 0 },
+        cost: [],
+        status: "deprecated",
+        enabled: false,
+        limit: { context: 1, output: 1 },
+    },
+];
+export function openCodeModelId(profileId, modelId) {
+    const profileKey = profileId === null ? "no-profile" : `profile-${encodeURIComponent(profileId)}`;
+    return `muse-${profileKey}-model-${encodeURIComponent(modelId)}`;
+}
+function parseCost(value) {
+    if (!/^(?:\d+)(?:\.\d+)?$/.test(value))
+        return undefined;
+    const parsed = Number(value);
+    return Number.isFinite(parsed) && parsed >= 0 ? parsed : undefined;
+}
+function releasedAt(releaseDate) {
+    if (releaseDate === null)
+        return 0;
+    const timestamp = Date.parse(releaseDate);
+    return Number.isFinite(timestamp) && timestamp >= 0 ? timestamp : 0;
+}
+function costInfo(row) {
+    if (!row.cost || row.cost.currency !== "USD")
+        return [];
+    const input = parseCost(row.cost.input);
+    const output = parseCost(row.cost.output);
+    const cached = parseCost(row.cost.cached);
+    if (input === undefined || output === undefined || cached === undefined)
+        return [];
+    return [{ input, output, cache: { read: cached, write: 0 } }];
+}
+function modelInfo(row) {
+    const limitsKnown = Number.isInteger(row.contextLimit)
+        && row.contextLimit !== null
+        && row.contextLimit > 0
+        && Number.isInteger(row.outputLimit)
+        && row.outputLimit !== null
+        && row.outputLimit > 0;
+    const effortVariants = Array.isArray(row.variants) ? row.variants : [];
+    return {
+        id: openCodeModelId(row.profileId, row.modelId),
+        modelID: row.modelId,
+        providerID: MUSE_PROVIDER_ID,
+        name: limitsKnown ? row.displayLabel : `${row.displayLabel} (limits unavailable)`,
+        capabilities: {
+            tools: true,
+            input: ["text", "image", "video"],
+            output: ["text"],
+        },
+        variants: effortVariants.map((id) => ({ id, settings: {} })),
+        time: { released: releasedAt(row.releaseDate) },
+        cost: costInfo(row),
+        status: limitsKnown ? "active" : "deprecated",
+        enabled: limitsKnown,
+        limit: {
+            context: limitsKnown ? row.contextLimit : 1,
+            output: limitsKnown ? row.outputLimit : 1,
+        },
+    };
+}
+export function buildOpenCodeCatalog(museCatalog, fallback = fallbackCatalog) {
+    if (museCatalog?.source !== "providerCatalog" || museCatalog.models.length === 0)
+        return [...fallback];
+    const rows = museCatalog.models.filter((row) => row.providerId.length > 0 && row.modelId.length > 0 && row.displayLabel.length > 0);
+    if (rows.length === 0)
+        return [...fallback];
+    return rows.map(modelInfo);
+}
+export function buildMuseModelIndex(museCatalog) {
+    const result = new Map();
+    if (museCatalog.source !== "providerCatalog")
+        return result;
+    for (const row of museCatalog.models) {
+        if (!row.providerId || !row.modelId || !row.displayLabel)
+            continue;
+        result.set(openCodeModelId(row.profileId, row.modelId), {
+            providerId: row.providerId,
+            profileId: row.profileId,
+            modelId: row.modelId,
+            isActive: row.isActive,
+            isDefault: row.isDefault,
+            ...(row.defaultReasoningEffort !== undefined ? { defaultReasoningEffort: row.defaultReasoningEffort } : {}),
+            variantsKnown: Array.isArray(row.variants),
+            variants: Array.isArray(row.variants) ? [...row.variants] : [],
+        });
+    }
+    return result;
+}
+export class CatalogCache {
+    fallback;
+    currentModels;
+    currentSelectionIndex = new Map();
+    live = false;
+    constructor(fallback = fallbackCatalog) {
+        this.fallback = fallback;
+        this.currentModels = [...fallback];
+    }
+    get models() {
+        return this.currentModels;
+    }
+    get selectionIndex() {
+        return this.currentSelectionIndex;
+    }
+    get hasLiveCatalog() {
+        return this.live;
+    }
+    async refresh(fetchCatalog, reload) {
+        let snapshot;
+        try {
+            snapshot = await fetchCatalog();
+        }
+        catch {
+            return false;
+        }
+        if (snapshot.source !== "providerCatalog" || snapshot.models.length === 0)
+            return false;
+        let models;
+        let index;
+        try {
+            models = buildOpenCodeCatalog(snapshot, this.fallback);
+            index = buildMuseModelIndex(snapshot);
+        }
+        catch {
+            return false;
+        }
+        if (index.size === 0 || models.length === this.fallback.length && models.every((model) => model.id === FALLBACK_ID)) {
+            return false;
+        }
+        const previousModels = this.currentModels;
+        const previousIndex = this.currentSelectionIndex;
+        const previousLive = this.live;
+        // Transform callbacks read this cache, so mutate it before provider.reload().
+        this.currentModels = models;
+        this.currentSelectionIndex = index;
+        this.live = true;
+        try {
+            await reload();
+            return true;
+        }
+        catch {
+            this.currentModels = previousModels;
+            this.currentSelectionIndex = previousIndex;
+            this.live = previousLive;
+            return false;
+        }
+    }
+}

package/dist/errors.d.ts

@@ -0,0 +1,92 @@
+export type MuseBridgeErrorCode = "MUSE_HOST_START_FAILED" | "MUSE_STARTUP_TIMEOUT" | "MUSE_COMMAND_TIMEOUT" | "MUSE_REQUEST_TIMEOUT" | "MUSE_COMMAND_REJECTED" | "MUSE_PROTOCOL_ERROR" | "MUSE_TRANSPORT_ERROR" | "MUSE_HOST_CLOSED" | "MUSE_REGISTRY_ERROR" | "MUSE_REGISTRY_STORAGE_ERROR" | "MUSE_WORKSPACE_BUSY" | "MUSE_WORKSPACE_LOCK_CORRUPT" | "MUSE_TURN_FAILED" | "MUSE_TURN_UNQUEUED" | "MUSE_UNSUPPORTED_REQUEST" | "MUSE_UNSUPPORTED_INPUT" | "MUSE_RECOVERY_CHOICE_REQUIRED" | "MUSE_TRANSCRIPT_DIVERGED";
+/** Safe plugin error: never attach raw CLI stderr, MSP text, prompts, or payloads. */
+export declare class MuseBridgeError extends Error {
+    readonly code: MuseBridgeErrorCode;
+    readonly retryable?: boolean | undefined;
+    constructor(code: MuseBridgeErrorCode, message: string, retryable?: boolean | undefined);
+}
+export declare class MspStartupTimeoutError extends MuseBridgeError {
+    readonly timeoutMs: number;
+    constructor(timeoutMs: number);
+}
+export declare class MspCommandTimeoutError extends MuseBridgeError {
+    readonly method: string;
+    readonly timeoutMs: number;
+    readonly outcomeMayBeUnknown = true;
+    constructor(method: string, timeoutMs: number);
+}
+export declare class MspRequestTimeoutError extends MuseBridgeError {
+    readonly method: string;
+    readonly timeoutMs: number;
+    constructor(method: string, timeoutMs: number);
+}
+export declare class MspCommandRejectedError extends MuseBridgeError {
+    readonly method: string;
+    readonly mspCode: number;
+    readonly mspKind: string;
+    constructor(method: string, mspCode: number, mspKind: string, retryable?: boolean);
+}
+export declare class MspProtocolError extends MuseBridgeError {
+    readonly method?: string | undefined;
+    constructor(method?: string | undefined);
+}
+export declare class MspTransportError extends MuseBridgeError {
+    readonly method?: string | undefined;
+    constructor(method?: string | undefined);
+}
+export declare class MspHostClosedError extends MuseBridgeError {
+    constructor();
+}
+export declare class MspHostStartError extends MuseBridgeError {
+    readonly reason: "spawn-failed" | "host-exited" | "initialize-rejected" | "unknown";
+    constructor(reason: "spawn-failed" | "host-exited" | "initialize-rejected" | "unknown");
+}
+export declare class MspInitializeRejectedError extends MuseBridgeError {
+    readonly mspCode: number;
+    readonly mspKind: string;
+    constructor(mspCode: number, mspKind: string);
+}
+export declare class MspSchemaMismatchError extends MuseBridgeError {
+    readonly pinned: string;
+    readonly served: string;
+    constructor(pinned: string, served: string);
+}
+export declare class RegistryValidationError extends MuseBridgeError {
+    constructor();
+}
+export declare class RegistryCorruptError extends MuseBridgeError {
+    constructor();
+}
+export declare class RegistryStorageError extends MuseBridgeError {
+    constructor();
+}
+export declare class RegistryWorkspaceMismatchError extends MuseBridgeError {
+    constructor();
+}
+export declare class WorkspaceBusyError extends MuseBridgeError {
+    constructor();
+}
+export declare class WorkspaceLockCorruptError extends MuseBridgeError {
+    constructor();
+}
+export declare class MuseTurnFailedError extends MuseBridgeError {
+    readonly turnErrorKind: string;
+    constructor(turnErrorKind: string, retryable: boolean | undefined);
+}
+export declare class MuseTurnUnqueuedError extends MuseBridgeError {
+    constructor();
+}
+export declare class MuseUnsupportedRequestError extends MuseBridgeError {
+    readonly requestKind: string;
+    constructor(requestKind: string);
+}
+export declare class MuseUnsupportedInputError extends MuseBridgeError {
+    readonly inputKind: string;
+    constructor(inputKind: string);
+}
+export declare class MuseRecoveryChoiceRequiredError extends MuseBridgeError {
+    constructor();
+}
+export declare class MuseTranscriptDivergedError extends MuseBridgeError {
+    constructor();
+}

package/dist/errors.js

@@ -0,0 +1,181 @@
+/** Safe plugin error: never attach raw CLI stderr, MSP text, prompts, or payloads. */
+export class MuseBridgeError extends Error {
+    code;
+    retryable;
+    constructor(code, message, retryable) {
+        super(message);
+        this.code = code;
+        this.retryable = retryable;
+        this.name = "MuseBridgeError";
+    }
+}
+export class MspStartupTimeoutError extends MuseBridgeError {
+    timeoutMs;
+    constructor(timeoutMs) {
+        super("MUSE_STARTUP_TIMEOUT", `Muse host did not initialize within ${timeoutMs}ms`, true);
+        this.timeoutMs = timeoutMs;
+        this.name = "MspStartupTimeoutError";
+    }
+}
+export class MspCommandTimeoutError extends MuseBridgeError {
+    method;
+    timeoutMs;
+    outcomeMayBeUnknown = true;
+    constructor(method, timeoutMs) {
+        super("MUSE_COMMAND_TIMEOUT", `Muse command ${method} timed out; its outcome may be unknown`, false);
+        this.method = method;
+        this.timeoutMs = timeoutMs;
+        this.name = "MspCommandTimeoutError";
+    }
+}
+export class MspRequestTimeoutError extends MuseBridgeError {
+    method;
+    timeoutMs;
+    constructor(method, timeoutMs) {
+        super("MUSE_REQUEST_TIMEOUT", `Muse request ${method} timed out`, true);
+        this.method = method;
+        this.timeoutMs = timeoutMs;
+        this.name = "MspRequestTimeoutError";
+    }
+}
+export class MspCommandRejectedError extends MuseBridgeError {
+    method;
+    mspCode;
+    mspKind;
+    constructor(method, mspCode, mspKind, retryable) {
+        super("MUSE_COMMAND_REJECTED", `Muse rejected command ${method} (${mspKind}, ${mspCode})`, retryable);
+        this.method = method;
+        this.mspCode = mspCode;
+        this.mspKind = mspKind;
+        this.name = "MspCommandRejectedError";
+    }
+}
+export class MspProtocolError extends MuseBridgeError {
+    method;
+    constructor(method) {
+        super("MUSE_PROTOCOL_ERROR", method ? `Muse protocol error during ${method}` : "Muse protocol error", false);
+        this.method = method;
+        this.name = "MspProtocolError";
+    }
+}
+export class MspTransportError extends MuseBridgeError {
+    method;
+    constructor(method) {
+        super("MUSE_TRANSPORT_ERROR", method ? `Muse transport failed during ${method}` : "Muse transport failed", true);
+        this.method = method;
+        this.name = "MspTransportError";
+    }
+}
+export class MspHostClosedError extends MuseBridgeError {
+    constructor() {
+        super("MUSE_HOST_CLOSED", "Muse host is closed", false);
+        this.name = "MspHostClosedError";
+    }
+}
+export class MspHostStartError extends MuseBridgeError {
+    reason;
+    constructor(reason) {
+        super("MUSE_HOST_START_FAILED", `Muse host failed to start (${reason})`, reason !== "initialize-rejected");
+        this.reason = reason;
+        this.name = "MspHostStartError";
+    }
+}
+export class MspInitializeRejectedError extends MuseBridgeError {
+    mspCode;
+    mspKind;
+    constructor(mspCode, mspKind) {
+        super("MUSE_HOST_START_FAILED", `Muse rejected initialization (${mspKind}, ${mspCode})`, false);
+        this.mspCode = mspCode;
+        this.mspKind = mspKind;
+        this.name = "MspInitializeRejectedError";
+    }
+}
+export class MspSchemaMismatchError extends MuseBridgeError {
+    pinned;
+    served;
+    constructor(pinned, served) {
+        super("MUSE_HOST_START_FAILED", "Muse host schema fingerprint does not match the pinned MSP schema", false);
+        this.pinned = pinned;
+        this.served = served;
+        this.name = "MspSchemaMismatchError";
+    }
+}
+export class RegistryValidationError extends MuseBridgeError {
+    constructor() {
+        super("MUSE_REGISTRY_ERROR", "Muse session registry entry is invalid or contains unsupported fields", false);
+        this.name = "RegistryValidationError";
+    }
+}
+export class RegistryCorruptError extends MuseBridgeError {
+    constructor() {
+        super("MUSE_REGISTRY_ERROR", "Muse session registry entry is corrupt and could not be quarantined safely", false);
+        this.name = "RegistryCorruptError";
+    }
+}
+export class RegistryStorageError extends MuseBridgeError {
+    constructor() {
+        super("MUSE_REGISTRY_STORAGE_ERROR", "Muse session registry storage operation failed", true);
+        this.name = "RegistryStorageError";
+    }
+}
+export class RegistryWorkspaceMismatchError extends MuseBridgeError {
+    constructor() {
+        super("MUSE_REGISTRY_ERROR", "OpenCode session is already bound to a different workspace", false);
+        this.name = "RegistryWorkspaceMismatchError";
+    }
+}
+export class WorkspaceBusyError extends MuseBridgeError {
+    constructor() {
+        super("MUSE_WORKSPACE_BUSY", "Another OpenCode session currently owns this workspace", true);
+        this.name = "WorkspaceBusyError";
+    }
+}
+export class WorkspaceLockCorruptError extends MuseBridgeError {
+    constructor() {
+        super("MUSE_WORKSPACE_LOCK_CORRUPT", "Workspace lock is corrupt; refusing to assume it is stale", false);
+        this.name = "WorkspaceLockCorruptError";
+    }
+}
+export class MuseTurnFailedError extends MuseBridgeError {
+    turnErrorKind;
+    constructor(turnErrorKind, retryable) {
+        const safeKind = /^[A-Za-z][A-Za-z0-9]{0,63}$/.test(turnErrorKind) ? turnErrorKind : "unknown";
+        super("MUSE_TURN_FAILED", `Muse turn failed (${safeKind})`, retryable);
+        this.turnErrorKind = safeKind;
+        this.name = "MuseTurnFailedError";
+    }
+}
+export class MuseTurnUnqueuedError extends MuseBridgeError {
+    constructor() {
+        super("MUSE_TURN_UNQUEUED", "Muse queued turn was reclaimed before it started", false);
+        this.name = "MuseTurnUnqueuedError";
+    }
+}
+export class MuseUnsupportedRequestError extends MuseBridgeError {
+    requestKind;
+    constructor(requestKind) {
+        super("MUSE_UNSUPPORTED_REQUEST", `Muse bridge does not support this request kind (${requestKind})`, false);
+        this.requestKind = requestKind;
+        this.name = "MuseUnsupportedRequestError";
+    }
+}
+export class MuseUnsupportedInputError extends MuseBridgeError {
+    inputKind;
+    constructor(inputKind) {
+        super("MUSE_UNSUPPORTED_INPUT", `Muse bridge cannot represent this input kind (${inputKind})`, false);
+        this.inputKind = inputKind;
+        this.name = "MuseUnsupportedInputError";
+    }
+}
+export class MuseRecoveryChoiceRequiredError extends MuseBridgeError {
+    constructor() {
+        super("MUSE_RECOVERY_CHOICE_REQUIRED", "A prior Muse command has an unknown outcome; inspect or resume the session before continuing", false);
+        this.name = "MuseRecoveryChoiceRequiredError";
+    }
+}
+export class MuseTranscriptDivergedError extends MuseBridgeError {
+    constructor() {
+        super("MUSE_TRANSCRIPT_DIVERGED", "OpenCode history diverged from the mapped Muse session; start a fresh Muse session or recover it explicitly", false);
+        this.name = "MuseTranscriptDivergedError";
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,7 @@
+import type { Plugin } from "@opencode/plugin";
+/** Factory hook required by OpenCode's bundled `aisdk:file://` dynamic provider. */
+export declare function createMuse(): {
+    languageModel(_modelID: string): never;
+};
+export declare const MusePlugin: Plugin.Plugin;
+export default MusePlugin;

package/dist/index.js

@@ -0,0 +1,17 @@
+import { createProviderPlugin } from "./provider.js";
+/** Factory hook required by OpenCode's bundled `aisdk:file://` dynamic provider. */
+export function createMuse() {
+    return {
+        languageModel(_modelID) {
+            throw new Error("opencode-muse: language hook did not engage (OpenCode seam drift?)");
+        },
+    };
+}
+export const MusePlugin = {
+    id: "opencode-muse",
+    async setup(ctx) {
+        const runtime = await createProviderPlugin(ctx, import.meta.url);
+        return runtime.dispose;
+    },
+};
+export default MusePlugin;

package/dist/model/agent-context.d.ts

@@ -0,0 +1,10 @@
+import type { ContextFragment } from "./prompt.js";
+export interface AgentContextResult {
+    supported: boolean;
+    fragments: ContextFragment[];
+}
+/**
+ * Forward only a custom agent's bounded prompt prefix. Stock OpenCode prompts,
+ * tool catalogs, and unknown system layouts are never copied into Muse input.
+ */
+export declare function extractAllowedAgentContext(agent: string, systemParts: readonly unknown[]): AgentContextResult;