expandai 0.0.2 → 0.0.4

package/build/dts/Init/HarnessRegistry.d.ts

@@ -0,0 +1,50 @@
+import { Effect, Schema } from 'effect';
+import { ClaudeAdapter } from './ClaudeAdapter.js';
+import type { InitHarness, InitScope } from './Domain.js';
+import type { HarnessConfigurationError, HarnessInspection, HarnessInspectionError } from './HarnessAdapter.js';
+import { CodexAdapter, CursorAdapter, OpencodeAdapter } from './StandardAdapters.js';
+export interface HarnessAdapterContract {
+    readonly harness: InitHarness;
+    readonly inspect: (scope: InitScope) => Effect.Effect<HarnessInspection, HarnessInspectionError>;
+    readonly configure: (scope: InitScope) => Effect.Effect<HarnessInspection, HarnessConfigurationError>;
+}
+interface HarnessRegistryContract {
+    readonly inspect: (harness: InitHarness, scope: InitScope) => Effect.Effect<HarnessInspection, UnsupportedInitHarnessError | HarnessInspectionError>;
+    readonly configure: (harness: InitHarness, scope: InitScope) => Effect.Effect<HarnessInspection, UnsupportedInitHarnessError | HarnessConfigurationError>;
+}
+declare const UnsupportedInitHarnessError_base: Schema.TaggedErrorClass<UnsupportedInitHarnessError, "UnsupportedInitHarnessError", {
+    readonly _tag: Schema.tag<"UnsupportedInitHarnessError">;
+} & {
+    harness: typeof Schema.String;
+}>;
+export declare class UnsupportedInitHarnessError extends UnsupportedInitHarnessError_base {
+    get message(): string;
+}
+declare const HarnessRegistry_base: Effect.Service.Class<HarnessRegistry, "@expandai/cli/Init/HarnessRegistry", {
+    readonly dependencies: readonly [import("effect/Layer").Layer<ClaudeAdapter, import("@effect/platform/Error").BadArgument | import("effect/ConfigError").ConfigError, import("@effect/platform/FileSystem").FileSystem>, import("effect/Layer").Layer<CursorAdapter, import("@effect/platform/Error").BadArgument | import("effect/ConfigError").ConfigError, never>, import("effect/Layer").Layer<OpencodeAdapter, import("@effect/platform/Error").BadArgument | import("effect/ConfigError").ConfigError, never>, import("effect/Layer").Layer<CodexAdapter, import("@effect/platform/Error").BadArgument | import("effect/ConfigError").ConfigError, never>];
+    readonly effect: Effect.Effect<HarnessRegistryContract, never, ClaudeAdapter | CodexAdapter | CursorAdapter | OpencodeAdapter>;
+}>;
+/**
+ * `Default` is the **real** registry, wired to the four adapters.
+ *
+ * It used to be `sync: () => makeRegistry([])` — an empty registry that reported
+ * every harness as unsupported. Nothing consumed it, because `main.ts` and the
+ * tests both built `DefaultWithoutDependencies` with a registry supplied by
+ * hand; but `InitService` and `StatusService` still *declared* it in their
+ * `dependencies`, so the declaration was decorative and would have silently
+ * produced an empty registry for anyone who reached for the obvious layer.
+ * `Effect.Service` always generates `Default`, so the fix is to make it correct
+ * rather than to remove it.
+ */
+export declare class HarnessRegistry extends HarnessRegistry_base {
+    /**
+     * The adapters are statically known at the composition root, so the contract
+     * is enforced by the type. The previous version took `ReadonlyArray<object>`
+     * and proved membership at runtime by walking prototypes and calling
+     * `Context.isTag` on the constructor — reflection standing in for a type, plus
+     * an error channel for a condition the compiler already rules out.
+     */
+    static readonly fromAdapters: (adapters: ReadonlyArray<HarnessAdapterContract>) => HarnessRegistry;
+}
+export {};
+//# sourceMappingURL=HarnessRegistry.d.ts.map

package/build/dts/Init/HarnessRegistry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"HarnessRegistry.d.ts","sourceRoot":"","sources":["../../../src/Init/HarnessRegistry.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAA;AACvC,OAAO,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAA;AAClD,OAAO,KAAK,EAAE,WAAW,EAAE,SAAS,EAAE,MAAM,aAAa,CAAA;AACzD,OAAO,KAAK,EAAE,yBAAyB,EAAE,iBAAiB,EAAE,sBAAsB,EAAE,MAAM,qBAAqB,CAAA;AAC/G,OAAO,EAAE,YAAY,EAAE,aAAa,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAA;AAEpF,MAAM,WAAW,sBAAsB;IACtC,QAAQ,CAAC,OAAO,EAAE,WAAW,CAAA;IAC7B,QAAQ,CAAC,OAAO,EAAE,CAAC,KAAK,EAAE,SAAS,KAAK,MAAM,CAAC,MAAM,CAAC,iBAAiB,EAAE,sBAAsB,CAAC,CAAA;IAChG,QAAQ,CAAC,SAAS,EAAE,CAAC,KAAK,EAAE,SAAS,KAAK,MAAM,CAAC,MAAM,CAAC,iBAAiB,EAAE,yBAAyB,CAAC,CAAA;CACrG;AAED,UAAU,uBAAuB;IAChC,QAAQ,CAAC,OAAO,EAAE,CACjB,OAAO,EAAE,WAAW,EACpB,KAAK,EAAE,SAAS,KACZ,MAAM,CAAC,MAAM,CAAC,iBAAiB,EAAE,2BAA2B,GAAG,sBAAsB,CAAC,CAAA;IAC3F,QAAQ,CAAC,SAAS,EAAE,CACnB,OAAO,EAAE,WAAW,EACpB,KAAK,EAAE,SAAS,KACZ,MAAM,CAAC,MAAM,CAAC,iBAAiB,EAAE,2BAA2B,GAAG,yBAAyB,CAAC,CAAA;CAC9F;;;;;;AAED,qBAAa,2BAA4B,SAAQ,gCAKhD;IACA,IAAI,OAAO,WAEV;CACD;;;;;AA0BD;;;;;;;;;;;GAWG;AACH,qBAAa,eAAgB,SAAQ,oBAMnC;IACD;;;;;;OAMG;IACH,MAAM,CAAC,QAAQ,CAAC,YAAY,aAAc,aAAa,CAAC,sBAAsB,CAAC,qBAClC;CAC7C"}

