saeeol 1.3.0 → 1.4.0

package/test/saeeol/transform-opus-4.7.test.ts

@@ -0,0 +1,89 @@
+import { describe, expect, test } from "bun:test"
+import { ProviderTransform } from "../../src/provider/transform"
+
+function mockModel(overrides: Partial<any> = {}): any {
+  return {
+    id: "test/test-model",
+    providerID: "test",
+    api: {
+      id: "test-model",
+      url: "https://api.test.com",
+      npm: "@ai-sdk/anthropic",
+    },
+    name: "Test Model",
+    capabilities: {
+      temperature: true,
+      reasoning: true,
+      attachment: true,
+      toolcall: true,
+      input: { text: true, audio: false, image: true, video: false, pdf: false },
+      output: { text: true, audio: false, image: false, video: false, pdf: false },
+      interleaved: false,
+    },
+    cost: { input: 0.001, output: 0.002, cache: { read: 0.0001, write: 0.0002 } },
+    limit: { context: 200_000, output: 64_000 },
+    status: "active",
+    options: {},
+    headers: {},
+    release_date: "2024-01-01",
+    ...overrides,
+  }
+}
+
+describe("ProviderTransform.variants - Claude Opus 4.7", () => {
+  test("opus-4-7 returns adaptive thinking variants including xhigh (native anthropic)", () => {
+    const model = mockModel({
+      api: {
+        id: "claude-opus-4-7",
+        url: "https://api.anthropic.com",
+        npm: "@ai-sdk/anthropic",
+      },
+    })
+    const result = ProviderTransform.variants(model)
+    expect(Object.keys(result)).toEqual(["low", "medium", "high", "xhigh", "max"])
+    expect(result.xhigh).toEqual({
+      thinking: { type: "adaptive", display: "summarized" },
+      effort: "xhigh",
+    })
+  })
+
+  test("opus-4.7 dot-form returns adaptive thinking variants via @ai-sdk/gateway", () => {
+    const model = mockModel({
+      id: "anthropic/claude-opus-4-7",
+      api: {
+        id: "anthropic/claude-opus-4.7",
+        url: "https://gateway.ai",
+        npm: "@ai-sdk/gateway",
+      },
+    })
+    const result = ProviderTransform.variants(model)
+    expect(Object.keys(result)).toEqual(["low", "medium", "high", "xhigh", "max"])
+  })
+
+  test("opus-4-7 on bedrock returns adaptive reasoningConfig with xhigh", () => {
+    const model = mockModel({
+      api: {
+        id: "anthropic.claude-opus-4-7",
+        url: "https://bedrock.amazonaws.com",
+        npm: "@ai-sdk/amazon-bedrock",
+      },
+    })
+    const result = ProviderTransform.variants(model)
+    expect(Object.keys(result)).toEqual(["low", "medium", "high", "xhigh", "max"])
+    expect(result.xhigh).toEqual({
+      reasoningConfig: { type: "adaptive", maxReasoningEffort: "xhigh", display: "summarized" },
+    })
+  })
+
+  test("opus-4-6 keeps original adaptive efforts without xhigh", () => {
+    const model = mockModel({
+      api: {
+        id: "claude-opus-4-6",
+        url: "https://api.anthropic.com",
+        npm: "@ai-sdk/anthropic",
+      },
+    })
+    const result = ProviderTransform.variants(model)
+    expect(Object.keys(result)).toEqual(["low", "medium", "high", "max"])
+  })
+})

package/test/saeeol/tui-diff.test.ts

