@prover-coder-ai/context-doc 1.0.12 → 1.0.13

package/dist/shell/codexSync.js

@@ -1,129 +0,0 @@
-import fs from "node:fs";
-import os from "node:os";
-import path from "node:path";
-import * as S from "@effect/schema/Schema";
-import { Console, Effect, pipe } from "effect";
-import { buildProjectLocator, linesMatchProject } from "../core/knowledge.js";
-import { ensureDirectory, syncError } from "./syncShared.js";
-const PackageRepositorySchema = S.Struct({
-    url: S.String,
-});
-const PackageFileSchema = S.Struct({
-    repository: S.optional(PackageRepositorySchema),
-});
-const PackageFileFromJson = S.compose(S.parseJson(), PackageFileSchema);
-const decodePackageFile = S.decodeUnknownSync(PackageFileFromJson);
-const readRepositoryUrl = (cwd, repositoryUrlOverride) => Effect.try({
-    try: () => {
-        if (repositoryUrlOverride !== undefined) {
-            return repositoryUrlOverride;
-        }
-        const raw = fs.readFileSync(path.join(cwd, "package.json"), "utf8");
-        const parsed = decodePackageFile(raw);
-        const repositoryUrl = parsed.repository?.url;
-        if (repositoryUrl === undefined) {
-            throw new Error("repository url is missing");
-        }
-        return repositoryUrl;
-    },
-    catch: () => syncError("package.json", "Cannot read repository url"),
-});
-const resolveSourceDir = (cwd, override, metaRoot) => pipe(Effect.sync(() => {
-    const envSource = process.env.CODEX_SOURCE_DIR;
-    const metaCandidate = metaRoot === undefined
-        ? undefined
-        : metaRoot.endsWith(".codex")
-            ? metaRoot
-            : path.join(metaRoot, ".codex");
-    const localSource = path.join(cwd, ".codex");
-    const homeSource = path.join(os.homedir(), ".codex");
-    const localKnowledge = path.join(cwd, ".knowledge", ".codex");
-    const homeKnowledge = path.join(os.homedir(), ".knowledge", ".codex");
-    const candidates = [
-        override,
-        envSource,
-        metaCandidate,
-        localSource,
-        homeSource,
-        localKnowledge,
-        homeKnowledge,
-    ].filter((candidate) => candidate !== undefined);
-    const existing = candidates.find((candidate) => fs.existsSync(candidate));
-    return { existing, candidates };
-}), Effect.flatMap(({ existing, candidates }) => existing === undefined
-    ? Effect.fail(syncError(".codex", `Source .codex directory is missing; checked: ${candidates.join(", ")}`))
-    : Effect.succeed(existing)));
-const collectJsonlFiles = (root) => Effect.try({
-    try: () => {
-        const collected = [];
-        const walk = (current) => {
-            const entries = fs.readdirSync(current, { withFileTypes: true });
-            for (const entry of entries) {
-                const fullPath = path.join(current, entry.name);
-                if (entry.isDirectory()) {
-                    walk(fullPath);
-                }
-                else if (entry.isFile() && entry.name.endsWith(".jsonl")) {
-                    collected.push(fullPath);
-                }
-            }
-        };
-        walk(root);
-        return collected;
-    },
-    catch: () => syncError(root, "Cannot traverse .codex"),
-});
-const isFileRelevant = (filePath, locator) => Effect.try({
-    try: () => {
-        const content = fs.readFileSync(filePath, "utf8");
-        const lines = content.split("\n");
-        return linesMatchProject(lines, locator);
-    },
-    catch: () => syncError(filePath, "Cannot read jsonl file"),
-});
-const copyRelevantFile = (sourceRoot, destinationRoot, filePath) => Effect.try({
-    try: () => {
-        const relative = path.relative(sourceRoot, filePath);
-        const targetPath = path.join(destinationRoot, relative);
-        fs.mkdirSync(path.dirname(targetPath), { recursive: true });
-        fs.copyFileSync(filePath, targetPath);
-    },
-    catch: () => syncError(filePath, "Cannot copy file into .knowledge/.codex"),
-});
-const selectRelevantFiles = (files, locator) => Effect.reduce(files, [], (acc, filePath) => pipe(isFileRelevant(filePath, locator), Effect.map((isRelevant) => {
-    if (isRelevant) {
-        acc.push(filePath);
-    }
-    return acc;
-})));
-const resolveLocator = (options) => pipe(readRepositoryUrl(options.cwd, options.repositoryUrlOverride), Effect.map((repositoryUrl) => buildProjectLocator(repositoryUrl, options.cwd)), Effect.catchAll(() => Effect.gen(function* (__) {
-    yield* __(Console.log("Codex repository url missing; falling back to cwd-only match"));
-    return buildProjectLocator(options.cwd, options.cwd);
-})));
-const copyCodexFiles = (sourceDir, destinationDir, locator) => Effect.gen(function* (_) {
-    yield* _(ensureDirectory(destinationDir));
-    const allJsonlFiles = yield* _(collectJsonlFiles(sourceDir));
-    const relevantFiles = yield* _(selectRelevantFiles(allJsonlFiles, locator));
-    yield* _(Effect.forEach(relevantFiles, (filePath) => copyRelevantFile(sourceDir, destinationDir, filePath)));
-    yield* _(Console.log(`Codex: copied ${relevantFiles.length} files from ${sourceDir} to ${destinationDir}`));
-});
-// CHANGE: Extract Codex dialog sync into dedicated module for clarity.
-// WHY: Separate Codex-specific shell effects from other sync flows.
-// QUOTE(ТЗ): "вынеси в отдельный файл"
-// REF: user request 2025-11-26
-// SOURCE: internal requirement
-// FORMAT THEOREM: ∀f ∈ Files: relevant(f, locator) → copied(f, destination)
-// PURITY: SHELL
-// EFFECT: Effect<void, SyncError, never>
-// INVARIANT: ∀f ∈ copiedFiles: linesMatchProject(f, locator)
-// COMPLEXITY: O(n) time / O(n) space, n = |files|
-export const syncCodex = (options) => Effect.gen(function* (_) {
-    const locator = yield* _(resolveLocator(options));
-    const sourceDir = yield* _(resolveSourceDir(options.cwd, options.sourceDir, options.metaRoot));
-    const destinationDir = options.destinationDir ?? path.join(options.cwd, ".knowledge", ".codex");
-    if (path.resolve(sourceDir) === path.resolve(destinationDir)) {
-        yield* _(Console.log("Codex source equals destination; skipping copy to avoid duplicates"));
-        return;
-    }
-    yield* _(copyCodexFiles(sourceDir, destinationDir, locator));
-}).pipe(Effect.catchAll((error) => Console.log(`Codex source not found; skipped syncing Codex dialog files (${error.reason})`)));

