expandai 0.0.4 → 0.0.6

package/src/Init/Status.ts

@@ -1,253 +0,0 @@
-import { DateTime, Effect, Option, Schema } from 'effect'
-import {
-	CLI_AUTHORIZATION_CLIENT_ID,
-	PendingInitCorrupt,
-	type PendingInitKey,
-	PendingInitRecord,
-} from '../Auth/Domain.js'
-import { PendingInitStore } from '../Auth/PendingInit.js'
-import { authMethodState } from '../Authentication.js'
-import { ConfigManager, ConfigParseError, CredentialStoreInsecure, NotAuthenticated } from '../Config.js'
-import { CLI_VERSION } from '../Version.js'
-import { CLAUDE_POLICY_READ_ONLY } from './ClaudeProfile.js'
-import { InitHarness, InitScope } from './Domain.js'
-import type { HarnessInspection } from './HarnessAdapter.js'
-import { HarnessRegistry } from './HarnessRegistry.js'
-
-const VERSION_PATTERN = /^[0-9]+\.[0-9]+\.[0-9]+(?:-[0-9A-Za-z.-]+)?(?:\+[0-9A-Za-z.-]+)?$/u
-const BoundedVersion = Schema.String.pipe(Schema.minLength(1), Schema.maxLength(64), Schema.pattern(VERSION_PATTERN))
-
-export class StatusRequest extends Schema.Class<StatusRequest>('StatusRequest')({
-	harness: InitHarness,
-	scope: InitScope,
-}) {}
-
-const StatusAuth = Schema.Struct({
-	// `healthy` means a call would authenticate right now. An expired access
-	// token with a refresh token on disk reports `refresh_required`, because the
-	// renewal has not happened and can fail.
-	state: Schema.Literal('absent', 'unusable', 'refresh_required', 'healthy'),
-	healthy: Schema.Boolean,
-})
-
-const 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: Schema.DateTimeUtc,
-	}),
-)
-
-const StatusInstallation = Schema.Struct({
-	configured: Schema.Boolean,
-	integrationVersion: Schema.optional(BoundedVersion),
-	components: Schema.Struct({
-		webfetchHook: Schema.Boolean,
-		runtimeSkill: Schema.Boolean,
-		mcp: 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.Array(Schema.Literal('managed_policy_blocked', 'target_read_only')).pipe(Schema.maxItems(1)),
-})
-
-export class StatusResult extends Schema.Class<StatusResult>('StatusResult')({
-	schemaVersion: Schema.Literal(1),
-	status: Schema.Literal('ok'),
-	harness: InitHarness,
-	scope: InitScope,
-	cli: Schema.Struct({ version: BoundedVersion }),
-	auth: StatusAuth,
-	pendingAuthorization: PendingAuthorization,
-	installation: StatusInstallation,
-}) {}
-
-export 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',
-)
-
-export class StatusServiceError extends Schema.TaggedError<StatusServiceError>()('StatusServiceError', {
-	code: StatusServiceErrorCode,
-	recoverable: Schema.Boolean,
-}) {
-	get message() {
-		switch (this.code) {
-			case 'credential_config_malformed':
-				return 'Stored credential configuration is malformed.'
-			case 'credential_storage_insecure':
-				return 'Credential storage is not secure enough to inspect.'
-			case 'credential_health_failed':
-				return 'Stored credentials could not be inspected safely.'
-			case 'pending_state_malformed':
-				return 'Pending authorization state is malformed.'
-			case 'pending_state_unavailable':
-				return 'Pending authorization state could not be inspected safely.'
-			case 'harness_inspection_failed':
-				return 'The harness configuration could not be inspected safely.'
-			case 'invalid_status_result':
-				return 'Local diagnostics returned an invalid result.'
-		}
-	}
-}
-
-function statusError(code: typeof StatusServiceErrorCode.Type, recoverable: boolean): StatusServiceError {
-	return new StatusServiceError({ code, recoverable })
-}
-
-function mapCredentialError(error: unknown): StatusServiceError {
-	if (error instanceof ConfigParseError) return statusError('credential_config_malformed', false)
-	if (error instanceof CredentialStoreInsecure) return statusError('credential_storage_insecure', false)
-	return statusError('credential_health_failed', false)
-}
-
-function mapPendingError(error: unknown): StatusServiceError {
-	if (error instanceof CredentialStoreInsecure) return statusError('credential_storage_insecure', false)
-	return error instanceof PendingInitCorrupt
-		? statusError('pending_state_malformed', true)
-		: statusError('pending_state_unavailable', true)
-}
-
-function authStatus(configManager: ConfigManager) {
-	return Effect.gen(function* () {
-		const loaded = yield* Effect.either(configManager.loadConfig())
-		if (loaded._tag === 'Left') {
-			if (loaded.left instanceof NotAuthenticated) return { state: 'absent' as const, healthy: false }
-			return yield* mapCredentialError(loaded.left)
-		}
-		const now = yield* DateTime.now
-		const state = authMethodState(loaded.right.authMethod, now)
-		return { state, healthy: state === 'healthy' }
-	})
-}
-
-function pendingStatus(record: Option.Option<PendingInitRecord>) {
-	return Effect.gen(function* () {
-		if (Option.isNone(record)) return { state: 'none' as const, count: 0 as const }
-		const now = DateTime.toEpochMillis(yield* DateTime.now)
-		if (DateTime.toEpochMillis(record.value.approvalExpiresAt) <= now) {
-			return { state: 'none' as const, count: 0 as const }
-		}
-		return {
-			state: 'approval_pending' as const,
-			count: 1 as const,
-			approvalExpiresAt: DateTime.formatIso(record.value.approvalExpiresAt),
-		}
-	})
-}
-
-function validateInspection(
-	harness: typeof InitHarness.Type,
-	inspection: HarnessInspection,
-): Effect.Effect<HarnessInspection, StatusServiceError> {
-	const componentSet = new Set(inspection.components)
-	// Only the harnesses with a web-fetch hook install three components; cursor
-	// and codex are complete with two. Demanding three of them reported a
-	// correctly configured machine as an invalid result.
-	const expectsHook = harness === 'opencode'
-	const allComponents =
-		componentSet.has('runtime-skill') &&
-		componentSet.has('mcp') &&
-		(expectsHook ? componentSet.has('webfetch-hook') && componentSet.size === 3 : componentSet.size === 2)
-	const versionValid =
-		inspection.integrationVersion === undefined ||
-		(inspection.integrationVersion.length <= 64 && VERSION_PATTERN.test(inspection.integrationVersion))
-	const configuredValid = inspection.configured === allComponents
-	const runtimeValid = inspection.runtimeState !== 'observed'
-	return componentSet.size === inspection.components.length && versionValid && configuredValid && runtimeValid
-		? Effect.succeed(inspection)
-		: statusError('invalid_status_result', false)
-}
-
-function installationStatus(inspection: HarnessInspection, scope: typeof InitScope.Type) {
-	const components = new Set(inspection.components)
-	const policyBlocked = inspection.policyBlock !== undefined || inspection.runtimeState === 'blocked'
-	const policyCodes =
-		inspection.policyBlock === CLAUDE_POLICY_READ_ONLY
-			? (['target_read_only'] as const)
-			: policyBlocked
-				? (['managed_policy_blocked'] as const)
-				: []
-	const reloadRequired = !policyBlocked && inspection.runtimeState === 'reload_required'
-	return {
-		configured: inspection.configured,
-		...(inspection.integrationVersion === undefined ? {} : { integrationVersion: inspection.integrationVersion }),
-		components: {
-			webfetchHook: components.has('webfetch-hook'),
-			runtimeSkill: components.has('runtime-skill'),
-			mcp: components.has('mcp'),
-		},
-		runtimeState: policyBlocked
-			? ('blocked' as const)
-			: reloadRequired
-				? ('reload_required' as const)
-				: ('unverified' as const),
-		reloadState: reloadRequired ? ('required' as const) : ('not_required' as const),
-		consentState: scope === 'project' ? ('may_be_required' as const) : ('not_required' as const),
-		policyState: policyBlocked ? ('blocked' as const) : ('unverified' as const),
-		policyCodes,
-	}
-}
-
-export class StatusService extends Effect.Service<StatusService>()('@expandai/cli/Init/StatusService', {
-	dependencies: [ConfigManager.Default, PendingInitStore.Default, HarnessRegistry.Default],
-	effect: Effect.gen(function* () {
-		const configManager = yield* ConfigManager
-		const pendingStore = yield* PendingInitStore
-		const registry = yield* HarnessRegistry
-
-		const run = Effect.fn('StatusService.run')(function* (request: StatusRequest) {
-			yield* Effect.annotateCurrentSpan({ harness: request.harness, scope: request.scope })
-			return yield* Effect.gen(function* () {
-				yield* configManager
-					.inspectSecureStorage()
-					.pipe(Effect.withTracerEnabled(false), Effect.mapError(mapCredentialError))
-				const auth = yield* authStatus(configManager).pipe(Effect.withTracerEnabled(false))
-				const apiUrl = yield* configManager
-					.getApiUrl()
-					.pipe(Effect.withTracerEnabled(false), Effect.mapError(mapCredentialError))
-				const canonicalScopeRoot = yield* pendingStore
-					.canonicalScopeRoot(request.scope)
-					.pipe(Effect.withTracerEnabled(false), Effect.mapError(mapPendingError))
-				const key: PendingInitKey = {
-					apiOrigin: apiUrl.origin,
-					clientId: CLI_AUTHORIZATION_CLIENT_ID,
-					harness: 'agent-harnesses',
-					scope: request.scope,
-					canonicalScopeRoot,
-				}
-				const pending = yield* pendingStore
-					.peek(key)
-					.pipe(Effect.withTracerEnabled(false), Effect.mapError(mapPendingError))
-				const inspection = yield* registry.inspect(request.harness, request.scope).pipe(
-					Effect.withTracerEnabled(false),
-					Effect.mapError(() => statusError('harness_inspection_failed', true)),
-					Effect.flatMap((inspection) => validateInspection(request.harness, inspection)),
-				)
-				const candidate = {
-					schemaVersion: 1 as const,
-					status: 'ok' as const,
-					harness: request.harness,
-					scope: request.scope,
-					cli: { version: CLI_VERSION },
-					auth,
-					pendingAuthorization: yield* pendingStatus(pending),
-					installation: installationStatus(inspection, request.scope),
-				}
-				return yield* Schema.decodeUnknown(StatusResult)(candidate).pipe(
-					Effect.mapError(() => statusError('invalid_status_result', false)),
-				)
-			})
-		})
-
-		return { run } as const
-	}),
-}) {}

package/src/Install/Claude/Hook.ts

@@ -1,123 +0,0 @@
-import { homedir } from 'node:os'
-import { Config, Console, Effect, Match, Schema } from 'effect'
-import { type CliCommand, ConfigIo, cliShellCommand, DIRECT_CLI } from '../Domain.js'
-import type { InstallScope } from '../Mcp.js'
-
-/** Claude Code WebFetch hook invocation persisted in harness settings. */
-export const HOOK_INVOCATION = 'expandai hook claude-code'
-export const HOOK_COMMAND = HOOK_INVOCATION
-const HOOK_ARGS = ['hook', 'claude-code'] as const
-
-/**
- * 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 function hookCommandFor(cli: CliCommand = DIRECT_CLI): string {
-	return cliShellCommand(cli, HOOK_ARGS)
-}
-export const WEBFETCH_MATCHER = 'WebFetch'
-
-export const HookCommandEntry = Schema.Struct(
-	{
-		type: Schema.Literal('command'),
-		command: Schema.String,
-		expandaiProfileVersion: Schema.optional(Schema.String),
-		/** Whether this install added the `WebFetch` deny rule — see `makeExpandaiMatcher`. */
-		expandaiManagedDeny: Schema.optional(Schema.Boolean),
-	},
-	Schema.Record({ key: Schema.String, value: Schema.Unknown }),
-)
-
-export const HookMatcher = Schema.Struct(
-	{
-		matcher: Schema.optional(Schema.String),
-		hooks: Schema.Array(HookCommandEntry),
-	},
-	Schema.Record({ key: Schema.String, value: Schema.Unknown }),
-)
-
-const HooksSection = Schema.Struct(
-	{ PreToolUse: Schema.optional(Schema.Array(HookMatcher)) },
-	Schema.Record({ key: Schema.String, value: Schema.Unknown }),
-)
-
-const PermissionsSection = Schema.Struct(
-	{ deny: Schema.optional(Schema.Array(Schema.String)) },
-	Schema.Record({ key: Schema.String, value: Schema.Unknown }),
-)
-
-export const SettingsSchema = Schema.parseJson(
-	Schema.Struct(
-		{
-			hooks: Schema.optionalWith(HooksSection, { default: () => ({}) as typeof HooksSection.Type }),
-			permissions: Schema.optional(PermissionsSection),
-		},
-		Schema.Record({ key: Schema.String, value: Schema.Unknown }),
-	),
-	{ space: 2 },
-)
-
-export interface ClaudeHookPlan {
-	readonly changed: boolean
-	readonly settings: typeof SettingsSchema.Type
-}
-
-export function isExpandaiHookCommand(command: string): boolean {
-	const value = command.trim()
-	const invocation = String.raw`expandai(?:\.exe)?\s+hook\s+(?:claude-code|claude)`
-	const direct = new RegExp(String.raw`^(?:npx\s+-y\s+)?${invocation}$`, 'u')
-	const absolute = new RegExp(
-		String.raw`^(?:"(?:[A-Za-z]:\\|/)[^"]*[\\/]expandai(?:\.exe)?"|'(?:[A-Za-z]:\\|/)[^']*[\\/]expandai(?:\.exe)?'|(?:[A-Za-z]:\\|/)[^\s]*[\\/]expandai(?:\.exe)?)\s+hook\s+(?:claude-code|claude)$`,
-		'u',
-	)
-	const shellFallback =
-		/^if\s+command\s+-v\s+expandai\s+>\/dev\/null\s+2>&1;\s*then\s+expandai\s+hook\s+(?:claude-code|claude);\s*else\s+npx\s+-y\s+expandai\s+hook\s+(?:claude-code|claude);\s*fi$/u
-	return direct.test(value) || absolute.test(value) || shellFallback.test(value)
-}
-
-/**
- * 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 class ClaudeHook extends Effect.Service<ClaudeHook>()('@expandai/cli/Install/Claude/Hook', {
-	dependencies: [ConfigIo.Default],
-	effect: Effect.gen(function* () {
-		const home = yield* Config.string('HOME').pipe(Config.withDefault(homedir()))
-		const cwd = yield* Config.string('PWD').pipe(Config.withDefault(process.cwd()))
-
-		const pathFor = Effect.fn(function* (scope: InstallScope) {
-			return yield* Match.value(scope).pipe(
-				Match.when('global', () => Effect.succeed(`${home}/.claude/settings.json`)),
-				Match.when('project', () => Effect.succeed(`${cwd}/.claude/settings.json`)),
-				Match.exhaustive,
-			)
-		})
-
-		const NOTICE =
-			'expandai does not install a WebFetch hook for Claude Code — the MCP server and runtime skill replace it, and neither can disable a built-in tool.'
-
-		/**
-		 * Kept as a no-op rather than deleted so `hook install|uninstall claude-code`
-		 * still resolves. Both say what the profile is instead of touching
-		 * `settings.json`, which expandai no longer writes for Claude Code.
-		 */
-		const install = Effect.fn('ClaudeHook.install')(function* (_scope: InstallScope) {
-			yield* Console.log(NOTICE)
-		})
-
-		const uninstall = Effect.fn('ClaudeHook.uninstall')(function* (_scope: InstallScope) {
-			yield* Console.log(NOTICE)
-		})
-
-		return { install, uninstall, pathFor } as const
-	}),
-}) {}

