@bluewombat/conductor 0.8.0 → 0.10.0

package/README.md

@@ -1,6 +1,6 @@
 # Conductor
 
-Kernel package, not a Transformer: sequences Transformers for one FeatureStandard. It
+Kernel package, not a Transformer: sequences Transformers for one TicketStandard. It
 writes the WorkLedger before it acts. Isolated workspaces are a consequence of
 that state.
 
@@ -30,9 +30,9 @@ npm install
 | Build     | `npm run build`  |
 
 There is no CLI in this implementation. The caller injects a WorkLedger and a
-Transformer Port (Isolation, Breakdown, Implementer, Integration).
+Transformer Port (Isolation, Implementer, Integration).
 
-**Optional Authority.** When injected, Conductor offers the assembled feature
+**Optional Authority.** When injected, Conductor offers the assembled ticket
 and does not fold it into WorkLineStable itself. See [SPECS.md](./SPECS.md) §8.
 
 ```ts

package/SPECS.md

@@ -1,10 +1,10 @@
 # Conductor
 
 Not a Transformer. It has many operations, not one IN and one OUT.
-It sequences other people's jobs: WorkLedger commands, Isolation, Breakdown,
-Implementer, Integration. It does not store FeatureStandards, does not isolate a
-directory, does not split a Plan, does not run a Builder, does not fold a Child,
-and does not report to a FeatureManager.
+It sequences other people's jobs: WorkLedger commands, Isolation, Implementer,
+Integration. It does not store TicketStandards, does not isolate a directory,
+does not run a Builder, does not fold a Child, and does not report to a
+TicketTracker.
 
 Conductor writes the WorkLedger **before** it acts. Isolated workspaces are a
 consequence of that state, never the source of it.
@@ -15,7 +15,7 @@ consequence of that state, never the source of it.
   caller                         Conductor                         others
   ------                         ---------                         ------
   run a Project                  check pause, reconcile            WorkLedger
-                                 claim or resume                   isolate / breakDown
+                                 claim or resume                   isolate
                                  write ledger, then act            implement / integrate
                              ←   idle | done | escalated | paused | refused
 ```
@@ -35,9 +35,9 @@ same functions.
 | Import       | `openConductor({ ledger, transformers, workLineStable, workspaceRoot })` | Import a Transformer package from `src/run/`           |
 | Transformers | A value that implements the Transformer Port                             | Live under `src/run/` as a concrete Transformer import |
 
-The caller builds the transformers (`runIsolator`, `runBreakdown`, `runImplementer`,
-`runIntegrator`, closed over Planner / Builder / Gate argv) and passes them in.
-Conductor does not import `@bluewombat/isolator` (or the other three) from its
+The caller builds the transformers (`runIsolator`, `runImplementer`,
+`runIntegrator`, closed over Builder / Gate argv) and passes them in.
+Conductor does not import `@bluewombat/isolator` (or the other two) from its
 run loop. The composition root that wires Transformers is the caller — Host
 (`packages/host/runtime`) — or a later thin adapter in this package.
 
@@ -51,15 +51,15 @@ Transformers do not import this package. WorkLedger does not import this package
            │
            │  Transformer Port + WorkLedger
            ▼
