@opencode-compat/profile 0.1.0

package/README.md

@@ -0,0 +1,14 @@
+# @opencode-compat/profile
+
+HostProfile types, draft profiles (`opencode` / `mimo` / `kilo` / `zcode`), and `detect()`.
+
+**License:** MPL-2.0
+
+```ts
+import { detect, mimoProfile, CORE_HOOKS } from "@opencode-compat/profile"
+
+const { profile, supported, message } = detect()
+// or: detect({ env: { OPENCODE_COMPAT_HOST: "mimo" } })
+```
+
+See the monorepo [README](../../README.md) and [OCP 0.1](../../docs/ocp/0.1.md) §5.

package/dist/detect.d.ts

@@ -0,0 +1,13 @@
+import type { DetectOptions, DetectResult } from "./types";
+/**
+ * Detect the current OCP host.
+ *
+ * Order (docs/ocp/0.1.md §5.1):
+ * 1. `OPENCODE_COMPAT_HOST`
+ * 2. Native binary / package identity
+ * 3. Config-dir heuristics
+ * 4. `zcode` → refuse OCP load (T0 doctor)
+ * 5. `unknown` → fail with doctor
+ */
+export declare function detect(options?: DetectOptions): DetectResult;
+//# sourceMappingURL=detect.d.ts.map

package/dist/detect.js

@@ -0,0 +1,155 @@
+import { existsSync as nodeExistsSync } from "node:fs";
+import { basename } from "node:path";
+import { DRAFTS, kiloProfile, mimoProfile, opencodeProfile, unknownProfile, zcodeProfile, } from "./drafts";
+import { unknownDoctorMessage, zcodeDoctorMessage } from "./doctor";
+const HOST_IDS = ["opencode", "mimo", "kilo", "zcode"];
+function isHostId(value) {
+    return HOST_IDS.includes(value);
+}
+function profileFor(id, options) {
+    const draft = DRAFTS[id];
+    return draft({ env: options.env, home: options.home });
+}
+function result(id, profile, source, supported, message) {
+    return { id, profile, source, supported, message };
+}
+function binaryHint(options) {
+    const argv = options.argv ?? process.argv;
+    const execPath = options.execPath ?? process.execPath;
+    const tokens = [
+        ...argv.map((a) => basename(a).toLowerCase()),
+        basename(execPath).toLowerCase(),
+    ];
+    for (const token of tokens) {
+        if (token === "mimo" ||
+            token === "mimocode" ||
+            token.startsWith("mimo-") ||
+            token.includes("mimocode")) {
+            return "mimo";
+        }
+        if (token === "kilo" ||
+            token === "kilocode" ||
+            token.startsWith("kilo-") ||
+            token.includes("kilocode")) {
+            return "kilo";
+        }
+        if (token === "zcode" ||
+            token.startsWith("zcode-") ||
+            token.includes("zcode")) {
+            return "zcode";
+        }
+        if (token === "opencode" ||
+            token.startsWith("opencode-") ||
+            token.includes("opencode")) {
+            return "opencode";
+        }
+    }
+    return undefined;
+}
+function envPrefixHint(env) {
+    // Strong host-specific prefixes first (avoid OPENCODE_* false positives from compat tooling).
+    if (hasPrefix(env, "MIMOCODE_"))
+        return "mimo";
+    if (hasPrefix(env, "KILO_"))
+        return "kilo";
+    if (hasPrefix(env, "ZCODE_"))
+        return "zcode";
+    // OPENCODE_* alone is weak — only count when not also running under compat tooling only.
+    // Prefer config/binary for OpenCode; still allow OPENCODE_CONFIG_DIR as a hint.
+    if (env.OPENCODE_CONFIG_DIR || env.OPENCODE_CONFIG)
+        return "opencode";
+    return undefined;
+}
+function hasPrefix(env, prefix) {
+    for (const key of Object.keys(env)) {
+        if (key.startsWith(prefix) && env[key])
+            return true;
+    }
+    return false;
+}
+function configDirHint(options) {
+    const exists = options.existsSync ?? nodeExistsSync;
+    const drafts = [
+        { id: "kilo", dir: kiloProfile(options).paths.configDir },
+        { id: "mimo", dir: mimoProfile(options).paths.configDir },
+        { id: "opencode", dir: opencodeProfile(options).paths.configDir },
+        { id: "zcode", dir: zcodeProfile(options).paths.configDir },
+    ];
+    // Prefer more specific fork dirs before OpenCode when multiple exist.
+    const order = [
+        "kilo",
+        "mimo",
+        "zcode",
+        "opencode",
+    ];
+    for (const id of order) {
+        const entry = drafts.find((d) => d.id === id);
+        if (entry && exists(entry.dir))
+            return id;
+    }
+    return undefined;
+}
+/**
+ * Detect the current OCP host.
+ *
+ * Order (docs/ocp/0.1.md §5.1):
+ * 1. `OPENCODE_COMPAT_HOST`
+ * 2. Native binary / package identity
+ * 3. Config-dir heuristics
+ * 4. `zcode` → refuse OCP load (T0 doctor)
+ * 5. `unknown` → fail with doctor
+ */
+export function detect(options = {}) {
+    const env = options.env ?? process.env;
+    const opts = { ...options, env };
+    const forced = env.OPENCODE_COMPAT_HOST?.trim().toLowerCase();
+    if (forced) {
+        if (forced === "unknown") {
+            const profile = unknownProfile(opts);
+            return result("unknown", profile, "env", false, unknownDoctorMessage());
+        }
+        if (isHostId(forced)) {
+            const profile = profileFor(forced, opts);
+            if (forced === "zcode") {
+                return result("zcode", profile, "env", false, zcodeDoctorMessage());
+            }
+            return result(forced, profile, "env", true);
+        }
+        const profile = unknownProfile(opts);
+        return result("unknown", profile, "env", false, `OCP: invalid OPENCODE_COMPAT_HOST=${JSON.stringify(forced)}. Expected opencode|mimo|kilo|zcode.`);
+    }
+    const fromPackage = opts.resolveNative?.();
+    if (fromPackage && fromPackage !== "unknown") {
+        if (isHostId(fromPackage)) {
+            const profile = profileFor(fromPackage, opts);
+            if (fromPackage === "zcode") {
+                return result("zcode", profile, "package", false, zcodeDoctorMessage());
+            }
+            return result(fromPackage, profile, "package", true);
+        }
+    }
+    const fromBinary = binaryHint(opts);
+    if (fromBinary === "zcode") {
+        return result("zcode", zcodeProfile(opts), "binary", false, zcodeDoctorMessage());
+    }
+    if (fromBinary) {
+        return result(fromBinary, profileFor(fromBinary, opts), "binary", true);
+    }
+    const fromEnvPrefix = envPrefixHint(env);
+    if (fromEnvPrefix) {
+        if (fromEnvPrefix === "zcode") {
+            return result("zcode", zcodeProfile(opts), "env", false, zcodeDoctorMessage());
+        }
+        return result(fromEnvPrefix, profileFor(fromEnvPrefix, opts), "env", true);
+    }
+    const fromConfig = configDirHint(opts);
+    if (fromConfig) {
+        if (fromConfig === "zcode") {
+            return result("zcode", zcodeProfile(opts), "config", false, zcodeDoctorMessage());
+        }
+        return result(fromConfig, profileFor(fromConfig, opts), "config", true);
+    }
+    const profile = unknownProfile(opts);
+    return result("unknown", profile, "fallback", false, unknownDoctorMessage());
+}
+//# sourceMappingURL=detect.js.map

