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

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

@@ -0,0 +1,261 @@
+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)

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

@@ -0,0 +1,97 @@
+import * as Path from "@effect/platform/Path"
+import { Effect, Option, pipe } from "effect"
+
+import { CryptoService } from "../../services/crypto.js"
+import { FileSystemService } from "../../services/file-system.js"
+import { RuntimeEnv } from "../../services/runtime-env.js"
+import { createFilteredSource, findFirstMatching, resolveProjectRoot, runSyncSource } from "../shared.js"
+import { type SyncError, syncError, type SyncOptions, type SyncSource } from "../types.js"
+
+type QwenEnv = RuntimeEnv | CryptoService | FileSystemService | Path.Path
+
+const resolveEnvValue = (envValue: Option.Option<string>): string | undefined => Option.getOrUndefined(envValue)
+
+const findFirstExisting = (
+  candidates: ReadonlyArray<string>
+): Effect.Effect<string | undefined, SyncError, FileSystemService> =>
+  findFirstMatching(candidates, (candidate) =>
+    Effect.gen(function*(_) {
+      const fs = yield* _(FileSystemService)
+      return yield* _(fs.exists(candidate))
+    }))
+
+const resolveQwenSourceDir = (
+  options: SyncOptions
+): Effect.Effect<string, SyncError, QwenEnv> =>
+  Effect.gen(function*(_) {
+    const env = yield* _(RuntimeEnv)
+    const crypto = yield* _(CryptoService)
+    const path = yield* _(Path.Path)
+    const projectRoot = resolveProjectRoot(path, options)
+    const hash = yield* _(
+      pipe(
+        crypto.sha256(projectRoot),
+        Effect.mapError((error) => syncError(".qwen", error.reason))
+      )
+    )
+    const envSource = resolveEnvValue(yield* _(env.envVar("QWEN_SOURCE_DIR")))
+    const homeDir = yield* _(env.homedir)
+    let baseFromMeta: string | undefined
+    if (options.metaRoot !== undefined) {
+      baseFromMeta = options.metaRoot.endsWith(".qwen")
+        ? options.metaRoot
+        : path.join(options.metaRoot, ".qwen")
+    }
+    const metaKnowledge = options.metaRoot === undefined
+      ? undefined
+      : path.join(options.metaRoot, ".knowledge", ".qwen")
+    const homeBase = path.join(homeDir, ".qwen")
+    const homeKnowledge = path.join(homeDir, ".knowledge", ".qwen")
+
+    const candidates = [
+      options.qwenSourceDir,
+      envSource,
+      baseFromMeta ? path.join(baseFromMeta, "tmp", hash) : undefined,
+      path.join(projectRoot, ".qwen", "tmp", hash),
+      path.join(projectRoot, ".knowledge", ".qwen", "tmp", hash),
+      metaKnowledge ? path.join(metaKnowledge, "tmp", hash) : undefined,
+      path.join(homeBase, "tmp", hash),
+      path.join(homeKnowledge, "tmp", hash)
+    ].filter((candidate): candidate is string => candidate !== undefined)
+
+    const found = yield* _(findFirstExisting(candidates))
+    if (found === undefined) {
+      return yield* _(
+        Effect.fail(
+          syncError(
+            ".qwen",
+            `Qwen source directory is missing for hash ${hash}`
+          )
+        )
+      )
+    }
+
+    return found
+  })
+
+const qwenSource: SyncSource<QwenEnv> = createFilteredSource({
+  name: "Qwen",
+  destSubdir: ".qwen",
+  resolveSource: resolveQwenSourceDir,
+  filter: (entry, fullPath) => entry.kind === "file" && fullPath.endsWith(".json"),
+  errorReason: "Cannot traverse Qwen directory"
+})
+
+// CHANGE: sync Qwen dialog files through shared sync runner
+// WHY: keep source-specific resolution isolated and reuse copy/traversal logic
+// QUOTE(TZ): "SHELL: Все эффекты (IO, сеть, БД, env/process) изолированы"
+// REF: user-2026-01-19-sync-rewrite
+// SOURCE: n/a
+// FORMAT THEOREM: forall f: json(f) -> copied(f)
+// PURITY: SHELL
+// EFFECT: Effect<void, never, FileSystemService | RuntimeEnv | CryptoService | Path>
+// INVARIANT: only .json files are copied
+// COMPLEXITY: O(n)/O(n)
+export const syncQwen = (
+  options: SyncOptions
+): Effect.Effect<void, never, QwenEnv> => runSyncSource(qwenSource, options)