package/build/dts/Init/MutationTransaction.d.ts

@@ -0,0 +1,96 @@
+import { FileSystem, Path } from '@effect/platform';
+import { Effect, Schema } from 'effect';
+type MutationType = 'write' | 'remove' | 'mkdir';
+interface MutationBase {
+    readonly type: MutationType;
+    readonly path: string;
+    readonly expected?: MutationExpectedState;
+    readonly validate?: Effect.Effect<unknown, unknown>;
+}
+export type MutationExpectedState = {
+    readonly exists: false;
+} | {
+    readonly exists: true;
+    readonly type: 'File';
+    readonly bytes: Uint8Array;
+    readonly mode: number;
+} | {
+    readonly exists: true;
+    readonly type: 'Directory';
+    readonly mode: number;
+};
+export interface WriteMutation extends MutationBase {
+    readonly type: 'write';
+    readonly bytes: Uint8Array;
+    readonly mode?: number;
+}
+export interface RemoveMutation extends MutationBase {
+    readonly type: 'remove';
+}
+export interface MakeDirectoryMutation extends MutationBase {
+    readonly type: 'mkdir';
+    readonly mode?: number;
+}
+export type MutationOperation = WriteMutation | RemoveMutation | MakeDirectoryMutation;
+declare const MutationFailure: Schema.Struct<{
+    path: typeof Schema.String;
+    operation: Schema.Literal<["write", "remove", "mkdir"]>;
+    error: typeof Schema.Defect;
+}>;
+export type MutationFailure = typeof MutationFailure.Type;
+declare const MutationSymlinkError_base: Schema.TaggedErrorClass<MutationSymlinkError, "MutationSymlinkError", {
+    readonly _tag: Schema.tag<"MutationSymlinkError">;
+} & {
+    path: typeof Schema.String;
+}>;
+export declare class MutationSymlinkError extends MutationSymlinkError_base {
+    get message(): string;
+}
+declare const MutationValidationError_base: Schema.TaggedErrorClass<MutationValidationError, "MutationValidationError", {
+    readonly _tag: Schema.tag<"MutationValidationError">;
+} & Readonly<{
+    path: typeof Schema.String;
+    operation: Schema.Literal<["write", "remove", "mkdir"]>;
+    error: typeof Schema.Defect;
+}>>;
+export declare class MutationValidationError extends MutationValidationError_base {
+    get message(): string;
+}
+declare const MutationApplicationError_base: Schema.TaggedErrorClass<MutationApplicationError, "MutationApplicationError", {
+    readonly _tag: Schema.tag<"MutationApplicationError">;
+} & {
+    path: typeof Schema.String;
+    operation: Schema.Literal<["write", "remove", "mkdir"]>;
+    error: typeof Schema.Defect;
+    rollbackFailures: Schema.Array$<Schema.Struct<{
+        path: typeof Schema.String;
+        operation: Schema.Literal<["write", "remove", "mkdir"]>;
+        error: typeof Schema.Defect;
+    }>>;
+}>;
+export declare class MutationApplicationError extends MutationApplicationError_base {
+    get message(): string;
+}
+declare const MutationRollbackError_base: Schema.TaggedErrorClass<MutationRollbackError, "MutationRollbackError", {
+    readonly _tag: Schema.tag<"MutationRollbackError">;
+} & {
+    rollbackFailures: Schema.Array$<Schema.Struct<{
+        path: typeof Schema.String;
+        operation: Schema.Literal<["write", "remove", "mkdir"]>;
+        error: typeof Schema.Defect;
+    }>>;
+}>;
+export declare class MutationRollbackError extends MutationRollbackError_base {
+    get message(): string;
+}
+export type MutationTransactionError = MutationSymlinkError | MutationValidationError | MutationApplicationError | MutationRollbackError;
+declare const MutationTransaction_base: Effect.Service.Class<MutationTransaction, "@expandai/cli/Init/MutationTransaction", {
+    readonly dependencies: readonly [import("effect/Layer").Layer<FileSystem.FileSystem, never, never>, import("effect/Layer").Layer<Path.Path, never, never>];
+    readonly effect: Effect.Effect<{
+        readonly run: (operations: readonly MutationOperation[]) => Effect.Effect<undefined, MutationTransactionError, never>;
+    }, never, FileSystem.FileSystem | Path.Path>;
+}>;
+export declare class MutationTransaction extends MutationTransaction_base {
+}
+export {};
+//# sourceMappingURL=MutationTransaction.d.ts.map

