@bluewombat/slots 0.8.0 → 0.9.0

package/README.md

@@ -1,11 +1,9 @@
 # Slots
 
-The Planner, Builder, and Gate commands that ship with mason. A Project points
+The Builder, Gate, and publishing commands that ship with mason. A Project points
 its config at one of these paths; nothing here is imported.
 
 ```yaml
-planner:
-  cmd: [node, ./node_modules/@bluewombat/slots/planners/one-subtask.mjs]
 builder:
   producer:
     cmd:
@@ -52,7 +50,6 @@ these all use it. How Host wires a slot into a run:
   - [The rules](#the-rules)
   - [Transcripts](#transcripts)
 - [Gates](#gates)
-- [Planners](#planners)
 
 ## Catalogue
 
@@ -60,21 +57,19 @@ these all use it. How Host wires a slot into a run:
 | ----------------------------- | --------- | ------------------------------------------------------------------------------------------ |
 | `agents/cursor.mjs`           | Agent     | Runs Cursor CLI with a filled prompt                                                       |
 | `agents/claude.mjs`           | Agent     | Runs Claude Code with a filled prompt                                                      |
-| `builders/producer.mjs`       | Builder   | First pass of a Subtask: fill `{{task}}`, then spawn the agent                             |
-| `builders/repair.mjs`         | Builder   | A Gate refused the Subtask: fill `{{task}}` and `{{report}}`                               |
-| `assembly/fix.mjs`            | Builder   | A judgement refused the assembled feature: fill `{{task}}` and `{{report}}`                |
-| `assembly/validate.mjs`       | Builder   | Read-only review of the assembled feature: fill `{{task}}`; answers `MASON_VERDICT: VALIDATED` or `MASON_VERDICT: REFUSED: …` |
+| `builders/producer.mjs`       | Builder   | First pass of the unit of work: fill `{{task}}`, then spawn the agent                             |
+| `builders/repair.mjs`         | Builder   | A Gate refused the unit: fill `{{task}}` and `{{report}}`                               |
+| `assembly/fix.mjs`            | Builder   | A judgement refused the assembled work: fill `{{task}}` and `{{report}}`                |
+| `assembly/validate.mjs`       | Builder   | Read-only review of the assembled work: fill `{{task}}`; answers `MASON_VERDICT: VALIDATED` or `MASON_VERDICT: REFUSED: …` |
 | `gates/workspace-changed.mjs` | Gate      | The Attempt left an uncommitted change                                                     |
 | `gates/parent-clean.mjs`      | Gate      | Isolator's Parent working files did not move                                               |
 | `gates/sensitive-path.mjs`    | Gate      | No path matching a glob was touched                                                        |
-| `gates/gitignore-leak.mjs`    | Gate      | The feature's commits add nothing its own `.gitignore` excludes                            |
+| `gates/gitignore-leak.mjs`    | Gate      | The ticket's commits add nothing its own `.gitignore` excludes                            |
 | `gates/ci-green.mjs`          | Gate      | The work line's own checks came back green                                                 |
-| `planners/one-subtask.mjs`    | Planner   | Bootstrap: one Subtask that is the FeatureStandard itself                                  |
-| `publishers/git.mjs`          | Publisher | Pushes the feature's branch to the work line's own remote                                  |
+| `publishers/git.mjs`          | Publisher | Pushes the ticket's branch to the work line's own remote                                  |
 | `refreshers/git.mjs`          | Refresher | Fast-forwards the work line copy onto what the Authority holds                             |
-| `planners/producer.mjs`       | Planner   | An agent CLI splits the FeatureStandard                                                    |
-| `messages/conventional.mjs`   | Message   | `<type>: <title>` for the feature's fold, no agent; `--scope`, `--type`                    |
-| `messages/git-producer.mjs`   | Describer | An agent reads the git diff and writes the feature's subject and body under `--rules-file` |
+| `messages/conventional.mjs`   | Message   | `<type>: <title>` for the ticket's fold, no agent; `--scope`, `--type`                    |
+| `messages/git-producer.mjs`   | Describer | An agent reads the git diff and writes the ticket's subject and body under `--rules-file` |
 
 ## Agents
 
@@ -237,18 +232,16 @@ builder:
 ```
 
 A path that names a file next to the config resolves against the config; any
