@every-env/compound-plugin 2.40.1 → 2.40.3

package/src/parsers/claude-home.ts

@@ -41,8 +41,18 @@ async function loadPersonalSkills(skillsDir: string): Promise<ClaudeSkill[]> {
         const sourceDir = entry.isSymbolicLink()
           ? await fs.realpath(entryPath)
           : entryPath
+        let data: Record<string, unknown> = {}
+        try {
+          const raw = await fs.readFile(skillPath, "utf8")
+          data = parseFrontmatter(raw).data
+        } catch {
+          // Keep syncing the skill even if frontmatter is malformed.
+        }
         skills.push({
           name: entry.name,
+          description: data.description as string | undefined,
+          argumentHint: data["argument-hint"] as string | undefined,
+          disableModelInvocation: data["disable-model-invocation"] === true ? true : undefined,
           sourceDir,
           skillPath,
         })

package/src/parsers/claude.ts

@@ -110,6 +110,7 @@ async function loadSkills(skillsDirs: string[]): Promise<ClaudeSkill[]> {
     skills.push({
       name,
       description: data.description as string | undefined,
+      argumentHint: data["argument-hint"] as string | undefined,
       disableModelInvocation,
       sourceDir: path.dirname(file),
       skillPath: file,

package/src/targets/codex.ts

@@ -1,7 +1,9 @@
+import { promises as fs } from "fs"
 import path from "path"
-import { backupFile, copyDir, ensureDir, writeText } from "../utils/files"
+import { backupFile, ensureDir, readText, writeText } from "../utils/files"
 import type { CodexBundle } from "../types/codex"
 import type { ClaudeMcpServer } from "../types/claude"
+import { transformContentForCodex } from "../utils/codex-content"
 
 export async function writeCodexBundle(outputRoot: string, bundle: CodexBundle): Promise<void> {
   const codexRoot = resolveCodexRoot(outputRoot)
@@ -17,7 +19,11 @@ export async function writeCodexBundle(outputRoot: string, bundle: CodexBundle):
   if (bundle.skillDirs.length > 0) {
     const skillsRoot = path.join(codexRoot, "skills")
     for (const skill of bundle.skillDirs) {
-      await copyDir(skill.sourceDir, path.join(skillsRoot, skill.name))
+      await copyCodexSkillDir(
+        skill.sourceDir,
+        path.join(skillsRoot, skill.name),
+        bundle.invocationTargets,
+      )
     }
   }
 
@@ -39,6 +45,41 @@ export async function writeCodexBundle(outputRoot: string, bundle: CodexBundle):
   }
 }
 
+async function copyCodexSkillDir(
+  sourceDir: string,
+  targetDir: string,
+  invocationTargets?: CodexBundle["invocationTargets"],
+): Promise<void> {
+  await ensureDir(targetDir)
+  const entries = await fs.readdir(sourceDir, { withFileTypes: true })
+
+  for (const entry of entries) {
+    const sourcePath = path.join(sourceDir, entry.name)
+    const targetPath = path.join(targetDir, entry.name)
+
+    if (entry.isDirectory()) {
+      await copyCodexSkillDir(sourcePath, targetPath, invocationTargets)
+      continue
+    }
+
+    if (!entry.isFile()) continue
+
+    if (entry.name === "SKILL.md") {
+      const content = await readText(sourcePath)
+      await writeText(
+        targetPath,
+        transformContentForCodex(content, invocationTargets, {
+          unknownSlashBehavior: "preserve",
+        }),
+      )
+      continue
+    }
+
+    await ensureDir(path.dirname(targetPath))
+    await fs.copyFile(sourcePath, targetPath)
+  }
+}
+
 function resolveCodexRoot(outputRoot: string): string {
   return path.basename(outputRoot) === ".codex" ? outputRoot : path.join(outputRoot, ".codex")
 }

package/src/types/claude.ts

@@ -47,6 +47,7 @@ export type ClaudeCommand = {
 export type ClaudeSkill = {
   name: string
   description?: string
+  argumentHint?: string
   disableModelInvocation?: boolean
   sourceDir: string
   skillPath: string

package/src/types/codex.ts

@@ -1,4 +1,5 @@
 import type { ClaudeMcpServer } from "./claude"
+import type { CodexInvocationTargets } from "../utils/codex-content"
 
 export type CodexPrompt = {
   name: string
@@ -19,5 +20,6 @@ export type CodexBundle = {
   prompts: CodexPrompt[]
   skillDirs: CodexSkillDir[]
   generatedSkills: CodexGeneratedSkill[]
+  invocationTargets?: CodexInvocationTargets
   mcpServers?: Record<string, ClaudeMcpServer>
 }

package/src/utils/codex-content.ts

@@ -0,0 +1,84 @@
+export type CodexInvocationTargets = {
+  promptTargets: Record<string, string>
+  skillTargets: Record<string, string>
+}
+
+export type CodexTransformOptions = {
+  unknownSlashBehavior?: "prompt" | "preserve"
+}
+
+/**
+ * Transform Claude Code content to Codex-compatible content.
+ *
+ * Handles multiple syntax differences:
+ * 1. Task agent calls: Task agent-name(args) -> Use the $agent-name skill to: args
+ * 2. Slash command references:
+ *    - known prompt entrypoints -> /prompts:prompt-name
+ *    - known skills -> the exact skill name
+ *    - unknown slash refs -> /prompts:command-name
+ * 3. Agent references: @agent-name -> $agent-name skill
+ * 4. Claude config paths: .claude/ -> .codex/
+ */
+export function transformContentForCodex(
+  body: string,
+  targets?: CodexInvocationTargets,
+  options: CodexTransformOptions = {},
+): string {
+  let result = body
+  const promptTargets = targets?.promptTargets ?? {}
+  const skillTargets = targets?.skillTargets ?? {}
+  const unknownSlashBehavior = options.unknownSlashBehavior ?? "prompt"
+
+  const taskPattern = /^(\s*-?\s*)Task\s+([a-z][a-z0-9:-]*)\(([^)]+)\)/gm
+  result = result.replace(taskPattern, (_match, prefix: string, agentName: string, args: string) => {
+    // For namespaced calls like "compound-engineering:research:repo-research-analyst",
+    // use only the final segment as the skill name.
+    const finalSegment = agentName.includes(":") ? agentName.split(":").pop()! : agentName
+    const skillName = normalizeCodexName(finalSegment)
+    const trimmedArgs = args.trim()
+    return `${prefix}Use the $${skillName} skill to: ${trimmedArgs}`
+  })
+
+  const slashCommandPattern = /(?<![:\w])\/([a-z][a-z0-9_:-]*?)(?=[\s,."')\]}`]|$)/gi
+  result = result.replace(slashCommandPattern, (match, commandName: string) => {
+    if (commandName.includes("/")) return match
+    if (["dev", "tmp", "etc", "usr", "var", "bin", "home"].includes(commandName)) return match
+
+    const normalizedName = normalizeCodexName(commandName)
+    if (promptTargets[normalizedName]) {
+      return `/prompts:${promptTargets[normalizedName]}`
+    }
+    if (skillTargets[normalizedName]) {
+      return `the ${skillTargets[normalizedName]} skill`
+    }
+    if (unknownSlashBehavior === "preserve") {
+      return match
+    }
+    return `/prompts:${normalizedName}`
+  })
+
+  result = result
+    .replace(/~\/\.claude\//g, "~/.codex/")
+    .replace(/\.claude\//g, ".codex/")
+
+  const agentRefPattern = /@([a-z][a-z0-9-]*-(?:agent|reviewer|researcher|analyst|specialist|oracle|sentinel|guardian|strategist))/gi
+  result = result.replace(agentRefPattern, (_match, agentName: string) => {
+    const skillName = normalizeCodexName(agentName)
+    return `$${skillName} skill`
+  })
+
+  return result
+}
+
+export function normalizeCodexName(value: string): string {
+  const trimmed = value.trim()
+  if (!trimmed) return "item"
+  const normalized = trimmed
+    .toLowerCase()
+    .replace(/[\\/]+/g, "-")
+    .replace(/[:\s]+/g, "-")
+    .replace(/[^a-z0-9_-]+/g, "-")
+    .replace(/-+/g, "-")
+    .replace(/^-+|-+$/g, "")
+  return normalized || "item"
+}

package/tests/claude-home.test.ts

@@ -43,4 +43,40 @@ describe("loadClaudeHome", () => {
     expect(config.commands?.find((command) => command.name === "custom-command")?.allowedTools).toEqual(["Bash", "Read"])
     expect(config.mcpServers.context7?.url).toBe("https://mcp.context7.com/mcp")
   })
+
+  test("keeps personal skill directory names stable even when frontmatter name differs", async () => {
+    const tempHome = await fs.mkdtemp(path.join(os.tmpdir(), "claude-home-skill-name-"))
+    const skillDir = path.join(tempHome, "skills", "reviewer")
+
+    await fs.mkdir(skillDir, { recursive: true })
+    await fs.writeFile(
+      path.join(skillDir, "SKILL.md"),
+      "---\nname: ce:plan\ndescription: Reviewer skill\nargument-hint: \"[topic]\"\n---\nReview things.\n",
+    )
+
+    const config = await loadClaudeHome(tempHome)
+
+    expect(config.skills).toHaveLength(1)
+    expect(config.skills[0]?.name).toBe("reviewer")
+    expect(config.skills[0]?.description).toBe("Reviewer skill")
+    expect(config.skills[0]?.argumentHint).toBe("[topic]")
+  })
+
+  test("keeps personal skills when frontmatter is malformed", async () => {
+    const tempHome = await fs.mkdtemp(path.join(os.tmpdir(), "claude-home-skill-yaml-"))
+    const skillDir = path.join(tempHome, "skills", "reviewer")
+
+    await fs.mkdir(skillDir, { recursive: true })
+    await fs.writeFile(
+      path.join(skillDir, "SKILL.md"),
+      "---\nname: ce:plan\nfoo: [unterminated\n---\nReview things.\n",
+    )
+
+    const config = await loadClaudeHome(tempHome)
+
+    expect(config.skills).toHaveLength(1)
+    expect(config.skills[0]?.name).toBe("reviewer")
+    expect(config.skills[0]?.description).toBeUndefined()
+    expect(config.skills[0]?.argumentHint).toBeUndefined()
+  })
 })

package/tests/codex-converter.test.ts

@@ -31,6 +31,7 @@ const fixturePlugin: ClaudePlugin = {
     {
       name: "existing-skill",
       description: "Existing skill",
+      argumentHint: "[ITEM]",
       sourceDir: "/tmp/plugin/skills/existing-skill",
       skillPath: "/tmp/plugin/skills/existing-skill/SKILL.md",
     },
@@ -78,6 +79,81 @@ describe("convertClaudeToCodex", () => {
     expect(parsedSkill.body).toContain("Threat modeling")
   })
 
+  test("generates prompt wrappers for canonical ce workflow skills and omits workflows aliases", () => {
+    const plugin: ClaudePlugin = {
+      ...fixturePlugin,
+      manifest: { name: "compound-engineering", version: "1.0.0" },
+      commands: [],
+      agents: [],
+      skills: [
+        {
+          name: "ce:plan",
+          description: "Planning workflow",
+          argumentHint: "[feature]",
+          sourceDir: "/tmp/plugin/skills/ce-plan",
+          skillPath: "/tmp/plugin/skills/ce-plan/SKILL.md",
+        },
+        {
+          name: "workflows:plan",
+          description: "Deprecated planning alias",
+          argumentHint: "[feature]",
+          sourceDir: "/tmp/plugin/skills/workflows-plan",
+          skillPath: "/tmp/plugin/skills/workflows-plan/SKILL.md",
+        },
+      ],
+    }
+
+    const bundle = convertClaudeToCodex(plugin, {
+      agentMode: "subagent",
+      inferTemperature: false,
+      permissions: "none",
+    })
+
+    expect(bundle.prompts).toHaveLength(1)
+    expect(bundle.prompts[0]?.name).toBe("ce-plan")
+
+    const parsedPrompt = parseFrontmatter(bundle.prompts[0]!.content)
+    expect(parsedPrompt.data.description).toBe("Planning workflow")
+    expect(parsedPrompt.data["argument-hint"]).toBe("[feature]")
+    expect(parsedPrompt.body).toContain("Use the ce:plan skill")
+
+    expect(bundle.skillDirs.map((skill) => skill.name)).toEqual(["ce:plan"])
+  })
+
+  test("does not apply compound workflow canonicalization to other plugins", () => {
+    const plugin: ClaudePlugin = {
+      ...fixturePlugin,
+      manifest: { name: "other-plugin", version: "1.0.0" },
+      commands: [],
+      agents: [],
+      skills: [
+        {
+          name: "ce:plan",
+          description: "Custom CE-namespaced skill",
+          argumentHint: "[feature]",
+          sourceDir: "/tmp/plugin/skills/ce-plan",
+          skillPath: "/tmp/plugin/skills/ce-plan/SKILL.md",
+        },
+        {
+          name: "workflows:plan",
+          description: "Custom workflows-namespaced skill",
+          argumentHint: "[feature]",
+          sourceDir: "/tmp/plugin/skills/workflows-plan",
+          skillPath: "/tmp/plugin/skills/workflows-plan/SKILL.md",
+        },
+      ],
+    }
+
+    const bundle = convertClaudeToCodex(plugin, {
+      agentMode: "subagent",
+      inferTemperature: false,
+      permissions: "none",
+    })
+
+    expect(bundle.prompts).toHaveLength(0)
+    expect(bundle.skillDirs.map((skill) => skill.name)).toEqual(["ce:plan", "workflows:plan"])
+  })
+
   test("passes through MCP servers", () => {
     const bundle = convertClaudeToCodex(fixturePlugin, {
       agentMode: "subagent",
@@ -131,6 +207,47 @@ Task best-practices-researcher(topic)`,
     expect(parsed.body).not.toContain("Task learnings-researcher")
   })
 
+  test("transforms namespaced Task agent calls to skill references using final segment", () => {
+    const plugin: ClaudePlugin = {
+      ...fixturePlugin,
+      commands: [
+        {
+          name: "plan",
+          description: "Planning with namespaced agents",
+          body: `Run these agents in parallel:
+
+- Task compound-engineering:research:repo-research-analyst(feature_description)
+- Task compound-engineering:research:learnings-researcher(feature_description)
+
+Then consolidate findings.
+
+Task compound-engineering:review:security-reviewer(code_diff)`,
+          sourcePath: "/tmp/plugin/commands/plan.md",
+        },
+      ],
+      agents: [],
+      skills: [],
+    }
+
+    const bundle = convertClaudeToCodex(plugin, {
+      agentMode: "subagent",
+      inferTemperature: false,
+      permissions: "none",
+    })
+
+    const commandSkill = bundle.generatedSkills.find((s) => s.name === "plan")
+    expect(commandSkill).toBeDefined()
+    const parsed = parseFrontmatter(commandSkill!.content)
+
+    // Namespaced Task calls should use only the final segment as the skill name
+    expect(parsed.body).toContain("Use the $repo-research-analyst skill to: feature_description")
+    expect(parsed.body).toContain("Use the $learnings-researcher skill to: feature_description")
+    expect(parsed.body).toContain("Use the $security-reviewer skill to: code_diff")
+
+    // Original namespaced Task syntax should not remain
+    expect(parsed.body).not.toContain("Task compound-engineering:")
+  })
+
   test("transforms slash commands to prompts syntax", () => {
     const plugin: ClaudePlugin = {
       ...fixturePlugin,
@@ -172,6 +289,61 @@ Don't confuse with file paths like /tmp/output.md or /dev/null.`,
     expect(parsed.body).toContain("/dev/null")
   })
 
+  test("transforms canonical workflow slash commands to Codex prompt references", () => {
+    const plugin: ClaudePlugin = {
+      ...fixturePlugin,
+      manifest: { name: "compound-engineering", version: "1.0.0" },
+      commands: [
+        {
+          name: "review",
+          description: "Review command",
+          body: `After the brainstorm, run /ce:plan.
+
+If planning is complete, continue with /ce:work.`,
+          sourcePath: "/tmp/plugin/commands/review.md",
+        },
+      ],
+      agents: [],
+      skills: [
+        {
+          name: "ce:plan",
+          description: "Planning workflow",
+          argumentHint: "[feature]",
+          sourceDir: "/tmp/plugin/skills/ce-plan",
+          skillPath: "/tmp/plugin/skills/ce-plan/SKILL.md",
+        },
+        {
+          name: "ce:work",
+          description: "Implementation workflow",
+          argumentHint: "[feature]",
+          sourceDir: "/tmp/plugin/skills/ce-work",
+          skillPath: "/tmp/plugin/skills/ce-work/SKILL.md",
+        },
+        {
+          name: "workflows:work",
+          description: "Deprecated implementation alias",
+          argumentHint: "[feature]",
+          sourceDir: "/tmp/plugin/skills/workflows-work",
+          skillPath: "/tmp/plugin/skills/workflows-work/SKILL.md",
+        },
+      ],
+    }
+
+    const bundle = convertClaudeToCodex(plugin, {
+      agentMode: "subagent",
+      inferTemperature: false,
+      permissions: "none",
+    })
+
+    const commandSkill = bundle.generatedSkills.find((s) => s.name === "review")
+    expect(commandSkill).toBeDefined()
+    const parsed = parseFrontmatter(commandSkill!.content)
+
+    expect(parsed.body).toContain("/prompts:ce-plan")
+    expect(parsed.body).toContain("/prompts:ce-work")
+    expect(parsed.body).not.toContain("the ce:plan skill")
+  })
+
   test("excludes commands with disable-model-invocation from prompts and skills", () => {
     const plugin: ClaudePlugin = {
       ...fixturePlugin,

package/tests/codex-writer.test.ts

@@ -105,4 +105,158 @@ describe("writeCodexBundle", () => {
     const backupContent = await fs.readFile(path.join(codexRoot, backupFileName!), "utf8")
     expect(backupContent).toBe(originalContent)
   })
+
+  test("transforms copied SKILL.md files using Codex invocation targets", async () => {
+    const tempRoot = await fs.mkdtemp(path.join(os.tmpdir(), "codex-skill-transform-"))
+    const sourceSkillDir = path.join(tempRoot, "source-skill")
+    await fs.mkdir(sourceSkillDir, { recursive: true })
+    await fs.writeFile(
+      path.join(sourceSkillDir, "SKILL.md"),
+      `---
+name: ce:brainstorm
+description: Brainstorm workflow
+---
+
+Continue with /ce:plan when ready.
+Or use /workflows:plan if you're following an older doc.
+Use /deepen-plan for deeper research.
+`,
+    )
+    await fs.writeFile(
+      path.join(sourceSkillDir, "notes.md"),
+      "Reference docs still mention /ce:plan here.\n",
+    )
+
+    const bundle: CodexBundle = {
+      prompts: [],
+      skillDirs: [{ name: "ce:brainstorm", sourceDir: sourceSkillDir }],
+      generatedSkills: [],
+      invocationTargets: {
+        promptTargets: {
+          "ce-plan": "ce-plan",
+          "workflows-plan": "ce-plan",
+          "deepen-plan": "deepen-plan",
+        },
+        skillTargets: {},
+      },
+    }
+
+    await writeCodexBundle(tempRoot, bundle)
+
+    const installedSkill = await fs.readFile(
+      path.join(tempRoot, ".codex", "skills", "ce:brainstorm", "SKILL.md"),
+      "utf8",
+    )
+    expect(installedSkill).toContain("/prompts:ce-plan")
+    expect(installedSkill).not.toContain("/workflows:plan")
+    expect(installedSkill).toContain("/prompts:deepen-plan")
+
+    const notes = await fs.readFile(
+      path.join(tempRoot, ".codex", "skills", "ce:brainstorm", "notes.md"),
+      "utf8",
+    )
+    expect(notes).toContain("/ce:plan")
+  })
+
+  test("transforms namespaced Task calls in copied SKILL.md files", async () => {
+    const tempRoot = await fs.mkdtemp(path.join(os.tmpdir(), "codex-ns-task-"))
+    const sourceSkillDir = path.join(tempRoot, "source-skill")
+    await fs.mkdir(sourceSkillDir, { recursive: true })
+    await fs.writeFile(
+      path.join(sourceSkillDir, "SKILL.md"),
+      `---
+name: ce:plan
+description: Planning workflow
+---
+
+Run these research agents:
+
+- Task compound-engineering:research:repo-research-analyst(feature_description)
+- Task compound-engineering:research:learnings-researcher(feature_description)
+
+Also run bare agents:
+
+- Task best-practices-researcher(topic)
+`,
+    )
+
+    const bundle: CodexBundle = {
+      prompts: [],
+      skillDirs: [{ name: "ce:plan", sourceDir: sourceSkillDir }],
+      generatedSkills: [],
+      invocationTargets: {
+        promptTargets: {},
+        skillTargets: {},
+      },
+    }
+
+    await writeCodexBundle(tempRoot, bundle)
+
+    const installedSkill = await fs.readFile(
+      path.join(tempRoot, ".codex", "skills", "ce:plan", "SKILL.md"),
+      "utf8",
+    )
+
+    // Namespaced Task calls should be rewritten using the final segment
+    expect(installedSkill).toContain("Use the $repo-research-analyst skill to: feature_description")
+    expect(installedSkill).toContain("Use the $learnings-researcher skill to: feature_description")
+    expect(installedSkill).not.toContain("Task compound-engineering:")
+
+    // Bare Task calls should still be rewritten
+    expect(installedSkill).toContain("Use the $best-practices-researcher skill to: topic")
+    expect(installedSkill).not.toContain("Task best-practices-researcher")
+  })
+
+  test("preserves unknown slash text in copied SKILL.md files", async () => {
+    const tempRoot = await fs.mkdtemp(path.join(os.tmpdir(), "codex-skill-preserve-"))
+    const sourceSkillDir = path.join(tempRoot, "source-skill")
+    await fs.mkdir(sourceSkillDir, { recursive: true })
+    await fs.writeFile(
+      path.join(sourceSkillDir, "SKILL.md"),
+      `---
+name: proof
+description: Proof skill
+---
+
+Route examples:
+- /users
+- /settings
+
+API examples:
+- https://www.proofeditor.ai/api/agent/{slug}/state
+- https://www.proofeditor.ai/share/markdown
+
+Workflow handoff:
+- /ce:plan
+`,
+    )
+
+    const bundle: CodexBundle = {
+      prompts: [],
+      skillDirs: [{ name: "proof", sourceDir: sourceSkillDir }],
+      generatedSkills: [],
+      invocationTargets: {
+        promptTargets: {
+          "ce-plan": "ce-plan",
+        },
+        skillTargets: {},
+      },
+    }
+
+    await writeCodexBundle(tempRoot, bundle)
+
+    const installedSkill = await fs.readFile(
+      path.join(tempRoot, ".codex", "skills", "proof", "SKILL.md"),
+      "utf8",
+    )
+
+    expect(installedSkill).toContain("/users")
+    expect(installedSkill).toContain("/settings")
+    expect(installedSkill).toContain("https://www.proofeditor.ai/api/agent/{slug}/state")
+    expect(installedSkill).toContain("https://www.proofeditor.ai/share/markdown")
+    expect(installedSkill).toContain("/prompts:ce-plan")
+    expect(installedSkill).not.toContain("/prompts:users")
+    expect(installedSkill).not.toContain("/prompts:settings")
+    expect(installedSkill).not.toContain("https://prompts:www.proofeditor.ai")
+  })
 })

package/plugins/compound-engineering/skills/workflows-brainstorm/SKILL.md

@@ -1,10 +0,0 @@
----
-name: workflows:brainstorm
-description: "[DEPRECATED] Use /ce:brainstorm instead — renamed for clarity."
-argument-hint: "[feature idea or problem to explore]"
-disable-model-invocation: true
----
-
-NOTE: /workflows:brainstorm is deprecated. Please use /ce:brainstorm instead. This alias will be removed in a future version.
-
-/ce:brainstorm $ARGUMENTS

package/plugins/compound-engineering/skills/workflows-compound/SKILL.md

@@ -1,10 +0,0 @@
----
-name: workflows:compound
-description: "[DEPRECATED] Use /ce:compound instead — renamed for clarity."
-argument-hint: "[optional: brief context about the fix]"
-disable-model-invocation: true
----
-
-NOTE: /workflows:compound is deprecated. Please use /ce:compound instead. This alias will be removed in a future version.
-
-/ce:compound $ARGUMENTS

package/plugins/compound-engineering/skills/workflows-plan/SKILL.md

@@ -1,10 +0,0 @@
----
-name: workflows:plan
-description: "[DEPRECATED] Use /ce:plan instead — renamed for clarity."
-argument-hint: "[feature description, bug report, or improvement idea]"
-disable-model-invocation: true
----
-
-NOTE: /workflows:plan is deprecated. Please use /ce:plan instead. This alias will be removed in a future version.
-
-/ce:plan $ARGUMENTS

package/plugins/compound-engineering/skills/workflows-review/SKILL.md

@@ -1,10 +0,0 @@
----
-name: workflows:review
-description: "[DEPRECATED] Use /ce:review instead — renamed for clarity."
-argument-hint: "[PR number, GitHub URL, branch name, or latest]"
-disable-model-invocation: true
----
-
-NOTE: /workflows:review is deprecated. Please use /ce:review instead. This alias will be removed in a future version.
-
-/ce:review $ARGUMENTS

package/plugins/compound-engineering/skills/workflows-work/SKILL.md

@@ -1,10 +0,0 @@
----
-name: workflows:work
-description: "[DEPRECATED] Use /ce:work instead — renamed for clarity."
-argument-hint: "[plan file, specification, or todo file path]"
-disable-model-invocation: true
----
-
-NOTE: /workflows:work is deprecated. Please use /ce:work instead. This alias will be removed in a future version.
-
-/ce:work $ARGUMENTS