@neurocode-ai/core 1.18.8

package/test/question.test.ts

@@ -0,0 +1,114 @@
+import { describe, expect } from "bun:test"
+import { Context, Deferred, Effect, Exit, Fiber, Layer, Scope } from "effect"
+import { LayerNode } from "@neurocode-ai/core/effect/layer-node"
+import { AppNodeBuilder } from "@neurocode-ai/core/effect/app-node-builder"
+import { EventV2 } from "@neurocode-ai/core/event"
+import { QuestionV2 } from "@neurocode-ai/core/question"
+import { SessionV2 } from "@neurocode-ai/core/session"
+import { testEffect } from "./lib/effect"
+
+const questions = AppNodeBuilder.build(LayerNode.group([EventV2.node, QuestionV2.node]))
+const it = testEffect(questions)
+
+const sessionID = SessionV2.ID.make("ses_question_test")
+const question: QuestionV2.Info = {
+  question: "Which option?",
+  header: "Option",
+  options: [{ label: "One", description: "First option" }],
+}
+
+const waitForAsk = Effect.fn("QuestionV2Test.waitForAsk")(function* (
+  service: QuestionV2.Interface,
+  input: QuestionV2.AskInput,
+) {
+  const events = yield* EventV2.Service
+  const asked = yield* Deferred.make<QuestionV2.Request>()
+  const unsubscribe = yield* events.listen((event) =>
+    event.type === QuestionV2.Event.Asked.type
+      ? Deferred.succeed(asked, event.data as QuestionV2.Request).pipe(Effect.asVoid)
+      : Effect.void,
+  )
+  yield* Effect.addFinalizer(() => unsubscribe)
+  const fiber = yield* service.ask(input).pipe(Effect.forkScoped)
+  return { fiber, request: yield* Deferred.await(asked) }
+})
+
+describe("QuestionV2", () => {
+  it.effect("publishes lifecycle events and settles a pending reply", () =>
+    Effect.gen(function* () {
+      const service = yield* QuestionV2.Service
+      const events = yield* EventV2.Service
+      const published: EventV2.Payload[] = []
+      const unsubscribe = yield* events.listen((event) =>
+        Effect.sync(() => {
+          if (event.type.startsWith("question.v2.")) published.push(event)
+        }),
+      )
+      yield* Effect.addFinalizer(() => unsubscribe)
+      const { fiber, request } = yield* waitForAsk(service, { sessionID, questions: [question] })
+
+      expect(request.id).toMatch(/^que_/)
+      expect(yield* service.list()).toEqual([request])
+      yield* service.reply({ requestID: request.id, answers: [["One"]] })
+
+      expect(yield* Fiber.join(fiber)).toEqual([["One"]])
+      expect(yield* service.list()).toEqual([])
+      expect(published.map((event) => [event.type, event.data])).toEqual([
+        [QuestionV2.Event.Asked.type, request],
+        [QuestionV2.Event.Replied.type, { sessionID, requestID: request.id, answers: [["One"]] }],
+      ])
+    }),
+  )
+
+  it.effect("publishes rejection, fails the ask, and rejects unknown IDs", () =>
+    Effect.gen(function* () {
+      const service = yield* QuestionV2.Service
+      const events = yield* EventV2.Service
+      const published: EventV2.Payload[] = []
+      const unsubscribe = yield* events.listen((event) =>
+        Effect.sync(() => {
+          if (event.type === QuestionV2.Event.Rejected.type) published.push(event)
+        }),
+      )
+      yield* Effect.addFinalizer(() => unsubscribe)
+      const { fiber, request } = yield* waitForAsk(service, { sessionID, questions: [question] })
+
+      yield* service.reject(request.id)
+      const exit = yield* Fiber.await(fiber)
+      expect(Exit.isFailure(exit)).toBe(true)
+      if (Exit.isFailure(exit)) expect(exit.cause.toString()).toContain("QuestionV2.RejectedError")
+      expect(published.map((event) => event.data)).toEqual([{ sessionID, requestID: request.id }])
+
+      const unknown = QuestionV2.ID.ascending("que_unknown")
+      expect(yield* service.reply({ requestID: unknown, answers: [] }).pipe(Effect.flip)).toEqual(
+        new QuestionV2.NotFoundError({ requestID: unknown }),
+      )
+      expect(yield* service.reject(unknown).pipe(Effect.flip)).toEqual(
+        new QuestionV2.NotFoundError({ requestID: unknown }),
+      )
+    }),
+  )
+
+  it.effect("isolates pending requests by location-layer instance and rejects them on finalization", () =>
+    Effect.gen(function* () {
+      const firstScope = yield* Scope.make()
+      const secondScope = yield* Scope.make()
+      const first = Context.get(yield* Layer.buildWithScope(Layer.fresh(questions), firstScope), QuestionV2.Service)
+      const second = Context.get(yield* Layer.buildWithScope(Layer.fresh(questions), secondScope), QuestionV2.Service)
+      const fiber = yield* first.ask({ sessionID, questions: [question] }).pipe(Effect.forkScoped)
+      yield* Effect.yieldNow
+      const request = (yield* first.list())[0]!
+
+      expect(yield* second.list()).toEqual([])
+      expect(yield* second.reply({ requestID: request.id, answers: [["One"]] }).pipe(Effect.flip)).toEqual(
+        new QuestionV2.NotFoundError({ requestID: request.id }),
+      )
+
+      yield* Scope.close(firstScope, Exit.void)
+      const exit = yield* Fiber.await(fiber)
+      expect(Exit.isFailure(exit)).toBe(true)
+      if (Exit.isFailure(exit)) expect(exit.cause.toString()).toContain("QuestionV2.RejectedError")
+      yield* Scope.close(secondScope, Exit.void)
+    }),
+  )
+})