package/build/dts/Init/MutationTransaction.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MutationTransaction.d.ts","sourceRoot":"","sources":["../../../src/Init/MutationTransaction.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,IAAI,EAA0B,MAAM,kBAAkB,CAAA;AAE3E,OAAO,EAAuB,MAAM,EAAqC,MAAM,EAAS,MAAM,QAAQ,CAAA;AAEtG,KAAK,YAAY,GAAG,OAAO,GAAG,QAAQ,GAAG,OAAO,CAAA;AAEhD,UAAU,YAAY;IACrB,QAAQ,CAAC,IAAI,EAAE,YAAY,CAAA;IAC3B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,QAAQ,CAAC,QAAQ,CAAC,EAAE,qBAAqB,CAAA;IACzC,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,CAAC,OAAO,EAAE,OAAO,CAAC,CAAA;CACnD;AAED,MAAM,MAAM,qBAAqB,GAC9B;IAAE,QAAQ,CAAC,MAAM,EAAE,KAAK,CAAA;CAAE,GAC1B;IACA,QAAQ,CAAC,MAAM,EAAE,IAAI,CAAA;IACrB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,QAAQ,CAAC,KAAK,EAAE,UAAU,CAAA;IAC1B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;CACpB,GACD;IACA,QAAQ,CAAC,MAAM,EAAE,IAAI,CAAA;IACrB,QAAQ,CAAC,IAAI,EAAE,WAAW,CAAA;IAC1B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;CACpB,CAAA;AAEJ,MAAM,WAAW,aAAc,SAAQ,YAAY;IAClD,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAA;IACtB,QAAQ,CAAC,KAAK,EAAE,UAAU,CAAA;IAC1B,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAA;CACtB;AAED,MAAM,WAAW,cAAe,SAAQ,YAAY;IACnD,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAA;CACvB;AAED,MAAM,WAAW,qBAAsB,SAAQ,YAAY;IAC1D,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAA;IACtB,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAA;CACtB;AAED,MAAM,MAAM,iBAAiB,GAAG,aAAa,GAAG,cAAc,GAAG,qBAAqB,CAAA;AAEtF,QAAA,MAAM,eAAe;;;;EAInB,CAAA;AAEF,MAAM,MAAM,eAAe,GAAG,OAAO,eAAe,CAAC,IAAI,CAAA;;;;;;AAEzD,qBAAa,oBAAqB,SAAQ,yBAExC;IACD,IAAI,OAAO,WAEV;CACD;;;;;;;;AAqBD,qBAAa,uBAAwB,SAAQ,4BAG5C;IACA,IAAI,OAAO,WAEV;CACD;;;;;;;;;;;;;AAED,qBAAa,wBAAyB,SAAQ,6BAM7C;IACA,IAAI,OAAO,WAIV;CACD;;;;;;;;;;AAED,qBAAa,qBAAsB,SAAQ,0BAEzC;IACD,IAAI,OAAO,WAEV;CACD;AAED,MAAM,MAAM,wBAAwB,GACjC,oBAAoB,GACpB,uBAAuB,GACvB,wBAAwB,GACxB,qBAAqB,CAAA;;;;;;;AAknBxB,qBAAa,mBAAoB,SAAQ,wBAMxC;CAAG"}

package/build/dts/Init/Service.d.ts

@@ -0,0 +1,72 @@
+import { DateTime, Effect, Schema } from 'effect';
+import { ManualAuthorization } from '../Auth/ManualAuthorization.js';
+import { SetupGrantAuthorization } from '../Auth/SetupGrantAuthorization.js';
+import { Authentication } from '../Authentication.js';
+import { type InitRequest } from './Domain.js';
+import { HarnessRegistry } from './HarnessRegistry.js';
+declare const InitServiceError_base: Schema.TaggedErrorClass<InitServiceError, "InitServiceError", {
+    readonly _tag: Schema.tag<"InitServiceError">;
+} & {
+    code: Schema.Literal<["authorization_failed", "setup_token_rejected", "setup_unreachable", "stored_credential_conflict", "authorization_unreachable", "authorization_denied", "authorization_refused", "credential_health_failed", "credential_save_failed", "credential_storage_insecure", "unsupported_harness", "inspection_failed", "configuration_failed", "policy_blocked", "invalid_adapter_result"]>;
+    recoverable: typeof Schema.Boolean;
+}>;
+export declare class InitServiceError extends InitServiceError_base {
+    get message(): "A managed harness policy blocks this configuration." | "An Expand API key is already stored on this machine, and completing setup would replace it with no way to recover it. Nothing was changed and the setup prompt is still valid. Tell the user to run `expandai logout` to clear the stored key, then run the same setup command again." | "Authorization completed, but credentials could not be saved. Start authorization again." | "Authorization could not be completed. Start authorization again." | "Could not reach Expand to redeem the setup token. Nothing was sent, so the same token is still good — check the network and run the same command again." | "Could not reach the Expand API. Nothing was changed: any pending authorization is still pending, and if none existed, none was started. Do not retry the same command until the connection is fixed. Check that this machine can reach the API — if you are running inside an agent sandbox, its shell may have network access disabled — and check `EXPAND_API_URL` if it is set. Then run the same command again." | "Credential storage is not secure enough to continue." | "Expand refused to complete the authorization for a reason a new code cannot fix — most likely an OAuth client, resource, or scope misconfiguration on the server. Do not run setup again; each retry asks the user to approve and then fails the same way. Report the error under `code`." | "Stored credentials could not be validated safely." | "That setup token was rejected and is now spent. Do not retry it. Ask the user for a fresh setup prompt from the Expand dashboard, or continue without one to authorize in a browser." | "The authorization was denied in the browser. If that was unintended, run the same command again for a fresh approval code." | "The harness adapter returned an invalid configuration result." | "The harness configuration could not be inspected safely." | "The harness configuration could not be updated safely." | "This harness is not supported by init.";
+}
+declare const InitService_base: Effect.Service.Class<InitService, "@expandai/cli/Init/Service", {
+    readonly dependencies: readonly [import("effect/Layer").Layer<Authentication, import("@effect/platform/Error").BadArgument | import("effect/ConfigError").ConfigError, never>, import("effect/Layer").Layer<ManualAuthorization, import("effect/ConfigError").ConfigError, never>, import("effect/Layer").Layer<SetupGrantAuthorization, import("effect/ConfigError").ConfigError, never>, import("effect/Layer").Layer<HarnessRegistry, import("@effect/platform/Error").BadArgument | import("effect/ConfigError").ConfigError, import("@effect/platform/FileSystem").FileSystem>];
+    readonly effect: Effect.Effect<{
+        readonly run: (request: InitRequest) => Effect.Effect<{
+            readonly schemaVersion: 1;
+            readonly status: "authorization_required";
+            readonly harnesses: readonly ["claude-code" | "codex" | "cursor" | "opencode", ...("claude-code" | "codex" | "cursor" | "opencode")[]];
+            readonly scope: "global" | "project";
+            readonly userMessage: "Open the approval page in your browser, type in the code shown here, and approve. Only enter this code on the Expand approval page your terminal named — never a code someone sent you, and never on a page from a link you did not expect. When you have approved, say so, and the same command will pick the authorization up.";
+            readonly authorization: {
+                readonly url: URL;
+                readonly userCode: string;
+                readonly approvalExpiresAt: DateTime.Utc;
+            };
+        } | {
+            readonly schemaVersion: 1;
+            readonly status: "completed";
+            readonly harnesses: readonly ["claude-code" | "codex" | "cursor" | "opencode", ...("claude-code" | "codex" | "cursor" | "opencode")[]];
+            readonly scope: "global" | "project";
+            readonly userMessage: "Authorization complete. That setup code has been consumed and cannot be reused." | "Expand is already authorized. Agent setup is complete." | "Expand is authorized, but not every harness could be configured. The harnesses that failed are listed under `failures`; the ones under `installations` are ready to use.";
+            readonly auth: {
+                readonly healthy: boolean;
+            };
+            readonly projectPath?: string | undefined;
+            readonly installations: readonly [{
+                readonly harness: "claude-code" | "codex" | "cursor" | "opencode";
+                readonly configured: boolean;
+                readonly changed: boolean;
+                readonly components: readonly ("mcp" | "runtime-skill" | "webfetch-hook")[];
+                readonly version: string;
+                readonly verification: {
+                    readonly runtimeState: "blocked" | "observed" | "reload_required" | "unverified";
+                    readonly nextAction: string;
+                };
+            }, ...{
+                readonly harness: "claude-code" | "codex" | "cursor" | "opencode";
+                readonly configured: boolean;
+                readonly changed: boolean;
+                readonly components: readonly ("mcp" | "runtime-skill" | "webfetch-hook")[];
+                readonly version: string;
+                readonly verification: {
+                    readonly runtimeState: "blocked" | "observed" | "reload_required" | "unverified";
+                    readonly nextAction: string;
+                };
+            }[]];
+            readonly failures?: readonly {
+                readonly harness: "claude-code" | "codex" | "cursor" | "opencode";
+                readonly code: string;
+                readonly recoverable: boolean;
+            }[] | undefined;
+        }, InitServiceError, never>;
+    }, never, Authentication | HarnessRegistry | ManualAuthorization | SetupGrantAuthorization>;
+}>;
+export declare class InitService extends InitService_base {
+}
+export {};
+//# sourceMappingURL=Service.d.ts.map

