@toolu/opencode 6.8.0

package/src/bootstrap/readiness.ts

@@ -0,0 +1,59 @@
+/** Bootstrap output proof — exit 0 alone is not ready (#211). */
+import { existsSync, readdirSync, statSync } from "node:fs";
+import { join } from "node:path";
+import { opencodeRegistryRoot } from "../host/roots.ts";
+
+const REGISTRY_EVENT_DIRS = ["pre-tools.d", "post-tools.d"] as const;
+
+const SESSION_ARTIFACT_NAMES = [".gate-preset-notice-v6"] as const;
+
+function listShModules(dir: string): string[] {
+  if (!existsSync(dir)) {
+    return [];
+  }
+  const out: string[] = [];
+  for (const entry of readdirSync(dir)) {
+    const path = join(dir, entry);
+    try {
+      if (statSync(path).isFile() && entry.endsWith(".sh")) {
+        out.push(path);
+      }
+    } catch {
+      continue;
+    }
+  }
+  return out;
+}
+
+/** Concrete artifacts produced by register/session-start under dataRoot. */
+export function collectBootstrapArtifacts(dataRoot: string): string[] {
+  const regRoot = opencodeRegistryRoot(dataRoot);
+  const artifacts: string[] = [];
+  for (const sub of REGISTRY_EVENT_DIRS) {
+    artifacts.push(...listShModules(join(regRoot, sub)));
+  }
+  for (const name of SESSION_ARTIFACT_NAMES) {
+    const path = join(regRoot, name);
+    if (existsSync(path)) {
+      artifacts.push(path);
+    }
+  }
+  return artifacts;
+}
+
+export function evaluateBootstrapReadiness(dataRoot: string): {
+  ready: boolean;
+  artifacts: string[];
+  reason?: string;
+} {
+  const artifacts = collectBootstrapArtifacts(dataRoot);
+  if (artifacts.length === 0) {
+    return {
+      ready: false,
+      artifacts,
+      reason:
+        "bootstrap entrypoints exited cleanly but required registry/session artifacts are missing under the OpenCode data root",
+    };
+  }
+  return { ready: true, artifacts };
+}

package/src/bootstrap/result.ts

@@ -0,0 +1,21 @@
+/** Bootstrap Ready / NotReady union (#211). */
+
+export type ReadyResult = {
+  status: "ready";
+  artifacts: string[];
+};
+
+export type NotReadyResult = {
+  status: "not-ready";
+  reason: string;
+};
+
+export type BootstrapResult = ReadyResult | NotReadyResult;
+
+export function ready(artifacts: string[]): ReadyResult {
+  return { status: "ready", artifacts };
+}
+
+export function notReady(reason: string): NotReadyResult {
+  return { status: "not-ready", reason };
+}

package/src/bootstrap/runtime.ts