-  transformers / ledger             injected             Isolation, Breakdown, Attempts,
+  transformers / ledger             injected             Isolation, Attempts,
                                                    Integration, durable state
 ```
 
 | Layer        | Owns                                                        | Does not own                                     |
 | ------------ | ----------------------------------------------------------- | ------------------------------------------------ |
-| Conductor    | Order of steps, pause, orphan destroy, when to call whom    | FeatureStandard transitions, git, Builder, Gates |
-| Ledger       | Legal transitions, bail, Plan freeze                        | Directories, Transformer outcomes                |
-| Transformers | One Isolation / Breakdown / Attempt loop / Integration each | WorkLedger commands, pause, claim                |
+| Conductor    | Order of steps, pause, orphan destroy, when to call whom    | TicketStandard transitions, git, Builder, Gates |
+| Ledger       | Legal transitions, bail                                     | Directories, Transformer outcomes                |
+| Transformers | One Isolation / Attempt loop / Integration each             | WorkLedger commands, pause, claim                |
 
 A caller never talks to Isolator through Conductor internals. It talks to
 `runProject`. The run loop never talks to `node:child_process`. It talks to
@@ -72,8 +72,7 @@ orphan destroy). It does not copy, merge, or create a workspace.
 Hard rules. Breaking one is a spec bug, not a refactor.
 
 1. **`src/run/` does not import a Transformer package** (`@bluewombat/isolator`,
-   `@bluewombat/implementer`, `@bluewombat/integrator`,
-   `@bluewombat/feature-breakdown`). It imports the Transformer Port type and
+   `@bluewombat/implementer`, `@bluewombat/integrator`). It imports the Transformer Port type and
    WorkLedger types. A test that fails if `run` grows those imports is part of
    this contract.
 2. **`src/run/` does not import `work-ledger` persistence adapters.** It talks
@@ -82,29 +81,21 @@ Hard rules. Breaking one is a spec bug, not a refactor.
 4. **Domain tests inject a Transformer Port and a WorkLedger.** They may use a
    test-double ledger (in the test file) and fake transformers that record call order.
    They do not require a Transformer `dist/`.
-5. **The caller, not Conductor, chooses Planner / Builder / Gate argv.** Those
+5. **The caller, not Conductor, chooses Builder / Gate argv.** Those
    slots close over the transformer functions.
 
 ## 5. Transformer Port
 
-Four operations. Real Transformers or test doubles; the Port does not care.
+Three operations. Real Transformers or test doubles; the Port does not care.
 
 | Operation   | In (minimum)                                                                                                       | Out (minimum)                                                                                       |
 | ----------- | ------------------------------------------------------------------------------------------------------------------ | --------------------------------------------------------------------------------------------------- |
 | `isolate`   | `id`, `parent`, `child` (absolute paths), `durationMs`                                                             | `isolated` / `failed` / `invalid-invocation` / `interrupted`                                        |
-| `breakDown` | FeatureStandard JSON (key, intention, optional title)                                                              | `planned` + subtasks + `planned_at`, or `refused` + code + reason, or `unavailable` / `interrupted` |
-| `implement` | `id`, intention, `workspace`, durations / attempt bound, optional definition of done, `report`, `stage`, `produce` | `validated` / `escalated` / `interrupted` / `invalid-invocation`, plus ordered Traces               |
+| `implement` | `id`, intention, `workspace`, durations / attempt bound, `report`, `stage`, `produce`                              | `validated` / `escalated` / `interrupted` / `invalid-invocation`, plus ordered Traces               |
 | `integrate` | `id`, `parent`, `child`, `durationMs`                                                                              | `integrated` / `conflict` / `failed` / `invalid-invocation` / `interrupted`                         |
 
-Conductor maps ledger fields into `breakDown` JSON. It does not reopen
-FeatureAdapter's closed shape. Recognised keys are `key`, `intention`, `title`.
-
-A Subtask carries the `definition_of_done` its Plan gave it. An assembly carries
-none: what it must meet is the Subtasks it is made of, and each was judged on its
-own.
-
-`stage` says what is being judged — one unit of work, or the feature they
-assemble into. They are not the same situation: a check that is right for one can
+`stage` says what is being judged — the unit of work, or the work once
+assembled. They are not the same situation: a check that is right for one can
 be wrong for the other. `produce` says whether the Task may make anything: a
 stage built only of already-validated work has nothing to make, and asking a
 producer to run there is how a correct result gets rewritten so a check expecting
@@ -121,7 +112,7 @@ whatever refused it — the first Gate that did not pass, or the producer's own
 detail. `ended` says an Attempt failed; `report` says why, and whoever drives the
 next one cannot invent it.
 
-`implement` Traces are Implementer's Traces. Conductor records each Subtask
+`implement` Traces are Implementer's Traces. Conductor records each unit
 Trace as a WorkLedger Attempt (`ended`, and `report` / `refusedBy` when the
 Attempt did not end well) before it decides escalate vs integrate.
 
@@ -129,33 +120,31 @@ Attempt did not end well) before it decides escalate vs integrate.
 They are not required by the Port's outcome.
 
 An optional **Authority Port** (`submit` / `fold`) is not a transformer. When the
-caller injects one, an assembled feature is offered outside instead of being
+caller injects one, an assembled ticket is offered outside instead of being
 folded into WorkLineStable by Integrator. `workLineTarget` names that work line
-for the Authority. `maxRefusals` (default 3) is how many times the Authority's
+for the Authority; a Ticket that names its own `line` is offered to that one. `maxRefusals` (default 3) is how many times the Authority's
 Gates may send the work back before Conductor escalates.
 
 ## 6. Paths
 
 Constructor: `openConductor({ ledger, transformers, workLineStable, workspaceRoot,
 transformerDurationMs?, authority?, workLineTarget?, maxRefusals?,
-assemblyValidate?, assemblyFixDeclared?, observe? })`. `assemblyValidate` says
+validate?, fixDeclared?, observe? })`. `validate` says
 whether a local judge runs after align, with or without an Authority.
-`assemblyFixDeclared` says whether a refusal has anything to repair it with; a
+`fixDeclared` says whether a refusal has anything to repair it with; a
 validate refusal escalates on the spot when it does not.
-`observe` is told, mid-pass, when the plan is recorded, when a Subtask is
-integrated (with the count), and when the work is submitted — awaited, and a
-throw from it changes nothing about the run.
+`observe` is told, mid-pass, when the work is submitted — awaited, and a throw
+from it changes nothing about the run.
 `workLineStable` and `workspaceRoot` are absolute directories. `workspaceRoot`
 must not be `workLineStable`. Conductor does not create `workLineStable`.
 
 Physical layout is this package's private choice:
 
 ```
-<workspaceRoot>/<key-segment>/feature
-<workspaceRoot>/<key-segment>/subtask-<id-segment>
+<workspaceRoot>/<key-segment>/ticket
 ```
 