package/test/reference-guidance.test.ts

@@ -0,0 +1,76 @@
+import { describe, expect } from "bun:test"
+import { Effect, Layer } from "effect"
+import { AppNodeBuilder } from "@neurocode-ai/core/effect/app-node-builder"
+import { AbsolutePath } from "@neurocode-ai/core/schema"
+import { Reference } from "@neurocode-ai/core/reference"
+import { ReferenceGuidance } from "@neurocode-ai/core/reference/guidance"
+import { SystemContext } from "@neurocode-ai/core/system-context/index"
+import { it } from "./lib/effect"
+
+const guidanceLayer = (referenceLayer: Layer.Layer<Reference.Service>) =>
+  AppNodeBuilder.build(ReferenceGuidance.node, [[Reference.node, referenceLayer]])
+
+describe("ReferenceGuidance", () => {
+  it.effect("lists available references in the system context", () =>
+    Effect.gen(function* () {
+      const guidance = yield* ReferenceGuidance.Service
+      const generation = yield* SystemContext.initialize(yield* guidance.load())
+
+      expect(generation.baseline).toContain("<available_references>")
+      expect(generation.baseline).toContain("<name>docs</name>")
+      expect(generation.baseline).toContain("<path>/docs</path>")
+      expect(generation.baseline).toContain("<description>Use for product documentation</description>")
+    }).pipe(
+      Effect.provide(
+        guidanceLayer(
+          Layer.mock(Reference.Service, {
+            list: () =>
+              Effect.succeed([
+                new Reference.Info({
+                  name: "docs",
+                  path: AbsolutePath.make("/docs"),
+                  description: "Use for product documentation",
+                  source: Reference.LocalSource.make({
+                    type: "local",
+                    path: AbsolutePath.make("/docs"),
+                    description: "Use for product documentation",
+                  }),
+                }),
+              ]),
+          }),
+        ),
+      ),
+    ),
+  )
+
+  it.effect("omits guidance when no references are available", () =>
+    Effect.gen(function* () {
+      const guidance = yield* ReferenceGuidance.Service
+      const generation = yield* SystemContext.initialize(yield* guidance.load())
+      expect(generation.baseline).toBe("")
+    }).pipe(Effect.provide(guidanceLayer(Layer.mock(Reference.Service, { list: () => Effect.succeed([]) })))),
+  )
+
+  it.effect("omits references without descriptions", () =>
+    Effect.gen(function* () {
+      const guidance = yield* ReferenceGuidance.Service
+      const generation = yield* SystemContext.initialize(yield* guidance.load())
+      expect(generation.baseline).toBe("")
+    }).pipe(
+      Effect.provide(
+        guidanceLayer(
+          Layer.mock(Reference.Service, {
+            list: () =>
+              Effect.succeed([
+                new Reference.Info({
+                  name: "docs",
+                  path: AbsolutePath.make("/docs"),
+                  source: Reference.LocalSource.make({ type: "local", path: AbsolutePath.make("/docs") }),
+                }),
+              ]),
+          }),
+        ),
+      ),
+    ),
+  )
+})