package/dist/doctor.d.ts

@@ -0,0 +1,49 @@
+/** T0 doctor copy for ZCode — marketplace ABI ≠ OCP. */
+export declare function zcodeDoctorMessage(): string;
+/** Doctor copy when no cooperating host can be identified. */
+export declare function unknownDoctorMessage(): string;
+/**
+ * Optional companion privacy pointer for doctor output.
+ * Docs only — OCP never mutates telemetry env/config/firewall.
+ */
+export declare function privacyGuideHint(hostId: string): string | undefined;
+/** Short capability summary for CLI doctor. */
+export declare function profileSummaryLines(profile: {
+    id: string;
+    ocpVersion: string;
+    nativePlugin: string;
+    envPrefix: string;
+    capabilities: {
+        classicHooks: boolean;
+        promiseV2: boolean;
+        effectV2: boolean;
+        aisdkProviderHooks: boolean;
+        scansDotOpencode: boolean;
+        streamToolCallEnsure: boolean;
+        bashDescriptionRequired: boolean;
+        marketplacePlugins?: boolean;
+    };
+    hooks: {
+        missing: readonly string[];
+        extensions: readonly string[];
+    };
+    paths: {
+        configDir: string;
+        projectDirs: string[];
+        compatProjectDirs?: string[];
+    };
+}): string[];
+/** Join summary lines for printing. */
+export declare function formatProfileSummary(profile: Parameters<typeof profileSummaryLines>[0]): string;
+/** Layer A override map: `@opencode-ai/*` → `@opencode-compat/facade-*` (npm: form). */
+export declare function facadeOverrides(version?: string): Record<string, string>;
+/** Suggested override map snippet for plugin install trees / operator overrides. */
+export declare function facadeOverrideSnippet(version?: string): string;
+/** Resolve a project-relative plugin dir candidate list for a profile. */
+export declare function projectPluginCandidates(profile: {
+    paths: {
+        projectDirs: string[];
+        compatProjectDirs?: string[];
+    };
+}, cwd: string): string[];
+//# sourceMappingURL=doctor.d.ts.map