-other relative path resolves inside the Subtask workspace, so a template
+other relative path resolves inside the workspace, so a template
 committed in the Project travels with it.
 
 Each role owns a closed set. An unknown name, or a required name the template
-never places, is `fail-blocking`. `{{done_when}}` is `Done when:` plus the
-definition of done, and vanishes whole when there is none — which is every
-assembly, so `assembly/fix` does not fill it at all.
+never places, is `fail-blocking`.
 
 | Role                | Required                              | Also fills                                                 |
 | ------------------- | ------------------------------------- | ---------------------------------------------------------- |
-| `builders/producer` | `{{task}}`, `{{rules}}`               | `{{history}}`, `{{done_when}}`, `{{id}}`, `{{attempt}}`    |
-| `builders/repair`   | `{{task}}`, `{{report}}`, `{{rules}}` | `{{history}}`, `{{refused_by}}`, `{{done_when}}`, `{{id}}`, `{{attempt}}` |
+| `builders/producer` | `{{task}}`, `{{rules}}`               | `{{history}}`, `{{id}}`, `{{attempt}}`                     |
+| `builders/repair`   | `{{task}}`, `{{report}}`, `{{rules}}` | `{{history}}`, `{{refused_by}}`, `{{id}}`, `{{attempt}}`    |
 | `assembly/fix`      | `{{task}}`, `{{report}}`, `{{rules}}` | `{{history}}`, `{{refused_by}}`, `{{id}}`, `{{attempt}}`   |
 | `assembly/validate` | `{{task}}`, `{{rules}}`               | `{{id}}`, `{{attempt}}`                                    |
 
@@ -258,7 +251,7 @@ belongs to the repair command. A repair or fix command without `--report` is the
 `{{history}}` is what the Task went through before this Attempt, oldest first (the
 refusal it came with, each Attempt, each Gate's answer; see Implementer's SPECS §
 History). It is empty on a first Attempt and vanishes whole then, so a template
-that does not place it works as before.
+that does not place it simply omits it.
 
 ### The way out
 
@@ -285,10 +278,9 @@ a run spent on nothing. A command that arrives with a report and no
 
 ### The fix prompt
 
-A judgement of the assembled feature that refused it is not a Subtask retry.
-The units already passed. `assembly/fix.mjs` tells the agent to change what the
-refusal names and leave the rest. Same placeholders as repair except
-`{{done_when}}`, which an assembly has nothing to fill.
+A judgement of the assembled work that refused it is not a retry of the unit.
+The unit already passed. `assembly/fix.mjs` tells the agent to change what the
+refusal names and leave the rest. Same placeholders as repair.
 
 ### The validate prompt
 
@@ -319,7 +311,7 @@ nothing pushed. A producing template must place it — one that leaves it out is
 Gates are what says no, which is slower, reaches the tracker, and spends a run.
 
 `--rules-file` replaces them with the Project's own. The last three are not a
-matter of taste: the Gates read the working tree of the Subtask directory, so an
+matter of taste: the Gates read the working tree of the workspace, so an
 agent that commits, stashes or writes elsewhere leaves them nothing to see and
 the pass is refused for having done nothing. Replacing the rules does not lift
 that; it only stops saying it out loud.
@@ -335,7 +327,7 @@ loop that misbehaves cannot be read back, only guessed at.
 as sent, stdout, stderr, how long it took, and — when the agent wrapper passed
 them — `skills`, `usage` and what the tools did (`unknown`, `(none)`, or the
 values). Files are