package/build/dts/Init/Service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Service.d.ts","sourceRoot":"","sources":["../../../src/Init/Service.ts"],"names":[],"mappings":"AAAA,OAAO,EAA0B,QAAQ,EAAE,MAAM,EAAU,MAAM,EAAE,MAAM,QAAQ,CAAA;AAEjF,OAAO,EACN,mBAAmB,EAKnB,MAAM,gCAAgC,CAAA;AACvC,OAAO,EAAE,uBAAuB,EAAgC,MAAM,oCAAoC,CAAA;AAC1G,OAAO,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAA;AAErD,OAAO,EAKN,KAAK,WAAW,EAGhB,MAAM,aAAa,CAAA;AAEpB,OAAO,EAAE,eAAe,EAA+B,MAAM,sBAAsB,CAAA;;;;;;;AAoBnF,qBAAa,gBAAiB,SAAQ,qBAGpC;IACD,IAAI,OAAO,m9DA8CV;CACD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAsHD,qBAAa,WAAY,SAAQ,gBA6K/B;CAAG"}

package/build/dts/Init/StandardAdapters.d.ts

@@ -0,0 +1,42 @@
+import { FileSystem } from '@effect/platform';
+import { Effect } from 'effect';
+import { CodexMcp } from '../Install/Codex/Mcp.js';
+import { CodexSkill } from '../Install/Codex/Skill.js';
+import { CursorMcp } from '../Install/Cursor/Mcp.js';
+import { CursorSkill } from '../Install/Cursor/Skill.js';
+import { OpencodeHook } from '../Install/Opencode/Hook.js';
+import { OpencodeMcp } from '../Install/Opencode/Mcp.js';
+import { OpencodeSkill } from '../Install/Opencode/Skill.js';
+import { HarnessConfigurationError, type HarnessInspection, HarnessInspectionError } from './HarnessAdapter.js';
+declare const CursorAdapter_base: Effect.Service.Class<CursorAdapter, "@expandai/cli/Init/CursorAdapter", {
+    readonly dependencies: readonly [import("effect/Layer").Layer<CursorMcp, import("effect/ConfigError").ConfigError, never>, import("effect/Layer").Layer<CursorSkill, import("@effect/platform/Error").BadArgument | import("effect/ConfigError").ConfigError, never>];
+    readonly effect: Effect.Effect<{
+        readonly harness: "claude-code" | "codex" | "cursor" | "opencode";
+        readonly inspect: (scope: "global" | "project") => Effect.Effect<HarnessInspection, HarnessInspectionError, never>;
+        readonly configure: (scope: "global" | "project") => Effect.Effect<HarnessInspection, HarnessConfigurationError, never>;
+    }, never, CursorMcp | CursorSkill>;
+}>;
+export declare class CursorAdapter extends CursorAdapter_base {
+}
+declare const CodexAdapter_base: Effect.Service.Class<CodexAdapter, "@expandai/cli/Init/CodexAdapter", {
+    readonly dependencies: readonly [import("effect/Layer").Layer<CodexMcp, 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 harness: "claude-code" | "codex" | "cursor" | "opencode";
+        readonly inspect: (scope: "global" | "project") => Effect.Effect<HarnessInspection, HarnessInspectionError, never>;
+        readonly configure: (scope: "global" | "project") => Effect.Effect<HarnessInspection, HarnessConfigurationError, never>;
+    }, never, CodexMcp | CodexSkill>;
+}>;
+export declare class CodexAdapter extends CodexAdapter_base {
+}
+declare const OpencodeAdapter_base: Effect.Service.Class<OpencodeAdapter, "@expandai/cli/Init/OpencodeAdapter", {
+    readonly dependencies: readonly [import("effect/Layer").Layer<FileSystem.FileSystem, never, never>, import("effect/Layer").Layer<OpencodeHook, import("@effect/platform/Error").BadArgument | import("effect/ConfigError").ConfigError, never>, import("effect/Layer").Layer<OpencodeMcp, import("effect/ConfigError").ConfigError, never>, import("effect/Layer").Layer<OpencodeSkill, import("@effect/platform/Error").BadArgument | import("effect/ConfigError").ConfigError, never>];
+    readonly effect: Effect.Effect<{
+        readonly harness: "claude-code" | "codex" | "cursor" | "opencode";
+        readonly inspect: (scope: "global" | "project") => Effect.Effect<HarnessInspection, HarnessInspectionError, never>;
+        readonly configure: (scope: "global" | "project") => Effect.Effect<HarnessInspection, HarnessConfigurationError, never>;
+    }, never, FileSystem.FileSystem | OpencodeHook | OpencodeMcp | OpencodeSkill>;
+}>;
+export declare class OpencodeAdapter extends OpencodeAdapter_base {
+}
+export {};
+//# sourceMappingURL=StandardAdapters.d.ts.map

