expandai 0.0.2 → 0.0.4

package/build/dts/Config.d.ts

@@ -1,7 +1,28 @@
-import { FileSystem, Path } from '@effect/platform';
-import { DateTime, Effect, Schema } from 'effect';
+/**
+ * CLI configuration. Persisted at `$XDG_CONFIG_HOME/expandai/config.json`
+ * (default `~/.config/expandai/config.json`). `EXPAND_API_URL` overrides the
+ * file. `EXPAND_API_KEY` overrides an API key stored in the file, but not
+ * credentials established by `expandai login` or agent setup — signing in is a
+ * deliberate act, and an exported API key usually is not. `EXPAND_APP_URL`
+ * points guide links at the web app serving them.
+ */
+import { CommandExecutor, FileSystem, Path, Error as PlatformError } from '@effect/platform';
+import { NodeContext } from '@effect/platform-node';
+import { Config, DateTime, Effect, Option, Redacted, Schema } from 'effect';
 /** Production API endpoint used when neither `EXPAND_API_URL` nor the config file overrides it. */
 export declare const DEFAULT_API_URL = "https://api.expand.ai";
+/** Production web app used when `EXPAND_APP_URL` does not override it. */
+export declare const DEFAULT_APP_URL = "https://expand.ai";
+/**
+ * Lenient env readers. `Config.option` / `Config.withDefault` only absorb
+ * missing data — a present-but-malformed value (`CLAUDECODE=banana`,
+ * `EXPANDAI_HARNESS=bogus`) fails as InvalidData and would crash the CLI at
+ * layer construction. These read the raw string and degrade gracefully:
+ * flags follow the DO_NOT_TRACK convention (set unless an explicit off),
+ * literals decode to None instead of failing.
+ */
+export declare const envFlag: (name: string) => Config.Config<boolean>;
+export declare const envLiteral: <A extends string>(name: string, schema: Schema.Schema<A, A>) => Config.Config<Option.Option<A>>;
 export declare const ApiKey: Schema.Redacted<Schema.brand<typeof Schema.NonEmptyTrimmedString, "ApiKey">>;
 export declare const ApiKeyConfig: Schema.TaggedStruct<"ApiKey", {
     apiKey: Schema.Redacted<Schema.brand<typeof Schema.NonEmptyTrimmedString, "ApiKey">>;
@@ -10,6 +31,12 @@ export declare const OAuthConfig: Schema.TaggedStruct<"OAuth", {
     accessToken: Schema.Redacted<typeof Schema.String>;
     refreshToken: Schema.optional<Schema.Redacted<typeof Schema.String>>;
     expiresAt: typeof Schema.DateTimeUtc;
+    clientId: Schema.optional<typeof Schema.String>;
+}>;
+export declare const TelemetrySettings: Schema.Struct<{
+    enabled: Schema.optional<typeof Schema.Boolean>;
+    distinctId: Schema.optional<typeof Schema.String>;
+    noticeShown: Schema.optional<typeof Schema.Boolean>;
 }>;
 declare const ExpandCliConfig_base: Schema.Class<ExpandCliConfig, {
     apiUrl: Schema.optional<typeof Schema.URL>;
@@ -19,7 +46,13 @@ declare const ExpandCliConfig_base: Schema.Class<ExpandCliConfig, {
         accessToken: Schema.Redacted<typeof Schema.String>;
         refreshToken: Schema.optional<Schema.Redacted<typeof Schema.String>>;
         expiresAt: typeof Schema.DateTimeUtc;
+        clientId: Schema.optional<typeof Schema.String>;
     }>]>>;
+    telemetry: Schema.optional<Schema.Struct<{
+        enabled: Schema.optional<typeof Schema.Boolean>;
+        distinctId: Schema.optional<typeof Schema.String>;
+        noticeShown: Schema.optional<typeof Schema.Boolean>;
+    }>>;
 }, Schema.Struct.Encoded<{
     apiUrl: Schema.optional<typeof Schema.URL>;
     authMethod: Schema.optional<Schema.Union<[Schema.TaggedStruct<"ApiKey", {
@@ -28,23 +61,49 @@ declare const ExpandCliConfig_base: Schema.Class<ExpandCliConfig, {
         accessToken: Schema.Redacted<typeof Schema.String>;
         refreshToken: Schema.optional<Schema.Redacted<typeof Schema.String>>;
         expiresAt: typeof Schema.DateTimeUtc;
+        clientId: Schema.optional<typeof Schema.String>;
     }>]>>;
+    telemetry: Schema.optional<Schema.Struct<{
+        enabled: Schema.optional<typeof Schema.Boolean>;
+        distinctId: Schema.optional<typeof Schema.String>;
+        noticeShown: Schema.optional<typeof Schema.Boolean>;
+    }>>;
 }>, never, {
     readonly apiUrl?: URL | undefined;
 } & {
     readonly authMethod?: {
-        readonly apiKey: import("effect/Redacted").Redacted<string & import("effect/Brand").Brand<"ApiKey">>;
         readonly _tag: "ApiKey";
+        readonly apiKey: Redacted.Redacted<string & import("effect/Brand").Brand<"ApiKey">>;
     } | {
-        readonly accessToken: import("effect/Redacted").Redacted<string>;
-        readonly refreshToken?: import("effect/Redacted").Redacted<string> | undefined;
-        readonly expiresAt: DateTime.Utc;
         readonly _tag: "OAuth";
+        readonly accessToken: Redacted.Redacted<string>;
+        readonly refreshToken?: Redacted.Redacted<string> | undefined;
+        readonly expiresAt: DateTime.Utc;
+        readonly clientId?: string | undefined;
+    } | undefined;
+} & {
+    readonly telemetry?: {
+        readonly enabled?: boolean | undefined;
+        readonly distinctId?: string | undefined;
+        readonly noticeShown?: boolean | undefined;
     } | undefined;
 }, {}, {}>;
 export declare class ExpandCliConfig extends ExpandCliConfig_base {
     static readonly Json: Schema.transform<Schema.SchemaClass<unknown, string, never>, typeof ExpandCliConfig>;
 }
+export type AuthMethod = typeof ApiKeyConfig.Type | typeof OAuthConfig.Type;
+/**
+ * How a stored credential stands right now.
+ *
+ * `refresh_required` is deliberately distinct from `healthy`: an expired access
+ * token with a refresh token on disk is only a credential we *could* renew, and
+ * renewal can fail. Reporting it as healthy told agents a machine was authorized
+ * when the next call would fail.
+ */
+export type AuthMethodState = 'healthy' | 'refresh_required' | 'unusable';
+export declare function authMethodState(authMethod: AuthMethod, now: DateTime.Utc): AuthMethodState;
+/** Returns whether a local credential can be used now or renewed on first API use. */
+export declare function isAuthMethodLocallyUsable(authMethod: AuthMethod, now: DateTime.Utc): boolean;
 declare const ConfigNotWritable_base: Schema.TaggedErrorClass<ConfigNotWritable, "ConfigNotWritable", {
     readonly _tag: Schema.tag<"ConfigNotWritable">;
 } & {
@@ -53,6 +112,17 @@ declare const ConfigNotWritable_base: Schema.TaggedErrorClass<ConfigNotWritable,
 export declare class ConfigNotWritable extends ConfigNotWritable_base {
     get message(): string;
 }
+declare const ConfigCleanupError_base: Schema.TaggedErrorClass<ConfigCleanupError, "ConfigCleanupError", {
+    readonly _tag: Schema.tag<"ConfigCleanupError">;
+} & {
+    path: typeof Schema.String;
+    temporaryPath: typeof Schema.String;
+    error: typeof Schema.Defect;
+    operationError: typeof Schema.Defect;
+}>;
+export declare class ConfigCleanupError extends ConfigCleanupError_base {
+    get message(): string;
+}
 declare const ConfigParseError_base: Schema.TaggedErrorClass<ConfigParseError, "ConfigParseError", {
     readonly _tag: Schema.tag<"ConfigParseError">;
 } & {
@@ -62,6 +132,16 @@ declare const ConfigParseError_base: Schema.TaggedErrorClass<ConfigParseError, "
 export declare class ConfigParseError extends ConfigParseError_base {
     get message(): string;
 }
+declare const CredentialStoreInsecure_base: Schema.TaggedErrorClass<CredentialStoreInsecure, "CredentialStoreInsecure", {
+    readonly _tag: Schema.tag<"CredentialStoreInsecure">;
+} & {
+    path: typeof Schema.String;
+    reason: typeof Schema.String;
+    error: typeof Schema.Defect;
+}>;
+export declare class CredentialStoreInsecure extends CredentialStoreInsecure_base {
+    get message(): string;
+}
 declare const NotAuthenticated_base: Schema.TaggedErrorClass<NotAuthenticated, "NotAuthenticated", {
     readonly _tag: Schema.tag<"NotAuthenticated">;
 }>;
@@ -77,27 +157,38 @@ export declare class OAuthTokenExpired extends OAuthTokenExpired_base {
     get message(): string;
 }
 declare const ConfigManager_base: Effect.Service.Class<ConfigManager, "@expandai/cli/Config/ConfigManager", {
-    readonly dependencies: readonly [import("effect/Layer").Layer<FileSystem.FileSystem, never, never>, import("effect/Layer").Layer<Path.Path, never, never>];
+    readonly dependencies: readonly [import("effect/Layer").Layer<NodeContext.NodeContext, never, never>];
     readonly effect: Effect.Effect<{
         readonly configPath: string;
+        readonly inspectSecureStorage: () => Effect.Effect<void, CredentialStoreInsecure, never>;
+        readonly ensureSecureStorage: () => Effect.Effect<void, CredentialStoreInsecure, never>;
         readonly loadConfig: () => Effect.Effect<{
             apiUrl: URL;
             authMethod: NonNullable<{
-                readonly apiKey: import("effect/Redacted").Redacted<string & import("effect/Brand").Brand<"ApiKey">>;
                 readonly _tag: "ApiKey";
+                readonly apiKey: Redacted.Redacted<string & import("effect/Brand").Brand<"ApiKey">>;
             } | {
-                readonly accessToken: import("effect/Redacted").Redacted<string>;
-                readonly refreshToken?: import("effect/Redacted").Redacted<string> | undefined;
-                readonly expiresAt: DateTime.Utc;
                 readonly _tag: "OAuth";
+                readonly accessToken: Redacted.Redacted<string>;
+                readonly refreshToken?: Redacted.Redacted<string> | undefined;
+                readonly expiresAt: DateTime.Utc;
+                readonly clientId?: string | undefined;
             } | undefined>;
-        }, ConfigParseError | NotAuthenticated | import("effect/ConfigError").ConfigError | import("@effect/platform/Error").PlatformError, never>;
-        readonly saveConfig: (config: ExpandCliConfig) => Effect.Effect<void, ConfigNotWritable | import("effect/ParseResult").ParseError, never>;
-        readonly updateConfig: (patch: Partial<ExpandCliConfig>) => Effect.Effect<void, ConfigNotWritable | import("effect/ParseResult").ParseError, never>;
-        readonly clearConfig: () => Effect.Effect<void, ConfigNotWritable | import("effect/ParseResult").ParseError, never>;
-        readonly getApiUrl: () => Effect.Effect<URL, ConfigParseError | import("effect/ConfigError").ConfigError | import("@effect/platform/Error").PlatformError, never>;
+        }, ConfigParseError | CredentialStoreInsecure | NotAuthenticated | import("effect/ConfigError").ConfigError | PlatformError.PlatformError, never>;
+        readonly saveConfig: (config: ExpandCliConfig) => Effect.Effect<void, ConfigCleanupError | ConfigNotWritable | CredentialStoreInsecure | import("effect/ParseResult").ParseError, never>;
+        readonly updateConfig: (patch: Partial<ExpandCliConfig>) => Effect.Effect<void, ConfigCleanupError | ConfigNotWritable | ConfigParseError | CredentialStoreInsecure | import("effect/ParseResult").ParseError | PlatformError.PlatformError, never>;
+        readonly clearConfig: () => Effect.Effect<undefined, PlatformError.BadArgument | ConfigCleanupError | ConfigNotWritable | CredentialStoreInsecure | import("effect/ParseResult").ParseError | PlatformError.SystemError, never>;
+        readonly readConfigFile: () => Effect.Effect<{
+            config: ExpandCliConfig;
+            parseFailed: boolean;
+        } | {
+            config: ExpandCliConfig;
+            parseFailed: boolean;
+        }, never, never>;
+        readonly getApiUrl: () => Effect.Effect<URL, ConfigParseError | CredentialStoreInsecure | import("effect/ConfigError").ConfigError | PlatformError.PlatformError, never>;
+        readonly getAppUrl: () => Effect.Effect<string, import("effect/ConfigError").ConfigError, never>;
         readonly getPlaygroundHost: () => Effect.Effect<string, import("effect/ConfigError").ConfigError, never>;
-    }, import("effect/ConfigError").ConfigError, FileSystem.FileSystem | Path.Path>;
+    }, import("effect/ConfigError").ConfigError, CommandExecutor.CommandExecutor | FileSystem.FileSystem | Path.Path>;
 }>;
 export declare class ConfigManager extends ConfigManager_base {
 }

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

@@ -1 +1 @@
-{"version":3,"file":"Config.d.ts","sourceRoot":"","sources":["../../src/Config.ts"],"names":[],"mappings":"AAMA,OAAO,EAAE,UAAU,EAAE,IAAI,EAAE,MAAM,kBAAkB,CAAA;AAGnD,OAAO,EAAU,QAAQ,EAAE,MAAM,EAAU,MAAM,EAAE,MAAM,QAAQ,CAAA;AAEjE,mGAAmG;AACnG,eAAO,MAAM,eAAe,0BAA0B,CAAA;AAEtD,eAAO,MAAM,MAAM,8EAA6E,CAAA;AAEhG,eAAO,MAAM,YAAY;;EAAoD,CAAA;AAC7E,eAAO,MAAM,WAAW;;;;EAItB,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEF,qBAAa,eAAgB,SAAQ,oBAGnC;IACD,MAAM,CAAC,QAAQ,CAAC,IAAI,uFAAoC;CACxD;;;;;;AAED,qBAAa,iBAAkB,SAAQ,sBAErC;IACD,IAAI,OAAO,WAEV;CACD;;;;;;;AAED,qBAAa,gBAAiB,SAAQ,qBAGpC;IACD,IAAI,OAAO,WAEV;CACD;;;;AAED,qBAAa,gBAAiB,SAAQ,qBAA8D;IACnG,IAAI,OAAO,WAEV;CACD;;;;;;AAED,qBAAa,iBAAkB,SAAQ,sBAErC;IACD,IAAI,OAAO,WAEV;CACD;;;;;;;;;;;;;;;;;;;;;;;;AAYD,qBAAa,aAAc,SAAQ,kBA2HjC;CAAG"}
+{"version":3,"file":"Config.d.ts","sourceRoot":"","sources":["../../src/Config.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,OAAO,EAAW,eAAe,EAAE,UAAU,EAAE,IAAI,EAAE,KAAK,IAAI,aAAa,EAAE,MAAM,kBAAkB,CAAA;AACrG,OAAO,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAA;AAEnD,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAgB,MAAM,EAAU,QAAQ,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAA;AAIjG,mGAAmG;AACnG,eAAO,MAAM,eAAe,0BAA0B,CAAA;AAEtD,0EAA0E;AAC1E,eAAO,MAAM,eAAe,sBAAsB,CAAA;AAElD;;;;;;;GAOG;AACH,eAAO,MAAM,OAAO,SAAU,MAAM,2BASlC,CAAA;AAEF,eAAO,MAAM,UAAU,GAAI,CAAC,SAAS,MAAM,QAAQ,MAAM,UAAU,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC,oCACkB,CAAA;AAExG,eAAO,MAAM,MAAM,8EAA6E,CAAA;AAEhG,eAAO,MAAM,YAAY;;EAAoD,CAAA;AAC7E,eAAO,MAAM,WAAW;;;;;EAQtB,CAAA;AAEF,eAAO,MAAM,iBAAiB;;;;EAI5B,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEF,qBAAa,eAAgB,SAAQ,oBAInC;IACD,MAAM,CAAC,QAAQ,CAAC,IAAI,uFAAoC;CACxD;AAED,MAAM,MAAM,UAAU,GAAG,OAAO,YAAY,CAAC,IAAI,GAAG,OAAO,WAAW,CAAC,IAAI,CAAA;AAE3E;;;;;;;GAOG;AACH,MAAM,MAAM,eAAe,GAAG,SAAS,GAAG,kBAAkB,GAAG,UAAU,CAAA;AAEzE,wBAAgB,eAAe,CAAC,UAAU,EAAE,UAAU,EAAE,GAAG,EAAE,QAAQ,CAAC,GAAG,GAAG,eAAe,CAO1F;AAED,sFAAsF;AACtF,wBAAgB,yBAAyB,CAAC,UAAU,EAAE,UAAU,EAAE,GAAG,EAAE,QAAQ,CAAC,GAAG,GAAG,OAAO,CAE5F;;;;;;AA2DD,qBAAa,iBAAkB,SAAQ,sBAErC;IACD,IAAI,OAAO,WAEV;CACD;;;;;;;;;AAED,qBAAa,kBAAmB,SAAQ,uBAKtC;IACD,IAAI,OAAO,WAEV;CACD;;;;;;;AAED,qBAAa,gBAAiB,SAAQ,qBAGpC;IACD,IAAI,OAAO,WAEV;CACD;;;;;;;;AAED,qBAAa,uBAAwB,SAAQ,4BAI3C;IACD,IAAI,OAAO,WAEV;CACD;;;;AAED,qBAAa,gBAAiB,SAAQ,qBAA8D;IACnG,IAAI,OAAO,WAEV;CACD;;;;;;AAED,qBAAa,iBAAkB,SAAQ,sBAErC;IACD,IAAI,OAAO,WAEV;CACD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAYD,qBAAa,aAAc,SAAQ,kBAgnBjC;CAAG"}

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

@@ -1,8 +1,12 @@
 /**
- * Prepends a short note to fetched markdown carrying the snapshot handle and the public
- * playground link, and telling the agent how to search the already-captured page by handle
- * (rather than fetching the URL again) and cite specific passages back to the user. Both the
- * Claude Code and OpenCode hooks inject this so the surfaced guidance stays identical.
+ * Citation guidance for `expandai fetch` text output consumed by an agent. The plain
+ * command is a third fetch path alongside the hook and the MCP tools — an agent that
+ * shells out to it used to receive evidence ids with nothing telling it to cite them,
+ * and answered uncited. Humans at a TTY do not need this, so callers gate on that.
+ *
+ * Returns the markdown unchanged when no playground URL is present, rather than
+ * emitting an instruction the reader cannot follow.
  */
+export declare function withCitationFooter(markdown: string): string;
 export declare function withSnapshotNote(markdown: string, snapshotId: string, playgroundUrl: string): string;
 //# sourceMappingURL=SnapshotNote.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"SnapshotNote.d.ts","sourceRoot":"","sources":["../../../src/Hook/SnapshotNote.ts"],"names":[],"mappings":"AAEA;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAAC,QAAQ,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,aAAa,EAAE,MAAM,GAAG,MAAM,CASpG"}
+{"version":3,"file":"SnapshotNote.d.ts","sourceRoot":"","sources":["../../../src/Hook/SnapshotNote.ts"],"names":[],"mappings":"AAeA;;;;;;;;GAQG;AACH,wBAAgB,kBAAkB,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAiB3D;AAED,wBAAgB,gBAAgB,CAAC,QAAQ,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,aAAa,EAAE,MAAM,GAAG,MAAM,CAsBpG"}

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

@@ -0,0 +1,61 @@
+import { CommandExecutor } from '@effect/platform';
+import { Effect, Layer, Schema } from 'effect';
+import { ClaudeProfile } from './ClaudeProfile.js';
+import { HarnessConfigurationError, type HarnessInspection, HarnessInspectionError } from './HarnessAdapter.js';
+import { MutationTransaction } from './MutationTransaction.js';
+declare const IncompatibleClaudeProfileVersionError_base: Schema.TaggedErrorClass<IncompatibleClaudeProfileVersionError, "IncompatibleClaudeProfileVersionError", {
+    readonly _tag: Schema.tag<"IncompatibleClaudeProfileVersionError">;
+} & {
+    executingVersion: typeof Schema.String;
+    requiredVersion: typeof Schema.String;
+}>;
+export declare class IncompatibleClaudeProfileVersionError extends IncompatibleClaudeProfileVersionError_base {
+    get message(): string;
+}
+declare const ClaudeProfilePolicyBlockedError_base: Schema.TaggedErrorClass<ClaudeProfilePolicyBlockedError, "ClaudeProfilePolicyBlockedError", {
+    readonly _tag: Schema.tag<"ClaudeProfilePolicyBlockedError">;
+} & {
+    policyBlock: typeof Schema.String;
+}>;
+export declare class ClaudeProfilePolicyBlockedError extends ClaudeProfilePolicyBlockedError_base {
+    get message(): string;
+}
+declare const ClaudeAdapterOperationError_base: Schema.TaggedErrorClass<ClaudeAdapterOperationError, "ClaudeAdapterOperationError", {
+    readonly _tag: Schema.tag<"ClaudeAdapterOperationError">;
+} & {
+    code: Schema.Literal<["inspection_failed", "configuration_failed"]>;
+}>;
+export declare class ClaudeAdapterOperationError extends ClaudeAdapterOperationError_base {
+    get message(): "Claude Code profile configuration failed" | "Claude Code profile inspection failed";
+}
+declare const ClaudeRuntimeProbe_base: Effect.Service.Class<ClaudeRuntimeProbe, "@expandai/cli/Init/ClaudeRuntimeProbe", {
+    readonly dependencies: readonly [Layer.Layer<CommandExecutor.CommandExecutor, never, import("@effect/platform/FileSystem").FileSystem>];
+    readonly effect: Effect.Effect<{
+        executingVersion: string;
+        portableCommandAvailable: Effect.Effect<boolean, never, never>;
+    }, import("effect/ConfigError").ConfigError, CommandExecutor.CommandExecutor>;
+}>;
+/** Runtime facts kept separate from persisted harness commands. */
+export declare class ClaudeRuntimeProbe extends ClaudeRuntimeProbe_base {
+    /**
+     * Not `DefaultWithoutDependencies`: that layer always reports `CLI_VERSION` and
+     * always runs the real command probe. Tests need to pin an arbitrary executing
+     * version and a precomputed probe result, which only a fixture layer can supply.
+     */
+    static testLayer(options: {
+        readonly executingVersion: string;
+        readonly portableCommandAvailable: boolean;
+    }): Layer.Layer<ClaudeRuntimeProbe, never, never>;
+}
+declare const ClaudeAdapter_base: Effect.Service.Class<ClaudeAdapter, "@expandai/cli/Init/ClaudeAdapter", {
+    readonly dependencies: readonly [Layer.Layer<ClaudeProfile, import("@effect/platform/Error").BadArgument | import("effect/ConfigError").ConfigError, never>, Layer.Layer<MutationTransaction, never, never>, Layer.Layer<ClaudeRuntimeProbe, import("effect/ConfigError").ConfigError, import("@effect/platform/FileSystem").FileSystem>];
+    readonly effect: Effect.Effect<{
+        readonly harness: 'claude-code';
+        readonly inspect: (scope: "global" | "project") => Effect.Effect<HarnessInspection, HarnessInspectionError, never>;
+        readonly configure: (scope: "global" | "project") => Effect.Effect<HarnessInspection, HarnessConfigurationError, never>;
+    }, never, ClaudeProfile | ClaudeRuntimeProbe | MutationTransaction>;
+}>;
+export declare class ClaudeAdapter extends ClaudeAdapter_base {
+}
+export {};
+//# sourceMappingURL=ClaudeAdapter.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ClaudeAdapter.d.ts","sourceRoot":"","sources":["../../../src/Init/ClaudeAdapter.ts"],"names":[],"mappings":"AAAA,OAAO,EAAW,eAAe,EAAE,MAAM,kBAAkB,CAAA;AAE3D,OAAO,EAAU,MAAM,EAAE,KAAK,EAAE,MAAM,EAAU,MAAM,QAAQ,CAAA;AAE9D,OAAO,EAA0B,aAAa,EAAgC,MAAM,oBAAoB,CAAA;AAExG,OAAO,EAAE,yBAAyB,EAAE,KAAK,iBAAiB,EAAE,sBAAsB,EAAE,MAAM,qBAAqB,CAAA;AAC/G,OAAO,EAAE,mBAAmB,EAAE,MAAM,0BAA0B,CAAA;;;;;;;AAE9D,qBAAa,qCAAsC,SAAQ,0CAM1D;IACA,IAAI,OAAO,WAEV;CACD;;;;;;AAED,qBAAa,+BAAgC,SAAQ,oCAKpD;IACA,IAAI,OAAO,WAEV;CACD;;;;;;AAED,qBAAa,2BAA4B,SAAQ,gCAKhD;IACA,IAAI,OAAO,yFAIV;CACD;;;;;;;;AA0CD,mEAAmE;AACnE,qBAAa,kBAAmB,SAAQ,uBAGtC;IACD;;;;OAIG;IACH,MAAM,CAAC,SAAS,CAAC,OAAO,EAAE;QAAE,QAAQ,CAAC,gBAAgB,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,wBAAwB,EAAE,OAAO,CAAA;KAAE,iDAQ1G;CACD;;;;0BAgFkB,aAAa;;;;;AAGhC,qBAAa,aAAc,SAAQ,kBAGjC;CAAG"}

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

@@ -0,0 +1,77 @@
+import { FileSystem, Path } from '@effect/platform';
+import { Effect, Layer } from 'effect';
+import { CliInvocation } from '../Install/Domain.js';
+import type { InitComponent, InitScope } from './Domain.js';
+import type { MutationOperation } from './MutationTransaction.js';
+export declare const CLAUDE_PROFILE_VERSION = "0.0.4";
+export declare const CLAUDE_POLICY_MANAGED_MCP = "managed_mcp_only";
+export declare const CLAUDE_POLICY_MCP_DENIED = "managed_mcp_denied";
+export declare const CLAUDE_POLICY_MCP_NOT_ALLOWED = "managed_mcp_not_allowed";
+export declare const CLAUDE_POLICY_READ_ONLY = "target_read_only";
+interface ClaudeTargetLocations {
+    readonly settingsFile: string;
+    readonly skillDirectory: string;
+    readonly skillFile: string;
+    readonly mcpFile: string;
+    readonly managedSettingsFiles: string[];
+    readonly managedSettingsDirectories: string[];
+}
+export interface ClaudeManagedSettingsLocationSet {
+    readonly files: string[];
+    readonly directories: string[];
+}
+interface ClaudeRegistrationInspection {
+    readonly current: boolean;
+    readonly installed: boolean;
+    readonly legacyVariants: string[];
+    readonly version?: string;
+}
+export interface ClaudeProfileInspection {
+    readonly scope: InitScope;
+    readonly targets: ClaudeTargetLocations;
+    readonly hook: ClaudeRegistrationInspection;
+    readonly skill: ClaudeRegistrationInspection;
+    readonly mcp: ClaudeRegistrationInspection;
+    readonly components: InitComponent[];
+    readonly configured: boolean;
+    readonly profileVersion: string;
+    readonly componentVersions: {
+        readonly hook?: string;
+        readonly skill?: string;
+        readonly mcp?: string;
+    };
+    readonly policyBlocks: string[];
+    readonly remotePolicyMayApply: true;
+    readonly reloadMayBeRequired: boolean;
+    readonly consentMayBeRequired: boolean;
+}
+export interface ClaudeProfileMutationPlan {
+    readonly changed: boolean;
+    readonly inspection: ClaudeProfileInspection;
+    readonly resultInspection: ClaudeProfileInspection;
+    readonly operations: MutationOperation[];
+}
+declare function defaultManagedSettingsLocations(): ClaudeManagedSettingsLocationSet;
+declare const ClaudeManagedSettingsLocations_base: Effect.Service.Class<ClaudeManagedSettingsLocations, "@expandai/cli/Init/ClaudeManagedSettingsLocations", {
+    readonly sync: typeof defaultManagedSettingsLocations;
+}>;
+/** Discoverable file-based Claude managed-policy locations for the current platform. */
+export declare class ClaudeManagedSettingsLocations extends ClaudeManagedSettingsLocations_base {
+    static testLayer(locations: ClaudeManagedSettingsLocationSet): Layer.Layer<ClaudeManagedSettingsLocations, never, never>;
+}
+declare const ClaudeProfile_base: Effect.Service.Class<ClaudeProfile, "@expandai/cli/Init/ClaudeProfile", {
+    readonly dependencies: readonly [Layer.Layer<FileSystem.FileSystem, never, never>, Layer.Layer<Path.Path, never, never>, Layer.Layer<ClaudeManagedSettingsLocations, never, never>, Layer.Layer<CliInvocation, import("effect/ConfigError").ConfigError, never>];
+    readonly effect: Effect.Effect<{
+        readonly inspect: (scope: "global" | "project") => Effect.Effect<ClaudeProfileInspection, import("effect/ParseResult").ParseError | import("@effect/platform/Error").PlatformError, never>;
+        readonly plan: (scope: "global" | "project") => Effect.Effect<{
+            changed: boolean;
+            inspection: ClaudeProfileInspection;
+            resultInspection: ClaudeProfileInspection;
+            operations: MutationOperation[];
+        }, import("effect/ParseResult").ParseError | import("@effect/platform/Error").PlatformError, never>;
+    }, import("@effect/platform/Error").BadArgument | import("effect/ConfigError").ConfigError, ClaudeManagedSettingsLocations | CliInvocation | FileSystem.FileSystem | Path.Path>;
+}>;
+export declare class ClaudeProfile extends ClaudeProfile_base {
+}
+export {};
+//# sourceMappingURL=ClaudeProfile.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ClaudeProfile.d.ts","sourceRoot":"","sources":["../../../src/Init/ClaudeProfile.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,UAAU,EAAE,IAAI,EAAE,MAAM,kBAAkB,CAAA;AAEnD,OAAO,EAAiB,MAAM,EAAU,KAAK,EAAkB,MAAM,QAAQ,CAAA;AAI7E,OAAO,EAAmB,aAAa,EAAsC,MAAM,sBAAsB,CAAA;AAEzG,OAAO,KAAK,EAAE,aAAa,EAAE,SAAS,EAAE,MAAM,aAAa,CAAA;AAC3D,OAAO,KAAK,EAAyB,iBAAiB,EAAE,MAAM,0BAA0B,CAAA;AAExF,eAAO,MAAM,sBAAsB,UAAc,CAAA;AAEjD,eAAO,MAAM,yBAAyB,qBAAqB,CAAA;AAC3D,eAAO,MAAM,wBAAwB,uBAAuB,CAAA;AAC5D,eAAO,MAAM,6BAA6B,4BAA4B,CAAA;AACtE,eAAO,MAAM,uBAAuB,qBAAqB,CAAA;AAEzD,UAAU,qBAAqB;IAC9B,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAA;IAC7B,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAA;IAC/B,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAA;IAC1B,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;IACxB,QAAQ,CAAC,oBAAoB,EAAE,MAAM,EAAE,CAAA;IACvC,QAAQ,CAAC,0BAA0B,EAAE,MAAM,EAAE,CAAA;CAC7C;AAED,MAAM,WAAW,gCAAgC;IAChD,QAAQ,CAAC,KAAK,EAAE,MAAM,EAAE,CAAA;IACxB,QAAQ,CAAC,WAAW,EAAE,MAAM,EAAE,CAAA;CAC9B;AAED,UAAU,4BAA4B;IACrC,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAA;IACzB,QAAQ,CAAC,SAAS,EAAE,OAAO,CAAA;IAC3B,QAAQ,CAAC,cAAc,EAAE,MAAM,EAAE,CAAA;IACjC,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAA;CACzB;AAED,MAAM,WAAW,uBAAuB;IACvC,QAAQ,CAAC,KAAK,EAAE,SAAS,CAAA;IACzB,QAAQ,CAAC,OAAO,EAAE,qBAAqB,CAAA;IACvC,QAAQ,CAAC,IAAI,EAAE,4BAA4B,CAAA;IAC3C,QAAQ,CAAC,KAAK,EAAE,4BAA4B,CAAA;IAC5C,QAAQ,CAAC,GAAG,EAAE,4BAA4B,CAAA;IAC1C,QAAQ,CAAC,UAAU,EAAE,aAAa,EAAE,CAAA;IACpC,QAAQ,CAAC,UAAU,EAAE,OAAO,CAAA;IAC5B,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAA;IAC/B,QAAQ,CAAC,iBAAiB,EAAE;QAC3B,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAA;QACtB,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAA;QACvB,QAAQ,CAAC,GAAG,CAAC,EAAE,MAAM,CAAA;KACrB,CAAA;IACD,QAAQ,CAAC,YAAY,EAAE,MAAM,EAAE,CAAA;IAC/B,QAAQ,CAAC,oBAAoB,EAAE,IAAI,CAAA;IACnC,QAAQ,CAAC,mBAAmB,EAAE,OAAO,CAAA;IACrC,QAAQ,CAAC,oBAAoB,EAAE,OAAO,CAAA;CACtC;AAED,MAAM,WAAW,yBAAyB;IACzC,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAA;IACzB,QAAQ,CAAC,UAAU,EAAE,uBAAuB,CAAA;IAC5C,QAAQ,CAAC,gBAAgB,EAAE,uBAAuB,CAAA;IAClD,QAAQ,CAAC,UAAU,EAAE,iBAAiB,EAAE,CAAA;CACxC;AA2BD,iBAAS,+BAA+B,IAAI,gCAAgC,CAmB3E;;;;AAED,wFAAwF;AACxF,qBAAa,8BAA+B,SAAQ,mCAKnD;IACA,MAAM,CAAC,SAAS,CAAC,SAAS,EAAE,gCAAgC,6DAE3D;CACD;;;;;;;;;;;;;AAsUD,qBAAa,aAAc,SAAQ,kBAGjC;CAAG"}

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

@@ -0,0 +1,139 @@
+import { Schema } from 'effect';
+export declare const AUTHORIZATION_REQUIRED_MESSAGE = "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 \u2014 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.";
+export declare const AUTHORIZATION_CONSUMED_MESSAGE = "Authorization complete. That setup code has been consumed and cannot be reused.";
+export declare const ALREADY_AUTHENTICATED_MESSAGE = "Expand is already authorized. Agent setup is complete.";
+/**
+ * Some harnesses were configured and some were not. This has to be its own
+ * message: the agent relays `userMessage` verbatim, so reporting a partial run
+ * with "Agent setup is complete" tells the user something untrue about a
+ * machine they are about to rely on.
+ */
+export declare const PARTIAL_CONFIGURATION_MESSAGE = "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.";
+export declare const HARNESS_SELECTION_MESSAGE = "Show these harnesses to the user and ask which to configure. Pass the chosen ones to `expandai init --harnesses`. Harnesses that are not chosen are left untouched.";
+/** There is nothing to choose from, so the agent must not present an empty list. */
+export declare const NO_HARNESS_DETECTED_MESSAGE = "No supported agent harness was found on this machine. Do not ask the user to choose from an empty list. Tell them Expand supports claude-code, cursor, opencode, and codex, and that setup cannot continue until one of them is installed.";
+export declare const InitHarness: Schema.Literal<["claude-code", "cursor", "opencode", "codex"]>;
+export type InitHarness = typeof InitHarness.Type;
+declare const InitDetectionResult_base: Schema.Class<InitDetectionResult, {
+    schemaVersion: Schema.Literal<[1]>;
+    status: Schema.Literal<["detected"]>;
+    harnesses: Schema.Array$<Schema.Literal<["claude-code", "cursor", "opencode", "codex"]>>;
+    current: Schema.optional<Schema.Literal<["claude-code", "cursor", "opencode", "codex"]>>;
+    userMessage: Schema.Literal<["Show these harnesses to the user and ask which to configure. Pass the chosen ones to `expandai init --harnesses`. Harnesses that are not chosen are left untouched.", "No supported agent harness was found on this machine. Do not ask the user to choose from an empty list. Tell them Expand supports claude-code, cursor, opencode, and codex, and that setup cannot continue until one of them is installed."]>;
+}, Schema.Struct.Encoded<{
+    schemaVersion: Schema.Literal<[1]>;
+    status: Schema.Literal<["detected"]>;
+    harnesses: Schema.Array$<Schema.Literal<["claude-code", "cursor", "opencode", "codex"]>>;
+    current: Schema.optional<Schema.Literal<["claude-code", "cursor", "opencode", "codex"]>>;
+    userMessage: Schema.Literal<["Show these harnesses to the user and ask which to configure. Pass the chosen ones to `expandai init --harnesses`. Harnesses that are not chosen are left untouched.", "No supported agent harness was found on this machine. Do not ask the user to choose from an empty list. Tell them Expand supports claude-code, cursor, opencode, and codex, and that setup cannot continue until one of them is installed."]>;
+}>, never, {
+    readonly current?: "claude-code" | "codex" | "cursor" | "opencode" | undefined;
+} & {
+    readonly harnesses: readonly ("claude-code" | "codex" | "cursor" | "opencode")[];
+} & {
+    readonly schemaVersion: 1;
+} & {
+    readonly status: "detected";
+} & {
+    readonly userMessage: "No supported agent harness was found on this machine. Do not ask the user to choose from an empty list. Tell them Expand supports claude-code, cursor, opencode, and codex, and that setup cannot continue until one of them is installed." | "Show these harnesses to the user and ask which to configure. Pass the chosen ones to `expandai init --harnesses`. Harnesses that are not chosen are left untouched.";
+}, {}, {}>;
+/**
+ * Answer to `init --detect`: what setup *would* touch, before it touches
+ * anything. Separate from `InitResult` because detection never authorizes,
+ * never writes, and can legitimately find nothing.
+ */
+export declare class InitDetectionResult extends InitDetectionResult_base {
+}
+export declare const InitHarnesses: Schema.NonEmptyArray<Schema.Literal<["claude-code", "cursor", "opencode", "codex"]>>;
+export type InitHarnesses = typeof InitHarnesses.Type;
+export declare const InitScope: Schema.Literal<["project", "global"]>;
+export type InitScope = typeof InitScope.Type;
+export declare const InitComponent: Schema.Literal<["webfetch-hook", "runtime-skill", "mcp"]>;
+export type InitComponent = typeof InitComponent.Type;
+export declare const InitRuntimeState: Schema.Literal<["unverified", "observed", "reload_required", "blocked"]>;
+export type InitRuntimeState = typeof InitRuntimeState.Type;
+export declare const InitStatus: Schema.Literal<["authorization_required", "completed"]>;
+export type InitStatus = typeof InitStatus.Type;
+declare const InitRequest_base: Schema.Class<InitRequest, {
+    harnesses: Schema.NonEmptyArray<Schema.Literal<["claude-code", "cursor", "opencode", "codex"]>>;
+    scope: Schema.Literal<["project", "global"]>;
+    setupToken: Schema.optional<Schema.transform<Schema.filter<Schema.filter<typeof Schema.String>>, Schema.Redacted<typeof Schema.String>>>;
+}, Schema.Struct.Encoded<{
+    harnesses: Schema.NonEmptyArray<Schema.Literal<["claude-code", "cursor", "opencode", "codex"]>>;
+    scope: Schema.Literal<["project", "global"]>;
+    setupToken: Schema.optional<Schema.transform<Schema.filter<Schema.filter<typeof Schema.String>>, Schema.Redacted<typeof Schema.String>>>;
+}>, never, {
+    readonly setupToken?: import("effect/Redacted").Redacted<string> | undefined;
+} & {
+    readonly harnesses: readonly ["claude-code" | "codex" | "cursor" | "opencode", ...("claude-code" | "codex" | "cursor" | "opencode")[]];
+} & {
+    readonly scope: "global" | "project";
+}, {}, {}>;
+export declare class InitRequest extends InitRequest_base {
+}
+export declare const InitResult: Schema.Union<[Schema.Struct<{
+    schemaVersion: Schema.Literal<[1]>;
+    status: Schema.Literal<["authorization_required"]>;
+    harnesses: Schema.NonEmptyArray<Schema.Literal<["claude-code", "cursor", "opencode", "codex"]>>;
+    scope: Schema.Literal<["project", "global"]>;
+    userMessage: Schema.Literal<["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."]>;
+    authorization: Schema.Struct<{
+        url: typeof Schema.URL;
+        userCode: typeof Schema.String;
+        approvalExpiresAt: typeof Schema.DateTimeUtc;
+    }>;
+}>, Schema.Struct<{
+    schemaVersion: Schema.Literal<[1]>;
+    status: Schema.Literal<["completed"]>;
+    harnesses: Schema.NonEmptyArray<Schema.Literal<["claude-code", "cursor", "opencode", "codex"]>>;
+    scope: Schema.Literal<["project", "global"]>;
+    userMessage: Schema.Literal<["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."]>;
+    auth: Schema.Struct<{
+        healthy: typeof Schema.Boolean;
+    }>;
+    projectPath: Schema.optional<typeof Schema.String>;
+    installations: Schema.NonEmptyArray<Schema.Struct<{
+        harness: Schema.Literal<["claude-code", "cursor", "opencode", "codex"]>;
+        configured: typeof Schema.Boolean;
+        changed: typeof Schema.Boolean;
+        components: Schema.Array$<Schema.Literal<["webfetch-hook", "runtime-skill", "mcp"]>>;
+        version: typeof Schema.String;
+        verification: Schema.Struct<{
+            runtimeState: Schema.Literal<["unverified", "observed", "reload_required", "blocked"]>;
+            nextAction: typeof Schema.String;
+        }>;
+    }>>;
+    failures: Schema.optional<Schema.Array$<Schema.Struct<{
+        harness: Schema.Literal<["claude-code", "cursor", "opencode", "codex"]>;
+        code: typeof Schema.String;
+        recoverable: typeof Schema.Boolean;
+    }>>>;
+}>]>;
+export type InitResult = typeof InitResult.Type;
+declare const InitErrorEnvelope_base: Schema.Class<InitErrorEnvelope, {
+    schemaVersion: Schema.Literal<[1]>;
+    status: Schema.Literal<["error"]>;
+    code: typeof Schema.String;
+    message: typeof Schema.String;
+    recoverable: typeof Schema.Boolean;
+}, Schema.Struct.Encoded<{
+    schemaVersion: Schema.Literal<[1]>;
+    status: Schema.Literal<["error"]>;
+    code: typeof Schema.String;
+    message: typeof Schema.String;
+    recoverable: typeof Schema.Boolean;
+}>, never, {
+    readonly code: string;
+} & {
+    readonly message: string;
+} & {
+    readonly recoverable: boolean;
+} & {
+    readonly schemaVersion: 1;
+} & {
+    readonly status: "error";
+}, {}, {}>;
+export declare class InitErrorEnvelope extends InitErrorEnvelope_base {
+}
+export {};
+//# sourceMappingURL=Domain.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Domain.d.ts","sourceRoot":"","sources":["../../../src/Init/Domain.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAA;AAI/B,eAAO,MAAM,8BAA8B,0UACwR,CAAA;AAEnU,eAAO,MAAM,8BAA8B,oFACuC,CAAA;AAElF,eAAO,MAAM,6BAA6B,2DAA2D,CAAA;AAErG;;;;;GAKG;AACH,eAAO,MAAM,6BAA6B,6KACiI,CAAA;AAE3K,eAAO,MAAM,yBAAyB,wKACgI,CAAA;AAEtK,oFAAoF;AACpF,eAAO,MAAM,2BAA2B,+OACqM,CAAA;AAE7O,eAAO,MAAM,WAAW,gEAA+D,CAAA;AACvF,MAAM,MAAM,WAAW,GAAG,OAAO,WAAW,CAAC,IAAI,CAAA;;;;;;;;;;;;;;;;;;;;;;;;AAEjD;;;;GAIG;AACH,qBAAa,mBAAoB,SAAQ,wBAMvC;CAAG;AAEL,eAAO,MAAM,aAAa,sFAAoC,CAAA;AAC9D,MAAM,MAAM,aAAa,GAAG,OAAO,aAAa,CAAC,IAAI,CAAA;AAErD,eAAO,MAAM,SAAS,uCAAsC,CAAA;AAC5D,MAAM,MAAM,SAAS,GAAG,OAAO,SAAS,CAAC,IAAI,CAAA;AAE7C,eAAO,MAAM,aAAa,2DAA0D,CAAA;AACpF,MAAM,MAAM,aAAa,GAAG,OAAO,aAAa,CAAC,IAAI,CAAA;AAErD,eAAO,MAAM,gBAAgB,0EAAyE,CAAA;AACtG,MAAM,MAAM,gBAAgB,GAAG,OAAO,gBAAgB,CAAC,IAAI,CAAA;AAE3D,eAAO,MAAM,UAAU,yDAAwD,CAAA;AAC/E,MAAM,MAAM,UAAU,GAAG,OAAO,UAAU,CAAC,IAAI,CAAA;;;;;;;;;;;;;;;;AAa/C,qBAAa,WAAY,SAAQ,gBAI/B;CAAG;AAqEL,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAAqE,CAAA;AAC5F,MAAM,MAAM,UAAU,GAAG,OAAO,UAAU,CAAC,IAAI,CAAA;;;;;;;;;;;;;;;;;;;;;;;;AAE/C,qBAAa,iBAAkB,SAAQ,sBAMrC;CAAG"}

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

@@ -0,0 +1,33 @@
+import { Schema } from 'effect';
+import { type InitComponent, type InitRuntimeState } from './Domain.js';
+export interface HarnessInspection {
+    readonly configured: boolean;
+    readonly changed?: boolean;
+    readonly components: InitComponent[];
+    readonly integrationVersion?: string;
+    readonly policyBlock?: string;
+    readonly nextAction: string;
+    readonly runtimeState?: InitRuntimeState;
+}
+declare const HarnessInspectionError_base: Schema.TaggedErrorClass<HarnessInspectionError, "HarnessInspectionError", {
+    readonly _tag: Schema.tag<"HarnessInspectionError">;
+} & {
+    harness: Schema.Literal<["claude-code", "cursor", "opencode", "codex"]>;
+    scope: Schema.Literal<["project", "global"]>;
+    error: typeof Schema.Defect;
+}>;
+export declare class HarnessInspectionError extends HarnessInspectionError_base {
+    get message(): string;
+}
+declare const HarnessConfigurationError_base: Schema.TaggedErrorClass<HarnessConfigurationError, "HarnessConfigurationError", {
+    readonly _tag: Schema.tag<"HarnessConfigurationError">;
+} & {
+    harness: Schema.Literal<["claude-code", "cursor", "opencode", "codex"]>;
+    scope: Schema.Literal<["project", "global"]>;
+    error: typeof Schema.Defect;
+}>;
+export declare class HarnessConfigurationError extends HarnessConfigurationError_base {
+    get message(): string;
+}
+export {};
+//# sourceMappingURL=HarnessAdapter.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"HarnessAdapter.d.ts","sourceRoot":"","sources":["../../../src/Init/HarnessAdapter.ts"],"names":[],"mappings":"AAAA,OAAO,EAAe,MAAM,EAAE,MAAM,QAAQ,CAAA;AAC5C,OAAO,EAAE,KAAK,aAAa,EAAe,KAAK,gBAAgB,EAAa,MAAM,aAAa,CAAA;AAE/F,MAAM,WAAW,iBAAiB;IACjC,QAAQ,CAAC,UAAU,EAAE,OAAO,CAAA;IAC5B,QAAQ,CAAC,OAAO,CAAC,EAAE,OAAO,CAAA;IAC1B,QAAQ,CAAC,UAAU,EAAE,aAAa,EAAE,CAAA;IACpC,QAAQ,CAAC,kBAAkB,CAAC,EAAE,MAAM,CAAA;IACpC,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAA;IAC7B,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAA;IAC3B,QAAQ,CAAC,YAAY,CAAC,EAAE,gBAAgB,CAAA;CACxC;;;;;;;;AAED,qBAAa,sBAAuB,SAAQ,2BAI1C;IACD,IAAI,OAAO,WAEV;CACD;;;;;;;;AAED,qBAAa,yBAA0B,SAAQ,8BAO9C;IACA,IAAI,OAAO,WAEV;CACD"}

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

@@ -0,0 +1,19 @@
+import { FileSystem, Path } from '@effect/platform';
+import { Effect, Option } from 'effect';
+import { InitHarness } from './Domain.js';
+interface HarnessDetectionInput {
+    readonly cwd?: string;
+    readonly environment?: Readonly<Record<string, string | undefined>>;
+    readonly hint?: typeof InitHarness.Type;
+}
+declare const HarnessDetector_base: Effect.Service.Class<HarnessDetector, "@expandai/cli/Init/HarnessDetector", {
+    readonly dependencies: readonly [import("effect/Layer").Layer<FileSystem.FileSystem, never, never>, import("effect/Layer").Layer<Path.Path, never, never>];
+    readonly effect: Effect.Effect<{
+        readonly detect: (input?: HarnessDetectionInput | undefined) => Effect.Effect<("claude-code" | "codex" | "cursor" | "opencode")[], never, never>;
+        readonly detectCurrent: (input?: Pick<HarnessDetectionInput, "environment"> | undefined) => Effect.Effect<Option.Option<"claude-code" | "codex" | "cursor" | "opencode">, never, never>;
+    }, never, FileSystem.FileSystem | Path.Path>;
+}>;
+export declare class HarnessDetector extends HarnessDetector_base {
+}
+export {};
+//# sourceMappingURL=HarnessDetector.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"HarnessDetector.d.ts","sourceRoot":"","sources":["../../../src/Init/HarnessDetector.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,UAAU,EAAE,IAAI,EAAE,MAAM,kBAAkB,CAAA;AAEnD,OAAO,EAAE,MAAM,EAAE,MAAM,EAAU,MAAM,QAAQ,CAAA;AAC/C,OAAO,EAAE,WAAW,EAAsB,MAAM,aAAa,CAAA;AAE7D,UAAU,qBAAqB;IAC9B,QAAQ,CAAC,GAAG,CAAC,EAAE,MAAM,CAAA;IACrB,QAAQ,CAAC,WAAW,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC,CAAC,CAAA;IACnE,QAAQ,CAAC,IAAI,CAAC,EAAE,OAAO,WAAW,CAAC,IAAI,CAAA;CACvC;;;;;;;;AAmBD,qBAAa,eAAgB,SAAQ,oBA+CnC;CAAG"}