package/dist/shell/qwenSync.js

@@ -1,41 +0,0 @@
-import { createHash } from "node:crypto";
-import fs from "node:fs";
-import os from "node:os";
-import path from "node:path";
-import { Effect } from "effect";
-import { copyFilteredFiles, runSyncSource, syncError } from "./syncShared.js";
-const qwenHashFromPath = (projectPath) => createHash("sha256").update(projectPath).digest("hex");
-const resolveQwenSourceDir = (cwd, override, metaRoot) => Effect.gen(function* (_) {
-    const hash = qwenHashFromPath(cwd);
-    const envSource = process.env.QWEN_SOURCE_DIR;
-    const baseFromMeta = metaRoot === undefined
-        ? undefined
-        : metaRoot.endsWith(".qwen")
-            ? metaRoot
-            : path.join(metaRoot, ".qwen");
-    const metaKnowledge = path.join(metaRoot ?? "", ".knowledge", ".qwen");
-    const homeBase = path.join(os.homedir(), ".qwen");
-    const homeKnowledge = path.join(os.homedir(), ".knowledge", ".qwen");
-    const candidates = [
-        override,
-        envSource,
-        baseFromMeta ? path.join(baseFromMeta, "tmp", hash) : undefined,
-        path.join(cwd, ".qwen", "tmp", hash),
-        path.join(cwd, ".knowledge", ".qwen", "tmp", hash),
-        metaKnowledge ? path.join(metaKnowledge, "tmp", hash) : undefined,
-        path.join(homeBase, "tmp", hash),
-        path.join(homeKnowledge, "tmp", hash),
-    ].filter((candidate) => candidate !== undefined);
-    const found = candidates.find((candidate) => fs.existsSync(candidate));
-    if (found === undefined) {
-        return yield* _(Effect.fail(syncError(".qwen", `Qwen source directory is missing for hash ${hash}`)));
-    }
-    return found;
-});
-export const syncQwen = (options) => runSyncSource(qwenSource, options);
-const qwenSource = {
-    name: "Qwen",
-    destSubdir: ".qwen",
-    resolveSource: (options) => resolveQwenSourceDir(options.cwd, options.qwenSourceDir, options.metaRoot),
-    copy: (sourceDir, destinationDir) => copyFilteredFiles(sourceDir, destinationDir, (entry, fullPath) => entry.isFile() && fullPath.endsWith(".json"), "Cannot traverse Qwen directory"),
-};

