@fabrika/builder 0.2.0 → 0.3.2

package/cli/src/daemon-client.ts

@@ -1,138 +1,25 @@
-import { resolve } from 'path'
-import { BASE_URL, SESSIONS_DIR, TIMEOUT_MS, WS_URL } from './config'
+import { waitForEvent } from '@fabrika/daemon-kit'
+import {
+	consumedFeedbackSchema,
+	feedbackMetaSchema,
+	feedbackTextSchema,
+	phaseStateSchema,
+	planResultSchema,
+	submitFeedbackSchema,
+} from '../../shared'
+import { BASE_URL, TIMEOUT_MS, WS_URL } from './config'
 import type { PhaseState } from './derive'
-import { PHASES } from './phases'
 
 const HEALTH_TIMEOUT_MS = 1000
 
-export interface HealthInfo {
-	ok: boolean
-	version?: string
-	pid?: number
-	dataDir?: string
-	sessionsDir?: string
-	sessions?: number | string[]
-}
-
-function isRecord(value: unknown): value is Record<string, unknown> {
-	return typeof value === 'object' && value !== null && !Array.isArray(value)
-}
-
-function optionalString(value: unknown): string | undefined {
-	return typeof value === 'string' ? value : undefined
-}
-
-function optionalNumber(value: unknown): number | undefined {
-	return typeof value === 'number' ? value : undefined
-}
-
-function optionalBoolean(value: unknown): boolean | undefined {
-	return typeof value === 'boolean' ? value : undefined
-}
-
-function stringArray(value: unknown): string[] | null {
-	if (!Array.isArray(value) || !value.every((item: unknown) => typeof item === 'string')) return null
-	return value
-}
-
-function parseHealthInfo(value: unknown): HealthInfo | null {
-	if (!isRecord(value) || value['ok'] !== true) return null
-	const sessions = typeof value['sessions'] === 'number' ? value['sessions'] : stringArray(value['sessions']) ?? undefined
-	return {
-		ok: true,
-		...(optionalString(value['version']) === undefined ? {} : { version: optionalString(value['version']) }),
-		...(optionalNumber(value['pid']) === undefined ? {} : { pid: optionalNumber(value['pid']) }),
-		...(optionalString(value['dataDir']) === undefined ? {} : { dataDir: optionalString(value['dataDir']) }),
-		...(optionalString(value['sessionsDir']) === undefined ? {} : { sessionsDir: optionalString(value['sessionsDir']) }),
-		...(sessions === undefined ? {} : { sessions }),
-	}
-}
-
-function isPhaseId(value: unknown): value is PhaseState['current'] {
-	return typeof value === 'string' && PHASES.some((phase) => phase.id === value)
-}
-
-function parsePhaseState(value: unknown): PhaseState | null {
-	if (!isRecord(value) || !isPhaseId(value['current']) || typeof value['index'] !== 'number') return null
-	const rawCompleted = value['completed']
-	const completed = Array.isArray(rawCompleted) ? rawCompleted.filter(isPhaseId) : null
-	const reads = stringArray(value['reads'])
-	const produces = stringArray(value['produces'])
-	if (completed === null || !Array.isArray(rawCompleted) || completed.length !== rawCompleted.length || reads === null || produces === null) {
-		return null
-	}
-	if (typeof value['gate'] !== 'boolean' || typeof value['satisfied'] !== 'boolean') return null
-	return {
-		current: value['current'],
-		index: value['index'],
-		completed,
-		reads,
-		produces,
-		gate: value['gate'],
-		satisfied: value['satisfied'],
-	}
-}
-
-function stringRecord(value: unknown): Record<string, string> | undefined {
-	if (!isRecord(value)) return undefined
-	const result: Record<string, string> = {}
-	for (const [key, entry] of Object.entries(value)) {
-		if (typeof entry !== 'string') return undefined
-		result[key] = entry
-	}
-	return result
-}
-
-function parsePlanResult(value: unknown): PlanResult {
-	if (!isRecord(value) || typeof value['ok'] !== 'boolean') return { ok: false, error: 'Invalid daemon response' }
-	return {
-		ok: value['ok'],
-		...(optionalString(value['browserUrl']) === undefined ? {} : { browserUrl: optionalString(value['browserUrl']) }),
-		...(optionalNumber(value['revision']) === undefined ? {} : { revision: optionalNumber(value['revision']) }),
-		...(optionalBoolean(value['isNew']) === undefined ? {} : { isNew: optionalBoolean(value['isNew']) }),
-		...(stringArray(value['canvasFiles']) === null ? {} : { canvasFiles: stringArray(value['canvasFiles']) ?? [] }),
-		...(optionalString(value['gate']) === undefined ? {} : { gate: optionalString(value['gate']) }),
-		...(optionalString(value['error']) === undefined ? {} : { error: optionalString(value['error']) }),
-		...(stringRecord(value['errors']) === undefined ? {} : { errors: stringRecord(value['errors']) }),
-	}
-}
-
-export async function health(): Promise<HealthInfo | null> {
-	try {
-		const res = await fetch(`${BASE_URL}/health`, { signal: AbortSignal.timeout(HEALTH_TIMEOUT_MS) })
-		const data: unknown = await res.json()
-		return parseHealthInfo(data)
-	} catch {
-		return null
-	}
-}
-
-export async function isDaemonRunning(): Promise<boolean> {
-	const info = await health()
-	return info !== null && healthMatchesDataRoot(info)
-}
-
-export function healthMatchesDataRoot(
-	info: HealthInfo,
-	expectedSessionsDir: string = SESSIONS_DIR,
-): boolean {
-	if (!info.sessionsDir) return false
-	return comparablePath(info.sessionsDir) === comparablePath(expectedSessionsDir)
-}
-
-function comparablePath(path: string): string {
-	const absolute = resolve(path)
-	return process.platform === 'win32' ? absolute.toLowerCase() : absolute
-}
-
 export async function fetchPhase(fabrikaDir: string, sessionId?: string): Promise<PhaseState | null> {
 	try {
 		let url = `${BASE_URL}/api/phase?root=${encodeURIComponent(fabrikaDir)}`
 		if (sessionId) url += `&session=${encodeURIComponent(sessionId)}`
 		const res = await fetch(url, { signal: AbortSignal.timeout(HEALTH_TIMEOUT_MS) })
 		if (!res.ok) return null
-		const data: unknown = await res.json()
-		return parsePhaseState(data)
+		const result = phaseStateSchema.safeParse(await res.json())
+		return result.success ? result.data : null
 	} catch {
 		return null
 	}
@@ -163,8 +50,8 @@ export async function pushPlan(
 			headers: { 'Content-Type': 'application/json' },
 			body: JSON.stringify(body),
 		})