package/src/shell/sync/types.ts

@@ -0,0 +1,47 @@
+import type * as Fx from "effect"
+
+export interface SyncError {
+  readonly _tag: "SyncError"
+  readonly path: string
+  readonly reason: string
+}
+
+export interface SyncOptions {
+  readonly cwd: string
+  readonly projectRoot?: string
+  readonly sourceDir?: string
+  readonly destinationDir?: string
+  readonly repositoryUrlOverride?: string
+  readonly metaRoot?: string
+  readonly qwenSourceDir?: string
+  readonly claudeProjectsRoot?: string
+}
+
+export type SyncEffect<A, R = never> = Fx.Effect.Effect<A, SyncError, R>
+
+export interface SyncSource<R> {
+  readonly name: string
+  readonly destSubdir: ".codex" | ".qwen" | ".claude"
+  readonly resolveSource: (options: SyncOptions) => SyncEffect<string, R>
+  readonly copy: (
+    sourceDir: string,
+    destinationDir: string,
+    options: SyncOptions
+  ) => SyncEffect<number, R>
+}
+
+// CHANGE: centralize sync-specific types to keep shell modules consistent
+// WHY: shared types and error model simplify composition and testing
+// QUOTE(TZ): "Ошибки: типизированы в сигнатурах функций"
+// REF: user-2026-01-19-sync-rewrite
+// SOURCE: n/a
+// FORMAT THEOREM: forall e: SyncError -> typed(e)
+// PURITY: SHELL
+// EFFECT: n/a
+// INVARIANT: SyncError contains path and reason for logging
+// COMPLEXITY: O(1)/O(1)
+export const syncError = (pathValue: string, reason: string): SyncError => ({
+  _tag: "SyncError",
+  path: pathValue,
+  reason
+})

package/tests/core/knowledge.test.ts