package/dist/shell/syncKnowledge.js

@@ -1,39 +0,0 @@
-#!/usr/bin/env node
-import { Effect } from "effect";
-import { syncClaude } from "./claudeSync.js";
-import { syncCodex } from "./codexSync.js";
-import { syncQwen } from "./qwenSync.js";
-// PURPOSE: Sync project-scoped dialogs (Codex + Qwen) into .knowledge storage.
-export const buildSyncProgram = (options) => Effect.gen(function* (_) {
-    yield* _(syncClaude(options));
-    yield* _(syncCodex(options));
-    yield* _(syncQwen(options));
-});
-export const parseArgs = () => {
-    const argv = process.argv.slice(2);
-    let result = { cwd: process.cwd() };
-    const mapping = {
-        "--source": "sourceDir",
-        "-s": "sourceDir",
-        "--dest": "destinationDir",
-        "-d": "destinationDir",
-        "--project-url": "repositoryUrlOverride",
-        "--project-name": "repositoryUrlOverride",
-        "--meta-root": "metaRoot",
-        "--qwen-source": "qwenSourceDir",
-        "--claude-projects": "claudeProjectsRoot",
-    };
-    for (let i = 0; i < argv.length; i++) {
-        const arg = argv[i];
-        const key = mapping[arg];
-        if (key === undefined) {
-            continue;
-        }
-        const value = argv[i + 1];
-        if (value !== undefined) {
-            result = { ...result, [key]: value };
-            i++;
-        }
-    }
-    return result;
-};

package/dist/shell/syncShared.js

@@ -1,49 +0,0 @@
-import fs from "node:fs";
-import path from "node:path";
-import { Console, Effect } from "effect";
-import { pipe } from "effect/Function";
-export const syncError = (pathValue, reason) => ({
-    _tag: "SyncError",
-    path: pathValue,
-    reason,
-});
-export const ensureDirectory = (directory) => Effect.try({
-    try: () => {
-        fs.mkdirSync(directory, { recursive: true });
-    },
-    catch: () => syncError(directory, "Cannot create destination directory structure"),
-});
-export const runSyncSource = (source, options) => pipe(Effect.gen(function* (_) {
-    const resolvedSource = yield* _(source.resolveSource(options));
-    const destination = path.join(options.cwd, ".knowledge", source.destSubdir);
-    if (path.resolve(resolvedSource) === path.resolve(destination)) {
-        yield* _(Console.log(`${source.name}: source equals destination; skipping copy to avoid duplicates`));
-        return;
-    }
-    yield* _(ensureDirectory(destination));
-    const copied = yield* _(source.copy(resolvedSource, destination, options));
-    yield* _(Console.log(`${source.name}: copied ${copied} files from ${resolvedSource} to ${destination}`));
-}), Effect.catchAll((error) => Console.log(`${source.name}: source not found; skipped syncing (${error.reason})`)));
-export const copyFilteredFiles = (sourceRoot, destinationRoot, isRelevant, errorReason) => Effect.try({
-    try: () => {
-        let copied = 0;
-        const walk = (current) => {
-            const entries = fs.readdirSync(current, { withFileTypes: true });
-            for (const entry of entries) {
-                const full = path.join(current, entry.name);
-                if (entry.isDirectory()) {
-                    walk(full);
-                }
-                else if (isRelevant(entry, full)) {
-                    const target = path.join(destinationRoot, path.relative(sourceRoot, full));
-                    fs.mkdirSync(path.dirname(target), { recursive: true });
-                    fs.copyFileSync(full, target);
-                    copied += 1;
-                }
-            }
-        };
-        walk(sourceRoot);
-        return copied;
-    },
-    catch: () => syncError(sourceRoot, errorReason),
-});

package/dist/shell/syncTypes.js

@@ -1 +0,0 @@
-export {};

package/src/core/greeting.ts

