expandai 0.0.2 → 0.0.3

package/build/dts/Install/Claude/Mcp.d.ts

@@ -1,5 +1,5 @@
 import { Effect, Schema } from 'effect';
-import { ConfigIo, McpParseError, McpWriteError } from '../Domain.js';
+import { type CliCommand, ConfigIo, McpParseError, McpServersConfigSchema, McpWriteError } from '../Domain.js';
 declare const Entry_base: Schema.Class<Entry, {
     type: Schema.Literal<["stdio"]>;
     command: typeof Schema.NonEmptyTrimmedString;
@@ -11,32 +11,35 @@ declare const Entry_base: Schema.Class<Entry, {
     args: Schema.Array$<typeof Schema.String>;
     env: Schema.optional<Schema.Record$<typeof Schema.String, typeof Schema.String>>;
 }>, never, {
-    readonly type: "stdio";
-} & {
-    readonly command: string;
-} & {
-    readonly args: readonly string[];
-} & {
     readonly env?: {
         readonly [x: string]: string;
     } | undefined;
+} & {
+    readonly args: readonly string[];
+} & {
+    readonly command: string;
+} & {
+    readonly type: "stdio";
 }, {}, {}>;
-/**
- * Claude Code MCP descriptor — `mcpServers` shape (de facto Claude Desktop
- * convention; also read by Cursor and other clients).
- *
- *   - global  → `~/.claude.json`        (Claude Code's user-scope store)
- *   - project → `<cwd>/.mcp.json`       (the agent-agnostic project file)
- */
+/** Claude Code MCP descriptor stored under the Expand-owned server key. */
 export declare class Entry extends Entry_base {
 }
+export interface ClaudeMcpPlan {
+    readonly changed: boolean;
+    readonly config: typeof McpServersConfigSchema.Type;
+}
+/** Claude execs the descriptor directly, so `command`/`args` stay separate. */
+export declare function claudeMcpEntry(cli?: CliCommand): Entry;
+export declare const CLAUDE_MCP_ENTRY: Entry;
+export declare function planClaudeMcp(config: typeof McpServersConfigSchema.Type, cli?: CliCommand): ClaudeMcpPlan;
+export declare function planClaudeMcpRemoval(config: typeof McpServersConfigSchema.Type): ClaudeMcpPlan;
 declare const ClaudeMcp_base: Effect.Service.Class<ClaudeMcp, "@expandai/cli/Install/Claude/Mcp", {
     readonly dependencies: readonly [import("effect/Layer").Layer<ConfigIo, never, never>];
     readonly effect: Effect.Effect<{
-        readonly install: (scope: "project" | "global") => Effect.Effect<void, McpParseError | McpWriteError, never>;
-        readonly uninstall: (scope: "project" | "global") => Effect.Effect<void, McpParseError | McpWriteError, never>;
-        readonly isInstalled: (scope: "project" | "global") => Effect.Effect<boolean, McpParseError, never>;
-        readonly pathFor: (scope: "project" | "global") => Effect.Effect<string, never, never>;
+        readonly install: (scope: "global" | "project") => Effect.Effect<void, McpParseError | McpWriteError, never>;
+        readonly uninstall: (scope: "global" | "project") => Effect.Effect<void, McpParseError | McpWriteError, never>;
+        readonly isInstalled: (scope: "global" | "project") => Effect.Effect<boolean, McpParseError, never>;
+        readonly pathFor: (scope: "global" | "project") => Effect.Effect<string, never, never>;
     }, import("effect/ConfigError").ConfigError, ConfigIo>;
 }>;
 export declare class ClaudeMcp extends ClaudeMcp_base {

package/build/dts/Install/Claude/Mcp.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Mcp.d.ts","sourceRoot":"","sources":["../../../../src/Install/Claude/Mcp.ts"],"names":[],"mappings":"AACA,OAAO,EAAmB,MAAM,EAAiB,MAAM,EAAE,MAAM,QAAQ,CAAA;AACvE,OAAO,EAAE,QAAQ,EAAE,aAAa,EAA0B,aAAa,EAAc,MAAM,cAAc,CAAA;;;;;;;;;;;;;;;;;;;;;;AAGzG;;;;;;GAMG;AACH,qBAAa,KAAM,SAAQ,UAKzB;CAAG;;;;;;;;;;AAEL,qBAAa,SAAU,SAAQ,cA8D7B;CAAG"}
+{"version":3,"file":"Mcp.d.ts","sourceRoot":"","sources":["../../../../src/Install/Claude/Mcp.ts"],"names":[],"mappings":"AACA,OAAO,EAAmB,MAAM,EAAiB,MAAM,EAAE,MAAM,QAAQ,CAAA;AACvE,OAAO,EACN,KAAK,UAAU,EACf,QAAQ,EAER,aAAa,EACb,sBAAsB,EACtB,aAAa,EAEb,MAAM,cAAc,CAAA;;;;;;;;;;;;;;;;;;;;;;AAGrB,2EAA2E;AAC3E,qBAAa,KAAM,SAAQ,UAKzB;CAAG;AAEL,MAAM,WAAW,aAAa;IAC7B,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAA;IACzB,QAAQ,CAAC,MAAM,EAAE,OAAO,sBAAsB,CAAC,IAAI,CAAA;CACnD;AAID,+EAA+E;AAC/E,wBAAgB,cAAc,CAAC,GAAG,GAAE,UAAuB,GAAG,KAAK,CAOlE;AAED,eAAO,MAAM,gBAAgB,OAAmB,CAAA;AAqBhD,wBAAgB,aAAa,CAAC,MAAM,EAAE,OAAO,sBAAsB,CAAC,IAAI,EAAE,GAAG,GAAE,UAAuB,GAAG,aAAa,CAUrH;AAED,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,OAAO,sBAAsB,CAAC,IAAI,GAAG,aAAa,CAM9F;;;;;;;;;;AAED,qBAAa,SAAU,SAAQ,cAiD7B;CAAG"}

package/build/dts/Install/Claude/Skill.d.ts

@@ -1,22 +1,21 @@
+import { FileSystem, Path } from '@effect/platform';
 import { Effect } from 'effect';
-import { SkillIo } from '../Domain.js';
-/**
- * Claude Code skills live under `<scope>/.claude/skills/<name>/SKILL.md`.
- *
- *   - global  → `~/.claude/skills/expandai/SKILL.md`
- *   - project → `<cwd>/.claude/skills/expandai/SKILL.md`
- *
- * (Globally-scoped Claude Code skills are also reachable via `npx skills`,
- * but file-copy gives us a uniform install path with OpenCode and works
- * without npm.)
- */
 export declare const SKILL_NAME = "expandai";
+export declare const SKILL_FILE_NAME = "SKILL.md";
+export interface ClaudeSkillPlan {
+    readonly changed: boolean;
+    readonly text: string;
+}
+export declare function renderClaudeSkill(source: string, profileVersion?: string): string;
+export declare function planClaudeSkill(current: string | undefined, source: string, profileVersion?: string): ClaudeSkillPlan;
 declare const ClaudeSkill_base: Effect.Service.Class<ClaudeSkill, "@expandai/cli/Install/Claude/Skill", {
-    readonly dependencies: readonly [import("effect/Layer").Layer<SkillIo, import("@effect/platform/Error").BadArgument, never>];
+    readonly dependencies: readonly [import("effect/Layer").Layer<FileSystem.FileSystem, never, never>, import("effect/Layer").Layer<Path.Path, never, never>];
     readonly effect: Effect.Effect<{
-        readonly install: (scope: "project" | "global") => Effect.Effect<string, import("@effect/platform/Error").PlatformError, never>;
-        readonly uninstall: (scope: "project" | "global") => Effect.Effect<string, import("@effect/platform/Error").PlatformError, never>;
-    }, import("effect/ConfigError").ConfigError, SkillIo>;
+        readonly install: (scope: "global" | "project") => Effect.Effect<string, import("@effect/platform/Error").PlatformError, never>;
+        readonly uninstall: (scope: "global" | "project") => Effect.Effect<string, import("@effect/platform/Error").PlatformError, never>;
+        readonly pathFor: (scope: "global" | "project") => Effect.Effect<string, never, never>;
+        readonly source: () => Effect.Effect<string, import("@effect/platform/Error").PlatformError, never>;
+    }, import("@effect/platform/Error").BadArgument | import("effect/ConfigError").ConfigError, FileSystem.FileSystem | Path.Path>;
 }>;
 export declare class ClaudeSkill extends ClaudeSkill_base {
 }

package/build/dts/Install/Claude/Skill.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Skill.d.ts","sourceRoot":"","sources":["../../../../src/Install/Claude/Skill.ts"],"names":[],"mappings":"AACA,OAAO,EAAU,MAAM,EAAS,MAAM,QAAQ,CAAA;AAC9C,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAA;AAGtC;;;;;;;;;GASG;AAEH,eAAO,MAAM,UAAU,aAAa,CAAA;;;;;;;;AAEpC,qBAAa,WAAY,SAAQ,gBAyB/B;CAAG"}
+{"version":3,"file":"Skill.d.ts","sourceRoot":"","sources":["../../../../src/Install/Claude/Skill.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,UAAU,EAAE,IAAI,EAAE,MAAM,kBAAkB,CAAA;AAEnD,OAAO,EAAU,MAAM,EAAS,MAAM,QAAQ,CAAA;AAI9C,eAAO,MAAM,UAAU,aAAa,CAAA;AACpC,eAAO,MAAM,eAAe,aAAa,CAAA;AAGzC,MAAM,WAAW,eAAe;IAC/B,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAA;IACzB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;CACrB;AAED,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,MAAM,EAAE,cAAc,GAAE,MAAoB,GAAG,MAAM,CAK9F;AAED,wBAAgB,eAAe,CAC9B,OAAO,EAAE,MAAM,GAAG,SAAS,EAC3B,MAAM,EAAE,MAAM,EACd,cAAc,GAAE,MAAoB,GAClC,eAAe,CAGjB;;;;;;;;;;AA2CD,qBAAa,WAAY,SAAQ,gBAG/B;CAAG"}

package/build/dts/Install/Codex/Mcp.d.ts

@@ -1,30 +1,36 @@
 import { Effect, Schema } from 'effect';
-import { ConfigIo, McpParseError, McpWriteError } from '../Domain.js';
+import { CliInvocation, ConfigIo, McpParseError, McpWriteError } from '../Domain.js';
 declare const Entry_base: Schema.Class<Entry, {
     command: typeof Schema.NonEmptyTrimmedString;
     args: Schema.Array$<typeof Schema.String>;
+    env: Schema.optional<Schema.Record$<typeof Schema.String, typeof Schema.String>>;
     enabled: typeof Schema.Boolean;
 }, Schema.Struct.Encoded<{
     command: typeof Schema.NonEmptyTrimmedString;
     args: Schema.Array$<typeof Schema.String>;
+    env: Schema.optional<Schema.Record$<typeof Schema.String, typeof Schema.String>>;
     enabled: typeof Schema.Boolean;
 }>, never, {
-    readonly command: string;
+    readonly env?: {
+        readonly [x: string]: string;
+    } | undefined;
 } & {
     readonly args: readonly string[];
+} & {
+    readonly command: string;
 } & {
     readonly enabled: boolean;
 }, {}, {}>;
 export declare class Entry extends Entry_base {
 }
 declare const CodexMcp_base: Effect.Service.Class<CodexMcp, "@expandai/cli/Install/Codex/Mcp", {
-    readonly dependencies: readonly [import("effect/Layer").Layer<ConfigIo, never, never>];
+    readonly dependencies: readonly [import("effect/Layer").Layer<ConfigIo, never, never>, import("effect/Layer").Layer<CliInvocation, import("effect/ConfigError").ConfigError, never>];
     readonly effect: Effect.Effect<{
-        readonly install: (scope: "project" | "global") => Effect.Effect<void, import("@effect/platform/Error").PlatformError | McpParseError | McpWriteError, never>;
-        readonly uninstall: (scope: "project" | "global") => Effect.Effect<void, import("@effect/platform/Error").PlatformError | McpParseError | McpWriteError, never>;
-        readonly isInstalled: (scope: "project" | "global") => Effect.Effect<boolean, import("@effect/platform/Error").PlatformError | McpParseError, never>;
-        readonly pathFor: (scope: "project" | "global") => Effect.Effect<string, never, never>;
-    }, import("effect/ConfigError").ConfigError, ConfigIo>;
+        readonly install: (scope: "global" | "project") => Effect.Effect<void, McpParseError | McpWriteError | import("@effect/platform/Error").PlatformError, never>;
+        readonly uninstall: (scope: "global" | "project") => Effect.Effect<void, McpParseError | McpWriteError | import("@effect/platform/Error").PlatformError, never>;
+        readonly isInstalled: (scope: "global" | "project") => Effect.Effect<boolean, McpParseError | import("@effect/platform/Error").PlatformError, never>;
+        readonly pathFor: (scope: "global" | "project") => Effect.Effect<string, never, never>;
+    }, import("effect/ConfigError").ConfigError, CliInvocation | ConfigIo>;
 }>;
 /**
  * Codex MCP descriptor — Codex stores MCP servers in TOML config under

package/build/dts/Install/Codex/Mcp.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Mcp.d.ts","sourceRoot":"","sources":["../../../../src/Install/Codex/Mcp.ts"],"names":[],"mappings":"AACA,OAAO,EAAmB,MAAM,EAAiB,MAAM,EAAE,MAAM,QAAQ,CAAA;AAEvE,OAAO,EAAE,QAAQ,EAAE,aAAa,EAAE,aAAa,EAAc,MAAM,cAAc,CAAA;;;;;;;;;;;;;;;;AAGjF,qBAAa,KAAM,SAAQ,UAIzB;CAAG;;;;;;;;;;AAgBL;;;;;;GAMG;AACH,qBAAa,QAAS,SAAQ,aA2E5B;CAAG"}
+{"version":3,"file":"Mcp.d.ts","sourceRoot":"","sources":["../../../../src/Install/Codex/Mcp.ts"],"names":[],"mappings":"AACA,OAAO,EAAmB,MAAM,EAAiB,MAAM,EAAE,MAAM,QAAQ,CAAA;AAEvE,OAAO,EAAE,aAAa,EAAE,QAAQ,EAAE,aAAa,EAAE,aAAa,EAAc,MAAM,cAAc,CAAA;;;;;;;;;;;;;;;;;;;;;;AAGhG,qBAAa,KAAM,SAAQ,UAKzB;CAAG;;;;;;;;;;AAgBL;;;;;;GAMG;AACH,qBAAa,QAAS,SAAQ,aA+E5B;CAAG"}

package/build/dts/Install/Codex/Skill.d.ts

@@ -10,8 +10,10 @@ export declare const SKILL_NAME = "expandai";
 declare const CodexSkill_base: Effect.Service.Class<CodexSkill, "@expandai/cli/Install/Codex/Skill", {
     readonly dependencies: readonly [import("effect/Layer").Layer<SkillIo, import("@effect/platform/Error").BadArgument, never>];
     readonly effect: Effect.Effect<{
-        readonly install: (scope: "project" | "global") => Effect.Effect<string, import("@effect/platform/Error").PlatformError, never>;
-        readonly uninstall: (scope: "project" | "global") => Effect.Effect<string, import("@effect/platform/Error").PlatformError, never>;
+        readonly install: (scope: "global" | "project") => Effect.Effect<string, import("@effect/platform/Error").PlatformError, never>;
+        readonly uninstall: (scope: "global" | "project") => Effect.Effect<string, import("@effect/platform/Error").PlatformError, never>;
+        readonly isCurrent: (scope: "global" | "project") => Effect.Effect<boolean, import("@effect/platform/Error").PlatformError, never>;
+        readonly pathFor: (scope: "global" | "project") => Effect.Effect<string, never, never>;
     }, import("effect/ConfigError").ConfigError, SkillIo>;
 }>;
 export declare class CodexSkill extends CodexSkill_base {

package/build/dts/Install/Codex/Skill.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Skill.d.ts","sourceRoot":"","sources":["../../../../src/Install/Codex/Skill.ts"],"names":[],"mappings":"AACA,OAAO,EAAU,MAAM,EAAS,MAAM,QAAQ,CAAA;AAC9C,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAA;AAGtC;;;;;GAKG;AAEH,eAAO,MAAM,UAAU,aAAa,CAAA;;;;;;;;AAEpC,qBAAa,UAAW,SAAQ,eAyB9B;CAAG"}
+{"version":3,"file":"Skill.d.ts","sourceRoot":"","sources":["../../../../src/Install/Codex/Skill.ts"],"names":[],"mappings":"AACA,OAAO,EAAU,MAAM,EAAS,MAAM,QAAQ,CAAA;AAC9C,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAA;AAGtC;;;;;GAKG;AAEH,eAAO,MAAM,UAAU,aAAa,CAAA;;;;;;;;;;AAEpC,qBAAa,UAAW,SAAQ,eA6B9B;CAAG"}

package/build/dts/Install/Cursor/Mcp.d.ts

@@ -1,5 +1,5 @@
 import { Effect, Schema } from 'effect';
-import { ConfigIo, McpParseError, McpWriteError } from '../Domain.js';
+import { CliInvocation, ConfigIo, McpParseError, McpWriteError } from '../Domain.js';
 declare const Entry_base: Schema.Class<Entry, {
     type: Schema.Literal<["stdio"]>;
     command: typeof Schema.NonEmptyTrimmedString;
@@ -11,15 +11,15 @@ declare const Entry_base: Schema.Class<Entry, {
     args: Schema.Array$<typeof Schema.String>;
     env: Schema.optional<Schema.Record$<typeof Schema.String, typeof Schema.String>>;
 }>, never, {
-    readonly type: "stdio";
-} & {
-    readonly command: string;
-} & {
-    readonly args: readonly string[];
-} & {
     readonly env?: {
         readonly [x: string]: string;
     } | undefined;
+} & {
+    readonly args: readonly string[];
+} & {
+    readonly command: string;
+} & {
+    readonly type: "stdio";
 }, {}, {}>;
 /**
  * Cursor MCP descriptor — same `mcpServers` shape as Claude Code, different
@@ -31,13 +31,13 @@ declare const Entry_base: Schema.Class<Entry, {
 export declare class Entry extends Entry_base {
 }
 declare const CursorMcp_base: Effect.Service.Class<CursorMcp, "@expandai/cli/Install/Cursor/Mcp", {
-    readonly dependencies: readonly [import("effect/Layer").Layer<ConfigIo, never, never>];
+    readonly dependencies: readonly [import("effect/Layer").Layer<ConfigIo, never, never>, import("effect/Layer").Layer<CliInvocation, import("effect/ConfigError").ConfigError, never>];
     readonly effect: Effect.Effect<{
-        readonly install: (scope: "project" | "global") => Effect.Effect<void, McpParseError | McpWriteError, never>;
-        readonly uninstall: (scope: "project" | "global") => Effect.Effect<void, McpParseError | McpWriteError, never>;
-        readonly isInstalled: (scope: "project" | "global") => Effect.Effect<boolean, McpParseError, never>;
-        readonly pathFor: (scope: "project" | "global") => Effect.Effect<string, never, never>;
-    }, import("effect/ConfigError").ConfigError, ConfigIo>;
+        readonly install: (scope: "global" | "project") => Effect.Effect<void, McpParseError | McpWriteError, never>;
+        readonly uninstall: (scope: "global" | "project") => Effect.Effect<void, McpParseError | McpWriteError, never>;
+        readonly isInstalled: (scope: "global" | "project") => Effect.Effect<boolean, McpParseError, never>;
+        readonly pathFor: (scope: "global" | "project") => Effect.Effect<string, never, never>;
+    }, import("effect/ConfigError").ConfigError, CliInvocation | ConfigIo>;
 }>;
 export declare class CursorMcp extends CursorMcp_base {
 }

package/build/dts/Install/Cursor/Mcp.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Mcp.d.ts","sourceRoot":"","sources":["../../../../src/Install/Cursor/Mcp.ts"],"names":[],"mappings":"AACA,OAAO,EAAmB,MAAM,EAAiB,MAAM,EAAE,MAAM,QAAQ,CAAA;AACvE,OAAO,EAAE,QAAQ,EAAE,aAAa,EAA0B,aAAa,EAAc,MAAM,cAAc,CAAA;;;;;;;;;;;;;;;;;;;;;;AAGzG;;;;;;GAMG;AACH,qBAAa,KAAM,SAAQ,UAKzB;CAAG;;;;;;;;;;AAEL,qBAAa,SAAU,SAAQ,cA8D7B;CAAG"}
+{"version":3,"file":"Mcp.d.ts","sourceRoot":"","sources":["../../../../src/Install/Cursor/Mcp.ts"],"names":[],"mappings":"AACA,OAAO,EAAmB,MAAM,EAAiB,MAAM,EAAE,MAAM,QAAQ,CAAA;AACvE,OAAO,EAAE,aAAa,EAAE,QAAQ,EAAE,aAAa,EAA0B,aAAa,EAAc,MAAM,cAAc,CAAA;;;;;;;;;;;;;;;;;;;;;;AAGxH;;;;;;GAMG;AACH,qBAAa,KAAM,SAAQ,UAKzB;CAAG;;;;;;;;;;AAEL,qBAAa,SAAU,SAAQ,cAiE7B;CAAG"}

package/build/dts/Install/Cursor/Skill.d.ts

@@ -17,8 +17,10 @@ export declare const SKILL_NAME = "expandai";
 declare const CursorSkill_base: Effect.Service.Class<CursorSkill, "@expandai/cli/Install/Cursor/Skill", {
     readonly dependencies: readonly [import("effect/Layer").Layer<SkillIo, import("@effect/platform/Error").BadArgument, never>];
     readonly effect: Effect.Effect<{
-        readonly install: (scope: "project" | "global") => Effect.Effect<string, import("@effect/platform/Error").PlatformError, never>;
-        readonly uninstall: (scope: "project" | "global") => Effect.Effect<string, import("@effect/platform/Error").PlatformError, never>;
+        readonly install: (scope: "global" | "project") => Effect.Effect<string, import("@effect/platform/Error").PlatformError, never>;
+        readonly uninstall: (scope: "global" | "project") => Effect.Effect<string, import("@effect/platform/Error").PlatformError, never>;
+        readonly isCurrent: (scope: "global" | "project") => Effect.Effect<boolean, import("@effect/platform/Error").PlatformError, never>;
+        readonly pathFor: (scope: "global" | "project") => Effect.Effect<string, never, never>;
     }, import("effect/ConfigError").ConfigError, SkillIo>;
 }>;
 export declare class CursorSkill extends CursorSkill_base {

package/build/dts/Install/Cursor/Skill.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Skill.d.ts","sourceRoot":"","sources":["../../../../src/Install/Cursor/Skill.ts"],"names":[],"mappings":"AACA,OAAO,EAAU,MAAM,EAAS,MAAM,QAAQ,CAAA;AAC9C,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAA;AAGtC;;;;;;;;;;;;GAYG;AAEH,eAAO,MAAM,UAAU,aAAa,CAAA;;;;;;;;AAEpC,qBAAa,WAAY,SAAQ,gBAyB/B;CAAG"}
+{"version":3,"file":"Skill.d.ts","sourceRoot":"","sources":["../../../../src/Install/Cursor/Skill.ts"],"names":[],"mappings":"AACA,OAAO,EAAU,MAAM,EAAS,MAAM,QAAQ,CAAA;AAC9C,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAA;AAGtC;;;;;;;;;;;;GAYG;AAEH,eAAO,MAAM,UAAU,aAAa,CAAA;;;;;;;;;;AAEpC,qBAAa,WAAY,SAAQ,gBA6B/B;CAAG"}

package/build/dts/Install/Domain.d.ts

@@ -1,5 +1,5 @@
 import { FileSystem, Path } from '@effect/platform';
-import { Effect, Schema } from 'effect';
+import { Effect, Layer, Schema } from 'effect';
 declare const McpParseError_base: Schema.TaggedErrorClass<McpParseError, "McpParseError", {
     readonly _tag: Schema.tag<"McpParseError">;
 } & {
@@ -20,8 +20,15 @@ export declare class McpWriteError extends McpWriteError_base {
 }
 export declare const Host: Schema.Literal<["claude-code", "cursor", "opencode", "codex"]>;
 export type Host = typeof Host.Type;
-export declare const Scope: Schema.Literal<["project", "global"]>;
-export type Scope = typeof Scope.Type;
+/**
+ * The agent harness invoking the CLI — every install target plus 'unknown'
+ * for uninstrumented callers. Installers bake `EXPANDAI_HARNESS=<host>` into
+ * MCP/hook configs; telemetry reads it back.
+ */
+export declare const Harness: Schema.Literal<["claude-code", "cursor", "opencode", "codex", "unknown"]>;
+export type Harness = typeof Harness.Type;
+export declare const InstallScope: Schema.Literal<["project", "global"]>;
+export type InstallScope = typeof InstallScope.Type;
 export declare const McpServersConfigSchema: Schema.transform<Schema.SchemaClass<unknown, string, never>, Schema.TypeLiteral<{
     mcpServers: Schema.optionalWith<Schema.Record$<typeof Schema.String, typeof Schema.Unknown>, {
         default: () => {};
@@ -33,10 +40,32 @@ export declare const OpencodeConfigSchema: Schema.transform<Schema.SchemaClass<u
     }>;
 }, readonly [Schema.Record$<typeof Schema.String, typeof Schema.Unknown>]>>;
 export declare const SERVER_KEY = "expandai";
+/** How a host config should launch the CLI: `command` plus leading args. */
+export interface CliCommand {
+    readonly command: string;
+    readonly args: ReadonlyArray<string>;
+}
+export declare const DIRECT_CLI: CliCommand;
+/**
+ * Renders a `CliCommand` as the single shell string Claude Code stores for hook
+ * entries. MCP descriptors keep `command`/`args` separate because they exec
+ * directly; hooks are run through a shell, so they need one flat line.
+ */
+export declare function cliShellCommand(cli: CliCommand, args: ReadonlyArray<string>): string;
+declare const CliInvocation_base: Effect.Service.Class<CliInvocation, "@expandai/cli/Install/CliInvocation", {
+    readonly dependencies: readonly [Layer.Layer<FileSystem.FileSystem, never, never>, Layer.Layer<Path.Path, never, never>];
+    readonly effect: Effect.Effect<{
+        readonly resolve: () => Effect.Effect<CliCommand, never, never>;
+    }, import("effect/ConfigError").ConfigError, FileSystem.FileSystem | Path.Path>;
+}>;
+export declare class CliInvocation extends CliInvocation_base {
+    /** Dependency-open layer so fixtures can supply their own file system and PATH. */
+    static readonly layer: Layer.Layer<CliInvocation, import("effect/ConfigError").ConfigError, FileSystem.FileSystem | Path.Path>;
+}
 export declare const readConfigText: (file: string) => Effect.Effect<string, import("@effect/platform/Error").PlatformError, FileSystem.FileSystem>;
 export declare const writeConfigText: (file: string, text: string) => Effect.Effect<void, import("@effect/platform/Error").PlatformError, FileSystem.FileSystem | Path.Path>;
 declare const ConfigIo_base: Effect.Service.Class<ConfigIo, "@expandai/cli/Install/ConfigIo", {
-    readonly dependencies: readonly [import("effect/Layer").Layer<FileSystem.FileSystem, never, never>, import("effect/Layer").Layer<Path.Path, never, never>];
+    readonly dependencies: readonly [Layer.Layer<FileSystem.FileSystem, never, never>, Layer.Layer<Path.Path, never, never>];
     readonly effect: Effect.Effect<{
         readonly read: <A>(file: string, schema: Schema.Schema<A, string, never>) => Effect.Effect<A, import("effect/ParseResult").ParseError | import("@effect/platform/Error").PlatformError, never>;
         readonly write: <A>(file: string, value: unknown, schema: Schema.Schema<A, string, never>) => Effect.Effect<void, import("effect/ParseResult").ParseError | import("@effect/platform/Error").PlatformError, never>;
@@ -54,10 +83,11 @@ declare const ConfigIo_base: Effect.Service.Class<ConfigIo, "@expandai/cli/Insta
 export declare class ConfigIo extends ConfigIo_base {
 }
 declare const SkillIo_base: Effect.Service.Class<SkillIo, "@expandai/cli/Install/SkillIo", {
-    readonly dependencies: readonly [import("effect/Layer").Layer<FileSystem.FileSystem, never, never>, import("effect/Layer").Layer<Path.Path, never, never>];
+    readonly dependencies: readonly [Layer.Layer<FileSystem.FileSystem, never, never>, Layer.Layer<Path.Path, never, never>];
     readonly effect: Effect.Effect<{
         readonly install: (target: string) => Effect.Effect<string, import("@effect/platform/Error").PlatformError, never>;
         readonly uninstall: (target: string) => Effect.Effect<string, import("@effect/platform/Error").PlatformError, never>;
+        readonly isCurrent: (target: string) => Effect.Effect<boolean, import("@effect/platform/Error").PlatformError, never>;
     }, import("@effect/platform/Error").BadArgument, FileSystem.FileSystem | Path.Path>;
 }>;
 /**

package/build/dts/Install/Domain.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Domain.d.ts","sourceRoot":"","sources":["../../../src/Install/Domain.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,IAAI,EAAE,MAAM,kBAAkB,CAAA;AAEnD,OAAO,EAAE,MAAM,EAAe,MAAM,EAAE,MAAM,QAAQ,CAAA;;;;;;;AAEpD,qBAAa,aAAc,SAAQ,kBAGjC;IACD,IAAI,OAAO,WAEV;CACD;;;;;;;AAED,qBAAa,aAAc,SAAQ,kBAGjC;IACD,IAAI,OAAO,WAEV;CACD;AAED,eAAO,MAAM,IAAI,gEAA+D,CAAA;AAChF,MAAM,MAAM,IAAI,GAAG,OAAO,IAAI,CAAC,IAAI,CAAA;AAEnC,eAAO,MAAM,KAAK,uCAAsC,CAAA;AACxD,MAAM,MAAM,KAAK,GAAG,OAAO,KAAK,CAAC,IAAI,CAAA;AAIrC,eAAO,MAAM,sBAAsB;;;;2EAGlC,CAAA;AAED,eAAO,MAAM,oBAAoB;;;;2EAGhC,CAAA;AAED,eAAO,MAAM,UAAU,aAAa,CAAA;AAEpC,eAAO,MAAM,cAAc,gHAOzB,CAAA;AAEF,eAAO,MAAM,eAAe,wIAK1B,CAAA;;;;wBAcmD,CAAC;yBAKC,CAAC;;;;;;AAjBxD;;;;;GAKG;AACH,qBAAa,QAAS,SAAQ,aA4C5B;CAAG;;;;;;;;AAEL;;;;;;GAMG;AACH,qBAAa,OAAQ,SAAQ,YA8B3B;CAAG"}
+{"version":3,"file":"Domain.d.ts","sourceRoot":"","sources":["../../../src/Install/Domain.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,IAAI,EAAE,MAAM,kBAAkB,CAAA;AAEnD,OAAO,EAAiB,MAAM,EAAe,KAAK,EAAE,MAAM,EAAU,MAAM,QAAQ,CAAA;;;;;;;AAElF,qBAAa,aAAc,SAAQ,kBAGjC;IACD,IAAI,OAAO,WAEV;CACD;;;;;;;AAED,qBAAa,aAAc,SAAQ,kBAGjC;IACD,IAAI,OAAO,WAEV;CACD;AAED,eAAO,MAAM,IAAI,gEAA+D,CAAA;AAChF,MAAM,MAAM,IAAI,GAAG,OAAO,IAAI,CAAC,IAAI,CAAA;AAEnC;;;;GAIG;AACH,eAAO,MAAM,OAAO,2EAA8C,CAAA;AAClE,MAAM,MAAM,OAAO,GAAG,OAAO,OAAO,CAAC,IAAI,CAAA;AAEzC,eAAO,MAAM,YAAY,uCAAsC,CAAA;AAC/D,MAAM,MAAM,YAAY,GAAG,OAAO,YAAY,CAAC,IAAI,CAAA;AAInD,eAAO,MAAM,sBAAsB;;;;2EAGlC,CAAA;AAED,eAAO,MAAM,oBAAoB;;;;2EAGhC,CAAA;AAED,eAAO,MAAM,UAAU,aAAa,CAAA;AAEpC,4EAA4E;AAC5E,MAAM,WAAW,UAAU;IAC1B,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;IACxB,QAAQ,CAAC,IAAI,EAAE,aAAa,CAAC,MAAM,CAAC,CAAA;CACpC;AAED,eAAO,MAAM,UAAU,EAAE,UAA8C,CAAA;AAGvE;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,GAAG,EAAE,UAAU,EAAE,IAAI,EAAE,aAAa,CAAC,MAAM,CAAC,GAAG,MAAM,CAEpF;;;;;;;AA0BD,qBAAa,aAAc,SAAQ,kBAGjC;IACD,mFAAmF;IACnF,MAAM,CAAC,QAAQ,CAAC,KAAK,0GAAsF;CAC3G;AAED,eAAO,MAAM,cAAc,gHAOzB,CAAA;AAEF,eAAO,MAAM,eAAe,wIAK1B,CAAA;;;;wBAcmD,CAAC;yBAKC,CAAC;;;;;;AAjBxD;;;;;GAKG;AACH,qBAAa,QAAS,SAAQ,aA4C5B;CAAG;;;;;;;;;AAEL;;;;;;GAMG;AACH,qBAAa,OAAQ,SAAQ,YA6C3B;CAAG"}

package/build/dts/Install/Hook.d.ts

@@ -18,11 +18,11 @@ import { OpencodeHook } from './Opencode/Hook.js';
 export declare const HookHost: Schema.Literal<["claude-code", "opencode"]>;
 export type HookHost = typeof HookHost.Type;
 declare const HookInstaller_base: Effect.Service.Class<HookInstaller, "@expandai/cli/Install/Hook", {
-    readonly dependencies: readonly [import("effect/Layer").Layer<Mcp, import("effect/ConfigError").ConfigError, never>, import("effect/Layer").Layer<ClaudeHook, import("effect/ConfigError").ConfigError, never>, import("effect/Layer").Layer<OpencodeHook, import("effect/ConfigError").ConfigError | import("@effect/platform/Error").BadArgument, never>];
+    readonly dependencies: readonly [import("effect/Layer").Layer<Mcp, import("effect/ConfigError").ConfigError, never>, import("effect/Layer").Layer<ClaudeHook, import("effect/ConfigError").ConfigError, never>, import("effect/Layer").Layer<OpencodeHook, import("@effect/platform/Error").BadArgument | import("effect/ConfigError").ConfigError, never>];
     readonly effect: Effect.Effect<{
-        readonly install: (host: "claude-code" | "opencode", scope: "project" | "global") => Effect.Effect<void, import("effect/ParseResult").ParseError | import("@effect/platform/Error").PlatformError | import("./Domain.js").McpParseError | import("./Domain.js").McpWriteError, never>;
-        readonly uninstall: (host: "claude-code" | "opencode", scope: "project" | "global") => Effect.Effect<void, import("effect/ParseResult").ParseError | import("@effect/platform/Error").PlatformError | import("./Domain.js").McpParseError | import("./Domain.js").McpWriteError, never>;
-    }, never, Mcp | ClaudeHook | OpencodeHook>;
+        readonly install: (host: "claude-code" | "opencode", scope: "global" | "project") => Effect.Effect<void, import("./Domain.js").McpParseError | import("./Domain.js").McpWriteError | import("effect/ParseResult").ParseError | import("@effect/platform/Error").PlatformError, never>;
+        readonly uninstall: (host: "claude-code" | "opencode", scope: "global" | "project") => Effect.Effect<void, import("./Domain.js").McpParseError | import("./Domain.js").McpWriteError | import("effect/ParseResult").ParseError | import("@effect/platform/Error").PlatformError, never>;
+    }, never, ClaudeHook | Mcp | OpencodeHook>;
 }>;
 export declare class HookInstaller extends HookInstaller_base {
 }

package/build/dts/Install/Hook.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Hook.d.ts","sourceRoot":"","sources":["../../../src/Install/Hook.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAS,MAAM,EAAE,MAAM,QAAQ,CAAA;AAC9C,OAAO,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAA;AAC7C,OAAO,EAAE,GAAG,EAAc,MAAM,UAAU,CAAA;AAC1C,OAAO,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAA;AAEjD;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,QAAQ,6CAA4C,CAAA;AACjE,MAAM,MAAM,QAAQ,GAAG,OAAO,QAAQ,CAAC,IAAI,CAAA;;;;;;;;AAE3C,qBAAa,aAAc,SAAQ,kBA4BjC;CAAG"}
+{"version":3,"file":"Hook.d.ts","sourceRoot":"","sources":["../../../src/Install/Hook.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAS,MAAM,EAAE,MAAM,QAAQ,CAAA;AAC9C,OAAO,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAA;AAC7C,OAAO,EAAqB,GAAG,EAAE,MAAM,UAAU,CAAA;AACjD,OAAO,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAA;AAEjD;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,QAAQ,6CAA4C,CAAA;AACjE,MAAM,MAAM,QAAQ,GAAG,OAAO,QAAQ,CAAC,IAAI,CAAA;;;;;;;;AAE3C,qBAAa,aAAc,SAAQ,kBA4BjC;CAAG"}

package/build/dts/Install/Mcp.d.ts

@@ -3,14 +3,14 @@ import { ClaudeMcp } from './Claude/Mcp.js';
 import { CodexMcp } from './Codex/Mcp.js';
 import { CursorMcp } from './Cursor/Mcp.js';
 import { OpencodeMcp } from './Opencode/Mcp.js';
-export { Host, McpParseError, McpWriteError, Scope } from './Domain.js';
+export { Host, InstallScope, McpParseError, McpWriteError } from './Domain.js';
 declare const Mcp_base: Effect.Service.Class<Mcp, "@expandai/cli/Install/Mcp", {
     readonly dependencies: readonly [import("effect/Layer").Layer<ClaudeMcp, import("effect/ConfigError").ConfigError, never>, import("effect/Layer").Layer<CursorMcp, import("effect/ConfigError").ConfigError, never>, import("effect/Layer").Layer<OpencodeMcp, import("effect/ConfigError").ConfigError, never>, import("effect/Layer").Layer<CodexMcp, import("effect/ConfigError").ConfigError, never>];
     readonly effect: Effect.Effect<{
-        readonly install: (host: "claude-code" | "cursor" | "opencode" | "codex", scope: "project" | "global") => Effect.Effect<void, import("@effect/platform/Error").PlatformError | import("./Domain.js").McpParseError | import("./Domain.js").McpWriteError, never>;
-        readonly uninstall: (host: "claude-code" | "cursor" | "opencode" | "codex", scope: "project" | "global") => Effect.Effect<void, import("@effect/platform/Error").PlatformError | import("./Domain.js").McpParseError | import("./Domain.js").McpWriteError, never>;
-        readonly isInstalled: (host: "claude-code" | "cursor" | "opencode" | "codex", scope: "project" | "global") => Effect.Effect<boolean, import("@effect/platform/Error").PlatformError | import("./Domain.js").McpParseError, never>;
-        readonly pathFor: (host: "claude-code" | "cursor" | "opencode" | "codex", scope: "project" | "global") => Effect.Effect<string, never, never>;
+        readonly install: (host: "claude-code" | "codex" | "cursor" | "opencode", scope: "global" | "project") => Effect.Effect<void, import("./Domain.js").McpParseError | import("./Domain.js").McpWriteError | import("@effect/platform/Error").PlatformError, never>;
+        readonly uninstall: (host: "claude-code" | "codex" | "cursor" | "opencode", scope: "global" | "project") => Effect.Effect<void, import("./Domain.js").McpParseError | import("./Domain.js").McpWriteError | import("@effect/platform/Error").PlatformError, never>;
+        readonly isInstalled: (host: "claude-code" | "codex" | "cursor" | "opencode", scope: "global" | "project") => Effect.Effect<boolean, import("./Domain.js").McpParseError | import("@effect/platform/Error").PlatformError, never>;
+        readonly pathFor: (host: "claude-code" | "codex" | "cursor" | "opencode", scope: "global" | "project") => Effect.Effect<string, never, never>;
     }, never, ClaudeMcp | CodexMcp | CursorMcp | OpencodeMcp>;
 }>;
 /**

package/build/dts/Install/Mcp.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Mcp.d.ts","sourceRoot":"","sources":["../../../src/Install/Mcp.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAS,MAAM,QAAQ,CAAA;AACtC,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAA;AAC3C,OAAO,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAA;AACzC,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAA;AAE3C,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAA;AAE/C,OAAO,EAAE,IAAI,EAAE,aAAa,EAAE,aAAa,EAAE,KAAK,EAAE,MAAM,aAAa,CAAA;;;;;;;;;;AAEvE;;;;;;;;;GASG;AAEH,qBAAa,GAAI,SAAQ,QAkDvB;CAAG"}
+{"version":3,"file":"Mcp.d.ts","sourceRoot":"","sources":["../../../src/Install/Mcp.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAS,MAAM,QAAQ,CAAA;AACtC,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAA;AAC3C,OAAO,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAA;AACzC,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAA;AAE3C,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAA;AAE/C,OAAO,EAAE,IAAI,EAAE,YAAY,EAAE,aAAa,EAAE,aAAa,EAAE,MAAM,aAAa,CAAA;;;;;;;;;;AAE9E;;;;;;;;;GASG;AAEH,qBAAa,GAAI,SAAQ,QAkDvB;CAAG"}

package/build/dts/Install/Opencode/Hook.d.ts

@@ -13,9 +13,10 @@ export declare const PLUGIN_FILE = "expandai-webfetch.js";
 declare const OpencodeHook_base: Effect.Service.Class<OpencodeHook, "@expandai/cli/Install/Opencode/Hook", {
     readonly dependencies: readonly [import("effect/Layer").Layer<FileSystem.FileSystem, never, never>, import("effect/Layer").Layer<Path.Path, never, never>];
     readonly effect: Effect.Effect<{
-        readonly install: (scope: "project" | "global") => Effect.Effect<void, import("@effect/platform/Error").PlatformError, never>;
-        readonly uninstall: (scope: "project" | "global") => Effect.Effect<void, import("@effect/platform/Error").PlatformError, never>;
-    }, import("effect/ConfigError").ConfigError | import("@effect/platform/Error").BadArgument, FileSystem.FileSystem | Path.Path>;
+        readonly install: (scope: "global" | "project") => Effect.Effect<void, import("@effect/platform/Error").PlatformError, never>;
+        readonly uninstall: (scope: "global" | "project") => Effect.Effect<void, import("@effect/platform/Error").PlatformError, never>;
+        readonly pathFor: (scope: "global" | "project") => Effect.Effect<string, never, never>;
+    }, import("@effect/platform/Error").BadArgument | import("effect/ConfigError").ConfigError, FileSystem.FileSystem | Path.Path>;
 }>;
 export declare class OpencodeHook extends OpencodeHook_base {
 }

package/build/dts/Install/Opencode/Hook.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Hook.d.ts","sourceRoot":"","sources":["../../../../src/Install/Opencode/Hook.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,UAAU,EAAE,IAAI,EAAE,MAAM,kBAAkB,CAAA;AAEnD,OAAO,EAAmB,MAAM,EAAS,MAAM,QAAQ,CAAA;AAGvD;;;;;;;;GAQG;AAEH,eAAO,MAAM,WAAW,yBAAyB,CAAA;;;;;;;;AAEjD,qBAAa,YAAa,SAAQ,iBAoChC;CAAG"}
+{"version":3,"file":"Hook.d.ts","sourceRoot":"","sources":["../../../../src/Install/Opencode/Hook.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,UAAU,EAAE,IAAI,EAAE,MAAM,kBAAkB,CAAA;AAEnD,OAAO,EAAmB,MAAM,EAAS,MAAM,QAAQ,CAAA;AAGvD;;;;;;;;GAQG;AAEH,eAAO,MAAM,WAAW,yBAAyB,CAAA;;;;;;;;;AAEjD,qBAAa,YAAa,SAAQ,iBAoChC;CAAG"}

package/build/dts/Install/Opencode/Mcp.d.ts

@@ -1,5 +1,5 @@
 import { Effect, Schema } from 'effect';
-import { ConfigIo, McpParseError, McpWriteError } from '../Domain.js';
+import { CliInvocation, ConfigIo, McpParseError, McpWriteError } from '../Domain.js';
 declare const Entry_base: Schema.Class<Entry, {
     type: Schema.Literal<["local"]>;
     command: Schema.Array$<typeof Schema.String>;
@@ -11,15 +11,15 @@ declare const Entry_base: Schema.Class<Entry, {
     environment: Schema.optional<Schema.Record$<typeof Schema.String, typeof Schema.String>>;
     enabled: Schema.optional<typeof Schema.Boolean>;
 }>, never, {
-    readonly type: "local";
-} & {
-    readonly command: readonly string[];
-} & {
     readonly enabled?: boolean | undefined;
 } & {
     readonly environment?: {
         readonly [x: string]: string;
     } | undefined;
+} & {
+    readonly command: readonly string[];
+} & {
+    readonly type: "local";
 }, {}, {}>;
 /**
  * OpenCode MCP descriptor — its own shape (per opencode.ai/docs/mcp-servers):
@@ -33,13 +33,13 @@ declare const Entry_base: Schema.Class<Entry, {
 export declare class Entry extends Entry_base {
 }
 declare const OpencodeMcp_base: Effect.Service.Class<OpencodeMcp, "@expandai/cli/Install/Opencode/Mcp", {
-    readonly dependencies: readonly [import("effect/Layer").Layer<ConfigIo, never, never>];
+    readonly dependencies: readonly [import("effect/Layer").Layer<ConfigIo, never, never>, import("effect/Layer").Layer<CliInvocation, import("effect/ConfigError").ConfigError, never>];
     readonly effect: Effect.Effect<{
-        readonly install: (scope: "project" | "global") => Effect.Effect<void, McpParseError | McpWriteError, never>;
-        readonly uninstall: (scope: "project" | "global") => Effect.Effect<void, McpParseError | McpWriteError, never>;
-        readonly isInstalled: (scope: "project" | "global") => Effect.Effect<boolean, McpParseError, never>;
-        readonly pathFor: (scope: "project" | "global") => Effect.Effect<string, never, never>;
-    }, import("effect/ConfigError").ConfigError, ConfigIo>;
+        readonly install: (scope: "global" | "project") => Effect.Effect<void, McpParseError | McpWriteError, never>;
+        readonly uninstall: (scope: "global" | "project") => Effect.Effect<void, McpParseError | McpWriteError, never>;
+        readonly isInstalled: (scope: "global" | "project") => Effect.Effect<boolean, McpParseError, never>;
+        readonly pathFor: (scope: "global" | "project") => Effect.Effect<string, never, never>;
+    }, import("effect/ConfigError").ConfigError, CliInvocation | ConfigIo>;
 }>;
 export declare class OpencodeMcp extends OpencodeMcp_base {
 }

package/build/dts/Install/Opencode/Mcp.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Mcp.d.ts","sourceRoot":"","sources":["../../../../src/Install/Opencode/Mcp.ts"],"names":[],"mappings":"AACA,OAAO,EAAmB,MAAM,EAAiB,MAAM,EAAE,MAAM,QAAQ,CAAA;AACvE,OAAO,EAAE,QAAQ,EAAE,aAAa,EAAE,aAAa,EAAoC,MAAM,cAAc,CAAA;;;;;;;;;;;;;;;;;;;;;;AAGvG;;;;;;;;GAQG;AACH,qBAAa,KAAM,SAAQ,UAKzB;CAAG;;;;;;;;;;AAEL,qBAAa,WAAY,SAAQ,gBA8D/B;CAAG"}
+{"version":3,"file":"Mcp.d.ts","sourceRoot":"","sources":["../../../../src/Install/Opencode/Mcp.ts"],"names":[],"mappings":"AACA,OAAO,EAAmB,MAAM,EAAiB,MAAM,EAAE,MAAM,QAAQ,CAAA;AACvE,OAAO,EAAE,aAAa,EAAE,QAAQ,EAAE,aAAa,EAAE,aAAa,EAAoC,MAAM,cAAc,CAAA;;;;;;;;;;;;;;;;;;;;;;AAGtH;;;;;;;;GAQG;AACH,qBAAa,KAAM,SAAQ,UAKzB;CAAG;;;;;;;;;;AAEL,qBAAa,WAAY,SAAQ,gBAiE/B;CAAG"}

package/build/dts/Install/Opencode/Skill.d.ts

@@ -14,8 +14,10 @@ export declare const SKILL_NAME = "expandai";
 declare const OpencodeSkill_base: Effect.Service.Class<OpencodeSkill, "@expandai/cli/Install/Opencode/Skill", {
     readonly dependencies: readonly [import("effect/Layer").Layer<SkillIo, import("@effect/platform/Error").BadArgument, never>];
     readonly effect: Effect.Effect<{
-        readonly install: (scope: "project" | "global") => Effect.Effect<string, import("@effect/platform/Error").PlatformError, never>;
-        readonly uninstall: (scope: "project" | "global") => Effect.Effect<string, import("@effect/platform/Error").PlatformError, never>;
+        readonly install: (scope: "global" | "project") => Effect.Effect<string, import("@effect/platform/Error").PlatformError, never>;
+        readonly uninstall: (scope: "global" | "project") => Effect.Effect<string, import("@effect/platform/Error").PlatformError, never>;
+        readonly isCurrent: (scope: "global" | "project") => Effect.Effect<boolean, import("@effect/platform/Error").PlatformError, never>;
+        readonly pathFor: (scope: "global" | "project") => Effect.Effect<string, never, never>;
     }, import("effect/ConfigError").ConfigError, SkillIo>;
 }>;
 export declare class OpencodeSkill extends OpencodeSkill_base {

package/build/dts/Install/Opencode/Skill.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Skill.d.ts","sourceRoot":"","sources":["../../../../src/Install/Opencode/Skill.ts"],"names":[],"mappings":"AACA,OAAO,EAAU,MAAM,EAAS,MAAM,QAAQ,CAAA;AAC9C,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAA;AAGtC;;;;;;;;;GASG;AAEH,eAAO,MAAM,UAAU,aAAa,CAAA;;;;;;;;AAEpC,qBAAa,aAAc,SAAQ,kBAyBjC;CAAG"}
+{"version":3,"file":"Skill.d.ts","sourceRoot":"","sources":["../../../../src/Install/Opencode/Skill.ts"],"names":[],"mappings":"AACA,OAAO,EAAU,MAAM,EAAS,MAAM,QAAQ,CAAA;AAC9C,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAA;AAGtC;;;;;;;;;GASG;AAEH,eAAO,MAAM,UAAU,aAAa,CAAA;;;;;;;;;;AAEpC,qBAAa,aAAc,SAAQ,kBA6BjC;CAAG"}

package/build/dts/Install/Skill.d.ts

@@ -4,10 +4,10 @@ import { CodexSkill } from './Codex/Skill.js';
 import { CursorSkill } from './Cursor/Skill.js';
 import { OpencodeSkill } from './Opencode/Skill.js';
 declare const Skill_base: Effect.Service.Class<Skill, "@expandai/cli/Install/Skill", {
-    readonly dependencies: readonly [import("effect/Layer").Layer<ClaudeSkill, import("effect/ConfigError").ConfigError | import("@effect/platform/Error").BadArgument, never>, import("effect/Layer").Layer<CursorSkill, import("effect/ConfigError").ConfigError | import("@effect/platform/Error").BadArgument, never>, import("effect/Layer").Layer<OpencodeSkill, import("effect/ConfigError").ConfigError | import("@effect/platform/Error").BadArgument, never>, import("effect/Layer").Layer<CodexSkill, import("effect/ConfigError").ConfigError | import("@effect/platform/Error").BadArgument, never>];
+    readonly dependencies: readonly [import("effect/Layer").Layer<ClaudeSkill, import("@effect/platform/Error").BadArgument | import("effect/ConfigError").ConfigError, never>, import("effect/Layer").Layer<CursorSkill, import("@effect/platform/Error").BadArgument | import("effect/ConfigError").ConfigError, never>, import("effect/Layer").Layer<OpencodeSkill, import("@effect/platform/Error").BadArgument | import("effect/ConfigError").ConfigError, never>, import("effect/Layer").Layer<CodexSkill, import("@effect/platform/Error").BadArgument | import("effect/ConfigError").ConfigError, never>];
     readonly effect: Effect.Effect<{
-        readonly install: (host: "claude-code" | "cursor" | "opencode" | "codex", scope: "project" | "global") => Effect.Effect<void, import("@effect/platform/Error").PlatformError, never>;
-        readonly uninstall: (host: "claude-code" | "cursor" | "opencode" | "codex", scope: "project" | "global") => Effect.Effect<void, import("@effect/platform/Error").PlatformError, never>;
+        readonly install: (host: "claude-code" | "codex" | "cursor" | "opencode", scope: "global" | "project") => Effect.Effect<void, import("@effect/platform/Error").PlatformError, never>;
+        readonly uninstall: (host: "claude-code" | "codex" | "cursor" | "opencode", scope: "global" | "project") => Effect.Effect<void, import("@effect/platform/Error").PlatformError, never>;
     }, never, ClaudeSkill | CodexSkill | CursorSkill | OpencodeSkill>;
 }>;
 /**

package/build/dts/Install/Uninstall.d.ts

@@ -12,19 +12,19 @@ declare const UninstallOptions_base: Schema.Class<UninstallOptions, {
     host: Schema.optional<Schema.Literal<["claude-code", "cursor", "opencode", "codex"]>>;
     scope: Schema.optional<Schema.Literal<["project", "global"]>>;
 }>, never, {
-    readonly scope?: "project" | "global" | undefined;
+    readonly host?: "claude-code" | "codex" | "cursor" | "opencode" | undefined;
 } & {
-    readonly target?: "mcp" | "all" | "hook" | "skill" | undefined;
+    readonly scope?: "global" | "project" | undefined;
 } & {
-    readonly host?: "claude-code" | "cursor" | "opencode" | "codex" | undefined;
+    readonly target?: "all" | "hook" | "mcp" | "skill" | undefined;
 }, {}, {}>;
 export declare class UninstallOptions extends UninstallOptions_base {
 }
 declare const Uninstall_base: Effect.Service.Class<Uninstall, "@expandai/cli/Install/Uninstall", {
-    readonly dependencies: readonly [import("effect/Layer").Layer<HookInstaller, import("effect/ConfigError").ConfigError | import("@effect/platform/Error").BadArgument, never>, import("effect/Layer").Layer<Mcp, import("effect/ConfigError").ConfigError, never>, import("effect/Layer").Layer<Skill, import("effect/ConfigError").ConfigError | import("@effect/platform/Error").BadArgument, never>];
+    readonly dependencies: readonly [import("effect/Layer").Layer<HookInstaller, import("@effect/platform/Error").BadArgument | import("effect/ConfigError").ConfigError, never>, import("effect/Layer").Layer<Mcp, import("effect/ConfigError").ConfigError, never>, import("effect/Layer").Layer<Skill, import("@effect/platform/Error").BadArgument | import("effect/ConfigError").ConfigError, never>];
     readonly effect: Effect.Effect<{
-        readonly uninstall: (options?: UninstallOptions | undefined) => Effect.Effect<void, import("effect/ParseResult").ParseError | import("@effect/platform/Error").PlatformError | import("./Domain.js").McpParseError | import("./Domain.js").McpWriteError, never>;
-    }, never, Mcp | HookInstaller | Skill>;
+        readonly uninstall: (options?: UninstallOptions | undefined) => Effect.Effect<void, import("./Domain.js").McpParseError | import("./Domain.js").McpWriteError | import("effect/ParseResult").ParseError | import("@effect/platform/Error").PlatformError, never>;
+    }, never, HookInstaller | Mcp | Skill>;
 }>;
 export declare class Uninstall extends Uninstall_base {
 }

package/build/dts/Install/Uninstall.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Uninstall.d.ts","sourceRoot":"","sources":["../../../src/Install/Uninstall.ts"],"names":[],"mappings":"AAAA,OAAO,EAAS,MAAM,EAAS,MAAM,EAAE,MAAM,QAAQ,CAAA;AACrD,OAAO,EAAiB,aAAa,EAAE,MAAM,WAAW,CAAA;AACxD,OAAO,EAAQ,GAAG,EAAS,MAAM,UAAU,CAAA;AAC3C,OAAO,EAAE,KAAK,EAAE,MAAM,YAAY,CAAA;AAElC,eAAO,MAAM,eAAe,iDAAgD,CAAA;;;;;;;;;;;;;;;;AAE5E,qBAAa,gBAAiB,SAAQ,qBAIpC;CAAG;;;;;;;AAOL,qBAAa,SAAU,SAAQ,cA+D7B;CAAG"}
+{"version":3,"file":"Uninstall.d.ts","sourceRoot":"","sources":["../../../src/Install/Uninstall.ts"],"names":[],"mappings":"AAAA,OAAO,EAAS,MAAM,EAAS,MAAM,EAAE,MAAM,QAAQ,CAAA;AACrD,OAAO,EAAiB,aAAa,EAAE,MAAM,WAAW,CAAA;AACxD,OAAO,EAAsB,GAAG,EAAE,MAAM,UAAU,CAAA;AAClD,OAAO,EAAE,KAAK,EAAE,MAAM,YAAY,CAAA;AAElC,eAAO,MAAM,eAAe,iDAAgD,CAAA;;;;;;;;;;;;;;;;AAE5E,qBAAa,gBAAiB,SAAQ,qBAIpC;CAAG;;;;;;;AAOL,qBAAa,SAAU,SAAQ,cA+D7B;CAAG"}

package/build/dts/MarkdownAnsi.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Zero-dependency ANSI syntax highlighting for markdown printed to an
+ * interactive terminal.
+ *
+ * This is a highlighter, not a renderer: the input text is preserved
+ * byte-for-byte and only wrapped in ANSI escape sequences, so copying
+ * from the terminal or stripping the escapes yields the exact document
+ * the API returned. Piped output (non-TTY) must stay unstyled — gate
+ * calls with `shouldColorizeMarkdown`.
+ */
+export interface ColorizeEnvironment {
+    readonly isTty: boolean;
+    readonly env: Readonly<Record<string, string | undefined>>;
+}
+/**
+ * Standard CLI color negotiation: color only on an interactive terminal,
+ * `NO_COLOR` (https://no-color.org) and `TERM=dumb` opt out, a non-zero
+ * `FORCE_COLOR` opts in regardless of the terminal.
+ */
+export declare function shouldColorizeMarkdown(environment?: ColorizeEnvironment): boolean;
+/**
+ * Wrap a markdown document in ANSI styles for terminal display. Line-based:
+ * headings, fences, front matter, blockquotes, list markers, and table pipes
+ * get block styling; plain text lines get inline code / link / bold styling.
+ */
+export declare function highlightMarkdownAnsi(markdown: string): string;
+/** Strip the escape sequences this module emits; used to verify lossless styling. */
+export declare function stripAnsi(text: string): string;
+//# sourceMappingURL=MarkdownAnsi.d.ts.map

package/build/dts/MarkdownAnsi.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MarkdownAnsi.d.ts","sourceRoot":"","sources":["../../src/MarkdownAnsi.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAkBH,MAAM,WAAW,mBAAmB;IACnC,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAA;IACvB,QAAQ,CAAC,GAAG,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC,CAAC,CAAA;CAC1D;AAED;;;;GAIG;AACH,wBAAgB,sBAAsB,CACrC,WAAW,GAAE,mBAAgF,GAC3F,OAAO,CAOT;AAmCD;;;;GAIG;AACH,wBAAgB,qBAAqB,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAoE9D;AAED,qFAAqF;AACrF,wBAAgB,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAI9C"}