@@ -0,0 +1,91 @@
+import { describe, expect, test } from "bun:test"
+import { splitDiffHunks } from "../../src/overlay/tui/diff"
+
+describe("splitDiffHunks", () => {
+  test("returns original diff when there are no hunks", () => {
+    const diff = "--- a/file.ts\n+++ b/file.ts"
+    expect(splitDiffHunks(diff)).toEqual([diff])
+  })
+
+  test("returns original diff when there is one hunk", () => {
+    const diff = ["--- a/file.ts", "+++ b/file.ts", "@@ -1,2 +1,2 @@", "-one", "+ONE", " two"].join("\n")
+
+    expect(splitDiffHunks(diff)).toEqual([diff])
+  })
+
+  test("ignores header-like content lines inside a hunk", () => {
+    const diff = [
+      "--- a/file.ts",
+      "+++ b/file.ts",
+      "@@ -1,1 +1,1 @@",
+      "--- not-a-header",
+      "+++ still-not-a-header",
+    ].join("\n")
+
+    expect(splitDiffHunks(diff)).toEqual([diff])
+  })
+
+  test("splits multi-hunk diff and preserves headers", () => {
+    const diff = [
+      "--- a/file.ts",
+      "+++ b/file.ts",
+      "@@ -1,2 +1,2 @@",
+      "-one",
+      "+ONE",
+      " two",
+      "@@ -10,2 +10,2 @@",
+      "-ten",
+      "+TEN",
+      " eleven",
+    ].join("\n")
+
+    expect(splitDiffHunks(diff)).toEqual([
+      ["--- a/file.ts", "+++ b/file.ts", "@@ -1,2 +1,2 @@", "-one", "+ONE", " two"].join("\n"),
+      ["--- a/file.ts", "+++ b/file.ts", "@@ -10,2 +10,2 @@", "-ten", "+TEN", " eleven"].join("\n"),
+    ])
+  })
+
+  test("splits concatenated multi-file diff with per-file headers", () => {
+    const diff = [
+      "--- a/one.ts",
+      "+++ b/one.ts",
+      "@@ -1,2 +1,2 @@",
+      "-one",
+      "+ONE",
+      "--- a/two.ts",
+      "+++ b/two.ts",
+      "@@ -1,2 +1,2 @@",
+      "-two",
+      "+TWO",
+    ].join("\n")
+
+    expect(splitDiffHunks(diff)).toEqual([
+      ["--- a/one.ts", "+++ b/one.ts", "@@ -1,2 +1,2 @@", "-one", "+ONE"].join("\n"),
+      ["--- a/two.ts", "+++ b/two.ts", "@@ -1,2 +1,2 @@", "-two", "+TWO"].join("\n"),
+    ])
+  })
+
+  test("splits multi-file diff when first file has multiple hunks", () => {
+    const diff = [
+      "--- a/one.ts",
+      "+++ b/one.ts",
+      "@@ -1,2 +1,2 @@",
+      "-one",
+      "+ONE",
+      "@@ -10,2 +10,2 @@",
+      "-ten",
+      "+TEN",
+      "--- a/two.ts",
+      "+++ b/two.ts",
+      "@@ -3,2 +3,2 @@",
+      "-two",
+      "+TWO",
+    ].join("\n")
+
+    expect(splitDiffHunks(diff)).toEqual([
+      ["--- a/one.ts", "+++ b/one.ts", "@@ -1,2 +1,2 @@", "-one", "+ONE"].join("\n"),
+      ["--- a/one.ts", "+++ b/one.ts", "@@ -10,2 +10,2 @@", "-ten", "+TEN"].join("\n"),
+      ["--- a/two.ts", "+++ b/two.ts", "@@ -3,2 +3,2 @@", "-two", "+TWO"].join("\n"),
+    ])
+  })
+})

package/test/saeeol/tui-sync.test.ts