-		const data = parsePlanResult(await res.json())
-		return { ...data, reachable: true }
+		const result = planResultSchema.safeParse(await res.json())
+		return { ...(result.success ? result.data : { ok: false, error: 'Invalid daemon response' }), reachable: true }
 	} catch (e) {
 		return { ok: false, reachable: false, error: String(e) }
 	}
@@ -172,23 +59,20 @@ export async function pushPlan(
 
 export async function peekFeedback(sessionId: string): Promise<string | null> {
 	try {
-		const metaRes = await fetch(`${BASE_URL}/api/session/${sessionId}/meta`, {
-			signal: AbortSignal.timeout(HEALTH_TIMEOUT_MS),
-		})
+		const metaRes = await fetch(`${BASE_URL}/api/session/${sessionId}/meta`, { signal: AbortSignal.timeout(HEALTH_TIMEOUT_MS) })
 		if (!metaRes.ok) return null
-		const meta: unknown = await metaRes.json()
-		if (!isRecord(meta) || !Array.isArray(meta['revisions'])) return null
-		const revisions = meta['revisions']
+		const meta = feedbackMetaSchema.safeParse(await metaRes.json())
+		if (!meta.success) return null
+		const revisions = meta.data.revisions
 		for (let i = revisions.length - 1; i >= 0; i--) {
-			const revision = revisions[i]
-			if (!isRecord(revision) || typeof revision['revision'] !== 'number') continue
-			if (revision['hasFeedback'] === true && revision['feedbackConsumed'] !== true) {
-				const fbRes = await fetch(`${BASE_URL}/api/session/${sessionId}/revision/${revision['revision']}/feedback`, {
+			const revision = revisions[i]!
+			if (revision.hasFeedback && !revision.feedbackConsumed) {
+				const fbRes = await fetch(`${BASE_URL}/api/session/${sessionId}/revision/${revision.revision}/feedback`, {
 					signal: AbortSignal.timeout(HEALTH_TIMEOUT_MS),
 				})
 				if (!fbRes.ok) return null
-				const data: unknown = await fbRes.json()
-				return isRecord(data) && typeof data['feedback'] === 'string' ? data['feedback'] : ''
+				const result = feedbackTextSchema.safeParse(await fbRes.json())
+				return result.success ? result.data.feedback : ''
 			}
 		}
 		return null
@@ -203,9 +87,8 @@ export async function consumeFeedback(sessionId: string): Promise<string | null>
 			method: 'POST',
 			signal: AbortSignal.timeout(HEALTH_TIMEOUT_MS),
 		})
-		const data: unknown = await res.json()
-		if (!isRecord(data) || data['found'] !== true) return null
-		return typeof data['feedback'] === 'string' ? data['feedback'] : ''
+		const result = consumedFeedbackSchema.safeParse(await res.json())
+		return result.success ? result.data.feedback : null
 	} catch {
 		return null
 	}
@@ -233,48 +116,16 @@ export async function postBuildEvent(event: BuildEvent): Promise<boolean> {
 }
 
 export function waitForFeedback(sessionId: string, timeoutMs: number = TIMEOUT_MS): Promise<string> {
-	return new Promise((resolveP, rejectP) => {
-		let settled = false
-		const ws = new WebSocket(`${WS_URL}/ws/wait/${sessionId}`)
-
-		const timer = setTimeout(() => {
-			if (settled) return
-			settled = true
-			try {
-				ws.close()
-			} catch {}
-			rejectP(new Error('timeout'))
-		}, timeoutMs)
-
-		ws.onmessage = (event: MessageEvent) => {
-			try {
-				const raw = typeof event.data === 'string' ? event.data : ''
-				const data: unknown = JSON.parse(raw)
-				if (isRecord(data) && data['type'] === 'submit') {
-					if (settled) return
-					settled = true
-					clearTimeout(timer)
-					try {
-						ws.close()
-					} catch {}
-					resolveP(typeof data['feedback'] === 'string' ? data['feedback'] : '')
-				}
-			} catch {
-			}
-		}
-
-		ws.onerror = () => {
-			if (settled) return
-			settled = true
-			clearTimeout(timer)
-			rejectP(new Error('connection-failed'))
-		}
-
-		ws.onclose = () => {
-			if (settled) return
-			settled = true
-			clearTimeout(timer)
-			rejectP(new Error('closed'))
-		}
+	return waitForEvent({
+		url: `${WS_URL}/ws/wait/${sessionId}`,
+		timeoutMs,
+		onFrame: (frame) => {
+			const result = submitFeedbackSchema.safeParse(frame)
+			return result.success ? { type: 'settle', value: result.data.feedback } : undefined
+		},
+		probe: async () => {
+			const feedback = await peekFeedback(sessionId)
+			return feedback === null ? undefined : { value: feedback }
+		},
 	})
 }

package/cli/src/daemon-lifecycle.ts

@@ -1,171 +1,92 @@
-import { spawn } from 'child_process'
-import { closeSync, existsSync, mkdirSync, openSync, readFileSync, unlinkSync } from 'fs'
-import { dirname, join, resolve } from 'path'
-import { fileURLToPath } from 'url'
-import { DATA_DIR, PID_FILE, SESSIONS_DIR, TEMP_DIR } from './config'
-import { health, type HealthInfo, healthMatchesDataRoot, isDaemonRunning } from './daemon-client'
-
-const HERE = dirname(fileURLToPath(import.meta.url))
-
-export function resolveDaemonServer(): string | null {
-	const candidates = [
-		resolve(HERE, '../../daemon/src/bin.ts'),
-	]
-	for (const c of candidates) {
-		if (existsSync(c)) return c
-	}
-	return null
+import { createDaemonLifecycle, type DaemonLifecycleConfig, DaemonStartError } from '@fabrika/daemon-kit'
+import { spawn } from 'node:child_process'
+import { dirname, join, resolve } from 'node:path'
+import { fileURLToPath } from 'node:url'
+import type { z } from 'zod'
+import { healthInfoSchema } from '../../shared'
+import { BASE_URL, DATA_DIR, PID_FILE, SESSIONS_DIR, TEMP_DIR } from './config'
+
+export type DaemonHealthInfo = z.output<typeof healthInfoSchema> & { pid: number }
+
+function parseDaemonHealth(body: unknown): DaemonHealthInfo | undefined {
+	const result = healthInfoSchema.safeParse(body)
+	if (!result.success) return undefined
+	const { pid } = result.data
+	return pid !== undefined && Number.isInteger(pid) ? { ...result.data, pid } : undefined
 }
 
-export class DaemonUnavailableError extends Error {
-	constructor(message: string) {
-		super(message)
-		this.name = 'DaemonUnavailableError'
-	}
+function comparablePath(path: string): string {
+	const absolute = resolve(path)
+	return process.platform === 'win32' ? absolute.toLowerCase() : absolute
 }
 
-export async function startDaemon(): Promise<void> {
-	const server = resolveDaemonServer()
-	if (!server) {
-		throw new DaemonUnavailableError(
-			'fabrika builder daemon not found. '
-				+ 'Build/start it manually, or run the CLI in offline mode.',
-		)
-	}
-
-	mkdirSync(TEMP_DIR, { recursive: true })
-	const startupLog = join(TEMP_DIR, 'daemon-startup.log')
-	const fd = openSync(startupLog, 'w')
-
-	const child = spawn('bun', ['run', server], {
-		detached: true,
-		stdio: ['ignore', 'ignore', fd],
-		cwd: dirname(dirname(server)),
-		env: daemonSpawnEnvironment(),
-	})
-	child.unref()
-	closeSync(fd)
-
-	for (let i = 0; i < 30; i++) {
-		await new Promise((r) => setTimeout(r, 100))
-		if (await isDaemonRunning()) return
-	}
-
-	let detail = ''
-	if (existsSync(startupLog)) {
-		const log = readFileSync(startupLog, 'utf-8').trim()
-		if (log) detail = '\nDaemon stderr:\n' + log
-	}
-	throw new DaemonUnavailableError('Daemon failed to start within 3 seconds.' + detail)
-}
-
-export function daemonSpawnEnvironment(
-	base: NodeJS.ProcessEnv = process.env,
-	dataDir: string = DATA_DIR,
-): NodeJS.ProcessEnv {
-	return { ...base, FABRIKA_DATA_DIR: resolve(dataDir) }
+export function healthMatchesDataRoot(info: { sessionsDir: string }, expectedSessionsDir: string = SESSIONS_DIR): boolean {
+	return comparablePath(info.sessionsDir) === comparablePath(expectedSessionsDir)
 }
 
-export async function ensureDaemon(opts: { quiet?: boolean } = {}): Promise<boolean> {
-	const active = await health()
-	if (active && healthMatchesDataRoot(active)) return true
-
-	if (active) {
-		const stopped = await stopMismatchedManagedDaemon(active, opts.quiet ?? false)
-		if (!stopped) return false
-	}
-
-	if (existsSync(PID_FILE)) {
-		const pid = parseInt(readFileSync(PID_FILE, 'utf-8').trim(), 10)
-		if (!isAlive(pid)) {
-			try {
-				unlinkSync(PID_FILE)
-			} catch {}
-		}
-	}
-
-	try {
-		await startDaemon()
-		return true
-	} catch (error: unknown) {
-		if (!opts.quiet) {
-			console.error(`[fabrika] ${error instanceof Error ? error.message : String(error)}`)
-		}
-		return false
-	}
+const DAEMON_BIN = fileURLToPath(new URL('../../daemon/src/bin.ts', import.meta.url))
+
+export const daemonLifecycleConfig: DaemonLifecycleConfig<DaemonHealthInfo> = {
+	baseUrl: BASE_URL,
+	parseHealth: parseDaemonHealth,
+	pidFile: PID_FILE,
+	command: [process.execPath, DAEMON_BIN, '--data-dir', DATA_DIR],
+	// Never the caller's project: its bunfig.toml preloads must not load into the daemon.
+	cwd: dirname(dirname(DAEMON_BIN)),
+	logFile: join(TEMP_DIR, 'daemon.log'),
+	// A daemon serving another data root is restarted, like one of another version.
+	versionCheck: {
+		expected: comparablePath(SESSIONS_DIR),
+		of: (health) => comparablePath(health.sessionsDir),
+	},
 }
 
-async function stopMismatchedManagedDaemon(info: HealthInfo, quiet: boolean): Promise<boolean> {
-	const actual = info.sessionsDir ?? '<not reported by legacy daemon>'
-	const mismatch = `daemon data-root mismatch: active ${actual}, requested ${SESSIONS_DIR}`
-	if (!existsSync(PID_FILE)) {
-		if (!quiet) console.error(`[fabrika] ${mismatch}; no managed PID file, refusing to stop it.`)
-		return false
-	}
+export const daemon = createDaemonLifecycle(daemonLifecycleConfig)
 
-	const pid = parseInt(readFileSync(PID_FILE, 'utf-8').trim(), 10)
-	if (!isAlive(pid) || info.pid === undefined || info.pid !== pid) {
-		if (!quiet) console.error(`[fabrika] ${mismatch}; daemon PID ownership could not be verified.`)
-		return false
+export async function ensureDaemon(opts: { quiet?: boolean } = {}): Promise<boolean> {
+	const report = (message: string) => {
+		if (!opts.quiet) console.error(`[fabrika] ${message}`)
 	}
-
-	if (!quiet) console.error(`[fabrika] ${mismatch}; restarting managed daemon ${pid}.`)
+	const lifecycle = createDaemonLifecycle({
+		...daemonLifecycleConfig,
+		onEvent: (event) => {
+			if (event.type === 'version-mismatch') {
+				report(`daemon data-root mismatch: active ${event.running}, requested ${event.expected}; restarting the daemon.`)
+			}
+		},
+	})
 	try {
-		process.kill(pid, 'SIGTERM')
-	} catch {
+		const health = await lifecycle.ensure()
+		if (healthMatchesDataRoot(health)) return true
+		report(`daemon data-root mismatch: active ${health.sessionsDir}, requested ${SESSIONS_DIR}`)
 		return false
-	}
-
-	for (let attempt = 0; attempt < 30; attempt++) {
-		await new Promise((resolveP) => setTimeout(resolveP, 100))
-		if ((await health()) === null) {
-			try {
-				unlinkSync(PID_FILE)
-			} catch {}
-			return true
+	} catch (error: unknown) {
+		if (error instanceof DaemonStartError) {
+			report(error.logTail ? `${error.message}\nDaemon log (${error.logFile}):\n${error.logTail}` : error.message)
+		} else {
+			report(error instanceof Error ? error.message : String(error))
 		}
-	}
-	if (!quiet) console.error(`[fabrika] mismatched daemon did not stop within 3 seconds.`)
-	return false
-}
-
-export function stopDaemon(): boolean {
-	if (!existsSync(PID_FILE)) return false
-	const pid = parseInt(readFileSync(PID_FILE, 'utf-8').trim(), 10)
-	try {
-		process.kill(pid, 'SIGTERM')
-		try {
-			unlinkSync(PID_FILE)
-		} catch {}
-		return true
-	} catch {
-		try {
-			unlinkSync(PID_FILE)
-		} catch {}
 		return false
 	}
 }
 
-function isAlive(pid: number): boolean {
-	if (!Number.isFinite(pid) || pid <= 0) return false
-	try {
-		process.kill(pid, 0)
-		return true
-	} catch {
-		return false
-	}
+export async function isDaemonRunning(): Promise<boolean> {
+	const health = await daemon.health()
+	return health.status === 'up' && healthMatchesDataRoot(health)
 }
 
-export function openBrowser(url: string): void {
+export function openBrowser(url: string, fallbackUrl: string = url): void {
 	const candidates = process.platform === 'darwin'
 		? ['open']
 		: ['xdg-open', 'wslview', 'sensible-browser']
 	for (const cmd of candidates) {
 		const which = Bun.spawnSync(['which', cmd])
 		if (which.exitCode === 0) {
-			spawn(cmd, [url], { detached: true, stdio: 'ignore' }).unref()
+			const child = spawn(cmd, [url], { detached: true, stdio: 'ignore' })
+			child.on('error', () => console.error(`Open this URL in your browser: ${fallbackUrl}`))
+			child.unref()
 			return
 		}
 	}
-	console.error(`Open this URL in your browser: ${url}`)
+	console.error(`Open this URL in your browser: ${fallbackUrl}`)
 }

package/cli/src/derive.ts

@@ -1,6 +1,6 @@
 import { existsSync, readdirSync, statSync } from 'fs'
 import { basename, dirname, join, resolve } from 'path'
-import { type Phase, type PhaseId, PHASES } from './phases'
+import { isPhaseHint, type Phase, type PhaseId, phaseIndex, PHASES } from '../../shared/phases'
 
 export interface PhaseState {
 	current: PhaseId
@@ -51,7 +51,7 @@ export function isNonEmptyFile(p: string): boolean {
 
 export function producesSatisfied(repoRoot: string, phase: Phase): boolean {
 	for (const glob of phase.produces) {
-		if (isPlaceholder(glob)) return false
+		if (isPhaseHint(glob)) return false
 		const matches = matchGlob(repoRoot, glob).filter(isNonEmptyFile)
 		if (matches.length === 0) return false
 	}
@@ -61,7 +61,7 @@ export function producesSatisfied(repoRoot: string, phase: Phase): boolean {
 export function resolveReads(repoRoot: string, phase: Phase): string[] {
 	const out: string[] = []
 	for (const glob of phase.reads) {
-		if (isPlaceholder(glob)) {
+		if (isPhaseHint(glob)) {
 			out.push(glob) // keep the human hint, e.g. "<init brief>"
 			continue
 		}
@@ -73,10 +73,6 @@ export function resolveReads(repoRoot: string, phase: Phase): string[] {
 	return out
 }
 
-function isPlaceholder(glob: string): boolean {
-	return glob.startsWith('<')
-}
-
 export function derivePhase(repoRoot: string, gateProbe: GateProbe = offlineGateProbe): PhaseState {
 	const completed: PhaseId[] = []
 
@@ -99,7 +95,7 @@ export function derivePhase(repoRoot: string, gateProbe: GateProbe = offlineGate
 function toState(repoRoot: string, phase: Phase, completed: PhaseId[], satisfied: boolean): PhaseState {
 	return {
 		current: phase.id,
-		index: PHASES.findIndex((p) => p.id === phase.id),
+		index: phaseIndex(phase.id),
 		completed,
 		reads: resolveReads(repoRoot, phase),
 		produces: phase.produces,

package/cli/src/errors.ts

@@ -0,0 +1 @@
+export class BuilderCliError extends Error {}

package/cli/src/index.ts

@@ -1,3 +1,4 @@
+export { type Phase, PHASE_COUNT, PHASE_IDS, phaseById, type PhaseId, phaseIndex, PHASES } from '../../shared/phases'
 export { resolveCatalogRoot, resolveStackPointer, type StackPointer } from './catalog'
 export {
 	BASE_URL,
@@ -6,7 +7,6 @@ export {
 	FABRIKA_DIRNAME,
 	getSessionId,
 	hashRepoPath,
-	LEGACY_DATA_DIR,
 	NEUTRAL_DATA_DIR,
 	resolveDataDir,
 	TEMP_DIR,
@@ -34,5 +34,4 @@ export {
 	readConfig,
 	scaffold,
 } from './layout'
-export { type PacketJson, packetJson, PHASE_IDS, type RenderOpts, renderPacket } from './packet'
-export { type Phase, PHASE_COUNT, phaseById, type PhaseId, phaseIndex, PHASES } from './phases'
+export { type PacketJson, packetJson, type RenderOpts, renderPacket } from './packet'

package/cli/src/inject-skills.ts

@@ -2,6 +2,7 @@ import { createHash } from 'crypto'
 import { existsSync, mkdirSync, readdirSync, readFileSync, renameSync, writeFileSync } from 'fs'
 import { dirname, join, relative, resolve } from 'path'
 import { fileURLToPath } from 'url'
+import { z } from 'zod'
 
 const HERE = dirname(fileURLToPath(import.meta.url))
 const MANIFEST_VERSION = 1
@@ -13,9 +14,8 @@ export interface InjectOptions {
 	hosts?: AgentHost[]
 }
 
-function isRecord(value: unknown): value is Record<string, unknown> {
-	return typeof value === 'object' && value !== null && !Array.isArray(value)
-}
+const managedFileSchema = z.object({ installedHash: z.string(), host: z.enum(['claude', 'codex']) })
+const managedManifestSchema = z.object({ files: z.record(managedFileSchema.nullable().catch(null)) })
 
 function isAgentHost(value: string): value is AgentHost {
 	return value === 'claude' || value === 'codex'
@@ -49,21 +49,6 @@ interface AgentSource {
 	raw: string
 }
 
-const LEGACY_MANAGED_HASHES: Record<string, Set<string>> = {
-	[join('.claude', 'skills', 'fabrika', 'SKILL.md')]: new Set([
-		'd06c8508d47ab36222bcb33b964fd928e3fbcff383db8c257ef68dfd956dd428',
-	]),
-	[join('.claude', 'agents', 'build-orchestrator.md')]: new Set([
-		'31c436e08ffac217d32c71ec56d1612f565b0b2828df9c067ff1e812768339f1',
-	]),
-	[join('.claude', 'agents', 'flows-author.md')]: new Set([
-		'1e55cce06f0210b65ce6ec2d9cd1d4bb5e0e8bcff11e06eb4f2ee405914dd322',
-	]),
-	[join('.claude', 'agents', 'opice-skeleton-author.md')]: new Set([
-		'8644461c1acdc236a886b648ae97984cbd54bc0d59872f7b310ce2b5783e4378',
-	]),
-}
-
 export function resolveSkillSource(): string | null {
 	const candidates = [resolve(HERE, '../../skill')]
 	for (const candidate of candidates) {
@@ -256,10 +241,7 @@ function installManagedFile(
 		result.written.push(destination)
 	} else if (existingHash === desiredHash) {
 		result.skipped.push(destination)
-	} else if (
-		existingHash === recorded?.installedHash
-		|| LEGACY_MANAGED_HASHES[desired.relativePath]?.has(existingHash ?? '')
-	) {
+	} else if (existingHash === recorded?.installedHash) {
 		writeAtomic(destination, desired.content)
 		result.updated.push(destination)
 	} else {
@@ -273,16 +255,11 @@ function installManagedFile(
 function readManifest(path: string): ManagedManifest {
 	if (!existsSync(path)) return { version: MANIFEST_VERSION, files: {} }
 	try {
-		const parsed: unknown = JSON.parse(readFileSync(path, 'utf-8'))
-		if (!isRecord(parsed) || !isRecord(parsed['files'])) return { version: MANIFEST_VERSION, files: {} }
+		const parsed = managedManifestSchema.safeParse(JSON.parse(readFileSync(path, 'utf-8')))
+		if (!parsed.success) return { version: MANIFEST_VERSION, files: {} }
 		const files: ManagedManifest['files'] = {}
-		for (const [relativePath, candidate] of Object.entries(parsed['files'])) {
-			if (!isRecord(candidate)) continue
-			const installedHash = candidate['installedHash']
-			const host = candidate['host']
-			if (typeof installedHash === 'string' && typeof host === 'string' && isAgentHost(host)) {
-				files[relativePath] = { installedHash, host }
-			}
+		for (const [relativePath, candidate] of Object.entries(parsed.data.files)) {
+			if (candidate !== null) files[relativePath] = candidate
 		}
 		return {
 			version: MANIFEST_VERSION,