package/dist/doctor.js

@@ -0,0 +1,90 @@
+import { join } from "node:path";
+/** T0 doctor copy for ZCode — marketplace ABI ≠ OCP. */
+export function zcodeDoctorMessage() {
+    return [
+        "OCP: host detected as zcode (T0).",
+        "ZCode Agent Mode marketplace (.zcode-plugin / Claude-/Codex-style hooks) is not the OpenCode npm plugin ABI (@opencode-ai/plugin).",
+        "External OpenCode agent tiles that spawn the OpenCode CLI are also not OCP plugin compatibility.",
+        "Public marketplace examples (glm-hammer, zcode-glm-fleet) use .zcode-plugin/plugin.json — a different protocol.",
+        "Until Z.AI ships an OpenCode-plugin loader, OCP will not load plugins on this host.",
+        "Companion (not OCP): pack plugin-package skills/commands/manifests with `compat migrate-zcode` (does not migrate host MCP; see docs/plans/zcode-asset-migrator-plan.md).",
+    ].join(" ");
+}
+/** Doctor copy when no cooperating host can be identified. */
+export function unknownDoctorMessage() {
+    return [
+        "OCP: could not detect a cooperating host (opencode, mimo, or kilo).",
+        "Set OPENCODE_COMPAT_HOST=opencode|mimo|kilo to force detection,",
+        "or run inside a supported CLI so binary/config heuristics can resolve the host.",
+        "ZCode is T0 only — see docs/ocp/0.1.md §9.",
+    ].join(" ");
+}
+/**
+ * Optional companion privacy pointer for doctor output.
+ * Docs only — OCP never mutates telemetry env/config/firewall.
+ */
+export function privacyGuideHint(hostId) {
+    switch (hostId) {
+        case "kilo":
+            return "privacy: Kilo PostHog opt-out — docs/guides/kilocode-telemetry-disable.md (not an OCP kill)";
+        case "mimo":
+            return "privacy: MiMo analysis opt-out — docs/guides/mimocode-telemetry-disable.md (MIMOCODE_ENABLE_ANALYSIS=false; not an OCP kill)";
+        case "zcode":
+            return "privacy: ZCode telemetry is docs-only firewall/DNS — docs/guides/zcode-telemetry-block.md (no in-app opt-out; not an OCP kill)";
+        default:
+            return undefined;
+    }
+}
+/** Short capability summary for CLI doctor. */
+export function profileSummaryLines(profile) {
+    const caps = profile.capabilities;
+    return [
+        `host: ${profile.id}`,
+        `ocp: ${profile.ocpVersion}`,
+        `nativePlugin: ${profile.nativePlugin}`,
+        `envPrefix: ${profile.envPrefix || "(none)"}`,
+        `configDir: ${profile.paths.configDir}`,
+        `projectDirs: ${profile.paths.projectDirs.join(", ") || "(none)"}`,
+        profile.paths.compatProjectDirs?.length
+            ? `compatProjectDirs: ${profile.paths.compatProjectDirs.join(", ")}`
+            : undefined,
+        `classicHooks: ${caps.classicHooks}`,
+        `promiseV2: ${caps.promiseV2}`,
+        `effectV2: ${caps.effectV2}`,
+        `aisdkProviderHooks: ${caps.aisdkProviderHooks}`,
+        `scansDotOpencode: ${caps.scansDotOpencode}`,
+        `streamToolCallEnsure: ${caps.streamToolCallEnsure}`,
+        `bashDescriptionRequired: ${caps.bashDescriptionRequired}`,
+        caps.marketplacePlugins ? "marketplacePlugins: true" : undefined,
+        profile.hooks.missing.length
+            ? `hooks.missing: ${profile.hooks.missing.join(", ")}`
+            : "hooks.missing: (none)",
+        profile.hooks.extensions.length
+            ? `hooks.extensions: ${profile.hooks.extensions.join(", ")}`
+            : undefined,
+    ].filter((line) => line !== undefined);
+}
+/** Join summary lines for printing. */
+export function formatProfileSummary(profile) {
+    return profileSummaryLines(profile).join("\n");
+}
+/** Layer A override map: `@opencode-ai/*` → `@opencode-compat/facade-*` (npm: form). */
+export function facadeOverrides(version = "0.1.0") {
+    return {
+        "@opencode-ai/plugin": `npm:@opencode-compat/facade-plugin@${version}`,
+        "@opencode-ai/sdk": `npm:@opencode-compat/facade-sdk@${version}`,
+    };
+}
+/** Suggested override map snippet for plugin install trees / operator overrides. */
+export function facadeOverrideSnippet(version = "0.1.0") {
+    return JSON.stringify(facadeOverrides(version), null, 2);
+}
+/** Resolve a project-relative plugin dir candidate list for a profile. */
+export function projectPluginCandidates(profile, cwd) {
+    const dirs = [
+        ...profile.paths.projectDirs,
+        ...(profile.paths.compatProjectDirs ?? []),
+    ];
+    return [...new Set(dirs)].map((d) => join(cwd, d, "plugins"));
+}
+//# sourceMappingURL=doctor.js.map