@@ -0,0 +1,99 @@
+/** Assemble registry via argv-only bash runner (#211). */
+import { mkdirSync } from "node:fs";
+import { createBunBashRunner, type BashRunner } from "@toolu/core/runner";
+import { opencodeDataRoot } from "../host/roots.ts";
+import type { PluginManifest } from "../inventory/types.ts";
+import { notReady, ready, type BootstrapResult } from "./result.ts";
+import { pluginBootstrapScript } from "./entrypoint.ts";
+import { evaluateBootstrapReadiness } from "./readiness.ts";
+
+export type BootstrapRuntimeOptions = {
+  repoRoot: string;
+  dataRoot?: string;
+  projectRoot: string;
+  plugins: PluginManifest[];
+  env?: Record<string, string>;
+  runner?: BashRunner;
+  isolatedHome?: string;
+  deadlineMs?: number;
+};
+
+function bootstrapEnv(options: BootstrapRuntimeOptions, dataRoot: string): Record<string, string> {
+  const base: Record<string, string> = {
+    TOOLU_CONFIG_DIR: dataRoot,
+    TOOLU_PROJECT_DIR: options.projectRoot,
+    TOOLU_PROJECT_CONFIG_DIRNAME: ".opencode",
+    TOOLU_HOST_OVERRIDE: "opencode",
+    HOME: options.isolatedHome ?? dataRoot,
+  };
+  if (options.env) {
+    for (const [key, value] of Object.entries(options.env)) {
+      base[key] = value;
+    }
+  }
+  return base;
+}
+
+async function runEntrypoint(
+  runner: BashRunner,
+  scriptPath: string,
+  cwd: string,
+  env: Record<string, string>,
+  deadlineMs: number,
+): Promise<BootstrapResult | null> {
+  const result = await runner.run({
+    argv: ["bash", scriptPath],
+    cwd,
+    env,
+    stdin: "{}",
+    deadlineMs,
+    maxStdoutBytes: 512_000,
+  });
+  if (!result.ok) {
+    return notReady(`bootstrap script failed (${scriptPath}): ${result.message}`);
+  }
+  if (result.exitCode !== 0) {
+    return notReady(
+      `bootstrap script ${scriptPath} exited ${result.exitCode}: ${result.stderr || result.stdout}`,
+    );
+  }
+  return null;
+}
+
+/** Run plugin register/session-start scripts and verify output artifacts. */
+export async function bootstrapRuntime(options: BootstrapRuntimeOptions): Promise<BootstrapResult> {
+  const dataRoot = options.dataRoot ?? opencodeDataRoot({ projectRoot: options.projectRoot });
+  mkdirSync(dataRoot, { recursive: true });
+
+  const runner = options.runner ?? createBunBashRunner();
+  const env = bootstrapEnv(options, dataRoot);
+  const deadlineMs = options.deadlineMs ?? 120_000;
+
+  const runChain = async (index: number): Promise<BootstrapResult | null> => {
+    const plugin = options.plugins[index];
+    if (!plugin) {
+      return null;
+    }
+    const script = pluginBootstrapScript(plugin.pluginDir);
+    // Not every plugin has register.sh / session-start.sh — skip, don't abort.
+    if (!script) {
+      return runChain(index + 1);
+    }
+    const failure = await runEntrypoint(runner, script, options.projectRoot, env, deadlineMs);
+    if (failure) {
+      return failure;
+    }
+    return runChain(index + 1);
+  };
+
+  const chainFailure = await runChain(0);
+  if (chainFailure) {
+    return chainFailure;
+  }
+
+  const proof = evaluateBootstrapReadiness(dataRoot);
+  if (!proof.ready) {
+    return notReady(proof.reason ?? "bootstrap artifacts missing");
+  }
+  return ready(proof.artifacts);
+}

package/src/bootstrap/test-helpers.ts

@@ -0,0 +1,25 @@
+/** Test helper: exit 0 without producing registry output → NotReady (#211 AC-4). */
+import type { BashRunner, RawProcessResult } from "@toolu/core/runner";
+import { bootstrapRuntime, type BootstrapRuntimeOptions } from "./runtime.ts";
+import type { BootstrapResult } from "./result.ts";
+
+export function createNoOpRunner(): BashRunner {
+  return {
+    run(): Promise<RawProcessResult> {
+      return Promise.resolve({
+        ok: true,
+        exitCode: 0,
+        stdout: "",
+        stderr: "",
+        truncated: false,
+      });
+    },
+  };
+}
+
+/** Run bootstrap with a runner that always succeeds without touching disk scripts. */
+export async function bootstrapWithNoOpRunner(
+  options: BootstrapRuntimeOptions,
+): Promise<BootstrapResult> {
+  return bootstrapRuntime({ ...options, runner: createNoOpRunner() });
+}

package/src/host/__tests__/host.test.ts