package/test/reference.test.ts

@@ -0,0 +1,78 @@
+import { describe, expect } from "bun:test"
+import { Effect, Exit, Layer, Scope } from "effect"
+import { AppNodeBuilder } from "@neurocode-ai/core/effect/app-node-builder"
+import { LayerNode } from "@neurocode-ai/core/effect/layer-node"
+import { AbsolutePath } from "@neurocode-ai/core/schema"
+import { Global } from "@neurocode-ai/core/global"
+import { Reference } from "@neurocode-ai/core/reference"
+import { Repository } from "@neurocode-ai/core/repository"
+import { RepositoryCache } from "@neurocode-ai/core/repository-cache"
+import { it } from "./lib/effect"
+
+const cache = Layer.mock(RepositoryCache.Service, {
+  ensure: () => Effect.die("unexpected Git materialization"),
+})
+const referenceLayer = AppNodeBuilder.build(Reference.node, [[RepositoryCache.node, cache]])
+
+describe("Reference", () => {
+  it.effect("registers normalized sources for the owning scope", () =>
+    Effect.gen(function* () {
+      const references = yield* Reference.Service
+      const scope = yield* Scope.make()
+      const path = AbsolutePath.make("/docs")
+      const source = Reference.LocalSource.make({
+        type: "local",
+        path,
+        description: "Use for API documentation",
+        hidden: true,
+      })
+      yield* references.transform((editor) => editor.add("docs", source)).pipe(Scope.provide(scope))
+
+      expect(yield* references.list()).toEqual([
+        new Reference.Info({ name: "docs", path, description: "Use for API documentation", hidden: true, source }),
+      ])
+
+      yield* Scope.close(scope, Exit.void)
+      expect(yield* references.list()).toEqual([])
+    }).pipe(Effect.provide(referenceLayer)),
+  )
+
+  it.effect("derives Git paths without exposing cache operations", () =>
+    Effect.gen(function* () {
+      const references = yield* Reference.Service
+      const repository = Repository.parseRemote("owner/repo")
+      const source = Reference.GitSource.make({ type: "git", repository: "owner/repo", branch: "main" })
+      yield* references.transform((editor) => editor.add("sdk", source))
+
+      expect(yield* references.list()).toEqual([
+        new Reference.Info({
+          name: "sdk",
+          path: AbsolutePath.make(Repository.cachePath(Global.Path.repos, repository, "main")),
+          source,
+        }),
+      ])
+    }).pipe(Effect.scoped, Effect.provide(referenceLayer)),
+  )
+
+  it.effect("preserves configured Git descriptions", () =>
+    Effect.gen(function* () {
+      const references = yield* Reference.Service
+      const repository = Repository.parseRemote("owner/repo")
+      const source = Reference.GitSource.make({
+        type: "git",
+        repository: "owner/repo",
+        description: "Use for SDK implementation details",
+      })
+      yield* references.transform((editor) => editor.add("sdk", source))
+
+      expect(yield* references.list()).toEqual([
+        new Reference.Info({
+          name: "sdk",
+          path: AbsolutePath.make(Repository.cachePath(Global.Path.repos, repository)),
+          description: "Use for SDK implementation details",
+          source,
+        }),
+      ])
+    }).pipe(Effect.scoped, Effect.provide(referenceLayer)),
+  )
+})