package/dist/drafts.d.ts

@@ -0,0 +1,34 @@
+import { type PathEnv } from "./paths";
+import type { HostProfile } from "./types";
+export type DraftOptions = {
+    env?: PathEnv;
+    home?: string;
+};
+/** OpenCode reference host — full OCP surface. */
+export declare function opencodeProfile(options?: DraftOptions): HostProfile;
+/**
+ * MiMo Code — classic T1 + OCP-layer Promise v2 (host-promise-v2), not native exports.
+ * Missing classic: dispose, experimental.provider.small_model (no-op + doctor).
+ * Stream gap: no ensureToolCall — bare tool-call drops; bash.description required.
+ */
+export declare function mimoProfile(options?: DraftOptions): HostProfile;
+/**
+ * Kilo Code — classic Hooks key-identical to OpenCode 1.18.3.
+ * Promise v2 via OCP host-promise-v2 (not native @kilocode exports).
+ * No project `.opencode` scan today; close via bridge docs/doctor/operator copy-symlink.
+ */
+export declare function kiloProfile(options?: DraftOptions): HostProfile;
+/**
+ * ZCode — T0 only. Marketplace ABI ≠ `@opencode-ai/plugin`.
+ */
+export declare function zcodeProfile(options?: DraftOptions): HostProfile;
+/** Fallback when no cooperating host is detected. */
+export declare function unknownProfile(options?: DraftOptions): HostProfile;
+/** All draft builders keyed by HostId (excluding unknown). */
+export declare const DRAFTS: {
+    readonly opencode: typeof opencodeProfile;
+    readonly mimo: typeof mimoProfile;
+    readonly kilo: typeof kiloProfile;
+    readonly zcode: typeof zcodeProfile;
+};
+//# sourceMappingURL=drafts.d.ts.map

package/dist/drafts.js