@@ -0,0 +1,80 @@
+import { describe, expect, test } from "bun:test"
+import { SaeeolSessionTuiSync } from "../../src/overlay/session/tui-sync"
+
+type Message = {
+  role: string
+  model?: { providerID: string; modelID: string; variant?: string }
+  parts?: readonly { type: string }[]
+}
+
+function syncVariant(input: { current: string | undefined; message: Message; parts?: readonly { type: string }[] }) {
+  if (!SaeeolSessionTuiSync.model({ role: input.message.role, parts: input.parts })) return input.current
+  return input.message.model?.variant ?? "default"
+}
+
+describe("SaeeolSessionTuiSync.model", () => {
+  test("syncs normal user messages", () => {
+    expect(SaeeolSessionTuiSync.model({ role: "user", parts: [{ type: "text" }] })).toBe(true)
+  })
+
+  test("skips compaction marker user messages", () => {
+    expect(SaeeolSessionTuiSync.model({ role: "user", parts: [{ type: "compaction" }] })).toBe(false)
+  })
+
+  test("skips messages before parts load", () => {
+    expect(SaeeolSessionTuiSync.model({ role: "user" })).toBe(false)
+  })
+
+  test("skips messages checked with stored parts", () => {
+    const msg = { role: "user" }
+    const parts = [{ type: "compaction" }]
+
+    expect(SaeeolSessionTuiSync.model({ role: msg.role, parts })).toBe(false)
+  })
+
+  test("skips non-user messages", () => {
+    expect(SaeeolSessionTuiSync.model({ role: "assistant", parts: [{ type: "text" }] })).toBe(false)
+  })
+
+  test("preserves thinking level after /compact", () => {
+    const msg = {
+      role: "user",
+      model: { providerID: "anthropic", modelID: "claude-sonnet-4-5" },
+      parts: [{ type: "compaction" }],
+    }
+
+    expect(syncVariant({ current: "high", message: msg, parts: msg.parts })).toBe("high")
+  })
+
+  test("preserves thinking level when compaction parts are stored separately", () => {
+    const msg = {
+      role: "user",
+      model: { providerID: "anthropic", modelID: "claude-sonnet-4-5" },
+    }
+    const parts = [{ type: "compaction" }]
+
+    expect(parts.some((part) => part.type === "compaction")).toBe(true)
+    expect(syncVariant({ current: "high", message: msg, parts })).toBe("high")
+  })
+
+  test("waits for normal user message parts before syncing", () => {
+    const msg = {
+      role: "user",
+      model: { providerID: "anthropic", modelID: "claude-sonnet-4-5", variant: "max" },
+    }
+    const parts = [{ type: "text" }]
+
+    expect(syncVariant({ current: "high", message: msg })).toBe("high")
+    expect(syncVariant({ current: "high", message: msg, parts })).toBe("max")
+  })
+
+  test("still updates thinking level from normal user messages", () => {
+    const msg = {
+      role: "user",
+      model: { providerID: "anthropic", modelID: "claude-sonnet-4-5", variant: "max" },
+      parts: [{ type: "text" }],
+    }
+
+    expect(syncVariant({ current: "high", message: msg, parts: msg.parts })).toBe("max")
+  })
+})

package/test/saeeol/util/url.test.ts