-`<key-segment>` and `<id-segment>` are one safe path segment each: a name made
+`<key-segment>` is one safe path segment: a name made
 of letters, digits, `.`, `_` and `-` is kept as it is; anything else becomes a
 readable slug plus the first 8 hex digits of the SHA-256 of the original, so
 `github:tilap/site#1` is `github-tilap-site-1-<hash>` and two keys never share a
@@ -163,18 +152,14 @@ directory. There is no `%`: a workspace is where the Builder runs the
 project's own tools, and several (Vitest among them) refuse a path that looks
 URL-encoded. Conductor never uses the raw key as a directory name.
 
-**A declared path is the path.** Every step that needs the feature's workspace
-reads the one the WorkLedger declared for it and computes the layout's own only
-when none is declared, so a feature made under an earlier layout — escalated,
-then resumed — keeps its work and its branch where they are. A kept Subtask at
-an older path is destroyed with the one at the current path when it starts
-over, so its branch is free to be taken again. The Authority is handed the
-feature's workspace in `submit` (`workspace`), and works out nothing itself.
+**A declared path is the path.** Every step that needs the workspace reads the
+one the WorkLedger declared for it and computes the layout's own only when none
+is declared. A unit that starts over destroys what is at that path first, so
+its branch is free to be taken again. The Authority is handed the workspace in
+`submit` (`workspace`), and works out nothing itself.
 
 It **declares** that path on the WorkLedger, **then** calls `isolate`. After
-`integrate` of a Subtask returns `integrated`, it deletes the Subtask directory
-and `clearWorkspace` for the Subtask. After `markDone`, it deletes the feature
-directory and `clearWorkspace` for the feature.
+`markDone`, it deletes the directory and `clearWorkspace`.
 
 ## 7. Commands
 
@@ -184,97 +169,105 @@ command does not start a Transformer.
 
 | Command      | Meaning                                                                                                                                                             | Refused when                                   |
 | ------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------- |
-| `reconcile`  | `expireBail` on expired keys. Destroy directories under `workspaceRoot` that are not on `listDeclaredWorkspaces`. Delete declared Subtask dirs after expiry.        | Paths not absolute (constructor already threw) |
-| `pause`      | In-process flag: no new `claim`, no new `startSubtask`, no `markMerging` / final fold into WorkLineStable. Current `implement` / `isolate` / `integrate` may finish | —                                              |
+| `reconcile`  | `expireBail` on expired keys. Destroy directories under `workspaceRoot` that are not on `listDeclaredWorkspaces`. Delete the declared directory of a unit whose lease expired. | Paths not absolute (constructor already threw) |
+| `pause`      | In-process flag: no new `claim`, no new unit start, no `markMerging` / final fold into WorkLineStable. Current `implement` / `isolate` / `integrate` may finish | —                                              |
 | `resume`     | Clear the pause flag. Does not itself take work                                                                                                                     | —                                              |
-| `runProject` | Reconcile, then take or resume the active FeatureStandard on that Project, and drive it until a terminal or wait state                                              | `workLineStable` missing on disk               |
+| `runProject` | Reconcile, then take or resume the active TicketStandard on that Project, and drive it until a terminal or wait state                                              | `workLineStable` missing on disk               |
 | `cancel`     | `ledger.cancel(key)` then destroy declared workspaces for that key                                                                                                  | Ledger `point-of-no-return`                    |
-| `release`    | `ledger.releaseBail(key)` then destroy the declared Subtask directory when one was recorded                                                                         | Ledger `illegal-transition` / `not-found`      |
+| `release`    | `ledger.releaseBail(key)` then destroy the declared directory when one was recorded                                                                                 | Ledger `illegal-transition` / `not-found`      |
 
 `runProject` outcomes:
 
 | Outcome     | Meaning                                                                                       |
 | ----------- | --------------------------------------------------------------------------------------------- |
-| `idle`      | No `received` FeatureStandard and no active one on that Project                               |
-| `done`      | The FeatureStandard is `done` in WorkLineStable                                               |
-| `escalated` | Frozen for a human. Isolated Subtask workspace kept when a Subtask was in play                |
+| `idle`      | No `received` TicketStandard and no active one on that Project                               |
+| `done`      | The TicketStandard is `done` in WorkLineStable                                               |
+| `escalated` | Frozen for a human. The workspace is kept for inspection                                      |
 | `paused`    | Stopped at a pause boundary. Ledger holds the current state                                   |
 | `refused`   | Constructor-level or ledger refusal the loop cannot handle (`persist-failed`, missing stable) |
 
-`runProject` does **not** wait for a human `ready`. After `escalated`, the
-caller (FeatureManager path) calls `ledger.resumeReady(key)` then `runProject`
+`runProject` does **not** wait for a human `resume`. After `escalated`, the
+caller (TicketTracker path) calls `ledger.resumeTicket(key)` then `runProject`
 again.
 
 ## 8. Happy path (ledger before act)
 
-One FeatureStandard, one Project. Pause flag is off.
+One TicketStandard, one Project. Pause flag is off.
 
 1. `reconcile`.