-filed under the Feature the Task belongs to, named for the Subtask and the
+filed under the Ticket the Task belongs to, named for the Subtask and the
 Attempt. It belongs on the **agent** command, after `--`.
 
 ```yaml
@@ -404,15 +396,15 @@ the workspace — tracked paths, and new ones `.gitignore` does not exclude —
 what an install left under an ignored directory (a dependency's own `.github/`)
 is not a change to guard.
 
-`gitignore-leak --base REF` fail-retries if the feature's commits add a path the
+`gitignore-leak --base REF` fail-retries if the ticket's commits add a path the
 workspace's own `.gitignore` excludes — a Builder's `node_modules/`, a build's
-`dist/`, a generated file. `REF` is the work line the feature is offered to
-(`main`): only what the feature adds since it left that line is judged, and
-only what is committed, so a path tracked on purpose before the feature began
+`dist/`, a generated file. `REF` is the work line the ticket is offered to
+(`main`): only what the ticket adds since it left that line is judged, and
+only what is committed, so a path tracked on purpose before the ticket began
 is not blamed on it, and a removal staged but not committed does not pass. The
 report is written for `assembly.fix`: untrack the paths, or change `.gitignore`
 if tracking one is the point. It passes at `--stage unit`, where no commit
-holds a Subtask's work yet.
+holds a the unit's work yet.
 
 It is a second line, not the first: the `isolation-git` fold already keeps an
 ignored path out of the commits it makes. It catches a leak that came some
@@ -464,47 +456,11 @@ without the other.
 is what Isolator makes when WorkLineStable is a git tree. They fail-block on a
 workspace Isolator had to copy.
 
-## Planners
-
-`one-subtask.mjs` is the bootstrap Planner: one Subtask that is the
-FeatureStandard itself. It is what `mason init` writes into a fresh config, and
-it takes no option.
-
-`planners/producer.mjs` hands the split to an agent CLI. It reads the project
-before answering and writes nothing into it. `--prompt-file` and `--read` belong
-on the role; the vendor is named after `--`, the same way a Builder names it.
-
-```yaml
-planner:
-  cmd:
-    - node
-    - ./node_modules/@bluewombat/slots/planners/producer.mjs
-    - --read
-    - ./work-line-stable
-    - --
-    - node
-    - ./node_modules/@bluewombat/slots/agents/cursor.mjs
-  timeoutMs: 600000
-```
-
-| Option               | Meaning                                                       |
-| -------------------- | ------------------------------------------------------------- |
-| `--read PATH`        | The project the agent may read before splitting. Default: cwd |
-| `--prompt-file PATH` | Prompt template. Must place `{{intention}}` and `{{out}}`     |
-
-`--bin`, `--model`, `--transcript-dir` and `--agent-arg` are the agent's, after
-`--`. Optional placeholder: `{{max_units}}`.
-
-A Plan it cannot use — a cycle, a dangling dependency, more Subtasks than
-`--max-units` — is this slot's own failure: it exits non-zero so the Breakdown is
-retried. A FeatureStandard that cannot be split is a refusal on stdout, which
-is a verdict on the intention instead.
-
 ## Publishers
 
-The slot that puts an assembled feature where the Authority can read it. It runs
+The slot that puts an assembled ticket where the Authority can read it. It runs
 **in the work line**, and mason appends `--id`, `--ref` — the name Isolator gave
-the feature — and `--target`, the work line it is offered to.
+the ticket — and `--target`, the work line it is offered to.
 
 `git.mjs` pushes that name to the work line's own remote. A plain push, no force
 of any kind: Integrator only ever adds history, so republishing after a refusal
@@ -519,12 +475,12 @@ read another. It comes back when that half is a slot too.
 The answer is one JSON object on stdout, like every slot:
 
 ```json
-{ "ref": "issue/feature-42" }
+{ "ref": "issue/ticket-42" }
 { "outcome": "refused", "reason": "the remote rejected the push" }
 ```
 
 The reference is opaque above this line — a branch, a directory, a URL. Whatever
-the Publisher answers is what the FeatureManager is told to judge, so a Project
+the Publisher answers is what the TicketTracker is told to judge, so a Project
 that places its work some other way writes its own Publisher and changes nothing
 else. A refusal stops the Submission and travels back to the tracker; a slot that
 could not run at all exits non-zero and says why on stderr.
@@ -582,12 +538,11 @@ type in JSDoc.
 ```
 README.md      this file
 agents/        vendor CLIs: filled prompt in, serialized run out
-builders/      first-pass and repair roles for a Subtask
-assembly/      the same two roles for the assembled feature
+builders/      first-pass and repair roles for the unit of work
+assembly/      the same two roles for the assembled work
 lib/           what the shipped templates say, shared by the roles
 gates/         checks on the workspace, and on the work line
-planners/      FeatureStandard in, a Plan out
 messages/      what a commit says: a rule, or an agent under the team's guideline
 test/          one suite per kind; each spawns the real command