@@ -0,0 +1,240 @@
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { CORE_HOOKS, MIMO_EXTENSION_HOOKS, MIMO_MISSING_HOOKS, } from "./hooks";
+import { resolveXdgDirs } from "./paths";
+function baseOpts(options) {
+    const env = options?.env ?? process.env;
+    const home = options?.home ?? env.HOME ?? homedir();
+    return { env, home };
+}
+/** OpenCode reference host — full OCP surface. */
+export function opencodeProfile(options) {
+    const { env, home } = baseOpts(options);
+    const configOverride = env.OPENCODE_CONFIG_DIR;
+    const xdg = resolveXdgDirs("opencode", env, home);
+    return {
+        id: "opencode",
+        ocpVersion: "0.1.0",
+        nativePlugin: "@opencode-ai/plugin",
+        nativeSdk: "@opencode-ai/sdk",
+        pluginVersionObserved: "1.18.3",
+        paths: {
+            configDir: configOverride && configOverride.length > 0 ? configOverride : xdg.configDir,
+            dataDir: xdg.dataDir,
+            cacheDir: xdg.cacheDir,
+            projectDirs: [".opencode"],
+            pluginInstallDir: join(xdg.cacheDir, "packages"),
+        },
+        configFiles: ["opencode.json", "opencode.jsonc"],
+        envPrefix: "OPENCODE",
+        capabilities: {
+            classicHooks: true,
+            promiseV2: true,
+            effectV2: true,
+            aisdkProviderHooks: true,
+            localPluginScan: true,
+            scansDotOpencode: true,
+            streamToolCallEnsure: true,
+            bashDescriptionRequired: false,
+        },
+        hooks: {
+            core: CORE_HOOKS,
+            missing: [],
+            extensions: [],
+        },
+    };
+}
+/**
+ * MiMo Code — classic T1 + OCP-layer Promise v2 (host-promise-v2), not native exports.
+ * Missing classic: dispose, experimental.provider.small_model (no-op + doctor).
+ * Stream gap: no ensureToolCall — bare tool-call drops; bash.description required.
+ */
+export function mimoProfile(options) {
+    const { env, home } = baseOpts(options);
+    const mimoHome = env.MIMOCODE_HOME;
+    let configDir;
+    let dataDir;
+    let cacheDir;
+    if (mimoHome && mimoHome.length > 0) {
+        configDir = join(mimoHome, "config");
+        dataDir = join(mimoHome, "share");
+        cacheDir = join(mimoHome, "cache");
+    }
+    else {
+        const xdg = resolveXdgDirs("mimocode", env, home);
+        configDir = xdg.configDir;
+        dataDir = xdg.dataDir;
+        cacheDir = xdg.cacheDir;
+    }
+    return {
+        id: "mimo",
+        ocpVersion: "0.1.0",
+        nativePlugin: "@mimo-ai/plugin",
+        nativeSdk: "@mimo-ai/sdk",
+        pluginVersionObserved: "0.1.6",
+        paths: {
+            configDir,
+            dataDir,
+            cacheDir,
+            projectDirs: [".mimocode"],
+            compatProjectDirs: [".opencode"],
+            pluginInstallDir: join(cacheDir, "packages"),
+        },
+        configFiles: ["mimocode.json", "mimocode.jsonc"],
+        envPrefix: "MIMOCODE",
+        capabilities: {
+            classicHooks: true,
+            // OCP layer supplies Promise v2 via @opencode-compat/host-promise-v2 (not @mimo-ai exports)
+            promiseV2: true,
+            effectV2: false,
+            aisdkProviderHooks: true,
+            localPluginScan: true,
+            scansDotOpencode: false,
+            // MiMo SessionProcessor creates tool parts only on tool-input-start (no ensureToolCall)
+            streamToolCallEnsure: false,
+            bashDescriptionRequired: true,
+        },
+        hooks: {
+            core: CORE_HOOKS,
+            missing: MIMO_MISSING_HOOKS,
+            extensions: MIMO_EXTENSION_HOOKS,
+        },
+        note: "PluginInput still types createOpencodeClient from @mimo-ai/sdk (residual name); Promise v2 via OCP host kit; streamToolCallEnsure=false → OCP provider shim emits tool-input-start",
+    };
+}
+/**
+ * Kilo Code — classic Hooks key-identical to OpenCode 1.18.3.
+ * Promise v2 via OCP host-promise-v2 (not native @kilocode exports).
+ * No project `.opencode` scan today; close via bridge docs/doctor/operator copy-symlink.
+ */
+export function kiloProfile(options) {
+    const { env, home } = baseOpts(options);
+    const configOverride = env.KILO_CONFIG_DIR;
+    const xdg = resolveXdgDirs("kilo", env, home);
+    const configDir = configOverride && configOverride.length > 0 ? configOverride : xdg.configDir;
+    return {
+        id: "kilo",
+        ocpVersion: "0.1.0",
+        nativePlugin: "@kilocode/plugin",
+        nativeSdk: "@kilocode/sdk",
+        pluginVersionObserved: "7.4.11",
+        upstreamPin: "v1.17.4",
+        paths: {
+            configDir,
+            dataDir: xdg.dataDir,
+            cacheDir: xdg.cacheDir,
+            projectDirs: [".kilo", ".kilocode"],
+            compatProjectDirs: [".opencode"],
+            pluginInstallDir: join(xdg.cacheDir, "packages"),
+        },
+        configFiles: [
+            "config.json",
+            "kilo.json",
+            "kilo.jsonc",
+            "opencode.json",
+            "opencode.jsonc",
+        ],
+        envPrefix: "KILO",
+        capabilities: {
+            classicHooks: true,
+            // OCP layer supplies Promise v2 via @opencode-compat/host-promise-v2 (not @kilocode exports)
+            promiseV2: true,
+            effectV2: false,
+            aisdkProviderHooks: true,
+            localPluginScan: true,
+            scansDotOpencode: false,
+            // Kilo SessionProcessor has ensureToolCall; bash.description is optional
+            streamToolCallEnsure: true,
+            bashDescriptionRequired: false,
+        },
+        hooks: {
+            core: CORE_HOOKS,
+            missing: [],
+            extensions: [],
+        },
+        note: "Promise v2 via OCP host kit; live host provider-resolve calls createPromiseV2Host().resolveProvider; keep stock plugins (no cursor-kilocode-provider fork)",
+    };
+}
+/**
+ * ZCode — T0 only. Marketplace ABI ≠ `@opencode-ai/plugin`.
+ */
+export function zcodeProfile(options) {
+    const { env, home } = baseOpts(options);
+    const zcodeHome = env.ZCODE_HOME && env.ZCODE_HOME.length > 0
+        ? env.ZCODE_HOME
+        : join(home, ".zcode");
+    return {
+        id: "zcode",
+        ocpVersion: "none",
+        nativePlugin: "(marketplace .zcode-plugin — not @opencode-ai/plugin)",
+        nativeSdk: "(none — @zcode/* internals)",
+        pluginVersionObserved: "3.3.6",
+        paths: {
+            home: zcodeHome,
+            configDir: join(zcodeHome, "v2"),
+            dataDir: zcodeHome,
+            cacheDir: join(zcodeHome, "cache"),
+            projectDirs: [],
+        },
+        configFiles: ["setting.json", "config.json"],
+        envPrefix: "ZCODE",
+        capabilities: {
+            classicHooks: false,
+            promiseV2: false,
+            effectV2: false,
+            aisdkProviderHooks: false,
+            localPluginScan: false,
+            scansDotOpencode: false,
+            streamToolCallEnsure: true,
+            bashDescriptionRequired: false,
+            marketplacePlugins: true,
+        },
+        hooks: {
+            core: [],
+            missing: [...CORE_HOOKS],
+            extensions: [],
+        },
+        note: "External OpenCode agent tile is not OCP plugin compatibility",
+    };
+}
+/** Fallback when no cooperating host is detected. */
+export function unknownProfile(options) {
+    const { home } = baseOpts(options);
+    return {
+        id: "unknown",
+        ocpVersion: "none",
+        nativePlugin: "(unknown)",
+        nativeSdk: "(unknown)",
+        paths: {
+            configDir: home,
+            dataDir: home,
+            cacheDir: home,
+            projectDirs: [],
+        },
+        configFiles: [],
+        envPrefix: "",
+        capabilities: {
+            classicHooks: false,
+            promiseV2: false,
+            effectV2: false,
+            aisdkProviderHooks: false,
+            localPluginScan: false,
+            scansDotOpencode: false,
+            streamToolCallEnsure: true,
+            bashDescriptionRequired: false,
+        },
+        hooks: {
+            core: [],
+            missing: [...CORE_HOOKS],
+            extensions: [],
+        },
+    };
+}
+/** All draft builders keyed by HostId (excluding unknown). */
+export const DRAFTS = {
+    opencode: opencodeProfile,
+    mimo: mimoProfile,
+    kilo: kiloProfile,
+    zcode: zcodeProfile,
+};
+//# sourceMappingURL=drafts.js.map