package/build/dts/Init/StandardAdapters.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"StandardAdapters.d.ts","sourceRoot":"","sources":["../../../src/Init/StandardAdapters.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAA;AAE7C,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAA;AAC/B,OAAO,EAAE,QAAQ,EAAE,MAAM,yBAAyB,CAAA;AAClD,OAAO,EAAE,UAAU,EAAE,MAAM,2BAA2B,CAAA;AACtD,OAAO,EAAE,SAAS,EAAE,MAAM,0BAA0B,CAAA;AACpD,OAAO,EAAE,WAAW,EAAE,MAAM,4BAA4B,CAAA;AACxD,OAAO,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAA;AAC1D,OAAO,EAAE,WAAW,EAAE,MAAM,4BAA4B,CAAA;AACxD,OAAO,EAAE,aAAa,EAAE,MAAM,8BAA8B,CAAA;AAG5D,OAAO,EAAE,yBAAyB,EAAE,KAAK,iBAAiB,EAAE,sBAAsB,EAAE,MAAM,qBAAqB,CAAA;;;;;;;;;AAoD/G,qBAAa,aAAc,SAAQ,kBAuBjC;CAAG;;;;;;;;;AAEL,qBAAa,YAAa,SAAQ,iBAuBhC;CAAG;;;;;;;;;AAEL,qBAAa,eAAgB,SAAQ,oBA0BnC;CAAG"}

package/build/dts/Init/Status.d.ts