@@ -1,39 +0,0 @@
-import { Option } from "effect";
-
-export interface AppProfile {
-	readonly name: string;
-	readonly mission: string;
-}
-
-export interface Greeting {
-	readonly message: string;
-}
-
-const normalize = (value: string): string => value.trim();
-
-const isNonEmpty = (value: string): boolean => value.length > 0;
-
-/**
- * CHANGE: Introduce pure greeting synthesis for console entrypoint
- * WHY: Provide mathematically checkable construction of startup banner without side effects
- * QUOTE(ТЗ): "Каждая функция — это теорема."
- * REF: REQ-GREETING-CORE
- * SOURCE: AGENTS.md – функциональное ядро без побочных эффектов
- * FORMAT THEOREM: ∀p ∈ AppProfile: valid(p) → nonEmpty(buildGreeting(p).message)
- * PURITY: CORE
- * EFFECT: None (pure)
- * INVARIANT: output.message.length > 0 when Option is Some
- * COMPLEXITY: O(1)/O(1)
- */
-export const buildGreeting = (profile: AppProfile): Option.Option<Greeting> => {
-	const trimmedName = normalize(profile.name);
-	const trimmedMission = normalize(profile.mission);
-
-	if (!isNonEmpty(trimmedName) || !isNonEmpty(trimmedMission)) {
-		return Option.none();
-	}
-
-	return Option.some({
-		message: `${trimmedName}: ${trimmedMission}`,
-	});
-};

package/src/main.ts

@@ -1,49 +0,0 @@
-import { Console, Effect, Option, pipe } from "effect";
-import { match } from "ts-pattern";
-import type { AppProfile } from "./core/greeting.js";
-import { buildGreeting } from "./core/greeting.js";
-
-interface StartupError {
-	readonly _tag: "StartupError";
-	readonly reason: string;
-}
-
-const appProfile: AppProfile = {
-	name: "Context Console",
-	mission: "Functional core ready for verifiable effects",
-};
-
-const toStartupError = (reason: string): StartupError => ({
-	_tag: "StartupError",
-	reason,
-});
-
-/**
- * CHANGE: Compose shell-level startup program around pure greeting builder
- * WHY: Isolate side effects (console IO) while delegating computation to functional core
- * QUOTE(ТЗ): "FUNCTIONAL CORE, IMPERATIVE SHELL"
- * REF: REQ-SHELL-STARTUP
- * SOURCE: AGENTS.md — эффекты только в SHELL
- * FORMAT THEOREM: ∀profile: valid(profile) → logs(buildGreeting(profile))
- * PURITY: SHELL
- * EFFECT: Effect<void, StartupError, Console>
- * INVARIANT: Console side-effects occur once and only after successful greeting synthesis
- * COMPLEXITY: O(1)/O(1)
- */
-const program = pipe(
-	Effect.succeed(buildGreeting(appProfile)),
-	Effect.filterOrFail(Option.isSome, () =>
-		toStartupError("Profile must not be empty"),
-	),
-	Effect.map((option) => option.value),
-	Effect.flatMap((greeting) => Console.log(greeting.message)),
-	Effect.catchAll((error) =>
-		match(error)
-			.with({ _tag: "StartupError" }, (startupError) =>
-				Console.error(`StartupError: ${startupError.reason}`),
-			)
-			.exhaustive(),
-	),
-);
-
-Effect.runSync(program);

package/src/shell/claudeSync.ts

@@ -1,55 +0,0 @@
-import * as NodeFs from "node:fs";
-import * as NodeOs from "node:os";
-import * as NodePath from "node:path";
-import { Effect, pipe } from "effect";
-import { copyFilteredFiles, runSyncSource, syncError } from "./syncShared.js";
-import type { SyncError, SyncOptions, SyncSource } from "./syncTypes.js";
-
-const slugFromCwd = (cwd: string): string =>
-	`-${cwd.replace(/^\/+/, "").replace(/\//g, "-")}`;
-
-const resolveClaudeProjectDir = (
-	cwd: string,
-	overrideProjectsRoot?: string,
-): Effect.Effect<string, SyncError> =>
-	pipe(
-		Effect.sync(() => {
-			const slug = slugFromCwd(cwd);
-			const base =
-				overrideProjectsRoot ??
-				NodePath.join(NodeOs.homedir(), ".claude", "projects");
-			const candidate = NodePath.join(base, slug);
-			return NodeFs.existsSync(candidate) ? candidate : undefined;
-		}),
-		Effect.flatMap((found) =>
-			found === undefined
-				? Effect.fail(
-						syncError(".claude", "Claude project directory is missing"),
-					)
-				: Effect.succeed(found),
-		),
-	);
-
-const copyClaudeJsonl = (
-	sourceDir: string,
-	destinationDir: string,
-): Effect.Effect<number, SyncError> =>
-	copyFilteredFiles(
-		sourceDir,
-		destinationDir,
-		(entry, fullPath) => entry.isFile() && fullPath.endsWith(".jsonl"),
-		"Cannot traverse Claude project",
-	);
-
-export const syncClaude = (
-	options: SyncOptions,
-): Effect.Effect<void, SyncError> => runSyncSource(claudeSource, options);
-
-const claudeSource: SyncSource = {
-	name: "Claude",
-	destSubdir: ".claude",
-	resolveSource: (options) =>
-		resolveClaudeProjectDir(options.cwd, options.claudeProjectsRoot),
-	copy: (sourceDir, destinationDir) =>
-		copyClaudeJsonl(sourceDir, destinationDir),
-};