package/dist/hooks.d.ts

@@ -0,0 +1,11 @@
+/**
+ * OCP 0.1 portable classic Hooks core set.
+ * Source: docs/ocp/0.1.md §6 + docs/plans/phase0-hooks-parity.md
+ */
+export declare const CORE_HOOKS: readonly ["dispose", "event", "config", "tool", "auth", "provider", "chat.message", "chat.params", "chat.headers", "permission.ask", "command.execute.before", "tool.execute.before", "tool.execute.after", "shell.env", "tool.definition", "experimental.chat.messages.transform", "experimental.chat.system.transform", "experimental.provider.small_model", "experimental.session.compacting", "experimental.compaction.autocontinue", "experimental.text.complete"];
+export type CoreHook = (typeof CORE_HOOKS)[number];
+/** MiMo host-extension hooks — non-portable (ADR-7) */
+export declare const MIMO_EXTENSION_HOOKS: readonly ["actor.preStop", "actor.postStop", "session.pre", "session.post", "session.userQuery.pre", "session.userQuery.post"];
+/** MiMo gaps vs OCP core */
+export declare const MIMO_MISSING_HOOKS: readonly ["dispose", "experimental.provider.small_model"];
+//# sourceMappingURL=hooks.d.ts.map

package/dist/hooks.js

@@ -0,0 +1,42 @@
+/**
+ * OCP 0.1 portable classic Hooks core set.
+ * Source: docs/ocp/0.1.md §6 + docs/plans/phase0-hooks-parity.md
+ */
+export const CORE_HOOKS = [
+    "dispose",
+    "event",
+    "config",
+    "tool",
+    "auth",
+    "provider",
+    "chat.message",
+    "chat.params",
+    "chat.headers",
+    "permission.ask",
+    "command.execute.before",
+    "tool.execute.before",
+    "tool.execute.after",
+    "shell.env",
+    "tool.definition",
+    "experimental.chat.messages.transform",
+    "experimental.chat.system.transform",
+    "experimental.provider.small_model",
+    "experimental.session.compacting",
+    "experimental.compaction.autocontinue",
+    "experimental.text.complete",
+];
+/** MiMo host-extension hooks — non-portable (ADR-7) */
+export const MIMO_EXTENSION_HOOKS = [
+    "actor.preStop",
+    "actor.postStop",
+    "session.pre",
+    "session.post",
+    "session.userQuery.pre",
+    "session.userQuery.post",
+];
+/** MiMo gaps vs OCP core */
+export const MIMO_MISSING_HOOKS = [
+    "dispose",
+    "experimental.provider.small_model",
+];
+//# sourceMappingURL=hooks.js.map