@@ -0,0 +1,141 @@
+import { describe, expect, test } from "bun:test"
+import { normalizeUrls } from "../../../src/overlay/util/url"
+
+describe("normalizeUrls", () => {
+  describe("homograph / IDN conversion", () => {
+    test("converts Cyrillic look-alike in hostname to punycode", () => {
+      // Cyrillic 'а' (U+0430) is visually identical to Latin 'a'
+      const input = "https://\u0430pitest.com/status"
+      const result = normalizeUrls(input)
+      expect(result).toBe("https://xn--pitest-2nf.com/status")
+      expect(result).not.toContain("\u0430")
+    })
+
+    test("converts mixed-script hostname to punycode", () => {
+      // Mix of Latin and Cyrillic in the same label
+      const input = "https://\u0430pitest.com/path"
+      expect(normalizeUrls(input)).not.toContain("\u0430")
+    })
+
+    test("converts fully unicode TLD to punycode", () => {
+      const input = "https://example.\u4e2d\u56fd"
+      const result = normalizeUrls(input)
+      expect(result).toMatch(/^https:\/\/example\.xn--/)
+    })
+
+    test("handles http scheme as well as https", () => {
+      const input = "http://\u0430pitest.com/path"
+      const result = normalizeUrls(input)
+      expect(result).not.toContain("\u0430")
+      expect(result).toMatch(/^http:\/\/xn--/)
+    })
+  })
+
+  describe("plain ASCII URLs are unchanged", () => {
+    test("leaves a URL with a path untouched", () => {
+      const url = "https://apitest.com/status"
+      expect(normalizeUrls(url)).toBe(url)
+    })
+
+    test("leaves a URL with path and query string untouched", () => {
+      const url = "http://example.com/foo?bar=1&baz=2"
+      expect(normalizeUrls(url)).toBe(url)
+    })
+
+    test("leaves a localhost URL with port untouched", () => {
+      const url = "http://localhost:3000/api"
+      expect(normalizeUrls(url)).toBe(url)
+    })
+
+    test("leaves a bare origin untouched (no trailing slash added)", () => {
+      // Regression: new URL("https://example.com").href === "https://example.com/"
+      // The old implementation using href would mutate bare origins by adding "/".
+      const url = "https://example.com"
+      expect(normalizeUrls(url)).toBe(url)
+    })
+  })
+
+  describe("trailing sentence punctuation is not consumed into the URL", () => {
+    test("period at end of sentence is not consumed (was: adds trailing slash)", () => {
+      // "see https://example.com." — the period ends the sentence, not the URL.
+      // Old behaviour (bug): returned "see https://example.com./"
+      expect(normalizeUrls("see https://example.com.")).toBe("see https://example.com.")
+    })
+
+    test("exclamation mark at end of sentence is not consumed", () => {
+      expect(normalizeUrls("visit https://example.com!")).toBe("visit https://example.com!")
+    })
+
+    test("comma after URL in a list is not consumed", () => {
+      expect(normalizeUrls("check https://example.com, then continue")).toBe("check https://example.com, then continue")
+    })
+
+    test("closing parenthesis after URL is not consumed", () => {
+      expect(normalizeUrls("(see https://example.com)")).toBe("(see https://example.com)")
+    })
+
+    test("trailing punctuation after an IDN URL is stripped correctly and punycode applied", () => {
+      // Trailing period on a homograph URL: period is sentence punctuation, not part of the URL.
+      const input = "see https://\u0430pitest.com."
+      const result = normalizeUrls(input)
+      expect(result).toBe("see https://xn--pitest-2nf.com.")
+      expect(result).not.toContain("\u0430")
+    })
+  })
+
+  describe("URL embedded in a bash command string", () => {
+    test("normalizes the URL portion of a curl command", () => {
+      const input = "curl https://\u0430pitest.com/status"
+      const result = normalizeUrls(input)
+      expect(result).toMatch(/^curl https:\/\/xn--/)
+      expect(result).not.toContain("\u0430")
+    })
+
+    test("preserves flags and pipe around the URL", () => {
+      const input = "curl -sSf https://\u0430pitest.com/status | bash"
+      const result = normalizeUrls(input)
+      expect(result).toMatch(/^curl -sSf /)
+      expect(result).toContain("| bash")
+    })
+
+    test("normalizes multiple URLs in a single command", () => {
+      const input = "curl https://\u0430pitest.com/a && curl https://\u0430pitest.com/b"
+      const result = normalizeUrls(input)
+      expect(result.match(/xn--/g)?.length).toBe(2)
+      expect(result).not.toContain("\u0430")
+    })
+
+    test("leaves a plain-ASCII command entirely unchanged", () => {
+      const input = "curl -sSf https://saeeol.ai/update.sh | bash"
+      expect(normalizeUrls(input)).toBe(input)
+    })
+  })
+
+  describe("edge cases", () => {
+    test("returns empty string unchanged", () => {
+      expect(normalizeUrls("")).toBe("")
+    })
+
+    test("returns text with no URLs unchanged", () => {
+      const text = "just some plain text without links"
+      expect(normalizeUrls(text)).toBe(text)
+    })
+
+    test("does not alter non-http/https schemes", () => {
+      const text = "ftp://example.com and file:///tmp/foo"
+      expect(normalizeUrls(text)).toBe(text)
+    })
+
+    test("preserves path, query string, and fragment after IDN conversion", () => {
+      const input = "https://\u0430pitest.com/path?q=1#anchor"
+      const result = normalizeUrls(input)
+      expect(result).toMatch(/xn--/)
+      expect(result).toContain("/path?q=1#anchor")
+    })
+
+    test("preserves a URL that fails to parse verbatim", () => {
+      const malformed = "https://[unclosed"
+      expect(normalizeUrls(malformed)).toBe(malformed)
+    })
+  })
+})

package/test/saeeol/workflows-migrator.test.ts

