@neurocode-ai/core 1.18.8

package/test/session-todo.test.ts

@@ -0,0 +1,94 @@
+import { describe, expect } from "bun:test"
+import { asc } from "drizzle-orm"
+import { Effect } from "effect"
+import { Database } from "@neurocode-ai/core/database/database"
+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 { Project } from "@neurocode-ai/core/project"
+import { ProjectTable } from "@neurocode-ai/core/project/sql"
+import { AbsolutePath } from "@neurocode-ai/core/schema"
+import { SessionV2 } from "@neurocode-ai/core/session"
+import { SessionTable, TodoTable } from "@neurocode-ai/core/session/sql"
+import { SessionTodo } from "@neurocode-ai/core/session/todo"
+import { testEffect } from "./lib/effect"
+
+const it = testEffect(AppNodeBuilder.build(LayerNode.group([Database.node, EventV2.node, SessionTodo.node])))
+const sessionID = SessionV2.ID.make("ses_todo_test")
+
+const setup = Effect.gen(function* () {
+  const { db } = yield* Database.Service
+  yield* db
+    .insert(ProjectTable)
+    .values({ id: Project.ID.global, worktree: AbsolutePath.make("/project"), sandboxes: [] })
+    .run()
+    .pipe(Effect.orDie)
+  yield* db
+    .insert(SessionTable)
+    .values({
+      id: sessionID,
+      project_id: Project.ID.global,
+      slug: "todo",
+      directory: "/project",
+      title: "todo",
+      version: "test",
+    })
+    .run()
+    .pipe(Effect.orDie)
+})
+
+describe("SessionTodo", () => {
+  it.effect("replaces persisted todos in order and publishes updates", () =>
+    Effect.gen(function* () {
+      yield* setup
+      const { db } = yield* Database.Service
+      const events = yield* EventV2.Service
+      const todos = yield* SessionTodo.Service
+      const published = new Array<EventV2.Payload>()
+      const unsubscribe = yield* events.listen((event) =>
+        Effect.sync(() => {
+          if (event.type === SessionTodo.Event.Updated.type) published.push(event)
+        }),
+      )
+      yield* Effect.addFinalizer(() => unsubscribe)
+
+      yield* todos.update({
+        sessionID,
+        todos: [
+          { content: "second", status: "pending", priority: "low" },
+          { content: "first", status: "in_progress", priority: "high" },
+        ],
+      })
+      expect(yield* todos.get(sessionID)).toEqual([
+        { content: "second", status: "pending", priority: "low" },
+        { content: "first", status: "in_progress", priority: "high" },
+      ])
+      expect(
+        (yield* db.select().from(TodoTable).orderBy(asc(TodoTable.position)).all().pipe(Effect.orDie)).map((row) => ({
+          content: row.content,
+          position: row.position,
+        })),
+      ).toEqual([
+        { content: "second", position: 0 },
+        { content: "first", position: 1 },
+      ])
+
+      yield* todos.update({ sessionID, todos: [{ content: "replacement", status: "completed", priority: "medium" }] })
+      expect(yield* todos.get(sessionID)).toEqual([{ content: "replacement", status: "completed", priority: "medium" }])
+
+      yield* todos.update({ sessionID, todos: [] })
+      expect(yield* todos.get(sessionID)).toEqual([])
+      expect(published.map((event) => event.data)).toEqual([
+        {
+          sessionID,
+          todos: [
+            { content: "second", status: "pending", priority: "low" },
+            { content: "first", status: "in_progress", priority: "high" },
+          ],
+        },
+        { sessionID, todos: [{ content: "replacement", status: "completed", priority: "medium" }] },
+        { sessionID, todos: [] },
+      ])
+    }),
+  )
+})

package/test/session-tool-progress.test.ts

