@prover-coder-ai/context-doc 1.0.18 → 1.0.19

package/src/shell/services/runtime-env.ts

@@ -1,54 +0,0 @@
-import { Context, Effect, Layer, Option } from "effect"
-
-export class RuntimeEnv extends Context.Tag("RuntimeEnv")<
-  RuntimeEnv,
-  {
-    readonly argv: Effect.Effect<ReadonlyArray<string>>
-    readonly cwd: Effect.Effect<string>
-    readonly homedir: Effect.Effect<string>
-    readonly envVar: (key: string) => Effect.Effect<Option.Option<string>>
-  }
->() {}
-
-const readProcess = (): NodeJS.Process | undefined => typeof process === "undefined" ? undefined : process
-
-const readEnv = (): NodeJS.ProcessEnv => readProcess()?.env ?? {}
-
-const resolveHomeDir = (env: NodeJS.ProcessEnv, cwdFallback: string): string => {
-  const direct = env["HOME"] ?? env["USERPROFILE"]
-  if (direct !== undefined) {
-    return direct
-  }
-
-  const drive = env["HOMEDRIVE"]
-  const path = env["HOMEPATH"]
-  if (drive !== undefined && path !== undefined) {
-    return `${drive}${path}`
-  }
-
-  return cwdFallback
-}
-
-// CHANGE: wrap process/os access behind a typed Effect service
-// WHY: keep shell dependencies injectable and testable
-// QUOTE(TZ): "Внешние зависимости: только через типизированные интерфейсы"
-// REF: user-2026-01-19-sync-rewrite
-// SOURCE: n/a
-// FORMAT THEOREM: forall k: env(k) -> Option<string>
-// PURITY: SHELL
-// EFFECT: Effect<RuntimeEnv, never, never>
-// INVARIANT: argv/cwd/homedir are read once per effect
-// COMPLEXITY: O(1)/O(1)
-export const RuntimeEnvLive = Layer.succeed(RuntimeEnv, {
-  argv: Effect.sync(() => {
-    const proc = readProcess()
-    return proc === undefined ? [] : [...proc.argv]
-  }),
-  cwd: Effect.sync(() => readProcess()?.cwd() ?? "."),
-  homedir: Effect.sync(() => {
-    const proc = readProcess()
-    const cwdFallback = proc?.cwd() ?? "."
-    return resolveHomeDir(readEnv(), cwdFallback)
-  }),
-  envVar: (key) => Effect.sync(() => Option.fromNullable(readEnv()[key]))
-})

package/src/shell/sync/index.ts

@@ -1,35 +0,0 @@
-import type * as Path from "@effect/platform/Path"
-import { Effect } from "effect"
-
-import type { CryptoService } from "../services/crypto.js"
-import type { FileSystemService } from "../services/file-system.js"
-import type { RuntimeEnv } from "../services/runtime-env.js"
-import { syncClaude } from "./sources/claude.js"
-import { syncCodex } from "./sources/codex.js"
-import { syncQwen } from "./sources/qwen.js"
-import type { SyncOptions } from "./types.js"
-
-type SyncProgramEnv = RuntimeEnv | FileSystemService | CryptoService | Path.Path
-
-// CHANGE: compose multi-source sync into a single Effect program
-// WHY: centralize orchestration while keeping each source isolated
-// QUOTE(TZ): "монодическая композиция"
-// REF: user-2026-01-19-sync-rewrite
-// SOURCE: n/a
-// FORMAT THEOREM: forall s in Sources: run(s) -> synced(s)
-// PURITY: SHELL
-// EFFECT: Effect<void, never, FileSystemService | RuntimeEnv | CryptoService | Path>
-// INVARIANT: sources run sequentially in fixed order
-// COMPLEXITY: O(n)/O(n)
-export const buildSyncProgram = (
-  options: SyncOptions
-): Effect.Effect<
-  void,
-  never,
-  SyncProgramEnv
-> =>
-  Effect.gen(function*(_) {
-    yield* _(syncClaude(options))
-    yield* _(syncCodex(options))
-    yield* _(syncQwen(options))
-  })

package/src/shell/sync/shared.ts