-fixtures/      fake agent CLIs the Builder and Planner suites run against
+fixtures/      fake agent CLIs the Builder suites run against
 ```

package/assembly/fix.mjs

@@ -19,9 +19,9 @@ const NAME = "assembly fix";
 
 const DEFAULT_TEMPLATE = `You are a coding agent working unattended in a checkout of the project.
 
-This directory is the assembled feature. The units of work that made it have
-already been validated. An earlier judgement of the whole refused it. Do not
-redo those units. Fix what the refusal names.
+This directory is the assembled work. It passed the checks made on the unit
+itself. An earlier judgement of the whole refused it. Do not redo the work.
+Fix what the refusal names.
 
 Refused by: {{refused_by}}
 

package/assembly/validate.mjs

@@ -19,11 +19,11 @@ const NAME = "assembly validate";
 
 const DEFAULT_TEMPLATE = `You are a coding agent working unattended in a checkout of the project.
 
-This directory is the assembled feature. Every unit of work that makes it up
-has already been validated on its own. Your job now is different: read the
-diff this feature carries against the work line it will land on, and judge
-whether the WHOLE meets what was asked. Do not redo the units. Do not change
-anything — this is a read-only review, not a repair.
+This directory is the assembled work. It has already passed the checks made on
+the unit itself. Your job now is different: read the diff it carries against
+the work line it will land on, and judge whether the WHOLE meets what was
+asked. Do not redo the work. Do not change anything — this is a
+read-only review, not a repair.
 
 ## What was asked
 
@@ -34,7 +34,7 @@ anything — this is a read-only review, not a repair.
 End your final message with exactly one line in this form, and nothing after
 it:
 
-- \`MASON_VERDICT: VALIDATED\` — the assembled feature meets what was asked.
+- \`MASON_VERDICT: VALIDATED\` — the assembled ticket meets what was asked.
 - \`MASON_VERDICT: REFUSED: <one paragraph>\` — it does not, and the paragraph
   says what is wrong, specifically enough for another agent to fix it without
   redoing your review. Keep the whole paragraph on that one line.
@@ -162,7 +162,7 @@ function answer(run, bin, name) {
       "fail-retryable",
       why.length > 0
         ? why
-        : "assembly.validate refused the assembled feature, with no reason given.",
+        : "assembly.validate refused the assembled ticket, with no reason given.",
     );
     process.exit(1);
   }

package/builders/producer.mjs

@@ -13,7 +13,7 @@ import {
   textOption,
   transcriptArgs,
 } from "@bluewombat/slot-kit";
-import { attemptOf, doneWhen } from "../lib/fill.mjs";
+import { attemptOf } from "../lib/fill.mjs";
 
 const NAME = "builder producer";
 
@@ -22,11 +22,8 @@ const DEFAULT_TEMPLATE = `You are a coding agent working unattended in a checkou
 Task:
 {{task}}
 
-{{done_when}}
-
-This checkout already includes any earlier subtasks that were folded into the
-feature. Do not rewrite that work. Add or change only what this task names, and
-leave the project's own checks green on the whole tree.
+This checkout is the project as it stands. Add or change only what this task
+names, and leave the project's own checks green on the whole tree.
 
 {{history}}
 