-2. If the Project already has an active FeatureStandard, resume it. Else `claim`.
+2. If the Project already has an active TicketStandard, resume it. Else `claim`.
    Empty → `idle`.
-3. **Planning.** `breakDown`. On `planned`: `recordPlan` **before** any Isolation.
-   On `refused`: `refusePlan`, return `escalated`. On `unavailable`: return
-   `refused` with code `unavailable` (ledger stays `planning`; retryable). On
-   `interrupted`: return `refused` with code `interrupted`. On
-   `invalid-invocation`: return `refused` with code `transformer-invalid`.
-4. **Feature workspace.** `declareWorkspace({ feature })` **then** `isolate`
-   (parent = WorkLineStable, child = feature path). Failure: do not start
-   Subtasks; `runProject` returns `refused` (`isolate-failed` or `transformer-invalid`)
-   and leaves the ledger in `running` so a retry isolates again if the directory
-   is missing. If a Submission is already recorded and the feature directory is
-   gone, Conductor escalates `kind: "submitted"` rather than isolating again
-   over what the Authority was shown. When a `warm` port is configured, prepare
-   the Feature workspace next (install deps, …) before any Subtask Isolation —
-   once per Feature in this Conductor instance, and again after a fresh
-   Isolation. Failure: `refused` with `warm-failed` (or `interrupted` /
-   `transformer-invalid`); the Feature directory is kept so the next
-   `runProject` retries warm without re-isolating.
-5. **Subtask loop** while `nextRunnable` is a Subtask and pause is off:
-   1. `startSubtask`.
-   2. `declareWorkspace({ subtask })` **then** `isolate` (parent = feature path).
-   3. `implement` in that child.
-   4. For each Trace, `recordAttempt` with the next number and that Trace's
+3. **The unit.** When the ledger is `running`, no lease is held and pause is
+   off: destroy what is at the workspace path, `declareWorkspace` **then**
+   `isolate` (parent = WorkLineStable, child = the workspace). Failure: no
+   lease was taken, so `runProject` returns `refused` (`isolate-failed` or
+   `transformer-invalid`) and a retry starts the unit again. When a `warm` port
+   is configured, prepare the workspace next (install deps, …) — each time the
+   workspace is made. Failure: `refused` with `warm-failed` (or `interrupted` /
+   `transformer-invalid`). Then `startUnit` (the lease) and `implement` in that
+   workspace.
+   1. For each Trace, `recordAttempt` with the next number and that Trace's
       `ended`, plus `report` / `refusedBy` when present.
-   5. `validated` → `integrate` child into feature. `integrated` →
-      `markSubtaskIntegrated`, delete child, `clearWorkspace` subtask.
-      `conflict` → `escalate({ kind: "subtask", subtaskId })`, **keep** the child.
-   6. `escalated` from Implementer → `escalate({ kind: "subtask", subtaskId })`
-      (Trace already recorded). Keep the child. The next `startSubtask` for
-      that id **destroys** the kept Child first (resume from zero).
-   7. After a Subtask is marked integrated, if `pending_fingerprint` is set,
-      `escalate({ kind: "plan" })` with a report that says the intention was
-      edited in flight and what resume does — not that a Plan was refused,
-      which is what `kind: "plan"` reads as without it. The ledger consumes
-      the pending field. Resume of `kind: "plan"` unfreezes the Plan
-      (`resumeReady`). A newer FeatureStandard body lands by `admit` of the
-      corrected document (from `escalated` → `received`).
+   2. `validated` → `markIntegrating`. The result stays loose in the
+      workspace; the Integration in 4.3 takes it up.
+   3. `escalated` from Implementer → `escalate({ kind: "unit" })` (Trace
+      already recorded). Keep the workspace. `resumeTicket` returns the
+      Ticket to `running`, forgets the workspace, and the unit starts again from zero.
+   4. After `markIntegrating`, if `pending_fingerprint` is set,
+      `escalate({ kind: "unit" })` with a report that says the intention was
+      edited in flight and what resume does. The ledger consumes the pending
+      field. A newer TicketStandard body lands by `admit` of the corrected
+      document (from `escalated` → `received`).
+   A `running` Ticket that holds a lease is `paused`: its lease runs out on
+   its own when nobody is on it.
+4. **The workspace must still be there** from `integrating` on. When it is
+   gone, Conductor does not make it again from the work line, which would drop
+   what was made: it escalates `kind: "submitted"` when the Authority holds a
+   Submission, `kind: "assembly"` otherwise.
+5. Pause is honoured before the unit starts, after Isolation, before align and
+   before `markMerging`.
 6. When the ledger is `integrating` and pause is off:
-   1. If `pending_fingerprint` is set, escalate `kind: "plan"` as in 5.7 and
+   1. If `pending_fingerprint` is set, escalate `kind: "unit"` as in 3.4 and
       stop. Do not align.
    2. If a parked refusal or a Submission `last_report` is set (the parked one
-      wins when both are), `implement` on the feature workspace with
-      `stage: "assembly"`, `produce: true`, and that report **before** align.
+      wins when both are), `implement` on the ticket workspace with
+      `stage: "ticket"`, `produce: true`, and that report **before** align.
       `escalated` → `escalate({ kind: "assembly" })`.