package/test/repository-cache.test.ts

@@ -0,0 +1,153 @@
+import { describe, expect } from "bun:test"
+import fs from "fs/promises"
+import path from "path"
+import { pathToFileURL } from "url"
+import { Effect, Layer } from "effect"
+import { AppNodeBuilder } from "@neurocode-ai/core/effect/app-node-builder"
+import { LayerNode } from "@neurocode-ai/core/effect/layer-node"
+import { Global } from "@neurocode-ai/core/global"
+import { Repository } from "@neurocode-ai/core/repository"
+import { RepositoryCache } from "@neurocode-ai/core/repository-cache"
+import { branch, git, gitRemote } from "./fixture/git"
+import { tmpdir } from "./fixture/tmpdir"
+import { testEffect } from "./lib/effect"
+
+const it = testEffect(Layer.empty)
+
+describe("RepositoryCache", () => {
+  it.live("replaces a stale cache directory before cloning", () =>
+    withRemote((fixture) =>
+      Effect.gen(function* () {
+        const localPath = Repository.cachePath(path.join(fixture.root, "repos"), fixture.reference)
+        yield* Effect.promise(async () => {
+          await fs.mkdir(localPath, { recursive: true })
+          await fs.writeFile(path.join(localPath, "stale.txt"), "stale")
+        })
+
+        const result = yield* (yield* RepositoryCache.Service).ensure({ reference: fixture.reference })
+
+        expect(result.status).toBe("cloned")
+        expect(yield* exists(path.join(localPath, "stale.txt"))).toBe(false)
+        expect(yield* read(path.join(localPath, "README.md"))).toBe("one\n")
+      }).pipe(Effect.provide(cacheLayer(fixture.root))),
+    ),
+  )
+
+  it.live("serializes concurrent materialization for the same checkout", () =>
+    withRemote((fixture) =>
+      Effect.gen(function* () {
+        const cache = yield* RepositoryCache.Service
+        const results = yield* Effect.all(
+          [cache.ensure({ reference: fixture.reference }), cache.ensure({ reference: fixture.reference })],
+          { concurrency: "unbounded" },
+        )
+
+        expect(results.map((result) => result.status).toSorted()).toEqual(["cached", "cloned"])
+        expect(results[0].localPath).toBe(results[1].localPath)
+      }).pipe(Effect.provide(cacheLayer(fixture.root))),
+    ),
+  )
+
+  it.live("replaces an existing checkout whose origin does not match", () =>
+    withRemote((fixture) =>
+      Effect.gen(function* () {
+        const cache = yield* RepositoryCache.Service
+        const initial = yield* cache.ensure({ reference: fixture.reference })
+        yield* Effect.promise(async () => {
+          await git(initial.localPath, "config", "remote.origin.url", "https://github.com/other/repo.git")
+          await fs.writeFile(path.join(initial.localPath, "stale.txt"), "stale")
+        })
+
+        const replaced = yield* cache.ensure({ reference: fixture.reference })
+
+        expect(replaced.status).toBe("cloned")
+        expect(yield* exists(path.join(replaced.localPath, "stale.txt"))).toBe(false)
+      }).pipe(Effect.provide(cacheLayer(fixture.root))),
+    ),
+  )
+
+  it.live("keeps branch checkouts isolated from branchless refreshes", () =>
+    withRemote((fixture) =>
+      Effect.gen(function* () {
+        yield* Effect.promise(() => branch(fixture.source, "feature", "two\n"))
+        const cache = yield* RepositoryCache.Service
+
+        const featured = yield* cache.ensure({ reference: fixture.reference, branch: "feature" })
+        expect(featured.branch).toBe("feature")
+        expect(featured.localPath.endsWith("repo@feature")).toBe(true)
+        expect(yield* read(path.join(featured.localPath, "README.md"))).toBe("two\n")
+
+        const refreshed = yield* cache.ensure({ reference: fixture.reference, refresh: true })
+        expect(refreshed.localPath).not.toBe(featured.localPath)
+        expect(yield* read(path.join(refreshed.localPath, "README.md"))).toBe("one\n")
+
+        const cached = yield* cache.ensure({ reference: fixture.reference, branch: "feature" })
+        expect(cached.status).toBe("cached")
+        expect(yield* read(path.join(cached.localPath, "README.md"))).toBe("two\n")
+      }).pipe(Effect.provide(cacheLayer(fixture.root))),
+    ),
+  )
+
+  it.live("does not mistake an enclosing repository for the cache checkout", () =>
+    withRemote((fixture) =>
+      Effect.gen(function* () {
+        yield* Effect.promise(() => git(fixture.root, "clone", fixture.remote, path.join(fixture.root, "repos")))
+
+        const result = yield* (yield* RepositoryCache.Service).ensure({ reference: fixture.reference })
+
+        expect(result.status).toBe("cloned")
+        expect(yield* read(path.join(result.localPath, "README.md"))).toBe("one\n")
+      }).pipe(Effect.provide(cacheLayer(fixture.root))),
+    ),
+  )
+
+  it.live("returns typed validation and clone failures", () =>
+    withRemote((fixture) =>
+      Effect.gen(function* () {
+        const cache = yield* RepositoryCache.Service
+        const invalidRepository = yield* Effect.flip(RepositoryCache.parseRemote("not-a-repo"))
+        expect(invalidRepository).toBeInstanceOf(RepositoryCache.InvalidRepositoryError)
+
+        const invalidBranch = yield* Effect.flip(cache.ensure({ reference: fixture.reference, branch: "../unsafe" }))
+        expect(invalidBranch).toBeInstanceOf(RepositoryCache.InvalidBranchError)
+
+        const cloneFailure = yield* Effect.flip(
+          cache.ensure({
+            reference: { ...fixture.reference, remote: pathToFileURL(path.join(fixture.root, "missing.git")).href },
+          }),
+        )
+        expect(cloneFailure).toBeInstanceOf(RepositoryCache.CloneFailedError)
+      }).pipe(Effect.provide(cacheLayer(fixture.root))),
+    ),
+  )
+})
+
+function cacheLayer(root: string) {
+  return AppNodeBuilder.build(RepositoryCache.node, [
+    [Global.node, Global.layerWith({ state: path.join(root, "state"), repos: path.join(root, "repos") })],
+  ])
+}
+
+function withRemote<A, E, R>(body: (fixture: Awaited<ReturnType<typeof gitRemote>>) => Effect.Effect<A, E, R>) {
+  return Effect.acquireUseRelease(
+    Effect.promise(async () => {
+      const root = await tmpdir()
+      return { root, fixture: await gitRemote(root.path) }
+    }),
+    (input) => body(input.fixture),
+    (input) => Effect.promise(() => input.root[Symbol.asyncDispose]()),
+  )
+}
+
+function read(file: string) {
+  return Effect.promise(() => fs.readFile(file, "utf8")).pipe(Effect.map((content) => content.replace(/\r\n/g, "\n")))
+}
+
+function exists(file: string) {
+  return Effect.promise(() =>
+    fs.stat(file).then(
+      () => true,
+      () => false,
+    ),
+  )
+}