package/src/Install/Claude/Mcp.ts

@@ -1,129 +0,0 @@
-import { homedir } from 'node:os'
-import { Config, Console, Effect, Match, Record, Schema } from 'effect'
-import {
-	type CliCommand,
-	ConfigIo,
-	DIRECT_CLI,
-	McpParseError,
-	McpServersConfigSchema,
-	McpWriteError,
-	SERVER_KEY,
-} from '../Domain.js'
-import type { InstallScope } from '../Mcp.js'
-
-/** Claude Code MCP descriptor stored under the Expand-owned server key. */
-export class Entry extends Schema.Class<Entry>('ClaudeMcpEntry')({
-	type: Schema.Literal('stdio'),
-	command: Schema.NonEmptyTrimmedString,
-	args: Schema.Array(Schema.String),
-	env: Schema.optional(Schema.Record({ key: Schema.String, value: Schema.String })),
-}) {}
-
-export interface ClaudeMcpPlan {
-	readonly changed: boolean
-	readonly config: typeof McpServersConfigSchema.Type
-}
-
-const MCP_ARGS = ['mcp', 'run'] as const
-
-/** Claude execs the descriptor directly, so `command`/`args` stay separate. */
-export function claudeMcpEntry(cli: CliCommand = DIRECT_CLI): Entry {
-	return new Entry({
-		type: 'stdio',
-		command: cli.command,
-		args: [...cli.args, ...MCP_ARGS],
-		env: { EXPANDAI_HARNESS: 'claude-code' },
-	})
-}
-
-export const CLAUDE_MCP_ENTRY = claudeMcpEntry()
-
-function isUnknownRecord(value: unknown): value is Record<string, unknown> {
-	return typeof value === 'object' && value !== null && !Array.isArray(value)
-}
-
-function isCurrentEntry(value: unknown, expected: Entry): boolean {
-	if (!isUnknownRecord(value)) return false
-	const args = value.args
-	const env = value.env
-	return (
-		value.type === expected.type &&
-		value.command === expected.command &&
-		Array.isArray(args) &&
-		args.length === expected.args.length &&
-		args.every((arg, index) => arg === expected.args[index]) &&
-		isUnknownRecord(env) &&
-		env.EXPANDAI_HARNESS === 'claude-code'
-	)
-}
-
-export function planClaudeMcp(config: typeof McpServersConfigSchema.Type, cli: CliCommand = DIRECT_CLI): ClaudeMcpPlan {
-	const entry = claudeMcpEntry(cli)
-	if (isCurrentEntry(config.mcpServers[SERVER_KEY], entry)) return { changed: false, config }
-	return {
-		changed: true,
-		config: {
-			...config,
-			mcpServers: { ...config.mcpServers, [SERVER_KEY]: entry },
-		},
-	}
-}
-
-export function planClaudeMcpRemoval(config: typeof McpServersConfigSchema.Type): ClaudeMcpPlan {
-	if (!(SERVER_KEY in config.mcpServers)) return { changed: false, config }
-	return {
-		changed: true,
-		config: { ...config, mcpServers: Record.remove(config.mcpServers, SERVER_KEY) },
-	}
-}
-
-export class ClaudeMcp extends Effect.Service<ClaudeMcp>()('@expandai/cli/Install/Claude/Mcp', {
-	dependencies: [ConfigIo.Default],
-	effect: Effect.gen(function* () {
-		const io = yield* ConfigIo
-		const home = yield* Config.string('HOME').pipe(Config.withDefault(homedir()))
-		const cwd = yield* Config.string('PWD').pipe(Config.withDefault(process.cwd()))
-
-		const pathFor = Effect.fn(function* (scope: InstallScope) {
-			return yield* Match.value(scope).pipe(
-				Match.when('global', () => Effect.succeed(`${home}/.claude.json`)),
-				Match.when('project', () => Effect.succeed(`${cwd}/.mcp.json`)),
-				Match.exhaustive,
-			)
-		})
-
-		const readConfig = Effect.fn(function* (file: string) {
-			return yield* io
-				.read(file, McpServersConfigSchema)
-				.pipe(Effect.mapError((error) => new McpParseError({ path: file, error })))
-		})
-
-		const writeConfig = Effect.fn(function* (file: string, value: unknown) {
-			yield* io
-				.write(file, value, McpServersConfigSchema)
-				.pipe(Effect.mapError((error) => new McpWriteError({ path: file, error })))
-		})
-
-		const install = Effect.fn(function* (scope: InstallScope) {
-			const file = yield* pathFor(scope)
-			const plan = planClaudeMcp(yield* readConfig(file))
-			if (plan.changed) yield* writeConfig(file, plan.config)
-			yield* Console.log(`Installed expandai MCP server into ${file}`)
-		})
-
-		const uninstall = Effect.fn(function* (scope: InstallScope) {
-			const file = yield* pathFor(scope)
-			const plan = planClaudeMcpRemoval(yield* readConfig(file))
-			if (!plan.changed) return
-			yield* writeConfig(file, plan.config)
-			yield* Console.log(`Removed expandai MCP server from ${file}`)
-		})
-
-		const isInstalled = Effect.fn(function* (scope: InstallScope) {
-			const file = yield* pathFor(scope)
-			return SERVER_KEY in (yield* readConfig(file)).mcpServers
-		})
-
-		return { install, uninstall, isInstalled, pathFor } as const
-	}),
-}) {}