@@ -0,0 +1,149 @@
+import { DateTime, Effect, Schema } from 'effect';
+import { PendingInitStore } from '../Auth/PendingInit.js';
+import { ConfigManager } from '../Config.js';
+import { HarnessRegistry } from './HarnessRegistry.js';
+declare const StatusRequest_base: Schema.Class<StatusRequest, {
+    harness: Schema.Literal<["claude-code", "cursor", "opencode", "codex"]>;
+    scope: Schema.Literal<["project", "global"]>;
+}, Schema.Struct.Encoded<{
+    harness: Schema.Literal<["claude-code", "cursor", "opencode", "codex"]>;
+    scope: Schema.Literal<["project", "global"]>;
+}>, never, {
+    readonly harness: "claude-code" | "codex" | "cursor" | "opencode";
+} & {
+    readonly scope: "global" | "project";
+}, {}, {}>;
+export declare class StatusRequest extends StatusRequest_base {
+}
+declare const StatusResult_base: Schema.Class<StatusResult, {
+    schemaVersion: Schema.Literal<[1]>;
+    status: Schema.Literal<["ok"]>;
+    harness: Schema.Literal<["claude-code", "cursor", "opencode", "codex"]>;
+    scope: Schema.Literal<["project", "global"]>;
+    cli: Schema.Struct<{
+        version: Schema.filter<Schema.filter<Schema.filter<typeof Schema.String>>>;
+    }>;
+    auth: Schema.Struct<{
+        state: Schema.Literal<["absent", "unusable", "refresh_required", "healthy"]>;
+        healthy: typeof Schema.Boolean;
+    }>;
+    pendingAuthorization: Schema.Union<[Schema.Struct<{
+        state: Schema.Literal<["none"]>;
+        count: Schema.Literal<[0]>;
+    }>, Schema.Struct<{
+        state: Schema.Literal<["approval_pending"]>;
+        count: Schema.Literal<[1]>;
+        approvalExpiresAt: typeof Schema.DateTimeUtc;
+    }>]>;
+    installation: Schema.Struct<{
+        configured: typeof Schema.Boolean;
+        integrationVersion: Schema.optional<Schema.filter<Schema.filter<Schema.filter<typeof Schema.String>>>>;
+        components: Schema.Struct<{
+            webfetchHook: typeof Schema.Boolean;
+            runtimeSkill: typeof Schema.Boolean;
+            mcp: typeof Schema.Boolean;
+        }>;
+        runtimeState: Schema.Literal<["unverified", "reload_required", "blocked"]>;
+        reloadState: Schema.Literal<["not_required", "required"]>;
+        consentState: Schema.Literal<["not_required", "may_be_required"]>;
+        policyState: Schema.Literal<["unverified", "blocked"]>;
+        policyCodes: Schema.filter<Schema.Array$<Schema.Literal<["managed_policy_blocked", "target_read_only"]>>>;
+    }>;
+}, Schema.Struct.Encoded<{
+    schemaVersion: Schema.Literal<[1]>;
+    status: Schema.Literal<["ok"]>;
+    harness: Schema.Literal<["claude-code", "cursor", "opencode", "codex"]>;
+    scope: Schema.Literal<["project", "global"]>;
+    cli: Schema.Struct<{
+        version: Schema.filter<Schema.filter<Schema.filter<typeof Schema.String>>>;
+    }>;
+    auth: Schema.Struct<{
+        state: Schema.Literal<["absent", "unusable", "refresh_required", "healthy"]>;
+        healthy: typeof Schema.Boolean;
+    }>;
+    pendingAuthorization: Schema.Union<[Schema.Struct<{
+        state: Schema.Literal<["none"]>;
+        count: Schema.Literal<[0]>;
+    }>, Schema.Struct<{
+        state: Schema.Literal<["approval_pending"]>;
+        count: Schema.Literal<[1]>;
+        approvalExpiresAt: typeof Schema.DateTimeUtc;
+    }>]>;
+    installation: Schema.Struct<{
+        configured: typeof Schema.Boolean;
+        integrationVersion: Schema.optional<Schema.filter<Schema.filter<Schema.filter<typeof Schema.String>>>>;
+        components: Schema.Struct<{
+            webfetchHook: typeof Schema.Boolean;
+            runtimeSkill: typeof Schema.Boolean;
+            mcp: typeof Schema.Boolean;
+        }>;
+        runtimeState: Schema.Literal<["unverified", "reload_required", "blocked"]>;
+        reloadState: Schema.Literal<["not_required", "required"]>;
+        consentState: Schema.Literal<["not_required", "may_be_required"]>;
+        policyState: Schema.Literal<["unverified", "blocked"]>;
+        policyCodes: Schema.filter<Schema.Array$<Schema.Literal<["managed_policy_blocked", "target_read_only"]>>>;
+    }>;
+}>, never, {
+    readonly auth: {
+        readonly state: "absent" | "healthy" | "refresh_required" | "unusable";
+        readonly healthy: boolean;
+    };
+} & {
+    readonly cli: {
+        readonly version: string;
+    };
+} & {
+    readonly harness: "claude-code" | "codex" | "cursor" | "opencode";
+} & {
+    readonly installation: {
+        readonly configured: boolean;
+        readonly integrationVersion?: string | undefined;
+        readonly components: {
+            readonly webfetchHook: boolean;
+            readonly runtimeSkill: boolean;
+            readonly mcp: boolean;
+        };
+        readonly runtimeState: "blocked" | "reload_required" | "unverified";
+        readonly reloadState: "not_required" | "required";
+        readonly consentState: "may_be_required" | "not_required";
+        readonly policyState: "blocked" | "unverified";
+        readonly policyCodes: readonly ("managed_policy_blocked" | "target_read_only")[];
+    };
+} & {
+    readonly pendingAuthorization: {
+        readonly state: "none";
+        readonly count: 0;
+    } | {
+        readonly state: "approval_pending";
+        readonly count: 1;
+        readonly approvalExpiresAt: DateTime.Utc;
+    };
+} & {
+    readonly schemaVersion: 1;
+} & {
+    readonly scope: "global" | "project";
+} & {
+    readonly status: "ok";
+}, {}, {}>;
+export declare class StatusResult extends StatusResult_base {
+}
+export declare const StatusServiceErrorCode: Schema.Literal<["credential_config_malformed", "credential_storage_insecure", "credential_health_failed", "pending_state_malformed", "pending_state_unavailable", "harness_inspection_failed", "invalid_status_result"]>;
+declare const StatusServiceError_base: Schema.TaggedErrorClass<StatusServiceError, "StatusServiceError", {
+    readonly _tag: Schema.tag<"StatusServiceError">;
+} & {
+    code: Schema.Literal<["credential_config_malformed", "credential_storage_insecure", "credential_health_failed", "pending_state_malformed", "pending_state_unavailable", "harness_inspection_failed", "invalid_status_result"]>;
+    recoverable: typeof Schema.Boolean;
+}>;
+export declare class StatusServiceError extends StatusServiceError_base {
+    get message(): "Credential storage is not secure enough to inspect." | "Local diagnostics returned an invalid result." | "Pending authorization state could not be inspected safely." | "Pending authorization state is malformed." | "Stored credential configuration is malformed." | "Stored credentials could not be inspected safely." | "The harness configuration could not be inspected safely.";
+}
+declare const StatusService_base: Effect.Service.Class<StatusService, "@expandai/cli/Init/StatusService", {
+    readonly dependencies: readonly [import("effect/Layer").Layer<ConfigManager, import("effect/ConfigError").ConfigError, never>, import("effect/Layer").Layer<PendingInitStore, import("effect/ConfigError").ConfigError, never>, import("effect/Layer").Layer<HarnessRegistry, import("@effect/platform/Error").BadArgument | import("effect/ConfigError").ConfigError, import("@effect/platform/FileSystem").FileSystem>];
+    readonly effect: Effect.Effect<{
+        readonly run: (request: StatusRequest) => Effect.Effect<StatusResult, StatusServiceError, never>;
+    }, never, ConfigManager | HarnessRegistry | PendingInitStore>;
+}>;
+export declare class StatusService extends StatusService_base {
+}
+export {};
+//# sourceMappingURL=Status.d.ts.map