@@ -0,0 +1,158 @@
+import { describe, expect } from "bun:test"
+import { asc, eq } from "drizzle-orm"
+import { DateTime, Effect, Schema } from "effect"
+import { Database } from "@neurocode-ai/core/database/database"
+import { LayerNode } from "@neurocode-ai/core/effect/layer-node"
+import { EventV2 } from "@neurocode-ai/core/event"
+import { EventTable } from "@neurocode-ai/core/event/sql"
+import { ModelV2 } from "@neurocode-ai/core/model"
+import { Project } from "@neurocode-ai/core/project"
+import { ProjectTable } from "@neurocode-ai/core/project/sql"
+import { ProviderV2 } from "@neurocode-ai/core/provider"
+import { AbsolutePath } from "@neurocode-ai/core/schema"
+import { SessionV2 } from "@neurocode-ai/core/session"
+import { SessionEvent } from "@neurocode-ai/core/session/event"
+import { SessionMessage } from "@neurocode-ai/core/session/message"
+import { SessionProjector } from "@neurocode-ai/core/session/projector"
+import { SessionTable, SessionMessageTable } from "@neurocode-ai/core/session/sql"
+import { testEffect } from "./lib/effect"
+
+const it = testEffect(LayerNode.compile(LayerNode.group([Database.node, EventV2.node, SessionProjector.node])))
+const timestamp = DateTime.makeUnsafe(1)
+const model = { id: ModelV2.ID.make("model"), providerID: ProviderV2.ID.make("provider") }
+
+const content = (text: string) => [{ type: "text" as const, text }]
+
+describe("Tool.Progress", () => {
+  it.effect("projects durable progress and keeps final settlements durable", () =>
+    Effect.gen(function* () {
+      const { db } = yield* Database.Service
+      const service = yield* EventV2.Service
+      const sessionID = SessionV2.ID.make("ses_tool_progress_projector")
+      yield* db
+        .insert(ProjectTable)
+        .values({ id: Project.ID.global, worktree: AbsolutePath.make("/project"), sandboxes: [] })
+        .onConflictDoNothing()
+        .run()
+        .pipe(Effect.orDie)
+      yield* db
+        .insert(SessionTable)
+        .values({
+          id: sessionID,
+          project_id: Project.ID.global,
+          slug: "progress",
+          directory: "/project",
+          title: "progress",
+          version: "test",
+        })
+        .run()
+        .pipe(Effect.orDie)
+      const assistantMessageID = SessionMessage.ID.create()
+      yield* service.publish(SessionEvent.Step.Started, {
+        sessionID,
+        assistantMessageID,
+        timestamp,
+        agent: "build",
+        model,
+      })
+      const readAssistant = Effect.gen(function* () {
+        const row = yield* db
+          .select()
+          .from(SessionMessageTable)
+          .where(eq(SessionMessageTable.id, assistantMessageID))
+          .get()
+          .pipe(Effect.orDie)
+        if (!row) return yield* Effect.die("Missing projected assistant")
+        return Schema.decodeUnknownSync(SessionMessage.Assistant)({ ...row.data, id: row.id, type: row.type })
+      })
+      const start = (callID: string) =>
+        Effect.gen(function* () {
+          yield* service.publish(SessionEvent.Tool.Input.Started, {
+            sessionID,
+            timestamp,
+            assistantMessageID,
+            callID,
+            name: "bash",
+          })
+          yield* service.publish(SessionEvent.Tool.Called, {
+            sessionID,
+            timestamp,
+            assistantMessageID,
+            callID,
+            tool: "bash",
+            input: { command: "pwd" },
+            provider: { executed: false },
+          })
+        })
+
+      yield* start("call-success")
+      expect((yield* readAssistant).content[0]).toMatchObject({
+        state: { status: "running", structured: {}, content: [] },
+      })
+
+      yield* service.publish(SessionEvent.Tool.Progress, {
+        sessionID,
+        timestamp,
+        assistantMessageID,
+        callID: "call-success",
+        structured: { phase: "checkpoint" },
+        content: content("saved"),
+      })
+      expect((yield* readAssistant).content[0]).toMatchObject({
+        state: { status: "running", structured: { phase: "checkpoint" }, content: content("saved") },
+      })
+
+      const success = yield* service.publish(SessionEvent.Tool.Success, {
+        sessionID,
+        timestamp,
+        assistantMessageID,
+        callID: "call-success",
+        structured: { phase: "done" },
+        content: content("complete"),
+        provider: { executed: false },
+      })
+      expect((yield* readAssistant).content[0]).toMatchObject({
+        state: { status: "completed", structured: { phase: "done" }, content: content("complete") },
+      })
+
+      yield* start("call-failed")
+      yield* service.publish(SessionEvent.Tool.Progress, {
+        sessionID,
+        timestamp,
+        assistantMessageID,
+        callID: "call-failed",
+        structured: { phase: "checkpoint" },
+        content: content("before failure"),
+      })
+      const failed = yield* service.publish(SessionEvent.Tool.Failed, {
+        sessionID,
+        timestamp,
+        assistantMessageID,
+        callID: "call-failed",
+        error: { type: "unknown", message: "boom" },
+        provider: { executed: false },
+      })
+      expect((yield* readAssistant).content[1]).toMatchObject({
+        state: {
+          status: "error",
+          structured: { phase: "checkpoint" },
+          content: content("before failure"),
+          error: { type: "unknown", message: "boom" },
+        },
+      })
+      expect(Schema.is(SessionEvent.Durable)(success)).toBe(true)
+      expect(Schema.is(SessionEvent.Durable)(failed)).toBe(true)
+
+      const rows = yield* db
+        .select({ type: EventTable.type })
+        .from(EventTable)
+        .where(eq(EventTable.aggregate_id, sessionID))
+        .orderBy(asc(EventTable.seq))
+        .all()
+        .pipe(Effect.orDie)
+      expect(rows.map((row) => row.type)).toContain(EventV2.versionedType(SessionEvent.Tool.Progress.type, 1))
+      expect(rows.map((row) => row.type)).toContain(EventV2.versionedType(SessionEvent.Tool.Success.type, 1))
+      expect(rows.map((row) => row.type)).toContain(EventV2.versionedType(SessionEvent.Tool.Failed.type, 1))
+    }),
+  )
+})