package/test/repository.test.ts

@@ -0,0 +1,71 @@
+import { describe, expect, test } from "bun:test"
+import path from "path"
+import { pathToFileURL } from "url"
+import { Repository } from "@neurocode-ai/core/repository"
+
+describe("Repository", () => {
+  test("parses github shorthand and builds an explicit-root cache path", () => {
+    const reference = Repository.parseRemote("owner/repo")
+
+    expect(reference).toMatchObject({
+      host: "github.com",
+      path: "owner/repo",
+      segments: ["owner", "repo"],
+      owner: "owner",
+      repo: "repo",
+      remote: "https://github.com/owner/repo.git",
+      label: "owner/repo",
+    })
+    expect(Repository.cachePath("/cache", reference)).toBe(path.join("/cache", "github.com", "owner", "repo"))
+    expect(Repository.cachePath("/cache", reference, "main")).toBe(
+      path.join("/cache", "github.com", "owner", "repo@main"),
+    )
+    expect(Repository.cachePath("/cache", reference, "feature/x")).toBe(
+      path.join("/cache", "github.com", "owner", "repo@feature%2Fx"),
+    )
+    expect(Repository.cacheIdentity(reference)).toBe("github.com/owner/repo")
+  })
+
+  test("parses host path and scp remote references", () => {
+    expect(Repository.parseRemote("gitlab.com/group/repo")).toMatchObject({
+      host: "gitlab.com",
+      path: "group/repo",
+      remote: "https://gitlab.com/group/repo.git",
+      label: "gitlab.com/group/repo",
+    })
+    expect(Repository.parseRemote("git@github.com:owner/repo.git")).toMatchObject({
+      host: "github.com",
+      path: "owner/repo",
+      remote: "git@github.com:owner/repo.git",
+      label: "owner/repo",
+    })
+  })
+
+  test("keeps local file repositories distinct from remote repositories", () => {
+    const localPath = path.resolve("repo.git")
+    const reference = Repository.parse(pathToFileURL(localPath).href)
+
+    expect(reference).toMatchObject({ host: "file", protocol: "file:", label: localPath })
+    expect(reference && Repository.isFile(reference)).toBe(true)
+    expect(reference && Repository.isRemote(reference)).toBe(false)
+    expect(() => Repository.parseRemote(pathToFileURL(localPath).href)).toThrow(
+      Repository.UnsupportedLocalRepositoryError,
+    )
+  })
+
+  test("rejects unsafe remote references and branches with typed errors", () => {
+    expect(() => Repository.parseRemote("not-a-repo")).toThrow(Repository.InvalidReferenceError)
+    expect(() => Repository.parseRemote("git@github.com:../../../etc/passwd")).toThrow(Repository.InvalidReferenceError)
+    expect(() => Repository.validateBranch("feature/docs.v1")).not.toThrow()
+    expect(() => Repository.validateBranch("-bad")).toThrow(Repository.InvalidBranchError)
+    expect(() => Repository.validateBranch("bad..branch")).toThrow(Repository.InvalidBranchError)
+    expect(() => Repository.validateBranch("bad branch")).toThrow(Repository.InvalidBranchError)
+  })
+
+  test("compares cache identity independent of input spelling", () => {
+    const shorthand = Repository.parseRemote("owner/repo")
+
+    expect(Repository.same(shorthand, Repository.parseRemote("https://github.com/owner/repo.git"))).toBe(true)
+    expect(Repository.same(shorthand, Repository.parseRemote("github.com/owner/repo"))).toBe(true)
+  })
+})