@@ -0,0 +1,95 @@
+import * as Path from "@effect/platform/Path"
+import { describe, expect, it } from "@effect/vitest"
+import { Effect } from "effect"
+import fc from "fast-check"
+
+import { buildProjectLocator, type JsonValue, valueMatchesProject } from "../../src/core/knowledge.js"
+
+const buildLocator = (root: string) =>
+  buildProjectLocator(
+    root,
+    (candidate) => candidate === root || candidate.startsWith(`${root}/`)
+  )
+
+describe("valueMatchesProject", () => {
+  const safeChar: fc.Arbitrary<string> = fc.constantFrom(
+    "a",
+    "b",
+    "c",
+    "d",
+    "e",
+    "f",
+    "0",
+    "1",
+    "2",
+    "3"
+  )
+  const segment: fc.Arbitrary<string> = fc.string({
+    minLength: 1,
+    maxLength: 8,
+    unit: safeChar
+  })
+  const nonRecordValue: fc.Arbitrary<JsonValue> = fc.oneof(
+    fc.string(),
+    fc.integer(),
+    fc.boolean(),
+    fc.constant(null),
+    fc.array(fc.string(), { maxLength: 5 }),
+    fc.array(fc.integer(), { maxLength: 5 }),
+    fc.array(fc.boolean(), { maxLength: 5 }),
+    fc.array(fc.constant(null), { maxLength: 5 })
+  )
+
+  const projectRoot = Effect.gen(function*(_) {
+    const path = yield* _(Path.Path)
+    const testFile = yield* _(path.fromFileUrl(new URL(import.meta.url)))
+    return path.resolve(path.dirname(testFile), "../../../..")
+  })
+
+  it.effect("matches by cwd inside project root", () =>
+    Effect.gen(function*(_) {
+      const root = yield* _(projectRoot)
+      const locator = buildLocator(root)
+      const insidePath: fc.Arbitrary<string> = fc
+        .array(segment, { minLength: 0, maxLength: 4 })
+        .map((segments) => segments.length === 0 ? root : `${root}/${segments.join("/")}`)
+      fc.assert(
+        fc.property(insidePath, (cwd: string) => {
+          const value: JsonValue = { cwd }
+          expect(valueMatchesProject(value, locator)).toBe(true)
+        })
+      )
+    }).pipe(Effect.provide(Path.layer)))
+
+  it.effect("rejects unrelated records", () =>
+    Effect.gen(function*(_) {
+      const root = yield* _(projectRoot)
+      const path = yield* _(Path.Path)
+      const locator = buildLocator(root)
+      const outsideBase = path.join(path.dirname(root), "outside")
+      const outsidePath: fc.Arbitrary<string> = fc
+        .array(segment, { minLength: 0, maxLength: 4 })
+        .map((segments) =>
+          segments.length === 0
+            ? outsideBase
+            : `${outsideBase}/${segments.join("/")}`
+        )
+      fc.assert(
+        fc.property(outsidePath, (cwd: string) => {
+          const value: JsonValue = { cwd }
+          expect(valueMatchesProject(value, locator)).toBe(false)
+        })
+      )
+    }).pipe(Effect.provide(Path.layer)))
+
+  it.effect("rejects non-record values", () =>
+    Effect.gen(function*(_) {
+      const root = yield* _(projectRoot)
+      const locator = buildLocator(root)
+      fc.assert(
+        fc.property(nonRecordValue, (value: JsonValue) => {
+          expect(valueMatchesProject(value, locator)).toBe(false)
+        })
+      )
+    }).pipe(Effect.provide(Path.layer)))
+})

package/tests/shell/cli-pack.test.ts