-   3. **Align.** `integrate` with WorkLineStable as **child** and the feature
-      workspace as **parent**. `conflict` → return `refused` (`align-conflict`);
-      state stays `integrating`. Cancel is still allowed. Retry `runProject`
-      retries align. Do not `escalate({ kind: "merging" })` here: that would set
+   3. **Align.** `integrate` with WorkLineStable as **child** and the
+      workspace as **parent**. What is loose in the workspace is first taken up
+      as one commit whose subject is the Ticket's title (or its intention's
+      headline); after a refusal it is the repair, with its own subject. `conflict` → the work is **sent back** like any
+      refusal (see below), with a report that names the line and says what to do;
+      it is not a stop. Do not `escalate({ kind: "merging" })` here: that would set
       `born_in_merging` and block cancel before WorkLineStable is the fold parent.
-   4. **Validate**, when `assemblyValidate` is set — with or without an
-      Authority. `implement` on the feature workspace with `stage: "assembly"`
+   3b. **Recheck.** Aligning brought other tickets' code in, so the unit's own
+      Gates run again: `implement` on the ticket workspace with
+      `stage: "ticket"`, `produce: false`, `recheck: true` (one attempt; Host
+      judges it by `builder.gates`, no other list). `validated` →
+      `clearParkedRefusal`. `escalated` → sent back with the Gate's report and name.
+
+   **Sent back** (align conflict, failed recheck, `ticket.validate` refusal): with
+   `fixDeclared`, a retryable cause and budget left → `recordParkedRefusal`,
+   return `paused`; the next pass produces the fix, then aligns, rechecks and
+   validates again. Otherwise (blocking, budget spent, no fix declared) →
+   `escalate({ kind: "assembly" })`. **One budget** covers every loop of a ticket:
+   `submission.refusals + parked_refusals + submission.realigns`, against
+   `maxRefusals`.
+   4. **Validate**, when `validate` is set — with or without an
+      Authority. `implement` on the ticket workspace with `stage: "ticket"`
       and `validate: true` (no gates, one attempt). `validated` →
       `clearParkedRefusal`, then continue to 5 or 6. `escalated`, retryable,
       under `maxRefusals` (the budget shared with `submission.refusals`), and
-      `assemblyFixDeclared` → `recordParkedRefusal`, return `paused`. Do not
+      `fixDeclared` → `recordParkedRefusal`, return `paused`. Do not
       continue to 5 or 6. `escalated` otherwise (blocking, at the budget, or no
-      `assembly.fix` declared) → `escalate({ kind: "assembly" })`.
-   5. **Without an Authority.** `implement` on the feature workspace with
-      `stage: "assembly"` and `produce: false` (judgement only). `validated` →
+      `ticket.fix` declared) → `escalate({ kind: "assembly" })`.
+   5. **Without an Authority.** `implement` on the ticket workspace with
+      `stage: "ticket"` and `produce: false` (judgement only). `validated` →
       `markMerging`. `escalated` → `escalate({ kind: "assembly" })`.
-      Then **final fold**: `integrate` feature child into WorkLineStable.
-      `integrated` → `markDone`, delete feature directory, `clearWorkspace`.
-      `conflict` → `escalate({ kind: "merging" })`, keep the feature directory.
-   6. **With an Authority.** `submit` the assembled feature. `submitted` →
+      Then **final fold**: `integrate` ticket child into WorkLineStable.
+      `integrated` → `markDone`, delete ticket directory, `clearWorkspace`.
+      `conflict` → `escalate({ kind: "merging" })`, keep the ticket directory.
+   6. **With an Authority.** `submit` the assembled ticket. `submitted` →
       `markSubmitted`, return `paused`. `refused` → `escalate({ kind: "submitted" })`
       with the refusal's reason as its report — the Publisher's or the
       Authority's own words, the only record of why the offer failed.
@@ -283,28 +276,33 @@ One FeatureStandard, one Project. Pause flag is off.
       `escalate({ kind: "submitted" })`. Retryable refusal → `recordRefusal`
       (which also drops a stale parked refusal, if one is held),
       return `paused` (next pass repairs then aligns, then offers again).
