@crafts69guy/orchestra 0.3.0 → 0.4.0

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "orch",
-  "version": "0.3.0",
+  "version": "0.4.0",
   "description": "Orchestrator workflow: scope, implement, review, ship via specialised subagents and worktrees.",
   "author": {
     "name": "crafts69guy"

package/.codex-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "orch",
-  "version": "0.3.0",
+  "version": "0.4.0",
   "description": "Orchestrator workflow: scope, implement, review, ship via specialised subagents and worktrees.",
   "author": {
     "name": "crafts69guy",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@crafts69guy/orchestra",
-  "version": "0.3.0",
+  "version": "0.4.0",
   "type": "module",
   "description": "Cross-harness (Claude Code + Codex) orchestration workflow plugin",
   "license": "MIT",
@@ -46,7 +46,8 @@
     "gen:codex": "node scripts/gen-codex-agents.mjs",
     "check": "npm run lint && npm run gen:codex -- --check && npm test",
     "validate": "claude plugin validate .",
-    "eval": "sh evals/_support/run.sh"
+    "eval": "sh evals/_support/run.sh",
+    "eval:bench": "sh evals/_support/bench.sh"
   },
   "devDependencies": {
     "@biomejs/biome": "2.5.15",

package/rules/orchestrator.md

@@ -10,7 +10,8 @@ Subagents: `scoper`, `implementer`, `reviewer`, `shipper`. On Claude Code call t
 - **Scoping:** run `scoper` first on non-trivial work in unfamiliar code, unless you expect to read 3 or fewer new files. Spot-check its brief.
 - **Implementation:** delegate to `implementer` when the change spans 2+ files, adds or fixes tests, or needs more than one edit-and-test cycle.
 - **Planning:** for work with 2+ separable parts, use the `plan` skill to write `.scratch/<feature>/plan.md` before implementing.
-- **Parallel:** when a plan has 2+ tasks with no `depends_on` between them and disjoint `files`, use the `dispatch` skill without asking, even when each task is small. Never run two writers on the same checkout.
+- **Parallel:** use the `dispatch` skill without asking when a plan has 2+ independent tasks (no `depends_on` path, disjoint `files`) that are each substantial: its own module or feature needing several edit-and-test cycles, roughly 100+ changed lines. Independent small tasks go to one `implementer` as a single batched task, done in order, not to dispatch. Never run two writers on the same checkout.
+  Measured: dispatch was no faster on 4 tiny modules (115 s vs 118 s, +45% cost) and 21% faster on 3 large ones (+22% cost).
 - **Review:** review every implementer diff yourself and rerun its validation. Use `reviewer` (fresh context: diff, brief, acceptance criteria) for risky changes (security, concurrency, migrations, public APIs) or on request. At most 2 fix rounds.
 - **Shipping:** delegate commit, push and PR to `shipper` only after review passes and the user asked to ship.
 - **Stays with you:** scope, architecture, cross-cutting decisions, root-cause analysis, merge conflicts, escalations.

package/scripts/orch-wt.mjs

@@ -1,5 +1,5 @@
 import { spawnSync } from 'node:child_process';
-import { appendFileSync, existsSync, mkdirSync } from 'node:fs';
+import { appendFileSync, existsSync, mkdirSync, rmdirSync } from 'node:fs';
 import { resolve } from 'node:path';
 import { parseArgs } from 'node:util';
 
@@ -122,9 +122,12 @@ export function merge(deps, cwd, feature, task, message, yes) {
   }
   if (tree.status !== 0) return fail(task, tree.stderr);
 
+  const yesArg = yes ? ['--yes'] : [];
+  // --no-remove: wt's own cleanup runs in the background and returns before the directory is
+  // gone (or never finishes when the caller's sandbox kills it), so remove in the foreground below.
   const r = deps.exec(
     'wt',
-    ['-C', path, 'merge', feature, '--no-commit', ...(yes ? ['--yes'] : [])],
+    ['-C', path, 'merge', feature, '--no-commit', '--no-remove', ...yesArg],
     cwd,
   );
   if (r.status !== 0) {
@@ -135,6 +138,17 @@ export function merge(deps, cwd, feature, task, message, yes) {
     return { code: 2, result: { status: 'conflict', task, files } };
   }
   const commit = git(deps, cwd, 'rev-parse', feature).stdout.trim();
+  const left = `merged as ${commit}, but ${path} is left`;
+  // -D: wt judges "merged" against the default branch, but the branch is now in `feature`.
+  const rm = deps.exec('wt', ['remove', branch, '--foreground', '-D', ...yesArg], cwd);
+  if (rm.status !== 0) return fail(task, `${left}: ${rm.stderr}`);
+  if (deps.exists(path)) {
+    try {
+      deps.rmdir(path); // only an empty leftover: rmdir refuses a non-empty directory
+    } catch (e) {
+      return fail(task, `${left}: ${e.message}`);
+    }
+  }
   return { code: 0, result: { status: 'merged', task, commit } };
 }
 
@@ -164,5 +178,6 @@ export const realDeps = {
   exec,
   exists: existsSync,
   mkdir: (p) => mkdirSync(p, { recursive: true }),
+  rmdir: rmdirSync,
   append: appendFileSync,
 };

package/skills/dispatch/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: dispatch
-description: "orch workflow: run independent tasks from .scratch/<feature>/plan.md in parallel, one implementer per git worktree (worktrunk), then merge them into the feature branch one at a time."
+description: "orch workflow: run independent substantial tasks from .scratch/<feature>/plan.md in parallel, one implementer per git worktree (worktrunk), then merge them into the feature branch one at a time."
 ---
 
 # Dispatch
@@ -21,8 +21,10 @@ absolute path. Use that path where the plugin's `bin/` is not on `PATH` (Codex).
 
 ## Each wave
 
-1. **Pick** the ready tasks: all `depends_on` merged, `files` disjoint. At most
-   4 per wave; queue the rest.
+1. **Pick** the ready `substantial` tasks: all `depends_on` merged, `files`
+   disjoint. At most 4 per wave; queue the rest. `small` tasks are never
+   dispatched: run them as one batched implementer task on `F`, before any wave
+   that depends on them.
 2. **Create** worktrees: `orch wt new <F> <T1> <T2> …` → JSON list of
    `{task, branch, path}`.
 3. **Spawn** one implementer per task, all in the **same message** so they run

package/skills/plan/SKILL.md

@@ -32,6 +32,7 @@ Base branch: <F>   # the branch the tasks merge into
   goal: <one sentence, observable outcome>
   files: [<paths this task owns>]
   depends_on: []
+  size: small        # or substantial (rule below)
   validate: <command that proves this task works>
   decisions: [<task-specific choices>]
 ```
@@ -43,14 +44,20 @@ Base branch: <F>   # the branch the tasks merge into
   share a file. If they must, add a `depends_on` edge or merge the tasks.
 - Shared files that everyone touches (lockfiles, barrel exports, registries) go
   to one task that the others depend on.
-- Each task is 1 implementer-sized unit: one edit-and-test loop, not a project.
+- Each task is 1 implementer-sized unit (one module or feature), not a project.
+- `size` is `substantial` when the task is its own module or feature needing
+  several edit-and-test cycles, roughly 100+ changed lines; otherwise `small`.
 - `validate` runs inside the task's own worktree and must not need other
   unmerged tasks.
 - Don't split one feature into many tiny tasks. Separate features stay separate
-  tasks, even when each one is small.
+  tasks (each can land as its own commit), but small ones are batched, not
+  dispatched (below).
 
 ## After writing
 
-Show the user the task table (id, goal, depends_on) in a few lines. If 2+ tasks
-are independent, continue with the `dispatch` skill; otherwise run implementers
-one at a time.
+Show the user the task table (id, goal, size, depends_on) in a few lines. If 2+
+independent tasks are `substantial`, continue with the `dispatch` skill for
+them. Batch the `small` tasks into one implementer task (all of them, in order,
+on the feature branch); run the rest (a lone or dependent substantial task) with
+its own implementer, one at a time. Parallel worktrees only pay off when each
+task is substantial.