package/src/shell/codexSync.ts

@@ -1,236 +0,0 @@
-import fs from "node:fs";
-import os from "node:os";
-import path from "node:path";
-import * as S from "@effect/schema/Schema";
-import { Console, Effect, pipe } from "effect";
-import type { ProjectLocator } from "../core/knowledge.js";
-import { buildProjectLocator, linesMatchProject } from "../core/knowledge.js";
-import { ensureDirectory, syncError } from "./syncShared.js";
-import type { SyncError, SyncOptions } from "./syncTypes.js";
-
-const PackageRepositorySchema = S.Struct({
-	url: S.String,
-});
-
-const PackageFileSchema = S.Struct({
-	repository: S.optional(PackageRepositorySchema),
-});
-const PackageFileFromJson = S.compose(S.parseJson(), PackageFileSchema);
-const decodePackageFile = S.decodeUnknownSync(PackageFileFromJson);
-
-const readRepositoryUrl = (
-	cwd: string,
-	repositoryUrlOverride?: string,
-): Effect.Effect<string, SyncError> =>
-	Effect.try({
-		try: () => {
-			if (repositoryUrlOverride !== undefined) {
-				return repositoryUrlOverride;
-			}
-
-			const raw = fs.readFileSync(path.join(cwd, "package.json"), "utf8");
-			const parsed = decodePackageFile(raw);
-			const repositoryUrl = parsed.repository?.url;
-
-			if (repositoryUrl === undefined) {
-				throw new Error("repository url is missing");
-			}
-
-			return repositoryUrl;
-		},
-		catch: () => syncError("package.json", "Cannot read repository url"),
-	});
-
-const resolveSourceDir = (
-	cwd: string,
-	override?: string,
-	metaRoot?: string,
-): Effect.Effect<string, SyncError> =>
-	pipe(
-		Effect.sync(() => {
-			const envSource = process.env.CODEX_SOURCE_DIR;
-			const metaCandidate =
-				metaRoot === undefined
-					? undefined
-					: metaRoot.endsWith(".codex")
-						? metaRoot
-						: path.join(metaRoot, ".codex");
-			const localSource = path.join(cwd, ".codex");
-			const homeSource = path.join(os.homedir(), ".codex");
-			const localKnowledge = path.join(cwd, ".knowledge", ".codex");
-			const homeKnowledge = path.join(os.homedir(), ".knowledge", ".codex");
-
-			const candidates = [
-				override,
-				envSource,
-				metaCandidate,
-				localSource,
-				homeSource,
-				localKnowledge,
-				homeKnowledge,
-			].filter((candidate): candidate is string => candidate !== undefined);
-
-			const existing = candidates.find((candidate) => fs.existsSync(candidate));
-
-			return { existing, candidates };
-		}),
-		Effect.flatMap(({ existing, candidates }) =>
-			existing === undefined
-				? Effect.fail(
-						syncError(
-							".codex",
-							`Source .codex directory is missing; checked: ${candidates.join(", ")}`,
-						),
-					)
-				: Effect.succeed(existing),
-		),
-	);
-
-const collectJsonlFiles = (
-	root: string,
-): Effect.Effect<ReadonlyArray<string>, SyncError> =>
-	Effect.try({
-		try: () => {
-			const collected: string[] = [];
-			const walk = (current: string): void => {
-				const entries = fs.readdirSync(current, { withFileTypes: true });
-				for (const entry of entries) {
-					const fullPath = path.join(current, entry.name);
-					if (entry.isDirectory()) {
-						walk(fullPath);
-					} else if (entry.isFile() && entry.name.endsWith(".jsonl")) {
-						collected.push(fullPath);
-					}
-				}
-			};
-
-			walk(root);
-			return collected;
-		},
-		catch: () => syncError(root, "Cannot traverse .codex"),
-	});
-
-const isFileRelevant = (
-	filePath: string,
-	locator: ProjectLocator,
-): Effect.Effect<boolean, SyncError> =>
-	Effect.try({
-		try: () => {
-			const content = fs.readFileSync(filePath, "utf8");
-			const lines = content.split("\n");
-			return linesMatchProject(lines, locator);
-		},
-		catch: () => syncError(filePath, "Cannot read jsonl file"),
-	});
-
-const copyRelevantFile = (
-	sourceRoot: string,
-	destinationRoot: string,
-	filePath: string,
-): Effect.Effect<void, SyncError> =>
-	Effect.try({
-		try: () => {
-			const relative = path.relative(sourceRoot, filePath);
-			const targetPath = path.join(destinationRoot, relative);
-			fs.mkdirSync(path.dirname(targetPath), { recursive: true });
-			fs.copyFileSync(filePath, targetPath);
-		},
-		catch: () => syncError(filePath, "Cannot copy file into .knowledge/.codex"),
-	});
-
-const selectRelevantFiles = (
-	files: ReadonlyArray<string>,
-	locator: ProjectLocator,
-): Effect.Effect<ReadonlyArray<string>, SyncError> =>
-	Effect.reduce(files, [] as string[], (acc, filePath) =>
-		pipe(
-			isFileRelevant(filePath, locator),
-			Effect.map((isRelevant) => {
-				if (isRelevant) {
-					acc.push(filePath);
-				}
-
-				return acc;
-			}),
-		),
-	);
-
-const resolveLocator = (
-	options: SyncOptions,
-): Effect.Effect<ProjectLocator, SyncError> =>
-	pipe(
-		readRepositoryUrl(options.cwd, options.repositoryUrlOverride),
-		Effect.map((repositoryUrl) =>
-			buildProjectLocator(repositoryUrl, options.cwd),
-		),
-		Effect.catchAll(() =>
-			Effect.gen(function* (__) {
-				yield* __(
-					Console.log(
-						"Codex repository url missing; falling back to cwd-only match",
-					),
-				);
-				return buildProjectLocator(options.cwd, options.cwd);
-			}),
-		),
-	);
-
-const copyCodexFiles = (
-	sourceDir: string,
-	destinationDir: string,
-	locator: ProjectLocator,
-): Effect.Effect<void, SyncError> =>
-	Effect.gen(function* (_) {
-		yield* _(ensureDirectory(destinationDir));
-		const allJsonlFiles = yield* _(collectJsonlFiles(sourceDir));
-		const relevantFiles = yield* _(selectRelevantFiles(allJsonlFiles, locator));
-		yield* _(
-			Effect.forEach(relevantFiles, (filePath) =>
-				copyRelevantFile(sourceDir, destinationDir, filePath),
-			),
-		);
-		yield* _(
-			Console.log(
-				`Codex: copied ${relevantFiles.length} files from ${sourceDir} to ${destinationDir}`,
-			),
-		);
-	});
-
-// CHANGE: Extract Codex dialog sync into dedicated module for clarity.
-// WHY: Separate Codex-specific shell effects from other sync flows.
-// QUOTE(ТЗ): "вынеси в отдельный файл"
-// REF: user request 2025-11-26
-// SOURCE: internal requirement
-// FORMAT THEOREM: ∀f ∈ Files: relevant(f, locator) → copied(f, destination)
-// PURITY: SHELL
-// EFFECT: Effect<void, SyncError, never>
-// INVARIANT: ∀f ∈ copiedFiles: linesMatchProject(f, locator)
-// COMPLEXITY: O(n) time / O(n) space, n = |files|
-export const syncCodex = (
-	options: SyncOptions,
-): Effect.Effect<void, SyncError> =>
-	Effect.gen(function* (_) {
-		const locator = yield* _(resolveLocator(options));
-		const sourceDir = yield* _(
-			resolveSourceDir(options.cwd, options.sourceDir, options.metaRoot),
-		);
-		const destinationDir =
-			options.destinationDir ?? path.join(options.cwd, ".knowledge", ".codex");
-
-		if (path.resolve(sourceDir) === path.resolve(destinationDir)) {
-			yield* _(
-				Console.log(
-					"Codex source equals destination; skipping copy to avoid duplicates",
-				),
-			);
-			return;
-		}
-
-		yield* _(copyCodexFiles(sourceDir, destinationDir, locator));
-	}).pipe(
-		Effect.catchAll((error) =>
-			Console.log(
-				`Codex source not found; skipped syncing Codex dialog files (${error.reason})`,
-			),
-		),
-	);