package/build/dts/Init/Status.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Status.d.ts","sourceRoot":"","sources":["../../../src/Init/Status.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,EAAU,MAAM,EAAE,MAAM,QAAQ,CAAA;AAOzD,OAAO,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAA;AAEzD,OAAO,EAAE,aAAa,EAA+D,MAAM,cAAc,CAAA;AAKzG,OAAO,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAA;;;;;;;;;;;;AAKtD,qBAAa,aAAc,SAAQ,kBAGjC;CAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAkCL,qBAAa,YAAa,SAAQ,iBAShC;CAAG;AAEL,eAAO,MAAM,sBAAsB,0NAQlC,CAAA;;;;;;;AAED,qBAAa,kBAAmB,SAAQ,uBAGtC;IACD,IAAI,OAAO,8XAiBV;CACD;;;;;;;AAoGD,qBAAa,aAAc,SAAQ,kBAqDjC;CAAG"}

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

@@ -1,59 +1,87 @@
 import { Effect, Schema } from 'effect';
-import { ConfigIo } from '../Domain.js';
+import { type CliCommand, ConfigIo } from '../Domain.js';
+/** Claude Code WebFetch hook invocation persisted in harness settings. */
+export declare const HOOK_INVOCATION = "expandai hook claude-code";
+export declare const HOOK_COMMAND = "expandai hook claude-code";
 /**
- * Claude Code hook config — `~/.claude/settings.json` (global) or
- * `<cwd>/.claude/settings.json` (project). PreToolUse hooks fire on built-in
- * tools; we register the WebFetch matcher to route to `expandai hook claude-code`.
+ * The hook line for a resolved CLI. Defaults to the bare `expandai` command;
+ * when the CLI is not on PATH — an `npx expandai init` with no global install —
+ * `CliInvocation` resolves to the npx form and the written hook stays runnable.
  */
-export declare const HOOK_COMMAND = "expandai hook claude-code";
+export declare function hookCommandFor(cli?: CliCommand): string;
 export declare const WEBFETCH_MATCHER = "WebFetch";
-export declare const HookCommandEntry: Schema.Struct<{
+export declare const HookCommandEntry: Schema.TypeLiteral<{
     type: Schema.Literal<["command"]>;
     command: typeof Schema.String;
-}>;
-export declare const HookMatcher: Schema.Struct<{
+    expandaiProfileVersion: Schema.optional<typeof Schema.String>;
+    /** Whether this install added the `WebFetch` deny rule — see `makeExpandaiMatcher`. */
+    expandaiManagedDeny: Schema.optional<typeof Schema.Boolean>;
+}, readonly [Schema.Record$<typeof Schema.String, typeof Schema.Unknown>]>;
+export declare const HookMatcher: Schema.TypeLiteral<{
     matcher: Schema.optional<typeof Schema.String>;
-    hooks: Schema.Array$<Schema.Struct<{
+    hooks: Schema.Array$<Schema.TypeLiteral<{
         type: Schema.Literal<["command"]>;
         command: typeof Schema.String;
-    }>>;
-}>;
+        expandaiProfileVersion: Schema.optional<typeof Schema.String>;
+        /** Whether this install added the `WebFetch` deny rule — see `makeExpandaiMatcher`. */
+        expandaiManagedDeny: Schema.optional<typeof Schema.Boolean>;
+    }, readonly [Schema.Record$<typeof Schema.String, typeof Schema.Unknown>]>>;
+}, readonly [Schema.Record$<typeof Schema.String, typeof Schema.Unknown>]>;
 declare const HooksSection: Schema.TypeLiteral<{
-    PreToolUse: Schema.optional<Schema.Array$<Schema.Struct<{
+    PreToolUse: Schema.optional<Schema.Array$<Schema.TypeLiteral<{
         matcher: Schema.optional<typeof Schema.String>;
-        hooks: Schema.Array$<Schema.Struct<{
+        hooks: Schema.Array$<Schema.TypeLiteral<{
             type: Schema.Literal<["command"]>;
             command: typeof Schema.String;
-        }>>;
-    }>>>;
+            expandaiProfileVersion: Schema.optional<typeof Schema.String>;
+            /** Whether this install added the `WebFetch` deny rule — see `makeExpandaiMatcher`. */
+            expandaiManagedDeny: Schema.optional<typeof Schema.Boolean>;
+        }, readonly [Schema.Record$<typeof Schema.String, typeof Schema.Unknown>]>>;
+    }, readonly [Schema.Record$<typeof Schema.String, typeof Schema.Unknown>]>>>;
 }, readonly [Schema.Record$<typeof Schema.String, typeof Schema.Unknown>]>;
 export declare const SettingsSchema: Schema.transform<Schema.SchemaClass<unknown, string, never>, Schema.TypeLiteral<{
     hooks: Schema.optionalWith<Schema.TypeLiteral<{
-        PreToolUse: Schema.optional<Schema.Array$<Schema.Struct<{
+        PreToolUse: Schema.optional<Schema.Array$<Schema.TypeLiteral<{
             matcher: Schema.optional<typeof Schema.String>;
-            hooks: Schema.Array$<Schema.Struct<{
+            hooks: Schema.Array$<Schema.TypeLiteral<{
                 type: Schema.Literal<["command"]>;
                 command: typeof Schema.String;
-            }>>;
-        }>>>;
+                expandaiProfileVersion: Schema.optional<typeof Schema.String>;
+                /** Whether this install added the `WebFetch` deny rule — see `makeExpandaiMatcher`. */
+                expandaiManagedDeny: Schema.optional<typeof Schema.Boolean>;
+            }, readonly [Schema.Record$<typeof Schema.String, typeof Schema.Unknown>]>>;
+        }, readonly [Schema.Record$<typeof Schema.String, typeof Schema.Unknown>]>>>;
     }, readonly [Schema.Record$<typeof Schema.String, typeof Schema.Unknown>]>, {
         default: () => typeof HooksSection.Type;
     }>;
+    permissions: Schema.optional<Schema.TypeLiteral<{
+        deny: Schema.optional<Schema.Array$<typeof Schema.String>>;
+    }, readonly [Schema.Record$<typeof Schema.String, typeof Schema.Unknown>]>>;
 }, readonly [Schema.Record$<typeof Schema.String, typeof Schema.Unknown>]>>;