@@ -0,0 +1,261 @@
+import { test, expect, describe } from "bun:test"
+import { WorkflowsMigrator } from "../../src/overlay/workflows-migrator"
+import { tmpdir } from "../fixture/fixture"
+import path from "path"
+
+async function withHome<T>(home: string, fn: () => Promise<T>): Promise<T> {
+  const prev = process.env.HOME
+  process.env.HOME = home
+  try {
+    return await fn()
+  } finally {
+    if (prev) process.env.HOME = prev
+    else delete process.env.HOME
+  }
+}
+
+describe("WorkflowsMigrator", () => {
+  describe("extractNameFromFilename", () => {
+    test("extracts name from simple filename", () => {
+      expect(WorkflowsMigrator.extractNameFromFilename("code-review.md")).toBe("code-review")
+    })
+
+    test("extracts name from path", () => {
+      expect(WorkflowsMigrator.extractNameFromFilename("/path/to/my-workflow.md")).toBe("my-workflow")
+    })
+
+    test("handles filename without extension", () => {
+      expect(WorkflowsMigrator.extractNameFromFilename("workflow")).toBe("workflow")
+    })
+  })
+
+  describe("extractDescription", () => {
+    test("extracts description from first paragraph after title", () => {
+      const content = `# My Workflow
+
+This is the description of the workflow.
+
+## Steps
+
+1. Do something`
+
+      expect(WorkflowsMigrator.extractDescription(content)).toBe("This is the description of the workflow.")
+    })
+
+    test("returns undefined when no description found", () => {
+      const content = `# My Workflow`
+      expect(WorkflowsMigrator.extractDescription(content)).toBeUndefined()
+    })
+
+    test("limits description to 200 characters", () => {
+      const longDescription = "A".repeat(300)
+      const content = `# Title
+
+${longDescription}`
+
+      const result = WorkflowsMigrator.extractDescription(content)
+      expect(result?.length).toBe(200)
+    })
+
+    test("skips empty lines after title", () => {
+      const content = `# Title
+
+
+Actual description here.`
+
+      expect(WorkflowsMigrator.extractDescription(content)).toBe("Actual description here.")
+    })
+  })
+
+  describe("discoverWorkflows", () => {
+    test("discovers project workflows", async () => {
+      await using tmp = await tmpdir({
+        init: async (dir) => {
+          const workflowsDir = path.join(dir, ".saeeol", "workflows")
+          await Bun.write(path.join(workflowsDir, "test-workflow.md"), "# Test\n\nDescription")
+        },
+      })
+
+      const workflows = await WorkflowsMigrator.discoverWorkflows(tmp.path, true)
+
+      expect(workflows).toHaveLength(1)
+      expect(workflows[0].name).toBe("test-workflow")
+      expect(workflows[0].source).toBe("project")
+    })
+
+    test("discovers workflows from legacy .saeeol/workflows/", async () => {
+      await using tmp = await tmpdir({
+        init: async (dir) => {
+          const workflowsDir = path.join(dir, ".saeeol", "workflows")
+          await Bun.write(path.join(workflowsDir, "legacy-workflow.md"), "# Legacy\n\nLegacy workflow")
+        },
+      })
+
+      const workflows = await WorkflowsMigrator.discoverWorkflows(tmp.path, true)
+
+      expect(workflows).toHaveLength(1)
+      expect(workflows[0].name).toBe("legacy-workflow")
+      expect(workflows[0].source).toBe("project")
+    })
+
+    test("returns empty array when no workflows directory exists", async () => {
+      await using tmp = await tmpdir()
+
+      const workflows = await WorkflowsMigrator.discoverWorkflows(tmp.path, true)
+
+      expect(workflows).toHaveLength(0)
+    })
+
+    test("only discovers .md files", async () => {
+      await using tmp = await tmpdir({
+        init: async (dir) => {
+          const workflowsDir = path.join(dir, ".saeeol", "workflows")
+          await Bun.write(path.join(workflowsDir, "workflow.md"), "# Workflow")
+          await Bun.write(path.join(workflowsDir, "readme.txt"), "Not a workflow")
+          await Bun.write(path.join(workflowsDir, "config.json"), "{}")
+        },
+      })
+
+      const workflows = await WorkflowsMigrator.discoverWorkflows(tmp.path, true)
+
+      expect(workflows).toHaveLength(1)
+      expect(workflows[0].name).toBe("workflow")
+    })
+
+    test("discovers global workflows from ~/.saeeol/workflows/", async () => {
+      await using tmp = await tmpdir({
+        init: async (dir) => {
+          await Bun.write(path.join(dir, ".saeeol", "workflows", "global.md"), "# Global\n\nGlobal workflow")
+          await Bun.write(path.join(dir, "repo", "README.md"), "repo")
+        },
+      })
+
+      const workflows = await withHome(tmp.path, () => WorkflowsMigrator.discoverWorkflows(path.join(tmp.path, "repo")))
+
+      expect(
+        workflows.some((w) => w.source === "global" && w.path.includes(path.join(".saeeol", "workflows", "global.md"))),
+      ).toBe(true)
+    })
+
+    test("applies markdown substitutions to workflow content", async () => {
+      process.env.SAEEOL_WORKFLOW_TEST = "env content"
+      await using tmp = await tmpdir({
+        init: async (dir) => {
+          const workflowsDir = path.join(dir, ".saeeol", "workflows")
+          await Bun.write(path.join(dir, "guide.md"), "file content")
+          await Bun.write(
+            path.join(workflowsDir, "workflow.md"),
+            ["# Workflow", "", "{file:../../guide.md}", "{env:SAEEOL_WORKFLOW_TEST}"].join("\n"),
+          )
+        },
+      })
+
+      try {
+        const workflows = await WorkflowsMigrator.discoverWorkflows(tmp.path, true)
+
+        expect(workflows[0].content).toContain("file content")
+        expect(workflows[0].content).toContain("env content")
+      } finally {
+        delete process.env.SAEEOL_WORKFLOW_TEST
+      }
+    })
+  })
+
+  describe("convertToCommand", () => {
+    test("converts workflow to command format", () => {
+      const workflow: WorkflowsMigrator.SaeeolWorkflow = {
+        name: "code-review",
+        path: "/path/to/code-review.md",
+        content: "# Code Review\n\nReview the code changes.\n\n## Steps\n\n1. Check",
+        source: "project",
+      }
+
+      const command = WorkflowsMigrator.convertToCommand(workflow)
+
+      expect(command.template).toBe(workflow.content)
+      expect(command.description).toBe("Review the code changes.")
+    })
+
+    test("uses fallback description when none found", () => {
+      const workflow: WorkflowsMigrator.SaeeolWorkflow = {
+        name: "simple",
+        path: "/path/to/simple.md",
+        content: "# Simple",
+        source: "project",
+      }
+
+      const command = WorkflowsMigrator.convertToCommand(workflow)
+
+      expect(command.description).toBe("Workflow: simple")
+    })
+  })
+
+  describe("migrate", () => {
+    test("migrates project workflows to commands", async () => {
+      await using tmp = await tmpdir({
+        init: async (dir) => {
+          const workflowsDir = path.join(dir, ".saeeol", "workflows")
+          await Bun.write(
+            path.join(workflowsDir, "code-review.md"),
+            "# Code Review\n\nPerform a code review.\n\n## Steps\n\n1. Review",
+          )
+        },
+      })
+
+      const result = await WorkflowsMigrator.migrate({ projectDir: tmp.path, skipGlobalPaths: true })
+
+      expect(Object.keys(result.commands)).toHaveLength(1)
+      expect(result.commands["code-review"]).toBeDefined()
+      expect(result.commands["code-review"].template).toContain("# Code Review")
+      expect(result.commands["code-review"].description).toBe("Perform a code review.")
+    })
+
+    test("returns empty commands when no workflows exist", async () => {
+      await using tmp = await tmpdir()
+
+      const result = await WorkflowsMigrator.migrate({ projectDir: tmp.path, skipGlobalPaths: true })
+
+      expect(Object.keys(result.commands)).toHaveLength(0)
+      expect(result.warnings).toHaveLength(0)
+    })
+
+    test("migrates multiple workflows", async () => {
+      await using tmp = await tmpdir({
+        init: async (dir) => {
+          const workflowsDir = path.join(dir, ".saeeol", "workflows")
+          await Bun.write(path.join(workflowsDir, "review.md"), "# Review\n\nReview code")
+          await Bun.write(path.join(workflowsDir, "deploy.md"), "# Deploy\n\nDeploy app")
+        },
+      })
+
+      const result = await WorkflowsMigrator.migrate({ projectDir: tmp.path, skipGlobalPaths: true })
+
+      expect(Object.keys(result.commands)).toHaveLength(2)
+      expect(result.commands["review"]).toBeDefined()
+      expect(result.commands["deploy"]).toBeDefined()
+    })
+
+    test("project workflows override global workflows with same name", async () => {
+      await using tmp = await tmpdir({
+        init: async (dir) => {
+          // Create a "global" directory to simulate global workflows
+          const globalDir = path.join(dir, "global-workflows")
+          await Bun.write(path.join(globalDir, "shared.md"), "# Shared\n\nGlobal version")
+
+          // Create project workflows
+          const projectDir = path.join(dir, ".saeeol", "workflows")
+          await Bun.write(path.join(projectDir, "shared.md"), "# Shared\n\nProject version")
+
+          return globalDir
+        },
+      })
+
+      // Note: We can't easily test global workflow override without mocking the home directory
+      // This test verifies the deduplication logic works for project workflows
+      const result = await WorkflowsMigrator.migrate({ projectDir: tmp.path, skipGlobalPaths: true })
+
+      expect(Object.keys(result.commands)).toHaveLength(1)
+      expect(result.commands["shared"].template).toContain("Project version")
+    })
+  })
+})