package/test/shared-schema.test.ts

@@ -0,0 +1,206 @@
+import { expect, test } from "bun:test"
+import { Schema } from "effect"
+import { AgentV2 } from "@neurocode-ai/core/agent"
+import { ModelV2 } from "@neurocode-ai/core/model"
+import { SessionV2 } from "@neurocode-ai/core/session"
+import { Agent } from "@neurocode-ai/schema/agent"
+import { Location } from "@neurocode-ai/schema/location"
+import { Model } from "@neurocode-ai/schema/model"
+import { AgentAttachment, FileAttachment, Prompt, Source } from "@neurocode-ai/schema/prompt"
+import { Provider } from "@neurocode-ai/schema/provider"
+import { Project } from "@neurocode-ai/schema/project"
+import { ProjectDirectories } from "@neurocode-ai/schema/project-directories"
+import { PermissionV1 } from "@neurocode-ai/schema/permission-v1"
+import { Session } from "@neurocode-ai/schema/session"
+import { SessionInput } from "@neurocode-ai/schema/session-input"
+import { SessionMessage } from "@neurocode-ai/schema/session-message"
+import { Workspace } from "@neurocode-ai/schema/workspace"
+import { Command } from "@neurocode-ai/schema/command"
+import { Connection } from "@neurocode-ai/schema/connection"
+import { Credential } from "@neurocode-ai/schema/credential"
+import { FileSystem } from "@neurocode-ai/schema/filesystem"
+import { Integration } from "@neurocode-ai/schema/integration"
+import { LLM } from "@neurocode-ai/schema/llm"
+import { Permission } from "@neurocode-ai/schema/permission"
+import { Plugin } from "@neurocode-ai/schema/plugin"
+import { Pty } from "@neurocode-ai/schema/pty"
+import { Reference } from "@neurocode-ai/schema/reference"
+import { SessionTodo } from "@neurocode-ai/schema/session-todo"
+import { Skill } from "@neurocode-ai/schema/skill"
+import { AbsolutePath, DateTimeUtcFromMillis, optional, statics } from "@neurocode-ai/schema/schema"
+import { ProviderV2 } from "@neurocode-ai/core/provider"
+import { PluginV2 } from "@neurocode-ai/core/plugin"
+
+test("Core reuses the canonical shared schemas", async () => {
+  const [
+    coreCommand,
+    coreConnection,
+    coreCredential,
+    coreFileSystem,
+    coreIntegration,
+    coreLocation,
+    coreLLM,
+    corePermission,
+    corePermissionV1,
+    coreProjectCopy,
+    corePty,
+    coreProject,
+    coreReference,
+    coreSessionInput,
+    coreSessionMessage,
+    coreSessionTodo,
+    corePrompt,
+    coreSkill,
+    coreV2Schema,
+    coreSchema,
+    coreWorkspace,
+  ] = await Promise.all([
+    import("@neurocode-ai/core/command"),
+    import("@neurocode-ai/core/integration/connection"),
+    import("@neurocode-ai/core/credential"),
+    import("@neurocode-ai/core/filesystem"),
+    import("@neurocode-ai/core/integration"),
+    import("@neurocode-ai/core/location"),
+    import("@neurocode-ai/llm"),
+    import("@neurocode-ai/core/permission"),
+    import("@neurocode-ai/core/v1/permission"),
+    import("@neurocode-ai/core/project/copy"),
+    import("@neurocode-ai/core/pty"),
+    import("@neurocode-ai/core/project/schema"),
+    import("@neurocode-ai/core/reference"),
+    import("@neurocode-ai/core/session/input"),
+    import("@neurocode-ai/core/session/message"),
+    import("@neurocode-ai/core/session/todo"),
+    import("@neurocode-ai/core/session/prompt"),
+    import("@neurocode-ai/core/skill"),
+    import("@neurocode-ai/core/v2-schema"),
+    import("@neurocode-ai/core/schema"),
+    import("@neurocode-ai/core/workspace"),
+  ])
+
+  const schemas = [
+    [AgentV2.ID, Agent.ID],
+    [AgentV2.Color, Agent.Color],
+    [AgentV2.Info, Agent.Info],
+    [coreCommand.Info, Command.Info],
+    [coreConnection.CredentialInfo, Connection.CredentialInfo],
+    [coreConnection.EnvInfo, Connection.EnvInfo],
+    [coreConnection.Info, Connection.Info],
+    [coreCredential.ID, Credential.ID],
+    [coreCredential.OAuth, Credential.OAuth],
+    [coreCredential.Key, Credential.Key],
+    [coreCredential.Value, Credential.Value],
+    [coreFileSystem.Entry, FileSystem.Entry],
+    [coreFileSystem.Submatch, FileSystem.Submatch],
+    [coreFileSystem.Match, FileSystem.Match],
+    [coreIntegration.ID, Integration.ID],
+    [coreIntegration.MethodID, Integration.MethodID],
+    [coreIntegration.When, Integration.When],
+    [coreIntegration.TextPrompt, Integration.TextPrompt],
+    [coreIntegration.SelectPrompt, Integration.SelectPrompt],
+    [coreIntegration.Prompt, Integration.Prompt],
+    [coreIntegration.OAuthMethod, Integration.OAuthMethod],
+    [coreIntegration.KeyMethod, Integration.KeyMethod],
+    [coreIntegration.EnvMethod, Integration.EnvMethod],
+    [coreIntegration.Method, Integration.Method],
+    [coreIntegration.Inputs, Integration.Inputs],
+    [coreIntegration.Ref, Integration.Ref],
+    [coreLocation.Ref, Location.Ref],
+    [coreLLM.ProviderMetadata, LLM.ProviderMetadata],
+    [coreLLM.ToolTextContent, LLM.ToolTextContent],
+    [coreLLM.ToolFileContent, LLM.ToolFileContent],
+    [coreLLM.ToolContent, LLM.ToolContent],
+    [ModelV2.ID, Model.ID],
+    [ModelV2.VariantID, Model.VariantID],
+    [ModelV2.Ref, Model.Ref],
+    [ModelV2.Family, Model.Family],
+    [ModelV2.Capabilities, Model.Capabilities],
+    [ModelV2.Cost, Model.Cost],
+    [ModelV2.Api, Model.Api],
+    [ModelV2.Info, Model.Info],
+    [ProviderV2.ID, Provider.ID],
+    [ProviderV2.AISDK, Provider.AISDK],
+    [ProviderV2.Native, Provider.Native],
+    [ProviderV2.Api, Provider.Api],
+    [ProviderV2.Request, Provider.Request],
+    [ProviderV2.Info, Provider.Info],
+    [corePermission.Effect, Permission.Effect],
+    [corePermission.Rule, Permission.Rule],
+    [corePermission.Ruleset, Permission.Ruleset],
+    [corePermissionV1.Event, PermissionV1.Event],
+    [coreProjectCopy.Event, ProjectDirectories.Event],
+    [PluginV2.ID, Plugin.ID],
+    [PluginV2.Event, Plugin.Event],
+    [corePty.Info, Pty.Info],
+    [corePty.Event, Pty.Event],
+    [coreProject.ID, Project.ID],
+    [coreReference.LocalSource, Reference.LocalSource],
+    [coreReference.GitSource, Reference.GitSource],
+    [coreReference.Source, Reference.Source],
+    [SessionV2.ID, Session.ID],
+    [SessionV2.Info, Session.Info],
+    [SessionV2.ListAnchor, Session.ListAnchor],
+    [coreSessionInput.Delivery, SessionInput.Delivery],
+    [coreSessionInput.Admitted, SessionInput.Admitted],
+    [coreSessionMessage.ID, SessionMessage.ID],
+    [coreSessionMessage.UnknownError, SessionMessage.UnknownError],
+    [coreSessionMessage.AgentSwitched, SessionMessage.AgentSwitched],
+    [coreSessionMessage.ModelSwitched, SessionMessage.ModelSwitched],
+    [coreSessionMessage.User, SessionMessage.User],
+    [coreSessionMessage.Synthetic, SessionMessage.Synthetic],
+    [coreSessionMessage.System, SessionMessage.System],
+    [coreSessionMessage.Shell, SessionMessage.Shell],
+    [coreSessionMessage.ToolStatePending, SessionMessage.ToolStatePending],
+    [coreSessionMessage.ToolStateRunning, SessionMessage.ToolStateRunning],
+    [coreSessionMessage.ToolStateCompleted, SessionMessage.ToolStateCompleted],
+    [coreSessionMessage.ToolStateError, SessionMessage.ToolStateError],
+    [coreSessionMessage.ToolState, SessionMessage.ToolState],
+    [coreSessionMessage.AssistantTool, SessionMessage.AssistantTool],
+    [coreSessionMessage.AssistantText, SessionMessage.AssistantText],
+    [coreSessionMessage.AssistantReasoning, SessionMessage.AssistantReasoning],
+    [coreSessionMessage.AssistantContent, SessionMessage.AssistantContent],
+    [coreSessionMessage.Assistant, SessionMessage.Assistant],
+    [coreSessionMessage.Compaction, SessionMessage.Compaction],
+    [coreSessionMessage.Message, SessionMessage.Message],
+    [coreSessionTodo.Info, SessionTodo.Info],
+    [coreSessionTodo.Event, SessionTodo.Event],
+    [corePrompt.Source, Source],
+    [corePrompt.FileAttachment, FileAttachment],
+    [corePrompt.AgentAttachment, AgentAttachment],
+    [corePrompt.Prompt, Prompt],
+    [coreSkill.DirectorySource, Skill.DirectorySource],
+    [coreSkill.UrlSource, Skill.UrlSource],
+    [coreSkill.EmbeddedSource, Skill.EmbeddedSource],
+    [coreSkill.Source, Skill.Source],
+    [coreSkill.Info, Skill.Info],
+    [coreV2Schema.DateTimeUtcFromMillis, DateTimeUtcFromMillis],
+    [coreSchema.optional, optional],
+    [coreSchema.statics, statics],
+    [coreWorkspace.ID, Workspace.ID],
+  ]
+  for (const [core, shared] of schemas) expect(core).toBe(shared)
+
+  expect(Agent.Info.empty(Agent.ID.make("test"))).toEqual(AgentV2.Info.empty(AgentV2.ID.make("test")))
+  expect(Model.Info.empty(Provider.ID.make("test"), Model.ID.make("model"))).toEqual(
+    ModelV2.Info.empty(ProviderV2.ID.make("test"), ModelV2.ID.make("model")),
+  )
+  expect(Provider.Info.empty(Provider.ID.make("test"))).toEqual(ProviderV2.Info.empty(ProviderV2.ID.make("test")))
+  expect(Skill.Source.key(Skill.DirectorySource.make({ type: "directory", path: AbsolutePath.make("/tmp") }))).toBe(
+    "directory:/tmp",
+  )
+})
+
+test("shared record schemas construct and decode plain objects", () => {
+  const made = Prompt.make({ text: "hello" })
+  const decoded = Schema.decodeUnknownSync(Prompt)({ text: "hello" })
+  const content = Schema.decodeUnknownSync(SessionMessage.AssistantText)({ type: "text", id: "part_1", text: "hi" })
+
+  expect(Object.getPrototypeOf(made)).toBe(Object.prototype)
+  expect(Object.getPrototypeOf(decoded)).toBe(Object.prototype)
+  expect(Object.getPrototypeOf(content)).toBe(Object.prototype)
+  expect(Prompt.ast.annotations?.identifier).toBe("Prompt")
+  expect(SessionMessage.AssistantText.ast.annotations?.identifier).toBe("Session.Message.Assistant.Text")
+  expect(Prompt.equivalence(Prompt.make({ text: "hello" }), decoded)).toBe(true)
+  expect(Prompt.fromUserMessage({ text: "hello" })).toEqual(made)
+  expect(Workspace.ID.ascending("")).toStartWith("wrk_")
+})