package/test/ripgrep.test.ts

@@ -0,0 +1,65 @@
+import { describe, expect } from "bun:test"
+import fs from "fs/promises"
+import path from "path"
+import { Effect } from "effect"
+import { LayerNode } from "@neurocode-ai/core/effect/layer-node"
+import { Ripgrep } from "@neurocode-ai/core/ripgrep"
+import { RelativePath } from "@neurocode-ai/core/schema"
+import { tmpdir } from "./fixture/tmpdir"
+import { testEffect } from "./lib/effect"
+
+const it = testEffect(LayerNode.compile(Ripgrep.node))
+
+describe("Ripgrep", () => {
+  it.live("keeps ignored files out of catch-all find results", () =>
+    Effect.acquireUseRelease(
+      Effect.promise(() => tmpdir()),
+      (tmp) =>
+        Effect.gen(function* () {
+          yield* Effect.promise(() => fs.mkdir(path.join(tmp.path, "node_modules", "pkg"), { recursive: true }))
+          yield* Effect.promise(() => fs.mkdir(path.join(tmp.path, "src")))
+          yield* Effect.promise(() => Bun.$`git init -q ${tmp.path}`)
+          yield* Effect.promise(() => fs.writeFile(path.join(tmp.path, ".gitignore"), "node_modules/\n"))
+          yield* Effect.promise(() => fs.writeFile(path.join(tmp.path, "node_modules", "pkg", "index.js"), "ignored\n"))
+          yield* Effect.promise(() => fs.writeFile(path.join(tmp.path, "src", "index.js"), "included\n"))
+
+          const files = yield* (yield* Ripgrep.Service).find({ cwd: tmp.path, pattern: "*", limit: 10 })
+          expect(files.map((item) => item.path)).toContain(RelativePath.make("src/index.js"))
+          expect(files.map((item) => item.path)).not.toContain(RelativePath.make("node_modules/pkg/index.js"))
+        }),
+      (tmp) => Effect.promise(() => tmp[Symbol.asyncDispose]()),
+    ),
+  )
+
+  it.live("never includes git metadata", () =>
+    Effect.acquireUseRelease(
+      Effect.promise(() => tmpdir()),
+      (tmp) =>
+        Effect.gen(function* () {
+          yield* Effect.promise(() => fs.mkdir(path.join(tmp.path, ".neurocode")))
+          yield* Effect.promise(() => fs.writeFile(path.join(tmp.path, ".neurocode", "config"), "needle\n"))
+          yield* Effect.promise(() => fs.mkdir(path.join(tmp.path, ".git")))
+          yield* Effect.promise(() => fs.writeFile(path.join(tmp.path, ".git", "config"), "needle\n"))
+          const ripgrep = yield* Ripgrep.Service
+
+          const files = yield* ripgrep.find({ cwd: tmp.path, pattern: "**/*", limit: 10 })
+          expect(files.map((item) => item.path)).toContain(RelativePath.make(".neurocode/config"))
+          expect(files.map((item) => item.path)).not.toContain(RelativePath.make(".git/config"))
+
+          const observed: string[] = []
+          const limited = yield* ripgrep.find({
+            cwd: tmp.path,
+            pattern: "**/*",
+            limit: 1,
+            onEntry: (entry) => Effect.sync(() => observed.push(entry.path)),
+          })
+          expect(observed).toEqual(limited.map((item) => item.path))
+
+          const matches = yield* ripgrep.grep({ cwd: tmp.path, pattern: "needle", include: "config", limit: 10 })
+          expect(matches.map((item) => item.entry.path)).toContain(RelativePath.make(".neurocode/config"))
+          expect(matches.map((item) => item.entry.path)).not.toContain(RelativePath.make(".git/config"))
+        }),
+      (tmp) => Effect.promise(() => tmp[Symbol.asyncDispose]()),
+    ),
+  )
+})

package/test/session-compaction.test.ts

@@ -0,0 +1,27 @@
+import { expect, test } from "bun:test"
+import { SessionCompaction } from "@neurocode-ai/core/session/compaction"
+
+test("compaction prompt preserves detailed work state and relevant files", () => {
+  const prompt = SessionCompaction.buildPrompt({ context: ["conversation history"] })
+
+  expect(prompt).toContain("## Work State\n### Completed")
+  expect(prompt).toContain("### Active")
+  expect(prompt).toContain("### Blocked")
+  expect(prompt).toContain("## Relevant Files")
+})
+
+test("compaction describes tool media without embedding base64", () => {
+  const base64 = "iVBORw0KGgoAAAANSUhEUgAAAAEAAAAB"
+  const serialized = SessionCompaction.serializeToolContent([
+    { type: "text", text: "Image read successfully" },
+    {
+      type: "file",
+      uri: `data:image/png;base64,${base64}`,
+      mime: "image/png",
+      name: "pixel.png",
+    },
+  ])
+
+  expect(serialized).toBe("Image read successfully\n[Attached image/png: pixel.png]")
+  expect(serialized).not.toContain(base64)
+})