@@ -82,7 +79,6 @@ const rendered = fillPrompt(
   {
     task: intention,
     history: (take(process.argv, "--history") ?? "").trim(),
-    done_when: doneWhen(take(process.argv, "--definition-of-done")),
     rules: rules.value.trim(),
     id: take(process.argv, "--id") ?? "",
     attempt: String(attemptOf(process.argv)),

package/builders/repair.mjs

@@ -13,7 +13,7 @@ import {
   textOption,
   transcriptArgs,
 } from "@bluewombat/slot-kit";
-import { attemptOf, doneWhen } from "../lib/fill.mjs";
+import { attemptOf } from "../lib/fill.mjs";
 
 const NAME = "builder repair";
 
@@ -38,8 +38,6 @@ This was asked in the first place, and still holds:
 
 {{task}}
 
-{{done_when}}
-
 {{history}}
 
 ## When you cannot act
@@ -96,7 +94,6 @@ const rendered = fillPrompt(
     report,
     refused_by:
       refusedBy.length > 0 ? refusedBy : "the producer of the last attempt, which did not finish",
-    done_when: doneWhen(take(process.argv, "--definition-of-done")),
     rules: rules.value.trim(),
     id: take(process.argv, "--id") ?? "",
     attempt: String(attemptOf(process.argv)),

package/gates/gitignore-leak.mjs

@@ -2,17 +2,17 @@
 import { spawnSync } from "node:child_process";
 import { emitVerdict, GATE_FLAGS, ownArgv, stageOf } from "@bluewombat/slot-kit";
 
-// Fail-retryable when the feature's commits add a path the workspace's own
+// Fail-retryable when the ticket's commits add a path the workspace's own
 // .gitignore excludes — a Builder's node_modules/, a build's dist/, a generated
 // file — so it would ship in the Submission.
 //
-// --base REF (required): the work line the feature is offered to. Only what the
-// feature adds since it left that line is judged, in what is committed: a path
-// tracked on purpose before the feature began is not this feature's leak, and
+// --base REF (required): the work line the ticket is offered to. Only what the
+// ticket adds since it left that line is judged, in what is committed: a path
+// tracked on purpose before the ticket began is not this ticket's leak, and
 // a removal staged but not committed has not removed anything yet.
 //
-// A unit only: nothing. A Subtask's work is uncommitted until a fold records it,
-// so there is no commit of its own here to judge.
+// A unit only: nothing. The work is uncommitted until a fold records it, so
+// there is no commit of its own here to judge.
 
 const cwd = process.cwd();
 const tokens = ownArgv(process.argv, GATE_FLAGS);
@@ -37,7 +37,7 @@ for (let i = 0; i < tokens.length; i++) {
 if (base === undefined) {
   emitVerdict(
     "fail-blocking",
-    "gitignore-leak needs --base <ref>: the work line the feature is offered to.",
+    "gitignore-leak needs --base <ref>: the work line the ticket is offered to.",
   );
   process.exit(0);
 }
@@ -105,7 +105,7 @@ emitVerdict(
   [
     `These paths are committed on top of ${base}, and this workspace's .gitignore excludes them.`,
     "Take them out of the commit with git rm -r --cached <path> and keep the files. If the",
-    "feature does mean to track one, change .gitignore so it no longer excludes it:",
+    "ticket does mean to track one, change .gitignore so it no longer excludes it:",
     ...shown,
     ...(rest > 0 ? [`… and ${rest} more`] : []),
   ].join("\n"),

package/lib/fill.mjs

@@ -4,12 +4,6 @@
  */
 import { take } from "@bluewombat/slot-kit";
 
-/** @param {string | undefined} raw */
-export function doneWhen(raw) {
-  const done = (raw ?? "").trim();
-  return done.length > 0 ? `Done when:\n${done}` : "";
-}
-
 /** @param {readonly string[]} argv */
 export function attemptOf(argv) {
   const parsed = Number.parseInt(take(argv, "--attempt") ?? "", 10);

package/messages/conventional.mjs

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import { emitMessage, MESSAGE_FLAGS, ownArgv, take, writeDiagnostic } from "@bluewombat/slot-kit";
 
-// The feature's commit in the Conventional Commits shape, from the issue's
+// The ticket's commit in the Conventional Commits shape, from the issue's
 // title and body and with no agent: `<type>: <title>`, the body as written.
 //
 // The type is read off the title's first word — a Project that wants a

package/messages/git-producer.mjs

@@ -16,9 +16,9 @@ import {
   writeDiagnostic,
 } from "@bluewombat/slot-kit";
 
-// The feature's commit message — and the pull request's description with it
+// The ticket's commit message — and the pull request's description with it
 // — written by an agent that read the diff, under the Project's own rules.
-// Asked once per feature. A role slot like the builders: it fills a template
+// Asked once per ticket. A role slot like the builders: it fills a template
 // and hands it to the agent after `--`; the agent answers in a file this slot
 // reads back. `--prompt-file` replaces the template, `--rules-file` the rules
 // — that is where a team's commit guideline goes.

package/package.json

@@ -1,14 +1,13 @@
 {
   "name": "@bluewombat/slots",
-  "version": "0.8.0",
+  "version": "0.9.0",
   "type": "module",
-  "description": "Shipped mason slots: Planners, Builders, Gates, publishers, and refreshers a Project names in its config.",
+  "description": "Shipped mason slots: Builders, Gates, publishers, and refreshers a Project names in its config.",
   "keywords": [
     "mason",
     "bluewombat",
     "gate",
-    "builder",
-    "planner"
+    "builder"
   ],
   "license": "MIT",
   "homepage": "https://github.com/tilap/bluewombat/tree/main/packages/plugins/slots#readme",
@@ -19,7 +18,6 @@
     "directory": "packages/plugins/slots"
   },
   "exports": {
-    "./planners/*": "./planners/*",
     "./builders/*": "./builders/*",
     "./assembly/*": "./assembly/*",
     "./agents/*": "./agents/*",
@@ -29,7 +27,6 @@
     "./messages/*": "./messages/*"
   },
   "files": [
-    "planners",
     "builders",
     "assembly",
     "agents",
@@ -53,7 +50,7 @@
     "test": "tsx --test $(find test -name '*.test.ts')"
   },
   "dependencies": {
-    "@bluewombat/slot-kit": "^0.8.0",
+    "@bluewombat/slot-kit": "^0.9.0",
     "@pinkpuma/deck": "1.0.0"
   }
 }

package/publishers/git.mjs

@@ -11,7 +11,7 @@ import {
   writeDiagnostic,
 } from "@bluewombat/slot-kit";
 
-// Put the feature's work where the Authority can read it, by pushing the name
+// Put the ticket's work where the Authority can read it, by pushing the name
 // Isolator gave it to the work line's own remote.
 //
 // A plain push, and no force of any kind. Integrator only ever adds history, so

package/refreshers/git.mjs

@@ -16,6 +16,9 @@ import {
 // would make the next Isolation start from a version that no longer exists, so
 // this runs before anything else in a pass.
 //
+// The copy moves onto the target line first: a Feature's Tickets are cut from
+// and folded into that Feature's line, not the final branch.
+//
 // Fast-forward only: this system never rewrites that line. A copy that cannot
 // fast-forward has been written to by somebody else, and that is a person's
 // problem, not a merge to attempt.
@@ -41,7 +44,8 @@ if (!existsSync(join(cwd, ".git"))) {
   process.exit(0);
 }
 
-const fetched = git(["fetch", "origin", target]);
+// An explicit refspec: a single-branch clone only knows its own branch.
+const fetched = git(["fetch", "origin", `+refs/heads/${target}:refs/remotes/origin/${target}`]);
 if (fetched.status !== 0) {
   emitRefreshRefusal(
     `Cannot fetch origin/${target} from ${cwd}: ${fetched.stderr.trim().slice(-500)}`,
@@ -49,6 +53,18 @@ if (fetched.status !== 0) {
   process.exit(0);
 }
 
+const current = git(["symbolic-ref", "--short", "HEAD"]);
+if (current.status !== 0 || current.stdout.trim() !== target) {
+  const exists = git(["rev-parse", "--verify", "--quiet", `refs/heads/${target}`]).status === 0;
+  const switched = git(
+    exists ? ["checkout", target] : ["checkout", "-b", target, `origin/${target}`],
+  );
+  if (switched.status !== 0) {
+    emitRefreshRefusal(`Cannot move ${cwd} onto ${target}: ${switched.stderr.trim().slice(-500)}`);
+    process.exit(0);
+  }
+}
+
 const merged = git(["merge", "--ff-only", `origin/${target}`]);
 if (merged.status !== 0) {
   // The one way a copy stops fast-forwarding is a commit made into it that

package/planners/one-subtask.mjs

@@ -1,21 +0,0 @@
-#!/usr/bin/env node
-/**
- * Bootstrap Planner: one Subtask that is the FeatureStandard itself.
- * FeatureBreakdown appends --intention, --key, --max-units.
- */
-import { emitPlan, emitRefusal, take } from "@bluewombat/slot-kit";
-
-const intention = (take(process.argv, "--intention") ?? "").trim();
-if (intention.length === 0) {
-  emitRefusal("The FeatureStandard has no intention to turn into a Subtask.");
-  process.exit(0);
-}
-
-emitPlan([
-  {
-    id: "A",
-    intention,
-    definition_of_done: "The intention is realized in the workspace.",
-    depends_on: [],
-  },
-]);

package/planners/producer.mjs

@@ -1,233 +0,0 @@
-#!/usr/bin/env node
-import { mkdtempSync, readFileSync, rmSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import {
-  checkPlan,
-  emitPlan,
-  emitRefusal,
-  fillPrompt,
-  loadPrompt,
-  PLANNER_FLAGS,
-  parseRole,
-  spawnFilled,
-  take,
-  textOption,
-  transcriptArgs,
-  writeDiagnostic,
-} from "@bluewombat/slot-kit";
-
-const NAME = "planner producer";
-
-const DEFAULT_TEMPLATE = `You are splitting one piece of work into an ordered list of subtasks.
-
-You are not writing any of it. Do not modify anything in this directory. Read as
-much of it as you need first: the split has to fit the project as it is. Do not
-invent conventions you can discover from the repository.
-
-The work:
-{{intention}}
-
-Treat that as the source of truth for the desired outcome, not as a finished
-specification. Its wording may be incomplete. Separate what it explicitly
-requires from what the repository or ordinary engineering practice implies.
-Do not invent requirements to make the plan look complete.
-
-How the subtasks will be run, which is what makes a good split:
-
-- One at a time, never in parallel. Each runs in its own copy of this project,
-  and its result is folded back before the next one starts. So a later subtask
-  sees the earlier ones' work. If two slices would both change the same path
-  (a README, an index or barrel file, a changelog, package.json, or any other
-  shared file), make them **one** subtask, or give the second a \`depends_on\` on
-  the first and let **only** that second one write the shared path. Do not invent
-  a docs-only subtask unless the work asked for documentation.
-- Every subtask is checked by the project's own checks — its tests, its lint —
-  on its own. **A subtask must leave the project working.** This is the rule that
-  decides your split: never cut by layer. "Add the types", then "add the code",
-  then "add the tests" is wrong, because the first two leave the project broken.
-  Cut by thin slices that each work end to end. Tests belong in the subtask that
-  introduces or changes the behavior they verify.
-- Each subtask is given to an agent with no memory of you and no memory of the
-  others. Its intention has to stand alone: no "as discussed above", no knowledge
-  of this planning process, no requirement that lives only in the original work
-  description. Copy into the subtask everything its agent needs. A pointer at
-  existing code is fine if it names the behavior or location clearly enough to
-  investigate.
-- Write each intention the way a good commit message is written: one headline
-  of at most 72 characters in the imperative ("Add titleCase in
-  src/title-case.js"), a blank line, then everything the agent needs. The
-  headline is what people see: in the plan on the tracker, in the change list
-  of the submission, on the commit.
-- Its definition of done has to be checkable by someone who cannot read your
-  mind, and preferably by a test. It describes this subtask's observable result,
-  not the whole feature and not an intention.
-- \`depends_on\` means "cannot start before this one is done", and nothing else.
-  Sharing a file is a reason not to start side by side: pack those slices into
-  one subtask, or make the later one depend on the earlier. The graph describes
-  what must land before a merge is safe, not the order you happened to think in.
-  Chaining every subtask to the one before it when their files do not overlap
-  hides which ones were actually independent.
-
-You are choosing between two costs, and both are real.
-
-Splitting too finely costs a full agent run per slice, and each slice pays the
-project's whole check sequence again. Do not create a subtask solely to read
-code, decide what to implement, create folders, rename things, add comments,
-write documentation (unless the work asked for it), clean up, or refactor
-speculatively.
-
-Not splitting enough costs more, and less visibly. One subtask is one agent run,
-with one budget of attempts and one clock: a subtask too large for that exhausts
-them and the whole piece of work stops. And a subtask that fails goes back to
-nothing, while a subtask that succeeded is never redone. Ten modules in one
-subtask means ten modules redone when the tenth goes wrong.
-
-Prefer adapting what the project already does over introducing a parallel
-mechanism. Do not propose an architectural change merely because it might be
-cleaner.
-
-So: as few subtasks as the work allows, and none larger than what one competent
-engineer would finish in a single sitting without losing the thread. At most
-{{max_units}}.
-
-Write your answer as JSON, and nothing else, to this file:
-
-{{out}}
-
-It looks like this:
-
-{
-  "subtasks": [
-    { "id": "s1", "intention": "Headline\\n\\nEverything the agent needs.", "definition_of_done": "...", "depends_on": [] },
-    { "id": "s2", "intention": "Headline\\n\\n...", "definition_of_done": "...", "depends_on": ["s1"] }
-  ]
-}
-
-If the work cannot be split as it is written — contradictory outcomes, a
-critical requirement so ambiguous that the implementation would change with
-the reading, or too little to determine what should be built — write this
-instead, and do not invent a plan to fill the silence. Do not refuse merely
-because some implementation details are unspecified; those come from the
-repository.
-
-{ "outcome": "refused", "reason": "..." }
-`;
-
-const intention = (take(process.argv, "--intention") ?? "").trim();
-if (intention.length === 0) {
-  fail("The Planner received no --intention.");
-}
-
-const parsed = parseRole(process.argv, PLANNER_FLAGS, NAME, { "--read": {} });
-if (!parsed.ok) {
-  fail(parsed.reason);
-}
-
-const template = loadPrompt(parsed.options, DEFAULT_TEMPLATE);
-if (!template.ok) {
-  fail(template.reason);
-}
-
-const maxUnits = Number.parseInt(take(process.argv, "--max-units") ?? "", 10);
-const scratch = mkdtempSync(join(tmpdir(), "plan-"));
-const out = join(scratch, "plan.json");
-const cwd = textOption(parsed.options, "read") ?? process.cwd();
-
-try {
-  const rendered = fillPrompt(
-    template.value,
-    {
-      intention,
-      max_units: Number.isInteger(maxUnits) ? String(maxUnits) : "a handful",
-      out,
-    },
-    ["intention", "out"],
-    textOption(parsed.options, "promptFile") ?? "built-in template",
-  );
-  if (!rendered.ok) {
-    fail(rendered.reason);
-  }
-
-  const spawned = await spawnFilled(
-    parsed.runner,
-    rendered.prompt,
-    transcriptArgs(process.argv, {
-      id: "breakdown",
-      context: take(process.argv, "--key"),
-    }),
-    cwd,
-  );
-  if (!spawned.ok) {
-    fail(spawned.reason);
-  }
-  if (spawned.run.error !== undefined) {
-    fail(`Could not start the agent at ${spawned.about.bin}: ${spawned.run.error.message}`);
-  }
-
-  const answer = readAnswer(out);
-  if (answer === undefined) {
-    fail(`The agent wrote no usable plan to ${out}. ${tail(spawned.run.output)}`);
-  }
-  if (answer.outcome === "refused") {
-    const reason =
-      typeof answer.reason === "string" && answer.reason.trim().length > 0
-        ? answer.reason.trim()
-        : "The Planner refused without saying why.";
-    emitRefusal(reason);
-    process.exit(0);
-  }
-
-  const checked = checkPlan(answer.subtasks, maxUnits);
-  if (!checked.ok) {
-    fail(`The agent returned a plan that cannot be used: ${checked.reason}`);
-  }
-  emitPlan(
-    checked.subtasks.map((subtask) => ({
-      id: subtask.id,
-      intention: subtask.intention,
-      definition_of_done: subtask.definition_of_done,
-      depends_on: subtask.depends_on,
-    })),
-  );
-  process.exit(0);
-} finally {
-  rmSync(scratch, { recursive: true, force: true });
-}
-
-/** @param {string} path @returns {Record<string, unknown> | undefined} */
-function readAnswer(path) {
-  let text;
-  try {
-    text = readFileSync(path, "utf8");
-  } catch {
-    return undefined;
-  }
-  const fenced = /```(?:json)?\s*([\s\S]*?)```/.exec(text);
-  for (const candidate of [fenced?.[1], text]) {
-    if (candidate === undefined) {
-      continue;
-    }
-    try {
-      const value = JSON.parse(candidate);
-      if (value !== null && typeof value === "object") {
-        return value;
-      }
-    } catch {
-      // try the next reading
-    }
-  }
-  return undefined;
-}
-
-/** @param {string | undefined} output */
-function tail(output) {
-  const trimmed = (output ?? "").trim();
-  return trimmed.length === 0 ? "" : trimmed.slice(-1000);
-}
-
-/** @param {string} reason @returns {never} */
-function fail(reason) {
-  writeDiagnostic(`${reason}\n`);
-  process.exit(1);
-}