@@ -1,229 +0,0 @@
-import * as Path from "@effect/platform/Path"
-import { Console, Effect, Match, pipe } from "effect"
-
-import { type DirectoryEntry, FileSystemService } from "../services/file-system.js"
-import { type SyncError, syncError, type SyncOptions, type SyncSource } from "./types.js"
-
-const forEach = Effect.forEach
-
-type FilteredSourceEnv<R> = R | FileSystemService | Path.Path
-
-const ensureDirectory = (
-  directory: string
-): Effect.Effect<void, SyncError, FileSystemService> =>
-  Effect.gen(function*(_) {
-    const fs = yield* _(FileSystemService)
-    yield* _(fs.makeDirectory(directory))
-  })
-
-// CHANGE: expose recursive traversal for callers that filter by entry
-// WHY: reuse traversal logic across sources without duplicating Match logic
-// QUOTE(TZ): "минимальный корректный diff"
-// REF: user-2026-01-19-sync-rewrite
-// SOURCE: n/a
-// FORMAT THEOREM: forall f: collectFiles(root, p) -> p(f) => exists(f)
-// PURITY: SHELL
-// EFFECT: Effect<ReadonlyArray<string>, SyncError, FileSystemService>
-// INVARIANT: returned paths are absolute and exist in traversal
-// COMPLEXITY: O(n)/O(n)
-export const collectFiles = (
-  root: string,
-  isRelevant: (entry: DirectoryEntry) => boolean
-): Effect.Effect<ReadonlyArray<string>, SyncError, FileSystemService> =>
-  Effect.gen(function*(_) {
-    const fs = yield* _(FileSystemService)
-    const entries = yield* _(fs.readDirectory(root))
-    const chunks = yield* _(
-      forEach(entries, (entry) =>
-        Match.value(entry.kind).pipe(
-          Match.when("directory", () => collectFiles(entry.path, isRelevant)),
-          Match.when("file", () => isRelevant(entry) ? Effect.succeed([entry.path]) : Effect.succeed([])),
-          Match.when("other", () => Effect.succeed([])),
-          Match.exhaustive
-        ))
-    )
-    return chunks.flat()
-  })
-
-// CHANGE: share relative path copy for multiple sync sources
-// WHY: avoid repeating path math in each source
-// QUOTE(TZ): "SHELL → CORE (but not наоборот)"
-// REF: user-2026-01-19-sync-rewrite
-// SOURCE: n/a
-// FORMAT THEOREM: forall f: copy(f) -> relative(f) preserved
-// PURITY: SHELL
-// EFFECT: Effect<void, SyncError, FileSystemService | Path>
-// INVARIANT: destination preserves source-relative path
-// COMPLEXITY: O(1)/O(1)
-export const copyFilePreservingRelativePath = (
-  sourceRoot: string,
-  destinationRoot: string,
-  filePath: string
-): Effect.Effect<void, SyncError, FileSystemService | Path.Path> =>
-  Effect.gen(function*(_) {
-    const fs = yield* _(FileSystemService)
-    const path = yield* _(Path.Path)
-    const relative = path.relative(sourceRoot, filePath)
-    const targetPath = path.join(destinationRoot, relative)
-    yield* _(fs.makeDirectory(path.dirname(targetPath)))
-    yield* _(fs.copyFile(filePath, targetPath))
-  })
-
-// CHANGE: expose reusable first-match search with effectful predicate
-// WHY: remove duplicated recursive search logic across sources
-// QUOTE(TZ): "минимальный корректный diff"
-// REF: user-2026-01-19-sync-rewrite
-// SOURCE: n/a
-// FORMAT THEOREM: forall c: match(c) -> returns first c
-// PURITY: SHELL
-// EFFECT: Effect<string | undefined, SyncError, R>
-// INVARIANT: result is undefined iff no candidate matches
-// COMPLEXITY: O(n)/O(1)
-export const findFirstMatching = <R>(
-  candidates: ReadonlyArray<string>,
-  matches: (candidate: string) => Effect.Effect<boolean, SyncError, R>
-): Effect.Effect<string | undefined, SyncError, R> => {
-  const loop = (
-    remaining: ReadonlyArray<string>
-  ): Effect.Effect<string | undefined, SyncError, R> =>
-    Effect.gen(function*(_) {
-      const [candidate, ...rest] = remaining
-      if (candidate === undefined) {
-        return
-      }
-      const matched = yield* _(matches(candidate))
-      if (!matched) {
-        return yield* _(loop(rest))
-      }
-      return candidate
-    })
-
-  return loop(candidates)
-}
-
-// CHANGE: ensure destination directory is created through Effect-typed fs
-// WHY: keep IO effects inside SHELL and reuse in sync flows
-// QUOTE(TZ): "SHELL: Все эффекты изолированы в тонкой оболочке"
-// REF: user-2026-01-19-sync-rewrite
-// SOURCE: n/a
-// FORMAT THEOREM: forall d: ensureDirectory(d) -> exists(d)
-// PURITY: SHELL
-// EFFECT: Effect<void, SyncError, FileSystemService>
-// INVARIANT: directory exists after successful effect
-// COMPLEXITY: O(1)/O(1)
-export const ensureDestination = ensureDirectory
-
-// CHANGE: resolve project root for cwd-based matching and destination paths
-// WHY: allow running from sub-packages while targeting the repo root
-// QUOTE(TZ): "передай root-path на основную папку"
-// REF: user-2026-01-19-project-root
-// SOURCE: n/a
-// FORMAT THEOREM: forall o: root(o) = resolve(o.projectRoot ?? o.cwd)
-// PURITY: SHELL
-// EFFECT: n/a
-// INVARIANT: resolved root is absolute
-// COMPLEXITY: O(1)/O(1)
-export const resolveProjectRoot = (
-  path: Path.Path,
-  options: SyncOptions
-): string => path.resolve(options.projectRoot ?? options.cwd)
-
-// CHANGE: copy filtered files with typed errors and deterministic traversal
-// WHY: reuse shared traversal logic for Qwen/Claude syncs
-// QUOTE(TZ): "FUNCTIONAL CORE, IMPERATIVE SHELL"
-// REF: user-2026-01-19-sync-rewrite
-// SOURCE: n/a
-// FORMAT THEOREM: forall f: relevant(f) -> copied(f)
-// PURITY: SHELL
-// EFFECT: Effect<number, SyncError, FileSystemService | Path>
-// INVARIANT: copied count equals length of relevant files
-// COMPLEXITY: O(n)/O(n)
-export const copyFilteredFiles = (
-  sourceRoot: string,
-  destinationRoot: string,
-  isRelevant: (entry: DirectoryEntry, fullPath: string) => boolean,
-  errorReason: string
-): Effect.Effect<number, SyncError, FileSystemService | Path.Path> =>
-  pipe(
-    Effect.gen(function*(_) {
-      const files = yield* _(collectFiles(sourceRoot, (entry) => isRelevant(entry, entry.path)))
-      yield* _(
-        forEach(files, (filePath) => copyFilePreservingRelativePath(sourceRoot, destinationRoot, filePath))
-      )
-      return files.length
-    }),
-    Effect.mapError(() => syncError(sourceRoot, errorReason))
-  )
-
-// CHANGE: build a SyncSource using shared filtered copy logic
-// WHY: eliminate repeated source definitions for file-extension based syncs
-// QUOTE(TZ): "минимальный корректный diff"
-// REF: user-2026-01-19-sync-rewrite
-// SOURCE: n/a
-// FORMAT THEOREM: forall s: createFilteredSource(s) -> copyFilteredFiles(s)
-// PURITY: SHELL
-// EFFECT: Effect<number, SyncError, R>
-// INVARIANT: copy uses shared filter predicate
-// COMPLEXITY: O(n)/O(n)
-export const createFilteredSource = <R>(params: {
-  readonly name: SyncSource<FilteredSourceEnv<R>>["name"]
-  readonly destSubdir: SyncSource<FilteredSourceEnv<R>>["destSubdir"]
-  readonly resolveSource: SyncSource<FilteredSourceEnv<R>>["resolveSource"]
-  readonly filter: (entry: DirectoryEntry, fullPath: string) => boolean
-  readonly errorReason: string
-}): SyncSource<FilteredSourceEnv<R>> => ({
-  name: params.name,
-  destSubdir: params.destSubdir,
-  resolveSource: params.resolveSource,
-  copy: (sourceDir, destinationDir) => copyFilteredFiles(sourceDir, destinationDir, params.filter, params.errorReason)
-})
-
-// CHANGE: standardize per-source sync orchestration with skip-on-error logging
-// WHY: keep the shell thin and consistent for all sources
-// QUOTE(TZ): "SHELL → CORE (but not наоборот)"
-// REF: user-2026-01-19-sync-rewrite
-// SOURCE: n/a
-// FORMAT THEOREM: forall s: runSyncSource(s) -> logs(s)
-// PURITY: SHELL
-// EFFECT: Effect<void, never, FileSystemService | Path>
-// INVARIANT: source==destination implies no copy
-// COMPLEXITY: O(n)/O(n)
-export const runSyncSource = <R>(
-  source: SyncSource<R>,
-  options: SyncOptions
-): Effect.Effect<void, never, R | FileSystemService | Path.Path> =>
-  pipe(
-    Effect.gen(function*(_) {
-      const path = yield* _(Path.Path)
-      const resolvedSource = yield* _(source.resolveSource(options))
-      const destination = path.join(
-        resolveProjectRoot(path, options),
-        ".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.matchEffect({
-      onFailure: (error: SyncError) =>
-        Console.log(
-          `${source.name}: source not found; skipped syncing (${error.reason})`
-        ),
-      onSuccess: () => Effect.void
-    })
-  )

package/src/shell/sync/sources/claude.ts

@@ -1,54 +0,0 @@
-import * as Path from "@effect/platform/Path"
-import { Effect } from "effect"
-
-import { FileSystemService } from "../../services/file-system.js"
-import { RuntimeEnv } from "../../services/runtime-env.js"
-import { createFilteredSource, resolveProjectRoot, runSyncSource } from "../shared.js"
-import { type SyncError, syncError, type SyncOptions, type SyncSource } from "../types.js"
-
-type ClaudeEnv = RuntimeEnv | FileSystemService | Path.Path
-
-const slugFromCwd = (cwd: string): string => `-${cwd.replace(/^\/+/, "").replaceAll("\\", "-").replaceAll("/", "-")}`
-
-const resolveClaudeProjectDir = (
-  options: SyncOptions
-): Effect.Effect<string, SyncError, ClaudeEnv> =>
-  Effect.gen(function*(_) {
-    const env = yield* _(RuntimeEnv)
-    const homeDir = yield* _(env.homedir)
-    const path = yield* _(Path.Path)
-    const base = options.claudeProjectsRoot ??
-      path.join(homeDir, ".claude", "projects")
-    const candidate = path.join(base, slugFromCwd(resolveProjectRoot(path, options)))
-    const fs = yield* _(FileSystemService)
-    const exists = yield* _(fs.exists(candidate))
-    if (!exists) {
-      return yield* _(
-        Effect.fail(syncError(".claude", "Claude project directory is missing"))
-      )
-    }
-
-    return candidate
-  })
-
-const claudeSource: SyncSource<ClaudeEnv> = createFilteredSource({
-  name: "Claude",
-  destSubdir: ".claude",
-  resolveSource: resolveClaudeProjectDir,
-  filter: (entry, fullPath) => entry.kind === "file" && fullPath.endsWith(".jsonl"),
-  errorReason: "Cannot traverse Claude project"
-})
-
-// CHANGE: sync Claude dialog files through shared sync runner
-// WHY: keep Claude-specific path resolution isolated from other sources
-// QUOTE(TZ): "SHELL: Все эффекты (IO, сеть, БД, env/process) изолированы"
-// REF: user-2026-01-19-sync-rewrite
-// SOURCE: n/a
-// FORMAT THEOREM: forall f: jsonl(f) -> copied(f)
-// PURITY: SHELL
-// EFFECT: Effect<void, never, FileSystemService | RuntimeEnv | Path>
-// INVARIANT: only .jsonl files are copied
-// COMPLEXITY: O(n)/O(n)
-export const syncClaude = (
-  options: SyncOptions
-): Effect.Effect<void, never, ClaudeEnv> => runSyncSource(claudeSource, options)

package/src/shell/sync/sources/codex.ts

@@ -1,261 +0,0 @@
-import * as Path from "@effect/platform/Path"
-import * as Schema from "@effect/schema/Schema"
-import { Console, Effect, Option, pipe } from "effect"
-
-import type { JsonValue, ProjectLocator } from "../../../core/knowledge.js"
-import { buildProjectLocator, valueMatchesProject } from "../../../core/knowledge.js"
-import { FileSystemService } from "../../services/file-system.js"
-import { RuntimeEnv } from "../../services/runtime-env.js"
-import {
-  collectFiles,
-  copyFilePreservingRelativePath,
-  ensureDestination,
-  findFirstMatching,
-  resolveProjectRoot
-} from "../shared.js"
-import { type SyncError, syncError, type SyncOptions } from "../types.js"
-
-type CodexEnv = RuntimeEnv | FileSystemService | Path.Path
-type CodexFsEnv = FileSystemService | Path.Path
-
-const some = Option.some
-const forEach = Effect.forEach
-
-const JsonValueSchema: Schema.Schema<JsonValue> = Schema.suspend(() =>
-  Schema.Union(
-    Schema.String,
-    Schema.Number,
-    Schema.Boolean,
-    Schema.Null,
-    Schema.Array(JsonValueSchema),
-    Schema.Record({ key: Schema.String, value: JsonValueSchema })
-  )
-)
-
-const parseJsonLine = (
-  line: string
-): Effect.Effect<Option.Option<JsonValue>> =>
-  pipe(
-    Schema.decode(Schema.parseJson(JsonValueSchema))(line),
-    Effect.match({
-      onFailure: () => Option.none(),
-      onSuccess: (value) => some(value)
-    })
-  )
-
-const resolveEnvValue = (envValue: Option.Option<string>): string | undefined => Option.getOrUndefined(envValue)
-
-const buildLocator = (path: Path.Path, projectRoot: string): ProjectLocator => {
-  const normalizedRoot = path.resolve(projectRoot)
-  const isWithinRoot = (candidate: string): boolean => {
-    const normalizedCandidate = path.resolve(candidate)
-    const relative = path.relative(normalizedRoot, normalizedCandidate)
-    return relative === "" || (!relative.startsWith("..") && !path.isAbsolute(relative))
-  }
-  return buildProjectLocator(normalizedRoot, isWithinRoot)
-}
-
-const containsJsonl = (root: string): Effect.Effect<boolean, SyncError, FileSystemService> =>
-  Effect.gen(function*(_) {
-    const fs = yield* _(FileSystemService)
-    const entries = yield* _(fs.readDirectory(root))
-    for (const entry of entries) {
-      if (entry.kind === "file" && entry.path.endsWith(".jsonl")) {
-        return true
-      }
-      if (entry.kind === "directory") {
-        const found = yield* _(containsJsonl(entry.path))
-        if (found) {
-          return true
-        }
-      }
-    }
-    return false
-  })
-
-const hasJsonlInCandidate = (
-  candidate: string
-): Effect.Effect<boolean, SyncError, FileSystemService> =>
-  Effect.gen(function*(_) {
-    const fs = yield* _(FileSystemService)
-    const exists = yield* _(fs.exists(candidate))
-    if (!exists) {
-      return false
-    }
-    return yield* _(containsJsonl(candidate))
-  })
-
-const findFirstExistingWithJsonl = (
-  candidates: ReadonlyArray<string>
-): Effect.Effect<string | undefined, SyncError, FileSystemService> => findFirstMatching(candidates, hasJsonlInCandidate)
-
-const resolveSourceDir = (
-  options: SyncOptions
-): Effect.Effect<string, SyncError, CodexEnv> =>
-  Effect.gen(function*(_) {
-    const env = yield* _(RuntimeEnv)
-    const path = yield* _(Path.Path)
-    const envSource = resolveEnvValue(yield* _(env.envVar("CODEX_SOURCE_DIR")))
-    const homeDir = yield* _(env.homedir)
-    const projectRoot = resolveProjectRoot(path, options)
-    let metaCandidate: string | undefined
-    if (options.metaRoot !== undefined) {
-      metaCandidate = options.metaRoot.endsWith(".codex")
-        ? options.metaRoot
-        : path.join(options.metaRoot, ".codex")
-    }
-    const localSource = path.join(projectRoot, ".codex")
-    const localKnowledge = path.join(projectRoot, ".knowledge", ".codex")
-    const homeSource = path.join(homeDir, ".codex")
-    const homeKnowledge = path.join(homeDir, ".knowledge", ".codex")
-
-    const candidates = [
-      options.sourceDir,
-      envSource,
-      metaCandidate,
-      localSource,
-      homeSource,
-      localKnowledge,
-      homeKnowledge
-    ].filter((candidate): candidate is string => candidate !== undefined)
-
-    const existing = yield* _(findFirstExistingWithJsonl(candidates))
-    if (existing === undefined) {
-      return yield* _(
-        Effect.fail(
-          syncError(
-            ".codex",
-            `No .jsonl files found in .codex candidates; checked: ${candidates.join(", ")}`
-          )
-        )
-      )
-    }
-
-    return existing
-  })
-
-const resolveLocator = (
-  options: SyncOptions
-): Effect.Effect<ProjectLocator, never, Path.Path> =>
-  Effect.gen(function*(_) {
-    const path = yield* _(Path.Path)
-    const projectRoot = resolveProjectRoot(path, options)
-    return buildLocator(path, projectRoot)
-  })
-
-const lineMatchesProject = (
-  line: string,
-  locator: ProjectLocator
-): Effect.Effect<boolean> =>
-  pipe(
-    parseJsonLine(line),
-    Effect.map((parsed) => Option.exists(parsed, (value) => valueMatchesProject(value, locator)))
-  )
-
-const fileMatchesProject = (
-  filePath: string,
-  locator: ProjectLocator
-): Effect.Effect<boolean, SyncError, FileSystemService> =>
-  Effect.gen(function*(_) {
-    const fs = yield* _(FileSystemService)
-    const content = yield* _(fs.readFileString(filePath))
-    const lines = content.split("\n")
-    const matches = yield* _(
-      forEach(lines, (line) => {
-        const trimmed = line.trim()
-        return trimmed.length === 0
-          ? Effect.succeed(false)
-          : lineMatchesProject(trimmed, locator)
-      })
-    )
-    return matches.some(Boolean)
-  })
-
-const selectRelevantFiles = (
-  files: ReadonlyArray<string>,
-  locator: ProjectLocator
-): Effect.Effect<ReadonlyArray<string>, SyncError, FileSystemService> =>
-  pipe(
-    forEach(files, (filePath) =>
-      pipe(
-        fileMatchesProject(filePath, locator),
-        Effect.map((matches) => ({ filePath, matches }))
-      )),
-    Effect.map((results) =>
-      results
-        .filter((result) => result.matches)
-        .map((result) => result.filePath)
-    )
-  )
-
-const copyCodexFiles = (
-  sourceDir: string,
-  destinationDir: string,
-  locator: ProjectLocator
-): Effect.Effect<void, SyncError, CodexFsEnv> =>
-  Effect.gen(function*(_) {
-    yield* _(ensureDestination(destinationDir))
-    const allJsonlFiles = yield* _(
-      collectFiles(sourceDir, (entry) => entry.kind === "file" && entry.path.endsWith(".jsonl"))
-    )
-    const relevantFiles = yield* _(selectRelevantFiles(allJsonlFiles, locator))
-    yield* _(
-      forEach(relevantFiles, (filePath) => copyFilePreservingRelativePath(sourceDir, destinationDir, filePath))
-    )
-    yield* _(
-      Console.log(
-        `Codex: copied ${relevantFiles.length} files from ${sourceDir} to ${destinationDir}`
-      )
-    )
-  })
-
-// CHANGE: extract Codex dialog sync into dedicated module
-// WHY: keep Codex-specific shell effects isolated from other sources
-// QUOTE(TZ): "FUNCTIONAL CORE, IMPERATIVE SHELL"
-// REF: user-2026-01-19-sync-rewrite
-// SOURCE: n/a
-// FORMAT THEOREM: forall f: relevant(f, locator) -> copied(f)
-// PURITY: SHELL
-// EFFECT: Effect<void, never, FileSystemService | RuntimeEnv | Path>
-// INVARIANT: copied files contain at least one project-matching line by projectRoot
-// COMPLEXITY: O(n)/O(n)
-export const syncCodex = (
-  options: SyncOptions
-): Effect.Effect<void, never, CodexEnv> =>
-  Effect.gen(function*(_) {
-    const locator = yield* _(resolveLocator(options))
-    const sourceDir = yield* _(resolveSourceDir(options))
-    const path = yield* _(Path.Path)
-    const destinationDir = options.destinationDir ??
-      path.join(resolveProjectRoot(path, options), ".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.matchEffect({
-      onFailure: (error: SyncError) =>
-        Console.log(
-          `Codex source not found; skipped syncing Codex dialog files (${error.reason})`
-        ),
-      onSuccess: () => Effect.void
-    })
-  )
-
-// CHANGE: expose DirectoryEntry type for Codex traversal helpers
-// WHY: reuse typed filesystem entries without leaking Node types
-// QUOTE(TZ): "CORE never calls SHELL"
-// REF: user-2026-01-19-sync-rewrite
-// SOURCE: n/a
-// FORMAT THEOREM: forall e: DirectoryEntry -> shellOnly(e)
-// PURITY: SHELL
-// EFFECT: n/a
-// INVARIANT: entry.kind is one of file|directory|other
-// COMPLEXITY: O(1)/O(1)