EveryInc/compound-engineering-plugin · error · Error

Target ${targetName} is registered but not implemented yet.

Error message

Target ${targetName} is registered but not implemented yet.

What it means

The `targets` registry can contain placeholder entries marked `implemented: false` (per the documented provider-addition checklist, a handler is added with implemented:false until complete). If you select such a target, `run` throws this error after the registry lookup succeeds — the target exists but its convert/write pipeline is not built yet.

Source

Thrown at src/commands/convert.ts:151

        const writeScope =
          tool.name === "opencode" ? resolveOpenCodeWriteScope(hasExplicitOutput, undefined) : undefined
        await handler.write(root, bundle, writeScope)
        console.log(`Converted ${plugin.manifest.name} to ${tool.name} at ${root}`)
      }

      if (activeTargets.some((t) => t.name === "codex")) {
        await stripCodexAgentsToolMap(codexHome)
      }
      return
    }

    const target = targets[targetName]
    if (!target) {
      throw new Error(`Unknown target: ${targetName}`)
    }

    if (!target.implemented) {
      throw new Error(`Target ${targetName} is registered but not implemented yet.`)
    }

    const resolvedScope = validateScope(targetName, target, args.scope ? String(args.scope) : undefined)

    const primaryOutputRoot = resolveTargetOutputRoot({
      targetName,
      outputRoot,
      codexHome,
      piHome,
      pluginName: plugin.manifest.name,
      hasExplicitOutput,
      scope: resolvedScope,
    })
    const bundle = target.convert(plugin, options)
    if (!bundle) {
      throw new Error(`Target ${targetName} did not return a bundle.`)
    }

View on GitHub (pinned to c9c10f8c75)

Solutions

1. Use a fully implemented target instead: opencode, codex, pi, or antigravity.
2. If you're developing the target, implement its `convert` and `write` handlers and flip `implemented: true` in src/targets/index.ts.
3. If you need the target in production, upgrade to a CLI version where the target's implementation landed.

Example fix

// in src/targets/index.ts, before
mytarget: { name: "mytarget", implemented: false, ... }
// after (once convert/write are implemented)
mytarget: { name: "mytarget", implemented: true, convert: convertClaudeToMyTarget, write: writeMyTargetBundle }

import { targets } from "./src/targets/index"
const t = targets[targetName]
if (!t) throw new Error(`Unknown target: ${targetName}`)
if (!t.implemented) throw new Error(`Target '${targetName}' is a stub in this build — use opencode/codex/pi/antigravity or upgrade the CLI.`)

function isImplementedTarget(name: string): boolean {
  const t = (targets as Record<string, { implemented?: boolean }>)[name]
  return Boolean(t?.implemented)
}

try {
  await convert({ to: targetName })
} catch (e) {
  if (e instanceof Error && /registered but not implemented/.test(e.message)) {
    console.error(`Target '${targetName}' is not finished in this build; pick an implemented target.`)
  } else throw e
}

When it happens

Trigger: Running `convert --to <name>` where targets[<name>] exists but has implemented:false — e.g. an in-development target added by a contributor following the new-provider checklist, in a branch or unreleased build.

Common situations: Working on a feature branch where a new target stub was registered; running from source at a commit mid-development; documentation mentioning a forthcoming target before its release.

Related errors

• Cleanup currently supports only the compound-engineering plu
• Unknown cleanup target: ${target}. Use one of: ${cleanupTarg
• Local plugin path not found: ${directPath}
• Unknown bundled plugin: ${input}
• Unknown permissions mode: ${permissions}

AI-assisted analysis of EveryInc/compound-engineering-plugin@c9c10f8c75 (2026-08-31). Data as JSON: /api/errors/bb41b5694a23108a. Report an issue: GitHub.