@@ -0,0 +1,37 @@
+import { expect, test } from "bun:test";
+import { mkdtempSync, mkdirSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { detectHost } from "../detect.ts";
+import { opencodeConfigRoot, opencodeDataRoot, opencodePluginSelectionPath } from "../roots.ts";
+
+const tmpBase = process.env.TMPDIR ?? "/tmp";
+
+test("detectHost honors TOOLU_HOST_OVERRIDE=opencode", () => {
+  expect(detectHost({ env: { TOOLU_HOST_OVERRIDE: "opencode" } })).toBe("opencode");
+});
+
+test("detectHost uses OPENCODE_* env and .opencode project marker", () => {
+  const project = mkdtempSync(join(tmpBase, "toolu-oc-host-"));
+  mkdirSync(join(project, ".opencode"), { recursive: true });
+  expect(detectHost({ env: { OPENCODE_HOME: "/tmp/oc" } })).toBe("opencode");
+  expect(detectHost({ env: {}, projectRoot: project })).toBe("opencode");
+});
+
+test("opencode roots honor TOOLU_CONFIG_DIR and TOOLU_OPENCODE_HOME", () => {
+  const project = mkdtempSync(join(tmpBase, "toolu-oc-roots-"));
+  const explicit = join(project, "data");
+  expect(opencodeDataRoot({ dataRoot: explicit })).toBe(explicit);
+  expect(opencodeConfigRoot({ env: { TOOLU_CONFIG_DIR: "/cfg" } })).toBe("/cfg");
+  expect(opencodeConfigRoot({ env: { TOOLU_OPENCODE_HOME: "/oc-home" } })).toBe("/oc-home");
+  const derived = opencodeDataRoot({ projectRoot: project });
+  expect(derived).toBe(join(project, ".opencode", "toolu", "state"));
+});
+
+test("selection path lives under project .opencode", () => {
+  const project = mkdtempSync(join(tmpBase, "toolu-oc-sel-"));
+  mkdirSync(join(project, ".opencode", "toolu"), { recursive: true });
+  writeFileSync(opencodePluginSelectionPath(project), '{"version":1,"enabled":["toolu"]}\n');
+  expect(opencodePluginSelectionPath(project)).toBe(
+    join(project, ".opencode", "toolu", "plugins.json"),
+  );
+});

package/src/host/detect.ts

@@ -0,0 +1,46 @@
+/** Detect runtime host; OpenCode via override, env, or project markers (#211). */
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+import type { HostDetectOptions, TooluHost } from "./types.ts";
+
+const OPENCODE_ENV_KEYS = [
+  "OPENCODE_HOME",
+  "OPENCODE_CONFIG",
+  "OPENCODE_PROJECT_DIR",
+  "OPENCODE_BIN",
+] as const;
+
+function hasOpencodeEnv(env: NodeJS.ProcessEnv): boolean {
+  return OPENCODE_ENV_KEYS.some((key) => {
+    const value = env[key];
+    return typeof value === "string" && value.length > 0;
+  });
+}
+
+function hasOpencodeProjectMarker(projectRoot: string): boolean {
+  return existsSync(join(projectRoot, ".opencode"));
+}
+
+/** Resolve host from env overrides and optional project markers. */
+export function detectHost(options: HostDetectOptions = {}): TooluHost {
+  const env = options.env ?? process.env;
+  const override = env.TOOLU_HOST_OVERRIDE;
+  if (override === "claude" || override === "codex" || override === "opencode") {
+    return override;
+  }
+
+  if (hasOpencodeEnv(env)) {
+    return "opencode";
+  }
+
+  const projectRoot = options.projectRoot ?? env.TOOLU_PROJECT_DIR;
+  if (projectRoot && hasOpencodeProjectMarker(projectRoot)) {
+    return "opencode";
+  }
+
+  if (env.PLUGIN_ROOT) {
+    return "codex";
+  }
+
+  return "claude";
+}

package/src/host/index.ts

@@ -0,0 +1,10 @@
+export { detectHost } from "./detect.ts";
+export {
+  opencodeConfigRoot,
+  opencodeDataRoot,
+  opencodePluginSelectionPath,
+  opencodeProjectConfigPath,
+  opencodeProjectDir,
+  opencodeRegistryRoot,
+} from "./roots.ts";
+export type { HostDetectOptions, OpencodeRootsOptions, TooluHost } from "./types.ts";

package/src/host/roots.ts

@@ -0,0 +1,59 @@
+/** OpenCode config/state roots; honors TOOLU_* without Claude/Codex homes (#211). */
+import { join } from "node:path";
+import type { OpencodeRootsOptions } from "./types.ts";
+
+const OPENCODE_PROJECT_DIRNAME = ".opencode";
+const OPENCODE_STATE_SEGMENT = join("toolu", "state");
+
+/** Writable data root for assembled registry and host state. */
+export function opencodeDataRoot(options: OpencodeRootsOptions = {}): string {
+  const env = options.env ?? process.env;
+  if (options.dataRoot) {
+    return options.dataRoot;
+  }
+  if (env.TOOLU_CONFIG_DIR) {
+    return env.TOOLU_CONFIG_DIR;
+  }
+  if (env.TOOLU_OPENCODE_HOME) {
+    return env.TOOLU_OPENCODE_HOME;
+  }
+  const projectRoot = options.projectRoot ?? env.TOOLU_PROJECT_DIR;
+  if (!projectRoot) {
+    throw new Error(
+      "opencodeDataRoot: set dataRoot, TOOLU_CONFIG_DIR, TOOLU_OPENCODE_HOME, or projectRoot",
+    );
+  }
+  return join(projectRoot, OPENCODE_PROJECT_DIRNAME, OPENCODE_STATE_SEGMENT);
+}
+
+/** Alias for portable-core export map. */
+export function opencodeConfigRoot(options: OpencodeRootsOptions = {}): string {
+  return opencodeDataRoot(options);
+}
+
+/** Project git/worktree root for config resolution. */
+export function opencodeProjectDir(options: OpencodeRootsOptions = {}): string {
+  const env = options.env ?? process.env;
+  if (options.projectRoot) {
+    return options.projectRoot;
+  }
+  if (env.TOOLU_PROJECT_DIR) {
+    return env.TOOLU_PROJECT_DIR;
+  }
+  throw new Error("opencodeProjectDir: set projectRoot or TOOLU_PROJECT_DIR");
+}
+
+/** Project-scoped toolu.config.json path under .opencode/. */
+export function opencodeProjectConfigPath(projectRoot: string): string {
+  return join(projectRoot, OPENCODE_PROJECT_DIRNAME, "toolu.config.json");
+}
+
+/** Selection file for enabled plugins (never Claude installed_plugins.json). */
+export function opencodePluginSelectionPath(projectRoot: string): string {
+  return join(projectRoot, OPENCODE_PROJECT_DIRNAME, "toolu", "plugins.json");
+}
+
+/** Registry root under the OpenCode data root. */
+export function opencodeRegistryRoot(dataRoot: string): string {
+  return join(dataRoot, "toolu");
+}

package/src/host/types.ts

@@ -0,0 +1,14 @@
+/** Host detection types for OpenCode bootstrap (#211). */
+
+export type TooluHost = "claude" | "codex" | "opencode";
+
+export type HostDetectOptions = {
+  env?: NodeJS.ProcessEnv;
+  projectRoot?: string;
+};
+
+export type OpencodeRootsOptions = {
+  env?: NodeJS.ProcessEnv;
+  dataRoot?: string;
+  projectRoot?: string;
+};

package/src/inventory/__tests__/inventory.test.ts

@@ -0,0 +1,69 @@
+import { expect, test } from "bun:test";
+import { mkdirSync, mkdtempSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { buildInventory, lookupPluginInstallState } from "../scan.ts";
+import { resolveEnabledPluginNames } from "../selection.ts";
+import { opencodePluginSelectionPath, opencodeProjectConfigPath } from "../../host/roots.ts";
+
+const tmpBase = process.env.TMPDIR ?? "/tmp";
+
+function repoRoot(): string {
+  return join(dirname(fileURLToPath(import.meta.url)), "../../../../..");
+}
+
+function writeManifest(pluginsRoot: string, name: string): void {
+  const dir = join(pluginsRoot, name, ".claude-plugin");
+  mkdirSync(dir, { recursive: true });
+  writeFileSync(
+    join(dir, "plugin.json"),
+    JSON.stringify({ name, version: "1.0.0", dependencies: [] }),
+  );
+}
+
+test("inventory install states installed absent unknown", () => {
+  const pluginsRoot = join(repoRoot(), "plugins");
+  expect(lookupPluginInstallState(pluginsRoot, "toolu")).toBe("installed");
+  expect(lookupPluginInstallState(pluginsRoot, "no-such-plugin-ever")).toBe("absent");
+  expect(lookupPluginInstallState("/nonexistent/plugins-root", "toolu")).toBe("unknown");
+});
+
+test("enabled selection from .opencode/toolu/plugins.json", () => {
+  const project = mkdtempSync(join(tmpBase, "toolu-inv-en-"));
+  const pluginsRoot = mkdtempSync(join(tmpBase, "toolu-inv-pl-"));
+  writeManifest(pluginsRoot, "toolu");
+  writeManifest(pluginsRoot, "ts-quality");
+  mkdirSync(join(project, ".opencode", "toolu"), { recursive: true });
+  writeFileSync(
+    opencodePluginSelectionPath(project),
+    JSON.stringify({ version: 1, enabled: ["toolu"] }),
+  );
+  const result = resolveEnabledPluginNames(pluginsRoot, project);
+  expect(result.ok).toBe(true);
+  if (!result.ok) {
+    return;
+  }
+  expect(result.enabled.has("toolu")).toBe(true);
+  expect(result.enabled.has("ts-quality")).toBe(false);
+  const inventory = buildInventory(pluginsRoot, result.enabled);
+  const tsEntry = inventory?.find((e) => e.name === "ts-quality");
+  expect(tsEntry).toBeDefined();
+  expect(tsEntry?.enabled).toBe("disabled");
+});
+
+test("skills false in toolu.config disables plugin", () => {
+  const project = mkdtempSync(join(tmpBase, "toolu-inv-sk-"));
+  const pluginsRoot = mkdtempSync(join(tmpBase, "toolu-inv-sk-pl-"));
+  writeManifest(pluginsRoot, "toolu");
+  mkdirSync(join(project, ".opencode"), { recursive: true });
+  writeFileSync(
+    opencodeProjectConfigPath(project),
+    JSON.stringify({ version: 1, skills: { toolu: false } }),
+  );
+  const result = resolveEnabledPluginNames(pluginsRoot, project);
+  expect(result.ok).toBe(true);
+  if (!result.ok) {
+    return;
+  }
+  expect(result.enabled.has("toolu")).toBe(false);
+});

package/src/inventory/index.ts

@@ -0,0 +1,9 @@
+export { buildInventory, listPluginManifests, lookupPluginInstallState } from "./scan.ts";
+export { readPluginManifest, pluginSpec } from "./manifest.ts";
+export { resolveEnabledPluginNames } from "./selection.ts";
+export type {
+  PluginEnabledState,
+  PluginInstallState,
+  PluginInventoryEntry,
+  PluginManifest,
+} from "./types.ts";

package/src/inventory/manifest.ts

@@ -0,0 +1,46 @@
+/** Read plugin.json manifests from a plugins root (#211). */
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+import { z } from "zod";
+import type { PluginManifest } from "./types.ts";
+
+const DependencySchema = z
+  .object({
+    name: z.string().min(1),
+    marketplace: z.string().min(1),
+  })
+  .strict();
+
+const PluginJsonSchema = z.object({
+  name: z.string().min(1),
+  version: z.string().min(1),
+  dependencies: z.array(DependencySchema).optional(),
+});
+
+export function pluginSpec(name: string, marketplace: string): string {
+  return `${name}@${marketplace}`;
+}
+
+export function readPluginManifest(pluginDir: string): PluginManifest | null {
+  const manifestPath = join(pluginDir, ".claude-plugin", "plugin.json");
+  let raw: unknown;
+  try {
+    raw = JSON.parse(readFileSync(manifestPath, "utf8"));
+  } catch {
+    return null;
+  }
+  const parsed = PluginJsonSchema.safeParse(raw);
+  if (!parsed.success) {
+    return null;
+  }
+  const marketplace = "toolu";
+  const { name, version, dependencies } = parsed.data;
+  return {
+    name,
+    spec: pluginSpec(name, marketplace),
+    marketplace,
+    version,
+    pluginDir,
+    dependencies: dependencies ?? [],
+  };
+}

package/src/inventory/scan.ts

@@ -0,0 +1,66 @@
+/** Scan plugins root for manifests; never reads Claude install sets (#211). */
+import { readdirSync, statSync } from "node:fs";
+import { join } from "node:path";
+import { readPluginManifest } from "./manifest.ts";
+import type { PluginInventoryEntry, PluginManifest } from "./types.ts";
+
+export function listPluginManifests(pluginsRoot: string): PluginManifest[] | null {
+  let entries: string[];
+  try {
+    entries = readdirSync(pluginsRoot);
+  } catch {
+    return null;
+  }
+
+  const manifests: PluginManifest[] = [];
+  for (const entry of entries) {
+    const pluginDir = join(pluginsRoot, entry);
+    try {
+      if (!statSync(pluginDir).isDirectory()) {
+        continue;
+      }
+    } catch {
+      continue;
+    }
+    const manifest = readPluginManifest(pluginDir);
+    if (manifest) {
+      manifests.push(manifest);
+    }
+  }
+  return manifests;
+}
+
+export function lookupPluginInstallState(
+  pluginsRoot: string,
+  pluginName: string,
+): PluginInventoryEntry["install"] {
+  const manifests = listPluginManifests(pluginsRoot);
+  if (manifests === null) {
+    return "unknown";
+  }
+  const hit = manifests.some((m) => m.name === pluginName);
+  return hit ? "installed" : "absent";
+}
+
+export function buildInventory(
+  pluginsRoot: string,
+  enabledNames: Set<string> | null,
+): PluginInventoryEntry[] | null {
+  const manifests = listPluginManifests(pluginsRoot);
+  if (manifests === null) {
+    return null;
+  }
+  return manifests.map((manifest) => {
+    let enabled: PluginInventoryEntry["enabled"] = "unknown";
+    if (enabledNames !== null) {
+      enabled = enabledNames.has(manifest.name) ? "enabled" : "disabled";
+    }
+    return {
+      name: manifest.name,
+      spec: manifest.spec,
+      pluginDir: manifest.pluginDir,
+      install: "installed",
+      enabled,
+    };
+  });
+}

package/src/inventory/selection.ts

@@ -0,0 +1,92 @@
+/**
+ * Enabled plugin selection (#211).
+ *
+ * Sources (in order):
+ * 1. `<project>/.opencode/toolu/plugins.json` — `{ "version": 1, "enabled": ["toolu", ...] }`
+ * 2. `<project>/.opencode/toolu.config.json` or repo `.opencode/toolu.config.json` —
+ *    `skills.<pluginName> === false` disables an otherwise-installed plugin.
+ * 3. Default: every installed plugin is enabled.
+ *
+ * Never reads Claude `installed_plugins.json` or Codex install snapshots.
+ */
+import { existsSync, readFileSync } from "node:fs";
+import { opencodePluginSelectionPath, opencodeProjectConfigPath } from "../host/roots.ts";
+import { listPluginManifests } from "./scan.ts";
+import { z } from "zod";
+import { TooluConfigSchema } from "@toolu/core/config";
+
+const SelectionFileSchema = z
+  .object({
+    version: z.literal(1),
+    enabled: z.array(z.string().min(1)),
+  })
+  .strict();
+
+function readSelectionFile(path: string): string[] | null {
+  if (!existsSync(path)) {
+    return null;
+  }
+  try {
+    const raw: unknown = JSON.parse(readFileSync(path, "utf8"));
+    const parsed = SelectionFileSchema.safeParse(raw);
+    if (!parsed.success) {
+      return null;
+    }
+    return parsed.data.enabled;
+  } catch {
+    return null;
+  }
+}
+
+function readSkillsDisabled(projectRoot: string): Set<string> {
+  const disabled = new Set<string>();
+  const configPath = opencodeProjectConfigPath(projectRoot);
+  if (!existsSync(configPath)) {
+    return disabled;
+  }
+  try {
+    const raw: unknown = JSON.parse(readFileSync(configPath, "utf8"));
+    const parsed = TooluConfigSchema.safeParse(raw);
+    if (!parsed.success) {
+      return disabled;
+    }
+    const skills = parsed.data.skills;
+    if (!skills) {
+      return disabled;
+    }
+    for (const [name, on] of Object.entries(skills)) {
+      if (!on) {
+        disabled.add(name);
+      }
+    }
+  } catch {
+    return disabled;
+  }
+  return disabled;
+}
+
+/** Resolve enabled plugin names for a project + plugins root. */
+export function resolveEnabledPluginNames(
+  pluginsRoot: string,
+  projectRoot: string,
+): { ok: true; enabled: Set<string> } | { ok: false; reason: string } {
+  const manifests = listPluginManifests(pluginsRoot);
+  if (manifests === null) {
+    return { ok: false, reason: `cannot read plugins root: ${pluginsRoot}` };
+  }
+  const installed = new Set(manifests.map((m) => m.name));
+
+  const fromFile = readSelectionFile(opencodePluginSelectionPath(projectRoot));
+  let enabled: Set<string>;
+  if (fromFile !== null) {
+    enabled = new Set(fromFile.filter((name) => installed.has(name)));
+  } else {
+    enabled = new Set(installed);
+  }
+
+  for (const name of readSkillsDisabled(projectRoot)) {
+    enabled.delete(name);
+  }
+
+  return { ok: true, enabled };
+}

package/src/inventory/types.ts

@@ -0,0 +1,22 @@
+/** Plugin inventory tri-state (#211). */
+
+export type PluginInstallState = "installed" | "absent" | "unknown";
+
+export type PluginEnabledState = "enabled" | "disabled" | "unknown";
+
+export type PluginInventoryEntry = {
+  name: string;
+  spec: string;
+  pluginDir: string;
+  install: PluginInstallState;
+  enabled: PluginEnabledState;
+};
+
+export type PluginManifest = {
+  name: string;
+  spec: string;
+  marketplace: string;
+  version: string;
+  pluginDir: string;
+  dependencies: Array<{ name: string; marketplace: string }>;
+};