package/dist/index.d.ts

@@ -0,0 +1,14 @@
+/**
+ * @opencode-compat/profile — HostProfile types, drafts, and detect().
+ * Contract: docs/ocp/0.1.md §5
+ */
+export declare const PKG: "@opencode-compat/profile";
+export declare const VERSION: "0.1.0";
+export declare const OCP_VERSION: "0.1.0";
+export type { DetectOptions, DetectResult, DetectSource, HostCapabilities, HostHooks, HostId, HostPaths, HostProfile, } from "./types";
+export { CORE_HOOKS, MIMO_EXTENSION_HOOKS, MIMO_MISSING_HOOKS, type CoreHook, } from "./hooks";
+export { expandHome, resolveXdgDirs } from "./paths";
+export { DRAFTS, kiloProfile, mimoProfile, opencodeProfile, unknownProfile, zcodeProfile, type DraftOptions, } from "./drafts";
+export { detect } from "./detect";
+export { facadeOverrides, facadeOverrideSnippet, formatProfileSummary, privacyGuideHint, profileSummaryLines, projectPluginCandidates, unknownDoctorMessage, zcodeDoctorMessage, } from "./doctor";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -0,0 +1,13 @@
+/**
+ * @opencode-compat/profile — HostProfile types, drafts, and detect().
+ * Contract: docs/ocp/0.1.md §5
+ */
+export const PKG = "@opencode-compat/profile";
+export const VERSION = "0.1.0";
+export const OCP_VERSION = "0.1.0";
+export { CORE_HOOKS, MIMO_EXTENSION_HOOKS, MIMO_MISSING_HOOKS, } from "./hooks";
+export { expandHome, resolveXdgDirs } from "./paths";
+export { DRAFTS, kiloProfile, mimoProfile, opencodeProfile, unknownProfile, zcodeProfile, } from "./drafts";
+export { detect } from "./detect";
+export { facadeOverrides, facadeOverrideSnippet, formatProfileSummary, privacyGuideHint, profileSummaryLines, projectPluginCandidates, unknownDoctorMessage, zcodeDoctorMessage, } from "./doctor";
+//# sourceMappingURL=index.js.map

package/dist/paths.d.ts

@@ -0,0 +1,10 @@
+export type PathEnv = NodeJS.ProcessEnv;
+/** Resolve OpenCode-style XDG layout for an app name. */
+export declare function resolveXdgDirs(app: string, env?: PathEnv, home?: string): {
+    configDir: string;
+    dataDir: string;
+    cacheDir: string;
+};
+/** Expand a leading `~` against `home`. */
+export declare function expandHome(path: string, home: string): string;
+//# sourceMappingURL=paths.d.ts.map

package/dist/paths.js

@@ -0,0 +1,25 @@
+import { homedir } from "node:os";
+import { join } from "node:path";
+function xdgHome(env, key, fallback, home) {
+    const override = env[key];
+    if (override && override.length > 0)
+        return override;
+    return join(home, fallback);
+}
+/** Resolve OpenCode-style XDG layout for an app name. */
+export function resolveXdgDirs(app, env = process.env, home = env.HOME ?? homedir()) {
+    return {
+        configDir: join(xdgHome(env, "XDG_CONFIG_HOME", ".config", home), app),
+        dataDir: join(xdgHome(env, "XDG_DATA_HOME", ".local/share", home), app),
+        cacheDir: join(xdgHome(env, "XDG_CACHE_HOME", ".cache", home), app),
+    };
+}
+/** Expand a leading `~` against `home`. */
+export function expandHome(path, home) {
+    if (path === "~")
+        return home;
+    if (path.startsWith("~/"))
+        return join(home, path.slice(2));
+    return path;
+}
+//# sourceMappingURL=paths.js.map

package/dist/types.d.ts