@@ -0,0 +1,176 @@
+import { NodeContext } from "@effect/platform-node"
+import * as Command from "@effect/platform/Command"
+import * as Path from "@effect/platform/Path"
+import { describe, expect, it } from "@effect/vitest"
+import { Effect, Layer, pipe } from "effect"
+
+import { buildTestPaths, makeTempDir, withFsPath, writeFile } from "../support/fs-helpers.js"
+
+const testPaths = buildTestPaths(
+  new URL(import.meta.url),
+  "context-doc-cli-tests",
+  "context-doc-pack-tests"
+)
+
+const runCommand = (command: Command.Command) =>
+  pipe(
+    Command.exitCode(command),
+    Effect.flatMap((exitCode) =>
+      Number(exitCode) === 0
+        ? Effect.void
+        : Effect.fail(new Error(`Command failed with exit code ${exitCode}`))
+    )
+  )
+
+const runCommandOutput = (command: Command.Command) => Command.string(command)
+
+const packCli = Effect.gen(function*(_) {
+  const { packBase, projectRoot } = yield* _(testPaths)
+  const path = yield* _(Path.Path)
+  const packDir = yield* _(
+    makeTempDir(
+      packBase ?? path.join(projectRoot, ".tmp", "context-doc-pack-tests"),
+      "pack-"
+    )
+  )
+
+  const build = pipe(
+    Command.make("pnpm", "--filter", "@prover-coder-ai/context-doc", "build"),
+    Command.workingDirectory(projectRoot)
+  )
+  yield* _(runCommand(build))
+
+  const appDir = path.join(projectRoot, "packages", "app")
+  const pack = pipe(
+    Command.make("npm", "pack", "--silent", "--pack-destination", packDir),
+    Command.workingDirectory(appDir)
+  )
+  const tarballName = (yield* _(runCommandOutput(pack))).trim()
+  const tarballPath = path.join(packDir, tarballName)
+  const tarballSpec = `file:${tarballPath}`
+
+  const tarballExists = yield* _(
+    withFsPath((fs) => fs.exists(tarballPath))
+  )
+  if (!tarballExists) {
+    return yield* _(Effect.fail(new Error("Packed tarball was not created")))
+  }
+
+  return { projectRoot, tarballSpec }
+})
+
+const prepareProject = Effect.gen(function*(_) {
+  const { tempBase } = yield* _(testPaths)
+  const path = yield* _(Path.Path)
+  const root = yield* _(
+    makeTempDir(tempBase, "project-")
+  )
+  const codexSource = path.join(root, "codex-src")
+  const destDir = path.join(root, ".knowledge", ".codex")
+  const qwenSource = path.join(root, "qwen-src")
+
+  yield* _(
+    writeFile(
+      path.join(codexSource, "sessions/2025/11/cli.jsonl"),
+      JSON.stringify({ cwd: root, message: "ok" })
+    )
+  )
+  yield* _(
+    writeFile(
+      path.join(qwenSource, "session-1.json"),
+      JSON.stringify({ sessionId: "s1" })
+    )
+  )
+
+  return { root, codexSource, destDir, qwenSource }
+})
+
+type CliRunner = "npx" | "pnpm-dlx"
+
+interface CliRunInput {
+  readonly runner: CliRunner
+  readonly tarballSpec: string
+  readonly root: string
+  readonly codexSource: string
+  readonly destDir: string
+  readonly qwenSource: string
+}
+
+const runCliWithRunner = ({
+  codexSource,
+  destDir,
+  qwenSource,
+  root,
+  runner,
+  tarballSpec
+}: CliRunInput) =>
+  Effect.gen(function*(_) {
+    const { projectRoot } = yield* _(testPaths)
+    const args = [
+      "--project-root",
+      root,
+      "--source",
+      codexSource,
+      "--dest",
+      destDir,
+      "--qwen-source",
+      qwenSource
+    ]
+    const command = pipe(
+      runner === "npx"
+        ? Command.make("npx", "-y", tarballSpec, ...args)
+        : Command.make("pnpm", "dlx", tarballSpec, ...args),
+      Command.workingDirectory(projectRoot)
+    )
+    yield* _(runCommand(command))
+  })
+
+const assertCopied = (root: string, destDir: string) =>
+  withFsPath((fs, path) =>
+    Effect.gen(function*(_) {
+      const codexFile = path.join(destDir, "sessions/2025/11/cli.jsonl")
+      const codexExists = yield* _(fs.exists(codexFile))
+      expect(codexExists).toBe(true)
+
+      const qwenFile = path.join(root, ".knowledge", ".qwen", "session-1.json")
+      const qwenExists = yield* _(fs.exists(qwenFile))
+      expect(qwenExists).toBe(true)
+    })
+  )
+
+describe("cli package execution", () => {
+  it.effect("packs the CLI and executes it via npx", () =>
+    Effect.scoped(
+      Effect.gen(function*(_) {
+        const { tarballSpec } = yield* _(packCli)
+        const { codexSource, destDir, qwenSource, root } = yield* _(
+          prepareProject
+        )
+        yield* _(
+          runCliWithRunner({
+            runner: "npx",
+            tarballSpec,
+            root,
+            codexSource,
+            destDir,
+            qwenSource
+          })
+        )
+        yield* _(assertCopied(root, destDir))
+        const second = yield* _(prepareProject)
+        yield* _(
+          runCliWithRunner({
+            runner: "pnpm-dlx",
+            tarballSpec,
+            root: second.root,
+            codexSource: second.codexSource,
+            destDir: second.destDir,
+            qwenSource: second.qwenSource
+          })
+        )
+        yield* _(assertCopied(second.root, second.destDir))
+      })
+    ).pipe(
+      Effect.provide(Layer.mergeAll(NodeContext.layer))
+    ), 30_000)
+})