package/src/Install/Claude/Skill.ts

@@ -1,77 +0,0 @@
-import { homedir } from 'node:os'
-import { FileSystem, Path } from '@effect/platform'
-import { NodeFileSystem, NodePath } from '@effect/platform-node'
-import { Config, Effect, Match } from 'effect'
-import { CLI_VERSION } from '../../Version.js'
-import type { InstallScope } from '../Mcp.js'
-
-export const SKILL_NAME = 'expandai'
-export const SKILL_FILE_NAME = 'SKILL.md'
-const PROFILE_VERSION_LINE = /^(\s*expandai-profile-version:\s*).+$/mu
-
-export interface ClaudeSkillPlan {
-	readonly changed: boolean
-	readonly text: string
-}
-
-export function renderClaudeSkill(source: string, profileVersion: string = CLI_VERSION): string {
-	if (!PROFILE_VERSION_LINE.test(source)) {
-		throw new Error('Bundled Expand skill is missing expandai-profile-version metadata')
-	}
-	return source.replace(PROFILE_VERSION_LINE, `$1${profileVersion}`)
-}
-
-export function planClaudeSkill(
-	current: string | undefined,
-	source: string,
-	profileVersion: string = CLI_VERSION,
-): ClaudeSkillPlan {
-	const text = renderClaudeSkill(source, profileVersion)
-	return { changed: current !== text, text }
-}
-
-const makeClaudeSkill = Effect.gen(function* () {
-	const fileSystem = yield* FileSystem.FileSystem
-	const path = yield* Path.Path
-	const home = yield* Config.string('HOME').pipe(Config.withDefault(homedir()))
-	const cwd = yield* Config.string('PWD').pipe(Config.withDefault(process.cwd()))
-	const moduleFile = yield* path.fromFileUrl(new URL(import.meta.url))
-	const sourceFile = path.resolve(path.dirname(moduleFile), '..', '..', '..', 'skills', SKILL_NAME, SKILL_FILE_NAME)
-
-	const pathFor = Effect.fn(function* (scope: InstallScope) {
-		return yield* Match.value(scope).pipe(
-			Match.when('global', () => Effect.succeed(path.join(home, '.claude', 'skills', SKILL_NAME))),
-			Match.when('project', () => Effect.succeed(path.join(cwd, '.claude', 'skills', SKILL_NAME))),
-			Match.exhaustive,
-		)
-	})
-
-	const source = Effect.fn('ClaudeSkill.source')(function* () {
-		return yield* fileSystem.readFileString(sourceFile)
-	})
-
-	const install = Effect.fn('ClaudeSkill.install')(function* (scope: InstallScope) {
-		const target = yield* pathFor(scope)
-		const targetFile = path.join(target, SKILL_FILE_NAME)
-		const current = (yield* fileSystem.exists(targetFile)) ? yield* fileSystem.readFileString(targetFile) : undefined
-		const plan = planClaudeSkill(current, yield* source())
-		if (plan.changed) {
-			yield* fileSystem.makeDirectory(target, { recursive: true })
-			yield* fileSystem.writeFileString(targetFile, plan.text)
-		}
-		return target
-	})
-
-	const uninstall = Effect.fn('ClaudeSkill.uninstall')(function* (scope: InstallScope) {
-		const target = yield* pathFor(scope)
-		if (yield* fileSystem.exists(target)) yield* fileSystem.remove(target, { recursive: true })
-		return target
-	})
-
-	return { install, uninstall, pathFor, source } as const
-})
-
-export class ClaudeSkill extends Effect.Service<ClaudeSkill>()('@expandai/cli/Install/Claude/Skill', {
-	dependencies: [NodeFileSystem.layer, NodePath.layer],
-	effect: makeClaudeSkill,
-}) {}