@@ -0,0 +1,95 @@
+/** OCP host identifiers — see docs/ocp/0.1.md §5 */
+export type HostId = "opencode" | "mimo" | "kilo" | "zcode" | "unknown";
+export type HostCapabilities = {
+    classicHooks: boolean;
+    /** Exports AND host wiring for Promise v2 */
+    promiseV2: boolean;
+    effectV2: boolean;
+    aisdkProviderHooks: boolean;
+    localPluginScan: boolean;
+    scansDotOpencode: boolean;
+    /**
+     * Host SessionProcessor lazily creates tool parts on bare `tool-call`
+     * (OpenCode / Kilo `ensureToolCall`). When false (MiMo), OCP must emit
+     * `tool-input-start` before `tool-call` for custom LanguageModel streams.
+     */
+    streamToolCallEnsure: boolean;
+    /**
+     * Host `bash` tool schema requires a string `description`. When true (MiMo),
+     * OCP may fill a missing description on bash tool-call inputs only.
+     */
+    bashDescriptionRequired: boolean;
+    /** ZCode marketplace ABI — not OCP */
+    marketplacePlugins?: boolean;
+};
+export type HostPaths = {
+    configDir: string;
+    dataDir: string;
+    cacheDir: string;
+    /** Project dirs the host actually scans today */
+    projectDirs: string[];
+    /** Recommended compat project dirs for matrix/doctor (e.g. `.opencode`) */
+    compatProjectDirs?: string[];
+    /** npm plugin install cache, when distinct from cacheDir */
+    pluginInstallDir?: string;
+    /** Absolute home root when the host uses a non-XDG layout (ZCode) */
+    home?: string;
+};
+export type HostHooks = {
+    /** Portable classic hooks implemented (or accepted via facade) */
+    core: readonly string[];
+    /** Core hooks absent on this host (compat gaps) */
+    missing: readonly string[];
+    /** Host-only hooks — never required for portable plugins */
+    extensions: readonly string[];
+};
+export type HostProfile = {
+    id: HostId;
+    /** OCP semver this profile targets, or `"none"` for T0 hosts */
+    ocpVersion: string;
+    nativePlugin: string;
+    nativeSdk: string;
+    /** Observed native plugin package version at research time */
+    pluginVersionObserved?: string;
+    upstreamPin?: string;
+    paths: HostPaths;
+    configFiles: readonly string[];
+    /** Env prefix without trailing underscore, e.g. `OPENCODE` */
+    envPrefix: string;
+    capabilities: HostCapabilities;
+    hooks: HostHooks;
+    agents?: {
+        builtins: string[];
+        aliases?: Record<string, string>;
+    };
+    /** Free-form research notes */
+    note?: string;
+};
+export type DetectSource = "env" | "binary" | "package" | "config" | "fallback";
+export type DetectResult = {
+    id: HostId;
+    profile: HostProfile;
+    source: DetectSource;
+    /**
+     * Whether OCP plugin load is allowed.
+     * `false` for `zcode` (T0) and `unknown`.
+     */
+    supported: boolean;
+    /** Doctor / refusal text when `supported` is false */
+    message?: string;
+};
+export type DetectOptions = {
+    env?: NodeJS.ProcessEnv;
+    home?: string;
+    cwd?: string;
+    argv?: readonly string[];
+    execPath?: string;
+    /** Injectable for tests */
+    existsSync?: (path: string) => boolean;
+    /**
+     * Injectable package-presence probe (e.g. try resolve native plugin).
+     * Return the HostId when a native package is detectable.
+     */
+    resolveNative?: () => HostId | undefined;
+};
+//# sourceMappingURL=types.d.ts.map

package/dist/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=types.js.map

package/package.json

@@ -0,0 +1,53 @@
+{
+  "name": "@opencode-compat/profile",
+  "version": "0.1.0",
+  "description": "HostProfile types and draft profiles for OCP hosts",
+  "type": "module",
+  "license": "MPL-2.0",
+  "author": "oakimov",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/oakimov/opencode-plugin-compat.git",
+    "directory": "packages/profile"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "LICENSE",
+    "README.md",
+    "!dist/**/*.map"
+  ],
+  "scripts": {
+    "build": "bunx tsc -p tsconfig.json",
+    "typecheck": "bunx tsc -p tsconfig.json --noEmit",
+    "prepack": "bunx tsc -p tsconfig.json"
+  },
+  "dependencies": {},
+  "devDependencies": {
+    "typescript": "^5.8.3"
+  },
+  "bugs": {
+    "url": "https://github.com/oakimov/opencode-plugin-compat/issues"
+  },
+  "homepage": "https://github.com/oakimov/opencode-plugin-compat/tree/main/packages/profile#readme",
+  "keywords": [
+    "opencode",
+    "ocp",
+    "hostprofile",
+    "mimocode",
+    "kilocode"
+  ],
+  "engines": {
+    "bun": ">=1.2.0"
+  }
+}