-      `validated` → Authority `fold`. `folded` → `markMerging` then `markDone` (with the fold's `reference`, when the Authority named one)
+      `validated` → ask the Authority whether the line moved on (`behind`, when
+      it can say): `unavailable` → `paused`; `behind` → `recordRealign` (state
+      `integrating`, no report kept, no fix owed) and `paused`, so the next pass
+      aligns, rechecks, validates, offers again and judges again; with the budget spent →
+      `escalate({ kind: "submitted" })`; `current`, or no `behind` → Authority
+      `fold`. `folded` → `markMerging` then `markDone` (with the fold's `reference`, when the Authority named one)
       (the Authority moved the work line; Conductor does not `integrate` into
-      WorkLineStable). `conflict` → `escalate({ kind: "submitted" })`.
+      WorkLineStable). `conflict` → the same as `behind`: `recordRealign` and back to align
+      (the alignment conflicts, the fix is told); `escalate({ kind: "submitted" })` only
+      when the budget is spent.
 
 ## 9. Pause and interrupt
 
 Pause is an in-process flag on the opened conductor. It is not stored in the
-WorkLedger (pause is Conductor admission, not a FeatureStandard state).
+WorkLedger (pause is Conductor admission, not a TicketStandard state).
 
-Boundaries where pause is honoured: before `claim`, before `startSubtask`,
+Boundaries where pause is honoured: before `claim`, before the unit starts,
 before align, before `markMerging`. A running `implement` finishes.
 
 Interrupt is the Transformer Port's problem (the same `interruptFlag` the Transformers
-already take). If a transformer returns `interrupted` after `startSubtask`
-(Subtask isolate, `implement`, or fold into the feature), Conductor does not
-mark the Subtask integrated. It calls `releaseBail` — the Subtask becomes
-`runnable` from zero, the declared Subtask directory is destroyed — and
-returns `refused` with code `interrupted`. The next process resumes without
-waiting for the bail clock. Interrupt during planning, feature isolate,
-align, assembly, or a Submission judgement leaves the ledger as the last
-successful command left it: those paths resume on the next `runProject`
-without a held Subtask.
+already take). If `implement` returns `interrupted` once the lease is taken,
+Conductor does not mark the unit done. It calls `releaseBail` — the Attempt
+is spent, the declared directory is destroyed — and returns `refused` with
+code `interrupted`. The next process starts the unit again without waiting for
+the bail clock. Interrupt during Isolation, warm, align, assembly, or a
+Submission judgement leaves the ledger as the last successful command left it:
+those paths resume on the next `runProject` without a held lease.
 
 ## 10. Reconcile
 
@@ -314,10 +312,10 @@ After process start, and at the beginning of every `runProject`:
 2. Delete any directory under `workspaceRoot` whose absolute path is **not**
    on that list (orphans). Never delete `workLineStable`.
 3. `expireBail` for those declared keys, and for `activeOn(project)` when that
-   FeatureStandard's bail is past expiry. Then delete a Subtask directory if
+   TicketStandard's bail is past expiry. Then delete the unit's directory if
    the ledger cleared it.
 
-The ledger decides Feature state. Disk never does. Conductor does not scan
+The ledger decides Ticket state. Disk never does. Conductor does not scan
 every Project; `runProject` reconciles the workspaces on disk plus the Project
 it was asked to run.
 
@@ -329,11 +327,9 @@ it was asked to run.
 | `root-invalid`        | `workspaceRoot` is not absolute, or equals `workLineStable`      |
 | `persist-failed`      | A ledger command returned `persist-failed`                       |
 | `interrupted`         | A transformer returned `interrupted`                             |
-| `isolate-failed`      | Feature Isolation did not return `isolated`                      |
-| `warm-failed`         | Feature warm (when configured) did not return `warmed`           |
-| `align-conflict`      | Align Integration returned `conflict`; state stays `integrating` |
+| `isolate-failed`      | Isolation did not return `isolated`                              |
+| `warm-failed`         | Warm (when configured) did not return `warmed`                   |
 | `transformer-invalid` | A transformer returned `invalid-invocation`                      |
-| `unavailable`         | `breakDown` returned `unavailable` (Planner did not answer)      |
 
 Ledger codes (`project-busy`, `point-of-no-return`, …) pass through on `cancel`
 and when `claim` refuses.
@@ -344,28 +340,28 @@ Shipped:
 
 - Import face, `openConductor({ ledger, transformers, workLineStable, workspaceRoot })`
 - Optional Authority (`submit` / `fold`), `workLineTarget`, `maxRefusals`
-- Optional local `assemblyValidate`, before offer or the local judge, with or
+- Optional local `validate`, before offer or the local judge, with or
   without an Authority. Its refusal is parked on the aggregate and shares the
-  `maxRefusals` budget; `assemblyFixDeclared` says whether it escalates on the
+  `maxRefusals` budget; `fixDeclared` says whether it escalates on the
   spot instead
 - `reconcile`, `pause`, `resume`, `runProject`, `cancel`, `release`
 - Happy path: align, assembly judgement (`produce: false`), `markMerging`, final fold
 - Authority path: offer, judge, `recordRefusal` / fold, no Integrator fold into WorkLineStable
-- `pending_fingerprint` consumed after a Subtask integrates and when entering `integrating`
+- `pending_fingerprint` consumed when the unit ends and when entering `integrating`
 - Ledger-before-act, declared workspaces, orphan destroy
 - Isolation tests in §4
 - Pause boundaries
 
 Not shipped:
 
