agentsclimarketplace

Delegate implementation

Skill kwintin/ensemble/skills/delegate-implementation

Route one well-scoped implementation unit to the strength-matched executor model, run it write-enabled in an isolated git worktree, verify it in a clean state, then merge or reroute. Use for Ensemble delegation or when offloading a self-contained coding unit to another model CLI.From its SKILL.md

Install
npx -y skills add kwintin/ensemble --skill delegate-implementation

Assembled from the repository path, not quoted from the project. Check it against their README if it does not work.

2 things to look at

  • no licenseNo license file was found in the repository. Code published without one is not open source by default, so using it at work is a question for whoever answers licensing questions where you are.
  • 1 stars1 stars. Stars are a popularity signal and not a quality one, but at this level it is likely that nobody has read this closely except its author, and you would be relying on your own review.

SKILL.md

5.1 KB, as published. Nobody here has run it

Delegate Implementation (strength-routed)

Offload ONE well-scoped unit to the best-fit executor model, verify it yourself, then merge. You stay the architect and the verification oracle; the executor is a hired hand working in a sandboxed copy.

Launcher

Prefer the plugin root the host exports, and fall back to this skill's own location. Set SKILL_DIR to the absolute directory containing this loaded SKILL.md, then set:

ENSEMBLE_ROOT="${ENSEMBLE_PLUGIN_ROOT:-${PLUGIN_ROOT:-${CLAUDE_PLUGIN_ROOT:-$(cd "$SKILL_DIR/../.." && pwd)}}}"
ENSEMBLE="$ENSEMBLE_ROOT/scripts/ensemble"

Never resolve the launcher from the current working directory. Use this launcher for every Ensemble operation.

The loop

  1. Contract first — you own it. Before delegating, write/define the acceptance gate (the tests or checks that mean done). This is both the executor's target and YOUR verification oracle. Put shared rules in a repo-root AGENTS.md so the executor follows what you follow.
  2. Route by strength. Pick the executor endpoint whose strengths best fit the unit; honor role: executor|both and the latency tier. Resolve the active roster in this order: $ENSEMBLE_ROSTER; roster.json under $ENSEMBLE_DATA_DIR, $PLUGIN_DATA, or $CLAUDE_PLUGIN_DATA; then the shipped roster.json beside the launcher. Read enabled executor/both endpoints from it. Strengths may be scored category:score tags (from ensemble calibrate, e.g. injection:0.88) or plain bare tags (uncalibrated priors). Map the unit to a calibration category — a security/sanitization unit → injection; a money/rounding/currency unit → payment-logic; a perf/complexity unit → perf; a signature/type unit → type-drift; a thread/async/locking unit → concurrency; a general correctness unit → bugs — and prefer the executor with the highest <category>:<score>; treat a bare tag as a weaker prior than any scored tag, and an absent tag as no signal. State why you routed where you did. --endpoint id / --strength tag override your judgment.
  3. Delegate one unit. Run the engine — it creates an isolated worktree, runs the executor write-enabled in it, and returns a JSON result; the worktree is LEFT in place:
    "$ENSEMBLE" delegate run --endpoint <id> --prompt-file <TASK>
    
    Result: {endpoint, status, signal, worktree, branch, files_changed, diff_stat, digest}. The executor's writes are isolated to worktree; read the digest (===DIGEST=== trailer: files / decisions / context) and diff_stat, not raw output.
  4. Verify in a clean state — the trust boundary. Re-run the acceptance gate inside the worktree from a pristine checkout/deps. Executors have been measured patching their own environment to fake a pass — never trust the executor's self-reported success. Inspect the diff for scope creep (the worktree contains the expected writes; codex is OS-sandboxed to it, the others rely on cwd — confirm the change is on-task).
  5. Merge or reroute.
    • pass → "$ENSEMBLE" delegate merge --worktree <worktree> [--message "..."] (commits + merges the unit, removes the worktree).
    • fail → "$ENSEMBLE" delegate discard --worktree <worktree> then: retry with more context, reroute to another executor, or implement it yourself.
  6. Optional sign-off. Before merging a risky unit, send the worktree diff through ensemble review (strength-routed implementation → multi-model review).

Rules

  • One isolated unit per delegation. Decompose larger work and delegate units independently (parallel-safe — each gets its own worktree).
  • You verify, always. Step 4 is non-negotiable; a digest saying "tests pass" is a claim, not evidence.
  • Structured failures, not prose. signal is quota|auth|timeout|missing|failed|empty (exit 10/11/12/13/2/3) — reroute/retry on it instead of scraping output.
  • Complete the handoff. Collect the executor result, verify it, and merge or discard it in the same workflow; do not assume the delegated CLI will provide a later interactive turn.
  • Containment. The worktree is the boundary for expected writes. Codex uses its workspace-write OS sandbox. Claude uses its native fail-closed Bash sandbox with unsandboxed escape disabled, plus project-scoped file permissions. The remaining executors rely on cwd, their permission controls, and worktree isolation and could in principle write elsewhere — the clean-state verify + diff inspection is your backstop.

Surface provenance. The engine prints a ▶/◀ line per dispatch (cli/model/family); when you report results, name the cli/model/family that produced each verdict/output (and, for delegate, the routing reason) so the user always knows which model did what. Set ENSEMBLE_PROVENANCE=0 to silence the lines.

Keep looking

Skills are one crate of 608,475. Ordering is by how many stacks a row turns up in, so the top of any crate is what has actually been picked rather than what has the most stars.