package/test/shell.test.ts

@@ -0,0 +1,108 @@
+import { describe, expect, test } from "bun:test"
+import path from "path"
+import { Shell } from "@neurocode-ai/core/shell"
+import { FSUtil } from "@neurocode-ai/core/fs-util"
+import { which } from "@neurocode-ai/core/util/which"
+
+const withShell = async (shell: string | undefined, fn: () => void | Promise<void>) => {
+  const prev = process.env.SHELL
+  if (shell === undefined) delete process.env.SHELL
+  else process.env.SHELL = shell
+  Shell.acceptable.reset()
+  Shell.preferred.reset()
+  try {
+    await fn()
+  } finally {
+    if (prev === undefined) delete process.env.SHELL
+    else process.env.SHELL = prev
+    Shell.acceptable.reset()
+    Shell.preferred.reset()
+  }
+}
+
+describe("shell", () => {
+  test("normalizes shell names", () => {
+    expect(Shell.name("/bin/bash")).toBe("bash")
+    if (process.platform === "win32") {
+      expect(Shell.name("C:/tools/NU.EXE")).toBe("nu")
+      expect(Shell.name("C:/tools/PWSH.EXE")).toBe("pwsh")
+    }
+  })
+
+  test("detects login shells", () => {
+    expect(Shell.login("/bin/bash")).toBe(true)
+    expect(Shell.login("C:/tools/pwsh.exe")).toBe(false)
+  })
+
+  test("detects posix shells", () => {
+    expect(Shell.posix("/bin/bash")).toBe(true)
+    expect(Shell.posix("/bin/fish")).toBe(false)
+    expect(Shell.posix("C:/tools/pwsh.exe")).toBe(false)
+  })
+
+  test("falls back when configured shell cannot be resolved", async () => {
+    await withShell(undefined, async () => {
+      const preferred = Shell.preferred()
+      const acceptable = Shell.acceptable()
+      expect(Shell.preferred("neurocode-missing-shell")).toBe(preferred)
+      expect(Shell.acceptable("neurocode-missing-shell")).toBe(acceptable)
+    })
+  })
+
+  test("falls back for terminal-only acceptable shells", () => {
+    expect(Shell.name(Shell.acceptable("fish"))).not.toBe("fish")
+    expect(Shell.name(Shell.acceptable("nu"))).not.toBe("nu")
+  })
+
+  test("builds command args per shell family", () => {
+    expect(Shell.args("/bin/sh", "echo hi", "/tmp")).toEqual(["-c", "echo hi"])
+    expect(Shell.args("/usr/bin/fish", "echo hi", "/tmp")).toEqual(["-c", "echo hi"])
+    const zsh = Shell.args("/bin/zsh", "echo hi", "/tmp")
+    expect(zsh[0]).toBe("-l")
+    expect(zsh[1]).toBe("-c")
+    expect(zsh.at(-1)).toBe("/tmp")
+  })
+
+  if (process.platform === "win32") {
+    test("rejects blacklisted shells case-insensitively", async () => {
+      await withShell("NU.EXE", async () => {
+        expect(Shell.name(Shell.acceptable())).not.toBe("nu")
+      })
+    })
+
+    test("normalizes Git Bash shell paths from env", async () => {
+      const shell = "/cygdrive/c/Program Files/Git/bin/bash.exe"
+      await withShell(shell, async () => {
+        expect(Shell.preferred()).toBe(FSUtil.windowsPath(shell))
+      })
+    })
+
+    test("resolves /usr/bin/bash from env to Git Bash", async () => {
+      const bash = Shell.gitbash()
+      if (!bash) return
+      await withShell("/usr/bin/bash", async () => {
+        expect(Shell.acceptable()).toBe(bash)
+        expect(Shell.preferred()).toBe(bash)
+      })
+    })
+
+    test("resolves bare bash to Git Bash before PATH", async () => {
+      const bash = Shell.gitbash()
+      if (!bash) return
+      expect(Shell.acceptable("bash")).toBe(bash)
+      expect(Shell.preferred("bash")).toBe(bash)
+      await withShell("bash", async () => {
+        expect(Shell.acceptable()).toBe(bash)
+        expect(Shell.preferred()).toBe(bash)
+      })
+    })
+
+    test("resolves bare PowerShell shells", async () => {
+      const shell = which("pwsh") || which("powershell")
+      if (!shell) return
+      await withShell(path.win32.basename(shell), async () => {
+        expect(Shell.preferred()).toBe(shell)
+      })
+    })
+  }
+})