-- FeatureListener / FeatureAdapter / FeatureEmitter (the caller wires them
+- Listener / Adapter / Emitter (the caller wires them
   through a manager package; Host's suite is the first such assembly)
 - CLI
 - Persistent pause across processes
-- A human `ready` daemon (caller invokes `resumeReady` then `runProject`)
+- A human `resume` daemon (caller invokes `resumeTicket` then `runProject`)
 - SQLite, a second workspace layout
-- Consuming `pending_fingerprint` while the Feature is `submitted` (admit stores
-  it; the next Subtask integrate / integrating entry is what consumes it)
+- Consuming `pending_fingerprint` while the Ticket is `submitted` (admit stores
+  it; the next unit end / integrating entry is what consumes it)
 
 ## 13. Layout
 
@@ -380,51 +376,71 @@ src/
 
 ## 14. Acceptance
 
-1. `runProject` on a Project with one `received` FeatureStandard calls `claim`
-   then `breakDown` then `recordPlan` **before** any `isolate`.
-2. `declareWorkspace` for the feature path is recorded **before** `isolate` of
-   that path. Same for a Subtask path.
-3. Fake transformers, one Subtask, all `validated` / `integrated`, no Authority:
-   Feature ends `done`; `isolate` was called twice (feature, then Subtask);
-   `integrate` was called three times (Subtask fold, align, final fold);
-   assembly `implement` ran once on the feature workspace with `produce: false`.
-4. `breakDown` `refused` → `refusePlan`; no `isolate`; outcome `escalated`.
-5. `implement` `escalated` after Traces → each Trace is `recordAttempt`d;
-   then `escalate`; no Subtask `integrate`; child directory not deleted by
-   Conductor.
-6. Subtask `integrate` `conflict` → `escalate`; child kept.
-7. `cancel` of a `running` Feature → ledger `cancelled`; declared directories
+1. `runProject` on a Project with one `received` TicketStandard calls `claim`
+   then `isolate` then `implement`, and the workspace path is declared **before**
+   `isolate`.
+2. Fake transformers, all `validated` / `integrated`, no Authority: Ticket ends
+   `done`; `isolate` was called once; `integrate` was called twice (align, final
+   fold); `implement` ran twice — the unit, then the assembly judgement with
+   `produce: false`.
+3. A failed Isolation → `refused` (`isolate-failed`); no lease, no Attempt, no
+   `implement`.
+4. `implement` `escalated` after Traces → each Trace is `recordAttempt`d;
+   then `escalate({ kind: "unit" })`; no `integrate`; the directory is not
+   deleted by Conductor. After `resumeTicket` the unit starts from a fresh
+   workspace.
+4a. A Ticket whose admission says `no_tests` (the tracker's label, carried beside its
+   words) has no stage before its producer: no `implement` for the tests, no checkpoint,
+   and `first_stage_done` is never set. Everything else about the unit is the same.
+4b. `implement` `interrupted` (the process was stopped) → the Attempts that
+   finished are `recordAttempt`d (the interrupted one is not an Attempt), then
+   `releaseBail`: no Attempt is spent, the workspace stays declared and on disk.
+   The next pass over the Ticket finds a declared workspace that still holds
+   something and picks it up: no `isolate`, no second `warm`; the stage made
+   before the producer (the tests) is not made again when the ledger says it is
+   done; `implement` is given `firstAttempt` (the Attempts already recorded this
+   round, plus one) and, as `report`, the refusal of the last Attempt, or a
+   note that the pass before was stopped and left its work there. A declared
+   workspace that is gone or empty starts the unit from zero. `release` is the
+   way to start over: it drops the bail, destroys the directory and forgets it.
+   Conductor does not look inside the workspace, nor at the line it was cut
+   from: a Project that cannot pick up a stale one uses `release`.
+5. `cancel` of a `running` Ticket → ledger `cancelled`; declared directories
    destroyed. `cancel` after `markMerging` → ledger `point-of-no-return`;
    WorkLineStable untouched.
-8. A directory under `workspaceRoot` that is not declared is gone after
+6. A directory under `workspaceRoot` that is not declared is gone after
    `reconcile`. `workLineStable` is never deleted.
-9. `pause` after `recordPlan` and feature isolate, before the first
-   `startSubtask` → outcome `paused`; no `startSubtask`.
+7. `pause` after Isolation, before the unit starts → outcome `paused`; no
+   `implement`.
+8. `implement` `interrupted` → lease released, directory destroyed, `refused`
+   (`interrupted`).
+9. A workspace that is gone while the Authority holds a Submission → escalated
+   `kind: "submitted"`, and no second Isolation.
 10. `src/run/` has no import of `@bluewombat/isolator`, `@bluewombat/implementer`,
-    `@bluewombat/integrator`, or `@bluewombat/feature-breakdown`.
+    or `@bluewombat/integrator`.
 11. Opening Conductor with a Transformer Port test double and a WorkLedger test
     double still passes 1–9. No Transformer `dist/` and no filesystem persist are
     required for those.
 
-Gap, named: align `conflict` leaves `integrating` (`align-conflict`) rather than
-a first-class ledger kind. Do not hide that. A later WorkLedger command can
-close it. Assembly `escalated` uses `escalate({ kind: "assembly" })`;
-`resumeReady` returns that Feature to `integrating`.
+An align `conflict` is not a stop: it is sent back to the fix like a refusal
+(`recordParkedRefusal`), so no ledger kind is needed for it. Assembly `escalated` uses `escalate({ kind: "assembly" })`;
+`resumeTicket` returns that Ticket to `integrating`; a `unit` escalation returns
+it to `running`.
 
 ## 15. Choices
 
 1. **Not a Transformer.** Sequencing many verbs is not Implementer-shaped.
-2. **Injected Transformer Port.** Depending on four Transformer packages would make the
+2. **Injected Transformer Port.** Depending on three Transformer packages would make the
    run loop untestable without `dist/` and would freeze Isolation strategy
    inside Conductor. The caller wires Transformers.
 3. **Injected WorkLedger.** Conductor does not open persist. Glue already chose
    the adapter.
 4. **Ledger before act, always.** Directories that exist without a declaration
    are orphans and die.
-5. **No Emitter in this package.** Reporting is FeatureEmitter. Conductor
+5. **No Emitter in this package.** Reporting is Emitter. Conductor
    returns a result; the caller reports.
-6. **Pause is in-process.** A FeatureStandard state for pause would confuse
-   `escalated` and `ready`. Restart clears pause; reconcile + bail remain.
+6. **Pause is in-process.** A TicketStandard state for pause would confuse
+   `escalated` and `resume`. Restart clears pause; reconcile + bail remain.
 7. **Stack: TypeScript on Node.js 24.20, Biome, `node:test` run through `tsx`.**
    Same as WorkLedger. Recorded here; commands live in this package's README.
 

package/dist/index.d.ts

@@ -1,5 +1,7 @@
-export type { Conductor, ConductorMoment, ConductorRefusalCode, OpenConductorOptions, ProjectRunResult, WarmOutcome, WarmPort, } from "./run/open-conductor.js";
+export type { Delivery, DeliveryOptions, DeliveryRead, DeliveryStore, DeliveryUnit, } from "./run/delivery.js";
+export { openDelivery, reasonOfTraces } from "./run/delivery.js";
+export type { Conductor, ConductorMoment, ConductorRefusalCode, LinePort, OpenConductorOptions, ProjectRunResult, WarmOutcome, WarmPort, } from "./run/open-conductor.js";
 export { foldMessageOf, openConductor, subjectOf } from "./run/open-conductor.js";
-export { featureWorkspacePath, subtaskWorkspacePath } from "./run/paths.js";
-export type { AuthorityFoldResult, AuthorityPort, BreakDownResult, ImplementResult, SubmitInput, SubmitResult, TransformerPort, } from "./transformers/port.js";
+export { pathSegment, ticketWorkspacePath } from "./run/paths.js";
+export type { AuthorityBehindResult, AuthorityFoldResult, AuthorityPort, ImplementResult, SubmitInput, SubmitResult, TransformerPort, } from "./transformers/port.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,YAAY,EACV,SAAS,EACT,eAAe,EACf,oBAAoB,EACpB,oBAAoB,EACpB,gBAAgB,EAChB,WAAW,EACX,QAAQ,GACT,MAAM,yBAAyB,CAAC;AACjC,OAAO,EAAE,aAAa,EAAE,aAAa,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAC;AAClF,OAAO,EAAE,oBAAoB,EAAE,oBAAoB,EAAE,MAAM,gBAAgB,CAAC;AAC5E,YAAY,EACV,mBAAmB,EACnB,aAAa,EACb,eAAe,EACf,eAAe,EACf,WAAW,EACX,YAAY,EACZ,eAAe,GAChB,MAAM,wBAAwB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,YAAY,EACV,QAAQ,EACR,eAAe,EACf,YAAY,EACZ,aAAa,EACb,YAAY,GACb,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EAAE,YAAY,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AACjE,YAAY,EACV,SAAS,EACT,eAAe,EACf,oBAAoB,EACpB,QAAQ,EACR,oBAAoB,EACpB,gBAAgB,EAChB,WAAW,EACX,QAAQ,GACT,MAAM,yBAAyB,CAAC;AACjC,OAAO,EAAE,aAAa,EAAE,aAAa,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAC;AAClF,OAAO,EAAE,WAAW,EAAE,mBAAmB,EAAE,MAAM,gBAAgB,CAAC;AAClE,YAAY,EACV,qBAAqB,EACrB,mBAAmB,EACnB,aAAa,EACb,eAAe,EACf,WAAW,EACX,YAAY,EACZ,eAAe,GAChB,MAAM,wBAAwB,CAAC"}

package/dist/index.js

@@ -1,3 +1,4 @@
+export { openDelivery, reasonOfTraces } from "./run/delivery.js";
 export { foldMessageOf, openConductor, subjectOf } from "./run/open-conductor.js";
-export { featureWorkspacePath, subtaskWorkspacePath } from "./run/paths.js";
+export { pathSegment, ticketWorkspacePath } from "./run/paths.js";
 //# sourceMappingURL=index.js.map