-export declare const expandaiMatcher: {
-    matcher: string;
-    hooks: {
-        type: "command";
-        command: string;
-    }[];
-};
+export interface ClaudeHookPlan {
+    readonly changed: boolean;
+    readonly settings: typeof SettingsSchema.Type;
+}
+export declare function isExpandaiHookCommand(command: string): boolean;
 declare const ClaudeHook_base: Effect.Service.Class<ClaudeHook, "@expandai/cli/Install/Claude/Hook", {
     readonly dependencies: readonly [import("effect/Layer").Layer<ConfigIo, never, never>];
     readonly effect: Effect.Effect<{
-        readonly install: (scope: "project" | "global") => Effect.Effect<void, import("effect/ParseResult").ParseError | import("@effect/platform/Error").PlatformError, never>;
-        readonly uninstall: (scope: "project" | "global") => Effect.Effect<void, import("effect/ParseResult").ParseError | import("@effect/platform/Error").PlatformError, never>;
-    }, import("effect/ConfigError").ConfigError, ConfigIo>;
+        readonly install: (_scope: "global" | "project") => Effect.Effect<void, never, never>;
+        readonly uninstall: (_scope: "global" | "project") => Effect.Effect<void, never, never>;
+        readonly pathFor: (scope: "global" | "project") => Effect.Effect<string, never, never>;
+    }, import("effect/ConfigError").ConfigError, never>;
 }>;
+/**
+ * Nothing here writes to `settings.json`, and nothing here removes from it.
+ *
+ * A `WebFetch` deny entry is a bare string with nowhere to record who wrote it,
+ * and our hook is not proof either: `hook install` used to write the hook on its
+ * own, so a settings file carrying our hook and a `WebFetch` deny may well hold a
+ * rule the user added afterwards. Removing it would revoke a restriction its
+ * owner chose. Since Claude Code no longer gets a hook or a deny rule from us,
+ * there is nothing of ours left to clean up, and guessing is the only thing a
+ * cleanup pass could do.
+ */
 export declare class ClaudeHook extends ClaudeHook_base {
 }
 export {};

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

@@ -1 +1 @@
-{"version":3,"file":"Hook.d.ts","sourceRoot":"","sources":["../../../../src/Install/Claude/Hook.ts"],"names":[],"mappings":"AACA,OAAO,EAA0B,MAAM,EAAS,MAAM,EAAE,MAAM,QAAQ,CAAA;AACtE,OAAO,EAAE,QAAQ,EAAE,MAAM,cAAc,CAAA;AAGvC;;;;GAIG;AAEH,eAAO,MAAM,YAAY,8BAA8B,CAAA;AACvD,eAAO,MAAM,gBAAgB,aAAa,CAAA;AAE1C,eAAO,MAAM,gBAAgB;;;EAG3B,CAAA;AAEF,eAAO,MAAM,WAAW;;;;;;EAGtB,CAAA;AAEF,QAAA,MAAM,YAAY;;;;;;;;0EAGjB,CAAA;AAED,eAAO,MAAM,cAAc;;;;;;;;;;uBAE2C,OAAO,YAAY,CAAC,IAAI;;2EAI7F,CAAA;AAED,eAAO,MAAM,eAAe;;;;;;CAG3B,CAAA;;;;;;;;AAED,qBAAa,UAAW,SAAQ,eA0F9B;CAAG"}
+{"version":3,"file":"Hook.d.ts","sourceRoot":"","sources":["../../../../src/Install/Claude/Hook.ts"],"names":[],"mappings":"AACA,OAAO,EAAmB,MAAM,EAAS,MAAM,EAAE,MAAM,QAAQ,CAAA;AAC/D,OAAO,EAAE,KAAK,UAAU,EAAE,QAAQ,EAA+B,MAAM,cAAc,CAAA;AAGrF,0EAA0E;AAC1E,eAAO,MAAM,eAAe,8BAA8B,CAAA;AAC1D,eAAO,MAAM,YAAY,8BAAkB,CAAA;AAG3C;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,GAAG,GAAE,UAAuB,GAAG,MAAM,CAEnE;AACD,eAAO,MAAM,gBAAgB,aAAa,CAAA;AAE1C,eAAO,MAAM,gBAAgB;;;;IAK3B,uFAAuF;;0EAIxF,CAAA;AAED,eAAO,MAAM,WAAW;;;;;;QANtB,uFAAuF;;;0EAYxF,CAAA;AAED,QAAA,MAAM,YAAY;;;;;;;YAdhB,uFAAuF;;;;0EAiBxF,CAAA;AAOD,eAAO,MAAM,cAAc;;;;;;;;gBAxBzB,uFAAuF;;;;;uBA2BpB,OAAO,YAAY,CAAC,IAAI;;;;;2EAM5F,CAAA;AAED,MAAM,WAAW,cAAc;IAC9B,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAA;IACzB,QAAQ,CAAC,QAAQ,EAAE,OAAO,cAAc,CAAC,IAAI,CAAA;CAC7C;AAED,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAW9D;;;;;;;;;AAED;;;;;;;;;;GAUG;AAEH,qBAAa,UAAW,SAAQ,eAgC9B;CAAG"}

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 {